OSDN Git Service

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