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, 1995 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'))
62 # define OB_LAST() (obstack_next_free (&scratch_obstack)[-1])
64 #ifdef NO_AUTO_OVERLOAD
71 gcc_obstack_init (&scratch_obstack);
72 scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
75 /* This must be large enough to hold any printed integer or floating-point
77 static char digit_buffer[128];
79 /* Move inline function definitions out of structure so that they
80 can be processed normally. CNAME is the name of the class
81 we are working from, METHOD_LIST is the list of method lists
82 of the structure. We delete friend methods here, after
83 saving away their inline function definitions (if any). */
86 do_inline_function_hair (type, friend_list)
87 tree type, friend_list;
89 tree method = TYPE_METHODS (type);
91 if (method && TREE_CODE (method) == TREE_VEC)
93 if (TREE_VEC_ELT (method, 0))
94 method = TREE_VEC_ELT (method, 0);
96 method = TREE_VEC_ELT (method, 1);
101 /* Do inline member functions. */
102 struct pending_inline *info = DECL_PENDING_INLINE_INFO (method);
107 my_friendly_assert (info->fndecl == method, 238);
108 args = DECL_ARGUMENTS (method);
111 DECL_CONTEXT (args) = method;
112 args = TREE_CHAIN (args);
115 /* Allow this decl to be seen in global scope. Don't do this for
116 local class methods, though. */
117 if (! current_function_decl)
118 IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (method)) = method;
120 method = TREE_CHAIN (method);
124 tree fndecl = TREE_VALUE (friend_list);
125 struct pending_inline *info = DECL_PENDING_INLINE_INFO (fndecl);
130 my_friendly_assert (info->fndecl == fndecl, 239);
131 args = DECL_ARGUMENTS (fndecl);
134 DECL_CONTEXT (args) = fndecl;
135 args = TREE_CHAIN (args);
138 /* Allow this decl to be seen in global scope */
139 if (! current_function_decl)
140 IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (fndecl)) = fndecl;
143 friend_list = TREE_CHAIN (friend_list);
147 /* Report an argument type mismatch between the best declared function
148 we could find and the current argument list that we have. */
150 report_type_mismatch (cp, parmtypes, name_kind)
151 struct candidate *cp;
155 int i = cp->u.bad_arg;
162 my_friendly_assert (TREE_CODE (cp->function) == TEMPLATE_DECL, 240);
163 cp_error ("type unification failed for function template `%#D'",
168 if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes))))
169 cp_error ("call to const %s `%#D' with non-const object", name_kind,
172 cp_error ("call to non-const %s `%#D' with const object", name_kind,
176 cp_error ("too few arguments for %s `%#D'", name_kind, cp->function);
179 cp_error ("too many arguments for %s `%#D'", name_kind, cp->function);
182 if (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
184 /* Happens when we have an ambiguous base class. */
185 my_friendly_assert (get_binfo (DECL_CLASS_CONTEXT (cp->function),
186 TREE_TYPE (TREE_TYPE (TREE_VALUE (parmtypes))), 1) == error_mark_node,
192 ttf = TYPE_ARG_TYPES (TREE_TYPE (cp->function));
197 ttf = TREE_CHAIN (ttf);
198 tta = TREE_CHAIN (tta);
202 OB_PUTS ("bad argument ");
203 sprintf (digit_buffer, "%d", cp->u.bad_arg
204 - (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
206 OB_PUTCP (digit_buffer);
208 OB_PUTS (" for function `");
209 OB_PUTCP (decl_as_string (cp->function, 1));
210 OB_PUTS ("' (type was ");
212 /* Reset `i' so that type printing routines do the right thing. */
215 enum tree_code code = TREE_CODE (TREE_TYPE (TREE_VALUE (tta)));
216 if (code == ERROR_MARK)
217 OB_PUTS ("(failed type instantiation)");
220 i = (code == FUNCTION_TYPE || code == METHOD_TYPE);
221 OB_PUTCP (type_as_string (TREE_TYPE (TREE_VALUE (tta)), 1));
224 else OB_PUTS ("void");
228 tmp_firstobj = (char *)alloca (obstack_object_size (&scratch_obstack));
229 bcopy (obstack_base (&scratch_obstack), tmp_firstobj,
230 obstack_object_size (&scratch_obstack));
231 error (tmp_firstobj);
234 /* Here is where overload code starts. */
236 /* Array of types seen so far in top-level call to `build_overload_name'.
237 Allocated and deallocated by caller. */
238 static tree *typevec;
240 /* Number of types interned by `build_overload_name' so far. */
243 /* Number of occurrences of last type seen. */
246 /* Nonzero if we should not try folding parameter types. */
249 #define ALLOCATE_TYPEVEC(PARMTYPES) \
250 do { maxtype = 0, nrepeats = 0; \
251 typevec = (tree *)alloca (list_length (PARMTYPES) * sizeof (tree)); } while (0)
253 #define DEALLOCATE_TYPEVEC(PARMTYPES) \
254 do { tree t = (PARMTYPES); \
255 while (t) { TREE_USED (TREE_VALUE (t)) = 0; t = TREE_CHAIN (t); } \
258 /* Code to concatenate an asciified integer to a string. */
267 /* Handle this case first, to go really quickly. For many common values,
268 the result of i/10 below is 1. */
285 OB_PUTC ('0' + (i % 10));
299 while (typevec[tindex] != type)
317 static int numeric_output_need_bar;
318 static void build_overload_identifier ();
321 build_overload_nested_name (decl)
324 if (DECL_CONTEXT (decl))
326 tree context = DECL_CONTEXT (decl);
327 if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
328 context = TYPE_MAIN_DECL (context);
329 build_overload_nested_name (context);
332 if (TREE_CODE (decl) == FUNCTION_DECL)
334 tree name = DECL_ASSEMBLER_NAME (decl);
336 extern int var_labelno;
338 ASM_FORMAT_PRIVATE_NAME (label, IDENTIFIER_POINTER (name), var_labelno);
341 if (numeric_output_need_bar)
344 numeric_output_need_bar = 0;
346 icat (strlen (label));
351 tree name = DECL_NAME (decl);
352 build_overload_identifier (name);
357 build_overload_value (type, value)
360 while (TREE_CODE (value) == NON_LVALUE_EXPR
361 || TREE_CODE (value) == NOP_EXPR)
362 value = TREE_OPERAND (value, 0);
363 my_friendly_assert (TREE_CODE (type) == PARM_DECL, 242);
364 type = TREE_TYPE (type);
365 if (TREE_CODE (type) == POINTER_TYPE
366 && TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE)
368 /* Handle a pointer to member as a template instantiation
369 parameter, boy, what fun! */
370 type = integer_type_node;
371 if (TREE_CODE (value) != INTEGER_CST)
373 sorry ("unknown pointer to member constant");
378 switch (TREE_CODE (type))
383 my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243);
384 if (TYPE_PRECISION (value) == 2 * HOST_BITS_PER_WIDE_INT)
386 if (tree_int_cst_lt (value, integer_zero_node))
389 value = build_int_2 (~ TREE_INT_CST_LOW (value),
390 - TREE_INT_CST_HIGH (value));
392 if (TREE_INT_CST_HIGH (value)
393 != (TREE_INT_CST_LOW (value) >> (HOST_BITS_PER_WIDE_INT - 1)))
395 /* need to print a DImode value in decimal */
396 sorry ("conversion of long long as PT parameter");
398 /* else fall through to print in smaller mode */
400 /* Wordsize or smaller */
401 icat (TREE_INT_CST_LOW (value));
406 icat (TREE_INT_CST_LOW (value));
409 #ifndef REAL_IS_NOT_DOUBLE
413 char *bufp = digit_buffer;
414 extern char *index ();
416 my_friendly_assert (TREE_CODE (value) == REAL_CST, 244);
417 val = TREE_REAL_CST (value);
423 sprintf (bufp, "%e", val);
424 bufp = (char *) index (bufp, 'e');
426 strcat (digit_buffer, "e0");
452 OB_PUTCP (digit_buffer);
457 value = TREE_OPERAND (value, 0);
458 if (TREE_CODE (value) == VAR_DECL)
460 my_friendly_assert (DECL_NAME (value) != 0, 245);
461 build_overload_identifier (DECL_NAME (value));
464 else if (TREE_CODE (value) == FUNCTION_DECL)
466 my_friendly_assert (DECL_NAME (value) != 0, 246);
467 build_overload_identifier (DECL_NAME (value));
471 my_friendly_abort (71);
472 break; /* not really needed */
475 sorry ("conversion of %s as template parameter",
476 tree_code_name [(int) TREE_CODE (type)]);
477 my_friendly_abort (72);
482 build_overload_identifier (name)
485 if (IDENTIFIER_TEMPLATE (name))
487 tree template, parmlist, arglist, tname;
489 template = IDENTIFIER_TEMPLATE (name);
490 arglist = TREE_VALUE (template);
491 template = TREE_PURPOSE (template);
492 tname = DECL_NAME (template);
493 parmlist = DECL_ARGUMENTS (template);
494 nparms = TREE_VEC_LENGTH (parmlist);
496 icat (IDENTIFIER_LENGTH (tname));
499 for (i = 0; i < nparms; i++)
501 tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i));
502 tree arg = TREE_VEC_ELT (arglist, i);
503 if (TREE_CODE (parm) == TYPE_DECL)
505 /* This parameter is a type. */
507 build_overload_name (arg, 0, 0);
511 /* It's a PARM_DECL. */
512 build_overload_name (TREE_TYPE (parm), 0, 0);
513 build_overload_value (parm, arg);
514 numeric_output_need_bar = 1;
520 if (numeric_output_need_bar)
523 numeric_output_need_bar = 0;
525 icat (IDENTIFIER_LENGTH (name));
530 /* Given a list of parameters in PARMTYPES, create an unambiguous
531 overload string. Should distinguish any type that C (or C++) can
532 distinguish. I.e., pointers to functions are treated correctly.
534 Caller must deal with whether a final `e' goes on the end or not.
536 Any default conversions must take place before this function
539 BEGIN and END control initialization and finalization of the
540 obstack where we build the string. */
543 build_overload_name (parmtypes, begin, end)
550 if (begin) OB_INIT ();
551 numeric_output_need_bar = 0;
553 if ((just_one = (TREE_CODE (parmtypes) != TREE_LIST)))
555 parmtype = parmtypes;
561 parmtype = TREE_VALUE (parmtypes);
565 if (! nofold && ! just_one)
567 /* Every argument gets counted. */
568 typevec[maxtype++] = parmtype;
570 if (TREE_USED (parmtype) && parmtype == typevec[maxtype-2])
577 flush_repeats (typevec[maxtype-2]);
579 if (TREE_USED (parmtype))
581 flush_repeats (parmtype);
585 /* Only cache types which take more than one character. */
586 if (parmtype != TYPE_MAIN_VARIANT (parmtype)
587 || (TREE_CODE (parmtype) != INTEGER_TYPE
588 && TREE_CODE (parmtype) != REAL_TYPE))
589 TREE_USED (parmtype) = 1;
592 if (TYPE_PTRMEMFUNC_P (parmtype))
593 parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
595 if (TREE_READONLY (parmtype))
597 if (TREE_CODE (parmtype) == INTEGER_TYPE
598 && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype)))
600 if (TYPE_VOLATILE (parmtype))
603 switch (TREE_CODE (parmtype))
607 build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0);
609 build_overload_name (TREE_TYPE (parmtype), 0, 0);
617 #if PARM_CAN_BE_ARRAY_TYPE
622 if (TYPE_DOMAIN (parmtype) == NULL_TREE)
623 error ("pointer or reference to array of unknown bound in parm type");
626 length = array_type_nelts (parmtype);
627 if (TREE_CODE (length) == INTEGER_CST)
628 icat (TREE_INT_CST_LOW (length) + 1);
641 build_overload_name (TREE_TYPE (parmtype), 0, 0);
647 tree firstarg = TYPE_ARG_TYPES (parmtype);
648 /* Otherwise have to implement reentrant typevecs,
649 unmark and remark types, etc. */
650 int old_nofold = nofold;
654 flush_repeats (typevec[maxtype-1]);
656 /* @@ It may be possible to pass a function type in
657 which is not preceded by a 'P'. */
658 if (TREE_CODE (parmtype) == FUNCTION_TYPE)
661 if (firstarg == NULL_TREE)
663 else if (firstarg == void_list_node)
666 build_overload_name (firstarg, 0, 0);
670 int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg)));
671 int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg)));
673 firstarg = TREE_CHAIN (firstarg);
675 build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0);
681 /* For cfront 2.0 compatibility. */
684 if (firstarg == NULL_TREE)
686 else if (firstarg == void_list_node)
689 build_overload_name (firstarg, 0, 0);
692 /* Separate args from return type. */
694 build_overload_name (TREE_TYPE (parmtype), 0, 0);
700 parmtype = TYPE_MAIN_VARIANT (parmtype);
701 if (parmtype == integer_type_node
702 || parmtype == unsigned_type_node)
704 else if (parmtype == long_integer_type_node
705 || parmtype == long_unsigned_type_node)
707 else if (parmtype == short_integer_type_node
708 || parmtype == short_unsigned_type_node)
710 else if (parmtype == signed_char_type_node)
715 else if (parmtype == char_type_node
716 || parmtype == unsigned_char_type_node)
718 else if (parmtype == wchar_type_node)
720 else if (parmtype == long_long_integer_type_node
721 || parmtype == long_long_unsigned_type_node)
724 /* it would seem there is no way to enter these in source code,
726 else if (parmtype == long_long_long_integer_type_node
727 || parmtype == long_long_long_unsigned_type_node)
731 my_friendly_abort (73);
739 parmtype = TYPE_MAIN_VARIANT (parmtype);
740 if (parmtype == long_double_type_node)
742 else if (parmtype == double_type_node)
744 else if (parmtype == float_type_node)
746 else my_friendly_abort (74);
753 extern tree void_list_node;
755 /* See if anybody is wasting memory. */
756 my_friendly_assert (parmtypes == void_list_node, 247);
758 /* This is the end of a parameter list. */
759 if (end) OB_FINISH ();
760 return (char *)obstack_base (&scratch_obstack);
765 case ERROR_MARK: /* not right, but nothing is anyway */
768 /* have to do these */
772 /* Make this type signature look incompatible
779 tree name = TYPE_NAME (parmtype);
782 if (TREE_CODE (name) == TYPE_DECL)
786 /* If DECL_ASSEMBLER_NAME has been set properly, use it. */
787 if (DECL_ASSEMBLER_NAME (context) != DECL_NAME (context))
789 OB_PUTID (DECL_ASSEMBLER_NAME (context));
792 while (DECL_CONTEXT (context))
795 context = DECL_CONTEXT (context);
796 if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
797 context = TYPE_NAME (context);
799 name = DECL_NAME (name);
801 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 248);
810 numeric_output_need_bar = 0;
811 build_overload_nested_name (TYPE_MAIN_DECL (parmtype));
814 build_overload_identifier (name);
819 /* This will take some work. */
823 case TEMPLATE_TYPE_PARM:
824 case TEMPLATE_CONST_PARM:
825 case UNINSTANTIATED_P_TYPE:
826 /* We don't ever want this output, but it's inconvenient not to
827 be able to build the string. This should cause assembler
828 errors we'll notice. */
831 sprintf (digit_buffer, " *%d", n++);
832 OB_PUTCP (digit_buffer);
837 my_friendly_abort (75);
842 parmtypes = TREE_CHAIN (parmtypes);
847 flush_repeats (typevec[maxtype-1]);
849 /* To get here, parms must end with `...'. */
853 if (end) OB_FINISH ();
854 return (char *)obstack_base (&scratch_obstack);
858 build_static_name (basetype, name)
861 char *basename = build_overload_name (basetype, 1, 1);
862 char *buf = (char *) alloca (IDENTIFIER_LENGTH (name)
863 + sizeof (STATIC_NAME_FORMAT)
864 + strlen (basename));
865 sprintf (buf, STATIC_NAME_FORMAT, basename, IDENTIFIER_POINTER (name));
866 return get_identifier (buf);
869 /* Generate an identifier that encodes the (ANSI) exception TYPE. */
871 /* This should be part of `ansi_opname', or at least be defined by the std. */
872 #define EXCEPTION_NAME_PREFIX "__ex"
873 #define EXCEPTION_NAME_LENGTH 4
876 cplus_exception_name (type)
880 OB_PUTS (EXCEPTION_NAME_PREFIX);
881 return get_identifier (build_overload_name (type, 0, 1));
884 /* Change the name of a function definition so that it may be
885 overloaded. NAME is the name of the function to overload,
886 PARMS is the parameter list (which determines what name the
887 final function obtains).
889 FOR_METHOD is 1 if this overload is being performed
890 for a method, rather than a function type. It is 2 if
891 this overload is being performed for a constructor. */
893 build_decl_overload (dname, parms, for_method)
898 char *name = IDENTIFIER_POINTER (dname);
900 /* member operators new and delete look like methods at this point. */
901 if (! for_method && parms != NULL_TREE && TREE_CODE (parms) == TREE_LIST)
903 if (dname == ansi_opname[(int) DELETE_EXPR])
904 return get_identifier ("__builtin_delete");
905 else if (dname == ansi_opname[(int) VEC_DELETE_EXPR])
906 return get_identifier ("__builtin_vec_delete");
907 else if (TREE_CHAIN (parms) == void_list_node)
909 if (dname == ansi_opname[(int) NEW_EXPR])
910 return get_identifier ("__builtin_new");
911 else if (dname == ansi_opname[(int) VEC_NEW_EXPR])
912 return get_identifier ("__builtin_vec_new");
919 /* Otherwise, we can divine that this is a constructor,
920 and figure out its name without any extra encoding. */
926 /* We can get away without doing this. */
930 tree this_type = TREE_VALUE (parms);
932 if (TREE_CODE (this_type) == RECORD_TYPE) /* a signature pointer */
933 parms = temp_tree_cons (NULL_TREE, SIGNATURE_TYPE (this_type),
936 parms = temp_tree_cons (NULL_TREE, TREE_TYPE (this_type),
943 if (parms == NULL_TREE)
944 OB_PUTC2 ('e', '\0');
945 else if (parms == void_list_node)
946 OB_PUTC2 ('v', '\0');
949 ALLOCATE_TYPEVEC (parms);
953 build_overload_name (TREE_VALUE (parms), 0, 0);
955 typevec[maxtype++] = TREE_VALUE (parms);
956 TREE_USED (TREE_VALUE (parms)) = 1;
958 if (TREE_CHAIN (parms))
959 build_overload_name (TREE_CHAIN (parms), 0, 1);
961 OB_PUTC2 ('e', '\0');
964 build_overload_name (parms, 0, 1);
965 DEALLOCATE_TYPEVEC (parms);
968 tree n = get_identifier (obstack_base (&scratch_obstack));
969 if (IDENTIFIER_OPNAME_P (dname))
970 IDENTIFIER_OPNAME_P (n) = 1;
975 /* Build an overload name for the type expression TYPE. */
977 build_typename_overload (type)
983 OB_PUTID (ansi_opname[(int) TYPE_EXPR]);
985 build_overload_name (type, 0, 1);
986 id = get_identifier (obstack_base (&scratch_obstack));
987 IDENTIFIER_OPNAME_P (id) = 1;
989 IDENTIFIER_GLOBAL_VALUE (id) = TYPE_NAME (type);
991 TREE_TYPE (id) = type;
995 #ifndef NO_DOLLAR_IN_LABEL
996 #define T_DESC_FORMAT "TD$"
997 #define I_DESC_FORMAT "ID$"
998 #define M_DESC_FORMAT "MD$"
1000 #if !defined(NO_DOT_IN_LABEL)
1001 #define T_DESC_FORMAT "TD."
1002 #define I_DESC_FORMAT "ID."
1003 #define M_DESC_FORMAT "MD."
1005 #define T_DESC_FORMAT "__t_desc_"
1006 #define I_DESC_FORMAT "__i_desc_"
1007 #define M_DESC_FORMAT "__m_desc_"
1011 /* Build an overload name for the type expression TYPE. */
1013 build_t_desc_overload (type)
1017 OB_PUTS (T_DESC_FORMAT);
1021 /* Use a different format if the type isn't defined yet. */
1022 if (TYPE_SIZE (type) == NULL_TREE)
1027 for (p = tname; *p; p++)
1033 /* If there's no change, we have an inappropriate T_DESC_FORMAT. */
1034 my_friendly_assert (changed != 0, 249);
1038 build_overload_name (type, 0, 1);
1039 return get_identifier (obstack_base (&scratch_obstack));
1042 /* Top-level interface to explicit overload requests. Allow NAME
1043 to be overloaded. Error if NAME is already declared for the current
1044 scope. Warning if function is redundantly overloaded. */
1047 declare_overloaded (name)
1050 #ifdef NO_AUTO_OVERLOAD
1051 if (is_overloaded (name))
1052 warning ("function `%s' already declared overloaded",
1053 IDENTIFIER_POINTER (name));
1054 else if (IDENTIFIER_GLOBAL_VALUE (name))
1055 error ("overloading function `%s' that is already defined",
1056 IDENTIFIER_POINTER (name));
1059 TREE_OVERLOADED (name) = 1;
1060 IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
1061 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
1064 if (current_lang_name == lang_name_cplusplus)
1067 warning ("functions are implicitly overloaded in C++");
1069 else if (current_lang_name == lang_name_c)
1070 error ("overloading function `%s' cannot be done in C language context");
1072 my_friendly_abort (76);
1076 #ifdef NO_AUTO_OVERLOAD
1077 /* Check to see if NAME is overloaded. For first approximation,
1078 check to see if its TREE_OVERLOADED is set. This is used on
1079 IDENTIFIER nodes. */
1081 is_overloaded (name)
1085 return (TREE_OVERLOADED (name)
1086 && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
1087 && ! IDENTIFIER_LOCAL_VALUE (name));
1091 /* Given a tree_code CODE, and some arguments (at least one),
1092 attempt to use an overloaded operator on the arguments.
1094 For unary operators, only the first argument need be checked.
1095 For binary operators, both arguments may need to be checked.
1097 Member functions can convert class references to class pointers,
1098 for one-level deep indirection. More than that is not supported.
1099 Operators [](), ()(), and ->() must be member functions.
1101 We call function call building calls with LOOKUP_COMPLAIN if they
1102 are our only hope. This is true when we see a vanilla operator
1103 applied to something of aggregate type. If this fails, we are free
1104 to return `error_mark_node', because we will have reported the
1107 Operators NEW and DELETE overload in funny ways: operator new takes
1108 a single `size' parameter, and operator delete takes a pointer to the
1109 storage being deleted. When overloading these operators, success is
1110 assumed. If there is a failure, report an error message and return
1111 `error_mark_node'. */
1115 build_opfncall (code, flags, xarg1, xarg2, arg3)
1116 enum tree_code code;
1118 tree xarg1, xarg2, arg3;
1122 tree type1, type2, fnname;
1123 tree fields1 = 0, parms = 0;
1126 int binary_is_unary;
1128 if (xarg1 == error_mark_node)
1129 return error_mark_node;
1131 if (code == COND_EXPR)
1133 if (TREE_CODE (xarg2) == ERROR_MARK
1134 || TREE_CODE (arg3) == ERROR_MARK)
1135 return error_mark_node;
1137 if (code == COMPONENT_REF)
1138 if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE)
1141 /* First, see if we can work with the first argument */
1142 type1 = TREE_TYPE (xarg1);
1144 /* Some tree codes have length > 1, but we really only want to
1145 overload them if their first argument has a user defined type. */
1148 case PREINCREMENT_EXPR:
1149 case PREDECREMENT_EXPR:
1150 case POSTINCREMENT_EXPR:
1151 case POSTDECREMENT_EXPR:
1153 binary_is_unary = 1;
1157 /* ARRAY_REFs and CALL_EXPRs must overload successfully.
1158 If they do not, return error_mark_node instead of NULL_TREE. */
1160 if (xarg2 == error_mark_node)
1161 return error_mark_node;
1163 rval = error_mark_node;
1164 binary_is_unary = 0;
1171 tree args = tree_cons (NULL_TREE, xarg2, arg3);
1172 fnname = ansi_opname[(int) code];
1173 if (flags & LOOKUP_GLOBAL)
1174 return build_overload_call (fnname, args, flags & LOOKUP_COMPLAIN,
1175 (struct candidate *)0);
1177 rval = build_method_call
1178 (build_indirect_ref (build1 (NOP_EXPR, xarg1, error_mark_node),
1180 fnname, args, NULL_TREE, flags);
1181 if (rval == error_mark_node)
1182 /* User might declare fancy operator new, but invoke it
1183 like standard one. */
1186 TREE_TYPE (rval) = xarg1;
1187 TREE_CALLS_NEW (rval) = 1;
1192 case VEC_DELETE_EXPR:
1195 fnname = ansi_opname[(int) code];
1196 if (flags & LOOKUP_GLOBAL)
1197 return build_overload_call (fnname,
1198 build_tree_list (NULL_TREE, xarg1),
1199 flags & LOOKUP_COMPLAIN,
1200 (struct candidate *)0);
1202 rval = build_method_call
1203 (build_indirect_ref (build1 (NOP_EXPR, TREE_TYPE (xarg1),
1206 fnname, tree_cons (NULL_TREE, xarg1,
1207 build_tree_list (NULL_TREE, xarg2)),
1210 /* This can happen when operator delete is protected. */
1211 my_friendly_assert (rval != error_mark_node, 250);
1212 TREE_TYPE (rval) = void_type_node;
1219 binary_is_unary = 0;
1220 try_second = tree_code_length [(int) code] == 2;
1221 if (try_second && xarg2 == error_mark_node)
1222 return error_mark_node;
1226 if (try_second && xarg2 == error_mark_node)
1227 return error_mark_node;
1229 /* What ever it was, we do not know how to deal with it. */
1230 if (type1 == NULL_TREE)
1233 if (TREE_CODE (type1) == OFFSET_TYPE)
1234 type1 = TREE_TYPE (type1);
1236 if (TREE_CODE (type1) == REFERENCE_TYPE)
1238 arg1 = convert_from_reference (xarg1);
1239 type1 = TREE_TYPE (arg1);
1246 if (!IS_AGGR_TYPE (type1) || TYPE_PTRMEMFUNC_P (type1))
1248 /* Try to fail. First, fail if unary */
1251 /* Second, see if second argument is non-aggregate. */
1252 type2 = TREE_TYPE (xarg2);
1253 if (TREE_CODE (type2) == OFFSET_TYPE)
1254 type2 = TREE_TYPE (type2);
1255 if (TREE_CODE (type2) == REFERENCE_TYPE)
1257 arg2 = convert_from_reference (xarg2);
1258 type2 = TREE_TYPE (arg2);
1265 if (!IS_AGGR_TYPE (type2))
1272 /* First arg may succeed; see whether second should. */
1273 type2 = TREE_TYPE (xarg2);
1274 if (TREE_CODE (type2) == OFFSET_TYPE)
1275 type2 = TREE_TYPE (type2);
1276 if (TREE_CODE (type2) == REFERENCE_TYPE)
1278 arg2 = convert_from_reference (xarg2);
1279 type2 = TREE_TYPE (arg2);
1286 if (! IS_AGGR_TYPE (type2))
1290 if (type1 == unknown_type_node
1291 || (try_second && TREE_TYPE (xarg2) == unknown_type_node))
1293 /* This will not be implemented in the foreseeable future. */
1297 if (code == MODIFY_EXPR)
1298 fnname = ansi_assopname[(int) TREE_CODE (arg3)];
1300 fnname = ansi_opname[(int) code];
1302 global_fn = lookup_name_nonclass (fnname);
1304 /* This is the last point where we will accept failure. This
1305 may be too eager if we wish an overloaded operator not to match,
1306 but would rather a normal operator be called on a type-converted
1309 if (IS_AGGR_TYPE (type1))
1311 fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0);
1312 /* ARM $13.4.7, prefix/postfix ++/--. */
1313 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1315 xarg2 = integer_zero_node;
1316 binary_is_unary = 0;
1321 int have_postfix = 0;
1323 /* Look for an `operator++ (int)'. If they didn't have
1324 one, then we fall back to the old way of doing things. */
1325 for (t = TREE_VALUE (fields1); t ; t = TREE_CHAIN (t))
1327 t2 = TYPE_ARG_TYPES (TREE_TYPE (t));
1328 if (TREE_CHAIN (t2) != NULL_TREE
1329 && TREE_VALUE (TREE_CHAIN (t2)) == integer_type_node)
1338 char *op = POSTINCREMENT_EXPR ? "++" : "--";
1340 /* There's probably a LOT of code in the world that
1341 relies upon this old behavior. So we'll only give this
1342 warning when we've been given -pedantic. A few
1343 releases after 2.4, we'll convert this to be a pedwarn
1344 or something else more appropriate. */
1346 warning ("no `operator%s (int)' declared for postfix `%s'",
1349 binary_is_unary = 1;
1355 if (fields1 == NULL_TREE && global_fn == NULL_TREE)
1358 /* If RVAL winds up being `error_mark_node', we will return
1359 that... There is no way that normal semantics of these
1360 operators will succeed. */
1362 /* This argument may be an uncommitted OFFSET_REF. This is
1363 the case for example when dealing with static class members
1364 which are referenced from their class name rather than
1365 from a class instance. */
1366 if (TREE_CODE (xarg1) == OFFSET_REF
1367 && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL)
1368 xarg1 = TREE_OPERAND (xarg1, 1);
1369 if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF
1370 && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL)
1371 xarg2 = TREE_OPERAND (xarg2, 1);
1374 flags |= LOOKUP_GLOBAL;
1376 if (code == CALL_EXPR)
1378 /* This can only be a member function. */
1379 return build_method_call (xarg1, fnname, xarg2,
1380 NULL_TREE, LOOKUP_NORMAL);
1382 else if (tree_code_length[(int) code] == 1 || binary_is_unary)
1385 rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags);
1387 else if (code == COND_EXPR)
1389 parms = tree_cons (0, xarg2, build_tree_list (NULL_TREE, arg3));
1390 rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1392 else if (code == METHOD_CALL_EXPR)
1394 /* must be a member function. */
1395 parms = tree_cons (NULL_TREE, xarg2, arg3);
1396 return build_method_call (xarg1, fnname, parms, NULL_TREE,
1401 parms = build_tree_list (NULL_TREE, xarg2);
1402 rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1406 parms = tree_cons (NULL_TREE, xarg1,
1407 build_tree_list (NULL_TREE, xarg2));
1408 rval = build_overload_call (fnname, parms, flags,
1409 (struct candidate *)0);
1415 /* This function takes an identifier, ID, and attempts to figure out what
1416 it means. There are a number of possible scenarios, presented in increasing
1419 1) not in a class's scope
1420 2) in class's scope, member name of the class's method
1421 3) in class's scope, but not a member name of the class
1422 4) in class's scope, member name of a class's variable
1424 NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
1425 VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
1426 yychar is the pending input character (suitably encoded :-).
1428 As a last ditch, try to look up the name as a label and return that
1431 Values which are declared as being of REFERENCE_TYPE are
1432 automatically dereferenced here (as a hack to make the
1433 compiler faster). */
1436 hack_identifier (value, name, yychar)
1442 if (TREE_CODE (value) == ERROR_MARK)
1444 if (current_class_name)
1446 tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 1);
1447 if (fields == error_mark_node)
1448 return error_mark_node;
1453 fndecl = TREE_VALUE (fields);
1454 my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
1455 if (DECL_CHAIN (fndecl) == NULL_TREE)
1457 warning ("methods cannot be converted to function pointers");
1462 error ("ambiguous request for method pointer `%s'",
1463 IDENTIFIER_POINTER (name));
1464 return error_mark_node;
1468 if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name))
1470 return IDENTIFIER_LABEL_VALUE (name);
1472 return error_mark_node;
1475 type = TREE_TYPE (value);
1476 if (TREE_CODE (value) == FIELD_DECL)
1478 if (current_class_decl == NULL_TREE)
1480 error ("request for member `%s' in static member function",
1481 IDENTIFIER_POINTER (DECL_NAME (value)));
1482 return error_mark_node;
1484 TREE_USED (current_class_decl) = 1;
1486 /* Mark so that if we are in a constructor, and then find that
1487 this field was initialized by a base initializer,
1488 we can emit an error message. */
1489 TREE_USED (value) = 1;
1490 return build_component_ref (C_C_D, name, 0, 1);
1493 if (really_overloaded_fn (value))
1495 tree t = get_first_fn (value);
1496 for (; t; t = DECL_CHAIN (t))
1498 if (TREE_CODE (t) == TEMPLATE_DECL)
1501 assemble_external (t);
1505 else if (TREE_CODE (value) == TREE_LIST)
1508 while (t && TREE_CODE (t) == TREE_LIST)
1510 assemble_external (TREE_VALUE (t));
1517 assemble_external (value);
1518 TREE_USED (value) = 1;
1521 if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && DECL_NONLOCAL (value))
1523 if (DECL_LANG_SPECIFIC (value)
1524 && DECL_CLASS_CONTEXT (value) != current_class_type)
1527 enum access_type access;
1528 register tree context
1529 = (TREE_CODE (value) == FUNCTION_DECL && DECL_VIRTUAL_P (value))
1530 ? DECL_CLASS_CONTEXT (value)
1531 : DECL_CONTEXT (value);
1533 get_base_distance (context, current_class_type, 0, &path);
1536 access = compute_access (path, value);
1537 if (access != access_public)
1539 if (TREE_CODE (value) == VAR_DECL)
1540 error ("static member `%s' is %s",
1541 IDENTIFIER_POINTER (name),
1542 TREE_PRIVATE (value) ? "private" :
1543 "from a private base class");
1545 error ("enum `%s' is from private base class",
1546 IDENTIFIER_POINTER (name));
1547 return error_mark_node;
1553 if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value))
1557 error ("request for member `%s' is ambiguous in multiple inheritance lattice",
1558 IDENTIFIER_POINTER (name));
1559 return error_mark_node;
1565 if (TREE_CODE (type) == REFERENCE_TYPE)
1567 my_friendly_assert (TREE_CODE (value) == VAR_DECL
1568 || TREE_CODE (value) == PARM_DECL
1569 || TREE_CODE (value) == RESULT_DECL, 252);
1570 if (DECL_REFERENCE_SLOT (value))
1571 return DECL_REFERENCE_SLOT (value);
1578 /* Given an object OF, and a type conversion operator COMPONENT
1579 build a call to the conversion operator, if a call is requested,
1580 or return the address (as a pointer to member function) if one is not.
1582 OF can be a TYPE_DECL or any kind of datum that would normally
1583 be passed to `build_component_ref'. It may also be NULL_TREE,
1584 in which case `current_class_type' and `current_class_decl'
1585 provide default values.
1587 BASETYPE_PATH, if non-null, is the path of basetypes
1588 to go through before we get the the instance of interest.
1590 PROTECT says whether we apply C++ scoping rules or not. */
1592 build_component_type_expr (of, component, basetype_path, protect)
1593 tree of, component, basetype_path;
1596 tree cname = NULL_TREE;
1599 int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN;
1602 my_friendly_assert (IS_AGGR_TYPE (TREE_TYPE (of)), 253);
1603 my_friendly_assert (TREE_CODE (component) == TYPE_EXPR, 254);
1605 tmp = TREE_OPERAND (component, 0);
1610 switch (TREE_CODE (tmp))
1614 TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
1616 TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0);
1618 last = groktypename (build_tree_list (TREE_TYPE (component),
1619 TREE_OPERAND (component, 0)));
1620 name = build_typename_overload (last);
1621 TREE_TYPE (name) = last;
1623 if (TREE_OPERAND (tmp, 0)
1624 && TREE_OPERAND (tmp, 0) != void_list_node)
1626 cp_error ("`operator %T' requires empty parameter list", last);
1627 TREE_OPERAND (tmp, 0) = NULL_TREE;
1630 if (of && TREE_CODE (of) != TYPE_DECL)
1631 return build_method_call (of, name, NULL_TREE, NULL_TREE, flags);
1636 if (current_class_decl == NULL_TREE)
1638 cp_error ("object required for `operator %T' call",
1640 return error_mark_node;
1643 this_this = convert_pointer_to (TREE_TYPE (of),
1644 current_class_decl);
1645 this_this = build_indirect_ref (this_this, NULL_PTR);
1646 return build_method_call (this_this, name, NULL_TREE,
1647 NULL_TREE, flags | LOOKUP_NONVIRTUAL);
1649 else if (current_class_decl)
1650 return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags);
1652 cp_error ("object required for `operator %T' call",
1654 return error_mark_node;
1662 my_friendly_assert (cname == 0, 255);
1663 cname = TREE_OPERAND (tmp, 0);
1664 tmp = TREE_OPERAND (tmp, 1);
1668 my_friendly_abort (77);
1671 tmp = TREE_OPERAND (tmp, 0);
1674 last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0)));
1675 name = build_typename_overload (last);
1676 TREE_TYPE (name) = last;
1677 if (of && TREE_CODE (of) == TYPE_DECL)
1679 if (cname == NULL_TREE)
1681 cname = DECL_NAME (of);
1684 else my_friendly_assert (cname == DECL_NAME (of), 256);
1691 if (current_class_decl == NULL_TREE)
1693 cp_error ("object required for `operator %T' call",
1695 return error_mark_node;
1698 this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
1699 return build_component_ref (this_this, name, 0, protect);
1702 return build_offset_ref (cname, name);
1703 else if (current_class_name)
1704 return build_offset_ref (current_class_name, name);
1706 cp_error ("object required for `operator %T' member reference",
1708 return error_mark_node;
1713 thunk_printable_name (decl)
1716 return "<thunk function>";
1720 make_thunk (function, delta)
1725 tree thunk_fndecl, thunk_id;
1728 static int thunk_number = 0;
1730 if (TREE_CODE (function) != ADDR_EXPR)
1732 func_decl = TREE_OPERAND (function, 0);
1733 if (TREE_CODE (func_decl) != FUNCTION_DECL)
1735 func_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func_decl));
1737 sprintf (buffer, "__thunk_%d_%s", -delta, func_name);
1739 sprintf (buffer, "__thunk_n%d_%s", delta, func_name);
1740 thunk_id = get_identifier (buffer);
1741 thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id);
1742 if (thunk && TREE_CODE (thunk) != THUNK_DECL)
1744 error_with_decl ("implementation-reserved name `%s' used");
1745 IDENTIFIER_GLOBAL_VALUE (thunk_id) = thunk = NULL_TREE;
1747 if (thunk == NULL_TREE)
1749 thunk = build_decl (THUNK_DECL, thunk_id, TREE_TYPE (func_decl));
1751 = build_decl (RESULT_DECL, NULL_TREE, TREE_TYPE (vtable_entry_type));
1752 make_function_rtl (thunk);
1753 DECL_INITIAL (thunk) = function;
1754 THUNK_DELTA (thunk) = delta;
1755 /* So that finish_file can write out any thunks that need to be: */
1756 pushdecl_top_level (thunk);
1762 emit_thunk (thunk_fndecl)
1769 struct args_size stack_args_size;
1770 tree function = TREE_OPERAND (DECL_INITIAL (thunk_fndecl), 0);
1771 int delta = THUNK_DELTA (thunk_fndecl);
1774 int current_call_is_indirect = 0; /* needed for HPPA FUNCTION_ARG */
1776 /* Used to remember which regs we need to emit a USE rtx for. */
1777 rtx need_use[FIRST_PSEUDO_REGISTER];
1778 int need_use_count = 0;
1780 /* rtx for the 'this' parameter. */
1781 rtx this_rtx = 0, this_reg_rtx = 0, fixed_this_rtx;
1783 char *(*save_decl_printable_name) () = decl_printable_name;
1784 /* Data on reg parms scanned so far. */
1785 CUMULATIVE_ARGS args_so_far;
1787 if (TREE_ASM_WRITTEN (thunk_fndecl))
1790 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1792 if (TREE_PUBLIC (function))
1794 TREE_PUBLIC (thunk_fndecl) = 1;
1795 if (DECL_EXTERNAL (function))
1797 DECL_EXTERNAL (thunk_fndecl) = 1;
1798 assemble_external (thunk_fndecl);
1803 decl_printable_name = thunk_printable_name;
1804 if (current_function_decl)
1806 current_function_decl = thunk_fndecl;
1807 init_function_start (thunk_fndecl, input_filename, lineno);
1809 expand_start_bindings (1);
1811 /* Start updating where the next arg would go. */
1812 INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (function), NULL_RTX);
1813 stack_args_size.constant = 0;
1814 stack_args_size.var = 0;
1815 /* SETUP for possible structure return address FIXME */
1817 /* Now look through all the parameters, make sure that we
1818 don't clobber any registers used for parameters.
1819 Also, pick up an rtx for the first "this" parameter. */
1820 for (argp = TYPE_ARG_TYPES (TREE_TYPE (function));
1822 argp = TREE_CHAIN (argp))
1825 tree passed_type = TREE_VALUE (argp);
1826 register rtx entry_parm;
1827 int named = 1; /* FIXME */
1828 struct args_size stack_offset;
1829 struct args_size arg_size;
1831 if (passed_type == void_type_node)
1834 if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
1835 && contains_placeholder_p (TYPE_SIZE (passed_type)))
1836 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1837 || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far,
1838 TYPE_MODE (passed_type),
1842 passed_type = build_pointer_type (passed_type);
1844 entry_parm = FUNCTION_ARG (args_so_far,
1845 TYPE_MODE (passed_type),
1848 if (entry_parm != 0)
1849 need_use[need_use_count++] = entry_parm;
1851 locate_and_pad_parm (TYPE_MODE (passed_type), passed_type,
1852 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1858 &stack_args_size, &stack_offset, &arg_size);
1860 /* REGNO (entry_parm);*/
1863 this_reg_rtx = entry_parm;
1866 rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
1868 rtx internal_arg_pointer, stack_parm;
1870 if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
1871 || ! (fixed_regs[ARG_POINTER_REGNUM]
1872 || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
1873 internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
1875 internal_arg_pointer = virtual_incoming_args_rtx;
1877 if (offset_rtx == const0_rtx)
1878 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1879 internal_arg_pointer);
1881 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1882 gen_rtx (PLUS, Pmode,
1883 internal_arg_pointer,
1887 this_rtx = entry_parm;
1890 FUNCTION_ARG_ADVANCE (args_so_far,
1891 TYPE_MODE (passed_type),
1896 fixed_this_rtx = plus_constant (this_rtx, delta);
1897 if (this_rtx != fixed_this_rtx)
1898 emit_move_insn (this_rtx, fixed_this_rtx);
1901 emit_insn (gen_rtx (USE, VOIDmode, this_reg_rtx));
1903 emit_indirect_jump (XEXP (DECL_RTL (function), 0));
1905 while (need_use_count > 0)
1906 emit_insn (gen_rtx (USE, VOIDmode, need_use[--need_use_count]));
1908 expand_end_bindings (NULL, 1, 0);
1911 /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
1912 Note that that may have been done above, in save_for_inline_copying.
1913 The call to resume_temporary_allocation near the end of this function
1914 goes back to the usual state of affairs. */
1916 rtl_in_current_obstack ();
1918 insns = get_insns ();
1920 /* Copy any shared structure that should not be shared. */
1922 unshare_all_rtl (insns);
1924 /* Instantiate all virtual registers. */
1926 instantiate_virtual_regs (current_function_decl, get_insns ());
1928 /* We are no longer anticipating cse in this function, at least. */
1930 cse_not_expected = 1;
1932 /* Now we choose between stupid (pcc-like) register allocation
1933 (if we got the -noreg switch and not -opt)
1934 and smart register allocation. */
1936 if (optimize > 0) /* Stupid allocation probably won't work */
1937 obey_regdecls = 0; /* if optimizations being done. */
1941 regclass (insns, max_reg_num ());
1944 stupid_life_analysis (insns, max_reg_num (), NULL);
1945 failure = reload (insns, 0, NULL);
1949 /* Do control and data flow analysis,
1950 and write some of the results to dump file. */
1952 flow_analysis (insns, max_reg_num (), NULL);
1954 failure = global_alloc (NULL);
1957 reload_completed = 1;
1959 #ifdef LEAF_REGISTERS
1961 if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
1965 /* If a machine dependent reorganization is needed, call it. */
1966 #ifdef MACHINE_DEPENDENT_REORG
1967 MACHINE_DEPENDENT_REORG (insns);
1970 /* Now turn the rtl into assembler code. */
1973 char *fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
1974 assemble_start_function (thunk_fndecl, fnname);
1975 final (insns, asm_out_file, optimize, 0);
1976 assemble_end_function (thunk_fndecl, fnname);
1979 exit_rest_of_compilation:
1981 reload_completed = 0;
1983 /* Cancel the effect of rtl_in_current_obstack. */
1985 resume_temporary_allocation ();
1987 decl_printable_name = save_decl_printable_name;
1988 current_function_decl = 0;
1991 /* Code for synthesizing methods which have default semantics defined. */
1993 /* For the anonymous union in TYPE, return the member that is at least as
1994 large as the rest of the members, so we can copy it. */
1996 largest_union_member (type)
1999 tree f, type_size = TYPE_SIZE (type);
2001 for (f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f))
2002 if (simple_cst_equal (DECL_SIZE (f), type_size))
2005 /* We should always find one. */
2006 my_friendly_abort (323);
2010 /* Generate code for default X(X&) constructor. */
2012 do_build_copy_constructor (fndecl)
2015 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
2021 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
2022 parm = TREE_CHAIN (parm);
2023 parm = convert_from_reference (parm);
2025 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
2027 t = build (INIT_EXPR, void_type_node, C_C_D, parm);
2028 TREE_SIDE_EFFECTS (t) = 1;
2029 cplus_expand_expr_stmt (t);
2033 tree fields = TYPE_FIELDS (current_class_type);
2034 int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
2035 tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
2038 for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
2041 tree basetype = BINFO_TYPE (t);
2042 tree p = convert_to_reference
2043 (build_reference_type (basetype), parm,
2044 CONV_IMPLICIT|CONV_CONST, LOOKUP_COMPLAIN, NULL_TREE);
2045 p = convert_from_reference (p);
2046 current_base_init_list = tree_cons (TYPE_NESTED_NAME (basetype),
2047 p, current_base_init_list);
2050 for (i = 0; i < n_bases; ++i)
2052 tree p, basetype = TREE_VEC_ELT (binfos, i);
2053 if (TREE_VIA_VIRTUAL (basetype))
2056 basetype = BINFO_TYPE (basetype);
2057 p = convert_to_reference
2058 (build_reference_type (basetype), parm,
2059 CONV_IMPLICIT|CONV_CONST, LOOKUP_COMPLAIN, NULL_TREE);
2060 p = convert_from_reference (p);
2061 current_base_init_list = tree_cons (TYPE_NESTED_NAME (basetype),
2062 p, current_base_init_list);
2064 for (; fields; fields = TREE_CHAIN (fields))
2067 tree field = fields;
2069 if (TREE_CODE (field) != FIELD_DECL)
2071 if (DECL_NAME (field))
2073 if (VFIELD_NAME_P (DECL_NAME (field)))
2075 if (VBASE_NAME_P (DECL_NAME (field)))
2078 /* True for duplicate members. */
2079 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
2082 else if ((t = TREE_TYPE (field)) != NULL_TREE
2083 && TREE_CODE (t) == UNION_TYPE
2084 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))
2085 && TYPE_FIELDS (t) != NULL_TREE)
2086 field = largest_union_member (t);
2090 init = build (COMPONENT_REF, TREE_TYPE (field), parm, field);
2091 init = build_tree_list (NULL_TREE, init);
2093 current_member_init_list
2094 = tree_cons (DECL_NAME (field), init, current_member_init_list);
2096 current_member_init_list = nreverse (current_member_init_list);
2097 current_base_init_list = nreverse (current_base_init_list);
2105 do_build_assign_ref (fndecl)
2108 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
2113 parm = convert_from_reference (parm);
2115 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
2117 tree t = build (MODIFY_EXPR, void_type_node, C_C_D, parm);
2118 TREE_SIDE_EFFECTS (t) = 1;
2119 cplus_expand_expr_stmt (t);
2123 tree fields = TYPE_FIELDS (current_class_type);
2124 int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
2125 tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
2128 for (i = 0; i < n_bases; ++i)
2130 tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
2131 if (TYPE_HAS_ASSIGN_REF (basetype))
2133 tree p = convert_to_reference
2134 (build_reference_type (basetype), parm,
2135 CONV_IMPLICIT|CONV_CONST, LOOKUP_COMPLAIN, NULL_TREE);
2136 p = convert_from_reference (p);
2137 p = build_member_call (TYPE_NESTED_NAME (basetype),
2138 ansi_opname [MODIFY_EXPR],
2139 build_tree_list (NULL_TREE, p));
2140 expand_expr_stmt (p);
2143 for (; fields; fields = TREE_CHAIN (fields))
2146 tree field = fields;
2148 if (TREE_CODE (field) != FIELD_DECL)
2150 if (DECL_NAME (field))
2152 if (VFIELD_NAME_P (DECL_NAME (field)))
2154 if (VBASE_NAME_P (DECL_NAME (field)))
2157 /* True for duplicate members. */
2158 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
2161 else if ((t = TREE_TYPE (field)) != NULL_TREE
2162 && TREE_CODE (t) == UNION_TYPE
2163 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))
2164 && TYPE_FIELDS (t) != NULL_TREE)
2165 field = largest_union_member (t);
2169 comp = build (COMPONENT_REF, TREE_TYPE (field), C_C_D, field);
2170 init = build (COMPONENT_REF, TREE_TYPE (field), parm, field);
2172 expand_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
2175 c_expand_return (C_C_D);
2179 void push_cp_function_context ();
2180 void pop_cp_function_context ();
2183 synthesize_method (fndecl)
2186 int nested = (current_function_decl != NULL_TREE);
2187 tree context = decl_function_context (fndecl);
2188 char *f = input_filename;
2189 tree base = DECL_CLASS_CONTEXT (fndecl);
2192 push_cp_function_context (context);
2194 input_filename = DECL_SOURCE_FILE (fndecl);
2195 interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (base);
2196 interface_only = CLASSTYPE_INTERFACE_ONLY (base);
2197 start_function (NULL_TREE, fndecl, NULL_TREE, 1);
2198 store_parm_decls ();
2200 if (DECL_NAME (fndecl) == ansi_opname[MODIFY_EXPR])
2201 do_build_assign_ref (fndecl);
2202 else if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2206 tree arg_chain = FUNCTION_ARG_CHAIN (fndecl);
2207 if (DECL_CONSTRUCTOR_FOR_VBASE_P (fndecl))
2208 arg_chain = TREE_CHAIN (arg_chain);
2209 if (arg_chain != void_list_node)
2210 do_build_copy_constructor (fndecl);
2211 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
2215 finish_function (lineno, 0, nested);
2217 /* Do we really *want* to inline this function? */
2218 if (DECL_INLINE (fndecl))
2220 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
2221 will check our size. */
2222 DECL_INLINE (fndecl) = 0;
2223 if (function_cannot_inline_p (fndecl) == 0)
2224 DECL_INLINE (fndecl) = 1;
2228 extract_interface_info ();
2230 pop_cp_function_context (context);