OSDN Git Service

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