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"