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 && ! LOCAL_VAR_OUT_OF_SCOPE_P (tmp))
121 rtl = DECL_RTL_IF_SET (tmp);
124 tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
127 SET_DECL_RTL (decl, rtl);
130 if (index >= DECL_MAX_LOCALS (current_function_decl))
131 DECL_REGISTER (decl) = 1;
135 /* Now link the decl into the decl_map. */
136 if (DECL_LANG_SPECIFIC (decl) == NULL)
138 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
139 DECL_LOCAL_START_PC (decl) = 0;
140 DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
141 DECL_LOCAL_SLOT_NUMBER (decl) = index;
143 DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
144 TREE_VEC_ELT (decl_map, index) = decl;
148 /* Find out if 'decl' passed in fits the defined PC location better than
149 'best'. Return decl if it does, return best if it doesn't. If decl
150 is returned, then updated is set to true. */
153 check_local_named_variable (tree best, tree decl, int pc, int *updated)
155 if (pc >= DECL_LOCAL_START_PC (decl)
156 && pc < DECL_LOCAL_END_PC (decl))
158 if (best == NULL_TREE
159 || (DECL_LOCAL_START_PC (decl) > DECL_LOCAL_START_PC (best)
160 && DECL_LOCAL_END_PC (decl) < DECL_LOCAL_END_PC (best)))
170 /* Find the best declaration based upon type. If 'decl' fits 'type' better
171 than 'best', return 'decl'. Otherwise return 'best'. */
174 check_local_unnamed_variable (tree best, tree decl, tree type)
176 if (TREE_TYPE (decl) == type
177 || (TREE_CODE (TREE_TYPE (decl)) == TREE_CODE (type)
178 && TYPE_PRECISION (TREE_TYPE (decl)) <= 32
179 && TYPE_PRECISION (type) <= 32
180 && TREE_CODE (type) != POINTER_TYPE)
181 || (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
182 && type == ptr_type_node))
184 if (best == NULL_TREE
185 || (TREE_TYPE (decl) == type && TREE_TYPE (best) != type))
193 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
194 that is valid at PC (or -1 if any pc).
195 If there is no existing matching decl, allocate one. */
198 find_local_variable (int index, tree type, int pc)
200 tree decl = TREE_VEC_ELT (decl_map, index);
201 tree best = NULL_TREE;
202 int found_scoped_var = 0;
204 /* Scan through every declaration that has been created in this slot. */
205 while (decl != NULL_TREE)
207 /* Variables created in give_name_to_locals() have a name and have
208 a specified scope, so we can handle them specifically. We want
209 to use the specific decls created for those so they are assigned
210 the right variables in the debugging information. */
211 if (DECL_NAME (decl) != NULL_TREE)
213 /* This is a variable we have a name for, so it has a scope
214 supplied in the class file. But it only matters when we
215 actually have a PC to use. If pc<0, then we are asking
216 for a stack slot and this decl won't be one of those. */
218 best = check_local_named_variable (best, decl, pc,
221 /* We scan for type information unless we found a variable in the
222 proper scope already. */
223 else if (!found_scoped_var)
225 /* If we don't have scoping information for a variable, we use
226 a different method to look it up. */
227 best = check_local_unnamed_variable (best, decl, type);
230 decl = DECL_LOCAL_SLOT_CHAIN (decl);
233 if (best != NULL_TREE)
236 /* If we don't find a match, create one with the type passed in. */
237 return push_jvm_slot (index, build_decl (VAR_DECL, NULL_TREE, type));
241 /* Same as find_local_index, except that INDEX is a stack index. */
244 find_stack_slot (int index, tree type)
246 return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
252 /* A chain of _DECL nodes for all variables, constants, functions,
253 * and typedef types. These are in the reverse of the order supplied.
257 /* For each level, a list of shadowed outer-level local definitions
258 to be restored when this level is popped.
259 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
260 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
263 /* For each level (except not the global one),
264 a chain of BLOCK nodes for all the levels
265 that were entered and exited one level down. */
268 /* The BLOCK node for this level, if one has been preallocated.
269 If 0, the BLOCK is allocated (if needed) when the level is popped. */
272 /* The binding level which this one is contained in (inherits from). */
273 struct binding_level *level_chain;
275 /* The bytecode PC that marks the end of this level. */
277 /* The bytecode PC that marks the start of this level. */
280 #if defined(DEBUG_JAVA_BINDING_LEVELS)
281 /* Binding depth at which this level began. */
282 unsigned binding_depth;
283 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
286 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
288 /* The binding level currently in effect. */
290 static struct binding_level *current_binding_level;
292 /* A chain of binding_level structures awaiting reuse. */
294 static struct binding_level *free_binding_level;
296 /* The outermost binding level, for names of file scope.
297 This is created when the compiler is started and exists
298 through the entire run. */
300 static struct binding_level *global_binding_level;
302 /* A PC value bigger than any PC value we may ever may encounter. */
304 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
306 /* Binding level structures are initialized by copying this one. */
308 static const struct binding_level clear_binding_level
309 = {NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
310 NULL_BINDING_LEVEL, LARGEST_PC, 0};
313 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
314 that have names. Here so we can clear out their names' definitions
315 at the end of the function. */
317 static tree named_labels;
319 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
321 static tree shadowed_labels;
324 tree java_global_trees[JTI_MAX];
326 /* Build (and pushdecl) a "promoted type" for all standard
327 types shorter than int. */
330 push_promoted_type (const char *name, tree actual_type)
332 tree type = make_node (TREE_CODE (actual_type));
334 tree in_min = TYPE_MIN_VALUE (int_type_node);
335 tree in_max = TYPE_MAX_VALUE (int_type_node);
337 tree in_min = TYPE_MIN_VALUE (actual_type);
338 tree in_max = TYPE_MAX_VALUE (actual_type);
340 TYPE_MIN_VALUE (type) = copy_node (in_min);
341 TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
342 TYPE_MAX_VALUE (type) = copy_node (in_max);
343 TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
344 TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
346 pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
350 /* Return a definition for a builtin function named NAME and whose data type
351 is TYPE. TYPE should be a function type with argument types.
352 FUNCTION_CODE tells later passes how to compile calls to this function.
353 See tree.h for its possible values.
355 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
356 the name to be called if we can't opencode the function. If
357 ATTRS is nonzero, use that for the function's attribute list. */
360 builtin_function (const char *name,
363 enum built_in_class class,
364 const char *library_name,
365 tree attrs ATTRIBUTE_UNUSED)
367 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
368 DECL_EXTERNAL (decl) = 1;
369 TREE_PUBLIC (decl) = 1;
371 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
372 make_decl_rtl (decl, NULL);
374 DECL_BUILT_IN_CLASS (decl) = class;
375 DECL_FUNCTION_CODE (decl) = function_code;
379 /* Return tree that represents a vtable for a primitive array. */
381 create_primitive_vtable (const char *name)
386 sprintf (buf, "_Jv_%sVTable", name);
387 r = build_decl (VAR_DECL, get_identifier (buf), ptr_type_node);
388 DECL_EXTERNAL (r) = 1;
393 java_init_decl_processing (void)
396 tree field = NULL_TREE;
399 init_class_processing ();
400 init_resource_processing ();
402 current_function_decl = NULL;
403 current_binding_level = NULL_BINDING_LEVEL;
404 free_binding_level = NULL_BINDING_LEVEL;
405 pushlevel (0); /* make the binding_level structure for global names */
406 global_binding_level = current_binding_level;
408 /* The code here must be similar to build_common_tree_nodes{,_2} in
409 tree.c, especially as to the order of initializing common nodes. */
410 error_mark_node = make_node (ERROR_MARK);
411 TREE_TYPE (error_mark_node) = error_mark_node;
413 /* Create sizetype first - needed for other types. */
414 initialize_sizetypes ();
416 byte_type_node = make_signed_type (8);
417 pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"), byte_type_node));
418 short_type_node = make_signed_type (16);
419 pushdecl (build_decl (TYPE_DECL, get_identifier ("short"), short_type_node));
420 int_type_node = make_signed_type (32);
421 pushdecl (build_decl (TYPE_DECL, get_identifier ("int"), int_type_node));
422 long_type_node = make_signed_type (64);
423 pushdecl (build_decl (TYPE_DECL, get_identifier ("long"), long_type_node));
425 unsigned_byte_type_node = make_unsigned_type (8);
426 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned byte"),
427 unsigned_byte_type_node));
428 unsigned_short_type_node = make_unsigned_type (16);
429 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned short"),
430 unsigned_short_type_node));
431 unsigned_int_type_node = make_unsigned_type (32);
432 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
433 unsigned_int_type_node));
434 unsigned_long_type_node = make_unsigned_type (64);
435 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned long"),
436 unsigned_long_type_node));
438 set_sizetype (make_unsigned_type (POINTER_SIZE));
440 /* Define these next since types below may used them. */
441 integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0);
442 integer_zero_node = build_int_2 (0, 0);
443 integer_one_node = build_int_2 (1, 0);
444 integer_two_node = build_int_2 (2, 0);
445 integer_four_node = build_int_2 (4, 0);
446 integer_minus_one_node = build_int_2 (-1, -1);
448 /* A few values used for range checking in the lexer. */
449 decimal_int_max = build_int_2 (0x80000000, 0);
450 TREE_TYPE (decimal_int_max) = unsigned_int_type_node;
451 #if HOST_BITS_PER_WIDE_INT == 64
452 decimal_long_max = build_int_2 (0x8000000000000000LL, 0);
454 #if HOST_BITS_PER_WIDE_INT == 32
455 decimal_long_max = build_int_2 (0, 0x80000000);
457 #error "unsupported size"
460 TREE_TYPE (decimal_long_max) = unsigned_long_type_node;
462 size_zero_node = size_int (0);
463 size_one_node = size_int (1);
464 bitsize_zero_node = bitsize_int (0);
465 bitsize_one_node = bitsize_int (1);
466 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
468 long_zero_node = build_int_2 (0, 0);
469 TREE_TYPE (long_zero_node) = long_type_node;
471 void_type_node = make_node (VOID_TYPE);
472 pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
473 layout_type (void_type_node); /* Uses size_zero_node */
474 ptr_type_node = build_pointer_type (void_type_node);
475 t = make_node (VOID_TYPE);
476 layout_type (t); /* Uses size_zero_node */
477 return_address_type_node = build_pointer_type (t);
479 null_pointer_node = build_int_2 (0, 0);
480 TREE_TYPE (null_pointer_node) = ptr_type_node;
482 /* Used by the parser to represent empty statements and blocks. */
483 empty_stmt_node = build1 (NOP_EXPR, void_type_node, size_zero_node);
484 CAN_COMPLETE_NORMALLY (empty_stmt_node) = 1;
487 /* Make a type to be the domain of a few array types
488 whose domains don't really matter.
489 200 is small enough that it always fits in size_t
490 and large enough that it can hold most function names for the
491 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
492 short_array_type_node = build_prim_array_type (short_type_node, 200);
494 char_type_node = make_node (CHAR_TYPE);
495 TYPE_PRECISION (char_type_node) = 16;
496 fixup_unsigned_type (char_type_node);
497 pushdecl (build_decl (TYPE_DECL, get_identifier ("char"), char_type_node));
499 boolean_type_node = make_node (BOOLEAN_TYPE);
500 TYPE_PRECISION (boolean_type_node) = 1;
501 fixup_unsigned_type (boolean_type_node);
502 pushdecl (build_decl (TYPE_DECL, get_identifier ("boolean"),
504 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
505 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
507 promoted_byte_type_node
508 = push_promoted_type ("promoted_byte", byte_type_node);
509 promoted_short_type_node
510 = push_promoted_type ("promoted_short", short_type_node);
511 promoted_char_type_node
512 = push_promoted_type ("promoted_char", char_type_node);
513 promoted_boolean_type_node
514 = push_promoted_type ("promoted_boolean", boolean_type_node);
516 float_type_node = make_node (REAL_TYPE);
517 TYPE_PRECISION (float_type_node) = 32;
518 pushdecl (build_decl (TYPE_DECL, get_identifier ("float"),
520 layout_type (float_type_node);
522 double_type_node = make_node (REAL_TYPE);
523 TYPE_PRECISION (double_type_node) = 64;
524 pushdecl (build_decl (TYPE_DECL, get_identifier ("double"),
526 layout_type (double_type_node);
528 float_zero_node = build_real (float_type_node, dconst0);
529 double_zero_node = build_real (double_type_node, dconst0);
531 /* These are the vtables for arrays of primitives. */
532 boolean_array_vtable = create_primitive_vtable ("boolean");
533 byte_array_vtable = create_primitive_vtable ("byte");
534 char_array_vtable = create_primitive_vtable ("char");
535 short_array_vtable = create_primitive_vtable ("short");
536 int_array_vtable = create_primitive_vtable ("int");
537 long_array_vtable = create_primitive_vtable ("long");
538 float_array_vtable = create_primitive_vtable ("float");
539 double_array_vtable = create_primitive_vtable ("double");
541 /* As you're adding items here, please update the code right after
542 this section, so that the filename containing the source code of
543 the pre-defined class gets registered correctly. */
544 unqualified_object_id_node = get_identifier ("Object");
545 object_type_node = lookup_class (get_identifier ("java.lang.Object"));
546 object_ptr_type_node = promote_type (object_type_node);
547 string_type_node = lookup_class (get_identifier ("java.lang.String"));
548 string_ptr_type_node = promote_type (string_type_node);
549 class_type_node = lookup_class (get_identifier ("java.lang.Class"));
550 throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
551 exception_type_node = lookup_class (get_identifier ("java.lang.Exception"));
552 runtime_exception_type_node =
553 lookup_class (get_identifier ("java.lang.RuntimeException"));
554 error_exception_type_node =
555 lookup_class (get_identifier ("java.lang.Error"));
557 rawdata_ptr_type_node
558 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
560 add_predefined_file (get_identifier ("java/lang/Class.java"));
561 add_predefined_file (get_identifier ("java/lang/Error.java"));
562 add_predefined_file (get_identifier ("java/lang/Object.java"));
563 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
564 add_predefined_file (get_identifier ("java/lang/String.java"));
565 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
566 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
567 add_predefined_file (get_identifier ("java/lang/Exception.java"));
568 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
569 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
570 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
572 methodtable_type = make_node (RECORD_TYPE);
573 layout_type (methodtable_type);
574 build_decl (TYPE_DECL, get_identifier ("methodtable"), methodtable_type);
575 methodtable_ptr_type = build_pointer_type (methodtable_type);
577 TYPE_identifier_node = get_identifier ("TYPE");
578 init_identifier_node = get_identifier ("<init>");
579 clinit_identifier_node = get_identifier ("<clinit>");
580 finit_identifier_node = get_identifier ("finit$");
581 instinit_identifier_node = get_identifier ("instinit$");
582 void_signature_node = get_identifier ("()V");
583 length_identifier_node = get_identifier ("length");
584 finalize_identifier_node = get_identifier ("finalize");
585 this_identifier_node = get_identifier ("this");
586 super_identifier_node = get_identifier ("super");
587 continue_identifier_node = get_identifier ("continue");
588 access0_identifier_node = get_identifier ("access$0");
589 classdollar_identifier_node = get_identifier ("class$");
591 java_lang_cloneable_identifier_node = get_identifier ("java.lang.Cloneable");
592 java_io_serializable_identifier_node =
593 get_identifier ("java.io.Serializable");
595 /* for lack of a better place to put this stub call */
596 init_expr_processing();
598 utf8const_type = make_node (RECORD_TYPE);
599 PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
600 PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
601 FINISH_RECORD (utf8const_type);
602 utf8const_ptr_type = build_pointer_type (utf8const_type);
604 constants_type_node = make_node (RECORD_TYPE);
605 PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node);
606 PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
607 PUSH_FIELD (constants_type_node, field, "data", ptr_type_node);
608 FINISH_RECORD (constants_type_node);
609 build_decl (TYPE_DECL, get_identifier ("constants"), constants_type_node);
611 access_flags_type_node = unsigned_short_type_node;
613 dtable_type = make_node (RECORD_TYPE);
614 dtable_ptr_type = build_pointer_type (dtable_type);
616 one_elt_array_domain_type = build_index_type (integer_one_node);
617 otable_type = build_array_type (integer_type_node,
618 one_elt_array_domain_type);
619 TYPE_NONALIASED_COMPONENT (otable_type) = 1;
620 otable_ptr_type = build_pointer_type (otable_type);
621 atable_type = build_array_type (ptr_type_node,
622 one_elt_array_domain_type);
623 TYPE_NONALIASED_COMPONENT (atable_type) = 1;
624 atable_ptr_type = build_pointer_type (atable_type);
626 symbol_type = make_node (RECORD_TYPE);
627 PUSH_FIELD (symbol_type, field, "clname", utf8const_ptr_type);
628 PUSH_FIELD (symbol_type, field, "name", utf8const_ptr_type);
629 PUSH_FIELD (symbol_type, field, "signature", utf8const_ptr_type);
630 FINISH_RECORD (symbol_type);
632 symbols_array_type = build_array_type (symbol_type,
633 one_elt_array_domain_type);
634 symbols_array_ptr_type = build_pointer_type (symbols_array_type);
636 if (flag_indirect_dispatch)
638 otable_decl = build_decl (VAR_DECL, get_identifier ("otable"), otable_type);
639 DECL_EXTERNAL (otable_decl) = 1;
640 TREE_STATIC (otable_decl) = 1;
641 TREE_READONLY (otable_decl) = 1;
642 TREE_CONSTANT (otable_decl) = 1;
643 pushdecl (otable_decl);
644 otable_syms_decl = build_decl (VAR_DECL, get_identifier ("otable_syms"),
646 TREE_STATIC (otable_syms_decl) = 1;
647 TREE_CONSTANT (otable_syms_decl) = 1;
648 pushdecl (otable_syms_decl);
650 atable_decl = build_decl (VAR_DECL, get_identifier ("atable"), atable_type);
651 DECL_EXTERNAL (atable_decl) = 1;
652 TREE_STATIC (atable_decl) = 1;
653 TREE_READONLY (atable_decl) = 1;
654 TREE_CONSTANT (atable_decl) = 1;
655 pushdecl (atable_decl);
656 atable_syms_decl = build_decl (VAR_DECL, get_identifier ("atable_syms"),
658 TREE_STATIC (atable_syms_decl) = 1;
659 TREE_CONSTANT (atable_syms_decl) = 1;
660 pushdecl (atable_syms_decl);
664 tree catch_class_type = make_node (RECORD_TYPE);
665 PUSH_FIELD (catch_class_type, field, "address", utf8const_ptr_type);
666 PUSH_FIELD (catch_class_type, field, "classname", ptr_type_node);
667 FINISH_RECORD (catch_class_type);
670 = build_decl (VAR_DECL, get_identifier ("catch_classes"),
672 (catch_class_type, 0));
673 DECL_EXTERNAL (ctable_decl) = 1;
674 TREE_STATIC (ctable_decl) = 1;
675 TREE_READONLY (ctable_decl) = 1;
676 TREE_CONSTANT (ctable_decl) = 1;
677 pushdecl (ctable_decl);
680 PUSH_FIELD (object_type_node, field, "vtable", dtable_ptr_type);
681 /* This isn't exactly true, but it is what we have in the source.
682 There is an unresolved issue here, which is whether the vtable
683 should be marked by the GC. */
684 if (! flag_hash_synchronization)
685 PUSH_FIELD (object_type_node, field, "sync_info",
686 build_pointer_type (object_type_node));
687 for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
688 FIELD_PRIVATE (t) = 1;
689 FINISH_RECORD (object_type_node);
691 field_type_node = make_node (RECORD_TYPE);
692 field_ptr_type_node = build_pointer_type (field_type_node);
693 method_type_node = make_node (RECORD_TYPE);
694 method_ptr_type_node = build_pointer_type (method_type_node);
696 set_super_info (0, class_type_node, object_type_node, 0);
697 set_super_info (0, string_type_node, object_type_node, 0);
698 class_ptr_type = build_pointer_type (class_type_node);
700 PUSH_FIELD (class_type_node, field, "next", class_ptr_type);
701 PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type);
702 PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node);
703 PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type);
704 PUSH_FIELD (class_type_node, field, "constants", constants_type_node);
705 PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node);
706 PUSH_FIELD (class_type_node, field, "method_count", short_type_node);
707 PUSH_FIELD (class_type_node, field, "vtable_method_count", short_type_node);
708 PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node);
709 PUSH_FIELD (class_type_node, field, "size_in_bytes", int_type_node);
710 PUSH_FIELD (class_type_node, field, "field_count", short_type_node);
711 PUSH_FIELD (class_type_node, field, "static_field_count", short_type_node);
712 PUSH_FIELD (class_type_node, field, "vtable", dtable_ptr_type);
713 PUSH_FIELD (class_type_node, field, "otable", otable_ptr_type);
714 PUSH_FIELD (class_type_node, field, "otable_syms",
715 symbols_array_ptr_type);
716 PUSH_FIELD (class_type_node, field, "atable", atable_ptr_type);
717 PUSH_FIELD (class_type_node, field, "atable_syms",
718 symbols_array_ptr_type);
719 PUSH_FIELD (class_type_node, field, "catch_classes", ptr_type_node);
720 PUSH_FIELD (class_type_node, field, "interfaces",
721 build_pointer_type (class_ptr_type));
722 PUSH_FIELD (class_type_node, field, "loader", ptr_type_node);
723 PUSH_FIELD (class_type_node, field, "interface_count", short_type_node);
724 PUSH_FIELD (class_type_node, field, "state", byte_type_node);
725 PUSH_FIELD (class_type_node, field, "thread", ptr_type_node);
726 PUSH_FIELD (class_type_node, field, "depth", short_type_node);
727 PUSH_FIELD (class_type_node, field, "ancestors", ptr_type_node);
728 PUSH_FIELD (class_type_node, field, "idt", ptr_type_node);
729 PUSH_FIELD (class_type_node, field, "arrayclass", ptr_type_node);
730 PUSH_FIELD (class_type_node, field, "protectionDomain", ptr_type_node);
731 PUSH_FIELD (class_type_node, field, "hack_signers", ptr_type_node);
732 PUSH_FIELD (class_type_node, field, "chain", ptr_type_node);
733 for (t = TYPE_FIELDS (class_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
734 FIELD_PRIVATE (t) = 1;
735 push_super_field (class_type_node, object_type_node);
737 FINISH_RECORD (class_type_node);
738 build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node);
740 field_info_union_node = make_node (UNION_TYPE);
741 PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node);
742 PUSH_FIELD (field_info_union_node, field, "addr", ptr_type_node);
744 PUSH_FIELD (field_info_union_node, field, "idx", unsigned_short_type_node);
746 layout_type (field_info_union_node);
748 PUSH_FIELD (field_type_node, field, "name", utf8const_ptr_type);
749 PUSH_FIELD (field_type_node, field, "type", class_ptr_type);
750 PUSH_FIELD (field_type_node, field, "accflags", access_flags_type_node);
751 PUSH_FIELD (field_type_node, field, "bsize", unsigned_short_type_node);
752 PUSH_FIELD (field_type_node, field, "info", field_info_union_node);
753 FINISH_RECORD (field_type_node);
754 build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node);
756 nativecode_ptr_array_type_node
757 = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
759 PUSH_FIELD (dtable_type, field, "class", class_ptr_type);
760 PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node);
761 FINISH_RECORD (dtable_type);
762 build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
764 #define jint_type int_type_node
765 #define jint_ptr_type ptr_type_node
767 jexception_type = make_node (RECORD_TYPE);
768 PUSH_FIELD (jexception_type, field, "start_pc", ptr_type_node);
769 PUSH_FIELD (jexception_type, field, "end_pc", ptr_type_node);
770 PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node);
771 PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type);
772 FINISH_RECORD (jexception_type);
773 build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node);
774 jexception_ptr_type = build_pointer_type (jexception_type);
776 lineNumberEntry_type = make_node (RECORD_TYPE);
777 PUSH_FIELD (lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
778 PUSH_FIELD (lineNumberEntry_type, field, "start_pc", ptr_type_node);
779 FINISH_RECORD (lineNumberEntry_type);
781 lineNumbers_type = make_node (RECORD_TYPE);
782 PUSH_FIELD (lineNumbers_type, field, "length", unsigned_int_type_node);
783 FINISH_RECORD (lineNumbers_type);
785 #define instn_ptr_type_node ptr_type_node /* XXX JH */
787 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
789 PUSH_FIELD (method_type_node, field, "name", utf8const_ptr_type);
790 PUSH_FIELD (method_type_node, field, "signature", utf8const_ptr_type);
791 PUSH_FIELD (method_type_node, field, "accflags", access_flags_type_node);
792 PUSH_FIELD (method_type_node, field, "index", unsigned_short_type_node);
793 PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node);
794 PUSH_FIELD (method_type_node, field, "throws", ptr_type_node);
795 FINISH_RECORD (method_type_node);
796 build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node);
798 endlink = end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
800 t = tree_cons (NULL_TREE, class_ptr_type,
801 tree_cons (NULL_TREE, int_type_node, endlink));
802 alloc_object_node = builtin_function ("_Jv_AllocObject",
803 build_function_type (ptr_type_node, t),
804 0, NOT_BUILT_IN, NULL, NULL_TREE);
805 DECL_IS_MALLOC (alloc_object_node) = 1;
806 alloc_no_finalizer_node =
807 builtin_function ("_Jv_AllocObjectNoFinalizer",
808 build_function_type (ptr_type_node, t),
809 0, NOT_BUILT_IN, NULL, NULL_TREE);
810 DECL_IS_MALLOC (alloc_no_finalizer_node) = 1;
812 t = tree_cons (NULL_TREE, ptr_type_node, endlink);
813 soft_initclass_node = builtin_function ("_Jv_InitClass",
814 build_function_type (void_type_node,
816 0, NOT_BUILT_IN, NULL, NULL_TREE);
818 throw_node = builtin_function ("_Jv_Throw",
819 build_function_type (ptr_type_node, t),
820 0, NOT_BUILT_IN, NULL, NULL_TREE);
821 /* Mark throw_nodes as `noreturn' functions with side effects. */
822 TREE_THIS_VOLATILE (throw_node) = 1;
823 TREE_SIDE_EFFECTS (throw_node) = 1;
825 t = build_function_type (int_type_node, endlink);
826 soft_monitorenter_node
827 = builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN,
829 soft_monitorexit_node
830 = builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN,
833 t = tree_cons (NULL_TREE, int_type_node,
834 tree_cons (NULL_TREE, int_type_node, endlink));
836 = builtin_function ("_Jv_NewPrimArray",
837 build_function_type(ptr_type_node, t),
838 0, NOT_BUILT_IN, NULL, NULL_TREE);
839 DECL_IS_MALLOC (soft_newarray_node) = 1;
841 t = tree_cons (NULL_TREE, int_type_node,
842 tree_cons (NULL_TREE, class_ptr_type,
843 tree_cons (NULL_TREE, object_ptr_type_node, endlink)));
845 = builtin_function ("_Jv_NewObjectArray",
846 build_function_type (ptr_type_node, t),
847 0, NOT_BUILT_IN, NULL, NULL_TREE);
848 DECL_IS_MALLOC (soft_anewarray_node) = 1;
850 /* There is no endlink here because _Jv_NewMultiArray is a varargs
852 t = tree_cons (NULL_TREE, ptr_type_node,
853 tree_cons (NULL_TREE, int_type_node, NULL_TREE));
854 soft_multianewarray_node
855 = builtin_function ("_Jv_NewMultiArray",
856 build_function_type (ptr_type_node, t),
857 0, NOT_BUILT_IN, NULL, NULL_TREE);
858 DECL_IS_MALLOC (soft_multianewarray_node) = 1;
860 t = build_function_type (void_type_node,
861 tree_cons (NULL_TREE, int_type_node, endlink));
862 soft_badarrayindex_node
863 = builtin_function ("_Jv_ThrowBadArrayIndex", t,
864 0, NOT_BUILT_IN, NULL, NULL_TREE);
865 /* Mark soft_badarrayindex_node as a `noreturn' function with side
867 TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
868 TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
870 soft_nullpointer_node
871 = builtin_function ("_Jv_ThrowNullPointerException",
872 build_function_type (void_type_node, endlink),
873 0, NOT_BUILT_IN, NULL, NULL_TREE);
874 /* Mark soft_nullpointer_node as a `noreturn' function with side
876 TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
877 TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
879 t = tree_cons (NULL_TREE, class_ptr_type,
880 tree_cons (NULL_TREE, object_ptr_type_node, endlink));
882 = builtin_function ("_Jv_CheckCast",
883 build_function_type (ptr_type_node, t),
884 0, NOT_BUILT_IN, NULL, NULL_TREE);
885 t = tree_cons (NULL_TREE, object_ptr_type_node,
886 tree_cons (NULL_TREE, class_ptr_type, endlink));
888 = builtin_function ("_Jv_IsInstanceOf",
889 build_function_type (boolean_type_node, t),
890 0, NOT_BUILT_IN, NULL, NULL_TREE);
891 t = tree_cons (NULL_TREE, object_ptr_type_node,
892 tree_cons (NULL_TREE, object_ptr_type_node, endlink));
893 soft_checkarraystore_node
894 = builtin_function ("_Jv_CheckArrayStore",
895 build_function_type (void_type_node, t),
896 0, NOT_BUILT_IN, NULL, NULL_TREE);
897 t = tree_cons (NULL_TREE, ptr_type_node,
898 tree_cons (NULL_TREE, ptr_type_node,
899 tree_cons (NULL_TREE, int_type_node, endlink)));
900 soft_lookupinterfacemethod_node
901 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
902 build_function_type (ptr_type_node, t),
903 0, NOT_BUILT_IN, NULL, NULL_TREE);
905 t = tree_cons (NULL_TREE, object_ptr_type_node,
906 tree_cons (NULL_TREE, ptr_type_node,
907 tree_cons (NULL_TREE, ptr_type_node,
908 tree_cons (NULL_TREE, int_type_node,
910 soft_lookupjnimethod_node
911 = builtin_function ("_Jv_LookupJNIMethod",
912 build_function_type (ptr_type_node, t),
913 0, NOT_BUILT_IN, NULL, NULL_TREE);
914 t = tree_cons (NULL_TREE, ptr_type_node, endlink);
915 soft_getjnienvnewframe_node
916 = builtin_function ("_Jv_GetJNIEnvNewFrame",
917 build_function_type (ptr_type_node, t),
918 0, NOT_BUILT_IN, NULL, NULL_TREE);
919 soft_jnipopsystemframe_node
920 = builtin_function ("_Jv_JNI_PopSystemFrame",
921 build_function_type (ptr_type_node, t),
922 0, NOT_BUILT_IN, NULL, NULL_TREE);
925 = builtin_function ("_Jv_divI",
926 build_function_type (int_type_node, t),
927 0, NOT_BUILT_IN, NULL, NULL_TREE);
930 = builtin_function ("_Jv_remI",
931 build_function_type (int_type_node, t),
932 0, NOT_BUILT_IN, NULL, NULL_TREE);
935 = builtin_function ("_Jv_divJ",
936 build_function_type (long_type_node, t),
937 0, NOT_BUILT_IN, NULL, NULL_TREE);
940 = builtin_function ("_Jv_remJ",
941 build_function_type (long_type_node, t),
942 0, NOT_BUILT_IN, NULL, NULL_TREE);
944 /* Initialize variables for except.c. */
945 eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
946 ? "__gcj_personality_sj0"
947 : "__gcj_personality_v0");
948 lang_eh_runtime_type = prepare_eh_table_type;
952 initialize_builtins ();
954 soft_fmod_node = built_in_decls[BUILT_IN_FMOD];
956 soft_fmodf_node = built_in_decls[BUILT_IN_FMODF];
961 /* Look up NAME in the current binding level and its superiors
962 in the namespace of variables, functions and typedefs.
963 Return a ..._DECL node of some kind representing its definition,
964 or return 0 if it is undefined. */
967 lookup_name (tree name)
970 if (current_binding_level != global_binding_level
971 && IDENTIFIER_LOCAL_VALUE (name))
972 val = IDENTIFIER_LOCAL_VALUE (name);
974 val = IDENTIFIER_GLOBAL_VALUE (name);
978 /* Similar to `lookup_name' but look only at current binding level and
979 the previous one if its the parameter level. */
982 lookup_name_current_level (tree name)
986 if (current_binding_level == global_binding_level)
987 return IDENTIFIER_GLOBAL_VALUE (name);
989 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
992 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
993 if (DECL_NAME (t) == name)
999 /* Use a binding level to record a labeled block declaration */
1002 push_labeled_block (tree lb)
1004 tree name = DECL_NAME (LABELED_BLOCK_LABEL (lb));
1005 struct binding_level *b = current_binding_level;
1006 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1008 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1009 TREE_CHAIN (lb) = b->names;
1011 IDENTIFIER_LOCAL_VALUE (name) = lb;
1014 /* Pop the current binding level, reinstalling values for the previous
1018 pop_labeled_block (void)
1020 struct binding_level *b = current_binding_level;
1021 tree label = b->names;
1022 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label))) =
1025 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b->shadowed)) =
1026 TREE_VALUE (b->shadowed);
1028 /* Pop the current level, and free the structure for reuse. */
1029 current_binding_level = current_binding_level->level_chain;
1030 b->level_chain = free_binding_level;
1031 free_binding_level = b;
1034 /* Record a decl-node X as belonging to the current lexical scope.
1035 Check for errors (such as an incompatible declaration for the same
1036 name already seen in the same scope).
1038 Returns either X or an old decl for the same name.
1039 If an old decl is returned, it may have been smashed
1040 to agree with what X says. */
1046 tree name = DECL_NAME (x);
1047 struct binding_level *b = current_binding_level;
1049 if (TREE_CODE (x) != TYPE_DECL)
1050 DECL_CONTEXT (x) = current_function_decl;
1053 t = lookup_name_current_level (name);
1054 if (t != 0 && t == error_mark_node)
1055 /* error_mark_node is 0 for a while during initialization! */
1058 error ("%J'%D' used prior to declaration", x, x);
1061 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1062 to point to the TYPE_DECL.
1063 Since Java does not have typedefs, a type can only have
1064 one (true) name, given by a class, interface, or builtin. */
1065 if (TREE_CODE (x) == TYPE_DECL
1066 && TYPE_NAME (TREE_TYPE (x)) == 0
1067 && TREE_TYPE (x) != error_mark_node)
1069 TYPE_NAME (TREE_TYPE (x)) = x;
1070 TYPE_STUB_DECL (TREE_TYPE (x)) = x;
1073 /* This name is new in its binding level.
1074 Install the new declaration and return it. */
1075 if (b == global_binding_level)
1077 /* Install a global value. */
1079 IDENTIFIER_GLOBAL_VALUE (name) = x;
1083 /* Here to install a non-global value. */
1084 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1085 IDENTIFIER_LOCAL_VALUE (name) = x;
1088 /* Warn if shadowing an argument at the top level of the body. */
1089 if (oldlocal != 0 && !DECL_EXTERNAL (x)
1090 /* This warning doesn't apply to the parms of a nested fcn. */
1091 && ! current_binding_level->parm_flag
1092 /* Check that this is one level down from the parms. */
1093 && current_binding_level->level_chain->parm_flag
1094 /* Check that the decl being shadowed
1095 comes from the parm level, one level up. */
1096 && chain_member (oldlocal, current_binding_level->level_chain->names))
1098 if (TREE_CODE (oldlocal) == PARM_DECL)
1099 pedwarn ("declaration of `%s' shadows a parameter",
1100 IDENTIFIER_POINTER (name));
1102 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1103 IDENTIFIER_POINTER (name));
1106 /* Maybe warn if shadowing something else. */
1107 else if (warn_shadow && !DECL_EXTERNAL (x)
1108 /* No shadow warnings for internally generated vars. */
1109 && DECL_SOURCE_LINE (x) != 0
1110 /* No shadow warnings for vars made for inlining. */
1111 && ! DECL_FROM_INLINE (x))
1113 const char *warnstring = 0;
1115 if (TREE_CODE (x) == PARM_DECL
1116 && current_binding_level->level_chain->parm_flag)
1117 /* Don't warn about the parm names in function declarator
1118 within a function declarator.
1119 It would be nice to avoid warning in any function
1120 declarator in a declaration, as opposed to a definition,
1121 but there is no way to tell it's not a definition. */
1123 else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
1124 warnstring = "declaration of `%s' shadows a parameter";
1125 else if (oldlocal != 0)
1126 warnstring = "declaration of `%s' shadows previous local";
1127 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
1128 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
1129 warnstring = "declaration of `%s' shadows global declaration";
1132 warning (warnstring, IDENTIFIER_POINTER (name));
1136 /* If storing a local value, there may already be one (inherited).
1137 If so, record it for restoration when this binding level ends. */
1139 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1143 /* Put decls on list in reverse order.
1144 We will reverse them later if necessary. */
1145 TREE_CHAIN (x) = b->names;
1152 pushdecl_force_head (tree x)
1154 current_binding_level->names = x;
1157 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1160 pushdecl_top_level (tree x)
1163 struct binding_level *b = current_binding_level;
1165 current_binding_level = global_binding_level;
1167 current_binding_level = b;
1171 /* Nonzero if we are currently in the global binding level. */
1174 global_bindings_p (void)
1176 return current_binding_level == global_binding_level;
1179 /* Return the list of declarations of the current level.
1180 Note that this list is in reverse order unless/until
1181 you nreverse it; and when you do nreverse it, you must
1182 store the result back using `storedecls' or you will lose. */
1187 return current_binding_level->names;
1190 /* Create a new `struct binding_level'. */
1192 static struct binding_level *
1193 make_binding_level (void)
1196 return xmalloc (sizeof (struct binding_level));
1200 pushlevel (int unused ATTRIBUTE_UNUSED)
1202 struct binding_level *newlevel = NULL_BINDING_LEVEL;
1205 /* If this is the top level of a function,
1206 just make sure that NAMED_LABELS is 0. */
1208 if (current_binding_level == global_binding_level)
1212 /* Reuse or create a struct for this binding level. */
1214 if (free_binding_level)
1216 newlevel = free_binding_level;
1217 free_binding_level = free_binding_level->level_chain;
1221 newlevel = make_binding_level ();
1224 /* Add this level to the front of the chain (stack) of levels that
1227 *newlevel = clear_binding_level;
1228 newlevel->level_chain = current_binding_level;
1229 current_binding_level = newlevel;
1230 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1231 newlevel->binding_depth = binding_depth;
1233 fprintf (stderr, "push %s level 0x%08x pc %d\n",
1234 (is_class_level) ? "class" : "block", newlevel, current_pc);
1237 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1240 /* Exit a binding level.
1241 Pop the level off, and restore the state of the identifier-decl mappings
1242 that were in effect when this level was entered.
1244 If KEEP is nonzero, this level had explicit declarations, so
1245 and create a "block" (a BLOCK node) for the level
1246 to record its declarations and subblocks for symbol table output.
1248 If FUNCTIONBODY is nonzero, this level is the body of a function,
1249 so create a block as if KEEP were set and also clear out all
1252 If REVERSE is nonzero, reverse the order of decls before putting
1253 them into the BLOCK. */
1256 poplevel (int keep, int reverse, int functionbody)
1259 /* The chain of decls was accumulated in reverse order.
1260 Put it into forward order, just for cleanliness. */
1262 tree subblocks = current_binding_level->blocks;
1265 int block_previously_created;
1268 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1271 if (current_binding_level->end_pc != LARGEST_PC)
1272 fprintf (stderr, "pop %s level 0x%08x pc %d (end pc %d)\n",
1273 (is_class_level) ? "class" : "block", current_binding_level, current_pc,
1274 current_binding_level->end_pc);
1276 fprintf (stderr, "pop %s level 0x%08x pc %d\n",
1277 (is_class_level) ? "class" : "block", current_binding_level, current_pc);
1279 if (is_class_level != (current_binding_level == class_binding_level))
1282 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1286 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1288 /* Get the decls in the order they were written.
1289 Usually current_binding_level->names is in reverse order.
1290 But parameter decls were previously put in forward order. */
1293 current_binding_level->names
1294 = decls = nreverse (current_binding_level->names);
1296 decls = current_binding_level->names;
1298 /* Output any nested inline functions within this block
1299 if they weren't already output. */
1301 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1302 if (TREE_CODE (decl) == FUNCTION_DECL
1303 && ! TREE_ASM_WRITTEN (decl)
1304 && DECL_INITIAL (decl) != 0
1305 && TREE_ADDRESSABLE (decl))
1307 /* If this decl was copied from a file-scope decl on account
1308 of a block-scope extern decl, propagate TREE_ADDRESSABLE
1309 to the file-scope decl.
1311 DECL_ABSTRACT_ORIGIN can be set to itself if
1312 warn_return_type is true, since then the decl goes
1313 through save_for_inline_copying. */
1314 if (DECL_ABSTRACT_ORIGIN (decl) != 0
1315 && DECL_ABSTRACT_ORIGIN (decl) != decl)
1316 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1319 push_function_context ();
1320 output_inline_function (decl);
1321 pop_function_context ();
1324 else if (TREE_CODE (decl) == VAR_DECL
1325 && DECL_LANG_SPECIFIC (decl) != NULL
1326 && DECL_LOCAL_SLOT_NUMBER (decl))
1327 LOCAL_VAR_OUT_OF_SCOPE_P (decl) = 1;
1330 /* If there were any declarations in that level,
1331 or if this level is a function body,
1332 create a BLOCK to record them for the life of this function. */
1335 block_previously_created = (current_binding_level->this_block != 0);
1336 if (block_previously_created)
1337 block = current_binding_level->this_block;
1338 else if (keep || functionbody)
1339 block = make_node (BLOCK);
1342 BLOCK_VARS (block) = decls;
1343 BLOCK_SUBBLOCKS (block) = subblocks;
1346 /* In each subblock, record that this is its superior. */
1348 for (link = subblocks; link; link = TREE_CHAIN (link))
1349 BLOCK_SUPERCONTEXT (link) = block;
1351 /* Clear out the meanings of the local variables of this level. */
1353 for (link = decls; link; link = TREE_CHAIN (link))
1355 tree name = DECL_NAME (link);
1356 if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
1358 /* If the ident. was used or addressed via a local extern decl,
1359 don't forget that fact. */
1360 if (DECL_EXTERNAL (link))
1362 if (TREE_USED (link))
1363 TREE_USED (name) = 1;
1364 if (TREE_ADDRESSABLE (link))
1365 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1367 IDENTIFIER_LOCAL_VALUE (name) = 0;
1371 /* Restore all name-meanings of the outer levels
1372 that were shadowed by this level. */
1374 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1375 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1377 /* If the level being exited is the top level of a function,
1378 check over all the labels, and clear out the current
1379 (function local) meanings of their names. */
1383 /* If this is the top level block of a function,
1384 the vars are the function's parameters.
1385 Don't leave them in the BLOCK because they are
1386 found in the FUNCTION_DECL instead. */
1388 BLOCK_VARS (block) = 0;
1390 /* Clear out the definitions of all label names,
1391 since their scopes end here,
1392 and add them to BLOCK_VARS. */
1395 for (link = named_labels; link; link = TREE_CHAIN (link))
1397 tree label = TREE_VALUE (link);
1399 if (DECL_INITIAL (label) == 0)
1401 error ("%Jlabel '%D' used but not defined", label, label);
1402 /* Avoid crashing later. */
1403 define_label (input_location, DECL_NAME (label));
1405 else if (warn_unused[UNUSED_LABEL] && !TREE_USED (label))
1406 warning ("%Jlabel '%D' defined but not used", label, label);
1407 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1409 /* Put the labels into the "variables" of the
1410 top-level block, so debugger can see them. */
1411 TREE_CHAIN (label) = BLOCK_VARS (block);
1412 BLOCK_VARS (block) = label;
1417 /* Pop the current level, and free the structure for reuse. */
1420 struct binding_level *level = current_binding_level;
1421 current_binding_level = current_binding_level->level_chain;
1423 level->level_chain = free_binding_level;
1424 free_binding_level = level;
1427 /* Dispose of the block that we just made inside some higher level. */
1429 DECL_INITIAL (current_function_decl) = block;
1432 if (!block_previously_created)
1433 current_binding_level->blocks
1434 = chainon (current_binding_level->blocks, block);
1436 /* If we did not make a block for the level just exited,
1437 any blocks made for inner levels
1438 (since they cannot be recorded as subblocks in that level)
1439 must be carried forward so they will later become subblocks
1440 of something else. */
1442 current_binding_level->blocks
1443 = chainon (current_binding_level->blocks, subblocks);
1445 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1446 binding contour so that they point to the appropriate construct, i.e.
1447 either to the current FUNCTION_DECL node, or else to the BLOCK node
1448 we just constructed.
1450 Note that for tagged types whose scope is just the formal parameter
1451 list for some function type specification, we can't properly set
1452 their TYPE_CONTEXTs here, because we don't have a pointer to the
1453 appropriate FUNCTION_TYPE node readily available to us. For those
1454 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1455 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1456 node which will represent the "scope" for these "parameter list local"
1461 TREE_USED (block) = 1;
1466 maybe_pushlevels (int pc)
1468 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1472 while (pending_local_decls != NULL_TREE &&
1473 DECL_LOCAL_START_PC (pending_local_decls) <= pc)
1475 tree *ptr = &pending_local_decls;
1477 int end_pc = DECL_LOCAL_END_PC (decl);
1479 while (*ptr != NULL_TREE
1480 && DECL_LOCAL_START_PC (*ptr) <= pc
1481 && DECL_LOCAL_END_PC (*ptr) == end_pc)
1482 ptr = &TREE_CHAIN (*ptr);
1483 pending_local_decls = *ptr;
1486 /* Force non-nested range to be nested in current range. */
1487 if (end_pc > current_binding_level->end_pc)
1488 end_pc = current_binding_level->end_pc;
1490 maybe_start_try (pc, end_pc);
1493 expand_start_bindings (0);
1495 current_binding_level->end_pc = end_pc;
1496 current_binding_level->start_pc = pc;
1497 current_binding_level->names = decl;
1498 for ( ; decl != NULL_TREE; decl = TREE_CHAIN (decl))
1500 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl);
1504 maybe_start_try (pc, 0);
1508 maybe_poplevels (int pc)
1510 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1514 while (current_binding_level->end_pc <= pc)
1516 expand_end_bindings (getdecls (), 1, 0);
1517 maybe_end_try (current_binding_level->start_pc, pc);
1520 maybe_end_try (0, pc);
1523 /* Terminate any binding which began during the range beginning at
1524 start_pc. This tidies up improperly nested local variable ranges
1525 and exception handlers; a variable declared within an exception
1526 range is forcibly terminated when that exception ends. */
1529 force_poplevels (int start_pc)
1531 while (current_binding_level->start_pc > start_pc)
1533 if (pedantic && current_binding_level->start_pc > start_pc)
1534 warning ("%JIn %D: overlapped variable and exception ranges at %d",
1535 current_function_decl, current_function_decl,
1536 current_binding_level->start_pc);
1537 expand_end_bindings (getdecls (), 1, 0);
1542 /* Insert BLOCK at the end of the list of subblocks of the
1543 current binding level. This is used when a BIND_EXPR is expanded,
1544 to handle the BLOCK node inside the BIND_EXPR. */
1547 insert_block (tree block)
1549 TREE_USED (block) = 1;
1550 current_binding_level->blocks
1551 = chainon (current_binding_level->blocks, block);
1554 /* Set the BLOCK node for the innermost scope
1555 (the one we are currently in). */
1558 set_block (tree block)
1560 current_binding_level->this_block = block;
1561 current_binding_level->names = chainon (current_binding_level->names,
1562 BLOCK_VARS (block));
1563 current_binding_level->blocks = chainon (current_binding_level->blocks,
1564 BLOCK_SUBBLOCKS (block));
1567 /* integrate_decl_tree calls this function. */
1570 java_dup_lang_specific_decl (tree node)
1573 struct lang_decl *x;
1575 if (!DECL_LANG_SPECIFIC (node))
1578 lang_decl_size = sizeof (struct lang_decl);
1579 x = ggc_alloc (lang_decl_size);
1580 memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
1581 DECL_LANG_SPECIFIC (node) = x;
1585 give_name_to_locals (JCF *jcf)
1587 int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
1588 int code_offset = DECL_CODE_OFFSET (current_function_decl);
1590 pending_local_decls = NULL_TREE;
1594 n = JCF_readu2 (jcf);
1595 for (i = 0; i < n; i++)
1597 int start_pc = JCF_readu2 (jcf);
1598 int length = JCF_readu2 (jcf);
1599 int name_index = JCF_readu2 (jcf);
1600 int signature_index = JCF_readu2 (jcf);
1601 int slot = JCF_readu2 (jcf);
1602 tree name = get_name_constant (jcf, name_index);
1603 tree type = parse_signature (jcf, signature_index);
1604 if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
1606 && length == DECL_CODE_LENGTH (current_function_decl))
1608 tree decl = TREE_VEC_ELT (decl_map, slot);
1609 DECL_NAME (decl) = name;
1610 SET_DECL_ASSEMBLER_NAME (decl, name);
1611 if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
1612 warning ("bad type in parameter debug info");
1617 int end_pc = start_pc + length;
1618 tree decl = build_decl (VAR_DECL, name, type);
1619 if (end_pc > DECL_CODE_LENGTH (current_function_decl))
1621 warning ("%Jbad PC range for debug info for local '%D'",
1623 end_pc = DECL_CODE_LENGTH (current_function_decl);
1626 /* Adjust start_pc if necessary so that the local's first
1627 store operation will use the relevant DECL as a
1628 destination. Fore more information, read the leading
1629 comments for expr.c:maybe_adjust_start_pc. */
1630 start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot);
1632 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1633 DECL_LOCAL_SLOT_NUMBER (decl) = slot;
1634 DECL_LOCAL_START_PC (decl) = start_pc;
1636 /* FIXME: The range used internally for exceptions and local
1637 variable ranges, is a half-open interval:
1638 start_pc <= pc < end_pc. However, the range used in the
1639 Java VM spec is inclusive at both ends:
1640 start_pc <= pc <= end_pc. */
1643 DECL_LOCAL_END_PC (decl) = end_pc;
1645 /* Now insert the new decl in the proper place in
1646 pending_local_decls. We are essentially doing an insertion sort,
1647 which works fine, since the list input will normally already
1649 ptr = &pending_local_decls;
1650 while (*ptr != NULL_TREE
1651 && (DECL_LOCAL_START_PC (*ptr) > start_pc
1652 || (DECL_LOCAL_START_PC (*ptr) == start_pc
1653 && DECL_LOCAL_END_PC (*ptr) < end_pc)))
1654 ptr = &TREE_CHAIN (*ptr);
1655 TREE_CHAIN (decl) = *ptr;
1660 pending_local_decls = nreverse (pending_local_decls);
1662 /* Fill in default names for the parameters. */
1663 for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
1664 parm != NULL_TREE; parm = TREE_CHAIN (parm), i++)
1666 if (DECL_NAME (parm) == NULL_TREE)
1668 int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
1670 DECL_NAME (parm) = get_identifier ("this");
1674 sprintf (buffer, "ARG_%d", arg_i);
1675 DECL_NAME (parm) = get_identifier (buffer);
1677 SET_DECL_ASSEMBLER_NAME (parm, DECL_NAME (parm));
1683 build_result_decl (tree fndecl)
1685 tree restype = TREE_TYPE (TREE_TYPE (fndecl));
1686 tree result = DECL_RESULT (fndecl);
1689 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1690 if (INTEGRAL_TYPE_P (restype)
1691 && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
1692 restype = integer_type_node;
1693 result = build_decl (RESULT_DECL, NULL_TREE, restype);
1694 DECL_CONTEXT (result) = fndecl;
1695 DECL_RESULT (fndecl) = result;
1701 complete_start_java_method (tree fndecl)
1703 if (! flag_emit_class_files)
1705 /* Initialize the RTL code for the function. */
1706 init_function_start (fndecl);
1708 /* Set up parameters and prepare for return, for the function. */
1709 expand_function_start (fndecl, 0);
1713 /* If this fcn was already referenced via a block-scope `extern' decl (or
1714 an implicit decl), propagate certain information about the usage. */
1715 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
1716 TREE_ADDRESSABLE (current_function_decl) = 1;
1720 if (METHOD_STATIC (fndecl) && ! METHOD_PRIVATE (fndecl)
1721 && ! flag_emit_class_files
1722 && ! DECL_CLINIT_P (fndecl)
1723 && ! CLASS_INTERFACE (TYPE_NAME (current_class)))
1725 tree clas = DECL_CONTEXT (fndecl);
1726 tree init = build (CALL_EXPR, void_type_node,
1727 build_address_of (soft_initclass_node),
1728 build_tree_list (NULL_TREE, build_class_ref (clas)),
1730 TREE_SIDE_EFFECTS (init) = 1;
1731 expand_expr_stmt (init);
1734 /* Push local variables. Function compiled from source code are
1735 using a different local variables management, and for them,
1736 pushlevel shouldn't be called from here. */
1737 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1740 if (! flag_emit_class_files)
1741 expand_start_bindings (1);
1744 if (METHOD_SYNCHRONIZED (fndecl) && ! flag_emit_class_files)
1746 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1747 tree enter, exit, lock;
1748 if (METHOD_STATIC (fndecl))
1749 lock = build_class_ref (DECL_CONTEXT (fndecl));
1751 lock = DECL_ARGUMENTS (fndecl);
1752 BUILD_MONITOR_ENTER (enter, lock);
1753 BUILD_MONITOR_EXIT (exit, lock);
1754 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1756 expand_expr_stmt (enter);
1757 expand_decl_cleanup (NULL_TREE, exit);
1761 tree function_body = DECL_FUNCTION_BODY (fndecl);
1762 tree body = BLOCK_EXPR_BODY (function_body);
1763 lock = build (COMPOUND_EXPR, void_type_node,
1765 build (TRY_FINALLY_EXPR, void_type_node, body, exit));
1766 TREE_SIDE_EFFECTS (lock) = 1;
1767 BLOCK_EXPR_BODY (function_body) = lock;
1773 start_java_method (tree fndecl)
1778 current_function_decl = fndecl;
1779 announce_function (fndecl);
1781 i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
1782 decl_map = make_tree_vec (i);
1783 type_map = xrealloc (type_map, i * sizeof (tree));
1785 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1786 fprintf (stderr, "%s:\n", lang_printable_name (fndecl, 2));
1788 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1789 pushlevel (1); /* Push parameters. */
1791 ptr = &DECL_ARGUMENTS (fndecl);
1792 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
1793 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
1795 tree parm_name = NULL_TREE, parm_decl;
1796 tree parm_type = TREE_VALUE (tem);
1797 if (i >= DECL_MAX_LOCALS (fndecl))
1800 parm_decl = build_decl (PARM_DECL, parm_name, parm_type);
1801 DECL_CONTEXT (parm_decl) = fndecl;
1802 if (PROMOTE_PROTOTYPES
1803 && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
1804 && INTEGRAL_TYPE_P (parm_type))
1805 parm_type = integer_type_node;
1806 DECL_ARG_TYPE (parm_decl) = parm_type;
1809 ptr = &TREE_CHAIN (parm_decl);
1811 /* Add parm_decl to the decl_map. */
1812 push_jvm_slot (i, parm_decl);
1814 type_map[i] = TREE_TYPE (parm_decl);
1815 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
1818 type_map[i] = void_type_node;
1822 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
1824 while (i < DECL_MAX_LOCALS(fndecl))
1825 type_map[i++] = NULL_TREE;
1827 build_result_decl (fndecl);
1828 complete_start_java_method (fndecl);
1832 end_java_method (void)
1834 tree fndecl = current_function_decl;
1836 expand_end_bindings (getdecls (), 1, 0);
1837 /* pop out of function */
1840 /* pop out of its parameters */
1843 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1845 /* Generate rtl for function exit. */
1846 expand_function_end ();
1848 /* Run the optimizers and output assembler code for this function. */
1849 rest_of_compilation (fndecl);
1851 current_function_decl = NULL_TREE;
1854 /* Expand a function's body. */
1857 java_expand_body (tree fndecl)
1859 location_t saved_location = input_location;
1861 current_function_decl = fndecl;
1862 input_location = DECL_SOURCE_LOCATION (fndecl);
1863 current_class = DECL_CONTEXT (fndecl);
1865 timevar_push (TV_EXPAND);
1867 /* Prepare the function for tree completion. */
1868 start_complete_expand_method (fndecl);
1870 if (! flag_emit_class_files && ! flag_emit_xref)
1872 /* Initialize the RTL code for the function. */
1873 init_function_start (fndecl);
1875 /* Set up parameters and prepare for return, for the function. */
1876 expand_function_start (fndecl, 0);
1878 /* Generate the RTL for this function. */
1879 expand_expr_stmt_value (DECL_SAVED_TREE (fndecl), 0, 1);
1882 /* Pop out of its parameters. */
1883 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
1885 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1887 if (! flag_emit_class_files && ! flag_emit_xref)
1889 /* Generate RTL for function exit. */
1890 input_line = DECL_FUNCTION_LAST_LINE (fndecl);
1891 expand_function_end ();
1893 /* Run the optimizers and output the assembler code
1894 for this function. */
1895 rest_of_compilation (fndecl);
1898 timevar_pop (TV_EXPAND);
1900 input_location = saved_location;
1902 current_function_decl = NULL_TREE;
1905 /* We pessimistically marked all methods and fields external until we
1906 knew what set of classes we were planning to compile. Now mark those
1907 associated with CLASS to be generated locally as not external. */
1910 java_mark_decl_local (tree decl)
1912 DECL_EXTERNAL (decl) = 0;
1914 /* If we've already constructed DECL_RTL, give encode_section_info
1915 a second chance, now that we've changed the flags. */
1916 if (DECL_RTL_SET_P (decl))
1917 make_decl_rtl (decl, NULL);
1921 java_mark_class_local (tree class)
1925 for (t = TYPE_FIELDS (class); t ; t = TREE_CHAIN (t))
1926 if (FIELD_STATIC (t))
1927 java_mark_decl_local (t);
1929 for (t = TYPE_METHODS (class); t ; t = TREE_CHAIN (t))
1930 if (!METHOD_ABSTRACT (t) && (!METHOD_NATIVE (t) || flag_jni))
1931 java_mark_decl_local (t);
1934 #include "gt-java-decl.h"