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, 2003 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
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
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
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. */
28 #undef FLOAT /* This is for hpux. They should change hpux. */
29 #undef FFS /* Some systems define this in param.h. */
31 #include "coretypes.h"
35 #ifdef HAVE_SYS_RESOURCE_H
36 # include <sys/resource.h>
39 #ifdef HAVE_SYS_TIMES_H
40 # include <sys/times.h>
48 #include "insn-attr.h"
49 #include "insn-config.h"
50 #include "insn-flags.h"
51 #include "hard-reg-set.h"
58 #include "basic-block.h"
65 #include "diagnostic.h"
69 #include "dwarf2asm.h"
70 #include "integrate.h"
74 #include "langhooks.h"
75 #include "cfglayout.h"
77 #include "hosthooks.h"
79 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
80 #include "dwarf2out.h"
83 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
87 #ifdef SDB_DEBUGGING_INFO
91 #ifdef XCOFF_DEBUGGING_INFO
92 #include "xcoffout.h" /* Needed for external data
93 declarations for e.g. AIX 4.x. */
96 /* Carry information from ASM_DECLARE_OBJECT_NAME
97 to ASM_FINISH_DECLARE_OBJECT. */
99 extern int size_directive_output;
100 extern tree last_assemble_variable_decl;
102 extern void reg_alloc PARAMS ((void));
104 static void general_init PARAMS ((char *));
105 static void parse_options_and_default_flags PARAMS ((int, char **));
106 static void do_compile PARAMS ((void));
107 static void process_options PARAMS ((void));
108 static void backend_init PARAMS ((void));
109 static int lang_dependent_init PARAMS ((const char *));
110 static void init_asm_output PARAMS ((const char *));
111 static void finalize PARAMS ((void));
113 static void set_target_switch PARAMS ((const char *));
115 static void crash_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
116 static void setup_core_dumping PARAMS ((void));
117 static void compile_file PARAMS ((void));
118 static void display_help PARAMS ((void));
119 static void display_target_options PARAMS ((void));
121 static void decode_d_option PARAMS ((const char *));
122 static int decode_f_option PARAMS ((const char *));
123 static int decode_W_option PARAMS ((const char *));
124 static int decode_g_option PARAMS ((const char *));
125 static unsigned int independent_decode_option PARAMS ((int, char **));
127 static void print_version PARAMS ((FILE *, const char *));
128 static int print_single_switch PARAMS ((FILE *, int, int, const char *,
129 const char *, const char *,
130 const char *, const char *));
131 static void print_switch_values PARAMS ((FILE *, int, int, const char *,
132 const char *, const char *));
134 /* Nonzero to dump debug info whilst parsing (-dy option). */
135 static int set_yydebug;
137 /* Length of line when printing switch values. */
140 /* Name of program invoked, sans directories. */
142 const char *progname;
144 /* Copy of arguments to toplev_main. */
148 /* Name of current original source file (what was input to cpp).
149 This comes from each #-command in the actual input. */
151 const char *input_filename;
153 /* Name of top-level original source file (what was input to cpp).
154 This comes from the #-command at the beginning of the actual input.
155 If there isn't any there, then this is the cc1 input file name. */
157 const char *main_input_filename;
159 /* Current line number in real source file. */
163 /* Nonzero if it is unsafe to create any new pseudo registers. */
166 /* Stack of currently pending input files. */
168 struct file_stack *input_file_stack;
170 /* Incremented on each change to input_file_stack. */
171 int input_file_stack_tick;
173 /* Name to use as base of names for dump output files. */
175 const char *dump_base_name;
177 /* Name to use as a base for auxiliary output files. */
179 const char *aux_base_name;
181 /* Format to use to print dumpfile index value */
182 #ifndef DUMPFILE_FORMAT
183 #define DUMPFILE_FORMAT ".%02d."
186 /* Bit flags that specify the machine subtype we are compiling for.
187 Bits are tested using macros TARGET_... defined in the tm.h file
188 and set by `-m...' switches. Must be defined in rtlanal.c. */
190 extern int target_flags;
192 /* A mask of target_flags that includes bit X if X was set or cleared
193 on the command line. */
195 int target_flags_explicit;
197 /* Debug hooks - dependent upon command line options. */
199 const struct gcc_debug_hooks *debug_hooks = &do_nothing_debug_hooks;
201 /* Describes a dump file. */
203 struct dump_file_info
205 /* The unique extension to apply, e.g. ".jump". */
206 const char *const extension;
208 /* The -d<c> character that enables this dump file. */
209 char const debug_switch;
211 /* True if there is a corresponding graph dump file. */
212 char const graph_dump_p;
214 /* True if the user selected this dump. */
217 /* True if the files have been initialized (ie truncated). */
221 /* Enumerate the extant dump files. */
265 /* Describes all the dump files. Should be kept in order of the
266 pass and in sync with dump_file_index above.
268 Remaining -d letters:
274 static struct dump_file_info dump_file[DFI_MAX] =
276 { "rtl", 'r', 0, 0, 0 },
277 { "sibling", 'i', 0, 0, 0 },
278 { "eh", 'h', 0, 0, 0 },
279 { "jump", 'j', 0, 0, 0 },
280 { "ssa", 'e', 1, 0, 0 },
281 { "ssaccp", 'W', 1, 0, 0 },
282 { "ssadce", 'X', 1, 0, 0 },
283 { "ussa", 'e', 1, 0, 0 }, /* Yes, duplicate enable switch. */
284 { "null", 'u', 0, 0, 0 },
285 { "cse", 's', 0, 0, 0 },
286 { "addressof", 'F', 0, 0, 0 },
287 { "gcse", 'G', 1, 0, 0 },
288 { "loop", 'L', 1, 0, 0 },
289 { "bypass", 'G', 1, 0, 0 }, /* Yes, duplicate enable switch. */
290 { "cfg", 'f', 1, 0, 0 },
291 { "bp", 'b', 1, 0, 0 },
292 { "ce1", 'C', 1, 0, 0 },
293 { "tracer", 'T', 1, 0, 0 },
294 { "loop2", 'L', 1, 0, 0 },
295 { "cse2", 't', 1, 0, 0 },
296 { "life", 'f', 1, 0, 0 }, /* Yes, duplicate enable switch. */
297 { "combine", 'c', 1, 0, 0 },
298 { "ce2", '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 { "ce3", '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. */
331 /* Value of the -G xx switch, and whether it was passed or not. */
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. */
359 /* Nonzero means optimize for size. -Os.
360 The only valid values are zero and nonzero. When optimize_size is
361 nonzero, 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
375 tree current_function_func_begin_label;
377 /* Nonzero if doing dwarf2 duplicate elimination. */
379 int flag_eliminate_dwarf2_dups = 0;
381 /* Nonzero if generating code to do profiling. */
383 int profile_flag = 0;
385 /* Nonzero if generating code to profile program flow graph arcs. */
387 int profile_arc_flag = 0;
389 /* Nonzero if generating info for gcov to calculate line test coverage. */
391 int flag_test_coverage = 0;
393 /* Nonzero indicates that branch taken probabilities should be calculated. */
395 int flag_branch_probabilities = 0;
397 /* Nonzero if basic blocks should be reordered. */
399 int flag_reorder_blocks = 0;
401 /* Nonzero if functions should be reordered. */
403 int flag_reorder_functions = 0;
405 /* Nonzero if registers should be renamed. */
407 int flag_rename_registers = 0;
408 int flag_cprop_registers = 0;
410 /* Nonzero for -pedantic switch: warn about anything
411 that standard spec forbids. */
415 /* Temporarily suppress certain warnings.
416 This is set while reading code from a system header file. */
418 int in_system_header = 0;
420 /* Don't print functions as they are compiled. -quiet. */
424 /* Print times taken by the various passes. -ftime-report. */
428 /* Print memory still in use at end of compilation (which may have little
429 to do with peak memory consumption). -fmem-report. */
433 /* Nonzero means to collect statistics which might be expensive
434 and to print them when we are done. */
435 int flag_detailed_statistics = 0;
440 /* Nonzero means `char' should be signed. */
442 int flag_signed_char;
444 /* Nonzero means give an enum type only as many bytes as it needs. */
446 int flag_short_enums;
448 /* Nonzero for -fcaller-saves: allocate values in regs that need to
449 be saved across function calls, if that produces overall better code.
450 Optional now, so people can test it. */
452 #ifdef DEFAULT_CALLER_SAVES
453 int flag_caller_saves = 1;
455 int flag_caller_saves = 0;
458 /* Nonzero if structures and unions should be returned in memory.
460 This should only be defined if compatibility with another compiler or
461 with an ABI is needed, because it results in slower code. */
463 #ifndef DEFAULT_PCC_STRUCT_RETURN
464 #define DEFAULT_PCC_STRUCT_RETURN 1
467 /* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
469 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
471 /* Nonzero for -fforce-mem: load memory value into a register
472 before arithmetic on it. This makes better cse but slower compilation. */
474 int flag_force_mem = 0;
476 /* Nonzero for -fforce-addr: load memory address into a register before
477 reference to memory. This makes better cse but slower compilation. */
479 int flag_force_addr = 0;
481 /* Nonzero for -fdefer-pop: don't pop args after each function call;
482 instead save them up to pop many calls' args with one insns. */
484 int flag_defer_pop = 0;
486 /* Nonzero for -ffloat-store: don't allocate floats and doubles
487 in extended-precision registers. */
489 int flag_float_store = 0;
491 /* Nonzero for -fcse-follow-jumps:
492 have cse follow jumps to do a more extensive job. */
494 int flag_cse_follow_jumps;
496 /* Nonzero for -fcse-skip-blocks:
497 have cse follow a branch around a block. */
498 int flag_cse_skip_blocks;
500 /* Nonzero for -fexpensive-optimizations:
501 perform miscellaneous relatively-expensive optimizations. */
502 int flag_expensive_optimizations;
504 /* Nonzero for -fthread-jumps:
505 have jump optimize output of loop. */
507 int flag_thread_jumps;
509 /* Nonzero enables strength-reduction in loop.c. */
511 int flag_strength_reduce = 0;
513 /* Nonzero enables loop unrolling in unroll.c. Only loops for which the
514 number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
515 UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
518 int flag_unroll_loops;
520 /* Nonzero enables loop unrolling in unroll.c. All loops are unrolled.
521 This is generally not a win. */
523 int flag_unroll_all_loops;
525 /* Nonzero enables loop unswitching. */
526 int flag_unswitch_loops;
528 /* Nonzero enables prefetch optimizations for arrays in loops. */
530 int flag_prefetch_loop_arrays;
532 /* Nonzero forces all invariant computations in loops to be moved
535 int flag_move_all_movables = 0;
537 /* Nonzero forces all general induction variables in loops to be
540 int flag_reduce_all_givs = 0;
542 /* Nonzero to perform full register move optimization passes. This is the
545 int flag_regmove = 0;
547 /* Nonzero for -fwritable-strings:
548 store string constants in data segment and don't uniquize them. */
550 int flag_writable_strings = 0;
552 /* Nonzero means don't put addresses of constant functions in registers.
553 Used for compiling the Unix kernel, where strange substitutions are
554 done on the assembly output. */
556 int flag_no_function_cse = 0;
558 /* Nonzero for -fomit-frame-pointer:
559 don't make a frame pointer in simple functions that don't require one. */
561 int flag_omit_frame_pointer = 0;
563 /* Nonzero means place each function into its own section on those platforms
564 which support arbitrary section names and unlimited numbers of sections. */
566 int flag_function_sections = 0;
568 /* ... and similar for data. */
570 int flag_data_sections = 0;
572 /* Nonzero to inhibit use of define_optimization peephole opts. */
574 int flag_no_peephole = 0;
576 /* Nonzero allows GCC to optimize sibling and tail recursive calls. */
578 int flag_optimize_sibling_calls = 0;
580 /* Nonzero means the front end generally wants `errno' maintained by math
581 operations, like built-in SQRT. */
583 int flag_errno_math = 1;
585 /* Nonzero means that unsafe floating-point math optimizations are allowed
586 for the sake of speed. IEEE compliance is not guaranteed, and operations
587 are allowed to assume that their arguments and results are "normal"
588 (e.g., nonnegative for SQRT). */
590 int flag_unsafe_math_optimizations = 0;
592 /* Nonzero means that no NaNs or +-Infs are expected. */
594 int flag_finite_math_only = 0;
596 /* Zero means that floating-point math operations cannot generate a
597 (user-visible) trap. This is the case, for example, in nonstop
598 IEEE 754 arithmetic. Trapping conditions include division by zero,
599 overflow, underflow, invalid and inexact, but does not include
600 operations on signaling NaNs (see below). */
602 int flag_trapping_math = 1;
604 /* Nonzero means disable transformations observable by signaling NaNs.
605 This option implies that any operation on a IEEE signaling NaN can
606 generate a (user-visible) trap. */
608 int flag_signaling_nans = 0;
610 /* 0 means straightforward implementation of complex divide acceptable.
611 1 means wide ranges of inputs must work for complex divide.
612 2 means C99-like requirements for complex divide (not yet implemented). */
614 int flag_complex_divide_method = 0;
616 /* Nonzero means just do syntax checking; don't output anything. */
618 int flag_syntax_only = 0;
620 /* Nonzero means perform loop optimizer. */
622 static int flag_loop_optimize;
624 /* Nonzero means perform crossjumping. */
626 static int flag_crossjumping;
628 /* Nonzero means perform if conversion. */
630 static int flag_if_conversion;
632 /* Nonzero means perform if conversion after reload. */
634 static int flag_if_conversion2;
636 /* Nonzero means to use global dataflow analysis to eliminate
637 useless null pointer tests. */
639 static int flag_delete_null_pointer_checks;
641 /* Nonzero means perform global CSE. */
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
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
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
675 int flag_keep_inline_functions;
677 /* Nonzero means that functions will not be inlined. */
679 int flag_no_inline = 2;
681 /* Nonzero means that we don't want inlining by virtue of -fno-inline,
682 not just because the tree inliner turned us off. */
684 int flag_really_no_inline = 2;
686 /* Nonzero means that we should emit static const variables
687 regardless of whether or not optimization is turned on. */
689 int flag_keep_static_consts = 1;
691 /* Nonzero means we should be saving declaration info into a .X file. */
693 int flag_gen_aux_info = 0;
695 /* Specified name of aux-info file. */
697 static char *aux_info_file_name;
699 /* Nonzero means make the text shared if supported. */
701 int flag_shared_data;
703 /* Nonzero means schedule into delayed branch slots if supported. */
705 int flag_delayed_branch;
707 /* Nonzero if we are compiling pure (sharable) code.
708 Value is 1 if we are doing "small" pic; value is 2 if we're doing
713 /* Set to the default thread-local storage (tls) model to use. */
715 enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
717 /* Nonzero means generate extra code for exception handling and enable
718 exception handling. */
722 /* Nonzero means generate frame unwind info table when supported. */
724 int flag_unwind_tables = 0;
726 /* Nonzero means generate frame unwind info table exact at each insn boundary */
728 int flag_asynchronous_unwind_tables = 0;
730 /* Nonzero means don't place uninitialized global data in common storage
735 /* Nonzero means change certain warnings into errors.
736 Usually these are warnings about failure to conform to some standard. */
738 int flag_pedantic_errors = 0;
740 /* flag_schedule_insns means schedule insns within basic blocks (before
742 flag_schedule_insns_after_reload means schedule insns after
745 int flag_schedule_insns = 0;
746 int flag_schedule_insns_after_reload = 0;
748 /* The following flags have effect only for scheduling before register
751 flag_schedule_interblock means schedule insns across basic blocks.
752 flag_schedule_speculative means allow speculative motion of non-load insns.
753 flag_schedule_speculative_load means allow speculative motion of some
755 flag_schedule_speculative_load_dangerous allows speculative motion of more
758 int flag_schedule_interblock = 1;
759 int flag_schedule_speculative = 1;
760 int flag_schedule_speculative_load = 0;
761 int flag_schedule_speculative_load_dangerous = 0;
763 int flag_single_precision_constant;
765 /* flag_branch_on_count_reg means try to replace add-1,compare,branch tupple
766 by a cheaper branch on a count register. */
767 int flag_branch_on_count_reg = 1;
769 /* -finhibit-size-directive inhibits output of .size for ELF.
770 This is used only for compiling crtstuff.c,
771 and it may be extended to other effects
772 needed for crtstuff.c on other systems. */
773 int flag_inhibit_size_directive = 0;
775 /* -fverbose-asm causes extra commentary information to be produced in
776 the generated assembly code (to make it more readable). This option
777 is generally only of use to those who actually need to read the
778 generated assembly code (perhaps while debugging the compiler itself).
779 -fno-verbose-asm, the default, causes the extra information
780 to be omitted and is useful when comparing two assembler files. */
782 int flag_verbose_asm = 0;
784 /* -dA causes debug commentary information to be produced in
785 the generated assembly code (to make it more readable). This option
786 is generally only of use to those who actually need to read the
787 generated assembly code (perhaps while debugging the compiler itself).
788 Currently, this switch is only used by dwarfout.c; however, it is intended
789 to be a catchall for printing debug information in the assembler file. */
791 int flag_debug_asm = 0;
793 /* -dP causes the rtl to be emitted as a comment in assembly. */
795 int flag_dump_rtl_in_asm = 0;
797 /* -fgnu-linker specifies use of the GNU linker for initializations.
798 (Or, more generally, a linker that handles initializations.)
799 -fno-gnu-linker says that collect2 will be used. */
801 int flag_gnu_linker = 0;
803 int flag_gnu_linker = 1;
806 /* Nonzero means put zero initialized data in the bss section. */
807 int flag_zero_initialized_in_bss = 1;
812 /* Enable ssa conditional constant propagation. */
813 int flag_ssa_ccp = 0;
815 /* Enable ssa aggressive dead code elimination. */
816 int flag_ssa_dce = 0;
818 /* Tag all structures with __attribute__(packed). */
819 int flag_pack_struct = 0;
821 /* Emit code to check for stack overflow; also may cause large objects
822 to be allocated dynamically. */
823 int flag_stack_check;
825 /* When non-NULL, indicates that whenever space is allocated on the
826 stack, the resulting stack pointer must not pass this
827 address---that is, for stacks that grow downward, the stack pointer
828 must always be greater than or equal to this address; for stacks
829 that grow upward, the stack pointer must be less than this address.
830 At present, the rtx may be either a REG or a SYMBOL_REF, although
831 the support provided depends on the backend. */
834 /* 0 if pointer arguments may alias each other. True in C.
835 1 if pointer arguments may not alias each other but may alias
837 2 if pointer arguments may not alias each other and may not
838 alias global variables. True in Fortran.
839 This defaults to 0 for C. */
840 int flag_argument_noalias = 0;
842 /* Nonzero if we should do (language-dependent) alias analysis.
843 Typically, this analysis will assume that expressions of certain
844 types do not alias expressions of certain other types. Only used
845 if alias analysis (in general) is enabled. */
846 int flag_strict_aliasing = 0;
848 /* Instrument functions with calls at entry and exit, for profiling. */
849 int flag_instrument_function_entry_exit = 0;
851 /* Nonzero means ignore `#ident' directives. 0 means handle them.
852 On SVR4 targets, it also controls whether or not to emit a
853 string identifying the compiler. */
855 int flag_no_ident = 0;
857 /* This will perform a peephole pass before sched2. */
858 int flag_peephole2 = 0;
860 /* This will try to guess branch probabilities. */
861 int flag_guess_branch_prob = 0;
863 /* -fcheck-bounds causes gcc to generate array bounds checks.
864 For C, C++, ObjC: defaults to off.
865 For Java: defaults to on.
866 For Fortran: defaults to off. */
867 int flag_bounds_check = 0;
869 /* This will attempt to merge constant section constants, if 1 only
870 string constants and constants from constant pool, if 2 also constant
872 int flag_merge_constants = 1;
874 /* If one, renumber instruction UIDs to reduce the number of
875 unused UIDs if there are a lot of instructions. If greater than
876 one, unconditionally renumber instruction UIDs. */
877 int flag_renumber_insns = 1;
879 /* If nonzero, use the graph coloring register allocator. */
880 int flag_new_regalloc = 0;
882 /* Nonzero if we perform superblock formation. */
886 /* Nonzero if we perform whole unit at a time compilation. */
888 int flag_unit_at_a_time = 0;
890 /* Values of the -falign-* flags: how much to align labels in code.
891 0 means `use default', 1 means `don't align'.
892 For each variable, there is an _log variant which is the power
893 of two not less than the variable, for .align output. */
897 int align_loops_max_skip;
900 int align_jumps_max_skip;
902 int align_labels_log;
903 int align_labels_max_skip;
905 int align_functions_log;
907 /* Like align_functions_log above, but used by front-ends to force the
908 minimum function alignment. Zero means no alignment is forced. */
909 int force_align_functions_log;
911 /* Table of supported debugging formats. */
914 const char *const arg;
915 /* Since PREFERRED_DEBUGGING_TYPE isn't necessarily a
916 constant expression, we use NO_DEBUG in its place. */
917 const enum debug_info_type debug_type;
918 const int use_extensions_p;
919 const char *const description;
923 { "", NO_DEBUG, DEFAULT_GDB_EXTENSIONS,
924 N_("Generate debugging info in default format") },
925 { "gdb", NO_DEBUG, 1, N_("Generate debugging info in default extended format") },
926 #ifdef DBX_DEBUGGING_INFO
927 { "stabs", DBX_DEBUG, 0, N_("Generate STABS format debug info") },
928 { "stabs+", DBX_DEBUG, 1, N_("Generate extended STABS format debug info") },
930 #ifdef DWARF_DEBUGGING_INFO
931 { "dwarf", DWARF_DEBUG, 0, N_("Generate DWARF-1 format debug info") },
932 { "dwarf+", DWARF_DEBUG, 1,
933 N_("Generate extended DWARF-1 format debug info") },
935 #ifdef DWARF2_DEBUGGING_INFO
936 { "dwarf-2", DWARF2_DEBUG, 0, N_("Generate DWARF-2 debug info") },
938 #ifdef XCOFF_DEBUGGING_INFO
939 { "xcoff", XCOFF_DEBUG, 0, N_("Generate XCOFF format debug info") },
940 { "xcoff+", XCOFF_DEBUG, 1, N_("Generate extended XCOFF format debug info") },
942 #ifdef SDB_DEBUGGING_INFO
943 { "coff", SDB_DEBUG, 0, N_("Generate COFF format debug info") },
945 #ifdef VMS_DEBUGGING_INFO
946 { "vms", VMS_DEBUG, 0, N_("Generate VMS format debug info") },
953 const char *const string;
956 const char *const description;
958 lang_independent_options;
962 /* Add or remove a leading underscore from user symbols. */
963 int flag_leading_underscore = -1;
965 /* The user symbol prefix after having resolved same. */
966 const char *user_label_prefix;
968 static const param_info lang_independent_params[] = {
969 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT) \
970 { OPTION, DEFAULT, HELP },
971 #include "params.def"
976 /* Table of language-independent -f options.
977 STRING is the option name. VARIABLE is the address of the variable.
978 ON_VALUE is the value to store in VARIABLE
979 if `-fSTRING' is seen as an option.
980 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
982 static const lang_independent_options f_options[] =
984 {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
985 N_("Perform DWARF2 duplicate elimination") },
986 {"float-store", &flag_float_store, 1,
987 N_("Do not store floats in registers") },
988 {"defer-pop", &flag_defer_pop, 1,
989 N_("Defer popping functions args from stack until later") },
990 {"omit-frame-pointer", &flag_omit_frame_pointer, 1,
991 N_("When possible do not generate stack frames") },
992 {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
993 N_("Optimize sibling and tail recursive calls") },
994 {"tracer", &flag_tracer, 1,
995 N_("Perform superblock formation via tail duplication") },
996 {"unit-at-a-time", &flag_unit_at_a_time, 1,
997 N_("Compile whole compilation unit at a time") },
998 {"cse-follow-jumps", &flag_cse_follow_jumps, 1,
999 N_("When running CSE, follow jumps to their targets") },
1000 {"cse-skip-blocks", &flag_cse_skip_blocks, 1,
1001 N_("When running CSE, follow conditional jumps") },
1002 {"expensive-optimizations", &flag_expensive_optimizations, 1,
1003 N_("Perform a number of minor, expensive optimizations") },
1004 {"thread-jumps", &flag_thread_jumps, 1,
1005 N_("Perform jump threading optimizations") },
1006 {"strength-reduce", &flag_strength_reduce, 1,
1007 N_("Perform strength reduction optimizations") },
1008 {"unroll-loops", &flag_unroll_loops, 1,
1009 N_("Perform loop unrolling when iteration count is known") },
1010 {"unroll-all-loops", &flag_unroll_all_loops, 1,
1011 N_("Perform loop unrolling for all loops") },
1012 {"unswitch-loops", &flag_unswitch_loops, 1,
1013 N_("Perform loop unswitching") },
1014 {"prefetch-loop-arrays", &flag_prefetch_loop_arrays, 1,
1015 N_("Generate prefetch instructions, if available, for arrays in loops") },
1016 {"move-all-movables", &flag_move_all_movables, 1,
1017 N_("Force all loop invariant computations out of loops") },
1018 {"reduce-all-givs", &flag_reduce_all_givs, 1,
1019 N_("Strength reduce all loop general induction variables") },
1020 {"writable-strings", &flag_writable_strings, 1,
1021 N_("Store strings in writable data section") },
1022 {"peephole", &flag_no_peephole, 0,
1023 N_("Enable machine specific peephole optimizations") },
1024 {"force-mem", &flag_force_mem, 1,
1025 N_("Copy memory operands into registers before using") },
1026 {"force-addr", &flag_force_addr, 1,
1027 N_("Copy memory address constants into regs before using") },
1028 {"function-cse", &flag_no_function_cse, 0,
1029 N_("Allow function addresses to be held in registers") },
1030 {"inline-functions", &flag_inline_functions, 1,
1031 N_("Integrate simple functions into their callers") },
1032 {"keep-inline-functions", &flag_keep_inline_functions, 1,
1033 N_("Generate code for funcs even if they are fully inlined") },
1034 {"inline", &flag_no_inline, 0,
1035 N_("Pay attention to the 'inline' keyword") },
1036 {"keep-static-consts", &flag_keep_static_consts, 1,
1037 N_("Emit static const variables even if they are not used") },
1038 {"syntax-only", &flag_syntax_only, 1,
1039 N_("Check for syntax errors, then stop") },
1040 {"shared-data", &flag_shared_data, 1,
1041 N_("Mark data as shared rather than private") },
1042 {"caller-saves", &flag_caller_saves, 1,
1043 N_("Enable saving registers around function calls") },
1044 {"pcc-struct-return", &flag_pcc_struct_return, 1,
1045 N_("Return 'short' aggregates in memory, not registers") },
1046 {"reg-struct-return", &flag_pcc_struct_return, 0,
1047 N_("Return 'short' aggregates in registers") },
1048 {"delayed-branch", &flag_delayed_branch, 1,
1049 N_("Attempt to fill delay slots of branch instructions") },
1050 {"gcse", &flag_gcse, 1,
1051 N_("Perform the global common subexpression elimination") },
1052 {"gcse-lm", &flag_gcse_lm, 1,
1053 N_("Perform enhanced load motion during global subexpression elimination") },
1054 {"gcse-sm", &flag_gcse_sm, 1,
1055 N_("Perform store motion after global subexpression elimination") },
1056 {"loop-optimize", &flag_loop_optimize, 1,
1057 N_("Perform the loop optimizations") },
1058 {"crossjumping", &flag_crossjumping, 1,
1059 N_("Perform cross-jumping optimization") },
1060 {"if-conversion", &flag_if_conversion, 1,
1061 N_("Perform conversion of conditional jumps to branchless equivalents") },
1062 {"if-conversion2", &flag_if_conversion2, 1,
1063 N_("Perform conversion of conditional jumps to conditional execution") },
1064 {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
1065 N_("Run CSE pass after loop optimizations") },
1066 {"rerun-loop-opt", &flag_rerun_loop_opt, 1,
1067 N_("Run the loop optimizer twice") },
1068 {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
1069 N_("Delete useless null pointer checks") },
1070 {"schedule-insns", &flag_schedule_insns, 1,
1071 N_("Reschedule instructions before register allocation") },
1072 {"schedule-insns2", &flag_schedule_insns_after_reload, 1,
1073 N_("Reschedule instructions after register allocation") },
1074 {"sched-interblock",&flag_schedule_interblock, 1,
1075 N_("Enable scheduling across basic blocks") },
1076 {"sched-spec",&flag_schedule_speculative, 1,
1077 N_("Allow speculative motion of non-loads") },
1078 {"sched-spec-load",&flag_schedule_speculative_load, 1,
1079 N_("Allow speculative motion of some loads") },
1080 {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
1081 N_("Allow speculative motion of more loads") },
1082 {"branch-count-reg",&flag_branch_on_count_reg, 1,
1083 N_("Replace add,compare,branch with branch on count reg") },
1084 {"pic", &flag_pic, 1,
1085 N_("Generate position independent code, if possible") },
1086 {"PIC", &flag_pic, 2, ""},
1087 {"exceptions", &flag_exceptions, 1,
1088 N_("Enable exception handling") },
1089 {"unwind-tables", &flag_unwind_tables, 1,
1090 N_("Just generate unwind tables for exception handling") },
1091 {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1,
1092 N_("Generate unwind tables exact at each instruction boundary") },
1093 {"non-call-exceptions", &flag_non_call_exceptions, 1,
1094 N_("Support synchronous non-call exceptions") },
1095 {"profile-arcs", &profile_arc_flag, 1,
1096 N_("Insert arc based program profiling code") },
1097 {"test-coverage", &flag_test_coverage, 1,
1098 N_("Create data files needed by gcov") },
1099 {"branch-probabilities", &flag_branch_probabilities, 1,
1100 N_("Use profiling information for branch probabilities") },
1101 {"profile", &profile_flag, 1,
1102 N_("Enable basic program profiling code") },
1103 {"reorder-blocks", &flag_reorder_blocks, 1,
1104 N_("Reorder basic blocks to improve code placement") },
1105 {"reorder-functions", &flag_reorder_functions, 1,
1106 N_("Reorder functions to improve code placement") },
1107 {"rename-registers", &flag_rename_registers, 1,
1108 N_("Do the register renaming optimization pass") },
1109 {"cprop-registers", &flag_cprop_registers, 1,
1110 N_("Do the register copy-propagation optimization pass") },
1111 {"common", &flag_no_common, 0,
1112 N_("Do not put uninitialized globals in the common section") },
1113 {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
1114 N_("Do not generate .size directives") },
1115 {"function-sections", &flag_function_sections, 1,
1116 N_("place each function into its own section") },
1117 {"data-sections", &flag_data_sections, 1,
1118 N_("place data items into their own section") },
1119 {"verbose-asm", &flag_verbose_asm, 1,
1120 N_("Add extra commentry to assembler output") },
1121 {"gnu-linker", &flag_gnu_linker, 1,
1122 N_("Output GNU ld formatted global initializers") },
1123 {"regmove", &flag_regmove, 1,
1124 N_("Enables a register move optimization") },
1125 {"optimize-register-move", &flag_regmove, 1,
1126 N_("Do the full regmove optimization pass") },
1127 {"pack-struct", &flag_pack_struct, 1,
1128 N_("Pack structure members together without holes") },
1129 {"stack-check", &flag_stack_check, 1,
1130 N_("Insert stack checking code into the program") },
1131 {"argument-alias", &flag_argument_noalias, 0,
1132 N_("Specify that arguments may alias each other & globals") },
1133 {"argument-noalias", &flag_argument_noalias, 1,
1134 N_("Assume arguments may alias globals but not each other") },
1135 {"argument-noalias-global", &flag_argument_noalias, 2,
1136 N_("Assume arguments do not alias each other or globals") },
1137 {"strict-aliasing", &flag_strict_aliasing, 1,
1138 N_("Assume strict aliasing rules apply") },
1139 {"align-loops", &align_loops, 0,
1140 N_("Align the start of loops") },
1141 {"align-jumps", &align_jumps, 0,
1142 N_("Align labels which are only reached by jumping") },
1143 {"align-labels", &align_labels, 0,
1144 N_("Align all labels") },
1145 {"align-functions", &align_functions, 0,
1146 N_("Align the start of functions") },
1147 {"merge-constants", &flag_merge_constants, 1,
1148 N_("Attempt to merge identical constants accross compilation units") },
1149 {"merge-all-constants", &flag_merge_constants, 2,
1150 N_("Attempt to merge identical constants and constant variables") },
1151 {"dump-unnumbered", &flag_dump_unnumbered, 1,
1152 N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
1153 {"instrument-functions", &flag_instrument_function_entry_exit, 1,
1154 N_("Instrument function entry/exit with profiling calls") },
1155 {"zero-initialized-in-bss", &flag_zero_initialized_in_bss, 1,
1156 N_("Put zero initialized data in the bss section") },
1157 {"ssa", &flag_ssa, 1,
1158 N_("Enable SSA optimizations") },
1159 {"ssa-ccp", &flag_ssa_ccp, 1,
1160 N_("Enable SSA conditional constant propagation") },
1161 {"ssa-dce", &flag_ssa_dce, 1,
1162 N_("Enable aggressive SSA dead code elimination") },
1163 {"leading-underscore", &flag_leading_underscore, 1,
1164 N_("External symbols have a leading underscore") },
1165 {"ident", &flag_no_ident, 0,
1166 N_("Process #ident directives") },
1167 { "peephole2", &flag_peephole2, 1,
1168 N_("Enables an rtl peephole pass run before sched2") },
1169 {"finite-math-only", &flag_finite_math_only, 1,
1170 N_("Assume no NaNs or +-Infs are generated") },
1171 { "guess-branch-probability", &flag_guess_branch_prob, 1,
1172 N_("Enables guessing of branch probabilities") },
1173 {"math-errno", &flag_errno_math, 1,
1174 N_("Set errno after built-in math functions") },
1175 {"trapping-math", &flag_trapping_math, 1,
1176 N_("Floating-point operations can trap") },
1177 {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
1178 N_("Allow math optimizations that may violate IEEE or ANSI standards") },
1179 {"signaling-nans", &flag_signaling_nans, 1,
1180 N_("Disable optimizations observable by IEEE signaling NaNs") },
1181 {"bounds-check", &flag_bounds_check, 1,
1182 N_("Generate code to check bounds before indexing arrays") },
1183 {"single-precision-constant", &flag_single_precision_constant, 1,
1184 N_("Convert floating point constant to single precision constant") },
1185 {"time-report", &time_report, 1,
1186 N_("Report time taken by each compiler pass at end of run") },
1187 {"mem-report", &mem_report, 1,
1188 N_("Report on permanent memory allocation at end of run") },
1189 { "trapv", &flag_trapv, 1,
1190 N_("Trap for signed overflow in addition / subtraction / multiplication") },
1191 { "new-ra", &flag_new_regalloc, 1,
1192 N_("Use graph coloring register allocation.") },
1195 /* Table of language-specific options. */
1197 static const struct lang_opt
1199 const char *const option;
1200 const char *const description;
1202 documented_lang_options[] =
1204 /* In order not to overload the --help output, the convention
1205 used here is to only describe those options which are not
1206 enabled by default. */
1209 N_("Compile just for ISO C90") },
1211 N_("Determine language standard") },
1213 { "-fsigned-bitfields", "" },
1214 { "-funsigned-bitfields",
1215 N_("Make bit-fields by unsigned by default") },
1216 { "-fno-signed-bitfields", "" },
1217 { "-fno-unsigned-bitfields","" },
1219 N_("Make 'char' be signed by default") },
1220 { "-funsigned-char",
1221 N_("Make 'char' be unsigned by default") },
1222 { "-fno-signed-char", "" },
1223 { "-fno-unsigned-char", "" },
1227 N_("Do not recognize the 'asm' keyword") },
1228 { "-fbuiltin", "" },
1230 N_("Do not recognize any built in functions") },
1232 N_("Assume normal C execution environment") },
1233 { "-fno-hosted", "" },
1235 N_("Assume that standard libraries & main might not exist") },
1236 { "-fno-freestanding", "" },
1237 { "-fcond-mismatch",
1238 N_("Allow different types as args of ? operator") },
1239 { "-fno-cond-mismatch", "" },
1240 { "-fdollars-in-identifiers",
1241 N_("Allow the use of $ inside identifiers") },
1242 { "-fno-dollars-in-identifiers", "" },
1243 { "-fpreprocessed", "" },
1244 { "-fno-preprocessed", "" },
1246 N_("Use the same size for double as for float") },
1247 { "-fno-short-double", "" },
1249 N_("Use the smallest fitting integer to hold enums") },
1250 { "-fno-short-enums", "" },
1252 N_("Override the underlying type for wchar_t to `unsigned short'") },
1253 { "-fno-short-wchar", "" },
1256 N_("Enable most warning messages") },
1257 { "-Wbad-function-cast",
1258 N_("Warn about casting functions to incompatible types") },
1259 { "-Wno-bad-function-cast", "" },
1260 { "-Wmissing-format-attribute",
1261 N_("Warn about functions which might be candidates for format attributes") },
1262 { "-Wno-missing-format-attribute", "" },
1264 N_("Warn about casts which discard qualifiers") },
1265 { "-Wno-cast-qual", "" },
1266 { "-Wchar-subscripts",
1267 N_("Warn about subscripts whose type is 'char'") },
1268 { "-Wno-char-subscripts", "" },
1270 N_("Warn if nested comments are detected") },
1271 { "-Wno-comment", "" },
1273 N_("Warn if nested comments are detected") },
1274 { "-Wno-comments", "" },
1276 N_("Warn about possibly confusing type conversions") },
1277 { "-Wno-conversion", "" },
1278 { "-Wdiv-by-zero", "" },
1279 { "-Wno-div-by-zero",
1280 N_("Do not warn about compile-time integer division by zero") },
1282 N_("Warn about testing equality of floating point numbers") },
1283 { "-Wno-float-equal", "" },
1285 N_("Warn about printf/scanf/strftime/strfmon format anomalies") },
1286 { "-Wno-format", "" },
1287 { "-Wformat-extra-args", "" },
1288 { "-Wno-format-extra-args",
1289 N_("Don't warn about too many arguments to format functions") },
1290 { "-Wformat-nonliteral",
1291 N_("Warn about non-string-literal format strings") },
1292 { "-Wno-format-nonliteral", "" },
1293 { "-Wformat-security",
1294 N_("Warn about possible security problems with format functions") },
1295 { "-Wno-format-security", "" },
1296 { "-Wformat-y2k", "" },
1297 { "-Wno-format-y2k",
1298 N_("Don't warn about strftime formats yielding 2 digit years") },
1299 { "-Wimplicit-function-declaration",
1300 N_("Warn about implicit function declarations") },
1301 { "-Wno-implicit-function-declaration", "" },
1302 { "-Werror-implicit-function-declaration", "" },
1304 N_("Warn when a declaration does not specify a type") },
1305 { "-Wno-implicit-int", "" },
1306 { "-Wimplicit", "" },
1307 { "-Wno-implicit", "" },
1309 N_("Warn about the use of the #import directive") },
1310 { "-Wno-import", "" },
1312 N_("Warn about PCH files that are found but not used") },
1313 { "-Wlong-long","" },
1315 N_("Do not warn about using 'long long' when -pedantic") },
1317 N_("Warn about suspicious declarations of main") },
1318 { "-Wno-main", "" },
1319 { "-Wmissing-braces",
1320 N_("Warn about possibly missing braces around initializers") },
1321 { "-Wno-missing-braces", "" },
1322 { "-Wmissing-declarations",
1323 N_("Warn about global funcs without previous declarations") },
1324 { "-Wno-missing-declarations", "" },
1325 { "-Wmissing-prototypes",
1326 N_("Warn about global funcs without prototypes") },
1327 { "-Wno-missing-prototypes", "" },
1329 N_("Warn about use of multicharacter literals") },
1330 { "-Wno-multichar", "" },
1331 { "-Wnested-externs",
1332 N_("Warn about externs not at file scope level") },
1333 { "-Wno-nested-externs", "" },
1335 N_("Warn about possible missing parentheses") },
1336 { "-Wno-parentheses", "" },
1337 { "-Wpointer-arith",
1338 N_("Warn about function pointer arithmetic") },
1339 { "-Wno-pointer-arith", "" },
1340 { "-Wredundant-decls",
1341 N_("Warn about multiple declarations of the same object") },
1342 { "-Wno-redundant-decls", "" },
1344 N_("Warn whenever a function's return-type defaults to int") },
1345 { "-Wno-return-type", "" },
1346 { "-Wsequence-point",
1347 N_("Warn about possible violations of sequence point rules") },
1348 { "-Wno-sequence-point", "" },
1350 N_("Warn about signed/unsigned comparisons") },
1351 { "-Wno-sign-compare", "" },
1352 { "-Wstrict-prototypes",
1353 N_("Warn about non-prototyped function decls") },
1354 { "-Wno-strict-prototypes", "" },
1356 N_("Warn about constructs whose meanings change in ISO C") },
1357 { "-Wno-traditional", "" },
1359 N_("Warn when trigraphs are encountered") },
1360 { "-Wno-trigraphs", "" },
1362 { "-Wno-undef", "" },
1363 { "-Wunknown-pragmas",
1364 N_("Warn about unrecognized pragmas") },
1365 { "-Wno-unknown-pragmas", "" },
1366 { "-Wwrite-strings",
1367 N_("Mark strings as 'const char *'") },
1368 { "-Wno-write-strings", "" },
1370 #define DEFINE_LANG_NAME(NAME) { NULL, NAME },
1372 #include "options.h"
1376 /* Here is a table, controlled by the tm.h file, listing each -m switch
1377 and which bits in `target_switches' it should set or clear.
1378 If VALUE is positive, it is bits to set.
1379 If VALUE is negative, -VALUE is bits to clear.
1380 (The sign bit is not used so there is no confusion.) */
1384 const char *const name;
1386 const char *const description;
1388 target_switches[] = TARGET_SWITCHES;
1390 /* This table is similar, but allows the switch to have a value. */
1392 #ifdef TARGET_OPTIONS
1395 const char *const prefix;
1396 const char **const variable;
1397 const char *const description;
1399 target_options[] = TARGET_OPTIONS;
1402 /* Options controlling warnings. */
1404 /* Don't print warning messages. -w. */
1406 int inhibit_warnings = 0;
1408 /* Don't suppress warnings from system headers. -Wsystem-headers. */
1410 int warn_system_headers = 0;
1412 /* Print various extra warnings. -W/-Wextra. */
1414 int extra_warnings = 0;
1416 /* Treat warnings as errors. -Werror. */
1418 int warnings_are_errors = 0;
1420 /* Nonzero to warn about unused variables, functions et.al. */
1422 int warn_unused_function;
1423 int warn_unused_label;
1424 int warn_unused_parameter;
1425 int warn_unused_variable;
1426 int warn_unused_value;
1428 /* Nonzero to warn about code which is never reached. */
1430 int warn_notreached;
1432 /* Nonzero to warn about variables used before they are initialized. */
1434 int warn_uninitialized;
1436 /* Nonzero means warn about all declarations which shadow others. */
1440 /* Warn if a switch on an enum, that does not have a default case,
1441 fails to have a case for every enum value. */
1445 /* Warn if a switch does not have a default case. */
1447 int warn_switch_default;
1449 /* Warn if a switch on an enum fails to have a case for every enum
1450 value (regardless of the presence or otherwise of a default case). */
1452 int warn_switch_enum;
1454 /* Nonzero means warn about function definitions that default the return type
1455 or that use a null return and have a return-type other than void. */
1457 int warn_return_type;
1459 /* Nonzero means warn about pointer casts that increase the required
1460 alignment of the target type (and might therefore lead to a crash
1461 due to a misaligned access). */
1463 int warn_cast_align;
1465 /* Nonzero means warn about any objects definitions whose size is larger
1466 than N bytes. Also want about function definitions whose returned
1467 values are larger than N bytes. The value N is in `larger_than_size'. */
1469 int warn_larger_than;
1470 HOST_WIDE_INT larger_than_size;
1472 /* Nonzero means warn if inline function is too large. */
1476 /* Warn if a function returns an aggregate,
1477 since there are often incompatible calling conventions for doing this. */
1479 int warn_aggregate_return;
1481 /* Warn if packed attribute on struct is unnecessary and inefficient. */
1485 /* Warn when gcc pads a structure to an alignment boundary. */
1489 /* Warn when an optimization pass is disabled. */
1491 int warn_disabled_optimization;
1493 /* Warn about functions which might be candidates for attribute noreturn. */
1495 int warn_missing_noreturn;
1497 /* Nonzero means warn about uses of __attribute__((deprecated))
1500 int warn_deprecated_decl = 1;
1502 /* Nonzero means warn about constructs which might not be
1503 strict-aliasing safe. */
1505 int warn_strict_aliasing;
1507 /* Like f_options, but for -W. */
1509 static const lang_independent_options W_options[] =
1511 {"unused-function", &warn_unused_function, 1,
1512 N_("Warn when a function is unused") },
1513 {"unused-label", &warn_unused_label, 1,
1514 N_("Warn when a label is unused") },
1515 {"unused-parameter", &warn_unused_parameter, 1,
1516 N_("Warn when a function parameter is unused") },
1517 {"unused-variable", &warn_unused_variable, 1,
1518 N_("Warn when a variable is unused") },
1519 {"unused-value", &warn_unused_value, 1,
1520 N_("Warn when an expression value is unused") },
1521 {"system-headers", &warn_system_headers, 1,
1522 N_("Do not suppress warnings from system headers") },
1523 {"error", &warnings_are_errors, 1,
1524 N_("Treat all warnings as errors") },
1525 {"shadow", &warn_shadow, 1,
1526 N_("Warn when one local variable shadows another") },
1527 {"switch", &warn_switch, 1,
1528 N_("Warn about enumerated switches, with no default, missing a case") },
1529 {"switch-default", &warn_switch_default, 1,
1530 N_("Warn about enumerated switches missing a default case") },
1531 {"switch-enum", &warn_switch_enum, 1,
1532 N_("Warn about all enumerated switches missing a specific case") },
1533 {"aggregate-return", &warn_aggregate_return, 1,
1534 N_("Warn about returning structures, unions or arrays") },
1535 {"cast-align", &warn_cast_align, 1,
1536 N_("Warn about pointer casts which increase alignment") },
1537 {"unreachable-code", &warn_notreached, 1,
1538 N_("Warn about code that will never be executed") },
1539 {"uninitialized", &warn_uninitialized, 1,
1540 N_("Warn about uninitialized automatic variables") },
1541 {"inline", &warn_inline, 1,
1542 N_("Warn when an inlined function cannot be inlined") },
1543 {"packed", &warn_packed, 1,
1544 N_("Warn when the packed attribute has no effect on struct layout") },
1545 {"padded", &warn_padded, 1,
1546 N_("Warn when padding is required to align struct members") },
1547 {"disabled-optimization", &warn_disabled_optimization, 1,
1548 N_("Warn when an optimization pass is disabled") },
1549 {"deprecated-declarations", &warn_deprecated_decl, 1,
1550 N_("Warn about uses of __attribute__((deprecated)) declarations") },
1551 {"extra", &extra_warnings, 1,
1552 N_("Print extra (possibly unwanted) warnings") },
1553 {"missing-noreturn", &warn_missing_noreturn, 1,
1554 N_("Warn about functions which might be candidates for attribute noreturn") },
1555 {"strict-aliasing", &warn_strict_aliasing, 1,
1556 N_ ("Warn about code which might break the strict aliasing rules") }
1560 set_Wunused (setting)
1563 warn_unused_function = setting;
1564 warn_unused_label = setting;
1565 /* Unused function parameter warnings are reported when either ``-W
1566 -Wunused'' or ``-Wunused-parameter'' is specified. Differentiate
1567 -Wunused by setting WARN_UNUSED_PARAMETER to -1. */
1569 warn_unused_parameter = 0;
1570 else if (!warn_unused_parameter)
1571 warn_unused_parameter = -1;
1572 warn_unused_variable = setting;
1573 warn_unused_value = setting;
1576 /* The following routines are useful in setting all the flags that
1577 -ffast-math and -fno-fast-math imply. */
1580 set_fast_math_flags (set)
1583 flag_trapping_math = !set;
1584 flag_unsafe_math_optimizations = set;
1585 flag_finite_math_only = set;
1586 flag_errno_math = !set;
1588 flag_signaling_nans = 0;
1591 /* Return true iff flags are set as if -ffast-math. */
1593 fast_math_flags_set_p ()
1595 return (!flag_trapping_math
1596 && flag_unsafe_math_optimizations
1597 && flag_finite_math_only
1598 && !flag_errno_math);
1602 /* Output files for assembler code (real compiler output)
1603 and debugging dumps. */
1606 FILE *aux_info_file;
1607 FILE *rtl_dump_file = NULL;
1609 /* Decode the string P as an integral parameter.
1610 If the string is indeed an integer return its numeric value else
1611 issue an Invalid Option error for the option PNAME and return DEFVAL.
1612 If PNAME is zero just return DEFVAL, do not call error. */
1615 read_integral_parameter (p, pname, defval)
1620 const char *endp = p;
1624 if (ISDIGIT (*endp))
1633 error ("invalid option `%s'", pname);
1640 /* This calls abort and is used to avoid problems when abort is a macro.
1641 It is used when we need to pass the address of abort. */
1649 /* When `malloc.c' is compiled with `rcheck' defined,
1650 it calls this function to report clobberage. */
1654 const char *s ATTRIBUTE_UNUSED;
1659 /* Return the logarithm of X, base 2, considering X unsigned,
1660 if X is a power of 2. Otherwise, returns -1.
1662 This should be used via the `exact_log2' macro. */
1666 unsigned HOST_WIDE_INT x;
1669 /* Test for 0 or a power of 2. */
1670 if (x == 0 || x != (x & -x))
1672 while ((x >>= 1) != 0)
1677 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1678 If X is 0, return -1.
1680 This should be used via the floor_log2 macro. */
1684 unsigned HOST_WIDE_INT x;
1693 /* Handler for fatal signals, such as SIGSEGV. These are transformed
1694 into ICE messages, which is much more user friendly. */
1697 crash_signal (signo)
1700 internal_error ("%s", strsignal (signo));
1703 /* Arrange to dump core on error. (The regular error message is still
1704 printed first, except in the case of abort().) */
1707 setup_core_dumping ()
1710 signal (SIGABRT, SIG_DFL);
1712 #if defined(HAVE_SETRLIMIT)
1715 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1716 fatal_io_error ("getting core file size maximum limit");
1717 rlim.rlim_cur = rlim.rlim_max;
1718 if (setrlimit (RLIMIT_CORE, &rlim) != 0)
1719 fatal_io_error ("setting core file size limit to maximum");
1722 diagnostic_abort_on_error (global_dc);
1726 /* Strip off a legitimate source ending from the input string NAME of
1727 length LEN. Rather than having to know the names used by all of
1728 our front ends, we strip off an ending of a period followed by
1729 up to five characters. (Java uses ".class".) */
1732 strip_off_ending (name, len)
1737 for (i = 2; i < 6 && len > i; i++)
1739 if (name[len - i] == '.')
1741 name[len - i] = '\0';
1747 /* Output a quoted string. */
1750 output_quoted_string (asm_file, string)
1754 #ifdef OUTPUT_QUOTED_STRING
1755 OUTPUT_QUOTED_STRING (asm_file, string);
1759 putc ('\"', asm_file);
1760 while ((c = *string++) != 0)
1764 if (c == '\"' || c == '\\')
1765 putc ('\\', asm_file);
1769 fprintf (asm_file, "\\%03o", (unsigned char) c);
1771 putc ('\"', asm_file);
1775 /* Output NAME into FILE after having turned it into something
1776 usable as an identifier in a target's assembly file. */
1778 output_clean_symbol_name (file, name)
1782 /* Make a copy of NAME. */
1783 char *id = xstrdup (name);
1785 /* Make it look like a valid identifier for an assembler. */
1786 clean_symbol_name (id);
1793 /* Output a file name in the form wanted by System V. */
1796 output_file_directive (asm_file, input_name)
1798 const char *input_name;
1800 int len = strlen (input_name);
1801 const char *na = input_name + len;
1803 /* NA gets INPUT_NAME sans directory names. */
1804 while (na > input_name)
1806 if (IS_DIR_SEPARATOR (na[-1]))
1811 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
1812 ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
1814 #ifdef ASM_OUTPUT_SOURCE_FILENAME
1815 ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
1817 fprintf (asm_file, "\t.file\t");
1818 output_quoted_string (asm_file, na);
1819 fputc ('\n', asm_file);
1824 /* Routine to open a dump file. Return true if the dump file is enabled. */
1827 open_dump_file (index, decl)
1828 enum dump_file_index index;
1832 const char *open_arg;
1835 if (! dump_file[index].enabled)
1838 timevar_push (TV_DUMP);
1839 if (rtl_dump_file != NULL)
1840 fclose (rtl_dump_file);
1842 sprintf (seq, DUMPFILE_FORMAT, index);
1844 if (! dump_file[index].initialized)
1846 /* If we've not initialized the files, do so now. */
1847 if (graph_dump_format != no_graph
1848 && dump_file[index].graph_dump_p)
1850 dump_name = concat (seq, dump_file[index].extension, NULL);
1851 clean_graph_dump_file (dump_base_name, dump_name);
1854 dump_file[index].initialized = 1;
1860 dump_name = concat (dump_base_name, seq,
1861 dump_file[index].extension, NULL);
1863 rtl_dump_file = fopen (dump_name, open_arg);
1864 if (rtl_dump_file == NULL)
1865 fatal_io_error ("can't open %s", dump_name);
1870 fprintf (rtl_dump_file, "\n;; Function %s%s\n\n",
1871 (*lang_hooks.decl_printable_name) (decl, 2),
1872 cfun->function_frequency == FUNCTION_FREQUENCY_HOT
1874 : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
1875 ? " (unlikely executed)"
1878 timevar_pop (TV_DUMP);
1882 /* Routine to close a dump file. */
1885 close_dump_file (index, func, insns)
1886 enum dump_file_index index;
1887 void (*func) PARAMS ((FILE *, rtx));
1890 if (! rtl_dump_file)
1893 timevar_push (TV_DUMP);
1895 && graph_dump_format != no_graph
1896 && dump_file[index].graph_dump_p)
1901 sprintf (seq, DUMPFILE_FORMAT, index);
1902 suffix = concat (seq, dump_file[index].extension, NULL);
1903 print_rtl_graph_with_bb (dump_base_name, suffix, insns);
1908 func (rtl_dump_file, insns);
1910 fflush (rtl_dump_file);
1911 fclose (rtl_dump_file);
1913 rtl_dump_file = NULL;
1914 timevar_pop (TV_DUMP);
1917 /* Do any final processing required for the declarations in VEC, of
1918 which there are LEN. We write out inline functions and variables
1919 that have been deferred until this point, but which are required.
1920 Returns nonzero if anything was put out. */
1923 wrapup_global_declarations (vec, len)
1930 int output_something = 0;
1932 for (i = 0; i < len; i++)
1936 /* We're not deferring this any longer. Assignment is
1937 conditional to avoid needlessly dirtying PCH pages. */
1938 if (DECL_DEFER_OUTPUT (decl) != 0)
1939 DECL_DEFER_OUTPUT (decl) = 0;
1941 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
1942 (*lang_hooks.finish_incomplete_decl) (decl);
1945 /* Now emit any global variables or functions that we have been
1946 putting off. We need to loop in case one of the things emitted
1947 here references another one which comes earlier in the list. */
1951 for (i = 0; i < len; i++)
1955 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
1958 /* Don't write out static consts, unless we still need them.
1960 We also keep static consts if not optimizing (for debugging),
1961 unless the user specified -fno-keep-static-consts.
1962 ??? They might be better written into the debug information.
1963 This is possible when using DWARF.
1965 A language processor that wants static constants to be always
1966 written out (even if it is not used) is responsible for
1967 calling rest_of_decl_compilation itself. E.g. the C front-end
1968 calls rest_of_decl_compilation from finish_decl.
1969 One motivation for this is that is conventional in some
1970 environments to write things like:
1971 static const char rcsid[] = "... version string ...";
1972 intending to force the string to be in the executable.
1974 A language processor that would prefer to have unneeded
1975 static constants "optimized away" would just defer writing
1976 them out until here. E.g. C++ does this, because static
1977 constants are often defined in header files.
1979 ??? A tempting alternative (for both C and C++) would be
1980 to force a constant to be written if and only if it is
1981 defined in a main file, as opposed to an include file. */
1983 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
1987 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
1989 else if (DECL_COMDAT (decl))
1991 else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
1992 && (optimize || !flag_keep_static_consts
1993 || DECL_ARTIFICIAL (decl)))
1999 rest_of_decl_compilation (decl, NULL, 1, 1);
2003 if (TREE_CODE (decl) == FUNCTION_DECL
2004 && DECL_INITIAL (decl) != 0
2005 && DECL_SAVED_INSNS (decl) != 0
2006 && (flag_keep_inline_functions
2007 || (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
2008 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
2011 output_inline_function (decl);
2016 output_something = 1;
2020 return output_something;
2023 /* Issue appropriate warnings for the global declarations in VEC (of
2024 which there are LEN). Output debugging information for them. */
2027 check_global_declarations (vec, len)
2034 for (i = 0; i < len; i++)
2038 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
2039 && ! TREE_ASM_WRITTEN (decl))
2040 /* Cancel the RTL for this decl so that, if debugging info
2041 output for global variables is still to come,
2042 this one will be omitted. */
2043 SET_DECL_RTL (decl, NULL_RTX);
2045 /* Warn about any function
2046 declared static but not defined.
2047 We don't warn about variables,
2048 because many programs have static variables
2049 that exist only to get some text into the object file. */
2050 if (TREE_CODE (decl) == FUNCTION_DECL
2051 && (warn_unused_function
2052 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2053 && DECL_INITIAL (decl) == 0
2054 && DECL_EXTERNAL (decl)
2055 && ! DECL_ARTIFICIAL (decl)
2056 && ! TREE_PUBLIC (decl))
2058 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2059 pedwarn_with_decl (decl,
2060 "`%s' used but never defined");
2062 warning_with_decl (decl,
2063 "`%s' declared `static' but never defined");
2064 /* This symbol is effectively an "extern" declaration now. */
2065 TREE_PUBLIC (decl) = 1;
2066 assemble_external (decl);
2069 /* Warn about static fns or vars defined but not used. */
2070 if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
2071 || (warn_unused_variable && TREE_CODE (decl) == VAR_DECL))
2072 && ! TREE_USED (decl)
2073 /* The TREE_USED bit for file-scope decls is kept in the identifier,
2074 to handle multiple external decls in different scopes. */
2075 && ! TREE_USED (DECL_NAME (decl))
2076 && ! DECL_EXTERNAL (decl)
2077 && ! TREE_PUBLIC (decl)
2078 /* Global register variables must be declared to reserve them. */
2079 && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
2080 /* Otherwise, ask the language. */
2081 && (*lang_hooks.decls.warn_unused_global) (decl))
2082 warning_with_decl (decl, "`%s' defined but not used");
2084 /* Avoid confusing the debug information machinery when there are
2086 if (errorcount == 0 && sorrycount == 0)
2088 timevar_push (TV_SYMOUT);
2089 (*debug_hooks->global_decl) (decl);
2090 timevar_pop (TV_SYMOUT);
2095 /* Save the current INPUT_FILENAME and LINENO on the top entry in the
2096 INPUT_FILE_STACK. Push a new entry for FILE and LINE, and set the
2097 INPUT_FILENAME and LINENO accordingly. */
2100 push_srcloc (file, line)
2104 struct file_stack *fs;
2106 if (input_file_stack)
2108 input_file_stack->name = input_filename;
2109 input_file_stack->line = lineno;
2112 fs = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2113 fs->name = input_filename = file;
2114 fs->line = lineno = line;
2115 fs->next = input_file_stack;
2116 input_file_stack = fs;
2117 input_file_stack_tick++;
2120 /* Pop the top entry off the stack of presently open source files.
2121 Restore the INPUT_FILENAME and LINENO from the new topmost entry on
2127 struct file_stack *fs;
2129 fs = input_file_stack;
2130 input_file_stack = fs->next;
2132 input_file_stack_tick++;
2133 /* The initial source file is never popped. */
2134 if (!input_file_stack)
2136 input_filename = input_file_stack->name;
2137 lineno = input_file_stack->line;
2140 /* Compile an entire translation unit. Write a file of assembly
2141 output and various debugging dumps. */
2146 /* Initialize yet another pass. */
2148 init_final (main_input_filename);
2149 init_branch_prob (aux_base_name);
2151 timevar_push (TV_PARSE);
2153 /* Call the parser, which parses the entire file (calling
2154 rest_of_compilation for each function). */
2155 (*lang_hooks.parse_file) (set_yydebug);
2157 /* In case there were missing block closers,
2158 get us back to the global binding level. */
2159 (*lang_hooks.clear_binding_stack) ();
2161 /* Compilation is now finished except for writing
2162 what's left of the symbol table output. */
2163 timevar_pop (TV_PARSE);
2165 if (flag_syntax_only)
2168 (*lang_hooks.decls.final_write_globals)();
2170 if (profile_arc_flag)
2171 /* This must occur after the loop to output deferred functions.
2172 Else the profiler initializer would not be emitted if all the
2173 functions in this compilation unit were deferred. */
2176 /* Write out any pending weak symbol declarations. */
2180 /* Do dbx symbols. */
2181 timevar_push (TV_SYMOUT);
2183 #ifdef DWARF2_UNWIND_INFO
2184 if (dwarf2out_do_frame ())
2185 dwarf2out_frame_finish ();
2188 (*debug_hooks->finish) (main_input_filename);
2189 timevar_pop (TV_SYMOUT);
2191 /* Output some stuff at end of file if nec. */
2193 dw2_output_indirect_constants ();
2195 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
2197 timevar_push (TV_DUMP);
2198 open_dump_file (DFI_bp, NULL);
2202 close_dump_file (DFI_bp, NULL, NULL_RTX);
2203 timevar_pop (TV_DUMP);
2207 ASM_FILE_END (asm_out_file);
2210 /* Attach a special .ident directive to the end of the file to identify
2211 the version of GCC which compiled this code. The format of the .ident
2212 string is patterned after the ones produced by native SVR4 compilers. */
2215 fprintf (asm_out_file, "%s\"GCC: (GNU) %s\"\n",
2216 IDENT_ASM_OP, version_string);
2219 if (optimize > 0 && open_dump_file (DFI_combine, NULL))
2221 timevar_push (TV_DUMP);
2222 dump_combine_total_stats (rtl_dump_file);
2223 close_dump_file (DFI_combine, NULL, NULL_RTX);
2224 timevar_pop (TV_DUMP);
2228 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2229 and TYPE_DECL nodes.
2231 This does nothing for local (non-static) variables, unless the
2232 variable is a register variable with an ASMSPEC. In that case, or
2233 if the variable is not an automatic, it sets up the RTL and
2234 outputs any assembler code (label definition, storage allocation
2235 and initialization).
2237 DECL is the declaration. If ASMSPEC is nonzero, it specifies
2238 the assembler symbol name to be used. TOP_LEVEL is nonzero
2239 if this declaration is not within a function. */
2242 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2244 const char *asmspec;
2248 /* We deferred calling assemble_alias so that we could collect
2249 other attributes such as visibility. Emit the alias now. */
2252 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
2255 alias = TREE_VALUE (TREE_VALUE (alias));
2256 alias = get_identifier (TREE_STRING_POINTER (alias));
2257 assemble_alias (decl, alias);
2261 /* Forward declarations for nested functions are not "external",
2262 but we need to treat them as if they were. */
2263 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
2264 || TREE_CODE (decl) == FUNCTION_DECL)
2266 timevar_push (TV_VARCONST);
2269 make_decl_rtl (decl, asmspec);
2271 /* Don't output anything when a tentative file-scope definition
2272 is seen. But at end of compilation, do output code for them. */
2273 if (at_end || !DECL_DEFER_OUTPUT (decl))
2274 assemble_variable (decl, top_level, at_end, 0);
2276 #ifdef ASM_FINISH_DECLARE_OBJECT
2277 if (decl == last_assemble_variable_decl)
2279 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
2284 timevar_pop (TV_VARCONST);
2286 else if (DECL_REGISTER (decl) && asmspec != 0)
2288 if (decode_reg_name (asmspec) >= 0)
2290 SET_DECL_RTL (decl, NULL_RTX);
2291 make_decl_rtl (decl, asmspec);
2295 error ("invalid register name `%s' for register variable", asmspec);
2296 DECL_REGISTER (decl) = 0;
2301 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2302 else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2303 && TREE_CODE (decl) == TYPE_DECL)
2305 timevar_push (TV_SYMOUT);
2306 dbxout_symbol (decl, 0);
2307 timevar_pop (TV_SYMOUT);
2310 #ifdef SDB_DEBUGGING_INFO
2311 else if (write_symbols == SDB_DEBUG && top_level
2312 && TREE_CODE (decl) == TYPE_DECL)
2314 timevar_push (TV_SYMOUT);
2315 sdbout_symbol (decl, 0);
2316 timevar_pop (TV_SYMOUT);
2319 #ifdef DWARF2_DEBUGGING_INFO
2320 else if ((write_symbols == DWARF2_DEBUG
2321 || write_symbols == VMS_AND_DWARF2_DEBUG)
2323 && TREE_CODE (decl) == TYPE_DECL)
2325 timevar_push (TV_SYMOUT);
2326 dwarf2out_decl (decl);
2327 timevar_pop (TV_SYMOUT);
2332 /* Called after finishing a record, union or enumeral type. */
2335 rest_of_type_compilation (type, toplev)
2336 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) \
2337 || defined (SDB_DEBUGGING_INFO) || defined (DWARF2_DEBUGGING_INFO)
2341 tree type ATTRIBUTE_UNUSED;
2342 int toplev ATTRIBUTE_UNUSED;
2345 /* Avoid confusing the debug information machinery when there are
2347 if (errorcount != 0 || sorrycount != 0)
2350 timevar_push (TV_SYMOUT);
2351 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2352 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2353 dbxout_symbol (TYPE_STUB_DECL (type), !toplev);
2355 #ifdef SDB_DEBUGGING_INFO
2356 if (write_symbols == SDB_DEBUG)
2357 sdbout_symbol (TYPE_STUB_DECL (type), !toplev);
2359 #ifdef DWARF2_DEBUGGING_INFO
2360 if ((write_symbols == DWARF2_DEBUG
2361 || write_symbols == VMS_AND_DWARF2_DEBUG)
2363 dwarf2out_decl (TYPE_STUB_DECL (type));
2365 timevar_pop (TV_SYMOUT);
2368 /* This is called from finish_function (within langhooks.parse_file)
2369 after each top-level definition is parsed.
2370 It is supposed to compile that function or variable
2371 and output the assembler code for it.
2372 After we return, the tree storage is freed. */
2375 rest_of_compilation (decl)
2381 int rebuild_label_notes_after_reload;
2383 timevar_push (TV_REST_OF_COMPILATION);
2385 /* Now that we're out of the frontend, we shouldn't have any more
2386 CONCATs anywhere. */
2387 generating_concat_p = 0;
2389 /* When processing delayed functions, prepare_function_start() won't
2390 have been run to re-initialize it. */
2391 cse_not_expected = ! optimize;
2393 /* First, make sure that NOTE_BLOCK is set correctly for each
2394 NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */
2395 if (!cfun->x_whole_function_mode_p)
2398 /* In function-at-a-time mode, we do not attempt to keep the BLOCK
2399 tree in sensible shape. So, we just recalculate it here. */
2400 if (cfun->x_whole_function_mode_p)
2405 /* If we are reconsidering an inline function
2406 at the end of compilation, skip the stuff for making it inline. */
2408 if (DECL_SAVED_INSNS (decl) == 0)
2414 /* If this is nested inside an inlined external function, pretend
2415 it was only declared. Since we cannot inline such functions,
2416 generating code for this one is not only not necessary but will
2417 confuse some debugging output writers. */
2418 for (parent = DECL_CONTEXT (current_function_decl);
2419 parent != NULL_TREE;
2420 parent = get_containing_scope (parent))
2421 if (TREE_CODE (parent) == FUNCTION_DECL
2422 && DECL_INLINE (parent) && DECL_EXTERNAL (parent))
2424 DECL_INITIAL (decl) = 0;
2425 goto exit_rest_of_compilation;
2427 else if (TYPE_P (parent))
2428 /* A function in a local class should be treated normally. */
2431 /* If requested, consider whether to make this function inline. */
2432 if ((DECL_INLINE (decl) && !flag_no_inline)
2433 || flag_inline_functions)
2435 timevar_push (TV_INTEGRATION);
2436 lose = function_cannot_inline_p (decl);
2437 timevar_pop (TV_INTEGRATION);
2438 if (lose || ! optimize)
2440 if (warn_inline && DECL_INLINE (decl))
2441 warning_with_decl (decl, lose);
2442 DECL_ABSTRACT_ORIGIN (decl) = 0;
2443 /* Don't really compile an extern inline function.
2444 If we can't make it inline, pretend
2445 it was only declared. */
2446 if (DECL_EXTERNAL (decl))
2448 DECL_INITIAL (decl) = 0;
2449 goto exit_rest_of_compilation;
2453 /* ??? Note that this has the effect of making it look
2454 like "inline" was specified for a function if we choose
2455 to inline it. This isn't quite right, but it's
2456 probably not worth the trouble to fix. */
2457 inlinable = DECL_INLINE (decl) = 1;
2460 insns = get_insns ();
2462 /* Dump the rtl code if we are dumping rtl. */
2464 if (open_dump_file (DFI_rtl, decl))
2466 if (DECL_SAVED_INSNS (decl))
2467 fprintf (rtl_dump_file, ";; (integrable)\n\n");
2468 close_dump_file (DFI_rtl, print_rtl, insns);
2471 /* Convert from NOTE_INSN_EH_REGION style notes, and do other
2472 sorts of eh initialization. Delay this until after the
2473 initial rtl dump so that we can see the original nesting. */
2474 convert_from_eh_region_ranges ();
2476 /* If function is inline, and we don't yet know whether to
2477 compile it by itself, defer decision till end of compilation.
2478 wrapup_global_declarations will (indirectly) call
2479 rest_of_compilation again for those functions that need to
2480 be output. Also defer those functions that we are supposed
2484 || (DECL_INLINE (decl)
2485 && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2486 && ! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
2487 && ! flag_keep_inline_functions)
2488 || DECL_EXTERNAL (decl))))
2489 DECL_DEFER_OUTPUT (decl) = 1;
2491 if (DECL_INLINE (decl))
2492 /* DWARF wants separate debugging info for abstract and
2493 concrete instances of all inline functions, including those
2494 declared inline but not inlined, and those inlined even
2495 though they weren't declared inline. Conveniently, that's
2496 what DECL_INLINE means at this point. */
2497 (*debug_hooks->deferred_inline_function) (decl);
2499 if (DECL_DEFER_OUTPUT (decl))
2501 /* If -Wreturn-type, we have to do a bit of compilation. We just
2502 want to call cleanup the cfg to figure out whether or not we can
2503 fall off the end of the function; we do the minimum amount of
2504 work necessary to make that safe. */
2505 if (warn_return_type)
2507 int saved_optimize = optimize;
2510 rebuild_jump_labels (insns);
2511 find_exception_handler_labels ();
2512 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2513 cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
2514 optimize = saved_optimize;
2516 /* CFG is no longer maintained up-to-date. */
2517 free_bb_for_insn ();
2520 set_nothrow_function_flags ();
2521 if (current_function_nothrow)
2522 /* Now we know that this can't throw; set the flag for the benefit
2523 of other functions later in this translation unit. */
2524 TREE_NOTHROW (current_function_decl) = 1;
2526 timevar_push (TV_INTEGRATION);
2527 save_for_inline (decl);
2528 timevar_pop (TV_INTEGRATION);
2529 DECL_SAVED_INSNS (decl)->inlinable = inlinable;
2530 goto exit_rest_of_compilation;
2533 /* If specified extern inline but we aren't inlining it, we are
2534 done. This goes for anything that gets here with DECL_EXTERNAL
2535 set, not just things with DECL_INLINE. */
2536 if (DECL_EXTERNAL (decl))
2537 goto exit_rest_of_compilation;
2540 /* If we're emitting a nested function, make sure its parent gets
2541 emitted as well. Doing otherwise confuses debug info. */
2544 for (parent = DECL_CONTEXT (current_function_decl);
2545 parent != NULL_TREE;
2546 parent = get_containing_scope (parent))
2547 if (TREE_CODE (parent) == FUNCTION_DECL)
2548 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
2551 /* We are now committed to emitting code for this function. Do any
2552 preparation, such as emitting abstract debug info for the inline
2553 before it gets mangled by optimization. */
2554 if (DECL_INLINE (decl))
2555 (*debug_hooks->outlining_inline_function) (decl);
2557 /* Remove any notes we don't need. That will make iterating
2558 over the instruction sequence faster, and allow the garbage
2559 collector to reclaim the memory used by the notes. */
2560 remove_unnecessary_notes ();
2565 /* Initialize some variables used by the optimizers. */
2566 init_function_for_compilation ();
2568 if (! DECL_DEFER_OUTPUT (decl))
2569 TREE_ASM_WRITTEN (decl) = 1;
2571 /* Now that integrate will no longer see our rtl, we need not
2572 distinguish between the return value of this function and the
2573 return value of called functions. Also, we can remove all SETs
2574 of subregs of hard registers; they are only here because of
2575 integrate. Also, we can now initialize pseudos intended to
2576 carry magic hard reg data throughout the function. */
2577 rtx_equal_function_value_matters = 0;
2578 purge_hard_subreg_sets (get_insns ());
2580 /* Early return if there were errors. We can run afoul of our
2581 consistency checks, and there's not really much point in fixing them.
2582 Don't return yet if -Wreturn-type; we need to do cleanup_cfg. */
2583 if (((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
2584 || errorcount || sorrycount)
2585 goto exit_rest_of_compilation;
2587 timevar_push (TV_JUMP);
2588 open_dump_file (DFI_sibling, decl);
2589 insns = get_insns ();
2590 rebuild_jump_labels (insns);
2591 find_exception_handler_labels ();
2592 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2594 delete_unreachable_blocks ();
2596 /* Turn NOTE_INSN_PREDICTIONs into branch predictions. */
2597 timevar_push (TV_BRANCH_PROB);
2598 note_prediction_to_br_prob ();
2599 timevar_pop (TV_BRANCH_PROB);
2601 /* We may have potential sibling or tail recursion sites. Select one
2602 (of possibly multiple) methods of performing the call. */
2603 if (flag_optimize_sibling_calls)
2606 optimize_sibling_and_tail_recursive_calls ();
2608 /* Recompute the CFG as sibling optimization clobbers it randomly. */
2609 free_bb_for_insn ();
2610 find_exception_handler_labels ();
2611 rebuild_jump_labels (insns);
2612 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2614 /* There is pass ordering problem - we must lower NOTE_INSN_PREDICTION
2615 notes before simplifying cfg and we must do lowering after sibcall
2616 that unhides parts of RTL chain and cleans up the CFG.
2618 Until sibcall is replaced by tree-level optimizer, lets just
2619 sweep away the NOTE_INSN_PREDICTION notes that leaked out. */
2620 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2621 if (GET_CODE (insn) == NOTE
2622 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION)
2625 close_dump_file (DFI_sibling, print_rtl, get_insns ());
2626 timevar_pop (TV_JUMP);
2628 scope_to_insns_initialize ();
2629 /* Complete generation of exception handling code. */
2632 timevar_push (TV_JUMP);
2633 open_dump_file (DFI_eh, decl);
2635 finish_eh_generation ();
2637 close_dump_file (DFI_eh, print_rtl, get_insns ());
2638 timevar_pop (TV_JUMP);
2641 /* Delay emitting hard_reg_initial_value sets until after EH landing pad
2642 generation, which might create new sets. */
2643 emit_initial_value_sets ();
2646 /* If we are doing position-independent code generation, now
2647 is the time to output special prologues and epilogues.
2648 We do not want to do this earlier, because it just clutters
2649 up inline functions with meaningless insns. */
2654 insns = get_insns ();
2656 /* Copy any shared structure that should not be shared. */
2657 unshare_all_rtl (current_function_decl, insns);
2659 #ifdef SETJMP_VIA_SAVE_AREA
2660 /* This must be performed before virtual register instantiation.
2661 Please be aware the everything in the compiler that can look
2662 at the RTL up to this point must understand that REG_SAVE_AREA
2663 is just like a use of the REG contained inside. */
2664 if (current_function_calls_alloca)
2665 optimize_save_area_alloca (insns);
2668 /* Instantiate all virtual registers. */
2669 instantiate_virtual_regs (current_function_decl, insns);
2671 open_dump_file (DFI_jump, decl);
2673 /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
2674 are initialized and to compute whether control can drop off the end
2677 timevar_push (TV_JUMP);
2678 /* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
2679 before jump optimization switches branch directions. */
2680 expected_value_to_br_prob ();
2682 reg_scan (insns, max_reg_num (), 0);
2683 rebuild_jump_labels (insns);
2684 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2686 dump_flow_info (rtl_dump_file);
2687 cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
2688 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
2690 /* CFG is no longer maintained up-to-date. */
2691 free_bb_for_insn ();
2692 copy_loop_headers (insns);
2693 purge_line_number_notes (insns);
2694 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2696 timevar_pop (TV_JUMP);
2697 close_dump_file (DFI_jump, print_rtl, insns);
2699 /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
2700 if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
2702 goto exit_rest_of_compilation;
2705 /* Long term, this should probably move before the jump optimizer too,
2706 but I didn't want to disturb the rtl_dump_and_exit and related
2707 stuff at this time. */
2708 if (optimize > 0 && flag_ssa)
2710 /* Convert to SSA form. */
2712 timevar_push (TV_TO_SSA);
2713 open_dump_file (DFI_ssa, decl);
2715 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2718 close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
2719 timevar_pop (TV_TO_SSA);
2721 /* Perform sparse conditional constant propagation, if requested. */
2724 timevar_push (TV_SSA_CCP);
2725 open_dump_file (DFI_ssa_ccp, decl);
2729 close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
2730 timevar_pop (TV_SSA_CCP);
2733 /* It would be useful to cleanup the CFG at this point, but block
2734 merging and possibly other transformations might leave a PHI
2735 node in the middle of a basic block, which is a strict no-no. */
2737 /* The SSA implementation uses basic block numbers in its phi
2738 nodes. Thus, changing the control-flow graph or the basic
2739 blocks, e.g., calling find_basic_blocks () or cleanup_cfg (),
2740 may cause problems. */
2744 /* Remove dead code. */
2746 timevar_push (TV_SSA_DCE);
2747 open_dump_file (DFI_ssa_dce, decl);
2749 insns = get_insns ();
2750 ssa_eliminate_dead_code ();
2752 close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
2753 timevar_pop (TV_SSA_DCE);
2756 /* Convert from SSA form. */
2758 timevar_push (TV_FROM_SSA);
2759 open_dump_file (DFI_ussa, decl);
2761 convert_from_ssa ();
2762 /* New registers have been created. Rescan their usage. */
2763 reg_scan (insns, max_reg_num (), 1);
2765 close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
2766 timevar_pop (TV_FROM_SSA);
2771 timevar_push (TV_JUMP);
2772 cleanup_cfg (optimize ? CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP: 0);
2774 /* Try to identify useless null pointer tests and delete them. */
2775 if (flag_delete_null_pointer_checks)
2777 open_dump_file (DFI_null, decl);
2779 dump_flow_info (rtl_dump_file);
2781 if (delete_null_pointer_checks (insns))
2782 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2784 close_dump_file (DFI_null, print_rtl_with_bb, insns);
2787 /* Jump optimization, and the removal of NULL pointer checks, may
2788 have reduced the number of instructions substantially. CSE, and
2789 future passes, allocate arrays whose dimensions involve the
2790 maximum instruction UID, so if we can reduce the maximum UID
2791 we'll save big on memory. */
2792 renumber_insns (rtl_dump_file);
2793 timevar_pop (TV_JUMP);
2795 close_dump_file (DFI_jump, print_rtl_with_bb, insns);
2799 /* Perform common subexpression elimination.
2800 Nonzero value from `cse_main' means that jumps were simplified
2801 and some code may now be unreachable, so do
2802 jump optimization again. */
2806 open_dump_file (DFI_cse, decl);
2808 dump_flow_info (rtl_dump_file);
2809 timevar_push (TV_CSE);
2811 reg_scan (insns, max_reg_num (), 1);
2813 tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2815 rebuild_jump_labels (insns);
2816 purge_all_dead_edges (0);
2818 delete_trivially_dead_insns (insns, max_reg_num ());
2820 /* If we are not running more CSE passes, then we are no longer
2821 expecting CSE to be run. But always rerun it in a cheap mode. */
2822 cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
2824 if (tem || optimize > 1)
2825 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2826 /* Try to identify useless null pointer tests and delete them. */
2827 if (flag_delete_null_pointer_checks)
2829 timevar_push (TV_JUMP);
2831 if (delete_null_pointer_checks (insns))
2832 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2833 timevar_pop (TV_JUMP);
2836 /* The second pass of jump optimization is likely to have
2837 removed a bunch more instructions. */
2838 renumber_insns (rtl_dump_file);
2840 timevar_pop (TV_CSE);
2841 close_dump_file (DFI_cse, print_rtl_with_bb, insns);
2844 open_dump_file (DFI_addressof, decl);
2846 purge_addressof (insns);
2848 purge_all_dead_edges (0);
2849 reg_scan (insns, max_reg_num (), 1);
2851 close_dump_file (DFI_addressof, print_rtl, insns);
2855 /* Perform global cse. */
2857 if (optimize > 0 && flag_gcse)
2859 int save_csb, save_cfj;
2862 timevar_push (TV_GCSE);
2863 open_dump_file (DFI_gcse, decl);
2865 tem = gcse_main (insns, rtl_dump_file);
2866 rebuild_jump_labels (insns);
2867 delete_trivially_dead_insns (insns, max_reg_num ());
2869 save_csb = flag_cse_skip_blocks;
2870 save_cfj = flag_cse_follow_jumps;
2871 flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
2873 /* If -fexpensive-optimizations, re-run CSE to clean up things done
2875 if (flag_expensive_optimizations)
2877 timevar_push (TV_CSE);
2878 reg_scan (insns, max_reg_num (), 1);
2879 tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2880 purge_all_dead_edges (0);
2881 delete_trivially_dead_insns (insns, max_reg_num ());
2882 timevar_pop (TV_CSE);
2883 cse_not_expected = !flag_rerun_cse_after_loop;
2886 /* If gcse or cse altered any jumps, rerun jump optimizations to clean
2887 things up. Then possibly re-run CSE again. */
2891 timevar_push (TV_JUMP);
2892 rebuild_jump_labels (insns);
2893 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2894 timevar_pop (TV_JUMP);
2896 if (flag_expensive_optimizations)
2898 timevar_push (TV_CSE);
2899 reg_scan (insns, max_reg_num (), 1);
2900 tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2901 purge_all_dead_edges (0);
2902 delete_trivially_dead_insns (insns, max_reg_num ());
2903 timevar_pop (TV_CSE);
2907 close_dump_file (DFI_gcse, print_rtl_with_bb, insns);
2908 timevar_pop (TV_GCSE);
2911 flag_cse_skip_blocks = save_csb;
2912 flag_cse_follow_jumps = save_cfj;
2913 #ifdef ENABLE_CHECKING
2914 verify_flow_info ();
2918 /* Instantiate any remaining CONSTANT_P_RTX nodes. */
2919 if (optimize > 0 && flag_gcse && current_function_calls_constant_p)
2920 purge_builtin_constant_p ();
2922 /* Move constant computations out of loops. */
2924 if (optimize > 0 && flag_loop_optimize)
2926 int do_unroll, do_prefetch;
2928 timevar_push (TV_LOOP);
2929 delete_dead_jumptables ();
2930 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2931 open_dump_file (DFI_loop, decl);
2932 /* CFG is no longer maintained up-to-date. */
2933 free_bb_for_insn ();
2935 do_unroll = flag_unroll_loops ? LOOP_UNROLL : LOOP_AUTO_UNROLL;
2936 do_prefetch = flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0;
2937 if (flag_rerun_loop_opt)
2939 cleanup_barriers ();
2941 /* We only want to perform unrolling once. */
2942 loop_optimize (insns, rtl_dump_file, do_unroll);
2945 /* The first call to loop_optimize makes some instructions
2946 trivially dead. We delete those instructions now in the
2947 hope that doing so will make the heuristics in loop work
2948 better and possibly speed up compilation. */
2949 delete_trivially_dead_insns (insns, max_reg_num ());
2951 /* The regscan pass is currently necessary as the alias
2952 analysis code depends on this information. */
2953 reg_scan (insns, max_reg_num (), 1);
2955 cleanup_barriers ();
2956 loop_optimize (insns, rtl_dump_file, do_unroll | LOOP_BCT | do_prefetch);
2958 /* Loop can create trivially dead instructions. */
2959 delete_trivially_dead_insns (insns, max_reg_num ());
2960 close_dump_file (DFI_loop, print_rtl, insns);
2961 timevar_pop (TV_LOOP);
2962 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2967 /* Perform jump bypassing and control flow optimizations. */
2968 if (optimize > 0 && flag_gcse)
2970 timevar_push (TV_BYPASS);
2971 open_dump_file (DFI_bypass, decl);
2973 cleanup_cfg (CLEANUP_EXPENSIVE);
2974 tem = bypass_jumps (rtl_dump_file);
2978 rebuild_jump_labels (insns);
2979 cleanup_cfg (CLEANUP_EXPENSIVE);
2980 delete_trivially_dead_insns (insns, max_reg_num ());
2983 close_dump_file (DFI_bypass, print_rtl_with_bb, insns);
2984 timevar_pop (TV_BYPASS);
2988 #ifdef ENABLE_CHECKING
2989 verify_flow_info ();
2993 /* Do control and data flow analysis; wrote some of the results to
2996 timevar_push (TV_FLOW);
2997 open_dump_file (DFI_cfg, decl);
2999 dump_flow_info (rtl_dump_file);
3000 cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0)
3001 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
3003 /* It may make more sense to mark constant functions after dead code is
3004 eliminated by life_analysis, but we need to do it early, as -fprofile-arcs
3005 may insert code making function non-constant, but we still must consider
3006 it as constant, otherwise -fbranch-probabilities will not read data back.
3008 life_analysis rarely eliminates modification of external memory.
3011 mark_constant_function ();
3013 close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
3015 /* Do branch profiling and static profile estimation passes. */
3016 if (optimize > 0 || cfun->arc_profile || flag_branch_probabilities)
3020 timevar_push (TV_BRANCH_PROB);
3021 open_dump_file (DFI_bp, decl);
3022 if (cfun->arc_profile || flag_branch_probabilities)
3025 /* Discover and record the loop depth at the head of each basic
3026 block. The loop infrastructure does the real job for us. */
3027 flow_loops_find (&loops, LOOP_TREE);
3030 flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
3032 /* Estimate using heuristics if no profiling info is available. */
3033 if (flag_guess_branch_prob)
3034 estimate_probability (&loops);
3036 flow_loops_free (&loops);
3037 close_dump_file (DFI_bp, print_rtl_with_bb, insns);
3038 timevar_pop (TV_BRANCH_PROB);
3042 open_dump_file (DFI_ce1, decl);
3043 if (flag_if_conversion)
3045 timevar_push (TV_IFCVT);
3047 dump_flow_info (rtl_dump_file);
3048 cleanup_cfg (CLEANUP_EXPENSIVE);
3049 reg_scan (insns, max_reg_num (), 0);
3051 timevar_pop (TV_IFCVT);
3053 timevar_push (TV_JUMP);
3054 cleanup_cfg (CLEANUP_EXPENSIVE);
3055 reg_scan (insns, max_reg_num (), 0);
3056 timevar_pop (TV_JUMP);
3057 close_dump_file (DFI_ce1, print_rtl_with_bb, get_insns ());
3061 timevar_push (TV_TRACER);
3062 open_dump_file (DFI_tracer, decl);
3064 dump_flow_info (rtl_dump_file);
3066 cleanup_cfg (CLEANUP_EXPENSIVE);
3067 reg_scan (insns, max_reg_num (), 0);
3068 close_dump_file (DFI_tracer, print_rtl_with_bb, get_insns ());
3069 timevar_pop (TV_TRACER);
3072 /* Perform loop optimalizations. It might be better to do them a bit
3073 sooner, but we want the profile feedback to work more efficiently. */
3075 && flag_unswitch_loops)
3077 struct loops *loops;
3078 timevar_push (TV_LOOP);
3079 open_dump_file (DFI_loop2, decl);
3081 dump_flow_info (rtl_dump_file);
3083 loops = loop_optimizer_init (rtl_dump_file);
3087 /* The optimalizations: */
3088 if (flag_unswitch_loops)
3089 unswitch_loops (loops);
3091 loop_optimizer_finalize (loops, rtl_dump_file);
3094 cleanup_cfg (CLEANUP_EXPENSIVE);
3095 delete_trivially_dead_insns (insns, max_reg_num ());
3096 reg_scan (insns, max_reg_num (), 0);
3098 dump_flow_info (rtl_dump_file);
3099 close_dump_file (DFI_loop2, print_rtl_with_bb, get_insns ());
3100 timevar_pop (TV_LOOP);
3104 if (flag_rerun_cse_after_loop)
3106 timevar_push (TV_CSE2);
3107 open_dump_file (DFI_cse2, decl);
3109 dump_flow_info (rtl_dump_file);
3110 /* CFG is no longer maintained up-to-date. */
3111 tem = cse_main (insns, max_reg_num (), 1, rtl_dump_file);
3112 purge_all_dead_edges (0);
3113 delete_trivially_dead_insns (insns, max_reg_num ());
3117 timevar_push (TV_JUMP);
3118 rebuild_jump_labels (insns);
3119 cleanup_cfg (CLEANUP_EXPENSIVE);
3120 timevar_pop (TV_JUMP);
3122 reg_scan (insns, max_reg_num (), 0);
3123 close_dump_file (DFI_cse2, print_rtl_with_bb, insns);
3125 timevar_pop (TV_CSE2);
3128 cse_not_expected = 1;
3130 open_dump_file (DFI_life, decl);
3133 check_function_return_warnings ();
3135 #ifdef ENABLE_CHECKING
3136 verify_flow_info ();
3138 life_analysis (insns, rtl_dump_file, PROP_FINAL);
3140 cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_UPDATE_LIFE
3141 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
3142 timevar_pop (TV_FLOW);
3146 if (warn_uninitialized || extra_warnings)
3148 uninitialized_vars_warning (DECL_INITIAL (decl));
3150 setjmp_args_warning ();
3156 if (!flag_new_regalloc && initialize_uninitialized_subregs ())
3158 /* Insns were inserted, so things might look a bit different. */
3159 insns = get_insns ();
3160 update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
3161 PROP_LOG_LINKS | PROP_REG_INFO
3162 | PROP_DEATH_NOTES);
3166 close_dump_file (DFI_life, print_rtl_with_bb, insns);
3170 /* If -opt, try combining insns through substitution. */
3174 int rebuild_jump_labels_after_combine = 0;
3176 timevar_push (TV_COMBINE);
3177 open_dump_file (DFI_combine, decl);
3179 rebuild_jump_labels_after_combine
3180 = combine_instructions (insns, max_reg_num ());
3182 /* Combining insns may have turned an indirect jump into a
3183 direct jump. Rebuild the JUMP_LABEL fields of jumping
3185 if (rebuild_jump_labels_after_combine)
3187 timevar_push (TV_JUMP);
3188 rebuild_jump_labels (insns);
3189 timevar_pop (TV_JUMP);
3191 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
3194 close_dump_file (DFI_combine, print_rtl_with_bb, insns);
3195 timevar_pop (TV_COMBINE);
3200 /* Rerun if-conversion, as combine may have simplified things enough to
3201 now meet sequence length restrictions. */
3202 if (flag_if_conversion)
3204 timevar_push (TV_IFCVT);
3205 open_dump_file (DFI_ce2, decl);
3211 close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
3212 timevar_pop (TV_IFCVT);
3215 /* Register allocation pre-pass, to reduce number of moves
3216 necessary for two-address machines. */
3217 if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
3219 timevar_push (TV_REGMOVE);
3220 open_dump_file (DFI_regmove, decl);
3222 regmove_optimize (insns, max_reg_num (), rtl_dump_file);
3224 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
3225 close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
3226 timevar_pop (TV_REGMOVE);
3231 /* Do unconditional splitting before register allocation to allow machine
3232 description to add extra information not needed previously. */
3233 split_all_insns (1);
3235 #ifdef OPTIMIZE_MODE_SWITCHING
3236 timevar_push (TV_MODE_SWITCH);
3239 optimize_mode_switching (NULL);
3242 timevar_pop (TV_MODE_SWITCH);
3245 /* Any of the several passes since flow1 will have munged register
3246 lifetime data a bit. We need it to be up to date for scheduling
3247 (see handling of reg_known_equiv in init_alias_analysis). */
3248 recompute_reg_usage (insns, !optimize_size);
3250 timevar_push (TV_SCHED);
3252 #ifdef INSN_SCHEDULING
3254 /* Print function header into sched dump now
3255 because doing the sched analysis makes some of the dump. */
3256 if (optimize > 0 && flag_schedule_insns)
3258 open_dump_file (DFI_sched, decl);
3260 /* Do control and data sched analysis,
3261 and write some of the results to dump file. */
3263 schedule_insns (rtl_dump_file);
3265 close_dump_file (DFI_sched, print_rtl_with_bb, insns);
3268 timevar_pop (TV_SCHED);
3272 /* Determine if the current function is a leaf before running reload
3273 since this can impact optimizations done by the prologue and
3274 epilogue thus changing register elimination offsets. */
3275 current_function_is_leaf = leaf_function_p ();
3277 timevar_push (TV_LOCAL_ALLOC);
3278 open_dump_file (DFI_lreg, decl);
3280 /* Allocate pseudo-regs that are used only within 1 basic block.
3282 RUN_JUMP_AFTER_RELOAD records whether or not we need to rerun the
3283 jump optimizer after register allocation and reloading are finished. */
3285 if (flag_new_regalloc)
3287 delete_trivially_dead_insns (insns, max_reg_num ());
3290 timevar_pop (TV_LOCAL_ALLOC);
3291 if (dump_file[DFI_lreg].enabled)
3293 timevar_push (TV_DUMP);
3295 close_dump_file (DFI_lreg, NULL, NULL);
3296 timevar_pop (TV_DUMP);
3299 /* XXX clean up the whole mess to bring live info in shape again. */
3300 timevar_push (TV_GLOBAL_ALLOC);
3301 open_dump_file (DFI_greg, decl);
3303 build_insn_chain (insns);
3304 failure = reload (insns, 0);
3306 timevar_pop (TV_GLOBAL_ALLOC);
3308 if (dump_file[DFI_greg].enabled)
3310 timevar_push (TV_DUMP);
3312 dump_global_regs (rtl_dump_file);
3314 close_dump_file (DFI_greg, print_rtl_with_bb, insns);
3315 timevar_pop (TV_DUMP);
3319 goto exit_rest_of_compilation;
3320 reload_completed = 1;
3321 rebuild_label_notes_after_reload = 0;
3325 /* Allocate the reg_renumber array. */
3326 allocate_reg_info (max_regno, FALSE, TRUE);
3328 /* And the reg_equiv_memory_loc array. */
3329 reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
3331 allocate_initial_values (reg_equiv_memory_loc);
3333 regclass (insns, max_reg_num (), rtl_dump_file);
3334 rebuild_label_notes_after_reload = local_alloc ();
3336 timevar_pop (TV_LOCAL_ALLOC);
3338 if (dump_file[DFI_lreg].enabled)
3340 timevar_push (TV_DUMP);
3342 dump_flow_info (rtl_dump_file);
3343 dump_local_alloc (rtl_dump_file);
3345 close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
3346 timevar_pop (TV_DUMP);
3351 timevar_push (TV_GLOBAL_ALLOC);
3352 open_dump_file (DFI_greg, decl);
3354 /* If optimizing, allocate remaining pseudo-regs. Do the reload
3355 pass fixing up any insns that are invalid. */
3358 failure = global_alloc (rtl_dump_file);
3361 build_insn_chain (insns);
3362 failure = reload (insns, 0);
3365 timevar_pop (TV_GLOBAL_ALLOC);
3367 if (dump_file[DFI_greg].enabled)
3369 timevar_push (TV_DUMP);
3371 dump_global_regs (rtl_dump_file);
3373 close_dump_file (DFI_greg, print_rtl_with_bb, insns);
3374 timevar_pop (TV_DUMP);
3378 goto exit_rest_of_compilation;
3383 open_dump_file (DFI_postreload, decl);
3385 /* Do a very simple CSE pass over just the hard registers. */
3388 timevar_push (TV_RELOAD_CSE_REGS);
3389 reload_cse_regs (insns);
3390 timevar_pop (TV_RELOAD_CSE_REGS);
3393 /* Register allocation and reloading may have turned an indirect jump into
3394 a direct jump. If so, we must rebuild the JUMP_LABEL fields of
3395 jumping instructions. */
3396 if (rebuild_label_notes_after_reload)
3398 timevar_push (TV_JUMP);
3400 rebuild_jump_labels (insns);
3401 purge_all_dead_edges (0);
3403 timevar_pop (TV_JUMP);
3406 close_dump_file (DFI_postreload, print_rtl_with_bb, insns);
3408 /* Re-create the death notes which were deleted during reload. */
3409 timevar_push (TV_FLOW2);
3410 open_dump_file (DFI_flow2, decl);
3412 #ifdef ENABLE_CHECKING
3413 verify_flow_info ();
3416 /* If optimizing, then go ahead and split insns now. */
3418 split_all_insns (0);
3420 cleanup_cfg (optimize ? CLEANUP_EXPENSIVE : 0);
3422 /* On some machines, the prologue and epilogue code, or parts thereof,
3423 can be represented as RTL. Doing so lets us schedule insns between
3424 it and the rest of the code and also allows delayed branch
3425 scheduling to operate in the epilogue. */
3426 thread_prologue_and_epilogue_insns (insns);
3430 life_analysis (insns, rtl_dump_file, PROP_FINAL);
3431 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE
3432 | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
3434 /* This is kind of a heuristic. We need to run combine_stack_adjustments
3435 even for machines with possibly nonzero RETURN_POPS_ARGS
3436 and ACCUMULATE_OUTGOING_ARGS. We expect that only ports having
3437 push instructions will have popping returns. */
3438 #ifndef PUSH_ROUNDING
3439 if (!ACCUMULATE_OUTGOING_ARGS)
3441 combine_stack_adjustments ();
3446 flow2_completed = 1;
3448 close_dump_file (DFI_flow2, print_rtl_with_bb, insns);
3449 timevar_pop (TV_FLOW2);
3451 #ifdef HAVE_peephole2
3452 if (optimize > 0 && flag_peephole2)
3454 timevar_push (TV_PEEPHOLE2);
3455 open_dump_file (DFI_peephole2, decl);
3457 peephole2_optimize (rtl_dump_file);
3459 close_dump_file (DFI_peephole2, print_rtl_with_bb, insns);
3460 timevar_pop (TV_PEEPHOLE2);
3464 if (optimize > 0 && (flag_rename_registers || flag_cprop_registers))
3466 timevar_push (TV_RENAME_REGISTERS);
3467 open_dump_file (DFI_rnreg, decl);
3469 if (flag_rename_registers)
3470 regrename_optimize ();
3471 if (flag_cprop_registers)
3472 copyprop_hardreg_forward ();
3474 close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
3475 timevar_pop (TV_RENAME_REGISTERS);
3478 if (flag_if_conversion2)
3480 timevar_push (TV_IFCVT2);
3481 open_dump_file (DFI_ce3, decl);
3485 close_dump_file (DFI_ce3, print_rtl_with_bb, insns);
3486 timevar_pop (TV_IFCVT2);
3490 split_all_insns (1);
3493 #ifdef INSN_SCHEDULING
3494 if (optimize > 0 && flag_schedule_insns_after_reload)
3496 timevar_push (TV_SCHED2);
3497 open_dump_file (DFI_sched2, decl);
3499 /* Do control and data sched analysis again,
3500 and write some more of the results to dump file. */
3502 split_all_insns (1);
3504 schedule_insns (rtl_dump_file);
3506 close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
3507 timevar_pop (TV_SCHED2);
3513 #ifdef LEAF_REGISTERS
3514 current_function_uses_only_leaf_regs
3515 = optimize > 0 && only_leaf_regs_used () && leaf_function_p ();
3519 timevar_push (TV_REG_STACK);
3520 open_dump_file (DFI_stack, decl);
3522 reg_to_stack (insns, rtl_dump_file);
3524 close_dump_file (DFI_stack, print_rtl_with_bb, insns);
3525 timevar_pop (TV_REG_STACK);
3531 timevar_push (TV_REORDER_BLOCKS);
3532 open_dump_file (DFI_bbro, decl);
3534 /* Last attempt to optimize CFG, as scheduling, peepholing and insn
3535 splitting possibly introduced more crossjumping opportunities.
3536 Except that we can't actually run crossjumping without running
3537 another DCE pass, which we can't do after reg-stack. */
3538 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
3539 | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
3540 if (flag_reorder_blocks)
3542 reorder_basic_blocks ();
3543 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
3546 close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
3547 timevar_pop (TV_REORDER_BLOCKS);
3549 compute_alignments ();
3551 /* CFG is no longer maintained up-to-date. */
3552 free_bb_for_insn ();
3554 /* If a machine dependent reorganization is needed, call it. */
3555 #ifdef MACHINE_DEPENDENT_REORG
3556 timevar_push (TV_MACH_DEP);
3557 open_dump_file (DFI_mach, decl);
3559 MACHINE_DEPENDENT_REORG (insns);
3561 close_dump_file (DFI_mach, print_rtl, insns);
3562 timevar_pop (TV_MACH_DEP);
3567 purge_line_number_notes (insns);
3568 cleanup_barriers ();
3570 /* If a scheduling pass for delayed branches is to be done,
3571 call the scheduling code. */
3574 if (optimize > 0 && flag_delayed_branch)
3576 timevar_push (TV_DBR_SCHED);
3577 open_dump_file (DFI_dbr, decl);
3579 dbr_schedule (insns, rtl_dump_file);
3581 close_dump_file (DFI_dbr, print_rtl, insns);
3582 timevar_pop (TV_DBR_SCHED);
3588 #if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
3589 timevar_push (TV_SHORTEN_BRANCH);
3590 split_all_insns_noflow ();
3591 timevar_pop (TV_SHORTEN_BRANCH);
3594 convert_to_eh_region_ranges ();
3596 /* Shorten branches. */
3597 timevar_push (TV_SHORTEN_BRANCH);
3598 shorten_branches (get_insns ());
3599 timevar_pop (TV_SHORTEN_BRANCH);
3601 set_nothrow_function_flags ();
3602 if (current_function_nothrow)
3603 /* Now we know that this can't throw; set the flag for the benefit
3604 of other functions later in this translation unit. */
3605 TREE_NOTHROW (current_function_decl) = 1;
3607 /* Now turn the rtl into assembler code. */
3609 timevar_push (TV_FINAL);
3614 /* Get the function's name, as described by its RTL. This may be
3615 different from the DECL_NAME name used in the source file. */
3617 x = DECL_RTL (decl);
3618 if (GET_CODE (x) != MEM)
3621 if (GET_CODE (x) != SYMBOL_REF)
3623 fnname = XSTR (x, 0);
3625 assemble_start_function (decl, fnname);
3626 final_start_function (insns, asm_out_file, optimize);
3627 final (insns, asm_out_file, optimize, 0);
3628 final_end_function ();
3630 #ifdef IA64_UNWIND_INFO
3631 /* ??? The IA-64 ".handlerdata" directive must be issued before
3632 the ".endp" directive that closes the procedure descriptor. */
3633 output_function_exception_table ();
3636 assemble_end_function (decl, fnname);
3638 #ifndef IA64_UNWIND_INFO
3639 /* Otherwise, it feels unclean to switch sections in the middle. */
3640 output_function_exception_table ();
3644 fflush (asm_out_file);
3646 /* Release all memory allocated by flow. */
3647 free_basic_block_vars (0);
3649 /* Release all memory held by regsets now. */
3650 regset_release_memory ();
3652 timevar_pop (TV_FINAL);
3656 /* Write DBX symbols if requested. */
3658 /* Note that for those inline functions where we don't initially
3659 know for certain that we will be generating an out-of-line copy,
3660 the first invocation of this routine (rest_of_compilation) will
3661 skip over this code by doing a `goto exit_rest_of_compilation;'.
3662 Later on, wrapup_global_declarations will (indirectly) call
3663 rest_of_compilation again for those inline functions that need
3664 to have out-of-line copies generated. During that call, we
3665 *will* be routed past here. */
3667 timevar_push (TV_SYMOUT);
3668 (*debug_hooks->function_decl) (decl);
3669 timevar_pop (TV_SYMOUT);
3671 exit_rest_of_compilation:
3673 /* In case the function was not output,
3674 don't leave any temporary anonymous types
3675 queued up for sdb output. */
3676 #ifdef SDB_DEBUGGING_INFO
3677 if (write_symbols == SDB_DEBUG)
3678 sdbout_types (NULL_TREE);
3681 reload_completed = 0;
3682 flow2_completed = 0;
3685 timevar_push (TV_FINAL);
3687 /* Clear out the insn_length contents now that they are no
3689 init_insn_lengths ();
3691 /* Show no temporary slots allocated. */
3694 free_basic_block_vars (0);
3695 free_bb_for_insn ();
3697 timevar_pop (TV_FINAL);
3699 /* Make sure volatile mem refs aren't considered valid operands for
3700 arithmetic insns. We must call this here if this is a nested inline
3701 function, since the above code leaves us in the init_recog state
3702 (from final.c), and the function context push/pop code does not
3703 save/restore volatile_ok.
3705 ??? Maybe it isn't necessary for expand_start_function to call this
3706 anymore if we do it here? */
3708 init_recog_no_volatile ();
3710 /* We're done with this function. Free up memory if we can. */
3711 free_after_parsing (cfun);
3712 if (! DECL_DEFER_OUTPUT (decl))
3714 free_after_compilation (cfun);
3716 /* Clear integrate.c's pointer to the cfun structure we just
3718 DECL_SAVED_INSNS (decl) = 0;
3724 timevar_pop (TV_REST_OF_COMPILATION);
3734 printf (_(" -ffixed-<register> Mark <register> as being unavailable to the compiler\n"));
3735 printf (_(" -fcall-used-<register> Mark <register> as being corrupted by function calls\n"));
3736 printf (_(" -fcall-saved-<register> Mark <register> as being preserved across functions\n"));
3737 printf (_(" -finline-limit=<number> Limits the size of inlined functions to <number>\n"));
3738 printf (_(" -fmessage-length=<number> Limits diagnostics messages lengths to <number> characters per line. 0 suppresses line-wrapping\n"));
3739 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"));
3740 printf (_(" -ftls-model=[global-dynamic | local-dynamic | initial-exec | local-exec] Indicates the default thread-local storage code generation model\n"));
3742 for (i = ARRAY_SIZE (f_options); i--;)
3744 const char *description = f_options[i].description;
3746 if (description != NULL && *description != 0)
3747 printf (" -f%-21s %s\n",
3748 f_options[i].string, _(description));
3751 printf (_(" -O[number] Set optimization level to [number]\n"));
3752 printf (_(" -Os Optimize for space rather than speed\n"));
3753 for (i = LAST_PARAM; i--;)
3755 const char *description = compiler_params[i].help;
3756 const int length = 21 - strlen (compiler_params[i].option);
3758 if (description != NULL && *description != 0)
3759 printf (" --param %s=<value>%.*s%s\n",
3760 compiler_params[i].option,
3761 length > 0 ? length : 1, " ",
3764 printf (_(" -pedantic Issue warnings needed by strict compliance to ISO C\n"));
3765 printf (_(" -pedantic-errors Like -pedantic except that errors are produced\n"));
3766 printf (_(" -w Suppress warnings\n"));
3768 for (i = ARRAY_SIZE (W_options); i--;)
3770 const char *description = W_options[i].description;
3772 if (description != NULL && *description != 0)
3773 printf (" -W%-21s %s\n",
3774 W_options[i].string, _(description));
3777 printf (_(" -Wunused Enable unused warnings\n"));
3778 printf (_(" -Wlarger-than-<number> Warn if an object is larger than <number> bytes\n"));
3779 printf (_(" -p Enable function profiling\n"));
3780 printf (_(" -o <file> Place output into <file> \n"));
3782 -G <number> Put global and static data smaller than <number>\n\
3783 bytes into a special section (on some targets)\n"));
3785 for (i = ARRAY_SIZE (debug_args); i--;)
3787 if (debug_args[i].description != NULL)
3788 printf (" -g%-21s %s\n",
3789 debug_args[i].arg, _(debug_args[i].description));
3792 printf (_(" -aux-info <file> Emit declaration info into <file>\n"));
3793 printf (_(" -quiet Do not display functions compiled or elapsed time\n"));
3794 printf (_(" -version Display the compiler's version\n"));
3795 printf (_(" -d[letters] Enable dumps from specific passes of the compiler\n"));
3796 printf (_(" -dumpbase <file> Base name to be used for dumps from specific passes\n"));
3797 #if defined INSN_SCHEDULING
3798 printf (_(" -fsched-verbose=<number> Set the verbosity level of the scheduler\n"));
3800 printf (_(" --help Display this information\n"));
3805 /* Display descriptions of language specific options.
3806 If there is no description, note that there is an undocumented option.
3807 If the description is empty, do not display anything. (This allows
3808 options to be deliberately undocumented, for whatever reason).
3809 If the option string is missing, then this is a marker, indicating
3810 that the description string is in fact the name of a language, whose
3811 language specific options are to follow. */
3813 if (ARRAY_SIZE (documented_lang_options) > 1)
3815 printf (_("\nLanguage specific options:\n"));
3817 for (i = 0; i < ARRAY_SIZE (documented_lang_options); i++)
3819 const char *description = documented_lang_options[i].description;
3820 const char *option = documented_lang_options[i].option;
3822 if (description == NULL)
3827 printf (_(" %-23.23s [undocumented]\n"), option);
3829 else if (*description == 0)
3831 else if (option == NULL)
3835 (_("\nThere are undocumented %s specific options as well.\n"),
3839 printf (_("\n Options for %s:\n"), description);
3844 printf (" %-23.23s %s\n", option, _(description));
3849 printf (_("\nThere are undocumented %s specific options as well.\n"),
3852 display_target_options ();
3856 display_target_options ()
3859 static bool displayed = false;
3861 /* Avoid double printing for --help --target-help. */
3866 if (ARRAY_SIZE (target_switches) > 1
3867 #ifdef TARGET_OPTIONS
3868 || ARRAY_SIZE (target_options) > 1
3876 printf (_("\nTarget specific options:\n"));
3878 for (i = ARRAY_SIZE (target_switches); i--;)
3880 const char *option = target_switches[i].name;
3881 const char *description = target_switches[i].description;
3883 if (option == NULL || *option == 0)
3885 else if (description == NULL)
3890 printf (_(" -m%-23.23s [undocumented]\n"), option);
3892 else if (*description != 0)
3893 doc += printf (" -m%-23.23s %s\n", option, _(description));
3896 #ifdef TARGET_OPTIONS
3897 for (i = ARRAY_SIZE (target_options); i--;)
3899 const char *option = target_options[i].prefix;
3900 const char *description = target_options[i].description;
3902 if (option == NULL || *option == 0)
3904 else if (description == NULL)
3909 printf (_(" -m%-23.23s [undocumented]\n"), option);
3911 else if (*description != 0)
3912 doc += printf (" -m%-23.23s %s\n", option, _(description));
3918 printf (_("\nThere are undocumented target specific options as well.\n"));
3920 printf (_(" They exist, but they are not documented.\n"));
3925 /* Parse a -d... command line switch. */
3928 decode_d_option (arg)
3937 for (i = 0; i < (int) DFI_MAX; ++i)
3938 dump_file[i].enabled = 1;
3944 flag_print_asm_name = 1;
3947 flag_dump_rtl_in_asm = 1;
3948 flag_print_asm_name = 1;
3951 graph_dump_format = vcg;
3954 rtl_dump_and_exit = 1;
3959 case 'D': /* These are handled by the preprocessor. */
3963 setup_core_dumping();
3968 for (i = 0; i < (int) DFI_MAX; ++i)
3969 if (c == dump_file[i].debug_switch)
3971 dump_file[i].enabled = 1;
3976 warning ("unrecognized gcc debugging option: %c", c);
3981 /* Parse a -f... command line switch. ARG is the value after the -f.
3982 It is safe to access 'ARG - 2' to generate the full switch name.
3983 Return the number of strings consumed. */
3986 decode_f_option (arg)
3990 const char *option_value = NULL;
3992 /* Search for the option in the table of binary f options. */
3993 for (j = ARRAY_SIZE (f_options); j--;)
3995 if (!strcmp (arg, f_options[j].string))
3997 *f_options[j].variable = f_options[j].on_value;
4001 if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
4002 && ! strcmp (arg + 3, f_options[j].string))
4004 *f_options[j].variable = ! f_options[j].on_value;
4009 if (!strcmp (arg, "fast-math"))
4010 set_fast_math_flags (1);
4011 else if (!strcmp (arg, "no-fast-math"))
4012 set_fast_math_flags (0);
4013 else if ((option_value = skip_leading_substring (arg, "inline-limit-"))
4014 || (option_value = skip_leading_substring (arg, "inline-limit=")))
4017 read_integral_parameter (option_value, arg - 2,
4019 set_param_value ("max-inline-insns", val);
4021 else if ((option_value = skip_leading_substring (arg, "tls-model=")))
4023 if (strcmp (option_value, "global-dynamic") == 0)
4024 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
4025 else if (strcmp (option_value, "local-dynamic") == 0)
4026 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
4027 else if (strcmp (option_value, "initial-exec") == 0)
4028 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
4029 else if (strcmp (option_value, "local-exec") == 0)
4030 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
4032 warning ("`%s': unknown tls-model option", arg - 2);
4034 #ifdef INSN_SCHEDULING
4035 else if ((option_value = skip_leading_substring (arg, "sched-verbose=")))
4036 fix_sched_param ("verbose", option_value);
4038 else if ((option_value = skip_leading_substring (arg, "fixed-")))
4039 fix_register (option_value, 1, 1);
4040 else if ((option_value = skip_leading_substring (arg, "call-used-")))
4041 fix_register (option_value, 0, 1);
4042 else if ((option_value = skip_leading_substring (arg, "call-saved-")))
4043 fix_register (option_value, 0, 0);
4044 else if ((option_value = skip_leading_substring (arg, "align-loops=")))
4045 align_loops = read_integral_parameter (option_value, arg - 2, align_loops);
4046 else if ((option_value = skip_leading_substring (arg, "align-functions=")))
4048 = read_integral_parameter (option_value, arg - 2, align_functions);
4049 else if ((option_value = skip_leading_substring (arg, "align-jumps=")))
4050 align_jumps = read_integral_parameter (option_value, arg - 2, align_jumps);
4051 else if ((option_value = skip_leading_substring (arg, "align-labels=")))
4053 = read_integral_parameter (option_value, arg - 2, align_labels);
4054 else if ((option_value
4055 = skip_leading_substring (arg, "stack-limit-register=")))
4057 int reg = decode_reg_name (option_value);
4059 error ("unrecognized register name `%s'", option_value);
4061 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
4063 else if ((option_value
4064 = skip_leading_substring (arg, "stack-limit-symbol=")))
4067 nm = ggc_strdup (option_value);
4068 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, nm);
4070 else if ((option_value
4071 = skip_leading_substring (arg, "message-length=")))
4072 output_set_maximum_length
4073 (&global_dc->buffer, read_integral_parameter
4074 (option_value, arg - 2, diagnostic_line_cutoff (global_dc)));
4075 else if ((option_value
4076 = skip_leading_substring (arg, "diagnostics-show-location=")))
4078 if (!strcmp (option_value, "once"))
4079 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
4080 else if (!strcmp (option_value, "every-line"))
4081 diagnostic_prefixing_rule (global_dc)
4082 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
4084 error ("unrecognized option `%s'", arg - 2);
4086 else if (!strcmp (arg, "no-stack-limit"))
4087 stack_limit_rtx = NULL_RTX;
4088 else if (!strcmp (arg, "preprocessed"))
4089 /* Recognize this switch but do nothing. This prevents warnings
4090 about an unrecognized switch if cpplib has not been linked in. */
4098 /* Parse a -W... command line switch. ARG is the value after the -W.
4099 It is safe to access 'ARG - 2' to generate the full switch name.
4100 Return the number of strings consumed. */
4103 decode_W_option (arg)
4106 const char *option_value = NULL;
4109 /* Search for the option in the table of binary W options. */
4111 for (j = ARRAY_SIZE (W_options); j--;)
4113 if (!strcmp (arg, W_options[j].string))
4115 *W_options[j].variable = W_options[j].on_value;
4119 if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
4120 && ! strcmp (arg + 3, W_options[j].string))
4122 *W_options[j].variable = ! W_options[j].on_value;
4127 if ((option_value = skip_leading_substring (arg, "id-clash-")))
4128 warning ("-Wid-clash-LEN is no longer supported");
4129 else if ((option_value = skip_leading_substring (arg, "larger-than-")))
4131 larger_than_size = read_integral_parameter (option_value, arg - 2, -1);
4133 warn_larger_than = larger_than_size != -1;
4135 else if (!strcmp (arg, "unused"))
4139 else if (!strcmp (arg, "no-unused"))
4143 else if (!strcmp (arg, "extra"))
4145 /* We save the value of warn_uninitialized, since if they put
4146 -Wuninitialized on the command line, we need to generate a
4147 warning about not using it without also specifying -O. */
4148 if (warn_uninitialized != 1)
4149 warn_uninitialized = 2;
4157 /* Parse a -g... command line switch. ARG is the value after the -g.
4158 It is safe to access 'ARG - 2' to generate the full switch name.
4159 Return the number of strings consumed. */
4162 decode_g_option (arg)
4165 static unsigned level = 0;
4166 /* A lot of code assumes write_symbols == NO_DEBUG if the
4167 debugging level is 0 (thus -gstabs1 -gstabs0 would lose track
4168 of what debugging type has been selected). This records the
4169 selected type. It is an error to specify more than one
4171 static enum debug_info_type selected_debug_type = NO_DEBUG;
4172 /* Nonzero if debugging format has been explicitly set.
4173 -g and -ggdb don't explicitly set the debugging format so
4174 -gdwarf -g3 is equivalent to -gdwarf3. */
4175 static int type_explicitly_set_p = 0;
4176 /* Indexed by enum debug_info_type. */
4177 static const char *const debug_type_names[] =
4179 "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff", "vms"
4182 /* The maximum admissible debug level value. */
4183 static const unsigned max_debug_level = 3;
4185 /* Look up ARG in the table. */
4186 for (da = debug_args; da->arg; da++)
4188 const int da_len = strlen (da->arg);
4190 if (da_len == 0 || ! strncmp (arg, da->arg, da_len))
4192 enum debug_info_type type = da->debug_type;
4193 const char *p = arg + da_len;
4195 if (*p && ! ISDIGIT (*p))
4198 /* A debug flag without a level defaults to level 2.
4199 Note we do not want to call read_integral_parameter
4200 for that case since it will call atoi which
4203 ??? We may want to generalize the interface to
4204 read_integral_parameter to better handle this case
4205 if this case shows up often. */
4207 level = read_integral_parameter (p, 0, max_debug_level + 1);
4209 level = (level == 0) ? 2 : level;
4211 if (da_len > 1 && *p && !strncmp (arg, "dwarf", da_len))
4213 error ("use -gdwarf -g%d for DWARF v1, level %d",
4216 error ("use -gdwarf-2 for DWARF v2");
4219 if (level > max_debug_level)
4222 ignoring option `%s' due to invalid debug level specification",
4224 level = debug_info_level;
4227 if (type == NO_DEBUG)
4229 type = PREFERRED_DEBUGGING_TYPE;
4231 if (da_len > 1 && strncmp (arg, "gdb", da_len) == 0)
4233 #ifdef DWARF2_DEBUGGING_INFO
4234 type = DWARF2_DEBUG;
4236 #ifdef DBX_DEBUGGING_INFO
4243 if (type == NO_DEBUG)
4244 warning ("`%s': unknown or unsupported -g option", arg - 2);
4246 /* Does it conflict with an already selected type? */
4247 if (type_explicitly_set_p
4248 /* -g/-ggdb don't conflict with anything. */
4249 && da->debug_type != NO_DEBUG
4250 && type != selected_debug_type)
4251 warning ("`%s' ignored, conflicts with `-g%s'",
4252 arg - 2, debug_type_names[(int) selected_debug_type]);
4255 /* If the format has already been set, -g/-ggdb
4256 only change the debug level. */
4257 if (type_explicitly_set_p && da->debug_type == NO_DEBUG)
4258 /* Don't change debugging type. */
4262 selected_debug_type = type;
4263 type_explicitly_set_p = da->debug_type != NO_DEBUG;
4266 write_symbols = (level == 0
4268 : selected_debug_type);
4269 use_gnu_debug_info_extensions = da->use_extensions_p;
4270 debug_info_level = (enum debug_info_level) level;
4283 /* Decode the first argument in the argv as a language-independent option.
4284 Return the number of strings consumed. */
4287 independent_decode_option (argc, argv)
4291 char *arg = argv[0];
4293 if (arg[0] != '-' || arg[1] == 0)
4305 if (!strcmp (arg, "-help"))
4308 exit_after_options = 1;
4311 if (!strcmp (arg, "-target-help"))
4313 display_target_options ();
4314 exit_after_options = 1;
4317 if (!strcmp (arg, "-version"))
4319 print_version (stderr, "");
4320 exit_after_options = 1;
4323 /* Handle '--param <name>=<value>'. */
4324 if (strcmp (arg, "-param") == 0)
4330 error ("-param option missing argument");
4334 /* Get the '<name>=<value>' parameter. */
4336 /* Look for the `='. */
4337 equal = strchr (arg, '=');
4339 error ("invalid --param option: %s", arg);
4344 /* Zero out the `=' sign so that we get two separate strings. */
4346 /* Figure out what value is specified. */
4347 val = read_integral_parameter (equal + 1, NULL, INVALID_PARAM_VAL);
4348 if (val != INVALID_PARAM_VAL)
4349 set_param_value (arg, val);
4351 error ("invalid parameter value `%s'", equal + 1);
4366 /* Already been treated in main (). Do nothing. */
4370 set_target_switch (arg + 1);
4374 return decode_f_option (arg + 1);
4377 return decode_g_option (arg + 1);
4380 if (!strcmp (arg, "dumpbase"))
4386 dump_base_name = argv[1];
4391 decode_d_option (arg + 1);
4395 if (!strcmp (arg, "pedantic"))
4397 else if (!strcmp (arg, "pedantic-errors"))
4398 flag_pedantic_errors = pedantic = 1;
4399 else if (arg[1] == 0)
4406 if (!strcmp (arg, "quiet"))
4413 if (!strcmp (arg, "version"))
4421 inhibit_warnings = 1;
4430 /* We save the value of warn_uninitialized, since if they put
4431 -Wuninitialized on the command line, we need to generate a
4432 warning about not using it without also specifying -O. */
4433 if (warn_uninitialized != 1)
4434 warn_uninitialized = 2;
4437 return decode_W_option (arg + 1);
4441 if (!strncmp (arg, "aux-info", 8))
4448 aux_info_file_name = argv[1];
4449 flag_gen_aux_info = 1;
4452 else if (arg[8] == '=')
4454 aux_info_file_name = arg + 9;
4455 flag_gen_aux_info = 1;
4460 else if (!strcmp (arg, "auxbase"))
4466 aux_base_name = argv[1];
4470 else if (!strcmp (arg, "auxbase-strip"))
4477 strip_off_ending (argv[1], strlen (argv[1]));
4479 aux_base_name = argv[1];
4494 asm_file_name = argv[1];
4509 g_switch_val = read_integral_parameter (argv[1], 0, -1);
4514 g_switch_val = read_integral_parameter (arg + 1, 0, -1);
4518 if (g_switch_val == -1)
4522 g_switch_set = TRUE;
4523 g_switch_value = g_switch_val;
4533 /* Decode -m switches. */
4534 /* Decode the switch -mNAME. */
4537 set_target_switch (name)
4541 int valid_target_option = 0;
4543 for (j = 0; j < ARRAY_SIZE (target_switches); j++)
4544 if (!strcmp (target_switches[j].name, name))
4546 if (target_switches[j].value < 0)
4547 target_flags &= ~-target_switches[j].value;
4549 target_flags |= target_switches[j].value;
4552 if (target_switches[j].value < 0)
4553 target_flags_explicit |= -target_switches[j].value;
4555 target_flags_explicit |= target_switches[j].value;
4557 valid_target_option = 1;
4560 #ifdef TARGET_OPTIONS
4561 if (!valid_target_option)
4562 for (j = 0; j < ARRAY_SIZE (target_options); j++)
4564 int len = strlen (target_options[j].prefix);
4565 if (!strncmp (target_options[j].prefix, name, len))
4567 *target_options[j].variable = name + len;
4568 valid_target_option = 1;
4573 if (!valid_target_option)
4574 error ("invalid option `%s'", name);
4577 /* Print version information to FILE.
4578 Each line begins with INDENT (for the case where FILE is the
4579 assembler output file). */
4582 print_version (file, indent)
4587 #define __VERSION__ "[?]"
4591 "%s%s%s version %s (%s)\n%s\tcompiled by GNU C version %s.\n"
4593 "%s%s%s version %s (%s) compiled by CC.\n"
4595 , indent, *indent != 0 ? " " : "",
4596 lang_hooks.name, version_string, TARGET_NAME,
4597 indent, __VERSION__);
4600 /* Print an option value and return the adjusted position in the line.
4601 ??? We don't handle error returns from fprintf (disk full); presumably
4602 other code will catch a disk full though. */
4605 print_single_switch (file, pos, max, indent, sep, term, type, name)
4608 const char *indent, *sep, *term, *type, *name;
4610 /* The ultrix fprintf returns 0 on success, so compute the result we want
4611 here since we need it for the following test. */
4612 int len = strlen (sep) + strlen (type) + strlen (name);
4617 fprintf (file, "%s", term);
4622 fprintf (file, "%s", indent);
4623 pos = strlen (indent);
4625 fprintf (file, "%s%s%s", sep, type, name);
4630 /* Print active target switches to FILE.
4631 POS is the current cursor position and MAX is the size of a "line".
4632 Each line begins with INDENT and ends with TERM.
4633 Each switch is separated from the next by SEP. */
4636 print_switch_values (file, pos, max, indent, sep, term)
4639 const char *indent, *sep, *term;
4644 /* Print the options as passed. */
4646 pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
4647 _("options passed: "), "");
4649 for (p = &save_argv[1]; *p != NULL; p++)
4653 if (strcmp (*p, "-o") == 0)
4659 if (strcmp (*p, "-quiet") == 0)
4661 if (strcmp (*p, "-version") == 0)
4666 pos = print_single_switch (file, pos, max, indent, sep, term, *p, "");
4669 fprintf (file, "%s", term);
4671 /* Print the -f and -m options that have been enabled.
4672 We don't handle language specific options but printing argv
4675 pos = print_single_switch (file, 0, max, indent, *indent ? " " : "", term,
4676 _("options enabled: "), "");
4678 for (j = 0; j < ARRAY_SIZE (f_options); j++)
4679 if (*f_options[j].variable == f_options[j].on_value)
4680 pos = print_single_switch (file, pos, max, indent, sep, term,
4681 "-f", f_options[j].string);
4683 /* Print target specific options. */
4685 for (j = 0; j < ARRAY_SIZE (target_switches); j++)
4686 if (target_switches[j].name[0] != '\0'
4687 && target_switches[j].value > 0
4688 && ((target_switches[j].value & target_flags)
4689 == target_switches[j].value))
4691 pos = print_single_switch (file, pos, max, indent, sep, term,
4692 "-m", target_switches[j].name);
4695 #ifdef TARGET_OPTIONS
4696 for (j = 0; j < ARRAY_SIZE (target_options); j++)
4697 if (*target_options[j].variable != NULL)
4700 sprintf (prefix, "-m%s", target_options[j].prefix);
4701 pos = print_single_switch (file, pos, max, indent, sep, term,
4702 prefix, *target_options[j].variable);
4706 fprintf (file, "%s", term);
4709 /* Open assembly code output file. Do this even if -fsyntax-only is
4710 on, because then the driver will have provided the name of a
4711 temporary file or bit bucket for us. NAME is the file specified on
4712 the command line, possibly NULL. */
4714 init_asm_output (name)
4717 if (name == NULL && asm_file_name == 0)
4718 asm_out_file = stdout;
4721 if (asm_file_name == 0)
4723 int len = strlen (dump_base_name);
4724 char *dumpname = (char *) xmalloc (len + 6);
4725 memcpy (dumpname, dump_base_name, len + 1);
4726 strip_off_ending (dumpname, len);
4727 strcat (dumpname, ".s");
4728 asm_file_name = dumpname;
4730 if (!strcmp (asm_file_name, "-"))
4731 asm_out_file = stdout;
4733 asm_out_file = fopen (asm_file_name, "w+");
4734 if (asm_out_file == 0)
4735 fatal_io_error ("can't open %s for writing", asm_file_name);
4738 #ifdef IO_BUFFER_SIZE
4739 setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
4740 _IOFBF, IO_BUFFER_SIZE);
4743 if (!flag_syntax_only)
4745 #ifdef ASM_FILE_START
4746 ASM_FILE_START (asm_out_file);
4749 #ifdef ASM_COMMENT_START
4750 if (flag_verbose_asm)
4752 /* Print the list of options in effect. */
4753 print_version (asm_out_file, ASM_COMMENT_START);
4754 print_switch_values (asm_out_file, 0, MAX_LINE,
4755 ASM_COMMENT_START, " ", "\n");
4756 /* Add a blank line here so it appears in assembler output but not
4758 fprintf (asm_out_file, "\n");
4764 /* Initialization of the front end environment, before command line
4765 options are parsed. Signal handlers, internationalization etc.
4766 ARGV0 is main's argv[0]. */
4768 general_init (argv0)
4773 p = argv0 + strlen (argv0);
4774 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
4778 xmalloc_set_program_name (progname);
4782 gcc_init_libintl ();
4784 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
4786 signal (SIGSEGV, crash_signal);
4789 signal (SIGILL, crash_signal);
4792 signal (SIGBUS, crash_signal);
4795 signal (SIGABRT, crash_signal);
4797 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
4798 signal (SIGIOT, crash_signal);
4801 signal (SIGFPE, crash_signal);
4804 /* Other host-specific signal setup. */
4805 (*host_hooks.extra_signals)();
4807 /* Initialize the diagnostics reporting machinery, so option parsing
4808 can give warnings and errors. */
4809 diagnostic_initialize (global_dc);
4811 /* Initialize the garbage-collector, string pools and tree type hash
4818 /* Parse command line options and set default flag values, called
4819 after language-independent option-independent initialization. Do
4820 minimal options processing. Outputting diagnostics is OK, but GC
4821 and identifier hashtables etc. are not initialized yet.
4823 Return nonzero to suppress compiler back end initialization. */
4825 parse_options_and_default_flags (argc, argv)
4831 /* Save in case md file wants to emit args as a comment. */
4835 /* Initialize register usage now so switches may override. */
4838 /* Register the language-independent parameters. */
4839 add_params (lang_independent_params, LAST_PARAM);
4841 /* Perform language-specific options initialization. */
4842 (*lang_hooks.init_options) ();
4844 /* Scan to see what optimization level has been specified. That will
4845 determine the default value of many flags. */
4846 for (i = 1; i < argc; i++)
4848 if (!strcmp (argv[i], "-O"))
4853 else if (argv[i][0] == '-' && argv[i][1] == 'O')
4855 /* Handle -Os, -O2, -O3, -O69, ... */
4856 char *p = &argv[i][2];
4858 if ((p[0] == 's') && (p[1] == 0))
4862 /* Optimizing for size forces optimize to be 2. */
4867 const int optimize_val = read_integral_parameter (p, p - 2, -1);
4868 if (optimize_val != -1)
4870 optimize = optimize_val;
4879 flag_merge_constants = 0;
4885 flag_thread_jumps = 1;
4887 flag_delayed_branch = 1;
4889 #ifdef CAN_DEBUG_WITHOUT_FP
4890 flag_omit_frame_pointer = 1;
4892 flag_guess_branch_prob = 1;
4893 flag_cprop_registers = 1;
4894 flag_loop_optimize = 1;
4895 flag_crossjumping = 1;
4896 flag_if_conversion = 1;
4897 flag_if_conversion2 = 1;
4902 flag_optimize_sibling_calls = 1;
4903 flag_cse_follow_jumps = 1;
4904 flag_cse_skip_blocks = 1;
4906 flag_expensive_optimizations = 1;
4907 flag_strength_reduce = 1;
4908 flag_rerun_cse_after_loop = 1;
4909 flag_rerun_loop_opt = 1;
4910 flag_caller_saves = 1;
4913 #ifdef INSN_SCHEDULING
4914 flag_schedule_insns = 1;
4915 flag_schedule_insns_after_reload = 1;
4918 flag_strict_aliasing = 1;
4919 flag_delete_null_pointer_checks = 1;
4920 flag_reorder_blocks = 1;
4921 flag_reorder_functions = 1;
4926 flag_inline_functions = 1;
4927 flag_rename_registers = 1;
4928 flag_unswitch_loops = 1;
4931 if (optimize < 2 || optimize_size)
4936 align_functions = 1;
4938 /* Don't reorder blocks when optimizing for size because extra
4939 jump insns may be created; also barrier may create extra padding.
4941 More correctly we should have a block reordering mode that tried
4942 to minimize the combined size of all the jumps. This would more
4943 or less automatically remove extra jumps, but would also try to
4944 use more short jumps instead of long jumps. */
4945 flag_reorder_blocks = 0;
4948 /* Initialize whether `char' is signed. */
4949 flag_signed_char = DEFAULT_SIGNED_CHAR;
4950 #ifdef DEFAULT_SHORT_ENUMS
4951 /* Initialize how much space enums occupy, by default. */
4952 flag_short_enums = DEFAULT_SHORT_ENUMS;
4955 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
4958 set_target_switch ("");
4960 /* Unwind tables are always present in an ABI-conformant IA-64
4961 object file, so the default should be ON. */
4962 #ifdef IA64_UNWIND_INFO
4963 flag_unwind_tables = IA64_UNWIND_INFO;
4966 #ifdef OPTIMIZATION_OPTIONS
4967 /* Allow default optimizations to be specified on a per-machine basis. */
4968 OPTIMIZATION_OPTIONS (optimize, optimize_size);
4971 /* Perform normal command line switch decoding. */
4972 for (i = 1; i < argc;)
4975 int indep_processed;
4977 /* Give the language a chance to decode the option for itself. */
4978 lang_processed = (*lang_hooks.decode_option) (argc - i, argv + i);
4980 if (lang_processed >= 0)
4981 /* Now see if the option also has a language independent meaning.
4982 Some options are both language specific and language independent,
4984 indep_processed = independent_decode_option (argc - i, argv + i);
4987 lang_processed = -lang_processed;
4988 indep_processed = 0;
4991 if (lang_processed || indep_processed)
4992 i += MAX (lang_processed, indep_processed);
4995 const char *option = NULL;
4996 const char *lang = NULL;
4999 /* It is possible that the command line switch is not valid for the
5000 current language, but it is valid for another language. In order
5001 to be compatible with previous versions of the compiler (which
5002 did not issue an error message in this case) we check for this
5003 possibility here. If we do find a match, then if extra_warnings
5004 is set we generate a warning message, otherwise we will just
5005 ignore the option. */
5006 for (j = 0; j < ARRAY_SIZE (documented_lang_options); j++)
5008 option = documented_lang_options[j].option;
5011 lang = documented_lang_options[j].description;
5012 else if (! strncmp (argv[i], option, strlen (option)))
5016 if (j != ARRAY_SIZE (documented_lang_options))
5020 warning ("ignoring command line option '%s'", argv[i]);
5023 ("(it is valid for %s but not the selected language)",
5027 else if (argv[i][0] == '-' && argv[i][1] == 'g')
5028 warning ("`%s': unknown or unsupported -g option", &argv[i][2]);
5030 error ("unrecognized option `%s'", argv[i]);
5036 if (flag_no_inline == 2)
5039 flag_really_no_inline = flag_no_inline;
5041 /* Set flag_no_inline before the post_options () hook. The C front
5042 ends use it to determine tree inlining defaults. FIXME: such
5043 code should be lang-independent when all front ends use tree
5044 inlining, in which case it, and this condition, should be moved
5045 to the top of process_options() instead. */
5048 /* Inlining does not work if not optimizing,
5049 so force it not to be done. */
5053 /* The c_decode_option function and decode_option hook set
5054 this to `2' if -Wall is used, so we can avoid giving out
5055 lots of errors for people who don't realize what -Wall does. */
5056 if (warn_uninitialized == 1)
5057 warning ("-Wuninitialized is not supported without -O");
5060 if (flag_really_no_inline == 2)
5061 flag_really_no_inline = flag_no_inline;
5064 /* Process the options that have been parsed. */
5068 #ifdef OVERRIDE_OPTIONS
5069 /* Some machines may reject certain combinations of options. */
5073 /* Set up the align_*_log variables, defaulting them to 1 if they
5074 were still unset. */
5075 if (align_loops <= 0) align_loops = 1;
5076 if (align_loops_max_skip > align_loops || !align_loops)
5077 align_loops_max_skip = align_loops - 1;
5078 align_loops_log = floor_log2 (align_loops * 2 - 1);
5079 if (align_jumps <= 0) align_jumps = 1;
5080 if (align_jumps_max_skip > align_jumps || !align_jumps)
5081 align_jumps_max_skip = align_jumps - 1;
5082 align_jumps_log = floor_log2 (align_jumps * 2 - 1);
5083 if (align_labels <= 0) align_labels = 1;
5084 align_labels_log = floor_log2 (align_labels * 2 - 1);
5085 if (align_labels_max_skip > align_labels || !align_labels)
5086 align_labels_max_skip = align_labels - 1;
5087 if (align_functions <= 0) align_functions = 1;
5088 align_functions_log = floor_log2 (align_functions * 2 - 1);
5090 /* Unrolling all loops implies that standard loop unrolling must also
5092 if (flag_unroll_all_loops)
5093 flag_unroll_loops = 1;
5094 /* Loop unrolling requires that strength_reduction be on also. Silently
5095 turn on strength reduction here if it isn't already on. Also, the loop
5096 unrolling code assumes that cse will be run after loop, so that must
5097 be turned on also. */
5098 if (flag_unroll_loops)
5100 flag_strength_reduce = 1;
5101 flag_rerun_cse_after_loop = 1;
5104 if (flag_non_call_exceptions)
5105 flag_asynchronous_unwind_tables = 1;
5106 if (flag_asynchronous_unwind_tables)
5107 flag_unwind_tables = 1;
5109 /* Disable unit-at-a-time mode for frontends not supporting callgraph
5111 if (flag_unit_at_a_time && ! lang_hooks.callgraph.expand_function)
5112 flag_unit_at_a_time = 0;
5114 /* Warn about options that are not supported on this machine. */
5115 #ifndef INSN_SCHEDULING
5116 if (flag_schedule_insns || flag_schedule_insns_after_reload)
5117 warning ("instruction scheduling not supported on this target machine");
5120 if (flag_delayed_branch)
5121 warning ("this target machine does not have delayed branches");
5124 user_label_prefix = USER_LABEL_PREFIX;
5125 if (flag_leading_underscore != -1)
5127 /* If the default prefix is more complicated than "" or "_",
5128 issue a warning and ignore this option. */
5129 if (user_label_prefix[0] == 0 ||
5130 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
5132 user_label_prefix = flag_leading_underscore ? "_" : "";
5135 warning ("-f%sleading-underscore not supported on this target machine",
5136 flag_leading_underscore ? "" : "no-");
5139 /* If we are in verbose mode, write out the version and maybe all the
5140 option flags in use. */
5143 print_version (stderr, "");
5145 print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
5151 if (flag_syntax_only)
5153 write_symbols = NO_DEBUG;
5157 /* Now we know write_symbols, set up the debug hooks based on it.
5158 By default we do nothing for debug output. */
5159 #if defined(DBX_DEBUGGING_INFO)
5160 if (write_symbols == DBX_DEBUG)
5161 debug_hooks = &dbx_debug_hooks;
5163 #if defined(XCOFF_DEBUGGING_INFO)
5164 if (write_symbols == XCOFF_DEBUG)
5165 debug_hooks = &xcoff_debug_hooks;
5167 #ifdef SDB_DEBUGGING_INFO
5168 if (write_symbols == SDB_DEBUG)
5169 debug_hooks = &sdb_debug_hooks;
5171 #ifdef DWARF_DEBUGGING_INFO
5172 if (write_symbols == DWARF_DEBUG)
5173 debug_hooks = &dwarf_debug_hooks;
5175 #ifdef DWARF2_DEBUGGING_INFO
5176 if (write_symbols == DWARF2_DEBUG)
5177 debug_hooks = &dwarf2_debug_hooks;
5179 #ifdef VMS_DEBUGGING_INFO
5180 if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
5181 debug_hooks = &vmsdbg_debug_hooks;
5184 /* If auxiliary info generation is desired, open the output file.
5185 This goes in the same directory as the source file--unlike
5186 all the other output files. */
5187 if (flag_gen_aux_info)
5189 aux_info_file = fopen (aux_info_file_name, "w");
5190 if (aux_info_file == 0)
5191 fatal_io_error ("can't open %s", aux_info_file_name);
5194 if (! targetm.have_named_sections)
5196 if (flag_function_sections)
5198 warning ("-ffunction-sections not supported for this target");
5199 flag_function_sections = 0;
5201 if (flag_data_sections)
5203 warning ("-fdata-sections not supported for this target");
5204 flag_data_sections = 0;
5208 if (flag_function_sections && profile_flag)
5210 warning ("-ffunction-sections disabled; it makes profiling impossible");
5211 flag_function_sections = 0;
5214 #ifndef HAVE_prefetch
5215 if (flag_prefetch_loop_arrays)
5217 warning ("-fprefetch-loop-arrays not supported for this target");
5218 flag_prefetch_loop_arrays = 0;
5221 if (flag_prefetch_loop_arrays && !HAVE_prefetch)
5223 warning ("-fprefetch-loop-arrays not supported for this target (try -march switches)");
5224 flag_prefetch_loop_arrays = 0;
5228 /* This combination of options isn't handled for i386 targets and doesn't
5229 make much sense anyway, so don't allow it. */
5230 if (flag_prefetch_loop_arrays && optimize_size)
5232 warning ("-fprefetch-loop-arrays is not supported with -Os");
5233 flag_prefetch_loop_arrays = 0;
5236 #ifndef OBJECT_FORMAT_ELF
5237 if (flag_function_sections && write_symbols != NO_DEBUG)
5238 warning ("-ffunction-sections may affect debugging on some targets");
5241 /* The presence of IEEE signaling NaNs, implies all math can trap. */
5242 if (flag_signaling_nans)
5243 flag_trapping_math = 1;
5246 /* Initialize the compiler back end. */
5250 /* init_emit_once uses reg_raw_mode and therefore must be called
5251 after init_regs which initialized reg_raw_mode. */
5253 init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
5254 || debug_info_level == DINFO_LEVEL_VERBOSE
5255 #ifdef VMS_DEBUGGING_INFO
5256 /* Enable line number info for traceback */
5257 || debug_info_level > DINFO_LEVEL_NONE
5259 || flag_test_coverage
5260 || warn_notreached);
5261 init_fake_stack_mems ();
5265 init_function_once ();
5266 init_varasm_once ();
5268 /* The following initialization functions need to generate rtl, so
5269 provide a dummy function context for them. */
5270 init_dummy_function_start ();
5272 if (flag_caller_saves)
5273 init_caller_save ();
5274 expand_dummy_function_end ();
5277 /* Language-dependent initialization. Returns nonzero on success. */
5279 lang_dependent_init (name)
5282 if (dump_base_name == 0)
5283 dump_base_name = name ? name : "gccdump";
5285 /* Front-end initialization. This hook can assume that GC,
5286 identifier hashes etc. are set up, but debug initialization is
5287 not done yet. This routine must return the original filename
5288 (e.g. foo.i -> foo.c) so can correctly initialize debug output. */
5289 name = (*lang_hooks.init) (name);
5293 /* Is this duplication necessary? */
5294 name = ggc_strdup (name);
5295 main_input_filename = input_filename = name;
5296 init_asm_output (name);
5298 /* These create various _DECL nodes, so need to be called after the
5299 front end is initialized. */
5303 /* The following initialization functions need to generate rtl, so
5304 provide a dummy function context for them. */
5305 init_dummy_function_start ();
5307 expand_dummy_function_end ();
5309 /* Put an entry on the input file stack for the main input file. */
5310 push_srcloc (input_filename, 0);
5312 /* If dbx symbol table desired, initialize writing it and output the
5313 predefined types. */
5314 timevar_push (TV_SYMOUT);
5316 #ifdef DWARF2_UNWIND_INFO
5317 if (dwarf2out_do_frame ())
5318 dwarf2out_frame_init ();
5321 /* Now we have the correct original filename, we can initialize
5323 (*debug_hooks->init) (name);
5325 timevar_pop (TV_SYMOUT);
5330 /* Clean up: close opened files, etc. */
5335 /* Close the dump files. */
5336 if (flag_gen_aux_info)
5338 fclose (aux_info_file);
5340 unlink (aux_info_file_name);
5343 /* Close non-debugging input and output files. Take special care to note
5344 whether fclose returns an error, since the pages might still be on the
5345 buffer chain while the file is open. */
5349 if (ferror (asm_out_file) != 0)
5350 fatal_io_error ("error writing to %s", asm_file_name);
5351 if (fclose (asm_out_file) != 0)
5352 fatal_io_error ("error closing %s", asm_file_name);
5355 /* Do whatever is necessary to finish printing the graphs. */
5356 if (graph_dump_format != no_graph)
5360 for (i = 0; i < (int) DFI_MAX; ++i)
5361 if (dump_file[i].initialized && dump_file[i].graph_dump_p)
5366 sprintf (seq, DUMPFILE_FORMAT, i);
5367 suffix = concat (seq, dump_file[i].extension, NULL);
5368 finish_graph_dump_file (dump_base_name, suffix);
5375 ggc_print_statistics ();
5376 stringpool_statistics ();
5377 dump_tree_statistics ();
5380 /* Free up memory for the benefit of leak detectors. */
5383 /* Language-specific end of compilation actions. */
5384 (*lang_hooks.finish) ();
5387 /* Initialize the compiler, and compile the input file. */
5391 /* All command line options have been parsed; allow the front end to
5392 perform consistency checks, etc. */
5393 bool no_backend = (*lang_hooks.post_options) ();
5395 /* The bulk of command line switch processing. */
5398 /* If an error has already occurred, give up. */
5406 char *name = xstrdup (lbasename (filename));
5408 aux_base_name = name;
5409 strip_off_ending (name, strlen (name));
5412 aux_base_name = "gccaux";
5414 /* We cannot start timing until after options are processed since that
5415 says if we run timers or not. */
5417 timevar_start (TV_TOTAL);
5419 /* Set up the back-end if requested. */
5423 /* Language-dependent initialization. Returns true on success. */
5424 if (lang_dependent_init (filename))
5429 /* Stop timing and print the times. */
5430 timevar_stop (TV_TOTAL);
5431 timevar_print (stderr);
5434 /* Entry point of cc1, cc1plus, jc1, f771, etc.
5435 Decode command args, then call compile_file.
5436 Exit code is FATAL_EXIT_CODE if can't open files or if there were
5437 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
5439 It is not safe to call this function more than once. */
5442 toplev_main (argc, argv)
5446 /* Initialization of GCC's environment, and diagnostics. */
5447 general_init (argv[0]);
5449 /* Parse the options and do minimal processing; basically just
5450 enough to default flags appropriately. */
5451 parse_options_and_default_flags (argc, argv);
5453 /* Exit early if we can (e.g. -help). */
5454 if (!exit_after_options)
5457 if (errorcount || sorrycount)
5458 return (FATAL_EXIT_CODE);
5460 return (SUCCESS_EXIT_CODE);