From ced3f397be6d68ba9a838ee7e3f27c456238501a Mon Sep 17 00:00:00 2001 From: Nathan Sidwell Date: Wed, 8 Sep 2004 07:47:45 +0000 Subject: dbxout.c (dbxout_type, [...]): Use gcc_assert and gcc_unreachable. * 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. From-SVN: r87176 --- gcc/df.c | 96 +++++++++++++++++++++++----------------------------------------- 1 file changed, 35 insertions(+), 61 deletions(-) (limited to 'gcc/df.c') diff --git a/gcc/df.c b/gcc/df.c index cf3889d..f4173c6 100644 --- a/gcc/df.c +++ b/gcc/df.c @@ -648,8 +648,8 @@ df_ref_unlink (struct df_link **phead, struct ref *ref) /* 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 (); + gcc_assert (link->ref == ref); + /* Now have an empty chain. */ *phead = NULL; } @@ -808,8 +808,7 @@ df_ref_record (struct df *df, rtx reg, rtx *loc, rtx insn, { unsigned int regno; - if (!REG_P (reg) && GET_CODE (reg) != SUBREG) - abort (); + 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 @@ -1040,10 +1039,10 @@ df_uses_record (struct df *df, rtx *loc, enum df_ref_type ref_type, bb, insn, 0); break; case STRICT_LOW_PART: - /* A strict_low_part uses the whole REG and not just the SUBREG. */ + /* A strict_low_part uses the whole REG and not just the + SUBREG. */ dst = XEXP (dst, 0); - if (GET_CODE (dst) != SUBREG) - abort (); + gcc_assert (GET_CODE (dst) == SUBREG); df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb, insn, DF_REF_READ_WRITE); break; @@ -1056,7 +1055,7 @@ df_uses_record (struct df *df, rtx *loc, enum df_ref_type ref_type, dst = XEXP (dst, 0); break; default: - abort (); + gcc_unreachable (); } return; } @@ -1311,8 +1310,7 @@ df_reg_def_chain_create (struct df *df, bitmap blocks, bool redo) { #ifdef ENABLE_CHECKING for (regno = 0; regno < df->n_regs; regno++) - if (df->regs[regno].defs) - abort (); + gcc_assert (!df->regs[regno].defs); #endif /* Pretend that all defs are new. */ @@ -1393,8 +1391,7 @@ df_reg_use_chain_create (struct df *df, bitmap blocks, bool redo) { #ifdef ENABLE_CHECKING for (regno = 0; regno < df->n_regs; regno++) - if (df->regs[regno].uses) - abort (); + gcc_assert (!df->regs[regno].uses); #endif /* Pretend that all uses are new. */ @@ -2298,8 +2295,7 @@ df_analyze (struct df *df, bitmap blocks, int flags) /* 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 (); + gcc_assert (!df->n_bbs || df->n_bbs == (unsigned int) last_basic_block); update = df_modified_p (df, blocks); if (update || (flags != df->flags)) @@ -2321,8 +2317,7 @@ df_analyze (struct df *df, bitmap blocks, int flags) if (blocks == (bitmap) -1) blocks = df->bbs_modified; - if (! df->n_bbs) - abort (); + gcc_assert (df->n_bbs); df_analyze_1 (df, blocks, flags, 1); bitmap_zero (df->bbs_modified); @@ -2631,8 +2626,7 @@ df_insn_delete (struct df *df, basic_block bb ATTRIBUTE_UNUSED, rtx insn) handle the JUMP_LABEL? */ /* We should not be deleting the NOTE_INSN_BASIC_BLOCK or label. */ - if (insn == BB_HEAD (bb)) - abort (); + gcc_assert (insn != BB_HEAD (bb)); /* Delete the insn. */ delete_insn (insn); @@ -2796,24 +2790,17 @@ df_refs_reg_replace (struct df *df, bitmap blocks, struct df_link *chain, rtx ol if (! INSN_P (insn)) continue; - if (bitmap_bit_p (blocks, DF_REF_BBNO (ref))) - { - df_ref_reg_replace (df, ref, oldreg, newreg); + 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); - } - } - else + /* 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)) { - /* Temporary check to ensure that we have a grip on which - regs should be replaced. */ - abort (); + args.insn = insn; + for_each_rtx (®_NOTES (insn), df_rtx_reg_replace, &args); } } } @@ -2844,8 +2831,7 @@ df_ref_reg_replace (struct df *df, struct ref *ref, rtx oldreg, rtx newreg) if (! INSN_P (DF_REF_INSN (ref))) return 0; - if (oldreg && oldreg != DF_REF_REG (ref)) - abort (); + gcc_assert (!oldreg || oldreg == DF_REF_REG (ref)); if (! validate_change (DF_REF_INSN (ref), DF_REF_LOC (ref), newreg, 1)) return 0; @@ -2911,10 +2897,8 @@ df_insns_modify (struct df *df, basic_block bb, rtx first_insn, rtx last_insn) /* 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 (); + gcc_assert ((!CALL_P (insn) || CONST_OR_PURE_CALL_P (insn)) + && !LABEL_P (insn)); uid = INSN_UID (insn); @@ -2937,8 +2921,7 @@ df_pattern_emit_before (struct df *df, rtx pattern, basic_block bb, rtx insn) rtx prev_insn = PREV_INSN (insn); /* We should not be inserting before the start of the block. */ - if (insn == BB_HEAD (bb)) - abort (); + gcc_assert (insn != BB_HEAD (bb)); ret_insn = emit_insn_before (pattern, insn); if (ret_insn == insn) return ret_insn; @@ -3196,10 +3179,7 @@ df_bb_reg_live_start_p (struct df *df, basic_block bb, rtx reg) { struct bb_info *bb_info = DF_BB_INFO (df, bb); -#ifdef ENABLE_CHECKING - if (! bb_info->lr_in) - abort (); -#endif + gcc_assert (bb_info->lr_in); return bitmap_bit_p (bb_info->lr_in, REGNO (reg)); } @@ -3211,10 +3191,7 @@ df_bb_reg_live_end_p (struct df *df, basic_block bb, rtx reg) { struct bb_info *bb_info = DF_BB_INFO (df, bb); -#ifdef ENABLE_CHECKING - if (! bb_info->lr_in) - abort (); -#endif + gcc_assert (bb_info->lr_in); return bitmap_bit_p (bb_info->lr_out, REGNO (reg)); } @@ -3234,9 +3211,8 @@ df_bb_regs_lives_compare (struct df *df, basic_block bb, rtx reg1, rtx reg2) /* The regs must be local to BB. */ - if (df_regno_bb (df, regno1) != bb - || df_regno_bb (df, regno2) != bb) - abort (); + 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); @@ -3380,8 +3356,7 @@ df_bb_single_def_use_insn_find (struct df *df, basic_block bb, rtx insn, rtx reg def = df_bb_insn_regno_first_def_find (df, bb, insn, REGNO (reg)); - if (! def) - abort (); + gcc_assert (def); du_link = DF_REF_CHAIN (def); @@ -3761,7 +3736,7 @@ dataflow_set_a_op_b (enum set_representation repr, break; default: - abort (); + gcc_unreachable (); } break; @@ -3777,12 +3752,12 @@ dataflow_set_a_op_b (enum set_representation repr, break; default: - abort (); + gcc_unreachable (); } break; default: - abort (); + gcc_unreachable (); } } @@ -3800,7 +3775,7 @@ dataflow_set_copy (enum set_representation repr, void *dest, void *src) break; default: - abort (); + gcc_unreachable (); } } @@ -3816,8 +3791,7 @@ hybrid_search (basic_block bb, struct dataflow *dataflow, edge e; SET_BIT (visited, bb->index); - if (!TEST_BIT (pending, bb->index)) - abort (); + 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, \ -- cgit v1.1