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