-/* 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.
#include "cfgloop.h"
#include "hosthooks.h"
#include "cgraph.h"
+#include "opts.h"
+#include "coverage.h"
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
#include "dwarf2out.h"
#include "xcoffout.h" /* Needed for external data
declarations for e.g. AIX 4.x. */
#endif
-\f
+
/* Carry information from ASM_DECLARE_OBJECT_NAME
to ASM_FINISH_DECLARE_OBJECT. */
extern int size_directive_output;
extern tree last_assemble_variable_decl;
-extern void reg_alloc PARAMS ((void));
-
-static void general_init PARAMS ((char *));
-static void parse_options_and_default_flags PARAMS ((int, char **));
-static void do_compile PARAMS ((int));
-static void process_options PARAMS ((void));
-static void backend_init PARAMS ((void));
-static int lang_dependent_init PARAMS ((const char *));
-static void init_asm_output PARAMS ((const char *));
-static void finalize PARAMS ((void));
-
-static void set_target_switch PARAMS ((const char *));
-
-static void crash_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
-static void setup_core_dumping PARAMS ((void));
-static void compile_file PARAMS ((void));
-static void display_help PARAMS ((void));
-static void display_target_options PARAMS ((void));
-
-static void decode_d_option PARAMS ((const char *));
-static int decode_f_option PARAMS ((const char *));
-static int decode_W_option PARAMS ((const char *));
-static int decode_g_option PARAMS ((const char *));
-static unsigned int independent_decode_option PARAMS ((int, char **));
-
-static void print_version PARAMS ((FILE *, const char *));
-static int print_single_switch PARAMS ((FILE *, int, int, const char *,
- const char *, const char *,
- const char *, const char *));
-static void print_switch_values PARAMS ((FILE *, int, int, const char *,
- const char *, const char *));
+extern void reg_alloc (void);
+
+static void general_init (const char *);
+static void do_compile (void);
+static void process_options (void);
+static void backend_init (void);
+static int lang_dependent_init (const char *);
+static void init_asm_output (const char *);
+static void finalize (void);
+
+static void crash_signal (int) ATTRIBUTE_NORETURN;
+static void setup_core_dumping (void);
+static void compile_file (void);
+
+static int print_single_switch (FILE *, int, int, const char *,
+ const char *, const char *,
+ const char *, const char *);
+static void print_switch_values (FILE *, int, int, 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_life (tree, rtx);
+static void rest_of_handle_loop_optimize (tree, rtx);
+static void rest_of_handle_loop2 (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_cfg (tree, rtx);
+static void rest_of_handle_branch_prob (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);
+#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 void rest_of_handle_regrename (tree, rtx);
+static void rest_of_handle_reorder_blocks (tree, rtx);
+#ifdef STACK_REGS
+static void rest_of_handle_stack_regs (tree, rtx);
+#endif
+static void rest_of_handle_machine_reorg (tree, rtx);
+#ifdef DELAY_SLOTS
+static void rest_of_handle_delay_slots (tree, rtx);
+#endif
+static void rest_of_handle_final (tree, rtx);
/* Nonzero to dump debug info whilst parsing (-dy option). */
static int set_yydebug;
+/* True if we don't need a backend (e.g. preprocessing only). */
+static bool no_backend;
+
/* Length of line when printing switch values. */
#define MAX_LINE 75
const char *progname;
-/* Copy of arguments to toplev_main. */
-int save_argc;
-char **save_argv;
-\f
-/* Name of current original source file (what was input to cpp).
- This comes from each #-command in the actual input. */
-
-const char *input_filename;
+/* 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.
const char *main_input_filename;
-/* Current line number in real source file. */
+/* Current position in real source file. */
-int lineno;
+location_t input_location;
/* Nonzero if it is unsafe to create any new pseudo registers. */
int no_new_pseudos;
/* Name to use as a base for auxiliary output files. */
-static const char *aux_base_name;
+const char *aux_base_name;
/* Format to use to print dumpfile index value */
#ifndef DUMPFILE_FORMAT
DFI_flow2,
DFI_peephole2,
DFI_rnreg,
- DFI_ce3,
DFI_bbro,
+ DFI_ce3,
+ DFI_branch_target_load,
DFI_sched2,
DFI_stack,
DFI_mach,
Remaining -d letters:
- " o q "
- " H JK OPQ TUV YZ"
+ " m q "
+ " JK O Q UV YZ"
*/
static struct dump_file_info dump_file[DFI_MAX] =
{ "flow2", 'w', 1, 0, 0 },
{ "peephole2", 'z', 1, 0, 0 },
{ "rnreg", 'n', 1, 0, 0 },
- { "ce3", 'E', 1, 0, 0 },
{ "bbro", 'B', 1, 0, 0 },
+ { "ce3", 'E', 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 },
{ "dbr", 'd', 0, 0, 0 },
};
-static int open_dump_file PARAMS ((enum dump_file_index, tree));
-static void close_dump_file PARAMS ((enum dump_file_index,
- void (*) (FILE *, rtx), rtx));
+static int open_dump_file (enum dump_file_index, tree);
+static void close_dump_file (enum dump_file_index,
+ void (*) (FILE *, rtx), rtx);
/* Other flags saying which kinds of debugging dump have been requested. */
int rtl_dump_and_exit;
int flag_print_asm_name;
-static int version_flag;
-static const char *filename;
enum graph_dump_types graph_dump_format;
/* Name for output file of assembly code, specified with -o. */
-char *asm_file_name;
-
-/* Value of the -G xx switch, and whether it was passed or not. */
-int g_switch_value;
-int g_switch_set;
+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
int optimize_size = 0;
-/* Nonzero if we should exit after parsing options. */
-static int exit_after_options = 0;
-
/* The FUNCTION_DECL for the function currently being compiled,
or 0 if between functions. */
tree current_function_decl;
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 generating info for gcov to calculate line test coverage. */
int flag_test_coverage = 0;
and to print them when we are done. */
int flag_detailed_statistics = 0;
-\f
/* -f flags. */
/* Nonzero means `char' should be signed. */
int flag_trapping_math = 1;
/* 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;
/* 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;
+/* 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;
+
/* 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. */
/* Specified name of aux-info file. */
-static char *aux_info_file_name;
+const char *aux_info_file_name;
/* Nonzero means make the text shared if supported. */
int flag_pic;
+/* Nonzero if we are compiling position independent code for executable.
+ The value is 1 if we are doing "small" pic; value is 2 if we're doing
+ "large" pic. */
+
+int flag_pie;
+
+/* Nonzero if we are compiling code for a shared library, zero for
+ executable. */
+
+int flag_shlib;
+
/* Set to the default thread-local storage (tls) model to use. */
enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
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;
}
lang_independent_options;
+/* Nonzero if signed arithmetic overflow should trap. */
int flag_trapv = 0;
+/* Nonzero if signed arithmetic overflow should wrap around. */
+int flag_wrapv = 0;
+
/* Add or remove a leading underscore from user symbols. */
int flag_leading_underscore = -1;
{
{"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
N_("Perform DWARF2 duplicate elimination") },
+ {"eliminate-unused-debug-symbols", &flag_debug_only_used_symbols, 1,
+ N_("Perform unused type elimination in debug info") },
{"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_("Perform enhanced load motion during global subexpression elimination") },
{"gcse-sm", &flag_gcse_sm, 1,
N_("Perform store motion after global subexpression elimination") },
+ {"branch-target-load-optimize", &flag_branch_target_load_optimize, 1,
+ N_("Perform branch target load optimization before prologue / epilogue threading") },
+ {"branch-target-load-optimize2", &flag_branch_target_load_optimize2, 1,
+ N_("Perform branch target load optimization after prologue / epilogue threading") },
{"loop-optimize", &flag_loop_optimize, 1,
N_("Perform the loop optimizations") },
{"crossjumping", &flag_crossjumping, 1,
{"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 sheduling") },
+ N_("If scheduling post reload, do superblock scheduling") },
{"sched2-use-traces", &flag_sched2_use_traces, 1,
- N_("If scheduling post reload, do trace sheduling") },
+ 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,
{"data-sections", &flag_data_sections, 1,
N_("place data items into their own section") },
{"verbose-asm", &flag_verbose_asm, 1,
- N_("Add extra commentry to assembler output") },
+ N_("Add extra commentary to assembler output") },
{"gnu-linker", &flag_gnu_linker, 1,
N_("Output GNU ld formatted global initializers") },
{"regmove", &flag_regmove, 1,
{"align-functions", &align_functions, 0,
N_("Align the start of functions") },
{"merge-constants", &flag_merge_constants, 1,
- N_("Attempt to merge identical constants accross compilation units") },
+ 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_("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.") },
};
#define DEFINE_LANG_NAME(NAME) { NULL, NAME },
-#include "options.h"
+#include "options_.h"
};
const char *const prefix;
const char **const variable;
const char *const description;
+ const char *const value;
}
target_options[] = TARGET_OPTIONS;
#endif
-\f
-/* 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;
-
-/* 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;
+/* Options controlling warnings. */
/* 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;
-
-/* Warn about functions which might be candidates for attribute noreturn. */
-
-int warn_missing_noreturn;
-
-/* Nonzero means warn about uses of __attribute__((deprecated))
- declarations. */
-
-int warn_deprecated_decl = 1;
-
-/* Nonzero means warn about constructs which might not be
- strict-aliasing safe. */
-
-int warn_strict_aliasing;
+/* Used for the -W options array temporarily. */
+static int warn_dummy;
/* Like f_options, but for -W. */
static const lang_independent_options W_options[] =
{
- {"unused-function", &warn_unused_function, 1,
+ {"unused-function", &warn_dummy, 1,
N_("Warn when a function is unused") },
- {"unused-label", &warn_unused_label, 1,
+ {"unused-label", &warn_dummy, 1,
N_("Warn when a label is unused") },
- {"unused-parameter", &warn_unused_parameter, 1,
+ {"unused-parameter", &warn_dummy, 1,
N_("Warn when a function parameter is unused") },
- {"unused-variable", &warn_unused_variable, 1,
+ {"unused-variable", &warn_dummy, 1,
N_("Warn when a variable is unused") },
- {"unused-value", &warn_unused_value, 1,
+ {"unused-value", &warn_dummy, 1,
N_("Warn when an expression value is unused") },
- {"system-headers", &warn_system_headers, 1,
+ {"system-headers", &warn_dummy, 1,
N_("Do not suppress warnings from system headers") },
- {"error", &warnings_are_errors, 1,
+ {"error", &warn_dummy, 1,
N_("Treat all warnings as errors") },
- {"shadow", &warn_shadow, 1,
+ {"shadow", &warn_dummy, 1,
N_("Warn when one local variable shadows another") },
- {"switch", &warn_switch, 1,
+ {"switch", &warn_dummy, 1,
N_("Warn about enumerated switches, with no default, missing a case") },
- {"switch-default", &warn_switch_default, 1,
+ {"switch-default", &warn_dummy, 1,
N_("Warn about enumerated switches missing a default case") },
- {"switch-enum", &warn_switch_enum, 1,
+ {"switch-enum", &warn_dummy, 1,
N_("Warn about all enumerated switches missing a specific case") },
- {"aggregate-return", &warn_aggregate_return, 1,
+ {"aggregate-return", &warn_dummy, 1,
N_("Warn about returning structures, unions or arrays") },
- {"cast-align", &warn_cast_align, 1,
+ {"cast-align", &warn_dummy, 1,
N_("Warn about pointer casts which increase alignment") },
- {"unreachable-code", &warn_notreached, 1,
+ {"unreachable-code", &warn_dummy, 1,
N_("Warn about code that will never be executed") },
- {"uninitialized", &warn_uninitialized, 1,
+ {"uninitialized", &warn_dummy, 1,
N_("Warn about uninitialized automatic variables") },
- {"inline", &warn_inline, 1,
+ {"inline", &warn_dummy, 1,
N_("Warn when an inlined function cannot be inlined") },
- {"packed", &warn_packed, 1,
+ {"packed", &warn_dummy, 1,
N_("Warn when the packed attribute has no effect on struct layout") },
- {"padded", &warn_padded, 1,
+ {"padded", &warn_dummy, 1,
N_("Warn when padding is required to align struct members") },
- {"disabled-optimization", &warn_disabled_optimization, 1,
+ {"disabled-optimization", &warn_dummy, 1,
N_("Warn when an optimization pass is disabled") },
- {"deprecated-declarations", &warn_deprecated_decl, 1,
+ {"deprecated-declarations", &warn_dummy, 1,
N_("Warn about uses of __attribute__((deprecated)) declarations") },
- {"extra", &extra_warnings, 1,
- N_("Print extra (possibly unwanted) warnings") },
- {"missing-noreturn", &warn_missing_noreturn, 1,
+ {"missing-noreturn", &warn_dummy, 1,
N_("Warn about functions which might be candidates for attribute noreturn") },
- {"strict-aliasing", &warn_strict_aliasing, 1,
+ {"strict-aliasing", &warn_dummy, 1,
N_ ("Warn about code which might break the strict aliasing rules") }
};
-void
-set_Wunused (setting)
- int setting;
-{
- warn_unused_function = setting;
- warn_unused_label = setting;
- /* Unused function parameter warnings are reported when either ``-W
- -Wunused'' or ``-Wunused-parameter'' is specified. Differentiate
- -Wunused by setting WARN_UNUSED_PARAMETER to -1. */
- if (!setting)
- warn_unused_parameter = 0;
- else if (!warn_unused_parameter)
- warn_unused_parameter = -1;
- warn_unused_variable = setting;
- warn_unused_value = setting;
-}
-
-/* The following routines are useful in setting all the flags that
- -ffast-math and -fno-fast-math imply. */
-
-void
-set_fast_math_flags (set)
- 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;
-}
-
-/* Return true iff flags are set as if -ffast-math. */
-bool
-fast_math_flags_set_p ()
-{
- return (!flag_trapping_math
- && flag_unsafe_math_optimizations
- && flag_finite_math_only
- && !flag_errno_math);
-}
-
-\f
/* Output files for assembler code (real compiler output)
and debugging dumps. */
If PNAME is zero just return DEFVAL, do not call error. */
int
-read_integral_parameter (p, pname, defval)
- const char *p;
- const char *pname;
- const int defval;
+read_integral_parameter (const char *p, const char *pname, const int defval)
{
const char *endp = p;
if (*endp != 0)
{
if (pname != 0)
- error ("invalid option `%s'", pname);
+ error ("invalid option argument `%s'", pname);
return defval;
}
return atoi (p);
}
-\f
-/* This calls abort and is used to avoid problems when abort is a macro.
- It is used when we need to pass the address of abort. */
-
-void
-do_abort ()
-{
- abort ();
-}
-
-/* When `malloc.c' is compiled with `rcheck' defined,
- it calls this function to report clobberage. */
-void
-botch (s)
- const char *s ATTRIBUTE_UNUSED;
-{
- abort ();
-}
-\f
/* Return the logarithm of X, base 2, considering X unsigned,
if X is a power of 2. Otherwise, returns -1.
This should be used via the `exact_log2' macro. */
int
-exact_log2_wide (x)
- unsigned HOST_WIDE_INT x;
+exact_log2_wide (unsigned HOST_WIDE_INT x)
{
int log = 0;
/* Test for 0 or a power of 2. */
This should be used via the floor_log2 macro. */
int
-floor_log2_wide (x)
- unsigned HOST_WIDE_INT x;
+floor_log2_wide (unsigned HOST_WIDE_INT x)
{
int log = -1;
while (x != 0)
}
/* Handler for fatal signals, such as SIGSEGV. These are transformed
- into ICE messages, which is much more user friendly. */
+ into ICE messages, which is much more user friendly. In case the
+ error printer crashes, reset the signal to prevent infinite recursion. */
static void
-crash_signal (signo)
- int signo;
+crash_signal (int signo)
{
+ signal (signo, SIG_DFL);
internal_error ("%s", strsignal (signo));
}
printed first, except in the case of abort().) */
static void
-setup_core_dumping ()
+setup_core_dumping (void)
{
#ifdef SIGABRT
signal (SIGABRT, SIG_DFL);
{
struct rlimit rlim;
if (getrlimit (RLIMIT_CORE, &rlim) != 0)
- fatal_io_error ("getting core file size maximum limit");
+ fatal_error ("getting core file size maximum limit: %m");
rlim.rlim_cur = rlim.rlim_max;
if (setrlimit (RLIMIT_CORE, &rlim) != 0)
- fatal_io_error ("setting core file size limit to maximum");
+ fatal_error ("setting core file size limit to maximum: %m");
}
#endif
diagnostic_abort_on_error (global_dc);
up to five characters. (Java uses ".class".) */
void
-strip_off_ending (name, len)
- char *name;
- int len;
+strip_off_ending (char *name, int len)
{
int i;
for (i = 2; i < 6 && len > i; i++)
/* Output a quoted string. */
void
-output_quoted_string (asm_file, string)
- FILE *asm_file;
- const char *string;
+output_quoted_string (FILE *asm_file, const char *string)
{
#ifdef OUTPUT_QUOTED_STRING
OUTPUT_QUOTED_STRING (asm_file, string);
#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, 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 (asm_file, input_name)
- FILE *asm_file;
- const char *input_name;
+output_file_directive (FILE *asm_file, const char *input_name)
{
int len = strlen (input_name);
const char *na = input_name + len;
#endif
#endif
}
-\f
+
/* Routine to open a dump file. Return true if the dump file is enabled. */
static int
-open_dump_file (index, decl)
- enum dump_file_index index;
- tree decl;
+open_dump_file (enum dump_file_index index, tree decl)
{
char *dump_name;
const char *open_arg;
rtl_dump_file = fopen (dump_name, open_arg);
if (rtl_dump_file == NULL)
- fatal_io_error ("can't open %s", dump_name);
+ fatal_error ("can't open %s: %m", dump_name);
free (dump_name);
/* Routine to close a dump file. */
static void
-close_dump_file (index, func, insns)
- enum dump_file_index index;
- void (*func) PARAMS ((FILE *, rtx));
- rtx insns;
+close_dump_file (enum dump_file_index index,
+ void (*func) (FILE *, rtx),
+ rtx insns)
{
if (! rtl_dump_file)
return;
Returns nonzero if anything was put out. */
int
-wrapup_global_declarations (vec, len)
- tree *vec;
- int len;
+wrapup_global_declarations (tree *vec, int len)
{
tree decl;
int i;
decl = vec[i];
/* We're not deferring this any longer. Assignment is
- conditional to avoid needlessly dirtying PCH pages. */
+ conditional to avoid needlessly dirtying PCH pages. */
if (DECL_DEFER_OUTPUT (decl) != 0)
DECL_DEFER_OUTPUT (decl) = 0;
{
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
+ && (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;
which there are LEN). Output debugging information for them. */
void
-check_global_declarations (vec, len)
- tree *vec;
- int len;
+check_global_declarations (tree *vec, int len)
{
tree decl;
int i;
&& ! TREE_USED (DECL_NAME (decl))
&& ! DECL_EXTERNAL (decl)
&& ! TREE_PUBLIC (decl)
+ /* A volatile variable might be used in some non-obvious way. */
+ && ! TREE_THIS_VOLATILE (decl)
/* Global register variables must be declared to reserve them. */
&& ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
/* Otherwise, ask the language. */
}
}
-/* Save the current INPUT_FILENAME and LINENO on the top entry in the
+/* 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_FILENAME and LINENO accordingly. */
+ INPUT_LOCATION accordingly. */
void
-push_srcloc (file, line)
- const char *file;
- int line;
+push_srcloc (const char *file, int line)
{
struct file_stack *fs;
- if (input_file_stack)
- {
- input_file_stack->name = input_filename;
- input_file_stack->line = lineno;
- }
-
fs = (struct file_stack *) xmalloc (sizeof (struct file_stack));
- fs->name = input_filename = file;
- fs->line = lineno = line;
+ fs->location = input_location;
fs->next = input_file_stack;
+ input_filename = file;
+ input_line = line;
input_file_stack = fs;
input_file_stack_tick++;
}
/* Pop the top entry off the stack of presently open source files.
- Restore the INPUT_FILENAME and LINENO from the new topmost entry on
- the stack. */
+ Restore the INPUT_LOCATION from the new topmost entry on the
+ stack. */
void
-pop_srcloc ()
+pop_srcloc (void)
{
struct file_stack *fs;
fs = input_file_stack;
+ input_location = fs->location;
input_file_stack = fs->next;
free (fs);
input_file_stack_tick++;
- /* The initial source file is never popped. */
- if (!input_file_stack)
- abort ();
- input_filename = input_file_stack->name;
- lineno = input_file_stack->line;
}
/* Compile an entire translation unit. Write a file of assembly
output and various debugging dumps. */
static void
-compile_file ()
+compile_file (void)
{
/* Initialize yet another pass. */
init_final (main_input_filename);
- init_branch_prob (aux_base_name);
+ coverage_init (aux_base_name);
timevar_push (TV_PARSE);
(*lang_hooks.decls.final_write_globals)();
- if (profile_arc_flag)
- /* This must occur after the loop to output deferred functions.
- Else the profiler initializer would not be emitted if all the
- functions in this compilation unit were deferred. */
- create_profiler ();
+ 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. */
+ coverage_finish ();
/* Write out any pending weak symbol declarations. */
timevar_pop (TV_DUMP);
}
-#ifdef ASM_FILE_END
- ASM_FILE_END (asm_out_file);
-#endif
+ targetm.asm_out.file_end ();
/* Attach a special .ident directive to the end of the file to identify
the version of GCC which compiled this code. The format of the .ident
timevar_pop (TV_DUMP);
}
}
-\f
+
/* This is called from various places for FUNCTION_DECL, VAR_DECL,
and TYPE_DECL nodes.
if this declaration is not within a function. */
void
-rest_of_decl_compilation (decl, asmspec, top_level, at_end)
- tree decl;
- const char *asmspec;
- int top_level;
- int at_end;
+rest_of_decl_compilation (tree decl,
+ const char *asmspec,
+ int top_level,
+ int at_end)
{
/* We deferred calling assemble_alias so that we could collect
other attributes such as visibility. Emit the alias now. */
/* 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);
+ {
+ 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)
/* Called after finishing a record, union or enumeral type. */
void
-rest_of_type_compilation (type, toplev)
+rest_of_type_compilation (
#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) \
|| defined (SDB_DEBUGGING_INFO) || defined (DWARF2_DEBUGGING_INFO)
- tree type;
- int toplev;
+ tree type,
+ int toplev
#else
- tree type ATTRIBUTE_UNUSED;
- int toplev ATTRIBUTE_UNUSED;
+ tree type ATTRIBUTE_UNUSED,
+ int toplev ATTRIBUTE_UNUSED
#endif
+ )
{
/* Avoid confusing the debug information machinery when there are
errors. */
timevar_pop (TV_SYMOUT);
}
-/* This is called from finish_function (within langhooks.parse_file)
- after each top-level definition is parsed.
- It is supposed to compile that function or variable
- and output the assembler code for it.
- After we return, the tree storage is freed. */
-
-void
-rest_of_compilation (decl)
- tree decl;
+/* Turn the RTL into assembly. */
+static void
+rest_of_handle_final (tree decl, rtx insns)
{
- rtx insns;
- int tem;
- int failure = 0;
- int rebuild_label_notes_after_reload;
+ timevar_push (TV_FINAL);
+ {
+ rtx x;
+ const char *fnname;
- timevar_push (TV_REST_OF_COMPILATION);
+ /* Get the function's name, as described by its RTL. This may be
+ different from the DECL_NAME name used in the source file. */
- /* Now that we're out of the frontend, we shouldn't have any more
- CONCATs anywhere. */
- generating_concat_p = 0;
+ x = DECL_RTL (decl);
+ if (GET_CODE (x) != MEM)
+ abort ();
+ x = XEXP (x, 0);
+ if (GET_CODE (x) != SYMBOL_REF)
+ abort ();
+ fnname = XSTR (x, 0);
- /* When processing delayed functions, prepare_function_start() won't
- have been run to re-initialize it. */
- cse_not_expected = ! optimize;
+ assemble_start_function (decl, fnname);
+ final_start_function (insns, asm_out_file, optimize);
+ final (insns, asm_out_file, optimize, 0);
+ final_end_function ();
- /* First, make sure that NOTE_BLOCK is set correctly for each
- NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */
- if (!cfun->x_whole_function_mode_p)
- identify_blocks ();
+#ifdef IA64_UNWIND_INFO
+ /* ??? The IA-64 ".handlerdata" directive must be issued before
+ the ".endp" directive that closes the procedure descriptor. */
+ output_function_exception_table ();
+#endif
- /* In function-at-a-time mode, we do not attempt to keep the BLOCK
- tree in sensible shape. So, we just recalculate it here. */
- if (cfun->x_whole_function_mode_p)
- reorder_blocks ();
+ assemble_end_function (decl, fnname);
- init_flow ();
+#ifndef IA64_UNWIND_INFO
+ /* Otherwise, it feels unclean to switch sections in the middle. */
+ output_function_exception_table ();
+#endif
- /* If we are reconsidering an inline function
- at the end of compilation, skip the stuff for making it inline. */
+ if (! quiet_flag)
+ fflush (asm_out_file);
- if (DECL_SAVED_INSNS (decl) == 0)
- {
- int inlinable = 0;
- tree parent;
- const char *lose;
-
- /* If this is nested inside an inlined external function, pretend
- it was only declared. Since we cannot inline such functions,
- generating code for this one is not only not necessary but will
- confuse some debugging output writers. */
- for (parent = DECL_CONTEXT (current_function_decl);
- parent != NULL_TREE;
- parent = get_containing_scope (parent))
- if (TREE_CODE (parent) == FUNCTION_DECL
- && DECL_INLINE (parent) && DECL_EXTERNAL (parent))
- {
- DECL_INITIAL (decl) = 0;
- goto exit_rest_of_compilation;
- }
- else if (TYPE_P (parent))
- /* A function in a local class should be treated normally. */
- break;
+ /* Release all memory allocated by flow. */
+ free_basic_block_vars (0);
- /* If requested, consider whether to make this function inline. */
- if ((DECL_INLINE (decl) && !flag_no_inline)
- || flag_inline_functions)
- {
- timevar_push (TV_INTEGRATION);
- lose = function_cannot_inline_p (decl);
- timevar_pop (TV_INTEGRATION);
- if (lose || ! optimize)
- {
- if (warn_inline && DECL_INLINE (decl))
- warning_with_decl (decl, lose);
- DECL_ABSTRACT_ORIGIN (decl) = 0;
- /* Don't really compile an extern inline function.
- If we can't make it inline, pretend
- it was only declared. */
- if (DECL_EXTERNAL (decl))
- {
- DECL_INITIAL (decl) = 0;
- goto exit_rest_of_compilation;
- }
- }
- 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;
- inlinable = DECL_INLINE (decl) = 1;
- }
- }
+ /* Release all memory held by regsets now. */
+ regset_release_memory ();
+ }
+ timevar_pop (TV_FINAL);
- insns = get_insns ();
+ ggc_collect ();
+}
- /* Dump the rtl code if we are dumping rtl. */
+#ifdef DELAY_SLOTS
+/* Run delay slot optimization. */
+static void
+rest_of_handle_delay_slots (tree decl, rtx insns)
+{
+ timevar_push (TV_DBR_SCHED);
+ open_dump_file (DFI_dbr, decl);
- if (open_dump_file (DFI_rtl, decl))
- {
- if (DECL_SAVED_INSNS (decl))
- fprintf (rtl_dump_file, ";; (integrable)\n\n");
- close_dump_file (DFI_rtl, print_rtl, insns);
- }
+ dbr_schedule (insns, rtl_dump_file);
- /* Convert from NOTE_INSN_EH_REGION style notes, and do other
- sorts of eh initialization. Delay this until after the
- initial rtl dump so that we can see the original nesting. */
- convert_from_eh_region_ranges ();
-
- /* If function is inline, and we don't yet know whether to
- compile it by itself, defer decision till end of compilation.
- wrapup_global_declarations will (indirectly) call
- rest_of_compilation again for those functions that need to
- be output. Also defer those functions that we are supposed
- to defer. */
-
- if (inlinable
- || (DECL_INLINE (decl)
- && flag_inline_functions
- && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
- && ! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
- && ! flag_keep_inline_functions)
- || DECL_EXTERNAL (decl))))
- DECL_DEFER_OUTPUT (decl) = 1;
-
- if (DECL_INLINE (decl))
- /* DWARF wants separate debugging info for abstract and
- concrete instances of all inline functions, including those
- declared inline but not inlined, and those inlined even
- though they weren't declared inline. Conveniently, that's
- what DECL_INLINE means at this point. */
- (*debug_hooks->deferred_inline_function) (decl);
-
- if (DECL_DEFER_OUTPUT (decl))
- {
- /* If -Wreturn-type, we have to do a bit of compilation. We just
- want to call cleanup the cfg to figure out whether or not we can
- fall off the end of the function; we do the minimum amount of
- work necessary to make that safe. */
- if (warn_return_type)
- {
- int saved_optimize = optimize;
+ close_dump_file (DFI_dbr, print_rtl, insns);
+ timevar_pop (TV_DBR_SCHED);
- optimize = 0;
- rebuild_jump_labels (insns);
- find_exception_handler_labels ();
- find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
- cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
- optimize = saved_optimize;
+ ggc_collect ();
+}
+#endif
- /* CFG is no longer maintained up-to-date. */
- free_bb_for_insn ();
- }
+#ifdef STACK_REGS
+/* Convert register usage from flat register file usage to a stack
+ register file. */
+static void
+rest_of_handle_stack_regs (tree decl, rtx insns)
+{
+ timevar_push (TV_REG_STACK);
+ open_dump_file (DFI_stack, decl);
- set_nothrow_function_flags ();
- if (current_function_nothrow)
- /* Now we know that this can't throw; set the flag for the benefit
- of other functions later in this translation unit. */
- TREE_NOTHROW (current_function_decl) = 1;
-
- timevar_push (TV_INTEGRATION);
- save_for_inline (decl);
- timevar_pop (TV_INTEGRATION);
- DECL_SAVED_INSNS (decl)->inlinable = inlinable;
- goto exit_rest_of_compilation;
+ if (reg_to_stack (insns, rtl_dump_file) && optimize)
+ {
+ if (cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
+ | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0))
+ && flag_reorder_blocks)
+ {
+ reorder_basic_blocks ();
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
}
-
- /* If specified extern inline but we aren't inlining it, we are
- done. This goes for anything that gets here with DECL_EXTERNAL
- set, not just things with DECL_INLINE. */
- if (DECL_EXTERNAL (decl))
- goto exit_rest_of_compilation;
}
- /* If we're emitting a nested function, make sure its parent gets
- emitted as well. Doing otherwise confuses debug info. */
- {
- tree parent;
- for (parent = DECL_CONTEXT (current_function_decl);
- parent != NULL_TREE;
- parent = get_containing_scope (parent))
- if (TREE_CODE (parent) == FUNCTION_DECL)
- TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
- }
+ close_dump_file (DFI_stack, print_rtl_with_bb, insns);
+ timevar_pop (TV_REG_STACK);
- /* 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))
- (*debug_hooks->outlining_inline_function) (decl);
+ ggc_collect ();
+}
+#endif
- /* Remove any notes we don't need. That will make iterating
- over the instruction sequence faster, and allow the garbage
- collector to reclaim the memory used by the notes. */
- remove_unnecessary_notes ();
- reorder_blocks ();
+
+/* Machine independent reorg pass. */
+static void
+rest_of_handle_machine_reorg (tree decl, rtx insns)
+{
+ timevar_push (TV_MACH_DEP);
+ open_dump_file (DFI_mach, decl);
+
+ (*targetm.machine_dependent_reorg) ();
+
+ close_dump_file (DFI_mach, print_rtl, insns);
+ timevar_pop (TV_MACH_DEP);
ggc_collect ();
+}
- /* Initialize some variables used by the optimizers. */
- init_function_for_compilation ();
- if (! DECL_DEFER_OUTPUT (decl))
- TREE_ASM_WRITTEN (decl) = 1;
+/* 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)
+{
+ int failure;
- /* Now that integrate will no longer see our rtl, we need not
- distinguish between the return value of this function and the
- return value of called functions. Also, we can remove all SETs
- of subregs of hard registers; they are only here because of
- integrate. Also, we can now initialize pseudos intended to
- carry magic hard reg data throughout the function. */
- rtx_equal_function_value_matters = 0;
- purge_hard_subreg_sets (get_insns ());
-
- /* Early return if there were errors. We can run afoul of our
- consistency checks, and there's not really much point in fixing them.
- Don't return yet if -Wreturn-type; we need to do cleanup_cfg. */
- if (((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
- || errorcount || sorrycount)
- goto exit_rest_of_compilation;
-
- timevar_push (TV_JUMP);
- open_dump_file (DFI_sibling, decl);
- insns = get_insns ();
- rebuild_jump_labels (insns);
- find_exception_handler_labels ();
- find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
-
- delete_unreachable_blocks ();
+ delete_trivially_dead_insns (insns, max_reg_num ());
+ reg_alloc ();
- /* Turn NOTE_INSN_PREDICTIONs into branch predictions. */
- if (flag_guess_branch_prob)
+ timevar_pop (TV_LOCAL_ALLOC);
+ if (dump_file[DFI_lreg].enabled)
{
- timevar_push (TV_BRANCH_PROB);
- note_prediction_to_br_prob ();
- timevar_pop (TV_BRANCH_PROB);
- }
+ timevar_push (TV_DUMP);
- /* We may have potential sibling or tail recursion sites. Select one
- (of possibly multiple) methods of performing the call. */
- if (flag_optimize_sibling_calls)
- {
- rtx insn;
- optimize_sibling_and_tail_recursive_calls ();
+ close_dump_file (DFI_lreg, NULL, NULL);
+ timevar_pop (TV_DUMP);
+ }
- /* Recompute the CFG as sibling optimization clobbers it randomly. */
- free_bb_for_insn ();
- find_exception_handler_labels ();
- rebuild_jump_labels (insns);
- find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
+ /* XXX clean up the whole mess to bring live info in shape again. */
+ timevar_push (TV_GLOBAL_ALLOC);
+ open_dump_file (DFI_greg, decl);
- /* There is pass ordering problem - we must lower NOTE_INSN_PREDICTION
- notes before simplifying cfg and we must do lowering after sibcall
- that unhides parts of RTL chain and cleans up the CFG.
+ build_insn_chain (insns);
+ failure = reload (insns, 0);
- Until sibcall is replaced by tree-level optimizer, lets just
- sweep away the NOTE_INSN_PREDICTION notes that leaked out. */
- for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (GET_CODE (insn) == NOTE
- && NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION)
- delete_insn (insn);
- }
- close_dump_file (DFI_sibling, print_rtl, get_insns ());
- timevar_pop (TV_JUMP);
+ timevar_pop (TV_GLOBAL_ALLOC);
- scope_to_insns_initialize ();
- /* Complete generation of exception handling code. */
- if (doing_eh (0))
+ if (dump_file[DFI_greg].enabled)
{
- timevar_push (TV_JUMP);
- open_dump_file (DFI_eh, decl);
+ timevar_push (TV_DUMP);
- finish_eh_generation ();
+ dump_global_regs (rtl_dump_file);
- close_dump_file (DFI_eh, print_rtl, get_insns ());
- timevar_pop (TV_JUMP);
+ close_dump_file (DFI_greg, print_rtl_with_bb, insns);
+ timevar_pop (TV_DUMP);
}
- /* Delay emitting hard_reg_initial_value sets until after EH landing pad
- generation, which might create new sets. */
- emit_initial_value_sets ();
-
-#ifdef FINALIZE_PIC
- /* If we are doing position-independent code generation, now
- is the time to output special prologues and epilogues.
- We do not want to do this earlier, because it just clutters
- up inline functions with meaningless insns. */
- if (flag_pic)
- FINALIZE_PIC;
-#endif
+ if (failure)
+ return true;
- insns = get_insns ();
+ reload_completed = 1;
+ *rebuild_notes = 0;
- /* Copy any shared structure that should not be shared. */
- unshare_all_rtl (current_function_decl, insns);
+ return false;
+}
-#ifdef SETJMP_VIA_SAVE_AREA
- /* This must be performed before virtual register instantiation.
- Please be aware the everything in the compiler that can look
- at the RTL up to this point must understand that REG_SAVE_AREA
- is just like a use of the REG contained inside. */
- if (current_function_calls_alloca)
- optimize_save_area_alloca (insns);
-#endif
+/* 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)
+{
+ int failure;
- /* Instantiate all virtual registers. */
- instantiate_virtual_regs (current_function_decl, insns);
+ /* Allocate the reg_renumber array. */
+ allocate_reg_info (max_regno, FALSE, TRUE);
- open_dump_file (DFI_jump, decl);
+ /* And the reg_equiv_memory_loc array. */
+ reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
- /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
- are initialized and to compute whether control can drop off the end
- of the function. */
+ allocate_initial_values (reg_equiv_memory_loc);
- timevar_push (TV_JUMP);
- /* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
- before jump optimization switches branch directions. */
- if (flag_guess_branch_prob)
- expected_value_to_br_prob ();
+ regclass (insns, max_reg_num (), rtl_dump_file);
+ *rebuild_notes = local_alloc ();
- reg_scan (insns, max_reg_num (), 0);
- rebuild_jump_labels (insns);
- find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
- delete_trivially_dead_insns (insns, max_reg_num ());
- if (rtl_dump_file)
- dump_flow_info (rtl_dump_file);
- cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
- | (flag_thread_jumps ? CLEANUP_THREADING : 0));
+ timevar_pop (TV_LOCAL_ALLOC);
- if (optimize)
+ if (dump_file[DFI_lreg].enabled)
{
- free_bb_for_insn ();
- copy_loop_headers (insns);
- find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
+ timevar_push (TV_DUMP);
+
+ dump_flow_info (rtl_dump_file);
+ dump_local_alloc (rtl_dump_file);
+
+ close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
+ timevar_pop (TV_DUMP);
}
- purge_line_number_notes (insns);
- timevar_pop (TV_JUMP);
- close_dump_file (DFI_jump, print_rtl, insns);
+ ggc_collect ();
- /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
- if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
+ timevar_push (TV_GLOBAL_ALLOC);
+ open_dump_file (DFI_greg, decl);
+
+ /* If optimizing, allocate remaining pseudo-regs. Do the reload
+ pass fixing up any insns that are invalid. */
+
+ if (optimize)
+ failure = global_alloc (rtl_dump_file);
+ else
{
- goto exit_rest_of_compilation;
+ build_insn_chain (insns);
+ failure = reload (insns, 0);
}
- /* 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)
+ timevar_pop (TV_GLOBAL_ALLOC);
+
+ if (dump_file[DFI_greg].enabled)
{
- /* Convert to SSA form. */
+ timevar_push (TV_DUMP);
- timevar_push (TV_TO_SSA);
- open_dump_file (DFI_ssa, decl);
+ dump_global_regs (rtl_dump_file);
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
- convert_to_ssa ();
+ close_dump_file (DFI_greg, print_rtl_with_bb, insns);
+ timevar_pop (TV_DUMP);
+ }
- close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
- timevar_pop (TV_TO_SSA);
+ return failure;
+}
- /* Perform sparse conditional constant propagation, if requested. */
- if (flag_ssa_ccp)
- {
- timevar_push (TV_SSA_CCP);
- open_dump_file (DFI_ssa_ccp, decl);
+/* Run the regrename and cprop passes. */
+static void
+rest_of_handle_regrename (tree decl, rtx insns)
+{
+ timevar_push (TV_RENAME_REGISTERS);
+ open_dump_file (DFI_rnreg, decl);
- ssa_const_prop ();
+ if (flag_rename_registers)
+ regrename_optimize ();
+ if (flag_cprop_registers)
+ copyprop_hardreg_forward ();
- close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
- timevar_pop (TV_SSA_CCP);
- }
+ close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
+ timevar_pop (TV_RENAME_REGISTERS);
+}
- /* 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. */
+/* Reorder basic blocks. */
+static void
+rest_of_handle_reorder_blocks (tree decl, rtx insns)
+{
+ timevar_push (TV_REORDER_BLOCKS);
+ 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));
+
+ if (flag_sched2_use_traces && flag_schedule_insns_after_reload)
+ tracer ();
+ if (flag_reorder_blocks)
+ reorder_basic_blocks ();
+ if (flag_reorder_blocks
+ || (flag_sched2_use_traces && flag_schedule_insns_after_reload))
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
+
+ close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
+ timevar_pop (TV_REORDER_BLOCKS);
+}
- /* 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. */
+#ifdef INSN_SCHEDULING
+/* Run instruction scheduler. */
+static void
+rest_of_handle_sched (tree decl, rtx insns)
+{
+ timevar_push (TV_SCHED);
- if (flag_ssa_dce)
- {
- /* Remove dead code. */
+ /* Print function header into sched dump now
+ because doing the sched analysis makes some of the dump. */
+ if (optimize > 0 && flag_schedule_insns)
+ {
+ open_dump_file (DFI_sched, decl);
- timevar_push (TV_SSA_DCE);
- open_dump_file (DFI_ssa_dce, decl);
+ /* Do control and data sched analysis,
+ and write some of the results to dump file. */
- insns = get_insns ();
- ssa_eliminate_dead_code ();
+ schedule_insns (rtl_dump_file);
- close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
- timevar_pop (TV_SSA_DCE);
- }
+ close_dump_file (DFI_sched, print_rtl_with_bb, insns);
+ }
+ timevar_pop (TV_SCHED);
- /* Convert from SSA form. */
+ ggc_collect ();
+}
- timevar_push (TV_FROM_SSA);
- open_dump_file (DFI_ussa, decl);
+/* Run second scheduling pass after reload. */
+static void
+rest_of_handle_sched2 (tree decl, rtx insns)
+{
+ timevar_push (TV_SCHED2);
+ open_dump_file (DFI_sched2, decl);
- convert_from_ssa ();
- /* New registers have been created. Rescan their usage. */
- reg_scan (insns, max_reg_num (), 1);
+ /* Do control and data sched analysis again,
+ and write some more of the results to dump file. */
- close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
- timevar_pop (TV_FROM_SSA);
+ split_all_insns (1);
- ggc_collect ();
+ if (flag_sched2_use_superblocks || flag_sched2_use_traces)
+ {
+ schedule_ebbs (rtl_dump_file);
+ /* No liveness updating code yet, but it should be easy to do.
+ reg-stack recompute the liveness when needed for now. */
+ count_or_remove_death_notes (NULL, 1);
+ cleanup_cfg (CLEANUP_EXPENSIVE);
}
+ else
+ schedule_insns (rtl_dump_file);
- timevar_push (TV_JUMP);
- if (optimize)
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
-
- /* Try to identify useless null pointer tests and delete them. */
- if (flag_delete_null_pointer_checks)
- {
- open_dump_file (DFI_null, decl);
- if (rtl_dump_file)
- dump_flow_info (rtl_dump_file);
+ close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
+ timevar_pop (TV_SCHED2);
- if (delete_null_pointer_checks (insns))
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ ggc_collect ();
+}
+#endif
- close_dump_file (DFI_null, print_rtl_with_bb, insns);
- }
+/* Register allocation pre-pass, to reduce number of moves necessary
+ for two-address machines. */
+static void
+rest_of_handle_regmove (tree decl, rtx insns)
+{
+ timevar_push (TV_REGMOVE);
+ open_dump_file (DFI_regmove, decl);
- /* Jump optimization, and the removal of NULL pointer checks, may
- have reduced the number of instructions substantially. CSE, and
- future passes, allocate arrays whose dimensions involve the
- maximum instruction UID, so if we can reduce the maximum UID
- we'll save big on memory. */
- renumber_insns (rtl_dump_file);
- timevar_pop (TV_JUMP);
+ regmove_optimize (insns, max_reg_num (), rtl_dump_file);
- close_dump_file (DFI_jump, print_rtl_with_bb, insns);
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
+ close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
+ timevar_pop (TV_REGMOVE);
ggc_collect ();
+}
- /* Perform common subexpression elimination.
- Nonzero value from `cse_main' means that jumps were simplified
- and some code may now be unreachable, so do
- jump optimization again. */
+/* Run tracer. */
+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);
+ tracer ();
+ 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 (optimize > 0)
+/* If-conversion and CFG cleanup. */
+static void
+rest_of_handle_if_conversion (tree decl, rtx insns)
+{
+ open_dump_file (DFI_ce1, decl);
+ if (flag_if_conversion)
{
- open_dump_file (DFI_cse, decl);
+ timevar_push (TV_IFCVT);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
- timevar_push (TV_CSE);
+ cleanup_cfg (CLEANUP_EXPENSIVE);
+ reg_scan (insns, max_reg_num (), 0);
+ if_convert (0);
+ timevar_pop (TV_IFCVT);
+ }
+ timevar_push (TV_JUMP);
+ cleanup_cfg (CLEANUP_EXPENSIVE);
+ reg_scan (insns, max_reg_num (), 0);
+ timevar_pop (TV_JUMP);
+ close_dump_file (DFI_ce1, print_rtl_with_bb, get_insns ());
+}
- reg_scan (insns, max_reg_num (), 1);
+/* Rerun if-conversion, as combine may have simplified things enough
+ to now meet sequence length restrictions. */
+static void
+rest_of_handle_if_after_combine (tree decl, rtx insns)
+{
+ timevar_push (TV_IFCVT);
+ open_dump_file (DFI_ce2, decl);
- tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
- if (tem)
- rebuild_jump_labels (insns);
- purge_all_dead_edges (0);
+ no_new_pseudos = 0;
+ if_convert (1);
+ no_new_pseudos = 1;
- delete_trivially_dead_insns (insns, max_reg_num ());
+ close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
+ timevar_pop (TV_IFCVT);
+}
- /* If we are not running more CSE passes, then we are no longer
- expecting CSE to be run. But always rerun it in a cheap mode. */
- cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
+/* Do branch profiling and static profile estimation passes. */
+static void
+rest_of_handle_branch_prob (tree decl, rtx insns)
+{
+ struct loops loops;
- if (tem || optimize > 1)
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
- /* Try to identify useless null pointer tests and delete them. */
- if (flag_delete_null_pointer_checks)
- {
- timevar_push (TV_JUMP);
+ timevar_push (TV_BRANCH_PROB);
+ open_dump_file (DFI_bp, decl);
+ if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
+ branch_prob ();
- if (delete_null_pointer_checks (insns))
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
- timevar_pop (TV_JUMP);
- }
+ /* Discover and record the loop depth at the head of each basic
+ block. The loop infrastructure does the real job for us. */
+ flow_loops_find (&loops, LOOP_TREE);
- /* The second pass of jump optimization is likely to have
- removed a bunch more instructions. */
- renumber_insns (rtl_dump_file);
+ if (rtl_dump_file)
+ flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
- timevar_pop (TV_CSE);
- close_dump_file (DFI_cse, print_rtl_with_bb, insns);
- }
+ /* Estimate using heuristics if no profiling info is available. */
+ if (flag_guess_branch_prob)
+ estimate_probability (&loops);
+
+ flow_loops_free (&loops);
+ close_dump_file (DFI_bp, print_rtl_with_bb, insns);
+ timevar_pop (TV_BRANCH_PROB);
+}
+
+/* Do control and data flow analysis; write some of the results to the
+ dump file. */
+static void
+rest_of_handle_cfg (tree decl, rtx insns)
+{
+ open_dump_file (DFI_cfg, decl);
+ if (rtl_dump_file)
+ dump_flow_info (rtl_dump_file);
+ if (optimize)
+ cleanup_cfg (CLEANUP_EXPENSIVE
+ | (flag_thread_jumps ? CLEANUP_THREADING : 0));
+
+ /* It may make more sense to mark constant functions after dead code is
+ eliminated by life_analysis, but we need to do it early, as -fprofile-arcs
+ may insert code making function non-constant, but we still must consider
+ it as constant, otherwise -fbranch-probabilities will not read data back.
+
+ life_analysis rarely eliminates modification of external memory.
+ */
+ if (optimize)
+ 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)
+{
open_dump_file (DFI_addressof, decl);
purge_addressof (insns);
reg_scan (insns, max_reg_num (), 1);
close_dump_file (DFI_addressof, print_rtl, insns);
+}
- ggc_collect ();
+/* We may have potential sibling or tail recursion sites. Select one
+ (of possibly multiple) methods of performing the call. */
+static void
+rest_of_handle_sibling_calls (rtx insns)
+{
+ rtx insn;
+ optimize_sibling_and_tail_recursive_calls ();
- /* Perform global cse. */
+ /* Recompute the CFG as sibling optimization clobbers it randomly. */
+ free_bb_for_insn ();
+ find_exception_handler_labels ();
+ rebuild_jump_labels (insns);
+ find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
- if (optimize > 0 && flag_gcse)
- {
- int save_csb, save_cfj;
- int tem2 = 0;
+ /* There is pass ordering problem - we must lower NOTE_INSN_PREDICTION
+ notes before simplifying cfg and we must do lowering after sibcall
+ that unhides parts of RTL chain and cleans up the CFG.
- timevar_push (TV_GCSE);
- open_dump_file (DFI_gcse, decl);
+ Until sibcall is replaced by tree-level optimizer, lets just
+ sweep away the NOTE_INSN_PREDICTION notes that leaked out. */
+ for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+ if (GET_CODE (insn) == NOTE
+ && NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION)
+ delete_insn (insn);
- tem = gcse_main (insns, rtl_dump_file);
- rebuild_jump_labels (insns);
- delete_trivially_dead_insns (insns, max_reg_num ());
+ close_dump_file (DFI_sibling, print_rtl, get_insns ());
+}
- save_csb = flag_cse_skip_blocks;
- save_cfj = flag_cse_follow_jumps;
- flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
+/* Perform jump bypassing and control flow optimizations. */
+static void
+rest_of_handle_jump_bypass (tree decl, rtx insns)
+{
+ timevar_push (TV_BYPASS);
+ open_dump_file (DFI_bypass, decl);
- /* If -fexpensive-optimizations, re-run CSE to clean up things done
- by gcse. */
- if (flag_expensive_optimizations)
- {
- timevar_push (TV_CSE);
- reg_scan (insns, max_reg_num (), 1);
- tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
- purge_all_dead_edges (0);
- delete_trivially_dead_insns (insns, max_reg_num ());
- timevar_pop (TV_CSE);
- cse_not_expected = !flag_rerun_cse_after_loop;
- }
+ cleanup_cfg (CLEANUP_EXPENSIVE);
- /* If gcse or cse altered any jumps, rerun jump optimizations to clean
- things up. Then possibly re-run CSE again. */
- while (tem || tem2)
- {
- tem = tem2 = 0;
- timevar_push (TV_JUMP);
- rebuild_jump_labels (insns);
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
- timevar_pop (TV_JUMP);
+ if (bypass_jumps (rtl_dump_file))
+ {
+ rebuild_jump_labels (insns);
+ cleanup_cfg (CLEANUP_EXPENSIVE);
+ delete_trivially_dead_insns (insns, max_reg_num ());
+ }
- if (flag_expensive_optimizations)
- {
- timevar_push (TV_CSE);
- reg_scan (insns, max_reg_num (), 1);
- tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
- purge_all_dead_edges (0);
- delete_trivially_dead_insns (insns, max_reg_num ());
- timevar_pop (TV_CSE);
- }
- }
+ close_dump_file (DFI_bypass, print_rtl_with_bb, insns);
+ timevar_pop (TV_BYPASS);
- close_dump_file (DFI_gcse, print_rtl_with_bb, insns);
- timevar_pop (TV_GCSE);
+ ggc_collect ();
- ggc_collect ();
- flag_cse_skip_blocks = save_csb;
- flag_cse_follow_jumps = save_cfj;
#ifdef ENABLE_CHECKING
- verify_flow_info ();
+ verify_flow_info ();
#endif
+}
+
+/* Handle inlining of functions in rest_of_compilation. Return TRUE
+ if we must exit rest_of_compilation upon return. */
+static bool
+rest_of_handle_inlining (tree decl)
+{
+ rtx insns;
+ int inlinable = 0;
+ tree parent;
+ const char *lose;
+
+ /* 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)
+ return 0;
+
+ /* If this is nested inside an inlined external function, pretend
+ it was only declared. Since we cannot inline such functions,
+ generating code for this one is not only not necessary but will
+ confuse some debugging output writers. */
+ for (parent = DECL_CONTEXT (current_function_decl);
+ parent != NULL_TREE;
+ parent = get_containing_scope (parent))
+ if (TREE_CODE (parent) == FUNCTION_DECL
+ && DECL_INLINE (parent) && DECL_EXTERNAL (parent))
+ {
+ DECL_INITIAL (decl) = 0;
+ return true;
+ }
+ else if (TYPE_P (parent))
+ /* A function in a local class should be treated normally. */
+ break;
+
+ /* If requested, consider whether to make this function inline. */
+ if ((DECL_INLINE (decl) && !flag_no_inline)
+ || flag_inline_functions)
+ {
+ timevar_push (TV_INTEGRATION);
+ lose = function_cannot_inline_p (decl);
+ timevar_pop (TV_INTEGRATION);
+ if (lose || ! optimize)
+ {
+ if (warn_inline && DECL_INLINE (decl))
+ warning_with_decl (decl, lose);
+ DECL_ABSTRACT_ORIGIN (decl) = 0;
+ /* Don't really compile an extern inline function.
+ If we can't make it inline, pretend
+ it was only declared. */
+ if (DECL_EXTERNAL (decl))
+ {
+ DECL_INITIAL (decl) = 0;
+ 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;
+ inlinable = DECL_INLINE (decl) = 1;
+ }
}
- /* Instantiate any remaining CONSTANT_P_RTX nodes. */
- if (optimize > 0 && flag_gcse && current_function_calls_constant_p)
- purge_builtin_constant_p ();
+ insns = get_insns ();
- /* Move constant computations out of loops. */
+ /* Dump the rtl code if we are dumping rtl. */
- if (optimize > 0 && flag_loop_optimize)
+ if (open_dump_file (DFI_rtl, decl))
{
- int do_unroll, do_prefetch;
+ if (DECL_SAVED_INSNS (decl))
+ fprintf (rtl_dump_file, ";; (integrable)\n\n");
+ close_dump_file (DFI_rtl, print_rtl, insns);
+ }
- timevar_push (TV_LOOP);
- delete_dead_jumptables ();
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
- open_dump_file (DFI_loop, decl);
- /* CFG is no longer maintained up-to-date. */
- free_bb_for_insn ();
+ /* Convert from NOTE_INSN_EH_REGION style notes, and do other
+ sorts of eh initialization. Delay this until after the
+ initial rtl dump so that we can see the original nesting. */
+ convert_from_eh_region_ranges ();
+
+ /* If function is inline, and we don't yet know whether to
+ compile it by itself, defer decision till end of compilation.
+ wrapup_global_declarations will (indirectly) call
+ rest_of_compilation again for those functions that need to
+ be output. Also defer those functions that we are supposed
+ to defer. */
+
+ if (inlinable
+ || (DECL_INLINE (decl)
+ && flag_inline_functions
+ && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
+ && ! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
+ && ! flag_keep_inline_functions)
+ || DECL_EXTERNAL (decl))))
+ DECL_DEFER_OUTPUT (decl) = 1;
- if (flag_unroll_loops)
- do_unroll = 0; /* 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;
- if (flag_rerun_loop_opt)
+ if (DECL_INLINE (decl))
+ /* DWARF wants separate debugging info for abstract and
+ concrete instances of all inline functions, including those
+ declared inline but not inlined, and those inlined even
+ though they weren't declared inline. Conveniently, that's
+ what DECL_INLINE means at this point. */
+ (*debug_hooks->deferred_inline_function) (decl);
+
+ if (DECL_DEFER_OUTPUT (decl))
+ {
+ /* If -Wreturn-type, we have to do a bit of compilation. We just
+ want to call cleanup the cfg to figure out whether or not we can
+ fall off the end of the function; we do the minimum amount of
+ work necessary to make that safe. */
+ if (warn_return_type)
{
- cleanup_barriers ();
-
- /* We only want to perform unrolling once. */
- loop_optimize (insns, rtl_dump_file, do_unroll);
- do_unroll = 0;
+ int saved_optimize = optimize;
- /* The first call to loop_optimize makes some instructions
- trivially dead. We delete those instructions now in the
- hope that doing so will make the heuristics in loop work
- better and possibly speed up compilation. */
- delete_trivially_dead_insns (insns, max_reg_num ());
+ optimize = 0;
+ rebuild_jump_labels (insns);
+ find_exception_handler_labels ();
+ find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
+ cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
+ optimize = saved_optimize;
- /* The regscan pass is currently necessary as the alias
- analysis code depends on this information. */
- reg_scan (insns, max_reg_num (), 1);
+ /* CFG is no longer maintained up-to-date. */
+ free_bb_for_insn ();
}
- cleanup_barriers ();
- loop_optimize (insns, rtl_dump_file, do_unroll | LOOP_BCT | do_prefetch);
-
- /* Loop can create trivially dead instructions. */
- delete_trivially_dead_insns (insns, max_reg_num ());
- close_dump_file (DFI_loop, print_rtl, insns);
- timevar_pop (TV_LOOP);
- find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
- ggc_collect ();
+ set_nothrow_function_flags ();
+ if (current_function_nothrow)
+ /* Now we know that this can't throw; set the flag for the benefit
+ of other functions later in this translation unit. */
+ TREE_NOTHROW (current_function_decl) = 1;
+
+ timevar_push (TV_INTEGRATION);
+ save_for_inline (decl);
+ timevar_pop (TV_INTEGRATION);
+ DECL_SAVED_INSNS (decl)->inlinable = inlinable;
+ return true;
}
- /* Perform jump bypassing and control flow optimizations. */
- if (optimize > 0 && flag_gcse)
- {
- timevar_push (TV_BYPASS);
- open_dump_file (DFI_bypass, decl);
+ /* If specified extern inline but we aren't inlining it, we are
+ done. This goes for anything that gets here with DECL_EXTERNAL
+ set, not just things with DECL_INLINE. */
+ return (bool) DECL_EXTERNAL (decl);
+}
- cleanup_cfg (CLEANUP_EXPENSIVE);
- tem = bypass_jumps (rtl_dump_file);
+/* 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);
- if (tem)
- {
- rebuild_jump_labels (insns);
- cleanup_cfg (CLEANUP_EXPENSIVE);
- delete_trivially_dead_insns (insns, max_reg_num ());
- }
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ convert_to_ssa ();
- close_dump_file (DFI_bypass, print_rtl_with_bb, insns);
- timevar_pop (TV_BYPASS);
+ close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
+ timevar_pop (TV_TO_SSA);
- ggc_collect ();
+ /* Perform sparse conditional constant propagation, if requested. */
+ if (flag_ssa_ccp)
+ {
+ timevar_push (TV_SSA_CCP);
+ open_dump_file (DFI_ssa_ccp, decl);
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ ssa_const_prop ();
+
+ close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
+ timevar_pop (TV_SSA_CCP);
}
- /* Do control and data flow analysis; wrote some of the results to
- the dump file. */
+ /* 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. */
- timevar_push (TV_FLOW);
- open_dump_file (DFI_cfg, decl);
- if (rtl_dump_file)
- dump_flow_info (rtl_dump_file);
- if (optimize)
- cleanup_cfg (CLEANUP_EXPENSIVE
- | (flag_thread_jumps ? CLEANUP_THREADING : 0));
+ /* 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. */
- /* It may make more sense to mark constant functions after dead code is
- eliminated by life_analysis, but we need to do it early, as -fprofile-arcs
- may insert code making function non-constant, but we still must consider
- it as constant, otherwise -fbranch-probabilities will not read data back.
+ if (flag_ssa_dce)
+ {
+ /* Remove dead code. */
- life_analysis rarely eliminates modification of external memory.
- */
- if (optimize)
- mark_constant_function ();
+ timevar_push (TV_SSA_DCE);
+ open_dump_file (DFI_ssa_dce, decl);
- close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
+ insns = get_insns ();
+ ssa_eliminate_dead_code ();
- /* Do branch profiling and static profile estimation passes. */
- if (optimize > 0 || cfun->arc_profile || flag_branch_probabilities)
- {
- struct loops loops;
+ close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
+ timevar_pop (TV_SSA_DCE);
+ }
- timevar_push (TV_BRANCH_PROB);
- open_dump_file (DFI_bp, decl);
- if (cfun->arc_profile || flag_branch_probabilities)
- branch_prob ();
+ /* Convert from SSA form. */
- /* Discover and record the loop depth at the head of each basic
- block. The loop infrastructure does the real job for us. */
- flow_loops_find (&loops, LOOP_TREE);
+ timevar_push (TV_FROM_SSA);
+ open_dump_file (DFI_ussa, decl);
- if (rtl_dump_file)
- flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
+ convert_from_ssa ();
+ /* New registers have been created. Rescan their usage. */
+ reg_scan (insns, max_reg_num (), 1);
- /* Estimate using heuristics if no profiling info is available. */
- if (flag_guess_branch_prob)
- estimate_probability (&loops);
+ close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
+ timevar_pop (TV_FROM_SSA);
- flow_loops_free (&loops);
- close_dump_file (DFI_bp, print_rtl_with_bb, insns);
- timevar_pop (TV_BRANCH_PROB);
- }
- if (optimize > 0)
- {
- open_dump_file (DFI_ce1, decl);
- if (flag_if_conversion)
- {
- timevar_push (TV_IFCVT);
- if (rtl_dump_file)
- dump_flow_info (rtl_dump_file);
- cleanup_cfg (CLEANUP_EXPENSIVE);
- reg_scan (insns, max_reg_num (), 0);
- if_convert (0);
- timevar_pop (TV_IFCVT);
- }
- timevar_push (TV_JUMP);
- cleanup_cfg (CLEANUP_EXPENSIVE);
- reg_scan (insns, max_reg_num (), 0);
- timevar_pop (TV_JUMP);
- close_dump_file (DFI_ce1, print_rtl_with_bb, get_insns ());
- }
- if (flag_tracer)
- {
- timevar_push (TV_TRACER);
- open_dump_file (DFI_tracer, decl);
- if (rtl_dump_file)
- dump_flow_info (rtl_dump_file);
- tracer ();
- 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);
- }
+ ggc_collect ();
- /* Perform loop optimalizations. It might be better to do them a bit
- sooner, but we want the profile feedback to work more efficiently. */
- if (optimize > 0
- && (flag_unswitch_loops
- || flag_peel_loops
- || flag_unroll_loops))
- {
- struct loops *loops;
- timevar_push (TV_LOOP);
- open_dump_file (DFI_loop2, decl);
- if (rtl_dump_file)
- dump_flow_info (rtl_dump_file);
+ return insns;
+}
+
+/* Try to identify useless null pointer tests and delete them. */
+static void
+rest_of_handle_null_pointer (tree decl, rtx insns)
+{
+ open_dump_file (DFI_null, decl);
+ if (rtl_dump_file)
+ dump_flow_info (rtl_dump_file);
- loops = loop_optimizer_init (rtl_dump_file);
+ if (delete_null_pointer_checks (insns))
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
- if (loops)
- {
- /* The optimalizations: */
- if (flag_unswitch_loops)
- unswitch_loops (loops);
+ close_dump_file (DFI_null, print_rtl_with_bb, insns);
+}
- if (flag_peel_loops || flag_unroll_loops)
- unroll_and_peel_loops (loops,
- (flag_peel_loops ? UAP_PEEL : 0) |
- (flag_unroll_loops ? UAP_UNROLL : 0) |
- (flag_unroll_all_loops ? UAP_UNROLL_ALL : 0));
+/* Try combining insns through substitution. */
+static void
+rest_of_handle_combine (tree decl, rtx insns)
+{
+ int rebuild_jump_labels_after_combine = 0;
- loop_optimizer_finalize (loops, rtl_dump_file);
- }
+ timevar_push (TV_COMBINE);
+ open_dump_file (DFI_combine, decl);
- cleanup_cfg (CLEANUP_EXPENSIVE);
- delete_trivially_dead_insns (insns, max_reg_num ());
- reg_scan (insns, max_reg_num (), 0);
- if (rtl_dump_file)
- dump_flow_info (rtl_dump_file);
- close_dump_file (DFI_loop2, print_rtl_with_bb, get_insns ());
- timevar_pop (TV_LOOP);
- ggc_collect ();
- }
+ rebuild_jump_labels_after_combine
+ = combine_instructions (insns, max_reg_num ());
- if (flag_rerun_cse_after_loop)
+ /* Combining insns may have turned an indirect jump into a
+ direct jump. Rebuild the JUMP_LABEL fields of jumping
+ instructions. */
+ if (rebuild_jump_labels_after_combine)
{
- timevar_push (TV_CSE2);
- open_dump_file (DFI_cse2, decl);
- if (rtl_dump_file)
- 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);
- purge_all_dead_edges (0);
- delete_trivially_dead_insns (insns, max_reg_num ());
+ timevar_push (TV_JUMP);
+ rebuild_jump_labels (insns);
+ timevar_pop (TV_JUMP);
- if (tem)
- {
- timevar_push (TV_JUMP);
- rebuild_jump_labels (insns);
- cleanup_cfg (CLEANUP_EXPENSIVE);
- timevar_pop (TV_JUMP);
- }
- reg_scan (insns, max_reg_num (), 0);
- close_dump_file (DFI_cse2, print_rtl_with_bb, insns);
- ggc_collect ();
- timevar_pop (TV_CSE2);
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
}
- cse_not_expected = 1;
+ close_dump_file (DFI_combine, print_rtl_with_bb, insns);
+ timevar_pop (TV_COMBINE);
+
+ ggc_collect ();
+}
+/* Perform life analysis. */
+static void
+rest_of_handle_life (tree decl, rtx insns)
+{
open_dump_file (DFI_life, decl);
regclass_init ();
- check_function_return_warnings ();
-
#ifdef ENABLE_CHECKING
verify_flow_info ();
#endif
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
timevar_pop (TV_FLOW);
- no_new_pseudos = 1;
-
- if (warn_uninitialized || extra_warnings)
+ if (warn_uninitialized)
{
uninitialized_vars_warning (DECL_INITIAL (decl));
if (extra_warnings)
if (optimize)
{
- clear_bb_flags ();
if (!flag_new_regalloc && initialize_uninitialized_subregs ())
{
- /* Insns were inserted, so things might look a bit different. */
+ /* Insns were inserted, and possibly pseudos created, so
+ things might look a bit different. */
insns = get_insns ();
- update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
- PROP_LOG_LINKS | PROP_REG_INFO
- | PROP_DEATH_NOTES);
+ allocate_reg_life_data ();
+ update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
+ PROP_LOG_LINKS | PROP_REG_INFO | PROP_DEATH_NOTES);
}
}
+ no_new_pseudos = 1;
+
close_dump_file (DFI_life, print_rtl_with_bb, insns);
ggc_collect ();
+}
- /* If -opt, try combining insns through substitution. */
+/* Perform common subexpression elimination. Nonzero value from
+ `cse_main' means that jumps were simplified and some code may now
+ be unreachable, so do jump optimization again. */
+static void
+rest_of_handle_cse (tree decl, rtx insns)
+{
+ int tem;
- if (optimize > 0)
- {
- int rebuild_jump_labels_after_combine = 0;
+ open_dump_file (DFI_cse, decl);
+ if (rtl_dump_file)
+ dump_flow_info (rtl_dump_file);
+ timevar_push (TV_CSE);
- timevar_push (TV_COMBINE);
- open_dump_file (DFI_combine, decl);
+ reg_scan (insns, max_reg_num (), 1);
- rebuild_jump_labels_after_combine
- = combine_instructions (insns, max_reg_num ());
+ tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
+ if (tem)
+ rebuild_jump_labels (insns);
+ purge_all_dead_edges (0);
- /* Combining insns may have turned an indirect jump into a
- direct jump. Rebuild the JUMP_LABEL fields of jumping
- instructions. */
- if (rebuild_jump_labels_after_combine)
- {
- timevar_push (TV_JUMP);
- rebuild_jump_labels (insns);
- timevar_pop (TV_JUMP);
+ delete_trivially_dead_insns (insns, max_reg_num ());
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
- }
+ /* If we are not running more CSE passes, then we are no longer
+ expecting CSE to be run. But always rerun it in a cheap mode. */
+ cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
- close_dump_file (DFI_combine, print_rtl_with_bb, insns);
- timevar_pop (TV_COMBINE);
+ if (tem || optimize > 1)
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ /* Try to identify useless null pointer tests and delete them. */
+ if (flag_delete_null_pointer_checks)
+ {
+ timevar_push (TV_JUMP);
- ggc_collect ();
+ if (delete_null_pointer_checks (insns))
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ timevar_pop (TV_JUMP);
}
- /* Rerun if-conversion, as combine may have simplified things enough to
- now meet sequence length restrictions. */
- if (flag_if_conversion)
+ /* The second pass of jump optimization is likely to have
+ removed a bunch more instructions. */
+ renumber_insns (rtl_dump_file);
+
+ timevar_pop (TV_CSE);
+ close_dump_file (DFI_cse, print_rtl_with_bb, insns);
+}
+
+/* Run second CSE pass after loop optimizations. */
+static void
+rest_of_handle_cse2 (tree decl, rtx insns)
+{
+ int tem;
+
+ timevar_push (TV_CSE2);
+ open_dump_file (DFI_cse2, decl);
+ if (rtl_dump_file)
+ 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);
+ purge_all_dead_edges (0);
+ delete_trivially_dead_insns (insns, max_reg_num ());
+
+ if (tem)
{
- timevar_push (TV_IFCVT);
- open_dump_file (DFI_ce2, decl);
+ timevar_push (TV_JUMP);
+ rebuild_jump_labels (insns);
+ cleanup_cfg (CLEANUP_EXPENSIVE);
+ timevar_pop (TV_JUMP);
+ }
+ reg_scan (insns, max_reg_num (), 0);
+ close_dump_file (DFI_cse2, print_rtl_with_bb, insns);
+ ggc_collect ();
+ timevar_pop (TV_CSE2);
+}
- no_new_pseudos = 0;
- if_convert (1);
- no_new_pseudos = 1;
+/* Perform global cse. */
+static void
+rest_of_handle_gcse (tree decl, rtx insns)
+{
+ int save_csb, save_cfj;
+ int tem2 = 0, tem;
- close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
- timevar_pop (TV_IFCVT);
+ timevar_push (TV_GCSE);
+ open_dump_file (DFI_gcse, decl);
+
+ tem = gcse_main (insns, rtl_dump_file);
+ rebuild_jump_labels (insns);
+ delete_trivially_dead_insns (insns, max_reg_num ());
+
+ save_csb = flag_cse_skip_blocks;
+ save_cfj = flag_cse_follow_jumps;
+ flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
+
+ /* Instantiate any remaining CONSTANT_P_RTX nodes. */
+ if (current_function_calls_constant_p)
+ purge_builtin_constant_p ();
+
+ /* If -fexpensive-optimizations, re-run CSE to clean up things done
+ by gcse. */
+ if (flag_expensive_optimizations)
+ {
+ timevar_push (TV_CSE);
+ reg_scan (insns, max_reg_num (), 1);
+ tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
+ purge_all_dead_edges (0);
+ delete_trivially_dead_insns (insns, max_reg_num ());
+ timevar_pop (TV_CSE);
+ cse_not_expected = !flag_rerun_cse_after_loop;
}
- /* Register allocation pre-pass, to reduce number of moves
- necessary for two-address machines. */
- if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
+ /* If gcse or cse altered any jumps, rerun jump optimizations to clean
+ things up. Then possibly re-run CSE again. */
+ while (tem || tem2)
{
- timevar_push (TV_REGMOVE);
- open_dump_file (DFI_regmove, decl);
+ tem = tem2 = 0;
+ timevar_push (TV_JUMP);
+ rebuild_jump_labels (insns);
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ timevar_pop (TV_JUMP);
+
+ if (flag_expensive_optimizations)
+ {
+ timevar_push (TV_CSE);
+ reg_scan (insns, max_reg_num (), 1);
+ tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
+ purge_all_dead_edges (0);
+ delete_trivially_dead_insns (insns, max_reg_num ());
+ timevar_pop (TV_CSE);
+ }
+ }
- regmove_optimize (insns, max_reg_num (), rtl_dump_file);
+ close_dump_file (DFI_gcse, print_rtl_with_bb, insns);
+ timevar_pop (TV_GCSE);
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
- close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
- timevar_pop (TV_REGMOVE);
+ ggc_collect ();
+ flag_cse_skip_blocks = save_csb;
+ flag_cse_follow_jumps = save_cfj;
+#ifdef ENABLE_CHECKING
+ verify_flow_info ();
+#endif
+}
+
+/* Move constant computations out of loops. */
+static void
+rest_of_handle_loop_optimize (tree decl, rtx insns)
+{
+ int do_unroll, do_prefetch;
+
+ timevar_push (TV_LOOP);
+ delete_dead_jumptables ();
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ open_dump_file (DFI_loop, decl);
+
+ /* CFG is no longer maintained up-to-date. */
+ free_bb_for_insn ();
+
+ if (flag_unroll_loops)
+ do_unroll = 0; /* 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;
+
+ if (flag_rerun_loop_opt)
+ {
+ cleanup_barriers ();
+
+ /* We only want to perform unrolling once. */
+ loop_optimize (insns, rtl_dump_file, do_unroll);
+ do_unroll = 0;
+
+ /* The first call to loop_optimize makes some instructions
+ trivially dead. We delete those instructions now in the
+ hope that doing so will make the heuristics in loop work
+ better and possibly speed up compilation. */
+ delete_trivially_dead_insns (insns, max_reg_num ());
+
+ /* The regscan pass is currently necessary as the alias
+ analysis code depends on this information. */
+ reg_scan (insns, max_reg_num (), 1);
+ }
+ cleanup_barriers ();
+ loop_optimize (insns, rtl_dump_file, do_unroll | LOOP_BCT | do_prefetch);
+
+ /* Loop can create trivially dead instructions. */
+ delete_trivially_dead_insns (insns, max_reg_num ());
+ close_dump_file (DFI_loop, print_rtl, insns);
+ timevar_pop (TV_LOOP);
+ find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
+
+ ggc_collect ();
+}
+
+/* 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
+rest_of_handle_loop2 (tree decl, rtx insns)
+{
+ struct loops *loops;
+ timevar_push (TV_LOOP);
+ open_dump_file (DFI_loop2, decl);
+ if (rtl_dump_file)
+ dump_flow_info (rtl_dump_file);
+
+ loops = loop_optimizer_init (rtl_dump_file);
+
+ if (loops)
+ {
+ /* The optimizations: */
+ if (flag_unswitch_loops)
+ unswitch_loops (loops);
+
+ if (flag_peel_loops || flag_unroll_loops)
+ unroll_and_peel_loops (loops,
+ (flag_peel_loops ? UAP_PEEL : 0) |
+ (flag_unroll_loops ? UAP_UNROLL : 0) |
+ (flag_unroll_all_loops ? UAP_UNROLL_ALL : 0));
+
+ loop_optimizer_finalize (loops, rtl_dump_file);
+ }
+
+ cleanup_cfg (CLEANUP_EXPENSIVE);
+ delete_trivially_dead_insns (insns, max_reg_num ());
+ reg_scan (insns, max_reg_num (), 0);
+ if (rtl_dump_file)
+ dump_flow_info (rtl_dump_file);
+ close_dump_file (DFI_loop2, print_rtl_with_bb, get_insns ());
+ timevar_pop (TV_LOOP);
+ ggc_collect ();
+}
+
+/* This is called from finish_function (within langhooks.parse_file)
+ after each top-level definition is parsed.
+ It is supposed to compile that function or variable
+ and output the assembler code for it.
+ After we return, the tree storage is freed. */
+
+void
+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;
+
+ /* When processing delayed functions, prepare_function_start() won't
+ have been run to re-initialize it. */
+ cse_not_expected = ! optimize;
+
+ /* First, make sure that NOTE_BLOCK is set correctly for each
+ NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */
+ if (!cfun->x_whole_function_mode_p)
+ identify_blocks ();
+
+ /* In function-at-a-time mode, we do not attempt to keep the BLOCK
+ tree in sensible shape. So, we just recalculate it here. */
+ if (cfun->x_whole_function_mode_p)
+ reorder_blocks ();
+
+ init_flow ();
+
+ if (rest_of_handle_inlining (decl))
+ goto exit_rest_of_compilation;
+
+ /* If we're emitting a nested function, make sure its parent gets
+ emitted as well. Doing otherwise confuses debug info. */
+ {
+ tree parent;
+ for (parent = DECL_CONTEXT (current_function_decl);
+ parent != NULL_TREE;
+ parent = get_containing_scope (parent))
+ if (TREE_CODE (parent) == FUNCTION_DECL)
+ TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
+ }
+
+ /* 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))
+ (*debug_hooks->outlining_inline_function) (decl);
+
+ /* Remove any notes we don't need. That will make iterating
+ over the instruction sequence faster, and allow the garbage
+ collector to reclaim the memory used by the notes. */
+ remove_unnecessary_notes ();
+ reorder_blocks ();
+
+ ggc_collect ();
+
+ /* Initialize some variables used by the optimizers. */
+ init_function_for_compilation ();
+
+ if (! DECL_DEFER_OUTPUT (decl))
+ TREE_ASM_WRITTEN (decl) = 1;
+
+ /* Now that integrate will no longer see our rtl, we need not
+ distinguish between the return value of this function and the
+ return value of called functions. Also, we can remove all SETs
+ of subregs of hard registers; they are only here because of
+ integrate. Also, we can now initialize pseudos intended to
+ carry magic hard reg data throughout the function. */
+ rtx_equal_function_value_matters = 0;
+ purge_hard_subreg_sets (get_insns ());
+
+ /* Early return if there were errors. We can run afoul of our
+ consistency checks, and there's not really much point in fixing them.
+ Don't return yet if -Wreturn-type; we need to do cleanup_cfg. */
+ if (((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
+ || errorcount || sorrycount)
+ goto exit_rest_of_compilation;
+
+ timevar_push (TV_JUMP);
+ open_dump_file (DFI_sibling, decl);
+ insns = get_insns ();
+ rebuild_jump_labels (insns);
+ find_exception_handler_labels ();
+ find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
+
+ 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)
+ {
+ timevar_push (TV_BRANCH_PROB);
+ note_prediction_to_br_prob ();
+ timevar_pop (TV_BRANCH_PROB);
+ }
+
+ if (flag_optimize_sibling_calls)
+ rest_of_handle_sibling_calls (insns);
+
+ timevar_pop (TV_JUMP);
+
+ insn_locators_initialize ();
+ /* Complete generation of exception handling code. */
+ if (doing_eh (0))
+ {
+ timevar_push (TV_JUMP);
+ open_dump_file (DFI_eh, decl);
+
+ finish_eh_generation ();
+
+ close_dump_file (DFI_eh, print_rtl, get_insns ());
+ timevar_pop (TV_JUMP);
+ }
+
+ /* Delay emitting hard_reg_initial_value sets until after EH landing pad
+ generation, which might create new sets. */
+ emit_initial_value_sets ();
+
+#ifdef FINALIZE_PIC
+ /* If we are doing position-independent code generation, now
+ is the time to output special prologues and epilogues.
+ We do not want to do this earlier, because it just clutters
+ up inline functions with meaningless insns. */
+ if (flag_pic)
+ FINALIZE_PIC;
+#endif
+
+ insns = get_insns ();
+
+ /* Copy any shared structure that should not be shared. */
+ unshare_all_rtl (current_function_decl, insns);
+
+#ifdef SETJMP_VIA_SAVE_AREA
+ /* This must be performed before virtual register instantiation.
+ Please be aware the everything in the compiler that can look
+ at the RTL up to this point must understand that REG_SAVE_AREA
+ is just like a use of the REG contained inside. */
+ if (current_function_calls_alloca)
+ optimize_save_area_alloca (insns);
+#endif
+
+ /* Instantiate all virtual registers. */
+ instantiate_virtual_regs (current_function_decl, insns);
+
+ open_dump_file (DFI_jump, decl);
+
+ /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
+ are initialized and to compute whether control can drop off the end
+ of the function. */
+
+ timevar_push (TV_JUMP);
+ /* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
+ before jump optimization switches branch directions. */
+ if (flag_guess_branch_prob)
+ expected_value_to_br_prob ();
+
+ reg_scan (insns, max_reg_num (), 0);
+ rebuild_jump_labels (insns);
+ find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
+ delete_trivially_dead_insns (insns, max_reg_num ());
+ if (rtl_dump_file)
+ dump_flow_info (rtl_dump_file);
+ cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
+ | (flag_thread_jumps ? CLEANUP_THREADING : 0));
+
+ if (optimize)
+ {
+ free_bb_for_insn ();
+ copy_loop_headers (insns);
+ find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
+ }
+ purge_line_number_notes (insns);
+
+ timevar_pop (TV_JUMP);
+ close_dump_file (DFI_jump, print_rtl, insns);
+
+ /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
+ 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)
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+
+ if (flag_delete_null_pointer_checks)
+ rest_of_handle_null_pointer (decl, insns);
+
+ /* Jump optimization, and the removal of NULL pointer checks, may
+ have reduced the number of instructions substantially. CSE, and
+ future passes, allocate arrays whose dimensions involve the
+ maximum instruction UID, so if we can reduce the maximum UID
+ we'll save big on memory. */
+ renumber_insns (rtl_dump_file);
+ timevar_pop (TV_JUMP);
+
+ close_dump_file (DFI_jump, print_rtl_with_bb, insns);
+
+ ggc_collect ();
+
+ if (optimize > 0)
+ rest_of_handle_cse (decl, insns);
+
+ rest_of_handle_addresof (decl, insns);
+
+ ggc_collect ();
+
+ if (optimize > 0)
+ {
+ if (flag_gcse)
+ rest_of_handle_gcse (decl, insns);
+
+ 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);
+
+ rest_of_handle_cfg (decl, insns);
+
+ if (optimize > 0
+ || profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
+ rest_of_handle_branch_prob (decl, insns);
+
+ 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
+ || flag_peel_loops
+ || flag_unroll_loops))
+ rest_of_handle_loop2 (decl, insns);
+
+ if (flag_rerun_cse_after_loop)
+ rest_of_handle_cse2 (decl, insns);
+
+ cse_not_expected = 1;
+
+ rest_of_handle_life (decl, insns);
+
+ if (optimize > 0)
+ rest_of_handle_combine (decl, insns);
+
+ if (flag_if_conversion)
+ rest_of_handle_if_after_combine (decl, insns);
- ggc_collect ();
- }
+ if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
+ rest_of_handle_regmove (decl, insns);
/* Do unconditional splitting before register allocation to allow machine
description to add extra information not needed previously. */
(see handling of reg_known_equiv in init_alias_analysis). */
recompute_reg_usage (insns, !optimize_size);
- timevar_push (TV_SCHED);
-
#ifdef INSN_SCHEDULING
-
- /* Print function header into sched dump now
- because doing the sched analysis makes some of the dump. */
- if (optimize > 0 && flag_schedule_insns)
- {
- open_dump_file (DFI_sched, decl);
-
- /* Do control and data sched analysis,
- and write some of the results to dump file. */
-
- schedule_insns (rtl_dump_file);
-
- close_dump_file (DFI_sched, print_rtl_with_bb, insns);
- }
+ rest_of_handle_sched (decl, insns);
#endif
- timevar_pop (TV_SCHED);
-
- ggc_collect ();
/* Determine if the current function is a leaf before running reload
since this can impact optimizations done by the prologue and
timevar_push (TV_LOCAL_ALLOC);
open_dump_file (DFI_lreg, decl);
- /* Allocate pseudo-regs that are used only within 1 basic block.
-
- RUN_JUMP_AFTER_RELOAD records whether or not we need to rerun the
- jump optimizer after register allocation and reloading are finished. */
-
if (flag_new_regalloc)
{
- delete_trivially_dead_insns (insns, max_reg_num ());
- reg_alloc ();
-
- timevar_pop (TV_LOCAL_ALLOC);
- if (dump_file[DFI_lreg].enabled)
- {
- timevar_push (TV_DUMP);
-
- close_dump_file (DFI_lreg, NULL, NULL);
- timevar_pop (TV_DUMP);
- }
-
- /* XXX clean up the whole mess to bring live info in shape again. */
- timevar_push (TV_GLOBAL_ALLOC);
- open_dump_file (DFI_greg, decl);
-
- build_insn_chain (insns);
- failure = reload (insns, 0);
-
- timevar_pop (TV_GLOBAL_ALLOC);
-
- if (dump_file[DFI_greg].enabled)
- {
- timevar_push (TV_DUMP);
-
- dump_global_regs (rtl_dump_file);
-
- close_dump_file (DFI_greg, print_rtl_with_bb, insns);
- timevar_pop (TV_DUMP);
- }
-
- if (failure)
- goto exit_rest_of_compilation;
- reload_completed = 1;
- rebuild_label_notes_after_reload = 0;
+ if (rest_of_handle_new_regalloc (decl, insns,
+ &rebuild_label_notes_after_reload))
+ goto exit_rest_of_compilation;
}
else
{
- /* 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));
-
- allocate_initial_values (reg_equiv_memory_loc);
-
- regclass (insns, max_reg_num (), rtl_dump_file);
- rebuild_label_notes_after_reload = local_alloc ();
-
- timevar_pop (TV_LOCAL_ALLOC);
-
- if (dump_file[DFI_lreg].enabled)
- {
- timevar_push (TV_DUMP);
-
- dump_flow_info (rtl_dump_file);
- dump_local_alloc (rtl_dump_file);
-
- close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
- timevar_pop (TV_DUMP);
- }
-
- ggc_collect ();
-
- timevar_push (TV_GLOBAL_ALLOC);
- open_dump_file (DFI_greg, decl);
-
- /* If optimizing, allocate remaining pseudo-regs. Do the reload
- pass fixing up any insns that are invalid. */
-
- if (optimize)
- failure = global_alloc (rtl_dump_file);
- else
- {
- build_insn_chain (insns);
- failure = reload (insns, 0);
- }
-
- timevar_pop (TV_GLOBAL_ALLOC);
-
- if (dump_file[DFI_greg].enabled)
- {
- timevar_push (TV_DUMP);
-
- dump_global_regs (rtl_dump_file);
-
- close_dump_file (DFI_greg, print_rtl_with_bb, insns);
- timevar_pop (TV_DUMP);
- }
-
- if (failure)
+ if (rest_of_handle_old_regalloc (decl, insns,
+ &rebuild_label_notes_after_reload))
goto exit_rest_of_compilation;
}
#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)
{
}
#endif
- if (optimize > 0 && (flag_rename_registers || flag_cprop_registers))
- {
- timevar_push (TV_RENAME_REGISTERS);
- open_dump_file (DFI_rnreg, decl);
-
- if (flag_rename_registers)
- regrename_optimize ();
- if (flag_cprop_registers)
- copyprop_hardreg_forward ();
-
- close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
- timevar_pop (TV_RENAME_REGISTERS);
- }
-
if (optimize > 0)
{
- timevar_push (TV_REORDER_BLOCKS);
- 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));
+ if (flag_rename_registers || flag_cprop_registers)
+ rest_of_handle_regrename (decl, insns);
- if (flag_sched2_use_traces && flag_schedule_insns_after_reload)
- tracer ();
- if (flag_reorder_blocks)
- reorder_basic_blocks ();
- if (flag_reorder_blocks
- || (flag_sched2_use_traces && flag_schedule_insns_after_reload))
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
-
- close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
- timevar_pop (TV_REORDER_BLOCKS);
+ rest_of_handle_reorder_blocks (decl, insns);
}
if (flag_if_conversion2)
timevar_pop (TV_IFCVT2);
}
-#ifdef INSN_SCHEDULING
- if (optimize > 0 && flag_schedule_insns_after_reload)
- {
- timevar_push (TV_SCHED2);
- open_dump_file (DFI_sched2, decl);
+ if (flag_branch_target_load_optimize2)
+ {
+ /* 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");
- /* Do control and data sched analysis again,
- and write some more of the results to dump file. */
+ open_dump_file (DFI_branch_target_load, decl);
- split_all_insns (1);
+ branch_target_load_optimize (insns, true);
- if (flag_sched2_use_superblocks || flag_sched2_use_traces)
- {
- schedule_ebbs (rtl_dump_file);
- /* No liveness updating code yet, but it should be easy to do.
- reg-stack recompute the liveness when needed for now. */
- count_or_remove_death_notes (NULL, 1);
- cleanup_cfg (CLEANUP_EXPENSIVE);
- }
- else
- schedule_insns (rtl_dump_file);
+ close_dump_file (DFI_branch_target_load, print_rtl_with_bb, insns);
- close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
- timevar_pop (TV_SCHED2);
+ ggc_collect ();
+ }
- ggc_collect ();
- }
+#ifdef INSN_SCHEDULING
+ if (optimize > 0 && flag_schedule_insns_after_reload)
+ rest_of_handle_sched2 (decl, insns);
#endif
#ifdef LEAF_REGISTERS
#endif
#ifdef STACK_REGS
- timevar_push (TV_REG_STACK);
- open_dump_file (DFI_stack, decl);
-
- if (reg_to_stack (insns, rtl_dump_file) && optimize)
- {
- if (cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
- | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0))
- && flag_reorder_blocks)
- {
- reorder_basic_blocks ();
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
- }
- }
-
- close_dump_file (DFI_stack, print_rtl_with_bb, insns);
- timevar_pop (TV_REG_STACK);
-
- ggc_collect ();
+ rest_of_handle_stack_regs (decl, insns);
#endif
+
compute_alignments ();
/* CFG is no longer maintained up-to-date. */
free_bb_for_insn ();
- /* If a machine dependent reorganization is needed, call it. */
-#ifdef MACHINE_DEPENDENT_REORG
- timevar_push (TV_MACH_DEP);
- open_dump_file (DFI_mach, decl);
-
- MACHINE_DEPENDENT_REORG (insns);
-
- close_dump_file (DFI_mach, print_rtl, insns);
- timevar_pop (TV_MACH_DEP);
-
- ggc_collect ();
-#endif
+ if (targetm.machine_dependent_reorg != 0)
+ rest_of_handle_machine_reorg (decl, insns);
purge_line_number_notes (insns);
cleanup_barriers ();
- /* If a scheduling pass for delayed branches is to be done,
- call the scheduling code. */
-
#ifdef DELAY_SLOTS
if (optimize > 0 && flag_delayed_branch)
- {
- timevar_push (TV_DBR_SCHED);
- open_dump_file (DFI_dbr, decl);
-
- dbr_schedule (insns, rtl_dump_file);
-
- close_dump_file (DFI_dbr, print_rtl, insns);
- timevar_pop (TV_DBR_SCHED);
-
- ggc_collect ();
- }
+ rest_of_handle_delay_slots (decl, insns);
#endif
#if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
of other functions later in this translation unit. */
TREE_NOTHROW (current_function_decl) = 1;
- /* Now turn the rtl into assembler code. */
-
- timevar_push (TV_FINAL);
- {
- rtx x;
- const char *fnname;
-
- /* Get the function's name, as described by its RTL. This may be
- different from the DECL_NAME name used in the source file. */
-
- x = DECL_RTL (decl);
- if (GET_CODE (x) != MEM)
- abort ();
- x = XEXP (x, 0);
- if (GET_CODE (x) != SYMBOL_REF)
- abort ();
- fnname = XSTR (x, 0);
-
- assemble_start_function (decl, fnname);
- final_start_function (insns, asm_out_file, optimize);
- final (insns, asm_out_file, optimize, 0);
- final_end_function ();
-
-#ifdef IA64_UNWIND_INFO
- /* ??? The IA-64 ".handlerdata" directive must be issued before
- the ".endp" directive that closes the procedure descriptor. */
- output_function_exception_table ();
-#endif
-
- assemble_end_function (decl, fnname);
-
-#ifndef IA64_UNWIND_INFO
- /* Otherwise, it feels unclean to switch sections in the middle. */
- output_function_exception_table ();
-#endif
-
- if (! quiet_flag)
- fflush (asm_out_file);
-
- /* Release all memory allocated by flow. */
- free_basic_block_vars (0);
-
- /* Release all memory held by regsets now. */
- regset_release_memory ();
- }
- timevar_pop (TV_FINAL);
-
- ggc_collect ();
+ rest_of_handle_final (decl, insns);
/* Write DBX symbols if requested. */
exit_rest_of_compilation:
+ coverage_end_function ();
+
/* In case the function was not output,
don't leave any temporary anonymous types
queued up for sdb output. */
#endif
reload_completed = 0;
+ epilogue_completed = 0;
flow2_completed = 0;
no_new_pseudos = 0;
timevar_pop (TV_REST_OF_COMPILATION);
}
-\f
-static void
-display_help ()
+
+/* Display help for generic options. */
+void
+display_help (void)
{
int undoc;
unsigned long i;
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--;)
{
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"));
display_target_options ();
}
-static void
-display_target_options ()
+/* Display help for target options. */
+void
+display_target_options (void)
{
int undoc, i;
static bool displayed = false;
/* Avoid double printing for --help --target-help. */
if (displayed)
return;
+
displayed = true;
if (ARRAY_SIZE (target_switches) > 1
}
}
}
-\f
+
/* Parse a -d... command line switch. */
-static void
-decode_d_option (arg)
- const char *arg;
+void
+decode_d_option (const char *arg)
{
int i, c, matched;
break;
case 'D': /* These are handled by the preprocessor. */
case 'I':
- break;
- case 'H':
- setup_core_dumping();
- break;
-
- default:
- matched = 0;
- for (i = 0; i < (int) DFI_MAX; ++i)
- if (c == dump_file[i].debug_switch)
- {
- dump_file[i].enabled = 1;
- matched = 1;
- }
-
- if (! matched)
- warning ("unrecognized gcc debugging option: %c", c);
- break;
- }
-}
-
-/* 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 (arg)
- 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 (!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 (arg)
- 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);
+ break;
+ case 'H':
+ setup_core_dumping();
+ break;
- 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"))
- {
- /* 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 (warn_uninitialized != 1)
- warn_uninitialized = 2;
- }
- else
- return 0;
+ default:
+ matched = 0;
+ for (i = 0; i < (int) DFI_MAX; ++i)
+ if (c == dump_file[i].debug_switch)
+ {
+ dump_file[i].enabled = 1;
+ matched = 1;
+ }
- return 1;
+ if (! matched)
+ warning ("unrecognized gcc debugging option: %c", c);
+ break;
+ }
}
+/* 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 (arg)
- const char *arg;
+void
+decode_g_option (const char *arg)
{
static unsigned level = 0;
/* A lot of code assumes write_symbols == NO_DEBUG if the
-g and -ggdb don't explicitly set the debugging format so
-gdwarf -g3 is equivalent to -gdwarf3. */
static int type_explicitly_set_p = 0;
- /* Indexed by enum debug_info_type. */
- static const char *const debug_type_names[] =
- {
- "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff", "vms"
- };
/* The maximum admissible debug level value. */
static const unsigned max_debug_level = 3;
}
if (! da->arg)
- return 0;
-
- return 1;
+ warning ("`-g%s': unknown or unsupported -g option", arg);
}
-/* Decode the first argument in the argv as a language-independent option.
- Return the number of strings consumed. */
-
-static unsigned int
-independent_decode_option (argc, argv)
- int argc;
- char **argv;
-{
- char *arg = argv[0];
-
- if (arg[0] != '-' || arg[1] == 0)
- {
- if (arg[0] == '+')
- return 0;
-
- filename = arg;
-
- return 1;
- }
-
- arg++;
-
- if (!strcmp (arg, "-help"))
- {
- display_help ();
- exit_after_options = 1;
- }
-
- if (!strcmp (arg, "-target-help"))
- {
- display_target_options ();
- exit_after_options = 1;
- }
-
- if (!strcmp (arg, "-version"))
- {
- print_version (stderr, "");
- exit_after_options = 1;
- }
-
- /* 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;
- }
-
- if (*arg == 'Y')
- arg++;
-
- 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 'd':
- if (!strcmp (arg, "dumpbase"))
- {
- if (argc == 1)
- return 0;
-
- if (argv[1][0])
- dump_base_name = argv[1];
-
- return 2;
- }
- else
- decode_d_option (arg + 1);
- break;
-
- case 'p':
- if (!strcmp (arg, "pedantic"))
- pedantic = 1;
- else if (!strcmp (arg, "pedantic-errors"))
- flag_pedantic_errors = pedantic = 1;
- else if (arg[1] == 0)
- profile_flag = 1;
- else
- return 0;
- break;
-
- case 'q':
- if (!strcmp (arg, "quiet"))
- quiet_flag = 1;
- else
- return 0;
- break;
-
- case 'v':
- if (!strcmp (arg, "version"))
- version_flag = 1;
- else
- return 0;
- break;
-
- case 'w':
- if (arg[1] == 0)
- inhibit_warnings = 1;
- else
- return 0;
- break;
-
- case 'W':
- if (arg[1] == 0)
- {
- extra_warnings = 1;
- /* 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 (warn_uninitialized != 1)
- warn_uninitialized = 2;
- }
- else
- return decode_W_option (arg + 1);
- break;
-
- case 'a':
- if (!strncmp (arg, "aux-info", 8))
- {
- if (arg[8] == '\0')
- {
- if (argc == 1)
- return 0;
-
- aux_info_file_name = argv[1];
- flag_gen_aux_info = 1;
- return 2;
- }
- else if (arg[8] == '=')
- {
- aux_info_file_name = arg + 9;
- flag_gen_aux_info = 1;
- }
- else
- return 0;
- }
- else if (!strcmp (arg, "auxbase"))
- {
- if (argc == 1)
- return 0;
-
- if (argv[1][0])
- aux_base_name = argv[1];
-
- return 2;
- }
- else if (!strcmp (arg, "auxbase-strip"))
- {
- if (argc == 1)
- return 0;
-
- if (argv[1][0])
- {
- strip_off_ending (argv[1], strlen (argv[1]));
- if (argv[1][0])
- aux_base_name = argv[1];
- }
-
- return 2;
- }
- else
- return 0;
- break;
-
- case 'o':
- if (arg[1] == 0)
- {
- if (argc == 1)
- return 0;
-
- asm_file_name = argv[1];
- return 2;
- }
- return 0;
-
- case 'G':
- {
- int g_switch_val;
- int return_val;
-
- if (arg[1] == 0)
- {
- if (argc == 1)
- return 0;
-
- g_switch_val = read_integral_parameter (argv[1], 0, -1);
- return_val = 2;
- }
- else
- {
- g_switch_val = read_integral_parameter (arg + 1, 0, -1);
- return_val = 1;
- }
-
- if (g_switch_val == -1)
- return_val = 0;
- else
- {
- g_switch_set = TRUE;
- g_switch_value = g_switch_val;
- }
-
- return return_val;
- }
- }
-
- return 1;
-}
-\f
/* Decode -m switches. */
/* Decode the switch -mNAME. */
-static void
-set_target_switch (name)
- const char *name;
+void
+set_target_switch (const char *name)
{
size_t j;
int valid_target_option = 0;
for (j = 0; j < ARRAY_SIZE (target_options); j++)
{
int len = strlen (target_options[j].prefix);
- if (!strncmp (target_options[j].prefix, name, len))
+ if (target_options[j].value)
+ {
+ if (!strcmp (target_options[j].prefix, name))
+ {
+ *target_options[j].variable = target_options[j].value;
+ valid_target_option = 1;
+ }
+ }
+ else
{
- *target_options[j].variable = name + len;
- valid_target_option = 1;
+ if (!strncmp (target_options[j].prefix, name, len))
+ {
+ *target_options[j].variable = name + len;
+ valid_target_option = 1;
+ }
}
}
#endif
if (!valid_target_option)
error ("invalid option `%s'", name);
}
-\f
+
/* Print version information to FILE.
Each line begins with INDENT (for the case where FILE is the
assembler output file). */
-static void
-print_version (file, indent)
- FILE *file;
- const char *indent;
+void
+print_version (FILE *file, const char *indent)
{
#ifndef __VERSION__
#define __VERSION__ "[?]"
other code will catch a disk full though. */
static int
-print_single_switch (file, pos, max, indent, sep, term, type, name)
- FILE *file;
- int pos, max;
- const char *indent, *sep, *term, *type, *name;
+print_single_switch (FILE *file, int pos, int max,
+ const char *indent, const char *sep, const char *term,
+ const char *type, const char *name)
{
/* The ultrix fprintf returns 0 on success, so compute the result we want
here since we need it for the following test. */
Each switch is separated from the next by SEP. */
static void
-print_switch_values (file, pos, max, indent, sep, term)
- FILE *file;
- int pos, max;
- const char *indent, *sep, *term;
+print_switch_values (FILE *file, int pos, int max,
+ 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 ();
/* Print the options as passed. */
fprintf (file, "%s", term);
}
-\f
+
/* Open assembly code output file. Do this even if -fsyntax-only is
on, because then the driver will have provided the name of a
temporary file or bit bucket for us. NAME is the file specified on
the command line, possibly NULL. */
static void
-init_asm_output (name)
- const char *name;
+init_asm_output (const char *name)
{
if (name == NULL && asm_file_name == 0)
asm_out_file = stdout;
else
asm_out_file = fopen (asm_file_name, "w+");
if (asm_out_file == 0)
- fatal_io_error ("can't open %s for writing", asm_file_name);
+ fatal_error ("can't open %s for writing: %m", asm_file_name);
}
#ifdef IO_BUFFER_SIZE
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)
#endif
}
}
-\f
+
/* 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 (argv0)
- char *argv0;
+general_init (const char *argv0)
{
- char *p;
+ const char *p;
p = argv0 + strlen (argv0);
while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
init_ggc ();
init_stringpool ();
init_ttree ();
-}
-\f
-/* 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 (argc, argv)
- int argc;
- char **argv;
-{
- int i;
-
- /* 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_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 = (*lang_hooks.decode_option) (argc - i, argv + i);
-
- 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_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;
}
-\f
+
/* Process the options that have been parsed. */
static void
-process_options ()
+process_options (void)
{
+ /* Allow the front end to perform consistency checks and do further
+ initialization based on the command line options. This hook also
+ sets the original filename if appropriate (e.g. foo.i -> foo.c)
+ so we can correctly initialize debug output. */
+ no_backend = (*lang_hooks.post_options) (&main_input_filename);
+ input_filename = main_input_filename;
+
#ifdef OVERRIDE_OPTIONS
/* Some machines may reject certain combinations of options. */
OVERRIDE_OPTIONS;
/* Set aux_base_name if not already set. */
if (aux_base_name)
;
- else if (filename)
+ else if (main_input_filename)
{
- char *name = xstrdup (lbasename (filename));
-
+ char *name = xstrdup (lbasename (main_input_filename));
+
strip_off_ending (name, strlen (name));
aux_base_name = name;
}
print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
}
- if (! quiet_flag || flag_detailed_statistics)
- time_report = 1;
-
if (flag_syntax_only)
{
write_symbols = NO_DEBUG;
{
aux_info_file = fopen (aux_info_file_name, "w");
if (aux_info_file == 0)
- fatal_io_error ("can't open %s", aux_info_file_name);
+ fatal_error ("can't open %s: %m", aux_info_file_name);
}
if (! targetm.have_named_sections)
if (flag_signaling_nans)
flag_trapping_math = 1;
}
-\f
+
/* Initialize the compiler back end. */
static void
-backend_init ()
+backend_init (void)
{
/* init_emit_once uses reg_raw_mode and therefore must be called
after init_regs which initialized reg_raw_mode. */
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
init_caller_save ();
expand_dummy_function_end ();
}
-\f
+
/* Language-dependent initialization. Returns nonzero on success. */
static int
-lang_dependent_init (name)
- const char *name;
+lang_dependent_init (const char *name)
{
if (dump_base_name == 0)
dump_base_name = name ? name : "gccdump";
- /* Front-end initialization. This hook can assume that GC,
- identifier hashes etc. are set up, but debug initialization is
- not done yet. This routine must return the original filename
- (e.g. foo.i -> foo.c) so can correctly initialize debug output. */
- name = (*lang_hooks.init) (name);
- if (name == NULL)
+ /* Other front-end initialization. */
+ if ((*lang_hooks.init) () == 0)
return 0;
- main_input_filename = input_filename = name;
init_asm_output (name);
/* These create various _DECL nodes, so need to be called after the
init_expr_once ();
expand_dummy_function_end ();
- /* Put an entry on the input file stack for the main input file. */
- push_srcloc (input_filename, 0);
-
/* If dbx symbol table desired, initialize writing it and output the
predefined types. */
timevar_push (TV_SYMOUT);
return 1;
}
-\f
+
/* Clean up: close opened files, etc. */
static void
-finalize ()
+finalize (void)
{
/* Close the dump files. */
if (flag_gen_aux_info)
if (asm_out_file)
{
if (ferror (asm_out_file) != 0)
- fatal_io_error ("error writing to %s", asm_file_name);
+ fatal_error ("error writing to %s: %m", asm_file_name);
if (fclose (asm_out_file) != 0)
- fatal_io_error ("error closing %s", asm_file_name);
+ fatal_error ("error closing %s: %m", asm_file_name);
}
/* Do whatever is necessary to finish printing the graphs. */
/* Language-specific end of compilation actions. */
(*lang_hooks.finish) ();
}
-\f
+
/* Initialize the compiler, and compile the input file. */
static void
-do_compile (no_backend)
- int no_backend;
+do_compile (void)
{
- /* We cannot start timing until after options are processed since that
- says if we run timers or not. */
- init_timevar ();
+ /* Initialize timing first. The C front ends read the main file in
+ the post_options hook, and C++ does file timings. */
+ if (time_report || !quiet_flag || flag_detailed_statistics)
+ timevar_init ();
timevar_start (TV_TOTAL);
- /* Set up the back-end if requested. */
- if (!no_backend)
- backend_init ();
+ process_options ();
+
+ /* Don't do any more if an error has already occurred. */
+ if (!errorcount)
+ {
+ /* Set up the back-end if requested. */
+ if (!no_backend)
+ backend_init ();
- /* Language-dependent initialization. Returns true on success. */
- if (lang_dependent_init (filename))
- compile_file ();
+ /* Language-dependent initialization. Returns true on success. */
+ if (lang_dependent_init (main_input_filename))
+ compile_file ();
- finalize ();
+ finalize ();
+ }
/* Stop timing and print the times. */
timevar_stop (TV_TOTAL);
timevar_print (stderr);
}
-\f
+
/* 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
It is not safe to call this function more than once. */
int
-toplev_main (argc, argv)
- 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);
/* Exit early if we can (e.g. -help). */
if (!exit_after_options)
- {
- /* All command line options have been parsed; allow the front
- end to perform consistency checks, etc. */
- bool no_backend = (*lang_hooks.post_options) ();
-
- /* The bulk of command line switch processing. */
- process_options ();
-
- /* Don't do any more if an error has already occurred. */
- if (!errorcount)
- do_compile (no_backend);
- }
+ do_compile ();
if (errorcount || sorrycount)
return (FATAL_EXIT_CODE);
OSDN Git Service
