1 /* Java(TM) language-specific utility routines.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
21 Java and all Java-based marks are trademarks or registered trademarks
22 of Sun Microsystems, Inc. in the United States and other countries.
23 The Free Software Foundation is independent of Sun Microsystems, Inc. */
25 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
29 #include "coretypes.h"
35 #include "java-tree.h"
38 #include "langhooks.h"
39 #include "langhooks-def.h"
42 #include "diagnostic.h"
43 #include "tree-inline.h"
44 #include "splay-tree.h"
45 #include "tree-dump.h"
49 static bool java_init (void);
50 static void java_finish (void);
51 static unsigned int java_init_options (unsigned int, const char **);
52 static bool java_post_options (const char **);
54 static int java_handle_option (size_t scode
, const char *arg
, int value
);
55 static void put_decl_string (const char *, int);
56 static void put_decl_node (tree
);
57 static void java_print_error_function (diagnostic_context
*, const char *,
59 static int merge_init_test_initialization (void * *, void *);
60 static int inline_init_test_initialization (void * *, void *);
61 static bool java_dump_tree (void *, tree
);
62 static void dump_compound_expr (dump_info_p
, tree
);
63 static bool java_decl_ok_for_sibcall (const_tree
);
65 static enum classify_record
java_classify_record (tree type
);
67 #ifndef TARGET_OBJECT_SUFFIX
68 # define TARGET_OBJECT_SUFFIX ".o"
71 /* Table of machine-independent attributes. */
72 const struct attribute_spec java_attribute_table
[] =
74 { "nonnull", 0, -1, false, true, true,
76 { NULL
, 0, 0, false, false, false, NULL
}
79 /* Used to avoid printing error messages with bogus function
80 prototypes. Starts out false. */
81 static bool inhibit_error_function_printing
;
83 const char *resource_name
;
85 /* When nonzero, -Wall was turned on. */
88 /* When nonzero, report use of deprecated classes, methods, or fields. */
89 int flag_deprecated
= 1;
91 /* When zero, don't optimize static class initialization. This flag shouldn't
92 be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead. */
93 /* FIXME: Make this work with gimplify. */
94 /* int flag_optimize_sci = 0; */
96 /* Don't attempt to verify invocations. */
97 int flag_verify_invocations
= 0;
99 /* When nonzero, print extra version information. */
100 static int v_flag
= 0;
104 /* Variable controlling how dependency tracking is enabled in
106 static int dependency_tracking
= 0;
108 /* Flag values for DEPENDENCY_TRACKING. */
109 #define DEPEND_SET_FILE 1
110 #define DEPEND_ENABLE 2
111 #define DEPEND_TARGET_SET 4
112 #define DEPEND_FILE_ALREADY_SET 8
114 struct language_function
GTY(())
119 #undef LANG_HOOKS_NAME
120 #define LANG_HOOKS_NAME "GNU Java"
121 #undef LANG_HOOKS_INIT
122 #define LANG_HOOKS_INIT java_init
123 #undef LANG_HOOKS_FINISH
124 #define LANG_HOOKS_FINISH java_finish
125 #undef LANG_HOOKS_INIT_OPTIONS
126 #define LANG_HOOKS_INIT_OPTIONS java_init_options
127 #undef LANG_HOOKS_HANDLE_OPTION
128 #define LANG_HOOKS_HANDLE_OPTION java_handle_option
129 #undef LANG_HOOKS_POST_OPTIONS
130 #define LANG_HOOKS_POST_OPTIONS java_post_options
131 #undef LANG_HOOKS_PARSE_FILE
132 #define LANG_HOOKS_PARSE_FILE java_parse_file
133 #undef LANG_HOOKS_MARK_ADDRESSABLE
134 #define LANG_HOOKS_MARK_ADDRESSABLE java_mark_addressable
135 #undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL
136 #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL java_dup_lang_specific_decl
137 #undef LANG_HOOKS_DECL_PRINTABLE_NAME
138 #define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name
139 #undef LANG_HOOKS_PRINT_ERROR_FUNCTION
140 #define LANG_HOOKS_PRINT_ERROR_FUNCTION java_print_error_function
142 #undef LANG_HOOKS_TYPE_FOR_MODE
143 #define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode
144 #undef LANG_HOOKS_TYPE_FOR_SIZE
145 #define LANG_HOOKS_TYPE_FOR_SIZE java_type_for_size
146 #undef LANG_HOOKS_CLASSIFY_RECORD
147 #define LANG_HOOKS_CLASSIFY_RECORD java_classify_record
149 #undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN
150 #define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN java_dump_tree
152 #undef LANG_HOOKS_GIMPLIFY_EXPR
153 #define LANG_HOOKS_GIMPLIFY_EXPR java_gimplify_expr
155 #undef LANG_HOOKS_DECL_OK_FOR_SIBCALL
156 #define LANG_HOOKS_DECL_OK_FOR_SIBCALL java_decl_ok_for_sibcall
158 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
159 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME java_mangle_decl
161 #undef LANG_HOOKS_ATTRIBUTE_TABLE
162 #define LANG_HOOKS_ATTRIBUTE_TABLE java_attribute_table
164 /* Each front end provides its own. */
165 const struct lang_hooks lang_hooks
= LANG_HOOKS_INITIALIZER
;
168 * process java-specific compiler command-line options
169 * return 0, but do not complain if the option is not recognized.
172 java_handle_option (size_t scode
, const char *arg
, int value
)
174 enum opt_code code
= (enum opt_code
) scode
;
179 jcf_path_include_arg (arg
);
183 jcf_dependency_init (1);
184 dependency_tracking
|= DEPEND_ENABLE
;
188 jcf_dependency_init (1);
189 dependency_tracking
|= DEPEND_SET_FILE
| DEPEND_ENABLE
;
193 jcf_dependency_set_dep_file (arg
);
194 dependency_tracking
|= DEPEND_FILE_ALREADY_SET
;
198 jcf_dependency_init (0);
199 dependency_tracking
|= DEPEND_ENABLE
;
203 jcf_dependency_init (0);
204 dependency_tracking
|= DEPEND_SET_FILE
| DEPEND_ENABLE
;
208 jcf_dependency_print_dummies ();
212 jcf_dependency_set_target (arg
);
213 dependency_tracking
|= DEPEND_TARGET_SET
;
218 /* When -Wall given, enable -Wunused. We do this because the C
219 compiler does it, and people expect it. */
223 case OPT_fenable_assertions_
:
224 add_enable_assert (arg
, value
);
227 case OPT_fenable_assertions
:
228 add_enable_assert ("", value
);
231 case OPT_fdisable_assertions_
:
232 add_enable_assert (arg
, !value
);
235 case OPT_fdisable_assertions
:
236 add_enable_assert ("", !value
);
239 case OPT_fassume_compiled_
:
240 add_assume_compiled (arg
, !value
);
243 case OPT_fassume_compiled
:
244 add_assume_compiled ("", !value
);
247 case OPT_fbootclasspath_
:
248 jcf_path_bootclasspath_arg (arg
);
251 case OPT_faux_classpath
:
252 case OPT_fclasspath_
:
253 case OPT_fCLASSPATH_
:
254 jcf_path_classpath_arg (arg
);
257 case OPT_fcompile_resource_
:
262 if (!dump_switch_p (arg
))
271 jcf_path_extdirs_arg (arg
);
274 case OPT_foutput_class_dir_
:
275 /* FIXME: remove; this is handled by ecj1 now. */
282 case OPT_fsource_filename_
:
283 java_read_sourcefilenames (arg
);
287 if (cl_options
[code
].flags
& CL_Java
)
295 /* Global open file. */
301 /* FIXME: Indirect dispatch isn't yet compatible with static class
302 init optimization. */
303 if (flag_indirect_dispatch
)
304 always_initialize_class_p
= true;
306 if (!flag_indirect_dispatch
)
307 flag_indirect_classes
= false;
309 jcf_path_seal (v_flag
);
311 java_init_decl_processing ();
313 using_eh_for_cleanups ();
321 jcf_dependency_write ();
324 /* Buffer used by lang_printable_name. */
325 static char *decl_buf
= NULL
;
327 /* Allocated size of decl_buf. */
328 static int decl_buflen
= 0;
330 /* Length of used part of decl_buf; position for next character. */
331 static int decl_bufpos
= 0;
333 /* Append the string STR to decl_buf.
334 It length is given by LEN; -1 means the string is nul-terminated. */
337 put_decl_string (const char *str
, int len
)
341 if (decl_bufpos
+ len
>= decl_buflen
)
343 if (decl_buf
== NULL
)
345 decl_buflen
= len
+ 100;
346 decl_buf
= XNEWVEC (char, decl_buflen
);
351 decl_buf
= XRESIZEVAR (char, decl_buf
, decl_buflen
);
354 strcpy (decl_buf
+ decl_bufpos
, str
);
358 /* Append to decl_buf a printable name for NODE. */
361 put_decl_node (tree node
)
364 if (TREE_CODE (node
) == POINTER_TYPE
)
366 node
= TREE_TYPE (node
);
369 if (DECL_P (node
) && DECL_NAME (node
) != NULL_TREE
)
371 if (TREE_CODE (node
) == FUNCTION_DECL
)
373 /* We want to print the type the DECL belongs to. We don't do
374 that when we handle constructors. */
375 if (! DECL_CONSTRUCTOR_P (node
)
376 && ! DECL_ARTIFICIAL (node
) && DECL_CONTEXT (node
))
378 put_decl_node (TYPE_NAME (DECL_CONTEXT (node
)));
379 put_decl_string (".", 1);
381 if (! DECL_CONSTRUCTOR_P (node
))
382 put_decl_node (DECL_NAME (node
));
383 if (TREE_TYPE (node
) != NULL_TREE
)
386 tree args
= TYPE_ARG_TYPES (TREE_TYPE (node
));
387 if (TREE_CODE (TREE_TYPE (node
)) == METHOD_TYPE
)
388 args
= TREE_CHAIN (args
);
389 put_decl_string ("(", 1);
390 for ( ; args
!= end_params_node
; args
= TREE_CHAIN (args
), i
++)
393 put_decl_string (",", 1);
394 put_decl_node (TREE_VALUE (args
));
396 put_decl_string (")", 1);
400 put_decl_node (DECL_NAME (node
));
402 else if (TYPE_P (node
) && TYPE_NAME (node
) != NULL_TREE
)
404 if (TREE_CODE (node
) == RECORD_TYPE
&& TYPE_ARRAY_P (node
))
406 put_decl_node (TYPE_ARRAY_ELEMENT (node
));
407 put_decl_string("[]", 2);
409 else if (node
== promoted_byte_type_node
)
410 put_decl_string ("byte", 4);
411 else if (node
== promoted_short_type_node
)
412 put_decl_string ("short", 5);
413 else if (node
== promoted_char_type_node
)
414 put_decl_string ("char", 4);
415 else if (node
== promoted_boolean_type_node
)
416 put_decl_string ("boolean", 7);
417 else if (node
== void_type_node
&& was_pointer
)
418 put_decl_string ("null", 4);
420 put_decl_node (TYPE_NAME (node
));
422 else if (TREE_CODE (node
) == IDENTIFIER_NODE
)
423 put_decl_string (IDENTIFIER_POINTER (node
), IDENTIFIER_LENGTH (node
));
425 put_decl_string ("<unknown>", -1);
428 /* Return a user-friendly name for DECL.
429 The resulting string is only valid until the next call.
430 The value of the hook decl_printable_name is this function,
431 which is also called directly by java_print_error_function. */
434 lang_printable_name (tree decl
, int v
)
437 if (v
== 0 && TREE_CODE (decl
) == FUNCTION_DECL
)
438 put_decl_node (DECL_NAME (decl
));
440 put_decl_node (decl
);
441 put_decl_string ("", 1);
445 /* Print on stderr the current class and method context. This function
446 is the value of the hook print_error_function. */
448 static GTY(()) tree last_error_function_context
;
449 static GTY(()) tree last_error_function
;
451 java_print_error_function (diagnostic_context
*context ATTRIBUTE_UNUSED
,
453 diagnostic_info
*diagnostic ATTRIBUTE_UNUSED
)
455 /* Don't print error messages with bogus function prototypes. */
456 if (inhibit_error_function_printing
)
459 if (current_function_decl
!= NULL
460 && DECL_CONTEXT (current_function_decl
) != last_error_function_context
)
463 fprintf (stderr
, "%s: ", file
);
465 last_error_function_context
= DECL_CONTEXT (current_function_decl
);
466 fprintf (stderr
, "In class '%s':\n",
467 lang_printable_name (last_error_function_context
, 0));
469 if (last_error_function
!= current_function_decl
)
472 fprintf (stderr
, "%s: ", file
);
474 if (current_function_decl
== NULL
)
475 fprintf (stderr
, "At top level:\n");
478 const char *name
= lang_printable_name (current_function_decl
, 2);
479 fprintf (stderr
, "In %s '%s':\n",
480 (DECL_CONSTRUCTOR_P (current_function_decl
) ? "constructor"
485 last_error_function
= current_function_decl
;
490 /* Called to install the PRINT_ERROR_FUNCTION hook differently
491 according to LEVEL. LEVEL is 1 during early parsing, when function
492 prototypes aren't fully resolved. java_print_error_function is set
493 so it doesn't print incomplete function prototypes. When LEVEL is
494 2, function prototypes are fully resolved and can be printed when
498 lang_init_source (int level
)
500 inhibit_error_function_printing
= (level
== 1);
504 java_init_options (unsigned int argc ATTRIBUTE_UNUSED
,
505 const char **argv ATTRIBUTE_UNUSED
)
507 flag_bounds_check
= 1;
509 flag_non_call_exceptions
= 1;
511 /* In Java floating point operations never trap. */
512 flag_trapping_math
= 0;
514 /* In Java arithmetic overflow always wraps around. */
517 /* Java requires left-to-right evaluation of subexpressions. */
518 flag_evaluation_order
= 1;
525 /* Post-switch processing. */
527 java_post_options (const char **pfilename
)
529 const char *filename
= *pfilename
;
531 /* An absolute requirement: if we're not using indirect dispatch, we
532 must always verify everything. */
533 if (! flag_indirect_dispatch
)
534 flag_verify_invocations
= true;
536 if (flag_reduced_reflection
)
538 if (flag_indirect_dispatch
)
539 error ("-findirect-dispatch is incompatible "
540 "with -freduced-reflection");
542 error ("-fjni is incompatible with -freduced-reflection");
545 /* Open input file. */
547 if (filename
== 0 || !strcmp (filename
, "-"))
552 if (dependency_tracking
)
553 error ("can't do dependency tracking with input from stdin");
557 if (dependency_tracking
)
561 /* If the target is set and the output filename is set, then
562 there's no processing to do here. Otherwise we must
563 compute one or the other. */
564 if (! ((dependency_tracking
& DEPEND_TARGET_SET
)
565 && (dependency_tracking
& DEPEND_FILE_ALREADY_SET
)))
567 dot
= strrchr (filename
, '.');
569 error ("couldn't determine target name for dependency tracking");
572 char *buf
= XNEWVEC (char, dot
- filename
+
573 3 + sizeof (TARGET_OBJECT_SUFFIX
));
574 strncpy (buf
, filename
, dot
- filename
);
576 /* If emitting class files, we might have multiple
577 targets. The class generation code takes care of
578 registering them. Otherwise we compute the
580 if ((dependency_tracking
& DEPEND_TARGET_SET
))
584 strcpy (buf
+ (dot
- filename
), TARGET_OBJECT_SUFFIX
);
585 jcf_dependency_set_target (buf
);
588 if ((dependency_tracking
& DEPEND_FILE_ALREADY_SET
))
590 else if ((dependency_tracking
& DEPEND_SET_FILE
))
592 strcpy (buf
+ (dot
- filename
), ".d");
593 jcf_dependency_set_dep_file (buf
);
596 jcf_dependency_set_dep_file ("-");
603 linemap_add (line_table
, LC_ENTER
, false, filename
, 0);
604 linemap_add (line_table
, LC_RENAME
, false, "<built-in>", 0);
606 /* Initialize the compiler back end. */
610 /* Return either DECL or its known constant value (if it has one). */
613 decl_constant_value (tree decl
)
615 if (/* Don't change a variable array bound or initial value to a constant
616 in a place where a variable is invalid. */
617 current_function_decl
!= 0
618 && ! TREE_THIS_VOLATILE (decl
)
619 && TREE_READONLY (decl
)
620 && DECL_INITIAL (decl
) != 0
621 && TREE_CODE (DECL_INITIAL (decl
)) != ERROR_MARK
622 /* This is invalid if initial value is not constant.
623 If it has either a function call, a memory reference,
624 or a variable, then re-evaluating it could give different results. */
625 && TREE_CONSTANT (DECL_INITIAL (decl
))
626 /* Check for cases where this is sub-optimal, even though valid. */
627 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
628 return DECL_INITIAL (decl
);
632 /* Every call to a static constructor has an associated boolean
633 variable which is in the outermost scope of the calling method.
634 This variable is used to avoid multiple calls to the static
635 constructor for each class.
637 It looks something like this:
641 boolean dummy = OtherClass.is_initialized;
646 OtherClass.initialize();
648 ... use OtherClass.data ...
651 Each of these boolean variables has an entry in the
652 DECL_FUNCTION_INIT_TEST_TABLE of a method. When inlining a method
653 we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
654 being inlined and create the boolean variables in the outermost
655 scope of the method being inlined into. */
657 /* Create a mapping from a boolean variable in a method being inlined
658 to one in the scope of the method being inlined into. */
661 merge_init_test_initialization (void **entry
, void *x
)
663 struct treetreehash_entry
*ite
= (struct treetreehash_entry
*) *entry
;
664 splay_tree decl_map
= (splay_tree
)x
;
666 tree
*init_test_decl
;
668 /* See if we have remapped this declaration. If we haven't there's
669 a bug in the inliner. */
670 n
= splay_tree_lookup (decl_map
, (splay_tree_key
) ite
->value
);
673 /* Create a new entry for the class and its remapped boolean
674 variable. If we already have a mapping for this class we've
675 already initialized it, so don't overwrite the value. */
676 init_test_decl
= java_treetreehash_new
677 (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl
), ite
->key
);
678 if (!*init_test_decl
)
679 *init_test_decl
= (tree
)n
->value
;
681 /* This fixes a weird case.
683 The front end assumes that once we have called a method that
684 initializes some class, we can assume the class is initialized. It
685 does this by setting the DECL_INITIAL of the init_test_decl for that
686 class, and no initializations are emitted for that class.
688 However, what if the method that is supposed to do the initialization
689 is itself inlined in the caller? When expanding the called method
690 we'll assume that the class initialization has already been done,
691 because the DECL_INITIAL of the init_test_decl is set.
693 To fix this we remove the DECL_INITIAL (in the caller scope) of all
694 the init_test_decls corresponding to classes initialized by the
695 inlined method. This makes the caller no longer assume that the
696 method being inlined does any class initializations. */
697 DECL_INITIAL (*init_test_decl
) = NULL
;
702 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
706 java_inlining_merge_static_initializers (tree fn
, void *decl_map
)
709 (DECL_FUNCTION_INIT_TEST_TABLE (fn
),
710 merge_init_test_initialization
, decl_map
);
713 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
714 inlining into. If we already have a corresponding entry in that
715 class we don't need to create another one, so we create a mapping
716 from the variable in the inlined class to the corresponding
720 inline_init_test_initialization (void **entry
, void *x
)
722 struct treetreehash_entry
*ite
= (struct treetreehash_entry
*) *entry
;
723 splay_tree decl_map
= (splay_tree
)x
;
725 tree h
= java_treetreehash_find
726 (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl
), ite
->key
);
729 splay_tree_insert (decl_map
,
730 (splay_tree_key
) ite
->value
,
731 (splay_tree_value
) h
);
735 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
736 of a method being inlined. For each hone, if we already have a
737 variable associated with the same class in the method being inlined
738 into, create a new mapping for it. */
741 java_inlining_map_static_initializers (tree fn
, void *decl_map
)
744 (DECL_FUNCTION_INIT_TEST_TABLE (fn
),
745 inline_init_test_initialization
, decl_map
);
748 /* Avoid voluminous output for deep recursion of compound exprs. */
751 dump_compound_expr (dump_info_p di
, tree t
)
757 switch (TREE_CODE (TREE_OPERAND (t
, i
)))
760 dump_compound_expr (di
, TREE_OPERAND (t
, i
));
764 dump_child ("expr", TREE_OPERAND (t
, i
));
770 java_dump_tree (void *dump_info
, tree t
)
773 dump_info_p di
= (dump_info_p
) dump_info
;
775 /* Figure out what kind of node this is. */
776 code
= TREE_CODE (t
);
781 dump_child ("args", DECL_ARGUMENTS (t
));
782 if (DECL_EXTERNAL (t
))
783 dump_string (di
, "undefined");
785 dump_string (di
, "extern");
787 dump_string (di
, "static");
788 if (DECL_LANG_SPECIFIC (t
) && !dump_flag (di
, TDF_SLIM
, t
))
789 dump_child ("inline body", DECL_SAVED_TREE (t
));
793 dump_child ("expr", TREE_OPERAND (t
, 0));
797 dump_child ("goto", TREE_OPERAND (t
, 0));
801 dump_child ("label", TREE_OPERAND (t
, 0));
805 if (BLOCK_EXPR_BODY (t
))
807 tree local
= BLOCK_VARS (t
);
810 tree next
= TREE_CHAIN (local
);
811 dump_child ("var", local
);
816 tree block
= BLOCK_EXPR_BODY (t
);
817 dump_child ("body", block
);
818 block
= TREE_CHAIN (block
);
824 if (!dump_flag (di
, TDF_SLIM
, t
))
826 dump_compound_expr (di
, t
);
835 /* Java calls can't, in general, be sibcalls because we need an
836 accurate stack trace in order to guarantee correct operation of
837 methods such as Class.forName(String) and
838 SecurityManager.getClassContext(). */
841 java_decl_ok_for_sibcall (const_tree decl
)
843 return (decl
!= NULL
&& DECL_CONTEXT (decl
) == output_class
844 && !DECL_UNINLINABLE (decl
));
847 static enum classify_record
848 java_classify_record (tree type
)
850 if (! CLASS_P (type
))
851 return RECORD_IS_STRUCT
;
853 /* ??? GDB does not support DW_TAG_interface_type as of December,
854 2007. Re-enable this at a later time. */
855 if (0 && CLASS_INTERFACE (TYPE_NAME (type
)))
856 return RECORD_IS_INTERFACE
;
858 return RECORD_IS_CLASS
;
861 #include "gt-java-lang.h"