gcc/java/lang.c

   1 /* Java(TM) language-specific utility routines.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   3    2005, 2006, 2007, 2008, 2010 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 3, 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 COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.
  20
  21 Java and all Java-based marks are trademarks or registered trademarks
  22 of Sun Microsystems, Inc. in the United States and other countries.
  23 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  24
  25 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tm.h"
  31 #include "tree.h"
  32 #include "input.h"
  33 #include "java-tree.h"
  34 #include "jcf.h"
  35 #include "langhooks.h"
  36 #include "langhooks-def.h"
  37 #include "flags.h"
  38 #include "ggc.h"
  39 #include "diagnostic.h"
  40 #include "tree-inline.h"
  41 #include "splay-tree.h"
  42 #include "tree-dump.h"
  43 #include "opts.h"
  44 #include "options.h"
  45 #include "target.h"
  46
  47 static bool java_init (void);
  48 static void java_finish (void);
  49 static unsigned int java_option_lang_mask (void);
  50 static void java_init_options_struct (struct gcc_options *);
  51 static void java_init_options (unsigned int, struct cl_decoded_option *);
  52 static bool java_post_options (const char **);
  53
  54 static bool java_handle_option (size_t, const char *, int, int, location_t,
  55                                 const struct cl_option_handlers *);
  56 static void put_decl_string (const char *, int);
  57 static void put_decl_node (tree, int);
  58 static void java_print_error_function (diagnostic_context *, const char *,
  59                                        diagnostic_info *);
  60 static int merge_init_test_initialization (void * *, void *);
  61 static int inline_init_test_initialization (void * *, void *);
  62 static bool java_dump_tree (void *, tree);
  63 static void dump_compound_expr (dump_info_p, tree);
  64 static bool java_decl_ok_for_sibcall (const_tree);
  65
  66 static enum classify_record java_classify_record (tree type);
  67
  68 static tree java_eh_personality (void);
  69
  70 #ifndef TARGET_OBJECT_SUFFIX
  71 # define TARGET_OBJECT_SUFFIX ".o"
  72 #endif
  73
  74 /* Table of machine-independent attributes.  */
  75 const struct attribute_spec java_attribute_table[] =
  76 {
  77  { "nonnull",                0, -1, false, true, true,
  78                               NULL, false },
  79   { NULL,                     0, 0, false, false, false, NULL, false }
  80 };
  81
  82 /* Used to avoid printing error messages with bogus function
  83    prototypes.  Starts out false.  */
  84 static bool inhibit_error_function_printing;
  85
  86 const char *resource_name;
  87
  88 /* When nonzero, -Wall was turned on.  */
  89 int flag_wall = 0;
  90
  91 /* When nonzero, report use of deprecated classes, methods, or fields.  */
  92 int flag_deprecated = 1;
  93
  94 /* When zero, don't optimize static class initialization. This flag shouldn't
  95    be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead.  */
  96 /* FIXME: Make this work with gimplify.  */
  97 /* int flag_optimize_sci = 0;  */
  98
  99 /* Don't attempt to verify invocations.  */
 100 int flag_verify_invocations = 0;
 101
 102 /* When nonzero, print extra version information.  */
 103 static int v_flag = 0;
 104
 105 JCF *current_jcf;
 106
 107 /* Variable controlling how dependency tracking is enabled in
 108    java_init.  */
 109 static int dependency_tracking = 0;
 110
 111 /* Flag values for DEPENDENCY_TRACKING.  */
 112 #define DEPEND_SET_FILE 1
 113 #define DEPEND_ENABLE   2
 114 #define DEPEND_TARGET_SET 4
 115 #define DEPEND_FILE_ALREADY_SET 8
 116
 117 struct GTY(()) language_function {
 118   int unused;
 119 };
 120
 121 #undef LANG_HOOKS_NAME
 122 #define LANG_HOOKS_NAME "GNU Java"
 123 #undef LANG_HOOKS_INIT
 124 #define LANG_HOOKS_INIT java_init
 125 #undef LANG_HOOKS_FINISH
 126 #define LANG_HOOKS_FINISH java_finish
 127 #undef LANG_HOOKS_OPTION_LANG_MASK
 128 #define LANG_HOOKS_OPTION_LANG_MASK java_option_lang_mask
 129 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
 130 #define LANG_HOOKS_INIT_OPTIONS_STRUCT java_init_options_struct
 131 #undef LANG_HOOKS_INIT_OPTIONS
 132 #define LANG_HOOKS_INIT_OPTIONS java_init_options
 133 #undef LANG_HOOKS_HANDLE_OPTION
 134 #define LANG_HOOKS_HANDLE_OPTION java_handle_option
 135 #undef LANG_HOOKS_POST_OPTIONS
 136 #define LANG_HOOKS_POST_OPTIONS java_post_options
 137 #undef LANG_HOOKS_PARSE_FILE
 138 #define LANG_HOOKS_PARSE_FILE java_parse_file
 139 #undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL
 140 #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL java_dup_lang_specific_decl
 141 #undef LANG_HOOKS_DECL_PRINTABLE_NAME
 142 #define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name
 143 #undef LANG_HOOKS_PRINT_ERROR_FUNCTION
 144 #define LANG_HOOKS_PRINT_ERROR_FUNCTION java_print_error_function
 145 #undef LANG_HOOKS_WRITE_GLOBALS
 146 #define LANG_HOOKS_WRITE_GLOBALS java_write_globals
 147
 148 #undef LANG_HOOKS_TYPE_FOR_MODE
 149 #define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode
 150 #undef LANG_HOOKS_TYPE_FOR_SIZE
 151 #define LANG_HOOKS_TYPE_FOR_SIZE java_type_for_size
 152 #undef LANG_HOOKS_CLASSIFY_RECORD
 153 #define LANG_HOOKS_CLASSIFY_RECORD java_classify_record
 154
 155 #undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN
 156 #define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN java_dump_tree
 157
 158 #undef LANG_HOOKS_GIMPLIFY_EXPR
 159 #define LANG_HOOKS_GIMPLIFY_EXPR java_gimplify_expr
 160
 161 #undef LANG_HOOKS_DECL_OK_FOR_SIBCALL
 162 #define LANG_HOOKS_DECL_OK_FOR_SIBCALL java_decl_ok_for_sibcall
 163
 164 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
 165 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME java_mangle_decl
 166
 167 #undef LANG_HOOKS_ATTRIBUTE_TABLE
 168 #define LANG_HOOKS_ATTRIBUTE_TABLE java_attribute_table
 169
 170 #undef LANG_HOOKS_EH_PERSONALITY
 171 #define LANG_HOOKS_EH_PERSONALITY java_eh_personality
 172
 173 #undef LANG_HOOKS_EH_USE_CXA_END_CLEANUP
 174 #define LANG_HOOKS_EH_USE_CXA_END_CLEANUP  true
 175
 176 /* Each front end provides its own.  */
 177 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 178
 179 /*
 180  * process java-specific compiler command-line options
 181  * return false, but do not complain if the option is not recognized.
 182  */
 183 static bool
 184 java_handle_option (size_t scode, const char *arg, int value,
 185                     int kind ATTRIBUTE_UNUSED, location_t loc ATTRIBUTE_UNUSED,
 186                     const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 187 {
 188   enum opt_code code = (enum opt_code) scode;
 189
 190   switch (code)
 191     {
 192     case OPT_I:
 193       jcf_path_include_arg (arg);
 194       break;
 195
 196     case OPT_M:
 197       jcf_dependency_init (1);
 198       dependency_tracking |= DEPEND_ENABLE;
 199       break;
 200
 201     case OPT_MD_:
 202       jcf_dependency_init (1);
 203       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 204       break;
 205
 206     case OPT_MF:
 207       jcf_dependency_set_dep_file (arg);
 208       dependency_tracking |= DEPEND_FILE_ALREADY_SET;
 209       break;
 210
 211     case OPT_MM:
 212       jcf_dependency_init (0);
 213       dependency_tracking |= DEPEND_ENABLE;
 214       break;
 215
 216     case OPT_MMD_:
 217       jcf_dependency_init (0);
 218       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 219       break;
 220
 221     case OPT_MP:
 222       jcf_dependency_print_dummies ();
 223       break;
 224
 225     case OPT_MT:
 226       jcf_dependency_set_target (arg);
 227       dependency_tracking |= DEPEND_TARGET_SET;
 228       break;
 229
 230     case OPT_Wall:
 231       flag_wall = value;
 232       /* When -Wall given, enable -Wunused.  We do this because the C
 233          compiler does it, and people expect it.  */
 234       warn_unused = value;
 235       break;
 236
 237     case OPT_fenable_assertions_:
 238       add_enable_assert (arg, value);
 239       break;
 240
 241     case OPT_fenable_assertions:
 242       add_enable_assert ("", value);
 243       break;
 244
 245     case OPT_fdisable_assertions_:
 246       add_enable_assert (arg, !value);
 247       break;
 248
 249     case OPT_fdisable_assertions:
 250       add_enable_assert ("", !value);
 251       break;
 252
 253     case OPT_fassume_compiled_:
 254       add_assume_compiled (arg, !value);
 255       break;
 256
 257     case OPT_fassume_compiled:
 258       add_assume_compiled ("", !value);
 259       break;
 260
 261     case OPT_fbootclasspath_:
 262       jcf_path_bootclasspath_arg (arg);
 263       break;
 264
 265     case OPT_faux_classpath:
 266     case OPT_fclasspath_:
 267       jcf_path_classpath_arg (arg);
 268       break;
 269
 270     case OPT_fcompile_resource_:
 271       resource_name = arg;
 272       break;
 273
 274     case OPT_fdump_:
 275       if (!dump_switch_p (arg))
 276         return false;
 277       break;
 278
 279     case OPT_fencoding_:
 280       /* Nothing.  */
 281       break;
 282
 283     case OPT_fextdirs_:
 284       jcf_path_extdirs_arg (arg);
 285       break;
 286
 287     case OPT_foutput_class_dir_:
 288       /* FIXME: remove; this is handled by ecj1 now.  */
 289       break;
 290
 291     case OPT_version:
 292       v_flag = 1;
 293       break;
 294
 295     case OPT_fsource_filename_:
 296       java_read_sourcefilenames (arg);
 297       break;
 298
 299     default:
 300       if (cl_options[code].flags & CL_Java)
 301         break;
 302       gcc_unreachable ();
 303     }
 304
 305   return true;
 306 }
 307
 308 /* Global open file.  */
 309 FILE *finput;
 310
 311 static bool
 312 java_init (void)
 313 {
 314   /* FIXME: Indirect dispatch isn't yet compatible with static class
 315      init optimization.  */
 316   if (flag_indirect_dispatch)
 317     always_initialize_class_p = true;
 318
 319   if (!flag_indirect_dispatch)
 320     flag_indirect_classes = false;
 321
 322   jcf_path_seal (v_flag);
 323
 324   java_init_decl_processing ();
 325
 326   using_eh_for_cleanups ();
 327
 328   return true;
 329 }
 330
 331 static void
 332 java_finish (void)
 333 {
 334   jcf_dependency_write ();
 335 }
 336
 337 /* Buffer used by lang_printable_name. */
 338 static char *decl_buf = NULL;
 339
 340 /* Allocated size of decl_buf. */
 341 static int decl_buflen = 0;
 342
 343 /* Length of used part of decl_buf;  position for next character. */
 344 static int decl_bufpos = 0;
 345
 346 /* Append the string STR to decl_buf.
 347    It length is given by LEN;  -1 means the string is nul-terminated. */
 348
 349 static void
 350 put_decl_string (const char *str, int len)
 351 {
 352   if (len < 0)
 353     len = strlen (str);
 354   if (decl_bufpos + len >= decl_buflen)
 355     {
 356       if (decl_buf == NULL)
 357         {
 358           decl_buflen = len + 100;
 359           decl_buf = XNEWVEC (char, decl_buflen);
 360         }
 361       else
 362         {
 363           decl_buflen *= 2;
 364           decl_buf = XRESIZEVAR (char, decl_buf, decl_buflen);
 365         }
 366     }
 367   strcpy (decl_buf + decl_bufpos, str);
 368   decl_bufpos += len;
 369 }
 370
 371 /* Append to decl_buf a printable name for NODE.
 372    Depending on VERBOSITY, more information about NODE
 373    is printed. Read the comments of decl_printable_name in
 374    langhooks.h for more.  */
 375
 376 static void
 377 put_decl_node (tree node, int verbosity)
 378 {
 379   int was_pointer = 0;
 380   if (TREE_CODE (node) == POINTER_TYPE)
 381     {
 382       node = TREE_TYPE (node);
 383       was_pointer = 1;
 384     }
 385   if (DECL_P (node) && DECL_NAME (node) != NULL_TREE)
 386     {
 387       if (TREE_CODE (node) == FUNCTION_DECL)
 388         {
 389           if (verbosity == 0 && DECL_NAME (node))
 390           /* We have been instructed to just print the bare name
 391              of the function.  */
 392             {
 393               put_decl_node (DECL_NAME (node), 0);
 394               return;
 395             }
 396
 397           /* We want to print the type the DECL belongs to. We don't do
 398              that when we handle constructors. */
 399           if (! DECL_CONSTRUCTOR_P (node)
 400               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node)
 401               /* We want to print qualified DECL names only
 402                  if verbosity is higher than 1.  */
 403               && verbosity >= 1)
 404             {
 405               put_decl_node (TREE_CODE (DECL_CONTEXT (node)) == FUNCTION_DECL
 406                              ? DECL_CONTEXT (node)
 407                              : TYPE_NAME (DECL_CONTEXT (node)),
 408                                verbosity);
 409               put_decl_string (".", 1);
 410             }
 411           if (! DECL_CONSTRUCTOR_P (node))
 412             put_decl_node (DECL_NAME (node), verbosity);
 413           if (TREE_TYPE (node) != NULL_TREE
 414               /* We want to print function parameters only if verbosity
 415                  is higher than 2.  */
 416               && verbosity >= 2)
 417             {
 418               int i = 0;
 419               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
 420               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
 421                 args = TREE_CHAIN (args);
 422               put_decl_string ("(", 1);
 423               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
 424                 {
 425                   if (i > 0)
 426                     put_decl_string (",", 1);
 427                   put_decl_node (TREE_VALUE (args), verbosity);
 428                 }
 429               put_decl_string (")", 1);
 430             }
 431         }
 432       else
 433         put_decl_node (DECL_NAME (node), verbosity);
 434     }
 435   else if (TYPE_P (node) && TYPE_NAME (node) != NULL_TREE)
 436     {
 437       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node)
 438           /* Print detailed array information only if verbosity is higher
 439             than 2.  */
 440           && verbosity >= 2)
 441         {
 442           put_decl_node (TYPE_ARRAY_ELEMENT (node), verbosity);
 443           put_decl_string("[]", 2);
 444         }
 445       else if (node == promoted_byte_type_node)
 446         put_decl_string ("byte", 4);
 447       else if (node == promoted_short_type_node)
 448         put_decl_string ("short", 5);
 449       else if (node == promoted_char_type_node)
 450         put_decl_string ("char", 4);
 451       else if (node == promoted_boolean_type_node)
 452         put_decl_string ("boolean", 7);
 453       else if (node == void_type_node && was_pointer)
 454         put_decl_string ("null", 4);
 455       else
 456         put_decl_node (TYPE_NAME (node), verbosity);
 457     }
 458   else if (TREE_CODE (node) == IDENTIFIER_NODE)
 459     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
 460   else
 461     put_decl_string ("<unknown>", -1);
 462 }
 463
 464 /* Return a user-friendly name for DECL.
 465    The resulting string is only valid until the next call.
 466    The value of the hook decl_printable_name is this function,
 467    which is also called directly by java_print_error_function. */
 468
 469 const char *
 470 lang_printable_name (tree decl, int v)
 471 {
 472   decl_bufpos = 0;
 473   put_decl_node (decl, v);
 474   put_decl_string ("", 1);
 475   return decl_buf;
 476 }
 477
 478 /* Print on stderr the current class and method context.  This function
 479    is the value of the hook print_error_function. */
 480
 481 static GTY(()) tree last_error_function_context;
 482 static GTY(()) tree last_error_function;
 483 static void
 484 java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
 485                            const char *file,
 486                            diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
 487 {
 488   /* Don't print error messages with bogus function prototypes.  */
 489   if (inhibit_error_function_printing)
 490     return;
 491
 492   if (current_function_decl != NULL
 493       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
 494     {
 495       if (file)
 496         fprintf (stderr, "%s: ", file);
 497
 498       last_error_function_context = DECL_CONTEXT (current_function_decl);
 499       fprintf (stderr, "In class '%s':\n",
 500                lang_printable_name (last_error_function_context, 0));
 501     }
 502   if (last_error_function != current_function_decl)
 503     {
 504       if (file)
 505         fprintf (stderr, "%s: ", file);
 506
 507       if (current_function_decl == NULL)
 508         fprintf (stderr, "At top level:\n");
 509       else
 510         {
 511           const char *name = lang_printable_name (current_function_decl, 2);
 512           fprintf (stderr, "In %s '%s':\n",
 513                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
 514                     : "method"),
 515                    name);
 516         }
 517
 518       last_error_function = current_function_decl;
 519     }
 520
 521 }
 522
 523 /* Called to install the PRINT_ERROR_FUNCTION hook differently
 524    according to LEVEL. LEVEL is 1 during early parsing, when function
 525    prototypes aren't fully resolved. java_print_error_function is set
 526    so it doesn't print incomplete function prototypes. When LEVEL is
 527    2, function prototypes are fully resolved and can be printed when
 528    reporting errors.  */
 529
 530 void
 531 lang_init_source (int level)
 532 {
 533   inhibit_error_function_printing = (level == 1);
 534 }
 535
 536 static unsigned int
 537 java_option_lang_mask (void)
 538 {
 539   return CL_Java;
 540 }
 541
 542 /* Initialize options structure OPTS.  */
 543
 544 static void
 545 java_init_options_struct (struct gcc_options *opts)
 546 {
 547   opts->x_flag_bounds_check = 1;
 548   opts->x_flag_exceptions = 1;
 549   opts->x_flag_non_call_exceptions = 1;
 550
 551   /* In Java floating point operations never trap.  */
 552   opts->x_flag_trapping_math = 0;
 553
 554   /* In Java arithmetic overflow always wraps around.  */
 555   opts->x_flag_wrapv = 1;
 556
 557   /* Java requires left-to-right evaluation of subexpressions.  */
 558   opts->x_flag_evaluation_order = 1;
 559 }
 560
 561 static void
 562 java_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED,
 563                    struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED)
 564 {
 565   jcf_path_init ();
 566 }
 567
 568 /* Post-switch processing.  */
 569 static bool
 570 java_post_options (const char **pfilename)
 571 {
 572   const char *filename = *pfilename;
 573
 574   /* Excess precision other than "fast" requires front-end
 575      support.  */
 576   if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
 577       && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
 578     sorry ("-fexcess-precision=standard for Java");
 579   flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
 580
 581   /* An absolute requirement: if we're not using indirect dispatch, we
 582      must always verify everything.  */
 583   if (! flag_indirect_dispatch)
 584     flag_verify_invocations = true;
 585
 586   if (flag_reduced_reflection)
 587     {
 588       if (flag_indirect_dispatch)
 589         error ("-findirect-dispatch is incompatible "
 590                "with -freduced-reflection");
 591       if (flag_jni)
 592         error ("-fjni is incompatible with -freduced-reflection");
 593     }
 594
 595   /* Open input file.  */
 596
 597   if (filename == 0 || !strcmp (filename, "-"))
 598     {
 599       finput = stdin;
 600       filename = "stdin";
 601
 602       if (dependency_tracking)
 603         error ("can%'t do dependency tracking with input from stdin");
 604     }
 605   else
 606     {
 607       if (dependency_tracking)
 608         {
 609           const char *dot;
 610
 611           /* If the target is set and the output filename is set, then
 612              there's no processing to do here.  Otherwise we must
 613              compute one or the other.  */
 614           if (! ((dependency_tracking & DEPEND_TARGET_SET)
 615                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
 616             {
 617               dot = strrchr (filename, '.');
 618               if (dot == NULL)
 619                 error ("couldn%'t determine target name for dependency tracking");
 620               else
 621                 {
 622                   char *buf = XNEWVEC (char, dot - filename +
 623                                        3 + sizeof (TARGET_OBJECT_SUFFIX));
 624                   strncpy (buf, filename, dot - filename);
 625
 626                   /* If emitting class files, we might have multiple
 627                      targets.  The class generation code takes care of
 628                      registering them.  Otherwise we compute the
 629                      target name here.  */
 630                   if ((dependency_tracking & DEPEND_TARGET_SET))
 631                     ; /* Nothing.  */
 632                   else
 633                     {
 634                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
 635                       jcf_dependency_set_target (buf);
 636                     }
 637
 638                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
 639                     ; /* Nothing.  */
 640                   else if ((dependency_tracking & DEPEND_SET_FILE))
 641                     {
 642                       strcpy (buf + (dot - filename), ".d");
 643                       jcf_dependency_set_dep_file (buf);
 644                     }
 645                   else
 646                     jcf_dependency_set_dep_file ("-");
 647
 648                   free (buf);
 649                 }
 650             }
 651         }
 652     }
 653   linemap_add (line_table, LC_ENTER, false, filename, 0);
 654   linemap_add (line_table, LC_RENAME, false, "<built-in>", 0);
 655
 656   /* Initialize the compiler back end.  */
 657   return false;
 658 }
 659
 660 /* Return either DECL or its known constant value (if it has one).  */
 661
 662 tree
 663 decl_constant_value (tree decl)
 664 {
 665   if (/* Don't change a variable array bound or initial value to a constant
 666          in a place where a variable is invalid.  */
 667       current_function_decl != 0
 668       && ! TREE_THIS_VOLATILE (decl)
 669       && TREE_READONLY (decl)
 670       && DECL_INITIAL (decl) != 0
 671       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 672       /* This is invalid if initial value is not constant.
 673          If it has either a function call, a memory reference,
 674          or a variable, then re-evaluating it could give different results.  */
 675       && TREE_CONSTANT (DECL_INITIAL (decl))
 676       /* Check for cases where this is sub-optimal, even though valid.  */
 677       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 678     return DECL_INITIAL (decl);
 679   return decl;
 680 }
 681
 682 /* Every call to a static constructor has an associated boolean
 683    variable which is in the outermost scope of the calling method.
 684    This variable is used to avoid multiple calls to the static
 685    constructor for each class.
 686
 687    It looks something like this:
 688
 689    foo ()
 690    {
 691       boolean dummy = OtherClass.is_initialized;
 692
 693      ...
 694
 695      if (! dummy)
 696        OtherClass.initialize();
 697
 698      ... use OtherClass.data ...
 699    }
 700
 701    Each of these boolean variables has an entry in the
 702    DECL_FUNCTION_INIT_TEST_TABLE of a method.  When inlining a method
 703    we must merge the DECL_FUNCTION_INIT_TEST_TABLE from the function
 704    being inlined and create the boolean variables in the outermost
 705    scope of the method being inlined into.  */
 706
 707 /* Create a mapping from a boolean variable in a method being inlined
 708    to one in the scope of the method being inlined into.  */
 709
 710 static int
 711 merge_init_test_initialization (void **entry, void *x)
 712 {
 713   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
 714   splay_tree decl_map = (splay_tree)x;
 715   splay_tree_node n;
 716   tree *init_test_decl;
 717
 718   /* See if we have remapped this declaration.  If we haven't there's
 719      a bug in the inliner.  */
 720   n = splay_tree_lookup (decl_map, (splay_tree_key) ite->value);
 721   gcc_assert (n);
 722
 723   /* Create a new entry for the class and its remapped boolean
 724      variable.  If we already have a mapping for this class we've
 725      already initialized it, so don't overwrite the value.  */
 726   init_test_decl = java_treetreehash_new
 727     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 728   if (!*init_test_decl)
 729     *init_test_decl = (tree)n->value;
 730
 731   /* This fixes a weird case.
 732
 733   The front end assumes that once we have called a method that
 734   initializes some class, we can assume the class is initialized.  It
 735   does this by setting the DECL_INITIAL of the init_test_decl for that
 736   class, and no initializations are emitted for that class.
 737
 738   However, what if the method that is supposed to do the initialization
 739   is itself inlined in the caller?  When expanding the called method
 740   we'll assume that the class initialization has already been done,
 741   because the DECL_INITIAL of the init_test_decl is set.
 742
 743   To fix this we remove the DECL_INITIAL (in the caller scope) of all
 744   the init_test_decls corresponding to classes initialized by the
 745   inlined method.  This makes the caller no longer assume that the
 746   method being inlined does any class initializations.  */
 747   DECL_INITIAL (*init_test_decl) = NULL;
 748
 749   return true;
 750 }
 751
 752 /* Merge the DECL_FUNCTION_INIT_TEST_TABLE from the function we're
 753    inlining.  */
 754
 755 void
 756 java_inlining_merge_static_initializers (tree fn, void *decl_map)
 757 {
 758   htab_traverse
 759     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 760      merge_init_test_initialization, decl_map);
 761 }
 762
 763 /* Lookup a DECL_FUNCTION_INIT_TEST_TABLE entry in the method we're
 764    inlining into.  If we already have a corresponding entry in that
 765    class we don't need to create another one, so we create a mapping
 766    from the variable in the inlined class to the corresponding
 767    pre-existing one.  */
 768
 769 static int
 770 inline_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
 775   tree h = java_treetreehash_find
 776     (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
 777   if (! h)
 778     return true;
 779   splay_tree_insert (decl_map,
 780                      (splay_tree_key) ite->value,
 781                      (splay_tree_value) h);
 782   return true;
 783 }
 784
 785 /* Look up the boolean variables in the DECL_FUNCTION_INIT_TEST_TABLE
 786    of a method being inlined.  For each hone, if we already have a
 787    variable associated with the same class in the method being inlined
 788    into, create a new mapping for it.  */
 789
 790 void
 791 java_inlining_map_static_initializers (tree fn, void *decl_map)
 792 {
 793   htab_traverse
 794     (DECL_FUNCTION_INIT_TEST_TABLE (fn),
 795      inline_init_test_initialization, decl_map);
 796 }
 797
 798 /* Avoid voluminous output for deep recursion of compound exprs.  */
 799
 800 static void
 801 dump_compound_expr (dump_info_p di, tree t)
 802 {
 803   int i;
 804
 805   for (i=0; i<2; i++)
 806     {
 807       switch (TREE_CODE (TREE_OPERAND (t, i)))
 808         {
 809         case COMPOUND_EXPR:
 810           dump_compound_expr (di, TREE_OPERAND (t, i));
 811           break;
 812
 813         default:
 814           dump_child ("expr", TREE_OPERAND (t, i));
 815         }
 816     }
 817 }
 818
 819 static bool
 820 java_dump_tree (void *dump_info, tree t)
 821 {
 822   enum tree_code code;
 823   dump_info_p di = (dump_info_p) dump_info;
 824
 825   /* Figure out what kind of node this is.  */
 826   code = TREE_CODE (t);
 827
 828   switch (code)
 829     {
 830     case FUNCTION_DECL:
 831       dump_child ("args", DECL_ARGUMENTS (t));
 832       if (DECL_EXTERNAL (t))
 833         dump_string (di, "undefined");
 834       if (TREE_PUBLIC (t))
 835         dump_string (di, "extern");
 836       else
 837         dump_string (di, "static");
 838       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
 839         dump_child ("inline body", DECL_SAVED_TREE (t));
 840       return true;
 841
 842     case RETURN_EXPR:
 843       dump_child ("expr", TREE_OPERAND (t, 0));
 844       return true;
 845
 846     case GOTO_EXPR:
 847       dump_child ("goto", TREE_OPERAND (t, 0));
 848       return true;
 849
 850     case LABEL_EXPR:
 851       dump_child ("label", TREE_OPERAND (t, 0));
 852       return true;
 853
 854     case BLOCK:
 855       if (BLOCK_EXPR_BODY (t))
 856         {
 857           tree local = BLOCK_VARS (t);
 858           while (local)
 859             {
 860               tree next = TREE_CHAIN (local);
 861               dump_child ("var", local);
 862               local = next;
 863             }
 864
 865           {
 866             tree block = BLOCK_EXPR_BODY (t);
 867             dump_child ("body", block);
 868             block = TREE_CHAIN (block);
 869           }
 870         }
 871       return true;
 872
 873     case COMPOUND_EXPR:
 874       if (!dump_flag (di, TDF_SLIM, t))
 875         return false;
 876       dump_compound_expr (di, t);
 877       return true;
 878
 879     default:
 880       break;
 881     }
 882   return false;
 883 }
 884
 885 /* Java calls can't, in general, be sibcalls because we need an
 886    accurate stack trace in order to guarantee correct operation of
 887    methods such as Class.forName(String) and
 888    SecurityManager.getClassContext().  */
 889
 890 static bool
 891 java_decl_ok_for_sibcall (const_tree decl)
 892 {
 893   return (decl != NULL && DECL_CONTEXT (decl) == output_class
 894           && !DECL_UNINLINABLE (decl));
 895 }
 896
 897 static enum classify_record
 898 java_classify_record (tree type)
 899 {
 900   if (! CLASS_P (type))
 901     return RECORD_IS_STRUCT;
 902
 903   if (CLASS_INTERFACE (TYPE_NAME (type)))
 904     return RECORD_IS_INTERFACE;
 905
 906   return RECORD_IS_CLASS;
 907 }
 908
 909 static GTY(()) tree java_eh_personality_decl;
 910
 911 static tree
 912 java_eh_personality (void)
 913 {
 914   if (!java_eh_personality_decl)
 915     java_eh_personality_decl = build_personality_function ("gcj");
 916   return java_eh_personality_decl;
 917 }
 918
 919 #include "gt-java-lang.h"