tree
get_tinfo_decl (tree type)
{
tree name;
tree d;
if (COMPLETE_TYPE_P (type)
&& TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
{
error ("cannot create type information for type %qT because "
"its size is variable",
type);
return error_mark_node;
}
if (TREE_CODE (type) == METHOD_TYPE)
type = build_function_type (TREE_TYPE (type),
TREE_CHAIN (TYPE_ARG_TYPES (type)));
/* For a class type, the variable is cached in the type node
itself. */
if (CLASS_TYPE_P (type))
{
d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
if (d)
return d;
}
name = mangle_typeinfo_for_type (type);
d = IDENTIFIER_GLOBAL_VALUE (name);
if (!d)
{
tree var_desc = get_pseudo_ti_desc (type);
d = build_lang_decl (VAR_DECL, name, TINFO_PSEUDO_TYPE (var_desc));
SET_DECL_ASSEMBLER_NAME (d, name);
/* Remember the type it is for. */
TREE_TYPE (name) = type;
DECL_TINFO_P (d) = 1;
DECL_ARTIFICIAL (d) = 1;
#ifdef KEY /* g++ does not actually ignore it (note push operation below),
so we cannot either */
if (!flag_spin_file)
#endif
DECL_IGNORED_P (d) = 1;
TREE_READONLY (d) = 1;
TREE_STATIC (d) = 1;
/* Mark the variable as undefined -- but remember that we can
define it later if we need to do so. */
DECL_EXTERNAL (d) = 1;
DECL_NOT_REALLY_EXTERN (d) = 1;
if (CLASS_TYPE_P (type))
CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
set_linkage_according_to_type (type, d);
pushdecl_top_level_and_finish (d, NULL_TREE);
/* Add decl to the global array of tinfo decls. */
VEC_safe_push (tree, unemitted_tinfo_decls, d);
}
static bool
decl_is_java_type (tree decl, int err)
{
bool r = (TYPE_PTR_P (decl)
&& TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
&& TYPE_FOR_JAVA (TREE_TYPE (decl)));
if (err)
{
if (TREE_CODE (decl) == REFERENCE_TYPE
&& TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
&& TYPE_FOR_JAVA (TREE_TYPE (decl)))
{
/* Can't throw a reference. */
error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
decl);
}
if (r)
{
tree jthrow_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
if (jthrow_node == NULL_TREE)
fatal_error
(input_location,
"call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
{
/* Thrown object must be a Throwable. */
error ("type %qT is not derived from %<java::lang::Throwable%>",
TREE_TYPE (decl));
}
}
}
return r;
}
static bool
decl_is_java_type (tree decl, int err)
{
bool r = (TREE_CODE (decl) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
&& TYPE_FOR_JAVA (TREE_TYPE (decl)));
if (err)
{
if (TREE_CODE (decl) == REFERENCE_TYPE
&& TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
&& TYPE_FOR_JAVA (TREE_TYPE (decl)))
{
/* Can't throw a reference. */
error ("type `%T' is disallowed in Java `throw' or `catch'",
decl);
}
if (r)
{
tree jthrow_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
if (jthrow_node == NULL_TREE)
fatal_error
("call to Java `catch' or `throw' with `jthrowable' undefined");
jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
{
/* Thrown object must be a Throwable. */
error ("type `%T' is not derived from `java::lang::Throwable'",
TREE_TYPE (decl));
}
}
}
return r;
}
static tree
call_eh_info ()
{
tree fn;
fn = get_identifier ("__start_cp_handler");
if (IDENTIFIER_GLOBAL_VALUE (fn))
fn = IDENTIFIER_GLOBAL_VALUE (fn);
else
{
tree t1, t, fields[7];
/* Declare cp_eh_info * __start_cp_handler (void),
as defined in exception.cc. */
/* struct cp_eh_info. This must match exception.cc. Note that this
type is not pushed anywhere. */
t1= make_aggr_type (RECORD_TYPE);
fields[0] = build_decl (FIELD_DECL,
get_identifier ("handler_label"), ptr_type_node);
fields[1] = build_decl (FIELD_DECL,
get_identifier ("dynamic_handler_chain"), ptr_type_node);
fields[2] = build_decl (FIELD_DECL,
get_identifier ("info"), ptr_type_node);
fields[3] = build_decl (FIELD_DECL,
get_identifier ("table_index"), ptr_type_node);
/* N.B.: The fourth field LEN is expected to be
the number of fields - 1, not the total number of fields. */
finish_builtin_type (t1, "eh_context", fields, 3, ptr_type_node);
t1 = build_pointer_type (t1);
t1= make_aggr_type (RECORD_TYPE);
#ifdef TARG_XTENSA
fields[0] = build_decl (FIELD_DECL,
get_identifier ("version"), integer_type_node);
/* N.B.: The fourth field LEN is expected to be
the number of fields - 1, not the total number of fields. */
finish_builtin_type (t1, "__eh_info", fields, 0, ptr_type_node);
#else
fields[0] = build_decl (FIELD_DECL,
get_identifier ("match_function"), ptr_type_node);
fields[1] = build_decl (FIELD_DECL,
get_identifier ("language"), short_integer_type_node);
fields[2] = build_decl (FIELD_DECL,
get_identifier ("version"), short_integer_type_node);
/* N.B.: The fourth field LEN is expected to be
the number of fields - 1, not the total number of fields. */
finish_builtin_type (t1, "__eh_info", fields, 2, ptr_type_node);
#endif
t = make_aggr_type (RECORD_TYPE);
fields[0] = build_decl (FIELD_DECL,
get_identifier ("eh_info"), t1);
fields[1] = build_decl (FIELD_DECL, get_identifier ("value"),
ptr_type_node);
fields[2] = build_decl (FIELD_DECL, get_identifier ("type"),
ptr_type_node);
fields[3] = build_decl
(FIELD_DECL, get_identifier ("cleanup"),
build_pointer_type (build_function_type
(ptr_type_node, tree_cons
(NULL_TREE, ptr_type_node, void_list_node))));
fields[4] = build_decl (FIELD_DECL, get_identifier ("caught"),
boolean_type_node);
fields[5] = build_decl (FIELD_DECL, get_identifier ("next"),
build_pointer_type (t));
fields[6] = build_decl
(FIELD_DECL, get_identifier ("handlers"), long_integer_type_node);
/* N.B.: The fourth field LEN is expected to be
the number of fields - 1, not the total number of fields. */
finish_builtin_type (t, "cp_eh_info", fields, 6, ptr_type_node);
t = build_pointer_type (t);
/* And now the function. */
fn = push_library_fn (fn, build_function_type (t, void_list_node));
}
return build_function_call (fn, NULL_TREE);
}