1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
33 #include "java-tree.h"
39 #include "java-except.h"
42 #if defined (DEBUG_JAVA_BINDING_LEVELS)
43 extern void indent
PROTO((void));
46 static tree push_jvm_slot
PARAMS ((int, tree
));
47 static tree lookup_name_current_level
PARAMS ((tree
));
48 static tree push_promoted_type
PARAMS ((const char *, tree
));
49 static struct binding_level
*make_binding_level
PARAMS ((void));
50 static boolean emit_init_test_initialization
PARAMS ((struct hash_entry
*,
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
;
77 /* Push a local variable or stack slot into the decl_map,
78 and assign it an rtl. */
80 #if defined(DEBUG_JAVA_BINDING_LEVELS)
81 int binding_depth
= 0;
82 int is_class_level
= 0;
90 for (i
= 0; i
< binding_depth
*2; i
++)
93 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
96 push_jvm_slot (index
, decl
)
100 struct rtx_def
*rtl
= NULL
;
101 tree type
= TREE_TYPE (decl
);
104 DECL_CONTEXT (decl
) = current_function_decl
;
105 layout_decl (decl
, 0);
107 /* See if we have an appropriate rtl (i.e. same mode) at this index.
108 If so, we must use it. */
109 tmp
= TREE_VEC_ELT (decl_map
, index
);
110 while (tmp
!= NULL_TREE
)
112 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
113 rtl
= DECL_RTL (tmp
);
116 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
119 DECL_RTL (decl
) = rtl
;
122 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
123 DECL_REGISTER (decl
) = 1;
127 /* Now link the decl into the decl_map. */
128 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
130 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
131 DECL_LOCAL_START_PC (decl
) = 0;
132 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
133 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
135 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
136 TREE_VEC_ELT (decl_map
, index
) = decl
;
140 /* Find out if 'decl' passed in fits the defined PC location better than
141 'best'. Return decl if it does, return best if it doesn't. If decl
142 is returned, then updated is set to true. */
145 check_local_named_variable (best
, decl
, pc
, updated
)
151 if (pc
>= DECL_LOCAL_START_PC (decl
)
152 && pc
< DECL_LOCAL_END_PC (decl
))
154 if (best
== NULL_TREE
155 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
156 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
166 /* Find the best declaration based upon type. If 'decl' fits 'type' better
167 than 'best', return 'decl'. Otherwise return 'best'. */
170 check_local_unnamed_variable (best
, decl
, type
)
175 if (TREE_TYPE (decl
) == type
176 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
177 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
178 && TYPE_PRECISION (type
) <= 32
179 && TREE_CODE (type
) != POINTER_TYPE
)
180 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
181 && type
== ptr_type_node
))
183 if (best
== NULL_TREE
184 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
192 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
193 that is valid at PC (or -1 if any pc).
194 If there is no existing matching decl, allocate one. */
197 find_local_variable (index
, type
, pc
)
202 tree decl
= TREE_VEC_ELT (decl_map
, index
);
203 tree best
= NULL_TREE
;
204 int found_scoped_var
= 0;
206 /* Scan through every declaration that has been created in this slot. */
207 while (decl
!= NULL_TREE
)
209 /* Variables created in give_name_to_locals() have a name and have
210 a specified scope, so we can handle them specifically. We want
211 to use the specific decls created for those so they are assigned
212 the right variables in the debugging information. */
213 if (DECL_NAME (decl
) != NULL_TREE
)
215 /* This is a variable we have a name for, so it has a scope
216 supplied in the class file. But it only matters when we
217 actually have a PC to use. If pc<0, then we are asking
218 for a stack slot and this decl won't be one of those. */
220 best
= check_local_named_variable (best
, decl
, pc
,
223 /* We scan for type information unless we found a variable in the
224 proper scope already. */
225 else if (!found_scoped_var
)
227 /* If we don't have scoping information for a variable, we use
228 a different method to look it up. */
229 best
= check_local_unnamed_variable (best
, decl
, type
);
232 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
235 if (best
!= NULL_TREE
)
238 /* If we don't find a match, create one with the type passed in. */
239 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
243 /* Same as find_local_index, except that INDEX is a stack index. */
246 find_stack_slot (index
, type
)
250 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
256 /* A chain of _DECL nodes for all variables, constants, functions,
257 * and typedef types. These are in the reverse of the order supplied.
261 /* For each level, a list of shadowed outer-level local definitions
262 to be restored when this level is popped.
263 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
264 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
267 /* For each level (except not the global one),
268 a chain of BLOCK nodes for all the levels
269 that were entered and exited one level down. */
272 /* The BLOCK node for this level, if one has been preallocated.
273 If 0, the BLOCK is allocated (if needed) when the level is popped. */
276 /* The binding level which this one is contained in (inherits from). */
277 struct binding_level
*level_chain
;
279 /* 1 means make a BLOCK for this level regardless of all else.
280 2 for temporary binding contours created by the compiler. */
283 /* Nonzero means make a BLOCK if this level has any subblocks. */
284 char keep_if_subblocks
;
286 /* Nonzero if this level can safely have additional
287 cleanup-needing variables added to it. */
288 char more_cleanups_ok
;
291 /* The bytecode PC that marks the end of this level. */
293 /* The bytecode PC that marks the start of this level. */
296 #if defined(DEBUG_JAVA_BINDING_LEVELS)
297 /* Binding depth at which this level began. */
298 unsigned binding_depth
;
299 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
302 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
304 /* The binding level currently in effect. */
306 static struct binding_level
*current_binding_level
;
308 /* A chain of binding_level structures awaiting reuse. */
310 static struct binding_level
*free_binding_level
;
312 /* The outermost binding level, for names of file scope.
313 This is created when the compiler is started and exists
314 through the entire run. */
316 static struct binding_level
*global_binding_level
;
318 /* A PC value bigger than any PC value we may ever may encounter. */
320 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
322 /* Binding level structures are initialized by copying this one. */
324 static struct binding_level clear_binding_level
325 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
326 NULL_BINDING_LEVEL
, 0, 0, 0, 0, LARGEST_PC
, 0};
329 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
330 that have names. Here so we can clear out their names' definitions
331 at the end of the function. */
333 static tree named_labels
;
335 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
337 static tree shadowed_labels
;
340 int flag_traditional
;
342 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
344 static int keep_next_level_flag
;
346 /* Nonzero means make a BLOCK for the next level pushed
347 if it has subblocks. */
349 static int keep_next_if_subblocks
;
351 tree java_global_trees
[JTI_MAX
];
353 tree predef_filenames
[PREDEF_FILENAMES_SIZE
];
355 /* Build (and pushdecl) a "promoted type" for all standard
356 types shorter than int. */
359 push_promoted_type (name
, actual_type
)
363 tree type
= make_node (TREE_CODE (actual_type
));
365 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
366 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
368 tree in_min
= TYPE_MIN_VALUE (actual_type
);
369 tree in_max
= TYPE_MAX_VALUE (actual_type
);
371 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
372 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
373 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
374 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
375 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
377 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
381 /* Return a definition for a builtin function named NAME and whose data type
382 is TYPE. TYPE should be a function type with argument types.
383 FUNCTION_CODE tells later passes how to compile calls to this function.
384 See tree.h for its possible values.
386 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
387 the name to be called if we can't opencode the function. */
390 builtin_function (name
, type
, function_code
, class, library_name
)
394 enum built_in_class
class;
395 const char *library_name
;
397 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
398 DECL_EXTERNAL (decl
) = 1;
399 TREE_PUBLIC (decl
) = 1;
401 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
402 make_decl_rtl (decl
, NULL_PTR
, 1);
404 DECL_BUILT_IN_CLASS (decl
) = class;
405 DECL_FUNCTION_CODE (decl
) = function_code
;
409 /* Return tree that represents a vtable for a primitive array. */
411 create_primitive_vtable (name
)
417 sprintf (buf
, "_Jv_%sVTable", name
);
418 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
419 DECL_EXTERNAL (r
) = 1;
420 make_decl_rtl (r
, buf
, 1);
425 init_decl_processing ()
427 register tree endlink
;
428 tree field
= NULL_TREE
;
431 init_class_processing ();
433 current_function_decl
= NULL
;
434 current_binding_level
= NULL_BINDING_LEVEL
;
435 free_binding_level
= NULL_BINDING_LEVEL
;
436 pushlevel (0); /* make the binding_level structure for global names */
437 global_binding_level
= current_binding_level
;
439 /* The code here must be similar to build_common_tree_nodes{,_2} in
440 tree.c, especially as to the order of initializing common nodes. */
441 error_mark_node
= make_node (ERROR_MARK
);
442 TREE_TYPE (error_mark_node
) = error_mark_node
;
444 /* Create sizetype first - needed for other types. */
445 initialize_sizetypes ();
447 byte_type_node
= make_signed_type (8);
448 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
449 short_type_node
= make_signed_type (16);
450 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
451 int_type_node
= make_signed_type (32);
452 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
453 long_type_node
= make_signed_type (64);
454 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
456 unsigned_byte_type_node
= make_unsigned_type (8);
457 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
458 unsigned_byte_type_node
));
459 unsigned_short_type_node
= make_unsigned_type (16);
460 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
461 unsigned_short_type_node
));
462 unsigned_int_type_node
= make_unsigned_type (32);
463 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
464 unsigned_int_type_node
));
465 unsigned_long_type_node
= make_unsigned_type (64);
466 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
467 unsigned_long_type_node
));
469 set_sizetype (make_unsigned_type (POINTER_SIZE
));
471 /* Define these next since types below may used them. */
472 integer_type_node
= type_for_size (INT_TYPE_SIZE
, 0);
473 integer_zero_node
= build_int_2 (0, 0);
474 integer_one_node
= build_int_2 (1, 0);
475 integer_two_node
= build_int_2 (2, 0);
476 integer_four_node
= build_int_2 (4, 0);
477 integer_negative_one_node
= build_int_2 (-1, 0);
479 size_zero_node
= size_int (0);
480 size_one_node
= size_int (1);
481 bitsize_zero_node
= bitsize_int (0);
482 bitsize_one_node
= bitsize_int (1);
483 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
485 long_zero_node
= build_int_2 (0, 0);
486 TREE_TYPE (long_zero_node
) = long_type_node
;
488 void_type_node
= make_node (VOID_TYPE
);
489 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
490 layout_type (void_type_node
); /* Uses size_zero_node */
491 ptr_type_node
= build_pointer_type (void_type_node
);
492 t
= make_node (VOID_TYPE
);
493 layout_type (t
); /* Uses size_zero_node */
494 return_address_type_node
= build_pointer_type (t
);
496 null_pointer_node
= build_int_2 (0, 0);
497 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
499 /* Used by the parser to represent empty statements and blocks. */
500 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
501 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
504 /* Make a type to be the domain of a few array types
505 whose domains don't really matter.
506 200 is small enough that it always fits in size_t
507 and large enough that it can hold most function names for the
508 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
509 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
511 char_type_node
= make_node (CHAR_TYPE
);
512 TYPE_PRECISION (char_type_node
) = 16;
513 fixup_unsigned_type (char_type_node
);
514 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
516 boolean_type_node
= make_node (BOOLEAN_TYPE
);
517 TYPE_PRECISION (boolean_type_node
) = 1;
518 fixup_unsigned_type (boolean_type_node
);
519 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
521 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
522 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
524 promoted_byte_type_node
525 = push_promoted_type ("promoted_byte", byte_type_node
);
526 promoted_short_type_node
527 = push_promoted_type ("promoted_short", short_type_node
);
528 promoted_char_type_node
529 = push_promoted_type ("promoted_char", char_type_node
);
530 promoted_boolean_type_node
531 = push_promoted_type ("promoted_boolean", boolean_type_node
);
533 float_type_node
= make_node (REAL_TYPE
);
534 TYPE_PRECISION (float_type_node
) = 32;
535 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
537 layout_type (float_type_node
);
539 double_type_node
= make_node (REAL_TYPE
);
540 TYPE_PRECISION (double_type_node
) = 64;
541 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
543 layout_type (double_type_node
);
545 float_zero_node
= build_real (float_type_node
, dconst0
);
546 double_zero_node
= build_real (double_type_node
, dconst0
);
548 /* These are the vtables for arrays of primitives. */
549 boolean_array_vtable
= create_primitive_vtable ("boolean");
550 byte_array_vtable
= create_primitive_vtable ("byte");
551 char_array_vtable
= create_primitive_vtable ("char");
552 short_array_vtable
= create_primitive_vtable ("short");
553 int_array_vtable
= create_primitive_vtable ("int");
554 long_array_vtable
= create_primitive_vtable ("long");
555 float_array_vtable
= create_primitive_vtable ("float");
556 double_array_vtable
= create_primitive_vtable ("double");
558 /* As you're adding items here, please update the code right after
559 this section, so that the filename containing the source code of
560 the pre-defined class gets registered correctly. */
561 unqualified_object_id_node
= get_identifier ("Object");
562 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
563 object_ptr_type_node
= promote_type (object_type_node
);
564 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
565 string_ptr_type_node
= promote_type (string_type_node
);
566 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
567 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
568 runtime_exception_type_node
=
569 lookup_class (get_identifier ("java.lang.RuntimeException"));
570 error_exception_type_node
=
571 lookup_class (get_identifier ("java.lang.Error"));
572 rawdata_ptr_type_node
573 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
575 /* If you add to this section, don't forget to increase
576 PREDEF_FILENAMES_SIZE. */
577 predef_filenames
[0] = get_identifier ("java/lang/Class.java");
578 predef_filenames
[1] = get_identifier ("java/lang/Error.java");
579 predef_filenames
[2] = get_identifier ("java/lang/Object.java");
580 predef_filenames
[3] = get_identifier ("java/lang/RuntimeException.java");
581 predef_filenames
[4] = get_identifier ("java/lang/String.java");
582 predef_filenames
[5] = get_identifier ("java/lang/Throwable.java");
583 predef_filenames
[6] = get_identifier ("gnu/gcj/RawData.java");
585 methodtable_type
= make_node (RECORD_TYPE
);
586 layout_type (methodtable_type
);
587 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
588 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
590 TYPE_identifier_node
= get_identifier ("TYPE");
591 init_identifier_node
= get_identifier ("<init>");
592 clinit_identifier_node
= get_identifier ("<clinit>");
593 /* Legacy `$finit$' special method identifier. This needs to be
594 recognized as equivalent to `finit$' but isn't generated anymore. */
595 finit_leg_identifier_node
= get_identifier ("$finit$");
596 /* The new `finit$' special method identifier. This one is now
597 generated in place of `$finit$'. */
598 finit_identifier_node
= get_identifier ("finit$");
599 void_signature_node
= get_identifier ("()V");
600 length_identifier_node
= get_identifier ("length");
601 this_identifier_node
= get_identifier ("this");
602 super_identifier_node
= get_identifier ("super");
603 continue_identifier_node
= get_identifier ("continue");
604 access0_identifier_node
= get_identifier ("access$0");
606 /* for lack of a better place to put this stub call */
607 init_expr_processing();
609 utf8const_type
= make_node (RECORD_TYPE
);
610 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
611 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
612 FINISH_RECORD (utf8const_type
);
613 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
615 constants_type_node
= make_node (RECORD_TYPE
);
616 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
617 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
618 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
619 FINISH_RECORD (constants_type_node
);
620 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
622 access_flags_type_node
= unsigned_short_type_node
;
624 dtable_type
= make_node (RECORD_TYPE
);
625 dtable_ptr_type
= build_pointer_type (dtable_type
);
627 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
628 /* This isn't exactly true, but it is what we have in the source.
629 There is an unresolved issue here, which is whether the vtable
630 should be marked by the GC. */
631 if (! flag_hash_synchronization
)
632 PUSH_FIELD (object_type_node
, field
, "sync_info",
633 build_pointer_type (object_type_node
));
634 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
635 FIELD_PRIVATE (t
) = 1;
636 FINISH_RECORD (object_type_node
);
638 class_dtable_decl
= build_dtable_decl (class_type_node
);
639 TREE_STATIC (class_dtable_decl
) = 1;
640 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
641 DECL_IGNORED_P (class_dtable_decl
) = 1;
642 rest_of_decl_compilation (class_dtable_decl
, (char*) 0, 1, 0);
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
, "interfaces",
667 build_pointer_type (class_ptr_type
));
668 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
669 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
670 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
671 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
672 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
673 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
674 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
675 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
676 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
677 FIELD_PRIVATE (t
) = 1;
678 push_super_field (class_type_node
, object_type_node
);
679 FINISH_RECORD (class_type_node
);
680 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
682 field_info_union_node
= make_node (UNION_TYPE
);
683 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
684 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
686 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
688 layout_type (field_info_union_node
);
690 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
691 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
692 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
693 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
694 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
695 FINISH_RECORD (field_type_node
);
696 CLASS_LOADED_P (field_type_node
) = 1;
697 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
699 one_elt_array_domain_type
= build_index_type (integer_one_node
);
700 nativecode_ptr_array_type_node
701 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
703 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
704 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
705 FINISH_RECORD (dtable_type
);
706 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
708 #define jint_type int_type_node
709 #define jint_ptr_type ptr_type_node
711 jexception_type
= make_node (RECORD_TYPE
);
712 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
713 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
714 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
715 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
716 FINISH_RECORD (jexception_type
);
717 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
718 jexception_ptr_type
= build_pointer_type (jexception_type
);
720 lineNumberEntry_type
= make_node (RECORD_TYPE
);
721 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
722 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
723 FINISH_RECORD (lineNumberEntry_type
);
725 lineNumbers_type
= make_node (RECORD_TYPE
);
726 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
727 FINISH_RECORD (lineNumbers_type
);
729 #define instn_ptr_type_node ptr_type_node /* XXX JH */
731 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
733 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
734 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
735 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
736 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
737 FINISH_RECORD (method_type_node
);
738 CLASS_LOADED_P (method_type_node
) = 1;
739 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
741 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
743 t
= tree_cons (NULL_TREE
, class_ptr_type
,
744 tree_cons (NULL_TREE
, int_type_node
, endlink
));
745 alloc_object_node
= builtin_function ("_Jv_AllocObject",
746 build_function_type (ptr_type_node
, t
),
747 0, NOT_BUILT_IN
, NULL_PTR
);
748 DECL_IS_MALLOC (alloc_object_node
) = 1;
750 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
751 soft_initclass_node
= builtin_function ("_Jv_InitClass",
752 build_function_type (void_type_node
,
756 throw_node
[0] = builtin_function ("_Jv_Throw",
757 build_function_type (ptr_type_node
, t
),
758 0, NOT_BUILT_IN
, NULL_PTR
);
759 /* Mark throw_nodes as `noreturn' functions with side effects. */
760 TREE_THIS_VOLATILE (throw_node
[0]) = 1;
761 TREE_SIDE_EFFECTS (throw_node
[0]) = 1;
762 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
763 throw_node
[1] = builtin_function ("_Jv_Sjlj_Throw",
764 build_function_type (ptr_type_node
, t
),
765 0, NOT_BUILT_IN
, NULL_PTR
);
766 TREE_THIS_VOLATILE (throw_node
[1]) = 1;
767 TREE_SIDE_EFFECTS (throw_node
[1]) = 1;
768 t
= build_function_type (int_type_node
, endlink
);
769 soft_monitorenter_node
770 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
772 soft_monitorexit_node
773 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
776 t
= tree_cons (NULL_TREE
, int_type_node
,
777 tree_cons (NULL_TREE
, int_type_node
, endlink
));
779 = builtin_function ("_Jv_NewPrimArray",
780 build_function_type(ptr_type_node
, t
),
781 0, NOT_BUILT_IN
, NULL_PTR
);
782 DECL_IS_MALLOC (soft_newarray_node
) = 1;
784 t
= tree_cons (NULL_TREE
, int_type_node
,
785 tree_cons (NULL_TREE
, class_ptr_type
,
786 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
788 = builtin_function ("_Jv_NewObjectArray",
789 build_function_type (ptr_type_node
, t
),
790 0, NOT_BUILT_IN
, NULL_PTR
);
791 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
793 t
= tree_cons (NULL_TREE
, ptr_type_node
,
794 tree_cons (NULL_TREE
, int_type_node
, endlink
));
795 soft_multianewarray_node
796 = builtin_function ("_Jv_NewMultiArray",
797 build_function_type (ptr_type_node
, t
),
798 0, NOT_BUILT_IN
, NULL_PTR
);
799 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
801 t
= build_function_type (void_type_node
,
802 tree_cons (NULL_TREE
, int_type_node
, endlink
));
803 soft_badarrayindex_node
804 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
805 0, NOT_BUILT_IN
, NULL_PTR
);
806 /* Mark soft_badarrayindex_node as a `noreturn' function with side
808 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
809 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
811 soft_nullpointer_node
812 = builtin_function ("_Jv_ThrowNullPointerException",
813 build_function_type (void_type_node
, endlink
),
814 0, NOT_BUILT_IN
, NULL_PTR
);
815 /* Mark soft_nullpointer_node as a `noreturn' function with side
817 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
818 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
820 t
= tree_cons (NULL_TREE
, class_ptr_type
,
821 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
823 = builtin_function ("_Jv_CheckCast",
824 build_function_type (ptr_type_node
, t
),
825 0, NOT_BUILT_IN
, NULL_PTR
);
826 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
827 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
829 = builtin_function ("_Jv_IsInstanceOf",
830 build_function_type (boolean_type_node
, t
),
831 0, NOT_BUILT_IN
, NULL_PTR
);
832 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
833 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
834 soft_checkarraystore_node
835 = builtin_function ("_Jv_CheckArrayStore",
836 build_function_type (void_type_node
, t
),
837 0, NOT_BUILT_IN
, NULL_PTR
);
838 t
= tree_cons (NULL_TREE
, ptr_type_node
,
839 tree_cons (NULL_TREE
, ptr_type_node
,
840 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
841 soft_lookupinterfacemethod_node
842 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
843 build_function_type (ptr_type_node
, t
),
844 0, NOT_BUILT_IN
, NULL_PTR
);
846 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
847 tree_cons (NULL_TREE
, ptr_type_node
,
848 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
849 soft_lookupjnimethod_node
850 = builtin_function ("_Jv_LookupJNIMethod",
851 build_function_type (ptr_type_node
, t
),
852 0, NOT_BUILT_IN
, NULL_PTR
);
853 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
854 soft_getjnienvnewframe_node
855 = builtin_function ("_Jv_GetJNIEnvNewFrame",
856 build_function_type (ptr_type_node
, t
),
857 0, NOT_BUILT_IN
, NULL_PTR
);
858 soft_jnipopsystemframe_node
859 = builtin_function ("_Jv_JNI_PopSystemFrame",
860 build_function_type (ptr_type_node
, t
),
861 0, NOT_BUILT_IN
, NULL_PTR
);
863 t
= tree_cons (NULL_TREE
, double_type_node
,
864 tree_cons (NULL_TREE
, double_type_node
, endlink
));
866 = builtin_function ("__builtin_fmod",
867 build_function_type (double_type_node
, t
),
868 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmod");
870 soft_exceptioninfo_call_node
874 (builtin_function ("_Jv_exception_info",
875 build_function_type (ptr_type_node
, endlink
),
876 0, NOT_BUILT_IN
, NULL_PTR
)),
877 NULL_TREE
, NULL_TREE
);
878 TREE_SIDE_EFFECTS (soft_exceptioninfo_call_node
) = 1;
880 t
= tree_cons (NULL_TREE
, float_type_node
,
881 tree_cons (NULL_TREE
, float_type_node
, endlink
));
883 = builtin_function ("__builtin_fmodf",
884 build_function_type (float_type_node
, t
),
885 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf");
889 = builtin_function ("_Jv_divI",
890 build_function_type (int_type_node
, t
),
891 0, NOT_BUILT_IN
, NULL_PTR
);
894 = builtin_function ("_Jv_remI",
895 build_function_type (int_type_node
, t
),
896 0, NOT_BUILT_IN
, NULL_PTR
);
899 = builtin_function ("_Jv_divJ",
900 build_function_type (long_type_node
, t
),
901 0, NOT_BUILT_IN
, NULL_PTR
);
904 = builtin_function ("_Jv_remJ",
905 build_function_type (long_type_node
, t
),
906 0, NOT_BUILT_IN
, NULL_PTR
);
910 /* Register nodes with the garbage collector. */
911 ggc_add_tree_root (java_global_trees
,
912 sizeof (java_global_trees
) / sizeof (tree
));
913 ggc_add_tree_root (throw_node
,
914 sizeof (throw_node
) / sizeof (tree
));
915 ggc_add_tree_root (predef_filenames
,
916 sizeof (predef_filenames
) / sizeof (tree
));
917 ggc_add_tree_root (&decl_map
, 1);
918 ggc_add_tree_root (&pending_local_decls
, 1);
922 /* Look up NAME in the current binding level and its superiors
923 in the namespace of variables, functions and typedefs.
924 Return a ..._DECL node of some kind representing its definition,
925 or return 0 if it is undefined. */
932 if (current_binding_level
!= global_binding_level
933 && IDENTIFIER_LOCAL_VALUE (name
))
934 val
= IDENTIFIER_LOCAL_VALUE (name
);
936 val
= IDENTIFIER_GLOBAL_VALUE (name
);
940 /* Similar to `lookup_name' but look only at current binding level and
941 the previous one if its the parameter level. */
944 lookup_name_current_level (name
)
949 if (current_binding_level
== global_binding_level
)
950 return IDENTIFIER_GLOBAL_VALUE (name
);
952 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
955 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
956 if (DECL_NAME (t
) == name
)
962 /* Use a binding level to record a labeled block declaration */
965 push_labeled_block (lb
)
968 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
969 register struct binding_level
*b
= current_binding_level
;
970 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
972 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
973 TREE_CHAIN (lb
) = b
->names
;
975 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
978 /* Pop the current binding level, reinstalling values for the previous
984 struct binding_level
*b
= current_binding_level
;
985 tree label
= b
->names
;
986 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
989 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
990 TREE_VALUE (b
->shadowed
);
992 /* Pop the current level, and free the structure for reuse. */
993 current_binding_level
= current_binding_level
->level_chain
;
994 b
->level_chain
= free_binding_level
;
995 free_binding_level
= b
;
998 /* Record a decl-node X as belonging to the current lexical scope.
999 Check for errors (such as an incompatible declaration for the same
1000 name already seen in the same scope).
1002 Returns either X or an old decl for the same name.
1003 If an old decl is returned, it may have been smashed
1004 to agree with what X says. */
1011 register tree name
= DECL_NAME (x
);
1012 register struct binding_level
*b
= current_binding_level
;
1014 if (TREE_CODE (x
) != TYPE_DECL
)
1015 DECL_CONTEXT (x
) = current_function_decl
;
1021 t
= lookup_name_current_level (name
);
1022 if (t
!= 0 && t
== error_mark_node
)
1023 /* error_mark_node is 0 for a while during initialization! */
1026 error_with_decl (x
, "`%s' used prior to declaration");
1031 file
= DECL_SOURCE_FILE (t
);
1032 line
= DECL_SOURCE_LINE (t
);
1035 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1036 to point to the TYPE_DECL.
1037 Since Java does not have typedefs, a type can only have
1038 one (true) name, given by a class, interface, or builtin. */
1039 if (TREE_CODE (x
) == TYPE_DECL
1040 && TYPE_NAME (TREE_TYPE (x
)) == 0
1041 && TREE_TYPE (x
) != error_mark_node
)
1043 TYPE_NAME (TREE_TYPE (x
)) = x
;
1044 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1047 /* This name is new in its binding level.
1048 Install the new declaration and return it. */
1049 if (b
== global_binding_level
)
1051 /* Install a global value. */
1053 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1057 /* Here to install a non-global value. */
1058 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1059 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1062 /* Warn if shadowing an argument at the top level of the body. */
1063 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1064 /* This warning doesn't apply to the parms of a nested fcn. */
1065 && ! current_binding_level
->parm_flag
1066 /* Check that this is one level down from the parms. */
1067 && current_binding_level
->level_chain
->parm_flag
1068 /* Check that the decl being shadowed
1069 comes from the parm level, one level up. */
1070 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1072 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1073 pedwarn ("declaration of `%s' shadows a parameter",
1074 IDENTIFIER_POINTER (name
));
1076 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1077 IDENTIFIER_POINTER (name
));
1080 /* Maybe warn if shadowing something else. */
1081 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1082 /* No shadow warnings for internally generated vars. */
1083 && DECL_SOURCE_LINE (x
) != 0
1084 /* No shadow warnings for vars made for inlining. */
1085 && ! DECL_FROM_INLINE (x
))
1087 const char *warnstring
= 0;
1089 if (TREE_CODE (x
) == PARM_DECL
1090 && current_binding_level
->level_chain
->parm_flag
)
1091 /* Don't warn about the parm names in function declarator
1092 within a function declarator.
1093 It would be nice to avoid warning in any function
1094 declarator in a declaration, as opposed to a definition,
1095 but there is no way to tell it's not a definition. */
1097 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1098 warnstring
= "declaration of `%s' shadows a parameter";
1099 else if (oldlocal
!= 0)
1100 warnstring
= "declaration of `%s' shadows previous local";
1101 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1102 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1103 warnstring
= "declaration of `%s' shadows global declaration";
1106 warning (warnstring
, IDENTIFIER_POINTER (name
));
1110 /* If storing a local value, there may already be one (inherited).
1111 If so, record it for restoration when this binding level ends. */
1113 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1117 /* Put decls on list in reverse order.
1118 We will reverse them later if necessary. */
1119 TREE_CHAIN (x
) = b
->names
;
1126 pushdecl_force_head (x
)
1129 current_binding_level
->names
= x
;
1132 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1135 pushdecl_top_level (x
)
1139 register struct binding_level
*b
= current_binding_level
;
1141 current_binding_level
= global_binding_level
;
1143 current_binding_level
= b
;
1147 /* Nonzero if we are currently in the global binding level. */
1150 global_bindings_p ()
1152 return current_binding_level
== global_binding_level
;
1155 /* Return the list of declarations of the current level.
1156 Note that this list is in reverse order unless/until
1157 you nreverse it; and when you do nreverse it, you must
1158 store the result back using `storedecls' or you will lose. */
1163 return current_binding_level
->names
;
1166 /* Create a new `struct binding_level'. */
1168 static struct binding_level
*
1169 make_binding_level ()
1172 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
1177 int unused ATTRIBUTE_UNUSED
;
1179 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1182 /* If this is the top level of a function,
1183 just make sure that NAMED_LABELS is 0. */
1185 if (current_binding_level
== global_binding_level
)
1189 /* Reuse or create a struct for this binding level. */
1191 if (free_binding_level
)
1193 newlevel
= free_binding_level
;
1194 free_binding_level
= free_binding_level
->level_chain
;
1198 newlevel
= make_binding_level ();
1201 /* Add this level to the front of the chain (stack) of levels that
1204 *newlevel
= clear_binding_level
;
1205 newlevel
->level_chain
= current_binding_level
;
1206 current_binding_level
= newlevel
;
1207 newlevel
->keep
= keep_next_level_flag
;
1208 keep_next_level_flag
= 0;
1209 newlevel
->keep_if_subblocks
= keep_next_if_subblocks
;
1210 keep_next_if_subblocks
= 0;
1211 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1212 newlevel
->binding_depth
= binding_depth
;
1214 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1215 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1218 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1221 /* Exit a binding level.
1222 Pop the level off, and restore the state of the identifier-decl mappings
1223 that were in effect when this level was entered.
1225 If KEEP is nonzero, this level had explicit declarations, so
1226 and create a "block" (a BLOCK node) for the level
1227 to record its declarations and subblocks for symbol table output.
1229 If FUNCTIONBODY is nonzero, this level is the body of a function,
1230 so create a block as if KEEP were set and also clear out all
1233 If REVERSE is nonzero, reverse the order of decls before putting
1234 them into the BLOCK. */
1237 poplevel (keep
, reverse
, functionbody
)
1243 /* The chain of decls was accumulated in reverse order.
1244 Put it into forward order, just for cleanliness. */
1246 tree subblocks
= current_binding_level
->blocks
;
1249 int block_previously_created
;
1251 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1254 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1255 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1256 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1257 current_binding_level
->end_pc
);
1259 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1260 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1262 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1265 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1269 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1271 keep
|= current_binding_level
->keep
;
1273 /* Get the decls in the order they were written.
1274 Usually current_binding_level->names is in reverse order.
1275 But parameter decls were previously put in forward order. */
1278 current_binding_level
->names
1279 = decls
= nreverse (current_binding_level
->names
);
1281 decls
= current_binding_level
->names
;
1283 /* Output any nested inline functions within this block
1284 if they weren't already output. */
1286 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1287 if (TREE_CODE (decl
) == FUNCTION_DECL
1288 && ! TREE_ASM_WRITTEN (decl
)
1289 && DECL_INITIAL (decl
) != 0
1290 && TREE_ADDRESSABLE (decl
))
1292 /* If this decl was copied from a file-scope decl
1293 on account of a block-scope extern decl,
1294 propagate TREE_ADDRESSABLE to the file-scope decl.
1296 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1297 true, since then the decl goes through save_for_inline_copying. */
1298 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1299 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1300 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1303 push_function_context ();
1304 output_inline_function (decl
);
1305 pop_function_context ();
1309 /* If there were any declarations in that level,
1310 or if this level is a function body,
1311 create a BLOCK to record them for the life of this function. */
1314 block_previously_created
= (current_binding_level
->this_block
!= 0);
1315 if (block_previously_created
)
1316 block
= current_binding_level
->this_block
;
1317 else if (keep
|| functionbody
1318 || (current_binding_level
->keep_if_subblocks
&& subblocks
!= 0))
1319 block
= make_node (BLOCK
);
1322 BLOCK_VARS (block
) = decls
;
1323 BLOCK_SUBBLOCKS (block
) = subblocks
;
1326 /* In each subblock, record that this is its superior. */
1328 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1329 BLOCK_SUPERCONTEXT (link
) = block
;
1331 /* Clear out the meanings of the local variables of this level. */
1333 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1335 tree name
= DECL_NAME (link
);
1336 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1338 /* If the ident. was used or addressed via a local extern decl,
1339 don't forget that fact. */
1340 if (DECL_EXTERNAL (link
))
1342 if (TREE_USED (link
))
1343 TREE_USED (name
) = 1;
1344 if (TREE_ADDRESSABLE (link
))
1345 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1347 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1351 /* Restore all name-meanings of the outer levels
1352 that were shadowed by this level. */
1354 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1355 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1357 /* If the level being exited is the top level of a function,
1358 check over all the labels, and clear out the current
1359 (function local) meanings of their names. */
1363 /* If this is the top level block of a function,
1364 the vars are the function's parameters.
1365 Don't leave them in the BLOCK because they are
1366 found in the FUNCTION_DECL instead. */
1368 BLOCK_VARS (block
) = 0;
1370 /* Clear out the definitions of all label names,
1371 since their scopes end here,
1372 and add them to BLOCK_VARS. */
1375 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1377 register tree label
= TREE_VALUE (link
);
1379 if (DECL_INITIAL (label
) == 0)
1381 error_with_decl (label
, "label `%s' used but not defined");
1382 /* Avoid crashing later. */
1383 define_label (input_filename
, lineno
,
1386 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1387 warning_with_decl (label
, "label `%s' defined but not used");
1388 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1390 /* Put the labels into the "variables" of the
1391 top-level block, so debugger can see them. */
1392 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1393 BLOCK_VARS (block
) = label
;
1398 /* Pop the current level, and free the structure for reuse. */
1401 register struct binding_level
*level
= current_binding_level
;
1402 current_binding_level
= current_binding_level
->level_chain
;
1404 level
->level_chain
= free_binding_level
;
1405 free_binding_level
= level
;
1408 /* Dispose of the block that we just made inside some higher level. */
1410 DECL_INITIAL (current_function_decl
) = block
;
1413 if (!block_previously_created
)
1414 current_binding_level
->blocks
1415 = chainon (current_binding_level
->blocks
, block
);
1417 /* If we did not make a block for the level just exited,
1418 any blocks made for inner levels
1419 (since they cannot be recorded as subblocks in that level)
1420 must be carried forward so they will later become subblocks
1421 of something else. */
1423 current_binding_level
->blocks
1424 = chainon (current_binding_level
->blocks
, subblocks
);
1426 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1427 binding contour so that they point to the appropriate construct, i.e.
1428 either to the current FUNCTION_DECL node, or else to the BLOCK node
1429 we just constructed.
1431 Note that for tagged types whose scope is just the formal parameter
1432 list for some function type specification, we can't properly set
1433 their TYPE_CONTEXTs here, because we don't have a pointer to the
1434 appropriate FUNCTION_TYPE node readily available to us. For those
1435 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1436 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1437 node which will represent the "scope" for these "parameter list local"
1442 TREE_USED (block
) = 1;
1447 maybe_pushlevels (pc
)
1450 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1454 while (pending_local_decls
!= NULL_TREE
&&
1455 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1457 tree
*ptr
= &pending_local_decls
;
1459 int end_pc
= DECL_LOCAL_END_PC (decl
);
1461 while (*ptr
!= NULL_TREE
1462 && DECL_LOCAL_START_PC (*ptr
) <= pc
1463 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1464 ptr
= &TREE_CHAIN (*ptr
);
1465 pending_local_decls
= *ptr
;
1468 /* Force non-nested range to be nested in current range. */
1469 if (end_pc
> current_binding_level
->end_pc
)
1470 end_pc
= current_binding_level
->end_pc
;
1472 maybe_start_try (pc
, end_pc
);
1475 expand_start_bindings (0);
1477 current_binding_level
->end_pc
= end_pc
;
1478 current_binding_level
->start_pc
= pc
;
1479 current_binding_level
->names
= decl
;
1480 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1482 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1486 maybe_start_try (pc
, 0);
1490 maybe_poplevels (pc
)
1493 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1497 while (current_binding_level
->end_pc
<= pc
)
1499 expand_end_bindings (getdecls (), 1, 0);
1500 maybe_end_try (current_binding_level
->start_pc
, pc
);
1503 maybe_end_try (0, pc
);
1506 /* Terminate any binding which began during the range beginning at
1507 start_pc. This tidies up improperly nested local variable ranges
1508 and exception handlers; a variable declared within an exception
1509 range is forcibly terminated when that exception ends. */
1512 force_poplevels (start_pc
)
1515 while (current_binding_level
->start_pc
> start_pc
)
1517 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1518 warning_with_decl (current_function_decl
,
1519 "In %s: overlapped variable and exception ranges at %d",
1520 current_binding_level
->start_pc
);
1521 expand_end_bindings (getdecls (), 1, 0);
1526 /* Insert BLOCK at the end of the list of subblocks of the
1527 current binding level. This is used when a BIND_EXPR is expanded,
1528 to handle the BLOCK node inside the BIND_EXPR. */
1531 insert_block (block
)
1534 TREE_USED (block
) = 1;
1535 current_binding_level
->blocks
1536 = chainon (current_binding_level
->blocks
, block
);
1539 /* Set the BLOCK node for the innermost scope
1540 (the one we are currently in). */
1544 register tree block
;
1546 current_binding_level
->this_block
= block
;
1549 /* integrate_decl_tree calls this function. */
1552 copy_lang_decl (node
)
1556 = TREE_CODE (node
) == VAR_DECL
? sizeof (struct lang_decl_var
)
1557 : sizeof (struct lang_decl
);
1558 struct lang_decl
*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 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 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
));
1685 /* Called for every element in DECL_FUNCTION_INIT_TEST_TABLE in order
1686 to emit initialization code for each test flag. */
1689 emit_init_test_initialization (entry
, key
)
1690 struct hash_entry
*entry
;
1691 hash_table_key key ATTRIBUTE_UNUSED
;
1693 struct init_test_hash_entry
*ite
= (struct init_test_hash_entry
*) entry
;
1694 tree klass
= build_class_ref ((tree
) entry
->key
);
1695 expand_decl (ite
->init_test_decl
);
1697 /* We initialize the class init check variable by looking at the
1698 `state' field of the class to see if it is already initialized.
1699 This makes things a bit faster if the class is already
1700 initialized, which should be the common case. */
1702 (build (MODIFY_EXPR
, boolean_type_node
,
1703 ite
->init_test_decl
,
1704 build (GE_EXPR
, boolean_type_node
,
1705 build (COMPONENT_REF
, byte_type_node
,
1706 build1 (INDIRECT_REF
, class_type_node
, klass
),
1707 lookup_field (&class_type_node
,
1708 get_identifier ("state"))),
1709 build_int_2 (JV_STATE_DONE
, 0))));
1715 complete_start_java_method (fndecl
)
1718 if (! flag_emit_class_files
)
1720 /* Initialize the RTL code for the function. */
1721 init_function_start (fndecl
, input_filename
, lineno
);
1723 /* Set up parameters and prepare for return, for the function. */
1724 expand_function_start (fndecl
, 0);
1726 /* Emit initialization code for test flags. */
1727 if (! always_initialize_class_p
)
1728 hash_traverse (&DECL_FUNCTION_INIT_TEST_TABLE (fndecl
),
1729 emit_init_test_initialization
, 0);
1733 /* If this fcn was already referenced via a block-scope `extern' decl (or
1734 an implicit decl), propagate certain information about the usage. */
1735 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1736 TREE_ADDRESSABLE (current_function_decl
) = 1;
1740 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1741 && ! flag_emit_class_files
1742 && ! DECL_CLINIT_P (fndecl
)
1743 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1745 tree clas
= DECL_CONTEXT (fndecl
);
1746 tree init
= build (CALL_EXPR
, void_type_node
,
1747 build_address_of (soft_initclass_node
),
1748 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1750 TREE_SIDE_EFFECTS (init
) = 1;
1751 expand_expr_stmt (init
);
1754 /* Push local variables. Function compiled from source code are
1755 using a different local variables management, and for them,
1756 pushlevel shouldn't be called from here. */
1757 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1760 if (! flag_emit_class_files
)
1761 expand_start_bindings (1);
1764 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1766 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1767 tree enter
, exit
, lock
;
1768 if (METHOD_STATIC (fndecl
))
1769 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1771 lock
= DECL_ARGUMENTS (fndecl
);
1772 BUILD_MONITOR_ENTER (enter
, lock
);
1773 BUILD_MONITOR_EXIT (exit
, lock
);
1774 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1776 expand_expr_stmt (enter
);
1777 expand_decl_cleanup (NULL_TREE
, exit
);
1781 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1782 tree body
= BLOCK_EXPR_BODY (function_body
);
1783 lock
= build (WITH_CLEANUP_EXPR
, void_type_node
,
1784 enter
, NULL_TREE
, exit
);
1785 TREE_SIDE_EFFECTS (lock
) = 1;
1786 lock
= build (COMPOUND_EXPR
, TREE_TYPE (body
), lock
, body
);
1787 TREE_SIDE_EFFECTS (lock
) = 1;
1788 lock
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (body
), lock
);
1789 TREE_SIDE_EFFECTS (lock
) = 1;
1790 BLOCK_EXPR_BODY (function_body
) = lock
;
1796 start_java_method (fndecl
)
1802 current_function_decl
= fndecl
;
1803 announce_function (fndecl
);
1805 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1806 decl_map
= make_tree_vec (i
);
1807 type_map
= (tree
*) xrealloc (type_map
, i
* sizeof (tree
));
1809 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1810 fprintf (stderr
, "%s:\n", (*decl_printable_name
) (fndecl
, 2));
1812 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1813 pushlevel (1); /* Push parameters. */
1815 ptr
= &DECL_ARGUMENTS (fndecl
);
1816 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1817 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1819 tree parm_name
= NULL_TREE
, parm_decl
;
1820 tree parm_type
= TREE_VALUE (tem
);
1821 if (i
>= DECL_MAX_LOCALS(fndecl
))
1822 fatal ("function has more parameters than local slots");
1824 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1825 DECL_CONTEXT (parm_decl
) = fndecl
;
1826 if (PROMOTE_PROTOTYPES
1827 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1828 && INTEGRAL_TYPE_P (parm_type
))
1829 parm_type
= integer_type_node
;
1830 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1833 ptr
= &TREE_CHAIN (parm_decl
);
1835 /* Add parm_decl to the decl_map. */
1836 push_jvm_slot (i
, parm_decl
);
1838 type_map
[i
] = TREE_TYPE (parm_decl
);
1839 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1842 type_map
[i
] = void_type_node
;
1846 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1848 while (i
< DECL_MAX_LOCALS(fndecl
))
1849 type_map
[i
++] = NULL_TREE
;
1851 build_result_decl (fndecl
);
1852 complete_start_java_method (fndecl
);
1858 tree fndecl
= current_function_decl
;
1859 int flag_asynchronous_exceptions
= asynchronous_exceptions
;
1861 expand_end_bindings (getdecls (), 1, 0);
1862 /* pop out of function */
1865 /* pop out of its parameters */
1868 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1872 /* Generate rtl for function exit. */
1873 expand_function_end (input_filename
, lineno
, 0);
1875 /* FIXME: If the current method contains any exception handlers,
1876 force asynchronous_exceptions: this is necessary because signal
1877 handlers in libjava may throw exceptions. This is far from being
1878 a perfect solution, but it's better than doing nothing at all.*/
1880 asynchronous_exceptions
= 1;
1882 /* Run the optimizers and output assembler code for this function. */
1883 rest_of_compilation (fndecl
);
1885 current_function_decl
= NULL_TREE
;
1886 asynchronous_exceptions
= flag_asynchronous_exceptions
;
1889 /* Mark language-specific parts of T for garbage-collection. */
1895 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1897 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
1898 ggc_mark_tree (li
->global_value
);
1899 ggc_mark_tree (li
->local_value
);
1900 ggc_mark_tree (li
->utf8_ref
);
1902 else if (TREE_CODE (t
) == VAR_DECL
1903 || TREE_CODE (t
) == PARM_DECL
1904 || TREE_CODE (t
) == FIELD_DECL
)
1906 struct lang_decl_var
*ldv
=
1907 ((struct lang_decl_var
*) DECL_LANG_SPECIFIC (t
));
1911 ggc_mark_tree (ldv
->slot_chain
);
1912 ggc_mark_tree (ldv
->am
);
1913 ggc_mark_tree (ldv
->wfl
);
1916 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1918 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
1923 ggc_mark_tree (ld
->throws_list
);
1924 ggc_mark_tree (ld
->function_decl_body
);
1925 ggc_mark_tree (ld
->called_constructor
);
1926 ggc_mark_tree (ld
->inner_access
);
1929 else if (TYPE_P (t
))
1931 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
1936 ggc_mark_tree (lt
->signature
);
1937 ggc_mark_tree (lt
->cpool_data_ref
);
1938 ggc_mark_tree (lt
->finit_stmt_list
);
1939 ggc_mark_tree (lt
->clinit_stmt_list
);
1940 ggc_mark_tree (lt
->ii_block
);
1941 ggc_mark_tree (lt
->dot_class
);