OSDN Git Service

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