OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert last patch

Browse Source 
From-SVN: r34474
This commit is contained in:
Mark Mitchell 2000-06-09 16:45:22 +00:00
parent bb779a5274
commit 4d8a1dd6c6
5 changed files with 36 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
gcc/cp/ChangeLog
View File

@ -1,19 +1,3 @@
2000-06-09 Mark Mitchell <mark@codesourcery.com>
* cp-tree.h (cp_tree_index): Remove Java types.
(java_fundamental_type_kind): New enumeration type.
(java_fundamental_types): New array.
* class.c (push_lang_context): Use java_fundamental_types.
* decl.c (java_fundamental_types): Define it.
(initialize_java_fundamental_types): New function.
(init_decl_processing): Call it
* mangle.c (integer_type_codes): Make it const.
(java_fundamental_type_codes): New variable.
(write_source_name_from_string): New function.
(write_identifier): Constify.
(write_builtin_type): Handle Java types. Use same_type_p for type
comparison.
2000-06-09 Jason Merrill <jason@casey.soma.redhat.com>
* semantics.c (expand_body): Push to TV_EXPAND.
@ -22,137 +6,6 @@
* tinfo2.cc: Just declare abort.
2000-06-08 Mark Mitchell <mark@codesourcery.com>
Remove old ABI mangling code.
* cp-tree.h (cp_tree_index): Remove CPTI_TINFO_DECL_ID and
CPTI_TINFO_VAR_ID.
(tinfo_decl_id): Remove.
(tinfo_var_id): Likewise.
(name_mangling_version): Likewise.
(flag_do_squangling): Likewise.
(get_vtt_name): Likewise.
(init_method): Likewise.
(build_overload_name): Likewise.
(build_static_name): Likewise.
(build_decl_overload_real): Likewise.
(build_overload_with_type): Likewise.
(build_destructor_name): Likewise.
(get_id_2): Likewise.
(get_ctor_vtbl_name): Likewise.
(mangle_typeinfo_fn_for_type): New function.
(mangle_java_reflection_var_for_type): Likewise.
* call.c (build_new_method_call): Use mangle_vtt_for_type.
* class.c (get_vtable_name): Remove.
(get_vtt_name): Remove.
(get_vtable_decl): Use mangle_vtbl_for_type.
(build_vtt): Likewise.
(build_ctor_vtbl_group): Remove old ABI mangling support.
* decl.c (pushtag): Likewise.
(maybe_commonize_var): Use set_mangled_name_for_decl.
(grokfndecl): Remove old ABI mangling support.
(grokvardecl): Likewise.
(grokdeclarator): Likewise.
(grok_op_properties): Adjust use of DEF_OPERATOR.
* decl2.c (name_mangling_version): Remove.
(lang_f_options): Remove squangle.
(unsupported_options): Add squangle.
(lang_decode_options): Don't set flag_do_squangling. Issue a
warning for -fname-mangling-version.
(grokclassfn): Remove old ABI mangling support.
(finish_static_data_member_decl): Likewise.
(grokfield): Likewise.
(grokoptypename): Likewise.
(get_sentry): Likewise.
* init.c (build_java_class_ref): Use
mangle_java_reflection_var_for_type.
* lex.c (init_operators): Adjust use of DEF_OPERATOR.
(init_parse): Call init_mangle, not init_method.
* mangle.c (write_special_name_constructor): Handle
maybe-in-charge constructors.
(write_special_name_destructor): Handle
maybe-in-charge destructors.
(write_expression): Tweak code to handle non-type template
arguments with reference type.
(mangle_typeinfo_fn_for_type): New function.
(mangle_java_reflection_var_for_type): Likewise.
(mangle_conv_op_name_for_type): Don't use a name that the user
could type.
* method.c (enum mangling_flags): Remove.
(mangling_flags): Likewise.
(obstack_chunk_alloc): Likewise.
(obstack_chunk_free): Likewise.
(OB_INIT): Likewise.
(OB_PUTC): Likewise.
(OB_PUTC2): Likewise.
(OB_PUTS): Likewise.
(OB_PUTID): Likewise.
(OB_PUTCP): Likewise.
(OB_FINISH): Likewise.
(OB_LAST): Likewise.
(btypelist): Likewise.
(ktypelist): Likewise.
(maxbtype): Likewise.
(maxktype): Likewise.
(typevec): Likewise.
(maxtype): Likewise.
(init_method): Likewise.
(digit_buffer): Likewise.
(nofold): Likewise.
(start_squangling): Likewise.
(end_squangling): Likewise.
(icat): Likewise.
(dicat): Likewise.
(old_backref_index): Likewise.
(flush_repeats): Likewise.
(is_back_referenceable_type): Likewise.
(issue_nrepeats): Likewise.
(check_ktype): Likewise.
(issue_ktype): Likewise.
(build_overload_nested_name): Likewise.
(build_underscore_int): Likewise.
(build_overload_scope_ref): Likewise.
(mangle_expression): Likewise.
(build_overload_int): Likewise.
(mangled_C9x_name): Likewise.
(build_overload_value): Likewise.
(build_template_template_parm_names): Likewise.
(build_template_parm_names): Likewise.
(build_overload_identifier): Likewise.
(build_qualified_name): Likewise.
(build_mangled_name_for_type_with_Gcode): Likewise.
(build_mangled_name_for_type): Likewise.
(build_overload_name): Likewise.
(build_mangled_name): Likewise.
(process_modifiers): Likewise.
(check_btype): Likewise.
(process_overload_item): Likewise.
(build_static_name): Likewise.
(build_decl_overload_real): Likewise.
(set_mangled_name_for_decl): Remove old ABI mangling support.
(build_typename_overload): Remove.
(build_overload_with_type): Remove.
(get_id_2): Remove.
(get_ctor_vtbl_name): Remove.
(build_destructor_name): Likewise.
(set_mangled_name_for_decl): Likewise.
(make_thunk): Remove old ABI mangling support.
* operators.def: Likewise.
* pt.c (check_explicit_specialization): Don't call
set_mangled_name_for_template_decl.
(lookup_template_class): Remove old ABI mangling support.
(tsubst_friend_function): Update comment.
(tsubst_decl): Remove old ABI mangling support.
(tsubst_copy): Likewise.
(set_mangled_name_for_template_decl): Remove.
* rtti.c (init_rtti_processing): Use std_identifier. Don't set
tinfo_decl_id or tinfo_var_id.
(get_tinfo_var): Use mangle_typeinfo_for_type.
(tinfo_name): Remove old ABI mangling support.
(get_tinfo_decl): Likewise.
(tinfo_base_init): Likewise.
(create_real_tinfo_var): Use a name that the user can't type.
2000-06-09 Gabriel Dos Reis <gdr@codesourcery.com>
* lex.c (DEF_OPERATOR): Say `operator@' -not- `operator @'

