OSDN Git Service

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