1 /* Handle the hair of processing (but not expanding) inline functions.
2 Also manage function and variable name overloading.
3 Copyright (C) 1987, 1989, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #ifndef PARM_CAN_BE_ARRAY_TYPE
24 #define PARM_CAN_BE_ARRAY_TYPE 1
27 /* Handle method declarations. */
38 #include "hard-reg-set.h"
41 /* TREE_LIST of the current inline functions that need to be
43 struct pending_inline *pending_inlines;
45 #define obstack_chunk_alloc xmalloc
46 #define obstack_chunk_free free
48 /* Obstack where we build text strings for overloading, etc. */
49 static struct obstack scratch_obstack;
50 static char *scratch_firstobj;
52 # define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0)
53 # define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C)))
54 # define OB_PUTC2(C1,C2) \
55 (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2)))
56 # define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1))
57 # define OB_PUTID(ID) \
58 (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \
59 IDENTIFIER_LENGTH (ID)))
60 # define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S)))
61 # define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
63 #ifdef NO_AUTO_OVERLOAD
70 gcc_obstack_init (&scratch_obstack);
71 scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
74 /* This must be large enough to hold any printed integer or floating-point
76 static char digit_buffer[128];
78 /* Move inline function definitions out of structure so that they
79 can be processed normally. CNAME is the name of the class
80 we are working from, METHOD_LIST is the list of method lists
81 of the structure. We delete friend methods here, after
82 saving away their inline function definitions (if any). */
85 do_inline_function_hair (type, friend_list)
86 tree type, friend_list;
88 tree method = TYPE_METHODS (type);
90 if (method && TREE_CODE (method) == TREE_VEC)
92 if (TREE_VEC_ELT (method, 0))
93 method = TREE_VEC_ELT (method, 0);
95 method = TREE_VEC_ELT (method, 1);
100 /* Do inline member functions. */
101 struct pending_inline *info = DECL_PENDING_INLINE_INFO (method);
106 my_friendly_assert (info->fndecl == method, 238);
107 args = DECL_ARGUMENTS (method);
110 DECL_CONTEXT (args) = method;
111 args = TREE_CHAIN (args);
114 /* Allow this decl to be seen in global scope. Don't do this for
115 local class methods, though. */
116 if (! current_function_decl)
117 IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (method)) = method;
119 method = TREE_CHAIN (method);
123 tree fndecl = TREE_VALUE (friend_list);
124 struct pending_inline *info = DECL_PENDING_INLINE_INFO (fndecl);
129 my_friendly_assert (info->fndecl == fndecl, 239);
130 args = DECL_ARGUMENTS (fndecl);
133 DECL_CONTEXT (args) = fndecl;
134 args = TREE_CHAIN (args);
137 /* Allow this decl to be seen in global scope */
138 if (! current_function_decl)
139 IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (fndecl)) = fndecl;
142 friend_list = TREE_CHAIN (friend_list);
146 /* Report an argument type mismatch between the best declared function
147 we could find and the current argument list that we have. */
149 report_type_mismatch (cp, parmtypes, name_kind)
150 struct candidate *cp;
154 int i = cp->u.bad_arg;
161 my_friendly_assert (TREE_CODE (cp->function) == TEMPLATE_DECL, 240);
162 cp_error ("type unification failed for function template `%#D'",
167 if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes))))
168 cp_error ("call to const %s `%#D' with non-const object", name_kind,
171 cp_error ("call to non-const %s `%#D' with const object", name_kind,
175 cp_error ("too few arguments for %s `%#D'", name_kind, cp->function);
178 cp_error ("too many arguments for %s `%#D'", name_kind, cp->function);
181 if (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
183 /* Happens when we have an ambiguous base class. */
184 my_friendly_assert (get_binfo (DECL_CLASS_CONTEXT (cp->function),
185 TREE_TYPE (TREE_TYPE (TREE_VALUE (parmtypes))), 1) == error_mark_node,
191 ttf = TYPE_ARG_TYPES (TREE_TYPE (cp->function));
196 ttf = TREE_CHAIN (ttf);
197 tta = TREE_CHAIN (tta);
201 OB_PUTS ("bad argument ");
202 sprintf (digit_buffer, "%d", cp->u.bad_arg
203 - (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
205 OB_PUTCP (digit_buffer);
207 OB_PUTS (" for function `");
208 OB_PUTCP (decl_as_string (cp->function, 1));
209 OB_PUTS ("' (type was ");
211 /* Reset `i' so that type printing routines do the right thing. */
214 enum tree_code code = TREE_CODE (TREE_TYPE (TREE_VALUE (tta)));
215 if (code == ERROR_MARK)
216 OB_PUTS ("(failed type instantiation)");
219 i = (code == FUNCTION_TYPE || code == METHOD_TYPE);
220 OB_PUTCP (type_as_string (TREE_TYPE (TREE_VALUE (tta)), 1));
223 else OB_PUTS ("void");
227 tmp_firstobj = (char *)alloca (obstack_object_size (&scratch_obstack));
228 bcopy (obstack_base (&scratch_obstack), tmp_firstobj,
229 obstack_object_size (&scratch_obstack));
230 error (tmp_firstobj);
233 /* Here is where overload code starts. */
235 /* Array of types seen so far in top-level call to `build_overload_name'.
236 Allocated and deallocated by caller. */
237 static tree *typevec;
239 /* Number of types interned by `build_overload_name' so far. */
242 /* Number of occurrences of last type seen. */
245 /* Nonzero if we should not try folding parameter types. */
248 #define ALLOCATE_TYPEVEC(PARMTYPES) \
249 do { maxtype = 0, nrepeats = 0; \
250 typevec = (tree *)alloca (list_length (PARMTYPES) * sizeof (tree)); } while (0)
252 #define DEALLOCATE_TYPEVEC(PARMTYPES) \
253 do { tree t = (PARMTYPES); \
254 while (t) { TREE_USED (TREE_VALUE (t)) = 0; t = TREE_CHAIN (t); } \
257 /* Code to concatenate an asciified integer to a string. */
266 /* Handle this case first, to go really quickly. For many common values,
267 the result of i/10 below is 1. */
284 OB_PUTC ('0' + (i % 10));
298 while (typevec[tindex] != type)
316 static int numeric_outputed_need_bar;
317 static void build_overload_identifier ();
320 build_overload_nested_name (context)
323 /* We use DECL_NAME here, because pushtag now sets the DECL_ASSEMBLER_NAME. */
324 tree name = DECL_NAME (context);
325 if (DECL_CONTEXT (context))
327 context = DECL_CONTEXT (context);
328 if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
329 context = TYPE_NAME (context);
330 build_overload_nested_name (context);
332 build_overload_identifier (name);
336 build_overload_value (type, value)
339 while (TREE_CODE (value) == NON_LVALUE_EXPR
340 || TREE_CODE (value) == NOP_EXPR)
341 value = TREE_OPERAND (value, 0);
342 my_friendly_assert (TREE_CODE (type) == PARM_DECL, 242);
343 type = TREE_TYPE (type);
344 switch (TREE_CODE (type))
349 my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243);
350 if (TYPE_PRECISION (value) == 2 * HOST_BITS_PER_WIDE_INT)
352 if (tree_int_cst_lt (value, integer_zero_node))
355 value = build_int_2 (~ TREE_INT_CST_LOW (value),
356 - TREE_INT_CST_HIGH (value));
358 if (TREE_INT_CST_HIGH (value)
359 != (TREE_INT_CST_LOW (value) >> (HOST_BITS_PER_WIDE_INT - 1)))
361 /* need to print a DImode value in decimal */
362 sorry ("conversion of long long as PT parameter");
364 /* else fall through to print in smaller mode */
366 /* Wordsize or smaller */
367 icat (TREE_INT_CST_LOW (value));
372 icat (TREE_INT_CST_LOW (value));
375 #ifndef REAL_IS_NOT_DOUBLE
379 char *bufp = digit_buffer;
380 extern char *index ();
382 my_friendly_assert (TREE_CODE (value) == REAL_CST, 244);
383 val = TREE_REAL_CST (value);
389 sprintf (bufp, "%e", val);
390 bufp = (char *) index (bufp, 'e');
392 strcat (digit_buffer, "e0");
418 OB_PUTCP (digit_buffer);
423 value = TREE_OPERAND (value, 0);
424 if (TREE_CODE (value) == VAR_DECL)
426 my_friendly_assert (DECL_NAME (value) != 0, 245);
427 build_overload_identifier (DECL_NAME (value));
430 else if (TREE_CODE (value) == FUNCTION_DECL)
432 my_friendly_assert (DECL_NAME (value) != 0, 246);
433 build_overload_identifier (DECL_NAME (value));
437 my_friendly_abort (71);
438 break; /* not really needed */
441 sorry ("conversion of %s as template parameter",
442 tree_code_name [(int) TREE_CODE (type)]);
443 my_friendly_abort (72);
448 build_overload_identifier (name)
451 if (IDENTIFIER_TEMPLATE (name))
453 tree template, parmlist, arglist, tname;
455 template = IDENTIFIER_TEMPLATE (name);
456 arglist = TREE_VALUE (template);
457 template = TREE_PURPOSE (template);
458 tname = DECL_NAME (template);
459 parmlist = DECL_ARGUMENTS (template);
460 nparms = TREE_VEC_LENGTH (parmlist);
462 icat (IDENTIFIER_LENGTH (tname));
465 for (i = 0; i < nparms; i++)
467 tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i));
468 tree arg = TREE_VEC_ELT (arglist, i);
469 if (TREE_CODE (parm) == TYPE_DECL)
471 /* This parameter is a type. */
473 build_overload_name (arg, 0, 0);
477 /* It's a PARM_DECL. */
478 build_overload_name (TREE_TYPE (parm), 0, 0);
479 build_overload_value (parm, arg);
480 numeric_outputed_need_bar = 1;
486 if (numeric_outputed_need_bar)
489 numeric_outputed_need_bar = 0;
491 icat (IDENTIFIER_LENGTH (name));
496 /* Given a list of parameters in PARMTYPES, create an unambiguous
497 overload string. Should distinguish any type that C (or C++) can
498 distinguish. I.e., pointers to functions are treated correctly.
500 Caller must deal with whether a final `e' goes on the end or not.
502 Any default conversions must take place before this function
505 BEGIN and END control initialization and finalization of the
506 obstack where we build the string. */
509 build_overload_name (parmtypes, begin, end)
516 if (begin) OB_INIT ();
518 if ((just_one = (TREE_CODE (parmtypes) != TREE_LIST)))
520 parmtype = parmtypes;
526 parmtype = TREE_VALUE (parmtypes);
533 /* Every argument gets counted. */
534 typevec[maxtype++] = parmtype;
536 if (TREE_USED (parmtype))
538 if (! just_one && parmtype == typevec[maxtype-2])
543 flush_repeats (parmtype);
544 if (! just_one && TREE_CHAIN (parmtypes)
545 && parmtype == TREE_VALUE (TREE_CHAIN (parmtypes)))
551 while (typevec[tindex] != parmtype)
562 flush_repeats (typevec[maxtype-2]);
564 /* Only cache types which take more than one character. */
565 && (parmtype != TYPE_MAIN_VARIANT (parmtype)
566 || (TREE_CODE (parmtype) != INTEGER_TYPE
567 && TREE_CODE (parmtype) != REAL_TYPE)))
568 TREE_USED (parmtype) = 1;
571 if (TYPE_PTRMEMFUNC_P (parmtype))
572 parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
574 if (TREE_READONLY (parmtype))
576 if (TREE_CODE (parmtype) == INTEGER_TYPE
577 && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype)))
579 if (TYPE_VOLATILE (parmtype))
582 switch (TREE_CODE (parmtype))
586 build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0);
588 build_overload_name (TREE_TYPE (parmtype), 0, 0);
596 #if PARM_CAN_BE_ARRAY_TYPE
601 if (TYPE_DOMAIN (parmtype) == NULL_TREE)
602 error ("pointer or reference to array of unknown bound in parm type");
605 length = array_type_nelts (parmtype);
606 if (TREE_CODE (length) == INTEGER_CST)
607 icat (TREE_INT_CST_LOW (length) + 1);
620 build_overload_name (TREE_TYPE (parmtype), 0, 0);
626 tree firstarg = TYPE_ARG_TYPES (parmtype);
627 /* Otherwise have to implement reentrant typevecs,
628 unmark and remark types, etc. */
629 int old_nofold = nofold;
633 flush_repeats (typevec[maxtype-1]);
635 /* @@ It may be possible to pass a function type in
636 which is not preceded by a 'P'. */
637 if (TREE_CODE (parmtype) == FUNCTION_TYPE)
640 if (firstarg == NULL_TREE)
642 else if (firstarg == void_list_node)
645 build_overload_name (firstarg, 0, 0);
649 int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg)));
650 int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg)));
652 firstarg = TREE_CHAIN (firstarg);
654 build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0);
660 /* For cfront 2.0 compatibility. */
663 if (firstarg == NULL_TREE)
665 else if (firstarg == void_list_node)
668 build_overload_name (firstarg, 0, 0);
671 /* Separate args from return type. */
673 build_overload_name (TREE_TYPE (parmtype), 0, 0);
679 parmtype = TYPE_MAIN_VARIANT (parmtype);
680 if (parmtype == integer_type_node
681 || parmtype == unsigned_type_node)
683 else if (parmtype == long_integer_type_node
684 || parmtype == long_unsigned_type_node)
686 else if (parmtype == short_integer_type_node
687 || parmtype == short_unsigned_type_node)
689 else if (parmtype == signed_char_type_node)
694 else if (parmtype == char_type_node
695 || parmtype == unsigned_char_type_node)
697 else if (parmtype == wchar_type_node)
699 else if (parmtype == long_long_integer_type_node
700 || parmtype == long_long_unsigned_type_node)
703 /* it would seem there is no way to enter these in source code,
705 else if (parmtype == long_long_long_integer_type_node
706 || parmtype == long_long_long_unsigned_type_node)
710 my_friendly_abort (73);
718 parmtype = TYPE_MAIN_VARIANT (parmtype);
719 if (parmtype == long_double_type_node)
721 else if (parmtype == double_type_node)
723 else if (parmtype == float_type_node)
725 else my_friendly_abort (74);
732 extern tree void_list_node;
734 /* See if anybody is wasting memory. */
735 my_friendly_assert (parmtypes == void_list_node, 247);
737 /* This is the end of a parameter list. */
738 if (end) OB_FINISH ();
739 return (char *)obstack_base (&scratch_obstack);
744 case ERROR_MARK: /* not right, but nothing is anyway */
747 /* have to do these */
751 /* Make this type signature look incompatible
758 tree name = TYPE_NAME (parmtype);
761 if (TREE_CODE (name) == TYPE_DECL)
764 while (DECL_CONTEXT (context))
767 context = DECL_CONTEXT (context);
768 if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
769 context = TYPE_NAME (context);
771 name = DECL_NAME (name);
773 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 248);
782 numeric_outputed_need_bar = 0;
783 build_overload_nested_name (TYPE_NAME (parmtype));
786 build_overload_identifier (name);
791 /* This will take some work. */
795 case TEMPLATE_TYPE_PARM:
796 case TEMPLATE_CONST_PARM:
797 case UNINSTANTIATED_P_TYPE:
798 /* We don't ever want this output, but it's inconvenient not to
799 be able to build the string. This should cause assembler
800 errors we'll notice. */
803 sprintf (digit_buffer, " *%d", n++);
804 OB_PUTCP (digit_buffer);
809 my_friendly_abort (75);
814 parmtypes = TREE_CHAIN (parmtypes);
819 flush_repeats (typevec[maxtype-1]);
821 /* To get here, parms must end with `...'. */
825 if (end) OB_FINISH ();
826 return (char *)obstack_base (&scratch_obstack);
830 build_static_name (basetype, name)
833 char *basename = build_overload_name (basetype, 1, 1);
834 char *buf = (char *) alloca (IDENTIFIER_LENGTH (name)
835 + sizeof (STATIC_NAME_FORMAT)
836 + strlen (basename));
837 sprintf (buf, STATIC_NAME_FORMAT, basename, IDENTIFIER_POINTER (name));
838 return get_identifier (buf);
841 /* Generate an identifier that encodes the (ANSI) exception TYPE. */
843 /* This should be part of `ansi_opname', or at least be defined by the std. */
844 #define EXCEPTION_NAME_PREFIX "__ex"
845 #define EXCEPTION_NAME_LENGTH 4
848 cplus_exception_name (type)
852 OB_PUTS (EXCEPTION_NAME_PREFIX);
853 return get_identifier (build_overload_name (type, 0, 1));
856 /* Change the name of a function definition so that it may be
857 overloaded. NAME is the name of the function to overload,
858 PARMS is the parameter list (which determines what name the
859 final function obtains).
861 FOR_METHOD is 1 if this overload is being performed
862 for a method, rather than a function type. It is 2 if
863 this overload is being performed for a constructor. */
865 build_decl_overload (dname, parms, for_method)
870 char *name = IDENTIFIER_POINTER (dname);
872 /* member operators new and delete look like methods at this point. */
873 if (! for_method && parms != NULL_TREE && TREE_CODE (parms) == TREE_LIST)
875 if (dname == ansi_opname[(int) DELETE_EXPR])
876 return get_identifier ("__builtin_delete");
877 else if (dname == ansi_opname[(int) VEC_DELETE_EXPR])
878 return get_identifier ("__builtin_vec_delete");
879 else if (TREE_CHAIN (parms) == void_list_node)
881 if (dname == ansi_opname[(int) NEW_EXPR])
882 return get_identifier ("__builtin_new");
883 else if (dname == ansi_opname[(int) VEC_NEW_EXPR])
884 return get_identifier ("__builtin_vec_new");
891 /* Otherwise, we can divine that this is a constructor,
892 and figure out its name without any extra encoding. */
898 /* We can get away without doing this. */
902 tree this_type = TREE_VALUE (parms);
904 if (TREE_CODE (this_type) == RECORD_TYPE) /* a signature pointer */
905 parms = temp_tree_cons (NULL_TREE, SIGNATURE_TYPE (this_type),
908 parms = temp_tree_cons (NULL_TREE, TREE_TYPE (this_type),
915 if (parms == NULL_TREE)
916 OB_PUTC2 ('e', '\0');
917 else if (parms == void_list_node)
918 OB_PUTC2 ('v', '\0');
921 ALLOCATE_TYPEVEC (parms);
923 numeric_outputed_need_bar = 0;
926 build_overload_name (TREE_VALUE (parms), 0, 0);
928 typevec[maxtype++] = TREE_VALUE (parms);
929 TREE_USED (TREE_VALUE (parms)) = 1;
931 if (TREE_CHAIN (parms))
932 build_overload_name (TREE_CHAIN (parms), 0, 1);
934 OB_PUTC2 ('e', '\0');
937 build_overload_name (parms, 0, 1);
938 DEALLOCATE_TYPEVEC (parms);
941 tree n = get_identifier (obstack_base (&scratch_obstack));
942 if (IDENTIFIER_OPNAME_P (dname))
943 IDENTIFIER_OPNAME_P (n) = 1;
948 /* Build an overload name for the type expression TYPE. */
950 build_typename_overload (type)
956 OB_PUTID (ansi_opname[(int) TYPE_EXPR]);
958 build_overload_name (type, 0, 1);
959 id = get_identifier (obstack_base (&scratch_obstack));
960 IDENTIFIER_OPNAME_P (id) = 1;
962 IDENTIFIER_GLOBAL_VALUE (id) = TYPE_NAME (type);
964 TREE_TYPE (id) = type;
968 #ifndef NO_DOLLAR_IN_LABEL
969 #define T_DESC_FORMAT "TD$"
970 #define I_DESC_FORMAT "ID$"
971 #define M_DESC_FORMAT "MD$"
973 #if !defined(NO_DOT_IN_LABEL)
974 #define T_DESC_FORMAT "TD."
975 #define I_DESC_FORMAT "ID."
976 #define M_DESC_FORMAT "MD."
978 #define T_DESC_FORMAT "__t_desc_"
979 #define I_DESC_FORMAT "__i_desc_"
980 #define M_DESC_FORMAT "__m_desc_"
984 /* Build an overload name for the type expression TYPE. */
986 build_t_desc_overload (type)
990 OB_PUTS (T_DESC_FORMAT);
994 /* Use a different format if the type isn't defined yet. */
995 if (TYPE_SIZE (type) == NULL_TREE)
1000 for (p = tname; *p; p++)
1006 /* If there's no change, we have an inappropriate T_DESC_FORMAT. */
1007 my_friendly_assert (changed != 0, 249);
1011 build_overload_name (type, 0, 1);
1012 return get_identifier (obstack_base (&scratch_obstack));
1015 /* Top-level interface to explicit overload requests. Allow NAME
1016 to be overloaded. Error if NAME is already declared for the current
1017 scope. Warning if function is redundantly overloaded. */
1020 declare_overloaded (name)
1023 #ifdef NO_AUTO_OVERLOAD
1024 if (is_overloaded (name))
1025 warning ("function `%s' already declared overloaded",
1026 IDENTIFIER_POINTER (name));
1027 else if (IDENTIFIER_GLOBAL_VALUE (name))
1028 error ("overloading function `%s' that is already defined",
1029 IDENTIFIER_POINTER (name));
1032 TREE_OVERLOADED (name) = 1;
1033 IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
1034 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
1037 if (current_lang_name == lang_name_cplusplus)
1040 warning ("functions are implicitly overloaded in C++");
1042 else if (current_lang_name == lang_name_c)
1043 error ("overloading function `%s' cannot be done in C language context");
1045 my_friendly_abort (76);
1049 #ifdef NO_AUTO_OVERLOAD
1050 /* Check to see if NAME is overloaded. For first approximation,
1051 check to see if its TREE_OVERLOADED is set. This is used on
1052 IDENTIFIER nodes. */
1054 is_overloaded (name)
1058 return (TREE_OVERLOADED (name)
1059 && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
1060 && ! IDENTIFIER_LOCAL_VALUE (name));
1064 /* Given a tree_code CODE, and some arguments (at least one),
1065 attempt to use an overloaded operator on the arguments.
1067 For unary operators, only the first argument need be checked.
1068 For binary operators, both arguments may need to be checked.
1070 Member functions can convert class references to class pointers,
1071 for one-level deep indirection. More than that is not supported.
1072 Operators [](), ()(), and ->() must be member functions.
1074 We call function call building calls with LOOKUP_COMPLAIN if they
1075 are our only hope. This is true when we see a vanilla operator
1076 applied to something of aggregate type. If this fails, we are free
1077 to return `error_mark_node', because we will have reported the
1080 Operators NEW and DELETE overload in funny ways: operator new takes
1081 a single `size' parameter, and operator delete takes a pointer to the
1082 storage being deleted. When overloading these operators, success is
1083 assumed. If there is a failure, report an error message and return
1084 `error_mark_node'. */
1088 build_opfncall (code, flags, xarg1, xarg2, arg3)
1089 enum tree_code code;
1091 tree xarg1, xarg2, arg3;
1095 tree type1, type2, fnname;
1096 tree fields1 = 0, parms = 0;
1099 int binary_is_unary;
1101 if (xarg1 == error_mark_node)
1102 return error_mark_node;
1104 if (code == COND_EXPR)
1106 if (TREE_CODE (xarg2) == ERROR_MARK
1107 || TREE_CODE (arg3) == ERROR_MARK)
1108 return error_mark_node;
1110 if (code == COMPONENT_REF)
1111 if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE)
1114 /* First, see if we can work with the first argument */
1115 type1 = TREE_TYPE (xarg1);
1117 /* Some tree codes have length > 1, but we really only want to
1118 overload them if their first argument has a user defined type. */
1121 case PREINCREMENT_EXPR:
1122 case PREDECREMENT_EXPR:
1123 case POSTINCREMENT_EXPR:
1124 case POSTDECREMENT_EXPR:
1126 binary_is_unary = 1;
1130 /* ARRAY_REFs and CALL_EXPRs must overload successfully.
1131 If they do not, return error_mark_node instead of NULL_TREE. */
1133 if (xarg2 == error_mark_node)
1134 return error_mark_node;
1136 rval = error_mark_node;
1137 binary_is_unary = 0;
1144 tree args = tree_cons (NULL_TREE, xarg2, arg3);
1145 fnname = ansi_opname[(int) code];
1146 if (flags & LOOKUP_GLOBAL)
1147 return build_overload_call (fnname, args, flags & LOOKUP_COMPLAIN,
1148 (struct candidate *)0);
1150 rval = build_method_call
1151 (build_indirect_ref (build1 (NOP_EXPR, xarg1, error_mark_node),
1153 fnname, args, NULL_TREE, flags);
1154 if (rval == error_mark_node)
1155 /* User might declare fancy operator new, but invoke it
1156 like standard one. */
1159 TREE_TYPE (rval) = xarg1;
1160 TREE_CALLS_NEW (rval) = 1;
1165 case VEC_DELETE_EXPR:
1168 fnname = ansi_opname[(int) code];
1169 if (flags & LOOKUP_GLOBAL)
1170 return build_overload_call (fnname,
1171 build_tree_list (NULL_TREE, xarg1),
1172 flags & LOOKUP_COMPLAIN,
1173 (struct candidate *)0);
1175 rval = build_method_call
1176 (build_indirect_ref (build1 (NOP_EXPR, TREE_TYPE (xarg1),
1179 fnname, tree_cons (NULL_TREE, xarg1,
1180 build_tree_list (NULL_TREE, xarg2)),
1182 /* This happens when the user mis-declares `operator delete'.
1183 Should now be impossible. */
1184 my_friendly_assert (rval != error_mark_node, 250);
1185 TREE_TYPE (rval) = void_type_node;
1191 binary_is_unary = 0;
1192 try_second = tree_code_length [(int) code] == 2;
1193 if (try_second && xarg2 == error_mark_node)
1194 return error_mark_node;
1198 if (try_second && xarg2 == error_mark_node)
1199 return error_mark_node;
1201 /* What ever it was, we do not know how to deal with it. */
1202 if (type1 == NULL_TREE)
1205 if (TREE_CODE (type1) == OFFSET_TYPE)
1206 type1 = TREE_TYPE (type1);
1208 if (TREE_CODE (type1) == REFERENCE_TYPE)
1210 arg1 = convert_from_reference (xarg1);
1211 type1 = TREE_TYPE (arg1);
1218 if (!IS_AGGR_TYPE (type1) || TYPE_PTRMEMFUNC_P (type1))
1220 /* Try to fail. First, fail if unary */
1223 /* Second, see if second argument is non-aggregate. */
1224 type2 = TREE_TYPE (xarg2);
1225 if (TREE_CODE (type2) == OFFSET_TYPE)
1226 type2 = TREE_TYPE (type2);
1227 if (TREE_CODE (type2) == REFERENCE_TYPE)
1229 arg2 = convert_from_reference (xarg2);
1230 type2 = TREE_TYPE (arg2);
1237 if (!IS_AGGR_TYPE (type2))
1244 /* First arg may succeed; see whether second should. */
1245 type2 = TREE_TYPE (xarg2);
1246 if (TREE_CODE (type2) == OFFSET_TYPE)
1247 type2 = TREE_TYPE (type2);
1248 if (TREE_CODE (type2) == REFERENCE_TYPE)
1250 arg2 = convert_from_reference (xarg2);
1251 type2 = TREE_TYPE (arg2);
1258 if (! IS_AGGR_TYPE (type2))
1262 if (type1 == unknown_type_node
1263 || (try_second && TREE_TYPE (xarg2) == unknown_type_node))
1265 /* This will not be implemented in the foreseeable future. */
1269 if (code == MODIFY_EXPR)
1270 fnname = ansi_assopname[(int) TREE_CODE (arg3)];
1272 fnname = ansi_opname[(int) code];
1274 global_fn = lookup_name_nonclass (fnname);
1276 /* This is the last point where we will accept failure. This
1277 may be too eager if we wish an overloaded operator not to match,
1278 but would rather a normal operator be called on a type-converted
1281 if (IS_AGGR_TYPE (type1))
1283 fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0);
1284 /* ARM $13.4.7, prefix/postfix ++/--. */
1285 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1287 xarg2 = integer_zero_node;
1288 binary_is_unary = 0;
1293 int have_postfix = 0;
1295 /* Look for an `operator++ (int)'. If they didn't have
1296 one, then we fall back to the old way of doing things. */
1297 for (t = TREE_VALUE (fields1); t ; t = TREE_CHAIN (t))
1299 t2 = TYPE_ARG_TYPES (TREE_TYPE (t));
1300 if (TREE_CHAIN (t2) != NULL_TREE
1301 && TREE_VALUE (TREE_CHAIN (t2)) == integer_type_node)
1310 char *op = POSTINCREMENT_EXPR ? "++" : "--";
1312 /* There's probably a LOT of code in the world that
1313 relies upon this old behavior. So we'll only give this
1314 warning when we've been given -pedantic. A few
1315 releases after 2.4, we'll convert this to be a pedwarn
1316 or something else more appropriate. */
1318 warning ("no `operator%s (int)' declared for postfix `%s'",
1321 binary_is_unary = 1;
1327 if (fields1 == NULL_TREE && global_fn == NULL_TREE)
1330 /* If RVAL winds up being `error_mark_node', we will return
1331 that... There is no way that normal semantics of these
1332 operators will succeed. */
1334 /* This argument may be an uncommitted OFFSET_REF. This is
1335 the case for example when dealing with static class members
1336 which are referenced from their class name rather than
1337 from a class instance. */
1338 if (TREE_CODE (xarg1) == OFFSET_REF
1339 && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL)
1340 xarg1 = TREE_OPERAND (xarg1, 1);
1341 if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF
1342 && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL)
1343 xarg2 = TREE_OPERAND (xarg2, 1);
1346 flags |= LOOKUP_GLOBAL;
1348 if (code == CALL_EXPR)
1350 /* This can only be a member function. */
1351 return build_method_call (xarg1, fnname, xarg2,
1352 NULL_TREE, LOOKUP_NORMAL);
1354 else if (tree_code_length[(int) code] == 1 || binary_is_unary)
1357 rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags);
1359 else if (code == COND_EXPR)
1361 parms = tree_cons (0, xarg2, build_tree_list (NULL_TREE, arg3));
1362 rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1364 else if (code == METHOD_CALL_EXPR)
1366 /* must be a member function. */
1367 parms = tree_cons (NULL_TREE, xarg2, arg3);
1368 return build_method_call (xarg1, fnname, parms, NULL_TREE,
1373 parms = build_tree_list (NULL_TREE, xarg2);
1374 rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1378 parms = tree_cons (NULL_TREE, xarg1,
1379 build_tree_list (NULL_TREE, xarg2));
1380 rval = build_overload_call (fnname, parms, flags,
1381 (struct candidate *)0);
1387 /* This function takes an identifier, ID, and attempts to figure out what
1388 it means. There are a number of possible scenarios, presented in increasing
1391 1) not in a class's scope
1392 2) in class's scope, member name of the class's method
1393 3) in class's scope, but not a member name of the class
1394 4) in class's scope, member name of a class's variable
1396 NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
1397 VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
1398 yychar is the pending input character (suitably encoded :-).
1400 As a last ditch, try to look up the name as a label and return that
1403 Values which are declared as being of REFERENCE_TYPE are
1404 automatically dereferenced here (as a hack to make the
1405 compiler faster). */
1408 hack_identifier (value, name, yychar)
1414 if (TREE_CODE (value) == ERROR_MARK)
1416 if (current_class_name)
1418 tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 1);
1419 if (fields == error_mark_node)
1420 return error_mark_node;
1425 fndecl = TREE_VALUE (fields);
1426 my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
1427 if (DECL_CHAIN (fndecl) == NULL_TREE)
1429 warning ("methods cannot be converted to function pointers");
1434 error ("ambiguous request for method pointer `%s'",
1435 IDENTIFIER_POINTER (name));
1436 return error_mark_node;
1440 if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name))
1442 return IDENTIFIER_LABEL_VALUE (name);
1444 return error_mark_node;
1447 type = TREE_TYPE (value);
1448 if (TREE_CODE (value) == FIELD_DECL)
1450 if (current_class_decl == NULL_TREE)
1452 error ("request for member `%s' in static member function",
1453 IDENTIFIER_POINTER (DECL_NAME (value)));
1454 return error_mark_node;
1456 TREE_USED (current_class_decl) = 1;
1458 if (! ((TYPE_LANG_SPECIFIC (type)
1459 && TYPE_OVERLOADS_CALL_EXPR (type))
1460 || (TREE_CODE (type) == REFERENCE_TYPE
1461 && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
1462 && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (type))))
1463 && TREE_CODE (type) != FUNCTION_TYPE
1464 && TREE_CODE (type) != METHOD_TYPE
1465 && !TYPE_PTRMEMFUNC_P (type)
1466 && (TREE_CODE (type) != POINTER_TYPE
1467 || (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
1468 && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)))
1470 error ("component `%s' is not a method",
1471 IDENTIFIER_POINTER (name));
1472 return error_mark_node;
1474 /* Mark so that if we are in a constructor, and then find that
1475 this field was initialized by a base initializer,
1476 we can emit an error message. */
1477 TREE_USED (value) = 1;
1478 return build_component_ref (C_C_D, name, 0, 1);
1481 if (really_overloaded_fn (value))
1483 tree t = get_first_fn (value);
1484 for (; t; t = DECL_CHAIN (t))
1486 if (TREE_CODE (t) == TEMPLATE_DECL)
1489 assemble_external (t);
1493 else if (TREE_CODE (value) == TREE_LIST)
1496 while (t && TREE_CODE (t) == TREE_LIST)
1498 assemble_external (TREE_VALUE (t));
1505 assemble_external (value);
1506 TREE_USED (value) = 1;
1509 if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && DECL_NONLOCAL (value))
1511 if (DECL_LANG_SPECIFIC (value)
1512 && DECL_CLASS_CONTEXT (value) != current_class_type)
1515 enum access_type access;
1516 register tree context
1517 = (TREE_CODE (value) == FUNCTION_DECL && DECL_VIRTUAL_P (value))
1518 ? DECL_CLASS_CONTEXT (value)
1519 : DECL_CONTEXT (value);
1521 get_base_distance (context, current_class_type, 0, &path);
1524 access = compute_access (path, value);
1525 if (access != access_public)
1527 if (TREE_CODE (value) == VAR_DECL)
1528 error ("static member `%s' is %s",
1529 IDENTIFIER_POINTER (name),
1530 TREE_PRIVATE (value) ? "private" :
1531 "from a private base class");
1533 error ("enum `%s' is from private base class",
1534 IDENTIFIER_POINTER (name));
1535 return error_mark_node;
1541 if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value))
1545 error ("request for member `%s' is ambiguous in multiple inheritance lattice",
1546 IDENTIFIER_POINTER (name));
1547 return error_mark_node;
1553 if (TREE_CODE (type) == REFERENCE_TYPE)
1555 my_friendly_assert (TREE_CODE (value) == VAR_DECL
1556 || TREE_CODE (value) == PARM_DECL
1557 || TREE_CODE (value) == RESULT_DECL, 252);
1558 if (DECL_REFERENCE_SLOT (value))
1559 return DECL_REFERENCE_SLOT (value);
1566 /* Given an object OF, and a type conversion operator COMPONENT
1567 build a call to the conversion operator, if a call is requested,
1568 or return the address (as a pointer to member function) if one is not.
1570 OF can be a TYPE_DECL or any kind of datum that would normally
1571 be passed to `build_component_ref'. It may also be NULL_TREE,
1572 in which case `current_class_type' and `current_class_decl'
1573 provide default values.
1575 BASETYPE_PATH, if non-null, is the path of basetypes
1576 to go through before we get the the instance of interest.
1578 PROTECT says whether we apply C++ scoping rules or not. */
1580 build_component_type_expr (of, component, basetype_path, protect)
1581 tree of, component, basetype_path;
1584 tree cname = NULL_TREE;
1587 int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN;
1590 my_friendly_assert (IS_AGGR_TYPE (TREE_TYPE (of)), 253);
1591 my_friendly_assert (TREE_CODE (component) == TYPE_EXPR, 254);
1593 tmp = TREE_OPERAND (component, 0);
1598 switch (TREE_CODE (tmp))
1602 TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
1604 TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0);
1606 last = groktypename (build_tree_list (TREE_TYPE (component),
1607 TREE_OPERAND (component, 0)));
1608 name = build_typename_overload (last);
1609 TREE_TYPE (name) = last;
1611 if (TREE_OPERAND (tmp, 0)
1612 && TREE_OPERAND (tmp, 0) != void_list_node)
1614 cp_error ("`operator %T' requires empty parameter list", last);
1615 TREE_OPERAND (tmp, 0) = NULL_TREE;
1618 if (of && TREE_CODE (of) != TYPE_DECL)
1619 return build_method_call (of, name, NULL_TREE, NULL_TREE, flags);
1624 if (current_class_decl == NULL_TREE)
1626 cp_error ("object required for `operator %T' call",
1628 return error_mark_node;
1631 this_this = convert_pointer_to (TREE_TYPE (of),
1632 current_class_decl);
1633 this_this = build_indirect_ref (this_this, NULL_PTR);
1634 return build_method_call (this_this, name, NULL_TREE,
1635 NULL_TREE, flags | LOOKUP_NONVIRTUAL);
1637 else if (current_class_decl)
1638 return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags);
1640 cp_error ("object required for `operator %T' call",
1642 return error_mark_node;
1650 my_friendly_assert (cname == 0, 255);
1651 cname = TREE_OPERAND (tmp, 0);
1652 tmp = TREE_OPERAND (tmp, 1);
1656 my_friendly_abort (77);
1659 tmp = TREE_OPERAND (tmp, 0);
1662 last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0)));
1663 name = build_typename_overload (last);
1664 TREE_TYPE (name) = last;
1665 if (of && TREE_CODE (of) == TYPE_DECL)
1667 if (cname == NULL_TREE)
1669 cname = DECL_NAME (of);
1672 else my_friendly_assert (cname == DECL_NAME (of), 256);
1679 if (current_class_decl == NULL_TREE)
1681 cp_error ("object required for `operator %T' call",
1683 return error_mark_node;
1686 this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
1687 return build_component_ref (this_this, name, 0, protect);
1690 return build_offset_ref (cname, name);
1691 else if (current_class_name)
1692 return build_offset_ref (current_class_name, name);
1694 cp_error ("object required for `operator %T' member reference",
1696 return error_mark_node;
1701 thunk_printable_name (decl)
1704 return "<thunk function>";
1708 make_thunk (function, delta)
1713 tree thunk_fndecl, thunk_id;
1716 static int thunk_number = 0;
1718 if (TREE_CODE (function) != ADDR_EXPR)
1720 func_decl = TREE_OPERAND (function, 0);
1721 if (TREE_CODE (func_decl) != FUNCTION_DECL)
1723 func_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func_decl));
1724 sprintf (buffer, "__thunk_%d_%s", -delta, func_name);
1725 thunk_id = get_identifier (buffer);
1726 thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id);
1727 if (thunk && TREE_CODE (thunk) != THUNK_DECL)
1729 error_with_decl ("implementation-reserved name `%s' used");
1730 IDENTIFIER_GLOBAL_VALUE (thunk_id) = thunk = NULL_TREE;
1732 if (thunk == NULL_TREE)
1734 thunk = build_decl (THUNK_DECL, thunk_id, TREE_TYPE (func_decl));
1736 = build_decl (RESULT_DECL, NULL_TREE, TREE_TYPE (vtable_entry_type));
1737 make_function_rtl (thunk);
1738 DECL_INITIAL (thunk) = function;
1739 THUNK_DELTA (thunk) = delta;
1740 /* So that finish_file can write out any thunks that need to be: */
1741 pushdecl_top_level (thunk);
1747 emit_thunk (thunk_fndecl)
1754 struct args_size stack_args_size;
1755 tree function = TREE_OPERAND (DECL_INITIAL (thunk_fndecl), 0);
1756 int delta = THUNK_DELTA (thunk_fndecl);
1759 int current_call_is_indirect = 0; /* needed for HPPA FUNCTION_ARG */
1761 /* Used to remember which regs we need to emit a USE rtx for. */
1762 rtx need_use[FIRST_PSEUDO_REGISTER];
1763 int need_use_count = 0;
1765 /* rtx for the 'this' parameter. */
1766 rtx this_rtx = 0, this_reg_rtx = 0, fixed_this_rtx;
1768 char *(*save_decl_printable_name) () = decl_printable_name;
1769 /* Data on reg parms scanned so far. */
1770 CUMULATIVE_ARGS args_so_far;
1772 if (TREE_ASM_WRITTEN (thunk_fndecl))
1775 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1777 if (TREE_PUBLIC (function))
1779 TREE_PUBLIC (thunk_fndecl) = 1;
1780 if (DECL_EXTERNAL (function))
1782 DECL_EXTERNAL (thunk_fndecl) = 1;
1783 assemble_external (thunk_fndecl);
1788 decl_printable_name = thunk_printable_name;
1789 if (current_function_decl)
1791 current_function_decl = thunk_fndecl;
1792 init_function_start (thunk_fndecl, input_filename, lineno);
1794 expand_start_bindings (1);
1796 /* Start updating where the next arg would go. */
1797 INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (function), NULL_RTX);
1798 stack_args_size.constant = 0;
1799 stack_args_size.var = 0;
1800 /* SETUP for possible structure return address FIXME */
1802 /* Now look through all the parameters, make sure that we
1803 don't clobber any registers used for parameters.
1804 Also, pick up an rtx for the first "this" parameter. */
1805 for (argp = TYPE_ARG_TYPES (TREE_TYPE (function));
1807 argp = TREE_CHAIN (argp))
1810 tree passed_type = TREE_VALUE (argp);
1811 register rtx entry_parm;
1812 int named = 1; /* FIXME */
1813 struct args_size stack_offset;
1814 struct args_size arg_size;
1816 if (passed_type == void_type_node)
1819 if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
1820 && contains_placeholder_p (TYPE_SIZE (passed_type)))
1821 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1822 || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far,
1823 TYPE_MODE (passed_type),
1827 passed_type = build_pointer_type (passed_type);
1829 entry_parm = FUNCTION_ARG (args_so_far,
1830 TYPE_MODE (passed_type),
1833 if (entry_parm != 0)
1834 need_use[need_use_count++] = entry_parm;
1836 locate_and_pad_parm (TYPE_MODE (passed_type), passed_type,
1837 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1843 &stack_args_size, &stack_offset, &arg_size);
1845 /* REGNO (entry_parm);*/
1848 this_reg_rtx = entry_parm;
1851 rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
1853 rtx internal_arg_pointer, stack_parm;
1855 if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
1856 || ! (fixed_regs[ARG_POINTER_REGNUM]
1857 || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
1858 internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
1860 internal_arg_pointer = virtual_incoming_args_rtx;
1862 if (offset_rtx == const0_rtx)
1863 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1864 internal_arg_pointer);
1866 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1867 gen_rtx (PLUS, Pmode,
1868 internal_arg_pointer,
1872 this_rtx = entry_parm;
1875 FUNCTION_ARG_ADVANCE (args_so_far,
1876 TYPE_MODE (passed_type),
1881 fixed_this_rtx = plus_constant (this_rtx, delta);
1882 if (this_rtx != fixed_this_rtx)
1883 emit_move_insn (this_rtx, fixed_this_rtx);
1886 emit_insn (gen_rtx (USE, VOIDmode, this_reg_rtx));
1888 emit_indirect_jump (XEXP (DECL_RTL (function), 0));
1890 while (need_use_count > 0)
1891 emit_insn (gen_rtx (USE, VOIDmode, need_use[--need_use_count]));
1893 expand_end_bindings (NULL, 1, 0);
1896 /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
1897 Note that that may have been done above, in save_for_inline_copying.
1898 The call to resume_temporary_allocation near the end of this function
1899 goes back to the usual state of affairs. */
1901 rtl_in_current_obstack ();
1903 insns = get_insns ();
1905 /* Copy any shared structure that should not be shared. */
1907 unshare_all_rtl (insns);
1909 /* We are no longer anticipating cse in this function, at least. */
1911 cse_not_expected = 1;
1913 /* Now we choose between stupid (pcc-like) register allocation
1914 (if we got the -noreg switch and not -opt)
1915 and smart register allocation. */
1917 if (optimize > 0) /* Stupid allocation probably won't work */
1918 obey_regdecls = 0; /* if optimizations being done. */
1922 regclass (insns, max_reg_num ());
1925 stupid_life_analysis (insns, max_reg_num (), NULL);
1926 failure = reload (insns, 0, NULL);
1930 /* Do control and data flow analysis,
1931 and write some of the results to dump file. */
1933 flow_analysis (insns, max_reg_num (), NULL);
1935 failure = global_alloc (NULL);
1938 reload_completed = 1;
1940 #ifdef LEAF_REGISTERS
1942 if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
1946 /* If a machine dependent reorganization is needed, call it. */
1947 #ifdef MACHINE_DEPENDENT_REORG
1948 MACHINE_DEPENDENT_REORG (insns);
1951 /* Now turn the rtl into assembler code. */
1954 char *fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
1955 assemble_start_function (thunk_fndecl, fnname);
1956 final (insns, asm_out_file, optimize, 0);
1957 assemble_end_function (thunk_fndecl, fnname);
1960 exit_rest_of_compilation:
1962 reload_completed = 0;
1964 /* Cancel the effect of rtl_in_current_obstack. */
1966 resume_temporary_allocation ();
1968 decl_printable_name = save_decl_printable_name;
1969 current_function_decl = 0;
1972 /* Code for synthesizing methods which have default semantics defined. */
1975 build_default_constructor (fndecl)
1978 start_function (NULL_TREE, fndecl, NULL_TREE, 1);
1979 store_parm_decls ();
1981 finish_function (lineno, 0);
1984 /* For the anonymous union in TYPE, return the member that is at least as
1985 large as the rest of the members, so we can copy it. */
1987 largest_union_member (type)
1990 tree f, type_size = TYPE_SIZE (type);
1992 for (f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f))
1993 if (simple_cst_equal (DECL_SIZE (f), type_size))
1996 /* We should always find one. */
1997 my_friendly_abort (323);
2001 /* Generate code for default X(X&) constructor. */
2003 build_copy_constructor (fndecl)
2006 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
2009 start_function (NULL_TREE, fndecl, NULL_TREE, 1);
2010 store_parm_decls ();
2014 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
2015 parm = TREE_CHAIN (parm);
2016 parm = convert_from_reference (parm);
2018 if (! TYPE_HAS_COMPLEX_INIT_REF (current_class_type))
2020 t = build (INIT_EXPR, void_type_node, C_C_D, parm);
2021 TREE_SIDE_EFFECTS (t) = 1;
2022 cplus_expand_expr_stmt (t);
2026 tree fields = TYPE_FIELDS (current_class_type);
2027 int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
2028 tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
2031 for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
2034 tree basetype = BINFO_TYPE (t);
2035 tree p = convert (build_reference_type (basetype), parm);
2036 p = convert_from_reference (p);
2037 current_base_init_list = tree_cons (TYPE_NESTED_NAME (basetype),
2038 p, current_base_init_list);
2041 for (i = 0; i < n_bases; ++i)
2043 tree p, basetype = TREE_VEC_ELT (binfos, i);
2044 if (TREE_VIA_VIRTUAL (basetype))
2047 basetype = BINFO_TYPE (basetype);
2048 p = convert (build_reference_type (basetype), parm);
2049 p = convert_from_reference (p);
2050 current_base_init_list = tree_cons (TYPE_NESTED_NAME (basetype),
2051 p, current_base_init_list);
2053 for (; fields; fields = TREE_CHAIN (fields))
2056 if (TREE_CODE (fields) != FIELD_DECL)
2058 if (DECL_NAME (fields))
2060 if (VFIELD_NAME_P (DECL_NAME (fields)))
2062 if (VBASE_NAME_P (DECL_NAME (fields)))
2065 /* True for duplicate members. */
2066 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) != fields)
2069 else if ((t = TREE_TYPE (fields)) != NULL_TREE
2070 && TREE_CODE (t) == UNION_TYPE
2071 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))
2072 && TYPE_FIELDS (t) != NULL_TREE)
2073 fields = largest_union_member (t);
2077 init = build (COMPONENT_REF, TREE_TYPE (fields), parm, fields);
2078 init = build_tree_list (NULL_TREE, init);
2080 current_member_init_list
2081 = tree_cons (DECL_NAME (fields), init, current_member_init_list);
2083 current_member_init_list = nreverse (current_member_init_list);
2088 finish_function (lineno, 0);
2092 build_assign_ref (fndecl)
2095 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
2097 start_function (NULL_TREE, fndecl, NULL_TREE, 1);
2098 store_parm_decls ();
2101 parm = convert_from_reference (parm);
2103 if (! TYPE_HAS_COMPLEX_ASSIGN_REF (current_class_type))
2105 tree t = build (MODIFY_EXPR, void_type_node, C_C_D, parm);
2106 TREE_SIDE_EFFECTS (t) = 1;
2107 cplus_expand_expr_stmt (t);
2111 tree fields = TYPE_FIELDS (current_class_type);
2112 int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
2113 tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
2116 for (i = 0; i < n_bases; ++i)
2118 tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
2119 if (TYPE_HAS_ASSIGN_REF (basetype))
2121 tree p = convert (build_reference_type (basetype), parm);
2122 p = convert_from_reference (p);
2123 p = build_member_call (TYPE_NESTED_NAME (basetype),
2124 ansi_opname [MODIFY_EXPR],
2125 build_tree_list (NULL_TREE, p));
2126 expand_expr_stmt (p);
2129 for (; fields; fields = TREE_CHAIN (fields))
2132 if (TREE_CODE (fields) != FIELD_DECL)
2134 if (DECL_NAME (fields))
2136 if (VFIELD_NAME_P (DECL_NAME (fields)))
2138 if (VBASE_NAME_P (DECL_NAME (fields)))
2141 /* True for duplicate members. */
2142 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) != fields)
2145 else if ((t = TREE_TYPE (fields)) != NULL_TREE
2146 && TREE_CODE (t) == UNION_TYPE
2147 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))
2148 && TYPE_FIELDS (t) != NULL_TREE)
2149 fields = largest_union_member (t);
2153 comp = build (COMPONENT_REF, TREE_TYPE (fields), C_C_D, fields);
2154 init = build (COMPONENT_REF, TREE_TYPE (fields), parm, fields);
2156 expand_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
2159 c_expand_return (C_C_D);
2161 finish_function (lineno, 0);
2168 start_function (NULL_TREE, fndecl, NULL_TREE, 1);
2169 store_parm_decls ();
2170 finish_function (lineno, 0);