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 bool emit_init_test_initialization
PARAMS ((struct hash_entry
*,
54 static tree create_primitive_vtable
PARAMS ((const char *));
55 static tree check_local_named_variable
PARAMS ((tree
, tree
, int, int *));
56 static tree check_local_unnamed_variable
PARAMS ((tree
, tree
, tree
));
58 /* Set to non-zero value in order to emit class initilization code
59 before static field references. */
60 extern int always_initialize_class_p
;
62 /* The DECL_MAP is a mapping from (index, type) to a decl node.
63 If index < max_locals, it is the index of a local variable.
64 if index >= max_locals, then index-max_locals is a stack slot.
65 The DECL_MAP mapping is represented as a TREE_VEC whose elements
66 are a list of decls (VAR_DECL or PARM_DECL) chained by
67 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
68 we search the chain for a decl with a matching TREE_TYPE. */
72 /* A list of local variables VAR_DECLs for this method that we have seen
73 debug information, but we have not reached their starting (byte) PC yet. */
75 static tree pending_local_decls
= NULL_TREE
;
77 /* Push a local variable or stack slot into the decl_map,
78 and assign it an rtl. */
80 #if defined(DEBUG_JAVA_BINDING_LEVELS)
81 int binding_depth
= 0;
82 int is_class_level
= 0;
90 for (i
= 0; i
< binding_depth
*2; i
++)
93 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
96 push_jvm_slot (index
, decl
)
100 struct rtx_def
*rtl
= NULL
;
101 tree type
= TREE_TYPE (decl
);
104 DECL_CONTEXT (decl
) = current_function_decl
;
105 layout_decl (decl
, 0);
107 /* See if we have an appropriate rtl (i.e. same mode) at this index.
108 If so, we must use it. */
109 tmp
= TREE_VEC_ELT (decl_map
, index
);
110 while (tmp
!= NULL_TREE
)
112 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
113 rtl
= DECL_RTL_IF_SET (tmp
);
116 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
119 SET_DECL_RTL (decl
, rtl
);
122 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
123 DECL_REGISTER (decl
) = 1;
127 /* Now link the decl into the decl_map. */
128 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
130 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
131 DECL_LOCAL_START_PC (decl
) = 0;
132 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
133 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
135 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
136 TREE_VEC_ELT (decl_map
, index
) = decl
;
140 /* Find out if 'decl' passed in fits the defined PC location better than
141 'best'. Return decl if it does, return best if it doesn't. If decl
142 is returned, then updated is set to true. */
145 check_local_named_variable (best
, decl
, pc
, updated
)
151 if (pc
>= DECL_LOCAL_START_PC (decl
)
152 && pc
< DECL_LOCAL_END_PC (decl
))
154 if (best
== NULL_TREE
155 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
156 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
166 /* Find the best declaration based upon type. If 'decl' fits 'type' better
167 than 'best', return 'decl'. Otherwise return 'best'. */
170 check_local_unnamed_variable (best
, decl
, type
)
175 if (TREE_TYPE (decl
) == type
176 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
177 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
178 && TYPE_PRECISION (type
) <= 32
179 && TREE_CODE (type
) != POINTER_TYPE
)
180 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
181 && type
== ptr_type_node
))
183 if (best
== NULL_TREE
184 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
192 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
193 that is valid at PC (or -1 if any pc).
194 If there is no existing matching decl, allocate one. */
197 find_local_variable (index
, type
, pc
)
202 tree decl
= TREE_VEC_ELT (decl_map
, index
);
203 tree best
= NULL_TREE
;
204 int found_scoped_var
= 0;
206 /* Scan through every declaration that has been created in this slot. */
207 while (decl
!= NULL_TREE
)
209 /* Variables created in give_name_to_locals() have a name and have
210 a specified scope, so we can handle them specifically. We want
211 to use the specific decls created for those so they are assigned
212 the right variables in the debugging information. */
213 if (DECL_NAME (decl
) != NULL_TREE
)
215 /* This is a variable we have a name for, so it has a scope
216 supplied in the class file. But it only matters when we
217 actually have a PC to use. If pc<0, then we are asking
218 for a stack slot and this decl won't be one of those. */
220 best
= check_local_named_variable (best
, decl
, pc
,
223 /* We scan for type information unless we found a variable in the
224 proper scope already. */
225 else if (!found_scoped_var
)
227 /* If we don't have scoping information for a variable, we use
228 a different method to look it up. */
229 best
= check_local_unnamed_variable (best
, decl
, type
);
232 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
235 if (best
!= NULL_TREE
)
238 /* If we don't find a match, create one with the type passed in. */
239 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
243 /* Same as find_local_index, except that INDEX is a stack index. */
246 find_stack_slot (index
, type
)
250 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
256 /* A chain of _DECL nodes for all variables, constants, functions,
257 * and typedef types. These are in the reverse of the order supplied.
261 /* For each level, a list of shadowed outer-level local definitions
262 to be restored when this level is popped.
263 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
264 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
267 /* For each level (except not the global one),
268 a chain of BLOCK nodes for all the levels
269 that were entered and exited one level down. */
272 /* The BLOCK node for this level, if one has been preallocated.
273 If 0, the BLOCK is allocated (if needed) when the level is popped. */
276 /* The binding level which this one is contained in (inherits from). */
277 struct binding_level
*level_chain
;
279 /* The bytecode PC that marks the end of this level. */
281 /* The bytecode PC that marks the start of this level. */
284 #if defined(DEBUG_JAVA_BINDING_LEVELS)
285 /* Binding depth at which this level began. */
286 unsigned binding_depth
;
287 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
290 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
292 /* The binding level currently in effect. */
294 static struct binding_level
*current_binding_level
;
296 /* A chain of binding_level structures awaiting reuse. */
298 static struct binding_level
*free_binding_level
;
300 /* The outermost binding level, for names of file scope.
301 This is created when the compiler is started and exists
302 through the entire run. */
304 static struct binding_level
*global_binding_level
;
306 /* A PC value bigger than any PC value we may ever may encounter. */
308 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
310 /* Binding level structures are initialized by copying this one. */
312 static struct binding_level clear_binding_level
313 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
314 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
317 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
318 that have names. Here so we can clear out their names' definitions
319 at the end of the function. */
321 static tree named_labels
;
323 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
325 static tree shadowed_labels
;
328 int flag_traditional
;
330 tree java_global_trees
[JTI_MAX
];
332 tree predef_filenames
[PREDEF_FILENAMES_SIZE
];
334 /* Build (and pushdecl) a "promoted type" for all standard
335 types shorter than int. */
338 push_promoted_type (name
, actual_type
)
342 tree type
= make_node (TREE_CODE (actual_type
));
344 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
345 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
347 tree in_min
= TYPE_MIN_VALUE (actual_type
);
348 tree in_max
= TYPE_MAX_VALUE (actual_type
);
350 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
351 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
352 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
353 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
354 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
356 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
360 /* Return a definition for a builtin function named NAME and whose data type
361 is TYPE. TYPE should be a function type with argument types.
362 FUNCTION_CODE tells later passes how to compile calls to this function.
363 See tree.h for its possible values.
365 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
366 the name to be called if we can't opencode the function. */
369 builtin_function (name
, type
, function_code
, class, library_name
)
373 enum built_in_class
class;
374 const char *library_name
;
376 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
377 DECL_EXTERNAL (decl
) = 1;
378 TREE_PUBLIC (decl
) = 1;
380 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
381 make_decl_rtl (decl
, NULL
);
383 DECL_BUILT_IN_CLASS (decl
) = class;
384 DECL_FUNCTION_CODE (decl
) = function_code
;
388 /* Return tree that represents a vtable for a primitive array. */
390 create_primitive_vtable (name
)
396 sprintf (buf
, "_Jv_%sVTable", name
);
397 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
398 DECL_EXTERNAL (r
) = 1;
403 init_decl_processing ()
405 register tree endlink
;
406 tree field
= NULL_TREE
;
409 init_class_processing ();
411 current_function_decl
= NULL
;
412 current_binding_level
= NULL_BINDING_LEVEL
;
413 free_binding_level
= NULL_BINDING_LEVEL
;
414 pushlevel (0); /* make the binding_level structure for global names */
415 global_binding_level
= current_binding_level
;
417 /* The code here must be similar to build_common_tree_nodes{,_2} in
418 tree.c, especially as to the order of initializing common nodes. */
419 error_mark_node
= make_node (ERROR_MARK
);
420 TREE_TYPE (error_mark_node
) = error_mark_node
;
422 /* Create sizetype first - needed for other types. */
423 initialize_sizetypes ();
425 byte_type_node
= make_signed_type (8);
426 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
427 short_type_node
= make_signed_type (16);
428 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
429 int_type_node
= make_signed_type (32);
430 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
431 long_type_node
= make_signed_type (64);
432 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
434 unsigned_byte_type_node
= make_unsigned_type (8);
435 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
436 unsigned_byte_type_node
));
437 unsigned_short_type_node
= make_unsigned_type (16);
438 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
439 unsigned_short_type_node
));
440 unsigned_int_type_node
= make_unsigned_type (32);
441 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
442 unsigned_int_type_node
));
443 unsigned_long_type_node
= make_unsigned_type (64);
444 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
445 unsigned_long_type_node
));
447 set_sizetype (make_unsigned_type (POINTER_SIZE
));
449 /* Define these next since types below may used them. */
450 integer_type_node
= type_for_size (INT_TYPE_SIZE
, 0);
451 integer_zero_node
= build_int_2 (0, 0);
452 integer_one_node
= build_int_2 (1, 0);
453 integer_two_node
= build_int_2 (2, 0);
454 integer_four_node
= build_int_2 (4, 0);
455 integer_minus_one_node
= build_int_2 (-1, -1);
457 size_zero_node
= size_int (0);
458 size_one_node
= size_int (1);
459 bitsize_zero_node
= bitsize_int (0);
460 bitsize_one_node
= bitsize_int (1);
461 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
463 long_zero_node
= build_int_2 (0, 0);
464 TREE_TYPE (long_zero_node
) = long_type_node
;
466 void_type_node
= make_node (VOID_TYPE
);
467 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
468 layout_type (void_type_node
); /* Uses size_zero_node */
469 ptr_type_node
= build_pointer_type (void_type_node
);
470 t
= make_node (VOID_TYPE
);
471 layout_type (t
); /* Uses size_zero_node */
472 return_address_type_node
= build_pointer_type (t
);
474 null_pointer_node
= build_int_2 (0, 0);
475 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
477 /* Used by the parser to represent empty statements and blocks. */
478 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
479 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
482 /* Make a type to be the domain of a few array types
483 whose domains don't really matter.
484 200 is small enough that it always fits in size_t
485 and large enough that it can hold most function names for the
486 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
487 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
489 char_type_node
= make_node (CHAR_TYPE
);
490 TYPE_PRECISION (char_type_node
) = 16;
491 fixup_unsigned_type (char_type_node
);
492 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
494 boolean_type_node
= make_node (BOOLEAN_TYPE
);
495 TYPE_PRECISION (boolean_type_node
) = 1;
496 fixup_unsigned_type (boolean_type_node
);
497 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
499 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
500 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
502 promoted_byte_type_node
503 = push_promoted_type ("promoted_byte", byte_type_node
);
504 promoted_short_type_node
505 = push_promoted_type ("promoted_short", short_type_node
);
506 promoted_char_type_node
507 = push_promoted_type ("promoted_char", char_type_node
);
508 promoted_boolean_type_node
509 = push_promoted_type ("promoted_boolean", boolean_type_node
);
511 float_type_node
= make_node (REAL_TYPE
);
512 TYPE_PRECISION (float_type_node
) = 32;
513 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
515 layout_type (float_type_node
);
517 double_type_node
= make_node (REAL_TYPE
);
518 TYPE_PRECISION (double_type_node
) = 64;
519 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
521 layout_type (double_type_node
);
523 float_zero_node
= build_real (float_type_node
, dconst0
);
524 double_zero_node
= build_real (double_type_node
, dconst0
);
526 /* These are the vtables for arrays of primitives. */
527 boolean_array_vtable
= create_primitive_vtable ("boolean");
528 byte_array_vtable
= create_primitive_vtable ("byte");
529 char_array_vtable
= create_primitive_vtable ("char");
530 short_array_vtable
= create_primitive_vtable ("short");
531 int_array_vtable
= create_primitive_vtable ("int");
532 long_array_vtable
= create_primitive_vtable ("long");
533 float_array_vtable
= create_primitive_vtable ("float");
534 double_array_vtable
= create_primitive_vtable ("double");
536 /* As you're adding items here, please update the code right after
537 this section, so that the filename containing the source code of
538 the pre-defined class gets registered correctly. */
539 unqualified_object_id_node
= get_identifier ("Object");
540 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
541 object_ptr_type_node
= promote_type (object_type_node
);
542 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
543 string_ptr_type_node
= promote_type (string_type_node
);
544 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
545 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
546 runtime_exception_type_node
=
547 lookup_class (get_identifier ("java.lang.RuntimeException"));
548 error_exception_type_node
=
549 lookup_class (get_identifier ("java.lang.Error"));
550 rawdata_ptr_type_node
551 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
553 /* If you add to this section, don't forget to increase
554 PREDEF_FILENAMES_SIZE. */
555 predef_filenames
[0] = get_identifier ("java/lang/Class.java");
556 predef_filenames
[1] = get_identifier ("java/lang/Error.java");
557 predef_filenames
[2] = get_identifier ("java/lang/Object.java");
558 predef_filenames
[3] = get_identifier ("java/lang/RuntimeException.java");
559 predef_filenames
[4] = get_identifier ("java/lang/String.java");
560 predef_filenames
[5] = get_identifier ("java/lang/Throwable.java");
561 predef_filenames
[6] = get_identifier ("gnu/gcj/RawData.java");
563 methodtable_type
= make_node (RECORD_TYPE
);
564 layout_type (methodtable_type
);
565 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
566 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
568 TYPE_identifier_node
= get_identifier ("TYPE");
569 init_identifier_node
= get_identifier ("<init>");
570 clinit_identifier_node
= get_identifier ("<clinit>");
571 /* Legacy `$finit$' special method identifier. This needs to be
572 recognized as equivalent to `finit$' but isn't generated anymore. */
573 finit_leg_identifier_node
= get_identifier ("$finit$");
574 /* The new `finit$' special method identifier. This one is now
575 generated in place of `$finit$'. */
576 finit_identifier_node
= get_identifier ("finit$");
577 void_signature_node
= get_identifier ("()V");
578 length_identifier_node
= get_identifier ("length");
579 this_identifier_node
= get_identifier ("this");
580 super_identifier_node
= get_identifier ("super");
581 continue_identifier_node
= get_identifier ("continue");
582 access0_identifier_node
= get_identifier ("access$0");
583 classdollar_identifier_node
= get_identifier ("class$");
585 /* for lack of a better place to put this stub call */
586 init_expr_processing();
588 utf8const_type
= make_node (RECORD_TYPE
);
589 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
590 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
591 FINISH_RECORD (utf8const_type
);
592 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
594 constants_type_node
= make_node (RECORD_TYPE
);
595 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
596 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
597 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
598 FINISH_RECORD (constants_type_node
);
599 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
601 access_flags_type_node
= unsigned_short_type_node
;
603 dtable_type
= make_node (RECORD_TYPE
);
604 dtable_ptr_type
= build_pointer_type (dtable_type
);
606 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
607 /* This isn't exactly true, but it is what we have in the source.
608 There is an unresolved issue here, which is whether the vtable
609 should be marked by the GC. */
610 if (! flag_hash_synchronization
)
611 PUSH_FIELD (object_type_node
, field
, "sync_info",
612 build_pointer_type (object_type_node
));
613 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
614 FIELD_PRIVATE (t
) = 1;
615 FINISH_RECORD (object_type_node
);
617 field_type_node
= make_node (RECORD_TYPE
);
618 field_ptr_type_node
= build_pointer_type (field_type_node
);
619 method_type_node
= make_node (RECORD_TYPE
);
620 method_ptr_type_node
= build_pointer_type (method_type_node
);
622 set_super_info (0, class_type_node
, object_type_node
, 0);
623 set_super_info (0, string_type_node
, object_type_node
, 0);
624 class_ptr_type
= build_pointer_type (class_type_node
);
626 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
627 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
628 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
629 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
630 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
631 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
632 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
633 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
634 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
635 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
636 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
637 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
638 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
639 PUSH_FIELD (class_type_node
, field
, "interfaces",
640 build_pointer_type (class_ptr_type
));
641 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
642 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
643 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
644 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
645 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
646 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
647 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
648 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
649 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
650 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
651 FIELD_PRIVATE (t
) = 1;
652 push_super_field (class_type_node
, object_type_node
);
653 FINISH_RECORD (class_type_node
);
654 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
656 field_info_union_node
= make_node (UNION_TYPE
);
657 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
658 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
660 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
662 layout_type (field_info_union_node
);
664 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
665 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
666 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
667 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
668 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
669 FINISH_RECORD (field_type_node
);
670 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
672 one_elt_array_domain_type
= build_index_type (integer_one_node
);
673 nativecode_ptr_array_type_node
674 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
676 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
677 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
678 FINISH_RECORD (dtable_type
);
679 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
681 #define jint_type int_type_node
682 #define jint_ptr_type ptr_type_node
684 jexception_type
= make_node (RECORD_TYPE
);
685 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
686 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
687 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
688 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
689 FINISH_RECORD (jexception_type
);
690 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
691 jexception_ptr_type
= build_pointer_type (jexception_type
);
693 lineNumberEntry_type
= make_node (RECORD_TYPE
);
694 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
695 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
696 FINISH_RECORD (lineNumberEntry_type
);
698 lineNumbers_type
= make_node (RECORD_TYPE
);
699 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
700 FINISH_RECORD (lineNumbers_type
);
702 #define instn_ptr_type_node ptr_type_node /* XXX JH */
704 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
706 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
707 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
708 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
709 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
710 FINISH_RECORD (method_type_node
);
711 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
713 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
715 t
= tree_cons (NULL_TREE
, class_ptr_type
,
716 tree_cons (NULL_TREE
, int_type_node
, endlink
));
717 alloc_object_node
= builtin_function ("_Jv_AllocObject",
718 build_function_type (ptr_type_node
, t
),
719 0, NOT_BUILT_IN
, NULL
);
720 DECL_IS_MALLOC (alloc_object_node
) = 1;
722 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
723 soft_initclass_node
= builtin_function ("_Jv_InitClass",
724 build_function_type (void_type_node
,
726 0, NOT_BUILT_IN
, NULL
);
728 throw_node
= builtin_function ("_Jv_Throw",
729 build_function_type (ptr_type_node
, t
),
730 0, NOT_BUILT_IN
, NULL
);
731 /* Mark throw_nodes as `noreturn' functions with side effects. */
732 TREE_THIS_VOLATILE (throw_node
) = 1;
733 TREE_SIDE_EFFECTS (throw_node
) = 1;
735 t
= build_function_type (int_type_node
, endlink
);
736 soft_monitorenter_node
737 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
, NULL
);
738 soft_monitorexit_node
739 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
, NULL
);
741 t
= tree_cons (NULL_TREE
, int_type_node
,
742 tree_cons (NULL_TREE
, int_type_node
, endlink
));
744 = builtin_function ("_Jv_NewPrimArray",
745 build_function_type(ptr_type_node
, t
),
746 0, NOT_BUILT_IN
, NULL
);
747 DECL_IS_MALLOC (soft_newarray_node
) = 1;
749 t
= tree_cons (NULL_TREE
, int_type_node
,
750 tree_cons (NULL_TREE
, class_ptr_type
,
751 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
753 = builtin_function ("_Jv_NewObjectArray",
754 build_function_type (ptr_type_node
, t
),
755 0, NOT_BUILT_IN
, NULL
);
756 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
758 t
= tree_cons (NULL_TREE
, ptr_type_node
,
759 tree_cons (NULL_TREE
, int_type_node
, endlink
));
760 soft_multianewarray_node
761 = builtin_function ("_Jv_NewMultiArray",
762 build_function_type (ptr_type_node
, t
),
763 0, NOT_BUILT_IN
, NULL
);
764 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
766 t
= build_function_type (void_type_node
,
767 tree_cons (NULL_TREE
, int_type_node
, endlink
));
768 soft_badarrayindex_node
769 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
770 0, NOT_BUILT_IN
, NULL
);
771 /* Mark soft_badarrayindex_node as a `noreturn' function with side
773 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
774 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
776 soft_nullpointer_node
777 = builtin_function ("_Jv_ThrowNullPointerException",
778 build_function_type (void_type_node
, endlink
),
779 0, NOT_BUILT_IN
, NULL
);
780 /* Mark soft_nullpointer_node as a `noreturn' function with side
782 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
783 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
785 t
= tree_cons (NULL_TREE
, class_ptr_type
,
786 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
788 = builtin_function ("_Jv_CheckCast",
789 build_function_type (ptr_type_node
, t
),
790 0, NOT_BUILT_IN
, NULL
);
791 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
792 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
794 = builtin_function ("_Jv_IsInstanceOf",
795 build_function_type (boolean_type_node
, t
),
796 0, NOT_BUILT_IN
, NULL
);
797 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
798 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
799 soft_checkarraystore_node
800 = builtin_function ("_Jv_CheckArrayStore",
801 build_function_type (void_type_node
, t
),
802 0, NOT_BUILT_IN
, NULL
);
803 t
= tree_cons (NULL_TREE
, ptr_type_node
,
804 tree_cons (NULL_TREE
, ptr_type_node
,
805 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
806 soft_lookupinterfacemethod_node
807 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
808 build_function_type (ptr_type_node
, t
),
809 0, NOT_BUILT_IN
, NULL
);
811 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
812 tree_cons (NULL_TREE
, ptr_type_node
,
813 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
814 soft_lookupjnimethod_node
815 = builtin_function ("_Jv_LookupJNIMethod",
816 build_function_type (ptr_type_node
, t
),
817 0, NOT_BUILT_IN
, NULL
);
818 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
819 soft_getjnienvnewframe_node
820 = builtin_function ("_Jv_GetJNIEnvNewFrame",
821 build_function_type (ptr_type_node
, t
),
822 0, NOT_BUILT_IN
, NULL
);
823 soft_jnipopsystemframe_node
824 = builtin_function ("_Jv_JNI_PopSystemFrame",
825 build_function_type (ptr_type_node
, t
),
826 0, NOT_BUILT_IN
, NULL
);
828 t
= tree_cons (NULL_TREE
, double_type_node
,
829 tree_cons (NULL_TREE
, double_type_node
, endlink
));
831 = builtin_function ("__builtin_fmod",
832 build_function_type (double_type_node
, t
),
833 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmod");
836 t
= tree_cons (NULL_TREE
, float_type_node
,
837 tree_cons (NULL_TREE
, float_type_node
, endlink
));
839 = builtin_function ("__builtin_fmodf",
840 build_function_type (float_type_node
, t
),
841 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf");
845 = builtin_function ("_Jv_divI",
846 build_function_type (int_type_node
, t
),
847 0, NOT_BUILT_IN
, NULL
);
850 = builtin_function ("_Jv_remI",
851 build_function_type (int_type_node
, t
),
852 0, NOT_BUILT_IN
, NULL
);
855 = builtin_function ("_Jv_divJ",
856 build_function_type (long_type_node
, t
),
857 0, NOT_BUILT_IN
, NULL
);
860 = builtin_function ("_Jv_remJ",
861 build_function_type (long_type_node
, t
),
862 0, NOT_BUILT_IN
, NULL
);
864 /* Initialize variables for except.c. */
865 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
866 ? "__gcj_personality_sj0"
867 : "__gcj_personality_v0");
868 lang_eh_runtime_type
= prepare_eh_table_type
;
872 /* Register nodes with the garbage collector. */
873 ggc_add_tree_root (java_global_trees
,
874 sizeof (java_global_trees
) / sizeof (tree
));
875 ggc_add_tree_root (predef_filenames
,
876 sizeof (predef_filenames
) / sizeof (tree
));
877 ggc_add_tree_root (&decl_map
, 1);
878 ggc_add_tree_root (&pending_local_decls
, 1);
882 /* Look up NAME in the current binding level and its superiors
883 in the namespace of variables, functions and typedefs.
884 Return a ..._DECL node of some kind representing its definition,
885 or return 0 if it is undefined. */
892 if (current_binding_level
!= global_binding_level
893 && IDENTIFIER_LOCAL_VALUE (name
))
894 val
= IDENTIFIER_LOCAL_VALUE (name
);
896 val
= IDENTIFIER_GLOBAL_VALUE (name
);
900 /* Similar to `lookup_name' but look only at current binding level and
901 the previous one if its the parameter level. */
904 lookup_name_current_level (name
)
909 if (current_binding_level
== global_binding_level
)
910 return IDENTIFIER_GLOBAL_VALUE (name
);
912 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
915 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
916 if (DECL_NAME (t
) == name
)
922 /* Use a binding level to record a labeled block declaration */
925 push_labeled_block (lb
)
928 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
929 register struct binding_level
*b
= current_binding_level
;
930 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
932 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
933 TREE_CHAIN (lb
) = b
->names
;
935 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
938 /* Pop the current binding level, reinstalling values for the previous
944 struct binding_level
*b
= current_binding_level
;
945 tree label
= b
->names
;
946 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
949 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
950 TREE_VALUE (b
->shadowed
);
952 /* Pop the current level, and free the structure for reuse. */
953 current_binding_level
= current_binding_level
->level_chain
;
954 b
->level_chain
= free_binding_level
;
955 free_binding_level
= b
;
958 /* Record a decl-node X as belonging to the current lexical scope.
959 Check for errors (such as an incompatible declaration for the same
960 name already seen in the same scope).
962 Returns either X or an old decl for the same name.
963 If an old decl is returned, it may have been smashed
964 to agree with what X says. */
971 register tree name
= DECL_NAME (x
);
972 register struct binding_level
*b
= current_binding_level
;
974 if (TREE_CODE (x
) != TYPE_DECL
)
975 DECL_CONTEXT (x
) = current_function_decl
;
981 t
= lookup_name_current_level (name
);
982 if (t
!= 0 && t
== error_mark_node
)
983 /* error_mark_node is 0 for a while during initialization! */
986 error_with_decl (x
, "`%s' used prior to declaration");
991 file
= DECL_SOURCE_FILE (t
);
992 line
= DECL_SOURCE_LINE (t
);
995 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
996 to point to the TYPE_DECL.
997 Since Java does not have typedefs, a type can only have
998 one (true) name, given by a class, interface, or builtin. */
999 if (TREE_CODE (x
) == TYPE_DECL
1000 && TYPE_NAME (TREE_TYPE (x
)) == 0
1001 && TREE_TYPE (x
) != error_mark_node
)
1003 TYPE_NAME (TREE_TYPE (x
)) = x
;
1004 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1007 /* This name is new in its binding level.
1008 Install the new declaration and return it. */
1009 if (b
== global_binding_level
)
1011 /* Install a global value. */
1013 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1017 /* Here to install a non-global value. */
1018 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1019 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1022 /* Warn if shadowing an argument at the top level of the body. */
1023 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1024 /* This warning doesn't apply to the parms of a nested fcn. */
1025 && ! current_binding_level
->parm_flag
1026 /* Check that this is one level down from the parms. */
1027 && current_binding_level
->level_chain
->parm_flag
1028 /* Check that the decl being shadowed
1029 comes from the parm level, one level up. */
1030 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1032 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1033 pedwarn ("declaration of `%s' shadows a parameter",
1034 IDENTIFIER_POINTER (name
));
1036 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1037 IDENTIFIER_POINTER (name
));
1040 /* Maybe warn if shadowing something else. */
1041 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1042 /* No shadow warnings for internally generated vars. */
1043 && DECL_SOURCE_LINE (x
) != 0
1044 /* No shadow warnings for vars made for inlining. */
1045 && ! DECL_FROM_INLINE (x
))
1047 const char *warnstring
= 0;
1049 if (TREE_CODE (x
) == PARM_DECL
1050 && current_binding_level
->level_chain
->parm_flag
)
1051 /* Don't warn about the parm names in function declarator
1052 within a function declarator.
1053 It would be nice to avoid warning in any function
1054 declarator in a declaration, as opposed to a definition,
1055 but there is no way to tell it's not a definition. */
1057 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1058 warnstring
= "declaration of `%s' shadows a parameter";
1059 else if (oldlocal
!= 0)
1060 warnstring
= "declaration of `%s' shadows previous local";
1061 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1062 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1063 warnstring
= "declaration of `%s' shadows global declaration";
1066 warning (warnstring
, IDENTIFIER_POINTER (name
));
1070 /* If storing a local value, there may already be one (inherited).
1071 If so, record it for restoration when this binding level ends. */
1073 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1077 /* Put decls on list in reverse order.
1078 We will reverse them later if necessary. */
1079 TREE_CHAIN (x
) = b
->names
;
1086 pushdecl_force_head (x
)
1089 current_binding_level
->names
= x
;
1092 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1095 pushdecl_top_level (x
)
1099 register struct binding_level
*b
= current_binding_level
;
1101 current_binding_level
= global_binding_level
;
1103 current_binding_level
= b
;
1107 /* Nonzero if we are currently in the global binding level. */
1110 global_bindings_p ()
1112 return current_binding_level
== global_binding_level
;
1115 /* Return the list of declarations of the current level.
1116 Note that this list is in reverse order unless/until
1117 you nreverse it; and when you do nreverse it, you must
1118 store the result back using `storedecls' or you will lose. */
1123 return current_binding_level
->names
;
1126 /* Create a new `struct binding_level'. */
1128 static struct binding_level
*
1129 make_binding_level ()
1132 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
1137 int unused ATTRIBUTE_UNUSED
;
1139 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1142 /* If this is the top level of a function,
1143 just make sure that NAMED_LABELS is 0. */
1145 if (current_binding_level
== global_binding_level
)
1149 /* Reuse or create a struct for this binding level. */
1151 if (free_binding_level
)
1153 newlevel
= free_binding_level
;
1154 free_binding_level
= free_binding_level
->level_chain
;
1158 newlevel
= make_binding_level ();
1161 /* Add this level to the front of the chain (stack) of levels that
1164 *newlevel
= clear_binding_level
;
1165 newlevel
->level_chain
= current_binding_level
;
1166 current_binding_level
= newlevel
;
1167 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1168 newlevel
->binding_depth
= binding_depth
;
1170 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1171 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1174 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1177 /* Exit a binding level.
1178 Pop the level off, and restore the state of the identifier-decl mappings
1179 that were in effect when this level was entered.
1181 If KEEP is nonzero, this level had explicit declarations, so
1182 and create a "block" (a BLOCK node) for the level
1183 to record its declarations and subblocks for symbol table output.
1185 If FUNCTIONBODY is nonzero, this level is the body of a function,
1186 so create a block as if KEEP were set and also clear out all
1189 If REVERSE is nonzero, reverse the order of decls before putting
1190 them into the BLOCK. */
1193 poplevel (keep
, reverse
, functionbody
)
1199 /* The chain of decls was accumulated in reverse order.
1200 Put it into forward order, just for cleanliness. */
1202 tree subblocks
= current_binding_level
->blocks
;
1205 int block_previously_created
;
1207 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1210 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1211 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1212 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1213 current_binding_level
->end_pc
);
1215 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1216 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1218 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1221 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1225 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1227 /* Get the decls in the order they were written.
1228 Usually current_binding_level->names is in reverse order.
1229 But parameter decls were previously put in forward order. */
1232 current_binding_level
->names
1233 = decls
= nreverse (current_binding_level
->names
);
1235 decls
= current_binding_level
->names
;
1237 /* Output any nested inline functions within this block
1238 if they weren't already output. */
1240 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1241 if (TREE_CODE (decl
) == FUNCTION_DECL
1242 && ! TREE_ASM_WRITTEN (decl
)
1243 && DECL_INITIAL (decl
) != 0
1244 && TREE_ADDRESSABLE (decl
))
1246 /* If this decl was copied from a file-scope decl
1247 on account of a block-scope extern decl,
1248 propagate TREE_ADDRESSABLE to the file-scope decl.
1250 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1251 true, since then the decl goes through save_for_inline_copying. */
1252 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1253 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1254 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1257 push_function_context ();
1258 output_inline_function (decl
);
1259 pop_function_context ();
1263 /* If there were any declarations in that level,
1264 or if this level is a function body,
1265 create a BLOCK to record them for the life of this function. */
1268 block_previously_created
= (current_binding_level
->this_block
!= 0);
1269 if (block_previously_created
)
1270 block
= current_binding_level
->this_block
;
1271 else if (keep
|| functionbody
)
1272 block
= make_node (BLOCK
);
1275 BLOCK_VARS (block
) = decls
;
1276 BLOCK_SUBBLOCKS (block
) = subblocks
;
1279 /* In each subblock, record that this is its superior. */
1281 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1282 BLOCK_SUPERCONTEXT (link
) = block
;
1284 /* Clear out the meanings of the local variables of this level. */
1286 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1288 tree name
= DECL_NAME (link
);
1289 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1291 /* If the ident. was used or addressed via a local extern decl,
1292 don't forget that fact. */
1293 if (DECL_EXTERNAL (link
))
1295 if (TREE_USED (link
))
1296 TREE_USED (name
) = 1;
1297 if (TREE_ADDRESSABLE (link
))
1298 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1300 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1304 /* Restore all name-meanings of the outer levels
1305 that were shadowed by this level. */
1307 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1308 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1310 /* If the level being exited is the top level of a function,
1311 check over all the labels, and clear out the current
1312 (function local) meanings of their names. */
1316 /* If this is the top level block of a function,
1317 the vars are the function's parameters.
1318 Don't leave them in the BLOCK because they are
1319 found in the FUNCTION_DECL instead. */
1321 BLOCK_VARS (block
) = 0;
1323 /* Clear out the definitions of all label names,
1324 since their scopes end here,
1325 and add them to BLOCK_VARS. */
1328 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1330 register tree label
= TREE_VALUE (link
);
1332 if (DECL_INITIAL (label
) == 0)
1334 error_with_decl (label
, "label `%s' used but not defined");
1335 /* Avoid crashing later. */
1336 define_label (input_filename
, lineno
,
1339 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1340 warning_with_decl (label
, "label `%s' defined but not used");
1341 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1343 /* Put the labels into the "variables" of the
1344 top-level block, so debugger can see them. */
1345 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1346 BLOCK_VARS (block
) = label
;
1351 /* Pop the current level, and free the structure for reuse. */
1354 register struct binding_level
*level
= current_binding_level
;
1355 current_binding_level
= current_binding_level
->level_chain
;
1357 level
->level_chain
= free_binding_level
;
1358 free_binding_level
= level
;
1361 /* Dispose of the block that we just made inside some higher level. */
1363 DECL_INITIAL (current_function_decl
) = block
;
1366 if (!block_previously_created
)
1367 current_binding_level
->blocks
1368 = chainon (current_binding_level
->blocks
, block
);
1370 /* If we did not make a block for the level just exited,
1371 any blocks made for inner levels
1372 (since they cannot be recorded as subblocks in that level)
1373 must be carried forward so they will later become subblocks
1374 of something else. */
1376 current_binding_level
->blocks
1377 = chainon (current_binding_level
->blocks
, subblocks
);
1379 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1380 binding contour so that they point to the appropriate construct, i.e.
1381 either to the current FUNCTION_DECL node, or else to the BLOCK node
1382 we just constructed.
1384 Note that for tagged types whose scope is just the formal parameter
1385 list for some function type specification, we can't properly set
1386 their TYPE_CONTEXTs here, because we don't have a pointer to the
1387 appropriate FUNCTION_TYPE node readily available to us. For those
1388 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1389 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1390 node which will represent the "scope" for these "parameter list local"
1395 TREE_USED (block
) = 1;
1400 maybe_pushlevels (pc
)
1403 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1407 while (pending_local_decls
!= NULL_TREE
&&
1408 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1410 tree
*ptr
= &pending_local_decls
;
1412 int end_pc
= DECL_LOCAL_END_PC (decl
);
1414 while (*ptr
!= NULL_TREE
1415 && DECL_LOCAL_START_PC (*ptr
) <= pc
1416 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1417 ptr
= &TREE_CHAIN (*ptr
);
1418 pending_local_decls
= *ptr
;
1421 /* Force non-nested range to be nested in current range. */
1422 if (end_pc
> current_binding_level
->end_pc
)
1423 end_pc
= current_binding_level
->end_pc
;
1425 maybe_start_try (pc
, end_pc
);
1428 expand_start_bindings (0);
1430 current_binding_level
->end_pc
= end_pc
;
1431 current_binding_level
->start_pc
= pc
;
1432 current_binding_level
->names
= decl
;
1433 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1435 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1439 maybe_start_try (pc
, 0);
1443 maybe_poplevels (pc
)
1446 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1450 while (current_binding_level
->end_pc
<= pc
)
1452 expand_end_bindings (getdecls (), 1, 0);
1453 maybe_end_try (current_binding_level
->start_pc
, pc
);
1456 maybe_end_try (0, pc
);
1459 /* Terminate any binding which began during the range beginning at
1460 start_pc. This tidies up improperly nested local variable ranges
1461 and exception handlers; a variable declared within an exception
1462 range is forcibly terminated when that exception ends. */
1465 force_poplevels (start_pc
)
1468 while (current_binding_level
->start_pc
> start_pc
)
1470 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1471 warning_with_decl (current_function_decl
,
1472 "In %s: overlapped variable and exception ranges at %d",
1473 current_binding_level
->start_pc
);
1474 expand_end_bindings (getdecls (), 1, 0);
1479 /* Insert BLOCK at the end of the list of subblocks of the
1480 current binding level. This is used when a BIND_EXPR is expanded,
1481 to handle the BLOCK node inside the BIND_EXPR. */
1484 insert_block (block
)
1487 TREE_USED (block
) = 1;
1488 current_binding_level
->blocks
1489 = chainon (current_binding_level
->blocks
, block
);
1492 /* Set the BLOCK node for the innermost scope
1493 (the one we are currently in). */
1497 register tree block
;
1499 current_binding_level
->this_block
= block
;
1500 current_binding_level
->names
= chainon (current_binding_level
->names
,
1501 BLOCK_VARS (block
));
1502 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1503 BLOCK_SUBBLOCKS (block
));
1506 /* integrate_decl_tree calls this function. */
1509 copy_lang_decl (node
)
1513 = TREE_CODE (node
) == VAR_DECL
? sizeof (struct lang_decl_var
)
1514 : sizeof (struct lang_decl
);
1515 struct lang_decl
*x
= (struct lang_decl
*) ggc_alloc (lang_decl_size
);
1516 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1517 DECL_LANG_SPECIFIC (node
) = x
;
1520 /* If DECL has a cleanup, build and return that cleanup here.
1521 This is a callback called by expand_expr. */
1524 maybe_build_cleanup (decl
)
1525 tree decl ATTRIBUTE_UNUSED
;
1527 /* There are no cleanups in Java (I think). */
1532 give_name_to_locals (jcf
)
1535 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1536 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1538 pending_local_decls
= NULL_TREE
;
1542 n
= JCF_readu2 (jcf
);
1543 for (i
= 0; i
< n
; i
++)
1545 int start_pc
= JCF_readu2 (jcf
);
1546 int length
= JCF_readu2 (jcf
);
1547 int name_index
= JCF_readu2 (jcf
);
1548 int signature_index
= JCF_readu2 (jcf
);
1549 int slot
= JCF_readu2 (jcf
);
1550 tree name
= get_name_constant (jcf
, name_index
);
1551 tree type
= parse_signature (jcf
, signature_index
);
1552 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1554 && length
== DECL_CODE_LENGTH (current_function_decl
))
1556 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1557 DECL_NAME (decl
) = name
;
1558 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1559 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1560 warning ("bad type in parameter debug info");
1565 int end_pc
= start_pc
+ length
;
1566 tree decl
= build_decl (VAR_DECL
, name
, type
);
1567 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1569 warning_with_decl (decl
,
1570 "bad PC range for debug info for local `%s'");
1571 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1574 /* Adjust start_pc if necessary so that the local's first
1575 store operation will use the relevant DECL as a
1576 destination. Fore more information, read the leading
1577 comments for expr.c:maybe_adjust_start_pc. */
1578 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1580 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1581 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1582 DECL_LOCAL_START_PC (decl
) = start_pc
;
1584 /* FIXME: The range used internally for exceptions and local
1585 variable ranges, is a half-open interval:
1586 start_pc <= pc < end_pc. However, the range used in the
1587 Java VM spec is inclusive at both ends:
1588 start_pc <= pc <= end_pc. */
1591 DECL_LOCAL_END_PC (decl
) = end_pc
;
1593 /* Now insert the new decl in the proper place in
1594 pending_local_decls. We are essentially doing an insertion sort,
1595 which works fine, since the list input will normally already
1597 ptr
= &pending_local_decls
;
1598 while (*ptr
!= NULL_TREE
1599 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1600 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1601 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1602 ptr
= &TREE_CHAIN (*ptr
);
1603 TREE_CHAIN (decl
) = *ptr
;
1608 pending_local_decls
= nreverse (pending_local_decls
);
1610 /* Fill in default names for the parameters. */
1611 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1612 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1614 if (DECL_NAME (parm
) == NULL_TREE
)
1616 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1618 DECL_NAME (parm
) = get_identifier ("this");
1622 sprintf (buffer
, "ARG_%d", arg_i
);
1623 DECL_NAME (parm
) = get_identifier (buffer
);
1625 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1631 build_result_decl (fndecl
)
1634 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1635 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1636 if (INTEGRAL_TYPE_P (restype
)
1637 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1638 restype
= integer_type_node
;
1639 return (DECL_RESULT (fndecl
) = build_decl (RESULT_DECL
, NULL_TREE
, restype
));
1642 /* Called for every element in DECL_FUNCTION_INIT_TEST_TABLE in order
1643 to emit initialization code for each test flag. */
1646 emit_init_test_initialization (entry
, key
)
1647 struct hash_entry
*entry
;
1648 hash_table_key key ATTRIBUTE_UNUSED
;
1650 struct init_test_hash_entry
*ite
= (struct init_test_hash_entry
*) entry
;
1651 tree klass
= build_class_ref ((tree
) entry
->key
);
1652 expand_decl (ite
->init_test_decl
);
1654 /* We initialize the class init check variable by looking at the
1655 `state' field of the class to see if it is already initialized.
1656 This makes things a bit faster if the class is already
1657 initialized, which should be the common case. */
1659 (build (MODIFY_EXPR
, boolean_type_node
,
1660 ite
->init_test_decl
,
1661 build (GE_EXPR
, boolean_type_node
,
1662 build (COMPONENT_REF
, byte_type_node
,
1663 build1 (INDIRECT_REF
, class_type_node
, klass
),
1664 lookup_field (&class_type_node
,
1665 get_identifier ("state"))),
1666 build_int_2 (JV_STATE_DONE
, 0))));
1672 complete_start_java_method (fndecl
)
1675 if (! flag_emit_class_files
)
1677 /* Initialize the RTL code for the function. */
1678 init_function_start (fndecl
, input_filename
, lineno
);
1680 /* Set up parameters and prepare for return, for the function. */
1681 expand_function_start (fndecl
, 0);
1683 /* Emit initialization code for test flags. */
1684 if (! always_initialize_class_p
)
1685 hash_traverse (&DECL_FUNCTION_INIT_TEST_TABLE (fndecl
),
1686 emit_init_test_initialization
, 0);
1690 /* If this fcn was already referenced via a block-scope `extern' decl (or
1691 an implicit decl), propagate certain information about the usage. */
1692 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1693 TREE_ADDRESSABLE (current_function_decl
) = 1;
1697 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1698 && ! flag_emit_class_files
1699 && ! DECL_CLINIT_P (fndecl
)
1700 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1702 tree clas
= DECL_CONTEXT (fndecl
);
1703 tree init
= build (CALL_EXPR
, void_type_node
,
1704 build_address_of (soft_initclass_node
),
1705 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1707 TREE_SIDE_EFFECTS (init
) = 1;
1708 expand_expr_stmt (init
);
1711 /* Push local variables. Function compiled from source code are
1712 using a different local variables management, and for them,
1713 pushlevel shouldn't be called from here. */
1714 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1717 if (! flag_emit_class_files
)
1718 expand_start_bindings (1);
1721 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1723 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1724 tree enter
, exit
, lock
;
1725 if (METHOD_STATIC (fndecl
))
1726 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1728 lock
= DECL_ARGUMENTS (fndecl
);
1729 BUILD_MONITOR_ENTER (enter
, lock
);
1730 BUILD_MONITOR_EXIT (exit
, lock
);
1731 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1733 expand_expr_stmt (enter
);
1734 expand_decl_cleanup (NULL_TREE
, exit
);
1738 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1739 tree body
= BLOCK_EXPR_BODY (function_body
);
1740 lock
= build (WITH_CLEANUP_EXPR
, void_type_node
,
1741 enter
, exit
, NULL_TREE
);
1742 TREE_SIDE_EFFECTS (lock
) = 1;
1743 lock
= build (COMPOUND_EXPR
, TREE_TYPE (body
), lock
, body
);
1744 TREE_SIDE_EFFECTS (lock
) = 1;
1745 lock
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (body
), lock
);
1746 TREE_SIDE_EFFECTS (lock
) = 1;
1747 BLOCK_EXPR_BODY (function_body
) = lock
;
1753 start_java_method (fndecl
)
1759 current_function_decl
= fndecl
;
1760 announce_function (fndecl
);
1762 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1763 decl_map
= make_tree_vec (i
);
1764 type_map
= (tree
*) xrealloc (type_map
, i
* sizeof (tree
));
1766 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1767 fprintf (stderr
, "%s:\n", (*decl_printable_name
) (fndecl
, 2));
1769 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1770 pushlevel (1); /* Push parameters. */
1772 ptr
= &DECL_ARGUMENTS (fndecl
);
1773 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1774 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1776 tree parm_name
= NULL_TREE
, parm_decl
;
1777 tree parm_type
= TREE_VALUE (tem
);
1778 if (i
>= DECL_MAX_LOCALS (fndecl
))
1781 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1782 DECL_CONTEXT (parm_decl
) = fndecl
;
1783 if (PROMOTE_PROTOTYPES
1784 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1785 && INTEGRAL_TYPE_P (parm_type
))
1786 parm_type
= integer_type_node
;
1787 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1790 ptr
= &TREE_CHAIN (parm_decl
);
1792 /* Add parm_decl to the decl_map. */
1793 push_jvm_slot (i
, parm_decl
);
1795 type_map
[i
] = TREE_TYPE (parm_decl
);
1796 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1799 type_map
[i
] = void_type_node
;
1803 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1805 while (i
< DECL_MAX_LOCALS(fndecl
))
1806 type_map
[i
++] = NULL_TREE
;
1808 build_result_decl (fndecl
);
1809 complete_start_java_method (fndecl
);
1815 tree fndecl
= current_function_decl
;
1817 expand_end_bindings (getdecls (), 1, 0);
1818 /* pop out of function */
1821 /* pop out of its parameters */
1824 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1826 /* Generate rtl for function exit. */
1827 expand_function_end (input_filename
, lineno
, 0);
1829 /* Run the optimizers and output assembler code for this function. */
1830 rest_of_compilation (fndecl
);
1832 current_function_decl
= NULL_TREE
;
1835 /* Mark language-specific parts of T for garbage-collection. */
1841 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1843 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
1844 ggc_mark_tree (li
->global_value
);
1845 ggc_mark_tree (li
->local_value
);
1846 ggc_mark_tree (li
->utf8_ref
);
1848 else if (TREE_CODE (t
) == VAR_DECL
1849 || TREE_CODE (t
) == PARM_DECL
1850 || TREE_CODE (t
) == FIELD_DECL
)
1852 struct lang_decl_var
*ldv
=
1853 ((struct lang_decl_var
*) DECL_LANG_SPECIFIC (t
));
1857 ggc_mark_tree (ldv
->slot_chain
);
1858 ggc_mark_tree (ldv
->am
);
1859 ggc_mark_tree (ldv
->wfl
);
1862 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1864 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
1869 ggc_mark_tree (ld
->wfl
);
1870 ggc_mark_tree (ld
->throws_list
);
1871 ggc_mark_tree (ld
->function_decl_body
);
1872 ggc_mark_tree (ld
->called_constructor
);
1873 ggc_mark_tree (ld
->inner_access
);
1876 else if (TYPE_P (t
))
1878 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
1883 ggc_mark_tree (lt
->signature
);
1884 ggc_mark_tree (lt
->cpool_data_ref
);
1885 ggc_mark_tree (lt
->finit_stmt_list
);
1886 ggc_mark_tree (lt
->clinit_stmt_list
);
1887 ggc_mark_tree (lt
->ii_block
);
1888 ggc_mark_tree (lt
->dot_class
);
1889 ggc_mark_tree (lt
->package_list
);