-/* Top level of GNU C compiler
+/* Top level of GCC compilers (cc1, cc1plus, etc.)
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
#include "regs.h"
#include "timevar.h"
#include "diagnostic.h"
-#include "ssa.h"
#include "params.h"
#include "reload.h"
#include "dwarf2asm.h"
#include "hosthooks.h"
#include "cgraph.h"
#include "opts.h"
+#include "coverage.h"
+#include "value-prof.h"
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
#include "dwarf2out.h"
declarations for e.g. AIX 4.x. */
#endif
+#ifndef HAVE_conditional_execution
+#define HAVE_conditional_execution 0
+#endif
+
/* Carry information from ASM_DECLARE_OBJECT_NAME
to ASM_FINISH_DECLARE_OBJECT. */
extern void reg_alloc (void);
-static void general_init (char *);
-static void parse_options_and_default_flags (int, char **);
+static void general_init (const char *);
static void do_compile (void);
static void process_options (void);
static void backend_init (void);
static void init_asm_output (const char *);
static void finalize (void);
-static void set_target_switch (const char *);
-
static void crash_signal (int) ATTRIBUTE_NORETURN;
static void setup_core_dumping (void);
static void compile_file (void);
-void decode_d_option (const char *);
-static int decode_f_option (const char *);
-static int decode_W_option (const char *);
-static int decode_g_option (const char *);
-static unsigned int independent_decode_option (int, char **);
-static void set_Wextra (int);
-
static int print_single_switch (FILE *, int, int, const char *,
const char *, const char *,
const char *, const char *);
/* Rest of compilation helper functions. */
static bool rest_of_handle_inlining (tree);
-static rtx rest_of_handle_ssa (tree, rtx);
static void rest_of_handle_cse (tree, rtx);
static void rest_of_handle_cse2 (tree, rtx);
static void rest_of_handle_gcse (tree, rtx);
static void rest_of_handle_jump_bypass (tree, rtx);
static void rest_of_handle_sibling_calls (rtx);
static void rest_of_handle_null_pointer (tree, rtx);
-static void rest_of_handle_addresof (tree, rtx);
+static void rest_of_handle_addressof (tree, rtx);
static void rest_of_handle_cfg (tree, rtx);
static void rest_of_handle_branch_prob (tree, rtx);
+static void rest_of_handle_value_profile_transformations (tree, rtx);
static void rest_of_handle_if_conversion (tree, rtx);
static void rest_of_handle_if_after_combine (tree, rtx);
static void rest_of_handle_tracer (tree, rtx);
static void rest_of_handle_combine (tree, rtx);
static void rest_of_handle_regmove (tree, rtx);
-static void rest_of_handle_sched (tree, rtx);
#ifdef INSN_SCHEDULING
+static void rest_of_handle_sched (tree, rtx);
static void rest_of_handle_sched2 (tree, rtx);
#endif
-static bool rest_of_handle_new_regalloc (tree, rtx, int *);
-static bool rest_of_handle_old_regalloc (tree, rtx, int *);
+static bool rest_of_handle_new_regalloc (tree, rtx);
+static bool rest_of_handle_old_regalloc (tree, rtx);
static void rest_of_handle_regrename (tree, rtx);
static void rest_of_handle_reorder_blocks (tree, rtx);
#ifdef STACK_REGS
const char *progname;
-/* Copy of arguments to toplev_main. */
-int save_argc;
-char **save_argv;
+/* Copy of argument vector to toplev_main. */
+static const char **save_argv;
/* Name of top-level original source file (what was input to cpp).
This comes from the #-command at the beginning of the actual input.
location_t input_location;
+struct line_maps line_table;
+
/* Nonzero if it is unsafe to create any new pseudo registers. */
int no_new_pseudos;
/* Debug hooks - dependent upon command line options. */
-const struct gcc_debug_hooks *debug_hooks = &do_nothing_debug_hooks;
+const struct gcc_debug_hooks *debug_hooks;
/* Describes a dump file. */
enum dump_file_index
{
+ DFI_cgraph,
DFI_rtl,
DFI_sibling,
DFI_eh,
DFI_jump,
- DFI_ssa,
- DFI_ssa_ccp,
- DFI_ssa_dce,
- DFI_ussa,
DFI_null,
DFI_cse,
DFI_addressof,
DFI_bypass,
DFI_cfg,
DFI_bp,
+ DFI_vpt,
DFI_ce1,
DFI_tracer,
DFI_loop2,
+ DFI_web,
DFI_cse2,
DFI_life,
DFI_combine,
DFI_flow2,
DFI_peephole2,
DFI_rnreg,
- DFI_bbro,
DFI_ce3,
+ DFI_bbro,
+ DFI_branch_target_load,
DFI_sched2,
DFI_stack,
DFI_mach,
Remaining -d letters:
- " o q "
- " H JK OPQ TUV YZ"
+ " e m q "
+ " JK O Q WXY "
*/
static struct dump_file_info dump_file[DFI_MAX] =
{
+ { "cgraph", 'U', 0, 0, 0 },
{ "rtl", 'r', 0, 0, 0 },
{ "sibling", 'i', 0, 0, 0 },
{ "eh", 'h', 0, 0, 0 },
{ "jump", 'j', 0, 0, 0 },
- { "ssa", 'e', 1, 0, 0 },
- { "ssaccp", 'W', 1, 0, 0 },
- { "ssadce", 'X', 1, 0, 0 },
- { "ussa", 'e', 1, 0, 0 }, /* Yes, duplicate enable switch. */
{ "null", 'u', 0, 0, 0 },
{ "cse", 's', 0, 0, 0 },
{ "addressof", 'F', 0, 0, 0 },
{ "bypass", 'G', 1, 0, 0 }, /* Yes, duplicate enable switch. */
{ "cfg", 'f', 1, 0, 0 },
{ "bp", 'b', 1, 0, 0 },
+ { "vpt", 'V', 1, 0, 0 },
{ "ce1", 'C', 1, 0, 0 },
{ "tracer", 'T', 1, 0, 0 },
{ "loop2", 'L', 1, 0, 0 },
+ { "web", 'Z', 0, 0, 0 },
{ "cse2", 't', 1, 0, 0 },
{ "life", 'f', 1, 0, 0 }, /* Yes, duplicate enable switch. */
{ "combine", 'c', 1, 0, 0 },
{ "flow2", 'w', 1, 0, 0 },
{ "peephole2", 'z', 1, 0, 0 },
{ "rnreg", 'n', 1, 0, 0 },
- { "bbro", 'B', 1, 0, 0 },
{ "ce3", 'E', 1, 0, 0 },
+ { "bbro", 'B', 1, 0, 0 },
+ { "btl", 'd', 1, 0, 0 }, /* Yes, duplicate enable switch. */
{ "sched2", 'R', 1, 0, 0 },
{ "stack", 'k', 1, 0, 0 },
{ "mach", 'M', 1, 0, 0 },
const char *asm_file_name;
-/* Type(s) of debugging information we are producing (if any).
- See flags.h for the definitions of the different possible
- types of debugging information. */
-enum debug_info_type write_symbols = NO_DEBUG;
-
-/* Level of debugging information we are producing. See flags.h
- for the definitions of the different possible levels. */
-enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
-
-/* Nonzero means use GNU-only extensions in the generated symbolic
- debugging information. */
-/* Currently, this only has an effect when write_symbols is set to
- DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
-int use_gnu_debug_info_extensions = 0;
-
/* Nonzero means do optimizations. -O.
Particular numeric values stand for particular amounts of optimization;
thus, -O2 stores 2 here. However, the optimizations beyond the basic
int flag_eliminate_unused_debug_types = 1;
+/* Nonzero means emit debugging information only for symbols which are used. */
+int flag_debug_only_used_symbols = 0;
+
/* Nonzero if generating code to do profiling. */
int profile_flag = 0;
int profile_arc_flag = 0;
+/* Nonzero if value histograms should be measured. */
+
+int flag_profile_values = 0;
+
+/* Nonzero if value histograms should be used to optimize code. */
+int flag_value_profile_transformations = 0;
+
/* Nonzero if generating info for gcov to calculate line test coverage. */
int flag_test_coverage = 0;
/* Print times taken by the various passes. -ftime-report. */
-static int time_report = 0;
+int time_report = 0;
/* Print memory still in use at end of compilation (which may have little
to do with peak memory consumption). -fmem-report. */
and to print them when we are done. */
int flag_detailed_statistics = 0;
+/* A random sequence of characters, unless overridden by user. */
+const char *flag_random_seed;
+
+/* A local time stamp derived from the time of compilation. It will be
+ zero if the system cannot provide a time. It will be -1u, if the
+ user has specified a particular random seed. */
+unsigned local_tick;
+
/* -f flags. */
/* Nonzero means `char' should be signed. */
be saved across function calls, if that produces overall better code.
Optional now, so people can test it. */
-#ifdef DEFAULT_CALLER_SAVES
-int flag_caller_saves = 1;
-#else
int flag_caller_saves = 0;
-#endif
/* Nonzero if structures and unions should be returned in memory.
int flag_trapping_math = 1;
+/* Nonzero means disable transformations that assume default floating
+ point rounding behavior. */
+
+int flag_rounding_math = 0;
+
/* Nonzero means disable transformations observable by signaling NaNs.
- This option implies that any operation on a IEEE signaling NaN can
+ This option implies that any operation on an IEEE signaling NaN can
generate a (user-visible) trap. */
int flag_signaling_nans = 0;
int flag_syntax_only = 0;
+/* Nonzero means performs web construction pass. */
+
+int flag_web;
+
/* Nonzero means perform loop optimizer. */
-static int flag_loop_optimize;
+int flag_loop_optimize;
/* Nonzero means perform crossjumping. */
-static int flag_crossjumping;
+int flag_crossjumping;
/* Nonzero means perform if conversion. */
-static int flag_if_conversion;
+int flag_if_conversion;
/* Nonzero means perform if conversion after reload. */
-static int flag_if_conversion2;
+int flag_if_conversion2;
/* Nonzero means to use global dataflow analysis to eliminate
useless null pointer tests. */
-static int flag_delete_null_pointer_checks;
+int flag_delete_null_pointer_checks;
/* Nonzero means perform global CSE. */
int flag_gcse_sm = 1;
+/* Nonzero if we want to perfrom redundant load after store elimination
+ in gcse. */
+
+int flag_gcse_las = 1;
+
+/* Perform target register optimization before prologue / epilogue
+ threading. */
+
+int flag_branch_target_load_optimize = 0;
+
+/* Perform target register optimization after prologue / epilogue
+ threading and jump2. */
+
+int flag_branch_target_load_optimize2 = 0;
+
+/* For the bt-load pass, nonzero means don't re-use branch target registers
+ in any basic block. */
+
+int flag_btr_bb_exclusive;
+
/* Nonzero means to rerun cse after loop optimization. This increases
compilation time about 20% and picks up a few more common expressions. */
-static int flag_rerun_cse_after_loop;
+int flag_rerun_cse_after_loop;
/* Nonzero means to run loop optimizations twice. */
int flag_unwind_tables = 0;
-/* Nonzero means generate frame unwind info table exact at each insn boundary */
+/* Nonzero means generate frame unwind info table exact at each insn
+ boundary. */
int flag_asynchronous_unwind_tables = 0;
int flag_schedule_speculative_load = 0;
int flag_schedule_speculative_load_dangerous = 0;
+/* The following flags have an effect during scheduling after register
+ allocation:
+
+ flag_sched_stalled_insns means that insns can be moved prematurely from the queue
+ of stalled insns into the ready list.
+
+ flag_sched_stalled_insns_dep controls how many insn groups will be examined
+ for a dependency on a stalled insn that is candidate for premature removal
+ from the queue of stalled insns into the ready list (has an effect only if
+ the flag 'sched_stalled_insns' is set). */
+
+int flag_sched_stalled_insns = 0;
+int flag_sched_stalled_insns_dep = 1;
+
int flag_single_precision_constant;
/* flag_branch_on_count_reg means try to replace add-1,compare,branch tupple
int flag_dump_rtl_in_asm = 0;
-/* -fgnu-linker specifies use of the GNU linker for initializations.
- (Or, more generally, a linker that handles initializations.)
- -fno-gnu-linker says that collect2 will be used. */
-#ifdef USE_COLLECT2
-int flag_gnu_linker = 0;
-#else
-int flag_gnu_linker = 1;
-#endif
-
/* Nonzero means put zero initialized data in the bss section. */
int flag_zero_initialized_in_bss = 1;
-/* Enable SSA. */
-int flag_ssa = 0;
-
-/* Enable ssa conditional constant propagation. */
-int flag_ssa_ccp = 0;
-
-/* Enable ssa aggressive dead code elimination. */
-int flag_ssa_dce = 0;
-
/* Tag all structures with __attribute__(packed). */
int flag_pack_struct = 0;
minimum function alignment. Zero means no alignment is forced. */
int force_align_functions_log;
-/* Table of supported debugging formats. */
-static const struct
-{
- const char *const arg;
- /* Since PREFERRED_DEBUGGING_TYPE isn't necessarily a
- constant expression, we use NO_DEBUG in its place. */
- const enum debug_info_type debug_type;
- const int use_extensions_p;
- const char *const description;
-} *da,
-debug_args[] =
-{
- { "", NO_DEBUG, DEFAULT_GDB_EXTENSIONS,
- N_("Generate debugging info in default format") },
- { "gdb", NO_DEBUG, 1, N_("Generate debugging info in default extended format") },
-#ifdef DBX_DEBUGGING_INFO
- { "stabs", DBX_DEBUG, 0, N_("Generate STABS format debug info") },
- { "stabs+", DBX_DEBUG, 1, N_("Generate extended STABS format debug info") },
-#endif
-#ifdef DWARF_DEBUGGING_INFO
- { "dwarf", DWARF_DEBUG, 0, N_("Generate DWARF-1 format debug info") },
- { "dwarf+", DWARF_DEBUG, 1,
- N_("Generate extended DWARF-1 format debug info") },
-#endif
-#ifdef DWARF2_DEBUGGING_INFO
- { "dwarf-2", DWARF2_DEBUG, 0, N_("Generate DWARF-2 debug info") },
-#endif
-#ifdef XCOFF_DEBUGGING_INFO
- { "xcoff", XCOFF_DEBUG, 0, N_("Generate XCOFF format debug info") },
- { "xcoff+", XCOFF_DEBUG, 1, N_("Generate extended XCOFF format debug info") },
-#endif
-#ifdef SDB_DEBUGGING_INFO
- { "coff", SDB_DEBUG, 0, N_("Generate COFF format debug info") },
-#endif
-#ifdef VMS_DEBUGGING_INFO
- { "vms", VMS_DEBUG, 0, N_("Generate VMS format debug info") },
-#endif
- { 0, 0, 0, 0 }
-};
-
typedef struct
{
const char *const string;
int *const variable;
const int on_value;
- const char *const description;
}
lang_independent_options;
/* Nonzero if signed arithmetic overflow should wrap around. */
int flag_wrapv = 0;
+/* Nonzero if subexpressions must be evaluated from left-to-right. */
+int flag_evaluation_order = 0;
+
/* Add or remove a leading underscore from user symbols. */
int flag_leading_underscore = -1;
static const lang_independent_options f_options[] =
{
- {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
- N_("Perform DWARF2 duplicate elimination") },
- {"eliminate-unused-debug-types", &flag_eliminate_unused_debug_types, 1,
- N_("Perform unused type elimination in debug info") },
- {"float-store", &flag_float_store, 1,
- N_("Do not store floats in registers") },
- {"defer-pop", &flag_defer_pop, 1,
- N_("Defer popping functions args from stack until later") },
- {"omit-frame-pointer", &flag_omit_frame_pointer, 1,
- N_("When possible do not generate stack frames") },
- {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
- N_("Optimize sibling and tail recursive calls") },
- {"tracer", &flag_tracer, 1,
- N_("Perform superblock formation via tail duplication") },
- {"unit-at-a-time", &flag_unit_at_a_time, 1,
- N_("Compile whole compilation unit at a time") },
- {"cse-follow-jumps", &flag_cse_follow_jumps, 1,
- N_("When running CSE, follow jumps to their targets") },
- {"cse-skip-blocks", &flag_cse_skip_blocks, 1,
- N_("When running CSE, follow conditional jumps") },
- {"expensive-optimizations", &flag_expensive_optimizations, 1,
- N_("Perform a number of minor, expensive optimizations") },
- {"thread-jumps", &flag_thread_jumps, 1,
- N_("Perform jump threading optimizations") },
- {"strength-reduce", &flag_strength_reduce, 1,
- N_("Perform strength reduction optimizations") },
- {"unroll-loops", &flag_unroll_loops, 1,
- N_("Perform loop unrolling when iteration count is known") },
- {"unroll-all-loops", &flag_unroll_all_loops, 1,
- N_("Perform loop unrolling for all loops") },
- {"old-unroll-loops", &flag_old_unroll_loops, 1,
- N_("Perform loop unrolling when iteration count is known") },
- {"old-unroll-all-loops", &flag_old_unroll_all_loops, 1,
- N_("Perform loop unrolling for all loops") },
- {"peel-loops", &flag_peel_loops, 1,
- N_("Perform loop peeling") },
- {"unswitch-loops", &flag_unswitch_loops, 1,
- N_("Perform loop unswitching") },
- {"prefetch-loop-arrays", &flag_prefetch_loop_arrays, 1,
- N_("Generate prefetch instructions, if available, for arrays in loops") },
- {"move-all-movables", &flag_move_all_movables, 1,
- N_("Force all loop invariant computations out of loops") },
- {"reduce-all-givs", &flag_reduce_all_givs, 1,
- N_("Strength reduce all loop general induction variables") },
- {"writable-strings", &flag_writable_strings, 1,
- N_("Store strings in writable data section") },
- {"peephole", &flag_no_peephole, 0,
- N_("Enable machine specific peephole optimizations") },
- {"force-mem", &flag_force_mem, 1,
- N_("Copy memory operands into registers before using") },
- {"force-addr", &flag_force_addr, 1,
- N_("Copy memory address constants into regs before using") },
- {"function-cse", &flag_no_function_cse, 0,
- N_("Allow function addresses to be held in registers") },
- {"inline-functions", &flag_inline_functions, 1,
- N_("Integrate simple functions into their callers") },
- {"keep-inline-functions", &flag_keep_inline_functions, 1,
- N_("Generate code for funcs even if they are fully inlined") },
- {"inline", &flag_no_inline, 0,
- N_("Pay attention to the 'inline' keyword") },
- {"keep-static-consts", &flag_keep_static_consts, 1,
- N_("Emit static const variables even if they are not used") },
- {"syntax-only", &flag_syntax_only, 1,
- N_("Check for syntax errors, then stop") },
- {"shared-data", &flag_shared_data, 1,
- N_("Mark data as shared rather than private") },
- {"caller-saves", &flag_caller_saves, 1,
- N_("Enable saving registers around function calls") },
- {"pcc-struct-return", &flag_pcc_struct_return, 1,
- N_("Return 'short' aggregates in memory, not registers") },
- {"reg-struct-return", &flag_pcc_struct_return, 0,
- N_("Return 'short' aggregates in registers") },
- {"delayed-branch", &flag_delayed_branch, 1,
- N_("Attempt to fill delay slots of branch instructions") },
- {"gcse", &flag_gcse, 1,
- N_("Perform the global common subexpression elimination") },
- {"gcse-lm", &flag_gcse_lm, 1,
- N_("Perform enhanced load motion during global subexpression elimination") },
- {"gcse-sm", &flag_gcse_sm, 1,
- N_("Perform store motion after global subexpression elimination") },
- {"loop-optimize", &flag_loop_optimize, 1,
- N_("Perform the loop optimizations") },
- {"crossjumping", &flag_crossjumping, 1,
- N_("Perform cross-jumping optimization") },
- {"if-conversion", &flag_if_conversion, 1,
- N_("Perform conversion of conditional jumps to branchless equivalents") },
- {"if-conversion2", &flag_if_conversion2, 1,
- N_("Perform conversion of conditional jumps to conditional execution") },
- {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
- N_("Run CSE pass after loop optimizations") },
- {"rerun-loop-opt", &flag_rerun_loop_opt, 1,
- N_("Run the loop optimizer twice") },
- {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
- N_("Delete useless null pointer checks") },
- {"schedule-insns", &flag_schedule_insns, 1,
- N_("Reschedule instructions before register allocation") },
- {"schedule-insns2", &flag_schedule_insns_after_reload, 1,
- N_("Reschedule instructions after register allocation") },
- {"sched-interblock",&flag_schedule_interblock, 1,
- N_("Enable scheduling across basic blocks") },
- {"sched-spec",&flag_schedule_speculative, 1,
- N_("Allow speculative motion of non-loads") },
- {"sched-spec-load",&flag_schedule_speculative_load, 1,
- N_("Allow speculative motion of some loads") },
- {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
- N_("Allow speculative motion of more loads") },
- {"sched2-use-superblocks", &flag_sched2_use_superblocks, 1,
- N_("If scheduling post reload, do superblock scheduling") },
- {"sched2-use-traces", &flag_sched2_use_traces, 1,
- N_("If scheduling post reload, do trace scheduling") },
- {"branch-count-reg",&flag_branch_on_count_reg, 1,
- N_("Replace add,compare,branch with branch on count reg") },
- {"pic", &flag_pic, 1,
- N_("Generate position independent code, if possible") },
- {"PIC", &flag_pic, 2, ""},
- {"pie", &flag_pie, 1,
- N_("Generate position independent code for executables, if possible") },
- {"PIE", &flag_pie, 2, ""},
- {"exceptions", &flag_exceptions, 1,
- N_("Enable exception handling") },
- {"unwind-tables", &flag_unwind_tables, 1,
- N_("Just generate unwind tables for exception handling") },
- {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1,
- N_("Generate unwind tables exact at each instruction boundary") },
- {"non-call-exceptions", &flag_non_call_exceptions, 1,
- N_("Support synchronous non-call exceptions") },
- {"profile-arcs", &profile_arc_flag, 1,
- N_("Insert arc based program profiling code") },
- {"test-coverage", &flag_test_coverage, 1,
- N_("Create data files needed by gcov") },
- {"branch-probabilities", &flag_branch_probabilities, 1,
- N_("Use profiling information for branch probabilities") },
- {"profile", &profile_flag, 1,
- N_("Enable basic program profiling code") },
- {"reorder-blocks", &flag_reorder_blocks, 1,
- N_("Reorder basic blocks to improve code placement") },
- {"reorder-functions", &flag_reorder_functions, 1,
- N_("Reorder functions to improve code placement") },
- {"rename-registers", &flag_rename_registers, 1,
- N_("Do the register renaming optimization pass") },
- {"cprop-registers", &flag_cprop_registers, 1,
- N_("Do the register copy-propagation optimization pass") },
- {"common", &flag_no_common, 0,
- N_("Do not put uninitialized globals in the common section") },
- {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
- N_("Do not generate .size directives") },
- {"function-sections", &flag_function_sections, 1,
- N_("place each function into its own section") },
- {"data-sections", &flag_data_sections, 1,
- N_("place data items into their own section") },
- {"verbose-asm", &flag_verbose_asm, 1,
- N_("Add extra commentary to assembler output") },
- {"gnu-linker", &flag_gnu_linker, 1,
- N_("Output GNU ld formatted global initializers") },
- {"regmove", &flag_regmove, 1,
- N_("Enables a register move optimization") },
- {"optimize-register-move", &flag_regmove, 1,
- N_("Do the full regmove optimization pass") },
- {"pack-struct", &flag_pack_struct, 1,
- N_("Pack structure members together without holes") },
- {"stack-check", &flag_stack_check, 1,
- N_("Insert stack checking code into the program") },
- {"argument-alias", &flag_argument_noalias, 0,
- N_("Specify that arguments may alias each other & globals") },
- {"argument-noalias", &flag_argument_noalias, 1,
- N_("Assume arguments may alias globals but not each other") },
- {"argument-noalias-global", &flag_argument_noalias, 2,
- N_("Assume arguments do not alias each other or globals") },
- {"strict-aliasing", &flag_strict_aliasing, 1,
- N_("Assume strict aliasing rules apply") },
- {"align-loops", &align_loops, 0,
- N_("Align the start of loops") },
- {"align-jumps", &align_jumps, 0,
- N_("Align labels which are only reached by jumping") },
- {"align-labels", &align_labels, 0,
- N_("Align all labels") },
- {"align-functions", &align_functions, 0,
- N_("Align the start of functions") },
- {"merge-constants", &flag_merge_constants, 1,
- N_("Attempt to merge identical constants across compilation units") },
- {"merge-all-constants", &flag_merge_constants, 2,
- N_("Attempt to merge identical constants and constant variables") },
- {"dump-unnumbered", &flag_dump_unnumbered, 1,
- N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
- {"instrument-functions", &flag_instrument_function_entry_exit, 1,
- N_("Instrument function entry/exit with profiling calls") },
- {"zero-initialized-in-bss", &flag_zero_initialized_in_bss, 1,
- N_("Put zero initialized data in the bss section") },
- {"ssa", &flag_ssa, 1,
- N_("Enable SSA optimizations") },
- {"ssa-ccp", &flag_ssa_ccp, 1,
- N_("Enable SSA conditional constant propagation") },
- {"ssa-dce", &flag_ssa_dce, 1,
- N_("Enable aggressive SSA dead code elimination") },
- {"leading-underscore", &flag_leading_underscore, 1,
- N_("External symbols have a leading underscore") },
- {"ident", &flag_no_ident, 0,
- N_("Process #ident directives") },
- { "peephole2", &flag_peephole2, 1,
- N_("Enables an rtl peephole pass run before sched2") },
- {"finite-math-only", &flag_finite_math_only, 1,
- N_("Assume no NaNs or +-Infs are generated") },
- { "guess-branch-probability", &flag_guess_branch_prob, 1,
- N_("Enables guessing of branch probabilities") },
- {"math-errno", &flag_errno_math, 1,
- N_("Set errno after built-in math functions") },
- {"trapping-math", &flag_trapping_math, 1,
- N_("Floating-point operations can trap") },
- {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
- N_("Allow math optimizations that may violate IEEE or ANSI standards") },
- {"signaling-nans", &flag_signaling_nans, 1,
- N_("Disable optimizations observable by IEEE signaling NaNs") },
- {"bounds-check", &flag_bounds_check, 1,
- N_("Generate code to check bounds before indexing arrays") },
- {"single-precision-constant", &flag_single_precision_constant, 1,
- N_("Convert floating point constant to single precision constant") },
- {"time-report", &time_report, 1,
- N_("Report time taken by each compiler pass at end of run") },
- {"mem-report", &mem_report, 1,
- N_("Report on permanent memory allocation at end of run") },
- { "trapv", &flag_trapv, 1,
- N_("Trap for signed overflow in addition / subtraction / multiplication") },
- { "wrapv", &flag_wrapv, 1,
- N_("Assume signed arithmetic overflow wraps around") },
- { "new-ra", &flag_new_regalloc, 1,
- N_("Use graph coloring register allocation.") },
-};
-
-/* Table of language-specific options. */
-
-static const struct lang_opt
-{
- const char *const option;
- const char *const description;
-}
-documented_lang_options[] =
-{
- /* In order not to overload the --help output, the convention
- used here is to only describe those options which are not
- enabled by default. */
-
- { "-ansi",
- N_("Compile just for ISO C90") },
- { "-std= ",
- N_("Determine language standard") },
-
- { "-fsigned-bitfields", "" },
- { "-funsigned-bitfields",
- N_("Make bit-fields by unsigned by default") },
- { "-fno-signed-bitfields", "" },
- { "-fno-unsigned-bitfields","" },
- { "-fsigned-char",
- N_("Make 'char' be signed by default") },
- { "-funsigned-char",
- N_("Make 'char' be unsigned by default") },
- { "-fno-signed-char", "" },
- { "-fno-unsigned-char", "" },
-
- { "-fasm", "" },
- { "-fno-asm",
- N_("Do not recognize the 'asm' keyword") },
- { "-fbuiltin", "" },
- { "-fno-builtin",
- N_("Do not recognize any built in functions") },
- { "-fhosted",
- N_("Assume normal C execution environment") },
- { "-fno-hosted", "" },
- { "-ffreestanding",
- N_("Assume that standard libraries & main might not exist") },
- { "-fno-freestanding", "" },
- { "-fcond-mismatch",
- N_("Allow different types as args of ? operator") },
- { "-fno-cond-mismatch", "" },
- { "-fdollars-in-identifiers",
- N_("Allow the use of $ inside identifiers") },
- { "-fno-dollars-in-identifiers", "" },
- { "-fpreprocessed", "" },
- { "-fno-preprocessed", "" },
- { "-fshort-double",
- N_("Use the same size for double as for float") },
- { "-fno-short-double", "" },
- { "-fshort-enums",
- N_("Use the smallest fitting integer to hold enums") },
- { "-fno-short-enums", "" },
- { "-fshort-wchar",
- N_("Override the underlying type for wchar_t to `unsigned short'") },
- { "-fno-short-wchar", "" },
-
- { "-Wall",
- N_("Enable most warning messages") },
- { "-Wbad-function-cast",
- N_("Warn about casting functions to incompatible types") },
- { "-Wno-bad-function-cast", "" },
- { "-Wmissing-format-attribute",
- N_("Warn about functions which might be candidates for format attributes") },
- { "-Wno-missing-format-attribute", "" },
- { "-Wcast-qual",
- N_("Warn about casts which discard qualifiers") },
- { "-Wno-cast-qual", "" },
- { "-Wchar-subscripts",
- N_("Warn about subscripts whose type is 'char'") },
- { "-Wno-char-subscripts", "" },
- { "-Wcomment",
- N_("Warn if nested comments are detected") },
- { "-Wno-comment", "" },
- { "-Wcomments",
- N_("Warn if nested comments are detected") },
- { "-Wno-comments", "" },
- { "-Wconversion",
- N_("Warn about possibly confusing type conversions") },
- { "-Wno-conversion", "" },
- { "-Wdiv-by-zero", "" },
- { "-Wno-div-by-zero",
- N_("Do not warn about compile-time integer division by zero") },
- { "-Wfloat-equal",
- N_("Warn about testing equality of floating point numbers") },
- { "-Wno-float-equal", "" },
- { "-Wformat",
- N_("Warn about printf/scanf/strftime/strfmon format anomalies") },
- { "-Wno-format", "" },
- { "-Wformat-extra-args", "" },
- { "-Wno-format-extra-args",
- N_("Don't warn about too many arguments to format functions") },
- { "-Wformat-nonliteral",
- N_("Warn about non-string-literal format strings") },
- { "-Wno-format-nonliteral", "" },
- { "-Wformat-security",
- N_("Warn about possible security problems with format functions") },
- { "-Wno-format-security", "" },
- { "-Wformat-y2k", "" },
- { "-Wno-format-y2k",
- N_("Don't warn about strftime formats yielding 2 digit years") },
- { "-Wimplicit-function-declaration",
- N_("Warn about implicit function declarations") },
- { "-Wno-implicit-function-declaration", "" },
- { "-Werror-implicit-function-declaration", "" },
- { "-Wimplicit-int",
- N_("Warn when a declaration does not specify a type") },
- { "-Wno-implicit-int", "" },
- { "-Wimplicit", "" },
- { "-Wno-implicit", "" },
- { "-Wimport",
- N_("Warn about the use of the #import directive") },
- { "-Wno-import", "" },
- { "-Winvalid-pch",
- N_("Warn about PCH files that are found but not used") },
- { "-Wlong-long","" },
- { "-Wno-long-long",
- N_("Do not warn about using 'long long' when -pedantic") },
- { "-Wmain",
- N_("Warn about suspicious declarations of main") },
- { "-Wno-main", "" },
- { "-Wmissing-braces",
- N_("Warn about possibly missing braces around initializers") },
- { "-Wno-missing-braces", "" },
- { "-Wmissing-declarations",
- N_("Warn about global funcs without previous declarations") },
- { "-Wno-missing-declarations", "" },
- { "-Wmissing-prototypes",
- N_("Warn about global funcs without prototypes") },
- { "-Wno-missing-prototypes", "" },
- { "-Wmultichar",
- N_("Warn about use of multicharacter literals") },
- { "-Wno-multichar", "" },
- { "-Wnested-externs",
- N_("Warn about externs not at file scope level") },
- { "-Wno-nested-externs", "" },
- { "-Wparentheses",
- N_("Warn about possible missing parentheses") },
- { "-Wno-parentheses", "" },
- { "-Wpointer-arith",
- N_("Warn about function pointer arithmetic") },
- { "-Wno-pointer-arith", "" },
- { "-Wredundant-decls",
- N_("Warn about multiple declarations of the same object") },
- { "-Wno-redundant-decls", "" },
- { "-Wreturn-type",
- N_("Warn whenever a function's return-type defaults to int") },
- { "-Wno-return-type", "" },
- { "-Wsequence-point",
- N_("Warn about possible violations of sequence point rules") },
- { "-Wno-sequence-point", "" },
- { "-Wsign-compare",
- N_("Warn about signed/unsigned comparisons") },
- { "-Wno-sign-compare", "" },
- { "-Wstrict-prototypes",
- N_("Warn about non-prototyped function decls") },
- { "-Wno-strict-prototypes", "" },
- { "-Wtraditional",
- N_("Warn about constructs whose meanings change in ISO C") },
- { "-Wno-traditional", "" },
- { "-Wtrigraphs",
- N_("Warn when trigraphs are encountered") },
- { "-Wno-trigraphs", "" },
- { "-Wundef", "" },
- { "-Wno-undef", "" },
- { "-Wunknown-pragmas",
- N_("Warn about unrecognized pragmas") },
- { "-Wno-unknown-pragmas", "" },
- { "-Wwrite-strings",
- N_("Mark strings as 'const char *'") },
- { "-Wno-write-strings", "" },
-
-#define DEFINE_LANG_NAME(NAME) { NULL, NAME },
-
-#include "options_.h"
-
+ {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1 },
+ {"eliminate-unused-debug-symbols", &flag_debug_only_used_symbols, 1 },
+ {"eliminate-unused-debug-types", &flag_eliminate_unused_debug_types, 1 },
+ {"float-store", &flag_float_store, 1 },
+ {"defer-pop", &flag_defer_pop, 1 },
+ {"omit-frame-pointer", &flag_omit_frame_pointer, 1 },
+ {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1 },
+ {"tracer", &flag_tracer, 1 },
+ {"unit-at-a-time", &flag_unit_at_a_time, 1 },
+ {"cse-follow-jumps", &flag_cse_follow_jumps, 1 },
+ {"cse-skip-blocks", &flag_cse_skip_blocks, 1 },
+ {"expensive-optimizations", &flag_expensive_optimizations, 1 },
+ {"thread-jumps", &flag_thread_jumps, 1 },
+ {"strength-reduce", &flag_strength_reduce, 1 },
+ {"unroll-loops", &flag_unroll_loops, 1 },
+ {"unroll-all-loops", &flag_unroll_all_loops, 1 },
+ {"old-unroll-loops", &flag_old_unroll_loops, 1 },
+ {"old-unroll-all-loops", &flag_old_unroll_all_loops, 1 },
+ {"peel-loops", &flag_peel_loops, 1 },
+ {"unswitch-loops", &flag_unswitch_loops, 1 },
+ {"prefetch-loop-arrays", &flag_prefetch_loop_arrays, 1 },
+ {"move-all-movables", &flag_move_all_movables, 1 },
+ {"reduce-all-givs", &flag_reduce_all_givs, 1 },
+ {"writable-strings", &flag_writable_strings, 1 },
+ {"peephole", &flag_no_peephole, 0 },
+ {"force-mem", &flag_force_mem, 1 },
+ {"force-addr", &flag_force_addr, 1 },
+ {"function-cse", &flag_no_function_cse, 0 },
+ {"inline-functions", &flag_inline_functions, 1 },
+ {"keep-inline-functions", &flag_keep_inline_functions, 1 },
+ {"inline", &flag_no_inline, 0 },
+ {"keep-static-consts", &flag_keep_static_consts, 1 },
+ {"syntax-only", &flag_syntax_only, 1 },
+ {"shared-data", &flag_shared_data, 1 },
+ {"caller-saves", &flag_caller_saves, 1 },
+ {"pcc-struct-return", &flag_pcc_struct_return, 1 },
+ {"reg-struct-return", &flag_pcc_struct_return, 0 },
+ {"delayed-branch", &flag_delayed_branch, 1 },
+ {"web", &flag_web, 1},
+ {"gcse", &flag_gcse, 1 },
+ {"gcse-lm", &flag_gcse_lm, 1 },
+ {"gcse-sm", &flag_gcse_sm, 1 },
+ {"gcse-las", &flag_gcse_las, 1 },
+ {"branch-target-load-optimize", &flag_branch_target_load_optimize, 1 },
+ {"branch-target-load-optimize2", &flag_branch_target_load_optimize2, 1 },
+ {"btr-bb-exclusive", &flag_btr_bb_exclusive, 1 },
+ {"loop-optimize", &flag_loop_optimize, 1 },
+ {"crossjumping", &flag_crossjumping, 1 },
+ {"if-conversion", &flag_if_conversion, 1 },
+ {"if-conversion2", &flag_if_conversion2, 1 },
+ {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1 },
+ {"rerun-loop-opt", &flag_rerun_loop_opt, 1 },
+ {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1 },
+ {"schedule-insns", &flag_schedule_insns, 1 },
+ {"schedule-insns2", &flag_schedule_insns_after_reload, 1 },
+ {"sched-interblock",&flag_schedule_interblock, 1 },
+ {"sched-spec",&flag_schedule_speculative, 1 },
+ {"sched-spec-load",&flag_schedule_speculative_load, 1 },
+ {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1 },
+ {"sched-stalled-insns", &flag_sched_stalled_insns, 0 },
+ {"sched-stalled-insns-dep", &flag_sched_stalled_insns_dep, 1 },
+ {"sched2-use-superblocks", &flag_sched2_use_superblocks, 1 },
+ {"sched2-use-traces", &flag_sched2_use_traces, 1 },
+ {"branch-count-reg",&flag_branch_on_count_reg, 1 },
+ {"pic", &flag_pic, 1 },
+ {"PIC", &flag_pic, 2 },
+ {"pie", &flag_pie, 1 },
+ {"PIE", &flag_pie, 2 },
+ {"exceptions", &flag_exceptions, 1 },
+ {"unwind-tables", &flag_unwind_tables, 1 },
+ {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1 },
+ {"non-call-exceptions", &flag_non_call_exceptions, 1 },
+ {"profile-arcs", &profile_arc_flag, 1 },
+ {"profile-values", &flag_profile_values, 1 },
+ {"vpt", &flag_value_profile_transformations, 1 },
+ {"test-coverage", &flag_test_coverage, 1 },
+ {"branch-probabilities", &flag_branch_probabilities, 1 },
+ {"profile", &profile_flag, 1 },
+ {"reorder-blocks", &flag_reorder_blocks, 1 },
+ {"reorder-functions", &flag_reorder_functions, 1 },
+ {"rename-registers", &flag_rename_registers, 1 },
+ {"cprop-registers", &flag_cprop_registers, 1 },
+ {"common", &flag_no_common, 0 },
+ {"inhibit-size-directive", &flag_inhibit_size_directive, 1 },
+ {"function-sections", &flag_function_sections, 1 },
+ {"data-sections", &flag_data_sections, 1 },
+ {"verbose-asm", &flag_verbose_asm, 1 },
+ {"regmove", &flag_regmove, 1 },
+ {"optimize-register-move", &flag_regmove, 1 },
+ {"pack-struct", &flag_pack_struct, 1 },
+ {"stack-check", &flag_stack_check, 1 },
+ {"argument-alias", &flag_argument_noalias, 0 },
+ {"argument-noalias", &flag_argument_noalias, 1 },
+ {"argument-noalias-global", &flag_argument_noalias, 2 },
+ {"strict-aliasing", &flag_strict_aliasing, 1 },
+ {"align-loops", &align_loops, 0 },
+ {"align-jumps", &align_jumps, 0 },
+ {"align-labels", &align_labels, 0 },
+ {"align-functions", &align_functions, 0 },
+ {"merge-constants", &flag_merge_constants, 1 },
+ {"merge-all-constants", &flag_merge_constants, 2 },
+ {"dump-unnumbered", &flag_dump_unnumbered, 1 },
+ {"instrument-functions", &flag_instrument_function_entry_exit, 1 },
+ {"zero-initialized-in-bss", &flag_zero_initialized_in_bss, 1 },
+ {"leading-underscore", &flag_leading_underscore, 1 },
+ {"ident", &flag_no_ident, 0 },
+ { "peephole2", &flag_peephole2, 1 },
+ {"finite-math-only", &flag_finite_math_only, 1 },
+ { "guess-branch-probability", &flag_guess_branch_prob, 1 },
+ {"math-errno", &flag_errno_math, 1 },
+ {"trapping-math", &flag_trapping_math, 1 },
+ {"rounding-math", &flag_rounding_math, 1 },
+ {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1 },
+ {"signaling-nans", &flag_signaling_nans, 1 },
+ {"bounds-check", &flag_bounds_check, 1 },
+ {"single-precision-constant", &flag_single_precision_constant, 1 },
+ {"time-report", &time_report, 1 },
+ {"mem-report", &mem_report, 1 },
+ { "trapv", &flag_trapv, 1 },
+ { "wrapv", &flag_wrapv, 1 },
+ { "new-ra", &flag_new_regalloc, 1 }
};
/* Here is a table, controlled by the tm.h file, listing each -m switch
target_options[] = TARGET_OPTIONS;
#endif
-/* Options controlling warnings. */
-
-/* Don't print warning messages. -w. */
-
-int inhibit_warnings = 0;
-
-/* Don't suppress warnings from system headers. -Wsystem-headers. */
-
-int warn_system_headers = 0;
-
-/* Print various extra warnings. -W/-Wextra. */
-
-int extra_warnings = 0;
-
-/* Treat warnings as errors. -Werror. */
-
-int warnings_are_errors = 0;
-
-/* Nonzero to warn about unused variables, functions et.al. */
-
-int warn_unused_function;
-int warn_unused_label;
-int warn_unused_parameter;
-int warn_unused_variable;
-int warn_unused_value;
-
-/* Used for cooperation between set_Wunused and set_Wextra. */
-static int maybe_warn_unused_parameter;
-
-/* Nonzero to warn about code which is never reached. */
-
-int warn_notreached;
-
-/* Nonzero to warn about variables used before they are initialized. */
-
-int warn_uninitialized;
-
-/* Nonzero means warn about all declarations which shadow others. */
-
-int warn_shadow;
-
-/* Warn if a switch on an enum, that does not have a default case,
- fails to have a case for every enum value. */
-
-int warn_switch;
-
-/* Warn if a switch does not have a default case. */
-
-int warn_switch_default;
-
-/* Warn if a switch on an enum fails to have a case for every enum
- value (regardless of the presence or otherwise of a default case). */
-
-int warn_switch_enum;
-
/* Nonzero means warn about function definitions that default the return type
or that use a null return and have a return-type other than void. */
int warn_return_type;
-/* Nonzero means warn about pointer casts that increase the required
- alignment of the target type (and might therefore lead to a crash
- due to a misaligned access). */
-
-int warn_cast_align;
-
-/* Nonzero means warn about any objects definitions whose size is larger
- than N bytes. Also want about function definitions whose returned
- values are larger than N bytes. The value N is in `larger_than_size'. */
-
-int warn_larger_than;
-HOST_WIDE_INT larger_than_size;
-
-/* Nonzero means warn if inline function is too large. */
-
-int warn_inline;
-
-/* Warn if a function returns an aggregate,
- since there are often incompatible calling conventions for doing this. */
-
-int warn_aggregate_return;
-
-/* Warn if packed attribute on struct is unnecessary and inefficient. */
-
-int warn_packed;
-
-/* Warn when gcc pads a structure to an alignment boundary. */
-
-int warn_padded;
-
-/* Warn when an optimization pass is disabled. */
-
-int warn_disabled_optimization;
+/* Output files for assembler code (real compiler output)
+ and debugging dumps. */
-/* Warn about functions which might be candidates for attribute noreturn. */
+FILE *asm_out_file;
+FILE *aux_info_file;
+FILE *rtl_dump_file = NULL;
+FILE *cgraph_dump_file = NULL;
-int warn_missing_noreturn;
+/* The current working directory of a translation. It's generally the
+ directory from which compilation was initiated, but a preprocessed
+ file may specify the original directory in which it was
+ created. */
-/* Nonzero means warn about uses of __attribute__((deprecated))
- declarations. */
+static const char *src_pwd;
-int warn_deprecated_decl = 1;
+/* Initialize src_pwd with the given string, and return true. If it
+ was already initialized, return false. As a special case, it may
+ be called with a NULL argument to test whether src_pwd has NOT been
+ initialized yet. */
-/* Nonzero means warn about constructs which might not be
- strict-aliasing safe. */
+bool
+set_src_pwd (const char *pwd)
+{
+ if (src_pwd)
+ return false;
-int warn_strict_aliasing;
+ src_pwd = xstrdup (pwd);
+ return true;
+}
-/* Like f_options, but for -W. */
+/* Return the directory from which the translation unit was initiated,
+ in case set_src_pwd() was not called before to assign it a
+ different value. */
-static const lang_independent_options W_options[] =
+const char *
+get_src_pwd (void)
{
- {"unused-function", &warn_unused_function, 1,
- N_("Warn when a function is unused") },
- {"unused-label", &warn_unused_label, 1,
- N_("Warn when a label is unused") },
- {"unused-parameter", &warn_unused_parameter, 1,
- N_("Warn when a function parameter is unused") },
- {"unused-variable", &warn_unused_variable, 1,
- N_("Warn when a variable is unused") },
- {"unused-value", &warn_unused_value, 1,
- N_("Warn when an expression value is unused") },
- {"system-headers", &warn_system_headers, 1,
- N_("Do not suppress warnings from system headers") },
- {"error", &warnings_are_errors, 1,
- N_("Treat all warnings as errors") },
- {"shadow", &warn_shadow, 1,
- N_("Warn when one local variable shadows another") },
- {"switch", &warn_switch, 1,
- N_("Warn about enumerated switches, with no default, missing a case") },
- {"switch-default", &warn_switch_default, 1,
- N_("Warn about enumerated switches missing a default case") },
- {"switch-enum", &warn_switch_enum, 1,
- N_("Warn about all enumerated switches missing a specific case") },
- {"aggregate-return", &warn_aggregate_return, 1,
- N_("Warn about returning structures, unions or arrays") },
- {"cast-align", &warn_cast_align, 1,
- N_("Warn about pointer casts which increase alignment") },
- {"unreachable-code", &warn_notreached, 1,
- N_("Warn about code that will never be executed") },
- {"uninitialized", &warn_uninitialized, 1,
- N_("Warn about uninitialized automatic variables") },
- {"inline", &warn_inline, 1,
- N_("Warn when an inlined function cannot be inlined") },
- {"packed", &warn_packed, 1,
- N_("Warn when the packed attribute has no effect on struct layout") },
- {"padded", &warn_padded, 1,
- N_("Warn when padding is required to align struct members") },
- {"disabled-optimization", &warn_disabled_optimization, 1,
- N_("Warn when an optimization pass is disabled") },
- {"deprecated-declarations", &warn_deprecated_decl, 1,
- N_("Warn about uses of __attribute__((deprecated)) declarations") },
- {"missing-noreturn", &warn_missing_noreturn, 1,
- N_("Warn about functions which might be candidates for attribute noreturn") },
- {"strict-aliasing", &warn_strict_aliasing, 1,
- N_ ("Warn about code which might break the strict aliasing rules") }
-};
+ if (! src_pwd)
+ src_pwd = getpwd ();
+
+ return src_pwd;
+}
-/* Initialize unused warning flags. */
+/* Called when the start of a function definition is parsed,
+ this function prints on stderr the name of the function. */
void
-set_Wunused (int setting)
+announce_function (tree decl)
{
- warn_unused_function = setting;
- warn_unused_label = setting;
- /* Unused function parameter warnings are reported when either
- ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
- Thus, if -Wextra has already been seen, set warn_unused_parameter;
- otherwise set maybe_warn_extra_parameter, which will be picked up
- by set_Wextra. */
- maybe_warn_unused_parameter = setting;
- warn_unused_parameter = (setting && extra_warnings);
- warn_unused_variable = setting;
- warn_unused_value = setting;
+ if (!quiet_flag)
+ {
+ if (rtl_dump_and_exit)
+ verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
+ else
+ verbatim (" %s", (*lang_hooks.decl_printable_name) (decl, 2));
+ fflush (stderr);
+ pp_needs_newline (global_dc->printer) = true;
+ diagnostic_set_last_function (global_dc);
+ }
}
-/* Initialize more unused warning flags. */
+/* Set up a default flag_random_seed and local_tick, unless the user
+ already specified one. */
+
static void
-set_Wextra (int setting)
+randomize (void)
{
- extra_warnings = setting;
- warn_unused_value = setting;
- warn_unused_parameter = (setting && maybe_warn_unused_parameter);
-
- /* We save the value of warn_uninitialized, since if they put
- -Wuninitialized on the command line, we need to generate a
- warning about not using it without also specifying -O. */
- if (setting == 0)
- warn_uninitialized = 0;
- else if (warn_uninitialized != 1)
- warn_uninitialized = 2;
-}
+ if (!flag_random_seed)
+ {
+ unsigned HOST_WIDE_INT value;
+ static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
-/* The following routines are useful in setting all the flags that
- -ffast-math and -fno-fast-math imply. */
+ /* Get some more or less random data. */
+#ifdef HAVE_GETTIMEOFDAY
+ {
+ struct timeval tv;
-void
-set_fast_math_flags (int set)
-{
- flag_trapping_math = !set;
- flag_unsafe_math_optimizations = set;
- flag_finite_math_only = set;
- flag_errno_math = !set;
- if (set)
- flag_signaling_nans = 0;
-}
+ gettimeofday (&tv, NULL);
+ local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+ }
+#else
+ {
+ time_t now = time (NULL);
-/* Return true iff flags are set as if -ffast-math. */
-bool
-fast_math_flags_set_p (void)
-{
- return (!flag_trapping_math
- && flag_unsafe_math_optimizations
- && flag_finite_math_only
- && !flag_errno_math);
-}
+ if (now != (time_t)-1)
+ local_tick = (unsigned) now;
+ }
+#endif
+ value = local_tick ^ getpid ();
-/* Output files for assembler code (real compiler output)
- and debugging dumps. */
+ sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
+ flag_random_seed = random_seed;
+ }
+ else if (!local_tick)
+ local_tick = -1;
+}
-FILE *asm_out_file;
-FILE *aux_info_file;
-FILE *rtl_dump_file = NULL;
/* Decode the string P as an integral parameter.
If the string is indeed an integer return its numeric value else
#endif
}
-/* Output NAME into FILE after having turned it into something
- usable as an identifier in a target's assembly file. */
-void
-output_clean_symbol_name (FILE *file, const char *name)
-{
- /* Make a copy of NAME. */
- char *id = xstrdup (name);
-
- /* Make it look like a valid identifier for an assembler. */
- clean_symbol_name (id);
-
- fputs (id, file);
- free (id);
-}
-
-
/* Output a file name in the form wanted by System V. */
void
output_file_directive (FILE *asm_file, const char *input_name)
{
- int len = strlen (input_name);
- const char *na = input_name + len;
+ int len;
+ const char *na;
+
+ if (input_name == NULL)
+ input_name = "<stdin>";
+
+ len = strlen (input_name);
+ na = input_name + len;
/* NA gets INPUT_NAME sans directory names. */
while (na > input_name)
na--;
}
-#ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
- ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
-#else
#ifdef ASM_OUTPUT_SOURCE_FILENAME
ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
#else
output_quoted_string (asm_file, na);
fputc ('\n', asm_file);
#endif
-#endif
}
/* Routine to open a dump file. Return true if the dump file is enabled. */
{
bool needed = 1;
- if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
+ if (flag_unit_at_a_time
+ && cgraph_varpool_node (decl)->finalized)
+ needed = 0;
+ else if ((flag_unit_at_a_time && !cgraph_global_info_ready)
+ && (TREE_USED (decl)
+ || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
+ /* needed */;
+ else if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
/* needed */;
else if (DECL_COMDAT (decl))
needed = 0;
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_INITIAL (decl) != 0
&& DECL_SAVED_INSNS (decl) != 0
+ && DECL_SAVED_INSNS (decl)->saved_for_inline
&& (flag_keep_inline_functions
|| (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
|| TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
&& ! TREE_PUBLIC (decl))
{
if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
- pedwarn_with_decl (decl,
- "`%s' used but never defined");
+ pedwarn ("%J'%F' used but never defined", decl, decl);
else
- warning_with_decl (decl,
- "`%s' declared `static' but never defined");
+ warning ("%J'%F' declared `static' but never defined", decl, decl);
/* This symbol is effectively an "extern" declaration now. */
TREE_PUBLIC (decl) = 1;
assemble_external (decl);
/* Warn about static fns or vars defined but not used. */
if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
- || (warn_unused_variable && TREE_CODE (decl) == VAR_DECL))
+ /* We don't warn about "static const" variables because the
+ "rcs_id" idiom uses that construction. */
+ || (warn_unused_variable
+ && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
+ && ! DECL_IN_SYSTEM_HEADER (decl)
&& ! TREE_USED (decl)
/* The TREE_USED bit for file-scope decls is kept in the identifier,
to handle multiple external decls in different scopes. */
&& ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
/* Otherwise, ask the language. */
&& (*lang_hooks.decls.warn_unused_global) (decl))
- warning_with_decl (decl, "`%s' defined but not used");
+ warning ("%J'%D' defined but not used", decl, decl);
/* Avoid confusing the debug information machinery when there are
errors. */
}
}
+/* Warn about a use of an identifier which was marked deprecated. */
+void
+warn_deprecated_use (tree node)
+{
+ if (node == 0 || !warn_deprecated_decl)
+ return;
+
+ if (DECL_P (node))
+ warning ("`%s' is deprecated (declared at %s:%d)",
+ IDENTIFIER_POINTER (DECL_NAME (node)),
+ DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
+ else if (TYPE_P (node))
+ {
+ const char *what = NULL;
+ tree decl = TYPE_STUB_DECL (node);
+
+ if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
+ what = IDENTIFIER_POINTER (TYPE_NAME (node));
+ else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
+ && DECL_NAME (TYPE_NAME (node)))
+ what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
+
+ if (what)
+ {
+ if (decl)
+ warning ("`%s' is deprecated (declared at %s:%d)", what,
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ else
+ warning ("`%s' is deprecated", what);
+ }
+ else if (decl)
+ warning ("type is deprecated (declared at %s:%d)",
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ else
+ warning ("type is deprecated");
+ }
+}
+
/* Save the current INPUT_LOCATION on the top entry in the
INPUT_FILE_STACK. Push a new entry for FILE and LINE, and set the
INPUT_LOCATION accordingly. */
{
struct file_stack *fs;
- fs = (struct file_stack *) xmalloc (sizeof (struct file_stack));
+ fs = xmalloc (sizeof (struct file_stack));
fs->location = input_location;
fs->next = input_file_stack;
input_filename = file;
(*lang_hooks.decls.final_write_globals)();
+ cgraph_varpool_assemble_pending_decls ();
+
/* This must occur after the loop to output deferred functions.
Else the coverage initializer would not be emitted if all the
functions in this compilation unit were deferred. */
make_decl_rtl (decl, asmspec);
/* Don't output anything when a tentative file-scope definition
- is seen. But at end of compilation, do output code for them. */
- if (at_end || !DECL_DEFER_OUTPUT (decl))
- assemble_variable (decl, top_level, at_end, 0);
+ is seen. But at end of compilation, do output code for them.
+
+ We do output all variables when unit-at-a-time is active and rely on
+ callgraph code to defer them except for forward declarations
+ (see gcc.c-torture/compile/920624-1.c) */
+ if ((at_end
+ || !DECL_DEFER_OUTPUT (decl)
+ || (flag_unit_at_a_time && DECL_INITIAL (decl)))
+ && !DECL_EXTERNAL (decl))
+ {
+ if (flag_unit_at_a_time && !cgraph_global_info_ready
+ && TREE_CODE (decl) != FUNCTION_DECL && top_level)
+ cgraph_varpool_finalize_decl (decl);
+ else
+ assemble_variable (decl, top_level, at_end, 0);
+ }
#ifdef ASM_FINISH_DECLARE_OBJECT
if (decl == last_assemble_variable_decl)
static void
rest_of_handle_stack_regs (tree decl, rtx insns)
{
+#if defined (HAVE_ATTR_length)
+ /* If flow2 creates new instructions which need splitting
+ and scheduling after reload is not done, they might not be
+ split until final which doesn't allow splitting
+ if HAVE_ATTR_length. */
+#ifdef INSN_SCHEDULING
+ if (optimize && !flag_schedule_insns_after_reload)
+#else
+ if (optimize)
+#endif
+ {
+ timevar_push (TV_SHORTEN_BRANCH);
+ split_all_insns (1);
+ timevar_pop (TV_SHORTEN_BRANCH);
+ }
+#endif
+
timevar_push (TV_REG_STACK);
open_dump_file (DFI_stack, decl);
/* Run new register allocator. Return TRUE if we must exit
rest_of_compilation upon return. */
static bool
-rest_of_handle_new_regalloc (tree decl, rtx insns, int *rebuild_notes)
+rest_of_handle_new_regalloc (tree decl, rtx insns)
{
int failure;
return true;
reload_completed = 1;
- *rebuild_notes = 0;
return false;
}
/* Run old register allocator. Return TRUE if we must exit
rest_of_compilation upon return. */
static bool
-rest_of_handle_old_regalloc (tree decl, rtx insns, int *rebuild_notes)
+rest_of_handle_old_regalloc (tree decl, rtx insns)
{
int failure;
+ int rebuild_notes;
/* Allocate the reg_renumber array. */
allocate_reg_info (max_regno, FALSE, TRUE);
/* And the reg_equiv_memory_loc array. */
- reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
+ reg_equiv_memory_loc = xcalloc (max_regno, sizeof (rtx));
allocate_initial_values (reg_equiv_memory_loc);
regclass (insns, max_reg_num (), rtl_dump_file);
- *rebuild_notes = local_alloc ();
+ rebuild_notes = local_alloc ();
timevar_pop (TV_LOCAL_ALLOC);
+ /* Local allocation may have turned an indirect jump into a direct
+ jump. If so, we must rebuild the JUMP_LABEL fields of jumping
+ instructions. */
+ if (rebuild_notes)
+ {
+ timevar_push (TV_JUMP);
+
+ rebuild_jump_labels (insns);
+ purge_all_dead_edges (0);
+
+ timevar_pop (TV_JUMP);
+ }
+
if (dump_file[DFI_lreg].enabled)
{
timevar_push (TV_DUMP);
static void
rest_of_handle_reorder_blocks (tree decl, rtx insns)
{
- timevar_push (TV_REORDER_BLOCKS);
+ bool changed;
open_dump_file (DFI_bbro, decl);
/* Last attempt to optimize CFG, as scheduling, peepholing and insn
splitting possibly introduced more crossjumping opportunities. */
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE
- | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
+ changed = cleanup_cfg (CLEANUP_EXPENSIVE
+ | (!HAVE_conditional_execution
+ ? CLEANUP_UPDATE_LIFE : 0));
if (flag_sched2_use_traces && flag_schedule_insns_after_reload)
tracer ();
reorder_basic_blocks ();
if (flag_reorder_blocks
|| (flag_sched2_use_traces && flag_schedule_insns_after_reload))
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
-
+ changed |= cleanup_cfg (CLEANUP_EXPENSIVE
+ | (!HAVE_conditional_execution
+ ? CLEANUP_UPDATE_LIFE : 0));
+
+ /* On conditional execution targets we can not update the life cheaply, so
+ we deffer the updating to after both cleanups. This may lose some cases
+ but should not be terribly bad. */
+ if (changed && HAVE_conditional_execution)
+ update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
+ PROP_DEATH_NOTES | PROP_REG_INFO);
close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
- timevar_pop (TV_REORDER_BLOCKS);
}
+#ifdef INSN_SCHEDULING
/* Run instruction scheduler. */
static void
rest_of_handle_sched (tree decl, rtx insns)
{
timevar_push (TV_SCHED);
-#ifdef INSN_SCHEDULING
/* Print function header into sched dump now
because doing the sched analysis makes some of the dump. */
close_dump_file (DFI_sched, print_rtl_with_bb, insns);
}
-#endif
timevar_pop (TV_SCHED);
ggc_collect ();
}
-#ifdef INSN_SCHEDULING
/* Run second scheduling pass after reload. */
static void
rest_of_handle_sched2 (tree decl, rtx insns)
static void
rest_of_handle_tracer (tree decl, rtx insns)
{
- timevar_push (TV_TRACER);
open_dump_file (DFI_tracer, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0);
close_dump_file (DFI_tracer, print_rtl_with_bb, get_insns ());
- timevar_pop (TV_TRACER);
}
/* If-conversion and CFG cleanup. */
timevar_pop (TV_IFCVT);
}
+static void
+rest_of_handle_web (tree decl, rtx insns)
+{
+ open_dump_file (DFI_web, decl);
+ timevar_push (TV_WEB);
+ web_main ();
+ delete_trivially_dead_insns (insns, max_reg_num ());
+ cleanup_cfg (CLEANUP_EXPENSIVE);
+
+ timevar_pop (TV_WEB);
+ close_dump_file (DFI_web, print_rtl_with_bb, insns);
+ reg_scan (get_insns (), max_reg_num (), 0);
+}
+
/* Do branch profiling and static profile estimation passes. */
static void
rest_of_handle_branch_prob (tree decl, rtx insns)
timevar_push (TV_BRANCH_PROB);
open_dump_file (DFI_bp, decl);
+
if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
branch_prob ();
estimate_probability (&loops);
flow_loops_free (&loops);
+ free_dominance_info (CDI_DOMINATORS);
close_dump_file (DFI_bp, print_rtl_with_bb, insns);
timevar_pop (TV_BRANCH_PROB);
}
+/* Do optimizations based on expression value profiles. */
+static void
+rest_of_handle_value_profile_transformations (tree decl, rtx insns)
+{
+ open_dump_file (DFI_vpt, decl);
+ timevar_push (TV_VPT);
+
+ if (value_profile_transformations ())
+ cleanup_cfg (CLEANUP_EXPENSIVE);
+
+ timevar_pop (TV_VPT);
+ close_dump_file (DFI_vpt, print_rtl_with_bb, insns);
+}
+
/* Do control and data flow analysis; write some of the results to the
dump file. */
static void
life_analysis rarely eliminates modification of external memory.
*/
if (optimize)
- mark_constant_function ();
+ {
+ /* Alias analysis depends on this information and mark_constant_function
+ depends on alias analysis. */
+ reg_scan (insns, max_reg_num (), 1);
+ mark_constant_function ();
+ }
close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
}
/* Purge addressofs. */
static void
-rest_of_handle_addresof (tree decl, rtx insns)
+rest_of_handle_addressof (tree decl, rtx insns)
{
open_dump_file (DFI_addressof, decl);
purge_addressof (insns);
- if (optimize)
- purge_all_dead_edges (0);
+ if (optimize && purge_all_dead_edges (0))
+ delete_unreachable_blocks ();
reg_scan (insns, max_reg_num (), 1);
close_dump_file (DFI_addressof, print_rtl, insns);
open_dump_file (DFI_bypass, decl);
cleanup_cfg (CLEANUP_EXPENSIVE);
+ reg_scan (insns, max_reg_num (), 1);
if (bypass_jumps (rtl_dump_file))
{
/* If we are reconsidering an inline function at the end of
compilation, skip the stuff for making it inline. */
- if (DECL_SAVED_INSNS (decl) != 0)
+ if (cfun->rtl_inline_init)
return 0;
+ cfun->rtl_inline_init = 1;
/* If this is nested inside an inlined external function, pretend
it was only declared. Since we cannot inline such functions,
timevar_pop (TV_INTEGRATION);
if (lose || ! optimize)
{
- if (warn_inline && DECL_INLINE (decl))
- warning_with_decl (decl, lose);
+ if (warn_inline && lose && DECL_INLINE (decl))
+ {
+ char *msg = concat ("%J", lose, NULL);
+ warning (msg, decl);
+ free (msg);
+ }
DECL_ABSTRACT_ORIGIN (decl) = 0;
/* Don't really compile an extern inline function.
If we can't make it inline, pretend
return true;
}
}
- else {
- /* ??? Note that we used to just make it look like if
- the "inline" keyword was specified when we decide
- to inline it (because of -finline-functions).
- garloff@suse.de, 2002-04-24: Add another flag to
- actually record this piece of information. */
- if (!DECL_INLINE (decl))
- DID_INLINE_FUNC (decl) = 1;
+ else
inlinable = DECL_INLINE (decl) = 1;
- }
}
insns = get_insns ();
if (open_dump_file (DFI_rtl, decl))
{
- if (DECL_SAVED_INSNS (decl))
+ if (DECL_SAVED_INSNS (decl) && DECL_SAVED_INSNS (decl)->saved_for_inline)
fprintf (rtl_dump_file, ";; (integrable)\n\n");
close_dump_file (DFI_rtl, print_rtl, insns);
}
if (inlinable
|| (DECL_INLINE (decl)
- && flag_inline_functions
+ /* Egad. This RTL deferral test conflicts with Fortran assumptions
+ for unreferenced symbols. See g77.f-torture/execute/980520-1.f.
+ But removing this line from the check breaks all languages that
+ use the call graph to output symbols. This hard-coded check is
+ the least invasive work-around. */
+ && (flag_inline_functions
+ || strcmp (lang_hooks.name, "GNU F77") == 0)
&& ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
&& ! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
&& ! flag_keep_inline_functions)
return (bool) DECL_EXTERNAL (decl);
}
-/* Rest of compilation helper to convert the rtl to SSA form. */
-static rtx
-rest_of_handle_ssa (tree decl, rtx insns)
-{
- timevar_push (TV_TO_SSA);
- open_dump_file (DFI_ssa, decl);
-
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
- convert_to_ssa ();
-
- close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
- timevar_pop (TV_TO_SSA);
-
- /* Perform sparse conditional constant propagation, if requested. */
- if (flag_ssa_ccp)
- {
- timevar_push (TV_SSA_CCP);
- open_dump_file (DFI_ssa_ccp, decl);
-
- ssa_const_prop ();
-
- close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
- timevar_pop (TV_SSA_CCP);
- }
-
- /* It would be useful to cleanup the CFG at this point, but block
- merging and possibly other transformations might leave a PHI
- node in the middle of a basic block, which is a strict no-no. */
-
- /* The SSA implementation uses basic block numbers in its phi
- nodes. Thus, changing the control-flow graph or the basic
- blocks, e.g., calling find_basic_blocks () or cleanup_cfg (),
- may cause problems. */
-
- if (flag_ssa_dce)
- {
- /* Remove dead code. */
-
- timevar_push (TV_SSA_DCE);
- open_dump_file (DFI_ssa_dce, decl);
-
- insns = get_insns ();
- ssa_eliminate_dead_code ();
-
- close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
- timevar_pop (TV_SSA_DCE);
- }
-
- /* Convert from SSA form. */
-
- timevar_push (TV_FROM_SSA);
- open_dump_file (DFI_ussa, decl);
-
- convert_from_ssa ();
- /* New registers have been created. Rescan their usage. */
- reg_scan (insns, max_reg_num (), 1);
-
- close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
- timevar_pop (TV_FROM_SSA);
-
- ggc_collect ();
-
- return insns;
-}
-
/* Try to identify useless null pointer tests and delete them. */
static void
rest_of_handle_null_pointer (tree decl, rtx insns)
life_analysis (insns, rtl_dump_file, PROP_FINAL);
if (optimize)
cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_UPDATE_LIFE
+ | CLEANUP_LOG_LINKS
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
timevar_pop (TV_FLOW);
tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
if (tem)
rebuild_jump_labels (insns);
- purge_all_dead_edges (0);
+ if (purge_all_dead_edges (0))
+ delete_unreachable_blocks ();
delete_trivially_dead_insns (insns, max_reg_num ());
dump_flow_info (rtl_dump_file);
/* CFG is no longer maintained up-to-date. */
tem = cse_main (insns, max_reg_num (), 1, rtl_dump_file);
+
+ /* Run a pass to eliminate duplicated assignments to condition code
+ registers. We have to run this after bypass_jumps, because it
+ makes it harder for that pass to determine whether a jump can be
+ bypassed safely. */
+ cse_condition_code_reg ();
+
purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ());
free_bb_for_insn ();
if (flag_unroll_loops)
- do_unroll = 0; /* Having two unrollers is useless. */
+ do_unroll = LOOP_AUTO_UNROLL; /* Having two unrollers is useless. */
else
do_unroll = flag_old_unroll_loops ? LOOP_UNROLL : LOOP_AUTO_UNROLL;
do_prefetch = flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0;
ggc_collect ();
}
-/* Perform loop optimalizations. It might be better to do them a bit
+/* Perform loop optimizations. It might be better to do them a bit
sooner, but we want the profile feedback to work more
efficiently. */
static void
if (loops)
{
- /* The optimalizations: */
+ /* The optimizations: */
if (flag_unswitch_loops)
unswitch_loops (loops);
rest_of_compilation (tree decl)
{
rtx insns;
- int rebuild_label_notes_after_reload;
timevar_push (TV_REST_OF_COMPILATION);
/* Register rtl specific functions for cfg. */
rtl_register_cfg_hooks ();
-
+
/* Now that we're out of the frontend, we shouldn't have any more
CONCATs anywhere. */
generating_concat_p = 0;
/* We are now committed to emitting code for this function. Do any
preparation, such as emitting abstract debug info for the inline
before it gets mangled by optimization. */
- if (DECL_INLINE (decl))
+ if (cgraph_function_possibly_inlined_p (decl))
(*debug_hooks->outlining_inline_function) (decl);
/* Remove any notes we don't need. That will make iterating
delete_unreachable_blocks ();
- /* We have to issue these warnings now already, because CFG cleanups
- further down may destroy the required information. */
- check_function_return_warnings ();
-
/* Turn NOTE_INSN_PREDICTIONs into branch predictions. */
if (flag_guess_branch_prob)
{
if (flag_optimize_sibling_calls)
rest_of_handle_sibling_calls (insns);
- timevar_pop (TV_JUMP);
+ /* We have to issue these warnings now already, because CFG cleanups
+ further down may destroy the required information. However, this
+ must be done after the sibcall optimization pass because the barrier
+ emitted for noreturn calls that are candidate for the optimization
+ is folded into the CALL_PLACEHOLDER until after this pass, so the
+ CFG is inaccurate. */
+ check_function_return_warnings ();
+
+ timevar_pop (TV_JUMP);
insn_locators_initialize ();
/* Complete generation of exception handling code. */
if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
goto exit_rest_of_compilation;
- /* Long term, this should probably move before the jump optimizer too,
- but I didn't want to disturb the rtl_dump_and_exit and related
- stuff at this time. */
- if (optimize > 0 && flag_ssa)
- insns = rest_of_handle_ssa (decl, insns);
-
timevar_push (TV_JUMP);
if (optimize)
if (optimize > 0)
rest_of_handle_cse (decl, insns);
- rest_of_handle_addresof (decl, insns);
+ rest_of_handle_addressof (decl, insns);
ggc_collect ();
if (flag_loop_optimize)
rest_of_handle_loop_optimize (decl, insns);
-
- if (flag_gcse)
- rest_of_handle_jump_bypass (decl, insns);
}
timevar_push (TV_FLOW);
if (optimize > 0
|| profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
- rest_of_handle_branch_prob (decl, insns);
+ {
+ rest_of_handle_branch_prob (decl, insns);
+
+ if (flag_branch_probabilities
+ && flag_profile_values
+ && flag_value_profile_transformations)
+ rest_of_handle_value_profile_transformations (decl, insns);
+
+ /* Remove the death notes created for vpt. */
+ if (flag_profile_values)
+ count_or_remove_death_notes (NULL, 1);
+ }
if (optimize > 0)
rest_of_handle_if_conversion (decl, insns);
if (flag_tracer)
rest_of_handle_tracer (decl, insns);
- if (optimize > 0
- && (flag_unswitch_loops
+ if (optimize > 0)
+ {
+ if (flag_unswitch_loops
|| flag_peel_loops
- || flag_unroll_loops))
- rest_of_handle_loop2 (decl, insns);
+ || flag_unroll_loops)
+ rest_of_handle_loop2 (decl, insns);
+
+ if (flag_gcse)
+ rest_of_handle_jump_bypass (decl, insns);
+ }
+
+ if (flag_web)
+ rest_of_handle_web (decl, insns);
if (flag_rerun_cse_after_loop)
rest_of_handle_cse2 (decl, insns);
(see handling of reg_known_equiv in init_alias_analysis). */
recompute_reg_usage (insns, !optimize_size);
+#ifdef INSN_SCHEDULING
rest_of_handle_sched (decl, insns);
+#endif
/* Determine if the current function is a leaf before running reload
since this can impact optimizations done by the prologue and
if (flag_new_regalloc)
{
- if (rest_of_handle_new_regalloc (decl, insns,
- &rebuild_label_notes_after_reload))
+ if (rest_of_handle_new_regalloc (decl, insns))
goto exit_rest_of_compilation;
}
else
{
- if (rest_of_handle_old_regalloc (decl, insns,
- &rebuild_label_notes_after_reload))
+ if (rest_of_handle_old_regalloc (decl, insns))
goto exit_rest_of_compilation;
}
{
timevar_push (TV_RELOAD_CSE_REGS);
reload_cse_regs (insns);
+ /* reload_cse_regs can eliminate potentially-trapping MEMs.
+ Remove any EH edges associated with them. */
+ if (flag_non_call_exceptions)
+ purge_all_dead_edges (0);
timevar_pop (TV_RELOAD_CSE_REGS);
}
- /* Register allocation and reloading may have turned an indirect jump into
- a direct jump. If so, we must rebuild the JUMP_LABEL fields of
- jumping instructions. */
- if (rebuild_label_notes_after_reload)
- {
- timevar_push (TV_JUMP);
-
- rebuild_jump_labels (insns);
- purge_all_dead_edges (0);
-
- timevar_pop (TV_JUMP);
- }
-
close_dump_file (DFI_postreload, print_rtl_with_bb, insns);
/* Re-create the death notes which were deleted during reload. */
#endif
split_all_insns (0);
+ if (flag_branch_target_load_optimize)
+ {
+ open_dump_file (DFI_branch_target_load, decl);
+
+ branch_target_load_optimize (insns, false);
+
+ close_dump_file (DFI_branch_target_load, print_rtl_with_bb, insns);
+
+ ggc_collect ();
+ }
+
if (optimize)
cleanup_cfg (CLEANUP_EXPENSIVE);
it and the rest of the code and also allows delayed branch
scheduling to operate in the epilogue. */
thread_prologue_and_epilogue_insns (insns);
+ epilogue_completed = 1;
if (optimize)
{
- life_analysis (insns, rtl_dump_file, PROP_FINAL);
+ life_analysis (insns, rtl_dump_file, PROP_POSTRELOAD);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE
| (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
}
#endif
+ open_dump_file (DFI_ce3, decl);
+ if (optimize)
+ /* Last attempt to optimize CFG, as scheduling, peepholing and insn
+ splitting possibly introduced more crossjumping opportunities. */
+ cleanup_cfg (CLEANUP_EXPENSIVE
+ | CLEANUP_UPDATE_LIFE
+ | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
+ if (flag_if_conversion2)
+ {
+ timevar_push (TV_IFCVT2);
+
+ if_convert (1);
+
+ timevar_pop (TV_IFCVT2);
+ }
+ close_dump_file (DFI_ce3, print_rtl_with_bb, insns);
+
if (optimize > 0)
{
if (flag_rename_registers || flag_cprop_registers)
rest_of_handle_reorder_blocks (decl, insns);
}
- if (flag_if_conversion2)
+ if (flag_branch_target_load_optimize2)
{
- timevar_push (TV_IFCVT2);
- open_dump_file (DFI_ce3, decl);
+ /* Leave this a warning for now so that it is possible to experiment
+ with running this pass twice. In 3.6, we should either make this
+ an error, or use separate dump files. */
+ if (flag_branch_target_load_optimize)
+ warning ("branch target register load optimization is not intended "
+ "to be run twice");
- if_convert (1);
+ open_dump_file (DFI_branch_target_load, decl);
- close_dump_file (DFI_ce3, print_rtl_with_bb, insns);
- timevar_pop (TV_IFCVT2);
+ branch_target_load_optimize (insns, true);
+
+ close_dump_file (DFI_branch_target_load, print_rtl_with_bb, insns);
+
+ ggc_collect ();
}
#ifdef INSN_SCHEDULING
#endif
reload_completed = 0;
+ epilogue_completed = 0;
flow2_completed = 0;
no_new_pseudos = 0;
if (! DECL_DEFER_OUTPUT (decl))
{
free_after_compilation (cfun);
-
- /* Clear integrate.c's pointer to the cfun structure we just
- destroyed. */
DECL_SAVED_INSNS (decl) = 0;
}
cfun = 0;
timevar_pop (TV_REST_OF_COMPILATION);
}
-/* Display help for generic options. */
-void
-display_help (void)
-{
- int undoc;
- unsigned long i;
- const char *lang;
-
- printf (_(" -ffixed-<register> Mark <register> as being unavailable to the compiler\n"));
- printf (_(" -fcall-used-<register> Mark <register> as being corrupted by function calls\n"));
- printf (_(" -fcall-saved-<register> Mark <register> as being preserved across functions\n"));
- printf (_(" -finline-limit=<number> Limits the size of inlined functions to <number>\n"));
- printf (_(" -fmessage-length=<number> Limits diagnostics messages lengths to <number> characters per line. 0 suppresses line-wrapping\n"));
- 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"));
- printf (_(" -ftls-model=[global-dynamic | local-dynamic | initial-exec | local-exec] Indicates the default thread-local storage code generation model\n"));
- printf (_(" -fstack-limit-register=<register> Trap if the stack goes past <register>\n"));
- printf (_(" -fstack-limit-symbol=<name> Trap if the stack goes past symbol <name>\n"));
- printf (_(" -frandom-seed=<string> Make compile reproducible using <string>\n"));
-
-
- for (i = ARRAY_SIZE (f_options); i--;)
- {
- const char *description = f_options[i].description;
-
- if (description != NULL && *description != 0)
- printf (" -f%-21s %s\n",
- f_options[i].string, _(description));
- }
-
- printf (_(" -O[number] Set optimization level to [number]\n"));
- printf (_(" -Os Optimize for space rather than speed\n"));
- for (i = LAST_PARAM; i--;)
- {
- const char *description = compiler_params[i].help;
- const int length = 21 - strlen (compiler_params[i].option);
-
- if (description != NULL && *description != 0)
- printf (" --param %s=<value>%.*s%s\n",
- compiler_params[i].option,
- length > 0 ? length : 1, " ",
- _(description));
- }
- printf (_(" -pedantic Issue warnings needed by strict compliance to ISO C\n"));
- printf (_(" -pedantic-errors Like -pedantic except that errors are produced\n"));
- printf (_(" -w Suppress warnings\n"));
-
- for (i = ARRAY_SIZE (W_options); i--;)
- {
- const char *description = W_options[i].description;
-
- if (description != NULL && *description != 0)
- printf (" -W%-21s %s\n",
- W_options[i].string, _(description));
- }
-
- printf (_(" -Wextra Print extra (possibly unwanted) warnings\n"));
- printf (_(" -Wunused Enable unused warnings\n"));
- printf (_(" -Wlarger-than-<number> Warn if an object is larger than <number> bytes\n"));
- printf (_(" -p Enable function profiling\n"));
- printf (_(" -o <file> Place output into <file> \n"));
- printf (_("\
- -G <number> Put global and static data smaller than <number>\n\
- bytes into a special section (on some targets)\n"));
-
- for (i = ARRAY_SIZE (debug_args); i--;)
- {
- if (debug_args[i].description != NULL)
- printf (" -g%-21s %s\n",
- debug_args[i].arg, _(debug_args[i].description));
- }
-
- printf (_(" -aux-info <file> Emit declaration info into <file>\n"));
- printf (_(" -quiet Do not display functions compiled or elapsed time\n"));
- printf (_(" -version Display the compiler's version\n"));
- printf (_(" -d[letters] Enable dumps from specific passes of the compiler\n"));
- printf (_(" -dumpbase <file> Base name to be used for dumps from specific passes\n"));
-#if defined INSN_SCHEDULING
- printf (_(" -fsched-verbose=<number> Set the verbosity level of the scheduler\n"));
-#endif
- printf (_(" --help Display this information\n"));
-
- undoc = 0;
- lang = "language";
-
- /* Display descriptions of language specific options.
- If there is no description, note that there is an undocumented option.
- If the description is empty, do not display anything. (This allows
- options to be deliberately undocumented, for whatever reason).
- If the option string is missing, then this is a marker, indicating
- that the description string is in fact the name of a language, whose
- language specific options are to follow. */
-
- if (ARRAY_SIZE (documented_lang_options) > 1)
- {
- printf (_("\nLanguage specific options:\n"));
-
- for (i = 0; i < ARRAY_SIZE (documented_lang_options); i++)
- {
- const char *description = documented_lang_options[i].description;
- const char *option = documented_lang_options[i].option;
-
- if (description == NULL)
- {
- undoc = 1;
-
- if (extra_warnings)
- printf (_(" %-23.23s [undocumented]\n"), option);
- }
- else if (*description == 0)
- continue;
- else if (option == NULL)
- {
- if (undoc)
- printf
- (_("\nThere are undocumented %s specific options as well.\n"),
- lang);
- undoc = 0;
-
- printf (_("\n Options for %s:\n"), description);
-
- lang = description;
- }
- else
- printf (" %-23.23s %s\n", option, _(description));
- }
- }
-
- if (undoc)
- printf (_("\nThere are undocumented %s specific options as well.\n"),
- lang);
-
- display_target_options ();
-}
-
/* Display help for target options. */
-void
+void
display_target_options (void)
{
int undoc, i;
undoc = 1;
if (extra_warnings)
- printf (_(" -m%-23.23s [undocumented]\n"), option);
+ printf (_(" -m%-23s [undocumented]\n"), option);
}
else if (*description != 0)
- doc += printf (" -m%-23.23s %s\n", option, _(description));
+ doc += printf (" -m%-23s %s\n", option, _(description));
}
#ifdef TARGET_OPTIONS
undoc = 1;
if (extra_warnings)
- printf (_(" -m%-23.23s [undocumented]\n"), option);
+ printf (_(" -m%-23s [undocumented]\n"), option);
}
else if (*description != 0)
- doc += printf (" -m%-23.23s %s\n", option, _(description));
+ doc += printf (" -m%-23s %s\n", option, _(description));
}
#endif
if (undoc)
}
}
-/* Parse a -f... command line switch. ARG is the value after the -f.
- It is safe to access 'ARG - 2' to generate the full switch name.
- Return the number of strings consumed. */
-
-static int
-decode_f_option (const char *arg)
-{
- int j;
- const char *option_value = NULL;
-
- /* Search for the option in the table of binary f options. */
- for (j = ARRAY_SIZE (f_options); j--;)
- {
- if (!strcmp (arg, f_options[j].string))
- {
- *f_options[j].variable = f_options[j].on_value;
- return 1;
- }
-
- if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
- && ! strcmp (arg + 3, f_options[j].string))
- {
- *f_options[j].variable = ! f_options[j].on_value;
- return 1;
- }
- }
-
- if (!strcmp (arg, "fast-math"))
- set_fast_math_flags (1);
- else if (!strcmp (arg, "no-fast-math"))
- set_fast_math_flags (0);
- else if ((option_value = skip_leading_substring (arg, "inline-limit-"))
- || (option_value = skip_leading_substring (arg, "inline-limit=")))
- {
- int val =
- read_integral_parameter (option_value, arg - 2,
- MAX_INLINE_INSNS);
- set_param_value ("max-inline-insns", val);
- set_param_value ("max-inline-insns-single", val/2);
- set_param_value ("max-inline-insns-auto", val/2);
- set_param_value ("max-inline-insns-rtl", val);
- if (val/4 < MIN_INLINE_INSNS)
- {
- if (val/4 > 10)
- set_param_value ("min-inline-insns", val/4);
- else
- set_param_value ("min-inline-insns", 10);
- }
- }
- else if ((option_value = skip_leading_substring (arg, "tls-model=")))
- {
- if (strcmp (option_value, "global-dynamic") == 0)
- flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
- else if (strcmp (option_value, "local-dynamic") == 0)
- flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
- else if (strcmp (option_value, "initial-exec") == 0)
- flag_tls_default = TLS_MODEL_INITIAL_EXEC;
- else if (strcmp (option_value, "local-exec") == 0)
- flag_tls_default = TLS_MODEL_LOCAL_EXEC;
- else
- warning ("`%s': unknown tls-model option", arg - 2);
- }
-#ifdef INSN_SCHEDULING
- else if ((option_value = skip_leading_substring (arg, "sched-verbose=")))
- fix_sched_param ("verbose", option_value);
-#endif
- else if ((option_value = skip_leading_substring (arg, "fixed-")))
- fix_register (option_value, 1, 1);
- else if ((option_value = skip_leading_substring (arg, "call-used-")))
- fix_register (option_value, 0, 1);
- else if ((option_value = skip_leading_substring (arg, "call-saved-")))
- fix_register (option_value, 0, 0);
- else if ((option_value = skip_leading_substring (arg, "align-loops=")))
- align_loops = read_integral_parameter (option_value, arg - 2, align_loops);
- else if ((option_value = skip_leading_substring (arg, "align-functions=")))
- align_functions
- = read_integral_parameter (option_value, arg - 2, align_functions);
- else if ((option_value = skip_leading_substring (arg, "align-jumps=")))
- align_jumps = read_integral_parameter (option_value, arg - 2, align_jumps);
- else if ((option_value = skip_leading_substring (arg, "align-labels=")))
- align_labels
- = read_integral_parameter (option_value, arg - 2, align_labels);
- else if ((option_value
- = skip_leading_substring (arg, "stack-limit-register=")))
- {
- int reg = decode_reg_name (option_value);
- if (reg < 0)
- error ("unrecognized register name `%s'", option_value);
- else
- stack_limit_rtx = gen_rtx_REG (Pmode, reg);
- }
- else if ((option_value
- = skip_leading_substring (arg, "stack-limit-symbol=")))
- {
- const char *nm;
- nm = ggc_strdup (option_value);
- stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, nm);
- }
- else if ((option_value
- = skip_leading_substring (arg, "message-length=")))
- output_set_maximum_length
- (&global_dc->buffer, read_integral_parameter
- (option_value, arg - 2, diagnostic_line_cutoff (global_dc)));
- else if ((option_value
- = skip_leading_substring (arg, "diagnostics-show-location=")))
- {
- if (!strcmp (option_value, "once"))
- diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
- else if (!strcmp (option_value, "every-line"))
- diagnostic_prefixing_rule (global_dc)
- = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
- else
- error ("unrecognized option `%s'", arg - 2);
- }
- else if (!strcmp (arg, "no-stack-limit"))
- stack_limit_rtx = NULL_RTX;
- else if ((option_value = skip_leading_substring (arg, "random-seed=")))
- flag_random_seed = option_value;
- else if (!strcmp (arg, "no-random-seed"))
- flag_random_seed = NULL;
- else if (!strcmp (arg, "preprocessed"))
- /* Recognize this switch but do nothing. This prevents warnings
- about an unrecognized switch if cpplib has not been linked in. */
- ;
- else
- return 0;
-
- return 1;
-}
-
-/* Parse a -W... command line switch. ARG is the value after the -W.
- It is safe to access 'ARG - 2' to generate the full switch name.
- Return the number of strings consumed. */
-
-static int
-decode_W_option (const char *arg)
-{
- const char *option_value = NULL;
- int j;
-
- /* Search for the option in the table of binary W options. */
-
- for (j = ARRAY_SIZE (W_options); j--;)
- {
- if (!strcmp (arg, W_options[j].string))
- {
- *W_options[j].variable = W_options[j].on_value;
- return 1;
- }
-
- if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
- && ! strcmp (arg + 3, W_options[j].string))
- {
- *W_options[j].variable = ! W_options[j].on_value;
- return 1;
- }
- }
-
- if ((option_value = skip_leading_substring (arg, "id-clash-")))
- warning ("-Wid-clash-LEN is no longer supported");
- else if ((option_value = skip_leading_substring (arg, "larger-than-")))
- {
- larger_than_size = read_integral_parameter (option_value, arg - 2, -1);
-
- warn_larger_than = larger_than_size != -1;
- }
- else if (!strcmp (arg, "unused"))
- {
- set_Wunused (1);
- }
- else if (!strcmp (arg, "no-unused"))
- {
- set_Wunused (0);
- }
- else if (!strcmp (arg, "extra"))
- {
- set_Wextra (1);
- }
- else if (!strcmp (arg, "no-extra"))
- {
- set_Wextra (0);
- }
- else
- return 0;
-
- return 1;
-}
-
/* Indexed by enum debug_info_type. */
const char *const debug_type_names[] =
{
"none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff", "vms"
};
-/* Parse a -g... command line switch. ARG is the value after the -g.
- It is safe to access 'ARG - 2' to generate the full switch name.
- Return the number of strings consumed. */
-
-static int
-decode_g_option (const char *arg)
-{
- static unsigned level = 0;
- /* A lot of code assumes write_symbols == NO_DEBUG if the
- debugging level is 0 (thus -gstabs1 -gstabs0 would lose track
- of what debugging type has been selected). This records the
- selected type. It is an error to specify more than one
- debugging type. */
- static enum debug_info_type selected_debug_type = NO_DEBUG;
- /* Nonzero if debugging format has been explicitly set.
- -g and -ggdb don't explicitly set the debugging format so
- -gdwarf -g3 is equivalent to -gdwarf3. */
- static int type_explicitly_set_p = 0;
-
- /* The maximum admissible debug level value. */
- static const unsigned max_debug_level = 3;
-
- /* Look up ARG in the table. */
- for (da = debug_args; da->arg; da++)
- {
- const int da_len = strlen (da->arg);
-
- if (da_len == 0 || ! strncmp (arg, da->arg, da_len))
- {
- enum debug_info_type type = da->debug_type;
- const char *p = arg + da_len;
-
- if (*p && ! ISDIGIT (*p))
- continue;
-
- /* A debug flag without a level defaults to level 2.
- Note we do not want to call read_integral_parameter
- for that case since it will call atoi which
- will return zero.
-
- ??? We may want to generalize the interface to
- read_integral_parameter to better handle this case
- if this case shows up often. */
- if (*p)
- level = read_integral_parameter (p, 0, max_debug_level + 1);
- else
- level = (level == 0) ? 2 : level;
-
- if (da_len > 1 && *p && !strncmp (arg, "dwarf", da_len))
- {
- error ("use -gdwarf -g%d for DWARF v1, level %d",
- level, level);
- if (level == 2)
- error ("use -gdwarf-2 for DWARF v2");
- }
-
- if (level > max_debug_level)
- {
- warning ("\
-ignoring option `%s' due to invalid debug level specification",
- arg - 2);
- level = debug_info_level;
- }
-
- if (type == NO_DEBUG)
- {
- type = PREFERRED_DEBUGGING_TYPE;
-
- if (da_len > 1 && strncmp (arg, "gdb", da_len) == 0)
- {
-#ifdef DWARF2_DEBUGGING_INFO
- type = DWARF2_DEBUG;
-#else
-#ifdef DBX_DEBUGGING_INFO
- type = DBX_DEBUG;
-#endif
-#endif
- }
- }
-
- if (type == NO_DEBUG)
- warning ("`%s': unknown or unsupported -g option", arg - 2);
-
- /* Does it conflict with an already selected type? */
- if (type_explicitly_set_p
- /* -g/-ggdb don't conflict with anything. */
- && da->debug_type != NO_DEBUG
- && type != selected_debug_type)
- warning ("`%s' ignored, conflicts with `-g%s'",
- arg - 2, debug_type_names[(int) selected_debug_type]);
- else
- {
- /* If the format has already been set, -g/-ggdb
- only change the debug level. */
- if (type_explicitly_set_p && da->debug_type == NO_DEBUG)
- /* Don't change debugging type. */
- ;
- else
- {
- selected_debug_type = type;
- type_explicitly_set_p = da->debug_type != NO_DEBUG;
- }
-
- write_symbols = (level == 0
- ? NO_DEBUG
- : selected_debug_type);
- use_gnu_debug_info_extensions = da->use_extensions_p;
- debug_info_level = (enum debug_info_level) level;
- }
-
- break;
- }
- }
-
- if (! da->arg)
- return 0;
-
- return 1;
-}
-
-/* Decode the first argument in the argv as a language-independent option.
- Return the number of strings consumed. */
-
-static unsigned int
-independent_decode_option (int argc, char **argv)
-{
- char *arg = argv[0];
-
- if (arg[0] != '-' || arg[1] == 0)
- return 1;
-
- arg++;
-
- /* Handle '--param <name>=<value>'. */
- if (strcmp (arg, "-param") == 0)
- {
- char *equal;
-
- if (argc == 1)
- {
- error ("-param option missing argument");
- return 1;
- }
-
- /* Get the '<name>=<value>' parameter. */
- arg = argv[1];
- /* Look for the `='. */
- equal = strchr (arg, '=');
- if (!equal)
- error ("invalid --param option: %s", arg);
- else
- {
- int val;
-
- /* Zero out the `=' sign so that we get two separate strings. */
- *equal = '\0';
- /* Figure out what value is specified. */
- val = read_integral_parameter (equal + 1, NULL, INVALID_PARAM_VAL);
- if (val != INVALID_PARAM_VAL)
- set_param_value (arg, val);
- else
- error ("invalid parameter value `%s'", equal + 1);
- }
-
- return 2;
- }
-
- switch (*arg)
- {
- default:
- return 0;
-
- case 'O':
- /* Already been treated in main (). Do nothing. */
- break;
-
- case 'm':
- set_target_switch (arg + 1);
- break;
-
- case 'f':
- return decode_f_option (arg + 1);
-
- case 'g':
- return decode_g_option (arg + 1);
-
- case 'W':
- /* For backward compatibility, -W is the same as -Wextra. */
- if (arg[1] == 0)
- set_Wextra (1);
- else
- return decode_W_option (arg + 1);
- break;
- }
-
- return 1;
-}
-
/* Decode -m switches. */
/* Decode the switch -mNAME. */
-static void
+void
set_target_switch (const char *name)
{
size_t j;
const char *indent, const char *sep, const char *term)
{
size_t j;
- char **p;
+ const char **p;
/* Fill in the -frandom-seed option, if the user didn't pass it, so
- that it can be printed below. This helps reproducibility. Of
- course, the string may never be used, but we can't tell that at
- this point in the compile. */
- default_flag_random_seed ();
+ that it can be printed below. This helps reproducibility. */
+ randomize ();
/* Print the options as passed. */
-
pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
_("options passed: "), "");
if (asm_file_name == 0)
{
int len = strlen (dump_base_name);
- char *dumpname = (char *) xmalloc (len + 6);
+ char *dumpname = xmalloc (len + 6);
memcpy (dumpname, dump_base_name, len + 1);
strip_off_ending (dumpname, len);
strcat (dumpname, ".s");
}
#ifdef IO_BUFFER_SIZE
- setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
+ setvbuf (asm_out_file, xmalloc (IO_BUFFER_SIZE),
_IOFBF, IO_BUFFER_SIZE);
#endif
if (!flag_syntax_only)
{
-#ifdef ASM_FILE_START
- ASM_FILE_START (asm_out_file);
-#endif
+ targetm.asm_out.file_start ();
#ifdef ASM_COMMENT_START
if (flag_verbose_asm)
}
}
+/* Default version of get_pch_validity.
+ By default, every flag difference is fatal; that will be mostly right for
+ most targets, but completely right for very few. */
+
+void *
+default_get_pch_validity (size_t *len)
+{
+#ifdef TARGET_OPTIONS
+ size_t i;
+#endif
+ char *result, *r;
+
+ *len = sizeof (target_flags) + 2;
+#ifdef TARGET_OPTIONS
+ for (i = 0; i < ARRAY_SIZE (target_options); i++)
+ {
+ *len += 1;
+ if (*target_options[i].variable)
+ *len += strlen (*target_options[i].variable);
+ }
+#endif
+
+ result = r = xmalloc (*len);
+ r[0] = flag_pic;
+ r[1] = flag_pie;
+ r += 2;
+ memcpy (r, &target_flags, sizeof (target_flags));
+ r += sizeof (target_flags);
+
+#ifdef TARGET_OPTIONS
+ for (i = 0; i < ARRAY_SIZE (target_options); i++)
+ {
+ const char *str = *target_options[i].variable;
+ size_t l;
+ if (! str)
+ str = "";
+ l = strlen (str) + 1;
+ memcpy (r, str, l);
+ r += l;
+ }
+#endif
+
+ return result;
+}
+
+/* Default version of pch_valid_p. */
+
+const char *
+default_pch_valid_p (const void *data_p, size_t len)
+{
+ const char *data = (const char *)data_p;
+ const char *flag_that_differs = NULL;
+ size_t i;
+
+ /* -fpic and -fpie also usually make a PCH invalid. */
+ if (data[0] != flag_pic)
+ return _("created and used with different settings of -fpic");
+ if (data[1] != flag_pie)
+ return _("created and used with different settings of -fpie");
+ data += 2;
+
+ /* Check target_flags. */
+ if (memcmp (data, &target_flags, sizeof (target_flags)) != 0)
+ {
+ for (i = 0; i < ARRAY_SIZE (target_switches); i++)
+ {
+ int bits;
+ int tf;
+
+ memcpy (&tf, data, sizeof (target_flags));
+
+ bits = target_switches[i].value;
+ if (bits < 0)
+ bits = -bits;
+ if ((target_flags & bits) != (tf & bits))
+ {
+ flag_that_differs = target_switches[i].name;
+ goto make_message;
+ }
+ }
+ abort ();
+ }
+ data += sizeof (target_flags);
+ len -= sizeof (target_flags);
+
+ /* Check string options. */
+#ifdef TARGET_OPTIONS
+ for (i = 0; i < ARRAY_SIZE (target_options); i++)
+ {
+ const char *str = *target_options[i].variable;
+ size_t l;
+ if (! str)
+ str = "";
+ l = strlen (str) + 1;
+ if (len < l || memcmp (data, str, l) != 0)
+ {
+ flag_that_differs = target_options[i].prefix;
+ goto make_message;
+ }
+ data += l;
+ len -= l;
+ }
+#endif
+
+ return NULL;
+
+ make_message:
+ {
+ char *r;
+ asprintf (&r, _("created and used with differing settings of `-m%s'"),
+ flag_that_differs);
+ if (r == NULL)
+ return _("out of memory");
+ return r;
+ }
+}
+
+/* Default tree printer. Handles declarations only. */
+static bool
+default_tree_printer (pretty_printer * pp, text_info *text)
+{
+ switch (*text->format_spec)
+ {
+ case 'D':
+ case 'F':
+ case 'T':
+ {
+ tree t = va_arg (*text->args_ptr, tree);
+ const char *n = DECL_NAME (t)
+ ? (*lang_hooks.decl_printable_name) (t, 2)
+ : "<anonymous>";
+ pp_string (pp, n);
+ }
+ return true;
+
+ default:
+ return false;
+ }
+}
+
/* Initialization of the front end environment, before command line
options are parsed. Signal handlers, internationalization etc.
ARGV0 is main's argv[0]. */
static void
-general_init (char *argv0)
+general_init (const char *argv0)
{
- char *p;
+ const char *p;
p = argv0 + strlen (argv0);
while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
gcc_init_libintl ();
+ /* Initialize the diagnostics reporting machinery, so option parsing
+ can give warnings and errors. */
+ diagnostic_initialize (global_dc);
+ /* Set a default printer. Language specific initializations will
+ override it later. */
+ pp_format_decoder (global_dc->printer) = &default_tree_printer;
+
/* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
#ifdef SIGSEGV
signal (SIGSEGV, crash_signal);
/* Other host-specific signal setup. */
(*host_hooks.extra_signals)();
- /* Initialize the diagnostics reporting machinery, so option parsing
- can give warnings and errors. */
- diagnostic_initialize (global_dc);
-
/* Initialize the garbage-collector, string pools and tree type hash
table. */
init_ggc ();
init_stringpool ();
+ linemap_init (&line_table);
init_ttree ();
-}
-
-/* Parse command line options and set default flag values, called
- after language-independent option-independent initialization. Do
- minimal options processing. Outputting diagnostics is OK, but GC
- and identifier hashtables etc. are not initialized yet.
-
- Return nonzero to suppress compiler back end initialization. */
-static void
-parse_options_and_default_flags (int argc, char **argv)
-{
- int i, lang_mask;
-
- /* Save in case md file wants to emit args as a comment. */
- save_argc = argc;
- save_argv = argv;
/* Initialize register usage now so switches may override. */
init_reg_sets ();
/* This must be done after add_params but before argument processing. */
init_ggc_heuristics();
-
- /* Perform language-specific options initialization. */
- lang_mask = (*lang_hooks.init_options) ();
-
- /* Scan to see what optimization level has been specified. That will
- determine the default value of many flags. */
- for (i = 1; i < argc; i++)
- {
- if (!strcmp (argv[i], "-O"))
- {
- optimize = 1;
- optimize_size = 0;
- }
- else if (argv[i][0] == '-' && argv[i][1] == 'O')
- {
- /* Handle -Os, -O2, -O3, -O69, ... */
- char *p = &argv[i][2];
-
- if ((p[0] == 's') && (p[1] == 0))
- {
- optimize_size = 1;
-
- /* Optimizing for size forces optimize to be 2. */
- optimize = 2;
- }
- else
- {
- const int optimize_val = read_integral_parameter (p, p - 2, -1);
- if (optimize_val != -1)
- {
- optimize = optimize_val;
- optimize_size = 0;
- }
- }
- }
- }
-
- if (!optimize)
- {
- flag_merge_constants = 0;
- }
-
- if (optimize >= 1)
- {
- flag_defer_pop = 1;
- flag_thread_jumps = 1;
-#ifdef DELAY_SLOTS
- flag_delayed_branch = 1;
-#endif
-#ifdef CAN_DEBUG_WITHOUT_FP
- flag_omit_frame_pointer = 1;
-#endif
- flag_guess_branch_prob = 1;
- flag_cprop_registers = 1;
- flag_loop_optimize = 1;
- flag_crossjumping = 1;
- flag_if_conversion = 1;
- flag_if_conversion2 = 1;
- }
-
- if (optimize >= 2)
- {
- flag_optimize_sibling_calls = 1;
- flag_cse_follow_jumps = 1;
- flag_cse_skip_blocks = 1;
- flag_gcse = 1;
- flag_expensive_optimizations = 1;
- flag_strength_reduce = 1;
- flag_rerun_cse_after_loop = 1;
- flag_rerun_loop_opt = 1;
- flag_caller_saves = 1;
- flag_force_mem = 1;
- flag_peephole2 = 1;
-#ifdef INSN_SCHEDULING
- flag_schedule_insns = 1;
- flag_schedule_insns_after_reload = 1;
-#endif
- flag_regmove = 1;
- flag_strict_aliasing = 1;
- flag_delete_null_pointer_checks = 1;
- flag_reorder_blocks = 1;
- flag_reorder_functions = 1;
- }
-
- if (optimize >= 3)
- {
- flag_inline_functions = 1;
- flag_rename_registers = 1;
- flag_unswitch_loops = 1;
- flag_unit_at_a_time = 1;
- }
-
- if (optimize < 2 || optimize_size)
- {
- align_loops = 1;
- align_jumps = 1;
- align_labels = 1;
- align_functions = 1;
-
- /* Don't reorder blocks when optimizing for size because extra
- jump insns may be created; also barrier may create extra padding.
-
- More correctly we should have a block reordering mode that tried
- to minimize the combined size of all the jumps. This would more
- or less automatically remove extra jumps, but would also try to
- use more short jumps instead of long jumps. */
- flag_reorder_blocks = 0;
- }
-
- /* Initialize whether `char' is signed. */
- flag_signed_char = DEFAULT_SIGNED_CHAR;
-#ifdef DEFAULT_SHORT_ENUMS
- /* Initialize how much space enums occupy, by default. */
- flag_short_enums = DEFAULT_SHORT_ENUMS;
-#endif
-
- /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
- modify it. */
- target_flags = 0;
- set_target_switch ("");
-
- /* Unwind tables are always present in an ABI-conformant IA-64
- object file, so the default should be ON. */
-#ifdef IA64_UNWIND_INFO
- flag_unwind_tables = IA64_UNWIND_INFO;
-#endif
-
-#ifdef OPTIMIZATION_OPTIONS
- /* Allow default optimizations to be specified on a per-machine basis. */
- OPTIMIZATION_OPTIONS (optimize, optimize_size);
-#endif
-
- /* Perform normal command line switch decoding. */
- for (i = 1; i < argc;)
- {
- int lang_processed;
- int indep_processed;
-
- /* Give the language a chance to decode the option for itself. */
- lang_processed = handle_option (argc - i, argv + i, lang_mask);
-
- if (lang_processed >= 0)
- /* Now see if the option also has a language independent meaning.
- Some options are both language specific and language independent,
- eg --help. */
- indep_processed = independent_decode_option (argc - i, argv + i);
- else
- {
- lang_processed = -lang_processed;
- indep_processed = 0;
- }
-
- if (lang_processed || indep_processed)
- i += MAX (lang_processed, indep_processed);
- else
- {
- const char *option = NULL;
- const char *lang = NULL;
- unsigned int j;
-
- /* It is possible that the command line switch is not valid for the
- current language, but it is valid for another language. In order
- to be compatible with previous versions of the compiler (which
- did not issue an error message in this case) we check for this
- possibility here. If we do find a match, then if extra_warnings
- is set we generate a warning message, otherwise we will just
- ignore the option. */
- for (j = 0; j < ARRAY_SIZE (documented_lang_options); j++)
- {
- option = documented_lang_options[j].option;
-
- if (option == NULL)
- lang = documented_lang_options[j].description;
- else if (! strncmp (argv[i], option, strlen (option)))
- break;
- }
-
- if (j != ARRAY_SIZE (documented_lang_options))
- {
- if (extra_warnings)
- {
- warning ("ignoring command line option '%s'", argv[i]);
- if (lang)
- warning
- ("(it is valid for %s but not the selected language)",
- lang);
- }
- }
- else if (argv[i][0] == '-' && argv[i][1] == 'g')
- warning ("`%s': unknown or unsupported -g option", &argv[i][2]);
- else
- error ("unrecognized option `%s'", argv[i]);
-
- i++;
- }
- }
-
- if (flag_pie)
- flag_pic = flag_pie;
- if (flag_pic && !flag_pie)
- flag_shlib = 1;
-
- if (flag_no_inline == 2)
- flag_no_inline = 0;
- else
- flag_really_no_inline = flag_no_inline;
-
- /* Set flag_no_inline before the post_options () hook. The C front
- ends use it to determine tree inlining defaults. FIXME: such
- code should be lang-independent when all front ends use tree
- inlining, in which case it, and this condition, should be moved
- to the top of process_options() instead. */
- if (optimize == 0)
- {
- /* Inlining does not work if not optimizing,
- so force it not to be done. */
- flag_no_inline = 1;
- warn_inline = 0;
-
- /* The c_decode_option function and decode_option hook set
- this to `2' if -Wall is used, so we can avoid giving out
- lots of errors for people who don't realize what -Wall does. */
- if (warn_uninitialized == 1)
- warning ("-Wuninitialized is not supported without -O");
- }
-
- if (flag_really_no_inline == 2)
- flag_really_no_inline = flag_no_inline;
}
/* Process the options that have been parsed. */
if (flag_unit_at_a_time && ! lang_hooks.callgraph.expand_function)
flag_unit_at_a_time = 0;
+ if (flag_value_profile_transformations)
+ flag_profile_values = 1;
+
/* Warn about options that are not supported on this machine. */
#ifndef INSN_SCHEDULING
if (flag_schedule_insns || flag_schedule_insns_after_reload)
profile_flag = 0;
}
+ /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
+ level is 0. */
+ if (debug_info_level == DINFO_LEVEL_NONE)
+ write_symbols = NO_DEBUG;
+
/* Now we know write_symbols, set up the debug hooks based on it.
By default we do nothing for debug output. */
+ if (write_symbols == NO_DEBUG)
+ debug_hooks = &do_nothing_debug_hooks;
#if defined(DBX_DEBUGGING_INFO)
- if (write_symbols == DBX_DEBUG)
+ else if (write_symbols == DBX_DEBUG)
debug_hooks = &dbx_debug_hooks;
#endif
#if defined(XCOFF_DEBUGGING_INFO)
- if (write_symbols == XCOFF_DEBUG)
+ else if (write_symbols == XCOFF_DEBUG)
debug_hooks = &xcoff_debug_hooks;
#endif
#ifdef SDB_DEBUGGING_INFO
- if (write_symbols == SDB_DEBUG)
+ else if (write_symbols == SDB_DEBUG)
debug_hooks = &sdb_debug_hooks;
#endif
-#ifdef DWARF_DEBUGGING_INFO
- if (write_symbols == DWARF_DEBUG)
- debug_hooks = &dwarf_debug_hooks;
-#endif
#ifdef DWARF2_DEBUGGING_INFO
- if (write_symbols == DWARF2_DEBUG)
+ else if (write_symbols == DWARF2_DEBUG)
debug_hooks = &dwarf2_debug_hooks;
#endif
#ifdef VMS_DEBUGGING_INFO
- if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
+ else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
debug_hooks = &vmsdbg_debug_hooks;
#endif
+ else
+ error ("target system does not support the \"%s\" debug format",
+ debug_type_names[write_symbols]);
/* If auxiliary info generation is desired, open the output file.
This goes in the same directory as the source file--unlike
static void
backend_init (void)
{
- /* init_emit_once uses reg_raw_mode and therefore must be called
- after init_regs which initialized reg_raw_mode. */
- init_regs ();
+ init_adjust_machine_modes ();
+
init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
|| debug_info_level == DINFO_LEVEL_VERBOSE
#ifdef VMS_DEBUGGING_INFO
- /* Enable line number info for traceback */
+ /* Enable line number info for traceback. */
|| debug_info_level > DINFO_LEVEL_NONE
#endif
|| flag_test_coverage
|| warn_notreached);
+
+ init_regs ();
init_fake_stack_mems ();
init_alias_once ();
init_loop ();
ggc_print_statistics ();
stringpool_statistics ();
dump_tree_statistics ();
+ dump_rtx_statistics ();
+ dump_varray_statistics ();
}
/* Free up memory for the benefit of leak detectors. */
/* Language-dependent initialization. Returns true on success. */
if (lang_dependent_init (main_input_filename))
- compile_file ();
+ {
+ if (flag_unit_at_a_time)
+ {
+ open_dump_file (DFI_cgraph, NULL);
+ cgraph_dump_file = rtl_dump_file;
+ rtl_dump_file = NULL;
+ }
+
+ compile_file ();
+
+ if (flag_unit_at_a_time)
+ {
+ rtl_dump_file = cgraph_dump_file;
+ cgraph_dump_file = NULL;
+ close_dump_file (DFI_cgraph, NULL, NULL_RTX);
+ }
+ }
finalize ();
}
}
/* Entry point of cc1, cc1plus, jc1, f771, etc.
- Decode command args, then call compile_file.
Exit code is FATAL_EXIT_CODE if can't open files or if there were
any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
It is not safe to call this function more than once. */
int
-toplev_main (int argc, char **argv)
+toplev_main (unsigned int argc, const char **argv)
{
+ save_argv = argv;
+
/* Initialization of GCC's environment, and diagnostics. */
general_init (argv[0]);
/* Parse the options and do minimal processing; basically just
enough to default flags appropriately. */
- parse_options_and_default_flags (argc, argv);
+ decode_options (argc, argv);
+
+ randomize ();
/* Exit early if we can (e.g. -help). */
if (!exit_after_options)
OSDN Git Service
