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