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