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