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