2018-02-19 Jakub Jelinek <jakub@redhat.com>
+ PR target/84146
+ * reg-notes.def (REG_CALL_ARG_LOCATION): New reg note.
+ * insn-notes.def (NOTE_INSN_CALL_ARG_LOCATION): Remove.
+ * var-tracking.c (emit_note_insn_var_location): Remove all references
+ to NOTE_INSN_CALL_ARG_LOCATION.
+ (emit_notes_in_bb): Emit arguments as REG_CALL_ARG_LOCATION note on
+ the CALL_INSN rather than separate NOTE_INSN_CALL_ARG_LOCATION note.
+ Use copy_rtx_if_shared.
+ * dwarf2out.c (gen_subprogram_die): Use XEXP with 0 instead of
+ NOTE_VAR_LOCATION on ca_loc->call_arg_loc_note.
+ (dwarf2out_var_location): Remove handling of
+ NOTE_INSN_CALL_ARG_LOCATION, instead handle REG_CALL_ARG_LOCATION note
+ on call_insn.
+ * final.c (final_scan_insn): Remove all references to
+ NOTE_INSN_CALL_ARG_LOCATION.
+ (rest_of_clean_state): Likewise. Remove REG_CALL_ARG_LOCATION notes
+ before dumping final insns.
+ * except.c (emit_note_eh_region_end): Remove all references to
+ NOTE_INSN_CALL_ARG_LOCATION.
+ * config/alpha/alpha.c (alpha_pad_function_end): Likewise.
+ * config/c6x/c6x.c (c6x_gen_bundles): Likewise.
+ * config/arc/arc.c (hwloop_optimize): Likewise.
+ * config/arm/arm.c (create_fix_barrier): Likewise.
+ * config/s390/s390.c (s390_chunkify_start): Likewise.
+ * config/sh/sh.c (find_barrier): Likewise.
+ * config/i386/i386.c (rest_of_insert_endbranch,
+ ix86_seh_fixup_eh_fallthru): Likewise.
+ * config/xtensa/xtensa.c (hwloop_optimize): Likewise.
+ * config/iq2000/iq2000.c (final_prescan_insn): Likewise.
+ * config/frv/frv.c (frv_function_prologue): Likewise.
+ * emit-rtl.c (try_split): Likewise. Copy over REG_CALL_ARG_LOCATION
+ reg note.
+ (note_outside_basic_block_p): Remove all references to
+ NOTE_INSN_CALL_ARG_LOCATION.
+ * gengtype.c (adjust_field_rtx_def): Likewise.
+ * print-rtl.c (rtx_writer::print_rtx_operand_code_0, print_insn):
+ Likewise.
+ * jump.c (cleanup_barriers, delete_related_insns): Likewise.
+ * cfgrtl.c (force_nonfallthru_and_redirect): Likewise.
+
PR c++/84444
* builtins.c (builtin_mathfn_code): Don't check if CALL_EXPR_FN (t)
is ADDR_EXPR.
else
new_head = BB_END (e->src);
new_head = NEXT_INSN (new_head);
- /* Make sure we don't split a call and its corresponding
- CALL_ARG_LOCATION note. */
- if (new_head && NOTE_P (new_head)
- && NOTE_KIND (new_head) == NOTE_INSN_CALL_ARG_LOCATION)
- new_head = NEXT_INSN (new_head);
jump_block = create_basic_block (new_head, NULL, e->src);
jump_block->count = count;
|| find_reg_note (insn, REG_NORETURN, NULL_RTX)))
continue;
- /* Make sure we do not split a call and its corresponding
- CALL_ARG_LOCATION note. */
- next = NEXT_INSN (insn);
- if (next == NULL)
- continue;
- if (NOTE_P (next) && NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
- insn = next;
-
next = next_active_insn (insn);
if (next)
{
#if 0
while (DEBUG_INSN_P (entry_after)
|| (NOTE_P (entry_after)
- && NOTE_KIND (entry_after) != NOTE_INSN_BASIC_BLOCK
- /* Make sure we don't split a call and its corresponding
- CALL_ARG_LOCATION note. */
- && NOTE_KIND (entry_after) != NOTE_INSN_CALL_ARG_LOCATION))
+ && NOTE_KIND (entry_after) != NOTE_INSN_BASIC_BLOCK))
entry_after = NEXT_INSN (entry_after);
#endif
entry_after = next_nonnote_nondebug_insn_bb (entry_after);
/* Make sure that we found a place to insert the jump. */
gcc_assert (selected);
- /* Make sure we do not split a call and its corresponding
- CALL_ARG_LOCATION note. */
- if (CALL_P (selected))
- {
- rtx_insn *next = NEXT_INSN (selected);
- if (next && NOTE_P (next)
- && NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
- selected = next;
- }
-
/* Create a new JUMP_INSN that branches around a barrier. */
from = emit_jump_insn_after (gen_jump (label), selected);
JUMP_LABEL (from) = label;
c6x_gen_bundles (void)
{
basic_block bb;
- rtx_insn *insn, *next, *last_call;
FOR_EACH_BB_FN (bb, cfun)
{
break;
}
}
- /* Bundling, and emitting nops, can separate
- NOTE_INSN_CALL_ARG_LOCATION from the corresponding calls. Fix
- that up here. */
- last_call = NULL;
- for (insn = get_insns (); insn; insn = next)
- {
- next = NEXT_INSN (insn);
- if (CALL_P (insn)
- || (INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE
- && CALL_P (XVECEXP (PATTERN (insn), 0, 0))))
- last_call = insn;
- if (!NOTE_P (insn) || NOTE_KIND (insn) != NOTE_INSN_CALL_ARG_LOCATION)
- continue;
- if (NEXT_INSN (last_call) == insn)
- continue;
- SET_NEXT_INSN (PREV_INSN (insn)) = NEXT_INSN (insn);
- SET_PREV_INSN (NEXT_INSN (insn)) = PREV_INSN (insn);
- SET_PREV_INSN (insn) = last_call;
- SET_NEXT_INSN (insn) = NEXT_INSN (last_call);
- SET_PREV_INSN (NEXT_INSN (insn)) = insn;
- SET_NEXT_INSN (PREV_INSN (insn)) = insn;
- last_call = insn;
- }
}
/* Emit a NOP instruction for CYCLES cycles after insn AFTER. Return it. */
static void
frv_function_prologue (FILE *file)
{
- rtx_insn *insn, *next, *last_call;
-
/* If no frame was created, check whether the function uses a call
instruction to implement a far jump. If so, save the link in gr3 and
replace all returns to LR with returns to GR3. GR3 is used because it
/* Allow the garbage collector to free the nops created by frv_reorg. */
memset (frv_nops, 0, sizeof (frv_nops));
-
- /* Locate CALL_ARG_LOCATION notes that have been misplaced
- and move them back to where they should be located. */
- last_call = NULL;
- for (insn = get_insns (); insn; insn = next)
- {
- next = NEXT_INSN (insn);
- if (CALL_P (insn)
- || (INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE
- && CALL_P (XVECEXP (PATTERN (insn), 0, 0))))
- last_call = insn;
-
- if (!NOTE_P (insn) || NOTE_KIND (insn) != NOTE_INSN_CALL_ARG_LOCATION)
- continue;
-
- if (NEXT_INSN (last_call) == insn)
- continue;
-
- SET_NEXT_INSN (PREV_INSN (insn)) = NEXT_INSN (insn);
- SET_PREV_INSN (NEXT_INSN (insn)) = PREV_INSN (insn);
- SET_PREV_INSN (insn) = last_call;
- SET_NEXT_INSN (insn) = NEXT_INSN (last_call);
- SET_PREV_INSN (NEXT_INSN (insn)) = insn;
- SET_NEXT_INSN (PREV_INSN (insn)) = insn;
- last_call = insn;
- }
}
\f
/* Generate ENDBRANCH after CALL, which can return more than
twice, setjmp-like functions. */
- /* Skip notes that must immediately follow the call insn. */
- rtx_insn *next_insn = insn;
- if (NEXT_INSN (insn)
- && NOTE_P (NEXT_INSN (insn))
- && (NOTE_KIND (NEXT_INSN (insn))
- == NOTE_INSN_CALL_ARG_LOCATION))
- next_insn = NEXT_INSN (insn);
-
cet_eb = gen_nop_endbr ();
- emit_insn_after_setloc (cet_eb, next_insn, INSN_LOCATION (insn));
+ emit_insn_after_setloc (cet_eb, insn, INSN_LOCATION (insn));
continue;
}
/* Do not separate calls from their debug information. */
for (next = NEXT_INSN (insn); next != NULL; next = NEXT_INSN (next))
- if (NOTE_P (next)
- && (NOTE_KIND (next) == NOTE_INSN_VAR_LOCATION
- || NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION))
+ if (NOTE_P (next) && NOTE_KIND (next) == NOTE_INSN_VAR_LOCATION)
insn = next;
else
break;
|| (GET_CODE (PATTERN (insn)) == RETURN))
&& NEXT_INSN (PREV_INSN (insn)) == insn)
{
- rtx_insn *tmp = insn;
- while (NEXT_INSN (tmp)
- && NOTE_P (NEXT_INSN (tmp))
- && NOTE_KIND (NEXT_INSN (tmp)) == NOTE_INSN_CALL_ARG_LOCATION)
- tmp = NEXT_INSN (tmp);
-
- rtx_insn *nop_insn = emit_insn_after (gen_nop (), tmp);
+ rtx_insn *nop_insn = emit_insn_after (gen_nop (), insn);
INSN_ADDRESSES_NEW (nop_insn, -1);
}
section_switch_p = true;
break;
case NOTE_INSN_VAR_LOCATION:
- case NOTE_INSN_CALL_ARG_LOCATION:
continue;
default:
break;
}
while (next
&& NOTE_P (next)
- && (NOTE_KIND (next) == NOTE_INSN_VAR_LOCATION
- || NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION));
+ && NOTE_KIND (next) == NOTE_INSN_VAR_LOCATION);
}
else
{
around the constant pool table will be hit. Putting it before
a jump makes it more likely that the bra delay slot will be
filled. */
- while (NOTE_P (from) || JUMP_P (from)
- || LABEL_P (from))
+ while (NOTE_P (from) || JUMP_P (from) || LABEL_P (from))
from = PREV_INSN (from);
- /* Make sure we do not split between a call and its corresponding
- CALL_ARG_LOCATION note. */
if (CALL_P (from))
{
bool sibcall_p = SIBLING_CALL_P (from);
- rtx_insn *next = NEXT_INSN (from);
- if (next && NOTE_P (next)
- && NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
- from = next;
-
/* If FROM was a sibling call, then we know that control
will not return. In fact, we were guaranteed to hit
a barrier before another real insn.
entry_after = BB_END (entry_bb);
while (DEBUG_INSN_P (entry_after)
|| (NOTE_P (entry_after)
- && NOTE_KIND (entry_after) != NOTE_INSN_BASIC_BLOCK
- /* Make sure we don't split a call and its corresponding
- CALL_ARG_LOCATION note. */
- && NOTE_KIND (entry_after) != NOTE_INSN_CALL_ARG_LOCATION))
+ && NOTE_KIND (entry_after) != NOTE_INSN_BASIC_BLOCK))
entry_after = PREV_INSN (entry_after);
emit_insn_after (seq, entry_after);
rtx arg, next_arg;
for (arg = (ca_loc->call_arg_loc_note != NULL_RTX
- ? NOTE_VAR_LOCATION (ca_loc->call_arg_loc_note)
+ ? XEXP (ca_loc->call_arg_loc_note, 0)
: NULL_RTX);
arg; arg = next_arg)
{
call_site_count++;
if (SIBLING_CALL_P (loc_note))
tail_call_site_count++;
+ if (find_reg_note (loc_note, REG_CALL_ARG_LOCATION, NULL_RTX))
+ {
+ call_insn = loc_note;
+ loc_note = NULL;
+ var_loc_p = false;
+
+ next_real = dwarf2out_next_real_insn (call_insn);
+ next_note = NULL;
+ cached_next_real_insn = NULL;
+ goto create_label;
+ }
if (optimize == 0 && !flag_var_tracking)
{
/* When the var-tracking pass is not running, there is no note
|| ! NOTE_P (next_note)
|| (NOTE_KIND (next_note) != NOTE_INSN_VAR_LOCATION
&& NOTE_KIND (next_note) != NOTE_INSN_BEGIN_STMT
- && NOTE_KIND (next_note) != NOTE_INSN_INLINE_ENTRY
- && NOTE_KIND (next_note) != NOTE_INSN_CALL_ARG_LOCATION))
+ && NOTE_KIND (next_note) != NOTE_INSN_INLINE_ENTRY))
next_note = NULL;
if (! next_real)
{
struct call_arg_loc_node *ca_loc
= ggc_cleared_alloc<call_arg_loc_node> ();
- rtx_insn *prev
- = loc_note != NULL_RTX ? prev_real_insn (loc_note) : call_insn;
+ rtx_insn *prev = call_insn;
- ca_loc->call_arg_loc_note = loc_note;
+ ca_loc->call_arg_loc_note
+ = find_reg_note (call_insn, REG_CALL_ARG_LOCATION, NULL_RTX);
ca_loc->next = NULL;
ca_loc->label = last_label;
gcc_assert (prev
for (insn = insn_last; insn ; insn = PREV_INSN (insn))
if (CALL_P (insn))
{
- rtx_insn *next;
- rtx *p;
-
gcc_assert (call_insn == NULL_RTX);
call_insn = insn;
/* Add the old CALL_INSN_FUNCTION_USAGE to whatever the
target may have explicitly specified. */
- p = &CALL_INSN_FUNCTION_USAGE (insn);
+ rtx *p = &CALL_INSN_FUNCTION_USAGE (insn);
while (*p)
p = &XEXP (*p, 1);
*p = CALL_INSN_FUNCTION_USAGE (trial);
/* If the old call was a sibling call, the new one must
be too. */
SIBLING_CALL_P (insn) = SIBLING_CALL_P (trial);
-
- /* If the new call is the last instruction in the sequence,
- it will effectively replace the old call in-situ. Otherwise
- we must move any following NOTE_INSN_CALL_ARG_LOCATION note
- so that it comes immediately after the new call. */
- if (NEXT_INSN (insn))
- for (next = NEXT_INSN (trial);
- next && NOTE_P (next);
- next = NEXT_INSN (next))
- if (NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
- {
- remove_insn (next);
- add_insn_after (next, insn, NULL);
- break;
- }
}
}
case REG_SETJMP:
case REG_TM:
case REG_CALL_NOCF_CHECK:
+ case REG_CALL_ARG_LOCATION:
for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
{
if (CALL_P (insn))
inside basic blocks. If the caller is emitting on the basic block
boundary, do not set BLOCK_FOR_INSN on the new note. */
case NOTE_INSN_VAR_LOCATION:
- case NOTE_INSN_CALL_ARG_LOCATION:
case NOTE_INSN_EH_REGION_BEG:
case NOTE_INSN_EH_REGION_END:
return on_bb_boundary_p;
static rtx_note *
emit_note_eh_region_end (rtx_insn *insn)
{
- rtx_insn *next = NEXT_INSN (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;
-
return emit_note_after (NOTE_INSN_EH_REGION_END, insn);
}
break;
case NOTE_INSN_VAR_LOCATION:
- case NOTE_INSN_CALL_ARG_LOCATION:
if (!DECL_IGNORED_P (current_function_decl))
{
debug_hooks->var_location (insn);
SET_NEXT_INSN (insn) = NULL;
SET_PREV_INSN (insn) = NULL;
+ if (CALL_P (insn))
+ {
+ rtx note = find_reg_note (insn, REG_CALL_ARG_LOCATION, NULL_RTX);
+ if (note)
+ remove_note (insn, note);
+ }
+
if (final_output
- && (!NOTE_P (insn) ||
- (NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION
- && NOTE_KIND (insn) != NOTE_INSN_BEGIN_STMT
- && NOTE_KIND (insn) != NOTE_INSN_INLINE_ENTRY
- && NOTE_KIND (insn) != NOTE_INSN_CALL_ARG_LOCATION
- && NOTE_KIND (insn) != NOTE_INSN_BLOCK_BEG
- && NOTE_KIND (insn) != NOTE_INSN_BLOCK_END
- && NOTE_KIND (insn) != NOTE_INSN_DELETED_DEBUG_LABEL)))
+ && (!NOTE_P (insn)
+ || (NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION
+ && NOTE_KIND (insn) != NOTE_INSN_BEGIN_STMT
+ && NOTE_KIND (insn) != NOTE_INSN_INLINE_ENTRY
+ && NOTE_KIND (insn) != NOTE_INSN_BLOCK_BEG
+ && NOTE_KIND (insn) != NOTE_INSN_BLOCK_END
+ && NOTE_KIND (insn) != NOTE_INSN_DELETED_DEBUG_LABEL)))
print_rtl_single (final_output, insn);
}
break;
case NOTE_INSN_VAR_LOCATION:
- case NOTE_INSN_CALL_ARG_LOCATION:
note_flds = create_field (note_flds, rtx_tp, "rt_rtx");
break;
/* The location of a variable. */
INSN_NOTE (VAR_LOCATION)
-/* The values passed to callee. */
-INSN_NOTE (CALL_ARG_LOCATION)
-
/* The beginning of a statement. */
INSN_NOTE (BEGIN_STMT)
if (!prev)
continue;
- if (CALL_P (prev))
- {
- /* Make sure we do not split a call and its corresponding
- CALL_ARG_LOCATION note. */
- rtx_insn *next = NEXT_INSN (prev);
-
- if (NOTE_P (next)
- && NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
- prev = next;
- }
-
if (BARRIER_P (prev))
delete_insn (insn);
else if (prev != PREV_INSN (insn))
if (next != 0 && BARRIER_P (next))
delete_insn (next);
- /* If this is a call, then we have to remove the var tracking note
- for the call arguments. */
-
- if (CALL_P (insn)
- || (NONJUMP_INSN_P (insn)
- && GET_CODE (PATTERN (insn)) == SEQUENCE
- && CALL_P (XVECEXP (PATTERN (insn), 0, 0))))
- {
- rtx_insn *p;
-
- for (p = next && next->deleted () ? NEXT_INSN (next) : next;
- p && NOTE_P (p);
- p = NEXT_INSN (p))
- if (NOTE_KIND (p) == NOTE_INSN_CALL_ARG_LOCATION)
- {
- remove_insn (p);
- break;
- }
- }
-
/* If deleting a jump, decrement the count of the label,
and delete the label if it is now unused. */
}
case NOTE_INSN_VAR_LOCATION:
- case NOTE_INSN_CALL_ARG_LOCATION:
fputc (' ', m_outfile);
print_rtx (NOTE_VAR_LOCATION (in_rtx));
break;
break;
case NOTE_INSN_VAR_LOCATION:
- case NOTE_INSN_CALL_ARG_LOCATION:
pp_left_brace (pp);
print_pattern (pp, NOTE_VAR_LOCATION (x), verbose);
pp_right_brace (pp);
when a called function has a 'notrack' attribute. This note is used by the
compiler when the option -fcf-protection=branch is specified. */
REG_NOTE (CALL_NOCF_CHECK)
+
+/* The values passed to callee, for debuginfo purposes. */
+REG_NOTE (CALL_ARG_LOCATION)
+2018-02-19 Jakub Jelinek <jakub@redhat.com>
+
+ PR target/84146
+ * gcc.target/i386/pr84146.c: Add -fcompare-debug to dg-options.
+
2017-02-19 Uros Bizjak <ubizjak@gmail.com>
* gcc.target/i386/pr70023.c (dg-do): Compile only for target int128.
/* PR target/84146 */
/* { dg-do compile } */
-/* { dg-options "-O2 -g -mcet -fcf-protection=full" } */
+/* { dg-options "-O2 -g -mcet -fcf-protection=full -fcompare-debug" } */
int __setjmp (void **);
void *buf[64];
/* Make sure that the call related notes come first. */
while (NEXT_INSN (insn)
&& NOTE_P (insn)
- && ((NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
- && NOTE_DURING_CALL_P (insn))
- || NOTE_KIND (insn) == NOTE_INSN_CALL_ARG_LOCATION))
+ && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
+ && NOTE_DURING_CALL_P (insn))
insn = NEXT_INSN (insn);
if (NOTE_P (insn)
- && ((NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
- && NOTE_DURING_CALL_P (insn))
- || NOTE_KIND (insn) == NOTE_INSN_CALL_ARG_LOCATION))
+ && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
+ && NOTE_DURING_CALL_P (insn))
note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
else
note = emit_note_before (NOTE_INSN_VAR_LOCATION, insn);
emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
{
rtx arguments = mo->u.loc, *p = &arguments;
- rtx_note *note;
while (*p)
{
XEXP (XEXP (*p, 0), 1)
shared_hash_htab (set->vars));
/* If expansion is successful, keep it in the list. */
if (XEXP (XEXP (*p, 0), 1))
- p = &XEXP (*p, 1);
+ {
+ XEXP (XEXP (*p, 0), 1)
+ = copy_rtx_if_shared (XEXP (XEXP (*p, 0), 1));
+ p = &XEXP (*p, 1);
+ }
/* Otherwise, if the following item is data_value for it,
drop it too too. */
else if (XEXP (*p, 1)
else
*p = XEXP (*p, 1);
}
- note = emit_note_after (NOTE_INSN_CALL_ARG_LOCATION, insn);
- NOTE_VAR_LOCATION (note) = arguments;
+ add_reg_note (insn, REG_CALL_ARG_LOCATION, arguments);
}
break;
projects / thirdparty / gcc.git / commitdiff
