OSDN Git Service

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