gcc/java/decl.c

   1 /* Process declarations and variables for the GNU compiler for the
   2    Java(TM) language.
   3    Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC 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 GNU CC 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 GNU CC; 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 "tree.h"
  31 #include "toplev.h"
  32 #include "flags.h"
  33 #include "java-tree.h"
  34 #include "jcf.h"
  35 #include "toplev.h"
  36 #include "function.h"
  37 #include "except.h"
  38 #include "defaults.h"
  39 #include "java-except.h"
  40
  41 #if defined (DEBUG_JAVA_BINDING_LEVELS)
  42 extern void indent PROTO((void));
  43 #endif
  44
  45 static tree push_jvm_slot PARAMS ((int, tree));
  46 static tree lookup_name_current_level PARAMS ((tree));
  47 static tree push_promoted_type PARAMS ((const char *, tree));
  48 static struct binding_level *make_binding_level PARAMS ((void));
  49 static boolean emit_init_test_initialization PARAMS ((struct hash_entry *,
  50                                                       hash_table_key));
  51
  52 /* Set to non-zero value in order to emit class initilization code
  53    before static field references.  */
  54 extern int always_initialize_class_p;
  55
  56 #ifndef INT_TYPE_SIZE
  57 #define INT_TYPE_SIZE BITS_PER_WORD
  58 #endif
  59
  60 /* The DECL_MAP is a mapping from (index, type) to a decl node.
  61    If index < max_locals, it is the index of a local variable.
  62    if index >= max_locals, then index-max_locals is a stack slot.
  63    The DECL_MAP mapping is represented as a TREE_VEC whose elements
  64    are a list of decls (VAR_DECL or PARM_DECL) chained by
  65    DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
  66    we search the chain for a decl with a matching TREE_TYPE. */
  67
  68 tree decl_map;
  69
  70 /* A list of local variables VAR_DECLs for this method that we have seen
  71    debug information, but we have not reached their starting (byte) PC yet. */
  72
  73 tree pending_local_decls = NULL_TREE;
  74
  75 /* Push a local variable or stack slot into the decl_map,
  76    and assign it an rtl. */
  77
  78 #if defined(DEBUG_JAVA_BINDING_LEVELS)
  79 int binding_depth = 0;
  80 int is_class_level = 0;
  81 int current_pc;
  82
  83 void
  84 indent ()
  85 {
  86   register unsigned i;
  87
  88   for (i = 0; i < binding_depth*2; i++)
  89     putc (' ', stderr);
  90 }
  91 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
  92
  93 static tree
  94 push_jvm_slot (index, decl)
  95      int index;
  96      tree decl;
  97 {
  98   struct rtx_def *rtl = NULL;
  99   tree type = TREE_TYPE (decl);
 100   tree tmp;
 101
 102   DECL_CONTEXT (decl) = current_function_decl;
 103   layout_decl (decl, 0);
 104
 105   /* See if we have an appropriate rtl (i.e. same mode) at this index.
 106      If so, we must use it. */
 107   tmp = TREE_VEC_ELT (decl_map, index);
 108   while (tmp != NULL_TREE)
 109     {
 110       if (TYPE_MODE (type) == TYPE_MODE (TREE_TYPE (tmp)))
 111         rtl = DECL_RTL (tmp);
 112       if (rtl != NULL)
 113         break;
 114      tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
 115     }
 116   if (rtl != NULL)
 117     DECL_RTL (decl) = rtl;
 118   else
 119     {
 120       if (index >= DECL_MAX_LOCALS (current_function_decl))
 121         DECL_REGISTER (decl) = 1;
 122       expand_decl (decl);
 123     }
 124
 125   /* Now link the decl into the decl_map. */
 126   if (DECL_LANG_SPECIFIC (decl) == NULL)
 127     {
 128       DECL_LANG_SPECIFIC (decl)
 129         = (struct lang_decl *) permalloc (sizeof (struct lang_decl_var));
 130       DECL_LOCAL_START_PC (decl) = 0;
 131       DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
 132       DECL_LOCAL_SLOT_NUMBER (decl) = index;
 133     }
 134   DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
 135   TREE_VEC_ELT (decl_map, index) = decl;
 136   return decl;
 137 }
 138
 139 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
 140    that is valid at PC (or -1 if any pc).
 141    If there is no existing matching decl, allocate one.  */
 142
 143 tree
 144 find_local_variable (index, type, pc)
 145      int index;
 146      tree type;
 147      int pc;
 148 {
 149   tree decl = TREE_VEC_ELT (decl_map, index);
 150   tree best = NULL_TREE;
 151
 152   while (decl != NULL_TREE)
 153     {
 154       int in_range;
 155       in_range = pc < 0
 156         || (pc >= DECL_LOCAL_START_PC (decl)
 157             && pc < DECL_LOCAL_END_PC (decl));
 158
 159       if ((TREE_TYPE (decl) == type
 160            || (TREE_CODE (TREE_TYPE (decl)) == TREE_CODE (type)
 161                && TYPE_PRECISION (TREE_TYPE (decl)) <= 32
 162                && TYPE_PRECISION (type) <= 32
 163                && TREE_CODE (type) != POINTER_TYPE)
 164            || (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
 165                && type == ptr_type_node))
 166            && in_range)
 167         {
 168           if (best == NULL_TREE
 169               || (TREE_TYPE (decl) == type && TREE_TYPE (best) != type)
 170               || DECL_LOCAL_START_PC (decl) > DECL_LOCAL_START_PC (best)
 171               || DECL_LOCAL_END_PC (decl) < DECL_LOCAL_START_PC (decl))
 172             best = decl;
 173         }
 174       decl = DECL_LOCAL_SLOT_CHAIN (decl);
 175     }
 176   if (best != NULL_TREE)
 177     return best;
 178   return push_jvm_slot (index, build_decl (VAR_DECL, NULL_TREE, type));
 179 }
 180
 181
 182 /* Same as find_local_index, except that INDEX is a stack index. */
 183
 184 tree
 185 find_stack_slot (index, type)
 186      int index;
 187      tree type;
 188 {
 189   return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
 190                               type, -1);
 191 }
 192
 193 struct binding_level
 194   {
 195     /* A chain of _DECL nodes for all variables, constants, functions,
 196      * and typedef types.  These are in the reverse of the order supplied.
 197      */
 198     tree names;
 199
 200     /* For each level, a list of shadowed outer-level local definitions
 201        to be restored when this level is popped.
 202        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 203        whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
 204     tree shadowed;
 205
 206     /* For each level (except not the global one),
 207        a chain of BLOCK nodes for all the levels
 208        that were entered and exited one level down.  */
 209     tree blocks;
 210
 211     /* The BLOCK node for this level, if one has been preallocated.
 212        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 213     tree this_block;
 214
 215     /* The binding level which this one is contained in (inherits from).  */
 216     struct binding_level *level_chain;
 217
 218     /* 1 means make a BLOCK for this level regardless of all else.
 219        2 for temporary binding contours created by the compiler.  */
 220     char keep;
 221
 222     /* Nonzero means make a BLOCK if this level has any subblocks.  */
 223     char keep_if_subblocks;
 224
 225     /* Nonzero if this level can safely have additional
 226        cleanup-needing variables added to it.  */
 227     char more_cleanups_ok;
 228     char have_cleanups;
 229
 230     /* The bytecode PC that marks the end of this level. */
 231     int end_pc;
 232     /* The bytecode PC that marks the start of this level. */
 233     int start_pc;
 234
 235 #if defined(DEBUG_JAVA_BINDING_LEVELS)
 236     /* Binding depth at which this level began.  */
 237     unsigned binding_depth;
 238 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
 239   };
 240
 241 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
 242
 243 /* The binding level currently in effect.  */
 244
 245 static struct binding_level *current_binding_level;
 246
 247 /* A chain of binding_level structures awaiting reuse.  */
 248
 249 static struct binding_level *free_binding_level;
 250
 251 /* The outermost binding level, for names of file scope.
 252    This is created when the compiler is started and exists
 253    through the entire run.  */
 254
 255 static struct binding_level *global_binding_level;
 256
 257 /* A PC value bigger than any PC value we may ever may encounter. */
 258
 259 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
 260
 261 /* Binding level structures are initialized by copying this one.  */
 262
 263 static struct binding_level clear_binding_level
 264   = {NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
 265        NULL_BINDING_LEVEL, 0, 0, 0, 0, LARGEST_PC, 0};
 266
 267 #if 0
 268 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 269    that have names.  Here so we can clear out their names' definitions
 270    at the end of the function.  */
 271
 272 static tree named_labels;
 273
 274 /* A list of LABEL_DECLs from outer contexts that are currently shadowed.  */
 275
 276 static tree shadowed_labels;
 277 #endif
 278
 279 int flag_traditional;
 280
 281 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 282
 283 static int keep_next_level_flag;
 284
 285 /* Nonzero means make a BLOCK for the next level pushed
 286    if it has subblocks.  */
 287
 288 static int keep_next_if_subblocks;
 289
 290 tree object_type_node;
 291 tree unqualified_object_id_node;
 292 tree object_ptr_type_node;
 293 tree string_type_node;
 294 tree string_ptr_type_node;
 295 tree throwable_type_node;
 296 tree runtime_exception_type_node;
 297 tree error_exception_type_node;
 298 tree *predef_filenames;
 299 int  predef_filenames_size;
 300
 301 tree boolean_type_node;
 302
 303 tree return_address_type_node;
 304
 305 tree byte_type_node;
 306 tree short_type_node;
 307 tree int_type_node;
 308 tree long_type_node;
 309
 310 tree promoted_byte_type_node;
 311 tree promoted_short_type_node;
 312 tree promoted_char_type_node;
 313 tree promoted_boolean_type_node;
 314
 315 tree unsigned_byte_type_node;
 316 tree unsigned_short_type_node;
 317 tree unsigned_int_type_node;
 318 tree unsigned_long_type_node;
 319
 320 /* The type for struct methodtable. */
 321 tree methodtable_type;
 322 tree methodtable_ptr_type;
 323
 324 tree utf8const_type;
 325 tree utf8const_ptr_type;
 326 tree class_type_node;
 327 tree class_ptr_type;
 328 tree field_type_node;
 329 tree field_ptr_type_node;
 330 tree field_info_union_node;
 331 tree jexception_type;
 332 tree jexception_ptr_type;
 333 tree lineNumberEntry_type;
 334 tree lineNumbers_type;
 335 tree constants_type_node;
 336 tree dtable_type;
 337 tree dtable_ptr_type;
 338 tree method_type_node;
 339 tree method_ptr_type_node;
 340 tree nativecode_ptr_array_type_node;
 341 tree one_elt_array_domain_type;
 342 tree access_flags_type_node;
 343 tree class_dtable_decl;
 344
 345 /* Expressions that are constants with value zero, of types
 346    `long', `float' and `double'.  */
 347 tree long_zero_node;
 348 tree float_zero_node;
 349 tree double_zero_node;
 350
 351 tree empty_stmt_node;
 352
 353 /* Nodes for boolean constants TRUE and FALSE. */
 354 tree boolean_true_node;
 355 tree boolean_false_node;
 356
 357 tree TYPE_identifier_node;
 358 tree init_identifier_node;
 359 tree clinit_identifier_node;
 360 tree finit_identifier_node;
 361 tree void_signature_node;
 362 tree length_identifier_node;
 363 tree this_identifier_node;
 364 tree super_identifier_node;
 365 tree continue_identifier_node;
 366 tree access0_identifier_node;   /* 1.1 */
 367 tree end_params_node;
 368
 369 /* References to internal libjava functions we use. */
 370 tree alloc_object_node;
 371 tree soft_instanceof_node;
 372 tree soft_checkcast_node;
 373 tree soft_initclass_node;
 374 tree soft_newarray_node;
 375 tree soft_anewarray_node;
 376 tree soft_multianewarray_node;
 377 tree soft_badarrayindex_node;
 378 tree soft_nullpointer_node;
 379 tree throw_node [2];
 380 tree soft_checkarraystore_node;
 381 tree soft_monitorenter_node;
 382 tree soft_monitorexit_node;
 383 tree soft_lookupinterfacemethod_node;
 384 tree soft_lookupjnimethod_node;
 385 tree soft_getjnienvnewframe_node;
 386 tree soft_jnipopsystemframe_node;
 387 tree soft_fmod_node;
 388 tree soft_exceptioninfo_call_node;
 389 tree soft_idiv_node;
 390 tree soft_irem_node;
 391 tree soft_ldiv_node;
 392 tree soft_lrem_node;
 393
 394 /* Build (and pushdecl) a "promoted type" for all standard
 395    types shorter than int.  */
 396
 397 static tree
 398 push_promoted_type (name, actual_type)
 399      const char *name;
 400      tree actual_type;
 401 {
 402   tree type = make_node (TREE_CODE (actual_type));
 403 #if 1
 404   tree in_min = TYPE_MIN_VALUE (int_type_node);
 405   tree in_max = TYPE_MAX_VALUE (int_type_node);
 406 #else
 407   tree in_min = TYPE_MIN_VALUE (actual_type);
 408   tree in_max = TYPE_MAX_VALUE (actual_type);
 409 #endif
 410   TYPE_MIN_VALUE (type) = copy_node (in_min);
 411   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
 412   TYPE_MAX_VALUE (type) = copy_node (in_max);
 413   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
 414   TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
 415   layout_type (type);
 416   pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
 417   return type;
 418 }
 419
 420 /* Nodes for integer constants.  */
 421 tree integer_two_node;
 422 tree integer_four_node;
 423 tree integer_negative_one_node;
 424
 425 /* Return a definition for a builtin function named NAME and whose data type
 426    is TYPE.  TYPE should be a function type with argument types.
 427    FUNCTION_CODE tells later passes how to compile calls to this function.
 428    See tree.h for its possible values.
 429
 430    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
 431    the name to be called if we can't opencode the function.  */
 432
 433 tree
 434 builtin_function (name, type, function_code, class, library_name)
 435      const char *name;
 436      tree type;
 437      int function_code;
 438      enum built_in_class class;
 439      const char *library_name;
 440 {
 441   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
 442   DECL_EXTERNAL (decl) = 1;
 443   TREE_PUBLIC (decl) = 1;
 444   if (library_name)
 445     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
 446   make_decl_rtl (decl, NULL_PTR, 1);
 447   pushdecl (decl);
 448   DECL_BUILT_IN_CLASS (decl) = class;
 449   DECL_FUNCTION_CODE (decl) = function_code;
 450   return decl;
 451 }
 452
 453 void
 454 init_decl_processing ()
 455 {
 456   register tree endlink;
 457   tree field = NULL_TREE;
 458   tree t;
 459
 460   current_function_decl = NULL;
 461   current_binding_level = NULL_BINDING_LEVEL;
 462   free_binding_level = NULL_BINDING_LEVEL;
 463   pushlevel (0);        /* make the binding_level structure for global names */
 464   global_binding_level = current_binding_level;
 465
 466   /* The code here must be similar to build_common_tree_nodes{,_2} in
 467      tree.c, especially as to the order of initializing common nodes.  */
 468   error_mark_node = make_node (ERROR_MARK);
 469   TREE_TYPE (error_mark_node) = error_mark_node;
 470
 471   /* Create sizetype first - needed for other types. */
 472   initialize_sizetypes ();
 473
 474   byte_type_node = make_signed_type (8);
 475   pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"), byte_type_node));
 476   short_type_node = make_signed_type (16);
 477   pushdecl (build_decl (TYPE_DECL, get_identifier ("short"), short_type_node));
 478   int_type_node = make_signed_type (32);
 479   pushdecl (build_decl (TYPE_DECL, get_identifier ("int"), int_type_node));
 480   long_type_node = make_signed_type (64);
 481   pushdecl (build_decl (TYPE_DECL, get_identifier ("long"), long_type_node));
 482
 483   unsigned_byte_type_node = make_unsigned_type (8);
 484   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned byte"),
 485                         unsigned_byte_type_node));
 486   unsigned_short_type_node = make_unsigned_type (16);
 487   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned short"),
 488                         unsigned_short_type_node));
 489   unsigned_int_type_node = make_unsigned_type (32);
 490   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
 491                         unsigned_int_type_node));
 492   unsigned_long_type_node = make_unsigned_type (64);
 493   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned long"),
 494                         unsigned_long_type_node));
 495
 496   set_sizetype (make_unsigned_type (POINTER_SIZE));
 497
 498   /* Define these next since types below may used them.  */
 499   integer_type_node = type_for_size (INT_TYPE_SIZE, 0);
 500   integer_zero_node = build_int_2 (0, 0);
 501   integer_one_node = build_int_2 (1, 0);
 502   integer_two_node = build_int_2 (2, 0);
 503   integer_four_node = build_int_2 (4, 0);
 504   integer_negative_one_node = build_int_2 (-1, 0);
 505
 506   size_zero_node = size_int (0);
 507   size_one_node = size_int (1);
 508   bitsize_zero_node = bitsize_int (0);
 509   bitsize_one_node = bitsize_int (1);
 510   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
 511
 512   long_zero_node = build_int_2 (0, 0);
 513   TREE_TYPE (long_zero_node) = long_type_node;
 514
 515   void_type_node = make_node (VOID_TYPE);
 516   pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
 517   layout_type (void_type_node); /* Uses size_zero_node */
 518   ptr_type_node = build_pointer_type (void_type_node);
 519   t = make_node (VOID_TYPE);
 520   layout_type (t); /* Uses size_zero_node */
 521   return_address_type_node = build_pointer_type (t);
 522
 523   null_pointer_node = build_int_2 (0, 0);
 524   TREE_TYPE (null_pointer_node) = ptr_type_node;
 525
 526   /* Used by the parser to represent empty statements and blocks. */
 527   empty_stmt_node = build1 (NOP_EXPR, void_type_node, size_zero_node);
 528   CAN_COMPLETE_NORMALLY (empty_stmt_node) = 1;
 529
 530 #if 0
 531   /* Make a type to be the domain of a few array types
 532      whose domains don't really matter.
 533      200 is small enough that it always fits in size_t
 534      and large enough that it can hold most function names for the
 535      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
 536   short_array_type_node = build_prim_array_type (short_type_node, 200);
 537 #endif
 538   char_type_node = make_node (CHAR_TYPE);
 539   TYPE_PRECISION (char_type_node) = 16;
 540   fixup_unsigned_type (char_type_node);
 541   pushdecl (build_decl (TYPE_DECL, get_identifier ("char"), char_type_node));
 542
 543   boolean_type_node = make_node (BOOLEAN_TYPE);
 544   TYPE_PRECISION (boolean_type_node) = 1;
 545   fixup_unsigned_type (boolean_type_node);
 546   pushdecl (build_decl (TYPE_DECL, get_identifier ("boolean"),
 547                         boolean_type_node));
 548   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
 549   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
 550
 551   promoted_byte_type_node
 552     = push_promoted_type ("promoted_byte", byte_type_node);
 553   promoted_short_type_node
 554     = push_promoted_type ("promoted_short", short_type_node);
 555   promoted_char_type_node
 556     = push_promoted_type ("promoted_char", char_type_node);
 557   promoted_boolean_type_node
 558     = push_promoted_type ("promoted_boolean", boolean_type_node);
 559
 560   float_type_node = make_node (REAL_TYPE);
 561   TYPE_PRECISION (float_type_node) = 32;
 562   pushdecl (build_decl (TYPE_DECL, get_identifier ("float"),
 563                         float_type_node));
 564   layout_type (float_type_node);
 565
 566   double_type_node = make_node (REAL_TYPE);
 567   TYPE_PRECISION (double_type_node) = 64;
 568   pushdecl (build_decl (TYPE_DECL, get_identifier ("double"),
 569                         double_type_node));
 570   layout_type (double_type_node);
 571
 572   float_zero_node = build_real (float_type_node, dconst0);
 573   double_zero_node = build_real (double_type_node, dconst0);
 574
 575   /* As your adding items here, please update the code right after
 576      this section, so that the filename containing the source code of
 577      the pre-defined class gets registered correctly. */
 578   unqualified_object_id_node = get_identifier ("Object");
 579   object_type_node = lookup_class (get_identifier ("java.lang.Object"));
 580   object_ptr_type_node = promote_type (object_type_node);
 581   string_type_node = lookup_class (get_identifier ("java.lang.String"));
 582   string_ptr_type_node = promote_type (string_type_node);
 583   class_type_node = lookup_class (get_identifier ("java.lang.Class"));
 584   throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
 585   runtime_exception_type_node =
 586     lookup_class (get_identifier ("java.lang.RuntimeException"));
 587   error_exception_type_node =
 588     lookup_class (get_identifier ("java.lang.Error"));
 589
 590   /* This section has to be updated as items are added to the previous
 591      section. */
 592   predef_filenames_size = 6;
 593   predef_filenames = (tree *)xmalloc (predef_filenames_size * sizeof (tree));
 594   predef_filenames [0] = get_identifier ("java/lang/Class.java");
 595   predef_filenames [1] = get_identifier ("java/lang/Error.java");
 596   predef_filenames [2] = get_identifier ("java/lang/Object.java");
 597   predef_filenames [3] = get_identifier ("java/lang/RuntimeException.java");
 598   predef_filenames [4] = get_identifier ("java/lang/String.java");
 599   predef_filenames [5] = get_identifier ("java/lang/Throwable.java");
 600
 601   methodtable_type = make_node (RECORD_TYPE);
 602   layout_type (methodtable_type);
 603   build_decl (TYPE_DECL, get_identifier ("methodtable"), methodtable_type);
 604   methodtable_ptr_type = build_pointer_type (methodtable_type);
 605
 606   TYPE_identifier_node = get_identifier ("TYPE");
 607   init_identifier_node = get_identifier ("<init>");
 608   clinit_identifier_node = get_identifier ("<clinit>");
 609   finit_identifier_node = get_identifier ("$finit$");
 610   void_signature_node = get_identifier ("()V");
 611   length_identifier_node = get_identifier ("length");
 612   this_identifier_node = get_identifier ("this");
 613   super_identifier_node = get_identifier ("super");
 614   continue_identifier_node = get_identifier ("continue");
 615   access0_identifier_node = get_identifier ("access$0");
 616
 617   /* for lack of a better place to put this stub call */
 618   init_expr_processing();
 619
 620   utf8const_type = make_node (RECORD_TYPE);
 621   PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
 622   PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
 623   FINISH_RECORD (utf8const_type);
 624   utf8const_ptr_type = build_pointer_type (utf8const_type);
 625
 626   constants_type_node = make_node (RECORD_TYPE);
 627   PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node);
 628   PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
 629   PUSH_FIELD (constants_type_node, field, "data", ptr_type_node);
 630   FINISH_RECORD (constants_type_node);
 631   build_decl (TYPE_DECL, get_identifier ("constants"), constants_type_node);
 632
 633   access_flags_type_node = unsigned_short_type_node;
 634
 635   dtable_type = make_node (RECORD_TYPE);
 636   dtable_ptr_type = build_pointer_type (dtable_type);
 637
 638   PUSH_FIELD (object_type_node, field, "vtable", dtable_ptr_type);
 639   /* This isn't exactly true, but it is what we have in the source.
 640      There is an unresolved issue here, which is whether the vtable
 641      should be marked by the GC.  */
 642   if (! flag_hash_synchronization)
 643     PUSH_FIELD (object_type_node, field, "sync_info",
 644                 build_pointer_type (object_type_node));
 645   for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
 646     FIELD_PRIVATE (t) = 1;
 647   FINISH_RECORD (object_type_node);
 648
 649   class_dtable_decl = build_dtable_decl (class_type_node);
 650   TREE_STATIC (class_dtable_decl) = 1;
 651   DECL_ARTIFICIAL (class_dtable_decl) = 1;
 652   DECL_IGNORED_P (class_dtable_decl) = 1;
 653   rest_of_decl_compilation (class_dtable_decl, (char*) 0, 1, 0);
 654
 655   field_type_node = make_node (RECORD_TYPE);
 656   field_ptr_type_node = build_pointer_type (field_type_node);
 657   method_type_node = make_node (RECORD_TYPE);
 658   method_ptr_type_node = build_pointer_type (method_type_node);
 659
 660   set_super_info (0, class_type_node, object_type_node, 0);
 661   set_super_info (0, string_type_node, object_type_node, 0);
 662   class_ptr_type = build_pointer_type (class_type_node);
 663
 664   PUSH_FIELD (class_type_node, field, "next", class_ptr_type);
 665   PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type);
 666   PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node);
 667   PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type);
 668   PUSH_FIELD (class_type_node, field, "constants", constants_type_node);
 669   PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node);
 670   PUSH_FIELD (class_type_node, field, "method_count", short_type_node);
 671   PUSH_FIELD (class_type_node, field, "vtable_method_count", short_type_node);
 672   PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node);
 673   PUSH_FIELD (class_type_node, field, "size_in_bytes", int_type_node);
 674   PUSH_FIELD (class_type_node, field, "field_count", short_type_node);
 675   PUSH_FIELD (class_type_node, field, "static_field_count", short_type_node);
 676   PUSH_FIELD (class_type_node, field, "vtable", dtable_ptr_type);
 677   PUSH_FIELD (class_type_node, field, "interfaces",
 678               build_pointer_type (class_ptr_type));
 679   PUSH_FIELD (class_type_node, field, "loader", ptr_type_node);
 680   PUSH_FIELD (class_type_node, field, "interface_count", short_type_node);
 681   PUSH_FIELD (class_type_node, field, "state", byte_type_node);
 682   PUSH_FIELD (class_type_node, field, "thread", ptr_type_node);
 683   PUSH_FIELD (class_type_node, field, "depth", short_type_node);
 684   PUSH_FIELD (class_type_node, field, "ancestors", ptr_type_node);
 685   PUSH_FIELD (class_type_node, field, "idt", ptr_type_node);
 686   for (t = TYPE_FIELDS (class_type_node);  t != NULL_TREE;  t = TREE_CHAIN (t))
 687     FIELD_PRIVATE (t) = 1;
 688   push_super_field (class_type_node, object_type_node);
 689   FINISH_RECORD (class_type_node);
 690   build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node);
 691
 692   field_info_union_node = make_node (UNION_TYPE);
 693   PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node);
 694   PUSH_FIELD (field_info_union_node, field, "addr", ptr_type_node);
 695 #if 0
 696   PUSH_FIELD (field_info_union_node, field, "idx", unsigned_short_type_node);
 697 #endif
 698   layout_type (field_info_union_node);
 699
 700   PUSH_FIELD (field_type_node, field, "name", utf8const_ptr_type);
 701   PUSH_FIELD (field_type_node, field, "type", class_ptr_type);
 702   PUSH_FIELD (field_type_node, field, "accflags", access_flags_type_node);
 703   PUSH_FIELD (field_type_node, field, "bsize", unsigned_short_type_node);
 704   PUSH_FIELD (field_type_node, field, "info", field_info_union_node);
 705   FINISH_RECORD (field_type_node);
 706   CLASS_LOADED_P (field_type_node) = 1;
 707   build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node);
 708
 709   one_elt_array_domain_type = build_index_type (integer_one_node);
 710   nativecode_ptr_array_type_node
 711     = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
 712
 713   PUSH_FIELD (dtable_type, field, "class", class_ptr_type);
 714   PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node);
 715   FINISH_RECORD (dtable_type);
 716   build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
 717
 718 #define jint_type int_type_node
 719 #define jint_ptr_type ptr_type_node
 720
 721   jexception_type = make_node (RECORD_TYPE);
 722   PUSH_FIELD (jexception_type, field, "start_pc", ptr_type_node);
 723   PUSH_FIELD (jexception_type, field, "end_pc", ptr_type_node);
 724   PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node);
 725   PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type);
 726   FINISH_RECORD (jexception_type);
 727   build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node);
 728   jexception_ptr_type = build_pointer_type (jexception_type);
 729
 730   lineNumberEntry_type = make_node (RECORD_TYPE);
 731   PUSH_FIELD (lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
 732   PUSH_FIELD (lineNumberEntry_type, field, "start_pc", ptr_type_node);
 733   FINISH_RECORD (lineNumberEntry_type);
 734
 735   lineNumbers_type = make_node (RECORD_TYPE);
 736   PUSH_FIELD (lineNumbers_type, field, "length", unsigned_int_type_node);
 737   FINISH_RECORD (lineNumbers_type);
 738
 739 #define instn_ptr_type_node ptr_type_node       /* XXX JH */
 740
 741 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
 742
 743   PUSH_FIELD (method_type_node, field, "name", utf8const_ptr_type);
 744   PUSH_FIELD (method_type_node, field, "signature", utf8const_ptr_type);
 745   PUSH_FIELD (method_type_node, field, "accflags", access_flags_type_node);
 746   PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node);
 747   FINISH_RECORD (method_type_node);
 748   CLASS_LOADED_P (method_type_node) = 1;
 749   build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node);
 750
 751   endlink = end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
 752
 753   t = tree_cons (NULL_TREE, class_ptr_type,
 754                  tree_cons (NULL_TREE, int_type_node, endlink));
 755   alloc_object_node = builtin_function ("_Jv_AllocObject",
 756                                         build_function_type (ptr_type_node, t),
 757                                         0, NOT_BUILT_IN, NULL_PTR);
 758   DECL_IS_MALLOC (alloc_object_node) = 1;
 759
 760   t = tree_cons (NULL_TREE, ptr_type_node, endlink);
 761   soft_initclass_node = builtin_function ("_Jv_InitClass",
 762                                           build_function_type (void_type_node,
 763                                                                t),
 764                                           0, NOT_BUILT_IN,
 765                                           NULL_PTR);
 766   throw_node[0] = builtin_function ("_Jv_Throw",
 767                                     build_function_type (ptr_type_node, t),
 768                                     0, NOT_BUILT_IN, NULL_PTR);
 769   /* Mark throw_nodes as `noreturn' functions with side effects.  */
 770   TREE_THIS_VOLATILE (throw_node[0]) = 1;
 771   TREE_SIDE_EFFECTS (throw_node[0]) = 1;
 772   t = tree_cons (NULL_TREE, ptr_type_node, endlink);
 773   throw_node[1] = builtin_function ("_Jv_Sjlj_Throw",
 774                                     build_function_type (ptr_type_node, t),
 775                                     0, NOT_BUILT_IN, NULL_PTR);
 776   TREE_THIS_VOLATILE (throw_node[1]) = 1;
 777   TREE_SIDE_EFFECTS (throw_node[1]) = 1;
 778   t = build_function_type (int_type_node, endlink);
 779   soft_monitorenter_node
 780     = builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN,
 781                         NULL_PTR);
 782   soft_monitorexit_node
 783     = builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN,
 784                         NULL_PTR);
 785
 786   t = tree_cons (NULL_TREE, int_type_node,
 787                  tree_cons (NULL_TREE, int_type_node, endlink));
 788   soft_newarray_node
 789       = builtin_function ("_Jv_NewArray",
 790                           build_function_type(ptr_type_node, t),
 791                           0, NOT_BUILT_IN, NULL_PTR);
 792   DECL_IS_MALLOC (soft_newarray_node) = 1;
 793
 794   t = tree_cons (NULL_TREE, int_type_node,
 795                  tree_cons (NULL_TREE, class_ptr_type,
 796                             tree_cons (NULL_TREE, object_ptr_type_node, endlink)));
 797   soft_anewarray_node
 798       = builtin_function ("_Jv_NewObjectArray",
 799                           build_function_type (ptr_type_node, t),
 800                           0, NOT_BUILT_IN, NULL_PTR);
 801   DECL_IS_MALLOC (soft_anewarray_node) = 1;
 802
 803   t = tree_cons (NULL_TREE, ptr_type_node,
 804                  tree_cons (NULL_TREE, int_type_node, endlink));
 805   soft_multianewarray_node
 806       = builtin_function ("_Jv_NewMultiArray",
 807                           build_function_type (ptr_type_node, t),
 808                           0, NOT_BUILT_IN, NULL_PTR);
 809   DECL_IS_MALLOC (soft_multianewarray_node) = 1;
 810
 811   t = build_function_type (void_type_node,
 812                            tree_cons (NULL_TREE, int_type_node, endlink));
 813   soft_badarrayindex_node
 814       = builtin_function ("_Jv_ThrowBadArrayIndex", t,
 815                           0, NOT_BUILT_IN, NULL_PTR);
 816   /* Mark soft_badarrayindex_node as a `noreturn' function with side
 817      effects.  */
 818   TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
 819   TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
 820
 821   soft_nullpointer_node
 822     = builtin_function ("_Jv_ThrowNullPointerException",
 823                         build_function_type (void_type_node, endlink),
 824                         0, NOT_BUILT_IN, NULL_PTR);
 825   /* Mark soft_nullpointer_node as a `noreturn' function with side
 826      effects.  */
 827   TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
 828   TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
 829
 830   t = tree_cons (NULL_TREE, class_ptr_type,
 831                  tree_cons (NULL_TREE, object_ptr_type_node, endlink));
 832   soft_checkcast_node
 833     = builtin_function ("_Jv_CheckCast",
 834                         build_function_type (ptr_type_node, t),
 835                         0, NOT_BUILT_IN, NULL_PTR);
 836   t = tree_cons (NULL_TREE, object_ptr_type_node,
 837                  tree_cons (NULL_TREE, class_ptr_type, endlink));
 838   soft_instanceof_node
 839     = builtin_function ("_Jv_IsInstanceOf",
 840                         build_function_type (boolean_type_node, t),
 841                         0, NOT_BUILT_IN, NULL_PTR);
 842   t = tree_cons (NULL_TREE, object_ptr_type_node,
 843                  tree_cons (NULL_TREE, object_ptr_type_node, endlink));
 844   soft_checkarraystore_node
 845     = builtin_function ("_Jv_CheckArrayStore",
 846                         build_function_type (void_type_node, t),
 847                         0, NOT_BUILT_IN, NULL_PTR);
 848   t = tree_cons (NULL_TREE, ptr_type_node,
 849                  tree_cons (NULL_TREE, ptr_type_node,
 850                             tree_cons (NULL_TREE, int_type_node, endlink)));
 851   soft_lookupinterfacemethod_node
 852     = builtin_function ("_Jv_LookupInterfaceMethodIdx",
 853                         build_function_type (ptr_type_node, t),
 854                         0, NOT_BUILT_IN, NULL_PTR);
 855
 856   t = tree_cons (NULL_TREE, object_ptr_type_node,
 857                  tree_cons (NULL_TREE, ptr_type_node,
 858                             tree_cons (NULL_TREE, ptr_type_node, endlink)));
 859   soft_lookupjnimethod_node
 860     = builtin_function ("_Jv_LookupJNIMethod",
 861                         build_function_type (ptr_type_node, t),
 862                         0, NOT_BUILT_IN, NULL_PTR);
 863   t = tree_cons (NULL_TREE, ptr_type_node, endlink);
 864   soft_getjnienvnewframe_node
 865     = builtin_function ("_Jv_GetJNIEnvNewFrame",
 866                         build_function_type (ptr_type_node, t),
 867                         0, NOT_BUILT_IN, NULL_PTR);
 868   soft_jnipopsystemframe_node
 869     = builtin_function ("_Jv_JNI_PopSystemFrame",
 870                         build_function_type (ptr_type_node, t),
 871                         0, NOT_BUILT_IN, NULL_PTR);
 872
 873   t = tree_cons (NULL_TREE, double_type_node,
 874                  tree_cons (NULL_TREE, double_type_node, endlink));
 875   soft_fmod_node
 876     = builtin_function ("__builtin_fmod",
 877                         build_function_type (double_type_node, t),
 878                         BUILT_IN_FMOD, BUILT_IN_NORMAL, "fmod");
 879
 880   soft_exceptioninfo_call_node
 881     = build (CALL_EXPR,
 882              ptr_type_node,
 883              build_address_of
 884                (builtin_function ("_Jv_exception_info",
 885                                   build_function_type (ptr_type_node, endlink),
 886                                   0, NOT_BUILT_IN, NULL_PTR)),
 887              NULL_TREE, NULL_TREE);
 888   TREE_SIDE_EFFECTS (soft_exceptioninfo_call_node) = 1;
 889 #if 0
 890   t = tree_cons (NULL_TREE, float_type_node,
 891                  tree_cons (NULL_TREE, float_type_node, endlink));
 892   soft_fmodf_node
 893     = builtin_function ("__builtin_fmodf",
 894                         build_function_type (float_type_node, t),
 895                         BUILT_IN_FMOD, BUILT_IN_NORMAL, "fmodf");
 896 #endif
 897
 898   soft_idiv_node
 899     = builtin_function ("_Jv_divI",
 900                         build_function_type (int_type_node, t),
 901                         0, NOT_BUILT_IN, NULL_PTR);
 902
 903   soft_irem_node
 904     = builtin_function ("_Jv_remI",
 905                         build_function_type (int_type_node, t),
 906                         0, NOT_BUILT_IN, NULL_PTR);
 907
 908   soft_ldiv_node
 909     = builtin_function ("_Jv_divJ",
 910                         build_function_type (long_type_node, t),
 911                         0, NOT_BUILT_IN, NULL_PTR);
 912
 913   soft_lrem_node
 914     = builtin_function ("_Jv_remJ",
 915                         build_function_type (long_type_node, t),
 916                         0, NOT_BUILT_IN, NULL_PTR);
 917
 918   init_class_processing ();
 919 }
 920
 921
 922 /* Look up NAME in the current binding level and its superiors
 923    in the namespace of variables, functions and typedefs.
 924    Return a ..._DECL node of some kind representing its definition,
 925    or return 0 if it is undefined.  */
 926
 927 tree
 928 lookup_name (name)
 929      tree name;
 930 {
 931   register tree val;
 932   if (current_binding_level != global_binding_level
 933       && IDENTIFIER_LOCAL_VALUE (name))
 934     val = IDENTIFIER_LOCAL_VALUE (name);
 935   else
 936     val = IDENTIFIER_GLOBAL_VALUE (name);
 937   return val;
 938 }
 939
 940 /* Similar to `lookup_name' but look only at current binding level and
 941    the previous one if its the parameter level.  */
 942
 943 static tree
 944 lookup_name_current_level (name)
 945      tree name;
 946 {
 947   register tree t;
 948
 949   if (current_binding_level == global_binding_level)
 950     return IDENTIFIER_GLOBAL_VALUE (name);
 951
 952   if (IDENTIFIER_LOCAL_VALUE (name) == 0)
 953     return 0;
 954
 955   for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
 956     if (DECL_NAME (t) == name)
 957       break;
 958
 959   return t;
 960 }
 961
 962 /* Use a binding level to record a labeled block declaration */
 963
 964 void
 965 push_labeled_block (lb)
 966     tree lb;
 967 {
 968   register tree name = DECL_NAME (LABELED_BLOCK_LABEL (lb));
 969   register struct binding_level *b = current_binding_level;
 970   tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
 971   if (oldlocal != 0)
 972       b->shadowed = tree_cons (name, oldlocal, b->shadowed);
 973   TREE_CHAIN (lb) = b->names;
 974   b->names = lb;
 975   IDENTIFIER_LOCAL_VALUE (name) = lb;
 976 }
 977
 978 /* Pop the current binding level, reinstalling values for the previous
 979    labeled block */
 980
 981 void
 982 pop_labeled_block ()
 983 {
 984   struct binding_level *b = current_binding_level;
 985   tree label =  b->names;
 986   IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label))) =
 987     NULL_TREE;
 988   if (b->shadowed)
 989     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b->shadowed)) =
 990       TREE_VALUE (b->shadowed);
 991
 992   /* Pop the current level, and free the structure for reuse.  */
 993   current_binding_level = current_binding_level->level_chain;
 994   b->level_chain = free_binding_level;
 995   free_binding_level = b;
 996 }
 997
 998 /* Record a decl-node X as belonging to the current lexical scope.
 999    Check for errors (such as an incompatible declaration for the same
1000    name already seen in the same scope).
1001
1002    Returns either X or an old decl for the same name.
1003    If an old decl is returned, it may have been smashed
1004    to agree with what X says.  */
1005
1006 tree
1007 pushdecl (x)
1008      tree x;
1009 {
1010   register tree t;
1011   register tree name = DECL_NAME (x);
1012   register struct binding_level *b = current_binding_level;
1013
1014   if (TREE_CODE (x) != TYPE_DECL)
1015     DECL_CONTEXT (x) = current_function_decl;
1016   if (name)
1017     {
1018       const char *file;
1019       int line;
1020
1021       t = lookup_name_current_level (name);
1022       if (t != 0 && t == error_mark_node)
1023         /* error_mark_node is 0 for a while during initialization!  */
1024         {
1025           t = 0;
1026           error_with_decl (x, "`%s' used prior to declaration");
1027         }
1028
1029       if (t != 0)
1030         {
1031           file = DECL_SOURCE_FILE (t);
1032           line = DECL_SOURCE_LINE (t);
1033         }
1034
1035       /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1036          to point to the TYPE_DECL.
1037          Since Java does not have typedefs, a type can only have
1038          one (true) name, given by a class, interface, or builtin. */
1039       if (TREE_CODE (x) == TYPE_DECL
1040           && TYPE_NAME (TREE_TYPE (x)) == 0
1041           && TREE_TYPE (x) != error_mark_node)
1042         {
1043           TYPE_NAME (TREE_TYPE (x)) = x;
1044           TYPE_STUB_DECL (TREE_TYPE (x)) = x;
1045         }
1046
1047       /* This name is new in its binding level.
1048          Install the new declaration and return it.  */
1049       if (b == global_binding_level)
1050         {
1051           /* Install a global value.  */
1052
1053           IDENTIFIER_GLOBAL_VALUE (name) = x;
1054         }
1055       else
1056         {
1057           /* Here to install a non-global value.  */
1058           tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1059           IDENTIFIER_LOCAL_VALUE (name) = x;
1060
1061 #if 0
1062           /* Warn if shadowing an argument at the top level of the body.  */
1063           if (oldlocal != 0 && !DECL_EXTERNAL (x)
1064               /* This warning doesn't apply to the parms of a nested fcn.  */
1065               && ! current_binding_level->parm_flag
1066               /* Check that this is one level down from the parms.  */
1067               && current_binding_level->level_chain->parm_flag
1068               /* Check that the decl being shadowed
1069                  comes from the parm level, one level up.  */
1070               && chain_member (oldlocal, current_binding_level->level_chain->names))
1071             {
1072               if (TREE_CODE (oldlocal) == PARM_DECL)
1073                 pedwarn ("declaration of `%s' shadows a parameter",
1074                          IDENTIFIER_POINTER (name));
1075               else
1076                 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1077                          IDENTIFIER_POINTER (name));
1078             }
1079
1080           /* Maybe warn if shadowing something else.  */
1081           else if (warn_shadow && !DECL_EXTERNAL (x)
1082                    /* No shadow warnings for internally generated vars.  */
1083                    && DECL_SOURCE_LINE (x) != 0
1084                    /* No shadow warnings for vars made for inlining.  */
1085                    && ! DECL_FROM_INLINE (x))
1086             {
1087               const char *warnstring = 0;
1088
1089               if (TREE_CODE (x) == PARM_DECL
1090                   && current_binding_level->level_chain->parm_flag)
1091                 /* Don't warn about the parm names in function declarator
1092                    within a function declarator.
1093                    It would be nice to avoid warning in any function
1094                    declarator in a declaration, as opposed to a definition,
1095                    but there is no way to tell it's not a definition.  */
1096                 ;
1097               else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
1098                 warnstring = "declaration of `%s' shadows a parameter";
1099               else if (oldlocal != 0)
1100                 warnstring = "declaration of `%s' shadows previous local";
1101               else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
1102                        && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
1103                 warnstring = "declaration of `%s' shadows global declaration";
1104
1105               if (warnstring)
1106                 warning (warnstring, IDENTIFIER_POINTER (name));
1107             }
1108 #endif
1109
1110           /* If storing a local value, there may already be one (inherited).
1111              If so, record it for restoration when this binding level ends.  */
1112           if (oldlocal != 0)
1113             b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1114         }
1115     }
1116
1117   /* Put decls on list in reverse order.
1118      We will reverse them later if necessary.  */
1119   TREE_CHAIN (x) = b->names;
1120   b->names = x;
1121
1122   return x;
1123 }
1124
1125 void
1126 pushdecl_force_head (x)
1127      tree x;
1128 {
1129   current_binding_level->names = x;
1130 }
1131
1132 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
1133
1134 tree
1135 pushdecl_top_level (x)
1136      tree x;
1137 {
1138   register tree t;
1139   register struct binding_level *b = current_binding_level;
1140
1141   current_binding_level = global_binding_level;
1142   t = pushdecl (x);
1143   current_binding_level = b;
1144   return t;
1145 }
1146
1147 /* Nonzero if we are currently in the global binding level.  */
1148
1149 int
1150 global_bindings_p ()
1151 {
1152   return current_binding_level == global_binding_level;
1153 }
1154
1155 /* Return the list of declarations of the current level.
1156    Note that this list is in reverse order unless/until
1157    you nreverse it; and when you do nreverse it, you must
1158    store the result back using `storedecls' or you will lose.  */
1159
1160 tree
1161 getdecls ()
1162 {
1163   return current_binding_level->names;
1164 }
1165
1166 /* Create a new `struct binding_level'.  */
1167
1168 static struct binding_level *
1169 make_binding_level ()
1170 {
1171   /* NOSTRICT */
1172   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
1173 }
1174
1175 void
1176 pushlevel (unused)
1177   int unused ATTRIBUTE_UNUSED;
1178 {
1179   register struct binding_level *newlevel = NULL_BINDING_LEVEL;
1180
1181 #if 0
1182   /* If this is the top level of a function,
1183      just make sure that NAMED_LABELS is 0.  */
1184
1185   if (current_binding_level == global_binding_level)
1186     named_labels = 0;
1187 #endif
1188
1189   /* Reuse or create a struct for this binding level.  */
1190
1191   if (free_binding_level)
1192     {
1193       newlevel = free_binding_level;
1194       free_binding_level = free_binding_level->level_chain;
1195     }
1196   else
1197     {
1198       newlevel = make_binding_level ();
1199     }
1200
1201   /* Add this level to the front of the chain (stack) of levels that
1202      are active.  */
1203
1204   *newlevel = clear_binding_level;
1205   newlevel->level_chain = current_binding_level;
1206   current_binding_level = newlevel;
1207   newlevel->keep = keep_next_level_flag;
1208   keep_next_level_flag = 0;
1209   newlevel->keep_if_subblocks = keep_next_if_subblocks;
1210   keep_next_if_subblocks = 0;
1211 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1212   newlevel->binding_depth = binding_depth;
1213   indent ();
1214   fprintf (stderr, "push %s level 0x%08x pc %d\n",
1215            (is_class_level) ? "class" : "block", newlevel, current_pc);
1216   is_class_level = 0;
1217   binding_depth++;
1218 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1219 }
1220
1221 /* Exit a binding level.
1222    Pop the level off, and restore the state of the identifier-decl mappings
1223    that were in effect when this level was entered.
1224
1225    If KEEP is nonzero, this level had explicit declarations, so
1226    and create a "block" (a BLOCK node) for the level
1227    to record its declarations and subblocks for symbol table output.
1228
1229    If FUNCTIONBODY is nonzero, this level is the body of a function,
1230    so create a block as if KEEP were set and also clear out all
1231    label names.
1232
1233    If REVERSE is nonzero, reverse the order of decls before putting
1234    them into the BLOCK.  */
1235
1236 tree
1237 poplevel (keep, reverse, functionbody)
1238      int keep;
1239      int reverse;
1240      int functionbody;
1241 {
1242   register tree link;
1243   /* The chain of decls was accumulated in reverse order.
1244      Put it into forward order, just for cleanliness.  */
1245   tree decls;
1246   tree subblocks = current_binding_level->blocks;
1247   tree block = 0;
1248   tree decl;
1249   int block_previously_created;
1250
1251 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1252   binding_depth--;
1253   indent ();
1254   if (current_binding_level->end_pc != LARGEST_PC)
1255     fprintf (stderr, "pop  %s level 0x%08x pc %d (end pc %d)\n",
1256              (is_class_level) ? "class" : "block", current_binding_level, current_pc,
1257              current_binding_level->end_pc);
1258   else
1259     fprintf (stderr, "pop  %s level 0x%08x pc %d\n",
1260              (is_class_level) ? "class" : "block", current_binding_level, current_pc);
1261 #if 0
1262   if (is_class_level != (current_binding_level == class_binding_level))
1263     {
1264       indent ();
1265       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1266     }
1267   is_class_level = 0;
1268 #endif
1269 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1270
1271   keep |= current_binding_level->keep;
1272
1273   /* Get the decls in the order they were written.
1274      Usually current_binding_level->names is in reverse order.
1275      But parameter decls were previously put in forward order.  */
1276
1277   if (reverse)
1278     current_binding_level->names
1279       = decls = nreverse (current_binding_level->names);
1280   else
1281     decls = current_binding_level->names;
1282
1283   /* Output any nested inline functions within this block
1284      if they weren't already output.  */
1285
1286   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1287     if (TREE_CODE (decl) == FUNCTION_DECL
1288         && ! TREE_ASM_WRITTEN (decl)
1289         && DECL_INITIAL (decl) != 0
1290         && TREE_ADDRESSABLE (decl))
1291       {
1292         /* If this decl was copied from a file-scope decl
1293            on account of a block-scope extern decl,
1294            propagate TREE_ADDRESSABLE to the file-scope decl.
1295
1296            DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1297            true, since then the decl goes through save_for_inline_copying.  */
1298         if (DECL_ABSTRACT_ORIGIN (decl) != 0
1299             && DECL_ABSTRACT_ORIGIN (decl) != decl)
1300           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1301         else
1302           {
1303             push_function_context ();
1304             output_inline_function (decl);
1305             pop_function_context ();
1306           }
1307       }
1308
1309   /* If there were any declarations in that level,
1310      or if this level is a function body,
1311      create a BLOCK to record them for the life of this function.  */
1312
1313   block = 0;
1314   block_previously_created = (current_binding_level->this_block != 0);
1315   if (block_previously_created)
1316     block = current_binding_level->this_block;
1317   else if (keep || functionbody
1318            || (current_binding_level->keep_if_subblocks && subblocks != 0))
1319     block = make_node (BLOCK);
1320   if (block != 0)
1321     {
1322       BLOCK_VARS (block) = decls;
1323       BLOCK_SUBBLOCKS (block) = subblocks;
1324     }
1325
1326   /* In each subblock, record that this is its superior.  */
1327
1328   for (link = subblocks; link; link = TREE_CHAIN (link))
1329     BLOCK_SUPERCONTEXT (link) = block;
1330
1331   /* Clear out the meanings of the local variables of this level.  */
1332
1333   for (link = decls; link; link = TREE_CHAIN (link))
1334     {
1335       tree name = DECL_NAME (link);
1336       if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
1337         {
1338           /* If the ident. was used or addressed via a local extern decl,
1339              don't forget that fact.  */
1340           if (DECL_EXTERNAL (link))
1341             {
1342               if (TREE_USED (link))
1343                 TREE_USED (name) = 1;
1344               if (TREE_ADDRESSABLE (link))
1345                 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1346             }
1347           IDENTIFIER_LOCAL_VALUE (name) = 0;
1348         }
1349     }
1350
1351   /* Restore all name-meanings of the outer levels
1352      that were shadowed by this level.  */
1353
1354   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1355     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1356
1357   /* If the level being exited is the top level of a function,
1358      check over all the labels, and clear out the current
1359      (function local) meanings of their names.  */
1360
1361   if (functionbody)
1362     {
1363       /* If this is the top level block of a function,
1364          the vars are the function's parameters.
1365          Don't leave them in the BLOCK because they are
1366          found in the FUNCTION_DECL instead.  */
1367
1368       BLOCK_VARS (block) = 0;
1369
1370       /* Clear out the definitions of all label names,
1371          since their scopes end here,
1372          and add them to BLOCK_VARS.  */
1373
1374 #if 0
1375       for (link = named_labels; link; link = TREE_CHAIN (link))
1376         {
1377           register tree label = TREE_VALUE (link);
1378
1379           if (DECL_INITIAL (label) == 0)
1380             {
1381               error_with_decl (label, "label `%s' used but not defined");
1382               /* Avoid crashing later.  */
1383               define_label (input_filename, lineno,
1384                             DECL_NAME (label));
1385             }
1386           else if (warn_unused && !TREE_USED (label))
1387             warning_with_decl (label, "label `%s' defined but not used");
1388           IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1389
1390           /* Put the labels into the "variables" of the
1391              top-level block, so debugger can see them.  */
1392           TREE_CHAIN (label) = BLOCK_VARS (block);
1393           BLOCK_VARS (block) = label;
1394         }
1395 #endif
1396     }
1397
1398   /* Pop the current level, and free the structure for reuse.  */
1399
1400   {
1401     register struct binding_level *level = current_binding_level;
1402     current_binding_level = current_binding_level->level_chain;
1403
1404     level->level_chain = free_binding_level;
1405     free_binding_level = level;
1406   }
1407
1408   /* Dispose of the block that we just made inside some higher level.  */
1409   if (functionbody)
1410     DECL_INITIAL (current_function_decl) = block;
1411   else if (block)
1412     {
1413       if (!block_previously_created)
1414         current_binding_level->blocks
1415           = chainon (current_binding_level->blocks, block);
1416     }
1417   /* If we did not make a block for the level just exited,
1418      any blocks made for inner levels
1419      (since they cannot be recorded as subblocks in that level)
1420      must be carried forward so they will later become subblocks
1421      of something else.  */
1422   else if (subblocks)
1423     current_binding_level->blocks
1424       = chainon (current_binding_level->blocks, subblocks);
1425
1426   /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1427      binding contour so that they point to the appropriate construct, i.e.
1428      either to the current FUNCTION_DECL node, or else to the BLOCK node
1429      we just constructed.
1430
1431      Note that for tagged types whose scope is just the formal parameter
1432      list for some function type specification, we can't properly set
1433      their TYPE_CONTEXTs here, because we don't have a pointer to the
1434      appropriate FUNCTION_TYPE node readily available to us.  For those
1435      cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1436      in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1437      node which will represent the "scope" for these "parameter list local"
1438      tagged types.
1439   */
1440
1441   if (block)
1442     TREE_USED (block) = 1;
1443   return block;
1444 }
1445
1446 void
1447 maybe_pushlevels (pc)
1448      int pc;
1449 {
1450 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1451   current_pc = pc;
1452 #endif
1453
1454   while (pending_local_decls != NULL_TREE &&
1455          DECL_LOCAL_START_PC (pending_local_decls) <= pc)
1456     {
1457       tree *ptr = &pending_local_decls;
1458       tree decl = *ptr;
1459       int end_pc = DECL_LOCAL_END_PC (decl);
1460
1461       while (*ptr != NULL_TREE
1462              && DECL_LOCAL_START_PC (*ptr) <= pc
1463              && DECL_LOCAL_END_PC (*ptr) == end_pc)
1464         ptr = &TREE_CHAIN (*ptr);
1465       pending_local_decls = *ptr;
1466       *ptr = NULL_TREE;
1467
1468       /* Force non-nested range to be nested in current range. */
1469       if (end_pc > current_binding_level->end_pc)
1470         end_pc = current_binding_level->end_pc;
1471
1472       maybe_start_try (pc, end_pc);
1473
1474       pushlevel (1);
1475       expand_start_bindings (0);
1476
1477       current_binding_level->end_pc = end_pc;
1478       current_binding_level->start_pc = pc;
1479       current_binding_level->names = decl;
1480       for ( ; decl != NULL_TREE;  decl = TREE_CHAIN (decl))
1481         {
1482           push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl);
1483         }
1484     }
1485
1486   maybe_start_try (pc, 0);
1487 }
1488
1489 void
1490 maybe_poplevels (pc)
1491      int pc;
1492 {
1493 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1494   current_pc = pc;
1495 #endif
1496
1497   while (current_binding_level->end_pc <= pc)
1498     {
1499       expand_end_bindings (getdecls (), 1, 0);
1500       maybe_end_try (current_binding_level->start_pc, pc);
1501       poplevel (1, 0, 0);
1502     }
1503   maybe_end_try (0, pc);
1504 }
1505
1506 /* Terminate any binding which began during the range beginning at
1507    start_pc.  This tidies up improperly nested local variable ranges
1508    and exception handlers; a variable declared within an exception
1509    range is forcibly terminated when that exception ends. */
1510
1511 void
1512 force_poplevels (start_pc)
1513      int start_pc;
1514 {
1515   while (current_binding_level->start_pc > start_pc)
1516     {
1517       if (pedantic && current_binding_level->start_pc > start_pc)
1518         warning_with_decl (current_function_decl,
1519                            "In %s: overlapped variable and exception ranges at %d",
1520                            current_binding_level->start_pc);
1521       expand_end_bindings (getdecls (), 1, 0);
1522       poplevel (1, 0, 0);
1523     }
1524 }
1525
1526 /* Insert BLOCK at the end of the list of subblocks of the
1527    current binding level.  This is used when a BIND_EXPR is expanded,
1528    to handle the BLOCK node inside the BIND_EXPR.  */
1529
1530 void
1531 insert_block (block)
1532      tree block;
1533 {
1534   TREE_USED (block) = 1;
1535   current_binding_level->blocks
1536     = chainon (current_binding_level->blocks, block);
1537 }
1538
1539 /* Set the BLOCK node for the innermost scope
1540    (the one we are currently in).  */
1541
1542 void
1543 set_block (block)
1544      register tree block;
1545 {
1546   current_binding_level->this_block = block;
1547 }
1548
1549 /* integrate_decl_tree calls this function. */
1550
1551 void
1552 copy_lang_decl (node)
1553      tree node;
1554 {
1555   int lang_decl_size
1556     = TREE_CODE (node) == VAR_DECL ? sizeof (struct lang_decl_var)
1557     : sizeof (struct lang_decl);
1558   struct lang_decl *x = (struct lang_decl *) oballoc (lang_decl_size);
1559   bcopy ((PTR) DECL_LANG_SPECIFIC (node), (PTR) x, lang_decl_size);
1560   DECL_LANG_SPECIFIC (node) = x;
1561 }
1562
1563 /* If DECL has a cleanup, build and return that cleanup here.
1564    This is a callback called by expand_expr.  */
1565
1566 tree
1567 maybe_build_cleanup (decl)
1568   tree decl ATTRIBUTE_UNUSED;
1569 {
1570   /* There are no cleanups in Java (I think).  */
1571   return NULL_TREE;
1572 }
1573
1574 void
1575 give_name_to_locals (jcf)
1576      JCF *jcf;
1577 {
1578   int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
1579   tree parm;
1580   pending_local_decls = NULL_TREE;
1581   if (n == 0)
1582     return;
1583   JCF_SEEK (jcf, n);
1584   n = JCF_readu2 (jcf);
1585   for (i = 0; i < n; i++)
1586     {
1587       int start_pc = JCF_readu2 (jcf);
1588       int length = JCF_readu2 (jcf);
1589       int name_index = JCF_readu2 (jcf);
1590       int signature_index = JCF_readu2 (jcf);
1591       int slot = JCF_readu2 (jcf);
1592       tree name = get_name_constant (jcf, name_index);
1593       tree type = parse_signature (jcf, signature_index);
1594       if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
1595           && start_pc == 0
1596           && length == DECL_CODE_LENGTH (current_function_decl))
1597         {
1598           tree decl = TREE_VEC_ELT (decl_map, slot);
1599           DECL_NAME (decl) = name;
1600           DECL_ASSEMBLER_NAME (decl) = name;
1601           if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
1602             warning ("bad type in parameter debug info");
1603         }
1604       else
1605         {
1606           tree *ptr;
1607           int end_pc = start_pc + length;
1608           tree decl = build_decl (VAR_DECL, name, type);
1609           if (end_pc > DECL_CODE_LENGTH (current_function_decl))
1610             {
1611               warning_with_decl (decl,
1612                          "bad PC range for debug info for local `%s'");
1613               end_pc = DECL_CODE_LENGTH (current_function_decl);
1614             }
1615           DECL_LANG_SPECIFIC (decl)
1616             = (struct lang_decl *) permalloc (sizeof (struct lang_decl_var));
1617           DECL_LOCAL_SLOT_NUMBER (decl) = slot;
1618           DECL_LOCAL_START_PC (decl) = start_pc;
1619 #if 0
1620           /* FIXME: The range used internally for exceptions and local
1621              variable ranges, is a half-open interval:
1622              start_pc <= pc < end_pc.  However, the range used in the
1623              Java VM spec is inclusive at both ends:
1624              start_pc <= pc <= end_pc. */
1625           end_pc++;
1626 #endif
1627           DECL_LOCAL_END_PC (decl) = end_pc;
1628
1629           /* Now insert the new decl in the proper place in
1630              pending_local_decls.  We are essentially doing an insertion sort,
1631              which works fine, since the list input will normally already
1632              be sorted. */
1633           ptr = &pending_local_decls;
1634           while (*ptr != NULL_TREE
1635                  && (DECL_LOCAL_START_PC (*ptr) > start_pc
1636                      || (DECL_LOCAL_START_PC (*ptr) == start_pc
1637                          && DECL_LOCAL_END_PC (*ptr) < end_pc)))
1638             ptr = &TREE_CHAIN (*ptr);
1639           TREE_CHAIN (decl) = *ptr;
1640           *ptr = decl;
1641         }
1642     }
1643
1644   pending_local_decls = nreverse (pending_local_decls);
1645
1646   /* Fill in default names for the parameters. */
1647   for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
1648        parm != NULL_TREE;  parm = TREE_CHAIN (parm), i++)
1649     {
1650       if (DECL_NAME (parm) == NULL_TREE)
1651         {
1652           int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
1653           if (arg_i == 0)
1654             DECL_NAME (parm) = get_identifier ("this");
1655           else
1656             {
1657               char buffer[12];
1658               sprintf (buffer, "ARG_%d", arg_i);
1659               DECL_NAME (parm) = get_identifier (buffer);
1660             }
1661           DECL_ASSEMBLER_NAME (parm) = DECL_NAME (parm);
1662         }
1663     }
1664 }
1665
1666 tree
1667 build_result_decl (fndecl)
1668   tree fndecl;
1669 {
1670   tree restype = TREE_TYPE (TREE_TYPE (fndecl));
1671   /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1672   if (INTEGRAL_TYPE_P (restype)
1673       && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
1674     restype = integer_type_node;
1675   return (DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, restype));
1676 }
1677
1678 /* Called for every element in DECL_FUNCTION_INIT_TEST_TABLE in order
1679    to emit initialization code for each test flag.  */
1680
1681 static boolean
1682 emit_init_test_initialization (entry, key)
1683   struct hash_entry *entry;
1684   hash_table_key key ATTRIBUTE_UNUSED;
1685 {
1686   struct init_test_hash_entry *ite = (struct init_test_hash_entry *) entry;
1687   expand_decl (ite->init_test_decl);
1688
1689   expand_expr_stmt (build (MODIFY_EXPR, boolean_type_node,
1690                            ite->init_test_decl, boolean_false_node));
1691
1692   return true;
1693 }
1694
1695 void
1696 complete_start_java_method (fndecl)
1697   tree fndecl;
1698 {
1699   if (! flag_emit_class_files)
1700     {
1701       /* Initialize the RTL code for the function.  */
1702       init_function_start (fndecl, input_filename, lineno);
1703
1704       /* Set up parameters and prepare for return, for the function.  */
1705       expand_function_start (fndecl, 0);
1706
1707       /* Emit initialization code for test flags.  */
1708       if (! always_initialize_class_p)
1709         hash_traverse (&DECL_FUNCTION_INIT_TEST_TABLE (fndecl),
1710                        emit_init_test_initialization, 0);
1711     }
1712
1713   /* Allocate further tree nodes temporarily during compilation
1714      of this function only.  */
1715   temporary_allocation ();
1716
1717 #if 0
1718       /* If this fcn was already referenced via a block-scope `extern' decl (or
1719          an implicit decl), propagate certain information about the usage. */
1720       if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
1721         TREE_ADDRESSABLE (current_function_decl) = 1;
1722
1723 #endif
1724
1725   if (METHOD_STATIC (fndecl) && ! METHOD_PRIVATE (fndecl)
1726       && ! flag_emit_class_files
1727       && ! DECL_CLINIT_P (fndecl)
1728       && ! CLASS_INTERFACE (TYPE_NAME (current_class)))
1729     {
1730       tree clas = DECL_CONTEXT (fndecl);
1731       tree init = build (CALL_EXPR, void_type_node,
1732                          build_address_of (soft_initclass_node),
1733                          build_tree_list (NULL_TREE, build_class_ref (clas)),
1734                          NULL_TREE);
1735       TREE_SIDE_EFFECTS (init) = 1;
1736       expand_expr_stmt (init);
1737     }
1738
1739   /* Push local variables. Function compiled from source code are
1740      using a different local variables management, and for them,
1741      pushlevel shouldn't be called from here.  */
1742   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1743     {
1744       pushlevel (2);
1745       if (! flag_emit_class_files)
1746         expand_start_bindings (1);
1747     }
1748
1749   if (METHOD_SYNCHRONIZED (fndecl) && ! flag_emit_class_files)
1750     {
1751       /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1752       tree enter, exit, lock;
1753       if (METHOD_STATIC (fndecl))
1754         lock = build_class_ref (DECL_CONTEXT (fndecl));
1755       else
1756         lock = DECL_ARGUMENTS (fndecl);
1757       BUILD_MONITOR_ENTER (enter, lock);
1758       BUILD_MONITOR_EXIT (exit, lock);
1759       if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1760         {
1761           expand_expr_stmt (enter);
1762           expand_decl_cleanup (NULL_TREE, exit);
1763         }
1764       else
1765         {
1766           tree function_body = DECL_FUNCTION_BODY (fndecl);
1767           tree body = BLOCK_EXPR_BODY (function_body);
1768           lock = build (WITH_CLEANUP_EXPR, void_type_node,
1769                         enter,  NULL_TREE, exit);
1770           TREE_SIDE_EFFECTS (lock) = 1;
1771           lock = build (COMPOUND_EXPR, TREE_TYPE (body), lock, body);
1772           TREE_SIDE_EFFECTS (lock) = 1;
1773           lock = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (body), lock);
1774           TREE_SIDE_EFFECTS (lock) = 1;
1775           BLOCK_EXPR_BODY (function_body) = lock;
1776         }
1777     }
1778 }
1779
1780 void
1781 start_java_method (fndecl)
1782      tree fndecl;
1783 {
1784   tree tem, *ptr;
1785   int i;
1786
1787   current_function_decl = fndecl;
1788   announce_function (fndecl);
1789
1790   i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
1791   decl_map = make_tree_vec (i);
1792   type_map = (tree *) oballoc (i * sizeof (tree));
1793
1794 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1795   fprintf (stderr, "%s:\n", (*decl_printable_name) (fndecl, 2));
1796   current_pc = 0;
1797 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1798   pushlevel (1);  /* Push parameters. */
1799
1800   ptr = &DECL_ARGUMENTS (fndecl);
1801   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
1802        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
1803     {
1804       tree parm_name = NULL_TREE, parm_decl;
1805       tree parm_type = TREE_VALUE (tem);
1806       if (i >= DECL_MAX_LOCALS(fndecl))
1807         fatal ("function has more parameters than local slots");
1808
1809       parm_decl = build_decl (PARM_DECL, parm_name, parm_type);
1810       DECL_CONTEXT (parm_decl) = fndecl;
1811       if (PROMOTE_PROTOTYPES
1812           && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
1813           && INTEGRAL_TYPE_P (parm_type))
1814         parm_type = integer_type_node;
1815       DECL_ARG_TYPE (parm_decl) = parm_type;
1816
1817       *ptr = parm_decl;
1818       ptr = &TREE_CHAIN (parm_decl);
1819
1820       /* Add parm_decl to the decl_map. */
1821       push_jvm_slot (i, parm_decl);
1822
1823       type_map[i] = TREE_TYPE (parm_decl);
1824       if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
1825         {
1826           i++;
1827           type_map[i] = void_type_node;
1828         }
1829     }
1830   *ptr = NULL_TREE;
1831   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
1832
1833   while (i < DECL_MAX_LOCALS(fndecl))
1834     type_map[i++] = NULL_TREE;
1835
1836   build_result_decl (fndecl);
1837   complete_start_java_method (fndecl);
1838 }
1839
1840 void
1841 end_java_method ()
1842 {
1843   tree fndecl = current_function_decl;
1844   int flag_asynchronous_exceptions = asynchronous_exceptions;
1845
1846   expand_end_bindings (getdecls (), 1, 0);
1847   /* pop out of function */
1848   poplevel (1, 1, 0);
1849
1850   /* pop out of its parameters */
1851   poplevel (1, 0, 1);
1852
1853   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1854
1855   emit_handlers ();
1856
1857   /* Generate rtl for function exit.  */
1858   expand_function_end (input_filename, lineno, 0);
1859
1860   /* FIXME: If the current method contains any exception handlers,
1861      force asynchronous_exceptions: this is necessary because signal
1862      handlers in libjava may throw exceptions.  This is far from being
1863      a perfect solution, but it's better than doing nothing at all.*/
1864   if (catch_clauses)
1865     asynchronous_exceptions = 1;
1866
1867   /* Run the optimizers and output assembler code for this function. */
1868   rest_of_compilation (fndecl);
1869
1870   current_function_decl = NULL_TREE;
1871   permanent_allocation (1);
1872   asynchronous_exceptions = flag_asynchronous_exceptions;
1873 }