gcc/java/lang.c

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