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 void build_overload_identifier ();
319 build_overload_nested_name (context)
322 /* We use DECL_NAME here, because pushtag now sets the DECL_ASSEMBLER_NAME. */
323 tree name = DECL_NAME (context);
324 if (DECL_CONTEXT (context))
326 context = DECL_CONTEXT (context);
327 if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
328 context = TYPE_NAME (context);
329 build_overload_nested_name (context);
331 build_overload_identifier (name);
335 build_overload_value (type, value)
338 while (TREE_CODE (value) == NON_LVALUE_EXPR
339 || TREE_CODE (value) == NOP_EXPR)
340 value = TREE_OPERAND (value, 0);
341 my_friendly_assert (TREE_CODE (type) == PARM_DECL, 242);
342 type = TREE_TYPE (type);
343 switch (TREE_CODE (type))
348 my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243);
349 if (TYPE_PRECISION (value) == 2 * HOST_BITS_PER_WIDE_INT)
351 if (tree_int_cst_lt (value, integer_zero_node))
354 value = build_int_2 (~ TREE_INT_CST_LOW (value),
355 - TREE_INT_CST_HIGH (value));
357 if (TREE_INT_CST_HIGH (value)
358 != (TREE_INT_CST_LOW (value) >> (HOST_BITS_PER_WIDE_INT - 1)))
360 /* need to print a DImode value in decimal */
361 sorry ("conversion of long long as PT parameter");
363 /* else fall through to print in smaller mode */
365 /* Wordsize or smaller */
366 icat (TREE_INT_CST_LOW (value));
371 icat (TREE_INT_CST_LOW (value));
374 #ifndef REAL_IS_NOT_DOUBLE
378 char *bufp = digit_buffer;
379 extern char *index ();
381 my_friendly_assert (TREE_CODE (value) == REAL_CST, 244);
382 val = TREE_REAL_CST (value);
388 sprintf (bufp, "%e", val);
389 bufp = (char *) index (bufp, 'e');
391 strcat (digit_buffer, "e0");
417 OB_PUTCP (digit_buffer);
422 value = TREE_OPERAND (value, 0);
423 if (TREE_CODE (value) == VAR_DECL)
425 my_friendly_assert (DECL_NAME (value) != 0, 245);
426 build_overload_identifier (DECL_NAME (value));
429 else if (TREE_CODE (value) == FUNCTION_DECL)
431 my_friendly_assert (DECL_NAME (value) != 0, 246);
432 build_overload_identifier (DECL_NAME (value));
436 my_friendly_abort (71);
437 break; /* not really needed */
440 sorry ("conversion of %s as template parameter",
441 tree_code_name [(int) TREE_CODE (type)]);
442 my_friendly_abort (72);
447 build_overload_identifier (name)
450 if (IDENTIFIER_TEMPLATE (name))
452 tree template, parmlist, arglist, tname;
454 template = IDENTIFIER_TEMPLATE (name);
455 arglist = TREE_VALUE (template);
456 template = TREE_PURPOSE (template);
457 tname = DECL_NAME (template);
458 parmlist = DECL_ARGUMENTS (template);
459 nparms = TREE_VEC_LENGTH (parmlist);
461 icat (IDENTIFIER_LENGTH (tname));
464 for (i = 0; i < nparms; i++)
466 tree parm = TREE_VEC_ELT (parmlist, i);
467 tree arg = TREE_VEC_ELT (arglist, i);
468 if (TREE_CODE (parm) == IDENTIFIER_NODE)
470 /* This parameter is a type. */
472 build_overload_name (arg, 0, 0);
476 /* It's a PARM_DECL. */
477 build_overload_name (TREE_TYPE (parm), 0, 0);
478 build_overload_value (parm, arg);
484 icat (IDENTIFIER_LENGTH (name));
489 /* Given a list of parameters in PARMTYPES, create an unambiguous
490 overload string. Should distinguish any type that C (or C++) can
491 distinguish. I.e., pointers to functions are treated correctly.
493 Caller must deal with whether a final `e' goes on the end or not.
495 Any default conversions must take place before this function
498 BEGIN and END control initialization and finalization of the
499 obstack where we build the string. */
502 build_overload_name (parmtypes, begin, end)
509 if (begin) OB_INIT ();
511 if ((just_one = (TREE_CODE (parmtypes) != TREE_LIST)))
513 parmtype = parmtypes;
519 parmtype = TREE_VALUE (parmtypes);
526 /* Every argument gets counted. */
527 typevec[maxtype++] = parmtype;
529 if (TREE_USED (parmtype))
531 if (! just_one && parmtype == typevec[maxtype-2])
536 flush_repeats (parmtype);
537 if (! just_one && TREE_CHAIN (parmtypes)
538 && parmtype == TREE_VALUE (TREE_CHAIN (parmtypes)))
544 while (typevec[tindex] != parmtype)
555 flush_repeats (typevec[maxtype-2]);
557 /* Only cache types which take more than one character. */
558 && (parmtype != TYPE_MAIN_VARIANT (parmtype)
559 || (TREE_CODE (parmtype) != INTEGER_TYPE
560 && TREE_CODE (parmtype) != REAL_TYPE)))
561 TREE_USED (parmtype) = 1;
564 if (TYPE_PTRMEMFUNC_P (parmtype))
565 parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
567 if (TREE_READONLY (parmtype))
569 if (TREE_CODE (parmtype) == INTEGER_TYPE
570 && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype)))
572 if (TYPE_VOLATILE (parmtype))
575 switch (TREE_CODE (parmtype))
579 build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0);
581 build_overload_name (TREE_TYPE (parmtype), 0, 0);
589 #if PARM_CAN_BE_ARRAY_TYPE
594 if (TYPE_DOMAIN (parmtype) == NULL_TREE)
595 error ("pointer or reference to array of unknown bound in parm type");
598 length = array_type_nelts (parmtype);
599 if (TREE_CODE (length) == INTEGER_CST)
600 icat (TREE_INT_CST_LOW (length) + 1);
613 build_overload_name (TREE_TYPE (parmtype), 0, 0);
619 tree firstarg = TYPE_ARG_TYPES (parmtype);
620 /* Otherwise have to implement reentrant typevecs,
621 unmark and remark types, etc. */
622 int old_nofold = nofold;
626 flush_repeats (typevec[maxtype-1]);
628 /* @@ It may be possible to pass a function type in
629 which is not preceded by a 'P'. */
630 if (TREE_CODE (parmtype) == FUNCTION_TYPE)
633 if (firstarg == NULL_TREE)
635 else if (firstarg == void_list_node)
638 build_overload_name (firstarg, 0, 0);
642 int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg)));
643 int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg)));
645 firstarg = TREE_CHAIN (firstarg);
647 build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0);
653 /* For cfront 2.0 compatibility. */
656 if (firstarg == NULL_TREE)
658 else if (firstarg == void_list_node)
661 build_overload_name (firstarg, 0, 0);
664 /* Separate args from return type. */
666 build_overload_name (TREE_TYPE (parmtype), 0, 0);
672 parmtype = TYPE_MAIN_VARIANT (parmtype);
673 if (parmtype == integer_type_node
674 || parmtype == unsigned_type_node)
676 else if (parmtype == long_integer_type_node
677 || parmtype == long_unsigned_type_node)
679 else if (parmtype == short_integer_type_node
680 || parmtype == short_unsigned_type_node)
682 else if (parmtype == signed_char_type_node)
687 else if (parmtype == char_type_node
688 || parmtype == unsigned_char_type_node)
690 else if (parmtype == wchar_type_node)
692 else if (parmtype == long_long_integer_type_node
693 || parmtype == long_long_unsigned_type_node)
696 /* it would seem there is no way to enter these in source code,
698 else if (parmtype == long_long_long_integer_type_node
699 || parmtype == long_long_long_unsigned_type_node)
703 my_friendly_abort (73);
711 parmtype = TYPE_MAIN_VARIANT (parmtype);
712 if (parmtype == long_double_type_node)
714 else if (parmtype == double_type_node)
716 else if (parmtype == float_type_node)
718 else my_friendly_abort (74);
725 extern tree void_list_node;
727 /* See if anybody is wasting memory. */
728 my_friendly_assert (parmtypes == void_list_node, 247);
730 /* This is the end of a parameter list. */
731 if (end) OB_FINISH ();
732 return (char *)obstack_base (&scratch_obstack);
737 case ERROR_MARK: /* not right, but nothing is anyway */
740 /* have to do these */
744 /* Make this type signature look incompatible
751 tree name = TYPE_NAME (parmtype);
754 if (TREE_CODE (name) == TYPE_DECL)
757 while (DECL_CONTEXT (context))
760 context = DECL_CONTEXT (context);
761 if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
762 context = TYPE_NAME (context);
764 name = DECL_NAME (name);
766 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 248);
775 build_overload_nested_name (TYPE_NAME (parmtype));
778 build_overload_identifier (name);
783 /* This will take some work. */
787 case TEMPLATE_TYPE_PARM:
788 case TEMPLATE_CONST_PARM:
789 case UNINSTANTIATED_P_TYPE:
790 /* We don't ever want this output, but it's inconvenient not to
791 be able to build the string. This should cause assembler
792 errors we'll notice. */
795 sprintf (digit_buffer, " *%d", n++);
796 OB_PUTCP (digit_buffer);
801 my_friendly_abort (75);
806 parmtypes = TREE_CHAIN (parmtypes);
811 flush_repeats (typevec[maxtype-1]);
813 /* To get here, parms must end with `...'. */
817 if (end) OB_FINISH ();
818 return (char *)obstack_base (&scratch_obstack);
821 /* Generate an identifier that encodes the (ANSI) exception TYPE. */
823 /* This should be part of `ansi_opname', or at least be defined by the std. */
824 #define EXCEPTION_NAME_PREFIX "__ex"
825 #define EXCEPTION_NAME_LENGTH 4
828 cplus_exception_name (type)
832 OB_PUTS (EXCEPTION_NAME_PREFIX);
833 return get_identifier (build_overload_name (type, 0, 1));
836 /* Change the name of a function definition so that it may be
837 overloaded. NAME is the name of the function to overload,
838 PARMS is the parameter list (which determines what name the
839 final function obtains).
841 FOR_METHOD is 1 if this overload is being performed
842 for a method, rather than a function type. It is 2 if
843 this overload is being performed for a constructor. */
845 build_decl_overload (dname, parms, for_method)
850 char *name = IDENTIFIER_POINTER (dname);
852 /* member operators new and delete look like methods at this point. */
853 if (! for_method && parms != NULL_TREE && TREE_CODE (parms) == TREE_LIST)
855 if (TREE_VALUE (parms) == sizetype
856 && TREE_CHAIN (parms) == void_list_node)
858 if (dname == ansi_opname[(int) NEW_EXPR])
859 return get_identifier ("__builtin_new");
860 else if (dname == ansi_opname[(int) VEC_NEW_EXPR])
861 return get_identifier ("__builtin_vec_new");
863 else if (dname == ansi_opname[(int) DELETE_EXPR])
864 return get_identifier ("__builtin_delete");
865 else if (dname == ansi_opname[(int) VEC_DELETE_EXPR])
866 return get_identifier ("__builtin_vec_delete");
872 /* Otherwise, we can divine that this is a constructor,
873 and figure out its name without any extra encoding. */
879 /* We can get away without doing this. */
883 tree this_type = TREE_VALUE (parms);
885 if (TREE_CODE (this_type) == RECORD_TYPE) /* a signature pointer */
886 parms = temp_tree_cons (NULL_TREE, SIGNATURE_TYPE (this_type),
889 parms = temp_tree_cons (NULL_TREE, TREE_TYPE (this_type),
896 if (parms == NULL_TREE)
897 OB_PUTC2 ('e', '\0');
898 else if (parms == void_list_node)
899 OB_PUTC2 ('v', '\0');
902 ALLOCATE_TYPEVEC (parms);
906 build_overload_name (TREE_VALUE (parms), 0, 0);
908 typevec[maxtype++] = TREE_VALUE (parms);
909 TREE_USED (TREE_VALUE (parms)) = 1;
911 if (TREE_CHAIN (parms))
912 build_overload_name (TREE_CHAIN (parms), 0, 1);
914 OB_PUTC2 ('e', '\0');
917 build_overload_name (parms, 0, 1);
918 DEALLOCATE_TYPEVEC (parms);
921 tree n = get_identifier (obstack_base (&scratch_obstack));
922 if (IDENTIFIER_OPNAME_P (dname))
923 IDENTIFIER_OPNAME_P (n) = 1;
928 /* Build an overload name for the type expression TYPE. */
930 build_typename_overload (type)
936 OB_PUTID (ansi_opname[(int) TYPE_EXPR]);
938 build_overload_name (type, 0, 1);
939 id = get_identifier (obstack_base (&scratch_obstack));
940 IDENTIFIER_OPNAME_P (id) = 1;
942 IDENTIFIER_GLOBAL_VALUE (id) = TYPE_NAME (type);
944 TREE_TYPE (id) = type;
948 #ifndef NO_DOLLAR_IN_LABEL
949 #define T_DESC_FORMAT "TD$"
950 #define I_DESC_FORMAT "ID$"
951 #define M_DESC_FORMAT "MD$"
953 #if !defined(NO_DOT_IN_LABEL)
954 #define T_DESC_FORMAT "TD."
955 #define I_DESC_FORMAT "ID."
956 #define M_DESC_FORMAT "MD."
958 #define T_DESC_FORMAT "__t_desc_"
959 #define I_DESC_FORMAT "__i_desc_"
960 #define M_DESC_FORMAT "__m_desc_"
964 /* Build an overload name for the type expression TYPE. */
966 build_t_desc_overload (type)
970 OB_PUTS (T_DESC_FORMAT);
974 /* Use a different format if the type isn't defined yet. */
975 if (TYPE_SIZE (type) == NULL_TREE)
980 for (p = tname; *p; p++)
986 /* If there's no change, we have an inappropriate T_DESC_FORMAT. */
987 my_friendly_assert (changed != 0, 249);
991 build_overload_name (type, 0, 1);
992 return get_identifier (obstack_base (&scratch_obstack));
995 /* Top-level interface to explicit overload requests. Allow NAME
996 to be overloaded. Error if NAME is already declared for the current
997 scope. Warning if function is redundantly overloaded. */
1000 declare_overloaded (name)
1003 #ifdef NO_AUTO_OVERLOAD
1004 if (is_overloaded (name))
1005 warning ("function `%s' already declared overloaded",
1006 IDENTIFIER_POINTER (name));
1007 else if (IDENTIFIER_GLOBAL_VALUE (name))
1008 error ("overloading function `%s' that is already defined",
1009 IDENTIFIER_POINTER (name));
1012 TREE_OVERLOADED (name) = 1;
1013 IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
1014 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
1017 if (current_lang_name == lang_name_cplusplus)
1020 warning ("functions are implicitly overloaded in C++");
1022 else if (current_lang_name == lang_name_c)
1023 error ("overloading function `%s' cannot be done in C language context");
1025 my_friendly_abort (76);
1029 #ifdef NO_AUTO_OVERLOAD
1030 /* Check to see if NAME is overloaded. For first approximation,
1031 check to see if its TREE_OVERLOADED is set. This is used on
1032 IDENTIFIER nodes. */
1034 is_overloaded (name)
1038 return (TREE_OVERLOADED (name)
1039 && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
1040 && ! IDENTIFIER_LOCAL_VALUE (name));
1044 /* Given a tree_code CODE, and some arguments (at least one),
1045 attempt to use an overloaded operator on the arguments.
1047 For unary operators, only the first argument need be checked.
1048 For binary operators, both arguments may need to be checked.
1050 Member functions can convert class references to class pointers,
1051 for one-level deep indirection. More than that is not supported.
1052 Operators [](), ()(), and ->() must be member functions.
1054 We call function call building calls with LOOKUP_COMPLAIN if they
1055 are our only hope. This is true when we see a vanilla operator
1056 applied to something of aggregate type. If this fails, we are free
1057 to return `error_mark_node', because we will have reported the
1060 Operators NEW and DELETE overload in funny ways: operator new takes
1061 a single `size' parameter, and operator delete takes a pointer to the
1062 storage being deleted. When overloading these operators, success is
1063 assumed. If there is a failure, report an error message and return
1064 `error_mark_node'. */
1068 build_opfncall (code, flags, xarg1, xarg2, arg3)
1069 enum tree_code code;
1071 tree xarg1, xarg2, arg3;
1075 tree type1, type2, fnname;
1076 tree fields1 = 0, parms = 0;
1079 int binary_is_unary;
1081 if (xarg1 == error_mark_node)
1082 return error_mark_node;
1084 if (code == COND_EXPR)
1086 if (TREE_CODE (xarg2) == ERROR_MARK
1087 || TREE_CODE (arg3) == ERROR_MARK)
1088 return error_mark_node;
1090 if (code == COMPONENT_REF)
1091 if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE)
1094 /* First, see if we can work with the first argument */
1095 type1 = TREE_TYPE (xarg1);
1097 /* Some tree codes have length > 1, but we really only want to
1098 overload them if their first argument has a user defined type. */
1101 case PREINCREMENT_EXPR:
1102 case PREDECREMENT_EXPR:
1103 case POSTINCREMENT_EXPR:
1104 case POSTDECREMENT_EXPR:
1106 binary_is_unary = 1;
1110 /* ARRAY_REFs and CALL_EXPRs must overload successfully.
1111 If they do not, return error_mark_node instead of NULL_TREE. */
1113 if (xarg2 == error_mark_node)
1114 return error_mark_node;
1116 rval = error_mark_node;
1117 binary_is_unary = 0;
1124 tree args = tree_cons (NULL_TREE, xarg2, arg3);
1125 fnname = ansi_opname[(int) code];
1126 if (flags & LOOKUP_GLOBAL)
1127 return build_overload_call (fnname, args, flags & LOOKUP_COMPLAIN,
1128 (struct candidate *)0);
1130 rval = build_method_call
1131 (build_indirect_ref (build1 (NOP_EXPR, xarg1, error_mark_node),
1133 fnname, args, NULL_TREE, flags);
1134 if (rval == error_mark_node)
1135 /* User might declare fancy operator new, but invoke it
1136 like standard one. */
1139 TREE_TYPE (rval) = xarg1;
1140 TREE_CALLS_NEW (rval) = 1;
1145 case VEC_DELETE_EXPR:
1148 fnname = ansi_opname[(int) code];
1149 if (flags & LOOKUP_GLOBAL)
1150 return build_overload_call (fnname,
1151 build_tree_list (NULL_TREE, xarg1),
1152 flags & LOOKUP_COMPLAIN,
1153 (struct candidate *)0);
1155 rval = build_method_call
1156 (build_indirect_ref (build1 (NOP_EXPR, TREE_TYPE (xarg1),
1159 fnname, tree_cons (NULL_TREE, xarg1,
1160 build_tree_list (NULL_TREE, xarg2)),
1162 /* This happens when the user mis-declares `operator delete'.
1163 Should now be impossible. */
1164 my_friendly_assert (rval != error_mark_node, 250);
1165 TREE_TYPE (rval) = void_type_node;
1171 binary_is_unary = 0;
1172 try_second = tree_code_length [(int) code] == 2;
1173 if (try_second && xarg2 == error_mark_node)
1174 return error_mark_node;
1178 if (try_second && xarg2 == error_mark_node)
1179 return error_mark_node;
1181 /* What ever it was, we do not know how to deal with it. */
1182 if (type1 == NULL_TREE)
1185 if (TREE_CODE (type1) == OFFSET_TYPE)
1186 type1 = TREE_TYPE (type1);
1188 if (TREE_CODE (type1) == REFERENCE_TYPE)
1190 arg1 = convert_from_reference (xarg1);
1191 type1 = TREE_TYPE (arg1);
1198 if (!IS_AGGR_TYPE (type1) || TYPE_PTRMEMFUNC_P (type1))
1200 /* Try to fail. First, fail if unary */
1203 /* Second, see if second argument is non-aggregate. */
1204 type2 = TREE_TYPE (xarg2);
1205 if (TREE_CODE (type2) == OFFSET_TYPE)
1206 type2 = TREE_TYPE (type2);
1207 if (TREE_CODE (type2) == REFERENCE_TYPE)
1209 arg2 = convert_from_reference (xarg2);
1210 type2 = TREE_TYPE (arg2);
1217 if (!IS_AGGR_TYPE (type2))
1224 /* First arg may succeed; see whether second should. */
1225 type2 = TREE_TYPE (xarg2);
1226 if (TREE_CODE (type2) == OFFSET_TYPE)
1227 type2 = TREE_TYPE (type2);
1228 if (TREE_CODE (type2) == REFERENCE_TYPE)
1230 arg2 = convert_from_reference (xarg2);
1231 type2 = TREE_TYPE (arg2);
1238 if (! IS_AGGR_TYPE (type2))
1242 if (type1 == unknown_type_node
1243 || (try_second && TREE_TYPE (xarg2) == unknown_type_node))
1245 /* This will not be implemented in the foreseeable future. */
1249 if (code == MODIFY_EXPR)
1250 fnname = ansi_assopname[(int) TREE_CODE (arg3)];
1252 fnname = ansi_opname[(int) code];
1254 global_fn = lookup_name_nonclass (fnname);
1256 /* This is the last point where we will accept failure. This
1257 may be too eager if we wish an overloaded operator not to match,
1258 but would rather a normal operator be called on a type-converted
1261 if (IS_AGGR_TYPE (type1))
1263 fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0);
1264 /* ARM $13.4.7, prefix/postfix ++/--. */
1265 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1267 xarg2 = integer_zero_node;
1268 binary_is_unary = 0;
1273 int have_postfix = 0;
1275 /* Look for an `operator++ (int)'. If they didn't have
1276 one, then we fall back to the old way of doing things. */
1277 for (t = TREE_VALUE (fields1); t ; t = TREE_CHAIN (t))
1279 t2 = TYPE_ARG_TYPES (TREE_TYPE (t));
1280 if (TREE_CHAIN (t2) != NULL_TREE
1281 && TREE_VALUE (TREE_CHAIN (t2)) == integer_type_node)
1290 char *op = POSTINCREMENT_EXPR ? "++" : "--";
1292 /* There's probably a LOT of code in the world that
1293 relies upon this old behavior. So we'll only give this
1294 warning when we've been given -pedantic. A few
1295 releases after 2.4, we'll convert this to be a pedwarn
1296 or something else more appropriate. */
1298 warning ("no `operator%s (int)' declared for postfix `%s'",
1301 binary_is_unary = 1;
1307 if (fields1 == NULL_TREE && global_fn == NULL_TREE)
1310 /* If RVAL winds up being `error_mark_node', we will return
1311 that... There is no way that normal semantics of these
1312 operators will succeed. */
1314 /* This argument may be an uncommitted OFFSET_REF. This is
1315 the case for example when dealing with static class members
1316 which are referenced from their class name rather than
1317 from a class instance. */
1318 if (TREE_CODE (xarg1) == OFFSET_REF
1319 && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL)
1320 xarg1 = TREE_OPERAND (xarg1, 1);
1321 if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF
1322 && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL)
1323 xarg2 = TREE_OPERAND (xarg2, 1);
1326 flags |= LOOKUP_GLOBAL;
1328 if (code == CALL_EXPR)
1330 /* This can only be a member function. */
1331 return build_method_call (xarg1, fnname, xarg2,
1332 NULL_TREE, LOOKUP_NORMAL);
1334 else if (tree_code_length[(int) code] == 1 || binary_is_unary)
1337 rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags);
1339 else if (code == COND_EXPR)
1341 parms = tree_cons (0, xarg2, build_tree_list (NULL_TREE, arg3));
1342 rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1344 else if (code == METHOD_CALL_EXPR)
1346 /* must be a member function. */
1347 parms = tree_cons (NULL_TREE, xarg2, arg3);
1348 return build_method_call (xarg1, fnname, parms, NULL_TREE,
1353 parms = build_tree_list (NULL_TREE, xarg2);
1354 rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1358 parms = tree_cons (NULL_TREE, xarg1,
1359 build_tree_list (NULL_TREE, xarg2));
1360 rval = build_overload_call (fnname, parms, flags,
1361 (struct candidate *)0);
1367 /* This function takes an identifier, ID, and attempts to figure out what
1368 it means. There are a number of possible scenarios, presented in increasing
1371 1) not in a class's scope
1372 2) in class's scope, member name of the class's method
1373 3) in class's scope, but not a member name of the class
1374 4) in class's scope, member name of a class's variable
1376 NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
1377 VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
1378 yychar is the pending input character (suitably encoded :-).
1380 As a last ditch, try to look up the name as a label and return that
1383 Values which are declared as being of REFERENCE_TYPE are
1384 automatically dereferenced here (as a hack to make the
1385 compiler faster). */
1388 hack_identifier (value, name, yychar)
1394 if (TREE_CODE (value) == ERROR_MARK)
1396 if (current_class_name)
1398 tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 1);
1399 if (fields == error_mark_node)
1400 return error_mark_node;
1405 fndecl = TREE_VALUE (fields);
1406 my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
1407 if (DECL_CHAIN (fndecl) == NULL_TREE)
1409 warning ("methods cannot be converted to function pointers");
1414 error ("ambiguous request for method pointer `%s'",
1415 IDENTIFIER_POINTER (name));
1416 return error_mark_node;
1420 if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name))
1422 return IDENTIFIER_LABEL_VALUE (name);
1424 return error_mark_node;
1427 type = TREE_TYPE (value);
1428 if (TREE_CODE (value) == FIELD_DECL)
1430 if (current_class_decl == NULL_TREE)
1432 error ("request for member `%s' in static member function",
1433 IDENTIFIER_POINTER (DECL_NAME (value)));
1434 return error_mark_node;
1436 TREE_USED (current_class_decl) = 1;
1438 if (! ((TYPE_LANG_SPECIFIC (type)
1439 && TYPE_OVERLOADS_CALL_EXPR (type))
1440 || (TREE_CODE (type) == REFERENCE_TYPE
1441 && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
1442 && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (type))))
1443 && TREE_CODE (type) != FUNCTION_TYPE
1444 && TREE_CODE (type) != METHOD_TYPE
1445 && !TYPE_PTRMEMFUNC_P (type)
1446 && (TREE_CODE (type) != POINTER_TYPE
1447 || (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
1448 && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)))
1450 error ("component `%s' is not a method",
1451 IDENTIFIER_POINTER (name));
1452 return error_mark_node;
1454 /* Mark so that if we are in a constructor, and then find that
1455 this field was initialized by a base initializer,
1456 we can emit an error message. */
1457 TREE_USED (value) = 1;
1458 return build_component_ref (C_C_D, name, 0, 1);
1461 if (TREE_CODE (value) == TREE_LIST)
1464 while (t && TREE_CODE (t) == TREE_LIST)
1466 assemble_external (TREE_VALUE (t));
1473 assemble_external (value);
1474 TREE_USED (value) = 1;
1477 if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && DECL_NONLOCAL (value))
1479 if (DECL_LANG_SPECIFIC (value)
1480 && DECL_CLASS_CONTEXT (value) != current_class_type)
1483 enum access_type access;
1484 register tree context
1485 = (TREE_CODE (value) == FUNCTION_DECL && DECL_VIRTUAL_P (value))
1486 ? DECL_CLASS_CONTEXT (value)
1487 : DECL_CONTEXT (value);
1489 get_base_distance (context, current_class_type, 0, &path);
1492 access = compute_access (path, value);
1493 if (access != access_public)
1495 if (TREE_CODE (value) == VAR_DECL)
1496 error ("static member `%s' is %s",
1497 IDENTIFIER_POINTER (name),
1498 TREE_PRIVATE (value) ? "private" :
1499 "from a private base class");
1501 error ("enum `%s' is from private base class",
1502 IDENTIFIER_POINTER (name));
1503 return error_mark_node;
1509 if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value))
1513 error ("request for member `%s' is ambiguous in multiple inheritance lattice",
1514 IDENTIFIER_POINTER (name));
1515 return error_mark_node;
1521 if (TREE_CODE (type) == REFERENCE_TYPE)
1523 my_friendly_assert (TREE_CODE (value) == VAR_DECL
1524 || TREE_CODE (value) == PARM_DECL
1525 || TREE_CODE (value) == RESULT_DECL, 252);
1526 if (DECL_REFERENCE_SLOT (value))
1527 return DECL_REFERENCE_SLOT (value);
1534 /* Given an object OF, and a type conversion operator COMPONENT
1535 build a call to the conversion operator, if a call is requested,
1536 or return the address (as a pointer to member function) if one is not.
1538 OF can be a TYPE_DECL or any kind of datum that would normally
1539 be passed to `build_component_ref'. It may also be NULL_TREE,
1540 in which case `current_class_type' and `current_class_decl'
1541 provide default values.
1543 BASETYPE_PATH, if non-null, is the path of basetypes
1544 to go through before we get the the instance of interest.
1546 PROTECT says whether we apply C++ scoping rules or not. */
1548 build_component_type_expr (of, component, basetype_path, protect)
1549 tree of, component, basetype_path;
1552 tree cname = NULL_TREE;
1555 int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN;
1558 my_friendly_assert (IS_AGGR_TYPE (TREE_TYPE (of)), 253);
1559 my_friendly_assert (TREE_CODE (component) == TYPE_EXPR, 254);
1561 tmp = TREE_OPERAND (component, 0);
1566 switch (TREE_CODE (tmp))
1570 TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
1572 TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0);
1574 last = groktypename (build_tree_list (TREE_TYPE (component),
1575 TREE_OPERAND (component, 0)));
1576 name = build_typename_overload (last);
1577 TREE_TYPE (name) = last;
1579 if (TREE_OPERAND (tmp, 0)
1580 && TREE_OPERAND (tmp, 0) != void_list_node)
1582 cp_error ("`operator %T' requires empty parameter list", last);
1583 TREE_OPERAND (tmp, 0) = NULL_TREE;
1586 if (of && TREE_CODE (of) != TYPE_DECL)
1587 return build_method_call (of, name, NULL_TREE, NULL_TREE, flags);
1592 if (current_class_decl == NULL_TREE)
1594 cp_error ("object required for `operator %T' call",
1596 return error_mark_node;
1599 this_this = convert_pointer_to (TREE_TYPE (of),
1600 current_class_decl);
1601 this_this = build_indirect_ref (this_this, NULL_PTR);
1602 return build_method_call (this_this, name, NULL_TREE,
1603 NULL_TREE, flags | LOOKUP_NONVIRTUAL);
1605 else if (current_class_decl)
1606 return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags);
1608 cp_error ("object required for `operator %T' call",
1610 return error_mark_node;
1618 my_friendly_assert (cname == 0, 255);
1619 cname = TREE_OPERAND (tmp, 0);
1620 tmp = TREE_OPERAND (tmp, 1);
1624 my_friendly_abort (77);
1627 tmp = TREE_OPERAND (tmp, 0);
1630 last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0)));
1631 name = build_typename_overload (last);
1632 TREE_TYPE (name) = last;
1633 if (of && TREE_CODE (of) == TYPE_DECL)
1635 if (cname == NULL_TREE)
1637 cname = DECL_NAME (of);
1640 else my_friendly_assert (cname == DECL_NAME (of), 256);
1647 if (current_class_decl == NULL_TREE)
1649 cp_error ("object required for `operator %T' call",
1651 return error_mark_node;
1654 this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
1655 return build_component_ref (this_this, name, 0, protect);
1658 return build_offset_ref (cname, name);
1659 else if (current_class_name)
1660 return build_offset_ref (current_class_name, name);
1662 cp_error ("object required for `operator %T' member reference",
1664 return error_mark_node;
1669 thunk_printable_name (decl)
1672 return "<thunk function>";
1676 make_thunk (function, delta)
1681 tree thunk_fndecl, thunk_id;
1684 static int thunk_number = 0;
1686 if (TREE_CODE (function) != ADDR_EXPR)
1688 func_decl = TREE_OPERAND (function, 0);
1689 if (TREE_CODE (func_decl) != FUNCTION_DECL)
1691 func_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func_decl));
1692 sprintf (buffer, "__thunk_%d_%s", -delta, func_name);
1693 thunk_id = get_identifier (buffer);
1694 thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id);
1695 if (thunk && TREE_CODE (thunk) != THUNK_DECL)
1697 error_with_decl ("implementation-reserved name `%s' used");
1698 IDENTIFIER_GLOBAL_VALUE (thunk_id) = thunk = NULL_TREE;
1700 if (thunk == NULL_TREE)
1702 thunk = build_decl (THUNK_DECL, thunk_id, TREE_TYPE (func_decl));
1704 = build_decl (RESULT_DECL, NULL_TREE, TREE_TYPE (vtable_entry_type));
1705 make_function_rtl (thunk);
1706 DECL_INITIAL (thunk) = function;
1707 THUNK_DELTA (thunk) = delta;
1708 /* So that finish_file can write out any thunks that need to be: */
1709 pushdecl_top_level (thunk);
1715 emit_thunk (thunk_fndecl)
1722 struct args_size stack_args_size;
1723 tree function = TREE_OPERAND (DECL_INITIAL (thunk_fndecl), 0);
1724 int delta = THUNK_DELTA (thunk_fndecl);
1727 int current_call_is_indirect = 0; /* needed for HPPA FUNCTION_ARG */
1729 /* Used to remember which regs we need to emit a USE rtx for. */
1730 rtx need_use[FIRST_PSEUDO_REGISTER];
1731 int need_use_count = 0;
1733 /* rtx for the 'this' parameter. */
1734 rtx this_rtx = 0, this_reg_rtx = 0, fixed_this_rtx;
1736 char *(*save_decl_printable_name) () = decl_printable_name;
1737 /* Data on reg parms scanned so far. */
1738 CUMULATIVE_ARGS args_so_far;
1740 if (TREE_ASM_WRITTEN (thunk_fndecl))
1743 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1745 if (TREE_PUBLIC (function))
1747 TREE_PUBLIC (thunk_fndecl) = 1;
1748 if (DECL_EXTERNAL (function))
1750 DECL_EXTERNAL (thunk_fndecl) = 1;
1751 assemble_external (thunk_fndecl);
1756 decl_printable_name = thunk_printable_name;
1757 if (current_function_decl)
1759 current_function_decl = thunk_fndecl;
1760 init_function_start (thunk_fndecl, input_filename, lineno);
1762 expand_start_bindings (1);
1764 /* Start updating where the next arg would go. */
1765 INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (function), NULL_RTX);
1766 stack_args_size.constant = 0;
1767 stack_args_size.var = 0;
1768 /* SETUP for possible structure return address FIXME */
1770 /* Now look through all the parameters, make sure that we
1771 don't clobber any registers used for parameters.
1772 Also, pick up an rtx for the first "this" parameter. */
1773 for (argp = TYPE_ARG_TYPES (TREE_TYPE (function));
1775 argp = TREE_CHAIN (argp))
1778 tree passed_type = TREE_VALUE (argp);
1779 register rtx entry_parm;
1780 int named = 1; /* FIXME */
1781 struct args_size stack_offset;
1782 struct args_size arg_size;
1784 if (passed_type == void_type_node)
1787 if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
1788 && contains_placeholder_p (TYPE_SIZE (passed_type)))
1789 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1790 || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far,
1791 TYPE_MODE (passed_type),
1795 passed_type = build_pointer_type (passed_type);
1797 entry_parm = FUNCTION_ARG (args_so_far,
1798 TYPE_MODE (passed_type),
1801 if (entry_parm != 0)
1802 need_use[need_use_count++] = entry_parm;
1804 locate_and_pad_parm (TYPE_MODE (passed_type), passed_type,
1805 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1811 &stack_args_size, &stack_offset, &arg_size);
1813 /* REGNO (entry_parm);*/
1816 this_reg_rtx = entry_parm;
1819 rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
1821 rtx internal_arg_pointer, stack_parm;
1823 if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
1824 || ! (fixed_regs[ARG_POINTER_REGNUM]
1825 || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
1826 internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
1828 internal_arg_pointer = virtual_incoming_args_rtx;
1830 if (offset_rtx == const0_rtx)
1831 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1832 internal_arg_pointer);
1834 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1835 gen_rtx (PLUS, Pmode,
1836 internal_arg_pointer,
1840 this_rtx = entry_parm;
1843 FUNCTION_ARG_ADVANCE (args_so_far,
1844 TYPE_MODE (passed_type),
1849 fixed_this_rtx = plus_constant (this_rtx, delta);
1850 if (this_rtx != fixed_this_rtx)
1851 emit_move_insn (this_rtx, fixed_this_rtx);
1854 emit_insn (gen_rtx (USE, VOIDmode, this_reg_rtx));
1856 emit_indirect_jump (XEXP (DECL_RTL (function), 0));
1858 while (need_use_count > 0)
1859 emit_insn (gen_rtx (USE, VOIDmode, need_use[--need_use_count]));
1861 expand_end_bindings (NULL, 1, 0);
1864 /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
1865 Note that that may have been done above, in save_for_inline_copying.
1866 The call to resume_temporary_allocation near the end of this function
1867 goes back to the usual state of affairs. */
1869 rtl_in_current_obstack ();
1871 insns = get_insns ();
1873 /* Copy any shared structure that should not be shared. */
1875 unshare_all_rtl (insns);
1877 /* We are no longer anticipating cse in this function, at least. */
1879 cse_not_expected = 1;
1881 /* Now we choose between stupid (pcc-like) register allocation
1882 (if we got the -noreg switch and not -opt)
1883 and smart register allocation. */
1885 if (optimize > 0) /* Stupid allocation probably won't work */
1886 obey_regdecls = 0; /* if optimizations being done. */
1890 regclass (insns, max_reg_num ());
1893 stupid_life_analysis (insns, max_reg_num (), NULL);
1894 failure = reload (insns, 0, NULL);
1898 /* Do control and data flow analysis,
1899 and write some of the results to dump file. */
1901 flow_analysis (insns, max_reg_num (), NULL);
1903 failure = global_alloc (NULL);
1906 reload_completed = 1;
1908 #ifdef LEAF_REGISTERS
1910 if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
1914 /* If a machine dependent reorganization is needed, call it. */
1915 #ifdef MACHINE_DEPENDENT_REORG
1916 MACHINE_DEPENDENT_REORG (insns);
1919 /* Now turn the rtl into assembler code. */
1922 char *fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
1923 assemble_start_function (thunk_fndecl, fnname);
1924 final (insns, asm_out_file, optimize, 0);
1925 assemble_end_function (thunk_fndecl, fnname);
1928 exit_rest_of_compilation:
1930 reload_completed = 0;
1932 /* Cancel the effect of rtl_in_current_obstack. */
1934 resume_temporary_allocation ();
1936 decl_printable_name = save_decl_printable_name;
1937 current_function_decl = 0;