OSDN Git Service

* toplev.c (default_get_pch_validity): Rename argument to "sz".
[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, 2007, 2008, 2009, 2010
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 3, 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 COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
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 "ira.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 #include "tree-pass.h"
86 #include "gimple.h"
87 #include "tree-ssa-alias.h"
88 #include "plugin.h"
89
90 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
91 #include "dwarf2out.h"
92 #endif
93
94 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
95 #include "dbxout.h"
96 #endif
97
98 #ifdef SDB_DEBUGGING_INFO
99 #include "sdbout.h"
100 #endif
101
102 #ifdef XCOFF_DEBUGGING_INFO
103 #include "xcoffout.h"           /* Needed for external data
104                                    declarations for e.g. AIX 4.x.  */
105 #endif
106
107 static void general_init (const char *);
108 static void do_compile (void);
109 static void process_options (void);
110 static void backend_init (void);
111 static int lang_dependent_init (const char *);
112 static void init_asm_output (const char *);
113 static void finalize (void);
114
115 static void crash_signal (int) ATTRIBUTE_NORETURN;
116 static void setup_core_dumping (void);
117 static void compile_file (void);
118
119 /* Nonzero to dump debug info whilst parsing (-dy option).  */
120 static int set_yydebug;
121
122 /* True if we don't need a backend (e.g. preprocessing only).  */
123 static bool no_backend;
124
125 /* Length of line when printing switch values.  */
126 #define MAX_LINE 75
127
128 /* Name of program invoked, sans directories.  */
129
130 const char *progname;
131
132 /* Copy of argument vector to toplev_main.  */
133 static const char **save_argv;
134
135 /* Name of top-level original source file (what was input to cpp).
136    This comes from the #-command at the beginning of the actual input.
137    If there isn't any there, then this is the cc1 input file name.  */
138
139 const char *main_input_filename;
140
141 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
142    to optimize and default_debug_hooks in process_options ().  */
143 #define AUTODETECT_VALUE 2
144
145 /* Current position in real source file.  */
146
147 location_t input_location;
148
149 struct line_maps *line_table;
150
151 /* Name to use as base of names for dump output files.  */
152
153 const char *dump_base_name;
154
155 /* Directory used for dump output files.  */
156
157 const char *dump_dir_name;
158
159 /* Name to use as a base for auxiliary output files.  */
160
161 const char *aux_base_name;
162
163 /* Prefix for profile data files */
164 const char *profile_data_prefix;
165
166 /* A mask of target_flags that includes bit X if X was set or cleared
167    on the command line.  */
168
169 int target_flags_explicit;
170
171 /* Debug hooks - dependent upon command line options.  */
172
173 const struct gcc_debug_hooks *debug_hooks;
174
175 /* Debug hooks - target default.  */
176
177 static const struct gcc_debug_hooks *default_debug_hooks;
178
179 /* Other flags saying which kinds of debugging dump have been requested.  */
180
181 int rtl_dump_and_exit;
182 int flag_print_asm_name;
183 enum graph_dump_types graph_dump_format;
184
185 /* Name for output file of assembly code, specified with -o.  */
186
187 const char *asm_file_name;
188
189 /* Nonzero means do optimizations.  -O.
190    Particular numeric values stand for particular amounts of optimization;
191    thus, -O2 stores 2 here.  However, the optimizations beyond the basic
192    ones are not controlled directly by this variable.  Instead, they are
193    controlled by individual `flag_...' variables that are defaulted
194    based on this variable.  */
195
196 int optimize = 0;
197
198 /* Nonzero means optimize for size.  -Os.
199    The only valid values are zero and nonzero. When optimize_size is
200    nonzero, optimize defaults to 2, but certain individual code
201    bloating optimizations are disabled.  */
202
203 int optimize_size = 0;
204
205 /* True if this is the lto front end.  This is used to disable
206    gimple generation and lowering passes that are normally run on the
207    output of a front end.  These passes must be bypassed for lto since
208    they have already been done before the gimple was written.  */
209
210 bool in_lto_p = false;
211
212 /* Nonzero if we should write GIMPLE bytecode for link-time optimization.  */
213
214 int flag_generate_lto;
215
216 /* The FUNCTION_DECL for the function currently being compiled,
217    or 0 if between functions.  */
218 tree current_function_decl;
219
220 /* Set to the FUNC_BEGIN label of the current function, or NULL
221    if none.  */
222 const char * current_function_func_begin_label;
223
224 /* Nonzero means to collect statistics which might be expensive
225    and to print them when we are done.  */
226 int flag_detailed_statistics = 0;
227
228 /* A random sequence of characters, unless overridden by user.  */
229 static const char *flag_random_seed;
230
231 /* A local time stamp derived from the time of compilation. It will be
232    zero if the system cannot provide a time.  It will be -1u, if the
233    user has specified a particular random seed.  */
234 unsigned local_tick;
235
236 /* -f flags.  */
237
238 /* Nonzero means `char' should be signed.  */
239
240 int flag_signed_char;
241
242 /* Nonzero means give an enum type only as many bytes as it needs.  A value
243    of 2 means it has not yet been initialized.  */
244
245 int flag_short_enums;
246
247 /* Nonzero if structures and unions should be returned in memory.
248
249    This should only be defined if compatibility with another compiler or
250    with an ABI is needed, because it results in slower code.  */
251
252 #ifndef DEFAULT_PCC_STRUCT_RETURN
253 #define DEFAULT_PCC_STRUCT_RETURN 1
254 #endif
255
256 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
257
258 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
259
260 /* 0 means straightforward implementation of complex divide acceptable.
261    1 means wide ranges of inputs must work for complex divide.
262    2 means C99-like requirements for complex multiply and divide.  */
263
264 int flag_complex_method = 1;
265
266 /* Nonzero means we should be saving declaration info into a .X file.  */
267
268 int flag_gen_aux_info = 0;
269
270 /* Specified name of aux-info file.  */
271
272 const char *aux_info_file_name;
273
274 /* Nonzero if we are compiling code for a shared library, zero for
275    executable.  */
276
277 int flag_shlib;
278
279 /* Generate code for GNU or NeXT Objective-C runtime environment.  */
280
281 #ifdef NEXT_OBJC_RUNTIME
282 int flag_next_runtime = 1;
283 #else
284 int flag_next_runtime = 0;
285 #endif
286
287 /* Set to the default thread-local storage (tls) model to use.  */
288
289 enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
290
291 /* Set the default region and algorithm for the integrated register
292    allocator.  */
293
294 enum ira_algorithm flag_ira_algorithm = IRA_ALGORITHM_CB;
295 enum ira_region flag_ira_region = IRA_REGION_MIXED;
296
297 /* Set the default value for -fira-verbose.  */
298
299 unsigned int flag_ira_verbose = 5;
300
301 /* Set the default for excess precision.  */
302
303 enum excess_precision flag_excess_precision_cmdline = EXCESS_PRECISION_DEFAULT;
304 enum excess_precision flag_excess_precision = EXCESS_PRECISION_DEFAULT;
305
306 /* Nonzero means change certain warnings into errors.
307    Usually these are warnings about failure to conform to some standard.  */
308
309 int flag_pedantic_errors = 0;
310
311 /* Nonzero means make permerror produce warnings instead of errors.  */
312
313 int flag_permissive = 0;
314
315 /* -dA causes debug commentary information to be produced in
316    the generated assembly code (to make it more readable).  This option
317    is generally only of use to those who actually need to read the
318    generated assembly code (perhaps while debugging the compiler itself).
319    Currently, this switch is only used by dwarfout.c; however, it is intended
320    to be a catchall for printing debug information in the assembler file.  */
321
322 int flag_debug_asm = 0;
323
324 /* -dP causes the rtl to be emitted as a comment in assembly.  */
325
326 int flag_dump_rtl_in_asm = 0;
327
328 /* When non-NULL, indicates that whenever space is allocated on the
329    stack, the resulting stack pointer must not pass this
330    address---that is, for stacks that grow downward, the stack pointer
331    must always be greater than or equal to this address; for stacks
332    that grow upward, the stack pointer must be less than this address.
333    At present, the rtx may be either a REG or a SYMBOL_REF, although
334    the support provided depends on the backend.  */
335 rtx stack_limit_rtx;
336
337 /* Positive if we should track variables, negative if we should run
338    the var-tracking pass only to discard debug annotations, zero if
339    we're not to run it.  When flag_var_tracking == AUTODETECT_VALUE it
340    will be set according to optimize, debug_info_level and debug_hooks
341    in process_options ().  */
342 int flag_var_tracking = AUTODETECT_VALUE;
343
344 /* Positive if we should track variables at assignments, negative if
345    we should run the var-tracking pass only to discard debug
346    annotations.  When flag_var_tracking_assignments ==
347    AUTODETECT_VALUE it will be set according to flag_var_tracking.  */
348 int flag_var_tracking_assignments = AUTODETECT_VALUE;
349
350 /* Nonzero if we should toggle flag_var_tracking_assignments after
351    processing options and computing its default.  */
352 int flag_var_tracking_assignments_toggle = 0;
353
354 /* Type of stack check.  */
355 enum stack_check_type flag_stack_check = NO_STACK_CHECK;
356
357 /* True if the user has tagged the function with the 'section'
358    attribute.  */
359
360 bool user_defined_section_attribute = false;
361
362 /* Values of the -falign-* flags: how much to align labels in code.
363    0 means `use default', 1 means `don't align'.
364    For each variable, there is an _log variant which is the power
365    of two not less than the variable, for .align output.  */
366
367 int align_loops_log;
368 int align_loops_max_skip;
369 int align_jumps_log;
370 int align_jumps_max_skip;
371 int align_labels_log;
372 int align_labels_max_skip;
373 int align_functions_log;
374
375 typedef struct
376 {
377   const char *const string;
378   int *const variable;
379   const int on_value;
380 }
381 lang_independent_options;
382
383 /* Nonzero if subexpressions must be evaluated from left-to-right.  */
384 int flag_evaluation_order = 0;
385
386 /* The user symbol prefix after having resolved same.  */
387 const char *user_label_prefix;
388
389 static const param_info lang_independent_params[] = {
390 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
391   { OPTION, DEFAULT, false, MIN, MAX, HELP },
392 #include "params.def"
393 #undef DEFPARAM
394   { NULL, 0, false, 0, 0, NULL }
395 };
396
397 /* Output files for assembler code (real compiler output)
398    and debugging dumps.  */
399
400 FILE *asm_out_file;
401 FILE *aux_info_file;
402 FILE *dump_file = NULL;
403 const char *dump_file_name;
404
405 /* The current working directory of a translation.  It's generally the
406    directory from which compilation was initiated, but a preprocessed
407    file may specify the original directory in which it was
408    created.  */
409
410 static const char *src_pwd;
411
412 /* Initialize src_pwd with the given string, and return true.  If it
413    was already initialized, return false.  As a special case, it may
414    be called with a NULL argument to test whether src_pwd has NOT been
415    initialized yet.  */
416
417 bool
418 set_src_pwd (const char *pwd)
419 {
420   if (src_pwd)
421     {
422       if (strcmp (src_pwd, pwd) == 0)
423         return true;
424       else
425         return false;
426     }
427
428   src_pwd = xstrdup (pwd);
429   return true;
430 }
431
432 /* Return the directory from which the translation unit was initiated,
433    in case set_src_pwd() was not called before to assign it a
434    different value.  */
435
436 const char *
437 get_src_pwd (void)
438 {
439   if (! src_pwd)
440     {
441       src_pwd = getpwd ();
442       if (!src_pwd)
443         src_pwd = ".";
444     }
445
446    return src_pwd;
447 }
448
449 /* Called when the start of a function definition is parsed,
450    this function prints on stderr the name of the function.  */
451 void
452 announce_function (tree decl)
453 {
454   if (!quiet_flag)
455     {
456       if (rtl_dump_and_exit)
457         fprintf (stderr, "%s ",
458                  identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl))));
459       else
460         fprintf (stderr, " %s",
461                  identifier_to_locale (lang_hooks.decl_printable_name (decl, 2)));
462       fflush (stderr);
463       pp_needs_newline (global_dc->printer) = true;
464       diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
465     }
466 }
467
468 /* Initialize local_tick with the time of day, or -1 if
469    flag_random_seed is set.  */
470
471 static void
472 init_local_tick (void)
473 {
474   if (!flag_random_seed)
475     {
476       /* Get some more or less random data.  */
477 #ifdef HAVE_GETTIMEOFDAY
478       {
479         struct timeval tv;
480
481         gettimeofday (&tv, NULL);
482         local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
483       }
484 #else
485       {
486         time_t now = time (NULL);
487
488         if (now != (time_t)-1)
489           local_tick = (unsigned) now;
490       }
491 #endif
492     }
493   else
494     local_tick = -1;
495 }
496
497 /* Set up a default flag_random_seed and local_tick, unless the user
498    already specified one.  Must be called after init_local_tick.  */
499
500 static void
501 init_random_seed (void)
502 {
503   unsigned HOST_WIDE_INT value;
504   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
505
506   value = local_tick ^ getpid ();
507
508   sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
509   flag_random_seed = random_seed;
510 }
511
512 /* Obtain the random_seed string.  Unless NOINIT, initialize it if
513    it's not provided in the command line.  */
514
515 const char *
516 get_random_seed (bool noinit)
517 {
518   if (!flag_random_seed && !noinit)
519     init_random_seed ();
520   return flag_random_seed;
521 }
522
523 /* Modify the random_seed string to VAL.  Return its previous
524    value.  */
525
526 const char *
527 set_random_seed (const char *val)
528 {
529   const char *old = flag_random_seed;
530   flag_random_seed = val;
531   return old;
532 }
533
534 /* Decode the string P as an integral parameter.
535    If the string is indeed an integer return its numeric value else
536    issue an Invalid Option error for the option PNAME and return DEFVAL.
537    If PNAME is zero just return DEFVAL, do not call error.  */
538
539 int
540 read_integral_parameter (const char *p, const char *pname, const int  defval)
541 {
542   const char *endp = p;
543
544   while (*endp)
545     {
546       if (ISDIGIT (*endp))
547         endp++;
548       else
549         break;
550     }
551
552   if (*endp != 0)
553     {
554       if (pname != 0)
555         error ("invalid option argument %qs", pname);
556       return defval;
557     }
558
559   return atoi (p);
560 }
561
562 #if GCC_VERSION < 3004
563
564 /* The functions floor_log2 and exact_log2 are defined as inline
565    functions in toplev.h if GCC_VERSION >= 3004.  The definitions here
566    are used for older versions of gcc.  */
567
568 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
569    If X is 0, return -1.  */
570
571 int
572 floor_log2 (unsigned HOST_WIDE_INT x)
573 {
574   int t = 0;
575
576   if (x == 0)
577     return -1;
578
579   if (HOST_BITS_PER_WIDE_INT > 64)
580     if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
581       t += 64;
582   if (HOST_BITS_PER_WIDE_INT > 32)
583     if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 32))
584       t += 32;
585   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 16))
586     t += 16;
587   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 8))
588     t += 8;
589   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 4))
590     t += 4;
591   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 2))
592     t += 2;
593   if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
594     t += 1;
595
596   return t;
597 }
598
599 /* Return the logarithm of X, base 2, considering X unsigned,
600    if X is a power of 2.  Otherwise, returns -1.  */
601
602 int
603 exact_log2 (unsigned HOST_WIDE_INT x)
604 {
605   if (x != (x & -x))
606     return -1;
607   return floor_log2 (x);
608 }
609
610 #endif /* GCC_VERSION < 3004 */
611
612 /* Handler for fatal signals, such as SIGSEGV.  These are transformed
613    into ICE messages, which is much more user friendly.  In case the
614    error printer crashes, reset the signal to prevent infinite recursion.  */
615
616 static void
617 crash_signal (int signo)
618 {
619   signal (signo, SIG_DFL);
620
621   /* If we crashed while processing an ASM statement, then be a little more
622      graceful.  It's most likely the user's fault.  */
623   if (this_is_asm_operands)
624     {
625       output_operand_lossage ("unrecoverable error");
626       exit (FATAL_EXIT_CODE);
627     }
628
629   internal_error ("%s", strsignal (signo));
630 }
631
632 /* Arrange to dump core on error.  (The regular error message is still
633    printed first, except in the case of abort().)  */
634
635 static void
636 setup_core_dumping (void)
637 {
638 #ifdef SIGABRT
639   signal (SIGABRT, SIG_DFL);
640 #endif
641 #if defined(HAVE_SETRLIMIT)
642   {
643     struct rlimit rlim;
644     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
645       fatal_error ("getting core file size maximum limit: %m");
646     rlim.rlim_cur = rlim.rlim_max;
647     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
648       fatal_error ("setting core file size limit to maximum: %m");
649   }
650 #endif
651   diagnostic_abort_on_error (global_dc);
652 }
653
654
655 /* Strip off a legitimate source ending from the input string NAME of
656    length LEN.  Rather than having to know the names used by all of
657    our front ends, we strip off an ending of a period followed by
658    up to five characters.  (Java uses ".class".)  */
659
660 void
661 strip_off_ending (char *name, int len)
662 {
663   int i;
664   for (i = 2; i < 6 && len > i; i++)
665     {
666       if (name[len - i] == '.')
667         {
668           name[len - i] = '\0';
669           break;
670         }
671     }
672 }
673
674 /* Output a quoted string.  */
675
676 void
677 output_quoted_string (FILE *asm_file, const char *string)
678 {
679 #ifdef OUTPUT_QUOTED_STRING
680   OUTPUT_QUOTED_STRING (asm_file, string);
681 #else
682   char c;
683
684   putc ('\"', asm_file);
685   while ((c = *string++) != 0)
686     {
687       if (ISPRINT (c))
688         {
689           if (c == '\"' || c == '\\')
690             putc ('\\', asm_file);
691           putc (c, asm_file);
692         }
693       else
694         fprintf (asm_file, "\\%03o", (unsigned char) c);
695     }
696   putc ('\"', asm_file);
697 #endif
698 }
699
700 /* Output a file name in the form wanted by System V.  */
701
702 void
703 output_file_directive (FILE *asm_file, const char *input_name)
704 {
705   int len;
706   const char *na;
707
708   if (input_name == NULL)
709     input_name = "<stdin>";
710   else
711     input_name = remap_debug_filename (input_name);
712
713   len = strlen (input_name);
714   na = input_name + len;
715
716   /* NA gets INPUT_NAME sans directory names.  */
717   while (na > input_name)
718     {
719       if (IS_DIR_SEPARATOR (na[-1]))
720         break;
721       na--;
722     }
723
724 #ifdef ASM_OUTPUT_SOURCE_FILENAME
725   ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
726 #else
727   fprintf (asm_file, "\t.file\t");
728   output_quoted_string (asm_file, na);
729   putc ('\n', asm_file);
730 #endif
731 }
732
733 /* A subroutine of wrapup_global_declarations.  We've come to the end of
734    the compilation unit.  All deferred variables should be undeferred,
735    and all incomplete decls should be finalized.  */
736
737 void
738 wrapup_global_declaration_1 (tree decl)
739 {
740   /* We're not deferring this any longer.  Assignment is conditional to
741      avoid needlessly dirtying PCH pages.  */
742   if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
743       && DECL_DEFER_OUTPUT (decl) != 0)
744     DECL_DEFER_OUTPUT (decl) = 0;
745
746   if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
747     lang_hooks.finish_incomplete_decl (decl);
748 }
749
750 /* A subroutine of wrapup_global_declarations.  Decide whether or not DECL
751    needs to be output.  Return true if it is output.  */
752
753 bool
754 wrapup_global_declaration_2 (tree decl)
755 {
756   if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
757     return false;
758
759   /* Don't write out static consts, unless we still need them.
760
761      We also keep static consts if not optimizing (for debugging),
762      unless the user specified -fno-keep-static-consts.
763      ??? They might be better written into the debug information.
764      This is possible when using DWARF.
765
766      A language processor that wants static constants to be always
767      written out (even if it is not used) is responsible for
768      calling rest_of_decl_compilation itself.  E.g. the C front-end
769      calls rest_of_decl_compilation from finish_decl.
770      One motivation for this is that is conventional in some
771      environments to write things like:
772      static const char rcsid[] = "... version string ...";
773      intending to force the string to be in the executable.
774
775      A language processor that would prefer to have unneeded
776      static constants "optimized away" would just defer writing
777      them out until here.  E.g. C++ does this, because static
778      constants are often defined in header files.
779
780      ??? A tempting alternative (for both C and C++) would be
781      to force a constant to be written if and only if it is
782      defined in a main file, as opposed to an include file.  */
783
784   if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
785     {
786       struct varpool_node *node;
787       bool needed = true;
788       node = varpool_node (decl);
789
790       if (node->finalized)
791         needed = false;
792       else if (node->alias)
793         needed = false;
794       else if (!cgraph_global_info_ready
795                && (TREE_USED (decl)
796                    || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
797         /* needed */;
798       else if (node->needed)
799         /* needed */;
800       else if (DECL_COMDAT (decl))
801         needed = false;
802       else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
803                && (optimize || !flag_keep_static_consts
804                    || DECL_ARTIFICIAL (decl)))
805         needed = false;
806
807       if (needed)
808         {
809           rest_of_decl_compilation (decl, 1, 1);
810           return true;
811         }
812     }
813
814   return false;
815 }
816
817 /* Do any final processing required for the declarations in VEC, of
818    which there are LEN.  We write out inline functions and variables
819    that have been deferred until this point, but which are required.
820    Returns nonzero if anything was put out.  */
821
822 bool
823 wrapup_global_declarations (tree *vec, int len)
824 {
825   bool reconsider, output_something = false;
826   int i;
827
828   for (i = 0; i < len; i++)
829     wrapup_global_declaration_1 (vec[i]);
830
831   /* Now emit any global variables or functions that we have been
832      putting off.  We need to loop in case one of the things emitted
833      here references another one which comes earlier in the list.  */
834   do
835     {
836       reconsider = false;
837       for (i = 0; i < len; i++)
838         reconsider |= wrapup_global_declaration_2 (vec[i]);
839       if (reconsider)
840         output_something = true;
841     }
842   while (reconsider);
843
844   return output_something;
845 }
846
847 /* A subroutine of check_global_declarations.  Issue appropriate warnings
848    for the global declaration DECL.  */
849
850 void
851 check_global_declaration_1 (tree decl)
852 {
853   /* Warn about any function declared static but not defined.  We don't
854      warn about variables, because many programs have static variables
855      that exist only to get some text into the object file.  */
856   if (TREE_CODE (decl) == FUNCTION_DECL
857       && DECL_INITIAL (decl) == 0
858       && DECL_EXTERNAL (decl)
859       && ! DECL_ARTIFICIAL (decl)
860       && ! TREE_NO_WARNING (decl)
861       && ! TREE_PUBLIC (decl)
862       && (warn_unused_function
863           || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
864     {
865       if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
866         pedwarn (input_location, 0, "%q+F used but never defined", decl);
867       else
868         warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl);
869       /* This symbol is effectively an "extern" declaration now.  */
870       TREE_PUBLIC (decl) = 1;
871       assemble_external (decl);
872     }
873
874   /* Warn about static fns or vars defined but not used.  */
875   if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
876        /* We don't warn about "static const" variables because the
877           "rcs_id" idiom uses that construction.  */
878        || (warn_unused_variable
879            && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
880       && ! DECL_IN_SYSTEM_HEADER (decl)
881       && ! TREE_USED (decl)
882       /* The TREE_USED bit for file-scope decls is kept in the identifier,
883          to handle multiple external decls in different scopes.  */
884       && ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl)))
885       && ! DECL_EXTERNAL (decl)
886       && ! TREE_PUBLIC (decl)
887       /* A volatile variable might be used in some non-obvious way.  */
888       && ! TREE_THIS_VOLATILE (decl)
889       /* Global register variables must be declared to reserve them.  */
890       && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
891       /* Otherwise, ask the language.  */
892       && lang_hooks.decls.warn_unused_global (decl))
893     warning ((TREE_CODE (decl) == FUNCTION_DECL)
894              ? OPT_Wunused_function
895              : OPT_Wunused_variable,
896              "%q+D defined but not used", decl);
897 }
898
899 /* Issue appropriate warnings for the global declarations in VEC (of
900    which there are LEN).  */
901
902 void
903 check_global_declarations (tree *vec, int len)
904 {
905   int i;
906
907   for (i = 0; i < len; i++)
908     check_global_declaration_1 (vec[i]);
909 }
910
911 /* Emit debugging information for all global declarations in VEC.  */
912
913 void
914 emit_debug_global_declarations (tree *vec, int len)
915 {
916   int i;
917
918   /* Avoid confusing the debug information machinery when there are errors.  */
919   if (errorcount != 0 || sorrycount != 0)
920     return;
921
922   timevar_push (TV_SYMOUT);
923   for (i = 0; i < len; i++)
924     debug_hooks->global_decl (vec[i]);
925   timevar_pop (TV_SYMOUT);
926 }
927
928 /* Warn about a use of an identifier which was marked deprecated.  */
929 void
930 warn_deprecated_use (tree node, tree attr)
931 {
932   const char *msg;
933
934   if (node == 0 || !warn_deprecated_decl)
935     return;
936
937   if (!attr)
938     {
939       if (DECL_P (node))
940         attr = DECL_ATTRIBUTES (node);
941       else if (TYPE_P (node))
942         {
943           tree decl = TYPE_STUB_DECL (node);
944           if (decl)
945             attr = lookup_attribute ("deprecated",
946                                      TYPE_ATTRIBUTES (TREE_TYPE (decl)));
947         }
948     }
949
950   if (attr)
951     attr = lookup_attribute ("deprecated", attr);
952
953   if (attr)
954     msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
955   else
956     msg = NULL;
957
958   if (DECL_P (node))
959     {
960       expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
961       if (msg)
962         warning (OPT_Wdeprecated_declarations,
963                  "%qD is deprecated (declared at %s:%d): %s",
964                  node, xloc.file, xloc.line, msg);
965       else
966         warning (OPT_Wdeprecated_declarations,
967                  "%qD is deprecated (declared at %s:%d)",
968                  node, xloc.file, xloc.line);
969     }
970   else if (TYPE_P (node))
971     {
972       tree what = NULL_TREE;
973       tree decl = TYPE_STUB_DECL (node);
974
975       if (TYPE_NAME (node))
976         {
977           if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
978             what = TYPE_NAME (node);
979           else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
980                    && DECL_NAME (TYPE_NAME (node)))
981             what = DECL_NAME (TYPE_NAME (node));
982         }
983
984       if (decl)
985         {
986           expanded_location xloc
987             = expand_location (DECL_SOURCE_LOCATION (decl));
988           if (what)
989             {
990               if (msg)
991                 warning (OPT_Wdeprecated_declarations,
992                          "%qE is deprecated (declared at %s:%d): %s",
993                          what, xloc.file, xloc.line, msg);
994               else
995                 warning (OPT_Wdeprecated_declarations,
996                          "%qE is deprecated (declared at %s:%d)", what,
997                          xloc.file, xloc.line);
998             }
999           else
1000             {
1001               if (msg)
1002                 warning (OPT_Wdeprecated_declarations,
1003                          "type is deprecated (declared at %s:%d): %s",
1004                          xloc.file, xloc.line, msg);
1005               else
1006                 warning (OPT_Wdeprecated_declarations,
1007                          "type is deprecated (declared at %s:%d)",
1008                          xloc.file, xloc.line);
1009             }
1010         }
1011       else
1012         {
1013           if (what)
1014             {
1015               if (msg)
1016                 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
1017                          what, msg);
1018               else
1019                 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
1020             }
1021           else
1022             {
1023               if (msg)
1024                 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
1025                          msg);
1026               else
1027                 warning (OPT_Wdeprecated_declarations, "type is deprecated");
1028             }
1029         }
1030     }
1031 }
1032
1033 /* Compile an entire translation unit.  Write a file of assembly
1034    output and various debugging dumps.  */
1035
1036 static void
1037 compile_file (void)
1038 {
1039   /* Initialize yet another pass.  */
1040
1041   ggc_protect_identifiers = true;
1042
1043   init_cgraph ();
1044   init_final (main_input_filename);
1045   coverage_init (aux_base_name);
1046   statistics_init ();
1047   invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
1048
1049   timevar_push (TV_PARSE);
1050
1051   /* Call the parser, which parses the entire file (calling
1052      rest_of_compilation for each function).  */
1053   lang_hooks.parse_file (set_yydebug);
1054
1055   /* Compilation is now finished except for writing
1056      what's left of the symbol table output.  */
1057   timevar_pop (TV_PARSE);
1058
1059   if (flag_syntax_only)
1060     return;
1061
1062   ggc_protect_identifiers = false;
1063
1064   /* This must also call cgraph_finalize_compilation_unit.  */
1065   lang_hooks.decls.final_write_globals ();
1066
1067   if (errorcount || sorrycount)
1068     return;
1069
1070   varpool_assemble_pending_decls ();
1071   finish_aliases_2 ();
1072
1073   /* Likewise for mudflap static object registrations.  */
1074   if (flag_mudflap)
1075     mudflap_finish_file ();
1076
1077   /* Likewise for emulated thread-local storage.  */
1078   if (!targetm.have_tls)
1079     emutls_finish ();
1080
1081   output_shared_constant_pool ();
1082   output_object_blocks ();
1083
1084   /* Write out any pending weak symbol declarations.  */
1085   weak_finish ();
1086
1087   /* Do dbx symbols.  */
1088   timevar_push (TV_SYMOUT);
1089
1090 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
1091   if (dwarf2out_do_frame ())
1092     dwarf2out_frame_finish ();
1093 #endif
1094
1095   (*debug_hooks->finish) (main_input_filename);
1096   timevar_pop (TV_SYMOUT);
1097
1098   /* Output some stuff at end of file if nec.  */
1099
1100   dw2_output_indirect_constants ();
1101
1102   /* Flush any pending external directives.  */
1103   process_pending_assemble_externals ();
1104
1105   /* Emit LTO marker if LTO info has been previously emitted.  This is
1106      used by collect2 to determine whether an object file contains IL.
1107      We used to emit an undefined reference here, but this produces
1108      link errors if an object file with IL is stored into a shared
1109      library without invoking lto1.  */
1110   if (flag_generate_lto)
1111     {
1112 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1113       ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE,
1114                                       "__gnu_lto_v1",
1115                                       (unsigned HOST_WIDE_INT) 1, 8);
1116 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1117       ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1",
1118                                  (unsigned HOST_WIDE_INT) 1, 8);
1119 #else
1120       ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1",
1121                          (unsigned HOST_WIDE_INT) 1,
1122                          (unsigned HOST_WIDE_INT) 1);
1123 #endif
1124     }
1125
1126   /* Attach a special .ident directive to the end of the file to identify
1127      the version of GCC which compiled this code.  The format of the .ident
1128      string is patterned after the ones produced by native SVR4 compilers.  */
1129 #ifdef IDENT_ASM_OP
1130   if (!flag_no_ident)
1131     {
1132       const char *pkg_version = "(GNU) ";
1133
1134       if (strcmp ("(GCC) ", pkgversion_string))
1135         pkg_version = pkgversion_string;
1136       fprintf (asm_out_file, "%s\"GCC: %s%s\"\n",
1137                IDENT_ASM_OP, pkg_version, version_string);
1138     }
1139 #endif
1140
1141   /* Invoke registered plugin callbacks.  */
1142   invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
1143
1144   /* This must be at the end.  Some target ports emit end of file directives
1145      into the assembly file here, and hence we can not output anything to the
1146      assembly file after this point.  */
1147   targetm.asm_out.file_end ();
1148 }
1149
1150 /* Parse a -d... command line switch.  */
1151
1152 void
1153 decode_d_option (const char *arg)
1154 {
1155   int c;
1156
1157   while (*arg)
1158     switch (c = *arg++)
1159       {
1160       case 'A':
1161         flag_debug_asm = 1;
1162         break;
1163       case 'p':
1164         flag_print_asm_name = 1;
1165         break;
1166       case 'P':
1167         flag_dump_rtl_in_asm = 1;
1168         flag_print_asm_name = 1;
1169         break;
1170       case 'v':
1171         graph_dump_format = vcg;
1172         break;
1173       case 'x':
1174         rtl_dump_and_exit = 1;
1175         break;
1176       case 'y':
1177         set_yydebug = 1;
1178         break;
1179       case 'D': /* These are handled by the preprocessor.  */
1180       case 'I':
1181       case 'M':
1182       case 'N':
1183       case 'U':
1184         break;
1185       case 'H':
1186         setup_core_dumping();
1187         break;
1188       case 'a':
1189         enable_rtl_dump_file ();
1190         break;
1191
1192       default:
1193           warning (0, "unrecognized gcc debugging option: %c", c);
1194         break;
1195       }
1196 }
1197
1198 /* Indexed by enum debug_info_type.  */
1199 const char *const debug_type_names[] =
1200 {
1201   "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
1202 };
1203
1204 /* Print version information to FILE.
1205    Each line begins with INDENT (for the case where FILE is the
1206    assembler output file).  */
1207
1208 void
1209 print_version (FILE *file, const char *indent)
1210 {
1211   static const char fmt1[] =
1212 #ifdef __GNUC__
1213     N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
1214 #else
1215     N_("%s%s%s %sversion %s (%s) compiled by CC, ")
1216 #endif
1217     ;
1218   static const char fmt2[] =
1219     N_("GMP version %s, MPFR version %s, MPC version %s\n");
1220   static const char fmt3[] =
1221     N_("%s%swarning: %s header version %s differs from library version %s.\n");
1222   static const char fmt4[] =
1223     N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
1224 #ifndef __VERSION__
1225 #define __VERSION__ "[?]"
1226 #endif
1227   fprintf (file,
1228            file == stderr ? _(fmt1) : fmt1,
1229            indent, *indent != 0 ? " " : "",
1230            lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
1231            indent, __VERSION__);
1232
1233   /* We need to stringify the GMP macro values.  Ugh, gmp_version has
1234      two string formats, "i.j.k" and "i.j" when k is zero.  As of
1235      gmp-4.3.0, GMP always uses the 3 number format.  */
1236 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
1237 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
1238 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
1239 #define GCC_GMP_VERSION \
1240   GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
1241 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
1242 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
1243   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
1244 #else
1245 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
1246   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
1247   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
1248 #endif
1249   fprintf (file,
1250            file == stderr ? _(fmt2) : fmt2,
1251            GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING);
1252   if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
1253     fprintf (file,
1254              file == stderr ? _(fmt3) : fmt3,
1255              indent, *indent != 0 ? " " : "",
1256              "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
1257   if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
1258     fprintf (file,
1259              file == stderr ? _(fmt3) : fmt3,
1260              indent, *indent != 0 ? " " : "",
1261              "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
1262   if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
1263     fprintf (file,
1264              file == stderr ? _(fmt3) : fmt3,
1265              indent, *indent != 0 ? " " : "",
1266              "MPC", MPC_VERSION_STRING, mpc_get_version ());
1267   fprintf (file,
1268            file == stderr ? _(fmt4) : fmt4,
1269            indent, *indent != 0 ? " " : "",
1270            PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
1271
1272   print_plugins_versions (file, indent);
1273 }
1274
1275 #ifdef ASM_COMMENT_START
1276 static int
1277 print_to_asm_out_file (print_switch_type type, const char * text)
1278 {
1279   bool prepend_sep = true;
1280
1281   switch (type)
1282     {
1283     case SWITCH_TYPE_LINE_END:
1284       putc ('\n', asm_out_file);
1285       return 1;
1286
1287     case SWITCH_TYPE_LINE_START:
1288       fputs (ASM_COMMENT_START, asm_out_file);
1289       return strlen (ASM_COMMENT_START);
1290
1291     case SWITCH_TYPE_DESCRIPTIVE:
1292       if (ASM_COMMENT_START[0] == 0)
1293         prepend_sep = false;
1294       /* Drop through.  */
1295     case SWITCH_TYPE_PASSED:
1296     case SWITCH_TYPE_ENABLED:
1297       if (prepend_sep)
1298         fputc (' ', asm_out_file);
1299       fputs (text, asm_out_file);
1300       /* No need to return the length here as
1301          print_single_switch has already done it.  */
1302       return 0;
1303
1304     default:
1305       return -1;
1306     }
1307 }
1308 #endif
1309
1310 static int
1311 print_to_stderr (print_switch_type type, const char * text)
1312 {
1313   switch (type)
1314     {
1315     case SWITCH_TYPE_LINE_END:
1316       putc ('\n', stderr);
1317       return 1;
1318
1319     case SWITCH_TYPE_LINE_START:
1320       return 0;
1321
1322     case SWITCH_TYPE_PASSED:
1323     case SWITCH_TYPE_ENABLED:
1324       fputc (' ', stderr);
1325       /* Drop through.  */
1326
1327     case SWITCH_TYPE_DESCRIPTIVE:
1328       fputs (text, stderr);
1329       /* No need to return the length here as
1330          print_single_switch has already done it.  */
1331       return 0;
1332
1333     default:
1334       return -1;
1335     }
1336 }
1337
1338 /* Print an option value and return the adjusted position in the line.
1339    ??? print_fn doesn't handle errors, eg disk full; presumably other
1340    code will catch a disk full though.  */
1341
1342 static int
1343 print_single_switch (print_switch_fn_type print_fn,
1344                      int pos,
1345                      print_switch_type type,
1346                      const char * text)
1347 {
1348   /* The ultrix fprintf returns 0 on success, so compute the result
1349      we want here since we need it for the following test.  The +1
1350      is for the separator character that will probably be emitted.  */
1351   int len = strlen (text) + 1;
1352
1353   if (pos != 0
1354       && pos + len > MAX_LINE)
1355     {
1356       print_fn (SWITCH_TYPE_LINE_END, NULL);
1357       pos = 0;
1358     }
1359
1360   if (pos == 0)
1361     pos += print_fn (SWITCH_TYPE_LINE_START, NULL);
1362
1363   print_fn (type, text);
1364   return pos + len;
1365 }
1366
1367 /* Print active target switches using PRINT_FN.
1368    POS is the current cursor position and MAX is the size of a "line".
1369    Each line begins with INDENT and ends with TERM.
1370    Each switch is separated from the next by SEP.  */
1371
1372 static void
1373 print_switch_values (print_switch_fn_type print_fn)
1374 {
1375   int pos = 0;
1376   size_t j;
1377   const char **p;
1378
1379   /* Fill in the -frandom-seed option, if the user didn't pass it, so
1380      that it can be printed below.  This helps reproducibility.  */
1381   if (!flag_random_seed)
1382     init_random_seed ();
1383
1384   /* Print the options as passed.  */
1385   pos = print_single_switch (print_fn, pos,
1386                              SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
1387
1388   for (p = &save_argv[1]; *p != NULL; p++)
1389     {
1390       if (**p == '-')
1391         {
1392           /* Ignore these.  */
1393           if (strcmp (*p, "-o") == 0
1394               || strcmp (*p, "-dumpbase") == 0
1395               || strcmp (*p, "-dumpdir") == 0
1396               || strcmp (*p, "-auxbase") == 0)
1397             {
1398               if (p[1] != NULL)
1399                 p++;
1400               continue;
1401             }
1402
1403           if (strcmp (*p, "-quiet") == 0
1404               || strcmp (*p, "-version") == 0)
1405             continue;
1406
1407           if ((*p)[1] == 'd')
1408             continue;
1409         }
1410
1411       pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED, *p);
1412     }
1413
1414   if (pos > 0)
1415     print_fn (SWITCH_TYPE_LINE_END, NULL);
1416
1417   /* Print the -f and -m options that have been enabled.
1418      We don't handle language specific options but printing argv
1419      should suffice.  */
1420   pos = print_single_switch (print_fn, 0,
1421                              SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
1422
1423   for (j = 0; j < cl_options_count; j++)
1424     if ((cl_options[j].flags & CL_REPORT)
1425         && option_enabled (j) > 0)
1426       pos = print_single_switch (print_fn, pos,
1427                                  SWITCH_TYPE_ENABLED, cl_options[j].opt_text);
1428
1429   print_fn (SWITCH_TYPE_LINE_END, NULL);
1430 }
1431
1432 /* Open assembly code output file.  Do this even if -fsyntax-only is
1433    on, because then the driver will have provided the name of a
1434    temporary file or bit bucket for us.  NAME is the file specified on
1435    the command line, possibly NULL.  */
1436 static void
1437 init_asm_output (const char *name)
1438 {
1439   if (name == NULL && asm_file_name == 0)
1440     asm_out_file = stdout;
1441   else
1442     {
1443       if (asm_file_name == 0)
1444         {
1445           int len = strlen (dump_base_name);
1446           char *dumpname = XNEWVEC (char, len + 6);
1447
1448           memcpy (dumpname, dump_base_name, len + 1);
1449           strip_off_ending (dumpname, len);
1450           strcat (dumpname, ".s");
1451           asm_file_name = dumpname;
1452         }
1453       if (!strcmp (asm_file_name, "-"))
1454         asm_out_file = stdout;
1455       else
1456         asm_out_file = fopen (asm_file_name, "w+b");
1457       if (asm_out_file == 0)
1458         fatal_error ("can%'t open %s for writing: %m", asm_file_name);
1459     }
1460
1461   if (!flag_syntax_only)
1462     {
1463       targetm.asm_out.file_start ();
1464
1465       if (flag_record_gcc_switches)
1466         {
1467           if (targetm.asm_out.record_gcc_switches)
1468             {
1469               /* Let the target know that we are about to start recording.  */
1470               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
1471                                                    NULL);
1472               /* Now record the switches.  */
1473               print_switch_values (targetm.asm_out.record_gcc_switches);
1474               /* Let the target know that the recording is over.  */
1475               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
1476                                                    NULL);
1477             }
1478           else
1479             inform (input_location, "-frecord-gcc-switches is not supported by the current target");
1480         }
1481
1482 #ifdef ASM_COMMENT_START
1483       if (flag_verbose_asm)
1484         {
1485           /* Print the list of switches in effect
1486              into the assembler file as comments.  */
1487           print_version (asm_out_file, ASM_COMMENT_START);
1488           print_switch_values (print_to_asm_out_file);
1489           putc ('\n', asm_out_file);
1490         }
1491 #endif
1492     }
1493 }
1494
1495 /* Return true if the state of option OPTION should be stored in PCH files
1496    and checked by default_pch_valid_p.  Store the option's current state
1497    in STATE if so.  */
1498
1499 static inline bool
1500 option_affects_pch_p (int option, struct cl_option_state *state)
1501 {
1502   if ((cl_options[option].flags & CL_TARGET) == 0)
1503     return false;
1504   if (cl_options[option].flag_var == &target_flags)
1505     if (targetm.check_pch_target_flags)
1506       return false;
1507   return get_option_state (option, state);
1508 }
1509
1510 /* Default version of get_pch_validity.
1511    By default, every flag difference is fatal; that will be mostly right for
1512    most targets, but completely right for very few.  */
1513
1514 void *
1515 default_get_pch_validity (size_t *sz)
1516 {
1517   struct cl_option_state state;
1518   size_t i;
1519   char *result, *r;
1520
1521   *sz = 2;
1522   if (targetm.check_pch_target_flags)
1523     *sz += sizeof (target_flags);
1524   for (i = 0; i < cl_options_count; i++)
1525     if (option_affects_pch_p (i, &state))
1526       *sz += state.size;
1527
1528   result = r = XNEWVEC (char, *sz);
1529   r[0] = flag_pic;
1530   r[1] = flag_pie;
1531   r += 2;
1532   if (targetm.check_pch_target_flags)
1533     {
1534       memcpy (r, &target_flags, sizeof (target_flags));
1535       r += sizeof (target_flags);
1536     }
1537
1538   for (i = 0; i < cl_options_count; i++)
1539     if (option_affects_pch_p (i, &state))
1540       {
1541         memcpy (r, state.data, state.size);
1542         r += state.size;
1543       }
1544
1545   return result;
1546 }
1547
1548 /* Return a message which says that a PCH file was created with a different
1549    setting of OPTION.  */
1550
1551 static const char *
1552 pch_option_mismatch (const char *option)
1553 {
1554   char *r;
1555
1556   asprintf (&r, _("created and used with differing settings of '%s'"), option);
1557   if (r == NULL)
1558     return _("out of memory");
1559   return r;
1560 }
1561
1562 /* Default version of pch_valid_p.  */
1563
1564 const char *
1565 default_pch_valid_p (const void *data_p, size_t len)
1566 {
1567   struct cl_option_state state;
1568   const char *data = (const char *)data_p;
1569   size_t i;
1570
1571   /* -fpic and -fpie also usually make a PCH invalid.  */
1572   if (data[0] != flag_pic)
1573     return _("created and used with different settings of -fpic");
1574   if (data[1] != flag_pie)
1575     return _("created and used with different settings of -fpie");
1576   data += 2;
1577
1578   /* Check target_flags.  */
1579   if (targetm.check_pch_target_flags)
1580     {
1581       int tf;
1582       const char *r;
1583
1584       memcpy (&tf, data, sizeof (target_flags));
1585       data += sizeof (target_flags);
1586       len -= sizeof (target_flags);
1587       r = targetm.check_pch_target_flags (tf);
1588       if (r != NULL)
1589         return r;
1590     }
1591
1592   for (i = 0; i < cl_options_count; i++)
1593     if (option_affects_pch_p (i, &state))
1594       {
1595         if (memcmp (data, state.data, state.size) != 0)
1596           return pch_option_mismatch (cl_options[i].opt_text);
1597         data += state.size;
1598         len -= state.size;
1599       }
1600
1601   return NULL;
1602 }
1603
1604 /* Default tree printer.   Handles declarations only.  */
1605 bool
1606 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
1607                       int precision, bool wide, bool set_locus, bool hash)
1608 {
1609   tree t;
1610
1611   /* FUTURE: %+x should set the locus.  */
1612   if (precision != 0 || wide || hash)
1613     return false;
1614
1615   switch (*spec)
1616     {
1617     case 'E':
1618       t = va_arg (*text->args_ptr, tree);
1619       if (TREE_CODE (t) == IDENTIFIER_NODE)
1620         {
1621           pp_identifier (pp, IDENTIFIER_POINTER (t));
1622           return true;
1623         }
1624       break;
1625
1626     case 'D':
1627       t = va_arg (*text->args_ptr, tree);
1628       if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
1629         t = DECL_DEBUG_EXPR (t);
1630       break;
1631
1632     case 'F':
1633     case 'T':
1634       t = va_arg (*text->args_ptr, tree);
1635       break;
1636
1637     default:
1638       return false;
1639     }
1640
1641   if (set_locus && text->locus)
1642     *text->locus = DECL_SOURCE_LOCATION (t);
1643
1644   if (DECL_P (t))
1645     {
1646       const char *n = DECL_NAME (t)
1647         ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
1648         : _("<anonymous>");
1649       pp_string (pp, n);
1650     }
1651   else
1652     dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0);
1653
1654   return true;
1655 }
1656
1657 /* A helper function; used as the reallocator function for cpp's line
1658    table.  */
1659 static void *
1660 realloc_for_line_map (void *ptr, size_t len)
1661 {
1662   return ggc_realloc (ptr, len);
1663 }
1664
1665 /* Initialization of the front end environment, before command line
1666    options are parsed.  Signal handlers, internationalization etc.
1667    ARGV0 is main's argv[0].  */
1668 static void
1669 general_init (const char *argv0)
1670 {
1671   const char *p;
1672
1673   p = argv0 + strlen (argv0);
1674   while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
1675     --p;
1676   progname = p;
1677
1678   xmalloc_set_program_name (progname);
1679
1680   hex_init ();
1681
1682   /* Unlock the stdio streams.  */
1683   unlock_std_streams ();
1684
1685   gcc_init_libintl ();
1686
1687   /* Initialize the diagnostics reporting machinery, so option parsing
1688      can give warnings and errors.  */
1689   diagnostic_initialize (global_dc);
1690   /* Set a default printer.  Language specific initializations will
1691      override it later.  */
1692   pp_format_decoder (global_dc->printer) = &default_tree_printer;
1693
1694   /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages.  */
1695 #ifdef SIGSEGV
1696   signal (SIGSEGV, crash_signal);
1697 #endif
1698 #ifdef SIGILL
1699   signal (SIGILL, crash_signal);
1700 #endif
1701 #ifdef SIGBUS
1702   signal (SIGBUS, crash_signal);
1703 #endif
1704 #ifdef SIGABRT
1705   signal (SIGABRT, crash_signal);
1706 #endif
1707 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1708   signal (SIGIOT, crash_signal);
1709 #endif
1710 #ifdef SIGFPE
1711   signal (SIGFPE, crash_signal);
1712 #endif
1713
1714   /* Other host-specific signal setup.  */
1715   (*host_hooks.extra_signals)();
1716
1717   /* Initialize the garbage-collector, string pools and tree type hash
1718      table.  */
1719   init_ggc ();
1720   init_stringpool ();
1721   line_table = GGC_NEW (struct line_maps);
1722   linemap_init (line_table);
1723   line_table->reallocator = realloc_for_line_map;
1724   init_ttree ();
1725
1726   /* Initialize register usage now so switches may override.  */
1727   init_reg_sets ();
1728
1729   /* Register the language-independent parameters.  */
1730   add_params (lang_independent_params, LAST_PARAM);
1731
1732   /* This must be done after add_params but before argument processing.  */
1733   init_ggc_heuristics();
1734   init_optimization_passes ();
1735   statistics_early_init ();
1736 }
1737
1738 /* Return true if the current target supports -fsection-anchors.  */
1739
1740 static bool
1741 target_supports_section_anchors_p (void)
1742 {
1743   if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
1744     return false;
1745
1746   if (targetm.asm_out.output_anchor == NULL)
1747     return false;
1748
1749   return true;
1750 }
1751
1752 /* Default the align_* variables to 1 if they're still unset, and
1753    set up the align_*_log variables.  */
1754 static void
1755 init_alignments (void)
1756 {
1757   if (align_loops <= 0)
1758     align_loops = 1;
1759   if (align_loops_max_skip > align_loops)
1760     align_loops_max_skip = align_loops - 1;
1761   align_loops_log = floor_log2 (align_loops * 2 - 1);
1762   if (align_jumps <= 0)
1763     align_jumps = 1;
1764   if (align_jumps_max_skip > align_jumps)
1765     align_jumps_max_skip = align_jumps - 1;
1766   align_jumps_log = floor_log2 (align_jumps * 2 - 1);
1767   if (align_labels <= 0)
1768     align_labels = 1;
1769   align_labels_log = floor_log2 (align_labels * 2 - 1);
1770   if (align_labels_max_skip > align_labels)
1771     align_labels_max_skip = align_labels - 1;
1772   if (align_functions <= 0)
1773     align_functions = 1;
1774   align_functions_log = floor_log2 (align_functions * 2 - 1);
1775 }
1776
1777 /* Process the options that have been parsed.  */
1778 static void
1779 process_options (void)
1780 {
1781   /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1782      This can happen with incorrect pre-processed input. */
1783   debug_hooks = &do_nothing_debug_hooks;
1784
1785   /* This replaces set_Wunused.  */
1786   if (warn_unused_function == -1)
1787     warn_unused_function = warn_unused;
1788   if (warn_unused_label == -1)
1789     warn_unused_label = warn_unused;
1790   /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled.  */
1791   if (warn_unused_parameter == -1)
1792     warn_unused_parameter = (warn_unused && extra_warnings);
1793   if (warn_unused_variable == -1)
1794     warn_unused_variable = warn_unused;
1795   if (warn_unused_value == -1)
1796     warn_unused_value = warn_unused;
1797
1798   /* This replaces set_Wextra.  */
1799   if (warn_uninitialized == -1)
1800     warn_uninitialized = extra_warnings;
1801
1802   /* Allow the front end to perform consistency checks and do further
1803      initialization based on the command line options.  This hook also
1804      sets the original filename if appropriate (e.g. foo.i -> foo.c)
1805      so we can correctly initialize debug output.  */
1806   no_backend = lang_hooks.post_options (&main_input_filename);
1807
1808 #ifdef OVERRIDE_OPTIONS
1809   /* Some machines may reject certain combinations of options.  */
1810   OVERRIDE_OPTIONS;
1811 #endif
1812
1813   if (flag_section_anchors && !target_supports_section_anchors_p ())
1814     {
1815       warning (OPT_fsection_anchors,
1816                "this target does not support %qs", "-fsection-anchors");
1817       flag_section_anchors = 0;
1818     }
1819
1820   if (flag_short_enums == 2)
1821     flag_short_enums = targetm.default_short_enums ();
1822
1823   /* Set aux_base_name if not already set.  */
1824   if (aux_base_name)
1825     ;
1826   else if (main_input_filename)
1827     {
1828       char *name = xstrdup (lbasename (main_input_filename));
1829
1830       strip_off_ending (name, strlen (name));
1831       aux_base_name = name;
1832     }
1833   else
1834     aux_base_name = "gccaux";
1835
1836 #ifndef HAVE_cloog
1837   if (flag_graphite
1838       || flag_loop_block
1839       || flag_loop_interchange
1840       || flag_loop_strip_mine
1841       || flag_graphite_identity
1842       || flag_loop_parallelize_all)
1843     sorry ("Graphite loop optimizations cannot be used");
1844 #endif
1845
1846   /* Unrolling all loops implies that standard loop unrolling must also
1847      be done.  */
1848   if (flag_unroll_all_loops)
1849     flag_unroll_loops = 1;
1850
1851   /* The loop unrolling code assumes that cse will be run after loop.
1852      web and rename-registers also help when run after loop unrolling.  */
1853   if (flag_rerun_cse_after_loop == AUTODETECT_VALUE)
1854     flag_rerun_cse_after_loop = flag_unroll_loops || flag_peel_loops;
1855
1856   if (flag_web == AUTODETECT_VALUE)
1857     flag_web = flag_unroll_loops || flag_peel_loops;
1858
1859   if (flag_rename_registers == AUTODETECT_VALUE)
1860     flag_rename_registers = flag_unroll_loops || flag_peel_loops;
1861
1862   if (flag_non_call_exceptions)
1863     flag_asynchronous_unwind_tables = 1;
1864   if (flag_asynchronous_unwind_tables)
1865     flag_unwind_tables = 1;
1866
1867   if (flag_value_profile_transformations)
1868     flag_profile_values = 1;
1869
1870   /* Warn about options that are not supported on this machine.  */
1871 #ifndef INSN_SCHEDULING
1872   if (flag_schedule_insns || flag_schedule_insns_after_reload)
1873     warning (0, "instruction scheduling not supported on this target machine");
1874 #endif
1875 #ifndef DELAY_SLOTS
1876   if (flag_delayed_branch)
1877     warning (0, "this target machine does not have delayed branches");
1878 #endif
1879
1880   user_label_prefix = USER_LABEL_PREFIX;
1881   if (flag_leading_underscore != -1)
1882     {
1883       /* If the default prefix is more complicated than "" or "_",
1884          issue a warning and ignore this option.  */
1885       if (user_label_prefix[0] == 0 ||
1886           (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1887         {
1888           user_label_prefix = flag_leading_underscore ? "_" : "";
1889         }
1890       else
1891         warning (0, "-f%sleading-underscore not supported on this target machine",
1892                  flag_leading_underscore ? "" : "no-");
1893     }
1894
1895   /* If we are in verbose mode, write out the version and maybe all the
1896      option flags in use.  */
1897   if (version_flag)
1898     {
1899       print_version (stderr, "");
1900       if (! quiet_flag)
1901         print_switch_values (print_to_stderr);
1902     }
1903
1904   if (flag_syntax_only)
1905     {
1906       write_symbols = NO_DEBUG;
1907       profile_flag = 0;
1908     }
1909
1910   if (flag_gtoggle)
1911     {
1912       if (debug_info_level == DINFO_LEVEL_NONE)
1913         {
1914           debug_info_level = DINFO_LEVEL_NORMAL;
1915
1916           if (write_symbols == NO_DEBUG)
1917             write_symbols = PREFERRED_DEBUGGING_TYPE;
1918         }
1919       else
1920         debug_info_level = DINFO_LEVEL_NONE;
1921     }
1922
1923   if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
1924     {
1925       FILE *final_output = fopen (flag_dump_final_insns, "w");
1926       if (!final_output)
1927         {
1928           error ("could not open final insn dump file %qs: %s",
1929                  flag_dump_final_insns, strerror (errno));
1930           flag_dump_final_insns = NULL;
1931         }
1932       else if (fclose (final_output))
1933         {
1934           error ("could not close zeroed insn dump file %qs: %s",
1935                  flag_dump_final_insns, strerror (errno));
1936           flag_dump_final_insns = NULL;
1937         }
1938     }
1939
1940   /* Unless over-ridden for the target, assume that all DWARF levels
1941      may be emitted, if DWARF2_DEBUG is selected.  */
1942   if (dwarf_strict < 0)
1943     dwarf_strict = 0;
1944
1945   /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1946      level is 0.  */
1947   if (debug_info_level == DINFO_LEVEL_NONE)
1948     write_symbols = NO_DEBUG;
1949
1950   /* Now we know write_symbols, set up the debug hooks based on it.
1951      By default we do nothing for debug output.  */
1952   if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
1953     default_debug_hooks = &do_nothing_debug_hooks;
1954 #if defined(DBX_DEBUGGING_INFO)
1955   else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
1956     default_debug_hooks = &dbx_debug_hooks;
1957 #endif
1958 #if defined(XCOFF_DEBUGGING_INFO)
1959   else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
1960     default_debug_hooks = &xcoff_debug_hooks;
1961 #endif
1962 #ifdef SDB_DEBUGGING_INFO
1963   else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
1964     default_debug_hooks = &sdb_debug_hooks;
1965 #endif
1966 #ifdef DWARF2_DEBUGGING_INFO
1967   else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
1968     default_debug_hooks = &dwarf2_debug_hooks;
1969 #endif
1970 #ifdef VMS_DEBUGGING_INFO
1971   else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
1972            || PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
1973     default_debug_hooks = &vmsdbg_debug_hooks;
1974 #endif
1975
1976   if (write_symbols == NO_DEBUG)
1977     ;
1978 #if defined(DBX_DEBUGGING_INFO)
1979   else if (write_symbols == DBX_DEBUG)
1980     debug_hooks = &dbx_debug_hooks;
1981 #endif
1982 #if defined(XCOFF_DEBUGGING_INFO)
1983   else if (write_symbols == XCOFF_DEBUG)
1984     debug_hooks = &xcoff_debug_hooks;
1985 #endif
1986 #ifdef SDB_DEBUGGING_INFO
1987   else if (write_symbols == SDB_DEBUG)
1988     debug_hooks = &sdb_debug_hooks;
1989 #endif
1990 #ifdef DWARF2_DEBUGGING_INFO
1991   else if (write_symbols == DWARF2_DEBUG)
1992     debug_hooks = &dwarf2_debug_hooks;
1993 #endif
1994 #ifdef VMS_DEBUGGING_INFO
1995   else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1996     debug_hooks = &vmsdbg_debug_hooks;
1997 #endif
1998   else
1999     error ("target system does not support the \"%s\" debug format",
2000            debug_type_names[write_symbols]);
2001
2002   /* We know which debug output will be used so we can set flag_var_tracking
2003      and flag_var_tracking_uninit if the user has not specified them.  */
2004   if (debug_info_level < DINFO_LEVEL_NORMAL
2005       || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
2006     {
2007       if (flag_var_tracking == 1
2008           || flag_var_tracking_uninit == 1)
2009         {
2010           if (debug_info_level < DINFO_LEVEL_NORMAL)
2011             warning (0, "variable tracking requested, but useless unless "
2012                      "producing debug info");
2013           else
2014             warning (0, "variable tracking requested, but not supported "
2015                      "by this debug format");
2016         }
2017       flag_var_tracking = 0;
2018       flag_var_tracking_uninit = 0;
2019     }
2020
2021   /* If the user specifically requested variable tracking with tagging
2022      uninitialized variables, we need to turn on variable tracking.
2023      (We already determined above that variable tracking is feasible.)  */
2024   if (flag_var_tracking_uninit)
2025     flag_var_tracking = 1;
2026
2027   if (flag_var_tracking == AUTODETECT_VALUE)
2028     flag_var_tracking = optimize >= 1;
2029
2030   if (flag_var_tracking_assignments == AUTODETECT_VALUE)
2031     flag_var_tracking_assignments = flag_var_tracking
2032       && !(flag_selective_scheduling || flag_selective_scheduling2);
2033
2034   if (flag_var_tracking_assignments_toggle)
2035     flag_var_tracking_assignments = !flag_var_tracking_assignments;
2036
2037   if (flag_var_tracking_assignments && !flag_var_tracking)
2038     flag_var_tracking = flag_var_tracking_assignments = -1;
2039
2040   if (flag_var_tracking_assignments
2041       && (flag_selective_scheduling || flag_selective_scheduling2))
2042     warning (0, "var-tracking-assignments changes selective scheduling");
2043
2044   if (flag_tree_cselim == AUTODETECT_VALUE)
2045 #ifdef HAVE_conditional_move
2046     flag_tree_cselim = 1;
2047 #else
2048     flag_tree_cselim = 0;
2049 #endif
2050
2051   /* If auxiliary info generation is desired, open the output file.
2052      This goes in the same directory as the source file--unlike
2053      all the other output files.  */
2054   if (flag_gen_aux_info)
2055     {
2056       aux_info_file = fopen (aux_info_file_name, "w");
2057       if (aux_info_file == 0)
2058         fatal_error ("can%'t open %s: %m", aux_info_file_name);
2059     }
2060
2061   if (! targetm.have_named_sections)
2062     {
2063       if (flag_function_sections)
2064         {
2065           warning (0, "-ffunction-sections not supported for this target");
2066           flag_function_sections = 0;
2067         }
2068       if (flag_data_sections)
2069         {
2070           warning (0, "-fdata-sections not supported for this target");
2071           flag_data_sections = 0;
2072         }
2073     }
2074
2075   if (flag_function_sections && profile_flag)
2076     {
2077       warning (0, "-ffunction-sections disabled; it makes profiling impossible");
2078       flag_function_sections = 0;
2079     }
2080
2081 #ifndef HAVE_prefetch
2082   if (flag_prefetch_loop_arrays)
2083     {
2084       warning (0, "-fprefetch-loop-arrays not supported for this target");
2085       flag_prefetch_loop_arrays = 0;
2086     }
2087 #else
2088   if (flag_prefetch_loop_arrays && !HAVE_prefetch)
2089     {
2090       warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
2091       flag_prefetch_loop_arrays = 0;
2092     }
2093 #endif
2094
2095   /* This combination of options isn't handled for i386 targets and doesn't
2096      make much sense anyway, so don't allow it.  */
2097   if (flag_prefetch_loop_arrays && optimize_size)
2098     {
2099       warning (0, "-fprefetch-loop-arrays is not supported with -Os");
2100       flag_prefetch_loop_arrays = 0;
2101     }
2102
2103   /* The presence of IEEE signaling NaNs, implies all math can trap.  */
2104   if (flag_signaling_nans)
2105     flag_trapping_math = 1;
2106
2107   /* We cannot reassociate if we want traps or signed zeros.  */
2108   if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
2109     {
2110       warning (0, "-fassociative-math disabled; other options take precedence");
2111       flag_associative_math = 0;
2112     }
2113
2114   /* With -fcx-limited-range, we do cheap and quick complex arithmetic.  */
2115   if (flag_cx_limited_range)
2116     flag_complex_method = 0;
2117
2118   /* With -fcx-fortran-rules, we do something in-between cheap and C99.  */
2119   if (flag_cx_fortran_rules)
2120     flag_complex_method = 1;
2121
2122   /* Targets must be able to place spill slots at lower addresses.  If the
2123      target already uses a soft frame pointer, the transition is trivial.  */
2124   if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
2125     {
2126       warning (0, "-fstack-protector not supported for this target");
2127       flag_stack_protect = 0;
2128     }
2129   if (!flag_stack_protect)
2130     warn_stack_protect = 0;
2131
2132   /* ??? Unwind info is not correct around the CFG unless either a frame
2133      pointer is present or A_O_A is set.  Fixing this requires rewriting
2134      unwind info generation to be aware of the CFG and propagating states
2135      around edges.  */
2136   if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
2137       && flag_omit_frame_pointer)
2138     {
2139       warning (0, "unwind tables currently require a frame pointer "
2140                "for correctness");
2141       flag_omit_frame_pointer = 0;
2142     }
2143 }
2144
2145 /* This function can be called multiple times to reinitialize the compiler
2146    back end when register classes or instruction sets have changed,
2147    before each function.  */
2148 static void
2149 backend_init_target (void)
2150 {
2151   /* Initialize alignment variables.  */
2152   init_alignments ();
2153
2154   /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
2155      to initialize reg_raw_mode[].  */
2156   init_emit_regs ();
2157
2158   /* This invokes target hooks to set fixed_reg[] etc, which is
2159      mode-dependent.  */
2160   init_regs ();
2161
2162   /* This depends on stack_pointer_rtx.  */
2163   init_fake_stack_mems ();
2164
2165   /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
2166      mode-dependent.  */
2167   init_alias_target ();
2168
2169   /* Depends on HARD_FRAME_POINTER_REGNUM.  */
2170   init_reload ();
2171
2172   /* The following initialization functions need to generate rtl, so
2173      provide a dummy function context for them.  */
2174   init_dummy_function_start ();
2175
2176   /* rtx_cost is mode-dependent, so cached values need to be recomputed
2177      on a mode change.  */
2178   init_expmed ();
2179
2180   /* We may need to recompute regno_save_code[] and regno_restore_code[]
2181      after a mode change as well.  */
2182   if (flag_caller_saves)
2183     init_caller_save ();
2184   expand_dummy_function_end ();
2185 }
2186
2187 /* Initialize the compiler back end.  This function is called only once,
2188    when starting the compiler.  */
2189 static void
2190 backend_init (void)
2191 {
2192   init_emit_once ();
2193
2194   init_rtlanal ();
2195   init_inline_once ();
2196   init_varasm_once ();
2197   save_register_info ();
2198
2199   /* Initialize the target-specific back end pieces.  */
2200   ira_init_once ();
2201   backend_init_target ();
2202 }
2203
2204 /* Initialize excess precision settings.  */
2205 static void
2206 init_excess_precision (void)
2207 {
2208   /* Adjust excess precision handling based on the target options.  If
2209      the front end cannot handle it, flag_excess_precision_cmdline
2210      will already have been set accordingly in the post_options
2211      hook.  */
2212   gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
2213   flag_excess_precision = flag_excess_precision_cmdline;
2214   if (flag_unsafe_math_optimizations)
2215     flag_excess_precision = EXCESS_PRECISION_FAST;
2216   if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
2217     {
2218       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
2219       switch (flt_eval_method)
2220         {
2221         case -1:
2222         case 0:
2223           /* Either the target acts unpredictably (-1) or has all the
2224              operations required not to have excess precision (0).  */
2225           flag_excess_precision = EXCESS_PRECISION_FAST;
2226           break;
2227         case 1:
2228         case 2:
2229           /* In these cases, predictable excess precision makes
2230              sense.  */
2231           break;
2232         default:
2233           /* Any other implementation-defined FLT_EVAL_METHOD values
2234              require the compiler to handle the associated excess
2235              precision rules in excess_precision_type.  */
2236           gcc_unreachable ();
2237         }
2238     }
2239 }
2240
2241 /* Initialize things that are both lang-dependent and target-dependent.
2242    This function can be called more than once if target parameters change.  */
2243 static void
2244 lang_dependent_init_target (void)
2245 {
2246   /* This determines excess precision settings.  */
2247   init_excess_precision ();
2248
2249   /* This creates various _DECL nodes, so needs to be called after the
2250      front end is initialized.  It also depends on the HAVE_xxx macros
2251      generated from the target machine description.  */
2252   init_optabs ();
2253
2254   /* The following initialization functions need to generate rtl, so
2255      provide a dummy function context for them.  */
2256   init_dummy_function_start ();
2257
2258   /* Do the target-specific parts of expr initialization.  */
2259   init_expr_target ();
2260
2261   /* Although the actions of these functions are language-independent,
2262      they use optabs, so we cannot call them from backend_init.  */
2263   init_set_costs ();
2264   ira_init ();
2265
2266   expand_dummy_function_end ();
2267 }
2268
2269 /* Language-dependent initialization.  Returns nonzero on success.  */
2270 static int
2271 lang_dependent_init (const char *name)
2272 {
2273   location_t save_loc = input_location;
2274   if (dump_base_name == 0)
2275     dump_base_name = name && name[0] ? name : "gccdump";
2276
2277   /* Other front-end initialization.  */
2278   input_location = BUILTINS_LOCATION;
2279   if (lang_hooks.init () == 0)
2280     return 0;
2281   input_location = save_loc;
2282
2283   init_asm_output (name);
2284
2285   /* This creates various _DECL nodes, so needs to be called after the
2286      front end is initialized.  */
2287   init_eh ();
2288
2289   /* Do the target-specific parts of the initialization.  */
2290   lang_dependent_init_target ();
2291
2292   /* If dbx symbol table desired, initialize writing it and output the
2293      predefined types.  */
2294   timevar_push (TV_SYMOUT);
2295
2296 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
2297   if (dwarf2out_do_frame ())
2298     dwarf2out_frame_init ();
2299 #endif
2300
2301   /* Now we have the correct original filename, we can initialize
2302      debug output.  */
2303   (*debug_hooks->init) (name);
2304
2305   timevar_pop (TV_SYMOUT);
2306
2307   return 1;
2308 }
2309
2310
2311 /* Reinitialize everything when target parameters, such as register usage,
2312    have changed.  */
2313 void
2314 target_reinit (void)
2315 {
2316   /* Reinitialize RTL backend.  */
2317   backend_init_target ();
2318
2319   /* Reinitialize lang-dependent parts.  */
2320   lang_dependent_init_target ();
2321 }
2322
2323 void
2324 dump_memory_report (bool final)
2325 {
2326   ggc_print_statistics ();
2327   stringpool_statistics ();
2328   dump_tree_statistics ();
2329   dump_gimple_statistics ();
2330   dump_rtx_statistics ();
2331   dump_varray_statistics ();
2332   dump_alloc_pool_statistics ();
2333   dump_bitmap_statistics ();
2334   dump_vec_loc_statistics ();
2335   dump_ggc_loc_statistics (final);
2336   dump_alias_stats (stderr);
2337   dump_pta_stats (stderr);
2338 }
2339
2340 /* Clean up: close opened files, etc.  */
2341
2342 static void
2343 finalize (void)
2344 {
2345   /* Close the dump files.  */
2346   if (flag_gen_aux_info)
2347     {
2348       fclose (aux_info_file);
2349       if (errorcount)
2350         unlink (aux_info_file_name);
2351     }
2352
2353   /* Close non-debugging input and output files.  Take special care to note
2354      whether fclose returns an error, since the pages might still be on the
2355      buffer chain while the file is open.  */
2356
2357   if (asm_out_file)
2358     {
2359       if (ferror (asm_out_file) != 0)
2360         fatal_error ("error writing to %s: %m", asm_file_name);
2361       if (fclose (asm_out_file) != 0)
2362         fatal_error ("error closing %s: %m", asm_file_name);
2363       if (flag_wpa)
2364         unlink_if_ordinary (asm_file_name);
2365     }
2366
2367   statistics_fini ();
2368   finish_optimization_passes ();
2369
2370   ira_finish_once ();
2371
2372   if (mem_report)
2373     dump_memory_report (true);
2374
2375   /* Language-specific end of compilation actions.  */
2376   lang_hooks.finish ();
2377 }
2378
2379 /* Initialize the compiler, and compile the input file.  */
2380 static void
2381 do_compile (void)
2382 {
2383   /* Initialize timing first.  The C front ends read the main file in
2384      the post_options hook, and C++ does file timings.  */
2385   if (time_report || !quiet_flag  || flag_detailed_statistics)
2386     timevar_init ();
2387   timevar_start (TV_TOTAL);
2388
2389   process_options ();
2390
2391   /* Don't do any more if an error has already occurred.  */
2392   if (!errorcount)
2393     {
2394       /* This must be run always, because it is needed to compute the FP
2395          predefined macros, such as __LDBL_MAX__, for targets using non
2396          default FP formats.  */
2397       init_adjust_machine_modes ();
2398
2399       /* Set up the back-end if requested.  */
2400       if (!no_backend)
2401         backend_init ();
2402
2403       /* Language-dependent initialization.  Returns true on success.  */
2404       if (lang_dependent_init (main_input_filename))
2405         compile_file ();
2406
2407       finalize ();
2408     }
2409
2410   /* Stop timing and print the times.  */
2411   timevar_stop (TV_TOTAL);
2412   timevar_print (stderr);
2413 }
2414
2415 /* Entry point of cc1, cc1plus, jc1, f771, etc.
2416    Exit code is FATAL_EXIT_CODE if can't open files or if there were
2417    any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2418
2419    It is not safe to call this function more than once.  */
2420
2421 int
2422 toplev_main (int argc, char **argv)
2423 {
2424   expandargv (&argc, &argv);
2425
2426   save_argv = CONST_CAST2 (const char **, char **, argv);
2427
2428   /* Initialization of GCC's environment, and diagnostics.  */
2429   general_init (argv[0]);
2430
2431   /* Parse the options and do minimal processing; basically just
2432      enough to default flags appropriately.  */
2433   decode_options (argc, CONST_CAST2 (const char **, char **, argv));
2434
2435   init_local_tick ();
2436
2437   initialize_plugins ();
2438
2439   if (version_flag)
2440     print_version (stderr, "");
2441
2442   if (help_flag)
2443     print_plugins_help (stderr, "");
2444
2445   /* Exit early if we can (e.g. -help).  */
2446   if (!exit_after_options)
2447     do_compile ();
2448
2449   if (warningcount || errorcount)
2450     print_ignored_options ();
2451
2452   /* Invoke registered plugin callbacks if any.  */
2453   invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
2454
2455   finalize_plugins ();
2456   if (errorcount || sorrycount)
2457     return (FATAL_EXIT_CODE);
2458
2459   return (SUCCESS_EXIT_CODE);
2460 }