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"
51 #include "tree-iterator.h"
53 #if defined (DEBUG_JAVA_BINDING_LEVELS)
54 extern void indent (void);
57 static tree
push_jvm_slot (int, tree
);
58 static tree
lookup_name_current_level (tree
);
59 static tree
push_promoted_type (const char *, tree
);
60 static struct binding_level
*make_binding_level (void);
61 static tree
create_primitive_vtable (const char *);
62 static tree
check_local_unnamed_variable (tree
, tree
, tree
);
63 static void parse_version (void);
66 /* The following ABI flags are used in the high-order bits of the version
67 ID field. The version ID number itself should never be larger than
68 0xfffff, so it should be safe to use top 12 bits for these flags. */
70 #define FLAG_BINARYCOMPAT_ABI (1<<31) /* Class is built with the BC-ABI. */
72 #define FLAG_BOOTSTRAP_LOADER (1<<30) /* Used when defining a class that
73 should be loaded by the bootstrap
76 /* If an ABI change is made within a GCC release series, rendering current
77 binaries incompatible with the old runtimes, this number can be set to
78 enforce the compatibility rules. */
79 #define MINOR_BINARYCOMPAT_ABI_VERSION 0
81 /* The runtime may recognize a variety of BC ABIs (objects generated by
82 different version of gcj), but will probably always require strict
83 matching for the ordinary (C++) ABI. */
85 /* The version ID of the BC ABI that we generate. This must be kept in
86 sync with parse_version(), libgcj, and reality (if the BC format changes,
88 #define GCJ_CURRENT_BC_ABI_VERSION \
89 (4 * 100000 + 0 * 1000 + MINOR_BINARYCOMPAT_ABI_VERSION)
91 /* The ABI version number. */
94 /* Name of the Cloneable class. */
95 tree java_lang_cloneable_identifier_node
;
97 /* Name of the Serializable class. */
98 tree java_io_serializable_identifier_node
;
100 /* The DECL_MAP is a mapping from (index, type) to a decl node.
101 If index < max_locals, it is the index of a local variable.
102 if index >= max_locals, then index-max_locals is a stack slot.
103 The DECL_MAP mapping is represented as a TREE_VEC whose elements
104 are a list of decls (VAR_DECL or PARM_DECL) chained by
105 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
106 we search the chain for a decl with a matching TREE_TYPE. */
108 static GTY(()) tree decl_map
;
110 /* The base_decl_map is contains one variable of ptr_type: this is
111 used to contain every variable of reference type that is ever
112 stored in a local variable slot. */
114 static GTY(()) tree base_decl_map
;
116 /* An index used to make temporary identifiers unique. */
119 /* A list of local variables VAR_DECLs for this method that we have seen
120 debug information, but we have not reached their starting (byte) PC yet. */
122 static GTY(()) tree pending_local_decls
;
124 /* The decl for "_Jv_ResolvePoolEntry". */
125 tree soft_resolvepoolentry_node
;
127 /* The decl for the .constants field of an instance of Class. */
128 tree constants_field_decl_node
;
130 /* The decl for the .data field of an instance of Class. */
131 tree constants_data_field_decl_node
;
133 #if defined(DEBUG_JAVA_BINDING_LEVELS)
134 int binding_depth
= 0;
135 int is_class_level
= 0;
143 for (i
= 0; i
< binding_depth
*2; i
++)
146 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
148 /* True if decl is a named local variable, i.e. if it is an alias
149 that's used only for debugging purposes. */
152 debug_variable_p (tree decl
)
154 if (TREE_CODE (decl
) == PARM_DECL
)
157 if (LOCAL_SLOT_P (decl
))
163 /* Copy the value in decl into every live alias in the same local
164 variable slot. Some of these will be dead stores removed by the
168 update_aliases (tree decl
, int index
, int pc
)
170 tree decl_type
= TREE_TYPE (decl
);
173 gcc_assert (! debug_variable_p (decl
));
175 for (tmp
= TREE_VEC_ELT (decl_map
, index
);
177 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
))
179 tree tmp_type
= TREE_TYPE (tmp
);
181 && LOCAL_SLOT_P (tmp
) == 0
183 || (pc
>= DECL_LOCAL_START_PC (tmp
)
184 && pc
< DECL_LOCAL_END_PC (tmp
)))
185 /* This test is < (rather than <=) because there's no point
186 updating an alias that's about to die at the end of this
188 && (tmp_type
== decl_type
189 || (INTEGRAL_TYPE_P (tmp_type
)
190 && INTEGRAL_TYPE_P (decl_type
)
191 && TYPE_PRECISION (decl_type
) <= 32
192 && TYPE_PRECISION (tmp_type
) <= 32)
193 || (TREE_CODE (tmp_type
) == POINTER_TYPE
194 && TREE_CODE (decl_type
) == POINTER_TYPE
)))
196 tree src
= build1 (NOP_EXPR
, tmp_type
, decl
);
197 gcc_assert (! LOCAL_VAR_OUT_OF_SCOPE_P (tmp
));
198 java_add_stmt (build2 (MODIFY_EXPR
, tmp_type
, tmp
, src
));
204 push_jvm_slot (int index
, tree decl
)
206 DECL_CONTEXT (decl
) = current_function_decl
;
207 layout_decl (decl
, 0);
209 /* Now link the decl into the decl_map. */
210 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
212 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
213 DECL_LOCAL_START_PC (decl
) = 0;
214 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
215 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
217 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
218 TREE_VEC_ELT (decl_map
, index
) = decl
;
223 /* At the point of its creation a local variable decl inherits
224 whatever is already in the same slot. In the case of a local
225 variable that is declared but unused, we won't find anything. */
228 initialize_local_variable (tree decl
, int index
)
230 tree decl_type
= TREE_TYPE (decl
);
231 if (TREE_CODE (decl_type
) == POINTER_TYPE
)
233 tree tmp
= TREE_VEC_ELT (base_decl_map
, index
);
237 /* At the point of its creation this decl inherits whatever
239 tree src
= build1 (NOP_EXPR
, decl_type
, tmp
);
240 java_add_stmt (build2 (MODIFY_EXPR
, decl_type
, decl
, src
));
247 for (tmp
= TREE_VEC_ELT (decl_map
, index
);
249 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
))
251 tree tmp_type
= TREE_TYPE (tmp
);
253 && ! debug_variable_p (tmp
)
254 && (tmp_type
== decl_type
255 || (INTEGRAL_TYPE_P (tmp_type
)
256 && INTEGRAL_TYPE_P (decl_type
)
257 && TYPE_PRECISION (decl_type
) <= 32
258 && TYPE_PRECISION (tmp_type
) <= 32
259 && TYPE_PRECISION (tmp_type
)
260 >= TYPE_PRECISION (decl_type
))))
262 java_add_stmt (build2 (MODIFY_EXPR
, decl_type
, decl
, tmp
));
269 /* Find the best declaration based upon type. If 'decl' fits 'type' better
270 than 'best', return 'decl'. Otherwise return 'best'. */
273 check_local_unnamed_variable (tree best
, tree decl
, tree type
)
275 tree decl_type
= TREE_TYPE (decl
);
277 gcc_assert (! LOCAL_VAR_OUT_OF_SCOPE_P (decl
));
279 /* Use the same decl for all integer types <= 32 bits. This is
280 necessary because sometimes a value is stored as (for example)
281 boolean but loaded as int. */
282 if (decl_type
== type
283 || (INTEGRAL_TYPE_P (decl_type
)
284 && INTEGRAL_TYPE_P (type
)
285 && TYPE_PRECISION (decl_type
) <= 32
286 && TYPE_PRECISION (type
) <= 32
287 && TYPE_PRECISION (decl_type
) >= TYPE_PRECISION (type
))
288 /* ptr_type_node is used for null pointers, which are
289 assignment compatible with everything. */
290 || (TREE_CODE (decl_type
) == POINTER_TYPE
291 && type
== ptr_type_node
)
292 /* Whenever anyone wants to use a slot that is initially
293 occupied by a PARM_DECL of pointer type they must get that
294 decl, even if they asked for a pointer to a different type.
295 However, if someone wants a scalar variable in a slot that
296 initially held a pointer arg -- or vice versa -- we create a
299 ???: As long as verification is correct, this will be a
300 compatible type. But maybe we should create a dummy variable
301 and replace all references to it with the DECL and a
304 || (TREE_CODE (decl_type
) == POINTER_TYPE
305 && TREE_CODE (decl
) == PARM_DECL
306 && TREE_CODE (type
) == POINTER_TYPE
))
308 if (best
== NULL_TREE
309 || (decl_type
== type
&& TREE_TYPE (best
) != type
))
317 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
318 that is valid at PC (or -1 if any pc).
319 If there is no existing matching decl, allocate one. */
322 find_local_variable (int index
, tree type
, int pc ATTRIBUTE_UNUSED
)
324 tree tmp
= TREE_VEC_ELT (decl_map
, index
);
325 tree decl
= NULL_TREE
;
327 /* Scan through every declaration that has been created in this
328 slot. We're only looking for variables that correspond to local
329 index declarations and PARM_DECLs, not named variables: such
330 local variables are used only for debugging information. */
331 while (tmp
!= NULL_TREE
)
333 if (! debug_variable_p (tmp
))
334 decl
= check_local_unnamed_variable (decl
, tmp
, type
);
335 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
338 /* gcj has a function called promote_type(), which is used by both
339 the bytecode compiler and the source compiler. Unfortunately,
340 the type systems for the Java VM and the Java language are not
341 the same: a boolean in the VM promotes to an int, not to a wide
342 boolean. If our caller wants something to hold a boolean, that
343 had better be an int, because that slot might be re-used
344 later in integer context. */
345 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
346 type
= integer_type_node
;
348 /* If we don't find a match, create one with the type passed in.
349 The name of the variable is #n#m, which n is the variable index
350 in the local variable area and m is a dummy identifier for
351 uniqueness -- multiple variables may share the same local
352 variable index. We don't call pushdecl() to push pointer types
353 into a binding expr because they'll all be replaced by a single
354 variable that is used for every reference in that local variable
360 sprintf (buf
, "#slot#%d#%d", index
, uniq
++);
361 name
= get_identifier (buf
);
362 decl
= build_decl (VAR_DECL
, name
, type
);
363 DECL_IGNORED_P (decl
) = 1;
364 DECL_ARTIFICIAL (decl
) = 1;
365 decl
= push_jvm_slot (index
, decl
);
366 LOCAL_SLOT_P (decl
) = 1;
368 if (TREE_CODE (type
) != POINTER_TYPE
)
369 pushdecl_function_level (decl
);
372 /* As well as creating a local variable that matches the type, we
373 also create a base variable (of ptr_type) that will hold all its
375 if (TREE_CODE (type
) == POINTER_TYPE
376 && ! TREE_VEC_ELT (base_decl_map
, index
))
381 sprintf (buf
, "#ref#%d#%d", index
, uniq
++);
382 name
= get_identifier (buf
);
384 = TREE_VEC_ELT (base_decl_map
, index
)
385 = build_decl (VAR_DECL
, name
, ptr_type_node
);
386 pushdecl_function_level (base_decl
);
387 DECL_IGNORED_P (base_decl
) = 1;
388 DECL_ARTIFICIAL (base_decl
) = 1;
394 /* Called during gimplification for every variable. If the variable
395 is a temporary of pointer type, replace it with a common variable
396 thath is used to hold all pointer types that are ever stored in
397 that slot. Set WANT_LVALUE if you want a variable that is to be
401 java_replace_reference (tree var_decl
, bool want_lvalue
)
408 decl_type
= TREE_TYPE (var_decl
);
410 if (TREE_CODE (decl_type
) == POINTER_TYPE
)
412 if (DECL_LANG_SPECIFIC (var_decl
)
413 && LOCAL_SLOT_P (var_decl
))
415 int index
= DECL_LOCAL_SLOT_NUMBER (var_decl
);
416 tree base_decl
= TREE_VEC_ELT (base_decl_map
, index
);
418 gcc_assert (base_decl
);
420 base_decl
= build1 (NOP_EXPR
, decl_type
, base_decl
);
430 /* Same as find_local_index, except that INDEX is a stack index. */
433 find_stack_slot (int index
, tree type
)
435 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
439 struct binding_level
GTY(())
441 /* A chain of _DECL nodes for all variables, constants, functions,
442 * and typedef types. These are in the reverse of the order supplied.
446 /* For each level, a list of shadowed outer-level local definitions
447 to be restored when this level is popped.
448 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
449 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
452 /* For each level (except not the global one),
453 a chain of BLOCK nodes for all the levels
454 that were entered and exited one level down. */
457 /* The binding level which this one is contained in (inherits from). */
458 struct binding_level
*level_chain
;
460 /* The bytecode PC that marks the end of this level. */
462 /* The bytecode PC that marks the start of this level. */
465 /* The statements in this binding level. */
468 /* An exception range associated with this binding level. */
469 struct eh_range
* GTY((skip (""))) exception_range
;
471 /* Binding depth at which this level began. Used only for debugging. */
472 unsigned binding_depth
;
475 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
477 /* The binding level currently in effect. */
479 static GTY(()) struct binding_level
*current_binding_level
;
481 /* A chain of binding_level structures awaiting reuse. */
483 static GTY(()) struct binding_level
*free_binding_level
;
485 /* The outermost binding level, for names of file scope.
486 This is created when the compiler is started and exists
487 through the entire run. */
489 static GTY(()) struct binding_level
*global_binding_level
;
491 /* The binding level that holds variables declared at the outermost
492 level within a function body. */
494 static struct binding_level
*function_binding_level
;
496 /* A PC value bigger than any PC value we may ever may encounter. */
498 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
500 /* Binding level structures are initialized by copying this one. */
502 static const struct binding_level clear_binding_level
504 NULL_TREE
, /* names */
505 NULL_TREE
, /* shadowed */
506 NULL_TREE
, /* blocks */
507 NULL_BINDING_LEVEL
, /* level_chain */
508 LARGEST_PC
, /* end_pc */
511 NULL
, /* exception_range */
512 0, /* binding_depth */
516 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
517 that have names. Here so we can clear out their names' definitions
518 at the end of the function. */
520 static tree named_labels
;
522 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
524 static tree shadowed_labels
;
527 tree java_global_trees
[JTI_MAX
];
529 /* Build (and pushdecl) a "promoted type" for all standard
530 types shorter than int. */
533 push_promoted_type (const char *name
, tree actual_type
)
535 tree type
= make_node (TREE_CODE (actual_type
));
537 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
538 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
540 tree in_min
= TYPE_MIN_VALUE (actual_type
);
541 tree in_max
= TYPE_MAX_VALUE (actual_type
);
543 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
544 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
545 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
546 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
547 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
548 TYPE_STRING_FLAG (type
) = TYPE_STRING_FLAG (actual_type
);
550 pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
554 /* Return a definition for a builtin function named NAME and whose data type
555 is TYPE. TYPE should be a function type with argument types.
556 FUNCTION_CODE tells later passes how to compile calls to this function.
557 See tree.h for its possible values.
559 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
560 the name to be called if we can't opencode the function. If
561 ATTRS is nonzero, use that for the function's attribute list. */
564 builtin_function (const char *name
,
567 enum built_in_class cl
,
568 const char *library_name
,
569 tree
ARG_UNUSED (attrs
))
571 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
572 DECL_EXTERNAL (decl
) = 1;
573 TREE_PUBLIC (decl
) = 1;
575 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
577 DECL_BUILT_IN_CLASS (decl
) = cl
;
578 DECL_FUNCTION_CODE (decl
) = function_code
;
582 /* Return tree that represents a vtable for a primitive array. */
584 create_primitive_vtable (const char *name
)
589 sprintf (buf
, "_Jv_%sVTable", name
);
590 r
= build_decl (VAR_DECL
, get_identifier (buf
), ptr_type_node
);
591 DECL_EXTERNAL (r
) = 1;
601 /* Parse the version string and compute the ABI version number. */
605 const char *p
= version_string
;
606 unsigned int major
= 0, minor
= 0;
607 unsigned int abi_version
;
609 /* Skip leading junk. */
610 while (*p
&& !ISDIGIT (*p
))
614 /* Extract major version. */
617 major
= major
* 10 + *p
- '0';
621 gcc_assert (*p
== '.' && ISDIGIT (p
[1]));
624 /* Extract minor version. */
627 minor
= minor
* 10 + *p
- '0';
631 if (flag_indirect_dispatch
)
633 abi_version
= GCJ_CURRENT_BC_ABI_VERSION
;
634 abi_version
|= FLAG_BINARYCOMPAT_ABI
;
638 /* Implicit in this computation is the idea that we won't break the
639 old-style binary ABI in a sub-minor release (e.g., from 4.0.0 to
641 abi_version
= 100000 * major
+ 1000 * minor
;
643 if (flag_bootstrap_classes
)
644 abi_version
|= FLAG_BOOTSTRAP_LOADER
;
646 gcj_abi_version
= build_int_cstu (ptr_type_node
, abi_version
);
650 java_init_decl_processing (void)
653 tree field
= NULL_TREE
;
656 init_class_processing ();
658 current_function_decl
= NULL
;
659 current_binding_level
= NULL_BINDING_LEVEL
;
660 free_binding_level
= NULL_BINDING_LEVEL
;
661 pushlevel (0); /* make the binding_level structure for global names */
662 global_binding_level
= current_binding_level
;
664 /* The code here must be similar to build_common_tree_nodes{,_2} in
665 tree.c, especially as to the order of initializing common nodes. */
666 error_mark_node
= make_node (ERROR_MARK
);
667 TREE_TYPE (error_mark_node
) = error_mark_node
;
669 /* Create sizetype first - needed for other types. */
670 initialize_sizetypes (false);
672 byte_type_node
= make_signed_type (8);
673 pushdecl (build_decl (TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
674 short_type_node
= make_signed_type (16);
675 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short"), short_type_node
));
676 int_type_node
= make_signed_type (32);
677 pushdecl (build_decl (TYPE_DECL
, get_identifier ("int"), int_type_node
));
678 long_type_node
= make_signed_type (64);
679 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long"), long_type_node
));
681 unsigned_byte_type_node
= make_unsigned_type (8);
682 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned byte"),
683 unsigned_byte_type_node
));
684 unsigned_short_type_node
= make_unsigned_type (16);
685 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned short"),
686 unsigned_short_type_node
));
687 unsigned_int_type_node
= make_unsigned_type (32);
688 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
689 unsigned_int_type_node
));
690 unsigned_long_type_node
= make_unsigned_type (64);
691 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned long"),
692 unsigned_long_type_node
));
694 /* This is not a java type, however tree-dfa requires a definition for
696 size_type_node
= make_unsigned_type (POINTER_SIZE
);
697 set_sizetype (size_type_node
);
699 /* Define these next since types below may used them. */
700 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
701 integer_zero_node
= build_int_cst (NULL_TREE
, 0);
702 integer_one_node
= build_int_cst (NULL_TREE
, 1);
703 integer_two_node
= build_int_cst (NULL_TREE
, 2);
704 integer_four_node
= build_int_cst (NULL_TREE
, 4);
705 integer_minus_one_node
= build_int_cst (NULL_TREE
, -1);
707 /* A few values used for range checking in the lexer. */
708 decimal_int_max
= build_int_cstu (unsigned_int_type_node
, 0x80000000);
709 #if HOST_BITS_PER_WIDE_INT == 64
710 decimal_long_max
= build_int_cstu (unsigned_long_type_node
,
711 0x8000000000000000LL
);
712 #elif HOST_BITS_PER_WIDE_INT == 32
713 decimal_long_max
= build_int_cst_wide (unsigned_long_type_node
,
716 #error "unsupported size"
719 size_zero_node
= size_int (0);
720 size_one_node
= size_int (1);
721 bitsize_zero_node
= bitsize_int (0);
722 bitsize_one_node
= bitsize_int (1);
723 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
725 long_zero_node
= build_int_cst (long_type_node
, 0);
727 void_type_node
= make_node (VOID_TYPE
);
728 pushdecl (build_decl (TYPE_DECL
, get_identifier ("void"), void_type_node
));
729 layout_type (void_type_node
); /* Uses size_zero_node */
731 ptr_type_node
= build_pointer_type (void_type_node
);
733 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
735 t
= make_node (VOID_TYPE
);
736 layout_type (t
); /* Uses size_zero_node */
737 return_address_type_node
= build_pointer_type (t
);
739 null_pointer_node
= build_int_cst (ptr_type_node
, 0);
742 /* Make a type to be the domain of a few array types
743 whose domains don't really matter.
744 200 is small enough that it always fits in size_t
745 and large enough that it can hold most function names for the
746 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
747 short_array_type_node
= build_prim_array_type (short_type_node
, 200);
749 char_type_node
= make_node (INTEGER_TYPE
);
750 TYPE_STRING_FLAG (char_type_node
) = 1;
751 TYPE_PRECISION (char_type_node
) = 16;
752 fixup_unsigned_type (char_type_node
);
753 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"), char_type_node
));
755 boolean_type_node
= make_node (BOOLEAN_TYPE
);
756 TYPE_PRECISION (boolean_type_node
) = 1;
757 fixup_unsigned_type (boolean_type_node
);
758 pushdecl (build_decl (TYPE_DECL
, get_identifier ("boolean"),
760 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
761 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
763 promoted_byte_type_node
764 = push_promoted_type ("promoted_byte", byte_type_node
);
765 promoted_short_type_node
766 = push_promoted_type ("promoted_short", short_type_node
);
767 promoted_char_type_node
768 = push_promoted_type ("promoted_char", char_type_node
);
769 promoted_boolean_type_node
770 = push_promoted_type ("promoted_boolean", boolean_type_node
);
772 float_type_node
= make_node (REAL_TYPE
);
773 TYPE_PRECISION (float_type_node
) = 32;
774 pushdecl (build_decl (TYPE_DECL
, get_identifier ("float"),
776 layout_type (float_type_node
);
778 double_type_node
= make_node (REAL_TYPE
);
779 TYPE_PRECISION (double_type_node
) = 64;
780 pushdecl (build_decl (TYPE_DECL
, get_identifier ("double"),
782 layout_type (double_type_node
);
784 float_zero_node
= build_real (float_type_node
, dconst0
);
785 double_zero_node
= build_real (double_type_node
, dconst0
);
787 /* These are the vtables for arrays of primitives. */
788 boolean_array_vtable
= create_primitive_vtable ("boolean");
789 byte_array_vtable
= create_primitive_vtable ("byte");
790 char_array_vtable
= create_primitive_vtable ("char");
791 short_array_vtable
= create_primitive_vtable ("short");
792 int_array_vtable
= create_primitive_vtable ("int");
793 long_array_vtable
= create_primitive_vtable ("long");
794 float_array_vtable
= create_primitive_vtable ("float");
795 double_array_vtable
= create_primitive_vtable ("double");
797 one_elt_array_domain_type
= build_index_type (integer_one_node
);
798 utf8const_type
= make_node (RECORD_TYPE
);
799 PUSH_FIELD (utf8const_type
, field
, "hash", unsigned_short_type_node
);
800 PUSH_FIELD (utf8const_type
, field
, "length", unsigned_short_type_node
);
801 FINISH_RECORD (utf8const_type
);
802 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
804 atable_type
= build_array_type (ptr_type_node
,
805 one_elt_array_domain_type
);
806 TYPE_NONALIASED_COMPONENT (atable_type
) = 1;
807 atable_ptr_type
= build_pointer_type (atable_type
);
809 itable_type
= build_array_type (ptr_type_node
,
810 one_elt_array_domain_type
);
811 TYPE_NONALIASED_COMPONENT (itable_type
) = 1;
812 itable_ptr_type
= build_pointer_type (itable_type
);
814 symbol_type
= make_node (RECORD_TYPE
);
815 PUSH_FIELD (symbol_type
, field
, "clname", utf8const_ptr_type
);
816 PUSH_FIELD (symbol_type
, field
, "name", utf8const_ptr_type
);
817 PUSH_FIELD (symbol_type
, field
, "signature", utf8const_ptr_type
);
818 FINISH_RECORD (symbol_type
);
820 symbols_array_type
= build_array_type (symbol_type
,
821 one_elt_array_domain_type
);
822 symbols_array_ptr_type
= build_pointer_type (symbols_array_type
);
824 assertion_entry_type
= make_node (RECORD_TYPE
);
825 PUSH_FIELD (assertion_entry_type
, field
, "assertion_code", integer_type_node
);
826 PUSH_FIELD (assertion_entry_type
, field
, "op1", utf8const_ptr_type
);
827 PUSH_FIELD (assertion_entry_type
, field
, "op2", utf8const_ptr_type
);
828 FINISH_RECORD (assertion_entry_type
);
830 assertion_table_type
= build_array_type (assertion_entry_type
,
831 one_elt_array_domain_type
);
833 /* As you're adding items here, please update the code right after
834 this section, so that the filename containing the source code of
835 the pre-defined class gets registered correctly. */
836 unqualified_object_id_node
= get_identifier ("Object");
837 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
838 object_ptr_type_node
= promote_type (object_type_node
);
839 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
840 string_ptr_type_node
= promote_type (string_type_node
);
841 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
842 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
843 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
844 runtime_exception_type_node
=
845 lookup_class (get_identifier ("java.lang.RuntimeException"));
846 error_exception_type_node
=
847 lookup_class (get_identifier ("java.lang.Error"));
849 rawdata_ptr_type_node
850 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
852 add_predefined_file (get_identifier ("java/lang/Class.java"));
853 add_predefined_file (get_identifier ("java/lang/Error.java"));
854 add_predefined_file (get_identifier ("java/lang/Object.java"));
855 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
856 add_predefined_file (get_identifier ("java/lang/String.java"));
857 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
858 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
859 add_predefined_file (get_identifier ("java/lang/Exception.java"));
860 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
861 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
863 methodtable_type
= make_node (RECORD_TYPE
);
864 layout_type (methodtable_type
);
865 build_decl (TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
866 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
868 TYPE_identifier_node
= get_identifier ("TYPE");
869 init_identifier_node
= get_identifier ("<init>");
870 clinit_identifier_node
= get_identifier ("<clinit>");
871 finit_identifier_node
= get_identifier ("finit$");
872 instinit_identifier_node
= get_identifier ("instinit$");
873 void_signature_node
= get_identifier ("()V");
874 length_identifier_node
= get_identifier ("length");
875 finalize_identifier_node
= get_identifier ("finalize");
876 this_identifier_node
= get_identifier ("this");
877 super_identifier_node
= get_identifier ("super");
878 continue_identifier_node
= get_identifier ("continue");
879 access0_identifier_node
= get_identifier ("access$0");
880 classdollar_identifier_node
= get_identifier ("class$");
882 java_lang_cloneable_identifier_node
= get_identifier ("java.lang.Cloneable");
883 java_io_serializable_identifier_node
=
884 get_identifier ("java.io.Serializable");
886 /* for lack of a better place to put this stub call */
887 init_expr_processing();
889 constants_type_node
= make_node (RECORD_TYPE
);
890 PUSH_FIELD (constants_type_node
, field
, "size", unsigned_int_type_node
);
891 PUSH_FIELD (constants_type_node
, field
, "tags", ptr_type_node
);
892 PUSH_FIELD (constants_type_node
, field
, "data", ptr_type_node
);
893 constants_data_field_decl_node
= field
;
894 FINISH_RECORD (constants_type_node
);
895 build_decl (TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
897 access_flags_type_node
= unsigned_short_type_node
;
899 dtable_type
= make_node (RECORD_TYPE
);
900 dtable_ptr_type
= build_pointer_type (dtable_type
);
902 otable_type
= build_array_type (integer_type_node
,
903 one_elt_array_domain_type
);
904 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
905 otable_ptr_type
= build_pointer_type (otable_type
);
907 PUSH_FIELD (object_type_node
, field
, "vtable", dtable_ptr_type
);
908 DECL_FCONTEXT (field
) = object_type_node
;
909 TYPE_VFIELD (object_type_node
) = field
;
911 /* This isn't exactly true, but it is what we have in the source.
912 There is an unresolved issue here, which is whether the vtable
913 should be marked by the GC. */
914 if (! flag_hash_synchronization
)
915 PUSH_FIELD (object_type_node
, field
, "sync_info",
916 build_pointer_type (object_type_node
));
917 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
918 FIELD_PRIVATE (t
) = 1;
919 FINISH_RECORD (object_type_node
);
921 field_type_node
= make_node (RECORD_TYPE
);
922 field_ptr_type_node
= build_pointer_type (field_type_node
);
923 method_type_node
= make_node (RECORD_TYPE
);
924 method_ptr_type_node
= build_pointer_type (method_type_node
);
926 set_super_info (0, class_type_node
, object_type_node
, 0);
927 set_super_info (0, string_type_node
, object_type_node
, 0);
928 class_ptr_type
= build_pointer_type (class_type_node
);
930 PUSH_FIELD (class_type_node
, field
, "next_or_version", class_ptr_type
);
931 PUSH_FIELD (class_type_node
, field
, "name", utf8const_ptr_type
);
932 PUSH_FIELD (class_type_node
, field
, "accflags", access_flags_type_node
);
933 PUSH_FIELD (class_type_node
, field
, "superclass", class_ptr_type
);
934 PUSH_FIELD (class_type_node
, field
, "constants", constants_type_node
);
935 constants_field_decl_node
= field
;
936 PUSH_FIELD (class_type_node
, field
, "methods", method_ptr_type_node
);
937 PUSH_FIELD (class_type_node
, field
, "method_count", short_type_node
);
938 PUSH_FIELD (class_type_node
, field
, "vtable_method_count", short_type_node
);
939 PUSH_FIELD (class_type_node
, field
, "fields", field_ptr_type_node
);
940 PUSH_FIELD (class_type_node
, field
, "size_in_bytes", int_type_node
);
941 PUSH_FIELD (class_type_node
, field
, "field_count", short_type_node
);
942 PUSH_FIELD (class_type_node
, field
, "static_field_count", short_type_node
);
943 PUSH_FIELD (class_type_node
, field
, "vtable", dtable_ptr_type
);
944 PUSH_FIELD (class_type_node
, field
, "otable", otable_ptr_type
);
945 PUSH_FIELD (class_type_node
, field
, "otable_syms",
946 symbols_array_ptr_type
);
947 PUSH_FIELD (class_type_node
, field
, "atable", atable_ptr_type
);
948 PUSH_FIELD (class_type_node
, field
, "atable_syms",
949 symbols_array_ptr_type
);
950 PUSH_FIELD (class_type_node
, field
, "itable", itable_ptr_type
);
951 PUSH_FIELD (class_type_node
, field
, "itable_syms",
952 symbols_array_ptr_type
);
953 PUSH_FIELD (class_type_node
, field
, "catch_classes", ptr_type_node
);
954 PUSH_FIELD (class_type_node
, field
, "interfaces",
955 build_pointer_type (class_ptr_type
));
956 PUSH_FIELD (class_type_node
, field
, "loader", ptr_type_node
);
957 PUSH_FIELD (class_type_node
, field
, "interface_count", short_type_node
);
958 PUSH_FIELD (class_type_node
, field
, "state", byte_type_node
);
959 PUSH_FIELD (class_type_node
, field
, "thread", ptr_type_node
);
960 PUSH_FIELD (class_type_node
, field
, "depth", short_type_node
);
961 PUSH_FIELD (class_type_node
, field
, "ancestors", ptr_type_node
);
962 PUSH_FIELD (class_type_node
, field
, "idt", ptr_type_node
);
963 PUSH_FIELD (class_type_node
, field
, "arrayclass", ptr_type_node
);
964 PUSH_FIELD (class_type_node
, field
, "protectionDomain", ptr_type_node
);
965 PUSH_FIELD (class_type_node
, field
, "assertion_table", ptr_type_node
);
966 PUSH_FIELD (class_type_node
, field
, "hack_signers", ptr_type_node
);
967 PUSH_FIELD (class_type_node
, field
, "chain", ptr_type_node
);
968 PUSH_FIELD (class_type_node
, field
, "aux_info", ptr_type_node
);
969 PUSH_FIELD (class_type_node
, field
, "engine", ptr_type_node
);
970 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
971 FIELD_PRIVATE (t
) = 1;
972 push_super_field (class_type_node
, object_type_node
);
974 FINISH_RECORD (class_type_node
);
975 build_decl (TYPE_DECL
, get_identifier ("Class"), class_type_node
);
977 field_info_union_node
= make_node (UNION_TYPE
);
978 PUSH_FIELD (field_info_union_node
, field
, "boffset", int_type_node
);
979 PUSH_FIELD (field_info_union_node
, field
, "addr", ptr_type_node
);
981 PUSH_FIELD (field_info_union_node
, field
, "idx", unsigned_short_type_node
);
983 layout_type (field_info_union_node
);
985 PUSH_FIELD (field_type_node
, field
, "name", utf8const_ptr_type
);
986 PUSH_FIELD (field_type_node
, field
, "type", class_ptr_type
);
987 PUSH_FIELD (field_type_node
, field
, "accflags", access_flags_type_node
);
988 PUSH_FIELD (field_type_node
, field
, "bsize", unsigned_short_type_node
);
989 PUSH_FIELD (field_type_node
, field
, "info", field_info_union_node
);
990 FINISH_RECORD (field_type_node
);
991 build_decl (TYPE_DECL
, get_identifier ("Field"), field_type_node
);
993 nativecode_ptr_array_type_node
994 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
996 PUSH_FIELD (dtable_type
, field
, "class", class_ptr_type
);
997 PUSH_FIELD (dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
998 FINISH_RECORD (dtable_type
);
999 build_decl (TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
1001 jexception_type
= make_node (RECORD_TYPE
);
1002 PUSH_FIELD (jexception_type
, field
, "start_pc", ptr_type_node
);
1003 PUSH_FIELD (jexception_type
, field
, "end_pc", ptr_type_node
);
1004 PUSH_FIELD (jexception_type
, field
, "handler_pc", ptr_type_node
);
1005 PUSH_FIELD (jexception_type
, field
, "catch_type", class_ptr_type
);
1006 FINISH_RECORD (jexception_type
);
1007 build_decl (TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
1008 jexception_ptr_type
= build_pointer_type (jexception_type
);
1010 lineNumberEntry_type
= make_node (RECORD_TYPE
);
1011 PUSH_FIELD (lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
1012 PUSH_FIELD (lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
1013 FINISH_RECORD (lineNumberEntry_type
);
1015 lineNumbers_type
= make_node (RECORD_TYPE
);
1016 PUSH_FIELD (lineNumbers_type
, field
, "length", unsigned_int_type_node
);
1017 FINISH_RECORD (lineNumbers_type
);
1019 PUSH_FIELD (method_type_node
, field
, "name", utf8const_ptr_type
);
1020 PUSH_FIELD (method_type_node
, field
, "signature", utf8const_ptr_type
);
1021 PUSH_FIELD (method_type_node
, field
, "accflags", access_flags_type_node
);
1022 PUSH_FIELD (method_type_node
, field
, "index", unsigned_short_type_node
);
1023 PUSH_FIELD (method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
1024 PUSH_FIELD (method_type_node
, field
, "throws", ptr_type_node
);
1025 FINISH_RECORD (method_type_node
);
1026 build_decl (TYPE_DECL
, get_identifier ("Method"), method_type_node
);
1028 endlink
= end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
1030 t
= tree_cons (NULL_TREE
, class_ptr_type
, endlink
);
1031 alloc_object_node
= builtin_function ("_Jv_AllocObject",
1032 build_function_type (ptr_type_node
, t
),
1033 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1034 DECL_IS_MALLOC (alloc_object_node
) = 1;
1035 alloc_no_finalizer_node
=
1036 builtin_function ("_Jv_AllocObjectNoFinalizer",
1037 build_function_type (ptr_type_node
, t
),
1038 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1039 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
1041 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
1042 soft_initclass_node
= builtin_function ("_Jv_InitClass",
1043 build_function_type (void_type_node
,
1045 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1046 t
= tree_cons (NULL_TREE
, class_ptr_type
,
1047 tree_cons (NULL_TREE
, int_type_node
, endlink
));
1048 soft_resolvepoolentry_node
1049 = builtin_function ("_Jv_ResolvePoolEntry",
1050 build_function_type (ptr_type_node
, t
),
1051 0,NOT_BUILT_IN
, NULL
, NULL_TREE
);
1052 DECL_IS_PURE (soft_resolvepoolentry_node
) = 1;
1053 throw_node
= builtin_function ("_Jv_Throw",
1054 build_function_type (void_type_node
, t
),
1055 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1056 /* Mark throw_nodes as `noreturn' functions with side effects. */
1057 TREE_THIS_VOLATILE (throw_node
) = 1;
1058 TREE_SIDE_EFFECTS (throw_node
) = 1;
1060 t
= build_function_type (void_type_node
, tree_cons (NULL_TREE
, ptr_type_node
,
1062 soft_monitorenter_node
1063 = builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
1065 soft_monitorexit_node
1066 = builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
1069 t
= tree_cons (NULL_TREE
, ptr_type_node
,
1070 tree_cons (NULL_TREE
, int_type_node
, endlink
));
1072 = builtin_function ("_Jv_NewPrimArray",
1073 build_function_type (ptr_type_node
, t
),
1074 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1075 DECL_IS_MALLOC (soft_newarray_node
) = 1;
1077 t
= tree_cons (NULL_TREE
, int_type_node
,
1078 tree_cons (NULL_TREE
, class_ptr_type
,
1079 tree_cons (NULL_TREE
, object_ptr_type_node
,
1082 = builtin_function ("_Jv_NewObjectArray",
1083 build_function_type (ptr_type_node
, t
),
1084 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1085 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
1087 /* There is no endlink here because _Jv_NewMultiArray is a varargs
1089 t
= tree_cons (NULL_TREE
, ptr_type_node
,
1090 tree_cons (NULL_TREE
, int_type_node
, NULL_TREE
));
1091 soft_multianewarray_node
1092 = builtin_function ("_Jv_NewMultiArray",
1093 build_function_type (ptr_type_node
, t
),
1094 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1095 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
1097 t
= build_function_type (void_type_node
,
1098 tree_cons (NULL_TREE
, int_type_node
, endlink
));
1099 soft_badarrayindex_node
1100 = builtin_function ("_Jv_ThrowBadArrayIndex", t
,
1101 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1102 /* Mark soft_badarrayindex_node as a `noreturn' function with side
1104 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
1105 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
1107 soft_nullpointer_node
1108 = builtin_function ("_Jv_ThrowNullPointerException",
1109 build_function_type (void_type_node
, endlink
),
1110 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1111 /* Mark soft_nullpointer_node as a `noreturn' function with side
1113 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
1114 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
1116 soft_abstractmethod_node
1117 = builtin_function ("_Jv_ThrowAbstractMethodError",
1118 build_function_type (void_type_node
, endlink
),
1119 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1120 /* Mark soft_abstractmethod_node as a `noreturn' function with side
1122 TREE_THIS_VOLATILE (soft_abstractmethod_node
) = 1;
1123 TREE_SIDE_EFFECTS (soft_abstractmethod_node
) = 1;
1125 soft_nosuchfield_node
1126 = builtin_function ("_Jv_ThrowNoSuchFieldError",
1127 build_function_type (void_type_node
, endlink
),
1128 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1129 /* Mark soft_nosuchfield_node as a `noreturn' function with side
1131 TREE_THIS_VOLATILE (soft_nosuchfield_node
) = 1;
1132 TREE_SIDE_EFFECTS (soft_nosuchfield_node
) = 1;
1134 t
= tree_cons (NULL_TREE
, class_ptr_type
,
1135 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
1137 = builtin_function ("_Jv_CheckCast",
1138 build_function_type (ptr_type_node
, t
),
1139 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1140 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
1141 tree_cons (NULL_TREE
, class_ptr_type
, endlink
));
1142 soft_instanceof_node
1143 = builtin_function ("_Jv_IsInstanceOf",
1144 build_function_type (boolean_type_node
, t
),
1145 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1146 DECL_IS_PURE (soft_instanceof_node
) = 1;
1147 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
1148 tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
));
1149 soft_checkarraystore_node
1150 = builtin_function ("_Jv_CheckArrayStore",
1151 build_function_type (void_type_node
, t
),
1152 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1153 t
= tree_cons (NULL_TREE
, ptr_type_node
,
1154 tree_cons (NULL_TREE
, ptr_type_node
,
1155 tree_cons (NULL_TREE
, int_type_node
, endlink
)));
1156 soft_lookupinterfacemethod_node
1157 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
1158 build_function_type (ptr_type_node
, t
),
1159 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1160 DECL_IS_PURE (soft_lookupinterfacemethod_node
) = 1;
1161 t
= tree_cons (NULL_TREE
, ptr_type_node
,
1162 tree_cons (NULL_TREE
, ptr_type_node
,
1163 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
1164 soft_lookupinterfacemethodbyname_node
1165 = builtin_function ("_Jv_LookupInterfaceMethod",
1166 build_function_type (ptr_type_node
, t
),
1167 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1168 t
= tree_cons (NULL_TREE
, object_ptr_type_node
,
1169 tree_cons (NULL_TREE
, ptr_type_node
,
1170 tree_cons (NULL_TREE
, ptr_type_node
,
1171 tree_cons (NULL_TREE
, int_type_node
,
1173 soft_lookupjnimethod_node
1174 = builtin_function ("_Jv_LookupJNIMethod",
1175 build_function_type (ptr_type_node
, t
),
1176 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1177 t
= tree_cons (NULL_TREE
, ptr_type_node
, endlink
);
1178 soft_getjnienvnewframe_node
1179 = builtin_function ("_Jv_GetJNIEnvNewFrame",
1180 build_function_type (ptr_type_node
, t
),
1181 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1182 soft_jnipopsystemframe_node
1183 = builtin_function ("_Jv_JNI_PopSystemFrame",
1184 build_function_type (void_type_node
, t
),
1185 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1187 t
= tree_cons (NULL_TREE
, object_ptr_type_node
, endlink
);
1189 = builtin_function ("_Jv_UnwrapJNIweakReference",
1190 build_function_type (object_ptr_type_node
, t
),
1191 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1193 t
= tree_cons (NULL_TREE
, int_type_node
,
1194 tree_cons (NULL_TREE
, int_type_node
, endlink
));
1196 = builtin_function ("_Jv_divI",
1197 build_function_type (int_type_node
, t
),
1198 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1201 = builtin_function ("_Jv_remI",
1202 build_function_type (int_type_node
, t
),
1203 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1205 t
= tree_cons (NULL_TREE
, long_type_node
,
1206 tree_cons (NULL_TREE
, long_type_node
, endlink
));
1208 = builtin_function ("_Jv_divJ",
1209 build_function_type (long_type_node
, t
),
1210 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1213 = builtin_function ("_Jv_remJ",
1214 build_function_type (long_type_node
, t
),
1215 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1217 /* Initialize variables for except.c. */
1218 eh_personality_libfunc
= init_one_libfunc (USING_SJLJ_EXCEPTIONS
1219 ? "__gcj_personality_sj0"
1220 : "__gcj_personality_v0");
1221 default_init_unwind_resume_libfunc ();
1223 lang_eh_runtime_type
= do_nothing
;
1227 initialize_builtins ();
1228 soft_fmod_node
= built_in_decls
[BUILT_IN_FMOD
];
1230 soft_fmodf_node
= built_in_decls
[BUILT_IN_FMODF
];
1237 /* Look up NAME in the current binding level and its superiors
1238 in the namespace of variables, functions and typedefs.
1239 Return a ..._DECL node of some kind representing its definition,
1240 or return 0 if it is undefined. */
1243 lookup_name (tree name
)
1246 if (current_binding_level
!= global_binding_level
1247 && IDENTIFIER_LOCAL_VALUE (name
))
1248 val
= IDENTIFIER_LOCAL_VALUE (name
);
1250 val
= IDENTIFIER_GLOBAL_VALUE (name
);
1254 /* Similar to `lookup_name' but look only at current binding level and
1255 the previous one if it's the parameter level. */
1258 lookup_name_current_level (tree name
)
1262 if (current_binding_level
== global_binding_level
)
1263 return IDENTIFIER_GLOBAL_VALUE (name
);
1265 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
1268 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
1269 if (DECL_NAME (t
) == name
)
1275 /* Use a binding level to record a labeled block declaration */
1278 push_labeled_block (tree lb
)
1280 tree name
= DECL_NAME (LABELED_BLOCK_LABEL (lb
));
1281 struct binding_level
*b
= current_binding_level
;
1282 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1284 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1285 TREE_CHAIN (lb
) = b
->names
;
1287 IDENTIFIER_LOCAL_VALUE (name
) = lb
;
1290 /* Pop the current binding level, reinstalling values for the previous
1294 pop_labeled_block (void)
1296 struct binding_level
*b
= current_binding_level
;
1297 tree label
= b
->names
;
1298 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label
))) =
1301 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b
->shadowed
)) =
1302 TREE_VALUE (b
->shadowed
);
1304 /* Pop the current level, and free the structure for reuse. */
1305 current_binding_level
= current_binding_level
->level_chain
;
1306 b
->level_chain
= free_binding_level
;
1307 free_binding_level
= b
;
1310 /* Record a decl-node X as belonging to the current lexical scope.
1311 Check for errors (such as an incompatible declaration for the same
1312 name already seen in the same scope).
1314 Returns either X or an old decl for the same name.
1315 If an old decl is returned, it may have been smashed
1316 to agree with what X says. */
1322 tree name
= DECL_NAME (x
);
1323 struct binding_level
*b
= current_binding_level
;
1325 if (TREE_CODE (x
) != TYPE_DECL
)
1326 DECL_CONTEXT (x
) = current_function_decl
;
1329 t
= lookup_name_current_level (name
);
1330 if (t
!= 0 && t
== error_mark_node
)
1331 /* error_mark_node is 0 for a while during initialization! */
1334 error ("%q+D used prior to declaration", x
);
1337 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1338 to point to the TYPE_DECL.
1339 Since Java does not have typedefs, a type can only have
1340 one (true) name, given by a class, interface, or builtin. */
1341 if (TREE_CODE (x
) == TYPE_DECL
1342 && TYPE_NAME (TREE_TYPE (x
)) == 0
1343 && TREE_TYPE (x
) != error_mark_node
)
1345 TYPE_NAME (TREE_TYPE (x
)) = x
;
1346 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1349 /* This name is new in its binding level.
1350 Install the new declaration and return it. */
1351 if (b
== global_binding_level
)
1353 /* Install a global value. */
1355 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1359 /* Here to install a non-global value. */
1360 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1361 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1364 /* Warn if shadowing an argument at the top level of the body. */
1365 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
1366 /* This warning doesn't apply to the parms of a nested fcn. */
1367 && ! current_binding_level
->parm_flag
1368 /* Check that this is one level down from the parms. */
1369 && current_binding_level
->level_chain
->parm_flag
1370 /* Check that the decl being shadowed
1371 comes from the parm level, one level up. */
1372 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1374 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1375 pedwarn ("declaration of %qs shadows a parameter",
1376 IDENTIFIER_POINTER (name
));
1378 pedwarn ("declaration of %qs shadows a symbol from the parameter list",
1379 IDENTIFIER_POINTER (name
));
1382 /* Maybe warn if shadowing something else. */
1383 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1384 /* No shadow warnings for internally generated vars. */
1385 && DECL_SOURCE_LINE (x
) != 0
1386 /* No shadow warnings for vars made for inlining. */
1387 && ! DECL_FROM_INLINE (x
))
1389 const char *warnstring
= 0;
1391 if (TREE_CODE (x
) == PARM_DECL
1392 && current_binding_level
->level_chain
->parm_flag
)
1393 /* Don't warn about the parm names in function declarator
1394 within a function declarator.
1395 It would be nice to avoid warning in any function
1396 declarator in a declaration, as opposed to a definition,
1397 but there is no way to tell it's not a definition. */
1399 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1400 warnstring
= "declaration of %qs shadows a parameter";
1401 else if (oldlocal
!= 0)
1402 warnstring
= "declaration of %qs shadows previous local";
1403 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1404 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1405 warnstring
= "declaration of %qs shadows global declaration";
1408 warning (0, warnstring
, IDENTIFIER_POINTER (name
));
1412 /* If storing a local value, there may already be one (inherited).
1413 If so, record it for restoration when this binding level ends. */
1415 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1419 /* Put decls on list in reverse order.
1420 We will reverse them later if necessary. */
1421 TREE_CHAIN (x
) = b
->names
;
1428 pushdecl_force_head (tree x
)
1430 current_binding_level
->names
= x
;
1433 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1436 pushdecl_top_level (tree x
)
1439 struct binding_level
*b
= current_binding_level
;
1441 current_binding_level
= global_binding_level
;
1443 current_binding_level
= b
;
1447 /* Like pushdecl, only it places X in FUNCTION_BINDING_LEVEL, if appropriate. */
1450 pushdecl_function_level (tree x
)
1453 struct binding_level
*b
= current_binding_level
;
1455 current_binding_level
= function_binding_level
;
1457 current_binding_level
= b
;
1461 /* Nonzero if we are currently in the global binding level. */
1464 global_bindings_p (void)
1466 return current_binding_level
== global_binding_level
;
1469 /* Return the list of declarations of the current level.
1470 Note that this list is in reverse order unless/until
1471 you nreverse it; and when you do nreverse it, you must
1472 store the result back using `storedecls' or you will lose. */
1477 return current_binding_level
->names
;
1480 /* Create a new `struct binding_level'. */
1482 static struct binding_level
*
1483 make_binding_level (void)
1486 return ggc_alloc_cleared (sizeof (struct binding_level
));
1490 pushlevel (int unused ATTRIBUTE_UNUSED
)
1492 struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1495 /* If this is the top level of a function,
1496 just make sure that NAMED_LABELS is 0. */
1498 if (current_binding_level
== global_binding_level
)
1502 /* Reuse or create a struct for this binding level. */
1504 if (free_binding_level
)
1506 newlevel
= free_binding_level
;
1507 free_binding_level
= free_binding_level
->level_chain
;
1511 newlevel
= make_binding_level ();
1514 /* Add this level to the front of the chain (stack) of levels that
1517 *newlevel
= clear_binding_level
;
1518 newlevel
->level_chain
= current_binding_level
;
1519 current_binding_level
= newlevel
;
1520 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1521 newlevel
->binding_depth
= binding_depth
;
1523 fprintf (stderr
, "push %s level %p pc %d\n",
1524 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1527 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1530 /* Exit a binding level.
1531 Pop the level off, and restore the state of the identifier-decl mappings
1532 that were in effect when this level was entered.
1534 If KEEP is nonzero, this level had explicit declarations, so
1535 and create a "block" (a BLOCK node) for the level
1536 to record its declarations and subblocks for symbol table output.
1538 If FUNCTIONBODY is nonzero, this level is the body of a function,
1539 so create a block as if KEEP were set and also clear out all
1542 If REVERSE is nonzero, reverse the order of decls before putting
1543 them into the BLOCK. */
1546 poplevel (int keep
, int reverse
, int functionbody
)
1549 /* The chain of decls was accumulated in reverse order.
1550 Put it into forward order, just for cleanliness. */
1552 tree subblocks
= current_binding_level
->blocks
;
1557 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1560 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1561 fprintf (stderr
, "pop %s level %p pc %d (end pc %d)\n",
1562 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1563 current_binding_level
->end_pc
);
1565 fprintf (stderr
, "pop %s level %p pc %d\n",
1566 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1568 if (is_class_level
!= (current_binding_level
== class_binding_level
))
1571 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1575 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1577 /* Get the decls in the order they were written.
1578 Usually current_binding_level->names is in reverse order.
1579 But parameter decls were previously put in forward order. */
1582 current_binding_level
->names
1583 = decls
= nreverse (current_binding_level
->names
);
1585 decls
= current_binding_level
->names
;
1587 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1588 if (TREE_CODE (decl
) == VAR_DECL
1589 && DECL_LANG_SPECIFIC (decl
) != NULL
1590 && DECL_LOCAL_SLOT_NUMBER (decl
))
1591 LOCAL_VAR_OUT_OF_SCOPE_P (decl
) = 1;
1593 /* If there were any declarations in that level,
1594 or if this level is a function body,
1595 create a BLOCK to record them for the life of this function. */
1598 if (keep
|| functionbody
)
1600 block
= make_node (BLOCK
);
1601 TREE_TYPE (block
) = void_type_node
;
1604 if (current_binding_level
->exception_range
)
1605 expand_end_java_handler (current_binding_level
->exception_range
);
1609 /* If any statements have been generated at this level, create a
1610 BIND_EXPR to hold them and copy the variables to it. This
1611 only applies to the bytecode compiler. */
1612 if (current_binding_level
->stmts
)
1615 tree
*var
= &BLOCK_VARS (block
);
1617 /* Copy decls from names list, ignoring labels. */
1620 tree next
= TREE_CHAIN (decl
);
1621 if (TREE_CODE (decl
) != LABEL_DECL
)
1624 var
= &TREE_CHAIN (decl
);
1630 bind
= build3 (BIND_EXPR
, TREE_TYPE (block
), BLOCK_VARS (block
),
1631 BLOCK_EXPR_BODY (block
), block
);
1632 BIND_EXPR_BODY (bind
) = current_binding_level
->stmts
;
1634 if (BIND_EXPR_BODY (bind
)
1635 && TREE_SIDE_EFFECTS (BIND_EXPR_BODY (bind
)))
1636 TREE_SIDE_EFFECTS (bind
) = 1;
1638 /* FIXME: gimplifier brain damage. */
1639 if (BIND_EXPR_BODY (bind
) == NULL
)
1640 BIND_EXPR_BODY (bind
) = build_java_empty_stmt ();
1642 current_binding_level
->stmts
= NULL
;
1646 BLOCK_VARS (block
) = decls
;
1648 BLOCK_SUBBLOCKS (block
) = subblocks
;
1651 /* In each subblock, record that this is its superior. */
1653 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1654 BLOCK_SUPERCONTEXT (link
) = block
;
1656 /* Clear out the meanings of the local variables of this level. */
1658 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1660 tree name
= DECL_NAME (link
);
1661 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1663 /* If the ident. was used or addressed via a local extern decl,
1664 don't forget that fact. */
1665 if (DECL_EXTERNAL (link
))
1667 if (TREE_USED (link
))
1668 TREE_USED (name
) = 1;
1669 if (TREE_ADDRESSABLE (link
))
1670 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1672 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1676 /* Restore all name-meanings of the outer levels
1677 that were shadowed by this level. */
1679 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1680 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1682 /* If the level being exited is the top level of a function,
1683 check over all the labels, and clear out the current
1684 (function local) meanings of their names. */
1688 /* If this is the top level block of a function,
1689 the vars are the function's parameters.
1690 Don't leave them in the BLOCK because they are
1691 found in the FUNCTION_DECL instead. */
1693 BLOCK_VARS (block
) = 0;
1695 /* Clear out the definitions of all label names,
1696 since their scopes end here,
1697 and add them to BLOCK_VARS. */
1700 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1702 tree label
= TREE_VALUE (link
);
1704 if (DECL_INITIAL (label
) == 0)
1706 error ("label %q+D used but not defined", label
);
1707 /* Avoid crashing later. */
1708 define_label (input_location
, DECL_NAME (label
));
1710 else if (warn_unused
[UNUSED_LABEL
] && !TREE_USED (label
))
1711 warning (0, "label %q+D defined but not used", label
);
1712 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1714 /* Put the labels into the "variables" of the
1715 top-level block, so debugger can see them. */
1716 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1717 BLOCK_VARS (block
) = label
;
1722 /* Pop the current level, and free the structure for reuse. */
1725 struct binding_level
*level
= current_binding_level
;
1726 current_binding_level
= current_binding_level
->level_chain
;
1728 level
->level_chain
= free_binding_level
;
1729 free_binding_level
= level
;
1732 /* Dispose of the block that we just made inside some higher level. */
1735 DECL_INITIAL (current_function_decl
) = block
;
1736 DECL_SAVED_TREE (current_function_decl
) = bind
;
1742 current_binding_level
->blocks
1743 = chainon (current_binding_level
->blocks
, block
);
1745 /* If we did not make a block for the level just exited,
1746 any blocks made for inner levels
1747 (since they cannot be recorded as subblocks in that level)
1748 must be carried forward so they will later become subblocks
1749 of something else. */
1751 current_binding_level
->blocks
1752 = chainon (current_binding_level
->blocks
, subblocks
);
1755 java_add_stmt (bind
);
1759 TREE_USED (block
) = 1;
1764 maybe_pushlevels (int pc
)
1766 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1770 while (pending_local_decls
!= NULL_TREE
&&
1771 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1773 tree
*ptr
= &pending_local_decls
;
1774 tree decl
= *ptr
, next
;
1775 int end_pc
= DECL_LOCAL_END_PC (decl
);
1777 while (*ptr
!= NULL_TREE
1778 && DECL_LOCAL_START_PC (*ptr
) <= pc
1779 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1780 ptr
= &TREE_CHAIN (*ptr
);
1781 pending_local_decls
= *ptr
;
1784 /* Force non-nested range to be nested in current range by
1785 truncating variable lifetimes. */
1786 if (end_pc
> current_binding_level
->end_pc
)
1788 end_pc
= current_binding_level
->end_pc
;
1789 DECL_LOCAL_END_PC (decl
) = end_pc
;
1792 maybe_start_try (pc
, end_pc
);
1796 current_binding_level
->end_pc
= end_pc
;
1797 current_binding_level
->start_pc
= pc
;
1798 current_binding_level
->names
= NULL
;
1799 for ( ; decl
!= NULL_TREE
; decl
= next
)
1801 next
= TREE_CHAIN (decl
);
1802 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl
), decl
);
1804 initialize_local_variable (decl
, DECL_LOCAL_SLOT_NUMBER (decl
));
1808 maybe_start_try (pc
, 0);
1812 maybe_poplevels (int pc
)
1814 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1818 /* FIXME: I'm pretty sure that this is wrong. Variable scopes are
1819 inclusive, so a variable is live if pc == end_pc. Here, we
1820 terminate a range if the current pc is equal to the end of the
1821 range, and this is *before* we have generated code for the
1822 instruction at end_pc. We're closing a binding level one
1823 instruction too early.*/
1824 while (current_binding_level
->end_pc
<= pc
)
1828 /* Terminate any binding which began during the range beginning at
1829 start_pc. This tidies up improperly nested local variable ranges
1830 and exception handlers; a variable declared within an exception
1831 range is forcibly terminated when that exception ends. */
1834 force_poplevels (int start_pc
)
1836 while (current_binding_level
->start_pc
> start_pc
)
1838 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1839 warning (0, "In %+D: overlapped variable and exception ranges at %d",
1840 current_function_decl
,
1841 current_binding_level
->start_pc
);
1846 /* Insert BLOCK at the end of the list of subblocks of the
1847 current binding level. This is used when a BIND_EXPR is expanded,
1848 to handle the BLOCK node inside the BIND_EXPR. */
1851 insert_block (tree block
)
1853 TREE_USED (block
) = 1;
1854 current_binding_level
->blocks
1855 = chainon (current_binding_level
->blocks
, block
);
1858 /* integrate_decl_tree calls this function. */
1861 java_dup_lang_specific_decl (tree node
)
1864 struct lang_decl
*x
;
1866 if (!DECL_LANG_SPECIFIC (node
))
1869 lang_decl_size
= sizeof (struct lang_decl
);
1870 x
= ggc_alloc (lang_decl_size
);
1871 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1872 DECL_LANG_SPECIFIC (node
) = x
;
1876 give_name_to_locals (JCF
*jcf
)
1878 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1879 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1881 pending_local_decls
= NULL_TREE
;
1885 n
= JCF_readu2 (jcf
);
1886 for (i
= 0; i
< n
; i
++)
1888 int start_pc
= JCF_readu2 (jcf
);
1889 int length
= JCF_readu2 (jcf
);
1890 int name_index
= JCF_readu2 (jcf
);
1891 int signature_index
= JCF_readu2 (jcf
);
1892 int slot
= JCF_readu2 (jcf
);
1893 tree name
= get_name_constant (jcf
, name_index
);
1894 tree type
= parse_signature (jcf
, signature_index
);
1895 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1897 && length
== DECL_CODE_LENGTH (current_function_decl
))
1899 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1900 DECL_NAME (decl
) = name
;
1901 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1902 warning (0, "bad type in parameter debug info");
1907 int end_pc
= start_pc
+ length
;
1908 tree decl
= build_decl (VAR_DECL
, name
, type
);
1909 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1911 warning (0, "bad PC range for debug info for local %q+D",
1913 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1916 /* Adjust start_pc if necessary so that the local's first
1917 store operation will use the relevant DECL as a
1918 destination. Fore more information, read the leading
1919 comments for expr.c:maybe_adjust_start_pc. */
1920 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1922 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1923 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1924 DECL_LOCAL_START_PC (decl
) = start_pc
;
1926 /* FIXME: The range used internally for exceptions and local
1927 variable ranges, is a half-open interval:
1928 start_pc <= pc < end_pc. However, the range used in the
1929 Java VM spec is inclusive at both ends:
1930 start_pc <= pc <= end_pc. */
1933 DECL_LOCAL_END_PC (decl
) = end_pc
;
1935 /* Now insert the new decl in the proper place in
1936 pending_local_decls. We are essentially doing an insertion sort,
1937 which works fine, since the list input will normally already
1939 ptr
= &pending_local_decls
;
1940 while (*ptr
!= NULL_TREE
1941 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1942 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1943 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1944 ptr
= &TREE_CHAIN (*ptr
);
1945 TREE_CHAIN (decl
) = *ptr
;
1950 pending_local_decls
= nreverse (pending_local_decls
);
1952 /* Fill in default names for the parameters. */
1953 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1954 parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
), i
++)
1956 if (DECL_NAME (parm
) == NULL_TREE
)
1958 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1960 DECL_NAME (parm
) = get_identifier ("this");
1964 sprintf (buffer
, "ARG_%d", arg_i
);
1965 DECL_NAME (parm
) = get_identifier (buffer
);
1972 build_result_decl (tree fndecl
)
1974 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1975 tree result
= DECL_RESULT (fndecl
);
1978 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1979 if (INTEGRAL_TYPE_P (restype
)
1980 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
1981 restype
= integer_type_node
;
1982 result
= build_decl (RESULT_DECL
, NULL_TREE
, restype
);
1983 DECL_ARTIFICIAL (result
) = 1;
1984 DECL_IGNORED_P (result
) = 1;
1985 DECL_CONTEXT (result
) = fndecl
;
1986 DECL_RESULT (fndecl
) = result
;
1992 start_java_method (tree fndecl
)
1999 current_function_decl
= fndecl
;
2000 announce_function (fndecl
);
2002 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
2003 decl_map
= make_tree_vec (i
);
2004 base_decl_map
= make_tree_vec (i
);
2005 type_map
= xrealloc (type_map
, i
* sizeof (tree
));
2007 #if defined(DEBUG_JAVA_BINDING_LEVELS)
2008 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
2010 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
2011 pushlevel (1); /* Push parameters. */
2013 ptr
= &DECL_ARGUMENTS (fndecl
);
2014 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
2015 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
2017 tree parm_name
= NULL_TREE
, parm_decl
;
2018 tree parm_type
= TREE_VALUE (tem
);
2019 gcc_assert (i
< DECL_MAX_LOCALS (fndecl
));
2021 parm_decl
= build_decl (PARM_DECL
, parm_name
, parm_type
);
2022 DECL_CONTEXT (parm_decl
) = fndecl
;
2023 if (targetm
.calls
.promote_prototypes (parm_type
)
2024 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
2025 && INTEGRAL_TYPE_P (parm_type
))
2026 parm_type
= integer_type_node
;
2027 DECL_ARG_TYPE (parm_decl
) = parm_type
;
2030 ptr
= &TREE_CHAIN (parm_decl
);
2032 /* Add parm_decl to the decl_map. */
2033 push_jvm_slot (i
, parm_decl
);
2035 type_map
[i
] = TREE_TYPE (parm_decl
);
2036 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
2039 type_map
[i
] = void_type_node
;
2043 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
2045 while (i
< DECL_MAX_LOCALS(fndecl
))
2046 type_map
[i
++] = NULL_TREE
;
2048 build_result_decl (fndecl
);
2050 /* Push local variables. */
2053 function_binding_level
= current_binding_level
;
2057 end_java_method (void)
2059 tree fndecl
= current_function_decl
;
2061 /* pop out of function */
2064 /* pop out of its parameters */
2067 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
2069 if (DECL_SAVED_TREE (fndecl
))
2071 tree fbody
, block_body
;
2072 /* Before we check initialization, attached all class initialization
2073 variable to the block_body */
2074 fbody
= DECL_SAVED_TREE (fndecl
);
2075 block_body
= BIND_EXPR_BODY (fbody
);
2076 htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (fndecl
),
2077 attach_init_test_initialization_flags
, block_body
);
2080 finish_method (fndecl
);
2082 if (! flag_unit_at_a_time
)
2084 /* Nulling these fields when we no longer need them saves
2086 DECL_SAVED_TREE (fndecl
) = NULL
;
2087 DECL_STRUCT_FUNCTION (fndecl
) = NULL
;
2088 DECL_INITIAL (fndecl
) = NULL_TREE
;
2090 current_function_decl
= NULL_TREE
;
2093 /* Prepare a method for expansion. */
2096 finish_method (tree fndecl
)
2098 tree
*tp
= &DECL_SAVED_TREE (fndecl
);
2100 /* Wrap body of synchronized methods in a monitorenter,
2101 plus monitorexit cleanup. */
2102 if (METHOD_SYNCHRONIZED (fndecl
))
2104 tree enter
, exit
, lock
;
2105 if (METHOD_STATIC (fndecl
))
2106 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
2108 lock
= DECL_ARGUMENTS (fndecl
);
2109 BUILD_MONITOR_ENTER (enter
, lock
);
2110 BUILD_MONITOR_EXIT (exit
, lock
);
2111 *tp
= build2 (COMPOUND_EXPR
, void_type_node
, enter
,
2112 build2 (TRY_FINALLY_EXPR
, void_type_node
, *tp
, exit
));
2115 /* Prepend class initialization for static methods reachable from
2117 if (METHOD_STATIC (fndecl
)
2118 && (! METHOD_PRIVATE (fndecl
)
2119 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
2120 && ! DECL_CLINIT_P (fndecl
)
2121 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
2123 tree clas
= DECL_CONTEXT (fndecl
);
2124 tree init
= build3 (CALL_EXPR
, void_type_node
,
2125 build_address_of (soft_initclass_node
),
2126 build_tree_list (NULL_TREE
, build_class_ref (clas
)),
2128 *tp
= build2 (COMPOUND_EXPR
, TREE_TYPE (*tp
), init
, *tp
);
2131 /* Convert function tree to GENERIC prior to inlining. */
2132 java_genericize (fndecl
);
2134 /* Store the end of the function, so that we get good line number
2135 info for the epilogue. */
2136 if (DECL_STRUCT_FUNCTION (fndecl
))
2137 cfun
= DECL_STRUCT_FUNCTION (fndecl
);
2139 allocate_struct_function (fndecl
);
2140 #ifdef USE_MAPPED_LOCATION
2141 cfun
->function_end_locus
= DECL_FUNCTION_LAST_LINE (fndecl
);
2143 cfun
->function_end_locus
.file
= DECL_SOURCE_FILE (fndecl
);
2144 cfun
->function_end_locus
.line
= DECL_FUNCTION_LAST_LINE (fndecl
);
2147 /* Defer inlining and expansion to the cgraph optimizers. */
2148 cgraph_finalize_function (fndecl
, false);
2151 /* Optimize and expand a function's entire body. */
2154 java_expand_body (tree fndecl
)
2156 tree_rest_of_compilation (fndecl
);
2159 /* We pessimistically marked all methods and fields external until we
2160 knew what set of classes we were planning to compile. Now mark those
2161 associated with CLASS to be generated locally as not external. */
2164 java_mark_decl_local (tree decl
)
2166 DECL_EXTERNAL (decl
) = 0;
2168 /* If we've already constructed DECL_RTL, give encode_section_info
2169 a second chance, now that we've changed the flags. */
2170 /* ??? Ideally, we'd have flag_unit_at_a_time set, and not have done
2171 anything that would have referenced DECL_RTL so far. But at the
2172 moment we force flag_unit_at_a_time off due to excessive memory
2173 consumption when compiling large jar files. Which probably means
2174 that we need to re-order how we process jar files... */
2175 if (DECL_RTL_SET_P (decl
))
2176 make_decl_rtl (decl
);
2179 /* Given appropriate target support, G++ will emit hidden aliases for native
2180 methods. Using this hidden name is required for proper operation of
2181 _Jv_Method::ncode, but it doesn't hurt to use it everywhere. Look for
2182 proper target support, then mark the method for aliasing. */
2185 java_mark_cni_decl_local (tree decl
)
2187 /* Setting DECL_LOCAL_CNI_METHOD_P changes the behavior of the mangler.
2188 We expect that we should not yet have referenced this decl in a
2189 context that requires it. Check this invariant even if we don't have
2190 support for hidden aliases. */
2191 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
2193 #if !defined(HAVE_GAS_HIDDEN) || !defined(ASM_OUTPUT_DEF)
2197 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
2198 DECL_LOCAL_CNI_METHOD_P (decl
) = 1;
2201 /* Use the preceding two functions and mark all members of the class. */
2204 java_mark_class_local (tree
class)
2208 for (t
= TYPE_FIELDS (class); t
; t
= TREE_CHAIN (t
))
2209 if (FIELD_STATIC (t
))
2210 java_mark_decl_local (t
);
2212 for (t
= TYPE_METHODS (class); t
; t
= TREE_CHAIN (t
))
2213 if (!METHOD_ABSTRACT (t
))
2215 if (METHOD_NATIVE (t
) && !flag_jni
)
2216 java_mark_cni_decl_local (t
);
2218 java_mark_decl_local (t
);
2222 /* Add a statement to a compound_expr. */
2225 add_stmt_to_compound (tree existing
, tree type
, tree stmt
)
2231 tree expr
= build2 (COMPOUND_EXPR
, type
, existing
, stmt
);
2232 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (existing
)
2233 | TREE_SIDE_EFFECTS (stmt
);
2240 /* Add a statement to the statement_list currently being constructed.
2241 If the statement_list is null, we don't create a singleton list.
2242 This is necessary because poplevel() assumes that adding a
2243 statement to a null statement_list returns the statement. */
2246 java_add_stmt (tree new_stmt
)
2248 tree stmts
= current_binding_level
->stmts
;
2249 tree_stmt_iterator i
;
2252 SET_EXPR_LOCATION (new_stmt
, input_location
);
2255 return current_binding_level
->stmts
= new_stmt
;
2257 /* Force STMTS to be a statement_list. */
2258 if (TREE_CODE (stmts
) != STATEMENT_LIST
)
2260 tree t
= make_node (STATEMENT_LIST
);
2262 tsi_link_after (&i
, stmts
, TSI_CONTINUE_LINKING
);
2266 i
= tsi_last (stmts
);
2267 tsi_link_after (&i
, new_stmt
, TSI_CONTINUE_LINKING
);
2269 return current_binding_level
->stmts
= stmts
;
2272 /* Add a variable to the current scope. */
2275 java_add_local_var (tree decl
)
2277 tree
*vars
= ¤t_binding_level
->names
;
2279 TREE_CHAIN (decl
) = next
;
2281 DECL_CONTEXT (decl
) = current_function_decl
;
2282 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2286 /* Return a pointer to the compound_expr currently being
2292 return ¤t_binding_level
->stmts
;
2295 /* Register an exception range as belonging to the current binding
2296 level. There may only be one: if there are more, we'll create more
2297 binding levels. However, each range can have multiple handlers,
2298 and these are expanded when we call expand_end_java_handler(). */
2301 register_exception_range (struct eh_range
*range
, int pc
, int end_pc
)
2303 gcc_assert (! current_binding_level
->exception_range
);
2304 current_binding_level
->exception_range
= range
;
2305 current_binding_level
->end_pc
= end_pc
;
2306 current_binding_level
->start_pc
= pc
;
2309 #include "gt-java-decl.h"