1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, 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"
48 #include "tree-inline.h"
52 #if defined (DEBUG_JAVA_BINDING_LEVELS)
53 extern void indent (void);
56 static tree
push_jvm_slot (int, tree
);
57 static tree
lookup_name_current_level (tree
);
58 static tree
push_promoted_type (const char *, tree
);
59 static struct binding_level
*make_binding_level (void);
60 static tree
create_primitive_vtable (const char *);
61 static tree
check_local_unnamed_variable (tree
, tree
, tree
);
62 static void parse_version (void);
65 /* The following ABI flags are used in the high-order bits of the version
66 ID field. The version ID number itself should never be larger than
67 0xfffff, so it should be safe to use top 12 bits for these flags. */
69 #define FLAG_BINARYCOMPAT_ABI (1<<31) /* Class is built with the BC-ABI. */
71 #define FLAG_BOOTSTRAP_LOADER (1<<30) /* Used when defining a class that
72 should be loaded by the bootstrap
75 /* If an ABI change is made within a GCC release series, rendering current
76 binaries incompatible with the old runtimes, this number can be set to
77 enforce the compatibility rules. */
78 #define MINOR_BINARYCOMPAT_ABI_VERSION 0
80 /* The runtime may recognize a variety of BC ABIs (objects generated by
81 different version of gcj), but will probably always require strict
82 matching for the ordinary (C++) ABI. */
84 /* The version ID of the BC ABI that we generate. This must be kept in
85 sync with parse_version(), libgcj, and reality (if the BC format changes,
87 #define GCJ_CURRENT_BC_ABI_VERSION \
88 (4 * 100000 + 0 * 1000 + MINOR_BINARYCOMPAT_ABI_VERSION)
90 /* The ABI version number. */
93 /* Name of the Cloneable class. */
94 tree java_lang_cloneable_identifier_node
;
96 /* Name of the Serializable class. */
97 tree java_io_serializable_identifier_node
;
99 /* The DECL_MAP is a mapping from (index, type) to a decl node.
100 If index < max_locals, it is the index of a local variable.
101 if index >= max_locals, then index-max_locals is a stack slot.
102 The DECL_MAP mapping is represented as a TREE_VEC whose elements
103 are a list of decls (VAR_DECL or PARM_DECL) chained by
104 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
105 we search the chain for a decl with a matching TREE_TYPE. */
107 static GTY(()) tree decl_map
;
109 /* The base_decl_map is contains one variable of ptr_type: this is
110 used to contain every variable of reference type that is ever
111 stored in a local variable slot. */
113 static GTY(()) tree base_decl_map
;
115 /* An index used to make temporary identifiers unique. */
118 /* A list of local variables VAR_DECLs for this method that we have seen
119 debug information, but we have not reached their starting (byte) PC yet. */
121 static GTY(()) tree pending_local_decls
;
123 /* The decl for "_Jv_ResolvePoolEntry". */
124 tree soft_resolvepoolentry_node
;
126 #if defined(DEBUG_JAVA_BINDING_LEVELS)
127 int binding_depth
= 0;
128 int is_class_level
= 0;
136 for (i
= 0; i
< binding_depth
*2; i
++)
139 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
141 /* True if decl is a named local variable, i.e. if it is an alias
142 that's used only for debugging purposes. */
145 debug_variable_p (tree decl
)
147 if (TREE_CODE (decl
) == PARM_DECL
)
150 if (LOCAL_SLOT_P (decl
))
156 /* Copy the value in decl into every live alias in the same local
157 variable slot. Some of these will be dead stores removed by the
161 update_aliases (tree decl
, int index
, int pc
)
163 tree decl_type
= TREE_TYPE (decl
);
166 if (debug_variable_p (decl
))
169 for (tmp
= TREE_VEC_ELT (decl_map
, index
);
171 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
))
173 tree tmp_type
= TREE_TYPE (tmp
);
175 && LOCAL_SLOT_P (tmp
) == 0
177 || (pc
>= DECL_LOCAL_START_PC (tmp
)
178 && pc
< DECL_LOCAL_END_PC (tmp
)))
179 /* This test is < (rather than <=) because there's no point
180 updating an alias that's about to die at the end of this
182 && (tmp_type
== decl_type
183 || (INTEGRAL_TYPE_P (tmp_type
)
184 && INTEGRAL_TYPE_P (decl_type
)
185 && TYPE_PRECISION (decl_type
) <= 32
186 && TYPE_PRECISION (tmp_type
) <= 32)
187 || (TREE_CODE (tmp_type
) == POINTER_TYPE
188 && TREE_CODE (decl_type
) == POINTER_TYPE
)))
190 tree src
= build1 (NOP_EXPR
, tmp_type
, decl
);
191 if (LOCAL_VAR_OUT_OF_SCOPE_P (tmp
))
193 java_add_stmt (build2 (MODIFY_EXPR
, tmp_type
, tmp
, src
));
199 push_jvm_slot (int index
, tree decl
)
201 DECL_CONTEXT (decl
) = current_function_decl
;
202 layout_decl (decl
, 0);
204 /* Now link the decl into the decl_map. */
205 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
207 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
208 DECL_LOCAL_START_PC (decl
) = 0;
209 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
210 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
212 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
213 TREE_VEC_ELT (decl_map
, index
) = decl
;
218 /* At the point of its creation a local variable decl inherits
219 whatever is already in the same slot. In the case of a local
220 variable that is declared but unused, we won't find anything. */
223 initialize_local_variable (tree decl
, int index
)
225 tree decl_type
= TREE_TYPE (decl
);
226 if (TREE_CODE (decl_type
) == POINTER_TYPE
)
228 tree tmp
= TREE_VEC_ELT (base_decl_map
, index
);
232 /* At the point of its creation this decl inherits whatever
234 tree src
= build1 (NOP_EXPR
, decl_type
, tmp
);
235 java_add_stmt (build2 (MODIFY_EXPR
, decl_type
, decl
, src
));
242 for (tmp
= TREE_VEC_ELT (decl_map
, index
);
244 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
))
246 tree tmp_type
= TREE_TYPE (tmp
);
248 && ! debug_variable_p (tmp
)
249 && (tmp_type
== decl_type
250 || (INTEGRAL_TYPE_P (tmp_type
)
251 && INTEGRAL_TYPE_P (decl_type
)
252 && TYPE_PRECISION (decl_type
) <= 32
253 && TYPE_PRECISION (tmp_type
) <= 32
254 && TYPE_PRECISION (tmp_type
)
255 >= TYPE_PRECISION (decl_type
))))
257 java_add_stmt (build2 (MODIFY_EXPR
, decl_type
, decl
, tmp
));
264 /* Find the best declaration based upon type. If 'decl' fits 'type' better
265 than 'best', return 'decl'. Otherwise return 'best'. */
268 check_local_unnamed_variable (tree best
, tree decl
, tree type
)
270 tree decl_type
= TREE_TYPE (decl
);
272 if (LOCAL_VAR_OUT_OF_SCOPE_P (decl
))
275 /* Use the same decl for all integer types <= 32 bits. This is
276 necessary because sometimes a value is stored as (for example)
277 boolean but loaded as int. */
278 if (decl_type
== type
279 || (INTEGRAL_TYPE_P (decl_type
)
280 && INTEGRAL_TYPE_P (type
)
281 && TYPE_PRECISION (decl_type
) <= 32
282 && TYPE_PRECISION (type
) <= 32
283 && TYPE_PRECISION (decl_type
) >= TYPE_PRECISION (type
))
284 /* ptr_type_node is used for null pointers, which are
285 assignment compatible with everything. */
286 || (TREE_CODE (decl_type
) == POINTER_TYPE
287 && type
== ptr_type_node
)
288 /* Whenever anyone wants to use a slot that is initially
289 occupied by a PARM_DECL of pointer type they must get that
290 decl, even if they asked for a pointer to a different type.
291 However, if someone wants a scalar variable in a slot that
292 initially held a pointer arg -- or vice versa -- we create a
295 ???: As long as verification is correct, this will be a
296 compatible type. But maybe we should create a dummy variable
297 and replace all references to it with the DECL and a
300 || (TREE_CODE (decl_type
) == POINTER_TYPE
301 && TREE_CODE (decl
) == PARM_DECL
302 && TREE_CODE (type
) == POINTER_TYPE
))
304 if (best
== NULL_TREE
305 || (decl_type
== type
&& TREE_TYPE (best
) != type
))
313 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
314 that is valid at PC (or -1 if any pc).
315 If there is no existing matching decl, allocate one. */
318 find_local_variable (int index
, tree type
, int pc ATTRIBUTE_UNUSED
)
320 tree tmp
= TREE_VEC_ELT (decl_map
, index
);
321 tree decl
= NULL_TREE
;
323 /* Scan through every declaration that has been created in this
324 slot. We're only looking for variables that correspond to local
325 index declarations and PARM_DECLs, not named variables: such
326 local variables are used only for debugging information. */
327 while (tmp
!= NULL_TREE
)
329 if (! debug_variable_p (tmp
))
330 decl
= check_local_unnamed_variable (decl
, tmp
, type
);
331 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
334 /* gcj has a function called promote_type(), which is used by both
335 the bytecode compiler and the source compiler. Unfortunately,
336 the type systems for the Java VM and the Java language are not
337 the same: a boolean in the VM promotes to an int, not to a wide
338 boolean. If our caller wants something to hold a boolean, that
339 had better be an int, because that slot might be re-used
340 later in integer context. */
341 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
342 type
= integer_type_node
;
344 /* If we don't find a match, create one with the type passed in.
345 The name of the variable is #n#m, which n is the variable index
346 in the local variable area and m is a dummy identifier for
347 uniqueness -- multiple variables may share the same local
348 variable index. We don't call pushdecl() to push pointer types
349 into a binding expr because they'll all be replaced by a single
350 variable that is used for every reference in that local variable
356 sprintf (buf
, "#slot#%d#%d", index
, uniq
++);
357 name
= get_identifier (buf
);
358 decl
= build_decl (VAR_DECL
, name
, type
);
359 DECL_IGNORED_P (decl
) = 1;
360 DECL_ARTIFICIAL (decl
) = 1;
361 decl
= push_jvm_slot (index
, decl
);
362 LOCAL_SLOT_P (decl
) = 1;
364 if (TREE_CODE (type
) != POINTER_TYPE
)
365 pushdecl_function_level (decl
);
368 /* As well as creating a local variable that matches the type, we
369 also create a base variable (of ptr_type) that will hold all its
371 if (TREE_CODE (type
) == POINTER_TYPE
372 && ! TREE_VEC_ELT (base_decl_map
, index
))
377 sprintf (buf
, "#ref#%d#%d", index
, uniq
++);
378 name
= get_identifier (buf
);
380 = TREE_VEC_ELT (base_decl_map
, index
)
381 = build_decl (VAR_DECL
, name
, ptr_type_node
);
382 pushdecl_function_level (base_decl
);
383 DECL_IGNORED_P (base_decl
) = 1;
384 DECL_ARTIFICIAL (base_decl
) = 1;
390 /* Called during gimplification for every variable. If the variable
391 is a temporary of pointer type, replace it with a common variable
392 thath is used to hold all pointer types that are ever stored in
393 that slot. Set WANT_LVALUE if you want a variable that is to be
397 java_replace_reference (tree var_decl
, bool want_lvalue
)
404 decl_type
= TREE_TYPE (var_decl
);
406 if (TREE_CODE (decl_type
) == POINTER_TYPE
)
408 if (DECL_LANG_SPECIFIC (var_decl
)
409 && LOCAL_SLOT_P (var_decl
))
411 int index
= DECL_LOCAL_SLOT_NUMBER (var_decl
);
412 tree base_decl
= TREE_VEC_ELT (base_decl_map
, index
);
418 base_decl
= build1 (NOP_EXPR
, decl_type
, base_decl
);
428 /* Same as find_local_index, except that INDEX is a stack index. */
431 find_stack_slot (int index
, tree type
)
433 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
437 struct binding_level
GTY(())
439 /* A chain of _DECL nodes for all variables, constants, functions,
440 * and typedef types. These are in the reverse of the order supplied.
444 /* For each level, a list of shadowed outer-level local definitions
445 to be restored when this level is popped.
446 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
447 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
450 /* For each level (except not the global one),
451 a chain of BLOCK nodes for all the levels
452 that were entered and exited one level down. */
455 /* The binding level which this one is contained in (inherits from). */
456 struct binding_level
*level_chain
;
458 /* The bytecode PC that marks the end of this level. */
460 /* The bytecode PC that marks the start of this level. */
463 /* The statements in this binding level. */
466 /* An exception range associated with this binding level. */
467 struct eh_range
* GTY((skip (""))) exception_range
;
469 /* Binding depth at which this level began. Used only for debugging. */
470 unsigned binding_depth
;
473 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
475 /* The binding level currently in effect. */
477 static GTY(()) struct binding_level
*current_binding_level
;
479 /* A chain of binding_level structures awaiting reuse. */
481 static GTY(()) struct binding_level
*free_binding_level
;
483 /* The outermost binding level, for names of file scope.
484 This is created when the compiler is started and exists
485 through the entire run. */
487 static GTY(()) struct binding_level
*global_binding_level
;
489 /* The binding level that holds variables declared at the outermost
490 level within a function body. */
492 static struct binding_level
*function_binding_level
;
494 /* A PC value bigger than any PC value we may ever may encounter. */
496 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
498 /* Binding level structures are initialized by copying this one. */
500 static const struct binding_level clear_binding_level
502 NULL_TREE
, /* names */
503 NULL_TREE
, /* shadowed */
504 NULL_TREE
, /* blocks */
505 NULL_BINDING_LEVEL
, /* level_chain */
506 LARGEST_PC
, /* end_pc */
509 NULL
, /* exception_range */
510 0, /* binding_depth */
514 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
515 that have names. Here so we can clear out their names' definitions
516 at the end of the function. */
518 static tree named_labels
;
520 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
522 static tree shadowed_labels
;
525 tree java_global_trees
[JTI_MAX
];
527 /* Build (and pushdecl) a "promoted type" for all standard
528 types shorter than int. */
531 push_promoted_type (const char *name
, tree actual_type
)
533 tree type
= make_node (TREE_CODE (actual_type
));
535 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
536 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
538 tree in_min
= TYPE_MIN_VALUE (actual_type
);
539 tree in_max
= TYPE_MAX_VALUE (actual_type
);
541 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
542 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
543 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
544 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
545 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
547 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
551 /* Return a definition for a builtin function named NAME and whose data type
552 is TYPE. TYPE should be a function type with argument types.
553 FUNCTION_CODE tells later passes how to compile calls to this function.
554 See tree.h for its possible values.
556 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
557 the name to be called if we can't opencode the function. If
558 ATTRS is nonzero, use that for the function's attribute list. */
561 builtin_function (const char *name
,
564 enum built_in_class cl
,
565 const char *library_name
,
566 tree
ARG_UNUSED (attrs
))
568 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
569 DECL_EXTERNAL (decl
) = 1;
570 TREE_PUBLIC (decl
) = 1;
572 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
574 DECL_BUILT_IN_CLASS (decl
) = cl
;
575 DECL_FUNCTION_CODE (decl
) = function_code
;
579 /* Return tree that represents a vtable for a primitive array. */
581 create_primitive_vtable (const char *name
)
586 sprintf (buf
, "_Jv_%sVTable", name
);
587 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
588 DECL_EXTERNAL (r
) = 1;
598 /* Parse the version string and compute the ABI version number. */
602 const char *p
= version_string
;
603 unsigned int major
= 0, minor
= 0;
604 unsigned int abi_version
;
606 /* Skip leading junk. */
607 while (*p
&& !ISDIGIT (*p
))
611 /* Extract major version. */
614 major
= major
* 10 + *p
- '0';
618 gcc_assert (*p
== '.' && ISDIGIT (p
[1]));
621 /* Extract minor version. */
624 minor
= minor
* 10 + *p
- '0';
628 if (flag_indirect_dispatch
)
630 abi_version
= GCJ_CURRENT_BC_ABI_VERSION
;
631 abi_version
|= FLAG_BINARYCOMPAT_ABI
;
635 /* Implicit in this computation is the idea that we won't break the
636 old-style binary ABI in a sub-minor release (e.g., from 4.0.0 to
638 abi_version
= 100000 * major
+ 1000 * minor
;
640 if (flag_bootstrap_classes
)
641 abi_version
|= FLAG_BOOTSTRAP_LOADER
;
643 gcj_abi_version
= build_int_cstu (ptr_type_node
, abi_version
);
647 java_init_decl_processing (void)
650 tree field
= NULL_TREE
;
653 init_class_processing ();
655 current_function_decl
= NULL
;
656 current_binding_level
= NULL_BINDING_LEVEL
;
657 free_binding_level
= NULL_BINDING_LEVEL
;
658 pushlevel (0); /* make the binding_level structure for global names */
659 global_binding_level
= current_binding_level
;
661 /* The code here must be similar to build_common_tree_nodes{,_2} in
662 tree.c, especially as to the order of initializing common nodes. */
663 error_mark_node
= make_node (ERROR_MARK
);
664 TREE_TYPE (error_mark_node
) = error_mark_node
;
666 /* Create sizetype first - needed for other types. */
667 initialize_sizetypes (false);
669 byte_type_node
= make_signed_type (8);
670 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
671 short_type_node
= make_signed_type (16);
672 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
673 int_type_node
= make_signed_type (32);
674 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
675 long_type_node
= make_signed_type (64);
676 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
678 unsigned_byte_type_node
= make_unsigned_type (8);
679 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
680 unsigned_byte_type_node
));
681 unsigned_short_type_node
= make_unsigned_type (16);
682 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
683 unsigned_short_type_node
));
684 unsigned_int_type_node
= make_unsigned_type (32);
685 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
686 unsigned_int_type_node
));
687 unsigned_long_type_node
= make_unsigned_type (64);
688 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
689 unsigned_long_type_node
));
691 /* This is not a java type, however tree-dfa requires a definition for
693 size_type_node
= make_unsigned_type (POINTER_SIZE
);
694 set_sizetype (size_type_node
);
696 /* Define these next since types below may used them. */
697 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
698 integer_zero_node
= build_int_cst (NULL_TREE
, 0);
699 integer_one_node
= build_int_cst (NULL_TREE
, 1);
700 integer_two_node
= build_int_cst (NULL_TREE
, 2);
701 integer_four_node
= build_int_cst (NULL_TREE
, 4);
702 integer_minus_one_node
= build_int_cst (NULL_TREE
, -1);
704 /* A few values used for range checking in the lexer. */
705 decimal_int_max
= build_int_cstu (unsigned_int_type_node
, 0x80000000);
706 #if HOST_BITS_PER_WIDE_INT == 64
707 decimal_long_max
= build_int_cstu (unsigned_long_type_node
,
708 0x8000000000000000LL
);
709 #elif HOST_BITS_PER_WIDE_INT == 32
710 decimal_long_max
= build_int_cst_wide (unsigned_long_type_node
,
713 #error "unsupported size"
716 size_zero_node
= size_int (0);
717 size_one_node
= size_int (1);
718 bitsize_zero_node
= bitsize_int (0);
719 bitsize_one_node
= bitsize_int (1);
720 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
722 long_zero_node
= build_int_cst (long_type_node
, 0);
724 void_type_node
= make_node (VOID_TYPE
);
725 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
726 layout_type (void_type_node
); /* Uses size_zero_node */
728 ptr_type_node
= build_pointer_type (void_type_node
);
730 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
732 t
= make_node (VOID_TYPE
);
733 layout_type (t
); /* Uses size_zero_node */
734 return_address_type_node
= build_pointer_type (t
);
736 null_pointer_node
= build_int_cst (ptr_type_node
, 0);
739 /* Make a type to be the domain of a few array types
740 whose domains don't really matter.
741 200 is small enough that it always fits in size_t
742 and large enough that it can hold most function names for the
743 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
744 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
746 char_type_node
= make_node (CHAR_TYPE
);
747 TYPE_PRECISION (char_type_node
) = 16;
748 fixup_unsigned_type (char_type_node
);
749 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
751 boolean_type_node
= make_node (BOOLEAN_TYPE
);
752 TYPE_PRECISION (boolean_type_node
) = 1;
753 fixup_unsigned_type (boolean_type_node
);
754 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
756 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
757 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
759 promoted_byte_type_node
760 = push_promoted_type ("promoted_byte", byte_type_node
);
761 promoted_short_type_node
762 = push_promoted_type ("promoted_short", short_type_node
);
763 promoted_char_type_node
764 = push_promoted_type ("promoted_char", char_type_node
);
765 promoted_boolean_type_node
766 = push_promoted_type ("promoted_boolean", boolean_type_node
);
768 float_type_node
= make_node (REAL_TYPE
);
769 TYPE_PRECISION (float_type_node
) = 32;
770 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
772 layout_type (float_type_node
);
774 double_type_node
= make_node (REAL_TYPE
);
775 TYPE_PRECISION (double_type_node
) = 64;
776 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
778 layout_type (double_type_node
);
780 float_zero_node
= build_real (float_type_node
, dconst0
);
781 double_zero_node
= build_real (double_type_node
, dconst0
);
783 /* These are the vtables for arrays of primitives. */
784 boolean_array_vtable
= create_primitive_vtable ("boolean");
785 byte_array_vtable
= create_primitive_vtable ("byte");
786 char_array_vtable
= create_primitive_vtable ("char");
787 short_array_vtable
= create_primitive_vtable ("short");
788 int_array_vtable
= create_primitive_vtable ("int");
789 long_array_vtable
= create_primitive_vtable ("long");
790 float_array_vtable
= create_primitive_vtable ("float");
791 double_array_vtable
= create_primitive_vtable ("double");
793 one_elt_array_domain_type
= build_index_type (integer_one_node
);
794 utf8const_type
= make_node (RECORD_TYPE
);
795 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
796 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
797 FINISH_RECORD (utf8const_type
);
798 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
800 atable_type
= build_array_type (ptr_type_node
,
801 one_elt_array_domain_type
);
802 TYPE_NONALIASED_COMPONENT (atable_type
) = 1;
803 atable_ptr_type
= build_pointer_type (atable_type
);
805 itable_type
= build_array_type (ptr_type_node
,
806 one_elt_array_domain_type
);
807 TYPE_NONALIASED_COMPONENT (itable_type
) = 1;
808 itable_ptr_type
= build_pointer_type (itable_type
);
810 symbol_type
= make_node (RECORD_TYPE
);
811 PUSH_FIELD (symbol_type
, field
, "clname", utf8const_ptr_type
);
812 PUSH_FIELD (symbol_type
, field
, "name", utf8const_ptr_type
);
813 PUSH_FIELD (symbol_type
, field
, "signature", utf8const_ptr_type
);
814 FINISH_RECORD (symbol_type
);
816 symbols_array_type
= build_array_type (symbol_type
,
817 one_elt_array_domain_type
);
818 symbols_array_ptr_type
= build_pointer_type (symbols_array_type
);
820 assertion_entry_type
= make_node (RECORD_TYPE
);
821 PUSH_FIELD (assertion_entry_type
, field
, "assertion_code", integer_type_node
);
822 PUSH_FIELD (assertion_entry_type
, field
, "op1", utf8const_ptr_type
);
823 PUSH_FIELD (assertion_entry_type
, field
, "op2", utf8const_ptr_type
);
824 FINISH_RECORD (assertion_entry_type
);
826 assertion_table_type
= build_array_type (assertion_entry_type
,
827 one_elt_array_domain_type
);
829 /* As you're adding items here, please update the code right after
830 this section, so that the filename containing the source code of
831 the pre-defined class gets registered correctly. */
832 unqualified_object_id_node
= get_identifier ("Object");
833 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
834 object_ptr_type_node
= promote_type (object_type_node
);
835 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
836 string_ptr_type_node
= promote_type (string_type_node
);
837 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
838 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
839 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
840 runtime_exception_type_node
=
841 lookup_class (get_identifier ("java.lang.RuntimeException"));
842 error_exception_type_node
=
843 lookup_class (get_identifier ("java.lang.Error"));
845 rawdata_ptr_type_node
846 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
848 add_predefined_file (get_identifier ("java/lang/Class.java"));
849 add_predefined_file (get_identifier ("java/lang/Error.java"));
850 add_predefined_file (get_identifier ("java/lang/Object.java"));
851 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
852 add_predefined_file (get_identifier ("java/lang/String.java"));
853 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
854 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
855 add_predefined_file (get_identifier ("java/lang/Exception.java"));
856 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
857 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
859 methodtable_type
= make_node (RECORD_TYPE
);
860 layout_type (methodtable_type
);
861 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
862 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
864 TYPE_identifier_node
= get_identifier ("TYPE");
865 init_identifier_node
= get_identifier ("<init>");
866 clinit_identifier_node
= get_identifier ("<clinit>");
867 finit_identifier_node
= get_identifier ("finit$");
868 instinit_identifier_node
= get_identifier ("instinit$");
869 void_signature_node
= get_identifier ("()V");
870 length_identifier_node
= get_identifier ("length");
871 finalize_identifier_node
= get_identifier ("finalize");
872 this_identifier_node
= get_identifier ("this");
873 super_identifier_node
= get_identifier ("super");
874 continue_identifier_node
= get_identifier ("continue");
875 access0_identifier_node
= get_identifier ("access$0");
876 classdollar_identifier_node
= get_identifier ("class$");
878 java_lang_cloneable_identifier_node
= get_identifier ("java.lang.Cloneable");
879 java_io_serializable_identifier_node
=
880 get_identifier ("java.io.Serializable");
882 /* for lack of a better place to put this stub call */
883 init_expr_processing();
885 constants_type_node
= make_node (RECORD_TYPE
);
886 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
887 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
888 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
889 FINISH_RECORD (constants_type_node
);
890 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
892 access_flags_type_node
= unsigned_short_type_node
;
894 dtable_type
= make_node (RECORD_TYPE
);
895 dtable_ptr_type
= build_pointer_type (dtable_type
);
897 otable_type
= build_array_type (integer_type_node
,
898 one_elt_array_domain_type
);
899 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
900 otable_ptr_type
= build_pointer_type (otable_type
);
902 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
903 DECL_FCONTEXT (field
) = object_type_node
;
904 TYPE_VFIELD (object_type_node
) = field
;
906 /* This isn't exactly true, but it is what we have in the source.
907 There is an unresolved issue here, which is whether the vtable
908 should be marked by the GC. */
909 if (! flag_hash_synchronization
)
910 PUSH_FIELD (object_type_node
, field
, "sync_info",
911 build_pointer_type (object_type_node
));
912 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
913 FIELD_PRIVATE (t
) = 1;
914 FINISH_RECORD (object_type_node
);
916 field_type_node
= make_node (RECORD_TYPE
);
917 field_ptr_type_node
= build_pointer_type (field_type_node
);
918 method_type_node
= make_node (RECORD_TYPE
);
919 method_ptr_type_node
= build_pointer_type (method_type_node
);
921 set_super_info (0, class_type_node
, object_type_node
, 0);
922 set_super_info (0, string_type_node
, object_type_node
, 0);
923 class_ptr_type
= build_pointer_type (class_type_node
);
925 PUSH_FIELD (class_type_node
, field
, "next_or_version", class_ptr_type
);
926 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
927 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
928 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
929 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
930 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
931 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
932 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
933 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
934 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
935 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
936 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
937 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
938 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
939 PUSH_FIELD (class_type_node
, field
, "otable_syms",
940 symbols_array_ptr_type
);
941 PUSH_FIELD (class_type_node
, field
, "atable", atable_ptr_type
);
942 PUSH_FIELD (class_type_node
, field
, "atable_syms",
943 symbols_array_ptr_type
);
944 PUSH_FIELD (class_type_node
, field
, "itable", itable_ptr_type
);
945 PUSH_FIELD (class_type_node
, field
, "itable_syms",
946 symbols_array_ptr_type
);
947 PUSH_FIELD (class_type_node
, field
, "catch_classes", ptr_type_node
);
948 PUSH_FIELD (class_type_node
, field
, "interfaces",
949 build_pointer_type (class_ptr_type
));
950 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
951 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
952 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
953 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
954 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
955 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
956 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
957 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
958 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
959 PUSH_FIELD (class_type_node
, field
, "assertion_table", ptr_type_node
);
960 PUSH_FIELD (class_type_node
, field
, "hack_signers", ptr_type_node
);
961 PUSH_FIELD (class_type_node
, field
, "chain", ptr_type_node
);
962 PUSH_FIELD (class_type_node
, field
, "aux_info", ptr_type_node
);
963 PUSH_FIELD (class_type_node
, field
, "engine", ptr_type_node
);
964 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
965 FIELD_PRIVATE (t
) = 1;
966 push_super_field (class_type_node
, object_type_node
);
968 FINISH_RECORD (class_type_node
);
969 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
971 field_info_union_node
= make_node (UNION_TYPE
);
972 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
973 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
975 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
977 layout_type (field_info_union_node
);
979 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
980 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
981 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
982 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
983 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
984 FINISH_RECORD (field_type_node
);
985 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
987 nativecode_ptr_array_type_node
988 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
990 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
991 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
992 FINISH_RECORD (dtable_type
);
993 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
995 jexception_type
= make_node (RECORD_TYPE
);
996 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
997 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
998 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
999 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
1000 FINISH_RECORD (jexception_type
);
1001 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
1002 jexception_ptr_type
= build_pointer_type (jexception_type
);
1004 lineNumberEntry_type
= make_node (RECORD_TYPE
);
1005 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
1006 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
1007 FINISH_RECORD (lineNumberEntry_type
);
1009 lineNumbers_type
= make_node (RECORD_TYPE
);
1010 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
1011 FINISH_RECORD (lineNumbers_type
);
1013 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
1014 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
1015 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
1016 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
1017 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
1018 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
1019 FINISH_RECORD (method_type_node
);
1020 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
1022 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
1024 t
= tree_cons (NULL_TREE
, class_ptr_type
, endlink
);
1025 alloc_object_node
= builtin_function ("_Jv_AllocObject",
1026 build_function_type (ptr_type_node
, t
),
1027 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1028 DECL_IS_MALLOC (alloc_object_node
) = 1;
1029 alloc_no_finalizer_node
=
1030 builtin_function ("_Jv_AllocObjectNoFinalizer",
1031 build_function_type (ptr_type_node
, t
),
1032 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1033 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
1035 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
1036 soft_initclass_node
= builtin_function ("_Jv_InitClass",
1037 build_function_type (void_type_node
,
1039 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1040 t
= tree_cons (NULL_TREE
, class_ptr_type
,
1041 tree_cons (NULL_TREE
, int_type_node
, endlink
));
1042 soft_resolvepoolentry_node
1043 = builtin_function ("_Jv_ResolvePoolEntry",
1044 build_function_type (ptr_type_node
, t
),
1045 0,NOT_BUILT_IN
, NULL
, NULL_TREE
);
1046 DECL_IS_PURE (soft_resolvepoolentry_node
) = 1;
1047 throw_node
= builtin_function ("_Jv_Throw",
1048 build_function_type (void_type_node
, t
),
1049 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1050 /* Mark throw_nodes as `noreturn' functions with side effects. */
1051 TREE_THIS_VOLATILE (throw_node
) = 1;
1052 TREE_SIDE_EFFECTS (throw_node
) = 1;
1054 t
= build_function_type (void_type_node
, tree_cons (NULL_TREE
, ptr_type_node
,
1056 soft_monitorenter_node
1057 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
1059 soft_monitorexit_node
1060 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
1063 t
= tree_cons (NULL_TREE
, ptr_type_node
,
1064 tree_cons (NULL_TREE
, int_type_node
, endlink
));
1066 = builtin_function ("_Jv_NewPrimArray",
1067 build_function_type (ptr_type_node
, t
),
1068 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1069 DECL_IS_MALLOC (soft_newarray_node
) = 1;
1071 t
= tree_cons (NULL_TREE
, int_type_node
,
1072 tree_cons (NULL_TREE
, class_ptr_type
,
1073 tree_cons (NULL_TREE
, object_ptr_type_node
,
1076 = builtin_function ("_Jv_NewObjectArray",
1077 build_function_type (ptr_type_node
, t
),
1078 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1079 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
1081 /* There is no endlink here because _Jv_NewMultiArray is a varargs
1083 t
= tree_cons (NULL_TREE
, ptr_type_node
,
1084 tree_cons (NULL_TREE
, int_type_node
, NULL_TREE
));
1085 soft_multianewarray_node
1086 = builtin_function ("_Jv_NewMultiArray",
1087 build_function_type (ptr_type_node
, t
),
1088 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1089 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
1091 t
= build_function_type (void_type_node
,
1092 tree_cons (NULL_TREE
, int_type_node
, endlink
));
1093 soft_badarrayindex_node
1094 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
1095 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1096 /* Mark soft_badarrayindex_node as a `noreturn' function with side
1098 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
1099 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
1101 soft_nullpointer_node
1102 = builtin_function ("_Jv_ThrowNullPointerException",
1103 build_function_type (void_type_node
, endlink
),
1104 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1105 /* Mark soft_nullpointer_node as a `noreturn' function with side
1107 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
1108 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
1110 soft_abstractmethod_node
1111 = builtin_function ("_Jv_ThrowAbstractMethodError",
1112 build_function_type (void_type_node
, endlink
),
1113 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1114 /* Mark soft_abstractmethod_node as a `noreturn' function with side
1116 TREE_THIS_VOLATILE (soft_abstractmethod_node
) = 1;
1117 TREE_SIDE_EFFECTS (soft_abstractmethod_node
) = 1;
1119 t
= tree_cons (NULL_TREE
, class_ptr_type
,
1120 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
1122 = builtin_function ("_Jv_CheckCast",
1123 build_function_type (ptr_type_node
, t
),
1124 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1125 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
1126 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
1127 soft_instanceof_node
1128 = builtin_function ("_Jv_IsInstanceOf",
1129 build_function_type (boolean_type_node
, t
),
1130 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1131 DECL_IS_PURE (soft_instanceof_node
) = 1;
1132 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
1133 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
1134 soft_checkarraystore_node
1135 = builtin_function ("_Jv_CheckArrayStore",
1136 build_function_type (void_type_node
, t
),
1137 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1138 t
= tree_cons (NULL_TREE
, ptr_type_node
,
1139 tree_cons (NULL_TREE
, ptr_type_node
,
1140 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
1141 soft_lookupinterfacemethod_node
1142 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
1143 build_function_type (ptr_type_node
, t
),
1144 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1145 DECL_IS_PURE (soft_lookupinterfacemethod_node
) = 1;
1146 t
= tree_cons (NULL_TREE
, ptr_type_node
,
1147 tree_cons (NULL_TREE
, ptr_type_node
,
1148 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
1149 soft_lookupinterfacemethodbyname_node
1150 = builtin_function ("_Jv_LookupInterfaceMethod",
1151 build_function_type (ptr_type_node
, t
),
1152 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1153 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
1154 tree_cons (NULL_TREE
, ptr_type_node
,
1155 tree_cons (NULL_TREE
, ptr_type_node
,
1156 tree_cons (NULL_TREE
, int_type_node
,
1158 soft_lookupjnimethod_node
1159 = builtin_function ("_Jv_LookupJNIMethod",
1160 build_function_type (ptr_type_node
, t
),
1161 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1162 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
1163 soft_getjnienvnewframe_node
1164 = builtin_function ("_Jv_GetJNIEnvNewFrame",
1165 build_function_type (ptr_type_node
, t
),
1166 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1167 soft_jnipopsystemframe_node
1168 = builtin_function ("_Jv_JNI_PopSystemFrame",
1169 build_function_type (void_type_node
, t
),
1170 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1172 t
= tree_cons (NULL_TREE
, int_type_node
,
1173 tree_cons (NULL_TREE
, int_type_node
, endlink
));
1175 = builtin_function ("_Jv_divI",
1176 build_function_type (int_type_node
, t
),
1177 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1180 = builtin_function ("_Jv_remI",
1181 build_function_type (int_type_node
, t
),
1182 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1184 t
= tree_cons (NULL_TREE
, long_type_node
,
1185 tree_cons (NULL_TREE
, long_type_node
, endlink
));
1187 = builtin_function ("_Jv_divJ",
1188 build_function_type (long_type_node
, t
),
1189 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1192 = builtin_function ("_Jv_remJ",
1193 build_function_type (long_type_node
, t
),
1194 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1196 /* Initialize variables for except.c. */
1197 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
1198 ? "__gcj_personality_sj0"
1199 : "__gcj_personality_v0");
1200 default_init_unwind_resume_libfunc ();
1202 lang_eh_runtime_type
= do_nothing
;
1206 initialize_builtins ();
1207 soft_fmod_node
= built_in_decls
[BUILT_IN_FMOD
];
1209 soft_fmodf_node
= built_in_decls
[BUILT_IN_FMODF
];
1216 /* Look up NAME in the current binding level and its superiors
1217 in the namespace of variables, functions and typedefs.
1218 Return a ..._DECL node of some kind representing its definition,
1219 or return 0 if it is undefined. */
1222 lookup_name (tree name
)
1225 if (current_binding_level
!= global_binding_level
1226 && IDENTIFIER_LOCAL_VALUE (name
))
1227 val
= IDENTIFIER_LOCAL_VALUE (name
);
1229 val
= IDENTIFIER_GLOBAL_VALUE (name
);
1233 /* Similar to `lookup_name' but look only at current binding level and
1234 the previous one if it's the parameter level. */
1237 lookup_name_current_level (tree name
)
1241 if (current_binding_level
== global_binding_level
)
1242 return IDENTIFIER_GLOBAL_VALUE (name
);
1244 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
1247 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
1248 if (DECL_NAME (t
) == name
)
1254 /* Use a binding level to record a labeled block declaration */
1257 push_labeled_block (tree lb
)
1259 tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
1260 struct binding_level
*b
= current_binding_level
;
1261 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1263 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1264 TREE_CHAIN (lb
) = b
->names
;
1266 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
1269 /* Pop the current binding level, reinstalling values for the previous
1273 pop_labeled_block (void)
1275 struct binding_level
*b
= current_binding_level
;
1276 tree label
= b
->names
;
1277 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
1280 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
1281 TREE_VALUE (b
->shadowed
);
1283 /* Pop the current level, and free the structure for reuse. */
1284 current_binding_level
= current_binding_level
->level_chain
;
1285 b
->level_chain
= free_binding_level
;
1286 free_binding_level
= b
;
1289 /* Record a decl-node X as belonging to the current lexical scope.
1290 Check for errors (such as an incompatible declaration for the same
1291 name already seen in the same scope).
1293 Returns either X or an old decl for the same name.
1294 If an old decl is returned, it may have been smashed
1295 to agree with what X says. */
1301 tree name
= DECL_NAME (x
);
1302 struct binding_level
*b
= current_binding_level
;
1304 if (TREE_CODE (x
) != TYPE_DECL
)
1305 DECL_CONTEXT (x
) = current_function_decl
;
1308 t
= lookup_name_current_level (name
);
1309 if (t
!= 0 && t
== error_mark_node
)
1310 /* error_mark_node is 0 for a while during initialization! */
1313 error ("%q+D used prior to declaration", x
);
1316 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1317 to point to the TYPE_DECL.
1318 Since Java does not have typedefs, a type can only have
1319 one (true) name, given by a class, interface, or builtin. */
1320 if (TREE_CODE (x
) == TYPE_DECL
1321 && TYPE_NAME (TREE_TYPE (x
)) == 0
1322 && TREE_TYPE (x
) != error_mark_node
)
1324 TYPE_NAME (TREE_TYPE (x
)) = x
;
1325 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1328 /* This name is new in its binding level.
1329 Install the new declaration and return it. */
1330 if (b
== global_binding_level
)
1332 /* Install a global value. */
1334 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1338 /* Here to install a non-global value. */
1339 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1340 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1343 /* Warn if shadowing an argument at the top level of the body. */
1344 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1345 /* This warning doesn't apply to the parms of a nested fcn. */
1346 && ! current_binding_level
->parm_flag
1347 /* Check that this is one level down from the parms. */
1348 && current_binding_level
->level_chain
->parm_flag
1349 /* Check that the decl being shadowed
1350 comes from the parm level, one level up. */
1351 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1353 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1354 pedwarn ("declaration of %qs shadows a parameter",
1355 IDENTIFIER_POINTER (name
));
1357 pedwarn ("declaration of %qs shadows a symbol from the parameter list",
1358 IDENTIFIER_POINTER (name
));
1361 /* Maybe warn if shadowing something else. */
1362 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1363 /* No shadow warnings for internally generated vars. */
1364 && DECL_SOURCE_LINE (x
) != 0
1365 /* No shadow warnings for vars made for inlining. */
1366 && ! DECL_FROM_INLINE (x
))
1368 const char *warnstring
= 0;
1370 if (TREE_CODE (x
) == PARM_DECL
1371 && current_binding_level
->level_chain
->parm_flag
)
1372 /* Don't warn about the parm names in function declarator
1373 within a function declarator.
1374 It would be nice to avoid warning in any function
1375 declarator in a declaration, as opposed to a definition,
1376 but there is no way to tell it's not a definition. */
1378 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1379 warnstring
= "declaration of %qs shadows a parameter";
1380 else if (oldlocal
!= 0)
1381 warnstring
= "declaration of %qs shadows previous local";
1382 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1383 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1384 warnstring
= "declaration of %qs shadows global declaration";
1387 warning (0, warnstring
, IDENTIFIER_POINTER (name
));
1391 /* If storing a local value, there may already be one (inherited).
1392 If so, record it for restoration when this binding level ends. */
1394 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1398 /* Put decls on list in reverse order.
1399 We will reverse them later if necessary. */
1400 TREE_CHAIN (x
) = b
->names
;
1407 pushdecl_force_head (tree x
)
1409 current_binding_level
->names
= x
;
1412 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1415 pushdecl_top_level (tree x
)
1418 struct binding_level
*b
= current_binding_level
;
1420 current_binding_level
= global_binding_level
;
1422 current_binding_level
= b
;
1426 /* Like pushdecl, only it places X in FUNCTION_BINDING_LEVEL, if appropriate. */
1429 pushdecl_function_level (tree x
)
1432 struct binding_level
*b
= current_binding_level
;
1434 current_binding_level
= function_binding_level
;
1436 current_binding_level
= b
;
1440 /* Nonzero if we are currently in the global binding level. */
1443 global_bindings_p (void)
1445 return current_binding_level
== global_binding_level
;
1448 /* Return the list of declarations of the current level.
1449 Note that this list is in reverse order unless/until
1450 you nreverse it; and when you do nreverse it, you must
1451 store the result back using `storedecls' or you will lose. */
1456 return current_binding_level
->names
;
1459 /* Create a new `struct binding_level'. */
1461 static struct binding_level
*
1462 make_binding_level (void)
1465 return ggc_alloc_cleared (sizeof (struct binding_level
));
1469 pushlevel (int unused ATTRIBUTE_UNUSED
)
1471 struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1474 /* If this is the top level of a function,
1475 just make sure that NAMED_LABELS is 0. */
1477 if (current_binding_level
== global_binding_level
)
1481 /* Reuse or create a struct for this binding level. */
1483 if (free_binding_level
)
1485 newlevel
= free_binding_level
;
1486 free_binding_level
= free_binding_level
->level_chain
;
1490 newlevel
= make_binding_level ();
1493 /* Add this level to the front of the chain (stack) of levels that
1496 *newlevel
= clear_binding_level
;
1497 newlevel
->level_chain
= current_binding_level
;
1498 current_binding_level
= newlevel
;
1499 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1500 newlevel
->binding_depth
= binding_depth
;
1502 fprintf (stderr
, "push %s level %p pc %d\n",
1503 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1506 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1509 /* Exit a binding level.
1510 Pop the level off, and restore the state of the identifier-decl mappings
1511 that were in effect when this level was entered.
1513 If KEEP is nonzero, this level had explicit declarations, so
1514 and create a "block" (a BLOCK node) for the level
1515 to record its declarations and subblocks for symbol table output.
1517 If FUNCTIONBODY is nonzero, this level is the body of a function,
1518 so create a block as if KEEP were set and also clear out all
1521 If REVERSE is nonzero, reverse the order of decls before putting
1522 them into the BLOCK. */
1525 poplevel (int keep
, int reverse
, int functionbody
)
1528 /* The chain of decls was accumulated in reverse order.
1529 Put it into forward order, just for cleanliness. */
1531 tree subblocks
= current_binding_level
->blocks
;
1536 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1539 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1540 fprintf (stderr
, "pop %s level %p pc %d (end pc %d)\n",
1541 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1542 current_binding_level
->end_pc
);
1544 fprintf (stderr
, "pop %s level %p pc %d\n",
1545 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1547 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1550 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1554 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1556 /* Get the decls in the order they were written.
1557 Usually current_binding_level->names is in reverse order.
1558 But parameter decls were previously put in forward order. */
1561 current_binding_level
->names
1562 = decls
= nreverse (current_binding_level
->names
);
1564 decls
= current_binding_level
->names
;
1566 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1567 if (TREE_CODE (decl
) == VAR_DECL
1568 && DECL_LANG_SPECIFIC (decl
) != NULL
1569 && DECL_LOCAL_SLOT_NUMBER (decl
))
1570 LOCAL_VAR_OUT_OF_SCOPE_P (decl
) = 1;
1572 /* If there were any declarations in that level,
1573 or if this level is a function body,
1574 create a BLOCK to record them for the life of this function. */
1577 if (keep
|| functionbody
)
1579 block
= make_node (BLOCK
);
1580 TREE_TYPE (block
) = void_type_node
;
1583 if (current_binding_level
->exception_range
)
1584 expand_end_java_handler (current_binding_level
->exception_range
);
1588 /* If any statements have been generated at this level, create a
1589 BIND_EXPR to hold them and copy the variables to it. This
1590 only applies to the bytecode compiler. */
1591 if (current_binding_level
->stmts
)
1594 tree
*var
= &BLOCK_VARS (block
);
1596 /* Copy decls from names list, ignoring labels. */
1599 tree next
= TREE_CHAIN (decl
);
1600 if (TREE_CODE (decl
) != LABEL_DECL
)
1603 var
= &TREE_CHAIN (decl
);
1609 bind
= build3 (BIND_EXPR
, TREE_TYPE (block
), BLOCK_VARS (block
),
1610 BLOCK_EXPR_BODY (block
), block
);
1611 BIND_EXPR_BODY (bind
) = current_binding_level
->stmts
;
1613 if (BIND_EXPR_BODY (bind
)
1614 && TREE_SIDE_EFFECTS (BIND_EXPR_BODY (bind
)))
1615 TREE_SIDE_EFFECTS (bind
) = 1;
1617 /* FIXME: gimplifier brain damage. */
1618 if (BIND_EXPR_BODY (bind
) == NULL
)
1619 BIND_EXPR_BODY (bind
) = build_java_empty_stmt ();
1621 current_binding_level
->stmts
= NULL
;
1625 BLOCK_VARS (block
) = decls
;
1627 BLOCK_SUBBLOCKS (block
) = subblocks
;
1630 /* In each subblock, record that this is its superior. */
1632 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1633 BLOCK_SUPERCONTEXT (link
) = block
;
1635 /* Clear out the meanings of the local variables of this level. */
1637 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1639 tree name
= DECL_NAME (link
);
1640 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1642 /* If the ident. was used or addressed via a local extern decl,
1643 don't forget that fact. */
1644 if (DECL_EXTERNAL (link
))
1646 if (TREE_USED (link
))
1647 TREE_USED (name
) = 1;
1648 if (TREE_ADDRESSABLE (link
))
1649 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1651 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1655 /* Restore all name-meanings of the outer levels
1656 that were shadowed by this level. */
1658 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1659 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1661 /* If the level being exited is the top level of a function,
1662 check over all the labels, and clear out the current
1663 (function local) meanings of their names. */
1667 /* If this is the top level block of a function,
1668 the vars are the function's parameters.
1669 Don't leave them in the BLOCK because they are
1670 found in the FUNCTION_DECL instead. */
1672 BLOCK_VARS (block
) = 0;
1674 /* Clear out the definitions of all label names,
1675 since their scopes end here,
1676 and add them to BLOCK_VARS. */
1679 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1681 tree label
= TREE_VALUE (link
);
1683 if (DECL_INITIAL (label
) == 0)
1685 error ("label %q+D used but not defined", label
);
1686 /* Avoid crashing later. */
1687 define_label (input_location
, DECL_NAME (label
));
1689 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1690 warning (0, "label %q+D defined but not used", label
);
1691 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1693 /* Put the labels into the "variables" of the
1694 top-level block, so debugger can see them. */
1695 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1696 BLOCK_VARS (block
) = label
;
1701 /* Pop the current level, and free the structure for reuse. */
1704 struct binding_level
*level
= current_binding_level
;
1705 current_binding_level
= current_binding_level
->level_chain
;
1707 level
->level_chain
= free_binding_level
;
1708 free_binding_level
= level
;
1711 /* Dispose of the block that we just made inside some higher level. */
1714 DECL_INITIAL (current_function_decl
) = block
;
1715 DECL_SAVED_TREE (current_function_decl
) = bind
;
1721 current_binding_level
->blocks
1722 = chainon (current_binding_level
->blocks
, block
);
1724 /* If we did not make a block for the level just exited,
1725 any blocks made for inner levels
1726 (since they cannot be recorded as subblocks in that level)
1727 must be carried forward so they will later become subblocks
1728 of something else. */
1730 current_binding_level
->blocks
1731 = chainon (current_binding_level
->blocks
, subblocks
);
1734 java_add_stmt (bind
);
1738 TREE_USED (block
) = 1;
1743 maybe_pushlevels (int pc
)
1745 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1749 while (pending_local_decls
!= NULL_TREE
&&
1750 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1752 tree
*ptr
= &pending_local_decls
;
1753 tree decl
= *ptr
, next
;
1754 int end_pc
= DECL_LOCAL_END_PC (decl
);
1756 while (*ptr
!= NULL_TREE
1757 && DECL_LOCAL_START_PC (*ptr
) <= pc
1758 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1759 ptr
= &TREE_CHAIN (*ptr
);
1760 pending_local_decls
= *ptr
;
1763 /* Force non-nested range to be nested in current range by
1764 truncating variable lifetimes. */
1765 if (end_pc
> current_binding_level
->end_pc
)
1767 end_pc
= current_binding_level
->end_pc
;
1768 DECL_LOCAL_END_PC (decl
) = end_pc
;
1771 maybe_start_try (pc
, end_pc
);
1775 current_binding_level
->end_pc
= end_pc
;
1776 current_binding_level
->start_pc
= pc
;
1777 current_binding_level
->names
= NULL
;
1778 for ( ; decl
!= NULL_TREE
; decl
= next
)
1780 next
= TREE_CHAIN (decl
);
1781 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1783 initialize_local_variable (decl
, DECL_LOCAL_SLOT_NUMBER (decl
));
1787 maybe_start_try (pc
, 0);
1791 maybe_poplevels (int pc
)
1793 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1797 /* FIXME: I'm pretty sure that this is wrong. Variable scopes are
1798 inclusive, so a variable is live if pc == end_pc. Here, we
1799 terminate a range if the current pc is equal to the end of the
1800 range, and this is *before* we have generated code for the
1801 instruction at end_pc. We're closing a binding level one
1802 instruction too early.*/
1803 while (current_binding_level
->end_pc
<= pc
)
1807 /* Terminate any binding which began during the range beginning at
1808 start_pc. This tidies up improperly nested local variable ranges
1809 and exception handlers; a variable declared within an exception
1810 range is forcibly terminated when that exception ends. */
1813 force_poplevels (int start_pc
)
1815 while (current_binding_level
->start_pc
> start_pc
)
1817 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1818 warning (0, "In %+D: overlapped variable and exception ranges at %d",
1819 current_function_decl
,
1820 current_binding_level
->start_pc
);
1825 /* Insert BLOCK at the end of the list of subblocks of the
1826 current binding level. This is used when a BIND_EXPR is expanded,
1827 to handle the BLOCK node inside the BIND_EXPR. */
1830 insert_block (tree block
)
1832 TREE_USED (block
) = 1;
1833 current_binding_level
->blocks
1834 = chainon (current_binding_level
->blocks
, block
);
1837 /* integrate_decl_tree calls this function. */
1840 java_dup_lang_specific_decl (tree node
)
1843 struct lang_decl
*x
;
1845 if (!DECL_LANG_SPECIFIC (node
))
1848 lang_decl_size
= sizeof (struct lang_decl
);
1849 x
= ggc_alloc (lang_decl_size
);
1850 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1851 DECL_LANG_SPECIFIC (node
) = x
;
1855 give_name_to_locals (JCF
*jcf
)
1857 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1858 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1860 pending_local_decls
= NULL_TREE
;
1864 n
= JCF_readu2 (jcf
);
1865 for (i
= 0; i
< n
; i
++)
1867 int start_pc
= JCF_readu2 (jcf
);
1868 int length
= JCF_readu2 (jcf
);
1869 int name_index
= JCF_readu2 (jcf
);
1870 int signature_index
= JCF_readu2 (jcf
);
1871 int slot
= JCF_readu2 (jcf
);
1872 tree name
= get_name_constant (jcf
, name_index
);
1873 tree type
= parse_signature (jcf
, signature_index
);
1874 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1876 && length
== DECL_CODE_LENGTH (current_function_decl
))
1878 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1879 DECL_NAME (decl
) = name
;
1880 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1881 warning (0, "bad type in parameter debug info");
1886 int end_pc
= start_pc
+ length
;
1887 tree decl
= build_decl (VAR_DECL
, name
, type
);
1888 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1890 warning (0, "bad PC range for debug info for local %q+D",
1892 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1895 /* Adjust start_pc if necessary so that the local's first
1896 store operation will use the relevant DECL as a
1897 destination. Fore more information, read the leading
1898 comments for expr.c:maybe_adjust_start_pc. */
1899 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1901 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1902 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1903 DECL_LOCAL_START_PC (decl
) = start_pc
;
1905 /* FIXME: The range used internally for exceptions and local
1906 variable ranges, is a half-open interval:
1907 start_pc <= pc < end_pc. However, the range used in the
1908 Java VM spec is inclusive at both ends:
1909 start_pc <= pc <= end_pc. */
1912 DECL_LOCAL_END_PC (decl
) = end_pc
;
1914 /* Now insert the new decl in the proper place in
1915 pending_local_decls. We are essentially doing an insertion sort,
1916 which works fine, since the list input will normally already
1918 ptr
= &pending_local_decls
;
1919 while (*ptr
!= NULL_TREE
1920 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1921 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1922 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1923 ptr
= &TREE_CHAIN (*ptr
);
1924 TREE_CHAIN (decl
) = *ptr
;
1929 pending_local_decls
= nreverse (pending_local_decls
);
1931 /* Fill in default names for the parameters. */
1932 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1933 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1935 if (DECL_NAME (parm
) == NULL_TREE
)
1937 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1939 DECL_NAME (parm
) = get_identifier ("this");
1943 sprintf (buffer
, "ARG_%d", arg_i
);
1944 DECL_NAME (parm
) = get_identifier (buffer
);
1951 build_result_decl (tree fndecl
)
1953 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1954 tree result
= DECL_RESULT (fndecl
);
1957 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1958 if (INTEGRAL_TYPE_P (restype
)
1959 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1960 restype
= integer_type_node
;
1961 result
= build_decl (RESULT_DECL
, NULL_TREE
, restype
);
1962 DECL_ARTIFICIAL (result
) = 1;
1963 DECL_IGNORED_P (result
) = 1;
1964 DECL_CONTEXT (result
) = fndecl
;
1965 DECL_RESULT (fndecl
) = result
;
1971 start_java_method (tree fndecl
)
1978 current_function_decl
= fndecl
;
1979 announce_function (fndecl
);
1981 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1982 decl_map
= make_tree_vec (i
);
1983 base_decl_map
= make_tree_vec (i
);
1984 type_map
= xrealloc (type_map
, i
* sizeof (tree
));
1986 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1987 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1989 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1990 pushlevel (1); /* Push parameters. */
1992 ptr
= &DECL_ARGUMENTS (fndecl
);
1993 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1994 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1996 tree parm_name
= NULL_TREE
, parm_decl
;
1997 tree parm_type
= TREE_VALUE (tem
);
1998 if (i
>= DECL_MAX_LOCALS (fndecl
))
2001 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
2002 DECL_CONTEXT (parm_decl
) = fndecl
;
2003 if (targetm
.calls
.promote_prototypes (parm_type
)
2004 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
2005 && INTEGRAL_TYPE_P (parm_type
))
2006 parm_type
= integer_type_node
;
2007 DECL_ARG_TYPE (parm_decl
) = parm_type
;
2010 ptr
= &TREE_CHAIN (parm_decl
);
2012 /* Add parm_decl to the decl_map. */
2013 push_jvm_slot (i
, parm_decl
);
2015 type_map
[i
] = TREE_TYPE (parm_decl
);
2016 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
2019 type_map
[i
] = void_type_node
;
2023 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
2025 while (i
< DECL_MAX_LOCALS(fndecl
))
2026 type_map
[i
++] = NULL_TREE
;
2028 build_result_decl (fndecl
);
2030 /* Push local variables. */
2033 function_binding_level
= current_binding_level
;
2037 end_java_method (void)
2039 tree fndecl
= current_function_decl
;
2041 /* pop out of function */
2044 /* pop out of its parameters */
2047 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
2049 if (DECL_SAVED_TREE (fndecl
))
2051 tree fbody
, block_body
;
2052 /* Before we check initialization, attached all class initialization
2053 variable to the block_body */
2054 fbody
= DECL_SAVED_TREE (fndecl
);
2055 block_body
= BIND_EXPR_BODY (fbody
);
2056 htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (fndecl
),
2057 attach_init_test_initialization_flags
, block_body
);
2060 flag_unit_at_a_time
= 0;
2061 finish_method (fndecl
);
2063 if (! flag_unit_at_a_time
)
2065 /* Nulling these fields when we no longer need them saves
2067 DECL_SAVED_TREE (fndecl
) = NULL
;
2068 DECL_STRUCT_FUNCTION (fndecl
) = NULL
;
2069 DECL_INITIAL (fndecl
) = NULL_TREE
;
2071 current_function_decl
= NULL_TREE
;
2074 /* Prepare a method for expansion. */
2077 finish_method (tree fndecl
)
2079 tree
*tp
= &DECL_SAVED_TREE (fndecl
);
2081 /* Wrap body of synchronized methods in a monitorenter,
2082 plus monitorexit cleanup. */
2083 if (METHOD_SYNCHRONIZED (fndecl
))
2085 tree enter
, exit
, lock
;
2086 if (METHOD_STATIC (fndecl
))
2087 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
2089 lock
= DECL_ARGUMENTS (fndecl
);
2090 BUILD_MONITOR_ENTER (enter
, lock
);
2091 BUILD_MONITOR_EXIT (exit
, lock
);
2092 *tp
= build2 (COMPOUND_EXPR
, void_type_node
, enter
,
2093 build2 (TRY_FINALLY_EXPR
, void_type_node
, *tp
, exit
));
2096 /* Prepend class initialization for static methods reachable from
2098 if (METHOD_STATIC (fndecl
)
2099 && (! METHOD_PRIVATE (fndecl
)
2100 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
2101 && ! DECL_CLINIT_P (fndecl
)
2102 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
2104 tree clas
= DECL_CONTEXT (fndecl
);
2105 tree init
= build3 (CALL_EXPR
, void_type_node
,
2106 build_address_of (soft_initclass_node
),
2107 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
2109 *tp
= build2 (COMPOUND_EXPR
, TREE_TYPE (*tp
), init
, *tp
);
2112 /* Convert function tree to GENERIC prior to inlining. */
2113 java_genericize (fndecl
);
2115 /* Store the end of the function, so that we get good line number
2116 info for the epilogue. */
2117 if (DECL_STRUCT_FUNCTION (fndecl
))
2118 cfun
= DECL_STRUCT_FUNCTION (fndecl
);
2120 allocate_struct_function (fndecl
);
2121 #ifdef USE_MAPPED_LOCATION
2122 cfun
->function_end_locus
= DECL_FUNCTION_LAST_LINE (fndecl
);
2124 cfun
->function_end_locus
.file
= DECL_SOURCE_FILE (fndecl
);
2125 cfun
->function_end_locus
.line
= DECL_FUNCTION_LAST_LINE (fndecl
);
2128 /* Defer inlining and expansion to the cgraph optimizers. */
2129 cgraph_finalize_function (fndecl
, false);
2132 /* Optimize and expand a function's entire body. */
2135 java_expand_body (tree fndecl
)
2137 tree_rest_of_compilation (fndecl
);
2140 /* We pessimistically marked all methods and fields external until we
2141 knew what set of classes we were planning to compile. Now mark those
2142 associated with CLASS to be generated locally as not external. */
2145 java_mark_decl_local (tree decl
)
2147 DECL_EXTERNAL (decl
) = 0;
2149 /* If we've already constructed DECL_RTL, give encode_section_info
2150 a second chance, now that we've changed the flags. */
2151 /* ??? Ideally, we'd have flag_unit_at_a_time set, and not have done
2152 anything that would have referenced DECL_RTL so far. But at the
2153 moment we force flag_unit_at_a_time off due to excessive memory
2154 consumption when compiling large jar files. Which probably means
2155 that we need to re-order how we process jar files... */
2156 if (DECL_RTL_SET_P (decl
))
2157 make_decl_rtl (decl
);
2160 /* Given appropriate target support, G++ will emit hidden aliases for native
2161 methods. Using this hidden name is required for proper operation of
2162 _Jv_Method::ncode, but it doesn't hurt to use it everywhere. Look for
2163 proper target support, then mark the method for aliasing. */
2166 java_mark_cni_decl_local (tree decl
)
2168 /* Setting DECL_LOCAL_CNI_METHOD_P changes the behavior of the mangler.
2169 We expect that we should not yet have referenced this decl in a
2170 context that requires it. Check this invariant even if we don't have
2171 support for hidden aliases. */
2172 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
2174 #if !defined(HAVE_GAS_HIDDEN) || !defined(ASM_OUTPUT_DEF)
2178 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
2179 DECL_LOCAL_CNI_METHOD_P (decl
) = 1;
2182 /* Use the preceding two functions and mark all members of the class. */
2185 java_mark_class_local (tree
class)
2189 for (t
= TYPE_FIELDS (class); t
; t
= TREE_CHAIN (t
))
2190 if (FIELD_STATIC (t
))
2191 java_mark_decl_local (t
);
2193 for (t
= TYPE_METHODS (class); t
; t
= TREE_CHAIN (t
))
2194 if (!METHOD_ABSTRACT (t
))
2196 if (METHOD_NATIVE (t
) && !flag_jni
)
2197 java_mark_cni_decl_local (t
);
2199 java_mark_decl_local (t
);
2203 /* Add a statement to a compound_expr. */
2206 add_stmt_to_compound (tree existing
, tree type
, tree stmt
)
2212 tree expr
= build2 (COMPOUND_EXPR
, type
, existing
, stmt
);
2213 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (existing
)
2214 | TREE_SIDE_EFFECTS (stmt
);
2221 /* Add a statement to the compound_expr currently being
2225 java_add_stmt (tree stmt
)
2228 SET_EXPR_LOCATION (stmt
, input_location
);
2230 return current_binding_level
->stmts
2231 = add_stmt_to_compound (current_binding_level
->stmts
,
2232 TREE_TYPE (stmt
), stmt
);
2235 /* Add a variable to the current scope. */
2238 java_add_local_var (tree decl
)
2240 tree
*vars
= ¤t_binding_level
->names
;
2242 TREE_CHAIN (decl
) = next
;
2244 DECL_CONTEXT (decl
) = current_function_decl
;
2245 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2249 /* Return a pointer to the compound_expr currently being
2255 return ¤t_binding_level
->stmts
;
2258 /* Register an exception range as belonging to the current binding
2259 level. There may only be one: if there are more, we'll create more
2260 binding levels. However, each range can have multiple handlers,
2261 and these are expanded when we call expand_end_java_handler(). */
2264 register_exception_range (struct eh_range
*range
, int pc
, int end_pc
)
2266 if (current_binding_level
->exception_range
)
2268 current_binding_level
->exception_range
= range
;
2269 current_binding_level
->end_pc
= end_pc
;
2270 current_binding_level
->start_pc
= pc
;
2273 #include "gt-java-decl.h"