gcc/java/lang.c

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