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