1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, 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"
47 #include "tree-inline.h"
49 #if defined (DEBUG_JAVA_BINDING_LEVELS)
50 extern void indent (void);
53 static tree push_jvm_slot (int, tree);
54 static tree lookup_name_current_level (tree);
55 static tree push_promoted_type (const char *, tree);
56 static struct binding_level *make_binding_level (void);
57 static tree create_primitive_vtable (const char *);
58 static tree check_local_named_variable (tree, tree, int, int *);
59 static tree check_local_unnamed_variable (tree, tree, tree);
61 /* Name of the Cloneable class. */
62 tree java_lang_cloneable_identifier_node;
64 /* Name of the Serializable class. */
65 tree java_io_serializable_identifier_node;
67 /* Set to nonzero value in order to emit class initialization code
68 before static field references. */
69 extern int always_initialize_class_p;
71 /* The DECL_MAP is a mapping from (index, type) to a decl node.
72 If index < max_locals, it is the index of a local variable.
73 if index >= max_locals, then index-max_locals is a stack slot.
74 The DECL_MAP mapping is represented as a TREE_VEC whose elements
75 are a list of decls (VAR_DECL or PARM_DECL) chained by
76 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
77 we search the chain for a decl with a matching TREE_TYPE. */
79 static GTY(()) tree decl_map;
81 /* A list of local variables VAR_DECLs for this method that we have seen
82 debug information, but we have not reached their starting (byte) PC yet. */
84 static GTY(()) tree pending_local_decls;
86 /* Push a local variable or stack slot into the decl_map,
87 and assign it an rtl. */
89 #if defined(DEBUG_JAVA_BINDING_LEVELS)
90 int binding_depth = 0;
91 int is_class_level = 0;
99 for (i = 0; i < binding_depth*2; i++)
102 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
105 push_jvm_slot (int index, tree decl)
107 struct rtx_def *rtl = NULL;
108 tree type = TREE_TYPE (decl);
111 DECL_CONTEXT (decl) = current_function_decl;
112 layout_decl (decl, 0);
114 /* See if we have an appropriate rtl (i.e. same mode) at this index.
115 If so, we must use it. */
116 tmp = TREE_VEC_ELT (decl_map, index);
117 while (tmp != NULL_TREE)
119 if (TYPE_MODE (type) == TYPE_MODE (TREE_TYPE (tmp)))
120 rtl = DECL_RTL_IF_SET (tmp);
123 tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
126 SET_DECL_RTL (decl, rtl);
129 if (index >= DECL_MAX_LOCALS (current_function_decl))
130 DECL_REGISTER (decl) = 1;
134 /* Now link the decl into the decl_map. */
135 if (DECL_LANG_SPECIFIC (decl) == NULL)
137 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
138 DECL_LOCAL_START_PC (decl) = 0;
139 DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
140 DECL_LOCAL_SLOT_NUMBER (decl) = index;
142 DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
143 TREE_VEC_ELT (decl_map, index) = decl;
147 /* Find out if 'decl' passed in fits the defined PC location better than
148 'best'. Return decl if it does, return best if it doesn't. If decl
149 is returned, then updated is set to true. */
152 check_local_named_variable (tree best, tree decl, int pc, int *updated)
154 if (pc >= DECL_LOCAL_START_PC (decl)
155 && pc < DECL_LOCAL_END_PC (decl))
157 if (best == NULL_TREE
158 || (DECL_LOCAL_START_PC (decl) > DECL_LOCAL_START_PC (best)
159 && DECL_LOCAL_END_PC (decl) < DECL_LOCAL_END_PC (best)))
169 /* Find the best declaration based upon type. If 'decl' fits 'type' better
170 than 'best', return 'decl'. Otherwise return 'best'. */
173 check_local_unnamed_variable (tree best, tree decl, tree type)
175 if (TREE_TYPE (decl) == type
176 || (TREE_CODE (TREE_TYPE (decl)) == TREE_CODE (type)
177 && TYPE_PRECISION (TREE_TYPE (decl)) <= 32
178 && TYPE_PRECISION (type) <= 32
179 && TREE_CODE (type) != POINTER_TYPE)
180 || (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
181 && type == ptr_type_node))
183 if (best == NULL_TREE
184 || (TREE_TYPE (decl) == type && TREE_TYPE (best) != type))
192 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
193 that is valid at PC (or -1 if any pc).
194 If there is no existing matching decl, allocate one. */
197 find_local_variable (int index, tree type, int pc)
199 tree decl = TREE_VEC_ELT (decl_map, index);
200 tree best = NULL_TREE;
201 int found_scoped_var = 0;
203 /* Scan through every declaration that has been created in this slot. */
204 while (decl != NULL_TREE)
206 /* Variables created in give_name_to_locals() have a name and have
207 a specified scope, so we can handle them specifically. We want
208 to use the specific decls created for those so they are assigned
209 the right variables in the debugging information. */
210 if (DECL_NAME (decl) != NULL_TREE)
212 /* This is a variable we have a name for, so it has a scope
213 supplied in the class file. But it only matters when we
214 actually have a PC to use. If pc<0, then we are asking
215 for a stack slot and this decl won't be one of those. */
217 best = check_local_named_variable (best, decl, pc,
220 /* We scan for type information unless we found a variable in the
221 proper scope already. */
222 else if (!found_scoped_var)
224 /* If we don't have scoping information for a variable, we use
225 a different method to look it up. */
226 best = check_local_unnamed_variable (best, decl, type);
229 decl = DECL_LOCAL_SLOT_CHAIN (decl);
232 if (best != NULL_TREE)
235 /* If we don't find a match, create one with the type passed in. */
236 return push_jvm_slot (index, build_decl (VAR_DECL, NULL_TREE, type));
240 /* Same as find_local_index, except that INDEX is a stack index. */
243 find_stack_slot (int index, tree type)
245 return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
251 /* A chain of _DECL nodes for all variables, constants, functions,
252 * and typedef types. These are in the reverse of the order supplied.
256 /* For each level, a list of shadowed outer-level local definitions
257 to be restored when this level is popped.
258 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
259 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
262 /* For each level (except not the global one),
263 a chain of BLOCK nodes for all the levels
264 that were entered and exited one level down. */
267 /* The BLOCK node for this level, if one has been preallocated.
268 If 0, the BLOCK is allocated (if needed) when the level is popped. */
271 /* The binding level which this one is contained in (inherits from). */
272 struct binding_level *level_chain;
274 /* The bytecode PC that marks the end of this level. */
276 /* The bytecode PC that marks the start of this level. */
279 #if defined(DEBUG_JAVA_BINDING_LEVELS)
280 /* Binding depth at which this level began. */
281 unsigned binding_depth;
282 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
285 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
287 /* The binding level currently in effect. */
289 static struct binding_level *current_binding_level;
291 /* A chain of binding_level structures awaiting reuse. */
293 static struct binding_level *free_binding_level;
295 /* The outermost binding level, for names of file scope.
296 This is created when the compiler is started and exists
297 through the entire run. */
299 static struct binding_level *global_binding_level;
301 /* A PC value bigger than any PC value we may ever may encounter. */
303 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
305 /* Binding level structures are initialized by copying this one. */
307 static const struct binding_level clear_binding_level
308 = {NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
309 NULL_BINDING_LEVEL, LARGEST_PC, 0};
312 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
313 that have names. Here so we can clear out their names' definitions
314 at the end of the function. */
316 static tree named_labels;
318 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
320 static tree shadowed_labels;
323 tree java_global_trees[JTI_MAX];
325 /* Build (and pushdecl) a "promoted type" for all standard
326 types shorter than int. */
329 push_promoted_type (const char *name, tree actual_type)
331 tree type = make_node (TREE_CODE (actual_type));
333 tree in_min = TYPE_MIN_VALUE (int_type_node);
334 tree in_max = TYPE_MAX_VALUE (int_type_node);
336 tree in_min = TYPE_MIN_VALUE (actual_type);
337 tree in_max = TYPE_MAX_VALUE (actual_type);
339 TYPE_MIN_VALUE (type) = copy_node (in_min);
340 TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
341 TYPE_MAX_VALUE (type) = copy_node (in_max);
342 TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
343 TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
345 pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
349 /* Return a definition for a builtin function named NAME and whose data type
350 is TYPE. TYPE should be a function type with argument types.
351 FUNCTION_CODE tells later passes how to compile calls to this function.
352 See tree.h for its possible values.
354 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
355 the name to be called if we can't opencode the function. If
356 ATTRS is nonzero, use that for the function's attribute list. */
359 builtin_function (const char *name,
362 enum built_in_class class,
363 const char *library_name,
364 tree attrs ATTRIBUTE_UNUSED)
366 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
367 DECL_EXTERNAL (decl) = 1;
368 TREE_PUBLIC (decl) = 1;
370 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
371 make_decl_rtl (decl, NULL);
373 DECL_BUILT_IN_CLASS (decl) = class;
374 DECL_FUNCTION_CODE (decl) = function_code;
378 /* Return tree that represents a vtable for a primitive array. */
380 create_primitive_vtable (const char *name)
385 sprintf (buf, "_Jv_%sVTable", name);
386 r = build_decl (VAR_DECL, get_identifier (buf), ptr_type_node);
387 DECL_EXTERNAL (r) = 1;
392 java_init_decl_processing (void)
394 register tree endlink;
395 tree field = NULL_TREE;
398 init_class_processing ();
399 init_resource_processing ();
401 current_function_decl = NULL;
402 current_binding_level = NULL_BINDING_LEVEL;
403 free_binding_level = NULL_BINDING_LEVEL;
404 pushlevel (0); /* make the binding_level structure for global names */
405 global_binding_level = current_binding_level;
407 /* The code here must be similar to build_common_tree_nodes{,_2} in
408 tree.c, especially as to the order of initializing common nodes. */
409 error_mark_node = make_node (ERROR_MARK);
410 TREE_TYPE (error_mark_node) = error_mark_node;
412 /* Create sizetype first - needed for other types. */
413 initialize_sizetypes ();
415 byte_type_node = make_signed_type (8);
416 pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"), byte_type_node));
417 short_type_node = make_signed_type (16);
418 pushdecl (build_decl (TYPE_DECL, get_identifier ("short"), short_type_node));
419 int_type_node = make_signed_type (32);
420 pushdecl (build_decl (TYPE_DECL, get_identifier ("int"), int_type_node));
421 long_type_node = make_signed_type (64);
422 pushdecl (build_decl (TYPE_DECL, get_identifier ("long"), long_type_node));
424 unsigned_byte_type_node = make_unsigned_type (8);
425 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned byte"),
426 unsigned_byte_type_node));
427 unsigned_short_type_node = make_unsigned_type (16);
428 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned short"),
429 unsigned_short_type_node));
430 unsigned_int_type_node = make_unsigned_type (32);
431 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
432 unsigned_int_type_node));
433 unsigned_long_type_node = make_unsigned_type (64);
434 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned long"),
435 unsigned_long_type_node));
437 set_sizetype (make_unsigned_type (POINTER_SIZE));
439 /* Define these next since types below may used them. */
440 integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0);
441 integer_zero_node = build_int_2 (0, 0);
442 integer_one_node = build_int_2 (1, 0);
443 integer_two_node = build_int_2 (2, 0);
444 integer_four_node = build_int_2 (4, 0);
445 integer_minus_one_node = build_int_2 (-1, -1);
447 /* A few values used for range checking in the lexer. */
448 decimal_int_max = build_int_2 (0x80000000, 0);
449 TREE_TYPE (decimal_int_max) = unsigned_int_type_node;
450 #if HOST_BITS_PER_WIDE_INT == 64
451 decimal_long_max = build_int_2 (0x8000000000000000LL, 0);
453 #if HOST_BITS_PER_WIDE_INT == 32
454 decimal_long_max = build_int_2 (0, 0x80000000);
456 #error "unsupported size"
459 TREE_TYPE (decimal_long_max) = unsigned_long_type_node;
461 size_zero_node = size_int (0);
462 size_one_node = size_int (1);
463 bitsize_zero_node = bitsize_int (0);
464 bitsize_one_node = bitsize_int (1);
465 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
467 long_zero_node = build_int_2 (0, 0);
468 TREE_TYPE (long_zero_node) = long_type_node;
470 void_type_node = make_node (VOID_TYPE);
471 pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
472 layout_type (void_type_node); /* Uses size_zero_node */
473 ptr_type_node = build_pointer_type (void_type_node);
474 t = make_node (VOID_TYPE);
475 layout_type (t); /* Uses size_zero_node */
476 return_address_type_node = build_pointer_type (t);
478 null_pointer_node = build_int_2 (0, 0);
479 TREE_TYPE (null_pointer_node) = ptr_type_node;
481 /* Used by the parser to represent empty statements and blocks. */
482 empty_stmt_node = build1 (NOP_EXPR, void_type_node, size_zero_node);
483 CAN_COMPLETE_NORMALLY (empty_stmt_node) = 1;
486 /* Make a type to be the domain of a few array types
487 whose domains don't really matter.
488 200 is small enough that it always fits in size_t
489 and large enough that it can hold most function names for the
490 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
491 short_array_type_node = build_prim_array_type (short_type_node, 200);
493 char_type_node = make_node (CHAR_TYPE);
494 TYPE_PRECISION (char_type_node) = 16;
495 fixup_unsigned_type (char_type_node);
496 pushdecl (build_decl (TYPE_DECL, get_identifier ("char"), char_type_node));
498 boolean_type_node = make_node (BOOLEAN_TYPE);
499 TYPE_PRECISION (boolean_type_node) = 1;
500 fixup_unsigned_type (boolean_type_node);
501 pushdecl (build_decl (TYPE_DECL, get_identifier ("boolean"),
503 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
504 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
506 promoted_byte_type_node
507 = push_promoted_type ("promoted_byte", byte_type_node);
508 promoted_short_type_node
509 = push_promoted_type ("promoted_short", short_type_node);
510 promoted_char_type_node
511 = push_promoted_type ("promoted_char", char_type_node);
512 promoted_boolean_type_node
513 = push_promoted_type ("promoted_boolean", boolean_type_node);
515 float_type_node = make_node (REAL_TYPE);
516 TYPE_PRECISION (float_type_node) = 32;
517 pushdecl (build_decl (TYPE_DECL, get_identifier ("float"),
519 layout_type (float_type_node);
521 double_type_node = make_node (REAL_TYPE);
522 TYPE_PRECISION (double_type_node) = 64;
523 pushdecl (build_decl (TYPE_DECL, get_identifier ("double"),
525 layout_type (double_type_node);
527 float_zero_node = build_real (float_type_node, dconst0);
528 double_zero_node = build_real (double_type_node, dconst0);
530 /* These are the vtables for arrays of primitives. */
531 boolean_array_vtable = create_primitive_vtable ("boolean");
532 byte_array_vtable = create_primitive_vtable ("byte");
533 char_array_vtable = create_primitive_vtable ("char");
534 short_array_vtable = create_primitive_vtable ("short");
535 int_array_vtable = create_primitive_vtable ("int");
536 long_array_vtable = create_primitive_vtable ("long");
537 float_array_vtable = create_primitive_vtable ("float");
538 double_array_vtable = create_primitive_vtable ("double");
540 /* As you're adding items here, please update the code right after
541 this section, so that the filename containing the source code of
542 the pre-defined class gets registered correctly. */
543 unqualified_object_id_node = get_identifier ("Object");
544 object_type_node = lookup_class (get_identifier ("java.lang.Object"));
545 object_ptr_type_node = promote_type (object_type_node);
546 string_type_node = lookup_class (get_identifier ("java.lang.String"));
547 string_ptr_type_node = promote_type (string_type_node);
548 class_type_node = lookup_class (get_identifier ("java.lang.Class"));
549 throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
550 exception_type_node = lookup_class (get_identifier ("java.lang.Exception"));
551 runtime_exception_type_node =
552 lookup_class (get_identifier ("java.lang.RuntimeException"));
553 error_exception_type_node =
554 lookup_class (get_identifier ("java.lang.Error"));
555 class_not_found_type_node =
556 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
557 no_class_def_found_type_node =
558 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
560 rawdata_ptr_type_node
561 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
563 add_predefined_file (get_identifier ("java/lang/Class.java"));
564 add_predefined_file (get_identifier ("java/lang/Error.java"));
565 add_predefined_file (get_identifier ("java/lang/Object.java"));
566 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
567 add_predefined_file (get_identifier ("java/lang/String.java"));
568 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
569 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
570 add_predefined_file (get_identifier ("java/lang/Exception.java"));
571 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
572 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
573 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
575 methodtable_type = make_node (RECORD_TYPE);
576 layout_type (methodtable_type);
577 build_decl (TYPE_DECL, get_identifier ("methodtable"), methodtable_type);
578 methodtable_ptr_type = build_pointer_type (methodtable_type);
580 TYPE_identifier_node = get_identifier ("TYPE");
581 init_identifier_node = get_identifier ("<init>");
582 clinit_identifier_node = get_identifier ("<clinit>");
583 finit_identifier_node = get_identifier ("finit$");
584 instinit_identifier_node = get_identifier ("instinit$");
585 void_signature_node = get_identifier ("()V");
586 length_identifier_node = get_identifier ("length");
587 finalize_identifier_node = get_identifier ("finalize");
588 this_identifier_node = get_identifier ("this");
589 super_identifier_node = get_identifier ("super");
590 continue_identifier_node = get_identifier ("continue");
591 access0_identifier_node = get_identifier ("access$0");
592 classdollar_identifier_node = get_identifier ("class$");
594 java_lang_cloneable_identifier_node = get_identifier ("java.lang.Cloneable");
595 java_io_serializable_identifier_node =
596 get_identifier ("java.io.Serializable");
598 /* for lack of a better place to put this stub call */
599 init_expr_processing();
601 utf8const_type = make_node (RECORD_TYPE);
602 PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
603 PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
604 FINISH_RECORD (utf8const_type);
605 utf8const_ptr_type = build_pointer_type (utf8const_type);
607 constants_type_node = make_node (RECORD_TYPE);
608 PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node);
609 PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
610 PUSH_FIELD (constants_type_node, field, "data", ptr_type_node);
611 FINISH_RECORD (constants_type_node);
612 build_decl (TYPE_DECL, get_identifier ("constants"), constants_type_node);
614 access_flags_type_node = unsigned_short_type_node;
616 dtable_type = make_node (RECORD_TYPE);
617 dtable_ptr_type = build_pointer_type (dtable_type);
619 one_elt_array_domain_type = build_index_type (integer_one_node);
620 otable_type = build_array_type (integer_type_node,
621 one_elt_array_domain_type);
622 TYPE_NONALIASED_COMPONENT (otable_type) = 1;
623 otable_ptr_type = build_pointer_type (otable_type);
624 atable_type = build_array_type (ptr_type_node,
625 one_elt_array_domain_type);
626 TYPE_NONALIASED_COMPONENT (atable_type) = 1;
627 atable_ptr_type = build_pointer_type (atable_type);
629 symbol_type = make_node (RECORD_TYPE);
630 PUSH_FIELD (symbol_type, field, "clname", utf8const_ptr_type);
631 PUSH_FIELD (symbol_type, field, "name", utf8const_ptr_type);
632 PUSH_FIELD (symbol_type, field, "signature", utf8const_ptr_type);
633 FINISH_RECORD (symbol_type);
635 symbols_array_type = build_array_type (symbol_type,
636 one_elt_array_domain_type);
637 symbols_array_ptr_type = build_pointer_type (symbols_array_type);
639 if (flag_indirect_dispatch)
641 otable_decl = build_decl (VAR_DECL, get_identifier ("otable"), otable_type);
642 DECL_EXTERNAL (otable_decl) = 1;
643 TREE_STATIC (otable_decl) = 1;
644 TREE_READONLY (otable_decl) = 1;
645 TREE_CONSTANT (otable_decl) = 1;
646 pushdecl (otable_decl);
647 otable_syms_decl = build_decl (VAR_DECL, get_identifier ("otable_syms"),
649 TREE_STATIC (otable_syms_decl) = 1;
650 TREE_CONSTANT (otable_syms_decl) = 1;
651 pushdecl (otable_syms_decl);
653 atable_decl = build_decl (VAR_DECL, get_identifier ("atable"), atable_type);
654 DECL_EXTERNAL (atable_decl) = 1;
655 TREE_STATIC (atable_decl) = 1;
656 TREE_READONLY (atable_decl) = 1;
657 TREE_CONSTANT (atable_decl) = 1;
658 pushdecl (atable_decl);
659 atable_syms_decl = build_decl (VAR_DECL, get_identifier ("atable_syms"),
661 TREE_STATIC (atable_syms_decl) = 1;
662 TREE_CONSTANT (atable_syms_decl) = 1;
663 pushdecl (atable_syms_decl);
666 PUSH_FIELD (object_type_node, field, "vtable", dtable_ptr_type);
667 /* This isn't exactly true, but it is what we have in the source.
668 There is an unresolved issue here, which is whether the vtable
669 should be marked by the GC. */
670 if (! flag_hash_synchronization)
671 PUSH_FIELD (object_type_node, field, "sync_info",
672 build_pointer_type (object_type_node));
673 for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
674 FIELD_PRIVATE (t) = 1;
675 FINISH_RECORD (object_type_node);
677 field_type_node = make_node (RECORD_TYPE);
678 field_ptr_type_node = build_pointer_type (field_type_node);
679 method_type_node = make_node (RECORD_TYPE);
680 method_ptr_type_node = build_pointer_type (method_type_node);
682 set_super_info (0, class_type_node, object_type_node, 0);
683 set_super_info (0, string_type_node, object_type_node, 0);
684 class_ptr_type = build_pointer_type (class_type_node);
686 PUSH_FIELD (class_type_node, field, "next", class_ptr_type);
687 PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type);
688 PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node);
689 PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type);
690 PUSH_FIELD (class_type_node, field, "constants", constants_type_node);
691 PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node);
692 PUSH_FIELD (class_type_node, field, "method_count", short_type_node);
693 PUSH_FIELD (class_type_node, field, "vtable_method_count", short_type_node);
694 PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node);
695 PUSH_FIELD (class_type_node, field, "size_in_bytes", int_type_node);
696 PUSH_FIELD (class_type_node, field, "field_count", short_type_node);
697 PUSH_FIELD (class_type_node, field, "static_field_count", short_type_node);
698 PUSH_FIELD (class_type_node, field, "vtable", dtable_ptr_type);
699 PUSH_FIELD (class_type_node, field, "otable", otable_ptr_type);
700 PUSH_FIELD (class_type_node, field, "otable_syms",
701 symbols_array_ptr_type);
702 PUSH_FIELD (class_type_node, field, "atable", atable_ptr_type);
703 PUSH_FIELD (class_type_node, field, "atable_syms",
704 symbols_array_ptr_type);
705 PUSH_FIELD (class_type_node, field, "interfaces",
706 build_pointer_type (class_ptr_type));
707 PUSH_FIELD (class_type_node, field, "loader", ptr_type_node);
708 PUSH_FIELD (class_type_node, field, "interface_count", short_type_node);
709 PUSH_FIELD (class_type_node, field, "state", byte_type_node);
710 PUSH_FIELD (class_type_node, field, "thread", ptr_type_node);
711 PUSH_FIELD (class_type_node, field, "depth", short_type_node);
712 PUSH_FIELD (class_type_node, field, "ancestors", ptr_type_node);
713 PUSH_FIELD (class_type_node, field, "idt", ptr_type_node);
714 PUSH_FIELD (class_type_node, field, "arrayclass", ptr_type_node);
715 PUSH_FIELD (class_type_node, field, "protectionDomain", ptr_type_node);
716 PUSH_FIELD (class_type_node, field, "signers", ptr_type_node);
717 PUSH_FIELD (class_type_node, field, "chain", ptr_type_node);
718 for (t = TYPE_FIELDS (class_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
719 FIELD_PRIVATE (t) = 1;
720 push_super_field (class_type_node, object_type_node);
722 FINISH_RECORD (class_type_node);
723 build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node);
725 field_info_union_node = make_node (UNION_TYPE);
726 PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node);
727 PUSH_FIELD (field_info_union_node, field, "addr", ptr_type_node);
729 PUSH_FIELD (field_info_union_node, field, "idx", unsigned_short_type_node);
731 layout_type (field_info_union_node);
733 PUSH_FIELD (field_type_node, field, "name", utf8const_ptr_type);
734 PUSH_FIELD (field_type_node, field, "type", class_ptr_type);
735 PUSH_FIELD (field_type_node, field, "accflags", access_flags_type_node);
736 PUSH_FIELD (field_type_node, field, "bsize", unsigned_short_type_node);
737 PUSH_FIELD (field_type_node, field, "info", field_info_union_node);
738 FINISH_RECORD (field_type_node);
739 build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node);
741 nativecode_ptr_array_type_node
742 = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
744 PUSH_FIELD (dtable_type, field, "class", class_ptr_type);
745 PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node);
746 FINISH_RECORD (dtable_type);
747 build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
749 #define jint_type int_type_node
750 #define jint_ptr_type ptr_type_node
752 jexception_type = make_node (RECORD_TYPE);
753 PUSH_FIELD (jexception_type, field, "start_pc", ptr_type_node);
754 PUSH_FIELD (jexception_type, field, "end_pc", ptr_type_node);
755 PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node);
756 PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type);
757 FINISH_RECORD (jexception_type);
758 build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node);
759 jexception_ptr_type = build_pointer_type (jexception_type);
761 lineNumberEntry_type = make_node (RECORD_TYPE);
762 PUSH_FIELD (lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
763 PUSH_FIELD (lineNumberEntry_type, field, "start_pc", ptr_type_node);
764 FINISH_RECORD (lineNumberEntry_type);
766 lineNumbers_type = make_node (RECORD_TYPE);
767 PUSH_FIELD (lineNumbers_type, field, "length", unsigned_int_type_node);
768 FINISH_RECORD (lineNumbers_type);
770 #define instn_ptr_type_node ptr_type_node /* XXX JH */
772 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
774 PUSH_FIELD (method_type_node, field, "name", utf8const_ptr_type);
775 PUSH_FIELD (method_type_node, field, "signature", utf8const_ptr_type);
776 PUSH_FIELD (method_type_node, field, "accflags", access_flags_type_node);
777 PUSH_FIELD (method_type_node, field, "index", unsigned_short_type_node);
778 PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node);
779 PUSH_FIELD (method_type_node, field, "throws", ptr_type_node);
780 FINISH_RECORD (method_type_node);
781 build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node);
783 endlink = end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
785 t = tree_cons (NULL_TREE, class_ptr_type,
786 tree_cons (NULL_TREE, int_type_node, endlink));
787 alloc_object_node = builtin_function ("_Jv_AllocObject",
788 build_function_type (ptr_type_node, t),
789 0, NOT_BUILT_IN, NULL, NULL_TREE);
790 DECL_IS_MALLOC (alloc_object_node) = 1;
791 alloc_no_finalizer_node =
792 builtin_function ("_Jv_AllocObjectNoFinalizer",
793 build_function_type (ptr_type_node, t),
794 0, NOT_BUILT_IN, NULL, NULL_TREE);
795 DECL_IS_MALLOC (alloc_no_finalizer_node) = 1;
797 t = tree_cons (NULL_TREE, ptr_type_node, endlink);
798 soft_initclass_node = builtin_function ("_Jv_InitClass",
799 build_function_type (void_type_node,
801 0, NOT_BUILT_IN, NULL, NULL_TREE);
803 throw_node = builtin_function ("_Jv_Throw",
804 build_function_type (ptr_type_node, t),
805 0, NOT_BUILT_IN, NULL, NULL_TREE);
806 /* Mark throw_nodes as `noreturn' functions with side effects. */
807 TREE_THIS_VOLATILE (throw_node) = 1;
808 TREE_SIDE_EFFECTS (throw_node) = 1;
810 t = build_function_type (int_type_node, endlink);
811 soft_monitorenter_node
812 = builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN,
814 soft_monitorexit_node
815 = builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN,
818 t = tree_cons (NULL_TREE, int_type_node,
819 tree_cons (NULL_TREE, int_type_node, endlink));
821 = builtin_function ("_Jv_NewPrimArray",
822 build_function_type(ptr_type_node, t),
823 0, NOT_BUILT_IN, NULL, NULL_TREE);
824 DECL_IS_MALLOC (soft_newarray_node) = 1;
826 t = tree_cons (NULL_TREE, int_type_node,
827 tree_cons (NULL_TREE, class_ptr_type,
828 tree_cons (NULL_TREE, object_ptr_type_node, endlink)));
830 = builtin_function ("_Jv_NewObjectArray",
831 build_function_type (ptr_type_node, t),
832 0, NOT_BUILT_IN, NULL, NULL_TREE);
833 DECL_IS_MALLOC (soft_anewarray_node) = 1;
835 /* There is no endlink here because _Jv_NewMultiArray is a varargs
837 t = tree_cons (NULL_TREE, ptr_type_node,
838 tree_cons (NULL_TREE, int_type_node, NULL_TREE));
839 soft_multianewarray_node
840 = builtin_function ("_Jv_NewMultiArray",
841 build_function_type (ptr_type_node, t),
842 0, NOT_BUILT_IN, NULL, NULL_TREE);
843 DECL_IS_MALLOC (soft_multianewarray_node) = 1;
845 t = build_function_type (void_type_node,
846 tree_cons (NULL_TREE, int_type_node, endlink));
847 soft_badarrayindex_node
848 = builtin_function ("_Jv_ThrowBadArrayIndex", t,
849 0, NOT_BUILT_IN, NULL, NULL_TREE);
850 /* Mark soft_badarrayindex_node as a `noreturn' function with side
852 TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
853 TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
855 soft_nullpointer_node
856 = builtin_function ("_Jv_ThrowNullPointerException",
857 build_function_type (void_type_node, endlink),
858 0, NOT_BUILT_IN, NULL, NULL_TREE);
859 /* Mark soft_nullpointer_node as a `noreturn' function with side
861 TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
862 TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
864 t = tree_cons (NULL_TREE, class_ptr_type,
865 tree_cons (NULL_TREE, object_ptr_type_node, endlink));
867 = builtin_function ("_Jv_CheckCast",
868 build_function_type (ptr_type_node, t),
869 0, NOT_BUILT_IN, NULL, NULL_TREE);
870 t = tree_cons (NULL_TREE, object_ptr_type_node,
871 tree_cons (NULL_TREE, class_ptr_type, endlink));
873 = builtin_function ("_Jv_IsInstanceOf",
874 build_function_type (boolean_type_node, t),
875 0, NOT_BUILT_IN, NULL, NULL_TREE);
876 t = tree_cons (NULL_TREE, object_ptr_type_node,
877 tree_cons (NULL_TREE, object_ptr_type_node, endlink));
878 soft_checkarraystore_node
879 = builtin_function ("_Jv_CheckArrayStore",
880 build_function_type (void_type_node, t),
881 0, NOT_BUILT_IN, NULL, NULL_TREE);
882 t = tree_cons (NULL_TREE, ptr_type_node,
883 tree_cons (NULL_TREE, ptr_type_node,
884 tree_cons (NULL_TREE, int_type_node, endlink)));
885 soft_lookupinterfacemethod_node
886 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
887 build_function_type (ptr_type_node, t),
888 0, NOT_BUILT_IN, NULL, NULL_TREE);
890 t = tree_cons (NULL_TREE, object_ptr_type_node,
891 tree_cons (NULL_TREE, ptr_type_node,
892 tree_cons (NULL_TREE, ptr_type_node,
893 tree_cons (NULL_TREE, int_type_node,
895 soft_lookupjnimethod_node
896 = builtin_function ("_Jv_LookupJNIMethod",
897 build_function_type (ptr_type_node, t),
898 0, NOT_BUILT_IN, NULL, NULL_TREE);
899 t = tree_cons (NULL_TREE, ptr_type_node, endlink);
900 soft_getjnienvnewframe_node
901 = builtin_function ("_Jv_GetJNIEnvNewFrame",
902 build_function_type (ptr_type_node, t),
903 0, NOT_BUILT_IN, NULL, NULL_TREE);
904 soft_jnipopsystemframe_node
905 = builtin_function ("_Jv_JNI_PopSystemFrame",
906 build_function_type (ptr_type_node, t),
907 0, NOT_BUILT_IN, NULL, NULL_TREE);
910 = builtin_function ("_Jv_divI",
911 build_function_type (int_type_node, t),
912 0, NOT_BUILT_IN, NULL, NULL_TREE);
915 = builtin_function ("_Jv_remI",
916 build_function_type (int_type_node, t),
917 0, NOT_BUILT_IN, NULL, NULL_TREE);
920 = builtin_function ("_Jv_divJ",
921 build_function_type (long_type_node, t),
922 0, NOT_BUILT_IN, NULL, NULL_TREE);
925 = builtin_function ("_Jv_remJ",
926 build_function_type (long_type_node, t),
927 0, NOT_BUILT_IN, NULL, NULL_TREE);
929 /* Initialize variables for except.c. */
930 eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
931 ? "__gcj_personality_sj0"
932 : "__gcj_personality_v0");
933 lang_eh_runtime_type = prepare_eh_table_type;
937 initialize_builtins ();
939 soft_fmod_node = built_in_decls[BUILT_IN_FMOD];
941 soft_fmodf_node = built_in_decls[BUILT_IN_FMODF];
946 /* Look up NAME in the current binding level and its superiors
947 in the namespace of variables, functions and typedefs.
948 Return a ..._DECL node of some kind representing its definition,
949 or return 0 if it is undefined. */
952 lookup_name (tree name)
955 if (current_binding_level != global_binding_level
956 && IDENTIFIER_LOCAL_VALUE (name))
957 val = IDENTIFIER_LOCAL_VALUE (name);
959 val = IDENTIFIER_GLOBAL_VALUE (name);
963 /* Similar to `lookup_name' but look only at current binding level and
964 the previous one if its the parameter level. */
967 lookup_name_current_level (tree name)
971 if (current_binding_level == global_binding_level)
972 return IDENTIFIER_GLOBAL_VALUE (name);
974 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
977 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
978 if (DECL_NAME (t) == name)
984 /* Use a binding level to record a labeled block declaration */
987 push_labeled_block (tree lb)
989 register tree name = DECL_NAME (LABELED_BLOCK_LABEL (lb));
990 register struct binding_level *b = current_binding_level;
991 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
993 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
994 TREE_CHAIN (lb) = b->names;
996 IDENTIFIER_LOCAL_VALUE (name) = lb;
999 /* Pop the current binding level, reinstalling values for the previous
1003 pop_labeled_block (void)
1005 struct binding_level *b = current_binding_level;
1006 tree label = b->names;
1007 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label))) =
1010 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b->shadowed)) =
1011 TREE_VALUE (b->shadowed);
1013 /* Pop the current level, and free the structure for reuse. */
1014 current_binding_level = current_binding_level->level_chain;
1015 b->level_chain = free_binding_level;
1016 free_binding_level = b;
1019 /* Record a decl-node X as belonging to the current lexical scope.
1020 Check for errors (such as an incompatible declaration for the same
1021 name already seen in the same scope).
1023 Returns either X or an old decl for the same name.
1024 If an old decl is returned, it may have been smashed
1025 to agree with what X says. */
1031 register tree name = DECL_NAME (x);
1032 register struct binding_level *b = current_binding_level;
1034 if (TREE_CODE (x) != TYPE_DECL)
1035 DECL_CONTEXT (x) = current_function_decl;
1038 t = lookup_name_current_level (name);
1039 if (t != 0 && t == error_mark_node)
1040 /* error_mark_node is 0 for a while during initialization! */
1043 error ("%J'%D' used prior to declaration", x, x);
1046 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1047 to point to the TYPE_DECL.
1048 Since Java does not have typedefs, a type can only have
1049 one (true) name, given by a class, interface, or builtin. */
1050 if (TREE_CODE (x) == TYPE_DECL
1051 && TYPE_NAME (TREE_TYPE (x)) == 0
1052 && TREE_TYPE (x) != error_mark_node)
1054 TYPE_NAME (TREE_TYPE (x)) = x;
1055 TYPE_STUB_DECL (TREE_TYPE (x)) = x;
1058 /* This name is new in its binding level.
1059 Install the new declaration and return it. */
1060 if (b == global_binding_level)
1062 /* Install a global value. */
1064 IDENTIFIER_GLOBAL_VALUE (name) = x;
1068 /* Here to install a non-global value. */
1069 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1070 IDENTIFIER_LOCAL_VALUE (name) = x;
1073 /* Warn if shadowing an argument at the top level of the body. */
1074 if (oldlocal != 0 && !DECL_EXTERNAL (x)
1075 /* This warning doesn't apply to the parms of a nested fcn. */
1076 && ! current_binding_level->parm_flag
1077 /* Check that this is one level down from the parms. */
1078 && current_binding_level->level_chain->parm_flag
1079 /* Check that the decl being shadowed
1080 comes from the parm level, one level up. */
1081 && chain_member (oldlocal, current_binding_level->level_chain->names))
1083 if (TREE_CODE (oldlocal) == PARM_DECL)
1084 pedwarn ("declaration of `%s' shadows a parameter",
1085 IDENTIFIER_POINTER (name));
1087 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1088 IDENTIFIER_POINTER (name));
1091 /* Maybe warn if shadowing something else. */
1092 else if (warn_shadow && !DECL_EXTERNAL (x)
1093 /* No shadow warnings for internally generated vars. */
1094 && DECL_SOURCE_LINE (x) != 0
1095 /* No shadow warnings for vars made for inlining. */
1096 && ! DECL_FROM_INLINE (x))
1098 const char *warnstring = 0;
1100 if (TREE_CODE (x) == PARM_DECL
1101 && current_binding_level->level_chain->parm_flag)
1102 /* Don't warn about the parm names in function declarator
1103 within a function declarator.
1104 It would be nice to avoid warning in any function
1105 declarator in a declaration, as opposed to a definition,
1106 but there is no way to tell it's not a definition. */
1108 else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
1109 warnstring = "declaration of `%s' shadows a parameter";
1110 else if (oldlocal != 0)
1111 warnstring = "declaration of `%s' shadows previous local";
1112 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
1113 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
1114 warnstring = "declaration of `%s' shadows global declaration";
1117 warning (warnstring, IDENTIFIER_POINTER (name));
1121 /* If storing a local value, there may already be one (inherited).
1122 If so, record it for restoration when this binding level ends. */
1124 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1128 /* Put decls on list in reverse order.
1129 We will reverse them later if necessary. */
1130 TREE_CHAIN (x) = b->names;
1137 pushdecl_force_head (tree x)
1139 current_binding_level->names = x;
1142 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1145 pushdecl_top_level (tree x)
1148 register struct binding_level *b = current_binding_level;
1150 current_binding_level = global_binding_level;
1152 current_binding_level = b;
1156 /* Nonzero if we are currently in the global binding level. */
1159 global_bindings_p (void)
1161 return current_binding_level == global_binding_level;
1164 /* Return the list of declarations of the current level.
1165 Note that this list is in reverse order unless/until
1166 you nreverse it; and when you do nreverse it, you must
1167 store the result back using `storedecls' or you will lose. */
1172 return current_binding_level->names;
1175 /* Create a new `struct binding_level'. */
1177 static struct binding_level *
1178 make_binding_level (void)
1181 return xmalloc (sizeof (struct binding_level));
1185 pushlevel (int unused ATTRIBUTE_UNUSED)
1187 register struct binding_level *newlevel = NULL_BINDING_LEVEL;
1190 /* If this is the top level of a function,
1191 just make sure that NAMED_LABELS is 0. */
1193 if (current_binding_level == global_binding_level)
1197 /* Reuse or create a struct for this binding level. */
1199 if (free_binding_level)
1201 newlevel = free_binding_level;
1202 free_binding_level = free_binding_level->level_chain;
1206 newlevel = make_binding_level ();
1209 /* Add this level to the front of the chain (stack) of levels that
1212 *newlevel = clear_binding_level;
1213 newlevel->level_chain = current_binding_level;
1214 current_binding_level = newlevel;
1215 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1216 newlevel->binding_depth = binding_depth;
1218 fprintf (stderr, "push %s level 0x%08x pc %d\n",
1219 (is_class_level) ? "class" : "block", newlevel, current_pc);
1222 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1225 /* Exit a binding level.
1226 Pop the level off, and restore the state of the identifier-decl mappings
1227 that were in effect when this level was entered.
1229 If KEEP is nonzero, this level had explicit declarations, so
1230 and create a "block" (a BLOCK node) for the level
1231 to record its declarations and subblocks for symbol table output.
1233 If FUNCTIONBODY is nonzero, this level is the body of a function,
1234 so create a block as if KEEP were set and also clear out all
1237 If REVERSE is nonzero, reverse the order of decls before putting
1238 them into the BLOCK. */
1241 poplevel (int keep, int reverse, int functionbody)
1244 /* The chain of decls was accumulated in reverse order.
1245 Put it into forward order, just for cleanliness. */
1247 tree subblocks = current_binding_level->blocks;
1250 int block_previously_created;
1252 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1255 if (current_binding_level->end_pc != LARGEST_PC)
1256 fprintf (stderr, "pop %s level 0x%08x pc %d (end pc %d)\n",
1257 (is_class_level) ? "class" : "block", current_binding_level, current_pc,
1258 current_binding_level->end_pc);
1260 fprintf (stderr, "pop %s level 0x%08x pc %d\n",
1261 (is_class_level) ? "class" : "block", current_binding_level, current_pc);
1263 if (is_class_level != (current_binding_level == class_binding_level))
1266 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1270 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1272 /* Get the decls in the order they were written.
1273 Usually current_binding_level->names is in reverse order.
1274 But parameter decls were previously put in forward order. */
1277 current_binding_level->names
1278 = decls = nreverse (current_binding_level->names);
1280 decls = current_binding_level->names;
1282 /* Output any nested inline functions within this block
1283 if they weren't already output. */
1285 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1286 if (TREE_CODE (decl) == FUNCTION_DECL
1287 && ! TREE_ASM_WRITTEN (decl)
1288 && DECL_INITIAL (decl) != 0
1289 && TREE_ADDRESSABLE (decl))
1291 /* If this decl was copied from a file-scope decl
1292 on account of a block-scope extern decl,
1293 propagate TREE_ADDRESSABLE to the file-scope decl.
1295 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1296 true, since then the decl goes through save_for_inline_copying. */
1297 if (DECL_ABSTRACT_ORIGIN (decl) != 0
1298 && DECL_ABSTRACT_ORIGIN (decl) != decl)
1299 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1302 push_function_context ();
1303 output_inline_function (decl);
1304 pop_function_context ();
1308 /* If there were any declarations in that level,
1309 or if this level is a function body,
1310 create a BLOCK to record them for the life of this function. */
1313 block_previously_created = (current_binding_level->this_block != 0);
1314 if (block_previously_created)
1315 block = current_binding_level->this_block;
1316 else if (keep || functionbody)
1317 block = make_node (BLOCK);
1320 BLOCK_VARS (block) = decls;
1321 BLOCK_SUBBLOCKS (block) = subblocks;
1324 /* In each subblock, record that this is its superior. */
1326 for (link = subblocks; link; link = TREE_CHAIN (link))
1327 BLOCK_SUPERCONTEXT (link) = block;
1329 /* Clear out the meanings of the local variables of this level. */
1331 for (link = decls; link; link = TREE_CHAIN (link))
1333 tree name = DECL_NAME (link);
1334 if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
1336 /* If the ident. was used or addressed via a local extern decl,
1337 don't forget that fact. */
1338 if (DECL_EXTERNAL (link))
1340 if (TREE_USED (link))
1341 TREE_USED (name) = 1;
1342 if (TREE_ADDRESSABLE (link))
1343 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1345 IDENTIFIER_LOCAL_VALUE (name) = 0;
1349 /* Restore all name-meanings of the outer levels
1350 that were shadowed by this level. */
1352 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1353 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1355 /* If the level being exited is the top level of a function,
1356 check over all the labels, and clear out the current
1357 (function local) meanings of their names. */
1361 /* If this is the top level block of a function,
1362 the vars are the function's parameters.
1363 Don't leave them in the BLOCK because they are
1364 found in the FUNCTION_DECL instead. */
1366 BLOCK_VARS (block) = 0;
1368 /* Clear out the definitions of all label names,
1369 since their scopes end here,
1370 and add them to BLOCK_VARS. */
1373 for (link = named_labels; link; link = TREE_CHAIN (link))
1375 register tree label = TREE_VALUE (link);
1377 if (DECL_INITIAL (label) == 0)
1379 error ("%Jlabel '%D' used but not defined", label, label);
1380 /* Avoid crashing later. */
1381 define_label (input_location, DECL_NAME (label));
1383 else if (warn_unused[UNUSED_LABEL] && !TREE_USED (label))
1384 warning ("%Jlabel '%D' defined but not used", label, label);
1385 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1387 /* Put the labels into the "variables" of the
1388 top-level block, so debugger can see them. */
1389 TREE_CHAIN (label) = BLOCK_VARS (block);
1390 BLOCK_VARS (block) = label;
1395 /* Pop the current level, and free the structure for reuse. */
1398 register struct binding_level *level = current_binding_level;
1399 current_binding_level = current_binding_level->level_chain;
1401 level->level_chain = free_binding_level;
1402 free_binding_level = level;
1405 /* Dispose of the block that we just made inside some higher level. */
1407 DECL_INITIAL (current_function_decl) = block;
1410 if (!block_previously_created)
1411 current_binding_level->blocks
1412 = chainon (current_binding_level->blocks, block);
1414 /* If we did not make a block for the level just exited,
1415 any blocks made for inner levels
1416 (since they cannot be recorded as subblocks in that level)
1417 must be carried forward so they will later become subblocks
1418 of something else. */
1420 current_binding_level->blocks
1421 = chainon (current_binding_level->blocks, subblocks);
1423 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1424 binding contour so that they point to the appropriate construct, i.e.
1425 either to the current FUNCTION_DECL node, or else to the BLOCK node
1426 we just constructed.
1428 Note that for tagged types whose scope is just the formal parameter
1429 list for some function type specification, we can't properly set
1430 their TYPE_CONTEXTs here, because we don't have a pointer to the
1431 appropriate FUNCTION_TYPE node readily available to us. For those
1432 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1433 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1434 node which will represent the "scope" for these "parameter list local"
1439 TREE_USED (block) = 1;
1444 maybe_pushlevels (int pc)
1446 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1450 while (pending_local_decls != NULL_TREE &&
1451 DECL_LOCAL_START_PC (pending_local_decls) <= pc)
1453 tree *ptr = &pending_local_decls;
1455 int end_pc = DECL_LOCAL_END_PC (decl);
1457 while (*ptr != NULL_TREE
1458 && DECL_LOCAL_START_PC (*ptr) <= pc
1459 && DECL_LOCAL_END_PC (*ptr) == end_pc)
1460 ptr = &TREE_CHAIN (*ptr);
1461 pending_local_decls = *ptr;
1464 /* Force non-nested range to be nested in current range. */
1465 if (end_pc > current_binding_level->end_pc)
1466 end_pc = current_binding_level->end_pc;
1468 maybe_start_try (pc, end_pc);
1471 expand_start_bindings (0);
1473 current_binding_level->end_pc = end_pc;
1474 current_binding_level->start_pc = pc;
1475 current_binding_level->names = decl;
1476 for ( ; decl != NULL_TREE; decl = TREE_CHAIN (decl))
1478 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl);
1482 maybe_start_try (pc, 0);
1486 maybe_poplevels (int pc)
1488 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1492 while (current_binding_level->end_pc <= pc)
1494 expand_end_bindings (getdecls (), 1, 0);
1495 maybe_end_try (current_binding_level->start_pc, pc);
1498 maybe_end_try (0, pc);
1501 /* Terminate any binding which began during the range beginning at
1502 start_pc. This tidies up improperly nested local variable ranges
1503 and exception handlers; a variable declared within an exception
1504 range is forcibly terminated when that exception ends. */
1507 force_poplevels (int start_pc)
1509 while (current_binding_level->start_pc > start_pc)
1511 if (pedantic && current_binding_level->start_pc > start_pc)
1512 warning ("%JIn %D: overlapped variable and exception ranges at %d",
1513 current_function_decl, current_function_decl,
1514 current_binding_level->start_pc);
1515 expand_end_bindings (getdecls (), 1, 0);
1520 /* Insert BLOCK at the end of the list of subblocks of the
1521 current binding level. This is used when a BIND_EXPR is expanded,
1522 to handle the BLOCK node inside the BIND_EXPR. */
1525 insert_block (tree block)
1527 TREE_USED (block) = 1;
1528 current_binding_level->blocks
1529 = chainon (current_binding_level->blocks, block);
1532 /* Set the BLOCK node for the innermost scope
1533 (the one we are currently in). */
1536 set_block (tree block)
1538 current_binding_level->this_block = block;
1539 current_binding_level->names = chainon (current_binding_level->names,
1540 BLOCK_VARS (block));
1541 current_binding_level->blocks = chainon (current_binding_level->blocks,
1542 BLOCK_SUBBLOCKS (block));
1545 /* integrate_decl_tree calls this function. */
1548 java_dup_lang_specific_decl (tree node)
1551 struct lang_decl *x;
1553 if (!DECL_LANG_SPECIFIC (node))
1556 lang_decl_size = sizeof (struct lang_decl);
1557 x = ggc_alloc (lang_decl_size);
1558 memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
1559 DECL_LANG_SPECIFIC (node) = x;
1563 give_name_to_locals (JCF *jcf)
1565 int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
1566 int code_offset = DECL_CODE_OFFSET (current_function_decl);
1568 pending_local_decls = NULL_TREE;
1572 n = JCF_readu2 (jcf);
1573 for (i = 0; i < n; i++)
1575 int start_pc = JCF_readu2 (jcf);
1576 int length = JCF_readu2 (jcf);
1577 int name_index = JCF_readu2 (jcf);
1578 int signature_index = JCF_readu2 (jcf);
1579 int slot = JCF_readu2 (jcf);
1580 tree name = get_name_constant (jcf, name_index);
1581 tree type = parse_signature (jcf, signature_index);
1582 if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
1584 && length == DECL_CODE_LENGTH (current_function_decl))
1586 tree decl = TREE_VEC_ELT (decl_map, slot);
1587 DECL_NAME (decl) = name;
1588 SET_DECL_ASSEMBLER_NAME (decl, name);
1589 if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
1590 warning ("bad type in parameter debug info");
1595 int end_pc = start_pc + length;
1596 tree decl = build_decl (VAR_DECL, name, type);
1597 if (end_pc > DECL_CODE_LENGTH (current_function_decl))
1599 warning ("%Jbad PC range for debug info for local '%D'",
1601 end_pc = DECL_CODE_LENGTH (current_function_decl);
1604 /* Adjust start_pc if necessary so that the local's first
1605 store operation will use the relevant DECL as a
1606 destination. Fore more information, read the leading
1607 comments for expr.c:maybe_adjust_start_pc. */
1608 start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot);
1610 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1611 DECL_LOCAL_SLOT_NUMBER (decl) = slot;
1612 DECL_LOCAL_START_PC (decl) = start_pc;
1614 /* FIXME: The range used internally for exceptions and local
1615 variable ranges, is a half-open interval:
1616 start_pc <= pc < end_pc. However, the range used in the
1617 Java VM spec is inclusive at both ends:
1618 start_pc <= pc <= end_pc. */
1621 DECL_LOCAL_END_PC (decl) = end_pc;
1623 /* Now insert the new decl in the proper place in
1624 pending_local_decls. We are essentially doing an insertion sort,
1625 which works fine, since the list input will normally already
1627 ptr = &pending_local_decls;
1628 while (*ptr != NULL_TREE
1629 && (DECL_LOCAL_START_PC (*ptr) > start_pc
1630 || (DECL_LOCAL_START_PC (*ptr) == start_pc
1631 && DECL_LOCAL_END_PC (*ptr) < end_pc)))
1632 ptr = &TREE_CHAIN (*ptr);
1633 TREE_CHAIN (decl) = *ptr;
1638 pending_local_decls = nreverse (pending_local_decls);
1640 /* Fill in default names for the parameters. */
1641 for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
1642 parm != NULL_TREE; parm = TREE_CHAIN (parm), i++)
1644 if (DECL_NAME (parm) == NULL_TREE)
1646 int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
1648 DECL_NAME (parm) = get_identifier ("this");
1652 sprintf (buffer, "ARG_%d", arg_i);
1653 DECL_NAME (parm) = get_identifier (buffer);
1655 SET_DECL_ASSEMBLER_NAME (parm, DECL_NAME (parm));
1661 build_result_decl (tree fndecl)
1663 tree restype = TREE_TYPE (TREE_TYPE (fndecl));
1664 tree result = DECL_RESULT (fndecl);
1667 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1668 if (INTEGRAL_TYPE_P (restype)
1669 && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
1670 restype = integer_type_node;
1671 result = build_decl (RESULT_DECL, NULL_TREE, restype);
1672 DECL_CONTEXT (result) = fndecl;
1673 DECL_RESULT (fndecl) = result;
1679 complete_start_java_method (tree fndecl)
1681 if (! flag_emit_class_files)
1683 /* Initialize the RTL code for the function. */
1684 init_function_start (fndecl);
1686 /* Set up parameters and prepare for return, for the function. */
1687 expand_function_start (fndecl, 0);
1691 /* If this fcn was already referenced via a block-scope `extern' decl (or
1692 an implicit decl), propagate certain information about the usage. */
1693 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
1694 TREE_ADDRESSABLE (current_function_decl) = 1;
1698 if (METHOD_STATIC (fndecl) && ! METHOD_PRIVATE (fndecl)
1699 && ! flag_emit_class_files
1700 && ! DECL_CLINIT_P (fndecl)
1701 && ! CLASS_INTERFACE (TYPE_NAME (current_class)))
1703 tree clas = DECL_CONTEXT (fndecl);
1704 tree init = build (CALL_EXPR, void_type_node,
1705 build_address_of (soft_initclass_node),
1706 build_tree_list (NULL_TREE, build_class_ref (clas)),
1708 TREE_SIDE_EFFECTS (init) = 1;
1709 expand_expr_stmt (init);
1712 /* Push local variables. Function compiled from source code are
1713 using a different local variables management, and for them,
1714 pushlevel shouldn't be called from here. */
1715 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1718 if (! flag_emit_class_files)
1719 expand_start_bindings (1);
1722 if (METHOD_SYNCHRONIZED (fndecl) && ! flag_emit_class_files)
1724 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1725 tree enter, exit, lock;
1726 if (METHOD_STATIC (fndecl))
1727 lock = build_class_ref (DECL_CONTEXT (fndecl));
1729 lock = DECL_ARGUMENTS (fndecl);
1730 BUILD_MONITOR_ENTER (enter, lock);
1731 BUILD_MONITOR_EXIT (exit, lock);
1732 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1734 expand_expr_stmt (enter);
1735 expand_decl_cleanup (NULL_TREE, exit);
1739 tree function_body = DECL_FUNCTION_BODY (fndecl);
1740 tree body = BLOCK_EXPR_BODY (function_body);
1741 lock = build (COMPOUND_EXPR, void_type_node,
1743 build (TRY_FINALLY_EXPR, void_type_node, body, exit));
1744 TREE_SIDE_EFFECTS (lock) = 1;
1745 BLOCK_EXPR_BODY (function_body) = lock;
1751 start_java_method (tree fndecl)
1756 current_function_decl = fndecl;
1757 announce_function (fndecl);
1759 i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
1760 decl_map = make_tree_vec (i);
1761 type_map = xrealloc (type_map, i * sizeof (tree));
1763 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1764 fprintf (stderr, "%s:\n", lang_printable_name (fndecl, 2));
1766 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1767 pushlevel (1); /* Push parameters. */
1769 ptr = &DECL_ARGUMENTS (fndecl);
1770 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
1771 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
1773 tree parm_name = NULL_TREE, parm_decl;
1774 tree parm_type = TREE_VALUE (tem);
1775 if (i >= DECL_MAX_LOCALS (fndecl))
1778 parm_decl = build_decl (PARM_DECL, parm_name, parm_type);
1779 DECL_CONTEXT (parm_decl) = fndecl;
1780 if (PROMOTE_PROTOTYPES
1781 && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
1782 && INTEGRAL_TYPE_P (parm_type))
1783 parm_type = integer_type_node;
1784 DECL_ARG_TYPE (parm_decl) = parm_type;
1787 ptr = &TREE_CHAIN (parm_decl);
1789 /* Add parm_decl to the decl_map. */
1790 push_jvm_slot (i, parm_decl);
1792 type_map[i] = TREE_TYPE (parm_decl);
1793 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
1796 type_map[i] = void_type_node;
1800 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
1802 while (i < DECL_MAX_LOCALS(fndecl))
1803 type_map[i++] = NULL_TREE;
1805 build_result_decl (fndecl);
1806 complete_start_java_method (fndecl);
1810 end_java_method (void)
1812 tree fndecl = current_function_decl;
1814 expand_end_bindings (getdecls (), 1, 0);
1815 /* pop out of function */
1818 /* pop out of its parameters */
1821 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1823 /* Generate rtl for function exit. */
1824 expand_function_end ();
1826 /* Run the optimizers and output assembler code for this function. */
1827 rest_of_compilation (fndecl);
1829 current_function_decl = NULL_TREE;
1832 /* Expand a function's body. */
1835 java_expand_body (tree fndecl)
1837 location_t saved_location = input_location;
1839 current_function_decl = fndecl;
1840 input_location = DECL_SOURCE_LOCATION (fndecl);
1842 timevar_push (TV_EXPAND);
1844 /* Prepare the function for tree completion. */
1845 start_complete_expand_method (fndecl);
1847 if (! flag_emit_class_files && ! flag_emit_xref)
1849 /* Initialize the RTL code for the function. */
1850 init_function_start (fndecl);
1852 /* Set up parameters and prepare for return, for the function. */
1853 expand_function_start (fndecl, 0);
1855 /* Generate the RTL for this function. */
1856 expand_expr_stmt_value (DECL_SAVED_TREE (fndecl), 0, 1);
1859 /* Pop out of its parameters. */
1860 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
1862 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1864 if (! flag_emit_class_files && ! flag_emit_xref)
1866 /* Generate RTL for function exit. */
1867 input_line = DECL_FUNCTION_LAST_LINE (fndecl);
1868 expand_function_end ();
1870 /* Run the optimizers and output the assembler code
1871 for this function. */
1872 rest_of_compilation (fndecl);
1875 timevar_pop (TV_EXPAND);
1877 input_location = saved_location;
1879 current_function_decl = NULL_TREE;
1882 /* We pessimistically marked all methods and fields external until we
1883 knew what set of classes we were planning to compile. Now mark those
1884 associated with CLASS to be generated locally as not external. */
1887 java_mark_decl_local (tree decl)
1889 DECL_EXTERNAL (decl) = 0;
1891 /* If we've already constructed DECL_RTL, give encode_section_info
1892 a second chance, now that we've changed the flags. */
1893 if (DECL_RTL_SET_P (decl))
1894 make_decl_rtl (decl, NULL);
1898 java_mark_class_local (tree class)
1902 for (t = TYPE_FIELDS (class); t ; t = TREE_CHAIN (t))
1903 if (FIELD_STATIC (t))
1904 java_mark_decl_local (t);
1906 for (t = TYPE_METHODS (class); t ; t = TREE_CHAIN (t))
1907 if (!METHOD_ABSTRACT (t) && (!METHOD_NATIVE (t) || flag_jni))
1908 java_mark_decl_local (t);
1911 #include "gt-java-decl.h"