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