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 java_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   finalize_identifier_node = get_identifier ("finalize");
 590   this_identifier_node = get_identifier ("this");
 591   super_identifier_node = get_identifier ("super");
 592   continue_identifier_node = get_identifier ("continue");
 593   access0_identifier_node = get_identifier ("access$0");
 594   classdollar_identifier_node = get_identifier ("class$");
 595
 596   /* for lack of a better place to put this stub call */
 597   init_expr_processing();
 598
 599   utf8const_type = make_node (RECORD_TYPE);
 600   PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
 601   PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
 602   FINISH_RECORD (utf8const_type);
 603   utf8const_ptr_type = build_pointer_type (utf8const_type);
 604
 605   constants_type_node = make_node (RECORD_TYPE);
 606   PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node);
 607   PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
 608   PUSH_FIELD (constants_type_node, field, "data", ptr_type_node);
 609   FINISH_RECORD (constants_type_node);
 610   build_decl (TYPE_DECL, get_identifier ("constants"), constants_type_node);
 611
 612   access_flags_type_node = unsigned_short_type_node;
 613
 614   dtable_type = make_node (RECORD_TYPE);
 615   dtable_ptr_type = build_pointer_type (dtable_type);
 616
 617   PUSH_FIELD (object_type_node, field, "vtable", dtable_ptr_type);
 618   /* This isn't exactly true, but it is what we have in the source.
 619      There is an unresolved issue here, which is whether the vtable
 620      should be marked by the GC.  */
 621   if (! flag_hash_synchronization)
 622     PUSH_FIELD (object_type_node, field, "sync_info",
 623                 build_pointer_type (object_type_node));
 624   for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
 625     FIELD_PRIVATE (t) = 1;
 626   FINISH_RECORD (object_type_node);
 627
 628   field_type_node = make_node (RECORD_TYPE);
 629   field_ptr_type_node = build_pointer_type (field_type_node);
 630   method_type_node = make_node (RECORD_TYPE);
 631   method_ptr_type_node = build_pointer_type (method_type_node);
 632
 633   set_super_info (0, class_type_node, object_type_node, 0);
 634   set_super_info (0, string_type_node, object_type_node, 0);
 635   class_ptr_type = build_pointer_type (class_type_node);
 636
 637   PUSH_FIELD (class_type_node, field, "next", class_ptr_type);
 638   PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type);
 639   PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node);
 640   PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type);
 641   PUSH_FIELD (class_type_node, field, "constants", constants_type_node);
 642   PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node);
 643   PUSH_FIELD (class_type_node, field, "method_count", short_type_node);
 644   PUSH_FIELD (class_type_node, field, "vtable_method_count", short_type_node);
 645   PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node);
 646   PUSH_FIELD (class_type_node, field, "size_in_bytes", int_type_node);
 647   PUSH_FIELD (class_type_node, field, "field_count", short_type_node);
 648   PUSH_FIELD (class_type_node, field, "static_field_count", short_type_node);
 649   PUSH_FIELD (class_type_node, field, "vtable", dtable_ptr_type);
 650   PUSH_FIELD (class_type_node, field, "interfaces",
 651               build_pointer_type (class_ptr_type));
 652   PUSH_FIELD (class_type_node, field, "loader", ptr_type_node);
 653   PUSH_FIELD (class_type_node, field, "interface_count", short_type_node);
 654   PUSH_FIELD (class_type_node, field, "state", byte_type_node);
 655   PUSH_FIELD (class_type_node, field, "thread", ptr_type_node);
 656   PUSH_FIELD (class_type_node, field, "depth", short_type_node);
 657   PUSH_FIELD (class_type_node, field, "ancestors", ptr_type_node);
 658   PUSH_FIELD (class_type_node, field, "idt", ptr_type_node);
 659   PUSH_FIELD (class_type_node, field, "arrayclass", ptr_type_node);
 660   PUSH_FIELD (class_type_node, field, "protectionDomain", ptr_type_node);
 661   for (t = TYPE_FIELDS (class_type_node);  t != NULL_TREE;  t = TREE_CHAIN (t))
 662     FIELD_PRIVATE (t) = 1;
 663   push_super_field (class_type_node, object_type_node);
 664   FINISH_RECORD (class_type_node);
 665   build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node);
 666
 667   field_info_union_node = make_node (UNION_TYPE);
 668   PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node);
 669   PUSH_FIELD (field_info_union_node, field, "addr", ptr_type_node);
 670 #if 0
 671   PUSH_FIELD (field_info_union_node, field, "idx", unsigned_short_type_node);
 672 #endif
 673   layout_type (field_info_union_node);
 674
 675   PUSH_FIELD (field_type_node, field, "name", utf8const_ptr_type);
 676   PUSH_FIELD (field_type_node, field, "type", class_ptr_type);
 677   PUSH_FIELD (field_type_node, field, "accflags", access_flags_type_node);
 678   PUSH_FIELD (field_type_node, field, "bsize", unsigned_short_type_node);
 679   PUSH_FIELD (field_type_node, field, "info", field_info_union_node);
 680   FINISH_RECORD (field_type_node);
 681   build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node);
 682
 683   one_elt_array_domain_type = build_index_type (integer_one_node);
 684   nativecode_ptr_array_type_node
 685     = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
 686
 687   PUSH_FIELD (dtable_type, field, "class", class_ptr_type);
 688   PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node);
 689   FINISH_RECORD (dtable_type);
 690   build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
 691
 692 #define jint_type int_type_node
 693 #define jint_ptr_type ptr_type_node
 694
 695   jexception_type = make_node (RECORD_TYPE);
 696   PUSH_FIELD (jexception_type, field, "start_pc", ptr_type_node);
 697   PUSH_FIELD (jexception_type, field, "end_pc", ptr_type_node);
 698   PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node);
 699   PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type);
 700   FINISH_RECORD (jexception_type);
 701   build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node);
 702   jexception_ptr_type = build_pointer_type (jexception_type);
 703
 704   lineNumberEntry_type = make_node (RECORD_TYPE);
 705   PUSH_FIELD (lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
 706   PUSH_FIELD (lineNumberEntry_type, field, "start_pc", ptr_type_node);
 707   FINISH_RECORD (lineNumberEntry_type);
 708
 709   lineNumbers_type = make_node (RECORD_TYPE);
 710   PUSH_FIELD (lineNumbers_type, field, "length", unsigned_int_type_node);
 711   FINISH_RECORD (lineNumbers_type);
 712
 713 #define instn_ptr_type_node ptr_type_node       /* XXX JH */
 714
 715 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
 716
 717   PUSH_FIELD (method_type_node, field, "name", utf8const_ptr_type);
 718   PUSH_FIELD (method_type_node, field, "signature", utf8const_ptr_type);
 719   PUSH_FIELD (method_type_node, field, "accflags", access_flags_type_node);
 720   PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node);
 721   PUSH_FIELD (method_type_node, field, "throws", ptr_type_node);
 722   FINISH_RECORD (method_type_node);
 723   build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node);
 724
 725   endlink = end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
 726
 727   t = tree_cons (NULL_TREE, class_ptr_type,
 728                  tree_cons (NULL_TREE, int_type_node, endlink));
 729   alloc_object_node = builtin_function ("_Jv_AllocObject",
 730                                         build_function_type (ptr_type_node, t),
 731                                         0, NOT_BUILT_IN, NULL);
 732   DECL_IS_MALLOC (alloc_object_node) = 1;
 733   alloc_no_finalizer_node =
 734     builtin_function ("_Jv_AllocObjectNoFinalizer",
 735                       build_function_type (ptr_type_node, t),
 736                       0, NOT_BUILT_IN, NULL);
 737   DECL_IS_MALLOC (alloc_no_finalizer_node) = 1;
 738
 739   t = tree_cons (NULL_TREE, ptr_type_node, endlink);
 740   soft_initclass_node = builtin_function ("_Jv_InitClass",
 741                                           build_function_type (void_type_node,
 742                                                                t),
 743                                           0, NOT_BUILT_IN, NULL);
 744
 745   throw_node = builtin_function ("_Jv_Throw",
 746                                  build_function_type (ptr_type_node, t),
 747                                  0, NOT_BUILT_IN, NULL);
 748   /* Mark throw_nodes as `noreturn' functions with side effects.  */
 749   TREE_THIS_VOLATILE (throw_node) = 1;
 750   TREE_SIDE_EFFECTS (throw_node) = 1;
 751
 752   t = build_function_type (int_type_node, endlink);
 753   soft_monitorenter_node
 754     = builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN, NULL);
 755   soft_monitorexit_node
 756     = builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN, NULL);
 757
 758   t = tree_cons (NULL_TREE, int_type_node,
 759                  tree_cons (NULL_TREE, int_type_node, endlink));
 760   soft_newarray_node
 761       = builtin_function ("_Jv_NewPrimArray",
 762                           build_function_type(ptr_type_node, t),
 763                           0, NOT_BUILT_IN, NULL);
 764   DECL_IS_MALLOC (soft_newarray_node) = 1;
 765
 766   t = tree_cons (NULL_TREE, int_type_node,
 767                  tree_cons (NULL_TREE, class_ptr_type,
 768                             tree_cons (NULL_TREE, object_ptr_type_node, endlink)));
 769   soft_anewarray_node
 770       = builtin_function ("_Jv_NewObjectArray",
 771                           build_function_type (ptr_type_node, t),
 772                           0, NOT_BUILT_IN, NULL);
 773   DECL_IS_MALLOC (soft_anewarray_node) = 1;
 774
 775   t = tree_cons (NULL_TREE, ptr_type_node,
 776                  tree_cons (NULL_TREE, int_type_node, endlink));
 777   soft_multianewarray_node
 778       = builtin_function ("_Jv_NewMultiArray",
 779                           build_function_type (ptr_type_node, t),
 780                           0, NOT_BUILT_IN, NULL);
 781   DECL_IS_MALLOC (soft_multianewarray_node) = 1;
 782
 783   t = build_function_type (void_type_node,
 784                            tree_cons (NULL_TREE, int_type_node, endlink));
 785   soft_badarrayindex_node
 786       = builtin_function ("_Jv_ThrowBadArrayIndex", t,
 787                           0, NOT_BUILT_IN, NULL);
 788   /* Mark soft_badarrayindex_node as a `noreturn' function with side
 789      effects.  */
 790   TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
 791   TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
 792
 793   soft_nullpointer_node
 794     = builtin_function ("_Jv_ThrowNullPointerException",
 795                         build_function_type (void_type_node, endlink),
 796                         0, NOT_BUILT_IN, NULL);
 797   /* Mark soft_nullpointer_node as a `noreturn' function with side
 798      effects.  */
 799   TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
 800   TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
 801
 802   t = tree_cons (NULL_TREE, class_ptr_type,
 803                  tree_cons (NULL_TREE, object_ptr_type_node, endlink));
 804   soft_checkcast_node
 805     = builtin_function ("_Jv_CheckCast",
 806                         build_function_type (ptr_type_node, t),
 807                         0, NOT_BUILT_IN, NULL);
 808   t = tree_cons (NULL_TREE, object_ptr_type_node,
 809                  tree_cons (NULL_TREE, class_ptr_type, endlink));
 810   soft_instanceof_node
 811     = builtin_function ("_Jv_IsInstanceOf",
 812                         build_function_type (boolean_type_node, t),
 813                         0, NOT_BUILT_IN, NULL);
 814   t = tree_cons (NULL_TREE, object_ptr_type_node,
 815                  tree_cons (NULL_TREE, object_ptr_type_node, endlink));
 816   soft_checkarraystore_node
 817     = builtin_function ("_Jv_CheckArrayStore",
 818                         build_function_type (void_type_node, t),
 819                         0, NOT_BUILT_IN, NULL);
 820   t = tree_cons (NULL_TREE, ptr_type_node,
 821                  tree_cons (NULL_TREE, ptr_type_node,
 822                             tree_cons (NULL_TREE, int_type_node, endlink)));
 823   soft_lookupinterfacemethod_node
 824     = builtin_function ("_Jv_LookupInterfaceMethodIdx",
 825                         build_function_type (ptr_type_node, t),
 826                         0, NOT_BUILT_IN, NULL);
 827
 828   t = tree_cons (NULL_TREE, object_ptr_type_node,
 829                  tree_cons (NULL_TREE, ptr_type_node,
 830                             tree_cons (NULL_TREE, ptr_type_node, endlink)));
 831   soft_lookupjnimethod_node
 832     = builtin_function ("_Jv_LookupJNIMethod",
 833                         build_function_type (ptr_type_node, t),
 834                         0, NOT_BUILT_IN, NULL);
 835   t = tree_cons (NULL_TREE, ptr_type_node, endlink);
 836   soft_getjnienvnewframe_node
 837     = builtin_function ("_Jv_GetJNIEnvNewFrame",
 838                         build_function_type (ptr_type_node, t),
 839                         0, NOT_BUILT_IN, NULL);
 840   soft_jnipopsystemframe_node
 841     = builtin_function ("_Jv_JNI_PopSystemFrame",
 842                         build_function_type (ptr_type_node, t),
 843                         0, NOT_BUILT_IN, NULL);
 844
 845   t = tree_cons (NULL_TREE, double_type_node,
 846                  tree_cons (NULL_TREE, double_type_node, endlink));
 847   soft_fmod_node
 848     = builtin_function ("__builtin_fmod",
 849                         build_function_type (double_type_node, t),
 850                         BUILT_IN_FMOD, BUILT_IN_NORMAL, "fmod");
 851
 852 #if 0
 853   t = tree_cons (NULL_TREE, float_type_node,
 854                  tree_cons (NULL_TREE, float_type_node, endlink));
 855   soft_fmodf_node
 856     = builtin_function ("__builtin_fmodf",
 857                         build_function_type (float_type_node, t),
 858                         BUILT_IN_FMOD, BUILT_IN_NORMAL, "fmodf");
 859 #endif
 860
 861   soft_idiv_node
 862     = builtin_function ("_Jv_divI",
 863                         build_function_type (int_type_node, t),
 864                         0, NOT_BUILT_IN, NULL);
 865
 866   soft_irem_node
 867     = builtin_function ("_Jv_remI",
 868                         build_function_type (int_type_node, t),
 869                         0, NOT_BUILT_IN, NULL);
 870
 871   soft_ldiv_node
 872     = builtin_function ("_Jv_divJ",
 873                         build_function_type (long_type_node, t),
 874                         0, NOT_BUILT_IN, NULL);
 875
 876   soft_lrem_node
 877     = builtin_function ("_Jv_remJ",
 878                         build_function_type (long_type_node, t),
 879                         0, NOT_BUILT_IN, NULL);
 880
 881   /* Initialize variables for except.c.  */
 882   eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
 883                                              ? "__gcj_personality_sj0"
 884                                              : "__gcj_personality_v0");
 885   lang_eh_runtime_type = prepare_eh_table_type;
 886
 887   init_jcf_parse ();
 888
 889   /* Register nodes with the garbage collector.  */
 890   ggc_add_tree_root (java_global_trees,
 891                      sizeof (java_global_trees) / sizeof (tree));
 892   ggc_add_tree_root (predef_filenames,
 893                      sizeof (predef_filenames) / sizeof (tree));
 894   ggc_add_tree_root (&decl_map, 1);
 895   ggc_add_tree_root (&pending_local_decls, 1);
 896 }
 897
 898
 899 /* Look up NAME in the current binding level and its superiors
 900    in the namespace of variables, functions and typedefs.
 901    Return a ..._DECL node of some kind representing its definition,
 902    or return 0 if it is undefined.  */
 903
 904 tree
 905 lookup_name (name)
 906      tree name;
 907 {
 908   register tree val;
 909   if (current_binding_level != global_binding_level
 910       && IDENTIFIER_LOCAL_VALUE (name))
 911     val = IDENTIFIER_LOCAL_VALUE (name);
 912   else
 913     val = IDENTIFIER_GLOBAL_VALUE (name);
 914   return val;
 915 }
 916
 917 /* Similar to `lookup_name' but look only at current binding level and
 918    the previous one if its the parameter level.  */
 919
 920 static tree
 921 lookup_name_current_level (name)
 922      tree name;
 923 {
 924   register tree t;
 925
 926   if (current_binding_level == global_binding_level)
 927     return IDENTIFIER_GLOBAL_VALUE (name);
 928
 929   if (IDENTIFIER_LOCAL_VALUE (name) == 0)
 930     return 0;
 931
 932   for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
 933     if (DECL_NAME (t) == name)
 934       break;
 935
 936   return t;
 937 }
 938
 939 /* Use a binding level to record a labeled block declaration */
 940
 941 void
 942 push_labeled_block (lb)
 943     tree lb;
 944 {
 945   register tree name = DECL_NAME (LABELED_BLOCK_LABEL (lb));
 946   register struct binding_level *b = current_binding_level;
 947   tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
 948   if (oldlocal != 0)
 949       b->shadowed = tree_cons (name, oldlocal, b->shadowed);
 950   TREE_CHAIN (lb) = b->names;
 951   b->names = lb;
 952   IDENTIFIER_LOCAL_VALUE (name) = lb;
 953 }
 954
 955 /* Pop the current binding level, reinstalling values for the previous
 956    labeled block */
 957
 958 void
 959 pop_labeled_block ()
 960 {
 961   struct binding_level *b = current_binding_level;
 962   tree label =  b->names;
 963   IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label))) =
 964     NULL_TREE;
 965   if (b->shadowed)
 966     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b->shadowed)) =
 967       TREE_VALUE (b->shadowed);
 968
 969   /* Pop the current level, and free the structure for reuse.  */
 970   current_binding_level = current_binding_level->level_chain;
 971   b->level_chain = free_binding_level;
 972   free_binding_level = b;
 973 }
 974
 975 /* Record a decl-node X as belonging to the current lexical scope.
 976    Check for errors (such as an incompatible declaration for the same
 977    name already seen in the same scope).
 978
 979    Returns either X or an old decl for the same name.
 980    If an old decl is returned, it may have been smashed
 981    to agree with what X says.  */
 982
 983 tree
 984 pushdecl (x)
 985      tree x;
 986 {
 987   register tree t;
 988   register tree name = DECL_NAME (x);
 989   register struct binding_level *b = current_binding_level;
 990
 991   if (TREE_CODE (x) != TYPE_DECL)
 992     DECL_CONTEXT (x) = current_function_decl;
 993   if (name)
 994     {
 995       const char *file;
 996       int line;
 997
 998       t = lookup_name_current_level (name);
 999       if (t != 0 && t == error_mark_node)
1000         /* error_mark_node is 0 for a while during initialization!  */
1001         {
1002           t = 0;
1003           error_with_decl (x, "`%s' used prior to declaration");
1004         }
1005
1006       if (t != 0)
1007         {
1008           file = DECL_SOURCE_FILE (t);
1009           line = DECL_SOURCE_LINE (t);
1010         }
1011
1012       /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1013          to point to the TYPE_DECL.
1014          Since Java does not have typedefs, a type can only have
1015          one (true) name, given by a class, interface, or builtin. */
1016       if (TREE_CODE (x) == TYPE_DECL
1017           && TYPE_NAME (TREE_TYPE (x)) == 0
1018           && TREE_TYPE (x) != error_mark_node)
1019         {
1020           TYPE_NAME (TREE_TYPE (x)) = x;
1021           TYPE_STUB_DECL (TREE_TYPE (x)) = x;
1022         }
1023
1024       /* This name is new in its binding level.
1025          Install the new declaration and return it.  */
1026       if (b == global_binding_level)
1027         {
1028           /* Install a global value.  */
1029
1030           IDENTIFIER_GLOBAL_VALUE (name) = x;
1031         }
1032       else
1033         {
1034           /* Here to install a non-global value.  */
1035           tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1036           IDENTIFIER_LOCAL_VALUE (name) = x;
1037
1038 #if 0
1039           /* Warn if shadowing an argument at the top level of the body.  */
1040           if (oldlocal != 0 && !DECL_EXTERNAL (x)
1041               /* This warning doesn't apply to the parms of a nested fcn.  */
1042               && ! current_binding_level->parm_flag
1043               /* Check that this is one level down from the parms.  */
1044               && current_binding_level->level_chain->parm_flag
1045               /* Check that the decl being shadowed
1046                  comes from the parm level, one level up.  */
1047               && chain_member (oldlocal, current_binding_level->level_chain->names))
1048             {
1049               if (TREE_CODE (oldlocal) == PARM_DECL)
1050                 pedwarn ("declaration of `%s' shadows a parameter",
1051                          IDENTIFIER_POINTER (name));
1052               else
1053                 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1054                          IDENTIFIER_POINTER (name));
1055             }
1056
1057           /* Maybe warn if shadowing something else.  */
1058           else if (warn_shadow && !DECL_EXTERNAL (x)
1059                    /* No shadow warnings for internally generated vars.  */
1060                    && DECL_SOURCE_LINE (x) != 0
1061                    /* No shadow warnings for vars made for inlining.  */
1062                    && ! DECL_FROM_INLINE (x))
1063             {
1064               const char *warnstring = 0;
1065
1066               if (TREE_CODE (x) == PARM_DECL
1067                   && current_binding_level->level_chain->parm_flag)
1068                 /* Don't warn about the parm names in function declarator
1069                    within a function declarator.
1070                    It would be nice to avoid warning in any function
1071                    declarator in a declaration, as opposed to a definition,
1072                    but there is no way to tell it's not a definition.  */
1073                 ;
1074               else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
1075                 warnstring = "declaration of `%s' shadows a parameter";
1076               else if (oldlocal != 0)
1077                 warnstring = "declaration of `%s' shadows previous local";
1078               else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
1079                        && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
1080                 warnstring = "declaration of `%s' shadows global declaration";
1081
1082               if (warnstring)
1083                 warning (warnstring, IDENTIFIER_POINTER (name));
1084             }
1085 #endif
1086
1087           /* If storing a local value, there may already be one (inherited).
1088              If so, record it for restoration when this binding level ends.  */
1089           if (oldlocal != 0)
1090             b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1091         }
1092     }
1093
1094   /* Put decls on list in reverse order.
1095      We will reverse them later if necessary.  */
1096   TREE_CHAIN (x) = b->names;
1097   b->names = x;
1098
1099   return x;
1100 }
1101
1102 void
1103 pushdecl_force_head (x)
1104      tree x;
1105 {
1106   current_binding_level->names = x;
1107 }
1108
1109 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
1110
1111 tree
1112 pushdecl_top_level (x)
1113      tree x;
1114 {
1115   register tree t;
1116   register struct binding_level *b = current_binding_level;
1117
1118   current_binding_level = global_binding_level;
1119   t = pushdecl (x);
1120   current_binding_level = b;
1121   return t;
1122 }
1123
1124 /* Nonzero if we are currently in the global binding level.  */
1125
1126 int
1127 global_bindings_p ()
1128 {
1129   return current_binding_level == global_binding_level;
1130 }
1131
1132 /* Return the list of declarations of the current level.
1133    Note that this list is in reverse order unless/until
1134    you nreverse it; and when you do nreverse it, you must
1135    store the result back using `storedecls' or you will lose.  */
1136
1137 tree
1138 getdecls ()
1139 {
1140   return current_binding_level->names;
1141 }
1142
1143 /* Create a new `struct binding_level'.  */
1144
1145 static struct binding_level *
1146 make_binding_level ()
1147 {
1148   /* NOSTRICT */
1149   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
1150 }
1151
1152 void
1153 pushlevel (unused)
1154   int unused ATTRIBUTE_UNUSED;
1155 {
1156   register struct binding_level *newlevel = NULL_BINDING_LEVEL;
1157
1158 #if 0
1159   /* If this is the top level of a function,
1160      just make sure that NAMED_LABELS is 0.  */
1161
1162   if (current_binding_level == global_binding_level)
1163     named_labels = 0;
1164 #endif
1165
1166   /* Reuse or create a struct for this binding level.  */
1167
1168   if (free_binding_level)
1169     {
1170       newlevel = free_binding_level;
1171       free_binding_level = free_binding_level->level_chain;
1172     }
1173   else
1174     {
1175       newlevel = make_binding_level ();
1176     }
1177
1178   /* Add this level to the front of the chain (stack) of levels that
1179      are active.  */
1180
1181   *newlevel = clear_binding_level;
1182   newlevel->level_chain = current_binding_level;
1183   current_binding_level = newlevel;
1184 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1185   newlevel->binding_depth = binding_depth;
1186   indent ();
1187   fprintf (stderr, "push %s level 0x%08x pc %d\n",
1188            (is_class_level) ? "class" : "block", newlevel, current_pc);
1189   is_class_level = 0;
1190   binding_depth++;
1191 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1192 }
1193
1194 /* Exit a binding level.
1195    Pop the level off, and restore the state of the identifier-decl mappings
1196    that were in effect when this level was entered.
1197
1198    If KEEP is nonzero, this level had explicit declarations, so
1199    and create a "block" (a BLOCK node) for the level
1200    to record its declarations and subblocks for symbol table output.
1201
1202    If FUNCTIONBODY is nonzero, this level is the body of a function,
1203    so create a block as if KEEP were set and also clear out all
1204    label names.
1205
1206    If REVERSE is nonzero, reverse the order of decls before putting
1207    them into the BLOCK.  */
1208
1209 tree
1210 poplevel (keep, reverse, functionbody)
1211      int keep;
1212      int reverse;
1213      int functionbody;
1214 {
1215   register tree link;
1216   /* The chain of decls was accumulated in reverse order.
1217      Put it into forward order, just for cleanliness.  */
1218   tree decls;
1219   tree subblocks = current_binding_level->blocks;
1220   tree block = 0;
1221   tree decl;
1222   int block_previously_created;
1223
1224 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1225   binding_depth--;
1226   indent ();
1227   if (current_binding_level->end_pc != LARGEST_PC)
1228     fprintf (stderr, "pop  %s level 0x%08x pc %d (end pc %d)\n",
1229              (is_class_level) ? "class" : "block", current_binding_level, current_pc,
1230              current_binding_level->end_pc);
1231   else
1232     fprintf (stderr, "pop  %s level 0x%08x pc %d\n",
1233              (is_class_level) ? "class" : "block", current_binding_level, current_pc);
1234 #if 0
1235   if (is_class_level != (current_binding_level == class_binding_level))
1236     {
1237       indent ();
1238       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
1239     }
1240   is_class_level = 0;
1241 #endif
1242 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1243
1244   /* Get the decls in the order they were written.
1245      Usually current_binding_level->names is in reverse order.
1246      But parameter decls were previously put in forward order.  */
1247
1248   if (reverse)
1249     current_binding_level->names
1250       = decls = nreverse (current_binding_level->names);
1251   else
1252     decls = current_binding_level->names;
1253
1254   /* Output any nested inline functions within this block
1255      if they weren't already output.  */
1256
1257   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1258     if (TREE_CODE (decl) == FUNCTION_DECL
1259         && ! TREE_ASM_WRITTEN (decl)
1260         && DECL_INITIAL (decl) != 0
1261         && TREE_ADDRESSABLE (decl))
1262       {
1263         /* If this decl was copied from a file-scope decl
1264            on account of a block-scope extern decl,
1265            propagate TREE_ADDRESSABLE to the file-scope decl.
1266
1267            DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1268            true, since then the decl goes through save_for_inline_copying.  */
1269         if (DECL_ABSTRACT_ORIGIN (decl) != 0
1270             && DECL_ABSTRACT_ORIGIN (decl) != decl)
1271           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1272         else
1273           {
1274             push_function_context ();
1275             output_inline_function (decl);
1276             pop_function_context ();
1277           }
1278       }
1279
1280   /* If there were any declarations in that level,
1281      or if this level is a function body,
1282      create a BLOCK to record them for the life of this function.  */
1283
1284   block = 0;
1285   block_previously_created = (current_binding_level->this_block != 0);
1286   if (block_previously_created)
1287     block = current_binding_level->this_block;
1288   else if (keep || functionbody)
1289     block = make_node (BLOCK);
1290   if (block != 0)
1291     {
1292       BLOCK_VARS (block) = decls;
1293       BLOCK_SUBBLOCKS (block) = subblocks;
1294     }
1295
1296   /* In each subblock, record that this is its superior.  */
1297
1298   for (link = subblocks; link; link = TREE_CHAIN (link))
1299     BLOCK_SUPERCONTEXT (link) = block;
1300
1301   /* Clear out the meanings of the local variables of this level.  */
1302
1303   for (link = decls; link; link = TREE_CHAIN (link))
1304     {
1305       tree name = DECL_NAME (link);
1306       if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
1307         {
1308           /* If the ident. was used or addressed via a local extern decl,
1309              don't forget that fact.  */
1310           if (DECL_EXTERNAL (link))
1311             {
1312               if (TREE_USED (link))
1313                 TREE_USED (name) = 1;
1314               if (TREE_ADDRESSABLE (link))
1315                 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1316             }
1317           IDENTIFIER_LOCAL_VALUE (name) = 0;
1318         }
1319     }
1320
1321   /* Restore all name-meanings of the outer levels
1322      that were shadowed by this level.  */
1323
1324   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1325     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1326
1327   /* If the level being exited is the top level of a function,
1328      check over all the labels, and clear out the current
1329      (function local) meanings of their names.  */
1330
1331   if (functionbody)
1332     {
1333       /* If this is the top level block of a function,
1334          the vars are the function's parameters.
1335          Don't leave them in the BLOCK because they are
1336          found in the FUNCTION_DECL instead.  */
1337
1338       BLOCK_VARS (block) = 0;
1339
1340       /* Clear out the definitions of all label names,
1341          since their scopes end here,
1342          and add them to BLOCK_VARS.  */
1343
1344 #if 0
1345       for (link = named_labels; link; link = TREE_CHAIN (link))
1346         {
1347           register tree label = TREE_VALUE (link);
1348
1349           if (DECL_INITIAL (label) == 0)
1350             {
1351               error_with_decl (label, "label `%s' used but not defined");
1352               /* Avoid crashing later.  */
1353               define_label (input_filename, lineno,
1354                             DECL_NAME (label));
1355             }
1356           else if (warn_unused[UNUSED_LABEL] && !TREE_USED (label))
1357             warning_with_decl (label, "label `%s' defined but not used");
1358           IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1359
1360           /* Put the labels into the "variables" of the
1361              top-level block, so debugger can see them.  */
1362           TREE_CHAIN (label) = BLOCK_VARS (block);
1363           BLOCK_VARS (block) = label;
1364         }
1365 #endif
1366     }
1367
1368   /* Pop the current level, and free the structure for reuse.  */
1369
1370   {
1371     register struct binding_level *level = current_binding_level;
1372     current_binding_level = current_binding_level->level_chain;
1373
1374     level->level_chain = free_binding_level;
1375     free_binding_level = level;
1376   }
1377
1378   /* Dispose of the block that we just made inside some higher level.  */
1379   if (functionbody)
1380     DECL_INITIAL (current_function_decl) = block;
1381   else if (block)
1382     {
1383       if (!block_previously_created)
1384         current_binding_level->blocks
1385           = chainon (current_binding_level->blocks, block);
1386     }
1387   /* If we did not make a block for the level just exited,
1388      any blocks made for inner levels
1389      (since they cannot be recorded as subblocks in that level)
1390      must be carried forward so they will later become subblocks
1391      of something else.  */
1392   else if (subblocks)
1393     current_binding_level->blocks
1394       = chainon (current_binding_level->blocks, subblocks);
1395
1396   /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1397      binding contour so that they point to the appropriate construct, i.e.
1398      either to the current FUNCTION_DECL node, or else to the BLOCK node
1399      we just constructed.
1400
1401      Note that for tagged types whose scope is just the formal parameter
1402      list for some function type specification, we can't properly set
1403      their TYPE_CONTEXTs here, because we don't have a pointer to the
1404      appropriate FUNCTION_TYPE node readily available to us.  For those
1405      cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1406      in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1407      node which will represent the "scope" for these "parameter list local"
1408      tagged types.
1409   */
1410
1411   if (block)
1412     TREE_USED (block) = 1;
1413   return block;
1414 }
1415
1416 void
1417 maybe_pushlevels (pc)
1418      int pc;
1419 {
1420 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1421   current_pc = pc;
1422 #endif
1423
1424   while (pending_local_decls != NULL_TREE &&
1425          DECL_LOCAL_START_PC (pending_local_decls) <= pc)
1426     {
1427       tree *ptr = &pending_local_decls;
1428       tree decl = *ptr;
1429       int end_pc = DECL_LOCAL_END_PC (decl);
1430
1431       while (*ptr != NULL_TREE
1432              && DECL_LOCAL_START_PC (*ptr) <= pc
1433              && DECL_LOCAL_END_PC (*ptr) == end_pc)
1434         ptr = &TREE_CHAIN (*ptr);
1435       pending_local_decls = *ptr;
1436       *ptr = NULL_TREE;
1437
1438       /* Force non-nested range to be nested in current range. */
1439       if (end_pc > current_binding_level->end_pc)
1440         end_pc = current_binding_level->end_pc;
1441
1442       maybe_start_try (pc, end_pc);
1443
1444       pushlevel (1);
1445       expand_start_bindings (0);
1446
1447       current_binding_level->end_pc = end_pc;
1448       current_binding_level->start_pc = pc;
1449       current_binding_level->names = decl;
1450       for ( ; decl != NULL_TREE;  decl = TREE_CHAIN (decl))
1451         {
1452           push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl);
1453         }
1454     }
1455
1456   maybe_start_try (pc, 0);
1457 }
1458
1459 void
1460 maybe_poplevels (pc)
1461      int pc;
1462 {
1463 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1464   current_pc = pc;
1465 #endif
1466
1467   while (current_binding_level->end_pc <= pc)
1468     {
1469       expand_end_bindings (getdecls (), 1, 0);
1470       maybe_end_try (current_binding_level->start_pc, pc);
1471       poplevel (1, 0, 0);
1472     }
1473   maybe_end_try (0, pc);
1474 }
1475
1476 /* Terminate any binding which began during the range beginning at
1477    start_pc.  This tidies up improperly nested local variable ranges
1478    and exception handlers; a variable declared within an exception
1479    range is forcibly terminated when that exception ends. */
1480
1481 void
1482 force_poplevels (start_pc)
1483      int start_pc;
1484 {
1485   while (current_binding_level->start_pc > start_pc)
1486     {
1487       if (pedantic && current_binding_level->start_pc > start_pc)
1488         warning_with_decl (current_function_decl,
1489                            "In %s: overlapped variable and exception ranges at %d",
1490                            current_binding_level->start_pc);
1491       expand_end_bindings (getdecls (), 1, 0);
1492       poplevel (1, 0, 0);
1493     }
1494 }
1495
1496 /* Insert BLOCK at the end of the list of subblocks of the
1497    current binding level.  This is used when a BIND_EXPR is expanded,
1498    to handle the BLOCK node inside the BIND_EXPR.  */
1499
1500 void
1501 insert_block (block)
1502      tree block;
1503 {
1504   TREE_USED (block) = 1;
1505   current_binding_level->blocks
1506     = chainon (current_binding_level->blocks, block);
1507 }
1508
1509 /* Set the BLOCK node for the innermost scope
1510    (the one we are currently in).  */
1511
1512 void
1513 set_block (block)
1514      register tree block;
1515 {
1516   current_binding_level->this_block = block;
1517   current_binding_level->names = chainon (current_binding_level->names,
1518                                           BLOCK_VARS (block));
1519   current_binding_level->blocks = chainon (current_binding_level->blocks,
1520                                            BLOCK_SUBBLOCKS (block));
1521 }
1522
1523 /* integrate_decl_tree calls this function. */
1524
1525 void
1526 copy_lang_decl (node)
1527      tree node;
1528 {
1529   int lang_decl_size
1530     = TREE_CODE (node) == VAR_DECL ? sizeof (struct lang_decl_var)
1531     : sizeof (struct lang_decl);
1532   struct lang_decl *x = (struct lang_decl *) ggc_alloc (lang_decl_size);
1533   memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
1534   DECL_LANG_SPECIFIC (node) = x;
1535 }
1536
1537 /* If DECL has a cleanup, build and return that cleanup here.
1538    This is a callback called by expand_expr.  */
1539
1540 tree
1541 maybe_build_cleanup (decl)
1542   tree decl ATTRIBUTE_UNUSED;
1543 {
1544   /* There are no cleanups in Java (I think).  */
1545   return NULL_TREE;
1546 }
1547
1548 void
1549 give_name_to_locals (jcf)
1550      JCF *jcf;
1551 {
1552   int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
1553   int code_offset = DECL_CODE_OFFSET (current_function_decl);
1554   tree parm;
1555   pending_local_decls = NULL_TREE;
1556   if (n == 0)
1557     return;
1558   JCF_SEEK (jcf, n);
1559   n = JCF_readu2 (jcf);
1560   for (i = 0; i < n; i++)
1561     {
1562       int start_pc = JCF_readu2 (jcf);
1563       int length = JCF_readu2 (jcf);
1564       int name_index = JCF_readu2 (jcf);
1565       int signature_index = JCF_readu2 (jcf);
1566       int slot = JCF_readu2 (jcf);
1567       tree name = get_name_constant (jcf, name_index);
1568       tree type = parse_signature (jcf, signature_index);
1569       if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
1570           && start_pc == 0
1571           && length == DECL_CODE_LENGTH (current_function_decl))
1572         {
1573           tree decl = TREE_VEC_ELT (decl_map, slot);
1574           DECL_NAME (decl) = name;
1575           SET_DECL_ASSEMBLER_NAME (decl, name);
1576           if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
1577             warning ("bad type in parameter debug info");
1578         }
1579       else
1580         {
1581           tree *ptr;
1582           int end_pc = start_pc + length;
1583           tree decl = build_decl (VAR_DECL, name, type);
1584           if (end_pc > DECL_CODE_LENGTH (current_function_decl))
1585             {
1586               warning_with_decl (decl,
1587                          "bad PC range for debug info for local `%s'");
1588               end_pc = DECL_CODE_LENGTH (current_function_decl);
1589             }
1590
1591           /* Adjust start_pc if necessary so that the local's first
1592              store operation will use the relevant DECL as a
1593              destination. Fore more information, read the leading
1594              comments for expr.c:maybe_adjust_start_pc. */
1595           start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot);
1596
1597           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1598           DECL_LOCAL_SLOT_NUMBER (decl) = slot;
1599           DECL_LOCAL_START_PC (decl) = start_pc;
1600 #if 0
1601           /* FIXME: The range used internally for exceptions and local
1602              variable ranges, is a half-open interval:
1603              start_pc <= pc < end_pc.  However, the range used in the
1604              Java VM spec is inclusive at both ends:
1605              start_pc <= pc <= end_pc. */
1606           end_pc++;
1607 #endif
1608           DECL_LOCAL_END_PC (decl) = end_pc;
1609
1610           /* Now insert the new decl in the proper place in
1611              pending_local_decls.  We are essentially doing an insertion sort,
1612              which works fine, since the list input will normally already
1613              be sorted. */
1614           ptr = &pending_local_decls;
1615           while (*ptr != NULL_TREE
1616                  && (DECL_LOCAL_START_PC (*ptr) > start_pc
1617                      || (DECL_LOCAL_START_PC (*ptr) == start_pc
1618                          && DECL_LOCAL_END_PC (*ptr) < end_pc)))
1619             ptr = &TREE_CHAIN (*ptr);
1620           TREE_CHAIN (decl) = *ptr;
1621           *ptr = decl;
1622         }
1623     }
1624
1625   pending_local_decls = nreverse (pending_local_decls);
1626
1627   /* Fill in default names for the parameters. */
1628   for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
1629        parm != NULL_TREE;  parm = TREE_CHAIN (parm), i++)
1630     {
1631       if (DECL_NAME (parm) == NULL_TREE)
1632         {
1633           int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
1634           if (arg_i == 0)
1635             DECL_NAME (parm) = get_identifier ("this");
1636           else
1637             {
1638               char buffer[12];
1639               sprintf (buffer, "ARG_%d", arg_i);
1640               DECL_NAME (parm) = get_identifier (buffer);
1641             }
1642           SET_DECL_ASSEMBLER_NAME (parm, DECL_NAME (parm));
1643         }
1644     }
1645 }
1646
1647 tree
1648 build_result_decl (fndecl)
1649   tree fndecl;
1650 {
1651   tree restype = TREE_TYPE (TREE_TYPE (fndecl));
1652   /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1653   if (INTEGRAL_TYPE_P (restype)
1654       && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
1655     restype = integer_type_node;
1656   return (DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, restype));
1657 }
1658
1659 void
1660 complete_start_java_method (fndecl)
1661   tree fndecl;
1662 {
1663   if (! flag_emit_class_files)
1664     {
1665       /* Initialize the RTL code for the function.  */
1666       init_function_start (fndecl, input_filename, lineno);
1667
1668       /* Set up parameters and prepare for return, for the function.  */
1669       expand_function_start (fndecl, 0);
1670     }
1671
1672 #if 0
1673       /* If this fcn was already referenced via a block-scope `extern' decl (or
1674          an implicit decl), propagate certain information about the usage. */
1675       if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
1676         TREE_ADDRESSABLE (current_function_decl) = 1;
1677
1678 #endif
1679
1680   if (METHOD_STATIC (fndecl) && ! METHOD_PRIVATE (fndecl)
1681       && ! flag_emit_class_files
1682       && ! DECL_CLINIT_P (fndecl)
1683       && ! CLASS_INTERFACE (TYPE_NAME (current_class)))
1684     {
1685       tree clas = DECL_CONTEXT (fndecl);
1686       tree init = build (CALL_EXPR, void_type_node,
1687                          build_address_of (soft_initclass_node),
1688                          build_tree_list (NULL_TREE, build_class_ref (clas)),
1689                          NULL_TREE);
1690       TREE_SIDE_EFFECTS (init) = 1;
1691       expand_expr_stmt (init);
1692     }
1693
1694   /* Push local variables. Function compiled from source code are
1695      using a different local variables management, and for them,
1696      pushlevel shouldn't be called from here.  */
1697   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1698     {
1699       pushlevel (2);
1700       if (! flag_emit_class_files)
1701         expand_start_bindings (1);
1702     }
1703
1704   if (METHOD_SYNCHRONIZED (fndecl) && ! flag_emit_class_files)
1705     {
1706       /* Wrap function body with a monitorenter plus monitorexit cleanup. */
1707       tree enter, exit, lock;
1708       if (METHOD_STATIC (fndecl))
1709         lock = build_class_ref (DECL_CONTEXT (fndecl));
1710       else
1711         lock = DECL_ARGUMENTS (fndecl);
1712       BUILD_MONITOR_ENTER (enter, lock);
1713       BUILD_MONITOR_EXIT (exit, lock);
1714       if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1715         {
1716           expand_expr_stmt (enter);
1717           expand_decl_cleanup (NULL_TREE, exit);
1718         }
1719       else
1720         {
1721           tree function_body = DECL_FUNCTION_BODY (fndecl);
1722           tree body = BLOCK_EXPR_BODY (function_body);
1723           lock = build (COMPOUND_EXPR, void_type_node,
1724                         enter,
1725                         build (TRY_FINALLY_EXPR, void_type_node, body, exit));
1726           TREE_SIDE_EFFECTS (lock) = 1;
1727           BLOCK_EXPR_BODY (function_body) = lock;
1728         }
1729     }
1730 }
1731
1732 void
1733 start_java_method (fndecl)
1734      tree fndecl;
1735 {
1736   tree tem, *ptr;
1737   int i;
1738
1739   current_function_decl = fndecl;
1740   announce_function (fndecl);
1741
1742   i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
1743   decl_map = make_tree_vec (i);
1744   type_map = (tree *) xrealloc (type_map, i * sizeof (tree));
1745
1746 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1747   fprintf (stderr, "%s:\n", (*decl_printable_name) (fndecl, 2));
1748   current_pc = 0;
1749 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1750   pushlevel (1);  /* Push parameters. */
1751
1752   ptr = &DECL_ARGUMENTS (fndecl);
1753   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
1754        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
1755     {
1756       tree parm_name = NULL_TREE, parm_decl;
1757       tree parm_type = TREE_VALUE (tem);
1758       if (i >= DECL_MAX_LOCALS (fndecl))
1759         abort ();
1760
1761       parm_decl = build_decl (PARM_DECL, parm_name, parm_type);
1762       DECL_CONTEXT (parm_decl) = fndecl;
1763       if (PROMOTE_PROTOTYPES
1764           && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
1765           && INTEGRAL_TYPE_P (parm_type))
1766         parm_type = integer_type_node;
1767       DECL_ARG_TYPE (parm_decl) = parm_type;
1768
1769       *ptr = parm_decl;
1770       ptr = &TREE_CHAIN (parm_decl);
1771
1772       /* Add parm_decl to the decl_map. */
1773       push_jvm_slot (i, parm_decl);
1774
1775       type_map[i] = TREE_TYPE (parm_decl);
1776       if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
1777         {
1778           i++;
1779           type_map[i] = void_type_node;
1780         }
1781     }
1782   *ptr = NULL_TREE;
1783   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
1784
1785   while (i < DECL_MAX_LOCALS(fndecl))
1786     type_map[i++] = NULL_TREE;
1787
1788   build_result_decl (fndecl);
1789   complete_start_java_method (fndecl);
1790 }
1791
1792 void
1793 end_java_method ()
1794 {
1795   tree fndecl = current_function_decl;
1796
1797   expand_end_bindings (getdecls (), 1, 0);
1798   /* pop out of function */
1799   poplevel (1, 1, 0);
1800
1801   /* pop out of its parameters */
1802   poplevel (1, 0, 1);
1803
1804   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1805
1806   /* Generate rtl for function exit.  */
1807   expand_function_end (input_filename, lineno, 0);
1808
1809   /* Run the optimizers and output assembler code for this function. */
1810   rest_of_compilation (fndecl);
1811
1812   current_function_decl = NULL_TREE;
1813 }
1814
1815 /* Mark language-specific parts of T for garbage-collection.  */
1816
1817 void
1818 lang_mark_tree (t)
1819      tree t;
1820 {
1821   if (TREE_CODE (t) == IDENTIFIER_NODE)
1822     {
1823       struct lang_identifier *li = (struct lang_identifier *) t;
1824       ggc_mark_tree (li->global_value);
1825       ggc_mark_tree (li->local_value);
1826       ggc_mark_tree (li->utf8_ref);
1827     }
1828   else if (TREE_CODE (t) == VAR_DECL
1829            || TREE_CODE (t) == PARM_DECL
1830            || TREE_CODE (t) == FIELD_DECL)
1831     {
1832       struct lang_decl_var *ldv =
1833         ((struct lang_decl_var *) DECL_LANG_SPECIFIC (t));
1834       if (ldv)
1835         {
1836           ggc_mark (ldv);
1837           ggc_mark_tree (ldv->slot_chain);
1838           ggc_mark_tree (ldv->am);
1839           ggc_mark_tree (ldv->wfl);
1840         }
1841     }
1842   else if (TREE_CODE (t) == FUNCTION_DECL)
1843     {
1844       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
1845
1846       if (ld)
1847         {
1848           ggc_mark (ld);
1849           ggc_mark_tree (ld->wfl);
1850           ggc_mark_tree (ld->throws_list);
1851           ggc_mark_tree (ld->function_decl_body);
1852           ggc_mark_tree (ld->called_constructor);
1853           ggc_mark_tree (ld->inner_access);
1854           ggc_mark_tree_hash_table (&ld->init_test_table);
1855           ggc_mark_tree_hash_table (&ld->ict);
1856           ggc_mark_tree (ld->smic);
1857         }
1858     }
1859   else if (TYPE_P (t))
1860     {
1861       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
1862
1863       if (lt)
1864         {
1865           ggc_mark (lt);
1866           ggc_mark_tree (lt->signature);
1867           ggc_mark_tree (lt->cpool_data_ref);
1868           ggc_mark_tree (lt->finit_stmt_list);
1869           ggc_mark_tree (lt->clinit_stmt_list);
1870           ggc_mark_tree (lt->ii_block);
1871           ggc_mark_tree (lt->dot_class);
1872           ggc_mark_tree (lt->package_list);
1873         }
1874     }
1875 }