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