OSDN Git Service

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