OSDN Git Service

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