gcc/java/lang.c

   1 /* Java(TM) language-specific utility routines.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.
  21
  22 Java and all Java-based marks are trademarks or registered trademarks
  23 of Sun Microsystems, Inc. in the United States and other countries.
  24 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  25
  26 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "tree.h"
  33 #include "input.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "java-tree.h"
  37 #include "jcf.h"
  38 #include "toplev.h"
  39 #include "langhooks.h"
  40 #include "langhooks-def.h"
  41 #include "flags.h"
  42 #include "xref.h"
  43 #include "ggc.h"
  44 #include "diagnostic.h"
  45 #include "tree-inline.h"
  46 #include "splay-tree.h"
  47 #include "tree-dump.h"
  48 #include "opts.h"
  49 #include "options.h"
  50
  51 static bool java_init (void);
  52 static void java_finish (void);
  53 static unsigned int java_init_options (unsigned int, const char **);
  54 static bool java_post_options (const char **);
  55
  56 static int java_handle_option (size_t scode, const char *arg, int value);
  57 static void put_decl_string (const char *, int);
  58 static void put_decl_node (tree);
  59 static void java_print_error_function (diagnostic_context *, const char *);
  60 static tree java_tree_inlining_walk_subtrees (tree *, int *, walk_tree_fn,
  61                                               void *, void *);
  62 static int java_unsafe_for_reeval (tree);
  63 static int merge_init_test_initialization (void * *, void *);
  64 static int inline_init_test_initialization (void * *, void *);
  65 static bool java_can_use_bit_fields_p (void);
  66 static bool java_dump_tree (void *, tree);
  67 static void dump_compound_expr (dump_info_p, tree);
  68 static bool java_decl_ok_for_sibcall (tree);
  69 static tree java_get_callee_fndecl (tree);
  70 static void java_clear_binding_stack (void);
  71
  72 #ifndef TARGET_OBJECT_SUFFIX
  73 # define TARGET_OBJECT_SUFFIX ".o"
  74 #endif
  75
  76 /* Table indexed by tree code giving a string containing a character
  77    classifying the tree code.  Possibilities are
  78    t, d, s, c, r, <, 1 and 2.  See java/java-tree.def for details.  */
  79
  80 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  81
  82 const char tree_code_type[] = {
  83 #include "tree.def"
  84   'x',
  85 #include "java-tree.def"
  86 };
  87 #undef DEFTREECODE
  88
  89 /* Table indexed by tree code giving number of expression
  90    operands beyond the fixed part of the node structure.
  91    Not used for types or decls.  */
  92
  93 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  94
  95 const unsigned char tree_code_length[] = {
  96 #include "tree.def"
  97   0,
  98 #include "java-tree.def"
  99 };
 100 #undef DEFTREECODE
 101
 102 /* Names of tree components.
 103    Used for printing out the tree and error messages.  */
 104 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
 105
 106 const char *const tree_code_name[] = {
 107 #include "tree.def"
 108   "@@dummy",
 109 #include "java-tree.def"
 110 };
 111 #undef DEFTREECODE
 112
 113 /* Used to avoid printing error messages with bogus function
 114    prototypes.  Starts out false.  */
 115 static bool inhibit_error_function_printing;
 116
 117 int compiling_from_source;
 118
 119 const char *resource_name;
 120
 121 int flag_emit_class_files = 0;
 122
 123 /* Nonzero if input file is a file with a list of filenames to compile. */
 124
 125 int flag_filelist_file = 0;
 126
 127 /* When nonzero, we emit xref strings. Values of the flag for xref
 128    backends are defined in xref_flag_table, xref.c.  */
 129
 130 int flag_emit_xref = 0;
 131
 132 /* When nonzero, -Wall was turned on.  */
 133 int flag_wall = 0;
 134
 135 /* When nonzero, check for redundant modifier uses.  */
 136 int flag_redundant = 0;
 137
 138 /* When nonzero, call a library routine to do integer divisions. */
 139 int flag_use_divide_subroutine = 1;
 140
 141 /* When nonzero, generate code for the Boehm GC.  */
 142 int flag_use_boehm_gc = 0;
 143
 144 /* When nonzero, assume the runtime uses a hash table to map an
 145    object to its synchronization structure.  */
 146 int flag_hash_synchronization;
 147
 148 /* When nonzero, permit the use of the assert keyword.  */
 149 int flag_assert = 1;
 150
 151 /* When nonzero, assume all native functions are implemented with
 152    JNI, not CNI.  */
 153 int flag_jni = 0;
 154
 155 /* When nonzero, warn when source file is newer than matching class
 156    file.  */
 157 int flag_newer = 1;
 158
 159 /* When nonzero, generate checks for references to NULL.  */
 160 int flag_check_references = 0;
 161
 162 /* The encoding of the source file.  */
 163 const char *current_encoding = NULL;
 164
 165 /* When nonzero, report the now deprecated empty statements.  */
 166 int flag_extraneous_semicolon;
 167
 168 /* When nonzero, report use of deprecated classes, methods, or fields.  */
 169 int flag_deprecated = 1;
 170
 171 /* When nonzero, always check for a non gcj generated classes archive.  */
 172 int flag_force_classes_archive_check;
 173
 174 /* When zero, don't optimize static class initialization. This flag shouldn't
 175    be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead.  */
 176 /* FIXME: Make this work with gimplify.  */
 177 int flag_optimize_sci = 0;
 178
 179 /* When nonzero, use offset tables for virtual method calls
 180    in order to improve binary compatibility. */
 181 int flag_indirect_dispatch = 0;
 182
 183 /* When zero, don't generate runtime array store checks. */
 184 int flag_store_check = 1;
 185
 186 /* When nonzero, print extra version information.  */
 187 static int v_flag = 0;
 188
 189 /* Set nonzero if the user specified -finline-functions on the command
 190    line.  */
 191 int flag_really_inline = 0;
 192
 193 JCF *current_jcf;
 194
 195 /* Variable controlling how dependency tracking is enabled in
 196    java_init.  */
 197 static int dependency_tracking = 0;
 198
 199 /* Flag values for DEPENDENCY_TRACKING.  */
 200 #define DEPEND_SET_FILE 1
 201 #define DEPEND_ENABLE   2
 202 #define DEPEND_TARGET_SET 4
 203 #define DEPEND_FILE_ALREADY_SET 8
 204
 205 struct language_function GTY(())
 206 {
 207   int unused;
 208 };
 209
 210 #undef LANG_HOOKS_NAME
 211 #define LANG_HOOKS_NAME "GNU Java"
 212 #undef LANG_HOOKS_INIT
 213 #define LANG_HOOKS_INIT java_init
 214 #undef LANG_HOOKS_FINISH
 215 #define LANG_HOOKS_FINISH java_finish
 216 #undef LANG_HOOKS_INIT_OPTIONS
 217 #define LANG_HOOKS_INIT_OPTIONS java_init_options
 218 #undef LANG_HOOKS_HANDLE_OPTION
 219 #define LANG_HOOKS_HANDLE_OPTION java_handle_option
 220 #undef LANG_HOOKS_POST_OPTIONS
 221 #define LANG_HOOKS_POST_OPTIONS java_post_options
 222 #undef LANG_HOOKS_PARSE_FILE
 223 #define LANG_HOOKS_PARSE_FILE java_parse_file
 224 #undef LANG_HOOKS_UNSAFE_FOR_REEVAL
 225 #define LANG_HOOKS_UNSAFE_FOR_REEVAL java_unsafe_for_reeval
 226 #undef LANG_HOOKS_MARK_ADDRESSABLE
 227 #define LANG_HOOKS_MARK_ADDRESSABLE java_mark_addressable
 228 #undef LANG_HOOKS_TRUTHVALUE_CONVERSION
 229 #define LANG_HOOKS_TRUTHVALUE_CONVERSION java_truthvalue_conversion
 230 #undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL
 231 #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL java_dup_lang_specific_decl
 232 #undef LANG_HOOKS_DECL_PRINTABLE_NAME
 233 #define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name
 234 #undef LANG_HOOKS_PRINT_ERROR_FUNCTION
 235 #define LANG_HOOKS_PRINT_ERROR_FUNCTION java_print_error_function
 236 #undef LANG_HOOKS_CAN_USE_BIT_FIELDS_P
 237 #define LANG_HOOKS_CAN_USE_BIT_FIELDS_P java_can_use_bit_fields_p
 238
 239 #undef LANG_HOOKS_TYPE_FOR_MODE
 240 #define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode
 241 #undef LANG_HOOKS_TYPE_FOR_SIZE
 242 #define LANG_HOOKS_TYPE_FOR_SIZE java_type_for_size
 243 #undef LANG_HOOKS_SIGNED_TYPE
 244 #define LANG_HOOKS_SIGNED_TYPE java_signed_type
 245 #undef LANG_HOOKS_UNSIGNED_TYPE
 246 #define LANG_HOOKS_UNSIGNED_TYPE java_unsigned_type
 247 #undef LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE
 248 #define LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE java_signed_or_unsigned_type
 249
 250 #undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN
 251 #define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN java_dump_tree
 252
 253 #undef LANG_HOOKS_GIMPLIFY_EXPR
 254 #define LANG_HOOKS_GIMPLIFY_EXPR java_gimplify_expr
 255
 256 #undef LANG_HOOKS_TREE_INLINING_WALK_SUBTREES
 257 #define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES java_tree_inlining_walk_subtrees
 258
 259 #undef LANG_HOOKS_DECL_OK_FOR_SIBCALL
 260 #define LANG_HOOKS_DECL_OK_FOR_SIBCALL java_decl_ok_for_sibcall
 261
 262 #undef LANG_HOOKS_GET_CALLEE_FNDECL
 263 #define LANG_HOOKS_GET_CALLEE_FNDECL java_get_callee_fndecl
 264
 265 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
 266 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION java_expand_body
 267
 268 #undef LANG_HOOKS_CLEAR_BINDING_STACK
 269 #define LANG_HOOKS_CLEAR_BINDING_STACK java_clear_binding_stack
 270
 271 /* Each front end provides its own.  */
 272 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 273
 274 /*
 275  * process java-specific compiler command-line options
 276  * return 0, but do not complain if the option is not recognized.
 277  */
 278 static int
 279 java_handle_option (size_t scode, const char *arg, int value)
 280 {
 281   enum opt_code code = (enum opt_code) scode;
 282
 283   switch (code)
 284     {
 285     default:
 286       abort();
 287
 288     case OPT_I:
 289       jcf_path_include_arg (arg);
 290       break;
 291
 292     case OPT_M:
 293       jcf_dependency_init (1);
 294       dependency_tracking |= DEPEND_ENABLE;
 295       break;
 296
 297     case OPT_MD_:
 298       jcf_dependency_init (1);
 299       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 300       break;
 301
 302     case OPT_MF:
 303       jcf_dependency_set_dep_file (arg);
 304       dependency_tracking |= DEPEND_FILE_ALREADY_SET;
 305       break;
 306
 307     case OPT_MM:
 308       jcf_dependency_init (0);
 309       dependency_tracking |= DEPEND_ENABLE;
 310       break;
 311
 312     case OPT_MMD_:
 313       jcf_dependency_init (0);
 314       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 315       break;
 316
 317     case OPT_MP:
 318       jcf_dependency_print_dummies ();
 319       break;
 320
 321     case OPT_MT:
 322       jcf_dependency_set_target (arg);
 323       dependency_tracking |= DEPEND_TARGET_SET;
 324       break;
 325
 326     case OPT_Wall:
 327       flag_wall = value;
 328       flag_redundant = value;
 329       flag_extraneous_semicolon = value;
 330       /* When -Wall given, enable -Wunused.  We do this because the C
 331          compiler does it, and people expect it.  */
 332       set_Wunused (value);
 333       break;
 334
 335     case OPT_Wdeprecated:
 336       flag_deprecated = value;
 337       break;
 338
 339     case OPT_Wextraneous_semicolon:
 340       flag_extraneous_semicolon = value;
 341       break;
 342
 343     case OPT_Wout_of_date:
 344       flag_newer = value;
 345       break;
 346
 347     case OPT_Wredundant_modifiers:
 348       flag_redundant = value;
 349       break;
 350
 351     case OPT_fassert:
 352       flag_assert = value;
 353       break;
 354
 355     case OPT_fenable_assertions_:
 356       add_enable_assert (arg, value);
 357       break;
 358
 359     case OPT_fenable_assertions:
 360       add_enable_assert ("", value);
 361       break;
 362
 363     case OPT_fdisable_assertions_:
 364       add_enable_assert (arg, !value);
 365       break;
 366
 367     case OPT_fdisable_assertions:
 368       add_enable_assert ("", !value);
 369       break;
 370
 371     case OPT_fassume_compiled_:
 372       add_assume_compiled (arg, !value);
 373       break;
 374
 375     case OPT_fassume_compiled:
 376       add_assume_compiled ("", !value);
 377       break;
 378
 379     case OPT_fbootclasspath_:
 380       jcf_path_bootclasspath_arg (arg);
 381       break;
 382
 383     case OPT_fcheck_references:
 384       flag_check_references = value;
 385       break;
 386
 387     case OPT_fclasspath_:
 388     case OPT_fCLASSPATH_:
 389       jcf_path_classpath_arg (arg);
 390       break;
 391
 392     case OPT_fcompile_resource_:
 393       resource_name = arg;
 394       break;
 395
 396     case OPT_fdump_:
 397       if (!dump_switch_p (arg))
 398         return 0;
 399       break;
 400
 401     case OPT_femit_class_file:
 402     case OPT_femit_class_files:
 403       flag_emit_class_files = value;
 404       break;
 405
 406     case OPT_fencoding_:
 407       current_encoding = arg;
 408       break;
 409
 410     case OPT_fextdirs_:
 411       jcf_path_extdirs_arg (arg);
 412       break;
 413
 414     case OPT_ffilelist_file:
 415       flag_filelist_file = value;
 416       break;
 417
 418     case OPT_fforce_classes_archive_check:
 419       flag_force_classes_archive_check = value;
 420       break;
 421
 422     case OPT_fhash_synchronization:
 423       flag_hash_synchronization = value;
 424       break;
 425
 426     case OPT_findirect_dispatch:
 427       flag_indirect_dispatch = value;
 428       break;
 429
 430     case OPT_finline_functions:
 431       flag_inline_functions = value;
 432       flag_really_inline = value;
 433       break;
 434
 435     case OPT_fjni:
 436       flag_jni = value;
 437       break;
 438
 439     case OPT_foptimize_static_class_initialization:
 440       flag_optimize_sci = value;
 441       break;
 442
 443     case OPT_foutput_class_dir_:
 444       jcf_write_base_directory = arg;
 445       break;
 446
 447     case OPT_fstore_check:
 448       flag_store_check = value;
 449       break;
 450
 451     case OPT_fuse_boehm_gc:
 452       flag_use_boehm_gc = value;
 453       break;
 454
 455     case OPT_fuse_divide_subroutine:
 456       flag_use_divide_subroutine = value;
 457       break;
 458
 459     case OPT_version:
 460       v_flag = 1;
 461       break;
 462     }
 463
 464   return 1;
 465 }
 466
 467 /* Global open file.  */
 468 FILE *finput;
 469
 470 static bool
 471 java_init (void)
 472 {
 473 #if 0
 474   extern int flag_minimal_debug;
 475   flag_minimal_debug = 0;
 476 #endif
 477
 478   if (flag_inline_functions)
 479     flag_inline_trees = 1;
 480
 481   /* FIXME: Indirect dispatch isn't yet compatible with static class
 482      init optimization.  */
 483   if (flag_indirect_dispatch)
 484     always_initialize_class_p = true;
 485
 486   /* Force minimum function alignment if g++ uses the least significant
 487      bit of function pointers to store the virtual bit. This is required
 488      to keep vtables compatible.  */
 489   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
 490       && force_align_functions_log < 1)
 491     force_align_functions_log = 1;
 492
 493   jcf_path_seal (v_flag);
 494
 495   java_init_decl_processing ();
 496
 497   using_eh_for_cleanups ();
 498
 499   return true;
 500 }
 501
 502 static void
 503 java_finish (void)
 504 {
 505   jcf_dependency_write ();
 506 }
 507
 508 /* Buffer used by lang_printable_name. */
 509 static char *decl_buf = NULL;
 510
 511 /* Allocated size of decl_buf. */
 512 static int decl_buflen = 0;
 513
 514 /* Length of used part of decl_buf;  position for next character. */
 515 static int decl_bufpos = 0;
 516
 517 /* Append the string STR to decl_buf.
 518    It length is given by LEN;  -1 means the string is nul-terminated. */
 519
 520 static void
 521 put_decl_string (const char *str, int len)
 522 {
 523   if (len < 0)
 524     len = strlen (str);
 525   if (decl_bufpos + len >= decl_buflen)
 526     {
 527       if (decl_buf == NULL)
 528         {
 529           decl_buflen = len + 100;
 530           decl_buf = xmalloc (decl_buflen);
 531         }
 532       else
 533         {
 534           decl_buflen *= 2;
 535           decl_buf = xrealloc (decl_buf, decl_buflen);
 536         }
 537     }
 538   strcpy (decl_buf + decl_bufpos, str);
 539   decl_bufpos += len;
 540 }
 541
 542 /* Append to decl_buf a printable name for NODE. */
 543
 544 static void
 545 put_decl_node (tree node)
 546 {
 547   int was_pointer = 0;
 548   if (TREE_CODE (node) == POINTER_TYPE)
 549     {
 550       node = TREE_TYPE (node);
 551       was_pointer = 1;
 552     }
 553   if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
 554       && DECL_NAME (node) != NULL_TREE)
 555     {
 556       if (TREE_CODE (node) == FUNCTION_DECL)
 557         {
 558           /* We want to print the type the DECL belongs to. We don't do
 559              that when we handle constructors. */
 560           if (! DECL_CONSTRUCTOR_P (node)
 561               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node))
 562             {
 563               put_decl_node (TYPE_NAME (DECL_CONTEXT (node)));
 564               put_decl_string (".", 1);
 565             }
 566           if (! DECL_CONSTRUCTOR_P (node))
 567             put_decl_node (DECL_NAME (node));
 568           if (TREE_TYPE (node) != NULL_TREE)
 569             {
 570               int i = 0;
 571               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
 572               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
 573                 args = TREE_CHAIN (args);
 574               put_decl_string ("(", 1);
 575               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
 576                 {
 577                   if (i > 0)
 578                     put_decl_string (",", 1);
 579                   put_decl_node (TREE_VALUE (args));
 580                 }
 581               put_decl_string (")", 1);
 582             }
 583         }
 584       else
 585         put_decl_node (DECL_NAME (node));
 586     }
 587   else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
 588       && TYPE_NAME (node) != NULL_TREE)
 589     {
 590       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
 591         {
 592           put_decl_node (TYPE_ARRAY_ELEMENT (node));
 593           put_decl_string("[]", 2);
 594         }
 595       else if (node == promoted_byte_type_node)
 596         put_decl_string ("byte", 4);
 597       else if (node == promoted_short_type_node)
 598         put_decl_string ("short", 5);
 599       else if (node == promoted_char_type_node)
 600         put_decl_string ("char", 4);
 601       else if (node == promoted_boolean_type_node)
 602         put_decl_string ("boolean", 7);
 603       else if (node == void_type_node && was_pointer)
 604         put_decl_string ("null", 4);
 605       else
 606         put_decl_node (TYPE_NAME (node));
 607     }
 608   else if (TREE_CODE (node) == IDENTIFIER_NODE)
 609     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
 610   else
 611     put_decl_string ("<unknown>", -1);
 612 }
 613
 614 /* Return a user-friendly name for DECL.
 615    The resulting string is only valid until the next call.
 616    The value of the hook decl_printable_name is this function,
 617    which is also called directly by java_print_error_function. */
 618
 619 const char *
 620 lang_printable_name (tree decl, int v  __attribute__ ((__unused__)))
 621 {
 622   decl_bufpos = 0;
 623   put_decl_node (decl);
 624   put_decl_string ("", 1);
 625   return decl_buf;
 626 }
 627
 628 /* Does the same thing that lang_printable_name, but add a leading
 629    space to the DECL name string -- With Leading Space.  */
 630
 631 const char *
 632 lang_printable_name_wls (tree decl, int v  __attribute__ ((__unused__)))
 633 {
 634   decl_bufpos = 1;
 635   put_decl_node (decl);
 636   put_decl_string ("", 1);
 637   decl_buf [0] = ' ';
 638   return decl_buf;
 639 }
 640
 641 /* Print on stderr the current class and method context.  This function
 642    is the value of the hook print_error_function. */
 643
 644 static GTY(()) tree last_error_function_context;
 645 static GTY(()) tree last_error_function;
 646 static void
 647 java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
 648                            const char *file)
 649 {
 650   /* Don't print error messages with bogus function prototypes.  */
 651   if (inhibit_error_function_printing)
 652     return;
 653
 654   if (current_function_decl != NULL
 655       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
 656     {
 657       if (file)
 658         fprintf (stderr, "%s: ", file);
 659
 660       last_error_function_context = DECL_CONTEXT (current_function_decl);
 661       fprintf (stderr, "In class `%s':\n",
 662                lang_printable_name (last_error_function_context, 0));
 663     }
 664   if (last_error_function != current_function_decl)
 665     {
 666       if (file)
 667         fprintf (stderr, "%s: ", file);
 668
 669       if (current_function_decl == NULL)
 670         fprintf (stderr, "At top level:\n");
 671       else
 672         {
 673           const char *name = lang_printable_name (current_function_decl, 2);
 674           fprintf (stderr, "In %s `%s':\n",
 675                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
 676                     : "method"),
 677                    name);
 678         }
 679
 680       last_error_function = current_function_decl;
 681     }
 682
 683 }
 684
 685 /* Called to install the PRINT_ERROR_FUNCTION hook differently
 686    according to LEVEL. LEVEL is 1 during early parsing, when function
 687    prototypes aren't fully resolved. java_print_error_function is set
 688    so it doesn't print incomplete function prototypes. When LEVEL is
 689    2, function prototypes are fully resolved and can be printed when
 690    reporting errors.  */
 691
 692 void
 693 lang_init_source (int level)
 694 {
 695   inhibit_error_function_printing = (level == 1);
 696 }
 697
 698 static unsigned int
 699 java_init_options (unsigned int argc ATTRIBUTE_UNUSED,
 700                    const char **argv ATTRIBUTE_UNUSED)
 701 {
 702   flag_bounds_check = 1;
 703   flag_exceptions = 1;
 704   flag_non_call_exceptions = 1;
 705
 706   /* In Java floating point operations never trap.  */
 707   flag_trapping_math = 0;
 708
 709   /* In Java arithmetic overflow always wraps around.  */
 710   flag_wrapv = 1;
 711
 712   /* Java requires left-to-right evaluation of subexpressions.  */
 713   flag_evaluation_order = 1;
 714
 715   jcf_path_init ();
 716
 717   return CL_Java;
 718 }
 719
 720 static bool
 721 java_can_use_bit_fields_p (void)
 722 {
 723   /* The bit-field optimizations cause problems when generating class
 724      files.  */
 725   return flag_emit_class_files ? false : true;
 726 }
 727
 728 /* Post-switch processing.  */
 729 static bool
 730 java_post_options (const char **pfilename)
 731 {
 732   const char *filename = *pfilename;
 733
 734   /* Use tree inlining.  */
 735   if (!flag_no_inline)
 736     flag_no_inline = 1;
 737   if (flag_inline_functions)
 738     {
 739       flag_inline_trees = 2;
 740       flag_inline_functions = 0;
 741     }
 742
 743   /* Open input file.  */
 744
 745   if (filename == 0 || !strcmp (filename, "-"))
 746     {
 747       finput = stdin;
 748       filename = "stdin";
 749
 750       if (dependency_tracking)
 751         error ("can't do dependency tracking with input from stdin");
 752     }
 753   else
 754     {
 755       if (dependency_tracking)
 756         {
 757           char *dot;
 758
 759           /* If the target is set and the output filename is set, then
 760              there's no processing to do here.  Otherwise we must
 761              compute one or the other.  */
 762           if (! ((dependency_tracking & DEPEND_TARGET_SET)
 763                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
 764             {
 765               dot = strrchr (filename, '.');
 766               if (dot == NULL)
 767                 error ("couldn't determine target name for dependency tracking");
 768               else
 769                 {
 770                   char *buf = xmalloc (dot - filename +
 771                                        3 + sizeof (TARGET_OBJECT_SUFFIX));
 772                   strncpy (buf, filename, dot - filename);
 773
 774                   /* If emitting class files, we might have multiple
 775                      targets.  The class generation code takes care of
 776                      registering them.  Otherwise we compute the
 777                      target name here.  */
 778                   if ((dependency_tracking & DEPEND_TARGET_SET))
 779                     ; /* Nothing.  */
 780                   else if (flag_emit_class_files)
 781                     jcf_dependency_set_target (NULL);
 782                   else
 783                     {
 784                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
 785                       jcf_dependency_set_target (buf);
 786                     }
 787
 788                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
 789                     ; /* Nothing.  */
 790                   else if ((dependency_tracking & DEPEND_SET_FILE))
 791                     {
 792                       strcpy (buf + (dot - filename), ".d");
 793                       jcf_dependency_set_dep_file (buf);
 794                     }
 795                   else
 796                     jcf_dependency_set_dep_file ("-");
 797
 798                   free (buf);
 799                 }
 800             }
 801         }
 802     }
 803
 804   /* Initialize the compiler back end.  */
 805   return false;
 806 }
 807
 808 /* Return either DECL or its known constant value (if it has one).  */
 809
 810 tree
 811 decl_constant_value (tree decl)
 812 {
 813   if (/* Don't change a variable array bound or initial value to a constant
 814          in a place where a variable is invalid.  */
 815       current_function_decl != 0
 816       && ! TREE_THIS_VOLATILE (decl)
 817       && TREE_READONLY (decl)
 818       && DECL_INITIAL (decl) != 0
 819       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 820       /* This is invalid if initial value is not constant.
 821          If it has either a function call, a memory reference,
 822          or a variable, then re-evaluating it could give different results.  */
 823       && TREE_CONSTANT (DECL_INITIAL (decl))
 824       /* Check for cases where this is sub-optimal, even though valid.  */
 825       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 826     return DECL_INITIAL (decl);
 827   return decl;
 828 }
 829
 830 /* Walk the language specific tree nodes during inlining.  */
 831
 832 static tree
 833 java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 834                                   int *subtrees ATTRIBUTE_UNUSED,
 835                                   walk_tree_fn func ATTRIBUTE_UNUSED,
 836                                   void *data ATTRIBUTE_UNUSED,
 837                                   void *htab ATTRIBUTE_UNUSED)
 838 {
 839   enum tree_code code;
 840   tree result;
 841
 842 #define WALK_SUBTREE(NODE)                              \
 843   do                                                    \
 844     {                                                   \
 845       result = walk_tree (&(NODE), func, data, htab);   \
 846       if (result)                                       \
 847         return result;                                  \
 848     }                                                   \
 849   while (0)
 850
 851   tree t = *tp;
 852   if (!t)
 853     return NULL_TREE;
 854
 855   code = TREE_CODE (t);
 856   switch (code)
 857     {
 858     case BLOCK:
 859       WALK_SUBTREE (BLOCK_EXPR_BODY (t));
 860       return NULL_TREE;
 861
 862     default:
 863       return NULL_TREE;
 864     }
 865
 866   #undef WALK_SUBTREE
 867 }
 868
 869 /* Called from unsafe_for_reeval.  */
 870 static int
 871 java_unsafe_for_reeval (tree t)
 872 {
 873   switch (TREE_CODE (t))
 874     {
 875     case BLOCK:
 876       /* Our expander tries to expand the variables twice.  Boom.  */
 877       if (BLOCK_EXPR_DECLS (t) != NULL)
 878         return 2;
 879       return unsafe_for_reeval (BLOCK_EXPR_BODY (t));
 880
 881     default:
 882       break;
 883     }
 884
 885   return -1;
 886 }
 887
 888 /* Every call to a static constructor has an associated boolean
 889    variable which is in the outermost scope of the calling method.
 890    This variable is used to avoid multiple calls to the static
 891    constructor for each class.
 892
 893    It looks something like this:
 894
 895    foo ()
 896    {
 897       boolean dummy = OtherClass.is_initialized;
 898
 899      ...
 900
 901      if (! dummy)
 902        OtherClass.initialize();
 903
 904      ... use OtherClass.data ...
 905    }
 906
 907    Each of these boolean variables has an entry in the
 908    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 909    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 910    being inlined and create the boolean variables in the outermost
 911    scope of the method being inlined into.  */
 912
 913 /* Create a mapping from a boolean variable in a method being inlined
 914    to one in the scope of the method being inlined into.  */
 915
 916 static int
 917 merge_init_test_initialization (void **entry, void *x)
 918 {
 919   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 920   splay_tree decl_map = (splay_tree)x;
 921   splay_tree_node n;
 922   tree *init_test_decl;
 923
 924   /* See if we have remapped this declaration.  If we haven't there's
 925      a bug in the inliner.  */
 926   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 927   if (! n)
 928     abort ();
 929
 930   /* Create a new entry for the class and its remapped boolean
 931      variable.  If we already have a mapping for this class we've
 932      already initialized it, so don't overwrite the value.  */
 933   init_test_decl = java_treetreehash_new
 934     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 935   if (!*init_test_decl)
 936     *init_test_decl = (tree)n->value;
 937
 938   /* This fixes a weird case.
 939
 940   The front end assumes that once we have called a method that
 941   initializes some class, we can assume the class is initialized.  It
 942   does this by setting the DECL_INITIAL of the init_test_decl for that
 943   class, and no initializations are emitted for that class.
 944
 945   However, what if the method that is suppoed to do the initialization
 946   is itself inlined in the caller?  When expanding the called method
 947   we'll assume that the class initialization has already been done,
 948   because the DECL_INITIAL of the init_test_decl is set.
 949
 950   To fix this we remove the DECL_INITIAL (in the caller scope) of all
 951   the init_test_decls corresponding to classes initialized by the
 952   inlined method.  This makes the caller no longer assume that the
 953   method being inlined does any class initializations.  */
 954   DECL_INITIAL (*init_test_decl) = NULL;
 955
 956   return true;
 957 }
 958
 959 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 960    inlining.  */
 961
 962 void
 963 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 964 {
 965   htab_traverse
 966     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 967      merge_init_test_initialization, decl_map);
 968 }
 969
 970 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 971    inlining into.  If we already have a corresponding entry in that
 972    class we don't need to create another one, so we create a mapping
 973    from the variable in the inlined class to the corresponding
 974    pre-existing one.  */
 975
 976 static int
 977 inline_init_test_initialization (void **entry, void *x)
 978 {
 979   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 980   splay_tree decl_map = (splay_tree)x;
 981
 982   tree h = java_treetreehash_find
 983     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 984   if (! h)
 985     return true;
 986   splay_tree_insert (decl_map,
 987                      (splay_tree_key) ite->value,
 988                      (splay_tree_value) h);
 989   return true;
 990 }
 991
 992 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 993    of a method being inlined.  For each hone, if we already have a
 994    variable associated with the same class in the method being inlined
 995    into, create a new mapping for it.  */
 996
 997 void
 998 java_inlining_map_static_initializers (tree fn, void *decl_map)
 999 {
1000   htab_traverse
1001     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
1002      inline_init_test_initialization, decl_map);
1003 }
1004
1005 /* Avoid voluminous output for deep recursion of compound exprs.  */
1006
1007 static void
1008 dump_compound_expr (dump_info_p di, tree t)
1009 {
1010   int i;
1011
1012   for (i=0; i<2; i++)
1013     {
1014       switch (TREE_CODE (TREE_OPERAND (t, i)))
1015         {
1016         case COMPOUND_EXPR:
1017           dump_compound_expr (di, TREE_OPERAND (t, i));
1018           break;
1019
1020         case EXPR_WITH_FILE_LOCATION:
1021             {
1022               tree wfl_node = EXPR_WFL_NODE (TREE_OPERAND (t, i));
1023               dump_child ("expr", wfl_node);
1024               break;
1025             }
1026
1027         default:
1028           dump_child ("expr", TREE_OPERAND (t, i));
1029         }
1030     }
1031 }
1032
1033 static bool
1034 java_dump_tree (void *dump_info, tree t)
1035 {
1036   enum tree_code code;
1037   dump_info_p di = (dump_info_p) dump_info;
1038
1039   /* Figure out what kind of node this is.  */
1040   code = TREE_CODE (t);
1041
1042   switch (code)
1043     {
1044     case FUNCTION_DECL:
1045       dump_child ("args", DECL_ARGUMENTS (t));
1046       if (DECL_EXTERNAL (t))
1047         dump_string (di, "undefined");
1048       if (TREE_PUBLIC (t))
1049         dump_string (di, "extern");
1050       else
1051         dump_string (di, "static");
1052       if (DECL_LANG_SPECIFIC (t))
1053         dump_child ("body", DECL_FUNCTION_BODY (t));
1054       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
1055         dump_child ("inline body", DECL_SAVED_TREE (t));
1056       return true;
1057
1058     case RETURN_EXPR:
1059       dump_child ("expr", TREE_OPERAND (t, 0));
1060       return true;
1061
1062     case GOTO_EXPR:
1063       dump_child ("goto", TREE_OPERAND (t, 0));
1064       return true;
1065
1066     case LABEL_EXPR:
1067       dump_child ("label", TREE_OPERAND (t, 0));
1068       return true;
1069
1070     case LABELED_BLOCK_EXPR:
1071       dump_child ("label", TREE_OPERAND (t, 0));
1072       dump_child ("block", TREE_OPERAND (t, 1));
1073       return true;
1074
1075     case EXIT_BLOCK_EXPR:
1076       dump_child ("block", TREE_OPERAND (t, 0));
1077       dump_child ("val", TREE_OPERAND (t, 1));
1078       return true;
1079
1080     case BLOCK:
1081       if (BLOCK_EXPR_BODY (t))
1082         {
1083           tree local = BLOCK_VARS (t);
1084           while (local)
1085             {
1086               tree next = TREE_CHAIN (local);
1087               dump_child ("var", local);
1088               local = next;
1089             }
1090
1091           {
1092             tree block = BLOCK_EXPR_BODY (t);
1093             dump_child ("body", block);
1094             block = TREE_CHAIN (block);
1095           }
1096         }
1097       return true;
1098
1099     case COMPOUND_EXPR:
1100       if (!dump_flag (di, TDF_SLIM, t))
1101         return false;
1102       dump_compound_expr (di, t);
1103       return true;
1104
1105     default:
1106       break;
1107     }
1108   return false;
1109 }
1110
1111 /* Java calls can't, in general, be sibcalls because we need an
1112    accurate stack trace in order to guarantee correct operation of
1113    methods such as Class.forName(String) and
1114    SecurityManager.getClassContext().  */
1115
1116 static bool
1117 java_decl_ok_for_sibcall (tree decl)
1118 {
1119   return decl != NULL && DECL_CONTEXT (decl) == output_class;
1120 }
1121
1122 /* Given a call_expr, try to figure out what its target might be.  In
1123    the case of an indirection via the atable, search for the decl.  If
1124    the decl is external, we return NULL.  If we don't, the optimizer
1125    will replace the indirection with a direct call, which undoes the
1126    purpose of the atable indirection.  */
1127 static tree
1128 java_get_callee_fndecl (tree call_expr)
1129 {
1130   tree method, table, element, atable_methods;
1131
1132   HOST_WIDE_INT index;
1133
1134   if (TREE_CODE (call_expr) != CALL_EXPR)
1135     return NULL;
1136   method = TREE_OPERAND (call_expr, 0);
1137   STRIP_NOPS (method);
1138   if (TREE_CODE (method) != ARRAY_REF)
1139     return NULL;
1140   table = TREE_OPERAND (method, 0);
1141   if (! DECL_LANG_SPECIFIC(table)
1142       || !DECL_OWNER (table)
1143       || TYPE_ATABLE_DECL (DECL_OWNER (table)) != table)
1144     return NULL;
1145
1146   atable_methods = TYPE_ATABLE_METHODS (DECL_OWNER (table));
1147   index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
1148
1149   /* FIXME: Replace this for loop with a hash table lookup.  */
1150   for (element = atable_methods; element; element = TREE_CHAIN (element))
1151     {
1152       if (index == 1)
1153         {
1154           tree purpose = TREE_PURPOSE (element);
1155           if (TREE_CODE (purpose) == FUNCTION_DECL
1156               && ! DECL_EXTERNAL (purpose))
1157             return purpose;
1158           else
1159             return NULL;
1160         }
1161       --index;
1162     }
1163
1164   return NULL;
1165 }
1166
1167
1168 /* Clear the binding stack.  */
1169 static void
1170 java_clear_binding_stack (void)
1171 {
1172   while (!global_bindings_p ())
1173     poplevel (0, 0, 0);
1174 }
1175
1176 #include "gt-java-lang.h"