#undef FFS /* Some systems define this in param.h. */
#include "system.h"
#include <signal.h>
-#include <setjmp.h>
#ifdef HAVE_SYS_RESOURCE_H
# include <sys/resource.h>
#include "halfpic.h"
#endif
\f
-#ifdef VMS
-/* The extra parameters substantially improve the I/O performance. */
-
-static FILE *
-vms_fopen (fname, type)
- char *fname;
- char *type;
-{
- /* The <stdio.h> in the gcc-vms-1.42 distribution prototypes fopen with two
- fixed arguments, which matches ANSI's specification but not VAXCRTL's
- pre-ANSI implementation. This hack circumvents the mismatch problem. */
- FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
-
- if (*type == 'w')
- return (*vmslib_fopen) (fname, type, "mbc=32",
- "deq=64", "fop=tef", "shr=nil");
- else
- return (*vmslib_fopen) (fname, type, "mbc=32");
-}
-
-#define fopen vms_fopen
-#endif /* VMS */
-
/* Carry information from ASM_DECLARE_OBJECT_NAME
to ASM_FINISH_DECLARE_OBJECT. */
static void finalize PARAMS ((void));
static void set_target_switch PARAMS ((const char *));
-static const char *decl_name PARAMS ((tree, int));
-static void float_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
static void crash_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
-static void set_float_handler PARAMS ((jmp_buf));
static void compile_file PARAMS ((void));
static void display_help PARAMS ((void));
static void display_target_options PARAMS ((void));
static void print_switch_values PARAMS ((FILE *, int, int, const char *,
const char *, const char *));
+/* Nonzero to dump debug info whilst parsing (-dy option). */
+static int set_yydebug;
+
/* Length of line when printing switch values. */
#define MAX_LINE 75
/* Debug hooks - dependent upon command line options. */
-struct gcc_debug_hooks *debug_hooks = &do_nothing_debug_hooks;
+const struct gcc_debug_hooks *debug_hooks = &do_nothing_debug_hooks;
/* Describes a dump file. */
if none. */
tree current_function_func_begin_label;
-/* Pointer to function to compute the name to use to print a declaration.
- DECL is the declaration in question.
- VERBOSITY determines what information will be printed:
- 0: DECL_NAME, demangled as necessary.
- 1: and scope information.
- 2: and any other information that might be interesting, such as function
- parameter types in C++. */
-
-const char *(*decl_printable_name) PARAMS ((tree, int));
-
-/* Pointer to function to compute rtl for a language-specific tree code. */
-
-typedef rtx (*lang_expand_expr_t)
- PARAMS ((union tree_node *, rtx, enum machine_mode,
- enum expand_modifier modifier));
-
-lang_expand_expr_t lang_expand_expr = 0;
-
-/* Pointer to function to finish handling an incomplete decl at the
- end of compilation. */
-
-void (*incomplete_decl_finalize_hook) PARAMS ((tree)) = 0;
-
/* Nonzero if doing dwarf2 duplicate elimination. */
int flag_eliminate_dwarf2_dups = 0;
int profile_arc_flag = 0;
+/* Nonzero if we should not attempt to generate thread-safe
+ code to profile program flow graph arcs. */
+
+int flag_unsafe_profile_arcs = 0;
+
/* Nonzero if generating info for gcov to calculate line test coverage. */
int flag_test_coverage = 0;
int flag_reorder_blocks = 0;
+/* Nonzero if functions should be reordered. */
+
+int flag_reorder_functions = 0;
+
/* Nonzero if registers should be renamed. */
int flag_rename_registers = 0;
static int flag_gcse;
+/* Nonzero means perform loop optimizer. */
+
+static int flag_loop_optimize;
+
+/* Nonzero means perform crossjumping. */
+
+static int flag_crossjumping;
+
+/* Nonzero means perform if conversion. */
+
+static int flag_if_conversion;
+
+/* Nonzero means perform if conversion after reload. */
+
+static int flag_if_conversion2;
+
/* Nonzero means to use global dataflow analysis to eliminate
useless null pointer tests. */
/* Nonzero means that functions will not be inlined. */
-int flag_no_inline;
+int flag_no_inline = 2;
+
+/* Nonzero means that we don't want inlining by virtue of -fno-inline,
+ not just because the tree inliner turned us off. */
+
+int flag_really_no_inline = 2;
/* Nonzero means that we should emit static const variables
regardless of whether or not optimization is turned on. */
#ifdef SDB_DEBUGGING_INFO
{ "coff", SDB_DEBUG, 0, N_("Generate COFF format debug info") },
#endif
+#ifdef VMS_DEBUGGING_INFO
+ { "vms", VMS_DEBUG, 0, N_("Generate VMS format debug info") },
+#endif
{ 0, 0, 0, 0 }
};
N_("Perform enhanced load motion during global subexpression elimination") },
{"gcse-sm", &flag_gcse_sm, 1,
N_("Perform store motion after global subexpression elimination") },
+ {"loop-optimize", &flag_loop_optimize, 1,
+ N_("Perform the loop optimizations") },
+ {"crossjumping", &flag_crossjumping, 1,
+ N_("Perform cross-jumping optimization") },
+ {"if-conversion", &flag_if_conversion, 1,
+ N_("Perform conversion of conditional jumps to branchless equivalents") },
+ {"if-conversion2", &flag_if_conversion2, 1,
+ N_("Perform conversion of conditional jumps to conditional execution") },
{"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
N_("Run CSE pass after loop optimizations") },
{"rerun-loop-opt", &flag_rerun_loop_opt, 1,
N_("Support synchronous non-call exceptions") },
{"profile-arcs", &profile_arc_flag, 1,
N_("Insert arc based program profiling code") },
+ {"unsafe-profile-arcs", &flag_unsafe_profile_arcs, 1,
+ N_("Avoid thread safety profiling overhead") },
{"test-coverage", &flag_test_coverage, 1,
N_("Create data files needed by gcov") },
{"branch-probabilities", &flag_branch_probabilities, 1,
N_("Use profiling information for branch probabilities") },
+ {"profile", &profile_flag, 1,
+ N_("Enable basic program profiling code") },
{"reorder-blocks", &flag_reorder_blocks, 1,
N_("Reorder basic blocks to improve code placement") },
+ {"reorder-functions", &flag_reorder_functions, 1,
+ N_("Reorder functions to improve code placement") },
{"rename-registers", &flag_rename_registers, 1,
N_("Do the register renaming optimization pass") },
{"cprop-registers", &flag_cprop_registers, 1,
used here is to only describe those options which are not
enabled by default. */
- { "-ansi",
+ { "-ansi",
N_("Compile just for ISO C89") },
- { "-std= ",
+ { "-std= ",
N_("Determine language standard") },
{ "-fsigned-bitfields", "" },
N_("Make bit-fields by unsigned by default") },
{ "-fno-signed-bitfields", "" },
{ "-fno-unsigned-bitfields","" },
- { "-fsigned-char",
+ { "-fsigned-char",
N_("Make 'char' be signed by default") },
- { "-funsigned-char",
+ { "-funsigned-char",
N_("Make 'char' be unsigned by default") },
{ "-fno-signed-char", "" },
{ "-fno-unsigned-char", "" },
{ "-fasm", "" },
- { "-fno-asm",
+ { "-fno-asm",
N_("Do not recognize the 'asm' keyword") },
{ "-fbuiltin", "" },
- { "-fno-builtin",
+ { "-fno-builtin",
N_("Do not recognize any built in functions") },
- { "-fhosted",
+ { "-fhosted",
N_("Assume normal C execution environment") },
{ "-fno-hosted", "" },
{ "-ffreestanding",
N_("Assume that standard libraries & main might not exist") },
{ "-fno-freestanding", "" },
- { "-fcond-mismatch",
+ { "-fcond-mismatch",
N_("Allow different types as args of ? operator") },
{ "-fno-cond-mismatch", "" },
- { "-fdollars-in-identifiers",
+ { "-fdollars-in-identifiers",
N_("Allow the use of $ inside identifiers") },
{ "-fno-dollars-in-identifiers", "" },
{ "-fpreprocessed", "" },
{ "-fno-preprocessed", "" },
- { "-fshort-double",
+ { "-fshort-double",
N_("Use the same size for double as for float") },
{ "-fno-short-double", "" },
- { "-fshort-enums",
+ { "-fshort-enums",
N_("Use the smallest fitting integer to hold enums") },
{ "-fno-short-enums", "" },
- { "-fshort-wchar",
+ { "-fshort-wchar",
N_("Override the underlying type for wchar_t to `unsigned short'") },
{ "-fno-short-wchar", "" },
- { "-Wall",
+ { "-Wall",
N_("Enable most warning messages") },
{ "-Wbad-function-cast",
N_("Warn about casting functions to incompatible types") },
{ "-Wmissing-format-attribute",
N_("Warn about functions which might be candidates for format attributes") },
{ "-Wno-missing-format-attribute", "" },
- { "-Wcast-qual",
+ { "-Wcast-qual",
N_("Warn about casts which discard qualifiers") },
{ "-Wno-cast-qual", "" },
- { "-Wchar-subscripts",
+ { "-Wchar-subscripts",
N_("Warn about subscripts whose type is 'char'") },
{ "-Wno-char-subscripts", "" },
- { "-Wcomment",
+ { "-Wcomment",
N_("Warn if nested comments are detected") },
{ "-Wno-comment", "" },
- { "-Wcomments",
+ { "-Wcomments",
N_("Warn if nested comments are detected") },
{ "-Wno-comments", "" },
- { "-Wconversion",
+ { "-Wconversion",
N_("Warn about possibly confusing type conversions") },
{ "-Wno-conversion", "" },
{ "-Wdiv-by-zero", "" },
- { "-Wno-div-by-zero",
+ { "-Wno-div-by-zero",
N_("Do not warn about compile-time integer division by zero") },
- { "-Wfloat-equal",
+ { "-Wfloat-equal",
N_("Warn about testing equality of floating point numbers") },
{ "-Wno-float-equal", "" },
- { "-Wformat",
+ { "-Wformat",
N_("Warn about printf/scanf/strftime/strfmon format anomalies") },
{ "-Wno-format", "" },
{ "-Wformat-extra-args", "" },
{ "-Wno-format-extra-args",
N_("Don't warn about too many arguments to format functions") },
- { "-Wformat-nonliteral",
+ { "-Wformat-nonliteral",
N_("Warn about non-string-literal format strings") },
{ "-Wno-format-nonliteral", "" },
{ "-Wformat-security",
N_("Warn about implicit function declarations") },
{ "-Wno-implicit-function-declaration", "" },
{ "-Werror-implicit-function-declaration", "" },
- { "-Wimplicit-int",
+ { "-Wimplicit-int",
N_("Warn when a declaration does not specify a type") },
{ "-Wno-implicit-int", "" },
{ "-Wimplicit", "" },
{ "-Wno-implicit", "" },
- { "-Wimport",
+ { "-Wimport",
N_("Warn about the use of the #import directive") },
{ "-Wno-import", "" },
{ "-Wlong-long","" },
- { "-Wno-long-long",
+ { "-Wno-long-long",
N_("Do not warn about using 'long long' when -pedantic") },
- { "-Wmain",
+ { "-Wmain",
N_("Warn about suspicious declarations of main") },
{ "-Wno-main", "" },
{ "-Wmissing-braces",
{ "-Wmissing-declarations",
N_("Warn about global funcs without previous declarations") },
{ "-Wno-missing-declarations", "" },
- { "-Wmissing-prototypes",
+ { "-Wmissing-prototypes",
N_("Warn about global funcs without prototypes") },
{ "-Wno-missing-prototypes", "" },
- { "-Wmultichar",
+ { "-Wmultichar",
N_("Warn about use of multicharacter literals") },
{ "-Wno-multichar", "" },
- { "-Wnested-externs",
+ { "-Wnested-externs",
N_("Warn about externs not at file scope level") },
{ "-Wno-nested-externs", "" },
- { "-Wparentheses",
+ { "-Wparentheses",
N_("Warn about possible missing parentheses") },
{ "-Wno-parentheses", "" },
- { "-Wpointer-arith",
+ { "-Wpointer-arith",
N_("Warn about function pointer arithmetic") },
{ "-Wno-pointer-arith", "" },
{ "-Wredundant-decls",
{ "-Wsequence-point",
N_("Warn about possible violations of sequence point rules") },
{ "-Wno-sequence-point", "" },
- { "-Wsign-compare",
+ { "-Wsign-compare",
N_("Warn about signed/unsigned comparisons") },
{ "-Wno-sign-compare", "" },
- { "-Wstrict-prototypes",
+ { "-Wstrict-prototypes",
N_("Warn about non-prototyped function decls") },
{ "-Wno-strict-prototypes", "" },
- { "-Wtraditional",
+ { "-Wtraditional",
N_("Warn about constructs whose meanings change in ISO C") },
{ "-Wno-traditional", "" },
- { "-Wtrigraphs",
+ { "-Wtrigraphs",
N_("Warn when trigraphs are encountered") },
{ "-Wno-trigraphs", "" },
{ "-Wundef", "" },
{ "-Wno-undef", "" },
- { "-Wunknown-pragmas",
+ { "-Wunknown-pragmas",
N_("Warn about unrecognized pragmas") },
{ "-Wno-unknown-pragmas", "" },
- { "-Wwrite-strings",
+ { "-Wwrite-strings",
N_("Mark strings as 'const char *'") },
{ "-Wno-write-strings", "" },
const int value;
const char *const description;
}
-target_switches [] = TARGET_SWITCHES;
+target_switches[] = TARGET_SWITCHES;
/* This table is similar, but allows the switch to have a value. */
const char **const variable;
const char *const description;
}
-target_options [] = TARGET_OPTIONS;
+target_options[] = TARGET_OPTIONS;
#endif
\f
/* Options controlling warnings. */
int warn_shadow;
-/* Warn if a switch on an enum fails to have a case for every enum value. */
+/* Warn if a switch on an enum, that does not have a default case,
+ fails to have a case for every enum value. */
int warn_switch;
+/* Warn if a switch does not have a default case. */
+
+int warn_switch_default;
+
+/* Warn if a switch on an enum fails to have a case for every enum
+ value (regardless of the presence or otherwise of a default case). */
+
+int warn_switch_enum;
+
/* Nonzero means warn about function definitions that default the return type
or that use a null return and have a return-type other than void. */
int warn_missing_noreturn;
-/* Nonzero means warn about uses of __attribute__((deprecated))
+/* Nonzero means warn about uses of __attribute__((deprecated))
declarations. */
int warn_deprecated_decl = 1;
{"shadow", &warn_shadow, 1,
N_("Warn when one local variable shadows another") },
{"switch", &warn_switch, 1,
- N_("Warn about enumerated switches missing a specific case") },
+ N_("Warn about enumerated switches, with no default, missing a case") },
+ {"switch-default", &warn_switch_default, 1,
+ N_("Warn about enumerated switches missing a default case") },
+ {"switch-enum", &warn_switch_enum, 1,
+ N_("Warn about all enumerated switches missing a specific case") },
{"aggregate-return", &warn_aggregate_return, 1,
N_("Warn about returning structures, unions or arrays") },
{"cast-align", &warn_cast_align, 1,
-ffast-math and -fno-fast-math imply. */
void
-set_fast_math_flags ()
+set_fast_math_flags (int set)
{
- flag_trapping_math = 0;
- flag_unsafe_math_optimizations = 1;
- flag_errno_math = 0;
+ flag_trapping_math = !set;
+ flag_unsafe_math_optimizations = set;
+ flag_errno_math = !set;
}
-void
-set_no_fast_math_flags ()
+/* Return true iff flags are set as if -ffast-math. */
+bool
+fast_math_flags_set_p ()
{
- flag_trapping_math = 1;
- flag_unsafe_math_optimizations = 0;
- flag_errno_math = 1;
+ return (!flag_trapping_math
+ && flag_unsafe_math_optimizations
+ && !flag_errno_math);
}
\f
return atoi (p);
}
-
-\f
-/* This is the default decl_printable_name function. */
-
-static const char *
-decl_name (decl, verbosity)
- tree decl;
- int verbosity ATTRIBUTE_UNUSED;
-{
- return IDENTIFIER_POINTER (DECL_NAME (decl));
-}
\f
-
/* This calls abort and is used to avoid problems when abort if a macro.
It is used when we need to pass the address of abort. */
return log;
}
-static int float_handler_set;
-int float_handled;
-jmp_buf float_handler;
-
-/* Signals actually come here. */
-
-static void
-float_signal (signo)
- /* If this is missing, some compilers complain. */
- int signo ATTRIBUTE_UNUSED;
-{
- if (float_handled == 0)
- crash_signal (signo);
- float_handled = 0;
-
- /* On System-V derived systems, we must reinstall the signal handler.
- This is harmless on BSD-derived systems. */
- signal (SIGFPE, float_signal);
- longjmp (float_handler, 1);
-}
-
-/* Specify where to longjmp to when a floating arithmetic error happens.
- If HANDLER is 0, it means don't handle the errors any more. */
-
-static void
-set_float_handler (handler)
- jmp_buf handler;
-{
- float_handled = (handler != 0);
- if (handler)
- memcpy (float_handler, handler, sizeof (float_handler));
-
- if (float_handled && ! float_handler_set)
- {
- signal (SIGFPE, float_signal);
- float_handler_set = 1;
- }
-}
-
-/* This is a wrapper function for code which might elicit an
- arithmetic exception. That code should be passed in as a function
- pointer FN, and one argument DATA. DATA is usually a struct which
- contains the real input and output for function FN. This function
- returns 0 (failure) if longjmp was called (i.e. an exception
- occurred.) It returns 1 (success) otherwise. */
-
-int
-do_float_handler (fn, data)
- void (*fn) PARAMS ((PTR));
- PTR data;
-{
- jmp_buf buf;
-
- if (setjmp (buf))
- {
- /* We got here via longjmp () caused by an exception in function
- fn (). */
- set_float_handler (NULL);
- return 0;
- }
-
- set_float_handler (buf);
- (*fn)(data);
- set_float_handler (NULL);
- return 1;
-}
-
/* Handler for fatal signals, such as SIGSEGV. These are transformed
into ICE messages, which is much more user friendly. */
int len;
{
int i;
- for (i = 2; i < 6 && len > i; i++)
+ for (i = 2; i < 6 && len > i; i++)
{
if (name[len - i] == '.')
{
while (na > input_name)
{
if (IS_DIR_SEPARATOR (na[-1]))
- break;
+ break;
na--;
}
if (decl)
fprintf (rtl_dump_file, "\n;; Function %s\n\n",
- decl_printable_name (decl, 2));
+ (*lang_hooks.decl_printable_name) (decl, 2));
timevar_pop (TV_DUMP);
return 1;
/* We're not deferring this any longer. */
DECL_DEFER_OUTPUT (decl) = 0;
- if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0
- && incomplete_decl_finalize_hook != 0)
- (*incomplete_decl_finalize_hook) (decl);
+ if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
+ (*lang_hooks.finish_incomplete_decl) (decl);
}
/* Now emit any global variables or functions that we have been
to force a constant to be written if and only if it is
defined in a main file, as opposed to an include file. */
- if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
- && (((! TREE_READONLY (decl) || TREE_PUBLIC (decl))
- && !DECL_COMDAT (decl))
- || (!optimize
- && flag_keep_static_consts
- && !DECL_ARTIFICIAL (decl))
- || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
+ if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
{
- reconsider = 1;
- rest_of_decl_compilation (decl, NULL, 1, 1);
+ bool needed = 1;
+
+ if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
+ /* needed */;
+ else if (DECL_COMDAT (decl))
+ needed = 0;
+ else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
+ && (optimize || !flag_keep_static_consts
+ || DECL_ARTIFICIAL (decl)))
+ needed = 0;
+
+ if (needed)
+ {
+ reconsider = 1;
+ rest_of_decl_compilation (decl, NULL, 1, 1);
+ }
}
if (TREE_CODE (decl) == FUNCTION_DECL
assemble_external (decl);
}
- /* Warn about static fns or vars defined but not used,
- but not about inline functions or static consts
- since defining those in header files is normal practice. */
- if (((warn_unused_function
- && TREE_CODE (decl) == FUNCTION_DECL && ! DECL_INLINE (decl))
- || (warn_unused_variable
- && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
- && ! DECL_IN_SYSTEM_HEADER (decl)
+ /* Warn about static fns or vars defined but not used. */
+ if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
+ || (warn_unused_variable && TREE_CODE (decl) == VAR_DECL))
+ && ! TREE_USED (decl)
+ /* The TREE_USED bit for file-scope decls is kept in the identifier,
+ to handle multiple external decls in different scopes. */
+ && ! TREE_USED (DECL_NAME (decl))
&& ! DECL_EXTERNAL (decl)
&& ! TREE_PUBLIC (decl)
- && ! TREE_USED (decl)
- && (TREE_CODE (decl) == FUNCTION_DECL || ! DECL_REGISTER (decl))
- /* The TREE_USED bit for file-scope decls
- is kept in the identifier, to handle multiple
- external decls in different scopes. */
- && ! TREE_USED (DECL_NAME (decl)))
+ /* Global register variables must be declared to reserve them. */
+ && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
+ /* Otherwise, ask the language. */
+ && (*lang_hooks.decls.warn_unused_global) (decl))
warning_with_decl (decl, "`%s' defined but not used");
timevar_push (TV_SYMOUT);
timevar_push (TV_PARSE);
- /* Call the parser, which parses the entire file
- (calling rest_of_compilation for each function). */
- yyparse ();
+ /* Call the parser, which parses the entire file (calling
+ rest_of_compilation for each function). */
+ (*lang_hooks.parse_file) (set_yydebug);
/* In case there were missing block closers,
get us back to the global binding level. */
/* Compilation is now finished except for writing
what's left of the symbol table output. */
-
timevar_pop (TV_PARSE);
if (flag_syntax_only)
return;
- globals = getdecls ();
+ globals = (*lang_hooks.decls.getdecls) ();
/* Really define vars that have had only a tentative definition.
Really output inline functions that must actually be callable
{
alias = TREE_VALUE (TREE_VALUE (alias));
alias = get_identifier (TREE_STRING_POINTER (alias));
- assemble_alias (decl, alias);
+ assemble_alias (decl, alias);
}
}
timevar_push (TV_VARCONST);
if (asmspec)
- make_decl_rtl (decl, asmspec);
+ make_decl_rtl (decl, asmspec);
/* Don't output anything when a tentative file-scope definition
is seen. But at end of compilation, do output code for them. */
timevar_pop (TV_SYMOUT);
}
-/* This is called from finish_function (within yyparse)
+/* 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.
if (inlinable
|| (DECL_INLINE (decl)
&& ((! 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;
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
+ 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 ());
- emit_initial_value_sets ();
- /* Don't return yet if -Wreturn-type; we need to do cleanup_cfg. */
- if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
+ /* 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 ();
+
+ /* Turn NOTE_INSN_PREDICTIONs into branch predictions. */
+ note_prediction_to_br_prob ();
+
/* We may have potential sibling or tail recursion sites. Select one
(of possibly multiple) methods of performing the call. */
if (flag_optimize_sibling_calls)
{
- timevar_push (TV_JUMP);
- open_dump_file (DFI_sibling, decl);
-
+ rtx insn;
optimize_sibling_and_tail_recursive_calls ();
- close_dump_file (DFI_sibling, print_rtl, get_insns ());
- timevar_pop (TV_JUMP);
+ /* 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.
+
+ 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);
/* Complete generation of exception handling code. */
find_exception_handler_labels ();
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.
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
- cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP);
+ cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
+ | (flag_thread_jumps ? CLEANUP_THREADING : 0));
/* CFG is no longer maintained up-to-date. */
free_bb_for_insn ();
open_dump_file (DFI_ssa_dce, decl);
insns = get_insns ();
- ssa_eliminate_dead_code();
+ ssa_eliminate_dead_code ();
close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
timevar_pop (TV_SSA_DCE);
timevar_push (TV_JUMP);
- if (optimize > 0)
+ if (flag_delete_null_pointer_checks || flag_if_conversion)
{
open_dump_file (DFI_null, decl);
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP
- | (flag_thread_jumps ? CLEANUP_THREADING : 0));
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
/* Try to identify useless null pointer tests and delete them. */
if (flag_delete_null_pointer_checks)
delete_null_pointer_checks (insns);
timevar_push (TV_IFCVT);
- if_convert (0);
+ if (flag_if_conversion)
+ if_convert (0);
timevar_pop (TV_IFCVT);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
close_dump_file (DFI_null, print_rtl_with_bb, insns);
rebuild_jump_labels (insns);
purge_all_dead_edges (0);
+ delete_trivially_dead_insns (insns, max_reg_num ());
+
/* 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;
if (tem || optimize > 1)
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
-
- /* Run this after jump optmizations remove all the unreachable code
- so that unreachable code will not keep values live. */
- delete_trivially_dead_insns (insns, max_reg_num ());
-
/* Try to identify useless null pointer tests and delete them. */
if (flag_delete_null_pointer_checks || flag_thread_jumps)
{
timevar_push (TV_JUMP);
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP
- | (flag_thread_jumps ? CLEANUP_THREADING : 0));
-
if (flag_delete_null_pointer_checks)
delete_null_pointer_checks (insns);
/* CFG is no longer maintained up-to-date. */
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
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;
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;
}
tem = tem2 = 0;
timevar_push (TV_JUMP);
rebuild_jump_labels (insns);
- delete_trivially_dead_insns (insns, max_reg_num ());
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
timevar_pop (TV_JUMP);
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);
}
}
/* Move constant computations out of loops. */
- if (optimize > 0)
+ if (optimize > 0 && flag_loop_optimize)
{
timevar_push (TV_LOOP);
delete_dead_jumptables ();
cleanup_barriers ();
/* We only want to perform unrolling once. */
-
- loop_optimize (insns, rtl_dump_file, 0);
+ loop_optimize (insns, rtl_dump_file, LOOP_FIRST_PASS);
/* The first call to loop_optimize makes some instructions
trivially dead. We delete those instructions now in the
life_analyzis rarely eliminates modification of external memory.
*/
- mark_constant_function ();
+ if (optimize)
+ mark_constant_function ();
close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
/* Do branch profiling and static profile estimation passes. */
- if (optimize > 0 || profile_arc_flag || flag_test_coverage
- || flag_branch_probabilities)
+ if (optimize > 0 || cfun->arc_profile || flag_branch_probabilities)
{
struct loops loops;
timevar_push (TV_BRANCH_PROB);
open_dump_file (DFI_bp, decl);
- if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
+ if (cfun->arc_profile || flag_branch_probabilities)
branch_prob ();
/* Discover and record the loop depth at the head of each basic
timevar_push (TV_IFCVT);
cleanup_cfg (CLEANUP_EXPENSIVE);
- if_convert (0);
- timevar_pop(TV_IFCVT);
+ if (flag_if_conversion)
+ if_convert (0);
+ timevar_pop (TV_IFCVT);
timevar_pop (TV_JUMP);
/* CFG is no longer maintained up-to-date. */
reg_scan (insns, max_reg_num (), 0);
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)
{
cse_not_expected = 1;
- close_dump_file (DFI_life, print_rtl_with_bb, insns);
+ open_dump_file (DFI_life, decl);
regclass_init ();
check_function_return_warnings ();
#endif
life_analysis (insns, rtl_dump_file, PROP_FINAL);
if (optimize)
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
+ cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_UPDATE_LIFE
+ | (flag_thread_jumps ? CLEANUP_THREADING : 0));
timevar_pop (TV_FLOW);
no_new_pseudos = 1;
rebuild_jump_labels_after_combine
= combine_instructions (insns, max_reg_num ());
- /* Always purge dead edges, as we may eliminate an insn throwing
- exception. */
- rebuild_jump_labels_after_combine |= purge_all_dead_edges (true);
-
/* Combining insns may have turned an indirect jump into a
direct jump. Rebuid the JUMP_LABEL fields of jumping
instructions. */
/* Rerun if-conversion, as combine may have simplified things enough to
now meet sequence length restrictions. */
- if (optimize > 0)
+ if (flag_if_conversion)
{
timevar_push (TV_IFCVT);
open_dump_file (DFI_ce, decl);
timevar_push (TV_JUMP);
rebuild_jump_labels (insns);
+ purge_all_dead_edges (0);
timevar_pop (TV_JUMP);
}
if (optimize)
{
- cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_CROSSJUMP);
life_analysis (insns, rtl_dump_file, PROP_FINAL);
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE
+ | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
/* This is kind of a heuristic. We need to run combine_stack_adjustments
even for machines with possibly nonzero RETURN_POPS_ARGS
}
#endif
- if (flag_rename_registers || flag_cprop_registers)
+ 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 ();
+ regrename_optimize ();
if (flag_cprop_registers)
- copyprop_hardreg_forward ();
+ copyprop_hardreg_forward ();
close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
timevar_pop (TV_RENAME_REGISTERS);
}
- if (optimize > 0)
+ if (flag_if_conversion2)
{
timevar_push (TV_IFCVT2);
open_dump_file (DFI_ce2, decl);
timevar_push (TV_REORDER_BLOCKS);
open_dump_file (DFI_bbro, decl);
- /* Last attempt to optimize CFG, as life analyzis possibly removed
- some instructions. */
+ /* Last attempt to optimize CFG, as scheduling, peepholing and insn
+ splitting possibly introduced more crossjumping oppurtuntities.
+ Except that we can't actually run crossjumping without running
+ another DCE pass, which we can't do after reg-stack. */
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
- | CLEANUP_CROSSJUMP);
+ | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
if (flag_reorder_blocks)
{
reorder_basic_blocks ();
longer valid. */
init_insn_lengths ();
- /* Clear out the real_constant_chain before some of the rtx's
- it runs through become garbage. */
- clear_const_double_mem ();
-
/* Show no temporary slots allocated. */
init_temp_slots ();
{
const char *description = f_options[i].description;
- if (description != NULL && * description != 0)
+ if (description != NULL && *description != 0)
printf (" -f%-21s %s\n",
f_options[i].string, _(description));
}
for (i = LAST_PARAM; i--;)
{
const char *description = compiler_params[i].help;
- const int length = 21-strlen(compiler_params[i].option);
+ const int length = 21 - strlen (compiler_params[i].option);
- if (description != NULL && * description != 0)
+ if (description != NULL && *description != 0)
printf (" --param %s=<value>%.*s%s\n",
compiler_params[i].option,
length > 0 ? length : 1, " ",
{
const char *description = W_options[i].description;
- if (description != NULL && * description != 0)
+ if (description != NULL && *description != 0)
printf (" -W%-21s %s\n",
W_options[i].string, _(description));
}
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"));
-#if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER)
- printf (_(" -a Enable block profiling \n"));
-#endif
-#if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER) || defined FUNCTION_BLOCK_PROFILER_EXIT
- printf (_(" -ax Enable jump profiling \n"));
-#endif
printf (_(" -o <file> Place output into <file> \n"));
printf (_("\
-G <number> Put global and static data smaller than <number>\n\
if (extra_warnings)
printf (_(" -m%-23.23s [undocumented]\n"), option);
}
- else if (* description != 0)
+ else if (*description != 0)
doc += printf (" -m%-23.23s %s\n", option, _(description));
}
if (extra_warnings)
printf (_(" -m%-23.23s [undocumented]\n"), option);
}
- else if (* description != 0)
+ else if (*description != 0)
doc += printf (" -m%-23.23s %s\n", option, _(description));
}
#endif
flag_print_asm_name = 1;
break;
case 'P':
- flag_dump_rtl_in_asm = 1;
- flag_print_asm_name = 1;
- break;
+ flag_dump_rtl_in_asm = 1;
+ flag_print_asm_name = 1;
+ break;
case 'v':
graph_dump_format = vcg;
break;
rtl_dump_and_exit = 1;
break;
case 'y':
- (*lang_hooks.set_yydebug) (1);
+ set_yydebug = 1;
break;
case 'D': /* These are handled by the preprocessor. */
case 'I':
}
if (!strcmp (arg, "fast-math"))
- set_fast_math_flags ();
+ set_fast_math_flags (1);
else if (!strcmp (arg, "no-fast-math"))
- set_no_fast_math_flags ();
+ set_fast_math_flags (0);
else if ((option_value = skip_leading_substring (arg, "inline-limit-"))
|| (option_value = skip_leading_substring (arg, "inline-limit=")))
{
stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, nm);
}
else if ((option_value
- = skip_leading_substring (arg, "message-length=")))
+ = 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)));
= skip_leading_substring (arg, "diagnostics-show-location=")))
{
if (!strcmp (option_value, "once"))
- diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_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;
+ diagnostic_prefixing_rule (global_dc)
+ = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
else
error ("unrecognized option `%s'", arg - 2);
}
decode_g_option (arg)
const char *arg;
{
- static unsigned level=0;
+ static unsigned level = 0;
/* A lot of code assumes write_symbols == NO_DEBUG if the
debugging level is 0 (thus -gstabs1 -gstabs0 would lose track
of what debugging type has been selected). This records the
if (da_len > 1 && strncmp (arg, "gdb", da_len) == 0)
{
-#if defined (DWARF2_DEBUGGING_INFO) && !defined (LINKER_DOES_NOT_WORK_WITH_DWARF2)
+#ifdef DWARF2_DEBUGGING_INFO
type = DWARF2_DEBUG;
#else
#ifdef DBX_DEBUGGING_INFO
else
{
if (asm_file_name == 0)
- {
- int len = strlen (dump_base_name);
- char *dumpname = (char *) xmalloc (len + 6);
- memcpy (dumpname, dump_base_name, len + 1);
- strip_off_ending (dumpname, len);
- strcat (dumpname, ".s");
- asm_file_name = dumpname;
- }
+ {
+ int len = strlen (dump_base_name);
+ char *dumpname = (char *) xmalloc (len + 6);
+ memcpy (dumpname, dump_base_name, len + 1);
+ strip_off_ending (dumpname, len);
+ strcat (dumpname, ".s");
+ asm_file_name = dumpname;
+ }
if (!strcmp (asm_file_name, "-"))
- asm_out_file = stdout;
+ asm_out_file = stdout;
else
- asm_out_file = fopen (asm_file_name, "w");
+ 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);
}
#ifdef IO_BUFFER_SIZE
setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
- _IOFBF, IO_BUFFER_SIZE);
+ _IOFBF, IO_BUFFER_SIZE);
#endif
if (!flag_syntax_only)
gcc_init_libintl ();
- /* Install handler for SIGFPE, which may be received while we do
- compile-time floating point arithmetic. */
- signal (SIGFPE, float_signal);
-
/* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
#ifdef SIGSEGV
signal (SIGSEGV, crash_signal);
#if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
signal (SIGIOT, crash_signal);
#endif
+#ifdef SIGFPE
+ signal (SIGFPE, crash_signal);
+#endif
/* Initialize the diagnostics reporting machinery, so option parsing
can give warnings and errors. */
#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_strict_aliasing = 1;
flag_delete_null_pointer_checks = 1;
flag_reorder_blocks = 1;
+ flag_reorder_functions = 1;
}
if (optimize >= 3)
}
}
+ 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
warning ("-Wuninitialized is not supported without -O");
}
+ if (flag_really_no_inline == 2)
+ flag_really_no_inline = flag_no_inline;
+
/* All command line options have been parsed; allow the front end to
perform consistency checks, etc. */
(*lang_hooks.post_options) ();
error ("profiling does not work without a frame pointer");
flag_omit_frame_pointer = 0;
}
-
+
user_label_prefix = USER_LABEL_PREFIX;
if (flag_leading_underscore != -1)
{
static void
lang_independent_init ()
{
- decl_printable_name = decl_name;
- lang_expand_expr = (lang_expand_expr_t) do_abort;
-
- /* Set the language-dependent identifier size. */
- tree_code_length[(int) IDENTIFIER_NODE]
- = ((lang_hooks.identifier_size - sizeof (struct tree_common)
- + sizeof (tree) - 1) / sizeof (tree));
-
/* Initialize the garbage-collector, and string pools. */
init_ggc ();
ggc_add_rtx_root (&stack_limit_rtx, 1);
provide a dummy function context for them. */
init_dummy_function_start ();
init_expmed ();
- init_expr_once ();
if (flag_caller_saves)
init_caller_save ();
expand_dummy_function_end ();
front end is initialized. */
init_eh ();
init_optabs ();
+ init_expr_once ();
/* Put an entry on the input file stack for the main input file. */
push_srcloc (input_filename, 0);
hex_init ();
/* Initialization of GCC's environment, and diagnostics. */
- general_init (argv [0]);
+ general_init (argv[0]);
/* Parse the options and do minimal processing; basically just
enough to default flags appropriately. */
OSDN Git Service
