gcc/java/lang.c

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