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