/* 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, 2004, 2005, 2006, 2007, 2008
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
This file is part of GCC.
#include "tree-mudflap.h"
#include "tree-pass.h"
#include "gimple.h"
+#include "tree-ssa-alias.h"
+#include "plugin.h"
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
#include "dwarf2out.h"
enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
-/* Set the default algorithm for the integrated register allocator. */
+/* Set the default region and algorithm for the integrated register
+ allocator. */
-enum ira_algorithm flag_ira_algorithm = IRA_ALGORITHM_MIXED;
+enum ira_algorithm flag_ira_algorithm = IRA_ALGORITHM_CB;
+enum ira_region flag_ira_region = IRA_REGION_MIXED;
/* Set the default value for -fira-verbose. */
unsigned int flag_ira_verbose = 5;
+/* Set the default for excess precision. */
+
+enum excess_precision flag_excess_precision_cmdline = EXCESS_PRECISION_DEFAULT;
+enum excess_precision flag_excess_precision = EXCESS_PRECISION_DEFAULT;
+
/* Nonzero means change certain warnings into errors.
Usually these are warnings about failure to conform to some standard. */
the support provided depends on the backend. */
rtx stack_limit_rtx;
-/* Nonzero if we should track variables. When
- flag_var_tracking == AUTODETECT_VALUE it will be set according
- to optimize, debug_info_level and debug_hooks in process_options (). */
+/* Positive if we should track variables, negative if we should run
+ the var-tracking pass only to discard debug annotations, zero if
+ we're not to run it. When flag_var_tracking == AUTODETECT_VALUE it
+ will be set according to optimize, debug_info_level and debug_hooks
+ in process_options (). */
int flag_var_tracking = AUTODETECT_VALUE;
+/* Positive if we should track variables at assignments, negative if
+ we should run the var-tracking pass only to discard debug
+ annotations. When flag_var_tracking_assignments ==
+ AUTODETECT_VALUE it will be set according to flag_var_tracking. */
+int flag_var_tracking_assignments = AUTODETECT_VALUE;
+
+/* Nonzero if we should toggle flag_var_tracking_assignments after
+ processing options and computing its default. */
+int flag_var_tracking_assignments_toggle = 0;
+
/* Type of stack check. */
enum stack_check_type flag_stack_check = NO_STACK_CHECK;
if (!quiet_flag)
{
if (rtl_dump_and_exit)
- fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
+ fprintf (stderr, "%s ",
+ identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl))));
else
- fprintf (stderr, " %s", lang_hooks.decl_printable_name (decl, 2));
+ fprintf (stderr, " %s",
+ identifier_to_locale (lang_hooks.decl_printable_name (decl, 2)));
fflush (stderr);
pp_needs_newline (global_dc->printer) = true;
diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
return atoi (p);
}
-/* When compiling with a recent enough GCC, we use the GNU C "extern inline"
- for floor_log2 and exact_log2; see toplev.h. That construct, however,
- conflicts with the ISO C++ One Definition Rule. */
+#if GCC_VERSION < 3004
-#if GCC_VERSION < 3004 || !defined (__cplusplus)
+/* The functions floor_log2 and exact_log2 are defined as inline
+ functions in toplev.h if GCC_VERSION >= 3004. The definitions here
+ are used for older versions of gcc. */
/* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
If X is 0, return -1. */
if (x == 0)
return -1;
-#ifdef CLZ_HWI
- t = HOST_BITS_PER_WIDE_INT - 1 - (int) CLZ_HWI (x);
-#else
if (HOST_BITS_PER_WIDE_INT > 64)
if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
t += 64;
t += 2;
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
t += 1;
-#endif
return t;
}
{
if (x != (x & -x))
return -1;
-#ifdef CTZ_HWI
- return x ? CTZ_HWI (x) : -1;
-#else
return floor_log2 (x);
-#endif
}
-#endif /* GCC_VERSION < 3004 || !defined (__cplusplus) */
+#endif /* GCC_VERSION < 3004 */
/* Handler for fatal signals, such as SIGSEGV. These are transformed
into ICE messages, which is much more user friendly. In case the
#else
fprintf (asm_file, "\t.file\t");
output_quoted_string (asm_file, na);
- fputc ('\n', asm_file);
+ putc ('\n', asm_file);
#endif
}
/* Warn about a use of an identifier which was marked deprecated. */
void
-warn_deprecated_use (tree node)
+warn_deprecated_use (tree node, tree attr)
{
+ const char *msg;
+
if (node == 0 || !warn_deprecated_decl)
return;
+ if (!attr)
+ {
+ if (DECL_P (node))
+ attr = DECL_ATTRIBUTES (node);
+ else if (TYPE_P (node))
+ {
+ tree decl = TYPE_STUB_DECL (node);
+ if (decl)
+ attr = lookup_attribute ("deprecated",
+ TYPE_ATTRIBUTES (TREE_TYPE (decl)));
+ }
+ }
+
+ if (attr)
+ attr = lookup_attribute ("deprecated", attr);
+
+ if (attr)
+ msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
+ else
+ msg = NULL;
+
if (DECL_P (node))
{
expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
- warning (OPT_Wdeprecated_declarations,
- "%qD is deprecated (declared at %s:%d)",
- node, xloc.file, xloc.line);
+ if (msg)
+ warning (OPT_Wdeprecated_declarations,
+ "%qD is deprecated (declared at %s:%d): %s",
+ node, xloc.file, xloc.line, msg);
+ else
+ warning (OPT_Wdeprecated_declarations,
+ "%qD is deprecated (declared at %s:%d)",
+ node, xloc.file, xloc.line);
}
else if (TYPE_P (node))
{
- const char *what = NULL;
+ tree what = NULL_TREE;
tree decl = TYPE_STUB_DECL (node);
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
- what = IDENTIFIER_POINTER (TYPE_NAME (node));
+ what = TYPE_NAME (node);
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
- what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
+ what = DECL_NAME (TYPE_NAME (node));
}
if (decl)
expanded_location xloc
= expand_location (DECL_SOURCE_LOCATION (decl));
if (what)
- warning (OPT_Wdeprecated_declarations,
- "%qs is deprecated (declared at %s:%d)", what,
- xloc.file, xloc.line);
+ {
+ if (msg)
+ warning (OPT_Wdeprecated_declarations,
+ "%qE is deprecated (declared at %s:%d): %s",
+ what, xloc.file, xloc.line, msg);
+ else
+ warning (OPT_Wdeprecated_declarations,
+ "%qE is deprecated (declared at %s:%d)", what,
+ xloc.file, xloc.line);
+ }
else
- warning (OPT_Wdeprecated_declarations,
- "type is deprecated (declared at %s:%d)",
- xloc.file, xloc.line);
+ {
+ if (msg)
+ warning (OPT_Wdeprecated_declarations,
+ "type is deprecated (declared at %s:%d): %s",
+ xloc.file, xloc.line, msg);
+ else
+ warning (OPT_Wdeprecated_declarations,
+ "type is deprecated (declared at %s:%d)",
+ xloc.file, xloc.line);
+ }
}
else
{
if (what)
- warning (OPT_Wdeprecated_declarations, "%qs is deprecated", what);
+ {
+ if (msg)
+ warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
+ what, msg);
+ else
+ warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
+ }
else
- warning (OPT_Wdeprecated_declarations, "type is deprecated");
+ {
+ if (msg)
+ warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
+ msg);
+ else
+ warning (OPT_Wdeprecated_declarations, "type is deprecated");
+ }
}
}
}
init_final (main_input_filename);
coverage_init (aux_base_name);
statistics_init ();
+ invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
timevar_push (TV_PARSE);
ggc_protect_identifiers = false;
+ /* This must also call cgraph_finalize_compilation_unit. */
lang_hooks.decls.final_write_globals ();
if (errorcount || sorrycount)
varpool_assemble_pending_decls ();
finish_aliases_2 ();
- /* 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 ();
-
/* Likewise for mudflap static object registrations. */
if (flag_mudflap)
mudflap_finish_file ();
}
#endif
+ /* Invoke registered plugin callbacks. */
+ invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
+
/* This must be at the end. Some target ports emit end of file directives
into the assembly file here, and hence we can not output anything to the
assembly file after this point. */
N_("%s%s%s %sversion %s (%s) compiled by CC, ")
#endif
;
+#ifdef HAVE_mpc
+ static const char fmt2[] =
+ N_("GMP version %s, MPFR version %s, MPC version %s\n");
+#else
static const char fmt2[] =
- N_("GMP version %s, MPFR version %s.\n");
+ N_("GMP version %s, MPFR version %s\n");
+#endif
static const char fmt3[] =
N_("%s%swarning: %s header version %s differs from library version %s.\n");
static const char fmt4[] =
indent, __VERSION__);
/* We need to stringify the GMP macro values. Ugh, gmp_version has
- two string formats, "i.j.k" and "i.j" when k is zero. */
+ two string formats, "i.j.k" and "i.j" when k is zero. As of
+ gmp-4.3.0, GMP always uses the 3 number format. */
#define GCC_GMP_STRINGIFY_VERSION3(X) #X
#define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
-#if __GNU_MP_VERSION_PATCHLEVEL == 0
+#define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
+#define GCC_GMP_VERSION \
+ GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
+#if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
#define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
#else
#endif
fprintf (file,
file == stderr ? _(fmt2) : fmt2,
- GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING);
+ GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING
+#ifdef HAVE_mpc
+ , MPC_VERSION_STRING
+#endif
+ );
if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
fprintf (file,
file == stderr ? _(fmt3) : fmt3,
file == stderr ? _(fmt3) : fmt3,
indent, *indent != 0 ? " " : "",
"MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
+#ifdef HAVE_mpc
+ if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
+ fprintf (file,
+ file == stderr ? _(fmt3) : fmt3,
+ indent, *indent != 0 ? " " : "",
+ "MPC", MPC_VERSION_STRING, mpc_get_version ());
+#endif
fprintf (file,
file == stderr ? _(fmt4) : fmt4,
indent, *indent != 0 ? " " : "",
PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
+
+ print_plugins_versions (file, indent);
}
#ifdef ASM_COMMENT_START
case SWITCH_TYPE_ENABLED:
if (prepend_sep)
fputc (' ', asm_out_file);
- fprintf (asm_out_file, text);
+ fputs (text, asm_out_file);
/* No need to return the length here as
print_single_switch has already done it. */
return 0;
/* Drop through. */
case SWITCH_TYPE_DESCRIPTIVE:
- fprintf (stderr, text);
+ fputs (text, stderr);
/* No need to return the length here as
print_single_switch has already done it. */
return 0;
into the assembler file as comments. */
print_version (asm_out_file, ASM_COMMENT_START);
print_switch_values (print_to_asm_out_file);
- fprintf (asm_out_file, "\n");
+ putc ('\n', asm_out_file);
}
#endif
}
}
/* Default tree printer. Handles declarations only. */
-static bool
-default_tree_printer (pretty_printer * pp, text_info *text, const char *spec,
+bool
+default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
int precision, bool wide, bool set_locus, bool hash)
{
tree t;
switch (*spec)
{
+ case 'E':
+ t = va_arg (*text->args_ptr, tree);
+ if (TREE_CODE (t) == IDENTIFIER_NODE)
+ {
+ pp_identifier (pp, IDENTIFIER_POINTER (t));
+ return true;
+ }
+ break;
+
case 'D':
t = va_arg (*text->args_ptr, tree);
if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
if (DECL_P (t))
{
const char *n = DECL_NAME (t)
- ? lang_hooks.decl_printable_name (t, 2)
- : "<anonymous>";
+ ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
+ : _("<anonymous>");
pp_string (pp, n);
}
else
if (warn_unused_value == -1)
warn_unused_value = warn_unused;
+ /* This replaces set_Wextra. */
+ if (warn_uninitialized == -1)
+ warn_uninitialized = extra_warnings;
+
/* 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)
|| flag_loop_block
|| flag_loop_interchange
|| flag_loop_strip_mine
- || flag_graphite_identity)
+ || flag_graphite_identity
+ || flag_loop_parallelize_all)
sorry ("Graphite loop optimizations cannot be used");
#endif
profile_flag = 0;
}
+ if (flag_gtoggle)
+ {
+ if (debug_info_level == DINFO_LEVEL_NONE)
+ {
+ debug_info_level = DINFO_LEVEL_NORMAL;
+
+ if (write_symbols == NO_DEBUG)
+ write_symbols = PREFERRED_DEBUGGING_TYPE;
+ }
+ else
+ debug_info_level = DINFO_LEVEL_NONE;
+ }
+
+ if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
+ {
+ FILE *final_output = fopen (flag_dump_final_insns, "w");
+ if (!final_output)
+ {
+ error ("could not open final insn dump file %qs: %s",
+ flag_dump_final_insns, strerror (errno));
+ flag_dump_final_insns = NULL;
+ }
+ else if (fclose (final_output))
+ {
+ error ("could not close zeroed insn dump file %qs: %s",
+ flag_dump_final_insns, strerror (errno));
+ flag_dump_final_insns = NULL;
+ }
+ }
+
/* A lot of code assumes write_symbols == NO_DEBUG if the debugging
level is 0. */
if (debug_info_level == DINFO_LEVEL_NONE)
flag_var_tracking_uninit = 0;
}
- if (flag_rename_registers == AUTODETECT_VALUE)
- flag_rename_registers = default_debug_hooks->var_location
- != do_nothing_debug_hooks.var_location;
+ /* If the user specifically requested variable tracking with tagging
+ uninitialized variables, we need to turn on variable tracking.
+ (We already determined above that variable tracking is feasible.) */
+ if (flag_var_tracking_uninit)
+ flag_var_tracking = 1;
if (flag_var_tracking == AUTODETECT_VALUE)
flag_var_tracking = optimize >= 1;
+ if (flag_var_tracking_assignments == AUTODETECT_VALUE)
+ flag_var_tracking_assignments = flag_var_tracking
+ && !(flag_selective_scheduling || flag_selective_scheduling2);
+
+ if (flag_var_tracking_assignments_toggle)
+ flag_var_tracking_assignments = !flag_var_tracking_assignments;
+
+ if (flag_var_tracking_assignments && !flag_var_tracking)
+ flag_var_tracking = flag_var_tracking_assignments = -1;
+
+ if (flag_var_tracking_assignments
+ && (flag_selective_scheduling || flag_selective_scheduling2))
+ warning (0, "var-tracking-assignments changes selective scheduling");
+
+ if (flag_rename_registers == AUTODETECT_VALUE)
+ flag_rename_registers = default_debug_hooks->var_location
+ != do_nothing_debug_hooks.var_location;
+
if (flag_tree_cselim == AUTODETECT_VALUE)
#ifdef HAVE_conditional_move
flag_tree_cselim = 1;
flag_tree_cselim = 0;
#endif
- /* If the user specifically requested variable tracking with tagging
- uninitialized variables, we need to turn on variable tracking.
- (We already determined above that variable tracking is feasible.) */
- if (flag_var_tracking_uninit)
- flag_var_tracking = 1;
-
/* If auxiliary info generation is desired, open the output file.
This goes in the same directory as the source file--unlike
all the other output files. */
if (flag_signaling_nans)
flag_trapping_math = 1;
- /* We cannot reassociate if we want traps or signed zeros. */
+ /* We cannot reassociate if we want traps or signed zeros. */
if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
{
warning (0, "-fassociative-math disabled; other options take precedence");
backend_init_target ();
}
+/* Initialize excess precision settings. */
+static void
+init_excess_precision (void)
+{
+ /* Adjust excess precision handling based on the target options. If
+ the front end cannot handle it, flag_excess_precision_cmdline
+ will already have been set accordingly in the post_options
+ hook. */
+ gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
+ flag_excess_precision = flag_excess_precision_cmdline;
+ if (flag_unsafe_math_optimizations)
+ flag_excess_precision = EXCESS_PRECISION_FAST;
+ if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
+ {
+ int flt_eval_method = TARGET_FLT_EVAL_METHOD;
+ switch (flt_eval_method)
+ {
+ case -1:
+ case 0:
+ /* Either the target acts unpredictably (-1) or has all the
+ operations required not to have excess precision (0). */
+ flag_excess_precision = EXCESS_PRECISION_FAST;
+ break;
+ case 1:
+ case 2:
+ /* In these cases, predictable excess precision makes
+ sense. */
+ break;
+ default:
+ /* Any other implementation-defined FLT_EVAL_METHOD values
+ require the compiler to handle the associated excess
+ precision rules in excess_precision_type. */
+ gcc_unreachable ();
+ }
+ }
+}
+
/* Initialize things that are both lang-dependent and target-dependent.
This function can be called more than once if target parameters change. */
static void
lang_dependent_init_target (void)
{
+ /* This determines excess precision settings. */
+ init_excess_precision ();
+
/* This creates various _DECL nodes, so needs to be called after the
front end is initialized. It also depends on the HAVE_xxx macros
generated from the target machine description. */
dump_bitmap_statistics ();
dump_vec_loc_statistics ();
dump_ggc_loc_statistics (final);
+ dump_alias_stats (stderr);
+ dump_pta_stats (stderr);
}
/* Clean up: close opened files, etc. */
It is not safe to call this function more than once. */
int
-toplev_main (unsigned int argc, const char **argv)
+toplev_main (int argc, char **argv)
{
- save_argv = argv;
+ expandargv (&argc, &argv);
+
+ save_argv = CONST_CAST2 (const char **, char **, 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. */
- decode_options (argc, argv);
+ decode_options (argc, CONST_CAST2 (const char **, char **, argv));
init_local_tick ();
+ initialize_plugins ();
+
+ if (version_flag)
+ print_version (stderr, "");
+
+ if (help_flag)
+ print_plugins_help (stderr, "");
+
/* Exit early if we can (e.g. -help). */
if (!exit_after_options)
do_compile ();
if (warningcount || errorcount)
print_ignored_options ();
+ /* Invoke registered plugin callbacks if any. */
+ invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
+
+ finalize_plugins ();
if (errorcount || sorrycount)
return (FATAL_EXIT_CODE);
OSDN Git Service
