From a7801c18fac9b20ee47d09ed15380a83fabeeec9 Mon Sep 17 00:00:00 2001
From: Maximilian Downey Twiss <creatorsmithmdt@gmail.com>
Date: Fri, 18 Nov 2022 09:34:30 +1100
Subject: [PATCH 20/56] Re-add Java handling to gcc and gcc/cp.
gcc/cp/ChangeLog:
* call.cc (build_java_interface_fn_ref): Re-add.
(build_over_call): Handle TYPE_JAVA_INTERFACE.
(java_iface_lookup_fn): Re-add.
* class.cc (add_method): Handle TYPE_FOR_JAVA.
(add_implicitly_declared_members): Likewise.
(determine_key_method): Likewise.
(finish_struct_1): Likewise.
(push_lang_context): Handle lang_name_java.
* cp-lang.cc (cp_eh_personality): Handle pragma_java_exceptions.
* cp-tree.h (enum cp_tree_index): Re-add CPTI_JAVA_*, CPTI_LANG_NAME_JAVA and CPTI_JCLASS.
(java_byte_type_node): Re-add.
(java_short_type_node): Likewise.
(java_int_type_node): Likewise.
(java_long_type_node): Likewise.
(java_float_type_node): Likewise.
(java_double_type_node): Likewise.
(java_char_type_node): Likewise.
(java_boolean_type_node): Likewise.
(lang_name_java): Likewise.
(jclass_node): Likewise.
(cp_global_trees): Re-add TYPE_FOR_JAVA.
(enum languages): Re-add lang_java.
(TYPE_FOR_JAVA): Re-add.
(struct lang_type): Re-add java_interface.
(TYPE_JAVA_INTERFACE): Re-add.
(struct lang_decl_base): Increase language by 1.
(check_java_method): Re-add.
(build_java_class_ref): Likewise.
(pragma_java_exceptions): Likewise.
* decl.cc (record_builtin_java_type): Re-add.
(initialize_predefined_identifiers): Re-add Java.
(cxx_init_decl_processing): Re-add java_*_type_node.
(cp_finish_decl): Handle TYPE_FOR_JAVA.
(grokfndecl): Likewise.
(check_special_function_return_type): Likewise.
(grokdeclarator): Set TYPE_FOR_JAVA.
(grokparms): Handle TYPE_FOR_JAVA.
(xref_basetypes): Likewise.
(check_function_type): Likewise.
(maybe_return_this): Likewise.
* decl2.cc (acceptable_java_type): Re-add.
(check_java_method): Likewise.
(import_export_decl): Handle TYPE_FOR_JAVA.
(build_java_method_aliases): Re-add.
(c_parse_final_cleanups): Call build_java_method_aliases.
(possibly_inlined_p): Test pragma_java_exceptions.
* error.cc (language_to_string): Handle lang_java.
* except.cc (decl_is_java_type): Re-add.
(eh_type_info): Re-add java type handling.
(choose_personality_routine): Re-add.
(initialize_handler_parm): Call choose_personality_routine.
(expand_start_catch_block): Handle java types.
(build_throw): Likewise.
* init.cc (build_new_1): Handle TYPE_FOR_JAVA.
(build_java_class_ref): Likewise.
* lex.cc (handle_pragma_java_exceptions): Re-add.
(init_cp_pragma): Register GCC java_exceptions pragma.
(set_decl_linkage): Handle lang_name_java.
* mangle.cc (write_java_integer_type_codes): Re-add.
(write_builtin_type): Handle TYPE_FOR_JAVA.
(write_bare_function_type): Handle java_*_type_node.
* method.cc (implicitly_declare_fn): Handle TYPE_FOR_JAVA.
* name-lookup.cc (pushtag): Set TYPE_FOR_JAVA.
* pt.cc (maybe_new_partial_specialization): Copy TYPE_FOR_JAVA.
(lookup_template_class): Likewise.
(instantiate_class_template): Likewise.
* tree.cc (handle_java_interface_attribute): Re-add.
* typeck.cc (structural_comptypes): Compare TYPE_FOR_JAVA.
gcc/ChangeLog:
* dwarf2out.cc (is_java): Re-add.
(output_pubname): Handle is_java.
(lower_bound_default): Handle DW_LANG_Java.
(gen_compile_unit_die): Likewise.
* gimplify.cc (mostly_copy_tree_r): Re-add Java-special part.
* ipa-free-lang-data.cc (free_lang_data_in_type): Handle Java's usage of TYPE_MIN_VALUE.
(find_decls_types_r): Handle Java's usage of TYPE_BINFO.
* tree.cc (verify_type): Handle Java's usage of TYPE_MIN_VALUE, TYPE_BINFO, and TYPE_STRING_FLAG.
---
gcc/cp/call.cc | 66 ++++++++++++++++-
gcc/cp/class.cc | 50 ++++++++++++-
gcc/cp/cp-lang.cc | 5 +-
gcc/cp/cp-tree.h | 45 ++++++++++-
gcc/cp/decl.cc | 124 +++++++++++++++++++++++++++++--
gcc/cp/decl2.cc | 122 +++++++++++++++++++++++++++++-
gcc/cp/error.cc | 3 +
gcc/cp/except.cc | 152 +++++++++++++++++++++++++++++++++++++-
gcc/cp/init.cc | 128 +++++++++++++++++++++++++++++---
gcc/cp/lex.cc | 18 +++++
gcc/cp/mangle.cc | 62 +++++++++++++++-
gcc/cp/method.cc | 2 +-
gcc/cp/name-lookup.cc | 3 +
gcc/cp/pt.cc | 3 +
gcc/cp/tree.cc | 28 +++++++
gcc/cp/typeck.cc | 2 +
gcc/dwarf2out.cc | 17 ++++-
gcc/gimplify.cc | 7 +-
gcc/ipa-free-lang-data.cc | 16 +++-
gcc/tree.cc | 30 +++++++-
20 files changed, 839 insertions(+), 44 deletions(-)
diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 459e86b5f09..32ead577737 100644
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -167,6 +167,7 @@ static int compare_ics (conversion *, conversion *);
static void maybe_warn_class_memaccess (location_t, tree,
const vec<tree, va_gc> *);
static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
+static tree build_java_interface_fn_ref (tree, tree);
static tree convert_like (conversion *, tree, tsubst_flags_t);
static tree convert_like_with_context (conversion *, tree, tree, int,
tsubst_flags_t);
@@ -10242,7 +10243,10 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
if (TREE_SIDE_EFFECTS (argarray[0]))
argarray[0] = save_expr (argarray[0]);
t = build_pointer_type (TREE_TYPE (fn));
- fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
+ if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
+ fn = build_java_interface_fn_ref (fn, argarray[0]);
+ else
+ fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
TREE_TYPE (fn) = t;
}
else
@@ -10819,6 +10823,66 @@ build_cxx_call (tree fn, int nargs, tree *argarray,
return convert_from_reference (fn);
}
+static GTY(()) tree java_iface_lookup_fn;
+
+/* Make an expression which yields the address of the Java interface
+ method FN. This is achieved by generating a call to libjava's
+ _Jv_LookupInterfaceMethodIdx(). */
+
+static tree
+build_java_interface_fn_ref (tree fn, tree instance)
+{
+ tree lookup_fn, method, idx;
+ tree klass_ref, iface, iface_ref;
+ int i;
+
+ if (!java_iface_lookup_fn)
+ {
+ tree ftype = build_function_type_list (ptr_type_node,
+ ptr_type_node, ptr_type_node,
+ java_int_type_node, NULL_TREE);
+ java_iface_lookup_fn
+ = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype,
+ 0, NOT_BUILT_IN, NULL, NULL_TREE);
+ }
+
+ /* Look up the pointer to the runtime java.lang.Class object for `instance'.
+ This is the first entry in the vtable. */
+ klass_ref = build_vtbl_ref (cp_build_fold_indirect_ref (instance),
+ integer_zero_node);
+
+ /* Get the java.lang.Class pointer for the interface being called. */
+ iface = DECL_CONTEXT (fn);
+ iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
+ if (!iface_ref || !VAR_P (iface_ref)
+ || DECL_CONTEXT (iface_ref) != iface)
+ {
+ error ("could not find class$ field in java interface type %qT",
+ iface);
+ return error_mark_node;
+ }
+ iface_ref = build_address (iface_ref);
+ iface_ref = convert (build_pointer_type (iface), iface_ref);
+
+ /* Determine the itable index of FN. */
+ i = 1;
+ for (method = TYPE_FIELDS (iface); method; method = DECL_CHAIN (method))
+ {
+ if (!DECL_VIRTUAL_P (method))
+ continue;
+ if (fn == method)
+ break;
+ i++;
+ }
+ idx = build_int_cst (NULL_TREE, i);
+
+ lookup_fn = build1 (ADDR_EXPR,
+ build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
+ java_iface_lookup_fn);
+ return build_call_nary (ptr_type_node, lookup_fn,
+ 3, klass_ref, iface_ref, idx);
+}
+
/* Returns the value to use for the in-charge parameter when making a
call to a function with the indicated NAME.
diff --git a/gcc/cp/class.cc b/gcc/cp/class.cc
index aebcb53739e..2dafb54b8c1 100644
--- a/gcc/cp/class.cc
+++ b/gcc/cp/class.cc
@@ -1247,6 +1247,16 @@ add_method (tree type, tree method, bool via_using)
/* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
grok_special_member_properties (method);
+ if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method) && (TYPE_FOR_JAVA (type)))
+ {
+ if (!DECL_ARTIFICIAL (method))
+ error ("Java class %qT cannot have a destructor", type);
+ else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
+ error ("Java class %qT cannot have an implicit non-trivial "
+ "destructor",
+ type);
+ }
+
*slot = current_fns;
return true;
@@ -3306,9 +3316,18 @@ add_implicitly_declared_members (tree t, tree* access_decls,
{
/* Destructor. */
if (!CLASSTYPE_DESTRUCTOR (t))
+ {
/* In general, we create destructors lazily. */
CLASSTYPE_LAZY_DESTRUCTOR (t) = 1;
+ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
+ && TYPE_FOR_JAVA (t))
+ /* But if this is a Java class, any non-trivial destructor is
+ invalid, even if compiler-generated. Therefore, if the
+ destructor is non-trivial we create it now. */
+ lazily_declare_fn (sfk_destructor, t);
+ }
+
bool move_ok = false;
if (cxx_dialect >= cxx11 && CLASSTYPE_LAZY_DESTRUCTOR (t)
&& !TYPE_HAS_COPY_CTOR (t) && !TYPE_HAS_COPY_ASSIGN (t)
@@ -3336,7 +3355,7 @@ add_implicitly_declared_members (tree t, tree* access_decls,
If a class definition does not explicitly declare a copy
constructor, one is declared implicitly. */
- if (! TYPE_HAS_COPY_CTOR (t))
+ if (! TYPE_HAS_COPY_CTOR (t) && ! TYPE_FOR_JAVA (t))
{
TYPE_HAS_COPY_CTOR (t) = 1;
TYPE_HAS_CONST_COPY_CTOR (t) = !cant_have_const_cctor;
@@ -3349,7 +3368,7 @@ add_implicitly_declared_members (tree t, tree* access_decls,
when it is needed. For now, just record whether or not the type
of the parameter to the assignment operator will be a const or
non-const reference. */
- if (!TYPE_HAS_COPY_ASSIGN (t))
+ if (!TYPE_HAS_COPY_ASSIGN (t) && !TYPE_FOR_JAVA (t))
{
TYPE_HAS_COPY_ASSIGN (t) = 1;
TYPE_HAS_CONST_COPY_ASSIGN (t) = !cant_have_const_assignment;
@@ -7031,7 +7050,8 @@ determine_key_method (tree type)
{
tree method;
- if (processing_template_decl
+ if (TYPE_FOR_JAVA (type)
+ || processing_template_decl
|| CLASSTYPE_TEMPLATE_INSTANTIATION (type)
|| CLASSTYPE_INTERFACE_KNOWN (type))
return;
@@ -7619,7 +7639,9 @@ finish_struct_1 (tree t)
/* Build the VTT for T. */
build_vtt (t);
- if (warn_nonvdtor
+ /* This warning does not make sense for Java classes, since they
+ cannot have destructors. */
+ if (!TYPE_FOR_JAVA (t) && warn_nonvdtor
&& TYPE_POLYMORPHIC_P (t) && accessible_nvdtor_p (t)
&& !CLASSTYPE_FINAL (t))
warning (OPT_Wnon_virtual_dtor,
@@ -8330,9 +8352,29 @@ push_lang_context (tree name)
vec_safe_push (current_lang_base, current_lang_name);
if (name == lang_name_cplusplus)
+ {
current_lang_name = name;
+ }
+ else if (name == lang_name_java)
+ {
+ current_lang_name = name;
+ /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
+ (See record_builtin_java_type in decl.cc.) However, that causes
+ incorrect debug entries if these types are actually used.
+ So we re-enable debug output after extern "Java". */
+ DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
+ DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
+ DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
+ DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
+ DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
+ DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
+ DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
+ DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
+ }
else if (name == lang_name_c)
+ {
current_lang_name = name;
+ }
else
error ("language string %<\"%E\"%> not recognized", name);
}
diff --git a/gcc/cp/cp-lang.cc b/gcc/cp/cp-lang.cc
index a3f29eda0d6..af66fe5727f 100644
--- a/gcc/cp/cp-lang.cc
+++ b/gcc/cp/cp-lang.cc
@@ -152,7 +152,10 @@ static tree
cp_eh_personality (void)
{
if (!cp_eh_personality_decl)
- cp_eh_personality_decl = build_personality_function ("gxx");
+ {
+ const char *lang = (pragma_java_exceptions ? "gcj" : "gxx");
+ cp_eh_personality_decl = build_personality_function (lang);
+ }
return cp_eh_personality_decl;
}
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 548b533266a..62543051359 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -130,6 +130,15 @@ operator == (const cp_expr &lhs, tree rhs)
enum cp_tree_index
{
+ CPTI_JAVA_BYTE_TYPE,
+ CPTI_JAVA_SHORT_TYPE,
+ CPTI_JAVA_INT_TYPE,
+ CPTI_JAVA_LONG_TYPE,
+ CPTI_JAVA_FLOAT_TYPE,
+ CPTI_JAVA_DOUBLE_TYPE,
+ CPTI_JAVA_CHAR_TYPE,
+ CPTI_JAVA_BOOLEAN_TYPE,
+
CPTI_WCHAR_DECL,
CPTI_VTABLE_ENTRY_TYPE,
CPTI_DELTA_TYPE,
@@ -195,10 +204,12 @@ enum cp_tree_index
CPTI_LANG_NAME_C,
CPTI_LANG_NAME_CPLUSPLUS,
+ CPTI_LANG_NAME_JAVA,
CPTI_EMPTY_EXCEPT_SPEC,
CPTI_NOEXCEPT_TRUE_SPEC,
CPTI_NOEXCEPT_FALSE_SPEC,
+ CPTI_JCLASS,
CPTI_NOEXCEPT_DEFERRED_SPEC,
CPTI_ANY_TARG,
@@ -246,6 +257,15 @@ enum cp_tree_index
extern GTY(()) tree cp_global_trees[CPTI_MAX];
+#define java_byte_type_node cp_global_trees[CPTI_JAVA_BYTE_TYPE]
+#define java_short_type_node cp_global_trees[CPTI_JAVA_SHORT_TYPE]
+#define java_int_type_node cp_global_trees[CPTI_JAVA_INT_TYPE]
+#define java_long_type_node cp_global_trees[CPTI_JAVA_LONG_TYPE]
+#define java_float_type_node cp_global_trees[CPTI_JAVA_FLOAT_TYPE]
+#define java_double_type_node cp_global_trees[CPTI_JAVA_DOUBLE_TYPE]
+#define java_char_type_node cp_global_trees[CPTI_JAVA_CHAR_TYPE]
+#define java_boolean_type_node cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE]
+
#define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL]
#define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
/* The type used to represent an offset by which to adjust the `this'
@@ -352,6 +372,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
#define omp_identifier cp_global_trees[CPTI_OMP_IDENTIFIER]
#define lang_name_c cp_global_trees[CPTI_LANG_NAME_C]
#define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS]
+#define lang_name_java cp_global_trees[CPTI_LANG_NAME_JAVA]
/* Exception specifiers used for throw(), noexcept(true),
noexcept(false) and deferred noexcept. We rely on these being
@@ -361,6 +382,9 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
#define noexcept_false_spec cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC]
#define noexcept_deferred_spec cp_global_trees[CPTI_NOEXCEPT_DEFERRED_SPEC]
+/* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */
+#define jclass_node cp_global_trees[CPTI_JCLASS]
+
/* Exception handling function declarations. */
#define terminate_fn cp_global_trees[CPTI_TERMINATE_FN]
#define call_unexpected_fn cp_global_trees[CPTI_CALL_UNEXPECTED_FN]
@@ -537,6 +561,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
1: TYPE_HAS_USER_CONSTRUCTOR.
2: TYPE_HAS_LATE_RETURN_TYPE (in FUNCTION_TYPE, METHOD_TYPE)
TYPE_PTRMEMFUNC_FLAG (in RECORD_TYPE)
+ 3: TYPE_FOR_JAVA.
4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE)
ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE)
@@ -2219,7 +2244,7 @@ extern bool statement_code_p[MAX_TREE_CODES];
#define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)]
-enum languages { lang_c, lang_cplusplus };
+enum languages { lang_c, lang_cplusplus, lang_java };
/* Macros to make error reporting functions' lives easier. */
#define TYPE_LINKAGE_IDENTIFIER(NODE) \
@@ -2277,6 +2302,9 @@ enum languages { lang_c, lang_cplusplus };
#define OVERLOAD_TYPE_P(T) \
(CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE)
+/* True if this a "Java" type, defined in 'extern "Java"'. */
+#define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE)
+
/* True if this type is dependent. This predicate is only valid if
TYPE_DEPENDENT_P_VALID is true. */
#define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE)
@@ -2381,6 +2409,7 @@ struct GTY(()) lang_type {
unsigned diamond_shaped : 1;
unsigned repeated_base : 1;
unsigned being_defined : 1;
+ unsigned java_interface : 1;
unsigned debug_requested : 1;
unsigned fields_readonly : 1;
unsigned ptrmemfunc_flag : 1;
@@ -2416,7 +2445,7 @@ struct GTY(()) lang_type {
/* There are some bits left to fill out a 32-bit word. Keep track
of this by updating the size of this bitfield whenever you add or
remove a flag. */
- unsigned dummy : 3;
+ unsigned dummy : 2;
tree primary_base;
vec<tree_pair_s, va_gc> *vcall_indices;
@@ -2614,6 +2643,11 @@ struct GTY(()) lang_type {
#define CLASSTYPE_ALIGN_UNIT(NODE) \
(CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)
+/* True if this a Java interface type, declared with
+ '__attribute__ ((java_interface))'. */
+#define TYPE_JAVA_INTERFACE(NODE) \
+ (LANG_TYPE_CLASS_CHECK (NODE)->java_interface)
+
/* A vec<tree> of virtual functions which cannot be inherited by
derived classes. When deriving from this type, the derived
class must provide its own definition for each of these functions. */
@@ -2860,7 +2894,7 @@ enum lang_decl_selector
struct GTY(()) lang_decl_base {
ENUM_BITFIELD(lang_decl_selector) selector : 3;
- ENUM_BITFIELD(languages) language : 1;
+ ENUM_BITFIELD(languages) language : 2;
unsigned use_template : 2;
unsigned not_really_extern : 1; /* var or fn */
unsigned initialized_in_class : 1; /* var or fn */
@@ -6556,6 +6590,9 @@ class_of_this_parm (const_tree fntype)
e.g "int f(void)". */
extern cp_parameter_declarator *no_parameters;
+/* True if we saw "#pragma GCC java_exceptions". */
+extern bool pragma_java_exceptions;
+
/* Various dump ids. */
extern int class_dump_id;
extern int module_dump_id;
@@ -6950,6 +6987,7 @@ extern tree do_aggregate_paren_init (tree, tree);
extern void record_mangling (tree, bool);
extern void overwrite_mangling (tree, tree);
extern void note_mangling_alias (tree, tree);
+extern bool check_java_method (tree);
extern void generate_mangling_aliases (void);
extern tree build_memfn_type (tree, tree, cp_cv_quals, cp_ref_qualifier);
extern tree build_pointer_ptrmemfn_type (tree);
@@ -7120,6 +7158,7 @@ extern tree build_vec_delete (location_t, tree, tree,
tsubst_flags_t);
extern tree create_temporary_var (tree);
extern void initialize_vtbl_ptrs (tree);
+extern tree build_java_class_ref (tree);
extern tree scalar_constant_value (tree);
extern tree decl_constant_value (tree, bool);
extern tree decl_really_constant_value (tree, bool = true);
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 06740d420d9..c91e65d1808 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -78,6 +78,7 @@ static void check_static_variable_definition (tree, tree);
static void record_unknown_type (tree, const char *);
static int member_function_or_else (tree, tree, enum overload_flags);
static tree local_variable_p_walkfn (tree *, int *, void *);
+static tree record_builtin_java_type (const char *, int);
static const char *tag_name (enum tag_types);
static tree lookup_and_check_tag (enum tag_types, tree, TAG_how, bool);
static void maybe_deduce_size_from_array_init (tree, tree);
@@ -4520,6 +4521,53 @@ record_builtin_type (enum rid rid_index,
}
}
+/* Record one of the standard Java types.
+ * Declare it as having the given NAME.
+ * If SIZE > 0, it is the size of one of the integral types;
+ * otherwise it is the negative of the size of one of the other types. */
+
+static tree
+record_builtin_java_type (const char* name, int size)
+{
+ tree type, decl;
+ if (size > 0)
+ {
+ type = build_nonstandard_integer_type (size, 0);
+ type = build_distinct_type_copy (type);
+ }
+ else if (size > -32)
+ {
+ tree stype;
+ /* "__java_char" or ""__java_boolean". */
+ type = build_nonstandard_integer_type (-size, 1);
+ type = build_distinct_type_copy (type);
+ /* Get the signed type cached and attached to the unsigned type,
+ so it doesn't get garbage-collected at "random" times,
+ causing potential codegen differences out of different UIDs
+ and different alias set numbers. */
+ stype = build_nonstandard_integer_type (-size, 0);
+ stype = build_distinct_type_copy (stype);
+ TREE_CHAIN (type) = stype;
+ /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
+ }
+ else
+ { /* "__java_float" or ""__java_double". */
+ type = make_node (REAL_TYPE);
+ TYPE_PRECISION (type) = - size;
+ layout_type (type);
+ }
+ record_builtin_type (RID_MAX, name, type);
+ decl = TYPE_NAME (type);
+
+ /* Suppress generate debug symbol entries for these types,
+ since for normal C++ they are just clutter.
+ However, push_lang_context undoes this if extern "Java" is seen. */
+ DECL_IGNORED_P (decl) = 1;
+
+ TYPE_FOR_JAVA (type) = 1;
+ return type;
+}
+
/* Push a type into the namespace so that the back ends ignore it. */
static void
@@ -4552,6 +4600,7 @@ initialize_predefined_identifiers (void)
static const predefined_identifier predefined_identifiers[] = {
{"C++", &lang_name_cplusplus, cik_normal},
{"C", &lang_name_c, cik_normal},
+ { "Java", &lang_name_java, cik_normal},
/* Some of these names have a trailing space so that it is
impossible for them to conflict with names written by users. */
{"__ct ", &ctor_identifier, cik_ctor},
@@ -4665,6 +4714,15 @@ cxx_init_decl_processing (void)
c_common_nodes_and_builtins ();
+ java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
+ java_short_type_node = record_builtin_java_type ("__java_short", 16);
+ java_int_type_node = record_builtin_java_type ("__java_int", 32);
+ java_long_type_node = record_builtin_java_type ("__java_long", 64);
+ java_float_type_node = record_builtin_java_type ("__java_float", -32);
+ java_double_type_node = record_builtin_java_type ("__java_double", -64);
+ java_char_type_node = record_builtin_java_type ("__java_char", -16);
+ java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
+
tree bool_ftype = build_function_type_list (boolean_type_node, NULL_TREE);
tree decl
= add_builtin_function ("__builtin_is_constant_evaluated",
@@ -8591,6 +8649,19 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
is *not* defined. */
&& (!DECL_EXTERNAL (decl) || init))
{
+ if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
+ {
+ tree jclass = get_global_binding (get_identifier ("jclass"));
+ /* Allow libjava/prims.cc define primitive classes. */
+ if (init != NULL_TREE
+ || jclass == NULL_TREE
+ || TREE_CODE (jclass) != TYPE_DECL
+ || !POINTER_TYPE_P (TREE_TYPE (jclass))
+ || !same_type_ignoring_top_level_qualifiers_p
+ (type, TREE_TYPE (TREE_TYPE (jclass))))
+ error ("Java object %qD not allocated with %<new%>", decl);
+ init = NULL_TREE;
+ }
cleanups = make_tree_vector ();
init = check_initializer (decl, init, flags, &cleanups);
@@ -8634,6 +8705,9 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
so that we can decide later to emit debug info for them. */
record_types_used_by_current_var_decl (decl);
}
+ else if (TREE_CODE (decl) == FIELD_DECL
+ && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
+ error ("non-static data member %qD has Java class type", decl);
/* Add this declaration to the statement-tree. This needs to happen
after the call to check_initializer so that the DECL_EXPR for a
@@ -10682,7 +10756,9 @@ grokfndecl (tree ctype,
check_main_parameter_types (decl);
}
- if (ctype != NULL_TREE && check)
+ if (ctype != NULL_TREE
+ && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
+ && check)
{
tree old_decl = check_classfn (ctype, decl,
(current_template_depth
@@ -11612,7 +11688,7 @@ check_special_function_return_type (special_function_kind sfk,
error_at (smallest_type_quals_location (type_quals, locations),
"qualifiers are not allowed on constructor declaration");
- if (targetm.cxx.cdtor_returns_this ())
+ if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
type = build_pointer_type (optype);
else
type = void_type_node;
@@ -11627,8 +11703,10 @@ check_special_function_return_type (special_function_kind sfk,
"qualifiers are not allowed on destructor declaration");
/* We can't use the proper return type here because we run into
- problems with ambiguous bases and covariant returns. */
- if (targetm.cxx.cdtor_returns_this ())
+ problems with ambiguous bases and covariant returns.
+ Java classes are left unchanged because (void *) isn't a valid
+ Java type, and we don't want to change the Java ABI. */
+ if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
type = build_pointer_type (void_type_node);
else
type = void_type_node;
@@ -13769,6 +13847,11 @@ grokdeclarator (const cp_declarator *declarator,
return error_mark_node;
}
+ /* Note that the grammar rejects storage classes
+ in typenames, fields or parameters. */
+ if (current_lang_name == lang_name_java)
+ TYPE_FOR_JAVA (type) = 1;
+
/* This declaration:
typedef void f(int) const;
@@ -15060,6 +15143,16 @@ grokparms (tree parmlist, tree *parms)
TREE_TYPE (decl) = error_mark_node;
}
+ if (type != error_mark_node
+ && TYPE_FOR_JAVA (type)
+ && MAYBE_CLASS_TYPE_P (type))
+ {
+ error ("parameter %qD has Java class type", decl);
+ type = error_mark_node;
+ TREE_TYPE (decl) = error_mark_node;
+ init = NULL_TREE;
+ }
+
if (type != error_mark_node)
{
if (deprecated_state != UNAVAILABLE_DEPRECATED_SUPPRESS)
@@ -16225,8 +16318,13 @@ xref_basetypes (tree ref, tree base_list)
}
if (max_bases > 1)
+ {
+ if (TYPE_FOR_JAVA (ref))
+ error ("Java class %qT cannot have multiple bases", ref);
+ else
warning (OPT_Wmultiple_inheritance,
"%qT defined with multiple direct bases", ref);
+ }
if (max_vbases)
{
@@ -16235,7 +16333,9 @@ xref_basetypes (tree ref, tree base_list)
vec_alloc (CLASSTYPE_VBASECLASSES (ref), max_vbases);
- if (max_dvbases)
+ if (TYPE_FOR_JAVA (ref))
+ error ("Java class %qT cannot have virtual bases", ref);
+ else if (max_dvbases)
warning (OPT_Wvirtual_inheritance,
"%qT defined with direct virtual base", ref);
}
@@ -16267,6 +16367,9 @@ xref_basetypes (tree ref, tree base_list)
goto dropped_base;
}
+ if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
+ TYPE_FOR_JAVA (ref) = 1;
+
base_binfo = NULL_TREE;
if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype))
{
@@ -17127,11 +17230,15 @@ check_function_type (tree decl, tree current_function_parms)
if (dependent_type_p (return_type)
|| type_uses_auto (return_type))
return;
- if (!COMPLETE_OR_VOID_TYPE_P (return_type))
+ if (!COMPLETE_OR_VOID_TYPE_P (return_type)
+ || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
{
tree args = TYPE_ARG_TYPES (fntype);
- error ("return type %q#T is incomplete", return_type);
+ if (!COMPLETE_OR_VOID_TYPE_P (return_type))
+ error ("return type %q#T is incomplete", return_type);
+ else
+ error ("return type has Java class type %q#T", return_type);
/* Make it return void instead. */
if (TREE_CODE (fntype) == METHOD_TYPE)
@@ -17747,7 +17854,8 @@ store_parm_decls (tree current_function_parms)
void
maybe_return_this (void)
{
- if (targetm.cxx.cdtor_returns_this ())
+ if (targetm.cxx.cdtor_returns_this ()
+ && (! TYPE_FOR_JAVA (current_class_type)))
{
/* Return the address of the object. */
tree val = DECL_ARGUMENTS (current_function_decl);
diff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc
index f95529a5c9a..c3a00a59e51 100644
--- a/gcc/cp/decl2.cc
+++ b/gcc/cp/decl2.cc
@@ -56,6 +56,7 @@ int raw_dump_id;
extern cpp_reader *parse_in;
+static bool acceptable_java_type (tree);
static tree start_objects (bool, unsigned, bool);
static tree finish_objects (bool, unsigned, tree, bool = true);
static tree start_partial_init_fini_fn (bool, unsigned, unsigned);
@@ -705,6 +706,80 @@ check_member_template (tree tmpl)
error ("template declaration of %q#D", decl);
}
+/* Return true iff TYPE is a valid Java parameter or return type. */
+
+static bool
+acceptable_java_type (tree type)
+{
+ if (type == error_mark_node)
+ return false;
+
+ if (VOID_TYPE_P (type) || TYPE_FOR_JAVA (type))
+ return true;
+ if (TYPE_PTR_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
+ {
+ type = TREE_TYPE (type);
+ if (TREE_CODE (type) == RECORD_TYPE)
+ {
+ tree args; int i;
+ if (! TYPE_FOR_JAVA (type))
+ return false;
+ if (! CLASSTYPE_TEMPLATE_INFO (type))
+ return true;
+ args = CLASSTYPE_TI_ARGS (type);
+ i = TREE_VEC_LENGTH (args);
+ while (--i >= 0)
+ {
+ type = TREE_VEC_ELT (args, i);
+ if (TYPE_PTR_P (type))
+ type = TREE_TYPE (type);
+ if (! TYPE_FOR_JAVA (type))
+ return false;
+ }
+ return true;
+ }
+ }
+ return false;
+}
+
+/* For a METHOD in a Java class CTYPE, return true if
+ the parameter and return types are valid Java types.
+ Otherwise, print appropriate error messages, and return false. */
+
+bool
+check_java_method (tree method)
+{
+ bool jerr = false;
+ tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
+ tree ret_type = TREE_TYPE (TREE_TYPE (method));
+
+ if (!acceptable_java_type (ret_type))
+ {
+ error ("Java method %qD has non-Java return type %qT",
+ method, ret_type);
+ jerr = true;
+ }
+
+ arg_types = TREE_CHAIN (arg_types);
+ if (DECL_HAS_IN_CHARGE_PARM_P (method))
+ arg_types = TREE_CHAIN (arg_types);
+ if (DECL_HAS_VTT_PARM_P (method))
+ arg_types = TREE_CHAIN (arg_types);
+
+ for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
+ {
+ tree type = TREE_VALUE (arg_types);
+ if (!acceptable_java_type (type))
+ {
+ if (type != error_mark_node)
+ error ("Java method %qD has non-Java parameter type %qT",
+ method, type);
+ jerr = true;
+ }
+ }
+ return !jerr;
+}
+
/* Sanity check: report error if this function FUNCTION is not
really a member of the class (CTYPE) it is supposed to belong to.
TEMPLATE_PARMS is used to specify the template parameters of a member
@@ -3248,8 +3323,10 @@ import_export_decl (tree decl)
{
class_type = DECL_CONTEXT (decl);
import_export_class (class_type);
- if (CLASSTYPE_INTERFACE_KNOWN (class_type)
- && CLASSTYPE_INTERFACE_ONLY (class_type))
+ if (TYPE_FOR_JAVA (class_type))
+ import_p = true;
+ else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
+ && CLASSTYPE_INTERFACE_ONLY (class_type))
import_p = true;
else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
&& !CLASSTYPE_USE_TEMPLATE (class_type)
@@ -4352,6 +4429,42 @@ generate_ctor_or_dtor_function (bool initp, unsigned priority,
expand_or_defer_fn (finish_objects (initp, priority, body, fns != NULL_TREE));
}
+/* Java requires that we be able to reference a local address for a
+ method, and not be confused by PLT entries. If supported, create a
+ hidden alias for all such methods. */
+
+static void
+build_java_method_aliases (void)
+{
+#ifndef HAVE_GAS_HIDDEN
+ return;
+#endif
+
+ struct cgraph_node *node;
+ FOR_EACH_FUNCTION (node)
+ {
+ tree fndecl = node->decl;
+
+ if (DECL_CLASS_SCOPE_P (fndecl)
+ && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
+ && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
+ {
+ /* Mangle the name in a predictable way; we need to reference
+ this from a java compiled object file. */
+ tree oid = DECL_ASSEMBLER_NAME (fndecl);
+ const char *oname = IDENTIFIER_POINTER (oid);
+ gcc_assert (oname[0] == '_' && oname[1] == 'Z');
+ char *nname = ACONCAT (("_ZGA", oname + 2, NULL));
+
+ tree alias = make_alias_for (fndecl, get_identifier (nname));
+ TREE_PUBLIC (alias) = 1;
+ DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
+
+ cgraph_node::create_same_body_alias (alias, fndecl);
+ }
+ }
+}
+
/* Return C++ property of T, based on given operation OP. */
static int
@@ -5242,6 +5355,9 @@ c_parse_final_cleanups (void)
/* Generate any missing aliases. */
maybe_apply_pending_pragma_weaks ();
+ /* Generate Java hidden aliases. */
+ build_java_method_aliases ();
+
if (flag_vtable_verify)
{
vtv_recover_class_info ();
@@ -5420,7 +5536,7 @@ possibly_inlined_p (tree decl)
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
if (DECL_UNINLINABLE (decl))
return false;
- if (!optimize)
+ if (!optimize || pragma_java_exceptions)
return DECL_DECLARED_INLINE_P (decl);
/* When optimizing, we might inline everything when flatten
attribute or heuristics inlining for size or autoinlining
diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc
index 12b28e8ee5b..efc07f1ed90 100644
--- a/gcc/cp/error.cc
+++ b/gcc/cp/error.cc
@@ -3339,6 +3339,9 @@ language_to_string (enum languages c)
case lang_cplusplus:
return "C++";
+ case lang_java:
+ return "Java";
+
default:
gcc_unreachable ();
}
diff --git a/gcc/cp/except.cc b/gcc/cp/except.cc
index 2677a9b7678..cb07d6d1783 100644
--- a/gcc/cp/except.cc
+++ b/gcc/cp/except.cc
@@ -36,6 +36,7 @@ static tree prepare_eh_type (tree);
static tree do_begin_catch (void);
static int dtor_nothrow (tree);
static tree do_end_catch (tree);
+static bool decl_is_java_type (tree decl, int err);
static void initialize_handler_parm (tree, tree);
static tree do_allocate_exception (tree);
static tree wrap_cleanups_r (tree *, int *, void *);
@@ -103,10 +104,17 @@ prepare_eh_type (tree type)
tree
eh_type_info (tree type)
{
+ tree exp;
+
if (type == NULL_TREE || type == error_mark_node)
return type;
- return get_tinfo_decl (type);
+ if (decl_is_java_type (type, 0))
+ exp = build_java_class_ref (TREE_TYPE (type));
+ else
+ exp = get_tinfo_decl (type);
+
+ return exp;
}
/* Build the address of a typeinfo decl for use in the runtime
@@ -270,6 +278,107 @@ push_eh_cleanup (tree type)
finish_decl_cleanup (NULL_TREE, do_end_catch (type));
}
+/* Return nonzero value if DECL is a Java type suitable for catch or
+ throw. */
+
+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
+ = get_global_binding (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;
+}
+
+/* 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 DECL_FUNCTION_PERSONALITY is set via
+ LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
+void
+choose_personality_routine (enum languages lang)
+{
+ static enum {
+ chose_none,
+ chose_cpp,
+ chose_java,
+ gave_error
+ } state;
+
+ switch (state)
+ {
+ case gave_error:
+ return;
+
+ case chose_cpp:
+ if (lang != lang_cplusplus)
+ goto give_error;
+ return;
+
+ case chose_java:
+ if (lang != lang_java)
+ goto give_error;
+ return;
+
+ case chose_none:
+ ; /* Proceed to language selection. */
+ }
+
+ switch (lang)
+ {
+ case lang_cplusplus:
+ state = chose_cpp;
+ break;
+
+ case lang_java:
+ state = chose_java;
+ terminate_fn = builtin_decl_explicit (BUILT_IN_ABORT);
+ pragma_java_exceptions = true;
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+ return;
+
+ give_error:
+ error ("mixing C++ and Java catches in a single translation unit");
+ state = gave_error;
+}
+
/* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
not throw any exceptions if COND is true. A condition of
NULL_TREE is treated as 'true'. */
@@ -325,6 +434,9 @@ initialize_handler_parm (tree decl, tree exp)
if (!INDIRECT_TYPE_P (init_type))
init_type = build_reference_type (init_type);
+ choose_personality_routine (decl_is_java_type (init_type, 0)
+ ? lang_java : lang_cplusplus);
+
/* Since pointers are passed by value, initialize a reference to
pointer catch parm with the address of the temporary. */
if (TYPE_REF_P (init_type)
@@ -404,6 +516,22 @@ expand_start_catch_block (tree decl)
else
type = NULL_TREE;
+ if (decl && decl_is_java_type (type, 1))
+ {
+ /* Java only passes object via pointer and doesn't require
+ adjusting. The java object is immediately before the
+ generic exception header. */
+ exp = build_exc_ptr ();
+ exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
+ exp = fold_build_pointer_plus (exp,
+ fold_build1_loc (input_location,
+ NEGATE_EXPR, sizetype,
+ TYPE_SIZE_UNIT (TREE_TYPE (exp))));
+ exp = cp_build_fold_indirect_ref (exp);
+ initialize_handler_parm (decl, exp);
+ return type;
+ }
+
/* Call __cxa_end_catch at the end of processing the exception. */
push_eh_cleanup (type);
@@ -631,7 +759,27 @@ build_throw (location_t loc, tree exp)
if (! doing_eh ())
return error_mark_node;
- if (exp)
+ if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
+ {
+ tree name = get_identifier ("_Jv_Throw");
+ tree fn = get_global_binding (name);
+ if (!fn)
+ {
+ /* Declare void _Jv_Throw (void *). */
+ tree tmp;
+ tmp = build_function_type_list (ptr_type_node,
+ ptr_type_node, NULL_TREE);
+ fn = push_throw_library_fn (name, tmp);
+ }
+ else if (really_overloaded_fn (fn))
+ {
+ error ("%qD should never be overloaded", fn);
+ return error_mark_node;
+ }
+ exp = cp_build_function_call_nary (fn, tf_warning_or_error,
+ exp, NULL_TREE);
+ }
+ else if (exp)
{
tree throw_type;
tree temp_type;
diff --git a/gcc/cp/init.cc b/gcc/cp/init.cc
index 2fff4ad2dc7..1885f2058b7 100644
--- a/gcc/cp/init.cc
+++ b/gcc/cp/init.cc
@@ -3037,6 +3037,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
tree alloc_fn;
tree cookie_expr, init_expr;
int nothrow, check_new;
+ int use_java_new = 0;
/* If non-NULL, the number of extra bytes to allocate at the
beginning of the storage allocated for an array-new expression in
order to store the number of elements. */
@@ -3307,7 +3308,62 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
bool member_new_p = false;
+ bool member_delete_p = (!globally_qualified_p
+ && CLASS_TYPE_P (elt_type)
+ && (array_p
+ ? TYPE_GETS_VEC_DELETE (elt_type)
+ : TYPE_GETS_REG_DELETE (elt_type)));
+
/* Allocate the object. */
+ if (vec_safe_is_empty (*placement) && TYPE_FOR_JAVA (elt_type))
+ {
+ tree class_addr;
+ tree class_decl;
+ static const char alloc_name[] = "_Jv_AllocObject";
+
+ if (!MAYBE_CLASS_TYPE_P (elt_type))
+ {
+ error ("%qT isn%'t a valid Java class type", elt_type);
+ return error_mark_node;
+ }
+
+ class_decl = build_java_class_ref (elt_type);
+ if (class_decl == error_mark_node)
+ return error_mark_node;
+
+ use_java_new = 1;
+
+ if (!(alloc_fn = get_global_binding (get_identifier (alloc_name))))
+ {
+ if (complain & tf_error)
+ error ("call to Java constructor with %qs undefined", alloc_name);
+ return error_mark_node;
+ }
+ else if (really_overloaded_fn (alloc_fn))
+ {
+ if (complain & tf_error)
+ error ("%qD should never be overloaded", alloc_fn);
+ return error_mark_node;
+ }
+ if (TREE_CODE (alloc_fn) != FUNCTION_DECL
+ || TREE_CODE (TREE_TYPE (alloc_fn)) != FUNCTION_TYPE
+ || !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (alloc_fn))))
+ {
+ if (complain & tf_error)
+ error ("%qD is not a function returning a pointer", alloc_fn);
+ return error_mark_node;
+ }
+ class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
+ alloc_call = cp_build_function_call_nary (alloc_fn, complain,
+ class_addr, NULL_TREE);
+ }
+ else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
+ {
+ error ("Java class %q#T object allocated using placement new", elt_type);
+ return error_mark_node;
+ }
+ else
+ {
tree fnname;
tree fns;
@@ -3319,12 +3375,6 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
: TYPE_HAS_NEW_OPERATOR (elt_type));
- bool member_delete_p = (!globally_qualified_p
- && CLASS_TYPE_P (elt_type)
- && (array_p
- ? TYPE_GETS_VEC_DELETE (elt_type)
- : TYPE_GETS_REG_DELETE (elt_type)));
-
if (member_new_p)
{
/* Use a class-specific operator new. */
@@ -3409,8 +3459,11 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
alloc_call = build_operator_new_call (fnname, placement,
&size, &cookie_size,
- align_arg, outer_nelts_check,
+ align_arg,
+ outer_nelts_check,
&alloc_fn, complain);
+
+ }
}
if (alloc_call == error_mark_node)
@@ -3523,8 +3576,9 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
So check for a null exception spec on the op new we just called. */
nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
- check_new
- = flag_check_new || (nothrow && !std_placement_new_fn_p (alloc_fn));
+ check_new = (flag_check_new
+ || (nothrow && !std_placement_new_fn_p (alloc_fn)))
+ && ! use_java_new;
if (cookie_size)
{
@@ -3728,7 +3782,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
unambiguous matching deallocation function can be found,
propagating the exception does not cause the object's memory to be
freed. */
- if (flag_exceptions && (init_expr || member_delete_p))
+ if (flag_exceptions && (init_expr || member_delete_p) && ! use_java_new)
{
enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
tree cleanup;
@@ -4028,6 +4082,60 @@ build_new (location_t loc, vec<tree, va_gc> **placement, tree type,
return rval;
}
+
+/* Given a Java class, return a decl for the corresponding java.lang.Class. */
+
+tree
+build_java_class_ref (tree type)
+{
+ tree name = NULL_TREE, class_decl;
+ static tree CL_suffix = NULL_TREE;
+ if (CL_suffix == NULL_TREE)
+ CL_suffix = get_identifier("class$");
+ if (jclass_node == NULL_TREE)
+ {
+ jclass_node = get_global_binding (get_identifier ("jclass"));
+ if (jclass_node == NULL_TREE)
+ {
+ error ("call to Java constructor, while %<jclass%> undefined");
+ return error_mark_node;
+ }
+ jclass_node = TREE_TYPE (jclass_node);
+ }
+
+ /* Mangle the class$ field. */
+ {
+ tree field;
+ for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+ if (DECL_NAME (field) == CL_suffix)
+ {
+ mangle_decl (field);
+ name = DECL_ASSEMBLER_NAME (field);
+ break;
+ }
+ if (!field)
+ {
+ error ("cannot find %<class$%> in %qT", type);
+ return error_mark_node;
+ }
+ }
+
+ class_decl = get_global_binding (name);
+ if (class_decl == NULL_TREE)
+ {
+ class_decl = build_decl (input_location,
+ VAR_DECL, name, TREE_TYPE (jclass_node));
+ TREE_STATIC (class_decl) = 1;
+ DECL_EXTERNAL (class_decl) = 1;
+ TREE_PUBLIC (class_decl) = 1;
+ DECL_ARTIFICIAL (class_decl) = 1;
+ DECL_IGNORED_P (class_decl) = 1;
+ pushdecl_top_level (class_decl);
+ make_decl_rtl (class_decl);
+ }
+ return class_decl;
+}
+
static tree
build_vec_delete_1 (location_t loc, tree base, tree maxindex, tree type,
diff --git a/gcc/cp/lex.cc b/gcc/cp/lex.cc
index 22d1ab92add..d9ab437b411 100644
--- a/gcc/cp/lex.cc
+++ b/gcc/cp/lex.cc
@@ -42,6 +42,7 @@ static void handle_pragma_vtable (cpp_reader *);
static void handle_pragma_unit (cpp_reader *);
static void handle_pragma_interface (cpp_reader *);
static void handle_pragma_implementation (cpp_reader *);
+static void handle_pragma_java_exceptions (cpp_reader *);
static void init_operators (void);
static void copy_lang_type (tree);
@@ -75,6 +76,9 @@ struct impl_files
};
static struct impl_files *impl_file_chain;
+
+/* True if we saw "#pragma GCC java_exceptions". */
+bool pragma_java_exceptions;
void
cxx_finish (void)
@@ -292,6 +296,7 @@ init_cp_pragma (void)
c_register_pragma (0, "implementation", handle_pragma_implementation);
c_register_pragma ("GCC", "interface", handle_pragma_interface);
c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
+ c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
}
/* TRUE if a code represents a statement. */
@@ -704,6 +709,17 @@ handle_pragma_implementation (cpp_reader* /*dfile*/)
impl_file_chain = ifiles;
}
}
+/* Indicate that this file uses Java-personality exception handling. */
+static void
+handle_pragma_java_exceptions (cpp_reader* /*dfile*/)
+{
+ tree x;
+ if (pragma_lex (&x) != CPP_EOF)
+ warning (0, "junk at end of %<#pragma GCC%> %<java_exceptions%>");
+
+ choose_personality_routine (lang_java);
+ pragma_java_exceptions = true;
+}
/* Issue an error message indicating that the lookup of NAME (an
IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
@@ -934,6 +950,8 @@ set_decl_linkage (tree t)
SET_DECL_LANGUAGE (t, lang_cplusplus);
else if (current_lang_name == lang_name_c)
SET_DECL_LANGUAGE (t, lang_c);
+ else if (current_lang_name == lang_name_java)
+ SET_DECL_LANGUAGE (t, lang_java);
else
gcc_unreachable ();
}
diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index e363ef35b9f..bf043609cd1 100644
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -245,6 +245,10 @@ static bool equal_abi_tags (tree, tree);
static inline void start_mangling (const tree);
static tree mangle_special_for_type (const tree, const char *);
+/* Foreign language functions. */
+
+static void write_java_integer_type_codes (const tree);
+
/* Append a single character to the end of the mangled
representation. */
#define write_char(CHAR) \
@@ -2671,6 +2675,8 @@ write_builtin_type (tree type)
write_string ("Ds");
else if (type == char32_type_node)
write_string ("Di");
+ else if (TYPE_FOR_JAVA (type))
+ write_java_integer_type_codes (type);
else
{
size_t itk;
@@ -2725,9 +2731,9 @@ write_builtin_type (tree type)
break;
case REAL_TYPE:
- if (type == float_type_node)
+ if (type == float_type_node || type == java_float_type_node)
write_char ('f');
- else if (type == double_type_node)
+ else if (type == double_type_node || type == java_double_type_node)
write_char ('d');
else if (type == long_double_type_node)
write_char ('e');
@@ -2815,16 +2821,40 @@ write_function_type (const tree type)
/* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
is mangled before the parameter types. If non-NULL, DECL is
- FUNCTION_DECL for the function whose type is being emitted. */
+ FUNCTION_DECL for the function whose type is being emitted.
+
+ If DECL is a member of a Java type, then a literal 'J'
+ is output and the return type is mangled as if INCLUDE_RETURN_TYPE
+ were nonzero.
+
+ <bare-function-type> ::= [J]</signature/ type>+ */
static void
write_bare_function_type (const tree type, const int include_return_type_p,
const tree decl)
{
+ int java_method_p;
+
MANGLE_TRACE_TREE ("bare-function-type", type);
+ /* Detect Java methods and emit special encoding. */
+ if (decl != NULL
+ && DECL_FUNCTION_MEMBER_P (decl)
+ && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
+ && !DECL_CONSTRUCTOR_P (decl)
+ && !DECL_DESTRUCTOR_P (decl)
+ && !DECL_CONV_FN_P (decl))
+ {
+ java_method_p = 1;
+ write_char ('J');
+ }
+ else
+ {
+ java_method_p = 0;
+ }
+
/* Mangle the return type, if requested. */
- if (include_return_type_p)
+ if (include_return_type_p || java_method_p)
write_type (TREE_TYPE (type));
/* Now mangle the types of the arguments. */
@@ -4608,6 +4638,30 @@ mangle_template_parm_object (tree expr)
return finish_mangling_get_identifier ();
}
+
+/* Foreign language type mangling section. */
+
+/* How to write the type codes for the integer Java type. */
+
+static void
+write_java_integer_type_codes (const tree type)
+{
+ if (type == java_int_type_node)
+ write_char ('i');
+ else if (type == java_short_type_node)
+ write_char ('s');
+ else if (type == java_byte_type_node)
+ write_char ('c');
+ else if (type == java_char_type_node)
+ write_char ('w');
+ else if (type == java_long_type_node)
+ write_char ('x');
+ else if (type == java_boolean_type_node)
+ write_char ('b');
+ else
+ gcc_unreachable ();
+}
+
/* Given a CLASS_TYPE, such as a record for std::bad_exception this
function generates a mangled name for the vtable map variable of
the class type. For example, if the class type is
diff --git a/gcc/cp/method.cc b/gcc/cp/method.cc
index 1e962b6e3b1..5ddc5079e58 100644
--- a/gcc/cp/method.cc
+++ b/gcc/cp/method.cc
@@ -3091,7 +3091,7 @@ implicitly_declare_fn (special_function_kind kind, tree type,
type = TYPE_MAIN_VARIANT (type);
- if (targetm.cxx.cdtor_returns_this ())
+ if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
{
if (kind == sfk_destructor)
/* See comment in check_special_function_return_type. */
diff --git a/gcc/cp/name-lookup.cc b/gcc/cp/name-lookup.cc
index b5f6e84cad9..bbfdbe384d7 100644
--- a/gcc/cp/name-lookup.cc
+++ b/gcc/cp/name-lookup.cc
@@ -7906,6 +7906,9 @@ pushtag (tree name, tree type, TAG_how how)
if (!context)
context = current_namespace;
+ if (current_lang_name == lang_name_java)
+ TYPE_FOR_JAVA (type) = 1;
+
tdef = create_implicit_typedef (name, type);
DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
set_originating_module (tdef);
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index fbf498ad16a..7f46ca2bd7d 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -957,6 +957,7 @@ maybe_new_partial_specialization (tree& type)
for the newly declared specialization. */
tree t = make_class_type (TREE_CODE (type));
CLASSTYPE_DECLARED_CLASS (t) = CLASSTYPE_DECLARED_CLASS (type);
+ TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (type);
SET_TYPE_TEMPLATE_INFO (t, build_template_info (tmpl, args));
/* We only need a separate type node for storing the definition of this
@@ -10059,6 +10060,7 @@ lookup_template_class (tree d1, tree arglist, tree in_decl, tree context,
CLASSTYPE_DECLARED_CLASS (t)
= CLASSTYPE_DECLARED_CLASS (template_type);
SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
+ TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
/* A local class. Make sure the decl gets registered properly. */
if (context == current_function_decl)
@@ -12062,6 +12064,7 @@ instantiate_class_template (tree type)
TYPE_PACKED (type) = TYPE_PACKED (pattern);
SET_TYPE_ALIGN (type, TYPE_ALIGN (pattern));
TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
+ TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
CLASSTYPE_NON_AGGREGATE (type) = CLASSTYPE_NON_AGGREGATE (pattern);
if (ANON_AGGR_TYPE_P (pattern))
SET_ANON_AGGR_TYPE_P (type);
diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index 04a055d9d77..282f3dde124 100644
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -44,6 +44,7 @@ static tree build_target_expr (tree, tree, tsubst_flags_t);
static tree count_trees_r (tree *, int *, void *);
static tree verify_stmt_tree_r (tree *, int *, void *);
+static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *);
static tree handle_contract_attribute (tree *, tree, tree, int, bool *);
@@ -5088,6 +5089,8 @@ const struct attribute_spec cxx_attribute_table[] =
{
/* { name, min_len, max_len, decl_req, type_req, fn_type_req,
affects_type_identity, handler, exclude } */
+ { "java_interface", 0, 0, false, false, false, false,
+ handle_java_interface_attribute, NULL },
{ "init_priority", 1, 1, true, false, false, false,
handle_init_priority_attribute, NULL },
{ "abi_tag", 1, -1, false, false, false, true,
@@ -5121,6 +5124,31 @@ const struct attribute_spec std_attribute_table[] =
{ NULL, 0, 0, false, false, false, false, NULL, NULL }
};
+/* Handle a "java_interface" attribute; arguments as in
+ struct attribute_spec.handler. */
+static tree
+handle_java_interface_attribute (tree* node,
+ tree name,
+ tree /*args*/,
+ int flags,
+ bool* no_add_attrs)
+{
+ if (DECL_P (*node)
+ || !CLASS_TYPE_P (*node)
+ || !TYPE_FOR_JAVA (*node))
+ {
+ error ("%qE attribute can only be applied to Java class definitions",
+ name);
+ *no_add_attrs = true;
+ return NULL_TREE;
+ }
+ if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
+ *node = build_variant_type_copy (*node);
+ TYPE_JAVA_INTERFACE (*node) = 1;
+
+ return NULL_TREE;
+}
+
/* Handle an "init_priority" attribute; arguments as in
struct attribute_spec.handler. */
static tree
diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index d5757b27f49..093817d8489 100644
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -1458,6 +1458,8 @@ structural_comptypes (tree t1, tree t2, int strict)
ce_type))
return false;
}
+ if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
+ return false;
/* Allow for two different type nodes which have essentially the same
definition. Note that we already checked for equality of the type
diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc
index e81044b8c48..b3a346a7b5a 100644
--- a/gcc/dwarf2out.cc
+++ b/gcc/dwarf2out.cc
@@ -5571,6 +5571,16 @@ is_cxx (const_tree decl)
return is_cxx ();
}
+/* Return TRUE if the language is Java. */
+
+static inline bool
+is_java (void)
+{
+ unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
+
+ return lang == DW_LANG_Java;
+}
+
/* Return TRUE if the language is Fortran. */
static inline bool
@@ -11629,7 +11639,7 @@ output_pubname (dw_offset die_offset, pubname_entry *entry)
case DW_TAG_enumerator:
GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
GDB_INDEX_SYMBOL_KIND_VARIABLE);
- if (!is_cxx ())
+ if (!is_cxx () && !is_java ())
GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
break;
case DW_TAG_subprogram:
@@ -11658,7 +11668,7 @@ output_pubname (dw_offset die_offset, pubname_entry *entry)
case DW_TAG_union_type:
case DW_TAG_enumeration_type:
GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
- if (!is_cxx ())
+ if (!is_cxx () && !is_java ())
GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
break;
default:
@@ -21505,6 +21515,7 @@ lower_bound_default (void)
case DW_LANG_C_plus_plus_14:
case DW_LANG_ObjC:
case DW_LANG_ObjC_plus_plus:
+ case DW_LANG_Java:
return 0;
case DW_LANG_Fortran77:
case DW_LANG_Fortran90:
@@ -25221,6 +25232,8 @@ gen_compile_unit_die (const char *filename)
language = DW_LANG_Fortran08;
}
}
+ else if (strcmp (language_string, "GNU Java") == 0)
+ language = DW_LANG_Java;
else if (strcmp (language_string, "GNU Objective-C") == 0)
language = DW_LANG_ObjC;
else if (strcmp (language_string, "GNU Objective-C++") == 0)
diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc
index eb562c3a313..845038151c3 100644
--- a/gcc/gimplify.cc
+++ b/gcc/gimplify.cc
@@ -892,7 +892,12 @@ mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
/* Stop at types, decls, constants like copy_tree_r. */
else if (TREE_CODE_CLASS (code) == tcc_type
|| TREE_CODE_CLASS (code) == tcc_declaration
- || TREE_CODE_CLASS (code) == tcc_constant)
+ || TREE_CODE_CLASS (code) == tcc_constant
+ /* We can't do anything sensible with a BLOCK used as an
+ expression, but we also can't just die when we see it
+ because of non-expression uses. So we avert our eyes
+ and cross our fingers. Silly Java. */
+ || code == BLOCK)
*walk_subtrees = 0;
/* Cope with the statement expression extension. */
diff --git a/gcc/ipa-free-lang-data.cc b/gcc/ipa-free-lang-data.cc
index ccdbf849c25..d82dab852d8 100644
--- a/gcc/ipa-free-lang-data.cc
+++ b/gcc/ipa-free-lang-data.cc
@@ -451,6 +451,8 @@ free_lang_data_in_type (tree type, class free_lang_data_d *fld)
/* C++ FE uses TREE_PURPOSE to store initial values. */
TREE_PURPOSE (p) = NULL;
}
+ /* Java uses TYPE_MIN_VALUE for TYPE_ARGUMENT_SIGNATURE. */
+ TYPE_MIN_VALUE (type) = NULL;
}
else if (TREE_CODE (type) == METHOD_TYPE)
{
@@ -461,6 +463,8 @@ free_lang_data_in_type (tree type, class free_lang_data_d *fld)
TREE_VALUE (p) = fld_simplified_type (TREE_VALUE (p), fld);
TREE_PURPOSE (p) = NULL;
}
+ /* Java uses TYPE_MIN_VALUE for TYPE_ARGUMENT_SIGNATURE. */
+ TYPE_MIN_VALUE (type) = NULL;
}
else if (RECORD_OR_UNION_TYPE_P (type))
{
@@ -798,8 +802,16 @@ find_decls_types_r (tree *tp, int *ws, void *data)
tree tem;
FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem)
fld_worklist_push (TREE_TYPE (tem), fld);
- fld_worklist_push (BINFO_TYPE (TYPE_BINFO (t)), fld);
- fld_worklist_push (BINFO_VTABLE (TYPE_BINFO (t)), fld);
+ tem = BINFO_VIRTUALS (TYPE_BINFO (t));
+ if (tem
+ /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
+ && TREE_CODE (tem) == TREE_LIST)
+ do
+ {
+ fld_worklist_push (TREE_VALUE (tem), fld);
+ tem = TREE_CHAIN (tem);
+ }
+ while (tem);
}
if (RECORD_OR_UNION_TYPE_P (t))
{
diff --git a/gcc/tree.cc b/gcc/tree.cc
index 0dbac1cb1f4..eb7994d7cae 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -13900,8 +13900,17 @@ verify_type (const_tree t)
TREE_TYPE (TYPE_MIN_VALUE (t))
but does not for C sizetypes in LTO. */
}
+ /* Java uses TYPE_MIN_VALUE_RAW for TYPE_ARGUMENT_SIGNATURE. */
+ else if (TYPE_MIN_VALUE_RAW (t)
+ && ((TREE_CODE (t) != METHOD_TYPE && TREE_CODE (t) != FUNCTION_TYPE)
+ || in_lto_p))
+ {
+ error ("%<TYPE_MIN_VALUE_RAW%> non-NULL");
+ debug_tree (TYPE_MIN_VALUE_RAW (t));
+ error_found = true;
+ }
- /* Check various uses of TYPE_MAXVAL_RAW. */
+ /* Check various uses of TYPE_MAX_VALUE_RAW. */
if (RECORD_OR_UNION_TYPE_P (t))
{
if (!TYPE_BINFO (t))
@@ -13912,7 +13921,9 @@ verify_type (const_tree t)
debug_tree (TYPE_BINFO (t));
error_found = true;
}
- else if (TREE_TYPE (TYPE_BINFO (t)) != TYPE_MAIN_VARIANT (t))
+ /* FIXME: Java builds invalid empty binfos that do not have
+ TREE_TYPE set. */
+ else if (TREE_TYPE (TYPE_BINFO (t)) != TYPE_MAIN_VARIANT (t) && 0)
{
error ("%<TYPE_BINFO%> type is not %<TYPE_MAIN_VARIANT%>");
debug_tree (TREE_TYPE (TYPE_BINFO (t)));
@@ -14118,6 +14129,21 @@ verify_type (const_tree t)
error ("%<TYPE_CACHED_VALUES_P%> is set while it should not be");
error_found = true;
}
+ else if ((TREE_CODE (t) == ARRAY_TYPE || TREE_CODE (t) == INTEGER_TYPE)
+ && TYPE_STRING_FLAG (t))
+ {
+ const_tree b = t;
+ if (TREE_CODE (b) == ARRAY_TYPE)
+ b = TREE_TYPE (t);
+ /* Java builds arrays with TYPE_STRING_FLAG of promoted_char_type
+ that is 32bits. */
+ if (TREE_CODE (b) != INTEGER_TYPE)
+ {
+ error ("%<TYPE_STRING_FLAG%> is set on type that does not look like "
+ "%<char%> nor array of chars");
+ error_found = true;
+ }
+ }
/* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always
TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns
--
2.38.1
