OSDN Git Service

af2ed8065c68dd88c78a75ea705ff24b0454ba39
[pf3gnuchains/gcc-fork.git] / gcc / java / lang.c
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.
4
5 This file is part of GCC.
6
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)
10 any later version.
11
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.
16
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/>.
20
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.  */
24
25 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "tree.h"
32 #include "input.h"
33 #include "rtl.h"
34 #include "expr.h"
35 #include "java-tree.h"
36 #include "jcf.h"
37 #include "toplev.h"
38 #include "langhooks.h"
39 #include "langhooks-def.h"
40 #include "flags.h"
41 #include "ggc.h"
42 #include "diagnostic.h"
43 #include "tree-inline.h"
44 #include "splay-tree.h"
45 #include "tree-dump.h"
46 #include "opts.h"
47 #include "options.h"
48
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 **);
53
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 *,
58                                        diagnostic_info *);
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);
64 static tree java_get_callee_fndecl (const_tree);
65
66 static enum classify_record java_classify_record (tree type);
67
68 #ifndef TARGET_OBJECT_SUFFIX
69 # define TARGET_OBJECT_SUFFIX ".o"
70 #endif
71
72 /* Table of machine-independent attributes.  */
73 const struct attribute_spec java_attribute_table[] =
74 {
75  { "nonnull",                0, -1, false, true, true,
76                               NULL },
77   { NULL,                     0, 0, false, false, false, NULL }
78 };
79
80 /* Used to avoid printing error messages with bogus function
81    prototypes.  Starts out false.  */
82 static bool inhibit_error_function_printing;
83
84 const char *resource_name;
85
86 /* When nonzero, -Wall was turned on.  */
87 int flag_wall = 0;
88
89 /* When nonzero, report use of deprecated classes, methods, or fields.  */
90 int flag_deprecated = 1;
91
92 /* When zero, don't optimize static class initialization. This flag shouldn't
93    be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead.  */
94 /* FIXME: Make this work with gimplify.  */
95 /* int flag_optimize_sci = 0;  */
96
97 /* Don't attempt to verify invocations.  */
98 int flag_verify_invocations = 0; 
99
100 /* When nonzero, print extra version information.  */
101 static int v_flag = 0;
102
103 JCF *current_jcf;
104
105 /* Variable controlling how dependency tracking is enabled in
106    java_init.  */
107 static int dependency_tracking = 0;
108
109 /* Flag values for DEPENDENCY_TRACKING.  */
110 #define DEPEND_SET_FILE 1
111 #define DEPEND_ENABLE   2
112 #define DEPEND_TARGET_SET 4
113 #define DEPEND_FILE_ALREADY_SET 8
114
115 struct language_function GTY(())
116 {
117   int unused;
118 };
119
120 #undef LANG_HOOKS_NAME
121 #define LANG_HOOKS_NAME "GNU Java"
122 #undef LANG_HOOKS_INIT
123 #define LANG_HOOKS_INIT java_init
124 #undef LANG_HOOKS_FINISH
125 #define LANG_HOOKS_FINISH java_finish
126 #undef LANG_HOOKS_INIT_OPTIONS
127 #define LANG_HOOKS_INIT_OPTIONS java_init_options
128 #undef LANG_HOOKS_HANDLE_OPTION
129 #define LANG_HOOKS_HANDLE_OPTION java_handle_option
130 #undef LANG_HOOKS_POST_OPTIONS
131 #define LANG_HOOKS_POST_OPTIONS java_post_options
132 #undef LANG_HOOKS_PARSE_FILE
133 #define LANG_HOOKS_PARSE_FILE java_parse_file
134 #undef LANG_HOOKS_MARK_ADDRESSABLE
135 #define LANG_HOOKS_MARK_ADDRESSABLE java_mark_addressable
136 #undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL
137 #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL java_dup_lang_specific_decl
138 #undef LANG_HOOKS_DECL_PRINTABLE_NAME
139 #define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name
140 #undef LANG_HOOKS_PRINT_ERROR_FUNCTION
141 #define LANG_HOOKS_PRINT_ERROR_FUNCTION java_print_error_function
142
143 #undef LANG_HOOKS_TYPE_FOR_MODE
144 #define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode
145 #undef LANG_HOOKS_TYPE_FOR_SIZE
146 #define LANG_HOOKS_TYPE_FOR_SIZE java_type_for_size
147 #undef LANG_HOOKS_CLASSIFY_RECORD
148 #define LANG_HOOKS_CLASSIFY_RECORD java_classify_record
149
150 #undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN
151 #define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN java_dump_tree
152
153 #undef LANG_HOOKS_GIMPLIFY_EXPR
154 #define LANG_HOOKS_GIMPLIFY_EXPR java_gimplify_expr
155
156 #undef LANG_HOOKS_DECL_OK_FOR_SIBCALL
157 #define LANG_HOOKS_DECL_OK_FOR_SIBCALL java_decl_ok_for_sibcall
158
159 #undef LANG_HOOKS_GET_CALLEE_FNDECL
160 #define LANG_HOOKS_GET_CALLEE_FNDECL java_get_callee_fndecl
161
162 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
163 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME java_mangle_decl
164
165 #undef LANG_HOOKS_ATTRIBUTE_TABLE
166 #define LANG_HOOKS_ATTRIBUTE_TABLE java_attribute_table
167
168 /* Each front end provides its own.  */
169 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
170
171 /*
172  * process java-specific compiler command-line options
173  * return 0, but do not complain if the option is not recognized.
174  */
175 static int
176 java_handle_option (size_t scode, const char *arg, int value)
177 {
178   enum opt_code code = (enum opt_code) scode;
179
180   switch (code)
181     {
182     case OPT_I:
183       jcf_path_include_arg (arg);
184       break;
185
186     case OPT_M:
187       jcf_dependency_init (1);
188       dependency_tracking |= DEPEND_ENABLE;
189       break;
190
191     case OPT_MD_:
192       jcf_dependency_init (1);
193       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
194       break;
195
196     case OPT_MF:
197       jcf_dependency_set_dep_file (arg);
198       dependency_tracking |= DEPEND_FILE_ALREADY_SET;
199       break;
200
201     case OPT_MM:
202       jcf_dependency_init (0);
203       dependency_tracking |= DEPEND_ENABLE;
204       break;
205
206     case OPT_MMD_:
207       jcf_dependency_init (0);
208       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
209       break;
210
211     case OPT_MP:
212       jcf_dependency_print_dummies ();
213       break;
214
215     case OPT_MT:
216       jcf_dependency_set_target (arg);
217       dependency_tracking |= DEPEND_TARGET_SET;
218       break;
219
220     case OPT_Wall:
221       flag_wall = value;
222       /* When -Wall given, enable -Wunused.  We do this because the C
223          compiler does it, and people expect it.  */
224       warn_unused = value;
225       break;
226
227     case OPT_fenable_assertions_:
228       add_enable_assert (arg, value);
229       break;
230
231     case OPT_fenable_assertions:
232       add_enable_assert ("", value);
233       break;
234
235     case OPT_fdisable_assertions_:
236       add_enable_assert (arg, !value);
237       break;
238
239     case OPT_fdisable_assertions:
240       add_enable_assert ("", !value);
241       break;
242
243     case OPT_fassume_compiled_:
244       add_assume_compiled (arg, !value);
245       break;
246
247     case OPT_fassume_compiled:
248       add_assume_compiled ("", !value);
249       break;
250
251     case OPT_fbootclasspath_:
252       jcf_path_bootclasspath_arg (arg);
253       break;
254
255     case OPT_faux_classpath:
256     case OPT_fclasspath_:
257     case OPT_fCLASSPATH_:
258       jcf_path_classpath_arg (arg);
259       break;
260
261     case OPT_fcompile_resource_:
262       resource_name = arg;
263       break;
264
265     case OPT_fdump_:
266       if (!dump_switch_p (arg))
267         return 0;
268       break;
269
270     case OPT_fencoding_:
271       /* Nothing.  */
272       break;
273
274     case OPT_fextdirs_:
275       jcf_path_extdirs_arg (arg);
276       break;
277
278     case OPT_foutput_class_dir_:
279       /* FIXME: remove; this is handled by ecj1 now.  */
280       break;
281
282     case OPT_version:
283       v_flag = 1;
284       break;
285       
286     case OPT_fsource_filename_:
287       java_read_sourcefilenames (arg);
288       break;
289       
290     default:
291       if (cl_options[code].flags & CL_Java)
292         break;
293       gcc_unreachable ();
294     }
295
296   return 1;
297 }
298
299 /* Global open file.  */
300 FILE *finput;
301
302 static bool
303 java_init (void)
304 {
305   /* FIXME: Indirect dispatch isn't yet compatible with static class
306      init optimization.  */
307   if (flag_indirect_dispatch)
308     always_initialize_class_p = true;
309
310   if (!flag_indirect_dispatch)
311     flag_indirect_classes = false;
312
313   jcf_path_seal (v_flag);
314
315   java_init_decl_processing ();
316
317   using_eh_for_cleanups ();
318
319   return true;
320 }
321
322 static void
323 java_finish (void)
324 {
325   jcf_dependency_write ();
326 }
327
328 /* Buffer used by lang_printable_name. */
329 static char *decl_buf = NULL;
330
331 /* Allocated size of decl_buf. */
332 static int decl_buflen = 0;
333
334 /* Length of used part of decl_buf;  position for next character. */
335 static int decl_bufpos = 0;
336
337 /* Append the string STR to decl_buf.
338    It length is given by LEN;  -1 means the string is nul-terminated. */
339
340 static void
341 put_decl_string (const char *str, int len)
342 {
343   if (len < 0)
344     len = strlen (str);
345   if (decl_bufpos + len >= decl_buflen)
346     {
347       if (decl_buf == NULL)
348         {
349           decl_buflen = len + 100;
350           decl_buf = XNEWVEC (char, decl_buflen);
351         }
352       else
353         {
354           decl_buflen *= 2;
355           decl_buf = XRESIZEVAR (char, decl_buf, decl_buflen);
356         }
357     }
358   strcpy (decl_buf + decl_bufpos, str);
359   decl_bufpos += len;
360 }
361
362 /* Append to decl_buf a printable name for NODE. */
363
364 static void
365 put_decl_node (tree node)
366 {
367   int was_pointer = 0;
368   if (TREE_CODE (node) == POINTER_TYPE)
369     {
370       node = TREE_TYPE (node);
371       was_pointer = 1;
372     }
373   if (DECL_P (node) && DECL_NAME (node) != NULL_TREE)
374     {
375       if (TREE_CODE (node) == FUNCTION_DECL)
376         {
377           /* We want to print the type the DECL belongs to. We don't do
378              that when we handle constructors. */
379           if (! DECL_CONSTRUCTOR_P (node)
380               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node))
381             {
382               put_decl_node (TYPE_NAME (DECL_CONTEXT (node)));
383               put_decl_string (".", 1);
384             }
385           if (! DECL_CONSTRUCTOR_P (node))
386             put_decl_node (DECL_NAME (node));
387           if (TREE_TYPE (node) != NULL_TREE)
388             {
389               int i = 0;
390               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
391               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
392                 args = TREE_CHAIN (args);
393               put_decl_string ("(", 1);
394               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
395                 {
396                   if (i > 0)
397                     put_decl_string (",", 1);
398                   put_decl_node (TREE_VALUE (args));
399                 }
400               put_decl_string (")", 1);
401             }
402         }
403       else
404         put_decl_node (DECL_NAME (node));
405     }
406   else if (TYPE_P (node) && TYPE_NAME (node) != NULL_TREE)
407     {
408       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
409         {
410           put_decl_node (TYPE_ARRAY_ELEMENT (node));
411           put_decl_string("[]", 2);
412         }
413       else if (node == promoted_byte_type_node)
414         put_decl_string ("byte", 4);
415       else if (node == promoted_short_type_node)
416         put_decl_string ("short", 5);
417       else if (node == promoted_char_type_node)
418         put_decl_string ("char", 4);
419       else if (node == promoted_boolean_type_node)
420         put_decl_string ("boolean", 7);
421       else if (node == void_type_node && was_pointer)
422         put_decl_string ("null", 4);
423       else
424         put_decl_node (TYPE_NAME (node));
425     }
426   else if (TREE_CODE (node) == IDENTIFIER_NODE)
427     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
428   else
429     put_decl_string ("<unknown>", -1);
430 }
431
432 /* Return a user-friendly name for DECL.
433    The resulting string is only valid until the next call.
434    The value of the hook decl_printable_name is this function,
435    which is also called directly by java_print_error_function. */
436
437 const char *
438 lang_printable_name (tree decl, int v)
439 {
440   decl_bufpos = 0;
441   if (v == 0 && TREE_CODE (decl) == FUNCTION_DECL)
442     put_decl_node (DECL_NAME (decl));
443   else
444     put_decl_node (decl);
445   put_decl_string ("", 1);
446   return decl_buf;
447 }
448
449 /* Print on stderr the current class and method context.  This function
450    is the value of the hook print_error_function. */
451
452 static GTY(()) tree last_error_function_context;
453 static GTY(()) tree last_error_function;
454 static void
455 java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
456                            const char *file,
457                            diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
458 {
459   /* Don't print error messages with bogus function prototypes.  */
460   if (inhibit_error_function_printing)
461     return;
462
463   if (current_function_decl != NULL
464       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
465     {
466       if (file)
467         fprintf (stderr, "%s: ", file);
468
469       last_error_function_context = DECL_CONTEXT (current_function_decl);
470       fprintf (stderr, "In class '%s':\n",
471                lang_printable_name (last_error_function_context, 0));
472     }
473   if (last_error_function != current_function_decl)
474     {
475       if (file)
476         fprintf (stderr, "%s: ", file);
477
478       if (current_function_decl == NULL)
479         fprintf (stderr, "At top level:\n");
480       else
481         {
482           const char *name = lang_printable_name (current_function_decl, 2);
483           fprintf (stderr, "In %s '%s':\n",
484                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
485                     : "method"),
486                    name);
487         }
488
489       last_error_function = current_function_decl;
490     }
491
492 }
493
494 /* Called to install the PRINT_ERROR_FUNCTION hook differently
495    according to LEVEL. LEVEL is 1 during early parsing, when function
496    prototypes aren't fully resolved. java_print_error_function is set
497    so it doesn't print incomplete function prototypes. When LEVEL is
498    2, function prototypes are fully resolved and can be printed when
499    reporting errors.  */
500
501 void
502 lang_init_source (int level)
503 {
504   inhibit_error_function_printing = (level == 1);
505 }
506
507 static unsigned int
508 java_init_options (unsigned int argc ATTRIBUTE_UNUSED,
509                    const char **argv ATTRIBUTE_UNUSED)
510 {
511   flag_bounds_check = 1;
512   flag_exceptions = 1;
513   flag_non_call_exceptions = 1;
514
515   /* In Java floating point operations never trap.  */
516   flag_trapping_math = 0;
517
518   /* In Java arithmetic overflow always wraps around.  */
519   flag_wrapv = 1;
520
521   /* Java requires left-to-right evaluation of subexpressions.  */
522   flag_evaluation_order = 1;
523
524   jcf_path_init ();
525
526   return CL_Java;
527 }
528
529 /* Post-switch processing.  */
530 static bool
531 java_post_options (const char **pfilename)
532 {
533   const char *filename = *pfilename;
534
535   /* An absolute requirement: if we're not using indirect dispatch, we
536      must always verify everything.  */
537   if (! flag_indirect_dispatch)
538     flag_verify_invocations = true;
539
540   if (flag_reduced_reflection)
541     {
542       if (flag_indirect_dispatch)
543         error ("-findirect-dispatch is incompatible "
544                "with -freduced-reflection");
545       if (flag_jni)
546         error ("-fjni is incompatible with -freduced-reflection");
547     }
548
549   /* Open input file.  */
550
551   if (filename == 0 || !strcmp (filename, "-"))
552     {
553       finput = stdin;
554       filename = "stdin";
555
556       if (dependency_tracking)
557         error ("can't do dependency tracking with input from stdin");
558     }
559   else
560     {
561       if (dependency_tracking)
562         {
563           char *dot;
564
565           /* If the target is set and the output filename is set, then
566              there's no processing to do here.  Otherwise we must
567              compute one or the other.  */
568           if (! ((dependency_tracking & DEPEND_TARGET_SET)
569                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
570             {
571               dot = strrchr (filename, '.');
572               if (dot == NULL)
573                 error ("couldn't determine target name for dependency tracking");
574               else
575                 {
576                   char *buf = XNEWVEC (char, dot - filename +
577                                        3 + sizeof (TARGET_OBJECT_SUFFIX));
578                   strncpy (buf, filename, dot - filename);
579
580                   /* If emitting class files, we might have multiple
581                      targets.  The class generation code takes care of
582                      registering them.  Otherwise we compute the
583                      target name here.  */
584                   if ((dependency_tracking & DEPEND_TARGET_SET))
585                     ; /* Nothing.  */
586                   else
587                     {
588                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
589                       jcf_dependency_set_target (buf);
590                     }
591
592                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
593                     ; /* Nothing.  */
594                   else if ((dependency_tracking & DEPEND_SET_FILE))
595                     {
596                       strcpy (buf + (dot - filename), ".d");
597                       jcf_dependency_set_dep_file (buf);
598                     }
599                   else
600                     jcf_dependency_set_dep_file ("-");
601
602                   free (buf);
603                 }
604             }
605         }
606     }
607   linemap_add (line_table, LC_ENTER, false, filename, 0);
608   linemap_add (line_table, LC_RENAME, false, "<built-in>", 0);
609
610   /* Initialize the compiler back end.  */
611   return false;
612 }
613
614 /* Return either DECL or its known constant value (if it has one).  */
615
616 tree
617 decl_constant_value (tree decl)
618 {
619   if (/* Don't change a variable array bound or initial value to a constant
620          in a place where a variable is invalid.  */
621       current_function_decl != 0
622       && ! TREE_THIS_VOLATILE (decl)
623       && TREE_READONLY (decl)
624       && DECL_INITIAL (decl) != 0
625       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
626       /* This is invalid if initial value is not constant.
627          If it has either a function call, a memory reference,
628          or a variable, then re-evaluating it could give different results.  */
629       && TREE_CONSTANT (DECL_INITIAL (decl))
630       /* Check for cases where this is sub-optimal, even though valid.  */
631       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
632     return DECL_INITIAL (decl);
633   return decl;
634 }
635
636 /* Every call to a static constructor has an associated boolean
637    variable which is in the outermost scope of the calling method.
638    This variable is used to avoid multiple calls to the static
639    constructor for each class.
640
641    It looks something like this:
642
643    foo ()
644    {
645       boolean dummy = OtherClass.is_initialized;
646
647      ...
648
649      if (! dummy)
650        OtherClass.initialize();
651
652      ... use OtherClass.data ...
653    }
654
655    Each of these boolean variables has an entry in the
656    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
657    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
658    being inlined and create the boolean variables in the outermost
659    scope of the method being inlined into.  */
660
661 /* Create a mapping from a boolean variable in a method being inlined
662    to one in the scope of the method being inlined into.  */
663
664 static int
665 merge_init_test_initialization (void **entry, void *x)
666 {
667   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
668   splay_tree decl_map = (splay_tree)x;
669   splay_tree_node n;
670   tree *init_test_decl;
671
672   /* See if we have remapped this declaration.  If we haven't there's
673      a bug in the inliner.  */
674   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
675   gcc_assert (n);
676
677   /* Create a new entry for the class and its remapped boolean
678      variable.  If we already have a mapping for this class we've
679      already initialized it, so don't overwrite the value.  */
680   init_test_decl = java_treetreehash_new
681     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
682   if (!*init_test_decl)
683     *init_test_decl = (tree)n->value;
684
685   /* This fixes a weird case.
686
687   The front end assumes that once we have called a method that
688   initializes some class, we can assume the class is initialized.  It
689   does this by setting the DECL_INITIAL of the init_test_decl for that
690   class, and no initializations are emitted for that class.
691
692   However, what if the method that is supposed to do the initialization
693   is itself inlined in the caller?  When expanding the called method
694   we'll assume that the class initialization has already been done,
695   because the DECL_INITIAL of the init_test_decl is set.
696
697   To fix this we remove the DECL_INITIAL (in the caller scope) of all
698   the init_test_decls corresponding to classes initialized by the
699   inlined method.  This makes the caller no longer assume that the
700   method being inlined does any class initializations.  */
701   DECL_INITIAL (*init_test_decl) = NULL;
702
703   return true;
704 }
705
706 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
707    inlining.  */
708
709 void
710 java_inlining_merge_static_initializers (tree fn, void *decl_map)
711 {
712   htab_traverse
713     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
714      merge_init_test_initialization, decl_map);
715 }
716
717 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
718    inlining into.  If we already have a corresponding entry in that
719    class we don't need to create another one, so we create a mapping
720    from the variable in the inlined class to the corresponding
721    pre-existing one.  */
722
723 static int
724 inline_init_test_initialization (void **entry, void *x)
725 {
726   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
727   splay_tree decl_map = (splay_tree)x;
728
729   tree h = java_treetreehash_find
730     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
731   if (! h)
732     return true;
733   splay_tree_insert (decl_map,
734                      (splay_tree_key) ite->value,
735                      (splay_tree_value) h);
736   return true;
737 }
738
739 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
740    of a method being inlined.  For each hone, if we already have a
741    variable associated with the same class in the method being inlined
742    into, create a new mapping for it.  */
743
744 void
745 java_inlining_map_static_initializers (tree fn, void *decl_map)
746 {
747   htab_traverse
748     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
749      inline_init_test_initialization, decl_map);
750 }
751
752 /* Avoid voluminous output for deep recursion of compound exprs.  */
753
754 static void
755 dump_compound_expr (dump_info_p di, tree t)
756 {
757   int i;
758
759   for (i=0; i<2; i++)
760     {
761       switch (TREE_CODE (TREE_OPERAND (t, i)))
762         {
763         case COMPOUND_EXPR:
764           dump_compound_expr (di, TREE_OPERAND (t, i));
765           break;
766
767         default:
768           dump_child ("expr", TREE_OPERAND (t, i));
769         }
770     }
771 }
772
773 static bool
774 java_dump_tree (void *dump_info, tree t)
775 {
776   enum tree_code code;
777   dump_info_p di = (dump_info_p) dump_info;
778
779   /* Figure out what kind of node this is.  */
780   code = TREE_CODE (t);
781
782   switch (code)
783     {
784     case FUNCTION_DECL:
785       dump_child ("args", DECL_ARGUMENTS (t));
786       if (DECL_EXTERNAL (t))
787         dump_string (di, "undefined");
788       if (TREE_PUBLIC (t))
789         dump_string (di, "extern");
790       else
791         dump_string (di, "static");
792       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
793         dump_child ("inline body", DECL_SAVED_TREE (t));
794       return true;
795
796     case RETURN_EXPR:
797       dump_child ("expr", TREE_OPERAND (t, 0));
798       return true;
799
800     case GOTO_EXPR:
801       dump_child ("goto", TREE_OPERAND (t, 0));
802       return true;
803
804     case LABEL_EXPR:
805       dump_child ("label", TREE_OPERAND (t, 0));
806       return true;
807
808     case BLOCK:
809       if (BLOCK_EXPR_BODY (t))
810         {
811           tree local = BLOCK_VARS (t);
812           while (local)
813             {
814               tree next = TREE_CHAIN (local);
815               dump_child ("var", local);
816               local = next;
817             }
818
819           {
820             tree block = BLOCK_EXPR_BODY (t);
821             dump_child ("body", block);
822             block = TREE_CHAIN (block);
823           }
824         }
825       return true;
826
827     case COMPOUND_EXPR:
828       if (!dump_flag (di, TDF_SLIM, t))
829         return false;
830       dump_compound_expr (di, t);
831       return true;
832
833     default:
834       break;
835     }
836   return false;
837 }
838
839 /* Java calls can't, in general, be sibcalls because we need an
840    accurate stack trace in order to guarantee correct operation of
841    methods such as Class.forName(String) and
842    SecurityManager.getClassContext().  */
843
844 static bool
845 java_decl_ok_for_sibcall (const_tree decl)
846 {
847   return (decl != NULL && DECL_CONTEXT (decl) == output_class
848           && !DECL_UNINLINABLE (decl));
849 }
850
851 /* Given a call_expr, try to figure out what its target might be.  In
852    the case of an indirection via the atable, search for the decl.  If
853    the decl is external, we return NULL.  If we don't, the optimizer
854    will replace the indirection with a direct call, which undoes the
855    purpose of the atable indirection.  */
856 static tree
857 java_get_callee_fndecl (const_tree call_expr)
858 {
859   tree method, table, element, atable_methods;
860
861   HOST_WIDE_INT index;
862
863   /* FIXME: This is disabled because we end up passing calls through
864      the PLT, and we do NOT want to do that.  */
865   return NULL;
866
867   if (TREE_CODE (call_expr) != CALL_EXPR)
868     return NULL;
869   method = CALL_EXPR_FN (call_expr);
870   STRIP_NOPS (method);
871   if (TREE_CODE (method) != ARRAY_REF)
872     return NULL;
873   table = TREE_OPERAND (method, 0);
874   if (! DECL_LANG_SPECIFIC(table)
875       || !DECL_OWNER (table)
876       || TYPE_ATABLE_DECL (DECL_OWNER (table)) != table)
877     return NULL;
878
879   atable_methods = TYPE_ATABLE_METHODS (DECL_OWNER (table));
880   index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
881
882   /* FIXME: Replace this for loop with a hash table lookup.  */
883   for (element = atable_methods; element; element = TREE_CHAIN (element))
884     {
885       if (index == 1)
886         {
887           tree purpose = TREE_PURPOSE (element);
888           if (TREE_CODE (purpose) == FUNCTION_DECL
889               && ! DECL_EXTERNAL (purpose))
890             return purpose;
891           else
892             return NULL;
893         }
894       --index;
895     }
896
897   return NULL;
898 }
899
900
901 static enum classify_record
902 java_classify_record (tree type)
903 {
904   if (! CLASS_P (type))
905     return RECORD_IS_STRUCT;
906
907   /* ??? GDB does not support DW_TAG_interface_type as of December,
908      2007.  Re-enable this at a later time.  */
909   if (0 && CLASS_INTERFACE (TYPE_NAME (type)))
910     return RECORD_IS_INTERFACE;
911
912   return RECORD_IS_CLASS;
913 }
914
915 #include "gt-java-lang.h"