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 initilization 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 ();
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 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"), otable_type
);
637 DECL_EXTERNAL (otable_decl
) = 1;
638 TREE_STATIC (otable_decl
) = 1;
639 TREE_READONLY (otable_decl
) = 1;
640 pushdecl (otable_decl
);
642 otable_syms_decl
= build_decl (VAR_DECL
, get_identifier ("otable_syms"),
643 method_symbols_array_type
);
644 TREE_STATIC (otable_syms_decl
) = 1;
645 TREE_CONSTANT (otable_syms_decl
) = 1;
646 pushdecl (otable_syms_decl
);
648 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
649 /* This isn't exactly true, but it is what we have in the source.
650 There is an unresolved issue here, which is whether the vtable
651 should be marked by the GC. */
652 if (! flag_hash_synchronization
)
653 PUSH_FIELD (object_type_node
, field
, "sync_info",
654 build_pointer_type (object_type_node
));
655 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
656 FIELD_PRIVATE (t
) = 1;
657 FINISH_RECORD (object_type_node
);
659 field_type_node
= make_node (RECORD_TYPE
);
660 field_ptr_type_node
= build_pointer_type (field_type_node
);
661 method_type_node
= make_node (RECORD_TYPE
);
662 method_ptr_type_node
= build_pointer_type (method_type_node
);
664 set_super_info (0, class_type_node
, object_type_node
, 0);
665 set_super_info (0, string_type_node
, object_type_node
, 0);
666 class_ptr_type
= build_pointer_type (class_type_node
);
668 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
669 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
670 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
671 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
672 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
673 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
674 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
675 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
676 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
677 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
678 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
679 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
680 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
681 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
682 PUSH_FIELD (class_type_node
, field
, "otable_syms",
683 method_symbols_array_ptr_type
);
684 PUSH_FIELD (class_type_node
, field
, "interfaces",
685 build_pointer_type (class_ptr_type
));
686 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
687 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
688 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
689 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
690 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
691 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
692 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
693 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
694 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
695 PUSH_FIELD (class_type_node
, field
, "chain", ptr_type_node
);
696 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
697 FIELD_PRIVATE (t
) = 1;
698 push_super_field (class_type_node
, object_type_node
);
700 FINISH_RECORD (class_type_node
);
701 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
703 field_info_union_node
= make_node (UNION_TYPE
);
704 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
705 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
707 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
709 layout_type (field_info_union_node
);
711 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
712 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
713 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
714 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
715 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
716 FINISH_RECORD (field_type_node
);
717 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
719 nativecode_ptr_array_type_node
720 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
722 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
723 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
724 FINISH_RECORD (dtable_type
);
725 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
727 #define jint_type int_type_node
728 #define jint_ptr_type ptr_type_node
730 jexception_type
= make_node (RECORD_TYPE
);
731 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
732 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
733 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
734 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
735 FINISH_RECORD (jexception_type
);
736 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
737 jexception_ptr_type
= build_pointer_type (jexception_type
);
739 lineNumberEntry_type
= make_node (RECORD_TYPE
);
740 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
741 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
742 FINISH_RECORD (lineNumberEntry_type
);
744 lineNumbers_type
= make_node (RECORD_TYPE
);
745 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
746 FINISH_RECORD (lineNumbers_type
);
748 #define instn_ptr_type_node ptr_type_node /* XXX JH */
750 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
752 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
753 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
754 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
755 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
756 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
757 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
758 FINISH_RECORD (method_type_node
);
759 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
761 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
763 t
= tree_cons (NULL_TREE
, class_ptr_type
,
764 tree_cons (NULL_TREE
, int_type_node
, endlink
));
765 alloc_object_node
= builtin_function ("_Jv_AllocObject",
766 build_function_type (ptr_type_node
, t
),
767 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
768 DECL_IS_MALLOC (alloc_object_node
) = 1;
769 alloc_no_finalizer_node
=
770 builtin_function ("_Jv_AllocObjectNoFinalizer",
771 build_function_type (ptr_type_node
, t
),
772 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
773 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
775 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
776 soft_initclass_node
= builtin_function ("_Jv_InitClass",
777 build_function_type (void_type_node
,
779 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
781 throw_node
= builtin_function ("_Jv_Throw",
782 build_function_type (ptr_type_node
, t
),
783 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
784 /* Mark throw_nodes as `noreturn' functions with side effects. */
785 TREE_THIS_VOLATILE (throw_node
) = 1;
786 TREE_SIDE_EFFECTS (throw_node
) = 1;
788 t
= build_function_type (int_type_node
, endlink
);
789 soft_monitorenter_node
790 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
792 soft_monitorexit_node
793 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
796 t
= tree_cons (NULL_TREE
, int_type_node
,
797 tree_cons (NULL_TREE
, int_type_node
, endlink
));
799 = builtin_function ("_Jv_NewPrimArray",
800 build_function_type(ptr_type_node
, t
),
801 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
802 DECL_IS_MALLOC (soft_newarray_node
) = 1;
804 t
= tree_cons (NULL_TREE
, int_type_node
,
805 tree_cons (NULL_TREE
, class_ptr_type
,
806 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
808 = builtin_function ("_Jv_NewObjectArray",
809 build_function_type (ptr_type_node
, t
),
810 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
811 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
813 /* There is no endlink here because _Jv_NewMultiArray is a varargs
815 t
= tree_cons (NULL_TREE
, ptr_type_node
, int_type_node
);
816 soft_multianewarray_node
817 = builtin_function ("_Jv_NewMultiArray",
818 build_function_type (ptr_type_node
, t
),
819 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
820 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
822 t
= build_function_type (void_type_node
,
823 tree_cons (NULL_TREE
, int_type_node
, endlink
));
824 soft_badarrayindex_node
825 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
826 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
827 /* Mark soft_badarrayindex_node as a `noreturn' function with side
829 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
830 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
832 soft_nullpointer_node
833 = builtin_function ("_Jv_ThrowNullPointerException",
834 build_function_type (void_type_node
, endlink
),
835 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
836 /* Mark soft_nullpointer_node as a `noreturn' function with side
838 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
839 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
841 t
= tree_cons (NULL_TREE
, class_ptr_type
,
842 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
844 = builtin_function ("_Jv_CheckCast",
845 build_function_type (ptr_type_node
, t
),
846 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
847 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
848 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
850 = builtin_function ("_Jv_IsInstanceOf",
851 build_function_type (boolean_type_node
, t
),
852 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
853 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
854 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
855 soft_checkarraystore_node
856 = builtin_function ("_Jv_CheckArrayStore",
857 build_function_type (void_type_node
, t
),
858 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
859 t
= tree_cons (NULL_TREE
, ptr_type_node
,
860 tree_cons (NULL_TREE
, ptr_type_node
,
861 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
862 soft_lookupinterfacemethod_node
863 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
864 build_function_type (ptr_type_node
, t
),
865 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
867 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
868 tree_cons (NULL_TREE
, ptr_type_node
,
869 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
870 soft_lookupjnimethod_node
871 = builtin_function ("_Jv_LookupJNIMethod",
872 build_function_type (ptr_type_node
, t
),
873 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
874 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
875 soft_getjnienvnewframe_node
876 = builtin_function ("_Jv_GetJNIEnvNewFrame",
877 build_function_type (ptr_type_node
, t
),
878 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
879 soft_jnipopsystemframe_node
880 = builtin_function ("_Jv_JNI_PopSystemFrame",
881 build_function_type (ptr_type_node
, t
),
882 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
884 t
= tree_cons (NULL_TREE
, double_type_node
,
885 tree_cons (NULL_TREE
, double_type_node
, endlink
));
887 = builtin_function ("__builtin_fmod",
888 build_function_type (double_type_node
, t
),
889 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmod", NULL_TREE
);
892 t
= tree_cons (NULL_TREE
, float_type_node
,
893 tree_cons (NULL_TREE
, float_type_node
, endlink
));
895 = builtin_function ("__builtin_fmodf",
896 build_function_type (float_type_node
, t
),
897 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf", NULL_TREE
);
901 = builtin_function ("_Jv_divI",
902 build_function_type (int_type_node
, t
),
903 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
906 = builtin_function ("_Jv_remI",
907 build_function_type (int_type_node
, t
),
908 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
911 = builtin_function ("_Jv_divJ",
912 build_function_type (long_type_node
, t
),
913 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
916 = builtin_function ("_Jv_remJ",
917 build_function_type (long_type_node
, t
),
918 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
920 /* Initialize variables for except.c. */
921 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
922 ? "__gcj_personality_sj0"
923 : "__gcj_personality_v0");
924 lang_eh_runtime_type
= prepare_eh_table_type
;
928 initialize_builtins ();
932 /* Look up NAME in the current binding level and its superiors
933 in the namespace of variables, functions and typedefs.
934 Return a ..._DECL node of some kind representing its definition,
935 or return 0 if it is undefined. */
938 lookup_name (tree name
)
941 if (current_binding_level
!= global_binding_level
942 && IDENTIFIER_LOCAL_VALUE (name
))
943 val
= IDENTIFIER_LOCAL_VALUE (name
);
945 val
= IDENTIFIER_GLOBAL_VALUE (name
);
949 /* Similar to `lookup_name' but look only at current binding level and
950 the previous one if its the parameter level. */
953 lookup_name_current_level (tree name
)
957 if (current_binding_level
== global_binding_level
)
958 return IDENTIFIER_GLOBAL_VALUE (name
);
960 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
963 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
964 if (DECL_NAME (t
) == name
)
970 /* Use a binding level to record a labeled block declaration */
973 push_labeled_block (tree lb
)
975 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
976 register struct binding_level
*b
= current_binding_level
;
977 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
979 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
980 TREE_CHAIN (lb
) = b
->names
;
982 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
985 /* Pop the current binding level, reinstalling values for the previous
989 pop_labeled_block (void)
991 struct binding_level
*b
= current_binding_level
;
992 tree label
= b
->names
;
993 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
996 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
997 TREE_VALUE (b
->shadowed
);
999 /* Pop the current level, and free the structure for reuse. */
1000 current_binding_level
= current_binding_level
->level_chain
;
1001 b
->level_chain
= free_binding_level
;
1002 free_binding_level
= b
;
1005 /* Record a decl-node X as belonging to the current lexical scope.
1006 Check for errors (such as an incompatible declaration for the same
1007 name already seen in the same scope).
1009 Returns either X or an old decl for the same name.
1010 If an old decl is returned, it may have been smashed
1011 to agree with what X says. */
1017 register tree name
= DECL_NAME (x
);
1018 register struct binding_level
*b
= current_binding_level
;
1020 if (TREE_CODE (x
) != TYPE_DECL
)
1021 DECL_CONTEXT (x
) = current_function_decl
;
1027 t
= lookup_name_current_level (name
);
1028 if (t
!= 0 && t
== error_mark_node
)
1029 /* error_mark_node is 0 for a while during initialization! */
1032 error_with_decl (x
, "`%s' used prior to declaration");
1037 file
= DECL_SOURCE_FILE (t
);
1038 line
= DECL_SOURCE_LINE (t
);
1041 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1042 to point to the TYPE_DECL.
1043 Since Java does not have typedefs, a type can only have
1044 one (true) name, given by a class, interface, or builtin. */
1045 if (TREE_CODE (x
) == TYPE_DECL
1046 && TYPE_NAME (TREE_TYPE (x
)) == 0
1047 && TREE_TYPE (x
) != error_mark_node
)
1049 TYPE_NAME (TREE_TYPE (x
)) = x
;
1050 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1053 /* This name is new in its binding level.
1054 Install the new declaration and return it. */
1055 if (b
== global_binding_level
)
1057 /* Install a global value. */
1059 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1063 /* Here to install a non-global value. */
1064 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1065 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1068 /* Warn if shadowing an argument at the top level of the body. */
1069 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1070 /* This warning doesn't apply to the parms of a nested fcn. */
1071 && ! current_binding_level
->parm_flag
1072 /* Check that this is one level down from the parms. */
1073 && current_binding_level
->level_chain
->parm_flag
1074 /* Check that the decl being shadowed
1075 comes from the parm level, one level up. */
1076 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1078 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1079 pedwarn ("declaration of `%s' shadows a parameter",
1080 IDENTIFIER_POINTER (name
));
1082 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1083 IDENTIFIER_POINTER (name
));
1086 /* Maybe warn if shadowing something else. */
1087 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1088 /* No shadow warnings for internally generated vars. */
1089 && DECL_SOURCE_LINE (x
) != 0
1090 /* No shadow warnings for vars made for inlining. */
1091 && ! DECL_FROM_INLINE (x
))
1093 const char *warnstring
= 0;
1095 if (TREE_CODE (x
) == PARM_DECL
1096 && current_binding_level
->level_chain
->parm_flag
)
1097 /* Don't warn about the parm names in function declarator
1098 within a function declarator.
1099 It would be nice to avoid warning in any function
1100 declarator in a declaration, as opposed to a definition,
1101 but there is no way to tell it's not a definition. */
1103 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1104 warnstring
= "declaration of `%s' shadows a parameter";
1105 else if (oldlocal
!= 0)
1106 warnstring
= "declaration of `%s' shadows previous local";
1107 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1108 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1109 warnstring
= "declaration of `%s' shadows global declaration";
1112 warning (warnstring
, IDENTIFIER_POINTER (name
));
1116 /* If storing a local value, there may already be one (inherited).
1117 If so, record it for restoration when this binding level ends. */
1119 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1123 /* Put decls on list in reverse order.
1124 We will reverse them later if necessary. */
1125 TREE_CHAIN (x
) = b
->names
;
1132 pushdecl_force_head (tree x
)
1134 current_binding_level
->names
= x
;
1137 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1140 pushdecl_top_level (tree x
)
1143 register struct binding_level
*b
= current_binding_level
;
1145 current_binding_level
= global_binding_level
;
1147 current_binding_level
= b
;
1151 /* Nonzero if we are currently in the global binding level. */
1154 global_bindings_p (void)
1156 return current_binding_level
== global_binding_level
;
1159 /* Return the list of declarations of the current level.
1160 Note that this list is in reverse order unless/until
1161 you nreverse it; and when you do nreverse it, you must
1162 store the result back using `storedecls' or you will lose. */
1167 return current_binding_level
->names
;
1170 /* Create a new `struct binding_level'. */
1172 static struct binding_level
*
1173 make_binding_level (void)
1176 return xmalloc (sizeof (struct binding_level
));
1180 pushlevel (int unused ATTRIBUTE_UNUSED
)
1182 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1185 /* If this is the top level of a function,
1186 just make sure that NAMED_LABELS is 0. */
1188 if (current_binding_level
== global_binding_level
)
1192 /* Reuse or create a struct for this binding level. */
1194 if (free_binding_level
)
1196 newlevel
= free_binding_level
;
1197 free_binding_level
= free_binding_level
->level_chain
;
1201 newlevel
= make_binding_level ();
1204 /* Add this level to the front of the chain (stack) of levels that
1207 *newlevel
= clear_binding_level
;
1208 newlevel
->level_chain
= current_binding_level
;
1209 current_binding_level
= newlevel
;
1210 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1211 newlevel
->binding_depth
= binding_depth
;
1213 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1214 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1217 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1220 /* Exit a binding level.
1221 Pop the level off, and restore the state of the identifier-decl mappings
1222 that were in effect when this level was entered.
1224 If KEEP is nonzero, this level had explicit declarations, so
1225 and create a "block" (a BLOCK node) for the level
1226 to record its declarations and subblocks for symbol table output.
1228 If FUNCTIONBODY is nonzero, this level is the body of a function,
1229 so create a block as if KEEP were set and also clear out all
1232 If REVERSE is nonzero, reverse the order of decls before putting
1233 them into the BLOCK. */
1236 poplevel (int keep
, int reverse
, int functionbody
)
1239 /* The chain of decls was accumulated in reverse order.
1240 Put it into forward order, just for cleanliness. */
1242 tree subblocks
= current_binding_level
->blocks
;
1245 int block_previously_created
;
1247 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1250 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1251 fprintf (stderr
, "pop %s level 0x%08x pc %d (end pc %d)\n",
1252 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1253 current_binding_level
->end_pc
);
1255 fprintf (stderr
, "pop %s level 0x%08x pc %d\n",
1256 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1258 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1261 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1265 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1267 /* Get the decls in the order they were written.
1268 Usually current_binding_level->names is in reverse order.
1269 But parameter decls were previously put in forward order. */
1272 current_binding_level
->names
1273 = decls
= nreverse (current_binding_level
->names
);
1275 decls
= current_binding_level
->names
;
1277 /* Output any nested inline functions within this block
1278 if they weren't already output. */
1280 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1281 if (TREE_CODE (decl
) == FUNCTION_DECL
1282 && ! TREE_ASM_WRITTEN (decl
)
1283 && DECL_INITIAL (decl
) != 0
1284 && TREE_ADDRESSABLE (decl
))
1286 /* If this decl was copied from a file-scope decl
1287 on account of a block-scope extern decl,
1288 propagate TREE_ADDRESSABLE to the file-scope decl.
1290 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1291 true, since then the decl goes through save_for_inline_copying. */
1292 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
1293 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
1294 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1297 push_function_context ();
1298 output_inline_function (decl
);
1299 pop_function_context ();
1303 /* If there were any declarations in that level,
1304 or if this level is a function body,
1305 create a BLOCK to record them for the life of this function. */
1308 block_previously_created
= (current_binding_level
->this_block
!= 0);
1309 if (block_previously_created
)
1310 block
= current_binding_level
->this_block
;
1311 else if (keep
|| functionbody
)
1312 block
= make_node (BLOCK
);
1315 BLOCK_VARS (block
) = decls
;
1316 BLOCK_SUBBLOCKS (block
) = subblocks
;
1319 /* In each subblock, record that this is its superior. */
1321 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1322 BLOCK_SUPERCONTEXT (link
) = block
;
1324 /* Clear out the meanings of the local variables of this level. */
1326 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1328 tree name
= DECL_NAME (link
);
1329 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1331 /* If the ident. was used or addressed via a local extern decl,
1332 don't forget that fact. */
1333 if (DECL_EXTERNAL (link
))
1335 if (TREE_USED (link
))
1336 TREE_USED (name
) = 1;
1337 if (TREE_ADDRESSABLE (link
))
1338 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1340 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1344 /* Restore all name-meanings of the outer levels
1345 that were shadowed by this level. */
1347 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1348 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1350 /* If the level being exited is the top level of a function,
1351 check over all the labels, and clear out the current
1352 (function local) meanings of their names. */
1356 /* If this is the top level block of a function,
1357 the vars are the function's parameters.
1358 Don't leave them in the BLOCK because they are
1359 found in the FUNCTION_DECL instead. */
1361 BLOCK_VARS (block
) = 0;
1363 /* Clear out the definitions of all label names,
1364 since their scopes end here,
1365 and add them to BLOCK_VARS. */
1368 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1370 register tree label
= TREE_VALUE (link
);
1372 if (DECL_INITIAL (label
) == 0)
1374 error_with_decl (label
, "label `%s' used but not defined");
1375 /* Avoid crashing later. */
1376 define_label (input_filename
, lineno
,
1379 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1380 warning_with_decl (label
, "label `%s' defined but not used");
1381 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1383 /* Put the labels into the "variables" of the
1384 top-level block, so debugger can see them. */
1385 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1386 BLOCK_VARS (block
) = label
;
1391 /* Pop the current level, and free the structure for reuse. */
1394 register struct binding_level
*level
= current_binding_level
;
1395 current_binding_level
= current_binding_level
->level_chain
;
1397 level
->level_chain
= free_binding_level
;
1398 free_binding_level
= level
;
1401 /* Dispose of the block that we just made inside some higher level. */
1403 DECL_INITIAL (current_function_decl
) = block
;
1406 if (!block_previously_created
)
1407 current_binding_level
->blocks
1408 = chainon (current_binding_level
->blocks
, block
);
1410 /* If we did not make a block for the level just exited,
1411 any blocks made for inner levels
1412 (since they cannot be recorded as subblocks in that level)
1413 must be carried forward so they will later become subblocks
1414 of something else. */
1416 current_binding_level
->blocks
1417 = chainon (current_binding_level
->blocks
, subblocks
);
1419 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1420 binding contour so that they point to the appropriate construct, i.e.
1421 either to the current FUNCTION_DECL node, or else to the BLOCK node
1422 we just constructed.
1424 Note that for tagged types whose scope is just the formal parameter
1425 list for some function type specification, we can't properly set
1426 their TYPE_CONTEXTs here, because we don't have a pointer to the
1427 appropriate FUNCTION_TYPE node readily available to us. For those
1428 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1429 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1430 node which will represent the "scope" for these "parameter list local"
1435 TREE_USED (block
) = 1;
1440 maybe_pushlevels (int pc
)
1442 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1446 while (pending_local_decls
!= NULL_TREE
&&
1447 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1449 tree
*ptr
= &pending_local_decls
;
1451 int end_pc
= DECL_LOCAL_END_PC (decl
);
1453 while (*ptr
!= NULL_TREE
1454 && DECL_LOCAL_START_PC (*ptr
) <= pc
1455 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1456 ptr
= &TREE_CHAIN (*ptr
);
1457 pending_local_decls
= *ptr
;
1460 /* Force non-nested range to be nested in current range. */
1461 if (end_pc
> current_binding_level
->end_pc
)
1462 end_pc
= current_binding_level
->end_pc
;
1464 maybe_start_try (pc
, end_pc
);
1467 expand_start_bindings (0);
1469 current_binding_level
->end_pc
= end_pc
;
1470 current_binding_level
->start_pc
= pc
;
1471 current_binding_level
->names
= decl
;
1472 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1474 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1478 maybe_start_try (pc
, 0);
1482 maybe_poplevels (int pc
)
1484 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1488 while (current_binding_level
->end_pc
<= pc
)
1490 expand_end_bindings (getdecls (), 1, 0);
1491 maybe_end_try (current_binding_level
->start_pc
, pc
);
1494 maybe_end_try (0, pc
);
1497 /* Terminate any binding which began during the range beginning at
1498 start_pc. This tidies up improperly nested local variable ranges
1499 and exception handlers; a variable declared within an exception
1500 range is forcibly terminated when that exception ends. */
1503 force_poplevels (int start_pc
)
1505 while (current_binding_level
->start_pc
> start_pc
)
1507 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1508 warning_with_decl (current_function_decl
,
1509 "In %s: overlapped variable and exception ranges at %d",
1510 current_binding_level
->start_pc
);
1511 expand_end_bindings (getdecls (), 1, 0);
1516 /* Insert BLOCK at the end of the list of subblocks of the
1517 current binding level. This is used when a BIND_EXPR is expanded,
1518 to handle the BLOCK node inside the BIND_EXPR. */
1521 insert_block (tree block
)
1523 TREE_USED (block
) = 1;
1524 current_binding_level
->blocks
1525 = chainon (current_binding_level
->blocks
, block
);
1528 /* Set the BLOCK node for the innermost scope
1529 (the one we are currently in). */
1532 set_block (tree block
)
1534 current_binding_level
->this_block
= block
;
1535 current_binding_level
->names
= chainon (current_binding_level
->names
,
1536 BLOCK_VARS (block
));
1537 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1538 BLOCK_SUBBLOCKS (block
));
1541 /* integrate_decl_tree calls this function. */
1544 java_dup_lang_specific_decl (tree node
)
1547 struct lang_decl
*x
;
1549 if (!DECL_LANG_SPECIFIC (node
))
1552 lang_decl_size
= sizeof (struct lang_decl
);
1553 x
= ggc_alloc (lang_decl_size
);
1554 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1555 DECL_LANG_SPECIFIC (node
) = x
;
1559 give_name_to_locals (JCF
*jcf
)
1561 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1562 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1564 pending_local_decls
= NULL_TREE
;
1568 n
= JCF_readu2 (jcf
);
1569 for (i
= 0; i
< n
; i
++)
1571 int start_pc
= JCF_readu2 (jcf
);
1572 int length
= JCF_readu2 (jcf
);
1573 int name_index
= JCF_readu2 (jcf
);
1574 int signature_index
= JCF_readu2 (jcf
);
1575 int slot
= JCF_readu2 (jcf
);
1576 tree name
= get_name_constant (jcf
, name_index
);
1577 tree type
= parse_signature (jcf
, signature_index
);
1578 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1580 && length
== DECL_CODE_LENGTH (current_function_decl
))
1582 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1583 DECL_NAME (decl
) = name
;
1584 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1585 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1586 warning ("bad type in parameter debug info");
1591 int end_pc
= start_pc
+ length
;
1592 tree decl
= build_decl (VAR_DECL
, name
, type
);
1593 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1595 warning_with_decl (decl
,
1596 "bad PC range for debug info for local `%s'");
1597 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1600 /* Adjust start_pc if necessary so that the local's first
1601 store operation will use the relevant DECL as a
1602 destination. Fore more information, read the leading
1603 comments for expr.c:maybe_adjust_start_pc. */
1604 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1606 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1607 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1608 DECL_LOCAL_START_PC (decl
) = start_pc
;
1610 /* FIXME: The range used internally for exceptions and local
1611 variable ranges, is a half-open interval:
1612 start_pc <= pc < end_pc. However, the range used in the
1613 Java VM spec is inclusive at both ends:
1614 start_pc <= pc <= end_pc. */
1617 DECL_LOCAL_END_PC (decl
) = end_pc
;
1619 /* Now insert the new decl in the proper place in
1620 pending_local_decls. We are essentially doing an insertion sort,
1621 which works fine, since the list input will normally already
1623 ptr
= &pending_local_decls
;
1624 while (*ptr
!= NULL_TREE
1625 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1626 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1627 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1628 ptr
= &TREE_CHAIN (*ptr
);
1629 TREE_CHAIN (decl
) = *ptr
;
1634 pending_local_decls
= nreverse (pending_local_decls
);
1636 /* Fill in default names for the parameters. */
1637 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1638 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1640 if (DECL_NAME (parm
) == NULL_TREE
)
1642 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1644 DECL_NAME (parm
) = get_identifier ("this");
1648 sprintf (buffer
, "ARG_%d", arg_i
);
1649 DECL_NAME (parm
) = get_identifier (buffer
);
1651 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1657 build_result_decl (tree fndecl
)
1659 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1660 tree result
= DECL_RESULT (fndecl
);
1663 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1664 if (INTEGRAL_TYPE_P (restype
)
1665 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1666 restype
= integer_type_node
;
1667 result
= build_decl (RESULT_DECL
, NULL_TREE
, restype
);
1668 DECL_CONTEXT (result
) = fndecl
;
1669 DECL_RESULT (fndecl
) = result
;
1675 complete_start_java_method (tree fndecl
)
1677 if (! flag_emit_class_files
)
1679 /* Initialize the RTL code for the function. */
1680 init_function_start (fndecl
, input_filename
, lineno
);
1682 /* Set up parameters and prepare for return, for the function. */
1683 expand_function_start (fndecl
, 0);
1687 /* If this fcn was already referenced via a block-scope `extern' decl (or
1688 an implicit decl), propagate certain information about the usage. */
1689 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1690 TREE_ADDRESSABLE (current_function_decl
) = 1;
1694 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1695 && ! flag_emit_class_files
1696 && ! DECL_CLINIT_P (fndecl
)
1697 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1699 tree clas
= DECL_CONTEXT (fndecl
);
1700 tree init
= build (CALL_EXPR
, void_type_node
,
1701 build_address_of (soft_initclass_node
),
1702 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1704 TREE_SIDE_EFFECTS (init
) = 1;
1705 expand_expr_stmt (init
);
1708 /* Push local variables. Function compiled from source code are
1709 using a different local variables management, and for them,
1710 pushlevel shouldn't be called from here. */
1711 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1714 if (! flag_emit_class_files
)
1715 expand_start_bindings (1);
1718 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1720 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1721 tree enter
, exit
, lock
;
1722 if (METHOD_STATIC (fndecl
))
1723 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1725 lock
= DECL_ARGUMENTS (fndecl
);
1726 BUILD_MONITOR_ENTER (enter
, lock
);
1727 BUILD_MONITOR_EXIT (exit
, lock
);
1728 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1730 expand_expr_stmt (enter
);
1731 expand_decl_cleanup (NULL_TREE
, exit
);
1735 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1736 tree body
= BLOCK_EXPR_BODY (function_body
);
1737 lock
= build (COMPOUND_EXPR
, void_type_node
,
1739 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1740 TREE_SIDE_EFFECTS (lock
) = 1;
1741 BLOCK_EXPR_BODY (function_body
) = lock
;
1747 start_java_method (tree fndecl
)
1752 current_function_decl
= fndecl
;
1753 announce_function (fndecl
);
1755 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1756 decl_map
= make_tree_vec (i
);
1757 type_map
= xrealloc (type_map
, i
* sizeof (tree
));
1759 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1760 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1762 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1763 pushlevel (1); /* Push parameters. */
1765 ptr
= &DECL_ARGUMENTS (fndecl
);
1766 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1767 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1769 tree parm_name
= NULL_TREE
, parm_decl
;
1770 tree parm_type
= TREE_VALUE (tem
);
1771 if (i
>= DECL_MAX_LOCALS (fndecl
))
1774 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1775 DECL_CONTEXT (parm_decl
) = fndecl
;
1776 if (PROMOTE_PROTOTYPES
1777 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1778 && INTEGRAL_TYPE_P (parm_type
))
1779 parm_type
= integer_type_node
;
1780 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1783 ptr
= &TREE_CHAIN (parm_decl
);
1785 /* Add parm_decl to the decl_map. */
1786 push_jvm_slot (i
, parm_decl
);
1788 type_map
[i
] = TREE_TYPE (parm_decl
);
1789 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1792 type_map
[i
] = void_type_node
;
1796 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1798 while (i
< DECL_MAX_LOCALS(fndecl
))
1799 type_map
[i
++] = NULL_TREE
;
1801 build_result_decl (fndecl
);
1802 complete_start_java_method (fndecl
);
1806 end_java_method (void)
1808 tree fndecl
= current_function_decl
;
1810 expand_end_bindings (getdecls (), 1, 0);
1811 /* pop out of function */
1814 /* pop out of its parameters */
1817 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1819 /* Generate rtl for function exit. */
1820 expand_function_end (input_filename
, lineno
, 0);
1822 /* Run the optimizers and output assembler code for this function. */
1823 rest_of_compilation (fndecl
);
1825 current_function_decl
= NULL_TREE
;
1828 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1831 dump_function (enum tree_dump_index phase
, tree fn
)
1836 stream
= dump_begin (phase
, &flags
);
1839 dump_node (fn
, TDF_SLIM
| flags
, stream
);
1840 dump_end (phase
, stream
);
1844 void java_optimize_inline (tree fndecl
)
1846 if (flag_inline_trees
)
1848 timevar_push (TV_INTEGRATION
);
1849 optimize_inline_calls (fndecl
);
1850 timevar_pop (TV_INTEGRATION
);
1851 dump_function (TDI_inlined
, fndecl
);
1855 #include "gt-java-decl.h"