1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GNU CC.
8 GNU CC 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 GNU CC 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 GNU CC; 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. */
36 #include "java-tree.h"
42 #include "java-except.h"
45 #if defined (DEBUG_JAVA_BINDING_LEVELS)
46 extern void indent
PROTO((void));
49 static tree push_jvm_slot
PARAMS ((int, tree
));
50 static tree lookup_name_current_level
PARAMS ((tree
));
51 static tree push_promoted_type
PARAMS ((const char *, tree
));
52 static struct binding_level
*make_binding_level
PARAMS ((void));
53 static tree create_primitive_vtable
PARAMS ((const char *));
54 static tree check_local_named_variable
PARAMS ((tree
, tree
, int, int *));
55 static tree check_local_unnamed_variable
PARAMS ((tree
, tree
, tree
));
57 /* Set to non-zero value in order to emit class initilization code
58 before static field references. */
59 extern int always_initialize_class_p
;
61 /* The DECL_MAP is a mapping from (index, type) to a decl node.
62 If index < max_locals, it is the index of a local variable.
63 if index >= max_locals, then index-max_locals is a stack slot.
64 The DECL_MAP mapping is represented as a TREE_VEC whose elements
65 are a list of decls (VAR_DECL or PARM_DECL) chained by
66 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
67 we search the chain for a decl with a matching TREE_TYPE. */
71 /* A list of local variables VAR_DECLs for this method that we have seen
72 debug information, but we have not reached their starting (byte) PC yet. */
74 static tree pending_local_decls
= NULL_TREE
;
76 /* Push a local variable or stack slot into the decl_map,
77 and assign it an rtl. */
79 #if defined(DEBUG_JAVA_BINDING_LEVELS)
80 int binding_depth
= 0;
81 int is_class_level
= 0;
89 for (i
= 0; i
< binding_depth
*2; i
++)
92 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
95 push_jvm_slot (index
, decl
)
99 struct rtx_def
*rtl
= NULL
;
100 tree type
= TREE_TYPE (decl
);
103 DECL_CONTEXT (decl
) = current_function_decl
;
104 layout_decl (decl
, 0);
106 /* See if we have an appropriate rtl (i.e. same mode) at this index.
107 If so, we must use it. */
108 tmp
= TREE_VEC_ELT (decl_map
, index
);
109 while (tmp
!= NULL_TREE
)
111 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
112 rtl
= DECL_RTL_IF_SET (tmp
);
115 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
118 SET_DECL_RTL (decl
, rtl
);
121 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
122 DECL_REGISTER (decl
) = 1;
126 /* Now link the decl into the decl_map. */
127 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
129 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
130 DECL_LOCAL_START_PC (decl
) = 0;
131 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
132 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
134 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
135 TREE_VEC_ELT (decl_map
, index
) = decl
;
139 /* Find out if 'decl' passed in fits the defined PC location better than
140 'best'. Return decl if it does, return best if it doesn't. If decl
141 is returned, then updated is set to true. */
144 check_local_named_variable (best
, decl
, pc
, updated
)
150 if (pc
>= DECL_LOCAL_START_PC (decl
)
151 && pc
< DECL_LOCAL_END_PC (decl
))
153 if (best
== NULL_TREE
154 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
155 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
165 /* Find the best declaration based upon type. If 'decl' fits 'type' better
166 than 'best', return 'decl'. Otherwise return 'best'. */
169 check_local_unnamed_variable (best
, decl
, type
)
174 if (TREE_TYPE (decl
) == type
175 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
176 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
177 && TYPE_PRECISION (type
) <= 32
178 && TREE_CODE (type
) != POINTER_TYPE
)
179 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
180 && type
== ptr_type_node
))
182 if (best
== NULL_TREE
183 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
191 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
192 that is valid at PC (or -1 if any pc).
193 If there is no existing matching decl, allocate one. */
196 find_local_variable (index
, type
, pc
)
201 tree decl
= TREE_VEC_ELT (decl_map
, index
);
202 tree best
= NULL_TREE
;
203 int found_scoped_var
= 0;
205 /* Scan through every declaration that has been created in this slot. */
206 while (decl
!= NULL_TREE
)
208 /* Variables created in give_name_to_locals() have a name and have
209 a specified scope, so we can handle them specifically. We want
210 to use the specific decls created for those so they are assigned
211 the right variables in the debugging information. */
212 if (DECL_NAME (decl
) != NULL_TREE
)
214 /* This is a variable we have a name for, so it has a scope
215 supplied in the class file. But it only matters when we
216 actually have a PC to use. If pc<0, then we are asking
217 for a stack slot and this decl won't be one of those. */
219 best
= check_local_named_variable (best
, decl
, pc
,
222 /* We scan for type information unless we found a variable in the
223 proper scope already. */
224 else if (!found_scoped_var
)
226 /* If we don't have scoping information for a variable, we use
227 a different method to look it up. */
228 best
= check_local_unnamed_variable (best
, decl
, type
);
231 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
234 if (best
!= NULL_TREE
)
237 /* If we don't find a match, create one with the type passed in. */
238 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
242 /* Same as find_local_index, except that INDEX is a stack index. */
245 find_stack_slot (index
, type
)
249 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
255 /* A chain of _DECL nodes for all variables, constants, functions,
256 * and typedef types. These are in the reverse of the order supplied.
260 /* For each level, a list of shadowed outer-level local definitions
261 to be restored when this level is popped.
262 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
263 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
266 /* For each level (except not the global one),
267 a chain of BLOCK nodes for all the levels
268 that were entered and exited one level down. */
271 /* The BLOCK node for this level, if one has been preallocated.
272 If 0, the BLOCK is allocated (if needed) when the level is popped. */
275 /* The binding level which this one is contained in (inherits from). */
276 struct binding_level
*level_chain
;
278 /* The bytecode PC that marks the end of this level. */
280 /* The bytecode PC that marks the start of this level. */
283 #if defined(DEBUG_JAVA_BINDING_LEVELS)
284 /* Binding depth at which this level began. */
285 unsigned binding_depth
;
286 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
289 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
291 /* The binding level currently in effect. */
293 static struct binding_level
*current_binding_level
;
295 /* A chain of binding_level structures awaiting reuse. */
297 static struct binding_level
*free_binding_level
;
299 /* The outermost binding level, for names of file scope.
300 This is created when the compiler is started and exists
301 through the entire run. */
303 static struct binding_level
*global_binding_level
;
305 /* A PC value bigger than any PC value we may ever may encounter. */
307 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
309 /* Binding level structures are initialized by copying this one. */
311 static struct binding_level clear_binding_level
312 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
313 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
316 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
317 that have names. Here so we can clear out their names' definitions
318 at the end of the function. */
320 static tree named_labels
;
322 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
324 static tree shadowed_labels
;
327 tree java_global_trees
[JTI_MAX
];
329 /* Build (and pushdecl) a "promoted type" for all standard
330 types shorter than int. */
333 push_promoted_type (name
, actual_type
)
337 tree type
= make_node (TREE_CODE (actual_type
));
339 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
340 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
342 tree in_min
= TYPE_MIN_VALUE (actual_type
);
343 tree in_max
= TYPE_MAX_VALUE (actual_type
);
345 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
346 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
347 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
348 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
349 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
351 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
355 /* Return a definition for a builtin function named NAME and whose data type
356 is TYPE. TYPE should be a function type with argument types.
357 FUNCTION_CODE tells later passes how to compile calls to this function.
358 See tree.h for its possible values.
360 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
361 the name to be called if we can't opencode the function. */
364 builtin_function (name
, type
, function_code
, class, library_name
)
368 enum built_in_class
class;
369 const char *library_name
;
371 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
372 DECL_EXTERNAL (decl
) = 1;
373 TREE_PUBLIC (decl
) = 1;
375 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
376 make_decl_rtl (decl
, NULL
);
378 DECL_BUILT_IN_CLASS (decl
) = class;
379 DECL_FUNCTION_CODE (decl
) = function_code
;
383 /* Return tree that represents a vtable for a primitive array. */
385 create_primitive_vtable (name
)
391 sprintf (buf
, "_Jv_%sVTable", name
);
392 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
393 DECL_EXTERNAL (r
) = 1;
398 java_init_decl_processing ()
400 register tree endlink
;
401 tree field
= NULL_TREE
;
404 init_class_processing ();
406 current_function_decl
= NULL
;
407 current_binding_level
= NULL_BINDING_LEVEL
;
408 free_binding_level
= NULL_BINDING_LEVEL
;
409 pushlevel (0); /* make the binding_level structure for global names */
410 global_binding_level
= current_binding_level
;
412 /* The code here must be similar to build_common_tree_nodes{,_2} in
413 tree.c, especially as to the order of initializing common nodes. */
414 error_mark_node
= make_node (ERROR_MARK
);
415 TREE_TYPE (error_mark_node
) = error_mark_node
;
417 /* Create sizetype first - needed for other types. */
418 initialize_sizetypes ();
420 byte_type_node
= make_signed_type (8);
421 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
422 short_type_node
= make_signed_type (16);
423 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
424 int_type_node
= make_signed_type (32);
425 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
426 long_type_node
= make_signed_type (64);
427 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
429 unsigned_byte_type_node
= make_unsigned_type (8);
430 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
431 unsigned_byte_type_node
));
432 unsigned_short_type_node
= make_unsigned_type (16);
433 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
434 unsigned_short_type_node
));
435 unsigned_int_type_node
= make_unsigned_type (32);
436 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
437 unsigned_int_type_node
));
438 unsigned_long_type_node
= make_unsigned_type (64);
439 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
440 unsigned_long_type_node
));
442 set_sizetype (make_unsigned_type (POINTER_SIZE
));
444 /* Define these next since types below may used them. */
445 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
446 integer_zero_node
= build_int_2 (0, 0);
447 integer_one_node
= build_int_2 (1, 0);
448 integer_two_node
= build_int_2 (2, 0);
449 integer_four_node
= build_int_2 (4, 0);
450 integer_minus_one_node
= build_int_2 (-1, -1);
452 size_zero_node
= size_int (0);
453 size_one_node
= size_int (1);
454 bitsize_zero_node
= bitsize_int (0);
455 bitsize_one_node
= bitsize_int (1);
456 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
458 long_zero_node
= build_int_2 (0, 0);
459 TREE_TYPE (long_zero_node
) = long_type_node
;
461 void_type_node
= make_node (VOID_TYPE
);
462 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
463 layout_type (void_type_node
); /* Uses size_zero_node */
464 ptr_type_node
= build_pointer_type (void_type_node
);
465 t
= make_node (VOID_TYPE
);
466 layout_type (t
); /* Uses size_zero_node */
467 return_address_type_node
= build_pointer_type (t
);
469 null_pointer_node
= build_int_2 (0, 0);
470 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
472 /* Used by the parser to represent empty statements and blocks. */
473 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
474 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
477 /* Make a type to be the domain of a few array types
478 whose domains don't really matter.
479 200 is small enough that it always fits in size_t
480 and large enough that it can hold most function names for the
481 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
482 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
484 char_type_node
= make_node (CHAR_TYPE
);
485 TYPE_PRECISION (char_type_node
) = 16;
486 fixup_unsigned_type (char_type_node
);
487 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
489 boolean_type_node
= make_node (BOOLEAN_TYPE
);
490 TYPE_PRECISION (boolean_type_node
) = 1;
491 fixup_unsigned_type (boolean_type_node
);
492 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
494 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
495 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
497 promoted_byte_type_node
498 = push_promoted_type ("promoted_byte", byte_type_node
);
499 promoted_short_type_node
500 = push_promoted_type ("promoted_short", short_type_node
);
501 promoted_char_type_node
502 = push_promoted_type ("promoted_char", char_type_node
);
503 promoted_boolean_type_node
504 = push_promoted_type ("promoted_boolean", boolean_type_node
);
506 float_type_node
= make_node (REAL_TYPE
);
507 TYPE_PRECISION (float_type_node
) = 32;
508 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
510 layout_type (float_type_node
);
512 double_type_node
= make_node (REAL_TYPE
);
513 TYPE_PRECISION (double_type_node
) = 64;
514 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
516 layout_type (double_type_node
);
518 float_zero_node
= build_real (float_type_node
, dconst0
);
519 double_zero_node
= build_real (double_type_node
, dconst0
);
521 /* These are the vtables for arrays of primitives. */
522 boolean_array_vtable
= create_primitive_vtable ("boolean");
523 byte_array_vtable
= create_primitive_vtable ("byte");
524 char_array_vtable
= create_primitive_vtable ("char");
525 short_array_vtable
= create_primitive_vtable ("short");
526 int_array_vtable
= create_primitive_vtable ("int");
527 long_array_vtable
= create_primitive_vtable ("long");
528 float_array_vtable
= create_primitive_vtable ("float");
529 double_array_vtable
= create_primitive_vtable ("double");
531 /* As you're adding items here, please update the code right after
532 this section, so that the filename containing the source code of
533 the pre-defined class gets registered correctly. */
534 unqualified_object_id_node
= get_identifier ("Object");
535 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
536 object_ptr_type_node
= promote_type (object_type_node
);
537 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
538 string_ptr_type_node
= promote_type (string_type_node
);
539 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
540 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
541 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
542 runtime_exception_type_node
=
543 lookup_class (get_identifier ("java.lang.RuntimeException"));
544 error_exception_type_node
=
545 lookup_class (get_identifier ("java.lang.Error"));
546 class_not_found_type_node
=
547 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
548 no_class_def_found_type_node
=
549 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
551 rawdata_ptr_type_node
552 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
554 add_predefined_file (get_identifier ("java/lang/Class.java"));
555 add_predefined_file (get_identifier ("java/lang/Error.java"));
556 add_predefined_file (get_identifier ("java/lang/Object.java"));
557 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
558 add_predefined_file (get_identifier ("java/lang/String.java"));
559 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
560 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
561 add_predefined_file (get_identifier ("java/lang/Exception.java"));
562 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
563 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
564 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
566 methodtable_type
= make_node (RECORD_TYPE
);
567 layout_type (methodtable_type
);
568 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
569 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
571 TYPE_identifier_node
= get_identifier ("TYPE");
572 init_identifier_node
= get_identifier ("<init>");
573 clinit_identifier_node
= get_identifier ("<clinit>");
574 finit_identifier_node
= get_identifier ("finit$");
575 instinit_identifier_node
= get_identifier ("instinit$");
576 void_signature_node
= get_identifier ("()V");
577 length_identifier_node
= get_identifier ("length");
578 finalize_identifier_node
= get_identifier ("finalize");
579 this_identifier_node
= get_identifier ("this");
580 super_identifier_node
= get_identifier ("super");
581 continue_identifier_node
= get_identifier ("continue");
582 access0_identifier_node
= get_identifier ("access$0");
583 classdollar_identifier_node
= get_identifier ("class$");
585 /* for lack of a better place to put this stub call */
586 init_expr_processing();
588 utf8const_type
= make_node (RECORD_TYPE
);
589 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
590 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
591 FINISH_RECORD (utf8const_type
);
592 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
594 constants_type_node
= make_node (RECORD_TYPE
);
595 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
596 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
597 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
598 FINISH_RECORD (constants_type_node
);
599 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
601 access_flags_type_node
= unsigned_short_type_node
;
603 dtable_type
= make_node (RECORD_TYPE
);
604 dtable_ptr_type
= build_pointer_type (dtable_type
);
606 one_elt_array_domain_type
= build_index_type (integer_one_node
);
607 otable_type
= build_array_type (integer_type_node
,
608 one_elt_array_domain_type
);
609 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
610 otable_ptr_type
= build_pointer_type (otable_type
);
612 method_symbol_type
= make_node (RECORD_TYPE
);
613 PUSH_FIELD (method_symbol_type
, field
, "clname", utf8const_ptr_type
);
614 PUSH_FIELD (method_symbol_type
, field
, "name", utf8const_ptr_type
);
615 PUSH_FIELD (method_symbol_type
, field
, "signature", utf8const_ptr_type
);
616 FINISH_RECORD (method_symbol_type
);
618 method_symbols_array_type
= build_array_type (method_symbol_type
,
619 one_elt_array_domain_type
);
620 method_symbols_array_ptr_type
= build_pointer_type
621 (method_symbols_array_type
);
623 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"), otable_type
);
624 DECL_EXTERNAL (otable_decl
) = 1;
625 TREE_STATIC (otable_decl
) = 1;
626 TREE_READONLY (otable_decl
) = 1;
627 pushdecl (otable_decl
);
629 otable_syms_decl
= build_decl (VAR_DECL
, get_identifier ("otable_syms"),
630 method_symbols_array_type
);
631 TREE_STATIC (otable_syms_decl
) = 1;
632 TREE_CONSTANT (otable_syms_decl
) = 1;
633 pushdecl (otable_syms_decl
);
635 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
636 /* This isn't exactly true, but it is what we have in the source.
637 There is an unresolved issue here, which is whether the vtable
638 should be marked by the GC. */
639 if (! flag_hash_synchronization
)
640 PUSH_FIELD (object_type_node
, field
, "sync_info",
641 build_pointer_type (object_type_node
));
642 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
643 FIELD_PRIVATE (t
) = 1;
644 FINISH_RECORD (object_type_node
);
646 field_type_node
= make_node (RECORD_TYPE
);
647 field_ptr_type_node
= build_pointer_type (field_type_node
);
648 method_type_node
= make_node (RECORD_TYPE
);
649 method_ptr_type_node
= build_pointer_type (method_type_node
);
651 set_super_info (0, class_type_node
, object_type_node
, 0);
652 set_super_info (0, string_type_node
, object_type_node
, 0);
653 class_ptr_type
= build_pointer_type (class_type_node
);
655 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
656 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
657 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
658 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
659 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
660 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
661 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
662 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
663 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
664 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
665 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
666 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
667 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
668 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
669 PUSH_FIELD (class_type_node
, field
, "otable_syms",
670 method_symbols_array_ptr_type
);
671 PUSH_FIELD (class_type_node
, field
, "interfaces",
672 build_pointer_type (class_ptr_type
));
673 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
674 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
675 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
676 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
677 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
678 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
679 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
680 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
681 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
682 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
683 FIELD_PRIVATE (t
) = 1;
684 push_super_field (class_type_node
, object_type_node
);
686 FINISH_RECORD (class_type_node
);
687 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
689 field_info_union_node
= make_node (UNION_TYPE
);
690 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
691 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
693 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
695 layout_type (field_info_union_node
);
697 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
698 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
699 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
700 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
701 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
702 FINISH_RECORD (field_type_node
);
703 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
705 nativecode_ptr_array_type_node
706 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
708 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
709 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
710 FINISH_RECORD (dtable_type
);
711 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
713 #define jint_type int_type_node
714 #define jint_ptr_type ptr_type_node
716 jexception_type
= make_node (RECORD_TYPE
);
717 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
718 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
719 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
720 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
721 FINISH_RECORD (jexception_type
);
722 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
723 jexception_ptr_type
= build_pointer_type (jexception_type
);
725 lineNumberEntry_type
= make_node (RECORD_TYPE
);
726 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
727 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
728 FINISH_RECORD (lineNumberEntry_type
);
730 lineNumbers_type
= make_node (RECORD_TYPE
);
731 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
732 FINISH_RECORD (lineNumbers_type
);
734 #define instn_ptr_type_node ptr_type_node /* XXX JH */
736 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
738 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
739 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
740 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
741 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
742 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
743 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
744 FINISH_RECORD (method_type_node
);
745 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
747 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
749 t
= tree_cons (NULL_TREE
, class_ptr_type
,
750 tree_cons (NULL_TREE
, int_type_node
, endlink
));
751 alloc_object_node
= builtin_function ("_Jv_AllocObject",
752 build_function_type (ptr_type_node
, t
),
753 0, NOT_BUILT_IN
, NULL
);
754 DECL_IS_MALLOC (alloc_object_node
) = 1;
755 alloc_no_finalizer_node
=
756 builtin_function ("_Jv_AllocObjectNoFinalizer",
757 build_function_type (ptr_type_node
, t
),
758 0, NOT_BUILT_IN
, NULL
);
759 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
761 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
762 soft_initclass_node
= builtin_function ("_Jv_InitClass",
763 build_function_type (void_type_node
,
765 0, NOT_BUILT_IN
, NULL
);
767 throw_node
= builtin_function ("_Jv_Throw",
768 build_function_type (ptr_type_node
, t
),
769 0, NOT_BUILT_IN
, NULL
);
770 /* Mark throw_nodes as `noreturn' functions with side effects. */
771 TREE_THIS_VOLATILE (throw_node
) = 1;
772 TREE_SIDE_EFFECTS (throw_node
) = 1;
774 t
= build_function_type (int_type_node
, endlink
);
775 soft_monitorenter_node
776 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
, NULL
);
777 soft_monitorexit_node
778 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
, NULL
);
780 t
= tree_cons (NULL_TREE
, int_type_node
,
781 tree_cons (NULL_TREE
, int_type_node
, endlink
));
783 = builtin_function ("_Jv_NewPrimArray",
784 build_function_type(ptr_type_node
, t
),
785 0, NOT_BUILT_IN
, NULL
);
786 DECL_IS_MALLOC (soft_newarray_node
) = 1;
788 t
= tree_cons (NULL_TREE
, int_type_node
,
789 tree_cons (NULL_TREE
, class_ptr_type
,
790 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
792 = builtin_function ("_Jv_NewObjectArray",
793 build_function_type (ptr_type_node
, t
),
794 0, NOT_BUILT_IN
, NULL
);
795 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
797 t
= tree_cons (NULL_TREE
, ptr_type_node
,
798 tree_cons (NULL_TREE
, int_type_node
, endlink
));
799 soft_multianewarray_node
800 = builtin_function ("_Jv_NewMultiArray",
801 build_function_type (ptr_type_node
, t
),
802 0, NOT_BUILT_IN
, NULL
);
803 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
805 t
= build_function_type (void_type_node
,
806 tree_cons (NULL_TREE
, int_type_node
, endlink
));
807 soft_badarrayindex_node
808 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
809 0, NOT_BUILT_IN
, NULL
);
810 /* Mark soft_badarrayindex_node as a `noreturn' function with side
812 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
813 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
815 soft_nullpointer_node
816 = builtin_function ("_Jv_ThrowNullPointerException",
817 build_function_type (void_type_node
, endlink
),
818 0, NOT_BUILT_IN
, NULL
);
819 /* Mark soft_nullpointer_node as a `noreturn' function with side
821 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
822 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
824 t
= tree_cons (NULL_TREE
, class_ptr_type
,
825 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
827 = builtin_function ("_Jv_CheckCast",
828 build_function_type (ptr_type_node
, t
),
829 0, NOT_BUILT_IN
, NULL
);
830 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
831 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
833 = builtin_function ("_Jv_IsInstanceOf",
834 build_function_type (boolean_type_node
, t
),
835 0, NOT_BUILT_IN
, NULL
);
836 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
837 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
838 soft_checkarraystore_node
839 = builtin_function ("_Jv_CheckArrayStore",
840 build_function_type (void_type_node
, t
),
841 0, NOT_BUILT_IN
, NULL
);
842 t
= tree_cons (NULL_TREE
, ptr_type_node
,
843 tree_cons (NULL_TREE
, ptr_type_node
,
844 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
845 soft_lookupinterfacemethod_node
846 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
847 build_function_type (ptr_type_node
, t
),
848 0, NOT_BUILT_IN
, NULL
);
850 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
851 tree_cons (NULL_TREE
, ptr_type_node
,
852 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
853 soft_lookupjnimethod_node
854 = builtin_function ("_Jv_LookupJNIMethod",
855 build_function_type (ptr_type_node
, t
),
856 0, NOT_BUILT_IN
, NULL
);
857 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
858 soft_getjnienvnewframe_node
859 = builtin_function ("_Jv_GetJNIEnvNewFrame",
860 build_function_type (ptr_type_node
, t
),
861 0, NOT_BUILT_IN
, NULL
);
862 soft_jnipopsystemframe_node
863 = builtin_function ("_Jv_JNI_PopSystemFrame",
864 build_function_type (ptr_type_node
, t
),
865 0, NOT_BUILT_IN
, NULL
);
867 t
= tree_cons (NULL_TREE
, double_type_node
,
868 tree_cons (NULL_TREE
, double_type_node
, endlink
));
870 = builtin_function ("__builtin_fmod",
871 build_function_type (double_type_node
, t
),
872 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmod");
875 t
= tree_cons (NULL_TREE
, float_type_node
,
876 tree_cons (NULL_TREE
, float_type_node
, endlink
));
878 = builtin_function ("__builtin_fmodf",
879 build_function_type (float_type_node
, t
),
880 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf");
884 = builtin_function ("_Jv_divI",
885 build_function_type (int_type_node
, t
),
886 0, NOT_BUILT_IN
, NULL
);
889 = builtin_function ("_Jv_remI",
890 build_function_type (int_type_node
, t
),
891 0, NOT_BUILT_IN
, NULL
);
894 = builtin_function ("_Jv_divJ",
895 build_function_type (long_type_node
, t
),
896 0, NOT_BUILT_IN
, NULL
);
899 = builtin_function ("_Jv_remJ",
900 build_function_type (long_type_node
, t
),
901 0, NOT_BUILT_IN
, NULL
);
903 /* Initialize variables for except.c. */
904 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
905 ? "__gcj_personality_sj0"
906 : "__gcj_personality_v0");
907 lang_eh_runtime_type
= prepare_eh_table_type
;
911 /* Register nodes with the garbage collector. */
912 ggc_add_tree_root (java_global_trees
, ARRAY_SIZE (java_global_trees
));
913 ggc_add_tree_root (&decl_map
, 1);
914 ggc_add_tree_root (&pending_local_decls
, 1);
916 initialize_builtins ();
920 /* Look up NAME in the current binding level and its superiors
921 in the namespace of variables, functions and typedefs.
922 Return a ..._DECL node of some kind representing its definition,
923 or return 0 if it is undefined. */
930 if (current_binding_level
!= global_binding_level
931 && IDENTIFIER_LOCAL_VALUE (name
))
932 val
= IDENTIFIER_LOCAL_VALUE (name
);
934 val
= IDENTIFIER_GLOBAL_VALUE (name
);
938 /* Similar to `lookup_name' but look only at current binding level and
939 the previous one if its the parameter level. */
942 lookup_name_current_level (name
)
947 if (current_binding_level
== global_binding_level
)
948 return IDENTIFIER_GLOBAL_VALUE (name
);
950 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
953 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
954 if (DECL_NAME (t
) == name
)
960 /* Use a binding level to record a labeled block declaration */
963 push_labeled_block (lb
)
966 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
967 register struct binding_level
*b
= current_binding_level
;
968 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
970 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
971 TREE_CHAIN (lb
) = b
->names
;
973 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
976 /* Pop the current binding level, reinstalling values for the previous
982 struct binding_level
*b
= current_binding_level
;
983 tree label
= b
->names
;
984 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
987 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
988 TREE_VALUE (b
->shadowed
);
990 /* Pop the current level, and free the structure for reuse. */
991 current_binding_level
= current_binding_level
->level_chain
;
992 b
->level_chain
= free_binding_level
;
993 free_binding_level
= b
;
996 /* Record a decl-node X as belonging to the current lexical scope.
997 Check for errors (such as an incompatible declaration for the same
998 name already seen in the same scope).
1000 Returns either X or an old decl for the same name.
1001 If an old decl is returned, it may have been smashed
1002 to agree with what X says. */
1009 register tree name
= DECL_NAME (x
);
1010 register struct binding_level
*b
= current_binding_level
;
1012 if (TREE_CODE (x
) != TYPE_DECL
)
1013 DECL_CONTEXT (x
) = current_function_decl
;
1019 t
= lookup_name_current_level (name
);
1020 if (t
!= 0 && t
== error_mark_node
)
1021 /* error_mark_node is 0 for a while during initialization! */
1024 error_with_decl (x
, "`%s' used prior to declaration");
1029 file
= DECL_SOURCE_FILE (t
);
1030 line
= DECL_SOURCE_LINE (t
);
1033 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1034 to point to the TYPE_DECL.
1035 Since Java does not have typedefs, a type can only have
1036 one (true) name, given by a class, interface, or builtin. */
1037 if (TREE_CODE (x
) == TYPE_DECL
1038 && TYPE_NAME (TREE_TYPE (x
)) == 0
1039 && TREE_TYPE (x
) != error_mark_node
)
1041 TYPE_NAME (TREE_TYPE (x
)) = x
;
1042 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1045 /* This name is new in its binding level.
1046 Install the new declaration and return it. */
1047 if (b
== global_binding_level
)
1049 /* Install a global value. */
1051 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1055 /* Here to install a non-global value. */
1056 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1057 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1060 /* Warn if shadowing an argument at the top level of the body. */
1061 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1062 /* This warning doesn't apply to the parms of a nested fcn. */
1063 && ! current_binding_level
->parm_flag
1064 /* Check that this is one level down from the parms. */
1065 && current_binding_level
->level_chain
->parm_flag
1066 /* Check that the decl being shadowed
1067 comes from the parm level, one level up. */
1068 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1070 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1071 pedwarn ("declaration of `%s' shadows a parameter",
1072 IDENTIFIER_POINTER (name
));
1074 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1075 IDENTIFIER_POINTER (name
));
1078 /* Maybe warn if shadowing something else. */
1079 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1080 /* No shadow warnings for internally generated vars. */
1081 && DECL_SOURCE_LINE (x
) != 0
1082 /* No shadow warnings for vars made for inlining. */
1083 && ! DECL_FROM_INLINE (x
))
1085 const char *warnstring
= 0;
1087 if (TREE_CODE (x
) == PARM_DECL
1088 && current_binding_level
->level_chain
->parm_flag
)
1089 /* Don't warn about the parm names in function declarator
1090 within a function declarator.
1091 It would be nice to avoid warning in any function
1092 declarator in a declaration, as opposed to a definition,
1093 but there is no way to tell it's not a definition. */
1095 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1096 warnstring
= "declaration of `%s' shadows a parameter";
1097 else if (oldlocal
!= 0)
1098 warnstring
= "declaration of `%s' shadows previous local";
1099 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1100 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1101 warnstring
= "declaration of `%s' shadows global declaration";
1104 warning (warnstring
, IDENTIFIER_POINTER (name
));
1108 /* If storing a local value, there may already be one (inherited).
1109 If so, record it for restoration when this binding level ends. */
1111 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1115 /* Put decls on list in reverse order.
1116 We will reverse them later if necessary. */
1117 TREE_CHAIN (x
) = b
->names
;
1124 pushdecl_force_head (x
)
1127 current_binding_level
->names
= x
;
1130 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1133 pushdecl_top_level (x
)
1137 register struct binding_level
*b
= current_binding_level
;
1139 current_binding_level
= global_binding_level
;
1141 current_binding_level
= b
;
1145 /* Nonzero if we are currently in the global binding level. */
1148 global_bindings_p ()
1150 return current_binding_level
== global_binding_level
;
1153 /* Return the list of declarations of the current level.
1154 Note that this list is in reverse order unless/until
1155 you nreverse it; and when you do nreverse it, you must
1156 store the result back using `storedecls' or you will lose. */
1161 return current_binding_level
->names
;
1164 /* Create a new `struct binding_level'. */
1166 static struct binding_level
*
1167 make_binding_level ()
1170 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
1175 int unused ATTRIBUTE_UNUSED
;
1177 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1180 /* If this is the top level of a function,
1181 just make sure that NAMED_LABELS is 0. */
1183 if (current_binding_level
== global_binding_level
)
1187 /* Reuse or create a struct for this binding level. */
1189 if (free_binding_level
)
1191 newlevel
= free_binding_level
;
1192 free_binding_level
= free_binding_level
->level_chain
;
1196 newlevel
= make_binding_level ();
1199 /* Add this level to the front of the chain (stack) of levels that
1202 *newlevel
= clear_binding_level
;
1203 newlevel
->level_chain
= current_binding_level
;
1204 current_binding_level
= newlevel
;
1205 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1206 newlevel
->binding_depth
= binding_depth
;
1208 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1209 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1212 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1215 /* Exit a binding level.
1216 Pop the level off, and restore the state of the identifier-decl mappings
1217 that were in effect when this level was entered.
1219 If KEEP is nonzero, this level had explicit declarations, so
1220 and create a "block" (a BLOCK node) for the level
1221 to record its declarations and subblocks for symbol table output.
1223 If FUNCTIONBODY is nonzero, this level is the body of a function,
1224 so create a block as if KEEP were set and also clear out all
1227 If REVERSE is nonzero, reverse the order of decls before putting
1228 them into the BLOCK. */
1231 poplevel (keep
, reverse
, functionbody
)
1237 /* The chain of decls was accumulated in reverse order.
1238 Put it into forward order, just for cleanliness. */
1240 tree subblocks
= current_binding_level
->blocks
;
1243 int block_previously_created
;
1245 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1248 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1249 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1250 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1251 current_binding_level
->end_pc
);
1253 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1254 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1256 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1259 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1263 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1265 /* Get the decls in the order they were written.
1266 Usually current_binding_level->names is in reverse order.
1267 But parameter decls were previously put in forward order. */
1270 current_binding_level
->names
1271 = decls
= nreverse (current_binding_level
->names
);
1273 decls
= current_binding_level
->names
;
1275 /* Output any nested inline functions within this block
1276 if they weren't already output. */
1278 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1279 if (TREE_CODE (decl
) == FUNCTION_DECL
1280 && ! TREE_ASM_WRITTEN (decl
)
1281 && DECL_INITIAL (decl
) != 0
1282 && TREE_ADDRESSABLE (decl
))
1284 /* If this decl was copied from a file-scope decl
1285 on account of a block-scope extern decl,
1286 propagate TREE_ADDRESSABLE to the file-scope decl.
1288 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1289 true, since then the decl goes through save_for_inline_copying. */
1290 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1291 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1292 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1295 push_function_context ();
1296 output_inline_function (decl
);
1297 pop_function_context ();
1301 /* If there were any declarations in that level,
1302 or if this level is a function body,
1303 create a BLOCK to record them for the life of this function. */
1306 block_previously_created
= (current_binding_level
->this_block
!= 0);
1307 if (block_previously_created
)
1308 block
= current_binding_level
->this_block
;
1309 else if (keep
|| functionbody
)
1310 block
= make_node (BLOCK
);
1313 BLOCK_VARS (block
) = decls
;
1314 BLOCK_SUBBLOCKS (block
) = subblocks
;
1317 /* In each subblock, record that this is its superior. */
1319 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1320 BLOCK_SUPERCONTEXT (link
) = block
;
1322 /* Clear out the meanings of the local variables of this level. */
1324 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1326 tree name
= DECL_NAME (link
);
1327 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1329 /* If the ident. was used or addressed via a local extern decl,
1330 don't forget that fact. */
1331 if (DECL_EXTERNAL (link
))
1333 if (TREE_USED (link
))
1334 TREE_USED (name
) = 1;
1335 if (TREE_ADDRESSABLE (link
))
1336 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1338 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1342 /* Restore all name-meanings of the outer levels
1343 that were shadowed by this level. */
1345 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1346 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1348 /* If the level being exited is the top level of a function,
1349 check over all the labels, and clear out the current
1350 (function local) meanings of their names. */
1354 /* If this is the top level block of a function,
1355 the vars are the function's parameters.
1356 Don't leave them in the BLOCK because they are
1357 found in the FUNCTION_DECL instead. */
1359 BLOCK_VARS (block
) = 0;
1361 /* Clear out the definitions of all label names,
1362 since their scopes end here,
1363 and add them to BLOCK_VARS. */
1366 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1368 register tree label
= TREE_VALUE (link
);
1370 if (DECL_INITIAL (label
) == 0)
1372 error_with_decl (label
, "label `%s' used but not defined");
1373 /* Avoid crashing later. */
1374 define_label (input_filename
, lineno
,
1377 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1378 warning_with_decl (label
, "label `%s' defined but not used");
1379 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1381 /* Put the labels into the "variables" of the
1382 top-level block, so debugger can see them. */
1383 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1384 BLOCK_VARS (block
) = label
;
1389 /* Pop the current level, and free the structure for reuse. */
1392 register struct binding_level
*level
= current_binding_level
;
1393 current_binding_level
= current_binding_level
->level_chain
;
1395 level
->level_chain
= free_binding_level
;
1396 free_binding_level
= level
;
1399 /* Dispose of the block that we just made inside some higher level. */
1401 DECL_INITIAL (current_function_decl
) = block
;
1404 if (!block_previously_created
)
1405 current_binding_level
->blocks
1406 = chainon (current_binding_level
->blocks
, block
);
1408 /* If we did not make a block for the level just exited,
1409 any blocks made for inner levels
1410 (since they cannot be recorded as subblocks in that level)
1411 must be carried forward so they will later become subblocks
1412 of something else. */
1414 current_binding_level
->blocks
1415 = chainon (current_binding_level
->blocks
, subblocks
);
1417 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1418 binding contour so that they point to the appropriate construct, i.e.
1419 either to the current FUNCTION_DECL node, or else to the BLOCK node
1420 we just constructed.
1422 Note that for tagged types whose scope is just the formal parameter
1423 list for some function type specification, we can't properly set
1424 their TYPE_CONTEXTs here, because we don't have a pointer to the
1425 appropriate FUNCTION_TYPE node readily available to us. For those
1426 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1427 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1428 node which will represent the "scope" for these "parameter list local"
1433 TREE_USED (block
) = 1;
1438 maybe_pushlevels (pc
)
1441 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1445 while (pending_local_decls
!= NULL_TREE
&&
1446 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1448 tree
*ptr
= &pending_local_decls
;
1450 int end_pc
= DECL_LOCAL_END_PC (decl
);
1452 while (*ptr
!= NULL_TREE
1453 && DECL_LOCAL_START_PC (*ptr
) <= pc
1454 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1455 ptr
= &TREE_CHAIN (*ptr
);
1456 pending_local_decls
= *ptr
;
1459 /* Force non-nested range to be nested in current range. */
1460 if (end_pc
> current_binding_level
->end_pc
)
1461 end_pc
= current_binding_level
->end_pc
;
1463 maybe_start_try (pc
, end_pc
);
1466 expand_start_bindings (0);
1468 current_binding_level
->end_pc
= end_pc
;
1469 current_binding_level
->start_pc
= pc
;
1470 current_binding_level
->names
= decl
;
1471 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1473 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1477 maybe_start_try (pc
, 0);
1481 maybe_poplevels (pc
)
1484 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1488 while (current_binding_level
->end_pc
<= pc
)
1490 expand_end_bindings (getdecls (), 1, 0);
1491 maybe_end_try (current_binding_level
->start_pc
, pc
);
1494 maybe_end_try (0, pc
);
1497 /* Terminate any binding which began during the range beginning at
1498 start_pc. This tidies up improperly nested local variable ranges
1499 and exception handlers; a variable declared within an exception
1500 range is forcibly terminated when that exception ends. */
1503 force_poplevels (start_pc
)
1506 while (current_binding_level
->start_pc
> start_pc
)
1508 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1509 warning_with_decl (current_function_decl
,
1510 "In %s: overlapped variable and exception ranges at %d",
1511 current_binding_level
->start_pc
);
1512 expand_end_bindings (getdecls (), 1, 0);
1517 /* Insert BLOCK at the end of the list of subblocks of the
1518 current binding level. This is used when a BIND_EXPR is expanded,
1519 to handle the BLOCK node inside the BIND_EXPR. */
1522 insert_block (block
)
1525 TREE_USED (block
) = 1;
1526 current_binding_level
->blocks
1527 = chainon (current_binding_level
->blocks
, block
);
1530 /* Set the BLOCK node for the innermost scope
1531 (the one we are currently in). */
1535 register tree block
;
1537 current_binding_level
->this_block
= block
;
1538 current_binding_level
->names
= chainon (current_binding_level
->names
,
1539 BLOCK_VARS (block
));
1540 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1541 BLOCK_SUBBLOCKS (block
));
1544 /* integrate_decl_tree calls this function. */
1547 java_dup_lang_specific_decl (node
)
1551 struct lang_decl
*x
;
1553 if (!DECL_LANG_SPECIFIC (node
))
1556 if (TREE_CODE (node
) == VAR_DECL
)
1557 lang_decl_size
= sizeof (struct lang_decl_var
);
1559 lang_decl_size
= sizeof (struct lang_decl
);
1560 x
= (struct lang_decl
*) ggc_alloc (lang_decl_size
);
1561 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1562 DECL_LANG_SPECIFIC (node
) = x
;
1566 give_name_to_locals (jcf
)
1569 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1570 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1572 pending_local_decls
= NULL_TREE
;
1576 n
= JCF_readu2 (jcf
);
1577 for (i
= 0; i
< n
; i
++)
1579 int start_pc
= JCF_readu2 (jcf
);
1580 int length
= JCF_readu2 (jcf
);
1581 int name_index
= JCF_readu2 (jcf
);
1582 int signature_index
= JCF_readu2 (jcf
);
1583 int slot
= JCF_readu2 (jcf
);
1584 tree name
= get_name_constant (jcf
, name_index
);
1585 tree type
= parse_signature (jcf
, signature_index
);
1586 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1588 && length
== DECL_CODE_LENGTH (current_function_decl
))
1590 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1591 DECL_NAME (decl
) = name
;
1592 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1593 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1594 warning ("bad type in parameter debug info");
1599 int end_pc
= start_pc
+ length
;
1600 tree decl
= build_decl (VAR_DECL
, name
, type
);
1601 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1603 warning_with_decl (decl
,
1604 "bad PC range for debug info for local `%s'");
1605 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1608 /* Adjust start_pc if necessary so that the local's first
1609 store operation will use the relevant DECL as a
1610 destination. Fore more information, read the leading
1611 comments for expr.c:maybe_adjust_start_pc. */
1612 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1614 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1615 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1616 DECL_LOCAL_START_PC (decl
) = start_pc
;
1618 /* FIXME: The range used internally for exceptions and local
1619 variable ranges, is a half-open interval:
1620 start_pc <= pc < end_pc. However, the range used in the
1621 Java VM spec is inclusive at both ends:
1622 start_pc <= pc <= end_pc. */
1625 DECL_LOCAL_END_PC (decl
) = end_pc
;
1627 /* Now insert the new decl in the proper place in
1628 pending_local_decls. We are essentially doing an insertion sort,
1629 which works fine, since the list input will normally already
1631 ptr
= &pending_local_decls
;
1632 while (*ptr
!= NULL_TREE
1633 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1634 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1635 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1636 ptr
= &TREE_CHAIN (*ptr
);
1637 TREE_CHAIN (decl
) = *ptr
;
1642 pending_local_decls
= nreverse (pending_local_decls
);
1644 /* Fill in default names for the parameters. */
1645 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1646 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1648 if (DECL_NAME (parm
) == NULL_TREE
)
1650 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1652 DECL_NAME (parm
) = get_identifier ("this");
1656 sprintf (buffer
, "ARG_%d", arg_i
);
1657 DECL_NAME (parm
) = get_identifier (buffer
);
1659 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1665 build_result_decl (fndecl
)
1668 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1669 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1670 if (INTEGRAL_TYPE_P (restype
)
1671 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1672 restype
= integer_type_node
;
1673 return (DECL_RESULT (fndecl
) = build_decl (RESULT_DECL
, NULL_TREE
, restype
));
1677 complete_start_java_method (fndecl
)
1680 if (! flag_emit_class_files
)
1682 /* Initialize the RTL code for the function. */
1683 init_function_start (fndecl
, input_filename
, lineno
);
1685 /* Set up parameters and prepare for return, for the function. */
1686 expand_function_start (fndecl
, 0);
1690 /* If this fcn was already referenced via a block-scope `extern' decl (or
1691 an implicit decl), propagate certain information about the usage. */
1692 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1693 TREE_ADDRESSABLE (current_function_decl
) = 1;
1697 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1698 && ! flag_emit_class_files
1699 && ! DECL_CLINIT_P (fndecl
)
1700 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1702 tree clas
= DECL_CONTEXT (fndecl
);
1703 tree init
= build (CALL_EXPR
, void_type_node
,
1704 build_address_of (soft_initclass_node
),
1705 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1707 TREE_SIDE_EFFECTS (init
) = 1;
1708 expand_expr_stmt (init
);
1711 /* Push local variables. Function compiled from source code are
1712 using a different local variables management, and for them,
1713 pushlevel shouldn't be called from here. */
1714 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1717 if (! flag_emit_class_files
)
1718 expand_start_bindings (1);
1721 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1723 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1724 tree enter
, exit
, lock
;
1725 if (METHOD_STATIC (fndecl
))
1726 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1728 lock
= DECL_ARGUMENTS (fndecl
);
1729 BUILD_MONITOR_ENTER (enter
, lock
);
1730 BUILD_MONITOR_EXIT (exit
, lock
);
1731 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1733 expand_expr_stmt (enter
);
1734 expand_decl_cleanup (NULL_TREE
, exit
);
1738 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1739 tree body
= BLOCK_EXPR_BODY (function_body
);
1740 lock
= build (COMPOUND_EXPR
, void_type_node
,
1742 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1743 TREE_SIDE_EFFECTS (lock
) = 1;
1744 BLOCK_EXPR_BODY (function_body
) = lock
;
1750 start_java_method (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
= (tree
*) 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
);
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 (input_filename
, lineno
, 0);
1826 /* Run the optimizers and output assembler code for this function. */
1827 rest_of_compilation (fndecl
);
1829 current_function_decl
= NULL_TREE
;
1832 /* Mark language-specific parts of T for garbage-collection. */
1838 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1840 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
1841 ggc_mark_tree (li
->global_value
);
1842 ggc_mark_tree (li
->local_value
);
1843 ggc_mark_tree (li
->utf8_ref
);
1845 else if (TREE_CODE (t
) == VAR_DECL
1846 || TREE_CODE (t
) == PARM_DECL
1847 || TREE_CODE (t
) == FIELD_DECL
)
1849 struct lang_decl_var
*ldv
=
1850 ((struct lang_decl_var
*) DECL_LANG_SPECIFIC (t
));
1854 ggc_mark_tree (ldv
->slot_chain
);
1855 ggc_mark_tree (ldv
->am
);
1856 ggc_mark_tree (ldv
->wfl
);
1859 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1861 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
1866 ggc_mark_tree (ld
->wfl
);
1867 ggc_mark_tree (ld
->throws_list
);
1868 ggc_mark_tree (ld
->function_decl_body
);
1869 ggc_mark_tree (ld
->called_constructor
);
1870 ggc_mark_tree (ld
->inner_access
);
1871 ggc_mark_tree_hash_table (&ld
->init_test_table
);
1872 ggc_mark_tree_hash_table (&ld
->ict
);
1873 ggc_mark_tree (ld
->smic
);
1876 else if (TYPE_P (t
))
1878 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
1883 ggc_mark_tree (lt
->signature
);
1884 ggc_mark_tree (lt
->cpool_data_ref
);
1885 ggc_mark_tree (lt
->finit_stmt_list
);
1886 ggc_mark_tree (lt
->clinit_stmt_list
);
1887 ggc_mark_tree (lt
->ii_block
);
1888 ggc_mark_tree (lt
->dot_class
);
1889 ggc_mark_tree (lt
->package_list
);