OSDN Git Service

* sdbout.c: Include vec.h, do not include varray.h.
[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 || flag_wpa)
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   global_dc->show_option_requested = flag_diagnostics_show_option;
1698
1699   /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages.  */
1700 #ifdef SIGSEGV
1701   signal (SIGSEGV, crash_signal);
1702 #endif
1703 #ifdef SIGILL
1704   signal (SIGILL, crash_signal);
1705 #endif
1706 #ifdef SIGBUS
1707   signal (SIGBUS, crash_signal);
1708 #endif
1709 #ifdef SIGABRT
1710   signal (SIGABRT, crash_signal);
1711 #endif
1712 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1713   signal (SIGIOT, crash_signal);
1714 #endif
1715 #ifdef SIGFPE
1716   signal (SIGFPE, crash_signal);
1717 #endif
1718
1719   /* Other host-specific signal setup.  */
1720   (*host_hooks.extra_signals)();
1721
1722   /* Initialize the garbage-collector, string pools and tree type hash
1723      table.  */
1724   init_ggc ();
1725   init_stringpool ();
1726   line_table = GGC_NEW (struct line_maps);
1727   linemap_init (line_table);
1728   line_table->reallocator = realloc_for_line_map;
1729   init_ttree ();
1730
1731   /* Initialize register usage now so switches may override.  */
1732   init_reg_sets ();
1733
1734   /* Register the language-independent parameters.  */
1735   add_params (lang_independent_params, LAST_PARAM);
1736
1737   /* This must be done after add_params but before argument processing.  */
1738   init_ggc_heuristics();
1739   init_optimization_passes ();
1740   statistics_early_init ();
1741 }
1742
1743 /* Return true if the current target supports -fsection-anchors.  */
1744
1745 static bool
1746 target_supports_section_anchors_p (void)
1747 {
1748   if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
1749     return false;
1750
1751   if (targetm.asm_out.output_anchor == NULL)
1752     return false;
1753
1754   return true;
1755 }
1756
1757 /* Default the align_* variables to 1 if they're still unset, and
1758    set up the align_*_log variables.  */
1759 static void
1760 init_alignments (void)
1761 {
1762   if (align_loops <= 0)
1763     align_loops = 1;
1764   if (align_loops_max_skip > align_loops)
1765     align_loops_max_skip = align_loops - 1;
1766   align_loops_log = floor_log2 (align_loops * 2 - 1);
1767   if (align_jumps <= 0)
1768     align_jumps = 1;
1769   if (align_jumps_max_skip > align_jumps)
1770     align_jumps_max_skip = align_jumps - 1;
1771   align_jumps_log = floor_log2 (align_jumps * 2 - 1);
1772   if (align_labels <= 0)
1773     align_labels = 1;
1774   align_labels_log = floor_log2 (align_labels * 2 - 1);
1775   if (align_labels_max_skip > align_labels)
1776     align_labels_max_skip = align_labels - 1;
1777   if (align_functions <= 0)
1778     align_functions = 1;
1779   align_functions_log = floor_log2 (align_functions * 2 - 1);
1780 }
1781
1782 /* Process the options that have been parsed.  */
1783 static void
1784 process_options (void)
1785 {
1786   /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1787      This can happen with incorrect pre-processed input. */
1788   debug_hooks = &do_nothing_debug_hooks;
1789
1790   /* This replaces set_Wunused.  */
1791   if (warn_unused_function == -1)
1792     warn_unused_function = warn_unused;
1793   if (warn_unused_label == -1)
1794     warn_unused_label = warn_unused;
1795   /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled.  */
1796   if (warn_unused_parameter == -1)
1797     warn_unused_parameter = (warn_unused && extra_warnings);
1798   if (warn_unused_variable == -1)
1799     warn_unused_variable = warn_unused;
1800   /* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
1801      enabled.  */
1802   if (warn_unused_but_set_parameter == -1)
1803     warn_unused_but_set_parameter = (warn_unused && extra_warnings);
1804   if (warn_unused_but_set_variable == -1)
1805     warn_unused_but_set_variable = warn_unused;
1806   if (warn_unused_value == -1)
1807     warn_unused_value = warn_unused;
1808
1809   /* This replaces set_Wextra.  */
1810   if (warn_uninitialized == -1)
1811     warn_uninitialized = extra_warnings;
1812
1813   /* Allow the front end to perform consistency checks and do further
1814      initialization based on the command line options.  This hook also
1815      sets the original filename if appropriate (e.g. foo.i -> foo.c)
1816      so we can correctly initialize debug output.  */
1817   no_backend = lang_hooks.post_options (&main_input_filename);
1818
1819 #ifdef OVERRIDE_OPTIONS
1820   /* Some machines may reject certain combinations of options.  */
1821   OVERRIDE_OPTIONS;
1822 #endif
1823
1824   /* Avoid any informative notes in the second run of -fcompare-debug.  */
1825   if (flag_compare_debug) 
1826     diagnostic_inhibit_notes (global_dc);
1827
1828   if (flag_section_anchors && !target_supports_section_anchors_p ())
1829     {
1830       warning (OPT_fsection_anchors,
1831                "this target does not support %qs", "-fsection-anchors");
1832       flag_section_anchors = 0;
1833     }
1834
1835   if (flag_short_enums == 2)
1836     flag_short_enums = targetm.default_short_enums ();
1837
1838   /* Set aux_base_name if not already set.  */
1839   if (aux_base_name)
1840     ;
1841   else if (main_input_filename)
1842     {
1843       char *name = xstrdup (lbasename (main_input_filename));
1844
1845       strip_off_ending (name, strlen (name));
1846       aux_base_name = name;
1847     }
1848   else
1849     aux_base_name = "gccaux";
1850
1851 #ifndef HAVE_cloog
1852   if (flag_graphite
1853       || flag_loop_block
1854       || flag_loop_interchange
1855       || flag_loop_strip_mine
1856       || flag_graphite_identity
1857       || flag_loop_parallelize_all)
1858     sorry ("Graphite loop optimizations cannot be used");
1859 #endif
1860
1861   /* Unrolling all loops implies that standard loop unrolling must also
1862      be done.  */
1863   if (flag_unroll_all_loops)
1864     flag_unroll_loops = 1;
1865
1866   /* The loop unrolling code assumes that cse will be run after loop.
1867      web and rename-registers also help when run after loop unrolling.  */
1868   if (flag_rerun_cse_after_loop == AUTODETECT_VALUE)
1869     flag_rerun_cse_after_loop = flag_unroll_loops || flag_peel_loops;
1870
1871   if (flag_web == AUTODETECT_VALUE)
1872     flag_web = flag_unroll_loops || flag_peel_loops;
1873
1874   if (flag_rename_registers == AUTODETECT_VALUE)
1875     flag_rename_registers = flag_unroll_loops || flag_peel_loops;
1876
1877   if (flag_non_call_exceptions)
1878     flag_asynchronous_unwind_tables = 1;
1879   if (flag_asynchronous_unwind_tables)
1880     flag_unwind_tables = 1;
1881
1882   if (flag_value_profile_transformations)
1883     flag_profile_values = 1;
1884
1885   /* Warn about options that are not supported on this machine.  */
1886 #ifndef INSN_SCHEDULING
1887   if (flag_schedule_insns || flag_schedule_insns_after_reload)
1888     warning (0, "instruction scheduling not supported on this target machine");
1889 #endif
1890 #ifndef DELAY_SLOTS
1891   if (flag_delayed_branch)
1892     warning (0, "this target machine does not have delayed branches");
1893 #endif
1894
1895   user_label_prefix = USER_LABEL_PREFIX;
1896   if (flag_leading_underscore != -1)
1897     {
1898       /* If the default prefix is more complicated than "" or "_",
1899          issue a warning and ignore this option.  */
1900       if (user_label_prefix[0] == 0 ||
1901           (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1902         {
1903           user_label_prefix = flag_leading_underscore ? "_" : "";
1904         }
1905       else
1906         warning (0, "-f%sleading-underscore not supported on this target machine",
1907                  flag_leading_underscore ? "" : "no-");
1908     }
1909
1910   /* If we are in verbose mode, write out the version and maybe all the
1911      option flags in use.  */
1912   if (version_flag)
1913     {
1914       print_version (stderr, "");
1915       if (! quiet_flag)
1916         print_switch_values (print_to_stderr);
1917     }
1918
1919   if (flag_syntax_only)
1920     {
1921       write_symbols = NO_DEBUG;
1922       profile_flag = 0;
1923     }
1924
1925   if (flag_gtoggle)
1926     {
1927       if (debug_info_level == DINFO_LEVEL_NONE)
1928         {
1929           debug_info_level = DINFO_LEVEL_NORMAL;
1930
1931           if (write_symbols == NO_DEBUG)
1932             write_symbols = PREFERRED_DEBUGGING_TYPE;
1933         }
1934       else
1935         debug_info_level = DINFO_LEVEL_NONE;
1936     }
1937
1938   if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
1939     {
1940       FILE *final_output = fopen (flag_dump_final_insns, "w");
1941       if (!final_output)
1942         {
1943           error ("could not open final insn dump file %qs: %s",
1944                  flag_dump_final_insns, strerror (errno));
1945           flag_dump_final_insns = NULL;
1946         }
1947       else if (fclose (final_output))
1948         {
1949           error ("could not close zeroed insn dump file %qs: %s",
1950                  flag_dump_final_insns, strerror (errno));
1951           flag_dump_final_insns = NULL;
1952         }
1953     }
1954
1955   /* Unless over-ridden for the target, assume that all DWARF levels
1956      may be emitted, if DWARF2_DEBUG is selected.  */
1957   if (dwarf_strict < 0)
1958     dwarf_strict = 0;
1959
1960   /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1961      level is 0.  */
1962   if (debug_info_level == DINFO_LEVEL_NONE)
1963     write_symbols = NO_DEBUG;
1964
1965   /* Now we know write_symbols, set up the debug hooks based on it.
1966      By default we do nothing for debug output.  */
1967   if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
1968     default_debug_hooks = &do_nothing_debug_hooks;
1969 #if defined(DBX_DEBUGGING_INFO)
1970   else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
1971     default_debug_hooks = &dbx_debug_hooks;
1972 #endif
1973 #if defined(XCOFF_DEBUGGING_INFO)
1974   else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
1975     default_debug_hooks = &xcoff_debug_hooks;
1976 #endif
1977 #ifdef SDB_DEBUGGING_INFO
1978   else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
1979     default_debug_hooks = &sdb_debug_hooks;
1980 #endif
1981 #ifdef DWARF2_DEBUGGING_INFO
1982   else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
1983     default_debug_hooks = &dwarf2_debug_hooks;
1984 #endif
1985 #ifdef VMS_DEBUGGING_INFO
1986   else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
1987            || PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
1988     default_debug_hooks = &vmsdbg_debug_hooks;
1989 #endif
1990
1991   if (write_symbols == NO_DEBUG)
1992     ;
1993 #if defined(DBX_DEBUGGING_INFO)
1994   else if (write_symbols == DBX_DEBUG)
1995     debug_hooks = &dbx_debug_hooks;
1996 #endif
1997 #if defined(XCOFF_DEBUGGING_INFO)
1998   else if (write_symbols == XCOFF_DEBUG)
1999     debug_hooks = &xcoff_debug_hooks;
2000 #endif
2001 #ifdef SDB_DEBUGGING_INFO
2002   else if (write_symbols == SDB_DEBUG)
2003     debug_hooks = &sdb_debug_hooks;
2004 #endif
2005 #ifdef DWARF2_DEBUGGING_INFO
2006   else if (write_symbols == DWARF2_DEBUG)
2007     debug_hooks = &dwarf2_debug_hooks;
2008 #endif
2009 #ifdef VMS_DEBUGGING_INFO
2010   else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
2011     debug_hooks = &vmsdbg_debug_hooks;
2012 #endif
2013   else
2014     error ("target system does not support the \"%s\" debug format",
2015            debug_type_names[write_symbols]);
2016
2017   /* We know which debug output will be used so we can set flag_var_tracking
2018      and flag_var_tracking_uninit if the user has not specified them.  */
2019   if (debug_info_level < DINFO_LEVEL_NORMAL
2020       || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
2021     {
2022       if (flag_var_tracking == 1
2023           || flag_var_tracking_uninit == 1)
2024         {
2025           if (debug_info_level < DINFO_LEVEL_NORMAL)
2026             warning (0, "variable tracking requested, but useless unless "
2027                      "producing debug info");
2028           else
2029             warning (0, "variable tracking requested, but not supported "
2030                      "by this debug format");
2031         }
2032       flag_var_tracking = 0;
2033       flag_var_tracking_uninit = 0;
2034     }
2035
2036   /* If the user specifically requested variable tracking with tagging
2037      uninitialized variables, we need to turn on variable tracking.
2038      (We already determined above that variable tracking is feasible.)  */
2039   if (flag_var_tracking_uninit)
2040     flag_var_tracking = 1;
2041
2042   if (flag_var_tracking == AUTODETECT_VALUE)
2043     flag_var_tracking = optimize >= 1;
2044
2045   if (flag_var_tracking_assignments == AUTODETECT_VALUE)
2046     flag_var_tracking_assignments = flag_var_tracking
2047       && !(flag_selective_scheduling || flag_selective_scheduling2);
2048
2049   if (flag_var_tracking_assignments_toggle)
2050     flag_var_tracking_assignments = !flag_var_tracking_assignments;
2051
2052   if (flag_var_tracking_assignments && !flag_var_tracking)
2053     flag_var_tracking = flag_var_tracking_assignments = -1;
2054
2055   if (flag_var_tracking_assignments
2056       && (flag_selective_scheduling || flag_selective_scheduling2))
2057     warning (0, "var-tracking-assignments changes selective scheduling");
2058
2059   if (flag_tree_cselim == AUTODETECT_VALUE)
2060 #ifdef HAVE_conditional_move
2061     flag_tree_cselim = 1;
2062 #else
2063     flag_tree_cselim = 0;
2064 #endif
2065
2066   /* If auxiliary info generation is desired, open the output file.
2067      This goes in the same directory as the source file--unlike
2068      all the other output files.  */
2069   if (flag_gen_aux_info)
2070     {
2071       aux_info_file = fopen (aux_info_file_name, "w");
2072       if (aux_info_file == 0)
2073         fatal_error ("can%'t open %s: %m", aux_info_file_name);
2074     }
2075
2076   if (! targetm.have_named_sections)
2077     {
2078       if (flag_function_sections)
2079         {
2080           warning (0, "-ffunction-sections not supported for this target");
2081           flag_function_sections = 0;
2082         }
2083       if (flag_data_sections)
2084         {
2085           warning (0, "-fdata-sections not supported for this target");
2086           flag_data_sections = 0;
2087         }
2088     }
2089
2090   if (flag_function_sections && profile_flag)
2091     {
2092       warning (0, "-ffunction-sections disabled; it makes profiling impossible");
2093       flag_function_sections = 0;
2094     }
2095
2096 #ifndef HAVE_prefetch
2097   if (flag_prefetch_loop_arrays)
2098     {
2099       warning (0, "-fprefetch-loop-arrays not supported for this target");
2100       flag_prefetch_loop_arrays = 0;
2101     }
2102 #else
2103   if (flag_prefetch_loop_arrays && !HAVE_prefetch)
2104     {
2105       warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
2106       flag_prefetch_loop_arrays = 0;
2107     }
2108 #endif
2109
2110   /* This combination of options isn't handled for i386 targets and doesn't
2111      make much sense anyway, so don't allow it.  */
2112   if (flag_prefetch_loop_arrays && optimize_size)
2113     {
2114       warning (0, "-fprefetch-loop-arrays is not supported with -Os");
2115       flag_prefetch_loop_arrays = 0;
2116     }
2117
2118   /* The presence of IEEE signaling NaNs, implies all math can trap.  */
2119   if (flag_signaling_nans)
2120     flag_trapping_math = 1;
2121
2122   /* We cannot reassociate if we want traps or signed zeros.  */
2123   if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
2124     {
2125       warning (0, "-fassociative-math disabled; other options take precedence");
2126       flag_associative_math = 0;
2127     }
2128
2129   /* With -fcx-limited-range, we do cheap and quick complex arithmetic.  */
2130   if (flag_cx_limited_range)
2131     flag_complex_method = 0;
2132
2133   /* With -fcx-fortran-rules, we do something in-between cheap and C99.  */
2134   if (flag_cx_fortran_rules)
2135     flag_complex_method = 1;
2136
2137   /* Targets must be able to place spill slots at lower addresses.  If the
2138      target already uses a soft frame pointer, the transition is trivial.  */
2139   if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
2140     {
2141       warning (0, "-fstack-protector not supported for this target");
2142       flag_stack_protect = 0;
2143     }
2144   if (!flag_stack_protect)
2145     warn_stack_protect = 0;
2146
2147   /* ??? Unwind info is not correct around the CFG unless either a frame
2148      pointer is present or A_O_A is set.  Fixing this requires rewriting
2149      unwind info generation to be aware of the CFG and propagating states
2150      around edges.  */
2151   if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
2152       && flag_omit_frame_pointer)
2153     {
2154       warning (0, "unwind tables currently require a frame pointer "
2155                "for correctness");
2156       flag_omit_frame_pointer = 0;
2157     }
2158
2159   /* Save the current optimization options.  */
2160   optimization_default_node = build_optimization_node ();
2161   optimization_current_node = optimization_default_node;
2162 }
2163
2164 /* This function can be called multiple times to reinitialize the compiler
2165    back end when register classes or instruction sets have changed,
2166    before each function.  */
2167 static void
2168 backend_init_target (void)
2169 {
2170   /* Initialize alignment variables.  */
2171   init_alignments ();
2172
2173   /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
2174      to initialize reg_raw_mode[].  */
2175   init_emit_regs ();
2176
2177   /* This invokes target hooks to set fixed_reg[] etc, which is
2178      mode-dependent.  */
2179   init_regs ();
2180
2181   /* This depends on stack_pointer_rtx.  */
2182   init_fake_stack_mems ();
2183
2184   /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
2185      mode-dependent.  */
2186   init_alias_target ();
2187
2188   /* Depends on HARD_FRAME_POINTER_REGNUM.  */
2189   init_reload ();
2190
2191   /* The following initialization functions need to generate rtl, so
2192      provide a dummy function context for them.  */
2193   init_dummy_function_start ();
2194
2195   /* rtx_cost is mode-dependent, so cached values need to be recomputed
2196      on a mode change.  */
2197   init_expmed ();
2198
2199   /* We may need to recompute regno_save_code[] and regno_restore_code[]
2200      after a mode change as well.  */
2201   caller_save_initialized_p = false;
2202
2203   expand_dummy_function_end ();
2204 }
2205
2206 /* Initialize the compiler back end.  This function is called only once,
2207    when starting the compiler.  */
2208 static void
2209 backend_init (void)
2210 {
2211   init_emit_once ();
2212
2213   init_rtlanal ();
2214   init_inline_once ();
2215   init_varasm_once ();
2216   save_register_info ();
2217
2218   /* Initialize the target-specific back end pieces.  */
2219   ira_init_once ();
2220   backend_init_target ();
2221 }
2222
2223 /* Initialize excess precision settings.  */
2224 static void
2225 init_excess_precision (void)
2226 {
2227   /* Adjust excess precision handling based on the target options.  If
2228      the front end cannot handle it, flag_excess_precision_cmdline
2229      will already have been set accordingly in the post_options
2230      hook.  */
2231   gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
2232   flag_excess_precision = flag_excess_precision_cmdline;
2233   if (flag_unsafe_math_optimizations)
2234     flag_excess_precision = EXCESS_PRECISION_FAST;
2235   if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
2236     {
2237       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
2238       switch (flt_eval_method)
2239         {
2240         case -1:
2241         case 0:
2242           /* Either the target acts unpredictably (-1) or has all the
2243              operations required not to have excess precision (0).  */
2244           flag_excess_precision = EXCESS_PRECISION_FAST;
2245           break;
2246         case 1:
2247         case 2:
2248           /* In these cases, predictable excess precision makes
2249              sense.  */
2250           break;
2251         default:
2252           /* Any other implementation-defined FLT_EVAL_METHOD values
2253              require the compiler to handle the associated excess
2254              precision rules in excess_precision_type.  */
2255           gcc_unreachable ();
2256         }
2257     }
2258 }
2259
2260 /* Initialize things that are both lang-dependent and target-dependent.
2261    This function can be called more than once if target parameters change.  */
2262 static void
2263 lang_dependent_init_target (void)
2264 {
2265   /* This determines excess precision settings.  */
2266   init_excess_precision ();
2267
2268   /* This creates various _DECL nodes, so needs to be called after the
2269      front end is initialized.  It also depends on the HAVE_xxx macros
2270      generated from the target machine description.  */
2271   init_optabs ();
2272
2273   /* The following initialization functions need to generate rtl, so
2274      provide a dummy function context for them.  */
2275   init_dummy_function_start ();
2276
2277   /* Do the target-specific parts of expr initialization.  */
2278   init_expr_target ();
2279
2280   /* Although the actions of these functions are language-independent,
2281      they use optabs, so we cannot call them from backend_init.  */
2282   init_set_costs ();
2283   ira_init ();
2284
2285   expand_dummy_function_end ();
2286 }
2287
2288 /* Language-dependent initialization.  Returns nonzero on success.  */
2289 static int
2290 lang_dependent_init (const char *name)
2291 {
2292   location_t save_loc = input_location;
2293   if (dump_base_name == 0)
2294     dump_base_name = name && name[0] ? name : "gccdump";
2295
2296   /* Other front-end initialization.  */
2297   input_location = BUILTINS_LOCATION;
2298   if (lang_hooks.init () == 0)
2299     return 0;
2300   input_location = save_loc;
2301
2302   init_asm_output (name);
2303
2304   /* This creates various _DECL nodes, so needs to be called after the
2305      front end is initialized.  */
2306   init_eh ();
2307
2308   /* Do the target-specific parts of the initialization.  */
2309   lang_dependent_init_target ();
2310
2311   /* If dbx symbol table desired, initialize writing it and output the
2312      predefined types.  */
2313   timevar_push (TV_SYMOUT);
2314
2315 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
2316   if (dwarf2out_do_frame ())
2317     dwarf2out_frame_init ();
2318 #endif
2319
2320   /* Now we have the correct original filename, we can initialize
2321      debug output.  */
2322   (*debug_hooks->init) (name);
2323
2324   timevar_pop (TV_SYMOUT);
2325
2326   return 1;
2327 }
2328
2329
2330 /* Reinitialize everything when target parameters, such as register usage,
2331    have changed.  */
2332 void
2333 target_reinit (void)
2334 {
2335   /* Reinitialize RTL backend.  */
2336   backend_init_target ();
2337
2338   /* Reinitialize lang-dependent parts.  */
2339   lang_dependent_init_target ();
2340 }
2341
2342 void
2343 dump_memory_report (bool final)
2344 {
2345   ggc_print_statistics ();
2346   stringpool_statistics ();
2347   dump_tree_statistics ();
2348   dump_gimple_statistics ();
2349   dump_rtx_statistics ();
2350   dump_alloc_pool_statistics ();
2351   dump_bitmap_statistics ();
2352   dump_vec_loc_statistics ();
2353   dump_ggc_loc_statistics (final);
2354   dump_alias_stats (stderr);
2355   dump_pta_stats (stderr);
2356 }
2357
2358 /* Clean up: close opened files, etc.  */
2359
2360 static void
2361 finalize (void)
2362 {
2363   /* Close the dump files.  */
2364   if (flag_gen_aux_info)
2365     {
2366       fclose (aux_info_file);
2367       if (errorcount)
2368         unlink (aux_info_file_name);
2369     }
2370
2371   /* Close non-debugging input and output files.  Take special care to note
2372      whether fclose returns an error, since the pages might still be on the
2373      buffer chain while the file is open.  */
2374
2375   if (asm_out_file)
2376     {
2377       if (ferror (asm_out_file) != 0)
2378         fatal_error ("error writing to %s: %m", asm_file_name);
2379       if (fclose (asm_out_file) != 0)
2380         fatal_error ("error closing %s: %m", asm_file_name);
2381       if (flag_wpa)
2382         unlink_if_ordinary (asm_file_name);
2383     }
2384
2385   statistics_fini ();
2386   finish_optimization_passes ();
2387
2388   ira_finish_once ();
2389
2390   if (mem_report)
2391     dump_memory_report (true);
2392
2393   /* Language-specific end of compilation actions.  */
2394   lang_hooks.finish ();
2395 }
2396
2397 /* Initialize the compiler, and compile the input file.  */
2398 static void
2399 do_compile (void)
2400 {
2401   /* Initialize timing first.  The C front ends read the main file in
2402      the post_options hook, and C++ does file timings.  */
2403   if (time_report || !quiet_flag  || flag_detailed_statistics)
2404     timevar_init ();
2405   timevar_start (TV_TOTAL);
2406
2407   process_options ();
2408
2409   /* Don't do any more if an error has already occurred.  */
2410   if (!errorcount)
2411     {
2412       /* This must be run always, because it is needed to compute the FP
2413          predefined macros, such as __LDBL_MAX__, for targets using non
2414          default FP formats.  */
2415       init_adjust_machine_modes ();
2416
2417       /* Set up the back-end if requested.  */
2418       if (!no_backend)
2419         backend_init ();
2420
2421       /* Language-dependent initialization.  Returns true on success.  */
2422       if (lang_dependent_init (main_input_filename))
2423         compile_file ();
2424
2425       finalize ();
2426     }
2427
2428   /* Stop timing and print the times.  */
2429   timevar_stop (TV_TOTAL);
2430   timevar_print (stderr);
2431 }
2432
2433 /* Entry point of cc1, cc1plus, jc1, f771, etc.
2434    Exit code is FATAL_EXIT_CODE if can't open files or if there were
2435    any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2436
2437    It is not safe to call this function more than once.  */
2438
2439 int
2440 toplev_main (int argc, char **argv)
2441 {
2442   expandargv (&argc, &argv);
2443
2444   save_argv = CONST_CAST2 (const char **, char **, argv);
2445
2446   /* Initialization of GCC's environment, and diagnostics.  */
2447   general_init (argv[0]);
2448
2449   /* Parse the options and do minimal processing; basically just
2450      enough to default flags appropriately.  */
2451   decode_options (argc, CONST_CAST2 (const char **, char **, argv));
2452
2453   init_local_tick ();
2454
2455   initialize_plugins ();
2456
2457   if (version_flag)
2458     print_version (stderr, "");
2459
2460   if (help_flag)
2461     print_plugins_help (stderr, "");
2462
2463   /* Exit early if we can (e.g. -help).  */
2464   if (!exit_after_options)
2465     do_compile ();
2466
2467   if (warningcount || errorcount)
2468     print_ignored_options ();
2469   diagnostic_finish (global_dc);
2470
2471   /* Invoke registered plugin callbacks if any.  */
2472   invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
2473
2474   finalize_plugins ();
2475   if (errorcount || sorrycount)
2476     return (FATAL_EXIT_CODE);
2477
2478   return (SUCCESS_EXIT_CODE);
2479 }