This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[assert] d*.c
- From: Nathan Sidwell <nathan at codesourcery dot com>
- To: GCC Patches <gcc-patches at gcc dot gnu dot org>
- Date: Wed, 08 Sep 2004 08:47:50 +0100
- Subject: [assert] d*.c
- Organization: Codesourcery LLC
This patch does the d*.c files -- debug & dominance mainly.
booted & tested on i686-pc-linux-gnu, installed.
nathan
--
Nathan Sidwell :: http://www.codesourcery.com :: CodeSourcery LLC
nathan@codesourcery.com :: http://www.planetfall.pwp.blueyonder.co.uk
2004-09-08 Nathan Sidwell <nathan@codesourcery.com>
* dbxout.c (dbxout_type, dbxout_type_name, dbxout_symbol): Use
gcc_assert and gcc_unreachable.
* ddg.c (create_ddg_dependence, add_deps_for_def,
add_deps_for_use, create_ddg, add_edge_to_ddg): Likewise.
* df.c (df_ref_unlink, df_ref_record, df_uses_record,
df_reg_def_chain_create, df_reg_use_chain_create, df_analyze,
df_insn_delete, df_refs_reg_replace, df_ref_reg_replace,
df_insns_modify, df_pattern_emit_before, df_bb_reg_live_start_p,
df_bb_reg_live_end_p, df_bb_regs_lives_compare,
df_bb_single_def_use_insn_find, dataflow_set_a_op_b,
dataflow_set_copy, hybrid_search, diagnostic.c,
diagnostic_build_prefix, diagnostic_count_diagnostic): Likewise.
* dojump.c (do_jump): Likewise.
* dominance.c (calc_dfs_tree_nonrec, calc_dfs_tree,
compute_dom_fast_query, calculate_dominance_info,
free_dominance_info, get_immediate_dominator,
set_immediate_dominator, get_dominated_by,
redirect_immediate_dominators, nearest_common_dominator,
dominated_by_p, verify_dominators, recount_dominator,
iterate_fix_dominators, add_to_dominance_info,
delete_from_dominance_info): Likewise.
* dwarf2asm.c (size_of_encoded_value, eh_data_format_name,
dw2_asm_output_delta_uleb128, dw2_asm_output_delta_sleb128,
dw2_force_const_mem, dw2_asm_output_encoded_addr_rtx): Likewise.
* dwarf2out.c (expand_builtin_init_dwarf_reg_sizes, reg_save,
initial_return_save, stack_adjust_offset, dwarf2out_stack_adjust,
flush_queued_reg_saves, dwarf2out_frame_debug_expr,
dwarf2out_frame_debug, dw_cfi_oprnd1_desc, output_cfi,
output_call_frame_info, output_loc_operands, build_cfa_loc,
decl_ultimate_origin, AT_flag, AT_int, AT_unsigned, AT_string,
AT_string_form, add_AT_specification, AT_ref, set_AT_ref_external,
AT_loc, AT_loc_list, AT_addr, AT_lbl, add_child_die,
splice_child_die, attr_checksum, same_dw_val_p,
break_out_includes, build_abbrev_table, size_of_die, mark_dies,
unmark_dies, value_format, output_loc_list, output_die,
output_pubnames, output_aranges, base_type_die, is_base_type,
modified_type_die, dbx_reg_number, multiple_reg_loc_descriptor,
mem_loc_descriptor, loc_descriptor, loc_descriptor_from_tree_1,
field_byte_offset, add_data_member_location_attribute,
add_const_value_attribute, rtl_for_decl_location,
add_location_or_const_value_attribute, add_byte_size_attribute,
add_bit_offset_attribute, add_bit_size_attribute,
add_abstract_origin_attribute, pop_decl_scope, scope_die_for,
decl_start_label, gen_formal_parameter_die,
gen_type_die_for_member, gen_subprogram_die, gen_label_die,
gen_typedef_die, gen_type_die, gen_tagged_type_instantiation_die,
force_decl_die, force_type_die, gen_decl_die,
dwarf2out_imported_module_or_decl, prune_unused_types_prune,
dwarf2out_finish): Likewise.
Index: dbxout.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dbxout.c,v
retrieving revision 1.197
diff -c -3 -p -r1.197 dbxout.c
*** dbxout.c 13 Aug 2004 20:15:33 -0000 1.197
--- dbxout.c 7 Sep 2004 16:08:28 -0000
*************** dbxout_type (tree type, int full)
*** 1683,1690 ****
/* We shouldn't be outputting a reference to a type before its
definition unless the type has a tag name.
A typedef name without a tag name should be impossible. */
! if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
! abort ();
#endif
if (TYPE_NAME (type) != 0)
dbxout_type_name (type);
--- 1683,1689 ----
/* We shouldn't be outputting a reference to a type before its
definition unless the type has a tag name.
A typedef name without a tag name should be impossible. */
! gcc_assert (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE);
#endif
if (TYPE_NAME (type) != 0)
dbxout_type_name (type);
*************** dbxout_type (tree type, int full)
*** 1919,1925 ****
break;
default:
! abort ();
}
}
--- 1918,1924 ----
break;
default:
! gcc_unreachable ();
}
}
*************** print_wide_int (HOST_WIDE_INT c)
*** 2040,2058 ****
static void
dbxout_type_name (tree type)
{
! tree t;
! if (TYPE_NAME (type) == 0)
! abort ();
! if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
{
! t = TYPE_NAME (type);
! }
! else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
! {
! t = DECL_NAME (TYPE_NAME (type));
}
- else
- abort ();
fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
CHARS (IDENTIFIER_LENGTH (t));
--- 2039,2057 ----
static void
dbxout_type_name (tree type)
{
! tree t = TYPE_NAME (type);
!
! gcc_assert (t);
! switch (TREE_CODE (t))
{
! case IDENTIFIER_NODE:
! break;
! case TYPE_DECL:
! t = DECL_NAME (t);
! break;
! default:
! gcc_unreachable ();
}
fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
CHARS (IDENTIFIER_LENGTH (t));
*************** dbxout_symbol (tree decl, int local ATTR
*** 2386,2392 ****
case PARM_DECL:
/* Parm decls go in their own separate chains
and are output by dbxout_reg_parms and dbxout_parms. */
! abort ();
case RESULT_DECL:
/* Named return value, treat like a VAR_DECL. */
--- 2385,2391 ----
case PARM_DECL:
/* Parm decls go in their own separate chains
and are output by dbxout_reg_parms and dbxout_parms. */
! gcc_unreachable ();
case RESULT_DECL:
/* Named return value, treat like a VAR_DECL. */
Index: ddg.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ddg.c,v
retrieving revision 1.6
diff -c -3 -p -r1.6 ddg.c
*** ddg.c 9 Jul 2004 03:29:26 -0000 1.6
--- ddg.c 7 Sep 2004 16:08:28 -0000
*************** create_ddg_dependence (ddg_ptr g, ddg_no
*** 164,171 ****
if (interloop)
distance = 1;
! if (!link)
! abort ();
/* Note: REG_DEP_ANTI applies to MEM ANTI_DEP as well!! */
if (REG_NOTE_KIND (link) == REG_DEP_ANTI)
--- 164,170 ----
if (interloop)
distance = 1;
! gcc_assert (link);
/* Note: REG_DEP_ANTI applies to MEM ANTI_DEP as well!! */
if (REG_NOTE_KIND (link) == REG_DEP_ANTI)
*************** add_deps_for_def (ddg_ptr g, struct df *
*** 240,247 ****
rtx use_insn = DF_REF_INSN (r_use->ref);
ddg_node_ptr dest_node = get_node_of_insn (g, use_insn);
! if (!src_node || !dest_node)
! abort ();
/* Any such upwards exposed use appears before the rd def. */
use_before_def = true;
--- 239,245 ----
rtx use_insn = DF_REF_INSN (r_use->ref);
ddg_node_ptr dest_node = get_node_of_insn (g, use_insn);
! gcc_assert (src_node && dest_node);
/* Any such upwards exposed use appears before the rd def. */
use_before_def = true;
*************** add_deps_for_use (ddg_ptr g, struct df *
*** 296,303 ****
use_node = get_node_of_insn (g, use->insn);
def_node = get_node_of_insn (g, first_def->insn);
! if (!use_node || !def_node)
! abort ();
/* Make sure there are no defs after USE. */
for (i = use_node->cuid + 1; i < g->num_nodes; i++)
--- 294,300 ----
use_node = get_node_of_insn (g, use->insn);
def_node = get_node_of_insn (g, first_def->insn);
! gcc_assert (use_node && def_node);
/* Make sure there are no defs after USE. */
for (i = use_node->cuid + 1; i < g->num_nodes; i++)
*************** create_ddg (basic_block bb, struct df *d
*** 484,493 ****
}
if (JUMP_P (insn))
{
! if (g->closing_branch)
! abort (); /* Found two branches in DDG. */
! else
! g->closing_branch = &g->nodes[i];
}
else if (GET_CODE (PATTERN (insn)) == USE)
{
--- 481,488 ----
}
if (JUMP_P (insn))
{
! gcc_assert (!g->closing_branch);
! g->closing_branch = &g->nodes[i];
}
else if (GET_CODE (PATTERN (insn)) == USE)
{
*************** create_ddg (basic_block bb, struct df *d
*** 505,513 ****
g->nodes[i++].insn = insn;
first_note = NULL_RTX;
}
!
! if (!g->closing_branch)
! abort (); /* Found no branch in DDG. */
/* Build the data dependency graph. */
build_intra_loop_deps (g);
--- 500,509 ----
g->nodes[i++].insn = insn;
first_note = NULL_RTX;
}
!
! /* We must have found a branch in DDG. */
! gcc_assert (g->closing_branch);
!
/* Build the data dependency graph. */
build_intra_loop_deps (g);
*************** add_edge_to_ddg (ddg_ptr g ATTRIBUTE_UNU
*** 646,653 ****
ddg_node_ptr src = e->src;
ddg_node_ptr dest = e->dest;
! if (!src->successors || !dest->predecessors)
! abort (); /* Should have allocated the sbitmaps. */
SET_BIT (src->successors, dest->cuid);
SET_BIT (dest->predecessors, src->cuid);
--- 642,649 ----
ddg_node_ptr src = e->src;
ddg_node_ptr dest = e->dest;
! /* Should have allocated the sbitmaps. */
! gcc_assert (src->successors && dest->predecessors);
SET_BIT (src->successors, dest->cuid);
SET_BIT (dest->predecessors, src->cuid);
Index: df.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/df.c,v
retrieving revision 1.70
diff -c -3 -p -r1.70 df.c
*** df.c 9 Jul 2004 03:29:26 -0000 1.70
--- df.c 7 Sep 2004 16:08:33 -0000
*************** df_ref_unlink (struct df_link **phead, s
*** 648,655 ****
/* Only a single ref. It must be the one we want.
If not, the def-use and use-def chains are likely to
be inconsistent. */
! if (link->ref != ref)
! abort ();
/* Now have an empty chain. */
*phead = NULL;
}
--- 648,655 ----
/* Only a single ref. It must be the one we want.
If not, the def-use and use-def chains are likely to
be inconsistent. */
! gcc_assert (link->ref == ref);
!
/* Now have an empty chain. */
*phead = NULL;
}
*************** df_ref_record (struct df *df, rtx reg, r
*** 808,815 ****
{
unsigned int regno;
! if (!REG_P (reg) && GET_CODE (reg) != SUBREG)
! abort ();
/* For the reg allocator we are interested in some SUBREG rtx's, but not
all. Notably only those representing a word extraction from a multi-word
--- 808,814 ----
{
unsigned int regno;
! gcc_assert (REG_P (reg) || GET_CODE (reg) == SUBREG);
/* For the reg allocator we are interested in some SUBREG rtx's, but not
all. Notably only those representing a word extraction from a multi-word
*************** df_uses_record (struct df *df, rtx *loc,
*** 1040,1049 ****
bb, insn, 0);
break;
case STRICT_LOW_PART:
! /* A strict_low_part uses the whole REG and not just the SUBREG. */
dst = XEXP (dst, 0);
! if (GET_CODE (dst) != SUBREG)
! abort ();
df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
insn, DF_REF_READ_WRITE);
break;
--- 1039,1048 ----
bb, insn, 0);
break;
case STRICT_LOW_PART:
! /* A strict_low_part uses the whole REG and not just the
! SUBREG. */
dst = XEXP (dst, 0);
! gcc_assert (GET_CODE (dst) == SUBREG);
df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
insn, DF_REF_READ_WRITE);
break;
*************** df_uses_record (struct df *df, rtx *loc,
*** 1056,1062 ****
dst = XEXP (dst, 0);
break;
default:
! abort ();
}
return;
}
--- 1055,1061 ----
dst = XEXP (dst, 0);
break;
default:
! gcc_unreachable ();
}
return;
}
*************** df_reg_def_chain_create (struct df *df,
*** 1311,1318 ****
{
#ifdef ENABLE_CHECKING
for (regno = 0; regno < df->n_regs; regno++)
! if (df->regs[regno].defs)
! abort ();
#endif
/* Pretend that all defs are new. */
--- 1310,1316 ----
{
#ifdef ENABLE_CHECKING
for (regno = 0; regno < df->n_regs; regno++)
! gcc_assert (!df->regs[regno].defs);
#endif
/* Pretend that all defs are new. */
*************** df_reg_use_chain_create (struct df *df,
*** 1393,1400 ****
{
#ifdef ENABLE_CHECKING
for (regno = 0; regno < df->n_regs; regno++)
! if (df->regs[regno].uses)
! abort ();
#endif
/* Pretend that all uses are new. */
--- 1391,1397 ----
{
#ifdef ENABLE_CHECKING
for (regno = 0; regno < df->n_regs; regno++)
! gcc_assert (!df->regs[regno].uses);
#endif
/* Pretend that all uses are new. */
*************** df_analyze (struct df *df, bitmap blocks
*** 2298,2305 ****
/* We could deal with additional basic blocks being created by
rescanning everything again. */
! if (df->n_bbs && df->n_bbs != (unsigned int) last_basic_block)
! abort ();
update = df_modified_p (df, blocks);
if (update || (flags != df->flags))
--- 2295,2301 ----
/* We could deal with additional basic blocks being created by
rescanning everything again. */
! gcc_assert (!df->n_bbs || df->n_bbs == (unsigned int) last_basic_block);
update = df_modified_p (df, blocks);
if (update || (flags != df->flags))
*************** df_analyze (struct df *df, bitmap blocks
*** 2321,2328 ****
if (blocks == (bitmap) -1)
blocks = df->bbs_modified;
! if (! df->n_bbs)
! abort ();
df_analyze_1 (df, blocks, flags, 1);
bitmap_zero (df->bbs_modified);
--- 2317,2323 ----
if (blocks == (bitmap) -1)
blocks = df->bbs_modified;
! gcc_assert (df->n_bbs);
df_analyze_1 (df, blocks, flags, 1);
bitmap_zero (df->bbs_modified);
*************** df_insn_delete (struct df *df, basic_blo
*** 2631,2638 ****
handle the JUMP_LABEL? */
/* We should not be deleting the NOTE_INSN_BASIC_BLOCK or label. */
! if (insn == BB_HEAD (bb))
! abort ();
/* Delete the insn. */
delete_insn (insn);
--- 2626,2632 ----
handle the JUMP_LABEL? */
/* We should not be deleting the NOTE_INSN_BASIC_BLOCK or label. */
! gcc_assert (insn != BB_HEAD (bb));
/* Delete the insn. */
delete_insn (insn);
*************** df_refs_reg_replace (struct df *df, bitm
*** 2796,2819 ****
if (! INSN_P (insn))
continue;
! if (bitmap_bit_p (blocks, DF_REF_BBNO (ref)))
! {
! df_ref_reg_replace (df, ref, oldreg, newreg);
!
! /* Replace occurrences of the reg within the REG_NOTES. */
! if ((! link->next || DF_REF_INSN (ref)
! != DF_REF_INSN (link->next->ref))
! && REG_NOTES (insn))
! {
! args.insn = insn;
! for_each_rtx (®_NOTES (insn), df_rtx_reg_replace, &args);
! }
! }
! else
{
! /* Temporary check to ensure that we have a grip on which
! regs should be replaced. */
! abort ();
}
}
}
--- 2790,2806 ----
if (! INSN_P (insn))
continue;
! gcc_assert (bitmap_bit_p (blocks, DF_REF_BBNO (ref)));
!
! df_ref_reg_replace (df, ref, oldreg, newreg);
!
! /* Replace occurrences of the reg within the REG_NOTES. */
! if ((! link->next || DF_REF_INSN (ref)
! != DF_REF_INSN (link->next->ref))
! && REG_NOTES (insn))
{
! args.insn = insn;
! for_each_rtx (®_NOTES (insn), df_rtx_reg_replace, &args);
}
}
}
*************** df_ref_reg_replace (struct df *df, struc
*** 2844,2851 ****
if (! INSN_P (DF_REF_INSN (ref)))
return 0;
! if (oldreg && oldreg != DF_REF_REG (ref))
! abort ();
if (! validate_change (DF_REF_INSN (ref), DF_REF_LOC (ref), newreg, 1))
return 0;
--- 2831,2837 ----
if (! INSN_P (DF_REF_INSN (ref)))
return 0;
! gcc_assert (!oldreg || oldreg == DF_REF_REG (ref));
if (! validate_change (DF_REF_INSN (ref), DF_REF_LOC (ref), newreg, 1))
return 0;
*************** df_insns_modify (struct df *df, basic_bl
*** 2911,2920 ****
/* A non-const call should not have slipped through the net. If
it does, we need to create a new basic block. Ouch. The
same applies for a label. */
! if ((CALL_P (insn)
! && ! CONST_OR_PURE_CALL_P (insn))
! || LABEL_P (insn))
! abort ();
uid = INSN_UID (insn);
--- 2897,2904 ----
/* A non-const call should not have slipped through the net. If
it does, we need to create a new basic block. Ouch. The
same applies for a label. */
! gcc_assert ((!CALL_P (insn) || CONST_OR_PURE_CALL_P (insn))
! && !LABEL_P (insn));
uid = INSN_UID (insn);
*************** df_pattern_emit_before (struct df *df, r
*** 2937,2944 ****
rtx prev_insn = PREV_INSN (insn);
/* We should not be inserting before the start of the block. */
! if (insn == BB_HEAD (bb))
! abort ();
ret_insn = emit_insn_before (pattern, insn);
if (ret_insn == insn)
return ret_insn;
--- 2921,2927 ----
rtx prev_insn = PREV_INSN (insn);
/* We should not be inserting before the start of the block. */
! gcc_assert (insn != BB_HEAD (bb));
ret_insn = emit_insn_before (pattern, insn);
if (ret_insn == insn)
return ret_insn;
*************** df_bb_reg_live_start_p (struct df *df, b
*** 3196,3205 ****
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
! #ifdef ENABLE_CHECKING
! if (! bb_info->lr_in)
! abort ();
! #endif
return bitmap_bit_p (bb_info->lr_in, REGNO (reg));
}
--- 3179,3185 ----
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
! gcc_assert (bb_info->lr_in);
return bitmap_bit_p (bb_info->lr_in, REGNO (reg));
}
*************** df_bb_reg_live_end_p (struct df *df, bas
*** 3211,3220 ****
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
! #ifdef ENABLE_CHECKING
! if (! bb_info->lr_in)
! abort ();
! #endif
return bitmap_bit_p (bb_info->lr_out, REGNO (reg));
}
--- 3191,3197 ----
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
! gcc_assert (bb_info->lr_in);
return bitmap_bit_p (bb_info->lr_out, REGNO (reg));
}
*************** df_bb_regs_lives_compare (struct df *df,
*** 3234,3242 ****
/* The regs must be local to BB. */
! if (df_regno_bb (df, regno1) != bb
! || df_regno_bb (df, regno2) != bb)
! abort ();
def2 = df_bb_regno_first_def_find (df, bb, regno2);
use1 = df_bb_regno_last_use_find (df, bb, regno1);
--- 3211,3218 ----
/* The regs must be local to BB. */
! gcc_assert (df_regno_bb (df, regno1) == bb
! && df_regno_bb (df, regno2) == bb);
def2 = df_bb_regno_first_def_find (df, bb, regno2);
use1 = df_bb_regno_last_use_find (df, bb, regno1);
*************** df_bb_single_def_use_insn_find (struct d
*** 3380,3387 ****
def = df_bb_insn_regno_first_def_find (df, bb, insn, REGNO (reg));
! if (! def)
! abort ();
du_link = DF_REF_CHAIN (def);
--- 3356,3362 ----
def = df_bb_insn_regno_first_def_find (df, bb, insn, REGNO (reg));
! gcc_assert (def);
du_link = DF_REF_CHAIN (def);
*************** dataflow_set_a_op_b (enum set_representa
*** 3761,3767 ****
break;
default:
! abort ();
}
break;
--- 3736,3742 ----
break;
default:
! gcc_unreachable ();
}
break;
*************** dataflow_set_a_op_b (enum set_representa
*** 3777,3788 ****
break;
default:
! abort ();
}
break;
default:
! abort ();
}
}
--- 3752,3763 ----
break;
default:
! gcc_unreachable ();
}
break;
default:
! gcc_unreachable ();
}
}
*************** dataflow_set_copy (enum set_representati
*** 3800,3806 ****
break;
default:
! abort ();
}
}
--- 3775,3781 ----
break;
default:
! gcc_unreachable ();
}
}
*************** hybrid_search (basic_block bb, struct da
*** 3816,3823 ****
edge e;
SET_BIT (visited, bb->index);
! if (!TEST_BIT (pending, bb->index))
! abort ();
RESET_BIT (pending, i);
#define HS(E_ANTI, E_ANTI_NEXT, E_ANTI_BB, E_ANTI_START_BB, IN_SET, \
--- 3791,3797 ----
edge e;
SET_BIT (visited, bb->index);
! gcc_assert (TEST_BIT (pending, bb->index));
RESET_BIT (pending, i);
#define HS(E_ANTI, E_ANTI_NEXT, E_ANTI_BB, E_ANTI_START_BB, IN_SET, \
Index: diagnostic.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/diagnostic.c,v
retrieving revision 1.141
diff -c -3 -p -r1.141 diagnostic.c
*** diagnostic.c 30 Aug 2004 04:48:33 -0000 1.141
--- diagnostic.c 7 Sep 2004 16:08:35 -0000
*************** diagnostic_build_prefix (diagnostic_info
*** 174,181 ****
"must-not-happen"
};
expanded_location s = expand_location (diagnostic->location);
! if (diagnostic->kind >= DK_LAST_DIAGNOSTIC_KIND)
! abort();
return s.file
? build_message_string ("%s:%d: %s",
--- 174,180 ----
"must-not-happen"
};
expanded_location s = expand_location (diagnostic->location);
! gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
return s.file
? build_message_string ("%s:%d: %s",
*************** diagnostic_count_diagnostic (diagnostic_
*** 194,201 ****
switch (kind)
{
default:
! abort();
! break;
case DK_ICE:
#ifndef ENABLE_CHECKING
--- 193,199 ----
switch (kind)
{
default:
! gcc_unreachable ();
case DK_ICE:
#ifndef ENABLE_CHECKING
Index: dojump.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dojump.c,v
retrieving revision 1.28
diff -c -3 -p -r1.28 dojump.c
*** dojump.c 18 Aug 2004 16:39:40 -0000 1.28
--- dojump.c 7 Sep 2004 16:08:37 -0000
*************** do_jump (tree exp, rtx if_false_label, r
*** 265,271 ****
case COMPOUND_EXPR:
case COND_EXPR:
/* Lowered by gimplify.c. */
! abort ();
case COMPONENT_REF:
case BIT_FIELD_REF:
--- 265,271 ----
case COMPOUND_EXPR:
case COND_EXPR:
/* Lowered by gimplify.c. */
! gcc_unreachable ();
case COMPONENT_REF:
case BIT_FIELD_REF:
*************** do_jump (tree exp, rtx if_false_label, r
*** 301,310 ****
{
tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
! if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
! || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
! abort ();
! else if (integer_zerop (TREE_OPERAND (exp, 1)))
do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
&& !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
--- 301,312 ----
{
tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
! gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
! != MODE_COMPLEX_FLOAT);
! gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
! != MODE_COMPLEX_INT);
!
! if (integer_zerop (TREE_OPERAND (exp, 1)))
do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
&& !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
*************** do_jump (tree exp, rtx if_false_label, r
*** 318,327 ****
{
tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
! if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
! || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
! abort ();
! else if (integer_zerop (TREE_OPERAND (exp, 1)))
do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
&& !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
--- 320,331 ----
{
tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
! gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
! != MODE_COMPLEX_FLOAT);
! gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
! != MODE_COMPLEX_INT);
!
! if (integer_zerop (TREE_OPERAND (exp, 1)))
do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
&& !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
*************** do_jump (tree exp, rtx if_false_label, r
*** 511,518 ****
&& ! can_compare_p (NE, GET_MODE (temp), ccp_jump))
/* Note swapping the labels gives us not-equal. */
do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
! else if (GET_MODE (temp) != VOIDmode)
{
/* The RTL optimizers prefer comparisons against pseudos. */
if (GET_CODE (temp) == SUBREG)
{
--- 515,524 ----
&& ! can_compare_p (NE, GET_MODE (temp), ccp_jump))
/* Note swapping the labels gives us not-equal. */
do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
! else
{
+ gcc_assert (GET_MODE (temp) != VOIDmode);
+
/* The RTL optimizers prefer comparisons against pseudos. */
if (GET_CODE (temp) == SUBREG)
{
*************** do_jump (tree exp, rtx if_false_label, r
*** 528,535 ****
GET_MODE (temp), NULL_RTX,
if_false_label, if_true_label);
}
- else
- abort ();
}
}
--- 534,539 ----
Index: dominance.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dominance.c,v
retrieving revision 1.26
diff -c -3 -p -r1.26 dominance.c
*** dominance.c 29 Jul 2004 17:47:31 -0000 1.26
--- dominance.c 7 Sep 2004 16:08:39 -0000
*************** calc_dfs_tree_nonrec (struct dom_info *d
*** 271,278 ****
e_next = bn->succ;
}
! if (bn == en_block)
! abort ();
/* Fill the DFS tree info calculatable _before_ recursing. */
if (bb != en_block)
--- 271,277 ----
e_next = bn->succ;
}
! gcc_assert (bn != en_block);
/* Fill the DFS tree info calculatable _before_ recursing. */
if (bb != en_block)
*************** calc_dfs_tree (struct dom_info *di, enum
*** 375,382 ****
di->nodes = di->dfsnum - 1;
/* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
! if (di->nodes != (unsigned int) n_basic_blocks + 1)
! abort ();
}
/* Compress the path from V to the root of its set and update path_min at the
--- 374,380 ----
di->nodes = di->dfsnum - 1;
/* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
! gcc_assert (di->nodes == (unsigned int) n_basic_blocks + 1);
}
/* Compress the path from V to the root of its set and update path_min at the
*************** compute_dom_fast_query (enum cdi_directi
*** 597,604 ****
int num = 0;
basic_block bb;
! if (dom_computed[dir] < DOM_NO_FAST_QUERY)
! abort ();
if (dom_computed[dir] == DOM_OK)
return;
--- 595,601 ----
int num = 0;
basic_block bb;
! gcc_assert (dom_computed[dir] >= DOM_NO_FAST_QUERY);
if (dom_computed[dir] == DOM_OK)
return;
*************** calculate_dominance_info (enum cdi_direc
*** 629,636 ****
if (dom_computed[dir] != DOM_NONE)
free_dominance_info (dir);
! if (n_bbs_in_dom_tree[dir])
! abort ();
FOR_ALL_BB (b)
{
--- 626,632 ----
if (dom_computed[dir] != DOM_NONE)
free_dominance_info (dir);
! gcc_assert (!n_bbs_in_dom_tree[dir]);
FOR_ALL_BB (b)
{
*************** free_dominance_info (enum cdi_direction
*** 672,679 ****
}
/* If there are any nodes left, something is wrong. */
! if (n_bbs_in_dom_tree[dir])
! abort ();
dom_computed[dir] = DOM_NONE;
}
--- 668,674 ----
}
/* If there are any nodes left, something is wrong. */
! gcc_assert (!n_bbs_in_dom_tree[dir]);
dom_computed[dir] = DOM_NONE;
}
*************** get_immediate_dominator (enum cdi_direct
*** 684,691 ****
{
struct et_node *node = bb->dom[dir];
! if (!dom_computed[dir])
! abort ();
if (!node->father)
return NULL;
--- 679,685 ----
{
struct et_node *node = bb->dom[dir];
! gcc_assert (dom_computed[dir]);
if (!node->father)
return NULL;
*************** set_immediate_dominator (enum cdi_direct
*** 701,708 ****
{
struct et_node *node = bb->dom[dir];
! if (!dom_computed[dir])
! abort ();
if (node->father)
{
--- 695,701 ----
{
struct et_node *node = bb->dom[dir];
! gcc_assert (dom_computed[dir]);
if (node->father)
{
*************** get_dominated_by (enum cdi_direction dir
*** 726,733 ****
int n;
struct et_node *node = bb->dom[dir], *son = node->son, *ason;
! if (!dom_computed[dir])
! abort ();
if (!son)
{
--- 719,725 ----
int n;
struct et_node *node = bb->dom[dir], *son = node->son, *ason;
! gcc_assert (dom_computed[dir]);
if (!son)
{
*************** redirect_immediate_dominators (enum cdi_
*** 753,760 ****
{
struct et_node *bb_node = bb->dom[dir], *to_node = to->dom[dir], *son;
! if (!dom_computed[dir])
! abort ();
if (!bb_node->son)
return;
--- 745,751 ----
{
struct et_node *bb_node = bb->dom[dir], *to_node = to->dom[dir], *son;
! gcc_assert (dom_computed[dir]);
if (!bb_node->son)
return;
*************** redirect_immediate_dominators (enum cdi_
*** 775,782 ****
basic_block
nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
{
! if (!dom_computed[dir])
! abort ();
if (!bb1)
return bb2;
--- 766,772 ----
basic_block
nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
{
! gcc_assert (dom_computed[dir]);
if (!bb1)
return bb2;
*************** dominated_by_p (enum cdi_direction dir,
*** 792,799 ****
{
struct et_node *n1 = bb1->dom[dir], *n2 = bb2->dom[dir];
! if (!dom_computed[dir])
! abort ();
if (dom_computed[dir] == DOM_OK)
return (n1->dfs_num_in >= n2->dfs_num_in
--- 782,788 ----
{
struct et_node *n1 = bb1->dom[dir], *n2 = bb2->dom[dir];
! gcc_assert (dom_computed[dir]);
if (dom_computed[dir] == DOM_OK)
return (n1->dfs_num_in >= n2->dfs_num_in
*************** verify_dominators (enum cdi_direction di
*** 809,816 ****
int err = 0;
basic_block bb;
! if (!dom_computed[dir])
! abort ();
FOR_EACH_BB (bb)
{
--- 798,804 ----
int err = 0;
basic_block bb;
! gcc_assert (dom_computed[dir]);
FOR_EACH_BB (bb)
{
*************** verify_dominators (enum cdi_direction di
*** 838,845 ****
}
}
! if (err)
! abort ();
}
/* Determine immediate dominator (or postdominator, according to DIR) of BB,
--- 826,832 ----
}
}
! gcc_assert (!err);
}
/* Determine immediate dominator (or postdominator, according to DIR) of BB,
*************** recount_dominator (enum cdi_direction di
*** 853,860 ****
basic_block dom_bb = NULL;
edge e;
! if (!dom_computed[dir])
! abort ();
if (dir == CDI_DOMINATORS)
{
--- 840,846 ----
basic_block dom_bb = NULL;
edge e;
! gcc_assert (dom_computed[dir]);
if (dir == CDI_DOMINATORS)
{
*************** iterate_fix_dominators (enum cdi_directi
*** 889,896 ****
int i, changed = 1;
basic_block old_dom, new_dom;
! if (!dom_computed[dir])
! abort ();
for (i = 0; i < n; i++)
set_immediate_dominator (dir, bbs[i], NULL);
--- 875,881 ----
int i, changed = 1;
basic_block old_dom, new_dom;
! gcc_assert (dom_computed[dir]);
for (i = 0; i < n; i++)
set_immediate_dominator (dir, bbs[i], NULL);
*************** iterate_fix_dominators (enum cdi_directi
*** 911,928 ****
}
for (i = 0; i < n; i++)
! if (!get_immediate_dominator (dir, bbs[i]))
! abort ();
}
void
add_to_dominance_info (enum cdi_direction dir, basic_block bb)
{
! if (!dom_computed[dir])
! abort ();
!
! if (bb->dom[dir])
! abort ();
n_bbs_in_dom_tree[dir]++;
--- 896,909 ----
}
for (i = 0; i < n; i++)
! gcc_assert (get_immediate_dominator (dir, bbs[i]));
}
void
add_to_dominance_info (enum cdi_direction dir, basic_block bb)
{
! gcc_assert (dom_computed[dir]);
! gcc_assert (!bb->dom[dir]);
n_bbs_in_dom_tree[dir]++;
*************** add_to_dominance_info (enum cdi_directio
*** 935,942 ****
void
delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
{
! if (!dom_computed[dir])
! abort ();
et_free_tree (bb->dom[dir]);
bb->dom[dir] = NULL;
--- 916,922 ----
void
delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
{
! gcc_assert (dom_computed[dir]);
et_free_tree (bb->dom[dir]);
bb->dom[dir] = NULL;
Index: dwarf2asm.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dwarf2asm.c,v
retrieving revision 1.38
diff -c -3 -p -r1.38 dwarf2asm.c
*** dwarf2asm.c 24 Mar 2004 23:45:41 -0000 1.38
--- dwarf2asm.c 7 Sep 2004 16:08:40 -0000
*************** size_of_encoded_value (int encoding)
*** 333,340 ****
return 4;
case DW_EH_PE_udata8:
return 8;
}
- abort ();
}
/* Yield a name for a given pointer encoding. */
--- 333,341 ----
return 4;
case DW_EH_PE_udata8:
return 8;
+ default:
+ gcc_unreachable ();
}
}
/* Yield a name for a given pointer encoding. */
*************** eh_data_format_name (int format)
*** 486,497 ****
#if HAVE_DESIGNATED_INITIALIZERS
};
! if (format < 0 || format > 0xff || format_names[format] == NULL)
! abort ();
return format_names[format];
#else
}
! abort ();
#endif
}
--- 487,498 ----
#if HAVE_DESIGNATED_INITIALIZERS
};
! gcc_assert (format >= 0 && format < 0x100 && format_names[format]);
!
return format_names[format];
#else
}
! gcc_unreachable ();
#endif
}
*************** dw2_asm_output_delta_uleb128 (const char
*** 635,641 ****
fputc ('-', asm_out_file);
assemble_name (asm_out_file, lab2);
#else
! abort ();
#endif
if (flag_debug_asm && comment)
--- 636,642 ----
fputc ('-', asm_out_file);
assemble_name (asm_out_file, lab2);
#else
! gcc_unreachable ();
#endif
if (flag_debug_asm && comment)
*************** dw2_asm_output_delta_sleb128 (const char
*** 663,669 ****
fputc ('-', asm_out_file);
assemble_name (asm_out_file, lab2);
#else
! abort ();
#endif
if (flag_debug_asm && comment)
--- 664,670 ----
fputc ('-', asm_out_file);
assemble_name (asm_out_file, lab2);
#else
! gcc_unreachable ();
#endif
if (flag_debug_asm && comment)
*************** dw2_force_const_mem (rtx x)
*** 704,711 ****
if (! indirect_pool)
indirect_pool = splay_tree_new_ggc (splay_tree_compare_pointers);
! if (GET_CODE (x) != SYMBOL_REF)
! abort ();
str = targetm.strip_name_encoding (XSTR (x, 0));
node = splay_tree_lookup (indirect_pool, (splay_tree_key) str);
--- 705,711 ----
if (! indirect_pool)
indirect_pool = splay_tree_new_ggc (splay_tree_compare_pointers);
! gcc_assert (GET_CODE (x) == SYMBOL_REF);
str = targetm.strip_name_encoding (XSTR (x, 0));
node = splay_tree_lookup (indirect_pool, (splay_tree_key) str);
*************** dw2_asm_output_encoded_addr_rtx (int enc
*** 836,843 ****
break;
case DW_EH_PE_pcrel:
! if (GET_CODE (addr) != SYMBOL_REF)
! abort ();
#ifdef ASM_OUTPUT_DWARF_PCREL
ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
#else
--- 836,842 ----
break;
case DW_EH_PE_pcrel:
! gcc_assert (GET_CODE (addr) == SYMBOL_REF);
#ifdef ASM_OUTPUT_DWARF_PCREL
ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
#else
*************** dw2_asm_output_encoded_addr_rtx (int enc
*** 848,854 ****
default:
/* Other encodings should have been handled by
ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */
! abort ();
}
#ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
--- 847,853 ----
default:
/* Other encodings should have been handled by
ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */
! gcc_unreachable ();
}
#ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
Index: dwarf2out.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dwarf2out.c,v
retrieving revision 1.543
diff -c -3 -p -r1.543 dwarf2out.c
*** dwarf2out.c 3 Sep 2004 17:10:39 -0000 1.543
--- dwarf2out.c 7 Sep 2004 16:09:07 -0000
*************** expand_builtin_init_dwarf_reg_sizes (tre
*** 489,496 ****
}
#ifdef DWARF_ALT_FRAME_RETURN_COLUMN
! if (! wrote_return_column)
! abort ();
i = DWARF_ALT_FRAME_RETURN_COLUMN;
wrote_return_column = false;
#else
--- 489,495 ----
}
#ifdef DWARF_ALT_FRAME_RETURN_COLUMN
! gcc_assert (wrote_return_column);
i = DWARF_ALT_FRAME_RETURN_COLUMN;
wrote_return_column = false;
#else
*************** reg_save (const char *label, unsigned in
*** 829,836 ****
description. */
HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
! if (check_offset * DWARF_CIE_DATA_ALIGNMENT != offset)
! abort ();
}
#endif
offset /= DWARF_CIE_DATA_ALIGNMENT;
--- 828,834 ----
description. */
HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
! gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
}
#endif
offset /= DWARF_CIE_DATA_ALIGNMENT;
*************** initial_return_save (rtx rtl)
*** 934,958 ****
switch (GET_CODE (rtl))
{
case REG:
! if (REGNO (rtl) != STACK_POINTER_REGNUM)
! abort ();
offset = 0;
break;
case PLUS:
! if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
! abort ();
offset = INTVAL (XEXP (rtl, 1));
break;
case MINUS:
! if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
! abort ();
offset = -INTVAL (XEXP (rtl, 1));
break;
default:
! abort ();
}
break;
--- 932,953 ----
switch (GET_CODE (rtl))
{
case REG:
! gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
offset = 0;
break;
case PLUS:
! gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
offset = INTVAL (XEXP (rtl, 1));
break;
case MINUS:
! gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
offset = -INTVAL (XEXP (rtl, 1));
break;
default:
! gcc_unreachable ();
}
break;
*************** initial_return_save (rtx rtl)
*** 961,973 ****
/* The return address is at some offset from any value we can
actually load. For instance, on the SPARC it is in %i7+8. Just
ignore the offset for now; it doesn't matter for unwinding frames. */
! if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
! abort ();
initial_return_save (XEXP (rtl, 0));
return;
default:
! abort ();
}
if (reg != DWARF_FRAME_RETURN_COLUMN)
--- 956,967 ----
/* The return address is at some offset from any value we can
actually load. For instance, on the SPARC it is in %i7+8. Just
ignore the offset for now; it doesn't matter for unwinding frames. */
! gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
initial_return_save (XEXP (rtl, 0));
return;
default:
! gcc_unreachable ();
}
if (reg != DWARF_FRAME_RETURN_COLUMN)
*************** stack_adjust_offset (rtx pattern)
*** 1012,1020 ****
{
rtx val = XEXP (XEXP (src, 1), 1);
/* We handle only adjustments by constant amount. */
! if (GET_CODE (XEXP (src, 1)) != PLUS ||
! GET_CODE (val) != CONST_INT)
! abort ();
offset = -INTVAL (val);
break;
}
--- 1006,1013 ----
{
rtx val = XEXP (XEXP (src, 1), 1);
/* We handle only adjustments by constant amount. */
! gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
! && GET_CODE (val) == CONST_INT);
offset = -INTVAL (val);
break;
}
*************** dwarf2out_stack_adjust (rtx insn)
*** 1074,1081 ****
insn = XVECEXP (insn, 0, 0);
if (GET_CODE (insn) == SET)
insn = SET_SRC (insn);
! if (GET_CODE (insn) != CALL)
! abort ();
dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
return;
--- 1067,1073 ----
insn = XVECEXP (insn, 0, 0);
if (GET_CODE (insn) == SET)
insn = SET_SRC (insn);
! gcc_assert (GET_CODE (insn) == CALL);
dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
return;
*************** flush_queued_reg_saves (void)
*** 1208,1215 ****
break;
if (q->saved_reg && i == num_regs_saved_in_regs)
{
! if (i == ARRAY_SIZE (regs_saved_in_regs))
! abort ();
num_regs_saved_in_regs++;
}
if (i != num_regs_saved_in_regs)
--- 1200,1206 ----
break;
if (q->saved_reg && i == num_regs_saved_in_regs)
{
! gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
num_regs_saved_in_regs++;
}
if (i != num_regs_saved_in_regs)
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1466,1473 ****
return;
}
! if (GET_CODE (expr) != SET)
! abort ();
src = SET_SRC (expr);
dest = SET_DEST (expr);
--- 1457,1463 ----
return;
}
! gcc_assert (GET_CODE (expr) == SET);
src = SET_SRC (expr);
dest = SET_DEST (expr);
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1500,1513 ****
cfa_temp.reg = cfa.reg;
cfa_temp.offset = cfa.offset;
}
! else if (call_used_regs [REGNO (dest)]
! && ! fixed_regs [REGNO (dest)])
{
/* Saving a register in a register. */
queue_reg_save (label, src, dest, 0);
}
- else
- abort ();
break;
case PLUS:
--- 1490,1502 ----
cfa_temp.reg = cfa.reg;
cfa_temp.offset = cfa.offset;
}
! else
{
/* Saving a register in a register. */
+ gcc_assert (call_used_regs [REGNO (dest)]
+ && !fixed_regs [REGNO (dest)]);
queue_reg_save (label, src, dest, 0);
}
break;
case PLUS:
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1523,1548 ****
offset = INTVAL (XEXP (src, 1));
break;
case REG:
! if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp.reg)
! abort ();
offset = cfa_temp.offset;
break;
default:
! abort ();
}
if (XEXP (src, 0) == hard_frame_pointer_rtx)
{
/* Restoring SP from FP in the epilogue. */
! if (cfa.reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
! abort ();
cfa.reg = STACK_POINTER_REGNUM;
}
else if (GET_CODE (src) == LO_SUM)
/* Assume we've set the source reg of the LO_SUM from sp. */
;
! else if (XEXP (src, 0) != stack_pointer_rtx)
! abort ();
if (GET_CODE (src) != MINUS)
offset = -offset;
--- 1512,1536 ----
offset = INTVAL (XEXP (src, 1));
break;
case REG:
! gcc_assert ((unsigned) REGNO (XEXP (src, 1))
! == cfa_temp.reg);
offset = cfa_temp.offset;
break;
default:
! gcc_unreachable ();
}
if (XEXP (src, 0) == hard_frame_pointer_rtx)
{
/* Restoring SP from FP in the epilogue. */
! gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
cfa.reg = STACK_POINTER_REGNUM;
}
else if (GET_CODE (src) == LO_SUM)
/* Assume we've set the source reg of the LO_SUM from sp. */
;
! else
! gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
if (GET_CODE (src) != MINUS)
offset = -offset;
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1556,1581 ****
/* Rule 3 */
/* Either setting the FP from an offset of the SP,
or adjusting the FP */
! if (! frame_pointer_needed)
! abort ();
! if (REG_P (XEXP (src, 0))
! && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
! && GET_CODE (XEXP (src, 1)) == CONST_INT)
! {
! offset = INTVAL (XEXP (src, 1));
! if (GET_CODE (src) != MINUS)
! offset = -offset;
! cfa.offset += offset;
! cfa.reg = HARD_FRAME_POINTER_REGNUM;
! }
! else
! abort ();
}
else
{
! if (GET_CODE (src) == MINUS)
! abort ();
/* Rule 4 */
if (REG_P (XEXP (src, 0))
--- 1544,1563 ----
/* Rule 3 */
/* Either setting the FP from an offset of the SP,
or adjusting the FP */
! gcc_assert (frame_pointer_needed);
! gcc_assert (REG_P (XEXP (src, 0))
! && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
! && GET_CODE (XEXP (src, 1)) == CONST_INT);
! offset = INTVAL (XEXP (src, 1));
! if (GET_CODE (src) != MINUS)
! offset = -offset;
! cfa.offset += offset;
! cfa.reg = HARD_FRAME_POINTER_REGNUM;
}
else
{
! gcc_assert (GET_CODE (src) != MINUS);
/* Rule 4 */
if (REG_P (XEXP (src, 0))
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1599,1606 ****
{
/* Setting a scratch register that we will use instead
of SP for saving registers to the stack. */
! if (cfa.reg != STACK_POINTER_REGNUM)
! abort ();
cfa_store.reg = REGNO (dest);
cfa_store.offset = cfa.offset - cfa_temp.offset;
}
--- 1581,1587 ----
{
/* Setting a scratch register that we will use instead
of SP for saving registers to the stack. */
! gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
cfa_store.reg = REGNO (dest);
cfa_store.offset = cfa.offset - cfa_temp.offset;
}
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1613,1619 ****
cfa_temp.offset = INTVAL (XEXP (src, 1));
}
else
! abort ();
}
break;
--- 1594,1600 ----
cfa_temp.offset = INTVAL (XEXP (src, 1));
}
else
! gcc_unreachable ();
}
break;
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1625,1634 ****
/* Rule 7 */
case IOR:
! if (!REG_P (XEXP (src, 0))
! || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp.reg
! || GET_CODE (XEXP (src, 1)) != CONST_INT)
! abort ();
if ((unsigned) REGNO (dest) != cfa_temp.reg)
cfa_temp.reg = REGNO (dest);
--- 1606,1614 ----
/* Rule 7 */
case IOR:
! gcc_assert (REG_P (XEXP (src, 0))
! && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
! && GET_CODE (XEXP (src, 1)) == CONST_INT);
if ((unsigned) REGNO (dest) != cfa_temp.reg)
cfa_temp.reg = REGNO (dest);
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1642,1656 ****
break;
default:
! abort ();
}
def_cfa_1 (label, &cfa);
break;
case MEM:
! if (!REG_P (src))
! abort ();
/* Saving a register to the stack. Make sure dest is relative to the
CFA register. */
--- 1622,1635 ----
break;
default:
! gcc_unreachable ();
}
def_cfa_1 (label, &cfa);
break;
case MEM:
! gcc_assert (REG_P (src));
/* Saving a register to the stack. Make sure dest is relative to the
CFA register. */
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1660,1672 ****
/* With a push. */
case PRE_MODIFY:
/* We can't handle variable size modifications. */
! if (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1)) != CONST_INT)
! abort ();
offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
! if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
! || cfa_store.reg != STACK_POINTER_REGNUM)
! abort ();
cfa_store.offset += offset;
if (cfa.reg == STACK_POINTER_REGNUM)
--- 1639,1650 ----
/* With a push. */
case PRE_MODIFY:
/* We can't handle variable size modifications. */
! gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
! == CONST_INT);
offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
! gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
! && cfa_store.reg == STACK_POINTER_REGNUM);
cfa_store.offset += offset;
if (cfa.reg == STACK_POINTER_REGNUM)
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1682,1690 ****
if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
offset = -offset;
! if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
! || cfa_store.reg != STACK_POINTER_REGNUM)
! abort ();
cfa_store.offset += offset;
if (cfa.reg == STACK_POINTER_REGNUM)
--- 1660,1667 ----
if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
offset = -offset;
! gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
! && cfa_store.reg == STACK_POINTER_REGNUM);
cfa_store.offset += offset;
if (cfa.reg == STACK_POINTER_REGNUM)
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1698,1738 ****
case PLUS:
case MINUS:
case LO_SUM:
! if (GET_CODE (XEXP (XEXP (dest, 0), 1)) != CONST_INT)
! abort ();
! offset = INTVAL (XEXP (XEXP (dest, 0), 1));
! if (GET_CODE (XEXP (dest, 0)) == MINUS)
! offset = -offset;
!
! if (cfa_store.reg == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
! offset -= cfa_store.offset;
! else if (cfa_temp.reg == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
! offset -= cfa_temp.offset;
! else
! abort ();
break;
/* Rule 13 */
/* Without an offset. */
case REG:
! if (cfa_store.reg == (unsigned) REGNO (XEXP (dest, 0)))
! offset = -cfa_store.offset;
! else if (cfa_temp.reg == (unsigned) REGNO (XEXP (dest, 0)))
! offset = -cfa_temp.offset;
! else
! abort ();
break;
/* Rule 14 */
case POST_INC:
! if (cfa_temp.reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
! abort ();
offset = -cfa_temp.offset;
cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
break;
default:
! abort ();
}
if (REGNO (src) != STACK_POINTER_REGNUM
--- 1675,1726 ----
case PLUS:
case MINUS:
case LO_SUM:
! {
! int regno;
!
! gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT);
! offset = INTVAL (XEXP (XEXP (dest, 0), 1));
! if (GET_CODE (XEXP (dest, 0)) == MINUS)
! offset = -offset;
!
! regno = REGNO (XEXP (XEXP (dest, 0), 0));
!
! if (cfa_store.reg == (unsigned) regno)
! offset -= cfa_store.offset;
! else
! {
! gcc_assert (cfa_temp.reg == (unsigned) regno);
! offset -= cfa_temp.offset;
! }
! }
break;
/* Rule 13 */
/* Without an offset. */
case REG:
! {
! int regno = REGNO (XEXP (dest, 0));
!
! if (cfa_store.reg == (unsigned) regno)
! offset = -cfa_store.offset;
! else
! {
! gcc_assert (cfa_temp.reg == (unsigned) regno);
! offset = -cfa_temp.offset;
! }
! }
break;
/* Rule 14 */
case POST_INC:
! gcc_assert (cfa_temp.reg
! == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
offset = -cfa_temp.offset;
cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
break;
default:
! gcc_unreachable ();
}
if (REGNO (src) != STACK_POINTER_REGNUM
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1758,1765 ****
if (!REG_P (x))
x = XEXP (x, 0);
! if (!REG_P (x))
! abort ();
cfa.reg = REGNO (x);
cfa.base_offset = offset;
--- 1746,1752 ----
if (!REG_P (x))
x = XEXP (x, 0);
! gcc_assert (REG_P (x));
cfa.reg = REGNO (x);
cfa.base_offset = offset;
*************** dwarf2out_frame_debug_expr (rtx expr, co
*** 1774,1780 ****
break;
default:
! abort ();
}
}
--- 1761,1767 ----
break;
default:
! gcc_unreachable ();
}
}
*************** dwarf2out_frame_debug (rtx insn)
*** 1797,1804 ****
/* Set up state for generating call frame debug info. */
lookup_cfa (&cfa);
! if (cfa.reg != (unsigned long) DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
! abort ();
cfa.reg = STACK_POINTER_REGNUM;
cfa_store = cfa;
--- 1784,1791 ----
/* Set up state for generating call frame debug info. */
lookup_cfa (&cfa);
! gcc_assert (cfa.reg
! == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
cfa.reg = STACK_POINTER_REGNUM;
cfa_store = cfa;
*************** dw_cfi_oprnd1_desc (enum dwarf_call_fram
*** 1879,1885 ****
return dw_cfi_oprnd_loc;
default:
! abort ();
}
}
--- 1866,1872 ----
return dw_cfi_oprnd_loc;
default:
! gcc_unreachable ();
}
}
*************** output_cfi (dw_cfi_ref cfi, dw_fde_ref f
*** 2030,2036 ****
case DW_CFA_GNU_negative_offset_extended:
/* Obsoleted by DW_CFA_offset_extended_sf. */
! abort ();
default:
break;
--- 2017,2023 ----
case DW_CFA_GNU_negative_offset_extended:
/* Obsoleted by DW_CFA_offset_extended_sf. */
! gcc_unreachable ();
default:
break;
*************** output_call_frame_info (int for_eh)
*** 2185,2192 ****
/* Augmentations should be small, so there's scarce need to
iterate for a solution. Die if we exceed one uleb128 byte. */
! if (size_of_uleb128 (augmentation_size) != 1)
! abort ();
}
}
--- 2172,2178 ----
/* Augmentations should be small, so there's scarce need to
iterate for a solution. Die if we exceed one uleb128 byte. */
! gcc_assert (size_of_uleb128 (augmentation_size) == 1);
}
}
*************** output_call_frame_info (int for_eh)
*** 2289,2296 ****
int pad = -offset & (PTR_SIZE - 1);
size += pad;
! if (size_of_uleb128 (size) != 1)
! abort ();
}
dw2_asm_output_data_uleb128 (size, "Augmentation size");
--- 2275,2281 ----
int pad = -offset & (PTR_SIZE - 1);
size += pad;
! gcc_assert (size_of_uleb128 (size) == 1);
}
dw2_asm_output_data_uleb128 (size, "Augmentation size");
*************** output_loc_operands (dw_loc_descr_ref lo
*** 3089,3096 ****
break;
case DW_OP_const8u:
case DW_OP_const8s:
! if (HOST_BITS_PER_LONG < 64)
! abort ();
dw2_asm_output_data (8, val1->v.val_int, NULL);
break;
case DW_OP_skip:
--- 3074,3080 ----
break;
case DW_OP_const8u:
case DW_OP_const8s:
! gcc_assert (HOST_BITS_PER_LONG >= 64);
dw2_asm_output_data (8, val1->v.val_int, NULL);
break;
case DW_OP_skip:
*************** output_loc_operands (dw_loc_descr_ref lo
*** 3098,3107 ****
{
int offset;
! if (val1->val_class == dw_val_class_loc)
! offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
! else
! abort ();
dw2_asm_output_data (2, offset, NULL);
}
--- 3082,3089 ----
{
int offset;
! gcc_assert (val1->val_class == dw_val_class_loc);
! offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
dw2_asm_output_data (2, offset, NULL);
}
*************** output_loc_operands (dw_loc_descr_ref lo
*** 3120,3126 ****
aligned properly like we do for the main unwind info, so
don't support emitting things larger than a byte if we're
only doing unwinding. */
! abort ();
#endif
case DW_OP_const1u:
case DW_OP_const1s:
--- 3102,3108 ----
aligned properly like we do for the main unwind info, so
don't support emitting things larger than a byte if we're
only doing unwinding. */
! gcc_unreachable ();
#endif
case DW_OP_const1u:
case DW_OP_const1s:
*************** output_loc_operands (dw_loc_descr_ref lo
*** 3196,3202 ****
val1->v.val_addr);
fputc ('\n', asm_out_file);
#else
! abort ();
#endif
break;
--- 3178,3184 ----
val1->v.val_addr);
fputc ('\n', asm_out_file);
#else
! gcc_unreachable ();
#endif
break;
*************** build_cfa_loc (dw_cfa_location *cfa)
*** 3248,3255 ****
{
struct dw_loc_descr_struct *head, *tmp;
! if (cfa->indirect == 0)
! abort ();
if (cfa->base_offset)
{
--- 3230,3236 ----
{
struct dw_loc_descr_struct *head, *tmp;
! gcc_assert (cfa->indirect);
if (cfa->base_offset)
{
*************** decl_ultimate_origin (tree decl)
*** 4585,4596 ****
if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
return NULL_TREE;
! #ifdef ENABLE_CHECKING
! if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
! /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
! most distant ancestor, this should never happen. */
! abort ();
! #endif
return DECL_ABSTRACT_ORIGIN (decl);
}
--- 4566,4574 ----
if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
return NULL_TREE;
! /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
! most distant ancestor, this should never happen. */
! gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
return DECL_ABSTRACT_ORIGIN (decl);
}
*************** add_AT_flag (dw_die_ref die, enum dwarf_
*** 4688,4697 ****
static inline unsigned
AT_flag (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_flag)
! return a->dw_attr_val.v.val_flag;
!
! abort ();
}
/* Add a signed integer attribute value to a DIE. */
--- 4666,4673 ----
static inline unsigned
AT_flag (dw_attr_ref a)
{
! gcc_assert (a && AT_class (a) == dw_val_class_flag);
! return a->dw_attr_val.v.val_flag;
}
/* Add a signed integer attribute value to a DIE. */
*************** add_AT_int (dw_die_ref die, enum dwarf_a
*** 4711,4720 ****
static inline HOST_WIDE_INT
AT_int (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_const)
! return a->dw_attr_val.v.val_int;
!
! abort ();
}
/* Add an unsigned integer attribute value to a DIE. */
--- 4687,4694 ----
static inline HOST_WIDE_INT
AT_int (dw_attr_ref a)
{
! gcc_assert (a && AT_class (a) == dw_val_class_const);
! return a->dw_attr_val.v.val_int;
}
/* Add an unsigned integer attribute value to a DIE. */
*************** add_AT_unsigned (dw_die_ref die, enum dw
*** 4735,4744 ****
static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_unsigned_const)
! return a->dw_attr_val.v.val_unsigned;
!
! abort ();
}
/* Add an unsigned double integer attribute value to a DIE. */
--- 4709,4716 ----
static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref a)
{
! gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
! return a->dw_attr_val.v.val_unsigned;
}
/* Add an unsigned double integer attribute value to a DIE. */
*************** add_AT_string (dw_die_ref die, enum dwar
*** 4820,4829 ****
static inline const char *
AT_string (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_str)
! return a->dw_attr_val.v.val_str->str;
!
! abort ();
}
/* Find out whether a string should be output inline in DIE
--- 4792,4799 ----
static inline const char *
AT_string (dw_attr_ref a)
{
! gcc_assert (a && AT_class (a) == dw_val_class_str);
! return a->dw_attr_val.v.val_str->str;
}
/* Find out whether a string should be output inline in DIE
*************** AT_string (dw_attr_ref a)
*** 4832,4869 ****
static int
AT_string_form (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_str)
! {
! struct indirect_string_node *node;
! unsigned int len;
! char label[32];
!
! node = a->dw_attr_val.v.val_str;
! if (node->form)
! return node->form;
!
! len = strlen (node->str) + 1;
!
! /* If the string is shorter or equal to the size of the reference, it is
! always better to put it inline. */
! if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
! return node->form = DW_FORM_string;
!
! /* If we cannot expect the linker to merge strings in .debug_str
! section, only put it into .debug_str if it is worth even in this
! single module. */
! if ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) == 0
! && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
! return node->form = DW_FORM_string;
! ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
! ++dw2_string_counter;
! node->label = xstrdup (label);
! return node->form = DW_FORM_strp;
! }
! abort ();
}
/* Add a DIE reference attribute value to a DIE. */
--- 4802,4836 ----
static int
AT_string_form (dw_attr_ref a)
{
! struct indirect_string_node *node;
! unsigned int len;
! char label[32];
! gcc_assert (a && AT_class (a) == dw_val_class_str);
!
! node = a->dw_attr_val.v.val_str;
! if (node->form)
! return node->form;
!
! len = strlen (node->str) + 1;
! /* If the string is shorter or equal to the size of the reference, it is
! always better to put it inline. */
! if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
! return node->form = DW_FORM_string;
!
! /* If we cannot expect the linker to merge strings in .debug_str
! section, only put it into .debug_str if it is worth even in this
! single module. */
! if ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) == 0
! && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
! return node->form = DW_FORM_string;
!
! ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
! ++dw2_string_counter;
! node->label = xstrdup (label);
! return node->form = DW_FORM_strp;
}
/* Add a DIE reference attribute value to a DIE. */
*************** static inline void
*** 4888,4905 ****
add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
{
add_AT_die_ref (die, DW_AT_specification, targ_die);
! if (targ_die->die_definition)
! abort ();
targ_die->die_definition = die;
}
static inline dw_die_ref
AT_ref (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_die_ref)
! return a->dw_attr_val.v.val_die_ref.die;
!
! abort ();
}
static inline int
--- 4855,4869 ----
add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
{
add_AT_die_ref (die, DW_AT_specification, targ_die);
! gcc_assert (!targ_die->die_definition);
targ_die->die_definition = die;
}
static inline dw_die_ref
AT_ref (dw_attr_ref a)
{
! gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
! return a->dw_attr_val.v.val_die_ref.die;
}
static inline int
*************** AT_ref_external (dw_attr_ref a)
*** 4914,4923 ****
static inline void
set_AT_ref_external (dw_attr_ref a, int i)
{
! if (a && AT_class (a) == dw_val_class_die_ref)
! a->dw_attr_val.v.val_die_ref.external = i;
! else
! abort ();
}
/* Add an FDE reference attribute value to a DIE. */
--- 4878,4885 ----
static inline void
set_AT_ref_external (dw_attr_ref a, int i)
{
! gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
! a->dw_attr_val.v.val_die_ref.external = i;
}
/* Add an FDE reference attribute value to a DIE. */
*************** add_AT_loc (dw_die_ref die, enum dwarf_a
*** 4951,4960 ****
static inline dw_loc_descr_ref
AT_loc (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_loc)
! return a->dw_attr_val.v.val_loc;
!
! abort ();
}
static inline void
--- 4913,4920 ----
static inline dw_loc_descr_ref
AT_loc (dw_attr_ref a)
{
! gcc_assert (a && AT_class (a) == dw_val_class_loc);
! return a->dw_attr_val.v.val_loc;
}
static inline void
*************** add_AT_loc_list (dw_die_ref die, enum dw
*** 4973,4982 ****
static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_loc_list)
! return a->dw_attr_val.v.val_loc_list;
!
! abort ();
}
/* Add an address constant attribute value to a DIE. */
--- 4933,4940 ----
static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref a)
{
! gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
! return a->dw_attr_val.v.val_loc_list;
}
/* Add an address constant attribute value to a DIE. */
*************** add_AT_addr (dw_die_ref die, enum dwarf_
*** 4996,5005 ****
static inline rtx
AT_addr (dw_attr_ref a)
{
! if (a && AT_class (a) == dw_val_class_addr)
! return a->dw_attr_val.v.val_addr;
!
! abort ();
}
/* Add a label identifier attribute value to a DIE. */
--- 4954,4961 ----
static inline rtx
AT_addr (dw_attr_ref a)
{
! gcc_assert (a && AT_class (a) == dw_val_class_addr);
! return a->dw_attr_val.v.val_addr;
}
/* Add a label identifier attribute value to a DIE. */
*************** add_AT_range_list (dw_die_ref die, enum
*** 5063,5073 ****
static inline const char *
AT_lbl (dw_attr_ref a)
{
! if (a && (AT_class (a) == dw_val_class_lbl_id
! || AT_class (a) == dw_val_class_lbl_offset))
! return a->dw_attr_val.v.val_lbl_id;
!
! abort ();
}
/* Get the attribute of type attr_kind. */
--- 5019,5027 ----
static inline const char *
AT_lbl (dw_attr_ref a)
{
! gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
! || AT_class (a) == dw_val_class_lbl_offset));
! return a->dw_attr_val.v.val_lbl_id;
}
/* Get the attribute of type attr_kind. */
*************** add_child_die (dw_die_ref die, dw_die_re
*** 5317,5324 ****
{
if (die != NULL && child_die != NULL)
{
! if (die == child_die)
! abort ();
child_die->die_parent = die;
child_die->die_sib = die->die_child;
--- 5271,5277 ----
{
if (die != NULL && child_die != NULL)
{
! gcc_assert (die != child_die);
child_die->die_parent = die;
child_die->die_sib = die->die_child;
*************** splice_child_die (dw_die_ref parent, dw_
*** 5344,5352 ****
child = tmp;
}
! if (child->die_parent != parent
! && child->die_parent != get_AT_ref (parent, DW_AT_specification))
! abort ();
for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
if (*p == child)
--- 5297,5305 ----
child = tmp;
}
! gcc_assert (child->die_parent == parent
! || (child->die_parent
! == get_AT_ref (parent, DW_AT_specification)));
for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
if (*p == child)
*************** attr_checksum (dw_attr_ref at, struct md
*** 5778,5792 ****
case dw_val_class_addr:
r = AT_addr (at);
! switch (GET_CODE (r))
! {
! case SYMBOL_REF:
! CHECKSUM_STRING (XSTR (r, 0));
! break;
!
! default:
! abort ();
! }
break;
case dw_val_class_offset:
--- 5731,5738 ----
case dw_val_class_addr:
r = AT_addr (at);
! gcc_assert (GET_CODE (r) == SYMBOL_REF);
! CHECKSUM_STRING (XSTR (r, 0));
break;
case dw_val_class_offset:
*************** same_dw_val_p (dw_val_node *v1, dw_val_n
*** 5886,5899 ****
r2 = v2->v.val_addr;
if (GET_CODE (r1) != GET_CODE (r2))
return 0;
! switch (GET_CODE (r1))
! {
! case SYMBOL_REF:
! return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
!
! default:
! abort ();
! }
case dw_val_class_offset:
return v1->v.val_offset == v2->v.val_offset;
--- 5832,5839 ----
r2 = v2->v.val_addr;
if (GET_CODE (r1) != GET_CODE (r2))
return 0;
! gcc_assert (GET_CODE (r1) == SYMBOL_REF);
! return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
case dw_val_class_offset:
return v1->v.val_offset == v2->v.val_offset;
*************** break_out_includes (dw_die_ref die)
*** 6269,6276 ****
#if 0
/* We can only use this in debugging, since the frontend doesn't check
to make sure that we leave every include file we enter. */
! if (unit != NULL)
! abort ();
#endif
assign_symbol_names (die);
--- 6209,6215 ----
#if 0
/* We can only use this in debugging, since the frontend doesn't check
to make sure that we leave every include file we enter. */
! gcc_assert (!unit);
#endif
assign_symbol_names (die);
*************** build_abbrev_table (dw_die_ref die)
*** 6351,6358 ****
if (AT_class (d_attr) == dw_val_class_die_ref
&& AT_ref (d_attr)->die_mark == 0)
{
! if (AT_ref (d_attr)->die_symbol == 0)
! abort ();
set_AT_ref_external (d_attr, 1);
}
--- 6290,6296 ----
if (AT_class (d_attr) == dw_val_class_die_ref
&& AT_ref (d_attr)->die_mark == 0)
{
! gcc_assert (AT_ref (d_attr)->die_symbol);
set_AT_ref_external (d_attr, 1);
}
*************** size_of_die (dw_die_ref die)
*** 6497,6503 ****
size += strlen (a->dw_attr_val.v.val_str->str) + 1;
break;
default:
! abort ();
}
}
--- 6435,6441 ----
size += strlen (a->dw_attr_val.v.val_str->str) + 1;
break;
default:
! gcc_unreachable ();
}
}
*************** mark_dies (dw_die_ref die)
*** 6535,6542 ****
{
dw_die_ref c;
! if (die->die_mark)
! abort ();
die->die_mark = 1;
for (c = die->die_child; c; c = c->die_sib)
--- 6473,6479 ----
{
dw_die_ref c;
! gcc_assert (!die->die_mark);
die->die_mark = 1;
for (c = die->die_child; c; c = c->die_sib)
*************** unmark_dies (dw_die_ref die)
*** 6550,6557 ****
{
dw_die_ref c;
! if (!die->die_mark)
! abort ();
die->die_mark = 0;
for (c = die->die_child; c; c = c->die_sib)
--- 6487,6493 ----
{
dw_die_ref c;
! gcc_assert (die->die_mark);
die->die_mark = 0;
for (c = die->die_child; c; c = c->die_sib)
*************** value_format (dw_attr_ref a)
*** 6627,6637 ****
return DW_FORM_addr;
case dw_val_class_range_list:
case dw_val_class_offset:
! if (DWARF_OFFSET_SIZE == 4)
! return DW_FORM_data4;
! if (DWARF_OFFSET_SIZE == 8)
! return DW_FORM_data8;
! abort ();
case dw_val_class_loc_list:
/* FIXME: Could be DW_FORM_data8, with a > 32 bit size
.debug_loc section */
--- 6563,6577 ----
return DW_FORM_addr;
case dw_val_class_range_list:
case dw_val_class_offset:
! switch (DWARF_OFFSET_SIZE)
! {
! case 4:
! return DW_FORM_data4;
! case 8:
! return DW_FORM_data8;
! default:
! gcc_unreachable ();
! }
case dw_val_class_loc_list:
/* FIXME: Could be DW_FORM_data8, with a > 32 bit size
.debug_loc section */
*************** value_format (dw_attr_ref a)
*** 6644,6650 ****
case 2:
return DW_FORM_block2;
default:
! abort ();
}
case dw_val_class_const:
return DW_FORM_sdata;
--- 6584,6590 ----
case 2:
return DW_FORM_block2;
default:
! gcc_unreachable ();
}
case dw_val_class_const:
return DW_FORM_sdata;
*************** value_format (dw_attr_ref a)
*** 6660,6666 ****
case 8:
return DW_FORM_data8;
default:
! abort ();
}
case dw_val_class_long_long:
return DW_FORM_block1;
--- 6600,6606 ----
case 8:
return DW_FORM_data8;
default:
! gcc_unreachable ();
}
case dw_val_class_long_long:
return DW_FORM_block1;
*************** value_format (dw_attr_ref a)
*** 6683,6689 ****
return AT_string_form (a);
default:
! abort ();
}
}
--- 6623,6629 ----
return AT_string_form (a);
default:
! gcc_unreachable ();
}
}
*************** output_loc_list (dw_loc_list_ref list_he
*** 6826,6833 ****
size = size_of_locs (curr->expr);
/* Output the block length for this list of location operations. */
! if (size > 0xffff)
! abort ();
dw2_asm_output_data (2, size, "%s", "Location expression size");
output_loc_sequence (curr->expr);
--- 6766,6772 ----
size = size_of_locs (curr->expr);
/* Output the block length for this list of location operations. */
! gcc_assert (size <= 0xffff);
dw2_asm_output_data (2, size, "%s", "Location expression size");
output_loc_sequence (curr->expr);
*************** output_die (dw_die_ref die)
*** 6962,6969 ****
{
char *sym = AT_loc_list (a)->ll_symbol;
! if (sym == 0)
! abort ();
dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, "%s", name);
}
break;
--- 6901,6907 ----
{
char *sym = AT_loc_list (a)->ll_symbol;
! gcc_assert (sym);
dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, "%s", name);
}
break;
*************** output_die (dw_die_ref die)
*** 6973,6987 ****
{
char *sym = AT_ref (a)->die_symbol;
! if (sym == 0)
! abort ();
dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
}
- else if (AT_ref (a)->die_offset == 0)
- abort ();
else
! dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
! "%s", name);
break;
case dw_val_class_fde_ref:
--- 6911,6925 ----
{
char *sym = AT_ref (a)->die_symbol;
! gcc_assert (sym);
dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
}
else
! {
! gcc_assert (AT_ref (a)->die_offset);
! dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
! "%s", name);
! }
break;
case dw_val_class_fde_ref:
*************** output_die (dw_die_ref die)
*** 7012,7018 ****
break;
default:
! abort ();
}
}
--- 6950,6956 ----
break;
default:
! gcc_unreachable ();
}
}
*************** output_pubnames (void)
*** 7155,7162 ****
pubname_ref pub = &pubname_table[i];
/* We shouldn't see pubnames for DIEs outside of the main CU. */
! if (pub->die->die_mark == 0)
! abort ();
dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
"DIE offset");
--- 7093,7099 ----
pubname_ref pub = &pubname_table[i];
/* We shouldn't see pubnames for DIEs outside of the main CU. */
! gcc_assert (pub->die->die_mark);
dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
"DIE offset");
*************** output_aranges (void)
*** 7229,7236 ****
dw_die_ref die = arange_table[i];
/* We shouldn't see aranges for DIEs outside of the main CU. */
! if (die->die_mark == 0)
! abort ();
if (die->die_tag == DW_TAG_subprogram)
{
--- 7166,7172 ----
dw_die_ref die = arange_table[i];
/* We shouldn't see aranges for DIEs outside of the main CU. */
! gcc_assert (die->die_mark);
if (die->die_tag == DW_TAG_subprogram)
{
*************** output_aranges (void)
*** 7247,7258 ****
dw_attr_ref a = get_AT (die, DW_AT_location);
dw_loc_descr_ref loc;
! if (! a || AT_class (a) != dw_val_class_loc)
! abort ();
loc = AT_loc (a);
! if (loc->dw_loc_opc != DW_OP_addr)
! abort ();
dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
loc->dw_loc_oprnd1.v.val_addr, "Address");
--- 7183,7192 ----
dw_attr_ref a = get_AT (die, DW_AT_location);
dw_loc_descr_ref loc;
! gcc_assert (a && AT_class (a) == dw_val_class_loc);
loc = AT_loc (a);
! gcc_assert (loc->dw_loc_opc == DW_OP_addr);
dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
loc->dw_loc_oprnd1.v.val_addr, "Address");
*************** base_type_die (tree type)
*** 8007,8013 ****
default:
/* No other TREE_CODEs are Dwarf fundamental types. */
! abort ();
}
base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
--- 7941,7947 ----
default:
/* No other TREE_CODEs are Dwarf fundamental types. */
! gcc_unreachable ();
}
base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
*************** is_base_type (tree type)
*** 8085,8091 ****
return 0;
default:
! abort ();
}
return 0;
--- 8019,8025 ----
return 0;
default:
! gcc_unreachable ();
}
return 0;
*************** modified_type_die (tree type, int is_con
*** 8323,8330 ****
/* Vectors have the debugging information in the type,
not the main variant. */
mod_type_die = lookup_type_die (type);
! if (mod_type_die == NULL)
! abort ();
}
/* We want to equate the qualified type to the die below. */
--- 8257,8263 ----
/* Vectors have the debugging information in the type,
not the main variant. */
mod_type_die = lookup_type_die (type);
! gcc_assert (mod_type_die);
}
/* We want to equate the qualified type to the die below. */
*************** dbx_reg_number (rtx rtl)
*** 8365,8372 ****
{
unsigned regno = REGNO (rtl);
! if (regno >= FIRST_PSEUDO_REGISTER)
! abort ();
return DBX_REGISTER_NUMBER (regno);
}
--- 8298,8304 ----
{
unsigned regno = REGNO (rtl);
! gcc_assert (regno < FIRST_PSEUDO_REGISTER);
return DBX_REGISTER_NUMBER (regno);
}
*************** multiple_reg_loc_descriptor (rtx rtl, rt
*** 8438,8445 ****
/* Now onto stupid register sets in non contiguous locations. */
! if (GET_CODE (regs) != PARALLEL)
! abort ();
size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
loc_result = NULL;
--- 8370,8376 ----
/* Now onto stupid register sets in non contiguous locations. */
! gcc_assert (GET_CODE (regs) == PARALLEL);
size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
loc_result = NULL;
*************** mem_loc_descriptor (rtx rtl, enum machin
*** 8734,8740 ****
break;
default:
! abort ();
}
return mem_loc_result;
--- 8665,8671 ----
break;
default:
! gcc_unreachable ();
}
return mem_loc_result;
*************** loc_descriptor (rtx rtl, bool can_use_fb
*** 8844,8850 ****
break;
default:
! abort ();
}
return loc_result;
--- 8775,8781 ----
break;
default:
! gcc_unreachable ();
}
return loc_result;
*************** loc_descriptor_from_tree_1 (tree loc, in
*** 9247,9253 ****
#ifdef ENABLE_CHECKING
/* Otherwise this is a generic code; we should just lists all of
these explicitly. Aborting means we forgot one. */
! abort ();
#else
/* In a release build, we want to degrade gracefully: better to
generate incomplete debugging information than to crash. */
--- 9178,9184 ----
#ifdef ENABLE_CHECKING
/* Otherwise this is a generic code; we should just lists all of
these explicitly. Aborting means we forgot one. */
! gcc_unreachable ();
#else
/* In a release build, we want to degrade gracefully: better to
generate incomplete debugging information than to crash. */
*************** field_byte_offset (tree decl)
*** 9350,9357 ****
if (TREE_CODE (decl) == ERROR_MARK)
return 0;
! else if (TREE_CODE (decl) != FIELD_DECL)
! abort ();
type = field_type (decl);
field_size_tree = DECL_SIZE (decl);
--- 9281,9288 ----
if (TREE_CODE (decl) == ERROR_MARK)
return 0;
!
! gcc_assert (TREE_CODE (decl) == FIELD_DECL);
type = field_type (decl);
field_size_tree = DECL_SIZE (decl);
*************** add_data_member_location_attribute (dw_d
*** 9513,9520 ****
/* Calculate the address of the offset. */
offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
! if (offset >= 0)
! abort ();
tmp = int_loc_descriptor (-offset);
add_loc_descr (&loc_descr, tmp);
--- 9444,9450 ----
/* Calculate the address of the offset. */
offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
! gcc_assert (offset < 0);
tmp = int_loc_descriptor (-offset);
add_loc_descr (&loc_descr, tmp);
*************** add_const_value_attribute (dw_die_ref di
*** 9649,9656 ****
else
{
/* ??? We really should be using HOST_WIDE_INT throughout. */
! if (HOST_BITS_PER_LONG != HOST_BITS_PER_WIDE_INT)
! abort ();
add_AT_long_long (die, DW_AT_const_value,
CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
--- 9579,9585 ----
else
{
/* ??? We really should be using HOST_WIDE_INT throughout. */
! gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
add_AT_long_long (die, DW_AT_const_value,
CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
*************** add_const_value_attribute (dw_die_ref di
*** 9667,9698 ****
unsigned int i;
unsigned char *p;
! if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
{
for (i = 0, p = array; i < length; i++, p += elt_size)
{
rtx elt = CONST_VECTOR_ELT (rtl, i);
HOST_WIDE_INT lo, hi;
! if (GET_CODE (elt) == CONST_INT)
{
lo = INTVAL (elt);
hi = -(lo < 0);
! }
! else if (GET_CODE (elt) == CONST_DOUBLE)
! {
lo = CONST_DOUBLE_LOW (elt);
hi = CONST_DOUBLE_HIGH (elt);
}
! else
! abort ();
!
if (elt_size <= sizeof (HOST_WIDE_INT))
insert_int (lo, elt_size, p);
! else if (elt_size == 2 * sizeof (HOST_WIDE_INT))
{
unsigned char *p0 = p;
unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
!
if (WORDS_BIG_ENDIAN)
{
p0 = p1;
--- 9596,9633 ----
unsigned int i;
unsigned char *p;
! switch (GET_MODE_CLASS (mode))
{
+ case MODE_VECTOR_INT:
for (i = 0, p = array; i < length; i++, p += elt_size)
{
rtx elt = CONST_VECTOR_ELT (rtl, i);
HOST_WIDE_INT lo, hi;
!
! switch (GET_CODE (elt))
{
+ case CONST_INT:
lo = INTVAL (elt);
hi = -(lo < 0);
! break;
!
! case CONST_DOUBLE:
lo = CONST_DOUBLE_LOW (elt);
hi = CONST_DOUBLE_HIGH (elt);
+ break;
+
+ default:
+ gcc_unreachable ();
}
!
if (elt_size <= sizeof (HOST_WIDE_INT))
insert_int (lo, elt_size, p);
! else
{
unsigned char *p0 = p;
unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
!
! gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
if (WORDS_BIG_ENDIAN)
{
p0 = p1;
*************** add_const_value_attribute (dw_die_ref di
*** 9701,9720 ****
insert_int (lo, sizeof (HOST_WIDE_INT), p0);
insert_int (hi, sizeof (HOST_WIDE_INT), p1);
}
- else
- abort ();
}
! }
! else if (GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
! {
for (i = 0, p = array; i < length; i++, p += elt_size)
{
rtx elt = CONST_VECTOR_ELT (rtl, i);
insert_float (elt, p);
}
}
- else
- abort ();
add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
}
--- 9636,9655 ----
insert_int (lo, sizeof (HOST_WIDE_INT), p0);
insert_int (hi, sizeof (HOST_WIDE_INT), p1);
}
}
! break;
!
! case MODE_VECTOR_FLOAT:
for (i = 0, p = array; i < length; i++, p += elt_size)
{
rtx elt = CONST_VECTOR_ELT (rtl, i);
insert_float (elt, p);
}
+ break;
+
+ default:
+ gcc_unreachable ();
}
add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
}
*************** add_const_value_attribute (dw_die_ref di
*** 9747,9753 ****
default:
/* No other kinds of rtx should be possible here. */
! abort ();
}
}
--- 9682,9688 ----
default:
/* No other kinds of rtx should be possible here. */
! gcc_unreachable ();
}
}
*************** rtl_for_decl_location (tree decl)
*** 9963,9970 ****
rtl = expand_expr (DECL_INITIAL (decl), NULL_RTX, VOIDmode,
EXPAND_INITIALIZER);
/* If expand_expr returns a MEM, it wasn't immediate. */
! if (rtl && MEM_P (rtl))
! abort ();
}
}
--- 9898,9904 ----
rtl = expand_expr (DECL_INITIAL (decl), NULL_RTX, VOIDmode,
EXPAND_INITIALIZER);
/* If expand_expr returns a MEM, it wasn't immediate. */
! gcc_assert (!rtl || !MEM_P (rtl));
}
}
*************** add_location_or_const_value_attribute (d
*** 10001,10009 ****
if (TREE_CODE (decl) == ERROR_MARK)
return;
! else if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL
! && TREE_CODE (decl) != RESULT_DECL)
! abort ();
/* See if we possibly have multiple locations for this variable. */
loc_list = lookup_decl_loc (decl);
--- 9935,9943 ----
if (TREE_CODE (decl) == ERROR_MARK)
return;
!
! gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
! || TREE_CODE (decl) == RESULT_DECL);
/* See if we possibly have multiple locations for this variable. */
loc_list = lookup_decl_loc (decl);
*************** add_byte_size_attribute (dw_die_ref die,
*** 10344,10350 ****
size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
break;
default:
! abort ();
}
/* Note that `size' might be -1 when we get to this point. If it is, that
--- 10278,10284 ----
size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
break;
default:
! gcc_unreachable ();
}
/* Note that `size' might be -1 when we get to this point. If it is, that
*************** add_bit_offset_attribute (dw_die_ref die
*** 10381,10389 ****
HOST_WIDE_INT unsigned bit_offset;
/* Must be a field and a bit field. */
! if (!type
! || TREE_CODE (decl) != FIELD_DECL)
! abort ();
/* We can't yet handle bit-fields whose offsets are variable, so if we
encounter such things, just return without generating any attribute
--- 10315,10321 ----
HOST_WIDE_INT unsigned bit_offset;
/* Must be a field and a bit field. */
! gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
/* We can't yet handle bit-fields whose offsets are variable, so if we
encounter such things, just return without generating any attribute
*************** static inline void
*** 10423,10431 ****
add_bit_size_attribute (dw_die_ref die, tree decl)
{
/* Must be a field and a bit field. */
! if (TREE_CODE (decl) != FIELD_DECL
! || ! DECL_BIT_FIELD_TYPE (decl))
! abort ();
if (host_integerp (DECL_SIZE (decl), 1))
add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
--- 10355,10362 ----
add_bit_size_attribute (dw_die_ref die, tree decl)
{
/* Must be a field and a bit field. */
! gcc_assert (TREE_CODE (decl) == FIELD_DECL
! && DECL_BIT_FIELD_TYPE (decl));
if (host_integerp (DECL_SIZE (decl), 1))
add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
*************** add_abstract_origin_attribute (dw_die_re
*** 10474,10481 ****
else if (TYPE_P (origin))
origin_die = lookup_type_die (origin);
! if (origin_die == NULL)
! abort ();
add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
}
--- 10405,10411 ----
else if (TYPE_P (origin))
origin_die = lookup_type_die (origin);
! gcc_assert (origin_die);
add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
}
*************** push_decl_scope (tree scope)
*** 10562,10569 ****
static inline void
pop_decl_scope (void)
{
! if (VARRAY_ACTIVE_SIZE (decl_scope_table) <= 0)
! abort ();
VARRAY_POP (decl_scope_table);
}
--- 10492,10498 ----
static inline void
pop_decl_scope (void)
{
! gcc_assert (VARRAY_ACTIVE_SIZE (decl_scope_table) > 0);
VARRAY_POP (decl_scope_table);
}
*************** scope_die_for (tree t, dw_die_ref contex
*** 10582,10589 ****
int i;
/* Non-types always go in the current scope. */
! if (! TYPE_P (t))
! abort ();
containing_scope = TYPE_CONTEXT (t);
--- 10511,10517 ----
int i;
/* Non-types always go in the current scope. */
! gcc_assert (TYPE_P (t));
containing_scope = TYPE_CONTEXT (t);
*************** scope_die_for (tree t, dw_die_ref contex
*** 10615,10623 ****
if (i < 0)
{
! if (debug_info_level > DINFO_LEVEL_TERSE
! && !TREE_ASM_WRITTEN (containing_scope))
! abort ();
/* If none of the current dies are suitable, we get file scope. */
scope_die = comp_unit_die;
--- 10543,10550 ----
if (i < 0)
{
! gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
! || TREE_ASM_WRITTEN (containing_scope));
/* If none of the current dies are suitable, we get file scope. */
scope_die = comp_unit_die;
*************** decl_start_label (tree decl)
*** 10744,10755 ****
const char *fnname;
x = DECL_RTL (decl);
! if (!MEM_P (x))
! abort ();
x = XEXP (x, 0);
! if (GET_CODE (x) != SYMBOL_REF)
! abort ();
fnname = XSTR (x, 0);
return fnname;
--- 10671,10680 ----
const char *fnname;
x = DECL_RTL (decl);
! gcc_assert (MEM_P (x));
x = XEXP (x, 0);
! gcc_assert (GET_CODE (x) == SYMBOL_REF);
fnname = XSTR (x, 0);
return fnname;
*************** gen_formal_parameter_die (tree node, dw_
*** 11018,11024 ****
break;
default:
! abort ();
}
return parm_die;
--- 10943,10949 ----
break;
default:
! gcc_unreachable ();
}
return parm_die;
*************** gen_type_die_for_member (tree type, tree
*** 11107,11114 ****
if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
&& ! lookup_decl_die (member))
{
! if (decl_ultimate_origin (member))
! abort ();
push_decl_scope (type);
if (TREE_CODE (member) == FUNCTION_DECL)
--- 11032,11038 ----
if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
&& ! lookup_decl_die (member))
{
! gcc_assert (!decl_ultimate_origin (member));
push_decl_scope (type);
if (TREE_CODE (member) == FUNCTION_DECL)
*************** gen_subprogram_die (tree decl, dw_die_re
*** 11187,11200 ****
if (origin && declaration && class_or_namespace_scope_p (context_die))
{
origin = NULL;
! if (old_die)
! abort ();
}
if (origin != NULL)
{
! if (declaration && ! local_scope_p (context_die))
! abort ();
/* Fixup die_parent for the abstract instance of a nested
inline function. */
--- 11111,11122 ----
if (origin && declaration && class_or_namespace_scope_p (context_die))
{
origin = NULL;
! gcc_assert (!old_die);
}
if (origin != NULL)
{
! gcc_assert (!declaration || local_scope_p (context_die));
/* Fixup die_parent for the abstract instance of a nested
inline function. */
*************** gen_subprogram_die (tree decl, dw_die_re
*** 11220,11228 ****
we should detect this case and ignore it. For now, if we have
already reported an error, any error at all, then assume that
we got here because of an input error, not a dwarf2 bug. */
! if (errorcount)
! return;
! abort ();
}
/* If the definition comes from the same place as the declaration,
--- 11142,11149 ----
we should detect this case and ignore it. For now, if we have
already reported an error, any error at all, then assume that
we got here because of an input error, not a dwarf2 bug. */
! gcc_assert (errorcount);
! return;
}
/* If the definition comes from the same place as the declaration,
*************** gen_label_die (tree decl, dw_die_ref con
*** 11563,11570 ****
represent source-level labels which were explicitly declared by
the user. This really shouldn't be happening though, so catch
it if it ever does happen. */
! if (INSN_DELETED_P (insn))
! abort ();
ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
--- 11484,11490 ----
represent source-level labels which were explicitly declared by
the user. This really shouldn't be happening though, so catch
it if it ever does happen. */
! gcc_assert (!INSN_DELETED_P (insn));
ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
*************** gen_typedef_die (tree decl, dw_die_ref c
*** 12022,12031 ****
{
type = DECL_ORIGINAL_TYPE (decl);
! if (type == TREE_TYPE (decl))
! abort ();
! else
! equate_type_number_to_die (TREE_TYPE (decl), type_die);
}
else
type = TREE_TYPE (decl);
--- 11942,11949 ----
{
type = DECL_ORIGINAL_TYPE (decl);
! gcc_assert (type != TREE_TYPE (decl));
! equate_type_number_to_die (TREE_TYPE (decl), type_die);
}
else
type = TREE_TYPE (decl);
*************** gen_type_die (tree type, dw_die_ref cont
*** 12055,12062 ****
return;
/* Prevent broken recursion; we can't hand off to the same type. */
! if (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) == type)
! abort ();
TREE_ASM_WRITTEN (type) = 1;
gen_decl_die (TYPE_NAME (type), context_die);
--- 11973,11979 ----
return;
/* Prevent broken recursion; we can't hand off to the same type. */
! gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
TREE_ASM_WRITTEN (type) = 1;
gen_decl_die (TYPE_NAME (type), context_die);
*************** gen_type_die (tree type, dw_die_ref cont
*** 12113,12119 ****
case FILE_TYPE:
gen_type_die (TREE_TYPE (type), context_die);
! abort (); /* No way to represent these in Dwarf yet! */
break;
case FUNCTION_TYPE:
--- 12030,12037 ----
case FILE_TYPE:
gen_type_die (TREE_TYPE (type), context_die);
! /* No way to represent these in Dwarf yet! */
! gcc_unreachable ();
break;
case FUNCTION_TYPE:
*************** gen_type_die (tree type, dw_die_ref cont
*** 12199,12205 ****
break;
default:
! abort ();
}
TREE_ASM_WRITTEN (type) = 1;
--- 12117,12123 ----
break;
default:
! gcc_unreachable ();
}
TREE_ASM_WRITTEN (type) = 1;
*************** gen_tagged_type_instantiation_die (tree
*** 12217,12224 ****
this type (i.e. without any const or volatile qualifiers) so make sure
that we have the main variant (i.e. the unqualified version) of this
type now. */
! if (type != type_main_variant (type))
! abort ();
/* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
an instance of an unresolved type. */
--- 12135,12141 ----
this type (i.e. without any const or volatile qualifiers) so make sure
that we have the main variant (i.e. the unqualified version) of this
type now. */
! gcc_assert (type == type_main_variant (type));
/* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
an instance of an unresolved type. */
*************** gen_tagged_type_instantiation_die (tree
*** 12242,12248 ****
break;
default:
! abort ();
}
}
--- 12159,12165 ----
break;
default:
! gcc_unreachable ();
}
}
*************** force_decl_die (tree decl)
*** 12453,12467 ****
break;
default:
! abort ();
}
/* See if we can find the die for this deci now.
If not then abort. */
if (!decl_die)
decl_die = lookup_decl_die (decl);
! if (!decl_die)
! abort ();
}
return decl_die;
--- 12370,12383 ----
break;
default:
! gcc_unreachable ();
}
/* See if we can find the die for this deci now.
If not then abort. */
if (!decl_die)
decl_die = lookup_decl_die (decl);
! gcc_assert (decl_die);
}
return decl_die;
*************** force_type_die (tree type)
*** 12488,12495 ****
gen_type_die (type, context_die);
type_die = lookup_type_die (type);
! if (!type_die)
! abort();
}
return type_die;
}
--- 12404,12410 ----
gen_type_die (type, context_die);
type_die = lookup_type_die (type);
! gcc_assert (type_die);
}
return type_die;
}
*************** gen_decl_die (tree decl, dw_die_ref cont
*** 12726,12735 ****
break;
default:
! if ((int)TREE_CODE (decl) > NUM_TREE_CODES)
! /* Probably some frontend-internal decl. Assume we don't care. */
! break;
! abort ();
}
}
--- 12641,12649 ----
break;
default:
! /* Probably some frontend-internal decl. Assume we don't care. */
! gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
! break;
}
}
*************** dwarf2out_imported_module_or_decl (tree
*** 12791,12798 ****
if (debug_info_level <= DINFO_LEVEL_TERSE)
return;
! if (!decl)
! abort ();
/* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
We need decl DIE for reference and scope die. First, get DIE for the decl
--- 12705,12711 ----
if (debug_info_level <= DINFO_LEVEL_TERSE)
return;
! gcc_assert (decl);
/* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
We need decl DIE for reference and scope die. First, get DIE for the decl
*************** static void
*** 13523,13530 ****
prune_unused_types_prune (dw_die_ref die)
{
dw_die_ref c, p, n;
! if (!die->die_mark)
! abort();
p = NULL;
for (c = die->die_child; c; c = n)
--- 13436,13443 ----
prune_unused_types_prune (dw_die_ref die)
{
dw_die_ref c, p, n;
!
! gcc_assert (die->die_mark);
p = NULL;
for (c = die->die_child; c; c = n)
*************** dwarf2out_finish (const char *filename)
*** 13623,13629 ****
if (die->die_parent == NULL)
{
dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
- tree context;
if (origin)
add_child_die (origin->die_parent, die);
--- 13536,13541 ----
*************** dwarf2out_finish (const char *filename)
*** 13632,13656 ****
else if (errorcount > 0 || sorrycount > 0)
/* It's OK to be confused by errors in the input. */
add_child_die (comp_unit_die, die);
! else if (node->created_for
! && ((DECL_P (node->created_for)
! && (context = DECL_CONTEXT (node->created_for)))
! || (TYPE_P (node->created_for)
! && (context = TYPE_CONTEXT (node->created_for))))
! && TREE_CODE (context) == FUNCTION_DECL)
{
/* In certain situations, the lexical block containing a
nested function can be optimized away, which results
in the nested function die being orphaned. Likewise
with the return type of that nested function. Force
this to be a child of the containing function. */
origin = lookup_decl_die (context);
! if (! origin)
! abort ();
add_child_die (origin, die);
}
- else
- abort ();
}
}
--- 13544,13571 ----
else if (errorcount > 0 || sorrycount > 0)
/* It's OK to be confused by errors in the input. */
add_child_die (comp_unit_die, die);
! else
{
/* In certain situations, the lexical block containing a
nested function can be optimized away, which results
in the nested function die being orphaned. Likewise
with the return type of that nested function. Force
this to be a child of the containing function. */
+ tree context = NULL_TREE;
+
+ gcc_assert (node->created_for);
+
+ if (DECL_P (node->created_for))
+ context = DECL_CONTEXT (node->created_for);
+ else if (TYPE_P (node->created_for))
+ context = TYPE_CONTEXT (node->created_for);
+
+ gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
+
origin = lookup_decl_die (context);
! gcc_assert (origin);
add_child_die (origin, die);
}
}
}