diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 78e651b0d98d49bd20122cff9c7afe9a9ce826d1..c589b3418a70a9b57ae52404b36c2a9848bedf55 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,29 @@
+2004-08-30 Nathan Sidwell <nathan@codesourcery.com>
+
+ * name-lookup.c (pop_binding, pushdecl,
+ set_identifier_type_value_with_scope, push_overloaded_decl,
+ arg_assoc_type): Replace abort with gcc_assert or gcc_unreachable.
+ * parser.c (cp_parser_diagnose_invalid_type_name,
+ cp_parser_postfix_expression, cp_parser_unary_expression,
+ cp_parser_check_declarator_template_para): Likewise.
+ * pt.c (push_inline_template_parms_recursive,
+ check_explicit_specialization, convert_nontype_argument,
+ coerce_template_template_parms, uses_template_parms,
+ instantiate_class_template, tsubst_decl, tsubst, tsubst_copy,
+ tsubst_expr, instantiate_template,
+ maybe_adjust_types_for_deduction, type_unification_real,
+ resolve_overloaded_unification, template_decl_level,
+ type_dependent_expression_p): Likewise.
+ * search.c (lookup_base_r): Likewise.
+ * semantics.c (finish_stmt_expr, simplify_aggr_init_expr): Likewise.
+ * tree.c (lvalue_p_1, count_functions, cxx_printable_name,
+ verify_stmt_tree_r, get_type_decl, stabilize_call): Likewise.
+ * typeck.c (common_type, get_member_function_from_ptrfunc,
+ build_binary_op, build_unary_op, expand_ptrmemfunc_cst): Likewise.
+ * typeck2.c (cxx_incomplete_type_diagnostic,
+ split_nonconstant_init_1, store_init_value,
+ process_init_constructor): Likewise.
+
2004-08-30 Nathan Sidwell <nathan@codesourcery.com>
* call.c (check_dtor_name): Replace abort with gcc_assert or
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
index 47f8cc262d5ed6338aff62b9ba5e287796251145..5ca98a9a8ff28b46130017868b6d5c828557def2 100644
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -457,10 +457,11 @@ pop_binding (tree id, tree decl)
binding for this identifier. Remove that binding. */
if (binding->value == decl)
binding->value = NULL_TREE;
- else if (binding->type == decl)
- binding->type = NULL_TREE;
else
- abort ();
+ {
+ gcc_assert (binding->type == decl);
+ binding->type = NULL_TREE;
+ }
if (!binding->value && !binding->type)
{
@@ -745,10 +746,7 @@ pushdecl (tree x)
}
else if (TREE_CODE (t) == PARM_DECL)
{
- if (DECL_CONTEXT (t) == NULL_TREE)
- /* This is probably caused by too many errors, but calling
- abort will say that if errors have occurred. */
- abort ();
+ gcc_assert (DECL_CONTEXT (t));
/* Check for duplicate params. */
if (duplicate_decls (x, t))
@@ -1759,15 +1757,12 @@ set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
{
cxx_binding *binding =
binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
- if (decl)
- {
- if (binding->value)
- supplement_binding (binding, decl);
- else
- binding->value = decl;
- }
+ gcc_assert (decl);
+ if (binding->value)
+ supplement_binding (binding, decl);
else
- abort ();
+ binding->value = decl;
+
/* Store marker instead of real type. */
type = global_type_node;
}
@@ -2098,7 +2093,7 @@ push_overloaded_decl (tree decl, int flags)
}
/* We should always find a previous binding in this case. */
- abort ();
+ gcc_unreachable ();
}
/* Install the new binding. */
@@ -4476,11 +4471,10 @@ arg_assoc_type (struct arg_lookup *k, tree type)
case TYPENAME_TYPE:
return false;
case LANG_TYPE:
- if (type == unknown_type_node)
- return false;
- /* else fall through */
+ gcc_assert (type == unknown_type_node);
+ return false;
default:
- abort ();
+ gcc_unreachable ();
}
return false;
}
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index c0d5227a7a163baef243ca4781e4835c175c8219..b0064420f192f88f812793330462072a7db0272a 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -2230,7 +2230,7 @@ cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree scope, tree id)
error ("`%E' in class `%T' does not name a type",
id, parser->scope);
else
- abort();
+ gcc_unreachable ();
}
}
@@ -3806,7 +3806,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
= build_const_cast (type, expression);
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
break;
@@ -4177,7 +4177,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
}
/* We should never get here. */
- abort ();
+ gcc_unreachable ();
return error_mark_node;
}
@@ -4741,7 +4741,7 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p)
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (non_constant_p
@@ -14460,9 +14460,9 @@ cp_parser_check_declarator_template_parameters (cp_parser* parser,
return true;
default:
- abort ();
- return false;
+ gcc_unreachable ();
}
+ return false;
}
/* NUM_TEMPLATES were used in the current declaration. If that is
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index a979e83896f27846183aa3529c53228f7569b979..d7335a06e6b69a248b2da03dbf7d31814ba19aab 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -384,7 +384,7 @@ push_inline_template_parms_recursive (tree parmlist, int levels)
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
}
@@ -1759,7 +1759,7 @@ check_explicit_specialization (tree declarator,
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (specialization || member_specialization)
@@ -3597,8 +3597,7 @@ convert_nontype_argument (tree type, tree expr)
default:
/* All non-type parameters must have one of these types. */
- abort ();
- break;
+ gcc_unreachable ();
}
return error_mark_node;
@@ -3690,7 +3689,7 @@ coerce_template_template_parms (tree parm_parms,
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
return 1;
@@ -4890,10 +4889,12 @@ uses_template_parms (tree t)
|| TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
dependent_p = (type_dependent_expression_p (t)
|| value_dependent_expression_p (t));
- else if (t == error_mark_node)
- dependent_p = false;
- else
- abort ();
+ else
+ {
+ gcc_assert (t == error_mark_node);
+ dependent_p = false;
+ }
+
processing_template_decl = saved_processing_template_decl;
return dependent_p;
@@ -5470,16 +5471,13 @@ instantiate_class_template (tree type)
pbinfo = TYPE_BINFO (pattern);
-#ifdef ENABLE_CHECKING
- if (DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
- && ! COMPLETE_TYPE_P (TYPE_CONTEXT (type))
- && ! TYPE_BEING_DEFINED (TYPE_CONTEXT (type)))
- /* We should never instantiate a nested class before its enclosing
- class; we need to look up the nested class by name before we can
- instantiate it, and that lookup should instantiate the enclosing
- class. */
- abort ();
-#endif
+ /* We should never instantiate a nested class before its enclosing
+ class; we need to look up the nested class by name before we can
+ instantiate it, and that lookup should instantiate the enclosing
+ class. */
+ gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
+ || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
+ || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
base_list = NULL_TREE;
if (BINFO_N_BASE_BINFOS (pbinfo))
@@ -6535,7 +6533,7 @@ tsubst_decl (tree t, tree args, tree type, tsubst_flags_t complain)
break;
default:
- abort ();
+ gcc_unreachable ();
}
/* Restore the file and line information. */
@@ -6813,9 +6811,11 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
int idx;
int level;
int levels;
+ tree arg = NULL_TREE;
r = NULL_TREE;
+ gcc_assert (TREE_VEC_LENGTH (args) > 0);
if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
|| TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
|| TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
@@ -6829,57 +6829,50 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
level = TEMPLATE_PARM_LEVEL (t);
}
- if (TREE_VEC_LENGTH (args) > 0)
- {
- tree arg = NULL_TREE;
+ levels = TMPL_ARGS_DEPTH (args);
+ if (level <= levels)
+ arg = TMPL_ARG (args, level, idx);
- levels = TMPL_ARGS_DEPTH (args);
- if (level <= levels)
- arg = TMPL_ARG (args, level, idx);
-
- if (arg == error_mark_node)
- return error_mark_node;
- else if (arg != NULL_TREE)
+ if (arg == error_mark_node)
+ return error_mark_node;
+ else if (arg != NULL_TREE)
+ {
+ if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
{
- if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
- {
- gcc_assert (TYPE_P (arg));
- return cp_build_qualified_type_real
- (arg, cp_type_quals (arg) | cp_type_quals (t),
- complain | tf_ignore_bad_quals);
- }
- else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
- {
- /* We are processing a type constructed from
- a template template parameter. */
- tree argvec = tsubst (TYPE_TI_ARGS (t),
- args, complain, in_decl);
- if (argvec == error_mark_node)
- return error_mark_node;
+ gcc_assert (TYPE_P (arg));
+ return cp_build_qualified_type_real
+ (arg, cp_type_quals (arg) | cp_type_quals (t),
+ complain | tf_ignore_bad_quals);
+ }
+ else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
+ {
+ /* We are processing a type constructed from a
+ template template parameter. */
+ tree argvec = tsubst (TYPE_TI_ARGS (t),
+ args, complain, in_decl);
+ if (argvec == error_mark_node)
+ return error_mark_node;
- /* We can get a TEMPLATE_TEMPLATE_PARM here when
- we are resolving nested-types in the signature of
- a member function templates.
- Otherwise ARG is a TEMPLATE_DECL and is the real
- template to be instantiated. */
- if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
- arg = TYPE_NAME (arg);
-
- r = lookup_template_class (arg,
- argvec, in_decl,
- DECL_CONTEXT (arg),
- /*entering_scope=*/0,
- complain);
- return cp_build_qualified_type_real
- (r, TYPE_QUALS (t), complain);
- }
- else
- /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
- return arg;
+ /* We can get a TEMPLATE_TEMPLATE_PARM here when we
+ are resolving nested-types in the signature of a
+ member function templates. Otherwise ARG is a
+ TEMPLATE_DECL and is the real template to be
+ instantiated. */
+ if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
+ arg = TYPE_NAME (arg);
+
+ r = lookup_template_class (arg,
+ argvec, in_decl,
+ DECL_CONTEXT (arg),
+ /*entering_scope=*/0,
+ complain);
+ return cp_build_qualified_type_real
+ (r, TYPE_QUALS (t), complain);
}
+ else
+ /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
+ return arg;
}
- else
- abort ();
if (level == 1)
/* This can happen during the attempted tsubst'ing in
@@ -6932,7 +6925,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
break;
default:
- abort ();
+ gcc_unreachable ();
}
return r;
@@ -6975,7 +6968,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
case TREE_BINFO:
/* We should never be tsubsting a binfo. */
- abort ();
+ gcc_unreachable ();
case TREE_VEC:
/* A vector of template arguments. */
@@ -7251,7 +7244,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
case INDIRECT_REF:
case ADDR_EXPR:
case CALL_EXPR:
- abort ();
+ gcc_unreachable ();
case ARRAY_REF:
{
@@ -7501,7 +7494,7 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
/* We didn't find the name. That should never happen; if
name-lookup found it during preliminary parsing, we
should find it again here during instantiation. */
- abort ();
+ gcc_unreachable ();
}
return t;
@@ -7786,7 +7779,7 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
/* We shouldn't have built any of these during initial template
generation. Instead, they should be built during instantiation
in response to the saved STMT_IS_FULL_EXPR_P setting. */
- abort ();
+ gcc_unreachable ();
default:
return t;
@@ -8098,10 +8091,10 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
return fold_offsetof (t);
default:
- if (!STATEMENT_CODE_P (TREE_CODE (t)))
- return tsubst_copy_and_build (t, args, complain, in_decl,
- /*function_p=*/false);
- abort ();
+ gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
+
+ return tsubst_copy_and_build (t, args, complain, in_decl,
+ /*function_p=*/false);
}
return NULL_TREE;
@@ -8734,7 +8727,7 @@ instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
if (DECL_NAME (clone) == DECL_NAME (tmpl))
return clone;
/* We should always have found the clone by now. */
- abort ();
+ gcc_unreachable ();
return NULL_TREE;
}
@@ -8996,7 +8989,7 @@ maybe_adjust_types_for_deduction (unification_kind_t strict,
}
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (TREE_CODE (*parm) != REFERENCE_TYPE)
@@ -9095,7 +9088,7 @@ type_unification_real (tree tparms,
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (xlen == 0)
@@ -9283,16 +9276,16 @@ resolve_overloaded_unification (tree tparms,
}
}
}
- else if (TREE_CODE (arg) == OVERLOAD
- || TREE_CODE (arg) == FUNCTION_DECL)
+ else
{
+ gcc_assert (TREE_CODE (arg) == OVERLOAD
+ || TREE_CODE (arg) == FUNCTION_DECL);
+
for (; arg; arg = OVL_NEXT (arg))
good += try_one_overload (tparms, targs, tempargs, parm,
TREE_TYPE (OVL_CURRENT (arg)),
strict, sub_strict, addr_p);
}
- else
- abort ();
/* [temp.deduct.type] A template-argument can be deduced from a pointer
to function or pointer to member function argument if the set of
@@ -9593,9 +9586,9 @@ template_decl_level (tree decl)
return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
default:
- abort ();
- return 0;
+ gcc_unreachable ();
}
+ return 0;
}
/* Decide whether ARG can be unified with PARM, considering only the
@@ -11959,6 +11952,7 @@ type_dependent_expression_p (tree expression)
if (TREE_CODE (expression) == BASELINK)
expression = BASELINK_FUNCTIONS (expression);
+
if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
{
if (any_dependent_template_arguments_p
@@ -11966,17 +11960,15 @@ type_dependent_expression_p (tree expression)
return true;
expression = TREE_OPERAND (expression, 0);
}
- if (TREE_CODE (expression) == OVERLOAD)
+ gcc_assert (TREE_CODE (expression) == OVERLOAD);
+
+ while (expression)
{
- while (expression)
- {
- if (type_dependent_expression_p (OVL_CURRENT (expression)))
- return true;
- expression = OVL_NEXT (expression);
- }
- return false;
+ if (type_dependent_expression_p (OVL_CURRENT (expression)))
+ return true;
+ expression = OVL_NEXT (expression);
}
- abort ();
+ return false;
}
return (dependent_type_p (TREE_TYPE (expression)));
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 2c5ec6b6808f54c31b9402e0baa88f5068af289b..d2b29f8977be9f0f33e984ae060f2e541404709d 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -161,7 +161,7 @@ lookup_base_r (tree binfo, tree base, base_access access,
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
return found;
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index a6aea7be3c5cfb8f07c44eef44f8a83f0a770544..cadb5a7e0381cfcc0535bde2f16b7f0cbc71cd2d 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -1563,7 +1563,7 @@ finish_stmt_expr (tree stmt_expr, bool has_no_scope)
result_stmt_p = &TREE_OPERAND (t, 0);
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
type = TREE_TYPE (EXPR_STMT_EXPR (result_stmt));
@@ -1601,10 +1601,8 @@ finish_stmt_expr (tree stmt_expr, bool has_no_scope)
returning a value directly, give it the appropriate type. */
if (VOID_TYPE_P (TREE_TYPE (result)))
TREE_TYPE (result) = type;
- else if (same_type_p (TREE_TYPE (result), type))
- ;
else
- abort ();
+ gcc_assert (same_type_p (TREE_TYPE (result), type));
}
else if (TREE_CODE (result) == STATEMENT_LIST)
/* We need to wrap a STATEMENT_LIST in a BIND_EXPR so it can have a
@@ -2771,12 +2769,11 @@ simplify_aggr_init_expr (tree *tp)
else if (1)
style = pcc;
#endif
- else if (TREE_ADDRESSABLE (type))
- style = arg;
else
- /* We shouldn't build an AGGR_INIT_EXPR if we don't need any special
- handling. See build_cplus_new. */
- abort ();
+ {
+ gcc_assert (TREE_ADDRESSABLE (type));
+ style = arg;
+ }
if (style == ctor || style == arg)
{
@@ -2793,11 +2790,9 @@ simplify_aggr_init_expr (tree *tp)
{
/* The return type might have different cv-quals from the slot. */
tree fntype = TREE_TYPE (TREE_TYPE (fn));
-#ifdef ENABLE_CHECKING
- if (TREE_CODE (fntype) != FUNCTION_TYPE
- && TREE_CODE (fntype) != METHOD_TYPE)
- abort ();
-#endif
+
+ gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
+ || TREE_CODE (fntype) == METHOD_TYPE);
addr = convert (build_pointer_type (TREE_TYPE (fntype)), addr);
}
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index ec5a749f53163f61572d37511ae87133af983452..2038b058aca36e6e711c160c9fb6dbc1b56fe99c 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -126,7 +126,7 @@ lvalue_p_1 (tree ref,
/* A currently unresolved scope ref. */
case SCOPE_REF:
- abort ();
+ gcc_unreachable ();
case MAX_EXPR:
case MIN_EXPR:
op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
@@ -796,17 +796,14 @@ int
count_functions (tree t)
{
int i;
+
if (TREE_CODE (t) == FUNCTION_DECL)
return 1;
- else if (TREE_CODE (t) == OVERLOAD)
- {
- for (i = 0; t; t = OVL_CHAIN (t))
- i++;
- return i;
- }
-
- abort ();
- return 0;
+ gcc_assert (TREE_CODE (t) == OVERLOAD);
+
+ for (i = 0; t; t = OVL_CHAIN (t))
+ i++;
+ return i;
}
int
@@ -915,8 +912,7 @@ cxx_printable_name (tree decl, int v)
ring_counter += 1;
if (ring_counter == PRINT_RING_SIZE)
ring_counter = 0;
- if (decl_ring[ring_counter] == current_function_decl)
- abort ();
+ gcc_assert (decl_ring[ring_counter] != current_function_decl);
}
if (print_ring[ring_counter])
@@ -1016,8 +1012,7 @@ verify_stmt_tree_r (tree* tp,
/* If this statement is already present in the hash table, then
there is a circularity in the statement tree. */
- if (htab_find (*statements, t))
- abort ();
+ gcc_assert (!htab_find (*statements, t));
slot = htab_find_slot (*statements, t, INSERT);
*slot = t;
@@ -1371,13 +1366,8 @@ get_type_decl (tree t)
return t;
if (TYPE_P (t))
return TYPE_STUB_DECL (t);
- if (t == error_mark_node)
- return t;
-
- abort ();
-
- /* Stop compiler from complaining control reaches end of non-void function. */
- return 0;
+ gcc_assert (t == error_mark_node);
+ return t;
}
/* Returns the namespace that contains DECL, whether directly or
@@ -2279,9 +2269,8 @@ stabilize_call (tree call, tree *initp)
if (call == error_mark_node)
return;
- if (TREE_CODE (call) != CALL_EXPR
- && TREE_CODE (call) != AGGR_INIT_EXPR)
- abort ();
+ gcc_assert (TREE_CODE (call) == CALL_EXPR
+ || TREE_CODE (call) == AGGR_INIT_EXPR);
for (t = TREE_OPERAND (call, 1); t; t = TREE_CHAIN (t))
if (TREE_SIDE_EFFECTS (TREE_VALUE (t)))
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index b204860d13bdbc0d8ef01d52b808f276f564604f..3ec1e427582b9711ee2f42711d375e6ddf6369b3 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -753,7 +753,7 @@ common_type (tree t1, tree t2)
return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
"conversion");
else
- abort ();
+ gcc_unreachable ();
}
/* Compare two exception specifier types for exactness or subsetness, if
@@ -2353,7 +2353,7 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
break;
default:
- abort ();
+ gcc_unreachable ();
}
/* Convert down to the right base before using the instance. First
@@ -3081,11 +3081,16 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
return e;
return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
}
- else if ((TYPE_PTRMEMFUNC_P (type0)
- && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0), type1))
- || (TYPE_PTRMEMFUNC_P (type1)
- && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1), type0)))
- abort ();
+ else
+ {
+ gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
+ || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
+ type1));
+ gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
+ || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
+ type0));
+ }
+
break;
case MAX_EXPR:
@@ -3975,14 +3980,8 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert)
address of a function is a no-op, so just return the
argument. */
- if (TREE_CODE (arg) == IDENTIFIER_NODE
- && IDENTIFIER_OPNAME_P (arg))
- {
- abort ();
- /* We don't know the type yet, so just work around the problem.
- We know that this will resolve to an lvalue. */
- return build1 (ADDR_EXPR, unknown_type_node, arg);
- }
+ gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
+ || !IDENTIFIER_OPNAME_P (arg));
if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
&& !really_overloaded_fn (TREE_OPERAND (arg, 1)))
@@ -5540,7 +5539,7 @@ expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
break;
default:
- abort ();
+ gcc_unreachable ();
}
*pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type),
diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index 19a11919b82ba78bcfc185c6507e0a60a2e14ceb..8d776915e84a17c6b46512b827ad0c885bf74833 100644
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -373,7 +373,7 @@ cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)
(*p_msg_at) ("`%D' has incomplete type", value);
decl = 1;
}
-retry:
+ retry:
/* We must print an error message. Be clever about what it says. */
switch (TREE_CODE (type))
@@ -423,7 +423,7 @@ retry:
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
@@ -509,7 +509,7 @@ split_nonconstant_init_1 (tree dest, tree init)
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
@@ -568,9 +568,8 @@ store_init_value (tree decl, tree init)
if (IS_AGGR_TYPE (type))
{
- if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
- && TREE_CODE (init) != CONSTRUCTOR)
- abort ();
+ gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
+ || TREE_CODE (init) == CONSTRUCTOR);
if (TREE_CODE (init) == TREE_LIST)
{
@@ -1107,8 +1106,7 @@ process_init_constructor (tree type, tree init, tree* elts)
next1 = digest_init (TREE_TYPE (field),
TREE_VALUE (tail), &tail1);
- if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
- abort ();
+ gcc_assert (!tail1 || TREE_CODE (tail1) == TREE_LIST);
tail = tail1;
}
else