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