/* Process declarations and variables for the GNU compiler for the
Java(TM) language.
- Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
+ Free Software Foundation, Inc.
This file is part of GNU CC.
#include "toplev.h"
#include "function.h"
#include "except.h"
-#include "defaults.h"
#include "java-except.h"
#include "ggc.h"
static boolean emit_init_test_initialization PARAMS ((struct hash_entry *,
hash_table_key));
static tree create_primitive_vtable PARAMS ((const char *));
+static tree check_local_named_variable PARAMS ((tree, tree, int, int *));
+static tree check_local_unnamed_variable PARAMS ((tree, tree, tree));
/* Set to non-zero value in order to emit class initilization code
before static field references. */
extern int always_initialize_class_p;
-/* Use garbage collection. */
-
-int ggc_p = 1;
-
/* The DECL_MAP is a mapping from (index, type) to a decl node.
If index < max_locals, it is the index of a local variable.
if index >= max_locals, then index-max_locals is a stack slot.
/* Now link the decl into the decl_map. */
if (DECL_LANG_SPECIFIC (decl) == NULL)
{
- DECL_LANG_SPECIFIC (decl)
- = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl_var));
+ MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
DECL_LOCAL_START_PC (decl) = 0;
DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
DECL_LOCAL_SLOT_NUMBER (decl) = index;
return decl;
}
+/* Find out if 'decl' passed in fits the defined PC location better than
+ 'best'. Return decl if it does, return best if it doesn't. If decl
+ is returned, then updated is set to true. */
+
+static tree
+check_local_named_variable (best, decl, pc, updated)
+ tree best;
+ tree decl;
+ int pc;
+ int *updated;
+{
+ if (pc >= DECL_LOCAL_START_PC (decl)
+ && pc < DECL_LOCAL_END_PC (decl))
+ {
+ if (best == NULL_TREE
+ || (DECL_LOCAL_START_PC (decl) > DECL_LOCAL_START_PC (best)
+ && DECL_LOCAL_END_PC (decl) < DECL_LOCAL_END_PC (best)))
+ {
+ *updated = 1;
+ return decl;
+ }
+ }
+
+ return best;
+}
+
+/* Find the best declaration based upon type. If 'decl' fits 'type' better
+ than 'best', return 'decl'. Otherwise return 'best'. */
+
+static tree
+check_local_unnamed_variable (best, decl, type)
+ tree best;
+ tree decl;
+ tree type;
+{
+ if (TREE_TYPE (decl) == type
+ || (TREE_CODE (TREE_TYPE (decl)) == TREE_CODE (type)
+ && TYPE_PRECISION (TREE_TYPE (decl)) <= 32
+ && TYPE_PRECISION (type) <= 32
+ && TREE_CODE (type) != POINTER_TYPE)
+ || (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
+ && type == ptr_type_node))
+ {
+ if (best == NULL_TREE
+ || (TREE_TYPE (decl) == type && TREE_TYPE (best) != type))
+ return decl;
+ }
+
+ return best;
+}
+
+
/* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
that is valid at PC (or -1 if any pc).
If there is no existing matching decl, allocate one. */
{
tree decl = TREE_VEC_ELT (decl_map, index);
tree best = NULL_TREE;
+ int found_scoped_var = 0;
+ /* Scan through every declaration that has been created in this slot. */
while (decl != NULL_TREE)
{
- int in_range;
- in_range = pc < 0
- || (pc >= DECL_LOCAL_START_PC (decl)
- && pc < DECL_LOCAL_END_PC (decl));
-
- if ((TREE_TYPE (decl) == type
- || (TREE_CODE (TREE_TYPE (decl)) == TREE_CODE (type)
- && TYPE_PRECISION (TREE_TYPE (decl)) <= 32
- && TYPE_PRECISION (type) <= 32
- && TREE_CODE (type) != POINTER_TYPE)
- || (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
- && type == ptr_type_node))
- && in_range)
+ /* Variables created in give_name_to_locals() have a name and have
+ a specified scope, so we can handle them specifically. We want
+ to use the specific decls created for those so they are assigned
+ the right variables in the debugging information. */
+ if (DECL_NAME (decl) != NULL_TREE)
{
- if (best == NULL_TREE
- || (DECL_LOCAL_START_PC (decl) > DECL_LOCAL_START_PC (best)
- && DECL_LOCAL_END_PC (decl) < DECL_LOCAL_START_PC (best)))
- best = decl;
- }
+ /* This is a variable we have a name for, so it has a scope
+ supplied in the class file. But it only matters when we
+ actually have a PC to use. If pc<0, then we are asking
+ for a stack slot and this decl won't be one of those. */
+ if (pc >= 0)
+ best = check_local_named_variable (best, decl, pc,
+ &found_scoped_var);
+ }
+ /* We scan for type information unless we found a variable in the
+ proper scope already. */
+ else if (!found_scoped_var)
+ {
+ /* If we don't have scoping information for a variable, we use
+ a different method to look it up. */
+ best = check_local_unnamed_variable (best, decl, type);
+ }
+
decl = DECL_LOCAL_SLOT_CHAIN (decl);
}
+
if (best != NULL_TREE)
return best;
+
+ /* If we don't find a match, create one with the type passed in. */
return push_jvm_slot (index, build_decl (VAR_DECL, NULL_TREE, type));
}
TREE_PUBLIC (decl) = 1;
if (library_name)
DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
- make_decl_rtl (decl, NULL_PTR, 1);
+ make_decl_rtl (decl, NULL_PTR);
pushdecl (decl);
DECL_BUILT_IN_CLASS (decl) = class;
DECL_FUNCTION_CODE (decl) = function_code;
sprintf (buf, "_Jv_%sVTable", name);
r = build_decl (VAR_DECL, get_identifier (buf), ptr_type_node);
DECL_EXTERNAL (r) = 1;
- make_decl_rtl (r, buf, 1);
+ make_decl_rtl (r, buf);
return r;
}
tree field = NULL_TREE;
tree t;
+ init_class_processing ();
+
current_function_decl = NULL;
current_binding_level = NULL_BINDING_LEVEL;
free_binding_level = NULL_BINDING_LEVEL;
integer_one_node = build_int_2 (1, 0);
integer_two_node = build_int_2 (2, 0);
integer_four_node = build_int_2 (4, 0);
- integer_negative_one_node = build_int_2 (-1, 0);
+ integer_minus_one_node = build_int_2 (-1, -1);
size_zero_node = size_int (0);
size_one_node = size_int (1);
super_identifier_node = get_identifier ("super");
continue_identifier_node = get_identifier ("continue");
access0_identifier_node = get_identifier ("access$0");
+ classdollar_identifier_node = get_identifier ("class$");
/* for lack of a better place to put this stub call */
init_expr_processing();
PUSH_FIELD (class_type_node, field, "depth", short_type_node);
PUSH_FIELD (class_type_node, field, "ancestors", ptr_type_node);
PUSH_FIELD (class_type_node, field, "idt", ptr_type_node);
+ PUSH_FIELD (class_type_node, field, "arrayclass", ptr_type_node);
for (t = TYPE_FIELDS (class_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
FIELD_PRIVATE (t) = 1;
push_super_field (class_type_node, object_type_node);
t = tree_cons (NULL_TREE, int_type_node,
tree_cons (NULL_TREE, int_type_node, endlink));
soft_newarray_node
- = builtin_function ("_Jv_NewArray",
+ = builtin_function ("_Jv_NewPrimArray",
build_function_type(ptr_type_node, t),
0, NOT_BUILT_IN, NULL_PTR);
DECL_IS_MALLOC (soft_newarray_node) = 1;
build_function_type (long_type_node, t),
0, NOT_BUILT_IN, NULL_PTR);
- init_class_processing ();
init_jcf_parse ();
/* Register nodes with the garbage collector. */
register tree block;
{
current_binding_level->this_block = block;
+ current_binding_level->names = chainon (current_binding_level->names,
+ BLOCK_VARS (block));
+ current_binding_level->blocks = chainon (current_binding_level->blocks,
+ BLOCK_SUBBLOCKS (block));
}
/* integrate_decl_tree calls this function. */
int lang_decl_size
= TREE_CODE (node) == VAR_DECL ? sizeof (struct lang_decl_var)
: sizeof (struct lang_decl);
- struct lang_decl *x = (struct lang_decl *) oballoc (lang_decl_size);
- bcopy ((PTR) DECL_LANG_SPECIFIC (node), (PTR) x, lang_decl_size);
+ struct lang_decl *x = (struct lang_decl *) ggc_alloc (lang_decl_size);
+ memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
DECL_LANG_SPECIFIC (node) = x;
}
comments for expr.c:maybe_adjust_start_pc. */
start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot);
- DECL_LANG_SPECIFIC (decl)
- = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl_var));
+ MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
DECL_LOCAL_SLOT_NUMBER (decl) = slot;
DECL_LOCAL_START_PC (decl) = start_pc;
#if 0
emit_init_test_initialization, 0);
}
- /* Allocate further tree nodes temporarily during compilation
- of this function only. */
- temporary_allocation ();
-
#if 0
/* If this fcn was already referenced via a block-scope `extern' decl (or
an implicit decl), propagate certain information about the usage. */
i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
decl_map = make_tree_vec (i);
- type_map = (tree *) oballoc (i * sizeof (tree));
+ type_map = (tree *) xrealloc (type_map, i * sizeof (tree));
#if defined(DEBUG_JAVA_BINDING_LEVELS)
fprintf (stderr, "%s:\n", (*decl_printable_name) (fndecl, 2));
{
tree parm_name = NULL_TREE, parm_decl;
tree parm_type = TREE_VALUE (tem);
- if (i >= DECL_MAX_LOCALS(fndecl))
- fatal ("function has more parameters than local slots");
+ if (i >= DECL_MAX_LOCALS (fndecl))
+ abort ();
parm_decl = build_decl (PARM_DECL, parm_name, parm_type);
DECL_CONTEXT (parm_decl) = fndecl;
rest_of_compilation (fndecl);
current_function_decl = NULL_TREE;
- permanent_allocation (1);
asynchronous_exceptions = flag_asynchronous_exceptions;
}
ggc_mark_tree (li->utf8_ref);
}
else if (TREE_CODE (t) == VAR_DECL
- || TREE_CODE (t) == PARM_DECL)
+ || TREE_CODE (t) == PARM_DECL
+ || TREE_CODE (t) == FIELD_DECL)
{
struct lang_decl_var *ldv =
((struct lang_decl_var *) DECL_LANG_SPECIFIC (t));
{
ggc_mark (ldv);
ggc_mark_tree (ldv->slot_chain);
+ ggc_mark_tree (ldv->am);
+ ggc_mark_tree (ldv->wfl);
}
}
else if (TREE_CODE (t) == FUNCTION_DECL)
if (ld)
{
ggc_mark (ld);
+ ggc_mark_tree (ld->wfl);
ggc_mark_tree (ld->throws_list);
ggc_mark_tree (ld->function_decl_body);
ggc_mark_tree (ld->called_constructor);
ggc_mark_tree (lt->clinit_stmt_list);
ggc_mark_tree (lt->ii_block);
ggc_mark_tree (lt->dot_class);
+ ggc_mark_tree (lt->package_list);
}
}
}