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 char tree_code_type[] = {
  82 #include "tree.def"
  83   'x',
  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 (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
 434       && DECL_NAME (node) != NULL_TREE)
 435     {
 436       if (TREE_CODE (node) == FUNCTION_DECL)
 437         {
 438           /* We want to print the type the DECL belongs to. We don't do
 439              that when we handle constructors. */
 440           if (! DECL_CONSTRUCTOR_P (node)
 441               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node))
 442             {
 443               put_decl_node (TYPE_NAME (DECL_CONTEXT (node)));
 444               put_decl_string (".", 1);
 445             }
 446           if (! DECL_CONSTRUCTOR_P (node))
 447             put_decl_node (DECL_NAME (node));
 448           if (TREE_TYPE (node) != NULL_TREE)
 449             {
 450               int i = 0;
 451               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
 452               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
 453                 args = TREE_CHAIN (args);
 454               put_decl_string ("(", 1);
 455               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
 456                 {
 457                   if (i > 0)
 458                     put_decl_string (",", 1);
 459                   put_decl_node (TREE_VALUE (args));
 460                 }
 461               put_decl_string (")", 1);
 462             }
 463         }
 464       else
 465         put_decl_node (DECL_NAME (node));
 466     }
 467   else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
 468       && TYPE_NAME (node) != NULL_TREE)
 469     {
 470       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
 471         {
 472           put_decl_node (TYPE_ARRAY_ELEMENT (node));
 473           put_decl_string("[]", 2);
 474         }
 475       else if (node == promoted_byte_type_node)
 476         put_decl_string ("byte", 4);
 477       else if (node == promoted_short_type_node)
 478         put_decl_string ("short", 5);
 479       else if (node == promoted_char_type_node)
 480         put_decl_string ("char", 4);
 481       else if (node == promoted_boolean_type_node)
 482         put_decl_string ("boolean", 7);
 483       else if (node == void_type_node && was_pointer)
 484         put_decl_string ("null", 4);
 485       else
 486         put_decl_node (TYPE_NAME (node));
 487     }
 488   else if (TREE_CODE (node) == IDENTIFIER_NODE)
 489     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
 490   else
 491     put_decl_string ("<unknown>", -1);
 492 }
 493
 494 /* Return a user-friendly name for DECL.
 495    The resulting string is only valid until the next call.
 496    The value of the hook decl_printable_name is this function,
 497    which is also called directly by java_print_error_function. */
 498
 499 const char *
 500 lang_printable_name (tree decl, int v  __attribute__ ((__unused__)))
 501 {
 502   decl_bufpos = 0;
 503   put_decl_node (decl);
 504   put_decl_string ("", 1);
 505   return decl_buf;
 506 }
 507
 508 /* Does the same thing that lang_printable_name, but add a leading
 509    space to the DECL name string -- With Leading Space.  */
 510
 511 const char *
 512 lang_printable_name_wls (tree decl, int v  __attribute__ ((__unused__)))
 513 {
 514   decl_bufpos = 1;
 515   put_decl_node (decl);
 516   put_decl_string ("", 1);
 517   decl_buf [0] = ' ';
 518   return decl_buf;
 519 }
 520
 521 /* Print on stderr the current class and method context.  This function
 522    is the value of the hook print_error_function. */
 523
 524 static GTY(()) tree last_error_function_context;
 525 static GTY(()) tree last_error_function;
 526 static void
 527 java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
 528                            const char *file)
 529 {
 530   /* Don't print error messages with bogus function prototypes.  */
 531   if (inhibit_error_function_printing)
 532     return;
 533
 534   if (current_function_decl != NULL
 535       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
 536     {
 537       if (file)
 538         fprintf (stderr, "%s: ", file);
 539
 540       last_error_function_context = DECL_CONTEXT (current_function_decl);
 541       fprintf (stderr, "In class `%s':\n",
 542                lang_printable_name (last_error_function_context, 0));
 543     }
 544   if (last_error_function != current_function_decl)
 545     {
 546       if (file)
 547         fprintf (stderr, "%s: ", file);
 548
 549       if (current_function_decl == NULL)
 550         fprintf (stderr, "At top level:\n");
 551       else
 552         {
 553           const char *name = lang_printable_name (current_function_decl, 2);
 554           fprintf (stderr, "In %s `%s':\n",
 555                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
 556                     : "method"),
 557                    name);
 558         }
 559
 560       last_error_function = current_function_decl;
 561     }
 562
 563 }
 564
 565 /* Called to install the PRINT_ERROR_FUNCTION hook differently
 566    according to LEVEL. LEVEL is 1 during early parsing, when function
 567    prototypes aren't fully resolved. java_print_error_function is set
 568    so it doesn't print incomplete function prototypes. When LEVEL is
 569    2, function prototypes are fully resolved and can be printed when
 570    reporting errors.  */
 571
 572 void
 573 lang_init_source (int level)
 574 {
 575   inhibit_error_function_printing = (level == 1);
 576 }
 577
 578 static unsigned int
 579 java_init_options (unsigned int argc ATTRIBUTE_UNUSED,
 580                    const char **argv ATTRIBUTE_UNUSED)
 581 {
 582   flag_bounds_check = 1;
 583   flag_exceptions = 1;
 584   flag_non_call_exceptions = 1;
 585
 586   /* In Java floating point operations never trap.  */
 587   flag_trapping_math = 0;
 588
 589   /* In Java arithmetic overflow always wraps around.  */
 590   flag_wrapv = 1;
 591
 592   /* Java requires left-to-right evaluation of subexpressions.  */
 593   flag_evaluation_order = 1;
 594
 595   jcf_path_init ();
 596
 597   return CL_Java;
 598 }
 599
 600 static bool
 601 java_can_use_bit_fields_p (void)
 602 {
 603   /* The bit-field optimizations cause problems when generating class
 604      files.  */
 605   return flag_emit_class_files ? false : true;
 606 }
 607
 608 /* Post-switch processing.  */
 609 static bool
 610 java_post_options (const char **pfilename)
 611 {
 612   const char *filename = *pfilename;
 613
 614   /* Use tree inlining.  */
 615   if (!flag_no_inline)
 616     flag_no_inline = 1;
 617   if (flag_inline_functions)
 618     {
 619       flag_inline_trees = 2;
 620       flag_inline_functions = 0;
 621     }
 622
 623   /* Open input file.  */
 624
 625   if (filename == 0 || !strcmp (filename, "-"))
 626     {
 627       finput = stdin;
 628       filename = "stdin";
 629
 630       if (dependency_tracking)
 631         error ("can't do dependency tracking with input from stdin");
 632     }
 633   else
 634     {
 635       if (dependency_tracking)
 636         {
 637           char *dot;
 638
 639           /* If the target is set and the output filename is set, then
 640              there's no processing to do here.  Otherwise we must
 641              compute one or the other.  */
 642           if (! ((dependency_tracking & DEPEND_TARGET_SET)
 643                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
 644             {
 645               dot = strrchr (filename, '.');
 646               if (dot == NULL)
 647                 error ("couldn't determine target name for dependency tracking");
 648               else
 649                 {
 650                   char *buf = xmalloc (dot - filename +
 651                                        3 + sizeof (TARGET_OBJECT_SUFFIX));
 652                   strncpy (buf, filename, dot - filename);
 653
 654                   /* If emitting class files, we might have multiple
 655                      targets.  The class generation code takes care of
 656                      registering them.  Otherwise we compute the
 657                      target name here.  */
 658                   if ((dependency_tracking & DEPEND_TARGET_SET))
 659                     ; /* Nothing.  */
 660                   else if (flag_emit_class_files)
 661                     jcf_dependency_set_target (NULL);
 662                   else
 663                     {
 664                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
 665                       jcf_dependency_set_target (buf);
 666                     }
 667
 668                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
 669                     ; /* Nothing.  */
 670                   else if ((dependency_tracking & DEPEND_SET_FILE))
 671                     {
 672                       strcpy (buf + (dot - filename), ".d");
 673                       jcf_dependency_set_dep_file (buf);
 674                     }
 675                   else
 676                     jcf_dependency_set_dep_file ("-");
 677
 678                   free (buf);
 679                 }
 680             }
 681         }
 682     }
 683
 684   /* Initialize the compiler back end.  */
 685   return false;
 686 }
 687
 688 /* Return either DECL or its known constant value (if it has one).  */
 689
 690 tree
 691 decl_constant_value (tree decl)
 692 {
 693   if (/* Don't change a variable array bound or initial value to a constant
 694          in a place where a variable is invalid.  */
 695       current_function_decl != 0
 696       && ! TREE_THIS_VOLATILE (decl)
 697       && TREE_READONLY (decl)
 698       && DECL_INITIAL (decl) != 0
 699       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 700       /* This is invalid if initial value is not constant.
 701          If it has either a function call, a memory reference,
 702          or a variable, then re-evaluating it could give different results.  */
 703       && TREE_CONSTANT (DECL_INITIAL (decl))
 704       /* Check for cases where this is sub-optimal, even though valid.  */
 705       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 706     return DECL_INITIAL (decl);
 707   return decl;
 708 }
 709
 710 /* Walk the language specific tree nodes during inlining.  */
 711
 712 static tree
 713 java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 714                                   int *subtrees ATTRIBUTE_UNUSED,
 715                                   walk_tree_fn func ATTRIBUTE_UNUSED,
 716                                   void *data ATTRIBUTE_UNUSED,
 717                                   void *htab ATTRIBUTE_UNUSED)
 718 {
 719   enum tree_code code;
 720   tree result;
 721
 722 #define WALK_SUBTREE(NODE)                              \
 723   do                                                    \
 724     {                                                   \
 725       result = walk_tree (&(NODE), func, data, htab);   \
 726       if (result)                                       \
 727         return result;                                  \
 728     }                                                   \
 729   while (0)
 730
 731   tree t = *tp;
 732   if (!t)
 733     return NULL_TREE;
 734
 735   code = TREE_CODE (t);
 736   switch (code)
 737     {
 738     case BLOCK:
 739       WALK_SUBTREE (BLOCK_EXPR_BODY (t));
 740       return NULL_TREE;
 741
 742     default:
 743       return NULL_TREE;
 744     }
 745
 746   #undef WALK_SUBTREE
 747 }
 748
 749 /* Every call to a static constructor has an associated boolean
 750    variable which is in the outermost scope of the calling method.
 751    This variable is used to avoid multiple calls to the static
 752    constructor for each class.
 753
 754    It looks something like this:
 755
 756    foo ()
 757    {
 758       boolean dummy = OtherClass.is_initialized;
 759
 760      ...
 761
 762      if (! dummy)
 763        OtherClass.initialize();
 764
 765      ... use OtherClass.data ...
 766    }
 767
 768    Each of these boolean variables has an entry in the
 769    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 770    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 771    being inlined and create the boolean variables in the outermost
 772    scope of the method being inlined into.  */
 773
 774 /* Create a mapping from a boolean variable in a method being inlined
 775    to one in the scope of the method being inlined into.  */
 776
 777 static int
 778 merge_init_test_initialization (void **entry, void *x)
 779 {
 780   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 781   splay_tree decl_map = (splay_tree)x;
 782   splay_tree_node n;
 783   tree *init_test_decl;
 784
 785   /* See if we have remapped this declaration.  If we haven't there's
 786      a bug in the inliner.  */
 787   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 788   if (! n)
 789     abort ();
 790
 791   /* Create a new entry for the class and its remapped boolean
 792      variable.  If we already have a mapping for this class we've
 793      already initialized it, so don't overwrite the value.  */
 794   init_test_decl = java_treetreehash_new
 795     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 796   if (!*init_test_decl)
 797     *init_test_decl = (tree)n->value;
 798
 799   /* This fixes a weird case.
 800
 801   The front end assumes that once we have called a method that
 802   initializes some class, we can assume the class is initialized.  It
 803   does this by setting the DECL_INITIAL of the init_test_decl for that
 804   class, and no initializations are emitted for that class.
 805
 806   However, what if the method that is suppoed to do the initialization
 807   is itself inlined in the caller?  When expanding the called method
 808   we'll assume that the class initialization has already been done,
 809   because the DECL_INITIAL of the init_test_decl is set.
 810
 811   To fix this we remove the DECL_INITIAL (in the caller scope) of all
 812   the init_test_decls corresponding to classes initialized by the
 813   inlined method.  This makes the caller no longer assume that the
 814   method being inlined does any class initializations.  */
 815   DECL_INITIAL (*init_test_decl) = NULL;
 816
 817   return true;
 818 }
 819
 820 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 821    inlining.  */
 822
 823 void
 824 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 825 {
 826   htab_traverse
 827     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 828      merge_init_test_initialization, decl_map);
 829 }
 830
 831 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 832    inlining into.  If we already have a corresponding entry in that
 833    class we don't need to create another one, so we create a mapping
 834    from the variable in the inlined class to the corresponding
 835    pre-existing one.  */
 836
 837 static int
 838 inline_init_test_initialization (void **entry, void *x)
 839 {
 840   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 841   splay_tree decl_map = (splay_tree)x;
 842
 843   tree h = java_treetreehash_find
 844     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 845   if (! h)
 846     return true;
 847   splay_tree_insert (decl_map,
 848                      (splay_tree_key) ite->value,
 849                      (splay_tree_value) h);
 850   return true;
 851 }
 852
 853 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 854    of a method being inlined.  For each hone, if we already have a
 855    variable associated with the same class in the method being inlined
 856    into, create a new mapping for it.  */
 857
 858 void
 859 java_inlining_map_static_initializers (tree fn, void *decl_map)
 860 {
 861   htab_traverse
 862     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 863      inline_init_test_initialization, decl_map);
 864 }
 865
 866 /* Avoid voluminous output for deep recursion of compound exprs.  */
 867
 868 static void
 869 dump_compound_expr (dump_info_p di, tree t)
 870 {
 871   int i;
 872
 873   for (i=0; i<2; i++)
 874     {
 875       switch (TREE_CODE (TREE_OPERAND (t, i)))
 876         {
 877         case COMPOUND_EXPR:
 878           dump_compound_expr (di, TREE_OPERAND (t, i));
 879           break;
 880
 881         case EXPR_WITH_FILE_LOCATION:
 882             {
 883               tree wfl_node = EXPR_WFL_NODE (TREE_OPERAND (t, i));
 884               dump_child ("expr", wfl_node);
 885               break;
 886             }
 887
 888         default:
 889           dump_child ("expr", TREE_OPERAND (t, i));
 890         }
 891     }
 892 }
 893
 894 static bool
 895 java_dump_tree (void *dump_info, tree t)
 896 {
 897   enum tree_code code;
 898   dump_info_p di = (dump_info_p) dump_info;
 899
 900   /* Figure out what kind of node this is.  */
 901   code = TREE_CODE (t);
 902
 903   switch (code)
 904     {
 905     case FUNCTION_DECL:
 906       dump_child ("args", DECL_ARGUMENTS (t));
 907       if (DECL_EXTERNAL (t))
 908         dump_string (di, "undefined");
 909       if (TREE_PUBLIC (t))
 910         dump_string (di, "extern");
 911       else
 912         dump_string (di, "static");
 913       if (DECL_LANG_SPECIFIC (t))
 914         dump_child ("body", DECL_FUNCTION_BODY (t));
 915       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
 916         dump_child ("inline body", DECL_SAVED_TREE (t));
 917       return true;
 918
 919     case RETURN_EXPR:
 920       dump_child ("expr", TREE_OPERAND (t, 0));
 921       return true;
 922
 923     case GOTO_EXPR:
 924       dump_child ("goto", TREE_OPERAND (t, 0));
 925       return true;
 926
 927     case LABEL_EXPR:
 928       dump_child ("label", TREE_OPERAND (t, 0));
 929       return true;
 930
 931     case LABELED_BLOCK_EXPR:
 932       dump_child ("label", TREE_OPERAND (t, 0));
 933       dump_child ("block", TREE_OPERAND (t, 1));
 934       return true;
 935
 936     case EXIT_BLOCK_EXPR:
 937       dump_child ("block", TREE_OPERAND (t, 0));
 938       dump_child ("val", TREE_OPERAND (t, 1));
 939       return true;
 940
 941     case BLOCK:
 942       if (BLOCK_EXPR_BODY (t))
 943         {
 944           tree local = BLOCK_VARS (t);
 945           while (local)
 946             {
 947               tree next = TREE_CHAIN (local);
 948               dump_child ("var", local);
 949               local = next;
 950             }
 951
 952           {
 953             tree block = BLOCK_EXPR_BODY (t);
 954             dump_child ("body", block);
 955             block = TREE_CHAIN (block);
 956           }
 957         }
 958       return true;
 959
 960     case COMPOUND_EXPR:
 961       if (!dump_flag (di, TDF_SLIM, t))
 962         return false;
 963       dump_compound_expr (di, t);
 964       return true;
 965
 966     default:
 967       break;
 968     }
 969   return false;
 970 }
 971
 972 /* Java calls can't, in general, be sibcalls because we need an
 973    accurate stack trace in order to guarantee correct operation of
 974    methods such as Class.forName(String) and
 975    SecurityManager.getClassContext().  */
 976
 977 static bool
 978 java_decl_ok_for_sibcall (tree decl)
 979 {
 980   return decl != NULL && DECL_CONTEXT (decl) == output_class;
 981 }
 982
 983 /* Given a call_expr, try to figure out what its target might be.  In
 984    the case of an indirection via the atable, search for the decl.  If
 985    the decl is external, we return NULL.  If we don't, the optimizer
 986    will replace the indirection with a direct call, which undoes the
 987    purpose of the atable indirection.  */
 988 static tree
 989 java_get_callee_fndecl (tree call_expr)
 990 {
 991   tree method, table, element, atable_methods;
 992
 993   HOST_WIDE_INT index;
 994
 995   if (TREE_CODE (call_expr) != CALL_EXPR)
 996     return NULL;
 997   method = TREE_OPERAND (call_expr, 0);
 998   STRIP_NOPS (method);
 999   if (TREE_CODE (method) != ARRAY_REF)
1000     return NULL;
1001   table = TREE_OPERAND (method, 0);
1002   if (! DECL_LANG_SPECIFIC(table)
1003       || !DECL_OWNER (table)
1004       || TYPE_ATABLE_DECL (DECL_OWNER (table)) != table)
1005     return NULL;
1006
1007   atable_methods = TYPE_ATABLE_METHODS (DECL_OWNER (table));
1008   index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
1009
1010   /* FIXME: Replace this for loop with a hash table lookup.  */
1011   for (element = atable_methods; element; element = TREE_CHAIN (element))
1012     {
1013       if (index == 1)
1014         {
1015           tree purpose = TREE_PURPOSE (element);
1016           if (TREE_CODE (purpose) == FUNCTION_DECL
1017               && ! DECL_EXTERNAL (purpose))
1018             return purpose;
1019           else
1020             return NULL;
1021         }
1022       --index;
1023     }
1024
1025   return NULL;
1026 }
1027
1028
1029 /* Clear the binding stack.  */
1030 static void
1031 java_clear_binding_stack (void)
1032 {
1033   while (!global_bindings_p ())
1034     poplevel (0, 0, 0);
1035 }
1036
1037 #include "gt-java-lang.h"