OSDN Git Service

PR 31567
[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
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 #undef FLOAT /* This is for hpux. They should change hpux.  */
29 #undef FFS  /* Some systems define this in param.h.  */
30 #include "system.h"
31 #include "coretypes.h"
32 #include "tm.h"
33 #include <signal.h>
34
35 #ifdef HAVE_SYS_RESOURCE_H
36 # include <sys/resource.h>
37 #endif
38
39 #ifdef HAVE_SYS_TIMES_H
40 # include <sys/times.h>
41 #endif
42
43 #include "line-map.h"
44 #include "input.h"
45 #include "tree.h"
46 #include "version.h"
47 #include "rtl.h"
48 #include "tm_p.h"
49 #include "flags.h"
50 #include "insn-attr.h"
51 #include "insn-config.h"
52 #include "insn-flags.h"
53 #include "hard-reg-set.h"
54 #include "recog.h"
55 #include "output.h"
56 #include "except.h"
57 #include "function.h"
58 #include "toplev.h"
59 #include "expr.h"
60 #include "basic-block.h"
61 #include "intl.h"
62 #include "ggc.h"
63 #include "graph.h"
64 #include "regs.h"
65 #include "timevar.h"
66 #include "diagnostic.h"
67 #include "params.h"
68 #include "reload.h"
69 #include "ira.h"
70 #include "dwarf2asm.h"
71 #include "integrate.h"
72 #include "real.h"
73 #include "debug.h"
74 #include "target.h"
75 #include "langhooks.h"
76 #include "cfglayout.h"
77 #include "cfgloop.h"
78 #include "hosthooks.h"
79 #include "cgraph.h"
80 #include "opts.h"
81 #include "coverage.h"
82 #include "value-prof.h"
83 #include "alloc-pool.h"
84 #include "tree-mudflap.h"
85 #include "tree-pass.h"
86 #include "gimple.h"
87 #include "tree-ssa-alias.h"
88 #include "plugin.h"
89
90 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
91 #include "dwarf2out.h"
92 #endif
93
94 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
95 #include "dbxout.h"
96 #endif
97
98 #ifdef SDB_DEBUGGING_INFO
99 #include "sdbout.h"
100 #endif
101
102 #ifdef XCOFF_DEBUGGING_INFO
103 #include "xcoffout.h"           /* Needed for external data
104                                    declarations for e.g. AIX 4.x.  */
105 #endif
106
107 static void general_init (const char *);
108 static void do_compile (void);
109 static void process_options (void);
110 static void backend_init (void);
111 static int lang_dependent_init (const char *);
112 static void init_asm_output (const char *);
113 static void finalize (void);
114
115 static void crash_signal (int) ATTRIBUTE_NORETURN;
116 static void setup_core_dumping (void);
117 static void compile_file (void);
118
119 /* Nonzero to dump debug info whilst parsing (-dy option).  */
120 static int set_yydebug;
121
122 /* True if we don't need a backend (e.g. preprocessing only).  */
123 static bool no_backend;
124
125 /* Length of line when printing switch values.  */
126 #define MAX_LINE 75
127
128 /* Name of program invoked, sans directories.  */
129
130 const char *progname;
131
132 /* Copy of argument vector to toplev_main.  */
133 static const char **save_argv;
134
135 /* Name of top-level original source file (what was input to cpp).
136    This comes from the #-command at the beginning of the actual input.
137    If there isn't any there, then this is the cc1 input file name.  */
138
139 const char *main_input_filename;
140
141 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
142    to optimize and default_debug_hooks in process_options ().  */
143 #define AUTODETECT_VALUE 2
144
145 /* Current position in real source file.  */
146
147 location_t input_location;
148
149 struct line_maps *line_table;
150
151 /* Name to use as base of names for dump output files.  */
152
153 const char *dump_base_name;
154
155 /* Name to use as a base for auxiliary output files.  */
156
157 const char *aux_base_name;
158
159 /* Prefix for profile data files */
160 const char *profile_data_prefix;
161
162 /* A mask of target_flags that includes bit X if X was set or cleared
163    on the command line.  */
164
165 int target_flags_explicit;
166
167 /* Debug hooks - dependent upon command line options.  */
168
169 const struct gcc_debug_hooks *debug_hooks;
170
171 /* Debug hooks - target default.  */
172
173 static const struct gcc_debug_hooks *default_debug_hooks;
174
175 /* Other flags saying which kinds of debugging dump have been requested.  */
176
177 int rtl_dump_and_exit;
178 int flag_print_asm_name;
179 enum graph_dump_types graph_dump_format;
180
181 /* Name for output file of assembly code, specified with -o.  */
182
183 const char *asm_file_name;
184
185 /* Nonzero means do optimizations.  -O.
186    Particular numeric values stand for particular amounts of optimization;
187    thus, -O2 stores 2 here.  However, the optimizations beyond the basic
188    ones are not controlled directly by this variable.  Instead, they are
189    controlled by individual `flag_...' variables that are defaulted
190    based on this variable.  */
191
192 int optimize = 0;
193
194 /* Nonzero means optimize for size.  -Os.
195    The only valid values are zero and nonzero. When optimize_size is
196    nonzero, optimize defaults to 2, but certain individual code
197    bloating optimizations are disabled.  */
198
199 int optimize_size = 0;
200
201 /* The FUNCTION_DECL for the function currently being compiled,
202    or 0 if between functions.  */
203 tree current_function_decl;
204
205 /* Set to the FUNC_BEGIN label of the current function, or NULL
206    if none.  */
207 const char * current_function_func_begin_label;
208
209 /* Nonzero means to collect statistics which might be expensive
210    and to print them when we are done.  */
211 int flag_detailed_statistics = 0;
212
213 /* A random sequence of characters, unless overridden by user.  */
214 static const char *flag_random_seed;
215
216 /* A local time stamp derived from the time of compilation. It will be
217    zero if the system cannot provide a time.  It will be -1u, if the
218    user has specified a particular random seed.  */
219 unsigned local_tick;
220
221 /* -f flags.  */
222
223 /* Nonzero means `char' should be signed.  */
224
225 int flag_signed_char;
226
227 /* Nonzero means give an enum type only as many bytes as it needs.  A value
228    of 2 means it has not yet been initialized.  */
229
230 int flag_short_enums;
231
232 /* Nonzero if structures and unions should be returned in memory.
233
234    This should only be defined if compatibility with another compiler or
235    with an ABI is needed, because it results in slower code.  */
236
237 #ifndef DEFAULT_PCC_STRUCT_RETURN
238 #define DEFAULT_PCC_STRUCT_RETURN 1
239 #endif
240
241 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
242
243 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
244
245 /* 0 means straightforward implementation of complex divide acceptable.
246    1 means wide ranges of inputs must work for complex divide.
247    2 means C99-like requirements for complex multiply and divide.  */
248
249 int flag_complex_method = 1;
250
251 /* Nonzero means we should be saving declaration info into a .X file.  */
252
253 int flag_gen_aux_info = 0;
254
255 /* Specified name of aux-info file.  */
256
257 const char *aux_info_file_name;
258
259 /* Nonzero if we are compiling code for a shared library, zero for
260    executable.  */
261
262 int flag_shlib;
263
264 /* Generate code for GNU or NeXT Objective-C runtime environment.  */
265
266 #ifdef NEXT_OBJC_RUNTIME
267 int flag_next_runtime = 1;
268 #else
269 int flag_next_runtime = 0;
270 #endif
271
272 /* Set to the default thread-local storage (tls) model to use.  */
273
274 enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
275
276 /* Set the default region and algorithm for the integrated register
277    allocator.  */
278
279 enum ira_algorithm flag_ira_algorithm = IRA_ALGORITHM_CB;
280 enum ira_region flag_ira_region = IRA_REGION_MIXED;
281
282 /* Set the default value for -fira-verbose.  */
283
284 unsigned int flag_ira_verbose = 5;
285
286 /* Set the default for excess precision.  */
287
288 enum excess_precision flag_excess_precision_cmdline = EXCESS_PRECISION_DEFAULT;
289 enum excess_precision flag_excess_precision = EXCESS_PRECISION_DEFAULT;
290
291 /* Nonzero means change certain warnings into errors.
292    Usually these are warnings about failure to conform to some standard.  */
293
294 int flag_pedantic_errors = 0;
295
296 /* Nonzero means make permerror produce warnings instead of errors.  */
297
298 int flag_permissive = 0;
299
300 /* -dA causes debug commentary information to be produced in
301    the generated assembly code (to make it more readable).  This option
302    is generally only of use to those who actually need to read the
303    generated assembly code (perhaps while debugging the compiler itself).
304    Currently, this switch is only used by dwarfout.c; however, it is intended
305    to be a catchall for printing debug information in the assembler file.  */
306
307 int flag_debug_asm = 0;
308
309 /* -dP causes the rtl to be emitted as a comment in assembly.  */
310
311 int flag_dump_rtl_in_asm = 0;
312
313 /* When non-NULL, indicates that whenever space is allocated on the
314    stack, the resulting stack pointer must not pass this
315    address---that is, for stacks that grow downward, the stack pointer
316    must always be greater than or equal to this address; for stacks
317    that grow upward, the stack pointer must be less than this address.
318    At present, the rtx may be either a REG or a SYMBOL_REF, although
319    the support provided depends on the backend.  */
320 rtx stack_limit_rtx;
321
322 /* Nonzero if we should track variables.  When
323    flag_var_tracking == AUTODETECT_VALUE it will be set according
324    to optimize, debug_info_level and debug_hooks in process_options ().  */
325 int flag_var_tracking = AUTODETECT_VALUE;
326
327 /* Type of stack check.  */
328 enum stack_check_type flag_stack_check = NO_STACK_CHECK;
329
330 /* True if the user has tagged the function with the 'section'
331    attribute.  */
332
333 bool user_defined_section_attribute = false;
334
335 /* Values of the -falign-* flags: how much to align labels in code.
336    0 means `use default', 1 means `don't align'.
337    For each variable, there is an _log variant which is the power
338    of two not less than the variable, for .align output.  */
339
340 int align_loops_log;
341 int align_loops_max_skip;
342 int align_jumps_log;
343 int align_jumps_max_skip;
344 int align_labels_log;
345 int align_labels_max_skip;
346 int align_functions_log;
347
348 typedef struct
349 {
350   const char *const string;
351   int *const variable;
352   const int on_value;
353 }
354 lang_independent_options;
355
356 /* Nonzero if subexpressions must be evaluated from left-to-right.  */
357 int flag_evaluation_order = 0;
358
359 /* The user symbol prefix after having resolved same.  */
360 const char *user_label_prefix;
361
362 static const param_info lang_independent_params[] = {
363 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
364   { OPTION, DEFAULT, false, MIN, MAX, HELP },
365 #include "params.def"
366 #undef DEFPARAM
367   { NULL, 0, false, 0, 0, NULL }
368 };
369
370 /* Output files for assembler code (real compiler output)
371    and debugging dumps.  */
372
373 FILE *asm_out_file;
374 FILE *aux_info_file;
375 FILE *dump_file = NULL;
376 const char *dump_file_name;
377
378 /* The current working directory of a translation.  It's generally the
379    directory from which compilation was initiated, but a preprocessed
380    file may specify the original directory in which it was
381    created.  */
382
383 static const char *src_pwd;
384
385 /* Initialize src_pwd with the given string, and return true.  If it
386    was already initialized, return false.  As a special case, it may
387    be called with a NULL argument to test whether src_pwd has NOT been
388    initialized yet.  */
389
390 bool
391 set_src_pwd (const char *pwd)
392 {
393   if (src_pwd)
394     {
395       if (strcmp (src_pwd, pwd) == 0)
396         return true;
397       else
398         return false;
399     }
400
401   src_pwd = xstrdup (pwd);
402   return true;
403 }
404
405 /* Return the directory from which the translation unit was initiated,
406    in case set_src_pwd() was not called before to assign it a
407    different value.  */
408
409 const char *
410 get_src_pwd (void)
411 {
412   if (! src_pwd)
413     {
414       src_pwd = getpwd ();
415       if (!src_pwd)
416         src_pwd = ".";
417     }
418
419    return src_pwd;
420 }
421
422 /* Called when the start of a function definition is parsed,
423    this function prints on stderr the name of the function.  */
424 void
425 announce_function (tree decl)
426 {
427   if (!quiet_flag)
428     {
429       if (rtl_dump_and_exit)
430         fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
431       else
432         fprintf (stderr, " %s", lang_hooks.decl_printable_name (decl, 2));
433       fflush (stderr);
434       pp_needs_newline (global_dc->printer) = true;
435       diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
436     }
437 }
438
439 /* Initialize local_tick with the time of day, or -1 if
440    flag_random_seed is set.  */
441
442 static void
443 init_local_tick (void)
444 {
445   if (!flag_random_seed)
446     {
447       /* Get some more or less random data.  */
448 #ifdef HAVE_GETTIMEOFDAY
449       {
450         struct timeval tv;
451
452         gettimeofday (&tv, NULL);
453         local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
454       }
455 #else
456       {
457         time_t now = time (NULL);
458
459         if (now != (time_t)-1)
460           local_tick = (unsigned) now;
461       }
462 #endif
463     }
464   else
465     local_tick = -1;
466 }
467
468 /* Set up a default flag_random_seed and local_tick, unless the user
469    already specified one.  Must be called after init_local_tick.  */
470
471 static void
472 init_random_seed (void)
473 {
474   unsigned HOST_WIDE_INT value;
475   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
476
477   value = local_tick ^ getpid ();
478
479   sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
480   flag_random_seed = random_seed;
481 }
482
483 /* Obtain the random_seed string.  Unless NOINIT, initialize it if
484    it's not provided in the command line.  */
485
486 const char *
487 get_random_seed (bool noinit)
488 {
489   if (!flag_random_seed && !noinit)
490     init_random_seed ();
491   return flag_random_seed;
492 }
493
494 /* Modify the random_seed string to VAL.  Return its previous
495    value.  */
496
497 const char *
498 set_random_seed (const char *val)
499 {
500   const char *old = flag_random_seed;
501   flag_random_seed = val;
502   return old;
503 }
504
505 /* Decode the string P as an integral parameter.
506    If the string is indeed an integer return its numeric value else
507    issue an Invalid Option error for the option PNAME and return DEFVAL.
508    If PNAME is zero just return DEFVAL, do not call error.  */
509
510 int
511 read_integral_parameter (const char *p, const char *pname, const int  defval)
512 {
513   const char *endp = p;
514
515   while (*endp)
516     {
517       if (ISDIGIT (*endp))
518         endp++;
519       else
520         break;
521     }
522
523   if (*endp != 0)
524     {
525       if (pname != 0)
526         error ("invalid option argument %qs", pname);
527       return defval;
528     }
529
530   return atoi (p);
531 }
532
533 /* When compiling with a recent enough GCC, we use the GNU C "extern inline"
534    for floor_log2 and exact_log2; see toplev.h.  That construct, however,
535    conflicts with the ISO C++ One Definition Rule.   */
536
537 #if GCC_VERSION < 3004 || !defined (__cplusplus)
538
539 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
540    If X is 0, return -1.  */
541
542 int
543 floor_log2 (unsigned HOST_WIDE_INT x)
544 {
545   int t = 0;
546
547   if (x == 0)
548     return -1;
549
550 #ifdef CLZ_HWI
551   t = HOST_BITS_PER_WIDE_INT - 1 - (int) CLZ_HWI (x);
552 #else
553   if (HOST_BITS_PER_WIDE_INT > 64)
554     if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
555       t += 64;
556   if (HOST_BITS_PER_WIDE_INT > 32)
557     if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 32))
558       t += 32;
559   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 16))
560     t += 16;
561   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 8))
562     t += 8;
563   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 4))
564     t += 4;
565   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 2))
566     t += 2;
567   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
568     t += 1;
569 #endif
570
571   return t;
572 }
573
574 /* Return the logarithm of X, base 2, considering X unsigned,
575    if X is a power of 2.  Otherwise, returns -1.  */
576
577 int
578 exact_log2 (unsigned HOST_WIDE_INT x)
579 {
580   if (x != (x & -x))
581     return -1;
582 #ifdef CTZ_HWI
583   return x ? CTZ_HWI (x) : -1;
584 #else
585   return floor_log2 (x);
586 #endif
587 }
588
589 #endif /*  GCC_VERSION < 3004 || !defined (__cplusplus)  */
590
591 /* Handler for fatal signals, such as SIGSEGV.  These are transformed
592    into ICE messages, which is much more user friendly.  In case the
593    error printer crashes, reset the signal to prevent infinite recursion.  */
594
595 static void
596 crash_signal (int signo)
597 {
598   signal (signo, SIG_DFL);
599
600   /* If we crashed while processing an ASM statement, then be a little more
601      graceful.  It's most likely the user's fault.  */
602   if (this_is_asm_operands)
603     {
604       output_operand_lossage ("unrecoverable error");
605       exit (FATAL_EXIT_CODE);
606     }
607
608   internal_error ("%s", strsignal (signo));
609 }
610
611 /* Arrange to dump core on error.  (The regular error message is still
612    printed first, except in the case of abort().)  */
613
614 static void
615 setup_core_dumping (void)
616 {
617 #ifdef SIGABRT
618   signal (SIGABRT, SIG_DFL);
619 #endif
620 #if defined(HAVE_SETRLIMIT)
621   {
622     struct rlimit rlim;
623     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
624       fatal_error ("getting core file size maximum limit: %m");
625     rlim.rlim_cur = rlim.rlim_max;
626     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
627       fatal_error ("setting core file size limit to maximum: %m");
628   }
629 #endif
630   diagnostic_abort_on_error (global_dc);
631 }
632
633
634 /* Strip off a legitimate source ending from the input string NAME of
635    length LEN.  Rather than having to know the names used by all of
636    our front ends, we strip off an ending of a period followed by
637    up to five characters.  (Java uses ".class".)  */
638
639 void
640 strip_off_ending (char *name, int len)
641 {
642   int i;
643   for (i = 2; i < 6 && len > i; i++)
644     {
645       if (name[len - i] == '.')
646         {
647           name[len - i] = '\0';
648           break;
649         }
650     }
651 }
652
653 /* Output a quoted string.  */
654
655 void
656 output_quoted_string (FILE *asm_file, const char *string)
657 {
658 #ifdef OUTPUT_QUOTED_STRING
659   OUTPUT_QUOTED_STRING (asm_file, string);
660 #else
661   char c;
662
663   putc ('\"', asm_file);
664   while ((c = *string++) != 0)
665     {
666       if (ISPRINT (c))
667         {
668           if (c == '\"' || c == '\\')
669             putc ('\\', asm_file);
670           putc (c, asm_file);
671         }
672       else
673         fprintf (asm_file, "\\%03o", (unsigned char) c);
674     }
675   putc ('\"', asm_file);
676 #endif
677 }
678
679 /* Output a file name in the form wanted by System V.  */
680
681 void
682 output_file_directive (FILE *asm_file, const char *input_name)
683 {
684   int len;
685   const char *na;
686
687   if (input_name == NULL)
688     input_name = "<stdin>";
689   else
690     input_name = remap_debug_filename (input_name);
691
692   len = strlen (input_name);
693   na = input_name + len;
694
695   /* NA gets INPUT_NAME sans directory names.  */
696   while (na > input_name)
697     {
698       if (IS_DIR_SEPARATOR (na[-1]))
699         break;
700       na--;
701     }
702
703 #ifdef ASM_OUTPUT_SOURCE_FILENAME
704   ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
705 #else
706   fprintf (asm_file, "\t.file\t");
707   output_quoted_string (asm_file, na);
708   fputc ('\n', asm_file);
709 #endif
710 }
711
712 /* A subroutine of wrapup_global_declarations.  We've come to the end of
713    the compilation unit.  All deferred variables should be undeferred,
714    and all incomplete decls should be finalized.  */
715
716 void
717 wrapup_global_declaration_1 (tree decl)
718 {
719   /* We're not deferring this any longer.  Assignment is conditional to
720      avoid needlessly dirtying PCH pages.  */
721   if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
722       && DECL_DEFER_OUTPUT (decl) != 0)
723     DECL_DEFER_OUTPUT (decl) = 0;
724
725   if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
726     lang_hooks.finish_incomplete_decl (decl);
727 }
728
729 /* A subroutine of wrapup_global_declarations.  Decide whether or not DECL
730    needs to be output.  Return true if it is output.  */
731
732 bool
733 wrapup_global_declaration_2 (tree decl)
734 {
735   if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
736     return false;
737
738   /* Don't write out static consts, unless we still need them.
739
740      We also keep static consts if not optimizing (for debugging),
741      unless the user specified -fno-keep-static-consts.
742      ??? They might be better written into the debug information.
743      This is possible when using DWARF.
744
745      A language processor that wants static constants to be always
746      written out (even if it is not used) is responsible for
747      calling rest_of_decl_compilation itself.  E.g. the C front-end
748      calls rest_of_decl_compilation from finish_decl.
749      One motivation for this is that is conventional in some
750      environments to write things like:
751      static const char rcsid[] = "... version string ...";
752      intending to force the string to be in the executable.
753
754      A language processor that would prefer to have unneeded
755      static constants "optimized away" would just defer writing
756      them out until here.  E.g. C++ does this, because static
757      constants are often defined in header files.
758
759      ??? A tempting alternative (for both C and C++) would be
760      to force a constant to be written if and only if it is
761      defined in a main file, as opposed to an include file.  */
762
763   if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
764     {
765       struct varpool_node *node;
766       bool needed = true;
767       node = varpool_node (decl);
768
769       if (node->finalized)
770         needed = false;
771       else if (node->alias)
772         needed = false;
773       else if (!cgraph_global_info_ready
774                && (TREE_USED (decl)
775                    || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
776         /* needed */;
777       else if (node->needed)
778         /* needed */;
779       else if (DECL_COMDAT (decl))
780         needed = false;
781       else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
782                && (optimize || !flag_keep_static_consts
783                    || DECL_ARTIFICIAL (decl)))
784         needed = false;
785
786       if (needed)
787         {
788           rest_of_decl_compilation (decl, 1, 1);
789           return true;
790         }
791     }
792
793   return false;
794 }
795
796 /* Do any final processing required for the declarations in VEC, of
797    which there are LEN.  We write out inline functions and variables
798    that have been deferred until this point, but which are required.
799    Returns nonzero if anything was put out.  */
800
801 bool
802 wrapup_global_declarations (tree *vec, int len)
803 {
804   bool reconsider, output_something = false;
805   int i;
806
807   for (i = 0; i < len; i++)
808     wrapup_global_declaration_1 (vec[i]);
809
810   /* Now emit any global variables or functions that we have been
811      putting off.  We need to loop in case one of the things emitted
812      here references another one which comes earlier in the list.  */
813   do
814     {
815       reconsider = false;
816       for (i = 0; i < len; i++)
817         reconsider |= wrapup_global_declaration_2 (vec[i]);
818       if (reconsider)
819         output_something = true;
820     }
821   while (reconsider);
822
823   return output_something;
824 }
825
826 /* A subroutine of check_global_declarations.  Issue appropriate warnings
827    for the global declaration DECL.  */
828
829 void
830 check_global_declaration_1 (tree decl)
831 {
832   /* Warn about any function declared static but not defined.  We don't
833      warn about variables, because many programs have static variables
834      that exist only to get some text into the object file.  */
835   if (TREE_CODE (decl) == FUNCTION_DECL
836       && DECL_INITIAL (decl) == 0
837       && DECL_EXTERNAL (decl)
838       && ! DECL_ARTIFICIAL (decl)
839       && ! TREE_NO_WARNING (decl)
840       && ! TREE_PUBLIC (decl)
841       && (warn_unused_function
842           || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
843     {
844       if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
845         pedwarn (input_location, 0, "%q+F used but never defined", decl);
846       else
847         warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl);
848       /* This symbol is effectively an "extern" declaration now.  */
849       TREE_PUBLIC (decl) = 1;
850       assemble_external (decl);
851     }
852
853   /* Warn about static fns or vars defined but not used.  */
854   if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
855        /* We don't warn about "static const" variables because the
856           "rcs_id" idiom uses that construction.  */
857        || (warn_unused_variable
858            && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
859       && ! DECL_IN_SYSTEM_HEADER (decl)
860       && ! TREE_USED (decl)
861       /* The TREE_USED bit for file-scope decls is kept in the identifier,
862          to handle multiple external decls in different scopes.  */
863       && ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl)))
864       && ! DECL_EXTERNAL (decl)
865       && ! TREE_PUBLIC (decl)
866       /* A volatile variable might be used in some non-obvious way.  */
867       && ! TREE_THIS_VOLATILE (decl)
868       /* Global register variables must be declared to reserve them.  */
869       && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
870       /* Otherwise, ask the language.  */
871       && lang_hooks.decls.warn_unused_global (decl))
872     warning ((TREE_CODE (decl) == FUNCTION_DECL) 
873              ? OPT_Wunused_function 
874              : OPT_Wunused_variable, 
875              "%q+D defined but not used", decl);
876 }
877
878 /* Issue appropriate warnings for the global declarations in VEC (of
879    which there are LEN).  */
880
881 void
882 check_global_declarations (tree *vec, int len)
883 {
884   int i;
885
886   for (i = 0; i < len; i++)
887     check_global_declaration_1 (vec[i]);
888 }
889
890 /* Emit debugging information for all global declarations in VEC.  */
891
892 void
893 emit_debug_global_declarations (tree *vec, int len)
894 {
895   int i;
896
897   /* Avoid confusing the debug information machinery when there are errors.  */
898   if (errorcount != 0 || sorrycount != 0)
899     return;
900
901   timevar_push (TV_SYMOUT);
902   for (i = 0; i < len; i++)
903     debug_hooks->global_decl (vec[i]);
904   timevar_pop (TV_SYMOUT);
905 }
906
907 /* Warn about a use of an identifier which was marked deprecated.  */
908 void
909 warn_deprecated_use (tree node)
910 {
911   if (node == 0 || !warn_deprecated_decl)
912     return;
913
914   if (DECL_P (node))
915     {
916       expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
917       warning (OPT_Wdeprecated_declarations,
918                "%qD is deprecated (declared at %s:%d)",
919                node, xloc.file, xloc.line);
920     }
921   else if (TYPE_P (node))
922     {
923       const char *what = NULL;
924       tree decl = TYPE_STUB_DECL (node);
925
926       if (TYPE_NAME (node))
927         {
928           if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
929             what = IDENTIFIER_POINTER (TYPE_NAME (node));
930           else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
931                    && DECL_NAME (TYPE_NAME (node)))
932             what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
933         }
934
935       if (decl)
936         {
937           expanded_location xloc
938             = expand_location (DECL_SOURCE_LOCATION (decl));
939           if (what)
940             warning (OPT_Wdeprecated_declarations,
941                      "%qs is deprecated (declared at %s:%d)", what,
942                      xloc.file, xloc.line);
943           else
944             warning (OPT_Wdeprecated_declarations,
945                      "type is deprecated (declared at %s:%d)",
946                      xloc.file, xloc.line);
947         }
948       else
949         {
950           if (what)
951             warning (OPT_Wdeprecated_declarations, "%qs is deprecated", what);
952           else
953             warning (OPT_Wdeprecated_declarations, "type is deprecated");
954         }
955     }
956 }
957
958 /* Compile an entire translation unit.  Write a file of assembly
959    output and various debugging dumps.  */
960
961 static void
962 compile_file (void)
963 {
964   /* Initialize yet another pass.  */
965
966   ggc_protect_identifiers = true;
967
968   init_cgraph ();
969   init_final (main_input_filename);
970   coverage_init (aux_base_name);
971   statistics_init ();
972
973   timevar_push (TV_PARSE);
974
975   /* Call the parser, which parses the entire file (calling
976      rest_of_compilation for each function).  */
977   lang_hooks.parse_file (set_yydebug);
978
979   /* Compilation is now finished except for writing
980      what's left of the symbol table output.  */
981   timevar_pop (TV_PARSE);
982
983   if (flag_syntax_only)
984     return;
985
986   ggc_protect_identifiers = false;
987
988   lang_hooks.decls.final_write_globals ();
989
990   if (errorcount || sorrycount)
991     return;
992
993   varpool_assemble_pending_decls ();
994   finish_aliases_2 ();
995
996   /* This must occur after the loop to output deferred functions.
997      Else the coverage initializer would not be emitted if all the
998      functions in this compilation unit were deferred.  */
999   coverage_finish ();
1000
1001   /* Likewise for mudflap static object registrations.  */
1002   if (flag_mudflap)
1003     mudflap_finish_file ();
1004
1005   /* Likewise for emulated thread-local storage.  */
1006   if (!targetm.have_tls)
1007     emutls_finish ();
1008
1009   output_shared_constant_pool ();
1010   output_object_blocks ();
1011
1012   /* Write out any pending weak symbol declarations.  */
1013   weak_finish ();
1014
1015   /* Do dbx symbols.  */
1016   timevar_push (TV_SYMOUT);
1017
1018 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
1019   if (dwarf2out_do_frame ())
1020     dwarf2out_frame_finish ();
1021 #endif
1022
1023   (*debug_hooks->finish) (main_input_filename);
1024   timevar_pop (TV_SYMOUT);
1025
1026   /* Output some stuff at end of file if nec.  */
1027
1028   dw2_output_indirect_constants ();
1029
1030   /* Flush any pending external directives.  */
1031   process_pending_assemble_externals ();
1032
1033   /* Attach a special .ident directive to the end of the file to identify
1034      the version of GCC which compiled this code.  The format of the .ident
1035      string is patterned after the ones produced by native SVR4 compilers.  */
1036 #ifdef IDENT_ASM_OP
1037   if (!flag_no_ident)
1038     {
1039       const char *pkg_version = "(GNU) ";
1040
1041       if (strcmp ("(GCC) ", pkgversion_string))
1042         pkg_version = pkgversion_string;
1043       fprintf (asm_out_file, "%s\"GCC: %s%s\"\n",
1044                IDENT_ASM_OP, pkg_version, version_string);
1045     }
1046 #endif
1047
1048   /* This must be at the end.  Some target ports emit end of file directives
1049      into the assembly file here, and hence we can not output anything to the
1050      assembly file after this point.  */
1051   targetm.asm_out.file_end ();
1052 }
1053
1054 /* Parse a -d... command line switch.  */
1055
1056 void
1057 decode_d_option (const char *arg)
1058 {
1059   int c;
1060
1061   while (*arg)
1062     switch (c = *arg++)
1063       {
1064       case 'A':
1065         flag_debug_asm = 1;
1066         break;
1067       case 'p':
1068         flag_print_asm_name = 1;
1069         break;
1070       case 'P':
1071         flag_dump_rtl_in_asm = 1;
1072         flag_print_asm_name = 1;
1073         break;
1074       case 'v':
1075         graph_dump_format = vcg;
1076         break;
1077       case 'x':
1078         rtl_dump_and_exit = 1;
1079         break;
1080       case 'y':
1081         set_yydebug = 1;
1082         break;
1083       case 'D': /* These are handled by the preprocessor.  */
1084       case 'I':
1085       case 'M':
1086       case 'N':
1087       case 'U':
1088         break;
1089       case 'H':
1090         setup_core_dumping();
1091         break;
1092       case 'a':
1093         enable_rtl_dump_file ();
1094         break;
1095
1096       default:
1097           warning (0, "unrecognized gcc debugging option: %c", c);
1098         break;
1099       }
1100 }
1101
1102 /* Indexed by enum debug_info_type.  */
1103 const char *const debug_type_names[] =
1104 {
1105   "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
1106 };
1107
1108 /* Print version information to FILE.
1109    Each line begins with INDENT (for the case where FILE is the
1110    assembler output file).  */
1111
1112 void
1113 print_version (FILE *file, const char *indent)
1114 {
1115   static const char fmt1[] =
1116 #ifdef __GNUC__
1117     N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
1118 #else
1119     N_("%s%s%s %sversion %s (%s) compiled by CC, ")
1120 #endif
1121     ;
1122   static const char fmt2[] =
1123     N_("GMP version %s, MPFR version %s.\n");
1124   static const char fmt3[] =
1125     N_("%s%swarning: %s header version %s differs from library version %s.\n");
1126   static const char fmt4[] =
1127     N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
1128 #ifndef __VERSION__
1129 #define __VERSION__ "[?]"
1130 #endif
1131   fprintf (file,
1132            file == stderr ? _(fmt1) : fmt1,
1133            indent, *indent != 0 ? " " : "",
1134            lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
1135            indent, __VERSION__);
1136
1137   /* We need to stringify the GMP macro values.  Ugh, gmp_version has
1138      two string formats, "i.j.k" and "i.j" when k is zero.  */
1139 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
1140 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
1141 #if __GNU_MP_VERSION_PATCHLEVEL == 0
1142 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
1143   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
1144 #else
1145 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
1146   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
1147   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
1148 #endif
1149   fprintf (file,
1150            file == stderr ? _(fmt2) : fmt2,
1151            GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING);
1152   if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
1153     fprintf (file,
1154              file == stderr ? _(fmt3) : fmt3,
1155              indent, *indent != 0 ? " " : "",
1156              "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
1157   if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
1158     fprintf (file,
1159              file == stderr ? _(fmt3) : fmt3,
1160              indent, *indent != 0 ? " " : "",
1161              "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
1162   fprintf (file,
1163            file == stderr ? _(fmt4) : fmt4,
1164            indent, *indent != 0 ? " " : "",
1165            PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
1166
1167   print_plugins_versions (file, indent);
1168 }
1169
1170 #ifdef ASM_COMMENT_START
1171 static int
1172 print_to_asm_out_file (print_switch_type type, const char * text)
1173 {
1174   bool prepend_sep = true;
1175
1176   switch (type)
1177     {
1178     case SWITCH_TYPE_LINE_END:
1179       putc ('\n', asm_out_file);
1180       return 1;
1181
1182     case SWITCH_TYPE_LINE_START:
1183       fputs (ASM_COMMENT_START, asm_out_file);
1184       return strlen (ASM_COMMENT_START);
1185
1186     case SWITCH_TYPE_DESCRIPTIVE:
1187       if (ASM_COMMENT_START[0] == 0)
1188         prepend_sep = false;
1189       /* Drop through.  */
1190     case SWITCH_TYPE_PASSED:
1191     case SWITCH_TYPE_ENABLED:
1192       if (prepend_sep)
1193         fputc (' ', asm_out_file);
1194       fprintf (asm_out_file, text);
1195       /* No need to return the length here as
1196          print_single_switch has already done it.  */
1197       return 0;
1198
1199     default:
1200       return -1;
1201     }
1202 }
1203 #endif
1204
1205 static int
1206 print_to_stderr (print_switch_type type, const char * text)
1207 {
1208   switch (type)
1209     {
1210     case SWITCH_TYPE_LINE_END:
1211       putc ('\n', stderr);
1212       return 1;
1213
1214     case SWITCH_TYPE_LINE_START:
1215       return 0;
1216       
1217     case SWITCH_TYPE_PASSED:
1218     case SWITCH_TYPE_ENABLED:
1219       fputc (' ', stderr);
1220       /* Drop through.  */
1221
1222     case SWITCH_TYPE_DESCRIPTIVE:
1223       fprintf (stderr, text);
1224       /* No need to return the length here as
1225          print_single_switch has already done it.  */
1226       return 0;
1227
1228     default:
1229       return -1;
1230     }
1231 }
1232
1233 /* Print an option value and return the adjusted position in the line.
1234    ??? print_fn doesn't handle errors, eg disk full; presumably other
1235    code will catch a disk full though.  */
1236
1237 static int
1238 print_single_switch (print_switch_fn_type print_fn,
1239                      int pos,
1240                      print_switch_type type,
1241                      const char * text)
1242 {
1243   /* The ultrix fprintf returns 0 on success, so compute the result
1244      we want here since we need it for the following test.  The +1
1245      is for the separator character that will probably be emitted.  */
1246   int len = strlen (text) + 1;
1247
1248   if (pos != 0
1249       && pos + len > MAX_LINE)
1250     {
1251       print_fn (SWITCH_TYPE_LINE_END, NULL);
1252       pos = 0;
1253     }
1254
1255   if (pos == 0)
1256     pos += print_fn (SWITCH_TYPE_LINE_START, NULL);
1257
1258   print_fn (type, text);
1259   return pos + len;
1260 }
1261
1262 /* Print active target switches using PRINT_FN.
1263    POS is the current cursor position and MAX is the size of a "line".
1264    Each line begins with INDENT and ends with TERM.
1265    Each switch is separated from the next by SEP.  */
1266
1267 static void
1268 print_switch_values (print_switch_fn_type print_fn)
1269 {
1270   int pos = 0;
1271   size_t j;
1272   const char **p;
1273
1274   /* Fill in the -frandom-seed option, if the user didn't pass it, so
1275      that it can be printed below.  This helps reproducibility.  */
1276   if (!flag_random_seed)
1277     init_random_seed ();
1278
1279   /* Print the options as passed.  */
1280   pos = print_single_switch (print_fn, pos,
1281                              SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
1282
1283   for (p = &save_argv[1]; *p != NULL; p++)
1284     {
1285       if (**p == '-')
1286         {
1287           /* Ignore these.  */
1288           if (strcmp (*p, "-o") == 0
1289               || strcmp (*p, "-dumpbase") == 0
1290               || strcmp (*p, "-auxbase") == 0)
1291             {
1292               if (p[1] != NULL)
1293                 p++;
1294               continue;
1295             }
1296
1297           if (strcmp (*p, "-quiet") == 0
1298               || strcmp (*p, "-version") == 0)
1299             continue;
1300
1301           if ((*p)[1] == 'd')
1302             continue;
1303         }
1304
1305       pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED, *p);
1306     }
1307
1308   if (pos > 0)
1309     print_fn (SWITCH_TYPE_LINE_END, NULL);
1310
1311   /* Print the -f and -m options that have been enabled.
1312      We don't handle language specific options but printing argv
1313      should suffice.  */
1314   pos = print_single_switch (print_fn, 0,
1315                              SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
1316
1317   for (j = 0; j < cl_options_count; j++)
1318     if ((cl_options[j].flags & CL_REPORT)
1319         && option_enabled (j) > 0)
1320       pos = print_single_switch (print_fn, pos,
1321                                  SWITCH_TYPE_ENABLED, cl_options[j].opt_text);
1322
1323   print_fn (SWITCH_TYPE_LINE_END, NULL);
1324 }
1325
1326 /* Open assembly code output file.  Do this even if -fsyntax-only is
1327    on, because then the driver will have provided the name of a
1328    temporary file or bit bucket for us.  NAME is the file specified on
1329    the command line, possibly NULL.  */
1330 static void
1331 init_asm_output (const char *name)
1332 {
1333   if (name == NULL && asm_file_name == 0)
1334     asm_out_file = stdout;
1335   else
1336     {
1337       if (asm_file_name == 0)
1338         {
1339           int len = strlen (dump_base_name);
1340           char *dumpname = XNEWVEC (char, len + 6);
1341
1342           memcpy (dumpname, dump_base_name, len + 1);
1343           strip_off_ending (dumpname, len);
1344           strcat (dumpname, ".s");
1345           asm_file_name = dumpname;
1346         }
1347       if (!strcmp (asm_file_name, "-"))
1348         asm_out_file = stdout;
1349       else
1350         asm_out_file = fopen (asm_file_name, "w+b");
1351       if (asm_out_file == 0)
1352         fatal_error ("can%'t open %s for writing: %m", asm_file_name);
1353     }
1354
1355   if (!flag_syntax_only)
1356     {
1357       targetm.asm_out.file_start ();
1358
1359       if (flag_record_gcc_switches)
1360         {
1361           if (targetm.asm_out.record_gcc_switches)
1362             {
1363               /* Let the target know that we are about to start recording.  */
1364               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
1365                                                    NULL);
1366               /* Now record the switches.  */
1367               print_switch_values (targetm.asm_out.record_gcc_switches);
1368               /* Let the target know that the recording is over.  */
1369               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
1370                                                    NULL);
1371             }
1372           else
1373             inform (input_location, "-frecord-gcc-switches is not supported by the current target");
1374         }
1375
1376 #ifdef ASM_COMMENT_START
1377       if (flag_verbose_asm)
1378         {
1379           /* Print the list of switches in effect
1380              into the assembler file as comments.  */
1381           print_version (asm_out_file, ASM_COMMENT_START);
1382           print_switch_values (print_to_asm_out_file);
1383           fprintf (asm_out_file, "\n");
1384         }
1385 #endif
1386     }
1387 }
1388
1389 /* Return true if the state of option OPTION should be stored in PCH files
1390    and checked by default_pch_valid_p.  Store the option's current state
1391    in STATE if so.  */
1392
1393 static inline bool
1394 option_affects_pch_p (int option, struct cl_option_state *state)
1395 {
1396   if ((cl_options[option].flags & CL_TARGET) == 0)
1397     return false;
1398   if (cl_options[option].flag_var == &target_flags)
1399     if (targetm.check_pch_target_flags)
1400       return false;
1401   return get_option_state (option, state);
1402 }
1403
1404 /* Default version of get_pch_validity.
1405    By default, every flag difference is fatal; that will be mostly right for
1406    most targets, but completely right for very few.  */
1407
1408 void *
1409 default_get_pch_validity (size_t *len)
1410 {
1411   struct cl_option_state state;
1412   size_t i;
1413   char *result, *r;
1414
1415   *len = 2;
1416   if (targetm.check_pch_target_flags)
1417     *len += sizeof (target_flags);
1418   for (i = 0; i < cl_options_count; i++)
1419     if (option_affects_pch_p (i, &state))
1420       *len += state.size;
1421
1422   result = r = XNEWVEC (char, *len);
1423   r[0] = flag_pic;
1424   r[1] = flag_pie;
1425   r += 2;
1426   if (targetm.check_pch_target_flags)
1427     {
1428       memcpy (r, &target_flags, sizeof (target_flags));
1429       r += sizeof (target_flags);
1430     }
1431
1432   for (i = 0; i < cl_options_count; i++)
1433     if (option_affects_pch_p (i, &state))
1434       {
1435         memcpy (r, state.data, state.size);
1436         r += state.size;
1437       }
1438
1439   return result;
1440 }
1441
1442 /* Return a message which says that a PCH file was created with a different
1443    setting of OPTION.  */
1444
1445 static const char *
1446 pch_option_mismatch (const char *option)
1447 {
1448   char *r;
1449
1450   asprintf (&r, _("created and used with differing settings of '%s'"), option);
1451   if (r == NULL)
1452     return _("out of memory");
1453   return r;
1454 }
1455
1456 /* Default version of pch_valid_p.  */
1457
1458 const char *
1459 default_pch_valid_p (const void *data_p, size_t len)
1460 {
1461   struct cl_option_state state;
1462   const char *data = (const char *)data_p;
1463   size_t i;
1464
1465   /* -fpic and -fpie also usually make a PCH invalid.  */
1466   if (data[0] != flag_pic)
1467     return _("created and used with different settings of -fpic");
1468   if (data[1] != flag_pie)
1469     return _("created and used with different settings of -fpie");
1470   data += 2;
1471
1472   /* Check target_flags.  */
1473   if (targetm.check_pch_target_flags)
1474     {
1475       int tf;
1476       const char *r;
1477
1478       memcpy (&tf, data, sizeof (target_flags));
1479       data += sizeof (target_flags);
1480       len -= sizeof (target_flags);
1481       r = targetm.check_pch_target_flags (tf);
1482       if (r != NULL)
1483         return r;
1484     }
1485
1486   for (i = 0; i < cl_options_count; i++)
1487     if (option_affects_pch_p (i, &state))
1488       {
1489         if (memcmp (data, state.data, state.size) != 0)
1490           return pch_option_mismatch (cl_options[i].opt_text);
1491         data += state.size;
1492         len -= state.size;
1493       }
1494
1495   return NULL;
1496 }
1497
1498 /* Default tree printer.   Handles declarations only.  */
1499 static bool
1500 default_tree_printer (pretty_printer * pp, text_info *text, const char *spec,
1501                       int precision, bool wide, bool set_locus, bool hash)
1502 {
1503   tree t;
1504
1505   /* FUTURE: %+x should set the locus.  */
1506   if (precision != 0 || wide || hash)
1507     return false;
1508
1509   switch (*spec)
1510     {
1511     case 'D':
1512       t = va_arg (*text->args_ptr, tree);
1513       if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
1514         t = DECL_DEBUG_EXPR (t);
1515       break;
1516
1517     case 'F':
1518     case 'T':
1519       t = va_arg (*text->args_ptr, tree);
1520       break;
1521
1522     default:
1523       return false;
1524     }
1525
1526   if (set_locus && text->locus)
1527     *text->locus = DECL_SOURCE_LOCATION (t);
1528
1529   if (DECL_P (t))
1530     {
1531       const char *n = DECL_NAME (t)
1532         ? lang_hooks.decl_printable_name (t, 2)
1533         : "<anonymous>";
1534       pp_string (pp, n);
1535     }
1536   else
1537     dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0);
1538
1539   return true;
1540 }
1541
1542 /* A helper function; used as the reallocator function for cpp's line
1543    table.  */
1544 static void *
1545 realloc_for_line_map (void *ptr, size_t len)
1546 {
1547   return ggc_realloc (ptr, len);
1548 }
1549
1550 /* Initialization of the front end environment, before command line
1551    options are parsed.  Signal handlers, internationalization etc.
1552    ARGV0 is main's argv[0].  */
1553 static void
1554 general_init (const char *argv0)
1555 {
1556   const char *p;
1557
1558   p = argv0 + strlen (argv0);
1559   while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
1560     --p;
1561   progname = p;
1562
1563   xmalloc_set_program_name (progname);
1564
1565   hex_init ();
1566
1567   /* Unlock the stdio streams.  */
1568   unlock_std_streams ();
1569
1570   gcc_init_libintl ();
1571
1572   /* Initialize the diagnostics reporting machinery, so option parsing
1573      can give warnings and errors.  */
1574   diagnostic_initialize (global_dc);
1575   /* Set a default printer.  Language specific initializations will
1576      override it later.  */
1577   pp_format_decoder (global_dc->printer) = &default_tree_printer;
1578
1579   /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages.  */
1580 #ifdef SIGSEGV
1581   signal (SIGSEGV, crash_signal);
1582 #endif
1583 #ifdef SIGILL
1584   signal (SIGILL, crash_signal);
1585 #endif
1586 #ifdef SIGBUS
1587   signal (SIGBUS, crash_signal);
1588 #endif
1589 #ifdef SIGABRT
1590   signal (SIGABRT, crash_signal);
1591 #endif
1592 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1593   signal (SIGIOT, crash_signal);
1594 #endif
1595 #ifdef SIGFPE
1596   signal (SIGFPE, crash_signal);
1597 #endif
1598
1599   /* Other host-specific signal setup.  */
1600   (*host_hooks.extra_signals)();
1601
1602   /* Initialize the garbage-collector, string pools and tree type hash
1603      table.  */
1604   init_ggc ();
1605   init_stringpool ();
1606   line_table = GGC_NEW (struct line_maps);
1607   linemap_init (line_table);
1608   line_table->reallocator = realloc_for_line_map;
1609   init_ttree ();
1610
1611   /* Initialize register usage now so switches may override.  */
1612   init_reg_sets ();
1613
1614   /* Register the language-independent parameters.  */
1615   add_params (lang_independent_params, LAST_PARAM);
1616
1617   /* This must be done after add_params but before argument processing.  */
1618   init_ggc_heuristics();
1619   init_optimization_passes ();
1620   statistics_early_init ();
1621 }
1622
1623 /* Return true if the current target supports -fsection-anchors.  */
1624
1625 static bool
1626 target_supports_section_anchors_p (void)
1627 {
1628   if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
1629     return false;
1630
1631   if (targetm.asm_out.output_anchor == NULL)
1632     return false;
1633
1634   return true;
1635 }
1636
1637 /* Default the align_* variables to 1 if they're still unset, and
1638    set up the align_*_log variables.  */
1639 static void
1640 init_alignments (void)
1641 {
1642   if (align_loops <= 0)
1643     align_loops = 1;
1644   if (align_loops_max_skip > align_loops)
1645     align_loops_max_skip = align_loops - 1;
1646   align_loops_log = floor_log2 (align_loops * 2 - 1);
1647   if (align_jumps <= 0)
1648     align_jumps = 1;
1649   if (align_jumps_max_skip > align_jumps)
1650     align_jumps_max_skip = align_jumps - 1;
1651   align_jumps_log = floor_log2 (align_jumps * 2 - 1);
1652   if (align_labels <= 0)
1653     align_labels = 1;
1654   align_labels_log = floor_log2 (align_labels * 2 - 1);
1655   if (align_labels_max_skip > align_labels)
1656     align_labels_max_skip = align_labels - 1;
1657   if (align_functions <= 0)
1658     align_functions = 1;
1659   align_functions_log = floor_log2 (align_functions * 2 - 1);
1660 }
1661
1662 /* Process the options that have been parsed.  */
1663 static void
1664 process_options (void)
1665 {
1666   /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1667      This can happen with incorrect pre-processed input. */
1668   debug_hooks = &do_nothing_debug_hooks;
1669
1670   /* This replaces set_Wunused.  */
1671   if (warn_unused_function == -1)
1672     warn_unused_function = warn_unused;
1673   if (warn_unused_label == -1)
1674     warn_unused_label = warn_unused;
1675   /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled.  */
1676   if (warn_unused_parameter == -1)
1677     warn_unused_parameter = (warn_unused && extra_warnings);
1678   if (warn_unused_variable == -1)
1679     warn_unused_variable = warn_unused;
1680   if (warn_unused_value == -1)
1681     warn_unused_value = warn_unused;
1682
1683   /* Allow the front end to perform consistency checks and do further
1684      initialization based on the command line options.  This hook also
1685      sets the original filename if appropriate (e.g. foo.i -> foo.c)
1686      so we can correctly initialize debug output.  */
1687   no_backend = lang_hooks.post_options (&main_input_filename);
1688
1689 #ifdef OVERRIDE_OPTIONS
1690   /* Some machines may reject certain combinations of options.  */
1691   OVERRIDE_OPTIONS;
1692 #endif
1693
1694   if (flag_section_anchors && !target_supports_section_anchors_p ())
1695     {
1696       warning (OPT_fsection_anchors,
1697                "this target does not support %qs", "-fsection-anchors");
1698       flag_section_anchors = 0;
1699     }
1700
1701   if (flag_short_enums == 2)
1702     flag_short_enums = targetm.default_short_enums ();
1703
1704   /* Set aux_base_name if not already set.  */
1705   if (aux_base_name)
1706     ;
1707   else if (main_input_filename)
1708     {
1709       char *name = xstrdup (lbasename (main_input_filename));
1710
1711       strip_off_ending (name, strlen (name));
1712       aux_base_name = name;
1713     }
1714   else
1715     aux_base_name = "gccaux";
1716
1717 #ifndef HAVE_cloog
1718   if (flag_graphite
1719       || flag_loop_block
1720       || flag_loop_interchange
1721       || flag_loop_strip_mine
1722       || flag_graphite_identity)
1723     sorry ("Graphite loop optimizations cannot be used");
1724 #endif
1725
1726   /* Unrolling all loops implies that standard loop unrolling must also
1727      be done.  */
1728   if (flag_unroll_all_loops)
1729     flag_unroll_loops = 1;
1730
1731   /* The loop unrolling code assumes that cse will be run after loop.
1732      web and rename-registers also help when run after loop unrolling.  */
1733
1734   if (flag_rerun_cse_after_loop == AUTODETECT_VALUE)
1735     flag_rerun_cse_after_loop = flag_unroll_loops || flag_peel_loops;
1736   if (flag_web == AUTODETECT_VALUE)
1737     flag_web = flag_unroll_loops || flag_peel_loops;
1738   if (flag_rename_registers == AUTODETECT_VALUE)
1739     flag_rename_registers = flag_unroll_loops || flag_peel_loops;
1740
1741   if (flag_non_call_exceptions)
1742     flag_asynchronous_unwind_tables = 1;
1743   if (flag_asynchronous_unwind_tables)
1744     flag_unwind_tables = 1;
1745
1746   if (flag_value_profile_transformations)
1747     flag_profile_values = 1;
1748
1749   /* Warn about options that are not supported on this machine.  */
1750 #ifndef INSN_SCHEDULING
1751   if (flag_schedule_insns || flag_schedule_insns_after_reload)
1752     warning (0, "instruction scheduling not supported on this target machine");
1753 #endif
1754 #ifndef DELAY_SLOTS
1755   if (flag_delayed_branch)
1756     warning (0, "this target machine does not have delayed branches");
1757 #endif
1758
1759   user_label_prefix = USER_LABEL_PREFIX;
1760   if (flag_leading_underscore != -1)
1761     {
1762       /* If the default prefix is more complicated than "" or "_",
1763          issue a warning and ignore this option.  */
1764       if (user_label_prefix[0] == 0 ||
1765           (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1766         {
1767           user_label_prefix = flag_leading_underscore ? "_" : "";
1768         }
1769       else
1770         warning (0, "-f%sleading-underscore not supported on this target machine",
1771                  flag_leading_underscore ? "" : "no-");
1772     }
1773
1774   /* If we are in verbose mode, write out the version and maybe all the
1775      option flags in use.  */
1776   if (version_flag)
1777     {
1778       print_version (stderr, "");
1779       if (! quiet_flag)
1780         print_switch_values (print_to_stderr);
1781     }
1782
1783   if (flag_syntax_only)
1784     {
1785       write_symbols = NO_DEBUG;
1786       profile_flag = 0;
1787     }
1788
1789   /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1790      level is 0.  */
1791   if (debug_info_level == DINFO_LEVEL_NONE)
1792     write_symbols = NO_DEBUG;
1793
1794   /* Now we know write_symbols, set up the debug hooks based on it.
1795      By default we do nothing for debug output.  */
1796   if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
1797     default_debug_hooks = &do_nothing_debug_hooks;
1798 #if defined(DBX_DEBUGGING_INFO)
1799   else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
1800     default_debug_hooks = &dbx_debug_hooks;
1801 #endif
1802 #if defined(XCOFF_DEBUGGING_INFO)
1803   else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
1804     default_debug_hooks = &xcoff_debug_hooks;
1805 #endif
1806 #ifdef SDB_DEBUGGING_INFO
1807   else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
1808     default_debug_hooks = &sdb_debug_hooks;
1809 #endif
1810 #ifdef DWARF2_DEBUGGING_INFO
1811   else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
1812     default_debug_hooks = &dwarf2_debug_hooks;
1813 #endif
1814 #ifdef VMS_DEBUGGING_INFO
1815   else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
1816            || PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
1817     default_debug_hooks = &vmsdbg_debug_hooks;
1818 #endif
1819
1820   if (write_symbols == NO_DEBUG)
1821     ;
1822 #if defined(DBX_DEBUGGING_INFO)
1823   else if (write_symbols == DBX_DEBUG)
1824     debug_hooks = &dbx_debug_hooks;
1825 #endif
1826 #if defined(XCOFF_DEBUGGING_INFO)
1827   else if (write_symbols == XCOFF_DEBUG)
1828     debug_hooks = &xcoff_debug_hooks;
1829 #endif
1830 #ifdef SDB_DEBUGGING_INFO
1831   else if (write_symbols == SDB_DEBUG)
1832     debug_hooks = &sdb_debug_hooks;
1833 #endif
1834 #ifdef DWARF2_DEBUGGING_INFO
1835   else if (write_symbols == DWARF2_DEBUG)
1836     debug_hooks = &dwarf2_debug_hooks;
1837 #endif
1838 #ifdef VMS_DEBUGGING_INFO
1839   else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1840     debug_hooks = &vmsdbg_debug_hooks;
1841 #endif
1842   else
1843     error ("target system does not support the \"%s\" debug format",
1844            debug_type_names[write_symbols]);
1845
1846   /* Now we know which debug output will be used so we can set
1847      flag_var_tracking, flag_rename_registers if the user has
1848      not specified them.  */
1849   if (debug_info_level < DINFO_LEVEL_NORMAL
1850       || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
1851     {
1852       if (flag_var_tracking == 1
1853           || flag_var_tracking_uninit == 1)
1854         {
1855           if (debug_info_level < DINFO_LEVEL_NORMAL)
1856             warning (0, "variable tracking requested, but useless unless "
1857                      "producing debug info");
1858           else
1859             warning (0, "variable tracking requested, but not supported "
1860                      "by this debug format");
1861         }
1862       flag_var_tracking = 0;
1863       flag_var_tracking_uninit = 0;
1864     }
1865
1866   if (flag_rename_registers == AUTODETECT_VALUE)
1867     flag_rename_registers = default_debug_hooks->var_location
1868                             != do_nothing_debug_hooks.var_location;
1869
1870   if (flag_var_tracking == AUTODETECT_VALUE)
1871     flag_var_tracking = optimize >= 1;
1872
1873   if (flag_tree_cselim == AUTODETECT_VALUE)
1874 #ifdef HAVE_conditional_move
1875     flag_tree_cselim = 1;
1876 #else
1877     flag_tree_cselim = 0;
1878 #endif
1879
1880   /* If the user specifically requested variable tracking with tagging
1881      uninitialized variables, we need to turn on variable tracking.
1882      (We already determined above that variable tracking is feasible.)  */
1883   if (flag_var_tracking_uninit)
1884     flag_var_tracking = 1;
1885
1886   /* If auxiliary info generation is desired, open the output file.
1887      This goes in the same directory as the source file--unlike
1888      all the other output files.  */
1889   if (flag_gen_aux_info)
1890     {
1891       aux_info_file = fopen (aux_info_file_name, "w");
1892       if (aux_info_file == 0)
1893         fatal_error ("can%'t open %s: %m", aux_info_file_name);
1894     }
1895
1896   if (! targetm.have_named_sections)
1897     {
1898       if (flag_function_sections)
1899         {
1900           warning (0, "-ffunction-sections not supported for this target");
1901           flag_function_sections = 0;
1902         }
1903       if (flag_data_sections)
1904         {
1905           warning (0, "-fdata-sections not supported for this target");
1906           flag_data_sections = 0;
1907         }
1908     }
1909
1910   if (flag_function_sections && profile_flag)
1911     {
1912       warning (0, "-ffunction-sections disabled; it makes profiling impossible");
1913       flag_function_sections = 0;
1914     }
1915
1916 #ifndef HAVE_prefetch
1917   if (flag_prefetch_loop_arrays)
1918     {
1919       warning (0, "-fprefetch-loop-arrays not supported for this target");
1920       flag_prefetch_loop_arrays = 0;
1921     }
1922 #else
1923   if (flag_prefetch_loop_arrays && !HAVE_prefetch)
1924     {
1925       warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
1926       flag_prefetch_loop_arrays = 0;
1927     }
1928 #endif
1929
1930   /* This combination of options isn't handled for i386 targets and doesn't
1931      make much sense anyway, so don't allow it.  */
1932   if (flag_prefetch_loop_arrays && optimize_size)
1933     {
1934       warning (0, "-fprefetch-loop-arrays is not supported with -Os");
1935       flag_prefetch_loop_arrays = 0;
1936     }
1937
1938   /* The presence of IEEE signaling NaNs, implies all math can trap.  */
1939   if (flag_signaling_nans)
1940     flag_trapping_math = 1;
1941
1942   /* We cannot reassociate if we want traps or signed zeros.  */
1943   if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
1944     {
1945       warning (0, "-fassociative-math disabled; other options take precedence");
1946       flag_associative_math = 0;
1947     }
1948
1949   /* With -fcx-limited-range, we do cheap and quick complex arithmetic.  */
1950   if (flag_cx_limited_range)
1951     flag_complex_method = 0;
1952
1953   /* With -fcx-fortran-rules, we do something in-between cheap and C99.  */
1954   if (flag_cx_fortran_rules)
1955     flag_complex_method = 1;
1956
1957   /* Targets must be able to place spill slots at lower addresses.  If the
1958      target already uses a soft frame pointer, the transition is trivial.  */
1959   if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
1960     {
1961       warning (0, "-fstack-protector not supported for this target");
1962       flag_stack_protect = 0;
1963     }
1964   if (!flag_stack_protect)
1965     warn_stack_protect = 0;
1966
1967   /* ??? Unwind info is not correct around the CFG unless either a frame
1968      pointer is present or A_O_A is set.  Fixing this requires rewriting
1969      unwind info generation to be aware of the CFG and propagating states
1970      around edges.  */
1971   if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
1972       && flag_omit_frame_pointer)
1973     {
1974       warning (0, "unwind tables currently require a frame pointer "
1975                "for correctness");
1976       flag_omit_frame_pointer = 0;
1977     }
1978 }
1979
1980 /* This function can be called multiple times to reinitialize the compiler
1981    back end when register classes or instruction sets have changed,
1982    before each function.  */
1983 static void
1984 backend_init_target (void)
1985 {
1986   /* Initialize alignment variables.  */
1987   init_alignments ();
1988
1989   /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
1990      to initialize reg_raw_mode[].  */
1991   init_emit_regs ();
1992
1993   /* This invokes target hooks to set fixed_reg[] etc, which is
1994      mode-dependent.  */
1995   init_regs ();
1996
1997   /* This depends on stack_pointer_rtx.  */
1998   init_fake_stack_mems ();
1999
2000   /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
2001      mode-dependent.  */
2002   init_alias_target ();
2003
2004   /* Depends on HARD_FRAME_POINTER_REGNUM.  */
2005   init_reload ();
2006
2007   /* The following initialization functions need to generate rtl, so
2008      provide a dummy function context for them.  */
2009   init_dummy_function_start ();
2010
2011   /* rtx_cost is mode-dependent, so cached values need to be recomputed
2012      on a mode change.  */
2013   init_expmed ();
2014
2015   /* We may need to recompute regno_save_code[] and regno_restore_code[]
2016      after a mode change as well.  */
2017   if (flag_caller_saves)
2018     init_caller_save ();
2019   expand_dummy_function_end ();
2020 }
2021
2022 /* Initialize the compiler back end.  This function is called only once,
2023    when starting the compiler.  */
2024 static void
2025 backend_init (void)
2026 {
2027   init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
2028                   || debug_info_level == DINFO_LEVEL_VERBOSE
2029 #ifdef VMS_DEBUGGING_INFO
2030                     /* Enable line number info for traceback.  */
2031                     || debug_info_level > DINFO_LEVEL_NONE
2032 #endif
2033                     || flag_test_coverage);
2034
2035   init_rtlanal ();
2036   init_inline_once ();
2037   init_varasm_once ();
2038   save_register_info ();
2039
2040   /* Initialize the target-specific back end pieces.  */
2041   ira_init_once ();
2042   backend_init_target ();
2043 }
2044
2045 /* Initialize excess precision settings.  */
2046 static void
2047 init_excess_precision (void)
2048 {
2049   /* Adjust excess precision handling based on the target options.  If
2050      the front end cannot handle it, flag_excess_precision_cmdline
2051      will already have been set accordingly in the post_options
2052      hook.  */
2053   gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
2054   flag_excess_precision = flag_excess_precision_cmdline;
2055   if (flag_unsafe_math_optimizations)
2056     flag_excess_precision = EXCESS_PRECISION_FAST;
2057   if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
2058     {
2059       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
2060       switch (flt_eval_method)
2061         {
2062         case -1:
2063         case 0:
2064           /* Either the target acts unpredictably (-1) or has all the
2065              operations required not to have excess precision (0).  */
2066           flag_excess_precision = EXCESS_PRECISION_FAST;
2067           break;
2068         case 1:
2069         case 2:
2070           /* In these cases, predictable excess precision makes
2071              sense.  */
2072           break;
2073         default:
2074           /* Any other implementation-defined FLT_EVAL_METHOD values
2075              require the compiler to handle the associated excess
2076              precision rules in excess_precision_type.  */
2077           gcc_unreachable ();
2078         }
2079     }
2080 }
2081
2082 /* Initialize things that are both lang-dependent and target-dependent.
2083    This function can be called more than once if target parameters change.  */
2084 static void
2085 lang_dependent_init_target (void)
2086 {
2087   /* This determines excess precision settings.  */
2088   init_excess_precision ();
2089
2090   /* This creates various _DECL nodes, so needs to be called after the
2091      front end is initialized.  It also depends on the HAVE_xxx macros
2092      generated from the target machine description.  */
2093   init_optabs ();
2094
2095   /* The following initialization functions need to generate rtl, so
2096      provide a dummy function context for them.  */
2097   init_dummy_function_start ();
2098
2099   /* Do the target-specific parts of expr initialization.  */
2100   init_expr_target ();
2101
2102   /* Although the actions of these functions are language-independent,
2103      they use optabs, so we cannot call them from backend_init.  */
2104   init_set_costs ();
2105   ira_init ();
2106
2107   expand_dummy_function_end ();
2108 }
2109
2110 /* Language-dependent initialization.  Returns nonzero on success.  */
2111 static int
2112 lang_dependent_init (const char *name)
2113 {
2114   location_t save_loc = input_location;
2115   if (dump_base_name == 0)
2116     dump_base_name = name && name[0] ? name : "gccdump";
2117
2118   /* Other front-end initialization.  */
2119   input_location = BUILTINS_LOCATION;
2120   if (lang_hooks.init () == 0)
2121     return 0;
2122   input_location = save_loc;
2123
2124   init_asm_output (name);
2125
2126   /* This creates various _DECL nodes, so needs to be called after the
2127      front end is initialized.  */
2128   init_eh ();
2129
2130   /* Do the target-specific parts of the initialization.  */
2131   lang_dependent_init_target ();
2132
2133   /* If dbx symbol table desired, initialize writing it and output the
2134      predefined types.  */
2135   timevar_push (TV_SYMOUT);
2136
2137 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
2138   if (dwarf2out_do_frame ())
2139     dwarf2out_frame_init ();
2140 #endif
2141
2142   /* Now we have the correct original filename, we can initialize
2143      debug output.  */
2144   (*debug_hooks->init) (name);
2145
2146   timevar_pop (TV_SYMOUT);
2147
2148   return 1;
2149 }
2150
2151
2152 /* Reinitialize everything when target parameters, such as register usage,
2153    have changed.  */
2154 void
2155 target_reinit (void)
2156 {
2157   /* Reinitialize RTL backend.  */
2158   backend_init_target ();
2159
2160   /* Reinitialize lang-dependent parts.  */
2161   lang_dependent_init_target ();
2162 }
2163
2164 void
2165 dump_memory_report (bool final)
2166 {
2167   ggc_print_statistics ();
2168   stringpool_statistics ();
2169   dump_tree_statistics ();
2170   dump_gimple_statistics ();
2171   dump_rtx_statistics ();
2172   dump_varray_statistics ();
2173   dump_alloc_pool_statistics ();
2174   dump_bitmap_statistics ();
2175   dump_vec_loc_statistics ();
2176   dump_ggc_loc_statistics (final);
2177   dump_alias_stats (stderr);
2178   dump_pta_stats (stderr);
2179 }
2180
2181 /* Clean up: close opened files, etc.  */
2182
2183 static void
2184 finalize (void)
2185 {
2186   /* Close the dump files.  */
2187   if (flag_gen_aux_info)
2188     {
2189       fclose (aux_info_file);
2190       if (errorcount)
2191         unlink (aux_info_file_name);
2192     }
2193
2194   /* Close non-debugging input and output files.  Take special care to note
2195      whether fclose returns an error, since the pages might still be on the
2196      buffer chain while the file is open.  */
2197
2198   if (asm_out_file)
2199     {
2200       if (ferror (asm_out_file) != 0)
2201         fatal_error ("error writing to %s: %m", asm_file_name);
2202       if (fclose (asm_out_file) != 0)
2203         fatal_error ("error closing %s: %m", asm_file_name);
2204     }
2205
2206   statistics_fini ();
2207   finish_optimization_passes ();
2208
2209   ira_finish_once ();
2210
2211   if (mem_report)
2212     dump_memory_report (true);
2213
2214   /* Language-specific end of compilation actions.  */
2215   lang_hooks.finish ();
2216 }
2217
2218 /* Initialize the compiler, and compile the input file.  */
2219 static void
2220 do_compile (void)
2221 {
2222   /* Initialize timing first.  The C front ends read the main file in
2223      the post_options hook, and C++ does file timings.  */
2224   if (time_report || !quiet_flag  || flag_detailed_statistics)
2225     timevar_init ();
2226   timevar_start (TV_TOTAL);
2227
2228   process_options ();
2229
2230   /* Don't do any more if an error has already occurred.  */
2231   if (!errorcount)
2232     {
2233       /* This must be run always, because it is needed to compute the FP
2234          predefined macros, such as __LDBL_MAX__, for targets using non
2235          default FP formats.  */
2236       init_adjust_machine_modes ();
2237
2238       /* Set up the back-end if requested.  */
2239       if (!no_backend)
2240         backend_init ();
2241
2242       /* Language-dependent initialization.  Returns true on success.  */
2243       if (lang_dependent_init (main_input_filename))
2244         compile_file ();
2245
2246       finalize ();
2247
2248       /* Invoke registered plugin callbacks.  */
2249       invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
2250     }
2251
2252   /* Stop timing and print the times.  */
2253   timevar_stop (TV_TOTAL);
2254   timevar_print (stderr);
2255 }
2256
2257 /* Entry point of cc1, cc1plus, jc1, f771, etc.
2258    Exit code is FATAL_EXIT_CODE if can't open files or if there were
2259    any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2260
2261    It is not safe to call this function more than once.  */
2262
2263 int
2264 toplev_main (int argc, char **argv)
2265 {
2266   expandargv (&argc, &argv);
2267
2268   save_argv = (const char **) argv;
2269
2270   /* Initialization of GCC's environment, and diagnostics.  */
2271   general_init (argv[0]);
2272
2273   /* Parse the options and do minimal processing; basically just
2274      enough to default flags appropriately.  */
2275   decode_options (argc, (const char **) argv);
2276
2277   init_local_tick ();
2278
2279   initialize_plugins ();
2280
2281   if (version_flag)
2282     print_version (stderr, "");
2283
2284   if (help_flag)
2285     print_plugins_help (stderr, "");
2286
2287   /* Exit early if we can (e.g. -help).  */
2288   if (!exit_after_options)
2289     do_compile ();
2290
2291   if (warningcount || errorcount) 
2292     print_ignored_options ();
2293
2294   /* Invoke registered plugin callbacks if any.  */
2295   invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
2296
2297   finalize_plugins ();
2298   if (errorcount || sorrycount)
2299     return (FATAL_EXIT_CODE);
2300
2301   return (SUCCESS_EXIT_CODE);
2302 }