+2012-06-15 Eric Botcazou <ebotcazou@adacore.com>
+
+ PR middle-end/53590
+ * common.opt (-fdelete-dead-exceptions): New switch.
+ * doc/invoke.texi (Code Gen Options): Document it.
+ * cse.c (count_reg_usage) <CALL_INSN>: Use !insn_nothrow_p in lieu of
+ insn_could_throw_p predicate. Do not skip an insn that could throw
+ if dead exceptions can be deleted.
+ (insn_live_p): Likewise, do not return true in that case.
+ * dce.c (can_alter_cfg): New flag.
+ (deletable_insn_p): Do not return false for an insn that can throw if
+ the CFG can be altered and dead exceptions can be deleted.
+ (init_dce): Set can_alter_cfg to false for fast DCE, true otherwise.
+ * dse.c (scan_insn): Use !insn_nothrow_p in lieu of insn_could_throw_
+ predicate. Do not preserve an insn that could throw if dead exceptions
+ can be deleted.
+ * function.h (struct function): Add can_delete_dead_exceptions flag.
+ * function.c (allocate_struct_function): Set it.
+ * lto-streamer-in.c (input_struct_function_base): Stream it.
+ * lto-streamer-out.c (input_struct_function_base): Likewise.
+ * tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Do not mark a
+ statement that could throw as necessary if dead exceptions can be
+ deleted.
+
2012-06-14 Maxim Kuvyrkov <maxim@codesourcery.com>
* config/tilegx/sync.md (atomic_fetch_sub<mode>): Fix typo.
+2012-06-15 Eric Botcazou <ebotcazou@adacore.com>
+
+ PR middle-end/53590
+ * gcc-interface/misc.c (gnat_init_options_struct): Set
+ opts->x_flag_delete_dead_exceptions to 1.
+
2012-06-14 Jose Ruiz <ruiz@adacore.com>
* gcc-interface/Make-lang.in (ada.install-common, ada.uninstall):
{
/* Uninitialized really means uninitialized in Ada. */
opts->x_flag_zero_initialized_in_bss = 0;
+
+ /* We can delete dead instructions that may throw exceptions in Ada. */
+ opts->x_flag_delete_dead_exceptions = 1;
}
/* Initialize for option processing. */
Common Report Var(flag_delayed_branch) Optimization
Attempt to fill delay slots of branch instructions
+fdelete-dead-exceptions
+Common Report Var(flag_delete_dead_exceptions) Init(0)
+Delete dead instructions that may throw exceptions
+
fdelete-null-pointer-checks
Common Report Var(flag_delete_null_pointer_checks) Init(1) Optimization
Delete useless null pointer checks
static void invalidate_from_sets_and_clobbers (rtx);
static rtx cse_process_notes (rtx, rtx, bool *);
static void cse_extended_basic_block (struct cse_basic_block_data *);
-static void count_reg_usage (rtx, int *, rtx, int);
static int check_for_label_ref (rtx *, void *);
extern void dump_class (struct table_elt*);
static void get_cse_reg_info_1 (unsigned int regno);
case CALL_INSN:
case INSN:
case JUMP_INSN:
- /* We expect dest to be NULL_RTX here. If the insn may trap,
+ /* We expect dest to be NULL_RTX here. If the insn may throw,
or if it cannot be deleted due to side-effects, mark this fact
by setting DEST to pc_rtx. */
- if (insn_could_throw_p (x) || side_effects_p (PATTERN (x)))
+ if ((!cfun->can_delete_dead_exceptions && !insn_nothrow_p (x))
+ || side_effects_p (PATTERN (x)))
dest = pc_rtx;
if (code == CALL_INSN)
count_reg_usage (CALL_INSN_FUNCTION_USAGE (x), counts, dest, incr);
insn_live_p (rtx insn, int *counts)
{
int i;
- if (insn_could_throw_p (insn))
+ if (!cfun->can_delete_dead_exceptions && !insn_nothrow_p (insn))
return true;
else if (GET_CODE (PATTERN (insn)) == SET)
return set_live_p (PATTERN (insn), insn, counts);
we don't want to reenter it. */
static bool df_in_progress = false;
+/* True if we are allowed to alter the CFG in this pass. */
+static bool can_alter_cfg = false;
+
/* Instructions that have been marked but whose dependencies have not
yet been processed. */
static VEC(rtx,heap) *worklist;
if (!NONJUMP_INSN_P (insn))
return false;
- /* Don't delete insns that can throw. */
- if (!insn_nothrow_p (insn))
+ /* Don't delete insns that may throw if we cannot do so. */
+ if (!(cfun->can_delete_dead_exceptions && can_alter_cfg)
+ && !insn_nothrow_p (insn))
return false;
body = PATTERN (insn);
{
bitmap_obstack_initialize (&dce_blocks_bitmap_obstack);
bitmap_obstack_initialize (&dce_tmp_bitmap_obstack);
+ can_alter_cfg = false;
}
+ else
+ can_alter_cfg = true;
marked = sbitmap_alloc (get_max_uid () + 1);
sbitmap_zero (marked);
@xref{Code Gen Options,,Options for Code Generation Conventions}.
@gccoptlist{-fcall-saved-@var{reg} -fcall-used-@var{reg} @gol
-ffixed-@var{reg} -fexceptions @gol
--fnon-call-exceptions -funwind-tables @gol
+-fnon-call-exceptions -fdelete-dead-exceptions -funwind-tables @gol
-fasynchronous-unwind-tables @gol
-finhibit-size-directive -finstrument-functions @gol
-finstrument-functions-exclude-function-list=@var{sym},@var{sym},@dots{} @gol
instructions. It does not allow exceptions to be thrown from
arbitrary signal handlers such as @code{SIGALRM}.
+@item -fdelete-dead-exceptions
+@opindex fdelete-dead-exceptions
+Consider that instructions that may throw exceptions but don't otherwise
+contribute to the execution of the program can be optimized away.
+This option is enabled by default for the Ada front end, as permitted by
+the Ada language specification.
+Optimization passes that cause dead exceptions to be removed are enabled independently at different optimization levels.
+
@item -funwind-tables
@opindex funwind-tables
Similar to @option{-fexceptions}, except that it just generates any needed
them. */
if ((GET_CODE (PATTERN (insn)) == CLOBBER)
|| volatile_refs_p (PATTERN (insn))
- || insn_could_throw_p (insn)
+ || (!cfun->can_delete_dead_exceptions && !insn_nothrow_p (insn))
|| (RTX_FRAME_RELATED_P (insn))
|| find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX))
insn_info->cannot_delete = true;
/* ??? This could be set on a per-function basis by the front-end
but is this worth the hassle? */
cfun->can_throw_non_call_exceptions = flag_non_call_exceptions;
+ cfun->can_delete_dead_exceptions = flag_delete_dead_exceptions;
}
}
exceptions. */
unsigned int can_throw_non_call_exceptions : 1;
+ /* Nonzero if instructions that may throw exceptions but don't otherwise
+ contribute to the execution of the program can be deleted. */
+ unsigned int can_delete_dead_exceptions : 1;
+
/* Fields below this point are not set for abstract functions; see
allocate_struct_function. */
fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
fn->returns_struct = bp_unpack_value (&bp, 1);
fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
+ fn->can_delete_dead_exceptions = bp_unpack_value (&bp, 1);
fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
fn->after_inlining = bp_unpack_value (&bp, 1);
fn->stdarg = bp_unpack_value (&bp, 1);
bp_pack_value (&bp, fn->returns_pcc_struct, 1);
bp_pack_value (&bp, fn->returns_struct, 1);
bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1);
+ bp_pack_value (&bp, fn->can_delete_dead_exceptions, 1);
bp_pack_value (&bp, fn->always_inline_functions_inlined, 1);
bp_pack_value (&bp, fn->after_inlining, 1);
bp_pack_value (&bp, fn->stdarg, 1);
mark_stmt_if_obviously_necessary (gimple stmt, bool aggressive)
{
/* With non-call exceptions, we have to assume that all statements could
- throw. If a statement may throw, it is inherently necessary. */
- if (cfun->can_throw_non_call_exceptions && stmt_could_throw_p (stmt))
+ throw. If a statement could throw, it can be deemed necessary. */
+ if (cfun->can_throw_non_call_exceptions
+ && !cfun->can_delete_dead_exceptions
+ && stmt_could_throw_p (stmt))
{
mark_stmt_necessary (stmt, true);
return;
projects / gcc.git / commitdiff