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