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