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
);
61 /* Name of the Cloneable class. */
62 tree java_lang_cloneable_identifier_node
;
64 /* Name of the Serializable class. */
65 tree java_io_serializable_identifier_node
;
67 /* Set to nonzero value in order to emit class initialization code
68 before static field references. */
69 extern int always_initialize_class_p
;
71 /* The DECL_MAP is a mapping from (index, type) to a decl node.
72 If index < max_locals, it is the index of a local variable.
73 if index >= max_locals, then index-max_locals is a stack slot.
74 The DECL_MAP mapping is represented as a TREE_VEC whose elements
75 are a list of decls (VAR_DECL or PARM_DECL) chained by
76 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
77 we search the chain for a decl with a matching TREE_TYPE. */
79 static GTY(()) tree decl_map
;
81 /* A list of local variables VAR_DECLs for this method that we have seen
82 debug information, but we have not reached their starting (byte) PC yet. */
84 static GTY(()) tree pending_local_decls
;
86 /* Push a local variable or stack slot into the decl_map,
87 and assign it an rtl. */
89 #if defined(DEBUG_JAVA_BINDING_LEVELS)
90 int binding_depth
= 0;
91 int is_class_level
= 0;
99 for (i
= 0; i
< binding_depth
*2; i
++)
102 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
105 push_jvm_slot (int index
, tree decl
)
107 struct rtx_def
*rtl
= NULL
;
108 tree type
= TREE_TYPE (decl
);
111 DECL_CONTEXT (decl
) = current_function_decl
;
112 layout_decl (decl
, 0);
114 /* See if we have an appropriate rtl (i.e. same mode) at this index.
115 If so, we must use it. */
116 tmp
= TREE_VEC_ELT (decl_map
, index
);
117 while (tmp
!= NULL_TREE
)
119 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
120 rtl
= DECL_RTL_IF_SET (tmp
);
123 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
126 SET_DECL_RTL (decl
, rtl
);
129 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
130 DECL_REGISTER (decl
) = 1;
134 /* Now link the decl into the decl_map. */
135 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
137 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
138 DECL_LOCAL_START_PC (decl
) = 0;
139 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
140 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
142 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
143 TREE_VEC_ELT (decl_map
, index
) = decl
;
147 /* Find out if 'decl' passed in fits the defined PC location better than
148 'best'. Return decl if it does, return best if it doesn't. If decl
149 is returned, then updated is set to true. */
152 check_local_named_variable (tree best
, tree decl
, int pc
, int *updated
)
154 if (pc
>= DECL_LOCAL_START_PC (decl
)
155 && pc
< DECL_LOCAL_END_PC (decl
))
157 if (best
== NULL_TREE
158 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
159 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
169 /* Find the best declaration based upon type. If 'decl' fits 'type' better
170 than 'best', return 'decl'. Otherwise return 'best'. */
173 check_local_unnamed_variable (tree best
, tree decl
, tree type
)
175 if (TREE_TYPE (decl
) == type
176 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
177 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
178 && TYPE_PRECISION (type
) <= 32
179 && TREE_CODE (type
) != POINTER_TYPE
)
180 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
181 && type
== ptr_type_node
))
183 if (best
== NULL_TREE
184 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
192 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
193 that is valid at PC (or -1 if any pc).
194 If there is no existing matching decl, allocate one. */
197 find_local_variable (int index
, tree type
, int pc
)
199 tree decl
= TREE_VEC_ELT (decl_map
, index
);
200 tree best
= NULL_TREE
;
201 int found_scoped_var
= 0;
203 /* Scan through every declaration that has been created in this slot. */
204 while (decl
!= NULL_TREE
)
206 /* Variables created in give_name_to_locals() have a name and have
207 a specified scope, so we can handle them specifically. We want
208 to use the specific decls created for those so they are assigned
209 the right variables in the debugging information. */
210 if (DECL_NAME (decl
) != NULL_TREE
)
212 /* This is a variable we have a name for, so it has a scope
213 supplied in the class file. But it only matters when we
214 actually have a PC to use. If pc<0, then we are asking
215 for a stack slot and this decl won't be one of those. */
217 best
= check_local_named_variable (best
, decl
, pc
,
220 /* We scan for type information unless we found a variable in the
221 proper scope already. */
222 else if (!found_scoped_var
)
224 /* If we don't have scoping information for a variable, we use
225 a different method to look it up. */
226 best
= check_local_unnamed_variable (best
, decl
, type
);
229 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
232 if (best
!= NULL_TREE
)
235 /* If we don't find a match, create one with the type passed in. */
236 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
240 /* Same as find_local_index, except that INDEX is a stack index. */
243 find_stack_slot (int index
, tree type
)
245 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
251 /* A chain of _DECL nodes for all variables, constants, functions,
252 * and typedef types. These are in the reverse of the order supplied.
256 /* For each level, a list of shadowed outer-level local definitions
257 to be restored when this level is popped.
258 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
259 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
262 /* For each level (except not the global one),
263 a chain of BLOCK nodes for all the levels
264 that were entered and exited one level down. */
267 /* The BLOCK node for this level, if one has been preallocated.
268 If 0, the BLOCK is allocated (if needed) when the level is popped. */
271 /* The binding level which this one is contained in (inherits from). */
272 struct binding_level
*level_chain
;
274 /* The bytecode PC that marks the end of this level. */
276 /* The bytecode PC that marks the start of this level. */
279 #if defined(DEBUG_JAVA_BINDING_LEVELS)
280 /* Binding depth at which this level began. */
281 unsigned binding_depth
;
282 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
285 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
287 /* The binding level currently in effect. */
289 static struct binding_level
*current_binding_level
;
291 /* A chain of binding_level structures awaiting reuse. */
293 static struct binding_level
*free_binding_level
;
295 /* The outermost binding level, for names of file scope.
296 This is created when the compiler is started and exists
297 through the entire run. */
299 static struct binding_level
*global_binding_level
;
301 /* A PC value bigger than any PC value we may ever may encounter. */
303 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
305 /* Binding level structures are initialized by copying this one. */
307 static const struct binding_level clear_binding_level
308 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
309 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
312 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
313 that have names. Here so we can clear out their names' definitions
314 at the end of the function. */
316 static tree named_labels
;
318 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
320 static tree shadowed_labels
;
323 tree java_global_trees
[JTI_MAX
];
325 /* Build (and pushdecl) a "promoted type" for all standard
326 types shorter than int. */
329 push_promoted_type (const char *name
, tree actual_type
)
331 tree type
= make_node (TREE_CODE (actual_type
));
333 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
334 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
336 tree in_min
= TYPE_MIN_VALUE (actual_type
);
337 tree in_max
= TYPE_MAX_VALUE (actual_type
);
339 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
340 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
341 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
342 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
343 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
345 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
349 /* Return a definition for a builtin function named NAME and whose data type
350 is TYPE. TYPE should be a function type with argument types.
351 FUNCTION_CODE tells later passes how to compile calls to this function.
352 See tree.h for its possible values.
354 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
355 the name to be called if we can't opencode the function. If
356 ATTRS is nonzero, use that for the function's attribute list. */
359 builtin_function (const char *name
,
362 enum built_in_class
class,
363 const char *library_name
,
364 tree attrs ATTRIBUTE_UNUSED
)
366 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
367 DECL_EXTERNAL (decl
) = 1;
368 TREE_PUBLIC (decl
) = 1;
370 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
371 make_decl_rtl (decl
, NULL
);
373 DECL_BUILT_IN_CLASS (decl
) = class;
374 DECL_FUNCTION_CODE (decl
) = function_code
;
378 /* Return tree that represents a vtable for a primitive array. */
380 create_primitive_vtable (const char *name
)
385 sprintf (buf
, "_Jv_%sVTable", name
);
386 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
387 DECL_EXTERNAL (r
) = 1;
392 java_init_decl_processing (void)
394 register tree endlink
;
395 tree field
= NULL_TREE
;
398 init_class_processing ();
399 init_resource_processing ();
401 current_function_decl
= NULL
;
402 current_binding_level
= NULL_BINDING_LEVEL
;
403 free_binding_level
= NULL_BINDING_LEVEL
;
404 pushlevel (0); /* make the binding_level structure for global names */
405 global_binding_level
= current_binding_level
;
407 /* The code here must be similar to build_common_tree_nodes{,_2} in
408 tree.c, especially as to the order of initializing common nodes. */
409 error_mark_node
= make_node (ERROR_MARK
);
410 TREE_TYPE (error_mark_node
) = error_mark_node
;
412 /* Create sizetype first - needed for other types. */
413 initialize_sizetypes ();
415 byte_type_node
= make_signed_type (8);
416 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
417 short_type_node
= make_signed_type (16);
418 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
419 int_type_node
= make_signed_type (32);
420 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
421 long_type_node
= make_signed_type (64);
422 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
424 unsigned_byte_type_node
= make_unsigned_type (8);
425 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
426 unsigned_byte_type_node
));
427 unsigned_short_type_node
= make_unsigned_type (16);
428 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
429 unsigned_short_type_node
));
430 unsigned_int_type_node
= make_unsigned_type (32);
431 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
432 unsigned_int_type_node
));
433 unsigned_long_type_node
= make_unsigned_type (64);
434 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
435 unsigned_long_type_node
));
437 set_sizetype (make_unsigned_type (POINTER_SIZE
));
439 /* Define these next since types below may used them. */
440 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
441 integer_zero_node
= build_int_2 (0, 0);
442 integer_one_node
= build_int_2 (1, 0);
443 integer_two_node
= build_int_2 (2, 0);
444 integer_four_node
= build_int_2 (4, 0);
445 integer_minus_one_node
= build_int_2 (-1, -1);
447 /* A few values used for range checking in the lexer. */
448 decimal_int_max
= build_int_2 (0x80000000, 0);
449 TREE_TYPE (decimal_int_max
) = unsigned_int_type_node
;
450 #if HOST_BITS_PER_WIDE_INT == 64
451 decimal_long_max
= build_int_2 (0x8000000000000000LL
, 0);
453 #if HOST_BITS_PER_WIDE_INT == 32
454 decimal_long_max
= build_int_2 (0, 0x80000000);
456 #error "unsupported size"
459 TREE_TYPE (decimal_long_max
) = unsigned_long_type_node
;
461 size_zero_node
= size_int (0);
462 size_one_node
= size_int (1);
463 bitsize_zero_node
= bitsize_int (0);
464 bitsize_one_node
= bitsize_int (1);
465 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
467 long_zero_node
= build_int_2 (0, 0);
468 TREE_TYPE (long_zero_node
) = long_type_node
;
470 void_type_node
= make_node (VOID_TYPE
);
471 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
472 layout_type (void_type_node
); /* Uses size_zero_node */
473 ptr_type_node
= build_pointer_type (void_type_node
);
474 t
= make_node (VOID_TYPE
);
475 layout_type (t
); /* Uses size_zero_node */
476 return_address_type_node
= build_pointer_type (t
);
478 null_pointer_node
= build_int_2 (0, 0);
479 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
481 /* Used by the parser to represent empty statements and blocks. */
482 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
483 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
486 /* Make a type to be the domain of a few array types
487 whose domains don't really matter.
488 200 is small enough that it always fits in size_t
489 and large enough that it can hold most function names for the
490 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
491 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
493 char_type_node
= make_node (CHAR_TYPE
);
494 TYPE_PRECISION (char_type_node
) = 16;
495 fixup_unsigned_type (char_type_node
);
496 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
498 boolean_type_node
= make_node (BOOLEAN_TYPE
);
499 TYPE_PRECISION (boolean_type_node
) = 1;
500 fixup_unsigned_type (boolean_type_node
);
501 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
503 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
504 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
506 promoted_byte_type_node
507 = push_promoted_type ("promoted_byte", byte_type_node
);
508 promoted_short_type_node
509 = push_promoted_type ("promoted_short", short_type_node
);
510 promoted_char_type_node
511 = push_promoted_type ("promoted_char", char_type_node
);
512 promoted_boolean_type_node
513 = push_promoted_type ("promoted_boolean", boolean_type_node
);
515 float_type_node
= make_node (REAL_TYPE
);
516 TYPE_PRECISION (float_type_node
) = 32;
517 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
519 layout_type (float_type_node
);
521 double_type_node
= make_node (REAL_TYPE
);
522 TYPE_PRECISION (double_type_node
) = 64;
523 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
525 layout_type (double_type_node
);
527 float_zero_node
= build_real (float_type_node
, dconst0
);
528 double_zero_node
= build_real (double_type_node
, dconst0
);
530 /* These are the vtables for arrays of primitives. */
531 boolean_array_vtable
= create_primitive_vtable ("boolean");
532 byte_array_vtable
= create_primitive_vtable ("byte");
533 char_array_vtable
= create_primitive_vtable ("char");
534 short_array_vtable
= create_primitive_vtable ("short");
535 int_array_vtable
= create_primitive_vtable ("int");
536 long_array_vtable
= create_primitive_vtable ("long");
537 float_array_vtable
= create_primitive_vtable ("float");
538 double_array_vtable
= create_primitive_vtable ("double");
540 /* As you're adding items here, please update the code right after
541 this section, so that the filename containing the source code of
542 the pre-defined class gets registered correctly. */
543 unqualified_object_id_node
= get_identifier ("Object");
544 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
545 object_ptr_type_node
= promote_type (object_type_node
);
546 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
547 string_ptr_type_node
= promote_type (string_type_node
);
548 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
549 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
550 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
551 runtime_exception_type_node
=
552 lookup_class (get_identifier ("java.lang.RuntimeException"));
553 error_exception_type_node
=
554 lookup_class (get_identifier ("java.lang.Error"));
555 class_not_found_type_node
=
556 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
557 no_class_def_found_type_node
=
558 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
560 rawdata_ptr_type_node
561 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
563 add_predefined_file (get_identifier ("java/lang/Class.java"));
564 add_predefined_file (get_identifier ("java/lang/Error.java"));
565 add_predefined_file (get_identifier ("java/lang/Object.java"));
566 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
567 add_predefined_file (get_identifier ("java/lang/String.java"));
568 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
569 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
570 add_predefined_file (get_identifier ("java/lang/Exception.java"));
571 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
572 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
573 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
575 methodtable_type
= make_node (RECORD_TYPE
);
576 layout_type (methodtable_type
);
577 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
578 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
580 TYPE_identifier_node
= get_identifier ("TYPE");
581 init_identifier_node
= get_identifier ("<init>");
582 clinit_identifier_node
= get_identifier ("<clinit>");
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 finalize_identifier_node
= get_identifier ("finalize");
588 this_identifier_node
= get_identifier ("this");
589 super_identifier_node
= get_identifier ("super");
590 continue_identifier_node
= get_identifier ("continue");
591 access0_identifier_node
= get_identifier ("access$0");
592 classdollar_identifier_node
= get_identifier ("class$");
594 java_lang_cloneable_identifier_node
= get_identifier ("java.lang.Cloneable");
595 java_io_serializable_identifier_node
=
596 get_identifier ("java.io.Serializable");
598 /* for lack of a better place to put this stub call */
599 init_expr_processing();
601 utf8const_type
= make_node (RECORD_TYPE
);
602 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
603 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
604 FINISH_RECORD (utf8const_type
);
605 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
607 constants_type_node
= make_node (RECORD_TYPE
);
608 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
609 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
610 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
611 FINISH_RECORD (constants_type_node
);
612 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
614 access_flags_type_node
= unsigned_short_type_node
;
616 dtable_type
= make_node (RECORD_TYPE
);
617 dtable_ptr_type
= build_pointer_type (dtable_type
);
619 one_elt_array_domain_type
= build_index_type (integer_one_node
);
620 otable_type
= build_array_type (integer_type_node
,
621 one_elt_array_domain_type
);
622 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
623 otable_ptr_type
= build_pointer_type (otable_type
);
625 method_symbol_type
= make_node (RECORD_TYPE
);
626 PUSH_FIELD (method_symbol_type
, field
, "clname", utf8const_ptr_type
);
627 PUSH_FIELD (method_symbol_type
, field
, "name", utf8const_ptr_type
);
628 PUSH_FIELD (method_symbol_type
, field
, "signature", utf8const_ptr_type
);
629 FINISH_RECORD (method_symbol_type
);
631 method_symbols_array_type
= build_array_type (method_symbol_type
,
632 one_elt_array_domain_type
);
633 method_symbols_array_ptr_type
= build_pointer_type
634 (method_symbols_array_type
);
636 if (flag_indirect_dispatch
)
638 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"),
640 DECL_EXTERNAL (otable_decl
) = 1;
641 TREE_STATIC (otable_decl
) = 1;
642 TREE_READONLY (otable_decl
) = 1;
643 pushdecl (otable_decl
);
645 otable_syms_decl
= build_decl (VAR_DECL
, get_identifier ("otable_syms"),
646 method_symbols_array_type
);
647 TREE_STATIC (otable_syms_decl
) = 1;
648 TREE_CONSTANT (otable_syms_decl
) = 1;
649 pushdecl (otable_syms_decl
);
652 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
653 /* This isn't exactly true, but it is what we have in the source.
654 There is an unresolved issue here, which is whether the vtable
655 should be marked by the GC. */
656 if (! flag_hash_synchronization
)
657 PUSH_FIELD (object_type_node
, field
, "sync_info",
658 build_pointer_type (object_type_node
));
659 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
660 FIELD_PRIVATE (t
) = 1;
661 FINISH_RECORD (object_type_node
);
663 field_type_node
= make_node (RECORD_TYPE
);
664 field_ptr_type_node
= build_pointer_type (field_type_node
);
665 method_type_node
= make_node (RECORD_TYPE
);
666 method_ptr_type_node
= build_pointer_type (method_type_node
);
668 set_super_info (0, class_type_node
, object_type_node
, 0);
669 set_super_info (0, string_type_node
, object_type_node
, 0);
670 class_ptr_type
= build_pointer_type (class_type_node
);
672 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
673 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
674 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
675 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
676 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
677 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
678 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
679 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
680 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
681 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
682 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
683 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
684 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
685 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
686 PUSH_FIELD (class_type_node
, field
, "otable_syms",
687 method_symbols_array_ptr_type
);
688 PUSH_FIELD (class_type_node
, field
, "interfaces",
689 build_pointer_type (class_ptr_type
));
690 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
691 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
692 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
693 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
694 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
695 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
696 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
697 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
698 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
699 PUSH_FIELD (class_type_node
, field
, "chain", ptr_type_node
);
700 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
701 FIELD_PRIVATE (t
) = 1;
702 push_super_field (class_type_node
, object_type_node
);
704 FINISH_RECORD (class_type_node
);
705 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
707 field_info_union_node
= make_node (UNION_TYPE
);
708 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
709 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
711 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
713 layout_type (field_info_union_node
);
715 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
716 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
717 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
718 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
719 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
720 FINISH_RECORD (field_type_node
);
721 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
723 nativecode_ptr_array_type_node
724 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
726 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
727 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
728 FINISH_RECORD (dtable_type
);
729 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
731 #define jint_type int_type_node
732 #define jint_ptr_type ptr_type_node
734 jexception_type
= make_node (RECORD_TYPE
);
735 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
736 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
737 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
738 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
739 FINISH_RECORD (jexception_type
);
740 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
741 jexception_ptr_type
= build_pointer_type (jexception_type
);
743 lineNumberEntry_type
= make_node (RECORD_TYPE
);
744 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
745 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
746 FINISH_RECORD (lineNumberEntry_type
);
748 lineNumbers_type
= make_node (RECORD_TYPE
);
749 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
750 FINISH_RECORD (lineNumbers_type
);
752 #define instn_ptr_type_node ptr_type_node /* XXX JH */
754 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
756 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
757 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
758 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
759 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
760 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
761 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
762 FINISH_RECORD (method_type_node
);
763 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
765 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
767 t
= tree_cons (NULL_TREE
, class_ptr_type
,
768 tree_cons (NULL_TREE
, int_type_node
, endlink
));
769 alloc_object_node
= builtin_function ("_Jv_AllocObject",
770 build_function_type (ptr_type_node
, t
),
771 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
772 DECL_IS_MALLOC (alloc_object_node
) = 1;
773 alloc_no_finalizer_node
=
774 builtin_function ("_Jv_AllocObjectNoFinalizer",
775 build_function_type (ptr_type_node
, t
),
776 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
777 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
779 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
780 soft_initclass_node
= builtin_function ("_Jv_InitClass",
781 build_function_type (void_type_node
,
783 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
785 throw_node
= builtin_function ("_Jv_Throw",
786 build_function_type (ptr_type_node
, t
),
787 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
788 /* Mark throw_nodes as `noreturn' functions with side effects. */
789 TREE_THIS_VOLATILE (throw_node
) = 1;
790 TREE_SIDE_EFFECTS (throw_node
) = 1;
792 t
= build_function_type (int_type_node
, endlink
);
793 soft_monitorenter_node
794 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
796 soft_monitorexit_node
797 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
800 t
= tree_cons (NULL_TREE
, int_type_node
,
801 tree_cons (NULL_TREE
, int_type_node
, endlink
));
803 = builtin_function ("_Jv_NewPrimArray",
804 build_function_type(ptr_type_node
, t
),
805 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
806 DECL_IS_MALLOC (soft_newarray_node
) = 1;
808 t
= tree_cons (NULL_TREE
, int_type_node
,
809 tree_cons (NULL_TREE
, class_ptr_type
,
810 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
812 = builtin_function ("_Jv_NewObjectArray",
813 build_function_type (ptr_type_node
, t
),
814 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
815 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
817 /* There is no endlink here because _Jv_NewMultiArray is a varargs
819 t
= tree_cons (NULL_TREE
, ptr_type_node
,
820 tree_cons (NULL_TREE
, int_type_node
, NULL_TREE
));
821 soft_multianewarray_node
822 = builtin_function ("_Jv_NewMultiArray",
823 build_function_type (ptr_type_node
, t
),
824 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
825 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
827 t
= build_function_type (void_type_node
,
828 tree_cons (NULL_TREE
, int_type_node
, endlink
));
829 soft_badarrayindex_node
830 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
831 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
832 /* Mark soft_badarrayindex_node as a `noreturn' function with side
834 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
835 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
837 soft_nullpointer_node
838 = builtin_function ("_Jv_ThrowNullPointerException",
839 build_function_type (void_type_node
, endlink
),
840 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
841 /* Mark soft_nullpointer_node as a `noreturn' function with side
843 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
844 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
846 t
= tree_cons (NULL_TREE
, class_ptr_type
,
847 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
849 = builtin_function ("_Jv_CheckCast",
850 build_function_type (ptr_type_node
, t
),
851 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
852 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
853 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
855 = builtin_function ("_Jv_IsInstanceOf",
856 build_function_type (boolean_type_node
, t
),
857 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
858 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
859 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
860 soft_checkarraystore_node
861 = builtin_function ("_Jv_CheckArrayStore",
862 build_function_type (void_type_node
, t
),
863 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
864 t
= tree_cons (NULL_TREE
, ptr_type_node
,
865 tree_cons (NULL_TREE
, ptr_type_node
,
866 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
867 soft_lookupinterfacemethod_node
868 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
869 build_function_type (ptr_type_node
, t
),
870 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
872 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
873 tree_cons (NULL_TREE
, ptr_type_node
,
874 tree_cons (NULL_TREE
, ptr_type_node
,
875 tree_cons (NULL_TREE
, int_type_node
,
877 soft_lookupjnimethod_node
878 = builtin_function ("_Jv_LookupJNIMethod",
879 build_function_type (ptr_type_node
, t
),
880 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
881 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
882 soft_getjnienvnewframe_node
883 = builtin_function ("_Jv_GetJNIEnvNewFrame",
884 build_function_type (ptr_type_node
, t
),
885 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
886 soft_jnipopsystemframe_node
887 = builtin_function ("_Jv_JNI_PopSystemFrame",
888 build_function_type (ptr_type_node
, t
),
889 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
892 = builtin_function ("_Jv_divI",
893 build_function_type (int_type_node
, t
),
894 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
897 = builtin_function ("_Jv_remI",
898 build_function_type (int_type_node
, t
),
899 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
902 = builtin_function ("_Jv_divJ",
903 build_function_type (long_type_node
, t
),
904 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
907 = builtin_function ("_Jv_remJ",
908 build_function_type (long_type_node
, t
),
909 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
911 /* Initialize variables for except.c. */
912 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
913 ? "__gcj_personality_sj0"
914 : "__gcj_personality_v0");
915 lang_eh_runtime_type
= prepare_eh_table_type
;
919 initialize_builtins ();
921 soft_fmod_node
= built_in_decls
[BUILT_IN_FMOD
];
923 soft_fmodf_node
= built_in_decls
[BUILT_IN_FMODF
];
928 /* Look up NAME in the current binding level and its superiors
929 in the namespace of variables, functions and typedefs.
930 Return a ..._DECL node of some kind representing its definition,
931 or return 0 if it is undefined. */
934 lookup_name (tree name
)
937 if (current_binding_level
!= global_binding_level
938 && IDENTIFIER_LOCAL_VALUE (name
))
939 val
= IDENTIFIER_LOCAL_VALUE (name
);
941 val
= IDENTIFIER_GLOBAL_VALUE (name
);
945 /* Similar to `lookup_name' but look only at current binding level and
946 the previous one if its the parameter level. */
949 lookup_name_current_level (tree name
)
953 if (current_binding_level
== global_binding_level
)
954 return IDENTIFIER_GLOBAL_VALUE (name
);
956 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
959 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
960 if (DECL_NAME (t
) == name
)
966 /* Use a binding level to record a labeled block declaration */
969 push_labeled_block (tree lb
)
971 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
972 register struct binding_level
*b
= current_binding_level
;
973 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
975 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
976 TREE_CHAIN (lb
) = b
->names
;
978 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
981 /* Pop the current binding level, reinstalling values for the previous
985 pop_labeled_block (void)
987 struct binding_level
*b
= current_binding_level
;
988 tree label
= b
->names
;
989 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
992 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
993 TREE_VALUE (b
->shadowed
);
995 /* Pop the current level, and free the structure for reuse. */
996 current_binding_level
= current_binding_level
->level_chain
;
997 b
->level_chain
= free_binding_level
;
998 free_binding_level
= b
;
1001 /* Record a decl-node X as belonging to the current lexical scope.
1002 Check for errors (such as an incompatible declaration for the same
1003 name already seen in the same scope).
1005 Returns either X or an old decl for the same name.
1006 If an old decl is returned, it may have been smashed
1007 to agree with what X says. */
1013 register tree name
= DECL_NAME (x
);
1014 register struct binding_level
*b
= current_binding_level
;
1016 if (TREE_CODE (x
) != TYPE_DECL
)
1017 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 ("%J'%D' used prior to declaration", x
, x
);
1028 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1029 to point to the TYPE_DECL.
1030 Since Java does not have typedefs, a type can only have
1031 one (true) name, given by a class, interface, or builtin. */
1032 if (TREE_CODE (x
) == TYPE_DECL
1033 && TYPE_NAME (TREE_TYPE (x
)) == 0
1034 && TREE_TYPE (x
) != error_mark_node
)
1036 TYPE_NAME (TREE_TYPE (x
)) = x
;
1037 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1040 /* This name is new in its binding level.
1041 Install the new declaration and return it. */
1042 if (b
== global_binding_level
)
1044 /* Install a global value. */
1046 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1050 /* Here to install a non-global value. */
1051 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1052 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1055 /* Warn if shadowing an argument at the top level of the body. */
1056 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1057 /* This warning doesn't apply to the parms of a nested fcn. */
1058 && ! current_binding_level
->parm_flag
1059 /* Check that this is one level down from the parms. */
1060 && current_binding_level
->level_chain
->parm_flag
1061 /* Check that the decl being shadowed
1062 comes from the parm level, one level up. */
1063 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1065 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1066 pedwarn ("declaration of `%s' shadows a parameter",
1067 IDENTIFIER_POINTER (name
));
1069 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1070 IDENTIFIER_POINTER (name
));
1073 /* Maybe warn if shadowing something else. */
1074 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1075 /* No shadow warnings for internally generated vars. */
1076 && DECL_SOURCE_LINE (x
) != 0
1077 /* No shadow warnings for vars made for inlining. */
1078 && ! DECL_FROM_INLINE (x
))
1080 const char *warnstring
= 0;
1082 if (TREE_CODE (x
) == PARM_DECL
1083 && current_binding_level
->level_chain
->parm_flag
)
1084 /* Don't warn about the parm names in function declarator
1085 within a function declarator.
1086 It would be nice to avoid warning in any function
1087 declarator in a declaration, as opposed to a definition,
1088 but there is no way to tell it's not a definition. */
1090 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1091 warnstring
= "declaration of `%s' shadows a parameter";
1092 else if (oldlocal
!= 0)
1093 warnstring
= "declaration of `%s' shadows previous local";
1094 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1095 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1096 warnstring
= "declaration of `%s' shadows global declaration";
1099 warning (warnstring
, IDENTIFIER_POINTER (name
));
1103 /* If storing a local value, there may already be one (inherited).
1104 If so, record it for restoration when this binding level ends. */
1106 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1110 /* Put decls on list in reverse order.
1111 We will reverse them later if necessary. */
1112 TREE_CHAIN (x
) = b
->names
;
1119 pushdecl_force_head (tree x
)
1121 current_binding_level
->names
= x
;
1124 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1127 pushdecl_top_level (tree x
)
1130 register struct binding_level
*b
= current_binding_level
;
1132 current_binding_level
= global_binding_level
;
1134 current_binding_level
= b
;
1138 /* Nonzero if we are currently in the global binding level. */
1141 global_bindings_p (void)
1143 return current_binding_level
== global_binding_level
;
1146 /* Return the list of declarations of the current level.
1147 Note that this list is in reverse order unless/until
1148 you nreverse it; and when you do nreverse it, you must
1149 store the result back using `storedecls' or you will lose. */
1154 return current_binding_level
->names
;
1157 /* Create a new `struct binding_level'. */
1159 static struct binding_level
*
1160 make_binding_level (void)
1163 return xmalloc (sizeof (struct binding_level
));
1167 pushlevel (int unused ATTRIBUTE_UNUSED
)
1169 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1172 /* If this is the top level of a function,
1173 just make sure that NAMED_LABELS is 0. */
1175 if (current_binding_level
== global_binding_level
)
1179 /* Reuse or create a struct for this binding level. */
1181 if (free_binding_level
)
1183 newlevel
= free_binding_level
;
1184 free_binding_level
= free_binding_level
->level_chain
;
1188 newlevel
= make_binding_level ();
1191 /* Add this level to the front of the chain (stack) of levels that
1194 *newlevel
= clear_binding_level
;
1195 newlevel
->level_chain
= current_binding_level
;
1196 current_binding_level
= newlevel
;
1197 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1198 newlevel
->binding_depth
= binding_depth
;
1200 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1201 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1204 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1207 /* Exit a binding level.
1208 Pop the level off, and restore the state of the identifier-decl mappings
1209 that were in effect when this level was entered.
1211 If KEEP is nonzero, this level had explicit declarations, so
1212 and create a "block" (a BLOCK node) for the level
1213 to record its declarations and subblocks for symbol table output.
1215 If FUNCTIONBODY is nonzero, this level is the body of a function,
1216 so create a block as if KEEP were set and also clear out all
1219 If REVERSE is nonzero, reverse the order of decls before putting
1220 them into the BLOCK. */
1223 poplevel (int keep
, int reverse
, int functionbody
)
1226 /* The chain of decls was accumulated in reverse order.
1227 Put it into forward order, just for cleanliness. */
1229 tree subblocks
= current_binding_level
->blocks
;
1232 int block_previously_created
;
1234 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1237 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1238 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1239 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1240 current_binding_level
->end_pc
);
1242 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1243 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1245 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1248 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1252 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1254 /* Get the decls in the order they were written.
1255 Usually current_binding_level->names is in reverse order.
1256 But parameter decls were previously put in forward order. */
1259 current_binding_level
->names
1260 = decls
= nreverse (current_binding_level
->names
);
1262 decls
= current_binding_level
->names
;
1264 /* Output any nested inline functions within this block
1265 if they weren't already output. */
1267 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1268 if (TREE_CODE (decl
) == FUNCTION_DECL
1269 && ! TREE_ASM_WRITTEN (decl
)
1270 && DECL_INITIAL (decl
) != 0
1271 && TREE_ADDRESSABLE (decl
))
1273 /* If this decl was copied from a file-scope decl
1274 on account of a block-scope extern decl,
1275 propagate TREE_ADDRESSABLE to the file-scope decl.
1277 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1278 true, since then the decl goes through save_for_inline_copying. */
1279 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1280 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1281 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1284 push_function_context ();
1285 output_inline_function (decl
);
1286 pop_function_context ();
1290 /* If there were any declarations in that level,
1291 or if this level is a function body,
1292 create a BLOCK to record them for the life of this function. */
1295 block_previously_created
= (current_binding_level
->this_block
!= 0);
1296 if (block_previously_created
)
1297 block
= current_binding_level
->this_block
;
1298 else if (keep
|| functionbody
)
1299 block
= make_node (BLOCK
);
1302 BLOCK_VARS (block
) = decls
;
1303 BLOCK_SUBBLOCKS (block
) = subblocks
;
1306 /* In each subblock, record that this is its superior. */
1308 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1309 BLOCK_SUPERCONTEXT (link
) = block
;
1311 /* Clear out the meanings of the local variables of this level. */
1313 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1315 tree name
= DECL_NAME (link
);
1316 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1318 /* If the ident. was used or addressed via a local extern decl,
1319 don't forget that fact. */
1320 if (DECL_EXTERNAL (link
))
1322 if (TREE_USED (link
))
1323 TREE_USED (name
) = 1;
1324 if (TREE_ADDRESSABLE (link
))
1325 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1327 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1331 /* Restore all name-meanings of the outer levels
1332 that were shadowed by this level. */
1334 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1335 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1337 /* If the level being exited is the top level of a function,
1338 check over all the labels, and clear out the current
1339 (function local) meanings of their names. */
1343 /* If this is the top level block of a function,
1344 the vars are the function's parameters.
1345 Don't leave them in the BLOCK because they are
1346 found in the FUNCTION_DECL instead. */
1348 BLOCK_VARS (block
) = 0;
1350 /* Clear out the definitions of all label names,
1351 since their scopes end here,
1352 and add them to BLOCK_VARS. */
1355 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1357 register tree label
= TREE_VALUE (link
);
1359 if (DECL_INITIAL (label
) == 0)
1361 error ("%Jlabel '%D' used but not defined", label
, label
);
1362 /* Avoid crashing later. */
1363 define_label (input_location
, DECL_NAME (label
));
1365 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1366 warning ("%Jlabel '%D' defined but not used", label
, label
);
1367 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1369 /* Put the labels into the "variables" of the
1370 top-level block, so debugger can see them. */
1371 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1372 BLOCK_VARS (block
) = label
;
1377 /* Pop the current level, and free the structure for reuse. */
1380 register struct binding_level
*level
= current_binding_level
;
1381 current_binding_level
= current_binding_level
->level_chain
;
1383 level
->level_chain
= free_binding_level
;
1384 free_binding_level
= level
;
1387 /* Dispose of the block that we just made inside some higher level. */
1389 DECL_INITIAL (current_function_decl
) = block
;
1392 if (!block_previously_created
)
1393 current_binding_level
->blocks
1394 = chainon (current_binding_level
->blocks
, block
);
1396 /* If we did not make a block for the level just exited,
1397 any blocks made for inner levels
1398 (since they cannot be recorded as subblocks in that level)
1399 must be carried forward so they will later become subblocks
1400 of something else. */
1402 current_binding_level
->blocks
1403 = chainon (current_binding_level
->blocks
, subblocks
);
1405 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1406 binding contour so that they point to the appropriate construct, i.e.
1407 either to the current FUNCTION_DECL node, or else to the BLOCK node
1408 we just constructed.
1410 Note that for tagged types whose scope is just the formal parameter
1411 list for some function type specification, we can't properly set
1412 their TYPE_CONTEXTs here, because we don't have a pointer to the
1413 appropriate FUNCTION_TYPE node readily available to us. For those
1414 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1415 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1416 node which will represent the "scope" for these "parameter list local"
1421 TREE_USED (block
) = 1;
1426 maybe_pushlevels (int pc
)
1428 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1432 while (pending_local_decls
!= NULL_TREE
&&
1433 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1435 tree
*ptr
= &pending_local_decls
;
1437 int end_pc
= DECL_LOCAL_END_PC (decl
);
1439 while (*ptr
!= NULL_TREE
1440 && DECL_LOCAL_START_PC (*ptr
) <= pc
1441 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1442 ptr
= &TREE_CHAIN (*ptr
);
1443 pending_local_decls
= *ptr
;
1446 /* Force non-nested range to be nested in current range. */
1447 if (end_pc
> current_binding_level
->end_pc
)
1448 end_pc
= current_binding_level
->end_pc
;
1450 maybe_start_try (pc
, end_pc
);
1453 expand_start_bindings (0);
1455 current_binding_level
->end_pc
= end_pc
;
1456 current_binding_level
->start_pc
= pc
;
1457 current_binding_level
->names
= decl
;
1458 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1460 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1464 maybe_start_try (pc
, 0);
1468 maybe_poplevels (int pc
)
1470 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1474 while (current_binding_level
->end_pc
<= pc
)
1476 expand_end_bindings (getdecls (), 1, 0);
1477 maybe_end_try (current_binding_level
->start_pc
, pc
);
1480 maybe_end_try (0, pc
);
1483 /* Terminate any binding which began during the range beginning at
1484 start_pc. This tidies up improperly nested local variable ranges
1485 and exception handlers; a variable declared within an exception
1486 range is forcibly terminated when that exception ends. */
1489 force_poplevels (int start_pc
)
1491 while (current_binding_level
->start_pc
> start_pc
)
1493 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1494 warning ("%JIn %D: overlapped variable and exception ranges at %d",
1495 current_function_decl
, current_function_decl
,
1496 current_binding_level
->start_pc
);
1497 expand_end_bindings (getdecls (), 1, 0);
1502 /* Insert BLOCK at the end of the list of subblocks of the
1503 current binding level. This is used when a BIND_EXPR is expanded,
1504 to handle the BLOCK node inside the BIND_EXPR. */
1507 insert_block (tree block
)
1509 TREE_USED (block
) = 1;
1510 current_binding_level
->blocks
1511 = chainon (current_binding_level
->blocks
, block
);
1514 /* Set the BLOCK node for the innermost scope
1515 (the one we are currently in). */
1518 set_block (tree block
)
1520 current_binding_level
->this_block
= block
;
1521 current_binding_level
->names
= chainon (current_binding_level
->names
,
1522 BLOCK_VARS (block
));
1523 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1524 BLOCK_SUBBLOCKS (block
));
1527 /* integrate_decl_tree calls this function. */
1530 java_dup_lang_specific_decl (tree node
)
1533 struct lang_decl
*x
;
1535 if (!DECL_LANG_SPECIFIC (node
))
1538 lang_decl_size
= sizeof (struct lang_decl
);
1539 x
= ggc_alloc (lang_decl_size
);
1540 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1541 DECL_LANG_SPECIFIC (node
) = x
;
1545 give_name_to_locals (JCF
*jcf
)
1547 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1548 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1550 pending_local_decls
= NULL_TREE
;
1554 n
= JCF_readu2 (jcf
);
1555 for (i
= 0; i
< n
; i
++)
1557 int start_pc
= JCF_readu2 (jcf
);
1558 int length
= JCF_readu2 (jcf
);
1559 int name_index
= JCF_readu2 (jcf
);
1560 int signature_index
= JCF_readu2 (jcf
);
1561 int slot
= JCF_readu2 (jcf
);
1562 tree name
= get_name_constant (jcf
, name_index
);
1563 tree type
= parse_signature (jcf
, signature_index
);
1564 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1566 && length
== DECL_CODE_LENGTH (current_function_decl
))
1568 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1569 DECL_NAME (decl
) = name
;
1570 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1571 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1572 warning ("bad type in parameter debug info");
1577 int end_pc
= start_pc
+ length
;
1578 tree decl
= build_decl (VAR_DECL
, name
, type
);
1579 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1581 warning ("%Jbad PC range for debug info for local '%D'",
1583 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1586 /* Adjust start_pc if necessary so that the local's first
1587 store operation will use the relevant DECL as a
1588 destination. Fore more information, read the leading
1589 comments for expr.c:maybe_adjust_start_pc. */
1590 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1592 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1593 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1594 DECL_LOCAL_START_PC (decl
) = start_pc
;
1596 /* FIXME: The range used internally for exceptions and local
1597 variable ranges, is a half-open interval:
1598 start_pc <= pc < end_pc. However, the range used in the
1599 Java VM spec is inclusive at both ends:
1600 start_pc <= pc <= end_pc. */
1603 DECL_LOCAL_END_PC (decl
) = end_pc
;
1605 /* Now insert the new decl in the proper place in
1606 pending_local_decls. We are essentially doing an insertion sort,
1607 which works fine, since the list input will normally already
1609 ptr
= &pending_local_decls
;
1610 while (*ptr
!= NULL_TREE
1611 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1612 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1613 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1614 ptr
= &TREE_CHAIN (*ptr
);
1615 TREE_CHAIN (decl
) = *ptr
;
1620 pending_local_decls
= nreverse (pending_local_decls
);
1622 /* Fill in default names for the parameters. */
1623 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1624 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1626 if (DECL_NAME (parm
) == NULL_TREE
)
1628 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1630 DECL_NAME (parm
) = get_identifier ("this");
1634 sprintf (buffer
, "ARG_%d", arg_i
);
1635 DECL_NAME (parm
) = get_identifier (buffer
);
1637 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1643 build_result_decl (tree fndecl
)
1645 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1646 tree result
= DECL_RESULT (fndecl
);
1649 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1650 if (INTEGRAL_TYPE_P (restype
)
1651 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1652 restype
= integer_type_node
;
1653 result
= build_decl (RESULT_DECL
, NULL_TREE
, restype
);
1654 DECL_CONTEXT (result
) = fndecl
;
1655 DECL_RESULT (fndecl
) = result
;
1661 complete_start_java_method (tree fndecl
)
1663 if (! flag_emit_class_files
)
1665 /* Initialize the RTL code for the function. */
1666 init_function_start (fndecl
);
1668 /* Set up parameters and prepare for return, for the function. */
1669 expand_function_start (fndecl
, 0);
1673 /* If this fcn was already referenced via a block-scope `extern' decl (or
1674 an implicit decl), propagate certain information about the usage. */
1675 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1676 TREE_ADDRESSABLE (current_function_decl
) = 1;
1680 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1681 && ! flag_emit_class_files
1682 && ! DECL_CLINIT_P (fndecl
)
1683 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1685 tree clas
= DECL_CONTEXT (fndecl
);
1686 tree init
= build (CALL_EXPR
, void_type_node
,
1687 build_address_of (soft_initclass_node
),
1688 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1690 TREE_SIDE_EFFECTS (init
) = 1;
1691 expand_expr_stmt (init
);
1694 /* Push local variables. Function compiled from source code are
1695 using a different local variables management, and for them,
1696 pushlevel shouldn't be called from here. */
1697 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1700 if (! flag_emit_class_files
)
1701 expand_start_bindings (1);
1704 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1706 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1707 tree enter
, exit
, lock
;
1708 if (METHOD_STATIC (fndecl
))
1709 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1711 lock
= DECL_ARGUMENTS (fndecl
);
1712 BUILD_MONITOR_ENTER (enter
, lock
);
1713 BUILD_MONITOR_EXIT (exit
, lock
);
1714 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1716 expand_expr_stmt (enter
);
1717 expand_decl_cleanup (NULL_TREE
, exit
);
1721 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1722 tree body
= BLOCK_EXPR_BODY (function_body
);
1723 lock
= build (COMPOUND_EXPR
, void_type_node
,
1725 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1726 TREE_SIDE_EFFECTS (lock
) = 1;
1727 BLOCK_EXPR_BODY (function_body
) = lock
;
1733 start_java_method (tree fndecl
)
1738 current_function_decl
= fndecl
;
1739 announce_function (fndecl
);
1741 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1742 decl_map
= make_tree_vec (i
);
1743 type_map
= xrealloc (type_map
, i
* sizeof (tree
));
1745 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1746 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1748 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1749 pushlevel (1); /* Push parameters. */
1751 ptr
= &DECL_ARGUMENTS (fndecl
);
1752 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1753 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1755 tree parm_name
= NULL_TREE
, parm_decl
;
1756 tree parm_type
= TREE_VALUE (tem
);
1757 if (i
>= DECL_MAX_LOCALS (fndecl
))
1760 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1761 DECL_CONTEXT (parm_decl
) = fndecl
;
1762 if (PROMOTE_PROTOTYPES
1763 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1764 && INTEGRAL_TYPE_P (parm_type
))
1765 parm_type
= integer_type_node
;
1766 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1769 ptr
= &TREE_CHAIN (parm_decl
);
1771 /* Add parm_decl to the decl_map. */
1772 push_jvm_slot (i
, parm_decl
);
1774 type_map
[i
] = TREE_TYPE (parm_decl
);
1775 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1778 type_map
[i
] = void_type_node
;
1782 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1784 while (i
< DECL_MAX_LOCALS(fndecl
))
1785 type_map
[i
++] = NULL_TREE
;
1787 build_result_decl (fndecl
);
1788 complete_start_java_method (fndecl
);
1792 end_java_method (void)
1794 tree fndecl
= current_function_decl
;
1796 expand_end_bindings (getdecls (), 1, 0);
1797 /* pop out of function */
1800 /* pop out of its parameters */
1803 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1805 /* Generate rtl for function exit. */
1806 expand_function_end ();
1808 /* Run the optimizers and output assembler code for this function. */
1809 rest_of_compilation (fndecl
);
1811 current_function_decl
= NULL_TREE
;
1814 /* Expand a function's body. */
1817 java_expand_body (tree fndecl
)
1819 const char *saved_input_filename
= input_filename
;
1820 int saved_lineno
= input_line
;
1822 current_function_decl
= fndecl
;
1823 input_filename
= DECL_SOURCE_FILE (fndecl
);
1824 input_line
= DECL_SOURCE_LINE (fndecl
);
1826 timevar_push (TV_EXPAND
);
1828 /* Prepare the function for tree completion. */
1829 start_complete_expand_method (fndecl
);
1831 if (! flag_emit_class_files
&& ! flag_emit_xref
)
1833 /* Initialize the RTL code for the function. */
1834 init_function_start (fndecl
);
1836 /* Set up parameters and prepare for return, for the function. */
1837 expand_function_start (fndecl
, 0);
1839 /* Generate the RTL for this function. */
1840 expand_expr_stmt_value (DECL_SAVED_TREE (fndecl
), 0, 1);
1843 /* Pop out of its parameters. */
1844 pushdecl_force_head (DECL_ARGUMENTS (fndecl
));
1846 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1848 if (! flag_emit_class_files
&& ! flag_emit_xref
)
1850 /* Generate RTL for function exit. */
1851 input_line
= DECL_FUNCTION_LAST_LINE (fndecl
);
1852 expand_function_end ();
1854 /* Run the optimizers and output the assembler code
1855 for this function. */
1856 rest_of_compilation (fndecl
);
1859 timevar_pop (TV_EXPAND
);
1861 input_filename
= saved_input_filename
;
1862 input_line
= saved_lineno
;
1864 current_function_decl
= NULL_TREE
;
1867 /* We pessimistically marked all methods and fields external until we
1868 knew what set of classes we were planning to compile. Now mark those
1869 associated with CLASS to be generated locally as not external. */
1872 java_mark_decl_local (tree decl
)
1874 DECL_EXTERNAL (decl
) = 0;
1876 /* If we've already constructed DECL_RTL, give encode_section_info
1877 a second chance, now that we've changed the flags. */
1878 if (DECL_RTL_SET_P (decl
))
1879 make_decl_rtl (decl
, NULL
);
1883 java_mark_class_local (tree
class)
1887 for (t
= TYPE_FIELDS (class); t
; t
= TREE_CHAIN (t
))
1888 if (FIELD_STATIC (t
))
1889 java_mark_decl_local (t
);
1891 for (t
= TYPE_METHODS (class); t
; t
= TREE_CHAIN (t
))
1892 if (!METHOD_ABSTRACT (t
) && (!METHOD_NATIVE (t
) || flag_jni
))
1893 java_mark_decl_local (t
);
1896 #include "gt-java-decl.h"