Use MODE_BASE_REG_CLASS in legitimize macros.
[official-gcc.git] / gcc / toplev.c
blob5d58ead1fd2311fda26178d606025468b9da95ef
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.
5 This file is part of GCC.
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.
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.
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. */
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. */
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>
34 #ifdef HAVE_SYS_RESOURCE_H
35 # include <sys/resource.h>
36 #endif
38 #ifdef HAVE_SYS_TIMES_H
39 # include <sys/times.h>
40 #endif
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"
74 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
75 #include "dwarf2out.h"
76 #endif
78 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
79 #include "dbxout.h"
80 #endif
82 #ifdef SDB_DEBUGGING_INFO
83 #include "sdbout.h"
84 #endif
86 #ifdef XCOFF_DEBUGGING_INFO
87 #include "xcoffout.h" /* Needed for external data
88 declarations for e.g. AIX 4.x. */
89 #endif
91 #ifdef HALF_PIC_DEBUG
92 #include "halfpic.h"
93 #endif
95 #ifdef VMS
96 /* The extra parameters substantially improve the I/O performance. */
98 static FILE *
99 vms_fopen (fname, type)
100 char *fname;
101 char *type;
103 /* The <stdio.h> in the gcc-vms-1.42 distribution prototypes fopen with two
104 fixed arguments, which matches ANSI's specification but not VAXCRTL's
105 pre-ANSI implementation. This hack circumvents the mismatch problem. */
106 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
108 if (*type == 'w')
109 return (*vmslib_fopen) (fname, type, "mbc=32",
110 "deq=64", "fop=tef", "shr=nil");
111 else
112 return (*vmslib_fopen) (fname, type, "mbc=32");
115 #define fopen vms_fopen
116 #endif /* VMS */
118 /* Carry information from ASM_DECLARE_OBJECT_NAME
119 to ASM_FINISH_DECLARE_OBJECT. */
121 extern int size_directive_output;
122 extern tree last_assemble_variable_decl;
124 static void general_init PARAMS ((char *));
125 static void parse_options_and_default_flags PARAMS ((int, char **));
126 static void do_compile PARAMS ((void));
127 static void process_options PARAMS ((void));
128 static void lang_independent_init PARAMS ((void));
129 static int lang_dependent_init PARAMS ((const char *));
130 static void init_asm_output PARAMS ((const char *));
131 static void finalize PARAMS ((void));
133 static void set_target_switch PARAMS ((const char *));
134 static const char *decl_name PARAMS ((tree, int));
136 static void float_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
137 static void crash_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
138 static void set_float_handler PARAMS ((jmp_buf));
139 static void compile_file PARAMS ((void));
140 static void display_help PARAMS ((void));
141 static void display_target_options PARAMS ((void));
143 static void decode_d_option PARAMS ((const char *));
144 static int decode_f_option PARAMS ((const char *));
145 static int decode_W_option PARAMS ((const char *));
146 static int decode_g_option PARAMS ((const char *));
147 static unsigned int independent_decode_option PARAMS ((int, char **));
149 static void print_version PARAMS ((FILE *, const char *));
150 static int print_single_switch PARAMS ((FILE *, int, int, const char *,
151 const char *, const char *,
152 const char *, const char *));
153 static void print_switch_values PARAMS ((FILE *, int, int, const char *,
154 const char *, const char *));
156 /* Length of line when printing switch values. */
157 #define MAX_LINE 75
159 /* Name of program invoked, sans directories. */
161 const char *progname;
163 /* Copy of arguments to toplev_main. */
164 int save_argc;
165 char **save_argv;
167 /* Name of current original source file (what was input to cpp).
168 This comes from each #-command in the actual input. */
170 const char *input_filename;
172 /* Name of top-level original source file (what was input to cpp).
173 This comes from the #-command at the beginning of the actual input.
174 If there isn't any there, then this is the cc1 input file name. */
176 const char *main_input_filename;
178 /* Current line number in real source file. */
180 int lineno;
182 /* Nonzero if it is unsafe to create any new pseudo registers. */
183 int no_new_pseudos;
185 /* Stack of currently pending input files. */
187 struct file_stack *input_file_stack;
189 /* Incremented on each change to input_file_stack. */
190 int input_file_stack_tick;
192 /* Name to use as base of names for dump output files. */
194 const char *dump_base_name;
196 /* Format to use to print dumpfile index value */
197 #ifndef DUMPFILE_FORMAT
198 #define DUMPFILE_FORMAT ".%02d."
199 #endif
201 /* Bit flags that specify the machine subtype we are compiling for.
202 Bits are tested using macros TARGET_... defined in the tm.h file
203 and set by `-m...' switches. Must be defined in rtlanal.c. */
205 extern int target_flags;
207 /* Debug hooks - dependent upon command line options. */
209 struct gcc_debug_hooks *debug_hooks = &do_nothing_debug_hooks;
211 /* Describes a dump file. */
213 struct dump_file_info
215 /* The unique extension to apply, e.g. ".jump". */
216 const char *const extension;
218 /* The -d<c> character that enables this dump file. */
219 char const debug_switch;
221 /* True if there is a corresponding graph dump file. */
222 char const graph_dump_p;
224 /* True if the user selected this dump. */
225 char enabled;
227 /* True if the files have been initialized (ie truncated). */
228 char initialized;
231 /* Enumerate the extant dump files. */
233 enum dump_file_index
235 DFI_rtl,
236 DFI_sibling,
237 DFI_eh,
238 DFI_jump,
239 DFI_ssa,
240 DFI_ssa_ccp,
241 DFI_ssa_dce,
242 DFI_ussa,
243 DFI_cse,
244 DFI_addressof,
245 DFI_gcse,
246 DFI_loop,
247 DFI_cse2,
248 DFI_cfg,
249 DFI_bp,
250 DFI_life,
251 DFI_combine,
252 DFI_ce,
253 DFI_regmove,
254 DFI_sched,
255 DFI_lreg,
256 DFI_greg,
257 DFI_postreload,
258 DFI_flow2,
259 DFI_peephole2,
260 DFI_rnreg,
261 DFI_ce2,
262 DFI_sched2,
263 DFI_stack,
264 DFI_bbro,
265 DFI_mach,
266 DFI_dbr,
267 DFI_MAX
270 /* Describes all the dump files. Should be kept in order of the
271 pass and in sync with dump_file_index above.
273 Remaining -d letters:
275 " o q u "
276 " H JK OPQ TUV YZ"
279 static struct dump_file_info dump_file[DFI_MAX] =
281 { "rtl", 'r', 0, 0, 0 },
282 { "sibling", 'i', 0, 0, 0 },
283 { "eh", 'h', 0, 0, 0 },
284 { "jump", 'j', 0, 0, 0 },
285 { "ssa", 'e', 1, 0, 0 },
286 { "ssaccp", 'W', 1, 0, 0 },
287 { "ssadce", 'X', 1, 0, 0 },
288 { "ussa", 'e', 1, 0, 0 }, /* Yes, duplicate enable switch. */
289 { "cse", 's', 0, 0, 0 },
290 { "addressof", 'F', 0, 0, 0 },
291 { "gcse", 'G', 1, 0, 0 },
292 { "loop", 'L', 1, 0, 0 },
293 { "cse2", 't', 1, 0, 0 },
294 { "cfg", 'f', 1, 0, 0 },
295 { "bp", 'b', 1, 0, 0 },
296 { "life", 'f', 1, 0, 0 }, /* Yes, duplicate enable switch. */
297 { "combine", 'c', 1, 0, 0 },
298 { "ce", 'C', 1, 0, 0 },
299 { "regmove", 'N', 1, 0, 0 },
300 { "sched", 'S', 1, 0, 0 },
301 { "lreg", 'l', 1, 0, 0 },
302 { "greg", 'g', 1, 0, 0 },
303 { "postreload", 'o', 1, 0, 0 },
304 { "flow2", 'w', 1, 0, 0 },
305 { "peephole2", 'z', 1, 0, 0 },
306 { "rnreg", 'n', 1, 0, 0 },
307 { "ce2", 'E', 1, 0, 0 },
308 { "sched2", 'R', 1, 0, 0 },
309 { "stack", 'k', 1, 0, 0 },
310 { "bbro", 'B', 1, 0, 0 },
311 { "mach", 'M', 1, 0, 0 },
312 { "dbr", 'd', 0, 0, 0 },
315 static int open_dump_file PARAMS ((enum dump_file_index, tree));
316 static void close_dump_file PARAMS ((enum dump_file_index,
317 void (*) (FILE *, rtx), rtx));
319 /* Other flags saying which kinds of debugging dump have been requested. */
321 int rtl_dump_and_exit;
322 int flag_print_asm_name;
323 static int version_flag;
324 static char *filename;
325 enum graph_dump_types graph_dump_format;
327 /* Name for output file of assembly code, specified with -o. */
329 char *asm_file_name;
331 /* Value of the -G xx switch, and whether it was passed or not. */
332 int g_switch_value;
333 int g_switch_set;
335 /* Type(s) of debugging information we are producing (if any).
336 See flags.h for the definitions of the different possible
337 types of debugging information. */
338 enum debug_info_type write_symbols = NO_DEBUG;
340 /* Level of debugging information we are producing. See flags.h
341 for the definitions of the different possible levels. */
342 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
344 /* Nonzero means use GNU-only extensions in the generated symbolic
345 debugging information. */
346 /* Currently, this only has an effect when write_symbols is set to
347 DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
348 int use_gnu_debug_info_extensions = 0;
350 /* Nonzero means do optimizations. -O.
351 Particular numeric values stand for particular amounts of optimization;
352 thus, -O2 stores 2 here. However, the optimizations beyond the basic
353 ones are not controlled directly by this variable. Instead, they are
354 controlled by individual `flag_...' variables that are defaulted
355 based on this variable. */
357 int optimize = 0;
359 /* Nonzero means optimize for size. -Os.
360 The only valid values are zero and non-zero. When optimize_size is
361 non-zero, optimize defaults to 2, but certain individual code
362 bloating optimizations are disabled. */
364 int optimize_size = 0;
366 /* Nonzero if we should exit after parsing options. */
367 static int exit_after_options = 0;
369 /* The FUNCTION_DECL for the function currently being compiled,
370 or 0 if between functions. */
371 tree current_function_decl;
373 /* Set to the FUNC_BEGIN label of the current function, or NULL_TREE
374 if none. */
375 tree current_function_func_begin_label;
377 /* Pointer to function to compute the name to use to print a declaration.
378 DECL is the declaration in question.
379 VERBOSITY determines what information will be printed:
380 0: DECL_NAME, demangled as necessary.
381 1: and scope information.
382 2: and any other information that might be interesting, such as function
383 parameter types in C++. */
385 const char *(*decl_printable_name) PARAMS ((tree, int));
387 /* Pointer to function to compute rtl for a language-specific tree code. */
389 typedef rtx (*lang_expand_expr_t)
390 PARAMS ((union tree_node *, rtx, enum machine_mode,
391 enum expand_modifier modifier));
393 lang_expand_expr_t lang_expand_expr = 0;
395 /* Pointer to function to finish handling an incomplete decl at the
396 end of compilation. */
398 void (*incomplete_decl_finalize_hook) PARAMS ((tree)) = 0;
400 /* Nonzero if doing dwarf2 duplicate elimination. */
402 int flag_eliminate_dwarf2_dups = 0;
404 /* Nonzero if generating code to do profiling. */
406 int profile_flag = 0;
408 /* Nonzero if generating code to profile program flow graph arcs. */
410 int profile_arc_flag = 0;
412 /* Nonzero if generating info for gcov to calculate line test coverage. */
414 int flag_test_coverage = 0;
416 /* Nonzero indicates that branch taken probabilities should be calculated. */
418 int flag_branch_probabilities = 0;
420 /* Nonzero if basic blocks should be reordered. */
422 int flag_reorder_blocks = 0;
424 /* Nonzero if registers should be renamed. */
426 int flag_rename_registers = 0;
427 int flag_cprop_registers = 0;
429 /* Nonzero for -pedantic switch: warn about anything
430 that standard spec forbids. */
432 int pedantic = 0;
434 /* Temporarily suppress certain warnings.
435 This is set while reading code from a system header file. */
437 int in_system_header = 0;
439 /* Don't print functions as they are compiled. -quiet. */
441 int quiet_flag = 0;
443 /* Print times taken by the various passes. -ftime-report. */
445 int time_report = 0;
447 /* Print memory still in use at end of compilation (which may have little
448 to do with peak memory consumption). -fmem-report. */
450 int mem_report = 0;
452 /* Non-zero means to collect statistics which might be expensive
453 and to print them when we are done. */
454 int flag_detailed_statistics = 0;
457 /* -f flags. */
459 /* Nonzero means `char' should be signed. */
461 int flag_signed_char;
463 /* Nonzero means give an enum type only as many bytes as it needs. */
465 int flag_short_enums;
467 /* Nonzero for -fcaller-saves: allocate values in regs that need to
468 be saved across function calls, if that produces overall better code.
469 Optional now, so people can test it. */
471 #ifdef DEFAULT_CALLER_SAVES
472 int flag_caller_saves = 1;
473 #else
474 int flag_caller_saves = 0;
475 #endif
477 /* Nonzero if structures and unions should be returned in memory.
479 This should only be defined if compatibility with another compiler or
480 with an ABI is needed, because it results in slower code. */
482 #ifndef DEFAULT_PCC_STRUCT_RETURN
483 #define DEFAULT_PCC_STRUCT_RETURN 1
484 #endif
486 /* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
488 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
490 /* Nonzero for -fforce-mem: load memory value into a register
491 before arithmetic on it. This makes better cse but slower compilation. */
493 int flag_force_mem = 0;
495 /* Nonzero for -fforce-addr: load memory address into a register before
496 reference to memory. This makes better cse but slower compilation. */
498 int flag_force_addr = 0;
500 /* Nonzero for -fdefer-pop: don't pop args after each function call;
501 instead save them up to pop many calls' args with one insns. */
503 int flag_defer_pop = 0;
505 /* Nonzero for -ffloat-store: don't allocate floats and doubles
506 in extended-precision registers. */
508 int flag_float_store = 0;
510 /* Nonzero for -fcse-follow-jumps:
511 have cse follow jumps to do a more extensive job. */
513 int flag_cse_follow_jumps;
515 /* Nonzero for -fcse-skip-blocks:
516 have cse follow a branch around a block. */
517 int flag_cse_skip_blocks;
519 /* Nonzero for -fexpensive-optimizations:
520 perform miscellaneous relatively-expensive optimizations. */
521 int flag_expensive_optimizations;
523 /* Nonzero for -fthread-jumps:
524 have jump optimize output of loop. */
526 int flag_thread_jumps;
528 /* Nonzero enables strength-reduction in loop.c. */
530 int flag_strength_reduce = 0;
532 /* Nonzero enables loop unrolling in unroll.c. Only loops for which the
533 number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
534 UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
535 unrolled. */
537 int flag_unroll_loops;
539 /* Nonzero enables loop unrolling in unroll.c. All loops are unrolled.
540 This is generally not a win. */
542 int flag_unroll_all_loops;
544 /* Nonzero enables prefetch optimizations for arrays in loops. */
546 int flag_prefetch_loop_arrays;
548 /* Nonzero forces all invariant computations in loops to be moved
549 outside the loop. */
551 int flag_move_all_movables = 0;
553 /* Nonzero forces all general induction variables in loops to be
554 strength reduced. */
556 int flag_reduce_all_givs = 0;
558 /* Nonzero to perform full register move optimization passes. This is the
559 default for -O2. */
561 int flag_regmove = 0;
563 /* Nonzero for -fwritable-strings:
564 store string constants in data segment and don't uniquize them. */
566 int flag_writable_strings = 0;
568 /* Nonzero means don't put addresses of constant functions in registers.
569 Used for compiling the Unix kernel, where strange substitutions are
570 done on the assembly output. */
572 int flag_no_function_cse = 0;
574 /* Nonzero for -fomit-frame-pointer:
575 don't make a frame pointer in simple functions that don't require one. */
577 int flag_omit_frame_pointer = 0;
579 /* Nonzero means place each function into its own section on those platforms
580 which support arbitrary section names and unlimited numbers of sections. */
582 int flag_function_sections = 0;
584 /* ... and similar for data. */
586 int flag_data_sections = 0;
588 /* Nonzero to inhibit use of define_optimization peephole opts. */
590 int flag_no_peephole = 0;
592 /* Nonzero allows GCC to optimize sibling and tail recursive calls. */
594 int flag_optimize_sibling_calls = 0;
596 /* Nonzero means the front end generally wants `errno' maintained by math
597 operations, like built-in SQRT. */
599 int flag_errno_math = 1;
601 /* Nonzero means that unsafe floating-point math optimizations are allowed
602 for the sake of speed. IEEE compliance is not guaranteed, and operations
603 are allowed to assume that their arguments and results are "normal"
604 (e.g., nonnegative for SQRT). */
606 int flag_unsafe_math_optimizations = 0;
608 /* Zero means that floating-point math operations cannot generate a
609 (user-visible) trap. This is the case, for example, in nonstop
610 IEEE 754 arithmetic. */
612 int flag_trapping_math = 1;
614 /* 0 means straightforward implementation of complex divide acceptable.
615 1 means wide ranges of inputs must work for complex divide.
616 2 means C99-like requirements for complex divide (not yet implemented). */
618 int flag_complex_divide_method = 0;
620 /* Nonzero means all references through pointers are volatile. */
622 int flag_volatile;
624 /* Nonzero means treat all global and extern variables as volatile. */
626 int flag_volatile_global;
628 /* Nonzero means treat all static variables as volatile. */
630 int flag_volatile_static;
632 /* Nonzero means just do syntax checking; don't output anything. */
634 int flag_syntax_only = 0;
636 /* Nonzero means perform global cse. */
638 static int flag_gcse;
640 /* Nonzero means to use global dataflow analysis to eliminate
641 useless null pointer tests. */
643 static int flag_delete_null_pointer_checks;
645 /* Nonzero means to do the enhanced load motion during gcse, which trys
646 to hoist loads by not killing them when a store to the same location
647 is seen. */
649 int flag_gcse_lm = 1;
651 /* Nonzero means to perform store motion after gcse, which will try to
652 move stores closer to the exit block. Its not very effective without
653 flag_gcse_lm. */
655 int flag_gcse_sm = 1;
657 /* Nonzero means to rerun cse after loop optimization. This increases
658 compilation time about 20% and picks up a few more common expressions. */
660 static int flag_rerun_cse_after_loop;
662 /* Nonzero means to run loop optimizations twice. */
664 int flag_rerun_loop_opt;
666 /* Nonzero for -finline-functions: ok to inline functions that look like
667 good inline candidates. */
669 int flag_inline_functions;
671 /* Nonzero for -fkeep-inline-functions: even if we make a function
672 go inline everywhere, keep its definition around for debugging
673 purposes. */
675 int flag_keep_inline_functions;
677 /* Nonzero means that functions will not be inlined. */
679 int flag_no_inline;
681 /* Nonzero means that we should emit static const variables
682 regardless of whether or not optimization is turned on. */
684 int flag_keep_static_consts = 1;
686 /* Nonzero means we should be saving declaration info into a .X file. */
688 int flag_gen_aux_info = 0;
690 /* Specified name of aux-info file. */
692 static char *aux_info_file_name;
694 /* Nonzero means make the text shared if supported. */
696 int flag_shared_data;
698 /* Nonzero means schedule into delayed branch slots if supported. */
700 int flag_delayed_branch;
702 /* Nonzero if we are compiling pure (sharable) code.
703 Value is 1 if we are doing reasonable (i.e. simple
704 offset into offset table) pic. Value is 2 if we can
705 only perform register offsets. */
707 int flag_pic;
709 /* Nonzero means generate extra code for exception handling and enable
710 exception handling. */
712 int flag_exceptions;
714 /* Nonzero means generate frame unwind info table when supported. */
716 int flag_unwind_tables = 0;
718 /* Nonzero means generate frame unwind info table exact at each insn boundary */
720 int flag_asynchronous_unwind_tables = 0;
722 /* Nonzero means don't place uninitialized global data in common storage
723 by default. */
725 int flag_no_common;
727 /* Nonzero means pretend it is OK to examine bits of target floats,
728 even if that isn't true. The resulting code will have incorrect constants,
729 but the same series of instructions that the native compiler would make. */
731 int flag_pretend_float;
733 /* Nonzero means change certain warnings into errors.
734 Usually these are warnings about failure to conform to some standard. */
736 int flag_pedantic_errors = 0;
738 /* flag_schedule_insns means schedule insns within basic blocks (before
739 local_alloc).
740 flag_schedule_insns_after_reload means schedule insns after
741 global_alloc. */
743 int flag_schedule_insns = 0;
744 int flag_schedule_insns_after_reload = 0;
746 /* The following flags have effect only for scheduling before register
747 allocation:
749 flag_schedule_interblock means schedule insns accross basic blocks.
750 flag_schedule_speculative means allow speculative motion of non-load insns.
751 flag_schedule_speculative_load means allow speculative motion of some
752 load insns.
753 flag_schedule_speculative_load_dangerous allows speculative motion of more
754 load insns. */
756 int flag_schedule_interblock = 1;
757 int flag_schedule_speculative = 1;
758 int flag_schedule_speculative_load = 0;
759 int flag_schedule_speculative_load_dangerous = 0;
761 int flag_single_precision_constant;
763 /* flag_branch_on_count_reg means try to replace add-1,compare,branch tupple
764 by a cheaper branch on a count register. */
765 int flag_branch_on_count_reg = 1;
767 /* -finhibit-size-directive inhibits output of .size for ELF.
768 This is used only for compiling crtstuff.c,
769 and it may be extended to other effects
770 needed for crtstuff.c on other systems. */
771 int flag_inhibit_size_directive = 0;
773 /* -fverbose-asm causes extra commentary information to be produced in
774 the generated assembly code (to make it more readable). This option
775 is generally only of use to those who actually need to read the
776 generated assembly code (perhaps while debugging the compiler itself).
777 -fno-verbose-asm, the default, causes the extra information
778 to be omitted and is useful when comparing two assembler files. */
780 int flag_verbose_asm = 0;
782 /* -dA causes debug commentary information to be produced in
783 the generated assembly code (to make it more readable). This option
784 is generally only of use to those who actually need to read the
785 generated assembly code (perhaps while debugging the compiler itself).
786 Currently, this switch is only used by dwarfout.c; however, it is intended
787 to be a catchall for printing debug information in the assembler file. */
789 int flag_debug_asm = 0;
791 /* -dP causes the rtl to be emitted as a comment in assembly. */
793 int flag_dump_rtl_in_asm = 0;
795 /* -fgnu-linker specifies use of the GNU linker for initializations.
796 (Or, more generally, a linker that handles initializations.)
797 -fno-gnu-linker says that collect2 will be used. */
798 #ifdef USE_COLLECT2
799 int flag_gnu_linker = 0;
800 #else
801 int flag_gnu_linker = 1;
802 #endif
804 /* Enable SSA. */
805 int flag_ssa = 0;
807 /* Enable ssa conditional constant propagation. */
808 int flag_ssa_ccp = 0;
810 /* Enable ssa aggressive dead code elimination. */
811 int flag_ssa_dce = 0;
813 /* Tag all structures with __attribute__(packed). */
814 int flag_pack_struct = 0;
816 /* Emit code to check for stack overflow; also may cause large objects
817 to be allocated dynamically. */
818 int flag_stack_check;
820 /* When non-NULL, indicates that whenever space is allocated on the
821 stack, the resulting stack pointer must not pass this
822 address---that is, for stacks that grow downward, the stack pointer
823 must always be greater than or equal to this address; for stacks
824 that grow upward, the stack pointer must be less than this address.
825 At present, the rtx may be either a REG or a SYMBOL_REF, although
826 the support provided depends on the backend. */
827 rtx stack_limit_rtx;
829 /* 0 if pointer arguments may alias each other. True in C.
830 1 if pointer arguments may not alias each other but may alias
831 global variables.
832 2 if pointer arguments may not alias each other and may not
833 alias global variables. True in Fortran.
834 This defaults to 0 for C. */
835 int flag_argument_noalias = 0;
837 /* Nonzero if we should do (language-dependent) alias analysis.
838 Typically, this analysis will assume that expressions of certain
839 types do not alias expressions of certain other types. Only used
840 if alias analysis (in general) is enabled. */
841 int flag_strict_aliasing = 0;
843 /* Instrument functions with calls at entry and exit, for profiling. */
844 int flag_instrument_function_entry_exit = 0;
846 /* Nonzero means ignore `#ident' directives. 0 means handle them.
847 On SVR4 targets, it also controls whether or not to emit a
848 string identifying the compiler. */
850 int flag_no_ident = 0;
852 /* This will perform a peephole pass before sched2. */
853 int flag_peephole2 = 0;
855 /* This will try to guess branch probabilities. */
856 int flag_guess_branch_prob = 0;
858 /* -fbounded-pointers causes gcc to compile pointers as composite
859 objects occupying three words: the pointer value, the base address
860 of the referent object, and the address immediately beyond the end
861 of the referent object. The base and extent allow us to perform
862 runtime bounds checking. -fbounded-pointers implies -fcheck-bounds. */
863 int flag_bounded_pointers = 0;
865 /* -fcheck-bounds causes gcc to generate array bounds checks.
866 For C, C++: defaults to value of flag_bounded_pointers.
867 For ObjC: defaults to off.
868 For Java: defaults to on.
869 For Fortran: defaults to off.
870 For CHILL: defaults to off. */
871 int flag_bounds_check = 0;
873 /* This will attempt to merge constant section constants, if 1 only
874 string constants and constants from constant pool, if 2 also constant
875 variables. */
876 int flag_merge_constants = 1;
878 /* If one, renumber instruction UIDs to reduce the number of
879 unused UIDs if there are a lot of instructions. If greater than
880 one, unconditionally renumber instruction UIDs. */
881 int flag_renumber_insns = 1;
883 /* Values of the -falign-* flags: how much to align labels in code.
884 0 means `use default', 1 means `don't align'.
885 For each variable, there is an _log variant which is the power
886 of two not less than the variable, for .align output. */
888 int align_loops;
889 int align_loops_log;
890 int align_loops_max_skip;
891 int align_jumps;
892 int align_jumps_log;
893 int align_jumps_max_skip;
894 int align_labels;
895 int align_labels_log;
896 int align_labels_max_skip;
897 int align_functions;
898 int align_functions_log;
900 /* Table of supported debugging formats. */
901 static const struct
903 const char *const arg;
904 /* Since PREFERRED_DEBUGGING_TYPE isn't necessarily a
905 constant expression, we use NO_DEBUG in its place. */
906 const enum debug_info_type debug_type;
907 const int use_extensions_p;
908 const char *const description;
909 } *da,
910 debug_args[] =
912 { "", NO_DEBUG, DEFAULT_GDB_EXTENSIONS,
913 N_("Generate debugging info in default format") },
914 { "gdb", NO_DEBUG, 1, N_("Generate debugging info in default extended format") },
915 #ifdef DBX_DEBUGGING_INFO
916 { "stabs", DBX_DEBUG, 0, N_("Generate STABS format debug info") },
917 { "stabs+", DBX_DEBUG, 1, N_("Generate extended STABS format debug info") },
918 #endif
919 #ifdef DWARF_DEBUGGING_INFO
920 { "dwarf", DWARF_DEBUG, 0, N_("Generate DWARF-1 format debug info") },
921 { "dwarf+", DWARF_DEBUG, 1,
922 N_("Generate extended DWARF-1 format debug info") },
923 #endif
924 #ifdef DWARF2_DEBUGGING_INFO
925 { "dwarf-2", DWARF2_DEBUG, 0, N_("Generate DWARF-2 debug info") },
926 #endif
927 #ifdef XCOFF_DEBUGGING_INFO
928 { "xcoff", XCOFF_DEBUG, 0, N_("Generate XCOFF format debug info") },
929 { "xcoff+", XCOFF_DEBUG, 1, N_("Generate extended XCOFF format debug info") },
930 #endif
931 #ifdef SDB_DEBUGGING_INFO
932 { "coff", SDB_DEBUG, 0, N_("Generate COFF format debug info") },
933 #endif
934 { 0, 0, 0, 0 }
937 typedef struct
939 const char *const string;
940 int *const variable;
941 const int on_value;
942 const char *const description;
944 lang_independent_options;
946 int flag_trapv = 0;
948 /* Add or remove a leading underscore from user symbols. */
949 int flag_leading_underscore = -1;
951 /* The user symbol prefix after having resolved same. */
952 const char *user_label_prefix;
954 static const param_info lang_independent_params[] = {
955 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT) \
956 { OPTION, DEFAULT, HELP },
957 #include "params.def"
958 #undef DEFPARAM
959 { NULL, 0, NULL }
962 /* A default for same. */
963 #ifndef USER_LABEL_PREFIX
964 #define USER_LABEL_PREFIX ""
965 #endif
967 /* Table of language-independent -f options.
968 STRING is the option name. VARIABLE is the address of the variable.
969 ON_VALUE is the value to store in VARIABLE
970 if `-fSTRING' is seen as an option.
971 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
973 static const lang_independent_options f_options[] =
975 {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
976 N_("Perform DWARF2 duplicate elimination") },
977 {"float-store", &flag_float_store, 1,
978 N_("Do not store floats in registers") },
979 {"volatile", &flag_volatile, 1,
980 N_("Consider all mem refs through pointers as volatile") },
981 {"volatile-global", &flag_volatile_global, 1,
982 N_("Consider all mem refs to global data to be volatile") },
983 {"volatile-static", &flag_volatile_static, 1,
984 N_("Consider all mem refs to static data to be volatile") },
985 {"defer-pop", &flag_defer_pop, 1,
986 N_("Defer popping functions args from stack until later") },
987 {"omit-frame-pointer", &flag_omit_frame_pointer, 1,
988 N_("When possible do not generate stack frames") },
989 {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
990 N_("Optimize sibling and tail recursive calls") },
991 {"cse-follow-jumps", &flag_cse_follow_jumps, 1,
992 N_("When running CSE, follow jumps to their targets") },
993 {"cse-skip-blocks", &flag_cse_skip_blocks, 1,
994 N_("When running CSE, follow conditional jumps") },
995 {"expensive-optimizations", &flag_expensive_optimizations, 1,
996 N_("Perform a number of minor, expensive optimizations") },
997 {"thread-jumps", &flag_thread_jumps, 1,
998 N_("Perform jump threading optimizations") },
999 {"strength-reduce", &flag_strength_reduce, 1,
1000 N_("Perform strength reduction optimizations") },
1001 {"unroll-loops", &flag_unroll_loops, 1,
1002 N_("Perform loop unrolling when iteration count is known") },
1003 {"unroll-all-loops", &flag_unroll_all_loops, 1,
1004 N_("Perform loop unrolling for all loops") },
1005 {"prefetch-loop-arrays", &flag_prefetch_loop_arrays, 1,
1006 N_("Generate prefetch instructions, if available, for arrays in loops") },
1007 {"move-all-movables", &flag_move_all_movables, 1,
1008 N_("Force all loop invariant computations out of loops") },
1009 {"reduce-all-givs", &flag_reduce_all_givs, 1,
1010 N_("Strength reduce all loop general induction variables") },
1011 {"writable-strings", &flag_writable_strings, 1,
1012 N_("Store strings in writable data section") },
1013 {"peephole", &flag_no_peephole, 0,
1014 N_("Enable machine specific peephole optimizations") },
1015 {"force-mem", &flag_force_mem, 1,
1016 N_("Copy memory operands into registers before using") },
1017 {"force-addr", &flag_force_addr, 1,
1018 N_("Copy memory address constants into regs before using") },
1019 {"function-cse", &flag_no_function_cse, 0,
1020 N_("Allow function addresses to be held in registers") },
1021 {"inline-functions", &flag_inline_functions, 1,
1022 N_("Integrate simple functions into their callers") },
1023 {"keep-inline-functions", &flag_keep_inline_functions, 1,
1024 N_("Generate code for funcs even if they are fully inlined") },
1025 {"inline", &flag_no_inline, 0,
1026 N_("Pay attention to the 'inline' keyword") },
1027 {"keep-static-consts", &flag_keep_static_consts, 1,
1028 N_("Emit static const variables even if they are not used") },
1029 {"syntax-only", &flag_syntax_only, 1,
1030 N_("Check for syntax errors, then stop") },
1031 {"shared-data", &flag_shared_data, 1,
1032 N_("Mark data as shared rather than private") },
1033 {"caller-saves", &flag_caller_saves, 1,
1034 N_("Enable saving registers around function calls") },
1035 {"pcc-struct-return", &flag_pcc_struct_return, 1,
1036 N_("Return 'short' aggregates in memory, not registers") },
1037 {"reg-struct-return", &flag_pcc_struct_return, 0,
1038 N_("Return 'short' aggregates in registers") },
1039 {"delayed-branch", &flag_delayed_branch, 1,
1040 N_("Attempt to fill delay slots of branch instructions") },
1041 {"gcse", &flag_gcse, 1,
1042 N_("Perform the global common subexpression elimination") },
1043 {"gcse-lm", &flag_gcse_lm, 1,
1044 N_("Perform enhanced load motion during global subexpression elimination") },
1045 {"gcse-sm", &flag_gcse_sm, 1,
1046 N_("Perform store motion after global subexpression elimination") },
1047 {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
1048 N_("Run CSE pass after loop optimizations") },
1049 {"rerun-loop-opt", &flag_rerun_loop_opt, 1,
1050 N_("Run the loop optimizer twice") },
1051 {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
1052 N_("Delete useless null pointer checks") },
1053 {"pretend-float", &flag_pretend_float, 1,
1054 N_("Pretend that host and target use the same FP format") },
1055 {"schedule-insns", &flag_schedule_insns, 1,
1056 N_("Reschedule instructions before register allocation") },
1057 {"schedule-insns2", &flag_schedule_insns_after_reload, 1,
1058 N_("Reschedule instructions after register allocation") },
1059 {"sched-interblock",&flag_schedule_interblock, 1,
1060 N_("Enable scheduling across basic blocks") },
1061 {"sched-spec",&flag_schedule_speculative, 1,
1062 N_("Allow speculative motion of non-loads") },
1063 {"sched-spec-load",&flag_schedule_speculative_load, 1,
1064 N_("Allow speculative motion of some loads") },
1065 {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
1066 N_("Allow speculative motion of more loads") },
1067 {"branch-count-reg",&flag_branch_on_count_reg, 1,
1068 N_("Replace add,compare,branch with branch on count reg") },
1069 {"pic", &flag_pic, 1,
1070 N_("Generate position independent code, if possible") },
1071 {"PIC", &flag_pic, 2, ""},
1072 {"exceptions", &flag_exceptions, 1,
1073 N_("Enable exception handling") },
1074 {"unwind-tables", &flag_unwind_tables, 1,
1075 N_("Just generate unwind tables for exception handling") },
1076 {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1,
1077 N_("Generate unwind tables exact at each instruction boundary") },
1078 {"non-call-exceptions", &flag_non_call_exceptions, 1,
1079 N_("Support synchronous non-call exceptions") },
1080 {"profile-arcs", &profile_arc_flag, 1,
1081 N_("Insert arc based program profiling code") },
1082 {"test-coverage", &flag_test_coverage, 1,
1083 N_("Create data files needed by gcov") },
1084 {"branch-probabilities", &flag_branch_probabilities, 1,
1085 N_("Use profiling information for branch probabilities") },
1086 {"reorder-blocks", &flag_reorder_blocks, 1,
1087 N_("Reorder basic blocks to improve code placement") },
1088 {"rename-registers", &flag_rename_registers, 1,
1089 N_("Do the register renaming optimization pass") },
1090 {"cprop-registers", &flag_cprop_registers, 1,
1091 N_("Do the register copy-propagation optimization pass") },
1092 {"common", &flag_no_common, 0,
1093 N_("Do not put uninitialized globals in the common section") },
1094 {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
1095 N_("Do not generate .size directives") },
1096 {"function-sections", &flag_function_sections, 1,
1097 N_("place each function into its own section") },
1098 {"data-sections", &flag_data_sections, 1,
1099 N_("place data items into their own section") },
1100 {"verbose-asm", &flag_verbose_asm, 1,
1101 N_("Add extra commentry to assembler output") },
1102 {"gnu-linker", &flag_gnu_linker, 1,
1103 N_("Output GNU ld formatted global initializers") },
1104 {"regmove", &flag_regmove, 1,
1105 N_("Enables a register move optimization") },
1106 {"optimize-register-move", &flag_regmove, 1,
1107 N_("Do the full regmove optimization pass") },
1108 {"pack-struct", &flag_pack_struct, 1,
1109 N_("Pack structure members together without holes") },
1110 {"stack-check", &flag_stack_check, 1,
1111 N_("Insert stack checking code into the program") },
1112 {"argument-alias", &flag_argument_noalias, 0,
1113 N_("Specify that arguments may alias each other & globals") },
1114 {"argument-noalias", &flag_argument_noalias, 1,
1115 N_("Assume arguments may alias globals but not each other") },
1116 {"argument-noalias-global", &flag_argument_noalias, 2,
1117 N_("Assume arguments do not alias each other or globals") },
1118 {"strict-aliasing", &flag_strict_aliasing, 1,
1119 N_("Assume strict aliasing rules apply") },
1120 {"align-loops", &align_loops, 0,
1121 N_("Align the start of loops") },
1122 {"align-jumps", &align_jumps, 0,
1123 N_("Align labels which are only reached by jumping") },
1124 {"align-labels", &align_labels, 0,
1125 N_("Align all labels") },
1126 {"align-functions", &align_functions, 0,
1127 N_("Align the start of functions") },
1128 {"merge-constants", &flag_merge_constants, 1,
1129 N_("Attempt to merge identical constants accross compilation units") },
1130 {"merge-all-constants", &flag_merge_constants, 2,
1131 N_("Attempt to merge identical constants and constant variables") },
1132 {"dump-unnumbered", &flag_dump_unnumbered, 1,
1133 N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
1134 {"instrument-functions", &flag_instrument_function_entry_exit, 1,
1135 N_("Instrument function entry/exit with profiling calls") },
1136 {"ssa", &flag_ssa, 1,
1137 N_("Enable SSA optimizations") },
1138 {"ssa-ccp", &flag_ssa_ccp, 1,
1139 N_("Enable SSA conditional constant propagation") },
1140 {"ssa-dce", &flag_ssa_dce, 1,
1141 N_("Enable aggressive SSA dead code elimination") },
1142 {"leading-underscore", &flag_leading_underscore, 1,
1143 N_("External symbols have a leading underscore") },
1144 {"ident", &flag_no_ident, 0,
1145 N_("Process #ident directives") },
1146 { "peephole2", &flag_peephole2, 1,
1147 N_("Enables an rtl peephole pass run before sched2") },
1148 { "guess-branch-probability", &flag_guess_branch_prob, 1,
1149 N_("Enables guessing of branch probabilities") },
1150 {"math-errno", &flag_errno_math, 1,
1151 N_("Set errno after built-in math functions") },
1152 {"trapping-math", &flag_trapping_math, 1,
1153 N_("Floating-point operations can trap") },
1154 {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
1155 N_("Allow math optimizations that may violate IEEE or ANSI standards") },
1156 {"bounded-pointers", &flag_bounded_pointers, 1,
1157 N_("Compile pointers as triples: value, base & end") },
1158 {"bounds-check", &flag_bounds_check, 1,
1159 N_("Generate code to check bounds before dereferencing pointers and arrays") },
1160 {"single-precision-constant", &flag_single_precision_constant, 1,
1161 N_("Convert floating point constant to single precision constant") },
1162 {"time-report", &time_report, 1,
1163 N_("Report time taken by each compiler pass at end of run") },
1164 {"mem-report", &mem_report, 1,
1165 N_("Report on permanent memory allocation at end of run") },
1166 { "trapv", &flag_trapv, 1,
1167 N_("Trap for signed overflow in addition / subtraction / multiplication") },
1170 /* Table of language-specific options. */
1172 static const struct lang_opt
1174 const char *const option;
1175 const char *const description;
1177 documented_lang_options[] =
1179 /* In order not to overload the --help output, the convention
1180 used here is to only describe those options which are not
1181 enabled by default. */
1183 { "-ansi",
1184 N_("Compile just for ISO C89") },
1185 { "-fallow-single-precision",
1186 N_("Do not promote floats to double if using -traditional") },
1187 { "-std= ",
1188 N_("Determine language standard") },
1190 { "-fsigned-bitfields", "" },
1191 { "-funsigned-bitfields",
1192 N_("Make bit-fields by unsigned by default") },
1193 { "-fno-signed-bitfields", "" },
1194 { "-fno-unsigned-bitfields","" },
1195 { "-fsigned-char",
1196 N_("Make 'char' be signed by default") },
1197 { "-funsigned-char",
1198 N_("Make 'char' be unsigned by default") },
1199 { "-fno-signed-char", "" },
1200 { "-fno-unsigned-char", "" },
1202 { "-ftraditional", "" },
1203 { "-traditional",
1204 N_("Attempt to support traditional K&R style C") },
1205 { "-fnotraditional", "" },
1206 { "-fno-traditional", "" },
1208 { "-fasm", "" },
1209 { "-fno-asm",
1210 N_("Do not recognize the 'asm' keyword") },
1211 { "-fbuiltin", "" },
1212 { "-fno-builtin",
1213 N_("Do not recognize any built in functions") },
1214 { "-fhosted",
1215 N_("Assume normal C execution environment") },
1216 { "-fno-hosted", "" },
1217 { "-ffreestanding",
1218 N_("Assume that standard libraries & main might not exist") },
1219 { "-fno-freestanding", "" },
1220 { "-fcond-mismatch",
1221 N_("Allow different types as args of ? operator") },
1222 { "-fno-cond-mismatch", "" },
1223 { "-fdollars-in-identifiers",
1224 N_("Allow the use of $ inside identifiers") },
1225 { "-fno-dollars-in-identifiers", "" },
1226 { "-fpreprocessed", "" },
1227 { "-fno-preprocessed", "" },
1228 { "-fshort-double",
1229 N_("Use the same size for double as for float") },
1230 { "-fno-short-double", "" },
1231 { "-fshort-enums",
1232 N_("Use the smallest fitting integer to hold enums") },
1233 { "-fno-short-enums", "" },
1234 { "-fshort-wchar",
1235 N_("Override the underlying type for wchar_t to `unsigned short'") },
1236 { "-fno-short-wchar", "" },
1238 { "-Wall",
1239 N_("Enable most warning messages") },
1240 { "-Wbad-function-cast",
1241 N_("Warn about casting functions to incompatible types") },
1242 { "-Wno-bad-function-cast", "" },
1243 { "-Wno-missing-noreturn", "" },
1244 { "-Wmissing-format-attribute",
1245 N_("Warn about functions which might be candidates for format attributes") },
1246 { "-Wno-missing-format-attribute", "" },
1247 { "-Wcast-qual",
1248 N_("Warn about casts which discard qualifiers") },
1249 { "-Wno-cast-qual", "" },
1250 { "-Wchar-subscripts",
1251 N_("Warn about subscripts whose type is 'char'") },
1252 { "-Wno-char-subscripts", "" },
1253 { "-Wcomment",
1254 N_("Warn if nested comments are detected") },
1255 { "-Wno-comment", "" },
1256 { "-Wcomments",
1257 N_("Warn if nested comments are detected") },
1258 { "-Wno-comments", "" },
1259 { "-Wconversion",
1260 N_("Warn about possibly confusing type conversions") },
1261 { "-Wno-conversion", "" },
1262 { "-Wformat",
1263 N_("Warn about printf/scanf/strftime/strfmon format anomalies") },
1264 { "-Wno-format", "" },
1265 { "-Wformat-y2k", "" },
1266 { "-Wno-format-y2k",
1267 N_("Don't warn about strftime formats yielding 2 digit years") },
1268 { "-Wformat-extra-args", "" },
1269 { "-Wno-format-extra-args",
1270 N_("Don't warn about too many arguments to format functions") },
1271 { "-Wformat-nonliteral",
1272 N_("Warn about non-string-literal format strings") },
1273 { "-Wno-format-nonliteral", "" },
1274 { "-Wformat-security",
1275 N_("Warn about possible security problems with format functions") },
1276 { "-Wno-format-security", "" },
1277 { "-Wimplicit-function-declaration",
1278 N_("Warn about implicit function declarations") },
1279 { "-Wno-implicit-function-declaration", "" },
1280 { "-Werror-implicit-function-declaration", "" },
1281 { "-Wimplicit-int",
1282 N_("Warn when a declaration does not specify a type") },
1283 { "-Wno-implicit-int", "" },
1284 { "-Wimplicit", "" },
1285 { "-Wno-implicit", "" },
1286 { "-Wimport",
1287 N_("Warn about the use of the #import directive") },
1288 { "-Wno-import", "" },
1289 { "-Wlong-long","" },
1290 { "-Wno-long-long",
1291 N_("Do not warn about using 'long long' when -pedantic") },
1292 { "-Wmain",
1293 N_("Warn about suspicious declarations of main") },
1294 { "-Wno-main", "" },
1295 { "-Wmissing-braces",
1296 N_("Warn about possibly missing braces around initializers") },
1297 { "-Wno-missing-braces", "" },
1298 { "-Wmissing-declarations",
1299 N_("Warn about global funcs without previous declarations") },
1300 { "-Wno-missing-declarations", "" },
1301 { "-Wmissing-prototypes",
1302 N_("Warn about global funcs without prototypes") },
1303 { "-Wno-missing-prototypes", "" },
1304 { "-Wmultichar",
1305 N_("Warn about use of multicharacter literals") },
1306 { "-Wno-multichar", "" },
1307 { "-Wnested-externs",
1308 N_("Warn about externs not at file scope level") },
1309 { "-Wno-nested-externs", "" },
1310 { "-Wparentheses",
1311 N_("Warn about possible missing parentheses") },
1312 { "-Wno-parentheses", "" },
1313 { "-Wsequence-point",
1314 N_("Warn about possible violations of sequence point rules") },
1315 { "-Wno-sequence-point", "" },
1316 { "-Wpointer-arith",
1317 N_("Warn about function pointer arithmetic") },
1318 { "-Wno-pointer-arith", "" },
1319 { "-Wredundant-decls",
1320 N_("Warn about multiple declarations of the same object") },
1321 { "-Wno-redundant-decls", "" },
1322 { "-Wsign-compare",
1323 N_("Warn about signed/unsigned comparisons") },
1324 { "-Wno-sign-compare", "" },
1325 { "-Wfloat-equal",
1326 N_("Warn about testing equality of floating point numbers") },
1327 { "-Wno-float-equal", "" },
1328 { "-Wunknown-pragmas",
1329 N_("Warn about unrecognized pragmas") },
1330 { "-Wno-unknown-pragmas", "" },
1331 { "-Wstrict-prototypes",
1332 N_("Warn about non-prototyped function decls") },
1333 { "-Wno-strict-prototypes", "" },
1334 { "-Wtraditional",
1335 N_("Warn about constructs whose meaning change in ISO C") },
1336 { "-Wno-traditional", "" },
1337 { "-Wtrigraphs",
1338 N_("Warn when trigraphs are encountered") },
1339 { "-Wno-trigraphs", "" },
1340 { "-Wundef", "" },
1341 { "-Wno-undef", "" },
1342 { "-Wwrite-strings",
1343 N_("Mark strings as 'const char *'") },
1344 { "-Wno-write-strings", "" },
1346 #define DEFINE_LANG_NAME(NAME) { NULL, NAME },
1348 #include "options.h"
1352 /* Here is a table, controlled by the tm.h file, listing each -m switch
1353 and which bits in `target_switches' it should set or clear.
1354 If VALUE is positive, it is bits to set.
1355 If VALUE is negative, -VALUE is bits to clear.
1356 (The sign bit is not used so there is no confusion.) */
1358 static const struct
1360 const char *const name;
1361 const int value;
1362 const char *const description;
1364 target_switches [] = TARGET_SWITCHES;
1366 /* This table is similar, but allows the switch to have a value. */
1368 #ifdef TARGET_OPTIONS
1369 static const struct
1371 const char *const prefix;
1372 const char **const variable;
1373 const char *const description;
1375 target_options [] = TARGET_OPTIONS;
1376 #endif
1378 /* Options controlling warnings. */
1380 /* Don't print warning messages. -w. */
1382 int inhibit_warnings = 0;
1384 /* Don't suppress warnings from system headers. -Wsystem-headers. */
1386 int warn_system_headers = 0;
1388 /* Print various extra warnings. -W. */
1390 int extra_warnings = 0;
1392 /* Treat warnings as errors. -Werror. */
1394 int warnings_are_errors = 0;
1396 /* Nonzero to warn about unused variables, functions et.al. */
1398 int warn_unused_function;
1399 int warn_unused_label;
1400 int warn_unused_parameter;
1401 int warn_unused_variable;
1402 int warn_unused_value;
1404 /* Nonzero to warn about code which is never reached. */
1406 int warn_notreached;
1408 /* Nonzero to warn about variables used before they are initialized. */
1410 int warn_uninitialized;
1412 /* Nonzero means warn about all declarations which shadow others. */
1414 int warn_shadow;
1416 /* Warn if a switch on an enum fails to have a case for every enum value. */
1418 int warn_switch;
1420 /* Nonzero means warn about function definitions that default the return type
1421 or that use a null return and have a return-type other than void. */
1423 int warn_return_type;
1425 /* Nonzero means warn about pointer casts that increase the required
1426 alignment of the target type (and might therefore lead to a crash
1427 due to a misaligned access). */
1429 int warn_cast_align;
1431 /* Nonzero means warn about any objects definitions whose size is larger
1432 than N bytes. Also want about function definitions whose returned
1433 values are larger than N bytes. The value N is in `larger_than_size'. */
1435 int warn_larger_than;
1436 HOST_WIDE_INT larger_than_size;
1438 /* Nonzero means warn if inline function is too large. */
1440 int warn_inline;
1442 /* Warn if a function returns an aggregate,
1443 since there are often incompatible calling conventions for doing this. */
1445 int warn_aggregate_return;
1447 /* Warn if packed attribute on struct is unnecessary and inefficient. */
1449 int warn_packed;
1451 /* Warn when gcc pads a structure to an alignment boundary. */
1453 int warn_padded;
1455 /* Warn when an optimization pass is disabled. */
1457 int warn_disabled_optimization;
1459 /* Warn about functions which might be candidates for attribute noreturn. */
1461 int warn_missing_noreturn;
1463 /* Nonzero means warn about uses of __attribute__((deprecated))
1464 declarations. */
1466 int warn_deprecated_decl = 1;
1468 /* Likewise for -W. */
1470 static const lang_independent_options W_options[] =
1472 {"unused-function", &warn_unused_function, 1,
1473 N_("Warn when a function is unused") },
1474 {"unused-label", &warn_unused_label, 1,
1475 N_("Warn when a label is unused") },
1476 {"unused-parameter", &warn_unused_parameter, 1,
1477 N_("Warn when a function parameter is unused") },
1478 {"unused-variable", &warn_unused_variable, 1,
1479 N_("Warn when a variable is unused") },
1480 {"unused-value", &warn_unused_value, 1,
1481 N_("Warn when an expression value is unused") },
1482 {"system-headers", &warn_system_headers, 1,
1483 N_("Do not suppress warnings from system headers") },
1484 {"error", &warnings_are_errors, 1,
1485 N_("Treat all warnings as errors") },
1486 {"shadow", &warn_shadow, 1,
1487 N_("Warn when one local variable shadows another") },
1488 {"switch", &warn_switch, 1,
1489 N_("Warn about enumerated switches missing a specific case") },
1490 {"aggregate-return", &warn_aggregate_return, 1,
1491 N_("Warn about returning structures, unions or arrays") },
1492 {"cast-align", &warn_cast_align, 1,
1493 N_("Warn about pointer casts which increase alignment") },
1494 {"unreachable-code", &warn_notreached, 1,
1495 N_("Warn about code that will never be executed") },
1496 {"uninitialized", &warn_uninitialized, 1,
1497 N_("Warn about uninitialized automatic variables") },
1498 {"inline", &warn_inline, 1,
1499 N_("Warn when an inlined function cannot be inlined") },
1500 {"packed", &warn_packed, 1,
1501 N_("Warn when the packed attribute has no effect on struct layout") },
1502 {"padded", &warn_padded, 1,
1503 N_("Warn when padding is required to align struct members") },
1504 {"disabled-optimization", &warn_disabled_optimization, 1,
1505 N_("Warn when an optimization pass is disabled") },
1506 {"deprecated-declarations", &warn_deprecated_decl, 1,
1507 N_("Warn about uses of __attribute__((deprecated)) declarations") },
1508 {"missing-noreturn", &warn_missing_noreturn, 1,
1509 N_("Warn about functions which might be candidates for attribute noreturn") }
1512 void
1513 set_Wunused (setting)
1514 int setting;
1516 warn_unused_function = setting;
1517 warn_unused_label = setting;
1518 /* Unused function parameter warnings are reported when either ``-W
1519 -Wunused'' or ``-Wunused-parameter'' is specified. Differentiate
1520 -Wunused by setting WARN_UNUSED_PARAMETER to -1. */
1521 if (!setting)
1522 warn_unused_parameter = 0;
1523 else if (!warn_unused_parameter)
1524 warn_unused_parameter = -1;
1525 warn_unused_variable = setting;
1526 warn_unused_value = setting;
1529 /* The following routines are useful in setting all the flags that
1530 -ffast-math and -fno-fast-math imply. */
1532 void
1533 set_fast_math_flags ()
1535 flag_trapping_math = 0;
1536 flag_unsafe_math_optimizations = 1;
1537 flag_errno_math = 0;
1540 void
1541 set_no_fast_math_flags ()
1543 flag_trapping_math = 1;
1544 flag_unsafe_math_optimizations = 0;
1545 flag_errno_math = 1;
1549 /* Output files for assembler code (real compiler output)
1550 and debugging dumps. */
1552 FILE *asm_out_file;
1553 FILE *aux_info_file;
1554 FILE *rtl_dump_file = NULL;
1556 /* Decode the string P as an integral parameter.
1557 If the string is indeed an integer return its numeric value else
1558 issue an Invalid Option error for the option PNAME and return DEFVAL.
1559 If PNAME is zero just return DEFVAL, do not call error. */
1562 read_integral_parameter (p, pname, defval)
1563 const char *p;
1564 const char *pname;
1565 const int defval;
1567 const char *endp = p;
1569 while (*endp)
1571 if (ISDIGIT (*endp))
1572 endp++;
1573 else
1574 break;
1577 if (*endp != 0)
1579 if (pname != 0)
1580 error ("invalid option `%s'", pname);
1581 return defval;
1584 return atoi (p);
1588 /* This is the default decl_printable_name function. */
1590 static const char *
1591 decl_name (decl, verbosity)
1592 tree decl;
1593 int verbosity ATTRIBUTE_UNUSED;
1595 return IDENTIFIER_POINTER (DECL_NAME (decl));
1599 /* This calls abort and is used to avoid problems when abort if a macro.
1600 It is used when we need to pass the address of abort. */
1602 void
1603 do_abort ()
1605 abort ();
1608 /* When `malloc.c' is compiled with `rcheck' defined,
1609 it calls this function to report clobberage. */
1611 void
1612 botch (s)
1613 const char *s ATTRIBUTE_UNUSED;
1615 abort ();
1618 /* Return the logarithm of X, base 2, considering X unsigned,
1619 if X is a power of 2. Otherwise, returns -1.
1621 This should be used via the `exact_log2' macro. */
1624 exact_log2_wide (x)
1625 unsigned HOST_WIDE_INT x;
1627 int log = 0;
1628 /* Test for 0 or a power of 2. */
1629 if (x == 0 || x != (x & -x))
1630 return -1;
1631 while ((x >>= 1) != 0)
1632 log++;
1633 return log;
1636 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1637 If X is 0, return -1.
1639 This should be used via the floor_log2 macro. */
1642 floor_log2_wide (x)
1643 unsigned HOST_WIDE_INT x;
1645 int log = -1;
1646 while (x != 0)
1647 log++,
1648 x >>= 1;
1649 return log;
1652 static int float_handler_set;
1653 int float_handled;
1654 jmp_buf float_handler;
1656 /* Signals actually come here. */
1658 static void
1659 float_signal (signo)
1660 /* If this is missing, some compilers complain. */
1661 int signo ATTRIBUTE_UNUSED;
1663 if (float_handled == 0)
1664 crash_signal (signo);
1665 float_handled = 0;
1667 /* On System-V derived systems, we must reinstall the signal handler.
1668 This is harmless on BSD-derived systems. */
1669 signal (SIGFPE, float_signal);
1670 longjmp (float_handler, 1);
1673 /* Specify where to longjmp to when a floating arithmetic error happens.
1674 If HANDLER is 0, it means don't handle the errors any more. */
1676 static void
1677 set_float_handler (handler)
1678 jmp_buf handler;
1680 float_handled = (handler != 0);
1681 if (handler)
1682 memcpy (float_handler, handler, sizeof (float_handler));
1684 if (float_handled && ! float_handler_set)
1686 signal (SIGFPE, float_signal);
1687 float_handler_set = 1;
1691 /* This is a wrapper function for code which might elicit an
1692 arithmetic exception. That code should be passed in as a function
1693 pointer FN, and one argument DATA. DATA is usually a struct which
1694 contains the real input and output for function FN. This function
1695 returns 0 (failure) if longjmp was called (i.e. an exception
1696 occurred.) It returns 1 (success) otherwise. */
1699 do_float_handler (fn, data)
1700 void (*fn) PARAMS ((PTR));
1701 PTR data;
1703 jmp_buf buf;
1705 if (setjmp (buf))
1707 /* We got here via longjmp () caused by an exception in function
1708 fn (). */
1709 set_float_handler (NULL);
1710 return 0;
1713 set_float_handler (buf);
1714 (*fn)(data);
1715 set_float_handler (NULL);
1716 return 1;
1719 /* Handler for fatal signals, such as SIGSEGV. These are transformed
1720 into ICE messages, which is much more user friendly. */
1722 static void
1723 crash_signal (signo)
1724 int signo;
1726 internal_error ("internal error: %s", strsignal (signo));
1729 /* Strip off a legitimate source ending from the input string NAME of
1730 length LEN. Rather than having to know the names used by all of
1731 our front ends, we strip off an ending of a period followed by
1732 up to five characters. (Java uses ".class".) */
1734 void
1735 strip_off_ending (name, len)
1736 char *name;
1737 int len;
1739 int i;
1740 for (i = 2; i < 6 && len > i; i++)
1742 if (name[len - i] == '.')
1744 name[len - i] = '\0';
1745 break;
1750 /* Output a quoted string. */
1752 void
1753 output_quoted_string (asm_file, string)
1754 FILE *asm_file;
1755 const char *string;
1757 #ifdef OUTPUT_QUOTED_STRING
1758 OUTPUT_QUOTED_STRING (asm_file, string);
1759 #else
1760 char c;
1762 putc ('\"', asm_file);
1763 while ((c = *string++) != 0)
1765 if (c == '\"' || c == '\\')
1766 putc ('\\', asm_file);
1767 putc (c, asm_file);
1769 putc ('\"', asm_file);
1770 #endif
1773 /* Output a file name in the form wanted by System V. */
1775 void
1776 output_file_directive (asm_file, input_name)
1777 FILE *asm_file;
1778 const char *input_name;
1780 int len = strlen (input_name);
1781 const char *na = input_name + len;
1783 /* NA gets INPUT_NAME sans directory names. */
1784 while (na > input_name)
1786 if (IS_DIR_SEPARATOR (na[-1]))
1787 break;
1788 na--;
1791 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
1792 ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
1793 #else
1794 #ifdef ASM_OUTPUT_SOURCE_FILENAME
1795 ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
1796 #else
1797 fprintf (asm_file, "\t.file\t");
1798 output_quoted_string (asm_file, na);
1799 fputc ('\n', asm_file);
1800 #endif
1801 #endif
1804 /* Routine to open a dump file. Return true if the dump file is enabled. */
1806 static int
1807 open_dump_file (index, decl)
1808 enum dump_file_index index;
1809 tree decl;
1811 char *dump_name;
1812 const char *open_arg;
1813 char seq[16];
1815 if (! dump_file[index].enabled)
1816 return 0;
1818 timevar_push (TV_DUMP);
1819 if (rtl_dump_file != NULL)
1820 fclose (rtl_dump_file);
1822 sprintf (seq, DUMPFILE_FORMAT, index);
1824 if (! dump_file[index].initialized)
1826 /* If we've not initialized the files, do so now. */
1827 if (graph_dump_format != no_graph
1828 && dump_file[index].graph_dump_p)
1830 dump_name = concat (seq, dump_file[index].extension, NULL);
1831 clean_graph_dump_file (dump_base_name, dump_name);
1832 free (dump_name);
1834 dump_file[index].initialized = 1;
1835 open_arg = "w";
1837 else
1838 open_arg = "a";
1840 dump_name = concat (dump_base_name, seq,
1841 dump_file[index].extension, NULL);
1843 rtl_dump_file = fopen (dump_name, open_arg);
1844 if (rtl_dump_file == NULL)
1845 fatal_io_error ("can't open %s", dump_name);
1847 free (dump_name);
1849 if (decl)
1850 fprintf (rtl_dump_file, "\n;; Function %s\n\n",
1851 decl_printable_name (decl, 2));
1853 timevar_pop (TV_DUMP);
1854 return 1;
1857 /* Routine to close a dump file. */
1859 static void
1860 close_dump_file (index, func, insns)
1861 enum dump_file_index index;
1862 void (*func) PARAMS ((FILE *, rtx));
1863 rtx insns;
1865 if (! rtl_dump_file)
1866 return;
1868 timevar_push (TV_DUMP);
1869 if (insns
1870 && graph_dump_format != no_graph
1871 && dump_file[index].graph_dump_p)
1873 char seq[16];
1874 char *suffix;
1876 sprintf (seq, DUMPFILE_FORMAT, index);
1877 suffix = concat (seq, dump_file[index].extension, NULL);
1878 print_rtl_graph_with_bb (dump_base_name, suffix, insns);
1879 free (suffix);
1882 if (func && insns)
1883 func (rtl_dump_file, insns);
1885 fflush (rtl_dump_file);
1886 fclose (rtl_dump_file);
1888 rtl_dump_file = NULL;
1889 timevar_pop (TV_DUMP);
1892 /* Do any final processing required for the declarations in VEC, of
1893 which there are LEN. We write out inline functions and variables
1894 that have been deferred until this point, but which are required.
1895 Returns non-zero if anything was put out. */
1898 wrapup_global_declarations (vec, len)
1899 tree *vec;
1900 int len;
1902 tree decl;
1903 int i;
1904 int reconsider;
1905 int output_something = 0;
1907 for (i = 0; i < len; i++)
1909 decl = vec[i];
1911 /* We're not deferring this any longer. */
1912 DECL_DEFER_OUTPUT (decl) = 0;
1914 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0
1915 && incomplete_decl_finalize_hook != 0)
1916 (*incomplete_decl_finalize_hook) (decl);
1919 /* Now emit any global variables or functions that we have been
1920 putting off. We need to loop in case one of the things emitted
1921 here references another one which comes earlier in the list. */
1924 reconsider = 0;
1925 for (i = 0; i < len; i++)
1927 decl = vec[i];
1929 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
1930 continue;
1932 /* Don't write out static consts, unless we still need them.
1934 We also keep static consts if not optimizing (for debugging),
1935 unless the user specified -fno-keep-static-consts.
1936 ??? They might be better written into the debug information.
1937 This is possible when using DWARF.
1939 A language processor that wants static constants to be always
1940 written out (even if it is not used) is responsible for
1941 calling rest_of_decl_compilation itself. E.g. the C front-end
1942 calls rest_of_decl_compilation from finish_decl.
1943 One motivation for this is that is conventional in some
1944 environments to write things like:
1945 static const char rcsid[] = "... version string ...";
1946 intending to force the string to be in the executable.
1948 A language processor that would prefer to have unneeded
1949 static constants "optimized away" would just defer writing
1950 them out until here. E.g. C++ does this, because static
1951 constants are often defined in header files.
1953 ??? A tempting alternative (for both C and C++) would be
1954 to force a constant to be written if and only if it is
1955 defined in a main file, as opposed to an include file. */
1957 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
1958 && (((! TREE_READONLY (decl) || TREE_PUBLIC (decl))
1959 && !DECL_COMDAT (decl))
1960 || (!optimize
1961 && flag_keep_static_consts
1962 && !DECL_ARTIFICIAL (decl))
1963 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1965 reconsider = 1;
1966 rest_of_decl_compilation (decl, NULL, 1, 1);
1969 if (TREE_CODE (decl) == FUNCTION_DECL
1970 && DECL_INITIAL (decl) != 0
1971 && DECL_SAVED_INSNS (decl) != 0
1972 && (flag_keep_inline_functions
1973 || (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1974 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1976 reconsider = 1;
1977 output_inline_function (decl);
1981 if (reconsider)
1982 output_something = 1;
1984 while (reconsider);
1986 return output_something;
1989 /* Issue appropriate warnings for the global declarations in VEC (of
1990 which there are LEN). Output debugging information for them. */
1992 void
1993 check_global_declarations (vec, len)
1994 tree *vec;
1995 int len;
1997 tree decl;
1998 int i;
2000 for (i = 0; i < len; i++)
2002 decl = vec[i];
2004 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
2005 && ! TREE_ASM_WRITTEN (decl))
2006 /* Cancel the RTL for this decl so that, if debugging info
2007 output for global variables is still to come,
2008 this one will be omitted. */
2009 SET_DECL_RTL (decl, NULL_RTX);
2011 /* Warn about any function
2012 declared static but not defined.
2013 We don't warn about variables,
2014 because many programs have static variables
2015 that exist only to get some text into the object file. */
2016 if (TREE_CODE (decl) == FUNCTION_DECL
2017 && (warn_unused_function
2018 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2019 && DECL_INITIAL (decl) == 0
2020 && DECL_EXTERNAL (decl)
2021 && ! DECL_ARTIFICIAL (decl)
2022 && ! TREE_PUBLIC (decl))
2024 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2025 pedwarn_with_decl (decl,
2026 "`%s' used but never defined");
2027 else
2028 warning_with_decl (decl,
2029 "`%s' declared `static' but never defined");
2030 /* This symbol is effectively an "extern" declaration now. */
2031 TREE_PUBLIC (decl) = 1;
2032 assemble_external (decl);
2035 /* Warn about static fns or vars defined but not used,
2036 but not about inline functions or static consts
2037 since defining those in header files is normal practice. */
2038 if (((warn_unused_function
2039 && TREE_CODE (decl) == FUNCTION_DECL && ! DECL_INLINE (decl))
2040 || (warn_unused_variable
2041 && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
2042 && ! DECL_IN_SYSTEM_HEADER (decl)
2043 && ! DECL_EXTERNAL (decl)
2044 && ! TREE_PUBLIC (decl)
2045 && ! TREE_USED (decl)
2046 && (TREE_CODE (decl) == FUNCTION_DECL || ! DECL_REGISTER (decl))
2047 /* The TREE_USED bit for file-scope decls
2048 is kept in the identifier, to handle multiple
2049 external decls in different scopes. */
2050 && ! TREE_USED (DECL_NAME (decl)))
2051 warning_with_decl (decl, "`%s' defined but not used");
2053 timevar_push (TV_SYMOUT);
2054 (*debug_hooks->global_decl) (decl);
2055 timevar_pop (TV_SYMOUT);
2059 /* Save the current INPUT_FILENAME and LINENO on the top entry in the
2060 INPUT_FILE_STACK. Push a new entry for FILE and LINE, and set the
2061 INPUT_FILENAME and LINENO accordingly. */
2063 void
2064 push_srcloc (file, line)
2065 const char *file;
2066 int line;
2068 struct file_stack *fs;
2070 if (input_file_stack)
2072 input_file_stack->name = input_filename;
2073 input_file_stack->line = lineno;
2076 fs = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2077 fs->name = input_filename = file;
2078 fs->line = lineno = line;
2079 fs->indent_level = 0;
2080 fs->next = input_file_stack;
2081 input_file_stack = fs;
2082 input_file_stack_tick++;
2085 /* Pop the top entry off the stack of presently open source files.
2086 Restore the INPUT_FILENAME and LINENO from the new topmost entry on
2087 the stack. */
2089 void
2090 pop_srcloc ()
2092 struct file_stack *fs;
2094 fs = input_file_stack;
2095 input_file_stack = fs->next;
2096 free (fs);
2097 input_file_stack_tick++;
2098 /* The initial source file is never popped. */
2099 if (!input_file_stack)
2100 abort ();
2101 input_filename = input_file_stack->name;
2102 lineno = input_file_stack->line;
2105 /* Compile an entire translation unit. Write a file of assembly
2106 output and various debugging dumps. */
2108 static void
2109 compile_file ()
2111 tree globals;
2113 /* Initialize yet another pass. */
2115 init_final (main_input_filename);
2116 init_branch_prob (dump_base_name);
2118 timevar_push (TV_PARSE);
2120 /* Call the parser, which parses the entire file
2121 (calling rest_of_compilation for each function). */
2122 yyparse ();
2124 /* In case there were missing block closers,
2125 get us back to the global binding level. */
2126 (*lang_hooks.clear_binding_stack) ();
2128 /* Compilation is now finished except for writing
2129 what's left of the symbol table output. */
2131 timevar_pop (TV_PARSE);
2133 if (flag_syntax_only)
2134 return;
2136 globals = getdecls ();
2138 /* Really define vars that have had only a tentative definition.
2139 Really output inline functions that must actually be callable
2140 and have not been output so far. */
2143 int len = list_length (globals);
2144 tree *vec = (tree *) xmalloc (sizeof (tree) * len);
2145 int i;
2146 tree decl;
2148 /* Process the decls in reverse order--earliest first.
2149 Put them into VEC from back to front, then take out from front. */
2151 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
2152 vec[len - i - 1] = decl;
2154 wrapup_global_declarations (vec, len);
2156 /* This must occur after the loop to output deferred functions. Else
2157 the profiler initializer would not be emitted if all the functions
2158 in this compilation unit were deferred.
2160 output_func_start_profiler can not cause any additional functions or
2161 data to need to be output, so it need not be in the deferred function
2162 loop above. */
2163 output_func_start_profiler ();
2165 check_global_declarations (vec, len);
2167 /* Clean up. */
2168 free (vec);
2171 /* Write out any pending weak symbol declarations. */
2173 weak_finish ();
2175 /* Do dbx symbols. */
2176 timevar_push (TV_SYMOUT);
2178 #ifdef DWARF2_UNWIND_INFO
2179 if (dwarf2out_do_frame ())
2180 dwarf2out_frame_finish ();
2181 #endif
2183 (*debug_hooks->finish) (main_input_filename);
2184 timevar_pop (TV_SYMOUT);
2186 /* Output some stuff at end of file if nec. */
2188 dw2_output_indirect_constants ();
2190 end_final (dump_base_name);
2192 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
2194 timevar_push (TV_DUMP);
2195 open_dump_file (DFI_bp, NULL);
2197 end_branch_prob ();
2199 close_dump_file (DFI_bp, NULL, NULL_RTX);
2200 timevar_pop (TV_DUMP);
2203 #ifdef ASM_FILE_END
2204 ASM_FILE_END (asm_out_file);
2205 #endif
2207 /* Attach a special .ident directive to the end of the file to identify
2208 the version of GCC which compiled this code. The format of the .ident
2209 string is patterned after the ones produced by native SVR4 compilers. */
2210 #ifdef IDENT_ASM_OP
2211 if (!flag_no_ident)
2212 fprintf (asm_out_file, "%s\"GCC: (GNU) %s\"\n",
2213 IDENT_ASM_OP, version_string);
2214 #endif
2216 if (optimize > 0 && open_dump_file (DFI_combine, NULL))
2218 timevar_push (TV_DUMP);
2219 dump_combine_total_stats (rtl_dump_file);
2220 close_dump_file (DFI_combine, NULL, NULL_RTX);
2221 timevar_pop (TV_DUMP);
2225 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2226 and TYPE_DECL nodes.
2228 This does nothing for local (non-static) variables, unless the
2229 variable is a register variable with an ASMSPEC. In that case, or
2230 if the variable is not an automatic, it sets up the RTL and
2231 outputs any assembler code (label definition, storage allocation
2232 and initialization).
2234 DECL is the declaration. If ASMSPEC is nonzero, it specifies
2235 the assembler symbol name to be used. TOP_LEVEL is nonzero
2236 if this declaration is not within a function. */
2238 void
2239 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2240 tree decl;
2241 const char *asmspec;
2242 int top_level;
2243 int at_end;
2245 /* Declarations of variables, and of functions defined elsewhere. */
2247 /* The most obvious approach, to put an #ifndef around where
2248 this macro is used, doesn't work since it's inside a macro call. */
2249 #ifndef ASM_FINISH_DECLARE_OBJECT
2250 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END)
2251 #endif
2253 /* Forward declarations for nested functions are not "external",
2254 but we need to treat them as if they were. */
2255 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
2256 || TREE_CODE (decl) == FUNCTION_DECL)
2258 timevar_push (TV_VARCONST);
2259 if (asmspec)
2260 make_decl_rtl (decl, asmspec);
2261 /* Don't output anything
2262 when a tentative file-scope definition is seen.
2263 But at end of compilation, do output code for them. */
2264 if (at_end || !DECL_DEFER_OUTPUT (decl))
2265 assemble_variable (decl, top_level, at_end, 0);
2266 if (decl == last_assemble_variable_decl)
2268 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
2269 top_level, at_end);
2271 timevar_pop (TV_VARCONST);
2273 else if (DECL_REGISTER (decl) && asmspec != 0)
2275 if (decode_reg_name (asmspec) >= 0)
2277 SET_DECL_RTL (decl, NULL_RTX);
2278 make_decl_rtl (decl, asmspec);
2280 else
2282 error ("invalid register name `%s' for register variable", asmspec);
2283 DECL_REGISTER (decl) = 0;
2284 if (!top_level)
2285 expand_decl (decl);
2288 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2289 else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2290 && TREE_CODE (decl) == TYPE_DECL)
2292 timevar_push (TV_SYMOUT);
2293 dbxout_symbol (decl, 0);
2294 timevar_pop (TV_SYMOUT);
2296 #endif
2297 #ifdef SDB_DEBUGGING_INFO
2298 else if (write_symbols == SDB_DEBUG && top_level
2299 && TREE_CODE (decl) == TYPE_DECL)
2301 timevar_push (TV_SYMOUT);
2302 sdbout_symbol (decl, 0);
2303 timevar_pop (TV_SYMOUT);
2305 #endif
2308 /* Called after finishing a record, union or enumeral type. */
2310 void
2311 rest_of_type_compilation (type, toplev)
2312 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO) || defined (SDB_DEBUGGING_INFO)
2313 tree type;
2314 int toplev;
2315 #else
2316 tree type ATTRIBUTE_UNUSED;
2317 int toplev ATTRIBUTE_UNUSED;
2318 #endif
2320 timevar_push (TV_SYMOUT);
2321 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2322 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2323 dbxout_symbol (TYPE_STUB_DECL (type), !toplev);
2324 #endif
2325 #ifdef SDB_DEBUGGING_INFO
2326 if (write_symbols == SDB_DEBUG)
2327 sdbout_symbol (TYPE_STUB_DECL (type), !toplev);
2328 #endif
2329 #ifdef DWARF2_DEBUGGING_INFO
2330 if ((write_symbols == DWARF2_DEBUG
2331 || write_symbols == VMS_AND_DWARF2_DEBUG)
2332 && toplev)
2333 dwarf2out_decl (TYPE_STUB_DECL (type));
2334 #endif
2335 timevar_pop (TV_SYMOUT);
2338 /* This is called from finish_function (within yyparse)
2339 after each top-level definition is parsed.
2340 It is supposed to compile that function or variable
2341 and output the assembler code for it.
2342 After we return, the tree storage is freed. */
2344 void
2345 rest_of_compilation (decl)
2346 tree decl;
2348 rtx insns;
2349 int tem;
2350 int failure = 0;
2351 int rebuild_label_notes_after_reload;
2352 int register_life_up_to_date;
2354 timevar_push (TV_REST_OF_COMPILATION);
2356 /* Now that we're out of the frontend, we shouldn't have any more
2357 CONCATs anywhere. */
2358 generating_concat_p = 0;
2360 /* When processing delayed functions, prepare_function_start() won't
2361 have been run to re-initialize it. */
2362 cse_not_expected = ! optimize;
2364 /* First, make sure that NOTE_BLOCK is set correctly for each
2365 NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */
2366 if (!cfun->x_whole_function_mode_p)
2367 identify_blocks ();
2369 /* In function-at-a-time mode, we do not attempt to keep the BLOCK
2370 tree in sensible shape. So, we just recalculate it here. */
2371 if (cfun->x_whole_function_mode_p)
2372 reorder_blocks ();
2374 init_flow ();
2376 /* If we are reconsidering an inline function
2377 at the end of compilation, skip the stuff for making it inline. */
2379 if (DECL_SAVED_INSNS (decl) == 0)
2381 int inlinable = 0;
2382 tree parent;
2383 const char *lose;
2385 /* If this is nested inside an inlined external function, pretend
2386 it was only declared. Since we cannot inline such functions,
2387 generating code for this one is not only not necessary but will
2388 confuse some debugging output writers. */
2389 for (parent = DECL_CONTEXT (current_function_decl);
2390 parent != NULL_TREE;
2391 parent = get_containing_scope (parent))
2392 if (TREE_CODE (parent) == FUNCTION_DECL
2393 && DECL_INLINE (parent) && DECL_EXTERNAL (parent))
2395 DECL_INITIAL (decl) = 0;
2396 goto exit_rest_of_compilation;
2399 /* If requested, consider whether to make this function inline. */
2400 if ((DECL_INLINE (decl) && !flag_no_inline)
2401 || flag_inline_functions)
2403 timevar_push (TV_INTEGRATION);
2404 lose = function_cannot_inline_p (decl);
2405 timevar_pop (TV_INTEGRATION);
2406 if (lose || ! optimize)
2408 if (warn_inline && DECL_INLINE (decl))
2409 warning_with_decl (decl, lose);
2410 DECL_ABSTRACT_ORIGIN (decl) = 0;
2411 /* Don't really compile an extern inline function.
2412 If we can't make it inline, pretend
2413 it was only declared. */
2414 if (DECL_EXTERNAL (decl))
2416 DECL_INITIAL (decl) = 0;
2417 goto exit_rest_of_compilation;
2420 else
2421 /* ??? Note that this has the effect of making it look
2422 like "inline" was specified for a function if we choose
2423 to inline it. This isn't quite right, but it's
2424 probably not worth the trouble to fix. */
2425 inlinable = DECL_INLINE (decl) = 1;
2428 insns = get_insns ();
2430 /* Dump the rtl code if we are dumping rtl. */
2432 if (open_dump_file (DFI_rtl, decl))
2434 if (DECL_SAVED_INSNS (decl))
2435 fprintf (rtl_dump_file, ";; (integrable)\n\n");
2436 close_dump_file (DFI_rtl, print_rtl, insns);
2439 /* Convert from NOTE_INSN_EH_REGION style notes, and do other
2440 sorts of eh initialization. Delay this until after the
2441 initial rtl dump so that we can see the original nesting. */
2442 convert_from_eh_region_ranges ();
2444 /* If function is inline, and we don't yet know whether to
2445 compile it by itself, defer decision till end of compilation.
2446 finish_compilation will call rest_of_compilation again
2447 for those functions that need to be output. Also defer those
2448 functions that we are supposed to defer. */
2450 if (inlinable
2451 || (DECL_INLINE (decl)
2452 && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2453 && ! flag_keep_inline_functions)
2454 || DECL_EXTERNAL (decl))))
2455 DECL_DEFER_OUTPUT (decl) = 1;
2457 if (DECL_INLINE (decl))
2458 /* DWARF wants separate debugging info for abstract and
2459 concrete instances of all inline functions, including those
2460 declared inline but not inlined, and those inlined even
2461 though they weren't declared inline. Conveniently, that's
2462 what DECL_INLINE means at this point. */
2463 (*debug_hooks->deferred_inline_function) (decl);
2465 if (DECL_DEFER_OUTPUT (decl))
2467 /* If -Wreturn-type, we have to do a bit of compilation. We just
2468 want to call cleanup the cfg to figure out whether or not we can
2469 fall off the end of the function; we do the minimum amount of
2470 work necessary to make that safe. */
2471 if (warn_return_type)
2473 int saved_optimize = optimize;
2475 optimize = 0;
2476 rebuild_jump_labels (insns);
2477 find_exception_handler_labels ();
2478 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2479 cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
2480 optimize = saved_optimize;
2482 /* CFG is no longer maintained up-to-date. */
2483 free_bb_for_insn ();
2486 current_function_nothrow = nothrow_function_p ();
2487 if (current_function_nothrow)
2488 /* Now we know that this can't throw; set the flag for the benefit
2489 of other functions later in this translation unit. */
2490 TREE_NOTHROW (current_function_decl) = 1;
2492 timevar_push (TV_INTEGRATION);
2493 save_for_inline (decl);
2494 timevar_pop (TV_INTEGRATION);
2495 DECL_SAVED_INSNS (decl)->inlinable = inlinable;
2496 goto exit_rest_of_compilation;
2499 /* If specified extern inline but we aren't inlining it, we are
2500 done. This goes for anything that gets here with DECL_EXTERNAL
2501 set, not just things with DECL_INLINE. */
2502 if (DECL_EXTERNAL (decl))
2503 goto exit_rest_of_compilation;
2506 /* If we're emitting a nested function, make sure its parent gets
2507 emitted as well. Doing otherwise confuses debug info. */
2509 tree parent;
2510 for (parent = DECL_CONTEXT (current_function_decl);
2511 parent != NULL_TREE;
2512 parent = get_containing_scope (parent))
2513 if (TREE_CODE (parent) == FUNCTION_DECL)
2514 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
2517 /* We are now committed to emitting code for this function. Do any
2518 preparation, such as emitting abstract debug info for the inline
2519 before it gets mangled by optimization. */
2520 if (DECL_INLINE (decl))
2521 (*debug_hooks->outlining_inline_function) (decl);
2523 /* Remove any notes we don't need. That will make iterating
2524 over the instruction sequence faster, and allow the garbage
2525 collector to reclaim the memory used by the notes. */
2526 remove_unnecessary_notes ();
2527 reorder_blocks ();
2529 ggc_collect ();
2531 /* Initialize some variables used by the optimizers. */
2532 init_function_for_compilation ();
2534 if (! DECL_DEFER_OUTPUT (decl))
2535 TREE_ASM_WRITTEN (decl) = 1;
2537 /* Now that integrate will no longer see our rtl, we need not
2538 distinguish between the return value of this function and the
2539 return value of called functions. Also, we can remove all SETs
2540 of subregs of hard registers; they are only here because of
2541 integrate. Also, we can now initialize pseudos intended to
2542 carry magic hard reg data throughout the function. */
2543 rtx_equal_function_value_matters = 0;
2544 purge_hard_subreg_sets (get_insns ());
2545 emit_initial_value_sets ();
2547 /* Don't return yet if -Wreturn-type; we need to do cleanup_cfg. */
2548 if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
2549 goto exit_rest_of_compilation;
2551 /* We may have potential sibling or tail recursion sites. Select one
2552 (of possibly multiple) methods of performing the call. */
2553 if (flag_optimize_sibling_calls)
2555 timevar_push (TV_JUMP);
2556 open_dump_file (DFI_sibling, decl);
2558 optimize_sibling_and_tail_recursive_calls ();
2560 close_dump_file (DFI_sibling, print_rtl, get_insns ());
2561 timevar_pop (TV_JUMP);
2564 /* Complete generation of exception handling code. */
2565 find_exception_handler_labels ();
2566 if (doing_eh (0))
2568 timevar_push (TV_JUMP);
2569 open_dump_file (DFI_eh, decl);
2571 finish_eh_generation ();
2573 close_dump_file (DFI_eh, print_rtl, get_insns ());
2574 timevar_pop (TV_JUMP);
2577 #ifdef FINALIZE_PIC
2578 /* If we are doing position-independent code generation, now
2579 is the time to output special prologues and epilogues.
2580 We do not want to do this earlier, because it just clutters
2581 up inline functions with meaningless insns. */
2582 if (flag_pic)
2583 FINALIZE_PIC;
2584 #endif
2586 insns = get_insns ();
2588 /* Copy any shared structure that should not be shared. */
2589 unshare_all_rtl (current_function_decl, insns);
2591 #ifdef SETJMP_VIA_SAVE_AREA
2592 /* This must be performed before virtual register instantiation. */
2593 if (current_function_calls_alloca)
2594 optimize_save_area_alloca (insns);
2595 #endif
2597 /* Instantiate all virtual registers. */
2598 instantiate_virtual_regs (current_function_decl, insns);
2600 open_dump_file (DFI_jump, decl);
2602 /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
2603 are initialized and to compute whether control can drop off the end
2604 of the function. */
2606 timevar_push (TV_JUMP);
2607 /* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
2608 before jump optimization switches branch directions. */
2609 expected_value_to_br_prob ();
2611 reg_scan (insns, max_reg_num (), 0);
2612 rebuild_jump_labels (insns);
2613 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2614 cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP);
2616 /* CFG is no longer maintained up-to-date. */
2617 free_bb_for_insn ();
2618 copy_loop_headers (insns);
2619 purge_line_number_notes (insns);
2621 timevar_pop (TV_JUMP);
2623 /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
2624 if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
2626 close_dump_file (DFI_jump, print_rtl, insns);
2627 goto exit_rest_of_compilation;
2630 /* Long term, this should probably move before the jump optimizer too,
2631 but I didn't want to disturb the rtl_dump_and_exit and related
2632 stuff at this time. */
2633 if (optimize > 0 && flag_ssa)
2635 /* Convert to SSA form. */
2637 timevar_push (TV_TO_SSA);
2638 open_dump_file (DFI_ssa, decl);
2640 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2641 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2642 convert_to_ssa ();
2644 close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
2645 timevar_pop (TV_TO_SSA);
2647 /* Perform sparse conditional constant propagation, if requested. */
2648 if (flag_ssa_ccp)
2650 timevar_push (TV_SSA_CCP);
2651 open_dump_file (DFI_ssa_ccp, decl);
2653 ssa_const_prop ();
2655 close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
2656 timevar_pop (TV_SSA_CCP);
2659 /* It would be useful to cleanup the CFG at this point, but block
2660 merging and possibly other transformations might leave a PHI
2661 node in the middle of a basic block, which is a strict no-no. */
2663 /* The SSA implementation uses basic block numbers in its phi
2664 nodes. Thus, changing the control-flow graph or the basic
2665 blocks, e.g., calling find_basic_blocks () or cleanup_cfg (),
2666 may cause problems. */
2668 if (flag_ssa_dce)
2670 /* Remove dead code. */
2672 timevar_push (TV_SSA_DCE);
2673 open_dump_file (DFI_ssa_dce, decl);
2675 insns = get_insns ();
2676 ssa_eliminate_dead_code();
2678 close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
2679 timevar_pop (TV_SSA_DCE);
2682 /* Convert from SSA form. */
2684 timevar_push (TV_FROM_SSA);
2685 open_dump_file (DFI_ussa, decl);
2687 convert_from_ssa ();
2688 /* New registers have been created. Rescan their usage. */
2689 reg_scan (insns, max_reg_num (), 1);
2691 close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
2692 timevar_pop (TV_FROM_SSA);
2694 ggc_collect ();
2695 /* CFG is no longer maintained up-to-date. */
2696 free_bb_for_insn ();
2699 timevar_push (TV_JUMP);
2701 if (optimize > 0)
2703 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2704 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP
2705 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
2707 /* ??? Run if-conversion before delete_null_pointer_checks,
2708 since the later does not preserve the CFG. This should
2709 be changed -- no since converting if's that are going to
2710 be deleted. */
2711 timevar_push (TV_IFCVT);
2712 if_convert (0);
2713 timevar_pop (TV_IFCVT);
2715 /* CFG is no longer maintained up-to-date. */
2716 free_bb_for_insn ();
2717 /* Try to identify useless null pointer tests and delete them. */
2718 if (flag_delete_null_pointer_checks)
2719 delete_null_pointer_checks (insns);
2722 /* Jump optimization, and the removal of NULL pointer checks, may
2723 have reduced the number of instructions substantially. CSE, and
2724 future passes, allocate arrays whose dimensions involve the
2725 maximum instruction UID, so if we can reduce the maximum UID
2726 we'll save big on memory. */
2727 renumber_insns (rtl_dump_file);
2728 timevar_pop (TV_JUMP);
2730 close_dump_file (DFI_jump, print_rtl, insns);
2732 ggc_collect ();
2734 /* Perform common subexpression elimination.
2735 Nonzero value from `cse_main' means that jumps were simplified
2736 and some code may now be unreachable, so do
2737 jump optimization again. */
2739 if (optimize > 0)
2741 open_dump_file (DFI_cse, decl);
2742 timevar_push (TV_CSE);
2744 reg_scan (insns, max_reg_num (), 1);
2746 tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2748 /* If we are not running more CSE passes, then we are no longer
2749 expecting CSE to be run. But always rerun it in a cheap mode. */
2750 cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
2752 if (tem || optimize > 1)
2754 timevar_push (TV_JUMP);
2755 rebuild_jump_labels (insns);
2756 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2757 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2758 timevar_pop (TV_JUMP);
2759 /* CFG is no longer maintained up-to-date. */
2760 free_bb_for_insn ();
2763 /* Run this after jump optmizations remove all the unreachable code
2764 so that unreachable code will not keep values live. */
2765 delete_trivially_dead_insns (insns, max_reg_num (), 0);
2767 /* Try to identify useless null pointer tests and delete them. */
2768 if (flag_delete_null_pointer_checks || flag_thread_jumps)
2770 timevar_push (TV_JUMP);
2771 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2773 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP
2774 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
2776 if (flag_delete_null_pointer_checks)
2777 delete_null_pointer_checks (insns);
2778 /* CFG is no longer maintained up-to-date. */
2779 free_bb_for_insn ();
2780 timevar_pop (TV_JUMP);
2783 /* The second pass of jump optimization is likely to have
2784 removed a bunch more instructions. */
2785 renumber_insns (rtl_dump_file);
2787 timevar_pop (TV_CSE);
2788 close_dump_file (DFI_cse, print_rtl, insns);
2791 open_dump_file (DFI_addressof, decl);
2793 purge_addressof (insns);
2794 reg_scan (insns, max_reg_num (), 1);
2796 close_dump_file (DFI_addressof, print_rtl, insns);
2798 ggc_collect ();
2800 /* Perform global cse. */
2802 if (optimize > 0 && flag_gcse)
2804 int save_csb, save_cfj;
2805 int tem2 = 0;
2807 timevar_push (TV_GCSE);
2808 open_dump_file (DFI_gcse, decl);
2810 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2811 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2812 tem = gcse_main (insns, rtl_dump_file);
2814 save_csb = flag_cse_skip_blocks;
2815 save_cfj = flag_cse_follow_jumps;
2816 flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
2818 /* CFG is no longer maintained up-to-date. */
2819 free_bb_for_insn ();
2820 /* If -fexpensive-optimizations, re-run CSE to clean up things done
2821 by gcse. */
2822 if (flag_expensive_optimizations)
2824 timevar_push (TV_CSE);
2825 reg_scan (insns, max_reg_num (), 1);
2826 tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2827 timevar_pop (TV_CSE);
2828 cse_not_expected = !flag_rerun_cse_after_loop;
2831 /* If gcse or cse altered any jumps, rerun jump optimizations to clean
2832 things up. Then possibly re-run CSE again. */
2833 while (tem || tem2)
2835 tem = tem2 = 0;
2836 timevar_push (TV_JUMP);
2837 rebuild_jump_labels (insns);
2838 delete_trivially_dead_insns (insns, max_reg_num (), 0);
2839 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2840 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2841 /* CFG is no longer maintained up-to-date. */
2842 free_bb_for_insn ();
2843 timevar_pop (TV_JUMP);
2845 if (flag_expensive_optimizations)
2847 timevar_push (TV_CSE);
2848 reg_scan (insns, max_reg_num (), 1);
2849 tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2850 timevar_pop (TV_CSE);
2854 close_dump_file (DFI_gcse, print_rtl, insns);
2855 timevar_pop (TV_GCSE);
2857 ggc_collect ();
2858 flag_cse_skip_blocks = save_csb;
2859 flag_cse_follow_jumps = save_cfj;
2862 /* Move constant computations out of loops. */
2864 if (optimize > 0)
2866 timevar_push (TV_LOOP);
2867 open_dump_file (DFI_loop, decl);
2868 free_bb_for_insn ();
2870 if (flag_rerun_loop_opt)
2872 cleanup_barriers ();
2874 /* We only want to perform unrolling once. */
2876 loop_optimize (insns, rtl_dump_file, 0);
2878 /* The first call to loop_optimize makes some instructions
2879 trivially dead. We delete those instructions now in the
2880 hope that doing so will make the heuristics in loop work
2881 better and possibly speed up compilation. */
2882 delete_trivially_dead_insns (insns, max_reg_num (), 0);
2884 /* The regscan pass is currently necessary as the alias
2885 analysis code depends on this information. */
2886 reg_scan (insns, max_reg_num (), 1);
2888 cleanup_barriers ();
2889 loop_optimize (insns, rtl_dump_file,
2890 (flag_unroll_loops ? LOOP_UNROLL : 0) | LOOP_BCT
2891 | (flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0));
2893 close_dump_file (DFI_loop, print_rtl, insns);
2894 timevar_pop (TV_LOOP);
2896 ggc_collect ();
2899 if (optimize > 0)
2901 timevar_push (TV_CSE2);
2902 open_dump_file (DFI_cse2, decl);
2904 if (flag_rerun_cse_after_loop)
2906 /* Running another jump optimization pass before the second
2907 cse pass sometimes simplifies the RTL enough to allow
2908 the second CSE pass to do a better job. Jump_optimize can change
2909 max_reg_num so we must rerun reg_scan afterwards.
2910 ??? Rework to not call reg_scan so often. */
2911 timevar_push (TV_JUMP);
2913 /* The previous call to loop_optimize makes some instructions
2914 trivially dead. We delete those instructions now in the
2915 hope that doing so will make the heuristics in jump work
2916 better and possibly speed up compilation. */
2917 delete_trivially_dead_insns (insns, max_reg_num (), 0);
2919 reg_scan (insns, max_reg_num (), 0);
2921 timevar_push (TV_IFCVT);
2923 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2924 cleanup_cfg (CLEANUP_EXPENSIVE);
2925 if_convert (0);
2927 timevar_pop(TV_IFCVT);
2929 timevar_pop (TV_JUMP);
2931 /* CFG is no longer maintained up-to-date. */
2932 free_bb_for_insn ();
2933 reg_scan (insns, max_reg_num (), 0);
2934 tem = cse_main (insns, max_reg_num (), 1, rtl_dump_file);
2936 if (tem)
2938 timevar_push (TV_JUMP);
2939 rebuild_jump_labels (insns);
2940 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2941 cleanup_cfg (CLEANUP_EXPENSIVE);
2942 /* CFG is no longer maintained up-to-date. */
2943 free_bb_for_insn ();
2944 timevar_pop (TV_JUMP);
2948 close_dump_file (DFI_cse2, print_rtl, insns);
2949 timevar_pop (TV_CSE2);
2951 ggc_collect ();
2954 cse_not_expected = 1;
2956 regclass_init ();
2958 /* Do control and data flow analysis; wrote some of the results to
2959 the dump file. */
2961 timevar_push (TV_FLOW);
2962 open_dump_file (DFI_cfg, decl);
2964 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2965 cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0)
2966 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
2967 check_function_return_warnings ();
2969 /* It may make more sense to mark constant functions after dead code is
2970 eliminated by life_analyzis, but we need to do it early, as -fprofile-arcs
2971 may insert code making function non-constant, but we still must consider
2972 it as constant, otherwise -fbranch-probabilities will not read data back.
2974 life_analyzis rarely eliminates modification of external memory.
2976 mark_constant_function ();
2978 close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
2980 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
2982 timevar_push (TV_BRANCH_PROB);
2983 open_dump_file (DFI_bp, decl);
2985 branch_prob ();
2987 close_dump_file (DFI_bp, print_rtl_with_bb, insns);
2988 timevar_pop (TV_BRANCH_PROB);
2991 open_dump_file (DFI_life, decl);
2992 if (optimize)
2994 struct loops loops;
2996 /* Discover and record the loop depth at the head of each basic
2997 block. The loop infrastructure does the real job for us. */
2998 flow_loops_find (&loops, LOOP_TREE);
3000 /* Estimate using heuristics if no profiling info is available. */
3001 if (flag_guess_branch_prob)
3002 estimate_probability (&loops);
3004 if (rtl_dump_file)
3005 flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
3007 flow_loops_free (&loops);
3009 life_analysis (insns, rtl_dump_file, PROP_FINAL);
3010 timevar_pop (TV_FLOW);
3012 no_new_pseudos = 1;
3014 if (warn_uninitialized || extra_warnings)
3016 uninitialized_vars_warning (DECL_INITIAL (decl));
3017 if (extra_warnings)
3018 setjmp_args_warning ();
3021 if (optimize)
3023 if (initialize_uninitialized_subregs ())
3025 /* Insns were inserted, so things might look a bit different. */
3026 insns = get_insns ();
3027 life_analysis (insns, rtl_dump_file,
3028 (PROP_LOG_LINKS | PROP_REG_INFO | PROP_DEATH_NOTES));
3032 close_dump_file (DFI_life, print_rtl_with_bb, insns);
3034 ggc_collect ();
3036 /* If -opt, try combining insns through substitution. */
3038 if (optimize > 0)
3040 int rebuild_jump_labels_after_combine = 0;
3042 timevar_push (TV_COMBINE);
3043 open_dump_file (DFI_combine, decl);
3045 rebuild_jump_labels_after_combine
3046 = combine_instructions (insns, max_reg_num ());
3048 /* Always purge dead edges, as we may eliminate an insn throwing
3049 exception. */
3050 rebuild_jump_labels_after_combine |= purge_all_dead_edges (true);
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)
3057 timevar_push (TV_JUMP);
3058 rebuild_jump_labels (insns);
3059 timevar_pop (TV_JUMP);
3061 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
3064 close_dump_file (DFI_combine, print_rtl_with_bb, insns);
3065 timevar_pop (TV_COMBINE);
3067 ggc_collect ();
3070 /* Rerun if-conversion, as combine may have simplified things enough to
3071 now meet sequence length restrictions. */
3072 if (optimize > 0)
3074 timevar_push (TV_IFCVT);
3075 open_dump_file (DFI_ce, decl);
3077 no_new_pseudos = 0;
3078 if_convert (1);
3079 no_new_pseudos = 1;
3081 close_dump_file (DFI_ce, print_rtl_with_bb, insns);
3082 timevar_pop (TV_IFCVT);
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))
3089 timevar_push (TV_REGMOVE);
3090 open_dump_file (DFI_regmove, decl);
3092 regmove_optimize (insns, max_reg_num (), rtl_dump_file);
3094 close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
3095 timevar_pop (TV_REGMOVE);
3097 ggc_collect ();
3100 /* Do unconditional splitting before register allocation to allow machine
3101 description to add extra information not needed previously. */
3102 split_all_insns (1);
3104 /* Any of the several passes since flow1 will have munged register
3105 lifetime data a bit. */
3106 register_life_up_to_date = 0;
3108 #ifdef OPTIMIZE_MODE_SWITCHING
3109 timevar_push (TV_MODE_SWITCH);
3111 no_new_pseudos = 0;
3112 if (optimize_mode_switching (NULL))
3114 /* We did work, and so had to regenerate global life information.
3115 Take advantage of this and don't re-recompute register life
3116 information below. */
3117 register_life_up_to_date = 1;
3119 no_new_pseudos = 1;
3121 timevar_pop (TV_MODE_SWITCH);
3122 #endif
3124 timevar_push (TV_SCHED);
3126 #ifdef INSN_SCHEDULING
3128 /* Print function header into sched dump now
3129 because doing the sched analysis makes some of the dump. */
3130 if (optimize > 0 && flag_schedule_insns)
3132 open_dump_file (DFI_sched, decl);
3134 /* Do control and data sched analysis,
3135 and write some of the results to dump file. */
3137 schedule_insns (rtl_dump_file);
3139 close_dump_file (DFI_sched, print_rtl_with_bb, insns);
3141 /* Register lifetime information was updated as part of verifying
3142 the schedule. */
3143 register_life_up_to_date = 1;
3145 #endif
3146 timevar_pop (TV_SCHED);
3148 ggc_collect ();
3150 /* Determine if the current function is a leaf before running reload
3151 since this can impact optimizations done by the prologue and
3152 epilogue thus changing register elimination offsets. */
3153 current_function_is_leaf = leaf_function_p ();
3155 timevar_push (TV_LOCAL_ALLOC);
3156 open_dump_file (DFI_lreg, decl);
3158 /* Allocate pseudo-regs that are used only within 1 basic block.
3160 RUN_JUMP_AFTER_RELOAD records whether or not we need to rerun the
3161 jump optimizer after register allocation and reloading are finished. */
3163 if (! register_life_up_to_date)
3164 recompute_reg_usage (insns, ! optimize_size);
3166 /* Allocate the reg_renumber array. */
3167 allocate_reg_info (max_regno, FALSE, TRUE);
3169 /* And the reg_equiv_memory_loc array. */
3170 reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
3172 allocate_initial_values (reg_equiv_memory_loc);
3174 regclass (insns, max_reg_num (), rtl_dump_file);
3175 rebuild_label_notes_after_reload = local_alloc ();
3177 timevar_pop (TV_LOCAL_ALLOC);
3179 if (dump_file[DFI_lreg].enabled)
3181 timevar_push (TV_DUMP);
3183 dump_flow_info (rtl_dump_file);
3184 dump_local_alloc (rtl_dump_file);
3186 close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
3187 timevar_pop (TV_DUMP);
3190 ggc_collect ();
3192 timevar_push (TV_GLOBAL_ALLOC);
3193 open_dump_file (DFI_greg, decl);
3195 /* If optimizing, allocate remaining pseudo-regs. Do the reload
3196 pass fixing up any insns that are invalid. */
3198 if (optimize)
3199 failure = global_alloc (rtl_dump_file);
3200 else
3202 build_insn_chain (insns);
3203 failure = reload (insns, 0);
3206 timevar_pop (TV_GLOBAL_ALLOC);
3208 if (dump_file[DFI_greg].enabled)
3210 timevar_push (TV_DUMP);
3212 dump_global_regs (rtl_dump_file);
3214 close_dump_file (DFI_greg, print_rtl_with_bb, insns);
3215 timevar_pop (TV_DUMP);
3218 if (failure)
3219 goto exit_rest_of_compilation;
3221 ggc_collect ();
3223 open_dump_file (DFI_postreload, decl);
3225 /* Do a very simple CSE pass over just the hard registers. */
3226 if (optimize > 0)
3228 timevar_push (TV_RELOAD_CSE_REGS);
3229 reload_cse_regs (insns);
3230 timevar_pop (TV_RELOAD_CSE_REGS);
3233 /* Register allocation and reloading may have turned an indirect jump into
3234 a direct jump. If so, we must rebuild the JUMP_LABEL fields of
3235 jumping instructions. */
3236 if (rebuild_label_notes_after_reload)
3238 timevar_push (TV_JUMP);
3240 rebuild_jump_labels (insns);
3242 timevar_pop (TV_JUMP);
3245 close_dump_file (DFI_postreload, print_rtl_with_bb, insns);
3247 /* Re-create the death notes which were deleted during reload. */
3248 timevar_push (TV_FLOW2);
3249 open_dump_file (DFI_flow2, decl);
3251 #ifdef ENABLE_CHECKING
3252 verify_flow_info ();
3253 #endif
3255 /* If optimizing, then go ahead and split insns now. */
3256 if (optimize > 0)
3257 split_all_insns (0);
3259 cleanup_cfg (optimize ? CLEANUP_EXPENSIVE : 0);
3261 /* On some machines, the prologue and epilogue code, or parts thereof,
3262 can be represented as RTL. Doing so lets us schedule insns between
3263 it and the rest of the code and also allows delayed branch
3264 scheduling to operate in the epilogue. */
3265 thread_prologue_and_epilogue_insns (insns);
3267 if (optimize)
3269 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_CROSSJUMP);
3270 life_analysis (insns, rtl_dump_file, PROP_FINAL);
3272 /* This is kind of a heuristic. We need to run combine_stack_adjustments
3273 even for machines with possibly nonzero RETURN_POPS_ARGS
3274 and ACCUMULATE_OUTGOING_ARGS. We expect that only ports having
3275 push instructions will have popping returns. */
3276 #ifndef PUSH_ROUNDING
3277 if (!ACCUMULATE_OUTGOING_ARGS)
3278 #endif
3279 combine_stack_adjustments ();
3281 ggc_collect ();
3284 flow2_completed = 1;
3286 close_dump_file (DFI_flow2, print_rtl_with_bb, insns);
3287 timevar_pop (TV_FLOW2);
3289 #ifdef HAVE_peephole2
3290 if (optimize > 0 && flag_peephole2)
3292 timevar_push (TV_PEEPHOLE2);
3293 open_dump_file (DFI_peephole2, decl);
3295 peephole2_optimize (rtl_dump_file);
3297 close_dump_file (DFI_peephole2, print_rtl_with_bb, insns);
3298 timevar_pop (TV_PEEPHOLE2);
3300 #endif
3302 if (flag_rename_registers || flag_cprop_registers)
3304 timevar_push (TV_RENAME_REGISTERS);
3305 open_dump_file (DFI_rnreg, decl);
3307 if (flag_rename_registers)
3308 regrename_optimize ();
3309 if (flag_cprop_registers)
3310 copyprop_hardreg_forward ();
3312 close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
3313 timevar_pop (TV_RENAME_REGISTERS);
3316 if (optimize > 0)
3318 timevar_push (TV_IFCVT2);
3319 open_dump_file (DFI_ce2, decl);
3321 if_convert (1);
3323 close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
3324 timevar_pop (TV_IFCVT2);
3326 #ifdef STACK_REGS
3327 if (optimize)
3328 split_all_insns (1);
3329 #endif
3331 #ifdef INSN_SCHEDULING
3332 if (optimize > 0 && flag_schedule_insns_after_reload)
3334 timevar_push (TV_SCHED2);
3335 open_dump_file (DFI_sched2, decl);
3337 /* Do control and data sched analysis again,
3338 and write some more of the results to dump file. */
3340 split_all_insns (1);
3342 schedule_insns (rtl_dump_file);
3344 close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
3345 timevar_pop (TV_SCHED2);
3347 ggc_collect ();
3349 #endif
3351 #ifdef LEAF_REGISTERS
3352 current_function_uses_only_leaf_regs
3353 = optimize > 0 && only_leaf_regs_used () && leaf_function_p ();
3354 #endif
3356 #ifdef STACK_REGS
3357 timevar_push (TV_REG_STACK);
3358 open_dump_file (DFI_stack, decl);
3360 reg_to_stack (insns, rtl_dump_file);
3362 close_dump_file (DFI_stack, print_rtl_with_bb, insns);
3363 timevar_pop (TV_REG_STACK);
3365 ggc_collect ();
3366 #endif
3367 if (optimize > 0)
3369 timevar_push (TV_REORDER_BLOCKS);
3370 open_dump_file (DFI_bbro, decl);
3372 /* Last attempt to optimize CFG, as life analyzis possibly removed
3373 some instructions. */
3374 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
3375 | CLEANUP_CROSSJUMP);
3376 if (flag_reorder_blocks)
3378 reorder_basic_blocks ();
3379 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
3382 close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
3383 timevar_pop (TV_REORDER_BLOCKS);
3385 compute_alignments ();
3387 /* CFG is no longer maintained up-to-date. */
3388 free_bb_for_insn ();
3390 /* If a machine dependent reorganization is needed, call it. */
3391 #ifdef MACHINE_DEPENDENT_REORG
3392 timevar_push (TV_MACH_DEP);
3393 open_dump_file (DFI_mach, decl);
3395 MACHINE_DEPENDENT_REORG (insns);
3397 close_dump_file (DFI_mach, print_rtl, insns);
3398 timevar_pop (TV_MACH_DEP);
3400 ggc_collect ();
3401 #endif
3403 purge_line_number_notes (insns);
3404 cleanup_barriers ();
3406 /* If a scheduling pass for delayed branches is to be done,
3407 call the scheduling code. */
3409 #ifdef DELAY_SLOTS
3410 if (optimize > 0 && flag_delayed_branch)
3412 timevar_push (TV_DBR_SCHED);
3413 open_dump_file (DFI_dbr, decl);
3415 dbr_schedule (insns, rtl_dump_file);
3417 close_dump_file (DFI_dbr, print_rtl, insns);
3418 timevar_pop (TV_DBR_SCHED);
3420 ggc_collect ();
3422 #endif
3424 #if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
3425 timevar_push (TV_SHORTEN_BRANCH);
3426 split_all_insns_noflow ();
3427 timevar_pop (TV_SHORTEN_BRANCH);
3428 #endif
3430 convert_to_eh_region_ranges ();
3432 /* Shorten branches. */
3433 timevar_push (TV_SHORTEN_BRANCH);
3434 shorten_branches (get_insns ());
3435 timevar_pop (TV_SHORTEN_BRANCH);
3437 current_function_nothrow = nothrow_function_p ();
3438 if (current_function_nothrow)
3439 /* Now we know that this can't throw; set the flag for the benefit
3440 of other functions later in this translation unit. */
3441 TREE_NOTHROW (current_function_decl) = 1;
3443 /* Now turn the rtl into assembler code. */
3445 timevar_push (TV_FINAL);
3447 rtx x;
3448 const char *fnname;
3450 /* Get the function's name, as described by its RTL. This may be
3451 different from the DECL_NAME name used in the source file. */
3453 x = DECL_RTL (decl);
3454 if (GET_CODE (x) != MEM)
3455 abort ();
3456 x = XEXP (x, 0);
3457 if (GET_CODE (x) != SYMBOL_REF)
3458 abort ();
3459 fnname = XSTR (x, 0);
3461 assemble_start_function (decl, fnname);
3462 final_start_function (insns, asm_out_file, optimize);
3463 final (insns, asm_out_file, optimize, 0);
3464 final_end_function ();
3466 #ifdef IA64_UNWIND_INFO
3467 /* ??? The IA-64 ".handlerdata" directive must be issued before
3468 the ".endp" directive that closes the procedure descriptor. */
3469 output_function_exception_table ();
3470 #endif
3472 assemble_end_function (decl, fnname);
3474 #ifndef IA64_UNWIND_INFO
3475 /* Otherwise, it feels unclean to switch sections in the middle. */
3476 output_function_exception_table ();
3477 #endif
3479 if (! quiet_flag)
3480 fflush (asm_out_file);
3482 /* Release all memory allocated by flow. */
3483 free_basic_block_vars (0);
3485 /* Release all memory held by regsets now. */
3486 regset_release_memory ();
3488 timevar_pop (TV_FINAL);
3490 ggc_collect ();
3492 /* Write DBX symbols if requested. */
3494 /* Note that for those inline functions where we don't initially
3495 know for certain that we will be generating an out-of-line copy,
3496 the first invocation of this routine (rest_of_compilation) will
3497 skip over this code by doing a `goto exit_rest_of_compilation;'.
3498 Later on, finish_compilation will call rest_of_compilation again
3499 for those inline functions that need to have out-of-line copies
3500 generated. During that call, we *will* be routed past here. */
3502 timevar_push (TV_SYMOUT);
3503 (*debug_hooks->function_decl) (decl);
3504 timevar_pop (TV_SYMOUT);
3506 exit_rest_of_compilation:
3508 /* In case the function was not output,
3509 don't leave any temporary anonymous types
3510 queued up for sdb output. */
3511 #ifdef SDB_DEBUGGING_INFO
3512 if (write_symbols == SDB_DEBUG)
3513 sdbout_types (NULL_TREE);
3514 #endif
3516 reload_completed = 0;
3517 flow2_completed = 0;
3518 no_new_pseudos = 0;
3520 timevar_push (TV_FINAL);
3522 /* Clear out the insn_length contents now that they are no
3523 longer valid. */
3524 init_insn_lengths ();
3526 /* Clear out the real_constant_chain before some of the rtx's
3527 it runs through become garbage. */
3528 clear_const_double_mem ();
3530 /* Show no temporary slots allocated. */
3531 init_temp_slots ();
3533 free_basic_block_vars (0);
3534 free_bb_for_insn ();
3536 timevar_pop (TV_FINAL);
3538 /* Make sure volatile mem refs aren't considered valid operands for
3539 arithmetic insns. We must call this here if this is a nested inline
3540 function, since the above code leaves us in the init_recog state
3541 (from final.c), and the function context push/pop code does not
3542 save/restore volatile_ok.
3544 ??? Maybe it isn't necessary for expand_start_function to call this
3545 anymore if we do it here? */
3547 init_recog_no_volatile ();
3549 /* We're done with this function. Free up memory if we can. */
3550 free_after_parsing (cfun);
3551 if (! DECL_DEFER_OUTPUT (decl))
3553 free_after_compilation (cfun);
3555 /* Clear integrate.c's pointer to the cfun structure we just
3556 destroyed. */
3557 DECL_SAVED_INSNS (decl) = 0;
3559 cfun = 0;
3561 ggc_collect ();
3563 timevar_pop (TV_REST_OF_COMPILATION);
3566 static void
3567 display_help ()
3569 int undoc;
3570 unsigned long i;
3571 const char *lang;
3573 printf (_(" -ffixed-<register> Mark <register> as being unavailable to the compiler\n"));
3574 printf (_(" -fcall-used-<register> Mark <register> as being corrupted by function calls\n"));
3575 printf (_(" -fcall-saved-<register> Mark <register> as being preserved across functions\n"));
3576 printf (_(" -finline-limit=<number> Limits the size of inlined functions to <number>\n"));
3577 printf (_(" -fmessage-length=<number> Limits diagnostics messages lengths to <number> characters per line. 0 suppresses line-wrapping\n"));
3578 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"));
3580 for (i = ARRAY_SIZE (f_options); i--;)
3582 const char *description = f_options[i].description;
3584 if (description != NULL && * description != 0)
3585 printf (" -f%-21s %s\n",
3586 f_options[i].string, _(description));
3589 printf (_(" -O[number] Set optimization level to [number]\n"));
3590 printf (_(" -Os Optimize for space rather than speed\n"));
3591 for (i = LAST_PARAM; i--;)
3593 const char *description = compiler_params[i].help;
3594 const int length = 21-strlen(compiler_params[i].option);
3596 if (description != NULL && * description != 0)
3597 printf (" --param %s=<value>%.*s%s\n",
3598 compiler_params[i].option,
3599 length > 0 ? length : 1, " ",
3600 _(description));
3602 printf (_(" -pedantic Issue warnings needed by strict compliance to ISO C\n"));
3603 printf (_(" -pedantic-errors Like -pedantic except that errors are produced\n"));
3604 printf (_(" -w Suppress warnings\n"));
3605 printf (_(" -W Enable extra warnings\n"));
3607 for (i = ARRAY_SIZE (W_options); i--;)
3609 const char *description = W_options[i].description;
3611 if (description != NULL && * description != 0)
3612 printf (" -W%-21s %s\n",
3613 W_options[i].string, _(description));
3616 printf (_(" -Wunused Enable unused warnings\n"));
3617 printf (_(" -Wlarger-than-<number> Warn if an object is larger than <number> bytes\n"));
3618 printf (_(" -p Enable function profiling\n"));
3619 #if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER)
3620 printf (_(" -a Enable block profiling \n"));
3621 #endif
3622 #if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER) || defined FUNCTION_BLOCK_PROFILER_EXIT
3623 printf (_(" -ax Enable jump profiling \n"));
3624 #endif
3625 printf (_(" -o <file> Place output into <file> \n"));
3626 printf (_("\
3627 -G <number> Put global and static data smaller than <number>\n\
3628 bytes into a special section (on some targets)\n"));
3630 for (i = ARRAY_SIZE (debug_args); i--;)
3632 if (debug_args[i].description != NULL)
3633 printf (" -g%-21s %s\n",
3634 debug_args[i].arg, _(debug_args[i].description));
3637 printf (_(" -aux-info <file> Emit declaration info into <file>\n"));
3638 printf (_(" -quiet Do not display functions compiled or elapsed time\n"));
3639 printf (_(" -version Display the compiler's version\n"));
3640 printf (_(" -d[letters] Enable dumps from specific passes of the compiler\n"));
3641 printf (_(" -dumpbase <file> Base name to be used for dumps from specific passes\n"));
3642 #if defined INSN_SCHEDULING
3643 printf (_(" -fsched-verbose=<number> Set the verbosity level of the scheduler\n"));
3644 #endif
3645 printf (_(" --help Display this information\n"));
3647 undoc = 0;
3648 lang = "language";
3650 /* Display descriptions of language specific options.
3651 If there is no description, note that there is an undocumented option.
3652 If the description is empty, do not display anything. (This allows
3653 options to be deliberately undocumented, for whatever reason).
3654 If the option string is missing, then this is a marker, indicating
3655 that the description string is in fact the name of a language, whose
3656 language specific options are to follow. */
3658 if (ARRAY_SIZE (documented_lang_options) > 1)
3660 printf (_("\nLanguage specific options:\n"));
3662 for (i = 0; i < ARRAY_SIZE (documented_lang_options); i++)
3664 const char *description = documented_lang_options[i].description;
3665 const char *option = documented_lang_options[i].option;
3667 if (description == NULL)
3669 undoc = 1;
3671 if (extra_warnings)
3672 printf (_(" %-23.23s [undocumented]\n"), option);
3674 else if (*description == 0)
3675 continue;
3676 else if (option == NULL)
3678 if (undoc)
3679 printf
3680 (_("\nThere are undocumented %s specific options as well.\n"),
3681 lang);
3682 undoc = 0;
3684 printf (_("\n Options for %s:\n"), description);
3686 lang = description;
3688 else
3689 printf (" %-23.23s %s\n", option, _(description));
3693 if (undoc)
3694 printf (_("\nThere are undocumented %s specific options as well.\n"),
3695 lang);
3697 display_target_options ();
3700 static void
3701 display_target_options ()
3703 int undoc, i;
3704 static bool displayed = false;
3706 /* Avoid double printing for --help --target-help. */
3707 if (displayed)
3708 return;
3709 displayed = true;
3711 if (ARRAY_SIZE (target_switches) > 1
3712 #ifdef TARGET_OPTIONS
3713 || ARRAY_SIZE (target_options) > 1
3714 #endif
3717 int doc = 0;
3719 undoc = 0;
3721 printf (_("\nTarget specific options:\n"));
3723 for (i = ARRAY_SIZE (target_switches); i--;)
3725 const char *option = target_switches[i].name;
3726 const char *description = target_switches[i].description;
3728 if (option == NULL || *option == 0)
3729 continue;
3730 else if (description == NULL)
3732 undoc = 1;
3734 if (extra_warnings)
3735 printf (_(" -m%-23.23s [undocumented]\n"), option);
3737 else if (* description != 0)
3738 doc += printf (" -m%-23.23s %s\n", option, _(description));
3741 #ifdef TARGET_OPTIONS
3742 for (i = ARRAY_SIZE (target_options); i--;)
3744 const char *option = target_options[i].prefix;
3745 const char *description = target_options[i].description;
3747 if (option == NULL || *option == 0)
3748 continue;
3749 else if (description == NULL)
3751 undoc = 1;
3753 if (extra_warnings)
3754 printf (_(" -m%-23.23s [undocumented]\n"), option);
3756 else if (* description != 0)
3757 doc += printf (" -m%-23.23s %s\n", option, _(description));
3759 #endif
3760 if (undoc)
3762 if (doc)
3763 printf (_("\nThere are undocumented target specific options as well.\n"));
3764 else
3765 printf (_(" They exist, but they are not documented.\n"));
3770 /* Parse a -d... command line switch. */
3772 static void
3773 decode_d_option (arg)
3774 const char *arg;
3776 int i, c, matched;
3778 while (*arg)
3779 switch (c = *arg++)
3781 case 'a':
3782 for (i = 0; i < (int) DFI_MAX; ++i)
3783 dump_file[i].enabled = 1;
3784 break;
3785 case 'A':
3786 flag_debug_asm = 1;
3787 break;
3788 case 'p':
3789 flag_print_asm_name = 1;
3790 break;
3791 case 'P':
3792 flag_dump_rtl_in_asm = 1;
3793 flag_print_asm_name = 1;
3794 break;
3795 case 'v':
3796 graph_dump_format = vcg;
3797 break;
3798 case 'x':
3799 rtl_dump_and_exit = 1;
3800 break;
3801 case 'y':
3802 (*lang_hooks.set_yydebug) (1);
3803 break;
3804 case 'D': /* These are handled by the preprocessor. */
3805 case 'I':
3806 break;
3808 default:
3809 matched = 0;
3810 for (i = 0; i < (int) DFI_MAX; ++i)
3811 if (c == dump_file[i].debug_switch)
3813 dump_file[i].enabled = 1;
3814 matched = 1;
3817 if (! matched)
3818 warning ("unrecognized gcc debugging option: %c", c);
3819 break;
3823 /* Parse a -f... command line switch. ARG is the value after the -f.
3824 It is safe to access 'ARG - 2' to generate the full switch name.
3825 Return the number of strings consumed. */
3827 static int
3828 decode_f_option (arg)
3829 const char *arg;
3831 int j;
3832 const char *option_value = NULL;
3834 /* Search for the option in the table of binary f options. */
3835 for (j = ARRAY_SIZE (f_options); j--;)
3837 if (!strcmp (arg, f_options[j].string))
3839 *f_options[j].variable = f_options[j].on_value;
3840 return 1;
3843 if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
3844 && ! strcmp (arg + 3, f_options[j].string))
3846 *f_options[j].variable = ! f_options[j].on_value;
3847 return 1;
3851 if (!strcmp (arg, "fast-math"))
3852 set_fast_math_flags ();
3853 else if (!strcmp (arg, "no-fast-math"))
3854 set_no_fast_math_flags ();
3855 else if ((option_value = skip_leading_substring (arg, "inline-limit-"))
3856 || (option_value = skip_leading_substring (arg, "inline-limit=")))
3858 int val =
3859 read_integral_parameter (option_value, arg - 2,
3860 MAX_INLINE_INSNS);
3861 set_param_value ("max-inline-insns", val);
3863 #ifdef INSN_SCHEDULING
3864 else if ((option_value = skip_leading_substring (arg, "sched-verbose=")))
3865 fix_sched_param ("verbose", option_value);
3866 #endif
3867 else if ((option_value = skip_leading_substring (arg, "fixed-")))
3868 fix_register (option_value, 1, 1);
3869 else if ((option_value = skip_leading_substring (arg, "call-used-")))
3870 fix_register (option_value, 0, 1);
3871 else if ((option_value = skip_leading_substring (arg, "call-saved-")))
3872 fix_register (option_value, 0, 0);
3873 else if ((option_value = skip_leading_substring (arg, "align-loops=")))
3874 align_loops = read_integral_parameter (option_value, arg - 2, align_loops);
3875 else if ((option_value = skip_leading_substring (arg, "align-functions=")))
3876 align_functions
3877 = read_integral_parameter (option_value, arg - 2, align_functions);
3878 else if ((option_value = skip_leading_substring (arg, "align-jumps=")))
3879 align_jumps = read_integral_parameter (option_value, arg - 2, align_jumps);
3880 else if ((option_value = skip_leading_substring (arg, "align-labels=")))
3881 align_labels
3882 = read_integral_parameter (option_value, arg - 2, align_labels);
3883 else if ((option_value
3884 = skip_leading_substring (arg, "stack-limit-register=")))
3886 int reg = decode_reg_name (option_value);
3887 if (reg < 0)
3888 error ("unrecognized register name `%s'", option_value);
3889 else
3890 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
3892 else if ((option_value
3893 = skip_leading_substring (arg, "stack-limit-symbol=")))
3895 const char *nm;
3896 nm = ggc_strdup (option_value);
3897 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, nm);
3899 else if ((option_value
3900 = skip_leading_substring (arg, "message-length=")))
3901 output_set_maximum_length
3902 (&global_dc->buffer, read_integral_parameter
3903 (option_value, arg - 2, diagnostic_line_cutoff (global_dc)));
3904 else if ((option_value
3905 = skip_leading_substring (arg, "diagnostics-show-location=")))
3907 if (!strcmp (option_value, "once"))
3908 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
3909 else if (!strcmp (option_value, "every-line"))
3910 diagnostic_prefixing_rule (global_dc)
3911 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
3912 else
3913 error ("unrecognized option `%s'", arg - 2);
3915 else if (!strcmp (arg, "no-stack-limit"))
3916 stack_limit_rtx = NULL_RTX;
3917 else if (!strcmp (arg, "preprocessed"))
3918 /* Recognise this switch but do nothing. This prevents warnings
3919 about an unrecognized switch if cpplib has not been linked in. */
3921 else
3922 return 0;
3924 return 1;
3927 /* Parse a -W... command line switch. ARG is the value after the -W.
3928 It is safe to access 'ARG - 2' to generate the full switch name.
3929 Return the number of strings consumed. */
3931 static int
3932 decode_W_option (arg)
3933 const char *arg;
3935 const char *option_value = NULL;
3936 int j;
3938 /* Search for the option in the table of binary W options. */
3940 for (j = ARRAY_SIZE (W_options); j--;)
3942 if (!strcmp (arg, W_options[j].string))
3944 *W_options[j].variable = W_options[j].on_value;
3945 return 1;
3948 if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
3949 && ! strcmp (arg + 3, W_options[j].string))
3951 *W_options[j].variable = ! W_options[j].on_value;
3952 return 1;
3956 if ((option_value = skip_leading_substring (arg, "id-clash-")))
3957 warning ("-Wid-clash-LEN is no longer supported");
3958 else if ((option_value = skip_leading_substring (arg, "larger-than-")))
3960 larger_than_size = read_integral_parameter (option_value, arg - 2, -1);
3962 warn_larger_than = larger_than_size != -1;
3964 else if (!strcmp (arg, "unused"))
3966 set_Wunused (1);
3968 else if (!strcmp (arg, "no-unused"))
3970 set_Wunused (0);
3972 else
3973 return 0;
3975 return 1;
3978 /* Parse a -g... command line switch. ARG is the value after the -g.
3979 It is safe to access 'ARG - 2' to generate the full switch name.
3980 Return the number of strings consumed. */
3982 static int
3983 decode_g_option (arg)
3984 const char *arg;
3986 static unsigned level=0;
3987 /* A lot of code assumes write_symbols == NO_DEBUG if the
3988 debugging level is 0 (thus -gstabs1 -gstabs0 would lose track
3989 of what debugging type has been selected). This records the
3990 selected type. It is an error to specify more than one
3991 debugging type. */
3992 static enum debug_info_type selected_debug_type = NO_DEBUG;
3993 /* Non-zero if debugging format has been explicitly set.
3994 -g and -ggdb don't explicitly set the debugging format so
3995 -gdwarf -g3 is equivalent to -gdwarf3. */
3996 static int type_explicitly_set_p = 0;
3997 /* Indexed by enum debug_info_type. */
3998 static const char *const debug_type_names[] =
4000 "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff", "vms"
4003 /* The maximum admissible debug level value. */
4004 static const unsigned max_debug_level = 3;
4006 /* Look up ARG in the table. */
4007 for (da = debug_args; da->arg; da++)
4009 const int da_len = strlen (da->arg);
4011 if (da_len == 0 || ! strncmp (arg, da->arg, da_len))
4013 enum debug_info_type type = da->debug_type;
4014 const char *p = arg + da_len;
4016 if (*p && ! ISDIGIT (*p))
4017 continue;
4019 /* A debug flag without a level defaults to level 2.
4020 Note we do not want to call read_integral_parameter
4021 for that case since it will call atoi which
4022 will return zero.
4024 ??? We may want to generalize the interface to
4025 read_integral_parameter to better handle this case
4026 if this case shows up often. */
4027 if (*p)
4028 level = read_integral_parameter (p, 0, max_debug_level + 1);
4029 else
4030 level = (level == 0) ? 2 : level;
4032 if (da_len > 1 && *p && !strncmp (arg, "dwarf", da_len))
4034 error ("use -gdwarf -g%d for DWARF v1, level %d",
4035 level, level);
4036 if (level == 2)
4037 error ("use -gdwarf-2 for DWARF v2");
4040 if (level > max_debug_level)
4042 warning ("\
4043 ignoring option `%s' due to invalid debug level specification",
4044 arg - 2);
4045 level = debug_info_level;
4048 if (type == NO_DEBUG)
4050 type = PREFERRED_DEBUGGING_TYPE;
4052 if (da_len > 1 && strncmp (arg, "gdb", da_len) == 0)
4054 #if defined (DWARF2_DEBUGGING_INFO) && !defined (LINKER_DOES_NOT_WORK_WITH_DWARF2)
4055 type = DWARF2_DEBUG;
4056 #else
4057 #ifdef DBX_DEBUGGING_INFO
4058 type = DBX_DEBUG;
4059 #endif
4060 #endif
4064 if (type == NO_DEBUG)
4065 warning ("`%s': unknown or unsupported -g option", arg - 2);
4067 /* Does it conflict with an already selected type? */
4068 if (type_explicitly_set_p
4069 /* -g/-ggdb don't conflict with anything. */
4070 && da->debug_type != NO_DEBUG
4071 && type != selected_debug_type)
4072 warning ("`%s' ignored, conflicts with `-g%s'",
4073 arg - 2, debug_type_names[(int) selected_debug_type]);
4074 else
4076 /* If the format has already been set, -g/-ggdb
4077 only change the debug level. */
4078 if (type_explicitly_set_p && da->debug_type == NO_DEBUG)
4079 /* Don't change debugging type. */
4081 else
4083 selected_debug_type = type;
4084 type_explicitly_set_p = da->debug_type != NO_DEBUG;
4087 write_symbols = (level == 0
4088 ? NO_DEBUG
4089 : selected_debug_type);
4090 use_gnu_debug_info_extensions = da->use_extensions_p;
4091 debug_info_level = (enum debug_info_level) level;
4094 break;
4098 if (! da->arg)
4099 return 0;
4101 return 1;
4104 /* Decode the first argument in the argv as a language-independent option.
4105 Return the number of strings consumed. */
4107 static unsigned int
4108 independent_decode_option (argc, argv)
4109 int argc;
4110 char **argv;
4112 char *arg = argv[0];
4114 if (arg[0] != '-' || arg[1] == 0)
4116 if (arg[0] == '+')
4117 return 0;
4119 filename = arg;
4121 return 1;
4124 arg++;
4126 if (!strcmp (arg, "-help"))
4128 display_help ();
4129 exit_after_options = 1;
4132 if (!strcmp (arg, "-target-help"))
4134 display_target_options ();
4135 exit_after_options = 1;
4138 if (!strcmp (arg, "-version"))
4140 print_version (stderr, "");
4141 exit_after_options = 1;
4144 /* Handle '--param <name>=<value>'. */
4145 if (strcmp (arg, "-param") == 0)
4147 char *equal;
4149 if (argc == 1)
4151 error ("-param option missing argument");
4152 return 1;
4155 /* Get the '<name>=<value>' parameter. */
4156 arg = argv[1];
4157 /* Look for the `='. */
4158 equal = strchr (arg, '=');
4159 if (!equal)
4160 error ("invalid --param option: %s", arg);
4161 else
4163 int val;
4165 /* Zero out the `=' sign so that we get two separate strings. */
4166 *equal = '\0';
4167 /* Figure out what value is specified. */
4168 val = read_integral_parameter (equal + 1, NULL, INVALID_PARAM_VAL);
4169 if (val != INVALID_PARAM_VAL)
4170 set_param_value (arg, val);
4171 else
4172 error ("invalid parameter value `%s'", equal + 1);
4175 return 2;
4178 if (*arg == 'Y')
4179 arg++;
4181 switch (*arg)
4183 default:
4184 return 0;
4186 case 'O':
4187 /* Already been treated in main (). Do nothing. */
4188 break;
4190 case 'm':
4191 set_target_switch (arg + 1);
4192 break;
4194 case 'f':
4195 return decode_f_option (arg + 1);
4197 case 'g':
4198 return decode_g_option (arg + 1);
4200 case 'd':
4201 if (!strcmp (arg, "dumpbase"))
4203 if (argc == 1)
4204 return 0;
4206 dump_base_name = argv[1];
4207 return 2;
4209 else
4210 decode_d_option (arg + 1);
4211 break;
4213 case 'p':
4214 if (!strcmp (arg, "pedantic"))
4215 pedantic = 1;
4216 else if (!strcmp (arg, "pedantic-errors"))
4217 flag_pedantic_errors = pedantic = 1;
4218 else if (arg[1] == 0)
4219 profile_flag = 1;
4220 else
4221 return 0;
4222 break;
4224 case 'q':
4225 if (!strcmp (arg, "quiet"))
4226 quiet_flag = 1;
4227 else
4228 return 0;
4229 break;
4231 case 'v':
4232 if (!strcmp (arg, "version"))
4233 version_flag = 1;
4234 else
4235 return 0;
4236 break;
4238 case 'w':
4239 if (arg[1] == 0)
4240 inhibit_warnings = 1;
4241 else
4242 return 0;
4243 break;
4245 case 'W':
4246 if (arg[1] == 0)
4248 extra_warnings = 1;
4249 /* We save the value of warn_uninitialized, since if they put
4250 -Wuninitialized on the command line, we need to generate a
4251 warning about not using it without also specifying -O. */
4252 if (warn_uninitialized != 1)
4253 warn_uninitialized = 2;
4255 else
4256 return decode_W_option (arg + 1);
4257 break;
4259 case 'a':
4260 if (!strncmp (arg, "aux-info", 8))
4262 if (arg[8] == '\0')
4264 if (argc == 1)
4265 return 0;
4267 aux_info_file_name = argv[1];
4268 flag_gen_aux_info = 1;
4269 return 2;
4271 else if (arg[8] == '=')
4273 aux_info_file_name = arg + 9;
4274 flag_gen_aux_info = 1;
4276 else
4277 return 0;
4279 else
4280 return 0;
4281 break;
4283 case 'o':
4284 if (arg[1] == 0)
4286 if (argc == 1)
4287 return 0;
4289 asm_file_name = argv[1];
4290 return 2;
4292 return 0;
4294 case 'G':
4296 int g_switch_val;
4297 int return_val;
4299 if (arg[1] == 0)
4301 if (argc == 1)
4302 return 0;
4304 g_switch_val = read_integral_parameter (argv[1], 0, -1);
4305 return_val = 2;
4307 else
4309 g_switch_val = read_integral_parameter (arg + 1, 0, -1);
4310 return_val = 1;
4313 if (g_switch_val == -1)
4314 return_val = 0;
4315 else
4317 g_switch_set = TRUE;
4318 g_switch_value = g_switch_val;
4321 return return_val;
4325 return 1;
4328 /* Decode -m switches. */
4329 /* Decode the switch -mNAME. */
4331 static void
4332 set_target_switch (name)
4333 const char *name;
4335 size_t j;
4336 int valid_target_option = 0;
4338 for (j = 0; j < ARRAY_SIZE (target_switches); j++)
4339 if (!strcmp (target_switches[j].name, name))
4341 if (target_switches[j].value < 0)
4342 target_flags &= ~-target_switches[j].value;
4343 else
4344 target_flags |= target_switches[j].value;
4345 valid_target_option = 1;
4348 #ifdef TARGET_OPTIONS
4349 if (!valid_target_option)
4350 for (j = 0; j < ARRAY_SIZE (target_options); j++)
4352 int len = strlen (target_options[j].prefix);
4353 if (!strncmp (target_options[j].prefix, name, len))
4355 *target_options[j].variable = name + len;
4356 valid_target_option = 1;
4359 #endif
4361 if (!valid_target_option)
4362 error ("invalid option `%s'", name);
4365 /* Print version information to FILE.
4366 Each line begins with INDENT (for the case where FILE is the
4367 assembler output file). */
4369 static void
4370 print_version (file, indent)
4371 FILE *file;
4372 const char *indent;
4374 #ifndef __VERSION__
4375 #define __VERSION__ "[?]"
4376 #endif
4377 fnotice (file,
4378 #ifdef __GNUC__
4379 "%s%s%s version %s (%s)\n%s\tcompiled by GNU C version %s.\n"
4380 #else
4381 "%s%s%s version %s (%s) compiled by CC.\n"
4382 #endif
4383 , indent, *indent != 0 ? " " : "",
4384 lang_hooks.name, version_string, TARGET_NAME,
4385 indent, __VERSION__);
4388 /* Print an option value and return the adjusted position in the line.
4389 ??? We don't handle error returns from fprintf (disk full); presumably
4390 other code will catch a disk full though. */
4392 static int
4393 print_single_switch (file, pos, max, indent, sep, term, type, name)
4394 FILE *file;
4395 int pos, max;
4396 const char *indent, *sep, *term, *type, *name;
4398 /* The ultrix fprintf returns 0 on success, so compute the result we want
4399 here since we need it for the following test. */
4400 int len = strlen (sep) + strlen (type) + strlen (name);
4402 if (pos != 0
4403 && pos + len > max)
4405 fprintf (file, "%s", term);
4406 pos = 0;
4408 if (pos == 0)
4410 fprintf (file, "%s", indent);
4411 pos = strlen (indent);
4413 fprintf (file, "%s%s%s", sep, type, name);
4414 pos += len;
4415 return pos;
4418 /* Print active target switches to FILE.
4419 POS is the current cursor position and MAX is the size of a "line".
4420 Each line begins with INDENT and ends with TERM.
4421 Each switch is separated from the next by SEP. */
4423 static void
4424 print_switch_values (file, pos, max, indent, sep, term)
4425 FILE *file;
4426 int pos, max;
4427 const char *indent, *sep, *term;
4429 size_t j;
4430 char **p;
4432 /* Print the options as passed. */
4434 pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
4435 _("options passed: "), "");
4437 for (p = &save_argv[1]; *p != NULL; p++)
4438 if (**p == '-')
4440 /* Ignore these. */
4441 if (strcmp (*p, "-o") == 0)
4443 if (p[1] != NULL)
4444 p++;
4445 continue;
4447 if (strcmp (*p, "-quiet") == 0)
4448 continue;
4449 if (strcmp (*p, "-version") == 0)
4450 continue;
4451 if ((*p)[1] == 'd')
4452 continue;
4454 pos = print_single_switch (file, pos, max, indent, sep, term, *p, "");
4456 if (pos > 0)
4457 fprintf (file, "%s", term);
4459 /* Print the -f and -m options that have been enabled.
4460 We don't handle language specific options but printing argv
4461 should suffice. */
4463 pos = print_single_switch (file, 0, max, indent, *indent ? " " : "", term,
4464 _("options enabled: "), "");
4466 for (j = 0; j < ARRAY_SIZE (f_options); j++)
4467 if (*f_options[j].variable == f_options[j].on_value)
4468 pos = print_single_switch (file, pos, max, indent, sep, term,
4469 "-f", f_options[j].string);
4471 /* Print target specific options. */
4473 for (j = 0; j < ARRAY_SIZE (target_switches); j++)
4474 if (target_switches[j].name[0] != '\0'
4475 && target_switches[j].value > 0
4476 && ((target_switches[j].value & target_flags)
4477 == target_switches[j].value))
4479 pos = print_single_switch (file, pos, max, indent, sep, term,
4480 "-m", target_switches[j].name);
4483 #ifdef TARGET_OPTIONS
4484 for (j = 0; j < ARRAY_SIZE (target_options); j++)
4485 if (*target_options[j].variable != NULL)
4487 char prefix[256];
4488 sprintf (prefix, "-m%s", target_options[j].prefix);
4489 pos = print_single_switch (file, pos, max, indent, sep, term,
4490 prefix, *target_options[j].variable);
4492 #endif
4494 fprintf (file, "%s", term);
4497 /* Open assembly code output file. Do this even if -fsyntax-only is
4498 on, because then the driver will have provided the name of a
4499 temporary file or bit bucket for us. NAME is the file specified on
4500 the command line, possibly NULL. */
4501 static void
4502 init_asm_output (name)
4503 const char *name;
4505 if (name == NULL && asm_file_name == 0)
4506 asm_out_file = stdout;
4507 else
4509 if (asm_file_name == 0)
4511 int len = strlen (dump_base_name);
4512 char *dumpname = (char *) xmalloc (len + 6);
4513 memcpy (dumpname, dump_base_name, len + 1);
4514 strip_off_ending (dumpname, len);
4515 strcat (dumpname, ".s");
4516 asm_file_name = dumpname;
4518 if (!strcmp (asm_file_name, "-"))
4519 asm_out_file = stdout;
4520 else
4521 asm_out_file = fopen (asm_file_name, "w");
4522 if (asm_out_file == 0)
4523 fatal_io_error ("can't open %s for writing", asm_file_name);
4526 #ifdef IO_BUFFER_SIZE
4527 setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
4528 _IOFBF, IO_BUFFER_SIZE);
4529 #endif
4531 if (!flag_syntax_only)
4533 #ifdef ASM_FILE_START
4534 ASM_FILE_START (asm_out_file);
4535 #endif
4537 #ifdef ASM_COMMENT_START
4538 if (flag_verbose_asm)
4540 /* Print the list of options in effect. */
4541 print_version (asm_out_file, ASM_COMMENT_START);
4542 print_switch_values (asm_out_file, 0, MAX_LINE,
4543 ASM_COMMENT_START, " ", "\n");
4544 /* Add a blank line here so it appears in assembler output but not
4545 screen output. */
4546 fprintf (asm_out_file, "\n");
4548 #endif
4552 /* Initialization of the front end environment, before command line
4553 options are parsed. Signal handlers, internationalization etc.
4554 ARGV0 is main's argv[0]. */
4555 static void
4556 general_init (argv0)
4557 char *argv0;
4559 char *p;
4561 p = argv0 + strlen (argv0);
4562 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
4563 --p;
4564 progname = p;
4566 xmalloc_set_program_name (progname);
4568 gcc_init_libintl ();
4570 /* Install handler for SIGFPE, which may be received while we do
4571 compile-time floating point arithmetic. */
4572 signal (SIGFPE, float_signal);
4574 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
4575 #ifdef SIGSEGV
4576 signal (SIGSEGV, crash_signal);
4577 #endif
4578 #ifdef SIGILL
4579 signal (SIGILL, crash_signal);
4580 #endif
4581 #ifdef SIGBUS
4582 signal (SIGBUS, crash_signal);
4583 #endif
4584 #ifdef SIGABRT
4585 signal (SIGABRT, crash_signal);
4586 #endif
4587 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
4588 signal (SIGIOT, crash_signal);
4589 #endif
4591 /* Initialize the diagnostics reporting machinery, so option parsing
4592 can give warnings and errors. */
4593 diagnostic_initialize (global_dc);
4596 /* Parse command line options and set default flag values, called
4597 after language-independent option-independent initialization. Do
4598 minimal options processing. Outputting diagnostics is OK, but GC
4599 and identifier hashtables etc. are not initialized yet. */
4600 static void
4601 parse_options_and_default_flags (argc, argv)
4602 int argc;
4603 char **argv;
4605 int i;
4607 /* Save in case md file wants to emit args as a comment. */
4608 save_argc = argc;
4609 save_argv = argv;
4611 /* Initialize register usage now so switches may override. */
4612 init_reg_sets ();
4614 /* Register the language-independent parameters. */
4615 add_params (lang_independent_params, LAST_PARAM);
4617 /* Perform language-specific options initialization. */
4618 (*lang_hooks.init_options) ();
4620 /* Scan to see what optimization level has been specified. That will
4621 determine the default value of many flags. */
4622 for (i = 1; i < argc; i++)
4624 if (!strcmp (argv[i], "-O"))
4626 optimize = 1;
4627 optimize_size = 0;
4629 else if (argv[i][0] == '-' && argv[i][1] == 'O')
4631 /* Handle -Os, -O2, -O3, -O69, ... */
4632 char *p = &argv[i][2];
4634 if ((p[0] == 's') && (p[1] == 0))
4636 optimize_size = 1;
4638 /* Optimizing for size forces optimize to be 2. */
4639 optimize = 2;
4641 else
4643 const int optimize_val = read_integral_parameter (p, p - 2, -1);
4644 if (optimize_val != -1)
4646 optimize = optimize_val;
4647 optimize_size = 0;
4653 if (!optimize)
4655 flag_merge_constants = 0;
4658 if (optimize >= 1)
4660 flag_defer_pop = 1;
4661 flag_thread_jumps = 1;
4662 #ifdef DELAY_SLOTS
4663 flag_delayed_branch = 1;
4664 #endif
4665 #ifdef CAN_DEBUG_WITHOUT_FP
4666 flag_omit_frame_pointer = 1;
4667 #endif
4668 flag_guess_branch_prob = 1;
4669 flag_cprop_registers = 1;
4672 if (optimize >= 2)
4674 flag_optimize_sibling_calls = 1;
4675 flag_cse_follow_jumps = 1;
4676 flag_cse_skip_blocks = 1;
4677 flag_gcse = 1;
4678 flag_expensive_optimizations = 1;
4679 flag_strength_reduce = 1;
4680 flag_rerun_cse_after_loop = 1;
4681 flag_rerun_loop_opt = 1;
4682 flag_caller_saves = 1;
4683 flag_force_mem = 1;
4684 flag_peephole2 = 1;
4685 #ifdef INSN_SCHEDULING
4686 flag_schedule_insns = 1;
4687 flag_schedule_insns_after_reload = 1;
4688 #endif
4689 flag_regmove = 1;
4690 flag_strict_aliasing = 1;
4691 flag_delete_null_pointer_checks = 1;
4692 flag_reorder_blocks = 1;
4695 if (optimize >= 3)
4697 flag_inline_functions = 1;
4698 flag_rename_registers = 1;
4701 if (optimize < 2 || optimize_size)
4703 align_loops = 1;
4704 align_jumps = 1;
4705 align_labels = 1;
4706 align_functions = 1;
4709 /* Initialize whether `char' is signed. */
4710 flag_signed_char = DEFAULT_SIGNED_CHAR;
4711 #ifdef DEFAULT_SHORT_ENUMS
4712 /* Initialize how much space enums occupy, by default. */
4713 flag_short_enums = DEFAULT_SHORT_ENUMS;
4714 #endif
4716 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
4717 modify it. */
4718 target_flags = 0;
4719 set_target_switch ("");
4721 /* Unwind tables are always present in an ABI-conformant IA-64
4722 object file, so the default should be ON. */
4723 #ifdef IA64_UNWIND_INFO
4724 flag_unwind_tables = IA64_UNWIND_INFO;
4725 #endif
4727 #ifdef OPTIMIZATION_OPTIONS
4728 /* Allow default optimizations to be specified on a per-machine basis. */
4729 OPTIMIZATION_OPTIONS (optimize, optimize_size);
4730 #endif
4732 /* Perform normal command line switch decoding. */
4733 for (i = 1; i < argc;)
4735 int lang_processed;
4736 int indep_processed;
4738 /* Give the language a chance to decode the option for itself. */
4739 lang_processed = (*lang_hooks.decode_option) (argc - i, argv + i);
4741 if (lang_processed >= 0)
4742 /* Now see if the option also has a language independent meaning.
4743 Some options are both language specific and language independent,
4744 eg --help. */
4745 indep_processed = independent_decode_option (argc - i, argv + i);
4746 else
4748 lang_processed = -lang_processed;
4749 indep_processed = 0;
4752 if (lang_processed || indep_processed)
4753 i += MAX (lang_processed, indep_processed);
4754 else
4756 const char *option = NULL;
4757 const char *lang = NULL;
4758 unsigned int j;
4760 /* It is possible that the command line switch is not valid for the
4761 current language, but it is valid for another language. In order
4762 to be compatible with previous versions of the compiler (which
4763 did not issue an error message in this case) we check for this
4764 possibility here. If we do find a match, then if extra_warnings
4765 is set we generate a warning message, otherwise we will just
4766 ignore the option. */
4767 for (j = 0; j < ARRAY_SIZE (documented_lang_options); j++)
4769 option = documented_lang_options[j].option;
4771 if (option == NULL)
4772 lang = documented_lang_options[j].description;
4773 else if (! strncmp (argv[i], option, strlen (option)))
4774 break;
4777 if (j != ARRAY_SIZE (documented_lang_options))
4779 if (extra_warnings)
4781 warning ("ignoring command line option '%s'", argv[i]);
4782 if (lang)
4783 warning
4784 ("(it is valid for %s but not the selected language)",
4785 lang);
4788 else if (argv[i][0] == '-' && argv[i][1] == 'g')
4789 warning ("`%s': unknown or unsupported -g option", &argv[i][2]);
4790 else
4791 error ("unrecognized option `%s'", argv[i]);
4793 i++;
4797 /* Set flag_no_inline before the post_options () hook. The C front
4798 ends use it to determine tree inlining defaults. FIXME: such
4799 code should be lang-independent when all front ends use tree
4800 inlining, in which case it, and this condition, should be moved
4801 to the top of process_options() instead. */
4802 if (optimize == 0)
4804 /* Inlining does not work if not optimizing,
4805 so force it not to be done. */
4806 flag_no_inline = 1;
4807 warn_inline = 0;
4809 /* The c_decode_option function and decode_option hook set
4810 this to `2' if -Wall is used, so we can avoid giving out
4811 lots of errors for people who don't realize what -Wall does. */
4812 if (warn_uninitialized == 1)
4813 warning ("-Wuninitialized is not supported without -O");
4816 /* All command line options have been parsed; allow the front end to
4817 perform consistency checks, etc. */
4818 (*lang_hooks.post_options) ();
4821 /* Process the options that have been parsed. */
4822 static void
4823 process_options ()
4825 #ifdef OVERRIDE_OPTIONS
4826 /* Some machines may reject certain combinations of options. */
4827 OVERRIDE_OPTIONS;
4828 #endif
4830 /* Set up the align_*_log variables, defaulting them to 1 if they
4831 were still unset. */
4832 if (align_loops <= 0) align_loops = 1;
4833 if (align_loops_max_skip > align_loops || !align_loops)
4834 align_loops_max_skip = align_loops - 1;
4835 align_loops_log = floor_log2 (align_loops * 2 - 1);
4836 if (align_jumps <= 0) align_jumps = 1;
4837 if (align_jumps_max_skip > align_jumps || !align_jumps)
4838 align_jumps_max_skip = align_jumps - 1;
4839 align_jumps_log = floor_log2 (align_jumps * 2 - 1);
4840 if (align_labels <= 0) align_labels = 1;
4841 align_labels_log = floor_log2 (align_labels * 2 - 1);
4842 if (align_labels_max_skip > align_labels || !align_labels)
4843 align_labels_max_skip = align_labels - 1;
4844 if (align_functions <= 0) align_functions = 1;
4845 align_functions_log = floor_log2 (align_functions * 2 - 1);
4847 /* Unrolling all loops implies that standard loop unrolling must also
4848 be done. */
4849 if (flag_unroll_all_loops)
4850 flag_unroll_loops = 1;
4851 /* Loop unrolling requires that strength_reduction be on also. Silently
4852 turn on strength reduction here if it isn't already on. Also, the loop
4853 unrolling code assumes that cse will be run after loop, so that must
4854 be turned on also. */
4855 if (flag_unroll_loops)
4857 flag_strength_reduce = 1;
4858 flag_rerun_cse_after_loop = 1;
4861 if (flag_non_call_exceptions)
4862 flag_asynchronous_unwind_tables = 1;
4863 if (flag_asynchronous_unwind_tables)
4864 flag_unwind_tables = 1;
4866 /* Warn about options that are not supported on this machine. */
4867 #ifndef INSN_SCHEDULING
4868 if (flag_schedule_insns || flag_schedule_insns_after_reload)
4869 warning ("instruction scheduling not supported on this target machine");
4870 #endif
4871 #ifndef DELAY_SLOTS
4872 if (flag_delayed_branch)
4873 warning ("this target machine does not have delayed branches");
4874 #endif
4876 /* Some operating systems do not allow profiling without a frame
4877 pointer. */
4878 if (!TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER
4879 && profile_flag
4880 && flag_omit_frame_pointer)
4882 error ("profiling does not work without a frame pointer");
4883 flag_omit_frame_pointer = 0;
4886 user_label_prefix = USER_LABEL_PREFIX;
4887 if (flag_leading_underscore != -1)
4889 /* If the default prefix is more complicated than "" or "_",
4890 issue a warning and ignore this option. */
4891 if (user_label_prefix[0] == 0 ||
4892 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
4894 user_label_prefix = flag_leading_underscore ? "_" : "";
4896 else
4897 warning ("-f%sleading-underscore not supported on this target machine",
4898 flag_leading_underscore ? "" : "no-");
4901 /* If we are in verbose mode, write out the version and maybe all the
4902 option flags in use. */
4903 if (version_flag)
4905 print_version (stderr, "");
4906 if (! quiet_flag)
4907 print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
4910 if (! quiet_flag)
4911 time_report = 1;
4913 if (flag_syntax_only)
4915 write_symbols = NO_DEBUG;
4916 profile_flag = 0;
4919 /* Now we know write_symbols, set up the debug hooks based on it.
4920 By default we do nothing for debug output. */
4921 #if defined(DBX_DEBUGGING_INFO)
4922 if (write_symbols == DBX_DEBUG)
4923 debug_hooks = &dbx_debug_hooks;
4924 #endif
4925 #if defined(XCOFF_DEBUGGING_INFO)
4926 if (write_symbols == XCOFF_DEBUG)
4927 debug_hooks = &xcoff_debug_hooks;
4928 #endif
4929 #ifdef SDB_DEBUGGING_INFO
4930 if (write_symbols == SDB_DEBUG)
4931 debug_hooks = &sdb_debug_hooks;
4932 #endif
4933 #ifdef DWARF_DEBUGGING_INFO
4934 if (write_symbols == DWARF_DEBUG)
4935 debug_hooks = &dwarf_debug_hooks;
4936 #endif
4937 #ifdef DWARF2_DEBUGGING_INFO
4938 if (write_symbols == DWARF2_DEBUG)
4939 debug_hooks = &dwarf2_debug_hooks;
4940 #endif
4941 #ifdef VMS_DEBUGGING_INFO
4942 if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
4943 debug_hooks = &vmsdbg_debug_hooks;
4944 #endif
4946 /* If auxiliary info generation is desired, open the output file.
4947 This goes in the same directory as the source file--unlike
4948 all the other output files. */
4949 if (flag_gen_aux_info)
4951 aux_info_file = fopen (aux_info_file_name, "w");
4952 if (aux_info_file == 0)
4953 fatal_io_error ("can't open %s", aux_info_file_name);
4956 if (! targetm.have_named_sections)
4958 if (flag_function_sections)
4960 warning ("-ffunction-sections not supported for this target");
4961 flag_function_sections = 0;
4963 if (flag_data_sections)
4965 warning ("-fdata-sections not supported for this target");
4966 flag_data_sections = 0;
4970 if (flag_function_sections && profile_flag)
4972 warning ("-ffunction-sections disabled; it makes profiling impossible");
4973 flag_function_sections = 0;
4976 #ifndef HAVE_prefetch
4977 if (flag_prefetch_loop_arrays)
4979 warning ("-fprefetch-loop-arrays not supported for this target");
4980 flag_prefetch_loop_arrays = 0;
4982 #else
4983 if (flag_prefetch_loop_arrays && !HAVE_prefetch)
4985 warning ("-fprefetch-loop-arrays not supported for this target (try -march switches)");
4986 flag_prefetch_loop_arrays = 0;
4988 #endif
4990 #ifndef OBJECT_FORMAT_ELF
4991 if (flag_function_sections && write_symbols != NO_DEBUG)
4992 warning ("-ffunction-sections may affect debugging on some targets");
4993 #endif
4996 /* Language-independent initialization, before language-dependent
4997 initialization. */
4998 static void
4999 lang_independent_init ()
5001 decl_printable_name = decl_name;
5002 lang_expand_expr = (lang_expand_expr_t) do_abort;
5004 /* Set the language-dependent identifier size. */
5005 tree_code_length[(int) IDENTIFIER_NODE]
5006 = ((lang_hooks.identifier_size - sizeof (struct tree_common))
5007 / sizeof (tree));
5009 /* Initialize the garbage-collector, and string pools. */
5010 init_ggc ();
5011 ggc_add_rtx_root (&stack_limit_rtx, 1);
5012 ggc_add_tree_root (&current_function_decl, 1);
5013 ggc_add_tree_root (&current_function_func_begin_label, 1);
5015 init_stringpool ();
5016 init_obstacks ();
5018 init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
5019 || debug_info_level == DINFO_LEVEL_VERBOSE
5020 #ifdef VMS_DEBUGGING_INFO
5021 /* Enable line number info for traceback */
5022 || debug_info_level > DINFO_LEVEL_NONE
5023 #endif
5024 || flag_test_coverage
5025 || warn_notreached);
5026 init_regs ();
5027 init_alias_once ();
5028 init_stmt ();
5029 init_loop ();
5030 init_reload ();
5031 init_function_once ();
5032 init_stor_layout_once ();
5033 init_varasm_once ();
5034 init_EXPR_INSN_LIST_cache ();
5036 /* The following initialization functions need to generate rtl, so
5037 provide a dummy function context for them. */
5038 init_dummy_function_start ();
5039 init_expmed ();
5040 init_expr_once ();
5041 if (flag_caller_saves)
5042 init_caller_save ();
5043 expand_dummy_function_end ();
5046 /* Language-dependent initialization. Returns non-zero on success. */
5047 static int
5048 lang_dependent_init (name)
5049 const char *name;
5051 if (dump_base_name == 0)
5052 dump_base_name = name ? name : "gccdump";
5054 /* Front-end initialization. This hook can assume that GC,
5055 identifier hashes etc. are set up, but debug initialization is
5056 not done yet. This routine must return the original filename
5057 (e.g. foo.i -> foo.c) so can correctly initialize debug output. */
5058 name = (*lang_hooks.init) (name);
5059 if (name == NULL)
5060 return 0;
5062 /* Is this duplication necessary? */
5063 name = ggc_strdup (name);
5064 main_input_filename = input_filename = name;
5065 init_asm_output (name);
5067 /* These create various _DECL nodes, so need to be called after the
5068 front end is initialized. */
5069 init_eh ();
5070 init_optabs ();
5072 /* Put an entry on the input file stack for the main input file. */
5073 push_srcloc (input_filename, 0);
5075 /* If dbx symbol table desired, initialize writing it and output the
5076 predefined types. */
5077 timevar_push (TV_SYMOUT);
5079 #ifdef DWARF2_UNWIND_INFO
5080 if (dwarf2out_do_frame ())
5081 dwarf2out_frame_init ();
5082 #endif
5084 /* Now we have the correct original filename, we can initialize
5085 debug output. */
5086 (*debug_hooks->init) (name);
5088 timevar_pop (TV_SYMOUT);
5090 return 1;
5093 /* Clean up: close opened files, etc. */
5095 static void
5096 finalize ()
5098 /* Close the dump files. */
5099 if (flag_gen_aux_info)
5101 fclose (aux_info_file);
5102 if (errorcount)
5103 unlink (aux_info_file_name);
5106 /* Close non-debugging input and output files. Take special care to note
5107 whether fclose returns an error, since the pages might still be on the
5108 buffer chain while the file is open. */
5110 if (asm_out_file)
5112 if (ferror (asm_out_file) != 0)
5113 fatal_io_error ("error writing to %s", asm_file_name);
5114 if (fclose (asm_out_file) != 0)
5115 fatal_io_error ("error closing %s", asm_file_name);
5118 /* Do whatever is necessary to finish printing the graphs. */
5119 if (graph_dump_format != no_graph)
5121 int i;
5123 for (i = 0; i < (int) DFI_MAX; ++i)
5124 if (dump_file[i].initialized && dump_file[i].graph_dump_p)
5126 char seq[16];
5127 char *suffix;
5129 sprintf (seq, DUMPFILE_FORMAT, i);
5130 suffix = concat (seq, dump_file[i].extension, NULL);
5131 finish_graph_dump_file (dump_base_name, suffix);
5132 free (suffix);
5136 if (mem_report)
5138 ggc_print_statistics ();
5139 stringpool_statistics ();
5140 dump_tree_statistics ();
5143 /* Free up memory for the benefit of leak detectors. */
5144 free_reg_info ();
5146 /* Language-specific end of compilation actions. */
5147 (*lang_hooks.finish) ();
5150 /* Initialize the compiler, and compile the input file. */
5151 static void
5152 do_compile ()
5154 /* The bulk of command line switch processing. */
5155 process_options ();
5157 /* We cannot start timing until after options are processed since that
5158 says if we run timers or not. */
5159 init_timevar ();
5160 timevar_start (TV_TOTAL);
5162 /* Language-independent initialization. Also sets up GC, identifier
5163 hashes etc. */
5164 lang_independent_init ();
5166 /* Language-dependent initialization. Returns true on success. */
5167 if (lang_dependent_init (filename))
5168 compile_file ();
5170 finalize ();
5172 /* Stop timing and print the times. */
5173 timevar_stop (TV_TOTAL);
5174 timevar_print (stderr);
5177 /* Entry point of cc1, cc1plus, jc1, f771, etc.
5178 Decode command args, then call compile_file.
5179 Exit code is FATAL_EXIT_CODE if can't open files or if there were
5180 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
5182 It is not safe to call this function more than once. */
5185 toplev_main (argc, argv)
5186 int argc;
5187 char **argv;
5189 hex_init ();
5191 /* Initialization of GCC's environment, and diagnostics. */
5192 general_init (argv [0]);
5194 /* Parse the options and do minimal processing; basically just
5195 enough to default flags appropriately. */
5196 parse_options_and_default_flags (argc, argv);
5198 /* Exit early if we can (e.g. -help). */
5199 if (!exit_after_options)
5200 do_compile ();
5202 if (errorcount || sorrycount)
5203 return (FATAL_EXIT_CODE);
5205 return (SUCCESS_EXIT_CODE);