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