![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gc.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 gc.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 root 1: /* Garbage collection primitives for GNU C++.
2: Copyright (C) 1992, 1993 Free Software Foundation, Inc.
3: Contributed by Michael Tiemann ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: #include "config.h"
23: #include "tree.h"
24: #include "cp-tree.h"
25: #include "flags.h"
26:
27: #undef NULL
28: #define NULL 0
29:
30: extern tree define_function ();
31: extern tree build_t_desc_overload ();
32:
33: /* This is the function decl for the (pseudo-builtin) __gc_protect
34: function. Args are (class *value, int index); Returns value. */
35: tree gc_protect_fndecl;
36:
37: /* This is the function decl for the (pseudo-builtin) __gc_unprotect
38: function. Args are (int index); void return. */
39: tree gc_unprotect_fndecl;
40:
41: /* This is the function decl for the (pseudo-builtin) __gc_push
42: function. Args are (int length); void return. */
43: tree gc_push_fndecl;
44:
45: /* This is the function decl for the (pseudo-builtin) __gc_pop
46: function. Args are void; void return. */
47: tree gc_pop_fndecl;
48:
49: /* Special integers that are used to represent bits in gc-safe objects. */
50: tree gc_nonobject;
51: tree gc_visible;
52: tree gc_white;
53: tree gc_offwhite;
54: tree gc_grey;
55: tree gc_black;
56:
57: /* in c-common.c */
58: extern tree combine_strings PROTO((tree));
59:
60: /* Predicate that returns non-zero if TYPE needs some kind of
61: entry for the GC. Returns zero otherwise. */
62: int
63: type_needs_gc_entry (type)
64: tree type;
65: {
66: tree ttype = type;
67:
68: if (! flag_gc || type == error_mark_node)
69: return 0;
70:
71: /* Aggregate types need gc entries if any of their members
72: need gc entries. */
73: if (IS_AGGR_TYPE (type))
74: {
75: tree binfos;
76: tree fields = TYPE_FIELDS (type);
77: int i;
78:
79: /* We don't care about certain pointers. Pointers
80: to virtual baseclasses are always up front. We also
81: cull out virtual function table pointers because it's
82: easy, and it simplifies the logic.*/
83: while (fields
84: && (DECL_NAME (fields) == NULL_TREE
85: || VFIELD_NAME_P (DECL_NAME (fields))
86: || VBASE_NAME_P (DECL_NAME (fields))
87: || !strcmp (IDENTIFIER_POINTER (DECL_NAME (fields)), "__bits")))
88: fields = TREE_CHAIN (fields);
89:
90: while (fields)
91: {
92: if (type_needs_gc_entry (TREE_TYPE (fields)))
93: return 1;
94: fields = TREE_CHAIN (fields);
95: }
96:
97: binfos = TYPE_BINFO_BASETYPES (type);
98: if (binfos)
99: for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--)
100: if (type_needs_gc_entry (BINFO_TYPE (TREE_VEC_ELT (binfos, i))))
101: return 1;
102:
103: return 0;
104: }
105:
106: while (TREE_CODE (ttype) == ARRAY_TYPE
107: && TREE_CODE (TREE_TYPE (ttype)) == ARRAY_TYPE)
108: ttype = TREE_TYPE (ttype);
109: if ((TREE_CODE (ttype) == POINTER_TYPE
110: || TREE_CODE (ttype) == ARRAY_TYPE
111: || TREE_CODE (ttype) == REFERENCE_TYPE)
112: && IS_AGGR_TYPE (TREE_TYPE (ttype))
113: && CLASSTYPE_DOSSIER (TREE_TYPE (ttype)))
114: return 1;
115:
116: return 0;
117: }
118:
119: /* Predicate that returns non-zero iff FROM is safe from the GC.
120:
121: If TO is nonzero, it means we know that FROM is being stored
122: in TO, which make make it safe. */
123: int
124: value_safe_from_gc (to, from)
125: tree to, from;
126: {
127: /* First, return non-zero for easy cases: parameters,
128: static variables. */
129: if (TREE_CODE (from) == PARM_DECL
130: || (TREE_CODE (from) == VAR_DECL
131: && TREE_STATIC (from)))
132: return 1;
133:
134: /* If something has its address taken, it cannot be
135: in the heap, so it doesn't need to be protected. */
136: if (TREE_CODE (from) == ADDR_EXPR || TREE_REFERENCE_EXPR (from))
137: return 1;
138:
139: /* If we are storing into a static variable, then what
140: we store will be safe from the gc. */
141: if (to && TREE_CODE (to) == VAR_DECL
142: && TREE_STATIC (to))
143: return 1;
144:
145: /* Now recurse on structure of FROM. */
146: switch (TREE_CODE (from))
147: {
148: case COMPONENT_REF:
149: /* These guys are special, and safe. */
150: if (TREE_CODE (TREE_OPERAND (from, 1)) == FIELD_DECL
151: && (VFIELD_NAME_P (DECL_NAME (TREE_OPERAND (from, 1)))
152: || VBASE_NAME_P (DECL_NAME (TREE_OPERAND (from, 1)))))
153: return 1;
154: /* fall through... */
155: case NOP_EXPR:
156: case CONVERT_EXPR:
157: case NON_LVALUE_EXPR:
158: case WITH_CLEANUP_EXPR:
159: case SAVE_EXPR:
160: case PREDECREMENT_EXPR:
161: case PREINCREMENT_EXPR:
162: case POSTDECREMENT_EXPR:
163: case POSTINCREMENT_EXPR:
164: if (value_safe_from_gc (to, TREE_OPERAND (from, 0)))
165: return 1;
166: break;
167:
168: case VAR_DECL:
169: case PARM_DECL:
170: /* We can safely pass these things as parameters to functions. */
171: if (to == 0)
172: return 1;
173:
174: case ARRAY_REF:
175: case INDIRECT_REF:
176: case RESULT_DECL:
177: case OFFSET_REF:
178: case CALL_EXPR:
179: case METHOD_CALL_EXPR:
180: break;
181:
182: case COMPOUND_EXPR:
183: case TARGET_EXPR:
184: if (value_safe_from_gc (to, TREE_OPERAND (from, 1)))
185: return 1;
186: break;
187:
188: case COND_EXPR:
189: if (value_safe_from_gc (to, TREE_OPERAND (from, 1))
190: && value_safe_from_gc (to, TREE_OPERAND (from, 2)))
191: return 1;
192: break;
193:
194: case PLUS_EXPR:
195: case MINUS_EXPR:
196: if ((type_needs_gc_entry (TREE_TYPE (TREE_OPERAND (from, 0)))
197: || value_safe_from_gc (to, TREE_OPERAND (from, 0)))
198: && (type_needs_gc_entry (TREE_TYPE (TREE_OPERAND (from, 1))) == 0
199: || value_safe_from_gc (to, TREE_OPERAND (from, 1))))
200: return 1;
201: break;
202:
203: case RTL_EXPR:
204: /* Every time we build an RTL_EXPR in the front-end, we must
205: ensure that everything in it is safe from the garbage collector.
206: ??? This has only been done for `build_new'. */
207: return 1;
208:
209: default:
210: my_friendly_abort (41);
211: }
212:
213: if (to == 0)
214: return 0;
215:
216: /* FROM wasn't safe. But other properties of TO might make it safe. */
217: switch (TREE_CODE (to))
218: {
219: case VAR_DECL:
220: case PARM_DECL:
221: /* We already culled out static VAR_DECLs above. */
222: return 0;
223:
224: case COMPONENT_REF:
225: /* These guys are special, and safe. */
226: if (TREE_CODE (TREE_OPERAND (to, 1)) == FIELD_DECL
227: && (VFIELD_NAME_P (DECL_NAME (TREE_OPERAND (to, 1)))
228: || VBASE_NAME_P (DECL_NAME (TREE_OPERAND (to, 1)))))
229: return 1;
230: /* fall through... */
231:
232: case NOP_EXPR:
233: case NON_LVALUE_EXPR:
234: case WITH_CLEANUP_EXPR:
235: case SAVE_EXPR:
236: case PREDECREMENT_EXPR:
237: case PREINCREMENT_EXPR:
238: case POSTDECREMENT_EXPR:
239: case POSTINCREMENT_EXPR:
240: return value_safe_from_gc (TREE_OPERAND (to, 0), from);
241:
242: case COMPOUND_EXPR:
243: case TARGET_EXPR:
244: return value_safe_from_gc (TREE_OPERAND (to, 1), from);
245:
246: case COND_EXPR:
247: return (value_safe_from_gc (TREE_OPERAND (to, 1), from)
248: && value_safe_from_gc (TREE_OPERAND (to, 2), from));
249:
250: case INDIRECT_REF:
251: case ARRAY_REF:
252: /* This used to be 0, but our current restricted model
253: allows this to be 1. We'll never get arrays this way. */
254: return 1;
255:
256: default:
257: my_friendly_abort (42);
258: }
259:
260: /* Catch-all case is that TO/FROM is not safe. */
261: return 0;
262: }
263:
264: /* Function to build a static GC entry for DECL. TYPE is DECL's type.
265:
266: For objects of type `class *', this is just an entry in the
267: static vector __PTR_LIST__.
268:
269: For objects of type `class[]', this requires building an entry
270: in the static vector __ARR_LIST__.
271:
272: For aggregates, this records all fields of type `class *'
273: and `class[]' in the respective lists above. */
274: void
275: build_static_gc_entry (decl, type)
276: tree decl;
277: tree type;
278: {
279: /* Now, figure out what sort of entry to build. */
280: if (TREE_CODE (type) == POINTER_TYPE
281: || TREE_CODE (type) == REFERENCE_TYPE)
282: assemble_gc_entry (IDENTIFIER_POINTER (DECL_NAME (decl)));
283: else if (TREE_CODE (type) == RECORD_TYPE)
284: {
285: tree ref = get_temp_name (build_reference_type (type), 1);
286: DECL_INITIAL (ref) = build1 (ADDR_EXPR, TREE_TYPE (ref), decl);
287: TREE_CONSTANT (DECL_INITIAL (ref)) = 1;
288: finish_decl (ref, DECL_INITIAL (ref), 0, 0);
289: }
290: else
291: {
292: /* Not yet implemented.
293:
294: Cons up a static variable that holds address and length info
295: and add that to ___ARR_LIST__. */
296: my_friendly_abort (43);
297: }
298: }
299:
300: /* Protect FROM from the GC, assuming FROM is going to be
301: stored into TO. We handle three cases for TO here:
302:
303: case 1: TO is a stack variable.
304: case 2: TO is zero (which means it is a parameter).
305: case 3: TO is a return value. */
306:
307: tree
308: protect_value_from_gc (to, from)
309: tree to, from;
310: {
311: if (to == 0)
312: {
313: tree cleanup;
314:
315: to = get_temp_regvar (TREE_TYPE (from), from);
316:
317: /* Convert from integer to list form since we'll use it twice. */
318: DECL_GC_OFFSET (to) = build_tree_list (NULL_TREE, DECL_GC_OFFSET (to));
319: cleanup = build_function_call (gc_unprotect_fndecl,
320: DECL_GC_OFFSET (to));
321:
322: if (! expand_decl_cleanup (to, cleanup))
323: {
324: compiler_error ("cannot unprotect parameter in this scope");
325: return error_mark_node;
326: }
327: }
328:
329: /* Should never need to protect a value that's headed for static storage. */
330: if (TREE_STATIC (to))
331: my_friendly_abort (44);
332:
333: switch (TREE_CODE (to))
334: {
335: case COMPONENT_REF:
336: case INDIRECT_REF:
337: return protect_value_from_gc (TREE_OPERAND (to, 0), from);
338:
339: case VAR_DECL:
340: case PARM_DECL:
341: {
342: tree rval;
343: if (DECL_GC_OFFSET (to) == NULL_TREE)
344: {
345: /* Because of a cast or a conversion, we might stick
346: a value into a variable that would not normally
347: have a GC entry. */
348: DECL_GC_OFFSET (to) = size_int (++current_function_obstack_index);
349: }
350:
351: if (TREE_CODE (DECL_GC_OFFSET (to)) != TREE_LIST)
352: {
353: DECL_GC_OFFSET (to)
354: = build_tree_list (NULL_TREE, DECL_GC_OFFSET (to));
355: }
356:
357: current_function_obstack_usage = 1;
358: rval = build_function_call (gc_protect_fndecl,
359: tree_cons (NULL_TREE, from,
360: DECL_GC_OFFSET (to)));
361: TREE_TYPE (rval) = TREE_TYPE (from);
362: return rval;
363: }
364: }
365:
366: /* If we fall through the switch, assume we lost. */
367: my_friendly_abort (45);
368: /* NOTREACHED */
369: return NULL_TREE;
370: }
371:
372: /* Given the expression EXP of type `class *', return the head
373: of the object pointed to by EXP. */
374: tree
375: build_headof (exp)
376: tree exp;
377: {
378: tree type = TREE_TYPE (exp);
379: tree vptr, offset;
380:
381: if (TREE_CODE (type) != POINTER_TYPE)
382: {
383: error ("`headof' applied to non-pointer type");
384: return error_mark_node;
385: }
386:
387: if (flag_vtable_thunks)
388: abort();
389:
390: vptr = build1 (INDIRECT_REF, TYPE_POINTER_TO (vtable_entry_type), exp);
391: offset = build_component_ref (build_array_ref (vptr, integer_one_node),
392: get_identifier (VTABLE_DELTA_NAME),
393: NULL_TREE, 0);
394: return build (PLUS_EXPR, class_star_type_node, exp,
395: convert (integer_type_node, offset));
396: }
397:
398: /* Given the expression EXP of type `class *', return the
399: type descriptor for the object pointed to by EXP. */
400: tree
401: build_classof (exp)
402: tree exp;
403: {
404: tree type = TREE_TYPE (exp);
405: tree vptr;
406: tree t_desc_entry;
407:
408: if (TREE_CODE (type) != POINTER_TYPE)
409: {
410: error ("`classof' applied to non-pointer type");
411: return error_mark_node;
412: }
413:
414: vptr = build1 (INDIRECT_REF, TYPE_POINTER_TO (vtable_entry_type), exp);
415: t_desc_entry = build_component_ref (build_array_ref (vptr, integer_one_node),
416: get_identifier (VTABLE_PFN_NAME),
417: NULL_TREE, 0);
418: TREE_TYPE (t_desc_entry) = TYPE_POINTER_TO (__t_desc_type_node);
419: return t_desc_entry;
420: }
421:
422: /* Return the Type_info node associated with the expression EXP. If EXP is
423: a reference to a polymorphic class, return the dynamic type; otherwise
424: return the static type of the expression. */
425: tree
426: build_typeid (exp)
427: tree exp;
428: {
429: tree type;
430:
431: if (exp == error_mark_node)
432: return error_mark_node;
433:
434: type = TREE_TYPE (exp);
435:
436: /* if b is an instance of B, typeid(b) == typeid(B). Do this before
437: reference trickiness. */
438: if (TREE_CODE (exp) == VAR_DECL && TREE_CODE (type) == RECORD_TYPE)
439: return get_typeid (type);
440:
441: /* Apply trivial conversion T -> T& for dereferenced ptrs. */
442: if (TREE_CODE (type) == RECORD_TYPE)
443: type = build_reference_type (type);
444:
445: /* If exp is a reference to polymorphic type, get the real Type_info. */
446: if (TREE_CODE (type) == REFERENCE_TYPE && TYPE_VIRTUAL_P (TREE_TYPE (type)))
447: {
448: /* build reference to Type_info from vtable. */
449:
450: sorry ("finding Type_info for an object");
451: return error_mark_node;
452: }
453:
454: /* otherwise return the Type_info for the static type of the expr. */
455: return get_typeid (type);
456: }
457:
458: /* Return the Type_info object for TYPE, creating it if necessary. */
459: tree
460: get_typeid (type)
461: tree type;
462: {
463: if (type == error_mark_node)
464: return error_mark_node;
465:
466: /* Is it useful (and/or correct) to have different typeids for `T &'
467: and `T'? */
468: if (TREE_CODE (type) == REFERENCE_TYPE)
469: type = TREE_TYPE (type);
470:
471: /* build reference to static Type_info */
472: #if 1
473: sorry ("finding Type_info for a type");
474: return error_mark_node;
475: #else
476: register tree t = TYPE_TINFO (type);
477:
478: if (t)
479: return t;
480:
481: /* ... */
482:
483: #endif
484: }
485:
486: /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
487: paper. */
488: tree
489: build_dynamic_cast (type, expr)
490: tree type, expr;
491: {
492: enum tree_code tc = TREE_CODE (type);
493: tree exprtype = TREE_TYPE (expr);
494: enum tree_code ec = TREE_CODE (exprtype);
495: tree retval;
496:
497: if (type == error_mark_node || expr == error_mark_node)
498: return error_mark_node;
499:
500: switch (tc)
501: {
502: case POINTER_TYPE:
503: if (TREE_TYPE (type) == void_type_node)
504: break;
505: /* else fall through */
506: case REFERENCE_TYPE:
507: if (TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
508: && TYPE_SIZE (TREE_TYPE (type)) != NULL_TREE)
509: break;
510: /* else fall through */
511: default:
512: cp_error ("`%#T' is not a valid type argument for dynamic_cast", type);
513: error ("(must be either pointer or reference to defined class or void *)");
514: return error_mark_node;
515: }
516:
517: /* Apply trivial conversion T -> T& for dereferenced ptrs. */
518: if (ec == RECORD_TYPE)
519: {
520: exprtype = build_reference_type (exprtype);
521: ec = REFERENCE_TYPE;
522: }
523:
524: /* the TREE_CODE of exprtype must match that of type. */
525: if (ec != tc)
526: {
527: cp_error ("`%E' (of type `%#T') fails to be of %s type", expr, exprtype,
528: tc == POINTER_TYPE ? "pointer" : "reference");
529: return error_mark_node;
530: }
531:
532: /* If *type is an unambiguous accessible base class of *exprtype,
533: convert statically. */
534: {
535: int distance;
536: tree path;
537:
538: distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
539: &path);
540: if (distance >= 0)
541: return build_vbase_path (PLUS_EXPR, type, expr, path, 0);
542: }
543:
544: /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
545: if (TYPE_VIRTUAL_P (TREE_TYPE (exprtype)))
546: {
547: /* if TYPE is `void *', return pointer to complete object. */
548: if (tc == POINTER_TYPE && TREE_TYPE (type) == void_type_node)
549: {
550: /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
551: if (TREE_CODE (expr) == ADDR_EXPR
552: && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
553: && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
554: return build1 (NOP_EXPR, type, expr);
555:
556: sorry ("finding pointer to complete object");
557: return build1 (NOP_EXPR, type, expr);
558: }
559: else
560: {
561: tree retval;
562:
563: /* If we got here, we can't convert statically. Therefore,
564: dynamic_cast<D&>(b) (b an object) cannot succeed. */
565: if (ec == REFERENCE_TYPE)
566: {
567: if (TREE_CODE (expr) == VAR_DECL
568: && TREE_CODE (TREE_TYPE (expr)) == RECORD_TYPE)
569: {
570: cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
571: expr, type);
572: /* cplus_expand_throw (Bad_cast_node); */
573: sorry ("throwing Bad_cast");
574: return error_mark_node;
575: }
576: }
577: /* Ditto for dynamic_cast<D*>(&b). */
578: else if (TREE_CODE (expr) == ADDR_EXPR)
579: {
580: tree op = TREE_OPERAND (expr, 0);
581: if (TREE_CODE (op) == VAR_DECL
582: && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
583: {
584: cp_warning ("dynamic_cast of `%E' to `%#T' can never succeed",
585: expr, type);
586: retval = build_int_2 (0, 0);
587: TREE_TYPE (retval) = type;
588: return retval;
589: }
590: }
591: /* Build run-time conversion. */
592: sorry ("run-time type conversion");
593: retval = build_int_2 (0, 0);
594: TREE_TYPE (retval) = type;
595: return retval;
596: }
597: }
598:
599: cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T'",
600: expr, exprtype, type);
601: return error_mark_node;
602: }
603:
604: /* Build and initialize various sorts of descriptors. Every descriptor
605: node has a name associated with it (the name created by mangling).
606: For this reason, we use the identifier as our access to the __*_desc
607: nodes, instead of sticking them directly in the types. Otherwise we
608: would burden all built-in types (and pointer types) with slots that
609: we don't necessarily want to use.
610:
611: For each descriptor we build, we build a variable that contains
612: the descriptor's information. When we need this info at runtime,
613: all we need is access to these variables.
614:
615: Note: these constructors always return the address of the descriptor
616: info, since that is simplest for their mutual interaction. */
617:
618: static tree
619: build_generic_desc (decl, elems)
620: tree decl;
621: tree elems;
622: {
623: tree init = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE, elems);
624: TREE_CONSTANT (init) = 1;
625: TREE_STATIC (init) = 1;
626: TREE_READONLY (init) = 1;
627:
628: DECL_INITIAL (decl) = init;
629: TREE_STATIC (decl) = 1;
630: layout_decl (decl, 0);
631: finish_decl (decl, init, 0, 0);
632:
633: return IDENTIFIER_AS_DESC (DECL_NAME (decl));
634: }
635:
636: /* Build an initializer for a __t_desc node. So that we can take advantage
637: of recursion, we accept NULL for TYPE.
638: DEFINITION is greater than zero iff we must define the type descriptor
639: (as opposed to merely referencing it). 1 means treat according to
640: #pragma interface/#pragma implementation rules. 2 means define as
641: global and public, no matter what. */
642: tree
643: build_t_desc (type, definition)
644: tree type;
645: int definition;
646: {
647: tree tdecl;
648: tree tname, name_string;
649: tree elems, fields;
650: tree parents, vbases, offsets, ivars, methods, target_type;
651: int method_count = 0, field_count = 0;
652:
653: if (type == NULL_TREE)
654: return NULL_TREE;
655:
656: tname = build_t_desc_overload (type);
657: if (IDENTIFIER_AS_DESC (tname)
658: && (!definition || TREE_ASM_WRITTEN (IDENTIFIER_AS_DESC (tname))))
659: return IDENTIFIER_AS_DESC (tname);
660:
661: tdecl = lookup_name (tname, 0);
662: if (tdecl == NULL_TREE)
663: {
664: tdecl = build_decl (VAR_DECL, tname, __t_desc_type_node);
665: DECL_EXTERNAL (tdecl) = 1;
666: TREE_PUBLIC (tdecl) = 1;
667: tdecl = pushdecl_top_level (tdecl);
668: }
669: /* If we previously defined it, return the defined result. */
670: else if (definition && DECL_INITIAL (tdecl))
671: return IDENTIFIER_AS_DESC (tname);
672:
673: if (definition)
674: {
675: tree taggr = type;
676: /* Let T* and T& be written only when T is written (if T is an aggr).
677: We do this for const, but not for volatile, since volatile
678: is rare and const is not. */
679: if (!TYPE_VOLATILE (taggr)
680: && (TREE_CODE (taggr) == POINTER_TYPE
681: || TREE_CODE (taggr) == REFERENCE_TYPE)
682: && IS_AGGR_TYPE (TREE_TYPE (taggr)))
683: taggr = TREE_TYPE (taggr);
684:
685: /* If we know that we don't need to write out this type's
686: vtable, then don't write out it's dossier. Somebody
687: else will take care of that. */
688: if (IS_AGGR_TYPE (taggr) && CLASSTYPE_VFIELD (taggr))
689: {
690: if (CLASSTYPE_VTABLE_NEEDS_WRITING (taggr))
691: {
692: TREE_PUBLIC (tdecl) = ! CLASSTYPE_INTERFACE_ONLY (taggr)
693: && CLASSTYPE_INTERFACE_KNOWN (taggr);
694: TREE_STATIC (tdecl) = 1;
695: DECL_EXTERNAL (tdecl) = 0;
696: }
697: else
698: {
699: if (write_virtuals != 0)
700: TREE_PUBLIC (tdecl) = 1;
701: }
702: }
703: else
704: {
705: DECL_EXTERNAL (tdecl) = 0;
706: TREE_STATIC (tdecl) = 1;
707: TREE_PUBLIC (tdecl) = (definition > 1);
708: }
709: }
710: SET_IDENTIFIER_AS_DESC (tname, build_unary_op (ADDR_EXPR, tdecl, 0));
711: if (!definition || DECL_EXTERNAL (tdecl))
712: {
713: /* That's it! */
714: finish_decl (tdecl, 0, 0, 0);
715: return IDENTIFIER_AS_DESC (tname);
716: }
717:
718: /* Show that we are defining the t_desc for this type. */
719: DECL_INITIAL (tdecl) = error_mark_node;
720:
721: parents = build_tree_list (NULL_TREE, integer_zero_node);
722: vbases = build_tree_list (NULL_TREE, integer_zero_node);
723: offsets = build_tree_list (NULL_TREE, integer_zero_node);
724: methods = NULL_TREE;
725: ivars = NULL_TREE;
726:
727: if (TYPE_LANG_SPECIFIC (type))
728: {
729: int i = CLASSTYPE_N_BASECLASSES (type);
730: tree method_vec = CLASSTYPE_METHOD_VEC (type);
731: tree *meth, *end;
732: tree binfos = TYPE_BINFO_BASETYPES (type);
733: tree vb = CLASSTYPE_VBASECLASSES (type);
734:
735: while (--i >= 0)
736: parents = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (TREE_VEC_ELT (binfos, i)), 0), parents);
737:
738: while (vb)
739: {
740: vbases = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (vb), 0), vbases);
741: offsets = tree_cons (NULL_TREE, BINFO_OFFSET (vb), offsets);
742: vb = TREE_CHAIN (vb);
743: }
744:
745: if (method_vec)
746: for (meth = TREE_VEC_END (method_vec),
747: end = &TREE_VEC_ELT (method_vec, 0); meth-- != end; )
748: if (*meth)
749: {
750: methods = tree_cons (NULL_TREE, build_m_desc (*meth), methods);
751: method_count++;
752: }
753: }
754:
755: if (IS_AGGR_TYPE (type))
756: {
757: for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
758: if (TREE_CODE (fields) == FIELD_DECL
759: || TREE_CODE (fields) == VAR_DECL)
760: {
761: ivars = tree_cons (NULL_TREE, build_i_desc (fields), ivars);
762: field_count++;
763: }
764: ivars = nreverse (ivars);
765: }
766:
767: parents = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node), parents, 0);
768: vbases = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node), vbases, 0);
769: offsets = finish_table (0, integer_type_node, offsets, 0);
770: if (methods == NULL_TREE)
771: methods = null_pointer_node;
772: else
773: methods = build_unary_op (ADDR_EXPR,
774: finish_table (0, __m_desc_type_node, methods, 0),
775: 0);
776: if (ivars == NULL_TREE)
777: ivars = null_pointer_node;
778: else
779: ivars = build_unary_op (ADDR_EXPR,
780: finish_table (0, __i_desc_type_node, ivars, 0),
781: 0);
782: if (TREE_TYPE (type))
783: target_type = build_t_desc (TREE_TYPE (type), definition);
784: else
785: target_type = integer_zero_node;
786:
787: name_string = combine_strings (build_string (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
788:
789: elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
790: tree_cons (NULL_TREE,
791: TYPE_SIZE(type)? size_in_bytes(type) : integer_zero_node,
792: /* really should use bitfield initialization here. */
793: tree_cons (NULL_TREE, integer_zero_node,
794: tree_cons (NULL_TREE, target_type,
795: tree_cons (NULL_TREE, build_int_2 (field_count, 2),
796: tree_cons (NULL_TREE, build_int_2 (method_count, 2),
797: tree_cons (NULL_TREE, ivars,
798: tree_cons (NULL_TREE, methods,
799: tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, parents, 0),
800: tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, vbases, 0),
801: build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, offsets, 0))))))))))));
802: return build_generic_desc (tdecl, elems);
803: }
804:
805: /* Build an initializer for a __i_desc node. */
806: tree
807: build_i_desc (decl)
808: tree decl;
809: {
810: tree elems, name_string;
811: tree taggr;
812:
813: name_string = DECL_NAME (decl);
814: name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string)));
815:
816: /* Now decide whether this ivar should cause it's type to get
817: def'd or ref'd in this file. If the type we are looking at
818: has a proxy definition, we look at the proxy (i.e., a
819: `foo *' is equivalent to a `foo'). */
820: taggr = TREE_TYPE (decl);
821:
822: if ((TREE_CODE (taggr) == POINTER_TYPE
823: || TREE_CODE (taggr) == REFERENCE_TYPE)
824: && TYPE_VOLATILE (taggr) == 0)
825: taggr = TREE_TYPE (taggr);
826:
827: elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
828: tree_cons (NULL_TREE, DECL_FIELD_BITPOS (decl),
829: build_tree_list (NULL_TREE, build_t_desc (TREE_TYPE (decl),
830: ! IS_AGGR_TYPE (taggr)))));
831: taggr = build (CONSTRUCTOR, __i_desc_type_node, NULL_TREE, elems);
832: TREE_CONSTANT (taggr) = 1;
833: TREE_STATIC (taggr) = 1;
834: TREE_READONLY (taggr) = 1;
835: return taggr;
836: }
837:
838: /* Build an initializer for a __m_desc node. */
839: tree
840: build_m_desc (decl)
841: tree decl;
842: {
843: tree taggr, elems, name_string;
844: tree parm_count, req_count, vindex, vcontext;
845: tree parms;
846: int p_count, r_count;
847: tree parm_types = NULL_TREE;
848:
849: for (parms = TYPE_ARG_TYPES (TREE_TYPE (decl)), p_count = 0, r_count = 0;
850: parms != NULL_TREE; parms = TREE_CHAIN (parms), p_count++)
851: {
852: taggr = TREE_VALUE (parms);
853: if ((TREE_CODE (taggr) == POINTER_TYPE
854: || TREE_CODE (taggr) == REFERENCE_TYPE)
855: && TYPE_VOLATILE (taggr) == 0)
856: taggr = TREE_TYPE (taggr);
857:
858: parm_types = tree_cons (NULL_TREE, build_t_desc (TREE_VALUE (parms),
859: ! IS_AGGR_TYPE (taggr)),
860: parm_types);
861: if (TREE_PURPOSE (parms) == NULL_TREE)
862: r_count++;
863: }
864:
865: parm_types = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node),
866: nreverse (parm_types), 0);
867: parm_count = build_int_2 (p_count, 0);
868: req_count = build_int_2 (r_count, 0);
869:
870: if (DECL_VINDEX (decl))
871: vindex = DECL_VINDEX (decl);
872: else
873: vindex = integer_zero_node;
874: if (DECL_CONTEXT (decl)
875: && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
876: vcontext = build_t_desc (DECL_CONTEXT (decl), 0);
877: else
878: vcontext = integer_zero_node;
879: name_string = DECL_NAME (decl);
880: if (name_string == NULL)
881: name_string = DECL_ASSEMBLER_NAME (decl);
882: name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string)));
883:
884: /* Now decide whether the return type of this mvar
885: should cause it's type to get def'd or ref'd in this file.
886: If the type we are looking at has a proxy definition,
887: we look at the proxy (i.e., a `foo *' is equivalent to a `foo'). */
888: taggr = TREE_TYPE (TREE_TYPE (decl));
889:
890: if ((TREE_CODE (taggr) == POINTER_TYPE
891: || TREE_CODE (taggr) == REFERENCE_TYPE)
892: && TYPE_VOLATILE (taggr) == 0)
893: taggr = TREE_TYPE (taggr);
894:
895: elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
896: tree_cons (NULL_TREE, vindex,
897: tree_cons (NULL_TREE, vcontext,
898: tree_cons (NULL_TREE, build_t_desc (TREE_TYPE (TREE_TYPE (decl)),
899: ! IS_AGGR_TYPE (taggr)),
900: tree_cons (NULL_TREE, build_c_cast (TYPE_POINTER_TO (default_function_type), build_unary_op (ADDR_EXPR, decl, 0)),
901: tree_cons (NULL_TREE, parm_count,
902: tree_cons (NULL_TREE, req_count,
903: build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, parm_types, 0)))))))));
904:
905: taggr = build (CONSTRUCTOR, __m_desc_type_node, NULL_TREE, elems);
906: TREE_CONSTANT (taggr) = 1;
907: TREE_STATIC (taggr) = 1;
908: TREE_READONLY (taggr) = 1;
909: return taggr;
910: }
911:
912: /* Conditionally emit code to set up an unwind-protect for the
913: garbage collector. If this function doesn't do anything that involves
914: the garbage collector, then do nothing. Otherwise, call __gc_push
915: at the beginning and __gc_pop at the end.
916:
917: NOTE! The __gc_pop function must operate transparently, since
918: it comes where the logical return label lies. This means that
919: at runtime *it* must preserve any return value registers. */
920:
921: void
922: expand_gc_prologue_and_epilogue ()
923: {
924: extern tree maybe_gc_cleanup;
925: struct rtx_def *last_parm_insn, *mark;
926: extern struct rtx_def *get_last_insn ();
927: extern struct rtx_def *get_first_nonparm_insn ();
928: extern struct rtx_def *previous_insn ();
929: tree action;
930:
931: /* If we didn't need the obstack, don't cons any space. */
932: if (current_function_obstack_index == 0
933: || current_function_obstack_usage == 0)
934: return;
935:
936: mark = get_last_insn ();
937: last_parm_insn = get_first_nonparm_insn ();
938: if (last_parm_insn == 0) last_parm_insn = mark;
939: else last_parm_insn = previous_insn (last_parm_insn);
940:
941: action = build_function_call (gc_push_fndecl,
942: build_tree_list (NULL_TREE, size_int (++current_function_obstack_index)));
943: expand_expr_stmt (action);
944:
945: reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
946:
947: /* This will be expanded as a cleanup. */
948: TREE_VALUE (maybe_gc_cleanup)
949: = build_function_call (gc_pop_fndecl, NULL_TREE);
950: }
951:
952: /* Some day we'll use this function as a call-back and clean
953: up all the unnecessary gc dribble that we otherwise create. */
954: void
955: lang_expand_end_bindings (first, last)
956: struct rtx_def *first, *last;
957: {
958: }
959:
960: void
961: init_gc_processing ()
962: {
963: tree parmtypes = hash_tree_chain (class_star_type_node,
964: hash_tree_chain (integer_type_node, NULL_TREE));
965: gc_protect_fndecl = define_function ("__gc_protect",
966: build_function_type (class_star_type_node, parmtypes),
967: NOT_BUILT_IN, 0, 0);
968:
969: parmtypes = hash_tree_chain (integer_type_node, NULL_TREE);
970: gc_unprotect_fndecl = define_function ("__gc_unprotect",
971: build_function_type (void_type_node, parmtypes),
972: NOT_BUILT_IN, 0, 0);
973:
974: gc_push_fndecl = define_function ("__gc_push",
975: TREE_TYPE (gc_unprotect_fndecl),
976: NOT_BUILT_IN, 0, 0);
977:
978: gc_pop_fndecl = define_function ("__gc_pop",
979: build_function_type (void_type_node,
980: void_list_node),
981: NOT_BUILT_IN, 0, 0);
982: gc_nonobject = build_int_2 (0x80000000, 0);
983: gc_visible = build_int_2 (0x40000000, 0);
984: gc_white = integer_zero_node;
985: gc_offwhite = build_int_2 (0x10000000, 0);
986: gc_grey = build_int_2 (0x20000000, 0);
987: gc_black = build_int_2 (0x30000000, 0);
988: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.