/* Functions related to mangling class names for the GNU compiler
for the Java(TM) language.
- Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2001, 2002, 2003
+ Free Software Foundation, Inc.
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
+GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
-GNU CC is distributed in the hope that it will be useful,
+GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
+along with GCC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "jcf.h"
#include "tree.h"
#include "java-tree.h"
#include "obstack.h"
#include "ggc.h"
-static void mangle_field_decl PARAMS ((tree));
-static void mangle_method_decl PARAMS ((tree));
+static void mangle_field_decl (tree);
+static void mangle_method_decl (tree);
-static void mangle_type PARAMS ((tree));
-static void mangle_pointer_type PARAMS ((tree));
-static void mangle_array_type PARAMS ((tree));
-static int mangle_record_type PARAMS ((tree, int));
+static void mangle_type (tree);
+static void mangle_pointer_type (tree);
+static void mangle_array_type (tree);
+static int mangle_record_type (tree, int);
-static int find_compression_pointer_match PARAMS ((tree));
-static int find_compression_array_match PARAMS ((tree));
-static int find_compression_record_match PARAMS ((tree, tree *));
-static int find_compression_array_template_match PARAMS ((tree));
+static int find_compression_pointer_match (tree);
+static int find_compression_array_match (tree);
+static int find_compression_record_match (tree, tree *);
+static int find_compression_array_template_match (tree);
-static void set_type_package_list PARAMS ((tree));
-static int entry_match_pointer_p PARAMS ((tree, int));
-static void emit_compression_string PARAMS ((int));
+static void set_type_package_list (tree);
+static int entry_match_pointer_p (tree, int);
+static void emit_compression_string (int);
-static void init_mangling PARAMS ((struct obstack *));
-static tree finish_mangling PARAMS ((void));
-static void compression_table_add PARAMS ((tree));
+static void init_mangling (struct obstack *);
+static tree finish_mangling (void);
+static void compression_table_add (tree);
-static void mangle_member_name PARAMS ((tree));
+static void mangle_member_name (tree);
/* We use an incoming obstack, always to be provided to the interface
functions. */
#define MANGLE_RAW_STRING(S) \
obstack_grow (mangle_obstack, (S), sizeof (S)-1)
+/* atms: array template mangled string. */
+static GTY(()) tree atms;
+
/* This is the mangling interface: a decl, a class field (.class) and
the vtable. */
tree
-java_mangle_decl (obstack, decl)
- struct obstack *obstack;
- tree decl;
+java_mangle_decl (struct obstack *obstack, tree decl)
{
init_mangling (obstack);
switch (TREE_CODE (decl))
mangle_method_decl (decl);
break;
default:
- internal_error ("Can't mangle %s", tree_code_name [TREE_CODE (decl)]);
+ internal_error ("can't mangle %s", tree_code_name [TREE_CODE (decl)]);
}
return finish_mangling ();
}
tree
-java_mangle_class_field (obstack, type)
- struct obstack *obstack;
- tree type;
+java_mangle_class_field (struct obstack *obstack, tree type)
{
init_mangling (obstack);
mangle_record_type (type, /* for_pointer = */ 0);
}
tree
-java_mangle_vtable (obstack, type)
- struct obstack *obstack;
- tree type;
+java_mangle_vtable (struct obstack *obstack, tree type)
{
init_mangling (obstack);
MANGLE_RAW_STRING ("TV");
/* This mangles a field decl */
static void
-mangle_field_decl (decl)
- tree decl;
+mangle_field_decl (tree decl)
{
/* Mangle the name of the this the field belongs to */
mangle_record_type (DECL_CONTEXT (decl), /* for_pointer = */ 0);
its arguments. */
static void
-mangle_method_decl (mdecl)
- tree mdecl;
+mangle_method_decl (tree mdecl)
{
tree method_name = DECL_NAME (mdecl);
tree arglist;
/* Mangle the name of the type that contains mdecl */
mangle_record_type (DECL_CONTEXT (mdecl), /* for_pointer = */ 0);
- /* Mangle the function name. There three cases
- - mdecl is java.lang.Object.Object(), use `C2' for its name
- (denotes a base object constructor.)
+ /* Mangle the function name. There are two cases:
- mdecl is a constructor, use `C1' for its name, (denotes a
complete object constructor.)
- mdecl is not a constructor, standard mangling is performed.
We terminate the mangled function name with a `E'. */
if (ID_INIT_P (method_name))
- {
- if (DECL_CONTEXT (mdecl) == object_type_node)
- obstack_grow (mangle_obstack, "C2", 2);
- else
- obstack_grow (mangle_obstack, "C1", 2);
- }
+ obstack_grow (mangle_obstack, "C1", 2);
else
mangle_member_name (method_name);
obstack_1grow (mangle_obstack, 'E');
}
/* This mangles a member name, like a function name or a field
- name. Handle cases were `name' is a C++ keyword. Return a non zero
+ name. Handle cases were `name' is a C++ keyword. Return a nonzero
value if unicode encoding was required. */
static void
-mangle_member_name (name)
- tree name;
+mangle_member_name (tree name)
{
append_gpp_mangled_name (IDENTIFIER_POINTER (name),
IDENTIFIER_LENGTH (name));
- /* If NAME happens to be a C++ keyword, add `$' or `.' or `_'. */
+ /* If NAME happens to be a C++ keyword, add `$'. */
if (cxx_keyword_p (IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name)))
- {
-#ifndef NO_DOLLAR_IN_LABEL
- obstack_1grow (mangle_obstack, '$');
-#else /* NO_DOLLAR_IN_LABEL */
-#ifndef NO_DOT_IN_LABEL
- obstack_1grow (mangle_obstack, '.');
-#else /* NO_DOT_IN_LABEL */
- obstack_1grow (mangle_obstack, '_');
-#endif /* NO_DOT_IN_LABEL */
-#endif /* NO_DOLLAR_IN_LABEL */
- }
+ obstack_1grow (mangle_obstack, '$');
}
/* Append the mangled name of TYPE onto OBSTACK. */
static void
-mangle_type (type)
- tree type;
+mangle_type (tree type)
{
switch (TREE_CODE (type))
{
/* The compression table is a vector that keeps track of things we've
already seen, so they can be reused. For example, java.lang.Object
- Would generate three entries: two package names and a type. If
+ would generate three entries: two package names and a type. If
java.lang.String is presented next, the java.lang will be matched
- against the first two entries (and kept for compression as S_0), and
+ against the first two entries (and kept for compression as S0_), and
type String would be added to the table. See mangle_record_type.
COMPRESSION_NEXT is the index to the location of the next insertion
of an element. */
-static tree compression_table;
+static GTY(()) tree compression_table;
static int compression_next;
/* Find a POINTER_TYPE in the compression table. Use a special
function to match pointer entries and start from the end */
static int
-find_compression_pointer_match (type)
- tree type;
+find_compression_pointer_match (tree type)
{
int i;
associated with it. */
static int
-find_compression_array_match (type)
- tree type;
+find_compression_array_match (tree type)
{
return find_compression_pointer_match (type);
}
/* Match the table of type against STRING. */
static int
-find_compression_array_template_match (string)
- tree string;
+find_compression_array_template_match (tree string)
{
int i;
for (i = 0; i < compression_next; i++)
/* We go through the compression table and try to find a complete or
partial match. The function returns the compression table entry
- that (evenutally partially) matches TYPE. *NEXT_CURRENT can be set
+ that (eventually partially) matches TYPE. *NEXT_CURRENT can be set
to the rest of TYPE to be mangled. */
static int
-find_compression_record_match (type, next_current)
- tree type;
- tree *next_current;
+find_compression_record_match (tree type, tree *next_current)
{
- int i, match;
+ int i, match = -1;
tree current, saved_current = NULL_TREE;
- /* Search from the beginning for something that matches TYPE, even
- partially. */
- for (current = TYPE_PACKAGE_LIST (type), i = 0, match = -1; current;
- current = TREE_CHAIN (current))
+ current = TYPE_PACKAGE_LIST (type);
+
+ for (i = 0; i < compression_next; i++)
{
- int j;
- for (j = i; j < compression_next; j++)
- if (TREE_VEC_ELT (compression_table, j) == TREE_PURPOSE (current))
- {
- match = i = j;
- saved_current = current;
- break;
- }
+ tree compression_entry = TREE_VEC_ELT (compression_table, i);
+ if (current && compression_entry == TREE_PURPOSE (current))
+ {
+ match = i;
+ saved_current = current;
+ current = TREE_CHAIN (current);
+ }
+ else
+ /* We don't want to match an element that appears in the middle
+ of a package name, so skip forward to the next complete type name.
+ IDENTIFIER_NODEs (except for a "6JArray") are partial package
+ names while RECORD_TYPEs represent complete type names. */
+ while (i < compression_next
+ && TREE_CODE (compression_entry) == IDENTIFIER_NODE
+ && compression_entry != atms)
+ compression_entry = TREE_VEC_ELT (compression_table, ++i);
}
if (!next_current)
return match;
}
-/* Mangle a record type. If a non zero value is returned, it means
+/* Mangle a record type. If a nonzero value is returned, it means
that a 'N' was emitted (so that a matching 'E' can be emitted if
necessary.) FOR_POINTER indicates that this element is for a pointer
symbol, meaning it was preceded by a 'P'. */
static int
-mangle_record_type (type, for_pointer)
- tree type;
- int for_pointer;
+mangle_record_type (tree type, int for_pointer)
{
tree current;
int match;
}
/* Mangle a pointer type. There are two cases: the pointer is already
- in the compression table: the compression is emited sans 'P'
+ in the compression table: the compression is emitted sans 'P'
indicator. Otherwise, a 'P' is emitted and, depending on the type,
a partial compression or/plus the rest of the mangling. */
static void
-mangle_pointer_type (type)
- tree type;
+mangle_pointer_type (tree type)
{
int match;
tree pointer_type;
/* Mangle an array type. Search for an easy solution first, then go
through the process of finding out whether the bare array type or even
- the template indicator where already used an compress appropriately.
+ the template indicator were already used and compressed appropriately.
It handles pointers. */
static void
-mangle_array_type (p_type)
- tree p_type;
+mangle_array_type (tree p_type)
{
- /* atms: array template mangled string. */
- static tree atms = NULL_TREE;
tree type, elt_type;
int match;
if (!atms)
{
atms = get_identifier ("6JArray");
- ggc_add_tree_root (&atms, 1);
}
- /* Maybe we have what we're looking in the compression table. */
+ /* Maybe we have what we're looking for in the compression table. */
if ((match = find_compression_array_match (p_type)) >= 0)
{
emit_compression_string (match);
compression_table_add (p_type);
}
-/* Write a substition string for entry I. Substitution string starts a
- -1 (encoded S_.) The base is 36, and the code shamlessly taken from
+/* Write a substitution string for entry I. Substitution string starts a
+ -1 (encoded S_.) The base is 36, and the code shamelessly taken from
cp/mangle.c. */
static void
might all be unique, we find the same RECORD_TYPE.) */
static int
-entry_match_pointer_p (type, i)
- tree type;
- int i;
+entry_match_pointer_p (tree type, int i)
{
tree t = TREE_VEC_ELT (compression_table, i);
part. The result is stored in TYPE_PACKAGE_LIST to be reused. */
static void
-set_type_package_list (type)
- tree type;
+set_type_package_list (tree type)
{
int i;
const char *type_string = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
compression table if necessary. */
static void
-compression_table_add (type)
- tree type;
+compression_table_add (tree type)
{
if (compression_next == TREE_VEC_LENGTH (compression_table))
{
for (i = 0; i < compression_next; i++)
TREE_VEC_ELT (new, i) = TREE_VEC_ELT (compression_table, i);
- ggc_del_root (&compression_table);
compression_table = new;
- ggc_add_tree_root (&compression_table, 1);
}
TREE_VEC_ELT (compression_table, compression_next++) = type;
}
/* Mangling initialization routine. */
static void
-init_mangling (obstack)
- struct obstack *obstack;
+init_mangling (struct obstack *obstack)
{
mangle_obstack = obstack;
if (!compression_table)
/* Mangled name are to be suffixed */
obstack_grow (mangle_obstack, "_Z", 2);
-
- /* Register the compression table with the GC */
- ggc_add_tree_root (&compression_table, 1);
}
/* Mangling finalization routine. The mangled name is returned as a
IDENTIFIER_NODE. */
static tree
-finish_mangling ()
+finish_mangling (void)
{
tree result;
/* Mangling already finished. */
abort ();
- ggc_del_root (&compression_table);
compression_table = NULL_TREE;
compression_next = 0;
obstack_1grow (mangle_obstack, '\0');
#endif
return result;
}
+
+#include "gt-java-mangle.h"
OSDN Git Service
