OSDN Git Service

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