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