12
gcc/cp/class.c
View File

@ -5642,16 +5642,20 @@ push_lang_context (name)
}
else if (name == lang_name_java)
{
java_fundamental_type_kind jtk;
strict_prototype = strict_prototypes_lang_cplusplus;
current_lang_name = name;
/* DECL_IGNORED_P is initially set for these types, to avoid clutter.
(See record_builtin_java_type in decl.c.) However, that causes
incorrect debug entries if these types are actually used.
So we re-enable debug output after extern "Java". */
for (jtk = jtk_first; jtk < jtk_last; ++jtk)
DECL_IGNORED_P (java_fundamental_types[jtk]) = 0;
DECL_IGNORED_P (java_byte_type_node) = 0;
DECL_IGNORED_P (java_short_type_node) = 0;
DECL_IGNORED_P (java_int_type_node) = 0;
DECL_IGNORED_P (java_long_type_node) = 0;
DECL_IGNORED_P (java_float_type_node) = 0;
DECL_IGNORED_P (java_double_type_node) = 0;
DECL_IGNORED_P (java_char_type_node) = 0;
DECL_IGNORED_P (java_boolean_type_node) = 0;
}
else if (name == lang_name_c)
{

29
gcc/cp/cp-tree.h
View File

@ -599,6 +599,15 @@ enum cp_tree_index
extern 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 void_zero_node cp_global_trees[CPTI_VOID_ZERO]
#define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL]
#define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
@ -728,26 +737,6 @@ extern tree cp_global_trees[CPTI_MAX];
destructors. */
#define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE]
/* The various kinds of fundamental Java types. */
typedef enum java_fundamental_type_kind
{
jtk_first, /* Must be first. */
jtk_byte = jtk_first,
jtk_short,
jtk_int,
jtk_long,
jtk_float,
jtk_double,
jtk_char,
jtk_boolean,
jtk_last /* Must be last */
} java_fundamental_type_kind;
/* The fundamental Java types. */
extern tree java_fundamental_types[jtk_last];
/* Global state. */
struct stmt_tree {

54
gcc/cp/decl.c
View File

@ -186,7 +186,6 @@ static tree start_cleanup_fn PARAMS ((void));
static void end_cleanup_fn PARAMS ((void));
static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
static void initialize_predefined_identifiers PARAMS ((void));
static void initialize_java_fundamental_types PARAMS ((void));
static tree check_special_function_return_type
PARAMS ((special_function_kind, tree, tree, tree));
static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
@ -262,10 +261,6 @@ tree error_mark_list;
tree cp_global_trees[CPTI_MAX];
/* The fundamental Java types. */
tree java_fundamental_types[jtk_last];
/* Indicates that there is a type value in some namespace, although
that is not necessarily in scope at the moment. */
@ -6147,9 +6142,9 @@ record_builtin_type (rid_index, name, type)
}
/* 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. */
* 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 (name, size)
@ -6253,38 +6248,6 @@ initialize_predefined_identifiers ()
}
}
/* Create nodes representing the fundamental Java types. */
static void
initialize_java_fundamental_types ()
{
typedef struct jft_info
{
/* The name of the type. */
const char *name;
/* The number of bits in the type. */
int size;
} jft_info;
static jft_info jft_infos[jtk_last] = {
{ "__java_byte", 8 },
{ "__java_short", 16 },
{ "__java_int", 32 },
{ "__java_long", 64 },
{ "__java_float", -32 },
{ "__java_double", -64 },
{ "__java_char", -16 },
{ "__java_boolean", -1 }
};
java_fundamental_type_kind jtk;
for (jtk = jtk_first; jtk < jtk_last; ++jtk)
java_fundamental_types[jtk]
= record_builtin_java_type (jft_infos[jtk].name,
jft_infos[jtk].size);
}
/* Create the predefined scalar types of C,
and some nodes representing standard constants (0, 1, (void *)0).
Initialize the global binding level.
@ -6434,7 +6397,14 @@ init_decl_processing ()
build_common_tree_nodes_2 (flag_short_double);
initialize_java_fundamental_types ();
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);
integer_two_node = build_int_2 (2, 0);
TREE_TYPE (integer_two_node) = integer_type_node;
@ -6686,8 +6656,6 @@ init_decl_processing ()
/* Add GC roots for all of our global variables. */
ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
ggc_add_tree_root (java_fundamental_types,
sizeof (java_fundamental_types) / sizeof (tree));
ggc_add_tree_root (&integer_three_node, 1);
ggc_add_tree_root (&integer_two_node, 1);
ggc_add_tree_root (&signed_size_zero_node, 1);

