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