X-Git-Url: https://oss.titaniummirror.com/gitweb?a=blobdiff_plain;f=gcc%2Fjava%2Fdecl.c;fp=gcc%2Fjava%2Fdecl.c;h=0000000000000000000000000000000000000000;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=b76f46fb86fb576573e012965dc6d1ac144a47db;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git diff --git a/gcc/java/decl.c b/gcc/java/decl.c deleted file mode 100644 index b76f46fb..00000000 --- a/gcc/java/decl.c +++ /dev/null @@ -1,1897 +0,0 @@ -/* Process declarations and variables for the GNU compiler for the - Java(TM) language. - Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 - Free Software Foundation, Inc. - -This file is part of GNU CC. - -GNU CC 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, -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 -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. - -Java and all Java-based marks are trademarks or registered trademarks -of Sun Microsystems, Inc. in the United States and other countries. -The Free Software Foundation is independent of Sun Microsystems, Inc. */ - -/* Hacked by Per Bothner February 1996. */ - -#include "config.h" -#include "system.h" -#include "tree.h" -#include "rtl.h" -#include "toplev.h" -#include "flags.h" -#include "java-tree.h" -#include "jcf.h" -#include "function.h" -#include "expr.h" -#include "libfuncs.h" -#include "except.h" -#include "java-except.h" -#include "ggc.h" - -#if defined (DEBUG_JAVA_BINDING_LEVELS) -extern void indent PROTO((void)); -#endif - -static tree push_jvm_slot PARAMS ((int, tree)); -static tree lookup_name_current_level PARAMS ((tree)); -static tree push_promoted_type PARAMS ((const char *, tree)); -static struct binding_level *make_binding_level PARAMS ((void)); -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; - -/* 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. - The DECL_MAP mapping is represented as a TREE_VEC whose elements - are a list of decls (VAR_DECL or PARM_DECL) chained by - DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then - we search the chain for a decl with a matching TREE_TYPE. */ - -tree decl_map; - -/* A list of local variables VAR_DECLs for this method that we have seen - debug information, but we have not reached their starting (byte) PC yet. */ - -static tree pending_local_decls = NULL_TREE; - -/* Push a local variable or stack slot into the decl_map, - and assign it an rtl. */ - -#if defined(DEBUG_JAVA_BINDING_LEVELS) -int binding_depth = 0; -int is_class_level = 0; -int current_pc; - -void -indent () -{ - register unsigned i; - - for (i = 0; i < binding_depth*2; i++) - putc (' ', stderr); -} -#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */ - -static tree -push_jvm_slot (index, decl) - int index; - tree decl; -{ - struct rtx_def *rtl = NULL; - tree type = TREE_TYPE (decl); - tree tmp; - - DECL_CONTEXT (decl) = current_function_decl; - layout_decl (decl, 0); - - /* See if we have an appropriate rtl (i.e. same mode) at this index. - If so, we must use it. */ - tmp = TREE_VEC_ELT (decl_map, index); - while (tmp != NULL_TREE) - { - if (TYPE_MODE (type) == TYPE_MODE (TREE_TYPE (tmp))) - rtl = DECL_RTL_IF_SET (tmp); - if (rtl != NULL) - break; - tmp = DECL_LOCAL_SLOT_CHAIN (tmp); - } - if (rtl != NULL) - SET_DECL_RTL (decl, rtl); - else - { - if (index >= DECL_MAX_LOCALS (current_function_decl)) - DECL_REGISTER (decl) = 1; - expand_decl (decl); - } - - /* Now link the decl into the decl_map. */ - if (DECL_LANG_SPECIFIC (decl) == NULL) - { - 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; - } - DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index); - TREE_VEC_ELT (decl_map, index) = decl; - 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 -find_local_variable (index, type, pc) - int index; - tree type; - int pc; -{ - 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) - { - /* 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) - { - /* 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)); -} - - -/* Same as find_local_index, except that INDEX is a stack index. */ - -tree -find_stack_slot (index, type) - int index; - tree type; -{ - return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl), - type, -1); -} - -struct binding_level - { - /* A chain of _DECL nodes for all variables, constants, functions, - * and typedef types. These are in the reverse of the order supplied. - */ - tree names; - - /* For each level, a list of shadowed outer-level local definitions - to be restored when this level is popped. - Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and - whose TREE_VALUE is its old definition (a kind of ..._DECL node). */ - tree shadowed; - - /* For each level (except not the global one), - a chain of BLOCK nodes for all the levels - that were entered and exited one level down. */ - tree blocks; - - /* The BLOCK node for this level, if one has been preallocated. - If 0, the BLOCK is allocated (if needed) when the level is popped. */ - tree this_block; - - /* The binding level which this one is contained in (inherits from). */ - struct binding_level *level_chain; - - /* The bytecode PC that marks the end of this level. */ - int end_pc; - /* The bytecode PC that marks the start of this level. */ - int start_pc; - -#if defined(DEBUG_JAVA_BINDING_LEVELS) - /* Binding depth at which this level began. */ - unsigned binding_depth; -#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */ - }; - -#define NULL_BINDING_LEVEL (struct binding_level *) NULL - -/* The binding level currently in effect. */ - -static struct binding_level *current_binding_level; - -/* A chain of binding_level structures awaiting reuse. */ - -static struct binding_level *free_binding_level; - -/* The outermost binding level, for names of file scope. - This is created when the compiler is started and exists - through the entire run. */ - -static struct binding_level *global_binding_level; - -/* A PC value bigger than any PC value we may ever may encounter. */ - -#define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1) - -/* Binding level structures are initialized by copying this one. */ - -static struct binding_level clear_binding_level - = {NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE, - NULL_BINDING_LEVEL, LARGEST_PC, 0}; - -#if 0 -/* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function - that have names. Here so we can clear out their names' definitions - at the end of the function. */ - -static tree named_labels; - -/* A list of LABEL_DECLs from outer contexts that are currently shadowed. */ - -static tree shadowed_labels; -#endif - -int flag_traditional; - -tree java_global_trees[JTI_MAX]; - -/* Build (and pushdecl) a "promoted type" for all standard - types shorter than int. */ - -static tree -push_promoted_type (name, actual_type) - const char *name; - tree actual_type; -{ - tree type = make_node (TREE_CODE (actual_type)); -#if 1 - tree in_min = TYPE_MIN_VALUE (int_type_node); - tree in_max = TYPE_MAX_VALUE (int_type_node); -#else - tree in_min = TYPE_MIN_VALUE (actual_type); - tree in_max = TYPE_MAX_VALUE (actual_type); -#endif - TYPE_MIN_VALUE (type) = copy_node (in_min); - TREE_TYPE (TYPE_MIN_VALUE (type)) = type; - TYPE_MAX_VALUE (type) = copy_node (in_max); - TREE_TYPE (TYPE_MAX_VALUE (type)) = type; - TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node); - layout_type (type); - pushdecl (build_decl (TYPE_DECL, get_identifier (name), type)); - return type; -} - -/* Return a definition for a builtin function named NAME and whose data type - is TYPE. TYPE should be a function type with argument types. - FUNCTION_CODE tells later passes how to compile calls to this function. - See tree.h for its possible values. - - If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME, - the name to be called if we can't opencode the function. */ - -tree -builtin_function (name, type, function_code, class, library_name) - const char *name; - tree type; - int function_code; - enum built_in_class class; - const char *library_name; -{ - tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type); - DECL_EXTERNAL (decl) = 1; - TREE_PUBLIC (decl) = 1; - if (library_name) - SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name)); - make_decl_rtl (decl, NULL); - pushdecl (decl); - DECL_BUILT_IN_CLASS (decl) = class; - DECL_FUNCTION_CODE (decl) = function_code; - return decl; -} - -/* Return tree that represents a vtable for a primitive array. */ -static tree -create_primitive_vtable (name) - const char *name; -{ - tree r; - char buf[50]; - - sprintf (buf, "_Jv_%sVTable", name); - r = build_decl (VAR_DECL, get_identifier (buf), ptr_type_node); - DECL_EXTERNAL (r) = 1; - return r; -} - -void -java_init_decl_processing () -{ - register tree endlink; - 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; - pushlevel (0); /* make the binding_level structure for global names */ - global_binding_level = current_binding_level; - - /* The code here must be similar to build_common_tree_nodes{,_2} in - tree.c, especially as to the order of initializing common nodes. */ - error_mark_node = make_node (ERROR_MARK); - TREE_TYPE (error_mark_node) = error_mark_node; - - /* Create sizetype first - needed for other types. */ - initialize_sizetypes (); - - byte_type_node = make_signed_type (8); - pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"), byte_type_node)); - short_type_node = make_signed_type (16); - pushdecl (build_decl (TYPE_DECL, get_identifier ("short"), short_type_node)); - int_type_node = make_signed_type (32); - pushdecl (build_decl (TYPE_DECL, get_identifier ("int"), int_type_node)); - long_type_node = make_signed_type (64); - pushdecl (build_decl (TYPE_DECL, get_identifier ("long"), long_type_node)); - - unsigned_byte_type_node = make_unsigned_type (8); - pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned byte"), - unsigned_byte_type_node)); - unsigned_short_type_node = make_unsigned_type (16); - pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned short"), - unsigned_short_type_node)); - unsigned_int_type_node = make_unsigned_type (32); - pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"), - unsigned_int_type_node)); - unsigned_long_type_node = make_unsigned_type (64); - pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned long"), - unsigned_long_type_node)); - - set_sizetype (make_unsigned_type (POINTER_SIZE)); - - /* Define these next since types below may used them. */ - integer_type_node = type_for_size (INT_TYPE_SIZE, 0); - integer_zero_node = build_int_2 (0, 0); - 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_minus_one_node = build_int_2 (-1, -1); - - size_zero_node = size_int (0); - size_one_node = size_int (1); - bitsize_zero_node = bitsize_int (0); - bitsize_one_node = bitsize_int (1); - bitsize_unit_node = bitsize_int (BITS_PER_UNIT); - - long_zero_node = build_int_2 (0, 0); - TREE_TYPE (long_zero_node) = long_type_node; - - void_type_node = make_node (VOID_TYPE); - pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node)); - layout_type (void_type_node); /* Uses size_zero_node */ - ptr_type_node = build_pointer_type (void_type_node); - t = make_node (VOID_TYPE); - layout_type (t); /* Uses size_zero_node */ - return_address_type_node = build_pointer_type (t); - - null_pointer_node = build_int_2 (0, 0); - TREE_TYPE (null_pointer_node) = ptr_type_node; - - /* Used by the parser to represent empty statements and blocks. */ - empty_stmt_node = build1 (NOP_EXPR, void_type_node, size_zero_node); - CAN_COMPLETE_NORMALLY (empty_stmt_node) = 1; - -#if 0 - /* Make a type to be the domain of a few array types - whose domains don't really matter. - 200 is small enough that it always fits in size_t - and large enough that it can hold most function names for the - initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */ - short_array_type_node = build_prim_array_type (short_type_node, 200); -#endif - char_type_node = make_node (CHAR_TYPE); - TYPE_PRECISION (char_type_node) = 16; - fixup_unsigned_type (char_type_node); - pushdecl (build_decl (TYPE_DECL, get_identifier ("char"), char_type_node)); - - boolean_type_node = make_node (BOOLEAN_TYPE); - TYPE_PRECISION (boolean_type_node) = 1; - fixup_unsigned_type (boolean_type_node); - pushdecl (build_decl (TYPE_DECL, get_identifier ("boolean"), - boolean_type_node)); - boolean_false_node = TYPE_MIN_VALUE (boolean_type_node); - boolean_true_node = TYPE_MAX_VALUE (boolean_type_node); - - promoted_byte_type_node - = push_promoted_type ("promoted_byte", byte_type_node); - promoted_short_type_node - = push_promoted_type ("promoted_short", short_type_node); - promoted_char_type_node - = push_promoted_type ("promoted_char", char_type_node); - promoted_boolean_type_node - = push_promoted_type ("promoted_boolean", boolean_type_node); - - float_type_node = make_node (REAL_TYPE); - TYPE_PRECISION (float_type_node) = 32; - pushdecl (build_decl (TYPE_DECL, get_identifier ("float"), - float_type_node)); - layout_type (float_type_node); - - double_type_node = make_node (REAL_TYPE); - TYPE_PRECISION (double_type_node) = 64; - pushdecl (build_decl (TYPE_DECL, get_identifier ("double"), - double_type_node)); - layout_type (double_type_node); - - float_zero_node = build_real (float_type_node, dconst0); - double_zero_node = build_real (double_type_node, dconst0); - - /* These are the vtables for arrays of primitives. */ - boolean_array_vtable = create_primitive_vtable ("boolean"); - byte_array_vtable = create_primitive_vtable ("byte"); - char_array_vtable = create_primitive_vtable ("char"); - short_array_vtable = create_primitive_vtable ("short"); - int_array_vtable = create_primitive_vtable ("int"); - long_array_vtable = create_primitive_vtable ("long"); - float_array_vtable = create_primitive_vtable ("float"); - double_array_vtable = create_primitive_vtable ("double"); - - /* As you're adding items here, please update the code right after - this section, so that the filename containing the source code of - the pre-defined class gets registered correctly. */ - unqualified_object_id_node = get_identifier ("Object"); - object_type_node = lookup_class (get_identifier ("java.lang.Object")); - object_ptr_type_node = promote_type (object_type_node); - string_type_node = lookup_class (get_identifier ("java.lang.String")); - string_ptr_type_node = promote_type (string_type_node); - class_type_node = lookup_class (get_identifier ("java.lang.Class")); - throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable")); - exception_type_node = lookup_class (get_identifier ("java.lang.Exception")); - runtime_exception_type_node = - lookup_class (get_identifier ("java.lang.RuntimeException")); - error_exception_type_node = - lookup_class (get_identifier ("java.lang.Error")); - class_not_found_type_node = - lookup_class (get_identifier ("java.lang.ClassNotFoundException")); - no_class_def_found_type_node = - lookup_class (get_identifier ("java.lang.NoClassDefFoundError")); - - rawdata_ptr_type_node - = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData"))); - - add_predefined_file (get_identifier ("java/lang/Class.java")); - add_predefined_file (get_identifier ("java/lang/Error.java")); - add_predefined_file (get_identifier ("java/lang/Object.java")); - add_predefined_file (get_identifier ("java/lang/RuntimeException.java")); - add_predefined_file (get_identifier ("java/lang/String.java")); - add_predefined_file (get_identifier ("java/lang/Throwable.java")); - add_predefined_file (get_identifier ("gnu/gcj/RawData.java")); - add_predefined_file (get_identifier ("java/lang/Exception.java")); - add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java")); - add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java")); - add_predefined_file (get_identifier ("gnu/gcj/RawData.java")); - - methodtable_type = make_node (RECORD_TYPE); - layout_type (methodtable_type); - build_decl (TYPE_DECL, get_identifier ("methodtable"), methodtable_type); - methodtable_ptr_type = build_pointer_type (methodtable_type); - - TYPE_identifier_node = get_identifier ("TYPE"); - init_identifier_node = get_identifier (""); - clinit_identifier_node = get_identifier (""); - finit_identifier_node = get_identifier ("finit$"); - instinit_identifier_node = get_identifier ("instinit$"); - void_signature_node = get_identifier ("()V"); - length_identifier_node = get_identifier ("length"); - finalize_identifier_node = get_identifier ("finalize"); - this_identifier_node = get_identifier ("this"); - 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(); - - utf8const_type = make_node (RECORD_TYPE); - PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node); - PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node); - FINISH_RECORD (utf8const_type); - utf8const_ptr_type = build_pointer_type (utf8const_type); - - constants_type_node = make_node (RECORD_TYPE); - PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node); - PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node); - PUSH_FIELD (constants_type_node, field, "data", ptr_type_node); - FINISH_RECORD (constants_type_node); - build_decl (TYPE_DECL, get_identifier ("constants"), constants_type_node); - - access_flags_type_node = unsigned_short_type_node; - - dtable_type = make_node (RECORD_TYPE); - dtable_ptr_type = build_pointer_type (dtable_type); - - one_elt_array_domain_type = build_index_type (integer_one_node); - otable_type = build_array_type (integer_type_node, - one_elt_array_domain_type); - otable_ptr_type = build_pointer_type (otable_type); - - method_symbol_type = make_node (RECORD_TYPE); - PUSH_FIELD (method_symbol_type, field, "clname", utf8const_ptr_type); - PUSH_FIELD (method_symbol_type, field, "name", utf8const_ptr_type); - PUSH_FIELD (method_symbol_type, field, "signature", utf8const_ptr_type); - FINISH_RECORD (method_symbol_type); - - method_symbols_array_type = build_array_type (method_symbol_type, - one_elt_array_domain_type); - method_symbols_array_ptr_type = build_pointer_type - (method_symbols_array_type); - - otable_decl = build_decl (VAR_DECL, get_identifier ("otable"), otable_type); - DECL_EXTERNAL (otable_decl) = 1; - TREE_STATIC (otable_decl) = 1; - TREE_READONLY (otable_decl) = 1; - pushdecl (otable_decl); - - otable_syms_decl = build_decl (VAR_DECL, get_identifier ("otable_syms"), - method_symbols_array_type); - TREE_STATIC (otable_syms_decl) = 1; - TREE_CONSTANT (otable_syms_decl) = 1; - pushdecl (otable_syms_decl); - - PUSH_FIELD (object_type_node, field, "vtable", dtable_ptr_type); - /* This isn't exactly true, but it is what we have in the source. - There is an unresolved issue here, which is whether the vtable - should be marked by the GC. */ - if (! flag_hash_synchronization) - PUSH_FIELD (object_type_node, field, "sync_info", - build_pointer_type (object_type_node)); - for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t)) - FIELD_PRIVATE (t) = 1; - FINISH_RECORD (object_type_node); - - field_type_node = make_node (RECORD_TYPE); - field_ptr_type_node = build_pointer_type (field_type_node); - method_type_node = make_node (RECORD_TYPE); - method_ptr_type_node = build_pointer_type (method_type_node); - - set_super_info (0, class_type_node, object_type_node, 0); - set_super_info (0, string_type_node, object_type_node, 0); - class_ptr_type = build_pointer_type (class_type_node); - - PUSH_FIELD (class_type_node, field, "next", class_ptr_type); - PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type); - PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node); - PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type); - PUSH_FIELD (class_type_node, field, "constants", constants_type_node); - PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node); - PUSH_FIELD (class_type_node, field, "method_count", short_type_node); - PUSH_FIELD (class_type_node, field, "vtable_method_count", short_type_node); - PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node); - PUSH_FIELD (class_type_node, field, "size_in_bytes", int_type_node); - PUSH_FIELD (class_type_node, field, "field_count", short_type_node); - PUSH_FIELD (class_type_node, field, "static_field_count", short_type_node); - PUSH_FIELD (class_type_node, field, "vtable", dtable_ptr_type); - PUSH_FIELD (class_type_node, field, "otable", otable_ptr_type); - PUSH_FIELD (class_type_node, field, "otable_syms", - method_symbols_array_ptr_type); - PUSH_FIELD (class_type_node, field, "interfaces", - build_pointer_type (class_ptr_type)); - PUSH_FIELD (class_type_node, field, "loader", ptr_type_node); - PUSH_FIELD (class_type_node, field, "interface_count", short_type_node); - PUSH_FIELD (class_type_node, field, "state", byte_type_node); - PUSH_FIELD (class_type_node, field, "thread", ptr_type_node); - 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); - PUSH_FIELD (class_type_node, field, "protectionDomain", 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); - - FINISH_RECORD (class_type_node); - build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node); - - field_info_union_node = make_node (UNION_TYPE); - PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node); - PUSH_FIELD (field_info_union_node, field, "addr", ptr_type_node); -#if 0 - PUSH_FIELD (field_info_union_node, field, "idx", unsigned_short_type_node); -#endif - layout_type (field_info_union_node); - - PUSH_FIELD (field_type_node, field, "name", utf8const_ptr_type); - PUSH_FIELD (field_type_node, field, "type", class_ptr_type); - PUSH_FIELD (field_type_node, field, "accflags", access_flags_type_node); - PUSH_FIELD (field_type_node, field, "bsize", unsigned_short_type_node); - PUSH_FIELD (field_type_node, field, "info", field_info_union_node); - FINISH_RECORD (field_type_node); - build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node); - - nativecode_ptr_array_type_node - = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type); - - PUSH_FIELD (dtable_type, field, "class", class_ptr_type); - PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node); - FINISH_RECORD (dtable_type); - build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type); - -#define jint_type int_type_node -#define jint_ptr_type ptr_type_node - - jexception_type = make_node (RECORD_TYPE); - PUSH_FIELD (jexception_type, field, "start_pc", ptr_type_node); - PUSH_FIELD (jexception_type, field, "end_pc", ptr_type_node); - PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node); - PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type); - FINISH_RECORD (jexception_type); - build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node); - jexception_ptr_type = build_pointer_type (jexception_type); - - lineNumberEntry_type = make_node (RECORD_TYPE); - PUSH_FIELD (lineNumberEntry_type, field, "line_nr", unsigned_short_type_node); - PUSH_FIELD (lineNumberEntry_type, field, "start_pc", ptr_type_node); - FINISH_RECORD (lineNumberEntry_type); - - lineNumbers_type = make_node (RECORD_TYPE); - PUSH_FIELD (lineNumbers_type, field, "length", unsigned_int_type_node); - FINISH_RECORD (lineNumbers_type); - -#define instn_ptr_type_node ptr_type_node /* XXX JH */ - -#define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type) - - PUSH_FIELD (method_type_node, field, "name", utf8const_ptr_type); - PUSH_FIELD (method_type_node, field, "signature", utf8const_ptr_type); - PUSH_FIELD (method_type_node, field, "accflags", access_flags_type_node); - PUSH_FIELD (method_type_node, field, "index", unsigned_short_type_node); - PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node); - PUSH_FIELD (method_type_node, field, "throws", ptr_type_node); - FINISH_RECORD (method_type_node); - build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node); - - endlink = end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE); - - t = tree_cons (NULL_TREE, class_ptr_type, - tree_cons (NULL_TREE, int_type_node, endlink)); - alloc_object_node = builtin_function ("_Jv_AllocObject", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - DECL_IS_MALLOC (alloc_object_node) = 1; - alloc_no_finalizer_node = - builtin_function ("_Jv_AllocObjectNoFinalizer", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - DECL_IS_MALLOC (alloc_no_finalizer_node) = 1; - - t = tree_cons (NULL_TREE, ptr_type_node, endlink); - soft_initclass_node = builtin_function ("_Jv_InitClass", - build_function_type (void_type_node, - t), - 0, NOT_BUILT_IN, NULL); - - throw_node = builtin_function ("_Jv_Throw", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - /* Mark throw_nodes as `noreturn' functions with side effects. */ - TREE_THIS_VOLATILE (throw_node) = 1; - TREE_SIDE_EFFECTS (throw_node) = 1; - - t = build_function_type (int_type_node, endlink); - soft_monitorenter_node - = builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN, NULL); - soft_monitorexit_node - = builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN, NULL); - - t = tree_cons (NULL_TREE, int_type_node, - tree_cons (NULL_TREE, int_type_node, endlink)); - soft_newarray_node - = builtin_function ("_Jv_NewPrimArray", - build_function_type(ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - DECL_IS_MALLOC (soft_newarray_node) = 1; - - t = tree_cons (NULL_TREE, int_type_node, - tree_cons (NULL_TREE, class_ptr_type, - tree_cons (NULL_TREE, object_ptr_type_node, endlink))); - soft_anewarray_node - = builtin_function ("_Jv_NewObjectArray", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - DECL_IS_MALLOC (soft_anewarray_node) = 1; - - t = tree_cons (NULL_TREE, ptr_type_node, - tree_cons (NULL_TREE, int_type_node, endlink)); - soft_multianewarray_node - = builtin_function ("_Jv_NewMultiArray", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - DECL_IS_MALLOC (soft_multianewarray_node) = 1; - - t = build_function_type (void_type_node, - tree_cons (NULL_TREE, int_type_node, endlink)); - soft_badarrayindex_node - = builtin_function ("_Jv_ThrowBadArrayIndex", t, - 0, NOT_BUILT_IN, NULL); - /* Mark soft_badarrayindex_node as a `noreturn' function with side - effects. */ - TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1; - TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1; - - soft_nullpointer_node - = builtin_function ("_Jv_ThrowNullPointerException", - build_function_type (void_type_node, endlink), - 0, NOT_BUILT_IN, NULL); - /* Mark soft_nullpointer_node as a `noreturn' function with side - effects. */ - TREE_THIS_VOLATILE (soft_nullpointer_node) = 1; - TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1; - - t = tree_cons (NULL_TREE, class_ptr_type, - tree_cons (NULL_TREE, object_ptr_type_node, endlink)); - soft_checkcast_node - = builtin_function ("_Jv_CheckCast", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - t = tree_cons (NULL_TREE, object_ptr_type_node, - tree_cons (NULL_TREE, class_ptr_type, endlink)); - soft_instanceof_node - = builtin_function ("_Jv_IsInstanceOf", - build_function_type (boolean_type_node, t), - 0, NOT_BUILT_IN, NULL); - t = tree_cons (NULL_TREE, object_ptr_type_node, - tree_cons (NULL_TREE, object_ptr_type_node, endlink)); - soft_checkarraystore_node - = builtin_function ("_Jv_CheckArrayStore", - build_function_type (void_type_node, t), - 0, NOT_BUILT_IN, NULL); - t = tree_cons (NULL_TREE, ptr_type_node, - tree_cons (NULL_TREE, ptr_type_node, - tree_cons (NULL_TREE, int_type_node, endlink))); - soft_lookupinterfacemethod_node - = builtin_function ("_Jv_LookupInterfaceMethodIdx", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - - t = tree_cons (NULL_TREE, object_ptr_type_node, - tree_cons (NULL_TREE, ptr_type_node, - tree_cons (NULL_TREE, ptr_type_node, endlink))); - soft_lookupjnimethod_node - = builtin_function ("_Jv_LookupJNIMethod", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - t = tree_cons (NULL_TREE, ptr_type_node, endlink); - soft_getjnienvnewframe_node - = builtin_function ("_Jv_GetJNIEnvNewFrame", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - soft_jnipopsystemframe_node - = builtin_function ("_Jv_JNI_PopSystemFrame", - build_function_type (ptr_type_node, t), - 0, NOT_BUILT_IN, NULL); - - t = tree_cons (NULL_TREE, double_type_node, - tree_cons (NULL_TREE, double_type_node, endlink)); - soft_fmod_node - = builtin_function ("__builtin_fmod", - build_function_type (double_type_node, t), - BUILT_IN_FMOD, BUILT_IN_NORMAL, "fmod"); - -#if 0 - t = tree_cons (NULL_TREE, float_type_node, - tree_cons (NULL_TREE, float_type_node, endlink)); - soft_fmodf_node - = builtin_function ("__builtin_fmodf", - build_function_type (float_type_node, t), - BUILT_IN_FMOD, BUILT_IN_NORMAL, "fmodf"); -#endif - - soft_idiv_node - = builtin_function ("_Jv_divI", - build_function_type (int_type_node, t), - 0, NOT_BUILT_IN, NULL); - - soft_irem_node - = builtin_function ("_Jv_remI", - build_function_type (int_type_node, t), - 0, NOT_BUILT_IN, NULL); - - soft_ldiv_node - = builtin_function ("_Jv_divJ", - build_function_type (long_type_node, t), - 0, NOT_BUILT_IN, NULL); - - soft_lrem_node - = builtin_function ("_Jv_remJ", - build_function_type (long_type_node, t), - 0, NOT_BUILT_IN, NULL); - - /* Initialize variables for except.c. */ - eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS - ? "__gcj_personality_sj0" - : "__gcj_personality_v0"); - lang_eh_runtime_type = prepare_eh_table_type; - - init_jcf_parse (); - - /* Register nodes with the garbage collector. */ - ggc_add_tree_root (java_global_trees, - sizeof (java_global_trees) / sizeof (tree)); - ggc_add_tree_root (&decl_map, 1); - ggc_add_tree_root (&pending_local_decls, 1); - - initialize_builtins (); -} - - -/* Look up NAME in the current binding level and its superiors - in the namespace of variables, functions and typedefs. - Return a ..._DECL node of some kind representing its definition, - or return 0 if it is undefined. */ - -tree -lookup_name (name) - tree name; -{ - register tree val; - if (current_binding_level != global_binding_level - && IDENTIFIER_LOCAL_VALUE (name)) - val = IDENTIFIER_LOCAL_VALUE (name); - else - val = IDENTIFIER_GLOBAL_VALUE (name); - return val; -} - -/* Similar to `lookup_name' but look only at current binding level and - the previous one if its the parameter level. */ - -static tree -lookup_name_current_level (name) - tree name; -{ - register tree t; - - if (current_binding_level == global_binding_level) - return IDENTIFIER_GLOBAL_VALUE (name); - - if (IDENTIFIER_LOCAL_VALUE (name) == 0) - return 0; - - for (t = current_binding_level->names; t; t = TREE_CHAIN (t)) - if (DECL_NAME (t) == name) - break; - - return t; -} - -/* Use a binding level to record a labeled block declaration */ - -void -push_labeled_block (lb) - tree lb; -{ - register tree name = DECL_NAME (LABELED_BLOCK_LABEL (lb)); - register struct binding_level *b = current_binding_level; - tree oldlocal = IDENTIFIER_LOCAL_VALUE (name); - if (oldlocal != 0) - b->shadowed = tree_cons (name, oldlocal, b->shadowed); - TREE_CHAIN (lb) = b->names; - b->names = lb; - IDENTIFIER_LOCAL_VALUE (name) = lb; -} - -/* Pop the current binding level, reinstalling values for the previous - labeled block */ - -void -pop_labeled_block () -{ - struct binding_level *b = current_binding_level; - tree label = b->names; - IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label))) = - NULL_TREE; - if (b->shadowed) - IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b->shadowed)) = - TREE_VALUE (b->shadowed); - - /* Pop the current level, and free the structure for reuse. */ - current_binding_level = current_binding_level->level_chain; - b->level_chain = free_binding_level; - free_binding_level = b; -} - -/* Record a decl-node X as belonging to the current lexical scope. - Check for errors (such as an incompatible declaration for the same - name already seen in the same scope). - - Returns either X or an old decl for the same name. - If an old decl is returned, it may have been smashed - to agree with what X says. */ - -tree -pushdecl (x) - tree x; -{ - register tree t; - register tree name = DECL_NAME (x); - register struct binding_level *b = current_binding_level; - - if (TREE_CODE (x) != TYPE_DECL) - DECL_CONTEXT (x) = current_function_decl; - if (name) - { - const char *file; - int line; - - t = lookup_name_current_level (name); - if (t != 0 && t == error_mark_node) - /* error_mark_node is 0 for a while during initialization! */ - { - t = 0; - error_with_decl (x, "`%s' used prior to declaration"); - } - - if (t != 0) - { - file = DECL_SOURCE_FILE (t); - line = DECL_SOURCE_LINE (t); - } - - /* If we're naming a hitherto-unnamed type, set its TYPE_NAME - to point to the TYPE_DECL. - Since Java does not have typedefs, a type can only have - one (true) name, given by a class, interface, or builtin. */ - if (TREE_CODE (x) == TYPE_DECL - && TYPE_NAME (TREE_TYPE (x)) == 0 - && TREE_TYPE (x) != error_mark_node) - { - TYPE_NAME (TREE_TYPE (x)) = x; - TYPE_STUB_DECL (TREE_TYPE (x)) = x; - } - - /* This name is new in its binding level. - Install the new declaration and return it. */ - if (b == global_binding_level) - { - /* Install a global value. */ - - IDENTIFIER_GLOBAL_VALUE (name) = x; - } - else - { - /* Here to install a non-global value. */ - tree oldlocal = IDENTIFIER_LOCAL_VALUE (name); - IDENTIFIER_LOCAL_VALUE (name) = x; - -#if 0 - /* Warn if shadowing an argument at the top level of the body. */ - if (oldlocal != 0 && !DECL_EXTERNAL (x) - /* This warning doesn't apply to the parms of a nested fcn. */ - && ! current_binding_level->parm_flag - /* Check that this is one level down from the parms. */ - && current_binding_level->level_chain->parm_flag - /* Check that the decl being shadowed - comes from the parm level, one level up. */ - && chain_member (oldlocal, current_binding_level->level_chain->names)) - { - if (TREE_CODE (oldlocal) == PARM_DECL) - pedwarn ("declaration of `%s' shadows a parameter", - IDENTIFIER_POINTER (name)); - else - pedwarn ("declaration of `%s' shadows a symbol from the parameter list", - IDENTIFIER_POINTER (name)); - } - - /* Maybe warn if shadowing something else. */ - else if (warn_shadow && !DECL_EXTERNAL (x) - /* No shadow warnings for internally generated vars. */ - && DECL_SOURCE_LINE (x) != 0 - /* No shadow warnings for vars made for inlining. */ - && ! DECL_FROM_INLINE (x)) - { - const char *warnstring = 0; - - if (TREE_CODE (x) == PARM_DECL - && current_binding_level->level_chain->parm_flag) - /* Don't warn about the parm names in function declarator - within a function declarator. - It would be nice to avoid warning in any function - declarator in a declaration, as opposed to a definition, - but there is no way to tell it's not a definition. */ - ; - else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL) - warnstring = "declaration of `%s' shadows a parameter"; - else if (oldlocal != 0) - warnstring = "declaration of `%s' shadows previous local"; - else if (IDENTIFIER_GLOBAL_VALUE (name) != 0 - && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node) - warnstring = "declaration of `%s' shadows global declaration"; - - if (warnstring) - warning (warnstring, IDENTIFIER_POINTER (name)); - } -#endif - - /* If storing a local value, there may already be one (inherited). - If so, record it for restoration when this binding level ends. */ - if (oldlocal != 0) - b->shadowed = tree_cons (name, oldlocal, b->shadowed); - } - } - - /* Put decls on list in reverse order. - We will reverse them later if necessary. */ - TREE_CHAIN (x) = b->names; - b->names = x; - - return x; -} - -void -pushdecl_force_head (x) - tree x; -{ - current_binding_level->names = x; -} - -/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */ - -tree -pushdecl_top_level (x) - tree x; -{ - register tree t; - register struct binding_level *b = current_binding_level; - - current_binding_level = global_binding_level; - t = pushdecl (x); - current_binding_level = b; - return t; -} - -/* Nonzero if we are currently in the global binding level. */ - -int -global_bindings_p () -{ - return current_binding_level == global_binding_level; -} - -/* Return the list of declarations of the current level. - Note that this list is in reverse order unless/until - you nreverse it; and when you do nreverse it, you must - store the result back using `storedecls' or you will lose. */ - -tree -getdecls () -{ - return current_binding_level->names; -} - -/* Create a new `struct binding_level'. */ - -static struct binding_level * -make_binding_level () -{ - /* NOSTRICT */ - return (struct binding_level *) xmalloc (sizeof (struct binding_level)); -} - -void -pushlevel (unused) - int unused ATTRIBUTE_UNUSED; -{ - register struct binding_level *newlevel = NULL_BINDING_LEVEL; - -#if 0 - /* If this is the top level of a function, - just make sure that NAMED_LABELS is 0. */ - - if (current_binding_level == global_binding_level) - named_labels = 0; -#endif - - /* Reuse or create a struct for this binding level. */ - - if (free_binding_level) - { - newlevel = free_binding_level; - free_binding_level = free_binding_level->level_chain; - } - else - { - newlevel = make_binding_level (); - } - - /* Add this level to the front of the chain (stack) of levels that - are active. */ - - *newlevel = clear_binding_level; - newlevel->level_chain = current_binding_level; - current_binding_level = newlevel; -#if defined(DEBUG_JAVA_BINDING_LEVELS) - newlevel->binding_depth = binding_depth; - indent (); - fprintf (stderr, "push %s level 0x%08x pc %d\n", - (is_class_level) ? "class" : "block", newlevel, current_pc); - is_class_level = 0; - binding_depth++; -#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */ -} - -/* Exit a binding level. - Pop the level off, and restore the state of the identifier-decl mappings - that were in effect when this level was entered. - - If KEEP is nonzero, this level had explicit declarations, so - and create a "block" (a BLOCK node) for the level - to record its declarations and subblocks for symbol table output. - - If FUNCTIONBODY is nonzero, this level is the body of a function, - so create a block as if KEEP were set and also clear out all - label names. - - If REVERSE is nonzero, reverse the order of decls before putting - them into the BLOCK. */ - -tree -poplevel (keep, reverse, functionbody) - int keep; - int reverse; - int functionbody; -{ - register tree link; - /* The chain of decls was accumulated in reverse order. - Put it into forward order, just for cleanliness. */ - tree decls; - tree subblocks = current_binding_level->blocks; - tree block = 0; - tree decl; - int block_previously_created; - -#if defined(DEBUG_JAVA_BINDING_LEVELS) - binding_depth--; - indent (); - if (current_binding_level->end_pc != LARGEST_PC) - fprintf (stderr, "pop %s level 0x%08x pc %d (end pc %d)\n", - (is_class_level) ? "class" : "block", current_binding_level, current_pc, - current_binding_level->end_pc); - else - fprintf (stderr, "pop %s level 0x%08x pc %d\n", - (is_class_level) ? "class" : "block", current_binding_level, current_pc); -#if 0 - if (is_class_level != (current_binding_level == class_binding_level)) - { - indent (); - fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n"); - } - is_class_level = 0; -#endif -#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */ - - /* Get the decls in the order they were written. - Usually current_binding_level->names is in reverse order. - But parameter decls were previously put in forward order. */ - - if (reverse) - current_binding_level->names - = decls = nreverse (current_binding_level->names); - else - decls = current_binding_level->names; - - /* Output any nested inline functions within this block - if they weren't already output. */ - - for (decl = decls; decl; decl = TREE_CHAIN (decl)) - if (TREE_CODE (decl) == FUNCTION_DECL - && ! TREE_ASM_WRITTEN (decl) - && DECL_INITIAL (decl) != 0 - && TREE_ADDRESSABLE (decl)) - { - /* If this decl was copied from a file-scope decl - on account of a block-scope extern decl, - propagate TREE_ADDRESSABLE to the file-scope decl. - - DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is - true, since then the decl goes through save_for_inline_copying. */ - if (DECL_ABSTRACT_ORIGIN (decl) != 0 - && DECL_ABSTRACT_ORIGIN (decl) != decl) - TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1; - else - { - push_function_context (); - output_inline_function (decl); - pop_function_context (); - } - } - - /* If there were any declarations in that level, - or if this level is a function body, - create a BLOCK to record them for the life of this function. */ - - block = 0; - block_previously_created = (current_binding_level->this_block != 0); - if (block_previously_created) - block = current_binding_level->this_block; - else if (keep || functionbody) - block = make_node (BLOCK); - if (block != 0) - { - BLOCK_VARS (block) = decls; - BLOCK_SUBBLOCKS (block) = subblocks; - } - - /* In each subblock, record that this is its superior. */ - - for (link = subblocks; link; link = TREE_CHAIN (link)) - BLOCK_SUPERCONTEXT (link) = block; - - /* Clear out the meanings of the local variables of this level. */ - - for (link = decls; link; link = TREE_CHAIN (link)) - { - tree name = DECL_NAME (link); - if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link) - { - /* If the ident. was used or addressed via a local extern decl, - don't forget that fact. */ - if (DECL_EXTERNAL (link)) - { - if (TREE_USED (link)) - TREE_USED (name) = 1; - if (TREE_ADDRESSABLE (link)) - TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1; - } - IDENTIFIER_LOCAL_VALUE (name) = 0; - } - } - - /* Restore all name-meanings of the outer levels - that were shadowed by this level. */ - - for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link)) - IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link); - - /* If the level being exited is the top level of a function, - check over all the labels, and clear out the current - (function local) meanings of their names. */ - - if (functionbody) - { - /* If this is the top level block of a function, - the vars are the function's parameters. - Don't leave them in the BLOCK because they are - found in the FUNCTION_DECL instead. */ - - BLOCK_VARS (block) = 0; - - /* Clear out the definitions of all label names, - since their scopes end here, - and add them to BLOCK_VARS. */ - -#if 0 - for (link = named_labels; link; link = TREE_CHAIN (link)) - { - register tree label = TREE_VALUE (link); - - if (DECL_INITIAL (label) == 0) - { - error_with_decl (label, "label `%s' used but not defined"); - /* Avoid crashing later. */ - define_label (input_filename, lineno, - DECL_NAME (label)); - } - else if (warn_unused[UNUSED_LABEL] && !TREE_USED (label)) - warning_with_decl (label, "label `%s' defined but not used"); - IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0; - - /* Put the labels into the "variables" of the - top-level block, so debugger can see them. */ - TREE_CHAIN (label) = BLOCK_VARS (block); - BLOCK_VARS (block) = label; - } -#endif - } - - /* Pop the current level, and free the structure for reuse. */ - - { - register struct binding_level *level = current_binding_level; - current_binding_level = current_binding_level->level_chain; - - level->level_chain = free_binding_level; - free_binding_level = level; - } - - /* Dispose of the block that we just made inside some higher level. */ - if (functionbody) - DECL_INITIAL (current_function_decl) = block; - else if (block) - { - if (!block_previously_created) - current_binding_level->blocks - = chainon (current_binding_level->blocks, block); - } - /* If we did not make a block for the level just exited, - any blocks made for inner levels - (since they cannot be recorded as subblocks in that level) - must be carried forward so they will later become subblocks - of something else. */ - else if (subblocks) - current_binding_level->blocks - = chainon (current_binding_level->blocks, subblocks); - - /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this - binding contour so that they point to the appropriate construct, i.e. - either to the current FUNCTION_DECL node, or else to the BLOCK node - we just constructed. - - Note that for tagged types whose scope is just the formal parameter - list for some function type specification, we can't properly set - their TYPE_CONTEXTs here, because we don't have a pointer to the - appropriate FUNCTION_TYPE node readily available to us. For those - cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set - in `grokdeclarator' as soon as we have created the FUNCTION_TYPE - node which will represent the "scope" for these "parameter list local" - tagged types. - */ - - if (block) - TREE_USED (block) = 1; - return block; -} - -void -maybe_pushlevels (pc) - int pc; -{ -#if defined(DEBUG_JAVA_BINDING_LEVELS) - current_pc = pc; -#endif - - while (pending_local_decls != NULL_TREE && - DECL_LOCAL_START_PC (pending_local_decls) <= pc) - { - tree *ptr = &pending_local_decls; - tree decl = *ptr; - int end_pc = DECL_LOCAL_END_PC (decl); - - while (*ptr != NULL_TREE - && DECL_LOCAL_START_PC (*ptr) <= pc - && DECL_LOCAL_END_PC (*ptr) == end_pc) - ptr = &TREE_CHAIN (*ptr); - pending_local_decls = *ptr; - *ptr = NULL_TREE; - - /* Force non-nested range to be nested in current range. */ - if (end_pc > current_binding_level->end_pc) - end_pc = current_binding_level->end_pc; - - maybe_start_try (pc, end_pc); - - pushlevel (1); - expand_start_bindings (0); - - current_binding_level->end_pc = end_pc; - current_binding_level->start_pc = pc; - current_binding_level->names = decl; - for ( ; decl != NULL_TREE; decl = TREE_CHAIN (decl)) - { - push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl); - } - } - - maybe_start_try (pc, 0); -} - -void -maybe_poplevels (pc) - int pc; -{ -#if defined(DEBUG_JAVA_BINDING_LEVELS) - current_pc = pc; -#endif - - while (current_binding_level->end_pc <= pc) - { - expand_end_bindings (getdecls (), 1, 0); - maybe_end_try (current_binding_level->start_pc, pc); - poplevel (1, 0, 0); - } - maybe_end_try (0, pc); -} - -/* Terminate any binding which began during the range beginning at - start_pc. This tidies up improperly nested local variable ranges - and exception handlers; a variable declared within an exception - range is forcibly terminated when that exception ends. */ - -void -force_poplevels (start_pc) - int start_pc; -{ - while (current_binding_level->start_pc > start_pc) - { - if (pedantic && current_binding_level->start_pc > start_pc) - warning_with_decl (current_function_decl, - "In %s: overlapped variable and exception ranges at %d", - current_binding_level->start_pc); - expand_end_bindings (getdecls (), 1, 0); - poplevel (1, 0, 0); - } -} - -/* Insert BLOCK at the end of the list of subblocks of the - current binding level. This is used when a BIND_EXPR is expanded, - to handle the BLOCK node inside the BIND_EXPR. */ - -void -insert_block (block) - tree block; -{ - TREE_USED (block) = 1; - current_binding_level->blocks - = chainon (current_binding_level->blocks, block); -} - -/* Set the BLOCK node for the innermost scope - (the one we are currently in). */ - -void -set_block (block) - 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. */ - -void -copy_lang_decl (node) - tree node; -{ - 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 *) ggc_alloc (lang_decl_size); - memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size); - DECL_LANG_SPECIFIC (node) = x; -} - -/* If DECL has a cleanup, build and return that cleanup here. - This is a callback called by expand_expr. */ - -tree -maybe_build_cleanup (decl) - tree decl ATTRIBUTE_UNUSED; -{ - /* There are no cleanups in Java (I think). */ - return NULL_TREE; -} - -void -give_name_to_locals (jcf) - JCF *jcf; -{ - int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl); - int code_offset = DECL_CODE_OFFSET (current_function_decl); - tree parm; - pending_local_decls = NULL_TREE; - if (n == 0) - return; - JCF_SEEK (jcf, n); - n = JCF_readu2 (jcf); - for (i = 0; i < n; i++) - { - int start_pc = JCF_readu2 (jcf); - int length = JCF_readu2 (jcf); - int name_index = JCF_readu2 (jcf); - int signature_index = JCF_readu2 (jcf); - int slot = JCF_readu2 (jcf); - tree name = get_name_constant (jcf, name_index); - tree type = parse_signature (jcf, signature_index); - if (slot < DECL_ARG_SLOT_COUNT (current_function_decl) - && start_pc == 0 - && length == DECL_CODE_LENGTH (current_function_decl)) - { - tree decl = TREE_VEC_ELT (decl_map, slot); - DECL_NAME (decl) = name; - SET_DECL_ASSEMBLER_NAME (decl, name); - if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type) - warning ("bad type in parameter debug info"); - } - else - { - tree *ptr; - int end_pc = start_pc + length; - tree decl = build_decl (VAR_DECL, name, type); - if (end_pc > DECL_CODE_LENGTH (current_function_decl)) - { - warning_with_decl (decl, - "bad PC range for debug info for local `%s'"); - end_pc = DECL_CODE_LENGTH (current_function_decl); - } - - /* Adjust start_pc if necessary so that the local's first - store operation will use the relevant DECL as a - destination. Fore more information, read the leading - comments for expr.c:maybe_adjust_start_pc. */ - start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot); - - MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); - DECL_LOCAL_SLOT_NUMBER (decl) = slot; - DECL_LOCAL_START_PC (decl) = start_pc; -#if 0 - /* FIXME: The range used internally for exceptions and local - variable ranges, is a half-open interval: - start_pc <= pc < end_pc. However, the range used in the - Java VM spec is inclusive at both ends: - start_pc <= pc <= end_pc. */ - end_pc++; -#endif - DECL_LOCAL_END_PC (decl) = end_pc; - - /* Now insert the new decl in the proper place in - pending_local_decls. We are essentially doing an insertion sort, - which works fine, since the list input will normally already - be sorted. */ - ptr = &pending_local_decls; - while (*ptr != NULL_TREE - && (DECL_LOCAL_START_PC (*ptr) > start_pc - || (DECL_LOCAL_START_PC (*ptr) == start_pc - && DECL_LOCAL_END_PC (*ptr) < end_pc))) - ptr = &TREE_CHAIN (*ptr); - TREE_CHAIN (decl) = *ptr; - *ptr = decl; - } - } - - pending_local_decls = nreverse (pending_local_decls); - - /* Fill in default names for the parameters. */ - for (parm = DECL_ARGUMENTS (current_function_decl), i = 0; - parm != NULL_TREE; parm = TREE_CHAIN (parm), i++) - { - if (DECL_NAME (parm) == NULL_TREE) - { - int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i; - if (arg_i == 0) - DECL_NAME (parm) = get_identifier ("this"); - else - { - char buffer[12]; - sprintf (buffer, "ARG_%d", arg_i); - DECL_NAME (parm) = get_identifier (buffer); - } - SET_DECL_ASSEMBLER_NAME (parm, DECL_NAME (parm)); - } - } -} - -tree -build_result_decl (fndecl) - tree fndecl; -{ - tree restype = TREE_TYPE (TREE_TYPE (fndecl)); - /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */ - if (INTEGRAL_TYPE_P (restype) - && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node)) - restype = integer_type_node; - return (DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, restype)); -} - -void -complete_start_java_method (fndecl) - tree fndecl; -{ - if (! flag_emit_class_files) - { - /* Initialize the RTL code for the function. */ - init_function_start (fndecl, input_filename, lineno); - - /* Set up parameters and prepare for return, for the function. */ - expand_function_start (fndecl, 0); - } - -#if 0 - /* If this fcn was already referenced via a block-scope `extern' decl (or - an implicit decl), propagate certain information about the usage. */ - if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl))) - TREE_ADDRESSABLE (current_function_decl) = 1; - -#endif - - if (METHOD_STATIC (fndecl) && ! METHOD_PRIVATE (fndecl) - && ! flag_emit_class_files - && ! DECL_CLINIT_P (fndecl) - && ! CLASS_INTERFACE (TYPE_NAME (current_class))) - { - tree clas = DECL_CONTEXT (fndecl); - tree init = build (CALL_EXPR, void_type_node, - build_address_of (soft_initclass_node), - build_tree_list (NULL_TREE, build_class_ref (clas)), - NULL_TREE); - TREE_SIDE_EFFECTS (init) = 1; - expand_expr_stmt (init); - } - - /* Push local variables. Function compiled from source code are - using a different local variables management, and for them, - pushlevel shouldn't be called from here. */ - if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl))) - { - pushlevel (2); - if (! flag_emit_class_files) - expand_start_bindings (1); - } - - if (METHOD_SYNCHRONIZED (fndecl) && ! flag_emit_class_files) - { - /* Wrap function body with a monitorenter plus monitorexit cleanup. */ - tree enter, exit, lock; - if (METHOD_STATIC (fndecl)) - lock = build_class_ref (DECL_CONTEXT (fndecl)); - else - lock = DECL_ARGUMENTS (fndecl); - BUILD_MONITOR_ENTER (enter, lock); - BUILD_MONITOR_EXIT (exit, lock); - if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl))) - { - expand_expr_stmt (enter); - expand_decl_cleanup (NULL_TREE, exit); - } - else - { - tree function_body = DECL_FUNCTION_BODY (fndecl); - tree body = BLOCK_EXPR_BODY (function_body); - lock = build (COMPOUND_EXPR, void_type_node, - enter, - build (TRY_FINALLY_EXPR, void_type_node, body, exit)); - TREE_SIDE_EFFECTS (lock) = 1; - BLOCK_EXPR_BODY (function_body) = lock; - } - } -} - -void -start_java_method (fndecl) - tree fndecl; -{ - tree tem, *ptr; - int i; - - current_function_decl = fndecl; - announce_function (fndecl); - - i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl); - decl_map = make_tree_vec (i); - type_map = (tree *) xrealloc (type_map, i * sizeof (tree)); - -#if defined(DEBUG_JAVA_BINDING_LEVELS) - fprintf (stderr, "%s:\n", (*decl_printable_name) (fndecl, 2)); - current_pc = 0; -#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */ - pushlevel (1); /* Push parameters. */ - - ptr = &DECL_ARGUMENTS (fndecl); - for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0; - tem != end_params_node; tem = TREE_CHAIN (tem), i++) - { - tree parm_name = NULL_TREE, parm_decl; - tree parm_type = TREE_VALUE (tem); - if (i >= DECL_MAX_LOCALS (fndecl)) - abort (); - - parm_decl = build_decl (PARM_DECL, parm_name, parm_type); - DECL_CONTEXT (parm_decl) = fndecl; - if (PROMOTE_PROTOTYPES - && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node) - && INTEGRAL_TYPE_P (parm_type)) - parm_type = integer_type_node; - DECL_ARG_TYPE (parm_decl) = parm_type; - - *ptr = parm_decl; - ptr = &TREE_CHAIN (parm_decl); - - /* Add parm_decl to the decl_map. */ - push_jvm_slot (i, parm_decl); - - type_map[i] = TREE_TYPE (parm_decl); - if (TYPE_IS_WIDE (TREE_TYPE (parm_decl))) - { - i++; - type_map[i] = void_type_node; - } - } - *ptr = NULL_TREE; - DECL_ARG_SLOT_COUNT (current_function_decl) = i; - - while (i < DECL_MAX_LOCALS(fndecl)) - type_map[i++] = NULL_TREE; - - build_result_decl (fndecl); - complete_start_java_method (fndecl); -} - -void -end_java_method () -{ - tree fndecl = current_function_decl; - - expand_end_bindings (getdecls (), 1, 0); - /* pop out of function */ - poplevel (1, 1, 0); - - /* pop out of its parameters */ - poplevel (1, 0, 1); - - BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl; - - /* Generate rtl for function exit. */ - expand_function_end (input_filename, lineno, 0); - - /* Run the optimizers and output assembler code for this function. */ - rest_of_compilation (fndecl); - - current_function_decl = NULL_TREE; -} - -/* Mark language-specific parts of T for garbage-collection. */ - -void -lang_mark_tree (t) - tree t; -{ - if (TREE_CODE (t) == IDENTIFIER_NODE) - { - struct lang_identifier *li = (struct lang_identifier *) t; - ggc_mark_tree (li->global_value); - ggc_mark_tree (li->local_value); - ggc_mark_tree (li->utf8_ref); - } - else if (TREE_CODE (t) == VAR_DECL - || TREE_CODE (t) == PARM_DECL - || TREE_CODE (t) == FIELD_DECL) - { - struct lang_decl_var *ldv = - ((struct lang_decl_var *) DECL_LANG_SPECIFIC (t)); - if (ldv) - { - 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) - { - struct lang_decl *ld = DECL_LANG_SPECIFIC (t); - - 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 (ld->inner_access); - ggc_mark_tree_hash_table (&ld->init_test_table); - ggc_mark_tree_hash_table (&ld->ict); - ggc_mark_tree (ld->smic); - } - } - else if (TYPE_P (t)) - { - struct lang_type *lt = TYPE_LANG_SPECIFIC (t); - - if (lt) - { - ggc_mark (lt); - ggc_mark_tree (lt->signature); - ggc_mark_tree (lt->cpool_data_ref); - ggc_mark_tree (lt->finit_stmt_list); - 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); - } - } -}