![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-tree.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-tree.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Language-dependent node constructors for parse phase of GNU compiler.
2: Copyright (C) 1987, 1988, 1992, 1993 Free Software Foundation, Inc.
3: Hacked 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: #include "config.h"
22: #include <stdio.h>
23: #include "obstack.h"
24: #include "tree.h"
25: #include "cp-tree.h"
26: #include "flags.h"
27:
28: #define CEIL(x,y) (((x) + (y) - 1) / (y))
29:
30: /* Return nonzero if REF is an lvalue valid for this language.
31: Lvalues can be assigned, unless they have TREE_READONLY.
32: Lvalues can have their address taken, unless they have DECL_REGISTER. */
33:
34: int
35: lvalue_p (ref)
36: tree ref;
37: {
38: register enum tree_code code = TREE_CODE (ref);
39:
40: if (language_lvalue_valid (ref))
41: switch (code)
42: {
43: /* preincrements and predecrements are valid lvals, provided
44: what they refer to are valid lvals. */
45: case PREINCREMENT_EXPR:
46: case PREDECREMENT_EXPR:
47: case COMPONENT_REF:
48: case SAVE_EXPR:
49: return lvalue_p (TREE_OPERAND (ref, 0));
50:
51: case STRING_CST:
52: return 1;
53:
54: case VAR_DECL:
55: if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
56: && DECL_LANG_SPECIFIC (ref)
57: && DECL_IN_AGGR_P (ref))
58: return 0;
59: case INDIRECT_REF:
60: case ARRAY_REF:
61: case PARM_DECL:
62: case RESULT_DECL:
63: case ERROR_MARK:
64: if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
65: && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
66: return 1;
67: break;
68:
69: case TARGET_EXPR:
70: case WITH_CLEANUP_EXPR:
71: return 1;
72:
73: case CALL_EXPR:
74: if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE
75: /* unary_complex_lvalue knows how to deal with this case. */
76: || TREE_ADDRESSABLE (TREE_TYPE (ref)))
77: return 1;
78: break;
79:
80: /* A currently unresolved scope ref. */
81: case SCOPE_REF:
82: my_friendly_abort (103);
83: case OFFSET_REF:
84: if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
85: return 1;
86: if (TREE_CODE (TREE_OPERAND (ref, 1)) == VAR_DECL)
87: if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
88: && DECL_LANG_SPECIFIC (ref)
89: && DECL_IN_AGGR_P (ref))
90: return 0;
91: else
92: return 1;
93: break;
94:
95: case ADDR_EXPR:
96: /* ANSI C++ June 5 1992 WP 5.4.14. The result of a cast to a
97: reference is an lvalue. */
98: if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
99: return 1;
100: break;
101: }
102: return 0;
103: }
104:
105: /* Return nonzero if REF is an lvalue valid for this language;
106: otherwise, print an error message and return zero. */
107:
108: int
109: lvalue_or_else (ref, string)
110: tree ref;
111: char *string;
112: {
113: int win = lvalue_p (ref);
114: if (! win)
115: error ("invalid lvalue in %s", string);
116: return win;
117: }
118:
119: /* INIT is a CALL_EXPR which needs info about its target.
120: TYPE is the type that this initialization should appear to have.
121:
122: Build an encapsulation of the initialization to perform
123: and return it so that it can be processed by language-independent
124: and language-specific expression expanders.
125:
126: If WITH_CLEANUP_P is nonzero, we build a cleanup for this expression.
127: Otherwise, cleanups are not built here. For example, when building
128: an initialization for a stack slot, since the called function handles
129: the cleanup, we would not want to do it here. */
130: tree
131: build_cplus_new (type, init, with_cleanup_p)
132: tree type;
133: tree init;
134: int with_cleanup_p;
135: {
136: tree slot = build (VAR_DECL, type);
137: tree rval = build (NEW_EXPR, type,
138: TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
139: TREE_SIDE_EFFECTS (rval) = 1;
140: TREE_ADDRESSABLE (rval) = 1;
141: rval = build (TARGET_EXPR, type, slot, rval, 0);
142: TREE_SIDE_EFFECTS (rval) = 1;
143: TREE_ADDRESSABLE (rval) = 1;
144:
145: if (with_cleanup_p && TYPE_NEEDS_DESTRUCTOR (type))
146: {
147: rval = build (WITH_CLEANUP_EXPR, type, rval, 0,
148: build_delete (TYPE_POINTER_TO (type),
149: build_unary_op (ADDR_EXPR, slot, 0),
150: integer_two_node,
151: LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0));
152: TREE_SIDE_EFFECTS (rval) = 1;
153: }
154: return rval;
155: }
156:
157: /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
158: these CALL_EXPRs with tree nodes that will perform the cleanups. */
159:
160: tree
161: break_out_cleanups (exp)
162: tree exp;
163: {
164: tree tmp = exp;
165:
166: if (TREE_CODE (tmp) == CALL_EXPR
167: && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
168: return build_cplus_new (TREE_TYPE (tmp), tmp, 1);
169:
170: while (TREE_CODE (tmp) == NOP_EXPR
171: || TREE_CODE (tmp) == CONVERT_EXPR
172: || TREE_CODE (tmp) == NON_LVALUE_EXPR)
173: {
174: if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
175: && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
176: {
177: TREE_OPERAND (tmp, 0)
178: = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
179: TREE_OPERAND (tmp, 0), 1);
180: break;
181: }
182: else
183: tmp = TREE_OPERAND (tmp, 0);
184: }
185: return exp;
186: }
187:
188: /* Recursively perform a preorder search EXP for CALL_EXPRs, making
189: copies where they are found. Returns a deep copy all nodes transitively
190: containing CALL_EXPRs. */
191:
192: tree
193: break_out_calls (exp)
194: tree exp;
195: {
196: register tree t1, t2;
197: register enum tree_code code;
198: register int changed = 0;
199: register int i;
200:
201: if (exp == NULL_TREE)
202: return exp;
203:
204: code = TREE_CODE (exp);
205:
206: if (code == CALL_EXPR)
207: return copy_node (exp);
208:
209: /* Don't try and defeat a save_expr, as it should only be done once. */
210: if (code == SAVE_EXPR)
211: return exp;
212:
213: switch (TREE_CODE_CLASS (code))
214: {
215: default:
216: abort ();
217:
218: case 'c': /* a constant */
219: case 't': /* a type node */
220: case 'x': /* something random, like an identifier or an ERROR_MARK. */
221: return exp;
222:
223: case 'd': /* A decl node */
224: t1 = break_out_calls (DECL_INITIAL (exp));
225: if (t1 != DECL_INITIAL (exp))
226: {
227: exp = copy_node (exp);
228: DECL_INITIAL (exp) = t1;
229: }
230: return exp;
231:
232: case 'b': /* A block node */
233: {
234: /* Don't know how to handle these correctly yet. Must do a
235: break_out_calls on all DECL_INITIAL values for local variables,
236: and also break_out_calls on all sub-blocks and sub-statements. */
237: abort ();
238: }
239: return exp;
240:
241: case 'e': /* an expression */
242: case 'r': /* a reference */
243: case 's': /* an expression with side effects */
244: for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
245: {
246: t1 = break_out_calls (TREE_OPERAND (exp, i));
247: if (t1 != TREE_OPERAND (exp, i))
248: {
249: exp = copy_node (exp);
250: TREE_OPERAND (exp, i) = t1;
251: }
252: }
253: return exp;
254:
255: case '<': /* a comparison expression */
256: case '2': /* a binary arithmetic expression */
257: t2 = break_out_calls (TREE_OPERAND (exp, 1));
258: if (t2 != TREE_OPERAND (exp, 1))
259: changed = 1;
260: case '1': /* a unary arithmetic expression */
261: t1 = break_out_calls (TREE_OPERAND (exp, 0));
262: if (t1 != TREE_OPERAND (exp, 0))
263: changed = 1;
264: if (changed)
265: {
266: if (tree_code_length[(int) code] == 1)
267: return build1 (code, TREE_TYPE (exp), t1);
268: else
269: return build (code, TREE_TYPE (exp), t1, t2);
270: }
271: return exp;
272: }
273:
274: }
275:
276: extern struct obstack *current_obstack;
277: extern struct obstack permanent_obstack, class_obstack;
278: extern struct obstack *saveable_obstack;
279:
280: /* Here is how primitive or already-canonicalized types' hash
281: codes are made. MUST BE CONSISTENT WITH tree.c !!! */
282: #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
283:
284: /* Construct, lay out and return the type of methods belonging to class
285: BASETYPE and whose arguments are described by ARGTYPES and whose values
286: are described by RETTYPE. If each type exists already, reuse it. */
287: tree
288: build_cplus_method_type (basetype, rettype, argtypes)
289: tree basetype, rettype, argtypes;
290: {
291: register tree t;
292: tree ptype = build_pointer_type (basetype);
293: int hashcode;
294:
295: /* Make a node of the sort we want. */
296: t = make_node (METHOD_TYPE);
297:
298: TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
299: TREE_TYPE (t) = rettype;
300: #if 0
301: /* it is wrong to flag the object the pointer points to as readonly
302: when flag_this_is_variable is 0. */
303: ptype = build_type_variant (ptype, flag_this_is_variable <= 0, 0);
304: #else
305: ptype = build_type_variant (ptype, 0, 0);
306: #endif
307: /* The actual arglist for this function includes a "hidden" argument
308: which is "this". Put it into the list of argument types. */
309:
310: argtypes = tree_cons (NULL_TREE, ptype, argtypes);
311: TYPE_ARG_TYPES (t) = argtypes;
312: TREE_SIDE_EFFECTS (argtypes) = 1; /* Mark first argtype as "artificial". */
313:
314: /* If we already have such a type, use the old one and free this one.
315: Note that it also frees up the above cons cell if found. */
316: hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes);
317: t = type_hash_canon (hashcode, t);
318:
319: if (TYPE_SIZE (t) == 0)
320: layout_type (t);
321:
322: return t;
323: }
324:
325: tree
326: build_cplus_staticfn_type (basetype, rettype, argtypes)
327: tree basetype, rettype, argtypes;
328: {
329: register tree t;
330: int hashcode;
331:
332: /* Make a node of the sort we want. */
333: t = make_node (FUNCTION_TYPE);
334:
335: TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
336: TREE_TYPE (t) = rettype;
337:
338: /* The actual arglist for this function includes a "hidden" argument
339: which is "this". Put it into the list of argument types. */
340:
341: TYPE_ARG_TYPES (t) = argtypes;
342:
343: /* If we already have such a type, use the old one and free this one.
344: Note that it also frees up the above cons cell if found. */
345: hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes);
346: t = type_hash_canon (hashcode, t);
347:
348: if (TYPE_SIZE (t) == 0)
349: layout_type (t);
350:
351: return t;
352: }
353:
354: tree
355: build_cplus_array_type (elt_type, index_type)
356: tree elt_type;
357: tree index_type;
358: {
359: register struct obstack *ambient_obstack = current_obstack;
360: register struct obstack *ambient_saveable_obstack = saveable_obstack;
361: tree t;
362:
363: /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
364: make this permanent too. */
365: if (TREE_PERMANENT (elt_type)
366: && (index_type == 0 || TREE_PERMANENT (index_type)))
367: {
368: current_obstack = &permanent_obstack;
369: saveable_obstack = &permanent_obstack;
370: }
371:
372: t = build_array_type (elt_type, index_type);
373:
374: /* Push these needs up so that initialization takes place
375: more easily. */
376: TYPE_NEEDS_CONSTRUCTING (t) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
377: TYPE_NEEDS_DESTRUCTOR (t) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
378: current_obstack = ambient_obstack;
379: saveable_obstack = ambient_saveable_obstack;
380: return t;
381: }
382:
383: /* Add OFFSET to all base types of T.
384:
385: OFFSET, which is a type offset, is number of bytes.
386:
387: Note that we don't have to worry about having two paths to the
388: same base type, since this type owns its association list. */
389: void
390: propagate_binfo_offsets (binfo, offset)
391: tree binfo;
392: tree offset;
393: {
394: tree binfos = BINFO_BASETYPES (binfo);
395: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
396:
397: for (i = 0; i < n_baselinks; /* note increment is done in the loop. */)
398: {
399: tree base_binfo = TREE_VEC_ELT (binfos, i);
400:
401: if (TREE_VIA_VIRTUAL (base_binfo))
402: i += 1;
403: else
404: {
405: int j;
406: tree base_binfos = BINFO_BASETYPES (base_binfo);
407: tree delta;
408:
409: for (j = i+1; j < n_baselinks; j++)
410: if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j)))
411: {
412: /* The next basetype offset must take into account the space
413: between the classes, not just the size of each class. */
414: delta = size_binop (MINUS_EXPR,
415: BINFO_OFFSET (TREE_VEC_ELT (binfos, j)),
416: BINFO_OFFSET (base_binfo));
417: break;
418: }
419:
420: #if 0
421: if (BINFO_OFFSET_ZEROP (base_binfo))
422: BINFO_OFFSET (base_binfo) = offset;
423: else
424: BINFO_OFFSET (base_binfo)
425: = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
426: #else
427: BINFO_OFFSET (base_binfo) = offset;
428: #endif
429: if (base_binfos)
430: {
431: int k;
432: tree chain = NULL_TREE;
433:
434: /* Now unshare the structure beneath BASE_BINFO. */
435: for (k = TREE_VEC_LENGTH (base_binfos)-1;
436: k >= 0; k--)
437: {
438: tree base_base_binfo = TREE_VEC_ELT (base_binfos, k);
439: if (! TREE_VIA_VIRTUAL (base_base_binfo))
440: TREE_VEC_ELT (base_binfos, k)
441: = make_binfo (BINFO_OFFSET (base_base_binfo),
442: BINFO_TYPE (base_base_binfo),
443: BINFO_VTABLE (base_base_binfo),
444: BINFO_VIRTUALS (base_base_binfo),
445: chain);
446: chain = TREE_VEC_ELT (base_binfos, k);
447: TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
448: TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
449: }
450: /* Now propagate the offset to the base types. */
451: propagate_binfo_offsets (base_binfo, offset);
452: }
453:
454: /* Go to our next class that counts for offset propagation. */
455: i = j;
456: if (i < n_baselinks)
457: offset = size_binop (PLUS_EXPR, offset, delta);
458: }
459: }
460: }
461:
462: /* Compute the actual offsets that our virtual base classes
463: will have *for this type*. This must be performed after
464: the fields are laid out, since virtual baseclasses must
465: lay down at the end of the record.
466:
467: Returns the maximum number of virtual functions any of the virtual
468: baseclasses provide. */
469: int
470: layout_vbasetypes (rec, max)
471: tree rec;
472: int max;
473: {
474: /* Get all the virtual base types that this type uses.
475: The TREE_VALUE slot holds the virtual baseclass type. */
476: tree vbase_types = get_vbase_types (rec);
477:
478: #ifdef STRUCTURE_SIZE_BOUNDARY
479: unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
480: #else
481: unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
482: #endif
483:
484: /* Record size so far is CONST_SIZE + VAR_SIZE bits,
485: where CONST_SIZE is an integer
486: and VAR_SIZE is a tree expression.
487: If VAR_SIZE is null, the size is just CONST_SIZE.
488: Naturally we try to avoid using VAR_SIZE. */
489: register unsigned const_size = 0;
490: register tree var_size = 0;
491: int nonvirtual_const_size;
492: tree nonvirtual_var_size;
493:
494: CLASSTYPE_VBASECLASSES (rec) = vbase_types;
495:
496: if (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST)
497: const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
498: else
499: var_size = TYPE_SIZE (rec);
500:
501: nonvirtual_const_size = const_size;
502: nonvirtual_var_size = var_size;
503:
504: while (vbase_types)
505: {
506: tree basetype = BINFO_TYPE (vbase_types);
507: tree offset;
508:
509: if (const_size == 0)
510: offset = integer_zero_node;
511: else
512: offset = size_int ((const_size + BITS_PER_UNIT - 1) / BITS_PER_UNIT);
513:
514: if (CLASSTYPE_VSIZE (basetype) > max)
515: max = CLASSTYPE_VSIZE (basetype);
516: BINFO_OFFSET (vbase_types) = offset;
517:
518: if (TREE_CODE (TYPE_SIZE (basetype)) == INTEGER_CST)
519: const_size += MAX (record_align,
520: TREE_INT_CST_LOW (TYPE_SIZE (basetype))
521: - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype)));
522: else if (var_size == 0)
523: var_size = TYPE_SIZE (basetype);
524: else
525: var_size = size_binop (PLUS_EXPR, var_size, TYPE_SIZE (basetype));
526:
527: vbase_types = TREE_CHAIN (vbase_types);
528: }
529:
530: if (const_size != nonvirtual_const_size)
531: {
532: CLASSTYPE_VBASE_SIZE (rec)
533: = size_int (const_size - nonvirtual_const_size);
534: TYPE_SIZE (rec) = size_int (const_size);
535: }
536:
537: /* Now propagate offset information throughout the lattice
538: under the vbase type. */
539: for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
540: vbase_types = TREE_CHAIN (vbase_types))
541: {
542: tree base_binfos = BINFO_BASETYPES (vbase_types);
543:
544: if (base_binfos)
545: {
546: tree chain = NULL_TREE;
547: int j;
548: /* Now unshare the structure beneath BASE_BINFO. */
549:
550: for (j = TREE_VEC_LENGTH (base_binfos)-1;
551: j >= 0; j--)
552: {
553: tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
554: if (! TREE_VIA_VIRTUAL (base_base_binfo))
555: TREE_VEC_ELT (base_binfos, j)
556: = make_binfo (BINFO_OFFSET (base_base_binfo),
557: BINFO_TYPE (base_base_binfo),
558: BINFO_VTABLE (base_base_binfo),
559: BINFO_VIRTUALS (base_base_binfo),
560: chain);
561: chain = TREE_VEC_ELT (base_binfos, j);
562: TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
563: TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
564: }
565:
566: propagate_binfo_offsets (vbase_types, BINFO_OFFSET (vbase_types));
567: }
568: }
569:
570: return max;
571: }
572:
573: /* Lay out the base types of a record type, REC.
574: Tentatively set the size and alignment of REC
575: according to the base types alone.
576:
577: Offsets for immediate nonvirtual baseclasses are also computed here.
578:
579: Returns list of virtual base classes in a FIELD_DECL chain. */
580: tree
581: layout_basetypes (rec, binfos)
582: tree rec, binfos;
583: {
584: /* Chain to hold all the new FIELD_DECLs which point at virtual
585: base classes. */
586: tree vbase_decls = NULL_TREE;
587:
588: #ifdef STRUCTURE_SIZE_BOUNDARY
589: unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
590: #else
591: unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
592: #endif
593:
594: /* Record size so far is CONST_SIZE + VAR_SIZE bits,
595: where CONST_SIZE is an integer
596: and VAR_SIZE is a tree expression.
597: If VAR_SIZE is null, the size is just CONST_SIZE.
598: Naturally we try to avoid using VAR_SIZE. */
599: register unsigned const_size = 0;
600: register tree var_size = 0;
601: int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
602:
603: /* Handle basetypes almost like fields, but record their
604: offsets differently. */
605:
606: for (i = 0; i < n_baseclasses; i++)
607: {
608: int inc, desired_align, int_vbase_size;
609: register tree base_binfo = TREE_VEC_ELT (binfos, i);
610: register tree basetype = BINFO_TYPE (base_binfo);
611: tree decl, offset;
612:
613: if (TYPE_SIZE (basetype) == 0)
614: {
615: #if 0
616: /* This error is now reported in xref_tag, thus giving better
617: location information. */
618: error_with_aggr_type (base_binfo,
619: "base class `%s' has incomplete type");
620:
621: TREE_VIA_PUBLIC (base_binfo) = 1;
622: TREE_VIA_PROTECTED (base_binfo) = 0;
623: TREE_VIA_VIRTUAL (base_binfo) = 0;
624:
625: /* Should handle this better so that
626:
627: class A;
628: class B: private A { virtual void F(); };
629:
630: does not dump core when compiled. */
631: my_friendly_abort (121);
632: #endif
633: continue;
634: }
635:
636: /* All basetypes are recorded in the association list of the
637: derived type. */
638:
639: if (TREE_VIA_VIRTUAL (base_binfo))
640: {
641: int j;
642: char *name = (char *)alloca (TYPE_NAME_LENGTH (basetype)
643: + sizeof (VBASE_NAME) + 1);
644:
645: /* The offset for a virtual base class is only used in computing
646: virtual function tables and for initializing virtual base
647: pointers. It is built once `get_vbase_types' is called. */
648:
649: /* If this basetype can come from another vbase pointer
650: without an additional indirection, we will share
651: that pointer. If an indirection is involved, we
652: make our own pointer. */
653: for (j = 0; j < n_baseclasses; j++)
654: {
655: tree other_base_binfo = TREE_VEC_ELT (binfos, j);
656: if (! TREE_VIA_VIRTUAL (other_base_binfo)
657: && binfo_member (basetype,
658: CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo))))
659: goto got_it;
660: }
661: sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (basetype));
662: decl = build_lang_decl (FIELD_DECL, get_identifier (name),
663: build_pointer_type (basetype));
664: /* If you change any of the below, take a look at all the
665: other VFIELD_BASEs and VTABLE_BASEs in the code, and change
666: them too. */
667: DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
668: DECL_VIRTUAL_P (decl) = 1;
669: DECL_FIELD_CONTEXT (decl) = rec;
670: DECL_CLASS_CONTEXT (decl) = rec;
671: DECL_FCONTEXT (decl) = basetype;
672: DECL_FIELD_SIZE (decl) = 0;
673: DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node);
674: TREE_CHAIN (decl) = vbase_decls;
675: BINFO_VPTR_FIELD (base_binfo) = decl;
676: vbase_decls = decl;
677:
678: if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (basetype)
679: && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0)) == NULL_TREE)
680: {
681: warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0),
682: "destructor `%s' non-virtual");
683: warning ("in inheritance relationship `%s: virtual %s'",
684: TYPE_NAME_STRING (rec),
685: TYPE_NAME_STRING (basetype));
686: }
687: got_it:
688: /* The space this decl occupies has already been accounted for. */
689: continue;
690: }
691:
692: if (const_size == 0)
693: offset = integer_zero_node;
694: else
695: {
696: /* Give each base type the alignment it wants. */
697: const_size = CEIL (const_size, TYPE_ALIGN (basetype))
698: * TYPE_ALIGN (basetype);
699: offset = size_int ((const_size + BITS_PER_UNIT - 1) / BITS_PER_UNIT);
700:
701: #if 0
702: /* bpk: Disabled this check until someone is willing to
703: claim it as theirs and explain exactly what circumstances
704: warrant the warning. */
705: if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (basetype)
706: && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0)) == NULL_TREE)
707: {
708: warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0),
709: "destructor `%s' non-virtual");
710: warning ("in inheritance relationship `%s:%s %s'",
711: TYPE_NAME_STRING (rec),
712: TREE_VIA_VIRTUAL (base_binfo) ? " virtual" : "",
713: TYPE_NAME_STRING (basetype));
714: }
715: #endif
716: }
717: BINFO_OFFSET (base_binfo) = offset;
718: if (CLASSTYPE_VSIZE (basetype))
719: {
720: BINFO_VTABLE (base_binfo) = TYPE_BINFO_VTABLE (basetype);
721: BINFO_VIRTUALS (base_binfo) = TYPE_BINFO_VIRTUALS (basetype);
722: }
723: TREE_CHAIN (base_binfo) = TYPE_BINFO (rec);
724: TYPE_BINFO (rec) = base_binfo;
725:
726: /* Add only the amount of storage not present in
727: the virtual baseclasses. */
728:
729: int_vbase_size = TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype));
730: if (TREE_INT_CST_LOW (TYPE_SIZE (basetype)) > int_vbase_size)
731: {
732: inc = MAX (record_align,
733: (TREE_INT_CST_LOW (TYPE_SIZE (basetype))
734: - int_vbase_size));
735:
736: /* Record must have at least as much alignment as any field. */
737: desired_align = TYPE_ALIGN (basetype);
738: record_align = MAX (record_align, desired_align);
739:
740: const_size += inc;
741: }
742: }
743:
744: if (const_size)
745: CLASSTYPE_SIZE (rec) = size_int (const_size);
746: else
747: CLASSTYPE_SIZE (rec) = integer_zero_node;
748: CLASSTYPE_ALIGN (rec) = record_align;
749:
750: return vbase_decls;
751: }
752:
753: /* Hashing of lists so that we don't make duplicates.
754: The entry point is `list_hash_canon'. */
755:
756: /* Each hash table slot is a bucket containing a chain
757: of these structures. */
758:
759: struct list_hash
760: {
761: struct list_hash *next; /* Next structure in the bucket. */
762: int hashcode; /* Hash code of this list. */
763: tree list; /* The list recorded here. */
764: };
765:
766: /* Now here is the hash table. When recording a list, it is added
767: to the slot whose index is the hash code mod the table size.
768: Note that the hash table is used for several kinds of lists.
769: While all these live in the same table, they are completely independent,
770: and the hash code is computed differently for each of these. */
771:
772: #define TYPE_HASH_SIZE 59
773: struct list_hash *list_hash_table[TYPE_HASH_SIZE];
774:
775: /* Compute a hash code for a list (chain of TREE_LIST nodes
776: with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
777: TREE_COMMON slots), by adding the hash codes of the individual entries. */
778:
779: int
780: list_hash (list)
781: tree list;
782: {
783: register int hashcode = 0;
784:
785: if (TREE_CHAIN (list))
786: hashcode += TYPE_HASH (TREE_CHAIN (list));
787:
788: if (TREE_VALUE (list))
789: hashcode += TYPE_HASH (TREE_VALUE (list));
790: else
791: hashcode += 1007;
792: if (TREE_PURPOSE (list))
793: hashcode += TYPE_HASH (TREE_PURPOSE (list));
794: else
795: hashcode += 1009;
796: return hashcode;
797: }
798:
799: /* Look in the type hash table for a type isomorphic to TYPE.
800: If one is found, return it. Otherwise return 0. */
801:
802: tree
803: list_hash_lookup (hashcode, list)
804: int hashcode;
805: tree list;
806: {
807: register struct list_hash *h;
808: for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
809: if (h->hashcode == hashcode
810: && TREE_VIA_VIRTUAL (h->list) == TREE_VIA_VIRTUAL (list)
811: && TREE_VIA_PUBLIC (h->list) == TREE_VIA_PUBLIC (list)
812: && TREE_VIA_PROTECTED (h->list) == TREE_VIA_PROTECTED (list)
813: && TREE_PURPOSE (h->list) == TREE_PURPOSE (list)
814: && TREE_VALUE (h->list) == TREE_VALUE (list)
815: && TREE_CHAIN (h->list) == TREE_CHAIN (list))
816: {
817: my_friendly_assert (TREE_TYPE (h->list) == TREE_TYPE (list), 299);
818: return h->list;
819: }
820: return 0;
821: }
822:
823: /* Add an entry to the list-hash-table
824: for a list TYPE whose hash code is HASHCODE. */
825:
826: void
827: list_hash_add (hashcode, list)
828: int hashcode;
829: tree list;
830: {
831: register struct list_hash *h;
832:
833: h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash));
834: h->hashcode = hashcode;
835: h->list = list;
836: h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
837: list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
838: }
839:
840: /* Given TYPE, and HASHCODE its hash code, return the canonical
841: object for an identical list if one already exists.
842: Otherwise, return TYPE, and record it as the canonical object
843: if it is a permanent object.
844:
845: To use this function, first create a list of the sort you want.
846: Then compute its hash code from the fields of the list that
847: make it different from other similar lists.
848: Then call this function and use the value.
849: This function frees the list you pass in if it is a duplicate. */
850:
851: /* Set to 1 to debug without canonicalization. Never set by program. */
852: int debug_no_list_hash = 0;
853:
854: tree
855: list_hash_canon (hashcode, list)
856: int hashcode;
857: tree list;
858: {
859: tree t1;
860:
861: if (debug_no_list_hash)
862: return list;
863:
864: t1 = list_hash_lookup (hashcode, list);
865: if (t1 != 0)
866: {
867: obstack_free (&class_obstack, list);
868: return t1;
869: }
870:
871: /* If this is a new list, record it for later reuse. */
872: list_hash_add (hashcode, list);
873:
874: return list;
875: }
876:
877: tree
878: hash_tree_cons (via_public, via_virtual, via_protected, purpose, value, chain)
879: int via_public, via_virtual, via_protected;
880: tree purpose, value, chain;
881: {
882: struct obstack *ambient_obstack = current_obstack;
883: tree t;
884: int hashcode;
885:
886: current_obstack = &class_obstack;
887: t = tree_cons (purpose, value, chain);
888: TREE_VIA_PUBLIC (t) = via_public;
889: TREE_VIA_PROTECTED (t) = via_protected;
890: TREE_VIA_VIRTUAL (t) = via_virtual;
891: hashcode = list_hash (t);
892: t = list_hash_canon (hashcode, t);
893: current_obstack = ambient_obstack;
894: return t;
895: }
896:
897: /* Constructor for hashed lists. */
898: tree
899: hash_tree_chain (value, chain)
900: tree value, chain;
901: {
902: struct obstack *ambient_obstack = current_obstack;
903: tree t;
904: int hashcode;
905:
906: current_obstack = &class_obstack;
907: t = tree_cons (NULL_TREE, value, chain);
908: hashcode = list_hash (t);
909: t = list_hash_canon (hashcode, t);
910: current_obstack = ambient_obstack;
911: return t;
912: }
913:
914: /* Similar, but used for concatenating two lists. */
915: tree
916: hash_chainon (list1, list2)
917: tree list1, list2;
918: {
919: if (list2 == 0)
920: return list1;
921: if (list1 == 0)
922: return list2;
923: if (TREE_CHAIN (list1) == NULL_TREE)
924: return hash_tree_chain (TREE_VALUE (list1), list2);
925: return hash_tree_chain (TREE_VALUE (list1),
926: hash_chainon (TREE_CHAIN (list1), list2));
927: }
928:
929: tree
930: get_decl_list (value)
931: tree value;
932: {
933: tree list = NULL_TREE;
934:
935: if (TREE_CODE (value) == IDENTIFIER_NODE)
936: {
937: list = IDENTIFIER_AS_LIST (value);
938: if (list != NULL_TREE
939: && (TREE_CODE (list) != TREE_LIST
940: || TREE_VALUE (list) != value))
941: list = NULL_TREE;
942: else if (IDENTIFIER_HAS_TYPE_VALUE (value)
943: && TREE_CODE (IDENTIFIER_TYPE_VALUE (value)) == RECORD_TYPE)
944: {
945: register tree id;
946: tree type = IDENTIFIER_TYPE_VALUE (value);
947:
948: /* This will return the correct thing for regular types,
949: nested types, and templates. Yay! */
950: if (DECL_NESTED_TYPENAME (TYPE_NAME (type)))
951: value = DECL_NESTED_TYPENAME (TYPE_NAME (type));
952: id = value;
953:
954: if (CLASSTYPE_ID_AS_LIST (type) == NULL_TREE)
955: CLASSTYPE_ID_AS_LIST (type) = perm_tree_cons (NULL_TREE,
956: id, NULL_TREE);
957: list = CLASSTYPE_ID_AS_LIST (type);
958: }
959: }
960: else if (TREE_CODE (value) == RECORD_TYPE
961: && TYPE_LANG_SPECIFIC (value))
962: list = CLASSTYPE_AS_LIST (value);
963:
964: if (list != NULL_TREE)
965: {
966: my_friendly_assert (TREE_CHAIN (list) == NULL_TREE, 301);
967: return list;
968: }
969:
970: #ifdef OBJCPLUS
971: return build_tree_list (NULL_TREE, value);
972: #else
973: return build_decl_list (NULL_TREE, value);
974: #endif
975: }
976:
977: /* Look in the type hash table for a type isomorphic to
978: `build_tree_list (NULL_TREE, VALUE)'.
979: If one is found, return it. Otherwise return 0. */
980:
981: tree
982: list_hash_lookup_or_cons (value)
983: tree value;
984: {
985: register int hashcode = TYPE_HASH (value);
986: register struct list_hash *h;
987: struct obstack *ambient_obstack;
988: tree list = NULL_TREE;
989:
990: if (TREE_CODE (value) == IDENTIFIER_NODE)
991: {
992: list = IDENTIFIER_AS_LIST (value);
993: if (list != NULL_TREE
994: && (TREE_CODE (list) != TREE_LIST
995: || TREE_VALUE (list) != value))
996: list = NULL_TREE;
997: else if (IDENTIFIER_HAS_TYPE_VALUE (value)
998: && TREE_CODE (IDENTIFIER_TYPE_VALUE (value)) == RECORD_TYPE)
999: {
1000: /* If the type name and constructor name are different, don't
1001: write constructor name into type. */
1002: if (identifier_typedecl_value (value)
1003: && identifier_typedecl_value (value) != constructor_name (value))
1004: list = tree_cons (NULL_TREE, value, NULL_TREE);
1005: else
1006: {
1007: tree type = IDENTIFIER_TYPE_VALUE (value);
1008: if (CLASSTYPE_ID_AS_LIST (type) == NULL_TREE)
1009: {
1010: /* Not just `value', which could be a template parm. */
1011: tree id = DECL_NAME (TYPE_NAME (type));
1012: CLASSTYPE_ID_AS_LIST (type) =
1013: perm_tree_cons (NULL_TREE, id, NULL_TREE);
1014: }
1015: list = CLASSTYPE_ID_AS_LIST (type);
1016: }
1017: }
1018: }
1019: else if (TREE_CODE (value) == TYPE_DECL
1020: && TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE
1021: && TYPE_LANG_SPECIFIC (TREE_TYPE (value)))
1022: list = CLASSTYPE_ID_AS_LIST (TREE_TYPE (value));
1023: else if (TREE_CODE (value) == RECORD_TYPE
1024: && TYPE_LANG_SPECIFIC (value))
1025: list = CLASSTYPE_AS_LIST (value);
1026:
1027: if (list != NULL_TREE)
1028: {
1029: my_friendly_assert (TREE_CHAIN (list) == NULL_TREE, 302);
1030: return list;
1031: }
1032:
1033: if (debug_no_list_hash)
1034: return hash_tree_chain (value, NULL_TREE);
1035:
1036: for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
1037: if (h->hashcode == hashcode
1038: && TREE_VIA_VIRTUAL (h->list) == 0
1039: && TREE_VIA_PUBLIC (h->list) == 0
1040: && TREE_VIA_PROTECTED (h->list) == 0
1041: && TREE_PURPOSE (h->list) == 0
1042: && TREE_VALUE (h->list) == value)
1043: {
1044: my_friendly_assert (TREE_TYPE (h->list) == 0, 303);
1045: my_friendly_assert (TREE_CHAIN (h->list) == 0, 304);
1046: return h->list;
1047: }
1048:
1049: ambient_obstack = current_obstack;
1050: current_obstack = &class_obstack;
1051: list = build_tree_list (NULL_TREE, value);
1052: list_hash_add (hashcode, list);
1053: current_obstack = ambient_obstack;
1054: return list;
1055: }
1056:
1057: /* Build an association between TYPE and some parameters:
1058:
1059: OFFSET is the offset added to `this' to convert it to a pointer
1060: of type `TYPE *'
1061:
1062: VTABLE is the virtual function table with which to initialize
1063: sub-objects of type TYPE.
1064:
1065: VIRTUALS are the virtual functions sitting in VTABLE.
1066:
1067: CHAIN are more associations we must retain. */
1068:
1069: tree
1070: make_binfo (offset, type, vtable, virtuals, chain)
1071: tree offset, type;
1072: tree vtable, virtuals;
1073: tree chain;
1074: {
1075: tree binfo = make_tree_vec (6);
1076: tree old_binfo = TYPE_BINFO (type);
1077: tree last;
1078:
1079: TREE_CHAIN (binfo) = chain;
1080: if (chain)
1081: TREE_USED (binfo) = TREE_USED (chain);
1082:
1083: TREE_TYPE (binfo) = TYPE_MAIN_VARIANT (type);
1084: BINFO_OFFSET (binfo) = offset;
1085: BINFO_VTABLE (binfo) = vtable;
1086: BINFO_VIRTUALS (binfo) = virtuals;
1087: BINFO_VPTR_FIELD (binfo) = NULL_TREE;
1088:
1089: last = binfo;
1090: if (old_binfo != NULL_TREE
1091: && BINFO_BASETYPES (old_binfo) != NULL_TREE)
1092: {
1093: int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (type);
1094: tree binfos = TYPE_BINFO_BASETYPES (type);
1095:
1096: BINFO_BASETYPES (binfo) = make_tree_vec (n_baseclasses);
1097: for (i = 0; i < n_baseclasses; i++)
1098: {
1099: tree base_binfo = TREE_VEC_ELT (binfos, i);
1100: tree old_base_binfo = old_binfo ? BINFO_BASETYPE (old_binfo, i) : 0;
1101: BINFO_BASETYPE (binfo, i) = base_binfo;
1102: if (old_binfo)
1103: {
1104: TREE_VIA_PUBLIC (base_binfo) = TREE_VIA_PUBLIC (old_base_binfo);
1105: TREE_VIA_PROTECTED (base_binfo) = TREE_VIA_PROTECTED (old_base_binfo);
1106: TREE_VIA_VIRTUAL (base_binfo) = TREE_VIA_VIRTUAL (old_base_binfo);
1107: }
1108: }
1109: }
1110: return binfo;
1111: }
1112:
1113: tree
1114: copy_binfo (list)
1115: tree list;
1116: {
1117: tree binfo = copy_list (list);
1118: tree rval = binfo;
1119: while (binfo)
1120: {
1121: TREE_USED (binfo) = 0;
1122: if (BINFO_BASETYPES (binfo))
1123: BINFO_BASETYPES (binfo) = copy_node (BINFO_BASETYPES (binfo));
1124: binfo = TREE_CHAIN (binfo);
1125: }
1126: return rval;
1127: }
1128:
1129: /* Return the binfo value for ELEM in TYPE. */
1130:
1131: tree
1132: binfo_value (elem, type)
1133: tree elem;
1134: tree type;
1135: {
1136: if (get_base_distance (elem, type, 0, (tree *)0) == -2)
1137: compiler_error ("base class `%s' ambiguous in binfo_value",
1138: TYPE_NAME_STRING (elem));
1139: if (elem == type)
1140: return TYPE_BINFO (type);
1141: if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
1142: return type;
1143: return get_binfo (elem, type, 0);
1144: }
1145:
1146: tree
1147: reverse_path (path)
1148: tree path;
1149: {
1150: register tree prev = 0, tmp, next;
1151: for (tmp = path; tmp; tmp = next)
1152: {
1153: next = BINFO_INHERITANCE_CHAIN (tmp);
1154: BINFO_INHERITANCE_CHAIN (tmp) = prev;
1155: prev = tmp;
1156: }
1157: return prev;
1158: }
1159:
1160: tree
1161: virtual_member (elem, list)
1162: tree elem;
1163: tree list;
1164: {
1165: tree t;
1166: tree rval, nval;
1167:
1168: for (t = list; t; t = TREE_CHAIN (t))
1169: if (elem == BINFO_TYPE (t))
1170: return t;
1171: rval = 0;
1172: for (t = list; t; t = TREE_CHAIN (t))
1173: {
1174: tree binfos = BINFO_BASETYPES (t);
1175: int i;
1176:
1177: if (binfos != NULL_TREE)
1178: for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--)
1179: {
1180: nval = binfo_value (elem, BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
1181: if (nval)
1182: {
1183: if (rval && BINFO_OFFSET (nval) != BINFO_OFFSET (rval))
1184: my_friendly_abort (104);
1185: rval = nval;
1186: }
1187: }
1188: }
1189: return rval;
1190: }
1191:
1192: /* Return the offset (as an INTEGER_CST) for ELEM in LIST.
1193: INITIAL_OFFSET is the value to add to the offset that ELEM's
1194: binfo entry in LIST provides.
1195:
1196: Returns NULL if ELEM does not have an binfo value in LIST. */
1197:
1198: tree
1199: virtual_offset (elem, list, initial_offset)
1200: tree elem;
1201: tree list;
1202: tree initial_offset;
1203: {
1204: tree vb, offset;
1205: tree rval, nval;
1206:
1207: for (vb = list; vb; vb = TREE_CHAIN (vb))
1208: if (elem == BINFO_TYPE (vb))
1209: return size_binop (PLUS_EXPR, initial_offset, BINFO_OFFSET (vb));
1210: rval = 0;
1211: for (vb = list; vb; vb = TREE_CHAIN (vb))
1212: {
1213: tree binfos = BINFO_BASETYPES (vb);
1214: int i;
1215:
1216: if (binfos == NULL_TREE)
1217: continue;
1218:
1219: for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--)
1220: {
1221: nval = binfo_value (elem, BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
1222: if (nval)
1223: {
1224: if (rval && BINFO_OFFSET (nval) != BINFO_OFFSET (rval))
1225: my_friendly_abort (105);
1226: offset = BINFO_OFFSET (vb);
1227: rval = nval;
1228: }
1229: }
1230: }
1231: if (rval == NULL_TREE)
1232: return rval;
1233: return size_binop (PLUS_EXPR, offset, BINFO_OFFSET (rval));
1234: }
1235:
1236: void
1237: debug_binfo (elem)
1238: tree elem;
1239: {
1240: int i;
1241: tree virtuals;
1242:
1243: fprintf (stderr, "type \"%s\"; offset = %d\n",
1244: TYPE_NAME_STRING (BINFO_TYPE (elem)),
1245: TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1246: fprintf (stderr, "vtable type:\n");
1247: debug_tree (BINFO_TYPE (elem));
1248: if (BINFO_VTABLE (elem))
1249: fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
1250: else
1251: fprintf (stderr, "no vtable decl yet\n");
1252: fprintf (stderr, "virtuals:\n");
1253: virtuals = BINFO_VIRTUALS (elem);
1254: if (virtuals != 0)
1255: {
1256: virtuals = TREE_CHAIN (virtuals);
1257: if (flag_dossier)
1258: virtuals = TREE_CHAIN (virtuals);
1259: }
1260: i = 1;
1261: while (virtuals)
1262: {
1263: tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
1264: fprintf (stderr, "%s [%d =? %d]\n",
1265: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1266: i, TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1267: virtuals = TREE_CHAIN (virtuals);
1268: i += 1;
1269: }
1270: }
1271:
1272: /* Return the length of a chain of nodes chained through DECL_CHAIN.
1273: We expect a null pointer to mark the end of the chain.
1274: This is the Lisp primitive `length'. */
1275:
1276: int
1277: decl_list_length (t)
1278: tree t;
1279: {
1280: register tree tail;
1281: register int len = 0;
1282:
1283: my_friendly_assert (TREE_CODE (t) == FUNCTION_DECL, 300);
1284: for (tail = t; tail; tail = DECL_CHAIN (tail))
1285: len++;
1286:
1287: return len;
1288: }
1289:
1290: int
1291: count_functions (t)
1292: tree t;
1293: {
1294: if (TREE_CODE (t) == FUNCTION_DECL)
1295: return 1;
1296:
1297: return decl_list_length (TREE_VALUE (t));
1298: }
1299:
1300: tree
1301: fnaddr_from_vtable_entry (entry)
1302: tree entry;
1303: {
1304: return TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry))));
1305: }
1306:
1307: void
1308: set_fnaddr_from_vtable_entry (entry, value)
1309: tree entry, value;
1310: {
1311: TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry)))) = value;
1312: }
1313:
1314: tree
1315: function_arg_chain (t)
1316: tree t;
1317: {
1318: return TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (t)));
1319: }
1320:
1321: int
1322: promotes_to_aggr_type (t, code)
1323: tree t;
1324: enum tree_code code;
1325: {
1326: if (TREE_CODE (t) == code)
1327: t = TREE_TYPE (t);
1328: return IS_AGGR_TYPE (t);
1329: }
1330:
1331: int
1332: is_aggr_type_2 (t1, t2)
1333: tree t1, t2;
1334: {
1335: if (TREE_CODE (t1) != TREE_CODE (t2))
1336: return 0;
1337: return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
1338: }
1339:
1340: /* Give message using types TYPE1 and TYPE2 as arguments.
1341: PFN is the function which will print the message;
1342: S is the format string for PFN to use. */
1343: void
1344: message_2_types (pfn, s, type1, type2)
1345: void (*pfn) ();
1346: char *s;
1347: tree type1, type2;
1348: {
1349: tree name1 = TYPE_NAME (type1);
1350: tree name2 = TYPE_NAME (type2);
1351: if (TREE_CODE (name1) == TYPE_DECL)
1352: name1 = DECL_NAME (name1);
1353: if (TREE_CODE (name2) == TYPE_DECL)
1354: name2 = DECL_NAME (name2);
1355: (*pfn) (s, IDENTIFIER_POINTER (name1), IDENTIFIER_POINTER (name2));
1356: }
1357:
1358: #define PRINT_RING_SIZE 4
1359:
1360: char *
1361: lang_printable_name (decl)
1362: tree decl;
1363: {
1364: static tree decl_ring[PRINT_RING_SIZE];
1365: static char *print_ring[PRINT_RING_SIZE];
1366: static int ring_counter;
1367: int i;
1368:
1369: /* Only cache functions. */
1370: if (TREE_CODE (decl) != FUNCTION_DECL
1371: || DECL_LANG_SPECIFIC (decl) == 0)
1372: return decl_as_string (decl, 1);
1373:
1374: /* See if this print name is lying around. */
1375: for (i = 0; i < PRINT_RING_SIZE; i++)
1376: if (decl_ring[i] == decl)
1377: /* yes, so return it. */
1378: return print_ring[i];
1379:
1380: if (++ring_counter == PRINT_RING_SIZE)
1381: ring_counter = 0;
1382:
1383: if (current_function_decl != NULL_TREE)
1384: {
1385: if (decl_ring[ring_counter] == current_function_decl)
1386: ring_counter += 1;
1387: if (ring_counter == PRINT_RING_SIZE)
1388: ring_counter = 0;
1389: if (decl_ring[ring_counter] == current_function_decl)
1390: my_friendly_abort (106);
1391: }
1392:
1393: if (print_ring[ring_counter])
1394: free (print_ring[ring_counter]);
1395:
1396: {
1397: int print_ret_type_p
1398: = (!DECL_CONSTRUCTOR_P (decl)
1399: && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)));
1400:
1401: char *name = (char *)decl_as_string (decl, print_ret_type_p);
1402: print_ring[ring_counter] = (char *)malloc (strlen (name) + 1);
1403: strcpy (print_ring[ring_counter], name);
1404: decl_ring[ring_counter] = decl;
1405: }
1406: return print_ring[ring_counter];
1407: }
1408:
1409: /* Comparison function for sorting identifiers in RAISES lists.
1410: Note that because IDENTIFIER_NODEs are unique, we can sort
1411: them by address, saving an indirection. */
1412: static int
1413: id_cmp (p1, p2)
1414: tree *p1, *p2;
1415: {
1416: return (HOST_WIDE_INT)TREE_VALUE (*p1) - (HOST_WIDE_INT)TREE_VALUE (*p2);
1417: }
1418:
1419: /* Build the FUNCTION_TYPE or METHOD_TYPE which may raise exceptions
1420: listed in RAISES. */
1421: tree
1422: build_exception_variant (ctype, type, raises)
1423: tree ctype, type;
1424: tree raises;
1425: {
1426: int i;
1427: tree v = TYPE_MAIN_VARIANT (type);
1428: tree t, t2, cname;
1429: tree *a = (tree *)alloca ((list_length (raises)+1) * sizeof (tree));
1430: int constp = TYPE_READONLY (type);
1431: int volatilep = TYPE_VOLATILE (type);
1432:
1433: if (raises && TREE_CHAIN (raises))
1434: {
1435: for (i = 0, t = raises; t; t = TREE_CHAIN (t), i++)
1436: a[i] = t;
1437: /* NULL terminator for list. */
1438: a[i] = NULL_TREE;
1439: qsort (a, i, sizeof (tree), id_cmp);
1440: while (i--)
1441: TREE_CHAIN (a[i]) = a[i+1];
1442: raises = a[0];
1443: }
1444: else if (raises)
1445: /* do nothing. */;
1446: else
1447: return build_type_variant (v, constp, volatilep);
1448:
1449: if (ctype)
1450: {
1451: cname = TYPE_NAME (ctype);
1452: if (TREE_CODE (cname) == TYPE_DECL)
1453: cname = DECL_NAME (cname);
1454: }
1455: else
1456: cname = NULL_TREE;
1457:
1458: for (t = raises; t; t = TREE_CHAIN (t))
1459: {
1460: /* See that all the exceptions we are thinking about
1461: raising have been declared. */
1462: tree this_cname = lookup_exception_cname (ctype, cname, t);
1463: tree decl = lookup_exception_object (this_cname, TREE_VALUE (t), 1);
1464:
1465: if (decl == NULL_TREE)
1466: decl = lookup_exception_object (this_cname, TREE_VALUE (t), 0);
1467: /* Place canonical exception decl into TREE_TYPE of RAISES list. */
1468: TREE_TYPE (t) = decl;
1469: }
1470:
1471: for (v = TYPE_NEXT_VARIANT (v); v; v = TYPE_NEXT_VARIANT (v))
1472: {
1473: if (TYPE_READONLY (v) != constp
1474: || TYPE_VOLATILE (v) != volatilep)
1475: continue;
1476:
1477: t = raises;
1478: t2 = TYPE_RAISES_EXCEPTIONS (v);
1479: while (t && t2)
1480: {
1481: if (TREE_TYPE (t) == TREE_TYPE (t2))
1482: {
1483: t = TREE_CHAIN (t);
1484: t2 = TREE_CHAIN (t2);
1485: }
1486: else break;
1487: }
1488: if (t || t2)
1489: continue;
1490: /* List of exceptions raised matches previously found list.
1491:
1492: @@ Nice to free up storage used in consing up the
1493: @@ list of exceptions raised. */
1494: return v;
1495: }
1496:
1497: /* Need to build a new variant. */
1498: v = copy_node (type);
1499: TYPE_NEXT_VARIANT (v) = TYPE_NEXT_VARIANT (type);
1500: TYPE_NEXT_VARIANT (type) = v;
1501: if (raises && ! TREE_PERMANENT (raises))
1502: {
1503: push_obstacks_nochange ();
1504: end_temporary_allocation ();
1505: raises = copy_list (raises);
1506: pop_obstacks ();
1507: }
1508: TYPE_RAISES_EXCEPTIONS (v) = raises;
1509: return v;
1510: }
1511:
1512: /* Subroutine of copy_to_permanent
1513:
1514: Assuming T is a node build bottom-up, make it all exist on
1515: permanent obstack, if it is not permanent already. */
1516: static tree
1517: make_deep_copy (t)
1518: tree t;
1519: {
1520: enum tree_code code;
1521:
1522: if (t == NULL_TREE || TREE_PERMANENT (t))
1523: return t;
1524:
1525: switch (code = TREE_CODE (t))
1526: {
1527: case ERROR_MARK:
1528: return error_mark_node;
1529:
1530: case VAR_DECL:
1531: case FUNCTION_DECL:
1532: case CONST_DECL:
1533: break;
1534:
1535: case PARM_DECL:
1536: {
1537: tree chain = TREE_CHAIN (t);
1538: t = copy_node (t);
1539: TREE_CHAIN (t) = make_deep_copy (chain);
1540: TREE_TYPE (t) = make_deep_copy (TREE_TYPE (t));
1541: DECL_INITIAL (t) = make_deep_copy (DECL_INITIAL (t));
1542: DECL_SIZE (t) = make_deep_copy (DECL_SIZE (t));
1543: return t;
1544: }
1545:
1546: case TREE_LIST:
1547: {
1548: tree chain = TREE_CHAIN (t);
1549: t = copy_node (t);
1550: TREE_PURPOSE (t) = make_deep_copy (TREE_PURPOSE (t));
1551: TREE_VALUE (t) = make_deep_copy (TREE_VALUE (t));
1552: TREE_CHAIN (t) = make_deep_copy (chain);
1553: return t;
1554: }
1555:
1556: case TREE_VEC:
1557: {
1558: int len = TREE_VEC_LENGTH (t);
1559:
1560: t = copy_node (t);
1561: while (len--)
1562: TREE_VEC_ELT (t, len) = make_deep_copy (TREE_VEC_ELT (t, len));
1563: return t;
1564: }
1565:
1566: case INTEGER_CST:
1567: case REAL_CST:
1568: case STRING_CST:
1569: return copy_node (t);
1570:
1571: case COND_EXPR:
1572: case TARGET_EXPR:
1573: case NEW_EXPR:
1574: t = copy_node (t);
1575: TREE_OPERAND (t, 0) = make_deep_copy (TREE_OPERAND (t, 0));
1576: TREE_OPERAND (t, 1) = make_deep_copy (TREE_OPERAND (t, 1));
1577: TREE_OPERAND (t, 2) = make_deep_copy (TREE_OPERAND (t, 2));
1578: return t;
1579:
1580: case SAVE_EXPR:
1581: t = copy_node (t);
1582: TREE_OPERAND (t, 0) = make_deep_copy (TREE_OPERAND (t, 0));
1583: return t;
1584:
1585: case MODIFY_EXPR:
1586: case PLUS_EXPR:
1587: case MINUS_EXPR:
1588: case MULT_EXPR:
1589: case TRUNC_DIV_EXPR:
1590: case TRUNC_MOD_EXPR:
1591: case MIN_EXPR:
1592: case MAX_EXPR:
1593: case LSHIFT_EXPR:
1594: case RSHIFT_EXPR:
1595: case BIT_IOR_EXPR:
1596: case BIT_XOR_EXPR:
1597: case BIT_AND_EXPR:
1598: case BIT_ANDTC_EXPR:
1599: case TRUTH_ANDIF_EXPR:
1600: case TRUTH_ORIF_EXPR:
1601: case LT_EXPR:
1602: case LE_EXPR:
1603: case GT_EXPR:
1604: case GE_EXPR:
1605: case EQ_EXPR:
1606: case NE_EXPR:
1607: case CEIL_DIV_EXPR:
1608: case FLOOR_DIV_EXPR:
1609: case ROUND_DIV_EXPR:
1610: case CEIL_MOD_EXPR:
1611: case FLOOR_MOD_EXPR:
1612: case ROUND_MOD_EXPR:
1613: case COMPOUND_EXPR:
1614: case PREDECREMENT_EXPR:
1615: case PREINCREMENT_EXPR:
1616: case POSTDECREMENT_EXPR:
1617: case POSTINCREMENT_EXPR:
1618: case CALL_EXPR:
1619: t = copy_node (t);
1620: TREE_OPERAND (t, 0) = make_deep_copy (TREE_OPERAND (t, 0));
1621: TREE_OPERAND (t, 1) = make_deep_copy (TREE_OPERAND (t, 1));
1622: return t;
1623:
1624: case CONVERT_EXPR:
1625: case ADDR_EXPR:
1626: case INDIRECT_REF:
1627: case NEGATE_EXPR:
1628: case BIT_NOT_EXPR:
1629: case TRUTH_NOT_EXPR:
1630: case NOP_EXPR:
1631: case COMPONENT_REF:
1632: t = copy_node (t);
1633: TREE_OPERAND (t, 0) = make_deep_copy (TREE_OPERAND (t, 0));
1634: return t;
1635:
1636: /* This list is incomplete, but should suffice for now.
1637: It is very important that `sorry' does not call
1638: `report_error_function'. That could cause an infinite loop. */
1639: default:
1640: sorry ("initializer contains unrecognized tree code");
1641: return error_mark_node;
1642:
1643: }
1644: my_friendly_abort (107);
1645: /* NOTREACHED */
1646: return NULL_TREE;
1647: }
1648:
1649: /* Assuming T is a node built bottom-up, make it all exist on
1650: permanent obstack, if it is not permanent already. */
1651: tree
1652: copy_to_permanent (t)
1653: tree t;
1654: {
1655: register struct obstack *ambient_obstack = current_obstack;
1656: register struct obstack *ambient_saveable_obstack = saveable_obstack;
1657:
1658: if (t == NULL_TREE || TREE_PERMANENT (t))
1659: return t;
1660:
1661: saveable_obstack = &permanent_obstack;
1662: current_obstack = saveable_obstack;
1663:
1664: t = make_deep_copy (t);
1665:
1666: current_obstack = ambient_obstack;
1667: saveable_obstack = ambient_saveable_obstack;
1668:
1669: return t;
1670: }
1671:
1672: void
1673: print_lang_statistics ()
1674: {
1675: extern struct obstack maybepermanent_obstack;
1676: print_obstack_statistics ("class_obstack", &class_obstack);
1677: print_obstack_statistics ("permanent_obstack", &permanent_obstack);
1678: print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack);
1679: print_search_statistics ();
1680: print_class_statistics ();
1681: }
1682:
1683: /* This is used by the `assert' macro. It is provided in libgcc.a,
1684: which `cc' doesn't know how to link. Note that the C++ front-end
1685: no longer actually uses the `assert' macro (instead, it calls
1686: my_friendly_assert). But all of the back-end files still need this. */
1687: void
1688: __eprintf (string, expression, line, filename)
1689: #ifdef __STDC__
1690: const char *string;
1691: const char *expression;
1692: unsigned line;
1693: const char *filename;
1694: #else
1695: char *string;
1696: char *expression;
1697: unsigned line;
1698: char *filename;
1699: #endif
1700: {
1701: fprintf (stderr, string, expression, line, filename);
1702: fflush (stderr);
1703: abort ();
1704: }
1705:
1706: /* Return, as an INTEGER_CST node, the number of elements for
1707: TYPE (which is an ARRAY_TYPE). This counts only elements of the top array. */
1708:
1709: tree
1710: array_type_nelts_top (type)
1711: tree type;
1712: {
1713: return fold (build (PLUS_EXPR, integer_type_node,
1714: array_type_nelts (type),
1715: integer_one_node));
1716: }
1717:
1718: /* Return, as an INTEGER_CST node, the number of elements for
1719: TYPE (which is an ARRAY_TYPE). This one is a recursive count of all
1720: ARRAY_TYPEs that are clumped together. */
1721:
1722: tree
1723: array_type_nelts_total (type)
1724: tree type;
1725: {
1726: tree sz = array_type_nelts_top (type);
1727: type = TREE_TYPE (type);
1728: while (TREE_CODE (type) == ARRAY_TYPE)
1729: {
1730: tree n = array_type_nelts_top (type);
1731: sz = fold (build (MULT_EXPR, integer_type_node, sz, n));
1732: type = TREE_TYPE (type);
1733: }
1734: return sz;
1735: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.