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