1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
31 #include "coretypes.h"
38 #include "java-tree.h"
44 #include "java-except.h"
47 #include "tree-inline.h"
49 #if defined (DEBUG_JAVA_BINDING_LEVELS)
50 extern void indent (void);
53 static tree
push_jvm_slot (int, tree
);
54 static tree
lookup_name_current_level (tree
);
55 static tree
push_promoted_type (const char *, tree
);
56 static struct binding_level
*make_binding_level (void);
57 static tree
create_primitive_vtable (const char *);
58 static tree
check_local_named_variable (tree
, tree
, int, int *);
59 static tree
check_local_unnamed_variable (tree
, tree
, tree
);
60 static void dump_function (enum tree_dump_index
, tree
);
62 /* Name of the Cloneable class. */
63 tree java_lang_cloneable_identifier_node
;
65 /* Name of the Serializable class. */
66 tree java_io_serializable_identifier_node
;
68 /* Set to nonzero value in order to emit class initialization code
69 before static field references. */
70 extern int always_initialize_class_p
;
72 /* The DECL_MAP is a mapping from (index, type) to a decl node.
73 If index < max_locals, it is the index of a local variable.
74 if index >= max_locals, then index-max_locals is a stack slot.
75 The DECL_MAP mapping is represented as a TREE_VEC whose elements
76 are a list of decls (VAR_DECL or PARM_DECL) chained by
77 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
78 we search the chain for a decl with a matching TREE_TYPE. */
80 static GTY(()) tree decl_map
;
82 /* A list of local variables VAR_DECLs for this method that we have seen
83 debug information, but we have not reached their starting (byte) PC yet. */
85 static GTY(()) tree pending_local_decls
;
87 /* Push a local variable or stack slot into the decl_map,
88 and assign it an rtl. */
90 #if defined(DEBUG_JAVA_BINDING_LEVELS)
91 int binding_depth
= 0;
92 int is_class_level
= 0;
100 for (i
= 0; i
< binding_depth
*2; i
++)
103 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
106 push_jvm_slot (int index
, tree decl
)
108 struct rtx_def
*rtl
= NULL
;
109 tree type
= TREE_TYPE (decl
);
112 DECL_CONTEXT (decl
) = current_function_decl
;
113 layout_decl (decl
, 0);
115 /* See if we have an appropriate rtl (i.e. same mode) at this index.
116 If so, we must use it. */
117 tmp
= TREE_VEC_ELT (decl_map
, index
);
118 while (tmp
!= NULL_TREE
)
120 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
121 rtl
= DECL_RTL_IF_SET (tmp
);
124 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
127 SET_DECL_RTL (decl
, rtl
);
130 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
131 DECL_REGISTER (decl
) = 1;
135 /* Now link the decl into the decl_map. */
136 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
138 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
139 DECL_LOCAL_START_PC (decl
) = 0;
140 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
141 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
143 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
144 TREE_VEC_ELT (decl_map
, index
) = decl
;
148 /* Find out if 'decl' passed in fits the defined PC location better than
149 'best'. Return decl if it does, return best if it doesn't. If decl
150 is returned, then updated is set to true. */
153 check_local_named_variable (tree best
, tree decl
, int pc
, int *updated
)
155 if (pc
>= DECL_LOCAL_START_PC (decl
)
156 && pc
< DECL_LOCAL_END_PC (decl
))
158 if (best
== NULL_TREE
159 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
160 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
170 /* Find the best declaration based upon type. If 'decl' fits 'type' better
171 than 'best', return 'decl'. Otherwise return 'best'. */
174 check_local_unnamed_variable (tree best
, tree decl
, tree type
)
176 if (TREE_TYPE (decl
) == type
177 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
178 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
179 && TYPE_PRECISION (type
) <= 32
180 && TREE_CODE (type
) != POINTER_TYPE
)
181 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
182 && type
== ptr_type_node
))
184 if (best
== NULL_TREE
185 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
193 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
194 that is valid at PC (or -1 if any pc).
195 If there is no existing matching decl, allocate one. */
198 find_local_variable (int index
, tree type
, int 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 (int index
, tree type
)
246 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
252 /* A chain of _DECL nodes for all variables, constants, functions,
253 * and typedef types. These are in the reverse of the order supplied.
257 /* For each level, a list of shadowed outer-level local definitions
258 to be restored when this level is popped.
259 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
260 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
263 /* For each level (except not the global one),
264 a chain of BLOCK nodes for all the levels
265 that were entered and exited one level down. */
268 /* The BLOCK node for this level, if one has been preallocated.
269 If 0, the BLOCK is allocated (if needed) when the level is popped. */
272 /* The binding level which this one is contained in (inherits from). */
273 struct binding_level
*level_chain
;
275 /* The bytecode PC that marks the end of this level. */
277 /* The bytecode PC that marks the start of this level. */
280 #if defined(DEBUG_JAVA_BINDING_LEVELS)
281 /* Binding depth at which this level began. */
282 unsigned binding_depth
;
283 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
286 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
288 /* The binding level currently in effect. */
290 static struct binding_level
*current_binding_level
;
292 /* A chain of binding_level structures awaiting reuse. */
294 static struct binding_level
*free_binding_level
;
296 /* The outermost binding level, for names of file scope.
297 This is created when the compiler is started and exists
298 through the entire run. */
300 static struct binding_level
*global_binding_level
;
302 /* A PC value bigger than any PC value we may ever may encounter. */
304 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
306 /* Binding level structures are initialized by copying this one. */
308 static const struct binding_level clear_binding_level
309 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
310 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
313 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
314 that have names. Here so we can clear out their names' definitions
315 at the end of the function. */
317 static tree named_labels
;
319 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
321 static tree shadowed_labels
;
324 tree java_global_trees
[JTI_MAX
];
326 /* Build (and pushdecl) a "promoted type" for all standard
327 types shorter than int. */
330 push_promoted_type (const char *name
, tree actual_type
)
332 tree type
= make_node (TREE_CODE (actual_type
));
334 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
335 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
337 tree in_min
= TYPE_MIN_VALUE (actual_type
);
338 tree in_max
= TYPE_MAX_VALUE (actual_type
);
340 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
341 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
342 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
343 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
344 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
346 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
350 /* Return a definition for a builtin function named NAME and whose data type
351 is TYPE. TYPE should be a function type with argument types.
352 FUNCTION_CODE tells later passes how to compile calls to this function.
353 See tree.h for its possible values.
355 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
356 the name to be called if we can't opencode the function. If
357 ATTRS is nonzero, use that for the function's attribute list. */
360 builtin_function (const char *name
,
363 enum built_in_class
class,
364 const char *library_name
,
365 tree attrs ATTRIBUTE_UNUSED
)
367 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
368 DECL_EXTERNAL (decl
) = 1;
369 TREE_PUBLIC (decl
) = 1;
371 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
372 make_decl_rtl (decl
, NULL
);
374 DECL_BUILT_IN_CLASS (decl
) = class;
375 DECL_FUNCTION_CODE (decl
) = function_code
;
379 /* Return tree that represents a vtable for a primitive array. */
381 create_primitive_vtable (const char *name
)
386 sprintf (buf
, "_Jv_%sVTable", name
);
387 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
388 DECL_EXTERNAL (r
) = 1;
393 java_init_decl_processing (void)
395 register tree endlink
;
396 tree field
= NULL_TREE
;
399 init_class_processing ();
400 init_resource_processing ();
402 current_function_decl
= NULL
;
403 current_binding_level
= NULL_BINDING_LEVEL
;
404 free_binding_level
= NULL_BINDING_LEVEL
;
405 pushlevel (0); /* make the binding_level structure for global names */
406 global_binding_level
= current_binding_level
;
408 /* The code here must be similar to build_common_tree_nodes{,_2} in
409 tree.c, especially as to the order of initializing common nodes. */
410 error_mark_node
= make_node (ERROR_MARK
);
411 TREE_TYPE (error_mark_node
) = error_mark_node
;
413 /* Create sizetype first - needed for other types. */
414 initialize_sizetypes ();
416 byte_type_node
= make_signed_type (8);
417 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
418 short_type_node
= make_signed_type (16);
419 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
420 int_type_node
= make_signed_type (32);
421 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
422 long_type_node
= make_signed_type (64);
423 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
425 unsigned_byte_type_node
= make_unsigned_type (8);
426 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
427 unsigned_byte_type_node
));
428 unsigned_short_type_node
= make_unsigned_type (16);
429 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
430 unsigned_short_type_node
));
431 unsigned_int_type_node
= make_unsigned_type (32);
432 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
433 unsigned_int_type_node
));
434 unsigned_long_type_node
= make_unsigned_type (64);
435 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
436 unsigned_long_type_node
));
438 set_sizetype (make_unsigned_type (POINTER_SIZE
));
440 /* Define these next since types below may used them. */
441 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
442 integer_zero_node
= build_int_2 (0, 0);
443 integer_one_node
= build_int_2 (1, 0);
444 integer_two_node
= build_int_2 (2, 0);
445 integer_four_node
= build_int_2 (4, 0);
446 integer_minus_one_node
= build_int_2 (-1, -1);
448 /* A few values used for range checking in the lexer. */
449 decimal_int_max
= build_int_2 (0x80000000, 0);
450 TREE_TYPE (decimal_int_max
) = unsigned_int_type_node
;
451 #if HOST_BITS_PER_WIDE_INT == 64
452 decimal_long_max
= build_int_2 (0x8000000000000000LL
, 0);
454 #if HOST_BITS_PER_WIDE_INT == 32
455 decimal_long_max
= build_int_2 (0, 0x80000000);
457 #error "unsupported size"
460 TREE_TYPE (decimal_long_max
) = unsigned_long_type_node
;
462 size_zero_node
= size_int (0);
463 size_one_node
= size_int (1);
464 bitsize_zero_node
= bitsize_int (0);
465 bitsize_one_node
= bitsize_int (1);
466 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
468 long_zero_node
= build_int_2 (0, 0);
469 TREE_TYPE (long_zero_node
) = long_type_node
;
471 void_type_node
= make_node (VOID_TYPE
);
472 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
473 layout_type (void_type_node
); /* Uses size_zero_node */
474 ptr_type_node
= build_pointer_type (void_type_node
);
475 t
= make_node (VOID_TYPE
);
476 layout_type (t
); /* Uses size_zero_node */
477 return_address_type_node
= build_pointer_type (t
);
479 null_pointer_node
= build_int_2 (0, 0);
480 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
482 /* Used by the parser to represent empty statements and blocks. */
483 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
484 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
487 /* Make a type to be the domain of a few array types
488 whose domains don't really matter.
489 200 is small enough that it always fits in size_t
490 and large enough that it can hold most function names for the
491 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
492 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
494 char_type_node
= make_node (CHAR_TYPE
);
495 TYPE_PRECISION (char_type_node
) = 16;
496 fixup_unsigned_type (char_type_node
);
497 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
499 boolean_type_node
= make_node (BOOLEAN_TYPE
);
500 TYPE_PRECISION (boolean_type_node
) = 1;
501 fixup_unsigned_type (boolean_type_node
);
502 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
504 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
505 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
507 promoted_byte_type_node
508 = push_promoted_type ("promoted_byte", byte_type_node
);
509 promoted_short_type_node
510 = push_promoted_type ("promoted_short", short_type_node
);
511 promoted_char_type_node
512 = push_promoted_type ("promoted_char", char_type_node
);
513 promoted_boolean_type_node
514 = push_promoted_type ("promoted_boolean", boolean_type_node
);
516 float_type_node
= make_node (REAL_TYPE
);
517 TYPE_PRECISION (float_type_node
) = 32;
518 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
520 layout_type (float_type_node
);
522 double_type_node
= make_node (REAL_TYPE
);
523 TYPE_PRECISION (double_type_node
) = 64;
524 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
526 layout_type (double_type_node
);
528 float_zero_node
= build_real (float_type_node
, dconst0
);
529 double_zero_node
= build_real (double_type_node
, dconst0
);
531 /* These are the vtables for arrays of primitives. */
532 boolean_array_vtable
= create_primitive_vtable ("boolean");
533 byte_array_vtable
= create_primitive_vtable ("byte");
534 char_array_vtable
= create_primitive_vtable ("char");
535 short_array_vtable
= create_primitive_vtable ("short");
536 int_array_vtable
= create_primitive_vtable ("int");
537 long_array_vtable
= create_primitive_vtable ("long");
538 float_array_vtable
= create_primitive_vtable ("float");
539 double_array_vtable
= create_primitive_vtable ("double");
541 /* As you're adding items here, please update the code right after
542 this section, so that the filename containing the source code of
543 the pre-defined class gets registered correctly. */
544 unqualified_object_id_node
= get_identifier ("Object");
545 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
546 object_ptr_type_node
= promote_type (object_type_node
);
547 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
548 string_ptr_type_node
= promote_type (string_type_node
);
549 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
550 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
551 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
552 runtime_exception_type_node
=
553 lookup_class (get_identifier ("java.lang.RuntimeException"));
554 error_exception_type_node
=
555 lookup_class (get_identifier ("java.lang.Error"));
556 class_not_found_type_node
=
557 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
558 no_class_def_found_type_node
=
559 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
561 rawdata_ptr_type_node
562 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
564 add_predefined_file (get_identifier ("java/lang/Class.java"));
565 add_predefined_file (get_identifier ("java/lang/Error.java"));
566 add_predefined_file (get_identifier ("java/lang/Object.java"));
567 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
568 add_predefined_file (get_identifier ("java/lang/String.java"));
569 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
570 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
571 add_predefined_file (get_identifier ("java/lang/Exception.java"));
572 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
573 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
574 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
576 methodtable_type
= make_node (RECORD_TYPE
);
577 layout_type (methodtable_type
);
578 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
579 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
581 TYPE_identifier_node
= get_identifier ("TYPE");
582 init_identifier_node
= get_identifier ("<init>");
583 clinit_identifier_node
= get_identifier ("<clinit>");
584 finit_identifier_node
= get_identifier ("finit$");
585 instinit_identifier_node
= get_identifier ("instinit$");
586 void_signature_node
= get_identifier ("()V");
587 length_identifier_node
= get_identifier ("length");
588 finalize_identifier_node
= get_identifier ("finalize");
589 this_identifier_node
= get_identifier ("this");
590 super_identifier_node
= get_identifier ("super");
591 continue_identifier_node
= get_identifier ("continue");
592 access0_identifier_node
= get_identifier ("access$0");
593 classdollar_identifier_node
= get_identifier ("class$");
595 java_lang_cloneable_identifier_node
= get_identifier ("java.lang.Cloneable");
596 java_io_serializable_identifier_node
=
597 get_identifier ("java.io.Serializable");
599 /* for lack of a better place to put this stub call */
600 init_expr_processing();
602 utf8const_type
= make_node (RECORD_TYPE
);
603 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
604 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
605 FINISH_RECORD (utf8const_type
);
606 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
608 constants_type_node
= make_node (RECORD_TYPE
);
609 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
610 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
611 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
612 FINISH_RECORD (constants_type_node
);
613 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
615 access_flags_type_node
= unsigned_short_type_node
;
617 dtable_type
= make_node (RECORD_TYPE
);
618 dtable_ptr_type
= build_pointer_type (dtable_type
);
620 one_elt_array_domain_type
= build_index_type (integer_one_node
);
621 otable_type
= build_array_type (integer_type_node
,
622 one_elt_array_domain_type
);
623 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
624 otable_ptr_type
= build_pointer_type (otable_type
);
626 method_symbol_type
= make_node (RECORD_TYPE
);
627 PUSH_FIELD (method_symbol_type
, field
, "clname", utf8const_ptr_type
);
628 PUSH_FIELD (method_symbol_type
, field
, "name", utf8const_ptr_type
);
629 PUSH_FIELD (method_symbol_type
, field
, "signature", utf8const_ptr_type
);
630 FINISH_RECORD (method_symbol_type
);
632 method_symbols_array_type
= build_array_type (method_symbol_type
,
633 one_elt_array_domain_type
);
634 method_symbols_array_ptr_type
= build_pointer_type
635 (method_symbols_array_type
);
637 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"), otable_type
);
638 DECL_EXTERNAL (otable_decl
) = 1;
639 TREE_STATIC (otable_decl
) = 1;
640 TREE_READONLY (otable_decl
) = 1;
641 pushdecl (otable_decl
);
643 otable_syms_decl
= build_decl (VAR_DECL
, get_identifier ("otable_syms"),
644 method_symbols_array_type
);
645 TREE_STATIC (otable_syms_decl
) = 1;
646 TREE_CONSTANT (otable_syms_decl
) = 1;
647 pushdecl (otable_syms_decl
);
649 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
650 /* This isn't exactly true, but it is what we have in the source.
651 There is an unresolved issue here, which is whether the vtable
652 should be marked by the GC. */
653 if (! flag_hash_synchronization
)
654 PUSH_FIELD (object_type_node
, field
, "sync_info",
655 build_pointer_type (object_type_node
));
656 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
657 FIELD_PRIVATE (t
) = 1;
658 FINISH_RECORD (object_type_node
);
660 field_type_node
= make_node (RECORD_TYPE
);
661 field_ptr_type_node
= build_pointer_type (field_type_node
);
662 method_type_node
= make_node (RECORD_TYPE
);
663 method_ptr_type_node
= build_pointer_type (method_type_node
);
665 set_super_info (0, class_type_node
, object_type_node
, 0);
666 set_super_info (0, string_type_node
, object_type_node
, 0);
667 class_ptr_type
= build_pointer_type (class_type_node
);
669 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
670 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
671 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
672 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
673 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
674 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
675 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
676 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
677 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
678 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
679 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
680 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
681 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
682 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
683 PUSH_FIELD (class_type_node
, field
, "otable_syms",
684 method_symbols_array_ptr_type
);
685 PUSH_FIELD (class_type_node
, field
, "interfaces",
686 build_pointer_type (class_ptr_type
));
687 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
688 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
689 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
690 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
691 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
692 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
693 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
694 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
695 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
696 PUSH_FIELD (class_type_node
, field
, "chain", ptr_type_node
);
697 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
698 FIELD_PRIVATE (t
) = 1;
699 push_super_field (class_type_node
, object_type_node
);
701 FINISH_RECORD (class_type_node
);
702 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
704 field_info_union_node
= make_node (UNION_TYPE
);
705 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
706 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
708 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
710 layout_type (field_info_union_node
);
712 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
713 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
714 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
715 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
716 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
717 FINISH_RECORD (field_type_node
);
718 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
720 nativecode_ptr_array_type_node
721 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
723 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
724 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
725 FINISH_RECORD (dtable_type
);
726 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
728 #define jint_type int_type_node
729 #define jint_ptr_type ptr_type_node
731 jexception_type
= make_node (RECORD_TYPE
);
732 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
733 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
734 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
735 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
736 FINISH_RECORD (jexception_type
);
737 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
738 jexception_ptr_type
= build_pointer_type (jexception_type
);
740 lineNumberEntry_type
= make_node (RECORD_TYPE
);
741 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
742 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
743 FINISH_RECORD (lineNumberEntry_type
);
745 lineNumbers_type
= make_node (RECORD_TYPE
);
746 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
747 FINISH_RECORD (lineNumbers_type
);
749 #define instn_ptr_type_node ptr_type_node /* XXX JH */
751 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
753 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
754 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
755 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
756 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
757 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
758 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
759 FINISH_RECORD (method_type_node
);
760 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
762 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
764 t
= tree_cons (NULL_TREE
, class_ptr_type
,
765 tree_cons (NULL_TREE
, int_type_node
, endlink
));
766 alloc_object_node
= builtin_function ("_Jv_AllocObject",
767 build_function_type (ptr_type_node
, t
),
768 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
769 DECL_IS_MALLOC (alloc_object_node
) = 1;
770 alloc_no_finalizer_node
=
771 builtin_function ("_Jv_AllocObjectNoFinalizer",
772 build_function_type (ptr_type_node
, t
),
773 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
774 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
776 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
777 soft_initclass_node
= builtin_function ("_Jv_InitClass",
778 build_function_type (void_type_node
,
780 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
782 throw_node
= builtin_function ("_Jv_Throw",
783 build_function_type (ptr_type_node
, t
),
784 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
785 /* Mark throw_nodes as `noreturn' functions with side effects. */
786 TREE_THIS_VOLATILE (throw_node
) = 1;
787 TREE_SIDE_EFFECTS (throw_node
) = 1;
789 t
= build_function_type (int_type_node
, endlink
);
790 soft_monitorenter_node
791 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
793 soft_monitorexit_node
794 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
797 t
= tree_cons (NULL_TREE
, int_type_node
,
798 tree_cons (NULL_TREE
, int_type_node
, endlink
));
800 = builtin_function ("_Jv_NewPrimArray",
801 build_function_type(ptr_type_node
, t
),
802 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
803 DECL_IS_MALLOC (soft_newarray_node
) = 1;
805 t
= tree_cons (NULL_TREE
, int_type_node
,
806 tree_cons (NULL_TREE
, class_ptr_type
,
807 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
809 = builtin_function ("_Jv_NewObjectArray",
810 build_function_type (ptr_type_node
, t
),
811 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
812 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
814 /* There is no endlink here because _Jv_NewMultiArray is a varargs
816 t
= tree_cons (NULL_TREE
, ptr_type_node
,
817 tree_cons (NULL_TREE
, int_type_node
, NULL_TREE
));
818 soft_multianewarray_node
819 = builtin_function ("_Jv_NewMultiArray",
820 build_function_type (ptr_type_node
, t
),
821 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
822 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
824 t
= build_function_type (void_type_node
,
825 tree_cons (NULL_TREE
, int_type_node
, endlink
));
826 soft_badarrayindex_node
827 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
828 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
829 /* Mark soft_badarrayindex_node as a `noreturn' function with side
831 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
832 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
834 soft_nullpointer_node
835 = builtin_function ("_Jv_ThrowNullPointerException",
836 build_function_type (void_type_node
, endlink
),
837 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
838 /* Mark soft_nullpointer_node as a `noreturn' function with side
840 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
841 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
843 t
= tree_cons (NULL_TREE
, class_ptr_type
,
844 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
846 = builtin_function ("_Jv_CheckCast",
847 build_function_type (ptr_type_node
, t
),
848 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
849 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
850 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
852 = builtin_function ("_Jv_IsInstanceOf",
853 build_function_type (boolean_type_node
, t
),
854 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
855 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
856 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
857 soft_checkarraystore_node
858 = builtin_function ("_Jv_CheckArrayStore",
859 build_function_type (void_type_node
, t
),
860 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
861 t
= tree_cons (NULL_TREE
, ptr_type_node
,
862 tree_cons (NULL_TREE
, ptr_type_node
,
863 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
864 soft_lookupinterfacemethod_node
865 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
866 build_function_type (ptr_type_node
, t
),
867 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
869 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
870 tree_cons (NULL_TREE
, ptr_type_node
,
871 tree_cons (NULL_TREE
, ptr_type_node
,
872 tree_cons (NULL_TREE
, int_type_node
,
874 soft_lookupjnimethod_node
875 = builtin_function ("_Jv_LookupJNIMethod",
876 build_function_type (ptr_type_node
, t
),
877 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
878 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
879 soft_getjnienvnewframe_node
880 = builtin_function ("_Jv_GetJNIEnvNewFrame",
881 build_function_type (ptr_type_node
, t
),
882 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
883 soft_jnipopsystemframe_node
884 = builtin_function ("_Jv_JNI_PopSystemFrame",
885 build_function_type (ptr_type_node
, t
),
886 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
889 = builtin_function ("_Jv_divI",
890 build_function_type (int_type_node
, t
),
891 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
894 = builtin_function ("_Jv_remI",
895 build_function_type (int_type_node
, t
),
896 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
899 = builtin_function ("_Jv_divJ",
900 build_function_type (long_type_node
, t
),
901 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
904 = builtin_function ("_Jv_remJ",
905 build_function_type (long_type_node
, t
),
906 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
908 /* Initialize variables for except.c. */
909 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
910 ? "__gcj_personality_sj0"
911 : "__gcj_personality_v0");
912 lang_eh_runtime_type
= prepare_eh_table_type
;
916 initialize_builtins ();
918 soft_fmod_node
= built_in_decls
[BUILT_IN_FMOD
];
920 soft_fmodf_node
= built_in_decls
[BUILT_IN_FMODF
];
925 /* Look up NAME in the current binding level and its superiors
926 in the namespace of variables, functions and typedefs.
927 Return a ..._DECL node of some kind representing its definition,
928 or return 0 if it is undefined. */
931 lookup_name (tree name
)
934 if (current_binding_level
!= global_binding_level
935 && IDENTIFIER_LOCAL_VALUE (name
))
936 val
= IDENTIFIER_LOCAL_VALUE (name
);
938 val
= IDENTIFIER_GLOBAL_VALUE (name
);
942 /* Similar to `lookup_name' but look only at current binding level and
943 the previous one if its the parameter level. */
946 lookup_name_current_level (tree name
)
950 if (current_binding_level
== global_binding_level
)
951 return IDENTIFIER_GLOBAL_VALUE (name
);
953 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
956 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
957 if (DECL_NAME (t
) == name
)
963 /* Use a binding level to record a labeled block declaration */
966 push_labeled_block (tree lb
)
968 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
969 register struct binding_level
*b
= current_binding_level
;
970 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
972 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
973 TREE_CHAIN (lb
) = b
->names
;
975 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
978 /* Pop the current binding level, reinstalling values for the previous
982 pop_labeled_block (void)
984 struct binding_level
*b
= current_binding_level
;
985 tree label
= b
->names
;
986 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
989 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
990 TREE_VALUE (b
->shadowed
);
992 /* Pop the current level, and free the structure for reuse. */
993 current_binding_level
= current_binding_level
->level_chain
;
994 b
->level_chain
= free_binding_level
;
995 free_binding_level
= b
;
998 /* Record a decl-node X as belonging to the current lexical scope.
999 Check for errors (such as an incompatible declaration for the same
1000 name already seen in the same scope).
1002 Returns either X or an old decl for the same name.
1003 If an old decl is returned, it may have been smashed
1004 to agree with what X says. */
1010 register tree name
= DECL_NAME (x
);
1011 register struct binding_level
*b
= current_binding_level
;
1013 if (TREE_CODE (x
) != TYPE_DECL
)
1014 DECL_CONTEXT (x
) = current_function_decl
;
1020 t
= lookup_name_current_level (name
);
1021 if (t
!= 0 && t
== error_mark_node
)
1022 /* error_mark_node is 0 for a while during initialization! */
1025 error_with_decl (x
, "`%s' used prior to declaration");
1030 file
= DECL_SOURCE_FILE (t
);
1031 line
= DECL_SOURCE_LINE (t
);
1034 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1035 to point to the TYPE_DECL.
1036 Since Java does not have typedefs, a type can only have
1037 one (true) name, given by a class, interface, or builtin. */
1038 if (TREE_CODE (x
) == TYPE_DECL
1039 && TYPE_NAME (TREE_TYPE (x
)) == 0
1040 && TREE_TYPE (x
) != error_mark_node
)
1042 TYPE_NAME (TREE_TYPE (x
)) = x
;
1043 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1046 /* This name is new in its binding level.
1047 Install the new declaration and return it. */
1048 if (b
== global_binding_level
)
1050 /* Install a global value. */
1052 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1056 /* Here to install a non-global value. */
1057 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1058 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1061 /* Warn if shadowing an argument at the top level of the body. */
1062 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1063 /* This warning doesn't apply to the parms of a nested fcn. */
1064 && ! current_binding_level
->parm_flag
1065 /* Check that this is one level down from the parms. */
1066 && current_binding_level
->level_chain
->parm_flag
1067 /* Check that the decl being shadowed
1068 comes from the parm level, one level up. */
1069 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1071 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1072 pedwarn ("declaration of `%s' shadows a parameter",
1073 IDENTIFIER_POINTER (name
));
1075 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1076 IDENTIFIER_POINTER (name
));
1079 /* Maybe warn if shadowing something else. */
1080 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1081 /* No shadow warnings for internally generated vars. */
1082 && DECL_SOURCE_LINE (x
) != 0
1083 /* No shadow warnings for vars made for inlining. */
1084 && ! DECL_FROM_INLINE (x
))
1086 const char *warnstring
= 0;
1088 if (TREE_CODE (x
) == PARM_DECL
1089 && current_binding_level
->level_chain
->parm_flag
)
1090 /* Don't warn about the parm names in function declarator
1091 within a function declarator.
1092 It would be nice to avoid warning in any function
1093 declarator in a declaration, as opposed to a definition,
1094 but there is no way to tell it's not a definition. */
1096 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1097 warnstring
= "declaration of `%s' shadows a parameter";
1098 else if (oldlocal
!= 0)
1099 warnstring
= "declaration of `%s' shadows previous local";
1100 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1101 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1102 warnstring
= "declaration of `%s' shadows global declaration";
1105 warning (warnstring
, IDENTIFIER_POINTER (name
));
1109 /* If storing a local value, there may already be one (inherited).
1110 If so, record it for restoration when this binding level ends. */
1112 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1116 /* Put decls on list in reverse order.
1117 We will reverse them later if necessary. */
1118 TREE_CHAIN (x
) = b
->names
;
1125 pushdecl_force_head (tree x
)
1127 current_binding_level
->names
= x
;
1130 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1133 pushdecl_top_level (tree x
)
1136 register struct binding_level
*b
= current_binding_level
;
1138 current_binding_level
= global_binding_level
;
1140 current_binding_level
= b
;
1144 /* Nonzero if we are currently in the global binding level. */
1147 global_bindings_p (void)
1149 return current_binding_level
== global_binding_level
;
1152 /* Return the list of declarations of the current level.
1153 Note that this list is in reverse order unless/until
1154 you nreverse it; and when you do nreverse it, you must
1155 store the result back using `storedecls' or you will lose. */
1160 return current_binding_level
->names
;
1163 /* Create a new `struct binding_level'. */
1165 static struct binding_level
*
1166 make_binding_level (void)
1169 return xmalloc (sizeof (struct binding_level
));
1173 pushlevel (int unused ATTRIBUTE_UNUSED
)
1175 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1178 /* If this is the top level of a function,
1179 just make sure that NAMED_LABELS is 0. */
1181 if (current_binding_level
== global_binding_level
)
1185 /* Reuse or create a struct for this binding level. */
1187 if (free_binding_level
)
1189 newlevel
= free_binding_level
;
1190 free_binding_level
= free_binding_level
->level_chain
;
1194 newlevel
= make_binding_level ();
1197 /* Add this level to the front of the chain (stack) of levels that
1200 *newlevel
= clear_binding_level
;
1201 newlevel
->level_chain
= current_binding_level
;
1202 current_binding_level
= newlevel
;
1203 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1204 newlevel
->binding_depth
= binding_depth
;
1206 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1207 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1210 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1213 /* Exit a binding level.
1214 Pop the level off, and restore the state of the identifier-decl mappings
1215 that were in effect when this level was entered.
1217 If KEEP is nonzero, this level had explicit declarations, so
1218 and create a "block" (a BLOCK node) for the level
1219 to record its declarations and subblocks for symbol table output.
1221 If FUNCTIONBODY is nonzero, this level is the body of a function,
1222 so create a block as if KEEP were set and also clear out all
1225 If REVERSE is nonzero, reverse the order of decls before putting
1226 them into the BLOCK. */
1229 poplevel (int keep
, int reverse
, int functionbody
)
1232 /* The chain of decls was accumulated in reverse order.
1233 Put it into forward order, just for cleanliness. */
1235 tree subblocks
= current_binding_level
->blocks
;
1238 int block_previously_created
;
1240 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1243 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1244 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1245 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1246 current_binding_level
->end_pc
);
1248 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1249 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1251 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1254 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1258 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1260 /* Get the decls in the order they were written.
1261 Usually current_binding_level->names is in reverse order.
1262 But parameter decls were previously put in forward order. */
1265 current_binding_level
->names
1266 = decls
= nreverse (current_binding_level
->names
);
1268 decls
= current_binding_level
->names
;
1270 /* Output any nested inline functions within this block
1271 if they weren't already output. */
1273 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1274 if (TREE_CODE (decl
) == FUNCTION_DECL
1275 && ! TREE_ASM_WRITTEN (decl
)
1276 && DECL_INITIAL (decl
) != 0
1277 && TREE_ADDRESSABLE (decl
))
1279 /* If this decl was copied from a file-scope decl
1280 on account of a block-scope extern decl,
1281 propagate TREE_ADDRESSABLE to the file-scope decl.
1283 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1284 true, since then the decl goes through save_for_inline_copying. */
1285 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1286 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1287 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1290 push_function_context ();
1291 output_inline_function (decl
);
1292 pop_function_context ();
1296 /* If there were any declarations in that level,
1297 or if this level is a function body,
1298 create a BLOCK to record them for the life of this function. */
1301 block_previously_created
= (current_binding_level
->this_block
!= 0);
1302 if (block_previously_created
)
1303 block
= current_binding_level
->this_block
;
1304 else if (keep
|| functionbody
)
1305 block
= make_node (BLOCK
);
1308 BLOCK_VARS (block
) = decls
;
1309 BLOCK_SUBBLOCKS (block
) = subblocks
;
1312 /* In each subblock, record that this is its superior. */
1314 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1315 BLOCK_SUPERCONTEXT (link
) = block
;
1317 /* Clear out the meanings of the local variables of this level. */
1319 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1321 tree name
= DECL_NAME (link
);
1322 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1324 /* If the ident. was used or addressed via a local extern decl,
1325 don't forget that fact. */
1326 if (DECL_EXTERNAL (link
))
1328 if (TREE_USED (link
))
1329 TREE_USED (name
) = 1;
1330 if (TREE_ADDRESSABLE (link
))
1331 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1333 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1337 /* Restore all name-meanings of the outer levels
1338 that were shadowed by this level. */
1340 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1341 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1343 /* If the level being exited is the top level of a function,
1344 check over all the labels, and clear out the current
1345 (function local) meanings of their names. */
1349 /* If this is the top level block of a function,
1350 the vars are the function's parameters.
1351 Don't leave them in the BLOCK because they are
1352 found in the FUNCTION_DECL instead. */
1354 BLOCK_VARS (block
) = 0;
1356 /* Clear out the definitions of all label names,
1357 since their scopes end here,
1358 and add them to BLOCK_VARS. */
1361 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1363 register tree label
= TREE_VALUE (link
);
1365 if (DECL_INITIAL (label
) == 0)
1367 error_with_decl (label
, "label `%s' used but not defined");
1368 /* Avoid crashing later. */
1369 define_label (input_filename
, lineno
,
1372 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1373 warning_with_decl (label
, "label `%s' defined but not used");
1374 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1376 /* Put the labels into the "variables" of the
1377 top-level block, so debugger can see them. */
1378 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1379 BLOCK_VARS (block
) = label
;
1384 /* Pop the current level, and free the structure for reuse. */
1387 register struct binding_level
*level
= current_binding_level
;
1388 current_binding_level
= current_binding_level
->level_chain
;
1390 level
->level_chain
= free_binding_level
;
1391 free_binding_level
= level
;
1394 /* Dispose of the block that we just made inside some higher level. */
1396 DECL_INITIAL (current_function_decl
) = block
;
1399 if (!block_previously_created
)
1400 current_binding_level
->blocks
1401 = chainon (current_binding_level
->blocks
, block
);
1403 /* If we did not make a block for the level just exited,
1404 any blocks made for inner levels
1405 (since they cannot be recorded as subblocks in that level)
1406 must be carried forward so they will later become subblocks
1407 of something else. */
1409 current_binding_level
->blocks
1410 = chainon (current_binding_level
->blocks
, subblocks
);
1412 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1413 binding contour so that they point to the appropriate construct, i.e.
1414 either to the current FUNCTION_DECL node, or else to the BLOCK node
1415 we just constructed.
1417 Note that for tagged types whose scope is just the formal parameter
1418 list for some function type specification, we can't properly set
1419 their TYPE_CONTEXTs here, because we don't have a pointer to the
1420 appropriate FUNCTION_TYPE node readily available to us. For those
1421 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1422 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1423 node which will represent the "scope" for these "parameter list local"
1428 TREE_USED (block
) = 1;
1433 maybe_pushlevels (int pc
)
1435 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1439 while (pending_local_decls
!= NULL_TREE
&&
1440 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1442 tree
*ptr
= &pending_local_decls
;
1444 int end_pc
= DECL_LOCAL_END_PC (decl
);
1446 while (*ptr
!= NULL_TREE
1447 && DECL_LOCAL_START_PC (*ptr
) <= pc
1448 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1449 ptr
= &TREE_CHAIN (*ptr
);
1450 pending_local_decls
= *ptr
;
1453 /* Force non-nested range to be nested in current range. */
1454 if (end_pc
> current_binding_level
->end_pc
)
1455 end_pc
= current_binding_level
->end_pc
;
1457 maybe_start_try (pc
, end_pc
);
1460 expand_start_bindings (0);
1462 current_binding_level
->end_pc
= end_pc
;
1463 current_binding_level
->start_pc
= pc
;
1464 current_binding_level
->names
= decl
;
1465 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1467 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1471 maybe_start_try (pc
, 0);
1475 maybe_poplevels (int pc
)
1477 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1481 while (current_binding_level
->end_pc
<= pc
)
1483 expand_end_bindings (getdecls (), 1, 0);
1484 maybe_end_try (current_binding_level
->start_pc
, pc
);
1487 maybe_end_try (0, pc
);
1490 /* Terminate any binding which began during the range beginning at
1491 start_pc. This tidies up improperly nested local variable ranges
1492 and exception handlers; a variable declared within an exception
1493 range is forcibly terminated when that exception ends. */
1496 force_poplevels (int start_pc
)
1498 while (current_binding_level
->start_pc
> start_pc
)
1500 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1501 warning_with_decl (current_function_decl
,
1502 "In %s: overlapped variable and exception ranges at %d",
1503 current_binding_level
->start_pc
);
1504 expand_end_bindings (getdecls (), 1, 0);
1509 /* Insert BLOCK at the end of the list of subblocks of the
1510 current binding level. This is used when a BIND_EXPR is expanded,
1511 to handle the BLOCK node inside the BIND_EXPR. */
1514 insert_block (tree block
)
1516 TREE_USED (block
) = 1;
1517 current_binding_level
->blocks
1518 = chainon (current_binding_level
->blocks
, block
);
1521 /* Set the BLOCK node for the innermost scope
1522 (the one we are currently in). */
1525 set_block (tree block
)
1527 current_binding_level
->this_block
= block
;
1528 current_binding_level
->names
= chainon (current_binding_level
->names
,
1529 BLOCK_VARS (block
));
1530 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1531 BLOCK_SUBBLOCKS (block
));
1534 /* integrate_decl_tree calls this function. */
1537 java_dup_lang_specific_decl (tree node
)
1540 struct lang_decl
*x
;
1542 if (!DECL_LANG_SPECIFIC (node
))
1545 lang_decl_size
= sizeof (struct lang_decl
);
1546 x
= ggc_alloc (lang_decl_size
);
1547 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1548 DECL_LANG_SPECIFIC (node
) = x
;
1552 give_name_to_locals (JCF
*jcf
)
1554 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1555 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1557 pending_local_decls
= NULL_TREE
;
1561 n
= JCF_readu2 (jcf
);
1562 for (i
= 0; i
< n
; i
++)
1564 int start_pc
= JCF_readu2 (jcf
);
1565 int length
= JCF_readu2 (jcf
);
1566 int name_index
= JCF_readu2 (jcf
);
1567 int signature_index
= JCF_readu2 (jcf
);
1568 int slot
= JCF_readu2 (jcf
);
1569 tree name
= get_name_constant (jcf
, name_index
);
1570 tree type
= parse_signature (jcf
, signature_index
);
1571 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1573 && length
== DECL_CODE_LENGTH (current_function_decl
))
1575 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1576 DECL_NAME (decl
) = name
;
1577 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1578 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1579 warning ("bad type in parameter debug info");
1584 int end_pc
= start_pc
+ length
;
1585 tree decl
= build_decl (VAR_DECL
, name
, type
);
1586 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1588 warning_with_decl (decl
,
1589 "bad PC range for debug info for local `%s'");
1590 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1593 /* Adjust start_pc if necessary so that the local's first
1594 store operation will use the relevant DECL as a
1595 destination. Fore more information, read the leading
1596 comments for expr.c:maybe_adjust_start_pc. */
1597 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1599 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1600 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1601 DECL_LOCAL_START_PC (decl
) = start_pc
;
1603 /* FIXME: The range used internally for exceptions and local
1604 variable ranges, is a half-open interval:
1605 start_pc <= pc < end_pc. However, the range used in the
1606 Java VM spec is inclusive at both ends:
1607 start_pc <= pc <= end_pc. */
1610 DECL_LOCAL_END_PC (decl
) = end_pc
;
1612 /* Now insert the new decl in the proper place in
1613 pending_local_decls. We are essentially doing an insertion sort,
1614 which works fine, since the list input will normally already
1616 ptr
= &pending_local_decls
;
1617 while (*ptr
!= NULL_TREE
1618 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1619 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1620 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1621 ptr
= &TREE_CHAIN (*ptr
);
1622 TREE_CHAIN (decl
) = *ptr
;
1627 pending_local_decls
= nreverse (pending_local_decls
);
1629 /* Fill in default names for the parameters. */
1630 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1631 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1633 if (DECL_NAME (parm
) == NULL_TREE
)
1635 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1637 DECL_NAME (parm
) = get_identifier ("this");
1641 sprintf (buffer
, "ARG_%d", arg_i
);
1642 DECL_NAME (parm
) = get_identifier (buffer
);
1644 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1650 build_result_decl (tree fndecl
)
1652 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1653 tree result
= DECL_RESULT (fndecl
);
1656 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1657 if (INTEGRAL_TYPE_P (restype
)
1658 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1659 restype
= integer_type_node
;
1660 result
= build_decl (RESULT_DECL
, NULL_TREE
, restype
);
1661 DECL_CONTEXT (result
) = fndecl
;
1662 DECL_RESULT (fndecl
) = result
;
1668 complete_start_java_method (tree fndecl
)
1670 if (! flag_emit_class_files
)
1672 /* Initialize the RTL code for the function. */
1673 init_function_start (fndecl
, input_filename
, input_line
);
1675 /* Set up parameters and prepare for return, for the function. */
1676 expand_function_start (fndecl
, 0);
1680 /* If this fcn was already referenced via a block-scope `extern' decl (or
1681 an implicit decl), propagate certain information about the usage. */
1682 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1683 TREE_ADDRESSABLE (current_function_decl
) = 1;
1687 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1688 && ! flag_emit_class_files
1689 && ! DECL_CLINIT_P (fndecl
)
1690 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1692 tree clas
= DECL_CONTEXT (fndecl
);
1693 tree init
= build (CALL_EXPR
, void_type_node
,
1694 build_address_of (soft_initclass_node
),
1695 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1697 TREE_SIDE_EFFECTS (init
) = 1;
1698 expand_expr_stmt (init
);
1701 /* Push local variables. Function compiled from source code are
1702 using a different local variables management, and for them,
1703 pushlevel shouldn't be called from here. */
1704 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1707 if (! flag_emit_class_files
)
1708 expand_start_bindings (1);
1711 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1713 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1714 tree enter
, exit
, lock
;
1715 if (METHOD_STATIC (fndecl
))
1716 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1718 lock
= DECL_ARGUMENTS (fndecl
);
1719 BUILD_MONITOR_ENTER (enter
, lock
);
1720 BUILD_MONITOR_EXIT (exit
, lock
);
1721 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1723 expand_expr_stmt (enter
);
1724 expand_decl_cleanup (NULL_TREE
, exit
);
1728 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1729 tree body
= BLOCK_EXPR_BODY (function_body
);
1730 lock
= build (COMPOUND_EXPR
, void_type_node
,
1732 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1733 TREE_SIDE_EFFECTS (lock
) = 1;
1734 BLOCK_EXPR_BODY (function_body
) = lock
;
1740 start_java_method (tree fndecl
)
1745 current_function_decl
= fndecl
;
1746 announce_function (fndecl
);
1748 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1749 decl_map
= make_tree_vec (i
);
1750 type_map
= xrealloc (type_map
, i
* sizeof (tree
));
1752 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1753 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1755 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1756 pushlevel (1); /* Push parameters. */
1758 ptr
= &DECL_ARGUMENTS (fndecl
);
1759 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1760 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1762 tree parm_name
= NULL_TREE
, parm_decl
;
1763 tree parm_type
= TREE_VALUE (tem
);
1764 if (i
>= DECL_MAX_LOCALS (fndecl
))
1767 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1768 DECL_CONTEXT (parm_decl
) = fndecl
;
1769 if (PROMOTE_PROTOTYPES
1770 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1771 && INTEGRAL_TYPE_P (parm_type
))
1772 parm_type
= integer_type_node
;
1773 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1776 ptr
= &TREE_CHAIN (parm_decl
);
1778 /* Add parm_decl to the decl_map. */
1779 push_jvm_slot (i
, parm_decl
);
1781 type_map
[i
] = TREE_TYPE (parm_decl
);
1782 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1785 type_map
[i
] = void_type_node
;
1789 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1791 while (i
< DECL_MAX_LOCALS(fndecl
))
1792 type_map
[i
++] = NULL_TREE
;
1794 build_result_decl (fndecl
);
1795 complete_start_java_method (fndecl
);
1799 end_java_method (void)
1801 tree fndecl
= current_function_decl
;
1803 expand_end_bindings (getdecls (), 1, 0);
1804 /* pop out of function */
1807 /* pop out of its parameters */
1810 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1812 /* Generate rtl for function exit. */
1813 expand_function_end (input_filename
, input_line
, 0);
1815 /* Run the optimizers and output assembler code for this function. */
1816 rest_of_compilation (fndecl
);
1818 current_function_decl
= NULL_TREE
;
1821 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1824 dump_function (enum tree_dump_index phase
, tree fn
)
1829 stream
= dump_begin (phase
, &flags
);
1832 dump_node (fn
, TDF_SLIM
| flags
, stream
);
1833 dump_end (phase
, stream
);
1837 void java_optimize_inline (tree fndecl
)
1839 if (flag_inline_trees
)
1841 timevar_push (TV_INTEGRATION
);
1842 optimize_inline_calls (fndecl
);
1843 timevar_pop (TV_INTEGRATION
);
1844 dump_function (TDI_inlined
, fndecl
);
1848 /* We pessimistically marked all methods and fields external until we
1849 knew what set of classes we were planning to compile. Now mark those
1850 associated with CLASS to be generated locally as not external. */
1853 java_mark_decl_local (tree decl
)
1855 DECL_EXTERNAL (decl
) = 0;
1857 /* If we've already constructed DECL_RTL, give encode_section_info
1858 a second chance, now that we've changed the flags. */
1859 if (DECL_RTL_SET_P (decl
))
1860 make_decl_rtl (decl
, NULL
);
1864 java_mark_class_local (tree
class)
1868 for (t
= TYPE_FIELDS (class); t
; t
= TREE_CHAIN (t
))
1869 if (FIELD_STATIC (t
))
1870 java_mark_decl_local (t
);
1872 for (t
= TYPE_METHODS (class); t
; t
= TREE_CHAIN (t
))
1873 if (!METHOD_ABSTRACT (t
) && (!METHOD_NATIVE (t
) || flag_jni
))
1874 java_mark_decl_local (t
);
1877 #include "gt-java-decl.h"