+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
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)
{
}
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))
{
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;
}
}
/* We should always find a previous binding in this case. */
- abort ();
+ gcc_unreachable ();
}
/* Install the new binding. */
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;
}
error ("`%E' in class `%T' does not name a type",
id, parser->scope);
else
- abort();
+ gcc_unreachable ();
}
}
= build_const_cast (type, expression);
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
break;
}
/* We should never get here. */
- abort ();
+ gcc_unreachable ();
return error_mark_node;
}
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (non_constant_p
return true;
default:
- abort ();
- return false;
+ gcc_unreachable ();
}
+ return false;
}
/* NUM_TEMPLATES were used in the current declaration. If that is
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
}
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (specialization || member_specialization)
default:
/* All non-type parameters must have one of these types. */
- abort ();
- break;
+ gcc_unreachable ();
}
return error_mark_node;
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
return 1;
|| 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;
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))
break;
default:
- abort ();
+ gcc_unreachable ();
}
/* Restore the file and line information. */
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)
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
break;
default:
- abort ();
+ gcc_unreachable ();
}
return r;
case TREE_BINFO:
/* We should never be tsubsting a binfo. */
- abort ();
+ gcc_unreachable ();
case TREE_VEC:
/* A vector of template arguments. */
case INDIRECT_REF:
case ADDR_EXPR:
case CALL_EXPR:
- abort ();
+ gcc_unreachable ();
case ARRAY_REF:
{
/* 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;
/* 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;
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;
if (DECL_NAME (clone) == DECL_NAME (tmpl))
return clone;
/* We should always have found the clone by now. */
- abort ();
+ gcc_unreachable ();
return NULL_TREE;
}
}
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (TREE_CODE (*parm) != REFERENCE_TYPE)
break;
default:
- abort ();
+ gcc_unreachable ();
}
if (xlen == 0)
}
}
}
- 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
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
if (TREE_CODE (expression) == BASELINK)
expression = BASELINK_FUNCTIONS (expression);
+
if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
{
if (any_dependent_template_arguments_p
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)));
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
return found;
result_stmt_p = &TREE_OPERAND (t, 0);
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
type = TREE_TYPE (EXPR_STMT_EXPR (result_stmt));
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
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)
{
{
/* 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);
}
/* 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),
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
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])
/* 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;
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
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)))
return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
"conversion");
else
- abort ();
+ gcc_unreachable ();
}
\f
/* Compare two exception specifier types for exactness or subsetness, if
break;
default:
- abort ();
+ gcc_unreachable ();
}
/* Convert down to the right base before using the instance. First
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:
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)))
break;
default:
- abort ();
+ gcc_unreachable ();
}
*pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (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))
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
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)
{
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
projects / gcc.git / commitdiff