OSDN Git Service

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