OSDN Git Service

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