1 /* Handle the hair of processing (but not expanding) inline functions.
2 Also manage function and variable name overloading.
3 Copyright (C) 1987, 89, 92-97, 1998, 1999 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
28 #ifndef PARM_CAN_BE_ARRAY_TYPE
29 #define PARM_CAN_BE_ARRAY_TYPE 1
32 /* Handle method declarations. */
41 #include "hard-reg-set.h"
46 /* TREE_LIST of the current inline functions that need to be
48 struct pending_inline
*pending_inlines
;
50 #define obstack_chunk_alloc xmalloc
51 #define obstack_chunk_free free
53 /* Obstack where we build text strings for overloading, etc. */
54 static struct obstack scratch_obstack
;
55 static char *scratch_firstobj
;
57 static void icat
PROTO((HOST_WIDE_INT
));
58 static void dicat
PROTO((HOST_WIDE_INT
, HOST_WIDE_INT
));
59 static int old_backref_index
PROTO((tree
));
60 static int flush_repeats
PROTO((int, tree
));
61 static void build_overload_identifier
PROTO((tree
));
62 static void build_overload_nested_name
PROTO((tree
));
63 static void build_overload_int
PROTO((tree
, int));
64 static void build_overload_identifier
PROTO((tree
));
65 static void build_qualified_name
PROTO((tree
));
66 static void build_overload_value
PROTO((tree
, tree
, int));
67 static void issue_nrepeats
PROTO((int, tree
));
68 static char *build_mangled_name
PROTO((tree
,int,int));
69 static void process_modifiers
PROTO((tree
));
70 static void process_overload_item
PROTO((tree
,int));
71 static void do_build_assign_ref
PROTO((tree
));
72 static void do_build_copy_constructor
PROTO((tree
));
73 static void build_template_template_parm_names
PROTO((tree
));
74 static void build_template_parm_names
PROTO((tree
, tree
));
75 static void build_underscore_int
PROTO((int));
76 static void start_squangling
PROTO((void));
77 static void end_squangling
PROTO((void));
78 static int check_ktype
PROTO((tree
, int));
79 static int issue_ktype
PROTO((tree
));
80 static void build_overload_scope_ref
PROTO((tree
));
81 static void build_mangled_template_parm_index
PROTO((const char *, tree
));
82 #if HOST_BITS_PER_WIDE_INT >= 64
83 static void build_mangled_C9x_name
PROTO((int));
85 static int is_back_referenceable_type
PROTO((tree
));
86 static int check_btype
PROTO((tree
));
87 static void build_mangled_name_for_type
PROTO((tree
));
88 static void build_mangled_name_for_type_with_Gcode
PROTO((tree
, int));
90 # define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0)
91 # define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C)))
92 # define OB_PUTC2(C1,C2) \
93 (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2)))
94 # define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1))
95 # define OB_PUTID(ID) \
96 (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \
97 IDENTIFIER_LENGTH (ID)))
98 # define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S)))
99 # define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
100 # define OB_LAST() (obstack_next_free (&scratch_obstack)[-1])
102 /* type tables for K and B type compression */
103 static varray_type btypelist
;
104 static varray_type ktypelist
;
106 /* number of each type seen */
107 static size_t maxbtype
;
108 static size_t maxktype
;
110 /* Array of types seen so far in top-level call to `build_mangled_name'.
111 Allocated and deallocated by caller. */
112 static varray_type typevec
;
114 /* Number of types interned by `build_mangled_name' so far. */
115 static size_t maxtype
;
117 /* Called once to initialize method.c. */
122 gcc_obstack_init (&scratch_obstack
);
123 scratch_firstobj
= (char *)obstack_alloc (&scratch_obstack
, 0);
124 ggc_add_tree_varray_root (&btypelist
, 1);
125 ggc_add_tree_varray_root (&ktypelist
, 1);
126 ggc_add_tree_varray_root (&typevec
, 1);
129 /* This must be large enough to hold any printed integer or floating-point
131 static char digit_buffer
[128];
133 /* Move inline function definitions out of structure so that they
134 can be processed normally. CNAME is the name of the class
135 we are working from, METHOD_LIST is the list of method lists
136 of the structure. We delete friend methods here, after
137 saving away their inline function definitions (if any). */
140 do_inline_function_hair (type
, friend_list
)
141 tree type
, friend_list
;
143 tree method
= TYPE_METHODS (type
);
145 if (method
&& TREE_CODE (method
) == TREE_VEC
)
147 if (TREE_VEC_ELT (method
, 1))
148 method
= TREE_VEC_ELT (method
, 1);
149 else if (TREE_VEC_ELT (method
, 0))
150 method
= TREE_VEC_ELT (method
, 0);
152 method
= TREE_VEC_ELT (method
, 2);
157 /* Do inline member functions. */
158 struct pending_inline
*info
= DECL_PENDING_INLINE_INFO (method
);
163 my_friendly_assert (info
->fndecl
== method
, 238);
164 args
= DECL_ARGUMENTS (method
);
167 DECL_CONTEXT (args
) = method
;
168 args
= TREE_CHAIN (args
);
171 method
= TREE_CHAIN (method
);
175 tree fndecl
= TREE_VALUE (friend_list
);
176 struct pending_inline
*info
= DECL_PENDING_INLINE_INFO (fndecl
);
181 my_friendly_assert (info
->fndecl
== fndecl
, 239);
182 args
= DECL_ARGUMENTS (fndecl
);
185 DECL_CONTEXT (args
) = fndecl
;
186 args
= TREE_CHAIN (args
);
190 friend_list
= TREE_CHAIN (friend_list
);
194 /* Here is where overload code starts. */
196 /* Nonzero if we should not try folding parameter types. */
199 /* This appears to be set to true if an underscore is required to be
200 comcatenated before another number can be outputed. */
201 static int numeric_output_need_bar
;
206 if (flag_do_squangling
)
211 VARRAY_TREE_INIT (btypelist
, 50, "btypelist");
212 VARRAY_TREE_INIT (ktypelist
, 50, "ktypelist");
219 if (flag_do_squangling
)
221 VARRAY_FREE (ktypelist
);
222 VARRAY_FREE (btypelist
);
228 /* Code to concatenate an asciified integer to a string. */
234 unsigned HOST_WIDE_INT ui
;
236 /* Handle this case first, to go really quickly. For many common values,
237 the result of ui/10 below is 1. */
255 OB_PUTC ('0' + (ui
% 10));
260 HOST_WIDE_INT lo
, hi
;
262 unsigned HOST_WIDE_INT ulo
, uhi
, qlo
, qhi
;
271 uhi
= (lo
== 0 ? -hi
: -hi
-1);
275 && ulo
< ((unsigned HOST_WIDE_INT
)1 << (HOST_BITS_PER_WIDE_INT
- 1)))
280 /* Divide 2^HOST_WIDE_INT*uhi+ulo by 10. */
283 qlo
= uhi
* (((unsigned HOST_WIDE_INT
)1 << (HOST_BITS_PER_WIDE_INT
- 1)) / 5);
286 ulo
+= uhi
* (((unsigned HOST_WIDE_INT
)1 << (HOST_BITS_PER_WIDE_INT
- 1)) % 5)
290 /* Quotient is 2^HOST_WIDE_INT*qhi+qlo, remainder is ulo. */
295 /* Returns the index of TYPE in the typevec, or -1 if it's not there. */
298 old_backref_index (type
)
303 if (! is_back_referenceable_type (type
))
306 /* The entry for this parm is at maxtype-1, so don't look there for
307 something to repeat. */
308 for (tindex
= 0; tindex
< maxtype
- 1; ++tindex
)
309 if (same_type_p (VARRAY_TREE (typevec
, tindex
), type
))
312 if (tindex
== maxtype
- 1)
318 /* Old mangling style: If TYPE has already been used in the parameter list,
319 emit a backward reference and return non-zero; otherwise, return 0.
321 NREPEATS is the number of repeats we've recorded of this type, or 0 if
322 this is the first time we've seen it and we're just looking to see if
323 it had been used before. */
326 flush_repeats (nrepeats
, type
)
330 int tindex
= old_backref_index (type
);
334 my_friendly_assert (nrepeats
== 0, 990316);
354 /* Returns nonzero iff this is a type to which we will want to make
355 back-references (using the `B' code). */
358 is_back_referenceable_type (type
)
361 /* For some reason, the Java folks don't want back refs on these. */
362 if (TYPE_FOR_JAVA (type
))
365 switch (TREE_CODE (type
))
368 if (!flag_do_squangling
)
369 /* Even though the mangling of this is just `b', we did
370 historically generate back-references for it. */
377 /* These types have single-character manglings, so there's no
378 point in generating back-references. */
381 case TEMPLATE_TYPE_PARM
:
382 /* It would be a bit complex to demangle signatures correctly if
383 we generated back-references to these, and the manglings of
384 type parameters are short. */
392 /* Issue the squangling code indicating NREPEATS repetitions of TYPE,
393 which was the last parameter type output. */
396 issue_nrepeats (nrepeats
, type
)
400 if (nrepeats
== 1 && !is_back_referenceable_type (type
))
401 /* For types whose manglings are short, don't bother using the
402 repetition code if there's only one repetition, since the
403 repetition code will be about as long as the ordinary mangling. */
404 build_mangled_name_for_type (type
);
414 /* Check to see if a tree node has been entered into the Kcode typelist.
415 If not, add it. Returns -1 if it isn't found, otherwise returns the
419 check_ktype (node
, add
)
424 tree localnode
= node
;
426 if (ktypelist
== NULL
)
429 if (TREE_CODE (node
) == TYPE_DECL
)
430 localnode
= TREE_TYPE (node
);
432 for (x
= 0; x
< maxktype
; x
++)
434 if (same_type_p (localnode
, VARRAY_TREE (ktypelist
, x
)))
437 /* Didn't find it, so add it here. */
440 if (VARRAY_SIZE (ktypelist
) <= maxktype
)
441 VARRAY_GROW (ktypelist
,
442 VARRAY_SIZE (ktypelist
) * 3 / 2);
443 VARRAY_TREE (ktypelist
, maxktype
) = localnode
;
455 kindex
= check_ktype (decl
, FALSE
);
467 /* Build a representation for DECL, which may be an entity not at
468 global scope. If so, a marker indicating that the name is
469 qualified has already been output, but the qualifying context has
473 build_overload_nested_name (decl
)
478 if (ktypelist
&& issue_ktype (decl
))
481 if (decl
== global_namespace
)
484 context
= CP_DECL_CONTEXT (decl
);
486 /* try to issue a K type, and if we can't continue the normal path */
487 if (!(ktypelist
&& issue_ktype (context
)))
489 /* For a template type parameter, we want to output an 'Xn'
490 rather than 'T' or some such. */
491 if (TREE_CODE (context
) == TEMPLATE_TYPE_PARM
492 || TREE_CODE (context
) == TEMPLATE_TEMPLATE_PARM
)
493 build_mangled_name_for_type (context
);
496 if (TREE_CODE_CLASS (TREE_CODE (context
)) == 't')
497 context
= TYPE_NAME (context
);
498 build_overload_nested_name (context
);
502 if (TREE_CODE (decl
) == FUNCTION_DECL
)
504 static int static_labelno
;
506 tree name
= DECL_ASSEMBLER_NAME (decl
);
509 ASM_FORMAT_PRIVATE_NAME (label
, IDENTIFIER_POINTER (name
), static_labelno
);
512 if (numeric_output_need_bar
)
514 icat (strlen (label
));
516 numeric_output_need_bar
= 1;
518 else if (TREE_CODE (decl
) == NAMESPACE_DECL
)
519 build_overload_identifier (DECL_NAME (decl
));
521 build_overload_identifier (decl
);
524 /* Output the decimal representation of I. If I > 9, the decimal
525 representation is preceeded and followed by an underscore. */
528 build_underscore_int (i
)
539 build_overload_scope_ref (value
)
543 numeric_output_need_bar
= 0;
544 build_mangled_name_for_type (TREE_OPERAND (value
, 0));
545 build_overload_identifier (TREE_OPERAND (value
, 1));
548 /* Encoding for an INTEGER_CST value. */
551 build_overload_int (value
, in_template
)
555 if (in_template
&& TREE_CODE (value
) != INTEGER_CST
)
557 if (TREE_CODE (value
) == SCOPE_REF
)
559 build_overload_scope_ref (value
);
564 numeric_output_need_bar
= 0;
566 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (value
))))
569 int operands
= tree_code_length
[(int) TREE_CODE (value
)];
573 id
= ansi_opname
[(int) TREE_CODE (value
)];
574 my_friendly_assert (id
!= NULL_TREE
, 0);
575 name
= IDENTIFIER_POINTER (id
);
576 if (name
[0] != '_' || name
[1] != '_')
577 /* On some erroneous inputs, we can get here with VALUE a
578 LOOKUP_EXPR. In that case, the NAME will be the
579 identifier for "<invalid operator>". We must survive
580 this routine in order to issue a sensible error
581 message, so we fall through to the case below. */
584 for (i
= 0; i
< operands
; ++i
)
589 /* We just outputted either the `E' or the name of the
591 numeric_output_need_bar
= 0;
594 /* Skip the leading underscores. */
597 operand
= TREE_OPERAND (value
, i
);
598 tc
= TREE_CODE (operand
);
600 if (TREE_CODE_CLASS (tc
) == 't')
601 /* We can get here with sizeof, e.g.:
603 template <class T> void f(A<sizeof(T)>); */
604 build_mangled_name_for_type (operand
);
605 else if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (tc
)))
606 build_overload_int (operand
, in_template
);
608 build_overload_value (TREE_TYPE (operand
),
615 /* We don't ever want this output, but it's
616 inconvenient not to be able to build the string.
617 This should cause assembler errors we'll notice. */
621 sprintf (digit_buffer
, " *%d", n
++);
622 OB_PUTCP (digit_buffer
);
626 numeric_output_need_bar
= 0;
630 my_friendly_assert (TREE_CODE (value
) == INTEGER_CST
, 243);
631 if (TYPE_PRECISION (TREE_TYPE (value
)) == 2 * HOST_BITS_PER_WIDE_INT
)
633 if (TREE_INT_CST_HIGH (value
)
634 != (TREE_INT_CST_LOW (value
) >> (HOST_BITS_PER_WIDE_INT
- 1)))
636 /* need to print a DImode value in decimal */
637 dicat (TREE_INT_CST_LOW (value
), TREE_INT_CST_HIGH (value
));
638 numeric_output_need_bar
= 1;
641 /* else fall through to print in smaller mode */
643 /* Wordsize or smaller */
644 icat (TREE_INT_CST_LOW (value
));
645 numeric_output_need_bar
= 1;
649 /* Output S followed by a representation of the TEMPLATE_PARM_INDEX
650 supplied in INDEX. */
653 build_mangled_template_parm_index (s
, index
)
658 build_underscore_int (TEMPLATE_PARM_IDX (index
));
659 /* We use the LEVEL, not the ORIG_LEVEL, because the mangling is a
660 representation of the function from the point of view of its
662 build_underscore_int (TEMPLATE_PARM_LEVEL (index
));
666 /* Mangling for C9X integer types (and Cygnus extensions for 128-bit
667 and other types) is based on the letter "I" followed by the hex
668 representations of the bitsize for the type in question. For
669 encodings that result in larger than two digits, a leading and
670 trailing underscore is added.
681 int256_t = 100 = I_100_
682 int512_t = 200 = I_200_
684 Given an integer in decimal format, mangle according to this scheme. */
686 #if HOST_BITS_PER_WIDE_INT >= 64
688 build_mangled_C9x_name (bits
)
691 char mangled
[10] = "";
694 sprintf (mangled
, "I_%x_", bits
);
696 sprintf (mangled
, "I%.2x", bits
);
703 build_overload_value (type
, value
, in_template
)
707 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (type
)) == 't', 0);
709 while (TREE_CODE (value
) == NON_LVALUE_EXPR
710 || TREE_CODE (value
) == NOP_EXPR
)
711 value
= TREE_OPERAND (value
, 0);
713 if (numeric_output_need_bar
)
716 numeric_output_need_bar
= 0;
719 if (TREE_CODE (value
) == TEMPLATE_PARM_INDEX
)
721 build_mangled_template_parm_index ("Y", value
);
725 if (TYPE_PTRMEM_P (type
))
727 if (TREE_CODE (value
) != PTRMEM_CST
)
728 /* We should have already rejected this pointer to member,
729 since it is not a constant. */
730 my_friendly_abort (0);
732 /* Get the actual FIELD_DECL. */
733 value
= PTRMEM_CST_MEMBER (value
);
734 my_friendly_assert (TREE_CODE (value
) == FIELD_DECL
, 0);
736 /* Output the name of the field. */
737 build_overload_identifier (DECL_NAME (value
));
741 switch (TREE_CODE (type
))
747 build_overload_int (value
, in_template
);
753 char *bufp
= digit_buffer
;
755 pedwarn ("ANSI C++ forbids floating-point template arguments");
757 my_friendly_assert (TREE_CODE (value
) == REAL_CST
, 244);
758 val
= TREE_REAL_CST (value
);
759 if (REAL_VALUE_ISNAN (val
))
761 sprintf (bufp
, "NaN");
765 if (REAL_VALUE_NEGATIVE (val
))
767 val
= REAL_VALUE_NEGATE (val
);
770 if (REAL_VALUE_ISINF (val
))
772 sprintf (bufp
, "Infinity");
776 REAL_VALUE_TO_DECIMAL (val
, "%.20e", bufp
);
777 bufp
= (char *) index (bufp
, 'e');
779 strcat (digit_buffer
, "e0");
805 #ifdef NO_DOT_IN_LABEL
806 bufp
= (char *) index (bufp
, '.');
812 OB_PUTCP (digit_buffer
);
813 numeric_output_need_bar
= 1;
817 if (TREE_CODE (value
) == INTEGER_CST
)
819 build_overload_int (value
, in_template
);
822 else if (TREE_CODE (value
) == TEMPLATE_PARM_INDEX
)
824 build_mangled_template_parm_index ("", value
);
825 numeric_output_need_bar
= 1;
829 value
= TREE_OPERAND (value
, 0);
834 if (TREE_CODE (value
) == VAR_DECL
)
836 my_friendly_assert (DECL_NAME (value
) != 0, 245);
837 build_overload_identifier (DECL_ASSEMBLER_NAME (value
));
840 else if (TREE_CODE (value
) == FUNCTION_DECL
)
842 my_friendly_assert (DECL_NAME (value
) != 0, 246);
843 build_overload_identifier (DECL_ASSEMBLER_NAME (value
));
846 else if (TREE_CODE (value
) == SCOPE_REF
)
847 build_overload_scope_ref (value
);
849 my_friendly_abort (71);
850 break; /* not really needed */
859 my_friendly_assert (TYPE_PTRMEMFUNC_P (type
), 0);
861 /* We'll get a ADDR_EXPR of a SCOPE_REF here if we're
862 mangling, an instantiation of something like:
864 template <class T, void (T::*fp)()> class C {};
865 template <class T> C<T, &T::f> x();
867 We mangle the return type of the function, and that
868 contains template parameters. */
869 if (TREE_CODE (value
) == ADDR_EXPR
870 && TREE_CODE (TREE_OPERAND (value
, 0)) == SCOPE_REF
)
872 build_overload_scope_ref (TREE_OPERAND (value
, 0));
876 my_friendly_assert (TREE_CODE (value
) == PTRMEM_CST
, 0);
878 expand_ptrmemfunc_cst (value
, &delta
, &idx
, &pfn
, &delta2
);
879 build_overload_int (delta
, in_template
);
881 build_overload_int (idx
, in_template
);
885 numeric_output_need_bar
= 0;
886 build_overload_identifier (DECL_ASSEMBLER_NAME
887 (PTRMEM_CST_MEMBER (value
)));
892 build_overload_int (delta2
, in_template
);
898 sorry ("conversion of %s as template parameter",
899 tree_code_name
[(int) TREE_CODE (type
)]);
900 my_friendly_abort (72);
905 /* Add encodings for the declaration of template template parameters.
906 PARMLIST must be a TREE_VEC. */
909 build_template_template_parm_names (parmlist
)
914 my_friendly_assert (TREE_CODE (parmlist
) == TREE_VEC
, 246.5);
915 nparms
= TREE_VEC_LENGTH (parmlist
);
917 for (i
= 0; i
< nparms
; i
++)
919 tree parm
= TREE_VALUE (TREE_VEC_ELT (parmlist
, i
));
920 if (TREE_CODE (parm
) == TYPE_DECL
)
922 /* This parameter is a type. */
925 else if (TREE_CODE (parm
) == TEMPLATE_DECL
)
927 /* This parameter is a template. */
929 build_template_template_parm_names (DECL_INNERMOST_TEMPLATE_PARMS (parm
));
932 /* It's a PARM_DECL. */
933 build_mangled_name_for_type (TREE_TYPE (parm
));
938 /* Add encodings for the vector of template parameters in PARMLIST,
939 given the vector of arguments to be substituted in ARGLIST. */
942 build_template_parm_names (parmlist
, arglist
)
947 tree inner_args
= innermost_args (arglist
);
949 nparms
= TREE_VEC_LENGTH (parmlist
);
951 for (i
= 0; i
< nparms
; i
++)
953 tree parm
= TREE_VALUE (TREE_VEC_ELT (parmlist
, i
));
954 tree arg
= TREE_VEC_ELT (inner_args
, i
);
955 if (TREE_CODE (parm
) == TYPE_DECL
)
957 /* This parameter is a type. */
959 build_mangled_name_for_type (arg
);
961 else if (TREE_CODE (parm
) == TEMPLATE_DECL
)
963 /* This parameter is a template. */
964 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
965 /* Output parameter declaration, argument index and level. */
966 build_mangled_name_for_type (arg
);
969 /* A TEMPLATE_DECL node, output the parameter declaration
973 build_template_template_parm_names
974 (DECL_INNERMOST_TEMPLATE_PARMS (parm
));
975 icat (IDENTIFIER_LENGTH (DECL_NAME (arg
)));
976 OB_PUTID (DECL_NAME (arg
));
981 parm
= tsubst (parm
, arglist
, /*complain=*/1, NULL_TREE
);
982 /* It's a PARM_DECL. */
983 build_mangled_name_for_type (TREE_TYPE (parm
));
984 build_overload_value (TREE_TYPE (parm
), arg
,
985 uses_template_parms (arglist
));
990 /* Output the representation for NAME, which is either a TYPE_DECL or
994 build_overload_identifier (name
)
997 if (TREE_CODE (name
) == TYPE_DECL
998 && CLASS_TYPE_P (TREE_TYPE (name
))
999 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (name
))
1000 && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (TREE_TYPE (name
)))
1001 || (TREE_CODE (CP_DECL_CONTEXT (CLASSTYPE_TI_TEMPLATE
1002 (TREE_TYPE (name
))))
1005 /* NAME is the TYPE_DECL for a template specialization. */
1006 tree
template, parmlist
, arglist
, tname
;
1007 template = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (name
));
1008 arglist
= CLASSTYPE_TI_ARGS (TREE_TYPE (name
));
1009 tname
= DECL_NAME (template);
1010 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
1012 icat (IDENTIFIER_LENGTH (tname
));
1014 build_template_parm_names (parmlist
, arglist
);
1018 if (TREE_CODE (name
) == TYPE_DECL
)
1019 name
= DECL_NAME (name
);
1020 if (numeric_output_need_bar
)
1023 numeric_output_need_bar
= 0;
1025 icat (IDENTIFIER_LENGTH (name
));
1030 /* Given DECL, either a class TYPE, TYPE_DECL or FUNCTION_DECL, produce
1031 the mangling for it. Used by build_mangled_name and build_static_name. */
1034 build_qualified_name (decl
)
1040 if (TREE_CODE_CLASS (TREE_CODE (decl
)) == 't')
1041 decl
= TYPE_NAME (decl
);
1043 /* If DECL_ASSEMBLER_NAME has been set properly, use it. */
1044 if (TREE_CODE (decl
) == TYPE_DECL
1045 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
) && !flag_do_squangling
)
1047 tree id
= DECL_ASSEMBLER_NAME (decl
);
1049 if (ISDIGIT (IDENTIFIER_POINTER (id
) [IDENTIFIER_LENGTH (id
) - 1]))
1050 numeric_output_need_bar
= 1;
1055 /* If we can't find a Ktype, do it the hard way. */
1056 if (check_ktype (context
, FALSE
) == -1)
1058 /* Count type and namespace scopes. */
1061 context
= CP_DECL_CONTEXT (context
);
1062 if (context
== global_namespace
)
1065 if (check_ktype (context
, FALSE
) != -1)
1068 if (TREE_CODE_CLASS (TREE_CODE (context
)) == 't')
1069 context
= TYPE_NAME (context
);
1076 build_underscore_int (i
);
1077 numeric_output_need_bar
= 0;
1079 build_overload_nested_name (decl
);
1082 /* Output the mangled representation for TYPE. If EXTRA_GCODE is
1083 non-zero, mangled names for structure/union types are intentionally
1084 mangled differently from the method described in the ARM. */
1087 build_mangled_name_for_type_with_Gcode (type
, extra_Gcode
)
1091 if (TYPE_PTRMEMFUNC_P (type
))
1092 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
1093 process_modifiers (type
);
1094 process_overload_item (type
, extra_Gcode
);
1097 /* Like build_mangled_name_for_type_with_Gcode, but never outputs the
1101 build_mangled_name_for_type (type
)
1104 build_mangled_name_for_type_with_Gcode (type
, 0);
1107 /* Given a list of parameters in PARMTYPES, create an unambiguous
1108 overload string. Should distinguish any type that C (or C++) can
1109 distinguish. I.e., pointers to functions are treated correctly.
1111 Caller must deal with whether a final `e' goes on the end or not.
1113 Any default conversions must take place before this function
1116 BEGIN and END control initialization and finalization of the
1117 obstack where we build the string. */
1120 build_overload_name (parmtypes
, begin
, end
)
1125 start_squangling ();
1126 ret
= build_mangled_name (parmtypes
, begin
, end
);
1131 /* Output the mangled representation for PARMTYPES. If PARMTYPES is a
1132 TREE_LIST, then it is a list of parameter types. Otherwise,
1133 PARMTYPES must be a single type. */
1136 build_mangled_name (parmtypes
, begin
, end
)
1143 if (TREE_CODE (parmtypes
) != TREE_LIST
)
1144 /* There is only one type. */
1145 build_mangled_name_for_type (parmtypes
);
1148 /* There are several types in a parameter list. */
1150 int old_style_repeats
= !flag_do_squangling
&& !nofold
&& typevec
;
1151 tree last_type
= NULL_TREE
;
1153 for (; parmtypes
&& parmtypes
!= void_list_node
;
1154 parmtypes
= TREE_CHAIN (parmtypes
))
1156 /* We used to call canonical_type_variant here, but that isn't
1157 good enough; it doesn't handle pointers to typedef types. So
1158 we can't just set TREE_USED to say we've seen a type already;
1159 we have to check each of the earlier types with same_type_p. */
1160 tree parmtype
= TREE_VALUE (parmtypes
);
1162 if (old_style_repeats
)
1164 /* Every argument gets counted. */
1165 my_friendly_assert (maxtype
< VARRAY_SIZE (typevec
), 387);
1166 VARRAY_TREE (typevec
, maxtype
) = parmtype
;
1170 if (last_type
&& same_type_p (parmtype
, last_type
))
1172 if (flag_do_squangling
1173 || (old_style_repeats
1174 && is_back_referenceable_type (parmtype
)))
1176 /* The next type is the same as this one. Keep
1177 track of the repetition, and output the repeat
1183 else if (nrepeats
!= 0)
1185 /* Indicate how many times the previous parameter was
1187 if (old_style_repeats
)
1188 flush_repeats (nrepeats
, last_type
);
1190 issue_nrepeats (nrepeats
, last_type
);
1194 last_type
= parmtype
;
1196 /* Note that for bug-compatibility with 2.7.2, we can't build up
1197 repeats of types other than the most recent one. So we call
1198 flush_repeats every round, if we get this far. */
1199 if (old_style_repeats
&& flush_repeats (0, parmtype
))
1202 /* Output the PARMTYPE. */
1203 build_mangled_name_for_type_with_Gcode (parmtype
, 1);
1206 /* Output the repeat count for the last parameter, if
1210 if (old_style_repeats
)
1211 flush_repeats (nrepeats
, last_type
);
1213 issue_nrepeats (nrepeats
, last_type
);
1218 /* The parameter list ends in an ellipsis. */
1224 return (char *)obstack_base (&scratch_obstack
);
1227 /* Emit modifiers such as constant, read-only, and volatile. */
1230 process_modifiers (parmtype
)
1233 /* Note that here we do not use CP_TYPE_CONST_P and friends because
1234 we describe types recursively; we will get the `const' in
1235 `const int ()[10]' when processing the `const int' part. */
1236 if (TYPE_READONLY (parmtype
))
1238 if (TREE_CODE (parmtype
) == INTEGER_TYPE
1239 && parmtype
!= char_type_node
1240 && parmtype
!= wchar_type_node
1241 && (TYPE_MAIN_VARIANT (parmtype
)
1242 == unsigned_type (TYPE_MAIN_VARIANT (parmtype
)))
1243 && ! TYPE_FOR_JAVA (parmtype
))
1245 if (TYPE_VOLATILE (parmtype
))
1247 /* It would be better to use `R' for `restrict', but that's already
1248 used for reference types. And `r' is used for `long double'. */
1249 if (TYPE_RESTRICT (parmtype
))
1253 /* Check to see if TYPE has been entered into the Bcode typelist. If
1254 so, return 1 and emit a backreference to TYPE. Otherwise, add TYPE
1255 to the list of back-referenceable types and return 0. */
1263 if (btypelist
== NULL
)
1266 if (!is_back_referenceable_type (type
))
1269 for (x
= 0; x
< maxbtype
; x
++)
1270 if (same_type_p (type
, VARRAY_TREE (btypelist
, x
)))
1279 if (VARRAY_SIZE (btypelist
) <= maxbtype
)
1280 /* Enlarge the table. */
1281 VARRAY_GROW (btypelist
,
1282 VARRAY_SIZE (btypelist
) * 3 / 2);
1284 /* Register the TYPE. */
1285 VARRAY_TREE (btypelist
, maxbtype
) = type
;
1291 /* Emit the correct code for various node types. */
1294 process_overload_item (parmtype
, extra_Gcode
)
1298 numeric_output_need_bar
= 0;
1300 /* Our caller should have already handed any qualifiers, so pull out the
1301 TYPE_MAIN_VARIANT to avoid typedef confusion. Except we can't do that
1302 for arrays, because they are transparent to qualifiers. Sigh. */
1303 if (TREE_CODE (parmtype
) == ARRAY_TYPE
)
1304 parmtype
= canonical_type_variant (parmtype
);
1306 parmtype
= TYPE_MAIN_VARIANT (parmtype
);
1308 /* These tree types are considered modifiers for B code squangling,
1309 and therefore should not get entries in the Btypelist. They are,
1310 however, repeatable types. */
1312 switch (TREE_CODE (parmtype
))
1314 case REFERENCE_TYPE
:
1319 #if PARM_CAN_BE_ARRAY_TYPE
1322 if (TYPE_DOMAIN (parmtype
) == NULL_TREE
)
1326 tree length
= array_type_nelts (parmtype
);
1327 if (TREE_CODE (length
) != INTEGER_CST
|| flag_do_squangling
)
1329 length
= fold (build (PLUS_EXPR
, TREE_TYPE (length
),
1330 length
, integer_one_node
));
1331 STRIP_NOPS (length
);
1333 build_overload_value (sizetype
, length
, 1);
1335 if (numeric_output_need_bar
&& ! flag_do_squangling
)
1347 build_mangled_name_for_type (TREE_TYPE (parmtype
));
1355 if (flag_do_squangling
&& check_btype (parmtype
))
1356 /* If PARMTYPE is already in the list of back-referenceable types,
1357 then check_btype will output the appropriate reference, and
1358 there's nothing more to do. */
1361 switch (TREE_CODE (parmtype
))
1365 build_mangled_name_for_type (TYPE_OFFSET_BASETYPE (parmtype
));
1367 build_mangled_name_for_type (TREE_TYPE (parmtype
));
1373 tree parms
= TYPE_ARG_TYPES (parmtype
);
1375 /* Rather than implementing a reentrant TYPEVEC, we turn off
1376 repeat codes here, unless we're squangling. Squangling
1377 doesn't make use of the TYPEVEC, so there's no reentrancy
1379 int old_nofold
= nofold
;
1380 if (!flag_do_squangling
)
1383 if (TREE_CODE (parmtype
) == METHOD_TYPE
)
1385 /* Mark this as a method. */
1387 /* Output the class of which this method is a member. */
1388 build_mangled_name_for_type (TYPE_METHOD_BASETYPE (parmtype
));
1389 /* Output any qualifiers for the `this' parameter. */
1390 process_modifiers (TREE_TYPE (TREE_VALUE (parms
)));
1393 /* Output the parameter types. */
1395 if (parms
== NULL_TREE
)
1397 else if (parms
== void_list_node
)
1400 build_mangled_name (parms
, 0, 0);
1402 /* Output the return type. */
1404 build_mangled_name_for_type (TREE_TYPE (parmtype
));
1406 nofold
= old_nofold
;
1411 if (parmtype
== integer_type_node
1412 || parmtype
== unsigned_type_node
1413 || parmtype
== java_int_type_node
)
1415 else if (parmtype
== long_integer_type_node
1416 || parmtype
== long_unsigned_type_node
)
1418 else if (parmtype
== short_integer_type_node
1419 || parmtype
== short_unsigned_type_node
1420 || parmtype
== java_short_type_node
)
1422 else if (parmtype
== signed_char_type_node
)
1427 else if (parmtype
== char_type_node
1428 || parmtype
== unsigned_char_type_node
1429 || parmtype
== java_byte_type_node
)
1431 else if (parmtype
== wchar_type_node
1432 || parmtype
== java_char_type_node
)
1434 else if (parmtype
== long_long_integer_type_node
1435 || parmtype
== long_long_unsigned_type_node
1436 || parmtype
== java_long_type_node
)
1438 else if (parmtype
== java_boolean_type_node
)
1440 #if HOST_BITS_PER_WIDE_INT >= 64
1443 int bits
= TREE_INT_CST_LOW (TYPE_SIZE (parmtype
));
1444 build_mangled_C9x_name (bits
);
1448 my_friendly_abort (73);
1457 if (parmtype
== long_double_type_node
)
1459 else if (parmtype
== double_type_node
1460 || parmtype
== java_double_type_node
)
1462 else if (parmtype
== float_type_node
1463 || parmtype
== java_float_type_node
)
1465 else my_friendly_abort (74);
1470 build_mangled_name_for_type (TREE_TYPE (parmtype
));
1477 case ERROR_MARK
: /* not right, but nothing is anyway */
1480 /* have to do these */
1485 OB_PUTC ('G'); /* make it look incompatible with AT&T */
1486 /* drop through into next case */
1490 tree name
= TYPE_NAME (parmtype
);
1492 my_friendly_assert (TREE_CODE (name
) == TYPE_DECL
, 248);
1494 build_qualified_name (name
);
1499 /* This will take some work. */
1503 case TEMPLATE_TEMPLATE_PARM
:
1504 /* Find and output the original template parameter
1506 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parmtype
))
1508 build_mangled_template_parm_index ("tzX",
1509 TEMPLATE_TYPE_PARM_INDEX
1511 build_template_parm_names
1512 (DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (parmtype
)),
1513 TYPE_TI_ARGS (parmtype
));
1517 build_mangled_template_parm_index ("ZzX",
1518 TEMPLATE_TYPE_PARM_INDEX
1520 build_template_template_parm_names
1521 (DECL_INNERMOST_TEMPLATE_PARMS (TYPE_STUB_DECL (parmtype
)));
1525 case TEMPLATE_TYPE_PARM
:
1526 build_mangled_template_parm_index ("X",
1527 TEMPLATE_TYPE_PARM_INDEX
1532 /* When mangling the type of a function template whose
1533 declaration looks like:
1535 template <class T> void foo(typename T::U)
1537 we have to mangle these. */
1538 build_qualified_name (parmtype
);
1542 my_friendly_abort (75);
1547 /* Produce the mangling for a variable named NAME in CONTEXT, which can
1548 be either a class TYPE or a FUNCTION_DECL. */
1551 build_static_name (context
, name
)
1555 numeric_output_need_bar
= 0;
1556 start_squangling ();
1559 build_qualified_name (context
);
1562 OB_PUTS ("__static_");
1563 build_qualified_name (context
);
1570 return get_identifier ((char *)obstack_base (&scratch_obstack
));
1573 /* FOR_METHOD should be 1 if the declaration in question is for a member
1574 of a class (including a static member) and 2 if the declaration is
1575 for a constructor. */
1577 build_decl_overload_real (dname
, parms
, ret_type
, tparms
, targs
,
1586 const char *name
= IDENTIFIER_POINTER (dname
);
1588 /* member operators new and delete look like methods at this point. */
1589 if (! for_method
&& parms
!= NULL_TREE
&& TREE_CODE (parms
) == TREE_LIST
1590 && TREE_CHAIN (parms
) == void_list_node
)
1592 if (dname
== ansi_opname
[(int) DELETE_EXPR
])
1593 return get_identifier ("__builtin_delete");
1594 else if (dname
== ansi_opname
[(int) VEC_DELETE_EXPR
])
1595 return get_identifier ("__builtin_vec_delete");
1596 if (dname
== ansi_opname
[(int) NEW_EXPR
])
1597 return get_identifier ("__builtin_new");
1598 else if (dname
== ansi_opname
[(int) VEC_NEW_EXPR
])
1599 return get_identifier ("__builtin_vec_new");
1602 start_squangling ();
1604 if (for_method
!= 2)
1606 /* Otherwise, we can divine that this is a constructor,
1607 and figure out its name without any extra encoding. */
1609 OB_PUTC2 ('_', '_');
1610 numeric_output_need_bar
= 0;
1615 build_template_parm_names (tparms
, targs
);
1618 else if (!for_method
&& current_namespace
== global_namespace
)
1619 /* XXX this works only if we call this in the same namespace
1620 as the declaration. Unfortunately, we don't have the _DECL,
1624 if (!for_method
&& current_namespace
!= global_namespace
)
1625 /* qualify with namespace */
1626 build_qualified_name (current_namespace
);
1628 if (parms
== NULL_TREE
)
1630 else if (parms
== void_list_node
)
1634 if (!flag_do_squangling
)
1636 /* Allocate typevec array. */
1637 size_t typevec_size
= list_length (parms
);
1639 if (!for_method
&& current_namespace
!= global_namespace
)
1640 /* The namespace of a global function needs one slot. */
1642 VARRAY_TREE_INIT (typevec
, typevec_size
, "typevec");
1648 tree this_type
= TREE_TYPE (TREE_VALUE (parms
));
1650 build_mangled_name_for_type (this_type
);
1652 if (!flag_do_squangling
)
1654 my_friendly_assert (maxtype
< VARRAY_SIZE (typevec
), 387);
1655 VARRAY_TREE (typevec
, maxtype
) = this_type
;
1659 if (TREE_CHAIN (parms
))
1660 build_mangled_name (TREE_CHAIN (parms
), 0, 0);
1666 /* the namespace qualifier for a global function
1667 will count as type */
1668 if (current_namespace
!= global_namespace
1669 && !flag_do_squangling
)
1671 my_friendly_assert (maxtype
< VARRAY_SIZE (typevec
), 387);
1672 VARRAY_TREE (typevec
, maxtype
) = current_namespace
;
1675 build_mangled_name (parms
, 0, 0);
1678 if (!flag_do_squangling
)
1679 /* Deallocate typevec array. */
1680 VARRAY_FREE (typevec
);
1683 if (ret_type
!= NULL_TREE
&& for_method
!= 2)
1685 /* Add the return type. */
1687 build_mangled_name_for_type (ret_type
);
1693 tree n
= get_identifier (obstack_base (&scratch_obstack
));
1694 if (IDENTIFIER_OPNAME_P (dname
))
1695 IDENTIFIER_OPNAME_P (n
) = 1;
1700 /* Change the name of a function definition so that it may be
1701 overloaded. NAME is the name of the function to overload,
1702 PARMS is the parameter list (which determines what name the
1703 final function obtains).
1705 FOR_METHOD is 1 if this overload is being performed
1706 for a method, rather than a function type. It is 2 if
1707 this overload is being performed for a constructor. */
1710 build_decl_overload (dname
, parms
, for_method
)
1715 return build_decl_overload_real (dname
, parms
, NULL_TREE
, NULL_TREE
,
1716 NULL_TREE
, for_method
);
1719 /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL. */
1722 set_mangled_name_for_decl (decl
)
1727 if (processing_template_decl
)
1728 /* There's no need to mangle the name of a template function. */
1731 parm_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1733 if (DECL_STATIC_FUNCTION_P (decl
))
1735 hash_tree_chain (build_pointer_type (DECL_CLASS_CONTEXT (decl
)),
1738 /* The only member functions whose type is a FUNCTION_TYPE, rather
1739 than a METHOD_TYPE, should be static members. */
1740 my_friendly_assert (!DECL_CONTEXT (decl
)
1741 || !IS_AGGR_TYPE_CODE (TREE_CODE (DECL_CONTEXT (decl
)))
1742 || TREE_CODE (TREE_TYPE (decl
)) != FUNCTION_TYPE
,
1745 DECL_ASSEMBLER_NAME (decl
)
1746 = build_decl_overload (DECL_NAME (decl
), parm_types
,
1747 DECL_FUNCTION_MEMBER_P (decl
)
1748 + DECL_CONSTRUCTOR_P (decl
));
1751 /* Build an overload name for the type expression TYPE. */
1754 build_typename_overload (type
)
1760 OB_PUTID (ansi_opname
[(int) TYPE_EXPR
]);
1762 start_squangling ();
1763 build_mangled_name (type
, 0, 1);
1764 id
= get_identifier (obstack_base (&scratch_obstack
));
1765 IDENTIFIER_OPNAME_P (id
) = 1;
1767 IDENTIFIER_GLOBAL_VALUE (id
) = TYPE_MAIN_DECL (type
);
1769 TREE_TYPE (id
) = type
;
1775 build_overload_with_type (name
, type
)
1782 start_squangling ();
1783 build_mangled_name (type
, 0, 1);
1785 return get_identifier (obstack_base (&scratch_obstack
));
1789 get_id_2 (name
, name2
)
1797 return get_identifier (obstack_base (&scratch_obstack
));
1800 /* Returns a DECL_ASSEMBLER_NAME for the destructor of type TYPE. */
1803 build_destructor_name (type
)
1806 return build_overload_with_type (get_identifier (DESTRUCTOR_DECL_PREFIX
),
1810 /* Given a tree_code CODE, and some arguments (at least one),
1811 attempt to use an overloaded operator on the arguments.
1813 For unary operators, only the first argument need be checked.
1814 For binary operators, both arguments may need to be checked.
1816 Member functions can convert class references to class pointers,
1817 for one-level deep indirection. More than that is not supported.
1818 Operators [](), ()(), and ->() must be member functions.
1820 We call function call building calls with LOOKUP_COMPLAIN if they
1821 are our only hope. This is true when we see a vanilla operator
1822 applied to something of aggregate type. If this fails, we are free
1823 to return `error_mark_node', because we will have reported the
1826 Operators NEW and DELETE overload in funny ways: operator new takes
1827 a single `size' parameter, and operator delete takes a pointer to the
1828 storage being deleted. When overloading these operators, success is
1829 assumed. If there is a failure, report an error message and return
1830 `error_mark_node'. */
1834 build_opfncall (code
, flags
, xarg1
, xarg2
, arg3
)
1835 enum tree_code code
;
1837 tree xarg1
, xarg2
, arg3
;
1839 return build_new_op (code
, flags
, xarg1
, xarg2
, arg3
);
1842 /* This function takes an identifier, ID, and attempts to figure out what
1843 it means. There are a number of possible scenarios, presented in increasing
1846 1) not in a class's scope
1847 2) in class's scope, member name of the class's method
1848 3) in class's scope, but not a member name of the class
1849 4) in class's scope, member name of a class's variable
1851 NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
1852 VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
1854 As a last ditch, try to look up the name as a label and return that
1857 Values which are declared as being of REFERENCE_TYPE are
1858 automatically dereferenced here (as a hack to make the
1859 compiler faster). */
1862 hack_identifier (value
, name
)
1867 if (value
== error_mark_node
)
1869 if (current_class_name
)
1871 tree fields
= lookup_fnfields (TYPE_BINFO (current_class_type
), name
, 1);
1872 if (fields
== error_mark_node
)
1873 return error_mark_node
;
1878 fndecl
= TREE_VALUE (fields
);
1879 my_friendly_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
, 251);
1880 /* I could not trigger this code. MvL */
1881 my_friendly_abort (980325);
1883 if (DECL_CHAIN (fndecl
) == NULL_TREE
)
1885 warning ("methods cannot be converted to function pointers");
1890 error ("ambiguous request for method pointer `%s'",
1891 IDENTIFIER_POINTER (name
));
1892 return error_mark_node
;
1897 if (flag_labels_ok
&& IDENTIFIER_LABEL_VALUE (name
))
1899 return IDENTIFIER_LABEL_VALUE (name
);
1901 return error_mark_node
;
1904 type
= TREE_TYPE (value
);
1905 if (TREE_CODE (value
) == FIELD_DECL
)
1907 if (current_class_ptr
== NULL_TREE
)
1909 if (current_function_decl
1910 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1911 cp_error ("invalid use of member `%D' in static member function",
1914 /* We can get here when processing a bad default
1916 struct S { int a; void f(int i = a); } */
1917 cp_error ("invalid use of member `%D'", value
);
1919 return error_mark_node
;
1921 TREE_USED (current_class_ptr
) = 1;
1923 /* Mark so that if we are in a constructor, and then find that
1924 this field was initialized by a base initializer,
1925 we can emit an error message. */
1926 TREE_USED (value
) = 1;
1927 value
= build_component_ref (current_class_ref
, name
, NULL_TREE
, 1);
1929 else if ((TREE_CODE (value
) == FUNCTION_DECL
1930 && DECL_FUNCTION_MEMBER_P (value
))
1931 || (TREE_CODE (value
) == OVERLOAD
1932 && DECL_FUNCTION_MEMBER_P (OVL_CURRENT (value
))))
1936 if (TREE_CODE (value
) == OVERLOAD
)
1937 value
= OVL_CURRENT (value
);
1939 decl
= maybe_dummy_object (DECL_CLASS_CONTEXT (value
), 0);
1940 value
= build_component_ref (decl
, name
, NULL_TREE
, 1);
1942 else if (really_overloaded_fn (value
))
1944 else if (TREE_CODE (value
) == OVERLOAD
)
1945 /* not really overloaded function */
1946 mark_used (OVL_FUNCTION (value
));
1947 else if (TREE_CODE (value
) == TREE_LIST
)
1949 /* Ambiguous reference to base members, possibly other cases?. */
1951 while (t
&& TREE_CODE (t
) == TREE_LIST
)
1953 mark_used (TREE_VALUE (t
));
1957 else if (TREE_CODE (value
) == NAMESPACE_DECL
)
1959 cp_error ("use of namespace `%D' as expression", value
);
1960 return error_mark_node
;
1962 else if (DECL_CLASS_TEMPLATE_P (value
))
1964 cp_error ("use of class template `%T' as expression", value
);
1965 return error_mark_node
;
1970 if (TREE_CODE (value
) == VAR_DECL
|| TREE_CODE (value
) == PARM_DECL
1971 || TREE_CODE (value
) == RESULT_DECL
)
1973 tree context
= decl_function_context (value
);
1974 if (context
!= NULL_TREE
&& context
!= current_function_decl
1975 && ! TREE_STATIC (value
))
1977 cp_error ("use of %s from containing function",
1978 (TREE_CODE (value
) == VAR_DECL
1979 ? "`auto' variable" : "parameter"));
1980 cp_error_at (" `%#D' declared here", value
);
1981 value
= error_mark_node
;
1985 if (TREE_CODE_CLASS (TREE_CODE (value
)) == 'd' && DECL_NONLOCAL (value
))
1987 if (DECL_LANG_SPECIFIC (value
)
1988 && DECL_CLASS_CONTEXT (value
) != current_class_type
)
1991 register tree context
1992 = (TREE_CODE (value
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (value
))
1993 ? DECL_CLASS_CONTEXT (value
)
1994 : DECL_CONTEXT (value
);
1996 get_base_distance (context
, current_class_type
, 0, &path
);
1997 if (path
&& !enforce_access (current_class_type
, value
))
1998 return error_mark_node
;
2001 else if (TREE_CODE (value
) == TREE_LIST
2002 && TREE_TYPE (value
) == error_mark_node
)
2004 error ("request for member `%s' is ambiguous in multiple inheritance lattice",
2005 IDENTIFIER_POINTER (name
));
2006 print_candidates (value
);
2007 return error_mark_node
;
2010 if (! processing_template_decl
)
2011 value
= convert_from_reference (value
);
2017 make_thunk (function
, delta
)
2025 if (TREE_CODE (function
) != ADDR_EXPR
)
2027 func_decl
= TREE_OPERAND (function
, 0);
2028 if (TREE_CODE (func_decl
) != FUNCTION_DECL
)
2032 OB_PUTS ("__thunk_");
2041 OB_PUTID (DECL_ASSEMBLER_NAME (func_decl
));
2043 thunk_id
= get_identifier (obstack_base (&scratch_obstack
));
2045 thunk
= IDENTIFIER_GLOBAL_VALUE (thunk_id
);
2046 if (thunk
&& TREE_CODE (thunk
) != THUNK_DECL
)
2048 cp_error ("implementation-reserved name `%D' used", thunk_id
);
2050 SET_IDENTIFIER_GLOBAL_VALUE (thunk_id
, thunk
);
2052 if (thunk
== NULL_TREE
)
2054 thunk
= build_decl (FUNCTION_DECL
, thunk_id
, TREE_TYPE (func_decl
));
2055 TREE_READONLY (thunk
) = TREE_READONLY (func_decl
);
2056 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (func_decl
);
2057 comdat_linkage (thunk
);
2058 TREE_SET_CODE (thunk
, THUNK_DECL
);
2059 DECL_INITIAL (thunk
) = function
;
2060 THUNK_DELTA (thunk
) = delta
;
2061 DECL_EXTERNAL (thunk
) = 1;
2062 DECL_ARTIFICIAL (thunk
) = 1;
2063 /* So that finish_file can write out any thunks that need to be: */
2064 pushdecl_top_level (thunk
);
2069 /* Emit the definition of a C++ multiple inheritance vtable thunk. */
2072 emit_thunk (thunk_fndecl
)
2075 tree function
= TREE_OPERAND (DECL_INITIAL (thunk_fndecl
), 0);
2076 int delta
= THUNK_DELTA (thunk_fndecl
);
2078 if (TREE_ASM_WRITTEN (thunk_fndecl
))
2081 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
2083 TREE_ADDRESSABLE (function
) = 1;
2084 mark_used (function
);
2086 if (current_function_decl
)
2089 TREE_SET_CODE (thunk_fndecl
, FUNCTION_DECL
);
2091 #ifdef ASM_OUTPUT_MI_THUNK
2092 if (!flag_syntax_only
)
2095 current_function_decl
= thunk_fndecl
;
2096 /* Make sure we build up its RTL before we go onto the
2097 temporary obstack. */
2098 make_function_rtl (thunk_fndecl
);
2099 temporary_allocation ();
2100 DECL_RESULT (thunk_fndecl
)
2101 = build_decl (RESULT_DECL
, 0, integer_type_node
);
2102 fnname
= XSTR (XEXP (DECL_RTL (thunk_fndecl
), 0), 0);
2103 init_function_start (thunk_fndecl
, input_filename
, lineno
);
2104 current_function_is_thunk
= 1;
2105 assemble_start_function (thunk_fndecl
, fnname
);
2106 ASM_OUTPUT_MI_THUNK (asm_out_file
, thunk_fndecl
, delta
, function
);
2107 assemble_end_function (thunk_fndecl
, fnname
);
2108 permanent_allocation (1);
2109 current_function_decl
= 0;
2110 current_function
= 0;
2112 #else /* ASM_OUTPUT_MI_THUNK */
2114 /* If we don't have the necessary macro for efficient thunks, generate a
2115 thunk function that just makes a call to the real function.
2116 Unfortunately, this doesn't work for varargs. */
2120 if (varargs_function_p (function
))
2121 cp_error ("generic thunk code fails for method `%#D' which uses `...'",
2124 /* Set up clone argument trees for the thunk. */
2126 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
2128 tree x
= copy_node (a
);
2130 DECL_CONTEXT (x
) = thunk_fndecl
;
2134 DECL_ARGUMENTS (thunk_fndecl
) = a
;
2135 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
2136 DECL_LANG_SPECIFIC (thunk_fndecl
) = DECL_LANG_SPECIFIC (function
);
2137 copy_lang_decl (thunk_fndecl
);
2138 DECL_INTERFACE_KNOWN (thunk_fndecl
) = 1;
2139 DECL_NOT_REALLY_EXTERN (thunk_fndecl
) = 1;
2141 start_function (NULL_TREE
, thunk_fndecl
, NULL_TREE
,
2142 SF_DEFAULT
| SF_PRE_PARSED
);
2143 store_parm_decls ();
2144 current_function_is_thunk
= 1;
2146 /* Build up the call to the real function. */
2147 t
= build_int_2 (delta
, -1 * (delta
< 0));
2148 TREE_TYPE (t
) = signed_type (sizetype
);
2149 t
= fold (build (PLUS_EXPR
, TREE_TYPE (a
), a
, t
));
2150 t
= tree_cons (NULL_TREE
, t
, NULL_TREE
);
2151 for (a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
))
2152 t
= tree_cons (NULL_TREE
, a
, t
);
2154 t
= build_call (function
, TREE_TYPE (TREE_TYPE (function
)), t
);
2155 finish_return_stmt (t
);
2157 expand_body (finish_function (lineno
, 0));
2159 /* Don't let the backend defer this function. */
2160 if (DECL_DEFER_OUTPUT (thunk_fndecl
))
2162 output_inline_function (thunk_fndecl
);
2163 permanent_allocation (1);
2166 #endif /* ASM_OUTPUT_MI_THUNK */
2168 TREE_SET_CODE (thunk_fndecl
, THUNK_DECL
);
2171 /* Code for synthesizing methods which have default semantics defined. */
2173 /* Generate code for default X(X&) constructor. */
2176 do_build_copy_constructor (fndecl
)
2179 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
2182 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
2183 parm
= TREE_CHAIN (parm
);
2184 parm
= convert_from_reference (parm
);
2186 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
2187 && is_empty_class (current_class_type
))
2188 /* Don't copy the padding byte; it might not have been allocated
2189 if *this is a base subobject. */;
2190 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
2192 t
= build (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
2193 finish_expr_stmt (t
);
2197 tree fields
= TYPE_FIELDS (current_class_type
);
2198 int n_bases
= CLASSTYPE_N_BASECLASSES (current_class_type
);
2199 tree binfos
= TYPE_BINFO_BASETYPES (current_class_type
);
2202 /* Initialize all the base-classes. */
2203 for (t
= CLASSTYPE_VBASECLASSES (current_class_type
); t
;
2205 current_base_init_list
2206 = tree_cons (BINFO_TYPE (t
), parm
, current_base_init_list
);
2207 for (i
= 0; i
< n_bases
; ++i
)
2209 t
= TREE_VEC_ELT (binfos
, i
);
2210 if (TREE_VIA_VIRTUAL (t
))
2213 current_base_init_list
2214 = tree_cons (BINFO_TYPE (t
), parm
, current_base_init_list
);
2217 for (; fields
; fields
= TREE_CHAIN (fields
))
2220 tree field
= fields
;
2222 if (TREE_CODE (field
) != FIELD_DECL
)
2226 if (DECL_NAME (field
))
2228 if (VFIELD_NAME_P (DECL_NAME (field
)))
2230 if (VBASE_NAME_P (DECL_NAME (field
)))
2233 /* True for duplicate members. */
2234 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field
)) != field
)
2237 else if ((t
= TREE_TYPE (field
)) != NULL_TREE
2238 && ANON_AGGR_TYPE_P (t
)
2239 && TYPE_FIELDS (t
) != NULL_TREE
)
2240 /* Just use the field; anonymous types can't have
2241 nontrivial copy ctors or assignment ops. */;
2245 init
= build (COMPONENT_REF
, TREE_TYPE (field
), init
, field
);
2246 init
= build_tree_list (NULL_TREE
, init
);
2248 current_member_init_list
2249 = tree_cons (field
, init
, current_member_init_list
);
2251 current_member_init_list
= nreverse (current_member_init_list
);
2252 current_base_init_list
= nreverse (current_base_init_list
);
2258 do_build_assign_ref (fndecl
)
2261 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
2264 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
2265 parm
= convert_from_reference (parm
);
2267 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
2268 && is_empty_class (current_class_type
))
2269 /* Don't copy the padding byte; it might not have been allocated
2270 if *this is a base subobject. */;
2271 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
2273 tree t
= build (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
2274 finish_expr_stmt (t
);
2278 tree fields
= TYPE_FIELDS (current_class_type
);
2279 int n_bases
= CLASSTYPE_N_BASECLASSES (current_class_type
);
2280 tree binfos
= TYPE_BINFO_BASETYPES (current_class_type
);
2283 for (i
= 0; i
< n_bases
; ++i
)
2285 tree basetype
= BINFO_TYPE (TREE_VEC_ELT (binfos
, i
));
2286 tree p
= convert_to_reference
2287 (build_reference_type (basetype
), parm
,
2288 CONV_IMPLICIT
|CONV_CONST
, LOOKUP_COMPLAIN
, NULL_TREE
);
2289 p
= convert_from_reference (p
);
2290 p
= build_member_call (basetype
, ansi_opname
[MODIFY_EXPR
],
2291 build_expr_list (NULL_TREE
, p
));
2292 finish_expr_stmt (p
);
2294 for (; fields
; fields
= TREE_CHAIN (fields
))
2297 tree field
= fields
;
2299 if (TREE_CODE (field
) != FIELD_DECL
)
2302 if (CP_TYPE_CONST_P (TREE_TYPE (field
)))
2304 if (DECL_NAME (field
))
2305 cp_error ("non-static const member `%#D', can't use default assignment operator", field
);
2307 cp_error ("non-static const member in type `%T', can't use default assignment operator", current_class_type
);
2310 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
2312 if (DECL_NAME (field
))
2313 cp_error ("non-static reference member `%#D', can't use default assignment operator", field
);
2315 cp_error ("non-static reference member in type `%T', can't use default assignment operator", current_class_type
);
2319 comp
= current_class_ref
;
2322 if (DECL_NAME (field
))
2324 if (VFIELD_NAME_P (DECL_NAME (field
)))
2326 if (VBASE_NAME_P (DECL_NAME (field
)))
2329 /* True for duplicate members. */
2330 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field
)) != field
)
2333 else if ((t
= TREE_TYPE (field
)) != NULL_TREE
2334 && ANON_AGGR_TYPE_P (t
)
2335 && TYPE_FIELDS (t
) != NULL_TREE
)
2336 /* Just use the field; anonymous types can't have
2337 nontrivial copy ctors or assignment ops. */;
2341 comp
= build (COMPONENT_REF
, TREE_TYPE (field
), comp
, field
);
2342 init
= build (COMPONENT_REF
, TREE_TYPE (field
), init
, field
);
2344 finish_expr_stmt (build_modify_expr (comp
, NOP_EXPR
, init
));
2347 finish_return_stmt (current_class_ref
);
2348 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
2352 synthesize_method (fndecl
)
2355 int nested
= (current_function_decl
!= NULL_TREE
);
2356 tree context
= hack_decl_function_context (fndecl
);
2360 import_export_decl (fndecl
);
2363 push_to_top_level ();
2365 push_function_context_to (context
);
2367 /* Put the function definition at the position where it is needed,
2368 rather than within the body of the class. That way, an error
2369 during the generation of the implicit body points at the place
2370 where the attempt to generate the function occurs, giving the
2371 user a hint as to why we are attempting to generate the
2373 DECL_SOURCE_LINE (fndecl
) = lineno
;
2374 DECL_SOURCE_FILE (fndecl
) = input_filename
;
2376 interface_unknown
= 1;
2377 start_function (NULL_TREE
, fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
2378 store_parm_decls ();
2381 if (DECL_NAME (fndecl
) == ansi_opname
[MODIFY_EXPR
])
2383 do_build_assign_ref (fndecl
);
2386 else if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl
)))
2390 tree arg_chain
= FUNCTION_ARG_CHAIN (fndecl
);
2391 if (DECL_CONSTRUCTOR_FOR_VBASE_P (fndecl
))
2392 arg_chain
= TREE_CHAIN (arg_chain
);
2393 if (arg_chain
!= void_list_node
)
2394 do_build_copy_constructor (fndecl
);
2395 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type
))
2399 /* If we haven't yet generated the body of the function, just
2400 generate an empty compound statement. */
2404 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
2405 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
2408 expand_body (finish_function (lineno
, 0));
2410 extract_interface_info ();
2412 pop_from_top_level ();
2414 pop_function_context_from (context
);