gcc/java/lang.c

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