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