1 /* Process declarations and variables for the GNU compiler for the
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007,
4 2005, 2006, 2007, 2008, 2009, 2010 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 3, 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 COPYING3. If not see
20 <http://www.gnu.org/licenses/>.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
30 #include "coretypes.h"
32 #include "diagnostic-core.h"
35 #include "java-tree.h"
38 #include "java-except.h"
41 #include "tree-inline.h"
44 #include "tree-iterator.h"
45 #include "langhooks.h"
48 #if defined (DEBUG_JAVA_BINDING_LEVELS)
49 extern void indent (void);
52 static tree
push_jvm_slot (int, tree
);
53 static tree
lookup_name_current_level (tree
);
54 static tree
push_promoted_type (const char *, tree
);
55 static struct binding_level
*make_binding_level (void);
56 static tree
create_primitive_vtable (const char *);
57 static tree
check_local_unnamed_variable (tree
, tree
, tree
);
58 static void parse_version (void);
61 /* The following ABI flags are used in the high-order bits of the version
62 ID field. The version ID number itself should never be larger than
63 0xfffff, so it should be safe to use top 12 bits for these flags. */
65 #define FLAG_BINARYCOMPAT_ABI (1<<31) /* Class is built with the BC-ABI. */
67 #define FLAG_BOOTSTRAP_LOADER (1<<30) /* Used when defining a class that
68 should be loaded by the bootstrap
71 /* If an ABI change is made within a GCC release series, rendering current
72 binaries incompatible with the old runtimes, this number must be set to
73 enforce the compatibility rules. */
74 #define MINOR_BINARYCOMPAT_ABI_VERSION 1
76 /* The runtime may recognize a variety of BC ABIs (objects generated by
77 different version of gcj), but will probably always require strict
78 matching for the ordinary (C++) ABI. */
80 /* The version ID of the BC ABI that we generate. This must be kept in
81 sync with parse_version(), libgcj, and reality (if the BC format changes,
83 #define GCJ_CURRENT_BC_ABI_VERSION \
84 (4 * 100000 + 0 * 1000 + MINOR_BINARYCOMPAT_ABI_VERSION)
86 /* The ABI version number. */
89 /* Name of the Cloneable class. */
90 tree java_lang_cloneable_identifier_node
;
92 /* Name of the Serializable class. */
93 tree java_io_serializable_identifier_node
;
95 /* The DECL_MAP is a mapping from (index, type) to a decl node.
96 If index < max_locals, it is the index of a local variable.
97 if index >= max_locals, then index-max_locals is a stack slot.
98 The DECL_MAP mapping is represented as a TREE_VEC whose elements
99 are a list of decls (VAR_DECL or PARM_DECL) chained by
100 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
101 we search the chain for a decl with a matching TREE_TYPE. */
103 static GTY(()) tree decl_map
;
105 /* The base_decl_map is contains one variable of ptr_type: this is
106 used to contain every variable of reference type that is ever
107 stored in a local variable slot. */
109 static GTY(()) tree base_decl_map
;
111 /* An index used to make temporary identifiers unique. */
114 /* A list of local variables VAR_DECLs for this method that we have seen
115 debug information, but we have not reached their starting (byte) PC yet. */
117 static GTY(()) tree pending_local_decls
;
119 /* The decl for "_Jv_ResolvePoolEntry". */
120 tree soft_resolvepoolentry_node
;
122 /* The decl for the .constants field of an instance of Class. */
123 tree constants_field_decl_node
;
125 /* The decl for the .data field of an instance of Class. */
126 tree constants_data_field_decl_node
;
128 #if defined(DEBUG_JAVA_BINDING_LEVELS)
129 int binding_depth
= 0;
130 int is_class_level
= 0;
138 for (i
= 0; i
< binding_depth
*2; i
++)
141 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
143 /* True if decl is a named local variable, i.e. if it is an alias
144 that's used only for debugging purposes. */
147 debug_variable_p (tree decl
)
149 if (TREE_CODE (decl
) == PARM_DECL
)
152 if (LOCAL_SLOT_P (decl
))
159 push_jvm_slot (int index
, tree decl
)
161 DECL_CONTEXT (decl
) = current_function_decl
;
162 layout_decl (decl
, 0);
164 /* Now link the decl into the decl_map. */
165 if (DECL_LANG_SPECIFIC (decl
) == NULL
)
167 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
168 DECL_LOCAL_START_PC (decl
) = 0;
169 DECL_LOCAL_END_PC (decl
) = DECL_CODE_LENGTH (current_function_decl
);
170 DECL_LOCAL_SLOT_NUMBER (decl
) = index
;
172 DECL_LOCAL_SLOT_CHAIN (decl
) = TREE_VEC_ELT (decl_map
, index
);
173 TREE_VEC_ELT (decl_map
, index
) = decl
;
178 /* Find the best declaration based upon type. If 'decl' fits 'type' better
179 than 'best', return 'decl'. Otherwise return 'best'. */
182 check_local_unnamed_variable (tree best
, tree decl
, tree type
)
184 tree decl_type
= TREE_TYPE (decl
);
186 gcc_assert (! LOCAL_VAR_OUT_OF_SCOPE_P (decl
));
188 /* Use the same decl for all integer types <= 32 bits. This is
189 necessary because sometimes a value is stored as (for example)
190 boolean but loaded as int. */
191 if (decl_type
== type
192 || (INTEGRAL_TYPE_P (decl_type
)
193 && INTEGRAL_TYPE_P (type
)
194 && TYPE_PRECISION (decl_type
) <= 32
195 && TYPE_PRECISION (type
) <= 32
196 && TYPE_PRECISION (decl_type
) >= TYPE_PRECISION (type
))
197 /* ptr_type_node is used for null pointers, which are
198 assignment compatible with everything. */
199 || (TREE_CODE (decl_type
) == POINTER_TYPE
200 && type
== ptr_type_node
)
201 /* Whenever anyone wants to use a slot that is initially
202 occupied by a PARM_DECL of pointer type they must get that
203 decl, even if they asked for a pointer to a different type.
204 However, if someone wants a scalar variable in a slot that
205 initially held a pointer arg -- or vice versa -- we create a
208 ???: As long as verification is correct, this will be a
209 compatible type. But maybe we should create a dummy variable
210 and replace all references to it with the DECL and a
213 || (TREE_CODE (decl_type
) == POINTER_TYPE
214 && TREE_CODE (decl
) == PARM_DECL
215 && TREE_CODE (type
) == POINTER_TYPE
))
217 if (best
== NULL_TREE
218 || (decl_type
== type
&& TREE_TYPE (best
) != type
))
226 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
227 that is valid at PC (or -1 if any pc).
228 If there is no existing matching decl, allocate one. */
231 find_local_variable (int index
, tree type
, int pc ATTRIBUTE_UNUSED
)
233 tree tmp
= TREE_VEC_ELT (decl_map
, index
);
234 tree decl
= NULL_TREE
;
236 /* Scan through every declaration that has been created in this
237 slot. We're only looking for variables that correspond to local
238 index declarations and PARM_DECLs, not named variables: such
239 local variables are used only for debugging information. */
240 while (tmp
!= NULL_TREE
)
242 if (! debug_variable_p (tmp
))
243 decl
= check_local_unnamed_variable (decl
, tmp
, type
);
244 tmp
= DECL_LOCAL_SLOT_CHAIN (tmp
);
247 /* gcj has a function called promote_type(), which is used by both
248 the bytecode compiler and the source compiler. Unfortunately,
249 the type systems for the Java VM and the Java language are not
250 the same: a boolean in the VM promotes to an int, not to a wide
251 boolean. If our caller wants something to hold a boolean, that
252 had better be an int, because that slot might be re-used
253 later in integer context. */
254 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
255 type
= integer_type_node
;
257 /* If we don't find a match, create one with the type passed in.
258 The name of the variable is #n#m, which n is the variable index
259 in the local variable area and m is a dummy identifier for
260 uniqueness -- multiple variables may share the same local
261 variable index. We don't call pushdecl() to push pointer types
262 into a binding expr because they'll all be replaced by a single
263 variable that is used for every reference in that local variable
269 sprintf (buf
, "#slot#%d#%d", index
, uniq
++);
270 name
= get_identifier (buf
);
271 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
272 DECL_IGNORED_P (decl
) = 1;
273 DECL_ARTIFICIAL (decl
) = 1;
274 decl
= push_jvm_slot (index
, decl
);
275 LOCAL_SLOT_P (decl
) = 1;
277 if (TREE_CODE (type
) != POINTER_TYPE
)
278 pushdecl_function_level (decl
);
281 /* As well as creating a local variable that matches the type, we
282 also create a base variable (of ptr_type) that will hold all its
284 if (TREE_CODE (type
) == POINTER_TYPE
285 && ! TREE_VEC_ELT (base_decl_map
, index
))
290 sprintf (buf
, "#ref#%d#%d", index
, uniq
++);
291 name
= get_identifier (buf
);
293 = TREE_VEC_ELT (base_decl_map
, index
)
294 = build_decl (input_location
, VAR_DECL
, name
, ptr_type_node
);
295 pushdecl_function_level (base_decl
);
296 DECL_IGNORED_P (base_decl
) = 1;
297 DECL_ARTIFICIAL (base_decl
) = 1;
303 /* Called during genericization for every variable. If the variable
304 is a temporary of pointer type, replace it with a common variable
305 thath is used to hold all pointer types that are ever stored in
306 that slot. Set WANT_LVALUE if you want a variable that is to be
310 java_replace_reference (tree var_decl
, bool want_lvalue
)
317 decl_type
= TREE_TYPE (var_decl
);
319 if (TREE_CODE (decl_type
) == POINTER_TYPE
)
321 if (DECL_LANG_SPECIFIC (var_decl
)
322 && LOCAL_SLOT_P (var_decl
))
324 int index
= DECL_LOCAL_SLOT_NUMBER (var_decl
);
325 tree base_decl
= TREE_VEC_ELT (base_decl_map
, index
);
327 gcc_assert (base_decl
);
329 base_decl
= build1 (NOP_EXPR
, decl_type
, base_decl
);
338 /* Helper for java_genericize. */
341 java_replace_references (tree
*tp
, int *walk_subtrees
,
342 void *data ATTRIBUTE_UNUSED
)
344 if (TREE_CODE (*tp
) == MODIFY_EXPR
)
346 source_location loc
= EXPR_LOCATION (*tp
);
347 tree lhs
= TREE_OPERAND (*tp
, 0);
348 /* This is specific to the bytecode compiler. If a variable has
349 LOCAL_SLOT_P set, replace an assignment to it with an assignment
350 to the corresponding variable that holds all its aliases. */
351 if (TREE_CODE (lhs
) == VAR_DECL
352 && DECL_LANG_SPECIFIC (lhs
)
353 && LOCAL_SLOT_P (lhs
)
354 && TREE_CODE (TREE_TYPE (lhs
)) == POINTER_TYPE
)
356 tree new_lhs
= java_replace_reference (lhs
, /* want_lvalue */ true);
357 tree new_rhs
= build1 (NOP_EXPR
, TREE_TYPE (new_lhs
),
358 TREE_OPERAND (*tp
, 1));
359 tree tem
= build2 (MODIFY_EXPR
, TREE_TYPE (new_lhs
),
361 *tp
= build1 (NOP_EXPR
, TREE_TYPE (lhs
), tem
);
362 SET_EXPR_LOCATION (tem
, loc
);
363 SET_EXPR_LOCATION (new_rhs
, loc
);
364 SET_EXPR_LOCATION (*tp
, loc
);
367 if (TREE_CODE (*tp
) == VAR_DECL
)
369 *tp
= java_replace_reference (*tp
, /* want_lvalue */ false);
376 /* Same as find_local_index, except that INDEX is a stack index. */
379 find_stack_slot (int index
, tree type
)
381 return find_local_variable (index
+ DECL_MAX_LOCALS (current_function_decl
),
387 /* A chain of _DECL nodes for all variables, constants, functions,
388 * and typedef types. These are in the reverse of the order supplied.
392 /* For each level, a list of shadowed outer-level local definitions
393 to be restored when this level is popped.
394 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
395 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
398 /* For each level (except not the global one),
399 a chain of BLOCK nodes for all the levels
400 that were entered and exited one level down. */
403 /* The binding level which this one is contained in (inherits from). */
404 struct binding_level
*level_chain
;
406 /* The bytecode PC that marks the end of this level. */
408 /* The bytecode PC that marks the start of this level. */
411 /* The statements in this binding level. */
414 /* An exception range associated with this binding level. */
415 struct eh_range
* GTY((skip (""))) exception_range
;
417 /* Binding depth at which this level began. Used only for debugging. */
418 unsigned binding_depth
;
420 /* The location at which this level began. */
424 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
426 /* The binding level currently in effect. */
428 static GTY(()) struct binding_level
*current_binding_level
;
430 /* A chain of binding_level structures awaiting reuse. */
432 static GTY(()) struct binding_level
*free_binding_level
;
434 /* The outermost binding level, for names of file scope.
435 This is created when the compiler is started and exists
436 through the entire run. */
438 static GTY(()) struct binding_level
*global_binding_level
;
440 /* The binding level that holds variables declared at the outermost
441 level within a function body. */
443 static struct binding_level
*function_binding_level
;
445 /* A PC value bigger than any PC value we may ever may encounter. */
447 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
449 /* Binding level structures are initialized by copying this one. */
451 static const struct binding_level clear_binding_level
453 NULL_TREE
, /* names */
454 NULL_TREE
, /* shadowed */
455 NULL_TREE
, /* blocks */
456 NULL_BINDING_LEVEL
, /* level_chain */
457 LARGEST_PC
, /* end_pc */
460 NULL
, /* exception_range */
461 0, /* binding_depth */
465 tree java_global_trees
[JTI_MAX
];
467 /* Build (and pushdecl) a "promoted type" for all standard
468 types shorter than int. */
471 push_promoted_type (const char *name
, tree actual_type
)
473 tree type
= make_node (TREE_CODE (actual_type
));
475 tree in_min
= TYPE_MIN_VALUE (int_type_node
);
476 tree in_max
= TYPE_MAX_VALUE (int_type_node
);
478 tree in_min
= TYPE_MIN_VALUE (actual_type
);
479 tree in_max
= TYPE_MAX_VALUE (actual_type
);
481 TYPE_MIN_VALUE (type
) = copy_node (in_min
);
482 TREE_TYPE (TYPE_MIN_VALUE (type
)) = type
;
483 TYPE_MAX_VALUE (type
) = copy_node (in_max
);
484 TREE_TYPE (TYPE_MAX_VALUE (type
)) = type
;
485 TYPE_PRECISION (type
) = TYPE_PRECISION (int_type_node
);
486 TYPE_STRING_FLAG (type
) = TYPE_STRING_FLAG (actual_type
);
488 pushdecl (build_decl (input_location
,
489 TYPE_DECL
, get_identifier (name
), type
));
493 /* Return tree that represents a vtable for a primitive array. */
495 create_primitive_vtable (const char *name
)
500 sprintf (buf
, "_Jv_%sVTable", name
);
501 r
= build_decl (input_location
,
502 VAR_DECL
, get_identifier (buf
), ptr_type_node
);
503 DECL_EXTERNAL (r
) = 1;
507 /* Parse the version string and compute the ABI version number. */
511 const char *p
= version_string
;
512 unsigned int major
= 0, minor
= 0;
513 unsigned int abi_version
;
515 /* Skip leading junk. */
516 while (*p
&& !ISDIGIT (*p
))
520 /* Extract major version. */
523 major
= major
* 10 + *p
- '0';
527 gcc_assert (*p
== '.' && ISDIGIT (p
[1]));
530 /* Extract minor version. */
533 minor
= minor
* 10 + *p
- '0';
537 if (flag_indirect_dispatch
)
539 abi_version
= GCJ_CURRENT_BC_ABI_VERSION
;
540 abi_version
|= FLAG_BINARYCOMPAT_ABI
;
544 /* Implicit in this computation is the idea that we won't break the
545 old-style binary ABI in a sub-minor release (e.g., from 4.0.0 to
547 abi_version
= 100000 * major
+ 1000 * minor
;
549 if (flag_bootstrap_classes
)
550 abi_version
|= FLAG_BOOTSTRAP_LOADER
;
552 gcj_abi_version
= build_int_cstu (ptr_type_node
, abi_version
);
556 java_init_decl_processing (void)
558 tree field
= NULL_TREE
;
561 init_class_processing ();
563 current_function_decl
= NULL
;
564 current_binding_level
= NULL_BINDING_LEVEL
;
565 free_binding_level
= NULL_BINDING_LEVEL
;
566 pushlevel (0); /* make the binding_level structure for global names */
567 global_binding_level
= current_binding_level
;
569 /* The code here must be similar to build_common_tree_nodes{,_2} in
570 tree.c, especially as to the order of initializing common nodes. */
571 error_mark_node
= make_node (ERROR_MARK
);
572 TREE_TYPE (error_mark_node
) = error_mark_node
;
574 /* Create sizetype first - needed for other types. */
575 initialize_sizetypes ();
577 byte_type_node
= make_signed_type (8);
578 pushdecl (build_decl (BUILTINS_LOCATION
,
579 TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
580 short_type_node
= make_signed_type (16);
581 pushdecl (build_decl (BUILTINS_LOCATION
,
582 TYPE_DECL
, get_identifier ("short"), short_type_node
));
583 int_type_node
= make_signed_type (32);
584 pushdecl (build_decl (BUILTINS_LOCATION
,
585 TYPE_DECL
, get_identifier ("int"), int_type_node
));
586 long_type_node
= make_signed_type (64);
587 pushdecl (build_decl (BUILTINS_LOCATION
,
588 TYPE_DECL
, get_identifier ("long"), long_type_node
));
590 unsigned_byte_type_node
= make_unsigned_type (8);
591 pushdecl (build_decl (BUILTINS_LOCATION
,
592 TYPE_DECL
, get_identifier ("unsigned byte"),
593 unsigned_byte_type_node
));
594 unsigned_short_type_node
= make_unsigned_type (16);
595 pushdecl (build_decl (BUILTINS_LOCATION
,
596 TYPE_DECL
, get_identifier ("unsigned short"),
597 unsigned_short_type_node
));
598 unsigned_int_type_node
= make_unsigned_type (32);
599 pushdecl (build_decl (BUILTINS_LOCATION
,
600 TYPE_DECL
, get_identifier ("unsigned int"),
601 unsigned_int_type_node
));
602 unsigned_long_type_node
= make_unsigned_type (64);
603 pushdecl (build_decl (BUILTINS_LOCATION
,
604 TYPE_DECL
, get_identifier ("unsigned long"),
605 unsigned_long_type_node
));
607 /* This is not a java type, however tree-dfa requires a definition for
609 if (strcmp (SIZE_TYPE
, "unsigned int") == 0)
610 size_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
611 else if (strcmp (SIZE_TYPE
, "long unsigned int") == 0)
612 size_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
613 else if (strcmp (SIZE_TYPE
, "long long unsigned int") == 0)
614 size_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
617 set_sizetype (size_type_node
);
619 /* Define these next since types below may used them. */
620 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
621 integer_zero_node
= build_int_cst (NULL_TREE
, 0);
622 integer_one_node
= build_int_cst (NULL_TREE
, 1);
623 integer_two_node
= build_int_cst (NULL_TREE
, 2);
624 integer_three_node
= build_int_cst (NULL_TREE
, 3);
625 integer_four_node
= build_int_cst (NULL_TREE
, 4);
626 integer_minus_one_node
= build_int_cst (NULL_TREE
, -1);
628 /* A few values used for range checking in the lexer. */
629 decimal_int_max
= build_int_cstu (unsigned_int_type_node
, 0x80000000);
631 = double_int_to_tree (unsigned_long_type_node
,
632 double_int_setbit (double_int_zero
, 64));
634 size_zero_node
= size_int (0);
635 size_one_node
= size_int (1);
636 bitsize_zero_node
= bitsize_int (0);
637 bitsize_one_node
= bitsize_int (1);
638 bitsize_unit_node
= bitsize_int (BITS_PER_UNIT
);
640 long_zero_node
= build_int_cst (long_type_node
, 0);
642 void_type_node
= make_node (VOID_TYPE
);
643 pushdecl (build_decl (BUILTINS_LOCATION
,
644 TYPE_DECL
, get_identifier ("void"), void_type_node
));
645 layout_type (void_type_node
); /* Uses size_zero_node */
647 ptr_type_node
= build_pointer_type (void_type_node
);
649 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
651 t
= make_node (VOID_TYPE
);
652 layout_type (t
); /* Uses size_zero_node */
653 return_address_type_node
= build_pointer_type (t
);
655 null_pointer_node
= build_int_cst (ptr_type_node
, 0);
657 char_type_node
= make_node (INTEGER_TYPE
);
658 TYPE_STRING_FLAG (char_type_node
) = 1;
659 TYPE_PRECISION (char_type_node
) = 16;
660 fixup_unsigned_type (char_type_node
);
661 pushdecl (build_decl (BUILTINS_LOCATION
,
662 TYPE_DECL
, get_identifier ("char"), char_type_node
));
664 boolean_type_node
= make_node (BOOLEAN_TYPE
);
665 TYPE_PRECISION (boolean_type_node
) = 1;
666 fixup_unsigned_type (boolean_type_node
);
667 pushdecl (build_decl (BUILTINS_LOCATION
,
668 TYPE_DECL
, get_identifier ("boolean"),
670 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
671 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
673 promoted_byte_type_node
674 = push_promoted_type ("promoted_byte", byte_type_node
);
675 promoted_short_type_node
676 = push_promoted_type ("promoted_short", short_type_node
);
677 promoted_char_type_node
678 = push_promoted_type ("promoted_char", char_type_node
);
679 promoted_boolean_type_node
680 = push_promoted_type ("promoted_boolean", boolean_type_node
);
682 float_type_node
= make_node (REAL_TYPE
);
683 TYPE_PRECISION (float_type_node
) = 32;
684 pushdecl (build_decl (BUILTINS_LOCATION
,
685 TYPE_DECL
, get_identifier ("float"),
687 layout_type (float_type_node
);
689 double_type_node
= make_node (REAL_TYPE
);
690 TYPE_PRECISION (double_type_node
) = 64;
691 pushdecl (build_decl (BUILTINS_LOCATION
,
692 TYPE_DECL
, get_identifier ("double"),
694 layout_type (double_type_node
);
696 float_zero_node
= build_real (float_type_node
, dconst0
);
697 double_zero_node
= build_real (double_type_node
, dconst0
);
699 /* These are the vtables for arrays of primitives. */
700 boolean_array_vtable
= create_primitive_vtable ("boolean");
701 byte_array_vtable
= create_primitive_vtable ("byte");
702 char_array_vtable
= create_primitive_vtable ("char");
703 short_array_vtable
= create_primitive_vtable ("short");
704 int_array_vtable
= create_primitive_vtable ("int");
705 long_array_vtable
= create_primitive_vtable ("long");
706 float_array_vtable
= create_primitive_vtable ("float");
707 double_array_vtable
= create_primitive_vtable ("double");
709 one_elt_array_domain_type
= build_index_type (integer_one_node
);
710 utf8const_type
= make_node (RECORD_TYPE
);
711 PUSH_FIELD (input_location
,
712 utf8const_type
, field
, "hash", unsigned_short_type_node
);
713 PUSH_FIELD (input_location
,
714 utf8const_type
, field
, "length", unsigned_short_type_node
);
715 FINISH_RECORD (utf8const_type
);
716 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
718 atable_type
= build_array_type (ptr_type_node
,
719 one_elt_array_domain_type
);
720 TYPE_NONALIASED_COMPONENT (atable_type
) = 1;
721 atable_ptr_type
= build_pointer_type (atable_type
);
723 itable_type
= build_array_type (ptr_type_node
,
724 one_elt_array_domain_type
);
725 TYPE_NONALIASED_COMPONENT (itable_type
) = 1;
726 itable_ptr_type
= build_pointer_type (itable_type
);
728 symbol_type
= make_node (RECORD_TYPE
);
729 PUSH_FIELD (input_location
,
730 symbol_type
, field
, "clname", utf8const_ptr_type
);
731 PUSH_FIELD (input_location
, symbol_type
, field
, "name", utf8const_ptr_type
);
732 PUSH_FIELD (input_location
,
733 symbol_type
, field
, "signature", utf8const_ptr_type
);
734 FINISH_RECORD (symbol_type
);
736 symbols_array_type
= build_array_type (symbol_type
,
737 one_elt_array_domain_type
);
738 symbols_array_ptr_type
= build_pointer_type (symbols_array_type
);
740 assertion_entry_type
= make_node (RECORD_TYPE
);
741 PUSH_FIELD (input_location
,
742 assertion_entry_type
, field
, "assertion_code", integer_type_node
);
743 PUSH_FIELD (input_location
,
744 assertion_entry_type
, field
, "op1", utf8const_ptr_type
);
745 PUSH_FIELD (input_location
,
746 assertion_entry_type
, field
, "op2", utf8const_ptr_type
);
747 FINISH_RECORD (assertion_entry_type
);
749 assertion_table_type
= build_array_type (assertion_entry_type
,
750 one_elt_array_domain_type
);
752 /* As you're adding items here, please update the code right after
753 this section, so that the filename containing the source code of
754 the pre-defined class gets registered correctly. */
755 unqualified_object_id_node
= get_identifier ("Object");
756 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
757 object_ptr_type_node
= promote_type (object_type_node
);
758 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
759 string_ptr_type_node
= promote_type (string_type_node
);
760 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
761 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
762 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
763 runtime_exception_type_node
=
764 lookup_class (get_identifier ("java.lang.RuntimeException"));
765 error_exception_type_node
=
766 lookup_class (get_identifier ("java.lang.Error"));
768 rawdata_ptr_type_node
769 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
771 add_predefined_file (get_identifier ("java/lang/Class.java"));
772 add_predefined_file (get_identifier ("java/lang/Error.java"));
773 add_predefined_file (get_identifier ("java/lang/Object.java"));
774 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
775 add_predefined_file (get_identifier ("java/lang/String.java"));
776 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
777 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
778 add_predefined_file (get_identifier ("java/lang/Exception.java"));
779 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
780 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
782 methodtable_type
= make_node (RECORD_TYPE
);
783 layout_type (methodtable_type
);
784 build_decl (BUILTINS_LOCATION
,
785 TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
786 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
788 TYPE_identifier_node
= get_identifier ("TYPE");
789 init_identifier_node
= get_identifier ("<init>");
790 clinit_identifier_node
= get_identifier ("<clinit>");
791 void_signature_node
= get_identifier ("()V");
792 finalize_identifier_node
= get_identifier ("finalize");
793 this_identifier_node
= get_identifier ("this");
795 java_lang_cloneable_identifier_node
= get_identifier ("java.lang.Cloneable");
796 java_io_serializable_identifier_node
=
797 get_identifier ("java.io.Serializable");
799 /* for lack of a better place to put this stub call */
800 init_expr_processing();
802 constants_type_node
= make_node (RECORD_TYPE
);
803 PUSH_FIELD (input_location
,
804 constants_type_node
, field
, "size", unsigned_int_type_node
);
805 PUSH_FIELD (input_location
,
806 constants_type_node
, field
, "tags", ptr_type_node
);
807 PUSH_FIELD (input_location
,
808 constants_type_node
, field
, "data", ptr_type_node
);
809 constants_data_field_decl_node
= field
;
810 FINISH_RECORD (constants_type_node
);
811 build_decl (BUILTINS_LOCATION
,
812 TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
814 access_flags_type_node
= unsigned_short_type_node
;
816 dtable_type
= make_node (RECORD_TYPE
);
817 dtable_ptr_type
= build_pointer_type (dtable_type
);
819 otable_type
= build_array_type (integer_type_node
,
820 one_elt_array_domain_type
);
821 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
822 otable_ptr_type
= build_pointer_type (otable_type
);
824 PUSH_FIELD (input_location
,
825 object_type_node
, field
, "vtable", dtable_ptr_type
);
826 DECL_FCONTEXT (field
) = object_type_node
;
827 TYPE_VFIELD (object_type_node
) = field
;
829 /* This isn't exactly true, but it is what we have in the source.
830 There is an unresolved issue here, which is whether the vtable
831 should be marked by the GC. */
832 if (! flag_hash_synchronization
)
833 PUSH_FIELD (input_location
, object_type_node
, field
, "sync_info",
834 build_pointer_type (object_type_node
));
835 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= DECL_CHAIN (t
))
836 FIELD_PRIVATE (t
) = 1;
837 FINISH_RECORD (object_type_node
);
839 field_type_node
= make_node (RECORD_TYPE
);
840 field_ptr_type_node
= build_pointer_type (field_type_node
);
841 method_type_node
= make_node (RECORD_TYPE
);
842 method_ptr_type_node
= build_pointer_type (method_type_node
);
844 set_super_info (0, class_type_node
, object_type_node
, 0);
845 set_super_info (0, string_type_node
, object_type_node
, 0);
846 class_ptr_type
= build_pointer_type (class_type_node
);
848 PUSH_FIELD (input_location
,
849 class_type_node
, field
, "next_or_version", class_ptr_type
);
850 PUSH_FIELD (input_location
,
851 class_type_node
, field
, "name", utf8const_ptr_type
);
852 PUSH_FIELD (input_location
,
853 class_type_node
, field
, "accflags", access_flags_type_node
);
854 PUSH_FIELD (input_location
,
855 class_type_node
, field
, "superclass", class_ptr_type
);
856 PUSH_FIELD (input_location
,
857 class_type_node
, field
, "constants", constants_type_node
);
858 constants_field_decl_node
= field
;
859 PUSH_FIELD (input_location
,
860 class_type_node
, field
, "methods", method_ptr_type_node
);
861 PUSH_FIELD (input_location
,
862 class_type_node
, field
, "method_count", short_type_node
);
863 PUSH_FIELD (input_location
,
864 class_type_node
, field
, "vtable_method_count", short_type_node
);
865 PUSH_FIELD (input_location
,
866 class_type_node
, field
, "fields", field_ptr_type_node
);
867 PUSH_FIELD (input_location
,
868 class_type_node
, field
, "size_in_bytes", int_type_node
);
869 PUSH_FIELD (input_location
,
870 class_type_node
, field
, "field_count", short_type_node
);
871 PUSH_FIELD (input_location
,
872 class_type_node
, field
, "static_field_count", short_type_node
);
873 PUSH_FIELD (input_location
,
874 class_type_node
, field
, "vtable", dtable_ptr_type
);
875 PUSH_FIELD (input_location
,
876 class_type_node
, field
, "otable", otable_ptr_type
);
877 PUSH_FIELD (input_location
,
878 class_type_node
, field
, "otable_syms",
879 symbols_array_ptr_type
);
880 PUSH_FIELD (input_location
,
881 class_type_node
, field
, "atable", atable_ptr_type
);
882 PUSH_FIELD (input_location
,
883 class_type_node
, field
, "atable_syms",
884 symbols_array_ptr_type
);
885 PUSH_FIELD (input_location
,
886 class_type_node
, field
, "itable", itable_ptr_type
);
887 PUSH_FIELD (input_location
, class_type_node
, field
, "itable_syms",
888 symbols_array_ptr_type
);
889 PUSH_FIELD (input_location
,
890 class_type_node
, field
, "catch_classes", ptr_type_node
);
891 PUSH_FIELD (input_location
, class_type_node
, field
, "interfaces",
892 build_pointer_type (class_ptr_type
));
893 PUSH_FIELD (input_location
, class_type_node
, field
, "loader", ptr_type_node
);
894 PUSH_FIELD (input_location
,
895 class_type_node
, field
, "interface_count", short_type_node
);
896 PUSH_FIELD (input_location
, class_type_node
, field
, "state", byte_type_node
);
897 PUSH_FIELD (input_location
, class_type_node
, field
, "thread", ptr_type_node
);
898 PUSH_FIELD (input_location
,
899 class_type_node
, field
, "depth", short_type_node
);
900 PUSH_FIELD (input_location
,
901 class_type_node
, field
, "ancestors", ptr_type_node
);
902 PUSH_FIELD (input_location
, class_type_node
, field
, "idt", ptr_type_node
);
903 PUSH_FIELD (input_location
,
904 class_type_node
, field
, "arrayclass", ptr_type_node
);
905 PUSH_FIELD (input_location
,
906 class_type_node
, field
, "protectionDomain", ptr_type_node
);
907 PUSH_FIELD (input_location
,
908 class_type_node
, field
, "assertion_table", ptr_type_node
);
909 PUSH_FIELD (input_location
,
910 class_type_node
, field
, "hack_signers", ptr_type_node
);
911 PUSH_FIELD (input_location
, class_type_node
, field
, "chain", ptr_type_node
);
912 PUSH_FIELD (input_location
,
913 class_type_node
, field
, "aux_info", ptr_type_node
);
914 PUSH_FIELD (input_location
, class_type_node
, field
, "engine", ptr_type_node
);
915 PUSH_FIELD (input_location
,
916 class_type_node
, field
, "reflection_data", ptr_type_node
);
917 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= DECL_CHAIN (t
))
918 FIELD_PRIVATE (t
) = 1;
919 push_super_field (class_type_node
, object_type_node
);
921 FINISH_RECORD (class_type_node
);
922 build_decl (BUILTINS_LOCATION
,
923 TYPE_DECL
, get_identifier ("Class"), class_type_node
);
925 field_info_union_node
= make_node (UNION_TYPE
);
926 PUSH_FIELD (input_location
,
927 field_info_union_node
, field
, "boffset", int_type_node
);
928 PUSH_FIELD (input_location
,
929 field_info_union_node
, field
, "addr", ptr_type_node
);
930 layout_type (field_info_union_node
);
932 PUSH_FIELD (input_location
,
933 field_type_node
, field
, "name", utf8const_ptr_type
);
934 PUSH_FIELD (input_location
, field_type_node
, field
, "type", class_ptr_type
);
935 PUSH_FIELD (input_location
,
936 field_type_node
, field
, "accflags", access_flags_type_node
);
937 PUSH_FIELD (input_location
,
938 field_type_node
, field
, "bsize", unsigned_short_type_node
);
939 PUSH_FIELD (input_location
,
940 field_type_node
, field
, "info", field_info_union_node
);
941 FINISH_RECORD (field_type_node
);
942 build_decl (BUILTINS_LOCATION
,
943 TYPE_DECL
, get_identifier ("Field"), field_type_node
);
945 nativecode_ptr_array_type_node
946 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
948 PUSH_FIELD (input_location
,
949 dtable_type
, field
, "class", class_ptr_type
);
950 PUSH_FIELD (input_location
,
951 dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
952 FINISH_RECORD (dtable_type
);
953 build_decl (BUILTINS_LOCATION
,
954 TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
956 jexception_type
= make_node (RECORD_TYPE
);
957 PUSH_FIELD (input_location
,
958 jexception_type
, field
, "start_pc", ptr_type_node
);
959 PUSH_FIELD (input_location
, jexception_type
, field
, "end_pc", ptr_type_node
);
960 PUSH_FIELD (input_location
,
961 jexception_type
, field
, "handler_pc", ptr_type_node
);
962 PUSH_FIELD (input_location
,
963 jexception_type
, field
, "catch_type", class_ptr_type
);
964 FINISH_RECORD (jexception_type
);
965 build_decl (BUILTINS_LOCATION
,
966 TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
967 jexception_ptr_type
= build_pointer_type (jexception_type
);
969 lineNumberEntry_type
= make_node (RECORD_TYPE
);
970 PUSH_FIELD (input_location
,
971 lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
972 PUSH_FIELD (input_location
,
973 lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
974 FINISH_RECORD (lineNumberEntry_type
);
976 lineNumbers_type
= make_node (RECORD_TYPE
);
977 PUSH_FIELD (input_location
,
978 lineNumbers_type
, field
, "length", unsigned_int_type_node
);
979 FINISH_RECORD (lineNumbers_type
);
981 PUSH_FIELD (input_location
,
982 method_type_node
, field
, "name", utf8const_ptr_type
);
983 PUSH_FIELD (input_location
,
984 method_type_node
, field
, "signature", utf8const_ptr_type
);
985 PUSH_FIELD (input_location
,
986 method_type_node
, field
, "accflags", access_flags_type_node
);
987 PUSH_FIELD (input_location
,
988 method_type_node
, field
, "index", unsigned_short_type_node
);
989 PUSH_FIELD (input_location
,
990 method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
991 PUSH_FIELD (input_location
,
992 method_type_node
, field
, "throws", ptr_type_node
);
993 FINISH_RECORD (method_type_node
);
994 build_decl (BUILTINS_LOCATION
,
995 TYPE_DECL
, get_identifier ("Method"), method_type_node
);
997 end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
999 t
= build_function_type_list (ptr_type_node
, class_ptr_type
, NULL_TREE
);
1000 alloc_object_node
= add_builtin_function ("_Jv_AllocObject", t
,
1001 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1002 DECL_IS_MALLOC (alloc_object_node
) = 1;
1003 alloc_no_finalizer_node
=
1004 add_builtin_function ("_Jv_AllocObjectNoFinalizer", t
,
1005 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1006 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
1008 t
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
1009 soft_initclass_node
= add_builtin_function ("_Jv_InitClass", t
,
1010 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1011 t
= build_function_type_list (ptr_type_node
,
1012 class_ptr_type
, int_type_node
, NULL_TREE
);
1013 soft_resolvepoolentry_node
1014 = add_builtin_function ("_Jv_ResolvePoolEntry", t
,
1015 0,NOT_BUILT_IN
, NULL
, NULL_TREE
);
1016 DECL_PURE_P (soft_resolvepoolentry_node
) = 1;
1017 t
= build_function_type_list (void_type_node
,
1018 class_ptr_type
, int_type_node
, NULL_TREE
);
1019 throw_node
= add_builtin_function ("_Jv_Throw", t
,
1020 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1021 /* Mark throw_nodes as `noreturn' functions with side effects. */
1022 TREE_THIS_VOLATILE (throw_node
) = 1;
1023 TREE_SIDE_EFFECTS (throw_node
) = 1;
1025 t
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
1026 soft_monitorenter_node
1027 = add_builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
1029 soft_monitorexit_node
1030 = add_builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
1033 t
= build_function_type_list (ptr_type_node
,
1034 ptr_type_node
, int_type_node
, NULL_TREE
);
1036 = add_builtin_function ("_Jv_NewPrimArray", t
,
1037 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1038 DECL_IS_MALLOC (soft_newarray_node
) = 1;
1040 t
= build_function_type_list (ptr_type_node
,
1041 int_type_node
, class_ptr_type
,
1042 object_ptr_type_node
, NULL_TREE
);
1044 = add_builtin_function ("_Jv_NewObjectArray", t
,
1045 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1046 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
1048 t
= build_varargs_function_type_list (ptr_type_node
,
1049 ptr_type_node
, int_type_node
,
1051 soft_multianewarray_node
1052 = add_builtin_function ("_Jv_NewMultiArray", t
,
1053 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1054 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
1056 t
= build_function_type_list (void_type_node
, int_type_node
, NULL_TREE
);
1057 soft_badarrayindex_node
1058 = add_builtin_function ("_Jv_ThrowBadArrayIndex", t
,
1059 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1060 /* Mark soft_badarrayindex_node as a `noreturn' function with side
1062 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
1063 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
1065 t
= build_function_type_list (void_type_node
, NULL_TREE
);
1066 soft_nullpointer_node
1067 = add_builtin_function ("_Jv_ThrowNullPointerException", t
,
1068 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1069 /* Mark soft_nullpointer_node as a `noreturn' function with side
1071 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
1072 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
1074 soft_abstractmethod_node
1075 = add_builtin_function ("_Jv_ThrowAbstractMethodError", t
,
1076 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1077 /* Mark soft_abstractmethod_node as a `noreturn' function with side
1079 TREE_THIS_VOLATILE (soft_abstractmethod_node
) = 1;
1080 TREE_SIDE_EFFECTS (soft_abstractmethod_node
) = 1;
1082 soft_nosuchfield_node
1083 = add_builtin_function ("_Jv_ThrowNoSuchFieldError", t
,
1084 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1085 /* Mark soft_nosuchfield_node as a `noreturn' function with side
1087 TREE_THIS_VOLATILE (soft_nosuchfield_node
) = 1;
1088 TREE_SIDE_EFFECTS (soft_nosuchfield_node
) = 1;
1090 t
= build_function_type_list (ptr_type_node
,
1091 class_ptr_type
, object_ptr_type_node
,
1094 = add_builtin_function ("_Jv_CheckCast", t
,
1095 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1096 t
= build_function_type_list (boolean_type_node
,
1097 object_ptr_type_node
, class_ptr_type
,
1099 soft_instanceof_node
1100 = add_builtin_function ("_Jv_IsInstanceOf", t
,
1101 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1102 DECL_PURE_P (soft_instanceof_node
) = 1;
1103 t
= build_function_type_list (void_type_node
,
1104 object_ptr_type_node
, object_ptr_type_node
,
1106 soft_checkarraystore_node
1107 = add_builtin_function ("_Jv_CheckArrayStore", t
,
1108 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1109 t
= build_function_type_list (ptr_type_node
,
1110 ptr_type_node
, ptr_type_node
, int_type_node
,
1112 soft_lookupinterfacemethod_node
1113 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", t
,
1114 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1115 DECL_PURE_P (soft_lookupinterfacemethod_node
) = 1;
1117 t
= build_function_type_list (ptr_type_node
,
1118 ptr_type_node
, ptr_type_node
, ptr_type_node
,
1120 soft_lookupinterfacemethodbyname_node
1121 = add_builtin_function ("_Jv_LookupInterfaceMethod", t
,
1122 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1123 t
= build_function_type_list (ptr_type_node
,
1124 object_ptr_type_node
, ptr_type_node
,
1125 ptr_type_node
, int_type_node
, NULL_TREE
);
1126 soft_lookupjnimethod_node
1127 = add_builtin_function ("_Jv_LookupJNIMethod", t
,
1128 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1129 t
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
1130 soft_getjnienvnewframe_node
1131 = add_builtin_function ("_Jv_GetJNIEnvNewFrame", t
,
1132 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1133 t
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
1134 soft_jnipopsystemframe_node
1135 = add_builtin_function ("_Jv_JNI_PopSystemFrame", t
,
1136 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1138 t
= build_function_type_list (object_ptr_type_node
,
1139 object_ptr_type_node
, NULL_TREE
);
1141 = add_builtin_function ("_Jv_UnwrapJNIweakReference", t
,
1142 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1144 t
= build_function_type_list (int_type_node
,
1145 int_type_node
, int_type_node
, NULL_TREE
);
1147 = add_builtin_function ("_Jv_divI", t
,
1148 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1151 = add_builtin_function ("_Jv_remI", t
,
1152 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1154 t
= build_function_type_list (long_type_node
,
1155 long_type_node
, long_type_node
, NULL_TREE
);
1157 = add_builtin_function ("_Jv_divJ", t
,
1158 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1161 = add_builtin_function ("_Jv_remJ", t
,
1162 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1164 initialize_builtins ();
1166 soft_fmod_node
= built_in_decls
[BUILT_IN_FMOD
];
1172 /* Look up NAME in the current binding level and its superiors
1173 in the namespace of variables, functions and typedefs.
1174 Return a ..._DECL node of some kind representing its definition,
1175 or return 0 if it is undefined. */
1178 lookup_name (tree name
)
1181 if (current_binding_level
!= global_binding_level
1182 && IDENTIFIER_LOCAL_VALUE (name
))
1183 val
= IDENTIFIER_LOCAL_VALUE (name
);
1185 val
= IDENTIFIER_GLOBAL_VALUE (name
);
1189 /* Similar to `lookup_name' but look only at current binding level and
1190 the previous one if it's the parameter level. */
1193 lookup_name_current_level (tree name
)
1197 if (current_binding_level
== global_binding_level
)
1198 return IDENTIFIER_GLOBAL_VALUE (name
);
1200 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
1203 for (t
= current_binding_level
->names
; t
; t
= DECL_CHAIN (t
))
1204 if (DECL_NAME (t
) == name
)
1210 /* Record a decl-node X as belonging to the current lexical scope.
1211 Check for errors (such as an incompatible declaration for the same
1212 name already seen in the same scope).
1214 Returns either X or an old decl for the same name.
1215 If an old decl is returned, it may have been smashed
1216 to agree with what X says. */
1222 tree name
= DECL_NAME (x
);
1223 struct binding_level
*b
= current_binding_level
;
1225 if (TREE_CODE (x
) != TYPE_DECL
)
1226 DECL_CONTEXT (x
) = current_function_decl
;
1229 t
= lookup_name_current_level (name
);
1230 if (t
!= 0 && t
== error_mark_node
)
1231 /* error_mark_node is 0 for a while during initialization! */
1234 error ("%q+D used prior to declaration", x
);
1237 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1238 to point to the TYPE_DECL.
1239 Since Java does not have typedefs, a type can only have
1240 one (true) name, given by a class, interface, or builtin. */
1241 if (TREE_CODE (x
) == TYPE_DECL
1242 && TYPE_NAME (TREE_TYPE (x
)) == 0
1243 && TREE_TYPE (x
) != error_mark_node
)
1245 TYPE_NAME (TREE_TYPE (x
)) = x
;
1246 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1249 /* This name is new in its binding level.
1250 Install the new declaration and return it. */
1251 if (b
== global_binding_level
)
1253 /* Install a global value. */
1255 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1259 /* Here to install a non-global value. */
1260 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1261 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1263 /* If storing a local value, there may already be one (inherited).
1264 If so, record it for restoration when this binding level ends. */
1266 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1270 /* Put decls on list in reverse order.
1271 We will reverse them later if necessary. */
1272 DECL_CHAIN (x
) = b
->names
;
1279 pushdecl_force_head (tree x
)
1281 current_binding_level
->names
= x
;
1284 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1287 pushdecl_top_level (tree x
)
1290 struct binding_level
*b
= current_binding_level
;
1292 current_binding_level
= global_binding_level
;
1294 current_binding_level
= b
;
1298 /* Like pushdecl, only it places X in FUNCTION_BINDING_LEVEL, if appropriate. */
1301 pushdecl_function_level (tree x
)
1304 struct binding_level
*b
= current_binding_level
;
1306 current_binding_level
= function_binding_level
;
1308 current_binding_level
= b
;
1312 /* Return true if we are in the global binding level. */
1315 global_bindings_p (void)
1317 return current_binding_level
== global_binding_level
;
1320 /* Return the list of declarations of the current level.
1321 Note that this list is in reverse order unless/until
1322 you nreverse it; and when you do nreverse it, you must
1323 store the result back using `storedecls' or you will lose. */
1328 return current_binding_level
->names
;
1331 /* Create a new `struct binding_level'. */
1333 static struct binding_level
*
1334 make_binding_level (void)
1337 return ggc_alloc_cleared_binding_level ();
1341 pushlevel (int unused ATTRIBUTE_UNUSED
)
1343 struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1345 /* Reuse or create a struct for this binding level. */
1347 if (free_binding_level
)
1349 newlevel
= free_binding_level
;
1350 free_binding_level
= free_binding_level
->level_chain
;
1354 newlevel
= make_binding_level ();
1357 /* Add this level to the front of the chain (stack) of levels that
1360 *newlevel
= clear_binding_level
;
1361 newlevel
->level_chain
= current_binding_level
;
1362 newlevel
->loc
= input_location
;
1363 current_binding_level
= newlevel
;
1364 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1365 newlevel
->binding_depth
= binding_depth
;
1367 fprintf (stderr
, "push %s level %p pc %d\n",
1368 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1371 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1374 /* Exit a binding level.
1375 Pop the level off, and restore the state of the identifier-decl mappings
1376 that were in effect when this level was entered.
1378 If KEEP is nonzero, this level had explicit declarations, so
1379 and create a "block" (a BLOCK node) for the level
1380 to record its declarations and subblocks for symbol table output.
1382 If FUNCTIONBODY is nonzero, this level is the body of a function,
1383 so create a block as if KEEP were set and also clear out all
1386 If REVERSE is nonzero, reverse the order of decls before putting
1387 them into the BLOCK. */
1390 poplevel (int keep
, int reverse
, int functionbody
)
1393 /* The chain of decls was accumulated in reverse order.
1394 Put it into forward order, just for cleanliness. */
1396 tree subblocks
= current_binding_level
->blocks
;
1401 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1404 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1405 fprintf (stderr
, "pop %s level %p pc %d (end pc %d)\n",
1406 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1407 current_binding_level
->end_pc
);
1409 fprintf (stderr
, "pop %s level %p pc %d\n",
1410 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1411 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1413 /* Get the decls in the order they were written.
1414 Usually current_binding_level->names is in reverse order.
1415 But parameter decls were previously put in forward order. */
1418 current_binding_level
->names
1419 = decls
= nreverse (current_binding_level
->names
);
1421 decls
= current_binding_level
->names
;
1423 for (decl
= decls
; decl
; decl
= DECL_CHAIN (decl
))
1424 if (TREE_CODE (decl
) == VAR_DECL
1425 && DECL_LANG_SPECIFIC (decl
) != NULL
1426 && DECL_LOCAL_SLOT_NUMBER (decl
))
1427 LOCAL_VAR_OUT_OF_SCOPE_P (decl
) = 1;
1429 /* If there were any declarations in that level,
1430 or if this level is a function body,
1431 create a BLOCK to record them for the life of this function. */
1434 if (keep
|| functionbody
)
1435 block
= make_node (BLOCK
);
1437 if (current_binding_level
->exception_range
)
1438 expand_end_java_handler (current_binding_level
->exception_range
);
1442 /* If any statements have been generated at this level, create a
1443 BIND_EXPR to hold them and copy the variables to it. This
1444 only applies to the bytecode compiler. */
1445 if (current_binding_level
->stmts
)
1448 tree
*var
= &BLOCK_VARS (block
);
1450 /* Copy decls from names list, ignoring labels. */
1453 tree next
= DECL_CHAIN (decl
);
1454 if (TREE_CODE (decl
) != LABEL_DECL
)
1457 var
= &DECL_CHAIN (decl
);
1463 bind
= build3 (BIND_EXPR
, void_type_node
, BLOCK_VARS (block
),
1464 BLOCK_EXPR_BODY (block
), block
);
1465 BIND_EXPR_BODY (bind
) = current_binding_level
->stmts
;
1467 if (BIND_EXPR_BODY (bind
)
1468 && TREE_SIDE_EFFECTS (BIND_EXPR_BODY (bind
)))
1469 TREE_SIDE_EFFECTS (bind
) = 1;
1471 /* FIXME: gimplifier brain damage. */
1472 if (BIND_EXPR_BODY (bind
) == NULL
)
1473 BIND_EXPR_BODY (bind
) = build_java_empty_stmt ();
1475 SET_EXPR_LOCATION (bind
, current_binding_level
->loc
);
1477 current_binding_level
->stmts
= NULL
;
1481 BLOCK_VARS (block
) = decls
;
1483 BLOCK_SUBBLOCKS (block
) = subblocks
;
1486 /* In each subblock, record that this is its superior. */
1488 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
1489 BLOCK_SUPERCONTEXT (link
) = block
;
1491 /* Clear out the meanings of the local variables of this level. */
1493 for (link
= decls
; link
; link
= DECL_CHAIN (link
))
1495 tree name
= DECL_NAME (link
);
1496 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1498 /* If the ident. was used or addressed via a local extern decl,
1499 don't forget that fact. */
1500 if (DECL_EXTERNAL (link
))
1502 if (TREE_USED (link
))
1503 TREE_USED (name
) = 1;
1504 if (TREE_ADDRESSABLE (link
))
1505 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1507 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1511 /* Restore all name-meanings of the outer levels
1512 that were shadowed by this level. */
1514 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1515 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1517 /* If the level being exited is the top level of a function,
1518 check over all the labels, and clear out the current
1519 (function local) meanings of their names. */
1523 /* If this is the top level block of a function,
1524 the vars are the function's parameters.
1525 Don't leave them in the BLOCK because they are
1526 found in the FUNCTION_DECL instead. */
1528 BLOCK_VARS (block
) = 0;
1531 /* Pop the current level, and free the structure for reuse. */
1534 struct binding_level
*level
= current_binding_level
;
1535 current_binding_level
= current_binding_level
->level_chain
;
1537 level
->level_chain
= free_binding_level
;
1538 free_binding_level
= level
;
1541 /* Dispose of the block that we just made inside some higher level. */
1544 DECL_INITIAL (current_function_decl
) = block
;
1545 DECL_SAVED_TREE (current_function_decl
) = bind
;
1551 current_binding_level
->blocks
1552 = block_chainon (current_binding_level
->blocks
, block
);
1554 /* If we did not make a block for the level just exited,
1555 any blocks made for inner levels
1556 (since they cannot be recorded as subblocks in that level)
1557 must be carried forward so they will later become subblocks
1558 of something else. */
1560 current_binding_level
->blocks
1561 = block_chainon (current_binding_level
->blocks
, subblocks
);
1564 java_add_stmt (bind
);
1568 TREE_USED (block
) = 1;
1573 maybe_pushlevels (int pc
)
1575 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1579 while (pending_local_decls
!= NULL_TREE
&&
1580 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1582 tree
*ptr
= &pending_local_decls
;
1583 tree decl
= *ptr
, next
;
1584 int end_pc
= DECL_LOCAL_END_PC (decl
);
1586 while (*ptr
!= NULL_TREE
1587 && DECL_LOCAL_START_PC (*ptr
) <= pc
1588 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1589 ptr
= &DECL_CHAIN (*ptr
);
1590 pending_local_decls
= *ptr
;
1593 /* Force non-nested range to be nested in current range by
1594 truncating variable lifetimes. */
1595 if (end_pc
> current_binding_level
->end_pc
)
1598 end_pc
= current_binding_level
->end_pc
;
1599 for (t
= decl
; t
!= NULL_TREE
; t
= DECL_CHAIN (t
))
1600 DECL_LOCAL_END_PC (t
) = end_pc
;
1603 maybe_start_try (pc
, end_pc
);
1607 current_binding_level
->end_pc
= end_pc
;
1608 current_binding_level
->start_pc
= pc
;
1609 current_binding_level
->names
= NULL
;
1610 for ( ; decl
!= NULL_TREE
; decl
= next
)
1612 int index
= DECL_LOCAL_SLOT_NUMBER (decl
);
1614 next
= DECL_CHAIN (decl
);
1615 push_jvm_slot (index
, decl
);
1618 = find_local_variable (index
, TREE_TYPE (decl
), pc
);
1619 if (TREE_CODE (TREE_TYPE (base_decl
)) == POINTER_TYPE
)
1620 base_decl
= TREE_VEC_ELT (base_decl_map
, index
);
1621 SET_DECL_VALUE_EXPR (decl
, base_decl
);
1622 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1626 maybe_start_try (pc
, 0);
1630 maybe_poplevels (int pc
)
1632 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1636 /* FIXME: I'm pretty sure that this is wrong. Variable scopes are
1637 inclusive, so a variable is live if pc == end_pc. Here, we
1638 terminate a range if the current pc is equal to the end of the
1639 range, and this is *before* we have generated code for the
1640 instruction at end_pc. We're closing a binding level one
1641 instruction too early.*/
1642 while (current_binding_level
->end_pc
<= pc
)
1646 /* Terminate any binding which began during the range beginning at
1647 start_pc. This tidies up improperly nested local variable ranges
1648 and exception handlers; a variable declared within an exception
1649 range is forcibly terminated when that exception ends. */
1652 force_poplevels (int start_pc
)
1654 while (current_binding_level
->start_pc
> start_pc
)
1656 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1657 warning (0, "In %+D: overlapped variable and exception ranges at %d",
1658 current_function_decl
,
1659 current_binding_level
->start_pc
);
1664 /* integrate_decl_tree calls this function. */
1667 java_dup_lang_specific_decl (tree node
)
1670 struct lang_decl
*x
;
1672 if (!DECL_LANG_SPECIFIC (node
))
1675 lang_decl_size
= sizeof (struct lang_decl
);
1676 x
= ggc_alloc_lang_decl (lang_decl_size
);
1677 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1678 DECL_LANG_SPECIFIC (node
) = x
;
1682 give_name_to_locals (JCF
*jcf
)
1684 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1685 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1687 pending_local_decls
= NULL_TREE
;
1691 n
= JCF_readu2 (jcf
);
1692 for (i
= 0; i
< n
; i
++)
1694 int start_pc
= JCF_readu2 (jcf
);
1695 int length
= JCF_readu2 (jcf
);
1696 int name_index
= JCF_readu2 (jcf
);
1697 int signature_index
= JCF_readu2 (jcf
);
1698 int slot
= JCF_readu2 (jcf
);
1699 tree name
= get_name_constant (jcf
, name_index
);
1700 tree type
= parse_signature (jcf
, signature_index
);
1701 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1703 && length
== DECL_CODE_LENGTH (current_function_decl
))
1705 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1706 DECL_NAME (decl
) = name
;
1707 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1708 warning (0, "bad type in parameter debug info");
1713 int end_pc
= start_pc
+ length
;
1714 tree decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
1715 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1717 warning (0, "bad PC range for debug info for local %q+D",
1719 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1722 /* Adjust start_pc if necessary so that the local's first
1723 store operation will use the relevant DECL as a
1724 destination. Fore more information, read the leading
1725 comments for expr.c:maybe_adjust_start_pc. */
1726 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1728 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1729 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1730 DECL_LOCAL_START_PC (decl
) = start_pc
;
1731 DECL_LOCAL_END_PC (decl
) = end_pc
;
1733 /* Now insert the new decl in the proper place in
1734 pending_local_decls. We are essentially doing an insertion sort,
1735 which works fine, since the list input will normally already
1737 ptr
= &pending_local_decls
;
1738 while (*ptr
!= NULL_TREE
1739 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1740 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1741 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1742 ptr
= &DECL_CHAIN (*ptr
);
1743 DECL_CHAIN (decl
) = *ptr
;
1748 pending_local_decls
= nreverse (pending_local_decls
);
1750 /* Fill in default names for the parameters. */
1751 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1752 parm
!= NULL_TREE
; parm
= DECL_CHAIN (parm
), i
++)
1754 if (DECL_NAME (parm
) == NULL_TREE
)
1756 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1758 DECL_NAME (parm
) = get_identifier ("this");
1762 sprintf (buffer
, "ARG_%d", arg_i
);
1763 DECL_NAME (parm
) = get_identifier (buffer
);
1770 build_result_decl (tree fndecl
)
1772 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1773 tree result
= DECL_RESULT (fndecl
);
1776 result
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
1777 RESULT_DECL
, NULL_TREE
, restype
);
1778 DECL_ARTIFICIAL (result
) = 1;
1779 DECL_IGNORED_P (result
) = 1;
1780 DECL_CONTEXT (result
) = fndecl
;
1781 DECL_RESULT (fndecl
) = result
;
1787 start_java_method (tree fndecl
)
1794 current_function_decl
= fndecl
;
1795 announce_function (fndecl
);
1797 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1798 decl_map
= make_tree_vec (i
);
1799 base_decl_map
= make_tree_vec (i
);
1800 type_map
= XRESIZEVEC (tree
, type_map
, i
);
1802 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1803 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1805 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1806 pushlevel (1); /* Push parameters. */
1808 ptr
= &DECL_ARGUMENTS (fndecl
);
1809 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1810 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1812 tree parm_name
= NULL_TREE
, parm_decl
;
1813 tree parm_type
= TREE_VALUE (tem
);
1814 gcc_assert (i
< DECL_MAX_LOCALS (fndecl
));
1816 parm_decl
= build_decl (input_location
, PARM_DECL
, parm_name
, parm_type
);
1817 DECL_CONTEXT (parm_decl
) = fndecl
;
1818 if (targetm
.calls
.promote_prototypes (parm_type
)
1819 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1820 && INTEGRAL_TYPE_P (parm_type
))
1821 parm_type
= integer_type_node
;
1822 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1825 ptr
= &DECL_CHAIN (parm_decl
);
1827 /* Add parm_decl to the decl_map. */
1828 push_jvm_slot (i
, parm_decl
);
1830 /* The this parameter of methods is artificial. */
1831 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
&& i
== 0)
1832 DECL_ARTIFICIAL (parm_decl
) = 1;
1834 type_map
[i
] = TREE_TYPE (parm_decl
);
1835 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1838 type_map
[i
] = void_type_node
;
1842 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1844 while (i
< DECL_MAX_LOCALS(fndecl
))
1845 type_map
[i
++] = NULL_TREE
;
1847 build_result_decl (fndecl
);
1848 DECL_SOURCE_LOCATION (fndecl
) = input_location
;
1850 /* Push local variables. */
1853 function_binding_level
= current_binding_level
;
1857 end_java_method (void)
1859 tree fndecl
= current_function_decl
;
1861 /* pop out of function */
1864 /* pop out of its parameters */
1867 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1869 if (DECL_SAVED_TREE (fndecl
))
1871 tree fbody
, block_body
;
1872 /* Before we check initialization, attached all class initialization
1873 variable to the block_body */
1874 fbody
= DECL_SAVED_TREE (fndecl
);
1875 block_body
= BIND_EXPR_BODY (fbody
);
1876 htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (fndecl
),
1877 attach_init_test_initialization_flags
, block_body
);
1880 finish_method (fndecl
);
1882 current_function_decl
= NULL_TREE
;
1883 base_decl_map
= NULL_TREE
;
1886 /* Prepare a method for expansion. */
1889 finish_method (tree fndecl
)
1891 tree
*tp
= &DECL_SAVED_TREE (fndecl
);
1893 /* Wrap body of synchronized methods in a monitorenter,
1894 plus monitorexit cleanup. */
1895 if (METHOD_SYNCHRONIZED (fndecl
))
1897 tree enter
, exit
, lock
;
1898 if (METHOD_STATIC (fndecl
))
1899 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1901 lock
= DECL_ARGUMENTS (fndecl
);
1902 BUILD_MONITOR_ENTER (enter
, lock
);
1903 BUILD_MONITOR_EXIT (exit
, lock
);
1904 *tp
= build2 (COMPOUND_EXPR
, void_type_node
, enter
,
1905 build2 (TRY_FINALLY_EXPR
, void_type_node
, *tp
, exit
));
1908 /* Convert function tree to GENERIC prior to inlining. */
1909 java_genericize (fndecl
);
1911 /* Store the end of the function, so that we get good line number
1912 info for the epilogue. */
1913 if (DECL_STRUCT_FUNCTION (fndecl
))
1914 set_cfun (DECL_STRUCT_FUNCTION (fndecl
));
1916 allocate_struct_function (fndecl
, false);
1917 cfun
->function_end_locus
= DECL_FUNCTION_LAST_LINE (fndecl
);
1919 /* Defer inlining and expansion to the cgraph optimizers. */
1920 cgraph_finalize_function (fndecl
, false);
1923 /* We pessimistically marked all methods and fields external until we
1924 knew what set of classes we were planning to compile. Now mark those
1925 associated with CLASS to be generated locally as not external. */
1928 java_mark_decl_local (tree decl
)
1930 DECL_EXTERNAL (decl
) = 0;
1932 #ifdef ENABLE_CHECKING
1933 /* Double check that we didn't pass the function to the callgraph early. */
1934 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1936 struct cgraph_node
*node
= cgraph_get_node (decl
);
1937 gcc_assert (!node
|| !node
->local
.finalized
);
1940 gcc_assert (!DECL_RTL_SET_P (decl
));
1943 /* Given appropriate target support, G++ will emit hidden aliases for native
1944 methods. Using this hidden name is required for proper operation of
1945 _Jv_Method::ncode, but it doesn't hurt to use it everywhere. Look for
1946 proper target support, then mark the method for aliasing. */
1949 java_mark_cni_decl_local (tree decl
)
1951 #if !defined(HAVE_GAS_HIDDEN) || !defined(ASM_OUTPUT_DEF)
1955 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
1956 DECL_LOCAL_CNI_METHOD_P (decl
) = 1;
1958 /* Setting DECL_LOCAL_CNI_METHOD_P changes the behavior of the
1959 mangler. We might have already referenced this native method and
1960 therefore created its name, but even if we have it won't hurt.
1961 We'll just go via its externally visible name, rather than its
1962 hidden alias. However, we must force things so that the correct
1963 mangling is done. */
1965 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
1966 java_mangle_decl (decl
);
1967 if (DECL_RTL_SET_P (decl
))
1969 SET_DECL_RTL (decl
, 0);
1970 make_decl_rtl (decl
);
1974 /* Use the preceding two functions and mark all members of the class. */
1977 java_mark_class_local (tree klass
)
1981 for (t
= TYPE_FIELDS (klass
); t
; t
= DECL_CHAIN (t
))
1982 if (FIELD_STATIC (t
))
1984 if (DECL_EXTERNAL (t
))
1985 VEC_safe_push (tree
, gc
, pending_static_fields
, t
);
1986 java_mark_decl_local (t
);
1989 for (t
= TYPE_METHODS (klass
); t
; t
= DECL_CHAIN (t
))
1990 if (!METHOD_ABSTRACT (t
))
1992 if (METHOD_NATIVE (t
) && !flag_jni
)
1993 java_mark_cni_decl_local (t
);
1995 java_mark_decl_local (t
);
1999 /* Add a statement to a compound_expr. */
2002 add_stmt_to_compound (tree existing
, tree type
, tree stmt
)
2008 tree expr
= build2 (COMPOUND_EXPR
, type
, existing
, stmt
);
2009 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (existing
)
2010 | TREE_SIDE_EFFECTS (stmt
);
2017 /* If this node is an expr, mark its input location. Called from
2021 set_input_location (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
2022 void *data ATTRIBUTE_UNUSED
)
2026 if (CAN_HAVE_LOCATION_P (t
))
2028 if (EXPR_HAS_LOCATION(t
))
2029 return t
; /* Don't walk any further into this expr. */
2031 SET_EXPR_LOCATION (t
, input_location
);
2034 return NULL_TREE
; /* Continue walking this expr. */
2037 /* Add a statement to the statement_list currently being constructed.
2038 If the statement_list is null, we don't create a singleton list.
2039 This is necessary because poplevel() assumes that adding a
2040 statement to a null statement_list returns the statement. */
2043 java_add_stmt (tree new_stmt
)
2045 tree stmts
= current_binding_level
->stmts
;
2046 tree_stmt_iterator i
;
2049 walk_tree (&new_stmt
, set_input_location
, NULL
, NULL
);
2052 return current_binding_level
->stmts
= new_stmt
;
2054 /* Force STMTS to be a statement_list. */
2055 if (TREE_CODE (stmts
) != STATEMENT_LIST
)
2057 tree t
= make_node (STATEMENT_LIST
);
2059 tsi_link_after (&i
, stmts
, TSI_CONTINUE_LINKING
);
2063 i
= tsi_last (stmts
);
2064 tsi_link_after (&i
, new_stmt
, TSI_CONTINUE_LINKING
);
2065 TREE_TYPE (stmts
) = void_type_node
;
2067 return current_binding_level
->stmts
= stmts
;
2070 /* Add a variable to the current scope. */
2073 java_add_local_var (tree decl
)
2075 tree
*vars
= ¤t_binding_level
->names
;
2077 DECL_CHAIN (decl
) = next
;
2079 DECL_CONTEXT (decl
) = current_function_decl
;
2080 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2084 /* Return a pointer to the compound_expr currently being
2090 return ¤t_binding_level
->stmts
;
2093 /* Register an exception range as belonging to the current binding
2094 level. There may only be one: if there are more, we'll create more
2095 binding levels. However, each range can have multiple handlers,
2096 and these are expanded when we call expand_end_java_handler(). */
2099 register_exception_range (struct eh_range
*range
, int pc
, int end_pc
)
2101 gcc_assert (! current_binding_level
->exception_range
);
2102 current_binding_level
->exception_range
= range
;
2103 current_binding_level
->end_pc
= end_pc
;
2104 current_binding_level
->start_pc
= pc
;
2107 #include "gt-java-decl.h"