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