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