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       set_Wunused (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   /* Unit at a time is disabled for Java because it is considered
 525      too expensive.  */
 526   no_unit_at_a_time_default = 1;
 527
 528   jcf_path_init ();
 529
 530   return CL_Java;
 531 }
 532
 533 /* Post-switch processing.  */
 534 static bool
 535 java_post_options (const char **pfilename)
 536 {
 537   const char *filename = *pfilename;
 538
 539   /* Use tree inlining.  */
 540   if (!flag_no_inline)
 541     flag_no_inline = 1;
 542   if (flag_inline_functions)
 543     flag_inline_trees = 2;
 544
 545   /* An absolute requirement: if we're not using indirect dispatch, we
 546      must always verify everything.  */
 547   if (! flag_indirect_dispatch)
 548     flag_verify_invocations = true;
 549
 550   if (flag_reduced_reflection)
 551     {
 552       if (flag_indirect_dispatch)
 553         error ("-findirect-dispatch is incompatible "
 554                "with -freduced-reflection");
 555       if (flag_jni)
 556         error ("-fjni is incompatible with -freduced-reflection");
 557     }
 558
 559   /* Open input file.  */
 560
 561   if (filename == 0 || !strcmp (filename, "-"))
 562     {
 563       finput = stdin;
 564       filename = "stdin";
 565
 566       if (dependency_tracking)
 567         error ("can't do dependency tracking with input from stdin");
 568     }
 569   else
 570     {
 571       if (dependency_tracking)
 572         {
 573           char *dot;
 574
 575           /* If the target is set and the output filename is set, then
 576              there's no processing to do here.  Otherwise we must
 577              compute one or the other.  */
 578           if (! ((dependency_tracking & DEPEND_TARGET_SET)
 579                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
 580             {
 581               dot = strrchr (filename, '.');
 582               if (dot == NULL)
 583                 error ("couldn't determine target name for dependency tracking");
 584               else
 585                 {
 586                   char *buf = XNEWVEC (char, dot - filename +
 587                                        3 + sizeof (TARGET_OBJECT_SUFFIX));
 588                   strncpy (buf, filename, dot - filename);
 589
 590                   /* If emitting class files, we might have multiple
 591                      targets.  The class generation code takes care of
 592                      registering them.  Otherwise we compute the
 593                      target name here.  */
 594                   if ((dependency_tracking & DEPEND_TARGET_SET))
 595                     ; /* Nothing.  */
 596                   else
 597                     {
 598                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
 599                       jcf_dependency_set_target (buf);
 600                     }
 601
 602                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
 603                     ; /* Nothing.  */
 604                   else if ((dependency_tracking & DEPEND_SET_FILE))
 605                     {
 606                       strcpy (buf + (dot - filename), ".d");
 607                       jcf_dependency_set_dep_file (buf);
 608                     }
 609                   else
 610                     jcf_dependency_set_dep_file ("-");
 611
 612                   free (buf);
 613                 }
 614             }
 615         }
 616     }
 617   linemap_add (line_table, LC_ENTER, false, filename, 0);
 618   linemap_add (line_table, LC_RENAME, false, "<built-in>", 0);
 619
 620   /* Initialize the compiler back end.  */
 621   return false;
 622 }
 623
 624 /* Return either DECL or its known constant value (if it has one).  */
 625
 626 tree
 627 decl_constant_value (tree decl)
 628 {
 629   if (/* Don't change a variable array bound or initial value to a constant
 630          in a place where a variable is invalid.  */
 631       current_function_decl != 0
 632       && ! TREE_THIS_VOLATILE (decl)
 633       && TREE_READONLY (decl)
 634       && DECL_INITIAL (decl) != 0
 635       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 636       /* This is invalid if initial value is not constant.
 637          If it has either a function call, a memory reference,
 638          or a variable, then re-evaluating it could give different results.  */
 639       && TREE_CONSTANT (DECL_INITIAL (decl))
 640       /* Check for cases where this is sub-optimal, even though valid.  */
 641       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 642     return DECL_INITIAL (decl);
 643   return decl;
 644 }
 645
 646 /* Every call to a static constructor has an associated boolean
 647    variable which is in the outermost scope of the calling method.
 648    This variable is used to avoid multiple calls to the static
 649    constructor for each class.
 650
 651    It looks something like this:
 652
 653    foo ()
 654    {
 655       boolean dummy = OtherClass.is_initialized;
 656
 657      ...
 658
 659      if (! dummy)
 660        OtherClass.initialize();
 661
 662      ... use OtherClass.data ...
 663    }
 664
 665    Each of these boolean variables has an entry in the
 666    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 667    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 668    being inlined and create the boolean variables in the outermost
 669    scope of the method being inlined into.  */
 670
 671 /* Create a mapping from a boolean variable in a method being inlined
 672    to one in the scope of the method being inlined into.  */
 673
 674 static int
 675 merge_init_test_initialization (void **entry, void *x)
 676 {
 677   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 678   splay_tree decl_map = (splay_tree)x;
 679   splay_tree_node n;
 680   tree *init_test_decl;
 681
 682   /* See if we have remapped this declaration.  If we haven't there's
 683      a bug in the inliner.  */
 684   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 685   gcc_assert (n);
 686
 687   /* Create a new entry for the class and its remapped boolean
 688      variable.  If we already have a mapping for this class we've
 689      already initialized it, so don't overwrite the value.  */
 690   init_test_decl = java_treetreehash_new
 691     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 692   if (!*init_test_decl)
 693     *init_test_decl = (tree)n->value;
 694
 695   /* This fixes a weird case.
 696
 697   The front end assumes that once we have called a method that
 698   initializes some class, we can assume the class is initialized.  It
 699   does this by setting the DECL_INITIAL of the init_test_decl for that
 700   class, and no initializations are emitted for that class.
 701
 702   However, what if the method that is supposed to do the initialization
 703   is itself inlined in the caller?  When expanding the called method
 704   we'll assume that the class initialization has already been done,
 705   because the DECL_INITIAL of the init_test_decl is set.
 706
 707   To fix this we remove the DECL_INITIAL (in the caller scope) of all
 708   the init_test_decls corresponding to classes initialized by the
 709   inlined method.  This makes the caller no longer assume that the
 710   method being inlined does any class initializations.  */
 711   DECL_INITIAL (*init_test_decl) = NULL;
 712
 713   return true;
 714 }
 715
 716 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 717    inlining.  */
 718
 719 void
 720 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 721 {
 722   htab_traverse
 723     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 724      merge_init_test_initialization, decl_map);
 725 }
 726
 727 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 728    inlining into.  If we already have a corresponding entry in that
 729    class we don't need to create another one, so we create a mapping
 730    from the variable in the inlined class to the corresponding
 731    pre-existing one.  */
 732
 733 static int
 734 inline_init_test_initialization (void **entry, void *x)
 735 {
 736   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 737   splay_tree decl_map = (splay_tree)x;
 738
 739   tree h = java_treetreehash_find
 740     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 741   if (! h)
 742     return true;
 743   splay_tree_insert (decl_map,
 744                      (splay_tree_key) ite->value,
 745                      (splay_tree_value) h);
 746   return true;
 747 }
 748
 749 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 750    of a method being inlined.  For each hone, if we already have a
 751    variable associated with the same class in the method being inlined
 752    into, create a new mapping for it.  */
 753
 754 void
 755 java_inlining_map_static_initializers (tree fn, void *decl_map)
 756 {
 757   htab_traverse
 758     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 759      inline_init_test_initialization, decl_map);
 760 }
 761
 762 /* Avoid voluminous output for deep recursion of compound exprs.  */
 763
 764 static void
 765 dump_compound_expr (dump_info_p di, tree t)
 766 {
 767   int i;
 768
 769   for (i=0; i<2; i++)
 770     {
 771       switch (TREE_CODE (TREE_OPERAND (t, i)))
 772         {
 773         case COMPOUND_EXPR:
 774           dump_compound_expr (di, TREE_OPERAND (t, i));
 775           break;
 776
 777         default:
 778           dump_child ("expr", TREE_OPERAND (t, i));
 779         }
 780     }
 781 }
 782
 783 static bool
 784 java_dump_tree (void *dump_info, tree t)
 785 {
 786   enum tree_code code;
 787   dump_info_p di = (dump_info_p) dump_info;
 788
 789   /* Figure out what kind of node this is.  */
 790   code = TREE_CODE (t);
 791
 792   switch (code)
 793     {
 794     case FUNCTION_DECL:
 795       dump_child ("args", DECL_ARGUMENTS (t));
 796       if (DECL_EXTERNAL (t))
 797         dump_string (di, "undefined");
 798       if (TREE_PUBLIC (t))
 799         dump_string (di, "extern");
 800       else
 801         dump_string (di, "static");
 802       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
 803         dump_child ("inline body", DECL_SAVED_TREE (t));
 804       return true;
 805
 806     case RETURN_EXPR:
 807       dump_child ("expr", TREE_OPERAND (t, 0));
 808       return true;
 809
 810     case GOTO_EXPR:
 811       dump_child ("goto", TREE_OPERAND (t, 0));
 812       return true;
 813
 814     case LABEL_EXPR:
 815       dump_child ("label", TREE_OPERAND (t, 0));
 816       return true;
 817
 818     case BLOCK:
 819       if (BLOCK_EXPR_BODY (t))
 820         {
 821           tree local = BLOCK_VARS (t);
 822           while (local)
 823             {
 824               tree next = TREE_CHAIN (local);
 825               dump_child ("var", local);
 826               local = next;
 827             }
 828
 829           {
 830             tree block = BLOCK_EXPR_BODY (t);
 831             dump_child ("body", block);
 832             block = TREE_CHAIN (block);
 833           }
 834         }
 835       return true;
 836
 837     case COMPOUND_EXPR:
 838       if (!dump_flag (di, TDF_SLIM, t))
 839         return false;
 840       dump_compound_expr (di, t);
 841       return true;
 842
 843     default:
 844       break;
 845     }
 846   return false;
 847 }
 848
 849 /* Java calls can't, in general, be sibcalls because we need an
 850    accurate stack trace in order to guarantee correct operation of
 851    methods such as Class.forName(String) and
 852    SecurityManager.getClassContext().  */
 853
 854 static bool
 855 java_decl_ok_for_sibcall (const_tree decl)
 856 {
 857   return (decl != NULL && DECL_CONTEXT (decl) == output_class
 858           && DECL_INLINE (decl));
 859 }
 860
 861 /* Given a call_expr, try to figure out what its target might be.  In
 862    the case of an indirection via the atable, search for the decl.  If
 863    the decl is external, we return NULL.  If we don't, the optimizer
 864    will replace the indirection with a direct call, which undoes the
 865    purpose of the atable indirection.  */
 866 static tree
 867 java_get_callee_fndecl (const_tree call_expr)
 868 {
 869   tree method, table, element, atable_methods;
 870
 871   HOST_WIDE_INT index;
 872
 873   /* FIXME: This is disabled because we end up passing calls through
 874      the PLT, and we do NOT want to do that.  */
 875   return NULL;
 876
 877   if (TREE_CODE (call_expr) != CALL_EXPR)
 878     return NULL;
 879   method = CALL_EXPR_FN (call_expr);
 880   STRIP_NOPS (method);
 881   if (TREE_CODE (method) != ARRAY_REF)
 882     return NULL;
 883   table = TREE_OPERAND (method, 0);
 884   if (! DECL_LANG_SPECIFIC(table)
 885       || !DECL_OWNER (table)
 886       || TYPE_ATABLE_DECL (DECL_OWNER (table)) != table)
 887     return NULL;
 888
 889   atable_methods = TYPE_ATABLE_METHODS (DECL_OWNER (table));
 890   index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
 891
 892   /* FIXME: Replace this for loop with a hash table lookup.  */
 893   for (element = atable_methods; element; element = TREE_CHAIN (element))
 894     {
 895       if (index == 1)
 896         {
 897           tree purpose = TREE_PURPOSE (element);
 898           if (TREE_CODE (purpose) == FUNCTION_DECL
 899               && ! DECL_EXTERNAL (purpose))
 900             return purpose;
 901           else
 902             return NULL;
 903         }
 904       --index;
 905     }
 906
 907   return NULL;
 908 }
 909
 910
 911 static enum classify_record
 912 java_classify_record (tree type)
 913 {
 914   if (! CLASS_P (type))
 915     return RECORD_IS_STRUCT;
 916
 917   /* ??? GDB does not support DW_TAG_interface_type as of December,
 918      2007.  Re-enable this at a later time.  */
 919   if (0 && CLASS_INTERFACE (TYPE_NAME (type)))
 920     return RECORD_IS_INTERFACE;
 921
 922   return RECORD_IS_CLASS;
 923 }
 924
 925 #include "gt-java-lang.h"