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. */
35 #include "java-tree.h"
41 #include "java-except.h"
44 #if defined (DEBUG_JAVA_BINDING_LEVELS)
45 extern void indent
PROTO((void));
48 static tree push_jvm_slot
PARAMS ((int, tree
));
49 static tree lookup_name_current_level
PARAMS ((tree
));
50 static tree push_promoted_type
PARAMS ((const char *, tree
));
51 static struct binding_level
*make_binding_level
PARAMS ((void));
52 static tree create_primitive_vtable
PARAMS ((const char *));
53 static tree check_local_named_variable
PARAMS ((tree
, tree
, int, int *));
54 static tree check_local_unnamed_variable
PARAMS ((tree
, tree
, tree
));
56 /* Set to non-zero value in order to emit class initilization code
57 before static field references. */
58 extern int always_initialize_class_p
;
60 /* The DECL_MAP is a mapping from (index, type) to a decl node.
61 If index < max_locals, it is the index of a local variable.
62 if index >= max_locals, then index-max_locals is a stack slot.
63 The DECL_MAP mapping is represented as a TREE_VEC whose elements
64 are a list of decls (VAR_DECL or PARM_DECL) chained by
65 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
66 we search the chain for a decl with a matching TREE_TYPE. */
70 /* A list of local variables VAR_DECLs for this method that we have seen
71 debug information, but we have not reached their starting (byte) PC yet. */
73 static tree pending_local_decls
= NULL_TREE
;
75 /* Push a local variable or stack slot into the decl_map,
76 and assign it an rtl. */
78 #if defined(DEBUG_JAVA_BINDING_LEVELS)
79 int binding_depth
= 0;
80 int is_class_level
= 0;
88 for (i
= 0; i
< binding_depth
*2; i
++)
91 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
94 push_jvm_slot (index
, decl
)
98 struct rtx_def
*rtl
= NULL
;
99 tree type
= TREE_TYPE (decl
);
102 DECL_CONTEXT (decl
) = current_function_decl
;
103 layout_decl (decl
, 0);
105 /* See if we have an appropriate rtl (i.e. same mode) at this index.
106 If so, we must use it. */
107 tmp
= TREE_VEC_ELT (decl_map
, index
);
108 while (tmp
!= NULL_TREE
)
110 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
111 rtl
= DECL_RTL_IF_SET (tmp
);
114 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
117 SET_DECL_RTL (decl
, rtl
);
120 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
121 DECL_REGISTER (decl
) = 1;
125 /* Now link the decl into the decl_map. */
126 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
128 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
129 DECL_LOCAL_START_PC (decl
) = 0;
130 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
131 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
133 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
134 TREE_VEC_ELT (decl_map
, index
) = decl
;
138 /* Find out if 'decl' passed in fits the defined PC location better than
139 'best'. Return decl if it does, return best if it doesn't. If decl
140 is returned, then updated is set to true. */
143 check_local_named_variable (best
, decl
, pc
, updated
)
149 if (pc
>= DECL_LOCAL_START_PC (decl
)
150 && pc
< DECL_LOCAL_END_PC (decl
))
152 if (best
== NULL_TREE
153 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
154 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
164 /* Find the best declaration based upon type. If 'decl' fits 'type' better
165 than 'best', return 'decl'. Otherwise return 'best'. */
168 check_local_unnamed_variable (best
, decl
, type
)
173 if (TREE_TYPE (decl
) == type
174 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
175 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
176 && TYPE_PRECISION (type
) <= 32
177 && TREE_CODE (type
) != POINTER_TYPE
)
178 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
179 && type
== ptr_type_node
))
181 if (best
== NULL_TREE
182 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
190 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
191 that is valid at PC (or -1 if any pc).
192 If there is no existing matching decl, allocate one. */
195 find_local_variable (index
, type
, 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 (index
, type
)
248 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
254 /* A chain of _DECL nodes for all variables, constants, functions,
255 * and typedef types. These are in the reverse of the order supplied.
259 /* For each level, a list of shadowed outer-level local definitions
260 to be restored when this level is popped.
261 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
262 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
265 /* For each level (except not the global one),
266 a chain of BLOCK nodes for all the levels
267 that were entered and exited one level down. */
270 /* The BLOCK node for this level, if one has been preallocated.
271 If 0, the BLOCK is allocated (if needed) when the level is popped. */
274 /* The binding level which this one is contained in (inherits from). */
275 struct binding_level
*level_chain
;
277 /* The bytecode PC that marks the end of this level. */
279 /* The bytecode PC that marks the start of this level. */
282 #if defined(DEBUG_JAVA_BINDING_LEVELS)
283 /* Binding depth at which this level began. */
284 unsigned binding_depth
;
285 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
288 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
290 /* The binding level currently in effect. */
292 static struct binding_level
*current_binding_level
;
294 /* A chain of binding_level structures awaiting reuse. */
296 static struct binding_level
*free_binding_level
;
298 /* The outermost binding level, for names of file scope.
299 This is created when the compiler is started and exists
300 through the entire run. */
302 static struct binding_level
*global_binding_level
;
304 /* A PC value bigger than any PC value we may ever may encounter. */
306 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
308 /* Binding level structures are initialized by copying this one. */
310 static struct binding_level clear_binding_level
311 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
312 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
315 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
316 that have names. Here so we can clear out their names' definitions
317 at the end of the function. */
319 static tree named_labels
;
321 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
323 static tree shadowed_labels
;
326 tree java_global_trees
[JTI_MAX
];
328 /* Build (and pushdecl) a "promoted type" for all standard
329 types shorter than int. */
332 push_promoted_type (name
, actual_type
)
336 tree type
= make_node (TREE_CODE (actual_type
));
338 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
339 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
341 tree in_min
= TYPE_MIN_VALUE (actual_type
);
342 tree in_max
= TYPE_MAX_VALUE (actual_type
);
344 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
345 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
346 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
347 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
348 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
350 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
354 /* Return a definition for a builtin function named NAME and whose data type
355 is TYPE. TYPE should be a function type with argument types.
356 FUNCTION_CODE tells later passes how to compile calls to this function.
357 See tree.h for its possible values.
359 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
360 the name to be called if we can't opencode the function. */
363 builtin_function (name
, type
, function_code
, class, library_name
)
367 enum built_in_class
class;
368 const char *library_name
;
370 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
371 DECL_EXTERNAL (decl
) = 1;
372 TREE_PUBLIC (decl
) = 1;
374 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
375 make_decl_rtl (decl
, NULL
);
377 DECL_BUILT_IN_CLASS (decl
) = class;
378 DECL_FUNCTION_CODE (decl
) = function_code
;
382 /* Return tree that represents a vtable for a primitive array. */
384 create_primitive_vtable (name
)
390 sprintf (buf
, "_Jv_%sVTable", name
);
391 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
392 DECL_EXTERNAL (r
) = 1;
397 java_init_decl_processing ()
399 register tree endlink
;
400 tree field
= NULL_TREE
;
403 init_class_processing ();
405 current_function_decl
= NULL
;
406 current_binding_level
= NULL_BINDING_LEVEL
;
407 free_binding_level
= NULL_BINDING_LEVEL
;
408 pushlevel (0); /* make the binding_level structure for global names */
409 global_binding_level
= current_binding_level
;
411 /* The code here must be similar to build_common_tree_nodes{,_2} in
412 tree.c, especially as to the order of initializing common nodes. */
413 error_mark_node
= make_node (ERROR_MARK
);
414 TREE_TYPE (error_mark_node
) = error_mark_node
;
416 /* Create sizetype first - needed for other types. */
417 initialize_sizetypes ();
419 byte_type_node
= make_signed_type (8);
420 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
421 short_type_node
= make_signed_type (16);
422 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
423 int_type_node
= make_signed_type (32);
424 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
425 long_type_node
= make_signed_type (64);
426 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
428 unsigned_byte_type_node
= make_unsigned_type (8);
429 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
430 unsigned_byte_type_node
));
431 unsigned_short_type_node
= make_unsigned_type (16);
432 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
433 unsigned_short_type_node
));
434 unsigned_int_type_node
= make_unsigned_type (32);
435 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
436 unsigned_int_type_node
));
437 unsigned_long_type_node
= make_unsigned_type (64);
438 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
439 unsigned_long_type_node
));
441 set_sizetype (make_unsigned_type (POINTER_SIZE
));
443 /* Define these next since types below may used them. */
444 integer_type_node
= type_for_size (INT_TYPE_SIZE
, 0);
445 integer_zero_node
= build_int_2 (0, 0);
446 integer_one_node
= build_int_2 (1, 0);
447 integer_two_node
= build_int_2 (2, 0);
448 integer_four_node
= build_int_2 (4, 0);
449 integer_minus_one_node
= build_int_2 (-1, -1);
451 size_zero_node
= size_int (0);
452 size_one_node
= size_int (1);
453 bitsize_zero_node
= bitsize_int (0);
454 bitsize_one_node
= bitsize_int (1);
455 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
457 long_zero_node
= build_int_2 (0, 0);
458 TREE_TYPE (long_zero_node
) = long_type_node
;
460 void_type_node
= make_node (VOID_TYPE
);
461 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
462 layout_type (void_type_node
); /* Uses size_zero_node */
463 ptr_type_node
= build_pointer_type (void_type_node
);
464 t
= make_node (VOID_TYPE
);
465 layout_type (t
); /* Uses size_zero_node */
466 return_address_type_node
= build_pointer_type (t
);
468 null_pointer_node
= build_int_2 (0, 0);
469 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
471 /* Used by the parser to represent empty statements and blocks. */
472 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
473 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
476 /* Make a type to be the domain of a few array types
477 whose domains don't really matter.
478 200 is small enough that it always fits in size_t
479 and large enough that it can hold most function names for the
480 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
481 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
483 char_type_node
= make_node (CHAR_TYPE
);
484 TYPE_PRECISION (char_type_node
) = 16;
485 fixup_unsigned_type (char_type_node
);
486 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
488 boolean_type_node
= make_node (BOOLEAN_TYPE
);
489 TYPE_PRECISION (boolean_type_node
) = 1;
490 fixup_unsigned_type (boolean_type_node
);
491 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
493 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
494 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
496 promoted_byte_type_node
497 = push_promoted_type ("promoted_byte", byte_type_node
);
498 promoted_short_type_node
499 = push_promoted_type ("promoted_short", short_type_node
);
500 promoted_char_type_node
501 = push_promoted_type ("promoted_char", char_type_node
);
502 promoted_boolean_type_node
503 = push_promoted_type ("promoted_boolean", boolean_type_node
);
505 float_type_node
= make_node (REAL_TYPE
);
506 TYPE_PRECISION (float_type_node
) = 32;
507 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
509 layout_type (float_type_node
);
511 double_type_node
= make_node (REAL_TYPE
);
512 TYPE_PRECISION (double_type_node
) = 64;
513 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
515 layout_type (double_type_node
);
517 float_zero_node
= build_real (float_type_node
, dconst0
);
518 double_zero_node
= build_real (double_type_node
, dconst0
);
520 /* These are the vtables for arrays of primitives. */
521 boolean_array_vtable
= create_primitive_vtable ("boolean");
522 byte_array_vtable
= create_primitive_vtable ("byte");
523 char_array_vtable
= create_primitive_vtable ("char");
524 short_array_vtable
= create_primitive_vtable ("short");
525 int_array_vtable
= create_primitive_vtable ("int");
526 long_array_vtable
= create_primitive_vtable ("long");
527 float_array_vtable
= create_primitive_vtable ("float");
528 double_array_vtable
= create_primitive_vtable ("double");
530 /* As you're adding items here, please update the code right after
531 this section, so that the filename containing the source code of
532 the pre-defined class gets registered correctly. */
533 unqualified_object_id_node
= get_identifier ("Object");
534 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
535 object_ptr_type_node
= promote_type (object_type_node
);
536 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
537 string_ptr_type_node
= promote_type (string_type_node
);
538 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
539 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
540 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
541 runtime_exception_type_node
=
542 lookup_class (get_identifier ("java.lang.RuntimeException"));
543 error_exception_type_node
=
544 lookup_class (get_identifier ("java.lang.Error"));
545 class_not_found_type_node
=
546 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
547 no_class_def_found_type_node
=
548 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
550 rawdata_ptr_type_node
551 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
553 add_predefined_file (get_identifier ("java/lang/Class.java"));
554 add_predefined_file (get_identifier ("java/lang/Error.java"));
555 add_predefined_file (get_identifier ("java/lang/Object.java"));
556 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
557 add_predefined_file (get_identifier ("java/lang/String.java"));
558 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
559 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
560 add_predefined_file (get_identifier ("java/lang/Exception.java"));
561 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
562 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
563 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
565 methodtable_type
= make_node (RECORD_TYPE
);
566 layout_type (methodtable_type
);
567 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
568 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
570 TYPE_identifier_node
= get_identifier ("TYPE");
571 init_identifier_node
= get_identifier ("<init>");
572 clinit_identifier_node
= get_identifier ("<clinit>");
573 finit_identifier_node
= get_identifier ("finit$");
574 instinit_identifier_node
= get_identifier ("instinit$");
575 void_signature_node
= get_identifier ("()V");
576 length_identifier_node
= get_identifier ("length");
577 finalize_identifier_node
= get_identifier ("finalize");
578 this_identifier_node
= get_identifier ("this");
579 super_identifier_node
= get_identifier ("super");
580 continue_identifier_node
= get_identifier ("continue");
581 access0_identifier_node
= get_identifier ("access$0");
582 classdollar_identifier_node
= get_identifier ("class$");
584 /* for lack of a better place to put this stub call */
585 init_expr_processing();
587 utf8const_type
= make_node (RECORD_TYPE
);
588 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
589 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
590 FINISH_RECORD (utf8const_type
);
591 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
593 constants_type_node
= make_node (RECORD_TYPE
);
594 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
595 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
596 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
597 FINISH_RECORD (constants_type_node
);
598 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
600 access_flags_type_node
= unsigned_short_type_node
;
602 dtable_type
= make_node (RECORD_TYPE
);
603 dtable_ptr_type
= build_pointer_type (dtable_type
);
605 one_elt_array_domain_type
= build_index_type (integer_one_node
);
606 otable_type
= build_array_type (integer_type_node
,
607 one_elt_array_domain_type
);
608 otable_ptr_type
= build_pointer_type (otable_type
);
610 method_symbol_type
= make_node (RECORD_TYPE
);
611 PUSH_FIELD (method_symbol_type
, field
, "clname", utf8const_ptr_type
);
612 PUSH_FIELD (method_symbol_type
, field
, "name", utf8const_ptr_type
);
613 PUSH_FIELD (method_symbol_type
, field
, "signature", utf8const_ptr_type
);
614 FINISH_RECORD (method_symbol_type
);
616 method_symbols_array_type
= build_array_type (method_symbol_type
,
617 one_elt_array_domain_type
);
618 method_symbols_array_ptr_type
= build_pointer_type
619 (method_symbols_array_type
);
621 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"), otable_type
);
622 DECL_EXTERNAL (otable_decl
) = 1;
623 TREE_STATIC (otable_decl
) = 1;
624 TREE_READONLY (otable_decl
) = 1;
625 pushdecl (otable_decl
);
627 otable_syms_decl
= build_decl (VAR_DECL
, get_identifier ("otable_syms"),
628 method_symbols_array_type
);
629 TREE_STATIC (otable_syms_decl
) = 1;
630 TREE_CONSTANT (otable_syms_decl
) = 1;
631 pushdecl (otable_syms_decl
);
633 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
634 /* This isn't exactly true, but it is what we have in the source.
635 There is an unresolved issue here, which is whether the vtable
636 should be marked by the GC. */
637 if (! flag_hash_synchronization
)
638 PUSH_FIELD (object_type_node
, field
, "sync_info",
639 build_pointer_type (object_type_node
));
640 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
641 FIELD_PRIVATE (t
) = 1;
642 FINISH_RECORD (object_type_node
);
644 field_type_node
= make_node (RECORD_TYPE
);
645 field_ptr_type_node
= build_pointer_type (field_type_node
);
646 method_type_node
= make_node (RECORD_TYPE
);
647 method_ptr_type_node
= build_pointer_type (method_type_node
);
649 set_super_info (0, class_type_node
, object_type_node
, 0);
650 set_super_info (0, string_type_node
, object_type_node
, 0);
651 class_ptr_type
= build_pointer_type (class_type_node
);
653 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
654 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
655 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
656 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
657 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
658 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
659 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
660 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
661 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
662 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
663 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
664 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
665 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
666 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
667 PUSH_FIELD (class_type_node
, field
, "otable_syms",
668 method_symbols_array_ptr_type
);
669 PUSH_FIELD (class_type_node
, field
, "interfaces",
670 build_pointer_type (class_ptr_type
));
671 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
672 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
673 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
674 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
675 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
676 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
677 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
678 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
679 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
680 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
681 FIELD_PRIVATE (t
) = 1;
682 push_super_field (class_type_node
, object_type_node
);
684 FINISH_RECORD (class_type_node
);
685 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
687 field_info_union_node
= make_node (UNION_TYPE
);
688 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
689 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
691 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
693 layout_type (field_info_union_node
);
695 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
696 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
697 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
698 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
699 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
700 FINISH_RECORD (field_type_node
);
701 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
703 nativecode_ptr_array_type_node
704 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
706 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
707 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
708 FINISH_RECORD (dtable_type
);
709 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
711 #define jint_type int_type_node
712 #define jint_ptr_type ptr_type_node
714 jexception_type
= make_node (RECORD_TYPE
);
715 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
716 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
717 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
718 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
719 FINISH_RECORD (jexception_type
);
720 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
721 jexception_ptr_type
= build_pointer_type (jexception_type
);
723 lineNumberEntry_type
= make_node (RECORD_TYPE
);
724 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
725 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
726 FINISH_RECORD (lineNumberEntry_type
);
728 lineNumbers_type
= make_node (RECORD_TYPE
);
729 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
730 FINISH_RECORD (lineNumbers_type
);
732 #define instn_ptr_type_node ptr_type_node /* XXX JH */
734 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
736 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
737 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
738 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
739 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
740 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
741 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
742 FINISH_RECORD (method_type_node
);
743 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
745 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
747 t
= tree_cons (NULL_TREE
, class_ptr_type
,
748 tree_cons (NULL_TREE
, int_type_node
, endlink
));
749 alloc_object_node
= builtin_function ("_Jv_AllocObject",
750 build_function_type (ptr_type_node
, t
),
751 0, NOT_BUILT_IN
, NULL
);
752 DECL_IS_MALLOC (alloc_object_node
) = 1;
753 alloc_no_finalizer_node
=
754 builtin_function ("_Jv_AllocObjectNoFinalizer",
755 build_function_type (ptr_type_node
, t
),
756 0, NOT_BUILT_IN
, NULL
);
757 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
759 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
760 soft_initclass_node
= builtin_function ("_Jv_InitClass",
761 build_function_type (void_type_node
,
763 0, NOT_BUILT_IN
, NULL
);
765 throw_node
= builtin_function ("_Jv_Throw",
766 build_function_type (ptr_type_node
, t
),
767 0, NOT_BUILT_IN
, NULL
);
768 /* Mark throw_nodes as `noreturn' functions with side effects. */
769 TREE_THIS_VOLATILE (throw_node
) = 1;
770 TREE_SIDE_EFFECTS (throw_node
) = 1;
772 t
= build_function_type (int_type_node
, endlink
);
773 soft_monitorenter_node
774 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
, NULL
);
775 soft_monitorexit_node
776 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
, NULL
);
778 t
= tree_cons (NULL_TREE
, int_type_node
,
779 tree_cons (NULL_TREE
, int_type_node
, endlink
));
781 = builtin_function ("_Jv_NewPrimArray",
782 build_function_type(ptr_type_node
, t
),
783 0, NOT_BUILT_IN
, NULL
);
784 DECL_IS_MALLOC (soft_newarray_node
) = 1;
786 t
= tree_cons (NULL_TREE
, int_type_node
,
787 tree_cons (NULL_TREE
, class_ptr_type
,
788 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
790 = builtin_function ("_Jv_NewObjectArray",
791 build_function_type (ptr_type_node
, t
),
792 0, NOT_BUILT_IN
, NULL
);
793 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
795 t
= tree_cons (NULL_TREE
, ptr_type_node
,
796 tree_cons (NULL_TREE
, int_type_node
, endlink
));
797 soft_multianewarray_node
798 = builtin_function ("_Jv_NewMultiArray",
799 build_function_type (ptr_type_node
, t
),
800 0, NOT_BUILT_IN
, NULL
);
801 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
803 t
= build_function_type (void_type_node
,
804 tree_cons (NULL_TREE
, int_type_node
, endlink
));
805 soft_badarrayindex_node
806 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
807 0, NOT_BUILT_IN
, NULL
);
808 /* Mark soft_badarrayindex_node as a `noreturn' function with side
810 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
811 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
813 soft_nullpointer_node
814 = builtin_function ("_Jv_ThrowNullPointerException",
815 build_function_type (void_type_node
, endlink
),
816 0, NOT_BUILT_IN
, NULL
);
817 /* Mark soft_nullpointer_node as a `noreturn' function with side
819 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
820 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
822 t
= tree_cons (NULL_TREE
, class_ptr_type
,
823 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
825 = builtin_function ("_Jv_CheckCast",
826 build_function_type (ptr_type_node
, t
),
827 0, NOT_BUILT_IN
, NULL
);
828 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
829 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
831 = builtin_function ("_Jv_IsInstanceOf",
832 build_function_type (boolean_type_node
, t
),
833 0, NOT_BUILT_IN
, NULL
);
834 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
835 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
836 soft_checkarraystore_node
837 = builtin_function ("_Jv_CheckArrayStore",
838 build_function_type (void_type_node
, t
),
839 0, NOT_BUILT_IN
, NULL
);
840 t
= tree_cons (NULL_TREE
, ptr_type_node
,
841 tree_cons (NULL_TREE
, ptr_type_node
,
842 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
843 soft_lookupinterfacemethod_node
844 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
845 build_function_type (ptr_type_node
, t
),
846 0, NOT_BUILT_IN
, NULL
);
848 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
849 tree_cons (NULL_TREE
, ptr_type_node
,
850 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
851 soft_lookupjnimethod_node
852 = builtin_function ("_Jv_LookupJNIMethod",
853 build_function_type (ptr_type_node
, t
),
854 0, NOT_BUILT_IN
, NULL
);
855 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
856 soft_getjnienvnewframe_node
857 = builtin_function ("_Jv_GetJNIEnvNewFrame",
858 build_function_type (ptr_type_node
, t
),
859 0, NOT_BUILT_IN
, NULL
);
860 soft_jnipopsystemframe_node
861 = builtin_function ("_Jv_JNI_PopSystemFrame",
862 build_function_type (ptr_type_node
, t
),
863 0, NOT_BUILT_IN
, NULL
);
865 t
= tree_cons (NULL_TREE
, double_type_node
,
866 tree_cons (NULL_TREE
, double_type_node
, endlink
));
868 = builtin_function ("__builtin_fmod",
869 build_function_type (double_type_node
, t
),
870 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmod");
873 t
= tree_cons (NULL_TREE
, float_type_node
,
874 tree_cons (NULL_TREE
, float_type_node
, endlink
));
876 = builtin_function ("__builtin_fmodf",
877 build_function_type (float_type_node
, t
),
878 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf");
882 = builtin_function ("_Jv_divI",
883 build_function_type (int_type_node
, t
),
884 0, NOT_BUILT_IN
, NULL
);
887 = builtin_function ("_Jv_remI",
888 build_function_type (int_type_node
, t
),
889 0, NOT_BUILT_IN
, NULL
);
892 = builtin_function ("_Jv_divJ",
893 build_function_type (long_type_node
, t
),
894 0, NOT_BUILT_IN
, NULL
);
897 = builtin_function ("_Jv_remJ",
898 build_function_type (long_type_node
, t
),
899 0, NOT_BUILT_IN
, NULL
);
901 /* Initialize variables for except.c. */
902 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
903 ? "__gcj_personality_sj0"
904 : "__gcj_personality_v0");
905 lang_eh_runtime_type
= prepare_eh_table_type
;
909 /* Register nodes with the garbage collector. */
910 ggc_add_tree_root (java_global_trees
, ARRAY_SIZE (java_global_trees
));
911 ggc_add_tree_root (&decl_map
, 1);
912 ggc_add_tree_root (&pending_local_decls
, 1);
914 initialize_builtins ();
918 /* Look up NAME in the current binding level and its superiors
919 in the namespace of variables, functions and typedefs.
920 Return a ..._DECL node of some kind representing its definition,
921 or return 0 if it is undefined. */
928 if (current_binding_level
!= global_binding_level
929 && IDENTIFIER_LOCAL_VALUE (name
))
930 val
= IDENTIFIER_LOCAL_VALUE (name
);
932 val
= IDENTIFIER_GLOBAL_VALUE (name
);
936 /* Similar to `lookup_name' but look only at current binding level and
937 the previous one if its the parameter level. */
940 lookup_name_current_level (name
)
945 if (current_binding_level
== global_binding_level
)
946 return IDENTIFIER_GLOBAL_VALUE (name
);
948 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
951 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
952 if (DECL_NAME (t
) == name
)
958 /* Use a binding level to record a labeled block declaration */
961 push_labeled_block (lb
)
964 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
965 register struct binding_level
*b
= current_binding_level
;
966 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
968 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
969 TREE_CHAIN (lb
) = b
->names
;
971 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
974 /* Pop the current binding level, reinstalling values for the previous
980 struct binding_level
*b
= current_binding_level
;
981 tree label
= b
->names
;
982 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
985 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
986 TREE_VALUE (b
->shadowed
);
988 /* Pop the current level, and free the structure for reuse. */
989 current_binding_level
= current_binding_level
->level_chain
;
990 b
->level_chain
= free_binding_level
;
991 free_binding_level
= b
;
994 /* Record a decl-node X as belonging to the current lexical scope.
995 Check for errors (such as an incompatible declaration for the same
996 name already seen in the same scope).
998 Returns either X or an old decl for the same name.
999 If an old decl is returned, it may have been smashed
1000 to agree with what X says. */
1007 register tree name
= DECL_NAME (x
);
1008 register struct binding_level
*b
= current_binding_level
;
1010 if (TREE_CODE (x
) != TYPE_DECL
)
1011 DECL_CONTEXT (x
) = current_function_decl
;
1017 t
= lookup_name_current_level (name
);
1018 if (t
!= 0 && t
== error_mark_node
)
1019 /* error_mark_node is 0 for a while during initialization! */
1022 error_with_decl (x
, "`%s' used prior to declaration");
1027 file
= DECL_SOURCE_FILE (t
);
1028 line
= DECL_SOURCE_LINE (t
);
1031 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1032 to point to the TYPE_DECL.
1033 Since Java does not have typedefs, a type can only have
1034 one (true) name, given by a class, interface, or builtin. */
1035 if (TREE_CODE (x
) == TYPE_DECL
1036 && TYPE_NAME (TREE_TYPE (x
)) == 0
1037 && TREE_TYPE (x
) != error_mark_node
)
1039 TYPE_NAME (TREE_TYPE (x
)) = x
;
1040 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1043 /* This name is new in its binding level.
1044 Install the new declaration and return it. */
1045 if (b
== global_binding_level
)
1047 /* Install a global value. */
1049 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1053 /* Here to install a non-global value. */
1054 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1055 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1058 /* Warn if shadowing an argument at the top level of the body. */
1059 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1060 /* This warning doesn't apply to the parms of a nested fcn. */
1061 && ! current_binding_level
->parm_flag
1062 /* Check that this is one level down from the parms. */
1063 && current_binding_level
->level_chain
->parm_flag
1064 /* Check that the decl being shadowed
1065 comes from the parm level, one level up. */
1066 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1068 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1069 pedwarn ("declaration of `%s' shadows a parameter",
1070 IDENTIFIER_POINTER (name
));
1072 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1073 IDENTIFIER_POINTER (name
));
1076 /* Maybe warn if shadowing something else. */
1077 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1078 /* No shadow warnings for internally generated vars. */
1079 && DECL_SOURCE_LINE (x
) != 0
1080 /* No shadow warnings for vars made for inlining. */
1081 && ! DECL_FROM_INLINE (x
))
1083 const char *warnstring
= 0;
1085 if (TREE_CODE (x
) == PARM_DECL
1086 && current_binding_level
->level_chain
->parm_flag
)
1087 /* Don't warn about the parm names in function declarator
1088 within a function declarator.
1089 It would be nice to avoid warning in any function
1090 declarator in a declaration, as opposed to a definition,
1091 but there is no way to tell it's not a definition. */
1093 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1094 warnstring
= "declaration of `%s' shadows a parameter";
1095 else if (oldlocal
!= 0)
1096 warnstring
= "declaration of `%s' shadows previous local";
1097 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1098 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1099 warnstring
= "declaration of `%s' shadows global declaration";
1102 warning (warnstring
, IDENTIFIER_POINTER (name
));
1106 /* If storing a local value, there may already be one (inherited).
1107 If so, record it for restoration when this binding level ends. */
1109 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1113 /* Put decls on list in reverse order.
1114 We will reverse them later if necessary. */
1115 TREE_CHAIN (x
) = b
->names
;
1122 pushdecl_force_head (x
)
1125 current_binding_level
->names
= x
;
1128 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1131 pushdecl_top_level (x
)
1135 register struct binding_level
*b
= current_binding_level
;
1137 current_binding_level
= global_binding_level
;
1139 current_binding_level
= b
;
1143 /* Nonzero if we are currently in the global binding level. */
1146 global_bindings_p ()
1148 return current_binding_level
== global_binding_level
;
1151 /* Return the list of declarations of the current level.
1152 Note that this list is in reverse order unless/until
1153 you nreverse it; and when you do nreverse it, you must
1154 store the result back using `storedecls' or you will lose. */
1159 return current_binding_level
->names
;
1162 /* Create a new `struct binding_level'. */
1164 static struct binding_level
*
1165 make_binding_level ()
1168 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
1173 int unused ATTRIBUTE_UNUSED
;
1175 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1178 /* If this is the top level of a function,
1179 just make sure that NAMED_LABELS is 0. */
1181 if (current_binding_level
== global_binding_level
)
1185 /* Reuse or create a struct for this binding level. */
1187 if (free_binding_level
)
1189 newlevel
= free_binding_level
;
1190 free_binding_level
= free_binding_level
->level_chain
;
1194 newlevel
= make_binding_level ();
1197 /* Add this level to the front of the chain (stack) of levels that
1200 *newlevel
= clear_binding_level
;
1201 newlevel
->level_chain
= current_binding_level
;
1202 current_binding_level
= newlevel
;
1203 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1204 newlevel
->binding_depth
= binding_depth
;
1206 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1207 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1210 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1213 /* Exit a binding level.
1214 Pop the level off, and restore the state of the identifier-decl mappings
1215 that were in effect when this level was entered.
1217 If KEEP is nonzero, this level had explicit declarations, so
1218 and create a "block" (a BLOCK node) for the level
1219 to record its declarations and subblocks for symbol table output.
1221 If FUNCTIONBODY is nonzero, this level is the body of a function,
1222 so create a block as if KEEP were set and also clear out all
1225 If REVERSE is nonzero, reverse the order of decls before putting
1226 them into the BLOCK. */
1229 poplevel (keep
, reverse
, functionbody
)
1235 /* The chain of decls was accumulated in reverse order.
1236 Put it into forward order, just for cleanliness. */
1238 tree subblocks
= current_binding_level
->blocks
;
1241 int block_previously_created
;
1243 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1246 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1247 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1248 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1249 current_binding_level
->end_pc
);
1251 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1252 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1254 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1257 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1261 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1263 /* Get the decls in the order they were written.
1264 Usually current_binding_level->names is in reverse order.
1265 But parameter decls were previously put in forward order. */
1268 current_binding_level
->names
1269 = decls
= nreverse (current_binding_level
->names
);
1271 decls
= current_binding_level
->names
;
1273 /* Output any nested inline functions within this block
1274 if they weren't already output. */
1276 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1277 if (TREE_CODE (decl
) == FUNCTION_DECL
1278 && ! TREE_ASM_WRITTEN (decl
)
1279 && DECL_INITIAL (decl
) != 0
1280 && TREE_ADDRESSABLE (decl
))
1282 /* If this decl was copied from a file-scope decl
1283 on account of a block-scope extern decl,
1284 propagate TREE_ADDRESSABLE to the file-scope decl.
1286 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1287 true, since then the decl goes through save_for_inline_copying. */
1288 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1289 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1290 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1293 push_function_context ();
1294 output_inline_function (decl
);
1295 pop_function_context ();
1299 /* If there were any declarations in that level,
1300 or if this level is a function body,
1301 create a BLOCK to record them for the life of this function. */
1304 block_previously_created
= (current_binding_level
->this_block
!= 0);
1305 if (block_previously_created
)
1306 block
= current_binding_level
->this_block
;
1307 else if (keep
|| functionbody
)
1308 block
= make_node (BLOCK
);
1311 BLOCK_VARS (block
) = decls
;
1312 BLOCK_SUBBLOCKS (block
) = subblocks
;
1315 /* In each subblock, record that this is its superior. */
1317 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1318 BLOCK_SUPERCONTEXT (link
) = block
;
1320 /* Clear out the meanings of the local variables of this level. */
1322 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1324 tree name
= DECL_NAME (link
);
1325 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1327 /* If the ident. was used or addressed via a local extern decl,
1328 don't forget that fact. */
1329 if (DECL_EXTERNAL (link
))
1331 if (TREE_USED (link
))
1332 TREE_USED (name
) = 1;
1333 if (TREE_ADDRESSABLE (link
))
1334 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1336 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1340 /* Restore all name-meanings of the outer levels
1341 that were shadowed by this level. */
1343 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1344 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1346 /* If the level being exited is the top level of a function,
1347 check over all the labels, and clear out the current
1348 (function local) meanings of their names. */
1352 /* If this is the top level block of a function,
1353 the vars are the function's parameters.
1354 Don't leave them in the BLOCK because they are
1355 found in the FUNCTION_DECL instead. */
1357 BLOCK_VARS (block
) = 0;
1359 /* Clear out the definitions of all label names,
1360 since their scopes end here,
1361 and add them to BLOCK_VARS. */
1364 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1366 register tree label
= TREE_VALUE (link
);
1368 if (DECL_INITIAL (label
) == 0)
1370 error_with_decl (label
, "label `%s' used but not defined");
1371 /* Avoid crashing later. */
1372 define_label (input_filename
, lineno
,
1375 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1376 warning_with_decl (label
, "label `%s' defined but not used");
1377 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1379 /* Put the labels into the "variables" of the
1380 top-level block, so debugger can see them. */
1381 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1382 BLOCK_VARS (block
) = label
;
1387 /* Pop the current level, and free the structure for reuse. */
1390 register struct binding_level
*level
= current_binding_level
;
1391 current_binding_level
= current_binding_level
->level_chain
;
1393 level
->level_chain
= free_binding_level
;
1394 free_binding_level
= level
;
1397 /* Dispose of the block that we just made inside some higher level. */
1399 DECL_INITIAL (current_function_decl
) = block
;
1402 if (!block_previously_created
)
1403 current_binding_level
->blocks
1404 = chainon (current_binding_level
->blocks
, block
);
1406 /* If we did not make a block for the level just exited,
1407 any blocks made for inner levels
1408 (since they cannot be recorded as subblocks in that level)
1409 must be carried forward so they will later become subblocks
1410 of something else. */
1412 current_binding_level
->blocks
1413 = chainon (current_binding_level
->blocks
, subblocks
);
1415 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1416 binding contour so that they point to the appropriate construct, i.e.
1417 either to the current FUNCTION_DECL node, or else to the BLOCK node
1418 we just constructed.
1420 Note that for tagged types whose scope is just the formal parameter
1421 list for some function type specification, we can't properly set
1422 their TYPE_CONTEXTs here, because we don't have a pointer to the
1423 appropriate FUNCTION_TYPE node readily available to us. For those
1424 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1425 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1426 node which will represent the "scope" for these "parameter list local"
1431 TREE_USED (block
) = 1;
1436 maybe_pushlevels (pc
)
1439 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1443 while (pending_local_decls
!= NULL_TREE
&&
1444 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1446 tree
*ptr
= &pending_local_decls
;
1448 int end_pc
= DECL_LOCAL_END_PC (decl
);
1450 while (*ptr
!= NULL_TREE
1451 && DECL_LOCAL_START_PC (*ptr
) <= pc
1452 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1453 ptr
= &TREE_CHAIN (*ptr
);
1454 pending_local_decls
= *ptr
;
1457 /* Force non-nested range to be nested in current range. */
1458 if (end_pc
> current_binding_level
->end_pc
)
1459 end_pc
= current_binding_level
->end_pc
;
1461 maybe_start_try (pc
, end_pc
);
1464 expand_start_bindings (0);
1466 current_binding_level
->end_pc
= end_pc
;
1467 current_binding_level
->start_pc
= pc
;
1468 current_binding_level
->names
= decl
;
1469 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1471 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1475 maybe_start_try (pc
, 0);
1479 maybe_poplevels (pc
)
1482 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1486 while (current_binding_level
->end_pc
<= pc
)
1488 expand_end_bindings (getdecls (), 1, 0);
1489 maybe_end_try (current_binding_level
->start_pc
, pc
);
1492 maybe_end_try (0, pc
);
1495 /* Terminate any binding which began during the range beginning at
1496 start_pc. This tidies up improperly nested local variable ranges
1497 and exception handlers; a variable declared within an exception
1498 range is forcibly terminated when that exception ends. */
1501 force_poplevels (start_pc
)
1504 while (current_binding_level
->start_pc
> start_pc
)
1506 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1507 warning_with_decl (current_function_decl
,
1508 "In %s: overlapped variable and exception ranges at %d",
1509 current_binding_level
->start_pc
);
1510 expand_end_bindings (getdecls (), 1, 0);
1515 /* Insert BLOCK at the end of the list of subblocks of the
1516 current binding level. This is used when a BIND_EXPR is expanded,
1517 to handle the BLOCK node inside the BIND_EXPR. */
1520 insert_block (block
)
1523 TREE_USED (block
) = 1;
1524 current_binding_level
->blocks
1525 = chainon (current_binding_level
->blocks
, block
);
1528 /* Set the BLOCK node for the innermost scope
1529 (the one we are currently in). */
1533 register tree block
;
1535 current_binding_level
->this_block
= block
;
1536 current_binding_level
->names
= chainon (current_binding_level
->names
,
1537 BLOCK_VARS (block
));
1538 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1539 BLOCK_SUBBLOCKS (block
));
1542 /* integrate_decl_tree calls this function. */
1545 java_dup_lang_specific_decl (node
)
1549 struct lang_decl
*x
;
1551 if (!DECL_LANG_SPECIFIC (node
))
1554 if (TREE_CODE (node
) == VAR_DECL
)
1555 lang_decl_size
= sizeof (struct lang_decl_var
);
1557 lang_decl_size
= sizeof (struct lang_decl
);
1558 x
= (struct lang_decl
*) ggc_alloc (lang_decl_size
);
1559 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1560 DECL_LANG_SPECIFIC (node
) = x
;
1563 /* If DECL has a cleanup, build and return that cleanup here.
1564 This is a callback called by expand_expr. */
1567 maybe_build_cleanup (decl
)
1568 tree decl ATTRIBUTE_UNUSED
;
1570 /* There are no cleanups in Java (I think). */
1575 give_name_to_locals (jcf
)
1578 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1579 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1581 pending_local_decls
= NULL_TREE
;
1585 n
= JCF_readu2 (jcf
);
1586 for (i
= 0; i
< n
; i
++)
1588 int start_pc
= JCF_readu2 (jcf
);
1589 int length
= JCF_readu2 (jcf
);
1590 int name_index
= JCF_readu2 (jcf
);
1591 int signature_index
= JCF_readu2 (jcf
);
1592 int slot
= JCF_readu2 (jcf
);
1593 tree name
= get_name_constant (jcf
, name_index
);
1594 tree type
= parse_signature (jcf
, signature_index
);
1595 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1597 && length
== DECL_CODE_LENGTH (current_function_decl
))
1599 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1600 DECL_NAME (decl
) = name
;
1601 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1602 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1603 warning ("bad type in parameter debug info");
1608 int end_pc
= start_pc
+ length
;
1609 tree decl
= build_decl (VAR_DECL
, name
, type
);
1610 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1612 warning_with_decl (decl
,
1613 "bad PC range for debug info for local `%s'");
1614 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1617 /* Adjust start_pc if necessary so that the local's first
1618 store operation will use the relevant DECL as a
1619 destination. Fore more information, read the leading
1620 comments for expr.c:maybe_adjust_start_pc. */
1621 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1623 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1624 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1625 DECL_LOCAL_START_PC (decl
) = start_pc
;
1627 /* FIXME: The range used internally for exceptions and local
1628 variable ranges, is a half-open interval:
1629 start_pc <= pc < end_pc. However, the range used in the
1630 Java VM spec is inclusive at both ends:
1631 start_pc <= pc <= end_pc. */
1634 DECL_LOCAL_END_PC (decl
) = end_pc
;
1636 /* Now insert the new decl in the proper place in
1637 pending_local_decls. We are essentially doing an insertion sort,
1638 which works fine, since the list input will normally already
1640 ptr
= &pending_local_decls
;
1641 while (*ptr
!= NULL_TREE
1642 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1643 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1644 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1645 ptr
= &TREE_CHAIN (*ptr
);
1646 TREE_CHAIN (decl
) = *ptr
;
1651 pending_local_decls
= nreverse (pending_local_decls
);
1653 /* Fill in default names for the parameters. */
1654 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1655 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1657 if (DECL_NAME (parm
) == NULL_TREE
)
1659 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1661 DECL_NAME (parm
) = get_identifier ("this");
1665 sprintf (buffer
, "ARG_%d", arg_i
);
1666 DECL_NAME (parm
) = get_identifier (buffer
);
1668 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1674 build_result_decl (fndecl
)
1677 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1678 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1679 if (INTEGRAL_TYPE_P (restype
)
1680 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1681 restype
= integer_type_node
;
1682 return (DECL_RESULT (fndecl
) = build_decl (RESULT_DECL
, NULL_TREE
, restype
));
1686 complete_start_java_method (fndecl
)
1689 if (! flag_emit_class_files
)
1691 /* Initialize the RTL code for the function. */
1692 init_function_start (fndecl
, input_filename
, lineno
);
1694 /* Set up parameters and prepare for return, for the function. */
1695 expand_function_start (fndecl
, 0);
1699 /* If this fcn was already referenced via a block-scope `extern' decl (or
1700 an implicit decl), propagate certain information about the usage. */
1701 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1702 TREE_ADDRESSABLE (current_function_decl
) = 1;
1706 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1707 && ! flag_emit_class_files
1708 && ! DECL_CLINIT_P (fndecl
)
1709 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1711 tree clas
= DECL_CONTEXT (fndecl
);
1712 tree init
= build (CALL_EXPR
, void_type_node
,
1713 build_address_of (soft_initclass_node
),
1714 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1716 TREE_SIDE_EFFECTS (init
) = 1;
1717 expand_expr_stmt (init
);
1720 /* Push local variables. Function compiled from source code are
1721 using a different local variables management, and for them,
1722 pushlevel shouldn't be called from here. */
1723 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1726 if (! flag_emit_class_files
)
1727 expand_start_bindings (1);
1730 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1732 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1733 tree enter
, exit
, lock
;
1734 if (METHOD_STATIC (fndecl
))
1735 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1737 lock
= DECL_ARGUMENTS (fndecl
);
1738 BUILD_MONITOR_ENTER (enter
, lock
);
1739 BUILD_MONITOR_EXIT (exit
, lock
);
1740 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1742 expand_expr_stmt (enter
);
1743 expand_decl_cleanup (NULL_TREE
, exit
);
1747 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1748 tree body
= BLOCK_EXPR_BODY (function_body
);
1749 lock
= build (COMPOUND_EXPR
, void_type_node
,
1751 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1752 TREE_SIDE_EFFECTS (lock
) = 1;
1753 BLOCK_EXPR_BODY (function_body
) = lock
;
1759 start_java_method (fndecl
)
1765 current_function_decl
= fndecl
;
1766 announce_function (fndecl
);
1768 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1769 decl_map
= make_tree_vec (i
);
1770 type_map
= (tree
*) xrealloc (type_map
, i
* sizeof (tree
));
1772 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1773 fprintf (stderr
, "%s:\n", (*decl_printable_name
) (fndecl
, 2));
1775 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1776 pushlevel (1); /* Push parameters. */
1778 ptr
= &DECL_ARGUMENTS (fndecl
);
1779 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1780 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1782 tree parm_name
= NULL_TREE
, parm_decl
;
1783 tree parm_type
= TREE_VALUE (tem
);
1784 if (i
>= DECL_MAX_LOCALS (fndecl
))
1787 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1788 DECL_CONTEXT (parm_decl
) = fndecl
;
1789 if (PROMOTE_PROTOTYPES
1790 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1791 && INTEGRAL_TYPE_P (parm_type
))
1792 parm_type
= integer_type_node
;
1793 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1796 ptr
= &TREE_CHAIN (parm_decl
);
1798 /* Add parm_decl to the decl_map. */
1799 push_jvm_slot (i
, parm_decl
);
1801 type_map
[i
] = TREE_TYPE (parm_decl
);
1802 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1805 type_map
[i
] = void_type_node
;
1809 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1811 while (i
< DECL_MAX_LOCALS(fndecl
))
1812 type_map
[i
++] = NULL_TREE
;
1814 build_result_decl (fndecl
);
1815 complete_start_java_method (fndecl
);
1821 tree fndecl
= current_function_decl
;
1823 expand_end_bindings (getdecls (), 1, 0);
1824 /* pop out of function */
1827 /* pop out of its parameters */
1830 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1832 /* Generate rtl for function exit. */
1833 expand_function_end (input_filename
, lineno
, 0);
1835 /* Run the optimizers and output assembler code for this function. */
1836 rest_of_compilation (fndecl
);
1838 current_function_decl
= NULL_TREE
;
1841 /* Mark language-specific parts of T for garbage-collection. */
1847 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1849 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
1850 ggc_mark_tree (li
->global_value
);
1851 ggc_mark_tree (li
->local_value
);
1852 ggc_mark_tree (li
->utf8_ref
);
1854 else if (TREE_CODE (t
) == VAR_DECL
1855 || TREE_CODE (t
) == PARM_DECL
1856 || TREE_CODE (t
) == FIELD_DECL
)
1858 struct lang_decl_var
*ldv
=
1859 ((struct lang_decl_var
*) DECL_LANG_SPECIFIC (t
));
1863 ggc_mark_tree (ldv
->slot_chain
);
1864 ggc_mark_tree (ldv
->am
);
1865 ggc_mark_tree (ldv
->wfl
);
1868 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1870 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
1875 ggc_mark_tree (ld
->wfl
);
1876 ggc_mark_tree (ld
->throws_list
);
1877 ggc_mark_tree (ld
->function_decl_body
);
1878 ggc_mark_tree (ld
->called_constructor
);
1879 ggc_mark_tree (ld
->inner_access
);
1880 ggc_mark_tree_hash_table (&ld
->init_test_table
);
1881 ggc_mark_tree_hash_table (&ld
->ict
);
1882 ggc_mark_tree (ld
->smic
);
1885 else if (TYPE_P (t
))
1887 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
1892 ggc_mark_tree (lt
->signature
);
1893 ggc_mark_tree (lt
->cpool_data_ref
);
1894 ggc_mark_tree (lt
->finit_stmt_list
);
1895 ggc_mark_tree (lt
->clinit_stmt_list
);
1896 ggc_mark_tree (lt
->ii_block
);
1897 ggc_mark_tree (lt
->dot_class
);
1898 ggc_mark_tree (lt
->package_list
);