OSDN Git Service

* common.opt (flag_stack_check): New Variable entry.
[pf3gnuchains/gcc-fork.git] / gcc / toplev.c
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.
5
6 This file is part of GCC.
7
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
11 version.
12
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
16 for more details.
17
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/>.  */
21
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.  */
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "line-map.h"
32 #include "input.h"
33 #include "tree.h"
34 #include "realmpfr.h"   /* For GMP/MPFR/MPC versions, in print_version.  */
35 #include "version.h"
36 #include "rtl.h"
37 #include "tm_p.h"
38 #include "flags.h"
39 #include "insn-attr.h"
40 #include "insn-config.h"
41 #include "insn-flags.h"
42 #include "hard-reg-set.h"
43 #include "recog.h"
44 #include "output.h"
45 #include "except.h"
46 #include "function.h"
47 #include "toplev.h"
48 #include "expr.h"
49 #include "basic-block.h"
50 #include "intl.h"
51 #include "ggc.h"
52 #include "graph.h"
53 #include "regs.h"
54 #include "timevar.h"
55 #include "diagnostic.h"
56 #include "tree-diagnostic.h"
57 #include "tree-pretty-print.h"
58 #include "params.h"
59 #include "reload.h"
60 #include "ira.h"
61 #include "dwarf2asm.h"
62 #include "integrate.h"
63 #include "debug.h"
64 #include "target.h"
65 #include "langhooks.h"
66 #include "cfglayout.h"
67 #include "cfgloop.h"
68 #include "hosthooks.h"
69 #include "cgraph.h"
70 #include "opts.h"
71 #include "opts-diagnostic.h"
72 #include "coverage.h"
73 #include "value-prof.h"
74 #include "alloc-pool.h"
75 #include "tree-mudflap.h"
76 #include "tree-pass.h"
77 #include "gimple.h"
78 #include "tree-ssa-alias.h"
79 #include "plugin.h"
80
81 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
82 #include "dwarf2out.h"
83 #endif
84
85 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
86 #include "dbxout.h"
87 #endif
88
89 #ifdef SDB_DEBUGGING_INFO
90 #include "sdbout.h"
91 #endif
92
93 #ifdef XCOFF_DEBUGGING_INFO
94 #include "xcoffout.h"           /* Needed for external data
95                                    declarations for e.g. AIX 4.x.  */
96 #endif
97
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);
105
106 static void crash_signal (int) ATTRIBUTE_NORETURN;
107 static void compile_file (void);
108
109 /* True if we don't need a backend (e.g. preprocessing only).  */
110 static bool no_backend;
111
112 /* Length of line when printing switch values.  */
113 #define MAX_LINE 75
114
115 /* Decoded options, and number of such options.  */
116 struct cl_decoded_option *save_decoded_options;
117 unsigned int save_decoded_options_count;
118
119 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
120    to optimize in process_options ().  */
121 #define AUTODETECT_VALUE 2
122
123 /* Debug hooks - dependent upon command line options.  */
124
125 const struct gcc_debug_hooks *debug_hooks;
126
127 /* True if this is the lto front end.  This is used to disable
128    gimple generation and lowering passes that are normally run on the
129    output of a front end.  These passes must be bypassed for lto since
130    they have already been done before the gimple was written.  */
131
132 bool in_lto_p = false;
133
134 /* The FUNCTION_DECL for the function currently being compiled,
135    or 0 if between functions.  */
136 tree current_function_decl;
137
138 /* Set to the FUNC_BEGIN label of the current function, or NULL
139    if none.  */
140 const char * current_function_func_begin_label;
141
142 /* A random sequence of characters, unless overridden by user.  */
143 static const char *flag_random_seed;
144
145 /* A local time stamp derived from the time of compilation. It will be
146    zero if the system cannot provide a time.  It will be -1u, if the
147    user has specified a particular random seed.  */
148 unsigned local_tick;
149
150 /* -f flags.  */
151
152 /* Generate code for GNU or NeXT Objective-C runtime environment.  */
153
154 #ifdef NEXT_OBJC_RUNTIME
155 int flag_next_runtime = 1;
156 #else
157 int flag_next_runtime = 0;
158 #endif
159
160 /* Nonzero means make permerror produce warnings instead of errors.  */
161
162 int flag_permissive = 0;
163
164 /* When non-NULL, indicates that whenever space is allocated on the
165    stack, the resulting stack pointer must not pass this
166    address---that is, for stacks that grow downward, the stack pointer
167    must always be greater than or equal to this address; for stacks
168    that grow upward, the stack pointer must be less than this address.
169    At present, the rtx may be either a REG or a SYMBOL_REF, although
170    the support provided depends on the backend.  */
171 rtx stack_limit_rtx;
172
173 /* True if the user has tagged the function with the 'section'
174    attribute.  */
175
176 bool user_defined_section_attribute = false;
177
178 struct target_flag_state default_target_flag_state;
179 #if SWITCHABLE_TARGET
180 struct target_flag_state *this_target_flag_state = &default_target_flag_state;
181 #else
182 #define this_target_flag_state (&default_target_flag_state)
183 #endif
184
185 typedef struct
186 {
187   const char *const string;
188   int *const variable;
189   const int on_value;
190 }
191 lang_independent_options;
192
193 /* The user symbol prefix after having resolved same.  */
194 const char *user_label_prefix;
195
196 static const param_info lang_independent_params[] = {
197 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
198   { OPTION, DEFAULT, MIN, MAX, HELP },
199 #include "params.def"
200 #undef DEFPARAM
201   { NULL, 0, 0, 0, NULL }
202 };
203
204 /* Output files for assembler code (real compiler output)
205    and debugging dumps.  */
206
207 FILE *asm_out_file;
208 FILE *aux_info_file;
209 FILE *stack_usage_file = NULL;
210 FILE *dump_file = NULL;
211 const char *dump_file_name;
212
213 /* The current working directory of a translation.  It's generally the
214    directory from which compilation was initiated, but a preprocessed
215    file may specify the original directory in which it was
216    created.  */
217
218 static const char *src_pwd;
219
220 /* Initialize src_pwd with the given string, and return true.  If it
221    was already initialized, return false.  As a special case, it may
222    be called with a NULL argument to test whether src_pwd has NOT been
223    initialized yet.  */
224
225 bool
226 set_src_pwd (const char *pwd)
227 {
228   if (src_pwd)
229     {
230       if (strcmp (src_pwd, pwd) == 0)
231         return true;
232       else
233         return false;
234     }
235
236   src_pwd = xstrdup (pwd);
237   return true;
238 }
239
240 /* Return the directory from which the translation unit was initiated,
241    in case set_src_pwd() was not called before to assign it a
242    different value.  */
243
244 const char *
245 get_src_pwd (void)
246 {
247   if (! src_pwd)
248     {
249       src_pwd = getpwd ();
250       if (!src_pwd)
251         src_pwd = ".";
252     }
253
254    return src_pwd;
255 }
256
257 /* Called when the start of a function definition is parsed,
258    this function prints on stderr the name of the function.  */
259 void
260 announce_function (tree decl)
261 {
262   if (!quiet_flag)
263     {
264       if (rtl_dump_and_exit)
265         fprintf (stderr, "%s ",
266                  identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl))));
267       else
268         fprintf (stderr, " %s",
269                  identifier_to_locale (lang_hooks.decl_printable_name (decl, 2)));
270       fflush (stderr);
271       pp_needs_newline (global_dc->printer) = true;
272       diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
273     }
274 }
275
276 /* Initialize local_tick with the time of day, or -1 if
277    flag_random_seed is set.  */
278
279 static void
280 init_local_tick (void)
281 {
282   if (!flag_random_seed)
283     {
284       /* Get some more or less random data.  */
285 #ifdef HAVE_GETTIMEOFDAY
286       {
287         struct timeval tv;
288
289         gettimeofday (&tv, NULL);
290         local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
291       }
292 #else
293       {
294         time_t now = time (NULL);
295
296         if (now != (time_t)-1)
297           local_tick = (unsigned) now;
298       }
299 #endif
300     }
301   else
302     local_tick = -1;
303 }
304
305 /* Set up a default flag_random_seed and local_tick, unless the user
306    already specified one.  Must be called after init_local_tick.  */
307
308 static void
309 init_random_seed (void)
310 {
311   unsigned HOST_WIDE_INT value;
312   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
313
314   value = local_tick ^ getpid ();
315
316   sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
317   flag_random_seed = random_seed;
318 }
319
320 /* Obtain the random_seed string.  Unless NOINIT, initialize it if
321    it's not provided in the command line.  */
322
323 const char *
324 get_random_seed (bool noinit)
325 {
326   if (!flag_random_seed && !noinit)
327     init_random_seed ();
328   return flag_random_seed;
329 }
330
331 /* Modify the random_seed string to VAL.  Return its previous
332    value.  */
333
334 const char *
335 set_random_seed (const char *val)
336 {
337   const char *old = flag_random_seed;
338   flag_random_seed = val;
339   return old;
340 }
341
342 /* Handler for fatal signals, such as SIGSEGV.  These are transformed
343    into ICE messages, which is much more user friendly.  In case the
344    error printer crashes, reset the signal to prevent infinite recursion.  */
345
346 static void
347 crash_signal (int signo)
348 {
349   signal (signo, SIG_DFL);
350
351   /* If we crashed while processing an ASM statement, then be a little more
352      graceful.  It's most likely the user's fault.  */
353   if (this_is_asm_operands)
354     {
355       output_operand_lossage ("unrecoverable error");
356       exit (FATAL_EXIT_CODE);
357     }
358
359   internal_error ("%s", strsignal (signo));
360 }
361
362 /* A subroutine of wrapup_global_declarations.  We've come to the end of
363    the compilation unit.  All deferred variables should be undeferred,
364    and all incomplete decls should be finalized.  */
365
366 void
367 wrapup_global_declaration_1 (tree decl)
368 {
369   /* We're not deferring this any longer.  Assignment is conditional to
370      avoid needlessly dirtying PCH pages.  */
371   if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
372       && DECL_DEFER_OUTPUT (decl) != 0)
373     DECL_DEFER_OUTPUT (decl) = 0;
374
375   if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
376     lang_hooks.finish_incomplete_decl (decl);
377 }
378
379 /* A subroutine of wrapup_global_declarations.  Decide whether or not DECL
380    needs to be output.  Return true if it is output.  */
381
382 bool
383 wrapup_global_declaration_2 (tree decl)
384 {
385   if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
386     return false;
387
388   /* Don't write out static consts, unless we still need them.
389
390      We also keep static consts if not optimizing (for debugging),
391      unless the user specified -fno-keep-static-consts.
392      ??? They might be better written into the debug information.
393      This is possible when using DWARF.
394
395      A language processor that wants static constants to be always
396      written out (even if it is not used) is responsible for
397      calling rest_of_decl_compilation itself.  E.g. the C front-end
398      calls rest_of_decl_compilation from finish_decl.
399      One motivation for this is that is conventional in some
400      environments to write things like:
401      static const char rcsid[] = "... version string ...";
402      intending to force the string to be in the executable.
403
404      A language processor that would prefer to have unneeded
405      static constants "optimized away" would just defer writing
406      them out until here.  E.g. C++ does this, because static
407      constants are often defined in header files.
408
409      ??? A tempting alternative (for both C and C++) would be
410      to force a constant to be written if and only if it is
411      defined in a main file, as opposed to an include file.  */
412
413   if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
414     {
415       struct varpool_node *node;
416       bool needed = true;
417       node = varpool_get_node (decl);
418
419       if (!node && flag_ltrans)
420         needed = false;
421       else if (node && node->finalized)
422         needed = false;
423       else if (node && node->alias)
424         needed = false;
425       else if (!cgraph_global_info_ready
426                && (TREE_USED (decl)
427                    || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
428         /* needed */;
429       else if (node && node->needed)
430         /* needed */;
431       else if (DECL_COMDAT (decl))
432         needed = false;
433       else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
434                && (optimize || !flag_keep_static_consts
435                    || DECL_ARTIFICIAL (decl)))
436         needed = false;
437
438       if (needed)
439         {
440           rest_of_decl_compilation (decl, 1, 1);
441           return true;
442         }
443     }
444
445   return false;
446 }
447
448 /* Do any final processing required for the declarations in VEC, of
449    which there are LEN.  We write out inline functions and variables
450    that have been deferred until this point, but which are required.
451    Returns nonzero if anything was put out.  */
452
453 bool
454 wrapup_global_declarations (tree *vec, int len)
455 {
456   bool reconsider, output_something = false;
457   int i;
458
459   for (i = 0; i < len; i++)
460     wrapup_global_declaration_1 (vec[i]);
461
462   /* Now emit any global variables or functions that we have been
463      putting off.  We need to loop in case one of the things emitted
464      here references another one which comes earlier in the list.  */
465   do
466     {
467       reconsider = false;
468       for (i = 0; i < len; i++)
469         reconsider |= wrapup_global_declaration_2 (vec[i]);
470       if (reconsider)
471         output_something = true;
472     }
473   while (reconsider);
474
475   return output_something;
476 }
477
478 /* A subroutine of check_global_declarations.  Issue appropriate warnings
479    for the global declaration DECL.  */
480
481 void
482 check_global_declaration_1 (tree decl)
483 {
484   /* Warn about any function declared static but not defined.  We don't
485      warn about variables, because many programs have static variables
486      that exist only to get some text into the object file.  */
487   if (TREE_CODE (decl) == FUNCTION_DECL
488       && DECL_INITIAL (decl) == 0
489       && DECL_EXTERNAL (decl)
490       && ! DECL_ARTIFICIAL (decl)
491       && ! TREE_NO_WARNING (decl)
492       && ! TREE_PUBLIC (decl)
493       && (warn_unused_function
494           || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
495     {
496       if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
497         pedwarn (input_location, 0, "%q+F used but never defined", decl);
498       else
499         warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl);
500       /* This symbol is effectively an "extern" declaration now.  */
501       TREE_PUBLIC (decl) = 1;
502       assemble_external (decl);
503     }
504
505   /* Warn about static fns or vars defined but not used.  */
506   if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
507        /* We don't warn about "static const" variables because the
508           "rcs_id" idiom uses that construction.  */
509        || (warn_unused_variable
510            && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
511       && ! DECL_IN_SYSTEM_HEADER (decl)
512       && ! TREE_USED (decl)
513       /* The TREE_USED bit for file-scope decls is kept in the identifier,
514          to handle multiple external decls in different scopes.  */
515       && ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl)))
516       && ! DECL_EXTERNAL (decl)
517       && ! TREE_PUBLIC (decl)
518       /* A volatile variable might be used in some non-obvious way.  */
519       && ! TREE_THIS_VOLATILE (decl)
520       /* Global register variables must be declared to reserve them.  */
521       && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
522       /* Otherwise, ask the language.  */
523       && lang_hooks.decls.warn_unused_global (decl))
524     warning ((TREE_CODE (decl) == FUNCTION_DECL)
525              ? OPT_Wunused_function
526              : OPT_Wunused_variable,
527              "%q+D defined but not used", decl);
528 }
529
530 /* Issue appropriate warnings for the global declarations in VEC (of
531    which there are LEN).  */
532
533 void
534 check_global_declarations (tree *vec, int len)
535 {
536   int i;
537
538   for (i = 0; i < len; i++)
539     check_global_declaration_1 (vec[i]);
540 }
541
542 /* Emit debugging information for all global declarations in VEC.  */
543
544 void
545 emit_debug_global_declarations (tree *vec, int len)
546 {
547   int i;
548
549   /* Avoid confusing the debug information machinery when there are errors.  */
550   if (seen_error ())
551     return;
552
553   timevar_push (TV_SYMOUT);
554   for (i = 0; i < len; i++)
555     debug_hooks->global_decl (vec[i]);
556   timevar_pop (TV_SYMOUT);
557 }
558
559 /* Compile an entire translation unit.  Write a file of assembly
560    output and various debugging dumps.  */
561
562 static void
563 compile_file (void)
564 {
565   /* Initialize yet another pass.  */
566
567   ggc_protect_identifiers = true;
568
569   init_cgraph ();
570   init_final (main_input_filename);
571   coverage_init (aux_base_name);
572   statistics_init ();
573   invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
574
575   timevar_push (TV_PARSE);
576
577   /* Call the parser, which parses the entire file (calling
578      rest_of_compilation for each function).  */
579   lang_hooks.parse_file ();
580
581   /* Compilation is now finished except for writing
582      what's left of the symbol table output.  */
583   timevar_pop (TV_PARSE);
584
585   if (flag_syntax_only || flag_wpa)
586     return;
587
588   ggc_protect_identifiers = false;
589
590   /* This must also call cgraph_finalize_compilation_unit.  */
591   lang_hooks.decls.final_write_globals ();
592
593   if (seen_error ())
594     return;
595
596   varpool_assemble_pending_decls ();
597   finish_aliases_2 ();
598
599   /* Likewise for mudflap static object registrations.  */
600   if (flag_mudflap)
601     mudflap_finish_file ();
602
603   output_shared_constant_pool ();
604   output_object_blocks ();
605
606   /* Write out any pending weak symbol declarations.  */
607   weak_finish ();
608
609   /* This must be at the end before unwind and debug info.
610      Some target ports emit PIC setup thunks here.  */
611   targetm.asm_out.code_end ();
612
613   /* Do dbx symbols.  */
614   timevar_push (TV_SYMOUT);
615
616 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
617   if (dwarf2out_do_frame ())
618     dwarf2out_frame_finish ();
619 #endif
620
621   (*debug_hooks->finish) (main_input_filename);
622   timevar_pop (TV_SYMOUT);
623
624   /* Output some stuff at end of file if nec.  */
625
626   dw2_output_indirect_constants ();
627
628   /* Flush any pending external directives.  */
629   process_pending_assemble_externals ();
630
631   /* Emit LTO marker if LTO info has been previously emitted.  This is
632      used by collect2 to determine whether an object file contains IL.
633      We used to emit an undefined reference here, but this produces
634      link errors if an object file with IL is stored into a shared
635      library without invoking lto1.  */
636   if (flag_generate_lto)
637     {
638 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
639       ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE,
640                                       "__gnu_lto_v1",
641                                       (unsigned HOST_WIDE_INT) 1, 8);
642 #elif defined ASM_OUTPUT_ALIGNED_COMMON
643       ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1",
644                                  (unsigned HOST_WIDE_INT) 1, 8);
645 #else
646       ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1",
647                          (unsigned HOST_WIDE_INT) 1,
648                          (unsigned HOST_WIDE_INT) 1);
649 #endif
650     }
651
652   /* Attach a special .ident directive to the end of the file to identify
653      the version of GCC which compiled this code.  The format of the .ident
654      string is patterned after the ones produced by native SVR4 compilers.  */
655 #ifdef IDENT_ASM_OP
656   if (!flag_no_ident)
657     {
658       const char *pkg_version = "(GNU) ";
659
660       if (strcmp ("(GCC) ", pkgversion_string))
661         pkg_version = pkgversion_string;
662       fprintf (asm_out_file, "%s\"GCC: %s%s\"\n",
663                IDENT_ASM_OP, pkg_version, version_string);
664     }
665 #endif
666
667   /* Invoke registered plugin callbacks.  */
668   invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
669
670   /* This must be at the end.  Some target ports emit end of file directives
671      into the assembly file here, and hence we can not output anything to the
672      assembly file after this point.  */
673   targetm.asm_out.file_end ();
674 }
675
676 /* Indexed by enum debug_info_type.  */
677 const char *const debug_type_names[] =
678 {
679   "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
680 };
681
682 /* Print version information to FILE.
683    Each line begins with INDENT (for the case where FILE is the
684    assembler output file).  */
685
686 void
687 print_version (FILE *file, const char *indent)
688 {
689   static const char fmt1[] =
690 #ifdef __GNUC__
691     N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
692 #else
693     N_("%s%s%s %sversion %s (%s) compiled by CC, ")
694 #endif
695     ;
696   static const char fmt2[] =
697     N_("GMP version %s, MPFR version %s, MPC version %s\n");
698   static const char fmt3[] =
699     N_("%s%swarning: %s header version %s differs from library version %s.\n");
700   static const char fmt4[] =
701     N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
702 #ifndef __VERSION__
703 #define __VERSION__ "[?]"
704 #endif
705   fprintf (file,
706            file == stderr ? _(fmt1) : fmt1,
707            indent, *indent != 0 ? " " : "",
708            lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
709            indent, __VERSION__);
710
711   /* We need to stringify the GMP macro values.  Ugh, gmp_version has
712      two string formats, "i.j.k" and "i.j" when k is zero.  As of
713      gmp-4.3.0, GMP always uses the 3 number format.  */
714 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
715 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
716 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
717 #define GCC_GMP_VERSION \
718   GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
719 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
720 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
721   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
722 #else
723 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
724   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
725   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
726 #endif
727   fprintf (file,
728            file == stderr ? _(fmt2) : fmt2,
729            GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING);
730   if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
731     fprintf (file,
732              file == stderr ? _(fmt3) : fmt3,
733              indent, *indent != 0 ? " " : "",
734              "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
735   if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
736     fprintf (file,
737              file == stderr ? _(fmt3) : fmt3,
738              indent, *indent != 0 ? " " : "",
739              "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
740   if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
741     fprintf (file,
742              file == stderr ? _(fmt3) : fmt3,
743              indent, *indent != 0 ? " " : "",
744              "MPC", MPC_VERSION_STRING, mpc_get_version ());
745   fprintf (file,
746            file == stderr ? _(fmt4) : fmt4,
747            indent, *indent != 0 ? " " : "",
748            PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
749
750   print_plugins_versions (file, indent);
751 }
752
753 #ifdef ASM_COMMENT_START
754 static int
755 print_to_asm_out_file (print_switch_type type, const char * text)
756 {
757   bool prepend_sep = true;
758
759   switch (type)
760     {
761     case SWITCH_TYPE_LINE_END:
762       putc ('\n', asm_out_file);
763       return 1;
764
765     case SWITCH_TYPE_LINE_START:
766       fputs (ASM_COMMENT_START, asm_out_file);
767       return strlen (ASM_COMMENT_START);
768
769     case SWITCH_TYPE_DESCRIPTIVE:
770       if (ASM_COMMENT_START[0] == 0)
771         prepend_sep = false;
772       /* Drop through.  */
773     case SWITCH_TYPE_PASSED:
774     case SWITCH_TYPE_ENABLED:
775       if (prepend_sep)
776         fputc (' ', asm_out_file);
777       fputs (text, asm_out_file);
778       /* No need to return the length here as
779          print_single_switch has already done it.  */
780       return 0;
781
782     default:
783       return -1;
784     }
785 }
786 #endif
787
788 static int
789 print_to_stderr (print_switch_type type, const char * text)
790 {
791   switch (type)
792     {
793     case SWITCH_TYPE_LINE_END:
794       putc ('\n', stderr);
795       return 1;
796
797     case SWITCH_TYPE_LINE_START:
798       return 0;
799
800     case SWITCH_TYPE_PASSED:
801     case SWITCH_TYPE_ENABLED:
802       fputc (' ', stderr);
803       /* Drop through.  */
804
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.  */
809       return 0;
810
811     default:
812       return -1;
813     }
814 }
815
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.  */
819
820 static int
821 print_single_switch (print_switch_fn_type print_fn,
822                      int pos,
823                      print_switch_type type,
824                      const char * text)
825 {
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;
830
831   if (pos != 0
832       && pos + len > MAX_LINE)
833     {
834       print_fn (SWITCH_TYPE_LINE_END, NULL);
835       pos = 0;
836     }
837
838   if (pos == 0)
839     pos += print_fn (SWITCH_TYPE_LINE_START, NULL);
840
841   print_fn (type, text);
842   return pos + len;
843 }
844
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.  */
849
850 static void
851 print_switch_values (print_switch_fn_type print_fn)
852 {
853   int pos = 0;
854   size_t j;
855
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)
859     init_random_seed ();
860
861   /* Print the options as passed.  */
862   pos = print_single_switch (print_fn, pos,
863                              SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
864
865   for (j = 1; j < save_decoded_options_count; j++)
866     {
867       switch (save_decoded_options[j].opt_index)
868         {
869         case OPT_o:
870         case OPT_d:
871         case OPT_dumpbase:
872         case OPT_dumpdir:
873         case OPT_auxbase:
874         case OPT_quiet:
875         case OPT_version:
876           /* Ignore these.  */
877           continue;
878         }
879
880       pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED,
881                                  save_decoded_options[j].orig_option_with_args_text);
882     }
883
884   if (pos > 0)
885     print_fn (SWITCH_TYPE_LINE_END, NULL);
886
887   /* Print the -f and -m options that have been enabled.
888      We don't handle language specific options but printing argv
889      should suffice.  */
890   pos = print_single_switch (print_fn, 0,
891                              SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
892
893   for (j = 0; j < cl_options_count; j++)
894     if ((cl_options[j].flags & 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);
898
899   print_fn (SWITCH_TYPE_LINE_END, NULL);
900 }
901
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.  */
906 static void
907 init_asm_output (const char *name)
908 {
909   if (name == NULL && asm_file_name == 0)
910     asm_out_file = stdout;
911   else
912     {
913       if (asm_file_name == 0)
914         {
915           int len = strlen (dump_base_name);
916           char *dumpname = XNEWVEC (char, len + 6);
917
918           memcpy (dumpname, dump_base_name, len + 1);
919           strip_off_ending (dumpname, len);
920           strcat (dumpname, ".s");
921           asm_file_name = dumpname;
922         }
923       if (!strcmp (asm_file_name, "-"))
924         asm_out_file = stdout;
925       else
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);
929     }
930
931   if (!flag_syntax_only)
932     {
933       targetm.asm_out.file_start ();
934
935       if (flag_record_gcc_switches)
936         {
937           if (targetm.asm_out.record_gcc_switches)
938             {
939               /* Let the target know that we are about to start recording.  */
940               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
941                                                    NULL);
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,
946                                                    NULL);
947             }
948           else
949             inform (input_location, "-frecord-gcc-switches is not supported by the current target");
950         }
951
952 #ifdef ASM_COMMENT_START
953       if (flag_verbose_asm)
954         {
955           /* Print the list of switches in effect
956              into the assembler file as comments.  */
957           print_version (asm_out_file, ASM_COMMENT_START);
958           print_switch_values (print_to_asm_out_file);
959           putc ('\n', asm_out_file);
960         }
961 #endif
962     }
963 }
964
965 /* Default tree printer.   Handles declarations only.  */
966 bool
967 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
968                       int precision, bool wide, bool set_locus, bool hash)
969 {
970   tree t;
971
972   /* FUTURE: %+x should set the locus.  */
973   if (precision != 0 || wide || hash)
974     return false;
975
976   switch (*spec)
977     {
978     case 'E':
979       t = va_arg (*text->args_ptr, tree);
980       if (TREE_CODE (t) == IDENTIFIER_NODE)
981         {
982           pp_identifier (pp, IDENTIFIER_POINTER (t));
983           return true;
984         }
985       break;
986
987     case 'D':
988       t = va_arg (*text->args_ptr, tree);
989       if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
990         t = DECL_DEBUG_EXPR (t);
991       break;
992
993     case 'F':
994     case 'T':
995       t = va_arg (*text->args_ptr, tree);
996       break;
997
998     case 'K':
999       percent_K_format (text);
1000       return true;
1001
1002     default:
1003       return false;
1004     }
1005
1006   if (set_locus && text->locus)
1007     *text->locus = DECL_SOURCE_LOCATION (t);
1008
1009   if (DECL_P (t))
1010     {
1011       const char *n = DECL_NAME (t)
1012         ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
1013         : _("<anonymous>");
1014       pp_string (pp, n);
1015     }
1016   else
1017     dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0);
1018
1019   return true;
1020 }
1021
1022 /* A helper function; used as the reallocator function for cpp's line
1023    table.  */
1024 static void *
1025 realloc_for_line_map (void *ptr, size_t len)
1026 {
1027   return GGC_RESIZEVAR (void, ptr, len);
1028 }
1029
1030 /* A helper function: used as the allocator function for
1031    identifier_to_locale.  */
1032 static void *
1033 alloc_for_identifier_to_locale (size_t len)
1034 {
1035   return ggc_alloc_atomic (len);
1036 }
1037
1038 /* Output stack usage information.  */
1039 void
1040 output_stack_usage (void)
1041 {
1042   static bool warning_issued = false;
1043   enum stack_usage_kind_type { STATIC = 0, DYNAMIC, DYNAMIC_BOUNDED };
1044   const char *stack_usage_kind_str[] = {
1045     "static",
1046     "dynamic",
1047     "dynamic,bounded"
1048   };
1049   HOST_WIDE_INT stack_usage = current_function_static_stack_size;
1050   enum stack_usage_kind_type stack_usage_kind;
1051   expanded_location loc;
1052   const char *raw_id, *id;
1053
1054   if (stack_usage < 0)
1055     {
1056       if (!warning_issued)
1057         {
1058           warning (0, "-fstack-usage not supported for this target");
1059           warning_issued = true;
1060         }
1061       return;
1062     }
1063
1064   stack_usage_kind = STATIC;
1065
1066   /* Add the maximum amount of space pushed onto the stack.  */
1067   if (current_function_pushed_stack_size > 0)
1068     {
1069       stack_usage += current_function_pushed_stack_size;
1070       stack_usage_kind = DYNAMIC_BOUNDED;
1071     }
1072
1073   /* Now on to the tricky part: dynamic stack allocation.  */
1074   if (current_function_allocates_dynamic_stack_space)
1075     {
1076       if (current_function_has_unbounded_dynamic_stack_size)
1077         stack_usage_kind = DYNAMIC;
1078       else
1079         stack_usage_kind = DYNAMIC_BOUNDED;
1080
1081       /* Add the size even in the unbounded case, this can't hurt.  */
1082       stack_usage += current_function_dynamic_stack_size;
1083     }
1084
1085   loc = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
1086
1087   /* Strip the scope prefix if any.  */
1088   raw_id = lang_hooks.decl_printable_name (current_function_decl, 2);
1089   id = strrchr (raw_id, '.');
1090   if (id)
1091     id++;
1092   else
1093     id = raw_id;
1094
1095   fprintf (stack_usage_file,
1096            "%s:%d:%d:%s\t"HOST_WIDE_INT_PRINT_DEC"\t%s\n",
1097            lbasename (loc.file),
1098            loc.line,
1099            loc.column,
1100            id,
1101            stack_usage,
1102            stack_usage_kind_str[stack_usage_kind]);
1103 }
1104
1105 /* Open an auxiliary output file.  */
1106 static FILE *
1107 open_auxiliary_file (const char *ext)
1108 {
1109   char *filename;
1110   FILE *file;
1111
1112   filename = concat (aux_base_name, ".", ext, NULL);
1113   file = fopen (filename, "w");
1114   if (!file)
1115     fatal_error ("can%'t open %s for writing: %m", filename);
1116   free (filename);
1117   return file;
1118 }
1119
1120 /* Initialization of the front end environment, before command line
1121    options are parsed.  Signal handlers, internationalization etc.
1122    ARGV0 is main's argv[0].  */
1123 static void
1124 general_init (const char *argv0)
1125 {
1126   const char *p;
1127
1128   p = argv0 + strlen (argv0);
1129   while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
1130     --p;
1131   progname = p;
1132
1133   xmalloc_set_program_name (progname);
1134
1135   hex_init ();
1136
1137   /* Unlock the stdio streams.  */
1138   unlock_std_streams ();
1139
1140   gcc_init_libintl ();
1141
1142   identifier_to_locale_alloc = alloc_for_identifier_to_locale;
1143   identifier_to_locale_free = ggc_free;
1144
1145   /* Initialize the diagnostics reporting machinery, so option parsing
1146      can give warnings and errors.  */
1147   diagnostic_initialize (global_dc, N_OPTS);
1148   diagnostic_starter (global_dc) = default_tree_diagnostic_starter;
1149   /* Set a default printer.  Language specific initializations will
1150      override it later.  */
1151   pp_format_decoder (global_dc->printer) = &default_tree_printer;
1152   global_dc->show_option_requested
1153     = global_options_init.x_flag_diagnostics_show_option;
1154   global_dc->show_column
1155     = global_options_init.x_flag_show_column;
1156   global_dc->internal_error = plugins_internal_error_function;
1157   global_dc->option_enabled = option_enabled;
1158   global_dc->option_state = &global_options;
1159   global_dc->option_name = option_name;
1160
1161   /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages.  */
1162 #ifdef SIGSEGV
1163   signal (SIGSEGV, crash_signal);
1164 #endif
1165 #ifdef SIGILL
1166   signal (SIGILL, crash_signal);
1167 #endif
1168 #ifdef SIGBUS
1169   signal (SIGBUS, crash_signal);
1170 #endif
1171 #ifdef SIGABRT
1172   signal (SIGABRT, crash_signal);
1173 #endif
1174 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1175   signal (SIGIOT, crash_signal);
1176 #endif
1177 #ifdef SIGFPE
1178   signal (SIGFPE, crash_signal);
1179 #endif
1180
1181   /* Other host-specific signal setup.  */
1182   (*host_hooks.extra_signals)();
1183
1184   /* Initialize the garbage-collector, string pools and tree type hash
1185      table.  */
1186   init_ggc ();
1187   init_stringpool ();
1188   line_table = ggc_alloc_line_maps ();
1189   linemap_init (line_table);
1190   line_table->reallocator = realloc_for_line_map;
1191   init_ttree ();
1192
1193   /* Initialize register usage now so switches may override.  */
1194   init_reg_sets ();
1195
1196   /* Register the language-independent parameters.  */
1197   add_params (lang_independent_params, LAST_PARAM);
1198   targetm.target_option.default_params ();
1199
1200   /* This must be done after add_params but before argument processing.  */
1201   init_ggc_heuristics();
1202   init_optimization_passes ();
1203   statistics_early_init ();
1204   finish_params ();
1205 }
1206
1207 /* Return true if the current target supports -fsection-anchors.  */
1208
1209 static bool
1210 target_supports_section_anchors_p (void)
1211 {
1212   if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
1213     return false;
1214
1215   if (targetm.asm_out.output_anchor == NULL)
1216     return false;
1217
1218   return true;
1219 }
1220
1221 /* Default the align_* variables to 1 if they're still unset, and
1222    set up the align_*_log variables.  */
1223 static void
1224 init_alignments (void)
1225 {
1226   if (align_loops <= 0)
1227     align_loops = 1;
1228   if (align_loops_max_skip > align_loops)
1229     align_loops_max_skip = align_loops - 1;
1230   align_loops_log = floor_log2 (align_loops * 2 - 1);
1231   if (align_jumps <= 0)
1232     align_jumps = 1;
1233   if (align_jumps_max_skip > align_jumps)
1234     align_jumps_max_skip = align_jumps - 1;
1235   align_jumps_log = floor_log2 (align_jumps * 2 - 1);
1236   if (align_labels <= 0)
1237     align_labels = 1;
1238   align_labels_log = floor_log2 (align_labels * 2 - 1);
1239   if (align_labels_max_skip > align_labels)
1240     align_labels_max_skip = align_labels - 1;
1241   if (align_functions <= 0)
1242     align_functions = 1;
1243   align_functions_log = floor_log2 (align_functions * 2 - 1);
1244 }
1245
1246 /* Process the options that have been parsed.  */
1247 static void
1248 process_options (void)
1249 {
1250   /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1251      This can happen with incorrect pre-processed input. */
1252   debug_hooks = &do_nothing_debug_hooks;
1253
1254   maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
1255
1256   /* This replaces set_Wunused.  */
1257   if (warn_unused_function == -1)
1258     warn_unused_function = warn_unused;
1259   if (warn_unused_label == -1)
1260     warn_unused_label = warn_unused;
1261   /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled.  */
1262   if (warn_unused_parameter == -1)
1263     warn_unused_parameter = (warn_unused && extra_warnings);
1264   if (warn_unused_variable == -1)
1265     warn_unused_variable = warn_unused;
1266   /* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
1267      enabled.  */
1268   if (warn_unused_but_set_parameter == -1)
1269     warn_unused_but_set_parameter = (warn_unused && extra_warnings);
1270   if (warn_unused_but_set_variable == -1)
1271     warn_unused_but_set_variable = warn_unused;
1272   if (warn_unused_value == -1)
1273     warn_unused_value = warn_unused;
1274
1275   /* This replaces set_Wextra.  */
1276   if (warn_uninitialized == -1)
1277     warn_uninitialized = extra_warnings;
1278
1279   /* Allow the front end to perform consistency checks and do further
1280      initialization based on the command line options.  This hook also
1281      sets the original filename if appropriate (e.g. foo.i -> foo.c)
1282      so we can correctly initialize debug output.  */
1283   no_backend = lang_hooks.post_options (&main_input_filename);
1284
1285   /* Some machines may reject certain combinations of options.  */
1286   targetm.target_option.override ();
1287
1288   /* Avoid any informative notes in the second run of -fcompare-debug.  */
1289   if (flag_compare_debug) 
1290     diagnostic_inhibit_notes (global_dc);
1291
1292   if (flag_section_anchors && !target_supports_section_anchors_p ())
1293     {
1294       warning (OPT_fsection_anchors,
1295                "this target does not support %qs", "-fsection-anchors");
1296       flag_section_anchors = 0;
1297     }
1298
1299   if (flag_short_enums == 2)
1300     flag_short_enums = targetm.default_short_enums ();
1301
1302   /* Set aux_base_name if not already set.  */
1303   if (aux_base_name)
1304     ;
1305   else if (main_input_filename)
1306     {
1307       char *name = xstrdup (lbasename (main_input_filename));
1308
1309       strip_off_ending (name, strlen (name));
1310       aux_base_name = name;
1311     }
1312   else
1313     aux_base_name = "gccaux";
1314
1315 #ifndef HAVE_cloog
1316   if (flag_graphite
1317       || flag_loop_block
1318       || flag_loop_interchange
1319       || flag_loop_strip_mine
1320       || flag_graphite_identity
1321       || flag_loop_parallelize_all)
1322     sorry ("Graphite loop optimizations cannot be used");
1323 #endif
1324
1325   /* Unrolling all loops implies that standard loop unrolling must also
1326      be done.  */
1327   if (flag_unroll_all_loops)
1328     flag_unroll_loops = 1;
1329
1330   /* web and rename-registers help when run after loop unrolling.  */
1331   if (flag_web == AUTODETECT_VALUE)
1332     flag_web = flag_unroll_loops || flag_peel_loops;
1333
1334   if (flag_rename_registers == AUTODETECT_VALUE)
1335     flag_rename_registers = flag_unroll_loops || flag_peel_loops;
1336
1337   if (flag_non_call_exceptions)
1338     flag_asynchronous_unwind_tables = 1;
1339   if (flag_asynchronous_unwind_tables)
1340     flag_unwind_tables = 1;
1341
1342   if (flag_value_profile_transformations)
1343     flag_profile_values = 1;
1344
1345   /* Warn about options that are not supported on this machine.  */
1346 #ifndef INSN_SCHEDULING
1347   if (flag_schedule_insns || flag_schedule_insns_after_reload)
1348     warning (0, "instruction scheduling not supported on this target machine");
1349 #endif
1350 #ifndef DELAY_SLOTS
1351   if (flag_delayed_branch)
1352     warning (0, "this target machine does not have delayed branches");
1353 #endif
1354
1355   user_label_prefix = USER_LABEL_PREFIX;
1356   if (flag_leading_underscore != -1)
1357     {
1358       /* If the default prefix is more complicated than "" or "_",
1359          issue a warning and ignore this option.  */
1360       if (user_label_prefix[0] == 0 ||
1361           (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1362         {
1363           user_label_prefix = flag_leading_underscore ? "_" : "";
1364         }
1365       else
1366         warning (0, "-f%sleading-underscore not supported on this target machine",
1367                  flag_leading_underscore ? "" : "no-");
1368     }
1369
1370   /* If we are in verbose mode, write out the version and maybe all the
1371      option flags in use.  */
1372   if (version_flag)
1373     {
1374       print_version (stderr, "");
1375       if (! quiet_flag)
1376         print_switch_values (print_to_stderr);
1377     }
1378
1379   if (flag_syntax_only)
1380     {
1381       write_symbols = NO_DEBUG;
1382       profile_flag = 0;
1383     }
1384
1385   if (flag_gtoggle)
1386     {
1387       if (debug_info_level == DINFO_LEVEL_NONE)
1388         {
1389           debug_info_level = DINFO_LEVEL_NORMAL;
1390
1391           if (write_symbols == NO_DEBUG)
1392             write_symbols = PREFERRED_DEBUGGING_TYPE;
1393         }
1394       else
1395         debug_info_level = DINFO_LEVEL_NONE;
1396     }
1397
1398   if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
1399     {
1400       FILE *final_output = fopen (flag_dump_final_insns, "w");
1401       if (!final_output)
1402         {
1403           error ("could not open final insn dump file %qs: %m",
1404                  flag_dump_final_insns);
1405           flag_dump_final_insns = NULL;
1406         }
1407       else if (fclose (final_output))
1408         {
1409           error ("could not close zeroed insn dump file %qs: %m",
1410                  flag_dump_final_insns);
1411           flag_dump_final_insns = NULL;
1412         }
1413     }
1414
1415   /* Unless over-ridden for the target, assume that all DWARF levels
1416      may be emitted, if DWARF2_DEBUG is selected.  */
1417   if (dwarf_strict < 0)
1418     dwarf_strict = 0;
1419
1420   /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1421      level is 0.  */
1422   if (debug_info_level == DINFO_LEVEL_NONE)
1423     write_symbols = NO_DEBUG;
1424
1425   if (write_symbols == NO_DEBUG)
1426     ;
1427 #if defined(DBX_DEBUGGING_INFO)
1428   else if (write_symbols == DBX_DEBUG)
1429     debug_hooks = &dbx_debug_hooks;
1430 #endif
1431 #if defined(XCOFF_DEBUGGING_INFO)
1432   else if (write_symbols == XCOFF_DEBUG)
1433     debug_hooks = &xcoff_debug_hooks;
1434 #endif
1435 #ifdef SDB_DEBUGGING_INFO
1436   else if (write_symbols == SDB_DEBUG)
1437     debug_hooks = &sdb_debug_hooks;
1438 #endif
1439 #ifdef DWARF2_DEBUGGING_INFO
1440   else if (write_symbols == DWARF2_DEBUG)
1441     debug_hooks = &dwarf2_debug_hooks;
1442 #endif
1443 #ifdef VMS_DEBUGGING_INFO
1444   else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1445     debug_hooks = &vmsdbg_debug_hooks;
1446 #endif
1447   else
1448     error ("target system does not support the \"%s\" debug format",
1449            debug_type_names[write_symbols]);
1450
1451   /* We know which debug output will be used so we can set flag_var_tracking
1452      and flag_var_tracking_uninit if the user has not specified them.  */
1453   if (debug_info_level < DINFO_LEVEL_NORMAL
1454       || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
1455     {
1456       if (flag_var_tracking == 1
1457           || flag_var_tracking_uninit == 1)
1458         {
1459           if (debug_info_level < DINFO_LEVEL_NORMAL)
1460             warning (0, "variable tracking requested, but useless unless "
1461                      "producing debug info");
1462           else
1463             warning (0, "variable tracking requested, but not supported "
1464                      "by this debug format");
1465         }
1466       flag_var_tracking = 0;
1467       flag_var_tracking_uninit = 0;
1468     }
1469
1470   /* The debug hooks are used to implement -fdump-go-spec because it
1471      gives a simple and stable API for all the information we need to
1472      dump.  */
1473   if (flag_dump_go_spec != NULL)
1474     debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks);
1475
1476   /* If the user specifically requested variable tracking with tagging
1477      uninitialized variables, we need to turn on variable tracking.
1478      (We already determined above that variable tracking is feasible.)  */
1479   if (flag_var_tracking_uninit)
1480     flag_var_tracking = 1;
1481
1482   if (flag_var_tracking == AUTODETECT_VALUE)
1483     flag_var_tracking = optimize >= 1;
1484
1485   if (flag_var_tracking_assignments == AUTODETECT_VALUE)
1486     flag_var_tracking_assignments = flag_var_tracking
1487       && !(flag_selective_scheduling || flag_selective_scheduling2);
1488
1489   if (flag_var_tracking_assignments_toggle)
1490     flag_var_tracking_assignments = !flag_var_tracking_assignments;
1491
1492   if (flag_var_tracking_assignments && !flag_var_tracking)
1493     flag_var_tracking = flag_var_tracking_assignments = -1;
1494
1495   if (flag_var_tracking_assignments
1496       && (flag_selective_scheduling || flag_selective_scheduling2))
1497     warning (0, "var-tracking-assignments changes selective scheduling");
1498
1499   if (flag_tree_cselim == AUTODETECT_VALUE)
1500 #ifdef HAVE_conditional_move
1501     flag_tree_cselim = 1;
1502 #else
1503     flag_tree_cselim = 0;
1504 #endif
1505
1506   /* If auxiliary info generation is desired, open the output file.
1507      This goes in the same directory as the source file--unlike
1508      all the other output files.  */
1509   if (flag_gen_aux_info)
1510     {
1511       aux_info_file = fopen (aux_info_file_name, "w");
1512       if (aux_info_file == 0)
1513         fatal_error ("can%'t open %s: %m", aux_info_file_name);
1514     }
1515
1516   if (! targetm.have_named_sections)
1517     {
1518       if (flag_function_sections)
1519         {
1520           warning (0, "-ffunction-sections not supported for this target");
1521           flag_function_sections = 0;
1522         }
1523       if (flag_data_sections)
1524         {
1525           warning (0, "-fdata-sections not supported for this target");
1526           flag_data_sections = 0;
1527         }
1528     }
1529
1530   if (flag_function_sections && profile_flag)
1531     {
1532       warning (0, "-ffunction-sections disabled; it makes profiling impossible");
1533       flag_function_sections = 0;
1534     }
1535
1536 #ifndef HAVE_prefetch
1537   if (flag_prefetch_loop_arrays > 0)
1538     {
1539       warning (0, "-fprefetch-loop-arrays not supported for this target");
1540       flag_prefetch_loop_arrays = 0;
1541     }
1542 #else
1543   if (flag_prefetch_loop_arrays > 0 && !HAVE_prefetch)
1544     {
1545       warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
1546       flag_prefetch_loop_arrays = 0;
1547     }
1548 #endif
1549
1550   /* This combination of options isn't handled for i386 targets and doesn't
1551      make much sense anyway, so don't allow it.  */
1552   if (flag_prefetch_loop_arrays > 0 && optimize_size)
1553     {
1554       warning (0, "-fprefetch-loop-arrays is not supported with -Os");
1555       flag_prefetch_loop_arrays = 0;
1556     }
1557
1558   /* The presence of IEEE signaling NaNs, implies all math can trap.  */
1559   if (flag_signaling_nans)
1560     flag_trapping_math = 1;
1561
1562   /* We cannot reassociate if we want traps or signed zeros.  */
1563   if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
1564     {
1565       warning (0, "-fassociative-math disabled; other options take precedence");
1566       flag_associative_math = 0;
1567     }
1568
1569   /* With -fcx-limited-range, we do cheap and quick complex arithmetic.  */
1570   if (flag_cx_limited_range)
1571     flag_complex_method = 0;
1572
1573   /* With -fcx-fortran-rules, we do something in-between cheap and C99.  */
1574   if (flag_cx_fortran_rules)
1575     flag_complex_method = 1;
1576
1577   /* Targets must be able to place spill slots at lower addresses.  If the
1578      target already uses a soft frame pointer, the transition is trivial.  */
1579   if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
1580     {
1581       warning (0, "-fstack-protector not supported for this target");
1582       flag_stack_protect = 0;
1583     }
1584   if (!flag_stack_protect)
1585     warn_stack_protect = 0;
1586
1587   /* ??? Unwind info is not correct around the CFG unless either a frame
1588      pointer is present or A_O_A is set.  Fixing this requires rewriting
1589      unwind info generation to be aware of the CFG and propagating states
1590      around edges.  */
1591   if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
1592       && flag_omit_frame_pointer)
1593     {
1594       warning (0, "unwind tables currently require a frame pointer "
1595                "for correctness");
1596       flag_omit_frame_pointer = 0;
1597     }
1598
1599   /* Save the current optimization options.  */
1600   optimization_default_node = build_optimization_node ();
1601   optimization_current_node = optimization_default_node;
1602 }
1603
1604 /* This function can be called multiple times to reinitialize the compiler
1605    back end when register classes or instruction sets have changed,
1606    before each function.  */
1607 static void
1608 backend_init_target (void)
1609 {
1610   /* Initialize alignment variables.  */
1611   init_alignments ();
1612
1613   /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
1614      to initialize reg_raw_mode[].  */
1615   init_emit_regs ();
1616
1617   /* This invokes target hooks to set fixed_reg[] etc, which is
1618      mode-dependent.  */
1619   init_regs ();
1620
1621   /* This depends on stack_pointer_rtx.  */
1622   init_fake_stack_mems ();
1623
1624   /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
1625      mode-dependent.  */
1626   init_alias_target ();
1627
1628   /* Depends on HARD_FRAME_POINTER_REGNUM.  */
1629   init_reload ();
1630
1631   /* The following initialization functions need to generate rtl, so
1632      provide a dummy function context for them.  */
1633   init_dummy_function_start ();
1634
1635   /* rtx_cost is mode-dependent, so cached values need to be recomputed
1636      on a mode change.  */
1637   init_expmed ();
1638
1639   /* We may need to recompute regno_save_code[] and regno_restore_code[]
1640      after a mode change as well.  */
1641   caller_save_initialized_p = false;
1642
1643   expand_dummy_function_end ();
1644 }
1645
1646 /* Initialize the compiler back end.  This function is called only once,
1647    when starting the compiler.  */
1648 static void
1649 backend_init (void)
1650 {
1651   init_emit_once ();
1652
1653   init_rtlanal ();
1654   init_inline_once ();
1655   init_varasm_once ();
1656   save_register_info ();
1657
1658   /* Initialize the target-specific back end pieces.  */
1659   ira_init_once ();
1660   backend_init_target ();
1661 }
1662
1663 /* Initialize excess precision settings.  */
1664 static void
1665 init_excess_precision (void)
1666 {
1667   /* Adjust excess precision handling based on the target options.  If
1668      the front end cannot handle it, flag_excess_precision_cmdline
1669      will already have been set accordingly in the post_options
1670      hook.  */
1671   gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
1672   flag_excess_precision = flag_excess_precision_cmdline;
1673   if (flag_unsafe_math_optimizations)
1674     flag_excess_precision = EXCESS_PRECISION_FAST;
1675   if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
1676     {
1677       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
1678       switch (flt_eval_method)
1679         {
1680         case -1:
1681         case 0:
1682           /* Either the target acts unpredictably (-1) or has all the
1683              operations required not to have excess precision (0).  */
1684           flag_excess_precision = EXCESS_PRECISION_FAST;
1685           break;
1686         case 1:
1687         case 2:
1688           /* In these cases, predictable excess precision makes
1689              sense.  */
1690           break;
1691         default:
1692           /* Any other implementation-defined FLT_EVAL_METHOD values
1693              require the compiler to handle the associated excess
1694              precision rules in excess_precision_type.  */
1695           gcc_unreachable ();
1696         }
1697     }
1698 }
1699
1700 /* Initialize things that are both lang-dependent and target-dependent.
1701    This function can be called more than once if target parameters change.  */
1702 static void
1703 lang_dependent_init_target (void)
1704 {
1705   /* This determines excess precision settings.  */
1706   init_excess_precision ();
1707
1708   /* This creates various _DECL nodes, so needs to be called after the
1709      front end is initialized.  It also depends on the HAVE_xxx macros
1710      generated from the target machine description.  */
1711   init_optabs ();
1712
1713   /* The following initialization functions need to generate rtl, so
1714      provide a dummy function context for them.  */
1715   init_dummy_function_start ();
1716
1717   /* Do the target-specific parts of expr initialization.  */
1718   init_expr_target ();
1719
1720   /* Although the actions of these functions are language-independent,
1721      they use optabs, so we cannot call them from backend_init.  */
1722   init_set_costs ();
1723   ira_init ();
1724
1725   expand_dummy_function_end ();
1726 }
1727
1728 /* Language-dependent initialization.  Returns nonzero on success.  */
1729 static int
1730 lang_dependent_init (const char *name)
1731 {
1732   location_t save_loc = input_location;
1733   if (dump_base_name == 0)
1734     dump_base_name = name && name[0] ? name : "gccdump";
1735
1736   /* Other front-end initialization.  */
1737   input_location = BUILTINS_LOCATION;
1738   if (lang_hooks.init () == 0)
1739     return 0;
1740   input_location = save_loc;
1741
1742   init_asm_output (name);
1743
1744   /* If stack usage information is desired, open the output file.  */
1745   if (flag_stack_usage)
1746     stack_usage_file = open_auxiliary_file ("su");
1747
1748   /* This creates various _DECL nodes, so needs to be called after the
1749      front end is initialized.  */
1750   init_eh ();
1751
1752   /* Do the target-specific parts of the initialization.  */
1753   lang_dependent_init_target ();
1754
1755   /* If dbx symbol table desired, initialize writing it and output the
1756      predefined types.  */
1757   timevar_push (TV_SYMOUT);
1758
1759 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
1760   if (dwarf2out_do_frame ())
1761     dwarf2out_frame_init ();
1762 #endif
1763
1764   /* Now we have the correct original filename, we can initialize
1765      debug output.  */
1766   (*debug_hooks->init) (name);
1767
1768   timevar_pop (TV_SYMOUT);
1769
1770   return 1;
1771 }
1772
1773
1774 /* Reinitialize everything when target parameters, such as register usage,
1775    have changed.  */
1776 void
1777 target_reinit (void)
1778 {
1779   /* Reinitialize RTL backend.  */
1780   backend_init_target ();
1781
1782   /* Reinitialize lang-dependent parts.  */
1783   lang_dependent_init_target ();
1784 }
1785
1786 void
1787 dump_memory_report (bool final)
1788 {
1789   ggc_print_statistics ();
1790   stringpool_statistics ();
1791   dump_tree_statistics ();
1792   dump_gimple_statistics ();
1793   dump_rtx_statistics ();
1794   dump_alloc_pool_statistics ();
1795   dump_bitmap_statistics ();
1796   dump_vec_loc_statistics ();
1797   dump_ggc_loc_statistics (final);
1798   dump_alias_stats (stderr);
1799   dump_pta_stats (stderr);
1800 }
1801
1802 /* Clean up: close opened files, etc.  */
1803
1804 static void
1805 finalize (bool no_backend)
1806 {
1807   /* Close the dump files.  */
1808   if (flag_gen_aux_info)
1809     {
1810       fclose (aux_info_file);
1811       if (seen_error ())
1812         unlink (aux_info_file_name);
1813     }
1814
1815   /* Close non-debugging input and output files.  Take special care to note
1816      whether fclose returns an error, since the pages might still be on the
1817      buffer chain while the file is open.  */
1818
1819   if (asm_out_file)
1820     {
1821       if (ferror (asm_out_file) != 0)
1822         fatal_error ("error writing to %s: %m", asm_file_name);
1823       if (fclose (asm_out_file) != 0)
1824         fatal_error ("error closing %s: %m", asm_file_name);
1825       if (flag_wpa)
1826         unlink_if_ordinary (asm_file_name);
1827     }
1828
1829   if (stack_usage_file)
1830     fclose (stack_usage_file);
1831
1832   if (!no_backend)
1833     {
1834       statistics_fini ();
1835
1836       finish_optimization_passes ();
1837
1838       ira_finish_once ();
1839     }
1840
1841   if (mem_report)
1842     dump_memory_report (true);
1843
1844   /* Language-specific end of compilation actions.  */
1845   lang_hooks.finish ();
1846 }
1847
1848 /* Initialize the compiler, and compile the input file.  */
1849 static void
1850 do_compile (void)
1851 {
1852   /* Initialize timing first.  The C front ends read the main file in
1853      the post_options hook, and C++ does file timings.  */
1854   if (time_report || !quiet_flag  || flag_detailed_statistics)
1855     timevar_init ();
1856   timevar_start (TV_TOTAL);
1857
1858   process_options ();
1859
1860   /* Don't do any more if an error has already occurred.  */
1861   if (!seen_error ())
1862     {
1863       /* This must be run always, because it is needed to compute the FP
1864          predefined macros, such as __LDBL_MAX__, for targets using non
1865          default FP formats.  */
1866       init_adjust_machine_modes ();
1867
1868       /* Set up the back-end if requested.  */
1869       if (!no_backend)
1870         backend_init ();
1871
1872       /* Language-dependent initialization.  Returns true on success.  */
1873       if (lang_dependent_init (main_input_filename))
1874         compile_file ();
1875
1876       finalize (no_backend);
1877     }
1878
1879   /* Stop timing and print the times.  */
1880   timevar_stop (TV_TOTAL);
1881   timevar_print (stderr);
1882 }
1883
1884 /* Entry point of cc1, cc1plus, jc1, f771, etc.
1885    Exit code is FATAL_EXIT_CODE if can't open files or if there were
1886    any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
1887
1888    It is not safe to call this function more than once.  */
1889
1890 int
1891 toplev_main (int argc, char **argv)
1892 {
1893   expandargv (&argc, &argv);
1894
1895   /* Initialization of GCC's environment, and diagnostics.  */
1896   general_init (argv[0]);
1897
1898   /* One-off initialization of options that does not need to be
1899      repeated when options are added for particular functions.  */
1900   init_options_once ();
1901
1902   /* Initialize global options structures; this must be repeated for
1903      each structure used for parsing options.  */
1904   init_options_struct (&global_options, &global_options_set);
1905   lang_hooks.init_options_struct (&global_options);
1906
1907   /* Convert the options to an array.  */
1908   decode_cmdline_options_to_array_default_mask (argc,
1909                                                 CONST_CAST2 (const char **,
1910                                                              char **, argv),
1911                                                 &save_decoded_options,
1912                                                 &save_decoded_options_count);
1913
1914   /* Perform language-specific options initialization.  */
1915   lang_hooks.init_options (save_decoded_options_count, save_decoded_options);
1916
1917   /* Parse the options and do minimal processing; basically just
1918      enough to default flags appropriately.  */
1919   decode_options (&global_options, &global_options_set,
1920                   save_decoded_options, save_decoded_options_count,
1921                   UNKNOWN_LOCATION, global_dc);
1922
1923   handle_common_deferred_options ();
1924
1925   init_local_tick ();
1926
1927   initialize_plugins ();
1928
1929   if (version_flag)
1930     print_version (stderr, "");
1931
1932   if (help_flag)
1933     print_plugins_help (stderr, "");
1934
1935   /* Exit early if we can (e.g. -help).  */
1936   if (!exit_after_options)
1937     do_compile ();
1938
1939   if (warningcount || errorcount)
1940     print_ignored_options ();
1941   diagnostic_finish (global_dc);
1942
1943   /* Invoke registered plugin callbacks if any.  */
1944   invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
1945
1946   finalize_plugins ();
1947   if (seen_error ())
1948     return (FATAL_EXIT_CODE);
1949
1950   return (SUCCESS_EXIT_CODE);
1951 }