OSDN Git Service

ec94a3c95345bf538be22c1dd16fe33d8402f509
[pf3gnuchains/gcc-fork.git] / gcc / java / class.c
1 /* Functions related to building classes and their related objects.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3    2005, 2006, 2007 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.
21
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
25
26 /* Written by Per Bothner <bothner@cygnus.com> */
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 "flags.h"
35 #include "java-tree.h"
36 #include "jcf.h"
37 #include "obstack.h"
38 #include "toplev.h"
39 #include "output.h"
40 #include "parse.h"
41 #include "function.h"
42 #include "ggc.h"
43 #include "stdio.h"
44 #include "target.h"
45 #include "except.h"
46 #include "cgraph.h"
47 #include "tree-iterator.h"
48 #include "cgraph.h"
49 #include "vecprim.h"
50
51 /* DOS brain-damage */
52 #ifndef O_BINARY
53 #define O_BINARY 0 /* MS-DOS brain-damage */
54 #endif
55
56 static tree make_method_value (tree);
57 static tree build_java_method_type (tree, tree, int);
58 static int32 hashUtf8String (const char *, int);
59 static tree make_field_value (tree);
60 static tree get_dispatch_vector (tree);
61 static tree get_dispatch_table (tree, tree);
62 static int supers_all_compiled (tree type);
63 static tree maybe_layout_super_class (tree, tree);
64 static void add_miranda_methods (tree, tree);
65 static int assume_compiled (const char *);
66 static tree build_symbol_entry (tree, tree);
67 static tree emit_assertion_table (tree);
68 static void register_class (void);
69
70 struct obstack temporary_obstack;
71
72 static const char *cyclic_inheritance_report;
73
74 /* The compiler generates different code depending on whether or not
75    it can assume certain classes have been compiled down to native
76    code or not.  The compiler options -fassume-compiled= and
77    -fno-assume-compiled= are used to create a tree of
78    class_flag_node objects.  This tree is queried to determine if
79    a class is assume to be compiled or not.  Each node in the tree
80    represents either a package or a specific class.  */
81
82 typedef struct class_flag_node_struct
83 {
84   /* The class or package name.  */
85   const char *ident;
86
87   /* Nonzero if this represents an exclusion.  */
88   int value;
89
90   /* Pointers to other nodes in the tree.  */
91   struct class_flag_node_struct *parent;
92   struct class_flag_node_struct *sibling;
93   struct class_flag_node_struct *child;
94 } class_flag_node;
95
96 static class_flag_node *find_class_flag_node (class_flag_node *, const char *);
97 static void add_class_flag (class_flag_node **, const char *, int);
98
99 /* This is the root of the include/exclude tree.  */
100
101 static class_flag_node *assume_compiled_tree;
102
103 static class_flag_node *enable_assert_tree;
104
105 static GTY(()) tree class_roots[4];
106 #define fields_ident class_roots[0]  /* get_identifier ("fields") */
107 #define info_ident class_roots[1]  /* get_identifier ("info") */
108 #define class_list class_roots[2]
109 #define class_dtable_decl class_roots[3]
110
111 static GTY(()) VEC(tree,gc) *registered_class;
112
113 /* A tree that returns the address of the class$ of the class
114    currently being compiled.  */
115 static GTY(()) tree this_classdollar;
116
117 /* Return the node that most closely represents the class whose name
118    is IDENT.  Start the search from NODE (followed by its siblings).
119    Return NULL if an appropriate node does not exist.  */
120
121 static class_flag_node *
122 find_class_flag_node (class_flag_node *node, const char *ident)
123 {
124   while (node)
125     {
126       size_t node_ident_length = strlen (node->ident);
127
128       /* node_ident_length is zero at the root of the tree.  If the
129          identifiers are the same length, then we have matching
130          classes.  Otherwise check if we've matched an enclosing
131          package name.  */
132
133       if (node_ident_length == 0
134           || (strncmp (ident, node->ident, node_ident_length) == 0
135               && (ident[node_ident_length] == '\0'
136                   || ident[node_ident_length] == '.')))
137         {
138           /* We've found a match, however, there might be a more
139              specific match.  */
140
141           class_flag_node *found = find_class_flag_node (node->child, ident);
142           if (found)
143             return found;
144           else
145             return node;
146         }
147
148       /* No match yet.  Continue through the sibling list.  */
149       node = node->sibling;
150     }
151
152   /* No match at all in this tree.  */
153   return NULL;
154 }
155
156 void
157 add_class_flag (class_flag_node **rootp, const char *ident, int value)
158 {
159   class_flag_node *root = *rootp;
160   class_flag_node *parent, *node;
161
162   /* Create the root of the tree if it doesn't exist yet.  */
163
164   if (NULL == root)
165     {
166       root = XNEW (class_flag_node);
167       root->ident = "";
168       root->value = 0;
169       root->sibling = NULL;
170       root->child = NULL;
171       root->parent = NULL;
172       *rootp = root;
173     }
174
175   /* Calling the function with the empty string means we're setting
176      value for the root of the hierarchy.  */
177
178   if (0 == ident[0])
179     {
180       root->value = value;
181       return;
182     }
183
184   /* Find the parent node for this new node.  PARENT will either be a
185      class or a package name.  Adjust PARENT accordingly.  */
186
187   parent = find_class_flag_node (root, ident);
188   if (strcmp (ident, parent->ident) == 0)
189     parent->value = value;
190   else
191     {
192       /* Insert new node into the tree.  */
193       node = XNEW (class_flag_node);
194
195       node->ident = xstrdup (ident);
196       node->value = value;
197       node->child = NULL;
198
199       node->parent = parent;
200       node->sibling = parent->child;
201       parent->child = node;
202     }
203 }
204
205 /* Add a new IDENT to the include/exclude tree.  It's an exclusion
206    if EXCLUDEP is nonzero.  */
207
208 void
209 add_assume_compiled (const char *ident, int excludep)
210 {
211   add_class_flag (&assume_compiled_tree, ident, excludep);
212 }
213
214 /* The default value returned by enable_assertions. */
215
216 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
217
218 /* Enter IDENT (a class or package name) into the enable-assertions table.
219    VALUE is true to enable and false to disable. */
220
221 void
222 add_enable_assert (const char *ident, int value)
223 {
224   if (enable_assert_tree == NULL)
225     add_class_flag (&enable_assert_tree, "", DEFAULT_ENABLE_ASSERT);
226   add_class_flag (&enable_assert_tree, ident, value);
227 }
228
229 /* Returns nonzero if IDENT is the name of a class that the compiler
230    should assume has been compiled to object code.  */
231
232 static int
233 assume_compiled (const char *ident)
234 {
235   class_flag_node *i;
236   int result;
237   
238   if (NULL == assume_compiled_tree)
239     return 1;
240
241   i = find_class_flag_node (assume_compiled_tree, ident);
242
243   result = ! i->value;
244   
245   return (result);
246 }
247
248 /* Return true if we should generate code to check assertions within KLASS. */
249
250 bool
251 enable_assertions (tree klass)
252 {
253   /* Check if command-line specifies whether we should check assertions. */
254
255   if (klass != NULL_TREE && DECL_NAME (klass) && enable_assert_tree != NULL)
256     {
257       const char *ident = IDENTIFIER_POINTER (DECL_NAME (klass));
258       class_flag_node *node
259         = find_class_flag_node (enable_assert_tree, ident);
260       return node->value;
261     }
262
263   /* The default is to enable assertions if generating class files,
264      or not optimizing. */
265   return DEFAULT_ENABLE_ASSERT;
266 }
267
268 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
269    except that characters matching OLD_CHAR are substituted by NEW_CHAR.
270    Also, PREFIX is prepended, and SUFFIX is appended. */
271
272 tree
273 ident_subst (const char* old_name,
274              int old_length,
275              const char *prefix,
276              int old_char,
277              int new_char,
278              const char *suffix)
279 {
280   int prefix_len = strlen (prefix);
281   int suffix_len = strlen (suffix);
282   int i = prefix_len + old_length + suffix_len + 1;
283   char *buffer = alloca (i);
284
285   strcpy (buffer, prefix);
286   for (i = 0; i < old_length; i++)
287     {
288       char ch = old_name[i];
289       if (ch == old_char)
290         ch = new_char;
291       buffer[prefix_len + i] = ch;
292     }
293   strcpy (buffer + prefix_len + old_length, suffix);
294   return get_identifier (buffer);
295 }
296
297 /* Return an IDENTIFIER_NODE the same as OLD_ID,
298    except that characters matching OLD_CHAR are substituted by NEW_CHAR.
299    Also, PREFIX is prepended, and SUFFIX is appended. */
300
301 tree
302 identifier_subst (const tree old_id,
303                   const char *prefix,
304                   int old_char,
305                   int new_char,
306                   const char *suffix)
307 {
308   return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
309                       prefix, old_char, new_char, suffix);
310 }
311
312 /* Generate a valid C identifier from the name of the class TYPE,
313    prefixed by PREFIX. */
314
315 tree
316 mangled_classname (const char *prefix, tree type)
317 {
318   tree ident = TYPE_NAME (type);
319   if (TREE_CODE (ident) != IDENTIFIER_NODE)
320     ident = DECL_NAME (ident);
321   return identifier_subst (ident, prefix, '.', '_', "");
322 }
323
324 tree
325 make_class (void)
326 {
327   tree type;
328   type = make_node (RECORD_TYPE);
329   /* Unfortunately we must create the binfo here, so that class
330      loading works.  */
331   TYPE_BINFO (type) = make_tree_binfo (0);
332   MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
333
334   return type;
335 }
336
337 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
338    and where each of the constituents is separated by '/',
339    return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
340
341 tree
342 unmangle_classname (const char *name, int name_length)
343 {
344   tree to_return = ident_subst (name, name_length, "", '/', '.', "");
345   /* It's not sufficient to compare to_return and get_identifier
346      (name) to determine whether to_return is qualified. There are
347      cases in signature analysis where name will be stripped of a
348      trailing ';'. */
349   name = IDENTIFIER_POINTER (to_return);
350   while (*name)
351     if (*name++ == '.') 
352       {
353         QUALIFIED_P (to_return) = 1;
354         break;
355       }
356   
357   return to_return;
358 }
359
360 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE)                        \
361 do                                                                      \
362 {                                                                       \
363   const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
364   char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
365   tree decl;                                                            \
366                                                                         \
367   sprintf (buf, #NAME "_%s", typename);                                 \
368   TYPE_## TABLE ##_DECL (type) = decl =                                 \
369     build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE);            \
370   DECL_EXTERNAL (decl) = 1;                                             \
371   TREE_STATIC (decl) = 1;                                               \
372   TREE_READONLY (decl) = 1;                                             \
373   TREE_CONSTANT (decl) = 1;                                             \
374   DECL_IGNORED_P (decl) = 1;                                            \
375   /* Mark the table as belonging to this class.  */                     \
376   pushdecl (decl);                                                      \
377   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);                           \
378   DECL_OWNER (decl) = TYPE;                                             \
379   sprintf (buf, #NAME "_syms_%s", typename);                            \
380   TYPE_## TABLE ##_SYMS_DECL (TYPE) =                                   \
381     build_decl (VAR_DECL, get_identifier (buf), symbols_array_type);    \
382   TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1;                  \
383   TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1;                \
384   DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1;               \
385 }                                                                       \
386 while (0)
387
388 /* Given a class, create the DECLs for all its associated indirect
389    dispatch tables.  */
390 void
391 gen_indirect_dispatch_tables (tree type)
392 {
393   const char *typename = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
394   {  
395     tree field = NULL;
396     char *buf = alloca (strlen (typename) + strlen ("_catch_classes_") + 1);
397     tree catch_class_type = make_node (RECORD_TYPE);
398
399     sprintf (buf, "_catch_classes_%s", typename);
400     PUSH_FIELD (catch_class_type, field, "address", utf8const_ptr_type);
401     PUSH_FIELD (catch_class_type, field, "classname", ptr_type_node);
402     FINISH_RECORD (catch_class_type);
403     
404     TYPE_CTABLE_DECL (type) 
405       = build_decl (VAR_DECL, get_identifier (buf),
406                     build_array_type (catch_class_type, 0));
407     DECL_EXTERNAL (TYPE_CTABLE_DECL (type)) = 1;
408     TREE_STATIC (TYPE_CTABLE_DECL (type)) = 1;
409     TREE_READONLY (TYPE_CTABLE_DECL (type)) = 1;
410     TREE_CONSTANT (TYPE_CTABLE_DECL (type)) = 1;
411     DECL_IGNORED_P (TYPE_CTABLE_DECL (type)) = 1;
412     pushdecl (TYPE_CTABLE_DECL (type));  
413   }
414
415   if (flag_indirect_dispatch)
416     {
417       GEN_TABLE (ATABLE, _atable, atable_type, type);
418       GEN_TABLE (OTABLE, _otable, otable_type, type);
419       GEN_TABLE (ITABLE, _itable, itable_type, type);
420     }
421 }
422
423 #undef GEN_TABLE
424
425 tree
426 push_class (tree class_type, tree class_name)
427 {
428   tree decl, signature;
429   location_t saved_loc = input_location;
430 #ifndef USE_MAPPED_LOCATION
431   tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
432   input_filename = IDENTIFIER_POINTER (source_name);
433   input_line = 0;
434 #endif
435   CLASS_P (class_type) = 1;
436   decl = build_decl (TYPE_DECL, class_name, class_type);
437   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
438
439   /* dbxout needs a DECL_SIZE if in gstabs mode */
440   DECL_SIZE (decl) = integer_zero_node;
441
442   input_location = saved_loc;
443   signature = identifier_subst (class_name, "L", '.', '/', ";");
444   IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
445
446   /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
447      both a typedef and in the struct name-space.  We may want to re-visit
448      this later, but for now it reduces the changes needed for gdb. */
449   DECL_ARTIFICIAL (decl) = 1;
450
451   pushdecl_top_level (decl);
452
453   return decl;
454 }
455
456 /* Finds the (global) class named NAME.  Creates the class if not found.
457    Also creates associated TYPE_DECL.
458    Does not check if the class actually exists, load the class,
459    fill in field or methods, or do layout_type. */
460
461 tree
462 lookup_class (tree name)
463 {
464   tree decl = IDENTIFIER_CLASS_VALUE (name);
465   if (decl == NULL_TREE)
466     decl = push_class (make_class (), name);
467   return TREE_TYPE (decl);
468 }
469
470 void
471 set_super_info (int access_flags, tree this_class,
472                 tree super_class, int interfaces_count)
473 {
474   int total_supers = interfaces_count;
475   tree class_decl = TYPE_NAME (this_class);
476   
477   if (super_class)
478     total_supers++;
479
480   if (total_supers)
481     TYPE_BINFO (this_class) = make_tree_binfo (total_supers);
482   TYPE_VFIELD (this_class) = TYPE_VFIELD (object_type_node);
483   if (super_class)
484     {
485       tree super_binfo = make_tree_binfo (0);
486       BINFO_TYPE (super_binfo) = super_class;
487       BINFO_OFFSET (super_binfo) = integer_zero_node;
488       BINFO_BASE_APPEND (TYPE_BINFO (this_class), super_binfo);
489       CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class)) = 1;
490     }
491
492   set_class_decl_access_flags (access_flags, class_decl);
493 }
494
495 void
496 set_class_decl_access_flags (int access_flags, tree class_decl)
497 {
498   if (access_flags & ACC_PUBLIC)    CLASS_PUBLIC (class_decl) = 1;
499   if (access_flags & ACC_FINAL)     CLASS_FINAL (class_decl) = 1;
500   if (access_flags & ACC_SUPER)     CLASS_SUPER (class_decl) = 1;
501   if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
502   if (access_flags & ACC_ABSTRACT)  CLASS_ABSTRACT (class_decl) = 1;
503   if (access_flags & ACC_STATIC)    CLASS_STATIC (class_decl) = 1;
504   if (access_flags & ACC_PRIVATE)   CLASS_PRIVATE (class_decl) = 1;
505   if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
506   if (access_flags & ACC_STRICT)    CLASS_STRICTFP (class_decl) = 1;
507   if (access_flags & ACC_ENUM)      CLASS_ENUM (class_decl) = 1;
508   if (access_flags & ACC_SYNTHETIC) CLASS_SYNTHETIC (class_decl) = 1;
509   if (access_flags & ACC_ANNOTATION) CLASS_ANNOTATION (class_decl) = 1;
510 }
511
512 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
513    direct sub-classes of Object are 1, and so on. */
514
515 int
516 class_depth (tree clas)
517 {
518   int depth = 0;
519   if (! CLASS_LOADED_P (clas))
520     load_class (clas, 1);
521   if (TYPE_SIZE (clas) == error_mark_node)
522     return -1;
523   while (clas != object_type_node)
524     {
525       depth++;
526       clas = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas), 0));
527     }
528   return depth;
529 }
530
531 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
532
533 int
534 interface_of_p (tree type1, tree type2)
535 {
536   int i;
537   tree binfo, base_binfo;
538
539   if (! TYPE_BINFO (type2))
540     return 0;
541
542   for (binfo = TYPE_BINFO (type2), i = 0;
543        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
544     if (BINFO_TYPE (base_binfo) == type1)
545       return 1;
546   
547   for (binfo = TYPE_BINFO (type2), i = 0;
548        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) /*  */
549     if (BINFO_TYPE (base_binfo)
550         && interface_of_p (type1, BINFO_TYPE (base_binfo)))
551       return 1;
552   
553   return 0;
554 }
555
556 /* Return true iff TYPE1 inherits from TYPE2. */
557
558 int
559 inherits_from_p (tree type1, tree type2)
560 {
561   while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
562     {
563       if (type1 == type2)
564         return 1;
565
566       if (! CLASS_LOADED_P (type1))
567         load_class (type1, 1);
568
569       type1 = maybe_layout_super_class (CLASSTYPE_SUPER (type1), type1);
570     }
571   return 0;
572 }
573
574 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
575
576 int
577 enclosing_context_p (tree type1, tree type2)
578 {
579   if (!INNER_CLASS_TYPE_P (type2))
580     return 0;
581
582   for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
583        type2; 
584        type2 = (INNER_CLASS_TYPE_P (type2) ?
585                 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
586     {
587       if (type2 == type1)
588         return 1;
589     }
590
591   return 0;
592 }
593
594
595 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
596    nesting level.  */
597
598 int
599 common_enclosing_context_p (tree type1, tree type2)
600 {
601   while (type1)
602     {
603       tree current;
604       for (current = type2; current;
605            current = (INNER_CLASS_TYPE_P (current) ?
606                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) : 
607                       NULL_TREE))
608         if (type1 == current)
609           return 1;
610
611       if (INNER_CLASS_TYPE_P (type1))
612         type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1)));
613       else
614         break;
615     }
616   return 0;
617 }
618
619 /* Return 1 iff there exists a common enclosing "this" between TYPE1
620    and TYPE2, without crossing any static context.  */
621
622 int
623 common_enclosing_instance_p (tree type1, tree type2)
624 {
625   if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
626     return 0;
627   
628   for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1; 
629        type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
630                 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
631     {
632       tree current;
633       for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
634            current = (PURE_INNER_CLASS_TYPE_P (current) ?
635                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) : 
636                       NULL_TREE))
637         if (type1 == current)
638           return 1;
639     }
640   return 0;
641 }
642
643 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
644    found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
645    if attempt is made to add it twice. */
646
647 tree
648 maybe_add_interface (tree this_class, tree interface_class)
649 {
650   tree binfo, base_binfo;
651   int i;
652
653   for (binfo = TYPE_BINFO (this_class), i = 0;
654        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
655     if (BINFO_TYPE (base_binfo) == interface_class)
656       return interface_class;
657   add_interface (this_class, interface_class);
658   return NULL_TREE;
659 }
660
661 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
662
663 void
664 add_interface (tree this_class, tree interface_class)
665 {
666   tree interface_binfo = make_tree_binfo (0);
667   
668   BINFO_TYPE (interface_binfo) = interface_class;
669   BINFO_OFFSET (interface_binfo) = integer_zero_node;
670   BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
671   BINFO_VIRTUAL_P (interface_binfo) = 1;
672   
673   BINFO_BASE_APPEND (TYPE_BINFO (this_class), interface_binfo);
674 }
675
676 static tree
677 build_java_method_type (tree fntype, tree this_class, int access_flags)
678 {
679   if (access_flags & ACC_STATIC)
680     return fntype;
681   fntype = build_method_type (this_class, fntype);
682
683   /* We know that arg 1 of every nonstatic method is non-null; tell
684      the back-end so.  */
685   TYPE_ATTRIBUTES (fntype) = (tree_cons 
686                               (get_identifier ("nonnull"),
687                                tree_cons (NULL_TREE, 
688                                           build_int_cst (NULL_TREE, 1),
689                                           NULL_TREE),
690                                TYPE_ATTRIBUTES (fntype)));
691   return fntype;
692 }
693
694 tree
695 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
696 {
697   tree method_type, fndecl;
698
699   method_type = build_java_method_type (function_type,
700                                         this_class, access_flags);
701
702   fndecl = build_decl (FUNCTION_DECL, name, method_type);
703   DECL_CONTEXT (fndecl) = this_class;
704
705   DECL_LANG_SPECIFIC (fndecl)
706     = ggc_alloc_cleared (sizeof (struct lang_decl));
707   DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
708
709   /* Initialize the static initializer test table.  */
710   
711   DECL_FUNCTION_INIT_TEST_TABLE (fndecl) = 
712     java_treetreehash_create (10, 1);
713
714   /* Initialize the initialized (static) class table. */
715   if (access_flags & ACC_STATIC)
716     DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
717       htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
718
719   TREE_CHAIN (fndecl) = TYPE_METHODS (this_class);
720   TYPE_METHODS (this_class) = fndecl;
721
722   /* Notice that this is a finalizer and update the class type
723      accordingly. This is used to optimize instance allocation. */
724   if (name == finalize_identifier_node
725       && TREE_TYPE (function_type) == void_type_node
726       && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
727     HAS_FINALIZER_P (this_class) = 1;
728
729   if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
730   if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
731   if (access_flags & ACC_PRIVATE)
732     METHOD_PRIVATE (fndecl) = DECL_INLINE (fndecl) = 1;
733   if (access_flags & ACC_NATIVE)
734     {
735       METHOD_NATIVE (fndecl) = 1;
736       DECL_EXTERNAL (fndecl) = 1;
737     }
738   else
739     /* FNDECL is external unless we are compiling it into this object
740        file.  */
741     DECL_EXTERNAL (fndecl) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class) == 0;
742   if (access_flags & ACC_STATIC) 
743     METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
744   if (access_flags & ACC_FINAL) 
745     METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
746   if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
747   if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
748   if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
749   if (access_flags & ACC_SYNTHETIC) DECL_ARTIFICIAL (fndecl) = 1;
750   if (access_flags & ACC_BRIDGE) METHOD_BRIDGE (fndecl) = 1;
751   if (access_flags & ACC_VARARGS) METHOD_VARARGS (fndecl) = 1;
752   return fndecl;
753 }
754
755 /* Add a method to THIS_CLASS.
756    The method's name is NAME.
757    Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
758
759 tree
760 add_method (tree this_class, int access_flags, tree name, tree method_sig)
761 {
762   tree function_type, fndecl;
763   const unsigned char *sig
764     = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
765
766   if (sig[0] != '(')
767     fatal_error ("bad method signature");
768
769   function_type = get_type_from_signature (method_sig);
770   fndecl = add_method_1 (this_class, access_flags, name, function_type);
771   set_java_signature (TREE_TYPE (fndecl), method_sig);
772   return fndecl;
773 }
774
775 tree
776 add_field (tree class, tree name, tree field_type, int flags)
777 {
778   int is_static = (flags & ACC_STATIC) != 0;
779   tree field;
780   field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
781   TREE_CHAIN (field) = TYPE_FIELDS (class);
782   TYPE_FIELDS (class) = field;
783   DECL_CONTEXT (field) = class;
784   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
785
786   if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
787   if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
788   if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
789   if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
790   if (flags & ACC_VOLATILE) 
791     {
792       FIELD_VOLATILE (field) = 1;
793       TREE_THIS_VOLATILE (field) = 1;
794     }
795   if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
796   if (flags & ACC_ENUM) FIELD_ENUM (field) = 1;
797   if (flags & ACC_SYNTHETIC) FIELD_SYNTHETIC (field) = 1;
798   if (is_static)
799     {
800       FIELD_STATIC (field) = 1;
801       /* Always make field externally visible.  This is required so
802          that native methods can always access the field.  */
803       TREE_PUBLIC (field) = 1;
804       /* Considered external unless we are compiling it into this
805          object file.  */
806       DECL_EXTERNAL (field) = (is_compiled_class (class) != 2);
807     }
808
809   return field;
810 }
811
812 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
813
814 void
815 set_constant_value (tree field, tree constant)
816 {
817   if (field == NULL_TREE)
818     warning (OPT_Wattributes,
819              "misplaced ConstantValue attribute (not in any field)");
820   else if (DECL_INITIAL (field) != NULL_TREE)
821     warning (OPT_Wattributes,
822              "duplicate ConstantValue attribute for field '%s'",
823              IDENTIFIER_POINTER (DECL_NAME (field)));
824   else
825     {
826       DECL_INITIAL (field) = constant;
827       if (TREE_TYPE (constant) != TREE_TYPE (field)
828           && ! (TREE_TYPE (constant) == int_type_node
829                 && INTEGRAL_TYPE_P (TREE_TYPE (field))
830                 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
831           && ! (TREE_TYPE (constant) == utf8const_ptr_type
832                 && TREE_TYPE (field) == string_ptr_type_node))
833         error ("ConstantValue attribute of field '%s' has wrong type",
834                IDENTIFIER_POINTER (DECL_NAME (field)));
835       if (FIELD_FINAL (field))
836         DECL_FIELD_FINAL_IUD (field) = 1;
837     }
838 }
839
840 /* Calculate a hash value for a string encoded in Utf8 format.
841  * This returns the same hash value as specified for java.lang.String.hashCode.
842  */
843
844 static int32
845 hashUtf8String (const char *str, int len)
846 {
847   const unsigned char* ptr = (const unsigned char*) str;
848   const unsigned char *limit = ptr + len;
849   int32 hash = 0;
850   for (; ptr < limit;)
851     {
852       int ch = UTF8_GET (ptr, limit);
853       /* Updated specification from
854          http://www.javasoft.com/docs/books/jls/clarify.html. */
855       hash = (31 * hash) + ch;
856     }
857   return hash;
858 }
859
860 static GTY(()) tree utf8_decl_list = NULL_TREE;
861
862 tree
863 build_utf8_ref (tree name)
864 {
865   const char * name_ptr = IDENTIFIER_POINTER(name);
866   int name_len = IDENTIFIER_LENGTH(name);
867   char buf[60];
868   tree ctype, field = NULL_TREE, str_type, cinit, string;
869   static int utf8_count = 0;
870   int name_hash;
871   tree ref = IDENTIFIER_UTF8_REF (name);
872   tree decl;
873   if (ref != NULL_TREE)
874     return ref;
875
876   ctype = make_node (RECORD_TYPE);
877   str_type = build_prim_array_type (unsigned_byte_type_node,
878                                     name_len + 1); /* Allow for final '\0'. */
879   PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
880   PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
881   PUSH_FIELD (ctype, field, "data", str_type);
882   FINISH_RECORD (ctype);
883   START_RECORD_CONSTRUCTOR (cinit, ctype);
884   name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
885   PUSH_FIELD_VALUE (cinit, "hash", build_int_cst (NULL_TREE, name_hash));
886   PUSH_FIELD_VALUE (cinit, "length", build_int_cst (NULL_TREE, name_len));
887   string = build_string (name_len, name_ptr);
888   TREE_TYPE (string) = str_type;
889   PUSH_FIELD_VALUE (cinit, "data", string);
890   FINISH_RECORD_CONSTRUCTOR (cinit);
891   TREE_CONSTANT (cinit) = 1;
892   TREE_INVARIANT (cinit) = 1;
893
894   /* Generate a unique-enough identifier.  */
895   sprintf(buf, "_Utf%d", ++utf8_count);
896
897   decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
898   TREE_STATIC (decl) = 1;
899   DECL_ARTIFICIAL (decl) = 1;
900   DECL_IGNORED_P (decl) = 1;
901   TREE_READONLY (decl) = 1;
902   TREE_THIS_VOLATILE (decl) = 0;
903   DECL_INITIAL (decl) = cinit;
904
905   if (HAVE_GAS_SHF_MERGE)
906     {
907       int decl_size;
908       /* Ensure decl_size is a multiple of utf8const_type's alignment. */
909       decl_size = (name_len + 5 + TYPE_ALIGN_UNIT (utf8const_type) - 1)
910         & ~(TYPE_ALIGN_UNIT (utf8const_type) - 1);
911       if (flag_merge_constants && decl_size < 256)
912         {
913           char buf[32];
914           int flags = (SECTION_OVERRIDE
915                        | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
916           sprintf (buf, ".rodata.jutf8.%d", decl_size);
917           switch_to_section (get_section (buf, flags, NULL));
918           DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf);
919         }
920     }
921
922   TREE_CHAIN (decl) = utf8_decl_list;
923   layout_decl (decl, 0);
924   pushdecl (decl);
925   rest_of_decl_compilation (decl, global_bindings_p (), 0);
926   varpool_mark_needed_node (varpool_node (decl));
927   utf8_decl_list = decl;
928   ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
929   IDENTIFIER_UTF8_REF (name) = ref;
930   return ref;
931 }
932
933 /* Like build_class_ref, but instead of a direct reference generate a
934    pointer into the constant pool.  */
935
936 static tree
937 build_indirect_class_ref (tree type)
938 {
939   int index;
940   tree cl;
941   index = alloc_class_constant (type);
942   cl = build_ref_from_constant_pool (index); 
943   return convert (promote_type (class_ptr_type), cl);
944 }
945
946 static tree
947 build_static_class_ref (tree type)
948 {
949   tree decl_name, decl, ref;
950
951   if (TYPE_SIZE (type) == error_mark_node)
952     return null_pointer_node;
953   decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
954                                 "", '/', '/', ".class$$");
955   decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
956   if (decl == NULL_TREE)
957     {
958       decl = build_decl (VAR_DECL, decl_name, class_type_node);
959       TREE_STATIC (decl) = 1;
960       if (! flag_indirect_classes)
961         TREE_PUBLIC (decl) = 1;
962       DECL_IGNORED_P (decl) = 1;
963       DECL_ARTIFICIAL (decl) = 1;
964       if (is_compiled_class (type) == 1)
965         DECL_EXTERNAL (decl) = 1;
966       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
967       DECL_CLASS_FIELD_P (decl) = 1;
968       DECL_CONTEXT (decl) = type;
969
970       /* ??? We want to preserve the DECL_CONTEXT we set just above,
971          that that means not calling pushdecl_top_level.  */
972       IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
973     }
974
975   ref = build1 (ADDR_EXPR, class_ptr_type, decl);
976   return ref;
977 }
978
979 static tree
980 build_classdollar_field (tree type)
981 {
982   tree decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
983                                      "", '/', '/', ".class$");
984   tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
985
986   if (decl == NULL_TREE)
987     {
988       decl 
989         = build_decl (VAR_DECL, decl_name, 
990                       (build_type_variant 
991                        (build_pointer_type 
992                         (build_type_variant (class_type_node, 
993                                              /* const */ 1, 0)),
994                         /* const */ 1, 0)));
995       TREE_STATIC (decl) = 1;
996       TREE_INVARIANT (decl) = 1;
997       TREE_CONSTANT (decl) = 1;
998       TREE_READONLY (decl) = 1;
999       TREE_PUBLIC (decl) = 1;
1000       DECL_IGNORED_P (decl) = 1;
1001       DECL_ARTIFICIAL (decl) = 1;
1002       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1003       IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
1004       DECL_CLASS_FIELD_P (decl) = 1;
1005       DECL_CONTEXT (decl) = type;
1006     }
1007
1008   return decl;
1009 }
1010
1011 /* Create a local variable that holds the the current class$.  */
1012
1013 void
1014 cache_this_class_ref (tree fndecl)
1015 {
1016   if (optimize)
1017     {
1018       tree classdollar_field;
1019       if (flag_indirect_classes)
1020         classdollar_field = build_classdollar_field (output_class);
1021       else
1022         classdollar_field = build_static_class_ref (output_class);
1023
1024       this_classdollar = build_decl (VAR_DECL, NULL_TREE, 
1025                                      TREE_TYPE (classdollar_field));
1026       
1027       java_add_local_var (this_classdollar);
1028       java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (this_classdollar), 
1029                              this_classdollar, classdollar_field));
1030     }
1031   else
1032     this_classdollar = build_classdollar_field (output_class);
1033
1034   /* Prepend class initialization for static methods reachable from
1035      other classes.  */
1036   if (METHOD_STATIC (fndecl)
1037       && (! METHOD_PRIVATE (fndecl)
1038           || INNER_CLASS_P (DECL_CONTEXT (fndecl)))
1039       && ! DECL_CLINIT_P (fndecl)
1040       && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl))))
1041     {
1042       tree init = build3 (CALL_EXPR, void_type_node,
1043                           build_address_of (soft_initclass_node),
1044                           build_tree_list (NULL_TREE, this_classdollar),
1045                           NULL_TREE);
1046       java_add_stmt (init);
1047     }
1048 }
1049
1050 /* Build a reference to the class TYPE.
1051    Also handles primitive types and array types. */
1052
1053 tree
1054 build_class_ref (tree type)
1055 {
1056   int is_compiled = is_compiled_class (type);
1057   if (is_compiled)
1058     {
1059       tree ref, decl;
1060       if (TREE_CODE (type) == POINTER_TYPE)
1061         type = TREE_TYPE (type);
1062
1063       if (flag_indirect_dispatch
1064           && type != output_class
1065           && TREE_CODE (type) == RECORD_TYPE)
1066         return build_indirect_class_ref (type);
1067
1068       if (type == output_class && flag_indirect_classes)
1069         return this_classdollar;
1070       
1071       if (TREE_CODE (type) == RECORD_TYPE)
1072         return build_static_class_ref (type);
1073       else
1074         {
1075           const char *name;
1076           tree decl_name;
1077           char buffer[25];
1078           decl_name = TYPE_NAME (type);
1079           if (TREE_CODE (decl_name) == TYPE_DECL)
1080             decl_name = DECL_NAME (decl_name);
1081           name = IDENTIFIER_POINTER (decl_name);
1082           if (strncmp (name, "promoted_", 9) == 0)
1083             name += 9;
1084           sprintf (buffer, "_Jv_%sClass", name);
1085           decl_name = get_identifier (buffer);
1086           decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1087           if (decl == NULL_TREE)
1088             {
1089               decl = build_decl (VAR_DECL, decl_name, class_type_node);
1090               TREE_STATIC (decl) = 1;
1091               TREE_PUBLIC (decl) = 1;
1092               DECL_EXTERNAL (decl) = 1;
1093               DECL_ARTIFICIAL (decl) = 1;
1094               pushdecl_top_level (decl);
1095             }
1096         }
1097
1098       ref = build1 (ADDR_EXPR, class_ptr_type, decl);
1099       return ref;
1100     }
1101   else
1102     return build_indirect_class_ref (type);
1103 }
1104
1105 /* Create a local statically allocated variable that will hold a
1106    pointer to a static field.  */
1107
1108 static tree
1109 build_fieldref_cache_entry (int index, tree fdecl ATTRIBUTE_UNUSED)
1110 {
1111   tree decl, decl_name;
1112   const char *name = IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class));
1113   char *buf = alloca (strlen (name) + 20);
1114   sprintf (buf, "%s_%d_ref", name, index);
1115   decl_name = get_identifier (buf);
1116   decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1117   if (decl == NULL_TREE)
1118     {
1119       decl = build_decl (VAR_DECL, decl_name, ptr_type_node);
1120       TREE_STATIC (decl) = 1;
1121       TREE_PUBLIC (decl) = 0;
1122       DECL_EXTERNAL (decl) = 0;
1123       DECL_ARTIFICIAL (decl) = 1;
1124       DECL_IGNORED_P (decl) = 1;
1125       pushdecl_top_level (decl);
1126     }
1127   return decl;
1128 }
1129
1130 tree
1131 build_static_field_ref (tree fdecl)
1132 {
1133   tree fclass = DECL_CONTEXT (fdecl);
1134   int is_compiled = is_compiled_class (fclass);
1135   int from_class = ! CLASS_FROM_SOURCE_P (current_class);
1136
1137   /* Allow static final fields to fold to a constant.  When using
1138      -findirect-dispatch, we simply never do this folding if compiling
1139      from .class; in the .class file constants will be referred to via
1140      the constant pool.  */
1141   if ((!flag_indirect_dispatch || !from_class)
1142       && (is_compiled
1143           || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
1144               && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
1145                   || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
1146               && TREE_CONSTANT (DECL_INITIAL (fdecl)))))
1147     {
1148       if (is_compiled == 1)
1149         DECL_EXTERNAL (fdecl) = 1;
1150     }
1151   else
1152     {
1153       /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1154          and a class local static variable CACHE_ENTRY, then
1155       
1156       *(fdecl **)((__builtin_expect (cache_entry == null, false)) 
1157                   ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1158                   : cache_entry)
1159
1160       This can mostly be optimized away, so that the usual path is a
1161       load followed by a test and branch.  _Jv_ResolvePoolEntry is
1162       only called once for each constant pool entry.
1163
1164       There is an optimization that we don't do: at the start of a
1165       method, create a local copy of CACHE_ENTRY and use that instead.
1166
1167       */
1168
1169       int cpool_index = alloc_constant_fieldref (output_class, fdecl);
1170       tree cache_entry = build_fieldref_cache_entry (cpool_index, fdecl);
1171       tree test 
1172         = build3 (CALL_EXPR, boolean_type_node, 
1173                   build_address_of (built_in_decls[BUILT_IN_EXPECT]),
1174                   tree_cons (NULL_TREE, build2 (EQ_EXPR, boolean_type_node,
1175                                                 cache_entry, null_pointer_node),
1176                              build_tree_list (NULL_TREE, boolean_false_node)),
1177                   NULL_TREE);
1178       tree cpool_index_cst = build_int_cst (NULL_TREE, cpool_index);
1179       tree init
1180         = build3 (CALL_EXPR, ptr_type_node,
1181                   build_address_of (soft_resolvepoolentry_node),
1182                   tree_cons (NULL_TREE, build_class_ref (output_class),
1183                              build_tree_list (NULL_TREE, cpool_index_cst)),
1184                   NULL_TREE);
1185       init = build2 (MODIFY_EXPR, ptr_type_node, cache_entry, init);
1186       init = build3 (COND_EXPR, ptr_type_node, test, init, cache_entry);
1187       init = fold_convert (build_pointer_type (TREE_TYPE (fdecl)), init);
1188       fdecl = build1 (INDIRECT_REF, TREE_TYPE (fdecl), init);
1189     }
1190   return fdecl;
1191 }
1192
1193 int
1194 get_access_flags_from_decl (tree decl)
1195 {
1196   int access_flags = 0;
1197   if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
1198     {
1199       if (FIELD_STATIC (decl))
1200         access_flags |= ACC_STATIC;
1201       if (FIELD_PUBLIC (decl))
1202         access_flags |= ACC_PUBLIC;
1203       if (FIELD_PROTECTED (decl))
1204         access_flags |= ACC_PROTECTED;
1205       if (FIELD_PRIVATE (decl))
1206         access_flags |= ACC_PRIVATE;
1207       if (FIELD_FINAL (decl))
1208         access_flags |= ACC_FINAL;
1209       if (FIELD_VOLATILE (decl))
1210         access_flags |= ACC_VOLATILE;
1211       if (FIELD_TRANSIENT (decl))
1212         access_flags |= ACC_TRANSIENT;
1213       if (FIELD_ENUM (decl))
1214         access_flags |= ACC_ENUM;
1215       if (FIELD_SYNTHETIC (decl))
1216         access_flags |= ACC_SYNTHETIC;
1217       return access_flags;
1218     }
1219   if (TREE_CODE (decl) == TYPE_DECL)
1220     {
1221       if (CLASS_PUBLIC (decl))
1222         access_flags |= ACC_PUBLIC;
1223       if (CLASS_FINAL (decl))
1224         access_flags |= ACC_FINAL;
1225       if (CLASS_SUPER (decl))
1226         access_flags |= ACC_SUPER;
1227       if (CLASS_INTERFACE (decl))
1228         access_flags |= ACC_INTERFACE;
1229       if (CLASS_ABSTRACT (decl))
1230         access_flags |= ACC_ABSTRACT;
1231       if (CLASS_STATIC (decl))
1232         access_flags |= ACC_STATIC;
1233       if (CLASS_PRIVATE (decl))
1234         access_flags |= ACC_PRIVATE;
1235       if (CLASS_PROTECTED (decl))
1236         access_flags |= ACC_PROTECTED;
1237       if (CLASS_STRICTFP (decl))
1238         access_flags |= ACC_STRICT;
1239       if (CLASS_ENUM (decl))
1240         access_flags |= ACC_ENUM;
1241       if (CLASS_SYNTHETIC (decl))
1242         access_flags |= ACC_SYNTHETIC;
1243       if (CLASS_ANNOTATION (decl))
1244         access_flags |= ACC_ANNOTATION;
1245       return access_flags;
1246     }
1247   if (TREE_CODE (decl) == FUNCTION_DECL)
1248     {
1249       if (METHOD_PUBLIC (decl))
1250         access_flags |= ACC_PUBLIC;
1251       if (METHOD_PRIVATE (decl))
1252         access_flags |= ACC_PRIVATE;
1253       if (METHOD_PROTECTED (decl))
1254         access_flags |= ACC_PROTECTED;
1255       if (METHOD_STATIC (decl))
1256         access_flags |= ACC_STATIC;
1257       if (METHOD_FINAL (decl))
1258         access_flags |= ACC_FINAL;
1259       if (METHOD_SYNCHRONIZED (decl))
1260         access_flags |= ACC_SYNCHRONIZED;
1261       if (METHOD_NATIVE (decl))
1262         access_flags |= ACC_NATIVE;
1263       if (METHOD_ABSTRACT (decl))
1264         access_flags |= ACC_ABSTRACT;
1265       if (METHOD_STRICTFP (decl))
1266         access_flags |= ACC_STRICT;
1267       if (METHOD_INVISIBLE (decl))
1268         access_flags |= ACC_INVISIBLE;
1269       if (DECL_ARTIFICIAL (decl))
1270         access_flags |= ACC_SYNTHETIC;
1271       if (METHOD_BRIDGE (decl))
1272         access_flags |= ACC_BRIDGE;
1273       if (METHOD_VARARGS (decl))
1274         access_flags |= ACC_VARARGS;
1275       return access_flags;
1276     }
1277   gcc_unreachable ();
1278 }
1279
1280 static GTY (()) int alias_labelno = 0;
1281
1282 /* Create a private alias for METHOD. Using this alias instead of the method
1283    decl ensures that ncode entries in the method table point to the real function 
1284    at runtime, not a PLT entry.  */
1285
1286 static tree
1287 make_local_function_alias (tree method)
1288 {
1289 #ifdef ASM_OUTPUT_DEF
1290   tree alias;
1291   
1292   const char *method_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method));
1293   char *name = alloca (strlen (method_name) + 2);
1294   char *buf = alloca (strlen (method_name) + 128);
1295
1296   /* Only create aliases for local functions.  */
1297   if (DECL_EXTERNAL (method))
1298     return method;
1299     
1300   /* Prefix method_name with 'L' for the alias label.  */
1301   *name = 'L';
1302   strcpy (name + 1, method_name);
1303
1304   ASM_GENERATE_INTERNAL_LABEL (buf, name, alias_labelno++);  
1305   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
1306                       TREE_TYPE (method));
1307   DECL_CONTEXT (alias) = NULL;
1308   TREE_READONLY (alias) = TREE_READONLY (method);
1309   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (method);
1310   TREE_PUBLIC (alias) = 0;
1311   DECL_EXTERNAL (alias) = 0;
1312   DECL_ARTIFICIAL (alias) = 1;
1313   DECL_INLINE (alias) = 0;
1314   DECL_INITIAL (alias) = error_mark_node;
1315   TREE_ADDRESSABLE (alias) = 1;
1316   TREE_USED (alias) = 1;
1317   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
1318   if (!flag_syntax_only)
1319     assemble_alias (alias, DECL_ASSEMBLER_NAME (method));
1320   return alias;
1321 #else
1322   return method;
1323 #endif
1324 }
1325
1326 /** Make reflection data (_Jv_Field) for field FDECL. */
1327
1328 static tree
1329 make_field_value (tree fdecl)
1330 {
1331   tree finit;
1332   int flags;
1333   tree type = TREE_TYPE (fdecl);
1334   int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
1335
1336   START_RECORD_CONSTRUCTOR (finit, field_type_node);
1337   PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1338   if (resolved)
1339     type = build_class_ref (type);
1340   else
1341     {
1342       tree signature = build_java_signature (type);
1343
1344       type = build_utf8_ref (unmangle_classname 
1345                              (IDENTIFIER_POINTER (signature),
1346                               IDENTIFIER_LENGTH (signature)));
1347     }
1348   PUSH_FIELD_VALUE (finit, "type", type);
1349
1350   flags = get_access_flags_from_decl (fdecl);
1351   if (! resolved)
1352     flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1353
1354   PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags));
1355   PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1356
1357   {
1358     tree field_address = integer_zero_node;
1359     if ((DECL_INITIAL (fdecl) || ! flag_indirect_classes) 
1360         && FIELD_STATIC (fdecl))
1361       field_address = build_address_of (fdecl);
1362
1363     PUSH_FIELD_VALUE
1364       (finit, "info",
1365        build_constructor_from_list (field_info_union_node,
1366          build_tree_list
1367            ((FIELD_STATIC (fdecl)
1368              ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1369              : TYPE_FIELDS (field_info_union_node)),
1370             (FIELD_STATIC (fdecl)
1371              ? field_address
1372              : byte_position (fdecl)))));
1373   }
1374
1375   FINISH_RECORD_CONSTRUCTOR (finit);
1376   return finit;
1377 }
1378
1379 /** Make reflection data (_Jv_Method) for method MDECL. */
1380
1381 static tree
1382 make_method_value (tree mdecl)
1383 {
1384   static int method_name_count = 0;
1385   tree minit;
1386   tree index;
1387   tree code;
1388   tree class_decl;
1389 #define ACC_TRANSLATED          0x4000
1390   int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1391
1392   class_decl = DECL_CONTEXT (mdecl);
1393   /* For interfaces, the index field contains the dispatch index. */
1394   if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
1395     index = build_int_cst (NULL_TREE,
1396                            get_interface_method_index (mdecl, class_decl));
1397   else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
1398     index = get_method_index (mdecl);
1399   else
1400     index = integer_minus_one_node;
1401
1402   code = null_pointer_node;
1403   if (METHOD_ABSTRACT (mdecl))
1404     code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1405                    soft_abstractmethod_node);
1406   else
1407     code = build1 (ADDR_EXPR, nativecode_ptr_type_node, 
1408                    make_local_function_alias (mdecl));
1409   START_RECORD_CONSTRUCTOR (minit, method_type_node);
1410   PUSH_FIELD_VALUE (minit, "name",
1411                     build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1412                                     init_identifier_node
1413                                     : DECL_NAME (mdecl)));
1414   {
1415     tree signature = build_java_signature (TREE_TYPE (mdecl));
1416     PUSH_FIELD_VALUE (minit, "signature", 
1417                       (build_utf8_ref 
1418                        (unmangle_classname 
1419                         (IDENTIFIER_POINTER(signature),
1420                          IDENTIFIER_LENGTH(signature)))));
1421   }
1422   PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags));
1423   PUSH_FIELD_VALUE (minit, "index", index);
1424   PUSH_FIELD_VALUE (minit, "ncode", code);
1425
1426   {
1427     /* Compute the `throws' information for the method.  */
1428     tree table = null_pointer_node;
1429     if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1430       {
1431         int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1432         tree iter, type, array;
1433         char buf[60];
1434
1435         table = tree_cons (NULL_TREE, table, NULL_TREE);
1436         for (iter = DECL_FUNCTION_THROWS (mdecl);
1437              iter != NULL_TREE;
1438              iter = TREE_CHAIN (iter))
1439           {
1440             tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1441             tree utf8
1442               = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1443                                                     IDENTIFIER_LENGTH (sig)));
1444             table = tree_cons (NULL_TREE, utf8, table);
1445           }
1446         type = build_prim_array_type (ptr_type_node, length);
1447         table = build_constructor_from_list (type, table);
1448         /* Compute something unique enough.  */
1449         sprintf (buf, "_methods%d", method_name_count++);
1450         array = build_decl (VAR_DECL, get_identifier (buf), type);
1451         DECL_INITIAL (array) = table;
1452         TREE_STATIC (array) = 1;
1453         DECL_ARTIFICIAL (array) = 1;
1454         DECL_IGNORED_P (array) = 1;
1455         rest_of_decl_compilation (array, 1, 0);
1456
1457         table = build1 (ADDR_EXPR, ptr_type_node, array);
1458       }
1459
1460     PUSH_FIELD_VALUE (minit, "throws", table);
1461   }
1462
1463   FINISH_RECORD_CONSTRUCTOR (minit);
1464   return minit;
1465 }
1466
1467 static tree
1468 get_dispatch_vector (tree type)
1469 {
1470   tree vtable = TYPE_VTABLE (type);
1471
1472   if (vtable == NULL_TREE)
1473     {
1474       HOST_WIDE_INT i;
1475       tree method;
1476       tree super = CLASSTYPE_SUPER (type);
1477       HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1478       vtable = make_tree_vec (nvirtuals);
1479       TYPE_VTABLE (type) = vtable;
1480       if (super != NULL_TREE)
1481         {
1482           tree super_vtable = get_dispatch_vector (super);
1483
1484           for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1485             TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1486         }
1487
1488       for (method = TYPE_METHODS (type);  method != NULL_TREE;
1489            method = TREE_CHAIN (method))
1490         {
1491           tree method_index = get_method_index (method);
1492           if (method_index != NULL_TREE
1493               && host_integerp (method_index, 0))
1494             TREE_VEC_ELT (vtable, tree_low_cst (method_index, 0)) = method;
1495         }
1496     }
1497
1498   return vtable;
1499 }
1500
1501 static tree
1502 get_dispatch_table (tree type, tree this_class_addr)
1503 {
1504   int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1505   tree vtable = get_dispatch_vector (type);
1506   int i, j;
1507   tree list = NULL_TREE;
1508   int nvirtuals = TREE_VEC_LENGTH (vtable);
1509   int arraysize;
1510   tree gc_descr;
1511
1512   for (i = nvirtuals;  --i >= 0; )
1513     {
1514       tree method = TREE_VEC_ELT (vtable, i);
1515       if (METHOD_ABSTRACT (method))
1516         {
1517           if (! abstract_p)
1518             warning (0, "%Jabstract method in non-abstract class", method);
1519
1520           if (TARGET_VTABLE_USES_DESCRIPTORS)
1521             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1522               list = tree_cons (NULL_TREE, null_pointer_node, list);
1523           else
1524             list = tree_cons (NULL_TREE, null_pointer_node, list);
1525         }
1526       else
1527         {
1528           if (TARGET_VTABLE_USES_DESCRIPTORS)
1529             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1530               {
1531                 tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node, 
1532                                      method, build_int_cst (NULL_TREE, j));
1533                 TREE_CONSTANT (fdesc) = 1;
1534                 TREE_INVARIANT (fdesc) = 1;
1535                 list = tree_cons (NULL_TREE, fdesc, list);
1536               }
1537           else
1538             list = tree_cons (NULL_TREE,
1539                               build1 (ADDR_EXPR, nativecode_ptr_type_node,
1540                                       method),
1541                               list);
1542         }
1543     }
1544
1545   /* Dummy entry for compatibility with G++ -fvtable-thunks.  When
1546      using the Boehm GC we sometimes stash a GC type descriptor
1547      there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1548      the emitted byte count during the output to the assembly file. */
1549   /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1550      fake "function descriptor".  It's first word is the is the class
1551      pointer, and subsequent words (usually one) contain the GC descriptor.
1552      In all other cases, we reserve two extra vtable slots. */
1553   gc_descr =  get_boehm_type_descriptor (type);
1554   list = tree_cons (NULL_TREE, gc_descr, list);
1555   for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1556     list = tree_cons (NULL_TREE, gc_descr, list);
1557   list = tree_cons (NULL_TREE, this_class_addr, list);
1558
1559   /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1560   list = tree_cons (NULL_TREE, null_pointer_node, list);
1561   /** Offset to start of whole object.  Always (ptrdiff_t)0 for Java. */
1562   list = tree_cons (integer_zero_node, null_pointer_node, list);
1563
1564   arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1565   if (TARGET_VTABLE_USES_DESCRIPTORS)
1566     arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1567   arraysize += 2;
1568   return build_constructor_from_list
1569           (build_prim_array_type (nativecode_ptr_type_node,
1570                                   arraysize), list);
1571 }
1572
1573
1574 /* Set the method_index for a method decl.  */
1575 void
1576 set_method_index (tree decl, tree method_index)
1577 {
1578   if (method_index != NULL_TREE)
1579     {
1580       /* method_index is null if we're using indirect dispatch.  */
1581       method_index = fold (convert (sizetype, method_index));
1582
1583       if (TARGET_VTABLE_USES_DESCRIPTORS)
1584         /* Add one to skip bogus descriptor for class and GC descriptor. */
1585         method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1586       else
1587         /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1588            descriptor.  */
1589         method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1590     }
1591
1592   DECL_VINDEX (decl) = method_index;
1593 }
1594
1595 /* Get the method_index for a method decl.  */
1596 tree
1597 get_method_index (tree decl)
1598 {
1599   tree method_index = DECL_VINDEX (decl);
1600
1601   if (! method_index)
1602     return NULL;
1603
1604   if (TARGET_VTABLE_USES_DESCRIPTORS)
1605     /* Sub one to skip bogus descriptor for class and GC descriptor. */
1606     method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
1607   else
1608     /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor.  */
1609     method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
1610
1611   return method_index;
1612 }
1613
1614 static int
1615 supers_all_compiled (tree type)
1616 {
1617   while (type != NULL_TREE)
1618     {
1619       if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1620         return 0;
1621       type = CLASSTYPE_SUPER (type);
1622     }
1623   return 1;
1624 }
1625
1626 void
1627 make_class_data (tree type)
1628 {
1629   tree decl, cons, temp;
1630   tree field, fields_decl;
1631   tree static_fields = NULL_TREE;
1632   tree instance_fields = NULL_TREE;
1633   HOST_WIDE_INT static_field_count = 0;
1634   HOST_WIDE_INT instance_field_count = 0;
1635   HOST_WIDE_INT field_count;
1636   tree field_array_type;
1637   tree method;
1638   tree methods = NULL_TREE;
1639   tree dtable_decl = NULL_TREE;
1640   HOST_WIDE_INT method_count = 0;
1641   tree method_array_type;
1642   tree methods_decl;
1643   tree super;
1644   tree this_class_addr;
1645   tree constant_pool_constructor;
1646   tree interfaces = null_pointer_node;
1647   int interface_len = 0;
1648   int uses_jv_markobj = 0;
1649   tree type_decl = TYPE_NAME (type);
1650   tree id_main = get_identifier("main");
1651   tree id_class = get_identifier("java.lang.Class");
1652   /** Offset from start of virtual function table declaration
1653       to where objects actually point at, following new g++ ABI. */
1654   tree dtable_start_offset = build_int_cst (NULL_TREE,
1655                                             2 * POINTER_SIZE / BITS_PER_UNIT);
1656   VEC(int, heap) *field_indexes;
1657   tree first_real_field;
1658
1659   this_class_addr = build_static_class_ref (type);
1660   decl = TREE_OPERAND (this_class_addr, 0);
1661
1662   if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1663       && !flag_indirect_dispatch)
1664     {
1665       tree dtable = get_dispatch_table (type, this_class_addr);
1666       uses_jv_markobj = uses_jv_markobj_p (dtable);
1667       if (type == class_type_node && class_dtable_decl != NULL_TREE)
1668         {
1669           /* We've already created some other class, and consequently
1670              we made class_dtable_decl.  Now we just want to fill it
1671              in.  */
1672           dtable_decl = class_dtable_decl;
1673         }
1674       else
1675         {
1676           dtable_decl = build_dtable_decl (type);
1677           TREE_STATIC (dtable_decl) = 1;
1678           DECL_ARTIFICIAL (dtable_decl) = 1;
1679           DECL_IGNORED_P (dtable_decl) = 1;
1680         }
1681
1682       TREE_PUBLIC (dtable_decl) = 1;
1683       DECL_INITIAL (dtable_decl) = dtable;
1684       if (! flag_indirect_classes)
1685         rest_of_decl_compilation (dtable_decl, 1, 0);
1686       /* Maybe we're compiling Class as the first class.  If so, set
1687          class_dtable_decl to the decl we just made.  */
1688       if (type == class_type_node && class_dtable_decl == NULL_TREE)
1689         class_dtable_decl = dtable_decl;
1690     }
1691
1692   /* Build Field array. */
1693   field = TYPE_FIELDS (type);
1694   while (field && DECL_ARTIFICIAL (field))
1695     field = TREE_CHAIN (field);  /* Skip dummy fields.  */
1696   if (field && DECL_NAME (field) == NULL_TREE)
1697     field = TREE_CHAIN (field);  /* Skip dummy field for inherited data. */
1698   first_real_field = field;
1699
1700   /* First count static and instance fields.  */
1701   for ( ; field != NULL_TREE; field = TREE_CHAIN (field))
1702     {
1703       if (! DECL_ARTIFICIAL (field))
1704         {
1705           if (FIELD_STATIC (field))
1706             static_field_count++;
1707           else if (uses_jv_markobj || !flag_reduced_reflection)
1708             instance_field_count++;
1709         }
1710     }
1711   field_count = static_field_count + instance_field_count;
1712   field_indexes = VEC_alloc (int, heap, field_count);
1713   
1714   /* gcj sorts fields so that static fields come first, followed by
1715      instance fields.  Unfortunately, by the time this takes place we
1716      have already generated the reflection_data for this class, and
1717      that data contains indexes into the fields.  So, we generate a
1718      permutation that maps each original field index to its final
1719      position.  Then we pass this permutation to
1720      rewrite_reflection_indexes(), which fixes up the reflection
1721      data.  */
1722   {
1723     int i;
1724     int static_count = 0;
1725     int instance_count = static_field_count;
1726     int field_index;
1727
1728     for (i = 0, field = first_real_field; 
1729          field != NULL_TREE; 
1730          field = TREE_CHAIN (field), i++)
1731     {
1732       if (! DECL_ARTIFICIAL (field))
1733         {
1734           field_index = 0;
1735           if (FIELD_STATIC (field))
1736             field_index = static_count++;
1737           else if (uses_jv_markobj || !flag_reduced_reflection)
1738             field_index = instance_count++;
1739           VEC_quick_push (int, field_indexes, field_index);
1740         }
1741     }
1742   }
1743
1744   for (field = first_real_field; field != NULL_TREE; 
1745        field = TREE_CHAIN (field))
1746     {
1747       if (! DECL_ARTIFICIAL (field))
1748         {
1749           if (FIELD_STATIC (field))
1750             {
1751               /* We must always create reflection data for static fields
1752                  as it is used in the creation of the field itself. */
1753               tree init = make_field_value (field);
1754               tree initial = DECL_INITIAL (field);
1755               static_fields = tree_cons (NULL_TREE, init, static_fields);
1756               /* If the initial value is a string constant,
1757                  prevent output_constant from trying to assemble the value. */
1758               if (initial != NULL_TREE
1759                   && TREE_TYPE (initial) == string_ptr_type_node)
1760                 DECL_INITIAL (field) = NULL_TREE;
1761               rest_of_decl_compilation (field, 1, 1);
1762               DECL_INITIAL (field) = initial;
1763             }
1764           else if (uses_jv_markobj || !flag_reduced_reflection)
1765             {
1766               tree init = make_field_value (field);
1767               instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1768             }
1769         }
1770     }
1771
1772   if (field_count > 0)
1773     {
1774       static_fields = nreverse (static_fields);
1775       instance_fields = nreverse (instance_fields);
1776       static_fields = chainon (static_fields, instance_fields);
1777       field_array_type = build_prim_array_type (field_type_node, field_count);
1778       fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1779                                 field_array_type);
1780       DECL_INITIAL (fields_decl) = build_constructor_from_list
1781                                     (field_array_type, static_fields);
1782       TREE_STATIC (fields_decl) = 1;
1783       DECL_ARTIFICIAL (fields_decl) = 1;
1784       DECL_IGNORED_P (fields_decl) = 1;
1785       rest_of_decl_compilation (fields_decl, 1, 0);
1786     }
1787   else
1788     fields_decl = NULL_TREE;
1789
1790   /* Build Method array. */
1791   for (method = TYPE_METHODS (type);
1792        method != NULL_TREE; method = TREE_CHAIN (method))
1793     {
1794       tree init;
1795       if (METHOD_PRIVATE (method)
1796           && ! flag_keep_inline_functions
1797           && optimize)
1798         continue;
1799       /* Even if we have a decl, we don't necessarily have the code.
1800          This can happen if we inherit a method from a superclass for
1801          which we don't have a .class file.  */
1802       if (METHOD_DUMMY (method))
1803         continue;
1804
1805       /* Generate method reflection data if:
1806
1807           - !flag_reduced_reflection.
1808
1809           - <clinit> -- The runtime uses reflection to initialize the
1810             class.
1811
1812           - Any method in class java.lang.Class -- Class.forName() and
1813             perhaps other things require it.
1814
1815           - class$ -- It does not work if reflection data missing.
1816
1817           - main -- Reflection is used to find main(String[]) methods.
1818
1819           - public not static -- It is potentially part of an
1820             interface.  The runtime uses reflection data to build
1821             interface dispatch tables.  */
1822       if (!flag_reduced_reflection
1823           || DECL_CLINIT_P (method)
1824           || DECL_NAME (type_decl) == id_class
1825           || DECL_NAME (method) == id_main
1826           || (METHOD_PUBLIC (method) && !METHOD_STATIC (method))
1827           || TYPE_DOT_CLASS (type) == method)
1828         {
1829           init = make_method_value (method);
1830           method_count++;
1831           methods = tree_cons (NULL_TREE, init, methods);
1832         }
1833     }
1834   method_array_type = build_prim_array_type (method_type_node, method_count);
1835   methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1836                              method_array_type);
1837   DECL_INITIAL (methods_decl) = build_constructor_from_list
1838                                  (method_array_type, nreverse (methods));
1839   TREE_STATIC (methods_decl) = 1;
1840   DECL_ARTIFICIAL (methods_decl) = 1;
1841   DECL_IGNORED_P (methods_decl) = 1;
1842   rest_of_decl_compilation (methods_decl, 1, 0);
1843
1844   if (class_dtable_decl == NULL_TREE)
1845     {
1846       class_dtable_decl = build_dtable_decl (class_type_node);
1847       TREE_STATIC (class_dtable_decl) = 1;
1848       DECL_ARTIFICIAL (class_dtable_decl) = 1;
1849       DECL_IGNORED_P (class_dtable_decl) = 1;
1850       if (is_compiled_class (class_type_node) != 2)
1851         {
1852           DECL_EXTERNAL (class_dtable_decl) = 1;
1853           rest_of_decl_compilation (class_dtable_decl, 1, 0);
1854         }
1855     }
1856
1857   super = CLASSTYPE_SUPER (type);
1858   if (super == NULL_TREE)
1859     super = null_pointer_node;
1860   else if (! flag_indirect_dispatch
1861            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1862            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1863     super = build_class_ref (super);
1864   else
1865     {
1866       int super_index = alloc_class_constant (super);
1867       super = build_int_cst (ptr_type_node, super_index);
1868     }
1869
1870   /* Build and emit the array of implemented interfaces. */
1871   if (type != object_type_node)
1872     interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
1873   
1874   if (interface_len > 0)
1875     {
1876       tree init = NULL_TREE;
1877       int i;
1878       tree interface_array_type, idecl;
1879       interface_array_type
1880         = build_prim_array_type (class_ptr_type, interface_len);
1881       idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1882                           interface_array_type);
1883       
1884       for (i = interface_len;  i > 0; i--)
1885         {
1886           tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
1887           tree iclass = BINFO_TYPE (child);
1888           tree index;
1889           if (! flag_indirect_dispatch
1890               && (assume_compiled 
1891                   (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
1892             index = build_class_ref (iclass);
1893           else
1894             {
1895               int int_index = alloc_class_constant (iclass);
1896               index = build_int_cst (ptr_type_node, int_index);
1897             }
1898           init = tree_cons (NULL_TREE, index, init); 
1899         }
1900       DECL_INITIAL (idecl) = build_constructor_from_list (interface_array_type,
1901                                                           init);
1902       TREE_STATIC (idecl) = 1;
1903       DECL_ARTIFICIAL (idecl) = 1;
1904       DECL_IGNORED_P (idecl) = 1;
1905       interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1906       rest_of_decl_compilation (idecl, 1, 0);
1907     }
1908
1909   constant_pool_constructor = build_constants_constructor ();
1910
1911   if (flag_indirect_dispatch)
1912     {
1913       TYPE_OTABLE_DECL (type) 
1914         = emit_symbol_table 
1915         (DECL_NAME (TYPE_OTABLE_DECL (type)), 
1916          TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type), 
1917          TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
1918        
1919       TYPE_ATABLE_DECL (type) 
1920         = emit_symbol_table 
1921         (DECL_NAME (TYPE_ATABLE_DECL (type)), 
1922          TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type), 
1923          TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
1924        
1925       TYPE_ITABLE_DECL (type) 
1926         = emit_symbol_table 
1927         (DECL_NAME (TYPE_ITABLE_DECL (type)), 
1928          TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type), 
1929          TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
1930     }
1931   
1932   TYPE_CTABLE_DECL (type) = emit_catch_table (type);
1933
1934   START_RECORD_CONSTRUCTOR (temp, object_type_node);
1935   PUSH_FIELD_VALUE (temp, "vtable",
1936                     (flag_indirect_classes 
1937                      ? null_pointer_node
1938                      : build2 (PLUS_EXPR, dtable_ptr_type,
1939                                build1 (ADDR_EXPR, dtable_ptr_type,
1940                                        class_dtable_decl),
1941                                dtable_start_offset)));
1942   if (! flag_hash_synchronization)
1943     PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1944   FINISH_RECORD_CONSTRUCTOR (temp);
1945   START_RECORD_CONSTRUCTOR (cons, class_type_node);
1946   PUSH_SUPER_VALUE (cons, temp);
1947   PUSH_FIELD_VALUE (cons, "next_or_version", gcj_abi_version);
1948   PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1949   PUSH_FIELD_VALUE (cons, "accflags",
1950                     build_int_cst (NULL_TREE,
1951                                    get_access_flags_from_decl (type_decl)));
1952
1953   PUSH_FIELD_VALUE (cons, "superclass", 
1954                     CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1955   PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1956   PUSH_FIELD_VALUE (cons, "methods",
1957                     methods_decl == NULL_TREE ? null_pointer_node
1958                     : build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1959   PUSH_FIELD_VALUE (cons, "method_count",
1960                     build_int_cst (NULL_TREE, method_count));
1961
1962   if (flag_indirect_dispatch)
1963     PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node);
1964   else
1965     PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1966     
1967   PUSH_FIELD_VALUE (cons, "fields",
1968                     fields_decl == NULL_TREE ? null_pointer_node
1969                     : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1970   /* If we're using the binary compatibility ABI we don't know the
1971      size until load time.  */
1972   PUSH_FIELD_VALUE (cons, "size_in_bytes", 
1973                     (flag_indirect_dispatch 
1974                      ? integer_minus_one_node 
1975                      : size_in_bytes (type)));
1976   PUSH_FIELD_VALUE (cons, "field_count", 
1977                     build_int_cst (NULL_TREE, field_count));
1978   PUSH_FIELD_VALUE (cons, "static_field_count",
1979                     build_int_cst (NULL_TREE, static_field_count));
1980
1981   if (flag_indirect_dispatch)
1982     PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node);
1983   else
1984     PUSH_FIELD_VALUE (cons, "vtable",
1985                       dtable_decl == NULL_TREE ? null_pointer_node
1986                       : build2 (PLUS_EXPR, dtable_ptr_type,
1987                                 build1 (ADDR_EXPR, dtable_ptr_type,
1988                                         dtable_decl),
1989                                 dtable_start_offset));
1990   if (TYPE_OTABLE_METHODS (type) == NULL_TREE)
1991     {
1992       PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
1993       PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
1994     }
1995   else
1996     {
1997       pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type));
1998       PUSH_FIELD_VALUE (cons, "otable",
1999                         build1 (ADDR_EXPR, otable_ptr_type, TYPE_OTABLE_DECL (type)));
2000       PUSH_FIELD_VALUE (cons, "otable_syms",
2001                         build1 (ADDR_EXPR, symbols_array_ptr_type,
2002                                 TYPE_OTABLE_SYMS_DECL (type)));
2003       TREE_CONSTANT (TYPE_OTABLE_DECL (type)) = 1;
2004       TREE_INVARIANT (TYPE_OTABLE_DECL (type)) = 1;
2005     }
2006   if (TYPE_ATABLE_METHODS(type) == NULL_TREE)
2007     {
2008       PUSH_FIELD_VALUE (cons, "atable", null_pointer_node);
2009       PUSH_FIELD_VALUE (cons, "atable_syms", null_pointer_node);
2010     }
2011   else
2012     {
2013       pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type));
2014       PUSH_FIELD_VALUE (cons, "atable",
2015                         build1 (ADDR_EXPR, atable_ptr_type, TYPE_ATABLE_DECL (type)));
2016       PUSH_FIELD_VALUE (cons, "atable_syms",
2017                         build1 (ADDR_EXPR, symbols_array_ptr_type,
2018                                 TYPE_ATABLE_SYMS_DECL (type)));
2019       TREE_CONSTANT (TYPE_ATABLE_DECL (type)) = 1;
2020       TREE_INVARIANT (TYPE_ATABLE_DECL (type)) = 1;
2021     }
2022    if (TYPE_ITABLE_METHODS(type) == NULL_TREE)
2023     {
2024       PUSH_FIELD_VALUE (cons, "itable", null_pointer_node);
2025       PUSH_FIELD_VALUE (cons, "itable_syms", null_pointer_node);
2026     }
2027   else
2028     {
2029       pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type));
2030       PUSH_FIELD_VALUE (cons, "itable",
2031                         build1 (ADDR_EXPR, itable_ptr_type, TYPE_ITABLE_DECL (type)));
2032       PUSH_FIELD_VALUE (cons, "itable_syms",
2033                         build1 (ADDR_EXPR, symbols_array_ptr_type,
2034                                 TYPE_ITABLE_SYMS_DECL (type)));
2035       TREE_CONSTANT (TYPE_ITABLE_DECL (type)) = 1;
2036       TREE_INVARIANT (TYPE_ITABLE_DECL (type)) = 1;
2037     }
2038  
2039   PUSH_FIELD_VALUE (cons, "catch_classes",
2040                     build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type))); 
2041   PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
2042   PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
2043   PUSH_FIELD_VALUE (cons, "interface_count",
2044                     build_int_cst (NULL_TREE, interface_len));
2045   PUSH_FIELD_VALUE (cons, "state",
2046                     convert (byte_type_node,
2047                              build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
2048
2049   PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
2050   PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
2051   PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
2052   PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
2053   PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
2054   PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
2055
2056   {
2057     tree assertion_table_ref;
2058     if (TYPE_ASSERTIONS (type) == NULL)
2059       assertion_table_ref = null_pointer_node;
2060     else
2061       assertion_table_ref = build1 (ADDR_EXPR, 
2062                                     build_pointer_type (assertion_table_type),
2063                                     emit_assertion_table (type));
2064     
2065     PUSH_FIELD_VALUE (cons, "assertion_table", assertion_table_ref);
2066   }
2067
2068   PUSH_FIELD_VALUE (cons, "hack_signers", null_pointer_node);
2069   PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
2070   PUSH_FIELD_VALUE (cons, "aux_info", null_pointer_node);
2071   PUSH_FIELD_VALUE (cons, "engine", null_pointer_node);
2072
2073   if (TYPE_REFLECTION_DATA (current_class))
2074     {
2075       int i;
2076       int count = TYPE_REFLECTION_DATASIZE (current_class);
2077       VEC (constructor_elt, gc) *v
2078         = VEC_alloc (constructor_elt, gc, count);
2079       unsigned char *data = TYPE_REFLECTION_DATA (current_class);
2080       tree max_index = build_int_cst (sizetype, count);
2081       tree index = build_index_type (max_index);
2082       tree type = build_array_type (unsigned_byte_type_node, index);
2083       char buf[64];
2084       tree array;
2085       static int reflection_data_count;
2086
2087       sprintf (buf, "_reflection_data_%d", reflection_data_count++);
2088       array = build_decl (VAR_DECL, get_identifier (buf), type);
2089
2090       rewrite_reflection_indexes (field_indexes);
2091
2092       for (i = 0; i < count; i++)
2093         {
2094           constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
2095           elt->index = build_int_cst (sizetype, i);
2096           elt->value = build_int_cstu (byte_type_node, data[i]);
2097         }
2098
2099       DECL_INITIAL (array) = build_constructor (type, v);
2100       TREE_STATIC (array) = 1;
2101       DECL_ARTIFICIAL (array) = 1;
2102       DECL_IGNORED_P (array) = 1;
2103       TREE_READONLY (array) = 1;
2104       TREE_CONSTANT (DECL_INITIAL (array)) = 1;
2105       rest_of_decl_compilation (array, 1, 0);
2106       
2107       PUSH_FIELD_VALUE (cons, "reflection_data", build_address_of (array));
2108
2109       free (data);
2110       TYPE_REFLECTION_DATA (current_class) = NULL;
2111     }
2112   else
2113     PUSH_FIELD_VALUE (cons, "reflection_data", null_pointer_node);
2114
2115   FINISH_RECORD_CONSTRUCTOR (cons);
2116
2117   DECL_INITIAL (decl) = cons;
2118   
2119   /* Hash synchronization requires at least 64-bit alignment. */
2120   if (flag_hash_synchronization && POINTER_SIZE < 64)
2121     DECL_ALIGN (decl) = 64; 
2122   
2123   if (flag_indirect_classes)
2124     {
2125       TREE_READONLY (decl) = 1;
2126       TREE_CONSTANT (DECL_INITIAL (decl)) = 1;
2127     }
2128
2129   rest_of_decl_compilation (decl, 1, 0);
2130   
2131   {
2132     tree classdollar_field = build_classdollar_field (type);
2133     if (!flag_indirect_classes)
2134       DECL_INITIAL (classdollar_field) = build_static_class_ref (type);
2135     rest_of_decl_compilation (classdollar_field, 1, 0);
2136   }
2137
2138   TYPE_OTABLE_DECL (type) = NULL_TREE;
2139   TYPE_ATABLE_DECL (type) = NULL_TREE;
2140   TYPE_CTABLE_DECL (type) = NULL_TREE;
2141 }
2142
2143 void
2144 finish_class (void)
2145 {
2146   if (TYPE_VERIFY_METHOD (output_class))
2147     {
2148       tree verify_method = TYPE_VERIFY_METHOD (output_class);
2149       DECL_SAVED_TREE (verify_method) 
2150         = add_stmt_to_compound (DECL_SAVED_TREE (verify_method), void_type_node,
2151                                 build1 (RETURN_EXPR, void_type_node, NULL));
2152       java_genericize (verify_method);
2153       cgraph_finalize_function (verify_method, false);
2154       TYPE_ASSERTIONS (current_class) = NULL;
2155     }
2156
2157   java_expand_catch_classes (current_class);
2158
2159   current_function_decl = NULL_TREE;
2160   TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
2161   make_class_data (current_class);
2162   register_class ();
2163   rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
2164 }
2165
2166 /* Return 2 if CLASS is compiled by this compilation job;
2167    return 1 if CLASS can otherwise be assumed to be compiled;
2168    return 0 if we cannot assume that CLASS is compiled.
2169    Returns 1 for primitive and 0 for array types.  */
2170 int
2171 is_compiled_class (tree class)
2172 {
2173   int seen_in_zip;
2174   if (TREE_CODE (class) == POINTER_TYPE)
2175     class = TREE_TYPE (class);
2176   if (TREE_CODE (class) != RECORD_TYPE)  /* Primitive types are static. */
2177     return 1;
2178   if (TYPE_ARRAY_P (class))
2179     return 0;
2180
2181   seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2182   if (CLASS_FROM_CURRENTLY_COMPILED_P (class))
2183     {
2184       /* The class was seen in the current ZIP file and will be
2185          available as a compiled class in the future but may not have
2186          been loaded already. Load it if necessary. This prevent
2187          build_class_ref () from crashing. */
2188
2189       if (seen_in_zip && !CLASS_LOADED_P (class) && (class != current_class))
2190         load_class (class, 1);
2191
2192       /* We return 2 for class seen in ZIP and class from files
2193          belonging to the same compilation unit */
2194       return 2;
2195     }
2196
2197   if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2198     {
2199       if (!CLASS_LOADED_P (class))
2200         {
2201           if (CLASS_FROM_SOURCE_P (class))
2202             safe_layout_class (class);
2203           else if (class != current_class)
2204             load_class (class, 1);
2205         }
2206       return 1;
2207     }
2208
2209   return 0;
2210 }
2211
2212 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2213
2214 tree
2215 build_dtable_decl (tree type)
2216 {
2217   tree dtype, decl;
2218
2219   /* We need to build a new dtable type so that its size is uniquely
2220      computed when we're dealing with the class for real and not just
2221      faking it (like java.lang.Class during the initialization of the
2222      compiler.) We know we're not faking a class when CURRENT_CLASS is
2223      TYPE. */
2224   if (current_class == type)
2225     {
2226       tree dummy = NULL_TREE;
2227       int n;
2228
2229       dtype = make_node (RECORD_TYPE);
2230
2231       PUSH_FIELD (dtype, dummy, "top_offset", ptr_type_node);
2232       PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node);
2233
2234       PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
2235       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2236         {
2237           tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2238           TREE_CHAIN (dummy) = tmp_field;
2239           DECL_CONTEXT (tmp_field) = dtype;
2240           DECL_ARTIFICIAL (tmp_field) = 1;
2241           dummy = tmp_field;
2242         }
2243
2244       PUSH_FIELD (dtype, dummy, "gc_descr", ptr_type_node);
2245       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2246         {
2247           tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2248           TREE_CHAIN (dummy) = tmp_field;
2249           DECL_CONTEXT (tmp_field) = dtype;
2250           DECL_ARTIFICIAL (tmp_field) = 1;
2251           dummy = tmp_field;
2252         }
2253
2254       n = TREE_VEC_LENGTH (get_dispatch_vector (type));
2255       if (TARGET_VTABLE_USES_DESCRIPTORS)
2256         n *= TARGET_VTABLE_USES_DESCRIPTORS;
2257
2258       PUSH_FIELD (dtype, dummy, "methods",
2259                   build_prim_array_type (nativecode_ptr_type_node, n));
2260       layout_type (dtype);
2261     }
2262   else
2263     dtype = dtable_type;
2264
2265   decl = build_decl (VAR_DECL, get_identifier ("vt$"), dtype);
2266   DECL_CONTEXT (decl) = type;
2267   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2268   DECL_VTABLE_P (decl) = 1;
2269
2270   return decl;
2271 }
2272
2273 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2274    fields inherited from SUPER_CLASS. */
2275
2276 void
2277 push_super_field (tree this_class, tree super_class)
2278 {
2279   tree base_decl;
2280   /* Don't insert the field if we're just re-laying the class out. */ 
2281   if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
2282     return;
2283   base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
2284   DECL_IGNORED_P (base_decl) = 1;
2285   TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
2286   TYPE_FIELDS (this_class) = base_decl;
2287   DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
2288   DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
2289 }
2290
2291 /* Handle the different manners we may have to lay out a super class.  */
2292
2293 static tree
2294 maybe_layout_super_class (tree super_class, tree this_class ATTRIBUTE_UNUSED)
2295 {
2296   if (!super_class)
2297     return NULL_TREE;
2298   else if (TREE_CODE (super_class) == RECORD_TYPE)
2299     {
2300       if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class))
2301         safe_layout_class (super_class);
2302       if (!CLASS_LOADED_P (super_class))
2303         load_class (super_class, 1);
2304     }
2305   /* We might have to layout the class before its dependency on
2306      the super class gets resolved by java_complete_class  */
2307   else if (TREE_CODE (super_class) == POINTER_TYPE)
2308     {
2309       if (TREE_TYPE (super_class) != NULL_TREE)
2310         super_class = TREE_TYPE (super_class);
2311       else
2312         gcc_unreachable ();
2313     }
2314   if (!TYPE_SIZE (super_class))
2315     safe_layout_class (super_class);
2316
2317   return super_class;
2318 }
2319
2320 /* safe_layout_class just makes sure that we can load a class without
2321    disrupting the current_class, input_file, input_line, etc, information
2322    about the class processed currently.  */
2323
2324 void
2325 safe_layout_class (tree class)
2326 {
2327   tree save_current_class = current_class;
2328   location_t save_location = input_location;
2329
2330   layout_class (class);
2331
2332   current_class = save_current_class;
2333   input_location = save_location;
2334 }
2335
2336 void
2337 layout_class (tree this_class)
2338 {
2339   tree super_class = CLASSTYPE_SUPER (this_class);
2340
2341   class_list = tree_cons (this_class, NULL_TREE, class_list);
2342   if (CLASS_BEING_LAIDOUT (this_class))
2343     {
2344       char buffer [1024];
2345       char *report;
2346       tree current;
2347
2348       sprintf (buffer, " with '%s'",
2349                IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
2350       obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2351
2352       for (current = TREE_CHAIN (class_list); current; 
2353            current = TREE_CHAIN (current))
2354         {
2355           tree decl = TYPE_NAME (TREE_PURPOSE (current));
2356           sprintf (buffer, "\n  which inherits from '%s' (%s:%d)",
2357                    IDENTIFIER_POINTER (DECL_NAME (decl)),
2358                    DECL_SOURCE_FILE (decl),
2359                    DECL_SOURCE_LINE (decl));
2360           obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2361         }
2362       obstack_1grow (&temporary_obstack, '\0');
2363       report = obstack_finish (&temporary_obstack);
2364       cyclic_inheritance_report = ggc_strdup (report);
2365       obstack_free (&temporary_obstack, report);
2366       TYPE_SIZE (this_class) = error_mark_node;
2367       return;
2368     }
2369   CLASS_BEING_LAIDOUT (this_class) = 1;
2370
2371   if (super_class && !CLASS_BEING_LAIDOUT (super_class))
2372     {
2373       tree maybe_super_class 
2374         = maybe_layout_super_class (super_class, this_class);
2375       if (maybe_super_class == NULL
2376           || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
2377         {
2378           TYPE_SIZE (this_class) = error_mark_node;
2379           CLASS_BEING_LAIDOUT (this_class) = 0;
2380           class_list = TREE_CHAIN (class_list);
2381           return;
2382         }
2383       if (TYPE_SIZE (this_class) == NULL_TREE)
2384         push_super_field (this_class, maybe_super_class);
2385     }
2386
2387   layout_type (this_class);
2388
2389   /* Also recursively load/layout any superinterfaces, but only if
2390      class was loaded from bytecode.  The source parser will take care
2391      of this itself.  */
2392   if (!CLASS_FROM_SOURCE_P (this_class))
2393     {
2394       int i;
2395             if (TYPE_BINFO (this_class))
2396         {
2397           for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class)) - 1; i > 0; i--)
2398             {
2399               tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (this_class), i);
2400               tree super_interface = BINFO_TYPE (binfo);
2401               tree maybe_super_interface 
2402                 = maybe_layout_super_class (super_interface, NULL_TREE);
2403               if (maybe_super_interface == NULL
2404                   || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
2405                 {
2406                   TYPE_SIZE (this_class) = error_mark_node;
2407                   CLASS_BEING_LAIDOUT (this_class) = 0;
2408                   class_list = TREE_CHAIN (class_list);
2409                   return;
2410                 }
2411             }
2412         }
2413     }
2414
2415   /* Convert the size back to an SI integer value.  */
2416   TYPE_SIZE_UNIT (this_class) =
2417     fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
2418
2419   CLASS_BEING_LAIDOUT (this_class) = 0;
2420   class_list = TREE_CHAIN (class_list);
2421 }
2422
2423 static void
2424 add_miranda_methods (tree base_class, tree search_class)
2425 {
2426   int i;
2427   tree binfo, base_binfo;
2428
2429   if (!CLASS_PARSED_P (search_class))
2430     load_class (search_class, 1);
2431   
2432   for (binfo = TYPE_BINFO (search_class), i = 1;
2433        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2434     {
2435       tree method_decl;
2436       tree elt = BINFO_TYPE (base_binfo);
2437
2438       /* FIXME: This is totally bogus.  We should not be handling
2439          Miranda methods at all if we're using the BC ABI.  */
2440       if (TYPE_DUMMY (elt))
2441         continue;
2442
2443       /* Ensure that interface methods are seen in declared order.  */
2444       if (!CLASS_LOADED_P (elt))
2445         load_class (elt, 1);
2446       layout_class_methods (elt);
2447
2448       /* All base classes will have been laid out at this point, so the order 
2449          will be correct.  This code must match similar layout code in the 
2450          runtime.  */
2451       for (method_decl = TYPE_METHODS (elt);
2452            method_decl; method_decl = TREE_CHAIN (method_decl))
2453         {
2454           tree sig, override;
2455
2456           /* An interface can have <clinit>.  */
2457           if (ID_CLINIT_P (DECL_NAME (method_decl)))
2458             continue;
2459
2460           sig = build_java_argument_signature (TREE_TYPE (method_decl));
2461           override = lookup_argument_method (base_class,
2462                                              DECL_NAME (method_decl), sig);
2463           if (override == NULL_TREE)
2464             {
2465               /* Found a Miranda method.  Add it.  */
2466               tree new_method;
2467               sig = build_java_signature (TREE_TYPE (method_decl));
2468               new_method
2469                 = add_method (base_class,
2470                               get_access_flags_from_decl (method_decl),
2471                               DECL_NAME (method_decl), sig);
2472               METHOD_INVISIBLE (new_method) = 1;
2473             }
2474         }
2475
2476       /* Try superinterfaces.  */
2477       add_miranda_methods (base_class, elt);
2478     }
2479 }
2480
2481 void
2482 layout_class_methods (tree this_class)
2483 {
2484   tree method_decl, dtable_count;
2485   tree super_class, type_name;
2486
2487   if (TYPE_NVIRTUALS (this_class))
2488     return;
2489   
2490   super_class = CLASSTYPE_SUPER (this_class);
2491
2492   if (super_class)
2493     {
2494       super_class = maybe_layout_super_class (super_class, this_class);
2495       if (!TYPE_NVIRTUALS (super_class))
2496         layout_class_methods (super_class);
2497       dtable_count = TYPE_NVIRTUALS (super_class);
2498     }
2499   else
2500     dtable_count = integer_zero_node;
2501
2502   type_name = TYPE_NAME (this_class);
2503   if (!flag_indirect_dispatch
2504       && (CLASS_ABSTRACT (type_name) || CLASS_INTERFACE (type_name)))
2505     {
2506       /* An abstract class can have methods which are declared only in
2507          an implemented interface.  These are called "Miranda
2508          methods".  We make a dummy method entry for such methods
2509          here.  */
2510       add_miranda_methods (this_class, this_class);
2511     }
2512
2513   TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
2514
2515   for (method_decl = TYPE_METHODS (this_class);
2516        method_decl; method_decl = TREE_CHAIN (method_decl))
2517     dtable_count = layout_class_method (this_class, super_class,
2518                                         method_decl, dtable_count);
2519
2520   TYPE_NVIRTUALS (this_class) = dtable_count;
2521 }
2522
2523 /* Return the index of METHOD in INTERFACE.  This index begins at 1
2524    and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2525 int
2526 get_interface_method_index (tree method, tree interface)
2527 {
2528   tree meth;
2529   int i = 1;
2530
2531   for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth))
2532     {
2533       if (meth == method)
2534         return i;
2535       /* We don't want to put <clinit> into the interface table.  */
2536       if (! ID_CLINIT_P (DECL_NAME (meth)))
2537         ++i;
2538       gcc_assert (meth != NULL_TREE);
2539     }
2540 }
2541
2542 /* Lay METHOD_DECL out, returning a possibly new value of
2543    DTABLE_COUNT. Also mangle the method's name. */
2544
2545 tree
2546 layout_class_method (tree this_class, tree super_class,
2547                      tree method_decl, tree dtable_count)
2548 {
2549   tree method_name = DECL_NAME (method_decl);
2550
2551   TREE_PUBLIC (method_decl) = 1;
2552
2553   /* Considered external unless it is being compiled into this object
2554      file, or it was already flagged as external.  */
2555   if (!DECL_EXTERNAL (method_decl))
2556     DECL_EXTERNAL (method_decl) = ((is_compiled_class (this_class) != 2)
2557                                    || METHOD_NATIVE (method_decl));
2558
2559   if (ID_INIT_P (method_name))
2560     {
2561       const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
2562       const char *ptr;
2563       for (ptr = p; *ptr; )
2564         {
2565           if (*ptr++ == '.')
2566             p = ptr;
2567         }
2568       DECL_CONSTRUCTOR_P (method_decl) = 1;
2569       build_java_signature (TREE_TYPE (method_decl));
2570     }
2571   else if (! METHOD_STATIC (method_decl))
2572     {
2573       tree method_sig =
2574         build_java_signature (TREE_TYPE (method_decl));
2575       bool method_override = false;
2576       tree super_method = lookup_java_method (super_class, method_name,
2577                                                   method_sig);
2578       if (super_method != NULL_TREE
2579           && ! METHOD_DUMMY (super_method))
2580         {
2581           method_override = true;
2582           if (! METHOD_PUBLIC (super_method) && 
2583               ! METHOD_PROTECTED (super_method))
2584             {
2585               /* Don't override private method, or default-access method in 
2586                  another package.  */
2587               if (METHOD_PRIVATE (super_method) ||
2588                   ! in_same_package (TYPE_NAME (this_class), 
2589                                      TYPE_NAME (super_class)))
2590                 method_override = false;
2591            }
2592         }
2593       if (method_override)
2594         {
2595           tree method_index = get_method_index (super_method);
2596           set_method_index (method_decl, method_index);
2597           if (method_index == NULL_TREE 
2598               && ! flag_indirect_dispatch
2599               && !CLASS_FROM_SOURCE_P (this_class)
2600               && ! DECL_ARTIFICIAL (super_method))
2601             error ("non-static method %q+D overrides static method",
2602                    method_decl);
2603         }
2604       else if (this_class == object_type_node
2605                && (METHOD_FINAL (method_decl)
2606                    || METHOD_PRIVATE (method_decl)))
2607         {
2608           /* We don't generate vtable entries for final Object
2609              methods.  This is simply to save space, since every
2610              object would otherwise have to define them.  */
2611         }
2612       else if (! METHOD_PRIVATE (method_decl)
2613                && dtable_count)
2614         {
2615           /* We generate vtable entries for final methods because they
2616              may one day be changed to non-final.  */
2617           set_method_index (method_decl, dtable_count);
2618           dtable_count = fold_build2 (PLUS_EXPR, integer_type_node,
2619                                       dtable_count, integer_one_node);
2620         }
2621     }
2622
2623   return dtable_count;
2624 }
2625
2626 static void
2627 register_class (void)
2628 {
2629   tree node;
2630
2631   if (!registered_class)
2632     registered_class = VEC_alloc (tree, gc, 8);
2633
2634   if (flag_indirect_classes)
2635     node = current_class;
2636   else
2637     node = TREE_OPERAND (build_class_ref (current_class), 0);
2638   VEC_safe_push (tree, gc, registered_class, node);
2639 }
2640
2641 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2642    all the classes we have emitted.  */
2643
2644 static void
2645 emit_indirect_register_classes (tree *list_p)
2646 {
2647   tree klass, t, register_class_fn;
2648   int i;
2649
2650   tree init = NULL_TREE;
2651   int size = VEC_length (tree, registered_class) * 2 + 1;
2652   tree class_array_type
2653     = build_prim_array_type (ptr_type_node, size);
2654   tree cdecl = build_decl (VAR_DECL, get_identifier ("_Jv_CLS"),
2655                            class_array_type);
2656   tree reg_class_list;
2657   for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2658     {
2659       init = tree_cons (NULL_TREE, 
2660                         fold_convert (ptr_type_node, 
2661                                       build_static_class_ref (klass)), init);
2662       init = tree_cons 
2663         (NULL_TREE, 
2664          fold_convert (ptr_type_node, 
2665                        build_address_of (build_classdollar_field (klass))),
2666          init);
2667     }
2668   init = tree_cons (NULL_TREE, integer_zero_node, init); 
2669   DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type,
2670                                                       nreverse (init));
2671   TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2672   TREE_STATIC (cdecl) = 1;
2673   DECL_ARTIFICIAL (cdecl) = 1;
2674   DECL_IGNORED_P (cdecl) = 1;
2675   TREE_READONLY (cdecl) = 1;
2676   TREE_CONSTANT (cdecl) = 1;
2677   rest_of_decl_compilation (cdecl, 1, 0);
2678   reg_class_list = fold_convert (ptr_type_node, build_address_of (cdecl));
2679
2680   t = build_function_type_list (void_type_node, 
2681                                 build_pointer_type (ptr_type_node), NULL);
2682   t = build_decl (FUNCTION_DECL, 
2683                   get_identifier ("_Jv_RegisterNewClasses"), t);
2684   TREE_PUBLIC (t) = 1;
2685   DECL_EXTERNAL (t) = 1;
2686   register_class_fn = t;
2687   t = tree_cons (NULL, reg_class_list, NULL);
2688   t = build_function_call_expr (register_class_fn, t);
2689   append_to_statement_list (t, list_p);
2690 }
2691
2692
2693 /* Emit something to register classes at start-up time.
2694
2695    The preferred mechanism is through the .jcr section, which contain
2696    a list of pointers to classes which get registered during constructor
2697    invocation time.
2698
2699    The fallback mechanism is to add statements to *LIST_P to call
2700    _Jv_RegisterClass for each class in this file.  These statements will
2701    be added to a static constructor function for this translation unit.  */
2702
2703 void
2704 emit_register_classes (tree *list_p)
2705 {
2706   if (registered_class == NULL)
2707     return;
2708
2709   if (flag_indirect_classes)
2710     {
2711       emit_indirect_register_classes (list_p);
2712       return;
2713     }
2714
2715   /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2716      TARGET_ASM_NAMED_SECTION, else 0.  Some targets meet those conditions
2717      but lack suitable crtbegin/end objects or linker support.  These
2718      targets can override the default in tm.h to use the fallback mechanism.  */
2719   if (TARGET_USE_JCR_SECTION)
2720     {
2721       tree klass, t;
2722       int i;
2723
2724 #ifdef JCR_SECTION_NAME
2725       switch_to_section (get_section (JCR_SECTION_NAME, SECTION_WRITE, NULL));
2726 #else
2727       /* A target has defined TARGET_USE_JCR_SECTION,
2728          but doesn't have a JCR_SECTION_NAME.  */
2729       gcc_unreachable ();
2730 #endif
2731       assemble_align (POINTER_SIZE);
2732
2733       for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2734         {
2735           t = build_fold_addr_expr (klass);
2736           output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE);
2737         }
2738     }
2739   else
2740     {
2741       tree klass, t, register_class_fn;
2742       int i;
2743
2744       t = build_function_type_list (void_type_node, class_ptr_type, NULL);
2745       t = build_decl (FUNCTION_DECL, get_identifier ("_Jv_RegisterClass"), t);
2746       TREE_PUBLIC (t) = 1;
2747       DECL_EXTERNAL (t) = 1;
2748       register_class_fn = t;
2749
2750       for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2751         {
2752           t = build_fold_addr_expr (klass);
2753           t = tree_cons (NULL, t, NULL);
2754           t = build_function_call_expr (register_class_fn, t);
2755           append_to_statement_list (t, list_p);
2756         }
2757     }
2758 }
2759
2760 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2761
2762 static tree
2763 build_symbol_entry (tree decl, tree special)
2764 {
2765   tree clname, name, signature, sym;
2766   clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
2767   /* ???  Constructors are given the name foo.foo all the way through
2768      the compiler, but in the method table they're all renamed
2769      foo.<init>.  So, we have to do the same here unless we want an
2770      unresolved reference at runtime.  */
2771   name = build_utf8_ref ((TREE_CODE (decl) == FUNCTION_DECL 
2772                           && DECL_CONSTRUCTOR_P (decl))
2773                          ? init_identifier_node
2774                          : DECL_NAME (decl));
2775   signature = build_java_signature (TREE_TYPE (decl));
2776   signature = build_utf8_ref (unmangle_classname 
2777                               (IDENTIFIER_POINTER (signature),
2778                                IDENTIFIER_LENGTH (signature)));
2779   /* SPECIAL is either NULL_TREE or integer_one_node.  We emit
2780      signature addr+1 if SPECIAL, and this indicates to the runtime
2781      system that this is a "special" symbol, i.e. one that should
2782      bypass access controls.  */
2783   if (special != NULL_TREE)
2784     signature = build2 (PLUS_EXPR, TREE_TYPE (signature), signature, special);
2785       
2786   START_RECORD_CONSTRUCTOR (sym, symbol_type);
2787   PUSH_FIELD_VALUE (sym, "clname", clname);
2788   PUSH_FIELD_VALUE (sym, "name", name);
2789   PUSH_FIELD_VALUE (sym, "signature", signature);
2790   FINISH_RECORD_CONSTRUCTOR (sym);
2791   TREE_CONSTANT (sym) = 1;
2792   TREE_INVARIANT (sym) = 1;
2793
2794   return sym;
2795
2796
2797 /* Emit a symbol table: used by -findirect-dispatch.  */
2798
2799 tree
2800 emit_symbol_table (tree name, tree the_table, tree decl_list,
2801                    tree the_syms_decl, tree the_array_element_type,
2802                    int element_size)
2803 {
2804   tree method_list, method, table, list, null_symbol;
2805   tree table_size, the_array_type;
2806   int index;
2807   
2808   /* Only emit a table if this translation unit actually made any
2809      references via it. */
2810   if (decl_list == NULL_TREE)
2811     return the_table;
2812
2813   /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2814   index = 0;
2815   method_list = decl_list;
2816   list = NULL_TREE;  
2817   while (method_list != NULL_TREE)
2818     {
2819       tree special = TREE_PURPOSE (method_list);
2820       method = TREE_VALUE (method_list);
2821       list = tree_cons (NULL_TREE, build_symbol_entry (method, special), list);
2822       method_list = TREE_CHAIN (method_list);
2823       index++;
2824     }
2825
2826   /* Terminate the list with a "null" entry. */
2827   START_RECORD_CONSTRUCTOR (null_symbol, symbol_type);
2828   PUSH_FIELD_VALUE (null_symbol, "clname", null_pointer_node);
2829   PUSH_FIELD_VALUE (null_symbol, "name", null_pointer_node);
2830   PUSH_FIELD_VALUE (null_symbol, "signature", null_pointer_node);
2831   FINISH_RECORD_CONSTRUCTOR (null_symbol);
2832   TREE_CONSTANT (null_symbol) = 1;  
2833   TREE_INVARIANT (null_symbol) = 1;  
2834   list = tree_cons (NULL_TREE, null_symbol, list);
2835
2836   /* Put the list in the right order and make it a constructor. */
2837   list = nreverse (list);
2838   table = build_constructor_from_list (symbols_array_type, list);  
2839
2840   /* Make it the initial value for otable_syms and emit the decl. */
2841   DECL_INITIAL (the_syms_decl) = table;
2842   DECL_ARTIFICIAL (the_syms_decl) = 1;
2843   DECL_IGNORED_P (the_syms_decl) = 1;
2844   rest_of_decl_compilation (the_syms_decl, 1, 0);
2845   
2846   /* Now that its size is known, redefine the table as an
2847      uninitialized static array of INDEX + 1 elements. The extra entry
2848      is used by the runtime to track whether the table has been
2849      initialized. */
2850   table_size 
2851     = build_index_type (build_int_cst (NULL_TREE, index * element_size + 1));
2852   the_array_type = build_array_type (the_array_element_type, table_size);
2853   the_table = build_decl (VAR_DECL, name, the_array_type);
2854   TREE_STATIC (the_table) = 1;
2855   TREE_READONLY (the_table) = 1;  
2856   rest_of_decl_compilation (the_table, 1, 0);
2857
2858   return the_table;
2859 }
2860
2861 /* Make an entry for the catch_classes list.  */
2862 tree
2863 make_catch_class_record (tree catch_class, tree classname)
2864 {
2865   tree entry;
2866   tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
2867   START_RECORD_CONSTRUCTOR (entry, type);
2868   PUSH_FIELD_VALUE (entry, "address", catch_class);
2869   PUSH_FIELD_VALUE (entry, "classname", classname);
2870   FINISH_RECORD_CONSTRUCTOR (entry);
2871   return entry;
2872 }
2873
2874
2875 /* Generate the list of Throwable classes that are caught by exception
2876    handlers in this class.  */
2877 tree 
2878 emit_catch_table (tree this_class)
2879 {
2880   tree table, table_size, array_type;
2881   TYPE_CATCH_CLASSES (this_class) =
2882     tree_cons (NULL,
2883                make_catch_class_record (null_pointer_node, null_pointer_node),
2884                TYPE_CATCH_CLASSES (this_class));
2885   TYPE_CATCH_CLASSES (this_class) = nreverse (TYPE_CATCH_CLASSES (this_class));
2886   TYPE_CATCH_CLASSES (this_class) = 
2887     tree_cons (NULL,
2888                make_catch_class_record (null_pointer_node, null_pointer_node),
2889                TYPE_CATCH_CLASSES (this_class));
2890   table_size = build_index_type
2891     (build_int_cst (NULL_TREE,
2892                     list_length (TYPE_CATCH_CLASSES (this_class))));
2893   array_type 
2894     = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
2895                         table_size);
2896   table = 
2897     build_decl (VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
2898   DECL_INITIAL (table) = 
2899     build_constructor_from_list (array_type, TYPE_CATCH_CLASSES (this_class));
2900   TREE_STATIC (table) = 1;
2901   TREE_READONLY (table) = 1;  
2902   DECL_IGNORED_P (table) = 1;
2903   rest_of_decl_compilation (table, 1, 0);
2904   return table;
2905 }
2906
2907 /* Given a type, return the signature used by
2908    _Jv_FindClassFromSignature() in libgcj.  This isn't exactly the
2909    same as build_java_signature() because we want the canonical array
2910    type.  */
2911
2912 static tree
2913 build_signature_for_libgcj (tree type)
2914 {
2915   tree sig, ref;
2916
2917   sig = build_java_signature (type);
2918   ref = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
2919                                             IDENTIFIER_LENGTH (sig)));
2920   return ref;
2921 }
2922
2923 /* Add an entry to the type assertion table. Callback used during hashtable
2924    traversal.  */
2925
2926 static int
2927 add_assertion_table_entry (void **htab_entry, void *ptr)
2928 {
2929   tree entry;
2930   tree code_val, op1_utf8, op2_utf8;
2931   tree *list = (tree *) ptr;
2932   type_assertion *as = (type_assertion *) *htab_entry;
2933
2934   code_val = build_int_cst (NULL_TREE, as->assertion_code);
2935
2936   if (as->op1 == NULL_TREE)
2937     op1_utf8 = null_pointer_node;
2938   else
2939     op1_utf8 = build_signature_for_libgcj (as->op1);
2940
2941   if (as->op2 == NULL_TREE)
2942     op2_utf8 = null_pointer_node;
2943   else
2944     op2_utf8 = build_signature_for_libgcj (as->op2);
2945   
2946   START_RECORD_CONSTRUCTOR (entry, assertion_entry_type);
2947   PUSH_FIELD_VALUE (entry, "assertion_code", code_val);
2948   PUSH_FIELD_VALUE (entry, "op1", op1_utf8);
2949   PUSH_FIELD_VALUE (entry, "op2", op2_utf8);
2950   FINISH_RECORD_CONSTRUCTOR (entry);
2951   
2952   *list = tree_cons (NULL_TREE, entry, *list);
2953   return true;
2954 }
2955
2956 /* Generate the type assertion table for CLASS, and return its DECL.  */
2957
2958 static tree
2959 emit_assertion_table (tree class)
2960 {
2961   tree null_entry, ctor, table_decl;
2962   tree list = NULL_TREE;
2963   htab_t assertions_htab = TYPE_ASSERTIONS (class);
2964
2965   /* Iterate through the hash table.  */
2966   htab_traverse (assertions_htab, add_assertion_table_entry, &list);
2967
2968   /* Finish with a null entry.  */
2969   START_RECORD_CONSTRUCTOR (null_entry, assertion_entry_type);
2970   PUSH_FIELD_VALUE (null_entry, "assertion_code", integer_zero_node);
2971   PUSH_FIELD_VALUE (null_entry, "op1", null_pointer_node);
2972   PUSH_FIELD_VALUE (null_entry, "op2", null_pointer_node);
2973   FINISH_RECORD_CONSTRUCTOR (null_entry);
2974   
2975   list = tree_cons (NULL_TREE, null_entry, list);
2976   
2977   /* Put the list in the right order and make it a constructor. */
2978   list = nreverse (list);
2979   ctor = build_constructor_from_list (assertion_table_type, list);
2980
2981   table_decl = build_decl (VAR_DECL, mangled_classname ("_type_assert_", class),
2982                            assertion_table_type);
2983
2984   TREE_STATIC (table_decl) = 1;
2985   TREE_READONLY (table_decl) = 1;
2986   TREE_CONSTANT (table_decl) = 1;
2987   DECL_IGNORED_P (table_decl) = 1;
2988
2989   DECL_INITIAL (table_decl) = ctor;
2990   DECL_ARTIFICIAL (table_decl) = 1;
2991   rest_of_decl_compilation (table_decl, 1, 0);
2992
2993   return table_decl;
2994 }
2995
2996 void
2997 init_class_processing (void)
2998 {
2999   fields_ident = get_identifier ("fields");
3000   info_ident = get_identifier ("info");
3001
3002   gcc_obstack_init (&temporary_obstack);
3003 }
3004 \f
3005 static hashval_t java_treetreehash_hash (const void *);
3006 static int java_treetreehash_compare (const void *, const void *);
3007
3008 /* A hash table mapping trees to trees.  Used generally.  */
3009
3010 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
3011
3012 static hashval_t
3013 java_treetreehash_hash (const void *k_p)
3014 {
3015   struct treetreehash_entry *k = (struct treetreehash_entry *) k_p;
3016   return JAVA_TREEHASHHASH_H (k->key);
3017 }
3018
3019 static int
3020 java_treetreehash_compare (const void * k1_p, const void * k2_p)
3021 {
3022   struct treetreehash_entry * k1 = (struct treetreehash_entry *) k1_p;
3023   tree k2 = (tree) k2_p;
3024   return (k1->key == k2);
3025 }
3026
3027 tree 
3028 java_treetreehash_find (htab_t ht, tree t)
3029 {
3030   struct treetreehash_entry *e;
3031   hashval_t hv = JAVA_TREEHASHHASH_H (t);
3032   e = htab_find_with_hash (ht, t, hv);
3033   if (e == NULL)
3034     return NULL;
3035   else
3036     return e->value;
3037 }
3038
3039 tree *
3040 java_treetreehash_new (htab_t ht, tree t)
3041 {
3042   void **e;
3043   struct treetreehash_entry *tthe;
3044   hashval_t hv = JAVA_TREEHASHHASH_H (t);
3045
3046   e = htab_find_slot_with_hash (ht, t, hv, INSERT);
3047   if (*e == NULL)
3048     {
3049       tthe = (*ht->alloc_f) (1, sizeof (*tthe));
3050       tthe->key = t;
3051       *e = tthe;
3052     }
3053   else
3054     tthe = (struct treetreehash_entry *) *e;
3055   return &tthe->value;
3056 }
3057
3058 htab_t
3059 java_treetreehash_create (size_t size, int gc)
3060 {
3061   if (gc)
3062     return htab_create_ggc (size, java_treetreehash_hash,
3063                             java_treetreehash_compare, NULL);
3064   else
3065     return htab_create_alloc (size, java_treetreehash_hash,
3066                               java_treetreehash_compare, free, xcalloc, free);
3067 }
3068
3069 /* Break down qualified IDENTIFIER into package and class-name components.
3070    For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3071    "pkg.foo", and RIGHT to "Bar". */
3072
3073 int
3074 split_qualified_name (tree *left, tree *right, tree source)
3075 {
3076   char *p, *base;
3077   int l = IDENTIFIER_LENGTH (source);
3078
3079   base = alloca (l + 1);
3080   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
3081
3082   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
3083   p = base + l - 1;
3084   while (*p != '.' && p != base)
3085     p--;
3086
3087   /* We didn't find a '.'. Return an error.  */
3088   if (p == base)
3089     return 1;
3090
3091   *p = '\0';
3092   if (right)
3093     *right = get_identifier (p+1);
3094   *left = get_identifier (base);
3095
3096   return 0;
3097 }
3098
3099 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE 
3100    if the classes are from the same package. */
3101
3102 int
3103 in_same_package (tree name1, tree name2)
3104 {
3105   tree tmp;
3106   tree pkg1;
3107   tree pkg2;
3108
3109   if (TREE_CODE (name1) == TYPE_DECL)
3110     name1 = DECL_NAME (name1);
3111   if (TREE_CODE (name2) == TYPE_DECL)
3112     name2 = DECL_NAME (name2);
3113
3114   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
3115     /* One in empty package. */
3116     return 0;
3117
3118   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
3119     /* Both in empty package. */
3120     return 1;
3121
3122   split_qualified_name (&pkg1, &tmp, name1);
3123   split_qualified_name (&pkg2, &tmp, name2);
3124
3125   return (pkg1 == pkg2);
3126 }
3127
3128 #include "gt-java-class.h"