62
gcc/cp/mangle.c
View File

@ -120,7 +120,7 @@ static tree subst_identifiers[SUBID_MAX];
/* Single-letter codes for builtin integer types, defined in
<builtin-type>. These are indexed by integer_type_kind values. */
static const char
static char
integer_type_codes[itk_none] =
{
'c', /* itk_char */
@ -136,21 +136,6 @@ integer_type_codes[itk_none] =
'y' /* itk_unsigned_long_long */
};
/* Manglings for the various builtin Java types. */
static const char *
java_fundamental_type_codes[jtk_last] =
{
"jb", /* jtk_byte */
"js", /* jtk_short */
"ji", /* jtk_int */
"jl", /* jtk_long */
"jf", /* jtk_float */
"jd", /* jtk_double */
"jc", /* jtk_char */
"jt" /* jtk_boolean */
};
/* Functions for handling substitutions. */
static inline tree canonicalize_for_substitution PARAMS ((tree));
@ -171,11 +156,10 @@ static void write_prefix PARAMS ((tree));
static void write_template_prefix PARAMS ((tree));
static void write_component PARAMS ((tree));
static void write_unqualified_name PARAMS ((tree));
static void write_source_name_from_string PARAMS ((const char *));
static void write_source_name PARAMS ((tree));
static void write_number PARAMS ((int, int));
static void write_integer_cst PARAMS ((tree));
static void write_identifier PARAMS ((const char *));
static void write_identifier PARAMS ((char *));
static void write_special_name_constructor PARAMS ((tree));
static void write_special_name_destructor PARAMS ((tree));
static void write_type PARAMS ((tree));
@ -914,18 +898,6 @@ write_unqualified_name (decl)
write_source_name (DECL_NAME (decl));
}
/* Non-termial <source-name>. NAME is a NTBS.
<source-name> ::= </length/ number> <identifier> */
static void
write_source_name_from_string (name)
const char *name;
{
write_number (strlen (name), 10);
write_identifier (name);
}
/* Non-termial <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
<source-name> ::= </length/ number> <identifier> */
@ -997,7 +969,7 @@ write_integer_cst (cst)
static void
write_identifier (identifier)
const char *identifier;
char *identifier;
{
MANGLE_TRACE ("identifier", identifier);
write_string (identifier);
@ -1335,24 +1307,6 @@ static void
write_builtin_type (type)
tree type;
{
/* If this is a Java type, mangle it specially, as a vendor
extension. */
if (TYPE_FOR_JAVA (type))
{
java_fundamental_type_kind jtk;
for (jtk = jtk_first; jtk < jtk_last; ++jtk)
if (same_type_p (type, java_fundamental_types[jtk]))
{
/* The `u' indicates a vendor extension. */
write_char ('u');
write_source_name_from_string (java_fundamental_type_codes[jtk]);
return;
}
my_friendly_abort (20000609);
}
switch (TREE_CODE (type))
{
case VOID_TYPE:
@ -1370,7 +1324,7 @@ write_builtin_type (type)
/* TYPE may still be wchar_t, since that isn't in
integer_type_nodes. */
if (same_type_p (type, wchar_type_node))
if (type == wchar_type_node)
write_char ('w');
else
{
@ -1378,7 +1332,7 @@ write_builtin_type (type)
/* Assume TYPE is one of the shared integer type nodes. Find
it in the array of these nodes. */
for (itk = 0; itk < itk_none; ++itk)
if (same_type_p (type, integer_types[itk]))
if (type == integer_types[itk])
{
/* Print the corresponding single-letter code. */
write_char (integer_type_codes[itk]);
@ -1392,11 +1346,11 @@ write_builtin_type (type)
break;
case REAL_TYPE:
if (same_type_p (type, float_type_node))
if (type == float_type_node)
write_char ('f');
else if (same_type_p (type, double_type_node))
else if (type == double_type_node)
write_char ('d');
else if (same_type_p (type, long_double_type_node))
else if (type == long_double_type_node)
write_char ('e');
else
my_friendly_abort (20000409);