OSDN Git Service

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