/* Parser for Java(TM) .class files.
- Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
text = (JCF)->read_ptr; \
save = text[LENGTH]; \
text[LENGTH] = 0; \
- (JCF)->cpool.data[INDEX].t = get_identifier (text); \
+ (JCF)->cpool.data[INDEX].t = get_identifier ((const char *) text); \
text[LENGTH] = save; \
JCF_SKIP (JCF, LENGTH); } while (0)
extern struct obstack temporary_obstack;
-/* Set to nonzero value in order to emit class initialization code
- before static field references. */
-extern int always_initialize_class_p;
-
static GTY(()) tree parse_roots[3];
/* The FIELD_DECL for the current field. */
#define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
{ tree super_class = SUPER==0 ? NULL_TREE : get_class_constant (jcf, SUPER); \
- current_class = give_name_to_class (jcf, THIS); \
+ output_class = current_class = give_name_to_class (jcf, THIS); \
set_super_info (ACCESS_FLAGS, current_class, super_class, INTERFACES_COUNT);}
#define HANDLE_CLASS_INTERFACE(INDEX) \
case CONSTANT_Long:
{
unsigned HOST_WIDE_INT num = JPOOL_UINT (jcf, index);
- HOST_WIDE_INT lo, hi;
+ unsigned HOST_WIDE_INT lo;
+ HOST_WIDE_INT hi;
lshift_double (num, 0, 32, 64, &lo, &hi, 0);
num = JPOOL_UINT (jcf, index+1);
add_double (lo, hi, num, 0, &lo, &hi);
tree this_class;
int j = JPOOL_USHORT1 (jcf, i);
/* verify_constant_pool confirmed that j is a CONSTANT_Utf8. */
- tree class_name = unmangle_classname (JPOOL_UTF_DATA (jcf, j),
+ tree class_name = unmangle_classname ((const char *) JPOOL_UTF_DATA (jcf, j),
JPOOL_UTF_LENGTH (jcf, j));
this_class = lookup_class (class_name);
input_filename = DECL_SOURCE_FILE (TYPE_NAME (this_class));
{
int name_index = JPOOL_USHORT1 (jcf, i);
/* verify_constant_pool confirmed that name_index is a CONSTANT_Utf8. */
- const char *name = JPOOL_UTF_DATA (jcf, name_index);
+ const char *name = (const char *) JPOOL_UTF_DATA (jcf, name_index);
int nlength = JPOOL_UTF_LENGTH (jcf, name_index);
if (name[0] == '[') /* Handle array "classes". */
- type = TREE_TYPE (parse_signature_string (name, nlength));
+ type = TREE_TYPE (parse_signature_string ((const unsigned char *) name, nlength));
else
{
tree cname = unmangle_classname (name, nlength);
JCF this_jcf, *jcf;
tree icv, class = NULL_TREE;
tree save_current_class = current_class;
+ tree save_output_class = output_class;
location_t save_location = input_location;
JCF *save_current_jcf = current_jcf;
if (current_jcf->java_source)
{
const char *filename = current_jcf->filename;
- tree file;
+ tree given_file, real_file;
FILE *finput;
int generate;
java_parser_context_save_global ();
java_push_parser_context ();
- BUILD_FILENAME_IDENTIFIER_NODE (file, filename);
- generate = IS_A_COMMAND_LINE_FILENAME_P (file);
+
+ given_file = get_identifier (filename);
+ real_file = get_identifier (lrealpath (filename));
+
+ generate = IS_A_COMMAND_LINE_FILENAME_P (given_file);
if (wfl_operator == NULL_TREE)
wfl_operator = build_expr_wfl (NULL_TREE, NULL, 0, 0);
- EXPR_WFL_FILENAME_NODE (wfl_operator) = file;
+ EXPR_WFL_FILENAME_NODE (wfl_operator) = given_file;
input_filename = ggc_strdup (filename);
- current_class = NULL_TREE;
+ output_class = current_class = NULL_TREE;
current_function_decl = NULL_TREE;
- if (!HAS_BEEN_ALREADY_PARSED_P (file))
+
+ if (! HAS_BEEN_ALREADY_PARSED_P (real_file))
{
- if (!(finput = fopen (input_filename, "r")))
+ if (! (finput = fopen (input_filename, "r")))
fatal_error ("can't reopen %s: %m", input_filename);
- parse_source_file_1 (file, finput);
+
+ parse_source_file_1 (real_file, finput);
parse_source_file_2 ();
parse_source_file_3 ();
+
if (fclose (finput))
fatal_error ("can't close %s: %m", input_filename);
}
{
java_parser_context_save_global ();
java_push_parser_context ();
- current_class = class;
+ output_class = current_class = class;
input_filename = current_jcf->filename;
if (JCF_SEEN_IN_ZIP (current_jcf))
read_zip_member(current_jcf,
load_inner_classes (class);
}
+ output_class = save_output_class;
current_class = save_current_class;
input_location = save_location;
current_jcf = save_current_jcf;
/* Load CLASS_OR_NAME. CLASS_OR_NAME can be a mere identifier if
called from the parser, otherwise it's a RECORD_TYPE node. If
VERBOSE is 1, print error message on failure to load a class. */
-
-/* Replace calls to load_class by having callers call read_class directly
- - and then perhaps rename read_class to load_class. FIXME */
-
void
load_class (tree class_or_name, int verbose)
{
name = TYPE_NAME (TREE_PURPOSE (class_or_name));
/* Or it's a type in the making */
else
- name = DECL_NAME (TYPE_NAME (class_or_name));
+ {
+ /* If the class is from source code, then it must already be loaded. */
+ if (CLASS_FROM_SOURCE_P (class_or_name))
+ return;
+ name = DECL_NAME (TYPE_NAME (class_or_name));
+ }
saved = name;
while (1)
compiling from class files. */
always_initialize_class_p = 1;
+ gen_indirect_dispatch_tables (current_class);
+
java_mark_class_local (current_class);
for (method = TYPE_METHODS (current_class);
DECL_MAX_LOCALS (method) = decl_max_locals;
start_java_method (method);
give_name_to_locals (jcf);
- expand_expr_stmt (build_jni_stub (method));
+ *get_stmts () = build_jni_stub (method);
end_java_method ();
continue;
}
input_line = 0;
if (DECL_LINENUMBERS_OFFSET (method))
{
- register int i;
- register unsigned char *ptr;
+ int i;
+ unsigned char *ptr;
JCF_SEEK (jcf, DECL_LINENUMBERS_OFFSET (method));
linenumber_count = i = JCF_readu2 (jcf);
linenumber_table = ptr = jcf->read_ptr;
for (ptr += 2; --i >= 0; ptr += 4)
{
int line = GET_u2 (ptr);
- /* Set initial lineno lineno to smallest linenumber.
+ /* Set initial input_line to smallest linenumber.
* Needs to be set before init_function_start. */
if (input_line == 0 || line < input_line)
input_line = line;
give_name_to_locals (jcf);
- /* Actually generate code. */
+ /* Convert bytecode to trees. */
expand_byte_code (jcf, method);
end_java_method ();
/* Parse a source file, as pointed by the current value of INPUT_FILENAME. */
static void
-parse_source_file_1 (tree file, FILE *finput)
+parse_source_file_1 (tree real_file, FILE *finput)
{
int save_error_count = java_error_count;
- /* Mark the file as parsed */
- HAS_BEEN_ALREADY_PARSED_P (file) = 1;
+
+ /* Mark the file as parsed. */
+ HAS_BEEN_ALREADY_PARSED_P (real_file) = 1;
jcf_dependency_add_file (input_filename, 0);
return 0;
}
+/* Generate a function that does all static initialization for this
+ translation unit. */
+
+static void
+java_emit_static_constructor (void)
+{
+ tree body = NULL;
+
+ emit_register_classes (&body);
+ write_resource_constructor (&body);
+
+ if (body)
+ cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
+}
+
void
java_parse_file (int set_yydebug ATTRIBUTE_UNUSED)
{
finput = NULL;
}
else
- list = xstrdup (input_filename);
+ list = input_filename ? xstrdup (input_filename) : 0;
- do
+ while (list)
{
for (next = list; ; )
{
}
else
{
- BUILD_FILENAME_IDENTIFIER_NODE (node, value);
+ node = get_identifier (value);
IS_A_COMMAND_LINE_FILENAME_P (node) = 1;
current_file_list = tree_cons (NULL_TREE, node,
current_file_list);
}
list = next;
}
- while (next);
if (filename_count == 0)
warning ("no input file specified");
resource_filename = IDENTIFIER_POINTER (TREE_VALUE (current_file_list));
compile_resource_file (resource_name, resource_filename);
- return;
+ goto finish;
}
current_jcf = main_jcf;
unsigned char magic_string[4];
uint32 magic = 0;
tree name = TREE_VALUE (node);
+ tree real_file;
/* Skip already parsed files */
- if (HAS_BEEN_ALREADY_PARSED_P (name))
+ real_file = get_identifier (lrealpath (IDENTIFIER_POINTER (name)));
+ if (HAS_BEEN_ALREADY_PARSED_P (real_file))
continue;
/* Close previous descriptor, if any */
JAVA_FILE_P (node) = 1;
java_push_parser_context ();
java_parser_context_save_global ();
- parse_source_file_1 (name, finput);
+
+ parse_source_file_1 (real_file, finput);
java_parser_context_restore_global ();
java_pop_parser_context (1);
}
input_filename = IDENTIFIER_POINTER (TREE_VALUE (node));
if (CLASS_FILE_P (node))
{
- current_class = TREE_PURPOSE (node);
+ output_class = current_class = TREE_PURPOSE (node);
current_jcf = TYPE_JCF (current_class);
layout_class (current_class);
load_inner_classes (current_class);
input_filename = main_input_filename;
java_expand_classes ();
- if (!java_report_errors () && !flag_syntax_only)
- {
- /* Optimize and expand all classes compiled from source. */
- cgraph_finalize_compilation_unit ();
- cgraph_optimize ();
- java_finish_classes ();
-
- /* Emit the .jcf section. */
- emit_register_classes ();
- if (flag_indirect_dispatch)
- {
- otable_decl
- = emit_symbol_table
- (get_identifier ("otable"),
- otable_decl, otable_methods, otable_syms_decl, integer_type_node);
- atable_decl
- = emit_symbol_table
- (get_identifier ("atable"),
- atable_decl, atable_methods, atable_syms_decl, ptr_type_node);
- }
- emit_catch_table ();
- }
-
- write_resource_constructor ();
+ if (java_report_errors () || flag_syntax_only)
+ return;
+
+ /* Expand all classes compiled from source. */
+ java_finish_classes ();
+
+ finish:
+ /* Arrange for any necessary initialization to happen. */
+ java_emit_static_constructor ();
+
+ /* Only finalize the compilation unit after we've told cgraph which
+ functions have their addresses stored. */
+ cgraph_finalize_compilation_unit ();
+ cgraph_optimize ();
}
+
/* Return the name of the class corresponding to the name of the file
in this zip entry. The result is newly allocated using ALLOC. */
static char *
class = lookup_class (get_identifier (class_name));
FREE (class_name);
current_jcf = TYPE_JCF (class);
- current_class = class;
+ output_class = current_class = class;
if (! CLASS_LOADED_P (class))
{
OSDN Git Service
