OSDN Git Service

a789383cfdc59781a43e0e1c63e9d0d3e5b61934
[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   /* This must be at the end before unwind and debug info.
1088      Some target ports emit PIC setup thunks here.  */
1089   targetm.asm_out.code_end ();
1090
1091   /* Do dbx symbols.  */
1092   timevar_push (TV_SYMOUT);
1093
1094 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
1095   if (dwarf2out_do_frame ())
1096     dwarf2out_frame_finish ();
1097 #endif
1098
1099   (*debug_hooks->finish) (main_input_filename);
1100   timevar_pop (TV_SYMOUT);
1101
1102   /* Output some stuff at end of file if nec.  */
1103
1104   dw2_output_indirect_constants ();
1105
1106   /* Flush any pending external directives.  */
1107   process_pending_assemble_externals ();
1108
1109   /* Emit LTO marker if LTO info has been previously emitted.  This is
1110      used by collect2 to determine whether an object file contains IL.
1111      We used to emit an undefined reference here, but this produces
1112      link errors if an object file with IL is stored into a shared
1113      library without invoking lto1.  */
1114   if (flag_generate_lto)
1115     {
1116 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1117       ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE,
1118                                       "__gnu_lto_v1",
1119                                       (unsigned HOST_WIDE_INT) 1, 8);
1120 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1121       ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1",
1122                                  (unsigned HOST_WIDE_INT) 1, 8);
1123 #else
1124       ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1",
1125                          (unsigned HOST_WIDE_INT) 1,
1126                          (unsigned HOST_WIDE_INT) 1);
1127 #endif
1128     }
1129
1130   /* Attach a special .ident directive to the end of the file to identify
1131      the version of GCC which compiled this code.  The format of the .ident
1132      string is patterned after the ones produced by native SVR4 compilers.  */
1133 #ifdef IDENT_ASM_OP
1134   if (!flag_no_ident)
1135     {
1136       const char *pkg_version = "(GNU) ";
1137
1138       if (strcmp ("(GCC) ", pkgversion_string))
1139         pkg_version = pkgversion_string;
1140       fprintf (asm_out_file, "%s\"GCC: %s%s\"\n",
1141                IDENT_ASM_OP, pkg_version, version_string);
1142     }
1143 #endif
1144
1145   /* Invoke registered plugin callbacks.  */
1146   invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
1147
1148   /* This must be at the end.  Some target ports emit end of file directives
1149      into the assembly file here, and hence we can not output anything to the
1150      assembly file after this point.  */
1151   targetm.asm_out.file_end ();
1152 }
1153
1154 /* Parse a -d... command line switch.  */
1155
1156 void
1157 decode_d_option (const char *arg)
1158 {
1159   int c;
1160
1161   while (*arg)
1162     switch (c = *arg++)
1163       {
1164       case 'A':
1165         flag_debug_asm = 1;
1166         break;
1167       case 'p':
1168         flag_print_asm_name = 1;
1169         break;
1170       case 'P':
1171         flag_dump_rtl_in_asm = 1;
1172         flag_print_asm_name = 1;
1173         break;
1174       case 'v':
1175         graph_dump_format = vcg;
1176         break;
1177       case 'x':
1178         rtl_dump_and_exit = 1;
1179         break;
1180       case 'y':
1181         set_yydebug = 1;
1182         break;
1183       case 'D': /* These are handled by the preprocessor.  */
1184       case 'I':
1185       case 'M':
1186       case 'N':
1187       case 'U':
1188         break;
1189       case 'H':
1190         setup_core_dumping();
1191         break;
1192       case 'a':
1193         enable_rtl_dump_file ();
1194         break;
1195
1196       default:
1197           warning (0, "unrecognized gcc debugging option: %c", c);
1198         break;
1199       }
1200 }
1201
1202 /* Indexed by enum debug_info_type.  */
1203 const char *const debug_type_names[] =
1204 {
1205   "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
1206 };
1207
1208 /* Print version information to FILE.
1209    Each line begins with INDENT (for the case where FILE is the
1210    assembler output file).  */
1211
1212 void
1213 print_version (FILE *file, const char *indent)
1214 {
1215   static const char fmt1[] =
1216 #ifdef __GNUC__
1217     N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
1218 #else
1219     N_("%s%s%s %sversion %s (%s) compiled by CC, ")
1220 #endif
1221     ;
1222   static const char fmt2[] =
1223     N_("GMP version %s, MPFR version %s, MPC version %s\n");
1224   static const char fmt3[] =
1225     N_("%s%swarning: %s header version %s differs from library version %s.\n");
1226   static const char fmt4[] =
1227     N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
1228 #ifndef __VERSION__
1229 #define __VERSION__ "[?]"
1230 #endif
1231   fprintf (file,
1232            file == stderr ? _(fmt1) : fmt1,
1233            indent, *indent != 0 ? " " : "",
1234            lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
1235            indent, __VERSION__);
1236
1237   /* We need to stringify the GMP macro values.  Ugh, gmp_version has
1238      two string formats, "i.j.k" and "i.j" when k is zero.  As of
1239      gmp-4.3.0, GMP always uses the 3 number format.  */
1240 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
1241 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
1242 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
1243 #define GCC_GMP_VERSION \
1244   GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
1245 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
1246 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
1247   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
1248 #else
1249 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
1250   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
1251   GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
1252 #endif
1253   fprintf (file,
1254            file == stderr ? _(fmt2) : fmt2,
1255            GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING);
1256   if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
1257     fprintf (file,
1258              file == stderr ? _(fmt3) : fmt3,
1259              indent, *indent != 0 ? " " : "",
1260              "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
1261   if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
1262     fprintf (file,
1263              file == stderr ? _(fmt3) : fmt3,
1264              indent, *indent != 0 ? " " : "",
1265              "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
1266   if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
1267     fprintf (file,
1268              file == stderr ? _(fmt3) : fmt3,
1269              indent, *indent != 0 ? " " : "",
1270              "MPC", MPC_VERSION_STRING, mpc_get_version ());
1271   fprintf (file,
1272            file == stderr ? _(fmt4) : fmt4,
1273            indent, *indent != 0 ? " " : "",
1274            PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
1275
1276   print_plugins_versions (file, indent);
1277 }
1278
1279 #ifdef ASM_COMMENT_START
1280 static int
1281 print_to_asm_out_file (print_switch_type type, const char * text)
1282 {
1283   bool prepend_sep = true;
1284
1285   switch (type)
1286     {
1287     case SWITCH_TYPE_LINE_END:
1288       putc ('\n', asm_out_file);
1289       return 1;
1290
1291     case SWITCH_TYPE_LINE_START:
1292       fputs (ASM_COMMENT_START, asm_out_file);
1293       return strlen (ASM_COMMENT_START);
1294
1295     case SWITCH_TYPE_DESCRIPTIVE:
1296       if (ASM_COMMENT_START[0] == 0)
1297         prepend_sep = false;
1298       /* Drop through.  */
1299     case SWITCH_TYPE_PASSED:
1300     case SWITCH_TYPE_ENABLED:
1301       if (prepend_sep)
1302         fputc (' ', asm_out_file);
1303       fputs (text, asm_out_file);
1304       /* No need to return the length here as
1305          print_single_switch has already done it.  */
1306       return 0;
1307
1308     default:
1309       return -1;
1310     }
1311 }
1312 #endif
1313
1314 static int
1315 print_to_stderr (print_switch_type type, const char * text)
1316 {
1317   switch (type)
1318     {
1319     case SWITCH_TYPE_LINE_END:
1320       putc ('\n', stderr);
1321       return 1;
1322
1323     case SWITCH_TYPE_LINE_START:
1324       return 0;
1325
1326     case SWITCH_TYPE_PASSED:
1327     case SWITCH_TYPE_ENABLED:
1328       fputc (' ', stderr);
1329       /* Drop through.  */
1330
1331     case SWITCH_TYPE_DESCRIPTIVE:
1332       fputs (text, stderr);
1333       /* No need to return the length here as
1334          print_single_switch has already done it.  */
1335       return 0;
1336
1337     default:
1338       return -1;
1339     }
1340 }
1341
1342 /* Print an option value and return the adjusted position in the line.
1343    ??? print_fn doesn't handle errors, eg disk full; presumably other
1344    code will catch a disk full though.  */
1345
1346 static int
1347 print_single_switch (print_switch_fn_type print_fn,
1348                      int pos,
1349                      print_switch_type type,
1350                      const char * text)
1351 {
1352   /* The ultrix fprintf returns 0 on success, so compute the result
1353      we want here since we need it for the following test.  The +1
1354      is for the separator character that will probably be emitted.  */
1355   int len = strlen (text) + 1;
1356
1357   if (pos != 0
1358       && pos + len > MAX_LINE)
1359     {
1360       print_fn (SWITCH_TYPE_LINE_END, NULL);
1361       pos = 0;
1362     }
1363
1364   if (pos == 0)
1365     pos += print_fn (SWITCH_TYPE_LINE_START, NULL);
1366
1367   print_fn (type, text);
1368   return pos + len;
1369 }
1370
1371 /* Print active target switches using PRINT_FN.
1372    POS is the current cursor position and MAX is the size of a "line".
1373    Each line begins with INDENT and ends with TERM.
1374    Each switch is separated from the next by SEP.  */
1375
1376 static void
1377 print_switch_values (print_switch_fn_type print_fn)
1378 {
1379   int pos = 0;
1380   size_t j;
1381   const char **p;
1382
1383   /* Fill in the -frandom-seed option, if the user didn't pass it, so
1384      that it can be printed below.  This helps reproducibility.  */
1385   if (!flag_random_seed)
1386     init_random_seed ();
1387
1388   /* Print the options as passed.  */
1389   pos = print_single_switch (print_fn, pos,
1390                              SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
1391
1392   for (p = &save_argv[1]; *p != NULL; p++)
1393     {
1394       if (**p == '-')
1395         {
1396           /* Ignore these.  */
1397           if (strcmp (*p, "-o") == 0
1398               || strcmp (*p, "-dumpbase") == 0
1399               || strcmp (*p, "-dumpdir") == 0
1400               || strcmp (*p, "-auxbase") == 0)
1401             {
1402               if (p[1] != NULL)
1403                 p++;
1404               continue;
1405             }
1406
1407           if (strcmp (*p, "-quiet") == 0
1408               || strcmp (*p, "-version") == 0)
1409             continue;
1410
1411           if ((*p)[1] == 'd')
1412             continue;
1413         }
1414
1415       pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED, *p);
1416     }
1417
1418   if (pos > 0)
1419     print_fn (SWITCH_TYPE_LINE_END, NULL);
1420
1421   /* Print the -f and -m options that have been enabled.
1422      We don't handle language specific options but printing argv
1423      should suffice.  */
1424   pos = print_single_switch (print_fn, 0,
1425                              SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
1426
1427   for (j = 0; j < cl_options_count; j++)
1428     if ((cl_options[j].flags & CL_REPORT)
1429         && option_enabled (j) > 0)
1430       pos = print_single_switch (print_fn, pos,
1431                                  SWITCH_TYPE_ENABLED, cl_options[j].opt_text);
1432
1433   print_fn (SWITCH_TYPE_LINE_END, NULL);
1434 }
1435
1436 /* Open assembly code output file.  Do this even if -fsyntax-only is
1437    on, because then the driver will have provided the name of a
1438    temporary file or bit bucket for us.  NAME is the file specified on
1439    the command line, possibly NULL.  */
1440 static void
1441 init_asm_output (const char *name)
1442 {
1443   if (name == NULL && asm_file_name == 0)
1444     asm_out_file = stdout;
1445   else
1446     {
1447       if (asm_file_name == 0)
1448         {
1449           int len = strlen (dump_base_name);
1450           char *dumpname = XNEWVEC (char, len + 6);
1451
1452           memcpy (dumpname, dump_base_name, len + 1);
1453           strip_off_ending (dumpname, len);
1454           strcat (dumpname, ".s");
1455           asm_file_name = dumpname;
1456         }
1457       if (!strcmp (asm_file_name, "-"))
1458         asm_out_file = stdout;
1459       else
1460         asm_out_file = fopen (asm_file_name, "w+b");
1461       if (asm_out_file == 0)
1462         fatal_error ("can%'t open %s for writing: %m", asm_file_name);
1463     }
1464
1465   if (!flag_syntax_only)
1466     {
1467       targetm.asm_out.file_start ();
1468
1469       if (flag_record_gcc_switches)
1470         {
1471           if (targetm.asm_out.record_gcc_switches)
1472             {
1473               /* Let the target know that we are about to start recording.  */
1474               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
1475                                                    NULL);
1476               /* Now record the switches.  */
1477               print_switch_values (targetm.asm_out.record_gcc_switches);
1478               /* Let the target know that the recording is over.  */
1479               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
1480                                                    NULL);
1481             }
1482           else
1483             inform (input_location, "-frecord-gcc-switches is not supported by the current target");
1484         }
1485
1486 #ifdef ASM_COMMENT_START
1487       if (flag_verbose_asm)
1488         {
1489           /* Print the list of switches in effect
1490              into the assembler file as comments.  */
1491           print_version (asm_out_file, ASM_COMMENT_START);
1492           print_switch_values (print_to_asm_out_file);
1493           putc ('\n', asm_out_file);
1494         }
1495 #endif
1496     }
1497 }
1498
1499 /* Return true if the state of option OPTION should be stored in PCH files
1500    and checked by default_pch_valid_p.  Store the option's current state
1501    in STATE if so.  */
1502
1503 static inline bool
1504 option_affects_pch_p (int option, struct cl_option_state *state)
1505 {
1506   if ((cl_options[option].flags & CL_TARGET) == 0)
1507     return false;
1508   if (cl_options[option].flag_var == &target_flags)
1509     if (targetm.check_pch_target_flags)
1510       return false;
1511   return get_option_state (option, state);
1512 }
1513
1514 /* Default version of get_pch_validity.
1515    By default, every flag difference is fatal; that will be mostly right for
1516    most targets, but completely right for very few.  */
1517
1518 void *
1519 default_get_pch_validity (size_t *sz)
1520 {
1521   struct cl_option_state state;
1522   size_t i;
1523   char *result, *r;
1524
1525   *sz = 2;
1526   if (targetm.check_pch_target_flags)
1527     *sz += sizeof (target_flags);
1528   for (i = 0; i < cl_options_count; i++)
1529     if (option_affects_pch_p (i, &state))
1530       *sz += state.size;
1531
1532   result = r = XNEWVEC (char, *sz);
1533   r[0] = flag_pic;
1534   r[1] = flag_pie;
1535   r += 2;
1536   if (targetm.check_pch_target_flags)
1537     {
1538       memcpy (r, &target_flags, sizeof (target_flags));
1539       r += sizeof (target_flags);
1540     }
1541
1542   for (i = 0; i < cl_options_count; i++)
1543     if (option_affects_pch_p (i, &state))
1544       {
1545         memcpy (r, state.data, state.size);
1546         r += state.size;
1547       }
1548
1549   return result;
1550 }
1551
1552 /* Return a message which says that a PCH file was created with a different
1553    setting of OPTION.  */
1554
1555 static const char *
1556 pch_option_mismatch (const char *option)
1557 {
1558   char *r;
1559
1560   asprintf (&r, _("created and used with differing settings of '%s'"), option);
1561   if (r == NULL)
1562     return _("out of memory");
1563   return r;
1564 }
1565
1566 /* Default version of pch_valid_p.  */
1567
1568 const char *
1569 default_pch_valid_p (const void *data_p, size_t len)
1570 {
1571   struct cl_option_state state;
1572   const char *data = (const char *)data_p;
1573   size_t i;
1574
1575   /* -fpic and -fpie also usually make a PCH invalid.  */
1576   if (data[0] != flag_pic)
1577     return _("created and used with different settings of -fpic");
1578   if (data[1] != flag_pie)
1579     return _("created and used with different settings of -fpie");
1580   data += 2;
1581
1582   /* Check target_flags.  */
1583   if (targetm.check_pch_target_flags)
1584     {
1585       int tf;
1586       const char *r;
1587
1588       memcpy (&tf, data, sizeof (target_flags));
1589       data += sizeof (target_flags);
1590       len -= sizeof (target_flags);
1591       r = targetm.check_pch_target_flags (tf);
1592       if (r != NULL)
1593         return r;
1594     }
1595
1596   for (i = 0; i < cl_options_count; i++)
1597     if (option_affects_pch_p (i, &state))
1598       {
1599         if (memcmp (data, state.data, state.size) != 0)
1600           return pch_option_mismatch (cl_options[i].opt_text);
1601         data += state.size;
1602         len -= state.size;
1603       }
1604
1605   return NULL;
1606 }
1607
1608 /* Default tree printer.   Handles declarations only.  */
1609 bool
1610 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
1611                       int precision, bool wide, bool set_locus, bool hash)
1612 {
1613   tree t;
1614
1615   /* FUTURE: %+x should set the locus.  */
1616   if (precision != 0 || wide || hash)
1617     return false;
1618
1619   switch (*spec)
1620     {
1621     case 'E':
1622       t = va_arg (*text->args_ptr, tree);
1623       if (TREE_CODE (t) == IDENTIFIER_NODE)
1624         {
1625           pp_identifier (pp, IDENTIFIER_POINTER (t));
1626           return true;
1627         }
1628       break;
1629
1630     case 'D':
1631       t = va_arg (*text->args_ptr, tree);
1632       if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
1633         t = DECL_DEBUG_EXPR (t);
1634       break;
1635
1636     case 'F':
1637     case 'T':
1638       t = va_arg (*text->args_ptr, tree);
1639       break;
1640
1641     default:
1642       return false;
1643     }
1644
1645   if (set_locus && text->locus)
1646     *text->locus = DECL_SOURCE_LOCATION (t);
1647
1648   if (DECL_P (t))
1649     {
1650       const char *n = DECL_NAME (t)
1651         ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
1652         : _("<anonymous>");
1653       pp_string (pp, n);
1654     }
1655   else
1656     dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0);
1657
1658   return true;
1659 }
1660
1661 /* A helper function; used as the reallocator function for cpp's line
1662    table.  */
1663 static void *
1664 realloc_for_line_map (void *ptr, size_t len)
1665 {
1666   return ggc_realloc (ptr, len);
1667 }
1668
1669 /* Initialization of the front end environment, before command line
1670    options are parsed.  Signal handlers, internationalization etc.
1671    ARGV0 is main's argv[0].  */
1672 static void
1673 general_init (const char *argv0)
1674 {
1675   const char *p;
1676
1677   p = argv0 + strlen (argv0);
1678   while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
1679     --p;
1680   progname = p;
1681
1682   xmalloc_set_program_name (progname);
1683
1684   hex_init ();
1685
1686   /* Unlock the stdio streams.  */
1687   unlock_std_streams ();
1688
1689   gcc_init_libintl ();
1690
1691   /* Initialize the diagnostics reporting machinery, so option parsing
1692      can give warnings and errors.  */
1693   diagnostic_initialize (global_dc);
1694   /* Set a default printer.  Language specific initializations will
1695      override it later.  */
1696   pp_format_decoder (global_dc->printer) = &default_tree_printer;
1697
1698   /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages.  */
1699 #ifdef SIGSEGV
1700   signal (SIGSEGV, crash_signal);
1701 #endif
1702 #ifdef SIGILL
1703   signal (SIGILL, crash_signal);
1704 #endif
1705 #ifdef SIGBUS
1706   signal (SIGBUS, crash_signal);
1707 #endif
1708 #ifdef SIGABRT
1709   signal (SIGABRT, crash_signal);
1710 #endif
1711 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1712   signal (SIGIOT, crash_signal);
1713 #endif
1714 #ifdef SIGFPE
1715   signal (SIGFPE, crash_signal);
1716 #endif
1717
1718   /* Other host-specific signal setup.  */
1719   (*host_hooks.extra_signals)();
1720
1721   /* Initialize the garbage-collector, string pools and tree type hash
1722      table.  */
1723   init_ggc ();
1724   init_stringpool ();
1725   line_table = GGC_NEW (struct line_maps);
1726   linemap_init (line_table);
1727   line_table->reallocator = realloc_for_line_map;
1728   init_ttree ();
1729
1730   /* Initialize register usage now so switches may override.  */
1731   init_reg_sets ();
1732
1733   /* Register the language-independent parameters.  */
1734   add_params (lang_independent_params, LAST_PARAM);
1735
1736   /* This must be done after add_params but before argument processing.  */
1737   init_ggc_heuristics();
1738   init_optimization_passes ();
1739   statistics_early_init ();
1740 }
1741
1742 /* Return true if the current target supports -fsection-anchors.  */
1743
1744 static bool
1745 target_supports_section_anchors_p (void)
1746 {
1747   if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
1748     return false;
1749
1750   if (targetm.asm_out.output_anchor == NULL)
1751     return false;
1752
1753   return true;
1754 }
1755
1756 /* Default the align_* variables to 1 if they're still unset, and
1757    set up the align_*_log variables.  */
1758 static void
1759 init_alignments (void)
1760 {
1761   if (align_loops <= 0)
1762     align_loops = 1;
1763   if (align_loops_max_skip > align_loops)
1764     align_loops_max_skip = align_loops - 1;
1765   align_loops_log = floor_log2 (align_loops * 2 - 1);
1766   if (align_jumps <= 0)
1767     align_jumps = 1;
1768   if (align_jumps_max_skip > align_jumps)
1769     align_jumps_max_skip = align_jumps - 1;
1770   align_jumps_log = floor_log2 (align_jumps * 2 - 1);
1771   if (align_labels <= 0)
1772     align_labels = 1;
1773   align_labels_log = floor_log2 (align_labels * 2 - 1);
1774   if (align_labels_max_skip > align_labels)
1775     align_labels_max_skip = align_labels - 1;
1776   if (align_functions <= 0)
1777     align_functions = 1;
1778   align_functions_log = floor_log2 (align_functions * 2 - 1);
1779 }
1780
1781 /* Process the options that have been parsed.  */
1782 static void
1783 process_options (void)
1784 {
1785   /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1786      This can happen with incorrect pre-processed input. */
1787   debug_hooks = &do_nothing_debug_hooks;
1788
1789   /* This replaces set_Wunused.  */
1790   if (warn_unused_function == -1)
1791     warn_unused_function = warn_unused;
1792   if (warn_unused_label == -1)
1793     warn_unused_label = warn_unused;
1794   /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled.  */
1795   if (warn_unused_parameter == -1)
1796     warn_unused_parameter = (warn_unused && extra_warnings);
1797   if (warn_unused_variable == -1)
1798     warn_unused_variable = warn_unused;
1799   if (warn_unused_value == -1)
1800     warn_unused_value = warn_unused;
1801
1802   /* This replaces set_Wextra.  */
1803   if (warn_uninitialized == -1)
1804     warn_uninitialized = extra_warnings;
1805
1806   /* Allow the front end to perform consistency checks and do further
1807      initialization based on the command line options.  This hook also
1808      sets the original filename if appropriate (e.g. foo.i -> foo.c)
1809      so we can correctly initialize debug output.  */
1810   no_backend = lang_hooks.post_options (&main_input_filename);
1811
1812 #ifdef OVERRIDE_OPTIONS
1813   /* Some machines may reject certain combinations of options.  */
1814   OVERRIDE_OPTIONS;
1815 #endif
1816
1817   /* Avoid any informative notes in the second run of -fcompare-debug.  */
1818   if (flag_compare_debug) 
1819     diagnostic_inhibit_notes (global_dc);
1820
1821   if (flag_section_anchors && !target_supports_section_anchors_p ())
1822     {
1823       warning (OPT_fsection_anchors,
1824                "this target does not support %qs", "-fsection-anchors");
1825       flag_section_anchors = 0;
1826     }
1827
1828   if (flag_short_enums == 2)
1829     flag_short_enums = targetm.default_short_enums ();
1830
1831   /* Set aux_base_name if not already set.  */
1832   if (aux_base_name)
1833     ;
1834   else if (main_input_filename)
1835     {
1836       char *name = xstrdup (lbasename (main_input_filename));
1837
1838       strip_off_ending (name, strlen (name));
1839       aux_base_name = name;
1840     }
1841   else
1842     aux_base_name = "gccaux";
1843
1844 #ifndef HAVE_cloog
1845   if (flag_graphite
1846       || flag_loop_block
1847       || flag_loop_interchange
1848       || flag_loop_strip_mine
1849       || flag_graphite_identity
1850       || flag_loop_parallelize_all)
1851     sorry ("Graphite loop optimizations cannot be used");
1852 #endif
1853
1854   /* Unrolling all loops implies that standard loop unrolling must also
1855      be done.  */
1856   if (flag_unroll_all_loops)
1857     flag_unroll_loops = 1;
1858
1859   /* The loop unrolling code assumes that cse will be run after loop.
1860      web and rename-registers also help when run after loop unrolling.  */
1861   if (flag_rerun_cse_after_loop == AUTODETECT_VALUE)
1862     flag_rerun_cse_after_loop = flag_unroll_loops || flag_peel_loops;
1863
1864   if (flag_web == AUTODETECT_VALUE)
1865     flag_web = flag_unroll_loops || flag_peel_loops;
1866
1867   if (flag_rename_registers == AUTODETECT_VALUE)
1868     flag_rename_registers = flag_unroll_loops || flag_peel_loops;
1869
1870   if (flag_non_call_exceptions)
1871     flag_asynchronous_unwind_tables = 1;
1872   if (flag_asynchronous_unwind_tables)
1873     flag_unwind_tables = 1;
1874
1875   if (flag_value_profile_transformations)
1876     flag_profile_values = 1;
1877
1878   /* Warn about options that are not supported on this machine.  */
1879 #ifndef INSN_SCHEDULING
1880   if (flag_schedule_insns || flag_schedule_insns_after_reload)
1881     warning (0, "instruction scheduling not supported on this target machine");
1882 #endif
1883 #ifndef DELAY_SLOTS
1884   if (flag_delayed_branch)
1885     warning (0, "this target machine does not have delayed branches");
1886 #endif
1887
1888   user_label_prefix = USER_LABEL_PREFIX;
1889   if (flag_leading_underscore != -1)
1890     {
1891       /* If the default prefix is more complicated than "" or "_",
1892          issue a warning and ignore this option.  */
1893       if (user_label_prefix[0] == 0 ||
1894           (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1895         {
1896           user_label_prefix = flag_leading_underscore ? "_" : "";
1897         }
1898       else
1899         warning (0, "-f%sleading-underscore not supported on this target machine",
1900                  flag_leading_underscore ? "" : "no-");
1901     }
1902
1903   /* If we are in verbose mode, write out the version and maybe all the
1904      option flags in use.  */
1905   if (version_flag)
1906     {
1907       print_version (stderr, "");
1908       if (! quiet_flag)
1909         print_switch_values (print_to_stderr);
1910     }
1911
1912   if (flag_syntax_only)
1913     {
1914       write_symbols = NO_DEBUG;
1915       profile_flag = 0;
1916     }
1917
1918   if (flag_gtoggle)
1919     {
1920       if (debug_info_level == DINFO_LEVEL_NONE)
1921         {
1922           debug_info_level = DINFO_LEVEL_NORMAL;
1923
1924           if (write_symbols == NO_DEBUG)
1925             write_symbols = PREFERRED_DEBUGGING_TYPE;
1926         }
1927       else
1928         debug_info_level = DINFO_LEVEL_NONE;
1929     }
1930
1931   if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
1932     {
1933       FILE *final_output = fopen (flag_dump_final_insns, "w");
1934       if (!final_output)
1935         {
1936           error ("could not open final insn dump file %qs: %s",
1937                  flag_dump_final_insns, strerror (errno));
1938           flag_dump_final_insns = NULL;
1939         }
1940       else if (fclose (final_output))
1941         {
1942           error ("could not close zeroed insn dump file %qs: %s",
1943                  flag_dump_final_insns, strerror (errno));
1944           flag_dump_final_insns = NULL;
1945         }
1946     }
1947
1948   /* Unless over-ridden for the target, assume that all DWARF levels
1949      may be emitted, if DWARF2_DEBUG is selected.  */
1950   if (dwarf_strict < 0)
1951     dwarf_strict = 0;
1952
1953   /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1954      level is 0.  */
1955   if (debug_info_level == DINFO_LEVEL_NONE)
1956     write_symbols = NO_DEBUG;
1957
1958   /* Now we know write_symbols, set up the debug hooks based on it.
1959      By default we do nothing for debug output.  */
1960   if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
1961     default_debug_hooks = &do_nothing_debug_hooks;
1962 #if defined(DBX_DEBUGGING_INFO)
1963   else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
1964     default_debug_hooks = &dbx_debug_hooks;
1965 #endif
1966 #if defined(XCOFF_DEBUGGING_INFO)
1967   else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
1968     default_debug_hooks = &xcoff_debug_hooks;
1969 #endif
1970 #ifdef SDB_DEBUGGING_INFO
1971   else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
1972     default_debug_hooks = &sdb_debug_hooks;
1973 #endif
1974 #ifdef DWARF2_DEBUGGING_INFO
1975   else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
1976     default_debug_hooks = &dwarf2_debug_hooks;
1977 #endif
1978 #ifdef VMS_DEBUGGING_INFO
1979   else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
1980            || PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
1981     default_debug_hooks = &vmsdbg_debug_hooks;
1982 #endif
1983
1984   if (write_symbols == NO_DEBUG)
1985     ;
1986 #if defined(DBX_DEBUGGING_INFO)
1987   else if (write_symbols == DBX_DEBUG)
1988     debug_hooks = &dbx_debug_hooks;
1989 #endif
1990 #if defined(XCOFF_DEBUGGING_INFO)
1991   else if (write_symbols == XCOFF_DEBUG)
1992     debug_hooks = &xcoff_debug_hooks;
1993 #endif
1994 #ifdef SDB_DEBUGGING_INFO
1995   else if (write_symbols == SDB_DEBUG)
1996     debug_hooks = &sdb_debug_hooks;
1997 #endif
1998 #ifdef DWARF2_DEBUGGING_INFO
1999   else if (write_symbols == DWARF2_DEBUG)
2000     debug_hooks = &dwarf2_debug_hooks;
2001 #endif
2002 #ifdef VMS_DEBUGGING_INFO
2003   else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
2004     debug_hooks = &vmsdbg_debug_hooks;
2005 #endif
2006   else
2007     error ("target system does not support the \"%s\" debug format",
2008            debug_type_names[write_symbols]);
2009
2010   /* We know which debug output will be used so we can set flag_var_tracking
2011      and flag_var_tracking_uninit if the user has not specified them.  */
2012   if (debug_info_level < DINFO_LEVEL_NORMAL
2013       || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
2014     {
2015       if (flag_var_tracking == 1
2016           || flag_var_tracking_uninit == 1)
2017         {
2018           if (debug_info_level < DINFO_LEVEL_NORMAL)
2019             warning (0, "variable tracking requested, but useless unless "
2020                      "producing debug info");
2021           else
2022             warning (0, "variable tracking requested, but not supported "
2023                      "by this debug format");
2024         }
2025       flag_var_tracking = 0;
2026       flag_var_tracking_uninit = 0;
2027     }
2028
2029   /* If the user specifically requested variable tracking with tagging
2030      uninitialized variables, we need to turn on variable tracking.
2031      (We already determined above that variable tracking is feasible.)  */
2032   if (flag_var_tracking_uninit)
2033     flag_var_tracking = 1;
2034
2035   if (flag_var_tracking == AUTODETECT_VALUE)
2036     flag_var_tracking = optimize >= 1;
2037
2038   if (flag_var_tracking_assignments == AUTODETECT_VALUE)
2039     flag_var_tracking_assignments = flag_var_tracking
2040       && !(flag_selective_scheduling || flag_selective_scheduling2);
2041
2042   if (flag_var_tracking_assignments_toggle)
2043     flag_var_tracking_assignments = !flag_var_tracking_assignments;
2044
2045   if (flag_var_tracking_assignments && !flag_var_tracking)
2046     flag_var_tracking = flag_var_tracking_assignments = -1;
2047
2048   if (flag_var_tracking_assignments
2049       && (flag_selective_scheduling || flag_selective_scheduling2))
2050     warning (0, "var-tracking-assignments changes selective scheduling");
2051
2052   if (flag_tree_cselim == AUTODETECT_VALUE)
2053 #ifdef HAVE_conditional_move
2054     flag_tree_cselim = 1;
2055 #else
2056     flag_tree_cselim = 0;
2057 #endif
2058
2059   /* If auxiliary info generation is desired, open the output file.
2060      This goes in the same directory as the source file--unlike
2061      all the other output files.  */
2062   if (flag_gen_aux_info)
2063     {
2064       aux_info_file = fopen (aux_info_file_name, "w");
2065       if (aux_info_file == 0)
2066         fatal_error ("can%'t open %s: %m", aux_info_file_name);
2067     }
2068
2069   if (! targetm.have_named_sections)
2070     {
2071       if (flag_function_sections)
2072         {
2073           warning (0, "-ffunction-sections not supported for this target");
2074           flag_function_sections = 0;
2075         }
2076       if (flag_data_sections)
2077         {
2078           warning (0, "-fdata-sections not supported for this target");
2079           flag_data_sections = 0;
2080         }
2081     }
2082
2083   if (flag_function_sections && profile_flag)
2084     {
2085       warning (0, "-ffunction-sections disabled; it makes profiling impossible");
2086       flag_function_sections = 0;
2087     }
2088
2089 #ifndef HAVE_prefetch
2090   if (flag_prefetch_loop_arrays)
2091     {
2092       warning (0, "-fprefetch-loop-arrays not supported for this target");
2093       flag_prefetch_loop_arrays = 0;
2094     }
2095 #else
2096   if (flag_prefetch_loop_arrays && !HAVE_prefetch)
2097     {
2098       warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
2099       flag_prefetch_loop_arrays = 0;
2100     }
2101 #endif
2102
2103   /* This combination of options isn't handled for i386 targets and doesn't
2104      make much sense anyway, so don't allow it.  */
2105   if (flag_prefetch_loop_arrays && optimize_size)
2106     {
2107       warning (0, "-fprefetch-loop-arrays is not supported with -Os");
2108       flag_prefetch_loop_arrays = 0;
2109     }
2110
2111   /* The presence of IEEE signaling NaNs, implies all math can trap.  */
2112   if (flag_signaling_nans)
2113     flag_trapping_math = 1;
2114
2115   /* We cannot reassociate if we want traps or signed zeros.  */
2116   if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
2117     {
2118       warning (0, "-fassociative-math disabled; other options take precedence");
2119       flag_associative_math = 0;
2120     }
2121
2122   /* With -fcx-limited-range, we do cheap and quick complex arithmetic.  */
2123   if (flag_cx_limited_range)
2124     flag_complex_method = 0;
2125
2126   /* With -fcx-fortran-rules, we do something in-between cheap and C99.  */
2127   if (flag_cx_fortran_rules)
2128     flag_complex_method = 1;
2129
2130   /* Targets must be able to place spill slots at lower addresses.  If the
2131      target already uses a soft frame pointer, the transition is trivial.  */
2132   if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
2133     {
2134       warning (0, "-fstack-protector not supported for this target");
2135       flag_stack_protect = 0;
2136     }
2137   if (!flag_stack_protect)
2138     warn_stack_protect = 0;
2139
2140   /* ??? Unwind info is not correct around the CFG unless either a frame
2141      pointer is present or A_O_A is set.  Fixing this requires rewriting
2142      unwind info generation to be aware of the CFG and propagating states
2143      around edges.  */
2144   if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
2145       && flag_omit_frame_pointer)
2146     {
2147       warning (0, "unwind tables currently require a frame pointer "
2148                "for correctness");
2149       flag_omit_frame_pointer = 0;
2150     }
2151
2152   /* Save the current optimization options.  */
2153   optimization_default_node = build_optimization_node ();
2154   optimization_current_node = optimization_default_node;
2155 }
2156
2157 /* This function can be called multiple times to reinitialize the compiler
2158    back end when register classes or instruction sets have changed,
2159    before each function.  */
2160 static void
2161 backend_init_target (void)
2162 {
2163   /* Initialize alignment variables.  */
2164   init_alignments ();
2165
2166   /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
2167      to initialize reg_raw_mode[].  */
2168   init_emit_regs ();
2169
2170   /* This invokes target hooks to set fixed_reg[] etc, which is
2171      mode-dependent.  */
2172   init_regs ();
2173
2174   /* This depends on stack_pointer_rtx.  */
2175   init_fake_stack_mems ();
2176
2177   /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
2178      mode-dependent.  */
2179   init_alias_target ();
2180
2181   /* Depends on HARD_FRAME_POINTER_REGNUM.  */
2182   init_reload ();
2183
2184   /* The following initialization functions need to generate rtl, so
2185      provide a dummy function context for them.  */
2186   init_dummy_function_start ();
2187
2188   /* rtx_cost is mode-dependent, so cached values need to be recomputed
2189      on a mode change.  */
2190   init_expmed ();
2191
2192   /* We may need to recompute regno_save_code[] and regno_restore_code[]
2193      after a mode change as well.  */
2194   if (flag_caller_saves)
2195     init_caller_save ();
2196   expand_dummy_function_end ();
2197 }
2198
2199 /* Initialize the compiler back end.  This function is called only once,
2200    when starting the compiler.  */
2201 static void
2202 backend_init (void)
2203 {
2204   init_emit_once ();
2205
2206   init_rtlanal ();
2207   init_inline_once ();
2208   init_varasm_once ();
2209   save_register_info ();
2210
2211   /* Initialize the target-specific back end pieces.  */
2212   ira_init_once ();
2213   backend_init_target ();
2214 }
2215
2216 /* Initialize excess precision settings.  */
2217 static void
2218 init_excess_precision (void)
2219 {
2220   /* Adjust excess precision handling based on the target options.  If
2221      the front end cannot handle it, flag_excess_precision_cmdline
2222      will already have been set accordingly in the post_options
2223      hook.  */
2224   gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
2225   flag_excess_precision = flag_excess_precision_cmdline;
2226   if (flag_unsafe_math_optimizations)
2227     flag_excess_precision = EXCESS_PRECISION_FAST;
2228   if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
2229     {
2230       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
2231       switch (flt_eval_method)
2232         {
2233         case -1:
2234         case 0:
2235           /* Either the target acts unpredictably (-1) or has all the
2236              operations required not to have excess precision (0).  */
2237           flag_excess_precision = EXCESS_PRECISION_FAST;
2238           break;
2239         case 1:
2240         case 2:
2241           /* In these cases, predictable excess precision makes
2242              sense.  */
2243           break;
2244         default:
2245           /* Any other implementation-defined FLT_EVAL_METHOD values
2246              require the compiler to handle the associated excess
2247              precision rules in excess_precision_type.  */
2248           gcc_unreachable ();
2249         }
2250     }
2251 }
2252
2253 /* Initialize things that are both lang-dependent and target-dependent.
2254    This function can be called more than once if target parameters change.  */
2255 static void
2256 lang_dependent_init_target (void)
2257 {
2258   /* This determines excess precision settings.  */
2259   init_excess_precision ();
2260
2261   /* This creates various _DECL nodes, so needs to be called after the
2262      front end is initialized.  It also depends on the HAVE_xxx macros
2263      generated from the target machine description.  */
2264   init_optabs ();
2265
2266   /* The following initialization functions need to generate rtl, so
2267      provide a dummy function context for them.  */
2268   init_dummy_function_start ();
2269
2270   /* Do the target-specific parts of expr initialization.  */
2271   init_expr_target ();
2272
2273   /* Although the actions of these functions are language-independent,
2274      they use optabs, so we cannot call them from backend_init.  */
2275   init_set_costs ();
2276   ira_init ();
2277
2278   expand_dummy_function_end ();
2279 }
2280
2281 /* Language-dependent initialization.  Returns nonzero on success.  */
2282 static int
2283 lang_dependent_init (const char *name)
2284 {
2285   location_t save_loc = input_location;
2286   if (dump_base_name == 0)
2287     dump_base_name = name && name[0] ? name : "gccdump";
2288
2289   /* Other front-end initialization.  */
2290   input_location = BUILTINS_LOCATION;
2291   if (lang_hooks.init () == 0)
2292     return 0;
2293   input_location = save_loc;
2294
2295   init_asm_output (name);
2296
2297   /* This creates various _DECL nodes, so needs to be called after the
2298      front end is initialized.  */
2299   init_eh ();
2300
2301   /* Do the target-specific parts of the initialization.  */
2302   lang_dependent_init_target ();
2303
2304   /* If dbx symbol table desired, initialize writing it and output the
2305      predefined types.  */
2306   timevar_push (TV_SYMOUT);
2307
2308 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
2309   if (dwarf2out_do_frame ())
2310     dwarf2out_frame_init ();
2311 #endif
2312
2313   /* Now we have the correct original filename, we can initialize
2314      debug output.  */
2315   (*debug_hooks->init) (name);
2316
2317   timevar_pop (TV_SYMOUT);
2318
2319   return 1;
2320 }
2321
2322
2323 /* Reinitialize everything when target parameters, such as register usage,
2324    have changed.  */
2325 void
2326 target_reinit (void)
2327 {
2328   /* Reinitialize RTL backend.  */
2329   backend_init_target ();
2330
2331   /* Reinitialize lang-dependent parts.  */
2332   lang_dependent_init_target ();
2333 }
2334
2335 void
2336 dump_memory_report (bool final)
2337 {
2338   ggc_print_statistics ();
2339   stringpool_statistics ();
2340   dump_tree_statistics ();
2341   dump_gimple_statistics ();
2342   dump_rtx_statistics ();
2343   dump_varray_statistics ();
2344   dump_alloc_pool_statistics ();
2345   dump_bitmap_statistics ();
2346   dump_vec_loc_statistics ();
2347   dump_ggc_loc_statistics (final);
2348   dump_alias_stats (stderr);
2349   dump_pta_stats (stderr);
2350 }
2351
2352 /* Clean up: close opened files, etc.  */
2353
2354 static void
2355 finalize (void)
2356 {
2357   /* Close the dump files.  */
2358   if (flag_gen_aux_info)
2359     {
2360       fclose (aux_info_file);
2361       if (errorcount)
2362         unlink (aux_info_file_name);
2363     }
2364
2365   /* Close non-debugging input and output files.  Take special care to note
2366      whether fclose returns an error, since the pages might still be on the
2367      buffer chain while the file is open.  */
2368
2369   if (asm_out_file)
2370     {
2371       if (ferror (asm_out_file) != 0)
2372         fatal_error ("error writing to %s: %m", asm_file_name);
2373       if (fclose (asm_out_file) != 0)
2374         fatal_error ("error closing %s: %m", asm_file_name);
2375       if (flag_wpa)
2376         unlink_if_ordinary (asm_file_name);
2377     }
2378
2379   statistics_fini ();
2380   finish_optimization_passes ();
2381
2382   ira_finish_once ();
2383
2384   if (mem_report)
2385     dump_memory_report (true);
2386
2387   /* Language-specific end of compilation actions.  */
2388   lang_hooks.finish ();
2389 }
2390
2391 /* Initialize the compiler, and compile the input file.  */
2392 static void
2393 do_compile (void)
2394 {
2395   /* Initialize timing first.  The C front ends read the main file in
2396      the post_options hook, and C++ does file timings.  */
2397   if (time_report || !quiet_flag  || flag_detailed_statistics)
2398     timevar_init ();
2399   timevar_start (TV_TOTAL);
2400
2401   process_options ();
2402
2403   /* Don't do any more if an error has already occurred.  */
2404   if (!errorcount)
2405     {
2406       /* This must be run always, because it is needed to compute the FP
2407          predefined macros, such as __LDBL_MAX__, for targets using non
2408          default FP formats.  */
2409       init_adjust_machine_modes ();
2410
2411       /* Set up the back-end if requested.  */
2412       if (!no_backend)
2413         backend_init ();
2414
2415       /* Language-dependent initialization.  Returns true on success.  */
2416       if (lang_dependent_init (main_input_filename))
2417         compile_file ();
2418
2419       finalize ();
2420     }
2421
2422   /* Stop timing and print the times.  */
2423   timevar_stop (TV_TOTAL);
2424   timevar_print (stderr);
2425 }
2426
2427 /* Entry point of cc1, cc1plus, jc1, f771, etc.
2428    Exit code is FATAL_EXIT_CODE if can't open files or if there were
2429    any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2430
2431    It is not safe to call this function more than once.  */
2432
2433 int
2434 toplev_main (int argc, char **argv)
2435 {
2436   expandargv (&argc, &argv);
2437
2438   save_argv = CONST_CAST2 (const char **, char **, argv);
2439
2440   /* Initialization of GCC's environment, and diagnostics.  */
2441   general_init (argv[0]);
2442
2443   /* Parse the options and do minimal processing; basically just
2444      enough to default flags appropriately.  */
2445   decode_options (argc, CONST_CAST2 (const char **, char **, argv));
2446
2447   init_local_tick ();
2448
2449   initialize_plugins ();
2450
2451   if (version_flag)
2452     print_version (stderr, "");
2453
2454   if (help_flag)
2455     print_plugins_help (stderr, "");
2456
2457   /* Exit early if we can (e.g. -help).  */
2458   if (!exit_after_options)
2459     do_compile ();
2460
2461   if (warningcount || errorcount)
2462     print_ignored_options ();
2463
2464   /* Invoke registered plugin callbacks if any.  */
2465   invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
2466
2467   finalize_plugins ();
2468   if (errorcount || sorrycount)
2469     return (FATAL_EXIT_CODE);
2470
2471   return (SUCCESS_EXIT_CODE);
2472 }