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
);
205 tree name
= build_signature_pointer_or_reference_name (to_type
, constp
,
208 /* Build a DECL node for this type, so the debugger has access to it. */
209 build_signature_pointer_or_reference_decl (t
, name
);
212 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
213 IS_SIGNATURE_POINTER (t
) = ! refp
;
214 IS_SIGNATURE_REFERENCE (t
) = refp
;
215 SIGNATURE_TYPE (t
) = to_type
;
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
;
225 /* Record this type as the reference to TO_TYPE. */
226 SIGNATURE_REFERENCE_TO (to_type
) = t
;
228 /* Record this type as the pointer to TO_TYPE. */
229 SIGNATURE_POINTER_TO (to_type
) = t
;
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. */
236 current_obstack
= ambient_obstack
;
237 saveable_obstack
= ambient_saveable_obstack
;
239 /* Ouput debug information for this type. */
240 rest_of_type_compilation (t
, 1);
245 /* Construct, lay out and return the type of pointers to signature TO_TYPE. */
248 build_signature_pointer_type (to_type
, constp
, volatilep
)
250 int constp
, volatilep
;
253 build_signature_pointer_or_reference_type (to_type
, constp
, volatilep
, 0);
256 /* Construct, lay out and return the type of pointers to signature TO_TYPE. */
259 build_signature_reference_type (to_type
, constp
, volatilep
)
261 int constp
, volatilep
;
264 build_signature_pointer_or_reference_type (to_type
, constp
, volatilep
, 1);
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. */
271 get_sigtable_name (sig_type
, rhs_type
)
272 tree sig_type
, rhs_type
;
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
);
283 for (i
= 0; sig_ptr
[i
] == OPERATOR_TYPENAME_FORMAT
[i
]; i
++)
285 while (sig_ptr
[i
] >= '0' && sig_ptr
[i
] <= '9')
288 for (j
= 0; rhs_ptr
[j
] == OPERATOR_TYPENAME_FORMAT
[j
]; j
++)
290 while (rhs_ptr
[j
] >= '0' && rhs_ptr
[j
] <= '9')
293 if (IS_SIGNATURE (rhs_type
))
294 sprintf (buf
, SIGTABLE_NAME_FORMAT_LONG
, sig_ptr
+i
, rhs_ptr
+j
,
295 global_sigtable_name_counter
++);
297 sprintf (buf
, SIGTABLE_NAME_FORMAT
, sig_ptr
+i
, rhs_ptr
+j
);
298 return get_identifier (buf
);
301 /* Build a field decl that points to a signature member function. */
304 build_member_function_pointer (member
)
307 char *namstr
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (member
));
308 int namlen
= IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (member
));
312 name
= (char *) alloca (namlen
+ sizeof (SIGNATURE_FIELD_NAME
) + 2);
313 sprintf (name
, SIGNATURE_FIELD_NAME_FORMAT
, namstr
);
315 /* @@ Do we really want to xref signature table fields? */
316 GNU_xref_ref (current_function_decl
, name
);
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;
323 /* @@ Do we really want to xref signature table fields? */
324 GNU_xref_decl (current_function_decl
, entry
);
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).
336 The new FIELD_DECLs are appended at the end of the last (and only)
337 sublist of `list_of_fieldlists.'
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. */
343 append_signature_fields (list_of_fieldlists
)
344 tree list_of_fieldlists
;
347 tree last_x
= NULL_TREE
;
350 tree mfptr_list
= NULL_TREE
;
352 /* For signatures it should actually be only a list with one element. */
353 for (l
= list_of_fieldlists
; l
; l
= TREE_CHAIN (l
))
355 for (x
= TREE_VALUE (l
); x
; x
= TREE_CHAIN (x
))
357 if (TREE_CODE (x
) == FUNCTION_DECL
)
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;
365 mfptr_list
= last_mfptr
= mfptr
;
368 TREE_CHAIN (last_mfptr
) = mfptr
;
376 /* Append the lists. */
377 if (last_x
&& mfptr_list
)
379 TREE_CHAIN (last_x
) = mfptr_list
;
380 TREE_CHAIN (last_mfptr
) = NULL_TREE
;
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.
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. */
394 match_method_types (sig_mtype
, class_mtype
)
395 tree sig_mtype
, class_mtype
;
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
);
402 /* The return types have to be the same. */
403 if (! comptypes (sig_return_type
, class_return_type
, 1))
406 /* Compare the first argument `this.' */
408 /* Get the type of what the `optr' is pointing to. */
410 TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_VALUE (sig_arg_types
))));
411 tree class_this
= TREE_VALUE (class_arg_types
);
413 if (TREE_CODE (class_this
) == RECORD_TYPE
) /* Is `this' a sig ptr? */
414 class_this
= TREE_TYPE (TREE_TYPE (TYPE_FIELDS (class_this
)));
416 class_this
= TREE_TYPE (class_this
);
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
)))
425 sig_arg_types
= TREE_CHAIN (sig_arg_types
);
426 class_arg_types
= TREE_CHAIN (class_arg_types
);
428 /* The number of arguments and the argument types have to be the same. */
429 return compparms (sig_arg_types
, class_arg_types
, 3);
432 /* Undo casts of opaque type variables to the RHS types. */
437 tree field
= TYPE_FIELDS (sig_ty
);
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
);
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. */
452 build_signature_table_constructor (sig_ty
, rhs
)
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
;
460 int sig_ptr_p
= IS_SIGNATURE (rhstype
);
461 int offset_p
= sig_ptr_p
;
463 rhstype
= sig_ptr_p
? rhstype
: TREE_TYPE (rhstype
);
465 if (CLASSTYPE_TAGS (sig_ty
))
467 sorry ("conformance check with signature containing class declarations");
468 return error_mark_node
;
471 for (; sig_field
; sig_field
= TREE_CHAIN (sig_field
))
473 tree basetype_path
, baselink
, basetypes
;
474 tree sig_method
, sig_mname
, sig_mtype
;
475 tree rhs_method
, tbl_entry
;
477 if (TREE_CODE (sig_field
) == TYPE_DECL
)
479 tree sig_field_type
= TREE_TYPE (sig_field
);
481 if (TYPE_MAIN_VARIANT (sig_field_type
) == opaque_type_node
)
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);
487 if (oty_type
== NULL_TREE
|| oty_type
== error_mark_node
)
489 cp_error ("class `%T' does not contain type `%T'",
492 return error_mark_node
;
494 oty_type
= TREE_TYPE (oty_type
);
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
);
500 /* If we don't have an opaque type, we can ignore the `typedef'. */
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
);
509 basetype_path
= TYPE_BINFO (rhstype
);
510 baselink
= lookup_fnfields (basetype_path
, sig_mname
, 0);
511 if (baselink
== NULL_TREE
|| baselink
== error_mark_node
)
513 if (! IS_DEFAULT_IMPLEMENTATION (sig_method
))
515 cp_error ("class `%T' does not contain method `%D'",
518 return error_mark_node
;
522 /* We use the signature's default implementation. */
523 rhs_method
= sig_method
;
528 /* Find the class method of the correct type. */
530 basetypes
= TREE_PURPOSE (baselink
);
531 if (TREE_CODE (basetypes
) == TREE_LIST
)
532 basetypes
= TREE_VALUE (basetypes
);
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
)))
541 if (rhs_method
== NULL_TREE
542 || (compute_access (basetypes
, rhs_method
)
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));
549 return error_mark_node
;
553 if (sig_ptr_p
&& rhs_method
!= sig_method
)
555 tree rhs_field
= DECL_MEMFUNC_POINTER_TO (rhs_method
);
557 if (first_rhs_field
== NULL_TREE
)
559 first_rhs_field
= rhs_field
;
560 last_rhs_field
= rhs_field
;
562 else if (TREE_CHAIN (last_rhs_field
) == rhs_field
)
563 last_rhs_field
= rhs_field
;
567 tbl_entry
= build_component_ref (rhs
, DECL_NAME (rhs_field
),
572 tree code
, offset
, pfn
;
574 if (rhs_method
== sig_method
)
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 */
582 else if (DECL_VINDEX (rhs_method
))
584 code
= integer_one_node
;
585 offset
= DECL_VINDEX (rhs_method
);
586 pfn
= null_pointer_node
;
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;
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;
605 /* Chain those function address expressions together. */
607 result
= tree_cons (NULL_TREE
, tbl_entry
, result
);
609 result
= build_tree_list (NULL_TREE
, tbl_entry
);
612 if (result
== NULL_TREE
)
614 /* The signature was empty, we don't need a signature table. */
621 if (first_rhs_field
== TYPE_FIELDS (rhstype
))
623 /* The sptr field on the lhs can be copied from the rhs. */
625 return integer_zero_node
;
629 /* The sptr field on the lhs will point into the rhs sigtable. */
631 return build_component_ref (rhs
, DECL_NAME (first_rhs_field
),
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
;
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.
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
655 build_sigtable (sig_type
, rhs_type
, init_from
)
656 tree sig_type
, rhs_type
, init_from
;
658 tree name
= NULL_TREE
;
659 tree decl
= NULL_TREE
;
662 push_obstacks_nochange ();
663 end_temporary_allocation ();
665 if (! IS_SIGNATURE (rhs_type
))
667 name
= get_sigtable_name (sig_type
, rhs_type
);
668 decl
= IDENTIFIER_GLOBAL_VALUE (name
);
670 if (decl
== NULL_TREE
)
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
))
681 error ("signature with opaque type implemented by multiple classes");
682 return error_mark_node
;
684 SIGTABLE_HAS_BEEN_GENERATED (sig_type
) = 1;
686 init_expr
= build_signature_table_constructor (sig_type
, init_from
);
687 if (init_expr
== NULL_TREE
|| TREE_CODE (init_expr
) != CONSTRUCTOR
)
690 if (name
== NULL_TREE
)
691 name
= get_sigtable_name (sig_type
, rhs_type
);
693 tree context
= current_function_decl
;
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
;
701 IDENTIFIER_GLOBAL_VALUE (name
) = decl
;
702 store_init_value (decl
, init_expr
);
703 if (IS_SIGNATURE (rhs_type
))
705 init
= DECL_INITIAL (decl
);
706 DECL_INITIAL (decl
) = error_mark_node
;
709 DECL_ALIGN (decl
) = MAX (TYPE_ALIGN (double_type_node
),
712 /* GDB-4.7 doesn't find the initialization value of a signature table
713 when it is constant. */
714 TREE_READONLY (decl
) = 1;
716 TREE_STATIC (decl
) = 1;
717 TREE_USED (decl
) = 1;
719 make_decl_rtl (decl
, NULL
, 1);
720 if (IS_SIGNATURE (rhs_type
))
721 expand_static_init (decl
, init
);
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. */
734 build_signature_pointer_constructor (lhs
, rhs
)
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
;
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
)))))
752 error ("invalid assignment to signature pointer or reference");
753 return error_mark_node
;
756 if (TYPE_SIZE (sig_ty
) == NULL_TREE
)
758 cp_error ("undefined signature `%T' used in signature %s declaration",
760 IS_SIGNATURE_POINTER (lhstype
) ? "pointer" : "reference");
761 return error_mark_node
;
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
))
768 current_obstack
= &permanent_obstack
;
769 saveable_obstack
= &permanent_obstack
;
772 if (TYPE_LANG_SPECIFIC (rhstype
) &&
773 (IS_SIGNATURE_POINTER (rhstype
) || IS_SIGNATURE_REFERENCE (rhstype
)))
775 if (SIGNATURE_TYPE (rhstype
) == sig_ty
)
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
);
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
),
790 sig_tbl
= build_sigtable (sig_ty
, SIGNATURE_TYPE (rhstype
), rhs_tbl
);
791 if (sig_tbl
== error_mark_node
)
792 return error_mark_node
;
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
;
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
);
811 if (TYPE_USES_COMPLEX_INHERITANCE (TREE_TYPE (rhstype
)))
813 sorry ("class with multiple inheritance as implementation of signature");
814 return error_mark_node
;
817 sig_tbl
= build_sigtable (sig_ty
, TREE_TYPE (rhstype
), rhs
);
818 if (sig_tbl
== error_mark_node
)
819 return error_mark_node
;
822 if (sig_tbl
== NULL_TREE
)
823 /* The signature was empty. The signature pointer is
824 pretty useless, but the user has been warned. */
826 sptr_expr
= copy_node (null_pointer_node
);
827 TREE_TYPE (sptr_expr
) = build_pointer_type (sig_ty
);
830 sptr_expr
= build_unary_op (ADDR_EXPR
, sig_tbl
, 0);
831 if (CLASSTYPE_VFIELD (TREE_TYPE (rhstype
)))
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);
838 vptr_expr
= copy_node (null_pointer_node
);
839 TREE_TYPE (vptr_expr
) = build_pointer_type (vtbl_type_node
);
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);
853 if (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
))
854 readonly_error (lhs
, "assignment", 0);
856 optr_expr
= build_modify_expr (build_optr_ref (lhs
), NOP_EXPR
,
858 sptr_expr
= build_modify_expr (build_sptr_ref (lhs
), NOP_EXPR
,
860 vptr_expr
= build_modify_expr (build_vptr_ref (lhs
), NOP_EXPR
,
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
,
868 result
= build_compound_expr (result
);
871 current_obstack
= ambient_obstack
;
872 saveable_obstack
= ambient_saveable_obstack
;
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. */
887 if (TREE_CODE_CLASS (TREE_CODE (instance
)) == 'd')
891 decl
= build_decl (VAR_DECL
, NULL_TREE
, TREE_TYPE (instance
));
892 DECL_REGISTER (decl
) = 1;
893 layout_decl (decl
, 0);
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. */
906 build_signature_method_call (basetype
, instance
, function
, parms
)
907 tree basetype
, instance
, function
, parms
;
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
,
915 sig_field_name
, basetype_path
, 1);
916 tree code
, offset
, pfn
, vfn
;
917 tree deflt_call
= NULL_TREE
, direct_call
, virtual_call
, result
;
919 code
= build_component_ref (tbl_entry
, get_identifier (SIGTABLE_CODE_NAME
),
921 offset
= build_component_ref (tbl_entry
,
922 get_identifier (SIGTABLE_OFFSET_NAME
),
924 pfn
= build_component_ref (tbl_entry
, get_identifier (SIGTABLE_PFN_NAME
),
926 TREE_TYPE (pfn
) = build_pointer_type (TREE_TYPE (function
));
928 if (IS_DEFAULT_IMPLEMENTATION (function
))
930 pfn
= save_expr (pfn
);
931 deflt_call
= build_function_call (pfn
,
932 tree_cons (NULL_TREE
, saved_instance
,
933 TREE_CHAIN (parms
)));
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
))));
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
));
945 direct_call
= build_function_call (pfn
, parms
);
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
);
951 /* Undo the cast, make `this' a signature pointer again. */
952 TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn
)))) = old_this
;
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
)))
962 compiler_error ("cannot build call of signature member function `%s'",
963 fndecl_as_string (NULL
, function
, 1));
964 return error_mark_node
;
967 if (IS_DEFAULT_IMPLEMENTATION (function
))
969 tree test
= build_binary_op_nodefault (EQ_EXPR
, code
, integer_one_node
,
971 result
= build_conditional_expr (code
,
972 build_conditional_expr (test
,
978 result
= build_conditional_expr (code
, virtual_call
, direct_call
);
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
),
989 /* Create a COMPONENT_REF expression for referencing the OPTR field
990 of a signature pointer or reference. */
993 build_optr_ref (instance
)
996 tree field
= get_identifier (SIGNATURE_OPTR_NAME
);
998 return build_component_ref (instance
, field
, NULL_TREE
, 1);
1001 /* Create a COMPONENT_REF expression for referencing the SPTR field
1002 of a signature pointer or reference. */
1005 build_sptr_ref (instance
)
1008 tree field
= get_identifier (SIGNATURE_SPTR_NAME
);
1010 return build_component_ref (instance
, field
, NULL_TREE
, 1);
1013 /* Create a COMPONENT_REF expression for referencing the VPTR field
1014 of a signature pointer or reference. */
1017 build_vptr_ref (instance
)
1020 tree field
= get_identifier (SIGNATURE_VPTR_NAME
);
1022 return build_component_ref (instance
, field
, NULL_TREE
, 1);