![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sig.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 sig.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 root 1: /* Functions dealing with signatures and signature pointers/references.
2: Copyright (C) 1992 Free Software Foundation, Inc.
3: Contributed by Gerald Baumgartner ([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 <stdio.h>
24: #include "obstack.h"
25: #include "tree.h"
26: #include "cp-tree.h"
27: #include "flags.h"
28: #include "assert.h"
29:
30: extern struct obstack *current_obstack;
31: extern struct obstack permanent_obstack;
32: extern struct obstack *saveable_obstack;
33:
34: extern void error ();
35: extern void sorry ();
36: extern void compiler_error ();
37: extern void make_decl_rtl PROTO((tree, char *, int));
38:
39: /* Used to help generate globally unique names for signature tables. */
40:
41: static int global_sigtable_name_counter;
42:
43: /* Build an identifier for a signature pointer or reference, so we
44: can use it's name in function name mangling. */
45:
46: static tree
47: build_signature_pointer_or_reference_name (to_type, constp, volatilep, refp)
48: tree to_type;
49: int constp, volatilep, refp;
50: {
51: char * sig_name = TYPE_NAME_STRING (to_type);
52: int name_len = TYPE_NAME_LENGTH (to_type) + constp + volatilep;
53: char * name;
54:
55: if (refp)
56: {
57: name = (char *) alloca (name_len + sizeof (SIGNATURE_REFERENCE_NAME) +2);
58: sprintf (name, SIGNATURE_REFERENCE_NAME_FORMAT,
59: constp ? "C" : "", volatilep ? "V": "", sig_name);
60: }
61: else
62: {
63: name = (char *) alloca (name_len + sizeof (SIGNATURE_POINTER_NAME) + 2);
64: sprintf (name, SIGNATURE_POINTER_NAME_FORMAT,
65: constp ? "C" : "", volatilep ? "V": "", sig_name);
66: }
67: return get_identifier (name);
68: }
69:
70: /* Build a DECL node for a signature pointer or reference, so we can
71: tell the debugger the structure of signature pointers/references.
72: This function is called at most eight times for a given signature,
73: once for each [const] [volatile] signature pointer/reference. */
74:
75: static void
76: build_signature_pointer_or_reference_decl (type, name)
77: tree type, name;
78: {
79: tree decl;
80:
81: /* We don't enter this declaration in any sort of symbol table. */
82: decl = build_decl (TYPE_DECL, name, type);
83: TYPE_NAME (type) = decl;
84: TREE_CHAIN (type) = decl;
85: }
86:
87: /* Construct, lay out and return the type of pointers or references
88: to signature TO_TYPE. If such a type has already been constructed,
89: reuse it. If CONSTP or VOLATILEP is specified, make the `optr' const
90: or volatile, respectively. If we are constructing a const/volatile
91: type variant and the main type variant doesn't exist yet, it is built
92: as well. If REFP is 1, we construct a signature reference, otherwise
93: a signature pointer is constructed.
94:
95: This function is a subroutine of `build_signature_pointer_type' and
96: `build_signature_reference_type'. */
97:
98: static tree
99: build_signature_pointer_or_reference_type (to_type, constp, volatilep, refp)
100: tree to_type;
101: int constp, volatilep, refp;
102: {
103: register tree t, m;
104: register struct obstack *ambient_obstack = current_obstack;
105: register struct obstack *ambient_saveable_obstack = saveable_obstack;
106:
107: m = refp ? SIGNATURE_REFERENCE_TO (to_type) : SIGNATURE_POINTER_TO (to_type);
108:
109: /* If we don't have the main variant yet, construct it. */
110: if (m == NULL_TREE
111: && (constp || volatilep))
112: m = build_signature_pointer_or_reference_type (to_type, 0, 0, refp);
113:
114: /* Treat any nonzero argument as 1. */
115: constp = !!constp;
116: volatilep = !!volatilep;
117: refp = !!refp;
118:
119: /* If not generating auxiliary info, search the chain of variants to see
120: if there is already one there just like the one we need to have. If so,
121: use that existing one.
122:
123: We don't do this in the case where we are generating aux info because
124: in that case we want each typedef names to get it's own distinct type
125: node, even if the type of this new typedef is the same as some other
126: (existing) type. */
127:
128: if (m && !flag_gen_aux_info)
129: for (t = m; t; t = TYPE_NEXT_VARIANT (t))
130: if (constp == TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (t))))
131: && volatilep == TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (t)))))
132: return t;
133:
134: /* We need a new one. If TO_TYPE is permanent, make this permanent too. */
135: if (TREE_PERMANENT (to_type))
136: {
137: current_obstack = &permanent_obstack;
138: saveable_obstack = &permanent_obstack;
139: }
140:
141: /* A signature pointer or reference to a signature `s' looks like this:
142:
143: struct {
144: void * optr;
145: const s * sptr;
146: vtbl_type_node * vptr;
147: };
148:
149: A `const' signature pointer/reference is a
150:
151: struct {
152: const void * optr;
153: const s * sptr;
154: vtbl_type_node * vptr;
155: };
156:
157: Similarly, for `volatile' and `const volatile'.
158: */
159:
160: t = make_lang_type (RECORD_TYPE);
161: {
162: tree obj_type = build_type_variant (void_type_node, constp, volatilep);
163: tree optr_type = build_pointer_type (obj_type);
164: tree optr, sptr, vptr;
165:
166: optr = build_lang_field_decl (FIELD_DECL,
167: get_identifier (SIGNATURE_OPTR_NAME),
168: optr_type);
169: DECL_FIELD_CONTEXT (optr) = t;
170: DECL_CLASS_CONTEXT (optr) = t;
171:
172: if (m)
173: {
174: /* We can share `sptr' and `vptr' among type variants. */
175: sptr = TREE_CHAIN (TYPE_FIELDS (m));
176: vptr = TREE_CHAIN (sptr);
177: }
178: else
179: {
180: tree sig_tbl_type = cp_build_type_variant (to_type, 1, 0);
181:
182: sptr = build_lang_field_decl (FIELD_DECL,
183: get_identifier (SIGNATURE_SPTR_NAME),
184: build_pointer_type (sig_tbl_type));
185: vptr = build_lang_field_decl (FIELD_DECL,
186: get_identifier (SIGNATURE_VPTR_NAME),
187: build_pointer_type (vtbl_type_node));
188: DECL_FIELD_CONTEXT (sptr) = t;
189: DECL_CLASS_CONTEXT (sptr) = t;
190: DECL_FIELD_CONTEXT (vptr) = t;
191: DECL_CLASS_CONTEXT (vptr) = t;
192: TREE_CHAIN (sptr) = vptr;
193: TREE_CHAIN (vptr) = NULL_TREE;
194: }
195:
196: TREE_CHAIN (optr) = sptr;
197: TYPE_FIELDS (t) = optr;
198: /* To make `build_vfn_ref' work when building a signature method call. */
199: CLASSTYPE_VFIELD (t) = vptr;
200: DECL_FCONTEXT (CLASSTYPE_VFIELD (t)) = t;
201: TYPE_ALIGN (t) = TYPE_ALIGN (optr_type);
202: }
203:
204: {
205: tree name = build_signature_pointer_or_reference_name (to_type, constp,
206: volatilep, refp);
207:
208: /* Build a DECL node for this type, so the debugger has access to it. */
209: build_signature_pointer_or_reference_decl (t, name);
210: }
211:
212: CLASSTYPE_GOT_SEMICOLON (t) = 1;
213: IS_SIGNATURE_POINTER (t) = ! refp;
214: IS_SIGNATURE_REFERENCE (t) = refp;
215: SIGNATURE_TYPE (t) = to_type;
216:
217: if (m)
218: {
219: /* Add this type to the chain of variants of TYPE.
220: Every type has to be its own TYPE_MAIN_VARIANT. */
221: TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
222: TYPE_NEXT_VARIANT (m) = t;
223: }
224: else if (refp)
225: /* Record this type as the reference to TO_TYPE. */
226: SIGNATURE_REFERENCE_TO (to_type) = t;
227: else
228: /* Record this type as the pointer to TO_TYPE. */
229: SIGNATURE_POINTER_TO (to_type) = t;
230:
231: /* Lay out the type. This function has many callers that are concerned
232: with expression-construction, and this simplifies them all.
233: Also, it guarantees the TYPE_SIZE is permanent if the type is. */
234: layout_type (t);
235:
236: current_obstack = ambient_obstack;
237: saveable_obstack = ambient_saveable_obstack;
238:
239: /* Ouput debug information for this type. */
240: rest_of_type_compilation (t, 1);
241:
242: return t;
243: }
244:
245: /* Construct, lay out and return the type of pointers to signature TO_TYPE. */
246:
247: tree
248: build_signature_pointer_type (to_type, constp, volatilep)
249: tree to_type;
250: int constp, volatilep;
251: {
252: return
253: build_signature_pointer_or_reference_type (to_type, constp, volatilep, 0);
254: }
255:
256: /* Construct, lay out and return the type of pointers to signature TO_TYPE. */
257:
258: tree
259: build_signature_reference_type (to_type, constp, volatilep)
260: tree to_type;
261: int constp, volatilep;
262: {
263: return
264: build_signature_pointer_or_reference_type (to_type, constp, volatilep, 1);
265: }
266:
267: /* Return the name of the signature table (as an IDENTIFIER_NODE)
268: for the given signature type SIG_TYPE and rhs type RHS_TYPE. */
269:
270: static tree
271: get_sigtable_name (sig_type, rhs_type)
272: tree sig_type, rhs_type;
273: {
274: tree sig_type_id = build_typename_overload (sig_type);
275: tree rhs_type_id = build_typename_overload (rhs_type);
276: char *buf = (char *) alloca (sizeof (SIGTABLE_NAME_FORMAT_LONG)
277: + IDENTIFIER_LENGTH (sig_type_id)
278: + IDENTIFIER_LENGTH (rhs_type_id) + 20);
279: char *sig_ptr = IDENTIFIER_POINTER (sig_type_id);
280: char *rhs_ptr = IDENTIFIER_POINTER (rhs_type_id);
281: int i, j;
282:
283: for (i = 0; sig_ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++)
284: /* do nothing */;
285: while (sig_ptr[i] >= '0' && sig_ptr[i] <= '9')
286: i += 1;
287:
288: for (j = 0; rhs_ptr[j] == OPERATOR_TYPENAME_FORMAT[j]; j++)
289: /* do nothing */;
290: while (rhs_ptr[j] >= '0' && rhs_ptr[j] <= '9')
291: j += 1;
292:
293: if (IS_SIGNATURE (rhs_type))
294: sprintf (buf, SIGTABLE_NAME_FORMAT_LONG, sig_ptr+i, rhs_ptr+j,
295: global_sigtable_name_counter++);
296: else
297: sprintf (buf, SIGTABLE_NAME_FORMAT, sig_ptr+i, rhs_ptr+j);
298: return get_identifier (buf);
299: }
300:
301: /* Build a field decl that points to a signature member function. */
302:
303: static tree
304: build_member_function_pointer (member)
305: tree member;
306: {
307: char *namstr = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (member));
308: int namlen = IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (member));
309: char *name;
310: tree entry;
311:
312: name = (char *) alloca (namlen + sizeof (SIGNATURE_FIELD_NAME) + 2);
313: sprintf (name, SIGNATURE_FIELD_NAME_FORMAT, namstr);
314:
315: /* @@ Do we really want to xref signature table fields? */
316: GNU_xref_ref (current_function_decl, name);
317:
318: entry = build_lang_field_decl (FIELD_DECL, get_identifier (name),
319: TYPE_MAIN_VARIANT (sigtable_entry_type));
320: TREE_CONSTANT (entry) = 1;
321: TREE_READONLY (entry) = 1;
322:
323: /* @@ Do we really want to xref signature table fields? */
324: GNU_xref_decl (current_function_decl, entry);
325:
326: return entry;
327: }
328:
329: /* For each FUNCTION_DECL in a signature we construct a member function
330: pointer of the appropriate type. We also need two flags to test
331: whether the member function pointer points to a virtual function or
332: to a default implementation. Those flags will be the two lower order
333: bits of the member function pointer (or the two higher order bits,
334: based on the configuration).
335:
336: The new FIELD_DECLs are appended at the end of the last (and only)
337: sublist of `list_of_fieldlists.'
338:
339: As a side effect, each member function in the signature gets the
340: `decl.ignored' bit turned on, so we don't output debug info for it. */
341:
342: void
343: append_signature_fields (list_of_fieldlists)
344: tree list_of_fieldlists;
345: {
346: tree l, x;
347: tree last_x = NULL_TREE;
348: tree mfptr;
349: tree last_mfptr;
350: tree mfptr_list = NULL_TREE;
351:
352: /* For signatures it should actually be only a list with one element. */
353: for (l = list_of_fieldlists; l; l = TREE_CHAIN (l))
354: {
355: for (x = TREE_VALUE (l); x; x = TREE_CHAIN (x))
356: {
357: if (TREE_CODE (x) == FUNCTION_DECL)
358: {
359: mfptr = build_member_function_pointer (x);
360: DECL_MEMFUNC_POINTER_TO (x) = mfptr;
361: DECL_MEMFUNC_POINTING_TO (mfptr) = x;
362: DECL_IGNORED_P (x) = 1;
363: DECL_IN_AGGR_P (mfptr) = 1;
364: if (! mfptr_list)
365: mfptr_list = last_mfptr = mfptr;
366: else
367: {
368: TREE_CHAIN (last_mfptr) = mfptr;
369: last_mfptr = mfptr;
370: }
371: }
372: last_x = x;
373: }
374: }
375:
376: /* Append the lists. */
377: if (last_x && mfptr_list)
378: {
379: TREE_CHAIN (last_x) = mfptr_list;
380: TREE_CHAIN (last_mfptr) = NULL_TREE;
381: }
382: }
383:
384: /* Compare the types of a signature member function and a class member
385: function. Returns 1 if the types are in the C++ `<=' relationship.
386:
387: If we have a signature pointer/reference as argument or return type
388: we don't want to do a recursive conformance check. The conformance
389: check only succeeds if both LHS and RHS refer to the same signature
390: pointer. Otherwise we need to keep information about parameter types
391: around at run time to initialize the signature table correctly. */
392:
393: static int
394: match_method_types (sig_mtype, class_mtype)
395: tree sig_mtype, class_mtype;
396: {
397: tree sig_return_type = TREE_TYPE (sig_mtype);
398: tree sig_arg_types = TYPE_ARG_TYPES (sig_mtype);
399: tree class_return_type = TREE_TYPE (class_mtype);
400: tree class_arg_types = TYPE_ARG_TYPES (class_mtype);
401:
402: /* The return types have to be the same. */
403: if (! comptypes (sig_return_type, class_return_type, 1))
404: return 0;
405:
406: /* Compare the first argument `this.' */
407: {
408: /* Get the type of what the `optr' is pointing to. */
409: tree sig_this =
410: TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_VALUE (sig_arg_types))));
411: tree class_this = TREE_VALUE (class_arg_types);
412:
413: if (TREE_CODE (class_this) == RECORD_TYPE) /* Is `this' a sig ptr? */
414: class_this = TREE_TYPE (TREE_TYPE (TYPE_FIELDS (class_this)));
415: else
416: class_this = TREE_TYPE (class_this);
417:
418: /* If a signature method's `this' is const or volatile, so has to be
419: the corresponding class method's `this.' */
420: if ((TYPE_READONLY (sig_this) && ! TYPE_READONLY (class_this))
421: || (TYPE_VOLATILE (sig_this) && ! TYPE_VOLATILE (class_this)))
422: return 0;
423: }
424:
425: sig_arg_types = TREE_CHAIN (sig_arg_types);
426: class_arg_types = TREE_CHAIN (class_arg_types);
427:
428: /* The number of arguments and the argument types have to be the same. */
429: return compparms (sig_arg_types, class_arg_types, 3);
430: }
431:
432: /* Undo casts of opaque type variables to the RHS types. */
433: static void
434: undo_casts (sig_ty)
435: tree sig_ty;
436: {
437: tree field = TYPE_FIELDS (sig_ty);
438:
439: /* Since all the FIELD_DECLs for the signature table entries are at the end
440: of the chain (see `append_signature_fields'), we can do it this way. */
441: for (; field && TREE_CODE (field) != FIELD_DECL; field = TREE_CHAIN (field))
442: if (TYPE_MAIN_VARIANT (TREE_TYPE (field)) == opaque_type_node)
443: TREE_TYPE (TREE_TYPE (field)) = TREE_TYPE (ptr_type_node);
444: }
445:
446: /* Do the type checking necessary to see whether the `rhs' conforms to
447: the lhs's `sig_ty'. Depending on the type of `rhs' return a NULL_TREE,
448: an integer_zero_node, a constructor, or an expression offsetting the
449: `rhs' signature table. */
450:
451: static tree
452: build_signature_table_constructor (sig_ty, rhs)
453: tree sig_ty, rhs;
454: {
455: tree rhstype = TREE_TYPE (rhs);
456: tree sig_field = TYPE_FIELDS (sig_ty);
457: tree result = NULL_TREE;
458: tree first_rhs_field = NULL_TREE;
459: tree last_rhs_field;
460: int sig_ptr_p = IS_SIGNATURE (rhstype);
461: int offset_p = sig_ptr_p;
462:
463: rhstype = sig_ptr_p ? rhstype : TREE_TYPE (rhstype);
464:
465: if (CLASSTYPE_TAGS (sig_ty))
466: {
467: sorry ("conformance check with signature containing class declarations");
468: return error_mark_node;
469: }
470:
471: for (; sig_field; sig_field = TREE_CHAIN (sig_field))
472: {
473: tree basetype_path, baselink, basetypes;
474: tree sig_method, sig_mname, sig_mtype;
475: tree rhs_method, tbl_entry;
476:
477: if (TREE_CODE (sig_field) == TYPE_DECL)
478: {
479: tree sig_field_type = TREE_TYPE (sig_field);
480:
481: if (TYPE_MAIN_VARIANT (sig_field_type) == opaque_type_node)
482: {
483: /* We've got an opaque type here. */
484: tree oty_name = DECL_NAME (sig_field);
485: tree oty_type = lookup_field (rhstype, oty_name, 1, 1);
486:
487: if (oty_type == NULL_TREE || oty_type == error_mark_node)
488: {
489: cp_error ("class `%T' does not contain type `%T'",
490: rhstype, oty_type);
491: undo_casts (sig_ty);
492: return error_mark_node;
493: }
494: oty_type = TREE_TYPE (oty_type);
495:
496: /* Cast `sig_field' to be of type `oty_type'. This will be
497: undone in `undo_casts' by walking over all the TYPE_DECLs. */
498: TREE_TYPE (sig_field_type) = TREE_TYPE (oty_type);
499: }
500: /* If we don't have an opaque type, we can ignore the `typedef'. */
501: continue;
502: }
503:
504: /* Find the signature method corresponding to `sig_field'. */
505: sig_method = DECL_MEMFUNC_POINTING_TO (sig_field);
506: sig_mname = DECL_NAME (sig_method);
507: sig_mtype = TREE_TYPE (sig_method);
508:
509: basetype_path = TYPE_BINFO (rhstype);
510: baselink = lookup_fnfields (basetype_path, sig_mname, 0);
511: if (baselink == NULL_TREE || baselink == error_mark_node)
512: {
513: if (! IS_DEFAULT_IMPLEMENTATION (sig_method))
514: {
515: cp_error ("class `%T' does not contain method `%D'",
516: rhstype, sig_mname);
517: undo_casts (sig_ty);
518: return error_mark_node;
519: }
520: else
521: {
522: /* We use the signature's default implementation. */
523: rhs_method = sig_method;
524: }
525: }
526: else
527: {
528: /* Find the class method of the correct type. */
529:
530: basetypes = TREE_PURPOSE (baselink);
531: if (TREE_CODE (basetypes) == TREE_LIST)
532: basetypes = TREE_VALUE (basetypes);
533:
534: rhs_method = TREE_VALUE (baselink);
535: for (; rhs_method; rhs_method = TREE_CHAIN (rhs_method))
536: if (sig_mname == DECL_NAME (rhs_method)
537: && ! DECL_STATIC_FUNCTION_P (rhs_method)
538: && match_method_types (sig_mtype, TREE_TYPE (rhs_method)))
539: break;
540:
541: if (rhs_method == NULL_TREE
542: || (compute_access (basetypes, rhs_method)
543: != access_public))
544: {
545: error ("class `%s' does not contain a method conforming to `%s'",
546: TYPE_NAME_STRING (rhstype),
547: fndecl_as_string (NULL, sig_method, 1));
548: undo_casts (sig_ty);
549: return error_mark_node;
550: }
551: }
552:
553: if (sig_ptr_p && rhs_method != sig_method)
554: {
555: tree rhs_field = DECL_MEMFUNC_POINTER_TO (rhs_method);
556:
557: if (first_rhs_field == NULL_TREE)
558: {
559: first_rhs_field = rhs_field;
560: last_rhs_field = rhs_field;
561: }
562: else if (TREE_CHAIN (last_rhs_field) == rhs_field)
563: last_rhs_field = rhs_field;
564: else
565: offset_p = 0;
566:
567: tbl_entry = build_component_ref (rhs, DECL_NAME (rhs_field),
568: NULL_TREE, 1);
569: }
570: else
571: {
572: tree code, offset, pfn;
573:
574: if (rhs_method == sig_method)
575: {
576: code = integer_two_node;
577: offset = integer_zero_node;
578: pfn = build_unary_op (ADDR_EXPR, rhs_method, 0);
579: TREE_TYPE (pfn) = ptr_type_node;
580: offset_p = 0; /* we can't offset the rhs sig table */
581: }
582: else if (DECL_VINDEX (rhs_method))
583: {
584: code = integer_one_node;
585: offset = DECL_VINDEX (rhs_method);
586: pfn = null_pointer_node;
587: }
588: else
589: {
590: code = integer_zero_node;
591: offset = integer_zero_node;
592: pfn = build_unary_op (ADDR_EXPR, rhs_method, 0);
593: TREE_TYPE (pfn) = ptr_type_node;
594: TREE_ADDRESSABLE (rhs_method) = 1;
595: }
596:
597: tbl_entry = tree_cons (NULL_TREE, code,
598: tree_cons (NULL_TREE, offset,
599: build_tree_list (NULL_TREE, pfn)));
600: tbl_entry = build_nt (CONSTRUCTOR, NULL_TREE, tbl_entry);
601: TREE_HAS_CONSTRUCTOR (tbl_entry) = 1;
602: TREE_CONSTANT (tbl_entry) = 1;
603: }
604:
605: /* Chain those function address expressions together. */
606: if (result)
607: result = tree_cons (NULL_TREE, tbl_entry, result);
608: else
609: result = build_tree_list (NULL_TREE, tbl_entry);
610: }
611:
612: if (result == NULL_TREE)
613: {
614: /* The signature was empty, we don't need a signature table. */
615: undo_casts (sig_ty);
616: return NULL_TREE;
617: }
618:
619: if (offset_p)
620: {
621: if (first_rhs_field == TYPE_FIELDS (rhstype))
622: {
623: /* The sptr field on the lhs can be copied from the rhs. */
624: undo_casts (sig_ty);
625: return integer_zero_node;
626: }
627: else
628: {
629: /* The sptr field on the lhs will point into the rhs sigtable. */
630: undo_casts (sig_ty);
631: return build_component_ref (rhs, DECL_NAME (first_rhs_field),
632: NULL_TREE, 0);
633: }
634: }
635:
636: /* We need to construct a new signature table. */
637: result = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (result));
638: TREE_HAS_CONSTRUCTOR (result) = 1;
639: TREE_CONSTANT (result) = !sig_ptr_p;
640:
641: undo_casts (sig_ty);
642: return result;
643: }
644:
645: /* Build a signature table declaration and initialize it or return an
646: existing one if we built one already. If we don't get a constructor
647: as initialization expression, we don't need a new signature table
648: variable and just hand back the init expression.
649:
650: The declaration processing is done by hand instead of using `finish_decl'
651: so that we can make signature pointers global variables instead of
652: static ones. */
653:
654: static tree
655: build_sigtable (sig_type, rhs_type, init_from)
656: tree sig_type, rhs_type, init_from;
657: {
658: tree name = NULL_TREE;
659: tree decl = NULL_TREE;
660: tree init_expr;
661:
662: push_obstacks_nochange ();
663: end_temporary_allocation ();
664:
665: if (! IS_SIGNATURE (rhs_type))
666: {
667: name = get_sigtable_name (sig_type, rhs_type);
668: decl = IDENTIFIER_GLOBAL_VALUE (name);
669: }
670: if (decl == NULL_TREE)
671: {
672: tree init;
673:
674: /* We allow only one signature table to be generated for signatures
675: with opaque types. Otherwise we create a loophole in the type
676: system since we could cast data from one classes implementation
677: of the opaque type to that of another class. */
678: if (SIGNATURE_HAS_OPAQUE_TYPEDECLS (sig_type)
679: && SIGTABLE_HAS_BEEN_GENERATED (sig_type))
680: {
681: error ("signature with opaque type implemented by multiple classes");
682: return error_mark_node;
683: }
684: SIGTABLE_HAS_BEEN_GENERATED (sig_type) = 1;
685:
686: init_expr = build_signature_table_constructor (sig_type, init_from);
687: if (init_expr == NULL_TREE || TREE_CODE (init_expr) != CONSTRUCTOR)
688: return init_expr;
689:
690: if (name == NULL_TREE)
691: name = get_sigtable_name (sig_type, rhs_type);
692: {
693: tree context = current_function_decl;
694:
695: /* Make the signature table global, not just static in whichever
696: function a signature pointer/ref is used for the first time. */
697: current_function_decl = NULL_TREE;
698: decl = pushdecl_top_level (build_decl (VAR_DECL, name, sig_type));
699: current_function_decl = context;
700: }
701: IDENTIFIER_GLOBAL_VALUE (name) = decl;
702: store_init_value (decl, init_expr);
703: if (IS_SIGNATURE (rhs_type))
704: {
705: init = DECL_INITIAL (decl);
706: DECL_INITIAL (decl) = error_mark_node;
707: }
708:
709: DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
710: DECL_ALIGN (decl));
711: #if 0
712: /* GDB-4.7 doesn't find the initialization value of a signature table
713: when it is constant. */
714: TREE_READONLY (decl) = 1;
715: #endif
716: TREE_STATIC (decl) = 1;
717: TREE_USED (decl) = 1;
718:
719: make_decl_rtl (decl, NULL, 1);
720: if (IS_SIGNATURE (rhs_type))
721: expand_static_init (decl, init);
722: }
723:
724: pop_obstacks ();
725:
726: return decl;
727: }
728:
729: /* Create a constructor or modify expression if the LHS of an assignment
730: is a signature pointer or a signature reference. If LHS is a record
731: type node, we build a constructor, otherwise a compound expression. */
732:
733: tree
734: build_signature_pointer_constructor (lhs, rhs)
735: tree lhs, rhs;
736: {
737: register struct obstack *ambient_obstack = current_obstack;
738: register struct obstack *ambient_saveable_obstack = saveable_obstack;
739: int initp = (TREE_CODE (lhs) == RECORD_TYPE);
740: tree lhstype = initp ? lhs : TREE_TYPE (lhs);
741: tree rhstype = TREE_TYPE (rhs);
742: tree sig_ty = SIGNATURE_TYPE (lhstype);
743: tree sig_tbl, sptr_expr, optr_expr, vptr_expr;
744: tree result;
745:
746: if (! ((TREE_CODE (rhstype) == POINTER_TYPE
747: && TREE_CODE (TREE_TYPE (rhstype)) == RECORD_TYPE)
748: || (TYPE_LANG_SPECIFIC (rhstype) &&
749: (IS_SIGNATURE_POINTER (rhstype)
750: || IS_SIGNATURE_REFERENCE (rhstype)))))
751: {
752: error ("invalid assignment to signature pointer or reference");
753: return error_mark_node;
754: }
755:
756: if (TYPE_SIZE (sig_ty) == NULL_TREE)
757: {
758: cp_error ("undefined signature `%T' used in signature %s declaration",
759: sig_ty,
760: IS_SIGNATURE_POINTER (lhstype) ? "pointer" : "reference");
761: return error_mark_node;
762: }
763:
764: /* If SIG_TY is permanent, make the signature table constructor and
765: the signature pointer/reference constructor permanent too. */
766: if (TREE_PERMANENT (sig_ty))
767: {
768: current_obstack = &permanent_obstack;
769: saveable_obstack = &permanent_obstack;
770: }
771:
772: if (TYPE_LANG_SPECIFIC (rhstype) &&
773: (IS_SIGNATURE_POINTER (rhstype) || IS_SIGNATURE_REFERENCE (rhstype)))
774: {
775: if (SIGNATURE_TYPE (rhstype) == sig_ty)
776: {
777: /* LHS and RHS are signature pointers/refs of the same signature. */
778: optr_expr = build_optr_ref (rhs);
779: sptr_expr = build_sptr_ref (rhs);
780: vptr_expr = build_vptr_ref (rhs);
781: }
782: else
783: {
784: /* We need to create a new signature table and copy
785: elements from the rhs signature table. */
786: tree rhs_sptr_ref = build_sptr_ref (rhs);
787: tree rhs_tbl = build1 (INDIRECT_REF, SIGNATURE_TYPE (rhstype),
788: rhs_sptr_ref);
789:
790: sig_tbl = build_sigtable (sig_ty, SIGNATURE_TYPE (rhstype), rhs_tbl);
791: if (sig_tbl == error_mark_node)
792: return error_mark_node;
793:
794: optr_expr = build_optr_ref (rhs);
795: if (sig_tbl == NULL_TREE)
796: /* The signature was empty. The signature pointer is
797: pretty useless, but the user has been warned. */
798: sptr_expr = copy_node (null_pointer_node);
799: else if (sig_tbl == integer_zero_node)
800: sptr_expr = rhs_sptr_ref;
801: else
802: sptr_expr = build_unary_op (ADDR_EXPR, sig_tbl, 0);
803: TREE_TYPE (sptr_expr) = build_pointer_type (sig_ty);
804: vptr_expr = build_vptr_ref (rhs);
805: }
806: }
807: else
808: {
809: tree rhs_vptr;
810:
811: if (TYPE_USES_COMPLEX_INHERITANCE (TREE_TYPE (rhstype)))
812: {
813: sorry ("class with multiple inheritance as implementation of signature");
814: return error_mark_node;
815: }
816:
817: sig_tbl = build_sigtable (sig_ty, TREE_TYPE (rhstype), rhs);
818: if (sig_tbl == error_mark_node)
819: return error_mark_node;
820:
821: optr_expr = rhs;
822: if (sig_tbl == NULL_TREE)
823: /* The signature was empty. The signature pointer is
824: pretty useless, but the user has been warned. */
825: {
826: sptr_expr = copy_node (null_pointer_node);
827: TREE_TYPE (sptr_expr) = build_pointer_type (sig_ty);
828: }
829: else
830: sptr_expr = build_unary_op (ADDR_EXPR, sig_tbl, 0);
831: if (CLASSTYPE_VFIELD (TREE_TYPE (rhstype)))
832: {
833: rhs_vptr = DECL_NAME (CLASSTYPE_VFIELD (TREE_TYPE (rhstype)));
834: vptr_expr = build_component_ref (build_indirect_ref (rhs, 0),
835: rhs_vptr, NULL_TREE, 0);
836: }
837: else
838: vptr_expr = copy_node (null_pointer_node);
839: TREE_TYPE (vptr_expr) = build_pointer_type (vtbl_type_node);
840: }
841:
842: if (initp)
843: {
844: result = tree_cons (NULL_TREE, optr_expr,
845: tree_cons (NULL_TREE, sptr_expr,
846: build_tree_list (NULL_TREE, vptr_expr)));
847: result = build_nt (CONSTRUCTOR, NULL_TREE, result);
848: TREE_HAS_CONSTRUCTOR (result) = 1;
849: result = digest_init (lhstype, result, 0);
850: }
851: else
852: {
853: if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype))
854: readonly_error (lhs, "assignment", 0);
855:
856: optr_expr = build_modify_expr (build_optr_ref (lhs), NOP_EXPR,
857: optr_expr);
858: sptr_expr = build_modify_expr (build_sptr_ref (lhs), NOP_EXPR,
859: sptr_expr);
860: vptr_expr = build_modify_expr (build_vptr_ref (lhs), NOP_EXPR,
861: vptr_expr);
862:
863: result = tree_cons (NULL_TREE, optr_expr,
864: tree_cons (NULL_TREE, sptr_expr,
865: tree_cons (NULL_TREE, vptr_expr,
866: build_tree_list (NULL_TREE,
867: lhs))));
868: result = build_compound_expr (result);
869: }
870:
871: current_obstack = ambient_obstack;
872: saveable_obstack = ambient_saveable_obstack;
873: return result;
874: }
875:
876: /* Build a temporary variable declaration for the instance of a signature
877: member function call if it isn't a declaration node already. Simply
878: using a SAVE_EXPR doesn't work since we need `this' in both branches
879: of a conditional expression. */
880:
881: static tree
882: save_this (instance)
883: tree instance;
884: {
885: tree decl;
886:
887: if (TREE_CODE_CLASS (TREE_CODE (instance)) == 'd')
888: decl = instance;
889: else
890: {
891: decl = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (instance));
892: DECL_REGISTER (decl) = 1;
893: layout_decl (decl, 0);
894: expand_decl (decl);
895: }
896:
897: return decl;
898: }
899:
900: /* Build a signature member function call. Looks up the signature table
901: entry corresponding to FUNCTION. Depending on the value of the CODE
902: field, either call the function in PFN directly, or use OFFSET to
903: index INSTANCE's virtual function table. */
904:
905: tree
906: build_signature_method_call (basetype, instance, function, parms)
907: tree basetype, instance, function, parms;
908: {
909: tree saved_instance = save_this (instance); /* Create temp for `this'. */
910: tree signature_tbl_ptr = build_sptr_ref (saved_instance);
911: tree sig_field_name = DECL_NAME (DECL_MEMFUNC_POINTER_TO (function));
912: tree basetype_path = TYPE_BINFO (basetype);
913: tree tbl_entry = build_component_ref (build1 (INDIRECT_REF, basetype,
914: signature_tbl_ptr),
915: sig_field_name, basetype_path, 1);
916: tree code, offset, pfn, vfn;
917: tree deflt_call = NULL_TREE, direct_call, virtual_call, result;
918:
919: code = build_component_ref (tbl_entry, get_identifier (SIGTABLE_CODE_NAME),
920: NULL_TREE, 1);
921: offset = build_component_ref (tbl_entry,
922: get_identifier (SIGTABLE_OFFSET_NAME),
923: NULL_TREE, 1);
924: pfn = build_component_ref (tbl_entry, get_identifier (SIGTABLE_PFN_NAME),
925: NULL_TREE, 1);
926: TREE_TYPE (pfn) = build_pointer_type (TREE_TYPE (function));
927:
928: if (IS_DEFAULT_IMPLEMENTATION (function))
929: {
930: pfn = save_expr (pfn);
931: deflt_call = build_function_call (pfn,
932: tree_cons (NULL_TREE, saved_instance,
933: TREE_CHAIN (parms)));
934: }
935:
936: {
937: /* Cast the signature method to have `this' of a normal pointer type. */
938: tree old_this = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn))));
939:
940: TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn)))) =
941: build_type_variant (TYPE_POINTER_TO (basetype),
942: TYPE_READONLY (old_this),
943: TYPE_VOLATILE (old_this));
944:
945: direct_call = build_function_call (pfn, parms);
946:
947: vfn = build_vfn_ref (&TREE_VALUE (parms), saved_instance, offset);
948: TREE_TYPE (vfn) = build_pointer_type (TREE_TYPE (function));
949: virtual_call = build_function_call (vfn, parms);
950:
951: /* Undo the cast, make `this' a signature pointer again. */
952: TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn)))) = old_this;
953: }
954:
955: /* Once the function was found, there should be no reason why we
956: couldn't build the member function pointer call. */
957: if (!direct_call || direct_call == error_mark_node
958: || !virtual_call || virtual_call == error_mark_node
959: || (IS_DEFAULT_IMPLEMENTATION (function)
960: && (!deflt_call || deflt_call == error_mark_node)))
961: {
962: compiler_error ("cannot build call of signature member function `%s'",
963: fndecl_as_string (NULL, function, 1));
964: return error_mark_node;
965: }
966:
967: if (IS_DEFAULT_IMPLEMENTATION (function))
968: {
969: tree test = build_binary_op_nodefault (EQ_EXPR, code, integer_one_node,
970: EQ_EXPR);
971: result = build_conditional_expr (code,
972: build_conditional_expr (test,
973: virtual_call,
974: deflt_call),
975: direct_call);
976: }
977: else
978: result = build_conditional_expr (code, virtual_call, direct_call);
979:
980: /* If we created a temporary variable for `this', initialize it first. */
981: if (instance != saved_instance)
982: result = build (COMPOUND_EXPR, TREE_TYPE (result),
983: build_modify_expr (saved_instance, NOP_EXPR, instance),
984: result);
985:
986: return result;
987: }
988:
989: /* Create a COMPONENT_REF expression for referencing the OPTR field
990: of a signature pointer or reference. */
991:
992: tree
993: build_optr_ref (instance)
994: tree instance;
995: {
996: tree field = get_identifier (SIGNATURE_OPTR_NAME);
997:
998: return build_component_ref (instance, field, NULL_TREE, 1);
999: }
1000:
1001: /* Create a COMPONENT_REF expression for referencing the SPTR field
1002: of a signature pointer or reference. */
1003:
1004: tree
1005: build_sptr_ref (instance)
1006: tree instance;
1007: {
1008: tree field = get_identifier (SIGNATURE_SPTR_NAME);
1009:
1010: return build_component_ref (instance, field, NULL_TREE, 1);
1011: }
1012:
1013: /* Create a COMPONENT_REF expression for referencing the VPTR field
1014: of a signature pointer or reference. */
1015:
1016: tree
1017: build_vptr_ref (instance)
1018: tree instance;
1019: {
1020: tree field = get_identifier (SIGNATURE_VPTR_NAME);
1021:
1022: return build_component_ref (instance, field, NULL_TREE, 1);
1023: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.