1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
31 #include "coretypes.h"
38 #include "java-tree.h"
44 #include "java-except.h"
47 #include "tree-inline.h"
50 #if defined (DEBUG_JAVA_BINDING_LEVELS)
51 extern void indent (void);
54 static tree
push_jvm_slot (int, tree
);
55 static tree
lookup_name_current_level (tree
);
56 static tree
push_promoted_type (const char *, tree
);
57 static struct binding_level
*make_binding_level (void);
58 static tree
create_primitive_vtable (const char *);
59 static tree
check_local_named_variable (tree
, tree
, int, int *);
60 static tree
check_local_unnamed_variable (tree
, tree
, tree
);
62 /* Name of the Cloneable class. */
63 tree java_lang_cloneable_identifier_node
;
65 /* Name of the Serializable class. */
66 tree java_io_serializable_identifier_node
;
68 /* The DECL_MAP is a mapping from (index, type) to a decl node.
69 If index < max_locals, it is the index of a local variable.
70 if index >= max_locals, then index-max_locals is a stack slot.
71 The DECL_MAP mapping is represented as a TREE_VEC whose elements
72 are a list of decls (VAR_DECL or PARM_DECL) chained by
73 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
74 we search the chain for a decl with a matching TREE_TYPE. */
76 static GTY(()) tree decl_map
;
78 /* A list of local variables VAR_DECLs for this method that we have seen
79 debug information, but we have not reached their starting (byte) PC yet. */
81 static GTY(()) tree pending_local_decls
;
83 /* Push a local variable or stack slot into the decl_map,
84 and assign it an rtl. */
86 #if defined(DEBUG_JAVA_BINDING_LEVELS)
87 int binding_depth
= 0;
88 int is_class_level
= 0;
96 for (i
= 0; i
< binding_depth
*2; i
++)
99 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
102 push_jvm_slot (int index
, tree decl
)
104 struct rtx_def
*rtl
= NULL
;
105 tree type
= TREE_TYPE (decl
);
108 DECL_CONTEXT (decl
) = current_function_decl
;
109 layout_decl (decl
, 0);
111 /* See if we have an appropriate rtl (i.e. same mode) at this index.
112 If so, we must use it. */
113 tmp
= TREE_VEC_ELT (decl_map
, index
);
114 while (tmp
!= NULL_TREE
)
116 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
))
117 && ! LOCAL_VAR_OUT_OF_SCOPE_P (tmp
))
118 rtl
= DECL_RTL_IF_SET (tmp
);
121 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
124 SET_DECL_RTL (decl
, rtl
);
127 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
128 DECL_REGISTER (decl
) = 1;
132 /* Now link the decl into the decl_map. */
133 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
135 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
136 DECL_LOCAL_START_PC (decl
) = 0;
137 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
138 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
140 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
141 TREE_VEC_ELT (decl_map
, index
) = decl
;
145 /* Find out if 'decl' passed in fits the defined PC location better than
146 'best'. Return decl if it does, return best if it doesn't. If decl
147 is returned, then updated is set to true. */
150 check_local_named_variable (tree best
, tree decl
, int pc
, int *updated
)
152 if (pc
>= DECL_LOCAL_START_PC (decl
)
153 && pc
< DECL_LOCAL_END_PC (decl
))
155 if (best
== NULL_TREE
156 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
157 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
167 /* Find the best declaration based upon type. If 'decl' fits 'type' better
168 than 'best', return 'decl'. Otherwise return 'best'. */
171 check_local_unnamed_variable (tree best
, tree decl
, tree 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 (int index
, tree type
, int pc
)
197 tree decl
= TREE_VEC_ELT (decl_map
, index
);
198 tree best
= NULL_TREE
;
199 int found_scoped_var
= 0;
201 /* Scan through every declaration that has been created in this slot. */
202 while (decl
!= NULL_TREE
)
204 /* Variables created in give_name_to_locals() have a name and have
205 a specified scope, so we can handle them specifically. We want
206 to use the specific decls created for those so they are assigned
207 the right variables in the debugging information. */
208 if (DECL_NAME (decl
) != NULL_TREE
)
210 /* This is a variable we have a name for, so it has a scope
211 supplied in the class file. But it only matters when we
212 actually have a PC to use. If pc<0, then we are asking
213 for a stack slot and this decl won't be one of those. */
215 best
= check_local_named_variable (best
, decl
, pc
,
218 /* We scan for type information unless we found a variable in the
219 proper scope already. */
220 else if (!found_scoped_var
)
222 /* If we don't have scoping information for a variable, we use
223 a different method to look it up. */
224 best
= check_local_unnamed_variable (best
, decl
, type
);
227 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
230 if (best
!= NULL_TREE
)
233 /* If we don't find a match, create one with the type passed in. */
234 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
238 /* Same as find_local_index, except that INDEX is a stack index. */
241 find_stack_slot (int index
, tree type
)
243 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
249 /* A chain of _DECL nodes for all variables, constants, functions,
250 * and typedef types. These are in the reverse of the order supplied.
254 /* For each level, a list of shadowed outer-level local definitions
255 to be restored when this level is popped.
256 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
257 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
260 /* For each level (except not the global one),
261 a chain of BLOCK nodes for all the levels
262 that were entered and exited one level down. */
265 /* The BLOCK node for this level, if one has been preallocated.
266 If 0, the BLOCK is allocated (if needed) when the level is popped. */
269 /* The binding level which this one is contained in (inherits from). */
270 struct binding_level
*level_chain
;
272 /* The bytecode PC that marks the end of this level. */
274 /* The bytecode PC that marks the start of this level. */
277 #if defined(DEBUG_JAVA_BINDING_LEVELS)
278 /* Binding depth at which this level began. */
279 unsigned binding_depth
;
280 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
283 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
285 /* The binding level currently in effect. */
287 static struct binding_level
*current_binding_level
;
289 /* A chain of binding_level structures awaiting reuse. */
291 static struct binding_level
*free_binding_level
;
293 /* The outermost binding level, for names of file scope.
294 This is created when the compiler is started and exists
295 through the entire run. */
297 static struct binding_level
*global_binding_level
;
299 /* A PC value bigger than any PC value we may ever may encounter. */
301 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
303 /* Binding level structures are initialized by copying this one. */
305 static const struct binding_level clear_binding_level
306 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
307 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
310 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
311 that have names. Here so we can clear out their names' definitions
312 at the end of the function. */
314 static tree named_labels
;
316 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
318 static tree shadowed_labels
;
321 tree java_global_trees
[JTI_MAX
];
323 /* Build (and pushdecl) a "promoted type" for all standard
324 types shorter than int. */
327 push_promoted_type (const char *name
, tree actual_type
)
329 tree type
= make_node (TREE_CODE (actual_type
));
331 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
332 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
334 tree in_min
= TYPE_MIN_VALUE (actual_type
);
335 tree in_max
= TYPE_MAX_VALUE (actual_type
);
337 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
338 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
339 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
340 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
341 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
343 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
347 /* Return a definition for a builtin function named NAME and whose data type
348 is TYPE. TYPE should be a function type with argument types.
349 FUNCTION_CODE tells later passes how to compile calls to this function.
350 See tree.h for its possible values.
352 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
353 the name to be called if we can't opencode the function. If
354 ATTRS is nonzero, use that for the function's attribute list. */
357 builtin_function (const char *name
,
360 enum built_in_class
class,
361 const char *library_name
,
362 tree attrs ATTRIBUTE_UNUSED
)
364 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
365 DECL_EXTERNAL (decl
) = 1;
366 TREE_PUBLIC (decl
) = 1;
368 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
369 make_decl_rtl (decl
, NULL
);
371 DECL_BUILT_IN_CLASS (decl
) = class;
372 DECL_FUNCTION_CODE (decl
) = function_code
;
376 /* Return tree that represents a vtable for a primitive array. */
378 create_primitive_vtable (const char *name
)
383 sprintf (buf
, "_Jv_%sVTable", name
);
384 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
385 DECL_EXTERNAL (r
) = 1;
397 java_init_decl_processing (void)
400 tree field
= NULL_TREE
;
403 init_class_processing ();
404 init_resource_processing ();
406 current_function_decl
= NULL
;
407 current_binding_level
= NULL_BINDING_LEVEL
;
408 free_binding_level
= NULL_BINDING_LEVEL
;
409 pushlevel (0); /* make the binding_level structure for global names */
410 global_binding_level
= current_binding_level
;
412 /* The code here must be similar to build_common_tree_nodes{,_2} in
413 tree.c, especially as to the order of initializing common nodes. */
414 error_mark_node
= make_node (ERROR_MARK
);
415 TREE_TYPE (error_mark_node
) = error_mark_node
;
417 /* Create sizetype first - needed for other types. */
418 initialize_sizetypes ();
420 byte_type_node
= make_signed_type (8);
421 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
422 short_type_node
= make_signed_type (16);
423 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
424 int_type_node
= make_signed_type (32);
425 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
426 long_type_node
= make_signed_type (64);
427 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
429 unsigned_byte_type_node
= make_unsigned_type (8);
430 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
431 unsigned_byte_type_node
));
432 unsigned_short_type_node
= make_unsigned_type (16);
433 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
434 unsigned_short_type_node
));
435 unsigned_int_type_node
= make_unsigned_type (32);
436 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
437 unsigned_int_type_node
));
438 unsigned_long_type_node
= make_unsigned_type (64);
439 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
440 unsigned_long_type_node
));
442 set_sizetype (make_unsigned_type (POINTER_SIZE
));
444 /* Define these next since types below may used them. */
445 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
446 integer_zero_node
= build_int_2 (0, 0);
447 integer_one_node
= build_int_2 (1, 0);
448 integer_two_node
= build_int_2 (2, 0);
449 integer_four_node
= build_int_2 (4, 0);
450 integer_minus_one_node
= build_int_2 (-1, -1);
452 /* A few values used for range checking in the lexer. */
453 decimal_int_max
= build_int_2 (0x80000000, 0);
454 TREE_TYPE (decimal_int_max
) = unsigned_int_type_node
;
455 #if HOST_BITS_PER_WIDE_INT == 64
456 decimal_long_max
= build_int_2 (0x8000000000000000LL
, 0);
458 #if HOST_BITS_PER_WIDE_INT == 32
459 decimal_long_max
= build_int_2 (0, 0x80000000);
461 #error "unsupported size"
464 TREE_TYPE (decimal_long_max
) = unsigned_long_type_node
;
466 size_zero_node
= size_int (0);
467 size_one_node
= size_int (1);
468 bitsize_zero_node
= bitsize_int (0);
469 bitsize_one_node
= bitsize_int (1);
470 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
472 long_zero_node
= build_int_2 (0, 0);
473 TREE_TYPE (long_zero_node
) = long_type_node
;
475 void_type_node
= make_node (VOID_TYPE
);
476 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
477 layout_type (void_type_node
); /* Uses size_zero_node */
478 ptr_type_node
= build_pointer_type (void_type_node
);
479 t
= make_node (VOID_TYPE
);
480 layout_type (t
); /* Uses size_zero_node */
481 return_address_type_node
= build_pointer_type (t
);
483 null_pointer_node
= build_int_2 (0, 0);
484 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
486 /* Used by the parser to represent empty statements and blocks. */
487 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
488 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
491 /* Make a type to be the domain of a few array types
492 whose domains don't really matter.
493 200 is small enough that it always fits in size_t
494 and large enough that it can hold most function names for the
495 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
496 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
498 char_type_node
= make_node (CHAR_TYPE
);
499 TYPE_PRECISION (char_type_node
) = 16;
500 fixup_unsigned_type (char_type_node
);
501 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
503 boolean_type_node
= make_node (BOOLEAN_TYPE
);
504 TYPE_PRECISION (boolean_type_node
) = 1;
505 fixup_unsigned_type (boolean_type_node
);
506 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
508 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
509 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
511 promoted_byte_type_node
512 = push_promoted_type ("promoted_byte", byte_type_node
);
513 promoted_short_type_node
514 = push_promoted_type ("promoted_short", short_type_node
);
515 promoted_char_type_node
516 = push_promoted_type ("promoted_char", char_type_node
);
517 promoted_boolean_type_node
518 = push_promoted_type ("promoted_boolean", boolean_type_node
);
520 float_type_node
= make_node (REAL_TYPE
);
521 TYPE_PRECISION (float_type_node
) = 32;
522 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
524 layout_type (float_type_node
);
526 double_type_node
= make_node (REAL_TYPE
);
527 TYPE_PRECISION (double_type_node
) = 64;
528 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
530 layout_type (double_type_node
);
532 float_zero_node
= build_real (float_type_node
, dconst0
);
533 double_zero_node
= build_real (double_type_node
, dconst0
);
535 /* These are the vtables for arrays of primitives. */
536 boolean_array_vtable
= create_primitive_vtable ("boolean");
537 byte_array_vtable
= create_primitive_vtable ("byte");
538 char_array_vtable
= create_primitive_vtable ("char");
539 short_array_vtable
= create_primitive_vtable ("short");
540 int_array_vtable
= create_primitive_vtable ("int");
541 long_array_vtable
= create_primitive_vtable ("long");
542 float_array_vtable
= create_primitive_vtable ("float");
543 double_array_vtable
= create_primitive_vtable ("double");
545 one_elt_array_domain_type
= build_index_type (integer_one_node
);
546 utf8const_type
= make_node (RECORD_TYPE
);
547 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
548 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
549 FINISH_RECORD (utf8const_type
);
550 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
552 atable_type
= build_array_type (ptr_type_node
,
553 one_elt_array_domain_type
);
554 TYPE_NONALIASED_COMPONENT (atable_type
) = 1;
555 atable_ptr_type
= build_pointer_type (atable_type
);
557 symbol_type
= make_node (RECORD_TYPE
);
558 PUSH_FIELD (symbol_type
, field
, "clname", utf8const_ptr_type
);
559 PUSH_FIELD (symbol_type
, field
, "name", utf8const_ptr_type
);
560 PUSH_FIELD (symbol_type
, field
, "signature", utf8const_ptr_type
);
561 FINISH_RECORD (symbol_type
);
563 symbols_array_type
= build_array_type (symbol_type
,
564 one_elt_array_domain_type
);
565 symbols_array_ptr_type
= build_pointer_type (symbols_array_type
);
567 /* As you're adding items here, please update the code right after
568 this section, so that the filename containing the source code of
569 the pre-defined class gets registered correctly. */
570 unqualified_object_id_node
= get_identifier ("Object");
571 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
572 object_ptr_type_node
= promote_type (object_type_node
);
573 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
574 string_ptr_type_node
= promote_type (string_type_node
);
575 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
576 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
577 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
578 runtime_exception_type_node
=
579 lookup_class (get_identifier ("java.lang.RuntimeException"));
580 error_exception_type_node
=
581 lookup_class (get_identifier ("java.lang.Error"));
583 rawdata_ptr_type_node
584 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
586 add_predefined_file (get_identifier ("java/lang/Class.java"));
587 add_predefined_file (get_identifier ("java/lang/Error.java"));
588 add_predefined_file (get_identifier ("java/lang/Object.java"));
589 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
590 add_predefined_file (get_identifier ("java/lang/String.java"));
591 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
592 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
593 add_predefined_file (get_identifier ("java/lang/Exception.java"));
594 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
595 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
597 methodtable_type
= make_node (RECORD_TYPE
);
598 layout_type (methodtable_type
);
599 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
600 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
602 TYPE_identifier_node
= get_identifier ("TYPE");
603 init_identifier_node
= get_identifier ("<init>");
604 clinit_identifier_node
= get_identifier ("<clinit>");
605 finit_identifier_node
= get_identifier ("finit$");
606 instinit_identifier_node
= get_identifier ("instinit$");
607 void_signature_node
= get_identifier ("()V");
608 length_identifier_node
= get_identifier ("length");
609 finalize_identifier_node
= get_identifier ("finalize");
610 this_identifier_node
= get_identifier ("this");
611 super_identifier_node
= get_identifier ("super");
612 continue_identifier_node
= get_identifier ("continue");
613 access0_identifier_node
= get_identifier ("access$0");
614 classdollar_identifier_node
= get_identifier ("class$");
616 java_lang_cloneable_identifier_node
= get_identifier ("java.lang.Cloneable");
617 java_io_serializable_identifier_node
=
618 get_identifier ("java.io.Serializable");
620 /* for lack of a better place to put this stub call */
621 init_expr_processing();
623 constants_type_node
= make_node (RECORD_TYPE
);
624 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
625 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
626 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
627 FINISH_RECORD (constants_type_node
);
628 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
630 access_flags_type_node
= unsigned_short_type_node
;
632 dtable_type
= make_node (RECORD_TYPE
);
633 dtable_ptr_type
= build_pointer_type (dtable_type
);
635 otable_type
= build_array_type (integer_type_node
,
636 one_elt_array_domain_type
);
637 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
638 otable_ptr_type
= build_pointer_type (otable_type
);
640 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
641 /* This isn't exactly true, but it is what we have in the source.
642 There is an unresolved issue here, which is whether the vtable
643 should be marked by the GC. */
644 if (! flag_hash_synchronization
)
645 PUSH_FIELD (object_type_node
, field
, "sync_info",
646 build_pointer_type (object_type_node
));
647 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
648 FIELD_PRIVATE (t
) = 1;
649 FINISH_RECORD (object_type_node
);
651 field_type_node
= make_node (RECORD_TYPE
);
652 field_ptr_type_node
= build_pointer_type (field_type_node
);
653 method_type_node
= make_node (RECORD_TYPE
);
654 method_ptr_type_node
= build_pointer_type (method_type_node
);
656 set_super_info (0, class_type_node
, object_type_node
, 0);
657 set_super_info (0, string_type_node
, object_type_node
, 0);
658 class_ptr_type
= build_pointer_type (class_type_node
);
660 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
661 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
662 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
663 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
664 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
665 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
666 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
667 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
668 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
669 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
670 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
671 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
672 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
673 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
674 PUSH_FIELD (class_type_node
, field
, "otable_syms",
675 symbols_array_ptr_type
);
676 PUSH_FIELD (class_type_node
, field
, "atable", atable_ptr_type
);
677 PUSH_FIELD (class_type_node
, field
, "atable_syms",
678 symbols_array_ptr_type
);
679 PUSH_FIELD (class_type_node
, field
, "catch_classes", ptr_type_node
);
680 PUSH_FIELD (class_type_node
, field
, "interfaces",
681 build_pointer_type (class_ptr_type
));
682 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
683 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
684 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
685 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
686 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
687 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
688 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
689 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
690 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
691 PUSH_FIELD (class_type_node
, field
, "hack_signers", ptr_type_node
);
692 PUSH_FIELD (class_type_node
, field
, "chain", ptr_type_node
);
693 PUSH_FIELD (class_type_node
, field
, "aux_info", ptr_type_node
);
694 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
695 FIELD_PRIVATE (t
) = 1;
696 push_super_field (class_type_node
, object_type_node
);
698 FINISH_RECORD (class_type_node
);
699 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
701 field_info_union_node
= make_node (UNION_TYPE
);
702 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
703 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
705 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
707 layout_type (field_info_union_node
);
709 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
710 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
711 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
712 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
713 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
714 FINISH_RECORD (field_type_node
);
715 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
717 nativecode_ptr_array_type_node
718 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
720 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
721 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
722 FINISH_RECORD (dtable_type
);
723 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
725 #define jint_type int_type_node
726 #define jint_ptr_type ptr_type_node
728 jexception_type
= make_node (RECORD_TYPE
);
729 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
730 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
731 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
732 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
733 FINISH_RECORD (jexception_type
);
734 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
735 jexception_ptr_type
= build_pointer_type (jexception_type
);
737 lineNumberEntry_type
= make_node (RECORD_TYPE
);
738 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
739 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
740 FINISH_RECORD (lineNumberEntry_type
);
742 lineNumbers_type
= make_node (RECORD_TYPE
);
743 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
744 FINISH_RECORD (lineNumbers_type
);
746 #define instn_ptr_type_node ptr_type_node /* XXX JH */
748 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
750 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
751 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
752 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
753 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
754 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
755 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
756 FINISH_RECORD (method_type_node
);
757 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
759 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
761 t
= tree_cons (NULL_TREE
, class_ptr_type
,
762 tree_cons (NULL_TREE
, int_type_node
, endlink
));
763 alloc_object_node
= builtin_function ("_Jv_AllocObject",
764 build_function_type (ptr_type_node
, t
),
765 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
766 DECL_IS_MALLOC (alloc_object_node
) = 1;
767 alloc_no_finalizer_node
=
768 builtin_function ("_Jv_AllocObjectNoFinalizer",
769 build_function_type (ptr_type_node
, t
),
770 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
771 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
773 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
774 soft_initclass_node
= builtin_function ("_Jv_InitClass",
775 build_function_type (void_type_node
,
777 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
779 throw_node
= builtin_function ("_Jv_Throw",
780 build_function_type (ptr_type_node
, t
),
781 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
782 /* Mark throw_nodes as `noreturn' functions with side effects. */
783 TREE_THIS_VOLATILE (throw_node
) = 1;
784 TREE_SIDE_EFFECTS (throw_node
) = 1;
786 t
= build_function_type (int_type_node
, endlink
);
787 soft_monitorenter_node
788 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
790 soft_monitorexit_node
791 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
794 t
= tree_cons (NULL_TREE
, int_type_node
,
795 tree_cons (NULL_TREE
, int_type_node
, endlink
));
797 = builtin_function ("_Jv_NewPrimArray",
798 build_function_type(ptr_type_node
, t
),
799 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
800 DECL_IS_MALLOC (soft_newarray_node
) = 1;
802 t
= tree_cons (NULL_TREE
, int_type_node
,
803 tree_cons (NULL_TREE
, class_ptr_type
,
804 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
806 = builtin_function ("_Jv_NewObjectArray",
807 build_function_type (ptr_type_node
, t
),
808 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
809 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
811 /* There is no endlink here because _Jv_NewMultiArray is a varargs
813 t
= tree_cons (NULL_TREE
, ptr_type_node
,
814 tree_cons (NULL_TREE
, int_type_node
, NULL_TREE
));
815 soft_multianewarray_node
816 = builtin_function ("_Jv_NewMultiArray",
817 build_function_type (ptr_type_node
, t
),
818 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
819 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
821 t
= build_function_type (void_type_node
,
822 tree_cons (NULL_TREE
, int_type_node
, endlink
));
823 soft_badarrayindex_node
824 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
825 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
826 /* Mark soft_badarrayindex_node as a `noreturn' function with side
828 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
829 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
831 soft_nullpointer_node
832 = builtin_function ("_Jv_ThrowNullPointerException",
833 build_function_type (void_type_node
, endlink
),
834 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
835 /* Mark soft_nullpointer_node as a `noreturn' function with side
837 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
838 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
840 t
= tree_cons (NULL_TREE
, class_ptr_type
,
841 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
843 = builtin_function ("_Jv_CheckCast",
844 build_function_type (ptr_type_node
, t
),
845 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
846 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
847 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
849 = builtin_function ("_Jv_IsInstanceOf",
850 build_function_type (boolean_type_node
, t
),
851 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
852 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
853 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
854 soft_checkarraystore_node
855 = builtin_function ("_Jv_CheckArrayStore",
856 build_function_type (void_type_node
, t
),
857 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
858 t
= tree_cons (NULL_TREE
, ptr_type_node
,
859 tree_cons (NULL_TREE
, ptr_type_node
,
860 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
861 soft_lookupinterfacemethod_node
862 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
863 build_function_type (ptr_type_node
, t
),
864 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
866 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
867 tree_cons (NULL_TREE
, ptr_type_node
,
868 tree_cons (NULL_TREE
, ptr_type_node
,
869 tree_cons (NULL_TREE
, int_type_node
,
871 soft_lookupjnimethod_node
872 = builtin_function ("_Jv_LookupJNIMethod",
873 build_function_type (ptr_type_node
, t
),
874 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
875 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
876 soft_getjnienvnewframe_node
877 = builtin_function ("_Jv_GetJNIEnvNewFrame",
878 build_function_type (ptr_type_node
, t
),
879 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
880 soft_jnipopsystemframe_node
881 = builtin_function ("_Jv_JNI_PopSystemFrame",
882 build_function_type (ptr_type_node
, t
),
883 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
886 = builtin_function ("_Jv_divI",
887 build_function_type (int_type_node
, t
),
888 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
891 = builtin_function ("_Jv_remI",
892 build_function_type (int_type_node
, t
),
893 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
896 = builtin_function ("_Jv_divJ",
897 build_function_type (long_type_node
, t
),
898 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
901 = builtin_function ("_Jv_remJ",
902 build_function_type (long_type_node
, t
),
903 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
905 /* Initialize variables for except.c. */
906 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
907 ? "__gcj_personality_sj0"
908 : "__gcj_personality_v0");
910 lang_eh_runtime_type
= do_nothing
;
914 initialize_builtins ();
915 soft_fmod_node
= built_in_decls
[BUILT_IN_FMOD
];
917 soft_fmodf_node
= built_in_decls
[BUILT_IN_FMODF
];
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. */
928 lookup_name (tree name
)
931 if (current_binding_level
!= global_binding_level
932 && IDENTIFIER_LOCAL_VALUE (name
))
933 val
= IDENTIFIER_LOCAL_VALUE (name
);
935 val
= IDENTIFIER_GLOBAL_VALUE (name
);
939 /* Similar to `lookup_name' but look only at current binding level and
940 the previous one if its the parameter level. */
943 lookup_name_current_level (tree name
)
947 if (current_binding_level
== global_binding_level
)
948 return IDENTIFIER_GLOBAL_VALUE (name
);
950 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
953 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
954 if (DECL_NAME (t
) == name
)
960 /* Use a binding level to record a labeled block declaration */
963 push_labeled_block (tree lb
)
965 tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
966 struct binding_level
*b
= current_binding_level
;
967 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
969 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
970 TREE_CHAIN (lb
) = b
->names
;
972 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
975 /* Pop the current binding level, reinstalling values for the previous
979 pop_labeled_block (void)
981 struct binding_level
*b
= current_binding_level
;
982 tree label
= b
->names
;
983 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
986 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
987 TREE_VALUE (b
->shadowed
);
989 /* Pop the current level, and free the structure for reuse. */
990 current_binding_level
= current_binding_level
->level_chain
;
991 b
->level_chain
= free_binding_level
;
992 free_binding_level
= b
;
995 /* Record a decl-node X as belonging to the current lexical scope.
996 Check for errors (such as an incompatible declaration for the same
997 name already seen in the same scope).
999 Returns either X or an old decl for the same name.
1000 If an old decl is returned, it may have been smashed
1001 to agree with what X says. */
1007 tree name
= DECL_NAME (x
);
1008 struct binding_level
*b
= current_binding_level
;
1010 if (TREE_CODE (x
) != TYPE_DECL
)
1011 DECL_CONTEXT (x
) = current_function_decl
;
1014 t
= lookup_name_current_level (name
);
1015 if (t
!= 0 && t
== error_mark_node
)
1016 /* error_mark_node is 0 for a while during initialization! */
1019 error ("%J'%D' used prior to declaration", x
, x
);
1022 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1023 to point to the TYPE_DECL.
1024 Since Java does not have typedefs, a type can only have
1025 one (true) name, given by a class, interface, or builtin. */
1026 if (TREE_CODE (x
) == TYPE_DECL
1027 && TYPE_NAME (TREE_TYPE (x
)) == 0
1028 && TREE_TYPE (x
) != error_mark_node
)
1030 TYPE_NAME (TREE_TYPE (x
)) = x
;
1031 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1034 /* This name is new in its binding level.
1035 Install the new declaration and return it. */
1036 if (b
== global_binding_level
)
1038 /* Install a global value. */
1040 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1044 /* Here to install a non-global value. */
1045 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1046 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1049 /* Warn if shadowing an argument at the top level of the body. */
1050 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1051 /* This warning doesn't apply to the parms of a nested fcn. */
1052 && ! current_binding_level
->parm_flag
1053 /* Check that this is one level down from the parms. */
1054 && current_binding_level
->level_chain
->parm_flag
1055 /* Check that the decl being shadowed
1056 comes from the parm level, one level up. */
1057 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1059 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1060 pedwarn ("declaration of `%s' shadows a parameter",
1061 IDENTIFIER_POINTER (name
));
1063 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1064 IDENTIFIER_POINTER (name
));
1067 /* Maybe warn if shadowing something else. */
1068 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1069 /* No shadow warnings for internally generated vars. */
1070 && DECL_SOURCE_LINE (x
) != 0
1071 /* No shadow warnings for vars made for inlining. */
1072 && ! DECL_FROM_INLINE (x
))
1074 const char *warnstring
= 0;
1076 if (TREE_CODE (x
) == PARM_DECL
1077 && current_binding_level
->level_chain
->parm_flag
)
1078 /* Don't warn about the parm names in function declarator
1079 within a function declarator.
1080 It would be nice to avoid warning in any function
1081 declarator in a declaration, as opposed to a definition,
1082 but there is no way to tell it's not a definition. */
1084 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1085 warnstring
= "declaration of `%s' shadows a parameter";
1086 else if (oldlocal
!= 0)
1087 warnstring
= "declaration of `%s' shadows previous local";
1088 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1089 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1090 warnstring
= "declaration of `%s' shadows global declaration";
1093 warning (warnstring
, IDENTIFIER_POINTER (name
));
1097 /* If storing a local value, there may already be one (inherited).
1098 If so, record it for restoration when this binding level ends. */
1100 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1104 /* Put decls on list in reverse order.
1105 We will reverse them later if necessary. */
1106 TREE_CHAIN (x
) = b
->names
;
1113 pushdecl_force_head (tree x
)
1115 current_binding_level
->names
= x
;
1118 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1121 pushdecl_top_level (tree x
)
1124 struct binding_level
*b
= current_binding_level
;
1126 current_binding_level
= global_binding_level
;
1128 current_binding_level
= b
;
1132 /* Nonzero if we are currently in the global binding level. */
1135 global_bindings_p (void)
1137 return current_binding_level
== global_binding_level
;
1140 /* Return the list of declarations of the current level.
1141 Note that this list is in reverse order unless/until
1142 you nreverse it; and when you do nreverse it, you must
1143 store the result back using `storedecls' or you will lose. */
1148 return current_binding_level
->names
;
1151 /* Create a new `struct binding_level'. */
1153 static struct binding_level
*
1154 make_binding_level (void)
1157 return xmalloc (sizeof (struct binding_level
));
1161 pushlevel (int unused ATTRIBUTE_UNUSED
)
1163 struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1166 /* If this is the top level of a function,
1167 just make sure that NAMED_LABELS is 0. */
1169 if (current_binding_level
== global_binding_level
)
1173 /* Reuse or create a struct for this binding level. */
1175 if (free_binding_level
)
1177 newlevel
= free_binding_level
;
1178 free_binding_level
= free_binding_level
->level_chain
;
1182 newlevel
= make_binding_level ();
1185 /* Add this level to the front of the chain (stack) of levels that
1188 *newlevel
= clear_binding_level
;
1189 newlevel
->level_chain
= current_binding_level
;
1190 current_binding_level
= newlevel
;
1191 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1192 newlevel
->binding_depth
= binding_depth
;
1194 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1195 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1198 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1201 /* Exit a binding level.
1202 Pop the level off, and restore the state of the identifier-decl mappings
1203 that were in effect when this level was entered.
1205 If KEEP is nonzero, this level had explicit declarations, so
1206 and create a "block" (a BLOCK node) for the level
1207 to record its declarations and subblocks for symbol table output.
1209 If FUNCTIONBODY is nonzero, this level is the body of a function,
1210 so create a block as if KEEP were set and also clear out all
1213 If REVERSE is nonzero, reverse the order of decls before putting
1214 them into the BLOCK. */
1217 poplevel (int keep
, int reverse
, int functionbody
)
1220 /* The chain of decls was accumulated in reverse order.
1221 Put it into forward order, just for cleanliness. */
1223 tree subblocks
= current_binding_level
->blocks
;
1226 int block_previously_created
;
1229 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1232 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1233 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1234 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1235 current_binding_level
->end_pc
);
1237 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1238 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1240 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1243 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1247 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1249 /* Get the decls in the order they were written.
1250 Usually current_binding_level->names is in reverse order.
1251 But parameter decls were previously put in forward order. */
1254 current_binding_level
->names
1255 = decls
= nreverse (current_binding_level
->names
);
1257 decls
= current_binding_level
->names
;
1259 /* Output any nested inline functions within this block
1260 if they weren't already output. */
1262 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1263 if (TREE_CODE (decl
) == FUNCTION_DECL
1264 && ! TREE_ASM_WRITTEN (decl
)
1265 && DECL_INITIAL (decl
) != 0
1266 && TREE_ADDRESSABLE (decl
))
1268 /* If this decl was copied from a file-scope decl on account
1269 of a block-scope extern decl, propagate TREE_ADDRESSABLE
1270 to the file-scope decl.
1272 DECL_ABSTRACT_ORIGIN can be set to itself if
1273 warn_return_type is true, since then the decl goes
1274 through save_for_inline_copying. */
1275 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1276 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1277 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1280 push_function_context ();
1281 output_inline_function (decl
);
1282 pop_function_context ();
1285 else if (TREE_CODE (decl
) == VAR_DECL
1286 && DECL_LANG_SPECIFIC (decl
) != NULL
1287 && DECL_LOCAL_SLOT_NUMBER (decl
))
1288 LOCAL_VAR_OUT_OF_SCOPE_P (decl
) = 1;
1291 /* If there were any declarations in that level,
1292 or if this level is a function body,
1293 create a BLOCK to record them for the life of this function. */
1296 block_previously_created
= (current_binding_level
->this_block
!= 0);
1297 if (block_previously_created
)
1298 block
= current_binding_level
->this_block
;
1299 else if (keep
|| functionbody
)
1300 block
= make_node (BLOCK
);
1303 BLOCK_VARS (block
) = decls
;
1304 BLOCK_SUBBLOCKS (block
) = subblocks
;
1307 /* In each subblock, record that this is its superior. */
1309 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1310 BLOCK_SUPERCONTEXT (link
) = block
;
1312 /* Clear out the meanings of the local variables of this level. */
1314 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1316 tree name
= DECL_NAME (link
);
1317 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1319 /* If the ident. was used or addressed via a local extern decl,
1320 don't forget that fact. */
1321 if (DECL_EXTERNAL (link
))
1323 if (TREE_USED (link
))
1324 TREE_USED (name
) = 1;
1325 if (TREE_ADDRESSABLE (link
))
1326 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1328 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1332 /* Restore all name-meanings of the outer levels
1333 that were shadowed by this level. */
1335 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1336 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1338 /* If the level being exited is the top level of a function,
1339 check over all the labels, and clear out the current
1340 (function local) meanings of their names. */
1344 /* If this is the top level block of a function,
1345 the vars are the function's parameters.
1346 Don't leave them in the BLOCK because they are
1347 found in the FUNCTION_DECL instead. */
1349 BLOCK_VARS (block
) = 0;
1351 /* Clear out the definitions of all label names,
1352 since their scopes end here,
1353 and add them to BLOCK_VARS. */
1356 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1358 tree label
= TREE_VALUE (link
);
1360 if (DECL_INITIAL (label
) == 0)
1362 error ("%Jlabel '%D' used but not defined", label
, label
);
1363 /* Avoid crashing later. */
1364 define_label (input_location
, DECL_NAME (label
));
1366 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1367 warning ("%Jlabel '%D' defined but not used", label
, label
);
1368 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1370 /* Put the labels into the "variables" of the
1371 top-level block, so debugger can see them. */
1372 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1373 BLOCK_VARS (block
) = label
;
1378 /* Pop the current level, and free the structure for reuse. */
1381 struct binding_level
*level
= current_binding_level
;
1382 current_binding_level
= current_binding_level
->level_chain
;
1384 level
->level_chain
= free_binding_level
;
1385 free_binding_level
= level
;
1388 /* Dispose of the block that we just made inside some higher level. */
1390 DECL_INITIAL (current_function_decl
) = block
;
1393 if (!block_previously_created
)
1394 current_binding_level
->blocks
1395 = chainon (current_binding_level
->blocks
, block
);
1397 /* If we did not make a block for the level just exited,
1398 any blocks made for inner levels
1399 (since they cannot be recorded as subblocks in that level)
1400 must be carried forward so they will later become subblocks
1401 of something else. */
1403 current_binding_level
->blocks
1404 = chainon (current_binding_level
->blocks
, subblocks
);
1406 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1407 binding contour so that they point to the appropriate construct, i.e.
1408 either to the current FUNCTION_DECL node, or else to the BLOCK node
1409 we just constructed.
1411 Note that for tagged types whose scope is just the formal parameter
1412 list for some function type specification, we can't properly set
1413 their TYPE_CONTEXTs here, because we don't have a pointer to the
1414 appropriate FUNCTION_TYPE node readily available to us. For those
1415 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1416 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1417 node which will represent the "scope" for these "parameter list local"
1422 TREE_USED (block
) = 1;
1427 maybe_pushlevels (int pc
)
1429 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1433 while (pending_local_decls
!= NULL_TREE
&&
1434 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1436 tree
*ptr
= &pending_local_decls
;
1438 int end_pc
= DECL_LOCAL_END_PC (decl
);
1440 while (*ptr
!= NULL_TREE
1441 && DECL_LOCAL_START_PC (*ptr
) <= pc
1442 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1443 ptr
= &TREE_CHAIN (*ptr
);
1444 pending_local_decls
= *ptr
;
1447 /* Force non-nested range to be nested in current range. */
1448 if (end_pc
> current_binding_level
->end_pc
)
1449 end_pc
= current_binding_level
->end_pc
;
1451 maybe_start_try (pc
, end_pc
);
1454 expand_start_bindings (0);
1456 current_binding_level
->end_pc
= end_pc
;
1457 current_binding_level
->start_pc
= pc
;
1458 current_binding_level
->names
= decl
;
1459 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1461 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1465 maybe_start_try (pc
, 0);
1469 maybe_poplevels (int pc
)
1471 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1475 while (current_binding_level
->end_pc
<= pc
)
1477 expand_end_bindings (getdecls (), 1, 0);
1478 maybe_end_try (current_binding_level
->start_pc
, pc
);
1481 maybe_end_try (0, pc
);
1484 /* Terminate any binding which began during the range beginning at
1485 start_pc. This tidies up improperly nested local variable ranges
1486 and exception handlers; a variable declared within an exception
1487 range is forcibly terminated when that exception ends. */
1490 force_poplevels (int start_pc
)
1492 while (current_binding_level
->start_pc
> start_pc
)
1494 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1495 warning ("%JIn %D: overlapped variable and exception ranges at %d",
1496 current_function_decl
, current_function_decl
,
1497 current_binding_level
->start_pc
);
1498 expand_end_bindings (getdecls (), 1, 0);
1503 /* Insert BLOCK at the end of the list of subblocks of the
1504 current binding level. This is used when a BIND_EXPR is expanded,
1505 to handle the BLOCK node inside the BIND_EXPR. */
1508 insert_block (tree block
)
1510 TREE_USED (block
) = 1;
1511 current_binding_level
->blocks
1512 = chainon (current_binding_level
->blocks
, block
);
1515 /* Set the BLOCK node for the innermost scope
1516 (the one we are currently in). */
1519 set_block (tree block
)
1521 current_binding_level
->this_block
= block
;
1522 current_binding_level
->names
= chainon (current_binding_level
->names
,
1523 BLOCK_VARS (block
));
1524 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1525 BLOCK_SUBBLOCKS (block
));
1528 /* integrate_decl_tree calls this function. */
1531 java_dup_lang_specific_decl (tree node
)
1534 struct lang_decl
*x
;
1536 if (!DECL_LANG_SPECIFIC (node
))
1539 lang_decl_size
= sizeof (struct lang_decl
);
1540 x
= ggc_alloc (lang_decl_size
);
1541 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1542 DECL_LANG_SPECIFIC (node
) = x
;
1546 give_name_to_locals (JCF
*jcf
)
1548 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1549 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1551 pending_local_decls
= NULL_TREE
;
1555 n
= JCF_readu2 (jcf
);
1556 for (i
= 0; i
< n
; i
++)
1558 int start_pc
= JCF_readu2 (jcf
);
1559 int length
= JCF_readu2 (jcf
);
1560 int name_index
= JCF_readu2 (jcf
);
1561 int signature_index
= JCF_readu2 (jcf
);
1562 int slot
= JCF_readu2 (jcf
);
1563 tree name
= get_name_constant (jcf
, name_index
);
1564 tree type
= parse_signature (jcf
, signature_index
);
1565 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1567 && length
== DECL_CODE_LENGTH (current_function_decl
))
1569 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1570 DECL_NAME (decl
) = name
;
1571 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1572 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1573 warning ("bad type in parameter debug info");
1578 int end_pc
= start_pc
+ length
;
1579 tree decl
= build_decl (VAR_DECL
, name
, type
);
1580 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1582 warning ("%Jbad PC range for debug info for local '%D'",
1584 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1587 /* Adjust start_pc if necessary so that the local's first
1588 store operation will use the relevant DECL as a
1589 destination. Fore more information, read the leading
1590 comments for expr.c:maybe_adjust_start_pc. */
1591 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1593 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1594 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1595 DECL_LOCAL_START_PC (decl
) = start_pc
;
1597 /* FIXME: The range used internally for exceptions and local
1598 variable ranges, is a half-open interval:
1599 start_pc <= pc < end_pc. However, the range used in the
1600 Java VM spec is inclusive at both ends:
1601 start_pc <= pc <= end_pc. */
1604 DECL_LOCAL_END_PC (decl
) = end_pc
;
1606 /* Now insert the new decl in the proper place in
1607 pending_local_decls. We are essentially doing an insertion sort,
1608 which works fine, since the list input will normally already
1610 ptr
= &pending_local_decls
;
1611 while (*ptr
!= NULL_TREE
1612 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1613 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1614 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1615 ptr
= &TREE_CHAIN (*ptr
);
1616 TREE_CHAIN (decl
) = *ptr
;
1621 pending_local_decls
= nreverse (pending_local_decls
);
1623 /* Fill in default names for the parameters. */
1624 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1625 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1627 if (DECL_NAME (parm
) == NULL_TREE
)
1629 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1631 DECL_NAME (parm
) = get_identifier ("this");
1635 sprintf (buffer
, "ARG_%d", arg_i
);
1636 DECL_NAME (parm
) = get_identifier (buffer
);
1638 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1644 build_result_decl (tree fndecl
)
1646 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1647 tree result
= DECL_RESULT (fndecl
);
1650 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1651 if (INTEGRAL_TYPE_P (restype
)
1652 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1653 restype
= integer_type_node
;
1654 result
= build_decl (RESULT_DECL
, NULL_TREE
, restype
);
1655 DECL_CONTEXT (result
) = fndecl
;
1656 DECL_RESULT (fndecl
) = result
;
1662 complete_start_java_method (tree fndecl
)
1664 if (! flag_emit_class_files
)
1666 /* Initialize the RTL code for the function. */
1667 init_function_start (fndecl
);
1669 /* Set up parameters and prepare for return, for the function. */
1670 expand_function_start (fndecl
, 0);
1674 /* If this fcn was already referenced via a block-scope `extern' decl (or
1675 an implicit decl), propagate certain information about the usage. */
1676 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1677 TREE_ADDRESSABLE (current_function_decl
) = 1;
1681 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1682 && ! flag_emit_class_files
1683 && ! DECL_CLINIT_P (fndecl
)
1684 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1686 tree clas
= DECL_CONTEXT (fndecl
);
1687 tree init
= build (CALL_EXPR
, void_type_node
,
1688 build_address_of (soft_initclass_node
),
1689 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1691 TREE_SIDE_EFFECTS (init
) = 1;
1692 expand_expr_stmt (init
);
1695 /* Push local variables. Function compiled from source code are
1696 using a different local variables management, and for them,
1697 pushlevel shouldn't be called from here. */
1698 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1701 if (! flag_emit_class_files
)
1702 expand_start_bindings (1);
1705 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1707 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1708 tree enter
, exit
, lock
;
1709 if (METHOD_STATIC (fndecl
))
1710 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1712 lock
= DECL_ARGUMENTS (fndecl
);
1713 BUILD_MONITOR_ENTER (enter
, lock
);
1714 BUILD_MONITOR_EXIT (exit
, lock
);
1715 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1717 expand_expr_stmt (enter
);
1718 expand_decl_cleanup (NULL_TREE
, exit
);
1722 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1723 tree body
= BLOCK_EXPR_BODY (function_body
);
1724 lock
= build (COMPOUND_EXPR
, void_type_node
,
1726 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1727 TREE_SIDE_EFFECTS (lock
) = 1;
1728 BLOCK_EXPR_BODY (function_body
) = lock
;
1734 start_java_method (tree fndecl
)
1739 current_function_decl
= fndecl
;
1740 announce_function (fndecl
);
1742 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1743 decl_map
= make_tree_vec (i
);
1744 type_map
= xrealloc (type_map
, i
* sizeof (tree
));
1746 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1747 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1749 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1750 pushlevel (1); /* Push parameters. */
1752 ptr
= &DECL_ARGUMENTS (fndecl
);
1753 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1754 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1756 tree parm_name
= NULL_TREE
, parm_decl
;
1757 tree parm_type
= TREE_VALUE (tem
);
1758 if (i
>= DECL_MAX_LOCALS (fndecl
))
1761 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1762 DECL_CONTEXT (parm_decl
) = fndecl
;
1763 if (targetm
.calls
.promote_prototypes (parm_type
)
1764 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1765 && INTEGRAL_TYPE_P (parm_type
))
1766 parm_type
= integer_type_node
;
1767 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1770 ptr
= &TREE_CHAIN (parm_decl
);
1772 /* Add parm_decl to the decl_map. */
1773 push_jvm_slot (i
, parm_decl
);
1775 type_map
[i
] = TREE_TYPE (parm_decl
);
1776 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1779 type_map
[i
] = void_type_node
;
1783 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1785 while (i
< DECL_MAX_LOCALS(fndecl
))
1786 type_map
[i
++] = NULL_TREE
;
1788 build_result_decl (fndecl
);
1789 complete_start_java_method (fndecl
);
1793 end_java_method (void)
1795 tree fndecl
= current_function_decl
;
1797 expand_end_bindings (getdecls (), 1, 0);
1798 /* pop out of function */
1801 /* pop out of its parameters */
1804 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1806 /* Generate rtl for function exit. */
1807 expand_function_end ();
1809 /* Run the optimizers and output assembler code for this function. */
1810 rest_of_compilation (fndecl
);
1812 current_function_decl
= NULL_TREE
;
1815 /* Expand a function's body. */
1818 java_expand_body (tree fndecl
)
1820 location_t saved_location
= input_location
;
1822 current_function_decl
= fndecl
;
1823 input_location
= DECL_SOURCE_LOCATION (fndecl
);
1824 output_class
= current_class
= DECL_CONTEXT (fndecl
);
1826 timevar_push (TV_EXPAND
);
1828 /* Prepare the function for tree completion. */
1829 start_complete_expand_method (fndecl
);
1831 if (! flag_emit_class_files
&& ! flag_emit_xref
)
1833 /* Initialize the RTL code for the function. */
1834 init_function_start (fndecl
);
1836 /* Set up parameters and prepare for return, for the function. */
1837 expand_function_start (fndecl
, 0);
1839 /* Generate the RTL for this function. */
1840 expand_expr_stmt_value (DECL_SAVED_TREE (fndecl
), 0, 1);
1843 /* Pop out of its parameters. */
1844 pushdecl_force_head (DECL_ARGUMENTS (fndecl
));
1846 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1848 if (! flag_emit_class_files
&& ! flag_emit_xref
)
1850 /* Generate RTL for function exit. */
1851 input_line
= DECL_FUNCTION_LAST_LINE (fndecl
);
1852 expand_function_end ();
1854 /* Run the optimizers and output the assembler code
1855 for this function. */
1856 rest_of_compilation (fndecl
);
1859 timevar_pop (TV_EXPAND
);
1861 input_location
= saved_location
;
1863 current_function_decl
= NULL_TREE
;
1866 /* We pessimistically marked all methods and fields external until we
1867 knew what set of classes we were planning to compile. Now mark those
1868 associated with CLASS to be generated locally as not external. */
1871 java_mark_decl_local (tree decl
)
1873 DECL_EXTERNAL (decl
) = 0;
1875 /* If we've already constructed DECL_RTL, give encode_section_info
1876 a second chance, now that we've changed the flags. */
1877 if (DECL_RTL_SET_P (decl
))
1878 make_decl_rtl (decl
, NULL
);
1882 java_mark_class_local (tree
class)
1886 for (t
= TYPE_FIELDS (class); t
; t
= TREE_CHAIN (t
))
1887 if (FIELD_STATIC (t
))
1888 java_mark_decl_local (t
);
1890 for (t
= TYPE_METHODS (class); t
; t
= TREE_CHAIN (t
))
1891 if (!METHOD_ABSTRACT (t
) && (!METHOD_NATIVE (t
) || flag_jni
))
1892 java_mark_decl_local (t
);
1895 #include "gt-java-decl.h"