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, 2001, 2002, 2003, 2004, 2007,
   4    2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.
  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 "coretypes.h"
  31 #include "tree.h"
  32 #include "diagnostic-core.h"
  33 #include "toplev.h"
  34 #include "flags.h"
  35 #include "java-tree.h"
  36 #include "jcf.h"
  37 #include "libfuncs.h"
  38 #include "java-except.h"
  39 #include "ggc.h"
  40 #include "cgraph.h"
  41 #include "tree-inline.h"
  42 #include "target.h"
  43 #include "version.h"
  44 #include "tree-iterator.h"
  45 #include "langhooks.h"
  46 #include "cgraph.h"
  47
  48 #if defined (DEBUG_JAVA_BINDING_LEVELS)
  49 extern void indent (void);
  50 #endif
  51
  52 static tree push_jvm_slot (int, tree);
  53 static tree lookup_name_current_level (tree);
  54 static tree push_promoted_type (const char *, tree);
  55 static struct binding_level *make_binding_level (void);
  56 static tree create_primitive_vtable (const char *);
  57 static tree check_local_unnamed_variable (tree, tree, tree);
  58 static void parse_version (void);
  59
  60
  61 /* The following ABI flags are used in the high-order bits of the version
  62    ID field. The version ID number itself should never be larger than
  63    0xfffff, so it should be safe to use top 12 bits for these flags. */
  64
  65 #define FLAG_BINARYCOMPAT_ABI (1<<31)  /* Class is built with the BC-ABI. */
  66
  67 #define FLAG_BOOTSTRAP_LOADER (1<<30)  /* Used when defining a class that
  68                                           should be loaded by the bootstrap
  69                                           loader.  */
  70
  71 /* If an ABI change is made within a GCC release series, rendering current
  72    binaries incompatible with the old runtimes, this number must be set to
  73    enforce the compatibility rules. */
  74 #define MINOR_BINARYCOMPAT_ABI_VERSION 1
  75
  76 /* The runtime may recognize a variety of BC ABIs (objects generated by
  77    different version of gcj), but will probably always require strict
  78    matching for the ordinary (C++) ABI.  */
  79
  80 /* The version ID of the BC ABI that we generate.  This must be kept in
  81    sync with parse_version(), libgcj, and reality (if the BC format changes,
  82    this must change).  */
  83 #define GCJ_CURRENT_BC_ABI_VERSION \
  84   (4 * 100000 + 0 * 1000 + MINOR_BINARYCOMPAT_ABI_VERSION)
  85
  86 /* The ABI version number.  */
  87 tree gcj_abi_version;
  88
  89 /* Name of the Cloneable class.  */
  90 tree java_lang_cloneable_identifier_node;
  91
  92 /* Name of the Serializable class.  */
  93 tree java_io_serializable_identifier_node;
  94
  95 /* The DECL_MAP is a mapping from (index, type) to a decl node.
  96    If index < max_locals, it is the index of a local variable.
  97    if index >= max_locals, then index-max_locals is a stack slot.
  98    The DECL_MAP mapping is represented as a TREE_VEC whose elements
  99    are a list of decls (VAR_DECL or PARM_DECL) chained by
 100    DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
 101    we search the chain for a decl with a matching TREE_TYPE. */
 102
 103 static GTY(()) tree decl_map;
 104
 105 /* The base_decl_map is contains one variable of ptr_type: this is
 106    used to contain every variable of reference type that is ever
 107    stored in a local variable slot.  */
 108
 109 static GTY(()) tree base_decl_map;
 110
 111 /* An index used to make temporary identifiers unique.  */
 112 static int uniq;
 113
 114 /* A list of local variables VAR_DECLs for this method that we have seen
 115    debug information, but we have not reached their starting (byte) PC yet. */
 116
 117 static GTY(()) tree pending_local_decls;
 118
 119 /* The decl for "_Jv_ResolvePoolEntry".  */
 120 tree soft_resolvepoolentry_node;
 121
 122 /* The decl for the .constants field of an instance of Class.  */
 123 tree constants_field_decl_node;
 124
 125 /* The decl for the .data field of an instance of Class.  */
 126 tree constants_data_field_decl_node;
 127
 128 #if defined(DEBUG_JAVA_BINDING_LEVELS)
 129 int binding_depth = 0;
 130 int is_class_level = 0;
 131 int current_pc;
 132
 133 void
 134 indent (void)
 135 {
 136   int i;
 137
 138   for (i = 0; i < binding_depth*2; i++)
 139     putc (' ', stderr);
 140 }
 141 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
 142
 143 /* True if decl is a named local variable, i.e. if it is an alias
 144    that's used only for debugging purposes.  */
 145
 146 static bool
 147 debug_variable_p (tree decl)
 148 {
 149   if (TREE_CODE (decl) == PARM_DECL)
 150     return false;
 151
 152   if (LOCAL_SLOT_P (decl))
 153     return false;
 154
 155   return true;
 156 }
 157
 158 static tree
 159 push_jvm_slot (int index, tree decl)
 160 {
 161   DECL_CONTEXT (decl) = current_function_decl;
 162   layout_decl (decl, 0);
 163
 164   /* Now link the decl into the decl_map. */
 165   if (DECL_LANG_SPECIFIC (decl) == NULL)
 166     {
 167       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
 168       DECL_LOCAL_START_PC (decl) = 0;
 169       DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
 170       DECL_LOCAL_SLOT_NUMBER (decl) = index;
 171     }
 172   DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
 173   TREE_VEC_ELT (decl_map, index) = decl;
 174
 175   return decl;
 176 }
 177
 178 /* Find the best declaration based upon type.  If 'decl' fits 'type' better
 179    than 'best', return 'decl'.  Otherwise return 'best'.  */
 180
 181 static tree
 182 check_local_unnamed_variable (tree best, tree decl, tree type)
 183 {
 184   tree decl_type = TREE_TYPE (decl);
 185
 186   gcc_assert (! LOCAL_VAR_OUT_OF_SCOPE_P (decl));
 187
 188   /* Use the same decl for all integer types <= 32 bits.  This is
 189      necessary because sometimes a value is stored as (for example)
 190      boolean but loaded as int.  */
 191   if (decl_type == type
 192       || (INTEGRAL_TYPE_P (decl_type)
 193           && INTEGRAL_TYPE_P (type)
 194           && TYPE_PRECISION (decl_type) <= 32
 195           && TYPE_PRECISION (type) <= 32
 196           && TYPE_PRECISION (decl_type) >= TYPE_PRECISION (type))
 197       /*  ptr_type_node is used for null pointers, which are
 198           assignment compatible with everything.  */
 199       || (TREE_CODE (decl_type) == POINTER_TYPE
 200           && type == ptr_type_node)
 201       /* Whenever anyone wants to use a slot that is initially
 202          occupied by a PARM_DECL of pointer type they must get that
 203          decl, even if they asked for a pointer to a different type.
 204          However, if someone wants a scalar variable in a slot that
 205          initially held a pointer arg -- or vice versa -- we create a
 206          new VAR_DECL.
 207
 208          ???: As long as verification is correct, this will be a
 209          compatible type.  But maybe we should create a dummy variable
 210          and replace all references to it with the DECL and a
 211          NOP_EXPR.
 212       */
 213       || (TREE_CODE (decl_type) == POINTER_TYPE
 214           && TREE_CODE (decl) == PARM_DECL
 215           && TREE_CODE (type) == POINTER_TYPE))
 216     {
 217       if (best == NULL_TREE
 218           || (decl_type == type && TREE_TYPE (best) != type))
 219         return decl;
 220     }
 221
 222   return best;
 223 }
 224
 225
 226 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
 227    that is valid at PC (or -1 if any pc).
 228    If there is no existing matching decl, allocate one.  */
 229
 230 tree
 231 find_local_variable (int index, tree type, int pc ATTRIBUTE_UNUSED)
 232 {
 233   tree tmp = TREE_VEC_ELT (decl_map, index);
 234   tree decl = NULL_TREE;
 235
 236   /* Scan through every declaration that has been created in this
 237      slot.  We're only looking for variables that correspond to local
 238      index declarations and PARM_DECLs, not named variables: such
 239      local variables are used only for debugging information.  */
 240   while (tmp != NULL_TREE)
 241     {
 242       if (! debug_variable_p (tmp))
 243         decl = check_local_unnamed_variable (decl, tmp, type);
 244       tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
 245     }
 246
 247   /* gcj has a function called promote_type(), which is used by both
 248      the bytecode compiler and the source compiler.  Unfortunately,
 249      the type systems for the Java VM and the Java language are not
 250      the same: a boolean in the VM promotes to an int, not to a wide
 251      boolean.  If our caller wants something to hold a boolean, that
 252      had better be an int, because that slot might be re-used
 253      later in integer context.  */
 254   if (TREE_CODE (type) == BOOLEAN_TYPE)
 255     type = integer_type_node;
 256
 257   /* If we don't find a match, create one with the type passed in.
 258      The name of the variable is #n#m, which n is the variable index
 259      in the local variable area and m is a dummy identifier for
 260      uniqueness -- multiple variables may share the same local
 261      variable index.  We don't call pushdecl() to push pointer types
 262      into a binding expr because they'll all be replaced by a single
 263      variable that is used for every reference in that local variable
 264      slot.  */
 265   if (! decl)
 266     {
 267       char buf[64];
 268       tree name;
 269       sprintf (buf, "#slot#%d#%d", index, uniq++);
 270       name = get_identifier (buf);
 271       decl = build_decl (input_location, VAR_DECL, name, type);
 272       DECL_IGNORED_P (decl) = 1;
 273       DECL_ARTIFICIAL (decl) = 1;
 274       decl = push_jvm_slot (index, decl);
 275       LOCAL_SLOT_P (decl) = 1;
 276
 277       if (TREE_CODE (type) != POINTER_TYPE)
 278         pushdecl_function_level (decl);
 279     }
 280
 281   /* As well as creating a local variable that matches the type, we
 282      also create a base variable (of ptr_type) that will hold all its
 283      aliases.  */
 284   if (TREE_CODE (type) == POINTER_TYPE
 285       && ! TREE_VEC_ELT (base_decl_map, index))
 286     {
 287       char buf[64];
 288       tree name;
 289       tree base_decl;
 290       sprintf (buf, "#ref#%d#%d", index, uniq++);
 291       name = get_identifier (buf);
 292       base_decl
 293         = TREE_VEC_ELT (base_decl_map, index)
 294         = build_decl (input_location, VAR_DECL, name, ptr_type_node);
 295       pushdecl_function_level (base_decl);
 296       DECL_IGNORED_P (base_decl) = 1;
 297       DECL_ARTIFICIAL (base_decl) = 1;
 298     }
 299
 300   return decl;
 301 }
 302
 303 /* Called during genericization for every variable.  If the variable
 304    is a temporary of pointer type, replace it with a common variable
 305    thath is used to hold all pointer types that are ever stored in
 306    that slot.  Set WANT_LVALUE if you want a variable that is to be
 307    written to.  */
 308
 309 static tree
 310 java_replace_reference (tree var_decl, bool want_lvalue)
 311 {
 312   tree decl_type;
 313
 314   if (! base_decl_map)
 315     return var_decl;
 316
 317   decl_type = TREE_TYPE (var_decl);
 318
 319   if (TREE_CODE (decl_type) == POINTER_TYPE)
 320     {
 321       if (DECL_LANG_SPECIFIC (var_decl)
 322           && LOCAL_SLOT_P (var_decl))
 323         {
 324           int index = DECL_LOCAL_SLOT_NUMBER (var_decl);
 325           tree base_decl = TREE_VEC_ELT (base_decl_map, index);
 326
 327           gcc_assert (base_decl);
 328           if (! want_lvalue)
 329             base_decl = build1 (NOP_EXPR, decl_type, base_decl);
 330
 331           return base_decl;
 332         }
 333     }
 334
 335   return var_decl;
 336 }
 337
 338 /* Helper for java_genericize.  */
 339
 340 tree
 341 java_replace_references (tree *tp, int *walk_subtrees,
 342                          void *data ATTRIBUTE_UNUSED)
 343 {
 344   if (TREE_CODE (*tp) == MODIFY_EXPR)
 345     {
 346       source_location loc = EXPR_LOCATION (*tp);
 347       tree lhs = TREE_OPERAND (*tp, 0);
 348       /* This is specific to the bytecode compiler.  If a variable has
 349          LOCAL_SLOT_P set, replace an assignment to it with an assignment
 350          to the corresponding variable that holds all its aliases.  */
 351       if (TREE_CODE (lhs) == VAR_DECL
 352           && DECL_LANG_SPECIFIC (lhs)
 353           && LOCAL_SLOT_P (lhs)
 354           && TREE_CODE (TREE_TYPE (lhs)) == POINTER_TYPE)
 355         {
 356           tree new_lhs = java_replace_reference (lhs, /* want_lvalue */ true);
 357           tree new_rhs = build1 (NOP_EXPR, TREE_TYPE (new_lhs),
 358                                  TREE_OPERAND (*tp, 1));
 359           tree tem = build2 (MODIFY_EXPR, TREE_TYPE (new_lhs),
 360                              new_lhs, new_rhs);
 361           *tp = build1 (NOP_EXPR, TREE_TYPE (lhs), tem);
 362           SET_EXPR_LOCATION (tem, loc);
 363           SET_EXPR_LOCATION (new_rhs, loc);
 364           SET_EXPR_LOCATION (*tp, loc);
 365         }
 366     }
 367   if (TREE_CODE (*tp) == VAR_DECL)
 368     {
 369       *tp = java_replace_reference (*tp, /* want_lvalue */ false);
 370       *walk_subtrees = 0;
 371     }
 372
 373   return NULL_TREE;
 374 }
 375
 376 /* Same as find_local_index, except that INDEX is a stack index. */
 377
 378 tree
 379 find_stack_slot (int index, tree type)
 380 {
 381   return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
 382                               type, -1);
 383 }
 384
 385 struct GTY(())
 386   binding_level {
 387     /* A chain of _DECL nodes for all variables, constants, functions,
 388      * and typedef types.  These are in the reverse of the order supplied.
 389      */
 390     tree names;
 391
 392     /* For each level, a list of shadowed outer-level local definitions
 393        to be restored when this level is popped.
 394        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 395        whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
 396     tree shadowed;
 397
 398     /* For each level (except not the global one),
 399        a chain of BLOCK nodes for all the levels
 400        that were entered and exited one level down.  */
 401     tree blocks;
 402
 403     /* The binding level which this one is contained in (inherits from).  */
 404     struct binding_level *level_chain;
 405
 406     /* The bytecode PC that marks the end of this level. */
 407     int end_pc;
 408     /* The bytecode PC that marks the start of this level. */
 409     int start_pc;
 410
 411     /* The statements in this binding level.  */
 412     tree stmts;
 413
 414     /* An exception range associated with this binding level.  */
 415     struct eh_range * GTY((skip (""))) exception_range;
 416
 417     /* Binding depth at which this level began.  Used only for debugging.  */
 418     unsigned binding_depth;
 419
 420     /* The location at which this level began.  */
 421     source_location loc;
 422   };
 423
 424 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
 425
 426 /* The binding level currently in effect.  */
 427
 428 static GTY(()) struct binding_level *current_binding_level;
 429
 430 /* A chain of binding_level structures awaiting reuse.  */
 431
 432 static GTY(()) struct binding_level *free_binding_level;
 433
 434 /* The outermost binding level, for names of file scope.
 435    This is created when the compiler is started and exists
 436    through the entire run.  */
 437
 438 static GTY(()) struct binding_level *global_binding_level;
 439
 440 /* The binding level that holds variables declared at the outermost
 441    level within a function body.  */
 442
 443 static struct binding_level *function_binding_level;
 444
 445 /* A PC value bigger than any PC value we may ever may encounter. */
 446
 447 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
 448
 449 /* Binding level structures are initialized by copying this one.  */
 450
 451 static const struct binding_level clear_binding_level
 452 = {
 453     NULL_TREE, /* names */
 454     NULL_TREE, /* shadowed */
 455     NULL_TREE, /* blocks */
 456     NULL_BINDING_LEVEL, /* level_chain */
 457     LARGEST_PC, /* end_pc */
 458     0, /* start_pc */
 459     NULL, /* stmts */
 460     NULL, /* exception_range */
 461     0, /* binding_depth */
 462     0, /* loc */
 463   };
 464
 465 tree java_global_trees[JTI_MAX];
 466
 467 /* Build (and pushdecl) a "promoted type" for all standard
 468    types shorter than int.  */
 469
 470 static tree
 471 push_promoted_type (const char *name, tree actual_type)
 472 {
 473   tree type = make_node (TREE_CODE (actual_type));
 474 #if 1
 475   tree in_min = TYPE_MIN_VALUE (int_type_node);
 476   tree in_max = TYPE_MAX_VALUE (int_type_node);
 477 #else
 478   tree in_min = TYPE_MIN_VALUE (actual_type);
 479   tree in_max = TYPE_MAX_VALUE (actual_type);
 480 #endif
 481   TYPE_MIN_VALUE (type) = copy_node (in_min);
 482   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
 483   TYPE_MAX_VALUE (type) = copy_node (in_max);
 484   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
 485   TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
 486   TYPE_STRING_FLAG (type) = TYPE_STRING_FLAG (actual_type);
 487   layout_type (type);
 488   pushdecl (build_decl (input_location,
 489                         TYPE_DECL, get_identifier (name), type));
 490   return type;
 491 }
 492
 493 /* Return tree that represents a vtable for a primitive array.  */
 494 static tree
 495 create_primitive_vtable (const char *name)
 496 {
 497   tree r;
 498   char buf[50];
 499
 500   sprintf (buf, "_Jv_%sVTable", name);
 501   r = build_decl (input_location,
 502                   VAR_DECL, get_identifier (buf), ptr_type_node);
 503   DECL_EXTERNAL (r) = 1;
 504   return r;
 505 }
 506
 507 /* Parse the version string and compute the ABI version number.  */
 508 static void
 509 parse_version (void)
 510 {
 511   const char *p = version_string;
 512   unsigned int major = 0, minor = 0;
 513   unsigned int abi_version;
 514
 515   /* Skip leading junk.  */
 516   while (*p && !ISDIGIT (*p))
 517     ++p;
 518   gcc_assert (*p);
 519
 520   /* Extract major version.  */
 521   while (ISDIGIT (*p))
 522     {
 523       major = major * 10 + *p - '0';
 524       ++p;
 525     }
 526
 527   gcc_assert (*p == '.' && ISDIGIT (p[1]));
 528   ++p;
 529
 530   /* Extract minor version.  */
 531   while (ISDIGIT (*p))
 532     {
 533       minor = minor * 10 + *p - '0';
 534       ++p;
 535     }
 536
 537   if (flag_indirect_dispatch)
 538     {
 539       abi_version = GCJ_CURRENT_BC_ABI_VERSION;
 540       abi_version |= FLAG_BINARYCOMPAT_ABI;
 541     }
 542   else /* C++ ABI */
 543     {
 544       /* Implicit in this computation is the idea that we won't break the
 545          old-style binary ABI in a sub-minor release (e.g., from 4.0.0 to
 546          4.0.1).  */
 547       abi_version = 100000 * major + 1000 * minor;
 548     }
 549   if (flag_bootstrap_classes)
 550     abi_version |= FLAG_BOOTSTRAP_LOADER;
 551
 552   gcj_abi_version = build_int_cstu (ptr_type_node, abi_version);
 553 }
 554
 555 void
 556 java_init_decl_processing (void)
 557 {
 558   tree endlink;
 559   tree field = NULL_TREE;
 560   tree t;
 561
 562   init_class_processing ();
 563
 564   current_function_decl = NULL;
 565   current_binding_level = NULL_BINDING_LEVEL;
 566   free_binding_level = NULL_BINDING_LEVEL;
 567   pushlevel (0);        /* make the binding_level structure for global names */
 568   global_binding_level = current_binding_level;
 569
 570   /* The code here must be similar to build_common_tree_nodes{,_2} in
 571      tree.c, especially as to the order of initializing common nodes.  */
 572   error_mark_node = make_node (ERROR_MARK);
 573   TREE_TYPE (error_mark_node) = error_mark_node;
 574
 575   /* Create sizetype first - needed for other types. */
 576   initialize_sizetypes ();
 577
 578   byte_type_node = make_signed_type (8);
 579   pushdecl (build_decl (BUILTINS_LOCATION,
 580                         TYPE_DECL, get_identifier ("byte"), byte_type_node));
 581   short_type_node = make_signed_type (16);
 582   pushdecl (build_decl (BUILTINS_LOCATION,
 583                         TYPE_DECL, get_identifier ("short"), short_type_node));
 584   int_type_node = make_signed_type (32);
 585   pushdecl (build_decl (BUILTINS_LOCATION,
 586                         TYPE_DECL, get_identifier ("int"), int_type_node));
 587   long_type_node = make_signed_type (64);
 588   pushdecl (build_decl (BUILTINS_LOCATION,
 589                         TYPE_DECL, get_identifier ("long"), long_type_node));
 590
 591   unsigned_byte_type_node = make_unsigned_type (8);
 592   pushdecl (build_decl (BUILTINS_LOCATION,
 593                         TYPE_DECL, get_identifier ("unsigned byte"),
 594                         unsigned_byte_type_node));
 595   unsigned_short_type_node = make_unsigned_type (16);
 596   pushdecl (build_decl (BUILTINS_LOCATION,
 597                         TYPE_DECL, get_identifier ("unsigned short"),
 598                         unsigned_short_type_node));
 599   unsigned_int_type_node = make_unsigned_type (32);
 600   pushdecl (build_decl (BUILTINS_LOCATION,
 601                         TYPE_DECL, get_identifier ("unsigned int"),
 602                         unsigned_int_type_node));
 603   unsigned_long_type_node = make_unsigned_type (64);
 604   pushdecl (build_decl (BUILTINS_LOCATION,
 605                         TYPE_DECL, get_identifier ("unsigned long"),
 606                         unsigned_long_type_node));
 607
 608   /* This is not a java type, however tree-dfa requires a definition for
 609      size_type_node.  */
 610   size_type_node = make_unsigned_type (POINTER_SIZE);
 611   set_sizetype (size_type_node);
 612
 613   /* Define these next since types below may used them.  */
 614   integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0);
 615   integer_zero_node = build_int_cst (NULL_TREE, 0);
 616   integer_one_node = build_int_cst (NULL_TREE, 1);
 617   integer_two_node = build_int_cst (NULL_TREE, 2);
 618   integer_four_node = build_int_cst (NULL_TREE, 4);
 619   integer_minus_one_node = build_int_cst (NULL_TREE, -1);
 620
 621   /* A few values used for range checking in the lexer.  */
 622   decimal_int_max = build_int_cstu (unsigned_int_type_node, 0x80000000);
 623   decimal_long_max
 624     = double_int_to_tree (unsigned_long_type_node,
 625                           double_int_setbit (double_int_zero, 64));
 626
 627   size_zero_node = size_int (0);
 628   size_one_node = size_int (1);
 629   bitsize_zero_node = bitsize_int (0);
 630   bitsize_one_node = bitsize_int (1);
 631   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
 632
 633   long_zero_node = build_int_cst (long_type_node, 0);
 634
 635   void_type_node = make_node (VOID_TYPE);
 636   pushdecl (build_decl (BUILTINS_LOCATION,
 637                         TYPE_DECL, get_identifier ("void"), void_type_node));
 638   layout_type (void_type_node); /* Uses size_zero_node */
 639
 640   ptr_type_node = build_pointer_type (void_type_node);
 641   const_ptr_type_node
 642     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
 643
 644   t = make_node (VOID_TYPE);
 645   layout_type (t); /* Uses size_zero_node */
 646   return_address_type_node = build_pointer_type (t);
 647
 648   null_pointer_node = build_int_cst (ptr_type_node, 0);
 649
 650   char_type_node = make_node (INTEGER_TYPE);
 651   TYPE_STRING_FLAG (char_type_node) = 1;
 652   TYPE_PRECISION (char_type_node) = 16;
 653   fixup_unsigned_type (char_type_node);
 654   pushdecl (build_decl (BUILTINS_LOCATION,
 655                         TYPE_DECL, get_identifier ("char"), char_type_node));
 656
 657   boolean_type_node = make_node (BOOLEAN_TYPE);
 658   TYPE_PRECISION (boolean_type_node) = 1;
 659   fixup_unsigned_type (boolean_type_node);
 660   pushdecl (build_decl (BUILTINS_LOCATION,
 661                         TYPE_DECL, get_identifier ("boolean"),
 662                         boolean_type_node));
 663   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
 664   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
 665
 666   promoted_byte_type_node
 667     = push_promoted_type ("promoted_byte", byte_type_node);
 668   promoted_short_type_node
 669     = push_promoted_type ("promoted_short", short_type_node);
 670   promoted_char_type_node
 671     = push_promoted_type ("promoted_char", char_type_node);
 672   promoted_boolean_type_node
 673     = push_promoted_type ("promoted_boolean", boolean_type_node);
 674
 675   float_type_node = make_node (REAL_TYPE);
 676   TYPE_PRECISION (float_type_node) = 32;
 677   pushdecl (build_decl (BUILTINS_LOCATION,
 678                         TYPE_DECL, get_identifier ("float"),
 679                         float_type_node));
 680   layout_type (float_type_node);
 681
 682   double_type_node = make_node (REAL_TYPE);
 683   TYPE_PRECISION (double_type_node) = 64;
 684   pushdecl (build_decl (BUILTINS_LOCATION,
 685                         TYPE_DECL, get_identifier ("double"),
 686                         double_type_node));
 687   layout_type (double_type_node);
 688
 689   float_zero_node = build_real (float_type_node, dconst0);
 690   double_zero_node = build_real (double_type_node, dconst0);
 691
 692   /* These are the vtables for arrays of primitives.  */
 693   boolean_array_vtable = create_primitive_vtable ("boolean");
 694   byte_array_vtable = create_primitive_vtable ("byte");
 695   char_array_vtable = create_primitive_vtable ("char");
 696   short_array_vtable = create_primitive_vtable ("short");
 697   int_array_vtable = create_primitive_vtable ("int");
 698   long_array_vtable = create_primitive_vtable ("long");
 699   float_array_vtable = create_primitive_vtable ("float");
 700   double_array_vtable = create_primitive_vtable ("double");
 701
 702   one_elt_array_domain_type = build_index_type (integer_one_node);
 703   utf8const_type = make_node (RECORD_TYPE);
 704   PUSH_FIELD (input_location,
 705               utf8const_type, field, "hash", unsigned_short_type_node);
 706   PUSH_FIELD (input_location,
 707               utf8const_type, field, "length", unsigned_short_type_node);
 708   FINISH_RECORD (utf8const_type);
 709   utf8const_ptr_type = build_pointer_type (utf8const_type);
 710
 711   atable_type = build_array_type (ptr_type_node,
 712                                   one_elt_array_domain_type);
 713   TYPE_NONALIASED_COMPONENT (atable_type) = 1;
 714   atable_ptr_type = build_pointer_type (atable_type);
 715
 716   itable_type = build_array_type (ptr_type_node,
 717                                   one_elt_array_domain_type);
 718   TYPE_NONALIASED_COMPONENT (itable_type) = 1;
 719   itable_ptr_type = build_pointer_type (itable_type);
 720
 721   symbol_type = make_node (RECORD_TYPE);
 722   PUSH_FIELD (input_location,
 723               symbol_type, field, "clname", utf8const_ptr_type);
 724   PUSH_FIELD (input_location, symbol_type, field, "name", utf8const_ptr_type);
 725   PUSH_FIELD (input_location,
 726               symbol_type, field, "signature", utf8const_ptr_type);
 727   FINISH_RECORD (symbol_type);
 728
 729   symbols_array_type = build_array_type (symbol_type,
 730                                          one_elt_array_domain_type);
 731   symbols_array_ptr_type = build_pointer_type (symbols_array_type);
 732
 733   assertion_entry_type = make_node (RECORD_TYPE);
 734   PUSH_FIELD (input_location,
 735               assertion_entry_type, field, "assertion_code", integer_type_node);
 736   PUSH_FIELD (input_location,
 737               assertion_entry_type, field, "op1", utf8const_ptr_type);
 738   PUSH_FIELD (input_location,
 739               assertion_entry_type, field, "op2", utf8const_ptr_type);
 740   FINISH_RECORD (assertion_entry_type);
 741
 742   assertion_table_type = build_array_type (assertion_entry_type,
 743                                            one_elt_array_domain_type);
 744
 745   /* As you're adding items here, please update the code right after
 746      this section, so that the filename containing the source code of
 747      the pre-defined class gets registered correctly. */
 748   unqualified_object_id_node = get_identifier ("Object");
 749   object_type_node = lookup_class (get_identifier ("java.lang.Object"));
 750   object_ptr_type_node = promote_type (object_type_node);
 751   string_type_node = lookup_class (get_identifier ("java.lang.String"));
 752   string_ptr_type_node = promote_type (string_type_node);
 753   class_type_node = lookup_class (get_identifier ("java.lang.Class"));
 754   throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
 755   exception_type_node = lookup_class (get_identifier ("java.lang.Exception"));
 756   runtime_exception_type_node =
 757     lookup_class (get_identifier ("java.lang.RuntimeException"));
 758   error_exception_type_node =
 759     lookup_class (get_identifier ("java.lang.Error"));
 760
 761   rawdata_ptr_type_node
 762     = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
 763
 764   add_predefined_file (get_identifier ("java/lang/Class.java"));
 765   add_predefined_file (get_identifier ("java/lang/Error.java"));
 766   add_predefined_file (get_identifier ("java/lang/Object.java"));
 767   add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
 768   add_predefined_file (get_identifier ("java/lang/String.java"));
 769   add_predefined_file (get_identifier ("java/lang/Throwable.java"));
 770   add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
 771   add_predefined_file (get_identifier ("java/lang/Exception.java"));
 772   add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
 773   add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
 774
 775   methodtable_type = make_node (RECORD_TYPE);
 776   layout_type (methodtable_type);
 777   build_decl (BUILTINS_LOCATION,
 778               TYPE_DECL, get_identifier ("methodtable"), methodtable_type);
 779   methodtable_ptr_type = build_pointer_type (methodtable_type);
 780
 781   TYPE_identifier_node = get_identifier ("TYPE");
 782   init_identifier_node = get_identifier ("<init>");
 783   clinit_identifier_node = get_identifier ("<clinit>");
 784   void_signature_node = get_identifier ("()V");
 785   finalize_identifier_node = get_identifier ("finalize");
 786   this_identifier_node = get_identifier ("this");
 787
 788   java_lang_cloneable_identifier_node = get_identifier ("java.lang.Cloneable");
 789   java_io_serializable_identifier_node =
 790     get_identifier ("java.io.Serializable");
 791
 792   /* for lack of a better place to put this stub call */
 793   init_expr_processing();
 794
 795   constants_type_node = make_node (RECORD_TYPE);
 796   PUSH_FIELD (input_location,
 797               constants_type_node, field, "size", unsigned_int_type_node);
 798   PUSH_FIELD (input_location,
 799               constants_type_node, field, "tags", ptr_type_node);
 800   PUSH_FIELD (input_location,
 801               constants_type_node, field, "data", ptr_type_node);
 802   constants_data_field_decl_node = field;
 803   FINISH_RECORD (constants_type_node);
 804   build_decl (BUILTINS_LOCATION,
 805               TYPE_DECL, get_identifier ("constants"), constants_type_node);
 806
 807   access_flags_type_node = unsigned_short_type_node;
 808
 809   dtable_type = make_node (RECORD_TYPE);
 810   dtable_ptr_type = build_pointer_type (dtable_type);
 811
 812   otable_type = build_array_type (integer_type_node,
 813                                   one_elt_array_domain_type);
 814   TYPE_NONALIASED_COMPONENT (otable_type) = 1;
 815   otable_ptr_type = build_pointer_type (otable_type);
 816
 817   PUSH_FIELD (input_location,
 818               object_type_node, field, "vtable", dtable_ptr_type);
 819   DECL_FCONTEXT (field) = object_type_node;
 820   TYPE_VFIELD (object_type_node) = field;
 821
 822   /* This isn't exactly true, but it is what we have in the source.
 823      There is an unresolved issue here, which is whether the vtable
 824      should be marked by the GC.  */
 825   if (! flag_hash_synchronization)
 826     PUSH_FIELD (input_location, object_type_node, field, "sync_info",
 827                 build_pointer_type (object_type_node));
 828   for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = DECL_CHAIN (t))
 829     FIELD_PRIVATE (t) = 1;
 830   FINISH_RECORD (object_type_node);
 831
 832   field_type_node = make_node (RECORD_TYPE);
 833   field_ptr_type_node = build_pointer_type (field_type_node);
 834   method_type_node = make_node (RECORD_TYPE);
 835   method_ptr_type_node = build_pointer_type (method_type_node);
 836
 837   set_super_info (0, class_type_node, object_type_node, 0);
 838   set_super_info (0, string_type_node, object_type_node, 0);
 839   class_ptr_type = build_pointer_type (class_type_node);
 840
 841   PUSH_FIELD (input_location,
 842               class_type_node, field, "next_or_version", class_ptr_type);
 843   PUSH_FIELD (input_location,
 844               class_type_node, field, "name", utf8const_ptr_type);
 845   PUSH_FIELD (input_location,
 846               class_type_node, field, "accflags", access_flags_type_node);
 847   PUSH_FIELD (input_location,
 848               class_type_node, field, "superclass", class_ptr_type);
 849   PUSH_FIELD (input_location,
 850               class_type_node, field, "constants", constants_type_node);
 851   constants_field_decl_node = field;
 852   PUSH_FIELD (input_location,
 853               class_type_node, field, "methods", method_ptr_type_node);
 854   PUSH_FIELD (input_location,
 855               class_type_node, field, "method_count", short_type_node);
 856   PUSH_FIELD (input_location,
 857               class_type_node, field, "vtable_method_count", short_type_node);
 858   PUSH_FIELD (input_location,
 859               class_type_node, field, "fields", field_ptr_type_node);
 860   PUSH_FIELD (input_location,
 861               class_type_node, field, "size_in_bytes", int_type_node);
 862   PUSH_FIELD (input_location,
 863               class_type_node, field, "field_count", short_type_node);
 864   PUSH_FIELD (input_location,
 865               class_type_node, field, "static_field_count", short_type_node);
 866   PUSH_FIELD (input_location,
 867               class_type_node, field, "vtable", dtable_ptr_type);
 868   PUSH_FIELD (input_location,
 869               class_type_node, field, "otable", otable_ptr_type);
 870   PUSH_FIELD (input_location,
 871               class_type_node, field, "otable_syms",
 872               symbols_array_ptr_type);
 873   PUSH_FIELD (input_location,
 874               class_type_node, field, "atable", atable_ptr_type);
 875   PUSH_FIELD (input_location,
 876               class_type_node, field, "atable_syms",
 877               symbols_array_ptr_type);
 878   PUSH_FIELD (input_location,
 879               class_type_node, field, "itable", itable_ptr_type);
 880   PUSH_FIELD (input_location, class_type_node, field, "itable_syms",
 881               symbols_array_ptr_type);
 882   PUSH_FIELD (input_location,
 883               class_type_node, field, "catch_classes", ptr_type_node);
 884   PUSH_FIELD (input_location, class_type_node, field, "interfaces",
 885               build_pointer_type (class_ptr_type));
 886   PUSH_FIELD (input_location, class_type_node, field, "loader", ptr_type_node);
 887   PUSH_FIELD (input_location,
 888               class_type_node, field, "interface_count", short_type_node);
 889   PUSH_FIELD (input_location, class_type_node, field, "state", byte_type_node);
 890   PUSH_FIELD (input_location, class_type_node, field, "thread", ptr_type_node);
 891   PUSH_FIELD (input_location,
 892               class_type_node, field, "depth", short_type_node);
 893   PUSH_FIELD (input_location,
 894               class_type_node, field, "ancestors", ptr_type_node);
 895   PUSH_FIELD (input_location, class_type_node, field, "idt", ptr_type_node);
 896   PUSH_FIELD (input_location,
 897               class_type_node, field, "arrayclass", ptr_type_node);
 898   PUSH_FIELD (input_location,
 899               class_type_node, field, "protectionDomain", ptr_type_node);
 900   PUSH_FIELD (input_location,
 901               class_type_node, field, "assertion_table", ptr_type_node);
 902   PUSH_FIELD (input_location,
 903               class_type_node, field, "hack_signers", ptr_type_node);
 904   PUSH_FIELD (input_location, class_type_node, field, "chain", ptr_type_node);
 905   PUSH_FIELD (input_location,
 906               class_type_node, field, "aux_info", ptr_type_node);
 907   PUSH_FIELD (input_location, class_type_node, field, "engine", ptr_type_node);
 908   PUSH_FIELD (input_location,
 909               class_type_node, field, "reflection_data", ptr_type_node);
 910   for (t = TYPE_FIELDS (class_type_node);  t != NULL_TREE;  t = DECL_CHAIN (t))
 911     FIELD_PRIVATE (t) = 1;
 912   push_super_field (class_type_node, object_type_node);
 913
 914   FINISH_RECORD (class_type_node);
 915   build_decl (BUILTINS_LOCATION,
 916               TYPE_DECL, get_identifier ("Class"), class_type_node);
 917
 918   field_info_union_node = make_node (UNION_TYPE);
 919   PUSH_FIELD (input_location,
 920               field_info_union_node, field, "boffset", int_type_node);
 921   PUSH_FIELD (input_location,
 922               field_info_union_node, field, "addr", ptr_type_node);
 923   layout_type (field_info_union_node);
 924
 925   PUSH_FIELD (input_location,
 926               field_type_node, field, "name", utf8const_ptr_type);
 927   PUSH_FIELD (input_location, field_type_node, field, "type", class_ptr_type);
 928   PUSH_FIELD (input_location,
 929               field_type_node, field, "accflags", access_flags_type_node);
 930   PUSH_FIELD (input_location,
 931               field_type_node, field, "bsize", unsigned_short_type_node);
 932   PUSH_FIELD (input_location,
 933               field_type_node, field, "info", field_info_union_node);
 934   FINISH_RECORD (field_type_node);
 935   build_decl (BUILTINS_LOCATION,
 936               TYPE_DECL, get_identifier ("Field"), field_type_node);
 937
 938   nativecode_ptr_array_type_node
 939     = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
 940
 941   PUSH_FIELD (input_location,
 942               dtable_type, field, "class", class_ptr_type);
 943   PUSH_FIELD (input_location,
 944               dtable_type, field, "methods", nativecode_ptr_array_type_node);
 945   FINISH_RECORD (dtable_type);
 946   build_decl (BUILTINS_LOCATION,
 947               TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
 948
 949   jexception_type = make_node (RECORD_TYPE);
 950   PUSH_FIELD (input_location,
 951               jexception_type, field, "start_pc", ptr_type_node);
 952   PUSH_FIELD (input_location, jexception_type, field, "end_pc", ptr_type_node);
 953   PUSH_FIELD (input_location,
 954               jexception_type, field, "handler_pc", ptr_type_node);
 955   PUSH_FIELD (input_location,
 956               jexception_type, field, "catch_type", class_ptr_type);
 957   FINISH_RECORD (jexception_type);
 958   build_decl (BUILTINS_LOCATION,
 959               TYPE_DECL, get_identifier ("jexception"), field_type_node);
 960   jexception_ptr_type = build_pointer_type (jexception_type);
 961
 962   lineNumberEntry_type = make_node (RECORD_TYPE);
 963   PUSH_FIELD (input_location,
 964               lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
 965   PUSH_FIELD (input_location,
 966               lineNumberEntry_type, field, "start_pc", ptr_type_node);
 967   FINISH_RECORD (lineNumberEntry_type);
 968
 969   lineNumbers_type = make_node (RECORD_TYPE);
 970   PUSH_FIELD (input_location,
 971               lineNumbers_type, field, "length", unsigned_int_type_node);
 972   FINISH_RECORD (lineNumbers_type);
 973
 974   PUSH_FIELD (input_location,
 975               method_type_node, field, "name", utf8const_ptr_type);
 976   PUSH_FIELD (input_location,
 977               method_type_node, field, "signature", utf8const_ptr_type);
 978   PUSH_FIELD (input_location,
 979               method_type_node, field, "accflags", access_flags_type_node);
 980   PUSH_FIELD (input_location,
 981               method_type_node, field, "index", unsigned_short_type_node);
 982   PUSH_FIELD (input_location,
 983               method_type_node, field, "ncode", nativecode_ptr_type_node);
 984   PUSH_FIELD (input_location,
 985               method_type_node, field, "throws", ptr_type_node);
 986   FINISH_RECORD (method_type_node);
 987   build_decl (BUILTINS_LOCATION,
 988               TYPE_DECL, get_identifier ("Method"), method_type_node);
 989
 990   endlink = end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
 991
 992   t = tree_cons (NULL_TREE, class_ptr_type, endlink);
 993   alloc_object_node = add_builtin_function ("_Jv_AllocObject",
 994                                             build_function_type (ptr_type_node, t),
 995                                             0, NOT_BUILT_IN, NULL, NULL_TREE);
 996   DECL_IS_MALLOC (alloc_object_node) = 1;
 997   alloc_no_finalizer_node =
 998     add_builtin_function ("_Jv_AllocObjectNoFinalizer",
 999                           build_function_type (ptr_type_node, t),
1000                           0, NOT_BUILT_IN, NULL, NULL_TREE);
1001   DECL_IS_MALLOC (alloc_no_finalizer_node) = 1;
1002
1003   t = tree_cons (NULL_TREE, ptr_type_node, endlink);
1004   soft_initclass_node = add_builtin_function ("_Jv_InitClass",
1005                                               build_function_type (void_type_node,
1006                                                                    t),
1007                                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1008   t = tree_cons (NULL_TREE, class_ptr_type,
1009                  tree_cons (NULL_TREE, int_type_node, endlink));
1010   soft_resolvepoolentry_node
1011     = add_builtin_function ("_Jv_ResolvePoolEntry",
1012                             build_function_type (ptr_type_node, t),
1013                             0,NOT_BUILT_IN, NULL, NULL_TREE);
1014   DECL_PURE_P (soft_resolvepoolentry_node) = 1;
1015   throw_node = add_builtin_function ("_Jv_Throw",
1016                                      build_function_type (void_type_node, t),
1017                                      0, NOT_BUILT_IN, NULL, NULL_TREE);
1018   /* Mark throw_nodes as `noreturn' functions with side effects.  */
1019   TREE_THIS_VOLATILE (throw_node) = 1;
1020   TREE_SIDE_EFFECTS (throw_node) = 1;
1021
1022   t = build_function_type (void_type_node, tree_cons (NULL_TREE, ptr_type_node,
1023                                                       endlink));
1024   soft_monitorenter_node
1025     = add_builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN,
1026                             NULL, NULL_TREE);
1027   soft_monitorexit_node
1028     = add_builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN,
1029                             NULL, NULL_TREE);
1030
1031   t = tree_cons (NULL_TREE, ptr_type_node,
1032                  tree_cons (NULL_TREE, int_type_node, endlink));
1033   soft_newarray_node
1034       = add_builtin_function ("_Jv_NewPrimArray",
1035                               build_function_type (ptr_type_node, t),
1036                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1037   DECL_IS_MALLOC (soft_newarray_node) = 1;
1038
1039   t = tree_cons (NULL_TREE, int_type_node,
1040                  tree_cons (NULL_TREE, class_ptr_type,
1041                             tree_cons (NULL_TREE, object_ptr_type_node,
1042                                        endlink)));
1043   soft_anewarray_node
1044       = add_builtin_function ("_Jv_NewObjectArray",
1045                               build_function_type (ptr_type_node, t),
1046                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1047   DECL_IS_MALLOC (soft_anewarray_node) = 1;
1048
1049   /* There is no endlink here because _Jv_NewMultiArray is a varargs
1050      function.  */
1051   t = tree_cons (NULL_TREE, ptr_type_node,
1052                  tree_cons (NULL_TREE, int_type_node, NULL_TREE));
1053   soft_multianewarray_node
1054       = add_builtin_function ("_Jv_NewMultiArray",
1055                               build_function_type (ptr_type_node, t),
1056                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1057   DECL_IS_MALLOC (soft_multianewarray_node) = 1;
1058
1059   t = build_function_type (void_type_node,
1060                            tree_cons (NULL_TREE, int_type_node, endlink));
1061   soft_badarrayindex_node
1062       = add_builtin_function ("_Jv_ThrowBadArrayIndex", t,
1063                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1064   /* Mark soft_badarrayindex_node as a `noreturn' function with side
1065      effects.  */
1066   TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
1067   TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
1068
1069   soft_nullpointer_node
1070     = add_builtin_function ("_Jv_ThrowNullPointerException",
1071                             build_function_type (void_type_node, endlink),
1072                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1073   /* Mark soft_nullpointer_node as a `noreturn' function with side
1074      effects.  */
1075   TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
1076   TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
1077
1078   soft_abstractmethod_node
1079     = add_builtin_function ("_Jv_ThrowAbstractMethodError",
1080                             build_function_type (void_type_node, endlink),
1081                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1082   /* Mark soft_abstractmethod_node as a `noreturn' function with side
1083      effects.  */
1084   TREE_THIS_VOLATILE (soft_abstractmethod_node) = 1;
1085   TREE_SIDE_EFFECTS (soft_abstractmethod_node) = 1;
1086
1087   soft_nosuchfield_node
1088     = add_builtin_function ("_Jv_ThrowNoSuchFieldError",
1089                             build_function_type (void_type_node, endlink),
1090                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1091   /* Mark soft_nosuchfield_node as a `noreturn' function with side
1092      effects.  */
1093   TREE_THIS_VOLATILE (soft_nosuchfield_node) = 1;
1094   TREE_SIDE_EFFECTS (soft_nosuchfield_node) = 1;
1095
1096   t = tree_cons (NULL_TREE, class_ptr_type,
1097                  tree_cons (NULL_TREE, object_ptr_type_node, endlink));
1098   soft_checkcast_node
1099     = add_builtin_function ("_Jv_CheckCast",
1100                             build_function_type (ptr_type_node, t),
1101                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1102   t = tree_cons (NULL_TREE, object_ptr_type_node,
1103                  tree_cons (NULL_TREE, class_ptr_type, endlink));
1104   soft_instanceof_node
1105     = add_builtin_function ("_Jv_IsInstanceOf",
1106                             build_function_type (boolean_type_node, t),
1107                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1108   DECL_PURE_P (soft_instanceof_node) = 1;
1109   t = tree_cons (NULL_TREE, object_ptr_type_node,
1110                  tree_cons (NULL_TREE, object_ptr_type_node, endlink));
1111   soft_checkarraystore_node
1112     = add_builtin_function ("_Jv_CheckArrayStore",
1113                             build_function_type (void_type_node, t),
1114                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1115   t = tree_cons (NULL_TREE, ptr_type_node,
1116                  tree_cons (NULL_TREE, ptr_type_node,
1117                             tree_cons (NULL_TREE, int_type_node, endlink)));
1118   soft_lookupinterfacemethod_node
1119     = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
1120                             build_function_type (ptr_type_node, t),
1121                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1122   DECL_PURE_P (soft_lookupinterfacemethod_node) = 1;
1123   t = tree_cons (NULL_TREE, ptr_type_node,
1124                  tree_cons (NULL_TREE, ptr_type_node,
1125                             tree_cons (NULL_TREE, ptr_type_node, endlink)));
1126   soft_lookupinterfacemethodbyname_node
1127     = add_builtin_function ("_Jv_LookupInterfaceMethod",
1128                             build_function_type (ptr_type_node, t),
1129                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1130   t = tree_cons (NULL_TREE, object_ptr_type_node,
1131                  tree_cons (NULL_TREE, ptr_type_node,
1132                             tree_cons (NULL_TREE, ptr_type_node,
1133                                        tree_cons (NULL_TREE, int_type_node,
1134                                                   endlink))));
1135   soft_lookupjnimethod_node
1136     = add_builtin_function ("_Jv_LookupJNIMethod",
1137                             build_function_type (ptr_type_node, t),
1138                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1139   t = tree_cons (NULL_TREE, ptr_type_node, endlink);
1140   soft_getjnienvnewframe_node
1141     = add_builtin_function ("_Jv_GetJNIEnvNewFrame",
1142                             build_function_type (ptr_type_node, t),
1143                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1144   soft_jnipopsystemframe_node
1145     = add_builtin_function ("_Jv_JNI_PopSystemFrame",
1146                             build_function_type (void_type_node, t),
1147                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1148
1149   t = tree_cons (NULL_TREE, object_ptr_type_node, endlink);
1150   soft_unwrapjni_node
1151     = add_builtin_function ("_Jv_UnwrapJNIweakReference",
1152                             build_function_type (object_ptr_type_node, t),
1153                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1154
1155   t = tree_cons (NULL_TREE, int_type_node,
1156                  tree_cons (NULL_TREE, int_type_node, endlink));
1157   soft_idiv_node
1158     = add_builtin_function ("_Jv_divI",
1159                             build_function_type (int_type_node, t),
1160                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1161
1162   soft_irem_node
1163     = add_builtin_function ("_Jv_remI",
1164                             build_function_type (int_type_node, t),
1165                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1166
1167   t = tree_cons (NULL_TREE, long_type_node,
1168                  tree_cons (NULL_TREE, long_type_node, endlink));
1169   soft_ldiv_node
1170     = add_builtin_function ("_Jv_divJ",
1171                             build_function_type (long_type_node, t),
1172                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1173
1174   soft_lrem_node
1175     = add_builtin_function ("_Jv_remJ",
1176                             build_function_type (long_type_node, t),
1177                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1178
1179   initialize_builtins ();
1180
1181   soft_fmod_node = built_in_decls[BUILT_IN_FMOD];
1182
1183   parse_version ();
1184 }
1185
1186
1187 /* Look up NAME in the current binding level and its superiors
1188    in the namespace of variables, functions and typedefs.
1189    Return a ..._DECL node of some kind representing its definition,
1190    or return 0 if it is undefined.  */
1191
1192 tree
1193 lookup_name (tree name)
1194 {
1195   tree val;
1196   if (current_binding_level != global_binding_level
1197       && IDENTIFIER_LOCAL_VALUE (name))
1198     val = IDENTIFIER_LOCAL_VALUE (name);
1199   else
1200     val = IDENTIFIER_GLOBAL_VALUE (name);
1201   return val;
1202 }
1203
1204 /* Similar to `lookup_name' but look only at current binding level and
1205    the previous one if it's the parameter level.  */
1206
1207 static tree
1208 lookup_name_current_level (tree name)
1209 {
1210   tree t;
1211
1212   if (current_binding_level == global_binding_level)
1213     return IDENTIFIER_GLOBAL_VALUE (name);
1214
1215   if (IDENTIFIER_LOCAL_VALUE (name) == 0)
1216     return 0;
1217
1218   for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
1219     if (DECL_NAME (t) == name)
1220       break;
1221
1222   return t;
1223 }
1224
1225 /* Record a decl-node X as belonging to the current lexical scope.
1226    Check for errors (such as an incompatible declaration for the same
1227    name already seen in the same scope).
1228
1229    Returns either X or an old decl for the same name.
1230    If an old decl is returned, it may have been smashed
1231    to agree with what X says.  */
1232
1233 tree
1234 pushdecl (tree x)
1235 {
1236   tree t;
1237   tree name = DECL_NAME (x);
1238   struct binding_level *b = current_binding_level;
1239
1240   if (TREE_CODE (x) != TYPE_DECL)
1241     DECL_CONTEXT (x) = current_function_decl;
1242   if (name)
1243     {
1244       t = lookup_name_current_level (name);
1245       if (t != 0 && t == error_mark_node)
1246         /* error_mark_node is 0 for a while during initialization!  */
1247         {
1248           t = 0;
1249           error ("%q+D used prior to declaration", x);
1250         }
1251
1252       /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1253          to point to the TYPE_DECL.
1254          Since Java does not have typedefs, a type can only have
1255          one (true) name, given by a class, interface, or builtin. */
1256       if (TREE_CODE (x) == TYPE_DECL
1257           && TYPE_NAME (TREE_TYPE (x)) == 0
1258           && TREE_TYPE (x) != error_mark_node)
1259         {
1260           TYPE_NAME (TREE_TYPE (x)) = x;
1261           TYPE_STUB_DECL (TREE_TYPE (x)) = x;
1262         }
1263
1264       /* This name is new in its binding level.
1265          Install the new declaration and return it.  */
1266       if (b == global_binding_level)
1267         {
1268           /* Install a global value.  */
1269
1270           IDENTIFIER_GLOBAL_VALUE (name) = x;
1271         }
1272       else
1273         {
1274           /* Here to install a non-global value.  */
1275           tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1276           IDENTIFIER_LOCAL_VALUE (name) = x;
1277
1278           /* If storing a local value, there may already be one (inherited).
1279              If so, record it for restoration when this binding level ends.  */
1280           if (oldlocal != 0)
1281             b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1282         }
1283     }
1284
1285   /* Put decls on list in reverse order.
1286      We will reverse them later if necessary.  */
1287   DECL_CHAIN (x) = b->names;
1288   b->names = x;
1289
1290   return x;
1291 }
1292
1293 void
1294 pushdecl_force_head (tree x)
1295 {
1296   current_binding_level->names = x;
1297 }
1298
1299 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
1300
1301 tree
1302 pushdecl_top_level (tree x)
1303 {
1304   tree t;
1305   struct binding_level *b = current_binding_level;
1306
1307   current_binding_level = global_binding_level;
1308   t = pushdecl (x);
1309   current_binding_level = b;
1310   return t;
1311 }
1312
1313 /* Like pushdecl, only it places X in FUNCTION_BINDING_LEVEL, if appropriate.  */
1314
1315 tree
1316 pushdecl_function_level (tree x)
1317 {
1318   tree t;
1319   struct binding_level *b = current_binding_level;
1320
1321   current_binding_level = function_binding_level;
1322   t = pushdecl (x);
1323   current_binding_level = b;
1324   return t;
1325 }
1326
1327 /* Nonzero if we are currently in the global binding level.  */
1328
1329 int
1330 global_bindings_p (void)
1331 {
1332   return current_binding_level == global_binding_level;
1333 }
1334
1335 /* Return the list of declarations of the current level.
1336    Note that this list is in reverse order unless/until
1337    you nreverse it; and when you do nreverse it, you must
1338    store the result back using `storedecls' or you will lose.  */
1339
1340 tree
1341 getdecls (void)
1342 {
1343   return current_binding_level->names;
1344 }
1345
1346 /* Create a new `struct binding_level'.  */
1347
1348 static struct binding_level *
1349 make_binding_level (void)
1350 {
1351   /* NOSTRICT */
1352   return ggc_alloc_cleared_binding_level ();
1353 }
1354
1355 void
1356 pushlevel (int unused ATTRIBUTE_UNUSED)
1357 {
1358   struct binding_level *newlevel = NULL_BINDING_LEVEL;
1359
1360   /* Reuse or create a struct for this binding level.  */
1361
1362   if (free_binding_level)
1363     {
1364       newlevel = free_binding_level;
1365       free_binding_level = free_binding_level->level_chain;
1366     }
1367   else
1368     {
1369       newlevel = make_binding_level ();
1370     }
1371
1372   /* Add this level to the front of the chain (stack) of levels that
1373      are active.  */
1374
1375   *newlevel = clear_binding_level;
1376   newlevel->level_chain = current_binding_level;
1377   newlevel->loc = input_location;
1378   current_binding_level = newlevel;
1379 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1380   newlevel->binding_depth = binding_depth;
1381   indent ();
1382   fprintf (stderr, "push %s level %p pc %d\n",
1383            (is_class_level) ? "class" : "block", newlevel, current_pc);
1384   is_class_level = 0;
1385   binding_depth++;
1386 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1387 }
1388
1389 /* Exit a binding level.
1390    Pop the level off, and restore the state of the identifier-decl mappings
1391    that were in effect when this level was entered.
1392
1393    If KEEP is nonzero, this level had explicit declarations, so
1394    and create a "block" (a BLOCK node) for the level
1395    to record its declarations and subblocks for symbol table output.
1396
1397    If FUNCTIONBODY is nonzero, this level is the body of a function,
1398    so create a block as if KEEP were set and also clear out all
1399    label names.
1400
1401    If REVERSE is nonzero, reverse the order of decls before putting
1402    them into the BLOCK.  */
1403
1404 tree
1405 poplevel (int keep, int reverse, int functionbody)
1406 {
1407   tree link;
1408   /* The chain of decls was accumulated in reverse order.
1409      Put it into forward order, just for cleanliness.  */
1410   tree decls;
1411   tree subblocks = current_binding_level->blocks;
1412   tree block = 0;
1413   tree decl;
1414   tree bind = 0;
1415
1416 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1417   binding_depth--;
1418   indent ();
1419   if (current_binding_level->end_pc != LARGEST_PC)
1420     fprintf (stderr, "pop  %s level %p pc %d (end pc %d)\n",
1421              (is_class_level) ? "class" : "block", current_binding_level, current_pc,
1422              current_binding_level->end_pc);
1423   else
1424     fprintf (stderr, "pop  %s level %p pc %d\n",
1425              (is_class_level) ? "class" : "block", current_binding_level, current_pc);
1426 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1427
1428   /* Get the decls in the order they were written.
1429      Usually current_binding_level->names is in reverse order.
1430      But parameter decls were previously put in forward order.  */
1431
1432   if (reverse)
1433     current_binding_level->names
1434       = decls = nreverse (current_binding_level->names);
1435   else
1436     decls = current_binding_level->names;
1437
1438   for (decl = decls; decl; decl = DECL_CHAIN (decl))
1439     if (TREE_CODE (decl) == VAR_DECL
1440         && DECL_LANG_SPECIFIC (decl) != NULL
1441         && DECL_LOCAL_SLOT_NUMBER (decl))
1442       LOCAL_VAR_OUT_OF_SCOPE_P (decl) = 1;
1443
1444   /* If there were any declarations in that level,
1445      or if this level is a function body,
1446      create a BLOCK to record them for the life of this function.  */
1447
1448   block = 0;
1449   if (keep || functionbody)
1450     {
1451       block = make_node (BLOCK);
1452       TREE_TYPE (block) = void_type_node;
1453     }
1454
1455   if (current_binding_level->exception_range)
1456     expand_end_java_handler (current_binding_level->exception_range);
1457
1458   if (block != 0)
1459     {
1460       /* If any statements have been generated at this level, create a
1461          BIND_EXPR to hold them and copy the variables to it.  This
1462          only applies to the bytecode compiler.  */
1463       if (current_binding_level->stmts)
1464         {
1465           tree decl = decls;
1466           tree *var = &BLOCK_VARS (block);
1467
1468           /* Copy decls from names list, ignoring labels.  */
1469           while (decl)
1470             {
1471               tree next = DECL_CHAIN (decl);
1472               if (TREE_CODE (decl) != LABEL_DECL)
1473                 {
1474                   *var = decl;
1475                   var = &DECL_CHAIN (decl);
1476                 }
1477               decl = next;
1478             }
1479           *var = NULL;
1480
1481           bind = build3 (BIND_EXPR, TREE_TYPE (block), BLOCK_VARS (block),
1482                          BLOCK_EXPR_BODY (block), block);
1483           BIND_EXPR_BODY (bind) = current_binding_level->stmts;
1484
1485           if (BIND_EXPR_BODY (bind)
1486               && TREE_SIDE_EFFECTS (BIND_EXPR_BODY (bind)))
1487             TREE_SIDE_EFFECTS (bind) = 1;
1488
1489           /* FIXME: gimplifier brain damage.  */
1490           if (BIND_EXPR_BODY (bind) == NULL)
1491             BIND_EXPR_BODY (bind) = build_java_empty_stmt ();
1492
1493           SET_EXPR_LOCATION (bind, current_binding_level->loc);
1494
1495           current_binding_level->stmts = NULL;
1496         }
1497       else
1498         {
1499           BLOCK_VARS (block) = decls;
1500         }
1501       BLOCK_SUBBLOCKS (block) = subblocks;
1502     }
1503
1504   /* In each subblock, record that this is its superior.  */
1505
1506   for (link = subblocks; link; link = TREE_CHAIN (link))
1507     BLOCK_SUPERCONTEXT (link) = block;
1508
1509   /* Clear out the meanings of the local variables of this level.  */
1510
1511   for (link = decls; link; link = DECL_CHAIN (link))
1512     {
1513       tree name = DECL_NAME (link);
1514       if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
1515         {
1516           /* If the ident. was used or addressed via a local extern decl,
1517              don't forget that fact.  */
1518           if (DECL_EXTERNAL (link))
1519             {
1520               if (TREE_USED (link))
1521                 TREE_USED (name) = 1;
1522               if (TREE_ADDRESSABLE (link))
1523                 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1524             }
1525           IDENTIFIER_LOCAL_VALUE (name) = 0;
1526         }
1527     }
1528
1529   /* Restore all name-meanings of the outer levels
1530      that were shadowed by this level.  */
1531
1532   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1533     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1534
1535   /* If the level being exited is the top level of a function,
1536      check over all the labels, and clear out the current
1537      (function local) meanings of their names.  */
1538
1539   if (functionbody)
1540     {
1541       /* If this is the top level block of a function,
1542          the vars are the function's parameters.
1543          Don't leave them in the BLOCK because they are
1544          found in the FUNCTION_DECL instead.  */
1545
1546       BLOCK_VARS (block) = 0;
1547     }
1548
1549   /* Pop the current level, and free the structure for reuse.  */
1550
1551   {
1552     struct binding_level *level = current_binding_level;
1553     current_binding_level = current_binding_level->level_chain;
1554
1555     level->level_chain = free_binding_level;
1556     free_binding_level = level;
1557   }
1558
1559   /* Dispose of the block that we just made inside some higher level.  */
1560   if (functionbody)
1561     {
1562       DECL_INITIAL (current_function_decl) = block;
1563       DECL_SAVED_TREE (current_function_decl) = bind;
1564     }
1565   else
1566     {
1567       if (block)
1568         {
1569           current_binding_level->blocks
1570             = chainon (current_binding_level->blocks, block);
1571         }
1572       /* If we did not make a block for the level just exited,
1573          any blocks made for inner levels
1574          (since they cannot be recorded as subblocks in that level)
1575          must be carried forward so they will later become subblocks
1576          of something else.  */
1577       else if (subblocks)
1578         current_binding_level->blocks
1579           = chainon (current_binding_level->blocks, subblocks);
1580
1581       if (bind)
1582         java_add_stmt (bind);
1583     }
1584
1585   if (block)
1586     TREE_USED (block) = 1;
1587   return block;
1588 }
1589
1590 void
1591 maybe_pushlevels (int pc)
1592 {
1593 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1594   current_pc = pc;
1595 #endif
1596
1597   while (pending_local_decls != NULL_TREE &&
1598          DECL_LOCAL_START_PC (pending_local_decls) <= pc)
1599     {
1600       tree *ptr = &pending_local_decls;
1601       tree decl = *ptr, next;
1602       int end_pc = DECL_LOCAL_END_PC (decl);
1603
1604       while (*ptr != NULL_TREE
1605              && DECL_LOCAL_START_PC (*ptr) <= pc
1606              && DECL_LOCAL_END_PC (*ptr) == end_pc)
1607         ptr = &DECL_CHAIN (*ptr);
1608       pending_local_decls = *ptr;
1609       *ptr = NULL_TREE;
1610
1611       /* Force non-nested range to be nested in current range by
1612          truncating variable lifetimes. */
1613       if (end_pc > current_binding_level->end_pc)
1614         {
1615           tree t;
1616           end_pc = current_binding_level->end_pc;
1617           for (t = decl; t != NULL_TREE; t = DECL_CHAIN (t))
1618             DECL_LOCAL_END_PC (t) = end_pc;
1619         }
1620
1621       maybe_start_try (pc, end_pc);
1622
1623       pushlevel (1);
1624
1625       current_binding_level->end_pc = end_pc;
1626       current_binding_level->start_pc = pc;
1627       current_binding_level->names = NULL;
1628       for ( ; decl != NULL_TREE; decl = next)
1629         {
1630           int index = DECL_LOCAL_SLOT_NUMBER (decl);
1631           tree base_decl;
1632           next = DECL_CHAIN (decl);
1633           push_jvm_slot (index, decl);
1634           pushdecl (decl);
1635           base_decl
1636             = find_local_variable (index, TREE_TYPE (decl), pc);
1637           if (TREE_CODE (TREE_TYPE (base_decl)) == POINTER_TYPE)
1638             base_decl = TREE_VEC_ELT (base_decl_map, index);
1639           SET_DECL_VALUE_EXPR (decl, base_decl);
1640           DECL_HAS_VALUE_EXPR_P (decl) = 1;
1641         }
1642     }
1643
1644   maybe_start_try (pc, 0);
1645 }
1646
1647 void
1648 maybe_poplevels (int pc)
1649 {
1650 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1651   current_pc = pc;
1652 #endif
1653
1654   /* FIXME: I'm pretty sure that this is wrong.  Variable scopes are
1655      inclusive, so a variable is live if pc == end_pc.  Here, we
1656      terminate a range if the current pc is equal to the end of the
1657      range, and this is *before* we have generated code for the
1658      instruction at end_pc.  We're closing a binding level one
1659      instruction too early.*/
1660   while (current_binding_level->end_pc <= pc)
1661     poplevel (1, 0, 0);
1662 }
1663
1664 /* Terminate any binding which began during the range beginning at
1665    start_pc.  This tidies up improperly nested local variable ranges
1666    and exception handlers; a variable declared within an exception
1667    range is forcibly terminated when that exception ends. */
1668
1669 void
1670 force_poplevels (int start_pc)
1671 {
1672   while (current_binding_level->start_pc > start_pc)
1673     {
1674       if (pedantic && current_binding_level->start_pc > start_pc)
1675         warning (0, "In %+D: overlapped variable and exception ranges at %d",
1676                  current_function_decl,
1677                  current_binding_level->start_pc);
1678       poplevel (1, 0, 0);
1679     }
1680 }
1681
1682 /* integrate_decl_tree calls this function. */
1683
1684 void
1685 java_dup_lang_specific_decl (tree node)
1686 {
1687   int lang_decl_size;
1688   struct lang_decl *x;
1689
1690   if (!DECL_LANG_SPECIFIC (node))
1691     return;
1692
1693   lang_decl_size = sizeof (struct lang_decl);
1694   x = ggc_alloc_lang_decl (lang_decl_size);
1695   memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
1696   DECL_LANG_SPECIFIC (node) = x;
1697 }
1698
1699 void
1700 give_name_to_locals (JCF *jcf)
1701 {
1702   int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
1703   int code_offset = DECL_CODE_OFFSET (current_function_decl);
1704   tree parm;
1705   pending_local_decls = NULL_TREE;
1706   if (n == 0)
1707     return;
1708   JCF_SEEK (jcf, n);
1709   n = JCF_readu2 (jcf);
1710   for (i = 0; i < n; i++)
1711     {
1712       int start_pc = JCF_readu2 (jcf);
1713       int length = JCF_readu2 (jcf);
1714       int name_index = JCF_readu2 (jcf);
1715       int signature_index = JCF_readu2 (jcf);
1716       int slot = JCF_readu2 (jcf);
1717       tree name = get_name_constant (jcf, name_index);
1718       tree type = parse_signature (jcf, signature_index);
1719       if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
1720           && start_pc == 0
1721           && length == DECL_CODE_LENGTH (current_function_decl))
1722         {
1723           tree decl = TREE_VEC_ELT (decl_map, slot);
1724           DECL_NAME (decl) = name;
1725           if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
1726             warning (0, "bad type in parameter debug info");
1727         }
1728       else
1729         {
1730           tree *ptr;
1731           int end_pc = start_pc + length;
1732           tree decl = build_decl (input_location, VAR_DECL, name, type);
1733           if (end_pc > DECL_CODE_LENGTH (current_function_decl))
1734             {
1735               warning (0, "bad PC range for debug info for local %q+D",
1736                        decl);
1737               end_pc = DECL_CODE_LENGTH (current_function_decl);
1738             }
1739
1740           /* Adjust start_pc if necessary so that the local's first
1741              store operation will use the relevant DECL as a
1742              destination. Fore more information, read the leading
1743              comments for expr.c:maybe_adjust_start_pc. */
1744           start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot);
1745
1746           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1747           DECL_LOCAL_SLOT_NUMBER (decl) = slot;
1748           DECL_LOCAL_START_PC (decl) = start_pc;
1749           DECL_LOCAL_END_PC (decl) = end_pc;
1750
1751           /* Now insert the new decl in the proper place in
1752              pending_local_decls.  We are essentially doing an insertion sort,
1753              which works fine, since the list input will normally already
1754              be sorted. */
1755           ptr = &pending_local_decls;
1756           while (*ptr != NULL_TREE
1757                  && (DECL_LOCAL_START_PC (*ptr) > start_pc
1758                      || (DECL_LOCAL_START_PC (*ptr) == start_pc
1759                          && DECL_LOCAL_END_PC (*ptr) < end_pc)))
1760             ptr = &DECL_CHAIN (*ptr);
1761           DECL_CHAIN (decl) = *ptr;
1762           *ptr = decl;
1763         }
1764     }
1765
1766   pending_local_decls = nreverse (pending_local_decls);
1767
1768   /* Fill in default names for the parameters. */
1769   for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
1770        parm != NULL_TREE;  parm = DECL_CHAIN (parm), i++)
1771     {
1772       if (DECL_NAME (parm) == NULL_TREE)
1773         {
1774           int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
1775           if (arg_i == 0)
1776             DECL_NAME (parm) = get_identifier ("this");
1777           else
1778             {
1779               char buffer[12];
1780               sprintf (buffer, "ARG_%d", arg_i);
1781               DECL_NAME (parm) = get_identifier (buffer);
1782             }
1783         }
1784     }
1785 }
1786
1787 tree
1788 build_result_decl (tree fndecl)
1789 {
1790   tree restype = TREE_TYPE (TREE_TYPE (fndecl));
1791   tree result = DECL_RESULT (fndecl);
1792   if (! result)
1793     {
1794       result = build_decl (DECL_SOURCE_LOCATION (fndecl),
1795                            RESULT_DECL, NULL_TREE, restype);
1796       DECL_ARTIFICIAL (result) = 1;
1797       DECL_IGNORED_P (result) = 1;
1798       DECL_CONTEXT (result) = fndecl;
1799       DECL_RESULT (fndecl) = result;
1800     }
1801   return result;
1802 }
1803
1804 void
1805 start_java_method (tree fndecl)
1806 {
1807   tree tem, *ptr;
1808   int i;
1809
1810   uniq = 0;
1811
1812   current_function_decl = fndecl;
1813   announce_function (fndecl);
1814
1815   i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
1816   decl_map = make_tree_vec (i);
1817   base_decl_map = make_tree_vec (i);
1818   type_map = XRESIZEVEC (tree, type_map, i);
1819
1820 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1821   fprintf (stderr, "%s:\n", lang_printable_name (fndecl, 2));
1822   current_pc = 0;
1823 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1824   pushlevel (1);  /* Push parameters. */
1825
1826   ptr = &DECL_ARGUMENTS (fndecl);
1827   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
1828        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
1829     {
1830       tree parm_name = NULL_TREE, parm_decl;
1831       tree parm_type = TREE_VALUE (tem);
1832       gcc_assert (i < DECL_MAX_LOCALS (fndecl));
1833
1834       parm_decl = build_decl (input_location, PARM_DECL, parm_name, parm_type);
1835       DECL_CONTEXT (parm_decl) = fndecl;
1836       if (targetm.calls.promote_prototypes (parm_type)
1837           && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
1838           && INTEGRAL_TYPE_P (parm_type))
1839         parm_type = integer_type_node;
1840       DECL_ARG_TYPE (parm_decl) = parm_type;
1841
1842       *ptr = parm_decl;
1843       ptr = &DECL_CHAIN (parm_decl);
1844
1845       /* Add parm_decl to the decl_map. */
1846       push_jvm_slot (i, parm_decl);
1847
1848       /* The this parameter of methods is artificial.  */
1849       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE && i == 0)
1850         DECL_ARTIFICIAL (parm_decl) = 1;
1851
1852       type_map[i] = TREE_TYPE (parm_decl);
1853       if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
1854         {
1855           i++;
1856           type_map[i] = void_type_node;
1857         }
1858     }
1859   *ptr = NULL_TREE;
1860   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
1861
1862   while (i < DECL_MAX_LOCALS(fndecl))
1863     type_map[i++] = NULL_TREE;
1864
1865   build_result_decl (fndecl);
1866   DECL_SOURCE_LOCATION (fndecl) = input_location;
1867
1868   /* Push local variables.  */
1869   pushlevel (2);
1870
1871   function_binding_level = current_binding_level;
1872 }
1873
1874 void
1875 end_java_method (void)
1876 {
1877   tree fndecl = current_function_decl;
1878
1879   /* pop out of function */
1880   poplevel (1, 1, 0);
1881
1882   /* pop out of its parameters */
1883   poplevel (1, 0, 1);
1884
1885   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1886
1887   if (DECL_SAVED_TREE (fndecl))
1888     {
1889       tree fbody, block_body;
1890       /* Before we check initialization, attached all class initialization
1891          variable to the block_body */
1892       fbody = DECL_SAVED_TREE (fndecl);
1893       block_body = BIND_EXPR_BODY (fbody);
1894       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (fndecl),
1895                      attach_init_test_initialization_flags, block_body);
1896     }
1897
1898   finish_method (fndecl);
1899
1900   current_function_decl = NULL_TREE;
1901   base_decl_map = NULL_TREE;
1902 }
1903
1904 /* Prepare a method for expansion.  */
1905
1906 void
1907 finish_method (tree fndecl)
1908 {
1909   tree *tp = &DECL_SAVED_TREE (fndecl);
1910
1911   /* Wrap body of synchronized methods in a monitorenter,
1912      plus monitorexit cleanup.  */
1913   if (METHOD_SYNCHRONIZED (fndecl))
1914     {
1915       tree enter, exit, lock;
1916       if (METHOD_STATIC (fndecl))
1917         lock = build_class_ref (DECL_CONTEXT (fndecl));
1918       else
1919         lock = DECL_ARGUMENTS (fndecl);
1920       BUILD_MONITOR_ENTER (enter, lock);
1921       BUILD_MONITOR_EXIT (exit, lock);
1922       *tp = build2 (COMPOUND_EXPR, void_type_node, enter,
1923                     build2 (TRY_FINALLY_EXPR, void_type_node, *tp, exit));
1924     }
1925
1926   /* Convert function tree to GENERIC prior to inlining.  */
1927   java_genericize (fndecl);
1928
1929   /* Store the end of the function, so that we get good line number
1930      info for the epilogue.  */
1931   if (DECL_STRUCT_FUNCTION (fndecl))
1932     set_cfun (DECL_STRUCT_FUNCTION (fndecl));
1933   else
1934     allocate_struct_function (fndecl, false);
1935   cfun->function_end_locus = DECL_FUNCTION_LAST_LINE (fndecl);
1936
1937   /* Defer inlining and expansion to the cgraph optimizers.  */
1938   cgraph_finalize_function (fndecl, false);
1939 }
1940
1941 /* We pessimistically marked all methods and fields external until we
1942    knew what set of classes we were planning to compile.  Now mark those
1943    associated with CLASS to be generated locally as not external.  */
1944
1945 static void
1946 java_mark_decl_local (tree decl)
1947 {
1948   DECL_EXTERNAL (decl) = 0;
1949
1950 #ifdef ENABLE_CHECKING
1951   /* Double check that we didn't pass the function to the callgraph early.  */
1952   if (TREE_CODE (decl) == FUNCTION_DECL)
1953     gcc_assert (!cgraph_node (decl)->local.finalized);
1954 #endif
1955   gcc_assert (!DECL_RTL_SET_P (decl));
1956 }
1957
1958 /* Given appropriate target support, G++ will emit hidden aliases for native
1959    methods.  Using this hidden name is required for proper operation of
1960    _Jv_Method::ncode, but it doesn't hurt to use it everywhere.  Look for
1961    proper target support, then mark the method for aliasing.  */
1962
1963 static void
1964 java_mark_cni_decl_local (tree decl)
1965 {
1966 #if !defined(HAVE_GAS_HIDDEN) || !defined(ASM_OUTPUT_DEF)
1967   return;
1968 #endif
1969
1970   DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
1971   DECL_LOCAL_CNI_METHOD_P (decl) = 1;
1972
1973   /* Setting DECL_LOCAL_CNI_METHOD_P changes the behavior of the
1974      mangler.  We might have already referenced this native method and
1975      therefore created its name, but even if we have it won't hurt.
1976      We'll just go via its externally visible name, rather than its
1977      hidden alias.  However, we must force things so that the correct
1978      mangling is done.  */
1979
1980   if (DECL_ASSEMBLER_NAME_SET_P (decl))
1981     java_mangle_decl (decl);
1982   if (DECL_RTL_SET_P (decl))
1983     {
1984       SET_DECL_RTL (decl, 0);
1985       make_decl_rtl (decl);
1986     }
1987 }
1988
1989 /* Use the preceding two functions and mark all members of the class.  */
1990
1991 void
1992 java_mark_class_local (tree klass)
1993 {
1994   tree t;
1995
1996   for (t = TYPE_FIELDS (klass); t ; t = DECL_CHAIN (t))
1997     if (FIELD_STATIC (t))
1998       {
1999         if (DECL_EXTERNAL (t))
2000           VEC_safe_push (tree, gc, pending_static_fields, t);
2001         java_mark_decl_local (t);
2002       }
2003
2004   for (t = TYPE_METHODS (klass); t ; t = DECL_CHAIN (t))
2005     if (!METHOD_ABSTRACT (t))
2006       {
2007         if (METHOD_NATIVE (t) && !flag_jni)
2008           java_mark_cni_decl_local (t);
2009         else
2010           java_mark_decl_local (t);
2011       }
2012 }
2013
2014 /* Add a statement to a compound_expr.  */
2015
2016 tree
2017 add_stmt_to_compound (tree existing, tree type, tree stmt)
2018 {
2019   if (!stmt)
2020     return existing;
2021   else if (existing)
2022     {
2023       tree expr = build2 (COMPOUND_EXPR, type, existing, stmt);
2024       TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (existing)
2025                                  | TREE_SIDE_EFFECTS (stmt);
2026       return expr;
2027     }
2028   else
2029     return stmt;
2030 }
2031
2032 /* If this node is an expr, mark its input location.  Called from
2033    walk_tree().  */
2034
2035 static tree
2036 set_input_location (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2037                     void *data ATTRIBUTE_UNUSED)
2038 {
2039   tree t = *tp;
2040
2041   if (CAN_HAVE_LOCATION_P (t))
2042     {
2043       if (EXPR_HAS_LOCATION(t))
2044         return t;  /* Don't walk any further into this expr.   */
2045       else
2046         SET_EXPR_LOCATION (t, input_location);
2047     }
2048
2049   return NULL_TREE;  /* Continue walking this expr.   */
2050 }
2051
2052 /* Add a statement to the statement_list currently being constructed.
2053    If the statement_list is null, we don't create a singleton list.
2054    This is necessary because poplevel() assumes that adding a
2055    statement to a null statement_list returns the statement.  */
2056
2057 tree
2058 java_add_stmt (tree new_stmt)
2059 {
2060   tree stmts = current_binding_level->stmts;
2061   tree_stmt_iterator i;
2062
2063   if (input_filename)
2064     walk_tree (&new_stmt, set_input_location, NULL, NULL);
2065
2066   if (stmts == NULL)
2067     return current_binding_level->stmts = new_stmt;
2068
2069   /* Force STMTS to be a statement_list.  */
2070   if (TREE_CODE (stmts) != STATEMENT_LIST)
2071     {
2072       tree t = make_node (STATEMENT_LIST);
2073       i = tsi_last (t);
2074       tsi_link_after (&i, stmts, TSI_CONTINUE_LINKING);
2075       stmts = t;
2076     }
2077
2078   i = tsi_last (stmts);
2079   tsi_link_after (&i, new_stmt, TSI_CONTINUE_LINKING);
2080   TREE_TYPE (stmts) = void_type_node;
2081
2082   return current_binding_level->stmts = stmts;
2083 }
2084
2085 /* Add a variable to the current scope.  */
2086
2087 tree
2088 java_add_local_var (tree decl)
2089 {
2090   tree *vars = &current_binding_level->names;
2091   tree next = *vars;
2092   DECL_CHAIN (decl) = next;
2093   *vars = decl;
2094   DECL_CONTEXT (decl) = current_function_decl;
2095   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2096   return decl;
2097 }
2098
2099 /* Return a pointer to the compound_expr currently being
2100    constructed.  */
2101
2102 tree *
2103 get_stmts (void)
2104 {
2105   return &current_binding_level->stmts;
2106 }
2107
2108 /* Register an exception range as belonging to the current binding
2109    level.  There may only be one: if there are more, we'll create more
2110    binding levels.  However, each range can have multiple handlers,
2111    and these are expanded when we call expand_end_java_handler().  */
2112
2113 void
2114 register_exception_range (struct eh_range *range, int pc, int end_pc)
2115 {
2116   gcc_assert (! current_binding_level->exception_range);
2117   current_binding_level->exception_range = range;
2118   current_binding_level->end_pc = end_pc;
2119   current_binding_level->start_pc = pc;
2120 }
2121
2122 #include "gt-java-decl.h"