OSDN Git Service

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