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 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 "langhooks.h"
66 #include "cfglayout.h"
68 #include "hosthooks.h"
71 #include "opts-diagnostic.h"
73 #include "value-prof.h"
74 #include "alloc-pool.h"
75 #include "tree-mudflap.h"
76 #include "tree-pass.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 /* Name of top-level original source file (what was input to cpp).
120 This comes from the #-command at the beginning of the actual input.
121 If there isn't any there, then this is the cc1 input file name. */
123 const char *main_input_filename;
125 /* Pointer to base name in main_input_filename, with directories and a
126 single final extension removed, and the length of this base
128 const char *main_input_basename;
129 int main_input_baselength;
131 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
132 to optimize in process_options (). */
133 #define AUTODETECT_VALUE 2
135 /* Debug hooks - dependent upon command line options. */
137 const struct gcc_debug_hooks *debug_hooks;
139 /* True if this is the lto front end. This is used to disable
140 gimple generation and lowering passes that are normally run on the
141 output of a front end. These passes must be bypassed for lto since
142 they have already been done before the gimple was written. */
144 bool in_lto_p = false;
146 /* The FUNCTION_DECL for the function currently being compiled,
147 or 0 if between functions. */
148 tree current_function_decl;
150 /* Set to the FUNC_BEGIN label of the current function, or NULL
152 const char * current_function_func_begin_label;
154 /* A random sequence of characters, unless overridden by user. */
155 static const char *flag_random_seed;
157 /* A local time stamp derived from the time of compilation. It will be
158 zero if the system cannot provide a time. It will be -1u, if the
159 user has specified a particular random seed. */
164 /* Generate code for GNU or NeXT Objective-C runtime environment. */
166 #ifdef NEXT_OBJC_RUNTIME
167 int flag_next_runtime = 1;
169 int flag_next_runtime = 0;
172 /* Nonzero means make permerror produce warnings instead of errors. */
174 int flag_permissive = 0;
176 /* When non-NULL, indicates that whenever space is allocated on the
177 stack, the resulting stack pointer must not pass this
178 address---that is, for stacks that grow downward, the stack pointer
179 must always be greater than or equal to this address; for stacks
180 that grow upward, the stack pointer must be less than this address.
181 At present, the rtx may be either a REG or a SYMBOL_REF, although
182 the support provided depends on the backend. */
185 /* Type of stack check. */
186 enum stack_check_type flag_stack_check = NO_STACK_CHECK;
188 /* True if the user has tagged the function with the 'section'
191 bool user_defined_section_attribute = false;
193 struct target_flag_state default_target_flag_state;
194 #if SWITCHABLE_TARGET
195 struct target_flag_state *this_target_flag_state = &default_target_flag_state;
197 #define this_target_flag_state (&default_target_flag_state)
202 const char *const string;
206 lang_independent_options;
208 /* The user symbol prefix after having resolved same. */
209 const char *user_label_prefix;
211 static const param_info lang_independent_params[] = {
212 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
213 { OPTION, DEFAULT, MIN, MAX, HELP },
214 #include "params.def"
216 { NULL, 0, 0, 0, NULL }
219 /* Output files for assembler code (real compiler output)
220 and debugging dumps. */
224 FILE *stack_usage_file = NULL;
225 FILE *dump_file = NULL;
226 const char *dump_file_name;
228 /* The current working directory of a translation. It's generally the
229 directory from which compilation was initiated, but a preprocessed
230 file may specify the original directory in which it was
233 static const char *src_pwd;
235 /* Initialize src_pwd with the given string, and return true. If it
236 was already initialized, return false. As a special case, it may
237 be called with a NULL argument to test whether src_pwd has NOT been
241 set_src_pwd (const char *pwd)
245 if (strcmp (src_pwd, pwd) == 0)
251 src_pwd = xstrdup (pwd);
255 /* Return the directory from which the translation unit was initiated,
256 in case set_src_pwd() was not called before to assign it a
272 /* Called when the start of a function definition is parsed,
273 this function prints on stderr the name of the function. */
275 announce_function (tree decl)
279 if (rtl_dump_and_exit)
280 fprintf (stderr, "%s ",
281 identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl))));
283 fprintf (stderr, " %s",
284 identifier_to_locale (lang_hooks.decl_printable_name (decl, 2)));
286 pp_needs_newline (global_dc->printer) = true;
287 diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
291 /* Initialize local_tick with the time of day, or -1 if
292 flag_random_seed is set. */
295 init_local_tick (void)
297 if (!flag_random_seed)
299 /* Get some more or less random data. */
300 #ifdef HAVE_GETTIMEOFDAY
304 gettimeofday (&tv, NULL);
305 local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
309 time_t now = time (NULL);
311 if (now != (time_t)-1)
312 local_tick = (unsigned) now;
320 /* Set up a default flag_random_seed and local_tick, unless the user
321 already specified one. Must be called after init_local_tick. */
324 init_random_seed (void)
326 unsigned HOST_WIDE_INT value;
327 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
329 value = local_tick ^ getpid ();
331 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
332 flag_random_seed = random_seed;
335 /* Obtain the random_seed string. Unless NOINIT, initialize it if
336 it's not provided in the command line. */
339 get_random_seed (bool noinit)
341 if (!flag_random_seed && !noinit)
343 return flag_random_seed;
346 /* Modify the random_seed string to VAL. Return its previous
350 set_random_seed (const char *val)
352 const char *old = flag_random_seed;
353 flag_random_seed = val;
357 #if GCC_VERSION < 3004
359 /* The functions clz_hwi, ctz_hwi, ffs_hwi, floor_log2 and exact_log2
360 are defined as inline functions in toplev.h if GCC_VERSION >= 3004.
361 The definitions here are used for older versions of gcc. */
363 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
364 If X is 0, return -1. */
367 floor_log2 (unsigned HOST_WIDE_INT x)
374 if (HOST_BITS_PER_WIDE_INT > 64)
375 if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
377 if (HOST_BITS_PER_WIDE_INT > 32)
378 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 32))
380 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 16))
382 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 8))
384 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 4))
386 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 2))
388 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
394 /* Return the logarithm of X, base 2, considering X unsigned,
395 if X is a power of 2. Otherwise, returns -1. */
398 exact_log2 (unsigned HOST_WIDE_INT x)
402 return floor_log2 (x);
405 /* Given X, an unsigned number, return the number of least significant bits
406 that are zero. When X == 0, the result is the word size. */
409 ctz_hwi (unsigned HOST_WIDE_INT x)
411 return x ? floor_log2 (x & -x) : HOST_BITS_PER_WIDE_INT;
414 /* Similarly for most significant bits. */
417 clz_hwi (unsigned HOST_WIDE_INT x)
419 return HOST_BITS_PER_WIDE_INT - 1 - floor_log2(x);
422 /* Similar to ctz_hwi, except that the least significant bit is numbered
423 starting from 1, and X == 0 yields 0. */
426 ffs_hwi (unsigned HOST_WIDE_INT x)
428 return 1 + floor_log2 (x & -x);
431 #endif /* GCC_VERSION < 3004 */
433 /* Handler for fatal signals, such as SIGSEGV. These are transformed
434 into ICE messages, which is much more user friendly. In case the
435 error printer crashes, reset the signal to prevent infinite recursion. */
438 crash_signal (int signo)
440 signal (signo, SIG_DFL);
442 /* If we crashed while processing an ASM statement, then be a little more
443 graceful. It's most likely the user's fault. */
444 if (this_is_asm_operands)
446 output_operand_lossage ("unrecoverable error");
447 exit (FATAL_EXIT_CODE);
450 internal_error ("%s", strsignal (signo));
453 /* Output a quoted string. */
456 output_quoted_string (FILE *asm_file, const char *string)
458 #ifdef OUTPUT_QUOTED_STRING
459 OUTPUT_QUOTED_STRING (asm_file, string);
463 putc ('\"', asm_file);
464 while ((c = *string++) != 0)
468 if (c == '\"' || c == '\\')
469 putc ('\\', asm_file);
473 fprintf (asm_file, "\\%03o", (unsigned char) c);
475 putc ('\"', asm_file);
479 /* A subroutine of wrapup_global_declarations. We've come to the end of
480 the compilation unit. All deferred variables should be undeferred,
481 and all incomplete decls should be finalized. */
484 wrapup_global_declaration_1 (tree decl)
486 /* We're not deferring this any longer. Assignment is conditional to
487 avoid needlessly dirtying PCH pages. */
488 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
489 && DECL_DEFER_OUTPUT (decl) != 0)
490 DECL_DEFER_OUTPUT (decl) = 0;
492 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
493 lang_hooks.finish_incomplete_decl (decl);
496 /* A subroutine of wrapup_global_declarations. Decide whether or not DECL
497 needs to be output. Return true if it is output. */
500 wrapup_global_declaration_2 (tree decl)
502 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
505 /* Don't write out static consts, unless we still need them.
507 We also keep static consts if not optimizing (for debugging),
508 unless the user specified -fno-keep-static-consts.
509 ??? They might be better written into the debug information.
510 This is possible when using DWARF.
512 A language processor that wants static constants to be always
513 written out (even if it is not used) is responsible for
514 calling rest_of_decl_compilation itself. E.g. the C front-end
515 calls rest_of_decl_compilation from finish_decl.
516 One motivation for this is that is conventional in some
517 environments to write things like:
518 static const char rcsid[] = "... version string ...";
519 intending to force the string to be in the executable.
521 A language processor that would prefer to have unneeded
522 static constants "optimized away" would just defer writing
523 them out until here. E.g. C++ does this, because static
524 constants are often defined in header files.
526 ??? A tempting alternative (for both C and C++) would be
527 to force a constant to be written if and only if it is
528 defined in a main file, as opposed to an include file. */
530 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
532 struct varpool_node *node;
534 node = varpool_get_node (decl);
536 if (!node && flag_ltrans)
538 else if (node && node->finalized)
540 else if (node && node->alias)
542 else if (!cgraph_global_info_ready
544 || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
546 else if (node && node->needed)
548 else if (DECL_COMDAT (decl))
550 else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
551 && (optimize || !flag_keep_static_consts
552 || DECL_ARTIFICIAL (decl)))
557 rest_of_decl_compilation (decl, 1, 1);
565 /* Do any final processing required for the declarations in VEC, of
566 which there are LEN. We write out inline functions and variables
567 that have been deferred until this point, but which are required.
568 Returns nonzero if anything was put out. */
571 wrapup_global_declarations (tree *vec, int len)
573 bool reconsider, output_something = false;
576 for (i = 0; i < len; i++)
577 wrapup_global_declaration_1 (vec[i]);
579 /* Now emit any global variables or functions that we have been
580 putting off. We need to loop in case one of the things emitted
581 here references another one which comes earlier in the list. */
585 for (i = 0; i < len; i++)
586 reconsider |= wrapup_global_declaration_2 (vec[i]);
588 output_something = true;
592 return output_something;
595 /* A subroutine of check_global_declarations. Issue appropriate warnings
596 for the global declaration DECL. */
599 check_global_declaration_1 (tree decl)
601 /* Warn about any function declared static but not defined. We don't
602 warn about variables, because many programs have static variables
603 that exist only to get some text into the object file. */
604 if (TREE_CODE (decl) == FUNCTION_DECL
605 && DECL_INITIAL (decl) == 0
606 && DECL_EXTERNAL (decl)
607 && ! DECL_ARTIFICIAL (decl)
608 && ! TREE_NO_WARNING (decl)
609 && ! TREE_PUBLIC (decl)
610 && (warn_unused_function
611 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
613 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
614 pedwarn (input_location, 0, "%q+F used but never defined", decl);
616 warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl);
617 /* This symbol is effectively an "extern" declaration now. */
618 TREE_PUBLIC (decl) = 1;
619 assemble_external (decl);
622 /* Warn about static fns or vars defined but not used. */
623 if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
624 /* We don't warn about "static const" variables because the
625 "rcs_id" idiom uses that construction. */
626 || (warn_unused_variable
627 && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
628 && ! DECL_IN_SYSTEM_HEADER (decl)
629 && ! TREE_USED (decl)
630 /* The TREE_USED bit for file-scope decls is kept in the identifier,
631 to handle multiple external decls in different scopes. */
632 && ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl)))
633 && ! DECL_EXTERNAL (decl)
634 && ! TREE_PUBLIC (decl)
635 /* A volatile variable might be used in some non-obvious way. */
636 && ! TREE_THIS_VOLATILE (decl)
637 /* Global register variables must be declared to reserve them. */
638 && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
639 /* Otherwise, ask the language. */
640 && lang_hooks.decls.warn_unused_global (decl))
641 warning ((TREE_CODE (decl) == FUNCTION_DECL)
642 ? OPT_Wunused_function
643 : OPT_Wunused_variable,
644 "%q+D defined but not used", decl);
647 /* Issue appropriate warnings for the global declarations in VEC (of
648 which there are LEN). */
651 check_global_declarations (tree *vec, int len)
655 for (i = 0; i < len; i++)
656 check_global_declaration_1 (vec[i]);
659 /* Emit debugging information for all global declarations in VEC. */
662 emit_debug_global_declarations (tree *vec, int len)
666 /* Avoid confusing the debug information machinery when there are errors. */
670 timevar_push (TV_SYMOUT);
671 for (i = 0; i < len; i++)
672 debug_hooks->global_decl (vec[i]);
673 timevar_pop (TV_SYMOUT);
676 /* Warn about a use of an identifier which was marked deprecated. */
678 warn_deprecated_use (tree node, tree attr)
682 if (node == 0 || !warn_deprecated_decl)
688 attr = DECL_ATTRIBUTES (node);
689 else if (TYPE_P (node))
691 tree decl = TYPE_STUB_DECL (node);
693 attr = lookup_attribute ("deprecated",
694 TYPE_ATTRIBUTES (TREE_TYPE (decl)));
699 attr = lookup_attribute ("deprecated", attr);
702 msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
708 expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
710 warning (OPT_Wdeprecated_declarations,
711 "%qD is deprecated (declared at %s:%d): %s",
712 node, xloc.file, xloc.line, msg);
714 warning (OPT_Wdeprecated_declarations,
715 "%qD is deprecated (declared at %s:%d)",
716 node, xloc.file, xloc.line);
718 else if (TYPE_P (node))
720 tree what = NULL_TREE;
721 tree decl = TYPE_STUB_DECL (node);
723 if (TYPE_NAME (node))
725 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
726 what = TYPE_NAME (node);
727 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
728 && DECL_NAME (TYPE_NAME (node)))
729 what = DECL_NAME (TYPE_NAME (node));
734 expanded_location xloc
735 = expand_location (DECL_SOURCE_LOCATION (decl));
739 warning (OPT_Wdeprecated_declarations,
740 "%qE is deprecated (declared at %s:%d): %s",
741 what, xloc.file, xloc.line, msg);
743 warning (OPT_Wdeprecated_declarations,
744 "%qE is deprecated (declared at %s:%d)", what,
745 xloc.file, xloc.line);
750 warning (OPT_Wdeprecated_declarations,
751 "type is deprecated (declared at %s:%d): %s",
752 xloc.file, xloc.line, msg);
754 warning (OPT_Wdeprecated_declarations,
755 "type is deprecated (declared at %s:%d)",
756 xloc.file, xloc.line);
764 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
767 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
772 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
775 warning (OPT_Wdeprecated_declarations, "type is deprecated");
781 /* Compile an entire translation unit. Write a file of assembly
782 output and various debugging dumps. */
787 /* Initialize yet another pass. */
789 ggc_protect_identifiers = true;
792 init_final (main_input_filename);
793 coverage_init (aux_base_name);
795 invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
797 timevar_push (TV_PARSE);
799 /* Call the parser, which parses the entire file (calling
800 rest_of_compilation for each function). */
801 lang_hooks.parse_file ();
803 /* Compilation is now finished except for writing
804 what's left of the symbol table output. */
805 timevar_pop (TV_PARSE);
807 if (flag_syntax_only || flag_wpa)
810 ggc_protect_identifiers = false;
812 /* This must also call cgraph_finalize_compilation_unit. */
813 lang_hooks.decls.final_write_globals ();
818 varpool_assemble_pending_decls ();
821 /* Likewise for mudflap static object registrations. */
823 mudflap_finish_file ();
825 output_shared_constant_pool ();
826 output_object_blocks ();
828 /* Write out any pending weak symbol declarations. */
831 /* This must be at the end before unwind and debug info.
832 Some target ports emit PIC setup thunks here. */
833 targetm.asm_out.code_end ();
835 /* Do dbx symbols. */
836 timevar_push (TV_SYMOUT);
838 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
839 if (dwarf2out_do_frame ())
840 dwarf2out_frame_finish ();
843 (*debug_hooks->finish) (main_input_filename);
844 timevar_pop (TV_SYMOUT);
846 /* Output some stuff at end of file if nec. */
848 dw2_output_indirect_constants ();
850 /* Flush any pending external directives. */
851 process_pending_assemble_externals ();
853 /* Emit LTO marker if LTO info has been previously emitted. This is
854 used by collect2 to determine whether an object file contains IL.
855 We used to emit an undefined reference here, but this produces
856 link errors if an object file with IL is stored into a shared
857 library without invoking lto1. */
858 if (flag_generate_lto)
860 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
861 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE,
863 (unsigned HOST_WIDE_INT) 1, 8);
864 #elif defined ASM_OUTPUT_ALIGNED_COMMON
865 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1",
866 (unsigned HOST_WIDE_INT) 1, 8);
868 ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1",
869 (unsigned HOST_WIDE_INT) 1,
870 (unsigned HOST_WIDE_INT) 1);
874 /* Attach a special .ident directive to the end of the file to identify
875 the version of GCC which compiled this code. The format of the .ident
876 string is patterned after the ones produced by native SVR4 compilers. */
880 const char *pkg_version = "(GNU) ";
882 if (strcmp ("(GCC) ", pkgversion_string))
883 pkg_version = pkgversion_string;
884 fprintf (asm_out_file, "%s\"GCC: %s%s\"\n",
885 IDENT_ASM_OP, pkg_version, version_string);
889 /* Invoke registered plugin callbacks. */
890 invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
892 /* This must be at the end. Some target ports emit end of file directives
893 into the assembly file here, and hence we can not output anything to the
894 assembly file after this point. */
895 targetm.asm_out.file_end ();
898 /* Indexed by enum debug_info_type. */
899 const char *const debug_type_names[] =
901 "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
904 /* Print version information to FILE.
905 Each line begins with INDENT (for the case where FILE is the
906 assembler output file). */
909 print_version (FILE *file, const char *indent)
911 static const char fmt1[] =
913 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
915 N_("%s%s%s %sversion %s (%s) compiled by CC, ")
918 static const char fmt2[] =
919 N_("GMP version %s, MPFR version %s, MPC version %s\n");
920 static const char fmt3[] =
921 N_("%s%swarning: %s header version %s differs from library version %s.\n");
922 static const char fmt4[] =
923 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
925 #define __VERSION__ "[?]"
928 file == stderr ? _(fmt1) : fmt1,
929 indent, *indent != 0 ? " " : "",
930 lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
931 indent, __VERSION__);
933 /* We need to stringify the GMP macro values. Ugh, gmp_version has
934 two string formats, "i.j.k" and "i.j" when k is zero. As of
935 gmp-4.3.0, GMP always uses the 3 number format. */
936 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
937 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
938 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
939 #define GCC_GMP_VERSION \
940 GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
941 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
942 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
943 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
945 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
946 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
947 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
950 file == stderr ? _(fmt2) : fmt2,
951 GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING);
952 if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
954 file == stderr ? _(fmt3) : fmt3,
955 indent, *indent != 0 ? " " : "",
956 "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
957 if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
959 file == stderr ? _(fmt3) : fmt3,
960 indent, *indent != 0 ? " " : "",
961 "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
962 if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
964 file == stderr ? _(fmt3) : fmt3,
965 indent, *indent != 0 ? " " : "",
966 "MPC", MPC_VERSION_STRING, mpc_get_version ());
968 file == stderr ? _(fmt4) : fmt4,
969 indent, *indent != 0 ? " " : "",
970 PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
972 print_plugins_versions (file, indent);
975 #ifdef ASM_COMMENT_START
977 print_to_asm_out_file (print_switch_type type, const char * text)
979 bool prepend_sep = true;
983 case SWITCH_TYPE_LINE_END:
984 putc ('\n', asm_out_file);
987 case SWITCH_TYPE_LINE_START:
988 fputs (ASM_COMMENT_START, asm_out_file);
989 return strlen (ASM_COMMENT_START);
991 case SWITCH_TYPE_DESCRIPTIVE:
992 if (ASM_COMMENT_START[0] == 0)
995 case SWITCH_TYPE_PASSED:
996 case SWITCH_TYPE_ENABLED:
998 fputc (' ', asm_out_file);
999 fputs (text, asm_out_file);
1000 /* No need to return the length here as
1001 print_single_switch has already done it. */
1011 print_to_stderr (print_switch_type type, const char * text)
1015 case SWITCH_TYPE_LINE_END:
1016 putc ('\n', stderr);
1019 case SWITCH_TYPE_LINE_START:
1022 case SWITCH_TYPE_PASSED:
1023 case SWITCH_TYPE_ENABLED:
1024 fputc (' ', stderr);
1027 case SWITCH_TYPE_DESCRIPTIVE:
1028 fputs (text, stderr);
1029 /* No need to return the length here as
1030 print_single_switch has already done it. */
1038 /* Print an option value and return the adjusted position in the line.
1039 ??? print_fn doesn't handle errors, eg disk full; presumably other
1040 code will catch a disk full though. */
1043 print_single_switch (print_switch_fn_type print_fn,
1045 print_switch_type type,
1048 /* The ultrix fprintf returns 0 on success, so compute the result
1049 we want here since we need it for the following test. The +1
1050 is for the separator character that will probably be emitted. */
1051 int len = strlen (text) + 1;
1054 && pos + len > MAX_LINE)
1056 print_fn (SWITCH_TYPE_LINE_END, NULL);
1061 pos += print_fn (SWITCH_TYPE_LINE_START, NULL);
1063 print_fn (type, text);
1067 /* Print active target switches using PRINT_FN.
1068 POS is the current cursor position and MAX is the size of a "line".
1069 Each line begins with INDENT and ends with TERM.
1070 Each switch is separated from the next by SEP. */
1073 print_switch_values (print_switch_fn_type print_fn)
1078 /* Fill in the -frandom-seed option, if the user didn't pass it, so
1079 that it can be printed below. This helps reproducibility. */
1080 if (!flag_random_seed)
1081 init_random_seed ();
1083 /* Print the options as passed. */
1084 pos = print_single_switch (print_fn, pos,
1085 SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
1087 for (j = 1; j < save_decoded_options_count; j++)
1089 switch (save_decoded_options[j].opt_index)
1102 pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED,
1103 save_decoded_options[j].orig_option_with_args_text);
1107 print_fn (SWITCH_TYPE_LINE_END, NULL);
1109 /* Print the -f and -m options that have been enabled.
1110 We don't handle language specific options but printing argv
1112 pos = print_single_switch (print_fn, 0,
1113 SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
1115 for (j = 0; j < cl_options_count; j++)
1116 if ((cl_options[j].flags & CL_REPORT)
1117 && option_enabled (j, &global_options) > 0)
1118 pos = print_single_switch (print_fn, pos,
1119 SWITCH_TYPE_ENABLED, cl_options[j].opt_text);
1121 print_fn (SWITCH_TYPE_LINE_END, NULL);
1124 /* Open assembly code output file. Do this even if -fsyntax-only is
1125 on, because then the driver will have provided the name of a
1126 temporary file or bit bucket for us. NAME is the file specified on
1127 the command line, possibly NULL. */
1129 init_asm_output (const char *name)
1131 if (name == NULL && asm_file_name == 0)
1132 asm_out_file = stdout;
1135 if (asm_file_name == 0)
1137 int len = strlen (dump_base_name);
1138 char *dumpname = XNEWVEC (char, len + 6);
1140 memcpy (dumpname, dump_base_name, len + 1);
1141 strip_off_ending (dumpname, len);
1142 strcat (dumpname, ".s");
1143 asm_file_name = dumpname;
1145 if (!strcmp (asm_file_name, "-"))
1146 asm_out_file = stdout;
1148 asm_out_file = fopen (asm_file_name, "w+b");
1149 if (asm_out_file == 0)
1150 fatal_error ("can%'t open %s for writing: %m", asm_file_name);
1153 if (!flag_syntax_only)
1155 targetm.asm_out.file_start ();
1157 if (flag_record_gcc_switches)
1159 if (targetm.asm_out.record_gcc_switches)
1161 /* Let the target know that we are about to start recording. */
1162 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
1164 /* Now record the switches. */
1165 print_switch_values (targetm.asm_out.record_gcc_switches);
1166 /* Let the target know that the recording is over. */
1167 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
1171 inform (input_location, "-frecord-gcc-switches is not supported by the current target");
1174 #ifdef ASM_COMMENT_START
1175 if (flag_verbose_asm)
1177 /* Print the list of switches in effect
1178 into the assembler file as comments. */
1179 print_version (asm_out_file, ASM_COMMENT_START);
1180 print_switch_values (print_to_asm_out_file);
1181 putc ('\n', asm_out_file);
1187 /* Return true if the state of option OPTION should be stored in PCH files
1188 and checked by default_pch_valid_p. Store the option's current state
1192 option_affects_pch_p (int option, struct cl_option_state *state)
1194 if ((cl_options[option].flags & CL_TARGET) == 0)
1196 if (option_flag_var (option, &global_options) == &target_flags)
1197 if (targetm.check_pch_target_flags)
1199 return get_option_state (&global_options, option, state);
1202 /* Default version of get_pch_validity.
1203 By default, every flag difference is fatal; that will be mostly right for
1204 most targets, but completely right for very few. */
1207 default_get_pch_validity (size_t *sz)
1209 struct cl_option_state state;
1214 if (targetm.check_pch_target_flags)
1215 *sz += sizeof (target_flags);
1216 for (i = 0; i < cl_options_count; i++)
1217 if (option_affects_pch_p (i, &state))
1220 result = r = XNEWVEC (char, *sz);
1224 if (targetm.check_pch_target_flags)
1226 memcpy (r, &target_flags, sizeof (target_flags));
1227 r += sizeof (target_flags);
1230 for (i = 0; i < cl_options_count; i++)
1231 if (option_affects_pch_p (i, &state))
1233 memcpy (r, state.data, state.size);
1240 /* Return a message which says that a PCH file was created with a different
1241 setting of OPTION. */
1244 pch_option_mismatch (const char *option)
1248 asprintf (&r, _("created and used with differing settings of '%s'"), option);
1250 return _("out of memory");
1254 /* Default version of pch_valid_p. */
1257 default_pch_valid_p (const void *data_p, size_t len)
1259 struct cl_option_state state;
1260 const char *data = (const char *)data_p;
1263 /* -fpic and -fpie also usually make a PCH invalid. */
1264 if (data[0] != flag_pic)
1265 return _("created and used with different settings of -fpic");
1266 if (data[1] != flag_pie)
1267 return _("created and used with different settings of -fpie");
1270 /* Check target_flags. */
1271 if (targetm.check_pch_target_flags)
1276 memcpy (&tf, data, sizeof (target_flags));
1277 data += sizeof (target_flags);
1278 len -= sizeof (target_flags);
1279 r = targetm.check_pch_target_flags (tf);
1284 for (i = 0; i < cl_options_count; i++)
1285 if (option_affects_pch_p (i, &state))
1287 if (memcmp (data, state.data, state.size) != 0)
1288 return pch_option_mismatch (cl_options[i].opt_text);
1296 /* Default tree printer. Handles declarations only. */
1298 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
1299 int precision, bool wide, bool set_locus, bool hash)
1303 /* FUTURE: %+x should set the locus. */
1304 if (precision != 0 || wide || hash)
1310 t = va_arg (*text->args_ptr, tree);
1311 if (TREE_CODE (t) == IDENTIFIER_NODE)
1313 pp_identifier (pp, IDENTIFIER_POINTER (t));
1319 t = va_arg (*text->args_ptr, tree);
1320 if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
1321 t = DECL_DEBUG_EXPR (t);
1326 t = va_arg (*text->args_ptr, tree);
1330 percent_K_format (text);
1337 if (set_locus && text->locus)
1338 *text->locus = DECL_SOURCE_LOCATION (t);
1342 const char *n = DECL_NAME (t)
1343 ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
1348 dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0);
1353 /* A helper function; used as the reallocator function for cpp's line
1356 realloc_for_line_map (void *ptr, size_t len)
1358 return GGC_RESIZEVAR (void, ptr, len);
1361 /* A helper function: used as the allocator function for
1362 identifier_to_locale. */
1364 alloc_for_identifier_to_locale (size_t len)
1366 return ggc_alloc_atomic (len);
1369 /* Output stack usage information. */
1371 output_stack_usage (void)
1373 static bool warning_issued = false;
1374 enum stack_usage_kind_type { STATIC = 0, DYNAMIC, DYNAMIC_BOUNDED };
1375 const char *stack_usage_kind_str[] = {
1380 HOST_WIDE_INT stack_usage = current_function_static_stack_size;
1381 enum stack_usage_kind_type stack_usage_kind;
1382 expanded_location loc;
1383 const char *raw_id, *id;
1385 if (stack_usage < 0)
1387 if (!warning_issued)
1389 warning (0, "-fstack-usage not supported for this target");
1390 warning_issued = true;
1395 stack_usage_kind = STATIC;
1397 /* Add the maximum amount of space pushed onto the stack. */
1398 if (current_function_pushed_stack_size > 0)
1400 stack_usage += current_function_pushed_stack_size;
1401 stack_usage_kind = DYNAMIC_BOUNDED;
1404 /* Now on to the tricky part: dynamic stack allocation. */
1405 if (current_function_allocates_dynamic_stack_space)
1407 if (current_function_has_unbounded_dynamic_stack_size)
1408 stack_usage_kind = DYNAMIC;
1410 stack_usage_kind = DYNAMIC_BOUNDED;
1412 /* Add the size even in the unbounded case, this can't hurt. */
1413 stack_usage += current_function_dynamic_stack_size;
1416 loc = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
1418 /* Strip the scope prefix if any. */
1419 raw_id = lang_hooks.decl_printable_name (current_function_decl, 2);
1420 id = strrchr (raw_id, '.');
1426 fprintf (stack_usage_file,
1427 "%s:%d:%d:%s\t"HOST_WIDE_INT_PRINT_DEC"\t%s\n",
1428 lbasename (loc.file),
1433 stack_usage_kind_str[stack_usage_kind]);
1436 /* Open an auxiliary output file. */
1438 open_auxiliary_file (const char *ext)
1443 filename = concat (aux_base_name, ".", ext, NULL);
1444 file = fopen (filename, "w");
1446 fatal_error ("can%'t open %s for writing: %m", filename);
1451 /* Initialization of the front end environment, before command line
1452 options are parsed. Signal handlers, internationalization etc.
1453 ARGV0 is main's argv[0]. */
1455 general_init (const char *argv0)
1459 p = argv0 + strlen (argv0);
1460 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
1464 xmalloc_set_program_name (progname);
1468 /* Unlock the stdio streams. */
1469 unlock_std_streams ();
1471 gcc_init_libintl ();
1473 identifier_to_locale_alloc = alloc_for_identifier_to_locale;
1474 identifier_to_locale_free = ggc_free;
1476 /* Initialize the diagnostics reporting machinery, so option parsing
1477 can give warnings and errors. */
1478 diagnostic_initialize (global_dc, N_OPTS);
1479 diagnostic_starter (global_dc) = default_tree_diagnostic_starter;
1480 /* Set a default printer. Language specific initializations will
1481 override it later. */
1482 pp_format_decoder (global_dc->printer) = &default_tree_printer;
1483 global_dc->show_option_requested
1484 = global_options_init.x_flag_diagnostics_show_option;
1485 global_dc->show_column
1486 = global_options_init.x_flag_show_column;
1487 global_dc->internal_error = plugins_internal_error_function;
1488 global_dc->option_enabled = option_enabled;
1489 global_dc->option_state = &global_options;
1490 global_dc->option_name = option_name;
1492 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
1494 signal (SIGSEGV, crash_signal);
1497 signal (SIGILL, crash_signal);
1500 signal (SIGBUS, crash_signal);
1503 signal (SIGABRT, crash_signal);
1505 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1506 signal (SIGIOT, crash_signal);
1509 signal (SIGFPE, crash_signal);
1512 /* Other host-specific signal setup. */
1513 (*host_hooks.extra_signals)();
1515 /* Initialize the garbage-collector, string pools and tree type hash
1519 line_table = ggc_alloc_line_maps ();
1520 linemap_init (line_table);
1521 line_table->reallocator = realloc_for_line_map;
1524 /* Initialize register usage now so switches may override. */
1527 /* Register the language-independent parameters. */
1528 add_params (lang_independent_params, LAST_PARAM);
1529 targetm.target_option.default_params ();
1531 /* This must be done after add_params but before argument processing. */
1532 init_ggc_heuristics();
1533 init_optimization_passes ();
1534 statistics_early_init ();
1538 /* Return true if the current target supports -fsection-anchors. */
1541 target_supports_section_anchors_p (void)
1543 if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
1546 if (targetm.asm_out.output_anchor == NULL)
1552 /* Default the align_* variables to 1 if they're still unset, and
1553 set up the align_*_log variables. */
1555 init_alignments (void)
1557 if (align_loops <= 0)
1559 if (align_loops_max_skip > align_loops)
1560 align_loops_max_skip = align_loops - 1;
1561 align_loops_log = floor_log2 (align_loops * 2 - 1);
1562 if (align_jumps <= 0)
1564 if (align_jumps_max_skip > align_jumps)
1565 align_jumps_max_skip = align_jumps - 1;
1566 align_jumps_log = floor_log2 (align_jumps * 2 - 1);
1567 if (align_labels <= 0)
1569 align_labels_log = floor_log2 (align_labels * 2 - 1);
1570 if (align_labels_max_skip > align_labels)
1571 align_labels_max_skip = align_labels - 1;
1572 if (align_functions <= 0)
1573 align_functions = 1;
1574 align_functions_log = floor_log2 (align_functions * 2 - 1);
1577 /* Process the options that have been parsed. */
1579 process_options (void)
1581 /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1582 This can happen with incorrect pre-processed input. */
1583 debug_hooks = &do_nothing_debug_hooks;
1585 maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
1587 /* This replaces set_Wunused. */
1588 if (warn_unused_function == -1)
1589 warn_unused_function = warn_unused;
1590 if (warn_unused_label == -1)
1591 warn_unused_label = warn_unused;
1592 /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled. */
1593 if (warn_unused_parameter == -1)
1594 warn_unused_parameter = (warn_unused && extra_warnings);
1595 if (warn_unused_variable == -1)
1596 warn_unused_variable = warn_unused;
1597 /* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
1599 if (warn_unused_but_set_parameter == -1)
1600 warn_unused_but_set_parameter = (warn_unused && extra_warnings);
1601 if (warn_unused_but_set_variable == -1)
1602 warn_unused_but_set_variable = warn_unused;
1603 if (warn_unused_value == -1)
1604 warn_unused_value = warn_unused;
1606 /* This replaces set_Wextra. */
1607 if (warn_uninitialized == -1)
1608 warn_uninitialized = extra_warnings;
1610 /* Allow the front end to perform consistency checks and do further
1611 initialization based on the command line options. This hook also
1612 sets the original filename if appropriate (e.g. foo.i -> foo.c)
1613 so we can correctly initialize debug output. */
1614 no_backend = lang_hooks.post_options (&main_input_filename);
1616 /* Some machines may reject certain combinations of options. */
1617 targetm.target_option.override ();
1619 /* Avoid any informative notes in the second run of -fcompare-debug. */
1620 if (flag_compare_debug)
1621 diagnostic_inhibit_notes (global_dc);
1623 if (flag_section_anchors && !target_supports_section_anchors_p ())
1625 warning (OPT_fsection_anchors,
1626 "this target does not support %qs", "-fsection-anchors");
1627 flag_section_anchors = 0;
1630 if (flag_short_enums == 2)
1631 flag_short_enums = targetm.default_short_enums ();
1633 /* Set aux_base_name if not already set. */
1636 else if (main_input_filename)
1638 char *name = xstrdup (lbasename (main_input_filename));
1640 strip_off_ending (name, strlen (name));
1641 aux_base_name = name;
1644 aux_base_name = "gccaux";
1649 || flag_loop_interchange
1650 || flag_loop_strip_mine
1651 || flag_graphite_identity
1652 || flag_loop_parallelize_all)
1653 sorry ("Graphite loop optimizations cannot be used");
1656 /* Unrolling all loops implies that standard loop unrolling must also
1658 if (flag_unroll_all_loops)
1659 flag_unroll_loops = 1;
1661 /* web and rename-registers help when run after loop unrolling. */
1662 if (flag_web == AUTODETECT_VALUE)
1663 flag_web = flag_unroll_loops || flag_peel_loops;
1665 if (flag_rename_registers == AUTODETECT_VALUE)
1666 flag_rename_registers = flag_unroll_loops || flag_peel_loops;
1668 if (flag_non_call_exceptions)
1669 flag_asynchronous_unwind_tables = 1;
1670 if (flag_asynchronous_unwind_tables)
1671 flag_unwind_tables = 1;
1673 if (flag_value_profile_transformations)
1674 flag_profile_values = 1;
1676 /* Warn about options that are not supported on this machine. */
1677 #ifndef INSN_SCHEDULING
1678 if (flag_schedule_insns || flag_schedule_insns_after_reload)
1679 warning (0, "instruction scheduling not supported on this target machine");
1682 if (flag_delayed_branch)
1683 warning (0, "this target machine does not have delayed branches");
1686 user_label_prefix = USER_LABEL_PREFIX;
1687 if (flag_leading_underscore != -1)
1689 /* If the default prefix is more complicated than "" or "_",
1690 issue a warning and ignore this option. */
1691 if (user_label_prefix[0] == 0 ||
1692 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1694 user_label_prefix = flag_leading_underscore ? "_" : "";
1697 warning (0, "-f%sleading-underscore not supported on this target machine",
1698 flag_leading_underscore ? "" : "no-");
1701 /* If we are in verbose mode, write out the version and maybe all the
1702 option flags in use. */
1705 print_version (stderr, "");
1707 print_switch_values (print_to_stderr);
1710 if (flag_syntax_only)
1712 write_symbols = NO_DEBUG;
1718 if (debug_info_level == DINFO_LEVEL_NONE)
1720 debug_info_level = DINFO_LEVEL_NORMAL;
1722 if (write_symbols == NO_DEBUG)
1723 write_symbols = PREFERRED_DEBUGGING_TYPE;
1726 debug_info_level = DINFO_LEVEL_NONE;
1729 if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
1731 FILE *final_output = fopen (flag_dump_final_insns, "w");
1734 error ("could not open final insn dump file %qs: %m",
1735 flag_dump_final_insns);
1736 flag_dump_final_insns = NULL;
1738 else if (fclose (final_output))
1740 error ("could not close zeroed insn dump file %qs: %m",
1741 flag_dump_final_insns);
1742 flag_dump_final_insns = NULL;
1746 /* Unless over-ridden for the target, assume that all DWARF levels
1747 may be emitted, if DWARF2_DEBUG is selected. */
1748 if (dwarf_strict < 0)
1751 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1753 if (debug_info_level == DINFO_LEVEL_NONE)
1754 write_symbols = NO_DEBUG;
1756 if (write_symbols == NO_DEBUG)
1758 #if defined(DBX_DEBUGGING_INFO)
1759 else if (write_symbols == DBX_DEBUG)
1760 debug_hooks = &dbx_debug_hooks;
1762 #if defined(XCOFF_DEBUGGING_INFO)
1763 else if (write_symbols == XCOFF_DEBUG)
1764 debug_hooks = &xcoff_debug_hooks;
1766 #ifdef SDB_DEBUGGING_INFO
1767 else if (write_symbols == SDB_DEBUG)
1768 debug_hooks = &sdb_debug_hooks;
1770 #ifdef DWARF2_DEBUGGING_INFO
1771 else if (write_symbols == DWARF2_DEBUG)
1772 debug_hooks = &dwarf2_debug_hooks;
1774 #ifdef VMS_DEBUGGING_INFO
1775 else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1776 debug_hooks = &vmsdbg_debug_hooks;
1779 error ("target system does not support the \"%s\" debug format",
1780 debug_type_names[write_symbols]);
1782 /* We know which debug output will be used so we can set flag_var_tracking
1783 and flag_var_tracking_uninit if the user has not specified them. */
1784 if (debug_info_level < DINFO_LEVEL_NORMAL
1785 || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
1787 if (flag_var_tracking == 1
1788 || flag_var_tracking_uninit == 1)
1790 if (debug_info_level < DINFO_LEVEL_NORMAL)
1791 warning (0, "variable tracking requested, but useless unless "
1792 "producing debug info");
1794 warning (0, "variable tracking requested, but not supported "
1795 "by this debug format");
1797 flag_var_tracking = 0;
1798 flag_var_tracking_uninit = 0;
1801 /* The debug hooks are used to implement -fdump-go-spec because it
1802 gives a simple and stable API for all the information we need to
1804 if (flag_dump_go_spec != NULL)
1805 debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks);
1807 /* If the user specifically requested variable tracking with tagging
1808 uninitialized variables, we need to turn on variable tracking.
1809 (We already determined above that variable tracking is feasible.) */
1810 if (flag_var_tracking_uninit)
1811 flag_var_tracking = 1;
1813 if (flag_var_tracking == AUTODETECT_VALUE)
1814 flag_var_tracking = optimize >= 1;
1816 if (flag_var_tracking_assignments == AUTODETECT_VALUE)
1817 flag_var_tracking_assignments = flag_var_tracking
1818 && !(flag_selective_scheduling || flag_selective_scheduling2);
1820 if (flag_var_tracking_assignments_toggle)
1821 flag_var_tracking_assignments = !flag_var_tracking_assignments;
1823 if (flag_var_tracking_assignments && !flag_var_tracking)
1824 flag_var_tracking = flag_var_tracking_assignments = -1;
1826 if (flag_var_tracking_assignments
1827 && (flag_selective_scheduling || flag_selective_scheduling2))
1828 warning (0, "var-tracking-assignments changes selective scheduling");
1830 if (flag_tree_cselim == AUTODETECT_VALUE)
1831 #ifdef HAVE_conditional_move
1832 flag_tree_cselim = 1;
1834 flag_tree_cselim = 0;
1837 /* If auxiliary info generation is desired, open the output file.
1838 This goes in the same directory as the source file--unlike
1839 all the other output files. */
1840 if (flag_gen_aux_info)
1842 aux_info_file = fopen (aux_info_file_name, "w");
1843 if (aux_info_file == 0)
1844 fatal_error ("can%'t open %s: %m", aux_info_file_name);
1847 if (! targetm.have_named_sections)
1849 if (flag_function_sections)
1851 warning (0, "-ffunction-sections not supported for this target");
1852 flag_function_sections = 0;
1854 if (flag_data_sections)
1856 warning (0, "-fdata-sections not supported for this target");
1857 flag_data_sections = 0;
1861 if (flag_function_sections && profile_flag)
1863 warning (0, "-ffunction-sections disabled; it makes profiling impossible");
1864 flag_function_sections = 0;
1867 #ifndef HAVE_prefetch
1868 if (flag_prefetch_loop_arrays > 0)
1870 warning (0, "-fprefetch-loop-arrays not supported for this target");
1871 flag_prefetch_loop_arrays = 0;
1874 if (flag_prefetch_loop_arrays > 0 && !HAVE_prefetch)
1876 warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
1877 flag_prefetch_loop_arrays = 0;
1881 /* This combination of options isn't handled for i386 targets and doesn't
1882 make much sense anyway, so don't allow it. */
1883 if (flag_prefetch_loop_arrays > 0 && optimize_size)
1885 warning (0, "-fprefetch-loop-arrays is not supported with -Os");
1886 flag_prefetch_loop_arrays = 0;
1889 /* The presence of IEEE signaling NaNs, implies all math can trap. */
1890 if (flag_signaling_nans)
1891 flag_trapping_math = 1;
1893 /* We cannot reassociate if we want traps or signed zeros. */
1894 if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
1896 warning (0, "-fassociative-math disabled; other options take precedence");
1897 flag_associative_math = 0;
1900 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1901 if (flag_cx_limited_range)
1902 flag_complex_method = 0;
1904 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1905 if (flag_cx_fortran_rules)
1906 flag_complex_method = 1;
1908 /* Targets must be able to place spill slots at lower addresses. If the
1909 target already uses a soft frame pointer, the transition is trivial. */
1910 if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
1912 warning (0, "-fstack-protector not supported for this target");
1913 flag_stack_protect = 0;
1915 if (!flag_stack_protect)
1916 warn_stack_protect = 0;
1918 /* ??? Unwind info is not correct around the CFG unless either a frame
1919 pointer is present or A_O_A is set. Fixing this requires rewriting
1920 unwind info generation to be aware of the CFG and propagating states
1922 if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
1923 && flag_omit_frame_pointer)
1925 warning (0, "unwind tables currently require a frame pointer "
1927 flag_omit_frame_pointer = 0;
1930 /* Save the current optimization options. */
1931 optimization_default_node = build_optimization_node ();
1932 optimization_current_node = optimization_default_node;
1935 /* This function can be called multiple times to reinitialize the compiler
1936 back end when register classes or instruction sets have changed,
1937 before each function. */
1939 backend_init_target (void)
1941 /* Initialize alignment variables. */
1944 /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
1945 to initialize reg_raw_mode[]. */
1948 /* This invokes target hooks to set fixed_reg[] etc, which is
1952 /* This depends on stack_pointer_rtx. */
1953 init_fake_stack_mems ();
1955 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
1957 init_alias_target ();
1959 /* Depends on HARD_FRAME_POINTER_REGNUM. */
1962 /* The following initialization functions need to generate rtl, so
1963 provide a dummy function context for them. */
1964 init_dummy_function_start ();
1966 /* rtx_cost is mode-dependent, so cached values need to be recomputed
1967 on a mode change. */
1970 /* We may need to recompute regno_save_code[] and regno_restore_code[]
1971 after a mode change as well. */
1972 caller_save_initialized_p = false;
1974 expand_dummy_function_end ();
1977 /* Initialize the compiler back end. This function is called only once,
1978 when starting the compiler. */
1985 init_inline_once ();
1986 init_varasm_once ();
1987 save_register_info ();
1989 /* Initialize the target-specific back end pieces. */
1991 backend_init_target ();
1994 /* Initialize excess precision settings. */
1996 init_excess_precision (void)
1998 /* Adjust excess precision handling based on the target options. If
1999 the front end cannot handle it, flag_excess_precision_cmdline
2000 will already have been set accordingly in the post_options
2002 gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
2003 flag_excess_precision = flag_excess_precision_cmdline;
2004 if (flag_unsafe_math_optimizations)
2005 flag_excess_precision = EXCESS_PRECISION_FAST;
2006 if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
2008 int flt_eval_method = TARGET_FLT_EVAL_METHOD;
2009 switch (flt_eval_method)
2013 /* Either the target acts unpredictably (-1) or has all the
2014 operations required not to have excess precision (0). */
2015 flag_excess_precision = EXCESS_PRECISION_FAST;
2019 /* In these cases, predictable excess precision makes
2023 /* Any other implementation-defined FLT_EVAL_METHOD values
2024 require the compiler to handle the associated excess
2025 precision rules in excess_precision_type. */
2031 /* Initialize things that are both lang-dependent and target-dependent.
2032 This function can be called more than once if target parameters change. */
2034 lang_dependent_init_target (void)
2036 /* This determines excess precision settings. */
2037 init_excess_precision ();
2039 /* This creates various _DECL nodes, so needs to be called after the
2040 front end is initialized. It also depends on the HAVE_xxx macros
2041 generated from the target machine description. */
2044 /* The following initialization functions need to generate rtl, so
2045 provide a dummy function context for them. */
2046 init_dummy_function_start ();
2048 /* Do the target-specific parts of expr initialization. */
2049 init_expr_target ();
2051 /* Although the actions of these functions are language-independent,
2052 they use optabs, so we cannot call them from backend_init. */
2056 expand_dummy_function_end ();
2059 /* Language-dependent initialization. Returns nonzero on success. */
2061 lang_dependent_init (const char *name)
2063 location_t save_loc = input_location;
2064 if (dump_base_name == 0)
2065 dump_base_name = name && name[0] ? name : "gccdump";
2067 /* Other front-end initialization. */
2068 input_location = BUILTINS_LOCATION;
2069 if (lang_hooks.init () == 0)
2071 input_location = save_loc;
2073 init_asm_output (name);
2075 /* If stack usage information is desired, open the output file. */
2076 if (flag_stack_usage)
2077 stack_usage_file = open_auxiliary_file ("su");
2079 /* This creates various _DECL nodes, so needs to be called after the
2080 front end is initialized. */
2083 /* Do the target-specific parts of the initialization. */
2084 lang_dependent_init_target ();
2086 /* If dbx symbol table desired, initialize writing it and output the
2087 predefined types. */
2088 timevar_push (TV_SYMOUT);
2090 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
2091 if (dwarf2out_do_frame ())
2092 dwarf2out_frame_init ();
2095 /* Now we have the correct original filename, we can initialize
2097 (*debug_hooks->init) (name);
2099 timevar_pop (TV_SYMOUT);
2105 /* Reinitialize everything when target parameters, such as register usage,
2108 target_reinit (void)
2110 /* Reinitialize RTL backend. */
2111 backend_init_target ();
2113 /* Reinitialize lang-dependent parts. */
2114 lang_dependent_init_target ();
2118 dump_memory_report (bool final)
2120 ggc_print_statistics ();
2121 stringpool_statistics ();
2122 dump_tree_statistics ();
2123 dump_gimple_statistics ();
2124 dump_rtx_statistics ();
2125 dump_alloc_pool_statistics ();
2126 dump_bitmap_statistics ();
2127 dump_vec_loc_statistics ();
2128 dump_ggc_loc_statistics (final);
2129 dump_alias_stats (stderr);
2130 dump_pta_stats (stderr);
2133 /* Clean up: close opened files, etc. */
2136 finalize (bool no_backend)
2138 /* Close the dump files. */
2139 if (flag_gen_aux_info)
2141 fclose (aux_info_file);
2143 unlink (aux_info_file_name);
2146 /* Close non-debugging input and output files. Take special care to note
2147 whether fclose returns an error, since the pages might still be on the
2148 buffer chain while the file is open. */
2152 if (ferror (asm_out_file) != 0)
2153 fatal_error ("error writing to %s: %m", asm_file_name);
2154 if (fclose (asm_out_file) != 0)
2155 fatal_error ("error closing %s: %m", asm_file_name);
2157 unlink_if_ordinary (asm_file_name);
2160 if (stack_usage_file)
2161 fclose (stack_usage_file);
2167 finish_optimization_passes ();
2173 dump_memory_report (true);
2175 /* Language-specific end of compilation actions. */
2176 lang_hooks.finish ();
2179 /* Initialize the compiler, and compile the input file. */
2183 /* Initialize timing first. The C front ends read the main file in
2184 the post_options hook, and C++ does file timings. */
2185 if (time_report || !quiet_flag || flag_detailed_statistics)
2187 timevar_start (TV_TOTAL);
2191 /* Don't do any more if an error has already occurred. */
2194 /* This must be run always, because it is needed to compute the FP
2195 predefined macros, such as __LDBL_MAX__, for targets using non
2196 default FP formats. */
2197 init_adjust_machine_modes ();
2199 /* Set up the back-end if requested. */
2203 /* Language-dependent initialization. Returns true on success. */
2204 if (lang_dependent_init (main_input_filename))
2207 finalize (no_backend);
2210 /* Stop timing and print the times. */
2211 timevar_stop (TV_TOTAL);
2212 timevar_print (stderr);
2215 /* Entry point of cc1, cc1plus, jc1, f771, etc.
2216 Exit code is FATAL_EXIT_CODE if can't open files or if there were
2217 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2219 It is not safe to call this function more than once. */
2222 toplev_main (int argc, char **argv)
2224 expandargv (&argc, &argv);
2226 /* Initialization of GCC's environment, and diagnostics. */
2227 general_init (argv[0]);
2229 /* One-off initialization of options that does not need to be
2230 repeated when options are added for particular functions. */
2231 init_options_once ();
2233 /* Initialize global options structures; this must be repeated for
2234 each structure used for parsing options. */
2235 init_options_struct (&global_options, &global_options_set);
2236 lang_hooks.init_options_struct (&global_options);
2238 /* Convert the options to an array. */
2239 decode_cmdline_options_to_array_default_mask (argc,
2240 CONST_CAST2 (const char **,
2242 &save_decoded_options,
2243 &save_decoded_options_count);
2245 /* Perform language-specific options initialization. */
2246 lang_hooks.init_options (save_decoded_options_count, save_decoded_options);
2248 /* Parse the options and do minimal processing; basically just
2249 enough to default flags appropriately. */
2250 decode_options (&global_options, &global_options_set,
2251 save_decoded_options, save_decoded_options_count,
2252 UNKNOWN_LOCATION, global_dc);
2254 handle_common_deferred_options ();
2258 initialize_plugins ();
2261 print_version (stderr, "");
2264 print_plugins_help (stderr, "");
2266 /* Exit early if we can (e.g. -help). */
2267 if (!exit_after_options)
2270 if (warningcount || errorcount)
2271 print_ignored_options ();
2272 diagnostic_finish (global_dc);
2274 /* Invoke registered plugin callbacks if any. */
2275 invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
2277 finalize_plugins ();
2279 return (FATAL_EXIT_CODE);
2281 return (SUCCESS_EXIT_CODE);