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 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 v_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   enum opt_code code = (enum opt_code) scode;
 269
 270   /* Ignore file names.  */
 271   if (code == N_OPTS)
 272       return 1;
 273
 274   switch (code)
 275     {
 276     default:
 277       abort();
 278
 279     case OPT_I:
 280       jcf_path_include_arg (arg);
 281       break;
 282
 283     case OPT_M:
 284       jcf_dependency_init (1);
 285       dependency_tracking |= DEPEND_ENABLE;
 286       break;
 287
 288     case OPT_MD_:
 289       jcf_dependency_init (1);
 290       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 291       break;
 292
 293     case OPT_MF:
 294       jcf_dependency_set_dep_file (arg);
 295       dependency_tracking |= DEPEND_FILE_ALREADY_SET;
 296       break;
 297
 298     case OPT_MM:
 299       jcf_dependency_init (0);
 300       dependency_tracking |= DEPEND_ENABLE;
 301       break;
 302
 303     case OPT_MMD_:
 304       jcf_dependency_init (0);
 305       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 306       break;
 307
 308     case OPT_MP:
 309       jcf_dependency_print_dummies ();
 310       break;
 311
 312     case OPT_MT:
 313       jcf_dependency_set_target (arg);
 314       dependency_tracking |= DEPEND_TARGET_SET;
 315       break;
 316
 317     case OPT_Wall:
 318       flag_wall = value;
 319       flag_redundant = value;
 320       flag_extraneous_semicolon = value;
 321       /* When -Wall given, enable -Wunused.  We do this because the C
 322          compiler does it, and people expect it.  */
 323       set_Wunused (value);
 324       break;
 325
 326     case OPT_Wdeprecated:
 327       flag_deprecated = value;
 328       break;
 329
 330     case OPT_Wextraneous_semicolon:
 331       flag_extraneous_semicolon = value;
 332       break;
 333
 334     case OPT_Wout_of_date:
 335       flag_newer = value;
 336       break;
 337
 338     case OPT_Wredundant_modifiers:
 339       flag_redundant = value;
 340       break;
 341
 342     case OPT_fassert:
 343       flag_assert = value;
 344       break;
 345
 346     case OPT_fassume_compiled_:
 347       add_assume_compiled (arg, !value);
 348       break;
 349
 350     case OPT_fassume_compiled:
 351       add_assume_compiled ("", !value);
 352       break;
 353
 354     case OPT_fbootclasspath_:
 355       jcf_path_bootclasspath_arg (arg);
 356       break;
 357
 358     case OPT_fcheck_references:
 359       flag_check_references = value;
 360       break;
 361
 362     case OPT_fclasspath_:
 363     case OPT_fCLASSPATH_:
 364       jcf_path_classpath_arg (arg);
 365       break;
 366
 367     case OPT_fcompile_resource_:
 368       resource_name = arg;
 369       break;
 370
 371     case OPT_fdump_:
 372       if (!dump_switch_p (arg))
 373         return 0;
 374       break;
 375
 376     case OPT_femit_class_file:
 377     case OPT_femit_class_files:
 378       flag_emit_class_files = value;
 379       break;
 380
 381     case OPT_fencoding_:
 382       current_encoding = arg;
 383       break;
 384
 385     case OPT_fextdirs_:
 386       jcf_path_extdirs_arg (arg);
 387       break;
 388
 389     case OPT_ffilelist_file:
 390       flag_filelist_file = value;
 391       break;
 392
 393     case OPT_fforce_classes_archive_check:
 394       flag_force_classes_archive_check = value;
 395       break;
 396
 397     case OPT_fhash_synchronization:
 398       flag_hash_synchronization = value;
 399       break;
 400
 401     case OPT_findirect_dispatch:
 402       flag_indirect_dispatch = value;
 403       break;
 404
 405     case OPT_finline_functions:
 406       flag_inline_functions = value;
 407       flag_really_inline = value;
 408       break;
 409
 410     case OPT_fjni:
 411       flag_jni = value;
 412       break;
 413
 414     case OPT_foptimize_static_class_initialization:
 415       flag_optimize_sci = value;
 416       break;
 417
 418     case OPT_foutput_class_dir_:
 419       jcf_write_base_directory = arg;
 420       break;
 421
 422     case OPT_fstore_check:
 423       flag_store_check = value;
 424       break;
 425
 426     case OPT_fuse_boehm_gc:
 427       flag_use_boehm_gc = value;
 428       break;
 429
 430     case OPT_fuse_divide_subroutine:
 431       flag_use_divide_subroutine = value;
 432       break;
 433
 434     case OPT_version:
 435       v_flag = 1;
 436       break;
 437     }
 438
 439   return 1;
 440 }
 441
 442 /* Global open file.  */
 443 FILE *finput;
 444
 445 static bool
 446 java_init (void)
 447 {
 448 #if 0
 449   extern int flag_minimal_debug;
 450   flag_minimal_debug = 0;
 451 #endif
 452
 453   if (flag_inline_functions)
 454     flag_inline_trees = 1;
 455
 456   /* Force minimum function alignment if g++ uses the least significant
 457      bit of function pointers to store the virtual bit. This is required
 458      to keep vtables compatible.  */
 459   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
 460       && force_align_functions_log < 1)
 461     force_align_functions_log = 1;
 462
 463   jcf_path_seal (v_flag);
 464
 465   java_init_decl_processing ();
 466
 467   using_eh_for_cleanups ();
 468
 469   return true;
 470 }
 471
 472 static void
 473 java_finish (void)
 474 {
 475   jcf_dependency_write ();
 476 }
 477
 478 /* Buffer used by lang_printable_name. */
 479 static char *decl_buf = NULL;
 480
 481 /* Allocated size of decl_buf. */
 482 static int decl_buflen = 0;
 483
 484 /* Length of used part of decl_buf;  position for next character. */
 485 static int decl_bufpos = 0;
 486
 487 /* Append the string STR to decl_buf.
 488    It length is given by LEN;  -1 means the string is nul-terminated. */
 489
 490 static void
 491 put_decl_string (const char *str, int len)
 492 {
 493   if (len < 0)
 494     len = strlen (str);
 495   if (decl_bufpos + len >= decl_buflen)
 496     {
 497       if (decl_buf == NULL)
 498         {
 499           decl_buflen = len + 100;
 500           decl_buf = xmalloc (decl_buflen);
 501         }
 502       else
 503         {
 504           decl_buflen *= 2;
 505           decl_buf = xrealloc (decl_buf, decl_buflen);
 506         }
 507     }
 508   strcpy (decl_buf + decl_bufpos, str);
 509   decl_bufpos += len;
 510 }
 511
 512 /* Append to decl_buf a printable name for NODE. */
 513
 514 static void
 515 put_decl_node (tree node)
 516 {
 517   int was_pointer = 0;
 518   if (TREE_CODE (node) == POINTER_TYPE)
 519     {
 520       node = TREE_TYPE (node);
 521       was_pointer = 1;
 522     }
 523   if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
 524       && DECL_NAME (node) != NULL_TREE)
 525     {
 526       if (TREE_CODE (node) == FUNCTION_DECL)
 527         {
 528           /* We want to print the type the DECL belongs to. We don't do
 529              that when we handle constructors. */
 530           if (! DECL_CONSTRUCTOR_P (node)
 531               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node))
 532             {
 533               put_decl_node (TYPE_NAME (DECL_CONTEXT (node)));
 534               put_decl_string (".", 1);
 535             }
 536           if (! DECL_CONSTRUCTOR_P (node))
 537             put_decl_node (DECL_NAME (node));
 538           if (TREE_TYPE (node) != NULL_TREE)
 539             {
 540               int i = 0;
 541               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
 542               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
 543                 args = TREE_CHAIN (args);
 544               put_decl_string ("(", 1);
 545               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
 546                 {
 547                   if (i > 0)
 548                     put_decl_string (",", 1);
 549                   put_decl_node (TREE_VALUE (args));
 550                 }
 551               put_decl_string (")", 1);
 552             }
 553         }
 554       else
 555         put_decl_node (DECL_NAME (node));
 556     }
 557   else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
 558       && TYPE_NAME (node) != NULL_TREE)
 559     {
 560       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
 561         {
 562           put_decl_node (TYPE_ARRAY_ELEMENT (node));
 563           put_decl_string("[]", 2);
 564         }
 565       else if (node == promoted_byte_type_node)
 566         put_decl_string ("byte", 4);
 567       else if (node == promoted_short_type_node)
 568         put_decl_string ("short", 5);
 569       else if (node == promoted_char_type_node)
 570         put_decl_string ("char", 4);
 571       else if (node == promoted_boolean_type_node)
 572         put_decl_string ("boolean", 7);
 573       else if (node == void_type_node && was_pointer)
 574         put_decl_string ("null", 4);
 575       else
 576         put_decl_node (TYPE_NAME (node));
 577     }
 578   else if (TREE_CODE (node) == IDENTIFIER_NODE)
 579     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
 580   else
 581     put_decl_string ("<unknown>", -1);
 582 }
 583
 584 /* Return a user-friendly name for DECL.
 585    The resulting string is only valid until the next call.
 586    The value of the hook decl_printable_name is this function,
 587    which is also called directly by java_print_error_function. */
 588
 589 const char *
 590 lang_printable_name (tree decl, int v  __attribute__ ((__unused__)))
 591 {
 592   decl_bufpos = 0;
 593   put_decl_node (decl);
 594   put_decl_string ("", 1);
 595   return decl_buf;
 596 }
 597
 598 /* Does the same thing that lang_printable_name, but add a leading
 599    space to the DECL name string -- With Leading Space.  */
 600
 601 const char *
 602 lang_printable_name_wls (tree decl, int v  __attribute__ ((__unused__)))
 603 {
 604   decl_bufpos = 1;
 605   put_decl_node (decl);
 606   put_decl_string ("", 1);
 607   decl_buf [0] = ' ';
 608   return decl_buf;
 609 }
 610
 611 /* Print on stderr the current class and method context.  This function
 612    is the value of the hook print_error_function. */
 613
 614 static GTY(()) tree last_error_function_context;
 615 static GTY(()) tree last_error_function;
 616 static void
 617 java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
 618                            const char *file)
 619 {
 620   /* Don't print error messages with bogus function prototypes.  */
 621   if (inhibit_error_function_printing)
 622     return;
 623
 624   if (current_function_decl != NULL
 625       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
 626     {
 627       if (file)
 628         fprintf (stderr, "%s: ", file);
 629
 630       last_error_function_context = DECL_CONTEXT (current_function_decl);
 631       fprintf (stderr, "In class `%s':\n",
 632                lang_printable_name (last_error_function_context, 0));
 633     }
 634   if (last_error_function != current_function_decl)
 635     {
 636       if (file)
 637         fprintf (stderr, "%s: ", file);
 638
 639       if (current_function_decl == NULL)
 640         fprintf (stderr, "At top level:\n");
 641       else
 642         {
 643           const char *name = lang_printable_name (current_function_decl, 2);
 644           fprintf (stderr, "In %s `%s':\n",
 645                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
 646                     : "method"),
 647                    name);
 648         }
 649
 650       last_error_function = current_function_decl;
 651     }
 652
 653 }
 654
 655 /* Called to install the PRINT_ERROR_FUNCTION hook differently
 656    according to LEVEL. LEVEL is 1 during early parsing, when function
 657    prototypes aren't fully resolved. java_print_error_function is set
 658    so it doesn't print incomplete function prototypes. When LEVEL is
 659    2, function prototypes are fully resolved and can be printed when
 660    reporting errors.  */
 661
 662 void lang_init_source (int level)
 663 {
 664   inhibit_error_function_printing = (level == 1);
 665 }
 666
 667 static int
 668 java_init_options (void)
 669 {
 670   flag_bounds_check = 1;
 671   flag_exceptions = 1;
 672   flag_non_call_exceptions = 1;
 673
 674   /* In Java floating point operations never trap.  */
 675   flag_trapping_math = 0;
 676
 677   /* In Java arithmetic overflow always wraps around.  */
 678   flag_wrapv = 1;
 679
 680   jcf_path_init ();
 681
 682   return CL_Java;
 683 }
 684
 685 static bool
 686 java_can_use_bit_fields_p (void)
 687 {
 688   /* The bit-field optimizations cause problems when generating class
 689      files.  */
 690   return flag_emit_class_files ? false : true;
 691 }
 692
 693 /* Post-switch processing.  */
 694 static bool
 695 java_post_options (const char **pfilename)
 696 {
 697   const char *filename = *pfilename;
 698
 699  /* Use tree inlining if possible.  Function instrumentation is only
 700      done in the RTL level, so we disable tree inlining.  */
 701   if (! flag_instrument_function_entry_exit)
 702     {
 703       if (!flag_no_inline)
 704         flag_no_inline = 1;
 705       if (flag_inline_functions)
 706         {
 707           flag_inline_trees = 2;
 708           flag_inline_functions = 0;
 709         }
 710     }
 711
 712   /* Open input file.  */
 713
 714   if (filename == 0 || !strcmp (filename, "-"))
 715     {
 716       finput = stdin;
 717       filename = "stdin";
 718
 719       if (dependency_tracking)
 720         error ("can't do dependency tracking with input from stdin");
 721     }
 722   else
 723     {
 724       if (dependency_tracking)
 725         {
 726           char *dot;
 727
 728           /* If the target is set and the output filename is set, then
 729              there's no processing to do here.  Otherwise we must
 730              compute one or the other.  */
 731           if (! ((dependency_tracking & DEPEND_TARGET_SET)
 732                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
 733             {
 734               dot = strrchr (filename, '.');
 735               if (dot == NULL)
 736                 error ("couldn't determine target name for dependency tracking");
 737               else
 738                 {
 739                   char *buf = xmalloc (dot - filename +
 740                                        3 + sizeof (TARGET_OBJECT_SUFFIX));
 741                   strncpy (buf, filename, dot - filename);
 742
 743                   /* If emitting class files, we might have multiple
 744                      targets.  The class generation code takes care of
 745                      registering them.  Otherwise we compute the
 746                      target name here.  */
 747                   if ((dependency_tracking & DEPEND_TARGET_SET))
 748                     ; /* Nothing.  */
 749                   else if (flag_emit_class_files)
 750                     jcf_dependency_set_target (NULL);
 751                   else
 752                     {
 753                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
 754                       jcf_dependency_set_target (buf);
 755                     }
 756
 757                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
 758                     ; /* Nothing.  */
 759                   else if ((dependency_tracking & DEPEND_SET_FILE))
 760                     {
 761                       strcpy (buf + (dot - filename), ".d");
 762                       jcf_dependency_set_dep_file (buf);
 763                     }
 764                   else
 765                     jcf_dependency_set_dep_file ("-");
 766
 767                   free (buf);
 768                 }
 769             }
 770         }
 771     }
 772
 773   /* Initialize the compiler back end.  */
 774   return false;
 775 }
 776
 777 /* Return either DECL or its known constant value (if it has one).  */
 778
 779 tree
 780 decl_constant_value (tree decl)
 781 {
 782   if (/* Don't change a variable array bound or initial value to a constant
 783          in a place where a variable is invalid.  */
 784       current_function_decl != 0
 785       && ! TREE_THIS_VOLATILE (decl)
 786       && TREE_READONLY (decl)
 787       && DECL_INITIAL (decl) != 0
 788       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 789       /* This is invalid if initial value is not constant.
 790          If it has either a function call, a memory reference,
 791          or a variable, then re-evaluating it could give different results.  */
 792       && TREE_CONSTANT (DECL_INITIAL (decl))
 793       /* Check for cases where this is sub-optimal, even though valid.  */
 794       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 795     return DECL_INITIAL (decl);
 796   return decl;
 797 }
 798
 799 /* Walk the language specific tree nodes during inlining.  */
 800
 801 static tree
 802 java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 803                                   int *subtrees ATTRIBUTE_UNUSED,
 804                                   walk_tree_fn func ATTRIBUTE_UNUSED,
 805                                   void *data ATTRIBUTE_UNUSED,
 806                                   void *htab ATTRIBUTE_UNUSED)
 807 {
 808   enum tree_code code;
 809   tree result;
 810
 811 #define WALK_SUBTREE(NODE)                              \
 812   do                                                    \
 813     {                                                   \
 814       result = walk_tree (&(NODE), func, data, htab);   \
 815       if (result)                                       \
 816         return result;                                  \
 817     }                                                   \
 818   while (0)
 819
 820   tree t = *tp;
 821   if (!t)
 822     return NULL_TREE;
 823
 824   code = TREE_CODE (t);
 825   switch (code)
 826     {
 827     case BLOCK:
 828       if (BLOCK_EXPR_BODY (t))
 829         {
 830           tree *prev = &BLOCK_EXPR_BODY (*tp);
 831           while (*prev)
 832             {
 833               WALK_SUBTREE (*prev);
 834               prev = &TREE_CHAIN (*prev);
 835             }
 836         }
 837       return NULL_TREE;
 838       break;
 839
 840     default:
 841       return NULL_TREE;
 842     }
 843 }
 844
 845 /* Called from unsafe_for_reeval.  */
 846 static int
 847 java_unsafe_for_reeval (tree t)
 848 {
 849   switch (TREE_CODE (t))
 850     {
 851     case BLOCK:
 852       /* Our expander tries to expand the variables twice.  Boom.  */
 853       if (BLOCK_EXPR_DECLS (t) != NULL)
 854         return 2;
 855       return unsafe_for_reeval (BLOCK_EXPR_BODY (t));
 856
 857     default:
 858       break;
 859     }
 860
 861   return -1;
 862 }
 863
 864 /* Every call to a static constructor has an associated boolean
 865    variable which is in the outermost scope of the calling method.
 866    This variable is used to avoid multiple calls to the static
 867    constructor for each class.
 868
 869    It looks something like this:
 870
 871    foo ()
 872    {
 873       boolean dummy = OtherClass.is_initialized;
 874
 875      ...
 876
 877      if (! dummy)
 878        OtherClass.initialize();
 879
 880      ... use OtherClass.data ...
 881    }
 882
 883    Each of these boolean variables has an entry in the
 884    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 885    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 886    being inlined and create the boolean variables in the outermost
 887    scope of the method being inlined into.  */
 888
 889 /* Create a mapping from a boolean variable in a method being inlined
 890    to one in the scope of the method being inlined into.  */
 891
 892 static int
 893 merge_init_test_initialization (void **entry, void *x)
 894 {
 895   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 896   splay_tree decl_map = (splay_tree)x;
 897   splay_tree_node n;
 898   tree *init_test_decl;
 899
 900   /* See if we have remapped this declaration.  If we haven't there's
 901      a bug in the inliner.  */
 902   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 903   if (! n)
 904     abort ();
 905
 906   /* Create a new entry for the class and its remapped boolean
 907      variable.  If we already have a mapping for this class we've
 908      already initialized it, so don't overwrite the value.  */
 909   init_test_decl = java_treetreehash_new
 910     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 911   if (!*init_test_decl)
 912     *init_test_decl = (tree)n->value;
 913
 914   return true;
 915 }
 916
 917 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 918    inlining.  */
 919
 920 void
 921 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 922 {
 923   htab_traverse
 924     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 925      merge_init_test_initialization, decl_map);
 926 }
 927
 928 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 929    inlining into.  If we already have a corresponding entry in that
 930    class we don't need to create another one, so we create a mapping
 931    from the variable in the inlined class to the corresponding
 932    pre-existing one.  */
 933
 934 static int
 935 inline_init_test_initialization (void **entry, void *x)
 936 {
 937   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 938   splay_tree decl_map = (splay_tree)x;
 939
 940   tree h = java_treetreehash_find
 941     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 942   if (! h)
 943     return true;
 944
 945   splay_tree_insert (decl_map,
 946                      (splay_tree_key) ite->value,
 947                      (splay_tree_value) h);
 948
 949   return true;
 950 }
 951
 952 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 953    of a method being inlined.  For each hone, if we already have a
 954    variable associated with the same class in the method being inlined
 955    into, create a new mapping for it.  */
 956
 957 void
 958 java_inlining_map_static_initializers (tree fn, void *decl_map)
 959 {
 960   htab_traverse
 961     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 962      inline_init_test_initialization, decl_map);
 963 }
 964
 965 /* Avoid voluminous output for deep recursion of compound exprs.  */
 966
 967 static void
 968 dump_compound_expr (dump_info_p di, tree t)
 969 {
 970   int i;
 971
 972   for (i=0; i<2; i++)
 973     {
 974       switch (TREE_CODE (TREE_OPERAND (t, i)))
 975         {
 976         case COMPOUND_EXPR:
 977           dump_compound_expr (di, TREE_OPERAND (t, i));
 978           break;
 979
 980         case EXPR_WITH_FILE_LOCATION:
 981             {
 982               tree wfl_node = EXPR_WFL_NODE (TREE_OPERAND (t, i));
 983               dump_child ("expr", wfl_node);
 984               break;
 985             }
 986
 987         default:
 988           dump_child ("expr", TREE_OPERAND (t, i));
 989         }
 990     }
 991 }
 992
 993 static bool
 994 java_dump_tree (void *dump_info, tree t)
 995 {
 996   enum tree_code code;
 997   dump_info_p di = (dump_info_p) dump_info;
 998
 999   /* Figure out what kind of node this is.  */
1000   code = TREE_CODE (t);
1001
1002   switch (code)
1003     {
1004     case FUNCTION_DECL:
1005       dump_child ("args", DECL_ARGUMENTS (t));
1006       if (DECL_EXTERNAL (t))
1007         dump_string (di, "undefined");
1008       if (TREE_PUBLIC (t))
1009         dump_string (di, "extern");
1010       else
1011         dump_string (di, "static");
1012       if (DECL_LANG_SPECIFIC (t))
1013         dump_child ("body", DECL_FUNCTION_BODY (t));
1014       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
1015         dump_child ("inline body", DECL_SAVED_TREE (t));
1016       return true;
1017
1018     case RETURN_EXPR:
1019       dump_child ("expr", TREE_OPERAND (t, 0));
1020       return true;
1021
1022     case GOTO_EXPR:
1023       dump_child ("goto", TREE_OPERAND (t, 0));
1024       return true;
1025
1026     case LABEL_EXPR:
1027       dump_child ("label", TREE_OPERAND (t, 0));
1028       return true;
1029
1030     case LABELED_BLOCK_EXPR:
1031       dump_child ("label", TREE_OPERAND (t, 0));
1032       dump_child ("block", TREE_OPERAND (t, 1));
1033       return true;
1034
1035     case EXIT_BLOCK_EXPR:
1036       dump_child ("block", TREE_OPERAND (t, 0));
1037       dump_child ("val", TREE_OPERAND (t, 1));
1038       return true;
1039
1040     case BLOCK:
1041       if (BLOCK_EXPR_BODY (t))
1042         {
1043           tree local = BLOCK_VARS (t);
1044           while (local)
1045             {
1046               tree next = TREE_CHAIN (local);
1047               dump_child ("var", local);
1048               local = next;
1049             }
1050
1051           {
1052             tree block = BLOCK_EXPR_BODY (t);
1053             dump_child ("body", block);
1054             block = TREE_CHAIN (block);
1055           }
1056         }
1057       return true;
1058
1059     case COMPOUND_EXPR:
1060       if (!dump_flag (di, TDF_SLIM, t))
1061         return false;
1062       dump_compound_expr (di, t);
1063       return true;
1064
1065     default:
1066       break;
1067     }
1068   return false;
1069 }
1070
1071 /* Java calls can't, in general, be sibcalls because we need an
1072    accurate stack trace in order to guarantee correct operation of
1073    methods such as Class.forName(String) and
1074    SecurityManager.getClassContext().  */
1075
1076 static bool
1077 java_decl_ok_for_sibcall (tree decl)
1078 {
1079   return decl != NULL && DECL_CONTEXT (decl) == current_class;
1080 }
1081
1082 #include "gt-java-lang.h"