1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
36 #include "java-tree.h"
42 #include "java-except.h"
45 #include "tree-inline.h"
47 #if defined (DEBUG_JAVA_BINDING_LEVELS)
48 extern void indent
PARAMS ((void));
51 static tree push_jvm_slot
PARAMS ((int, tree
));
52 static tree lookup_name_current_level
PARAMS ((tree
));
53 static tree push_promoted_type
PARAMS ((const char *, tree
));
54 static struct binding_level
*make_binding_level
PARAMS ((void));
55 static tree create_primitive_vtable
PARAMS ((const char *));
56 static tree check_local_named_variable
PARAMS ((tree
, tree
, int, int *));
57 static tree check_local_unnamed_variable
PARAMS ((tree
, tree
, tree
));
58 static void dump_function
PARAMS ((enum tree_dump_index
, tree
));
60 /* Set to non-zero value in order to emit class initilization code
61 before static field references. */
62 extern int always_initialize_class_p
;
64 /* The DECL_MAP is a mapping from (index, type) to a decl node.
65 If index < max_locals, it is the index of a local variable.
66 if index >= max_locals, then index-max_locals is a stack slot.
67 The DECL_MAP mapping is represented as a TREE_VEC whose elements
68 are a list of decls (VAR_DECL or PARM_DECL) chained by
69 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
70 we search the chain for a decl with a matching TREE_TYPE. */
72 static GTY(()) tree decl_map
;
74 /* A list of local variables VAR_DECLs for this method that we have seen
75 debug information, but we have not reached their starting (byte) PC yet. */
77 static GTY(()) tree pending_local_decls
;
79 /* Push a local variable or stack slot into the decl_map,
80 and assign it an rtl. */
82 #if defined(DEBUG_JAVA_BINDING_LEVELS)
83 int binding_depth
= 0;
84 int is_class_level
= 0;
92 for (i
= 0; i
< binding_depth
*2; i
++)
95 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
98 push_jvm_slot (index
, decl
)
102 struct rtx_def
*rtl
= NULL
;
103 tree type
= TREE_TYPE (decl
);
106 DECL_CONTEXT (decl
) = current_function_decl
;
107 layout_decl (decl
, 0);
109 /* See if we have an appropriate rtl (i.e. same mode) at this index.
110 If so, we must use it. */
111 tmp
= TREE_VEC_ELT (decl_map
, index
);
112 while (tmp
!= NULL_TREE
)
114 if (TYPE_MODE (type
) == TYPE_MODE (TREE_TYPE (tmp
)))
115 rtl
= DECL_RTL_IF_SET (tmp
);
118 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
121 SET_DECL_RTL (decl
, rtl
);
124 if (index
>= DECL_MAX_LOCALS (current_function_decl
))
125 DECL_REGISTER (decl
) = 1;
129 /* Now link the decl into the decl_map. */
130 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
132 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
133 DECL_LOCAL_START_PC (decl
) = 0;
134 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
135 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
137 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
138 TREE_VEC_ELT (decl_map
, index
) = decl
;
142 /* Find out if 'decl' passed in fits the defined PC location better than
143 'best'. Return decl if it does, return best if it doesn't. If decl
144 is returned, then updated is set to true. */
147 check_local_named_variable (best
, decl
, pc
, updated
)
153 if (pc
>= DECL_LOCAL_START_PC (decl
)
154 && pc
< DECL_LOCAL_END_PC (decl
))
156 if (best
== NULL_TREE
157 || (DECL_LOCAL_START_PC (decl
) > DECL_LOCAL_START_PC (best
)
158 && DECL_LOCAL_END_PC (decl
) < DECL_LOCAL_END_PC (best
)))
168 /* Find the best declaration based upon type. If 'decl' fits 'type' better
169 than 'best', return 'decl'. Otherwise return 'best'. */
172 check_local_unnamed_variable (best
, decl
, type
)
177 if (TREE_TYPE (decl
) == type
178 || (TREE_CODE (TREE_TYPE (decl
)) == TREE_CODE (type
)
179 && TYPE_PRECISION (TREE_TYPE (decl
)) <= 32
180 && TYPE_PRECISION (type
) <= 32
181 && TREE_CODE (type
) != POINTER_TYPE
)
182 || (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
183 && type
== ptr_type_node
))
185 if (best
== NULL_TREE
186 || (TREE_TYPE (decl
) == type
&& TREE_TYPE (best
) != type
))
194 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
195 that is valid at PC (or -1 if any pc).
196 If there is no existing matching decl, allocate one. */
199 find_local_variable (index
, type
, pc
)
204 tree decl
= TREE_VEC_ELT (decl_map
, index
);
205 tree best
= NULL_TREE
;
206 int found_scoped_var
= 0;
208 /* Scan through every declaration that has been created in this slot. */
209 while (decl
!= NULL_TREE
)
211 /* Variables created in give_name_to_locals() have a name and have
212 a specified scope, so we can handle them specifically. We want
213 to use the specific decls created for those so they are assigned
214 the right variables in the debugging information. */
215 if (DECL_NAME (decl
) != NULL_TREE
)
217 /* This is a variable we have a name for, so it has a scope
218 supplied in the class file. But it only matters when we
219 actually have a PC to use. If pc<0, then we are asking
220 for a stack slot and this decl won't be one of those. */
222 best
= check_local_named_variable (best
, decl
, pc
,
225 /* We scan for type information unless we found a variable in the
226 proper scope already. */
227 else if (!found_scoped_var
)
229 /* If we don't have scoping information for a variable, we use
230 a different method to look it up. */
231 best
= check_local_unnamed_variable (best
, decl
, type
);
234 decl
= DECL_LOCAL_SLOT_CHAIN (decl
);
237 if (best
!= NULL_TREE
)
240 /* If we don't find a match, create one with the type passed in. */
241 return push_jvm_slot (index
, build_decl (VAR_DECL
, NULL_TREE
, type
));
245 /* Same as find_local_index, except that INDEX is a stack index. */
248 find_stack_slot (index
, type
)
252 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
258 /* A chain of _DECL nodes for all variables, constants, functions,
259 * and typedef types. These are in the reverse of the order supplied.
263 /* For each level, a list of shadowed outer-level local definitions
264 to be restored when this level is popped.
265 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
266 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
269 /* For each level (except not the global one),
270 a chain of BLOCK nodes for all the levels
271 that were entered and exited one level down. */
274 /* The BLOCK node for this level, if one has been preallocated.
275 If 0, the BLOCK is allocated (if needed) when the level is popped. */
278 /* The binding level which this one is contained in (inherits from). */
279 struct binding_level
*level_chain
;
281 /* The bytecode PC that marks the end of this level. */
283 /* The bytecode PC that marks the start of this level. */
286 #if defined(DEBUG_JAVA_BINDING_LEVELS)
287 /* Binding depth at which this level began. */
288 unsigned binding_depth
;
289 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
292 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
294 /* The binding level currently in effect. */
296 static struct binding_level
*current_binding_level
;
298 /* A chain of binding_level structures awaiting reuse. */
300 static struct binding_level
*free_binding_level
;
302 /* The outermost binding level, for names of file scope.
303 This is created when the compiler is started and exists
304 through the entire run. */
306 static struct binding_level
*global_binding_level
;
308 /* A PC value bigger than any PC value we may ever may encounter. */
310 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
312 /* Binding level structures are initialized by copying this one. */
314 static const struct binding_level clear_binding_level
315 = {NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
316 NULL_BINDING_LEVEL
, LARGEST_PC
, 0};
319 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
320 that have names. Here so we can clear out their names' definitions
321 at the end of the function. */
323 static tree named_labels
;
325 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
327 static tree shadowed_labels
;
330 tree java_global_trees
[JTI_MAX
];
332 /* Build (and pushdecl) a "promoted type" for all standard
333 types shorter than int. */
336 push_promoted_type (name
, actual_type
)
340 tree type
= make_node (TREE_CODE (actual_type
));
342 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
343 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
345 tree in_min
= TYPE_MIN_VALUE (actual_type
);
346 tree in_max
= TYPE_MAX_VALUE (actual_type
);
348 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
349 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
350 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
351 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
352 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
354 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
358 /* Return a definition for a builtin function named NAME and whose data type
359 is TYPE. TYPE should be a function type with argument types.
360 FUNCTION_CODE tells later passes how to compile calls to this function.
361 See tree.h for its possible values.
363 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
364 the name to be called if we can't opencode the function. If
365 ATTRS is nonzero, use that for the function's attribute list. */
368 builtin_function (name
, type
, function_code
, class, library_name
, attrs
)
372 enum built_in_class
class;
373 const char *library_name
;
374 tree attrs ATTRIBUTE_UNUSED
;
376 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
377 DECL_EXTERNAL (decl
) = 1;
378 TREE_PUBLIC (decl
) = 1;
380 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
381 make_decl_rtl (decl
, NULL
);
383 DECL_BUILT_IN_CLASS (decl
) = class;
384 DECL_FUNCTION_CODE (decl
) = function_code
;
388 /* Return tree that represents a vtable for a primitive array. */
390 create_primitive_vtable (name
)
396 sprintf (buf
, "_Jv_%sVTable", name
);
397 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
398 DECL_EXTERNAL (r
) = 1;
403 java_init_decl_processing ()
405 register tree endlink
;
406 tree field
= NULL_TREE
;
409 init_class_processing ();
411 current_function_decl
= NULL
;
412 current_binding_level
= NULL_BINDING_LEVEL
;
413 free_binding_level
= NULL_BINDING_LEVEL
;
414 pushlevel (0); /* make the binding_level structure for global names */
415 global_binding_level
= current_binding_level
;
417 /* The code here must be similar to build_common_tree_nodes{,_2} in
418 tree.c, especially as to the order of initializing common nodes. */
419 error_mark_node
= make_node (ERROR_MARK
);
420 TREE_TYPE (error_mark_node
) = error_mark_node
;
422 /* Create sizetype first - needed for other types. */
423 initialize_sizetypes ();
425 byte_type_node
= make_signed_type (8);
426 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
427 short_type_node
= make_signed_type (16);
428 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
429 int_type_node
= make_signed_type (32);
430 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
431 long_type_node
= make_signed_type (64);
432 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
434 unsigned_byte_type_node
= make_unsigned_type (8);
435 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
436 unsigned_byte_type_node
));
437 unsigned_short_type_node
= make_unsigned_type (16);
438 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
439 unsigned_short_type_node
));
440 unsigned_int_type_node
= make_unsigned_type (32);
441 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
442 unsigned_int_type_node
));
443 unsigned_long_type_node
= make_unsigned_type (64);
444 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
445 unsigned_long_type_node
));
447 set_sizetype (make_unsigned_type (POINTER_SIZE
));
449 /* Define these next since types below may used them. */
450 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
451 integer_zero_node
= build_int_2 (0, 0);
452 integer_one_node
= build_int_2 (1, 0);
453 integer_two_node
= build_int_2 (2, 0);
454 integer_four_node
= build_int_2 (4, 0);
455 integer_minus_one_node
= build_int_2 (-1, -1);
457 size_zero_node
= size_int (0);
458 size_one_node
= size_int (1);
459 bitsize_zero_node
= bitsize_int (0);
460 bitsize_one_node
= bitsize_int (1);
461 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
463 long_zero_node
= build_int_2 (0, 0);
464 TREE_TYPE (long_zero_node
) = long_type_node
;
466 void_type_node
= make_node (VOID_TYPE
);
467 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
468 layout_type (void_type_node
); /* Uses size_zero_node */
469 ptr_type_node
= build_pointer_type (void_type_node
);
470 t
= make_node (VOID_TYPE
);
471 layout_type (t
); /* Uses size_zero_node */
472 return_address_type_node
= build_pointer_type (t
);
474 null_pointer_node
= build_int_2 (0, 0);
475 TREE_TYPE (null_pointer_node
) = ptr_type_node
;
477 /* Used by the parser to represent empty statements and blocks. */
478 empty_stmt_node
= build1 (NOP_EXPR
, void_type_node
, size_zero_node
);
479 CAN_COMPLETE_NORMALLY (empty_stmt_node
) = 1;
482 /* Make a type to be the domain of a few array types
483 whose domains don't really matter.
484 200 is small enough that it always fits in size_t
485 and large enough that it can hold most function names for the
486 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
487 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
489 char_type_node
= make_node (CHAR_TYPE
);
490 TYPE_PRECISION (char_type_node
) = 16;
491 fixup_unsigned_type (char_type_node
);
492 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
494 boolean_type_node
= make_node (BOOLEAN_TYPE
);
495 TYPE_PRECISION (boolean_type_node
) = 1;
496 fixup_unsigned_type (boolean_type_node
);
497 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
499 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
500 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
502 promoted_byte_type_node
503 = push_promoted_type ("promoted_byte", byte_type_node
);
504 promoted_short_type_node
505 = push_promoted_type ("promoted_short", short_type_node
);
506 promoted_char_type_node
507 = push_promoted_type ("promoted_char", char_type_node
);
508 promoted_boolean_type_node
509 = push_promoted_type ("promoted_boolean", boolean_type_node
);
511 float_type_node
= make_node (REAL_TYPE
);
512 TYPE_PRECISION (float_type_node
) = 32;
513 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
515 layout_type (float_type_node
);
517 double_type_node
= make_node (REAL_TYPE
);
518 TYPE_PRECISION (double_type_node
) = 64;
519 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
521 layout_type (double_type_node
);
523 float_zero_node
= build_real (float_type_node
, dconst0
);
524 double_zero_node
= build_real (double_type_node
, dconst0
);
526 /* These are the vtables for arrays of primitives. */
527 boolean_array_vtable
= create_primitive_vtable ("boolean");
528 byte_array_vtable
= create_primitive_vtable ("byte");
529 char_array_vtable
= create_primitive_vtable ("char");
530 short_array_vtable
= create_primitive_vtable ("short");
531 int_array_vtable
= create_primitive_vtable ("int");
532 long_array_vtable
= create_primitive_vtable ("long");
533 float_array_vtable
= create_primitive_vtable ("float");
534 double_array_vtable
= create_primitive_vtable ("double");
536 /* As you're adding items here, please update the code right after
537 this section, so that the filename containing the source code of
538 the pre-defined class gets registered correctly. */
539 unqualified_object_id_node
= get_identifier ("Object");
540 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
541 object_ptr_type_node
= promote_type (object_type_node
);
542 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
543 string_ptr_type_node
= promote_type (string_type_node
);
544 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
545 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
546 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
547 runtime_exception_type_node
=
548 lookup_class (get_identifier ("java.lang.RuntimeException"));
549 error_exception_type_node
=
550 lookup_class (get_identifier ("java.lang.Error"));
551 class_not_found_type_node
=
552 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
553 no_class_def_found_type_node
=
554 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
556 rawdata_ptr_type_node
557 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
559 add_predefined_file (get_identifier ("java/lang/Class.java"));
560 add_predefined_file (get_identifier ("java/lang/Error.java"));
561 add_predefined_file (get_identifier ("java/lang/Object.java"));
562 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
563 add_predefined_file (get_identifier ("java/lang/String.java"));
564 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
565 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
566 add_predefined_file (get_identifier ("java/lang/Exception.java"));
567 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
568 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
569 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
571 methodtable_type
= make_node (RECORD_TYPE
);
572 layout_type (methodtable_type
);
573 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
574 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
576 TYPE_identifier_node
= get_identifier ("TYPE");
577 init_identifier_node
= get_identifier ("<init>");
578 clinit_identifier_node
= get_identifier ("<clinit>");
579 finit_identifier_node
= get_identifier ("finit$");
580 instinit_identifier_node
= get_identifier ("instinit$");
581 void_signature_node
= get_identifier ("()V");
582 length_identifier_node
= get_identifier ("length");
583 finalize_identifier_node
= get_identifier ("finalize");
584 this_identifier_node
= get_identifier ("this");
585 super_identifier_node
= get_identifier ("super");
586 continue_identifier_node
= get_identifier ("continue");
587 access0_identifier_node
= get_identifier ("access$0");
588 classdollar_identifier_node
= get_identifier ("class$");
590 /* for lack of a better place to put this stub call */
591 init_expr_processing();
593 utf8const_type
= make_node (RECORD_TYPE
);
594 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
595 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
596 FINISH_RECORD (utf8const_type
);
597 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
599 constants_type_node
= make_node (RECORD_TYPE
);
600 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
601 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
602 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
603 FINISH_RECORD (constants_type_node
);
604 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
606 access_flags_type_node
= unsigned_short_type_node
;
608 dtable_type
= make_node (RECORD_TYPE
);
609 dtable_ptr_type
= build_pointer_type (dtable_type
);
611 one_elt_array_domain_type
= build_index_type (integer_one_node
);
612 otable_type
= build_array_type (integer_type_node
,
613 one_elt_array_domain_type
);
614 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
615 otable_ptr_type
= build_pointer_type (otable_type
);
617 method_symbol_type
= make_node (RECORD_TYPE
);
618 PUSH_FIELD (method_symbol_type
, field
, "clname", utf8const_ptr_type
);
619 PUSH_FIELD (method_symbol_type
, field
, "name", utf8const_ptr_type
);
620 PUSH_FIELD (method_symbol_type
, field
, "signature", utf8const_ptr_type
);
621 FINISH_RECORD (method_symbol_type
);
623 method_symbols_array_type
= build_array_type (method_symbol_type
,
624 one_elt_array_domain_type
);
625 method_symbols_array_ptr_type
= build_pointer_type
626 (method_symbols_array_type
);
628 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"), otable_type
);
629 DECL_EXTERNAL (otable_decl
) = 1;
630 TREE_STATIC (otable_decl
) = 1;
631 TREE_READONLY (otable_decl
) = 1;
632 pushdecl (otable_decl
);
634 otable_syms_decl
= build_decl (VAR_DECL
, get_identifier ("otable_syms"),
635 method_symbols_array_type
);
636 TREE_STATIC (otable_syms_decl
) = 1;
637 TREE_CONSTANT (otable_syms_decl
) = 1;
638 pushdecl (otable_syms_decl
);
640 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
641 /* This isn't exactly true, but it is what we have in the source.
642 There is an unresolved issue here, which is whether the vtable
643 should be marked by the GC. */
644 if (! flag_hash_synchronization
)
645 PUSH_FIELD (object_type_node
, field
, "sync_info",
646 build_pointer_type (object_type_node
));
647 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
648 FIELD_PRIVATE (t
) = 1;
649 FINISH_RECORD (object_type_node
);
651 field_type_node
= make_node (RECORD_TYPE
);
652 field_ptr_type_node
= build_pointer_type (field_type_node
);
653 method_type_node
= make_node (RECORD_TYPE
);
654 method_ptr_type_node
= build_pointer_type (method_type_node
);
656 set_super_info (0, class_type_node
, object_type_node
, 0);
657 set_super_info (0, string_type_node
, object_type_node
, 0);
658 class_ptr_type
= build_pointer_type (class_type_node
);
660 PUSH_FIELD (class_type_node
, field
, "next", class_ptr_type
);
661 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
662 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
663 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
664 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
665 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
666 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
667 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
668 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
669 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
670 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
671 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
672 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
673 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
674 PUSH_FIELD (class_type_node
, field
, "otable_syms",
675 method_symbols_array_ptr_type
);
676 PUSH_FIELD (class_type_node
, field
, "interfaces",
677 build_pointer_type (class_ptr_type
));
678 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
679 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
680 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
681 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
682 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
683 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
684 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
685 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
686 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
687 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
688 FIELD_PRIVATE (t
) = 1;
689 push_super_field (class_type_node
, object_type_node
);
691 FINISH_RECORD (class_type_node
);
692 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
694 field_info_union_node
= make_node (UNION_TYPE
);
695 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
696 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
698 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
700 layout_type (field_info_union_node
);
702 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
703 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
704 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
705 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
706 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
707 FINISH_RECORD (field_type_node
);
708 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
710 nativecode_ptr_array_type_node
711 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
713 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
714 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
715 FINISH_RECORD (dtable_type
);
716 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
718 #define jint_type int_type_node
719 #define jint_ptr_type ptr_type_node
721 jexception_type
= make_node (RECORD_TYPE
);
722 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
723 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
724 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
725 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
726 FINISH_RECORD (jexception_type
);
727 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
728 jexception_ptr_type
= build_pointer_type (jexception_type
);
730 lineNumberEntry_type
= make_node (RECORD_TYPE
);
731 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
732 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
733 FINISH_RECORD (lineNumberEntry_type
);
735 lineNumbers_type
= make_node (RECORD_TYPE
);
736 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
737 FINISH_RECORD (lineNumbers_type
);
739 #define instn_ptr_type_node ptr_type_node /* XXX JH */
741 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
743 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
744 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
745 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
746 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
747 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
748 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
749 FINISH_RECORD (method_type_node
);
750 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
752 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
754 t
= tree_cons (NULL_TREE
, class_ptr_type
,
755 tree_cons (NULL_TREE
, int_type_node
, endlink
));
756 alloc_object_node
= builtin_function ("_Jv_AllocObject",
757 build_function_type (ptr_type_node
, t
),
758 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
759 DECL_IS_MALLOC (alloc_object_node
) = 1;
760 alloc_no_finalizer_node
=
761 builtin_function ("_Jv_AllocObjectNoFinalizer",
762 build_function_type (ptr_type_node
, t
),
763 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
764 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
766 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
767 soft_initclass_node
= builtin_function ("_Jv_InitClass",
768 build_function_type (void_type_node
,
770 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
772 throw_node
= builtin_function ("_Jv_Throw",
773 build_function_type (ptr_type_node
, t
),
774 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
775 /* Mark throw_nodes as `noreturn' functions with side effects. */
776 TREE_THIS_VOLATILE (throw_node
) = 1;
777 TREE_SIDE_EFFECTS (throw_node
) = 1;
779 t
= build_function_type (int_type_node
, endlink
);
780 soft_monitorenter_node
781 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
783 soft_monitorexit_node
784 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
787 t
= tree_cons (NULL_TREE
, int_type_node
,
788 tree_cons (NULL_TREE
, int_type_node
, endlink
));
790 = builtin_function ("_Jv_NewPrimArray",
791 build_function_type(ptr_type_node
, t
),
792 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
793 DECL_IS_MALLOC (soft_newarray_node
) = 1;
795 t
= tree_cons (NULL_TREE
, int_type_node
,
796 tree_cons (NULL_TREE
, class_ptr_type
,
797 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
)));
799 = builtin_function ("_Jv_NewObjectArray",
800 build_function_type (ptr_type_node
, t
),
801 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
802 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
804 t
= tree_cons (NULL_TREE
, ptr_type_node
,
805 tree_cons (NULL_TREE
, int_type_node
, endlink
));
806 soft_multianewarray_node
807 = builtin_function ("_Jv_NewMultiArray",
808 build_function_type (ptr_type_node
, t
),
809 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
810 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
812 t
= build_function_type (void_type_node
,
813 tree_cons (NULL_TREE
, int_type_node
, endlink
));
814 soft_badarrayindex_node
815 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
816 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
817 /* Mark soft_badarrayindex_node as a `noreturn' function with side
819 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
820 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
822 soft_nullpointer_node
823 = builtin_function ("_Jv_ThrowNullPointerException",
824 build_function_type (void_type_node
, endlink
),
825 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
826 /* Mark soft_nullpointer_node as a `noreturn' function with side
828 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
829 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
831 t
= tree_cons (NULL_TREE
, class_ptr_type
,
832 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
834 = builtin_function ("_Jv_CheckCast",
835 build_function_type (ptr_type_node
, t
),
836 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
837 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
838 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
840 = builtin_function ("_Jv_IsInstanceOf",
841 build_function_type (boolean_type_node
, t
),
842 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
843 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
844 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
845 soft_checkarraystore_node
846 = builtin_function ("_Jv_CheckArrayStore",
847 build_function_type (void_type_node
, t
),
848 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
849 t
= tree_cons (NULL_TREE
, ptr_type_node
,
850 tree_cons (NULL_TREE
, ptr_type_node
,
851 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
852 soft_lookupinterfacemethod_node
853 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
854 build_function_type (ptr_type_node
, t
),
855 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
857 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
858 tree_cons (NULL_TREE
, ptr_type_node
,
859 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
860 soft_lookupjnimethod_node
861 = builtin_function ("_Jv_LookupJNIMethod",
862 build_function_type (ptr_type_node
, t
),
863 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
864 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
865 soft_getjnienvnewframe_node
866 = builtin_function ("_Jv_GetJNIEnvNewFrame",
867 build_function_type (ptr_type_node
, t
),
868 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
869 soft_jnipopsystemframe_node
870 = builtin_function ("_Jv_JNI_PopSystemFrame",
871 build_function_type (ptr_type_node
, t
),
872 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
874 t
= tree_cons (NULL_TREE
, double_type_node
,
875 tree_cons (NULL_TREE
, double_type_node
, endlink
));
877 = builtin_function ("__builtin_fmod",
878 build_function_type (double_type_node
, t
),
879 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmod", NULL_TREE
);
882 t
= tree_cons (NULL_TREE
, float_type_node
,
883 tree_cons (NULL_TREE
, float_type_node
, endlink
));
885 = builtin_function ("__builtin_fmodf",
886 build_function_type (float_type_node
, t
),
887 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, "fmodf", NULL_TREE
);
891 = builtin_function ("_Jv_divI",
892 build_function_type (int_type_node
, t
),
893 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
896 = builtin_function ("_Jv_remI",
897 build_function_type (int_type_node
, t
),
898 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
901 = builtin_function ("_Jv_divJ",
902 build_function_type (long_type_node
, t
),
903 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
906 = builtin_function ("_Jv_remJ",
907 build_function_type (long_type_node
, t
),
908 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
910 /* Initialize variables for except.c. */
911 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
912 ? "__gcj_personality_sj0"
913 : "__gcj_personality_v0");
914 lang_eh_runtime_type
= prepare_eh_table_type
;
918 initialize_builtins ();
922 /* Look up NAME in the current binding level and its superiors
923 in the namespace of variables, functions and typedefs.
924 Return a ..._DECL node of some kind representing its definition,
925 or return 0 if it is undefined. */
932 if (current_binding_level
!= global_binding_level
933 && IDENTIFIER_LOCAL_VALUE (name
))
934 val
= IDENTIFIER_LOCAL_VALUE (name
);
936 val
= IDENTIFIER_GLOBAL_VALUE (name
);
940 /* Similar to `lookup_name' but look only at current binding level and
941 the previous one if its the parameter level. */
944 lookup_name_current_level (name
)
949 if (current_binding_level
== global_binding_level
)
950 return IDENTIFIER_GLOBAL_VALUE (name
);
952 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
955 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
956 if (DECL_NAME (t
) == name
)
962 /* Use a binding level to record a labeled block declaration */
965 push_labeled_block (lb
)
968 register tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
969 register struct binding_level
*b
= current_binding_level
;
970 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
972 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
973 TREE_CHAIN (lb
) = b
->names
;
975 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
978 /* Pop the current binding level, reinstalling values for the previous
984 struct binding_level
*b
= current_binding_level
;
985 tree label
= b
->names
;
986 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
989 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
990 TREE_VALUE (b
->shadowed
);
992 /* Pop the current level, and free the structure for reuse. */
993 current_binding_level
= current_binding_level
->level_chain
;
994 b
->level_chain
= free_binding_level
;
995 free_binding_level
= b
;
998 /* Record a decl-node X as belonging to the current lexical scope.
999 Check for errors (such as an incompatible declaration for the same
1000 name already seen in the same scope).
1002 Returns either X or an old decl for the same name.
1003 If an old decl is returned, it may have been smashed
1004 to agree with what X says. */
1011 register tree name
= DECL_NAME (x
);
1012 register struct binding_level
*b
= current_binding_level
;
1014 if (TREE_CODE (x
) != TYPE_DECL
)
1015 DECL_CONTEXT (x
) = current_function_decl
;
1021 t
= lookup_name_current_level (name
);
1022 if (t
!= 0 && t
== error_mark_node
)
1023 /* error_mark_node is 0 for a while during initialization! */
1026 error_with_decl (x
, "`%s' used prior to declaration");
1031 file
= DECL_SOURCE_FILE (t
);
1032 line
= DECL_SOURCE_LINE (t
);
1035 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1036 to point to the TYPE_DECL.
1037 Since Java does not have typedefs, a type can only have
1038 one (true) name, given by a class, interface, or builtin. */
1039 if (TREE_CODE (x
) == TYPE_DECL
1040 && TYPE_NAME (TREE_TYPE (x
)) == 0
1041 && TREE_TYPE (x
) != error_mark_node
)
1043 TYPE_NAME (TREE_TYPE (x
)) = x
;
1044 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1047 /* This name is new in its binding level.
1048 Install the new declaration and return it. */
1049 if (b
== global_binding_level
)
1051 /* Install a global value. */
1053 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1057 /* Here to install a non-global value. */
1058 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1059 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1062 /* Warn if shadowing an argument at the top level of the body. */
1063 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1064 /* This warning doesn't apply to the parms of a nested fcn. */
1065 && ! current_binding_level
->parm_flag
1066 /* Check that this is one level down from the parms. */
1067 && current_binding_level
->level_chain
->parm_flag
1068 /* Check that the decl being shadowed
1069 comes from the parm level, one level up. */
1070 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1072 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1073 pedwarn ("declaration of `%s' shadows a parameter",
1074 IDENTIFIER_POINTER (name
));
1076 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1077 IDENTIFIER_POINTER (name
));
1080 /* Maybe warn if shadowing something else. */
1081 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1082 /* No shadow warnings for internally generated vars. */
1083 && DECL_SOURCE_LINE (x
) != 0
1084 /* No shadow warnings for vars made for inlining. */
1085 && ! DECL_FROM_INLINE (x
))
1087 const char *warnstring
= 0;
1089 if (TREE_CODE (x
) == PARM_DECL
1090 && current_binding_level
->level_chain
->parm_flag
)
1091 /* Don't warn about the parm names in function declarator
1092 within a function declarator.
1093 It would be nice to avoid warning in any function
1094 declarator in a declaration, as opposed to a definition,
1095 but there is no way to tell it's not a definition. */
1097 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1098 warnstring
= "declaration of `%s' shadows a parameter";
1099 else if (oldlocal
!= 0)
1100 warnstring
= "declaration of `%s' shadows previous local";
1101 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1102 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1103 warnstring
= "declaration of `%s' shadows global declaration";
1106 warning (warnstring
, IDENTIFIER_POINTER (name
));
1110 /* If storing a local value, there may already be one (inherited).
1111 If so, record it for restoration when this binding level ends. */
1113 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1117 /* Put decls on list in reverse order.
1118 We will reverse them later if necessary. */
1119 TREE_CHAIN (x
) = b
->names
;
1126 pushdecl_force_head (x
)
1129 current_binding_level
->names
= x
;
1132 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1135 pushdecl_top_level (x
)
1139 register struct binding_level
*b
= current_binding_level
;
1141 current_binding_level
= global_binding_level
;
1143 current_binding_level
= b
;
1147 /* Nonzero if we are currently in the global binding level. */
1150 global_bindings_p ()
1152 return current_binding_level
== global_binding_level
;
1155 /* Return the list of declarations of the current level.
1156 Note that this list is in reverse order unless/until
1157 you nreverse it; and when you do nreverse it, you must
1158 store the result back using `storedecls' or you will lose. */
1163 return current_binding_level
->names
;
1166 /* Create a new `struct binding_level'. */
1168 static struct binding_level
*
1169 make_binding_level ()
1172 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
1177 int unused ATTRIBUTE_UNUSED
;
1179 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1182 /* If this is the top level of a function,
1183 just make sure that NAMED_LABELS is 0. */
1185 if (current_binding_level
== global_binding_level
)
1189 /* Reuse or create a struct for this binding level. */
1191 if (free_binding_level
)
1193 newlevel
= free_binding_level
;
1194 free_binding_level
= free_binding_level
->level_chain
;
1198 newlevel
= make_binding_level ();
1201 /* Add this level to the front of the chain (stack) of levels that
1204 *newlevel
= clear_binding_level
;
1205 newlevel
->level_chain
= current_binding_level
;
1206 current_binding_level
= newlevel
;
1207 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1208 newlevel
->binding_depth
= binding_depth
;
1210 fprintf (stderr
, "push %s level 0x%08x pc %d\n",
1211 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1214 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1217 /* Exit a binding level.
1218 Pop the level off, and restore the state of the identifier-decl mappings
1219 that were in effect when this level was entered.
1221 If KEEP is nonzero, this level had explicit declarations, so
1222 and create a "block" (a BLOCK node) for the level
1223 to record its declarations and subblocks for symbol table output.
1225 If FUNCTIONBODY is nonzero, this level is the body of a function,
1226 so create a block as if KEEP were set and also clear out all
1229 If REVERSE is nonzero, reverse the order of decls before putting
1230 them into the BLOCK. */
1233 poplevel (keep
, reverse
, 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 (pc
)
1443 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1447 while (pending_local_decls
!= NULL_TREE
&&
1448 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1450 tree
*ptr
= &pending_local_decls
;
1452 int end_pc
= DECL_LOCAL_END_PC (decl
);
1454 while (*ptr
!= NULL_TREE
1455 && DECL_LOCAL_START_PC (*ptr
) <= pc
1456 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1457 ptr
= &TREE_CHAIN (*ptr
);
1458 pending_local_decls
= *ptr
;
1461 /* Force non-nested range to be nested in current range. */
1462 if (end_pc
> current_binding_level
->end_pc
)
1463 end_pc
= current_binding_level
->end_pc
;
1465 maybe_start_try (pc
, end_pc
);
1468 expand_start_bindings (0);
1470 current_binding_level
->end_pc
= end_pc
;
1471 current_binding_level
->start_pc
= pc
;
1472 current_binding_level
->names
= decl
;
1473 for ( ; decl
!= NULL_TREE
; decl
= TREE_CHAIN (decl
))
1475 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1479 maybe_start_try (pc
, 0);
1483 maybe_poplevels (pc
)
1486 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1490 while (current_binding_level
->end_pc
<= pc
)
1492 expand_end_bindings (getdecls (), 1, 0);
1493 maybe_end_try (current_binding_level
->start_pc
, pc
);
1496 maybe_end_try (0, pc
);
1499 /* Terminate any binding which began during the range beginning at
1500 start_pc. This tidies up improperly nested local variable ranges
1501 and exception handlers; a variable declared within an exception
1502 range is forcibly terminated when that exception ends. */
1505 force_poplevels (start_pc
)
1508 while (current_binding_level
->start_pc
> start_pc
)
1510 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1511 warning_with_decl (current_function_decl
,
1512 "In %s: overlapped variable and exception ranges at %d",
1513 current_binding_level
->start_pc
);
1514 expand_end_bindings (getdecls (), 1, 0);
1519 /* Insert BLOCK at the end of the list of subblocks of the
1520 current binding level. This is used when a BIND_EXPR is expanded,
1521 to handle the BLOCK node inside the BIND_EXPR. */
1524 insert_block (block
)
1527 TREE_USED (block
) = 1;
1528 current_binding_level
->blocks
1529 = chainon (current_binding_level
->blocks
, block
);
1532 /* Set the BLOCK node for the innermost scope
1533 (the one we are currently in). */
1537 register tree block
;
1539 current_binding_level
->this_block
= block
;
1540 current_binding_level
->names
= chainon (current_binding_level
->names
,
1541 BLOCK_VARS (block
));
1542 current_binding_level
->blocks
= chainon (current_binding_level
->blocks
,
1543 BLOCK_SUBBLOCKS (block
));
1546 /* integrate_decl_tree calls this function. */
1549 java_dup_lang_specific_decl (node
)
1553 struct lang_decl
*x
;
1555 if (!DECL_LANG_SPECIFIC (node
))
1558 lang_decl_size
= sizeof (struct lang_decl
);
1559 x
= (struct lang_decl
*) ggc_alloc (lang_decl_size
);
1560 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1561 DECL_LANG_SPECIFIC (node
) = x
;
1565 give_name_to_locals (jcf
)
1568 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1569 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1571 pending_local_decls
= NULL_TREE
;
1575 n
= JCF_readu2 (jcf
);
1576 for (i
= 0; i
< n
; i
++)
1578 int start_pc
= JCF_readu2 (jcf
);
1579 int length
= JCF_readu2 (jcf
);
1580 int name_index
= JCF_readu2 (jcf
);
1581 int signature_index
= JCF_readu2 (jcf
);
1582 int slot
= JCF_readu2 (jcf
);
1583 tree name
= get_name_constant (jcf
, name_index
);
1584 tree type
= parse_signature (jcf
, signature_index
);
1585 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1587 && length
== DECL_CODE_LENGTH (current_function_decl
))
1589 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1590 DECL_NAME (decl
) = name
;
1591 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1592 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1593 warning ("bad type in parameter debug info");
1598 int end_pc
= start_pc
+ length
;
1599 tree decl
= build_decl (VAR_DECL
, name
, type
);
1600 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1602 warning_with_decl (decl
,
1603 "bad PC range for debug info for local `%s'");
1604 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1607 /* Adjust start_pc if necessary so that the local's first
1608 store operation will use the relevant DECL as a
1609 destination. Fore more information, read the leading
1610 comments for expr.c:maybe_adjust_start_pc. */
1611 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1613 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1614 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1615 DECL_LOCAL_START_PC (decl
) = start_pc
;
1617 /* FIXME: The range used internally for exceptions and local
1618 variable ranges, is a half-open interval:
1619 start_pc <= pc < end_pc. However, the range used in the
1620 Java VM spec is inclusive at both ends:
1621 start_pc <= pc <= end_pc. */
1624 DECL_LOCAL_END_PC (decl
) = end_pc
;
1626 /* Now insert the new decl in the proper place in
1627 pending_local_decls. We are essentially doing an insertion sort,
1628 which works fine, since the list input will normally already
1630 ptr
= &pending_local_decls
;
1631 while (*ptr
!= NULL_TREE
1632 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1633 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1634 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1635 ptr
= &TREE_CHAIN (*ptr
);
1636 TREE_CHAIN (decl
) = *ptr
;
1641 pending_local_decls
= nreverse (pending_local_decls
);
1643 /* Fill in default names for the parameters. */
1644 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1645 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1647 if (DECL_NAME (parm
) == NULL_TREE
)
1649 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1651 DECL_NAME (parm
) = get_identifier ("this");
1655 sprintf (buffer
, "ARG_%d", arg_i
);
1656 DECL_NAME (parm
) = get_identifier (buffer
);
1658 SET_DECL_ASSEMBLER_NAME (parm
, DECL_NAME (parm
));
1664 build_result_decl (fndecl
)
1667 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1668 tree result
= DECL_RESULT (fndecl
);
1671 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1672 if (INTEGRAL_TYPE_P (restype
)
1673 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1674 restype
= integer_type_node
;
1675 result
= build_decl (RESULT_DECL
, NULL_TREE
, restype
);
1676 DECL_CONTEXT (result
) = fndecl
;
1677 DECL_RESULT (fndecl
) = result
;
1683 complete_start_java_method (fndecl
)
1686 if (! flag_emit_class_files
)
1688 /* Initialize the RTL code for the function. */
1689 init_function_start (fndecl
, input_filename
, lineno
);
1691 /* Set up parameters and prepare for return, for the function. */
1692 expand_function_start (fndecl
, 0);
1696 /* If this fcn was already referenced via a block-scope `extern' decl (or
1697 an implicit decl), propagate certain information about the usage. */
1698 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
1699 TREE_ADDRESSABLE (current_function_decl
) = 1;
1703 if (METHOD_STATIC (fndecl
) && ! METHOD_PRIVATE (fndecl
)
1704 && ! flag_emit_class_files
1705 && ! DECL_CLINIT_P (fndecl
)
1706 && ! CLASS_INTERFACE (TYPE_NAME (current_class
)))
1708 tree clas
= DECL_CONTEXT (fndecl
);
1709 tree init
= build (CALL_EXPR
, void_type_node
,
1710 build_address_of (soft_initclass_node
),
1711 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
1713 TREE_SIDE_EFFECTS (init
) = 1;
1714 expand_expr_stmt (init
);
1717 /* Push local variables. Function compiled from source code are
1718 using a different local variables management, and for them,
1719 pushlevel shouldn't be called from here. */
1720 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1723 if (! flag_emit_class_files
)
1724 expand_start_bindings (1);
1727 if (METHOD_SYNCHRONIZED (fndecl
) && ! flag_emit_class_files
)
1729 /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1730 tree enter
, exit
, lock
;
1731 if (METHOD_STATIC (fndecl
))
1732 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1734 lock
= DECL_ARGUMENTS (fndecl
);
1735 BUILD_MONITOR_ENTER (enter
, lock
);
1736 BUILD_MONITOR_EXIT (exit
, lock
);
1737 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl
)))
1739 expand_expr_stmt (enter
);
1740 expand_decl_cleanup (NULL_TREE
, exit
);
1744 tree function_body
= DECL_FUNCTION_BODY (fndecl
);
1745 tree body
= BLOCK_EXPR_BODY (function_body
);
1746 lock
= build (COMPOUND_EXPR
, void_type_node
,
1748 build (TRY_FINALLY_EXPR
, void_type_node
, body
, exit
));
1749 TREE_SIDE_EFFECTS (lock
) = 1;
1750 BLOCK_EXPR_BODY (function_body
) = lock
;
1756 start_java_method (fndecl
)
1762 current_function_decl
= fndecl
;
1763 announce_function (fndecl
);
1765 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1766 decl_map
= make_tree_vec (i
);
1767 type_map
= (tree
*) xrealloc (type_map
, i
* sizeof (tree
));
1769 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1770 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1772 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1773 pushlevel (1); /* Push parameters. */
1775 ptr
= &DECL_ARGUMENTS (fndecl
);
1776 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1777 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1779 tree parm_name
= NULL_TREE
, parm_decl
;
1780 tree parm_type
= TREE_VALUE (tem
);
1781 if (i
>= DECL_MAX_LOCALS (fndecl
))
1784 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
1785 DECL_CONTEXT (parm_decl
) = fndecl
;
1786 if (PROMOTE_PROTOTYPES
1787 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1788 && INTEGRAL_TYPE_P (parm_type
))
1789 parm_type
= integer_type_node
;
1790 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1793 ptr
= &TREE_CHAIN (parm_decl
);
1795 /* Add parm_decl to the decl_map. */
1796 push_jvm_slot (i
, parm_decl
);
1798 type_map
[i
] = TREE_TYPE (parm_decl
);
1799 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1802 type_map
[i
] = void_type_node
;
1806 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1808 while (i
< DECL_MAX_LOCALS(fndecl
))
1809 type_map
[i
++] = NULL_TREE
;
1811 build_result_decl (fndecl
);
1812 complete_start_java_method (fndecl
);
1818 tree fndecl
= current_function_decl
;
1820 expand_end_bindings (getdecls (), 1, 0);
1821 /* pop out of function */
1824 /* pop out of its parameters */
1827 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1829 /* Generate rtl for function exit. */
1830 expand_function_end (input_filename
, lineno
, 0);
1832 /* Run the optimizers and output assembler code for this function. */
1833 rest_of_compilation (fndecl
);
1835 current_function_decl
= NULL_TREE
;
1838 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1841 dump_function (phase
, fn
)
1842 enum tree_dump_index phase
;
1848 stream
= dump_begin (phase
, &flags
);
1851 dump_node (fn
, TDF_SLIM
| flags
, stream
);
1852 dump_end (phase
, stream
);
1856 void java_optimize_inline (fndecl
)
1859 if (flag_inline_trees
)
1861 timevar_push (TV_INTEGRATION
);
1862 optimize_inline_calls (fndecl
);
1863 timevar_pop (TV_INTEGRATION
);
1864 dump_function (TDI_inlined
, fndecl
);
1868 #include "gt-java-decl.h"