1 /* Java(TM) language-specific utility routines.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
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"
36 #include "java-tree.h"
39 #include "langhooks.h"
40 #include "langhooks-def.h"
44 #include "diagnostic.h"
45 #include "tree-inline.h"
46 #include "splay-tree.h"
47 #include "tree-dump.h"
51 static bool java_init (void);
52 static void java_finish (void);
53 static unsigned int java_init_options (unsigned int, const char **);
54 static bool java_post_options (const char **);
56 static int java_handle_option (size_t scode
, const char *arg
, int value
);
57 static void put_decl_string (const char *, int);
58 static void put_decl_node (tree
);
59 static void java_print_error_function (diagnostic_context
*, const char *);
60 static tree
java_tree_inlining_walk_subtrees (tree
*, int *, walk_tree_fn
,
62 static int java_unsafe_for_reeval (tree
);
63 static int merge_init_test_initialization (void * *, void *);
64 static int inline_init_test_initialization (void * *, void *);
65 static bool java_can_use_bit_fields_p (void);
66 static bool java_dump_tree (void *, tree
);
67 static void dump_compound_expr (dump_info_p
, tree
);
68 static bool java_decl_ok_for_sibcall (tree
);
70 #ifndef TARGET_OBJECT_SUFFIX
71 # define TARGET_OBJECT_SUFFIX ".o"
74 /* Table indexed by tree code giving a string containing a character
75 classifying the tree code. Possibilities are
76 t, d, s, c, r, <, 1 and 2. See java/java-tree.def for details. */
78 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
80 const char tree_code_type
[] = {
83 #include "java-tree.def"
87 /* Table indexed by tree code giving number of expression
88 operands beyond the fixed part of the node structure.
89 Not used for types or decls. */
91 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
93 const unsigned char tree_code_length
[] = {
96 #include "java-tree.def"
100 /* Names of tree components.
101 Used for printing out the tree and error messages. */
102 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
104 const char *const tree_code_name
[] = {
107 #include "java-tree.def"
111 /* Used to avoid printing error messages with bogus function
112 prototypes. Starts out false. */
113 static bool inhibit_error_function_printing
;
115 int compiling_from_source
;
117 const char *resource_name
;
119 int flag_emit_class_files
= 0;
121 /* Nonzero if input file is a file with a list of filenames to compile. */
123 int flag_filelist_file
= 0;
125 /* When nonzero, we emit xref strings. Values of the flag for xref
126 backends are defined in xref_flag_table, xref.c. */
128 int flag_emit_xref
= 0;
130 /* When nonzero, -Wall was turned on. */
133 /* When nonzero, check for redundant modifier uses. */
134 int flag_redundant
= 0;
136 /* When nonzero, call a library routine to do integer divisions. */
137 int flag_use_divide_subroutine
= 1;
139 /* When nonzero, generate code for the Boehm GC. */
140 int flag_use_boehm_gc
= 0;
142 /* When nonzero, assume the runtime uses a hash table to map an
143 object to its synchronization structure. */
144 int flag_hash_synchronization
;
146 /* When nonzero, permit the use of the assert keyword. */
149 /* When nonzero, assume all native functions are implemented with
153 /* When nonzero, warn when source file is newer than matching class
157 /* When nonzero, generate checks for references to NULL. */
158 int flag_check_references
= 0;
160 /* The encoding of the source file. */
161 const char *current_encoding
= NULL
;
163 /* When nonzero, report the now deprecated empty statements. */
164 int flag_extraneous_semicolon
;
166 /* When nonzero, report use of deprecated classes, methods, or fields. */
167 int flag_deprecated
= 1;
169 /* When nonzero, always check for a non gcj generated classes archive. */
170 int flag_force_classes_archive_check
;
172 /* When zero, don't optimize static class initialization. This flag shouldn't
173 be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead. */
174 int flag_optimize_sci
= 1;
176 /* When nonzero, use offset tables for virtual method calls
177 in order to improve binary compatibility. */
178 int flag_indirect_dispatch
= 0;
180 /* When zero, don't generate runtime array store checks. */
181 int flag_store_check
= 1;
183 /* When nonzero, print extra version information. */
184 static int v_flag
= 0;
186 /* Set nonzero if the user specified -finline-functions on the command
188 int flag_really_inline
= 0;
192 /* Variable controlling how dependency tracking is enabled in
194 static int dependency_tracking
= 0;
196 /* Flag values for DEPENDENCY_TRACKING. */
197 #define DEPEND_SET_FILE 1
198 #define DEPEND_ENABLE 2
199 #define DEPEND_TARGET_SET 4
200 #define DEPEND_FILE_ALREADY_SET 8
202 struct language_function
GTY(())
207 #undef LANG_HOOKS_NAME
208 #define LANG_HOOKS_NAME "GNU Java"
209 #undef LANG_HOOKS_INIT
210 #define LANG_HOOKS_INIT java_init
211 #undef LANG_HOOKS_FINISH
212 #define LANG_HOOKS_FINISH java_finish
213 #undef LANG_HOOKS_INIT_OPTIONS
214 #define LANG_HOOKS_INIT_OPTIONS java_init_options
215 #undef LANG_HOOKS_HANDLE_OPTION
216 #define LANG_HOOKS_HANDLE_OPTION java_handle_option
217 #undef LANG_HOOKS_POST_OPTIONS
218 #define LANG_HOOKS_POST_OPTIONS java_post_options
219 #undef LANG_HOOKS_PARSE_FILE
220 #define LANG_HOOKS_PARSE_FILE java_parse_file
221 #undef LANG_HOOKS_UNSAFE_FOR_REEVAL
222 #define LANG_HOOKS_UNSAFE_FOR_REEVAL java_unsafe_for_reeval
223 #undef LANG_HOOKS_MARK_ADDRESSABLE
224 #define LANG_HOOKS_MARK_ADDRESSABLE java_mark_addressable
225 #undef LANG_HOOKS_EXPAND_EXPR
226 #define LANG_HOOKS_EXPAND_EXPR java_expand_expr
227 #undef LANG_HOOKS_TRUTHVALUE_CONVERSION
228 #define LANG_HOOKS_TRUTHVALUE_CONVERSION java_truthvalue_conversion
229 #undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL
230 #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL java_dup_lang_specific_decl
231 #undef LANG_HOOKS_DECL_PRINTABLE_NAME
232 #define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name
233 #undef LANG_HOOKS_PRINT_ERROR_FUNCTION
234 #define LANG_HOOKS_PRINT_ERROR_FUNCTION java_print_error_function
235 #undef LANG_HOOKS_CAN_USE_BIT_FIELDS_P
236 #define LANG_HOOKS_CAN_USE_BIT_FIELDS_P java_can_use_bit_fields_p
238 #undef LANG_HOOKS_TYPE_FOR_MODE
239 #define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode
240 #undef LANG_HOOKS_TYPE_FOR_SIZE
241 #define LANG_HOOKS_TYPE_FOR_SIZE java_type_for_size
242 #undef LANG_HOOKS_SIGNED_TYPE
243 #define LANG_HOOKS_SIGNED_TYPE java_signed_type
244 #undef LANG_HOOKS_UNSIGNED_TYPE
245 #define LANG_HOOKS_UNSIGNED_TYPE java_unsigned_type
246 #undef LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE
247 #define LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE java_signed_or_unsigned_type
249 #undef LANG_HOOKS_TREE_INLINING_WALK_SUBTREES
250 #define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES java_tree_inlining_walk_subtrees
252 #undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN
253 #define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN java_dump_tree
255 #undef LANG_HOOKS_DECL_OK_FOR_SIBCALL
256 #define LANG_HOOKS_DECL_OK_FOR_SIBCALL java_decl_ok_for_sibcall
258 /* Each front end provides its own. */
259 const struct lang_hooks lang_hooks
= LANG_HOOKS_INITIALIZER
;
262 * process java-specific compiler command-line options
263 * return 0, but do not complain if the option is not recognized.
266 java_handle_option (size_t scode
, const char *arg
, int value
)
268 enum opt_code code
= (enum opt_code
) scode
;
276 jcf_path_include_arg (arg
);
280 jcf_dependency_init (1);
281 dependency_tracking
|= DEPEND_ENABLE
;
285 jcf_dependency_init (1);
286 dependency_tracking
|= DEPEND_SET_FILE
| DEPEND_ENABLE
;
290 jcf_dependency_set_dep_file (arg
);
291 dependency_tracking
|= DEPEND_FILE_ALREADY_SET
;
295 jcf_dependency_init (0);
296 dependency_tracking
|= DEPEND_ENABLE
;
300 jcf_dependency_init (0);
301 dependency_tracking
|= DEPEND_SET_FILE
| DEPEND_ENABLE
;
305 jcf_dependency_print_dummies ();
309 jcf_dependency_set_target (arg
);
310 dependency_tracking
|= DEPEND_TARGET_SET
;
315 flag_redundant
= value
;
316 flag_extraneous_semicolon
= value
;
317 /* When -Wall given, enable -Wunused. We do this because the C
318 compiler does it, and people expect it. */
322 case OPT_Wdeprecated
:
323 flag_deprecated
= value
;
326 case OPT_Wextraneous_semicolon
:
327 flag_extraneous_semicolon
= value
;
330 case OPT_Wout_of_date
:
334 case OPT_Wredundant_modifiers
:
335 flag_redundant
= value
;
342 case OPT_fassume_compiled_
:
343 add_assume_compiled (arg
, !value
);
346 case OPT_fassume_compiled
:
347 add_assume_compiled ("", !value
);
350 case OPT_fbootclasspath_
:
351 jcf_path_bootclasspath_arg (arg
);
354 case OPT_fcheck_references
:
355 flag_check_references
= value
;
358 case OPT_fclasspath_
:
359 case OPT_fCLASSPATH_
:
360 jcf_path_classpath_arg (arg
);
363 case OPT_fcompile_resource_
:
368 if (!dump_switch_p (arg
))
372 case OPT_femit_class_file
:
373 case OPT_femit_class_files
:
374 flag_emit_class_files
= value
;
378 current_encoding
= arg
;
382 jcf_path_extdirs_arg (arg
);
385 case OPT_ffilelist_file
:
386 flag_filelist_file
= value
;
389 case OPT_fforce_classes_archive_check
:
390 flag_force_classes_archive_check
= value
;
393 case OPT_fhash_synchronization
:
394 flag_hash_synchronization
= value
;
397 case OPT_findirect_dispatch
:
398 flag_indirect_dispatch
= value
;
401 case OPT_finline_functions
:
402 flag_inline_functions
= value
;
403 flag_really_inline
= value
;
410 case OPT_foptimize_static_class_initialization
:
411 flag_optimize_sci
= value
;
414 case OPT_foutput_class_dir_
:
415 jcf_write_base_directory
= arg
;
418 case OPT_fstore_check
:
419 flag_store_check
= value
;
422 case OPT_fuse_boehm_gc
:
423 flag_use_boehm_gc
= value
;
426 case OPT_fuse_divide_subroutine
:
427 flag_use_divide_subroutine
= value
;
438 /* Global open file. */
445 extern int flag_minimal_debug
;
446 flag_minimal_debug
= 0;
449 if (flag_inline_functions
)
450 flag_inline_trees
= 1;
452 /* Force minimum function alignment if g++ uses the least significant
453 bit of function pointers to store the virtual bit. This is required
454 to keep vtables compatible. */
455 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
456 && force_align_functions_log
< 1)
457 force_align_functions_log
= 1;
459 jcf_path_seal (v_flag
);
461 java_init_decl_processing ();
463 using_eh_for_cleanups ();
471 jcf_dependency_write ();
474 /* Buffer used by lang_printable_name. */
475 static char *decl_buf
= NULL
;
477 /* Allocated size of decl_buf. */
478 static int decl_buflen
= 0;
480 /* Length of used part of decl_buf; position for next character. */
481 static int decl_bufpos
= 0;
483 /* Append the string STR to decl_buf.
484 It length is given by LEN; -1 means the string is nul-terminated. */
487 put_decl_string (const char *str
, int len
)
491 if (decl_bufpos
+ len
>= decl_buflen
)
493 if (decl_buf
== NULL
)
495 decl_buflen
= len
+ 100;
496 decl_buf
= xmalloc (decl_buflen
);
501 decl_buf
= xrealloc (decl_buf
, decl_buflen
);
504 strcpy (decl_buf
+ decl_bufpos
, str
);
508 /* Append to decl_buf a printable name for NODE. */
511 put_decl_node (tree node
)
514 if (TREE_CODE (node
) == POINTER_TYPE
)
516 node
= TREE_TYPE (node
);
519 if (TREE_CODE_CLASS (TREE_CODE (node
)) == 'd'
520 && DECL_NAME (node
) != NULL_TREE
)
522 if (TREE_CODE (node
) == FUNCTION_DECL
)
524 /* We want to print the type the DECL belongs to. We don't do
525 that when we handle constructors. */
526 if (! DECL_CONSTRUCTOR_P (node
)
527 && ! DECL_ARTIFICIAL (node
) && DECL_CONTEXT (node
))
529 put_decl_node (TYPE_NAME (DECL_CONTEXT (node
)));
530 put_decl_string (".", 1);
532 if (! DECL_CONSTRUCTOR_P (node
))
533 put_decl_node (DECL_NAME (node
));
534 if (TREE_TYPE (node
) != NULL_TREE
)
537 tree args
= TYPE_ARG_TYPES (TREE_TYPE (node
));
538 if (TREE_CODE (TREE_TYPE (node
)) == METHOD_TYPE
)
539 args
= TREE_CHAIN (args
);
540 put_decl_string ("(", 1);
541 for ( ; args
!= end_params_node
; args
= TREE_CHAIN (args
), i
++)
544 put_decl_string (",", 1);
545 put_decl_node (TREE_VALUE (args
));
547 put_decl_string (")", 1);
551 put_decl_node (DECL_NAME (node
));
553 else if (TREE_CODE_CLASS (TREE_CODE (node
)) == 't'
554 && TYPE_NAME (node
) != NULL_TREE
)
556 if (TREE_CODE (node
) == RECORD_TYPE
&& TYPE_ARRAY_P (node
))
558 put_decl_node (TYPE_ARRAY_ELEMENT (node
));
559 put_decl_string("[]", 2);
561 else if (node
== promoted_byte_type_node
)
562 put_decl_string ("byte", 4);
563 else if (node
== promoted_short_type_node
)
564 put_decl_string ("short", 5);
565 else if (node
== promoted_char_type_node
)
566 put_decl_string ("char", 4);
567 else if (node
== promoted_boolean_type_node
)
568 put_decl_string ("boolean", 7);
569 else if (node
== void_type_node
&& was_pointer
)
570 put_decl_string ("null", 4);
572 put_decl_node (TYPE_NAME (node
));
574 else if (TREE_CODE (node
) == IDENTIFIER_NODE
)
575 put_decl_string (IDENTIFIER_POINTER (node
), IDENTIFIER_LENGTH (node
));
577 put_decl_string ("<unknown>", -1);
580 /* Return a user-friendly name for DECL.
581 The resulting string is only valid until the next call.
582 The value of the hook decl_printable_name is this function,
583 which is also called directly by java_print_error_function. */
586 lang_printable_name (tree decl
, int v
__attribute__ ((__unused__
)))
589 put_decl_node (decl
);
590 put_decl_string ("", 1);
594 /* Does the same thing that lang_printable_name, but add a leading
595 space to the DECL name string -- With Leading Space. */
598 lang_printable_name_wls (tree decl
, int v
__attribute__ ((__unused__
)))
601 put_decl_node (decl
);
602 put_decl_string ("", 1);
607 /* Print on stderr the current class and method context. This function
608 is the value of the hook print_error_function. */
610 static GTY(()) tree last_error_function_context
;
611 static GTY(()) tree last_error_function
;
613 java_print_error_function (diagnostic_context
*context ATTRIBUTE_UNUSED
,
616 /* Don't print error messages with bogus function prototypes. */
617 if (inhibit_error_function_printing
)
620 if (current_function_decl
!= NULL
621 && DECL_CONTEXT (current_function_decl
) != last_error_function_context
)
624 fprintf (stderr
, "%s: ", file
);
626 last_error_function_context
= DECL_CONTEXT (current_function_decl
);
627 fprintf (stderr
, "In class `%s':\n",
628 lang_printable_name (last_error_function_context
, 0));
630 if (last_error_function
!= current_function_decl
)
633 fprintf (stderr
, "%s: ", file
);
635 if (current_function_decl
== NULL
)
636 fprintf (stderr
, "At top level:\n");
639 const char *name
= lang_printable_name (current_function_decl
, 2);
640 fprintf (stderr
, "In %s `%s':\n",
641 (DECL_CONSTRUCTOR_P (current_function_decl
) ? "constructor"
646 last_error_function
= current_function_decl
;
651 /* Called to install the PRINT_ERROR_FUNCTION hook differently
652 according to LEVEL. LEVEL is 1 during early parsing, when function
653 prototypes aren't fully resolved. java_print_error_function is set
654 so it doesn't print incomplete function prototypes. When LEVEL is
655 2, function prototypes are fully resolved and can be printed when
658 void lang_init_source (int level
)
660 inhibit_error_function_printing
= (level
== 1);
664 java_init_options (unsigned int argc ATTRIBUTE_UNUSED
,
665 const char **argv ATTRIBUTE_UNUSED
)
667 flag_bounds_check
= 1;
669 flag_non_call_exceptions
= 1;
671 /* In Java floating point operations never trap. */
672 flag_trapping_math
= 0;
674 /* In Java arithmetic overflow always wraps around. */
683 java_can_use_bit_fields_p (void)
685 /* The bit-field optimizations cause problems when generating class
687 return flag_emit_class_files
? false : true;
690 /* Post-switch processing. */
692 java_post_options (const char **pfilename
)
694 const char *filename
= *pfilename
;
696 /* Use tree inlining if possible. Function instrumentation is only
697 done in the RTL level, so we disable tree inlining. */
698 if (! flag_instrument_function_entry_exit
)
702 if (flag_inline_functions
)
704 flag_inline_trees
= 2;
705 flag_inline_functions
= 0;
709 /* Open input file. */
711 if (filename
== 0 || !strcmp (filename
, "-"))
716 if (dependency_tracking
)
717 error ("can't do dependency tracking with input from stdin");
721 if (dependency_tracking
)
725 /* If the target is set and the output filename is set, then
726 there's no processing to do here. Otherwise we must
727 compute one or the other. */
728 if (! ((dependency_tracking
& DEPEND_TARGET_SET
)
729 && (dependency_tracking
& DEPEND_FILE_ALREADY_SET
)))
731 dot
= strrchr (filename
, '.');
733 error ("couldn't determine target name for dependency tracking");
736 char *buf
= xmalloc (dot
- filename
+
737 3 + sizeof (TARGET_OBJECT_SUFFIX
));
738 strncpy (buf
, filename
, dot
- filename
);
740 /* If emitting class files, we might have multiple
741 targets. The class generation code takes care of
742 registering them. Otherwise we compute the
744 if ((dependency_tracking
& DEPEND_TARGET_SET
))
746 else if (flag_emit_class_files
)
747 jcf_dependency_set_target (NULL
);
750 strcpy (buf
+ (dot
- filename
), TARGET_OBJECT_SUFFIX
);
751 jcf_dependency_set_target (buf
);
754 if ((dependency_tracking
& DEPEND_FILE_ALREADY_SET
))
756 else if ((dependency_tracking
& DEPEND_SET_FILE
))
758 strcpy (buf
+ (dot
- filename
), ".d");
759 jcf_dependency_set_dep_file (buf
);
762 jcf_dependency_set_dep_file ("-");
770 /* Initialize the compiler back end. */
774 /* Return either DECL or its known constant value (if it has one). */
777 decl_constant_value (tree decl
)
779 if (/* Don't change a variable array bound or initial value to a constant
780 in a place where a variable is invalid. */
781 current_function_decl
!= 0
782 && ! TREE_THIS_VOLATILE (decl
)
783 && TREE_READONLY (decl
)
784 && DECL_INITIAL (decl
) != 0
785 && TREE_CODE (DECL_INITIAL (decl
)) != ERROR_MARK
786 /* This is invalid if initial value is not constant.
787 If it has either a function call, a memory reference,
788 or a variable, then re-evaluating it could give different results. */
789 && TREE_CONSTANT (DECL_INITIAL (decl
))
790 /* Check for cases where this is sub-optimal, even though valid. */
791 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
792 return DECL_INITIAL (decl
);
796 /* Walk the language specific tree nodes during inlining. */
799 java_tree_inlining_walk_subtrees (tree
*tp ATTRIBUTE_UNUSED
,
800 int *subtrees ATTRIBUTE_UNUSED
,
801 walk_tree_fn func ATTRIBUTE_UNUSED
,
802 void *data ATTRIBUTE_UNUSED
,
803 void *htab ATTRIBUTE_UNUSED
)
808 #define WALK_SUBTREE(NODE) \
811 result = walk_tree (&(NODE), func, data, htab); \
821 code
= TREE_CODE (t
);
825 if (BLOCK_EXPR_BODY (t
))
827 tree
*prev
= &BLOCK_EXPR_BODY (*tp
);
830 WALK_SUBTREE (*prev
);
831 prev
= &TREE_CHAIN (*prev
);
842 /* Called from unsafe_for_reeval. */
844 java_unsafe_for_reeval (tree t
)
846 switch (TREE_CODE (t
))
849 /* Our expander tries to expand the variables twice. Boom. */
850 if (BLOCK_EXPR_DECLS (t
) != NULL
)
852 return unsafe_for_reeval (BLOCK_EXPR_BODY (t
));
861 /* Every call to a static constructor has an associated boolean
862 variable which is in the outermost scope of the calling method.
863 This variable is used to avoid multiple calls to the static
864 constructor for each class.
866 It looks something like this:
870 boolean dummy = OtherClass.is_initialized;
875 OtherClass.initialize();
877 ... use OtherClass.data ...
880 Each of these boolean variables has an entry in the
881 DECL_FUNCTION_INIT_TEST_TABLE of a method. When inlining a method
882 we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
883 being inlined and create the boolean variables in the outermost
884 scope of the method being inlined into. */
886 /* Create a mapping from a boolean variable in a method being inlined
887 to one in the scope of the method being inlined into. */
890 merge_init_test_initialization (void **entry
, void *x
)
892 struct treetreehash_entry
*ite
= (struct treetreehash_entry
*) *entry
;
893 splay_tree decl_map
= (splay_tree
)x
;
895 tree
*init_test_decl
;
897 /* See if we have remapped this declaration. If we haven't there's
898 a bug in the inliner. */
899 n
= splay_tree_lookup (decl_map
, (splay_tree_key
) ite
->value
);
903 /* Create a new entry for the class and its remapped boolean
904 variable. If we already have a mapping for this class we've
905 already initialized it, so don't overwrite the value. */
906 init_test_decl
= java_treetreehash_new
907 (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl
), ite
->key
);
908 if (!*init_test_decl
)
909 *init_test_decl
= (tree
)n
->value
;
914 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
918 java_inlining_merge_static_initializers (tree fn
, void *decl_map
)
921 (DECL_FUNCTION_INIT_TEST_TABLE (fn
),
922 merge_init_test_initialization
, decl_map
);
925 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
926 inlining into. If we already have a corresponding entry in that
927 class we don't need to create another one, so we create a mapping
928 from the variable in the inlined class to the corresponding
932 inline_init_test_initialization (void **entry
, void *x
)
934 struct treetreehash_entry
*ite
= (struct treetreehash_entry
*) *entry
;
935 splay_tree decl_map
= (splay_tree
)x
;
937 tree h
= java_treetreehash_find
938 (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl
), ite
->key
);
942 splay_tree_insert (decl_map
,
943 (splay_tree_key
) ite
->value
,
944 (splay_tree_value
) h
);
949 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
950 of a method being inlined. For each hone, if we already have a
951 variable associated with the same class in the method being inlined
952 into, create a new mapping for it. */
955 java_inlining_map_static_initializers (tree fn
, void *decl_map
)
958 (DECL_FUNCTION_INIT_TEST_TABLE (fn
),
959 inline_init_test_initialization
, decl_map
);
962 /* Avoid voluminous output for deep recursion of compound exprs. */
965 dump_compound_expr (dump_info_p di
, tree t
)
971 switch (TREE_CODE (TREE_OPERAND (t
, i
)))
974 dump_compound_expr (di
, TREE_OPERAND (t
, i
));
977 case EXPR_WITH_FILE_LOCATION
:
979 tree wfl_node
= EXPR_WFL_NODE (TREE_OPERAND (t
, i
));
980 dump_child ("expr", wfl_node
);
985 dump_child ("expr", TREE_OPERAND (t
, i
));
991 java_dump_tree (void *dump_info
, tree t
)
994 dump_info_p di
= (dump_info_p
) dump_info
;
996 /* Figure out what kind of node this is. */
997 code
= TREE_CODE (t
);
1002 dump_child ("args", DECL_ARGUMENTS (t
));
1003 if (DECL_EXTERNAL (t
))
1004 dump_string (di
, "undefined");
1005 if (TREE_PUBLIC (t
))
1006 dump_string (di
, "extern");
1008 dump_string (di
, "static");
1009 if (DECL_LANG_SPECIFIC (t
))
1010 dump_child ("body", DECL_FUNCTION_BODY (t
));
1011 if (DECL_LANG_SPECIFIC (t
) && !dump_flag (di
, TDF_SLIM
, t
))
1012 dump_child ("inline body", DECL_SAVED_TREE (t
));
1016 dump_child ("expr", TREE_OPERAND (t
, 0));
1020 dump_child ("goto", TREE_OPERAND (t
, 0));
1024 dump_child ("label", TREE_OPERAND (t
, 0));
1027 case LABELED_BLOCK_EXPR
:
1028 dump_child ("label", TREE_OPERAND (t
, 0));
1029 dump_child ("block", TREE_OPERAND (t
, 1));
1032 case EXIT_BLOCK_EXPR
:
1033 dump_child ("block", TREE_OPERAND (t
, 0));
1034 dump_child ("val", TREE_OPERAND (t
, 1));
1038 if (BLOCK_EXPR_BODY (t
))
1040 tree local
= BLOCK_VARS (t
);
1043 tree next
= TREE_CHAIN (local
);
1044 dump_child ("var", local
);
1049 tree block
= BLOCK_EXPR_BODY (t
);
1050 dump_child ("body", block
);
1051 block
= TREE_CHAIN (block
);
1057 if (!dump_flag (di
, TDF_SLIM
, t
))
1059 dump_compound_expr (di
, t
);
1068 /* Java calls can't, in general, be sibcalls because we need an
1069 accurate stack trace in order to guarantee correct operation of
1070 methods such as Class.forName(String) and
1071 SecurityManager.getClassContext(). */
1074 java_decl_ok_for_sibcall (tree decl
)
1076 return decl
!= NULL
&& DECL_CONTEXT (decl
) == current_class
;
1079 #include "gt-java-lang.h"