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. */
34 #include "java-tree.h"
39 #include "java-except.h"
42 #if defined (DEBUG_JAVA_BINDING_LEVELS)
43 extern void indent
PROTO((void));
46 static tree push_jvm_slot
PARAMS ((int, tree
));
47 static tree lookup_name_current_level
PARAMS ((tree
));
48 static tree push_promoted_type
PARAMS ((const char *, tree
));
49 static struct binding_level
*make_binding_level
PARAMS ((void));
50 static bool emit_init_test_initialization
PARAMS ((struct hash_entry
*,
52 static tree create_primitive_vtable
PARAMS ((const char *));
53 static tree check_local_named_variable
PARAMS ((tree
, tree
, int, int *));
54 static tree check_local_unnamed_variable
PARAMS ((tree
, tree
, tree
));
56 /* Set to non-zero value in order to emit class initilization code
57 before static field references. */
58 extern int always_initialize_class_p
;
60 /* The DECL_MAP is a mapping from (index, type) to a decl node.
61 If index < max_locals, it is the index of a local variable.
62 if index >= max_locals, then index-max_locals is a stack slot.
63 The DECL_MAP mapping is represented as a TREE_VEC whose elements
64 are a list of decls (VAR_DECL or PARM_DECL) chained by
65 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
66 we search the chain for a decl with a matching TREE_TYPE. */
70 /* A list of local variables VAR_DECLs for this method that we have seen
71 debug information, but we have not reached their starting (byte) PC yet. */
73 static tree pending_local_decls
= NULL_TREE
;
77 /* Push a local variable or stack slot into the decl_map,
78 and assign it an rtl. */
80 #if defined(DEBUG_JAVA_BINDING_LEVELS)
81 int binding_depth
= 0;
82 int is_class_level
= 0;
90 for (i
= 0; i
< binding_depth
*2; i
++)
93 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
96 push_jvm_slot (index
, decl
)
100 struct rtx_def
*rtl
= NULL
;
101 tree type
= TREE_TYPE (decl
);
104 DECL_CONTEXT (decl
) = current_function_decl
;
105 layout_decl (decl
, 0);
107 /* See if we have an appropriate rtl (i.e. same mode) at this index.
108 If so, we must use it. */
109 tmp
= TREE_VEC_ELT (decl_map
, index
);
110 while (tmp
!= NULL_TREE
)
112 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
113 rtl
= DECL_RTL_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_PTR
);
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;
399 make_decl_rtl (r
, buf
);
404 init_decl_processing ()
406 register tree endlink
;
407 tree field
= NULL_TREE
;
410 init_class_processing ();
412 current_function_decl
= NULL
;
413 current_binding_level
= NULL_BINDING_LEVEL
;
414 free_binding_level
= NULL_BINDING_LEVEL
;
415 pushlevel (0); /* make the binding_level structure for global names */
416 global_binding_level
= current_binding_level
;
418 /* The code here must be similar to build_common_tree_nodes{,_2} in
419 tree.c, especially as to the order of initializing common nodes. */
420 error_mark_node
= make_node (ERROR_MARK
);
421 TREE_TYPE (error_mark_node
) = error_mark_node
;
423 /* Create sizetype first - needed for other types. */
424 initialize_sizetypes ();
426 byte_type_node
= make_signed_type (8);
427 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
428 short_type_node
= make_signed_type (16);
429 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
430 int_type_node
= make_signed_type (32);
431 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
432 long_type_node
= make_signed_type (64);
433 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
435 unsigned_byte_type_node
= make_unsigned_type (8);
436 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
437 unsigned_byte_type_node
));
438 unsigned_short_type_node
= make_unsigned_type (16);
439 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
440 unsigned_short_type_node
));
441 unsigned_int_type_node
= make_unsigned_type (32);
442 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
443 unsigned_int_type_node
));
444 unsigned_long_type_node
= make_unsigned_type (64);
445 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
446 unsigned_long_type_node
));
448 set_sizetype (make_unsigned_type (POINTER_SIZE
));
450 /* Define these next since types below may used them. */
451 integer_type_node
= type_for_size (INT_TYPE_SIZE
, 0);
452 integer_zero_node
= build_int_2 (0, 0);
453 integer_one_node
= build_int_2 (1, 0);
454 integer_two_node
= build_int_2 (2, 0);
455 integer_four_node
= build_int_2 (4, 0);
456 integer_minus_one_node
= build_int_2 (-1, -1);
458 size_zero_node
= size_int (0);
459 size_one_node
= size_int (1);
460 bitsize_zero_node
= bitsize_int (0);
461 bitsize_one_node
= bitsize_int (1);
462 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
464 long_zero_node
= build_int_2 (0, 0);
465 TREE_TYPE (long_zero_node
) = long_type_node
;
467 void_type_node
= make_node (VOID_TYPE
);
468 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
469 layout_type (void_type_node
); /* Uses size_zero_node */
470 ptr_type_node
= build_pointer_type (void_type_node
);
471 t
= make_node (VOID_TYPE
);
472 layout_type (t
); /* Uses size_zero_node */
473 return_address_type_node
= build_pointer_type (t
);
475 null_pointer_node
= build_int_2 (0, 0);
476 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
478 /* Used by the parser to represent empty statements and blocks. */
479 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
480 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
483 /* Make a type to be the domain of a few array types
484 whose domains don't really matter.
485 200 is small enough that it always fits in size_t
486 and large enough that it can hold most function names for the
487 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
488 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
490 char_type_node
= make_node (CHAR_TYPE
);
491 TYPE_PRECISION (char_type_node
) = 16;
492 fixup_unsigned_type (char_type_node
);
493 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
495 boolean_type_node
= make_node (BOOLEAN_TYPE
);
496 TYPE_PRECISION (boolean_type_node
) = 1;
497 fixup_unsigned_type (boolean_type_node
);
498 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
500 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
501 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
503 promoted_byte_type_node
504 = push_promoted_type ("promoted_byte", byte_type_node
);
505 promoted_short_type_node
506 = push_promoted_type ("promoted_short", short_type_node
);
507 promoted_char_type_node
508 = push_promoted_type ("promoted_char", char_type_node
);
509 promoted_boolean_type_node
510 = push_promoted_type ("promoted_boolean", boolean_type_node
);
512 float_type_node
= make_node (REAL_TYPE
);
513 TYPE_PRECISION (float_type_node
) = 32;
514 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
516 layout_type (float_type_node
);
518 double_type_node
= make_node (REAL_TYPE
);
519 TYPE_PRECISION (double_type_node
) = 64;
520 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
522 layout_type (double_type_node
);
524 float_zero_node
= build_real (float_type_node
, dconst0
);
525 double_zero_node
= build_real (double_type_node
, dconst0
);
527 /* These are the vtables for arrays of primitives. */
528 boolean_array_vtable
= create_primitive_vtable ("boolean");
529 byte_array_vtable
= create_primitive_vtable ("byte");
530 char_array_vtable
= create_primitive_vtable ("char");
531 short_array_vtable
= create_primitive_vtable ("short");
532 int_array_vtable
= create_primitive_vtable ("int");
533 long_array_vtable
= create_primitive_vtable ("long");
534 float_array_vtable
= create_primitive_vtable ("float");
535 double_array_vtable
= create_primitive_vtable ("double");
537 /* As you're adding items here, please update the code right after
538 this section, so that the filename containing the source code of
539 the pre-defined class gets registered correctly. */
540 unqualified_object_id_node
= get_identifier ("Object");
541 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
542 object_ptr_type_node
= promote_type (object_type_node
);
543 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
544 string_ptr_type_node
= promote_type (string_type_node
);
545 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
546 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
547 runtime_exception_type_node
=
548 lookup_class (get_identifier ("java.lang.RuntimeException"));
549 error_exception_type_node
=
550 lookup_class (get_identifier ("java.lang.Error"));
551 rawdata_ptr_type_node
552 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
554 /* If you add to this section, don't forget to increase
555 PREDEF_FILENAMES_SIZE. */
556 predef_filenames
[0] = get_identifier ("java/lang/Class.java");
557 predef_filenames
[1] = get_identifier ("java/lang/Error.java");
558 predef_filenames
[2] = get_identifier ("java/lang/Object.java");
559 predef_filenames
[3] = get_identifier ("java/lang/RuntimeException.java");
560 predef_filenames
[4] = get_identifier ("java/lang/String.java");
561 predef_filenames
[5] = get_identifier ("java/lang/Throwable.java");
562 predef_filenames
[6] = get_identifier ("gnu/gcj/RawData.java");
564 methodtable_type
= make_node (RECORD_TYPE
);
565 layout_type (methodtable_type
);
566 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
567 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
569 TYPE_identifier_node
= get_identifier ("TYPE");
570 init_identifier_node
= get_identifier ("<init>");
571 clinit_identifier_node
= get_identifier ("<clinit>");
572 /* Legacy `$finit$' special method identifier. This needs to be
573 recognized as equivalent to `finit$' but isn't generated anymore. */
574 finit_leg_identifier_node
= get_identifier ("$finit$");
575 /* The new `finit$' special method identifier. This one is now
576 generated in place of `$finit$'. */
577 finit_identifier_node
= get_identifier ("finit$");
578 void_signature_node
= get_identifier ("()V");
579 length_identifier_node
= get_identifier ("length");
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 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
608 /* This isn't exactly true, but it is what we have in the source.
609 There is an unresolved issue here, which is whether the vtable
610 should be marked by the GC. */
611 if (! flag_hash_synchronization
)
612 PUSH_FIELD (object_type_node
, field
, "sync_info",
613 build_pointer_type (object_type_node
));
614 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
615 FIELD_PRIVATE (t
) = 1;
616 FINISH_RECORD (object_type_node
);
618 field_type_node
= make_node (RECORD_TYPE
);
619 field_ptr_type_node
= build_pointer_type (field_type_node
);
620 method_type_node
= make_node (RECORD_TYPE
);
621 method_ptr_type_node
= build_pointer_type (method_type_node
);
623 set_super_info (0, class_type_node
, object_type_node
, 0);
624 set_super_info (0, string_type_node
, object_type_node
, 0);
625 class_ptr_type
= build_pointer_type (class_type_node
);
627 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
628 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
629 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
630 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
631 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
632 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
633 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
634 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
635 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
636 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
637 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
638 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
639 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
640 PUSH_FIELD (class_type_node
, field
, "interfaces",
641 build_pointer_type (class_ptr_type
));
642 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
643 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
644 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
645 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
646 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
647 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
648 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
649 PUSH_FIELD (class_type_node
, field
, "arrayclass", 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 CLASS_LOADED_P (field_type_node
) = 1;
671 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
673 one_elt_array_domain_type
= build_index_type (integer_one_node
);
674 nativecode_ptr_array_type_node
675 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
677 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
678 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
679 FINISH_RECORD (dtable_type
);
680 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
682 #define jint_type int_type_node
683 #define jint_ptr_type ptr_type_node
685 jexception_type
= make_node (RECORD_TYPE
);
686 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
687 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
688 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
689 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
690 FINISH_RECORD (jexception_type
);
691 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
692 jexception_ptr_type
= build_pointer_type (jexception_type
);
694 lineNumberEntry_type
= make_node (RECORD_TYPE
);
695 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
696 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
697 FINISH_RECORD (lineNumberEntry_type
);
699 lineNumbers_type
= make_node (RECORD_TYPE
);
700 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
701 FINISH_RECORD (lineNumbers_type
);
703 #define instn_ptr_type_node ptr_type_node /* XXX JH */
705 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
707 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
708 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
709 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
710 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
711 FINISH_RECORD (method_type_node
);
712 CLASS_LOADED_P (method_type_node
) = 1;
713 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
715 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
717 t
= tree_cons (NULL_TREE
, class_ptr_type
,
718 tree_cons (NULL_TREE
, int_type_node
, endlink
));
719 alloc_object_node
= builtin_function ("_Jv_AllocObject",
720 build_function_type (ptr_type_node
, t
),
721 0, NOT_BUILT_IN
, NULL_PTR
);
722 DECL_IS_MALLOC (alloc_object_node
) = 1;
724 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
725 soft_initclass_node
= builtin_function ("_Jv_InitClass",
726 build_function_type (void_type_node
,
730 throw_node
[0] = builtin_function ("_Jv_Throw",
731 build_function_type (ptr_type_node
, t
),
732 0, NOT_BUILT_IN
, NULL_PTR
);
733 /* Mark throw_nodes as `noreturn' functions with side effects. */
734 TREE_THIS_VOLATILE (throw_node
[0]) = 1;
735 TREE_SIDE_EFFECTS (throw_node
[0]) = 1;
736 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
737 throw_node
[1] = builtin_function ("_Jv_Sjlj_Throw",
738 build_function_type (ptr_type_node
, t
),
739 0, NOT_BUILT_IN
, NULL_PTR
);
740 TREE_THIS_VOLATILE (throw_node
[1]) = 1;
741 TREE_SIDE_EFFECTS (throw_node
[1]) = 1;
742 t
= build_function_type (int_type_node
, endlink
);
743 soft_monitorenter_node
744 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
746 soft_monitorexit_node
747 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
750 t
= tree_cons (NULL_TREE
, int_type_node
,
751 tree_cons (NULL_TREE
, int_type_node
, endlink
));
753 = builtin_function ("_Jv_NewPrimArray",
754 build_function_type(ptr_type_node
, t
),
755 0, NOT_BUILT_IN
, NULL_PTR
);
756 DECL_IS_MALLOC (soft_newarray_node
) = 1;
758 t
= tree_cons (NULL_TREE
, int_type_node
,
759 tree_cons (NULL_TREE
, class_ptr_type
,
760 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
762 = builtin_function ("_Jv_NewObjectArray",
763 build_function_type (ptr_type_node
, t
),
764 0, NOT_BUILT_IN
, NULL_PTR
);
765 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
767 t
= tree_cons (NULL_TREE
, ptr_type_node
,
768 tree_cons (NULL_TREE
, int_type_node
, endlink
));
769 soft_multianewarray_node
770 = builtin_function ("_Jv_NewMultiArray",
771 build_function_type (ptr_type_node
, t
),
772 0, NOT_BUILT_IN
, NULL_PTR
);
773 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
775 t
= build_function_type (void_type_node
,
776 tree_cons (NULL_TREE
, int_type_node
, endlink
));
777 soft_badarrayindex_node
778 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
779 0, NOT_BUILT_IN
, NULL_PTR
);
780 /* Mark soft_badarrayindex_node as a `noreturn' function with side
782 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
783 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
785 soft_nullpointer_node
786 = builtin_function ("_Jv_ThrowNullPointerException",
787 build_function_type (void_type_node
, endlink
),
788 0, NOT_BUILT_IN
, NULL_PTR
);
789 /* Mark soft_nullpointer_node as a `noreturn' function with side
791 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
792 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
794 t
= tree_cons (NULL_TREE
, class_ptr_type
,
795 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
797 = builtin_function ("_Jv_CheckCast",
798 build_function_type (ptr_type_node
, t
),
799 0, NOT_BUILT_IN
, NULL_PTR
);
800 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
801 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
803 = builtin_function ("_Jv_IsInstanceOf",
804 build_function_type (boolean_type_node
, t
),
805 0, NOT_BUILT_IN
, NULL_PTR
);
806 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
807 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
808 soft_checkarraystore_node
809 = builtin_function ("_Jv_CheckArrayStore",
810 build_function_type (void_type_node
, t
),
811 0, NOT_BUILT_IN
, NULL_PTR
);
812 t
= tree_cons (NULL_TREE
, ptr_type_node
,
813 tree_cons (NULL_TREE
, ptr_type_node
,
814 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
815 soft_lookupinterfacemethod_node
816 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
817 build_function_type (ptr_type_node
, t
),
818 0, NOT_BUILT_IN
, NULL_PTR
);
820 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
821 tree_cons (NULL_TREE
, ptr_type_node
,
822 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
823 soft_lookupjnimethod_node
824 = builtin_function ("_Jv_LookupJNIMethod",
825 build_function_type (ptr_type_node
, t
),
826 0, NOT_BUILT_IN
, NULL_PTR
);
827 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
828 soft_getjnienvnewframe_node
829 = builtin_function ("_Jv_GetJNIEnvNewFrame",
830 build_function_type (ptr_type_node
, t
),
831 0, NOT_BUILT_IN
, NULL_PTR
);
832 soft_jnipopsystemframe_node
833 = builtin_function ("_Jv_JNI_PopSystemFrame",
834 build_function_type (ptr_type_node
, t
),
835 0, NOT_BUILT_IN
, NULL_PTR
);
837 t
= tree_cons (NULL_TREE
, double_type_node
,
838 tree_cons (NULL_TREE
, double_type_node
, endlink
));
840 = builtin_function ("__builtin_fmod",
841 build_function_type (double_type_node
, t
),
842 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmod");
844 soft_exceptioninfo_call_node
848 (builtin_function ("_Jv_exception_info",
849 build_function_type (ptr_type_node
, endlink
),
850 0, NOT_BUILT_IN
, NULL_PTR
)),
851 NULL_TREE
, NULL_TREE
);
852 TREE_SIDE_EFFECTS (soft_exceptioninfo_call_node
) = 1;
854 t
= tree_cons (NULL_TREE
, float_type_node
,
855 tree_cons (NULL_TREE
, float_type_node
, endlink
));
857 = builtin_function ("__builtin_fmodf",
858 build_function_type (float_type_node
, t
),
859 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf");
863 = builtin_function ("_Jv_divI",
864 build_function_type (int_type_node
, t
),
865 0, NOT_BUILT_IN
, NULL_PTR
);
868 = builtin_function ("_Jv_remI",
869 build_function_type (int_type_node
, t
),
870 0, NOT_BUILT_IN
, NULL_PTR
);
873 = builtin_function ("_Jv_divJ",
874 build_function_type (long_type_node
, t
),
875 0, NOT_BUILT_IN
, NULL_PTR
);
878 = builtin_function ("_Jv_remJ",
879 build_function_type (long_type_node
, t
),
880 0, NOT_BUILT_IN
, NULL_PTR
);
884 /* Register nodes with the garbage collector. */
885 ggc_add_tree_root (java_global_trees
,
886 sizeof (java_global_trees
) / sizeof (tree
));
887 ggc_add_tree_root (throw_node
,
888 sizeof (throw_node
) / sizeof (tree
));
889 ggc_add_tree_root (predef_filenames
,
890 sizeof (predef_filenames
) / sizeof (tree
));
891 ggc_add_tree_root (&decl_map
, 1);
892 ggc_add_tree_root (&pending_local_decls
, 1);
896 /* Look up NAME in the current binding level and its superiors
897 in the namespace of variables, functions and typedefs.
898 Return a ..._DECL node of some kind representing its definition,
899 or return 0 if it is undefined. */
906 if (current_binding_level
!= global_binding_level
907 && IDENTIFIER_LOCAL_VALUE (name
))
908 val
= IDENTIFIER_LOCAL_VALUE (name
);
910 val
= IDENTIFIER_GLOBAL_VALUE (name
);
914 /* Similar to `lookup_name' but look only at current binding level and
915 the previous one if its the parameter level. */
918 lookup_name_current_level (name
)
923 if (current_binding_level
== global_binding_level
)
924 return IDENTIFIER_GLOBAL_VALUE (name
);
926 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
929 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
930 if (DECL_NAME (t
) == name
)
936 /* Use a binding level to record a labeled block declaration */
939 push_labeled_block (lb
)
942 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
943 register struct binding_level
*b
= current_binding_level
;
944 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
946 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
947 TREE_CHAIN (lb
) = b
->names
;
949 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
952 /* Pop the current binding level, reinstalling values for the previous
958 struct binding_level
*b
= current_binding_level
;
959 tree label
= b
->names
;
960 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
963 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
964 TREE_VALUE (b
->shadowed
);
966 /* Pop the current level, and free the structure for reuse. */
967 current_binding_level
= current_binding_level
->level_chain
;
968 b
->level_chain
= free_binding_level
;
969 free_binding_level
= b
;
972 /* Record a decl-node X as belonging to the current lexical scope.
973 Check for errors (such as an incompatible declaration for the same
974 name already seen in the same scope).
976 Returns either X or an old decl for the same name.
977 If an old decl is returned, it may have been smashed
978 to agree with what X says. */
985 register tree name
= DECL_NAME (x
);
986 register struct binding_level
*b
= current_binding_level
;
988 if (TREE_CODE (x
) != TYPE_DECL
)
989 DECL_CONTEXT (x
) = current_function_decl
;
995 t
= lookup_name_current_level (name
);
996 if (t
!= 0 && t
== error_mark_node
)
997 /* error_mark_node is 0 for a while during initialization! */
1000 error_with_decl (x
, "`%s' used prior to declaration");
1005 file
= DECL_SOURCE_FILE (t
);
1006 line
= DECL_SOURCE_LINE (t
);
1009 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1010 to point to the TYPE_DECL.
1011 Since Java does not have typedefs, a type can only have
1012 one (true) name, given by a class, interface, or builtin. */
1013 if (TREE_CODE (x
) == TYPE_DECL
1014 && TYPE_NAME (TREE_TYPE (x
)) == 0
1015 && TREE_TYPE (x
) != error_mark_node
)
1017 TYPE_NAME (TREE_TYPE (x
)) = x
;
1018 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1021 /* This name is new in its binding level.
1022 Install the new declaration and return it. */
1023 if (b
== global_binding_level
)
1025 /* Install a global value. */
1027 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1031 /* Here to install a non-global value. */
1032 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1033 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1036 /* Warn if shadowing an argument at the top level of the body. */
1037 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1038 /* This warning doesn't apply to the parms of a nested fcn. */
1039 && ! current_binding_level
->parm_flag
1040 /* Check that this is one level down from the parms. */
1041 && current_binding_level
->level_chain
->parm_flag
1042 /* Check that the decl being shadowed
1043 comes from the parm level, one level up. */
1044 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1046 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1047 pedwarn ("declaration of `%s' shadows a parameter",
1048 IDENTIFIER_POINTER (name
));
1050 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1051 IDENTIFIER_POINTER (name
));
1054 /* Maybe warn if shadowing something else. */
1055 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1056 /* No shadow warnings for internally generated vars. */
1057 && DECL_SOURCE_LINE (x
) != 0
1058 /* No shadow warnings for vars made for inlining. */
1059 && ! DECL_FROM_INLINE (x
))
1061 const char *warnstring
= 0;
1063 if (TREE_CODE (x
) == PARM_DECL
1064 && current_binding_level
->level_chain
->parm_flag
)
1065 /* Don't warn about the parm names in function declarator
1066 within a function declarator.
1067 It would be nice to avoid warning in any function
1068 declarator in a declaration, as opposed to a definition,
1069 but there is no way to tell it's not a definition. */
1071 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1072 warnstring
= "declaration of `%s' shadows a parameter";
1073 else if (oldlocal
!= 0)
1074 warnstring
= "declaration of `%s' shadows previous local";
1075 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1076 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1077 warnstring
= "declaration of `%s' shadows global declaration";
1080 warning (warnstring
, IDENTIFIER_POINTER (name
));
1084 /* If storing a local value, there may already be one (inherited).
1085 If so, record it for restoration when this binding level ends. */
1087 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1091 /* Put decls on list in reverse order.
1092 We will reverse them later if necessary. */
1093 TREE_CHAIN (x
) = b
->names
;
1100 pushdecl_force_head (x
)
1103 current_binding_level
->names
= x
;
1106 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1109 pushdecl_top_level (x
)
1113 register struct binding_level
*b
= current_binding_level
;
1115 current_binding_level
= global_binding_level
;
1117 current_binding_level
= b
;
1121 /* Nonzero if we are currently in the global binding level. */
1124 global_bindings_p ()
1126 return current_binding_level
== global_binding_level
;
1129 /* Return the list of declarations of the current level.
1130 Note that this list is in reverse order unless/until
1131 you nreverse it; and when you do nreverse it, you must
1132 store the result back using `storedecls' or you will lose. */
1137 return current_binding_level
->names
;
1140 /* Create a new `struct binding_level'. */
1142 static struct binding_level
*
1143 make_binding_level ()
1146 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
1151 int unused ATTRIBUTE_UNUSED
;
1153 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1156 /* If this is the top level of a function,
1157 just make sure that NAMED_LABELS is 0. */
1159 if (current_binding_level
== global_binding_level
)
1163 /* Reuse or create a struct for this binding level. */
1165 if (free_binding_level
)
1167 newlevel
= free_binding_level
;
1168 free_binding_level
= free_binding_level
->level_chain
;
1172 newlevel
= make_binding_level ();
1175 /* Add this level to the front of the chain (stack) of levels that
1178 *newlevel
= clear_binding_level
;
1179 newlevel
->level_chain
= current_binding_level
;
1180 current_binding_level
= newlevel
;
1181 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1182 newlevel
->binding_depth
= binding_depth
;
1184 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1185 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1188 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1191 /* Exit a binding level.
1192 Pop the level off, and restore the state of the identifier-decl mappings
1193 that were in effect when this level was entered.
1195 If KEEP is nonzero, this level had explicit declarations, so
1196 and create a "block" (a BLOCK node) for the level
1197 to record its declarations and subblocks for symbol table output.
1199 If FUNCTIONBODY is nonzero, this level is the body of a function,
1200 so create a block as if KEEP were set and also clear out all
1203 If REVERSE is nonzero, reverse the order of decls before putting
1204 them into the BLOCK. */
1207 poplevel (keep
, reverse
, functionbody
)
1213 /* The chain of decls was accumulated in reverse order.
1214 Put it into forward order, just for cleanliness. */
1216 tree subblocks
= current_binding_level
->blocks
;
1219 int block_previously_created
;
1221 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1224 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1225 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1226 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1227 current_binding_level
->end_pc
);
1229 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1230 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1232 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1235 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1239 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1241 /* Get the decls in the order they were written.
1242 Usually current_binding_level->names is in reverse order.
1243 But parameter decls were previously put in forward order. */
1246 current_binding_level
->names
1247 = decls
= nreverse (current_binding_level
->names
);
1249 decls
= current_binding_level
->names
;
1251 /* Output any nested inline functions within this block
1252 if they weren't already output. */
1254 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1255 if (TREE_CODE (decl
) == FUNCTION_DECL
1256 && ! TREE_ASM_WRITTEN (decl
)
1257 && DECL_INITIAL (decl
) != 0
1258 && TREE_ADDRESSABLE (decl
))
1260 /* If this decl was copied from a file-scope decl
1261 on account of a block-scope extern decl,
1262 propagate TREE_ADDRESSABLE to the file-scope decl.
1264 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1265 true, since then the decl goes through save_for_inline_copying. */
1266 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1267 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1268 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1271 push_function_context ();
1272 output_inline_function (decl
);
1273 pop_function_context ();
1277 /* If there were any declarations in that level,
1278 or if this level is a function body,
1279 create a BLOCK to record them for the life of this function. */
1282 block_previously_created
= (current_binding_level
->this_block
!= 0);
1283 if (block_previously_created
)
1284 block
= current_binding_level
->this_block
;
1285 else if (keep
|| functionbody
)
1286 block
= make_node (BLOCK
);
1289 BLOCK_VARS (block
) = decls
;
1290 BLOCK_SUBBLOCKS (block
) = subblocks
;
1293 /* In each subblock, record that this is its superior. */
1295 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1296 BLOCK_SUPERCONTEXT (link
) = block
;
1298 /* Clear out the meanings of the local variables of this level. */
1300 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1302 tree name
= DECL_NAME (link
);
1303 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1305 /* If the ident. was used or addressed via a local extern decl,
1306 don't forget that fact. */
1307 if (DECL_EXTERNAL (link
))
1309 if (TREE_USED (link
))
1310 TREE_USED (name
) = 1;
1311 if (TREE_ADDRESSABLE (link
))
1312 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1314 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1318 /* Restore all name-meanings of the outer levels
1319 that were shadowed by this level. */
1321 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1322 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1324 /* If the level being exited is the top level of a function,
1325 check over all the labels, and clear out the current
1326 (function local) meanings of their names. */
1330 /* If this is the top level block of a function,
1331 the vars are the function's parameters.
1332 Don't leave them in the BLOCK because they are
1333 found in the FUNCTION_DECL instead. */
1335 BLOCK_VARS (block
) = 0;
1337 /* Clear out the definitions of all label names,
1338 since their scopes end here,
1339 and add them to BLOCK_VARS. */
1342 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1344 register tree label
= TREE_VALUE (link
);
1346 if (DECL_INITIAL (label
) == 0)
1348 error_with_decl (label
, "label `%s' used but not defined");
1349 /* Avoid crashing later. */
1350 define_label (input_filename
, lineno
,
1353 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1354 warning_with_decl (label
, "label `%s' defined but not used");
1355 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1357 /* Put the labels into the "variables" of the
1358 top-level block, so debugger can see them. */
1359 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1360 BLOCK_VARS (block
) = label
;
1365 /* Pop the current level, and free the structure for reuse. */
1368 register struct binding_level
*level
= current_binding_level
;
1369 current_binding_level
= current_binding_level
->level_chain
;
1371 level
->level_chain
= free_binding_level
;
1372 free_binding_level
= level
;
1375 /* Dispose of the block that we just made inside some higher level. */
1377 DECL_INITIAL (current_function_decl
) = block
;
1380 if (!block_previously_created
)
1381 current_binding_level
->blocks
1382 = chainon (current_binding_level
->blocks
, block
);
1384 /* If we did not make a block for the level just exited,
1385 any blocks made for inner levels
1386 (since they cannot be recorded as subblocks in that level)
1387 must be carried forward so they will later become subblocks
1388 of something else. */
1390 current_binding_level
->blocks
1391 = chainon (current_binding_level
->blocks
, subblocks
);
1393 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1394 binding contour so that they point to the appropriate construct, i.e.
1395 either to the current FUNCTION_DECL node, or else to the BLOCK node
1396 we just constructed.
1398 Note that for tagged types whose scope is just the formal parameter
1399 list for some function type specification, we can't properly set
1400 their TYPE_CONTEXTs here, because we don't have a pointer to the
1401 appropriate FUNCTION_TYPE node readily available to us. For those
1402 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1403 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1404 node which will represent the "scope" for these "parameter list local"
1409 TREE_USED (block
) = 1;
1414 maybe_pushlevels (pc
)
1417 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1421 while (pending_local_decls
!= NULL_TREE
&&
1422 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1424 tree
*ptr
= &pending_local_decls
;
1426 int end_pc
= DECL_LOCAL_END_PC (decl
);
1428 while (*ptr
!= NULL_TREE
1429 && DECL_LOCAL_START_PC (*ptr
) <= pc
1430 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1431 ptr
= &TREE_CHAIN (*ptr
);
1432 pending_local_decls
= *ptr
;
1435 /* Force non-nested range to be nested in current range. */
1436 if (end_pc
> current_binding_level
->end_pc
)
1437 end_pc
= current_binding_level
->end_pc
;
1439 maybe_start_try (pc
, end_pc
);
1442 expand_start_bindings (0);
1444 current_binding_level
->end_pc
= end_pc
;
1445 current_binding_level
->start_pc
= pc
;
1446 current_binding_level
->names
= decl
;
1447 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1449 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1453 maybe_start_try (pc
, 0);
1457 maybe_poplevels (pc
)
1460 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1464 while (current_binding_level
->end_pc
<= pc
)
1466 expand_end_bindings (getdecls (), 1, 0);
1467 maybe_end_try (current_binding_level
->start_pc
, pc
);
1470 maybe_end_try (0, pc
);
1473 /* Terminate any binding which began during the range beginning at
1474 start_pc. This tidies up improperly nested local variable ranges
1475 and exception handlers; a variable declared within an exception
1476 range is forcibly terminated when that exception ends. */
1479 force_poplevels (start_pc
)
1482 while (current_binding_level
->start_pc
> start_pc
)
1484 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1485 warning_with_decl (current_function_decl
,
1486 "In %s: overlapped variable and exception ranges at %d",
1487 current_binding_level
->start_pc
);
1488 expand_end_bindings (getdecls (), 1, 0);
1493 /* Insert BLOCK at the end of the list of subblocks of the
1494 current binding level. This is used when a BIND_EXPR is expanded,
1495 to handle the BLOCK node inside the BIND_EXPR. */
1498 insert_block (block
)
1501 TREE_USED (block
) = 1;
1502 current_binding_level
->blocks
1503 = chainon (current_binding_level
->blocks
, block
);
1506 /* Set the BLOCK node for the innermost scope
1507 (the one we are currently in). */
1511 register tree block
;
1513 current_binding_level
->this_block
= block
;
1514 current_binding_level
->names
= chainon (current_binding_level
->names
,
1515 BLOCK_VARS (block
));
1516 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1517 BLOCK_SUBBLOCKS (block
));
1520 /* integrate_decl_tree calls this function. */
1523 copy_lang_decl (node
)
1527 = TREE_CODE (node
) == VAR_DECL
? sizeof (struct lang_decl_var
)
1528 : sizeof (struct lang_decl
);
1529 struct lang_decl
*x
= (struct lang_decl
*) ggc_alloc (lang_decl_size
);
1530 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1531 DECL_LANG_SPECIFIC (node
) = x
;
1534 /* If DECL has a cleanup, build and return that cleanup here.
1535 This is a callback called by expand_expr. */
1538 maybe_build_cleanup (decl
)
1539 tree decl ATTRIBUTE_UNUSED
;
1541 /* There are no cleanups in Java (I think). */
1546 give_name_to_locals (jcf
)
1549 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1550 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1552 pending_local_decls
= NULL_TREE
;
1556 n
= JCF_readu2 (jcf
);
1557 for (i
= 0; i
< n
; i
++)
1559 int start_pc
= JCF_readu2 (jcf
);
1560 int length
= JCF_readu2 (jcf
);
1561 int name_index
= JCF_readu2 (jcf
);
1562 int signature_index
= JCF_readu2 (jcf
);
1563 int slot
= JCF_readu2 (jcf
);
1564 tree name
= get_name_constant (jcf
, name_index
);
1565 tree type
= parse_signature (jcf
, signature_index
);
1566 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1568 && length
== DECL_CODE_LENGTH (current_function_decl
))
1570 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1571 DECL_NAME (decl
) = name
;
1572 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1573 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1574 warning ("bad type in parameter debug info");
1579 int end_pc
= start_pc
+ length
;
1580 tree decl
= build_decl (VAR_DECL
, name
, type
);
1581 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1583 warning_with_decl (decl
,
1584 "bad PC range for debug info for local `%s'");
1585 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1588 /* Adjust start_pc if necessary so that the local's first
1589 store operation will use the relevant DECL as a
1590 destination. Fore more information, read the leading
1591 comments for expr.c:maybe_adjust_start_pc. */
1592 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1594 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1595 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1596 DECL_LOCAL_START_PC (decl
) = start_pc
;
1598 /* FIXME: The range used internally for exceptions and local
1599 variable ranges, is a half-open interval:
1600 start_pc <= pc < end_pc. However, the range used in the
1601 Java VM spec is inclusive at both ends:
1602 start_pc <= pc <= end_pc. */
1605 DECL_LOCAL_END_PC (decl
) = end_pc
;
1607 /* Now insert the new decl in the proper place in
1608 pending_local_decls. We are essentially doing an insertion sort,
1609 which works fine, since the list input will normally already
1611 ptr
= &pending_local_decls
;
1612 while (*ptr
!= NULL_TREE
1613 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1614 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1615 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1616 ptr
= &TREE_CHAIN (*ptr
);
1617 TREE_CHAIN (decl
) = *ptr
;
1622 pending_local_decls
= nreverse (pending_local_decls
);
1624 /* Fill in default names for the parameters. */
1625 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1626 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1628 if (DECL_NAME (parm
) == NULL_TREE
)
1630 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1632 DECL_NAME (parm
) = get_identifier ("this");
1636 sprintf (buffer
, "ARG_%d", arg_i
);
1637 DECL_NAME (parm
) = get_identifier (buffer
);
1639 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1645 build_result_decl (fndecl
)
1648 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1649 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1650 if (INTEGRAL_TYPE_P (restype
)
1651 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1652 restype
= integer_type_node
;
1653 return (DECL_RESULT (fndecl
) = build_decl (RESULT_DECL
, NULL_TREE
, restype
));
1656 /* Called for every element in DECL_FUNCTION_INIT_TEST_TABLE in order
1657 to emit initialization code for each test flag. */
1660 emit_init_test_initialization (entry
, key
)
1661 struct hash_entry
*entry
;
1662 hash_table_key key ATTRIBUTE_UNUSED
;
1664 struct init_test_hash_entry
*ite
= (struct init_test_hash_entry
*) entry
;
1665 tree klass
= build_class_ref ((tree
) entry
->key
);
1666 expand_decl (ite
->init_test_decl
);
1668 /* We initialize the class init check variable by looking at the
1669 `state' field of the class to see if it is already initialized.
1670 This makes things a bit faster if the class is already
1671 initialized, which should be the common case. */
1673 (build (MODIFY_EXPR
, boolean_type_node
,
1674 ite
->init_test_decl
,
1675 build (GE_EXPR
, boolean_type_node
,
1676 build (COMPONENT_REF
, byte_type_node
,
1677 build1 (INDIRECT_REF
, class_type_node
, klass
),
1678 lookup_field (&class_type_node
,
1679 get_identifier ("state"))),
1680 build_int_2 (JV_STATE_DONE
, 0))));
1686 complete_start_java_method (fndecl
)
1689 if (! flag_emit_class_files
)
1691 /* Initialize the RTL code for the function. */
1692 init_function_start (fndecl
, input_filename
, lineno
);
1694 /* Set up parameters and prepare for return, for the function. */
1695 expand_function_start (fndecl
, 0);
1697 /* Emit initialization code for test flags. */
1698 if (! always_initialize_class_p
)
1699 hash_traverse (&DECL_FUNCTION_INIT_TEST_TABLE (fndecl
),
1700 emit_init_test_initialization
, 0);
1704 /* If this fcn was already referenced via a block-scope `extern' decl (or
1705 an implicit decl), propagate certain information about the usage. */
1706 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1707 TREE_ADDRESSABLE (current_function_decl
) = 1;
1711 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1712 && ! flag_emit_class_files
1713 && ! DECL_CLINIT_P (fndecl
)
1714 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1716 tree clas
= DECL_CONTEXT (fndecl
);
1717 tree init
= build (CALL_EXPR
, void_type_node
,
1718 build_address_of (soft_initclass_node
),
1719 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1721 TREE_SIDE_EFFECTS (init
) = 1;
1722 expand_expr_stmt (init
);
1725 /* Push local variables. Function compiled from source code are
1726 using a different local variables management, and for them,
1727 pushlevel shouldn't be called from here. */
1728 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1731 if (! flag_emit_class_files
)
1732 expand_start_bindings (1);
1735 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1737 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1738 tree enter
, exit
, lock
;
1739 if (METHOD_STATIC (fndecl
))
1740 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1742 lock
= DECL_ARGUMENTS (fndecl
);
1743 BUILD_MONITOR_ENTER (enter
, lock
);
1744 BUILD_MONITOR_EXIT (exit
, lock
);
1745 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1747 expand_expr_stmt (enter
);
1748 expand_decl_cleanup (NULL_TREE
, exit
);
1752 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1753 tree body
= BLOCK_EXPR_BODY (function_body
);
1754 lock
= build (WITH_CLEANUP_EXPR
, void_type_node
,
1755 enter
, NULL_TREE
, exit
);
1756 TREE_SIDE_EFFECTS (lock
) = 1;
1757 lock
= build (COMPOUND_EXPR
, TREE_TYPE (body
), lock
, body
);
1758 TREE_SIDE_EFFECTS (lock
) = 1;
1759 lock
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (body
), lock
);
1760 TREE_SIDE_EFFECTS (lock
) = 1;
1761 BLOCK_EXPR_BODY (function_body
) = lock
;
1767 start_java_method (fndecl
)
1773 current_function_decl
= fndecl
;
1774 announce_function (fndecl
);
1776 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1777 decl_map
= make_tree_vec (i
);
1778 type_map
= (tree
*) xrealloc (type_map
, i
* sizeof (tree
));
1780 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1781 fprintf (stderr
, "%s:\n", (*decl_printable_name
) (fndecl
, 2));
1783 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1784 pushlevel (1); /* Push parameters. */
1786 ptr
= &DECL_ARGUMENTS (fndecl
);
1787 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1788 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1790 tree parm_name
= NULL_TREE
, parm_decl
;
1791 tree parm_type
= TREE_VALUE (tem
);
1792 if (i
>= DECL_MAX_LOCALS (fndecl
))
1795 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1796 DECL_CONTEXT (parm_decl
) = fndecl
;
1797 if (PROMOTE_PROTOTYPES
1798 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1799 && INTEGRAL_TYPE_P (parm_type
))
1800 parm_type
= integer_type_node
;
1801 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1804 ptr
= &TREE_CHAIN (parm_decl
);
1806 /* Add parm_decl to the decl_map. */
1807 push_jvm_slot (i
, parm_decl
);
1809 type_map
[i
] = TREE_TYPE (parm_decl
);
1810 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1813 type_map
[i
] = void_type_node
;
1817 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1819 while (i
< DECL_MAX_LOCALS(fndecl
))
1820 type_map
[i
++] = NULL_TREE
;
1822 build_result_decl (fndecl
);
1823 complete_start_java_method (fndecl
);
1829 tree fndecl
= current_function_decl
;
1830 int flag_flag_non_call_exceptions
= flag_non_call_exceptions
;
1832 expand_end_bindings (getdecls (), 1, 0);
1833 /* pop out of function */
1836 /* pop out of its parameters */
1839 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1843 /* Generate rtl for function exit. */
1844 expand_function_end (input_filename
, lineno
, 0);
1846 /* FIXME: If the current method contains any exception handlers,
1847 force flag_non_call_exceptions: this is necessary because signal
1848 handlers in libjava may throw exceptions. This is far from being
1849 a perfect solution, but it's better than doing nothing at all.*/
1851 flag_non_call_exceptions
= 1;
1853 /* Run the optimizers and output assembler code for this function. */
1854 rest_of_compilation (fndecl
);
1856 current_function_decl
= NULL_TREE
;
1857 flag_non_call_exceptions
= flag_flag_non_call_exceptions
;
1860 /* Mark language-specific parts of T for garbage-collection. */
1866 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1868 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
1869 ggc_mark_tree (li
->global_value
);
1870 ggc_mark_tree (li
->local_value
);
1871 ggc_mark_tree (li
->utf8_ref
);
1873 else if (TREE_CODE (t
) == VAR_DECL
1874 || TREE_CODE (t
) == PARM_DECL
1875 || TREE_CODE (t
) == FIELD_DECL
)
1877 struct lang_decl_var
*ldv
=
1878 ((struct lang_decl_var
*) DECL_LANG_SPECIFIC (t
));
1882 ggc_mark_tree (ldv
->slot_chain
);
1883 ggc_mark_tree (ldv
->am
);
1884 ggc_mark_tree (ldv
->wfl
);
1887 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1889 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
1894 ggc_mark_tree (ld
->wfl
);
1895 ggc_mark_tree (ld
->throws_list
);
1896 ggc_mark_tree (ld
->function_decl_body
);
1897 ggc_mark_tree (ld
->called_constructor
);
1898 ggc_mark_tree (ld
->inner_access
);
1901 else if (TYPE_P (t
))
1903 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
1908 ggc_mark_tree (lt
->signature
);
1909 ggc_mark_tree (lt
->cpool_data_ref
);
1910 ggc_mark_tree (lt
->finit_stmt_list
);
1911 ggc_mark_tree (lt
->clinit_stmt_list
);
1912 ggc_mark_tree (lt
->ii_block
);
1913 ggc_mark_tree (lt
->dot_class
);
1914 ggc_mark_tree (lt
->package_list
);