gcc/java/lang.c

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