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