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 /* Build common tree nodes, Java has an unsigned char. */
570 build_common_tree_nodes (false);
572 /* Build the rest of the common tree nodes. */
573 build_common_tree_nodes_2 (0);
575 /* ??? Now we continue and override some of the built types again
576 with Java specific types. As the above generated types are
577 supposed to match the targets C ABI this isn't really the way
578 to go and any Java specifics should _not_ use those global types
579 if the Java ABI does not match the C one. */
581 byte_type_node
= make_signed_type (8);
582 pushdecl (build_decl (BUILTINS_LOCATION
,
583 TYPE_DECL
, get_identifier ("byte"), byte_type_node
));
584 short_type_node
= make_signed_type (16);
585 pushdecl (build_decl (BUILTINS_LOCATION
,
586 TYPE_DECL
, get_identifier ("short"), short_type_node
));
587 int_type_node
= make_signed_type (32);
588 pushdecl (build_decl (BUILTINS_LOCATION
,
589 TYPE_DECL
, get_identifier ("int"), int_type_node
));
590 long_type_node
= make_signed_type (64);
591 pushdecl (build_decl (BUILTINS_LOCATION
,
592 TYPE_DECL
, get_identifier ("long"), long_type_node
));
594 unsigned_byte_type_node
= make_unsigned_type (8);
595 pushdecl (build_decl (BUILTINS_LOCATION
,
596 TYPE_DECL
, get_identifier ("unsigned byte"),
597 unsigned_byte_type_node
));
598 unsigned_short_type_node
= make_unsigned_type (16);
599 pushdecl (build_decl (BUILTINS_LOCATION
,
600 TYPE_DECL
, get_identifier ("unsigned short"),
601 unsigned_short_type_node
));
602 unsigned_int_type_node
= make_unsigned_type (32);
603 pushdecl (build_decl (BUILTINS_LOCATION
,
604 TYPE_DECL
, get_identifier ("unsigned int"),
605 unsigned_int_type_node
));
606 unsigned_long_type_node
= make_unsigned_type (64);
607 pushdecl (build_decl (BUILTINS_LOCATION
,
608 TYPE_DECL
, get_identifier ("unsigned long"),
609 unsigned_long_type_node
));
611 /* Define these next since types below may used them. */
612 integer_type_node
= java_type_for_size (INT_TYPE_SIZE
, 0);
613 integer_zero_node
= build_int_cst (NULL_TREE
, 0);
614 integer_one_node
= build_int_cst (NULL_TREE
, 1);
615 integer_two_node
= build_int_cst (NULL_TREE
, 2);
616 integer_three_node
= build_int_cst (NULL_TREE
, 3);
617 integer_four_node
= build_int_cst (NULL_TREE
, 4);
618 integer_minus_one_node
= build_int_cst (NULL_TREE
, -1);
620 /* A few values used for range checking in the lexer. */
621 decimal_int_max
= build_int_cstu (unsigned_int_type_node
, 0x80000000);
623 = double_int_to_tree (unsigned_long_type_node
,
624 double_int_setbit (double_int_zero
, 64));
626 long_zero_node
= build_int_cst (long_type_node
, 0);
628 pushdecl (build_decl (BUILTINS_LOCATION
,
629 TYPE_DECL
, get_identifier ("void"), void_type_node
));
631 t
= make_node (VOID_TYPE
);
632 layout_type (t
); /* Uses size_zero_node */
633 return_address_type_node
= build_pointer_type (t
);
635 char_type_node
= make_unsigned_type (16);
636 TYPE_STRING_FLAG (char_type_node
) = 1;
637 pushdecl (build_decl (BUILTINS_LOCATION
,
638 TYPE_DECL
, get_identifier ("char"), char_type_node
));
640 boolean_type_node
= make_unsigned_type (1);
641 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
642 pushdecl (build_decl (BUILTINS_LOCATION
,
643 TYPE_DECL
, get_identifier ("boolean"),
645 boolean_false_node
= TYPE_MIN_VALUE (boolean_type_node
);
646 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
648 promoted_byte_type_node
649 = push_promoted_type ("promoted_byte", byte_type_node
);
650 promoted_short_type_node
651 = push_promoted_type ("promoted_short", short_type_node
);
652 promoted_char_type_node
653 = push_promoted_type ("promoted_char", char_type_node
);
654 promoted_boolean_type_node
655 = push_promoted_type ("promoted_boolean", boolean_type_node
);
657 float_type_node
= make_node (REAL_TYPE
);
658 TYPE_PRECISION (float_type_node
) = 32;
659 pushdecl (build_decl (BUILTINS_LOCATION
,
660 TYPE_DECL
, get_identifier ("float"),
662 layout_type (float_type_node
);
664 double_type_node
= make_node (REAL_TYPE
);
665 TYPE_PRECISION (double_type_node
) = 64;
666 pushdecl (build_decl (BUILTINS_LOCATION
,
667 TYPE_DECL
, get_identifier ("double"),
669 layout_type (double_type_node
);
671 float_zero_node
= build_real (float_type_node
, dconst0
);
672 double_zero_node
= build_real (double_type_node
, dconst0
);
674 /* These are the vtables for arrays of primitives. */
675 boolean_array_vtable
= create_primitive_vtable ("boolean");
676 byte_array_vtable
= create_primitive_vtable ("byte");
677 char_array_vtable
= create_primitive_vtable ("char");
678 short_array_vtable
= create_primitive_vtable ("short");
679 int_array_vtable
= create_primitive_vtable ("int");
680 long_array_vtable
= create_primitive_vtable ("long");
681 float_array_vtable
= create_primitive_vtable ("float");
682 double_array_vtable
= create_primitive_vtable ("double");
684 one_elt_array_domain_type
= build_index_type (integer_one_node
);
685 utf8const_type
= make_node (RECORD_TYPE
);
686 PUSH_FIELD (input_location
,
687 utf8const_type
, field
, "hash", unsigned_short_type_node
);
688 PUSH_FIELD (input_location
,
689 utf8const_type
, field
, "length", unsigned_short_type_node
);
690 FINISH_RECORD (utf8const_type
);
691 utf8const_ptr_type
= build_pointer_type (utf8const_type
);
693 atable_type
= build_array_type (ptr_type_node
,
694 one_elt_array_domain_type
);
695 TYPE_NONALIASED_COMPONENT (atable_type
) = 1;
696 atable_ptr_type
= build_pointer_type (atable_type
);
698 itable_type
= build_array_type (ptr_type_node
,
699 one_elt_array_domain_type
);
700 TYPE_NONALIASED_COMPONENT (itable_type
) = 1;
701 itable_ptr_type
= build_pointer_type (itable_type
);
703 symbol_type
= make_node (RECORD_TYPE
);
704 PUSH_FIELD (input_location
,
705 symbol_type
, field
, "clname", utf8const_ptr_type
);
706 PUSH_FIELD (input_location
, symbol_type
, field
, "name", utf8const_ptr_type
);
707 PUSH_FIELD (input_location
,
708 symbol_type
, field
, "signature", utf8const_ptr_type
);
709 FINISH_RECORD (symbol_type
);
711 symbols_array_type
= build_array_type (symbol_type
,
712 one_elt_array_domain_type
);
713 symbols_array_ptr_type
= build_pointer_type (symbols_array_type
);
715 assertion_entry_type
= make_node (RECORD_TYPE
);
716 PUSH_FIELD (input_location
,
717 assertion_entry_type
, field
, "assertion_code", integer_type_node
);
718 PUSH_FIELD (input_location
,
719 assertion_entry_type
, field
, "op1", utf8const_ptr_type
);
720 PUSH_FIELD (input_location
,
721 assertion_entry_type
, field
, "op2", utf8const_ptr_type
);
722 FINISH_RECORD (assertion_entry_type
);
724 assertion_table_type
= build_array_type (assertion_entry_type
,
725 one_elt_array_domain_type
);
727 /* As you're adding items here, please update the code right after
728 this section, so that the filename containing the source code of
729 the pre-defined class gets registered correctly. */
730 unqualified_object_id_node
= get_identifier ("Object");
731 object_type_node
= lookup_class (get_identifier ("java.lang.Object"));
732 object_ptr_type_node
= promote_type (object_type_node
);
733 string_type_node
= lookup_class (get_identifier ("java.lang.String"));
734 string_ptr_type_node
= promote_type (string_type_node
);
735 class_type_node
= lookup_class (get_identifier ("java.lang.Class"));
736 throwable_type_node
= lookup_class (get_identifier ("java.lang.Throwable"));
737 exception_type_node
= lookup_class (get_identifier ("java.lang.Exception"));
738 runtime_exception_type_node
=
739 lookup_class (get_identifier ("java.lang.RuntimeException"));
740 error_exception_type_node
=
741 lookup_class (get_identifier ("java.lang.Error"));
743 rawdata_ptr_type_node
744 = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
746 add_predefined_file (get_identifier ("java/lang/Class.java"));
747 add_predefined_file (get_identifier ("java/lang/Error.java"));
748 add_predefined_file (get_identifier ("java/lang/Object.java"));
749 add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
750 add_predefined_file (get_identifier ("java/lang/String.java"));
751 add_predefined_file (get_identifier ("java/lang/Throwable.java"));
752 add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
753 add_predefined_file (get_identifier ("java/lang/Exception.java"));
754 add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
755 add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
757 methodtable_type
= make_node (RECORD_TYPE
);
758 layout_type (methodtable_type
);
759 build_decl (BUILTINS_LOCATION
,
760 TYPE_DECL
, get_identifier ("methodtable"), methodtable_type
);
761 methodtable_ptr_type
= build_pointer_type (methodtable_type
);
763 TYPE_identifier_node
= get_identifier ("TYPE");
764 init_identifier_node
= get_identifier ("<init>");
765 clinit_identifier_node
= get_identifier ("<clinit>");
766 void_signature_node
= get_identifier ("()V");
767 finalize_identifier_node
= get_identifier ("finalize");
768 this_identifier_node
= get_identifier ("this");
770 java_lang_cloneable_identifier_node
= get_identifier ("java.lang.Cloneable");
771 java_io_serializable_identifier_node
=
772 get_identifier ("java.io.Serializable");
774 /* for lack of a better place to put this stub call */
775 init_expr_processing();
777 constants_type_node
= make_node (RECORD_TYPE
);
778 PUSH_FIELD (input_location
,
779 constants_type_node
, field
, "size", unsigned_int_type_node
);
780 PUSH_FIELD (input_location
,
781 constants_type_node
, field
, "tags", ptr_type_node
);
782 PUSH_FIELD (input_location
,
783 constants_type_node
, field
, "data", ptr_type_node
);
784 constants_data_field_decl_node
= field
;
785 FINISH_RECORD (constants_type_node
);
786 build_decl (BUILTINS_LOCATION
,
787 TYPE_DECL
, get_identifier ("constants"), constants_type_node
);
789 access_flags_type_node
= unsigned_short_type_node
;
791 dtable_type
= make_node (RECORD_TYPE
);
792 dtable_ptr_type
= build_pointer_type (dtable_type
);
794 otable_type
= build_array_type (integer_type_node
,
795 one_elt_array_domain_type
);
796 TYPE_NONALIASED_COMPONENT (otable_type
) = 1;
797 otable_ptr_type
= build_pointer_type (otable_type
);
799 PUSH_FIELD (input_location
,
800 object_type_node
, field
, "vtable", dtable_ptr_type
);
801 DECL_FCONTEXT (field
) = object_type_node
;
802 TYPE_VFIELD (object_type_node
) = field
;
804 /* This isn't exactly true, but it is what we have in the source.
805 There is an unresolved issue here, which is whether the vtable
806 should be marked by the GC. */
807 if (! flag_hash_synchronization
)
808 PUSH_FIELD (input_location
, object_type_node
, field
, "sync_info",
809 build_pointer_type (object_type_node
));
810 for (t
= TYPE_FIELDS (object_type_node
); t
!= NULL_TREE
; t
= DECL_CHAIN (t
))
811 FIELD_PRIVATE (t
) = 1;
812 FINISH_RECORD (object_type_node
);
814 field_type_node
= make_node (RECORD_TYPE
);
815 field_ptr_type_node
= build_pointer_type (field_type_node
);
816 method_type_node
= make_node (RECORD_TYPE
);
817 method_ptr_type_node
= build_pointer_type (method_type_node
);
819 set_super_info (0, class_type_node
, object_type_node
, 0);
820 set_super_info (0, string_type_node
, object_type_node
, 0);
821 class_ptr_type
= build_pointer_type (class_type_node
);
823 PUSH_FIELD (input_location
,
824 class_type_node
, field
, "next_or_version", class_ptr_type
);
825 PUSH_FIELD (input_location
,
826 class_type_node
, field
, "name", utf8const_ptr_type
);
827 PUSH_FIELD (input_location
,
828 class_type_node
, field
, "accflags", access_flags_type_node
);
829 PUSH_FIELD (input_location
,
830 class_type_node
, field
, "superclass", class_ptr_type
);
831 PUSH_FIELD (input_location
,
832 class_type_node
, field
, "constants", constants_type_node
);
833 constants_field_decl_node
= field
;
834 PUSH_FIELD (input_location
,
835 class_type_node
, field
, "methods", method_ptr_type_node
);
836 PUSH_FIELD (input_location
,
837 class_type_node
, field
, "method_count", short_type_node
);
838 PUSH_FIELD (input_location
,
839 class_type_node
, field
, "vtable_method_count", short_type_node
);
840 PUSH_FIELD (input_location
,
841 class_type_node
, field
, "fields", field_ptr_type_node
);
842 PUSH_FIELD (input_location
,
843 class_type_node
, field
, "size_in_bytes", int_type_node
);
844 PUSH_FIELD (input_location
,
845 class_type_node
, field
, "field_count", short_type_node
);
846 PUSH_FIELD (input_location
,
847 class_type_node
, field
, "static_field_count", short_type_node
);
848 PUSH_FIELD (input_location
,
849 class_type_node
, field
, "vtable", dtable_ptr_type
);
850 PUSH_FIELD (input_location
,
851 class_type_node
, field
, "otable", otable_ptr_type
);
852 PUSH_FIELD (input_location
,
853 class_type_node
, field
, "otable_syms",
854 symbols_array_ptr_type
);
855 PUSH_FIELD (input_location
,
856 class_type_node
, field
, "atable", atable_ptr_type
);
857 PUSH_FIELD (input_location
,
858 class_type_node
, field
, "atable_syms",
859 symbols_array_ptr_type
);
860 PUSH_FIELD (input_location
,
861 class_type_node
, field
, "itable", itable_ptr_type
);
862 PUSH_FIELD (input_location
, class_type_node
, field
, "itable_syms",
863 symbols_array_ptr_type
);
864 PUSH_FIELD (input_location
,
865 class_type_node
, field
, "catch_classes", ptr_type_node
);
866 PUSH_FIELD (input_location
, class_type_node
, field
, "interfaces",
867 build_pointer_type (class_ptr_type
));
868 PUSH_FIELD (input_location
, class_type_node
, field
, "loader", ptr_type_node
);
869 PUSH_FIELD (input_location
,
870 class_type_node
, field
, "interface_count", short_type_node
);
871 PUSH_FIELD (input_location
, class_type_node
, field
, "state", byte_type_node
);
872 PUSH_FIELD (input_location
, class_type_node
, field
, "thread", ptr_type_node
);
873 PUSH_FIELD (input_location
,
874 class_type_node
, field
, "depth", short_type_node
);
875 PUSH_FIELD (input_location
,
876 class_type_node
, field
, "ancestors", ptr_type_node
);
877 PUSH_FIELD (input_location
, class_type_node
, field
, "idt", ptr_type_node
);
878 PUSH_FIELD (input_location
,
879 class_type_node
, field
, "arrayclass", ptr_type_node
);
880 PUSH_FIELD (input_location
,
881 class_type_node
, field
, "protectionDomain", ptr_type_node
);
882 PUSH_FIELD (input_location
,
883 class_type_node
, field
, "assertion_table", ptr_type_node
);
884 PUSH_FIELD (input_location
,
885 class_type_node
, field
, "hack_signers", ptr_type_node
);
886 PUSH_FIELD (input_location
, class_type_node
, field
, "chain", ptr_type_node
);
887 PUSH_FIELD (input_location
,
888 class_type_node
, field
, "aux_info", ptr_type_node
);
889 PUSH_FIELD (input_location
, class_type_node
, field
, "engine", ptr_type_node
);
890 PUSH_FIELD (input_location
,
891 class_type_node
, field
, "reflection_data", ptr_type_node
);
892 for (t
= TYPE_FIELDS (class_type_node
); t
!= NULL_TREE
; t
= DECL_CHAIN (t
))
893 FIELD_PRIVATE (t
) = 1;
894 push_super_field (class_type_node
, object_type_node
);
896 FINISH_RECORD (class_type_node
);
897 build_decl (BUILTINS_LOCATION
,
898 TYPE_DECL
, get_identifier ("Class"), class_type_node
);
900 field_info_union_node
= make_node (UNION_TYPE
);
901 PUSH_FIELD (input_location
,
902 field_info_union_node
, field
, "boffset", int_type_node
);
903 PUSH_FIELD (input_location
,
904 field_info_union_node
, field
, "addr", ptr_type_node
);
905 layout_type (field_info_union_node
);
907 PUSH_FIELD (input_location
,
908 field_type_node
, field
, "name", utf8const_ptr_type
);
909 PUSH_FIELD (input_location
, field_type_node
, field
, "type", class_ptr_type
);
910 PUSH_FIELD (input_location
,
911 field_type_node
, field
, "accflags", access_flags_type_node
);
912 PUSH_FIELD (input_location
,
913 field_type_node
, field
, "bsize", unsigned_short_type_node
);
914 PUSH_FIELD (input_location
,
915 field_type_node
, field
, "info", field_info_union_node
);
916 FINISH_RECORD (field_type_node
);
917 build_decl (BUILTINS_LOCATION
,
918 TYPE_DECL
, get_identifier ("Field"), field_type_node
);
920 nativecode_ptr_array_type_node
921 = build_array_type (nativecode_ptr_type_node
, one_elt_array_domain_type
);
923 PUSH_FIELD (input_location
,
924 dtable_type
, field
, "class", class_ptr_type
);
925 PUSH_FIELD (input_location
,
926 dtable_type
, field
, "methods", nativecode_ptr_array_type_node
);
927 FINISH_RECORD (dtable_type
);
928 build_decl (BUILTINS_LOCATION
,
929 TYPE_DECL
, get_identifier ("dispatchTable"), dtable_type
);
931 jexception_type
= make_node (RECORD_TYPE
);
932 PUSH_FIELD (input_location
,
933 jexception_type
, field
, "start_pc", ptr_type_node
);
934 PUSH_FIELD (input_location
, jexception_type
, field
, "end_pc", ptr_type_node
);
935 PUSH_FIELD (input_location
,
936 jexception_type
, field
, "handler_pc", ptr_type_node
);
937 PUSH_FIELD (input_location
,
938 jexception_type
, field
, "catch_type", class_ptr_type
);
939 FINISH_RECORD (jexception_type
);
940 build_decl (BUILTINS_LOCATION
,
941 TYPE_DECL
, get_identifier ("jexception"), field_type_node
);
942 jexception_ptr_type
= build_pointer_type (jexception_type
);
944 lineNumberEntry_type
= make_node (RECORD_TYPE
);
945 PUSH_FIELD (input_location
,
946 lineNumberEntry_type
, field
, "line_nr", unsigned_short_type_node
);
947 PUSH_FIELD (input_location
,
948 lineNumberEntry_type
, field
, "start_pc", ptr_type_node
);
949 FINISH_RECORD (lineNumberEntry_type
);
951 lineNumbers_type
= make_node (RECORD_TYPE
);
952 PUSH_FIELD (input_location
,
953 lineNumbers_type
, field
, "length", unsigned_int_type_node
);
954 FINISH_RECORD (lineNumbers_type
);
956 PUSH_FIELD (input_location
,
957 method_type_node
, field
, "name", utf8const_ptr_type
);
958 PUSH_FIELD (input_location
,
959 method_type_node
, field
, "signature", utf8const_ptr_type
);
960 PUSH_FIELD (input_location
,
961 method_type_node
, field
, "accflags", access_flags_type_node
);
962 PUSH_FIELD (input_location
,
963 method_type_node
, field
, "index", unsigned_short_type_node
);
964 PUSH_FIELD (input_location
,
965 method_type_node
, field
, "ncode", nativecode_ptr_type_node
);
966 PUSH_FIELD (input_location
,
967 method_type_node
, field
, "throws", ptr_type_node
);
968 FINISH_RECORD (method_type_node
);
969 build_decl (BUILTINS_LOCATION
,
970 TYPE_DECL
, get_identifier ("Method"), method_type_node
);
972 end_params_node
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
974 t
= build_function_type_list (ptr_type_node
, class_ptr_type
, NULL_TREE
);
975 alloc_object_node
= add_builtin_function ("_Jv_AllocObject", t
,
976 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
977 DECL_IS_MALLOC (alloc_object_node
) = 1;
978 alloc_no_finalizer_node
=
979 add_builtin_function ("_Jv_AllocObjectNoFinalizer", t
,
980 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
981 DECL_IS_MALLOC (alloc_no_finalizer_node
) = 1;
983 t
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
984 soft_initclass_node
= add_builtin_function ("_Jv_InitClass", t
,
985 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
986 t
= build_function_type_list (ptr_type_node
,
987 class_ptr_type
, int_type_node
, NULL_TREE
);
988 soft_resolvepoolentry_node
989 = add_builtin_function ("_Jv_ResolvePoolEntry", t
,
990 0,NOT_BUILT_IN
, NULL
, NULL_TREE
);
991 DECL_PURE_P (soft_resolvepoolentry_node
) = 1;
992 t
= build_function_type_list (void_type_node
,
993 class_ptr_type
, int_type_node
, NULL_TREE
);
994 throw_node
= add_builtin_function ("_Jv_Throw", t
,
995 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
996 /* Mark throw_nodes as `noreturn' functions with side effects. */
997 TREE_THIS_VOLATILE (throw_node
) = 1;
998 TREE_SIDE_EFFECTS (throw_node
) = 1;
1000 t
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
1001 soft_monitorenter_node
1002 = add_builtin_function ("_Jv_MonitorEnter", t
, 0, NOT_BUILT_IN
,
1004 soft_monitorexit_node
1005 = add_builtin_function ("_Jv_MonitorExit", t
, 0, NOT_BUILT_IN
,
1008 t
= build_function_type_list (ptr_type_node
,
1009 ptr_type_node
, int_type_node
, NULL_TREE
);
1011 = add_builtin_function ("_Jv_NewPrimArray", t
,
1012 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1013 DECL_IS_MALLOC (soft_newarray_node
) = 1;
1015 t
= build_function_type_list (ptr_type_node
,
1016 int_type_node
, class_ptr_type
,
1017 object_ptr_type_node
, NULL_TREE
);
1019 = add_builtin_function ("_Jv_NewObjectArray", t
,
1020 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1021 DECL_IS_MALLOC (soft_anewarray_node
) = 1;
1023 t
= build_varargs_function_type_list (ptr_type_node
,
1024 ptr_type_node
, int_type_node
,
1026 soft_multianewarray_node
1027 = add_builtin_function ("_Jv_NewMultiArray", t
,
1028 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1029 DECL_IS_MALLOC (soft_multianewarray_node
) = 1;
1031 t
= build_function_type_list (void_type_node
, int_type_node
, NULL_TREE
);
1032 soft_badarrayindex_node
1033 = add_builtin_function ("_Jv_ThrowBadArrayIndex", t
,
1034 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1035 /* Mark soft_badarrayindex_node as a `noreturn' function with side
1037 TREE_THIS_VOLATILE (soft_badarrayindex_node
) = 1;
1038 TREE_SIDE_EFFECTS (soft_badarrayindex_node
) = 1;
1040 t
= build_function_type_list (void_type_node
, NULL_TREE
);
1041 soft_nullpointer_node
1042 = add_builtin_function ("_Jv_ThrowNullPointerException", t
,
1043 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1044 /* Mark soft_nullpointer_node as a `noreturn' function with side
1046 TREE_THIS_VOLATILE (soft_nullpointer_node
) = 1;
1047 TREE_SIDE_EFFECTS (soft_nullpointer_node
) = 1;
1049 soft_abstractmethod_node
1050 = add_builtin_function ("_Jv_ThrowAbstractMethodError", t
,
1051 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1052 /* Mark soft_abstractmethod_node as a `noreturn' function with side
1054 TREE_THIS_VOLATILE (soft_abstractmethod_node
) = 1;
1055 TREE_SIDE_EFFECTS (soft_abstractmethod_node
) = 1;
1057 soft_nosuchfield_node
1058 = add_builtin_function ("_Jv_ThrowNoSuchFieldError", t
,
1059 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1060 /* Mark soft_nosuchfield_node as a `noreturn' function with side
1062 TREE_THIS_VOLATILE (soft_nosuchfield_node
) = 1;
1063 TREE_SIDE_EFFECTS (soft_nosuchfield_node
) = 1;
1065 t
= build_function_type_list (ptr_type_node
,
1066 class_ptr_type
, object_ptr_type_node
,
1069 = add_builtin_function ("_Jv_CheckCast", t
,
1070 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1071 t
= build_function_type_list (boolean_type_node
,
1072 object_ptr_type_node
, class_ptr_type
,
1074 soft_instanceof_node
1075 = add_builtin_function ("_Jv_IsInstanceOf", t
,
1076 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1077 DECL_PURE_P (soft_instanceof_node
) = 1;
1078 t
= build_function_type_list (void_type_node
,
1079 object_ptr_type_node
, object_ptr_type_node
,
1081 soft_checkarraystore_node
1082 = add_builtin_function ("_Jv_CheckArrayStore", t
,
1083 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1084 t
= build_function_type_list (ptr_type_node
,
1085 ptr_type_node
, ptr_type_node
, int_type_node
,
1087 soft_lookupinterfacemethod_node
1088 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", t
,
1089 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1090 DECL_PURE_P (soft_lookupinterfacemethod_node
) = 1;
1092 t
= build_function_type_list (ptr_type_node
,
1093 ptr_type_node
, ptr_type_node
, ptr_type_node
,
1095 soft_lookupinterfacemethodbyname_node
1096 = add_builtin_function ("_Jv_LookupInterfaceMethod", t
,
1097 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1098 t
= build_function_type_list (ptr_type_node
,
1099 object_ptr_type_node
, ptr_type_node
,
1100 ptr_type_node
, int_type_node
, NULL_TREE
);
1101 soft_lookupjnimethod_node
1102 = add_builtin_function ("_Jv_LookupJNIMethod", t
,
1103 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1104 t
= build_function_type_list (ptr_type_node
, ptr_type_node
, NULL_TREE
);
1105 soft_getjnienvnewframe_node
1106 = add_builtin_function ("_Jv_GetJNIEnvNewFrame", t
,
1107 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1108 t
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
1109 soft_jnipopsystemframe_node
1110 = add_builtin_function ("_Jv_JNI_PopSystemFrame", t
,
1111 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1113 t
= build_function_type_list (object_ptr_type_node
,
1114 object_ptr_type_node
, NULL_TREE
);
1116 = add_builtin_function ("_Jv_UnwrapJNIweakReference", t
,
1117 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1119 t
= build_function_type_list (int_type_node
,
1120 int_type_node
, int_type_node
, NULL_TREE
);
1122 = add_builtin_function ("_Jv_divI", t
,
1123 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1126 = add_builtin_function ("_Jv_remI", t
,
1127 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1129 t
= build_function_type_list (long_type_node
,
1130 long_type_node
, long_type_node
, NULL_TREE
);
1132 = add_builtin_function ("_Jv_divJ", t
,
1133 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1136 = add_builtin_function ("_Jv_remJ", t
,
1137 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1139 initialize_builtins ();
1141 soft_fmod_node
= built_in_decls
[BUILT_IN_FMOD
];
1147 /* Look up NAME in the current binding level and its superiors
1148 in the namespace of variables, functions and typedefs.
1149 Return a ..._DECL node of some kind representing its definition,
1150 or return 0 if it is undefined. */
1153 lookup_name (tree name
)
1156 if (current_binding_level
!= global_binding_level
1157 && IDENTIFIER_LOCAL_VALUE (name
))
1158 val
= IDENTIFIER_LOCAL_VALUE (name
);
1160 val
= IDENTIFIER_GLOBAL_VALUE (name
);
1164 /* Similar to `lookup_name' but look only at current binding level and
1165 the previous one if it's the parameter level. */
1168 lookup_name_current_level (tree name
)
1172 if (current_binding_level
== global_binding_level
)
1173 return IDENTIFIER_GLOBAL_VALUE (name
);
1175 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
1178 for (t
= current_binding_level
->names
; t
; t
= DECL_CHAIN (t
))
1179 if (DECL_NAME (t
) == name
)
1185 /* Record a decl-node X as belonging to the current lexical scope.
1186 Check for errors (such as an incompatible declaration for the same
1187 name already seen in the same scope).
1189 Returns either X or an old decl for the same name.
1190 If an old decl is returned, it may have been smashed
1191 to agree with what X says. */
1197 tree name
= DECL_NAME (x
);
1198 struct binding_level
*b
= current_binding_level
;
1200 if (TREE_CODE (x
) != TYPE_DECL
)
1201 DECL_CONTEXT (x
) = current_function_decl
;
1204 t
= lookup_name_current_level (name
);
1205 if (t
!= 0 && t
== error_mark_node
)
1206 /* error_mark_node is 0 for a while during initialization! */
1209 error ("%q+D used prior to declaration", x
);
1212 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1213 to point to the TYPE_DECL.
1214 Since Java does not have typedefs, a type can only have
1215 one (true) name, given by a class, interface, or builtin. */
1216 if (TREE_CODE (x
) == TYPE_DECL
1217 && TYPE_NAME (TREE_TYPE (x
)) == 0
1218 && TREE_TYPE (x
) != error_mark_node
)
1220 TYPE_NAME (TREE_TYPE (x
)) = x
;
1221 TYPE_STUB_DECL (TREE_TYPE (x
)) = x
;
1224 /* This name is new in its binding level.
1225 Install the new declaration and return it. */
1226 if (b
== global_binding_level
)
1228 /* Install a global value. */
1230 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1234 /* Here to install a non-global value. */
1235 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1236 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1238 /* If storing a local value, there may already be one (inherited).
1239 If so, record it for restoration when this binding level ends. */
1241 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1245 /* Put decls on list in reverse order.
1246 We will reverse them later if necessary. */
1247 DECL_CHAIN (x
) = b
->names
;
1254 pushdecl_force_head (tree x
)
1256 current_binding_level
->names
= x
;
1259 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1262 pushdecl_top_level (tree x
)
1265 struct binding_level
*b
= current_binding_level
;
1267 current_binding_level
= global_binding_level
;
1269 current_binding_level
= b
;
1273 /* Like pushdecl, only it places X in FUNCTION_BINDING_LEVEL, if appropriate. */
1276 pushdecl_function_level (tree x
)
1279 struct binding_level
*b
= current_binding_level
;
1281 current_binding_level
= function_binding_level
;
1283 current_binding_level
= b
;
1287 /* Return true if we are in the global binding level. */
1290 global_bindings_p (void)
1292 return current_binding_level
== global_binding_level
;
1295 /* Return the list of declarations of the current level.
1296 Note that this list is in reverse order unless/until
1297 you nreverse it; and when you do nreverse it, you must
1298 store the result back using `storedecls' or you will lose. */
1303 return current_binding_level
->names
;
1306 /* Create a new `struct binding_level'. */
1308 static struct binding_level
*
1309 make_binding_level (void)
1312 return ggc_alloc_cleared_binding_level ();
1316 pushlevel (int unused ATTRIBUTE_UNUSED
)
1318 struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
1320 /* Reuse or create a struct for this binding level. */
1322 if (free_binding_level
)
1324 newlevel
= free_binding_level
;
1325 free_binding_level
= free_binding_level
->level_chain
;
1329 newlevel
= make_binding_level ();
1332 /* Add this level to the front of the chain (stack) of levels that
1335 *newlevel
= clear_binding_level
;
1336 newlevel
->level_chain
= current_binding_level
;
1337 newlevel
->loc
= input_location
;
1338 current_binding_level
= newlevel
;
1339 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1340 newlevel
->binding_depth
= binding_depth
;
1342 fprintf (stderr
, "push %s level %p pc %d\n",
1343 (is_class_level
) ? "class" : "block", newlevel
, current_pc
);
1346 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1349 /* Exit a binding level.
1350 Pop the level off, and restore the state of the identifier-decl mappings
1351 that were in effect when this level was entered.
1353 If KEEP is nonzero, this level had explicit declarations, so
1354 and create a "block" (a BLOCK node) for the level
1355 to record its declarations and subblocks for symbol table output.
1357 If FUNCTIONBODY is nonzero, this level is the body of a function,
1358 so create a block as if KEEP were set and also clear out all
1361 If REVERSE is nonzero, reverse the order of decls before putting
1362 them into the BLOCK. */
1365 poplevel (int keep
, int reverse
, int functionbody
)
1368 /* The chain of decls was accumulated in reverse order.
1369 Put it into forward order, just for cleanliness. */
1371 tree subblocks
= current_binding_level
->blocks
;
1376 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1379 if (current_binding_level
->end_pc
!= LARGEST_PC
)
1380 fprintf (stderr
, "pop %s level %p pc %d (end pc %d)\n",
1381 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
,
1382 current_binding_level
->end_pc
);
1384 fprintf (stderr
, "pop %s level %p pc %d\n",
1385 (is_class_level
) ? "class" : "block", current_binding_level
, current_pc
);
1386 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1388 /* Get the decls in the order they were written.
1389 Usually current_binding_level->names is in reverse order.
1390 But parameter decls were previously put in forward order. */
1393 current_binding_level
->names
1394 = decls
= nreverse (current_binding_level
->names
);
1396 decls
= current_binding_level
->names
;
1398 for (decl
= decls
; decl
; decl
= DECL_CHAIN (decl
))
1399 if (TREE_CODE (decl
) == VAR_DECL
1400 && DECL_LANG_SPECIFIC (decl
) != NULL
1401 && DECL_LOCAL_SLOT_NUMBER (decl
))
1402 LOCAL_VAR_OUT_OF_SCOPE_P (decl
) = 1;
1404 /* If there were any declarations in that level,
1405 or if this level is a function body,
1406 create a BLOCK to record them for the life of this function. */
1409 if (keep
|| functionbody
)
1410 block
= make_node (BLOCK
);
1412 if (current_binding_level
->exception_range
)
1413 expand_end_java_handler (current_binding_level
->exception_range
);
1417 /* If any statements have been generated at this level, create a
1418 BIND_EXPR to hold them and copy the variables to it. This
1419 only applies to the bytecode compiler. */
1420 if (current_binding_level
->stmts
)
1423 tree
*var
= &BLOCK_VARS (block
);
1425 /* Copy decls from names list, ignoring labels. */
1428 tree next
= DECL_CHAIN (decl
);
1429 if (TREE_CODE (decl
) != LABEL_DECL
)
1432 var
= &DECL_CHAIN (decl
);
1438 bind
= build3 (BIND_EXPR
, void_type_node
, BLOCK_VARS (block
),
1439 BLOCK_EXPR_BODY (block
), block
);
1440 BIND_EXPR_BODY (bind
) = current_binding_level
->stmts
;
1442 if (BIND_EXPR_BODY (bind
)
1443 && TREE_SIDE_EFFECTS (BIND_EXPR_BODY (bind
)))
1444 TREE_SIDE_EFFECTS (bind
) = 1;
1446 /* FIXME: gimplifier brain damage. */
1447 if (BIND_EXPR_BODY (bind
) == NULL
)
1448 BIND_EXPR_BODY (bind
) = build_java_empty_stmt ();
1450 SET_EXPR_LOCATION (bind
, current_binding_level
->loc
);
1452 current_binding_level
->stmts
= NULL
;
1456 BLOCK_VARS (block
) = decls
;
1458 BLOCK_SUBBLOCKS (block
) = subblocks
;
1461 /* In each subblock, record that this is its superior. */
1463 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
1464 BLOCK_SUPERCONTEXT (link
) = block
;
1466 /* Clear out the meanings of the local variables of this level. */
1468 for (link
= decls
; link
; link
= DECL_CHAIN (link
))
1470 tree name
= DECL_NAME (link
);
1471 if (name
!= 0 && IDENTIFIER_LOCAL_VALUE (name
) == link
)
1473 /* If the ident. was used or addressed via a local extern decl,
1474 don't forget that fact. */
1475 if (DECL_EXTERNAL (link
))
1477 if (TREE_USED (link
))
1478 TREE_USED (name
) = 1;
1479 if (TREE_ADDRESSABLE (link
))
1480 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1482 IDENTIFIER_LOCAL_VALUE (name
) = 0;
1486 /* Restore all name-meanings of the outer levels
1487 that were shadowed by this level. */
1489 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1490 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1492 /* If the level being exited is the top level of a function,
1493 check over all the labels, and clear out the current
1494 (function local) meanings of their names. */
1498 /* If this is the top level block of a function,
1499 the vars are the function's parameters.
1500 Don't leave them in the BLOCK because they are
1501 found in the FUNCTION_DECL instead. */
1503 BLOCK_VARS (block
) = 0;
1506 /* Pop the current level, and free the structure for reuse. */
1509 struct binding_level
*level
= current_binding_level
;
1510 current_binding_level
= current_binding_level
->level_chain
;
1512 level
->level_chain
= free_binding_level
;
1513 free_binding_level
= level
;
1516 /* Dispose of the block that we just made inside some higher level. */
1519 DECL_INITIAL (current_function_decl
) = block
;
1520 DECL_SAVED_TREE (current_function_decl
) = bind
;
1526 current_binding_level
->blocks
1527 = block_chainon (current_binding_level
->blocks
, block
);
1529 /* If we did not make a block for the level just exited,
1530 any blocks made for inner levels
1531 (since they cannot be recorded as subblocks in that level)
1532 must be carried forward so they will later become subblocks
1533 of something else. */
1535 current_binding_level
->blocks
1536 = block_chainon (current_binding_level
->blocks
, subblocks
);
1539 java_add_stmt (bind
);
1543 TREE_USED (block
) = 1;
1548 maybe_pushlevels (int pc
)
1550 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1554 while (pending_local_decls
!= NULL_TREE
&&
1555 DECL_LOCAL_START_PC (pending_local_decls
) <= pc
)
1557 tree
*ptr
= &pending_local_decls
;
1558 tree decl
= *ptr
, next
;
1559 int end_pc
= DECL_LOCAL_END_PC (decl
);
1561 while (*ptr
!= NULL_TREE
1562 && DECL_LOCAL_START_PC (*ptr
) <= pc
1563 && DECL_LOCAL_END_PC (*ptr
) == end_pc
)
1564 ptr
= &DECL_CHAIN (*ptr
);
1565 pending_local_decls
= *ptr
;
1568 /* Force non-nested range to be nested in current range by
1569 truncating variable lifetimes. */
1570 if (end_pc
> current_binding_level
->end_pc
)
1573 end_pc
= current_binding_level
->end_pc
;
1574 for (t
= decl
; t
!= NULL_TREE
; t
= DECL_CHAIN (t
))
1575 DECL_LOCAL_END_PC (t
) = end_pc
;
1578 maybe_start_try (pc
, end_pc
);
1582 current_binding_level
->end_pc
= end_pc
;
1583 current_binding_level
->start_pc
= pc
;
1584 current_binding_level
->names
= NULL
;
1585 for ( ; decl
!= NULL_TREE
; decl
= next
)
1587 int index
= DECL_LOCAL_SLOT_NUMBER (decl
);
1589 next
= DECL_CHAIN (decl
);
1590 push_jvm_slot (index
, decl
);
1593 = find_local_variable (index
, TREE_TYPE (decl
), pc
);
1594 if (TREE_CODE (TREE_TYPE (base_decl
)) == POINTER_TYPE
)
1595 base_decl
= TREE_VEC_ELT (base_decl_map
, index
);
1596 SET_DECL_VALUE_EXPR (decl
, base_decl
);
1597 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1601 maybe_start_try (pc
, 0);
1605 maybe_poplevels (int pc
)
1607 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1611 /* FIXME: I'm pretty sure that this is wrong. Variable scopes are
1612 inclusive, so a variable is live if pc == end_pc. Here, we
1613 terminate a range if the current pc is equal to the end of the
1614 range, and this is *before* we have generated code for the
1615 instruction at end_pc. We're closing a binding level one
1616 instruction too early.*/
1617 while (current_binding_level
->end_pc
<= pc
)
1621 /* Terminate any binding which began during the range beginning at
1622 start_pc. This tidies up improperly nested local variable ranges
1623 and exception handlers; a variable declared within an exception
1624 range is forcibly terminated when that exception ends. */
1627 force_poplevels (int start_pc
)
1629 while (current_binding_level
->start_pc
> start_pc
)
1631 if (pedantic
&& current_binding_level
->start_pc
> start_pc
)
1632 warning (0, "In %+D: overlapped variable and exception ranges at %d",
1633 current_function_decl
,
1634 current_binding_level
->start_pc
);
1639 /* integrate_decl_tree calls this function. */
1642 java_dup_lang_specific_decl (tree node
)
1645 struct lang_decl
*x
;
1647 if (!DECL_LANG_SPECIFIC (node
))
1650 lang_decl_size
= sizeof (struct lang_decl
);
1651 x
= ggc_alloc_lang_decl (lang_decl_size
);
1652 memcpy (x
, DECL_LANG_SPECIFIC (node
), lang_decl_size
);
1653 DECL_LANG_SPECIFIC (node
) = x
;
1657 give_name_to_locals (JCF
*jcf
)
1659 int i
, n
= DECL_LOCALVARIABLES_OFFSET (current_function_decl
);
1660 int code_offset
= DECL_CODE_OFFSET (current_function_decl
);
1662 pending_local_decls
= NULL_TREE
;
1666 n
= JCF_readu2 (jcf
);
1667 for (i
= 0; i
< n
; i
++)
1669 int start_pc
= JCF_readu2 (jcf
);
1670 int length
= JCF_readu2 (jcf
);
1671 int name_index
= JCF_readu2 (jcf
);
1672 int signature_index
= JCF_readu2 (jcf
);
1673 int slot
= JCF_readu2 (jcf
);
1674 tree name
= get_name_constant (jcf
, name_index
);
1675 tree type
= parse_signature (jcf
, signature_index
);
1676 if (slot
< DECL_ARG_SLOT_COUNT (current_function_decl
)
1678 && length
== DECL_CODE_LENGTH (current_function_decl
))
1680 tree decl
= TREE_VEC_ELT (decl_map
, slot
);
1681 DECL_NAME (decl
) = name
;
1682 if (TREE_CODE (decl
) != PARM_DECL
|| TREE_TYPE (decl
) != type
)
1683 warning (0, "bad type in parameter debug info");
1688 int end_pc
= start_pc
+ length
;
1689 tree decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
1690 if (end_pc
> DECL_CODE_LENGTH (current_function_decl
))
1692 warning (0, "bad PC range for debug info for local %q+D",
1694 end_pc
= DECL_CODE_LENGTH (current_function_decl
);
1697 /* Adjust start_pc if necessary so that the local's first
1698 store operation will use the relevant DECL as a
1699 destination. Fore more information, read the leading
1700 comments for expr.c:maybe_adjust_start_pc. */
1701 start_pc
= maybe_adjust_start_pc (jcf
, code_offset
, start_pc
, slot
);
1703 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1704 DECL_LOCAL_SLOT_NUMBER (decl
) = slot
;
1705 DECL_LOCAL_START_PC (decl
) = start_pc
;
1706 DECL_LOCAL_END_PC (decl
) = end_pc
;
1708 /* Now insert the new decl in the proper place in
1709 pending_local_decls. We are essentially doing an insertion sort,
1710 which works fine, since the list input will normally already
1712 ptr
= &pending_local_decls
;
1713 while (*ptr
!= NULL_TREE
1714 && (DECL_LOCAL_START_PC (*ptr
) > start_pc
1715 || (DECL_LOCAL_START_PC (*ptr
) == start_pc
1716 && DECL_LOCAL_END_PC (*ptr
) < end_pc
)))
1717 ptr
= &DECL_CHAIN (*ptr
);
1718 DECL_CHAIN (decl
) = *ptr
;
1723 pending_local_decls
= nreverse (pending_local_decls
);
1725 /* Fill in default names for the parameters. */
1726 for (parm
= DECL_ARGUMENTS (current_function_decl
), i
= 0;
1727 parm
!= NULL_TREE
; parm
= DECL_CHAIN (parm
), i
++)
1729 if (DECL_NAME (parm
) == NULL_TREE
)
1731 int arg_i
= METHOD_STATIC (current_function_decl
) ? i
+1 : i
;
1733 DECL_NAME (parm
) = get_identifier ("this");
1737 sprintf (buffer
, "ARG_%d", arg_i
);
1738 DECL_NAME (parm
) = get_identifier (buffer
);
1745 build_result_decl (tree fndecl
)
1747 tree restype
= TREE_TYPE (TREE_TYPE (fndecl
));
1748 tree result
= DECL_RESULT (fndecl
);
1751 result
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
1752 RESULT_DECL
, NULL_TREE
, restype
);
1753 DECL_ARTIFICIAL (result
) = 1;
1754 DECL_IGNORED_P (result
) = 1;
1755 DECL_CONTEXT (result
) = fndecl
;
1756 DECL_RESULT (fndecl
) = result
;
1762 start_java_method (tree fndecl
)
1769 current_function_decl
= fndecl
;
1770 announce_function (fndecl
);
1772 i
= DECL_MAX_LOCALS(fndecl
) + DECL_MAX_STACK(fndecl
);
1773 decl_map
= make_tree_vec (i
);
1774 base_decl_map
= make_tree_vec (i
);
1775 type_map
= XRESIZEVEC (tree
, type_map
, i
);
1777 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1778 fprintf (stderr
, "%s:\n", lang_printable_name (fndecl
, 2));
1780 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1781 pushlevel (1); /* Push parameters. */
1783 ptr
= &DECL_ARGUMENTS (fndecl
);
1784 for (tem
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)), i
= 0;
1785 tem
!= end_params_node
; tem
= TREE_CHAIN (tem
), i
++)
1787 tree parm_name
= NULL_TREE
, parm_decl
;
1788 tree parm_type
= TREE_VALUE (tem
);
1789 gcc_assert (i
< DECL_MAX_LOCALS (fndecl
));
1791 parm_decl
= build_decl (input_location
, PARM_DECL
, parm_name
, parm_type
);
1792 DECL_CONTEXT (parm_decl
) = fndecl
;
1793 if (targetm
.calls
.promote_prototypes (parm_type
)
1794 && TYPE_PRECISION (parm_type
) < TYPE_PRECISION (integer_type_node
)
1795 && INTEGRAL_TYPE_P (parm_type
))
1796 parm_type
= integer_type_node
;
1797 DECL_ARG_TYPE (parm_decl
) = parm_type
;
1800 ptr
= &DECL_CHAIN (parm_decl
);
1802 /* Add parm_decl to the decl_map. */
1803 push_jvm_slot (i
, parm_decl
);
1805 /* The this parameter of methods is artificial. */
1806 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
&& i
== 0)
1807 DECL_ARTIFICIAL (parm_decl
) = 1;
1809 type_map
[i
] = TREE_TYPE (parm_decl
);
1810 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl
)))
1813 type_map
[i
] = void_type_node
;
1817 DECL_ARG_SLOT_COUNT (current_function_decl
) = i
;
1819 while (i
< DECL_MAX_LOCALS(fndecl
))
1820 type_map
[i
++] = NULL_TREE
;
1822 build_result_decl (fndecl
);
1823 DECL_SOURCE_LOCATION (fndecl
) = input_location
;
1825 /* Push local variables. */
1828 function_binding_level
= current_binding_level
;
1832 end_java_method (void)
1834 tree fndecl
= current_function_decl
;
1836 /* pop out of function */
1839 /* pop out of its parameters */
1842 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
1844 if (DECL_SAVED_TREE (fndecl
))
1846 tree fbody
, block_body
;
1847 /* Before we check initialization, attached all class initialization
1848 variable to the block_body */
1849 fbody
= DECL_SAVED_TREE (fndecl
);
1850 block_body
= BIND_EXPR_BODY (fbody
);
1851 htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (fndecl
),
1852 attach_init_test_initialization_flags
, block_body
);
1855 finish_method (fndecl
);
1857 current_function_decl
= NULL_TREE
;
1858 base_decl_map
= NULL_TREE
;
1861 /* Prepare a method for expansion. */
1864 finish_method (tree fndecl
)
1866 tree
*tp
= &DECL_SAVED_TREE (fndecl
);
1868 /* Wrap body of synchronized methods in a monitorenter,
1869 plus monitorexit cleanup. */
1870 if (METHOD_SYNCHRONIZED (fndecl
))
1872 tree enter
, exit
, lock
;
1873 if (METHOD_STATIC (fndecl
))
1874 lock
= build_class_ref (DECL_CONTEXT (fndecl
));
1876 lock
= DECL_ARGUMENTS (fndecl
);
1877 BUILD_MONITOR_ENTER (enter
, lock
);
1878 BUILD_MONITOR_EXIT (exit
, lock
);
1879 *tp
= build2 (COMPOUND_EXPR
, void_type_node
, enter
,
1880 build2 (TRY_FINALLY_EXPR
, void_type_node
, *tp
, exit
));
1883 /* Convert function tree to GENERIC prior to inlining. */
1884 java_genericize (fndecl
);
1886 /* Store the end of the function, so that we get good line number
1887 info for the epilogue. */
1888 if (DECL_STRUCT_FUNCTION (fndecl
))
1889 set_cfun (DECL_STRUCT_FUNCTION (fndecl
));
1891 allocate_struct_function (fndecl
, false);
1892 cfun
->function_end_locus
= DECL_FUNCTION_LAST_LINE (fndecl
);
1894 /* Defer inlining and expansion to the cgraph optimizers. */
1895 cgraph_finalize_function (fndecl
, false);
1898 /* We pessimistically marked all methods and fields external until we
1899 knew what set of classes we were planning to compile. Now mark those
1900 associated with CLASS to be generated locally as not external. */
1903 java_mark_decl_local (tree decl
)
1905 DECL_EXTERNAL (decl
) = 0;
1907 #ifdef ENABLE_CHECKING
1908 /* Double check that we didn't pass the function to the callgraph early. */
1909 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1911 struct cgraph_node
*node
= cgraph_get_node (decl
);
1912 gcc_assert (!node
|| !node
->local
.finalized
);
1915 gcc_assert (!DECL_RTL_SET_P (decl
));
1918 /* Given appropriate target support, G++ will emit hidden aliases for native
1919 methods. Using this hidden name is required for proper operation of
1920 _Jv_Method::ncode, but it doesn't hurt to use it everywhere. Look for
1921 proper target support, then mark the method for aliasing. */
1924 java_mark_cni_decl_local (tree decl
)
1926 #if !defined(HAVE_GAS_HIDDEN) || !defined(ASM_OUTPUT_DEF)
1930 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
1931 DECL_LOCAL_CNI_METHOD_P (decl
) = 1;
1933 /* Setting DECL_LOCAL_CNI_METHOD_P changes the behavior of the
1934 mangler. We might have already referenced this native method and
1935 therefore created its name, but even if we have it won't hurt.
1936 We'll just go via its externally visible name, rather than its
1937 hidden alias. However, we must force things so that the correct
1938 mangling is done. */
1940 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
1941 java_mangle_decl (decl
);
1942 if (DECL_RTL_SET_P (decl
))
1944 SET_DECL_RTL (decl
, 0);
1945 make_decl_rtl (decl
);
1949 /* Use the preceding two functions and mark all members of the class. */
1952 java_mark_class_local (tree klass
)
1956 for (t
= TYPE_FIELDS (klass
); t
; t
= DECL_CHAIN (t
))
1957 if (FIELD_STATIC (t
))
1959 if (DECL_EXTERNAL (t
))
1960 VEC_safe_push (tree
, gc
, pending_static_fields
, t
);
1961 java_mark_decl_local (t
);
1964 for (t
= TYPE_METHODS (klass
); t
; t
= DECL_CHAIN (t
))
1965 if (!METHOD_ABSTRACT (t
))
1967 if (METHOD_NATIVE (t
) && !flag_jni
)
1968 java_mark_cni_decl_local (t
);
1970 java_mark_decl_local (t
);
1974 /* Add a statement to a compound_expr. */
1977 add_stmt_to_compound (tree existing
, tree type
, tree stmt
)
1983 tree expr
= build2 (COMPOUND_EXPR
, type
, existing
, stmt
);
1984 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (existing
)
1985 | TREE_SIDE_EFFECTS (stmt
);
1992 /* If this node is an expr, mark its input location. Called from
1996 set_input_location (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
1997 void *data ATTRIBUTE_UNUSED
)
2001 if (CAN_HAVE_LOCATION_P (t
))
2003 if (EXPR_HAS_LOCATION(t
))
2004 return t
; /* Don't walk any further into this expr. */
2006 SET_EXPR_LOCATION (t
, input_location
);
2009 return NULL_TREE
; /* Continue walking this expr. */
2012 /* Add a statement to the statement_list currently being constructed.
2013 If the statement_list is null, we don't create a singleton list.
2014 This is necessary because poplevel() assumes that adding a
2015 statement to a null statement_list returns the statement. */
2018 java_add_stmt (tree new_stmt
)
2020 tree stmts
= current_binding_level
->stmts
;
2021 tree_stmt_iterator i
;
2024 walk_tree (&new_stmt
, set_input_location
, NULL
, NULL
);
2027 return current_binding_level
->stmts
= new_stmt
;
2029 /* Force STMTS to be a statement_list. */
2030 if (TREE_CODE (stmts
) != STATEMENT_LIST
)
2032 tree t
= make_node (STATEMENT_LIST
);
2034 tsi_link_after (&i
, stmts
, TSI_CONTINUE_LINKING
);
2038 i
= tsi_last (stmts
);
2039 tsi_link_after (&i
, new_stmt
, TSI_CONTINUE_LINKING
);
2040 TREE_TYPE (stmts
) = void_type_node
;
2042 return current_binding_level
->stmts
= stmts
;
2045 /* Add a variable to the current scope. */
2048 java_add_local_var (tree decl
)
2050 tree
*vars
= ¤t_binding_level
->names
;
2052 DECL_CHAIN (decl
) = next
;
2054 DECL_CONTEXT (decl
) = current_function_decl
;
2055 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2059 /* Return a pointer to the compound_expr currently being
2065 return ¤t_binding_level
->stmts
;
2068 /* Register an exception range as belonging to the current binding
2069 level. There may only be one: if there are more, we'll create more
2070 binding levels. However, each range can have multiple handlers,
2071 and these are expanded when we call expand_end_java_handler(). */
2074 register_exception_range (struct eh_range
*range
, int pc
, int end_pc
)
2076 gcc_assert (! current_binding_level
->exception_range
);
2077 current_binding_level
->exception_range
= range
;
2078 current_binding_level
->end_pc
= end_pc
;
2079 current_binding_level
->start_pc
= pc
;
2082 #include "gt-java-decl.h"