1 /* Functions dealing with signatures and signature pointers/references.
2 Copyright (C) 1992 Free Software Foundation, Inc.
3 Contributed by Gerald Baumgartner (gb@cs.purdue.edu)
5 This file is part of GNU CC.
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)
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.
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. */
30 extern struct obstack *current_obstack;
31 extern struct obstack permanent_obstack;
32 extern struct obstack *saveable_obstack;
36 extern void compiler_error ();
37 extern void make_decl_rtl PROTO((tree, char *, int));
39 /* Used to help generate globally unique names for signature tables. */
41 static int global_sigtable_name_counter;
43 /* Build an identifier for a signature pointer or reference, so we
44 can use it's name in function name mangling. */
47 build_signature_pointer_or_reference_name (to_type, constp, volatilep, refp)
49 int constp, volatilep, refp;
51 char * sig_name = TYPE_NAME_STRING (to_type);
52 int name_len = TYPE_NAME_LENGTH (to_type) + constp + volatilep;
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);
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);
67 return get_identifier (name);
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. */
76 build_signature_pointer_or_reference_decl (type, name)
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;
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.
95 This function is a subroutine of `build_signature_pointer_type' and
96 `build_signature_reference_type'. */
99 build_signature_pointer_or_reference_type (to_type, constp, volatilep, refp)
101 int constp, volatilep, refp;
104 register struct obstack *ambient_obstack = current_obstack;
105 register struct obstack *ambient_saveable_obstack = saveable_obstack;
107 m = refp ? SIGNATURE_REFERENCE_TO (to_type) : SIGNATURE_POINTER_TO (to_type);
109 /* If we don't have the main variant yet, construct it. */
111 && (constp || volatilep))
112 m = build_signature_pointer_or_reference_type (to_type, 0, 0, refp);
114 /* Treat any nonzero argument as 1. */
116 volatilep = !!volatilep;
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.
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
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)))))
134 /* We need a new one. If TO_TYPE is permanent, make this permanent too. */
135 if (TREE_PERMANENT (to_type))
137 current_obstack = &permanent_obstack;
138 saveable_obstack = &permanent_obstack;
141 /* A signature pointer or reference to a signature `s' looks like this:
146 vtbl_type_node * vptr;
149 A `const' signature pointer/reference is a
154 vtbl_type_node * vptr;
157 Similarly, for `volatile' and `const volatile'.
160 t = make_lang_type (RECORD_TYPE);
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;
166 optr = build_lang_field_decl (FIELD_DECL,
167 get_identifier (SIGNATURE_OPTR_NAME),
169 DECL_FIELD_CONTEXT (optr) = t;
170 DECL_CLASS_CONTEXT (optr) = t;
174 /* We can share `sptr' and `vptr' among type variants. */
175 sptr = TREE_CHAIN (TYPE_FIELDS (m));
176 vptr = TREE_CHAIN (sptr);
180 tree sig_tbl_type = cp_build_type_variant (to_type, 1, 0);
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;
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);
203 /* A signature pointer/reference isn't a `real' class. */
204 IS_AGGR_TYPE (t) = 0;
208 tree name = build_signature_pointer_or_reference_name (to_type, constp,
211 /* Build a DECL node for this type, so the debugger has access to it. */
212 build_signature_pointer_or_reference_decl (t, name);
215 CLASSTYPE_GOT_SEMICOLON (t) = 1;
216 IS_SIGNATURE_POINTER (t) = ! refp;
217 IS_SIGNATURE_REFERENCE (t) = refp;
218 SIGNATURE_TYPE (t) = to_type;
222 /* Add this type to the chain of variants of TYPE.
223 Every type has to be its own TYPE_MAIN_VARIANT. */
224 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
225 TYPE_NEXT_VARIANT (m) = t;
228 /* Record this type as the reference to TO_TYPE. */
229 SIGNATURE_REFERENCE_TO (to_type) = t;
231 /* Record this type as the pointer to TO_TYPE. */
232 SIGNATURE_POINTER_TO (to_type) = t;
234 /* Lay out the type. This function has many callers that are concerned
235 with expression-construction, and this simplifies them all.
236 Also, it guarantees the TYPE_SIZE is permanent if the type is. */
239 current_obstack = ambient_obstack;
240 saveable_obstack = ambient_saveable_obstack;
242 /* Ouput debug information for this type. */
243 rest_of_type_compilation (t, 1);
248 /* Construct, lay out and return the type of pointers to signature TO_TYPE. */
251 build_signature_pointer_type (to_type, constp, volatilep)
253 int constp, volatilep;
256 build_signature_pointer_or_reference_type (to_type, constp, volatilep, 0);
259 /* Construct, lay out and return the type of pointers to signature TO_TYPE. */
262 build_signature_reference_type (to_type, constp, volatilep)
264 int constp, volatilep;
267 build_signature_pointer_or_reference_type (to_type, constp, volatilep, 1);
270 /* Return the name of the signature table (as an IDENTIFIER_NODE)
271 for the given signature type SIG_TYPE and rhs type RHS_TYPE. */
274 get_sigtable_name (sig_type, rhs_type)
275 tree sig_type, rhs_type;
277 tree sig_type_id = build_typename_overload (sig_type);
278 tree rhs_type_id = build_typename_overload (rhs_type);
279 char *buf = (char *) alloca (sizeof (SIGTABLE_NAME_FORMAT_LONG)
280 + IDENTIFIER_LENGTH (sig_type_id)
281 + IDENTIFIER_LENGTH (rhs_type_id) + 20);
282 char *sig_ptr = IDENTIFIER_POINTER (sig_type_id);
283 char *rhs_ptr = IDENTIFIER_POINTER (rhs_type_id);
286 for (i = 0; sig_ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++)
288 while (sig_ptr[i] >= '0' && sig_ptr[i] <= '9')
291 for (j = 0; rhs_ptr[j] == OPERATOR_TYPENAME_FORMAT[j]; j++)
293 while (rhs_ptr[j] >= '0' && rhs_ptr[j] <= '9')
296 if (IS_SIGNATURE (rhs_type))
297 sprintf (buf, SIGTABLE_NAME_FORMAT_LONG, sig_ptr+i, rhs_ptr+j,
298 global_sigtable_name_counter++);
300 sprintf (buf, SIGTABLE_NAME_FORMAT, sig_ptr+i, rhs_ptr+j);
301 return get_identifier (buf);
304 /* Build a field decl that points to a signature member function. */
307 build_member_function_pointer (member)
310 char *namstr = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (member));
311 int namlen = IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (member));
315 name = (char *) alloca (namlen + sizeof (SIGNATURE_FIELD_NAME) + 2);
316 sprintf (name, SIGNATURE_FIELD_NAME_FORMAT, namstr);
318 /* @@ Do we really want to xref signature table fields? */
319 GNU_xref_ref (current_function_decl, name);
321 entry = build_lang_field_decl (FIELD_DECL, get_identifier (name),
322 TYPE_MAIN_VARIANT (sigtable_entry_type));
323 TREE_CONSTANT (entry) = 1;
324 TREE_READONLY (entry) = 1;
326 /* @@ Do we really want to xref signature table fields? */
327 GNU_xref_decl (current_function_decl, entry);
332 /* For each FUNCTION_DECL in a signature we construct a member function
333 pointer of the appropriate type. We also need two flags to test
334 whether the member function pointer points to a virtual function or
335 to a default implementation. Those flags will be the two lower order
336 bits of the member function pointer (or the two higher order bits,
337 based on the configuration).
339 The new FIELD_DECLs are appended at the end of the last (and only)
340 sublist of `list_of_fieldlists.'
342 As a side effect, each member function in the signature gets the
343 `decl.ignored' bit turned on, so we don't output debug info for it. */
346 append_signature_fields (list_of_fieldlists)
347 tree list_of_fieldlists;
350 tree last_x = NULL_TREE;
353 tree mfptr_list = NULL_TREE;
355 /* For signatures it should actually be only a list with one element. */
356 for (l = list_of_fieldlists; l; l = TREE_CHAIN (l))
358 for (x = TREE_VALUE (l); x; x = TREE_CHAIN (x))
360 if (TREE_CODE (x) == FUNCTION_DECL)
362 mfptr = build_member_function_pointer (x);
363 DECL_MEMFUNC_POINTER_TO (x) = mfptr;
364 DECL_MEMFUNC_POINTING_TO (mfptr) = x;
365 DECL_IGNORED_P (x) = 1;
366 DECL_IN_AGGR_P (mfptr) = 1;
368 mfptr_list = last_mfptr = mfptr;
371 TREE_CHAIN (last_mfptr) = mfptr;
379 /* Append the lists. */
380 if (last_x && mfptr_list)
382 TREE_CHAIN (last_x) = mfptr_list;
383 TREE_CHAIN (last_mfptr) = NULL_TREE;
387 /* Compare the types of a signature member function and a class member
388 function. Returns 1 if the types are in the C++ `<=' relationship.
390 If we have a signature pointer/reference as argument or return type
391 we don't want to do a recursive conformance check. The conformance
392 check only succeeds if both LHS and RHS refer to the same signature
393 pointer. Otherwise we need to keep information about parameter types
394 around at run time to initialize the signature table correctly. */
397 match_method_types (sig_mtype, class_mtype)
398 tree sig_mtype, class_mtype;
400 tree sig_return_type = TREE_TYPE (sig_mtype);
401 tree sig_arg_types = TYPE_ARG_TYPES (sig_mtype);
402 tree class_return_type = TREE_TYPE (class_mtype);
403 tree class_arg_types = TYPE_ARG_TYPES (class_mtype);
405 /* The return types have to be the same. */
406 if (! comptypes (sig_return_type, class_return_type, 1))
409 /* Compare the first argument `this.' */
411 /* Get the type of what the `optr' is pointing to. */
413 TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_VALUE (sig_arg_types))));
414 tree class_this = TREE_VALUE (class_arg_types);
416 if (TREE_CODE (class_this) == RECORD_TYPE) /* Is `this' a sig ptr? */
417 class_this = TREE_TYPE (TREE_TYPE (TYPE_FIELDS (class_this)));
419 class_this = TREE_TYPE (class_this);
421 /* If a signature method's `this' is const or volatile, so has to be
422 the corresponding class method's `this.' */
423 if ((TYPE_READONLY (sig_this) && ! TYPE_READONLY (class_this))
424 || (TYPE_VOLATILE (sig_this) && ! TYPE_VOLATILE (class_this)))
428 sig_arg_types = TREE_CHAIN (sig_arg_types);
429 class_arg_types = TREE_CHAIN (class_arg_types);
431 /* The number of arguments and the argument types have to be the same. */
432 return compparms (sig_arg_types, class_arg_types, 3);
435 /* Undo casts of opaque type variables to the RHS types. */
440 tree field = TYPE_FIELDS (sig_ty);
442 /* Since all the FIELD_DECLs for the signature table entries are at the end
443 of the chain (see `append_signature_fields'), we can do it this way. */
444 for (; field && TREE_CODE (field) != FIELD_DECL; field = TREE_CHAIN (field))
445 if (TYPE_MAIN_VARIANT (TREE_TYPE (field)) == opaque_type_node)
446 TREE_TYPE (TREE_TYPE (field)) = TREE_TYPE (ptr_type_node);
449 /* Do the type checking necessary to see whether the `rhs' conforms to
450 the lhs's `sig_ty'. Depending on the type of `rhs' return a NULL_TREE,
451 an integer_zero_node, a constructor, or an expression offsetting the
452 `rhs' signature table. */
455 build_signature_table_constructor (sig_ty, rhs)
458 tree rhstype = TREE_TYPE (rhs);
459 tree sig_field = TYPE_FIELDS (sig_ty);
460 tree result = NULL_TREE;
461 tree first_rhs_field = NULL_TREE;
463 int sig_ptr_p = IS_SIGNATURE (rhstype);
464 int offset_p = sig_ptr_p;
466 rhstype = sig_ptr_p ? rhstype : TREE_TYPE (rhstype);
468 if (CLASSTYPE_TAGS (sig_ty))
470 sorry ("conformance check with signature containing class declarations");
471 return error_mark_node;
474 for (; sig_field; sig_field = TREE_CHAIN (sig_field))
476 tree basetype_path, baselink, basetypes;
477 tree sig_method, sig_mname, sig_mtype;
478 tree rhs_method, tbl_entry;
480 if (TREE_CODE (sig_field) == TYPE_DECL)
482 tree sig_field_type = TREE_TYPE (sig_field);
484 if (TYPE_MAIN_VARIANT (sig_field_type) == opaque_type_node)
486 /* We've got an opaque type here. */
487 tree oty_name = DECL_NAME (sig_field);
488 tree oty_type = lookup_field (rhstype, oty_name, 1, 1);
490 if (oty_type == NULL_TREE || oty_type == error_mark_node)
492 cp_error ("class `%T' does not contain type `%T'",
495 return error_mark_node;
497 oty_type = TREE_TYPE (oty_type);
499 /* Cast `sig_field' to be of type `oty_type'. This will be
500 undone in `undo_casts' by walking over all the TYPE_DECLs. */
501 TREE_TYPE (sig_field_type) = TREE_TYPE (oty_type);
503 /* If we don't have an opaque type, we can ignore the `typedef'. */
507 /* Find the signature method corresponding to `sig_field'. */
508 sig_method = DECL_MEMFUNC_POINTING_TO (sig_field);
509 sig_mname = DECL_NAME (sig_method);
510 sig_mtype = TREE_TYPE (sig_method);
512 basetype_path = TYPE_BINFO (rhstype);
513 baselink = lookup_fnfields (basetype_path, sig_mname, 0);
514 if (baselink == NULL_TREE || baselink == error_mark_node)
516 if (! IS_DEFAULT_IMPLEMENTATION (sig_method))
518 cp_error ("class `%T' does not contain method `%D'",
521 return error_mark_node;
525 /* We use the signature's default implementation. */
526 rhs_method = sig_method;
531 /* Find the class method of the correct type. */
533 basetypes = TREE_PURPOSE (baselink);
534 if (TREE_CODE (basetypes) == TREE_LIST)
535 basetypes = TREE_VALUE (basetypes);
537 rhs_method = TREE_VALUE (baselink);
538 for (; rhs_method; rhs_method = TREE_CHAIN (rhs_method))
539 if (sig_mname == DECL_NAME (rhs_method)
540 && ! DECL_STATIC_FUNCTION_P (rhs_method)
541 && match_method_types (sig_mtype, TREE_TYPE (rhs_method)))
544 if (rhs_method == NULL_TREE
545 || (compute_access (basetypes, rhs_method)
548 error ("class `%s' does not contain a method conforming to `%s'",
549 TYPE_NAME_STRING (rhstype),
550 fndecl_as_string (NULL, sig_method, 1));
552 return error_mark_node;
556 if (sig_ptr_p && rhs_method != sig_method)
558 tree rhs_field = DECL_MEMFUNC_POINTER_TO (rhs_method);
560 if (first_rhs_field == NULL_TREE)
562 first_rhs_field = rhs_field;
563 last_rhs_field = rhs_field;
565 else if (TREE_CHAIN (last_rhs_field) == rhs_field)
566 last_rhs_field = rhs_field;
570 tbl_entry = build_component_ref (rhs, DECL_NAME (rhs_field),
575 tree code, offset, pfn;
577 if (rhs_method == sig_method)
579 code = integer_two_node;
580 offset = integer_zero_node;
581 pfn = build_unary_op (ADDR_EXPR, rhs_method, 0);
582 TREE_TYPE (pfn) = ptr_type_node;
583 offset_p = 0; /* we can't offset the rhs sig table */
585 else if (DECL_VINDEX (rhs_method))
587 code = integer_one_node;
588 offset = DECL_VINDEX (rhs_method);
589 pfn = null_pointer_node;
593 code = integer_zero_node;
594 offset = integer_zero_node;
595 pfn = build_unary_op (ADDR_EXPR, rhs_method, 0);
596 TREE_TYPE (pfn) = ptr_type_node;
597 TREE_ADDRESSABLE (rhs_method) = 1;
600 tbl_entry = tree_cons (NULL_TREE, code,
601 tree_cons (NULL_TREE, offset,
602 build_tree_list (NULL_TREE, pfn)));
603 tbl_entry = build_nt (CONSTRUCTOR, NULL_TREE, tbl_entry);
604 TREE_HAS_CONSTRUCTOR (tbl_entry) = 1;
605 TREE_CONSTANT (tbl_entry) = 1;
608 /* Chain those function address expressions together. */
610 result = tree_cons (NULL_TREE, tbl_entry, result);
612 result = build_tree_list (NULL_TREE, tbl_entry);
615 if (result == NULL_TREE)
617 /* The signature was empty, we don't need a signature table. */
624 if (first_rhs_field == TYPE_FIELDS (rhstype))
626 /* The sptr field on the lhs can be copied from the rhs. */
628 return integer_zero_node;
632 /* The sptr field on the lhs will point into the rhs sigtable. */
634 return build_component_ref (rhs, DECL_NAME (first_rhs_field),
639 /* We need to construct a new signature table. */
640 result = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (result));
641 TREE_HAS_CONSTRUCTOR (result) = 1;
642 TREE_CONSTANT (result) = !sig_ptr_p;
648 /* Build a signature table declaration and initialize it or return an
649 existing one if we built one already. If we don't get a constructor
650 as initialization expression, we don't need a new signature table
651 variable and just hand back the init expression.
653 The declaration processing is done by hand instead of using `finish_decl'
654 so that we can make signature pointers global variables instead of
658 build_sigtable (sig_type, rhs_type, init_from)
659 tree sig_type, rhs_type, init_from;
661 tree name = NULL_TREE;
662 tree decl = NULL_TREE;
665 push_obstacks_nochange ();
666 end_temporary_allocation ();
668 if (! IS_SIGNATURE (rhs_type))
670 name = get_sigtable_name (sig_type, rhs_type);
671 decl = IDENTIFIER_GLOBAL_VALUE (name);
673 if (decl == NULL_TREE)
677 /* We allow only one signature table to be generated for signatures
678 with opaque types. Otherwise we create a loophole in the type
679 system since we could cast data from one classes implementation
680 of the opaque type to that of another class. */
681 if (SIGNATURE_HAS_OPAQUE_TYPEDECLS (sig_type)
682 && SIGTABLE_HAS_BEEN_GENERATED (sig_type))
684 error ("signature with opaque type implemented by multiple classes");
685 return error_mark_node;
687 SIGTABLE_HAS_BEEN_GENERATED (sig_type) = 1;
689 init_expr = build_signature_table_constructor (sig_type, init_from);
690 if (init_expr == NULL_TREE || TREE_CODE (init_expr) != CONSTRUCTOR)
693 if (name == NULL_TREE)
694 name = get_sigtable_name (sig_type, rhs_type);
696 tree context = current_function_decl;
698 /* Make the signature table global, not just static in whichever
699 function a signature pointer/ref is used for the first time. */
700 current_function_decl = NULL_TREE;
701 decl = pushdecl_top_level (build_decl (VAR_DECL, name, sig_type));
702 current_function_decl = context;
704 IDENTIFIER_GLOBAL_VALUE (name) = decl;
705 store_init_value (decl, init_expr);
706 if (IS_SIGNATURE (rhs_type))
708 init = DECL_INITIAL (decl);
709 DECL_INITIAL (decl) = error_mark_node;
712 DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
715 /* GDB-4.7 doesn't find the initialization value of a signature table
716 when it is constant. */
717 TREE_READONLY (decl) = 1;
719 TREE_STATIC (decl) = 1;
720 TREE_USED (decl) = 1;
722 make_decl_rtl (decl, NULL, 1);
723 if (IS_SIGNATURE (rhs_type))
724 expand_static_init (decl, init);
732 /* Create a constructor or modify expression if the LHS of an assignment
733 is a signature pointer or a signature reference. If LHS is a record
734 type node, we build a constructor, otherwise a compound expression. */
737 build_signature_pointer_constructor (lhs, rhs)
740 register struct obstack *ambient_obstack = current_obstack;
741 register struct obstack *ambient_saveable_obstack = saveable_obstack;
742 int initp = (TREE_CODE (lhs) == RECORD_TYPE);
743 tree lhstype = initp ? lhs : TREE_TYPE (lhs);
744 tree rhstype = TREE_TYPE (rhs);
745 tree sig_ty = SIGNATURE_TYPE (lhstype);
746 tree sig_tbl, sptr_expr, optr_expr, vptr_expr;
749 if (! ((TREE_CODE (rhstype) == POINTER_TYPE
750 && TREE_CODE (TREE_TYPE (rhstype)) == RECORD_TYPE)
751 || (TYPE_LANG_SPECIFIC (rhstype) &&
752 (IS_SIGNATURE_POINTER (rhstype)
753 || IS_SIGNATURE_REFERENCE (rhstype)))))
755 error ("invalid assignment to signature pointer or reference");
756 return error_mark_node;
759 if (TYPE_SIZE (sig_ty) == NULL_TREE)
761 cp_error ("undefined signature `%T' used in signature %s declaration",
763 IS_SIGNATURE_POINTER (lhstype) ? "pointer" : "reference");
764 return error_mark_node;
767 /* If SIG_TY is permanent, make the signature table constructor and
768 the signature pointer/reference constructor permanent too. */
769 if (TREE_PERMANENT (sig_ty))
771 current_obstack = &permanent_obstack;
772 saveable_obstack = &permanent_obstack;
775 if (TYPE_LANG_SPECIFIC (rhstype) &&
776 (IS_SIGNATURE_POINTER (rhstype) || IS_SIGNATURE_REFERENCE (rhstype)))
778 if (SIGNATURE_TYPE (rhstype) == sig_ty)
780 /* LHS and RHS are signature pointers/refs of the same signature. */
781 optr_expr = build_optr_ref (rhs);
782 sptr_expr = build_sptr_ref (rhs);
783 vptr_expr = build_vptr_ref (rhs);
787 /* We need to create a new signature table and copy
788 elements from the rhs signature table. */
789 tree rhs_sptr_ref = build_sptr_ref (rhs);
790 tree rhs_tbl = build1 (INDIRECT_REF, SIGNATURE_TYPE (rhstype),
793 sig_tbl = build_sigtable (sig_ty, SIGNATURE_TYPE (rhstype), rhs_tbl);
794 if (sig_tbl == error_mark_node)
795 return error_mark_node;
797 optr_expr = build_optr_ref (rhs);
798 if (sig_tbl == NULL_TREE)
799 /* The signature was empty. The signature pointer is
800 pretty useless, but the user has been warned. */
801 sptr_expr = copy_node (null_pointer_node);
802 else if (sig_tbl == integer_zero_node)
803 sptr_expr = rhs_sptr_ref;
805 sptr_expr = build_unary_op (ADDR_EXPR, sig_tbl, 0);
806 TREE_TYPE (sptr_expr) = build_pointer_type (sig_ty);
807 vptr_expr = build_vptr_ref (rhs);
814 if (TYPE_USES_COMPLEX_INHERITANCE (TREE_TYPE (rhstype)))
816 sorry ("class with multiple inheritance as implementation of signature");
817 return error_mark_node;
820 sig_tbl = build_sigtable (sig_ty, TREE_TYPE (rhstype), rhs);
821 if (sig_tbl == error_mark_node)
822 return error_mark_node;
825 if (sig_tbl == NULL_TREE)
826 /* The signature was empty. The signature pointer is
827 pretty useless, but the user has been warned. */
829 sptr_expr = copy_node (null_pointer_node);
830 TREE_TYPE (sptr_expr) = build_pointer_type (sig_ty);
833 sptr_expr = build_unary_op (ADDR_EXPR, sig_tbl, 0);
834 if (CLASSTYPE_VFIELD (TREE_TYPE (rhstype)))
836 rhs_vptr = DECL_NAME (CLASSTYPE_VFIELD (TREE_TYPE (rhstype)));
837 vptr_expr = build_component_ref (build_indirect_ref (rhs, 0),
838 rhs_vptr, NULL_TREE, 0);
841 vptr_expr = copy_node (null_pointer_node);
842 TREE_TYPE (vptr_expr) = build_pointer_type (vtbl_type_node);
847 result = tree_cons (NULL_TREE, optr_expr,
848 tree_cons (NULL_TREE, sptr_expr,
849 build_tree_list (NULL_TREE, vptr_expr)));
850 result = build_nt (CONSTRUCTOR, NULL_TREE, result);
851 TREE_HAS_CONSTRUCTOR (result) = 1;
852 result = digest_init (lhstype, result, 0);
856 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype))
857 readonly_error (lhs, "assignment", 0);
859 optr_expr = build_modify_expr (build_optr_ref (lhs), NOP_EXPR,
861 sptr_expr = build_modify_expr (build_sptr_ref (lhs), NOP_EXPR,
863 vptr_expr = build_modify_expr (build_vptr_ref (lhs), NOP_EXPR,
866 result = tree_cons (NULL_TREE, optr_expr,
867 tree_cons (NULL_TREE, sptr_expr,
868 tree_cons (NULL_TREE, vptr_expr,
869 build_tree_list (NULL_TREE,
871 result = build_compound_expr (result);
874 current_obstack = ambient_obstack;
875 saveable_obstack = ambient_saveable_obstack;
879 /* Build a temporary variable declaration for the instance of a signature
880 member function call if it isn't a declaration node already. Simply
881 using a SAVE_EXPR doesn't work since we need `this' in both branches
882 of a conditional expression. */
890 if (TREE_CODE_CLASS (TREE_CODE (instance)) == 'd')
894 decl = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (instance));
895 DECL_REGISTER (decl) = 1;
896 layout_decl (decl, 0);
903 /* Build a signature member function call. Looks up the signature table
904 entry corresponding to FUNCTION. Depending on the value of the CODE
905 field, either call the function in PFN directly, or use OFFSET to
906 index INSTANCE's virtual function table. */
909 build_signature_method_call (basetype, instance, function, parms)
910 tree basetype, instance, function, parms;
912 tree saved_instance = save_this (instance); /* Create temp for `this'. */
913 tree signature_tbl_ptr = build_sptr_ref (saved_instance);
914 tree sig_field_name = DECL_NAME (DECL_MEMFUNC_POINTER_TO (function));
915 tree basetype_path = TYPE_BINFO (basetype);
916 tree tbl_entry = build_component_ref (build1 (INDIRECT_REF, basetype,
918 sig_field_name, basetype_path, 1);
919 tree code, offset, pfn, vfn;
920 tree deflt_call = NULL_TREE, direct_call, virtual_call, result;
922 code = build_component_ref (tbl_entry, get_identifier (SIGTABLE_CODE_NAME),
924 offset = build_component_ref (tbl_entry,
925 get_identifier (SIGTABLE_OFFSET_NAME),
927 pfn = build_component_ref (tbl_entry, get_identifier (SIGTABLE_PFN_NAME),
929 TREE_TYPE (pfn) = build_pointer_type (TREE_TYPE (function));
931 if (IS_DEFAULT_IMPLEMENTATION (function))
933 pfn = save_expr (pfn);
934 deflt_call = build_function_call (pfn,
935 tree_cons (NULL_TREE, saved_instance,
936 TREE_CHAIN (parms)));
940 /* Cast the signature method to have `this' of a normal pointer type. */
941 tree old_this = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn))));
943 TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn)))) =
944 build_type_variant (TYPE_POINTER_TO (basetype),
945 TYPE_READONLY (old_this),
946 TYPE_VOLATILE (old_this));
948 direct_call = build_function_call (pfn, parms);
950 vfn = build_vfn_ref (&TREE_VALUE (parms), saved_instance, offset);
951 TREE_TYPE (vfn) = build_pointer_type (TREE_TYPE (function));
952 virtual_call = build_function_call (vfn, parms);
954 /* Undo the cast, make `this' a signature pointer again. */
955 TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn)))) = old_this;
958 /* Once the function was found, there should be no reason why we
959 couldn't build the member function pointer call. */
960 if (!direct_call || direct_call == error_mark_node
961 || !virtual_call || virtual_call == error_mark_node
962 || (IS_DEFAULT_IMPLEMENTATION (function)
963 && (!deflt_call || deflt_call == error_mark_node)))
965 compiler_error ("cannot build call of signature member function `%s'",
966 fndecl_as_string (NULL, function, 1));
967 return error_mark_node;
970 if (IS_DEFAULT_IMPLEMENTATION (function))
972 tree test = build_binary_op_nodefault (EQ_EXPR, code, integer_one_node,
974 result = build_conditional_expr (code,
975 build_conditional_expr (test,
981 result = build_conditional_expr (code, virtual_call, direct_call);
983 /* If we created a temporary variable for `this', initialize it first. */
984 if (instance != saved_instance)
985 result = build (COMPOUND_EXPR, TREE_TYPE (result),
986 build_modify_expr (saved_instance, NOP_EXPR, instance),
992 /* Create a COMPONENT_REF expression for referencing the OPTR field
993 of a signature pointer or reference. */
996 build_optr_ref (instance)
999 tree field = get_identifier (SIGNATURE_OPTR_NAME);
1001 return build_component_ref (instance, field, NULL_TREE, 1);
1004 /* Create a COMPONENT_REF expression for referencing the SPTR field
1005 of a signature pointer or reference. */
1008 build_sptr_ref (instance)
1011 tree field = get_identifier (SIGNATURE_SPTR_NAME);
1013 return build_component_ref (instance, field, NULL_TREE, 1);
1016 /* Create a COMPONENT_REF expression for referencing the VPTR field
1017 of a signature pointer or reference. */
1020 build_vptr_ref (instance)
1023 tree field = get_identifier (SIGNATURE_VPTR_NAME);
1025 return build_component_ref (instance, field, NULL_TREE, 1);