OSDN Git Service

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