gcc/java/lang.c

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