gcc/java/lang.c

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