gcc/java/lang.c

   1 /* Java(TM) language-specific utility routines.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.
  21
  22 Java and all Java-based marks are trademarks or registered trademarks
  23 of Sun Microsystems, Inc. in the United States and other countries.
  24 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  25
  26 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "tree.h"
  33 #include "input.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "java-tree.h"
  37 #include "jcf.h"
  38 #include "toplev.h"
  39 #include "langhooks.h"
  40 #include "langhooks-def.h"
  41 #include "flags.h"
  42 #include "xref.h"
  43 #include "ggc.h"
  44 #include "diagnostic.h"
  45 #include "tree-inline.h"
  46 #include "splay-tree.h"
  47 #include "tree-dump.h"
  48 #include "opts.h"
  49 #include "options.h"
  50
  51 static bool java_init (void);
  52 static void java_finish (void);
  53 static unsigned int java_init_options (unsigned int, const char **);
  54 static bool java_post_options (const char **);
  55
  56 static int java_handle_option (size_t scode, const char *arg, int value);
  57 static void put_decl_string (const char *, int);
  58 static void put_decl_node (tree);
  59 static void java_print_error_function (diagnostic_context *, const char *);
  60 static tree java_tree_inlining_walk_subtrees (tree *, int *, walk_tree_fn,
  61                                               void *, struct pointer_set_t *);
  62 static int merge_init_test_initialization (void * *, void *);
  63 static int inline_init_test_initialization (void * *, void *);
  64 static bool java_can_use_bit_fields_p (void);
  65 static bool java_dump_tree (void *, tree);
  66 static void dump_compound_expr (dump_info_p, tree);
  67 static bool java_decl_ok_for_sibcall (tree);
  68 static tree java_get_callee_fndecl (tree);
  69 static void java_clear_binding_stack (void);
  70
  71 #ifndef TARGET_OBJECT_SUFFIX
  72 # define TARGET_OBJECT_SUFFIX ".o"
  73 #endif
  74
  75 /* Table indexed by tree code giving a string containing a character
  76    classifying the tree code.  Possibilities are
  77    t, d, s, c, r, <, 1 and 2.  See java/java-tree.def for details.  */
  78
  79 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  80
  81 const enum tree_code_class tree_code_type[] = {
  82 #include "tree.def"
  83   tcc_exceptional,
  84 #include "java-tree.def"
  85 };
  86 #undef DEFTREECODE
  87
  88 /* Table indexed by tree code giving number of expression
  89    operands beyond the fixed part of the node structure.
  90    Not used for types or decls.  */
  91
  92 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  93
  94 const unsigned char tree_code_length[] = {
  95 #include "tree.def"
  96   0,
  97 #include "java-tree.def"
  98 };
  99 #undef DEFTREECODE
 100
 101 /* Names of tree components.
 102    Used for printing out the tree and error messages.  */
 103 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
 104
 105 const char *const tree_code_name[] = {
 106 #include "tree.def"
 107   "@@dummy",
 108 #include "java-tree.def"
 109 };
 110 #undef DEFTREECODE
 111
 112 /* Used to avoid printing error messages with bogus function
 113    prototypes.  Starts out false.  */
 114 static bool inhibit_error_function_printing;
 115
 116 int compiling_from_source;
 117
 118 const char *resource_name;
 119
 120 /* When nonzero, we emit xref strings. Values of the flag for xref
 121    backends are defined in xref_flag_table, xref.c.  */
 122
 123 int flag_emit_xref = 0;
 124
 125 /* When nonzero, -Wall was turned on.  */
 126 int flag_wall = 0;
 127
 128 /* The encoding of the source file.  */
 129 const char *current_encoding = NULL;
 130
 131 /* When nonzero, report use of deprecated classes, methods, or fields.  */
 132 int flag_deprecated = 1;
 133
 134 /* When zero, don't optimize static class initialization. This flag shouldn't
 135    be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead.  */
 136 /* FIXME: Make this work with gimplify.  */
 137 /* int flag_optimize_sci = 0;  */
 138
 139 /* Don't attempt to verify invocations.  */
 140 int flag_verify_invocations = 0;
 141
 142 /* When nonzero, print extra version information.  */
 143 static int v_flag = 0;
 144
 145 JCF *current_jcf;
 146
 147 /* Variable controlling how dependency tracking is enabled in
 148    java_init.  */
 149 static int dependency_tracking = 0;
 150
 151 /* Flag values for DEPENDENCY_TRACKING.  */
 152 #define DEPEND_SET_FILE 1
 153 #define DEPEND_ENABLE   2
 154 #define DEPEND_TARGET_SET 4
 155 #define DEPEND_FILE_ALREADY_SET 8
 156
 157 struct language_function GTY(())
 158 {
 159   int unused;
 160 };
 161
 162 #undef LANG_HOOKS_NAME
 163 #define LANG_HOOKS_NAME "GNU Java"
 164 #undef LANG_HOOKS_INIT
 165 #define LANG_HOOKS_INIT java_init
 166 #undef LANG_HOOKS_FINISH
 167 #define LANG_HOOKS_FINISH java_finish
 168 #undef LANG_HOOKS_INIT_OPTIONS
 169 #define LANG_HOOKS_INIT_OPTIONS java_init_options
 170 #undef LANG_HOOKS_HANDLE_OPTION
 171 #define LANG_HOOKS_HANDLE_OPTION java_handle_option
 172 #undef LANG_HOOKS_POST_OPTIONS
 173 #define LANG_HOOKS_POST_OPTIONS java_post_options
 174 #undef LANG_HOOKS_PARSE_FILE
 175 #define LANG_HOOKS_PARSE_FILE java_parse_file
 176 #undef LANG_HOOKS_MARK_ADDRESSABLE
 177 #define LANG_HOOKS_MARK_ADDRESSABLE java_mark_addressable
 178 #undef LANG_HOOKS_TRUTHVALUE_CONVERSION
 179 #define LANG_HOOKS_TRUTHVALUE_CONVERSION java_truthvalue_conversion
 180 #undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL
 181 #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL java_dup_lang_specific_decl
 182 #undef LANG_HOOKS_DECL_PRINTABLE_NAME
 183 #define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name
 184 #undef LANG_HOOKS_PRINT_ERROR_FUNCTION
 185 #define LANG_HOOKS_PRINT_ERROR_FUNCTION java_print_error_function
 186 #undef LANG_HOOKS_CAN_USE_BIT_FIELDS_P
 187 #define LANG_HOOKS_CAN_USE_BIT_FIELDS_P java_can_use_bit_fields_p
 188
 189 #undef LANG_HOOKS_TYPE_FOR_MODE
 190 #define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode
 191 #undef LANG_HOOKS_TYPE_FOR_SIZE
 192 #define LANG_HOOKS_TYPE_FOR_SIZE java_type_for_size
 193 #undef LANG_HOOKS_SIGNED_TYPE
 194 #define LANG_HOOKS_SIGNED_TYPE java_signed_type
 195 #undef LANG_HOOKS_UNSIGNED_TYPE
 196 #define LANG_HOOKS_UNSIGNED_TYPE java_unsigned_type
 197 #undef LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE
 198 #define LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE java_signed_or_unsigned_type
 199
 200 #undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN
 201 #define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN java_dump_tree
 202
 203 #undef LANG_HOOKS_GIMPLIFY_EXPR
 204 #define LANG_HOOKS_GIMPLIFY_EXPR java_gimplify_expr
 205
 206 #undef LANG_HOOKS_TREE_INLINING_WALK_SUBTREES
 207 #define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES java_tree_inlining_walk_subtrees
 208
 209 #undef LANG_HOOKS_DECL_OK_FOR_SIBCALL
 210 #define LANG_HOOKS_DECL_OK_FOR_SIBCALL java_decl_ok_for_sibcall
 211
 212 #undef LANG_HOOKS_GET_CALLEE_FNDECL
 213 #define LANG_HOOKS_GET_CALLEE_FNDECL java_get_callee_fndecl
 214
 215 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
 216 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION java_expand_body
 217
 218 #undef LANG_HOOKS_CLEAR_BINDING_STACK
 219 #define LANG_HOOKS_CLEAR_BINDING_STACK java_clear_binding_stack
 220
 221 /* Each front end provides its own.  */
 222 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 223
 224 /*
 225  * process java-specific compiler command-line options
 226  * return 0, but do not complain if the option is not recognized.
 227  */
 228 static int
 229 java_handle_option (size_t scode, const char *arg, int value)
 230 {
 231   enum opt_code code = (enum opt_code) scode;
 232
 233   switch (code)
 234     {
 235     case OPT_I:
 236       jcf_path_include_arg (arg);
 237       break;
 238
 239     case OPT_M:
 240       jcf_dependency_init (1);
 241       dependency_tracking |= DEPEND_ENABLE;
 242       break;
 243
 244     case OPT_MD_:
 245       jcf_dependency_init (1);
 246       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 247       break;
 248
 249     case OPT_MF:
 250       jcf_dependency_set_dep_file (arg);
 251       dependency_tracking |= DEPEND_FILE_ALREADY_SET;
 252       break;
 253
 254     case OPT_MM:
 255       jcf_dependency_init (0);
 256       dependency_tracking |= DEPEND_ENABLE;
 257       break;
 258
 259     case OPT_MMD_:
 260       jcf_dependency_init (0);
 261       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 262       break;
 263
 264     case OPT_MP:
 265       jcf_dependency_print_dummies ();
 266       break;
 267
 268     case OPT_MT:
 269       jcf_dependency_set_target (arg);
 270       dependency_tracking |= DEPEND_TARGET_SET;
 271       break;
 272
 273     case OPT_Wall:
 274       flag_wall = value;
 275       flag_redundant = value;
 276       flag_extraneous_semicolon = value;
 277       /* When -Wall given, enable -Wunused.  We do this because the C
 278          compiler does it, and people expect it.  */
 279       set_Wunused (value);
 280       break;
 281
 282     case OPT_fenable_assertions_:
 283       add_enable_assert (arg, value);
 284       break;
 285
 286     case OPT_fenable_assertions:
 287       add_enable_assert ("", value);
 288       break;
 289
 290     case OPT_fdisable_assertions_:
 291       add_enable_assert (arg, !value);
 292       break;
 293
 294     case OPT_fdisable_assertions:
 295       add_enable_assert ("", !value);
 296       break;
 297
 298     case OPT_fassume_compiled_:
 299       add_assume_compiled (arg, !value);
 300       break;
 301
 302     case OPT_fassume_compiled:
 303       add_assume_compiled ("", !value);
 304       break;
 305
 306     case OPT_fbootclasspath_:
 307       jcf_path_bootclasspath_arg (arg);
 308       break;
 309
 310     case OPT_fclasspath_:
 311     case OPT_fCLASSPATH_:
 312       jcf_path_classpath_arg (arg);
 313       break;
 314
 315     case OPT_fcompile_resource_:
 316       resource_name = arg;
 317       break;
 318
 319     case OPT_fdump_:
 320       if (!dump_switch_p (arg))
 321         return 0;
 322       break;
 323
 324     case OPT_fencoding_:
 325       current_encoding = arg;
 326       break;
 327
 328     case OPT_fextdirs_:
 329       jcf_path_extdirs_arg (arg);
 330       break;
 331
 332     case OPT_foutput_class_dir_:
 333       jcf_write_base_directory = arg;
 334       break;
 335
 336     case OPT_version:
 337       v_flag = 1;
 338       break;
 339
 340     default:
 341       if (cl_options[code].flags & CL_Java)
 342         break;
 343       abort();
 344     }
 345
 346   return 1;
 347 }
 348
 349 /* Global open file.  */
 350 FILE *finput;
 351
 352 static bool
 353 java_init (void)
 354 {
 355 #if 0
 356   extern int flag_minimal_debug;
 357   flag_minimal_debug = 0;
 358 #endif
 359
 360   /* FIXME: Indirect dispatch isn't yet compatible with static class
 361      init optimization.  */
 362   if (flag_indirect_dispatch)
 363     always_initialize_class_p = true;
 364
 365   /* Force minimum function alignment if g++ uses the least significant
 366      bit of function pointers to store the virtual bit. This is required
 367      to keep vtables compatible.  */
 368   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
 369       && force_align_functions_log < 1)
 370     force_align_functions_log = 1;
 371
 372   jcf_path_seal (v_flag);
 373
 374   java_init_decl_processing ();
 375
 376   using_eh_for_cleanups ();
 377
 378   return true;
 379 }
 380
 381 static void
 382 java_finish (void)
 383 {
 384   jcf_dependency_write ();
 385 }
 386
 387 /* Buffer used by lang_printable_name. */
 388 static char *decl_buf = NULL;
 389
 390 /* Allocated size of decl_buf. */
 391 static int decl_buflen = 0;
 392
 393 /* Length of used part of decl_buf;  position for next character. */
 394 static int decl_bufpos = 0;
 395
 396 /* Append the string STR to decl_buf.
 397    It length is given by LEN;  -1 means the string is nul-terminated. */
 398
 399 static void
 400 put_decl_string (const char *str, int len)
 401 {
 402   if (len < 0)
 403     len = strlen (str);
 404   if (decl_bufpos + len >= decl_buflen)
 405     {
 406       if (decl_buf == NULL)
 407         {
 408           decl_buflen = len + 100;
 409           decl_buf = xmalloc (decl_buflen);
 410         }
 411       else
 412         {
 413           decl_buflen *= 2;
 414           decl_buf = xrealloc (decl_buf, decl_buflen);
 415         }
 416     }
 417   strcpy (decl_buf + decl_bufpos, str);
 418   decl_bufpos += len;
 419 }
 420
 421 /* Append to decl_buf a printable name for NODE. */
 422
 423 static void
 424 put_decl_node (tree node)
 425 {
 426   int was_pointer = 0;
 427   if (TREE_CODE (node) == POINTER_TYPE)
 428     {
 429       node = TREE_TYPE (node);
 430       was_pointer = 1;
 431     }
 432   if (DECL_P (node) && DECL_NAME (node) != NULL_TREE)
 433     {
 434       if (TREE_CODE (node) == FUNCTION_DECL)
 435         {
 436           /* We want to print the type the DECL belongs to. We don't do
 437              that when we handle constructors. */
 438           if (! DECL_CONSTRUCTOR_P (node)
 439               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node))
 440             {
 441               put_decl_node (TYPE_NAME (DECL_CONTEXT (node)));
 442               put_decl_string (".", 1);
 443             }
 444           if (! DECL_CONSTRUCTOR_P (node))
 445             put_decl_node (DECL_NAME (node));
 446           if (TREE_TYPE (node) != NULL_TREE)
 447             {
 448               int i = 0;
 449               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
 450               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
 451                 args = TREE_CHAIN (args);
 452               put_decl_string ("(", 1);
 453               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
 454                 {
 455                   if (i > 0)
 456                     put_decl_string (",", 1);
 457                   put_decl_node (TREE_VALUE (args));
 458                 }
 459               put_decl_string (")", 1);
 460             }
 461         }
 462       else
 463         put_decl_node (DECL_NAME (node));
 464     }
 465   else if (TYPE_P (node) && TYPE_NAME (node) != NULL_TREE)
 466     {
 467       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
 468         {
 469           put_decl_node (TYPE_ARRAY_ELEMENT (node));
 470           put_decl_string("[]", 2);
 471         }
 472       else if (node == promoted_byte_type_node)
 473         put_decl_string ("byte", 4);
 474       else if (node == promoted_short_type_node)
 475         put_decl_string ("short", 5);
 476       else if (node == promoted_char_type_node)
 477         put_decl_string ("char", 4);
 478       else if (node == promoted_boolean_type_node)
 479         put_decl_string ("boolean", 7);
 480       else if (node == void_type_node && was_pointer)
 481         put_decl_string ("null", 4);
 482       else
 483         put_decl_node (TYPE_NAME (node));
 484     }
 485   else if (TREE_CODE (node) == IDENTIFIER_NODE)
 486     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
 487   else
 488     put_decl_string ("<unknown>", -1);
 489 }
 490
 491 /* Return a user-friendly name for DECL.
 492    The resulting string is only valid until the next call.
 493    The value of the hook decl_printable_name is this function,
 494    which is also called directly by java_print_error_function. */
 495
 496 const char *
 497 lang_printable_name (tree decl, int v)
 498 {
 499   decl_bufpos = 0;
 500   if (v == 0 && TREE_CODE (decl) == FUNCTION_DECL)
 501     put_decl_node (DECL_NAME (decl));
 502   else
 503     put_decl_node (decl);
 504   put_decl_string ("", 1);
 505   return decl_buf;
 506 }
 507
 508 /* Print on stderr the current class and method context.  This function
 509    is the value of the hook print_error_function. */
 510
 511 static GTY(()) tree last_error_function_context;
 512 static GTY(()) tree last_error_function;
 513 static void
 514 java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
 515                            const char *file)
 516 {
 517   /* Don't print error messages with bogus function prototypes.  */
 518   if (inhibit_error_function_printing)
 519     return;
 520
 521   if (current_function_decl != NULL
 522       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
 523     {
 524       if (file)
 525         fprintf (stderr, "%s: ", file);
 526
 527       last_error_function_context = DECL_CONTEXT (current_function_decl);
 528       fprintf (stderr, "In class '%s':\n",
 529                lang_printable_name (last_error_function_context, 0));
 530     }
 531   if (last_error_function != current_function_decl)
 532     {
 533       if (file)
 534         fprintf (stderr, "%s: ", file);
 535
 536       if (current_function_decl == NULL)
 537         fprintf (stderr, "At top level:\n");
 538       else
 539         {
 540           const char *name = lang_printable_name (current_function_decl, 2);
 541           fprintf (stderr, "In %s '%s':\n",
 542                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
 543                     : "method"),
 544                    name);
 545         }
 546
 547       last_error_function = current_function_decl;
 548     }
 549
 550 }
 551
 552 /* Called to install the PRINT_ERROR_FUNCTION hook differently
 553    according to LEVEL. LEVEL is 1 during early parsing, when function
 554    prototypes aren't fully resolved. java_print_error_function is set
 555    so it doesn't print incomplete function prototypes. When LEVEL is
 556    2, function prototypes are fully resolved and can be printed when
 557    reporting errors.  */
 558
 559 void
 560 lang_init_source (int level)
 561 {
 562   inhibit_error_function_printing = (level == 1);
 563 }
 564
 565 static unsigned int
 566 java_init_options (unsigned int argc ATTRIBUTE_UNUSED,
 567                    const char **argv ATTRIBUTE_UNUSED)
 568 {
 569   flag_bounds_check = 1;
 570   flag_exceptions = 1;
 571   flag_non_call_exceptions = 1;
 572
 573   /* In Java floating point operations never trap.  */
 574   flag_trapping_math = 0;
 575
 576   /* In Java arithmetic overflow always wraps around.  */
 577   flag_wrapv = 1;
 578
 579   /* Java requires left-to-right evaluation of subexpressions.  */
 580   flag_evaluation_order = 1;
 581
 582   jcf_path_init ();
 583
 584   return CL_Java;
 585 }
 586
 587 static bool
 588 java_can_use_bit_fields_p (void)
 589 {
 590   /* The bit-field optimizations cause problems when generating class
 591      files.  */
 592   return flag_emit_class_files ? false : true;
 593 }
 594
 595 /* Post-switch processing.  */
 596 static bool
 597 java_post_options (const char **pfilename)
 598 {
 599   const char *filename = *pfilename;
 600
 601   /* Use tree inlining.  */
 602   if (!flag_no_inline)
 603     flag_no_inline = 1;
 604   if (flag_inline_functions)
 605     flag_inline_trees = 2;
 606
 607   /* An absolute requirement: if we're not using indirect dispatch, we
 608      must always verify everything.  */
 609   if (! flag_indirect_dispatch)
 610     flag_verify_invocations = true;
 611
 612   /* Open input file.  */
 613
 614   if (filename == 0 || !strcmp (filename, "-"))
 615     {
 616       finput = stdin;
 617       filename = "stdin";
 618
 619       if (dependency_tracking)
 620         error ("can't do dependency tracking with input from stdin");
 621     }
 622   else
 623     {
 624       if (dependency_tracking)
 625         {
 626           char *dot;
 627
 628           /* If the target is set and the output filename is set, then
 629              there's no processing to do here.  Otherwise we must
 630              compute one or the other.  */
 631           if (! ((dependency_tracking & DEPEND_TARGET_SET)
 632                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
 633             {
 634               dot = strrchr (filename, '.');
 635               if (dot == NULL)
 636                 error ("couldn't determine target name for dependency tracking");
 637               else
 638                 {
 639                   char *buf = xmalloc (dot - filename +
 640                                        3 + sizeof (TARGET_OBJECT_SUFFIX));
 641                   strncpy (buf, filename, dot - filename);
 642
 643                   /* If emitting class files, we might have multiple
 644                      targets.  The class generation code takes care of
 645                      registering them.  Otherwise we compute the
 646                      target name here.  */
 647                   if ((dependency_tracking & DEPEND_TARGET_SET))
 648                     ; /* Nothing.  */
 649                   else if (flag_emit_class_files)
 650                     jcf_dependency_set_target (NULL);
 651                   else
 652                     {
 653                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
 654                       jcf_dependency_set_target (buf);
 655                     }
 656
 657                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
 658                     ; /* Nothing.  */
 659                   else if ((dependency_tracking & DEPEND_SET_FILE))
 660                     {
 661                       strcpy (buf + (dot - filename), ".d");
 662                       jcf_dependency_set_dep_file (buf);
 663                     }
 664                   else
 665                     jcf_dependency_set_dep_file ("-");
 666
 667                   free (buf);
 668                 }
 669             }
 670         }
 671     }
 672 #ifdef USE_MAPPED_LOCATION
 673   linemap_add (&line_table, LC_ENTER, false, filename, 0);
 674   linemap_add (&line_table, LC_RENAME, false, "<built-in>", 0);
 675 #endif
 676
 677   /* Initialize the compiler back end.  */
 678   return false;
 679 }
 680
 681 /* Return either DECL or its known constant value (if it has one).  */
 682
 683 tree
 684 decl_constant_value (tree decl)
 685 {
 686   if (/* Don't change a variable array bound or initial value to a constant
 687          in a place where a variable is invalid.  */
 688       current_function_decl != 0
 689       && ! TREE_THIS_VOLATILE (decl)
 690       && TREE_READONLY (decl)
 691       && DECL_INITIAL (decl) != 0
 692       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 693       /* This is invalid if initial value is not constant.
 694          If it has either a function call, a memory reference,
 695          or a variable, then re-evaluating it could give different results.  */
 696       && TREE_CONSTANT (DECL_INITIAL (decl))
 697       /* Check for cases where this is sub-optimal, even though valid.  */
 698       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 699     return DECL_INITIAL (decl);
 700   return decl;
 701 }
 702
 703 /* Walk the language specific tree nodes during inlining.  */
 704
 705 static tree
 706 java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 707                                   int *subtrees ATTRIBUTE_UNUSED,
 708                                   walk_tree_fn func ATTRIBUTE_UNUSED,
 709                                   void *data ATTRIBUTE_UNUSED,
 710                                   struct pointer_set_t *pset ATTRIBUTE_UNUSED)
 711 {
 712   enum tree_code code;
 713   tree result;
 714
 715 #define WALK_SUBTREE(NODE)                              \
 716   do                                                    \
 717     {                                                   \
 718       result = walk_tree (&(NODE), func, data, pset);   \
 719       if (result)                                       \
 720         return result;                                  \
 721     }                                                   \
 722   while (0)
 723
 724   tree t = *tp;
 725   if (!t)
 726     return NULL_TREE;
 727
 728   code = TREE_CODE (t);
 729   switch (code)
 730     {
 731     case BLOCK:
 732       WALK_SUBTREE (BLOCK_EXPR_BODY (t));
 733       return NULL_TREE;
 734
 735     case EXIT_BLOCK_EXPR:
 736       *subtrees = 0;
 737       return NULL_TREE;
 738
 739     default:
 740       return NULL_TREE;
 741     }
 742
 743   #undef WALK_SUBTREE
 744 }
 745
 746 /* Every call to a static constructor has an associated boolean
 747    variable which is in the outermost scope of the calling method.
 748    This variable is used to avoid multiple calls to the static
 749    constructor for each class.
 750
 751    It looks something like this:
 752
 753    foo ()
 754    {
 755       boolean dummy = OtherClass.is_initialized;
 756
 757      ...
 758
 759      if (! dummy)
 760        OtherClass.initialize();
 761
 762      ... use OtherClass.data ...
 763    }
 764
 765    Each of these boolean variables has an entry in the
 766    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 767    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 768    being inlined and create the boolean variables in the outermost
 769    scope of the method being inlined into.  */
 770
 771 /* Create a mapping from a boolean variable in a method being inlined
 772    to one in the scope of the method being inlined into.  */
 773
 774 static int
 775 merge_init_test_initialization (void **entry, void *x)
 776 {
 777   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 778   splay_tree decl_map = (splay_tree)x;
 779   splay_tree_node n;
 780   tree *init_test_decl;
 781
 782   /* See if we have remapped this declaration.  If we haven't there's
 783      a bug in the inliner.  */
 784   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 785   if (! n)
 786     abort ();
 787
 788   /* Create a new entry for the class and its remapped boolean
 789      variable.  If we already have a mapping for this class we've
 790      already initialized it, so don't overwrite the value.  */
 791   init_test_decl = java_treetreehash_new
 792     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 793   if (!*init_test_decl)
 794     *init_test_decl = (tree)n->value;
 795
 796   /* This fixes a weird case.
 797
 798   The front end assumes that once we have called a method that
 799   initializes some class, we can assume the class is initialized.  It
 800   does this by setting the DECL_INITIAL of the init_test_decl for that
 801   class, and no initializations are emitted for that class.
 802
 803   However, what if the method that is suppoed to do the initialization
 804   is itself inlined in the caller?  When expanding the called method
 805   we'll assume that the class initialization has already been done,
 806   because the DECL_INITIAL of the init_test_decl is set.
 807
 808   To fix this we remove the DECL_INITIAL (in the caller scope) of all
 809   the init_test_decls corresponding to classes initialized by the
 810   inlined method.  This makes the caller no longer assume that the
 811   method being inlined does any class initializations.  */
 812   DECL_INITIAL (*init_test_decl) = NULL;
 813
 814   return true;
 815 }
 816
 817 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 818    inlining.  */
 819
 820 void
 821 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 822 {
 823   htab_traverse
 824     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 825      merge_init_test_initialization, decl_map);
 826 }
 827
 828 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 829    inlining into.  If we already have a corresponding entry in that
 830    class we don't need to create another one, so we create a mapping
 831    from the variable in the inlined class to the corresponding
 832    pre-existing one.  */
 833
 834 static int
 835 inline_init_test_initialization (void **entry, void *x)
 836 {
 837   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 838   splay_tree decl_map = (splay_tree)x;
 839
 840   tree h = java_treetreehash_find
 841     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 842   if (! h)
 843     return true;
 844   splay_tree_insert (decl_map,
 845                      (splay_tree_key) ite->value,
 846                      (splay_tree_value) h);
 847   return true;
 848 }
 849
 850 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 851    of a method being inlined.  For each hone, if we already have a
 852    variable associated with the same class in the method being inlined
 853    into, create a new mapping for it.  */
 854
 855 void
 856 java_inlining_map_static_initializers (tree fn, void *decl_map)
 857 {
 858   htab_traverse
 859     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 860      inline_init_test_initialization, decl_map);
 861 }
 862
 863 /* Avoid voluminous output for deep recursion of compound exprs.  */
 864
 865 static void
 866 dump_compound_expr (dump_info_p di, tree t)
 867 {
 868   int i;
 869
 870   for (i=0; i<2; i++)
 871     {
 872       switch (TREE_CODE (TREE_OPERAND (t, i)))
 873         {
 874         case COMPOUND_EXPR:
 875           dump_compound_expr (di, TREE_OPERAND (t, i));
 876           break;
 877
 878         case EXPR_WITH_FILE_LOCATION:
 879             {
 880               tree wfl_node = EXPR_WFL_NODE (TREE_OPERAND (t, i));
 881               dump_child ("expr", wfl_node);
 882               break;
 883             }
 884
 885         default:
 886           dump_child ("expr", TREE_OPERAND (t, i));
 887         }
 888     }
 889 }
 890
 891 static bool
 892 java_dump_tree (void *dump_info, tree t)
 893 {
 894   enum tree_code code;
 895   dump_info_p di = (dump_info_p) dump_info;
 896
 897   /* Figure out what kind of node this is.  */
 898   code = TREE_CODE (t);
 899
 900   switch (code)
 901     {
 902     case FUNCTION_DECL:
 903       dump_child ("args", DECL_ARGUMENTS (t));
 904       if (DECL_EXTERNAL (t))
 905         dump_string (di, "undefined");
 906       if (TREE_PUBLIC (t))
 907         dump_string (di, "extern");
 908       else
 909         dump_string (di, "static");
 910       if (DECL_LANG_SPECIFIC (t))
 911         dump_child ("body", DECL_FUNCTION_BODY (t));
 912       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
 913         dump_child ("inline body", DECL_SAVED_TREE (t));
 914       return true;
 915
 916     case RETURN_EXPR:
 917       dump_child ("expr", TREE_OPERAND (t, 0));
 918       return true;
 919
 920     case GOTO_EXPR:
 921       dump_child ("goto", TREE_OPERAND (t, 0));
 922       return true;
 923
 924     case LABEL_EXPR:
 925       dump_child ("label", TREE_OPERAND (t, 0));
 926       return true;
 927
 928     case LABELED_BLOCK_EXPR:
 929       dump_child ("label", LABELED_BLOCK_LABEL (t));
 930       dump_child ("block", LABELED_BLOCK_BODY (t));
 931       return true;
 932
 933     case EXIT_BLOCK_EXPR:
 934       dump_child ("block", EXIT_BLOCK_LABELED_BLOCK (t));
 935       return true;
 936
 937     case BLOCK:
 938       if (BLOCK_EXPR_BODY (t))
 939         {
 940           tree local = BLOCK_VARS (t);
 941           while (local)
 942             {
 943               tree next = TREE_CHAIN (local);
 944               dump_child ("var", local);
 945               local = next;
 946             }
 947
 948           {
 949             tree block = BLOCK_EXPR_BODY (t);
 950             dump_child ("body", block);
 951             block = TREE_CHAIN (block);
 952           }
 953         }
 954       return true;
 955
 956     case COMPOUND_EXPR:
 957       if (!dump_flag (di, TDF_SLIM, t))
 958         return false;
 959       dump_compound_expr (di, t);
 960       return true;
 961
 962     default:
 963       break;
 964     }
 965   return false;
 966 }
 967
 968 /* Java calls can't, in general, be sibcalls because we need an
 969    accurate stack trace in order to guarantee correct operation of
 970    methods such as Class.forName(String) and
 971    SecurityManager.getClassContext().  */
 972
 973 static bool
 974 java_decl_ok_for_sibcall (tree decl)
 975 {
 976   return decl != NULL && DECL_CONTEXT (decl) == output_class;
 977 }
 978
 979 /* Given a call_expr, try to figure out what its target might be.  In
 980    the case of an indirection via the atable, search for the decl.  If
 981    the decl is external, we return NULL.  If we don't, the optimizer
 982    will replace the indirection with a direct call, which undoes the
 983    purpose of the atable indirection.  */
 984 static tree
 985 java_get_callee_fndecl (tree call_expr)
 986 {
 987   tree method, table, element, atable_methods;
 988
 989   HOST_WIDE_INT index;
 990
 991   /* FIXME: This is disabled because we end up passing calls through
 992      the PLT, and we do NOT want to do that.  */
 993   return NULL;
 994
 995   if (TREE_CODE (call_expr) != CALL_EXPR)
 996     return NULL;
 997   method = TREE_OPERAND (call_expr, 0);
 998   STRIP_NOPS (method);
 999   if (TREE_CODE (method) != ARRAY_REF)
1000     return NULL;
1001   table = TREE_OPERAND (method, 0);
1002   if (! DECL_LANG_SPECIFIC(table)
1003       || !DECL_OWNER (table)
1004       || TYPE_ATABLE_DECL (DECL_OWNER (table)) != table)
1005     return NULL;
1006
1007   atable_methods = TYPE_ATABLE_METHODS (DECL_OWNER (table));
1008   index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
1009
1010   /* FIXME: Replace this for loop with a hash table lookup.  */
1011   for (element = atable_methods; element; element = TREE_CHAIN (element))
1012     {
1013       if (index == 1)
1014         {
1015           tree purpose = TREE_PURPOSE (element);
1016           if (TREE_CODE (purpose) == FUNCTION_DECL
1017               && ! DECL_EXTERNAL (purpose))
1018             return purpose;
1019           else
1020             return NULL;
1021         }
1022       --index;
1023     }
1024
1025   return NULL;
1026 }
1027
1028
1029 /* Clear the binding stack.  */
1030 static void
1031 java_clear_binding_stack (void)
1032 {
1033   while (!global_bindings_p ())
1034     poplevel (0, 0, 0);
1035 }
1036
1037 #include "gt-java-lang.h"