![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-class.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-class.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Functions related to building classes and their related objects.
2: Copyright (C) 1987, 1992, 1993 Free Software Foundation, Inc.
3: Contributed by Michael Tiemann ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC 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 GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: /* High-level class interface. */
23:
24: #include "config.h"
25: #include "tree.h"
26: #include <stdio.h>
27: #include "cp-tree.h"
28: #include "flags.h"
29:
30: #include "obstack.h"
31: #define obstack_chunk_alloc xmalloc
32: #define obstack_chunk_free free
33:
34: extern struct obstack permanent_obstack;
35:
36: extern void set_class_shadows PROTO ((tree));
37:
38: /* Way of stacking class types. */
39: static tree *current_class_base, *current_class_stack;
40: static int current_class_stacksize;
41: int current_class_depth;
42:
43: struct class_level
44: {
45: /* The previous class level. */
46: struct class_level *level_chain;
47:
48: /* The class instance variable, as a PARM_DECL. */
49: tree decl;
50: /* The class instance variable, as an object. */
51: tree object;
52: /* The virtual function table pointer
53: for the class instance variable. */
54: tree vtable_decl;
55:
56: /* Name of the current class. */
57: tree name;
58: /* Type of the current class. */
59: tree type;
60:
61: /* Flags for this class level. */
62: int this_is_variable;
63: int memoized_lookups;
64: int save_memoized;
65: int unused;
66: };
67:
68: tree current_class_decl, C_C_D; /* PARM_DECL: the class instance variable */
69: tree current_vtable_decl;
70:
71: /* The following two can be derived from the previous one */
72: tree current_class_name; /* IDENTIFIER_NODE: name of current class */
73: tree current_class_type; /* _TYPE: the type of the current class */
74: tree previous_class_type; /* _TYPE: the previous type that was a class */
75: tree previous_class_values; /* TREE_LIST: copy of the class_shadowed list
76: when leaving an outermost class scope. */
77: static tree get_vfield_name PROTO((tree));
78: tree the_null_vtable_entry;
79:
80: /* Way of stacking language names. */
81: tree *current_lang_base, *current_lang_stack;
82: static int current_lang_stacksize;
83:
84: /* Names of languages we recognize. */
85: tree lang_name_c, lang_name_cplusplus;
86: tree lang_name_objc;
87: tree current_lang_name;
88:
89: /* When layout out an aggregate type, the size of the
90: basetypes (virtual and non-virtual) is passed to layout_record
91: via this node. */
92: static tree base_layout_decl;
93:
94: /* Variables shared between cp-class.c and cp-call.c. */
95:
96: int n_vtables = 0;
97: int n_vtable_entries = 0;
98: int n_vtable_searches = 0;
99: int n_vtable_elems = 0;
100: int n_convert_harshness = 0;
101: int n_compute_conversion_costs = 0;
102: int n_build_method_call = 0;
103: int n_inner_fields_searched = 0;
104:
105: /* Virtual baseclass things. */
106: tree
107: build_vbase_pointer (exp, type)
108: tree exp, type;
109: {
110: char *name;
111:
112: name = (char *) alloca (TYPE_NAME_LENGTH (type) + sizeof (VBASE_NAME) + 1);
113: sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (type));
114: return build_component_ref (exp, get_identifier (name), 0, 0);
115: }
116:
117: /* Build multi-level access to EXPR using hierarchy path PATH.
118: CODE is PLUS_EXPR if we are going with the grain,
119: and MINUS_EXPR if we are not (in which case, we cannot traverse
120: virtual baseclass links).
121:
122: TYPE is the type we want this path to have on exit.
123:
124: ALIAS_THIS is non-zero if EXPR in an expression involving `this'. */
125: tree
126: build_vbase_path (code, type, expr, path, alias_this)
127: enum tree_code code;
128: tree type, expr, path;
129: int alias_this;
130: {
131: register int changed = 0;
132: tree last = NULL_TREE, last_virtual = NULL_TREE;
133: int nonnull = 0;
134: int fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
135: tree null_expr = 0, nonnull_expr;
136: tree basetype;
137: tree offset = integer_zero_node;
138:
139: if (!fixed_type_p && TREE_SIDE_EFFECTS (expr))
140: expr = save_expr (expr);
141: nonnull_expr = expr;
142:
143: if (BINFO_INHERITANCE_CHAIN (path))
144: {
145: tree reverse_path = NULL_TREE;
146:
147: while (path)
148: {
149: tree r = copy_node (path);
150: BINFO_INHERITANCE_CHAIN (r) = reverse_path;
151: reverse_path = r;
152: path = BINFO_INHERITANCE_CHAIN (path);
153: }
154: path = reverse_path;
155: }
156:
157: basetype = BINFO_TYPE (path);
158:
159: while (path)
160: {
161: if (TREE_VIA_VIRTUAL (path))
162: {
163: last_virtual = BINFO_TYPE (path);
164: if (code == PLUS_EXPR)
165: {
166: changed = ! fixed_type_p;
167:
168: if (changed)
169: {
170: extern int flag_assume_nonnull_objects;
171: tree ind;
172:
173: if (last)
174: nonnull_expr = convert_pointer_to (last, nonnull_expr);
175: ind = build_indirect_ref (nonnull_expr, NULL_PTR);
176: nonnull_expr = build_vbase_pointer (ind, last_virtual);
177: if (nonnull == 0 && !flag_assume_nonnull_objects
178: && null_expr == NULL_TREE)
179: {
180: null_expr = build1 (NOP_EXPR, TYPE_POINTER_TO (last_virtual), integer_zero_node);
181: expr = build (COND_EXPR, TYPE_POINTER_TO (last_virtual),
182: build (EQ_EXPR, integer_type_node, expr,
183: integer_zero_node),
184: null_expr, nonnull_expr);
185: }
186: }
187: /* else we'll figure out the offset below. */
188:
189: /* Happens in the case of parse errors. */
190: if (nonnull_expr == error_mark_node)
191: return error_mark_node;
192: }
193: else
194: {
195: cp_error ("cannot cast up from virtual baseclass `%T'",
196: last_virtual);
197: return error_mark_node;
198: }
199: }
200: last = path;
201: path = BINFO_INHERITANCE_CHAIN (path);
202: }
203: /* LAST is now the last basetype assoc on the path. */
204:
205: /* A pointer to a virtual base member of a non-null object
206: is non-null. Therefore, we only need to test for zeroness once.
207: Make EXPR the canonical expression to deal with here. */
208: if (null_expr)
209: {
210: TREE_OPERAND (expr, 2) = nonnull_expr;
211: TREE_TYPE (TREE_OPERAND (expr, 1)) = TREE_TYPE (nonnull_expr);
212: }
213: else
214: expr = nonnull_expr;
215:
216: /* If we go through any virtual base pointers, make sure that
217: casts to BASETYPE from the last virtual base class use
218: the right value for BASETYPE. */
219: if (changed)
220: {
221: tree intype = TREE_TYPE (TREE_TYPE (expr));
222: if (TYPE_MAIN_VARIANT (intype) == BINFO_TYPE (last))
223: basetype = intype;
224: else
225: {
226: tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (intype), 0);
227: basetype = last;
228: offset = BINFO_OFFSET (binfo);
229: }
230: }
231: else
232: {
233: if (last_virtual)
234: {
235: offset = BINFO_OFFSET (binfo_member (last_virtual,
236: CLASSTYPE_VBASECLASSES (basetype)));
237: offset = size_binop (PLUS_EXPR, offset, BINFO_OFFSET (last));
238: }
239: else
240: offset = BINFO_OFFSET (last);
241:
242: #if 0
243: /* why unconditionally set this? (mrs) see deja-gnu/g++.mike/net15.C
244: for a test case. */
245: code = PLUS_EXPR;
246: #endif
247: }
248:
249: if (TREE_INT_CST_LOW (offset))
250: {
251: /* For multiple inheritance: if `this' can be set by any
252: function, then it could be 0 on entry to any function.
253: Preserve such zeroness here. Otherwise, only in the
254: case of constructors need we worry, and in those cases,
255: it will be zero, or initialized to some legal value to
256: which we may add. */
257: if (nonnull == 0 && (alias_this == 0 || flag_this_is_variable > 0))
258: {
259: if (null_expr)
260: TREE_TYPE (null_expr) = type;
261: else
262: null_expr = build1 (NOP_EXPR, type, integer_zero_node);
263: if (TREE_SIDE_EFFECTS (expr))
264: expr = save_expr (expr);
265:
266: return build (COND_EXPR, type,
267: build (EQ_EXPR, integer_type_node, expr, integer_zero_node),
268: null_expr,
269: build (code, type, expr, offset));
270: }
271: else return build (code, type, expr, offset);
272: }
273:
274: /* Cannot change the TREE_TYPE of a NOP_EXPR here, since it may
275: be used multiple times in initialization of multiple inheritance. */
276: if (null_expr)
277: {
278: TREE_TYPE (expr) = type;
279: return expr;
280: }
281: else
282: return build1 (NOP_EXPR, type, expr);
283: }
284:
285: /* Virtual function things. */
286:
287: /* Virtual functions to be dealt with after laying out our
288: base classes. Usually this is used only when classes have virtual
289: baseclasses, but it can happen also when classes have non-virtual
290: baseclasses if the derived class overrides baseclass functions
291: at different offsets. */
292: static tree pending_hard_virtuals;
293: static int doing_hard_virtuals;
294:
295: /* XXX This is set but never used. (bpk) */
296: #if 0
297: /* Temporary binfo list to memoize lookups of the left-most non-virtual
298: baseclass B in a lattice topped by T. B can appear multiple times
299: in the lattice.
300: TREE_PURPOSE is B's TYPE_MAIN_VARIANT.
301: TREE_VALUE is the path by which B is reached from T.
302: TREE_TYPE is B's real type.
303:
304: If TREE_TYPE is NULL_TREE, it means that B was reached via
305: a virtual baseclass.
306: N.B.: This list consists of nodes on the temporary obstack. */
307: static tree leftmost_baseclasses;
308: #endif
309:
310: /* Build an entry in the virtual function table.
311: DELTA is the offset for the `this' pointer.
312: PFN is an ADDR_EXPR containing a pointer to the virtual function.
313: Note that the index (DELTA2) in the virtual function table
314: is always 0. */
315: tree
316: build_vtable_entry (delta, pfn)
317: tree delta, pfn;
318: {
319: tree elems = tree_cons (NULL_TREE, delta,
320: tree_cons (NULL_TREE, integer_zero_node,
321: build_tree_list (NULL_TREE, pfn)));
322: tree entry = build (CONSTRUCTOR, vtable_entry_type, NULL_TREE, elems);
323:
324: /* DELTA is constructed by `size_int', which means it may be an
325: unsigned quantity on some platforms. Therefore, we cannot use
326: `int_fits_type_p', because when DELTA is really negative,
327: `force_fit_type' will make it look like a very large number. */
328:
329: if ((TREE_INT_CST_LOW (TYPE_MAX_VALUE (short_integer_type_node))
330: < TREE_INT_CST_LOW (delta))
331: || (TREE_INT_CST_LOW (delta)
332: < TREE_INT_CST_LOW (TYPE_MIN_VALUE (short_integer_type_node))))
333: sorry ("object size exceeds built-in limit for virtual function table implementation");
334:
335: TREE_CONSTANT (entry) = 1;
336: TREE_STATIC (entry) = 1;
337: TREE_READONLY (entry) = 1;
338:
339: #ifdef GATHER_STATISTICS
340: n_vtable_entries += 1;
341: #endif
342:
343: return entry;
344: }
345:
346: /* Given an object INSTANCE, return an expression which yields the
347: virtual function corresponding to INDEX. There are many special
348: cases for INSTANCE which we take care of here, mainly to avoid
349: creating extra tree nodes when we don't have to. */
350: tree
351: build_vfn_ref (ptr_to_instptr, instance, idx)
352: tree *ptr_to_instptr, instance;
353: tree idx;
354: {
355: extern int building_cleanup;
356: tree vtbl, aref;
357: tree basetype = TREE_TYPE (instance);
358:
359: if (TREE_CODE (basetype) == REFERENCE_TYPE)
360: basetype = TREE_TYPE (basetype);
361:
362: if (instance == C_C_D)
363: {
364: if (current_vtable_decl == NULL_TREE
365: || current_vtable_decl == error_mark_node
366: || !UNIQUELY_DERIVED_FROM_P (DECL_FCONTEXT (CLASSTYPE_VFIELD (current_class_type)), basetype))
367: vtbl = build_indirect_ref (build_vfield_ref (instance, basetype), NULL_PTR);
368: else
369: vtbl = current_vtable_decl;
370: }
371: else
372: {
373: if (optimize)
374: {
375: /* Try to figure out what a reference refers to, and
376: access its virtual function table directly. */
377: tree ref = NULL_TREE;
378:
379: if (TREE_CODE (instance) == INDIRECT_REF
380: && TREE_CODE (TREE_TYPE (TREE_OPERAND (instance, 0))) == REFERENCE_TYPE)
381: ref = TREE_OPERAND (instance, 0);
382: else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
383: ref = instance;
384:
385: if (ref && TREE_CODE (ref) == VAR_DECL
386: && DECL_INITIAL (ref))
387: {
388: tree init = DECL_INITIAL (ref);
389:
390: while (TREE_CODE (init) == NOP_EXPR
391: || TREE_CODE (init) == NON_LVALUE_EXPR)
392: init = TREE_OPERAND (init, 0);
393: if (TREE_CODE (init) == ADDR_EXPR)
394: {
395: init = TREE_OPERAND (init, 0);
396: if (IS_AGGR_TYPE (TREE_TYPE (init))
397: && (TREE_CODE (init) == PARM_DECL
398: || TREE_CODE (init) == VAR_DECL))
399: instance = init;
400: }
401: }
402: }
403:
404: if (IS_AGGR_TYPE (TREE_TYPE (instance))
405: && (TREE_CODE (instance) == RESULT_DECL
406: || TREE_CODE (instance) == PARM_DECL
407: || TREE_CODE (instance) == VAR_DECL))
408: vtbl = TYPE_BINFO_VTABLE (basetype);
409: else
410: vtbl = build_indirect_ref (build_vfield_ref (instance, basetype),
411: NULL_PTR);
412: }
413: assemble_external (vtbl);
414: aref = build_array_ref (vtbl, idx);
415:
416: /* Save the intermediate result in a SAVE_EXPR so we don't have to
417: compute each component of the virtual function pointer twice. */
418: if (!building_cleanup && TREE_CODE (aref) == INDIRECT_REF)
419: TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
420:
421: /* FIXME: This is what breaks vtables on the alpha. */
422: *ptr_to_instptr = build (PLUS_EXPR, TREE_TYPE (*ptr_to_instptr),
423: *ptr_to_instptr,
424: convert (integer_type_node, build_component_ref (aref, delta_identifier, 0, 0)));
425: return build_component_ref (aref, pfn_identifier, 0, 0);
426: }
427:
428: /* Set TREE_PUBLIC and/or TREE_EXTERN on the vtable DECL,
429: based on TYPE and other static flags.
430:
431: Note that anything public is tagged TREE_PUBLIC, whether
432: it's public in this file or in another one. */
433:
434: static void
435: import_export_vtable (decl, type)
436: tree decl, type;
437: {
438: if (write_virtuals >= 2)
439: {
440: if (CLASSTYPE_INTERFACE_KNOWN (type))
441: {
442: TREE_PUBLIC (decl) = 1;
443: DECL_EXTERNAL (decl) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type);
444: }
445: }
446: else if (write_virtuals != 0)
447: {
448: TREE_PUBLIC (decl) = 1;
449: if (write_virtuals < 0)
450: DECL_EXTERNAL (decl) = 1;
451: }
452: }
453:
454: /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
455: for the given TYPE. */
456: static tree
457: get_vtable_name (type)
458: tree type;
459: {
460: tree type_id = build_typename_overload (type);
461: char *buf = (char *)alloca (sizeof (VTABLE_NAME_FORMAT)
462: + IDENTIFIER_LENGTH (type_id) + 2);
463: char *ptr = IDENTIFIER_POINTER (type_id);
464: int i;
465: for (i = 0; ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++) ;
466: #if 0
467: /* We don't take off the numbers; prepare_fresh_vtable uses the
468: DECL_ASSEMBLER_NAME for the type, which includes the number
469: in `3foo'. If we were to pull them off here, we'd end up with
470: something like `_vt.foo.3bar', instead of a uniform definition. */
471: while (ptr[i] >= '0' && ptr[i] <= '9')
472: i += 1;
473: #endif
474: sprintf (buf, VTABLE_NAME_FORMAT, ptr+i);
475: return get_identifier (buf);
476: }
477:
478: /* Build a virtual function for type TYPE.
479: If BINFO is non-NULL, build the vtable starting with the initial
480: approximation that it is the same as the one which is the head of
481: the association list. */
482: static tree
483: build_vtable (binfo, type)
484: tree binfo, type;
485: {
486: tree name = get_vtable_name (type);
487: tree virtuals, decl;
488:
489: if (binfo)
490: {
491: virtuals = copy_list (BINFO_VIRTUALS (binfo));
492: decl = build_decl (VAR_DECL, name, TREE_TYPE (BINFO_VTABLE (binfo)));
493: }
494: else
495: {
496: virtuals = NULL_TREE;
497: decl = build_decl (VAR_DECL, name, void_type_node);
498: }
499:
500: #ifdef GATHER_STATISTICS
501: n_vtables += 1;
502: n_vtable_elems += list_length (virtuals);
503: #endif
504:
505: /* Set TREE_PUBLIC and TREE_EXTERN as appropriate. */
506: import_export_vtable (decl, type);
507:
508: IDENTIFIER_GLOBAL_VALUE (name) = decl = pushdecl_top_level (decl);
509: /* Initialize the association list for this type, based
510: on our first approximation. */
511: TYPE_BINFO_VTABLE (type) = decl;
512: TYPE_BINFO_VIRTUALS (type) = virtuals;
513:
514: TREE_STATIC (decl) = 1;
515: #ifndef WRITABLE_VTABLES
516: /* Make them READONLY by default. (mrs) */
517: TREE_READONLY (decl) = 1;
518: #endif
519: /* At one time the vtable info was grabbed 2 words at a time. This
520: fails on sparc unless you have 8-byte alignment. (tiemann) */
521: DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
522: DECL_ALIGN (decl));
523:
524: /* Why is this conditional? (mrs) */
525: if (binfo && write_virtuals >= 0)
526: DECL_VIRTUAL_P (decl) = 1;
527: #if 0
528: /* Remember which class this vtable is really for. */
529: if (binfo)
530: DECL_VPARENT (decl) = BINFO_TYPE (binfo);
531: else
532: DECL_VPARENT (decl) = type;
533: #endif
534: DECL_CONTEXT (decl) = type;
535:
536: binfo = TYPE_BINFO (type);
537: SET_BINFO_VTABLE_PATH_MARKED (binfo);
538: SET_BINFO_NEW_VTABLE_MARKED (binfo);
539: return decl;
540: }
541:
542: /* Given a base type PARENT, and a derived type TYPE, build
543: a name which distinguishes exactly the PARENT member of TYPE's type.
544:
545: FORMAT is a string which controls how sprintf formats the name
546: we have generated.
547:
548: For example, given
549:
550: class A; class B; class C : A, B;
551:
552: it is possible to distinguish "A" from "C's A". And given
553:
554: class L;
555: class A : L; class B : L; class C : A, B;
556:
557: it is possible to distinguish "L" from "A's L", and also from
558: "C's L from A".
559:
560: Make sure to use the DECL_ASSEMBLER_NAME of the TYPE_NAME of the
561: type, as template have DECL_NAMEs like: X<int>, whereas the
562: DECL_ASSEMBLER_NAME is set to be something the assembler can handle.
563: */
564: static tree
565: build_type_pathname (format, parent, type)
566: char *format;
567: tree parent, type;
568: {
569: extern struct obstack temporary_obstack;
570: char *first, *base, *name;
571: int i;
572: tree id;
573:
574: parent = TYPE_MAIN_VARIANT (parent);
575:
576: /* Remember where to cut the obstack to. */
577: first = obstack_base (&temporary_obstack);
578:
579: /* Put on TYPE+PARENT. */
580: obstack_grow (&temporary_obstack,
581: TYPE_ASSEMBLER_NAME_STRING (type),
582: TYPE_ASSEMBLER_NAME_LENGTH (type));
583: #ifdef JOINER
584: obstack_1grow (&temporary_obstack, JOINER);
585: #else
586: obstack_1grow (&temporary_obstack, '_');
587: #endif
588: obstack_grow0 (&temporary_obstack,
589: TYPE_ASSEMBLER_NAME_STRING (parent),
590: TYPE_ASSEMBLER_NAME_LENGTH (parent));
591: i = obstack_object_size (&temporary_obstack);
592: base = obstack_base (&temporary_obstack);
593: obstack_finish (&temporary_obstack);
594:
595: /* Put on FORMAT+TYPE+PARENT. */
596: obstack_blank (&temporary_obstack, strlen (format) + i + 1);
597: name = obstack_base (&temporary_obstack);
598: sprintf (name, format, base);
599: id = get_identifier (name);
600: obstack_free (&temporary_obstack, first);
601:
602: return id;
603: }
604:
605: /* Give TYPE a new virtual function table which is initialized
606: with a skeleton-copy of its original initialization. The only
607: entry that changes is the `delta' entry, so we can really
608: share a lot of structure.
609:
610: FOR_TYPE is the derived type which caused this table to
611: be needed.
612:
613: BINFO is the type association which provided TYPE for FOR_TYPE.
614:
615: The way we update BASE_BINFO's vtable information is just to change the
616: association information in FOR_TYPE's association list. */
617: static void
618: prepare_fresh_vtable (binfo, base_binfo, for_type)
619: tree binfo, base_binfo, for_type;
620: {
621: tree basetype = BINFO_TYPE (binfo);
622: tree orig_decl = BINFO_VTABLE (binfo);
623: tree name = build_type_pathname (VTABLE_NAME_FORMAT, basetype, for_type);
624: tree new_decl = build_decl (VAR_DECL, name, TREE_TYPE (orig_decl));
625: tree path;
626: int result;
627:
628: /* Remember which class this vtable is really for. */
629: #if 0
630: DECL_VPARENT (new_decl) = BINFO_TYPE (base_binfo);
631: #endif
632: DECL_CONTEXT (new_decl) = for_type;
633:
634: TREE_STATIC (new_decl) = 1;
635: BINFO_VTABLE (binfo) = pushdecl_top_level (new_decl);
636: DECL_VIRTUAL_P (new_decl) = 1;
637: #ifndef WRITABLE_VTABLES
638: /* Make them READONLY by default. (mrs) */
639: TREE_READONLY (new_decl) = 1;
640: #endif
641: DECL_ALIGN (new_decl) = DECL_ALIGN (orig_decl);
642:
643: /* Make fresh virtual list, so we can smash it later. */
644: BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
645: /* Install the value for `headof' if that's what we're doing. */
646: if (flag_dossier)
647: TREE_VALUE (TREE_CHAIN (BINFO_VIRTUALS (binfo)))
648: = build_vtable_entry (size_binop (MINUS_EXPR, integer_zero_node, BINFO_OFFSET (binfo)),
649: FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (TREE_CHAIN (BINFO_VIRTUALS (binfo)))));
650:
651: #ifdef GATHER_STATISTICS
652: n_vtables += 1;
653: n_vtable_elems += list_length (BINFO_VIRTUALS (binfo));
654: #endif
655:
656: /* Set TREE_PUBLIC and TREE_EXTERN as appropriate. */
657: import_export_vtable (new_decl, for_type);
658:
659: if (TREE_VIA_VIRTUAL (binfo))
660: my_friendly_assert (binfo == binfo_member (BINFO_TYPE (binfo),
661: CLASSTYPE_VBASECLASSES (current_class_type)),
662: 170);
663: SET_BINFO_NEW_VTABLE_MARKED (binfo);
664: SET_BINFO_VTABLE_PATH_MARKED (binfo);
665:
666: /* Mark all types between FOR_TYPE and TYPE as having been
667: touched, so that if we change virtual function table entries,
668: new vtables will be initialized. We may reach the virtual
669: baseclass via ambiguous intervening baseclasses. This
670: loop makes sure we get through to the actual baseclass we marked.
671:
672: Also, update the vtable entries to reflect the overrides
673: of the top-most class (short of the top type). */
674:
675: do
676: {
677: result = get_base_distance (basetype, for_type, 0, &path);
678: for_type = path;
679: while (path)
680: {
681: tree path_binfo = path;
682: tree path_type = BINFO_TYPE (path);
683:
684: if (TREE_VIA_VIRTUAL (path))
685: path_binfo = binfo_member (path_type,
686: CLASSTYPE_VBASECLASSES (current_class_type));
687:
688: SET_BINFO_VTABLE_PATH_MARKED (path_binfo);
689: if (BINFO_INHERITANCE_CHAIN (path)
690: && CLASSTYPE_VFIELD (path_type) != NULL_TREE
691: && (DECL_NAME (CLASSTYPE_VFIELD (BINFO_TYPE (binfo)))
692: == DECL_NAME (CLASSTYPE_VFIELD (path_type)))
693: /* This is the baseclass just before the original FOR_TYPE. */
694: && BINFO_INHERITANCE_CHAIN (BINFO_INHERITANCE_CHAIN (path)) == NULL_TREE)
695: {
696: tree old_virtuals = TREE_CHAIN (BINFO_VIRTUALS (binfo));
697: tree new_virtuals = TREE_CHAIN (BINFO_VIRTUALS (path_binfo));
698: if (flag_dossier)
699: {
700: old_virtuals = TREE_CHAIN (old_virtuals);
701: new_virtuals = TREE_CHAIN (new_virtuals);
702: }
703: while (old_virtuals)
704: {
705: TREE_VALUE (old_virtuals) = TREE_VALUE (new_virtuals);
706: old_virtuals = TREE_CHAIN (old_virtuals);
707: new_virtuals = TREE_CHAIN (new_virtuals);
708: }
709: }
710: path = BINFO_INHERITANCE_CHAIN (path);
711: }
712: }
713: while (result == -2);
714: }
715:
716: /* Access the virtual function table entry that logically
717: contains BASE_FNDECL. VIRTUALS is the virtual function table's
718: initializer. */
719: static tree
720: get_vtable_entry (virtuals, base_fndecl)
721: tree virtuals, base_fndecl;
722: {
723: unsigned HOST_WIDE_INT i = (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
724: #ifdef VTABLE_USES_MASK
725: && 0
726: #endif
727: ? (TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl))
728: & (((unsigned HOST_WIDE_INT)1<<(BITS_PER_WORD-1))-1))
729: : TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl)));
730:
731: #ifdef GATHER_STATISTICS
732: n_vtable_searches += i;
733: #endif
734:
735: while (i > 0)
736: {
737: virtuals = TREE_CHAIN (virtuals);
738: i -= 1;
739: }
740: return virtuals;
741: }
742:
743: /* Put new entry ENTRY into virtual function table initializer
744: VIRTUALS.
745:
746: Also update DECL_VINDEX (FNDECL). */
747:
748: static void
749: modify_vtable_entry (old_entry_in_list, new_entry, fndecl)
750: tree old_entry_in_list, new_entry, fndecl;
751: {
752: tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (old_entry_in_list));
753: tree vindex;
754:
755: /* We can't put in the really right offset information
756: here, since we have not yet laid out the class to
757: take into account virtual base classes. */
758: TREE_VALUE (old_entry_in_list) = new_entry;
759: vindex = DECL_VINDEX (TREE_OPERAND (base_pfn, 0));
760: if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
761: DECL_VINDEX (fndecl) = vindex;
762: else
763: {
764: if (! tree_int_cst_equal (DECL_VINDEX (fndecl), vindex))
765: {
766: tree elts = CONSTRUCTOR_ELTS (new_entry);
767:
768: if (! doing_hard_virtuals)
769: {
770: pending_hard_virtuals
771: = tree_cons (fndecl, FNADDR_FROM_VTABLE_ENTRY (new_entry),
772: pending_hard_virtuals);
773: TREE_TYPE (pending_hard_virtuals) = TREE_OPERAND (base_pfn, 0);
774: return;
775: }
776: }
777: }
778: }
779:
780: /* Check to ensure that the virtual function table slot in VFIELD,
781: found by DECL_VINDEX of the BASE_FNDECL is in fact from a parent
782: virtual function table that is the same parent as for the
783: BASE_FNDECL given to us. */
784:
785: static int
786: related_vslot (base_fndecl, vfields, type)
787: tree base_fndecl, vfields, type;
788: {
789: tree base_context = TYPE_MAIN_VARIANT (DECL_CONTEXT (base_fndecl));
790: tree base;
791: tree path;
792: int distance;
793:
794: if (TREE_CODE (vfields) != TREE_LIST)
795: abort ();
796: base = VF_NORMAL_VALUE (vfields);
797: if (base == NULL_TREE)
798: base = VF_BASETYPE_VALUE (vfields);
799:
800: /* The simple right way to do this is to ensure that the context of
801: the base virtual function is found along the leftmost path
802: between the most derived type associated with the vfield and the
803: current type. */
804: distance = get_base_distance (base, type, 0, &path);
805: if (distance == -1)
806: abort ();
807: while (path)
808: {
809: if (BINFO_TYPE (path) == base_context)
810: return 1;
811: path = BINFO_INHERITANCE_CHAIN (path);
812: }
813:
814: /* given:
815: Rr
816: / \
817: Mm Hh
818: \ /
819: P
820:
821: make sure we fill in P's vtable for H with overrides of r,
822: but be cautious of virtual base classes. */
823: /* Combine the two below after debugging. */
824: if (get_base_distance (base_context, base, 0, &path) != -1)
825: {
826: while (path)
827: {
828: if (TREE_VIA_VIRTUAL (path))
829: return 0;
830: path = BINFO_INHERITANCE_CHAIN (path);
831: }
832: /* Make sure that:
833:
834: RRB
835: |
836: RL RR
837: \ /
838: L R
839: \ /
840: C
841:
842: returns 0. VF_BASETYPE_VALUE is RL, base_context is RRB, type is C,
843: and the vfield we are checking is R. */
844: if (VF_BASETYPE_VALUE (vfields)
845: && get_base_distance (base_context, VF_BASETYPE_VALUE (vfields), 0, &path) == -1
846: && get_base_distance (VF_BASETYPE_VALUE (vfields), base_context, 0, &path) == -1)
847: return 0;
848: return 1;
849: }
850: return 0;
851: }
852:
853: /* Modify virtual function tables in lattice topped by T to
854: place FNDECL in tables which previously held BASE_FNDECL.
855: PFN is just FNDECL wrapped in an ADDR_EXPR, so that it
856: is suitable for placement directly into an initializer.
857:
858: All distinct virtual function tables that this type uses
859: must be updated. */
860: static void
861: modify_vtable_entries (t, fndecl, base_fndecl, pfn)
862: tree t;
863: tree fndecl, base_fndecl, pfn;
864: {
865: tree base_offset, offset;
866: tree base_context = DECL_CLASS_CONTEXT (base_fndecl);
867: tree context = DECL_CLASS_CONTEXT (fndecl);
868: tree vfield = CLASSTYPE_VFIELD (t);
869: tree vfields, vbases;
870:
871: DECL_CONTEXT (fndecl) = DECL_CONTEXT (base_fndecl);
872:
873: offset = integer_zero_node;
874: if (context != t && TYPE_USES_COMPLEX_INHERITANCE (t))
875: {
876: offset = virtual_offset (context, CLASSTYPE_VBASECLASSES (t), offset);
877: if (offset == NULL_TREE)
878: {
879: tree binfo = binfo_value (context, t);
880: offset = BINFO_OFFSET (binfo);
881: }
882: }
883:
884: /* For each layer of base class (i.e., the first base class, and each
885: virtual base class from that one), modify the virtual function table
886: of the derived class to contain the new virtual function.
887: A class has as many vfields as it has virtual base classes (total). */
888: for (vfields = CLASSTYPE_VFIELDS (t); vfields; vfields = TREE_CHAIN (vfields))
889: {
890: int normal = 1;
891: tree binfo, this_offset;
892: tree base, path;
893:
894: if (!related_vslot (base_fndecl, vfields, t))
895: continue;
896:
897: /* Find the right base class for this derived class, call it BASE. */
898: base = VF_BASETYPE_VALUE (vfields);
899:
900: /* Get the path starting from the deepest base class CONTEXT
901: of T (i.e., first defn of BASE_FNDECL). */
902: get_base_distance (DECL_CONTEXT (base_fndecl), t, 0, &path);
903:
904: /* Get our best approximation of what to use for constructing
905: the virtual function table for T. */
906: do
907: {
908: /* Walk from base toward derived, stopping at the
909: most derived baseclass that matters. That baseclass
910: is exactly the one which provides the vtable along
911: the VFIELD spine, but no more. */
912: if (TREE_VIA_VIRTUAL (path))
913: {
914: base = path;
915: binfo = binfo_member (BINFO_TYPE (base), CLASSTYPE_VBASECLASSES (t));
916: break;
917: }
918: if (BINFO_INHERITANCE_CHAIN (path) == NULL_TREE
919: || (BINFO_TYPE (BINFO_BASETYPE (BINFO_INHERITANCE_CHAIN (path), 0))
920: != BINFO_TYPE (path))
921: || BINFO_INHERITANCE_CHAIN (BINFO_INHERITANCE_CHAIN (path)) == NULL_TREE)
922: {
923: base = path;
924: binfo = base;
925: break;
926: }
927: path = BINFO_INHERITANCE_CHAIN (path);
928: }
929: while (1);
930:
931: /* Find the right offset for the this pointer based on the base
932: class we just found. */
933: base_offset = BINFO_OFFSET (binfo);
934: this_offset = size_binop (MINUS_EXPR, offset, base_offset);
935:
936: /* Make sure we can modify the derived association with immunity. */
937: if (TREE_USED (TYPE_BINFO (t)))
938: TYPE_BINFO (t) = copy_binfo (TYPE_BINFO (t));
939:
940: /* We call this case NORMAL iff this virtual function table
941: pointer field has its storage reserved in this class.
942: This is normally the case without virtual baseclasses
943: or off-center multiple baseclasses. */
944: normal = (vfield != NULL_TREE
945: && VF_BASETYPE_VALUE (vfields) == DECL_FCONTEXT (vfield)
946: && (VF_BINFO_VALUE (vfields) == NULL_TREE
947: || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields))));
948:
949: if (normal && VF_BINFO_VALUE (vfields))
950: /* Everything looks normal so far...check that we are really
951: working from VFIELD's basetype, and not some other appearance
952: of that basetype in the lattice. */
953: normal = (VF_BINFO_VALUE (vfields)
954: == get_binfo (VF_BASETYPE_VALUE (vfields), t, 0));
955:
956: if (normal)
957: {
958: /* In this case, it is *type*'s vtable we are modifying.
959: We start with the approximation that it's vtable is that
960: of the immediate base class. */
961: base_context = t;
962: binfo = TYPE_BINFO (t);
963: if (! BINFO_NEW_VTABLE_MARKED (binfo))
964: build_vtable (TYPE_BINFO (DECL_CONTEXT (vfield)), t);
965: }
966: else
967: {
968: /* This is our very own copy of `basetype' to play with.
969: Later, we will fill in all the virtual functions
970: that override the virtual functions in these base classes
971: which are not defined by the current type. */
972: if (! BINFO_NEW_VTABLE_MARKED (binfo))
973: prepare_fresh_vtable (binfo, base, t);
974: }
975:
976: modify_vtable_entry (get_vtable_entry (BINFO_VIRTUALS (binfo), base_fndecl),
977: build_vtable_entry (this_offset, pfn),
978: fndecl);
979: }
980: for (vbases = CLASSTYPE_VBASECLASSES (t); vbases; vbases = TREE_CHAIN (vbases))
981: {
982: tree this_offset;
983: tree base, path;
984:
985: if (! BINFO_VTABLE (vbases))
986: /* There are only two ways that a type can fail to have
987: virtual functions: neither it nor any of its base
988: types define virtual functions (in which case
989: no updating need be done), or virtual functions
990: accessible to it come from virtual base classes
991: (in which case we have or will get them modified
992: in other passes of this loop). */
993: continue;
994:
995: base = BINFO_TYPE (vbases);
996: path = NULL_TREE;
997:
998: if (base != base_context
999: && get_base_distance (base_context, base, 0, &path) == -1)
1000: continue;
1001:
1002: if (path)
1003: this_offset = size_binop (MINUS_EXPR, offset, BINFO_OFFSET (path));
1004: else
1005: this_offset = offset;
1006:
1007: /* Doesn't matter if not actually from this virtual base class,
1008: but shouldn't come from deeper virtual baseclasses. The enclosing
1009: loop should take care of such baseclasses. */
1010: while (path)
1011: {
1012: if (TREE_VIA_VIRTUAL (path))
1013: goto skip;
1014: path = BINFO_INHERITANCE_CHAIN (path);
1015: }
1016:
1017: base_offset = BINFO_OFFSET (vbases);
1018: this_offset = size_binop (MINUS_EXPR, this_offset, base_offset);
1019:
1020: /* Make sure we can modify the derived association with immunity. */
1021: if (TREE_USED (TYPE_BINFO (t)))
1022: TYPE_BINFO (t) = copy_binfo (TYPE_BINFO (t));
1023:
1024: /* This is our very own copy of `basetype' to play with. */
1025: if (! BINFO_NEW_VTABLE_MARKED (vbases))
1026: {
1027: tree context_binfo = binfo_value (base_context, base);
1028: prepare_fresh_vtable (vbases, context_binfo, t);
1029: }
1030: modify_vtable_entry (get_vtable_entry (BINFO_VIRTUALS (vbases),
1031: base_fndecl),
1032: build_vtable_entry (this_offset, pfn),
1033: fndecl);
1034: skip: {}
1035: }
1036: }
1037:
1038: static tree
1039: add_virtual_function (pending_virtuals, has_virtual, x, t)
1040: tree pending_virtuals;
1041: int *has_virtual;
1042: tree x;
1043: tree t; /* Structure type. */
1044: {
1045: int debug_vbase = 1;
1046:
1047: /* FUNCTION_TYPEs and OFFSET_TYPEs no longer freely
1048: convert to void *. Make such a conversion here. */
1049: tree vfn = build1 (ADDR_EXPR, ptr_type_node, x);
1050: TREE_CONSTANT (vfn) = 1;
1051:
1052: /* current_class_type may be NULL_TREE in case of error. */
1053: if (current_class_type)
1054: TREE_ADDRESSABLE (x) = CLASSTYPE_VTABLE_NEEDS_WRITING (current_class_type);
1055:
1056: /* If the virtual function is a redefinition of a prior one,
1057: figure out in which base class the new definition goes,
1058: and if necessary, make a fresh virtual function table
1059: to hold that entry. */
1060: if (DECL_VINDEX (x) == error_mark_node)
1061: {
1062: tree entry = build_vtable_entry (integer_zero_node, vfn);
1063:
1064: if (flag_dossier && *has_virtual == 0)
1065: {
1066: /* CLASSTYPE_DOSSIER is only used as a Boolean (NULL or not). */
1067: CLASSTYPE_DOSSIER (t) = integer_one_node;
1068: *has_virtual = 1;
1069: }
1070:
1071: /* Build a new INT_CST for this DECL_VINDEX. */
1072: #ifdef VTABLE_USES_MASK
1073: SET_DECL_VINDEX (x, build_int_2 (++(*has_virtual), 0));
1074: #else
1075: {
1076: static tree index_table[256];
1077: tree index;
1078: int i = ++(*has_virtual);
1079:
1080: if (i >= 256 || index_table[i] == 0)
1081: {
1082: index = build_int_2 (i, 0);
1083: if (i < 256)
1084: index_table[i] = index;
1085: }
1086: else
1087: index = index_table[i];
1088:
1089: DECL_VINDEX (x) = index;
1090: }
1091: #endif
1092: pending_virtuals = tree_cons (DECL_VINDEX (x), entry, pending_virtuals);
1093: }
1094: /* Happens if declared twice in class or we're not in a class definition.
1095: We will give error later or we've already given it. */
1096: else if (TREE_CODE (DECL_VINDEX (x)) == INTEGER_CST
1097: || current_class_type == NULL_TREE)
1098: return pending_virtuals;
1099: else if (debug_vbase && TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
1100: {
1101: /* Need an entry in some other virtual function table.
1102: Deal with this after we have laid out our virtual base classes. */
1103: pending_hard_virtuals = temp_tree_cons (x, vfn, pending_hard_virtuals);
1104: }
1105: else
1106: {
1107: /* Need an entry in some other virtual function table.
1108: We can do this now. */
1109: tree base_fndecl_list = DECL_VINDEX (x), base_fndecls, prev = 0;
1110: tree vtable_context = DECL_FCONTEXT (CLASSTYPE_VFIELD (current_class_type));
1111: tree true_base_fndecl = 0;
1112:
1113: /* First assign DECL_VINDEX from the base vfn with which
1114: we share our vtable. */
1115: base_fndecls = base_fndecl_list;
1116: while (base_fndecls)
1117: {
1118: if (TREE_CHAIN (base_fndecls) == NULL_TREE
1119: || DECL_FCONTEXT (CLASSTYPE_VFIELD (DECL_CLASS_CONTEXT (TREE_VALUE (base_fndecls)))) == vtable_context)
1120: {
1121: true_base_fndecl = TREE_VALUE (base_fndecls);
1122: modify_vtable_entries (current_class_type, x,
1123: true_base_fndecl, vfn);
1124: if (prev)
1125: TREE_CHAIN (prev) = TREE_CHAIN (base_fndecls);
1126: else
1127: base_fndecl_list = prev;
1128: break;
1129: }
1130: prev = base_fndecls;
1131: base_fndecls = TREE_CHAIN (base_fndecls);
1132: }
1133:
1134: /* Now fill in the rest of the vtables. */
1135: base_fndecls = base_fndecl_list;
1136: while (base_fndecls)
1137: {
1138: /* If we haven't found one we like, first one wins. */
1139: if (true_base_fndecl == 0)
1140: true_base_fndecl = TREE_VALUE (base_fndecls);
1141:
1142: modify_vtable_entries (current_class_type, x,
1143: TREE_VALUE (base_fndecls), vfn);
1144: base_fndecls = TREE_CHAIN (base_fndecls);
1145: }
1146:
1147: DECL_CONTEXT (x) = DECL_CONTEXT (true_base_fndecl);
1148: }
1149: return pending_virtuals;
1150: }
1151:
1152: /* Obstack on which to build the vector of class methods. */
1153: struct obstack class_obstack;
1154: extern struct obstack *current_obstack;
1155:
1156: /* Add method METHOD to class TYPE. This is used when a method
1157: has been defined which did not initially appear in the class definition,
1158: and helps cut down on spurious error messages.
1159:
1160: FIELDS is the entry in the METHOD_VEC vector entry of the class type where
1161: the method should be added. */
1162: void
1163: add_method (type, fields, method)
1164: tree type, *fields, method;
1165: {
1166: /* We must make a copy of METHOD here, since we must be sure that
1167: we have exclusive title to this method's DECL_CHAIN. */
1168: tree decl;
1169:
1170: push_obstacks (&permanent_obstack, &permanent_obstack);
1171: {
1172: decl = copy_node (method);
1173: if (DECL_RTL (decl) == 0
1174: && (!processing_template_decl
1175: || !uses_template_parms (decl)))
1176: {
1177: make_function_rtl (decl);
1178: DECL_RTL (method) = DECL_RTL (decl);
1179: }
1180: }
1181:
1182: if (fields && *fields)
1183: {
1184: /* Take care not to hide destructor. */
1185: DECL_CHAIN (decl) = DECL_CHAIN (*fields);
1186: DECL_CHAIN (*fields) = decl;
1187: }
1188: else if (CLASSTYPE_METHOD_VEC (type) == 0)
1189: {
1190: tree method_vec = make_node (TREE_VEC);
1191: if (TYPE_IDENTIFIER (type) == DECL_NAME (decl))
1192: {
1193: TREE_VEC_ELT (method_vec, 0) = decl;
1194: TREE_VEC_LENGTH (method_vec) = 1;
1195: }
1196: else
1197: {
1198: /* ??? Is it possible for there to have been enough room in the
1199: current chunk for the tree_vec structure but not a tree_vec
1200: plus a tree*? Will this work in that case? */
1201: obstack_free (current_obstack, method_vec);
1202: obstack_blank (current_obstack, sizeof (struct tree_vec) + sizeof (tree *));
1203: TREE_VEC_ELT (method_vec, 1) = decl;
1204: TREE_VEC_LENGTH (method_vec) = 2;
1205: obstack_finish (current_obstack);
1206: }
1207: CLASSTYPE_METHOD_VEC (type) = method_vec;
1208: }
1209: else
1210: {
1211: tree method_vec = CLASSTYPE_METHOD_VEC (type);
1212: int len = TREE_VEC_LENGTH (method_vec);
1213:
1214: /* Adding a new ctor or dtor. This is easy because our
1215: METHOD_VEC always has a slot for such entries. */
1216: if (TYPE_IDENTIFIER (type) == DECL_NAME (decl))
1217: {
1218: /* TREE_VEC_ELT (method_vec, 0) = decl; */
1219: if (decl != TREE_VEC_ELT (method_vec, 0))
1220: {
1221: DECL_CHAIN (decl) = TREE_VEC_ELT (method_vec, 0);
1222: TREE_VEC_ELT (method_vec, 0) = decl;
1223: }
1224: }
1225: else
1226: {
1227: /* This is trickier. We try to extend the TREE_VEC in-place,
1228: but if that does not work, we copy all its data to a new
1229: TREE_VEC that's large enough. */
1230: struct obstack *ob = &class_obstack;
1231: tree *end = (tree *)obstack_next_free (ob);
1232:
1233: if (end != TREE_VEC_END (method_vec))
1234: {
1235: ob = current_obstack;
1236: TREE_VEC_LENGTH (method_vec) += 1;
1237: TREE_VEC_ELT (method_vec, len) = NULL_TREE;
1238: method_vec = copy_node (method_vec);
1239: TREE_VEC_LENGTH (method_vec) -= 1;
1240: }
1241: else
1242: {
1243: tree tmp_vec = (tree) obstack_base (ob);
1244: if (obstack_room (ob) < sizeof (tree))
1245: {
1246: obstack_blank (ob, sizeof (struct tree_common)
1247: + tree_code_length[(int) TREE_VEC]
1248: * sizeof (char *)
1249: + len * sizeof (tree));
1250: tmp_vec = (tree) obstack_base (ob);
1251: bcopy (method_vec, tmp_vec,
1252: (sizeof (struct tree_common)
1253: + tree_code_length[(int) TREE_VEC] * sizeof (char *)
1254: + (len-1) * sizeof (tree)));
1255: method_vec = tmp_vec;
1256: }
1257: else
1258: obstack_blank (ob, sizeof (tree));
1259: }
1260:
1261: obstack_finish (ob);
1262: TREE_VEC_ELT (method_vec, len) = decl;
1263: TREE_VEC_LENGTH (method_vec) = len + 1;
1264: CLASSTYPE_METHOD_VEC (type) = method_vec;
1265:
1266: if (TYPE_BINFO_BASETYPES (type) && CLASSTYPE_BASELINK_VEC (type))
1267: {
1268: /* ??? May be better to know whether these can be extended? */
1269: tree baselink_vec = CLASSTYPE_BASELINK_VEC (type);
1270:
1271: TREE_VEC_LENGTH (baselink_vec) += 1;
1272: CLASSTYPE_BASELINK_VEC (type) = copy_node (baselink_vec);
1273: TREE_VEC_LENGTH (baselink_vec) -= 1;
1274:
1275: TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), len) = 0;
1276: }
1277: }
1278: }
1279: DECL_CONTEXT (decl) = type;
1280: DECL_CLASS_CONTEXT (decl) = type;
1281:
1282: pop_obstacks ();
1283: }
1284:
1285: /* Subroutines of finish_struct. */
1286:
1287: /* Look through the list of fields for this struct, deleting
1288: duplicates as we go. This must be recursive to handle
1289: anonymous unions.
1290:
1291: FIELD is the field which may not appear anywhere in FIELDS.
1292: FIELD_PTR, if non-null, is the starting point at which
1293: chained deletions may take place.
1294: The value returned is the first acceptable entry found
1295: in FIELDS.
1296:
1297: Note that anonymous fields which are not of UNION_TYPE are
1298: not duplicates, they are just anonymous fields. This happens
1299: when we have unnamed bitfields, for example. */
1300: static tree
1301: delete_duplicate_fields_1 (field, field_ptr, fields)
1302: tree field, *field_ptr, fields;
1303: {
1304: tree x;
1305: tree prev = field_ptr ? *field_ptr : 0;
1306: if (DECL_NAME (field) == 0)
1307: {
1308: if (TREE_CODE (TREE_TYPE (field)) != UNION_TYPE)
1309: return fields;
1310:
1311: for (x = TYPE_FIELDS (TREE_TYPE (field)); x; x = TREE_CHAIN (x))
1312: fields = delete_duplicate_fields_1 (x, field_ptr, fields);
1313: if (prev)
1314: TREE_CHAIN (prev) = fields;
1315: return fields;
1316: }
1317: else
1318: {
1319: for (x = fields; x; prev = x, x = TREE_CHAIN (x))
1320: {
1321: if (DECL_NAME (x) == 0)
1322: {
1323: if (TREE_CODE (TREE_TYPE (x)) != UNION_TYPE)
1324: continue;
1325: TYPE_FIELDS (TREE_TYPE (x))
1326: = delete_duplicate_fields_1 (field, (tree *)0, TYPE_FIELDS (TREE_TYPE (x)));
1327: if (TYPE_FIELDS (TREE_TYPE (x)) == 0)
1328: {
1329: if (prev == 0)
1330: fields = TREE_CHAIN (fields);
1331: else
1332: TREE_CHAIN (prev) = TREE_CHAIN (x);
1333: }
1334: }
1335: else
1336: {
1337: if (DECL_NAME (field) == DECL_NAME (x))
1338: {
1339: if (TREE_CODE (field) == CONST_DECL
1340: && TREE_CODE (x) == CONST_DECL)
1341: cp_error_at ("duplicate enum value `%D'", x);
1342: else if (TREE_CODE (field) == CONST_DECL
1343: || TREE_CODE (x) == CONST_DECL)
1344: cp_error_at ("duplicate field `%D' (as enum and non-enum)",
1345: x);
1346: else if (TREE_CODE (field) == TYPE_DECL
1347: && TREE_CODE (x) == TYPE_DECL)
1348: cp_error_at ("duplicate class scope type `%D'", x);
1349: else if (TREE_CODE (field) == TYPE_DECL
1350: || TREE_CODE (x) == TYPE_DECL)
1351: cp_error_at ("duplicate field `%D' (as type and non-type)",
1352: x);
1353: else
1354: cp_error_at ("duplicate member `%D'", x);
1355: if (prev == 0)
1356: fields = TREE_CHAIN (fields);
1357: else
1358: TREE_CHAIN (prev) = TREE_CHAIN (x);
1359: }
1360: }
1361: }
1362: }
1363: return fields;
1364: }
1365:
1366: static void
1367: delete_duplicate_fields (fields)
1368: tree fields;
1369: {
1370: tree x;
1371: for (x = fields; x && TREE_CHAIN (x); x = TREE_CHAIN (x))
1372: TREE_CHAIN (x) = delete_duplicate_fields_1 (x, &x, TREE_CHAIN (x));
1373: }
1374:
1375: /* Change the visibility of T::FDECL to VISIBILITY.
1376: Return 1 if change was legit, otherwise return 0. */
1377: static int
1378: alter_visibility (t, fdecl, visibility)
1379: tree t;
1380: tree fdecl;
1381: enum visibility_type visibility;
1382: {
1383: tree elem = purpose_member (t, DECL_VISIBILITY (fdecl));
1384: if (elem && TREE_VALUE (elem) != (tree)visibility)
1385: {
1386: if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1387: {
1388: cp_error_at ("conflicting visibility specifications for method `%D', ignored", TREE_TYPE (fdecl));
1389: }
1390: else
1391: error ("conflicting visibility specifications for field `%s', ignored",
1392: IDENTIFIER_POINTER (DECL_NAME (fdecl)));
1393: }
1394: else if (TREE_PRIVATE (fdecl) && visibility != visibility_private)
1395: cp_error_at ("cannot make private `%D' non-private", fdecl);
1396: else if (TREE_PROTECTED (fdecl))
1397: {
1398: if (visibility == visibility_public)
1399: cp_error_at ("cannot make protected `%D' public", fdecl);
1400: goto alter;
1401: }
1402: /* ARM 11.3: an access declaration may not be used to restrict access
1403: to a member that is accessible in the base class. */
1404: else if (TREE_PUBLIC (fdecl)
1405: && (visibility == visibility_private
1406: || visibility == visibility_protected))
1407: cp_error_at ("cannot reduce visibility of public member `%D'", fdecl);
1408: else if (elem == NULL_TREE)
1409: {
1410: alter:
1411: DECL_VISIBILITY (fdecl) = tree_cons (t, (tree)visibility,
1412: DECL_VISIBILITY (fdecl));
1413: return 1;
1414: }
1415: return 0;
1416: }
1417:
1418: static tree
1419: get_vfield_offset (binfo)
1420: tree binfo;
1421: {
1422: return size_binop (PLUS_EXPR,
1423: DECL_FIELD_BITPOS (CLASSTYPE_VFIELD (BINFO_TYPE (binfo))),
1424: BINFO_OFFSET (binfo));
1425: }
1426:
1427: /* If FOR_TYPE needs to reinitialize virtual function table pointers
1428: for TYPE's sub-objects, add such reinitializations to BASE_INIT_LIST.
1429: Returns BASE_INIT_LIST appropriately modified. */
1430:
1431: static tree
1432: maybe_fixup_vptrs (for_type, binfo, base_init_list)
1433: tree for_type, binfo, base_init_list;
1434: {
1435: /* Now reinitialize any slots that don't fall under our virtual
1436: function table pointer. */
1437: tree vfields = CLASSTYPE_VFIELDS (BINFO_TYPE (binfo));
1438: while (vfields)
1439: {
1440: tree basetype = VF_NORMAL_VALUE (vfields)
1441: ? TYPE_MAIN_VARIANT (VF_NORMAL_VALUE (vfields))
1442: : VF_BASETYPE_VALUE (vfields);
1443:
1444: tree base_binfo = get_binfo (basetype, for_type, 0);
1445: if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (basetype))
1446: {
1447: tree base_offset = get_vfield_offset (base_binfo);
1448: if (! tree_int_cst_equal (base_offset, get_vfield_offset (TYPE_BINFO (for_type)))
1449: && ! tree_int_cst_equal (base_offset, get_vfield_offset (binfo)))
1450: base_init_list = tree_cons (error_mark_node, base_binfo,
1451: base_init_list);
1452: }
1453: vfields = TREE_CHAIN (vfields);
1454: }
1455: return base_init_list;
1456: }
1457:
1458: /* If TYPE does not have a constructor, then the compiler must
1459: manually deal with all of the initialization this type requires.
1460:
1461: If a base initializer exists only to fill in the virtual function
1462: table pointer, then we mark that fact with the TREE_VIRTUAL bit.
1463: This way, we avoid multiple initializations of the same field by
1464: each virtual function table up the class hierarchy.
1465:
1466: Virtual base class pointers are not initialized here. They are
1467: initialized only at the "top level" of object creation. If we
1468: initialized them here, we would have to skip a lot of work. */
1469:
1470: static void
1471: build_class_init_list (type)
1472: tree type;
1473: {
1474: tree base_init_list = NULL_TREE;
1475: tree member_init_list = NULL_TREE;
1476:
1477: /* Since we build member_init_list and base_init_list using
1478: tree_cons, backwards fields the all through work. */
1479: tree x;
1480: tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
1481: int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1482:
1483: for (x = TYPE_FIELDS (type); x; x = TREE_CHAIN (x))
1484: {
1485: if (TREE_CODE (x) != FIELD_DECL)
1486: continue;
1487:
1488: if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (x))
1489: || DECL_INITIAL (x) != NULL_TREE)
1490: member_init_list = tree_cons (x, type, member_init_list);
1491: }
1492: member_init_list = nreverse (member_init_list);
1493:
1494: /* We will end up doing this last. Need special marker
1495: to avoid infinite regress. */
1496: if (TYPE_VIRTUAL_P (type))
1497: {
1498: base_init_list = build_tree_list (error_mark_node, TYPE_BINFO (type));
1499: if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (type) == 0)
1500: TREE_VALUE (base_init_list) = NULL_TREE;
1501: TREE_ADDRESSABLE (base_init_list) = 1;
1502: }
1503:
1504: /* Each base class which needs to have initialization
1505: of some kind gets to make such requests known here. */
1506: for (i = n_baseclasses-1; i >= 0; i--)
1507: {
1508: tree base_binfo = TREE_VEC_ELT (binfos, i);
1509: tree blist;
1510:
1511: /* Don't initialize virtual baseclasses this way. */
1512: if (TREE_VIA_VIRTUAL (base_binfo))
1513: continue;
1514:
1515: if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (base_binfo)))
1516: {
1517: /* ...and the last shall come first... */
1518: base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
1519: base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
1520: continue;
1521: }
1522:
1523: if ((blist = CLASSTYPE_BASE_INIT_LIST (BINFO_TYPE (base_binfo))) == NULL_TREE)
1524: /* Nothing to initialize. */
1525: continue;
1526:
1527: /* ...ditto... */
1528: base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
1529:
1530: /* This is normally true for single inheritance.
1531: The win is we can shrink the chain of initializations
1532: to be done by only converting to the actual type
1533: we are interested in. */
1534: if (TREE_VALUE (blist)
1535: && TREE_CODE (TREE_VALUE (blist)) == TREE_VEC
1536: && tree_int_cst_equal (BINFO_OFFSET (base_binfo),
1537: BINFO_OFFSET (TREE_VALUE (blist))))
1538: {
1539: if (base_init_list)
1540: {
1541: /* Does it do more than just fill in a
1542: virtual function table pointer? */
1543: if (! TREE_ADDRESSABLE (blist))
1544: base_init_list = build_tree_list (blist, base_init_list);
1545: /* Can we get by just with the virtual function table
1546: pointer that it fills in? */
1547: else if (TREE_ADDRESSABLE (base_init_list)
1548: && TREE_VALUE (base_init_list) == 0)
1549: base_init_list = blist;
1550: /* Maybe, but it is not obvious as the previous case. */
1551: else if (! CLASSTYPE_NEEDS_VIRTUAL_REINIT (type))
1552: {
1553: tree last = tree_last (base_init_list);
1554: while (TREE_VALUE (last)
1555: && TREE_CODE (TREE_VALUE (last)) == TREE_LIST)
1556: last = tree_last (TREE_VALUE (last));
1557: if (TREE_VALUE (last) == 0)
1558: base_init_list = build_tree_list (blist, base_init_list);
1559: }
1560: }
1561: else
1562: base_init_list = blist;
1563: }
1564: else
1565: {
1566: /* The function expand_aggr_init knows how to do the
1567: initialization of `basetype' without getting
1568: an explicit `blist'. */
1569: if (base_init_list)
1570: base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
1571: else
1572: base_init_list = CLASSTYPE_BINFO_AS_LIST (BINFO_TYPE (base_binfo));
1573: }
1574: }
1575:
1576: if (base_init_list)
1577: if (member_init_list)
1578: CLASSTYPE_BASE_INIT_LIST (type) = build_tree_list (base_init_list, member_init_list);
1579: else
1580: CLASSTYPE_BASE_INIT_LIST (type) = base_init_list;
1581: else if (member_init_list)
1582: CLASSTYPE_BASE_INIT_LIST (type) = member_init_list;
1583: }
1584:
1585: struct base_info
1586: {
1587: int has_virtual;
1588: int max_has_virtual;
1589: int n_ancestors;
1590: tree vfield;
1591: tree vfields;
1592: char needs_default_ctor;
1593: char cant_have_default_ctor;
1594: char cant_have_const_ctor;
1595: char members_need_dtors;
1596: char needs_virtual_dtor;
1597: };
1598:
1599: /* Record information about type T derived from its base classes.
1600: Store most of that information in T itself, and place the
1601: remaining information in the struct BASE_INFO.
1602:
1603: Propagate basetype offsets throughout the lattice. Note that the
1604: lattice topped by T is really a pair: it's a DAG that gives the
1605: structure of the derivation hierarchy, and it's a list of the
1606: virtual baseclasses that appear anywhere in the DAG. When a vbase
1607: type appears in the DAG, it's offset is 0, and it's children start
1608: their offsets from that point. When a vbase type appears in the list,
1609: its offset is the offset it has in the hierarchy, and its children's
1610: offsets include that offset in theirs.
1611:
1612: Returns the index of the first base class to have virtual functions,
1613: or zero if no such base class. */
1614:
1615: static int
1616: finish_base_struct (t, b, binfos)
1617: tree t;
1618: struct base_info *b;
1619: tree binfos;
1620: {
1621: int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1622: int first_vfn_base_index = -1;
1623: bzero (b, sizeof (struct base_info));
1624:
1625: for (i = 0; i < n_baseclasses; i++)
1626: {
1627: tree base_binfo = TREE_VEC_ELT (binfos, i);
1628: tree basetype = BINFO_TYPE (base_binfo);
1629:
1630: /* If the type of basetype is incomplete, then
1631: we already complained about that fact
1632: (and we should have fixed it up as well). */
1633: if (TYPE_SIZE (basetype) == 0)
1634: {
1635: int j;
1636: /* The base type is of incomplete type. It is
1637: probably best to pretend that it does not
1638: exist. */
1639: if (i == n_baseclasses-1)
1640: TREE_VEC_ELT (binfos, i) = NULL_TREE;
1641: TREE_VEC_LENGTH (binfos) -= 1;
1642: n_baseclasses -= 1;
1643: for (j = i; j+1 < n_baseclasses; j++)
1644: TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);
1645: }
1646:
1647: if (TYPE_NEEDS_DESTRUCTOR (basetype))
1648: b->members_need_dtors = 1;
1649: if (TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
1650: b->needs_default_ctor = 1;
1651: else if (TYPE_HAS_CONSTRUCTOR (basetype))
1652: b->cant_have_default_ctor = 1;
1653: if (TYPE_GETS_INIT_REF (basetype)
1654: && !TYPE_GETS_CONST_INIT_REF (basetype))
1655: b->cant_have_const_ctor = 1;
1656:
1657: CLASSTYPE_ALTERS_VISIBILITIES_P (t)
1658: |= CLASSTYPE_ALTERS_VISIBILITIES_P (basetype);
1659:
1660: b->n_ancestors += CLASSTYPE_N_SUPERCLASSES (basetype);
1661: TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1662: TYPE_NEEDS_CONSTRUCTOR (t) |= TYPE_NEEDS_CONSTRUCTOR (basetype);
1663: TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (basetype);
1664: TYPE_GETS_ASSIGNMENT (t) |= TYPE_GETS_ASSIGNMENT (basetype);
1665: TYPE_GETS_INIT_REF (t) |= TYPE_GETS_INIT_REF (basetype);
1666:
1667: TYPE_OVERLOADS_CALL_EXPR (t) |= TYPE_OVERLOADS_CALL_EXPR (basetype);
1668: TYPE_OVERLOADS_ARRAY_REF (t) |= TYPE_OVERLOADS_ARRAY_REF (basetype);
1669: TYPE_OVERLOADS_ARROW (t) |= TYPE_OVERLOADS_ARROW (basetype);
1670:
1671: if (! TREE_VIA_VIRTUAL (base_binfo)
1672: #if 0
1673: /* This cannot be done, as prepare_fresh_vtable wants to modify
1674: binfos associated with vfields anywhere in the hierarchy, not
1675: just immediate base classes. Due to unsharing, the compiler
1676: might consume 3% more memory on a real program.
1677: */
1678: && ! BINFO_OFFSET_ZEROP (base_binfo)
1679: #endif
1680: && BINFO_BASETYPES (base_binfo))
1681: {
1682: tree base_binfos = BINFO_BASETYPES (base_binfo);
1683: tree chain = NULL_TREE;
1684: int j;
1685:
1686: /* Now unshare the structure beneath BASE_BINFO. */
1687: for (j = TREE_VEC_LENGTH (base_binfos)-1;
1688: j >= 0; j--)
1689: {
1690: tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
1691: if (! TREE_VIA_VIRTUAL (base_base_binfo))
1692: TREE_VEC_ELT (base_binfos, j)
1693: = make_binfo (BINFO_OFFSET (base_base_binfo),
1694: BINFO_TYPE (base_base_binfo),
1695: BINFO_VTABLE (base_base_binfo),
1696: BINFO_VIRTUALS (base_base_binfo),
1697: chain);
1698: chain = TREE_VEC_ELT (base_binfos, j);
1699: TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
1700: TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
1701: }
1702:
1703: /* Completely unshare potentially shared data, and
1704: update what is ours. */
1705: propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
1706: }
1707:
1708: if (! TREE_VIA_VIRTUAL (base_binfo))
1709: CLASSTYPE_N_SUPERCLASSES (t) += 1;
1710:
1711: if (TYPE_VIRTUAL_P (basetype))
1712: {
1713: /* If there's going to be a destructor needed, make
1714: sure it will be virtual. */
1715: b->needs_virtual_dtor = 1;
1716:
1717: /* Don't borrow virtuals from virtual baseclasses. */
1718: if (TREE_VIA_VIRTUAL (base_binfo))
1719: continue;
1720:
1721: if (first_vfn_base_index < 0)
1722: {
1723: tree vfields;
1724: first_vfn_base_index = i;
1725:
1726: b->has_virtual = CLASSTYPE_VSIZE (basetype);
1727: b->vfield = CLASSTYPE_VFIELD (basetype);
1728: b->vfields = copy_list (CLASSTYPE_VFIELDS (basetype));
1729: vfields = b->vfields;
1730: while (vfields)
1731: {
1732: if (VF_BINFO_VALUE (vfields) == NULL_TREE
1733: || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1734: {
1735: tree value = VF_BASETYPE_VALUE (vfields);
1736: if (DECL_NAME (CLASSTYPE_VFIELD (value))
1737: == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1738: VF_NORMAL_VALUE (b->vfields) = basetype;
1739: else
1740: VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
1741: }
1742: vfields = TREE_CHAIN (vfields);
1743: }
1744: CLASSTYPE_VFIELD (t) = b->vfield;
1745: }
1746: else
1747: {
1748: /* Only add unique vfields, and flatten them out as we go. */
1749: tree vfields = CLASSTYPE_VFIELDS (basetype);
1750: while (vfields)
1751: {
1752: if (VF_BINFO_VALUE (vfields) == NULL_TREE
1753: || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1754: {
1755: tree value = VF_BASETYPE_VALUE (vfields);
1756: b->vfields = tree_cons (base_binfo, value, b->vfields);
1757: if (DECL_NAME (CLASSTYPE_VFIELD (value))
1758: == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1759: VF_NORMAL_VALUE (b->vfields) = basetype;
1760: else
1761: VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
1762: }
1763: vfields = TREE_CHAIN (vfields);
1764: }
1765:
1766: if (b->has_virtual == 0)
1767: {
1768: first_vfn_base_index = i;
1769: b->has_virtual = CLASSTYPE_VSIZE (basetype);
1770: b->vfield = CLASSTYPE_VFIELD (basetype);
1771: CLASSTYPE_VFIELD (t) = b->vfield;
1772: /* When we install the first one, set the VF_NORMAL_VALUE
1773: to be the current class, as this it is the most derived
1774: class. Hopefully, this is not set to something else
1775: later. (mrs) */
1776: vfields = b->vfields;
1777: while (vfields)
1778: {
1779: if (DECL_NAME (CLASSTYPE_VFIELD (t))
1780: == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1781: {
1782: VF_NORMAL_VALUE (vfields) = t;
1783: /* There should only be one of them! And it should
1784: always be found, if we get into here. (mrs) */
1785: break;
1786: }
1787: vfields = TREE_CHAIN (vfields);
1788: }
1789: }
1790: }
1791: }
1792: }
1793:
1794: {
1795: tree vfields;
1796: /* Find the base class with the largest number of virtual functions. */
1797: for (vfields = b->vfields; vfields; vfields = TREE_CHAIN (vfields))
1798: {
1799: if (CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields)) > b->max_has_virtual)
1800: b->max_has_virtual = CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields));
1801: if (VF_DERIVED_VALUE (vfields)
1802: && CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields)) > b->max_has_virtual)
1803: b->max_has_virtual = CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields));
1804: }
1805: }
1806:
1807: if (b->vfield == 0)
1808: /* If all virtual functions come only from virtual baseclasses. */
1809: return -1;
1810: return first_vfn_base_index;
1811: }
1812:
1813: static int
1814: typecode_p (type, code)
1815: tree type;
1816: enum tree_code code;
1817: {
1818: return (TREE_CODE (type) == code
1819: || (TREE_CODE (type) == REFERENCE_TYPE
1820: && TREE_CODE (TREE_TYPE (type)) == code));
1821: }
1822:
1823: /* Set memoizing fields and bits of T (and its variants) for later use.
1824: MAX_HAS_VIRTUAL is the largest size of any T's virtual function tables. */
1825: static void
1826: finish_struct_bits (t, max_has_virtual)
1827: tree t;
1828: int max_has_virtual;
1829: {
1830: int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1831: tree method_vec = CLASSTYPE_METHOD_VEC (t);
1832:
1833: /* Fix up variants (if any). */
1834: tree variants = TYPE_NEXT_VARIANT (t);
1835: while (variants)
1836: {
1837: /* These fields are in the _TYPE part of the node, not in
1838: the TYPE_LANG_SPECIFIC component, so they are not shared. */
1839: TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
1840: TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
1841: TYPE_NEEDS_CONSTRUCTOR (variants) = TYPE_NEEDS_CONSTRUCTOR (t);
1842: TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1843: TYPE_NEEDS_DESTRUCTOR (variants) = TYPE_NEEDS_DESTRUCTOR (t);
1844:
1845: TYPE_USES_COMPLEX_INHERITANCE (variants) = TYPE_USES_COMPLEX_INHERITANCE (t);
1846: TYPE_VIRTUAL_P (variants) = TYPE_VIRTUAL_P (t);
1847: TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t);
1848: /* Copy whatever these are holding today. */
1849: TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t);
1850: TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t);
1851: variants = TYPE_NEXT_VARIANT (variants);
1852: }
1853:
1854: if (n_baseclasses && max_has_virtual)
1855: {
1856: /* Done by `finish_struct' for classes without baseclasses. */
1857: int has_abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (t) != 0;
1858: tree binfos = TYPE_BINFO_BASETYPES (t);
1859: for (i = n_baseclasses-1; i >= 0; i--)
1860: {
1861: has_abstract_virtuals
1862: |= (CLASSTYPE_ABSTRACT_VIRTUALS (BINFO_TYPE (TREE_VEC_ELT (binfos, i))) != 0);
1863: if (has_abstract_virtuals)
1864: break;
1865: }
1866: if (has_abstract_virtuals)
1867: CLASSTYPE_ABSTRACT_VIRTUALS (t) = get_abstract_virtuals (t);
1868: }
1869:
1870: if (n_baseclasses)
1871: {
1872: /* Notice whether this class has type conversion functions defined. */
1873: tree binfo = TYPE_BINFO (t);
1874: tree binfos = BINFO_BASETYPES (binfo);
1875: int n_binfos = list_length (binfo);
1876: tree vbases = CLASSTYPE_VBASECLASSES (t), basetype;
1877: int n_vbases = list_length (vbases), j;
1878:
1879: build_mi_virtuals (n_binfos+n_vbases*n_baseclasses, max_has_virtual);
1880: /* Fill in virtual function table with values which do not come
1881: "normal"ly, i.e., those which come from virtual and/or
1882: non-leftmost base classes. */
1883: for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
1884: {
1885: if (TREE_VIA_VIRTUAL (binfo))
1886: /* Virtual functions from virtual baseclasses are done below. */;
1887: else if (CLASSTYPE_VSIZE (BINFO_TYPE (binfo)))
1888: {
1889: tree virtuals = TREE_CHAIN (BINFO_VIRTUALS (binfo));
1890: if (flag_dossier)
1891: virtuals = TREE_CHAIN (virtuals);
1892: add_mi_virtuals (++i, virtuals);
1893: }
1894: }
1895: for (; vbases; vbases = TREE_CHAIN (vbases))
1896: {
1897: basetype = BINFO_TYPE (vbases);
1898: if (CLASSTYPE_VSIZE (basetype))
1899: for (j = n_baseclasses-1; j >= 0; j--)
1900: {
1901: tree this_binfo = TREE_VEC_ELT (binfos, j);
1902: if (UNIQUELY_DERIVED_FROM_P (basetype, this_binfo))
1903: {
1904: tree virtuals = TREE_CHAIN (BINFO_VIRTUALS (vbases));
1905: if (flag_dossier)
1906: virtuals = TREE_CHAIN (virtuals);
1907: add_mi_virtuals (++i, virtuals);
1908: }
1909: }
1910: }
1911: for (i = n_baseclasses-1; i >= 0; i--)
1912: {
1913: basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
1914:
1915: if (TYPE_HAS_CONVERSION (basetype))
1916: {
1917: TYPE_HAS_CONVERSION (t) = 1;
1918: TYPE_HAS_INT_CONVERSION (t) |= TYPE_HAS_INT_CONVERSION (basetype);
1919: TYPE_HAS_REAL_CONVERSION (t) |= TYPE_HAS_REAL_CONVERSION (basetype);
1920: }
1921: if (CLASSTYPE_MAX_DEPTH (basetype) >= CLASSTYPE_MAX_DEPTH (t))
1922: CLASSTYPE_MAX_DEPTH (t) = CLASSTYPE_MAX_DEPTH (basetype) + 1;
1923: }
1924: report_ambiguous_mi_virtuals (n_binfos+n_vbases*n_baseclasses, t);
1925: #if 0
1926: /* Now that we know what the virtual function table looks like,
1927: fix up offsets in the presence of virtual base classes. */
1928: if (n_vbases)
1929: fixup_vbase_offsets (t);
1930: #endif
1931: }
1932:
1933: /* Need to test METHOD_VEC here in case all methods
1934: (conversions and otherwise) are inherited. */
1935: if (TYPE_HAS_CONVERSION (t) && method_vec != NULL_TREE)
1936: {
1937: tree first_conversions[last_conversion_type];
1938: tree last_conversions[last_conversion_type];
1939: enum conversion_type conv_index;
1940: tree *tmp;
1941: int i;
1942:
1943: bzero (first_conversions, sizeof (first_conversions));
1944: bzero (last_conversions, sizeof (last_conversions));
1945: for (tmp = &TREE_VEC_ELT (method_vec, 1);
1946: tmp != TREE_VEC_END (method_vec); tmp += 1)
1947: {
1948: /* ??? This should compare DECL_NAME (*tmp) == ansi_opname[TYPE_EXPR]. */
1949: if (IDENTIFIER_TYPENAME_P (DECL_ASSEMBLER_NAME (*tmp)))
1950: {
1951: tree fntype = TREE_TYPE (*tmp);
1952: tree return_type = TREE_TYPE (fntype);
1953: my_friendly_assert (TREE_CODE (fntype) == METHOD_TYPE, 171);
1954:
1955: if (typecode_p (return_type, POINTER_TYPE))
1956: {
1957: if (TYPE_READONLY (TREE_TYPE (return_type)))
1958: conv_index = constptr_conv;
1959: else
1960: conv_index = ptr_conv;
1961: }
1962: else if (typecode_p (return_type, INTEGER_TYPE))
1963: {
1964: TYPE_HAS_INT_CONVERSION (t) = 1;
1965: conv_index = int_conv;
1966: }
1967: else if (typecode_p (return_type, REAL_TYPE))
1968: {
1969: TYPE_HAS_REAL_CONVERSION (t) = 1;
1970: conv_index = real_conv;
1971: }
1972: else
1973: continue;
1974:
1975: if (first_conversions[(int) conv_index] == NULL_TREE)
1976: first_conversions[(int) conv_index] = *tmp;
1977: last_conversions[(int) conv_index] = *tmp;
1978: }
1979: }
1980:
1981: for (i = 0; i < (int) last_conversion_type; i++)
1982: if (first_conversions[i] != last_conversions[i])
1983: CLASSTYPE_CONVERSION (t, i) = error_mark_node;
1984: else
1985: CLASSTYPE_CONVERSION (t, i) = first_conversions[i];
1986: }
1987:
1988: /* If this type has constructors, force its mode to be BLKmode,
1989: and force its TREE_ADDRESSABLE bit to be nonzero. */
1990: if (TYPE_NEEDS_CONSTRUCTING (t) || TYPE_NEEDS_DESTRUCTOR (t))
1991: {
1992: tree variants = t;
1993:
1994: if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
1995: DECL_MODE (TYPE_NAME (t)) = BLKmode;
1996: while (variants)
1997: {
1998: TYPE_MODE (variants) = BLKmode;
1999: TREE_ADDRESSABLE (variants) = 1;
2000: variants = TYPE_NEXT_VARIANT (variants);
2001: }
2002: }
2003: }
2004:
2005: /* Warn about duplicate methods in fn_fields. Also compact method
2006: lists so that lookup can be made faster.
2007:
2008: Algorithm: Outer loop builds lists by method name. Inner loop
2009: checks for redundant method names within a list.
2010:
2011: Data Structure: List of method lists. The outer list is a
2012: TREE_LIST, whose TREE_PURPOSE field is the field name and the
2013: TREE_VALUE is the TREE_CHAIN of the FUNCTION_DECLs. Friends are
2014: chained in the same way as member functions, but they live in the
2015: TREE_TYPE field of the outer list. That allows them to be quickly
2016: deleted, and requires no extra storage.
2017:
2018: If there are any constructors/destructors, they are moved to the
2019: front of the list. This makes pushclass more efficient.
2020:
2021: We also link each field which has shares a name with its baseclass
2022: to the head of the list of fields for that base class. This allows
2023: us to reduce search time in places like `build_method_call' to
2024: consider only reasonably likely functions. */
2025:
2026: static tree
2027: finish_struct_methods (t, fn_fields, nonprivate_method)
2028: tree t;
2029: tree fn_fields;
2030: int nonprivate_method;
2031: {
2032: tree method_vec;
2033: tree name = constructor_name (t);
2034: int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
2035:
2036: /* Now prepare to gather fn_fields into vector. */
2037: struct obstack *ambient_obstack = current_obstack;
2038: current_obstack = &class_obstack;
2039: method_vec = make_node (TREE_VEC);
2040: /* Room has been saved for constructors and destructors. */
2041: current_obstack = ambient_obstack;
2042: /* Now make this a live vector. */
2043: obstack_free (&class_obstack, method_vec);
2044: obstack_blank (&class_obstack, sizeof (struct tree_vec));
2045:
2046: while (fn_fields)
2047: {
2048: /* NEXT Pointer, TEST Pointer, and BASE Pointer. */
2049: tree nextp, *testp;
2050: tree fn_name = DECL_NAME (fn_fields);
2051: if (fn_name == NULL_TREE)
2052: fn_name = name;
2053:
2054: nextp = TREE_CHAIN (fn_fields);
2055: TREE_CHAIN (fn_fields) = NULL_TREE;
2056: /* Constructors are handled easily in search routines.
2057: Besides, we know we won't find any, so do not bother looking. */
2058: if (fn_name == name && TREE_VEC_ELT (method_vec, 0) == 0)
2059: TREE_VEC_ELT (method_vec, 0) = fn_fields;
2060: else
2061: {
2062: testp = &TREE_VEC_ELT (method_vec, 0);
2063: if (*testp == NULL_TREE)
2064: testp++;
2065: while (((HOST_WIDE_INT) testp
2066: < (HOST_WIDE_INT) obstack_next_free (&class_obstack))
2067: && DECL_NAME (*testp) != fn_name)
2068: testp++;
2069: if ((HOST_WIDE_INT) testp
2070: < (HOST_WIDE_INT) obstack_next_free (&class_obstack))
2071: {
2072: tree x, prev_x;
2073:
2074: for (x = *testp; x; x = DECL_CHAIN (x))
2075: {
2076: if (DECL_NAME (fn_fields) == ansi_opname[(int) DELETE_EXPR])
2077: {
2078: /* ANSI C++ June 5 1992 WP 12.5.5.1 */
2079: cp_error_at ("`%D' overloaded", fn_fields);
2080: cp_error_at ("previous declaration as `%D' here", x);
2081: }
2082: if (DECL_ASSEMBLER_NAME (fn_fields)==DECL_ASSEMBLER_NAME (x))
2083: {
2084: /* We complain about multiple destructors on sight,
2085: so we do not repeat the warning here. Friend-friend
2086: ambiguities are warned about outside this loop. */
2087: if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fn_fields)))
2088: cp_error_at ("ambiguous method `%#D' in structure",
2089: fn_fields);
2090: break;
2091: }
2092: prev_x = x;
2093: }
2094: if (x == 0)
2095: {
2096: if (*testp)
2097: DECL_CHAIN (prev_x) = fn_fields;
2098: else
2099: *testp = fn_fields;
2100: }
2101: }
2102: else
2103: {
2104: obstack_ptr_grow (&class_obstack, fn_fields);
2105: method_vec = (tree)obstack_base (&class_obstack);
2106: }
2107: }
2108: fn_fields = nextp;
2109: }
2110:
2111: TREE_VEC_LENGTH (method_vec) = (tree *)obstack_next_free (&class_obstack)
2112: - (&TREE_VEC_ELT (method_vec, 0));
2113: obstack_finish (&class_obstack);
2114: CLASSTYPE_METHOD_VEC (t) = method_vec;
2115:
2116: if (nonprivate_method == 0
2117: && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
2118: && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
2119: {
2120: tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2121: for (i = 0; i < n_baseclasses; i++)
2122: if (TREE_VIA_PUBLIC (TREE_VEC_ELT (binfos, i))
2123: || TREE_VIA_PROTECTED (TREE_VEC_ELT (binfos, i)))
2124: {
2125: nonprivate_method = 1;
2126: break;
2127: }
2128: if (nonprivate_method == 0)
2129: cp_warning ("all member functions in class `%T' are private", t);
2130: }
2131:
2132: /* If there are constructors (and destructors), they are at the
2133: front. Place destructors at very front. Also warn if all
2134: constructors and/or destructors are private (in which case this
2135: class is effectively unusable. */
2136: if (TYPE_HAS_DESTRUCTOR (t))
2137: {
2138: tree dtor, prev;
2139:
2140: for (dtor = TREE_VEC_ELT (method_vec, 0);
2141: dtor;
2142: prev = dtor, dtor = DECL_CHAIN (dtor))
2143: {
2144: if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (dtor)))
2145: {
2146: if (TREE_PRIVATE (dtor)
2147: && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
2148: && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE
2149: && warn_ctor_dtor_privacy)
2150: warning ("class `%s' only defines a private destructor and has no friends",
2151: TYPE_NAME_STRING (t));
2152: break;
2153: }
2154: }
2155:
2156: /* Wild parse errors can cause this to happen. */
2157: if (dtor == NULL_TREE)
2158: TYPE_HAS_DESTRUCTOR (t) = 0;
2159: else if (dtor != TREE_VEC_ELT (method_vec, 0))
2160: {
2161: DECL_CHAIN (prev) = DECL_CHAIN (dtor);
2162: DECL_CHAIN (dtor) = TREE_VEC_ELT (method_vec, 0);
2163: TREE_VEC_ELT (method_vec, 0) = dtor;
2164: }
2165: }
2166:
2167: /* Now for each member function (except for constructors and
2168: destructors), compute where member functions of the same
2169: name reside in base classes. */
2170: if (n_baseclasses != 0
2171: && TREE_VEC_LENGTH (method_vec) > 1)
2172: {
2173: int len = TREE_VEC_LENGTH (method_vec);
2174: tree baselink_vec = make_tree_vec (len);
2175: int any_links = 0;
2176: tree baselink_binfo = build_tree_list (NULL_TREE, TYPE_BINFO (t));
2177:
2178: for (i = 1; i < len; i++)
2179: {
2180: TREE_VEC_ELT (baselink_vec, i)
2181: = get_baselinks (baselink_binfo, t,
2182: DECL_NAME (TREE_VEC_ELT (method_vec, i)));
2183: if (TREE_VEC_ELT (baselink_vec, i) != 0)
2184: {
2185: any_links = 1;
2186:
2187: if (DECL_VINDEX (TREE_VEC_ELT (method_vec, i)) != 0)
2188: {
2189: tree blist = TREE_VEC_ELT (baselink_vec, i);
2190: tree this_decl = TREE_VEC_ELT (method_vec, i);
2191:
2192: while (blist)
2193: {
2194: tree base_decl = TREE_VALUE (blist);
2195: blist = TREE_CHAIN (blist);
2196:
2197: if (DECL_VINDEX (base_decl) == 0)
2198: {
2199: tree bft = TREE_TYPE (base_decl);
2200: tree tft = TREE_TYPE (this_decl);
2201: tree bal = TYPE_ARG_TYPES (bft);
2202: tree tal = TYPE_ARG_TYPES (tft);
2203:
2204: if (compparms (TREE_CHAIN (bal), TREE_CHAIN (tal), 2))
2205: cp_warning ("method `%D' redeclared as `virtual %D'",
2206: base_decl, this_decl);
2207: }
2208: }
2209: }
2210: }
2211: }
2212: if (any_links != 0)
2213: CLASSTYPE_BASELINK_VEC (t) = baselink_vec;
2214: else
2215: obstack_free (current_obstack, baselink_vec);
2216: }
2217:
2218:
2219:
2220: /* Now add the methods to the TYPE_METHODS of T, arranged in a chain. */
2221: {
2222: tree x, last_x = NULL_TREE;
2223: int limit = TREE_VEC_LENGTH (method_vec);
2224:
2225: for (i = 1; i < limit; i++)
2226: {
2227: for (x = TREE_VEC_ELT (method_vec, i); x; x = DECL_CHAIN (x))
2228: {
2229: if (last_x != NULL_TREE)
2230: TREE_CHAIN (last_x) = x;
2231: last_x = x;
2232: }
2233: }
2234:
2235: /* Put ctors and dtors at the front of the list. */
2236: x = TREE_VEC_ELT (method_vec, 0);
2237: if (x)
2238: {
2239: while (DECL_CHAIN (x))
2240: {
2241: /* Let's avoid being circular about this. */
2242: if (x == DECL_CHAIN (x))
2243: break;
2244: TREE_CHAIN (x) = DECL_CHAIN (x);
2245: x = DECL_CHAIN (x);
2246: }
2247: if (TREE_VEC_LENGTH (method_vec) > 1)
2248: TREE_CHAIN (x) = TREE_VEC_ELT (method_vec, 1);
2249: else
2250: TREE_CHAIN (x) = NULL_TREE;
2251: }
2252: }
2253:
2254: #if 0
2255: TYPE_METHODS (t) = TREE_VEC_ELT (method_vec, 0)
2256: ? TREE_VEC_ELT (method_vec, 0) : TREE_VEC_ELT (method_vec, 1);
2257: #else
2258: TYPE_METHODS (t) = method_vec;
2259: #endif
2260:
2261: return method_vec;
2262: }
2263:
2264: /* Emit error when a duplicate definition of a type is seen. Patch up. */
2265:
2266: void
2267: duplicate_tag_error (t)
2268: tree t;
2269: {
2270: char *err_name;
2271: tree name = TYPE_NAME (t);
2272: if (TREE_CODE (name) == TYPE_DECL)
2273: name = DECL_NAME (name);
2274: err_name = IDENTIFIER_POINTER (name);
2275: if (TREE_CODE (t) == UNION_TYPE)
2276: error ("redefinition of `union %s'", err_name);
2277: else if (TREE_CODE (t) == RECORD_TYPE)
2278: error ("redefinition of `struct %s'", err_name);
2279: else
2280: error ("redefinition of tag %s", err_name);
2281:
2282: /* Pretend we haven't defined this type. */
2283:
2284: /* All of the component_decl's were TREE_CHAINed together in the parser.
2285: finish_struct_methods walks these chains and assembles all methods with
2286: the same base name into DECL_CHAINs. Now we don't need the parser chains
2287: anymore, so we unravel them.
2288: */
2289: /*
2290: * This used to be in finish_struct, but it turns out that the
2291: * TREE_CHAIN is used by dbxout_type_methods and perhaps some other things...
2292: */
2293: if (CLASSTYPE_METHOD_VEC(t))
2294: {
2295: tree tv = CLASSTYPE_METHOD_VEC(t);
2296: int i, len = TREE_VEC_LENGTH (tv);
2297: for (i = 0; i < len; i++)
2298: {
2299: tree unchain = TREE_VEC_ELT (tv, i);
2300: while(unchain != NULL_TREE)
2301: {
2302: TREE_CHAIN (unchain) = NULL_TREE;
2303: unchain = DECL_CHAIN(unchain);
2304: }
2305: }
2306: }
2307:
2308: if (TYPE_LANG_SPECIFIC (t))
2309: {
2310: tree as_list = CLASSTYPE_AS_LIST (t);
2311: tree binfo = TYPE_BINFO (t);
2312: tree binfo_as_list = CLASSTYPE_BINFO_AS_LIST (t);
2313: int interface_only = CLASSTYPE_INTERFACE_ONLY (t);
2314: int interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (t);
2315:
2316: bzero (TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
2317: BINFO_BASETYPES(binfo) = NULL_TREE;
2318:
2319: CLASSTYPE_AS_LIST (t) = as_list;
2320: TYPE_BINFO (t) = binfo;
2321: CLASSTYPE_BINFO_AS_LIST (t) = binfo_as_list;
2322: CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2323: SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
2324: CLASSTYPE_VBASE_SIZE (t) = integer_zero_node;
2325: TYPE_REDEFINED (t) = 1;
2326: }
2327: TYPE_SIZE (t) = NULL_TREE;
2328: TYPE_MODE (t) = VOIDmode;
2329: TYPE_FIELDS (t) = NULL_TREE;
2330: TYPE_METHODS (t) = NULL_TREE;
2331: TYPE_VFIELD (t) = NULL_TREE;
2332: TYPE_CONTEXT (t) = NULL_TREE;
2333: }
2334:
2335: /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
2336: (or C++ class declaration).
2337:
2338: For C++, we must handle the building of derived classes.
2339: Also, C++ allows static class members. The way that this is
2340: handled is to keep the field name where it is (as the DECL_NAME
2341: of the field), and place the overloaded decl in the DECL_FIELD_BITPOS
2342: of the field. layout_record and layout_union will know about this.
2343:
2344: More C++ hair: inline functions have text in their
2345: DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
2346: meaningful tree structure. After the struct has been laid out, set
2347: things up so that this can happen.
2348:
2349: And still more: virtual functions. In the case of single inheritance,
2350: when a new virtual function is seen which redefines a virtual function
2351: from the base class, the new virtual function is placed into
2352: the virtual function table at exactly the same address that
2353: it had in the base class. When this is extended to multiple
2354: inheritance, the same thing happens, except that multiple virtual
2355: function tables must be maintained. The first virtual function
2356: table is treated in exactly the same way as in the case of single
2357: inheritance. Additional virtual function tables have different
2358: DELTAs, which tell how to adjust `this' to point to the right thing.
2359:
2360: LIST_OF_FIELDLISTS is just that. The elements of the list are
2361: TREE_LIST elements, whose TREE_PURPOSE field tells what visibility
2362: the list has, and the TREE_VALUE slot gives the actual fields.
2363:
2364: If flag_all_virtual == 1, then we lay all functions into
2365: the virtual function table, as though they were declared
2366: virtual. Constructors do not lay down in the virtual function table.
2367:
2368: If flag_all_virtual == 2, then we lay all functions into
2369: the virtual function table, such that virtual functions
2370: occupy a space by themselves, and then all functions
2371: of the class occupy a space by themselves. This is illustrated
2372: in the following diagram:
2373:
2374: class A; class B : A;
2375:
2376: Class A's vtbl: Class B's vtbl:
2377: --------------------------------------------------------------------
2378: | A's virtual functions| | B's virtual functions |
2379: | | | (may inherit some from A). |
2380: --------------------------------------------------------------------
2381: | All of A's functions | | All of A's functions |
2382: | (such as a->A::f). | | (such as b->A::f) |
2383: --------------------------------------------------------------------
2384: | B's new virtual functions |
2385: | (not defined in A.) |
2386: -------------------------------
2387: | All of B's functions |
2388: | (such as b->B::f) |
2389: -------------------------------
2390:
2391: this allows the program to make references to any function, virtual
2392: or otherwise in a type-consistent manner. */
2393:
2394: tree
2395: finish_struct (t, list_of_fieldlists, warn_anon)
2396: tree t;
2397: tree list_of_fieldlists;
2398: int warn_anon;
2399: {
2400: extern int interface_only, interface_unknown;
2401: extern tree EHS_type;
2402:
2403: int old;
2404: int round_up_size = 1;
2405:
2406: enum tree_code code = TREE_CODE (t);
2407: register tree x, last_x, method_vec;
2408: int needs_ctor = 0, needs_dtor = 0;
2409: int members_need_dtors, needs_virtual_dtor;
2410: tree name = TYPE_NAME (t), fields, fn_fields, tail;
2411: enum visibility_type visibility;
2412: int all_virtual;
2413: int has_virtual;
2414: int max_has_virtual;
2415: tree pending_virtuals = NULL_TREE;
2416: tree abstract_virtuals = NULL_TREE;
2417: tree vfield;
2418: tree vfields;
2419: int needs_default_ctor;
2420: int cant_have_default_ctor;
2421: int cant_have_const_ctor;
2422:
2423: /* The index of the first base class which has virtual
2424: functions. Only applied to non-virtual baseclasses. */
2425: int first_vfn_base_index;
2426:
2427: int n_baseclasses;
2428: int any_default_members = 0;
2429: char *err_name;
2430: int const_sans_init = 0;
2431: int ref_sans_init = 0;
2432: int nonprivate_method = 0;
2433: tree t_binfo = TYPE_BINFO (t);
2434:
2435: if (TREE_CODE (name) == TYPE_DECL)
2436: {
2437: #if 0 /* Maybe later. -jason */
2438: struct tinst_level *til = tinst_for_decl();
2439:
2440: if (til)
2441: {
2442: DECL_SOURCE_FILE (name) = til->file;
2443: if (DECL_SOURCE_LINE (name))
2444: DECL_SOURCE_LINE (name) = til->line;
2445: }
2446: else
2447: #endif
2448: {
2449: extern int lineno;
2450:
2451: DECL_SOURCE_FILE (name) = input_filename;
2452: /* For TYPE_DECL that are not typedefs (those marked with a line
2453: number of zero, we don't want to mark them as real typedefs.
2454: If this fails one needs to make sure real typedefs have a
2455: previous line number, even if it is wrong, that way the below
2456: will fill in the right line number. (mrs) */
2457: if (DECL_SOURCE_LINE (name))
2458: DECL_SOURCE_LINE (name) = lineno;
2459: }
2460: name = DECL_NAME (name);
2461: }
2462: err_name = IDENTIFIER_POINTER (name);
2463:
2464: if (warn_anon && code != UNION_TYPE && ANON_AGGRNAME_P (name))
2465: {
2466: warning ("anonymous class type not used to declare any objects");
2467: err_name = "(anon)";
2468: }
2469:
2470: #if 0
2471: /* This is set here, but it's never actually used anywhere. (bpk) */
2472: leftmost_baseclasses = NULL_TREE;
2473: #endif
2474: if (TYPE_SIZE (t))
2475: {
2476: if (TREE_CODE (t) == UNION_TYPE)
2477: error ("redefinition of `union %s'", err_name);
2478: else if (TREE_CODE (t) == RECORD_TYPE)
2479: error ("redefinition of `struct %s'", err_name);
2480: else
2481: my_friendly_abort (172);
2482: popclass (0);
2483: return t;
2484: }
2485:
2486: GNU_xref_decl (current_function_decl, t);
2487:
2488: /* If this type was previously laid out as a forward reference,
2489: make sure we lay it out again. */
2490:
2491: TYPE_SIZE (t) = 0;
2492: CLASSTYPE_GOT_SEMICOLON (t) = 0;
2493: CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2494: SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
2495:
2496: if (flag_dossier)
2497: build_t_desc (t, 0);
2498:
2499: TYPE_BINFO (t) = NULL_TREE;
2500:
2501: old = suspend_momentary ();
2502:
2503: /* Install struct as DECL_FIELD_CONTEXT of each field decl.
2504: Also process specified field sizes.
2505: Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
2506: The specified size is found in the DECL_INITIAL.
2507: Store 0 there, except for ": 0" fields (so we can find them
2508: and delete them, below). */
2509:
2510: if (t_binfo && BINFO_BASETYPES (t_binfo))
2511: n_baseclasses = TREE_VEC_LENGTH (BINFO_BASETYPES (t_binfo));
2512: else
2513: n_baseclasses = 0;
2514:
2515: if (n_baseclasses > 0)
2516: {
2517: struct base_info base_info;
2518:
2519: /* If using multiple inheritance, this may cause variants of our
2520: basetypes to be used (instead of their canonical forms). */
2521: fields = layout_basetypes (t, BINFO_BASETYPES (t_binfo));
2522: last_x = tree_last (fields);
2523:
2524: first_vfn_base_index = finish_base_struct (t, &base_info,
2525: BINFO_BASETYPES (t_binfo));
2526: has_virtual = base_info.has_virtual;
2527: max_has_virtual = base_info.max_has_virtual;
2528: CLASSTYPE_N_SUPERCLASSES (t) += base_info.n_ancestors;
2529: vfield = base_info.vfield;
2530: vfields = base_info.vfields;
2531: needs_default_ctor = base_info.needs_default_ctor;
2532: cant_have_default_ctor = base_info.cant_have_default_ctor;
2533: cant_have_const_ctor = base_info.cant_have_const_ctor;
2534: members_need_dtors = base_info.members_need_dtors;
2535: needs_virtual_dtor = base_info.needs_virtual_dtor;
2536: n_baseclasses = TREE_VEC_LENGTH (BINFO_BASETYPES (t_binfo));
2537: }
2538: else
2539: {
2540: first_vfn_base_index = -1;
2541: has_virtual = 0;
2542: max_has_virtual = has_virtual;
2543: vfield = NULL_TREE;
2544: vfields = NULL_TREE;
2545: fields = NULL_TREE;
2546: last_x = NULL_TREE;
2547: needs_default_ctor = 0;
2548: cant_have_default_ctor = 0;
2549: cant_have_const_ctor = 0;
2550: members_need_dtors = 0;
2551: needs_virtual_dtor = 0;
2552: }
2553:
2554: if (write_virtuals == 3 && CLASSTYPE_INTERFACE_KNOWN (t)
2555: && current_lang_name == lang_name_cplusplus)
2556: {
2557: CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2558: CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! interface_only;
2559: }
2560:
2561: /* The three of these are approximations which may later be
2562: modified. Needed at this point to make add_virtual_function
2563: and modify_vtable_entries work. */
2564: TREE_CHAIN (t_binfo) = TYPE_BINFO (t);
2565: TYPE_BINFO (t) = t_binfo;
2566: CLASSTYPE_VFIELDS (t) = vfields;
2567: CLASSTYPE_VFIELD (t) = vfield;
2568:
2569: fn_fields = NULL_TREE;
2570: tail = NULL_TREE;
2571: if (last_x && list_of_fieldlists)
2572: TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
2573:
2574: if (flag_all_virtual == 1 && TYPE_OVERLOADS_METHOD_CALL_EXPR (t))
2575: all_virtual = 1;
2576: else
2577: all_virtual = 0;
2578:
2579: if (CLASSTYPE_DECLARED_CLASS (t) == 0)
2580: {
2581: nonprivate_method = 1;
2582: if (list_of_fieldlists
2583: && TREE_PURPOSE (list_of_fieldlists) == (tree)visibility_default)
2584: TREE_PURPOSE (list_of_fieldlists) = (tree)visibility_public;
2585: }
2586: else if (list_of_fieldlists
2587: && TREE_PURPOSE (list_of_fieldlists) == (tree)visibility_default)
2588: TREE_PURPOSE (list_of_fieldlists) = (tree)visibility_private;
2589:
2590: while (list_of_fieldlists)
2591: {
2592: visibility = (enum visibility_type)TREE_PURPOSE (list_of_fieldlists);
2593:
2594: for (x = TREE_VALUE (list_of_fieldlists); x; x = TREE_CHAIN (x))
2595: {
2596: TREE_PRIVATE (x) = visibility == visibility_private;
2597: TREE_PROTECTED (x) = visibility == visibility_protected;
2598: GNU_xref_member (current_class_name, x);
2599:
2600: if (TREE_CODE (x) == TYPE_DECL
2601: && TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE)
2602: {
2603: /* Make sure we set this up. In find_scoped_type, it explicitly
2604: looks for a TYPE_DECL in the TYPE_FIELDS list. If we don't
2605: do this here, we'll miss including this TYPE_DECL in the
2606: list. */
2607: if (! fields)
2608: fields = x;
2609: last_x = x;
2610: DECL_CONTEXT (x) = t;
2611: continue;
2612: }
2613:
2614:
2615: if (TREE_CODE (x) == FUNCTION_DECL)
2616: {
2617: /* Clear out this flag.
2618:
2619: @@ Doug may figure out how to break
2620: @@ this with nested classes and friends. */
2621: DECL_IN_AGGR_P (x) = 0;
2622:
2623: nonprivate_method |= ! TREE_PRIVATE (x);
2624:
2625: /* If this was an evil function, don't keep it in class. */
2626: if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
2627: continue;
2628:
2629: if (last_x)
2630: TREE_CHAIN (last_x) = TREE_CHAIN (x);
2631: if (! fn_fields)
2632: fn_fields = x;
2633: else
2634: TREE_CHAIN (tail) = x;
2635: tail = x;
2636:
2637: #if 0
2638: /* ??? What if we have duplicate declarations
2639: in T's definition? */
2640: if (DECL_CLASS_CONTEXT (x))
2641: continue;
2642: #endif
2643: DECL_CLASS_CONTEXT (x) = t;
2644:
2645: DECL_FIELD_SIZE (x) = 0;
2646:
2647: /* The name of the field is the original field name
2648: Save this in auxiliary field for later overloading. */
2649: if (DECL_VINDEX (x)
2650: || (all_virtual == 1 && ! DECL_CONSTRUCTOR_P (x)))
2651: {
2652: pending_virtuals = add_virtual_function (pending_virtuals,
2653: &has_virtual, x, t);
2654: if (DECL_ABSTRACT_VIRTUAL_P (x))
2655: abstract_virtuals = tree_cons (NULL_TREE, x, abstract_virtuals);
2656: }
2657: continue;
2658: }
2659:
2660: /* Handle visibility declarations. */
2661: if (DECL_NAME (x) && TREE_CODE (DECL_NAME (x)) == SCOPE_REF)
2662: {
2663: tree fdecl = TREE_OPERAND (DECL_NAME (x), 1);
2664:
2665: if (last_x)
2666: TREE_CHAIN (last_x) = TREE_CHAIN (x);
2667: /* Make type T see field decl FDECL with visibility VISIBILITY.*/
2668: if (TREE_CODE (fdecl) == TREE_LIST)
2669: {
2670: fdecl = TREE_VALUE (fdecl);
2671: while (fdecl)
2672: {
2673: if (alter_visibility (t, fdecl, visibility) == 0)
2674: break;
2675: fdecl = DECL_CHAIN (fdecl);
2676: }
2677: }
2678: else
2679: alter_visibility (t, fdecl, visibility);
2680: CLASSTYPE_ALTERS_VISIBILITIES_P (t) = 1;
2681: continue;
2682: }
2683:
2684: /* If this is of reference type, check if it needs an init. Also
2685: do a little ANSI jig if necessary. */
2686: if (TREE_CODE (x) != TYPE_DECL
2687: && TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE)
2688: {
2689: if (DECL_INITIAL (x) == NULL_TREE)
2690: ref_sans_init = 1;
2691:
2692: /* ARM $12.6.2: [A member initializer list] is the only
2693: way to initialize a nonstatic const and reference
2694: [member]. */
2695: if (! TYPE_HAS_CONSTRUCTOR (t) && !TREE_STATIC (x))
2696: {
2697: if (DECL_NAME (x))
2698: cp_pedwarn_at ("non-static reference `%D' in class without a constructor", x);
2699: else
2700: cp_pedwarn_at ("non-static reference in class without a constructor", x);
2701: }
2702: }
2703:
2704: /* ``A local class cannot have static data members.'' ARM 9.4 */
2705: if (current_function_decl && TREE_STATIC (x))
2706: cp_error ("field `%D' in local class cannot be static", x);
2707:
2708: /* When this goes into scope, it will be a non-local reference. */
2709: DECL_NONLOCAL (x) = 1;
2710:
2711: /* Perform error checking that did not get done in grokdeclarator. */
2712: if (TREE_CODE (x) == FIELD_DECL || TREE_CODE (x) == VAR_DECL)
2713: {
2714: if (TREE_CODE (TREE_TYPE (x)) == FUNCTION_TYPE)
2715: {
2716: cp_error ("field `%D' invalidly declared function type",
2717: x);
2718: TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
2719: }
2720: else if (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE)
2721: {
2722: cp_error ("field `%D' invalidly declared method type", x);
2723: TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
2724: }
2725: else if (TREE_CODE (TREE_TYPE (x)) == OFFSET_TYPE)
2726: {
2727: cp_error ("field `%D' invalidly declared offset type", x);
2728: TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
2729: }
2730: }
2731:
2732: if (TREE_CODE (x) == FIELD_DECL)
2733: {
2734: /* If the field has a bogus type, don't bother with it. */
2735: if (TREE_TYPE (x) != error_mark_node)
2736: {
2737: /* Never let anything with uninheritable virtuals
2738: make it through without complaint. */
2739: if (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
2740: && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (x)))
2741: abstract_virtuals_error (x, TREE_TYPE (x));
2742:
2743: if (TYPE_LANG_SPECIFIC (TREE_TYPE (x)))
2744: {
2745: /* It's possible that the type does have a default
2746: constructor, *and* have GETS_INIT_REF set, if
2747: the class has a non-const copy constructor. */
2748: if (TYPE_HAS_DEFAULT_CONSTRUCTOR (TREE_TYPE (x)))
2749: needs_default_ctor = 1;
2750: if (TYPE_GETS_INIT_REF (TREE_TYPE (x))
2751: && !TYPE_GETS_CONST_INIT_REF (TREE_TYPE (x)))
2752: cant_have_const_ctor = 1;
2753: }
2754: else if (DECL_INITIAL (x) == NULL_TREE
2755: && (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (x))
2756: || TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE))
2757: cant_have_default_ctor = 1;
2758: }
2759:
2760: /* If any field is const, the structure type is pseudo-const. */
2761: if (TREE_READONLY (x))
2762: {
2763: C_TYPE_FIELDS_READONLY (t) = 1;
2764: if (DECL_INITIAL (x) == NULL_TREE)
2765: const_sans_init = 1;
2766:
2767: /* ARM $12.6.2: [A member initializer list] is the only
2768: way to initialize a nonstatic const and reference
2769: [member]. */
2770: if (! TYPE_HAS_CONSTRUCTOR (t) && !TREE_STATIC (x))
2771: {
2772: if (DECL_NAME (x))
2773: cp_pedwarn_at ("non-static const member `%D' in class without a constructor", x);
2774: else
2775: cp_pedwarn_at ("non-static const member in class without a constructor", x);
2776: }
2777: }
2778: else
2779: {
2780: /* A field that is pseudo-const makes the structure likewise. */
2781: tree t1 = TREE_TYPE (x);
2782: while (TREE_CODE (t1) == ARRAY_TYPE)
2783: t1 = TREE_TYPE (t1);
2784: if (IS_AGGR_TYPE (t1))
2785: {
2786: if (C_TYPE_FIELDS_READONLY (t1))
2787: C_TYPE_FIELDS_READONLY (t) = 1;
2788: if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (t1))
2789: const_sans_init = 1;
2790: }
2791: }
2792: }
2793: else if (TREE_CODE (x) == VAR_DECL && TREE_CODE (t) == UNION_TYPE)
2794: /* Unions cannot have static members. */
2795: cp_error ("field `%D' declared static in union", x);
2796:
2797: if (! fields)
2798: fields = x;
2799: DECL_FIELD_CONTEXT (x) = t;
2800:
2801: /* We could be making an extern "C" function a friend. */
2802: if (TREE_CODE (x) == FUNCTION_DECL
2803: && DECL_LANG_SPECIFIC (x)
2804: && DECL_VIRTUAL_P (x))
2805: DECL_CLASS_CONTEXT (x) = t;
2806:
2807: DECL_FIELD_SIZE (x) = 0;
2808:
2809: /* We set DECL_BIT_FIELD tentatively in grokbitfield.
2810: If the type and width are valid, we'll keep it set.
2811: Otherwise, the flag is cleared. */
2812: if (DECL_BIT_FIELD (x))
2813: {
2814: DECL_BIT_FIELD (x) = 0;
2815: /* Invalid bit-field size done by grokfield. */
2816: /* Detect invalid bit-field type. */
2817: if (DECL_INITIAL (x)
2818: && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
2819: && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
2820: {
2821: cp_error ("bit-field `%D' has invalid type", x);
2822: DECL_INITIAL (x) = NULL;
2823: }
2824:
2825: /* Detect and ignore out of range field width. */
2826: if (DECL_INITIAL (x))
2827: {
2828: register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
2829:
2830: if (width < 0)
2831: {
2832: DECL_INITIAL (x) = NULL;
2833: cp_error ("negative width in bit-field `%D'", x);
2834: }
2835: else if (width == 0 && DECL_NAME (x) != 0)
2836: {
2837: DECL_INITIAL (x) = NULL;
2838: cp_error ("zero width for bit-field `%D'", x);
2839: }
2840: else if ((unsigned)width > TYPE_PRECISION (TREE_TYPE (x)))
2841: {
2842: DECL_INITIAL (x) = NULL;
2843: cp_error ("width of `%D' exceeds its type", x);
2844: }
2845: }
2846:
2847: /* Process valid field width. */
2848: if (DECL_INITIAL (x))
2849: {
2850: register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
2851:
2852: if (width == 0)
2853: {
2854: #ifdef EMPTY_FIELD_BOUNDARY
2855: /* field size 0 => mark following field as "aligned" */
2856: if (TREE_CHAIN (x))
2857: DECL_ALIGN (TREE_CHAIN (x))
2858: = MAX (DECL_ALIGN (TREE_CHAIN (x)), EMPTY_FIELD_BOUNDARY);
2859: /* field of size 0 at the end => round up the size. */
2860: else
2861: round_up_size = EMPTY_FIELD_BOUNDARY;
2862: #endif
2863: #ifdef PCC_BITFIELD_TYPE_MATTERS
2864: DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
2865: TYPE_ALIGN (TREE_TYPE (x)));
2866: #endif
2867: }
2868: else
2869: {
2870: DECL_INITIAL (x) = NULL_TREE;
2871: DECL_FIELD_SIZE (x) = width;
2872: DECL_BIT_FIELD (x) = 1;
2873: /* Traditionally a bit field is unsigned
2874: even if declared signed. */
2875: if (flag_traditional
2876: && TREE_CODE (TREE_TYPE (x)) == INTEGER_TYPE)
2877: TREE_TYPE (x) = unsigned_type_node;
2878: }
2879: }
2880: else
2881: /* Non-bit-fields are aligned for their type. */
2882: DECL_ALIGN (x) = MAX (DECL_ALIGN (x), TYPE_ALIGN (TREE_TYPE (x)));
2883: }
2884: else if (TREE_CODE (x) == FIELD_DECL)
2885: {
2886: tree type = TREE_TYPE (x);
2887: if (TREE_CODE (type) == ARRAY_TYPE)
2888: type = TREE_TYPE (type);
2889: if (code == UNION_TYPE && IS_AGGR_TYPE (type))
2890: {
2891: if (TYPE_NEEDS_CONSTRUCTING (type)
2892: || TYPE_NEEDS_DESTRUCTOR (type))
2893: cp_error ("member `%D' with constructor or destructor not allowed in union", x);
2894: TYPE_GETS_ASSIGNMENT (t) |= TYPE_GETS_ASSIGNMENT (type);
2895: TYPE_GETS_INIT_REF (t) |= TYPE_GETS_INIT_REF (type);
2896: }
2897: else if (code == RECORD_TYPE)
2898: {
2899: /* Array of record type doesn't matter for this bit. */
2900: TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2901: if (IS_AGGR_TYPE (type))
2902: {
2903: needs_ctor |= TYPE_NEEDS_CONSTRUCTOR (type);
2904: needs_dtor |= TYPE_NEEDS_DESTRUCTOR (type);
2905: members_need_dtors |= TYPE_NEEDS_DESTRUCTOR (type);
2906: TYPE_GETS_CONST_INIT_REF (t) |= TYPE_GETS_CONST_INIT_REF (type);
2907: TYPE_GETS_ASSIGNMENT (t) |= TYPE_GETS_ASSIGNMENT (type);
2908: TYPE_GETS_INIT_REF (t) |= TYPE_GETS_INIT_REF (type);
2909: }
2910: }
2911: if (DECL_INITIAL (x) != NULL_TREE)
2912: {
2913: /* `build_class_init_list' does not recognize non-FIELD_DECLs. */
2914: if (code == UNION_TYPE && any_default_members != 0)
2915: error ("multiple fields in union initialized");
2916: any_default_members = 1;
2917: }
2918: }
2919: last_x = x;
2920: }
2921: list_of_fieldlists = TREE_CHAIN (list_of_fieldlists);
2922: /* link the tail while we have it! */
2923: if (last_x)
2924: {
2925: TREE_CHAIN (last_x) = NULL_TREE;
2926:
2927: if (list_of_fieldlists
2928: && TREE_VALUE (list_of_fieldlists)
2929: && TREE_CODE (TREE_VALUE (list_of_fieldlists)) != FUNCTION_DECL)
2930: TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
2931: }
2932: }
2933:
2934: if (tail) TREE_CHAIN (tail) = NULL_TREE;
2935:
2936: /* If this type has any constant members which did not come
2937: with their own initialization, mark that fact here. It is
2938: not an error here, since such types can be saved either by their
2939: constructors, or by fortuitous initialization. */
2940: CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) = const_sans_init;
2941: CLASSTYPE_REF_FIELDS_NEED_INIT (t) = ref_sans_init;
2942: CLASSTYPE_ABSTRACT_VIRTUALS (t) = abstract_virtuals;
2943:
2944: if (members_need_dtors && !TYPE_HAS_DESTRUCTOR (t))
2945: {
2946: /* Here we must cons up a destructor on the fly. */
2947: tree dtor = cons_up_default_function (t, name, fields,
2948: needs_virtual_dtor != 0);
2949:
2950: /* If we couldn't make it work, then pretend we didn't need it. */
2951: if (dtor == void_type_node)
2952: TYPE_NEEDS_DESTRUCTOR (t) = 0;
2953: else
2954: {
2955: if (! fn_fields)
2956: fn_fields = dtor;
2957: else
2958: TREE_CHAIN (tail) = dtor;
2959: tail = dtor;
2960:
2961: if (DECL_VINDEX (dtor) == NULL_TREE
2962: && ! CLASSTYPE_DECLARED_EXCEPTION (t)
2963: && (needs_virtual_dtor
2964: || pending_virtuals != NULL_TREE
2965: || pending_hard_virtuals != NULL_TREE))
2966: DECL_VINDEX (dtor) = error_mark_node;
2967: if (DECL_VINDEX (dtor))
2968: pending_virtuals = add_virtual_function (pending_virtuals,
2969: &has_virtual, dtor, NULL_TREE);
2970: nonprivate_method = 1;
2971: TYPE_HAS_DESTRUCTOR (t) = 1;
2972: }
2973: }
2974:
2975: /* Create default constructor, if needed. */
2976:
2977: /* ARM $12.1: A default constructor will be generated for a class X
2978: only if no constructor has been declared for class X. So we
2979: check TYPE_HAS_CONSTRUCTOR also, to make sure we don't generate
2980: one if they declared a constructor in this class. */
2981: if (! TYPE_HAS_DEFAULT_CONSTRUCTOR (t)
2982: && ! TYPE_HAS_CONSTRUCTOR (t)
2983: #ifdef OBJCPLUS
2984: && !is_class_name (name)
2985: #endif
2986: && needs_default_ctor && ! cant_have_default_ctor)
2987: {
2988: tree default_fn = cons_up_default_function (t, name, fields, 2);
2989: TREE_CHAIN (default_fn) = fn_fields;
2990: fn_fields = default_fn;
2991: TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1;
2992: nonprivate_method = 1;
2993: }
2994:
2995: /* Create default copy constructor, if needed. Don't do it for
2996: the exception handler. */
2997: if ((TYPE_NEEDS_CONSTRUCTOR (t) || TYPE_HAS_CONSTRUCTOR (t) || needs_ctor)
2998: #ifdef OBJCPLUS
2999: && ! is_class_name (name)
3000: #endif
3001: && ! TYPE_HAS_INIT_REF (t) && t != EHS_type)
3002: {
3003: /* ARM 12.18: You get either X(X&) or X(const X&), but
3004: not both. --Chip */
3005: tree default_fn =
3006: cons_up_default_function (t, name, fields,
3007: cant_have_const_ctor ? 4 : 3);
3008: TREE_CHAIN (default_fn) = fn_fields;
3009: fn_fields = default_fn;
3010: TYPE_HAS_INIT_REF (t) = 1;
3011: nonprivate_method = 1;
3012: }
3013:
3014: if (fn_fields)
3015: {
3016: method_vec = finish_struct_methods (t, fn_fields, nonprivate_method);
3017:
3018: if (TYPE_HAS_CONSTRUCTOR (t)
3019: && ! CLASSTYPE_DECLARED_EXCEPTION (t)
3020: && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
3021: && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
3022: {
3023: int nonprivate_ctor = 0;
3024: tree ctor;
3025:
3026: for (ctor = TREE_VEC_ELT (method_vec, 0);
3027: ctor;
3028: ctor = DECL_CHAIN (ctor))
3029: if (! TREE_PRIVATE (ctor))
3030: {
3031: nonprivate_ctor = 1;
3032: break;
3033: }
3034:
3035: if (nonprivate_ctor == 0 && warn_ctor_dtor_privacy)
3036: warning ("class `%s' only defines private constructors and has no friends",
3037: err_name);
3038: }
3039: }
3040: else
3041: {
3042: method_vec = 0;
3043:
3044: /* Just in case these got accidentally
3045: filled in by syntax errors. */
3046: TYPE_HAS_CONSTRUCTOR (t) = 0;
3047: TYPE_HAS_DESTRUCTOR (t) = 0;
3048: }
3049:
3050: if (vfield == NULL_TREE && has_virtual)
3051: {
3052: /* We build this decl with ptr_type_node, and
3053: change the type when we know what it should be. */
3054: vfield = build_lang_field_decl (FIELD_DECL, get_vfield_name (t),
3055: ptr_type_node);
3056: /* If you change any of the below, take a look at all the
3057: other VFIELD_BASEs and VTABLE_BASEs in the code, and change
3058: them too. */
3059: DECL_ASSEMBLER_NAME (vfield) = get_identifier (VFIELD_BASE);
3060: CLASSTYPE_VFIELD (t) = vfield;
3061: DECL_VIRTUAL_P (vfield) = 1;
3062: DECL_FIELD_CONTEXT (vfield) = t;
3063: DECL_CLASS_CONTEXT (vfield) = t;
3064: DECL_FCONTEXT (vfield) = t;
3065: DECL_FIELD_SIZE (vfield) = 0;
3066: DECL_ALIGN (vfield) = TYPE_ALIGN (ptr_type_node);
3067: if (CLASSTYPE_DOSSIER (t))
3068: {
3069: /* vfield is always first entry in structure. */
3070: TREE_CHAIN (vfield) = fields;
3071: fields = vfield;
3072: }
3073: else if (last_x)
3074: {
3075: my_friendly_assert (TREE_CHAIN (last_x) == 0, 175);
3076: TREE_CHAIN (last_x) = vfield;
3077: last_x = vfield;
3078: }
3079: else
3080: fields = vfield;
3081: vfields = chainon (vfields, CLASSTYPE_AS_LIST (t));
3082: }
3083:
3084: /* Now DECL_INITIAL is null on all members except for zero-width bit-fields.
3085: And they have already done their work.
3086:
3087: C++: maybe we will support default field initialization some day... */
3088:
3089: /* Delete all zero-width bit-fields from the front of the fieldlist */
3090: while (fields && DECL_BIT_FIELD (fields)
3091: && DECL_INITIAL (fields))
3092: fields = TREE_CHAIN (fields);
3093: /* Delete all such fields from the rest of the fields. */
3094: for (x = fields; x;)
3095: {
3096: if (TREE_CHAIN (x) && DECL_BIT_FIELD (TREE_CHAIN (x))
3097: && DECL_INITIAL (TREE_CHAIN (x)))
3098: TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
3099: else
3100: x = TREE_CHAIN (x);
3101: }
3102: /* Delete all duplicate fields from the fields */
3103: delete_duplicate_fields (fields);
3104:
3105: /* Now we have the final fieldlist for the data fields. Record it,
3106: then lay out the structure or union (including the fields). */
3107:
3108: TYPE_FIELDS (t) = fields;
3109:
3110: /* If there's a :0 field at the end, round the size to the
3111: EMPTY_FIELD_BOUNDARY. */
3112: TYPE_ALIGN (t) = round_up_size;
3113:
3114: /* Pass layout information about base classes to layout_type, if any. */
3115:
3116: {
3117: tree field;
3118: for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3119: {
3120: if (TREE_STATIC (field))
3121: continue;
3122: if (TREE_CODE (field) != FIELD_DECL)
3123: continue;
3124:
3125: /* If this field is an anonymous union,
3126: give each union-member the same position as the union has.
3127:
3128: ??? This is a real kludge because it makes the structure
3129: of the types look strange. This feature is only used by
3130: C++, which should have build_component_ref build two
3131: COMPONENT_REF operations, one for the union and one for
3132: the inner field. We set the offset of this field to zero
3133: so that either the old or the correct method will work.
3134: Setting DECL_FIELD_CONTEXT is wrong unless the inner fields are
3135: moved into the type of this field, but nothing seems to break
3136: by doing this. */
3137:
3138: if (DECL_NAME (field) == 0
3139: && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
3140: {
3141: tree uelt = TYPE_FIELDS (TREE_TYPE (field));
3142: for (; uelt; uelt = TREE_CHAIN (uelt))
3143: {
3144: DECL_FIELD_CONTEXT (uelt) = DECL_FIELD_CONTEXT (field);
3145: DECL_FIELD_BITPOS (uelt) = DECL_FIELD_BITPOS (field);
3146: }
3147:
3148: DECL_FIELD_BITPOS (field) = integer_zero_node;
3149: }
3150: }
3151: }
3152:
3153: if (n_baseclasses)
3154: {
3155: tree pseudo_basetype = TREE_TYPE (base_layout_decl);
3156:
3157: TREE_CHAIN (base_layout_decl) = TYPE_FIELDS (t);
3158: TYPE_FIELDS (t) = base_layout_decl;
3159:
3160: TYPE_SIZE (pseudo_basetype) = CLASSTYPE_SIZE (t);
3161: TYPE_MODE (pseudo_basetype) = TYPE_MODE (t);
3162: TYPE_ALIGN (pseudo_basetype) = CLASSTYPE_ALIGN (t);
3163: DECL_ALIGN (base_layout_decl) = TYPE_ALIGN (pseudo_basetype);
3164: /* Don't re-use old size. */
3165: DECL_SIZE (base_layout_decl) = 0;
3166: }
3167:
3168: layout_type (t);
3169:
3170: {
3171: tree field;
3172: for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3173: {
3174: if (TREE_STATIC (field))
3175: continue;
3176: if (TREE_CODE (field) != FIELD_DECL)
3177: continue;
3178:
3179: /* If this field is an anonymous union,
3180: give each union-member the same position as the union has.
3181:
3182: ??? This is a real kludge because it makes the structure
3183: of the types look strange. This feature is only used by
3184: C++, which should have build_component_ref build two
3185: COMPONENT_REF operations, one for the union and one for
3186: the inner field. We set the offset of this field to zero
3187: so that either the old or the correct method will work.
3188: Setting DECL_FIELD_CONTEXT is wrong unless the inner fields are
3189: moved into the type of this field, but nothing seems to break
3190: by doing this. */
3191:
3192: if (DECL_NAME (field) == 0
3193: && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
3194: {
3195: tree uelt = TYPE_FIELDS (TREE_TYPE (field));
3196: for (; uelt; uelt = TREE_CHAIN (uelt))
3197: {
3198: DECL_FIELD_CONTEXT (uelt) = DECL_FIELD_CONTEXT (field);
3199: DECL_FIELD_BITPOS (uelt) = DECL_FIELD_BITPOS (field);
3200: }
3201:
3202: DECL_FIELD_BITPOS (field) = integer_zero_node;
3203: }
3204: }
3205: }
3206:
3207: if (n_baseclasses)
3208: TYPE_FIELDS (t) = TREE_CHAIN (TYPE_FIELDS (t));
3209:
3210: /* C++: do not let empty structures exist. */
3211: if (integer_zerop (TYPE_SIZE (t)))
3212: TYPE_SIZE (t) = TYPE_SIZE (char_type_node);
3213:
3214: /* Set the TYPE_DECL for this type to contain the right
3215: value for DECL_OFFSET, so that we can use it as part
3216: of a COMPONENT_REF for multiple inheritance. */
3217:
3218: if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
3219: layout_decl (TYPE_NAME (t), 0);
3220:
3221: /* Now fix up any virtual base class types that we
3222: left lying around. We must get these done
3223: before we try to lay out the virtual function table. */
3224: doing_hard_virtuals = 1;
3225: pending_hard_virtuals = nreverse (pending_hard_virtuals);
3226:
3227: if (TYPE_USES_VIRTUAL_BASECLASSES (t))
3228: {
3229: tree vbases;
3230:
3231: max_has_virtual = layout_vbasetypes (t, max_has_virtual);
3232: vbases = CLASSTYPE_VBASECLASSES (t);
3233: CLASSTYPE_N_VBASECLASSES (t) = list_length (vbases);
3234:
3235: /* This loop makes all the entries in the virtual function tables
3236: of interest contain the "latest" version of the functions
3237: we have defined. */
3238:
3239: while (vbases)
3240: {
3241: tree virtuals = BINFO_VIRTUALS (vbases);
3242:
3243: if (virtuals)
3244: {
3245: /* Get past the `null' vtable entry... */
3246: virtuals = TREE_CHAIN (virtuals);
3247: /* and the `dossier' vtable entry if we're doing dossiers. */
3248: if (flag_dossier)
3249: virtuals = TREE_CHAIN (virtuals);
3250: }
3251:
3252: while (virtuals != NULL_TREE)
3253: {
3254: tree pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals));
3255: tree base_fndecl = TREE_OPERAND (pfn, 0);
3256: tree decl = get_first_matching_virtual (TYPE_BINFO (t), base_fndecl,
3257: DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl)));
3258: tree context = DECL_CLASS_CONTEXT (decl);
3259: if (decl != base_fndecl && context != t)
3260: {
3261: tree base_context = DECL_CLASS_CONTEXT (base_fndecl);
3262: tree binfo = NULL_TREE, these_virtuals;
3263: #if 0
3264: unsigned HOST_WIDE_INT i
3265: = (TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl))
3266: & (((unsigned HOST_WIDE_INT)1<<(BITS_PER_WORD-1))-1));
3267: #endif
3268:
3269: if (TYPE_USES_VIRTUAL_BASECLASSES (context))
3270: binfo = virtual_member (base_context,
3271: CLASSTYPE_VBASECLASSES (context));
3272: if (binfo == NULL_TREE)
3273: binfo = binfo_value (base_context, context);
3274: if (binfo != NULL_TREE)
3275: {
3276: #if 1
3277: pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (get_vtable_entry (BINFO_VIRTUALS (binfo), base_fndecl)));
3278: #else
3279: these_virtuals = BINFO_VIRTUALS (binfo);
3280:
3281: while (i-- > 0)
3282: these_virtuals = TREE_CHAIN (these_virtuals);
3283: pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (these_virtuals));
3284: #endif
3285: modify_vtable_entries (t, decl, base_fndecl, pfn);
3286: }
3287: }
3288: virtuals = TREE_CHAIN (virtuals);
3289: }
3290: /* Update dossier info with offsets for virtual baseclasses. */
3291: if (flag_dossier && ! BINFO_NEW_VTABLE_MARKED (vbases))
3292: prepare_fresh_vtable (vbases, vbases, t);
3293:
3294: vbases = TREE_CHAIN (vbases);
3295: }
3296: }
3297:
3298: while (pending_hard_virtuals)
3299: {
3300: /* Need an entry in some other virtual function table. */
3301: if (TREE_TYPE (pending_hard_virtuals))
3302: {
3303: /* This is how we modify entries when a vfn's index changes
3304: between derived and base type. */
3305: modify_vtable_entries (t, TREE_PURPOSE (pending_hard_virtuals),
3306: TREE_TYPE (pending_hard_virtuals),
3307: TREE_VALUE (pending_hard_virtuals));
3308: }
3309: else
3310: {
3311: /* This is how we modify entries when a vfn comes from
3312: a virtual baseclass. */
3313: tree base_fndecls = DECL_VINDEX (TREE_PURPOSE (pending_hard_virtuals));
3314: my_friendly_assert (base_fndecls != error_mark_node, 176);
3315: while (base_fndecls)
3316: {
3317: modify_vtable_entries (t, TREE_PURPOSE (pending_hard_virtuals),
3318: TREE_VALUE (base_fndecls),
3319: TREE_VALUE (pending_hard_virtuals));
3320: base_fndecls = TREE_CHAIN (base_fndecls);
3321: }
3322: }
3323: pending_hard_virtuals = TREE_CHAIN (pending_hard_virtuals);
3324: }
3325: doing_hard_virtuals = 0;
3326:
3327: /* Under our model of GC, every C++ class gets its own virtual
3328: function table, at least virtually. */
3329: if (pending_virtuals || CLASSTYPE_DOSSIER (t))
3330: {
3331: pending_virtuals = nreverse (pending_virtuals);
3332: /* We must enter these virtuals into the table. */
3333: if (first_vfn_base_index < 0)
3334: {
3335: if (flag_dossier)
3336: pending_virtuals = tree_cons (NULL_TREE,
3337: build_vtable_entry (integer_zero_node,
3338: build_t_desc (t, 0)),
3339: pending_virtuals);
3340: pending_virtuals = tree_cons (NULL_TREE, the_null_vtable_entry,
3341: pending_virtuals);
3342: build_vtable (NULL_TREE, t);
3343: }
3344: else
3345: {
3346: /* Here we know enough to change the type of our virtual
3347: function table, but we will wait until later this function. */
3348:
3349: if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
3350: build_vtable (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index), t);
3351:
3352: /* Update the dossier pointer for this class. */
3353: if (flag_dossier)
3354: TREE_VALUE (TREE_CHAIN (TYPE_BINFO_VIRTUALS (t)))
3355: = build_vtable_entry (integer_zero_node, build_t_desc (t, 0));
3356: }
3357:
3358: /* If this type has basetypes with constructors, then those
3359: constructors might clobber the virtual function table. But
3360: they don't if the derived class shares the exact vtable of the base
3361: class. */
3362:
3363: CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
3364: }
3365: else if (first_vfn_base_index >= 0)
3366: {
3367: tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index);
3368: #if 0
3369: /* For testing. */
3370: tree binfo1 = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
3371: if (binfo != binfo1)
3372: warning ("binfos are different in vtable creation");
3373: #endif
3374:
3375: /* This class contributes nothing new to the virtual function
3376: table. However, it may have declared functions which
3377: went into the virtual function table "inherited" from the
3378: base class. If so, we grab a copy of those updated functions,
3379: and pretend they are ours. */
3380:
3381: /* See if we should steal the virtual info from base class. */
3382: if (TYPE_BINFO_VTABLE (t) == NULL_TREE)
3383: TYPE_BINFO_VTABLE (t) = BINFO_VTABLE (binfo);
3384: if (TYPE_BINFO_VIRTUALS (t) == NULL_TREE)
3385: TYPE_BINFO_VIRTUALS (t) = BINFO_VIRTUALS (binfo);
3386: if (TYPE_BINFO_VTABLE (t) != BINFO_VTABLE (binfo))
3387: CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
3388: }
3389:
3390: if (has_virtual > max_has_virtual)
3391: max_has_virtual = has_virtual;
3392: if (max_has_virtual || first_vfn_base_index >= 0)
3393: {
3394: #ifdef VTABLE_USES_MASK
3395: if (max_has_virtual >= VINDEX_MAX)
3396: {
3397: error ("too many virtual functions for class `%s' (VINDEX_MAX < %d)",
3398: err_name, has_virtual);
3399: }
3400: #endif
3401: TYPE_VIRTUAL_P (t) = 1;
3402: CLASSTYPE_VSIZE (t) = has_virtual;
3403: if (first_vfn_base_index >= 0)
3404: {
3405: if (pending_virtuals)
3406: TYPE_BINFO_VIRTUALS (t) = chainon (TYPE_BINFO_VIRTUALS (t),
3407: pending_virtuals);
3408: }
3409: else if (has_virtual)
3410: {
3411: TYPE_BINFO_VIRTUALS (t) = pending_virtuals;
3412: if (write_virtuals >= 0)
3413: DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)) = 1;
3414: }
3415: }
3416:
3417: /* Now lay out the virtual function table. */
3418: if (has_virtual)
3419: {
3420: tree atype, itype;
3421:
3422: if (TREE_TYPE (vfield) == ptr_type_node)
3423: {
3424: /* We must create a pointer to this table because
3425: the one inherited from base class does not exist.
3426: We will fill in the type when we know what it
3427: should really be. Use `size_int' so values are memoized
3428: in common cases. */
3429: itype = build_index_type (size_int (has_virtual));
3430: atype = build_array_type (vtable_entry_type, itype);
3431: layout_type (atype);
3432: TREE_TYPE (vfield) = build_pointer_type (atype);
3433: }
3434: else
3435: {
3436: atype = TREE_TYPE (TREE_TYPE (vfield));
3437:
3438: if (has_virtual != TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (atype))))
3439: {
3440: /* We must extend (or create) the boundaries on this array,
3441: because we picked up virtual functions from multiple
3442: base classes. */
3443: itype = build_index_type (size_int (has_virtual));
3444: atype = build_array_type (vtable_entry_type, itype);
3445: layout_type (atype);
3446: vfield = copy_node (vfield);
3447: TREE_TYPE (vfield) = build_pointer_type (atype);
3448: }
3449: }
3450:
3451: CLASSTYPE_VFIELD (t) = vfield;
3452: if (TREE_TYPE (TYPE_BINFO_VTABLE (t)) != atype)
3453: {
3454: TREE_TYPE (TYPE_BINFO_VTABLE (t)) = atype;
3455: layout_decl (TYPE_BINFO_VTABLE (t), 0);
3456: /* At one time the vtable info was grabbed 2 words at a time. This
3457: fails on sparc unless you have 8-byte alignment. (tiemann) */
3458: DECL_ALIGN (TYPE_BINFO_VTABLE (t))
3459: = MAX (TYPE_ALIGN (double_type_node),
3460: DECL_ALIGN (TYPE_BINFO_VTABLE (t)));
3461: }
3462: }
3463: else if (first_vfn_base_index >= 0)
3464: CLASSTYPE_VFIELD (t) = vfield;
3465: CLASSTYPE_VFIELDS (t) = vfields;
3466:
3467: /* Set all appropriate CLASSTYPE_... flags for this type
3468: and its variants. */
3469: TYPE_NEEDS_CONSTRUCTOR (t) |= needs_ctor || TYPE_HAS_CONSTRUCTOR (t);
3470: TYPE_NEEDS_CONSTRUCTING (t)
3471: |= ((TYPE_NEEDS_CONSTRUCTOR (t)|TYPE_USES_VIRTUAL_BASECLASSES (t))
3472: || has_virtual || any_default_members
3473: || first_vfn_base_index >= 0);
3474: TYPE_NEEDS_DESTRUCTOR (t) |= needs_dtor || TYPE_HAS_DESTRUCTOR (t);
3475: finish_struct_bits (t, max_has_virtual);
3476:
3477: /* Promote each bit-field's type to int if it is narrower than that.
3478: There's more: complete the rtl for any static member objects which
3479: is of the same type we're working on. */
3480: for (x = fields; x; x = TREE_CHAIN (x))
3481: {
3482: if (DECL_BIT_FIELD (x)
3483: && (C_PROMOTING_INTEGER_TYPE_P (TREE_TYPE (x))
3484: || DECL_FIELD_SIZE (x) < TYPE_PRECISION (integer_type_node)))
3485: {
3486: tree type = TREE_TYPE (x);
3487:
3488: /* Preserve unsignedness if traditional or if not really getting
3489: any wider. */
3490: if (TREE_UNSIGNED (type)
3491: && (flag_traditional
3492: ||
3493: (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
3494: && DECL_FIELD_SIZE (x) == TYPE_PRECISION (integer_type_node))))
3495: TREE_TYPE (x) = unsigned_type_node;
3496: else
3497: TREE_TYPE (x) = integer_type_node;
3498: }
3499:
3500: if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
3501: && TREE_TYPE (x) == t)
3502: {
3503: DECL_MODE (x) = TYPE_MODE (t);
3504: make_decl_rtl (x, NULL, 0);
3505: }
3506: }
3507:
3508: /* Now add the tags, if any, to the list of TYPE_DECLs
3509: defined for this type. */
3510: if (CLASSTYPE_TAGS (t))
3511: {
3512: x = CLASSTYPE_TAGS (t);
3513: last_x = tree_last (TYPE_FIELDS (t));
3514: while (x)
3515: {
3516: tree tag = build_lang_decl (TYPE_DECL, TREE_PURPOSE (x), TREE_VALUE (x));
3517: #ifdef DWARF_DEBUGGING_INFO
3518: if (write_symbols == DWARF_DEBUG)
3519: {
3520: /* Notify dwarfout.c that this TYPE_DECL node represent a
3521: gratuitous typedef. */
3522: DECL_IGNORED_P (tag) = 1;
3523: }
3524: #endif /* DWARF_DEBUGGING_INFO */
3525: DECL_CONTEXT (tag) = t;
3526: DECL_CLASS_CONTEXT (tag) = t;
3527: x = TREE_CHAIN (x);
3528: last_x = chainon (last_x, tag);
3529: }
3530: if (TYPE_FIELDS (t) == 0)
3531: TYPE_FIELDS (t) = last_x;
3532: CLASSTYPE_LOCAL_TYPEDECLS (t) = 1;
3533: }
3534:
3535: if (TYPE_HAS_CONSTRUCTOR (t))
3536: {
3537: tree vfields = CLASSTYPE_VFIELDS (t);
3538:
3539: while (vfields)
3540: {
3541: /* Mark the fact that constructor for T
3542: could affect anybody inheriting from T
3543: who wants to initialize vtables for VFIELDS's type. */
3544: if (VF_DERIVED_VALUE (vfields))
3545: TREE_ADDRESSABLE (vfields) = 1;
3546: vfields = TREE_CHAIN (vfields);
3547: }
3548: if (any_default_members != 0)
3549: build_class_init_list (t);
3550: }
3551: else if (TYPE_NEEDS_CONSTRUCTING (t))
3552: build_class_init_list (t);
3553:
3554: if (current_lang_name == lang_name_cplusplus)
3555: {
3556: if (! CLASSTYPE_DECLARED_EXCEPTION (t))
3557: embrace_waiting_friends (t);
3558:
3559: /* Write out inline function definitions. */
3560: do_inline_function_hair (t, CLASSTYPE_INLINE_FRIENDS (t));
3561: CLASSTYPE_INLINE_FRIENDS (t) = 0;
3562: }
3563:
3564: if (CLASSTYPE_VSIZE (t) != 0)
3565: {
3566: if ((flag_this_is_variable & 1) == 0)
3567: {
3568: tree vtbl_ptr = build_decl (VAR_DECL, get_identifier (VPTR_NAME),
3569: TREE_TYPE (vfield));
3570: DECL_REGISTER (vtbl_ptr) = 1;
3571: CLASSTYPE_VTBL_PTR (t) = vtbl_ptr;
3572: }
3573: if (DECL_FIELD_CONTEXT (vfield) != t)
3574: {
3575: tree binfo = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
3576: tree offset = BINFO_OFFSET (binfo);
3577:
3578: vfield = copy_node (vfield);
3579: copy_lang_decl (vfield);
3580:
3581: if (! integer_zerop (offset))
3582: offset = size_binop (MULT_EXPR, offset, size_int (BITS_PER_UNIT));
3583: DECL_FIELD_CONTEXT (vfield) = t;
3584: DECL_CLASS_CONTEXT (vfield) = t;
3585: DECL_FIELD_BITPOS (vfield)
3586: = size_binop (PLUS_EXPR, offset, DECL_FIELD_BITPOS (vfield));
3587: CLASSTYPE_VFIELD (t) = vfield;
3588: }
3589:
3590: /* In addition to this one, all the other vfields should be listed. */
3591: /* Before that can be done, we have to have FIELD_DECLs for them, and
3592: a place to find them. */
3593: TYPE_NONCOPIED_PARTS (t) = build_tree_list (default_conversion (TYPE_BINFO_VTABLE (t)), vfield);
3594:
3595: if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (t)
3596: && DECL_VINDEX (TREE_VEC_ELT (method_vec, 0)) == NULL_TREE)
3597: warning ("class `%s' has virtual functions but non-virtual destructor",
3598: err_name);
3599: }
3600:
3601: /* Make the rtl for any new vtables we have created, and unmark
3602: the base types we marked. */
3603: unmark_finished_struct (t);
3604: TYPE_BEING_DEFINED (t) = 0;
3605:
3606: if (flag_dossier && CLASSTYPE_VTABLE_NEEDS_WRITING (t))
3607: {
3608: tree variants;
3609: tree tdecl;
3610:
3611: /* Now instantiate its type descriptors. */
3612: tdecl = TREE_OPERAND (build_t_desc (t, 1), 0);
3613: variants = TYPE_POINTER_TO (t);
3614: build_type_variant (variants, 1, 0);
3615: while (variants)
3616: {
3617: build_t_desc (variants, 1);
3618: variants = TYPE_NEXT_VARIANT (variants);
3619: }
3620: variants = build_reference_type (t);
3621: build_type_variant (variants, 1, 0);
3622: while (variants)
3623: {
3624: build_t_desc (variants, 1);
3625: variants = TYPE_NEXT_VARIANT (variants);
3626: }
3627: #if 0
3628: DECL_VPARENT (tdecl) = t;
3629: #endif
3630: DECL_CONTEXT (tdecl) = t;
3631: }
3632: /* Still need to instantiate this C struct's type descriptor. */
3633: else if (flag_dossier && ! CLASSTYPE_DOSSIER (t))
3634: build_t_desc (t, 1);
3635:
3636: if (TYPE_NAME (t) && TYPE_IDENTIFIER (t))
3637: undo_template_name_overload (TYPE_IDENTIFIER (t), 1);
3638: if (current_class_type)
3639: popclass (0);
3640: else
3641: #ifdef OBJCPLUS
3642: if (!doing_objc_thang)
3643: #endif
3644: error ("trying to finish struct, but kicked out due to previous parse errors.");
3645:
3646: hack_incomplete_structures (t);
3647:
3648: resume_momentary (old);
3649:
3650: if (flag_cadillac)
3651: cadillac_finish_struct (t);
3652:
3653: #if 0
3654: /* This has to be done after we have sorted out what to do with
3655: the enclosing type. */
3656: if (write_symbols != DWARF_DEBUG)
3657: {
3658: /* Be smarter about nested classes here. If a type is nested,
3659: only output it if we would output the enclosing type. */
3660: if (DECL_CONTEXT (TYPE_NAME (t))
3661: && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (TYPE_NAME (t)))) == 't')
3662: DECL_IGNORED_P (TYPE_NAME (t)) = TREE_ASM_WRITTEN (TYPE_NAME (t));
3663: }
3664: #endif
3665:
3666: if (write_symbols != DWARF_DEBUG)
3667: {
3668: /* If the type has methods, we want to think about cutting down
3669: the amount of symbol table stuff we output. The value stored in
3670: the TYPE_DECL's DECL_IGNORED_P slot is a first approximation.
3671: For example, if a member function is seen and we decide to
3672: write out that member function, then we can change the value
3673: of the DECL_IGNORED_P slot, and the type will be output when
3674: that member function's debug info is written out. */
3675: if (CLASSTYPE_METHOD_VEC (t))
3676: {
3677: extern tree pending_vtables;
3678:
3679: /* Don't output full info about any type
3680: which does not have its implementation defined here. */
3681: if (TYPE_VIRTUAL_P (t) && write_virtuals == 2)
3682: DECL_IGNORED_P (TYPE_NAME (t))
3683: = (value_member (TYPE_IDENTIFIER (t), pending_vtables) == 0);
3684: else if (CLASSTYPE_INTERFACE_ONLY (t))
3685: DECL_IGNORED_P (TYPE_NAME (t)) = 1;
3686: else if (CLASSTYPE_INTERFACE_UNKNOWN (t))
3687: /* Only a first approximation! */
3688: DECL_IGNORED_P (TYPE_NAME (t)) = 1;
3689: }
3690: else if (CLASSTYPE_INTERFACE_ONLY (t))
3691: DECL_IGNORED_P (TYPE_NAME (t)) = 1;
3692: }
3693:
3694: /* Finish debugging output for this type. */
3695: rest_of_type_compilation (t, global_bindings_p ());
3696:
3697: return t;
3698: }
3699:
3700: /* Return non-zero if the effective type of INSTANCE is static.
3701: Used to determine whether the virtual function table is needed
3702: or not.
3703:
3704: *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
3705: of our knowledge of its type. */
3706: int
3707: resolves_to_fixed_type_p (instance, nonnull)
3708: tree instance;
3709: int *nonnull;
3710: {
3711: switch (TREE_CODE (instance))
3712: {
3713: case INDIRECT_REF:
3714: /* Check that we are not going through a cast of some sort. */
3715: if (TREE_TYPE (instance)
3716: == TREE_TYPE (TREE_TYPE (TREE_OPERAND (instance, 0))))
3717: instance = TREE_OPERAND (instance, 0);
3718: /* fall through... */
3719: case CALL_EXPR:
3720: /* This is a call to a constructor, hence it's never zero. */
3721: if (TREE_HAS_CONSTRUCTOR (instance))
3722: {
3723: if (nonnull)
3724: *nonnull = 1;
3725: return 1;
3726: }
3727: return 0;
3728:
3729: case SAVE_EXPR:
3730: /* This is a call to a constructor, hence it's never zero. */
3731: if (TREE_HAS_CONSTRUCTOR (instance))
3732: {
3733: if (nonnull)
3734: *nonnull = 1;
3735: return 1;
3736: }
3737: return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
3738:
3739: case RTL_EXPR:
3740: /* This is a call to `new', hence it's never zero. */
3741: if (TREE_CALLS_NEW (instance))
3742: {
3743: if (nonnull)
3744: *nonnull = 1;
3745: return 1;
3746: }
3747: return 0;
3748:
3749: case PLUS_EXPR:
3750: case MINUS_EXPR:
3751: if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
3752: /* Propagate nonnull. */
3753: resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
3754: if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
3755: return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
3756: return 0;
3757:
3758: case NOP_EXPR:
3759: case CONVERT_EXPR:
3760: return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
3761:
3762: case ADDR_EXPR:
3763: if (nonnull)
3764: *nonnull = 1;
3765: return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
3766:
3767: case COMPONENT_REF:
3768: return resolves_to_fixed_type_p (TREE_OPERAND (instance, 1), nonnull);
3769:
3770: case WITH_CLEANUP_EXPR:
3771: if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
3772: return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
3773: /* fall through... */
3774: case VAR_DECL:
3775: case FIELD_DECL:
3776: if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
3777: && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
3778: {
3779: if (nonnull)
3780: *nonnull = 1;
3781: return 1;
3782: }
3783: /* fall through... */
3784: case TARGET_EXPR:
3785: case PARM_DECL:
3786: if (IS_AGGR_TYPE (TREE_TYPE (instance)))
3787: {
3788: if (nonnull)
3789: *nonnull = 1;
3790: return 1;
3791: }
3792: else if (nonnull)
3793: {
3794: if (instance == current_class_decl
3795: && flag_this_is_variable <= 0)
3796: {
3797: /* Some people still use `this = 0' inside destructors. */
3798: *nonnull = ! DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (current_function_decl));
3799: /* In a constructor, we know our type. */
3800: if (flag_this_is_variable < 0)
3801: return 1;
3802: }
3803: else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
3804: /* Reference variables should be references to objects. */
3805: *nonnull = 1;
3806: }
3807: return 0;
3808:
3809: default:
3810: return 0;
3811: }
3812: }
3813:
3814: void
3815: init_class_processing ()
3816: {
3817: current_class_depth = 0;
3818: current_class_stacksize = 10;
3819: current_class_base = (tree *)xmalloc(current_class_stacksize * sizeof (tree));
3820: current_class_stack = current_class_base;
3821:
3822: current_lang_stacksize = 10;
3823: current_lang_base = (tree *)xmalloc(current_lang_stacksize * sizeof (tree));
3824: current_lang_stack = current_lang_base;
3825:
3826: /* Keep these values lying around. */
3827: the_null_vtable_entry = build_vtable_entry (integer_zero_node, integer_zero_node);
3828: base_layout_decl = build_lang_field_decl (FIELD_DECL, NULL_TREE, error_mark_node);
3829: TREE_TYPE (base_layout_decl) = make_node (RECORD_TYPE);
3830:
3831: gcc_obstack_init (&class_obstack);
3832: }
3833:
3834: /* Set current scope to NAME. CODE tells us if this is a
3835: STRUCT, UNION, or ENUM environment.
3836:
3837: NAME may end up being NULL_TREE if this is an anonymous or
3838: late-bound struct (as in "struct { ... } foo;") */
3839:
3840: /* Here's a subroutine we need because C lacks lambdas. */
3841: static void
3842: unuse_fields (type)
3843: tree type;
3844: {
3845: tree fields;
3846:
3847: for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
3848: {
3849: if (TREE_CODE (fields) != FIELD_DECL)
3850: continue;
3851:
3852: TREE_USED (fields) = 0;
3853: if (DECL_NAME (fields) == NULL_TREE
3854: && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
3855: unuse_fields (TREE_TYPE (fields));
3856: }
3857: }
3858:
3859: /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE to
3860: appropriate values, found by looking up the type definition of
3861: NAME (as a CODE).
3862:
3863: If MODIFY is 1, we set IDENTIFIER_CLASS_VALUE's of names
3864: which can be seen locally to the class. They are shadowed by
3865: any subsequent local declaration (including parameter names).
3866:
3867: If MODIFY is 2, we set IDENTIFIER_CLASS_VALUE's of names
3868: which have static meaning (i.e., static members, static
3869: member functions, enum declarations, etc).
3870:
3871: If MODIFY is 3, we set IDENTIFIER_CLASS_VALUE of names
3872: which can be seen locally to the class (as in 1), but
3873: know that we are doing this for declaration purposes
3874: (i.e. friend foo::bar (int)).
3875:
3876: So that we may avoid calls to lookup_name, we cache the _TYPE
3877: nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
3878:
3879: For multiple inheritance, we perform a two-pass depth-first search
3880: of the type lattice. The first pass performs a pre-order search,
3881: marking types after the type has had its fields installed in
3882: the appropriate IDENTIFIER_CLASS_VALUE slot. The second pass merely
3883: unmarks the marked types. If a field or member function name
3884: appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
3885: that name becomes `error_mark_node'. */
3886:
3887: void
3888: pushclass (type, modify)
3889: tree type;
3890: int modify;
3891: {
3892: push_memoized_context (type, modify);
3893:
3894: current_class_depth++;
3895: *current_class_stack++ = current_class_name;
3896: *current_class_stack++ = current_class_type;
3897: if (current_class_stack >= current_class_base + current_class_stacksize)
3898: {
3899: current_class_base =
3900: (tree *)xrealloc (current_class_base,
3901: sizeof (tree) * (current_class_stacksize + 10));
3902: current_class_stack = current_class_base + current_class_stacksize;
3903: current_class_stacksize += 10;
3904: }
3905:
3906: current_class_name = TYPE_NAME (type);
3907: if (TREE_CODE (current_class_name) == TYPE_DECL)
3908: current_class_name = DECL_NAME (current_class_name);
3909: current_class_type = type;
3910:
3911: #if NEW_CLASS_SCOPING
3912: if (previous_class_type != NULL_TREE
3913: && (type != previous_class_type || TYPE_SIZE (previous_class_type) == NULL_TREE)
3914: && current_class_depth == 1)
3915: #else
3916: if (previous_class_type != NULL_TREE
3917: && (type != previous_class_type
3918: || TYPE_SIZE (previous_class_type) == NULL_TREE
3919: /* ??? Is this necessary any more? */
3920: || IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (previous_class_type)))
3921: && (current_class_depth == 1 || modify == 3))
3922: #endif
3923: {
3924: /* Forcibly remove any old class remnants. */
3925: popclass (-1);
3926: previous_class_type = NULL_TREE;
3927: }
3928:
3929: pushlevel_class ();
3930:
3931: if (modify)
3932: {
3933: tree tags;
3934: tree this_fndecl = current_function_decl;
3935:
3936: if (current_function_decl
3937: && DECL_CONTEXT (current_function_decl)
3938: && TREE_CODE (DECL_CONTEXT (current_function_decl)) == FUNCTION_DECL)
3939: current_function_decl = DECL_CONTEXT (current_function_decl);
3940: else
3941: current_function_decl = NULL_TREE;
3942:
3943: if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
3944: {
3945: declare_uninstantiated_type_level ();
3946: overload_template_name (current_class_name, 0);
3947: }
3948: #if !NEW_CLASS_SCOPING
3949: else if (type != previous_class_type)
3950: #else
3951: else if (type != previous_class_type || current_class_depth > 1)
3952: #endif
3953: {
3954: build_mi_matrix (type);
3955: push_class_decls (type);
3956: free_mi_matrix ();
3957: #if NEW_CLASS_SCOPING
3958: if (current_class_depth == 1)
3959: #endif
3960: previous_class_type = type;
3961: }
3962: #if NEW_CLASS_SCOPING
3963: else
3964: {
3965: tree item;
3966:
3967: /* Hooray, our cacheing was successful, let's just install the
3968: cached class_shadowed list, and walk through it to get the
3969: IDENTIFIER_TYPE_VALUEs correct. */
3970: set_class_shadows (previous_class_values);
3971: for (item = previous_class_values; item; item = TREE_CHAIN (item))
3972: {
3973: tree id = TREE_PURPOSE (item);
3974: tree decl = IDENTIFIER_CLASS_VALUE (id);
3975:
3976: if (TREE_CODE (decl) == TYPE_DECL)
3977: set_identifier_type_value (id, TREE_TYPE (decl));
3978: }
3979: }
3980: #endif
3981:
3982: for (tags = CLASSTYPE_TAGS (type); tags; tags = TREE_CHAIN (tags))
3983: {
3984: TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 1;
3985: if (! TREE_PURPOSE (tags))
3986: continue;
3987: pushtag (TREE_PURPOSE (tags), TREE_VALUE (tags));
3988: #if !NEW_CLASS_SCOPING
3989: if (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (tags)) == NULL_TREE
3990: && TREE_CODE (TYPE_NAME (TREE_VALUE (tags))) == TYPE_DECL)
3991: IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (tags))
3992: = TYPE_NAME (TREE_VALUE (tags));
3993: #endif
3994: }
3995:
3996: current_function_decl = this_fndecl;
3997: }
3998:
3999: if (flag_cadillac)
4000: cadillac_push_class (type);
4001: }
4002:
4003: /* Get out of the current class scope. If we were in a class scope
4004: previously, that is the one popped to. The flag MODIFY tells
4005: whether the current scope declarations needs to be modified
4006: as a result of popping to the previous scope. */
4007: void
4008: popclass (modify)
4009: int modify;
4010: {
4011: if (flag_cadillac)
4012: cadillac_pop_class ();
4013:
4014: if (modify < 0)
4015: {
4016: /* Back this old class out completely. */
4017: tree tags = CLASSTYPE_TAGS (previous_class_type);
4018: #if NEW_CLASS_SCOPING
4019: tree t;
4020:
4021: /* This code can be seen as a cache miss. When we've cached a
4022: class' scope's bindings and we can't use them, we need to reset
4023: them. This is it! */
4024: for (t = previous_class_values; t; t = TREE_CHAIN(t))
4025: IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
4026: #else
4027: pop_class_decls (previous_class_type);
4028: #endif
4029: while (tags)
4030: {
4031: TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
4032: #if !NEW_CLASS_SCOPING
4033: IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (tags)) = NULL_TREE;
4034: #endif
4035: tags = TREE_CHAIN (tags);
4036: }
4037: goto ret;
4038: }
4039:
4040: if (modify)
4041: {
4042: /* Just remove from this class what didn't make
4043: it into IDENTIFIER_CLASS_VALUE. */
4044: tree tags = CLASSTYPE_TAGS (current_class_type);
4045:
4046: while (tags)
4047: {
4048: TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
4049: #if !NEW_CLASS_SCOPING
4050: if (TREE_PURPOSE (tags))
4051: IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (tags)) = NULL_TREE;
4052: #endif
4053: tags = TREE_CHAIN (tags);
4054: }
4055: }
4056: if (TREE_CODE (current_class_type) == UNINSTANTIATED_P_TYPE)
4057: undo_template_name_overload (current_class_name, 0);
4058:
4059: poplevel_class ();
4060:
4061: #if NEW_CLASS_SCOPING
4062: /* Since poplevel_class does the popping of class decls nowadays,
4063: this really only frees the obstack used for these decls.
4064: That's why it had to be moved down here. */
4065: if (modify)
4066: pop_class_decls (current_class_type);
4067: #endif
4068:
4069: current_class_depth--;
4070: current_class_type = *--current_class_stack;
4071: current_class_name = *--current_class_stack;
4072:
4073: if (current_class_type)
4074: {
4075: if (CLASSTYPE_VTBL_PTR (current_class_type))
4076: {
4077: current_vtable_decl = lookup_name (DECL_NAME (CLASSTYPE_VTBL_PTR (current_class_type)), 0);
4078: if (current_vtable_decl)
4079: current_vtable_decl = build_indirect_ref (current_vtable_decl,
4080: NULL_PTR);
4081: }
4082: current_class_decl = lookup_name (this_identifier, 0);
4083: if (current_class_decl)
4084: {
4085: if (TREE_CODE (TREE_TYPE (current_class_decl)) == POINTER_TYPE)
4086: {
4087: tree temp;
4088: /* Can't call build_indirect_ref here, because it has special
4089: logic to return C_C_D given this argument. */
4090: C_C_D = build1 (INDIRECT_REF, current_class_type, current_class_decl);
4091: temp = TREE_TYPE (TREE_TYPE (current_class_decl));
4092: TREE_READONLY (C_C_D) = TYPE_READONLY (temp);
4093: TREE_SIDE_EFFECTS (C_C_D) = TYPE_VOLATILE (temp);
4094: TREE_THIS_VOLATILE (C_C_D) = TYPE_VOLATILE (temp);
4095: }
4096: else
4097: C_C_D = current_class_decl;
4098: }
4099: else
4100: C_C_D = NULL_TREE;
4101: }
4102: else
4103: {
4104: current_class_decl = NULL_TREE;
4105: current_vtable_decl = NULL_TREE;
4106: C_C_D = NULL_TREE;
4107: }
4108:
4109: pop_memoized_context (modify);
4110:
4111: ret:
4112: ;
4113: }
4114:
4115: #if NEW_CLASS_SCOPING
4116: /* When entering a class scope, all enclosing class scopes' names with
4117: static meaning (static variables, static functions, types and enumerators)
4118: have to be visible. This recursive function calls pushclass for all
4119: enclosing class contexts until global or a local scope is reached.
4120: TYPE is the enclosed class and MODIFY is equivalent with the pushclass
4121: formal of the same name. */
4122:
4123: void
4124: push_nested_class (type, modify)
4125: tree type;
4126: int modify;
4127: {
4128: tree context = DECL_CONTEXT (TYPE_NAME (type));
4129:
4130: if (context && TREE_CODE (context) == RECORD_TYPE)
4131: push_nested_class (context, 2);
4132: pushclass (type, modify);
4133: }
4134:
4135: /* Undoes a push_nested_class call. MODIFY is passed on to popclass. */
4136:
4137: void
4138: pop_nested_class (modify)
4139: int modify;
4140: {
4141: tree context = DECL_CONTEXT (TYPE_NAME (current_class_type));
4142:
4143: popclass (modify);
4144: if (context && TREE_CODE (context) == RECORD_TYPE)
4145: pop_nested_class (modify);
4146: }
4147: #endif
4148:
4149: /* Set global variables CURRENT_LANG_NAME to appropriate value
4150: so that behavior of name-mangling machinery is correct. */
4151:
4152: void
4153: push_lang_context (name)
4154: tree name;
4155: {
4156: *current_lang_stack++ = current_lang_name;
4157: if (current_lang_stack >= current_lang_base + current_lang_stacksize)
4158: {
4159: current_lang_base =
4160: (tree *)xrealloc (current_lang_base,
4161: sizeof (tree) * (current_lang_stacksize + 10));
4162: current_lang_stack = current_lang_base + current_lang_stacksize;
4163: current_lang_stacksize += 10;
4164: }
4165:
4166: if (name == lang_name_cplusplus)
4167: {
4168: strict_prototype = strict_prototypes_lang_cplusplus;
4169: current_lang_name = name;
4170: #ifdef OBJCPLUS
4171: install_reserved_words (lang_cplusplus);
4172: #endif
4173: }
4174: else if (name == lang_name_c)
4175: {
4176: strict_prototype = strict_prototypes_lang_c;
4177: current_lang_name = name;
4178: #ifdef OBJCPLUS
4179: install_reserved_words (lang_c);
4180: #endif
4181: }
4182: #ifdef OBJCPLUS
4183: else if (name == lang_name_objc)
4184: {
4185: strict_prototype = strict_prototypes_lang_c;
4186: current_lang_name = name;
4187: install_reserved_words (lang_objc);
4188: }
4189: #endif
4190: else
4191: error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name));
4192:
4193: if (flag_cadillac)
4194: cadillac_push_lang (name);
4195: }
4196:
4197: /* Get out of the current language scope. */
4198: void
4199: pop_lang_context ()
4200: {
4201: if (flag_cadillac)
4202: cadillac_pop_lang ();
4203:
4204: current_lang_name = *--current_lang_stack;
4205: if (current_lang_name == lang_name_cplusplus)
4206: {
4207: strict_prototype = strict_prototypes_lang_cplusplus;
4208: #ifdef OBJCPLUS
4209: install_reserved_words (lang_cplusplus);
4210: #endif
4211: }
4212: else if (current_lang_name == lang_name_c)
4213: {
4214: strict_prototype = strict_prototypes_lang_c;
4215: #ifdef OBJCPLUS
4216: install_reserved_words (lang_c);
4217: #endif
4218: }
4219: #ifdef OBJCPLUS
4220: else if (current_lang_name == lang_name_objc)
4221: {
4222: strict_prototype = strict_prototypes_lang_c;
4223: if (doing_objc_thang)
4224: install_reserved_words (lang_objc);
4225: }
4226: #endif
4227: }
4228:
4229: int
4230: root_lang_context_p ()
4231: {
4232: return current_lang_stack == current_lang_base;
4233: }
4234:
4235: /* Type instantiation routines. */
4236:
4237: /* This function will instantiate the type of the expression given
4238: in RHS to match the type of LHSTYPE. If LHSTYPE is NULL_TREE,
4239: or other errors exist, the TREE_TYPE of RHS will be ERROR_MARK_NODE.
4240:
4241: This function is used in build_modify_expr, convert_arguments,
4242: build_c_cast, and compute_conversion_costs. */
4243: tree
4244: instantiate_type (lhstype, rhs, complain)
4245: tree lhstype, rhs;
4246: int complain;
4247: {
4248: if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
4249: {
4250: if (complain)
4251: error ("not enough type information");
4252: return error_mark_node;
4253: }
4254:
4255: if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
4256: return rhs;
4257:
4258: /* This should really only be used when attempting to distinguish
4259: what sort of a pointer to function we have. For now, any
4260: arithmetic operation which is not supported on pointers
4261: is rejected as an error. */
4262:
4263: switch (TREE_CODE (rhs))
4264: {
4265: case TYPE_EXPR:
4266: case CONVERT_EXPR:
4267: case SAVE_EXPR:
4268: case CONSTRUCTOR:
4269: case BUFFER_REF:
4270: my_friendly_abort (177);
4271: return error_mark_node;
4272:
4273: case INDIRECT_REF:
4274: case ARRAY_REF:
4275: TREE_TYPE (rhs) = lhstype;
4276: lhstype = build_pointer_type (lhstype);
4277: TREE_OPERAND (rhs, 0)
4278: = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
4279: if (TREE_OPERAND (rhs, 0) == error_mark_node)
4280: return error_mark_node;
4281:
4282: return rhs;
4283:
4284: case NOP_EXPR:
4285: rhs = copy_node (TREE_OPERAND (rhs, 0));
4286: TREE_TYPE (rhs) = unknown_type_node;
4287: return instantiate_type (lhstype, rhs, complain);
4288:
4289: case COMPONENT_REF:
4290: {
4291: tree field = TREE_OPERAND (rhs, 1);
4292: if (TREE_CODE (field) == TREE_LIST)
4293: {
4294: tree function = instantiate_type (lhstype, field, complain);
4295: if (function == error_mark_node)
4296: return error_mark_node;
4297: my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 185);
4298: if (DECL_VINDEX (function))
4299: {
4300: tree base = TREE_OPERAND (rhs, 0);
4301: tree base_ptr = build_unary_op (ADDR_EXPR, base, 0);
4302: if (base_ptr == error_mark_node)
4303: return error_mark_node;
4304: base_ptr = convert_pointer_to (DECL_CONTEXT (function), base_ptr);
4305: if (base_ptr == error_mark_node)
4306: return error_mark_node;
4307: return build_vfn_ref (&base_ptr, base, DECL_VINDEX (function));
4308: }
4309: return function;
4310: }
4311:
4312: my_friendly_assert (TREE_CODE (field) == FIELD_DECL, 178);
4313: my_friendly_assert (!(TREE_CODE (TREE_TYPE (field)) == FUNCTION_TYPE
4314: || TREE_CODE (TREE_TYPE (field)) == METHOD_TYPE),
4315: 179);
4316:
4317: TREE_TYPE (rhs) = lhstype;
4318: /* First look for an exact match */
4319:
4320: while (field && TREE_TYPE (field) != lhstype)
4321: field = TREE_CHAIN (field);
4322: if (field)
4323: {
4324: TREE_OPERAND (rhs, 1) = field;
4325: return rhs;
4326: }
4327:
4328: /* No exact match found, look for a compatible function. */
4329: field = TREE_OPERAND (rhs, 1);
4330: while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
4331: field = TREE_CHAIN (field);
4332: if (field)
4333: {
4334: TREE_OPERAND (rhs, 1) = field;
4335: field = TREE_CHAIN (field);
4336: while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
4337: field = TREE_CHAIN (field);
4338: if (field)
4339: {
4340: if (complain)
4341: error ("ambiguous overload for COMPONENT_REF requested");
4342: return error_mark_node;
4343: }
4344: }
4345: else
4346: {
4347: if (complain)
4348: error ("no appropriate overload exists for COMPONENT_REF");
4349: return error_mark_node;
4350: }
4351: return rhs;
4352: }
4353:
4354: case TREE_LIST:
4355: {
4356: tree elem, baselink, name;
4357: int globals = overloaded_globals_p (rhs);
4358:
4359: /* If there's only one function we know about, return that. */
4360: if (globals > 0 && TREE_CHAIN (rhs) == NULL_TREE)
4361: return TREE_VALUE (rhs);
4362:
4363: /* First look for an exact match. Search either overloaded
4364: functions or member functions. May have to undo what
4365: `default_conversion' might do to lhstype. */
4366:
4367: if (TREE_CODE (lhstype) == POINTER_TYPE)
4368: if (TREE_CODE (TREE_TYPE (lhstype)) == FUNCTION_TYPE
4369: || TREE_CODE (TREE_TYPE (lhstype)) == METHOD_TYPE)
4370: lhstype = TREE_TYPE (lhstype);
4371: else
4372: {
4373: if (complain)
4374: error ("invalid type combination for overload");
4375: return error_mark_node;
4376: }
4377:
4378: if (TREE_CODE (lhstype) != FUNCTION_TYPE && globals > 0)
4379: {
4380: if (complain)
4381: cp_error ("cannot resolve overloaded function `%D' based on non-function type",
4382: TREE_PURPOSE (rhs));
4383: return error_mark_node;
4384: }
4385:
4386: if (globals > 0)
4387: {
4388: my_friendly_assert (TREE_CODE (TREE_VALUE (rhs)) == FUNCTION_DECL,
4389: 180);
4390: elem = rhs;
4391: while (elem)
4392: if (TREE_TYPE (TREE_VALUE (elem)) != lhstype)
4393: elem = TREE_CHAIN (elem);
4394: else
4395: return TREE_VALUE (elem);
4396: /* No exact match found, look for a compatible function. */
4397: elem = rhs;
4398: while (elem && ! comp_target_types (lhstype, TREE_TYPE (TREE_VALUE (elem)), 1))
4399: elem = TREE_CHAIN (elem);
4400: if (elem)
4401: {
4402: tree save_elem = TREE_VALUE (elem);
4403: elem = TREE_CHAIN (elem);
4404: while (elem && ! comp_target_types (lhstype, TREE_TYPE (TREE_VALUE (elem)), 0))
4405: elem = TREE_CHAIN (elem);
4406: if (elem)
4407: {
4408: if (complain)
4409: error ("ambiguous overload for overloaded function requested");
4410: return error_mark_node;
4411: }
4412: return save_elem;
4413: }
4414: if (complain)
4415: {
4416: cp_error ("cannot resolve overload to target type `%#T';",
4417: lhstype);
4418: cp_error ("no suitable overload of function `%D' exists",
4419: TREE_PURPOSE (rhs));
4420: }
4421: return error_mark_node;
4422: }
4423:
4424: if (TREE_NONLOCAL_FLAG (rhs))
4425: {
4426: /* Got to get it as a baselink. */
4427: rhs = lookup_fnfields (TYPE_BINFO (current_class_type),
4428: TREE_PURPOSE (rhs), 0);
4429: }
4430: else
4431: {
4432: my_friendly_assert (TREE_CHAIN (rhs) == NULL_TREE, 181);
4433: if (TREE_CODE (TREE_VALUE (rhs)) == TREE_LIST)
4434: rhs = TREE_VALUE (rhs);
4435: my_friendly_assert (TREE_CODE (TREE_VALUE (rhs)) == FUNCTION_DECL,
4436: 182);
4437: }
4438:
4439: for (baselink = rhs; baselink;
4440: baselink = next_baselink (baselink))
4441: {
4442: elem = TREE_VALUE (baselink);
4443: while (elem)
4444: if (TREE_TYPE (elem) != lhstype)
4445: elem = TREE_CHAIN (elem);
4446: else
4447: return elem;
4448: }
4449:
4450: /* No exact match found, look for a compatible method. */
4451: for (baselink = rhs; baselink;
4452: baselink = next_baselink (baselink))
4453: {
4454: elem = TREE_VALUE (baselink);
4455: while (elem && ! comp_target_types (lhstype, TREE_TYPE (elem), 1))
4456: elem = TREE_CHAIN (elem);
4457: if (elem)
4458: {
4459: tree save_elem = elem;
4460: elem = TREE_CHAIN (elem);
4461: while (elem && ! comp_target_types (lhstype, TREE_TYPE (elem), 0))
4462: elem = TREE_CHAIN (elem);
4463: if (elem)
4464: {
4465: if (complain)
4466: error ("ambiguous overload for overloaded method requested");
4467: return error_mark_node;
4468: }
4469: return save_elem;
4470: }
4471: name = DECL_NAME (TREE_VALUE (rhs));
4472: if (TREE_CODE (lhstype) == FUNCTION_TYPE && globals < 0)
4473: {
4474: /* Try to instantiate from non-member functions. */
4475: rhs = IDENTIFIER_GLOBAL_VALUE (name);
4476: if (rhs && TREE_CODE (rhs) == TREE_LIST)
4477: {
4478: /* This code seems to be missing a `return'. */
4479: my_friendly_abort (4);
4480: instantiate_type (lhstype, rhs, complain);
4481: }
4482: }
4483: }
4484: if (complain)
4485: error ("no static member functions named `%s'",
4486: IDENTIFIER_POINTER (name));
4487: return error_mark_node;
4488: }
4489:
4490: case CALL_EXPR:
4491: /* This is too hard for now. */
4492: my_friendly_abort (183);
4493: return error_mark_node;
4494:
4495: case PLUS_EXPR:
4496: case MINUS_EXPR:
4497: case COMPOUND_EXPR:
4498: TREE_OPERAND (rhs, 0) = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
4499: if (TREE_OPERAND (rhs, 0) == error_mark_node)
4500: return error_mark_node;
4501: TREE_OPERAND (rhs, 1) = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
4502: if (TREE_OPERAND (rhs, 1) == error_mark_node)
4503: return error_mark_node;
4504:
4505: TREE_TYPE (rhs) = lhstype;
4506: return rhs;
4507:
4508: case MULT_EXPR:
4509: case TRUNC_DIV_EXPR:
4510: case FLOOR_DIV_EXPR:
4511: case CEIL_DIV_EXPR:
4512: case ROUND_DIV_EXPR:
4513: case RDIV_EXPR:
4514: case TRUNC_MOD_EXPR:
4515: case FLOOR_MOD_EXPR:
4516: case CEIL_MOD_EXPR:
4517: case ROUND_MOD_EXPR:
4518: case FIX_ROUND_EXPR:
4519: case FIX_FLOOR_EXPR:
4520: case FIX_CEIL_EXPR:
4521: case FIX_TRUNC_EXPR:
4522: case FLOAT_EXPR:
4523: case NEGATE_EXPR:
4524: case ABS_EXPR:
4525: case MAX_EXPR:
4526: case MIN_EXPR:
4527: case FFS_EXPR:
4528:
4529: case BIT_AND_EXPR:
4530: case BIT_IOR_EXPR:
4531: case BIT_XOR_EXPR:
4532: case LSHIFT_EXPR:
4533: case RSHIFT_EXPR:
4534: case LROTATE_EXPR:
4535: case RROTATE_EXPR:
4536:
4537: case PREINCREMENT_EXPR:
4538: case PREDECREMENT_EXPR:
4539: case POSTINCREMENT_EXPR:
4540: case POSTDECREMENT_EXPR:
4541: if (complain)
4542: error ("illegal operation on uninstantiated type");
4543: return error_mark_node;
4544:
4545: case TRUTH_AND_EXPR:
4546: case TRUTH_OR_EXPR:
4547: case TRUTH_XOR_EXPR:
4548: case LT_EXPR:
4549: case LE_EXPR:
4550: case GT_EXPR:
4551: case GE_EXPR:
4552: case EQ_EXPR:
4553: case NE_EXPR:
4554: case TRUTH_ANDIF_EXPR:
4555: case TRUTH_ORIF_EXPR:
4556: case TRUTH_NOT_EXPR:
4557: if (complain)
4558: error ("not enough type information");
4559: return error_mark_node;
4560:
4561: case COND_EXPR:
4562: if (type_unknown_p (TREE_OPERAND (rhs, 0)))
4563: {
4564: if (complain)
4565: error ("not enough type information");
4566: return error_mark_node;
4567: }
4568: TREE_OPERAND (rhs, 1) = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
4569: if (TREE_OPERAND (rhs, 1) == error_mark_node)
4570: return error_mark_node;
4571: TREE_OPERAND (rhs, 2) = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), complain);
4572: if (TREE_OPERAND (rhs, 2) == error_mark_node)
4573: return error_mark_node;
4574:
4575: TREE_TYPE (rhs) = lhstype;
4576: return rhs;
4577:
4578: case MODIFY_EXPR:
4579: TREE_OPERAND (rhs, 1) = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
4580: if (TREE_OPERAND (rhs, 1) == error_mark_node)
4581: return error_mark_node;
4582:
4583: TREE_TYPE (rhs) = lhstype;
4584: return rhs;
4585:
4586: case ADDR_EXPR:
4587: if (TREE_CODE (lhstype) != POINTER_TYPE)
4588: {
4589: if (complain)
4590: error ("type for resolving address of overloaded function must be pointer type");
4591: return error_mark_node;
4592: }
4593: TREE_TYPE (rhs) = lhstype;
4594: lhstype = TREE_TYPE (lhstype);
4595: TREE_OPERAND (rhs, 0) = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
4596: if (TREE_OPERAND (rhs, 0) == error_mark_node)
4597: return error_mark_node;
4598:
4599: mark_addressable (TREE_OPERAND (rhs, 0));
4600: return rhs;
4601:
4602: case ENTRY_VALUE_EXPR:
4603: my_friendly_abort (184);
4604: return error_mark_node;
4605:
4606: case ERROR_MARK:
4607: return error_mark_node;
4608:
4609: default:
4610: my_friendly_abort (185);
4611: return error_mark_node;
4612: }
4613: }
4614:
4615: /* Return the name of the virtual function pointer field
4616: (as an IDENTIFIER_NODE) for the given TYPE. Note that
4617: this may have to look back through base types to find the
4618: ultimate field name. (For single inheritance, these could
4619: all be the same name. Who knows for multiple inheritance). */
4620: static tree
4621: get_vfield_name (type)
4622: tree type;
4623: {
4624: tree binfo = TYPE_BINFO (type);
4625: char *buf;
4626:
4627: while (BINFO_BASETYPES (binfo)
4628: && TYPE_VIRTUAL_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
4629: && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
4630: binfo = BINFO_BASETYPE (binfo, 0);
4631:
4632: type = BINFO_TYPE (binfo);
4633: buf = (char *)alloca (sizeof (VFIELD_NAME_FORMAT)
4634: + TYPE_NAME_LENGTH (type) + 2);
4635: sprintf (buf, VFIELD_NAME_FORMAT, TYPE_NAME_STRING (type));
4636: return get_identifier (buf);
4637: }
4638:
4639: void
4640: print_class_statistics ()
4641: {
4642: #ifdef GATHER_STATISTICS
4643: fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
4644: fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
4645: fprintf (stderr, "build_method_call = %d (inner = %d)\n",
4646: n_build_method_call, n_inner_fields_searched);
4647: if (n_vtables)
4648: {
4649: fprintf (stderr, "vtables = %d; vtable searches = %d\n",
4650: n_vtables, n_vtable_searches);
4651: fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
4652: n_vtable_entries, n_vtable_elems);
4653: }
4654: #endif
4655: }
4656:
4657: #if NEW_CLASS_SCOPING
4658: /* Push an obstack which is sufficiently long-lived to hold such class
4659: decls that may be cached in the previous_class_values list. For now, let's
4660: use the permanent obstack, later we may create a dedicated obstack just
4661: for this purpose. The effect is undone by pop_obstacks. */
4662: void
4663: maybe_push_cache_obstack ()
4664: {
4665: push_obstacks_nochange ();
4666: if (current_class_depth == 1)
4667: current_obstack = &permanent_obstack;
4668: }
4669: #endif
4670:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.