OSDN Git Service

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