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 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   /* FIXME: Indirect dispatch isn't yet compatible with static class
 468      init optimization.  */
 469   if (flag_indirect_dispatch)
 470     always_initialize_class_p = true;
 471
 472   /* Force minimum function alignment if g++ uses the least significant
 473      bit of function pointers to store the virtual bit. This is required
 474      to keep vtables compatible.  */
 475   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
 476       && force_align_functions_log < 1)
 477     force_align_functions_log = 1;
 478
 479   jcf_path_seal (v_flag);
 480
 481   java_init_decl_processing ();
 482
 483   using_eh_for_cleanups ();
 484
 485   return true;
 486 }
 487
 488 static void
 489 java_finish (void)
 490 {
 491   jcf_dependency_write ();
 492 }
 493
 494 /* Buffer used by lang_printable_name. */
 495 static char *decl_buf = NULL;
 496
 497 /* Allocated size of decl_buf. */
 498 static int decl_buflen = 0;
 499
 500 /* Length of used part of decl_buf;  position for next character. */
 501 static int decl_bufpos = 0;
 502
 503 /* Append the string STR to decl_buf.
 504    It length is given by LEN;  -1 means the string is nul-terminated. */
 505
 506 static void
 507 put_decl_string (const char *str, int len)
 508 {
 509   if (len < 0)
 510     len = strlen (str);
 511   if (decl_bufpos + len >= decl_buflen)
 512     {
 513       if (decl_buf == NULL)
 514         {
 515           decl_buflen = len + 100;
 516           decl_buf = xmalloc (decl_buflen);
 517         }
 518       else
 519         {
 520           decl_buflen *= 2;
 521           decl_buf = xrealloc (decl_buf, decl_buflen);
 522         }
 523     }
 524   strcpy (decl_buf + decl_bufpos, str);
 525   decl_bufpos += len;
 526 }
 527
 528 /* Append to decl_buf a printable name for NODE. */
 529
 530 static void
 531 put_decl_node (tree node)
 532 {
 533   int was_pointer = 0;
 534   if (TREE_CODE (node) == POINTER_TYPE)
 535     {
 536       node = TREE_TYPE (node);
 537       was_pointer = 1;
 538     }
 539   if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
 540       && DECL_NAME (node) != NULL_TREE)
 541     {
 542       if (TREE_CODE (node) == FUNCTION_DECL)
 543         {
 544           /* We want to print the type the DECL belongs to. We don't do
 545              that when we handle constructors. */
 546           if (! DECL_CONSTRUCTOR_P (node)
 547               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node))
 548             {
 549               put_decl_node (TYPE_NAME (DECL_CONTEXT (node)));
 550               put_decl_string (".", 1);
 551             }
 552           if (! DECL_CONSTRUCTOR_P (node))
 553             put_decl_node (DECL_NAME (node));
 554           if (TREE_TYPE (node) != NULL_TREE)
 555             {
 556               int i = 0;
 557               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
 558               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
 559                 args = TREE_CHAIN (args);
 560               put_decl_string ("(", 1);
 561               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
 562                 {
 563                   if (i > 0)
 564                     put_decl_string (",", 1);
 565                   put_decl_node (TREE_VALUE (args));
 566                 }
 567               put_decl_string (")", 1);
 568             }
 569         }
 570       else
 571         put_decl_node (DECL_NAME (node));
 572     }
 573   else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
 574       && TYPE_NAME (node) != NULL_TREE)
 575     {
 576       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
 577         {
 578           put_decl_node (TYPE_ARRAY_ELEMENT (node));
 579           put_decl_string("[]", 2);
 580         }
 581       else if (node == promoted_byte_type_node)
 582         put_decl_string ("byte", 4);
 583       else if (node == promoted_short_type_node)
 584         put_decl_string ("short", 5);
 585       else if (node == promoted_char_type_node)
 586         put_decl_string ("char", 4);
 587       else if (node == promoted_boolean_type_node)
 588         put_decl_string ("boolean", 7);
 589       else if (node == void_type_node && was_pointer)
 590         put_decl_string ("null", 4);
 591       else
 592         put_decl_node (TYPE_NAME (node));
 593     }
 594   else if (TREE_CODE (node) == IDENTIFIER_NODE)
 595     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
 596   else
 597     put_decl_string ("<unknown>", -1);
 598 }
 599
 600 /* Return a user-friendly name for DECL.
 601    The resulting string is only valid until the next call.
 602    The value of the hook decl_printable_name is this function,
 603    which is also called directly by java_print_error_function. */
 604
 605 const char *
 606 lang_printable_name (tree decl, int v  __attribute__ ((__unused__)))
 607 {
 608   decl_bufpos = 0;
 609   put_decl_node (decl);
 610   put_decl_string ("", 1);
 611   return decl_buf;
 612 }
 613
 614 /* Does the same thing that lang_printable_name, but add a leading
 615    space to the DECL name string -- With Leading Space.  */
 616
 617 const char *
 618 lang_printable_name_wls (tree decl, int v  __attribute__ ((__unused__)))
 619 {
 620   decl_bufpos = 1;
 621   put_decl_node (decl);
 622   put_decl_string ("", 1);
 623   decl_buf [0] = ' ';
 624   return decl_buf;
 625 }
 626
 627 /* Print on stderr the current class and method context.  This function
 628    is the value of the hook print_error_function. */
 629
 630 static GTY(()) tree last_error_function_context;
 631 static GTY(()) tree last_error_function;
 632 static void
 633 java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
 634                            const char *file)
 635 {
 636   /* Don't print error messages with bogus function prototypes.  */
 637   if (inhibit_error_function_printing)
 638     return;
 639
 640   if (current_function_decl != NULL
 641       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
 642     {
 643       if (file)
 644         fprintf (stderr, "%s: ", file);
 645
 646       last_error_function_context = DECL_CONTEXT (current_function_decl);
 647       fprintf (stderr, "In class `%s':\n",
 648                lang_printable_name (last_error_function_context, 0));
 649     }
 650   if (last_error_function != current_function_decl)
 651     {
 652       if (file)
 653         fprintf (stderr, "%s: ", file);
 654
 655       if (current_function_decl == NULL)
 656         fprintf (stderr, "At top level:\n");
 657       else
 658         {
 659           const char *name = lang_printable_name (current_function_decl, 2);
 660           fprintf (stderr, "In %s `%s':\n",
 661                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
 662                     : "method"),
 663                    name);
 664         }
 665
 666       last_error_function = current_function_decl;
 667     }
 668
 669 }
 670
 671 /* Called to install the PRINT_ERROR_FUNCTION hook differently
 672    according to LEVEL. LEVEL is 1 during early parsing, when function
 673    prototypes aren't fully resolved. java_print_error_function is set
 674    so it doesn't print incomplete function prototypes. When LEVEL is
 675    2, function prototypes are fully resolved and can be printed when
 676    reporting errors.  */
 677
 678 void lang_init_source (int level)
 679 {
 680   inhibit_error_function_printing = (level == 1);
 681 }
 682
 683 static unsigned int
 684 java_init_options (unsigned int argc ATTRIBUTE_UNUSED,
 685                    const char **argv ATTRIBUTE_UNUSED)
 686 {
 687   flag_bounds_check = 1;
 688   flag_exceptions = 1;
 689   flag_non_call_exceptions = 1;
 690
 691   /* In Java floating point operations never trap.  */
 692   flag_trapping_math = 0;
 693
 694   /* In Java arithmetic overflow always wraps around.  */
 695   flag_wrapv = 1;
 696
 697   /* Java requires left-to-right evaluation of subexpressions.  */
 698   flag_evaluation_order = 1;
 699
 700   jcf_path_init ();
 701
 702   return CL_Java;
 703 }
 704
 705 static bool
 706 java_can_use_bit_fields_p (void)
 707 {
 708   /* The bit-field optimizations cause problems when generating class
 709      files.  */
 710   return flag_emit_class_files ? false : true;
 711 }
 712
 713 /* Post-switch processing.  */
 714 static bool
 715 java_post_options (const char **pfilename)
 716 {
 717   const char *filename = *pfilename;
 718
 719  /* Use tree inlining if possible.  Function instrumentation is only
 720      done in the RTL level, so we disable tree inlining.  */
 721   if (! flag_instrument_function_entry_exit)
 722     {
 723       if (!flag_no_inline)
 724         flag_no_inline = 1;
 725       if (flag_inline_functions)
 726         {
 727           flag_inline_trees = 2;
 728           flag_inline_functions = 0;
 729         }
 730     }
 731
 732   /* Open input file.  */
 733
 734   if (filename == 0 || !strcmp (filename, "-"))
 735     {
 736       finput = stdin;
 737       filename = "stdin";
 738
 739       if (dependency_tracking)
 740         error ("can't do dependency tracking with input from stdin");
 741     }
 742   else
 743     {
 744       if (dependency_tracking)
 745         {
 746           char *dot;
 747
 748           /* If the target is set and the output filename is set, then
 749              there's no processing to do here.  Otherwise we must
 750              compute one or the other.  */
 751           if (! ((dependency_tracking & DEPEND_TARGET_SET)
 752                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
 753             {
 754               dot = strrchr (filename, '.');
 755               if (dot == NULL)
 756                 error ("couldn't determine target name for dependency tracking");
 757               else
 758                 {
 759                   char *buf = xmalloc (dot - filename +
 760                                        3 + sizeof (TARGET_OBJECT_SUFFIX));
 761                   strncpy (buf, filename, dot - filename);
 762
 763                   /* If emitting class files, we might have multiple
 764                      targets.  The class generation code takes care of
 765                      registering them.  Otherwise we compute the
 766                      target name here.  */
 767                   if ((dependency_tracking & DEPEND_TARGET_SET))
 768                     ; /* Nothing.  */
 769                   else if (flag_emit_class_files)
 770                     jcf_dependency_set_target (NULL);
 771                   else
 772                     {
 773                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
 774                       jcf_dependency_set_target (buf);
 775                     }
 776
 777                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
 778                     ; /* Nothing.  */
 779                   else if ((dependency_tracking & DEPEND_SET_FILE))
 780                     {
 781                       strcpy (buf + (dot - filename), ".d");
 782                       jcf_dependency_set_dep_file (buf);
 783                     }
 784                   else
 785                     jcf_dependency_set_dep_file ("-");
 786
 787                   free (buf);
 788                 }
 789             }
 790         }
 791     }
 792
 793   /* Initialize the compiler back end.  */
 794   return false;
 795 }
 796
 797 /* Return either DECL or its known constant value (if it has one).  */
 798
 799 tree
 800 decl_constant_value (tree decl)
 801 {
 802   if (/* Don't change a variable array bound or initial value to a constant
 803          in a place where a variable is invalid.  */
 804       current_function_decl != 0
 805       && ! TREE_THIS_VOLATILE (decl)
 806       && TREE_READONLY (decl)
 807       && DECL_INITIAL (decl) != 0
 808       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 809       /* This is invalid if initial value is not constant.
 810          If it has either a function call, a memory reference,
 811          or a variable, then re-evaluating it could give different results.  */
 812       && TREE_CONSTANT (DECL_INITIAL (decl))
 813       /* Check for cases where this is sub-optimal, even though valid.  */
 814       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 815     return DECL_INITIAL (decl);
 816   return decl;
 817 }
 818
 819 /* Walk the language specific tree nodes during inlining.  */
 820
 821 static tree
 822 java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 823                                   int *subtrees ATTRIBUTE_UNUSED,
 824                                   walk_tree_fn func ATTRIBUTE_UNUSED,
 825                                   void *data ATTRIBUTE_UNUSED,
 826                                   void *htab ATTRIBUTE_UNUSED)
 827 {
 828   enum tree_code code;
 829   tree result;
 830
 831 #define WALK_SUBTREE(NODE)                              \
 832   do                                                    \
 833     {                                                   \
 834       result = walk_tree (&(NODE), func, data, htab);   \
 835       if (result)                                       \
 836         return result;                                  \
 837     }                                                   \
 838   while (0)
 839
 840   tree t = *tp;
 841   if (!t)
 842     return NULL_TREE;
 843
 844   code = TREE_CODE (t);
 845   switch (code)
 846     {
 847     case BLOCK:
 848       WALK_SUBTREE (BLOCK_EXPR_BODY (t));
 849       return NULL_TREE;
 850
 851     default:
 852       return NULL_TREE;
 853     }
 854
 855   #undef WALK_SUBTREE
 856 }
 857
 858 /* Called from unsafe_for_reeval.  */
 859 static int
 860 java_unsafe_for_reeval (tree t)
 861 {
 862   switch (TREE_CODE (t))
 863     {
 864     case BLOCK:
 865       /* Our expander tries to expand the variables twice.  Boom.  */
 866       if (BLOCK_EXPR_DECLS (t) != NULL)
 867         return 2;
 868       return unsafe_for_reeval (BLOCK_EXPR_BODY (t));
 869
 870     default:
 871       break;
 872     }
 873
 874   return -1;
 875 }
 876
 877 /* Every call to a static constructor has an associated boolean
 878    variable which is in the outermost scope of the calling method.
 879    This variable is used to avoid multiple calls to the static
 880    constructor for each class.
 881
 882    It looks something like this:
 883
 884    foo ()
 885    {
 886       boolean dummy = OtherClass.is_initialized;
 887
 888      ...
 889
 890      if (! dummy)
 891        OtherClass.initialize();
 892
 893      ... use OtherClass.data ...
 894    }
 895
 896    Each of these boolean variables has an entry in the
 897    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 898    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 899    being inlined and create the boolean variables in the outermost
 900    scope of the method being inlined into.  */
 901
 902 /* Create a mapping from a boolean variable in a method being inlined
 903    to one in the scope of the method being inlined into.  */
 904
 905 static int
 906 merge_init_test_initialization (void **entry, void *x)
 907 {
 908   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 909   splay_tree decl_map = (splay_tree)x;
 910   splay_tree_node n;
 911   tree *init_test_decl;
 912
 913   /* See if we have remapped this declaration.  If we haven't there's
 914      a bug in the inliner.  */
 915   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 916   if (! n)
 917     abort ();
 918
 919   /* Create a new entry for the class and its remapped boolean
 920      variable.  If we already have a mapping for this class we've
 921      already initialized it, so don't overwrite the value.  */
 922   init_test_decl = java_treetreehash_new
 923     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 924   if (!*init_test_decl)
 925     *init_test_decl = (tree)n->value;
 926
 927   /* This fixes a weird case.
 928
 929   The front end assumes that once we have called a method that
 930   initializes some class, we can assume the class is initialized.  It
 931   does this by setting the DECL_INITIAL of the init_test_decl for that
 932   class, and no initializations are emitted for that class.
 933
 934   However, what if the method that is suppoed to do the initialization
 935   is itself inlined in the caller?  When expanding the called method
 936   we'll assume that the class initalization has already been done,
 937   because the DECL_INITIAL of the init_test_decl is set.
 938
 939   To fix this we remove the DECL_INITIAL (in the caller scope) of all
 940   the init_test_decls corresponding to classes initialized by the
 941   inlined method.  This makes the caller no longer assume that the
 942   method being inlined does any class initializations.  */
 943   DECL_INITIAL (*init_test_decl) = NULL;
 944
 945   return true;
 946 }
 947
 948 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 949    inlining.  */
 950
 951 void
 952 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 953 {
 954   htab_traverse
 955     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 956      merge_init_test_initialization, decl_map);
 957 }
 958
 959 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 960    inlining into.  If we already have a corresponding entry in that
 961    class we don't need to create another one, so we create a mapping
 962    from the variable in the inlined class to the corresponding
 963    pre-existing one.  */
 964
 965 static int
 966 inline_init_test_initialization (void **entry, void *x)
 967 {
 968   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 969   splay_tree decl_map = (splay_tree)x;
 970
 971   tree h = java_treetreehash_find
 972     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 973   if (! h)
 974     return true;
 975   splay_tree_insert (decl_map,
 976                      (splay_tree_key) ite->value,
 977                      (splay_tree_value) h);
 978   return true;
 979 }
 980
 981 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 982    of a method being inlined.  For each hone, if we already have a
 983    variable associated with the same class in the method being inlined
 984    into, create a new mapping for it.  */
 985
 986 void
 987 java_inlining_map_static_initializers (tree fn, void *decl_map)
 988 {
 989   htab_traverse
 990     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 991      inline_init_test_initialization, decl_map);
 992 }
 993
 994 /* Avoid voluminous output for deep recursion of compound exprs.  */
 995
 996 static void
 997 dump_compound_expr (dump_info_p di, tree t)
 998 {
 999   int i;
1000
1001   for (i=0; i<2; i++)
1002     {
1003       switch (TREE_CODE (TREE_OPERAND (t, i)))
1004         {
1005         case COMPOUND_EXPR:
1006           dump_compound_expr (di, TREE_OPERAND (t, i));
1007           break;
1008
1009         case EXPR_WITH_FILE_LOCATION:
1010             {
1011               tree wfl_node = EXPR_WFL_NODE (TREE_OPERAND (t, i));
1012               dump_child ("expr", wfl_node);
1013               break;
1014             }
1015
1016         default:
1017           dump_child ("expr", TREE_OPERAND (t, i));
1018         }
1019     }
1020 }
1021
1022 static bool
1023 java_dump_tree (void *dump_info, tree t)
1024 {
1025   enum tree_code code;
1026   dump_info_p di = (dump_info_p) dump_info;
1027
1028   /* Figure out what kind of node this is.  */
1029   code = TREE_CODE (t);
1030
1031   switch (code)
1032     {
1033     case FUNCTION_DECL:
1034       dump_child ("args", DECL_ARGUMENTS (t));
1035       if (DECL_EXTERNAL (t))
1036         dump_string (di, "undefined");
1037       if (TREE_PUBLIC (t))
1038         dump_string (di, "extern");
1039       else
1040         dump_string (di, "static");
1041       if (DECL_LANG_SPECIFIC (t))
1042         dump_child ("body", DECL_FUNCTION_BODY (t));
1043       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
1044         dump_child ("inline body", DECL_SAVED_TREE (t));
1045       return true;
1046
1047     case RETURN_EXPR:
1048       dump_child ("expr", TREE_OPERAND (t, 0));
1049       return true;
1050
1051     case GOTO_EXPR:
1052       dump_child ("goto", TREE_OPERAND (t, 0));
1053       return true;
1054
1055     case LABEL_EXPR:
1056       dump_child ("label", TREE_OPERAND (t, 0));
1057       return true;
1058
1059     case LABELED_BLOCK_EXPR:
1060       dump_child ("label", TREE_OPERAND (t, 0));
1061       dump_child ("block", TREE_OPERAND (t, 1));
1062       return true;
1063
1064     case EXIT_BLOCK_EXPR:
1065       dump_child ("block", TREE_OPERAND (t, 0));
1066       dump_child ("val", TREE_OPERAND (t, 1));
1067       return true;
1068
1069     case BLOCK:
1070       if (BLOCK_EXPR_BODY (t))
1071         {
1072           tree local = BLOCK_VARS (t);
1073           while (local)
1074             {
1075               tree next = TREE_CHAIN (local);
1076               dump_child ("var", local);
1077               local = next;
1078             }
1079
1080           {
1081             tree block = BLOCK_EXPR_BODY (t);
1082             dump_child ("body", block);
1083             block = TREE_CHAIN (block);
1084           }
1085         }
1086       return true;
1087
1088     case COMPOUND_EXPR:
1089       if (!dump_flag (di, TDF_SLIM, t))
1090         return false;
1091       dump_compound_expr (di, t);
1092       return true;
1093
1094     default:
1095       break;
1096     }
1097   return false;
1098 }
1099
1100 /* Java calls can't, in general, be sibcalls because we need an
1101    accurate stack trace in order to guarantee correct operation of
1102    methods such as Class.forName(String) and
1103    SecurityManager.getClassContext().  */
1104
1105 static bool
1106 java_decl_ok_for_sibcall (tree decl)
1107 {
1108   return decl != NULL && DECL_CONTEXT (decl) == output_class;
1109 }
1110
1111 /* Used by estimate_num_insns.  Estimate number of instructions seen
1112    by given statement.  */
1113 static tree
1114 java_estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
1115 {
1116   int *count = data;
1117   tree x = *tp;
1118
1119   if (TYPE_P (x) || DECL_P (x))
1120     {
1121       *walk_subtrees = 0;
1122       return NULL;
1123     }
1124   /* Assume that constants and references counts nothing.  These should
1125      be majorized by amount of operations among them we count later
1126      and are common target of CSE and similar optimizations.  */
1127   if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
1128       || TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
1129     return NULL;
1130   switch (TREE_CODE (x))
1131     {
1132     /* Recognize assignments of large structures and constructors of
1133        big arrays.  */
1134     case MODIFY_EXPR:
1135     case CONSTRUCTOR:
1136       {
1137         HOST_WIDE_INT size;
1138
1139         size = int_size_in_bytes (TREE_TYPE (x));
1140
1141         if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
1142           *count += 10;
1143         else
1144           *count += ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
1145       }
1146       break;
1147     /* Few special cases of expensive operations.  This is usefull
1148        to avoid inlining on functions having too many of these.  */
1149     case TRUNC_DIV_EXPR:
1150     case CEIL_DIV_EXPR:
1151     case FLOOR_DIV_EXPR:
1152     case ROUND_DIV_EXPR:
1153     case TRUNC_MOD_EXPR:
1154     case CEIL_MOD_EXPR:
1155     case FLOOR_MOD_EXPR:
1156     case ROUND_MOD_EXPR:
1157     case RDIV_EXPR:
1158     case CALL_EXPR:
1159
1160     case NEW_ARRAY_EXPR:
1161     case NEW_ANONYMOUS_ARRAY_EXPR:
1162     case NEW_CLASS_EXPR:
1163       *count += 10;
1164       break;
1165     /* Various containers that will produce no code themselves.  */
1166     case INIT_EXPR:
1167     case TARGET_EXPR:
1168     case BIND_EXPR:
1169     case BLOCK:
1170     case TREE_LIST:
1171     case TREE_VEC:
1172     case IDENTIFIER_NODE:
1173     case PLACEHOLDER_EXPR:
1174     case WITH_CLEANUP_EXPR:
1175     case CLEANUP_POINT_EXPR:
1176     case NOP_EXPR:
1177     case VIEW_CONVERT_EXPR:
1178     case SAVE_EXPR:
1179     case UNSAVE_EXPR:
1180     case COMPLEX_EXPR:
1181     case REALPART_EXPR:
1182     case IMAGPART_EXPR:
1183     case TRY_CATCH_EXPR:
1184     case TRY_FINALLY_EXPR:
1185     case LABEL_EXPR:
1186     case EXIT_EXPR:
1187     case LABELED_BLOCK_EXPR:
1188     case EXIT_BLOCK_EXPR:
1189     case EXPR_WITH_FILE_LOCATION:
1190     case UNARY_PLUS_EXPR:
1191     case THIS_EXPR:
1192     case DEFAULT_EXPR:
1193     case TRY_EXPR:
1194
1195       break;
1196     case CLASS_LITERAL:
1197       *walk_subtrees = 0;
1198       break;
1199     default:
1200       (*count)++;
1201     }
1202   return NULL;
1203 }
1204
1205 /*  Estimate number of instructions that will be created by expanding the body.  */
1206 static int
1207 java_estimate_num_insns (tree decl)
1208 {
1209   int num = 0;
1210   walk_tree_without_duplicates (&DECL_SAVED_TREE (decl),
1211                                 java_estimate_num_insns_1, &num);
1212   return num;
1213 }
1214
1215 /* Start inlining fn.  Called by the tree inliner via
1216    lang_hooks.tree_inlining.cannot_inline_tree_fn.  */
1217
1218 static int
1219 java_start_inlining (tree fn)
1220 {
1221   /* A java function's body doesn't have a BLOCK structure suitable
1222      for debug output until it is expanded.  Prevent inlining functions
1223      that are not yet expanded.  */
1224   return TREE_ASM_WRITTEN (fn) ? 1 : 0;
1225 }
1226
1227 /* Given a call_expr, try to figure out what its target might be.  In
1228    the case of an indirection via the atable, search for the decl.  If
1229    the decl is external, we return NULL.  If we don't, the optimizer
1230    will replace the indirection with a direct call, which undoes the
1231    purpose of the atable indirection.  */
1232 static tree
1233 java_get_callee_fndecl (tree call_expr)
1234 {
1235   tree method, table, element, atable_methods;
1236
1237   HOST_WIDE_INT index;
1238
1239   if (TREE_CODE (call_expr) != CALL_EXPR)
1240     return NULL;
1241   method = TREE_OPERAND (call_expr, 0);
1242   STRIP_NOPS (method);
1243   if (TREE_CODE (method) != ARRAY_REF)
1244     return NULL;
1245   table = TREE_OPERAND (method, 0);
1246   if (! DECL_LANG_SPECIFIC(table)
1247       || !DECL_OWNER (table)
1248       || TYPE_ATABLE_DECL (DECL_OWNER (table)) != table)
1249     return NULL;
1250
1251   atable_methods = TYPE_ATABLE_METHODS (DECL_OWNER (table));
1252   index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
1253
1254   /* FIXME: Replace this for loop with a hash table lookup.  */
1255   for (element = atable_methods; element; element = TREE_CHAIN (element))
1256     {
1257       if (index == 1)
1258         {
1259           tree purpose = TREE_PURPOSE (element);
1260           if (TREE_CODE (purpose) == FUNCTION_DECL
1261               && ! DECL_EXTERNAL (purpose))
1262             return purpose;
1263           else
1264             return NULL;
1265         }
1266       --index;
1267     }
1268
1269   return NULL;
1270 }
1271
1272 #include "gt-java-lang.h"