1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
35 #include "java-tree.h"
41 #include "java-except.h"
44 #if defined (DEBUG_JAVA_BINDING_LEVELS)
45 extern void indent
PROTO((void));
48 static tree push_jvm_slot
PARAMS ((int, tree
));
49 static tree lookup_name_current_level
PARAMS ((tree
));
50 static tree push_promoted_type
PARAMS ((const char *, tree
));
51 static struct binding_level
*make_binding_level
PARAMS ((void));
52 static tree create_primitive_vtable
PARAMS ((const char *));
53 static tree check_local_named_variable
PARAMS ((tree
, tree
, int, int *));
54 static tree check_local_unnamed_variable
PARAMS ((tree
, tree
, tree
));
56 /* Set to non-zero value in order to emit class initilization code
57 before static field references. */
58 extern int always_initialize_class_p
;
60 /* The DECL_MAP is a mapping from (index, type) to a decl node.
61 If index < max_locals, it is the index of a local variable.
62 if index >= max_locals, then index-max_locals is a stack slot.
63 The DECL_MAP mapping is represented as a TREE_VEC whose elements
64 are a list of decls (VAR_DECL or PARM_DECL) chained by
65 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
66 we search the chain for a decl with a matching TREE_TYPE. */
70 /* A list of local variables VAR_DECLs for this method that we have seen
71 debug information, but we have not reached their starting (byte) PC yet. */
73 static tree pending_local_decls
= NULL_TREE
;
75 /* Push a local variable or stack slot into the decl_map,
76 and assign it an rtl. */
78 #if defined(DEBUG_JAVA_BINDING_LEVELS)
79 int binding_depth
= 0;
80 int is_class_level
= 0;
88 for (i
= 0; i
< binding_depth
*2; i
++)
91 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
94 push_jvm_slot (index
, decl
)
98 struct rtx_def
*rtl
= NULL
;
99 tree type
= TREE_TYPE (decl
);
102 DECL_CONTEXT (decl
) = current_function_decl
;
103 layout_decl (decl
, 0);
105 /* See if we have an appropriate rtl (i.e. same mode) at this index.
106 If so, we must use it. */
107 tmp
= TREE_VEC_ELT (decl_map
, index
);
108 while (tmp
!= NULL_TREE
)
110 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
111 rtl
= DECL_RTL_IF_SET (tmp
);
114 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
117 SET_DECL_RTL (decl
, rtl
);
120 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
121 DECL_REGISTER (decl
) = 1;
125 /* Now link the decl into the decl_map. */
126 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
128 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
129 DECL_LOCAL_START_PC (decl
) = 0;
130 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
131 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
133 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
134 TREE_VEC_ELT (decl_map
, index
) = decl
;
138 /* Find out if 'decl' passed in fits the defined PC location better than
139 'best'. Return decl if it does, return best if it doesn't. If decl
140 is returned, then updated is set to true. */
143 check_local_named_variable (best
, decl
, pc
, updated
)
149 if (pc
>= DECL_LOCAL_START_PC (decl
)
150 && pc
< DECL_LOCAL_END_PC (decl
))
152 if (best
== NULL_TREE
153 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
154 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
164 /* Find the best declaration based upon type. If 'decl' fits 'type' better
165 than 'best', return 'decl'. Otherwise return 'best'. */
168 check_local_unnamed_variable (best
, decl
, type
)
173 if (TREE_TYPE (decl
) == type
174 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
175 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
176 && TYPE_PRECISION (type
) <= 32
177 && TREE_CODE (type
) != POINTER_TYPE
)
178 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
179 && type
== ptr_type_node
))
181 if (best
== NULL_TREE
182 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
190 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
191 that is valid at PC (or -1 if any pc).
192 If there is no existing matching decl, allocate one. */
195 find_local_variable (index
, type
, pc
)
200 tree decl
= TREE_VEC_ELT (decl_map
, index
);
201 tree best
= NULL_TREE
;
202 int found_scoped_var
= 0;
204 /* Scan through every declaration that has been created in this slot. */
205 while (decl
!= NULL_TREE
)
207 /* Variables created in give_name_to_locals() have a name and have
208 a specified scope, so we can handle them specifically. We want
209 to use the specific decls created for those so they are assigned
210 the right variables in the debugging information. */
211 if (DECL_NAME (decl
) != NULL_TREE
)
213 /* This is a variable we have a name for, so it has a scope
214 supplied in the class file. But it only matters when we
215 actually have a PC to use. If pc<0, then we are asking
216 for a stack slot and this decl won't be one of those. */
218 best
= check_local_named_variable (best
, decl
, pc
,
221 /* We scan for type information unless we found a variable in the
222 proper scope already. */
223 else if (!found_scoped_var
)
225 /* If we don't have scoping information for a variable, we use
226 a different method to look it up. */
227 best
= check_local_unnamed_variable (best
, decl
, type
);
230 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
233 if (best
!= NULL_TREE
)
236 /* If we don't find a match, create one with the type passed in. */
237 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
241 /* Same as find_local_index, except that INDEX is a stack index. */
244 find_stack_slot (index
, type
)
248 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
254 /* A chain of _DECL nodes for all variables, constants, functions,
255 * and typedef types. These are in the reverse of the order supplied.
259 /* For each level, a list of shadowed outer-level local definitions
260 to be restored when this level is popped.
261 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
262 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
265 /* For each level (except not the global one),
266 a chain of BLOCK nodes for all the levels
267 that were entered and exited one level down. */
270 /* The BLOCK node for this level, if one has been preallocated.
271 If 0, the BLOCK is allocated (if needed) when the level is popped. */
274 /* The binding level which this one is contained in (inherits from). */
275 struct binding_level
*level_chain
;
277 /* The bytecode PC that marks the end of this level. */
279 /* The bytecode PC that marks the start of this level. */
282 #if defined(DEBUG_JAVA_BINDING_LEVELS)
283 /* Binding depth at which this level began. */
284 unsigned binding_depth
;
285 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
288 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
290 /* The binding level currently in effect. */
292 static struct binding_level
*current_binding_level
;
294 /* A chain of binding_level structures awaiting reuse. */
296 static struct binding_level
*free_binding_level
;
298 /* The outermost binding level, for names of file scope.
299 This is created when the compiler is started and exists
300 through the entire run. */
302 static struct binding_level
*global_binding_level
;
304 /* A PC value bigger than any PC value we may ever may encounter. */
306 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
308 /* Binding level structures are initialized by copying this one. */
310 static struct binding_level clear_binding_level
311 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
312 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
315 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
316 that have names. Here so we can clear out their names' definitions
317 at the end of the function. */
319 static tree named_labels
;
321 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
323 static tree shadowed_labels
;
326 int flag_traditional
;
328 tree java_global_trees
[JTI_MAX
];
330 /* Build (and pushdecl) a "promoted type" for all standard
331 types shorter than int. */
334 push_promoted_type (name
, actual_type
)
338 tree type
= make_node (TREE_CODE (actual_type
));
340 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
341 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
343 tree in_min
= TYPE_MIN_VALUE (actual_type
);
344 tree in_max
= TYPE_MAX_VALUE (actual_type
);
346 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
347 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
348 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
349 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
350 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
352 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
356 /* Return a definition for a builtin function named NAME and whose data type
357 is TYPE. TYPE should be a function type with argument types.
358 FUNCTION_CODE tells later passes how to compile calls to this function.
359 See tree.h for its possible values.
361 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
362 the name to be called if we can't opencode the function. */
365 builtin_function (name
, type
, function_code
, class, library_name
)
369 enum built_in_class
class;
370 const char *library_name
;
372 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
373 DECL_EXTERNAL (decl
) = 1;
374 TREE_PUBLIC (decl
) = 1;
376 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
377 make_decl_rtl (decl
, NULL
);
379 DECL_BUILT_IN_CLASS (decl
) = class;
380 DECL_FUNCTION_CODE (decl
) = function_code
;
384 /* Return tree that represents a vtable for a primitive array. */
386 create_primitive_vtable (name
)
392 sprintf (buf
, "_Jv_%sVTable", name
);
393 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
394 DECL_EXTERNAL (r
) = 1;
399 java_init_decl_processing ()
401 register tree endlink
;
402 tree field
= NULL_TREE
;
405 init_class_processing ();
407 current_function_decl
= NULL
;
408 current_binding_level
= NULL_BINDING_LEVEL
;
409 free_binding_level
= NULL_BINDING_LEVEL
;
410 pushlevel (0); /* make the binding_level structure for global names */
411 global_binding_level
= current_binding_level
;
413 /* The code here must be similar to build_common_tree_nodes{,_2} in
414 tree.c, especially as to the order of initializing common nodes. */
415 error_mark_node
= make_node (ERROR_MARK
);
416 TREE_TYPE (error_mark_node
) = error_mark_node
;
418 /* Create sizetype first - needed for other types. */
419 initialize_sizetypes ();
421 byte_type_node
= make_signed_type (8);
422 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
423 short_type_node
= make_signed_type (16);
424 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
425 int_type_node
= make_signed_type (32);
426 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
427 long_type_node
= make_signed_type (64);
428 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
430 unsigned_byte_type_node
= make_unsigned_type (8);
431 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
432 unsigned_byte_type_node
));
433 unsigned_short_type_node
= make_unsigned_type (16);
434 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
435 unsigned_short_type_node
));
436 unsigned_int_type_node
= make_unsigned_type (32);
437 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
438 unsigned_int_type_node
));
439 unsigned_long_type_node
= make_unsigned_type (64);
440 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
441 unsigned_long_type_node
));
443 set_sizetype (make_unsigned_type (POINTER_SIZE
));
445 /* Define these next since types below may used them. */
446 integer_type_node
= type_for_size (INT_TYPE_SIZE
, 0);
447 integer_zero_node
= build_int_2 (0, 0);
448 integer_one_node
= build_int_2 (1, 0);
449 integer_two_node
= build_int_2 (2, 0);
450 integer_four_node
= build_int_2 (4, 0);
451 integer_minus_one_node
= build_int_2 (-1, -1);
453 size_zero_node
= size_int (0);
454 size_one_node
= size_int (1);
455 bitsize_zero_node
= bitsize_int (0);
456 bitsize_one_node
= bitsize_int (1);
457 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
459 long_zero_node
= build_int_2 (0, 0);
460 TREE_TYPE (long_zero_node
) = long_type_node
;
462 void_type_node
= make_node (VOID_TYPE
);
463 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
464 layout_type (void_type_node
); /* Uses size_zero_node */
465 ptr_type_node
= build_pointer_type (void_type_node
);
466 t
= make_node (VOID_TYPE
);
467 layout_type (t
); /* Uses size_zero_node */
468 return_address_type_node
= build_pointer_type (t
);
470 null_pointer_node
= build_int_2 (0, 0);
471 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
473 /* Used by the parser to represent empty statements and blocks. */
474 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
475 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
478 /* Make a type to be the domain of a few array types
479 whose domains don't really matter.
480 200 is small enough that it always fits in size_t
481 and large enough that it can hold most function names for the
482 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
483 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
485 char_type_node
= make_node (CHAR_TYPE
);
486 TYPE_PRECISION (char_type_node
) = 16;
487 fixup_unsigned_type (char_type_node
);
488 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
490 boolean_type_node
= make_node (BOOLEAN_TYPE
);
491 TYPE_PRECISION (boolean_type_node
) = 1;
492 fixup_unsigned_type (boolean_type_node
);
493 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
495 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
496 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
498 promoted_byte_type_node
499 = push_promoted_type ("promoted_byte", byte_type_node
);
500 promoted_short_type_node
501 = push_promoted_type ("promoted_short", short_type_node
);
502 promoted_char_type_node
503 = push_promoted_type ("promoted_char", char_type_node
);
504 promoted_boolean_type_node
505 = push_promoted_type ("promoted_boolean", boolean_type_node
);
507 float_type_node
= make_node (REAL_TYPE
);
508 TYPE_PRECISION (float_type_node
) = 32;
509 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
511 layout_type (float_type_node
);
513 double_type_node
= make_node (REAL_TYPE
);
514 TYPE_PRECISION (double_type_node
) = 64;
515 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
517 layout_type (double_type_node
);
519 float_zero_node
= build_real (float_type_node
, dconst0
);
520 double_zero_node
= build_real (double_type_node
, dconst0
);
522 /* These are the vtables for arrays of primitives. */
523 boolean_array_vtable
= create_primitive_vtable ("boolean");
524 byte_array_vtable
= create_primitive_vtable ("byte");
525 char_array_vtable
= create_primitive_vtable ("char");
526 short_array_vtable
= create_primitive_vtable ("short");
527 int_array_vtable
= create_primitive_vtable ("int");
528 long_array_vtable
= create_primitive_vtable ("long");
529 float_array_vtable
= create_primitive_vtable ("float");
530 double_array_vtable
= create_primitive_vtable ("double");
532 /* As you're adding items here, please update the code right after
533 this section, so that the filename containing the source code of
534 the pre-defined class gets registered correctly. */
535 unqualified_object_id_node
= get_identifier ("Object");
536 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
537 object_ptr_type_node
= promote_type (object_type_node
);
538 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
539 string_ptr_type_node
= promote_type (string_type_node
);
540 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
541 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
542 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
543 runtime_exception_type_node
=
544 lookup_class (get_identifier ("java.lang.RuntimeException"));
545 error_exception_type_node
=
546 lookup_class (get_identifier ("java.lang.Error"));
547 class_not_found_type_node
=
548 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
549 no_class_def_found_type_node
=
550 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
552 rawdata_ptr_type_node
553 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
555 add_predefined_file (get_identifier ("java/lang/Class.java"));
556 add_predefined_file (get_identifier ("java/lang/Error.java"));
557 add_predefined_file (get_identifier ("java/lang/Object.java"));
558 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
559 add_predefined_file (get_identifier ("java/lang/String.java"));
560 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
561 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
562 add_predefined_file (get_identifier ("java/lang/Exception.java"));
563 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
564 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
565 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
567 methodtable_type
= make_node (RECORD_TYPE
);
568 layout_type (methodtable_type
);
569 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
570 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
572 TYPE_identifier_node
= get_identifier ("TYPE");
573 init_identifier_node
= get_identifier ("<init>");
574 clinit_identifier_node
= get_identifier ("<clinit>");
575 finit_identifier_node
= get_identifier ("finit$");
576 instinit_identifier_node
= get_identifier ("instinit$");
577 void_signature_node
= get_identifier ("()V");
578 length_identifier_node
= get_identifier ("length");
579 finalize_identifier_node
= get_identifier ("finalize");
580 this_identifier_node
= get_identifier ("this");
581 super_identifier_node
= get_identifier ("super");
582 continue_identifier_node
= get_identifier ("continue");
583 access0_identifier_node
= get_identifier ("access$0");
584 classdollar_identifier_node
= get_identifier ("class$");
586 /* for lack of a better place to put this stub call */
587 init_expr_processing();
589 utf8const_type
= make_node (RECORD_TYPE
);
590 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
591 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
592 FINISH_RECORD (utf8const_type
);
593 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
595 constants_type_node
= make_node (RECORD_TYPE
);
596 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
597 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
598 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
599 FINISH_RECORD (constants_type_node
);
600 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
602 access_flags_type_node
= unsigned_short_type_node
;
604 dtable_type
= make_node (RECORD_TYPE
);
605 dtable_ptr_type
= build_pointer_type (dtable_type
);
607 one_elt_array_domain_type
= build_index_type (integer_one_node
);
608 otable_type
= build_array_type (integer_type_node
,
609 one_elt_array_domain_type
);
610 otable_ptr_type
= build_pointer_type (otable_type
);
612 method_symbol_type
= make_node (RECORD_TYPE
);
613 PUSH_FIELD (method_symbol_type
, field
, "clname", utf8const_ptr_type
);
614 PUSH_FIELD (method_symbol_type
, field
, "name", utf8const_ptr_type
);
615 PUSH_FIELD (method_symbol_type
, field
, "signature", utf8const_ptr_type
);
616 FINISH_RECORD (method_symbol_type
);
618 method_symbols_array_type
= build_array_type (method_symbol_type
,
619 one_elt_array_domain_type
);
620 method_symbols_array_ptr_type
= build_pointer_type
621 (method_symbols_array_type
);
623 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"), otable_type
);
624 DECL_EXTERNAL (otable_decl
) = 1;
625 TREE_STATIC (otable_decl
) = 1;
626 TREE_READONLY (otable_decl
) = 1;
627 pushdecl (otable_decl
);
629 otable_syms_decl
= build_decl (VAR_DECL
, get_identifier ("otable_syms"),
630 method_symbols_array_type
);
631 TREE_STATIC (otable_syms_decl
) = 1;
632 TREE_CONSTANT (otable_syms_decl
) = 1;
633 pushdecl (otable_syms_decl
);
635 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
636 /* This isn't exactly true, but it is what we have in the source.
637 There is an unresolved issue here, which is whether the vtable
638 should be marked by the GC. */
639 if (! flag_hash_synchronization
)
640 PUSH_FIELD (object_type_node
, field
, "sync_info",
641 build_pointer_type (object_type_node
));
642 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
643 FIELD_PRIVATE (t
) = 1;
644 FINISH_RECORD (object_type_node
);
646 field_type_node
= make_node (RECORD_TYPE
);
647 field_ptr_type_node
= build_pointer_type (field_type_node
);
648 method_type_node
= make_node (RECORD_TYPE
);
649 method_ptr_type_node
= build_pointer_type (method_type_node
);
651 set_super_info (0, class_type_node
, object_type_node
, 0);
652 set_super_info (0, string_type_node
, object_type_node
, 0);
653 class_ptr_type
= build_pointer_type (class_type_node
);
655 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
656 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
657 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
658 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
659 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
660 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
661 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
662 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
663 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
664 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
665 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
666 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
667 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
668 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
669 PUSH_FIELD (class_type_node
, field
, "otable_syms",
670 method_symbols_array_ptr_type
);
671 PUSH_FIELD (class_type_node
, field
, "interfaces",
672 build_pointer_type (class_ptr_type
));
673 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
674 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
675 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
676 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
677 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
678 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
679 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
680 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
681 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
682 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
683 FIELD_PRIVATE (t
) = 1;
684 push_super_field (class_type_node
, object_type_node
);
686 FINISH_RECORD (class_type_node
);
687 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
689 field_info_union_node
= make_node (UNION_TYPE
);
690 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
691 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
693 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
695 layout_type (field_info_union_node
);
697 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
698 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
699 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
700 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
701 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
702 FINISH_RECORD (field_type_node
);
703 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
705 nativecode_ptr_array_type_node
706 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
708 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
709 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
710 FINISH_RECORD (dtable_type
);
711 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
713 #define jint_type int_type_node
714 #define jint_ptr_type ptr_type_node
716 jexception_type
= make_node (RECORD_TYPE
);
717 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
718 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
719 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
720 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
721 FINISH_RECORD (jexception_type
);
722 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
723 jexception_ptr_type
= build_pointer_type (jexception_type
);
725 lineNumberEntry_type
= make_node (RECORD_TYPE
);
726 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
727 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
728 FINISH_RECORD (lineNumberEntry_type
);
730 lineNumbers_type
= make_node (RECORD_TYPE
);
731 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
732 FINISH_RECORD (lineNumbers_type
);
734 #define instn_ptr_type_node ptr_type_node /* XXX JH */
736 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
738 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
739 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
740 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
741 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
742 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
743 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
744 FINISH_RECORD (method_type_node
);
745 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
747 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
749 t
= tree_cons (NULL_TREE
, class_ptr_type
,
750 tree_cons (NULL_TREE
, int_type_node
, endlink
));
751 alloc_object_node
= builtin_function ("_Jv_AllocObject",
752 build_function_type (ptr_type_node
, t
),
753 0, NOT_BUILT_IN
, NULL
);
754 DECL_IS_MALLOC (alloc_object_node
) = 1;
755 alloc_no_finalizer_node
=
756 builtin_function ("_Jv_AllocObjectNoFinalizer",
757 build_function_type (ptr_type_node
, t
),
758 0, NOT_BUILT_IN
, NULL
);
759 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
761 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
762 soft_initclass_node
= builtin_function ("_Jv_InitClass",
763 build_function_type (void_type_node
,
765 0, NOT_BUILT_IN
, NULL
);
767 throw_node
= builtin_function ("_Jv_Throw",
768 build_function_type (ptr_type_node
, t
),
769 0, NOT_BUILT_IN
, NULL
);
770 /* Mark throw_nodes as `noreturn' functions with side effects. */
771 TREE_THIS_VOLATILE (throw_node
) = 1;
772 TREE_SIDE_EFFECTS (throw_node
) = 1;
774 t
= build_function_type (int_type_node
, endlink
);
775 soft_monitorenter_node
776 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
, NULL
);
777 soft_monitorexit_node
778 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
, NULL
);
780 t
= tree_cons (NULL_TREE
, int_type_node
,
781 tree_cons (NULL_TREE
, int_type_node
, endlink
));
783 = builtin_function ("_Jv_NewPrimArray",
784 build_function_type(ptr_type_node
, t
),
785 0, NOT_BUILT_IN
, NULL
);
786 DECL_IS_MALLOC (soft_newarray_node
) = 1;
788 t
= tree_cons (NULL_TREE
, int_type_node
,
789 tree_cons (NULL_TREE
, class_ptr_type
,
790 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
792 = builtin_function ("_Jv_NewObjectArray",
793 build_function_type (ptr_type_node
, t
),
794 0, NOT_BUILT_IN
, NULL
);
795 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
797 t
= tree_cons (NULL_TREE
, ptr_type_node
,
798 tree_cons (NULL_TREE
, int_type_node
, endlink
));
799 soft_multianewarray_node
800 = builtin_function ("_Jv_NewMultiArray",
801 build_function_type (ptr_type_node
, t
),
802 0, NOT_BUILT_IN
, NULL
);
803 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
805 t
= build_function_type (void_type_node
,
806 tree_cons (NULL_TREE
, int_type_node
, endlink
));
807 soft_badarrayindex_node
808 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
809 0, NOT_BUILT_IN
, NULL
);
810 /* Mark soft_badarrayindex_node as a `noreturn' function with side
812 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
813 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
815 soft_nullpointer_node
816 = builtin_function ("_Jv_ThrowNullPointerException",
817 build_function_type (void_type_node
, endlink
),
818 0, NOT_BUILT_IN
, NULL
);
819 /* Mark soft_nullpointer_node as a `noreturn' function with side
821 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
822 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
824 t
= tree_cons (NULL_TREE
, class_ptr_type
,
825 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
827 = builtin_function ("_Jv_CheckCast",
828 build_function_type (ptr_type_node
, t
),
829 0, NOT_BUILT_IN
, NULL
);
830 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
831 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
833 = builtin_function ("_Jv_IsInstanceOf",
834 build_function_type (boolean_type_node
, t
),
835 0, NOT_BUILT_IN
, NULL
);
836 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
837 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
838 soft_checkarraystore_node
839 = builtin_function ("_Jv_CheckArrayStore",
840 build_function_type (void_type_node
, t
),
841 0, NOT_BUILT_IN
, NULL
);
842 t
= tree_cons (NULL_TREE
, ptr_type_node
,
843 tree_cons (NULL_TREE
, ptr_type_node
,
844 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
845 soft_lookupinterfacemethod_node
846 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
847 build_function_type (ptr_type_node
, t
),
848 0, NOT_BUILT_IN
, NULL
);
850 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
851 tree_cons (NULL_TREE
, ptr_type_node
,
852 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
853 soft_lookupjnimethod_node
854 = builtin_function ("_Jv_LookupJNIMethod",
855 build_function_type (ptr_type_node
, t
),
856 0, NOT_BUILT_IN
, NULL
);
857 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
858 soft_getjnienvnewframe_node
859 = builtin_function ("_Jv_GetJNIEnvNewFrame",
860 build_function_type (ptr_type_node
, t
),
861 0, NOT_BUILT_IN
, NULL
);
862 soft_jnipopsystemframe_node
863 = builtin_function ("_Jv_JNI_PopSystemFrame",
864 build_function_type (ptr_type_node
, t
),
865 0, NOT_BUILT_IN
, NULL
);
867 t
= tree_cons (NULL_TREE
, double_type_node
,
868 tree_cons (NULL_TREE
, double_type_node
, endlink
));
870 = builtin_function ("__builtin_fmod",
871 build_function_type (double_type_node
, t
),
872 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmod");
875 t
= tree_cons (NULL_TREE
, float_type_node
,
876 tree_cons (NULL_TREE
, float_type_node
, endlink
));
878 = builtin_function ("__builtin_fmodf",
879 build_function_type (float_type_node
, t
),
880 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf");
884 = builtin_function ("_Jv_divI",
885 build_function_type (int_type_node
, t
),
886 0, NOT_BUILT_IN
, NULL
);
889 = builtin_function ("_Jv_remI",
890 build_function_type (int_type_node
, t
),
891 0, NOT_BUILT_IN
, NULL
);
894 = builtin_function ("_Jv_divJ",
895 build_function_type (long_type_node
, t
),
896 0, NOT_BUILT_IN
, NULL
);
899 = builtin_function ("_Jv_remJ",
900 build_function_type (long_type_node
, t
),
901 0, NOT_BUILT_IN
, NULL
);
903 /* Initialize variables for except.c. */
904 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
905 ? "__gcj_personality_sj0"
906 : "__gcj_personality_v0");
907 lang_eh_runtime_type
= prepare_eh_table_type
;
911 /* Register nodes with the garbage collector. */
912 ggc_add_tree_root (java_global_trees
,
913 sizeof (java_global_trees
) / sizeof (tree
));
914 ggc_add_tree_root (&decl_map
, 1);
915 ggc_add_tree_root (&pending_local_decls
, 1);
917 initialize_builtins ();
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. */
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 (name
)
948 if (current_binding_level
== global_binding_level
)
949 return IDENTIFIER_GLOBAL_VALUE (name
);
951 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
954 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
955 if (DECL_NAME (t
) == name
)
961 /* Use a binding level to record a labeled block declaration */
964 push_labeled_block (lb
)
967 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
968 register struct binding_level
*b
= current_binding_level
;
969 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
971 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
972 TREE_CHAIN (lb
) = b
->names
;
974 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
977 /* Pop the current binding level, reinstalling values for the previous
983 struct binding_level
*b
= current_binding_level
;
984 tree label
= b
->names
;
985 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
988 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
989 TREE_VALUE (b
->shadowed
);
991 /* Pop the current level, and free the structure for reuse. */
992 current_binding_level
= current_binding_level
->level_chain
;
993 b
->level_chain
= free_binding_level
;
994 free_binding_level
= b
;
997 /* Record a decl-node X as belonging to the current lexical scope.
998 Check for errors (such as an incompatible declaration for the same
999 name already seen in the same scope).
1001 Returns either X or an old decl for the same name.
1002 If an old decl is returned, it may have been smashed
1003 to agree with what X says. */
1010 register tree name
= DECL_NAME (x
);
1011 register struct binding_level
*b
= current_binding_level
;
1013 if (TREE_CODE (x
) != TYPE_DECL
)
1014 DECL_CONTEXT (x
) = current_function_decl
;
1020 t
= lookup_name_current_level (name
);
1021 if (t
!= 0 && t
== error_mark_node
)
1022 /* error_mark_node is 0 for a while during initialization! */
1025 error_with_decl (x
, "`%s' used prior to declaration");
1030 file
= DECL_SOURCE_FILE (t
);
1031 line
= DECL_SOURCE_LINE (t
);
1034 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1035 to point to the TYPE_DECL.
1036 Since Java does not have typedefs, a type can only have
1037 one (true) name, given by a class, interface, or builtin. */
1038 if (TREE_CODE (x
) == TYPE_DECL
1039 && TYPE_NAME (TREE_TYPE (x
)) == 0
1040 && TREE_TYPE (x
) != error_mark_node
)
1042 TYPE_NAME (TREE_TYPE (x
)) = x
;
1043 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1046 /* This name is new in its binding level.
1047 Install the new declaration and return it. */
1048 if (b
== global_binding_level
)
1050 /* Install a global value. */
1052 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1056 /* Here to install a non-global value. */
1057 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1058 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1061 /* Warn if shadowing an argument at the top level of the body. */
1062 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1063 /* This warning doesn't apply to the parms of a nested fcn. */
1064 && ! current_binding_level
->parm_flag
1065 /* Check that this is one level down from the parms. */
1066 && current_binding_level
->level_chain
->parm_flag
1067 /* Check that the decl being shadowed
1068 comes from the parm level, one level up. */
1069 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1071 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1072 pedwarn ("declaration of `%s' shadows a parameter",
1073 IDENTIFIER_POINTER (name
));
1075 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1076 IDENTIFIER_POINTER (name
));
1079 /* Maybe warn if shadowing something else. */
1080 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1081 /* No shadow warnings for internally generated vars. */
1082 && DECL_SOURCE_LINE (x
) != 0
1083 /* No shadow warnings for vars made for inlining. */
1084 && ! DECL_FROM_INLINE (x
))
1086 const char *warnstring
= 0;
1088 if (TREE_CODE (x
) == PARM_DECL
1089 && current_binding_level
->level_chain
->parm_flag
)
1090 /* Don't warn about the parm names in function declarator
1091 within a function declarator.
1092 It would be nice to avoid warning in any function
1093 declarator in a declaration, as opposed to a definition,
1094 but there is no way to tell it's not a definition. */
1096 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1097 warnstring
= "declaration of `%s' shadows a parameter";
1098 else if (oldlocal
!= 0)
1099 warnstring
= "declaration of `%s' shadows previous local";
1100 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1101 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1102 warnstring
= "declaration of `%s' shadows global declaration";
1105 warning (warnstring
, IDENTIFIER_POINTER (name
));
1109 /* If storing a local value, there may already be one (inherited).
1110 If so, record it for restoration when this binding level ends. */
1112 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1116 /* Put decls on list in reverse order.
1117 We will reverse them later if necessary. */
1118 TREE_CHAIN (x
) = b
->names
;
1125 pushdecl_force_head (x
)
1128 current_binding_level
->names
= x
;
1131 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1134 pushdecl_top_level (x
)
1138 register struct binding_level
*b
= current_binding_level
;
1140 current_binding_level
= global_binding_level
;
1142 current_binding_level
= b
;
1146 /* Nonzero if we are currently in the global binding level. */
1149 global_bindings_p ()
1151 return current_binding_level
== global_binding_level
;
1154 /* Return the list of declarations of the current level.
1155 Note that this list is in reverse order unless/until
1156 you nreverse it; and when you do nreverse it, you must
1157 store the result back using `storedecls' or you will lose. */
1162 return current_binding_level
->names
;
1165 /* Create a new `struct binding_level'. */
1167 static struct binding_level
*
1168 make_binding_level ()
1171 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
1176 int unused ATTRIBUTE_UNUSED
;
1178 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1181 /* If this is the top level of a function,
1182 just make sure that NAMED_LABELS is 0. */
1184 if (current_binding_level
== global_binding_level
)
1188 /* Reuse or create a struct for this binding level. */
1190 if (free_binding_level
)
1192 newlevel
= free_binding_level
;
1193 free_binding_level
= free_binding_level
->level_chain
;
1197 newlevel
= make_binding_level ();
1200 /* Add this level to the front of the chain (stack) of levels that
1203 *newlevel
= clear_binding_level
;
1204 newlevel
->level_chain
= current_binding_level
;
1205 current_binding_level
= newlevel
;
1206 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1207 newlevel
->binding_depth
= binding_depth
;
1209 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1210 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1213 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1216 /* Exit a binding level.
1217 Pop the level off, and restore the state of the identifier-decl mappings
1218 that were in effect when this level was entered.
1220 If KEEP is nonzero, this level had explicit declarations, so
1221 and create a "block" (a BLOCK node) for the level
1222 to record its declarations and subblocks for symbol table output.
1224 If FUNCTIONBODY is nonzero, this level is the body of a function,
1225 so create a block as if KEEP were set and also clear out all
1228 If REVERSE is nonzero, reverse the order of decls before putting
1229 them into the BLOCK. */
1232 poplevel (keep
, reverse
, functionbody
)
1238 /* The chain of decls was accumulated in reverse order.
1239 Put it into forward order, just for cleanliness. */
1241 tree subblocks
= current_binding_level
->blocks
;
1244 int block_previously_created
;
1246 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1249 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1250 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1251 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1252 current_binding_level
->end_pc
);
1254 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1255 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1257 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1260 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1264 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1266 /* Get the decls in the order they were written.
1267 Usually current_binding_level->names is in reverse order.
1268 But parameter decls were previously put in forward order. */
1271 current_binding_level
->names
1272 = decls
= nreverse (current_binding_level
->names
);
1274 decls
= current_binding_level
->names
;
1276 /* Output any nested inline functions within this block
1277 if they weren't already output. */
1279 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1280 if (TREE_CODE (decl
) == FUNCTION_DECL
1281 && ! TREE_ASM_WRITTEN (decl
)
1282 && DECL_INITIAL (decl
) != 0
1283 && TREE_ADDRESSABLE (decl
))
1285 /* If this decl was copied from a file-scope decl
1286 on account of a block-scope extern decl,
1287 propagate TREE_ADDRESSABLE to the file-scope decl.
1289 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1290 true, since then the decl goes through save_for_inline_copying. */
1291 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1292 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1293 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1296 push_function_context ();
1297 output_inline_function (decl
);
1298 pop_function_context ();
1302 /* If there were any declarations in that level,
1303 or if this level is a function body,
1304 create a BLOCK to record them for the life of this function. */
1307 block_previously_created
= (current_binding_level
->this_block
!= 0);
1308 if (block_previously_created
)
1309 block
= current_binding_level
->this_block
;
1310 else if (keep
|| functionbody
)
1311 block
= make_node (BLOCK
);
1314 BLOCK_VARS (block
) = decls
;
1315 BLOCK_SUBBLOCKS (block
) = subblocks
;
1318 /* In each subblock, record that this is its superior. */
1320 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1321 BLOCK_SUPERCONTEXT (link
) = block
;
1323 /* Clear out the meanings of the local variables of this level. */
1325 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1327 tree name
= DECL_NAME (link
);
1328 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1330 /* If the ident. was used or addressed via a local extern decl,
1331 don't forget that fact. */
1332 if (DECL_EXTERNAL (link
))
1334 if (TREE_USED (link
))
1335 TREE_USED (name
) = 1;
1336 if (TREE_ADDRESSABLE (link
))
1337 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1339 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1343 /* Restore all name-meanings of the outer levels
1344 that were shadowed by this level. */
1346 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1347 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1349 /* If the level being exited is the top level of a function,
1350 check over all the labels, and clear out the current
1351 (function local) meanings of their names. */
1355 /* If this is the top level block of a function,
1356 the vars are the function's parameters.
1357 Don't leave them in the BLOCK because they are
1358 found in the FUNCTION_DECL instead. */
1360 BLOCK_VARS (block
) = 0;
1362 /* Clear out the definitions of all label names,
1363 since their scopes end here,
1364 and add them to BLOCK_VARS. */
1367 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1369 register tree label
= TREE_VALUE (link
);
1371 if (DECL_INITIAL (label
) == 0)
1373 error_with_decl (label
, "label `%s' used but not defined");
1374 /* Avoid crashing later. */
1375 define_label (input_filename
, lineno
,
1378 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1379 warning_with_decl (label
, "label `%s' defined but not used");
1380 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1382 /* Put the labels into the "variables" of the
1383 top-level block, so debugger can see them. */
1384 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1385 BLOCK_VARS (block
) = label
;
1390 /* Pop the current level, and free the structure for reuse. */
1393 register struct binding_level
*level
= current_binding_level
;
1394 current_binding_level
= current_binding_level
->level_chain
;
1396 level
->level_chain
= free_binding_level
;
1397 free_binding_level
= level
;
1400 /* Dispose of the block that we just made inside some higher level. */
1402 DECL_INITIAL (current_function_decl
) = block
;
1405 if (!block_previously_created
)
1406 current_binding_level
->blocks
1407 = chainon (current_binding_level
->blocks
, block
);
1409 /* If we did not make a block for the level just exited,
1410 any blocks made for inner levels
1411 (since they cannot be recorded as subblocks in that level)
1412 must be carried forward so they will later become subblocks
1413 of something else. */
1415 current_binding_level
->blocks
1416 = chainon (current_binding_level
->blocks
, subblocks
);
1418 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1419 binding contour so that they point to the appropriate construct, i.e.
1420 either to the current FUNCTION_DECL node, or else to the BLOCK node
1421 we just constructed.
1423 Note that for tagged types whose scope is just the formal parameter
1424 list for some function type specification, we can't properly set
1425 their TYPE_CONTEXTs here, because we don't have a pointer to the
1426 appropriate FUNCTION_TYPE node readily available to us. For those
1427 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1428 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1429 node which will represent the "scope" for these "parameter list local"
1434 TREE_USED (block
) = 1;
1439 maybe_pushlevels (pc
)
1442 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1446 while (pending_local_decls
!= NULL_TREE
&&
1447 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1449 tree
*ptr
= &pending_local_decls
;
1451 int end_pc
= DECL_LOCAL_END_PC (decl
);
1453 while (*ptr
!= NULL_TREE
1454 && DECL_LOCAL_START_PC (*ptr
) <= pc
1455 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1456 ptr
= &TREE_CHAIN (*ptr
);
1457 pending_local_decls
= *ptr
;
1460 /* Force non-nested range to be nested in current range. */
1461 if (end_pc
> current_binding_level
->end_pc
)
1462 end_pc
= current_binding_level
->end_pc
;
1464 maybe_start_try (pc
, end_pc
);
1467 expand_start_bindings (0);
1469 current_binding_level
->end_pc
= end_pc
;
1470 current_binding_level
->start_pc
= pc
;
1471 current_binding_level
->names
= decl
;
1472 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1474 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1478 maybe_start_try (pc
, 0);
1482 maybe_poplevels (pc
)
1485 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1489 while (current_binding_level
->end_pc
<= pc
)
1491 expand_end_bindings (getdecls (), 1, 0);
1492 maybe_end_try (current_binding_level
->start_pc
, pc
);
1495 maybe_end_try (0, pc
);
1498 /* Terminate any binding which began during the range beginning at
1499 start_pc. This tidies up improperly nested local variable ranges
1500 and exception handlers; a variable declared within an exception
1501 range is forcibly terminated when that exception ends. */
1504 force_poplevels (start_pc
)
1507 while (current_binding_level
->start_pc
> start_pc
)
1509 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1510 warning_with_decl (current_function_decl
,
1511 "In %s: overlapped variable and exception ranges at %d",
1512 current_binding_level
->start_pc
);
1513 expand_end_bindings (getdecls (), 1, 0);
1518 /* Insert BLOCK at the end of the list of subblocks of the
1519 current binding level. This is used when a BIND_EXPR is expanded,
1520 to handle the BLOCK node inside the BIND_EXPR. */
1523 insert_block (block
)
1526 TREE_USED (block
) = 1;
1527 current_binding_level
->blocks
1528 = chainon (current_binding_level
->blocks
, block
);
1531 /* Set the BLOCK node for the innermost scope
1532 (the one we are currently in). */
1536 register tree block
;
1538 current_binding_level
->this_block
= block
;
1539 current_binding_level
->names
= chainon (current_binding_level
->names
,
1540 BLOCK_VARS (block
));
1541 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1542 BLOCK_SUBBLOCKS (block
));
1545 /* integrate_decl_tree calls this function. */
1548 copy_lang_decl (node
)
1552 = TREE_CODE (node
) == VAR_DECL
? sizeof (struct lang_decl_var
)
1553 : sizeof (struct lang_decl
);
1554 struct lang_decl
*x
= (struct lang_decl
*) ggc_alloc (lang_decl_size
);
1555 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1556 DECL_LANG_SPECIFIC (node
) = x
;
1559 /* If DECL has a cleanup, build and return that cleanup here.
1560 This is a callback called by expand_expr. */
1563 maybe_build_cleanup (decl
)
1564 tree decl ATTRIBUTE_UNUSED
;
1566 /* There are no cleanups in Java (I think). */
1571 give_name_to_locals (jcf
)
1574 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1575 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1577 pending_local_decls
= NULL_TREE
;
1581 n
= JCF_readu2 (jcf
);
1582 for (i
= 0; i
< n
; i
++)
1584 int start_pc
= JCF_readu2 (jcf
);
1585 int length
= JCF_readu2 (jcf
);
1586 int name_index
= JCF_readu2 (jcf
);
1587 int signature_index
= JCF_readu2 (jcf
);
1588 int slot
= JCF_readu2 (jcf
);
1589 tree name
= get_name_constant (jcf
, name_index
);
1590 tree type
= parse_signature (jcf
, signature_index
);
1591 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1593 && length
== DECL_CODE_LENGTH (current_function_decl
))
1595 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1596 DECL_NAME (decl
) = name
;
1597 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1598 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1599 warning ("bad type in parameter debug info");
1604 int end_pc
= start_pc
+ length
;
1605 tree decl
= build_decl (VAR_DECL
, name
, type
);
1606 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1608 warning_with_decl (decl
,
1609 "bad PC range for debug info for local `%s'");
1610 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1613 /* Adjust start_pc if necessary so that the local's first
1614 store operation will use the relevant DECL as a
1615 destination. Fore more information, read the leading
1616 comments for expr.c:maybe_adjust_start_pc. */
1617 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1619 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1620 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1621 DECL_LOCAL_START_PC (decl
) = start_pc
;
1623 /* FIXME: The range used internally for exceptions and local
1624 variable ranges, is a half-open interval:
1625 start_pc <= pc < end_pc. However, the range used in the
1626 Java VM spec is inclusive at both ends:
1627 start_pc <= pc <= end_pc. */
1630 DECL_LOCAL_END_PC (decl
) = end_pc
;
1632 /* Now insert the new decl in the proper place in
1633 pending_local_decls. We are essentially doing an insertion sort,
1634 which works fine, since the list input will normally already
1636 ptr
= &pending_local_decls
;
1637 while (*ptr
!= NULL_TREE
1638 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1639 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1640 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1641 ptr
= &TREE_CHAIN (*ptr
);
1642 TREE_CHAIN (decl
) = *ptr
;
1647 pending_local_decls
= nreverse (pending_local_decls
);
1649 /* Fill in default names for the parameters. */
1650 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1651 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1653 if (DECL_NAME (parm
) == NULL_TREE
)
1655 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1657 DECL_NAME (parm
) = get_identifier ("this");
1661 sprintf (buffer
, "ARG_%d", arg_i
);
1662 DECL_NAME (parm
) = get_identifier (buffer
);
1664 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1670 build_result_decl (fndecl
)
1673 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1674 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1675 if (INTEGRAL_TYPE_P (restype
)
1676 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1677 restype
= integer_type_node
;
1678 return (DECL_RESULT (fndecl
) = build_decl (RESULT_DECL
, NULL_TREE
, restype
));
1682 complete_start_java_method (fndecl
)
1685 if (! flag_emit_class_files
)
1687 /* Initialize the RTL code for the function. */
1688 init_function_start (fndecl
, input_filename
, lineno
);
1690 /* Set up parameters and prepare for return, for the function. */
1691 expand_function_start (fndecl
, 0);
1695 /* If this fcn was already referenced via a block-scope `extern' decl (or
1696 an implicit decl), propagate certain information about the usage. */
1697 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1698 TREE_ADDRESSABLE (current_function_decl
) = 1;
1702 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1703 && ! flag_emit_class_files
1704 && ! DECL_CLINIT_P (fndecl
)
1705 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1707 tree clas
= DECL_CONTEXT (fndecl
);
1708 tree init
= build (CALL_EXPR
, void_type_node
,
1709 build_address_of (soft_initclass_node
),
1710 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1712 TREE_SIDE_EFFECTS (init
) = 1;
1713 expand_expr_stmt (init
);
1716 /* Push local variables. Function compiled from source code are
1717 using a different local variables management, and for them,
1718 pushlevel shouldn't be called from here. */
1719 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1722 if (! flag_emit_class_files
)
1723 expand_start_bindings (1);
1726 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1728 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1729 tree enter
, exit
, lock
;
1730 if (METHOD_STATIC (fndecl
))
1731 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1733 lock
= DECL_ARGUMENTS (fndecl
);
1734 BUILD_MONITOR_ENTER (enter
, lock
);
1735 BUILD_MONITOR_EXIT (exit
, lock
);
1736 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1738 expand_expr_stmt (enter
);
1739 expand_decl_cleanup (NULL_TREE
, exit
);
1743 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1744 tree body
= BLOCK_EXPR_BODY (function_body
);
1745 lock
= build (COMPOUND_EXPR
, void_type_node
,
1747 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1748 TREE_SIDE_EFFECTS (lock
) = 1;
1749 BLOCK_EXPR_BODY (function_body
) = lock
;
1755 start_java_method (fndecl
)
1761 current_function_decl
= fndecl
;
1762 announce_function (fndecl
);
1764 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1765 decl_map
= make_tree_vec (i
);
1766 type_map
= (tree
*) xrealloc (type_map
, i
* sizeof (tree
));
1768 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1769 fprintf (stderr
, "%s:\n", (*decl_printable_name
) (fndecl
, 2));
1771 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1772 pushlevel (1); /* Push parameters. */
1774 ptr
= &DECL_ARGUMENTS (fndecl
);
1775 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1776 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1778 tree parm_name
= NULL_TREE
, parm_decl
;
1779 tree parm_type
= TREE_VALUE (tem
);
1780 if (i
>= DECL_MAX_LOCALS (fndecl
))
1783 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1784 DECL_CONTEXT (parm_decl
) = fndecl
;
1785 if (PROMOTE_PROTOTYPES
1786 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1787 && INTEGRAL_TYPE_P (parm_type
))
1788 parm_type
= integer_type_node
;
1789 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1792 ptr
= &TREE_CHAIN (parm_decl
);
1794 /* Add parm_decl to the decl_map. */
1795 push_jvm_slot (i
, parm_decl
);
1797 type_map
[i
] = TREE_TYPE (parm_decl
);
1798 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1801 type_map
[i
] = void_type_node
;
1805 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1807 while (i
< DECL_MAX_LOCALS(fndecl
))
1808 type_map
[i
++] = NULL_TREE
;
1810 build_result_decl (fndecl
);
1811 complete_start_java_method (fndecl
);
1817 tree fndecl
= current_function_decl
;
1819 expand_end_bindings (getdecls (), 1, 0);
1820 /* pop out of function */
1823 /* pop out of its parameters */
1826 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1828 /* Generate rtl for function exit. */
1829 expand_function_end (input_filename
, lineno
, 0);
1831 /* Run the optimizers and output assembler code for this function. */
1832 rest_of_compilation (fndecl
);
1834 current_function_decl
= NULL_TREE
;
1837 /* Mark language-specific parts of T for garbage-collection. */
1843 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1845 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
1846 ggc_mark_tree (li
->global_value
);
1847 ggc_mark_tree (li
->local_value
);
1848 ggc_mark_tree (li
->utf8_ref
);
1850 else if (TREE_CODE (t
) == VAR_DECL
1851 || TREE_CODE (t
) == PARM_DECL
1852 || TREE_CODE (t
) == FIELD_DECL
)
1854 struct lang_decl_var
*ldv
=
1855 ((struct lang_decl_var
*) DECL_LANG_SPECIFIC (t
));
1859 ggc_mark_tree (ldv
->slot_chain
);
1860 ggc_mark_tree (ldv
->am
);
1861 ggc_mark_tree (ldv
->wfl
);
1864 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1866 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
1871 ggc_mark_tree (ld
->wfl
);
1872 ggc_mark_tree (ld
->throws_list
);
1873 ggc_mark_tree (ld
->function_decl_body
);
1874 ggc_mark_tree (ld
->called_constructor
);
1875 ggc_mark_tree (ld
->inner_access
);
1876 ggc_mark_tree_hash_table (&ld
->init_test_table
);
1877 ggc_mark_tree_hash_table (&ld
->ict
);
1878 ggc_mark_tree (ld
->smic
);
1881 else if (TYPE_P (t
))
1883 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
1888 ggc_mark_tree (lt
->signature
);
1889 ggc_mark_tree (lt
->cpool_data_ref
);
1890 ggc_mark_tree (lt
->finit_stmt_list
);
1891 ggc_mark_tree (lt
->clinit_stmt_list
);
1892 ggc_mark_tree (lt
->ii_block
);
1893 ggc_mark_tree (lt
->dot_class
);
1894 ggc_mark_tree (lt
->package_list
);