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 "j-options.h"
  50
  51 static bool java_init (void);
  52 static void java_finish (void);
  53 static int java_init_options (void);
  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
  70 #ifndef TARGET_OBJECT_SUFFIX
  71 # define TARGET_OBJECT_SUFFIX ".o"
  72 #endif
  73
  74 /* Table indexed by tree code giving a string containing a character
  75    classifying the tree code.  Possibilities are
  76    t, d, s, c, r, <, 1 and 2.  See java/java-tree.def for details.  */
  77
  78 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  79
  80 const char tree_code_type[] = {
  81 #include "tree.def"
  82   'x',
  83 #include "java-tree.def"
  84 };
  85 #undef DEFTREECODE
  86
  87 /* Table indexed by tree code giving number of expression
  88    operands beyond the fixed part of the node structure.
  89    Not used for types or decls.  */
  90
  91 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  92
  93 const unsigned char tree_code_length[] = {
  94 #include "tree.def"
  95   0,
  96 #include "java-tree.def"
  97 };
  98 #undef DEFTREECODE
  99
 100 /* Names of tree components.
 101    Used for printing out the tree and error messages.  */
 102 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
 103
 104 const char *const tree_code_name[] = {
 105 #include "tree.def"
 106   "@@dummy",
 107 #include "java-tree.def"
 108 };
 109 #undef DEFTREECODE
 110
 111 /* Used to avoid printing error messages with bogus function
 112    prototypes.  Starts out false.  */
 113 static bool inhibit_error_function_printing;
 114
 115 int compiling_from_source;
 116
 117 const char *resource_name;
 118
 119 int flag_emit_class_files = 0;
 120
 121 /* Nonzero if input file is a file with a list of filenames to compile. */
 122
 123 int flag_filelist_file = 0;
 124
 125 /* When nonzero, we emit xref strings. Values of the flag for xref
 126    backends are defined in xref_flag_table, xref.c.  */
 127
 128 int flag_emit_xref = 0;
 129
 130 /* When nonzero, -Wall was turned on.  */
 131 int flag_wall = 0;
 132
 133 /* When nonzero, check for redundant modifier uses.  */
 134 int flag_redundant = 0;
 135
 136 /* When nonzero, call a library routine to do integer divisions. */
 137 int flag_use_divide_subroutine = 1;
 138
 139 /* When nonzero, generate code for the Boehm GC.  */
 140 int flag_use_boehm_gc = 0;
 141
 142 /* When nonzero, assume the runtime uses a hash table to map an
 143    object to its synchronization structure.  */
 144 int flag_hash_synchronization;
 145
 146 /* When nonzero, permit the use of the assert keyword.  */
 147 int flag_assert = 1;
 148
 149 /* When nonzero, assume all native functions are implemented with
 150    JNI, not CNI.  */
 151 int flag_jni = 0;
 152
 153 /* When nonzero, warn when source file is newer than matching class
 154    file.  */
 155 int flag_newer = 1;
 156
 157 /* When nonzero, generate checks for references to NULL.  */
 158 int flag_check_references = 0;
 159
 160 /* The encoding of the source file.  */
 161 const char *current_encoding = NULL;
 162
 163 /* When nonzero, report the now deprecated empty statements.  */
 164 int flag_extraneous_semicolon;
 165
 166 /* When nonzero, report use of deprecated classes, methods, or fields.  */
 167 int flag_deprecated = 1;
 168
 169 /* When nonzero, always check for a non gcj generated classes archive.  */
 170 int flag_force_classes_archive_check;
 171
 172 /* When zero, don't optimize static class initialization. This flag shouldn't
 173    be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead.  */
 174 int flag_optimize_sci = 1;
 175
 176 /* When nonzero, use offset tables for virtual method calls
 177    in order to improve binary compatibility. */
 178 int flag_indirect_dispatch = 0;
 179
 180 /* When zero, don't generate runtime array store checks. */
 181 int flag_store_check = 1;
 182
 183 /* When nonzero, print extra version information.  */
 184 static int version_flag = 0;
 185
 186 /* Set nonzero if the user specified -finline-functions on the command
 187    line.  */
 188 int flag_really_inline = 0;
 189
 190 JCF *current_jcf;
 191
 192 /* Variable controlling how dependency tracking is enabled in
 193    java_init.  */
 194 static int dependency_tracking = 0;
 195
 196 /* Flag values for DEPENDENCY_TRACKING.  */
 197 #define DEPEND_SET_FILE 1
 198 #define DEPEND_ENABLE   2
 199 #define DEPEND_TARGET_SET 4
 200 #define DEPEND_FILE_ALREADY_SET 8
 201
 202 struct language_function GTY(())
 203 {
 204   int unused;
 205 };
 206
 207 #undef LANG_HOOKS_NAME
 208 #define LANG_HOOKS_NAME "GNU Java"
 209 #undef LANG_HOOKS_INIT
 210 #define LANG_HOOKS_INIT java_init
 211 #undef LANG_HOOKS_FINISH
 212 #define LANG_HOOKS_FINISH java_finish
 213 #undef LANG_HOOKS_INIT_OPTIONS
 214 #define LANG_HOOKS_INIT_OPTIONS java_init_options
 215 #undef LANG_HOOKS_HANDLE_OPTION
 216 #define LANG_HOOKS_HANDLE_OPTION java_handle_option
 217 #undef LANG_HOOKS_POST_OPTIONS
 218 #define LANG_HOOKS_POST_OPTIONS java_post_options
 219 #undef LANG_HOOKS_PARSE_FILE
 220 #define LANG_HOOKS_PARSE_FILE java_parse_file
 221 #undef LANG_HOOKS_UNSAFE_FOR_REEVAL
 222 #define LANG_HOOKS_UNSAFE_FOR_REEVAL java_unsafe_for_reeval
 223 #undef LANG_HOOKS_MARK_ADDRESSABLE
 224 #define LANG_HOOKS_MARK_ADDRESSABLE java_mark_addressable
 225 #undef LANG_HOOKS_EXPAND_EXPR
 226 #define LANG_HOOKS_EXPAND_EXPR java_expand_expr
 227 #undef LANG_HOOKS_TRUTHVALUE_CONVERSION
 228 #define LANG_HOOKS_TRUTHVALUE_CONVERSION java_truthvalue_conversion
 229 #undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL
 230 #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL java_dup_lang_specific_decl
 231 #undef LANG_HOOKS_DECL_PRINTABLE_NAME
 232 #define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name
 233 #undef LANG_HOOKS_PRINT_ERROR_FUNCTION
 234 #define LANG_HOOKS_PRINT_ERROR_FUNCTION java_print_error_function
 235 #undef LANG_HOOKS_CAN_USE_BIT_FIELDS_P
 236 #define LANG_HOOKS_CAN_USE_BIT_FIELDS_P java_can_use_bit_fields_p
 237
 238 #undef LANG_HOOKS_TYPE_FOR_MODE
 239 #define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode
 240 #undef LANG_HOOKS_TYPE_FOR_SIZE
 241 #define LANG_HOOKS_TYPE_FOR_SIZE java_type_for_size
 242 #undef LANG_HOOKS_SIGNED_TYPE
 243 #define LANG_HOOKS_SIGNED_TYPE java_signed_type
 244 #undef LANG_HOOKS_UNSIGNED_TYPE
 245 #define LANG_HOOKS_UNSIGNED_TYPE java_unsigned_type
 246 #undef LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE
 247 #define LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE java_signed_or_unsigned_type
 248
 249 #undef LANG_HOOKS_TREE_INLINING_WALK_SUBTREES
 250 #define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES java_tree_inlining_walk_subtrees
 251
 252 #undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN
 253 #define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN java_dump_tree
 254
 255 #undef LANG_HOOKS_DECL_OK_FOR_SIBCALL
 256 #define LANG_HOOKS_DECL_OK_FOR_SIBCALL java_decl_ok_for_sibcall
 257
 258 /* Each front end provides its own.  */
 259 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 260
 261 /*
 262  * process java-specific compiler command-line options
 263  * return 0, but do not complain if the option is not recognized.
 264  */
 265 static int
 266 java_handle_option (size_t scode, const char *arg, int value)
 267 {
 268   const struct cl_option *option = &cl_options[scode];
 269   enum opt_code code = (enum opt_code) scode;
 270
 271   /* Ignore file names.  */
 272   if (code == N_OPTS)
 273       return 1;
 274
 275   if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
 276     {
 277       /* These can take an empty argument.  */
 278       if (code == OPT_fassume_compiled_
 279           || code == OPT_fclasspath_
 280           || code == OPT_fCLASSPATH_
 281           || code == OPT_fbootclasspath_)
 282         arg = "";
 283       else
 284         {
 285           error ("missing argument to \"-%s\"", option->opt_text);
 286           return 1;
 287         }
 288     }
 289
 290   switch (code)
 291     {
 292     default:
 293       return 0;
 294
 295     case OPT_I:
 296       jcf_path_include_arg (arg);
 297       break;
 298
 299     case OPT_M:
 300       jcf_dependency_init (1);
 301       dependency_tracking |= DEPEND_ENABLE;
 302       break;
 303
 304     case OPT_MD:
 305       jcf_dependency_init (1);
 306       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 307       break;
 308
 309     case OPT_MF:
 310       jcf_dependency_set_dep_file (arg);
 311       break;
 312
 313     case OPT_MM:
 314       jcf_dependency_init (0);
 315       dependency_tracking |= DEPEND_ENABLE;
 316       break;
 317
 318     case OPT_MMD:
 319       jcf_dependency_init (0);
 320       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 321       break;
 322
 323     case OPT_MP:
 324       jcf_dependency_print_dummies ();
 325       break;
 326
 327     case OPT_MT:
 328       jcf_dependency_set_target (arg);
 329       dependency_tracking |= DEPEND_TARGET_SET;
 330       break;
 331
 332     case OPT_Wall:
 333       flag_wall = value;
 334       flag_redundant = value;
 335       flag_extraneous_semicolon = value;
 336       /* When -Wall given, enable -Wunused.  We do this because the C
 337          compiler does it, and people expect it.  */
 338       set_Wunused (value);
 339       break;
 340
 341     case OPT_Wdeprecated:
 342       flag_deprecated = value;
 343       break;
 344
 345     case OPT_Wextraneous_semicolon:
 346       flag_extraneous_semicolon = value;
 347       break;
 348
 349     case OPT_Wout_of_date:
 350       flag_newer = value;
 351       break;
 352
 353     case OPT_Wredundant_modifiers:
 354       flag_redundant = value;
 355       break;
 356
 357     case OPT_fassert:
 358       flag_assert = value;
 359       break;
 360
 361     case OPT_fassume_compiled_:
 362       add_assume_compiled (arg, !value);
 363       break;
 364
 365     case OPT_fassume_compiled:
 366       add_assume_compiled ("", !value);
 367       break;
 368
 369     case OPT_fbootclasspath_:
 370       jcf_path_bootclasspath_arg (arg);
 371       break;
 372
 373     case OPT_fcheck_references:
 374       flag_check_references = value;
 375       break;
 376
 377     case OPT_fclasspath_:
 378     case OPT_fCLASSPATH_:
 379       jcf_path_classpath_arg (arg);
 380       break;
 381
 382     case OPT_fcompile_resource_:
 383       resource_name = arg;
 384       break;
 385
 386     case OPT_fdump_:
 387       if (!dump_switch_p (option->opt_text + strlen ("f")))
 388         return 0;
 389       break;
 390
 391     case OPT_femit_class_file:
 392     case OPT_femit_class_files:
 393       flag_emit_class_files = value;
 394       break;
 395
 396     case OPT_fencoding_:
 397       current_encoding = arg;
 398       break;
 399
 400     case OPT_fextdirs_:
 401       jcf_path_extdirs_arg (arg);
 402       break;
 403
 404     case OPT_ffilelist_file:
 405       flag_filelist_file = value;
 406       break;
 407
 408     case OPT_fforce_classes_archive_check:
 409       flag_force_classes_archive_check = value;
 410       break;
 411
 412     case OPT_fhash_synchronization:
 413       flag_hash_synchronization = value;
 414       break;
 415
 416     case OPT_findirect_dispatch:
 417       flag_indirect_dispatch = value;
 418       break;
 419
 420     case OPT_finline_functions:
 421       flag_inline_functions = value;
 422       flag_really_inline = value;
 423       break;
 424
 425     case OPT_fjni:
 426       flag_jni = value;
 427       break;
 428
 429     case OPT_foptimize_static_class_initialization:
 430       flag_optimize_sci = value;
 431       break;
 432
 433     case OPT_foutput_class_dir_:
 434       jcf_write_base_directory = arg;
 435       break;
 436
 437     case OPT_fstore_check:
 438       flag_store_check = value;
 439       break;
 440
 441     case OPT_fuse_boehm_gc:
 442       flag_use_boehm_gc = value;
 443       break;
 444
 445     case OPT_fuse_divide_subroutine:
 446       flag_use_divide_subroutine = value;
 447       break;
 448
 449     case OPT_version:
 450       version_flag = 1;
 451       break;
 452     }
 453
 454   return 1;
 455 }
 456
 457 /* Global open file.  */
 458 FILE *finput;
 459
 460 static bool
 461 java_init (void)
 462 {
 463 #if 0
 464   extern int flag_minimal_debug;
 465   flag_minimal_debug = 0;
 466 #endif
 467
 468   if (flag_inline_functions)
 469     flag_inline_trees = 1;
 470
 471   /* Force minimum function alignment if g++ uses the least significant
 472      bit of function pointers to store the virtual bit. This is required
 473      to keep vtables compatible.  */
 474   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
 475       && force_align_functions_log < 1)
 476     force_align_functions_log = 1;
 477
 478   jcf_path_seal (version_flag);
 479
 480   java_init_decl_processing ();
 481
 482   using_eh_for_cleanups ();
 483
 484   return true;
 485 }
 486
 487 static void
 488 java_finish (void)
 489 {
 490   jcf_dependency_write ();
 491 }
 492
 493 /* Buffer used by lang_printable_name. */
 494 static char *decl_buf = NULL;
 495
 496 /* Allocated size of decl_buf. */
 497 static int decl_buflen = 0;
 498
 499 /* Length of used part of decl_buf;  position for next character. */
 500 static int decl_bufpos = 0;
 501
 502 /* Append the string STR to decl_buf.
 503    It length is given by LEN;  -1 means the string is nul-terminated. */
 504
 505 static void
 506 put_decl_string (const char *str, int len)
 507 {
 508   if (len < 0)
 509     len = strlen (str);
 510   if (decl_bufpos + len >= decl_buflen)
 511     {
 512       if (decl_buf == NULL)
 513         {
 514           decl_buflen = len + 100;
 515           decl_buf = xmalloc (decl_buflen);
 516         }
 517       else
 518         {
 519           decl_buflen *= 2;
 520           decl_buf = xrealloc (decl_buf, decl_buflen);
 521         }
 522     }
 523   strcpy (decl_buf + decl_bufpos, str);
 524   decl_bufpos += len;
 525 }
 526
 527 /* Append to decl_buf a printable name for NODE. */
 528
 529 static void
 530 put_decl_node (tree node)
 531 {
 532   int was_pointer = 0;
 533   if (TREE_CODE (node) == POINTER_TYPE)
 534     {
 535       node = TREE_TYPE (node);
 536       was_pointer = 1;
 537     }
 538   if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
 539       && DECL_NAME (node) != NULL_TREE)
 540     {
 541       if (TREE_CODE (node) == FUNCTION_DECL)
 542         {
 543           /* We want to print the type the DECL belongs to. We don't do
 544              that when we handle constructors. */
 545           if (! DECL_CONSTRUCTOR_P (node)
 546               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node))
 547             {
 548               put_decl_node (TYPE_NAME (DECL_CONTEXT (node)));
 549               put_decl_string (".", 1);
 550             }
 551           if (! DECL_CONSTRUCTOR_P (node))
 552             put_decl_node (DECL_NAME (node));
 553           if (TREE_TYPE (node) != NULL_TREE)
 554             {
 555               int i = 0;
 556               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
 557               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
 558                 args = TREE_CHAIN (args);
 559               put_decl_string ("(", 1);
 560               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
 561                 {
 562                   if (i > 0)
 563                     put_decl_string (",", 1);
 564                   put_decl_node (TREE_VALUE (args));
 565                 }
 566               put_decl_string (")", 1);
 567             }
 568         }
 569       else
 570         put_decl_node (DECL_NAME (node));
 571     }
 572   else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
 573       && TYPE_NAME (node) != NULL_TREE)
 574     {
 575       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
 576         {
 577           put_decl_node (TYPE_ARRAY_ELEMENT (node));
 578           put_decl_string("[]", 2);
 579         }
 580       else if (node == promoted_byte_type_node)
 581         put_decl_string ("byte", 4);
 582       else if (node == promoted_short_type_node)
 583         put_decl_string ("short", 5);
 584       else if (node == promoted_char_type_node)
 585         put_decl_string ("char", 4);
 586       else if (node == promoted_boolean_type_node)
 587         put_decl_string ("boolean", 7);
 588       else if (node == void_type_node && was_pointer)
 589         put_decl_string ("null", 4);
 590       else
 591         put_decl_node (TYPE_NAME (node));
 592     }
 593   else if (TREE_CODE (node) == IDENTIFIER_NODE)
 594     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
 595   else
 596     put_decl_string ("<unknown>", -1);
 597 }
 598
 599 /* Return a user-friendly name for DECL.
 600    The resulting string is only valid until the next call.
 601    The value of the hook decl_printable_name is this function,
 602    which is also called directly by java_print_error_function. */
 603
 604 const char *
 605 lang_printable_name (tree decl, int v  __attribute__ ((__unused__)))
 606 {
 607   decl_bufpos = 0;
 608   put_decl_node (decl);
 609   put_decl_string ("", 1);
 610   return decl_buf;
 611 }
 612
 613 /* Does the same thing that lang_printable_name, but add a leading
 614    space to the DECL name string -- With Leading Space.  */
 615
 616 const char *
 617 lang_printable_name_wls (tree decl, int v  __attribute__ ((__unused__)))
 618 {
 619   decl_bufpos = 1;
 620   put_decl_node (decl);
 621   put_decl_string ("", 1);
 622   decl_buf [0] = ' ';
 623   return decl_buf;
 624 }
 625
 626 /* Print on stderr the current class and method context.  This function
 627    is the value of the hook print_error_function. */
 628
 629 static GTY(()) tree last_error_function_context;
 630 static GTY(()) tree last_error_function;
 631 static void
 632 java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
 633                            const char *file)
 634 {
 635   /* Don't print error messages with bogus function prototypes.  */
 636   if (inhibit_error_function_printing)
 637     return;
 638
 639   if (current_function_decl != NULL
 640       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
 641     {
 642       if (file)
 643         fprintf (stderr, "%s: ", file);
 644
 645       last_error_function_context = DECL_CONTEXT (current_function_decl);
 646       fprintf (stderr, "In class `%s':\n",
 647                lang_printable_name (last_error_function_context, 0));
 648     }
 649   if (last_error_function != current_function_decl)
 650     {
 651       if (file)
 652         fprintf (stderr, "%s: ", file);
 653
 654       if (current_function_decl == NULL)
 655         fprintf (stderr, "At top level:\n");
 656       else
 657         {
 658           const char *name = lang_printable_name (current_function_decl, 2);
 659           fprintf (stderr, "In %s `%s':\n",
 660                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
 661                     : "method"),
 662                    name);
 663         }
 664
 665       last_error_function = current_function_decl;
 666     }
 667
 668 }
 669
 670 /* Called to install the PRINT_ERROR_FUNCTION hook differently
 671    according to LEVEL. LEVEL is 1 during early parsing, when function
 672    prototypes aren't fully resolved. java_print_error_function is set
 673    so it doesn't print incomplete function prototypes. When LEVEL is
 674    2, function prototypes are fully resolved and can be printed when
 675    reporting errors.  */
 676
 677 void lang_init_source (int level)
 678 {
 679   inhibit_error_function_printing = (level == 1);
 680 }
 681
 682 static int
 683 java_init_options (void)
 684 {
 685   flag_bounds_check = 1;
 686   flag_exceptions = 1;
 687   flag_non_call_exceptions = 1;
 688
 689   /* In Java floating point operations never trap.  */
 690   flag_trapping_math = 0;
 691
 692   /* In Java arithmetic overflow always wraps around.  */
 693   flag_wrapv = 1;
 694
 695   jcf_path_init ();
 696
 697   return 0;
 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       if (BLOCK_EXPR_BODY (t))
 844         {
 845           tree *prev = &BLOCK_EXPR_BODY (*tp);
 846           while (*prev)
 847             {
 848               WALK_SUBTREE (*prev);
 849               prev = &TREE_CHAIN (*prev);
 850             }
 851         }
 852       return NULL_TREE;
 853       break;
 854
 855     default:
 856       return NULL_TREE;
 857     }
 858 }
 859
 860 /* Called from unsafe_for_reeval.  */
 861 static int
 862 java_unsafe_for_reeval (tree t)
 863 {
 864   switch (TREE_CODE (t))
 865     {
 866     case BLOCK:
 867       /* Our expander tries to expand the variables twice.  Boom.  */
 868       if (BLOCK_EXPR_DECLS (t) != NULL)
 869         return 2;
 870       return unsafe_for_reeval (BLOCK_EXPR_BODY (t));
 871
 872     default:
 873       break;
 874     }
 875
 876   return -1;
 877 }
 878
 879 /* Every call to a static constructor has an associated boolean
 880    variable which is in the outermost scope of the calling method.
 881    This variable is used to avoid multiple calls to the static
 882    constructor for each class.
 883
 884    It looks something like this:
 885
 886    foo ()
 887    {
 888       boolean dummy = OtherClass.is_initialized;
 889
 890      ...
 891
 892      if (! dummy)
 893        OtherClass.initialize();
 894
 895      ... use OtherClass.data ...
 896    }
 897
 898    Each of these boolean variables has an entry in the
 899    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 900    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 901    being inlined and create the boolean variables in the outermost
 902    scope of the method being inlined into.  */
 903
 904 /* Create a mapping from a boolean variable in a method being inlined
 905    to one in the scope of the method being inlined into.  */
 906
 907 static int
 908 merge_init_test_initialization (void **entry, void *x)
 909 {
 910   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 911   splay_tree decl_map = (splay_tree)x;
 912   splay_tree_node n;
 913   tree *init_test_decl;
 914
 915   /* See if we have remapped this declaration.  If we haven't there's
 916      a bug in the inliner.  */
 917   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 918   if (! n)
 919     abort ();
 920
 921   /* Create a new entry for the class and its remapped boolean
 922      variable.  If we already have a mapping for this class we've
 923      already initialized it, so don't overwrite the value.  */
 924   init_test_decl = java_treetreehash_new
 925     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 926   if (!*init_test_decl)
 927     *init_test_decl = (tree)n->value;
 928
 929   return true;
 930 }
 931
 932 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 933    inlining.  */
 934
 935 void
 936 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 937 {
 938   htab_traverse
 939     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 940      merge_init_test_initialization, decl_map);
 941 }
 942
 943 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 944    inlining into.  If we already have a corresponding entry in that
 945    class we don't need to create another one, so we create a mapping
 946    from the variable in the inlined class to the corresponding
 947    pre-existing one.  */
 948
 949 static int
 950 inline_init_test_initialization (void **entry, void *x)
 951 {
 952   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 953   splay_tree decl_map = (splay_tree)x;
 954
 955   tree h = java_treetreehash_find
 956     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 957   if (! h)
 958     return true;
 959
 960   splay_tree_insert (decl_map,
 961                      (splay_tree_key) ite->value,
 962                      (splay_tree_value) h);
 963
 964   return true;
 965 }
 966
 967 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 968    of a method being inlined.  For each hone, if we already have a
 969    variable associated with the same class in the method being inlined
 970    into, create a new mapping for it.  */
 971
 972 void
 973 java_inlining_map_static_initializers (tree fn, void *decl_map)
 974 {
 975   htab_traverse
 976     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 977      inline_init_test_initialization, decl_map);
 978 }
 979
 980 /* Avoid voluminous output for deep recursion of compound exprs.  */
 981
 982 static void
 983 dump_compound_expr (dump_info_p di, tree t)
 984 {
 985   int i;
 986
 987   for (i=0; i<2; i++)
 988     {
 989       switch (TREE_CODE (TREE_OPERAND (t, i)))
 990         {
 991         case COMPOUND_EXPR:
 992           dump_compound_expr (di, TREE_OPERAND (t, i));
 993           break;
 994
 995         case EXPR_WITH_FILE_LOCATION:
 996             {
 997               tree wfl_node = EXPR_WFL_NODE (TREE_OPERAND (t, i));
 998               dump_child ("expr", wfl_node);
 999               break;
1000             }
1001
1002         default:
1003           dump_child ("expr", TREE_OPERAND (t, i));
1004         }
1005     }
1006 }
1007
1008 static bool
1009 java_dump_tree (void *dump_info, tree t)
1010 {
1011   enum tree_code code;
1012   dump_info_p di = (dump_info_p) dump_info;
1013
1014   /* Figure out what kind of node this is.  */
1015   code = TREE_CODE (t);
1016
1017   switch (code)
1018     {
1019     case FUNCTION_DECL:
1020       dump_child ("args", DECL_ARGUMENTS (t));
1021       if (DECL_EXTERNAL (t))
1022         dump_string (di, "undefined");
1023       if (TREE_PUBLIC (t))
1024         dump_string (di, "extern");
1025       else
1026         dump_string (di, "static");
1027       if (DECL_LANG_SPECIFIC (t))
1028         dump_child ("body", DECL_FUNCTION_BODY (t));
1029       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
1030         dump_child ("inline body", DECL_SAVED_TREE (t));
1031       return true;
1032
1033     case RETURN_EXPR:
1034       dump_child ("expr", TREE_OPERAND (t, 0));
1035       return true;
1036
1037     case GOTO_EXPR:
1038       dump_child ("goto", TREE_OPERAND (t, 0));
1039       return true;
1040
1041     case LABEL_EXPR:
1042       dump_child ("label", TREE_OPERAND (t, 0));
1043       return true;
1044
1045     case LABELED_BLOCK_EXPR:
1046       dump_child ("label", TREE_OPERAND (t, 0));
1047       dump_child ("block", TREE_OPERAND (t, 1));
1048       return true;
1049
1050     case EXIT_BLOCK_EXPR:
1051       dump_child ("block", TREE_OPERAND (t, 0));
1052       dump_child ("val", TREE_OPERAND (t, 1));
1053       return true;
1054
1055     case BLOCK:
1056       if (BLOCK_EXPR_BODY (t))
1057         {
1058           tree local = BLOCK_VARS (t);
1059           while (local)
1060             {
1061               tree next = TREE_CHAIN (local);
1062               dump_child ("var", local);
1063               local = next;
1064             }
1065
1066           {
1067             tree block = BLOCK_EXPR_BODY (t);
1068             dump_child ("body", block);
1069             block = TREE_CHAIN (block);
1070           }
1071         }
1072       return true;
1073
1074     case COMPOUND_EXPR:
1075       if (!dump_flag (di, TDF_SLIM, t))
1076         return false;
1077       dump_compound_expr (di, t);
1078       return true;
1079
1080     default:
1081       break;
1082     }
1083   return false;
1084 }
1085
1086 /* Java calls can't, in general, be sibcalls because we need an
1087    accurate stack trace in order to guarantee correct operation of
1088    methods such as Class.forName(String) and
1089    SecurityManager.getClassContext().  */
1090
1091 static bool
1092 java_decl_ok_for_sibcall (tree decl)
1093 {
1094   return decl != NULL && DECL_CONTEXT (decl) == current_class;
1095 }
1096
1097 #include "gt-java-lang.h"