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