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"
49 #if defined (DEBUG_JAVA_BINDING_LEVELS)
50 extern void indent (void);
53 static tree
push_jvm_slot (int, tree
);
54 static tree
lookup_name_current_level (tree
);
55 static tree
push_promoted_type (const char *, tree
);
56 static struct binding_level
*make_binding_level (void);
57 static tree
create_primitive_vtable (const char *);
58 static tree
check_local_named_variable (tree
, tree
, int, int *);
59 static tree
check_local_unnamed_variable (tree
, tree
, tree
);
61 /* Name of the Cloneable class. */
62 tree java_lang_cloneable_identifier_node
;
64 /* Name of the Serializable class. */
65 tree java_io_serializable_identifier_node
;
67 /* The DECL_MAP is a mapping from (index, type) to a decl node.
68 If index < max_locals, it is the index of a local variable.
69 if index >= max_locals, then index-max_locals is a stack slot.
70 The DECL_MAP mapping is represented as a TREE_VEC whose elements
71 are a list of decls (VAR_DECL or PARM_DECL) chained by
72 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
73 we search the chain for a decl with a matching TREE_TYPE. */
75 static GTY(()) tree decl_map
;
77 /* A list of local variables VAR_DECLs for this method that we have seen
78 debug information, but we have not reached their starting (byte) PC yet. */
80 static GTY(()) tree pending_local_decls
;
82 /* Push a local variable or stack slot into the decl_map,
83 and assign it an rtl. */
85 #if defined(DEBUG_JAVA_BINDING_LEVELS)
86 int binding_depth
= 0;
87 int is_class_level
= 0;
95 for (i
= 0; i
< binding_depth
*2; i
++)
98 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
101 push_jvm_slot (int index
, tree decl
)
103 struct rtx_def
*rtl
= NULL
;
104 tree type
= TREE_TYPE (decl
);
107 DECL_CONTEXT (decl
) = current_function_decl
;
108 layout_decl (decl
, 0);
110 /* See if we have an appropriate rtl (i.e. same mode) at this index.
111 If so, we must use it. */
112 tmp
= TREE_VEC_ELT (decl_map
, index
);
113 while (tmp
!= NULL_TREE
)
115 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
))
116 && ! LOCAL_VAR_OUT_OF_SCOPE_P (tmp
))
117 rtl
= DECL_RTL_IF_SET (tmp
);
120 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
123 SET_DECL_RTL (decl
, rtl
);
126 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
127 DECL_REGISTER (decl
) = 1;
131 /* Now link the decl into the decl_map. */
132 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
134 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
135 DECL_LOCAL_START_PC (decl
) = 0;
136 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
137 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
139 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
140 TREE_VEC_ELT (decl_map
, index
) = decl
;
144 /* Find out if 'decl' passed in fits the defined PC location better than
145 'best'. Return decl if it does, return best if it doesn't. If decl
146 is returned, then updated is set to true. */
149 check_local_named_variable (tree best
, tree decl
, int pc
, int *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 (tree best
, tree decl
, tree type
)
172 if (TREE_TYPE (decl
) == type
173 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
174 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
175 && TYPE_PRECISION (type
) <= 32
176 && TREE_CODE (type
) != POINTER_TYPE
)
177 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
178 && type
== ptr_type_node
))
180 if (best
== NULL_TREE
181 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
189 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
190 that is valid at PC (or -1 if any pc).
191 If there is no existing matching decl, allocate one. */
194 find_local_variable (int index
, tree type
, int pc
)
196 tree decl
= TREE_VEC_ELT (decl_map
, index
);
197 tree best
= NULL_TREE
;
198 int found_scoped_var
= 0;
200 /* Scan through every declaration that has been created in this slot. */
201 while (decl
!= NULL_TREE
)
203 /* Variables created in give_name_to_locals() have a name and have
204 a specified scope, so we can handle them specifically. We want
205 to use the specific decls created for those so they are assigned
206 the right variables in the debugging information. */
207 if (DECL_NAME (decl
) != NULL_TREE
)
209 /* This is a variable we have a name for, so it has a scope
210 supplied in the class file. But it only matters when we
211 actually have a PC to use. If pc<0, then we are asking
212 for a stack slot and this decl won't be one of those. */
214 best
= check_local_named_variable (best
, decl
, pc
,
217 /* We scan for type information unless we found a variable in the
218 proper scope already. */
219 else if (!found_scoped_var
)
221 /* If we don't have scoping information for a variable, we use
222 a different method to look it up. */
223 best
= check_local_unnamed_variable (best
, decl
, type
);
226 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
229 if (best
!= NULL_TREE
)
232 /* If we don't find a match, create one with the type passed in. */
233 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
237 /* Same as find_local_index, except that INDEX is a stack index. */
240 find_stack_slot (int index
, tree type
)
242 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
248 /* A chain of _DECL nodes for all variables, constants, functions,
249 * and typedef types. These are in the reverse of the order supplied.
253 /* For each level, a list of shadowed outer-level local definitions
254 to be restored when this level is popped.
255 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
256 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
259 /* For each level (except not the global one),
260 a chain of BLOCK nodes for all the levels
261 that were entered and exited one level down. */
264 /* The BLOCK node for this level, if one has been preallocated.
265 If 0, the BLOCK is allocated (if needed) when the level is popped. */
268 /* The binding level which this one is contained in (inherits from). */
269 struct binding_level
*level_chain
;
271 /* The bytecode PC that marks the end of this level. */
273 /* The bytecode PC that marks the start of this level. */
276 #if defined(DEBUG_JAVA_BINDING_LEVELS)
277 /* Binding depth at which this level began. */
278 unsigned binding_depth
;
279 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
282 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
284 /* The binding level currently in effect. */
286 static struct binding_level
*current_binding_level
;
288 /* A chain of binding_level structures awaiting reuse. */
290 static struct binding_level
*free_binding_level
;
292 /* The outermost binding level, for names of file scope.
293 This is created when the compiler is started and exists
294 through the entire run. */
296 static struct binding_level
*global_binding_level
;
298 /* A PC value bigger than any PC value we may ever may encounter. */
300 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
302 /* Binding level structures are initialized by copying this one. */
304 static const struct binding_level clear_binding_level
305 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
306 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
309 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
310 that have names. Here so we can clear out their names' definitions
311 at the end of the function. */
313 static tree named_labels
;
315 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
317 static tree shadowed_labels
;
320 tree java_global_trees
[JTI_MAX
];
322 /* Build (and pushdecl) a "promoted type" for all standard
323 types shorter than int. */
326 push_promoted_type (const char *name
, tree actual_type
)
328 tree type
= make_node (TREE_CODE (actual_type
));
330 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
331 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
333 tree in_min
= TYPE_MIN_VALUE (actual_type
);
334 tree in_max
= TYPE_MAX_VALUE (actual_type
);
336 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
337 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
338 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
339 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
340 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
342 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
346 /* Return a definition for a builtin function named NAME and whose data type
347 is TYPE. TYPE should be a function type with argument types.
348 FUNCTION_CODE tells later passes how to compile calls to this function.
349 See tree.h for its possible values.
351 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
352 the name to be called if we can't opencode the function. If
353 ATTRS is nonzero, use that for the function's attribute list. */
356 builtin_function (const char *name
,
359 enum built_in_class
class,
360 const char *library_name
,
361 tree attrs ATTRIBUTE_UNUSED
)
363 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
364 DECL_EXTERNAL (decl
) = 1;
365 TREE_PUBLIC (decl
) = 1;
367 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
368 make_decl_rtl (decl
, NULL
);
370 DECL_BUILT_IN_CLASS (decl
) = class;
371 DECL_FUNCTION_CODE (decl
) = function_code
;
375 /* Return tree that represents a vtable for a primitive array. */
377 create_primitive_vtable (const char *name
)
382 sprintf (buf
, "_Jv_%sVTable", name
);
383 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
384 DECL_EXTERNAL (r
) = 1;
396 java_init_decl_processing (void)
399 tree field
= NULL_TREE
;
402 init_class_processing ();
403 init_resource_processing ();
405 current_function_decl
= NULL
;
406 current_binding_level
= NULL_BINDING_LEVEL
;
407 free_binding_level
= NULL_BINDING_LEVEL
;
408 pushlevel (0); /* make the binding_level structure for global names */
409 global_binding_level
= current_binding_level
;
411 /* The code here must be similar to build_common_tree_nodes{,_2} in
412 tree.c, especially as to the order of initializing common nodes. */
413 error_mark_node
= make_node (ERROR_MARK
);
414 TREE_TYPE (error_mark_node
) = error_mark_node
;
416 /* Create sizetype first - needed for other types. */
417 initialize_sizetypes ();
419 byte_type_node
= make_signed_type (8);
420 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
421 short_type_node
= make_signed_type (16);
422 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
423 int_type_node
= make_signed_type (32);
424 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
425 long_type_node
= make_signed_type (64);
426 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
428 unsigned_byte_type_node
= make_unsigned_type (8);
429 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
430 unsigned_byte_type_node
));
431 unsigned_short_type_node
= make_unsigned_type (16);
432 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
433 unsigned_short_type_node
));
434 unsigned_int_type_node
= make_unsigned_type (32);
435 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
436 unsigned_int_type_node
));
437 unsigned_long_type_node
= make_unsigned_type (64);
438 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
439 unsigned_long_type_node
));
441 set_sizetype (make_unsigned_type (POINTER_SIZE
));
443 /* Define these next since types below may used them. */
444 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
445 integer_zero_node
= build_int_2 (0, 0);
446 integer_one_node
= build_int_2 (1, 0);
447 integer_two_node
= build_int_2 (2, 0);
448 integer_four_node
= build_int_2 (4, 0);
449 integer_minus_one_node
= build_int_2 (-1, -1);
451 /* A few values used for range checking in the lexer. */
452 decimal_int_max
= build_int_2 (0x80000000, 0);
453 TREE_TYPE (decimal_int_max
) = unsigned_int_type_node
;
454 #if HOST_BITS_PER_WIDE_INT == 64
455 decimal_long_max
= build_int_2 (0x8000000000000000LL
, 0);
457 #if HOST_BITS_PER_WIDE_INT == 32
458 decimal_long_max
= build_int_2 (0, 0x80000000);
460 #error "unsupported size"
463 TREE_TYPE (decimal_long_max
) = unsigned_long_type_node
;
465 size_zero_node
= size_int (0);
466 size_one_node
= size_int (1);
467 bitsize_zero_node
= bitsize_int (0);
468 bitsize_one_node
= bitsize_int (1);
469 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
471 long_zero_node
= build_int_2 (0, 0);
472 TREE_TYPE (long_zero_node
) = long_type_node
;
474 void_type_node
= make_node (VOID_TYPE
);
475 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
476 layout_type (void_type_node
); /* Uses size_zero_node */
477 ptr_type_node
= build_pointer_type (void_type_node
);
478 t
= make_node (VOID_TYPE
);
479 layout_type (t
); /* Uses size_zero_node */
480 return_address_type_node
= build_pointer_type (t
);
482 null_pointer_node
= build_int_2 (0, 0);
483 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
485 /* Used by the parser to represent empty statements and blocks. */
486 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
487 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
490 /* Make a type to be the domain of a few array types
491 whose domains don't really matter.
492 200 is small enough that it always fits in size_t
493 and large enough that it can hold most function names for the
494 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
495 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
497 char_type_node
= make_node (CHAR_TYPE
);
498 TYPE_PRECISION (char_type_node
) = 16;
499 fixup_unsigned_type (char_type_node
);
500 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
502 boolean_type_node
= make_node (BOOLEAN_TYPE
);
503 TYPE_PRECISION (boolean_type_node
) = 1;
504 fixup_unsigned_type (boolean_type_node
);
505 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
507 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
508 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
510 promoted_byte_type_node
511 = push_promoted_type ("promoted_byte", byte_type_node
);
512 promoted_short_type_node
513 = push_promoted_type ("promoted_short", short_type_node
);
514 promoted_char_type_node
515 = push_promoted_type ("promoted_char", char_type_node
);
516 promoted_boolean_type_node
517 = push_promoted_type ("promoted_boolean", boolean_type_node
);
519 float_type_node
= make_node (REAL_TYPE
);
520 TYPE_PRECISION (float_type_node
) = 32;
521 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
523 layout_type (float_type_node
);
525 double_type_node
= make_node (REAL_TYPE
);
526 TYPE_PRECISION (double_type_node
) = 64;
527 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
529 layout_type (double_type_node
);
531 float_zero_node
= build_real (float_type_node
, dconst0
);
532 double_zero_node
= build_real (double_type_node
, dconst0
);
534 /* These are the vtables for arrays of primitives. */
535 boolean_array_vtable
= create_primitive_vtable ("boolean");
536 byte_array_vtable
= create_primitive_vtable ("byte");
537 char_array_vtable
= create_primitive_vtable ("char");
538 short_array_vtable
= create_primitive_vtable ("short");
539 int_array_vtable
= create_primitive_vtable ("int");
540 long_array_vtable
= create_primitive_vtable ("long");
541 float_array_vtable
= create_primitive_vtable ("float");
542 double_array_vtable
= create_primitive_vtable ("double");
544 one_elt_array_domain_type
= build_index_type (integer_one_node
);
545 utf8const_type
= make_node (RECORD_TYPE
);
546 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
547 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
548 FINISH_RECORD (utf8const_type
);
549 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
551 atable_type
= build_array_type (ptr_type_node
,
552 one_elt_array_domain_type
);
553 TYPE_NONALIASED_COMPONENT (atable_type
) = 1;
554 atable_ptr_type
= build_pointer_type (atable_type
);
556 symbol_type
= make_node (RECORD_TYPE
);
557 PUSH_FIELD (symbol_type
, field
, "clname", utf8const_ptr_type
);
558 PUSH_FIELD (symbol_type
, field
, "name", utf8const_ptr_type
);
559 PUSH_FIELD (symbol_type
, field
, "signature", utf8const_ptr_type
);
560 FINISH_RECORD (symbol_type
);
562 symbols_array_type
= build_array_type (symbol_type
,
563 one_elt_array_domain_type
);
564 symbols_array_ptr_type
= build_pointer_type (symbols_array_type
);
566 /* As you're adding items here, please update the code right after
567 this section, so that the filename containing the source code of
568 the pre-defined class gets registered correctly. */
569 unqualified_object_id_node
= get_identifier ("Object");
570 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
571 object_ptr_type_node
= promote_type (object_type_node
);
572 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
573 string_ptr_type_node
= promote_type (string_type_node
);
574 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
575 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
576 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
577 runtime_exception_type_node
=
578 lookup_class (get_identifier ("java.lang.RuntimeException"));
579 error_exception_type_node
=
580 lookup_class (get_identifier ("java.lang.Error"));
582 rawdata_ptr_type_node
583 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
585 add_predefined_file (get_identifier ("java/lang/Class.java"));
586 add_predefined_file (get_identifier ("java/lang/Error.java"));
587 add_predefined_file (get_identifier ("java/lang/Object.java"));
588 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
589 add_predefined_file (get_identifier ("java/lang/String.java"));
590 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
591 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
592 add_predefined_file (get_identifier ("java/lang/Exception.java"));
593 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
594 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
595 add_predefined_file (get_identifier ("gnu/gcj/RawData.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 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
694 FIELD_PRIVATE (t
) = 1;
695 push_super_field (class_type_node
, object_type_node
);
697 FINISH_RECORD (class_type_node
);
698 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
700 field_info_union_node
= make_node (UNION_TYPE
);
701 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
702 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
704 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
706 layout_type (field_info_union_node
);
708 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
709 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
710 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
711 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
712 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
713 FINISH_RECORD (field_type_node
);
714 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
716 nativecode_ptr_array_type_node
717 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
719 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
720 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
721 FINISH_RECORD (dtable_type
);
722 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
724 #define jint_type int_type_node
725 #define jint_ptr_type ptr_type_node
727 jexception_type
= make_node (RECORD_TYPE
);
728 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
729 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
730 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
731 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
732 FINISH_RECORD (jexception_type
);
733 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
734 jexception_ptr_type
= build_pointer_type (jexception_type
);
736 lineNumberEntry_type
= make_node (RECORD_TYPE
);
737 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
738 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
739 FINISH_RECORD (lineNumberEntry_type
);
741 lineNumbers_type
= make_node (RECORD_TYPE
);
742 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
743 FINISH_RECORD (lineNumbers_type
);
745 #define instn_ptr_type_node ptr_type_node /* XXX JH */
747 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
749 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
750 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
751 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
752 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
753 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
754 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
755 FINISH_RECORD (method_type_node
);
756 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
758 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
760 t
= tree_cons (NULL_TREE
, class_ptr_type
,
761 tree_cons (NULL_TREE
, int_type_node
, endlink
));
762 alloc_object_node
= builtin_function ("_Jv_AllocObject",
763 build_function_type (ptr_type_node
, t
),
764 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
765 DECL_IS_MALLOC (alloc_object_node
) = 1;
766 alloc_no_finalizer_node
=
767 builtin_function ("_Jv_AllocObjectNoFinalizer",
768 build_function_type (ptr_type_node
, t
),
769 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
770 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
772 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
773 soft_initclass_node
= builtin_function ("_Jv_InitClass",
774 build_function_type (void_type_node
,
776 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
778 throw_node
= builtin_function ("_Jv_Throw",
779 build_function_type (ptr_type_node
, t
),
780 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
781 /* Mark throw_nodes as `noreturn' functions with side effects. */
782 TREE_THIS_VOLATILE (throw_node
) = 1;
783 TREE_SIDE_EFFECTS (throw_node
) = 1;
785 t
= build_function_type (int_type_node
, endlink
);
786 soft_monitorenter_node
787 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
789 soft_monitorexit_node
790 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
793 t
= tree_cons (NULL_TREE
, int_type_node
,
794 tree_cons (NULL_TREE
, int_type_node
, endlink
));
796 = builtin_function ("_Jv_NewPrimArray",
797 build_function_type(ptr_type_node
, t
),
798 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
799 DECL_IS_MALLOC (soft_newarray_node
) = 1;
801 t
= tree_cons (NULL_TREE
, int_type_node
,
802 tree_cons (NULL_TREE
, class_ptr_type
,
803 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
805 = builtin_function ("_Jv_NewObjectArray",
806 build_function_type (ptr_type_node
, t
),
807 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
808 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
810 /* There is no endlink here because _Jv_NewMultiArray is a varargs
812 t
= tree_cons (NULL_TREE
, ptr_type_node
,
813 tree_cons (NULL_TREE
, int_type_node
, NULL_TREE
));
814 soft_multianewarray_node
815 = builtin_function ("_Jv_NewMultiArray",
816 build_function_type (ptr_type_node
, t
),
817 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
818 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
820 t
= build_function_type (void_type_node
,
821 tree_cons (NULL_TREE
, int_type_node
, endlink
));
822 soft_badarrayindex_node
823 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
824 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
825 /* Mark soft_badarrayindex_node as a `noreturn' function with side
827 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
828 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
830 soft_nullpointer_node
831 = builtin_function ("_Jv_ThrowNullPointerException",
832 build_function_type (void_type_node
, endlink
),
833 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
834 /* Mark soft_nullpointer_node as a `noreturn' function with side
836 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
837 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
839 t
= tree_cons (NULL_TREE
, class_ptr_type
,
840 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
842 = builtin_function ("_Jv_CheckCast",
843 build_function_type (ptr_type_node
, t
),
844 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
845 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
846 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
848 = builtin_function ("_Jv_IsInstanceOf",
849 build_function_type (boolean_type_node
, t
),
850 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
851 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
852 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
853 soft_checkarraystore_node
854 = builtin_function ("_Jv_CheckArrayStore",
855 build_function_type (void_type_node
, t
),
856 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
857 t
= tree_cons (NULL_TREE
, ptr_type_node
,
858 tree_cons (NULL_TREE
, ptr_type_node
,
859 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
860 soft_lookupinterfacemethod_node
861 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
862 build_function_type (ptr_type_node
, t
),
863 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
865 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
866 tree_cons (NULL_TREE
, ptr_type_node
,
867 tree_cons (NULL_TREE
, ptr_type_node
,
868 tree_cons (NULL_TREE
, int_type_node
,
870 soft_lookupjnimethod_node
871 = builtin_function ("_Jv_LookupJNIMethod",
872 build_function_type (ptr_type_node
, t
),
873 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
874 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
875 soft_getjnienvnewframe_node
876 = builtin_function ("_Jv_GetJNIEnvNewFrame",
877 build_function_type (ptr_type_node
, t
),
878 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
879 soft_jnipopsystemframe_node
880 = builtin_function ("_Jv_JNI_PopSystemFrame",
881 build_function_type (ptr_type_node
, t
),
882 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
885 = builtin_function ("_Jv_divI",
886 build_function_type (int_type_node
, t
),
887 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
890 = builtin_function ("_Jv_remI",
891 build_function_type (int_type_node
, t
),
892 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
895 = builtin_function ("_Jv_divJ",
896 build_function_type (long_type_node
, t
),
897 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
900 = builtin_function ("_Jv_remJ",
901 build_function_type (long_type_node
, t
),
902 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
904 /* Initialize variables for except.c. */
905 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
906 ? "__gcj_personality_sj0"
907 : "__gcj_personality_v0");
909 lang_eh_runtime_type
= do_nothing
;
913 initialize_builtins ();
914 soft_fmod_node
= built_in_decls
[BUILT_IN_FMOD
];
916 soft_fmodf_node
= built_in_decls
[BUILT_IN_FMODF
];
921 /* Look up NAME in the current binding level and its superiors
922 in the namespace of variables, functions and typedefs.
923 Return a ..._DECL node of some kind representing its definition,
924 or return 0 if it is undefined. */
927 lookup_name (tree name
)
930 if (current_binding_level
!= global_binding_level
931 && IDENTIFIER_LOCAL_VALUE (name
))
932 val
= IDENTIFIER_LOCAL_VALUE (name
);
934 val
= IDENTIFIER_GLOBAL_VALUE (name
);
938 /* Similar to `lookup_name' but look only at current binding level and
939 the previous one if its the parameter level. */
942 lookup_name_current_level (tree name
)
946 if (current_binding_level
== global_binding_level
)
947 return IDENTIFIER_GLOBAL_VALUE (name
);
949 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
952 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
953 if (DECL_NAME (t
) == name
)
959 /* Use a binding level to record a labeled block declaration */
962 push_labeled_block (tree lb
)
964 tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
965 struct binding_level
*b
= current_binding_level
;
966 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
968 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
969 TREE_CHAIN (lb
) = b
->names
;
971 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
974 /* Pop the current binding level, reinstalling values for the previous
978 pop_labeled_block (void)
980 struct binding_level
*b
= current_binding_level
;
981 tree label
= b
->names
;
982 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
985 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
986 TREE_VALUE (b
->shadowed
);
988 /* Pop the current level, and free the structure for reuse. */
989 current_binding_level
= current_binding_level
->level_chain
;
990 b
->level_chain
= free_binding_level
;
991 free_binding_level
= b
;
994 /* Record a decl-node X as belonging to the current lexical scope.
995 Check for errors (such as an incompatible declaration for the same
996 name already seen in the same scope).
998 Returns either X or an old decl for the same name.
999 If an old decl is returned, it may have been smashed
1000 to agree with what X says. */
1006 tree name
= DECL_NAME (x
);
1007 struct binding_level
*b
= current_binding_level
;
1009 if (TREE_CODE (x
) != TYPE_DECL
)
1010 DECL_CONTEXT (x
) = current_function_decl
;
1013 t
= lookup_name_current_level (name
);
1014 if (t
!= 0 && t
== error_mark_node
)
1015 /* error_mark_node is 0 for a while during initialization! */
1018 error ("%J'%D' used prior to declaration", x
, x
);
1021 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1022 to point to the TYPE_DECL.
1023 Since Java does not have typedefs, a type can only have
1024 one (true) name, given by a class, interface, or builtin. */
1025 if (TREE_CODE (x
) == TYPE_DECL
1026 && TYPE_NAME (TREE_TYPE (x
)) == 0
1027 && TREE_TYPE (x
) != error_mark_node
)
1029 TYPE_NAME (TREE_TYPE (x
)) = x
;
1030 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1033 /* This name is new in its binding level.
1034 Install the new declaration and return it. */
1035 if (b
== global_binding_level
)
1037 /* Install a global value. */
1039 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1043 /* Here to install a non-global value. */
1044 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1045 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1048 /* Warn if shadowing an argument at the top level of the body. */
1049 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1050 /* This warning doesn't apply to the parms of a nested fcn. */
1051 && ! current_binding_level
->parm_flag
1052 /* Check that this is one level down from the parms. */
1053 && current_binding_level
->level_chain
->parm_flag
1054 /* Check that the decl being shadowed
1055 comes from the parm level, one level up. */
1056 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1058 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1059 pedwarn ("declaration of `%s' shadows a parameter",
1060 IDENTIFIER_POINTER (name
));
1062 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1063 IDENTIFIER_POINTER (name
));
1066 /* Maybe warn if shadowing something else. */
1067 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1068 /* No shadow warnings for internally generated vars. */
1069 && DECL_SOURCE_LINE (x
) != 0
1070 /* No shadow warnings for vars made for inlining. */
1071 && ! DECL_FROM_INLINE (x
))
1073 const char *warnstring
= 0;
1075 if (TREE_CODE (x
) == PARM_DECL
1076 && current_binding_level
->level_chain
->parm_flag
)
1077 /* Don't warn about the parm names in function declarator
1078 within a function declarator.
1079 It would be nice to avoid warning in any function
1080 declarator in a declaration, as opposed to a definition,
1081 but there is no way to tell it's not a definition. */
1083 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1084 warnstring
= "declaration of `%s' shadows a parameter";
1085 else if (oldlocal
!= 0)
1086 warnstring
= "declaration of `%s' shadows previous local";
1087 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1088 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1089 warnstring
= "declaration of `%s' shadows global declaration";
1092 warning (warnstring
, IDENTIFIER_POINTER (name
));
1096 /* If storing a local value, there may already be one (inherited).
1097 If so, record it for restoration when this binding level ends. */
1099 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1103 /* Put decls on list in reverse order.
1104 We will reverse them later if necessary. */
1105 TREE_CHAIN (x
) = b
->names
;
1112 pushdecl_force_head (tree x
)
1114 current_binding_level
->names
= x
;
1117 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1120 pushdecl_top_level (tree x
)
1123 struct binding_level
*b
= current_binding_level
;
1125 current_binding_level
= global_binding_level
;
1127 current_binding_level
= b
;
1131 /* Nonzero if we are currently in the global binding level. */
1134 global_bindings_p (void)
1136 return current_binding_level
== global_binding_level
;
1139 /* Return the list of declarations of the current level.
1140 Note that this list is in reverse order unless/until
1141 you nreverse it; and when you do nreverse it, you must
1142 store the result back using `storedecls' or you will lose. */
1147 return current_binding_level
->names
;
1150 /* Create a new `struct binding_level'. */
1152 static struct binding_level
*
1153 make_binding_level (void)
1156 return xmalloc (sizeof (struct binding_level
));
1160 pushlevel (int unused ATTRIBUTE_UNUSED
)
1162 struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1165 /* If this is the top level of a function,
1166 just make sure that NAMED_LABELS is 0. */
1168 if (current_binding_level
== global_binding_level
)
1172 /* Reuse or create a struct for this binding level. */
1174 if (free_binding_level
)
1176 newlevel
= free_binding_level
;
1177 free_binding_level
= free_binding_level
->level_chain
;
1181 newlevel
= make_binding_level ();
1184 /* Add this level to the front of the chain (stack) of levels that
1187 *newlevel
= clear_binding_level
;
1188 newlevel
->level_chain
= current_binding_level
;
1189 current_binding_level
= newlevel
;
1190 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1191 newlevel
->binding_depth
= binding_depth
;
1193 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1194 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1197 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1200 /* Exit a binding level.
1201 Pop the level off, and restore the state of the identifier-decl mappings
1202 that were in effect when this level was entered.
1204 If KEEP is nonzero, this level had explicit declarations, so
1205 and create a "block" (a BLOCK node) for the level
1206 to record its declarations and subblocks for symbol table output.
1208 If FUNCTIONBODY is nonzero, this level is the body of a function,
1209 so create a block as if KEEP were set and also clear out all
1212 If REVERSE is nonzero, reverse the order of decls before putting
1213 them into the BLOCK. */
1216 poplevel (int keep
, int reverse
, int functionbody
)
1219 /* The chain of decls was accumulated in reverse order.
1220 Put it into forward order, just for cleanliness. */
1222 tree subblocks
= current_binding_level
->blocks
;
1225 int block_previously_created
;
1228 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1231 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1232 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1233 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1234 current_binding_level
->end_pc
);
1236 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1237 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1239 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1242 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1246 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1248 /* Get the decls in the order they were written.
1249 Usually current_binding_level->names is in reverse order.
1250 But parameter decls were previously put in forward order. */
1253 current_binding_level
->names
1254 = decls
= nreverse (current_binding_level
->names
);
1256 decls
= current_binding_level
->names
;
1258 /* Output any nested inline functions within this block
1259 if they weren't already output. */
1261 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1262 if (TREE_CODE (decl
) == FUNCTION_DECL
1263 && ! TREE_ASM_WRITTEN (decl
)
1264 && DECL_INITIAL (decl
) != 0
1265 && TREE_ADDRESSABLE (decl
))
1267 /* If this decl was copied from a file-scope decl on account
1268 of a block-scope extern decl, propagate TREE_ADDRESSABLE
1269 to the file-scope decl.
1271 DECL_ABSTRACT_ORIGIN can be set to itself if
1272 warn_return_type is true, since then the decl goes
1273 through save_for_inline_copying. */
1274 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1275 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1276 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1279 push_function_context ();
1280 output_inline_function (decl
);
1281 pop_function_context ();
1284 else if (TREE_CODE (decl
) == VAR_DECL
1285 && DECL_LANG_SPECIFIC (decl
) != NULL
1286 && DECL_LOCAL_SLOT_NUMBER (decl
))
1287 LOCAL_VAR_OUT_OF_SCOPE_P (decl
) = 1;
1290 /* If there were any declarations in that level,
1291 or if this level is a function body,
1292 create a BLOCK to record them for the life of this function. */
1295 block_previously_created
= (current_binding_level
->this_block
!= 0);
1296 if (block_previously_created
)
1297 block
= current_binding_level
->this_block
;
1298 else if (keep
|| functionbody
)
1299 block
= make_node (BLOCK
);
1302 BLOCK_VARS (block
) = decls
;
1303 BLOCK_SUBBLOCKS (block
) = subblocks
;
1306 /* In each subblock, record that this is its superior. */
1308 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1309 BLOCK_SUPERCONTEXT (link
) = block
;
1311 /* Clear out the meanings of the local variables of this level. */
1313 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1315 tree name
= DECL_NAME (link
);
1316 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1318 /* If the ident. was used or addressed via a local extern decl,
1319 don't forget that fact. */
1320 if (DECL_EXTERNAL (link
))
1322 if (TREE_USED (link
))
1323 TREE_USED (name
) = 1;
1324 if (TREE_ADDRESSABLE (link
))
1325 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1327 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1331 /* Restore all name-meanings of the outer levels
1332 that were shadowed by this level. */
1334 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1335 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1337 /* If the level being exited is the top level of a function,
1338 check over all the labels, and clear out the current
1339 (function local) meanings of their names. */
1343 /* If this is the top level block of a function,
1344 the vars are the function's parameters.
1345 Don't leave them in the BLOCK because they are
1346 found in the FUNCTION_DECL instead. */
1348 BLOCK_VARS (block
) = 0;
1350 /* Clear out the definitions of all label names,
1351 since their scopes end here,
1352 and add them to BLOCK_VARS. */
1355 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1357 tree label
= TREE_VALUE (link
);
1359 if (DECL_INITIAL (label
) == 0)
1361 error ("%Jlabel '%D' used but not defined", label
, label
);
1362 /* Avoid crashing later. */
1363 define_label (input_location
, DECL_NAME (label
));
1365 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1366 warning ("%Jlabel '%D' defined but not used", label
, label
);
1367 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1369 /* Put the labels into the "variables" of the
1370 top-level block, so debugger can see them. */
1371 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1372 BLOCK_VARS (block
) = label
;
1377 /* Pop the current level, and free the structure for reuse. */
1380 struct binding_level
*level
= current_binding_level
;
1381 current_binding_level
= current_binding_level
->level_chain
;
1383 level
->level_chain
= free_binding_level
;
1384 free_binding_level
= level
;
1387 /* Dispose of the block that we just made inside some higher level. */
1389 DECL_INITIAL (current_function_decl
) = block
;
1392 if (!block_previously_created
)
1393 current_binding_level
->blocks
1394 = chainon (current_binding_level
->blocks
, block
);
1396 /* If we did not make a block for the level just exited,
1397 any blocks made for inner levels
1398 (since they cannot be recorded as subblocks in that level)
1399 must be carried forward so they will later become subblocks
1400 of something else. */
1402 current_binding_level
->blocks
1403 = chainon (current_binding_level
->blocks
, subblocks
);
1405 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1406 binding contour so that they point to the appropriate construct, i.e.
1407 either to the current FUNCTION_DECL node, or else to the BLOCK node
1408 we just constructed.
1410 Note that for tagged types whose scope is just the formal parameter
1411 list for some function type specification, we can't properly set
1412 their TYPE_CONTEXTs here, because we don't have a pointer to the
1413 appropriate FUNCTION_TYPE node readily available to us. For those
1414 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1415 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1416 node which will represent the "scope" for these "parameter list local"
1421 TREE_USED (block
) = 1;
1426 maybe_pushlevels (int pc
)
1428 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1432 while (pending_local_decls
!= NULL_TREE
&&
1433 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1435 tree
*ptr
= &pending_local_decls
;
1437 int end_pc
= DECL_LOCAL_END_PC (decl
);
1439 while (*ptr
!= NULL_TREE
1440 && DECL_LOCAL_START_PC (*ptr
) <= pc
1441 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1442 ptr
= &TREE_CHAIN (*ptr
);
1443 pending_local_decls
= *ptr
;
1446 /* Force non-nested range to be nested in current range. */
1447 if (end_pc
> current_binding_level
->end_pc
)
1448 end_pc
= current_binding_level
->end_pc
;
1450 maybe_start_try (pc
, end_pc
);
1453 expand_start_bindings (0);
1455 current_binding_level
->end_pc
= end_pc
;
1456 current_binding_level
->start_pc
= pc
;
1457 current_binding_level
->names
= decl
;
1458 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1460 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1464 maybe_start_try (pc
, 0);
1468 maybe_poplevels (int pc
)
1470 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1474 while (current_binding_level
->end_pc
<= pc
)
1476 expand_end_bindings (getdecls (), 1, 0);
1477 maybe_end_try (current_binding_level
->start_pc
, pc
);
1480 maybe_end_try (0, pc
);
1483 /* Terminate any binding which began during the range beginning at
1484 start_pc. This tidies up improperly nested local variable ranges
1485 and exception handlers; a variable declared within an exception
1486 range is forcibly terminated when that exception ends. */
1489 force_poplevels (int start_pc
)
1491 while (current_binding_level
->start_pc
> start_pc
)
1493 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1494 warning ("%JIn %D: overlapped variable and exception ranges at %d",
1495 current_function_decl
, current_function_decl
,
1496 current_binding_level
->start_pc
);
1497 expand_end_bindings (getdecls (), 1, 0);
1502 /* Insert BLOCK at the end of the list of subblocks of the
1503 current binding level. This is used when a BIND_EXPR is expanded,
1504 to handle the BLOCK node inside the BIND_EXPR. */
1507 insert_block (tree block
)
1509 TREE_USED (block
) = 1;
1510 current_binding_level
->blocks
1511 = chainon (current_binding_level
->blocks
, block
);
1514 /* Set the BLOCK node for the innermost scope
1515 (the one we are currently in). */
1518 set_block (tree block
)
1520 current_binding_level
->this_block
= block
;
1521 current_binding_level
->names
= chainon (current_binding_level
->names
,
1522 BLOCK_VARS (block
));
1523 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1524 BLOCK_SUBBLOCKS (block
));
1527 /* integrate_decl_tree calls this function. */
1530 java_dup_lang_specific_decl (tree node
)
1533 struct lang_decl
*x
;
1535 if (!DECL_LANG_SPECIFIC (node
))
1538 lang_decl_size
= sizeof (struct lang_decl
);
1539 x
= ggc_alloc (lang_decl_size
);
1540 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1541 DECL_LANG_SPECIFIC (node
) = x
;
1545 give_name_to_locals (JCF
*jcf
)
1547 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1548 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1550 pending_local_decls
= NULL_TREE
;
1554 n
= JCF_readu2 (jcf
);
1555 for (i
= 0; i
< n
; i
++)
1557 int start_pc
= JCF_readu2 (jcf
);
1558 int length
= JCF_readu2 (jcf
);
1559 int name_index
= JCF_readu2 (jcf
);
1560 int signature_index
= JCF_readu2 (jcf
);
1561 int slot
= JCF_readu2 (jcf
);
1562 tree name
= get_name_constant (jcf
, name_index
);
1563 tree type
= parse_signature (jcf
, signature_index
);
1564 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1566 && length
== DECL_CODE_LENGTH (current_function_decl
))
1568 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1569 DECL_NAME (decl
) = name
;
1570 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1571 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1572 warning ("bad type in parameter debug info");
1577 int end_pc
= start_pc
+ length
;
1578 tree decl
= build_decl (VAR_DECL
, name
, type
);
1579 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1581 warning ("%Jbad PC range for debug info for local '%D'",
1583 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1586 /* Adjust start_pc if necessary so that the local's first
1587 store operation will use the relevant DECL as a
1588 destination. Fore more information, read the leading
1589 comments for expr.c:maybe_adjust_start_pc. */
1590 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1592 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1593 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1594 DECL_LOCAL_START_PC (decl
) = start_pc
;
1596 /* FIXME: The range used internally for exceptions and local
1597 variable ranges, is a half-open interval:
1598 start_pc <= pc < end_pc. However, the range used in the
1599 Java VM spec is inclusive at both ends:
1600 start_pc <= pc <= end_pc. */
1603 DECL_LOCAL_END_PC (decl
) = end_pc
;
1605 /* Now insert the new decl in the proper place in
1606 pending_local_decls. We are essentially doing an insertion sort,
1607 which works fine, since the list input will normally already
1609 ptr
= &pending_local_decls
;
1610 while (*ptr
!= NULL_TREE
1611 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1612 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1613 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1614 ptr
= &TREE_CHAIN (*ptr
);
1615 TREE_CHAIN (decl
) = *ptr
;
1620 pending_local_decls
= nreverse (pending_local_decls
);
1622 /* Fill in default names for the parameters. */
1623 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1624 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1626 if (DECL_NAME (parm
) == NULL_TREE
)
1628 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1630 DECL_NAME (parm
) = get_identifier ("this");
1634 sprintf (buffer
, "ARG_%d", arg_i
);
1635 DECL_NAME (parm
) = get_identifier (buffer
);
1637 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1643 build_result_decl (tree fndecl
)
1645 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1646 tree result
= DECL_RESULT (fndecl
);
1649 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1650 if (INTEGRAL_TYPE_P (restype
)
1651 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1652 restype
= integer_type_node
;
1653 result
= build_decl (RESULT_DECL
, NULL_TREE
, restype
);
1654 DECL_CONTEXT (result
) = fndecl
;
1655 DECL_RESULT (fndecl
) = result
;
1661 complete_start_java_method (tree fndecl
)
1663 if (! flag_emit_class_files
)
1665 /* Initialize the RTL code for the function. */
1666 init_function_start (fndecl
);
1668 /* Set up parameters and prepare for return, for the function. */
1669 expand_function_start (fndecl
, 0);
1673 /* If this fcn was already referenced via a block-scope `extern' decl (or
1674 an implicit decl), propagate certain information about the usage. */
1675 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1676 TREE_ADDRESSABLE (current_function_decl
) = 1;
1680 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1681 && ! flag_emit_class_files
1682 && ! DECL_CLINIT_P (fndecl
)
1683 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1685 tree clas
= DECL_CONTEXT (fndecl
);
1686 tree init
= build (CALL_EXPR
, void_type_node
,
1687 build_address_of (soft_initclass_node
),
1688 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1690 TREE_SIDE_EFFECTS (init
) = 1;
1691 expand_expr_stmt (init
);
1694 /* Push local variables. Function compiled from source code are
1695 using a different local variables management, and for them,
1696 pushlevel shouldn't be called from here. */
1697 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1700 if (! flag_emit_class_files
)
1701 expand_start_bindings (1);
1704 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1706 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1707 tree enter
, exit
, lock
;
1708 if (METHOD_STATIC (fndecl
))
1709 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1711 lock
= DECL_ARGUMENTS (fndecl
);
1712 BUILD_MONITOR_ENTER (enter
, lock
);
1713 BUILD_MONITOR_EXIT (exit
, lock
);
1714 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1716 expand_expr_stmt (enter
);
1717 expand_decl_cleanup (NULL_TREE
, exit
);
1721 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1722 tree body
= BLOCK_EXPR_BODY (function_body
);
1723 lock
= build (COMPOUND_EXPR
, void_type_node
,
1725 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1726 TREE_SIDE_EFFECTS (lock
) = 1;
1727 BLOCK_EXPR_BODY (function_body
) = lock
;
1733 start_java_method (tree fndecl
)
1738 current_function_decl
= fndecl
;
1739 announce_function (fndecl
);
1741 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1742 decl_map
= make_tree_vec (i
);
1743 type_map
= xrealloc (type_map
, i
* sizeof (tree
));
1745 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1746 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1748 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1749 pushlevel (1); /* Push parameters. */
1751 ptr
= &DECL_ARGUMENTS (fndecl
);
1752 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1753 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1755 tree parm_name
= NULL_TREE
, parm_decl
;
1756 tree parm_type
= TREE_VALUE (tem
);
1757 if (i
>= DECL_MAX_LOCALS (fndecl
))
1760 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1761 DECL_CONTEXT (parm_decl
) = fndecl
;
1762 if (PROMOTE_PROTOTYPES
1763 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1764 && INTEGRAL_TYPE_P (parm_type
))
1765 parm_type
= integer_type_node
;
1766 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1769 ptr
= &TREE_CHAIN (parm_decl
);
1771 /* Add parm_decl to the decl_map. */
1772 push_jvm_slot (i
, parm_decl
);
1774 type_map
[i
] = TREE_TYPE (parm_decl
);
1775 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1778 type_map
[i
] = void_type_node
;
1782 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1784 while (i
< DECL_MAX_LOCALS(fndecl
))
1785 type_map
[i
++] = NULL_TREE
;
1787 build_result_decl (fndecl
);
1788 complete_start_java_method (fndecl
);
1792 end_java_method (void)
1794 tree fndecl
= current_function_decl
;
1796 expand_end_bindings (getdecls (), 1, 0);
1797 /* pop out of function */
1800 /* pop out of its parameters */
1803 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1805 /* Generate rtl for function exit. */
1806 expand_function_end ();
1808 /* Run the optimizers and output assembler code for this function. */
1809 rest_of_compilation (fndecl
);
1811 current_function_decl
= NULL_TREE
;
1814 /* Expand a function's body. */
1817 java_expand_body (tree fndecl
)
1819 location_t saved_location
= input_location
;
1821 current_function_decl
= fndecl
;
1822 input_location
= DECL_SOURCE_LOCATION (fndecl
);
1823 output_class
= DECL_CONTEXT (current_function_decl
);
1824 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"