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