OSDN Git Service

* toplev.c (wrapup_global_declarations): Clarify variable handling.
[pf3gnuchains/gcc-fork.git] / gcc / toplev.c
1 /* Top level of GNU C compiler
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
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 <signal.h>
32 #include <setjmp.h>
33
34 #ifdef HAVE_SYS_RESOURCE_H
35 # include <sys/resource.h>
36 #endif
37
38 #ifdef HAVE_SYS_TIMES_H
39 # include <sys/times.h>
40 #endif
41
42 #include "input.h"
43 #include "tree.h"
44 #include "rtl.h"
45 #include "tm_p.h"
46 #include "flags.h"
47 #include "insn-attr.h"
48 #include "insn-config.h"
49 #include "insn-flags.h"
50 #include "hard-reg-set.h"
51 #include "recog.h"
52 #include "output.h"
53 #include "except.h"
54 #include "function.h"
55 #include "toplev.h"
56 #include "expr.h"
57 #include "basic-block.h"
58 #include "intl.h"
59 #include "ggc.h"
60 #include "graph.h"
61 #include "loop.h"
62 #include "regs.h"
63 #include "timevar.h"
64 #include "diagnostic.h"
65 #include "ssa.h"
66 #include "params.h"
67 #include "reload.h"
68 #include "dwarf2asm.h"
69 #include "integrate.h"
70 #include "debug.h"
71 #include "target.h"
72 #include "langhooks.h"
73
74 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
75 #include "dwarf2out.h"
76 #endif
77
78 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
79 #include "dbxout.h"
80 #endif
81
82 #ifdef SDB_DEBUGGING_INFO
83 #include "sdbout.h"
84 #endif
85
86 #ifdef XCOFF_DEBUGGING_INFO
87 #include "xcoffout.h"           /* Needed for external data
88                                    declarations for e.g. AIX 4.x.  */
89 #endif
90
91 #ifdef HALF_PIC_DEBUG
92 #include "halfpic.h"
93 #endif
94 \f
95 /* Carry information from ASM_DECLARE_OBJECT_NAME
96    to ASM_FINISH_DECLARE_OBJECT.  */
97
98 extern int size_directive_output;
99 extern tree last_assemble_variable_decl;
100
101 static void general_init PARAMS ((char *));
102 static void parse_options_and_default_flags PARAMS ((int, char **));
103 static void do_compile PARAMS ((void));
104 static void process_options PARAMS ((void));
105 static void lang_independent_init PARAMS ((void));
106 static int lang_dependent_init PARAMS ((const char *));
107 static void init_asm_output PARAMS ((const char *));
108 static void finalize PARAMS ((void));
109
110 static void set_target_switch PARAMS ((const char *));
111 static const char *decl_name PARAMS ((tree, int));
112
113 static void float_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
114 static void crash_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
115 static void set_float_handler PARAMS ((jmp_buf));
116 static void compile_file PARAMS ((void));
117 static void display_help PARAMS ((void));
118 static void display_target_options PARAMS ((void));
119
120 static void decode_d_option PARAMS ((const char *));
121 static int decode_f_option PARAMS ((const char *));
122 static int decode_W_option PARAMS ((const char *));
123 static int decode_g_option PARAMS ((const char *));
124 static unsigned int independent_decode_option PARAMS ((int, char **));
125
126 static void print_version PARAMS ((FILE *, const char *));
127 static int print_single_switch PARAMS ((FILE *, int, int, const char *,
128                                       const char *, const char *,
129                                       const char *, const char *));
130 static void print_switch_values PARAMS ((FILE *, int, int, const char *,
131                                        const char *, const char *));
132
133 /* Length of line when printing switch values.  */
134 #define MAX_LINE 75
135
136 /* Name of program invoked, sans directories.  */
137
138 const char *progname;
139
140 /* Copy of arguments to toplev_main.  */
141 int save_argc;
142 char **save_argv;
143 \f
144 /* Name of current original source file (what was input to cpp).
145    This comes from each #-command in the actual input.  */
146
147 const char *input_filename;
148
149 /* Name of top-level original source file (what was input to cpp).
150    This comes from the #-command at the beginning of the actual input.
151    If there isn't any there, then this is the cc1 input file name.  */
152
153 const char *main_input_filename;
154
155 /* Current line number in real source file.  */
156
157 int lineno;
158
159 /* Nonzero if it is unsafe to create any new pseudo registers.  */
160 int no_new_pseudos;
161
162 /* Stack of currently pending input files.  */
163
164 struct file_stack *input_file_stack;
165
166 /* Incremented on each change to input_file_stack.  */
167 int input_file_stack_tick;
168
169 /* Name to use as base of names for dump output files.  */
170
171 const char *dump_base_name;
172
173 /* Format to use to print dumpfile index value */
174 #ifndef DUMPFILE_FORMAT
175 #define DUMPFILE_FORMAT ".%02d."
176 #endif
177
178 /* Bit flags that specify the machine subtype we are compiling for.
179    Bits are tested using macros TARGET_... defined in the tm.h file
180    and set by `-m...' switches.  Must be defined in rtlanal.c.  */
181
182 extern int target_flags;
183
184 /* Debug hooks - dependent upon command line options.  */
185
186 const struct gcc_debug_hooks *debug_hooks = &do_nothing_debug_hooks;
187
188 /* Describes a dump file.  */
189
190 struct dump_file_info
191 {
192   /* The unique extension to apply, e.g. ".jump".  */
193   const char *const extension;
194
195   /* The -d<c> character that enables this dump file.  */
196   char const debug_switch;
197
198   /* True if there is a corresponding graph dump file.  */
199   char const graph_dump_p;
200
201   /* True if the user selected this dump.  */
202   char enabled;
203
204   /* True if the files have been initialized (ie truncated).  */
205   char initialized;
206 };
207
208 /* Enumerate the extant dump files.  */
209
210 enum dump_file_index
211 {
212   DFI_rtl,
213   DFI_sibling,
214   DFI_eh,
215   DFI_jump,
216   DFI_ssa,
217   DFI_ssa_ccp,
218   DFI_ssa_dce,
219   DFI_ussa,
220   DFI_null,
221   DFI_cse,
222   DFI_addressof,
223   DFI_gcse,
224   DFI_loop,
225   DFI_cfg,
226   DFI_bp,
227   DFI_cse2,
228   DFI_life,
229   DFI_combine,
230   DFI_ce,
231   DFI_regmove,
232   DFI_sched,
233   DFI_lreg,
234   DFI_greg,
235   DFI_postreload,
236   DFI_flow2,
237   DFI_peephole2,
238   DFI_rnreg,
239   DFI_ce2,
240   DFI_sched2,
241   DFI_stack,
242   DFI_bbro,
243   DFI_mach,
244   DFI_dbr,
245   DFI_MAX
246 };
247
248 /* Describes all the dump files.  Should be kept in order of the
249    pass and in sync with dump_file_index above.
250
251    Remaining -d letters:
252
253         "              o q         "
254         "       H JK   OPQ  TUV  YZ"
255 */
256
257 static struct dump_file_info dump_file[DFI_MAX] =
258 {
259   { "rtl",      'r', 0, 0, 0 },
260   { "sibling",  'i', 0, 0, 0 },
261   { "eh",       'h', 0, 0, 0 },
262   { "jump",     'j', 0, 0, 0 },
263   { "ssa",      'e', 1, 0, 0 },
264   { "ssaccp",   'W', 1, 0, 0 },
265   { "ssadce",   'X', 1, 0, 0 },
266   { "ussa",     'e', 1, 0, 0 }, /* Yes, duplicate enable switch.  */
267   { "null",     'u', 0, 0, 0 },
268   { "cse",      's', 0, 0, 0 },
269   { "addressof", 'F', 0, 0, 0 },
270   { "gcse",     'G', 1, 0, 0 },
271   { "loop",     'L', 1, 0, 0 },
272   { "cfg",      'f', 1, 0, 0 },
273   { "bp",       'b', 1, 0, 0 },
274   { "cse2",     't', 1, 0, 0 },
275   { "life",     'f', 1, 0, 0 }, /* Yes, duplicate enable switch.  */
276   { "combine",  'c', 1, 0, 0 },
277   { "ce",       'C', 1, 0, 0 },
278   { "regmove",  'N', 1, 0, 0 },
279   { "sched",    'S', 1, 0, 0 },
280   { "lreg",     'l', 1, 0, 0 },
281   { "greg",     'g', 1, 0, 0 },
282   { "postreload", 'o', 1, 0, 0 },
283   { "flow2",    'w', 1, 0, 0 },
284   { "peephole2", 'z', 1, 0, 0 },
285   { "rnreg",    'n', 1, 0, 0 },
286   { "ce2",      'E', 1, 0, 0 },
287   { "sched2",   'R', 1, 0, 0 },
288   { "stack",    'k', 1, 0, 0 },
289   { "bbro",     'B', 1, 0, 0 },
290   { "mach",     'M', 1, 0, 0 },
291   { "dbr",      'd', 0, 0, 0 },
292 };
293
294 static int open_dump_file PARAMS ((enum dump_file_index, tree));
295 static void close_dump_file PARAMS ((enum dump_file_index,
296                                      void (*) (FILE *, rtx), rtx));
297
298 /* Other flags saying which kinds of debugging dump have been requested.  */
299
300 int rtl_dump_and_exit;
301 int flag_print_asm_name;
302 static int version_flag;
303 static char *filename;
304 enum graph_dump_types graph_dump_format;
305
306 /* Name for output file of assembly code, specified with -o.  */
307
308 char *asm_file_name;
309
310 /* Value of the -G xx switch, and whether it was passed or not.  */
311 int g_switch_value;
312 int g_switch_set;
313
314 /* Type(s) of debugging information we are producing (if any).
315    See flags.h for the definitions of the different possible
316    types of debugging information.  */
317 enum debug_info_type write_symbols = NO_DEBUG;
318
319 /* Level of debugging information we are producing.  See flags.h
320    for the definitions of the different possible levels.  */
321 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
322
323 /* Nonzero means use GNU-only extensions in the generated symbolic
324    debugging information.  */
325 /* Currently, this only has an effect when write_symbols is set to
326    DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
327 int use_gnu_debug_info_extensions = 0;
328
329 /* Nonzero means do optimizations.  -O.
330    Particular numeric values stand for particular amounts of optimization;
331    thus, -O2 stores 2 here.  However, the optimizations beyond the basic
332    ones are not controlled directly by this variable.  Instead, they are
333    controlled by individual `flag_...' variables that are defaulted
334    based on this variable.  */
335
336 int optimize = 0;
337
338 /* Nonzero means optimize for size.  -Os.
339    The only valid values are zero and non-zero. When optimize_size is
340    non-zero, optimize defaults to 2, but certain individual code
341    bloating optimizations are disabled.  */
342
343 int optimize_size = 0;
344
345 /* Nonzero if we should exit after parsing options.  */
346 static int exit_after_options = 0;
347
348 /* The FUNCTION_DECL for the function currently being compiled,
349    or 0 if between functions.  */
350 tree current_function_decl;
351
352 /* Set to the FUNC_BEGIN label of the current function, or NULL_TREE
353    if none.  */
354 tree current_function_func_begin_label;
355
356 /* Pointer to function to compute the name to use to print a declaration.
357    DECL is the declaration in question.
358    VERBOSITY determines what information will be printed:
359      0: DECL_NAME, demangled as necessary.
360      1: and scope information.
361      2: and any other information that might be interesting, such as function
362         parameter types in C++.  */
363
364 const char *(*decl_printable_name)      PARAMS ((tree, int));
365
366 /* Pointer to function to compute rtl for a language-specific tree code.  */
367
368 typedef rtx (*lang_expand_expr_t)
369   PARAMS ((union tree_node *, rtx, enum machine_mode,
370           enum expand_modifier modifier));
371
372 lang_expand_expr_t lang_expand_expr = 0;
373
374 /* Pointer to function to finish handling an incomplete decl at the
375    end of compilation.  */
376
377 void (*incomplete_decl_finalize_hook) PARAMS ((tree)) = 0;
378
379 /* Nonzero if doing dwarf2 duplicate elimination.  */
380
381 int flag_eliminate_dwarf2_dups = 0;
382
383 /* Nonzero if generating code to do profiling.  */
384
385 int profile_flag = 0;
386
387 /* Nonzero if generating code to profile program flow graph arcs.  */
388
389 int profile_arc_flag = 0;
390
391 /* Nonzero if generating info for gcov to calculate line test coverage.  */
392
393 int flag_test_coverage = 0;
394
395 /* Nonzero indicates that branch taken probabilities should be calculated.  */
396
397 int flag_branch_probabilities = 0;
398
399 /* Nonzero if basic blocks should be reordered.  */
400
401 int flag_reorder_blocks = 0;
402
403 /* Nonzero if registers should be renamed.  */
404
405 int flag_rename_registers = 0;
406 int flag_cprop_registers = 0;
407
408 /* Nonzero for -pedantic switch: warn about anything
409    that standard spec forbids.  */
410
411 int pedantic = 0;
412
413 /* Temporarily suppress certain warnings.
414    This is set while reading code from a system header file.  */
415
416 int in_system_header = 0;
417
418 /* Don't print functions as they are compiled.  -quiet.  */
419
420 int quiet_flag = 0;
421
422 /* Print times taken by the various passes.  -ftime-report.  */
423
424 int time_report = 0;
425
426 /* Print memory still in use at end of compilation (which may have little
427    to do with peak memory consumption).  -fmem-report.  */
428
429 int mem_report = 0;
430
431 /* Non-zero means to collect statistics which might be expensive
432    and to print them when we are done.  */
433 int flag_detailed_statistics = 0;
434
435 \f
436 /* -f flags.  */
437
438 /* Nonzero means `char' should be signed.  */
439
440 int flag_signed_char;
441
442 /* Nonzero means give an enum type only as many bytes as it needs.  */
443
444 int flag_short_enums;
445
446 /* Nonzero for -fcaller-saves: allocate values in regs that need to
447    be saved across function calls, if that produces overall better code.
448    Optional now, so people can test it.  */
449
450 #ifdef DEFAULT_CALLER_SAVES
451 int flag_caller_saves = 1;
452 #else
453 int flag_caller_saves = 0;
454 #endif
455
456 /* Nonzero if structures and unions should be returned in memory.
457
458    This should only be defined if compatibility with another compiler or
459    with an ABI is needed, because it results in slower code.  */
460
461 #ifndef DEFAULT_PCC_STRUCT_RETURN
462 #define DEFAULT_PCC_STRUCT_RETURN 1
463 #endif
464
465 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
466
467 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
468
469 /* Nonzero for -fforce-mem: load memory value into a register
470    before arithmetic on it.  This makes better cse but slower compilation.  */
471
472 int flag_force_mem = 0;
473
474 /* Nonzero for -fforce-addr: load memory address into a register before
475    reference to memory.  This makes better cse but slower compilation.  */
476
477 int flag_force_addr = 0;
478
479 /* Nonzero for -fdefer-pop: don't pop args after each function call;
480    instead save them up to pop many calls' args with one insns.  */
481
482 int flag_defer_pop = 0;
483
484 /* Nonzero for -ffloat-store: don't allocate floats and doubles
485    in extended-precision registers.  */
486
487 int flag_float_store = 0;
488
489 /* Nonzero for -fcse-follow-jumps:
490    have cse follow jumps to do a more extensive job.  */
491
492 int flag_cse_follow_jumps;
493
494 /* Nonzero for -fcse-skip-blocks:
495    have cse follow a branch around a block.  */
496 int flag_cse_skip_blocks;
497
498 /* Nonzero for -fexpensive-optimizations:
499    perform miscellaneous relatively-expensive optimizations.  */
500 int flag_expensive_optimizations;
501
502 /* Nonzero for -fthread-jumps:
503    have jump optimize output of loop.  */
504
505 int flag_thread_jumps;
506
507 /* Nonzero enables strength-reduction in loop.c.  */
508
509 int flag_strength_reduce = 0;
510
511 /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
512    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
513    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
514    unrolled.  */
515
516 int flag_unroll_loops;
517
518 /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
519    This is generally not a win.  */
520
521 int flag_unroll_all_loops;
522
523 /* Nonzero enables prefetch optimizations for arrays in loops.  */
524
525 int flag_prefetch_loop_arrays;
526
527 /* Nonzero forces all invariant computations in loops to be moved
528    outside the loop.  */
529
530 int flag_move_all_movables = 0;
531
532 /* Nonzero forces all general induction variables in loops to be
533    strength reduced.  */
534
535 int flag_reduce_all_givs = 0;
536
537 /* Nonzero to perform full register move optimization passes.  This is the
538    default for -O2.  */
539
540 int flag_regmove = 0;
541
542 /* Nonzero for -fwritable-strings:
543    store string constants in data segment and don't uniquize them.  */
544
545 int flag_writable_strings = 0;
546
547 /* Nonzero means don't put addresses of constant functions in registers.
548    Used for compiling the Unix kernel, where strange substitutions are
549    done on the assembly output.  */
550
551 int flag_no_function_cse = 0;
552
553 /* Nonzero for -fomit-frame-pointer:
554    don't make a frame pointer in simple functions that don't require one.  */
555
556 int flag_omit_frame_pointer = 0;
557
558 /* Nonzero means place each function into its own section on those platforms
559    which support arbitrary section names and unlimited numbers of sections.  */
560
561 int flag_function_sections = 0;
562
563 /* ... and similar for data.  */
564
565 int flag_data_sections = 0;
566
567 /* Nonzero to inhibit use of define_optimization peephole opts.  */
568
569 int flag_no_peephole = 0;
570
571 /* Nonzero allows GCC to optimize sibling and tail recursive calls.  */
572
573 int flag_optimize_sibling_calls = 0;
574
575 /* Nonzero means the front end generally wants `errno' maintained by math
576    operations, like built-in SQRT.  */
577
578 int flag_errno_math = 1;
579
580 /* Nonzero means that unsafe floating-point math optimizations are allowed
581    for the sake of speed.  IEEE compliance is not guaranteed, and operations
582    are allowed to assume that their arguments and results are "normal"
583    (e.g., nonnegative for SQRT).  */
584
585 int flag_unsafe_math_optimizations = 0;
586
587 /* Zero means that floating-point math operations cannot generate a
588    (user-visible) trap.  This is the case, for example, in nonstop
589    IEEE 754 arithmetic.  */
590
591 int flag_trapping_math = 1;
592
593 /* 0 means straightforward implementation of complex divide acceptable.
594    1 means wide ranges of inputs must work for complex divide.
595    2 means C99-like requirements for complex divide (not yet implemented).  */
596
597 int flag_complex_divide_method = 0;
598
599 /* Nonzero means all references through pointers are volatile.  */
600
601 int flag_volatile;
602
603 /* Nonzero means treat all global and extern variables as volatile.  */
604
605 int flag_volatile_global;
606
607 /* Nonzero means treat all static variables as volatile.  */
608
609 int flag_volatile_static;
610
611 /* Nonzero means just do syntax checking; don't output anything.  */
612
613 int flag_syntax_only = 0;
614
615 /* Nonzero means perform global cse.  */
616
617 static int flag_gcse;
618
619 /* Nonzero means to use global dataflow analysis to eliminate
620    useless null pointer tests.  */
621
622 static int flag_delete_null_pointer_checks;
623
624 /* Nonzero means to do the enhanced load motion during gcse, which trys
625    to hoist loads by not killing them when a store to the same location
626    is seen.  */
627
628 int flag_gcse_lm = 1;
629
630 /* Nonzero means to perform store motion after gcse, which will try to
631    move stores closer to the exit block.  Its not very effective without
632    flag_gcse_lm.  */
633
634 int flag_gcse_sm = 1;
635
636 /* Nonzero means to rerun cse after loop optimization.  This increases
637    compilation time about 20% and picks up a few more common expressions.  */
638
639 static int flag_rerun_cse_after_loop;
640
641 /* Nonzero means to run loop optimizations twice.  */
642
643 int flag_rerun_loop_opt;
644
645 /* Nonzero for -finline-functions: ok to inline functions that look like
646    good inline candidates.  */
647
648 int flag_inline_functions;
649
650 /* Nonzero for -fkeep-inline-functions: even if we make a function
651    go inline everywhere, keep its definition around for debugging
652    purposes.  */
653
654 int flag_keep_inline_functions;
655
656 /* Nonzero means that functions will not be inlined.  */
657
658 int flag_no_inline;
659
660 /* Nonzero means that we should emit static const variables
661    regardless of whether or not optimization is turned on.  */
662
663 int flag_keep_static_consts = 1;
664
665 /* Nonzero means we should be saving declaration info into a .X file.  */
666
667 int flag_gen_aux_info = 0;
668
669 /* Specified name of aux-info file.  */
670
671 static char *aux_info_file_name;
672
673 /* Nonzero means make the text shared if supported.  */
674
675 int flag_shared_data;
676
677 /* Nonzero means schedule into delayed branch slots if supported.  */
678
679 int flag_delayed_branch;
680
681 /* Nonzero if we are compiling pure (sharable) code.
682    Value is 1 if we are doing reasonable (i.e. simple
683    offset into offset table) pic.  Value is 2 if we can
684    only perform register offsets.  */
685
686 int flag_pic;
687
688 /* Nonzero means generate extra code for exception handling and enable
689    exception handling.  */
690
691 int flag_exceptions;
692
693 /* Nonzero means generate frame unwind info table when supported.  */
694
695 int flag_unwind_tables = 0;
696
697 /* Nonzero means generate frame unwind info table exact at each insn boundary */
698
699 int flag_asynchronous_unwind_tables = 0;
700
701 /* Nonzero means don't place uninitialized global data in common storage
702    by default.  */
703
704 int flag_no_common;
705
706 /* Nonzero means change certain warnings into errors.
707    Usually these are warnings about failure to conform to some standard.  */
708
709 int flag_pedantic_errors = 0;
710
711 /* flag_schedule_insns means schedule insns within basic blocks (before
712    local_alloc).
713    flag_schedule_insns_after_reload means schedule insns after
714    global_alloc.  */
715
716 int flag_schedule_insns = 0;
717 int flag_schedule_insns_after_reload = 0;
718
719 /* The following flags have effect only for scheduling before register
720    allocation:
721
722    flag_schedule_interblock means schedule insns accross basic blocks.
723    flag_schedule_speculative means allow speculative motion of non-load insns.
724    flag_schedule_speculative_load means allow speculative motion of some
725    load insns.
726    flag_schedule_speculative_load_dangerous allows speculative motion of more
727    load insns.  */
728
729 int flag_schedule_interblock = 1;
730 int flag_schedule_speculative = 1;
731 int flag_schedule_speculative_load = 0;
732 int flag_schedule_speculative_load_dangerous = 0;
733
734 int flag_single_precision_constant;
735
736 /* flag_branch_on_count_reg means try to replace add-1,compare,branch tupple
737    by a cheaper branch on a count register.  */
738 int flag_branch_on_count_reg = 1;
739
740 /* -finhibit-size-directive inhibits output of .size for ELF.
741    This is used only for compiling crtstuff.c,
742    and it may be extended to other effects
743    needed for crtstuff.c on other systems.  */
744 int flag_inhibit_size_directive = 0;
745
746 /* -fverbose-asm causes extra commentary information to be produced in
747    the generated assembly code (to make it more readable).  This option
748    is generally only of use to those who actually need to read the
749    generated assembly code (perhaps while debugging the compiler itself).
750    -fno-verbose-asm, the default, causes the extra information
751    to be omitted and is useful when comparing two assembler files.  */
752
753 int flag_verbose_asm = 0;
754
755 /* -dA causes debug commentary information to be produced in
756    the generated assembly code (to make it more readable).  This option
757    is generally only of use to those who actually need to read the
758    generated assembly code (perhaps while debugging the compiler itself).
759    Currently, this switch is only used by dwarfout.c; however, it is intended
760    to be a catchall for printing debug information in the assembler file.  */
761
762 int flag_debug_asm = 0;
763
764 /* -dP causes the rtl to be emitted as a comment in assembly.  */
765
766 int flag_dump_rtl_in_asm = 0;
767
768 /* -fgnu-linker specifies use of the GNU linker for initializations.
769    (Or, more generally, a linker that handles initializations.)
770    -fno-gnu-linker says that collect2 will be used.  */
771 #ifdef USE_COLLECT2
772 int flag_gnu_linker = 0;
773 #else
774 int flag_gnu_linker = 1;
775 #endif
776
777 /* Nonzero means put zero initialized data in the bss section.  */
778 int flag_zero_initialized_in_bss = 1;
779
780 /* Enable SSA.  */
781 int flag_ssa = 0;
782
783 /* Enable ssa conditional constant propagation.  */
784 int flag_ssa_ccp = 0;
785
786 /* Enable ssa aggressive dead code elimination.  */
787 int flag_ssa_dce = 0;
788
789 /* Tag all structures with __attribute__(packed).  */
790 int flag_pack_struct = 0;
791
792 /* Emit code to check for stack overflow; also may cause large objects
793    to be allocated dynamically.  */
794 int flag_stack_check;
795
796 /* When non-NULL, indicates that whenever space is allocated on the
797    stack, the resulting stack pointer must not pass this
798    address---that is, for stacks that grow downward, the stack pointer
799    must always be greater than or equal to this address; for stacks
800    that grow upward, the stack pointer must be less than this address.
801    At present, the rtx may be either a REG or a SYMBOL_REF, although
802    the support provided depends on the backend.  */
803 rtx stack_limit_rtx;
804
805 /* 0 if pointer arguments may alias each other.  True in C.
806    1 if pointer arguments may not alias each other but may alias
807    global variables.
808    2 if pointer arguments may not alias each other and may not
809    alias global variables.  True in Fortran.
810    This defaults to 0 for C.  */
811 int flag_argument_noalias = 0;
812
813 /* Nonzero if we should do (language-dependent) alias analysis.
814    Typically, this analysis will assume that expressions of certain
815    types do not alias expressions of certain other types.  Only used
816    if alias analysis (in general) is enabled.  */
817 int flag_strict_aliasing = 0;
818
819 /* Instrument functions with calls at entry and exit, for profiling.  */
820 int flag_instrument_function_entry_exit = 0;
821
822 /* Nonzero means ignore `#ident' directives.  0 means handle them.
823    On SVR4 targets, it also controls whether or not to emit a
824    string identifying the compiler.  */
825
826 int flag_no_ident = 0;
827
828 /* This will perform a peephole pass before sched2.  */
829 int flag_peephole2 = 0;
830
831 /* This will try to guess branch probabilities.  */
832 int flag_guess_branch_prob = 0;
833
834 /* -fbounded-pointers causes gcc to compile pointers as composite
835    objects occupying three words: the pointer value, the base address
836    of the referent object, and the address immediately beyond the end
837    of the referent object.  The base and extent allow us to perform
838    runtime bounds checking.  -fbounded-pointers implies -fcheck-bounds.  */
839 int flag_bounded_pointers = 0;
840
841 /* -fcheck-bounds causes gcc to generate array bounds checks.
842    For C, C++: defaults to value of flag_bounded_pointers.
843    For ObjC: defaults to off.
844    For Java: defaults to on.
845    For Fortran: defaults to off.
846    For CHILL: defaults to off.  */
847 int flag_bounds_check = 0;
848
849 /* This will attempt to merge constant section constants, if 1 only
850    string constants and constants from constant pool, if 2 also constant
851    variables.  */
852 int flag_merge_constants = 1;
853
854 /* If one, renumber instruction UIDs to reduce the number of
855    unused UIDs if there are a lot of instructions.  If greater than
856    one, unconditionally renumber instruction UIDs.  */
857 int flag_renumber_insns = 1;
858
859 /* Values of the -falign-* flags: how much to align labels in code.
860    0 means `use default', 1 means `don't align'.
861    For each variable, there is an _log variant which is the power
862    of two not less than the variable, for .align output.  */
863
864 int align_loops;
865 int align_loops_log;
866 int align_loops_max_skip;
867 int align_jumps;
868 int align_jumps_log;
869 int align_jumps_max_skip;
870 int align_labels;
871 int align_labels_log;
872 int align_labels_max_skip;
873 int align_functions;
874 int align_functions_log;
875
876 /* Table of supported debugging formats.  */
877 static const struct
878 {
879   const char *const arg;
880   /* Since PREFERRED_DEBUGGING_TYPE isn't necessarily a
881      constant expression, we use NO_DEBUG in its place.  */
882   const enum debug_info_type debug_type;
883   const int use_extensions_p;
884   const char *const description;
885 } *da,
886 debug_args[] =
887 {
888   { "",       NO_DEBUG, DEFAULT_GDB_EXTENSIONS,
889     N_("Generate debugging info in default format") },
890   { "gdb",    NO_DEBUG, 1, N_("Generate debugging info in default extended format") },
891 #ifdef DBX_DEBUGGING_INFO
892   { "stabs",  DBX_DEBUG, 0, N_("Generate STABS format debug info") },
893   { "stabs+", DBX_DEBUG, 1, N_("Generate extended STABS format debug info") },
894 #endif
895 #ifdef DWARF_DEBUGGING_INFO
896   { "dwarf",  DWARF_DEBUG, 0, N_("Generate DWARF-1 format debug info") },
897   { "dwarf+", DWARF_DEBUG, 1,
898     N_("Generate extended DWARF-1 format debug info") },
899 #endif
900 #ifdef DWARF2_DEBUGGING_INFO
901   { "dwarf-2", DWARF2_DEBUG, 0, N_("Generate DWARF-2 debug info") },
902 #endif
903 #ifdef XCOFF_DEBUGGING_INFO
904   { "xcoff",  XCOFF_DEBUG, 0, N_("Generate XCOFF format debug info") },
905   { "xcoff+", XCOFF_DEBUG, 1, N_("Generate extended XCOFF format debug info") },
906 #endif
907 #ifdef SDB_DEBUGGING_INFO
908   { "coff", SDB_DEBUG, 0, N_("Generate COFF format debug info") },
909 #endif
910 #ifdef VMS_DEBUGGING_INFO
911   { "vms", VMS_DEBUG, 0, N_("Generate VMS format debug info") },
912 #endif
913   { 0, 0, 0, 0 }
914 };
915
916 typedef struct
917 {
918   const char *const string;
919   int *const variable;
920   const int on_value;
921   const char *const description;
922 }
923 lang_independent_options;
924
925 int flag_trapv = 0;
926
927 /* Add or remove a leading underscore from user symbols.  */
928 int flag_leading_underscore = -1;
929
930 /* The user symbol prefix after having resolved same.  */
931 const char *user_label_prefix;
932
933 static const param_info lang_independent_params[] = {
934 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT) \
935   { OPTION, DEFAULT, HELP },
936 #include "params.def"
937 #undef DEFPARAM
938   { NULL, 0, NULL }
939 };
940
941 /* A default for same.  */
942 #ifndef USER_LABEL_PREFIX
943 #define USER_LABEL_PREFIX ""
944 #endif
945
946 /* Table of language-independent -f options.
947    STRING is the option name.  VARIABLE is the address of the variable.
948    ON_VALUE is the value to store in VARIABLE
949     if `-fSTRING' is seen as an option.
950    (If `-fno-STRING' is seen as an option, the opposite value is stored.)  */
951
952 static const lang_independent_options f_options[] =
953 {
954   {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
955    N_("Perform DWARF2 duplicate elimination") },
956   {"float-store", &flag_float_store, 1,
957    N_("Do not store floats in registers") },
958   {"volatile", &flag_volatile, 1,
959    N_("Consider all mem refs through pointers as volatile") },
960   {"volatile-global", &flag_volatile_global, 1,
961    N_("Consider all mem refs to global data to be volatile") },
962   {"volatile-static", &flag_volatile_static, 1,
963    N_("Consider all mem refs to static data to be volatile") },
964   {"defer-pop", &flag_defer_pop, 1,
965    N_("Defer popping functions args from stack until later") },
966   {"omit-frame-pointer", &flag_omit_frame_pointer, 1,
967    N_("When possible do not generate stack frames") },
968   {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
969    N_("Optimize sibling and tail recursive calls") },
970   {"cse-follow-jumps", &flag_cse_follow_jumps, 1,
971    N_("When running CSE, follow jumps to their targets") },
972   {"cse-skip-blocks", &flag_cse_skip_blocks, 1,
973    N_("When running CSE, follow conditional jumps") },
974   {"expensive-optimizations", &flag_expensive_optimizations, 1,
975    N_("Perform a number of minor, expensive optimizations") },
976   {"thread-jumps", &flag_thread_jumps, 1,
977    N_("Perform jump threading optimizations") },
978   {"strength-reduce", &flag_strength_reduce, 1,
979    N_("Perform strength reduction optimizations") },
980   {"unroll-loops", &flag_unroll_loops, 1,
981    N_("Perform loop unrolling when iteration count is known") },
982   {"unroll-all-loops", &flag_unroll_all_loops, 1,
983    N_("Perform loop unrolling for all loops") },
984   {"prefetch-loop-arrays", &flag_prefetch_loop_arrays, 1,
985    N_("Generate prefetch instructions, if available, for arrays in loops") },
986   {"move-all-movables", &flag_move_all_movables, 1,
987    N_("Force all loop invariant computations out of loops") },
988   {"reduce-all-givs", &flag_reduce_all_givs, 1,
989    N_("Strength reduce all loop general induction variables") },
990   {"writable-strings", &flag_writable_strings, 1,
991    N_("Store strings in writable data section") },
992   {"peephole", &flag_no_peephole, 0,
993    N_("Enable machine specific peephole optimizations") },
994   {"force-mem", &flag_force_mem, 1,
995    N_("Copy memory operands into registers before using") },
996   {"force-addr", &flag_force_addr, 1,
997    N_("Copy memory address constants into regs before using") },
998   {"function-cse", &flag_no_function_cse, 0,
999    N_("Allow function addresses to be held in registers") },
1000   {"inline-functions", &flag_inline_functions, 1,
1001    N_("Integrate simple functions into their callers") },
1002   {"keep-inline-functions", &flag_keep_inline_functions, 1,
1003    N_("Generate code for funcs even if they are fully inlined") },
1004   {"inline", &flag_no_inline, 0,
1005    N_("Pay attention to the 'inline' keyword") },
1006   {"keep-static-consts", &flag_keep_static_consts, 1,
1007    N_("Emit static const variables even if they are not used") },
1008   {"syntax-only", &flag_syntax_only, 1,
1009    N_("Check for syntax errors, then stop") },
1010   {"shared-data", &flag_shared_data, 1,
1011    N_("Mark data as shared rather than private") },
1012   {"caller-saves", &flag_caller_saves, 1,
1013    N_("Enable saving registers around function calls") },
1014   {"pcc-struct-return", &flag_pcc_struct_return, 1,
1015    N_("Return 'short' aggregates in memory, not registers") },
1016   {"reg-struct-return", &flag_pcc_struct_return, 0,
1017    N_("Return 'short' aggregates in registers") },
1018   {"delayed-branch", &flag_delayed_branch, 1,
1019    N_("Attempt to fill delay slots of branch instructions") },
1020   {"gcse", &flag_gcse, 1,
1021    N_("Perform the global common subexpression elimination") },
1022   {"gcse-lm", &flag_gcse_lm, 1,
1023    N_("Perform enhanced load motion during global subexpression elimination") },
1024   {"gcse-sm", &flag_gcse_sm, 1,
1025    N_("Perform store motion after global subexpression elimination") },
1026   {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
1027    N_("Run CSE pass after loop optimizations") },
1028   {"rerun-loop-opt", &flag_rerun_loop_opt, 1,
1029    N_("Run the loop optimizer twice") },
1030   {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
1031    N_("Delete useless null pointer checks") },
1032   {"schedule-insns", &flag_schedule_insns, 1,
1033    N_("Reschedule instructions before register allocation") },
1034   {"schedule-insns2", &flag_schedule_insns_after_reload, 1,
1035    N_("Reschedule instructions after register allocation") },
1036   {"sched-interblock",&flag_schedule_interblock, 1,
1037    N_("Enable scheduling across basic blocks") },
1038   {"sched-spec",&flag_schedule_speculative, 1,
1039    N_("Allow speculative motion of non-loads") },
1040   {"sched-spec-load",&flag_schedule_speculative_load, 1,
1041    N_("Allow speculative motion of some loads") },
1042   {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
1043    N_("Allow speculative motion of more loads") },
1044   {"branch-count-reg",&flag_branch_on_count_reg, 1,
1045    N_("Replace add,compare,branch with branch on count reg") },
1046   {"pic", &flag_pic, 1,
1047    N_("Generate position independent code, if possible") },
1048   {"PIC", &flag_pic, 2, ""},
1049   {"exceptions", &flag_exceptions, 1,
1050    N_("Enable exception handling") },
1051   {"unwind-tables", &flag_unwind_tables, 1,
1052    N_("Just generate unwind tables for exception handling") },
1053   {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1,
1054    N_("Generate unwind tables exact at each instruction boundary") },
1055   {"non-call-exceptions", &flag_non_call_exceptions, 1,
1056    N_("Support synchronous non-call exceptions") },
1057   {"profile-arcs", &profile_arc_flag, 1,
1058    N_("Insert arc based program profiling code") },
1059   {"test-coverage", &flag_test_coverage, 1,
1060    N_("Create data files needed by gcov") },
1061   {"branch-probabilities", &flag_branch_probabilities, 1,
1062    N_("Use profiling information for branch probabilities") },
1063   {"reorder-blocks", &flag_reorder_blocks, 1,
1064    N_("Reorder basic blocks to improve code placement") },
1065   {"rename-registers", &flag_rename_registers, 1,
1066    N_("Do the register renaming optimization pass") },
1067   {"cprop-registers", &flag_cprop_registers, 1,
1068    N_("Do the register copy-propagation optimization pass") },
1069   {"common", &flag_no_common, 0,
1070    N_("Do not put uninitialized globals in the common section") },
1071   {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
1072    N_("Do not generate .size directives") },
1073   {"function-sections", &flag_function_sections, 1,
1074    N_("place each function into its own section") },
1075   {"data-sections", &flag_data_sections, 1,
1076    N_("place data items into their own section") },
1077   {"verbose-asm", &flag_verbose_asm, 1,
1078    N_("Add extra commentry to assembler output") },
1079   {"gnu-linker", &flag_gnu_linker, 1,
1080    N_("Output GNU ld formatted global initializers") },
1081   {"regmove", &flag_regmove, 1,
1082    N_("Enables a register move optimization") },
1083   {"optimize-register-move", &flag_regmove, 1,
1084    N_("Do the full regmove optimization pass") },
1085   {"pack-struct", &flag_pack_struct, 1,
1086    N_("Pack structure members together without holes") },
1087   {"stack-check", &flag_stack_check, 1,
1088    N_("Insert stack checking code into the program") },
1089   {"argument-alias", &flag_argument_noalias, 0,
1090    N_("Specify that arguments may alias each other & globals") },
1091   {"argument-noalias", &flag_argument_noalias, 1,
1092    N_("Assume arguments may alias globals but not each other") },
1093   {"argument-noalias-global", &flag_argument_noalias, 2,
1094    N_("Assume arguments do not alias each other or globals") },
1095   {"strict-aliasing", &flag_strict_aliasing, 1,
1096    N_("Assume strict aliasing rules apply") },
1097   {"align-loops", &align_loops, 0,
1098    N_("Align the start of loops") },
1099   {"align-jumps", &align_jumps, 0,
1100    N_("Align labels which are only reached by jumping") },
1101   {"align-labels", &align_labels, 0,
1102    N_("Align all labels") },
1103   {"align-functions", &align_functions, 0,
1104    N_("Align the start of functions") },
1105   {"merge-constants", &flag_merge_constants, 1,
1106    N_("Attempt to merge identical constants accross compilation units") },
1107   {"merge-all-constants", &flag_merge_constants, 2,
1108    N_("Attempt to merge identical constants and constant variables") },
1109   {"dump-unnumbered", &flag_dump_unnumbered, 1,
1110    N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
1111   {"instrument-functions", &flag_instrument_function_entry_exit, 1,
1112    N_("Instrument function entry/exit with profiling calls") },
1113   {"zero-initialized-in-bss", &flag_zero_initialized_in_bss, 1,
1114    N_("Put zero initialized data in the bss section") },
1115   {"ssa", &flag_ssa, 1,
1116    N_("Enable SSA optimizations") },
1117   {"ssa-ccp", &flag_ssa_ccp, 1,
1118    N_("Enable SSA conditional constant propagation") },
1119   {"ssa-dce", &flag_ssa_dce, 1,
1120    N_("Enable aggressive SSA dead code elimination") },
1121   {"leading-underscore", &flag_leading_underscore, 1,
1122    N_("External symbols have a leading underscore") },
1123   {"ident", &flag_no_ident, 0,
1124    N_("Process #ident directives") },
1125   { "peephole2", &flag_peephole2, 1,
1126    N_("Enables an rtl peephole pass run before sched2") },
1127   { "guess-branch-probability", &flag_guess_branch_prob, 1,
1128    N_("Enables guessing of branch probabilities") },
1129   {"math-errno", &flag_errno_math, 1,
1130    N_("Set errno after built-in math functions") },
1131   {"trapping-math", &flag_trapping_math, 1,
1132    N_("Floating-point operations can trap") },
1133   {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
1134    N_("Allow math optimizations that may violate IEEE or ANSI standards") },
1135   {"bounded-pointers", &flag_bounded_pointers, 1,
1136    N_("Compile pointers as triples: value, base & end") },
1137   {"bounds-check", &flag_bounds_check, 1,
1138    N_("Generate code to check bounds before dereferencing pointers and arrays") },
1139   {"single-precision-constant", &flag_single_precision_constant, 1,
1140    N_("Convert floating point constant to single precision constant") },
1141   {"time-report", &time_report, 1,
1142    N_("Report time taken by each compiler pass at end of run") },
1143   {"mem-report", &mem_report, 1,
1144    N_("Report on permanent memory allocation at end of run") },
1145   { "trapv", &flag_trapv, 1,
1146    N_("Trap for signed overflow in addition / subtraction / multiplication") },
1147 };
1148
1149 /* Table of language-specific options.  */
1150
1151 static const struct lang_opt
1152 {
1153   const char *const option;
1154   const char *const description;
1155 }
1156 documented_lang_options[] =
1157 {
1158   /* In order not to overload the --help output, the convention
1159      used here is to only describe those options which are not
1160      enabled by default.  */
1161
1162   { "-ansi", 
1163     N_("Compile just for ISO C89") },
1164   { "-std= ", 
1165     N_("Determine language standard") },
1166
1167   { "-fsigned-bitfields", "" },
1168   { "-funsigned-bitfields",
1169     N_("Make bit-fields by unsigned by default") },
1170   { "-fno-signed-bitfields", "" },
1171   { "-fno-unsigned-bitfields","" },
1172   { "-fsigned-char", 
1173     N_("Make 'char' be signed by default") },
1174   { "-funsigned-char", 
1175     N_("Make 'char' be unsigned by default") },
1176   { "-fno-signed-char", "" },
1177   { "-fno-unsigned-char", "" },
1178
1179   { "-fasm", "" },
1180   { "-fno-asm", 
1181     N_("Do not recognize the 'asm' keyword") },
1182   { "-fbuiltin", "" },
1183   { "-fno-builtin", 
1184     N_("Do not recognize any built in functions") },
1185   { "-fhosted", 
1186     N_("Assume normal C execution environment") },
1187   { "-fno-hosted", "" },
1188   { "-ffreestanding",
1189     N_("Assume that standard libraries & main might not exist") },
1190   { "-fno-freestanding", "" },
1191   { "-fcond-mismatch", 
1192     N_("Allow different types as args of ? operator") },
1193   { "-fno-cond-mismatch", "" },
1194   { "-fdollars-in-identifiers", 
1195     N_("Allow the use of $ inside identifiers") },
1196   { "-fno-dollars-in-identifiers", "" },
1197   { "-fpreprocessed", "" },
1198   { "-fno-preprocessed", "" },
1199   { "-fshort-double", 
1200     N_("Use the same size for double as for float") },
1201   { "-fno-short-double", "" },
1202   { "-fshort-enums", 
1203     N_("Use the smallest fitting integer to hold enums") },
1204   { "-fno-short-enums", "" },
1205   { "-fshort-wchar", 
1206     N_("Override the underlying type for wchar_t to `unsigned short'") },
1207   { "-fno-short-wchar", "" },
1208
1209   { "-Wall", 
1210     N_("Enable most warning messages") },
1211   { "-Wbad-function-cast",
1212     N_("Warn about casting functions to incompatible types") },
1213   { "-Wno-bad-function-cast", "" },
1214   { "-Wmissing-format-attribute",
1215     N_("Warn about functions which might be candidates for format attributes") },
1216   { "-Wno-missing-format-attribute", "" },
1217   { "-Wcast-qual", 
1218     N_("Warn about casts which discard qualifiers") },
1219   { "-Wno-cast-qual", "" },
1220   { "-Wchar-subscripts", 
1221     N_("Warn about subscripts whose type is 'char'") },
1222   { "-Wno-char-subscripts", "" },
1223   { "-Wcomment", 
1224     N_("Warn if nested comments are detected") },
1225   { "-Wno-comment", "" },
1226   { "-Wcomments", 
1227     N_("Warn if nested comments are detected") },
1228   { "-Wno-comments", "" },
1229   { "-Wconversion", 
1230     N_("Warn about possibly confusing type conversions") },
1231   { "-Wno-conversion", "" },
1232   { "-Wdiv-by-zero", "" },
1233   { "-Wno-div-by-zero", 
1234     N_("Do not warn about compile-time integer division by zero") },
1235   { "-Wfloat-equal", 
1236     N_("Warn about testing equality of floating point numbers") },
1237   { "-Wno-float-equal", "" },
1238   { "-Wformat", 
1239     N_("Warn about printf/scanf/strftime/strfmon format anomalies") },
1240   { "-Wno-format", "" },
1241   { "-Wformat-extra-args", "" },
1242   { "-Wno-format-extra-args",
1243     N_("Don't warn about too many arguments to format functions") },
1244   { "-Wformat-nonliteral", 
1245     N_("Warn about non-string-literal format strings") },
1246   { "-Wno-format-nonliteral", "" },
1247   { "-Wformat-security",
1248     N_("Warn about possible security problems with format functions") },
1249   { "-Wno-format-security", "" },
1250   { "-Wformat-y2k", "" },
1251   { "-Wno-format-y2k",
1252     N_("Don't warn about strftime formats yielding 2 digit years") },
1253   { "-Wimplicit-function-declaration",
1254     N_("Warn about implicit function declarations") },
1255   { "-Wno-implicit-function-declaration", "" },
1256   { "-Werror-implicit-function-declaration", "" },
1257   { "-Wimplicit-int", 
1258     N_("Warn when a declaration does not specify a type") },
1259   { "-Wno-implicit-int", "" },
1260   { "-Wimplicit", "" },
1261   { "-Wno-implicit", "" },
1262   { "-Wimport", 
1263     N_("Warn about the use of the #import directive") },
1264   { "-Wno-import", "" },
1265   { "-Wlong-long","" },
1266   { "-Wno-long-long", 
1267     N_("Do not warn about using 'long long' when -pedantic") },
1268   { "-Wmain", 
1269     N_("Warn about suspicious declarations of main") },
1270   { "-Wno-main", "" },
1271   { "-Wmissing-braces",
1272     N_("Warn about possibly missing braces around initializers") },
1273   { "-Wno-missing-braces", "" },
1274   { "-Wmissing-declarations",
1275     N_("Warn about global funcs without previous declarations") },
1276   { "-Wno-missing-declarations", "" },
1277   { "-Wmissing-prototypes", 
1278     N_("Warn about global funcs without prototypes") },
1279   { "-Wno-missing-prototypes", "" },
1280   { "-Wmultichar", 
1281     N_("Warn about use of multicharacter literals") },
1282   { "-Wno-multichar", "" },
1283   { "-Wnested-externs", 
1284     N_("Warn about externs not at file scope level") },
1285   { "-Wno-nested-externs", "" },
1286   { "-Wparentheses", 
1287     N_("Warn about possible missing parentheses") },
1288   { "-Wno-parentheses", "" },
1289   { "-Wpointer-arith", 
1290     N_("Warn about function pointer arithmetic") },
1291   { "-Wno-pointer-arith", "" },
1292   { "-Wredundant-decls",
1293     N_("Warn about multiple declarations of the same object") },
1294   { "-Wno-redundant-decls", "" },
1295   { "-Wreturn-type",
1296     N_("Warn whenever a function's return-type defaults to int") },
1297   { "-Wno-return-type", "" },
1298   { "-Wsequence-point",
1299     N_("Warn about possible violations of sequence point rules") },
1300   { "-Wno-sequence-point", "" },
1301   { "-Wsign-compare", 
1302     N_("Warn about signed/unsigned comparisons") },
1303   { "-Wno-sign-compare", "" },
1304   { "-Wstrict-prototypes", 
1305     N_("Warn about non-prototyped function decls") },
1306   { "-Wno-strict-prototypes", "" },
1307   { "-Wtraditional", 
1308     N_("Warn about constructs whose meanings change in ISO C") },
1309   { "-Wno-traditional", "" },
1310   { "-Wtrigraphs", 
1311     N_("Warn when trigraphs are encountered") },
1312   { "-Wno-trigraphs", "" },
1313   { "-Wundef", "" },
1314   { "-Wno-undef", "" },
1315   { "-Wunknown-pragmas", 
1316     N_("Warn about unrecognized pragmas") },
1317   { "-Wno-unknown-pragmas", "" },
1318   { "-Wwrite-strings", 
1319     N_("Mark strings as 'const char *'") },
1320   { "-Wno-write-strings", "" },
1321
1322 #define DEFINE_LANG_NAME(NAME) { NULL, NAME },
1323
1324 #include "options.h"
1325
1326 };
1327
1328 /* Here is a table, controlled by the tm.h file, listing each -m switch
1329    and which bits in `target_switches' it should set or clear.
1330    If VALUE is positive, it is bits to set.
1331    If VALUE is negative, -VALUE is bits to clear.
1332    (The sign bit is not used so there is no confusion.)  */
1333
1334 static const struct
1335 {
1336   const char *const name;
1337   const int value;
1338   const char *const description;
1339 }
1340 target_switches [] = TARGET_SWITCHES;
1341
1342 /* This table is similar, but allows the switch to have a value.  */
1343
1344 #ifdef TARGET_OPTIONS
1345 static const struct
1346 {
1347   const char *const prefix;
1348   const char **const variable;
1349   const char *const description;
1350 }
1351 target_options [] = TARGET_OPTIONS;
1352 #endif
1353 \f
1354 /* Options controlling warnings.  */
1355
1356 /* Don't print warning messages.  -w.  */
1357
1358 int inhibit_warnings = 0;
1359
1360 /* Don't suppress warnings from system headers.  -Wsystem-headers.  */
1361
1362 int warn_system_headers = 0;
1363
1364 /* Print various extra warnings.  -W.  */
1365
1366 int extra_warnings = 0;
1367
1368 /* Treat warnings as errors.  -Werror.  */
1369
1370 int warnings_are_errors = 0;
1371
1372 /* Nonzero to warn about unused variables, functions et.al.  */
1373
1374 int warn_unused_function;
1375 int warn_unused_label;
1376 int warn_unused_parameter;
1377 int warn_unused_variable;
1378 int warn_unused_value;
1379
1380 /* Nonzero to warn about code which is never reached.  */
1381
1382 int warn_notreached;
1383
1384 /* Nonzero to warn about variables used before they are initialized.  */
1385
1386 int warn_uninitialized;
1387
1388 /* Nonzero means warn about all declarations which shadow others.  */
1389
1390 int warn_shadow;
1391
1392 /* Warn if a switch on an enum fails to have a case for every enum value.  */
1393
1394 int warn_switch;
1395
1396 /* Nonzero means warn about function definitions that default the return type
1397    or that use a null return and have a return-type other than void.  */
1398
1399 int warn_return_type;
1400
1401 /* Nonzero means warn about pointer casts that increase the required
1402    alignment of the target type (and might therefore lead to a crash
1403    due to a misaligned access).  */
1404
1405 int warn_cast_align;
1406
1407 /* Nonzero means warn about any objects definitions whose size is larger
1408    than N bytes.  Also want about function definitions whose returned
1409    values are larger than N bytes. The value N is in `larger_than_size'.  */
1410
1411 int warn_larger_than;
1412 HOST_WIDE_INT larger_than_size;
1413
1414 /* Nonzero means warn if inline function is too large.  */
1415
1416 int warn_inline;
1417
1418 /* Warn if a function returns an aggregate,
1419    since there are often incompatible calling conventions for doing this.  */
1420
1421 int warn_aggregate_return;
1422
1423 /* Warn if packed attribute on struct is unnecessary and inefficient.  */
1424
1425 int warn_packed;
1426
1427 /* Warn when gcc pads a structure to an alignment boundary.  */
1428
1429 int warn_padded;
1430
1431 /* Warn when an optimization pass is disabled.  */
1432
1433 int warn_disabled_optimization;
1434
1435 /* Warn about functions which might be candidates for attribute noreturn.  */
1436
1437 int warn_missing_noreturn;
1438
1439 /* Nonzero means warn about uses of __attribute__((deprecated)) 
1440    declarations.  */
1441
1442 int warn_deprecated_decl = 1;
1443
1444 /* Likewise for -W.  */
1445
1446 static const lang_independent_options W_options[] =
1447 {
1448   {"unused-function", &warn_unused_function, 1,
1449    N_("Warn when a function is unused") },
1450   {"unused-label", &warn_unused_label, 1,
1451    N_("Warn when a label is unused") },
1452   {"unused-parameter", &warn_unused_parameter, 1,
1453    N_("Warn when a function parameter is unused") },
1454   {"unused-variable", &warn_unused_variable, 1,
1455    N_("Warn when a variable is unused") },
1456   {"unused-value", &warn_unused_value, 1,
1457    N_("Warn when an expression value is unused") },
1458   {"system-headers", &warn_system_headers, 1,
1459    N_("Do not suppress warnings from system headers") },
1460   {"error", &warnings_are_errors, 1,
1461    N_("Treat all warnings as errors") },
1462   {"shadow", &warn_shadow, 1,
1463    N_("Warn when one local variable shadows another") },
1464   {"switch", &warn_switch, 1,
1465    N_("Warn about enumerated switches missing a specific case") },
1466   {"aggregate-return", &warn_aggregate_return, 1,
1467    N_("Warn about returning structures, unions or arrays") },
1468   {"cast-align", &warn_cast_align, 1,
1469    N_("Warn about pointer casts which increase alignment") },
1470   {"unreachable-code", &warn_notreached, 1,
1471    N_("Warn about code that will never be executed") },
1472   {"uninitialized", &warn_uninitialized, 1,
1473    N_("Warn about uninitialized automatic variables") },
1474   {"inline", &warn_inline, 1,
1475    N_("Warn when an inlined function cannot be inlined") },
1476   {"packed", &warn_packed, 1,
1477    N_("Warn when the packed attribute has no effect on struct layout") },
1478   {"padded", &warn_padded, 1,
1479    N_("Warn when padding is required to align struct members") },
1480   {"disabled-optimization", &warn_disabled_optimization, 1,
1481    N_("Warn when an optimization pass is disabled") },
1482   {"deprecated-declarations", &warn_deprecated_decl, 1,
1483    N_("Warn about uses of __attribute__((deprecated)) declarations") },
1484   {"missing-noreturn", &warn_missing_noreturn, 1,
1485    N_("Warn about functions which might be candidates for attribute noreturn") }
1486 };
1487
1488 void
1489 set_Wunused (setting)
1490      int setting;
1491 {
1492   warn_unused_function = setting;
1493   warn_unused_label = setting;
1494   /* Unused function parameter warnings are reported when either ``-W
1495      -Wunused'' or ``-Wunused-parameter'' is specified.  Differentiate
1496      -Wunused by setting WARN_UNUSED_PARAMETER to -1.  */
1497   if (!setting)
1498     warn_unused_parameter = 0;
1499   else if (!warn_unused_parameter)
1500     warn_unused_parameter = -1;
1501   warn_unused_variable = setting;
1502   warn_unused_value = setting;
1503 }
1504
1505 /* The following routines are useful in setting all the flags that
1506    -ffast-math and -fno-fast-math imply.  */
1507
1508 void
1509 set_fast_math_flags ()
1510 {
1511   flag_trapping_math = 0;
1512   flag_unsafe_math_optimizations = 1;
1513   flag_errno_math = 0;
1514 }
1515
1516 void
1517 set_no_fast_math_flags ()
1518 {
1519   flag_trapping_math = 1;
1520   flag_unsafe_math_optimizations = 0;
1521   flag_errno_math = 1;
1522 }
1523
1524 \f
1525 /* Output files for assembler code (real compiler output)
1526    and debugging dumps.  */
1527
1528 FILE *asm_out_file;
1529 FILE *aux_info_file;
1530 FILE *rtl_dump_file = NULL;
1531
1532 /* Decode the string P as an integral parameter.
1533    If the string is indeed an integer return its numeric value else
1534    issue an Invalid Option error for the option PNAME and return DEFVAL.
1535    If PNAME is zero just return DEFVAL, do not call error.  */
1536
1537 int
1538 read_integral_parameter (p, pname, defval)
1539      const char *p;
1540      const char *pname;
1541      const int  defval;
1542 {
1543   const char *endp = p;
1544
1545   while (*endp)
1546     {
1547       if (ISDIGIT (*endp))
1548         endp++;
1549       else
1550         break;
1551     }
1552
1553   if (*endp != 0)
1554     {
1555       if (pname != 0)
1556         error ("invalid option `%s'", pname);
1557       return defval;
1558     }
1559
1560   return atoi (p);
1561 }
1562
1563 \f
1564 /* This is the default decl_printable_name function.  */
1565
1566 static const char *
1567 decl_name (decl, verbosity)
1568      tree decl;
1569      int verbosity ATTRIBUTE_UNUSED;
1570 {
1571   return IDENTIFIER_POINTER (DECL_NAME (decl));
1572 }
1573 \f
1574
1575 /* This calls abort and is used to avoid problems when abort if a macro.
1576    It is used when we need to pass the address of abort.  */
1577
1578 void
1579 do_abort ()
1580 {
1581   abort ();
1582 }
1583
1584 /* When `malloc.c' is compiled with `rcheck' defined,
1585    it calls this function to report clobberage.  */
1586
1587 void
1588 botch (s)
1589      const char *s ATTRIBUTE_UNUSED;
1590 {
1591   abort ();
1592 }
1593 \f
1594 /* Return the logarithm of X, base 2, considering X unsigned,
1595    if X is a power of 2.  Otherwise, returns -1.
1596
1597    This should be used via the `exact_log2' macro.  */
1598
1599 int
1600 exact_log2_wide (x)
1601      unsigned HOST_WIDE_INT x;
1602 {
1603   int log = 0;
1604   /* Test for 0 or a power of 2.  */
1605   if (x == 0 || x != (x & -x))
1606     return -1;
1607   while ((x >>= 1) != 0)
1608     log++;
1609   return log;
1610 }
1611
1612 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1613    If X is 0, return -1.
1614
1615    This should be used via the floor_log2 macro.  */
1616
1617 int
1618 floor_log2_wide (x)
1619      unsigned HOST_WIDE_INT x;
1620 {
1621   int log = -1;
1622   while (x != 0)
1623     log++,
1624     x >>= 1;
1625   return log;
1626 }
1627
1628 static int float_handler_set;
1629 int float_handled;
1630 jmp_buf float_handler;
1631
1632 /* Signals actually come here.  */
1633
1634 static void
1635 float_signal (signo)
1636      /* If this is missing, some compilers complain.  */
1637      int signo ATTRIBUTE_UNUSED;
1638 {
1639   if (float_handled == 0)
1640     crash_signal (signo);
1641   float_handled = 0;
1642
1643   /* On System-V derived systems, we must reinstall the signal handler.
1644      This is harmless on BSD-derived systems.  */
1645   signal (SIGFPE, float_signal);
1646   longjmp (float_handler, 1);
1647 }
1648
1649 /* Specify where to longjmp to when a floating arithmetic error happens.
1650    If HANDLER is 0, it means don't handle the errors any more.  */
1651
1652 static void
1653 set_float_handler (handler)
1654      jmp_buf handler;
1655 {
1656   float_handled = (handler != 0);
1657   if (handler)
1658     memcpy (float_handler, handler, sizeof (float_handler));
1659
1660   if (float_handled && ! float_handler_set)
1661     {
1662       signal (SIGFPE, float_signal);
1663       float_handler_set = 1;
1664     }
1665 }
1666
1667 /* This is a wrapper function for code which might elicit an
1668    arithmetic exception.  That code should be passed in as a function
1669    pointer FN, and one argument DATA.  DATA is usually a struct which
1670    contains the real input and output for function FN.  This function
1671    returns 0 (failure) if longjmp was called (i.e. an exception
1672    occurred.)  It returns 1 (success) otherwise.  */
1673
1674 int
1675 do_float_handler (fn, data)
1676      void (*fn) PARAMS ((PTR));
1677      PTR data;
1678 {
1679   jmp_buf buf;
1680
1681   if (setjmp (buf))
1682     {
1683       /* We got here via longjmp () caused by an exception in function
1684          fn ().  */
1685       set_float_handler (NULL);
1686       return 0;
1687     }
1688
1689   set_float_handler (buf);
1690   (*fn)(data);
1691   set_float_handler (NULL);
1692   return 1;
1693 }
1694
1695 /* Handler for fatal signals, such as SIGSEGV.  These are transformed
1696    into ICE messages, which is much more user friendly.  */
1697
1698 static void
1699 crash_signal (signo)
1700      int signo;
1701 {
1702   internal_error ("internal error: %s", strsignal (signo));
1703 }
1704
1705 /* Strip off a legitimate source ending from the input string NAME of
1706    length LEN.  Rather than having to know the names used by all of
1707    our front ends, we strip off an ending of a period followed by
1708    up to five characters.  (Java uses ".class".)  */
1709
1710 void
1711 strip_off_ending (name, len)
1712      char *name;
1713      int len;
1714 {
1715   int i;
1716   for (i = 2;  i < 6 && len > i;  i++)
1717     {
1718       if (name[len - i] == '.')
1719         {
1720           name[len - i] = '\0';
1721           break;
1722         }
1723     }
1724 }
1725
1726 /* Output a quoted string.  */
1727
1728 void
1729 output_quoted_string (asm_file, string)
1730      FILE *asm_file;
1731      const char *string;
1732 {
1733 #ifdef OUTPUT_QUOTED_STRING
1734   OUTPUT_QUOTED_STRING (asm_file, string);
1735 #else
1736   char c;
1737
1738   putc ('\"', asm_file);
1739   while ((c = *string++) != 0)
1740     {
1741       if (ISPRINT (c))
1742         {
1743           if (c == '\"' || c == '\\')
1744             putc ('\\', asm_file);
1745           putc (c, asm_file);
1746         }
1747       else
1748         fprintf (asm_file, "\\%03o", c);
1749     }
1750   putc ('\"', asm_file);
1751 #endif
1752 }
1753
1754 /* Output a file name in the form wanted by System V.  */
1755
1756 void
1757 output_file_directive (asm_file, input_name)
1758      FILE *asm_file;
1759      const char *input_name;
1760 {
1761   int len = strlen (input_name);
1762   const char *na = input_name + len;
1763
1764   /* NA gets INPUT_NAME sans directory names.  */
1765   while (na > input_name)
1766     {
1767       if (IS_DIR_SEPARATOR (na[-1]))
1768         break;
1769       na--;
1770     }
1771
1772 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
1773   ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
1774 #else
1775 #ifdef ASM_OUTPUT_SOURCE_FILENAME
1776   ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
1777 #else
1778   fprintf (asm_file, "\t.file\t");
1779   output_quoted_string (asm_file, na);
1780   fputc ('\n', asm_file);
1781 #endif
1782 #endif
1783 }
1784 \f
1785 /* Routine to open a dump file.  Return true if the dump file is enabled.  */
1786
1787 static int
1788 open_dump_file (index, decl)
1789      enum dump_file_index index;
1790      tree decl;
1791 {
1792   char *dump_name;
1793   const char *open_arg;
1794   char seq[16];
1795
1796   if (! dump_file[index].enabled)
1797     return 0;
1798
1799   timevar_push (TV_DUMP);
1800   if (rtl_dump_file != NULL)
1801     fclose (rtl_dump_file);
1802
1803   sprintf (seq, DUMPFILE_FORMAT, index);
1804
1805   if (! dump_file[index].initialized)
1806     {
1807       /* If we've not initialized the files, do so now.  */
1808       if (graph_dump_format != no_graph
1809           && dump_file[index].graph_dump_p)
1810         {
1811           dump_name = concat (seq, dump_file[index].extension, NULL);
1812           clean_graph_dump_file (dump_base_name, dump_name);
1813           free (dump_name);
1814         }
1815       dump_file[index].initialized = 1;
1816       open_arg = "w";
1817     }
1818   else
1819     open_arg = "a";
1820
1821   dump_name = concat (dump_base_name, seq,
1822                       dump_file[index].extension, NULL);
1823
1824   rtl_dump_file = fopen (dump_name, open_arg);
1825   if (rtl_dump_file == NULL)
1826     fatal_io_error ("can't open %s", dump_name);
1827
1828   free (dump_name);
1829
1830   if (decl)
1831     fprintf (rtl_dump_file, "\n;; Function %s\n\n",
1832              decl_printable_name (decl, 2));
1833
1834   timevar_pop (TV_DUMP);
1835   return 1;
1836 }
1837
1838 /* Routine to close a dump file.  */
1839
1840 static void
1841 close_dump_file (index, func, insns)
1842      enum dump_file_index index;
1843      void (*func) PARAMS ((FILE *, rtx));
1844      rtx insns;
1845 {
1846   if (! rtl_dump_file)
1847     return;
1848
1849   timevar_push (TV_DUMP);
1850   if (insns
1851       && graph_dump_format != no_graph
1852       && dump_file[index].graph_dump_p)
1853     {
1854       char seq[16];
1855       char *suffix;
1856
1857       sprintf (seq, DUMPFILE_FORMAT, index);
1858       suffix = concat (seq, dump_file[index].extension, NULL);
1859       print_rtl_graph_with_bb (dump_base_name, suffix, insns);
1860       free (suffix);
1861     }
1862
1863   if (func && insns)
1864     func (rtl_dump_file, insns);
1865
1866   fflush (rtl_dump_file);
1867   fclose (rtl_dump_file);
1868
1869   rtl_dump_file = NULL;
1870   timevar_pop (TV_DUMP);
1871 }
1872
1873 /* Do any final processing required for the declarations in VEC, of
1874    which there are LEN.  We write out inline functions and variables
1875    that have been deferred until this point, but which are required.
1876    Returns non-zero if anything was put out.  */
1877
1878 int
1879 wrapup_global_declarations (vec, len)
1880      tree *vec;
1881      int len;
1882 {
1883   tree decl;
1884   int i;
1885   int reconsider;
1886   int output_something = 0;
1887
1888   for (i = 0; i < len; i++)
1889     {
1890       decl = vec[i];
1891
1892       /* We're not deferring this any longer.  */
1893       DECL_DEFER_OUTPUT (decl) = 0;
1894
1895       if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0
1896           && incomplete_decl_finalize_hook != 0)
1897         (*incomplete_decl_finalize_hook) (decl);
1898     }
1899
1900   /* Now emit any global variables or functions that we have been
1901      putting off.  We need to loop in case one of the things emitted
1902      here references another one which comes earlier in the list.  */
1903   do
1904     {
1905       reconsider = 0;
1906       for (i = 0; i < len; i++)
1907         {
1908           decl = vec[i];
1909
1910           if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
1911             continue;
1912
1913           /* Don't write out static consts, unless we still need them.
1914
1915              We also keep static consts if not optimizing (for debugging),
1916              unless the user specified -fno-keep-static-consts.
1917              ??? They might be better written into the debug information.
1918              This is possible when using DWARF.
1919
1920              A language processor that wants static constants to be always
1921              written out (even if it is not used) is responsible for
1922              calling rest_of_decl_compilation itself.  E.g. the C front-end
1923              calls rest_of_decl_compilation from finish_decl.
1924              One motivation for this is that is conventional in some
1925              environments to write things like:
1926              static const char rcsid[] = "... version string ...";
1927              intending to force the string to be in the executable.
1928
1929              A language processor that would prefer to have unneeded
1930              static constants "optimized away" would just defer writing
1931              them out until here.  E.g. C++ does this, because static
1932              constants are often defined in header files.
1933
1934              ??? A tempting alternative (for both C and C++) would be
1935              to force a constant to be written if and only if it is
1936              defined in a main file, as opposed to an include file.  */
1937
1938           if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
1939             {
1940               bool needed = 1;
1941
1942               if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
1943                 /* needed */;
1944               else if (DECL_COMDAT (decl))
1945                 needed = 0;
1946               else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
1947                        && (optimize || !flag_keep_static_consts
1948                            || DECL_ARTIFICIAL (decl)))
1949                 needed = 0;
1950
1951               if (needed)
1952                 {
1953                   reconsider = 1;
1954                   rest_of_decl_compilation (decl, NULL, 1, 1);
1955                 }
1956             }
1957
1958           if (TREE_CODE (decl) == FUNCTION_DECL
1959               && DECL_INITIAL (decl) != 0
1960               && DECL_SAVED_INSNS (decl) != 0
1961               && (flag_keep_inline_functions
1962                   || (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1963                   || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1964             {
1965               reconsider = 1;
1966               output_inline_function (decl);
1967             }
1968         }
1969
1970       if (reconsider)
1971         output_something = 1;
1972     }
1973   while (reconsider);
1974
1975   return output_something;
1976 }
1977
1978 /* Issue appropriate warnings for the global declarations in VEC (of
1979    which there are LEN).  Output debugging information for them.  */
1980
1981 void
1982 check_global_declarations (vec, len)
1983      tree *vec;
1984      int len;
1985 {
1986   tree decl;
1987   int i;
1988
1989   for (i = 0; i < len; i++)
1990     {
1991       decl = vec[i];
1992
1993       if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
1994           && ! TREE_ASM_WRITTEN (decl))
1995         /* Cancel the RTL for this decl so that, if debugging info
1996            output for global variables is still to come,
1997            this one will be omitted.  */
1998         SET_DECL_RTL (decl, NULL_RTX);
1999
2000       /* Warn about any function
2001          declared static but not defined.
2002          We don't warn about variables,
2003          because many programs have static variables
2004          that exist only to get some text into the object file.  */
2005       if (TREE_CODE (decl) == FUNCTION_DECL
2006           && (warn_unused_function
2007               || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2008           && DECL_INITIAL (decl) == 0
2009           && DECL_EXTERNAL (decl)
2010           && ! DECL_ARTIFICIAL (decl)
2011           && ! TREE_PUBLIC (decl))
2012         {
2013           if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2014             pedwarn_with_decl (decl,
2015                                "`%s' used but never defined");
2016           else
2017             warning_with_decl (decl,
2018                                "`%s' declared `static' but never defined");
2019           /* This symbol is effectively an "extern" declaration now.  */
2020           TREE_PUBLIC (decl) = 1;
2021           assemble_external (decl);
2022         }
2023
2024       /* Warn about static fns or vars defined but not used,
2025          but not about inline functions or static consts
2026          since defining those in header files is normal practice.  */
2027       if (((warn_unused_function
2028             && TREE_CODE (decl) == FUNCTION_DECL && ! DECL_INLINE (decl))
2029            || (warn_unused_variable
2030                && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
2031           && ! DECL_IN_SYSTEM_HEADER (decl)
2032           && ! DECL_EXTERNAL (decl)
2033           && ! TREE_PUBLIC (decl)
2034           && ! TREE_USED (decl)
2035           && (TREE_CODE (decl) == FUNCTION_DECL || ! DECL_REGISTER (decl))
2036           /* The TREE_USED bit for file-scope decls
2037              is kept in the identifier, to handle multiple
2038              external decls in different scopes.  */
2039           && ! TREE_USED (DECL_NAME (decl)))
2040         warning_with_decl (decl, "`%s' defined but not used");
2041
2042       timevar_push (TV_SYMOUT);
2043       (*debug_hooks->global_decl) (decl);
2044       timevar_pop (TV_SYMOUT);
2045     }
2046 }
2047
2048 /* Save the current INPUT_FILENAME and LINENO on the top entry in the
2049    INPUT_FILE_STACK.  Push a new entry for FILE and LINE, and set the
2050    INPUT_FILENAME and LINENO accordingly.  */
2051
2052 void
2053 push_srcloc (file, line)
2054      const char *file;
2055      int line;
2056 {
2057   struct file_stack *fs;
2058
2059   if (input_file_stack)
2060     {
2061       input_file_stack->name = input_filename;
2062       input_file_stack->line = lineno;
2063     }
2064
2065   fs = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2066   fs->name = input_filename = file;
2067   fs->line = lineno = line;
2068   fs->indent_level = 0;
2069   fs->next = input_file_stack;
2070   input_file_stack = fs;
2071   input_file_stack_tick++;
2072 }
2073
2074 /* Pop the top entry off the stack of presently open source files.
2075    Restore the INPUT_FILENAME and LINENO from the new topmost entry on
2076    the stack.  */
2077
2078 void
2079 pop_srcloc ()
2080 {
2081   struct file_stack *fs;
2082
2083   fs = input_file_stack;
2084   input_file_stack = fs->next;
2085   free (fs);
2086   input_file_stack_tick++;
2087   /* The initial source file is never popped.  */
2088   if (!input_file_stack)
2089     abort ();
2090   input_filename = input_file_stack->name;
2091   lineno = input_file_stack->line;
2092 }
2093
2094 /* Compile an entire translation unit.  Write a file of assembly
2095    output and various debugging dumps.  */
2096
2097 static void
2098 compile_file ()
2099 {
2100   tree globals;
2101
2102   /* Initialize yet another pass.  */
2103
2104   init_final (main_input_filename);
2105   init_branch_prob (dump_base_name);
2106
2107   timevar_push (TV_PARSE);
2108
2109   /* Call the parser, which parses the entire file
2110      (calling rest_of_compilation for each function).  */
2111   yyparse ();
2112
2113   /* In case there were missing block closers,
2114      get us back to the global binding level.  */
2115   (*lang_hooks.clear_binding_stack) ();
2116
2117   /* Compilation is now finished except for writing
2118      what's left of the symbol table output.  */
2119
2120   timevar_pop (TV_PARSE);
2121
2122   if (flag_syntax_only)
2123     return;
2124
2125   globals = getdecls ();
2126
2127   /* Really define vars that have had only a tentative definition.
2128      Really output inline functions that must actually be callable
2129      and have not been output so far.  */
2130
2131   {
2132     int len = list_length (globals);
2133     tree *vec = (tree *) xmalloc (sizeof (tree) * len);
2134     int i;
2135     tree decl;
2136
2137     /* Process the decls in reverse order--earliest first.
2138        Put them into VEC from back to front, then take out from front.  */
2139
2140     for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
2141       vec[len - i - 1] = decl;
2142
2143     wrapup_global_declarations (vec, len);
2144
2145     /* This must occur after the loop to output deferred functions.  Else
2146        the profiler initializer would not be emitted if all the functions
2147        in this compilation unit were deferred.
2148
2149        output_func_start_profiler can not cause any additional functions or
2150        data to need to be output, so it need not be in the deferred function
2151        loop above.  */
2152     output_func_start_profiler ();
2153
2154     check_global_declarations (vec, len);
2155
2156     /* Clean up.  */
2157     free (vec);
2158   }
2159
2160   /* Write out any pending weak symbol declarations.  */
2161
2162   weak_finish ();
2163
2164   /* Do dbx symbols.  */
2165   timevar_push (TV_SYMOUT);
2166
2167 #ifdef DWARF2_UNWIND_INFO
2168   if (dwarf2out_do_frame ())
2169     dwarf2out_frame_finish ();
2170 #endif
2171
2172   (*debug_hooks->finish) (main_input_filename);
2173   timevar_pop (TV_SYMOUT);
2174
2175   /* Output some stuff at end of file if nec.  */
2176
2177   dw2_output_indirect_constants ();
2178
2179   end_final (dump_base_name);
2180
2181   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
2182     {
2183       timevar_push (TV_DUMP);
2184       open_dump_file (DFI_bp, NULL);
2185
2186       end_branch_prob ();
2187
2188       close_dump_file (DFI_bp, NULL, NULL_RTX);
2189       timevar_pop (TV_DUMP);
2190     }
2191
2192 #ifdef ASM_FILE_END
2193   ASM_FILE_END (asm_out_file);
2194 #endif
2195
2196   /* Attach a special .ident directive to the end of the file to identify
2197      the version of GCC which compiled this code.  The format of the .ident
2198      string is patterned after the ones produced by native SVR4 compilers.  */
2199 #ifdef IDENT_ASM_OP
2200   if (!flag_no_ident)
2201     fprintf (asm_out_file, "%s\"GCC: (GNU) %s\"\n",
2202              IDENT_ASM_OP, version_string);
2203 #endif
2204
2205   if (optimize > 0 && open_dump_file (DFI_combine, NULL))
2206     {
2207       timevar_push (TV_DUMP);
2208       dump_combine_total_stats (rtl_dump_file);
2209       close_dump_file (DFI_combine, NULL, NULL_RTX);
2210       timevar_pop (TV_DUMP);
2211     }
2212 }
2213 \f
2214 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2215    and TYPE_DECL nodes.
2216
2217    This does nothing for local (non-static) variables, unless the
2218    variable is a register variable with an ASMSPEC.  In that case, or
2219    if the variable is not an automatic, it sets up the RTL and
2220    outputs any assembler code (label definition, storage allocation
2221    and initialization).
2222
2223    DECL is the declaration.  If ASMSPEC is nonzero, it specifies
2224    the assembler symbol name to be used.  TOP_LEVEL is nonzero
2225    if this declaration is not within a function.  */
2226
2227 void
2228 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2229      tree decl;
2230      const char *asmspec;
2231      int top_level;
2232      int at_end;
2233 {
2234   /* Declarations of variables, and of functions defined elsewhere.  */
2235
2236 /* The most obvious approach, to put an #ifndef around where
2237    this macro is used, doesn't work since it's inside a macro call.  */
2238 #ifndef ASM_FINISH_DECLARE_OBJECT
2239 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END)
2240 #endif
2241
2242   /* We deferred calling assemble_alias so that we could collect
2243      other attributes such as visibility.  Emit the alias now.  */
2244   {
2245     tree alias;
2246     alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
2247     if (alias)
2248       {
2249         alias = TREE_VALUE (TREE_VALUE (alias));
2250         alias = get_identifier (TREE_STRING_POINTER (alias));
2251         assemble_alias (decl, alias);
2252       }
2253   }
2254
2255   /* Forward declarations for nested functions are not "external",
2256      but we need to treat them as if they were.  */
2257   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
2258       || TREE_CODE (decl) == FUNCTION_DECL)
2259     {
2260       timevar_push (TV_VARCONST);
2261
2262       if (asmspec)
2263         make_decl_rtl (decl, asmspec);
2264
2265       /* Don't output anything when a tentative file-scope definition
2266          is seen.  But at end of compilation, do output code for them.  */
2267       if (at_end || !DECL_DEFER_OUTPUT (decl))
2268         assemble_variable (decl, top_level, at_end, 0);
2269       if (decl == last_assemble_variable_decl)
2270         {
2271           ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
2272                                      top_level, at_end);
2273         }
2274
2275       timevar_pop (TV_VARCONST);
2276     }
2277   else if (DECL_REGISTER (decl) && asmspec != 0)
2278     {
2279       if (decode_reg_name (asmspec) >= 0)
2280         {
2281           SET_DECL_RTL (decl, NULL_RTX);
2282           make_decl_rtl (decl, asmspec);
2283         }
2284       else
2285         {
2286           error ("invalid register name `%s' for register variable", asmspec);
2287           DECL_REGISTER (decl) = 0;
2288           if (!top_level)
2289             expand_decl (decl);
2290         }
2291     }
2292 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2293   else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2294            && TREE_CODE (decl) == TYPE_DECL)
2295     {
2296       timevar_push (TV_SYMOUT);
2297       dbxout_symbol (decl, 0);
2298       timevar_pop (TV_SYMOUT);
2299     }
2300 #endif
2301 #ifdef SDB_DEBUGGING_INFO
2302   else if (write_symbols == SDB_DEBUG && top_level
2303            && TREE_CODE (decl) == TYPE_DECL)
2304     {
2305       timevar_push (TV_SYMOUT);
2306       sdbout_symbol (decl, 0);
2307       timevar_pop (TV_SYMOUT);
2308     }
2309 #endif
2310 }
2311
2312 /* Called after finishing a record, union or enumeral type.  */
2313
2314 void
2315 rest_of_type_compilation (type, toplev)
2316 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO) || defined (SDB_DEBUGGING_INFO)
2317      tree type;
2318      int toplev;
2319 #else
2320      tree type ATTRIBUTE_UNUSED;
2321      int toplev ATTRIBUTE_UNUSED;
2322 #endif
2323 {
2324   timevar_push (TV_SYMOUT);
2325 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2326   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2327     dbxout_symbol (TYPE_STUB_DECL (type), !toplev);
2328 #endif
2329 #ifdef SDB_DEBUGGING_INFO
2330   if (write_symbols == SDB_DEBUG)
2331     sdbout_symbol (TYPE_STUB_DECL (type), !toplev);
2332 #endif
2333 #ifdef DWARF2_DEBUGGING_INFO
2334   if ((write_symbols == DWARF2_DEBUG
2335        || write_symbols == VMS_AND_DWARF2_DEBUG)
2336       && toplev)
2337     dwarf2out_decl (TYPE_STUB_DECL (type));
2338 #endif
2339   timevar_pop (TV_SYMOUT);
2340 }
2341
2342 /* This is called from finish_function (within yyparse)
2343    after each top-level definition is parsed.
2344    It is supposed to compile that function or variable
2345    and output the assembler code for it.
2346    After we return, the tree storage is freed.  */
2347
2348 void
2349 rest_of_compilation (decl)
2350      tree decl;
2351 {
2352   rtx insns;
2353   int tem;
2354   int failure = 0;
2355   int rebuild_label_notes_after_reload;
2356   int register_life_up_to_date;
2357
2358   timevar_push (TV_REST_OF_COMPILATION);
2359
2360   /* Now that we're out of the frontend, we shouldn't have any more
2361      CONCATs anywhere.  */
2362   generating_concat_p = 0;
2363
2364   /* When processing delayed functions, prepare_function_start() won't
2365      have been run to re-initialize it.  */
2366   cse_not_expected = ! optimize;
2367
2368   /* First, make sure that NOTE_BLOCK is set correctly for each
2369      NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note.  */
2370   if (!cfun->x_whole_function_mode_p)
2371     identify_blocks ();
2372
2373   /* In function-at-a-time mode, we do not attempt to keep the BLOCK
2374      tree in sensible shape.  So, we just recalculate it here.  */
2375   if (cfun->x_whole_function_mode_p)
2376     reorder_blocks ();
2377
2378   init_flow ();
2379
2380   /* If we are reconsidering an inline function
2381      at the end of compilation, skip the stuff for making it inline.  */
2382
2383   if (DECL_SAVED_INSNS (decl) == 0)
2384     {
2385       int inlinable = 0;
2386       tree parent;
2387       const char *lose;
2388
2389       /* If this is nested inside an inlined external function, pretend
2390          it was only declared.  Since we cannot inline such functions,
2391          generating code for this one is not only not necessary but will
2392          confuse some debugging output writers.  */
2393       for (parent = DECL_CONTEXT (current_function_decl);
2394            parent != NULL_TREE;
2395            parent = get_containing_scope (parent))
2396         if (TREE_CODE (parent) == FUNCTION_DECL
2397             && DECL_INLINE (parent) && DECL_EXTERNAL (parent))
2398           {
2399             DECL_INITIAL (decl) = 0;
2400             goto exit_rest_of_compilation;
2401           }
2402
2403       /* If requested, consider whether to make this function inline.  */
2404       if ((DECL_INLINE (decl) && !flag_no_inline)
2405           || flag_inline_functions)
2406         {
2407           timevar_push (TV_INTEGRATION);
2408           lose = function_cannot_inline_p (decl);
2409           timevar_pop (TV_INTEGRATION);
2410           if (lose || ! optimize)
2411             {
2412               if (warn_inline && DECL_INLINE (decl))
2413                 warning_with_decl (decl, lose);
2414               DECL_ABSTRACT_ORIGIN (decl) = 0;
2415               /* Don't really compile an extern inline function.
2416                  If we can't make it inline, pretend
2417                  it was only declared.  */
2418               if (DECL_EXTERNAL (decl))
2419                 {
2420                   DECL_INITIAL (decl) = 0;
2421                   goto exit_rest_of_compilation;
2422                 }
2423             }
2424           else
2425             /* ??? Note that this has the effect of making it look
2426                  like "inline" was specified for a function if we choose
2427                  to inline it.  This isn't quite right, but it's
2428                  probably not worth the trouble to fix.  */
2429             inlinable = DECL_INLINE (decl) = 1;
2430         }
2431
2432       insns = get_insns ();
2433
2434       /* Dump the rtl code if we are dumping rtl.  */
2435
2436       if (open_dump_file (DFI_rtl, decl))
2437         {
2438           if (DECL_SAVED_INSNS (decl))
2439             fprintf (rtl_dump_file, ";; (integrable)\n\n");
2440           close_dump_file (DFI_rtl, print_rtl, insns);
2441         }
2442
2443       /* Convert from NOTE_INSN_EH_REGION style notes, and do other
2444          sorts of eh initialization.  Delay this until after the
2445          initial rtl dump so that we can see the original nesting.  */
2446       convert_from_eh_region_ranges ();
2447
2448       /* If function is inline, and we don't yet know whether to
2449          compile it by itself, defer decision till end of compilation.
2450          finish_compilation will call rest_of_compilation again
2451          for those functions that need to be output.  Also defer those
2452          functions that we are supposed to defer.  */
2453
2454       if (inlinable
2455           || (DECL_INLINE (decl)
2456               && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2457                    && ! flag_keep_inline_functions)
2458                   || DECL_EXTERNAL (decl))))
2459         DECL_DEFER_OUTPUT (decl) = 1;
2460
2461       if (DECL_INLINE (decl))
2462         /* DWARF wants separate debugging info for abstract and
2463            concrete instances of all inline functions, including those
2464            declared inline but not inlined, and those inlined even
2465            though they weren't declared inline.  Conveniently, that's
2466            what DECL_INLINE means at this point.  */
2467         (*debug_hooks->deferred_inline_function) (decl);
2468
2469       if (DECL_DEFER_OUTPUT (decl))
2470         {
2471           /* If -Wreturn-type, we have to do a bit of compilation.  We just
2472              want to call cleanup the cfg to figure out whether or not we can
2473              fall off the end of the function; we do the minimum amount of
2474              work necessary to make that safe.  */
2475           if (warn_return_type)
2476             {
2477               int saved_optimize = optimize;
2478
2479               optimize = 0;
2480               rebuild_jump_labels (insns);
2481               find_exception_handler_labels ();
2482               find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2483               cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
2484               optimize = saved_optimize;
2485
2486               /* CFG is no longer maintained up-to-date.  */
2487               free_bb_for_insn ();
2488             }
2489
2490           current_function_nothrow = nothrow_function_p ();
2491           if (current_function_nothrow)
2492             /* Now we know that this can't throw; set the flag for the benefit
2493                of other functions later in this translation unit.  */
2494             TREE_NOTHROW (current_function_decl) = 1;
2495
2496           timevar_push (TV_INTEGRATION);
2497           save_for_inline (decl);
2498           timevar_pop (TV_INTEGRATION);
2499           DECL_SAVED_INSNS (decl)->inlinable = inlinable;
2500           goto exit_rest_of_compilation;
2501         }
2502
2503       /* If specified extern inline but we aren't inlining it, we are
2504          done.  This goes for anything that gets here with DECL_EXTERNAL
2505          set, not just things with DECL_INLINE.  */
2506       if (DECL_EXTERNAL (decl))
2507         goto exit_rest_of_compilation;
2508     }
2509
2510   /* If we're emitting a nested function, make sure its parent gets
2511      emitted as well.  Doing otherwise confuses debug info.  */
2512   {
2513     tree parent;
2514     for (parent = DECL_CONTEXT (current_function_decl);
2515          parent != NULL_TREE;
2516          parent = get_containing_scope (parent))
2517       if (TREE_CODE (parent) == FUNCTION_DECL)
2518         TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
2519   }
2520
2521   /* We are now committed to emitting code for this function.  Do any
2522      preparation, such as emitting abstract debug info for the inline
2523      before it gets mangled by optimization.  */
2524   if (DECL_INLINE (decl))
2525     (*debug_hooks->outlining_inline_function) (decl);
2526
2527   /* Remove any notes we don't need.  That will make iterating
2528      over the instruction sequence faster, and allow the garbage
2529      collector to reclaim the memory used by the notes.  */
2530   remove_unnecessary_notes ();
2531   reorder_blocks ();
2532
2533   ggc_collect ();
2534
2535   /* Initialize some variables used by the optimizers.  */
2536   init_function_for_compilation ();
2537
2538   if (! DECL_DEFER_OUTPUT (decl))
2539     TREE_ASM_WRITTEN (decl) = 1;
2540
2541   /* Now that integrate will no longer see our rtl, we need not
2542      distinguish between the return value of this function and the
2543      return value of called functions.  Also, we can remove all SETs
2544      of subregs of hard registers; they are only here because of
2545      integrate.  Also, we can now initialize pseudos intended to 
2546      carry magic hard reg data throughout the function.  */
2547   rtx_equal_function_value_matters = 0;
2548   purge_hard_subreg_sets (get_insns ());
2549   emit_initial_value_sets ();
2550
2551   /* Early return if there were errors.  We can run afoul of our
2552      consistency checks, and there's not really much point in fixing them.
2553      Don't return yet if -Wreturn-type; we need to do cleanup_cfg.  */
2554   if (((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
2555       || errorcount || sorrycount)
2556     goto exit_rest_of_compilation;
2557
2558   /* We may have potential sibling or tail recursion sites.  Select one
2559      (of possibly multiple) methods of performing the call.  */
2560   if (flag_optimize_sibling_calls)
2561     {
2562       timevar_push (TV_JUMP);
2563       open_dump_file (DFI_sibling, decl);
2564
2565       optimize_sibling_and_tail_recursive_calls ();
2566
2567       close_dump_file (DFI_sibling, print_rtl, get_insns ());
2568       timevar_pop (TV_JUMP);
2569     }
2570
2571   /* Complete generation of exception handling code.  */
2572   find_exception_handler_labels ();
2573   if (doing_eh (0))
2574     {
2575       timevar_push (TV_JUMP);
2576       open_dump_file (DFI_eh, decl);
2577
2578       finish_eh_generation ();
2579
2580       close_dump_file (DFI_eh, print_rtl, get_insns ());
2581       timevar_pop (TV_JUMP);
2582     }
2583
2584 #ifdef FINALIZE_PIC
2585   /* If we are doing position-independent code generation, now
2586      is the time to output special prologues and epilogues.
2587      We do not want to do this earlier, because it just clutters
2588      up inline functions with meaningless insns.  */
2589   if (flag_pic)
2590     FINALIZE_PIC;
2591 #endif
2592
2593   insns = get_insns ();
2594
2595   /* Copy any shared structure that should not be shared.  */
2596   unshare_all_rtl (current_function_decl, insns);
2597
2598 #ifdef SETJMP_VIA_SAVE_AREA
2599   /* This must be performed before virtual register instantiation.  */
2600   if (current_function_calls_alloca)
2601     optimize_save_area_alloca (insns);
2602 #endif
2603
2604   /* Instantiate all virtual registers.  */
2605   instantiate_virtual_regs (current_function_decl, insns);
2606
2607   open_dump_file (DFI_jump, decl);
2608
2609   /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
2610      are initialized and to compute whether control can drop off the end
2611      of the function.  */
2612
2613   timevar_push (TV_JUMP);
2614   /* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB.  Do this
2615      before jump optimization switches branch directions.  */
2616   expected_value_to_br_prob ();
2617
2618   reg_scan (insns, max_reg_num (), 0);
2619   rebuild_jump_labels (insns);
2620   find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2621   if (rtl_dump_file)
2622     dump_flow_info (rtl_dump_file);
2623   cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
2624                | (flag_thread_jumps ? CLEANUP_THREADING : 0));
2625
2626   /* CFG is no longer maintained up-to-date.  */
2627   free_bb_for_insn ();
2628   copy_loop_headers (insns);
2629   purge_line_number_notes (insns);
2630
2631   timevar_pop (TV_JUMP);
2632   close_dump_file (DFI_jump, print_rtl, insns);
2633
2634   /* Now is when we stop if -fsyntax-only and -Wreturn-type.  */
2635   if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
2636     {
2637       goto exit_rest_of_compilation;
2638     }
2639
2640   /* Long term, this should probably move before the jump optimizer too,
2641      but I didn't want to disturb the rtl_dump_and_exit and related
2642      stuff at this time.  */
2643   if (optimize > 0 && flag_ssa)
2644     {
2645       /* Convert to SSA form.  */
2646
2647       timevar_push (TV_TO_SSA);
2648       open_dump_file (DFI_ssa, decl);
2649
2650       find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2651       cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2652       convert_to_ssa ();
2653
2654       close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
2655       timevar_pop (TV_TO_SSA);
2656
2657       /* Perform sparse conditional constant propagation, if requested.  */
2658       if (flag_ssa_ccp)
2659         {
2660           timevar_push (TV_SSA_CCP);
2661           open_dump_file (DFI_ssa_ccp, decl);
2662
2663           ssa_const_prop ();
2664
2665           close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
2666           timevar_pop (TV_SSA_CCP);
2667         }
2668
2669       /* It would be useful to cleanup the CFG at this point, but block
2670          merging and possibly other transformations might leave a PHI
2671          node in the middle of a basic block, which is a strict no-no.  */
2672
2673       /* The SSA implementation uses basic block numbers in its phi
2674          nodes.  Thus, changing the control-flow graph or the basic
2675          blocks, e.g., calling find_basic_blocks () or cleanup_cfg (),
2676          may cause problems.  */
2677
2678       if (flag_ssa_dce)
2679         {
2680           /* Remove dead code.  */
2681
2682           timevar_push (TV_SSA_DCE);
2683           open_dump_file (DFI_ssa_dce, decl);
2684
2685           insns = get_insns ();
2686           ssa_eliminate_dead_code();
2687
2688           close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
2689           timevar_pop (TV_SSA_DCE);
2690         }
2691
2692       /* Convert from SSA form.  */
2693
2694       timevar_push (TV_FROM_SSA);
2695       open_dump_file (DFI_ussa, decl);
2696
2697       convert_from_ssa ();
2698       /* New registers have been created.  Rescan their usage.  */
2699       reg_scan (insns, max_reg_num (), 1);
2700
2701       close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
2702       timevar_pop (TV_FROM_SSA);
2703
2704       ggc_collect ();
2705       /* CFG is no longer maintained up-to-date.  */
2706       free_bb_for_insn ();
2707     }
2708
2709   timevar_push (TV_JUMP);
2710
2711   if (optimize > 0)
2712     {
2713       open_dump_file (DFI_null, decl);
2714       find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2715       if (rtl_dump_file)
2716         dump_flow_info (rtl_dump_file);
2717       cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2718
2719       /* Try to identify useless null pointer tests and delete them.  */
2720       if (flag_delete_null_pointer_checks)
2721         delete_null_pointer_checks (insns);
2722
2723       timevar_push (TV_IFCVT);
2724       if_convert (0);
2725       timevar_pop (TV_IFCVT);
2726       cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2727       close_dump_file (DFI_null, print_rtl_with_bb, insns);
2728     }
2729
2730   /* Jump optimization, and the removal of NULL pointer checks, may
2731      have reduced the number of instructions substantially.  CSE, and
2732      future passes, allocate arrays whose dimensions involve the
2733      maximum instruction UID, so if we can reduce the maximum UID
2734      we'll save big on memory.  */
2735   renumber_insns (rtl_dump_file);
2736   if (optimize)
2737     compute_bb_for_insn (get_max_uid ());
2738   timevar_pop (TV_JUMP);
2739
2740   close_dump_file (DFI_jump, print_rtl_with_bb, insns);
2741
2742   ggc_collect ();
2743
2744   /* Perform common subexpression elimination.
2745      Nonzero value from `cse_main' means that jumps were simplified
2746      and some code may now be unreachable, so do
2747      jump optimization again.  */
2748
2749   if (optimize > 0)
2750     {
2751       open_dump_file (DFI_cse, decl);
2752       if (rtl_dump_file)
2753         dump_flow_info (rtl_dump_file);
2754       timevar_push (TV_CSE);
2755
2756       reg_scan (insns, max_reg_num (), 1);
2757
2758       tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2759       if (tem)
2760         rebuild_jump_labels (insns);
2761       purge_all_dead_edges (0);
2762
2763       delete_trivially_dead_insns (insns, max_reg_num ());
2764
2765       /* If we are not running more CSE passes, then we are no longer
2766          expecting CSE to be run.  But always rerun it in a cheap mode.  */
2767       cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
2768
2769       if (tem || optimize > 1)
2770         cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2771       /* Try to identify useless null pointer tests and delete them.  */
2772       if (flag_delete_null_pointer_checks || flag_thread_jumps)
2773         {
2774           timevar_push (TV_JUMP);
2775
2776           if (flag_delete_null_pointer_checks)
2777             delete_null_pointer_checks (insns);
2778           /* CFG is no longer maintained up-to-date.  */
2779           timevar_pop (TV_JUMP);
2780         }
2781
2782       /* The second pass of jump optimization is likely to have
2783          removed a bunch more instructions.  */
2784       renumber_insns (rtl_dump_file);
2785       compute_bb_for_insn (get_max_uid ());
2786
2787       timevar_pop (TV_CSE);
2788       close_dump_file (DFI_cse, print_rtl_with_bb, insns);
2789     }
2790
2791   open_dump_file (DFI_addressof, decl);
2792
2793   purge_addressof (insns);
2794   if (optimize)
2795     purge_all_dead_edges (0);
2796   reg_scan (insns, max_reg_num (), 1);
2797
2798   close_dump_file (DFI_addressof, print_rtl, insns);
2799
2800   ggc_collect ();
2801
2802   /* Perform global cse.  */
2803
2804   if (optimize > 0 && flag_gcse)
2805     {
2806       int save_csb, save_cfj;
2807       int tem2 = 0;
2808
2809       timevar_push (TV_GCSE);
2810       open_dump_file (DFI_gcse, decl);
2811
2812       cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2813       tem = gcse_main (insns, rtl_dump_file);
2814       rebuild_jump_labels (insns);
2815       delete_trivially_dead_insns (insns, max_reg_num ());
2816
2817       save_csb = flag_cse_skip_blocks;
2818       save_cfj = flag_cse_follow_jumps;
2819       flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
2820
2821       /* If -fexpensive-optimizations, re-run CSE to clean up things done
2822          by gcse.  */
2823       if (flag_expensive_optimizations)
2824         {
2825           timevar_push (TV_CSE);
2826           reg_scan (insns, max_reg_num (), 1);
2827           tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2828           purge_all_dead_edges (0);
2829           delete_trivially_dead_insns (insns, max_reg_num ());
2830           timevar_pop (TV_CSE);
2831           cse_not_expected = !flag_rerun_cse_after_loop;
2832         }
2833
2834       /* If gcse or cse altered any jumps, rerun jump optimizations to clean
2835          things up.  Then possibly re-run CSE again.  */
2836       while (tem || tem2)
2837         {
2838           tem = tem2 = 0;
2839           timevar_push (TV_JUMP);
2840           rebuild_jump_labels (insns);
2841           cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2842           timevar_pop (TV_JUMP);
2843
2844           if (flag_expensive_optimizations)
2845             {
2846               timevar_push (TV_CSE);
2847               reg_scan (insns, max_reg_num (), 1);
2848               tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2849               purge_all_dead_edges (0);
2850               delete_trivially_dead_insns (insns, max_reg_num ());
2851               timevar_pop (TV_CSE);
2852             }
2853         }
2854
2855       close_dump_file (DFI_gcse, print_rtl_with_bb, insns);
2856       timevar_pop (TV_GCSE);
2857
2858       ggc_collect ();
2859       flag_cse_skip_blocks = save_csb;
2860       flag_cse_follow_jumps = save_cfj;
2861 #ifdef ENABLE_CHECKING
2862       verify_flow_info ();
2863 #endif
2864     }
2865
2866   /* Move constant computations out of loops.  */
2867
2868   if (optimize > 0)
2869     {
2870       timevar_push (TV_LOOP);
2871       delete_dead_jumptables ();
2872       cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2873       open_dump_file (DFI_loop, decl);
2874       /* CFG is no longer maintained up-to-date.  */
2875       free_bb_for_insn ();
2876
2877       if (flag_rerun_loop_opt)
2878         {
2879           cleanup_barriers ();
2880
2881           /* We only want to perform unrolling once.  */
2882
2883           loop_optimize (insns, rtl_dump_file, 0);
2884
2885           /* The first call to loop_optimize makes some instructions
2886              trivially dead.  We delete those instructions now in the
2887              hope that doing so will make the heuristics in loop work
2888              better and possibly speed up compilation.  */
2889           delete_trivially_dead_insns (insns, max_reg_num ());
2890
2891           /* The regscan pass is currently necessary as the alias
2892                   analysis code depends on this information.  */
2893           reg_scan (insns, max_reg_num (), 1);
2894         }
2895       cleanup_barriers ();
2896       loop_optimize (insns, rtl_dump_file,
2897                      (flag_unroll_loops ? LOOP_UNROLL : 0) | LOOP_BCT
2898                      | (flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0));
2899
2900       /* Loop can create trivially dead instructions.  */
2901       delete_trivially_dead_insns (insns, max_reg_num ());
2902       close_dump_file (DFI_loop, print_rtl, insns);
2903       timevar_pop (TV_LOOP);
2904
2905       ggc_collect ();
2906     }
2907
2908   /* Do control and data flow analysis; wrote some of the results to
2909      the dump file.  */
2910
2911   timevar_push (TV_FLOW);
2912   open_dump_file (DFI_cfg, decl);
2913
2914   find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2915   if (rtl_dump_file)
2916     dump_flow_info (rtl_dump_file);
2917   cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0)
2918                | (flag_thread_jumps ? CLEANUP_THREADING : 0));
2919
2920   /* It may make more sense to mark constant functions after dead code is
2921      eliminated by life_analyzis, but we need to do it early, as -fprofile-arcs
2922      may insert code making function non-constant, but we still must consider
2923      it as constant, otherwise -fbranch-probabilities will not read data back.
2924
2925      life_analyzis rarely eliminates modification of external memory.
2926    */
2927   mark_constant_function ();
2928
2929   close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
2930
2931   /* Do branch profiling and static profile estimation passes.  */
2932   if (optimize > 0 || profile_arc_flag || flag_test_coverage
2933       || flag_branch_probabilities)
2934     {
2935       struct loops loops;
2936
2937       timevar_push (TV_BRANCH_PROB);
2938       open_dump_file (DFI_bp, decl);
2939       if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
2940         branch_prob ();
2941
2942       /* Discover and record the loop depth at the head of each basic
2943          block.  The loop infrastructure does the real job for us.  */
2944       flow_loops_find (&loops, LOOP_TREE);
2945
2946       /* Estimate using heuristics if no profiling info is available.  */
2947       if (flag_guess_branch_prob)
2948         estimate_probability (&loops);
2949
2950       if (rtl_dump_file)
2951         flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
2952
2953       flow_loops_free (&loops);
2954       close_dump_file (DFI_bp, print_rtl_with_bb, insns);
2955       timevar_pop (TV_BRANCH_PROB);
2956     }
2957
2958   if (optimize > 0)
2959     {
2960       timevar_push (TV_CSE2);
2961       open_dump_file (DFI_cse2, decl);
2962       if (rtl_dump_file)
2963         dump_flow_info (rtl_dump_file);
2964
2965       if (flag_rerun_cse_after_loop)
2966         {
2967           timevar_push (TV_JUMP);
2968
2969           reg_scan (insns, max_reg_num (), 0);
2970
2971           timevar_push (TV_IFCVT);
2972           cleanup_cfg (CLEANUP_EXPENSIVE);
2973           if_convert (0);
2974           timevar_pop(TV_IFCVT);
2975
2976           timevar_pop (TV_JUMP);
2977           /* CFG is no longer maintained up-to-date.  */
2978           reg_scan (insns, max_reg_num (), 0);
2979           tem = cse_main (insns, max_reg_num (), 1, rtl_dump_file);
2980           purge_all_dead_edges (0);
2981           delete_trivially_dead_insns (insns, max_reg_num ());
2982
2983           if (tem)
2984             {
2985               timevar_push (TV_JUMP);
2986               rebuild_jump_labels (insns);
2987               cleanup_cfg (CLEANUP_EXPENSIVE);
2988               timevar_pop (TV_JUMP);
2989             }
2990         }
2991
2992       close_dump_file (DFI_cse2, print_rtl_with_bb, insns);
2993       timevar_pop (TV_CSE2);
2994
2995       ggc_collect ();
2996     }
2997
2998   cse_not_expected = 1;
2999
3000   open_dump_file (DFI_life, decl);
3001   regclass_init ();
3002
3003   check_function_return_warnings ();
3004
3005 #ifdef ENABLE_CHECKING
3006   verify_flow_info ();
3007 #endif
3008   life_analysis (insns, rtl_dump_file, PROP_FINAL);
3009   if (optimize)
3010     cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_UPDATE_LIFE
3011                  | (flag_thread_jumps ? CLEANUP_THREADING : 0));
3012   timevar_pop (TV_FLOW);
3013
3014   no_new_pseudos = 1;
3015
3016   if (warn_uninitialized || extra_warnings)
3017     {
3018       uninitialized_vars_warning (DECL_INITIAL (decl));
3019       if (extra_warnings)
3020         setjmp_args_warning ();
3021     }
3022
3023   if (optimize)
3024     {
3025       clear_bb_flags ();
3026       if (initialize_uninitialized_subregs ())
3027         {
3028           /* Insns were inserted, so things might look a bit different.  */
3029           insns = get_insns ();
3030           update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
3031                                             PROP_LOG_LINKS | PROP_REG_INFO
3032                                             | PROP_DEATH_NOTES);
3033         }
3034     }
3035
3036   close_dump_file (DFI_life, print_rtl_with_bb, insns);
3037
3038   ggc_collect ();
3039
3040   /* If -opt, try combining insns through substitution.  */
3041
3042   if (optimize > 0)
3043     {
3044       int rebuild_jump_labels_after_combine = 0;
3045
3046       timevar_push (TV_COMBINE);
3047       open_dump_file (DFI_combine, decl);
3048
3049       rebuild_jump_labels_after_combine
3050         = combine_instructions (insns, max_reg_num ());
3051
3052       /* Combining insns may have turned an indirect jump into a
3053          direct jump.  Rebuid the JUMP_LABEL fields of jumping
3054          instructions.  */
3055       if (rebuild_jump_labels_after_combine)
3056         {
3057           timevar_push (TV_JUMP);
3058           rebuild_jump_labels (insns);
3059           timevar_pop (TV_JUMP);
3060
3061           cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
3062         }
3063
3064       close_dump_file (DFI_combine, print_rtl_with_bb, insns);
3065       timevar_pop (TV_COMBINE);
3066
3067       ggc_collect ();
3068     }
3069
3070   /* Rerun if-conversion, as combine may have simplified things enough to
3071      now meet sequence length restrictions.  */
3072   if (optimize > 0)
3073     {
3074       timevar_push (TV_IFCVT);
3075       open_dump_file (DFI_ce, decl);
3076
3077       no_new_pseudos = 0;
3078       if_convert (1);
3079       no_new_pseudos = 1;
3080
3081       close_dump_file (DFI_ce, print_rtl_with_bb, insns);
3082       timevar_pop (TV_IFCVT);
3083     }
3084
3085   /* Register allocation pre-pass, to reduce number of moves
3086      necessary for two-address machines.  */
3087   if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
3088     {
3089       timevar_push (TV_REGMOVE);
3090       open_dump_file (DFI_regmove, decl);
3091
3092       regmove_optimize (insns, max_reg_num (), rtl_dump_file);
3093
3094       cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
3095       close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
3096       timevar_pop (TV_REGMOVE);
3097
3098       ggc_collect ();
3099     }
3100
3101   /* Do unconditional splitting before register allocation to allow machine
3102      description to add extra information not needed previously.  */
3103   split_all_insns (1);
3104
3105   /* Any of the several passes since flow1 will have munged register
3106      lifetime data a bit.  */
3107   register_life_up_to_date = 0;
3108
3109 #ifdef OPTIMIZE_MODE_SWITCHING
3110   timevar_push (TV_MODE_SWITCH);
3111
3112   no_new_pseudos = 0;
3113   optimize_mode_switching (NULL);
3114   no_new_pseudos = 1;
3115
3116   timevar_pop (TV_MODE_SWITCH);
3117 #endif
3118
3119   timevar_push (TV_SCHED);
3120
3121 #ifdef INSN_SCHEDULING
3122
3123   /* Print function header into sched dump now
3124      because doing the sched analysis makes some of the dump.  */
3125   if (optimize > 0 && flag_schedule_insns)
3126     {
3127       open_dump_file (DFI_sched, decl);
3128
3129       /* Do control and data sched analysis,
3130          and write some of the results to dump file.  */
3131
3132       schedule_insns (rtl_dump_file);
3133
3134       close_dump_file (DFI_sched, print_rtl_with_bb, insns);
3135
3136       /* Register lifetime information was updated as part of verifying
3137          the schedule.  */
3138       register_life_up_to_date = 1;
3139     }
3140 #endif
3141   timevar_pop (TV_SCHED);
3142
3143   ggc_collect ();
3144
3145   /* Determine if the current function is a leaf before running reload
3146      since this can impact optimizations done by the prologue and
3147      epilogue thus changing register elimination offsets.  */
3148   current_function_is_leaf = leaf_function_p ();
3149
3150   timevar_push (TV_LOCAL_ALLOC);
3151   open_dump_file (DFI_lreg, decl);
3152
3153   /* Allocate pseudo-regs that are used only within 1 basic block.
3154
3155      RUN_JUMP_AFTER_RELOAD records whether or not we need to rerun the
3156      jump optimizer after register allocation and reloading are finished.  */
3157
3158   if (! register_life_up_to_date)
3159     recompute_reg_usage (insns, ! optimize_size);
3160
3161   /* Allocate the reg_renumber array.  */
3162   allocate_reg_info (max_regno, FALSE, TRUE);
3163
3164   /* And the reg_equiv_memory_loc array.  */
3165   reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
3166
3167   allocate_initial_values (reg_equiv_memory_loc);
3168
3169   regclass (insns, max_reg_num (), rtl_dump_file);
3170   rebuild_label_notes_after_reload = local_alloc ();
3171
3172   timevar_pop (TV_LOCAL_ALLOC);
3173
3174   if (dump_file[DFI_lreg].enabled)
3175     {
3176       timevar_push (TV_DUMP);
3177
3178       dump_flow_info (rtl_dump_file);
3179       dump_local_alloc (rtl_dump_file);
3180
3181       close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
3182       timevar_pop (TV_DUMP);
3183     }
3184
3185   ggc_collect ();
3186
3187   timevar_push (TV_GLOBAL_ALLOC);
3188   open_dump_file (DFI_greg, decl);
3189
3190   /* If optimizing, allocate remaining pseudo-regs.  Do the reload
3191      pass fixing up any insns that are invalid.  */
3192
3193   if (optimize)
3194     failure = global_alloc (rtl_dump_file);
3195   else
3196     {
3197       build_insn_chain (insns);
3198       failure = reload (insns, 0);
3199     }
3200
3201   timevar_pop (TV_GLOBAL_ALLOC);
3202
3203   if (dump_file[DFI_greg].enabled)
3204     {
3205       timevar_push (TV_DUMP);
3206
3207       dump_global_regs (rtl_dump_file);
3208
3209       close_dump_file (DFI_greg, print_rtl_with_bb, insns);
3210       timevar_pop (TV_DUMP);
3211     }
3212
3213   if (failure)
3214     goto exit_rest_of_compilation;
3215
3216   ggc_collect ();
3217
3218   open_dump_file (DFI_postreload, decl);
3219
3220   /* Do a very simple CSE pass over just the hard registers.  */
3221   if (optimize > 0)
3222     {
3223       timevar_push (TV_RELOAD_CSE_REGS);
3224       reload_cse_regs (insns);
3225       timevar_pop (TV_RELOAD_CSE_REGS);
3226     }
3227
3228   /* Register allocation and reloading may have turned an indirect jump into
3229      a direct jump.  If so, we must rebuild the JUMP_LABEL fields of
3230      jumping instructions.  */
3231   if (rebuild_label_notes_after_reload)
3232     {
3233       timevar_push (TV_JUMP);
3234
3235       rebuild_jump_labels (insns);
3236       purge_all_dead_edges (0);
3237
3238       timevar_pop (TV_JUMP);
3239     }
3240
3241   close_dump_file (DFI_postreload, print_rtl_with_bb, insns);
3242
3243   /* Re-create the death notes which were deleted during reload.  */
3244   timevar_push (TV_FLOW2);
3245   open_dump_file (DFI_flow2, decl);
3246
3247 #ifdef ENABLE_CHECKING
3248   verify_flow_info ();
3249 #endif
3250
3251   /* If optimizing, then go ahead and split insns now.  */
3252   if (optimize > 0)
3253     split_all_insns (0);
3254
3255   cleanup_cfg (optimize ? CLEANUP_EXPENSIVE : 0);
3256
3257   /* On some machines, the prologue and epilogue code, or parts thereof,
3258      can be represented as RTL.  Doing so lets us schedule insns between
3259      it and the rest of the code and also allows delayed branch
3260      scheduling to operate in the epilogue.  */
3261   thread_prologue_and_epilogue_insns (insns);
3262
3263   if (optimize)
3264     {
3265       life_analysis (insns, rtl_dump_file, PROP_FINAL);
3266       cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_CROSSJUMP | CLEANUP_UPDATE_LIFE);
3267
3268       /* This is kind of a heuristic.  We need to run combine_stack_adjustments
3269          even for machines with possibly nonzero RETURN_POPS_ARGS
3270          and ACCUMULATE_OUTGOING_ARGS.  We expect that only ports having
3271          push instructions will have popping returns.  */
3272 #ifndef PUSH_ROUNDING
3273       if (!ACCUMULATE_OUTGOING_ARGS)
3274 #endif
3275         combine_stack_adjustments ();
3276
3277       ggc_collect ();
3278     }
3279
3280   flow2_completed = 1;
3281
3282   close_dump_file (DFI_flow2, print_rtl_with_bb, insns);
3283   timevar_pop (TV_FLOW2);
3284
3285 #ifdef HAVE_peephole2
3286   if (optimize > 0 && flag_peephole2)
3287     {
3288       timevar_push (TV_PEEPHOLE2);
3289       open_dump_file (DFI_peephole2, decl);
3290
3291       peephole2_optimize (rtl_dump_file);
3292
3293       close_dump_file (DFI_peephole2, print_rtl_with_bb, insns);
3294       timevar_pop (TV_PEEPHOLE2);
3295     }
3296 #endif
3297
3298   if (flag_rename_registers || flag_cprop_registers)
3299     {
3300       timevar_push (TV_RENAME_REGISTERS);
3301       open_dump_file (DFI_rnreg, decl);
3302
3303       if (flag_rename_registers)
3304         regrename_optimize ();
3305       if (flag_cprop_registers)
3306         copyprop_hardreg_forward ();
3307
3308       close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
3309       timevar_pop (TV_RENAME_REGISTERS);
3310     }
3311
3312   if (optimize > 0)
3313     {
3314       timevar_push (TV_IFCVT2);
3315       open_dump_file (DFI_ce2, decl);
3316
3317       if_convert (1);
3318
3319       close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
3320       timevar_pop (TV_IFCVT2);
3321     }
3322 #ifdef STACK_REGS
3323   if (optimize)
3324     split_all_insns (1);
3325 #endif
3326
3327 #ifdef INSN_SCHEDULING
3328   if (optimize > 0 && flag_schedule_insns_after_reload)
3329     {
3330       timevar_push (TV_SCHED2);
3331       open_dump_file (DFI_sched2, decl);
3332
3333       /* Do control and data sched analysis again,
3334          and write some more of the results to dump file.  */
3335
3336       split_all_insns (1);
3337
3338       schedule_insns (rtl_dump_file);
3339
3340       close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
3341       timevar_pop (TV_SCHED2);
3342
3343       ggc_collect ();
3344     }
3345 #endif
3346
3347 #ifdef LEAF_REGISTERS
3348   current_function_uses_only_leaf_regs
3349     = optimize > 0 && only_leaf_regs_used () && leaf_function_p ();
3350 #endif
3351
3352 #ifdef STACK_REGS
3353   timevar_push (TV_REG_STACK);
3354   open_dump_file (DFI_stack, decl);
3355
3356   reg_to_stack (insns, rtl_dump_file);
3357
3358   close_dump_file (DFI_stack, print_rtl_with_bb, insns);
3359   timevar_pop (TV_REG_STACK);
3360
3361   ggc_collect ();
3362 #endif
3363   if (optimize > 0)
3364     {
3365       timevar_push (TV_REORDER_BLOCKS);
3366       open_dump_file (DFI_bbro, decl);
3367
3368       /* Last attempt to optimize CFG, as scheduling, peepholing
3369          and insn splitting possibly introduced more crossjumping
3370          oppurtuntities.  */
3371       cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
3372                    | CLEANUP_CROSSJUMP);
3373       if (flag_reorder_blocks)
3374         {
3375           reorder_basic_blocks ();
3376           cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
3377         }
3378
3379       close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
3380       timevar_pop (TV_REORDER_BLOCKS);
3381     }
3382   compute_alignments ();
3383
3384   /* CFG is no longer maintained up-to-date.  */
3385   free_bb_for_insn ();
3386
3387   /* If a machine dependent reorganization is needed, call it.  */
3388 #ifdef MACHINE_DEPENDENT_REORG
3389   timevar_push (TV_MACH_DEP);
3390   open_dump_file (DFI_mach, decl);
3391
3392   MACHINE_DEPENDENT_REORG (insns);
3393
3394   close_dump_file (DFI_mach, print_rtl, insns);
3395   timevar_pop (TV_MACH_DEP);
3396
3397   ggc_collect ();
3398 #endif
3399
3400   purge_line_number_notes (insns);
3401   cleanup_barriers ();
3402
3403   /* If a scheduling pass for delayed branches is to be done,
3404      call the scheduling code.  */
3405
3406 #ifdef DELAY_SLOTS
3407   if (optimize > 0 && flag_delayed_branch)
3408     {
3409       timevar_push (TV_DBR_SCHED);
3410       open_dump_file (DFI_dbr, decl);
3411
3412       dbr_schedule (insns, rtl_dump_file);
3413
3414       close_dump_file (DFI_dbr, print_rtl, insns);
3415       timevar_pop (TV_DBR_SCHED);
3416
3417       ggc_collect ();
3418     }
3419 #endif
3420
3421 #if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
3422   timevar_push (TV_SHORTEN_BRANCH);
3423   split_all_insns_noflow ();
3424   timevar_pop (TV_SHORTEN_BRANCH);
3425 #endif
3426
3427   convert_to_eh_region_ranges ();
3428
3429   /* Shorten branches.  */
3430   timevar_push (TV_SHORTEN_BRANCH);
3431   shorten_branches (get_insns ());
3432   timevar_pop (TV_SHORTEN_BRANCH);
3433
3434   current_function_nothrow = nothrow_function_p ();
3435   if (current_function_nothrow)
3436     /* Now we know that this can't throw; set the flag for the benefit
3437        of other functions later in this translation unit.  */
3438     TREE_NOTHROW (current_function_decl) = 1;
3439
3440   /* Now turn the rtl into assembler code.  */
3441
3442   timevar_push (TV_FINAL);
3443   {
3444     rtx x;
3445     const char *fnname;
3446
3447     /* Get the function's name, as described by its RTL.  This may be
3448        different from the DECL_NAME name used in the source file.  */
3449
3450     x = DECL_RTL (decl);
3451     if (GET_CODE (x) != MEM)
3452       abort ();
3453     x = XEXP (x, 0);
3454     if (GET_CODE (x) != SYMBOL_REF)
3455       abort ();
3456     fnname = XSTR (x, 0);
3457
3458     assemble_start_function (decl, fnname);
3459     final_start_function (insns, asm_out_file, optimize);
3460     final (insns, asm_out_file, optimize, 0);
3461     final_end_function ();
3462
3463 #ifdef IA64_UNWIND_INFO
3464     /* ??? The IA-64 ".handlerdata" directive must be issued before
3465        the ".endp" directive that closes the procedure descriptor.  */
3466     output_function_exception_table ();
3467 #endif
3468
3469     assemble_end_function (decl, fnname);
3470
3471 #ifndef IA64_UNWIND_INFO
3472     /* Otherwise, it feels unclean to switch sections in the middle.  */
3473     output_function_exception_table ();
3474 #endif
3475
3476     if (! quiet_flag)
3477       fflush (asm_out_file);
3478
3479     /* Release all memory allocated by flow.  */
3480     free_basic_block_vars (0);
3481
3482     /* Release all memory held by regsets now.  */
3483     regset_release_memory ();
3484   }
3485   timevar_pop (TV_FINAL);
3486
3487   ggc_collect ();
3488
3489   /* Write DBX symbols if requested.  */
3490
3491   /* Note that for those inline functions where we don't initially
3492      know for certain that we will be generating an out-of-line copy,
3493      the first invocation of this routine (rest_of_compilation) will
3494      skip over this code by doing a `goto exit_rest_of_compilation;'.
3495      Later on, finish_compilation will call rest_of_compilation again
3496      for those inline functions that need to have out-of-line copies
3497      generated.  During that call, we *will* be routed past here.  */
3498
3499   timevar_push (TV_SYMOUT);
3500   (*debug_hooks->function_decl) (decl);
3501   timevar_pop (TV_SYMOUT);
3502
3503  exit_rest_of_compilation:
3504
3505   /* In case the function was not output,
3506      don't leave any temporary anonymous types
3507      queued up for sdb output.  */
3508 #ifdef SDB_DEBUGGING_INFO
3509   if (write_symbols == SDB_DEBUG)
3510     sdbout_types (NULL_TREE);
3511 #endif
3512
3513   reload_completed = 0;
3514   flow2_completed = 0;
3515   no_new_pseudos = 0;
3516
3517   timevar_push (TV_FINAL);
3518
3519   /* Clear out the insn_length contents now that they are no
3520      longer valid.  */
3521   init_insn_lengths ();
3522
3523   /* Clear out the real_constant_chain before some of the rtx's
3524      it runs through become garbage.  */
3525   clear_const_double_mem ();
3526
3527   /* Show no temporary slots allocated.  */
3528   init_temp_slots ();
3529
3530   free_basic_block_vars (0);
3531   free_bb_for_insn ();
3532
3533   timevar_pop (TV_FINAL);
3534
3535   /* Make sure volatile mem refs aren't considered valid operands for
3536      arithmetic insns.  We must call this here if this is a nested inline
3537      function, since the above code leaves us in the init_recog state
3538      (from final.c), and the function context push/pop code does not
3539      save/restore volatile_ok.
3540
3541      ??? Maybe it isn't necessary for expand_start_function to call this
3542      anymore if we do it here?  */
3543
3544   init_recog_no_volatile ();
3545
3546   /* We're done with this function.  Free up memory if we can.  */
3547   free_after_parsing (cfun);
3548   if (! DECL_DEFER_OUTPUT (decl))
3549     {
3550       free_after_compilation (cfun);
3551
3552       /* Clear integrate.c's pointer to the cfun structure we just
3553          destroyed.  */
3554       DECL_SAVED_INSNS (decl) = 0;
3555     }
3556   cfun = 0;
3557
3558   ggc_collect ();
3559
3560   timevar_pop (TV_REST_OF_COMPILATION);
3561 }
3562 \f
3563 static void
3564 display_help ()
3565 {
3566   int undoc;
3567   unsigned long i;
3568   const char *lang;
3569
3570   printf (_("  -ffixed-<register>      Mark <register> as being unavailable to the compiler\n"));
3571   printf (_("  -fcall-used-<register>  Mark <register> as being corrupted by function calls\n"));
3572   printf (_("  -fcall-saved-<register> Mark <register> as being preserved across functions\n"));
3573   printf (_("  -finline-limit=<number> Limits the size of inlined functions to <number>\n"));
3574   printf (_("  -fmessage-length=<number> Limits diagnostics messages lengths to <number> characters per line.  0 suppresses line-wrapping\n"));
3575   printf (_("  -fdiagnostics-show-location=[once | every-line] Indicates how often source location information should be emitted, as prefix, at the beginning of diagnostics when line-wrapping\n"));
3576
3577   for (i = ARRAY_SIZE (f_options); i--;)
3578     {
3579       const char *description = f_options[i].description;
3580
3581       if (description != NULL && * description != 0)
3582         printf ("  -f%-21s %s\n",
3583                 f_options[i].string, _(description));
3584     }
3585
3586   printf (_("  -O[number]              Set optimization level to [number]\n"));
3587   printf (_("  -Os                     Optimize for space rather than speed\n"));
3588   for (i = LAST_PARAM; i--;)
3589     {
3590       const char *description = compiler_params[i].help;
3591       const int length = 21-strlen(compiler_params[i].option);
3592
3593       if (description != NULL && * description != 0)
3594         printf ("  --param %s=<value>%.*s%s\n",
3595                 compiler_params[i].option,
3596                 length > 0 ? length : 1, "                     ",
3597                 _(description));
3598     }
3599   printf (_("  -pedantic               Issue warnings needed by strict compliance to ISO C\n"));
3600   printf (_("  -pedantic-errors        Like -pedantic except that errors are produced\n"));
3601   printf (_("  -w                      Suppress warnings\n"));
3602   printf (_("  -W                      Enable extra warnings\n"));
3603
3604   for (i = ARRAY_SIZE (W_options); i--;)
3605     {
3606       const char *description = W_options[i].description;
3607
3608       if (description != NULL && * description != 0)
3609         printf ("  -W%-21s %s\n",
3610                 W_options[i].string, _(description));
3611     }
3612
3613   printf (_("  -Wunused                Enable unused warnings\n"));
3614   printf (_("  -Wlarger-than-<number>  Warn if an object is larger than <number> bytes\n"));
3615   printf (_("  -p                      Enable function profiling\n"));
3616 #if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER)
3617   printf (_("  -a                      Enable block profiling \n"));
3618 #endif
3619 #if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER) || defined FUNCTION_BLOCK_PROFILER_EXIT
3620   printf (_("  -ax                     Enable jump profiling \n"));
3621 #endif
3622   printf (_("  -o <file>               Place output into <file> \n"));
3623   printf (_("\
3624   -G <number>             Put global and static data smaller than <number>\n\
3625                           bytes into a special section (on some targets)\n"));
3626
3627   for (i = ARRAY_SIZE (debug_args); i--;)
3628     {
3629       if (debug_args[i].description != NULL)
3630         printf ("  -g%-21s %s\n",
3631                 debug_args[i].arg, _(debug_args[i].description));
3632     }
3633
3634   printf (_("  -aux-info <file>        Emit declaration info into <file>\n"));
3635   printf (_("  -quiet                  Do not display functions compiled or elapsed time\n"));
3636   printf (_("  -version                Display the compiler's version\n"));
3637   printf (_("  -d[letters]             Enable dumps from specific passes of the compiler\n"));
3638   printf (_("  -dumpbase <file>        Base name to be used for dumps from specific passes\n"));
3639 #if defined INSN_SCHEDULING
3640   printf (_("  -fsched-verbose=<number> Set the verbosity level of the scheduler\n"));
3641 #endif
3642   printf (_("  --help                  Display this information\n"));
3643
3644   undoc = 0;
3645   lang  = "language";
3646
3647   /* Display descriptions of language specific options.
3648      If there is no description, note that there is an undocumented option.
3649      If the description is empty, do not display anything.  (This allows
3650      options to be deliberately undocumented, for whatever reason).
3651      If the option string is missing, then this is a marker, indicating
3652      that the description string is in fact the name of a language, whose
3653      language specific options are to follow.  */
3654
3655   if (ARRAY_SIZE (documented_lang_options) > 1)
3656     {
3657       printf (_("\nLanguage specific options:\n"));
3658
3659       for (i = 0; i < ARRAY_SIZE (documented_lang_options); i++)
3660         {
3661           const char *description = documented_lang_options[i].description;
3662           const char *option      = documented_lang_options[i].option;
3663
3664           if (description == NULL)
3665             {
3666               undoc = 1;
3667
3668               if (extra_warnings)
3669                 printf (_("  %-23.23s [undocumented]\n"), option);
3670             }
3671           else if (*description == 0)
3672             continue;
3673           else if (option == NULL)
3674             {
3675               if (undoc)
3676                 printf
3677                   (_("\nThere are undocumented %s specific options as well.\n"),
3678                         lang);
3679               undoc = 0;
3680
3681               printf (_("\n Options for %s:\n"), description);
3682
3683               lang = description;
3684             }
3685           else
3686             printf ("  %-23.23s %s\n", option, _(description));
3687         }
3688     }
3689
3690   if (undoc)
3691     printf (_("\nThere are undocumented %s specific options as well.\n"),
3692             lang);
3693
3694   display_target_options ();
3695 }
3696
3697 static void
3698 display_target_options ()
3699 {
3700   int undoc, i;
3701   static bool displayed = false;
3702
3703   /* Avoid double printing for --help --target-help.  */
3704   if (displayed)
3705     return;
3706   displayed = true;
3707
3708   if (ARRAY_SIZE (target_switches) > 1
3709 #ifdef&nbs