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 *, void *);
  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                                   void *htab 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, htab);   \
 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     default:
 735       return NULL_TREE;
 736     }
 737
 738   #undef WALK_SUBTREE
 739 }
 740
 741 /* Every call to a static constructor has an associated boolean
 742    variable which is in the outermost scope of the calling method.
 743    This variable is used to avoid multiple calls to the static
 744    constructor for each class.
 745
 746    It looks something like this:
 747
 748    foo ()
 749    {
 750       boolean dummy = OtherClass.is_initialized;
 751
 752      ...
 753
 754      if (! dummy)
 755        OtherClass.initialize();
 756
 757      ... use OtherClass.data ...
 758    }
 759
 760    Each of these boolean variables has an entry in the
 761    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 762    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 763    being inlined and create the boolean variables in the outermost
 764    scope of the method being inlined into.  */
 765
 766 /* Create a mapping from a boolean variable in a method being inlined
 767    to one in the scope of the method being inlined into.  */
 768
 769 static int
 770 merge_init_test_initialization (void **entry, void *x)
 771 {
 772   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 773   splay_tree decl_map = (splay_tree)x;
 774   splay_tree_node n;
 775   tree *init_test_decl;
 776
 777   /* See if we have remapped this declaration.  If we haven't there's
 778      a bug in the inliner.  */
 779   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 780   if (! n)
 781     abort ();
 782
 783   /* Create a new entry for the class and its remapped boolean
 784      variable.  If we already have a mapping for this class we've
 785      already initialized it, so don't overwrite the value.  */
 786   init_test_decl = java_treetreehash_new
 787     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 788   if (!*init_test_decl)
 789     *init_test_decl = (tree)n->value;
 790
 791   /* This fixes a weird case.
 792
 793   The front end assumes that once we have called a method that
 794   initializes some class, we can assume the class is initialized.  It
 795   does this by setting the DECL_INITIAL of the init_test_decl for that
 796   class, and no initializations are emitted for that class.
 797
 798   However, what if the method that is suppoed to do the initialization
 799   is itself inlined in the caller?  When expanding the called method
 800   we'll assume that the class initialization has already been done,
 801   because the DECL_INITIAL of the init_test_decl is set.
 802
 803   To fix this we remove the DECL_INITIAL (in the caller scope) of all
 804   the init_test_decls corresponding to classes initialized by the
 805   inlined method.  This makes the caller no longer assume that the
 806   method being inlined does any class initializations.  */
 807   DECL_INITIAL (*init_test_decl) = NULL;
 808
 809   return true;
 810 }
 811
 812 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 813    inlining.  */
 814
 815 void
 816 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 817 {
 818   htab_traverse
 819     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 820      merge_init_test_initialization, decl_map);
 821 }
 822
 823 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 824    inlining into.  If we already have a corresponding entry in that
 825    class we don't need to create another one, so we create a mapping
 826    from the variable in the inlined class to the corresponding
 827    pre-existing one.  */
 828
 829 static int
 830 inline_init_test_initialization (void **entry, void *x)
 831 {
 832   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 833   splay_tree decl_map = (splay_tree)x;
 834
 835   tree h = java_treetreehash_find
 836     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 837   if (! h)
 838     return true;
 839   splay_tree_insert (decl_map,
 840                      (splay_tree_key) ite->value,
 841                      (splay_tree_value) h);
 842   return true;
 843 }
 844
 845 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 846    of a method being inlined.  For each hone, if we already have a
 847    variable associated with the same class in the method being inlined
 848    into, create a new mapping for it.  */
 849
 850 void
 851 java_inlining_map_static_initializers (tree fn, void *decl_map)
 852 {
 853   htab_traverse
 854     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 855      inline_init_test_initialization, decl_map);
 856 }
 857
 858 /* Avoid voluminous output for deep recursion of compound exprs.  */
 859
 860 static void
 861 dump_compound_expr (dump_info_p di, tree t)
 862 {
 863   int i;
 864
 865   for (i=0; i<2; i++)
 866     {
 867       switch (TREE_CODE (TREE_OPERAND (t, i)))
 868         {
 869         case COMPOUND_EXPR:
 870           dump_compound_expr (di, TREE_OPERAND (t, i));
 871           break;
 872
 873         case EXPR_WITH_FILE_LOCATION:
 874             {
 875               tree wfl_node = EXPR_WFL_NODE (TREE_OPERAND (t, i));
 876               dump_child ("expr", wfl_node);
 877               break;
 878             }
 879
 880         default:
 881           dump_child ("expr", TREE_OPERAND (t, i));
 882         }
 883     }
 884 }
 885
 886 static bool
 887 java_dump_tree (void *dump_info, tree t)
 888 {
 889   enum tree_code code;
 890   dump_info_p di = (dump_info_p) dump_info;
 891
 892   /* Figure out what kind of node this is.  */
 893   code = TREE_CODE (t);
 894
 895   switch (code)
 896     {
 897     case FUNCTION_DECL:
 898       dump_child ("args", DECL_ARGUMENTS (t));
 899       if (DECL_EXTERNAL (t))
 900         dump_string (di, "undefined");
 901       if (TREE_PUBLIC (t))
 902         dump_string (di, "extern");
 903       else
 904         dump_string (di, "static");
 905       if (DECL_LANG_SPECIFIC (t))
 906         dump_child ("body", DECL_FUNCTION_BODY (t));
 907       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
 908         dump_child ("inline body", DECL_SAVED_TREE (t));
 909       return true;
 910
 911     case RETURN_EXPR:
 912       dump_child ("expr", TREE_OPERAND (t, 0));
 913       return true;
 914
 915     case GOTO_EXPR:
 916       dump_child ("goto", TREE_OPERAND (t, 0));
 917       return true;
 918
 919     case LABEL_EXPR:
 920       dump_child ("label", TREE_OPERAND (t, 0));
 921       return true;
 922
 923     case LABELED_BLOCK_EXPR:
 924       dump_child ("label", TREE_OPERAND (t, 0));
 925       dump_child ("block", TREE_OPERAND (t, 1));
 926       return true;
 927
 928     case EXIT_BLOCK_EXPR:
 929       dump_child ("block", TREE_OPERAND (t, 0));
 930       dump_child ("val", TREE_OPERAND (t, 1));
 931       return true;
 932
 933     case BLOCK:
 934       if (BLOCK_EXPR_BODY (t))
 935         {
 936           tree local = BLOCK_VARS (t);
 937           while (local)
 938             {
 939               tree next = TREE_CHAIN (local);
 940               dump_child ("var", local);
 941               local = next;
 942             }
 943
 944           {
 945             tree block = BLOCK_EXPR_BODY (t);
 946             dump_child ("body", block);
 947             block = TREE_CHAIN (block);
 948           }
 949         }
 950       return true;
 951
 952     case COMPOUND_EXPR:
 953       if (!dump_flag (di, TDF_SLIM, t))
 954         return false;
 955       dump_compound_expr (di, t);
 956       return true;
 957
 958     default:
 959       break;
 960     }
 961   return false;
 962 }
 963
 964 /* Java calls can't, in general, be sibcalls because we need an
 965    accurate stack trace in order to guarantee correct operation of
 966    methods such as Class.forName(String) and
 967    SecurityManager.getClassContext().  */
 968
 969 static bool
 970 java_decl_ok_for_sibcall (tree decl)
 971 {
 972   return decl != NULL && DECL_CONTEXT (decl) == output_class;
 973 }
 974
 975 /* Given a call_expr, try to figure out what its target might be.  In
 976    the case of an indirection via the atable, search for the decl.  If
 977    the decl is external, we return NULL.  If we don't, the optimizer
 978    will replace the indirection with a direct call, which undoes the
 979    purpose of the atable indirection.  */
 980 static tree
 981 java_get_callee_fndecl (tree call_expr)
 982 {
 983   tree method, table, element, atable_methods;
 984
 985   HOST_WIDE_INT index;
 986
 987   if (TREE_CODE (call_expr) != CALL_EXPR)
 988     return NULL;
 989   method = TREE_OPERAND (call_expr, 0);
 990   STRIP_NOPS (method);
 991   if (TREE_CODE (method) != ARRAY_REF)
 992     return NULL;
 993   table = TREE_OPERAND (method, 0);
 994   if (! DECL_LANG_SPECIFIC(table)
 995       || !DECL_OWNER (table)
 996       || TYPE_ATABLE_DECL (DECL_OWNER (table)) != table)
 997     return NULL;
 998
 999   atable_methods = TYPE_ATABLE_METHODS (DECL_OWNER (table));
1000   index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
1001
1002   /* FIXME: Replace this for loop with a hash table lookup.  */
1003   for (element = atable_methods; element; element = TREE_CHAIN (element))
1004     {
1005       if (index == 1)
1006         {
1007           tree purpose = TREE_PURPOSE (element);
1008           if (TREE_CODE (purpose) == FUNCTION_DECL
1009               && ! DECL_EXTERNAL (purpose))
1010             return purpose;
1011           else
1012             return NULL;
1013         }
1014       --index;
1015     }
1016
1017   return NULL;
1018 }
1019
1020
1021 /* Clear the binding stack.  */
1022 static void
1023 java_clear_binding_stack (void)
1024 {
1025   while (!global_bindings_p ())
1026     poplevel (0, 0, 0);
1027 }
1028
1029 #include "gt-java-lang.h"