/* Implements exception handling.
- Copyright (C) 1989-2017 Free Software Foundation, Inc.
+ Copyright (C) 1989-2020 Free Software Foundation, Inc.
Contributed by Mike Stump <mrs@cygnus.com>.
This file is part of GCC.
the compilation process:
In the beginning, in the front end, we have the GENERIC trees
- TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
+ TRY_CATCH_EXPR, TRY_FINALLY_EXPR, EH_ELSE_EXPR, WITH_CLEANUP_EXPR,
CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
- During initial gimplification (gimplify.c) these are lowered
- to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
- The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
- into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
- conversion.
+ During initial gimplification (gimplify.c) these are lowered to the
+ GIMPLE_TRY, GIMPLE_CATCH, GIMPLE_EH_ELSE, and GIMPLE_EH_FILTER
+ nodes. The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are
+ converted into GIMPLE_TRY_FINALLY nodes; the others are a more
+ direct 1-1 conversion.
During pass_lower_eh (tree-eh.c) we record the nested structure
of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
static GTY(()) int call_site_base;
-static GTY (()) hash_map<tree_hash, tree> *type_to_runtime_map;
+static GTY(()) hash_map<tree_hash, tree> *type_to_runtime_map;
+
+static GTY(()) tree setjmp_fn;
/* Describe the SjLj_Function_Context structure. */
static GTY(()) tree sjlj_fc_type_node;
sjlj_fc_jbuf_ofs
= (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf))
+ tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf)) / BITS_PER_UNIT);
+
+#ifdef DONT_USE_BUILTIN_SETJMP
+ tmp = build_function_type_list (integer_type_node, TREE_TYPE (f_jbuf),
+ NULL);
+ setjmp_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
+ get_identifier ("setjmp"), tmp);
+ TREE_PUBLIC (setjmp_fn) = 1;
+ DECL_EXTERNAL (setjmp_fn) = 1;
+ DECL_ASSEMBLER_NAME (setjmp_fn);
+#endif
}
}
static basic_block
emit_to_new_bb_before (rtx_insn *seq, rtx_insn *insn)
{
- rtx_insn *last;
+ rtx_insn *next, *last;
basic_block bb;
edge e;
edge_iterator ei;
force_nonfallthru (e);
else
ei_next (&ei);
- last = emit_insn_before (seq, insn);
+
+ /* Make sure to put the location of INSN or a subsequent instruction on SEQ
+ to avoid inheriting the location of the previous instruction. */
+ next = insn;
+ while (next && !NONDEBUG_INSN_P (next))
+ next = NEXT_INSN (next);
+ if (next)
+ last = emit_insn_before_setloc (seq, insn, INSN_LOCATION (next));
+ else
+ last = emit_insn_before (seq, insn);
if (BARRIER_P (last))
last = PREV_INSN (last);
bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);
at the rtl level. Emit the code required by the target at a landing
pad for the given region. */
-void
+static void
expand_dw2_landing_pad_for_region (eh_region region)
{
if (targetm.have_exception_receiver ())
end_sequence ();
bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad));
+ bb->count = bb->next_bb->count;
make_single_succ_edge (bb, bb->next_bb, e_flags);
if (current_loops)
{
- struct loop *loop = bb->next_bb->loop_father;
+ class loop *loop = bb->next_bb->loop_father;
/* If we created a pre-header block, add the new block to the
outer loop, otherwise to the loop itself. */
if (bb->next_bb == loop->header)
/* We're storing this libcall's address into memory instead of
calling it directly. Thus, we must call assemble_external_libcall
- here, as we can not depend on emit_library_call to do it for us. */
+ here, as we cannot depend on emit_library_call to do it for us. */
assemble_external_libcall (personality);
mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
emit_move_insn (mem, personality);
addr = convert_memory_address (ptr_mode, addr);
tree addr_tree = make_tree (ptr_type_node, addr);
- tree fn = builtin_decl_implicit (BUILT_IN_SETJMP);
- tree call_expr = build_call_expr (fn, 1, addr_tree);
+ tree call_expr = build_call_expr (setjmp_fn, 1, addr_tree);
rtx x = expand_call (call_expr, NULL_RTX, false);
emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
}
emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
- 1, XEXP (fc, 0), Pmode);
+ XEXP (fc, 0), Pmode);
seq = get_insns ();
end_sequence ();
fn_begin_outside_block = false;
}
+#ifdef DONT_USE_BUILTIN_SETJMP
+ if (dispatch_label)
+ {
+ /* The sequence contains a branch in the middle so we need to force
+ the creation of a new basic block by means of BB_SUPERBLOCK. */
+ if (fn_begin_outside_block)
+ {
+ basic_block bb
+ = split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
+ if (JUMP_P (BB_END (bb)))
+ emit_insn_before (seq, BB_END (bb));
+ else
+ emit_insn_after (seq, BB_END (bb));
+ }
+ else
+ emit_insn_after (seq, fn_begin);
+
+ single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun))->flags |= BB_SUPERBLOCK;
+ return;
+ }
+#endif
+
if (fn_begin_outside_block)
insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
else
start_sequence ();
emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
- 1, XEXP (crtl->eh.sjlj_fc, 0), Pmode);
+ XEXP (crtl->eh.sjlj_fc, 0), Pmode);
seq = get_insns ();
end_sequence ();
static void
sjlj_emit_dispatch_table (rtx_code_label *dispatch_label, int num_dispatch)
{
- machine_mode unwind_word_mode = targetm.unwind_word_mode ();
- machine_mode filter_mode = targetm.eh_return_filter_mode ();
+ scalar_int_mode unwind_word_mode = targetm.unwind_word_mode ();
+ scalar_int_mode filter_mode = targetm.eh_return_filter_mode ();
eh_landing_pad lp;
rtx mem, fc, exc_ptr_reg, filter_reg;
rtx_insn *seq;
make_single_succ_edge (bb, bb->next_bb, EDGE_FALLTHRU);
if (current_loops)
{
- struct loop *loop = bb->next_bb->loop_father;
+ class loop *loop = bb->next_bb->loop_father;
/* If we created a pre-header block, add the new block to the
outer loop, otherwise to the loop itself. */
if (bb->next_bb == loop->header)
make_single_succ_edge (bb, bb->next_bb, EDGE_FALLTHRU);
if (current_loops)
{
- struct loop *loop = bb->next_bb->loop_father;
+ class loop *loop = bb->next_bb->loop_father;
/* If we created a pre-header block, add the new block to the
outer loop, otherwise to the loop itself. */
if (bb->next_bb == loop->header)
sjlj_build_landing_pads ();
else
dw2_build_landing_pads ();
- break_superblocks ();
- if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ
- /* Kludge for Alpha (see alpha_gp_save_rtx). */
- || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun))->insns.r)
- commit_edge_insertions ();
+ break_superblocks ();
/* Redirect all EH edges from the post_landing_pad to the landing pad. */
FOR_EACH_BB_FN (bb, cfun)
: EDGE_ABNORMAL);
}
}
+
+ if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ
+ /* Kludge for Alpha (see alpha_gp_save_rtx). */
+ || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun))->insns.r)
+ commit_edge_insertions ();
}
\f
/* This section handles removing dead code for flow. */
if (note == NULL)
return;
}
+ else if (is_a <rtx_insn *> (note_or_insn))
+ return;
note = XEXP (note, 0);
for (insn = first; insn != last ; insn = NEXT_INSN (insn))
if (note == NULL)
return;
}
+ else if (is_a <rtx_insn *> (note_or_insn))
+ return;
note = XEXP (note, 0);
for (insn = last; insn != first; insn = PREV_INSN (insn))
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
eh_region src
= expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1));
- machine_mode fmode = targetm.eh_return_filter_mode ();
+ scalar_int_mode fmode = targetm.eh_return_filter_mode ();
if (dst->exc_ptr_reg == NULL)
dst->exc_ptr_reg = gen_reg_rtx (ptr_mode);
if (rtx handler = EH_RETURN_HANDLER_RTX)
emit_move_insn (handler, crtl->eh.ehr_handler);
else
- error ("__builtin_eh_return not supported on this target");
+ error ("%<__builtin_eh_return%> not supported on this target");
}
emit_label (around_label);
static rtx_note *
emit_note_eh_region_end (rtx_insn *insn)
{
- rtx_insn *next = NEXT_INSN (insn);
+ return emit_note_after (NOTE_INSN_EH_REGION_END, insn);
+}
- /* Make sure we do not split a call and its corresponding
- CALL_ARG_LOCATION note. */
- if (next && NOTE_P (next)
- && NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
- insn = next;
+/* Add NOP after NOTE_INSN_SWITCH_TEXT_SECTIONS when the cold section starts
+ with landing pad.
+ With landing pad being at offset 0 from the start label of the section
+ we would miss EH delivery because 0 is special and means no landing pad. */
- return emit_note_after (NOTE_INSN_EH_REGION_END, insn);
+static bool
+maybe_add_nop_after_section_switch (void)
+{
+ if (!crtl->uses_eh_lsda
+ || !crtl->eh.call_site_record_v[1])
+ return false;
+ int n = vec_safe_length (crtl->eh.call_site_record_v[1]);
+ hash_set<rtx_insn *> visited;
+
+ for (int i = 0; i < n; ++i)
+ {
+ struct call_site_record_d *cs
+ = (*crtl->eh.call_site_record_v[1])[i];
+ if (cs->landing_pad)
+ {
+ rtx_insn *insn = as_a <rtx_insn *> (cs->landing_pad);
+ while (true)
+ {
+ /* Landing pads have LABEL_PRESERVE_P flag set. This check make
+ sure that we do not walk past landing pad visited earlier
+ which would result in possible quadratic behaviour. */
+ if (LABEL_P (insn) && LABEL_PRESERVE_P (insn)
+ && visited.add (insn))
+ break;
+
+ /* Conservatively assume that ASM insn may be empty. We have
+ now way to tell what they contain. */
+ if (active_insn_p (insn)
+ && GET_CODE (PATTERN (insn)) != ASM_INPUT
+ && GET_CODE (PATTERN (insn)) != ASM_OPERANDS)
+ break;
+
+ /* If we reached the start of hot section, then NOP will be
+ needed. */
+ if (GET_CODE (insn) == NOTE
+ && NOTE_KIND (insn) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
+ {
+ emit_insn_after (gen_nop (), insn);
+ break;
+ }
+
+ /* We visit only labels from cold section. We should never hit
+ begining of the insn stream here. */
+ insn = PREV_INSN (insn);
+ }
+ }
+ }
+ return false;
}
/* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
virtual bool gate (function *);
virtual unsigned int execute (function *)
{
- return convert_to_eh_region_ranges ();
+ int ret = convert_to_eh_region_ranges ();
+ maybe_add_nop_after_section_switch ();
+ return ret;
}
}; // class pass_convert_to_eh_region_ranges
switch_to_section (s);
}
-
/* Output a reference from an exception table to the type_info object TYPE.
TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
the value. */
dw2_asm_output_encoded_addr_rtx (tt_format, value, is_public, NULL);
}
+/* Output an exception table for the current function according to SECTION.
+
+ If the function has been partitioned into hot and cold parts, value 0 for
+ SECTION refers to the table associated with the hot part while value 1
+ refers to the table associated with the cold part. If the function has
+ not been partitioned, value 0 refers to the single exception table. */
+
static void
output_one_function_exception_table (int section)
{
}
}
+/* Output an exception table for the current function according to SECTION,
+ switching back and forth from the function section appropriately.
+
+ If the function has been partitioned into hot and cold parts, value 0 for
+ SECTION refers to the table associated with the hot part while value 1
+ refers to the table associated with the cold part. If the function has
+ not been partitioned, value 0 refers to the single exception table. */
+
void
-output_function_exception_table (const char *fnname)
+output_function_exception_table (int section)
{
+ const char *fnname = get_fnname_from_decl (current_function_decl);
rtx personality = get_personality_function (current_function_decl);
/* Not all functions need anything. */
- if (! crtl->uses_eh_lsda)
+ if (!crtl->uses_eh_lsda
+ || targetm_common.except_unwind_info (&global_options) == UI_NONE)
+ return;
+
+ /* No need to emit any boilerplate stuff for the cold part. */
+ if (section == 1 && !crtl->eh.call_site_record_v[1])
return;
if (personality)
/* If the target wants a label to begin the table, emit it here. */
targetm.asm_out.emit_except_table_label (asm_out_file);
- output_one_function_exception_table (0);
- if (crtl->eh.call_site_record_v[1])
- output_one_function_exception_table (1);
+ /* Do the real work. */
+ output_one_function_exception_table (section);
switch_to_section (current_function_section ());
}
count_r++;
else
{
- error ("region_array is corrupted for region %i", r->index);
+ error ("%<region_array%> is corrupted for region %i", r->index);
err = true;
}
}
count_lp++;
else
{
- error ("lp_array is corrupted for lp %i", lp->index);
+ error ("%<lp_array%> is corrupted for lp %i", lp->index);
err = true;
}
}
{
if ((*fun->eh->region_array)[r->index] != r)
{
- error ("region_array is corrupted for region %i", r->index);
+ error ("%<region_array%> is corrupted for region %i", r->index);
err = true;
}
if (r->outer != outer)
{
if ((*fun->eh->lp_array)[lp->index] != lp)
{
- error ("lp_array is corrupted for lp %i", lp->index);
+ error ("%<lp_array%> is corrupted for lp %i", lp->index);
err = true;
}
if (lp->region != r)
}
if (count_r != nvisited_r)
{
- error ("region_array does not match region_tree");
+ error ("%<region_array%> does not match %<region_tree%>");
err = true;
}
if (count_lp != nvisited_lp)
{
- error ("lp_array does not match region_tree");
+ error ("%<lp_array%> does not match %<region_tree%>");
err = true;
}
if (err)
{
dump_eh_tree (stderr, fun);
- internal_error ("verify_eh_tree failed");
+ internal_error ("%qs failed", __func__);
}
}
\f