#include "cp-tree.h"
#include "flags.h"
#include "output.h"
-#include "except.h"
-#include "toplev.h"
#include "tree-inline.h"
#include "tree-iterator.h"
#include "target.h"
static int complete_ptr_ref_or_void_ptr_p (tree, tree);
static bool is_admissible_throw_operand (tree);
static int can_convert_eh (tree, tree);
-static tree cp_protect_cleanup_actions (void);
/* Sets up all the global eh stuff that needs to be initialized at the
start of compilation. */
/* void std::terminate (); */
push_namespace (std_identifier);
- tmp = build_function_type (void_type_node, void_list_node);
+ tmp = build_function_type_list (void_type_node, NULL_TREE);
terminate_node = build_cp_library_fn_ptr ("terminate", tmp);
TREE_THIS_VOLATILE (terminate_node) = 1;
TREE_NOTHROW (terminate_node) = 1;
pop_namespace ();
/* void __cxa_call_unexpected(void *); */
- tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
- tmp = build_function_type (void_type_node, tmp);
+ tmp = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
call_unexpected_node
= push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
-
- lang_protect_cleanup_actions = &cp_protect_cleanup_actions;
}
/* Returns an expression to be executed if an unhandled exception is
propagated out of a cleanup region. */
-static tree
+tree
cp_protect_cleanup_actions (void)
{
/* [except.terminate]
static tree
declare_nothrow_library_fn (tree name, tree return_type, tree parm_type)
{
- tree tmp = tree_cons (NULL_TREE, parm_type, void_list_node);
- return push_library_fn (name, build_function_type (return_type, tmp),
+ return push_library_fn (name, build_function_type_list (return_type,
+ parm_type,
+ NULL_TREE),
empty_except_spec);
}
fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
}
- return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
- NULL_TREE),
- tf_warning_or_error);
+ return cp_build_function_call_nary (fn, tf_warning_or_error,
+ build_exc_ptr (), NULL_TREE);
}
/* Build up a call to __cxa_begin_catch, to tell the runtime that the
fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
}
- return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
- NULL_TREE),
- tf_warning_or_error);
+ return cp_build_function_call_nary (fn, tf_warning_or_error,
+ build_exc_ptr (), NULL_TREE);
}
/* Returns nonzero if cleaning up an exception of type TYPE (which can be
TREE_NOTHROW (fn) = 0;
}
- cleanup = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error);
+ cleanup = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);
TREE_NOTHROW (cleanup) = dtor_nothrow (type);
return cleanup;
/* Select the personality routine to be used for exception handling,
or issue an error if we need two different ones in the same
translation unit.
- ??? At present eh_personality_decl is set to
- __gxx_personality_(sj|v)0 in init_exception_processing - should it
- be done here instead? */
+ ??? At present DECL_FUNCTION_PERSONALITY is set via
+ LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
void
choose_personality_routine (enum languages lang)
{
pointer catch parm with the address of the temporary. */
if (TREE_CODE (init_type) == REFERENCE_TYPE
&& TYPE_PTR_P (TREE_TYPE (init_type)))
- exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
+ exp = cp_build_addr_expr (exp, tf_warning_or_error);
exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
LOOKUP_ONLYCONVERTING|DIRECT_BIND);
}
+\f
+/* Routine to see if exception handling is turned on.
+ DO_WARN is nonzero if we want to inform the user that exception
+ handling is turned off.
+
+ This is used to ensure that -fexceptions has been specified if the
+ compiler tries to use any exception-specific functions. */
+
+static inline int
+doing_eh (void)
+{
+ if (! flag_exceptions)
+ {
+ static int warned = 0;
+ if (! warned)
+ {
+ error ("exception handling disabled, use -fexceptions to enable");
+ warned = 1;
+ }
+ return 0;
+ }
+ return 1;
+}
+
/* Call this to start a catch block. DECL is the catch parameter. */
tree
tree exp;
tree type, init;
- if (! doing_eh (1))
+ if (! doing_eh ())
return NULL_TREE;
/* Make sure this declaration is reasonable. */
void
expand_end_catch_block (void)
{
- if (! doing_eh (1))
+ if (! doing_eh ())
return;
/* The exception being handled is rethrown if control reaches the end of
fn = declare_nothrow_library_fn (fn, ptr_type_node, size_type_node);
}
- return cp_build_function_call (fn,
- tree_cons (NULL_TREE, size_in_bytes (type),
- NULL_TREE),
- tf_warning_or_error);
+ return cp_build_function_call_nary (fn, tf_warning_or_error,
+ size_in_bytes (type), NULL_TREE);
}
/* Call __cxa_free_exception from a cleanup. This is never invoked
fn = declare_nothrow_library_fn (fn, void_type_node, ptr_type_node);
}
- return cp_build_function_call (fn, tree_cons (NULL_TREE, ptr, NULL_TREE),
- tf_warning_or_error);
+ return cp_build_function_call_nary (fn, tf_warning_or_error, ptr, NULL_TREE);
}
/* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
{
if (cfun)
current_function_returns_abnormally = 1;
- return build_min (THROW_EXPR, void_type_node, exp);
+ exp = build_min (THROW_EXPR, void_type_node, exp);
+ SET_EXPR_LOCATION (exp, input_location);
+ return exp;
}
if (exp == null_node)
return error_mark_node;
}
- if (! doing_eh (1))
+ if (! doing_eh ())
return error_mark_node;
if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
if (!get_global_value_if_present (fn, &fn))
{
/* Declare void _Jv_Throw (void *). */
- tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
- tmp = build_function_type (ptr_type_node, tmp);
+ tree tmp;
+ tmp = build_function_type_list (ptr_type_node,
+ ptr_type_node, NULL_TREE);
fn = push_throw_library_fn (fn, tmp);
}
else if (really_overloaded_fn (fn))
return error_mark_node;
}
fn = OVL_CURRENT (fn);
- exp = cp_build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE),
- tf_warning_or_error);
+ exp = cp_build_function_call_nary (fn, tf_warning_or_error,
+ exp, NULL_TREE);
}
else if (exp)
{
/* The CLEANUP_TYPE is the internal type of a destructor. */
if (!cleanup_type)
{
- tmp = void_list_node;
- tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
- tmp = build_function_type (void_type_node, tmp);
+ tmp = build_function_type_list (void_type_node,
+ ptr_type_node, NULL_TREE);
cleanup_type = build_pointer_type (tmp);
}
{
/* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
/* ??? Second argument is supposed to be "std::type_info*". */
- tmp = void_list_node;
- tmp = tree_cons (NULL_TREE, cleanup_type, tmp);
- tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
- tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
- tmp = build_function_type (void_type_node, tmp);
+ tmp = build_function_type_list (void_type_node,
+ ptr_type_node, ptr_type_node,
+ cleanup_type, NULL_TREE);
fn = push_throw_library_fn (fn, tmp);
}
else
cleanup = build_int_cst (cleanup_type, 0);
- tmp = tree_cons (NULL_TREE, cleanup, NULL_TREE);
- tmp = tree_cons (NULL_TREE, throw_type, tmp);
- tmp = tree_cons (NULL_TREE, ptr, tmp);
/* ??? Indicate that this function call throws throw_type. */
- tmp = cp_build_function_call (fn, tmp, tf_warning_or_error);
+ tmp = cp_build_function_call_nary (fn, tf_warning_or_error,
+ ptr, throw_type, cleanup, NULL_TREE);
/* Tack on the initialization stuff. */
exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
{
/* Declare void __cxa_rethrow (void). */
fn = push_throw_library_fn
- (fn, build_function_type (void_type_node, void_list_node));
+ (fn, build_function_type_list (void_type_node, NULL_TREE));
}
/* ??? Indicate that this function call allows exceptions of the type
of the enclosing catch block (if known). */
- exp = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error);
+ exp = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);
}
exp = build1 (THROW_EXPR, void_type_node, exp);
+ SET_EXPR_LOCATION (exp, input_location);
return exp;
}
check_handlers_1 (handler, i);
}
}
+
+/* walk_tree helper for finish_noexcept_expr. Returns non-null if the
+ expression *TP causes the noexcept operator to evaluate to false.
+
+ 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
+ in a potentially-evaluated context the expression would contain
+ * a potentially evaluated call to a function, member function,
+ function pointer, or member function pointer that does not have a
+ non-throwing exception-specification (15.4),
+ * a potentially evaluated throw-expression (15.1),
+ * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
+ where T is a reference type, that requires a run-time check (5.2.7), or
+ * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
+ expression whose type is a polymorphic class type (10.3). */
+
+static tree
+check_noexcept_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
+{
+ tree t = *tp;
+ enum tree_code code = TREE_CODE (t);
+ if (code == CALL_EXPR
+ || code == AGGR_INIT_EXPR)
+ {
+ /* We can only use the exception specification of the called function
+ for determining the value of a noexcept expression; we can't use
+ TREE_NOTHROW, as it might have a different value in another
+ translation unit, creating ODR problems.
+
+ We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
+ tree fn = (code == AGGR_INIT_EXPR
+ ? AGGR_INIT_EXPR_FN (t) : CALL_EXPR_FN (t));
+ tree type = TREE_TYPE (TREE_TYPE (fn));
+
+ STRIP_NOPS (fn);
+ if (TREE_CODE (fn) == ADDR_EXPR)
+ fn = TREE_OPERAND (fn, 0);
+ if (TREE_CODE (fn) == FUNCTION_DECL)
+ {
+ /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
+ and for C library functions known not to throw. */
+ if (DECL_EXTERN_C_P (fn)
+ && (DECL_ARTIFICIAL (fn)
+ || nothrow_libfn_p (fn)))
+ return TREE_NOTHROW (fn) ? NULL_TREE : fn;
+ /* A call to a constexpr function is noexcept if the call
+ is a constant expression. */
+ if (DECL_DECLARED_CONSTEXPR_P (fn)
+ && is_sub_constant_expr (t))
+ return NULL_TREE;
+ }
+ if (!TYPE_NOTHROW_P (type))
+ return fn;
+ }
+
+ return NULL_TREE;
+}
+
+/* If a function that causes a noexcept-expression to be false isn't
+ defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
+
+typedef struct GTY(()) pending_noexcept {
+ tree fn;
+ location_t loc;
+} pending_noexcept;
+DEF_VEC_O(pending_noexcept);
+DEF_VEC_ALLOC_O(pending_noexcept,gc);
+static GTY(()) VEC(pending_noexcept,gc) *pending_noexcept_checks;
+
+/* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
+ it can't throw. */
+
+static void
+maybe_noexcept_warning (tree fn)
+{
+ if (TREE_NOTHROW (fn))
+ {
+ warning (OPT_Wnoexcept, "noexcept-expression evaluates to %<false%> "
+ "because of a call to %qD", fn);
+ warning (OPT_Wnoexcept, "but %q+D does not throw; perhaps "
+ "it should be declared %<noexcept%>", fn);
+ }
+}
+
+/* Check any functions that weren't defined earlier when they caused a
+ noexcept expression to evaluate to false. */
+
+void
+perform_deferred_noexcept_checks (void)
+{
+ int i;
+ pending_noexcept *p;
+ location_t saved_loc = input_location;
+ FOR_EACH_VEC_ELT (pending_noexcept, pending_noexcept_checks, i, p)
+ {
+ input_location = p->loc;
+ maybe_noexcept_warning (p->fn);
+ }
+ input_location = saved_loc;
+}
+
+/* Evaluate noexcept ( EXPR ). */
+
+tree
+finish_noexcept_expr (tree expr, tsubst_flags_t complain)
+{
+ tree fn;
+
+ if (expr == error_mark_node)
+ return error_mark_node;
+
+ if (processing_template_decl)
+ return build_min (NOEXCEPT_EXPR, boolean_type_node, expr);
+
+ fn = cp_walk_tree_without_duplicates (&expr, check_noexcept_r, 0);
+ if (fn)
+ {
+ if ((complain & tf_warning) && warn_noexcept
+ && TREE_CODE (fn) == FUNCTION_DECL)
+ {
+ if (!DECL_INITIAL (fn))
+ {
+ /* Not defined yet; check again at EOF. */
+ pending_noexcept *p
+ = VEC_safe_push (pending_noexcept, gc,
+ pending_noexcept_checks, NULL);
+ p->fn = fn;
+ p->loc = input_location;
+ }
+ else
+ maybe_noexcept_warning (fn);
+ }
+ return boolean_false_node;
+ }
+ else
+ return boolean_true_node;
+}
+
+/* Return true iff SPEC is throw() or noexcept(true). */
+
+bool
+nothrow_spec_p (const_tree spec)
+{
+ if (spec == NULL_TREE
+ || TREE_VALUE (spec) != NULL_TREE
+ || spec == noexcept_false_spec)
+ return false;
+ if (TREE_PURPOSE (spec) == NULL_TREE
+ || spec == noexcept_true_spec)
+ return true;
+ gcc_assert (processing_template_decl
+ || TREE_PURPOSE (spec) == error_mark_node);
+ return false;
+}
+
+/* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
+ case for things declared noexcept(true) and, with -fnothrow-opt, for
+ throw() functions. */
+
+bool
+type_noexcept_p (const_tree type)
+{
+ tree spec = TYPE_RAISES_EXCEPTIONS (type);
+ if (flag_nothrow_opt)
+ return nothrow_spec_p (spec);
+ else
+ return spec == noexcept_true_spec;
+}
+
+/* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
+ i.e. no exception-specification or noexcept(false). */
+
+bool
+type_throw_all_p (const_tree type)
+{
+ tree spec = TYPE_RAISES_EXCEPTIONS (type);
+ return spec == NULL_TREE || spec == noexcept_false_spec;
+}
+
+/* Create a representation of the noexcept-specification with
+ constant-expression of EXPR. COMPLAIN is as for tsubst. */
+
+tree
+build_noexcept_spec (tree expr, int complain)
+{
+ /* This isn't part of the signature, so don't bother trying to evaluate
+ it until instantiation. */
+ if (!processing_template_decl)
+ {
+ expr = perform_implicit_conversion_flags (boolean_type_node, expr,
+ complain,
+ LOOKUP_NORMAL);
+ expr = cxx_constant_value (expr);
+ }
+ if (expr == boolean_true_node)
+ return noexcept_true_spec;
+ else if (expr == boolean_false_node)
+ return noexcept_false_spec;
+ else if (expr == error_mark_node)
+ return error_mark_node;
+ else
+ {
+ gcc_assert (processing_template_decl || expr == error_mark_node);
+ return build_tree_list (expr, NULL_TREE);
+ }
+}
OSDN Git Service
