1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
31 #include "coretypes.h"
38 #include "java-tree.h"
44 #include "java-except.h"
48 #include "tree-inline.h"
52 #if defined (DEBUG_JAVA_BINDING_LEVELS)
53 extern void indent (void);
56 static tree push_jvm_slot (int, tree);
57 static tree lookup_name_current_level (tree);
58 static tree push_promoted_type (const char *, tree);
59 static struct binding_level *make_binding_level (void);
60 static tree create_primitive_vtable (const char *);
61 static tree check_local_unnamed_variable (tree, tree, tree);
62 static void parse_version (void);
65 /* The following ABI flags are used in the high-order bits of the version
66 ID field. The version ID number itself should never be larger than
67 0xfffff, so it should be safe to use top 12 bits for these flags. */
69 #define FLAG_BINARYCOMPAT_ABI (1<<31) /* Class is built with the BC-ABI. */
71 #define FLAG_BOOTSTRAP_LOADER (1<<30) /* Used when defining a class that
72 should be loaded by the bootstrap
75 /* If an ABI change is made within a GCC release series, rendering current
76 binaries incompatible with the old runtimes, this number can be set to
77 enforce the compatibility rules. */
78 #define MINOR_BINARYCOMPAT_ABI_VERSION 0
80 /* The runtime may recognize a variety of BC ABIs (objects generated by
81 different version of gcj), but will probably always require strict
82 matching for the ordinary (C++) ABI. */
84 /* The version ID of the BC ABI that we generate. This must be kept in
85 sync with parse_version(), libgcj, and reality (if the BC format changes,
87 #define GCJ_CURRENT_BC_ABI_VERSION \
88 (4 * 100000 + 0 * 1000 + MINOR_BINARYCOMPAT_ABI_VERSION)
90 /* The ABI version number. */
93 /* Name of the Cloneable class. */
94 tree java_lang_cloneable_identifier_node;
96 /* Name of the Serializable class. */
97 tree java_io_serializable_identifier_node;
99 /* The DECL_MAP is a mapping from (index, type) to a decl node.
100 If index < max_locals, it is the index of a local variable.
101 if index >= max_locals, then index-max_locals is a stack slot.
102 The DECL_MAP mapping is represented as a TREE_VEC whose elements
103 are a list of decls (VAR_DECL or PARM_DECL) chained by
104 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
105 we search the chain for a decl with a matching TREE_TYPE. */
107 static GTY(()) tree decl_map;
109 /* The base_decl_map is contains one variable of ptr_type: this is
110 used to contain every variable of reference type that is ever
111 stored in a local variable slot. */
113 static GTY(()) tree base_decl_map;
115 /* An index used to make temporary identifiers unique. */
118 /* A list of local variables VAR_DECLs for this method that we have seen
119 debug information, but we have not reached their starting (byte) PC yet. */
121 static GTY(()) tree pending_local_decls;
123 /* The decl for "_Jv_ResolvePoolEntry". */
124 tree soft_resolvepoolentry_node;
126 #if defined(DEBUG_JAVA_BINDING_LEVELS)
127 int binding_depth = 0;
128 int is_class_level = 0;
136 for (i = 0; i < binding_depth*2; i++)
139 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
141 /* True if decl is a named local variable, i.e. if it is an alias
142 that's used only for debugging purposes. */
145 debug_variable_p (tree decl)
147 if (TREE_CODE (decl) == PARM_DECL)
150 if (LOCAL_SLOT_P (decl))
156 /* Copy the value in decl into every live alias in the same local
157 variable slot. Some of these will be dead stores removed by the
161 update_aliases (tree decl, int index, int pc)
163 tree decl_type = TREE_TYPE (decl);
166 if (debug_variable_p (decl))
169 for (tmp = TREE_VEC_ELT (decl_map, index);
171 tmp = DECL_LOCAL_SLOT_CHAIN (tmp))
173 tree tmp_type = TREE_TYPE (tmp);
175 && LOCAL_SLOT_P (tmp) == 0
177 || (pc >= DECL_LOCAL_START_PC (tmp)
178 && pc < DECL_LOCAL_END_PC (tmp)))
179 /* This test is < (rather than <=) because there's no point
180 updating an alias that's about to die at the end of this
182 && (tmp_type == decl_type
183 || (INTEGRAL_TYPE_P (tmp_type)
184 && INTEGRAL_TYPE_P (decl_type)
185 && TYPE_PRECISION (decl_type) <= 32
186 && TYPE_PRECISION (tmp_type) <= 32)
187 || (TREE_CODE (tmp_type) == POINTER_TYPE
188 && TREE_CODE (decl_type) == POINTER_TYPE)))
190 tree src = build1 (NOP_EXPR, tmp_type, decl);
191 if (LOCAL_VAR_OUT_OF_SCOPE_P (tmp))
193 java_add_stmt (build2 (MODIFY_EXPR, tmp_type, tmp, src));
199 push_jvm_slot (int index, tree decl)
201 DECL_CONTEXT (decl) = current_function_decl;
202 layout_decl (decl, 0);
204 /* Now link the decl into the decl_map. */
205 if (DECL_LANG_SPECIFIC (decl) == NULL)
207 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
208 DECL_LOCAL_START_PC (decl) = 0;
209 DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
210 DECL_LOCAL_SLOT_NUMBER (decl) = index;
212 DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
213 TREE_VEC_ELT (decl_map, index) = decl;
218 /* At the point of its creation a local variable decl inherits
219 whatever is already in the same slot. In the case of a local
220 variable that is declared but unused, we won't find anything. */
223 initialize_local_variable (tree decl, int index)
225 tree decl_type = TREE_TYPE (decl);
226 if (TREE_CODE (decl_type) == POINTER_TYPE)
228 tree tmp = TREE_VEC_ELT (base_decl_map, index);
232 /* At the point of its creation this decl inherits whatever
234 tree src = build1 (NOP_EXPR, decl_type, tmp);
235 java_add_stmt (build2 (MODIFY_EXPR, decl_type, decl, src));
242 for (tmp = TREE_VEC_ELT (decl_map, index);
244 tmp = DECL_LOCAL_SLOT_CHAIN (tmp))
246 tree tmp_type = TREE_TYPE (tmp);
248 && ! debug_variable_p (tmp)
249 && (tmp_type == decl_type
250 || (INTEGRAL_TYPE_P (tmp_type)
251 && INTEGRAL_TYPE_P (decl_type)
252 && TYPE_PRECISION (decl_type) <= 32
253 && TYPE_PRECISION (tmp_type) <= 32
254 && TYPE_PRECISION (tmp_type)
255 >= TYPE_PRECISION (decl_type))))
257 java_add_stmt (build2 (MODIFY_EXPR, decl_type, decl, tmp));
264 /* Find the best declaration based upon type. If 'decl' fits 'type' better
265 than 'best', return 'decl'. Otherwise return 'best'. */
268 check_local_unnamed_variable (tree best, tree decl, tree type)
270 tree decl_type = TREE_TYPE (decl);
272 if (LOCAL_VAR_OUT_OF_SCOPE_P (decl))
275 /* Use the same decl for all integer types <= 32 bits. This is
276 necessary because sometimes a value is stored as (for example)
277 boolean but loaded as int. */
278 if (decl_type == type
279 || (INTEGRAL_TYPE_P (decl_type)
280 && INTEGRAL_TYPE_P (type)
281 && TYPE_PRECISION (decl_type) <= 32
282 && TYPE_PRECISION (type) <= 32
283 && TYPE_PRECISION (decl_type) >= TYPE_PRECISION (type))
284 /* ptr_type_node is used for null pointers, which are
285 assignment compatible with everything. */
286 || (TREE_CODE (decl_type) == POINTER_TYPE
287 && type == ptr_type_node)
288 /* Whenever anyone wants to use a slot that is initially
289 occupied by a PARM_DECL of pointer type they must get that
290 decl, even if they asked for a pointer to a different type.
291 However, if someone wants a scalar variable in a slot that
292 initially held a pointer arg -- or vice versa -- we create a
295 ???: As long as verification is correct, this will be a
296 compatible type. But maybe we should create a dummy variable
297 and replace all references to it with the DECL and a
300 || (TREE_CODE (decl_type) == POINTER_TYPE
301 && TREE_CODE (decl) == PARM_DECL
302 && TREE_CODE (type) == POINTER_TYPE))
304 if (best == NULL_TREE
305 || (decl_type == type && TREE_TYPE (best) != type))
313 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
314 that is valid at PC (or -1 if any pc).
315 If there is no existing matching decl, allocate one. */
318 find_local_variable (int index, tree type, int pc ATTRIBUTE_UNUSED)
320 tree tmp = TREE_VEC_ELT (decl_map, index);
321 tree decl = NULL_TREE;
323 /* Scan through every declaration that has been created in this
324 slot. We're only looking for variables that correspond to local
325 index declarations and PARM_DECLs, not named variables: such
326 local variables are used only for debugging information. */
327 while (tmp != NULL_TREE)
329 if (! debug_variable_p (tmp))
330 decl = check_local_unnamed_variable (decl, tmp, type);
331 tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
334 /* gcj has a function called promote_type(), which is used by both
335 the bytecode compiler and the source compiler. Unfortunately,
336 the type systems for the Java VM and the Java language are not
337 the same: a boolean in the VM promotes to an int, not to a wide
338 boolean. If our caller wants something to hold a boolean, that
339 had better be an int, because that slot might be re-used
340 later in integer context. */
341 if (TREE_CODE (type) == BOOLEAN_TYPE)
342 type = integer_type_node;
344 /* If we don't find a match, create one with the type passed in.
345 The name of the variable is #n#m, which n is the variable index
346 in the local variable area and m is a dummy identifier for
347 uniqueness -- multiple variables may share the same local
348 variable index. We don't call pushdecl() to push pointer types
349 into a binding expr because they'll all be replaced by a single
350 variable that is used for every reference in that local variable
356 sprintf (buf, "#slot#%d#%d", index, uniq++);
357 name = get_identifier (buf);
358 decl = build_decl (VAR_DECL, name, type);
359 DECL_IGNORED_P (decl) = 1;
360 DECL_ARTIFICIAL (decl) = 1;
361 decl = push_jvm_slot (index, decl);
362 LOCAL_SLOT_P (decl) = 1;
364 if (TREE_CODE (type) != POINTER_TYPE)
365 pushdecl_function_level (decl);
368 /* As well as creating a local variable that matches the type, we
369 also create a base variable (of ptr_type) that will hold all its
371 if (TREE_CODE (type) == POINTER_TYPE
372 && ! TREE_VEC_ELT (base_decl_map, index))
377 sprintf (buf, "#ref#%d#%d", index, uniq++);
378 name = get_identifier (buf);
380 = TREE_VEC_ELT (base_decl_map, index)
381 = build_decl (VAR_DECL, name, ptr_type_node);
382 pushdecl_function_level (base_decl);
383 DECL_IGNORED_P (base_decl) = 1;
384 DECL_ARTIFICIAL (base_decl) = 1;
390 /* Called during gimplification for every variable. If the variable
391 is a temporary of pointer type, replace it with a common variable
392 thath is used to hold all pointer types that are ever stored in
393 that slot. Set WANT_LVALUE if you want a variable that is to be
397 java_replace_reference (tree var_decl, bool want_lvalue)
404 decl_type = TREE_TYPE (var_decl);
406 if (TREE_CODE (decl_type) == POINTER_TYPE)
408 if (DECL_LANG_SPECIFIC (var_decl)
409 && LOCAL_SLOT_P (var_decl))
411 int index = DECL_LOCAL_SLOT_NUMBER (var_decl);
412 tree base_decl = TREE_VEC_ELT (base_decl_map, index);
418 base_decl = build1 (NOP_EXPR, decl_type, base_decl);
428 /* Same as find_local_index, except that INDEX is a stack index. */
431 find_stack_slot (int index, tree type)
433 return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
437 struct binding_level GTY(())
439 /* A chain of _DECL nodes for all variables, constants, functions,
440 * and typedef types. These are in the reverse of the order supplied.
444 /* For each level, a list of shadowed outer-level local definitions
445 to be restored when this level is popped.
446 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
447 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
450 /* For each level (except not the global one),
451 a chain of BLOCK nodes for all the levels
452 that were entered and exited one level down. */
455 /* The binding level which this one is contained in (inherits from). */
456 struct binding_level *level_chain;
458 /* The bytecode PC that marks the end of this level. */
460 /* The bytecode PC that marks the start of this level. */
463 /* The statements in this binding level. */
466 /* An exception range associated with this binding level. */
467 struct eh_range * GTY((skip (""))) exception_range;
469 /* Binding depth at which this level began. Used only for debugging. */
470 unsigned binding_depth;
473 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
475 /* The binding level currently in effect. */
477 static GTY(()) struct binding_level *current_binding_level;
479 /* A chain of binding_level structures awaiting reuse. */
481 static GTY(()) struct binding_level *free_binding_level;
483 /* The outermost binding level, for names of file scope.
484 This is created when the compiler is started and exists
485 through the entire run. */
487 static GTY(()) struct binding_level *global_binding_level;
489 /* The binding level that holds variables declared at the outermost
490 level within a function body. */
492 static struct binding_level *function_binding_level;
494 /* A PC value bigger than any PC value we may ever may encounter. */
496 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
498 /* Binding level structures are initialized by copying this one. */
500 static const struct binding_level clear_binding_level
502 NULL_TREE, /* names */
503 NULL_TREE, /* shadowed */
504 NULL_TREE, /* blocks */
505 NULL_BINDING_LEVEL, /* level_chain */
506 LARGEST_PC, /* end_pc */
509 NULL, /* exception_range */
510 0, /* binding_depth */
514 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
515 that have names. Here so we can clear out their names' definitions
516 at the end of the function. */
518 static tree named_labels;
520 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
522 static tree shadowed_labels;
525 tree java_global_trees[JTI_MAX];
527 /* Build (and pushdecl) a "promoted type" for all standard
528 types shorter than int. */
531 push_promoted_type (const char *name, tree actual_type)
533 tree type = make_node (TREE_CODE (actual_type));
535 tree in_min = TYPE_MIN_VALUE (int_type_node);
536 tree in_max = TYPE_MAX_VALUE (int_type_node);
538 tree in_min = TYPE_MIN_VALUE (actual_type);
539 tree in_max = TYPE_MAX_VALUE (actual_type);
541 TYPE_MIN_VALUE (type) = copy_node (in_min);
542 TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
543 TYPE_MAX_VALUE (type) = copy_node (in_max);
544 TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
545 TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
547 pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
551 /* Return a definition for a builtin function named NAME and whose data type
552 is TYPE. TYPE should be a function type with argument types.
553 FUNCTION_CODE tells later passes how to compile calls to this function.
554 See tree.h for its possible values.
556 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
557 the name to be called if we can't opencode the function. If
558 ATTRS is nonzero, use that for the function's attribute list. */
561 builtin_function (const char *name,
564 enum built_in_class cl,
565 const char *library_name,
566 tree ARG_UNUSED (attrs))
568 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
569 DECL_EXTERNAL (decl) = 1;
570 TREE_PUBLIC (decl) = 1;
572 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
574 DECL_BUILT_IN_CLASS (decl) = cl;
575 DECL_FUNCTION_CODE (decl) = function_code;
579 /* Return tree that represents a vtable for a primitive array. */
581 create_primitive_vtable (const char *name)
586 sprintf (buf, "_Jv_%sVTable", name);
587 r = build_decl (VAR_DECL, get_identifier (buf), ptr_type_node);
588 DECL_EXTERNAL (r) = 1;
598 /* Parse the version string and compute the ABI version number. */
602 const char *p = version_string;
603 unsigned int major = 0, minor = 0;
604 unsigned int abi_version;
606 /* Skip leading junk. */
607 while (*p && !ISDIGIT (*p))
611 /* Extract major version. */
614 major = major * 10 + *p - '0';
618 gcc_assert (*p == '.' && ISDIGIT (p[1]));
621 /* Extract minor version. */
624 minor = minor * 10 + *p - '0';
628 if (flag_indirect_dispatch)
630 abi_version = GCJ_CURRENT_BC_ABI_VERSION;
631 abi_version |= FLAG_BINARYCOMPAT_ABI;
635 /* Implicit in this computation is the idea that we won't break the
636 old-style binary ABI in a sub-minor release (e.g., from 4.0.0 to
638 abi_version = 100000 * major + 1000 * minor;
640 if (flag_bootstrap_classes)
641 abi_version |= FLAG_BOOTSTRAP_LOADER;
643 gcj_abi_version = build_int_cstu (ptr_type_node, abi_version);
647 java_init_decl_processing (void)
650 tree field = NULL_TREE;
653 init_class_processing ();
655 current_function_decl = NULL;
656 current_binding_level = NULL_BINDING_LEVEL;
657 free_binding_level = NULL_BINDING_LEVEL;
658 pushlevel (0); /* make the binding_level structure for global names */
659 global_binding_level = current_binding_level;
661 /* The code here must be similar to build_common_tree_nodes{,_2} in
662 tree.c, especially as to the order of initializing common nodes. */
663 error_mark_node = make_node (ERROR_MARK);
664 TREE_TYPE (error_mark_node) = error_mark_node;
666 /* Create sizetype first - needed for other types. */
667 initialize_sizetypes (false);
669 byte_type_node = make_signed_type (8);
670 pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"), byte_type_node));
671 short_type_node = make_signed_type (16);
672 pushdecl (build_decl (TYPE_DECL, get_identifier ("short"), short_type_node));
673 int_type_node = make_signed_type (32);
674 pushdecl (build_decl (TYPE_DECL, get_identifier ("int"), int_type_node));
675 long_type_node = make_signed_type (64);
676 pushdecl (build_decl (TYPE_DECL, get_identifier ("long"), long_type_node));
678 unsigned_byte_type_node = make_unsigned_type (8);
679 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned byte"),
680 unsigned_byte_type_node));
681 unsigned_short_type_node = make_unsigned_type (16);
682 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned short"),
683 unsigned_short_type_node));
684 unsigned_int_type_node = make_unsigned_type (32);
685 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
686 unsigned_int_type_node));
687 unsigned_long_type_node = make_unsigned_type (64);
688 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned long"),
689 unsigned_long_type_node));
691 /* This is not a java type, however tree-dfa requires a definition for
693 size_type_node = make_unsigned_type (POINTER_SIZE);
694 set_sizetype (size_type_node);
696 /* Define these next since types below may used them. */
697 integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0);
698 integer_zero_node = build_int_cst (NULL_TREE, 0);
699 integer_one_node = build_int_cst (NULL_TREE, 1);
700 integer_two_node = build_int_cst (NULL_TREE, 2);
701 integer_four_node = build_int_cst (NULL_TREE, 4);
702 integer_minus_one_node = build_int_cst (NULL_TREE, -1);
704 /* A few values used for range checking in the lexer. */
705 decimal_int_max = build_int_cstu (unsigned_int_type_node, 0x80000000);
706 #if HOST_BITS_PER_WIDE_INT == 64
707 decimal_long_max = build_int_cstu (unsigned_long_type_node,
708 0x8000000000000000LL);
709 #elif HOST_BITS_PER_WIDE_INT == 32
710 decimal_long_max = build_int_cst_wide (unsigned_long_type_node,
713 #error "unsupported size"
716 size_zero_node = size_int (0);
717 size_one_node = size_int (1);
718 bitsize_zero_node = bitsize_int (0);
719 bitsize_one_node = bitsize_int (1);
720 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
722 long_zero_node = build_int_cst (long_type_node, 0);
724 void_type_node = make_node (VOID_TYPE);
725 pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
726 layout_type (void_type_node); /* Uses size_zero_node */
728 ptr_type_node = build_pointer_type (void_type_node);
730 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
732 t = make_node (VOID_TYPE);
733 layout_type (t); /* Uses size_zero_node */
734 return_address_type_node = build_pointer_type (t);
736 null_pointer_node = build_int_cst (ptr_type_node, 0);
739 /* Make a type to be the domain of a few array types
740 whose domains don't really matter.
741 200 is small enough that it always fits in size_t
742 and large enough that it can hold most function names for the
743 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
744 short_array_type_node = build_prim_array_type (short_type_node, 200);
746 char_type_node = make_node (CHAR_TYPE);
747 TYPE_PRECISION (char_type_node) = 16;
748 fixup_unsigned_type (char_type_node);
749 pushdecl (build_decl (TYPE_DECL, get_identifier ("char"), char_type_node));
751 boolean_type_node = make_node (BOOLEAN_TYPE);
752 TYPE_PRECISION (boolean_type_node) = 1;
753 fixup_unsigned_type (boolean_type_node);
754 pushdecl (build_decl (TYPE_DECL, get_identifier ("boolean"),
756 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
757 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
759 promoted_byte_type_node
760 = push_promoted_type ("promoted_byte", byte_type_node);
761 promoted_short_type_node
762 = push_promoted_type ("promoted_short", short_type_node);
763 promoted_char_type_node
764 = push_promoted_type ("promoted_char", char_type_node);
765 promoted_boolean_type_node
766 = push_promoted_type ("promoted_boolean", boolean_type_node);
768 float_type_node = make_node (REAL_TYPE);
769 TYPE_PRECISION (float_type_node) = 32;
770 pushdecl (build_decl (TYPE_DECL, get_identifier ("float"),
772 layout_type (float_type_node);
774 double_type_node = make_node (REAL_TYPE);
775 TYPE_PRECISION (double_type_node) = 64;
776 pushdecl (build_decl (TYPE_DECL, get_identifier ("double"),
778 layout_type (double_type_node);
780 float_zero_node = build_real (float_type_node, dconst0);
781 double_zero_node = build_real (double_type_node, dconst0);
783 /* These are the vtables for arrays of primitives. */
784 boolean_array_vtable = create_primitive_vtable ("boolean");
785 byte_array_vtable = create_primitive_vtable ("byte");
786 char_array_vtable = create_primitive_vtable ("char");
787 short_array_vtable = create_primitive_vtable ("short");
788 int_array_vtable = create_primitive_vtable ("int");
789 long_array_vtable = create_primitive_vtable ("long");
790 float_array_vtable = create_primitive_vtable ("float");
791 double_array_vtable = create_primitive_vtable ("double");
793 one_elt_array_domain_type = build_index_type (integer_one_node);
794 utf8const_type = make_node (RECORD_TYPE);
795 PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
796 PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
797 FINISH_RECORD (utf8const_type);
798 utf8const_ptr_type = build_pointer_type (utf8const_type);
800 atable_type = build_array_type (ptr_type_node,
801 one_elt_array_domain_type);
802 TYPE_NONALIASED_COMPONENT (atable_type) = 1;
803 atable_ptr_type = build_pointer_type (atable_type);
805 itable_type = build_array_type (ptr_type_node,
806 one_elt_array_domain_type);
807 TYPE_NONALIASED_COMPONENT (itable_type) = 1;
808 itable_ptr_type = build_pointer_type (itable_type);
810 symbol_type = make_node (RECORD_TYPE);
811 PUSH_FIELD (symbol_type, field, "clname", utf8const_ptr_type);
812 PUSH_FIELD (symbol_type, field, "name", utf8const_ptr_type);
813 PUSH_FIELD (symbol_type, field, "signature", utf8const_ptr_type);
814 FINISH_RECORD (symbol_type);
816 symbols_array_type = build_array_type (symbol_type,
817 one_elt_array_domain_type);
818 symbols_array_ptr_type = build_pointer_type (symbols_array_type);
820 assertion_entry_type = make_node (RECORD_TYPE);
821 PUSH_FIELD (assertion_entry_type, field, "assertion_code", integer_type_node);
822 PUSH_FIELD (assertion_entry_type, field, "op1", utf8const_ptr_type);
823 PUSH_FIELD (assertion_entry_type, field, "op2", utf8const_ptr_type);
824 FINISH_RECORD (assertion_entry_type);
826 assertion_table_type = build_array_type (assertion_entry_type,
827 one_elt_array_domain_type);
829 /* As you're adding items here, please update the code right after
830 this section, so that the filename containing the source code of
831 the pre-defined class gets registered correctly. */
832 unqualified_object_id_node = get_identifier ("Object");
833 object_type_node = lookup_class (get_identifier ("java.lang.Object"));
834 object_ptr_type_node = promote_type (object_type_node);
835 string_type_node = lookup_class (get_identifier ("java.lang.String"));
836 string_ptr_type_node = promote_type (string_type_node);
837 class_type_node = lookup_class (get_identifier ("java.lang.Class"));
838 throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
839 exception_type_node = lookup_class (get_identifier ("java.lang.Exception"));
840 runtime_exception_type_node =
841 lookup_class (get_identifier ("java.lang.RuntimeException"));
842 error_exception_type_node =
843 lookup_class (get_identifier ("java.lang.Error"));
845 rawdata_ptr_type_node
846 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
848 add_predefined_file (get_identifier ("java/lang/Class.java"));
849 add_predefined_file (get_identifier ("java/lang/Error.java"));
850 add_predefined_file (get_identifier ("java/lang/Object.java"));
851 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
852 add_predefined_file (get_identifier ("java/lang/String.java"));
853 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
854 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
855 add_predefined_file (get_identifier ("java/lang/Exception.java"));
856 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
857 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
859 methodtable_type = make_node (RECORD_TYPE);
860 layout_type (methodtable_type);
861 build_decl (TYPE_DECL, get_identifier ("methodtable"), methodtable_type);
862 methodtable_ptr_type = build_pointer_type (methodtable_type);
864 TYPE_identifier_node = get_identifier ("TYPE");
865 init_identifier_node = get_identifier ("<init>");
866 clinit_identifier_node = get_identifier ("<clinit>");
867 finit_identifier_node = get_identifier ("finit$");
868 instinit_identifier_node = get_identifier ("instinit$");
869 void_signature_node = get_identifier ("()V");
870 length_identifier_node = get_identifier ("length");
871 finalize_identifier_node = get_identifier ("finalize");
872 this_identifier_node = get_identifier ("this");
873 super_identifier_node = get_identifier ("super");
874 continue_identifier_node = get_identifier ("continue");
875 access0_identifier_node = get_identifier ("access$0");
876 classdollar_identifier_node = get_identifier ("class$");
878 java_lang_cloneable_identifier_node = get_identifier ("java.lang.Cloneable");
879 java_io_serializable_identifier_node =
880 get_identifier ("java.io.Serializable");
882 /* for lack of a better place to put this stub call */
883 init_expr_processing();
885 constants_type_node = make_node (RECORD_TYPE);
886 PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node);
887 PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
888 PUSH_FIELD (constants_type_node, field, "data", ptr_type_node);
889 FINISH_RECORD (constants_type_node);
890 build_decl (TYPE_DECL, get_identifier ("constants"), constants_type_node);
892 access_flags_type_node = unsigned_short_type_node;
894 dtable_type = make_node (RECORD_TYPE);
895 dtable_ptr_type = build_pointer_type (dtable_type);
897 otable_type = build_array_type (integer_type_node,
898 one_elt_array_domain_type);
899 TYPE_NONALIASED_COMPONENT (otable_type) = 1;
900 otable_ptr_type = build_pointer_type (otable_type);
902 PUSH_FIELD (object_type_node, field, "vtable", dtable_ptr_type);
903 DECL_FCONTEXT (field) = object_type_node;
904 TYPE_VFIELD (object_type_node) = field;
906 /* This isn't exactly true, but it is what we have in the source.
907 There is an unresolved issue here, which is whether the vtable
908 should be marked by the GC. */
909 if (! flag_hash_synchronization)
910 PUSH_FIELD (object_type_node, field, "sync_info",
911 build_pointer_type (object_type_node));
912 for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
913 FIELD_PRIVATE (t) = 1;
914 FINISH_RECORD (object_type_node);
916 field_type_node = make_node (RECORD_TYPE);
917 field_ptr_type_node = build_pointer_type (field_type_node);
918 method_type_node = make_node (RECORD_TYPE);
919 method_ptr_type_node = build_pointer_type (method_type_node);
921 set_super_info (0, class_type_node, object_type_node, 0);
922 set_super_info (0, string_type_node, object_type_node, 0);
923 class_ptr_type = build_pointer_type (class_type_node);
925 PUSH_FIELD (class_type_node, field, "next_or_version", class_ptr_type);
926 PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type);
927 PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node);
928 PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type);
929 PUSH_FIELD (class_type_node, field, "constants", constants_type_node);
930 PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node);
931 PUSH_FIELD (class_type_node, field, "method_count", short_type_node);
932 PUSH_FIELD (class_type_node, field, "vtable_method_count", short_type_node);
933 PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node);
934 PUSH_FIELD (class_type_node, field, "size_in_bytes", int_type_node);
935 PUSH_FIELD (class_type_node, field, "field_count", short_type_node);
936 PUSH_FIELD (class_type_node, field, "static_field_count", short_type_node);
937 PUSH_FIELD (class_type_node, field, "vtable", dtable_ptr_type);
938 PUSH_FIELD (class_type_node, field, "otable", otable_ptr_type);
939 PUSH_FIELD (class_type_node, field, "otable_syms",
940 symbols_array_ptr_type);
941 PUSH_FIELD (class_type_node, field, "atable", atable_ptr_type);
942 PUSH_FIELD (class_type_node, field, "atable_syms",
943 symbols_array_ptr_type);
944 PUSH_FIELD (class_type_node, field, "itable", itable_ptr_type);
945 PUSH_FIELD (class_type_node, field, "itable_syms",
946 symbols_array_ptr_type);
947 PUSH_FIELD (class_type_node, field, "catch_classes", ptr_type_node);
948 PUSH_FIELD (class_type_node, field, "interfaces",
949 build_pointer_type (class_ptr_type));
950 PUSH_FIELD (class_type_node, field, "loader", ptr_type_node);
951 PUSH_FIELD (class_type_node, field, "interface_count", short_type_node);
952 PUSH_FIELD (class_type_node, field, "state", byte_type_node);
953 PUSH_FIELD (class_type_node, field, "thread", ptr_type_node);
954 PUSH_FIELD (class_type_node, field, "depth", short_type_node);
955 PUSH_FIELD (class_type_node, field, "ancestors", ptr_type_node);
956 PUSH_FIELD (class_type_node, field, "idt", ptr_type_node);
957 PUSH_FIELD (class_type_node, field, "arrayclass", ptr_type_node);
958 PUSH_FIELD (class_type_node, field, "protectionDomain", ptr_type_node);
959 PUSH_FIELD (class_type_node, field, "assertion_table", ptr_type_node);
960 PUSH_FIELD (class_type_node, field, "hack_signers", ptr_type_node);
961 PUSH_FIELD (class_type_node, field, "chain", ptr_type_node);
962 PUSH_FIELD (class_type_node, field, "aux_info", ptr_type_node);
963 PUSH_FIELD (class_type_node, field, "engine", ptr_type_node);
964 for (t = TYPE_FIELDS (class_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
965 FIELD_PRIVATE (t) = 1;
966 push_super_field (class_type_node, object_type_node);
968 FINISH_RECORD (class_type_node);
969 build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node);
971 field_info_union_node = make_node (UNION_TYPE);
972 PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node);
973 PUSH_FIELD (field_info_union_node, field, "addr", ptr_type_node);
975 PUSH_FIELD (field_info_union_node, field, "idx", unsigned_short_type_node);
977 layout_type (field_info_union_node);
979 PUSH_FIELD (field_type_node, field, "name", utf8const_ptr_type);
980 PUSH_FIELD (field_type_node, field, "type", class_ptr_type);
981 PUSH_FIELD (field_type_node, field, "accflags", access_flags_type_node);
982 PUSH_FIELD (field_type_node, field, "bsize", unsigned_short_type_node);
983 PUSH_FIELD (field_type_node, field, "info", field_info_union_node);
984 FINISH_RECORD (field_type_node);
985 build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node);
987 nativecode_ptr_array_type_node
988 = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
990 PUSH_FIELD (dtable_type, field, "class", class_ptr_type);
991 PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node);
992 FINISH_RECORD (dtable_type);
993 build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
995 jexception_type = make_node (RECORD_TYPE);
996 PUSH_FIELD (jexception_type, field, "start_pc", ptr_type_node);
997 PUSH_FIELD (jexception_type, field, "end_pc", ptr_type_node);
998 PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node);
999 PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type);
1000 FINISH_RECORD (jexception_type);
1001 build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node);
1002 jexception_ptr_type = build_pointer_type (jexception_type);
1004 lineNumberEntry_type = make_node (RECORD_TYPE);
1005 PUSH_FIELD (lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
1006 PUSH_FIELD (lineNumberEntry_type, field, "start_pc", ptr_type_node);
1007 FINISH_RECORD (lineNumberEntry_type);
1009 lineNumbers_type = make_node (RECORD_TYPE);
1010 PUSH_FIELD (lineNumbers_type, field, "length", unsigned_int_type_node);
1011 FINISH_RECORD (lineNumbers_type);
1013 PUSH_FIELD (method_type_node, field, "name", utf8const_ptr_type);
1014 PUSH_FIELD (method_type_node, field, "signature", utf8const_ptr_type);
1015 PUSH_FIELD (method_type_node, field, "accflags", access_flags_type_node);
1016 PUSH_FIELD (method_type_node, field, "index", unsigned_short_type_node);
1017 PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node);
1018 PUSH_FIELD (method_type_node, field, "throws", ptr_type_node);
1019 FINISH_RECORD (method_type_node);
1020 build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node);
1022 endlink = end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
1024 t = tree_cons (NULL_TREE, class_ptr_type, endlink);
1025 alloc_object_node = builtin_function ("_Jv_AllocObject",
1026 build_function_type (ptr_type_node, t),
1027 0, NOT_BUILT_IN, NULL, NULL_TREE);
1028 DECL_IS_MALLOC (alloc_object_node) = 1;
1029 alloc_no_finalizer_node =
1030 builtin_function ("_Jv_AllocObjectNoFinalizer",
1031 build_function_type (ptr_type_node, t),
1032 0, NOT_BUILT_IN, NULL, NULL_TREE);
1033 DECL_IS_MALLOC (alloc_no_finalizer_node) = 1;
1035 t = tree_cons (NULL_TREE, ptr_type_node, endlink);
1036 soft_initclass_node = builtin_function ("_Jv_InitClass",
1037 build_function_type (void_type_node,
1039 0, NOT_BUILT_IN, NULL, NULL_TREE);
1040 t = tree_cons (NULL_TREE, class_ptr_type,
1041 tree_cons (NULL_TREE, int_type_node, endlink));
1042 soft_resolvepoolentry_node
1043 = builtin_function ("_Jv_ResolvePoolEntry",
1044 build_function_type (ptr_type_node, t),
1045 0,NOT_BUILT_IN, NULL, NULL_TREE);
1046 DECL_IS_PURE (soft_resolvepoolentry_node) = 1;
1047 throw_node = builtin_function ("_Jv_Throw",
1048 build_function_type (void_type_node, t),
1049 0, NOT_BUILT_IN, NULL, NULL_TREE);
1050 /* Mark throw_nodes as `noreturn' functions with side effects. */
1051 TREE_THIS_VOLATILE (throw_node) = 1;
1052 TREE_SIDE_EFFECTS (throw_node) = 1;
1054 t = build_function_type (void_type_node, tree_cons (NULL_TREE, ptr_type_node,
1056 soft_monitorenter_node
1057 = builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN,
1059 soft_monitorexit_node
1060 = builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN,
1063 t = tree_cons (NULL_TREE, ptr_type_node,
1064 tree_cons (NULL_TREE, int_type_node, endlink));
1066 = builtin_function ("_Jv_NewPrimArray",
1067 build_function_type (ptr_type_node, t),
1068 0, NOT_BUILT_IN, NULL, NULL_TREE);
1069 DECL_IS_MALLOC (soft_newarray_node) = 1;
1071 t = tree_cons (NULL_TREE, int_type_node,
1072 tree_cons (NULL_TREE, class_ptr_type,
1073 tree_cons (NULL_TREE, object_ptr_type_node,
1076 = builtin_function ("_Jv_NewObjectArray",
1077 build_function_type (ptr_type_node, t),
1078 0, NOT_BUILT_IN, NULL, NULL_TREE);
1079 DECL_IS_MALLOC (soft_anewarray_node) = 1;
1081 /* There is no endlink here because _Jv_NewMultiArray is a varargs
1083 t = tree_cons (NULL_TREE, ptr_type_node,
1084 tree_cons (NULL_TREE, int_type_node, NULL_TREE));
1085 soft_multianewarray_node
1086 = builtin_function ("_Jv_NewMultiArray",
1087 build_function_type (ptr_type_node, t),
1088 0, NOT_BUILT_IN, NULL, NULL_TREE);
1089 DECL_IS_MALLOC (soft_multianewarray_node) = 1;
1091 t = build_function_type (void_type_node,
1092 tree_cons (NULL_TREE, int_type_node, endlink));
1093 soft_badarrayindex_node
1094 = builtin_function ("_Jv_ThrowBadArrayIndex", t,
1095 0, NOT_BUILT_IN, NULL, NULL_TREE);
1096 /* Mark soft_badarrayindex_node as a `noreturn' function with side
1098 TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
1099 TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
1101 soft_nullpointer_node
1102 = builtin_function ("_Jv_ThrowNullPointerException",
1103 build_function_type (void_type_node, endlink),
1104 0, NOT_BUILT_IN, NULL, NULL_TREE);
1105 /* Mark soft_nullpointer_node as a `noreturn' function with side
1107 TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
1108 TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
1110 soft_abstractmethod_node
1111 = builtin_function ("_Jv_ThrowAbstractMethodError",
1112 build_function_type (void_type_node, endlink),
1113 0, NOT_BUILT_IN, NULL, NULL_TREE);
1114 /* Mark soft_abstractmethod_node as a `noreturn' function with side
1116 TREE_THIS_VOLATILE (soft_abstractmethod_node) = 1;
1117 TREE_SIDE_EFFECTS (soft_abstractmethod_node) = 1;
1119 t = tree_cons (NULL_TREE, class_ptr_type,
1120 tree_cons (NULL_TREE, object_ptr_type_node, endlink));
1122 = builtin_function ("_Jv_CheckCast",
1123 build_function_type (ptr_type_node, t),
1124 0, NOT_BUILT_IN, NULL, NULL_TREE);
1125 t = tree_cons (NULL_TREE, object_ptr_type_node,
1126 tree_cons (NULL_TREE, class_ptr_type, endlink));
1127 soft_instanceof_node
1128 = builtin_function ("_Jv_IsInstanceOf",
1129 build_function_type (boolean_type_node, t),
1130 0, NOT_BUILT_IN, NULL, NULL_TREE);
1131 DECL_IS_PURE (soft_instanceof_node) = 1;
1132 t = tree_cons (NULL_TREE, object_ptr_type_node,
1133 tree_cons (NULL_TREE, object_ptr_type_node, endlink));
1134 soft_checkarraystore_node
1135 = builtin_function ("_Jv_CheckArrayStore",
1136 build_function_type (void_type_node, t),
1137 0, NOT_BUILT_IN, NULL, NULL_TREE);
1138 t = tree_cons (NULL_TREE, ptr_type_node,
1139 tree_cons (NULL_TREE, ptr_type_node,
1140 tree_cons (NULL_TREE, int_type_node, endlink)));
1141 soft_lookupinterfacemethod_node
1142 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
1143 build_function_type (ptr_type_node, t),
1144 0, NOT_BUILT_IN, NULL, NULL_TREE);
1145 DECL_IS_PURE (soft_lookupinterfacemethod_node) = 1;
1146 t = tree_cons (NULL_TREE, ptr_type_node,
1147 tree_cons (NULL_TREE, ptr_type_node,
1148 tree_cons (NULL_TREE, ptr_type_node, endlink)));
1149 soft_lookupinterfacemethodbyname_node
1150 = builtin_function ("_Jv_LookupInterfaceMethod",
1151 build_function_type (ptr_type_node, t),
1152 0, NOT_BUILT_IN, NULL, NULL_TREE);
1153 t = tree_cons (NULL_TREE, object_ptr_type_node,
1154 tree_cons (NULL_TREE, ptr_type_node,
1155 tree_cons (NULL_TREE, ptr_type_node,
1156 tree_cons (NULL_TREE, int_type_node,
1158 soft_lookupjnimethod_node
1159 = builtin_function ("_Jv_LookupJNIMethod",
1160 build_function_type (ptr_type_node, t),
1161 0, NOT_BUILT_IN, NULL, NULL_TREE);
1162 t = tree_cons (NULL_TREE, ptr_type_node, endlink);
1163 soft_getjnienvnewframe_node
1164 = builtin_function ("_Jv_GetJNIEnvNewFrame",
1165 build_function_type (ptr_type_node, t),
1166 0, NOT_BUILT_IN, NULL, NULL_TREE);
1167 soft_jnipopsystemframe_node
1168 = builtin_function ("_Jv_JNI_PopSystemFrame",
1169 build_function_type (void_type_node, t),
1170 0, NOT_BUILT_IN, NULL, NULL_TREE);
1172 t = tree_cons (NULL_TREE, object_ptr_type_node, endlink);
1174 = builtin_function ("_Jv_UnwrapJNIweakReference",
1175 build_function_type (object_ptr_type_node, t),
1176 0, NOT_BUILT_IN, NULL, NULL_TREE);
1178 t = tree_cons (NULL_TREE, int_type_node,
1179 tree_cons (NULL_TREE, int_type_node, endlink));
1181 = builtin_function ("_Jv_divI",
1182 build_function_type (int_type_node, t),
1183 0, NOT_BUILT_IN, NULL, NULL_TREE);
1186 = builtin_function ("_Jv_remI",
1187 build_function_type (int_type_node, t),
1188 0, NOT_BUILT_IN, NULL, NULL_TREE);
1190 t = tree_cons (NULL_TREE, long_type_node,
1191 tree_cons (NULL_TREE, long_type_node, endlink));
1193 = builtin_function ("_Jv_divJ",
1194 build_function_type (long_type_node, t),
1195 0, NOT_BUILT_IN, NULL, NULL_TREE);
1198 = builtin_function ("_Jv_remJ",
1199 build_function_type (long_type_node, t),
1200 0, NOT_BUILT_IN, NULL, NULL_TREE);
1202 /* Initialize variables for except.c. */
1203 eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
1204 ? "__gcj_personality_sj0"
1205 : "__gcj_personality_v0");
1206 default_init_unwind_resume_libfunc ();
1208 lang_eh_runtime_type = do_nothing;
1212 initialize_builtins ();
1213 soft_fmod_node = built_in_decls[BUILT_IN_FMOD];
1215 soft_fmodf_node = built_in_decls[BUILT_IN_FMODF];
1222 /* Look up NAME in the current binding level and its superiors
1223 in the namespace of variables, functions and typedefs.
1224 Return a ..._DECL node of some kind representing its definition,
1225 or return 0 if it is undefined. */
1228 lookup_name (tree name)
1231 if (current_binding_level != global_binding_level
1232 && IDENTIFIER_LOCAL_VALUE (name))
1233 val = IDENTIFIER_LOCAL_VALUE (name);
1235 val = IDENTIFIER_GLOBAL_VALUE (name);
1239 /* Similar to `lookup_name' but look only at current binding level and
1240 the previous one if it's the parameter level. */
1243 lookup_name_current_level (tree name)
1247 if (current_binding_level == global_binding_level)
1248 return IDENTIFIER_GLOBAL_VALUE (name);
1250 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
1253 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
1254 if (DECL_NAME (t) == name)
1260 /* Use a binding level to record a labeled block declaration */
1263 push_labeled_block (tree lb)
1265 tree name = DECL_NAME (LABELED_BLOCK_LABEL (lb));
1266 struct binding_level *b = current_binding_level;
1267 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1269 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1270 TREE_CHAIN (lb) = b->names;
1272 IDENTIFIER_LOCAL_VALUE (name) = lb;
1275 /* Pop the current binding level, reinstalling values for the previous
1279 pop_labeled_block (void)
1281 struct binding_level *b = current_binding_level;
1282 tree label = b->names;
1283 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label))) =
1286 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b->shadowed)) =
1287 TREE_VALUE (b->shadowed);
1289 /* Pop the current level, and free the structure for reuse. */
1290 current_binding_level = current_binding_level->level_chain;
1291 b->level_chain = free_binding_level;
1292 free_binding_level = b;
1295 /* Record a decl-node X as belonging to the current lexical scope.
1296 Check for errors (such as an incompatible declaration for the same
1297 name already seen in the same scope).
1299 Returns either X or an old decl for the same name.
1300 If an old decl is returned, it may have been smashed
1301 to agree with what X says. */
1307 tree name = DECL_NAME (x);
1308 struct binding_level *b = current_binding_level;
1310 if (TREE_CODE (x) != TYPE_DECL)
1311 DECL_CONTEXT (x) = current_function_decl;
1314 t = lookup_name_current_level (name);
1315 if (t != 0 && t == error_mark_node)
1316 /* error_mark_node is 0 for a while during initialization! */
1319 error ("%q+D used prior to declaration", x);
1322 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1323 to point to the TYPE_DECL.
1324 Since Java does not have typedefs, a type can only have
1325 one (true) name, given by a class, interface, or builtin. */
1326 if (TREE_CODE (x) == TYPE_DECL
1327 && TYPE_NAME (TREE_TYPE (x)) == 0
1328 && TREE_TYPE (x) != error_mark_node)
1330 TYPE_NAME (TREE_TYPE (x)) = x;
1331 TYPE_STUB_DECL (TREE_TYPE (x)) = x;
1334 /* This name is new in its binding level.
1335 Install the new declaration and return it. */
1336 if (b == global_binding_level)
1338 /* Install a global value. */
1340 IDENTIFIER_GLOBAL_VALUE (name) = x;
1344 /* Here to install a non-global value. */
1345 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1346 IDENTIFIER_LOCAL_VALUE (name) = x;
1349 /* Warn if shadowing an argument at the top level of the body. */
1350 if (oldlocal != 0 && !DECL_EXTERNAL (x)
1351 /* This warning doesn't apply to the parms of a nested fcn. */
1352 && ! current_binding_level->parm_flag
1353 /* Check that this is one level down from the parms. */
1354 && current_binding_level->level_chain->parm_flag
1355 /* Check that the decl being shadowed
1356 comes from the parm level, one level up. */
1357 && chain_member (oldlocal, current_binding_level->level_chain->names))
1359 if (TREE_CODE (oldlocal) == PARM_DECL)
1360 pedwarn ("declaration of %qs shadows a parameter",
1361 IDENTIFIER_POINTER (name));
1363 pedwarn ("declaration of %qs shadows a symbol from the parameter list",
1364 IDENTIFIER_POINTER (name));
1367 /* Maybe warn if shadowing something else. */
1368 else if (warn_shadow && !DECL_EXTERNAL (x)
1369 /* No shadow warnings for internally generated vars. */
1370 && DECL_SOURCE_LINE (x) != 0
1371 /* No shadow warnings for vars made for inlining. */
1372 && ! DECL_FROM_INLINE (x))
1374 const char *warnstring = 0;
1376 if (TREE_CODE (x) == PARM_DECL
1377 && current_binding_level->level_chain->parm_flag)
1378 /* Don't warn about the parm names in function declarator
1379 within a function declarator.
1380 It would be nice to avoid warning in any function
1381 declarator in a declaration, as opposed to a definition,
1382 but there is no way to tell it's not a definition. */
1384 else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
1385 warnstring = "declaration of %qs shadows a parameter";
1386 else if (oldlocal != 0)
1387 warnstring = "declaration of %qs shadows previous local";
1388 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
1389 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
1390 warnstring = "declaration of %qs shadows global declaration";
1393 warning (0, warnstring, IDENTIFIER_POINTER (name));
1397 /* If storing a local value, there may already be one (inherited).
1398 If so, record it for restoration when this binding level ends. */
1400 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1404 /* Put decls on list in reverse order.
1405 We will reverse them later if necessary. */
1406 TREE_CHAIN (x) = b->names;
1413 pushdecl_force_head (tree x)
1415 current_binding_level->names = x;
1418 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1421 pushdecl_top_level (tree x)
1424 struct binding_level *b = current_binding_level;
1426 current_binding_level = global_binding_level;
1428 current_binding_level = b;
1432 /* Like pushdecl, only it places X in FUNCTION_BINDING_LEVEL, if appropriate. */
1435 pushdecl_function_level (tree x)
1438 struct binding_level *b = current_binding_level;
1440 current_binding_level = function_binding_level;
1442 current_binding_level = b;
1446 /* Nonzero if we are currently in the global binding level. */
1449 global_bindings_p (void)
1451 return current_binding_level == global_binding_level;
1454 /* Return the list of declarations of the current level.
1455 Note that this list is in reverse order unless/until
1456 you nreverse it; and when you do nreverse it, you must
1457 store the result back using `storedecls' or you will lose. */
1462 return current_binding_level->names;
1465 /* Create a new `struct binding_level'. */
1467 static struct binding_level *
1468 make_binding_level (void)
1471 return ggc_alloc_cleared (sizeof (struct binding_level));
1475 pushlevel (int unused ATTRIBUTE_UNUSED)
1477 struct binding_level *newlevel = NULL_BINDING_LEVEL;
1480 /* If this is the top level of a function,
1481 just make sure that NAMED_LABELS is 0. */
1483 if (current_binding_level == global_binding_level)
1487 /* Reuse or create a struct for this binding level. */
1489 if (free_binding_level)
1491 newlevel = free_binding_level;
1492 free_binding_level = free_binding_level->level_chain;
1496 newlevel = make_binding_level ();
1499 /* Add this level to the front of the chain (stack) of levels that
1502 *newlevel = clear_binding_level;
1503 newlevel->level_chain = current_binding_level;
1504 current_binding_level = newlevel;
1505 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1506 newlevel->binding_depth = binding_depth;
1508 fprintf (stderr, "push %s level %p pc %d\n",
1509 (is_class_level) ? "class" : "block", newlevel, current_pc);
1512 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1515 /* Exit a binding level.
1516 Pop the level off, and restore the state of the identifier-decl mappings
1517 that were in effect when this level was entered.
1519 If KEEP is nonzero, this level had explicit declarations, so
1520 and create a "block" (a BLOCK node) for the level
1521 to record its declarations and subblocks for symbol table output.
1523 If FUNCTIONBODY is nonzero, this level is the body of a function,
1524 so create a block as if KEEP were set and also clear out all
1527 If REVERSE is nonzero, reverse the order of decls before putting
1528 them into the BLOCK. */
1531 poplevel (int keep, int reverse, int functionbody)
1534 /* The chain of decls was accumulated in reverse order.
1535 Put it into forward order, just for cleanliness. */
1537 tree subblocks = current_binding_level->blocks;
1542 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1545 if (current_binding_level->end_pc != LARGEST_PC)
1546 fprintf (stderr, "pop %s level %p pc %d (end pc %d)\n",
1547 (is_class_level) ? "class" : "block", current_binding_level, current_pc,
1548 current_binding_level->end_pc);
1550 fprintf (stderr, "pop %s level %p pc %d\n",
1551 (is_class_level) ? "class" : "block", current_binding_level, current_pc);
1553 if (is_class_level != (current_binding_level == class_binding_level))
1556 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1560 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1562 /* Get the decls in the order they were written.
1563 Usually current_binding_level->names is in reverse order.
1564 But parameter decls were previously put in forward order. */
1567 current_binding_level->names
1568 = decls = nreverse (current_binding_level->names);
1570 decls = current_binding_level->names;
1572 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1573 if (TREE_CODE (decl) == VAR_DECL
1574 && DECL_LANG_SPECIFIC (decl) != NULL
1575 && DECL_LOCAL_SLOT_NUMBER (decl))
1576 LOCAL_VAR_OUT_OF_SCOPE_P (decl) = 1;
1578 /* If there were any declarations in that level,
1579 or if this level is a function body,
1580 create a BLOCK to record them for the life of this function. */
1583 if (keep || functionbody)
1585 block = make_node (BLOCK);
1586 TREE_TYPE (block) = void_type_node;
1589 if (current_binding_level->exception_range)
1590 expand_end_java_handler (current_binding_level->exception_range);
1594 /* If any statements have been generated at this level, create a
1595 BIND_EXPR to hold them and copy the variables to it. This
1596 only applies to the bytecode compiler. */
1597 if (current_binding_level->stmts)
1600 tree *var = &BLOCK_VARS (block);
1602 /* Copy decls from names list, ignoring labels. */
1605 tree next = TREE_CHAIN (decl);
1606 if (TREE_CODE (decl) != LABEL_DECL)
1609 var = &TREE_CHAIN (decl);
1615 bind = build3 (BIND_EXPR, TREE_TYPE (block), BLOCK_VARS (block),
1616 BLOCK_EXPR_BODY (block), block);
1617 BIND_EXPR_BODY (bind) = current_binding_level->stmts;
1619 if (BIND_EXPR_BODY (bind)
1620 && TREE_SIDE_EFFECTS (BIND_EXPR_BODY (bind)))
1621 TREE_SIDE_EFFECTS (bind) = 1;
1623 /* FIXME: gimplifier brain damage. */
1624 if (BIND_EXPR_BODY (bind) == NULL)
1625 BIND_EXPR_BODY (bind) = build_java_empty_stmt ();
1627 current_binding_level->stmts = NULL;
1631 BLOCK_VARS (block) = decls;
1633 BLOCK_SUBBLOCKS (block) = subblocks;
1636 /* In each subblock, record that this is its superior. */
1638 for (link = subblocks; link; link = TREE_CHAIN (link))
1639 BLOCK_SUPERCONTEXT (link) = block;
1641 /* Clear out the meanings of the local variables of this level. */
1643 for (link = decls; link; link = TREE_CHAIN (link))
1645 tree name = DECL_NAME (link);
1646 if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
1648 /* If the ident. was used or addressed via a local extern decl,
1649 don't forget that fact. */
1650 if (DECL_EXTERNAL (link))
1652 if (TREE_USED (link))
1653 TREE_USED (name) = 1;
1654 if (TREE_ADDRESSABLE (link))
1655 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1657 IDENTIFIER_LOCAL_VALUE (name) = 0;
1661 /* Restore all name-meanings of the outer levels
1662 that were shadowed by this level. */
1664 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1665 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1667 /* If the level being exited is the top level of a function,
1668 check over all the labels, and clear out the current
1669 (function local) meanings of their names. */
1673 /* If this is the top level block of a function,
1674 the vars are the function's parameters.
1675 Don't leave them in the BLOCK because they are
1676 found in the FUNCTION_DECL instead. */
1678 BLOCK_VARS (block) = 0;
1680 /* Clear out the definitions of all label names,
1681 since their scopes end here,
1682 and add them to BLOCK_VARS. */
1685 for (link = named_labels; link; link = TREE_CHAIN (link))
1687 tree label = TREE_VALUE (link);
1689 if (DECL_INITIAL (label) == 0)
1691 error ("label %q+D used but not defined", label);
1692 /* Avoid crashing later. */
1693 define_label (input_location, DECL_NAME (label));
1695 else if (warn_unused[UNUSED_LABEL] && !TREE_USED (label))
1696 warning (0, "label %q+D defined but not used", label);
1697 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1699 /* Put the labels into the "variables" of the
1700 top-level block, so debugger can see them. */
1701 TREE_CHAIN (label) = BLOCK_VARS (block);
1702 BLOCK_VARS (block) = label;
1707 /* Pop the current level, and free the structure for reuse. */
1710 struct binding_level *level = current_binding_level;
1711 current_binding_level = current_binding_level->level_chain;
1713 level->level_chain = free_binding_level;
1714 free_binding_level = level;
1717 /* Dispose of the block that we just made inside some higher level. */
1720 DECL_INITIAL (current_function_decl) = block;
1721 DECL_SAVED_TREE (current_function_decl) = bind;
1727 current_binding_level->blocks
1728 = chainon (current_binding_level->blocks, block);
1730 /* If we did not make a block for the level just exited,
1731 any blocks made for inner levels
1732 (since they cannot be recorded as subblocks in that level)
1733 must be carried forward so they will later become subblocks
1734 of something else. */
1736 current_binding_level->blocks
1737 = chainon (current_binding_level->blocks, subblocks);
1740 java_add_stmt (bind);
1744 TREE_USED (block) = 1;
1749 maybe_pushlevels (int pc)
1751 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1755 while (pending_local_decls != NULL_TREE &&
1756 DECL_LOCAL_START_PC (pending_local_decls) <= pc)
1758 tree *ptr = &pending_local_decls;
1759 tree decl = *ptr, next;
1760 int end_pc = DECL_LOCAL_END_PC (decl);
1762 while (*ptr != NULL_TREE
1763 && DECL_LOCAL_START_PC (*ptr) <= pc
1764 && DECL_LOCAL_END_PC (*ptr) == end_pc)
1765 ptr = &TREE_CHAIN (*ptr);
1766 pending_local_decls = *ptr;
1769 /* Force non-nested range to be nested in current range by
1770 truncating variable lifetimes. */
1771 if (end_pc > current_binding_level->end_pc)
1773 end_pc = current_binding_level->end_pc;
1774 DECL_LOCAL_END_PC (decl) = end_pc;
1777 maybe_start_try (pc, end_pc);
1781 current_binding_level->end_pc = end_pc;
1782 current_binding_level->start_pc = pc;
1783 current_binding_level->names = NULL;
1784 for ( ; decl != NULL_TREE; decl = next)
1786 next = TREE_CHAIN (decl);
1787 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl);
1789 initialize_local_variable (decl, DECL_LOCAL_SLOT_NUMBER (decl));
1793 maybe_start_try (pc, 0);
1797 maybe_poplevels (int pc)
1799 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1803 /* FIXME: I'm pretty sure that this is wrong. Variable scopes are
1804 inclusive, so a variable is live if pc == end_pc. Here, we
1805 terminate a range if the current pc is equal to the end of the
1806 range, and this is *before* we have generated code for the
1807 instruction at end_pc. We're closing a binding level one
1808 instruction too early.*/
1809 while (current_binding_level->end_pc <= pc)
1813 /* Terminate any binding which began during the range beginning at
1814 start_pc. This tidies up improperly nested local variable ranges
1815 and exception handlers; a variable declared within an exception
1816 range is forcibly terminated when that exception ends. */
1819 force_poplevels (int start_pc)
1821 while (current_binding_level->start_pc > start_pc)
1823 if (pedantic && current_binding_level->start_pc > start_pc)
1824 warning (0, "In %+D: overlapped variable and exception ranges at %d",
1825 current_function_decl,
1826 current_binding_level->start_pc);
1831 /* Insert BLOCK at the end of the list of subblocks of the
1832 current binding level. This is used when a BIND_EXPR is expanded,
1833 to handle the BLOCK node inside the BIND_EXPR. */
1836 insert_block (tree block)
1838 TREE_USED (block) = 1;
1839 current_binding_level->blocks
1840 = chainon (current_binding_level->blocks, block);
1843 /* integrate_decl_tree calls this function. */
1846 java_dup_lang_specific_decl (tree node)
1849 struct lang_decl *x;
1851 if (!DECL_LANG_SPECIFIC (node))
1854 lang_decl_size = sizeof (struct lang_decl);
1855 x = ggc_alloc (lang_decl_size);
1856 memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
1857 DECL_LANG_SPECIFIC (node) = x;
1861 give_name_to_locals (JCF *jcf)
1863 int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
1864 int code_offset = DECL_CODE_OFFSET (current_function_decl);
1866 pending_local_decls = NULL_TREE;
1870 n = JCF_readu2 (jcf);
1871 for (i = 0; i < n; i++)
1873 int start_pc = JCF_readu2 (jcf);
1874 int length = JCF_readu2 (jcf);
1875 int name_index = JCF_readu2 (jcf);
1876 int signature_index = JCF_readu2 (jcf);
1877 int slot = JCF_readu2 (jcf);
1878 tree name = get_name_constant (jcf, name_index);
1879 tree type = parse_signature (jcf, signature_index);
1880 if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
1882 && length == DECL_CODE_LENGTH (current_function_decl))
1884 tree decl = TREE_VEC_ELT (decl_map, slot);
1885 DECL_NAME (decl) = name;
1886 if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
1887 warning (0, "bad type in parameter debug info");
1892 int end_pc = start_pc + length;
1893 tree decl = build_decl (VAR_DECL, name, type);
1894 if (end_pc > DECL_CODE_LENGTH (current_function_decl))
1896 warning (0, "bad PC range for debug info for local %q+D",
1898 end_pc = DECL_CODE_LENGTH (current_function_decl);
1901 /* Adjust start_pc if necessary so that the local's first
1902 store operation will use the relevant DECL as a
1903 destination. Fore more information, read the leading
1904 comments for expr.c:maybe_adjust_start_pc. */
1905 start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot);
1907 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1908 DECL_LOCAL_SLOT_NUMBER (decl) = slot;
1909 DECL_LOCAL_START_PC (decl) = start_pc;
1911 /* FIXME: The range used internally for exceptions and local
1912 variable ranges, is a half-open interval:
1913 start_pc <= pc < end_pc. However, the range used in the
1914 Java VM spec is inclusive at both ends:
1915 start_pc <= pc <= end_pc. */
1918 DECL_LOCAL_END_PC (decl) = end_pc;
1920 /* Now insert the new decl in the proper place in
1921 pending_local_decls. We are essentially doing an insertion sort,
1922 which works fine, since the list input will normally already
1924 ptr = &pending_local_decls;
1925 while (*ptr != NULL_TREE
1926 && (DECL_LOCAL_START_PC (*ptr) > start_pc
1927 || (DECL_LOCAL_START_PC (*ptr) == start_pc
1928 && DECL_LOCAL_END_PC (*ptr) < end_pc)))
1929 ptr = &TREE_CHAIN (*ptr);
1930 TREE_CHAIN (decl) = *ptr;
1935 pending_local_decls = nreverse (pending_local_decls);
1937 /* Fill in default names for the parameters. */
1938 for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
1939 parm != NULL_TREE; parm = TREE_CHAIN (parm), i++)
1941 if (DECL_NAME (parm) == NULL_TREE)
1943 int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
1945 DECL_NAME (parm) = get_identifier ("this");
1949 sprintf (buffer, "ARG_%d", arg_i);
1950 DECL_NAME (parm) = get_identifier (buffer);
1957 build_result_decl (tree fndecl)
1959 tree restype = TREE_TYPE (TREE_TYPE (fndecl));
1960 tree result = DECL_RESULT (fndecl);
1963 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1964 if (INTEGRAL_TYPE_P (restype)
1965 && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
1966 restype = integer_type_node;
1967 result = build_decl (RESULT_DECL, NULL_TREE, restype);
1968 DECL_ARTIFICIAL (result) = 1;
1969 DECL_IGNORED_P (result) = 1;
1970 DECL_CONTEXT (result) = fndecl;
1971 DECL_RESULT (fndecl) = result;
1977 start_java_method (tree fndecl)
1984 current_function_decl = fndecl;
1985 announce_function (fndecl);
1987 i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
1988 decl_map = make_tree_vec (i);
1989 base_decl_map = make_tree_vec (i);
1990 type_map = xrealloc (type_map, i * sizeof (tree));
1992 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1993 fprintf (stderr, "%s:\n", lang_printable_name (fndecl, 2));
1995 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1996 pushlevel (1); /* Push parameters. */
1998 ptr = &DECL_ARGUMENTS (fndecl);
1999 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
2000 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
2002 tree parm_name = NULL_TREE, parm_decl;
2003 tree parm_type = TREE_VALUE (tem);
2004 if (i >= DECL_MAX_LOCALS (fndecl))
2007 parm_decl = build_decl (PARM_DECL, parm_name, parm_type);
2008 DECL_CONTEXT (parm_decl) = fndecl;
2009 if (targetm.calls.promote_prototypes (parm_type)
2010 && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
2011 && INTEGRAL_TYPE_P (parm_type))
2012 parm_type = integer_type_node;
2013 DECL_ARG_TYPE (parm_decl) = parm_type;
2016 ptr = &TREE_CHAIN (parm_decl);
2018 /* Add parm_decl to the decl_map. */
2019 push_jvm_slot (i, parm_decl);
2021 type_map[i] = TREE_TYPE (parm_decl);
2022 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
2025 type_map[i] = void_type_node;
2029 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
2031 while (i < DECL_MAX_LOCALS(fndecl))
2032 type_map[i++] = NULL_TREE;
2034 build_result_decl (fndecl);
2036 /* Push local variables. */
2039 function_binding_level = current_binding_level;
2043 end_java_method (void)
2045 tree fndecl = current_function_decl;
2047 /* pop out of function */
2050 /* pop out of its parameters */
2053 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
2055 if (DECL_SAVED_TREE (fndecl))
2057 tree fbody, block_body;
2058 /* Before we check initialization, attached all class initialization
2059 variable to the block_body */
2060 fbody = DECL_SAVED_TREE (fndecl);
2061 block_body = BIND_EXPR_BODY (fbody);
2062 htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (fndecl),
2063 attach_init_test_initialization_flags, block_body);
2066 flag_unit_at_a_time = 0;
2067 finish_method (fndecl);
2069 if (! flag_unit_at_a_time)
2071 /* Nulling these fields when we no longer need them saves
2073 DECL_SAVED_TREE (fndecl) = NULL;
2074 DECL_STRUCT_FUNCTION (fndecl) = NULL;
2075 DECL_INITIAL (fndecl) = NULL_TREE;
2077 current_function_decl = NULL_TREE;
2080 /* Prepare a method for expansion. */
2083 finish_method (tree fndecl)
2085 tree *tp = &DECL_SAVED_TREE (fndecl);
2087 /* Wrap body of synchronized methods in a monitorenter,
2088 plus monitorexit cleanup. */
2089 if (METHOD_SYNCHRONIZED (fndecl))
2091 tree enter, exit, lock;
2092 if (METHOD_STATIC (fndecl))
2093 lock = build_class_ref (DECL_CONTEXT (fndecl));
2095 lock = DECL_ARGUMENTS (fndecl);
2096 BUILD_MONITOR_ENTER (enter, lock);
2097 BUILD_MONITOR_EXIT (exit, lock);
2098 *tp = build2 (COMPOUND_EXPR, void_type_node, enter,
2099 build2 (TRY_FINALLY_EXPR, void_type_node, *tp, exit));
2102 /* Prepend class initialization for static methods reachable from
2104 if (METHOD_STATIC (fndecl)
2105 && (! METHOD_PRIVATE (fndecl)
2106 || INNER_CLASS_P (DECL_CONTEXT (fndecl)))
2107 && ! DECL_CLINIT_P (fndecl)
2108 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl))))
2110 tree clas = DECL_CONTEXT (fndecl);
2111 tree init = build3 (CALL_EXPR, void_type_node,
2112 build_address_of (soft_initclass_node),
2113 build_tree_list (NULL_TREE, build_class_ref (clas)),
2115 *tp = build2 (COMPOUND_EXPR, TREE_TYPE (*tp), init, *tp);
2118 /* Convert function tree to GENERIC prior to inlining. */
2119 java_genericize (fndecl);
2121 /* Store the end of the function, so that we get good line number
2122 info for the epilogue. */
2123 if (DECL_STRUCT_FUNCTION (fndecl))
2124 cfun = DECL_STRUCT_FUNCTION (fndecl);
2126 allocate_struct_function (fndecl);
2127 #ifdef USE_MAPPED_LOCATION
2128 cfun->function_end_locus = DECL_FUNCTION_LAST_LINE (fndecl);
2130 cfun->function_end_locus.file = DECL_SOURCE_FILE (fndecl);
2131 cfun->function_end_locus.line = DECL_FUNCTION_LAST_LINE (fndecl);
2134 /* Defer inlining and expansion to the cgraph optimizers. */
2135 cgraph_finalize_function (fndecl, false);
2138 /* Optimize and expand a function's entire body. */
2141 java_expand_body (tree fndecl)
2143 tree_rest_of_compilation (fndecl);
2146 /* We pessimistically marked all methods and fields external until we
2147 knew what set of classes we were planning to compile. Now mark those
2148 associated with CLASS to be generated locally as not external. */
2151 java_mark_decl_local (tree decl)
2153 DECL_EXTERNAL (decl) = 0;
2155 /* If we've already constructed DECL_RTL, give encode_section_info
2156 a second chance, now that we've changed the flags. */
2157 /* ??? Ideally, we'd have flag_unit_at_a_time set, and not have done
2158 anything that would have referenced DECL_RTL so far. But at the
2159 moment we force flag_unit_at_a_time off due to excessive memory
2160 consumption when compiling large jar files. Which probably means
2161 that we need to re-order how we process jar files... */
2162 if (DECL_RTL_SET_P (decl))
2163 make_decl_rtl (decl);
2166 /* Given appropriate target support, G++ will emit hidden aliases for native
2167 methods. Using this hidden name is required for proper operation of
2168 _Jv_Method::ncode, but it doesn't hurt to use it everywhere. Look for
2169 proper target support, then mark the method for aliasing. */
2172 java_mark_cni_decl_local (tree decl)
2174 /* Setting DECL_LOCAL_CNI_METHOD_P changes the behavior of the mangler.
2175 We expect that we should not yet have referenced this decl in a
2176 context that requires it. Check this invariant even if we don't have
2177 support for hidden aliases. */
2178 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
2180 #if !defined(HAVE_GAS_HIDDEN) || !defined(ASM_OUTPUT_DEF)
2184 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2185 DECL_LOCAL_CNI_METHOD_P (decl) = 1;
2188 /* Use the preceding two functions and mark all members of the class. */
2191 java_mark_class_local (tree class)
2195 for (t = TYPE_FIELDS (class); t ; t = TREE_CHAIN (t))
2196 if (FIELD_STATIC (t))
2197 java_mark_decl_local (t);
2199 for (t = TYPE_METHODS (class); t ; t = TREE_CHAIN (t))
2200 if (!METHOD_ABSTRACT (t))
2202 if (METHOD_NATIVE (t) && !flag_jni)
2203 java_mark_cni_decl_local (t);
2205 java_mark_decl_local (t);
2209 /* Add a statement to a compound_expr. */
2212 add_stmt_to_compound (tree existing, tree type, tree stmt)
2218 tree expr = build2 (COMPOUND_EXPR, type, existing, stmt);
2219 TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (existing)
2220 | TREE_SIDE_EFFECTS (stmt);
2227 /* Add a statement to the compound_expr currently being
2231 java_add_stmt (tree stmt)
2234 SET_EXPR_LOCATION (stmt, input_location);
2236 return current_binding_level->stmts
2237 = add_stmt_to_compound (current_binding_level->stmts,
2238 TREE_TYPE (stmt), stmt);
2241 /* Add a variable to the current scope. */
2244 java_add_local_var (tree decl)
2246 tree *vars = ¤t_binding_level->names;
2248 TREE_CHAIN (decl) = next;
2250 DECL_CONTEXT (decl) = current_function_decl;
2251 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2255 /* Return a pointer to the compound_expr currently being
2261 return ¤t_binding_level->stmts;
2264 /* Register an exception range as belonging to the current binding
2265 level. There may only be one: if there are more, we'll create more
2266 binding levels. However, each range can have multiple handlers,
2267 and these are expanded when we call expand_end_java_handler(). */
2270 register_exception_range (struct eh_range *range, int pc, int end_pc)
2272 if (current_binding_level->exception_range)
2274 current_binding_level->exception_range = range;
2275 current_binding_level->end_pc = end_pc;
2276 current_binding_level->start_pc = pc;
2279 #include "gt-java-decl.h"