1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
35 #include "java-tree.h"
41 #include "java-except.h"
44 #if defined (DEBUG_JAVA_BINDING_LEVELS)
45 extern void indent
PROTO((void));
48 static tree push_jvm_slot
PARAMS ((int, tree
));
49 static tree lookup_name_current_level
PARAMS ((tree
));
50 static tree push_promoted_type
PARAMS ((const char *, tree
));
51 static struct binding_level
*make_binding_level
PARAMS ((void));
52 static tree create_primitive_vtable
PARAMS ((const char *));
53 static tree check_local_named_variable
PARAMS ((tree
, tree
, int, int *));
54 static tree check_local_unnamed_variable
PARAMS ((tree
, tree
, tree
));
56 /* Set to non-zero value in order to emit class initilization code
57 before static field references. */
58 extern int always_initialize_class_p
;
60 /* The DECL_MAP is a mapping from (index, type) to a decl node.
61 If index < max_locals, it is the index of a local variable.
62 if index >= max_locals, then index-max_locals is a stack slot.
63 The DECL_MAP mapping is represented as a TREE_VEC whose elements
64 are a list of decls (VAR_DECL or PARM_DECL) chained by
65 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
66 we search the chain for a decl with a matching TREE_TYPE. */
70 /* A list of local variables VAR_DECLs for this method that we have seen
71 debug information, but we have not reached their starting (byte) PC yet. */
73 static tree pending_local_decls
= NULL_TREE
;
75 /* Push a local variable or stack slot into the decl_map,
76 and assign it an rtl. */
78 #if defined(DEBUG_JAVA_BINDING_LEVELS)
79 int binding_depth
= 0;
80 int is_class_level
= 0;
88 for (i
= 0; i
< binding_depth
*2; i
++)
91 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
94 push_jvm_slot (index
, decl
)
98 struct rtx_def
*rtl
= NULL
;
99 tree type
= TREE_TYPE (decl
);
102 DECL_CONTEXT (decl
) = current_function_decl
;
103 layout_decl (decl
, 0);
105 /* See if we have an appropriate rtl (i.e. same mode) at this index.
106 If so, we must use it. */
107 tmp
= TREE_VEC_ELT (decl_map
, index
);
108 while (tmp
!= NULL_TREE
)
110 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
111 rtl
= DECL_RTL_IF_SET (tmp
);
114 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
117 SET_DECL_RTL (decl
, rtl
);
120 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
121 DECL_REGISTER (decl
) = 1;
125 /* Now link the decl into the decl_map. */
126 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
128 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
129 DECL_LOCAL_START_PC (decl
) = 0;
130 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
131 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
133 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
134 TREE_VEC_ELT (decl_map
, index
) = decl
;
138 /* Find out if 'decl' passed in fits the defined PC location better than
139 'best'. Return decl if it does, return best if it doesn't. If decl
140 is returned, then updated is set to true. */
143 check_local_named_variable (best
, decl
, pc
, updated
)
149 if (pc
>= DECL_LOCAL_START_PC (decl
)
150 && pc
< DECL_LOCAL_END_PC (decl
))
152 if (best
== NULL_TREE
153 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
154 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
164 /* Find the best declaration based upon type. If 'decl' fits 'type' better
165 than 'best', return 'decl'. Otherwise return 'best'. */
168 check_local_unnamed_variable (best
, decl
, type
)
173 if (TREE_TYPE (decl
) == type
174 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
175 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
176 && TYPE_PRECISION (type
) <= 32
177 && TREE_CODE (type
) != POINTER_TYPE
)
178 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
179 && type
== ptr_type_node
))
181 if (best
== NULL_TREE
182 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
190 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
191 that is valid at PC (or -1 if any pc).
192 If there is no existing matching decl, allocate one. */
195 find_local_variable (index
, type
, pc
)
200 tree decl
= TREE_VEC_ELT (decl_map
, index
);
201 tree best
= NULL_TREE
;
202 int found_scoped_var
= 0;
204 /* Scan through every declaration that has been created in this slot. */
205 while (decl
!= NULL_TREE
)
207 /* Variables created in give_name_to_locals() have a name and have
208 a specified scope, so we can handle them specifically. We want
209 to use the specific decls created for those so they are assigned
210 the right variables in the debugging information. */
211 if (DECL_NAME (decl
) != NULL_TREE
)
213 /* This is a variable we have a name for, so it has a scope
214 supplied in the class file. But it only matters when we
215 actually have a PC to use. If pc<0, then we are asking
216 for a stack slot and this decl won't be one of those. */
218 best
= check_local_named_variable (best
, decl
, pc
,
221 /* We scan for type information unless we found a variable in the
222 proper scope already. */
223 else if (!found_scoped_var
)
225 /* If we don't have scoping information for a variable, we use
226 a different method to look it up. */
227 best
= check_local_unnamed_variable (best
, decl
, type
);
230 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
233 if (best
!= NULL_TREE
)
236 /* If we don't find a match, create one with the type passed in. */
237 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
241 /* Same as find_local_index, except that INDEX is a stack index. */
244 find_stack_slot (index
, type
)
248 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
254 /* A chain of _DECL nodes for all variables, constants, functions,
255 * and typedef types. These are in the reverse of the order supplied.
259 /* For each level, a list of shadowed outer-level local definitions
260 to be restored when this level is popped.
261 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
262 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
265 /* For each level (except not the global one),
266 a chain of BLOCK nodes for all the levels
267 that were entered and exited one level down. */
270 /* The BLOCK node for this level, if one has been preallocated.
271 If 0, the BLOCK is allocated (if needed) when the level is popped. */
274 /* The binding level which this one is contained in (inherits from). */
275 struct binding_level
*level_chain
;
277 /* The bytecode PC that marks the end of this level. */
279 /* The bytecode PC that marks the start of this level. */
282 #if defined(DEBUG_JAVA_BINDING_LEVELS)
283 /* Binding depth at which this level began. */
284 unsigned binding_depth
;
285 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
288 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
290 /* The binding level currently in effect. */
292 static struct binding_level
*current_binding_level
;
294 /* A chain of binding_level structures awaiting reuse. */
296 static struct binding_level
*free_binding_level
;
298 /* The outermost binding level, for names of file scope.
299 This is created when the compiler is started and exists
300 through the entire run. */
302 static struct binding_level
*global_binding_level
;
304 /* A PC value bigger than any PC value we may ever may encounter. */
306 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
308 /* Binding level structures are initialized by copying this one. */
310 static struct binding_level clear_binding_level
311 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
312 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
315 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
316 that have names. Here so we can clear out their names' definitions
317 at the end of the function. */
319 static tree named_labels
;
321 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
323 static tree shadowed_labels
;
326 int flag_traditional
;
328 tree java_global_trees
[JTI_MAX
];
330 tree predef_filenames
[PREDEF_FILENAMES_SIZE
];
332 /* Build (and pushdecl) a "promoted type" for all standard
333 types shorter than int. */
336 push_promoted_type (name
, actual_type
)
340 tree type
= make_node (TREE_CODE (actual_type
));
342 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
343 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
345 tree in_min
= TYPE_MIN_VALUE (actual_type
);
346 tree in_max
= TYPE_MAX_VALUE (actual_type
);
348 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
349 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
350 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
351 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
352 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
354 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
358 /* Return a definition for a builtin function named NAME and whose data type
359 is TYPE. TYPE should be a function type with argument types.
360 FUNCTION_CODE tells later passes how to compile calls to this function.
361 See tree.h for its possible values.
363 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
364 the name to be called if we can't opencode the function. */
367 builtin_function (name
, type
, function_code
, class, library_name
)
371 enum built_in_class
class;
372 const char *library_name
;
374 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
375 DECL_EXTERNAL (decl
) = 1;
376 TREE_PUBLIC (decl
) = 1;
378 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
379 make_decl_rtl (decl
, NULL
);
381 DECL_BUILT_IN_CLASS (decl
) = class;
382 DECL_FUNCTION_CODE (decl
) = function_code
;
386 /* Return tree that represents a vtable for a primitive array. */
388 create_primitive_vtable (name
)
394 sprintf (buf
, "_Jv_%sVTable", name
);
395 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
396 DECL_EXTERNAL (r
) = 1;
401 init_decl_processing ()
403 register tree endlink
;
404 tree field
= NULL_TREE
;
407 init_class_processing ();
409 current_function_decl
= NULL
;
410 current_binding_level
= NULL_BINDING_LEVEL
;
411 free_binding_level
= NULL_BINDING_LEVEL
;
412 pushlevel (0); /* make the binding_level structure for global names */
413 global_binding_level
= current_binding_level
;
415 /* The code here must be similar to build_common_tree_nodes{,_2} in
416 tree.c, especially as to the order of initializing common nodes. */
417 error_mark_node
= make_node (ERROR_MARK
);
418 TREE_TYPE (error_mark_node
) = error_mark_node
;
420 /* Create sizetype first - needed for other types. */
421 initialize_sizetypes ();
423 byte_type_node
= make_signed_type (8);
424 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
425 short_type_node
= make_signed_type (16);
426 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
427 int_type_node
= make_signed_type (32);
428 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
429 long_type_node
= make_signed_type (64);
430 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
432 unsigned_byte_type_node
= make_unsigned_type (8);
433 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
434 unsigned_byte_type_node
));
435 unsigned_short_type_node
= make_unsigned_type (16);
436 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
437 unsigned_short_type_node
));
438 unsigned_int_type_node
= make_unsigned_type (32);
439 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
440 unsigned_int_type_node
));
441 unsigned_long_type_node
= make_unsigned_type (64);
442 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
443 unsigned_long_type_node
));
445 set_sizetype (make_unsigned_type (POINTER_SIZE
));
447 /* Define these next since types below may used them. */
448 integer_type_node
= type_for_size (INT_TYPE_SIZE
, 0);
449 integer_zero_node
= build_int_2 (0, 0);
450 integer_one_node
= build_int_2 (1, 0);
451 integer_two_node
= build_int_2 (2, 0);
452 integer_four_node
= build_int_2 (4, 0);
453 integer_minus_one_node
= build_int_2 (-1, -1);
455 size_zero_node
= size_int (0);
456 size_one_node
= size_int (1);
457 bitsize_zero_node
= bitsize_int (0);
458 bitsize_one_node
= bitsize_int (1);
459 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
461 long_zero_node
= build_int_2 (0, 0);
462 TREE_TYPE (long_zero_node
) = long_type_node
;
464 void_type_node
= make_node (VOID_TYPE
);
465 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
466 layout_type (void_type_node
); /* Uses size_zero_node */
467 ptr_type_node
= build_pointer_type (void_type_node
);
468 t
= make_node (VOID_TYPE
);
469 layout_type (t
); /* Uses size_zero_node */
470 return_address_type_node
= build_pointer_type (t
);
472 null_pointer_node
= build_int_2 (0, 0);
473 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
475 /* Used by the parser to represent empty statements and blocks. */
476 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
477 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
480 /* Make a type to be the domain of a few array types
481 whose domains don't really matter.
482 200 is small enough that it always fits in size_t
483 and large enough that it can hold most function names for the
484 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
485 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
487 char_type_node
= make_node (CHAR_TYPE
);
488 TYPE_PRECISION (char_type_node
) = 16;
489 fixup_unsigned_type (char_type_node
);
490 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
492 boolean_type_node
= make_node (BOOLEAN_TYPE
);
493 TYPE_PRECISION (boolean_type_node
) = 1;
494 fixup_unsigned_type (boolean_type_node
);
495 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
497 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
498 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
500 promoted_byte_type_node
501 = push_promoted_type ("promoted_byte", byte_type_node
);
502 promoted_short_type_node
503 = push_promoted_type ("promoted_short", short_type_node
);
504 promoted_char_type_node
505 = push_promoted_type ("promoted_char", char_type_node
);
506 promoted_boolean_type_node
507 = push_promoted_type ("promoted_boolean", boolean_type_node
);
509 float_type_node
= make_node (REAL_TYPE
);
510 TYPE_PRECISION (float_type_node
) = 32;
511 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
513 layout_type (float_type_node
);
515 double_type_node
= make_node (REAL_TYPE
);
516 TYPE_PRECISION (double_type_node
) = 64;
517 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
519 layout_type (double_type_node
);
521 float_zero_node
= build_real (float_type_node
, dconst0
);
522 double_zero_node
= build_real (double_type_node
, dconst0
);
524 /* These are the vtables for arrays of primitives. */
525 boolean_array_vtable
= create_primitive_vtable ("boolean");
526 byte_array_vtable
= create_primitive_vtable ("byte");
527 char_array_vtable
= create_primitive_vtable ("char");
528 short_array_vtable
= create_primitive_vtable ("short");
529 int_array_vtable
= create_primitive_vtable ("int");
530 long_array_vtable
= create_primitive_vtable ("long");
531 float_array_vtable
= create_primitive_vtable ("float");
532 double_array_vtable
= create_primitive_vtable ("double");
534 /* As you're adding items here, please update the code right after
535 this section, so that the filename containing the source code of
536 the pre-defined class gets registered correctly. */
537 unqualified_object_id_node
= get_identifier ("Object");
538 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
539 object_ptr_type_node
= promote_type (object_type_node
);
540 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
541 string_ptr_type_node
= promote_type (string_type_node
);
542 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
543 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
544 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
545 runtime_exception_type_node
=
546 lookup_class (get_identifier ("java.lang.RuntimeException"));
547 error_exception_type_node
=
548 lookup_class (get_identifier ("java.lang.Error"));
549 class_not_found_type_node
=
550 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
551 no_class_def_found_type_node
=
552 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
554 rawdata_ptr_type_node
555 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
557 /* If you add to this section, don't forget to increase
558 PREDEF_FILENAMES_SIZE. */
559 predef_filenames
[0] = get_identifier ("java/lang/Class.java");
560 predef_filenames
[1] = get_identifier ("java/lang/Error.java");
561 predef_filenames
[2] = get_identifier ("java/lang/Object.java");
562 predef_filenames
[3] = get_identifier ("java/lang/RuntimeException.java");
563 predef_filenames
[4] = get_identifier ("java/lang/String.java");
564 predef_filenames
[5] = get_identifier ("java/lang/Throwable.java");
565 predef_filenames
[6] = get_identifier ("gnu/gcj/RawData.java");
566 predef_filenames
[7] = get_identifier ("java/lang/Exception");
567 predef_filenames
[8] = get_identifier ("java/lang/ClassNotFoundException");
568 predef_filenames
[9] = get_identifier ("java/lang/NoClassDefFoundError");
570 methodtable_type
= make_node (RECORD_TYPE
);
571 layout_type (methodtable_type
);
572 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
573 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
575 TYPE_identifier_node
= get_identifier ("TYPE");
576 init_identifier_node
= get_identifier ("<init>");
577 clinit_identifier_node
= get_identifier ("<clinit>");
578 /* Legacy `$finit$' special method identifier. This needs to be
579 recognized as equivalent to `finit$' but isn't generated anymore. */
580 finit_leg_identifier_node
= get_identifier ("$finit$");
581 /* The new `finit$' special method identifier. This one is now
582 generated in place of `$finit$'. */
583 finit_identifier_node
= get_identifier ("finit$");
584 instinit_identifier_node
= get_identifier ("instinit$");
585 void_signature_node
= get_identifier ("()V");
586 length_identifier_node
= get_identifier ("length");
587 this_identifier_node
= get_identifier ("this");
588 super_identifier_node
= get_identifier ("super");
589 continue_identifier_node
= get_identifier ("continue");
590 access0_identifier_node
= get_identifier ("access$0");
591 classdollar_identifier_node
= get_identifier ("class$");
593 /* for lack of a better place to put this stub call */
594 init_expr_processing();
596 utf8const_type
= make_node (RECORD_TYPE
);
597 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
598 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
599 FINISH_RECORD (utf8const_type
);
600 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
602 constants_type_node
= make_node (RECORD_TYPE
);
603 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
604 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
605 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
606 FINISH_RECORD (constants_type_node
);
607 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
609 access_flags_type_node
= unsigned_short_type_node
;
611 dtable_type
= make_node (RECORD_TYPE
);
612 dtable_ptr_type
= build_pointer_type (dtable_type
);
614 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
615 /* This isn't exactly true, but it is what we have in the source.
616 There is an unresolved issue here, which is whether the vtable
617 should be marked by the GC. */
618 if (! flag_hash_synchronization
)
619 PUSH_FIELD (object_type_node
, field
, "sync_info",
620 build_pointer_type (object_type_node
));
621 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
622 FIELD_PRIVATE (t
) = 1;
623 FINISH_RECORD (object_type_node
);
625 field_type_node
= make_node (RECORD_TYPE
);
626 field_ptr_type_node
= build_pointer_type (field_type_node
);
627 method_type_node
= make_node (RECORD_TYPE
);
628 method_ptr_type_node
= build_pointer_type (method_type_node
);
630 set_super_info (0, class_type_node
, object_type_node
, 0);
631 set_super_info (0, string_type_node
, object_type_node
, 0);
632 class_ptr_type
= build_pointer_type (class_type_node
);
634 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
635 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
636 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
637 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
638 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
639 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
640 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
641 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
642 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
643 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
644 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
645 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
646 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
647 PUSH_FIELD (class_type_node
, field
, "interfaces",
648 build_pointer_type (class_ptr_type
));
649 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
650 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
651 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
652 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
653 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
654 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
655 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
656 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
657 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
658 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
659 FIELD_PRIVATE (t
) = 1;
660 push_super_field (class_type_node
, object_type_node
);
661 FINISH_RECORD (class_type_node
);
662 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
664 field_info_union_node
= make_node (UNION_TYPE
);
665 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
666 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
668 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
670 layout_type (field_info_union_node
);
672 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
673 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
674 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
675 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
676 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
677 FINISH_RECORD (field_type_node
);
678 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
680 one_elt_array_domain_type
= build_index_type (integer_one_node
);
681 nativecode_ptr_array_type_node
682 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
684 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
685 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
686 FINISH_RECORD (dtable_type
);
687 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
689 #define jint_type int_type_node
690 #define jint_ptr_type ptr_type_node
692 jexception_type
= make_node (RECORD_TYPE
);
693 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
694 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
695 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
696 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
697 FINISH_RECORD (jexception_type
);
698 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
699 jexception_ptr_type
= build_pointer_type (jexception_type
);
701 lineNumberEntry_type
= make_node (RECORD_TYPE
);
702 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
703 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
704 FINISH_RECORD (lineNumberEntry_type
);
706 lineNumbers_type
= make_node (RECORD_TYPE
);
707 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
708 FINISH_RECORD (lineNumbers_type
);
710 #define instn_ptr_type_node ptr_type_node /* XXX JH */
712 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
714 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
715 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
716 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
717 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
718 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
719 FINISH_RECORD (method_type_node
);
720 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
722 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
724 t
= tree_cons (NULL_TREE
, class_ptr_type
,
725 tree_cons (NULL_TREE
, int_type_node
, endlink
));
726 alloc_object_node
= builtin_function ("_Jv_AllocObject",
727 build_function_type (ptr_type_node
, t
),
728 0, NOT_BUILT_IN
, NULL
);
729 DECL_IS_MALLOC (alloc_object_node
) = 1;
731 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
732 soft_initclass_node
= builtin_function ("_Jv_InitClass",
733 build_function_type (void_type_node
,
735 0, NOT_BUILT_IN
, NULL
);
737 throw_node
= builtin_function ("_Jv_Throw",
738 build_function_type (ptr_type_node
, t
),
739 0, NOT_BUILT_IN
, NULL
);
740 /* Mark throw_nodes as `noreturn' functions with side effects. */
741 TREE_THIS_VOLATILE (throw_node
) = 1;
742 TREE_SIDE_EFFECTS (throw_node
) = 1;
744 t
= build_function_type (int_type_node
, endlink
);
745 soft_monitorenter_node
746 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
, NULL
);
747 soft_monitorexit_node
748 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
, NULL
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
832 soft_jnipopsystemframe_node
833 = builtin_function ("_Jv_JNI_PopSystemFrame",
834 build_function_type (ptr_type_node
, t
),
835 0, NOT_BUILT_IN
, NULL
);
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");
845 t
= tree_cons (NULL_TREE
, float_type_node
,
846 tree_cons (NULL_TREE
, float_type_node
, endlink
));
848 = builtin_function ("__builtin_fmodf",
849 build_function_type (float_type_node
, t
),
850 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf");
854 = builtin_function ("_Jv_divI",
855 build_function_type (int_type_node
, t
),
856 0, NOT_BUILT_IN
, NULL
);
859 = builtin_function ("_Jv_remI",
860 build_function_type (int_type_node
, t
),
861 0, NOT_BUILT_IN
, NULL
);
864 = builtin_function ("_Jv_divJ",
865 build_function_type (long_type_node
, t
),
866 0, NOT_BUILT_IN
, NULL
);
869 = builtin_function ("_Jv_remJ",
870 build_function_type (long_type_node
, t
),
871 0, NOT_BUILT_IN
, NULL
);
873 /* Initialize variables for except.c. */
874 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
875 ? "__gcj_personality_sj0"
876 : "__gcj_personality_v0");
877 lang_eh_runtime_type
= prepare_eh_table_type
;
881 /* Register nodes with the garbage collector. */
882 ggc_add_tree_root (java_global_trees
,
883 sizeof (java_global_trees
) / sizeof (tree
));
884 ggc_add_tree_root (predef_filenames
,
885 sizeof (predef_filenames
) / sizeof (tree
));
886 ggc_add_tree_root (&decl_map
, 1);
887 ggc_add_tree_root (&pending_local_decls
, 1);
891 /* Look up NAME in the current binding level and its superiors
892 in the namespace of variables, functions and typedefs.
893 Return a ..._DECL node of some kind representing its definition,
894 or return 0 if it is undefined. */
901 if (current_binding_level
!= global_binding_level
902 && IDENTIFIER_LOCAL_VALUE (name
))
903 val
= IDENTIFIER_LOCAL_VALUE (name
);
905 val
= IDENTIFIER_GLOBAL_VALUE (name
);
909 /* Similar to `lookup_name' but look only at current binding level and
910 the previous one if its the parameter level. */
913 lookup_name_current_level (name
)
918 if (current_binding_level
== global_binding_level
)
919 return IDENTIFIER_GLOBAL_VALUE (name
);
921 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
924 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
925 if (DECL_NAME (t
) == name
)
931 /* Use a binding level to record a labeled block declaration */
934 push_labeled_block (lb
)
937 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
938 register struct binding_level
*b
= current_binding_level
;
939 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
941 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
942 TREE_CHAIN (lb
) = b
->names
;
944 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
947 /* Pop the current binding level, reinstalling values for the previous
953 struct binding_level
*b
= current_binding_level
;
954 tree label
= b
->names
;
955 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
958 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
959 TREE_VALUE (b
->shadowed
);
961 /* Pop the current level, and free the structure for reuse. */
962 current_binding_level
= current_binding_level
->level_chain
;
963 b
->level_chain
= free_binding_level
;
964 free_binding_level
= b
;
967 /* Record a decl-node X as belonging to the current lexical scope.
968 Check for errors (such as an incompatible declaration for the same
969 name already seen in the same scope).
971 Returns either X or an old decl for the same name.
972 If an old decl is returned, it may have been smashed
973 to agree with what X says. */
980 register tree name
= DECL_NAME (x
);
981 register struct binding_level
*b
= current_binding_level
;
983 if (TREE_CODE (x
) != TYPE_DECL
)
984 DECL_CONTEXT (x
) = current_function_decl
;
990 t
= lookup_name_current_level (name
);
991 if (t
!= 0 && t
== error_mark_node
)
992 /* error_mark_node is 0 for a while during initialization! */
995 error_with_decl (x
, "`%s' used prior to declaration");
1000 file
= DECL_SOURCE_FILE (t
);
1001 line
= DECL_SOURCE_LINE (t
);
1004 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1005 to point to the TYPE_DECL.
1006 Since Java does not have typedefs, a type can only have
1007 one (true) name, given by a class, interface, or builtin. */
1008 if (TREE_CODE (x
) == TYPE_DECL
1009 && TYPE_NAME (TREE_TYPE (x
)) == 0
1010 && TREE_TYPE (x
) != error_mark_node
)
1012 TYPE_NAME (TREE_TYPE (x
)) = x
;
1013 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1016 /* This name is new in its binding level.
1017 Install the new declaration and return it. */
1018 if (b
== global_binding_level
)
1020 /* Install a global value. */
1022 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1026 /* Here to install a non-global value. */
1027 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1028 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1031 /* Warn if shadowing an argument at the top level of the body. */
1032 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1033 /* This warning doesn't apply to the parms of a nested fcn. */
1034 && ! current_binding_level
->parm_flag
1035 /* Check that this is one level down from the parms. */
1036 && current_binding_level
->level_chain
->parm_flag
1037 /* Check that the decl being shadowed
1038 comes from the parm level, one level up. */
1039 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1041 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1042 pedwarn ("declaration of `%s' shadows a parameter",
1043 IDENTIFIER_POINTER (name
));
1045 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1046 IDENTIFIER_POINTER (name
));
1049 /* Maybe warn if shadowing something else. */
1050 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1051 /* No shadow warnings for internally generated vars. */
1052 && DECL_SOURCE_LINE (x
) != 0
1053 /* No shadow warnings for vars made for inlining. */
1054 && ! DECL_FROM_INLINE (x
))
1056 const char *warnstring
= 0;
1058 if (TREE_CODE (x
) == PARM_DECL
1059 && current_binding_level
->level_chain
->parm_flag
)
1060 /* Don't warn about the parm names in function declarator
1061 within a function declarator.
1062 It would be nice to avoid warning in any function
1063 declarator in a declaration, as opposed to a definition,
1064 but there is no way to tell it's not a definition. */
1066 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1067 warnstring
= "declaration of `%s' shadows a parameter";
1068 else if (oldlocal
!= 0)
1069 warnstring
= "declaration of `%s' shadows previous local";
1070 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1071 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1072 warnstring
= "declaration of `%s' shadows global declaration";
1075 warning (warnstring
, IDENTIFIER_POINTER (name
));
1079 /* If storing a local value, there may already be one (inherited).
1080 If so, record it for restoration when this binding level ends. */
1082 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1086 /* Put decls on list in reverse order.
1087 We will reverse them later if necessary. */
1088 TREE_CHAIN (x
) = b
->names
;
1095 pushdecl_force_head (x
)
1098 current_binding_level
->names
= x
;
1101 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1104 pushdecl_top_level (x
)
1108 register struct binding_level
*b
= current_binding_level
;
1110 current_binding_level
= global_binding_level
;
1112 current_binding_level
= b
;
1116 /* Nonzero if we are currently in the global binding level. */
1119 global_bindings_p ()
1121 return current_binding_level
== global_binding_level
;
1124 /* Return the list of declarations of the current level.
1125 Note that this list is in reverse order unless/until
1126 you nreverse it; and when you do nreverse it, you must
1127 store the result back using `storedecls' or you will lose. */
1132 return current_binding_level
->names
;
1135 /* Create a new `struct binding_level'. */
1137 static struct binding_level
*
1138 make_binding_level ()
1141 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
1146 int unused ATTRIBUTE_UNUSED
;
1148 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1151 /* If this is the top level of a function,
1152 just make sure that NAMED_LABELS is 0. */
1154 if (current_binding_level
== global_binding_level
)
1158 /* Reuse or create a struct for this binding level. */
1160 if (free_binding_level
)
1162 newlevel
= free_binding_level
;
1163 free_binding_level
= free_binding_level
->level_chain
;
1167 newlevel
= make_binding_level ();
1170 /* Add this level to the front of the chain (stack) of levels that
1173 *newlevel
= clear_binding_level
;
1174 newlevel
->level_chain
= current_binding_level
;
1175 current_binding_level
= newlevel
;
1176 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1177 newlevel
->binding_depth
= binding_depth
;
1179 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1180 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1183 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1186 /* Exit a binding level.
1187 Pop the level off, and restore the state of the identifier-decl mappings
1188 that were in effect when this level was entered.
1190 If KEEP is nonzero, this level had explicit declarations, so
1191 and create a "block" (a BLOCK node) for the level
1192 to record its declarations and subblocks for symbol table output.
1194 If FUNCTIONBODY is nonzero, this level is the body of a function,
1195 so create a block as if KEEP were set and also clear out all
1198 If REVERSE is nonzero, reverse the order of decls before putting
1199 them into the BLOCK. */
1202 poplevel (keep
, reverse
, functionbody
)
1208 /* The chain of decls was accumulated in reverse order.
1209 Put it into forward order, just for cleanliness. */
1211 tree subblocks
= current_binding_level
->blocks
;
1214 int block_previously_created
;
1216 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1219 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1220 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1221 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1222 current_binding_level
->end_pc
);
1224 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1225 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1227 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1230 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1234 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1236 /* Get the decls in the order they were written.
1237 Usually current_binding_level->names is in reverse order.
1238 But parameter decls were previously put in forward order. */
1241 current_binding_level
->names
1242 = decls
= nreverse (current_binding_level
->names
);
1244 decls
= current_binding_level
->names
;
1246 /* Output any nested inline functions within this block
1247 if they weren't already output. */
1249 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1250 if (TREE_CODE (decl
) == FUNCTION_DECL
1251 && ! TREE_ASM_WRITTEN (decl
)
1252 && DECL_INITIAL (decl
) != 0
1253 && TREE_ADDRESSABLE (decl
))
1255 /* If this decl was copied from a file-scope decl
1256 on account of a block-scope extern decl,
1257 propagate TREE_ADDRESSABLE to the file-scope decl.
1259 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1260 true, since then the decl goes through save_for_inline_copying. */
1261 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1262 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1263 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1266 push_function_context ();
1267 output_inline_function (decl
);
1268 pop_function_context ();
1272 /* If there were any declarations in that level,
1273 or if this level is a function body,
1274 create a BLOCK to record them for the life of this function. */
1277 block_previously_created
= (current_binding_level
->this_block
!= 0);
1278 if (block_previously_created
)
1279 block
= current_binding_level
->this_block
;
1280 else if (keep
|| functionbody
)
1281 block
= make_node (BLOCK
);
1284 BLOCK_VARS (block
) = decls
;
1285 BLOCK_SUBBLOCKS (block
) = subblocks
;
1288 /* In each subblock, record that this is its superior. */
1290 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1291 BLOCK_SUPERCONTEXT (link
) = block
;
1293 /* Clear out the meanings of the local variables of this level. */
1295 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1297 tree name
= DECL_NAME (link
);
1298 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1300 /* If the ident. was used or addressed via a local extern decl,
1301 don't forget that fact. */
1302 if (DECL_EXTERNAL (link
))
1304 if (TREE_USED (link
))
1305 TREE_USED (name
) = 1;
1306 if (TREE_ADDRESSABLE (link
))
1307 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1309 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1313 /* Restore all name-meanings of the outer levels
1314 that were shadowed by this level. */
1316 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1317 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1319 /* If the level being exited is the top level of a function,
1320 check over all the labels, and clear out the current
1321 (function local) meanings of their names. */
1325 /* If this is the top level block of a function,
1326 the vars are the function's parameters.
1327 Don't leave them in the BLOCK because they are
1328 found in the FUNCTION_DECL instead. */
1330 BLOCK_VARS (block
) = 0;
1332 /* Clear out the definitions of all label names,
1333 since their scopes end here,
1334 and add them to BLOCK_VARS. */
1337 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1339 register tree label
= TREE_VALUE (link
);
1341 if (DECL_INITIAL (label
) == 0)
1343 error_with_decl (label
, "label `%s' used but not defined");
1344 /* Avoid crashing later. */
1345 define_label (input_filename
, lineno
,
1348 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1349 warning_with_decl (label
, "label `%s' defined but not used");
1350 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1352 /* Put the labels into the "variables" of the
1353 top-level block, so debugger can see them. */
1354 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1355 BLOCK_VARS (block
) = label
;
1360 /* Pop the current level, and free the structure for reuse. */
1363 register struct binding_level
*level
= current_binding_level
;
1364 current_binding_level
= current_binding_level
->level_chain
;
1366 level
->level_chain
= free_binding_level
;
1367 free_binding_level
= level
;
1370 /* Dispose of the block that we just made inside some higher level. */
1372 DECL_INITIAL (current_function_decl
) = block
;
1375 if (!block_previously_created
)
1376 current_binding_level
->blocks
1377 = chainon (current_binding_level
->blocks
, block
);
1379 /* If we did not make a block for the level just exited,
1380 any blocks made for inner levels
1381 (since they cannot be recorded as subblocks in that level)
1382 must be carried forward so they will later become subblocks
1383 of something else. */
1385 current_binding_level
->blocks
1386 = chainon (current_binding_level
->blocks
, subblocks
);
1388 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1389 binding contour so that they point to the appropriate construct, i.e.
1390 either to the current FUNCTION_DECL node, or else to the BLOCK node
1391 we just constructed.
1393 Note that for tagged types whose scope is just the formal parameter
1394 list for some function type specification, we can't properly set
1395 their TYPE_CONTEXTs here, because we don't have a pointer to the
1396 appropriate FUNCTION_TYPE node readily available to us. For those
1397 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1398 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1399 node which will represent the "scope" for these "parameter list local"
1404 TREE_USED (block
) = 1;
1409 maybe_pushlevels (pc
)
1412 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1416 while (pending_local_decls
!= NULL_TREE
&&
1417 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1419 tree
*ptr
= &pending_local_decls
;
1421 int end_pc
= DECL_LOCAL_END_PC (decl
);
1423 while (*ptr
!= NULL_TREE
1424 && DECL_LOCAL_START_PC (*ptr
) <= pc
1425 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1426 ptr
= &TREE_CHAIN (*ptr
);
1427 pending_local_decls
= *ptr
;
1430 /* Force non-nested range to be nested in current range. */
1431 if (end_pc
> current_binding_level
->end_pc
)
1432 end_pc
= current_binding_level
->end_pc
;
1434 maybe_start_try (pc
, end_pc
);
1437 expand_start_bindings (0);
1439 current_binding_level
->end_pc
= end_pc
;
1440 current_binding_level
->start_pc
= pc
;
1441 current_binding_level
->names
= decl
;
1442 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1444 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1448 maybe_start_try (pc
, 0);
1452 maybe_poplevels (pc
)
1455 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1459 while (current_binding_level
->end_pc
<= pc
)
1461 expand_end_bindings (getdecls (), 1, 0);
1462 maybe_end_try (current_binding_level
->start_pc
, pc
);
1465 maybe_end_try (0, pc
);
1468 /* Terminate any binding which began during the range beginning at
1469 start_pc. This tidies up improperly nested local variable ranges
1470 and exception handlers; a variable declared within an exception
1471 range is forcibly terminated when that exception ends. */
1474 force_poplevels (start_pc
)
1477 while (current_binding_level
->start_pc
> start_pc
)
1479 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1480 warning_with_decl (current_function_decl
,
1481 "In %s: overlapped variable and exception ranges at %d",
1482 current_binding_level
->start_pc
);
1483 expand_end_bindings (getdecls (), 1, 0);
1488 /* Insert BLOCK at the end of the list of subblocks of the
1489 current binding level. This is used when a BIND_EXPR is expanded,
1490 to handle the BLOCK node inside the BIND_EXPR. */
1493 insert_block (block
)
1496 TREE_USED (block
) = 1;
1497 current_binding_level
->blocks
1498 = chainon (current_binding_level
->blocks
, block
);
1501 /* Set the BLOCK node for the innermost scope
1502 (the one we are currently in). */
1506 register tree block
;
1508 current_binding_level
->this_block
= block
;
1509 current_binding_level
->names
= chainon (current_binding_level
->names
,
1510 BLOCK_VARS (block
));
1511 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1512 BLOCK_SUBBLOCKS (block
));
1515 /* integrate_decl_tree calls this function. */
1518 copy_lang_decl (node
)
1522 = TREE_CODE (node
) == VAR_DECL
? sizeof (struct lang_decl_var
)
1523 : sizeof (struct lang_decl
);
1524 struct lang_decl
*x
= (struct lang_decl
*) ggc_alloc (lang_decl_size
);
1525 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1526 DECL_LANG_SPECIFIC (node
) = x
;
1529 /* If DECL has a cleanup, build and return that cleanup here.
1530 This is a callback called by expand_expr. */
1533 maybe_build_cleanup (decl
)
1534 tree decl ATTRIBUTE_UNUSED
;
1536 /* There are no cleanups in Java (I think). */
1541 give_name_to_locals (jcf
)
1544 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1545 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1547 pending_local_decls
= NULL_TREE
;
1551 n
= JCF_readu2 (jcf
);
1552 for (i
= 0; i
< n
; i
++)
1554 int start_pc
= JCF_readu2 (jcf
);
1555 int length
= JCF_readu2 (jcf
);
1556 int name_index
= JCF_readu2 (jcf
);
1557 int signature_index
= JCF_readu2 (jcf
);
1558 int slot
= JCF_readu2 (jcf
);
1559 tree name
= get_name_constant (jcf
, name_index
);
1560 tree type
= parse_signature (jcf
, signature_index
);
1561 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1563 && length
== DECL_CODE_LENGTH (current_function_decl
))
1565 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1566 DECL_NAME (decl
) = name
;
1567 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1568 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1569 warning ("bad type in parameter debug info");
1574 int end_pc
= start_pc
+ length
;
1575 tree decl
= build_decl (VAR_DECL
, name
, type
);
1576 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1578 warning_with_decl (decl
,
1579 "bad PC range for debug info for local `%s'");
1580 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1583 /* Adjust start_pc if necessary so that the local's first
1584 store operation will use the relevant DECL as a
1585 destination. Fore more information, read the leading
1586 comments for expr.c:maybe_adjust_start_pc. */
1587 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1589 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1590 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1591 DECL_LOCAL_START_PC (decl
) = start_pc
;
1593 /* FIXME: The range used internally for exceptions and local
1594 variable ranges, is a half-open interval:
1595 start_pc <= pc < end_pc. However, the range used in the
1596 Java VM spec is inclusive at both ends:
1597 start_pc <= pc <= end_pc. */
1600 DECL_LOCAL_END_PC (decl
) = end_pc
;
1602 /* Now insert the new decl in the proper place in
1603 pending_local_decls. We are essentially doing an insertion sort,
1604 which works fine, since the list input will normally already
1606 ptr
= &pending_local_decls
;
1607 while (*ptr
!= NULL_TREE
1608 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1609 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1610 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1611 ptr
= &TREE_CHAIN (*ptr
);
1612 TREE_CHAIN (decl
) = *ptr
;
1617 pending_local_decls
= nreverse (pending_local_decls
);
1619 /* Fill in default names for the parameters. */
1620 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1621 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1623 if (DECL_NAME (parm
) == NULL_TREE
)
1625 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1627 DECL_NAME (parm
) = get_identifier ("this");
1631 sprintf (buffer
, "ARG_%d", arg_i
);
1632 DECL_NAME (parm
) = get_identifier (buffer
);
1634 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1640 build_result_decl (fndecl
)
1643 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1644 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1645 if (INTEGRAL_TYPE_P (restype
)
1646 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1647 restype
= integer_type_node
;
1648 return (DECL_RESULT (fndecl
) = build_decl (RESULT_DECL
, NULL_TREE
, restype
));
1652 complete_start_java_method (fndecl
)
1655 if (! flag_emit_class_files
)
1657 /* Initialize the RTL code for the function. */
1658 init_function_start (fndecl
, input_filename
, lineno
);
1660 /* Set up parameters and prepare for return, for the function. */
1661 expand_function_start (fndecl
, 0);
1665 /* If this fcn was already referenced via a block-scope `extern' decl (or
1666 an implicit decl), propagate certain information about the usage. */
1667 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1668 TREE_ADDRESSABLE (current_function_decl
) = 1;
1672 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1673 && ! flag_emit_class_files
1674 && ! DECL_CLINIT_P (fndecl
)
1675 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1677 tree clas
= DECL_CONTEXT (fndecl
);
1678 tree init
= build (CALL_EXPR
, void_type_node
,
1679 build_address_of (soft_initclass_node
),
1680 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1682 TREE_SIDE_EFFECTS (init
) = 1;
1683 expand_expr_stmt (init
);
1686 /* Push local variables. Function compiled from source code are
1687 using a different local variables management, and for them,
1688 pushlevel shouldn't be called from here. */
1689 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1692 if (! flag_emit_class_files
)
1693 expand_start_bindings (1);
1696 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1698 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1699 tree enter
, exit
, lock
;
1700 if (METHOD_STATIC (fndecl
))
1701 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1703 lock
= DECL_ARGUMENTS (fndecl
);
1704 BUILD_MONITOR_ENTER (enter
, lock
);
1705 BUILD_MONITOR_EXIT (exit
, lock
);
1706 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1708 expand_expr_stmt (enter
);
1709 expand_decl_cleanup (NULL_TREE
, exit
);
1713 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1714 tree body
= BLOCK_EXPR_BODY (function_body
);
1715 lock
= build (WITH_CLEANUP_EXPR
, void_type_node
,
1716 enter
, exit
, NULL_TREE
);
1717 TREE_SIDE_EFFECTS (lock
) = 1;
1718 lock
= build (COMPOUND_EXPR
, TREE_TYPE (body
), lock
, body
);
1719 TREE_SIDE_EFFECTS (lock
) = 1;
1720 lock
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (body
), lock
);
1721 TREE_SIDE_EFFECTS (lock
) = 1;
1722 BLOCK_EXPR_BODY (function_body
) = lock
;
1728 start_java_method (fndecl
)
1734 current_function_decl
= fndecl
;
1735 announce_function (fndecl
);
1737 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1738 decl_map
= make_tree_vec (i
);
1739 type_map
= (tree
*) xrealloc (type_map
, i
* sizeof (tree
));
1741 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1742 fprintf (stderr
, "%s:\n", (*decl_printable_name
) (fndecl
, 2));
1744 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1745 pushlevel (1); /* Push parameters. */
1747 ptr
= &DECL_ARGUMENTS (fndecl
);
1748 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1749 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1751 tree parm_name
= NULL_TREE
, parm_decl
;
1752 tree parm_type
= TREE_VALUE (tem
);
1753 if (i
>= DECL_MAX_LOCALS (fndecl
))
1756 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1757 DECL_CONTEXT (parm_decl
) = fndecl
;
1758 if (PROMOTE_PROTOTYPES
1759 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1760 && INTEGRAL_TYPE_P (parm_type
))
1761 parm_type
= integer_type_node
;
1762 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1765 ptr
= &TREE_CHAIN (parm_decl
);
1767 /* Add parm_decl to the decl_map. */
1768 push_jvm_slot (i
, parm_decl
);
1770 type_map
[i
] = TREE_TYPE (parm_decl
);
1771 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1774 type_map
[i
] = void_type_node
;
1778 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1780 while (i
< DECL_MAX_LOCALS(fndecl
))
1781 type_map
[i
++] = NULL_TREE
;
1783 build_result_decl (fndecl
);
1784 complete_start_java_method (fndecl
);
1790 tree fndecl
= current_function_decl
;
1792 expand_end_bindings (getdecls (), 1, 0);
1793 /* pop out of function */
1796 /* pop out of its parameters */
1799 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1801 /* Generate rtl for function exit. */
1802 expand_function_end (input_filename
, lineno
, 0);
1804 /* Run the optimizers and output assembler code for this function. */
1805 rest_of_compilation (fndecl
);
1807 current_function_decl
= NULL_TREE
;
1810 /* Mark language-specific parts of T for garbage-collection. */
1816 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1818 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
1819 ggc_mark_tree (li
->global_value
);
1820 ggc_mark_tree (li
->local_value
);
1821 ggc_mark_tree (li
->utf8_ref
);
1823 else if (TREE_CODE (t
) == VAR_DECL
1824 || TREE_CODE (t
) == PARM_DECL
1825 || TREE_CODE (t
) == FIELD_DECL
)
1827 struct lang_decl_var
*ldv
=
1828 ((struct lang_decl_var
*) DECL_LANG_SPECIFIC (t
));
1832 ggc_mark_tree (ldv
->slot_chain
);
1833 ggc_mark_tree (ldv
->am
);
1834 ggc_mark_tree (ldv
->wfl
);
1837 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1839 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
1844 ggc_mark_tree (ld
->wfl
);
1845 ggc_mark_tree (ld
->throws_list
);
1846 ggc_mark_tree (ld
->function_decl_body
);
1847 ggc_mark_tree (ld
->called_constructor
);
1848 ggc_mark_tree (ld
->inner_access
);
1849 ggc_mark_tree_hash_table (&ld
->init_test_table
);
1850 ggc_mark_tree_hash_table (&ld
->ict
);
1851 ggc_mark_tree_hash_table (&ld
->smic
);
1854 else if (TYPE_P (t
))
1856 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
1861 ggc_mark_tree (lt
->signature
);
1862 ggc_mark_tree (lt
->cpool_data_ref
);
1863 ggc_mark_tree (lt
->finit_stmt_list
);
1864 ggc_mark_tree (lt
->clinit_stmt_list
);
1865 ggc_mark_tree (lt
->ii_block
);
1866 ggc_mark_tree (lt
->dot_class
);
1867 ggc_mark_tree (lt
->package_list
);