]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/cp/call.c
cp-tree.h (build_scoped_method_call): Remove.
[thirdparty/gcc.git] / gcc / cp / call.c
CommitLineData
8d08fdba 1/* Functions related to invoking methods and overloaded functions.
3d938426
MM
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
8d08fdba 4 Contributed by Michael Tiemann (tiemann@cygnus.com) and
e5e809f4 5 modified by Brendan Kehoe (brendan@cygnus.com).
8d08fdba 6
f5adbb8d 7This file is part of GCC.
8d08fdba 8
f5adbb8d 9GCC is free software; you can redistribute it and/or modify
8d08fdba
MS
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
f5adbb8d 14GCC is distributed in the hope that it will be useful,
8d08fdba
MS
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
f5adbb8d 20along with GCC; see the file COPYING. If not, write to
e9fa0c7c
RK
21the Free Software Foundation, 59 Temple Place - Suite 330,
22Boston, MA 02111-1307, USA. */
8d08fdba
MS
23
24
e92cc029 25/* High-level class interface. */
8d08fdba
MS
26
27#include "config.h"
8d052bc7 28#include "system.h"
4977bab6
ZW
29#include "coretypes.h"
30#include "tm.h"
570221c2 31#include "tree.h"
8d08fdba 32#include "cp-tree.h"
e8abc66f 33#include "output.h"
8d08fdba 34#include "flags.h"
570221c2 35#include "rtl.h"
54f92bfb 36#include "toplev.h"
70a51bda 37#include "expr.h"
2a2b2d43 38#include "diagnostic.h"
d2a6f3c0 39#include "intl.h"
8d08fdba 40
94be8403
GDR
41static tree build_field_call (tree, tree, tree);
42static struct z_candidate * tourney (struct z_candidate *);
43static int equal_functions (tree, tree);
44static int joust (struct z_candidate *, struct z_candidate *, bool);
45static int compare_ics (tree, tree);
b80f8ef3 46static tree build_over_call (struct z_candidate *, int);
94be8403 47static tree build_java_interface_fn_ref (tree, tree);
3fe18f1d
MM
48#define convert_like(CONV, EXPR) \
49 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
50 /*issue_conversion_warnings=*/true)
51#define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
52 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
53 /*issue_conversion_warnings=*/true)
54static tree convert_like_real (tree, tree, tree, int, int, bool);
94be8403
GDR
55static void op_error (enum tree_code, enum tree_code, tree, tree,
56 tree, const char *);
57static tree build_object_call (tree, tree);
58static tree resolve_args (tree);
59static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
d2a6f3c0 60static void print_z_candidate (const char *, struct z_candidate *);
94be8403
GDR
61static void print_z_candidates (struct z_candidate *);
62static tree build_this (tree);
436f8a4c 63static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
94be8403
GDR
64static bool any_strictly_viable (struct z_candidate *);
65static struct z_candidate *add_template_candidate
7993382e 66 (struct z_candidate **, tree, tree, tree, tree, tree,
94be8403
GDR
67 tree, tree, int, unification_kind_t);
68static struct z_candidate *add_template_candidate_real
7993382e 69 (struct z_candidate **, tree, tree, tree, tree, tree,
94be8403
GDR
70 tree, tree, int, tree, unification_kind_t);
71static struct z_candidate *add_template_conv_candidate
7993382e
MM
72 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
73static void add_builtin_candidates
74 (struct z_candidate **, enum tree_code, enum tree_code,
94be8403 75 tree, tree *, int);
7993382e
MM
76static void add_builtin_candidate
77 (struct z_candidate **, enum tree_code, enum tree_code,
94be8403
GDR
78 tree, tree, tree, tree *, tree *, int);
79static bool is_complete (tree);
7993382e
MM
80static void build_builtin_candidate
81 (struct z_candidate **, tree, tree, tree, tree *, tree *,
94be8403
GDR
82 int);
83static struct z_candidate *add_conv_candidate
7993382e 84 (struct z_candidate **, tree, tree, tree, tree, tree);
94be8403 85static struct z_candidate *add_function_candidate
7993382e 86 (struct z_candidate **, tree, tree, tree, tree, tree, int);
94be8403
GDR
87static tree implicit_conversion (tree, tree, tree, int);
88static tree standard_conversion (tree, tree, tree);
aa6e8ed3 89static tree reference_binding (tree, tree, tree, int);
94be8403
GDR
90static tree build_conv (enum tree_code, tree, tree);
91static bool is_subseq (tree, tree);
92static tree maybe_handle_ref_bind (tree *);
93static void maybe_handle_implicit_object (tree *);
4ba126e4 94static struct z_candidate *add_candidate
7993382e 95 (struct z_candidate **, tree, tree, tree, tree, tree, int);
94be8403
GDR
96static tree source_type (tree);
97static void add_warning (struct z_candidate *, struct z_candidate *);
98static bool reference_related_p (tree, tree);
99static bool reference_compatible_p (tree, tree);
100static tree convert_class_to_reference (tree, tree, tree);
101static tree direct_reference_binding (tree, tree);
102static bool promoted_arithmetic_type_p (tree);
103static tree conditional_conversion (tree, tree);
a723baf1 104static char *name_as_c_string (tree, tree, bool *);
94be8403 105static tree call_builtin_trap (void);
14d22dd6 106static tree prep_operand (tree);
125e6594 107static void add_candidates (tree, tree, tree, bool, tree, tree,
7993382e 108 int, struct z_candidate **);
3d938426 109static tree merge_conversion_sequences (tree, tree);
49c249e1 110
277294d7 111tree
94be8403 112build_vfield_ref (tree datum, tree type)
8d08fdba 113{
277294d7
JM
114 if (datum == error_mark_node)
115 return error_mark_node;
e92cc029 116
277294d7
JM
117 if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
118 datum = convert_from_reference (datum);
8d08fdba 119
50ad9642
MM
120 if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
121 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
122 datum = convert_to_base (datum, type, /*check_access=*/false);
8d08fdba 123
50ad9642
MM
124 return build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),
125 datum, TYPE_VFIELD (type));
8d08fdba
MS
126}
127
277294d7
JM
128/* Build a call to a member of an object. I.e., one that overloads
129 operator ()(), or is a pointer-to-function or pointer-to-method. */
e92cc029 130
277294d7 131static tree
4ba126e4 132build_field_call (tree instance_ptr, tree decl, tree parms)
8d08fdba 133{
4ba126e4 134 tree instance;
8d08fdba 135
4ba126e4
MM
136 if (decl == error_mark_node || decl == NULL_TREE)
137 return decl;
8d08fdba 138
4ba126e4 139 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
277294d7 140 {
90e734a8
JM
141 /* If it's a field, try overloading operator (),
142 or calling if the field is a pointer-to-function. */
3e411c3f 143 instance = build_indirect_ref (instance_ptr, NULL);
50ad9642
MM
144 instance = build_class_member_access_expr (instance, decl,
145 /*access_path=*/NULL_TREE,
146 /*preserve_reference=*/false);
90e734a8
JM
147
148 if (instance == error_mark_node)
149 return error_mark_node;
150
151 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
14d22dd6
MM
152 return build_new_op (CALL_EXPR, LOOKUP_NORMAL,
153 instance, parms, NULL_TREE);
477f6664
JM
154 else if (TREE_CODE (TREE_TYPE (instance)) == FUNCTION_TYPE
155 || (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE
156 && (TREE_CODE (TREE_TYPE (TREE_TYPE (instance)))
157 == FUNCTION_TYPE)))
158 return build_function_call (instance, parms);
8d08fdba 159 }
90e734a8 160
277294d7
JM
161 return NULL_TREE;
162}
8d08fdba 163
1c2c08a5
JM
164/* Returns nonzero iff the destructor name specified in NAME
165 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
166 forms... */
167
94be8403
GDR
168bool
169check_dtor_name (tree basetype, tree name)
1c2c08a5
JM
170{
171 name = TREE_OPERAND (name, 0);
172
ee996e9e 173 /* Just accept something we've already complained about. */
f3400fe2 174 if (name == error_mark_node)
94be8403 175 return true;
f3400fe2 176
1c2c08a5
JM
177 if (TREE_CODE (name) == TYPE_DECL)
178 name = TREE_TYPE (name);
2f939d94 179 else if (TYPE_P (name))
1c2c08a5
JM
180 /* OK */;
181 else if (TREE_CODE (name) == IDENTIFIER_NODE)
182 {
26877584
JM
183 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
184 || (TREE_CODE (basetype) == ENUMERAL_TYPE
185 && name == TYPE_IDENTIFIER (basetype)))
1c2c08a5
JM
186 name = basetype;
187 else
188 name = get_type_value (name);
189 }
8084b91e
MM
190 /* In the case of:
191
192 template <class T> struct S { ~S(); };
193 int i;
194 i.~S();
195
196 NAME will be a class template. */
197 else if (DECL_CLASS_TEMPLATE_P (name))
94be8403 198 return false;
1c2c08a5 199 else
a98facb0 200 abort ();
1c2c08a5
JM
201
202 if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
94be8403
GDR
203 return true;
204 return false;
1c2c08a5
JM
205}
206
277294d7
JM
207/* We want the address of a function or method. We avoid creating a
208 pointer-to-member function. */
209
210tree
94be8403 211build_addr_func (tree function)
277294d7
JM
212{
213 tree type = TREE_TYPE (function);
878cd289 214
277294d7
JM
215 /* We have to do these by hand to avoid real pointer to member
216 functions. */
217 if (TREE_CODE (type) == METHOD_TYPE)
8d08fdba 218 {
d6b4ea85
MM
219 if (TREE_CODE (function) == OFFSET_REF)
220 {
221 tree object = build_address (TREE_OPERAND (function, 0));
222 return get_member_function_from_ptrfunc (&object,
223 TREE_OPERAND (function, 1));
224 }
225 function = build_address (function);
277294d7
JM
226 }
227 else
0a72704b 228 function = decay_conversion (function);
8d08fdba 229
277294d7
JM
230 return function;
231}
8d08fdba 232
277294d7
JM
233/* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
234 POINTER_TYPE to those. Note, pointer to member function types
235 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
8d08fdba
MS
236
237tree
94be8403 238build_call (tree function, tree parms)
8d08fdba 239{
277294d7 240 int is_constructor = 0;
12a22e76 241 int nothrow;
570221c2 242 tree tmp;
7c76b292 243 tree decl;
0c11ada6 244 tree result_type;
5aa3396c 245 tree fntype;
8d08fdba 246
277294d7 247 function = build_addr_func (function);
8d08fdba 248
277294d7 249 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
8d08fdba 250 {
277294d7 251 sorry ("unable to call pointer to member function here");
ce122a86 252 return error_mark_node;
8d08fdba 253 }
ce122a86 254
5aa3396c
JM
255 fntype = TREE_TYPE (TREE_TYPE (function));
256 result_type = TREE_TYPE (fntype);
0c11ada6 257
277294d7 258 if (TREE_CODE (function) == ADDR_EXPR
7c76b292
JM
259 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
260 decl = TREE_OPERAND (function, 0);
261 else
262 decl = NULL_TREE;
263
12a22e76
JM
264 /* We check both the decl and the type; a function may be known not to
265 throw without being declared throw(). */
266 nothrow = ((decl && TREE_NOTHROW (decl))
267 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
e23bd218 268
1a55127d 269 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
efe49da0
JM
270 current_function_returns_abnormally = 1;
271
e23bd218
IR
272 if (decl && TREE_DEPRECATED (decl))
273 warn_deprecated_use (decl);
5aa3396c 274 require_complete_eh_spec_types (fntype, decl);
e23bd218 275
7c76b292 276 if (decl && DECL_CONSTRUCTOR_P (decl))
277294d7 277 is_constructor = 1;
8d08fdba 278
0c11ada6
JM
279 if (decl && ! TREE_USED (decl))
280 {
f49fad00
JM
281 /* We invoke build_call directly for several library functions.
282 These may have been declared normally if we're building libgcc,
283 so we can't just check DECL_ARTIFICIAL. */
284 if (DECL_ARTIFICIAL (decl)
285 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
0c11ada6
JM
286 mark_used (decl);
287 else
a98facb0 288 abort ();
0c11ada6 289 }
a6ecf8b6 290
7c76b292 291 /* Don't pass empty class objects by value. This is useful
570221c2
JM
292 for tags in STL, which are used to control overload resolution.
293 We don't need to handle other cases of copying empty classes. */
7c76b292
JM
294 if (! decl || ! DECL_BUILT_IN (decl))
295 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
296 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
297 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
298 {
699ed0ce 299 tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
a59ca936
JM
300 TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t),
301 TREE_VALUE (tmp), t);
7c76b292 302 }
570221c2 303
277294d7
JM
304 function = build_nt (CALL_EXPR, function, parms, NULL_TREE);
305 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
306 TREE_TYPE (function) = result_type;
307 TREE_SIDE_EFFECTS (function) = 1;
12a22e76 308 TREE_NOTHROW (function) = nothrow;
277294d7
JM
309
310 return function;
311}
8d08fdba 312
277294d7
JM
313/* Build something of the form ptr->method (args)
314 or object.method (args). This can also build
315 calls to constructors, and find friends.
8d08fdba 316
277294d7
JM
317 Member functions always take their class variable
318 as a pointer.
8d08fdba 319
277294d7 320 INSTANCE is a class instance.
8d08fdba 321
277294d7 322 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
8d08fdba 323
277294d7 324 PARMS help to figure out what that NAME really refers to.
8d08fdba 325
277294d7
JM
326 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
327 down to the real instance type to use for access checking. We need this
328 information to get protected accesses correct. This parameter is used
329 by build_member_call.
8d08fdba 330
277294d7
JM
331 FLAGS is the logical disjunction of zero or more LOOKUP_
332 flags. See cp-tree.h for more info.
8d08fdba 333
277294d7
JM
334 If this is all OK, calls build_function_call with the resolved
335 member function.
a4443a08 336
277294d7
JM
337 This function must also handle being called to perform
338 initialization, promotion/coercion of arguments, and
339 instantiation of default parameters.
a4443a08 340
277294d7
JM
341 Note that NAME may refer to an instance variable name. If
342 `operator()()' is defined for the type of that field, then we return
343 that result. */
8d08fdba 344
57bed152
KG
345#ifdef GATHER_STATISTICS
346extern int n_build_method_call;
347#endif
348
277294d7 349tree
94be8403
GDR
350build_method_call (tree instance, tree name, tree parms,
351 tree basetype_path, int flags)
277294d7 352{
4ba126e4
MM
353 tree fn;
354 tree object_type;
355 tree template_args = NULL_TREE;
356 bool has_template_args = false;
8d08fdba 357
277294d7
JM
358#ifdef GATHER_STATISTICS
359 n_build_method_call++;
360#endif
8d08fdba 361
ee76b931 362 if (error_operand_p (instance)
277294d7 363 || name == error_mark_node
ee76b931 364 || parms == error_mark_node)
277294d7 365 return error_mark_node;
8d08fdba 366
ee76b931 367 my_friendly_assert (!processing_template_decl, 20030707);
8d08fdba 368
4ba126e4
MM
369 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
370 instance = convert_from_reference (instance);
371 object_type = TREE_TYPE (instance);
372
277294d7
JM
373 if (TREE_CODE (name) == BIT_NOT_EXPR)
374 {
4ba126e4
MM
375 tree instance_ptr;
376
277294d7 377 if (parms)
8251199e 378 error ("destructors take no parameters");
a4785564 379
4ba126e4 380 if (! check_dtor_name (object_type, name))
33bd39a2 381 error
8251199e 382 ("destructor name `~%T' does not match type `%T' of expression",
4ba126e4 383 TREE_OPERAND (name, 0), object_type);
8d08fdba 384
4ba126e4 385 if (! TYPE_HAS_DESTRUCTOR (complete_type (object_type)))
8d245821 386 return convert_to_void (instance, /*implicit=*/NULL);
277294d7
JM
387 instance = default_conversion (instance);
388 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
4ba126e4 389 return build_delete (build_pointer_type (object_type),
86f45d2c 390 instance_ptr, sfk_complete_destructor,
277294d7 391 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
8d08fdba
MS
392 }
393
4ba126e4
MM
394 if (!CLASS_TYPE_P (object_type))
395 {
396 if ((flags & LOOKUP_COMPLAIN)
397 && TREE_TYPE (instance) != error_mark_node)
398 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
399 name, instance, object_type);
400 return error_mark_node;
401 }
402
403 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
404 {
405 template_args = TREE_OPERAND (name, 1);
406 has_template_args = true;
407 name = TREE_OPERAND (name, 0);
408 }
409 if (TREE_CODE (name) == OVERLOAD)
410 name = DECL_NAME (get_first_fn (name));
411 else if (DECL_P (name))
412 name = DECL_NAME (name);
413 if (has_template_args)
4a34e0e8 414 fn = lookup_fnfields (object_type, name, /*protect=*/2);
4ba126e4 415 else
86ac0575 416 fn = lookup_member (object_type, name, /*protect=*/2, /*want_type=*/false);
4ba126e4 417
ee76b931 418 if (fn && TREE_CODE (fn) == TREE_LIST)
4a34e0e8 419 {
7c38703b 420 error ("request for member `%D' is ambiguous", name);
4a34e0e8
MM
421 print_candidates (fn);
422 return error_mark_node;
423 }
424
4ba126e4
MM
425 /* If the name could not be found, issue an error. */
426 if (!fn)
427 {
428 unqualified_name_lookup_error (name);
429 return error_mark_node;
430 }
431
432 if (BASELINK_P (fn) && has_template_args)
433 BASELINK_FUNCTIONS (fn)
434 = build_nt (TEMPLATE_ID_EXPR,
435 BASELINK_FUNCTIONS (fn),
436 template_args);
437 if (BASELINK_P (fn) && basetype_path)
438 BASELINK_ACCESS_BINFO (fn) = basetype_path;
439
440 return build_new_method_call (instance, fn, parms,
441 /*conversion_path=*/NULL_TREE, flags);
8d08fdba 442}
c73964b2
MS
443
444/* New overloading code. */
445
e2500fed 446struct z_candidate GTY(()) {
4ba126e4
MM
447 /* The FUNCTION_DECL that will be called if this candidate is
448 selected by overload resolution. */
c73964b2 449 tree fn;
b80f8ef3
MM
450 /* The arguments to use when calling this function. */
451 tree args;
3d938426
MM
452 /* The implicit conversion sequences for each of the arguments to
453 FN. */
c73964b2 454 tree convs;
3d938426
MM
455 /* If FN is a user-defined conversion, the standard conversion
456 sequence from the type returned by FN to the desired destination
457 type. */
c73964b2
MS
458 tree second_conv;
459 int viable;
4ba126e4
MM
460 /* If FN is a member function, the binfo indicating the path used to
461 qualify the name of FN at the call site. This path is used to
462 determine whether or not FN is accessible if it is selected by
463 overload resolution. The DECL_CONTEXT of FN will always be a
464 (possibly improper) base of this binfo. */
465 tree access_path;
466 /* If FN is a non-static member function, the binfo indicating the
467 subobject to which the `this' pointer should be converted if FN
468 is selected by overload resolution. The type pointed to the by
469 the `this' pointer must correspond to the most derived class
470 indicated by the CONVERSION_PATH. */
471 tree conversion_path;
c73964b2 472 tree template;
5ffe581d 473 tree warnings;
c73964b2
MS
474 struct z_candidate *next;
475};
476
477#define IDENTITY_RANK 0
478#define EXACT_RANK 1
479#define PROMO_RANK 2
480#define STD_RANK 3
481#define PBOOL_RANK 4
482#define USER_RANK 5
483#define ELLIPSIS_RANK 6
d11ad92e 484#define BAD_RANK 7
c73964b2
MS
485
486#define ICS_RANK(NODE) \
f11f20b0 487 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
d11ad92e 488 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
c73964b2
MS
489 : ICS_USER_FLAG (NODE) ? USER_RANK \
490 : ICS_STD_RANK (NODE))
491
492#define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
493
494#define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
495#define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
d11ad92e
MS
496#define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
497#define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
c73964b2 498
27b8d0cd
MM
499/* In a REF_BIND or a BASE_CONV, this indicates that a temporary
500 should be created to hold the result of the conversion. */
f11f20b0 501#define NEED_TEMPORARY_P(NODE) TREE_LANG_FLAG_4 (NODE)
27b8d0cd 502
e2500fed 503#define USER_CONV_CAND(NODE) WRAPPER_ZC (TREE_OPERAND (NODE, 1))
5ffe581d 504#define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn)
c73964b2 505
94be8403
GDR
506bool
507null_ptr_cst_p (tree t)
c73964b2 508{
a7a64a77
MM
509 /* [conv.ptr]
510
511 A null pointer constant is an integral constant expression
512 (_expr.const_) rvalue of integer type that evaluates to zero. */
d11ad92e 513 if (t == null_node
a7a64a77 514 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
94be8403
GDR
515 return true;
516 return false;
c73964b2
MS
517}
518
a11d04b5 519
838dfd8a 520/* Returns nonzero if PARMLIST consists of only default parms and/or
00a17e31 521 ellipsis. */
a11d04b5 522
94be8403
GDR
523bool
524sufficient_parms_p (tree parmlist)
a11d04b5
NS
525{
526 for (; parmlist && parmlist != void_list_node;
527 parmlist = TREE_CHAIN (parmlist))
528 if (!TREE_PURPOSE (parmlist))
94be8403
GDR
529 return false;
530 return true;
a11d04b5
NS
531}
532
824b9a4c 533static tree
94be8403 534build_conv (enum tree_code code, tree type, tree from)
c73964b2 535{
519c9806 536 tree t;
c73964b2 537 int rank = ICS_STD_RANK (from);
519c9806 538
4cff6abe 539 /* We can't use buildl1 here because CODE could be USER_CONV, which
519c9806
MM
540 takes two arguments. In that case, the caller is responsible for
541 filling in the second argument. */
542 t = make_node (code);
543 TREE_TYPE (t) = type;
544 TREE_OPERAND (t, 0) = from;
545
c73964b2
MS
546 switch (code)
547 {
548 case PTR_CONV:
549 case PMEM_CONV:
550 case BASE_CONV:
551 case STD_CONV:
552 if (rank < STD_RANK)
553 rank = STD_RANK;
554 break;
555
c73964b2 556 case QUAL_CONV:
c73964b2
MS
557 if (rank < EXACT_RANK)
558 rank = EXACT_RANK;
559
560 default:
561 break;
562 }
563 ICS_STD_RANK (t) = rank;
3d938426 564 ICS_USER_FLAG (t) = (code == USER_CONV || ICS_USER_FLAG (from));
d11ad92e 565 ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from);
c73964b2
MS
566 return t;
567}
568
a7a64a77 569tree
94be8403 570strip_top_quals (tree t)
de22184b
MS
571{
572 if (TREE_CODE (t) == ARRAY_TYPE)
573 return t;
574 return TYPE_MAIN_VARIANT (t);
575}
576
c73964b2
MS
577/* Returns the standard conversion path (see [conv]) from type FROM to type
578 TO, if any. For proper handling of null pointer constants, you must
579 also pass the expression EXPR to convert from. */
580
824b9a4c 581static tree
94be8403 582standard_conversion (tree to, tree from, tree expr)
c73964b2
MS
583{
584 enum tree_code fcode, tcode;
585 tree conv;
94be8403 586 bool fromref = false;
de22184b 587
ee76b931 588 to = non_reference (to);
de22184b
MS
589 if (TREE_CODE (from) == REFERENCE_TYPE)
590 {
94be8403 591 fromref = true;
de22184b
MS
592 from = TREE_TYPE (from);
593 }
594 to = strip_top_quals (to);
595 from = strip_top_quals (from);
c73964b2 596
e6e174e5
JM
597 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
598 && expr && type_unknown_p (expr))
599 {
c2ea3a40 600 expr = instantiate_type (to, expr, tf_none);
e6e174e5
JM
601 if (expr == error_mark_node)
602 return NULL_TREE;
603 from = TREE_TYPE (expr);
604 }
605
c73964b2
MS
606 fcode = TREE_CODE (from);
607 tcode = TREE_CODE (to);
608
609 conv = build1 (IDENTITY_CONV, from, expr);
610
c73964b2
MS
611 if (fcode == FUNCTION_TYPE)
612 {
613 from = build_pointer_type (from);
614 fcode = TREE_CODE (from);
615 conv = build_conv (LVALUE_CONV, from, conv);
616 }
617 else if (fcode == ARRAY_TYPE)
618 {
619 from = build_pointer_type (TREE_TYPE (from));
620 fcode = TREE_CODE (from);
621 conv = build_conv (LVALUE_CONV, from, conv);
622 }
583ca5a0 623 else if (fromref || (expr && lvalue_p (expr)))
de22184b
MS
624 conv = build_conv (RVALUE_CONV, from, conv);
625
a04678ca
GDR
626 /* Allow conversion between `__complex__' data types */
627 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
628 {
629 /* The standard conversion sequence to convert FROM to TO is
630 the standard conversion sequence to perform componentwise
631 conversion. */
632 tree part_conv = standard_conversion
633 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE);
634
635 if (part_conv)
636 {
637 conv = build_conv (TREE_CODE (part_conv), to, conv);
638 ICS_STD_RANK (conv) = ICS_STD_RANK (part_conv);
639 }
640 else
641 conv = NULL_TREE;
642
643 return conv;
644 }
645
a7a64a77 646 if (same_type_p (from, to))
de22184b 647 return conv;
c73964b2
MS
648
649 if ((tcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (to))
650 && expr && null_ptr_cst_p (expr))
651 {
652 conv = build_conv (STD_CONV, to, conv);
653 }
72a08131
JM
654 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
655 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
656 {
657 /* For backwards brain damage compatibility, allow interconversion of
658 pointers and integers with a pedwarn. */
659 conv = build_conv (STD_CONV, to, conv);
660 ICS_BAD_FLAG (conv) = 1;
661 }
8a2b77e7
JM
662 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE
663 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
664 {
665 /* For backwards brain damage compatibility, allow interconversion of
666 enums and integers with a pedwarn. */
667 conv = build_conv (STD_CONV, to, conv);
668 ICS_BAD_FLAG (conv) = 1;
669 }
c73964b2
MS
670 else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE)
671 {
672 enum tree_code ufcode = TREE_CODE (TREE_TYPE (from));
673 enum tree_code utcode = TREE_CODE (TREE_TYPE (to));
674
9edc3913
MM
675 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
676 TREE_TYPE (to)))
4d50dd69
JM
677 ;
678 else if (utcode == VOID_TYPE && ufcode != OFFSET_TYPE
679 && ufcode != FUNCTION_TYPE)
c73964b2
MS
680 {
681 from = build_pointer_type
91063b51 682 (cp_build_qualified_type (void_type_node,
89d684bb 683 cp_type_quals (TREE_TYPE (from))));
798eed5e 684 conv = build_conv (PTR_CONV, from, conv);
c73964b2
MS
685 }
686 else if (ufcode == OFFSET_TYPE && utcode == OFFSET_TYPE)
687 {
688 tree fbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (from));
689 tree tbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (to));
690
999cc24c 691 if (DERIVED_FROM_P (fbase, tbase)
9edc3913
MM
692 && (same_type_ignoring_top_level_qualifiers_p
693 (TREE_TYPE (TREE_TYPE (from)),
694 TREE_TYPE (TREE_TYPE (to)))))
c73964b2 695 {
9e259dd1 696 from = build_ptrmem_type (tbase, TREE_TYPE (TREE_TYPE (from)));
798eed5e 697 conv = build_conv (PMEM_CONV, from, conv);
c73964b2 698 }
c73964b2
MS
699 }
700 else if (IS_AGGR_TYPE (TREE_TYPE (from))
701 && IS_AGGR_TYPE (TREE_TYPE (to)))
702 {
703 if (DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
704 {
91063b51
MM
705 from =
706 cp_build_qualified_type (TREE_TYPE (to),
89d684bb 707 cp_type_quals (TREE_TYPE (from)));
c73964b2 708 from = build_pointer_type (from);
798eed5e 709 conv = build_conv (PTR_CONV, from, conv);
c73964b2 710 }
c73964b2 711 }
c73964b2 712
3bfdc719 713 if (same_type_p (from, to))
798eed5e
JM
714 /* OK */;
715 else if (comp_ptr_ttypes (TREE_TYPE (to), TREE_TYPE (from)))
716 conv = build_conv (QUAL_CONV, to, conv);
d9cf7c82
JM
717 else if (expr && string_conv_p (to, expr, 0))
718 /* converting from string constant to char *. */
719 conv = build_conv (QUAL_CONV, to, conv);
d11ad92e 720 else if (ptr_reasonably_similar (TREE_TYPE (to), TREE_TYPE (from)))
c73964b2 721 {
d11ad92e
MS
722 conv = build_conv (PTR_CONV, to, conv);
723 ICS_BAD_FLAG (conv) = 1;
c73964b2 724 }
d11ad92e
MS
725 else
726 return 0;
727
728 from = to;
c73964b2
MS
729 }
730 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
731 {
732 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
733 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
734 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
735 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
736
999cc24c 737 if (!DERIVED_FROM_P (fbase, tbase)
13f9714b
NS
738 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
739 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
740 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
89d684bb 741 || cp_type_quals (fbase) != cp_type_quals (tbase))
c73964b2
MS
742 return 0;
743
89d684bb 744 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
c73964b2
MS
745 from = build_cplus_method_type (from, TREE_TYPE (fromfn),
746 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
747 from = build_ptrmemfunc_type (build_pointer_type (from));
748 conv = build_conv (PMEM_CONV, from, conv);
749 }
750 else if (tcode == BOOLEAN_TYPE)
751 {
752 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE
753 || fcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (from)))
754 return 0;
755
756 conv = build_conv (STD_CONV, to, conv);
a703fb38
KG
757 if (fcode == POINTER_TYPE
758 || (TYPE_PTRMEMFUNC_P (from) && ICS_STD_RANK (conv) < PBOOL_RANK))
c73964b2
MS
759 ICS_STD_RANK (conv) = PBOOL_RANK;
760 }
761 /* We don't check for ENUMERAL_TYPE here because there are no standard
762 conversions to enum type. */
763 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
764 || tcode == REAL_TYPE)
765 {
766 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
767 return 0;
768 conv = build_conv (STD_CONV, to, conv);
769
770 /* Give this a better rank if it's a promotion. */
771 if (to == type_promotes_to (from)
772 && ICS_STD_RANK (TREE_OPERAND (conv, 0)) <= PROMO_RANK)
773 ICS_STD_RANK (conv) = PROMO_RANK;
774 }
775 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
a7a64a77 776 && is_properly_derived_from (from, to))
2dbfb418
JM
777 {
778 if (TREE_CODE (conv) == RVALUE_CONV)
779 conv = TREE_OPERAND (conv, 0);
780 conv = build_conv (BASE_CONV, to, conv);
27b8d0cd
MM
781 /* The derived-to-base conversion indicates the initialization
782 of a parameter with base type from an object of a derived
783 type. A temporary object is created to hold the result of
784 the conversion. */
785 NEED_TEMPORARY_P (conv) = 1;
2dbfb418 786 }
c73964b2
MS
787 else
788 return 0;
789
790 return conv;
791}
792
838dfd8a 793/* Returns nonzero if T1 is reference-related to T2. */
27b8d0cd 794
94be8403
GDR
795static bool
796reference_related_p (tree t1, tree t2)
27b8d0cd
MM
797{
798 t1 = TYPE_MAIN_VARIANT (t1);
799 t2 = TYPE_MAIN_VARIANT (t2);
800
801 /* [dcl.init.ref]
802
803 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
804 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
805 of T2. */
806 return (same_type_p (t1, t2)
807 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
808 && DERIVED_FROM_P (t1, t2)));
809}
810
838dfd8a 811/* Returns nonzero if T1 is reference-compatible with T2. */
27b8d0cd 812
94be8403
GDR
813static bool
814reference_compatible_p (tree t1, tree t2)
27b8d0cd
MM
815{
816 /* [dcl.init.ref]
817
818 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
819 reference-related to T2 and cv1 is the same cv-qualification as,
820 or greater cv-qualification than, cv2. */
821 return (reference_related_p (t1, t2)
822 && at_least_as_qualified_p (t1, t2));
823}
824
825/* Determine whether or not the EXPR (of class type S) can be
826 converted to T as in [over.match.ref]. */
827
828static tree
94be8403 829convert_class_to_reference (tree t, tree s, tree expr)
27b8d0cd
MM
830{
831 tree conversions;
832 tree arglist;
833 tree conv;
7993382e 834 tree reference_type;
27b8d0cd
MM
835 struct z_candidate *candidates;
836 struct z_candidate *cand;
436f8a4c 837 bool any_viable_p;
27b8d0cd 838
7993382e
MM
839 conversions = lookup_conversions (s);
840 if (!conversions)
841 return NULL_TREE;
842
27b8d0cd
MM
843 /* [over.match.ref]
844
845 Assuming that "cv1 T" is the underlying type of the reference
846 being initialized, and "cv S" is the type of the initializer
847 expression, with S a class type, the candidate functions are
848 selected as follows:
849
850 --The conversion functions of S and its base classes are
851 considered. Those that are not hidden within S and yield type
852 "reference to cv2 T2", where "cv1 T" is reference-compatible
853 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
854
855 The argument list has one argument, which is the initializer
856 expression. */
857
858 candidates = 0;
859
860 /* Conceptually, we should take the address of EXPR and put it in
861 the argument list. Unfortunately, however, that can result in
862 error messages, which we should not issue now because we are just
863 trying to find a conversion operator. Therefore, we use NULL,
864 cast to the appropriate type. */
865 arglist = build_int_2 (0, 0);
866 TREE_TYPE (arglist) = build_pointer_type (s);
051e6fd7 867 arglist = build_tree_list (NULL_TREE, arglist);
7993382e
MM
868
869 reference_type = build_reference_type (t);
870
871 while (conversions)
27b8d0cd
MM
872 {
873 tree fns = TREE_VALUE (conversions);
874
aa52c1ff 875 for (; fns; fns = OVL_NEXT (fns))
27b8d0cd
MM
876 {
877 tree f = OVL_CURRENT (fns);
878 tree t2 = TREE_TYPE (TREE_TYPE (f));
7993382e
MM
879
880 cand = NULL;
27b8d0cd
MM
881
882 /* If this is a template function, try to get an exact
883 match. */
884 if (TREE_CODE (f) == TEMPLATE_DECL)
885 {
7993382e
MM
886 cand = add_template_candidate (&candidates,
887 f, s,
888 NULL_TREE,
889 arglist,
890 reference_type,
891 TYPE_BINFO (s),
892 TREE_PURPOSE (conversions),
893 LOOKUP_NORMAL,
894 DEDUCE_CONV);
27b8d0cd 895
7993382e 896 if (cand)
27b8d0cd
MM
897 {
898 /* Now, see if the conversion function really returns
899 an lvalue of the appropriate type. From the
900 point of view of unification, simply returning an
901 rvalue of the right type is good enough. */
7993382e 902 f = cand->fn;
27b8d0cd
MM
903 t2 = TREE_TYPE (TREE_TYPE (f));
904 if (TREE_CODE (t2) != REFERENCE_TYPE
905 || !reference_compatible_p (t, TREE_TYPE (t2)))
7993382e
MM
906 {
907 candidates = candidates->next;
908 cand = NULL;
909 }
27b8d0cd
MM
910 }
911 }
912 else if (TREE_CODE (t2) == REFERENCE_TYPE
913 && reference_compatible_p (t, TREE_TYPE (t2)))
7993382e
MM
914 cand = add_function_candidate (&candidates, f, s, arglist,
915 TYPE_BINFO (s),
916 TREE_PURPOSE (conversions),
917 LOOKUP_NORMAL);
918
919 if (cand)
3d938426
MM
920 /* Build a standard conversion sequence indicating the
921 binding from the reference type returned by the
922 function to the desired REFERENCE_TYPE. */
923 cand->second_conv
924 = (direct_reference_binding
925 (reference_type,
926 build1 (IDENTITY_CONV,
927 TREE_TYPE (TREE_TYPE (TREE_TYPE (cand->fn))),
928 NULL_TREE)));
27b8d0cd 929 }
7993382e 930 conversions = TREE_CHAIN (conversions);
27b8d0cd
MM
931 }
932
436f8a4c 933 candidates = splice_viable (candidates, pedantic, &any_viable_p);
27b8d0cd
MM
934 /* If none of the conversion functions worked out, let our caller
935 know. */
436f8a4c 936 if (!any_viable_p)
27b8d0cd 937 return NULL_TREE;
436f8a4c 938
27b8d0cd
MM
939 cand = tourney (candidates);
940 if (!cand)
941 return NULL_TREE;
942
b80f8ef3
MM
943 /* Now that we know that this is the function we're going to use fix
944 the dummy first argument. */
945 cand->args = tree_cons (NULL_TREE,
946 build_this (expr),
947 TREE_CHAIN (cand->args));
948
3d938426
MM
949 /* Build a user-defined conversion sequence representing the
950 conversion. */
951 conv = build_conv (USER_CONV,
952 TREE_TYPE (TREE_TYPE (cand->fn)),
953 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
954 TREE_OPERAND (conv, 1) = build_zc_wrapper (cand);
955
956 /* Merge it with the standard conversion sequence from the
957 conversion function's return type to the desired type. */
958 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
959
27b8d0cd
MM
960 if (cand->viable == -1)
961 ICS_BAD_FLAG (conv) = 1;
7993382e 962
3d938426 963 return cand->second_conv;
27b8d0cd
MM
964}
965
966/* A reference of the indicated TYPE is being bound directly to the
967 expression represented by the implicit conversion sequence CONV.
968 Return a conversion sequence for this binding. */
969
970static tree
94be8403 971direct_reference_binding (tree type, tree conv)
27b8d0cd 972{
3d938426
MM
973 tree t;
974
975 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306);
976 my_friendly_assert (TREE_CODE (TREE_TYPE (conv)) != REFERENCE_TYPE,
977 20030306);
978
979 t = TREE_TYPE (type);
27b8d0cd
MM
980
981 /* [over.ics.rank]
982
983 When a parameter of reference type binds directly
984 (_dcl.init.ref_) to an argument expression, the implicit
985 conversion sequence is the identity conversion, unless the
986 argument expression has a type that is a derived class of the
987 parameter type, in which case the implicit conversion sequence is
988 a derived-to-base Conversion.
989
990 If the parameter binds directly to the result of applying a
991 conversion function to the argument expression, the implicit
992 conversion sequence is a user-defined conversion sequence
993 (_over.ics.user_), with the second standard conversion sequence
994 either an identity conversion or, if the conversion function
995 returns an entity of a type that is a derived class of the
996 parameter type, a derived-to-base conversion. */
9edc3913 997 if (!same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (conv)))
27b8d0cd
MM
998 {
999 /* Represent the derived-to-base conversion. */
1000 conv = build_conv (BASE_CONV, t, conv);
1001 /* We will actually be binding to the base-class subobject in
1002 the derived class, so we mark this conversion appropriately.
1003 That way, convert_like knows not to generate a temporary. */
1004 NEED_TEMPORARY_P (conv) = 0;
1005 }
1006 return build_conv (REF_BIND, type, conv);
1007}
1008
c73964b2
MS
1009/* Returns the conversion path from type FROM to reference type TO for
1010 purposes of reference binding. For lvalue binding, either pass a
c7f9c6f5
MM
1011 reference type to FROM or an lvalue expression to EXPR. If the
1012 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
aa6e8ed3 1013 the conversion returned. */
c73964b2 1014
824b9a4c 1015static tree
aa6e8ed3 1016reference_binding (tree rto, tree rfrom, tree expr, int flags)
c73964b2 1017{
27b8d0cd 1018 tree conv = NULL_TREE;
c73964b2 1019 tree to = TREE_TYPE (rto);
de22184b 1020 tree from = rfrom;
94be8403
GDR
1021 bool related_p;
1022 bool compatible_p;
27b8d0cd 1023 cp_lvalue_kind lvalue_p = clk_none;
c73964b2 1024
e6e174e5
JM
1025 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1026 {
c2ea3a40 1027 expr = instantiate_type (to, expr, tf_none);
e6e174e5
JM
1028 if (expr == error_mark_node)
1029 return NULL_TREE;
1030 from = TREE_TYPE (expr);
1031 }
1032
27b8d0cd
MM
1033 if (TREE_CODE (from) == REFERENCE_TYPE)
1034 {
1035 /* Anything with reference type is an lvalue. */
1036 lvalue_p = clk_ordinary;
1037 from = TREE_TYPE (from);
1038 }
1039 else if (expr)
1040 lvalue_p = real_lvalue_p (expr);
eb66be0e 1041
b0385db8
MM
1042 /* Figure out whether or not the types are reference-related and
1043 reference compatible. We have do do this after stripping
1044 references from FROM. */
1045 related_p = reference_related_p (to, from);
1046 compatible_p = reference_compatible_p (to, from);
1047
27b8d0cd 1048 if (lvalue_p && compatible_p)
c73964b2 1049 {
27b8d0cd 1050 /* [dcl.init.ref]
c73964b2 1051
aba649ba 1052 If the initializer expression
27b8d0cd
MM
1053
1054 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1055 is reference-compatible with "cv2 T2,"
1056
34cd5ae7 1057 the reference is bound directly to the initializer expression
27b8d0cd
MM
1058 lvalue. */
1059 conv = build1 (IDENTITY_CONV, from, expr);
1060 conv = direct_reference_binding (rto, conv);
1061 if ((lvalue_p & clk_bitfield) != 0
1062 && CP_TYPE_CONST_NON_VOLATILE_P (to))
1063 /* For the purposes of overload resolution, we ignore the fact
1064 this expression is a bitfield. (In particular,
1065 [over.ics.ref] says specifically that a function with a
1066 non-const reference parameter is viable even if the
1067 argument is a bitfield.)
1068
1069 However, when we actually call the function we must create
1070 a temporary to which to bind the reference. If the
1071 reference is volatile, or isn't const, then we cannot make
1072 a temporary, so we just issue an error when the conversion
1073 actually occurs. */
1074 NEED_TEMPORARY_P (conv) = 1;
1075 return conv;
c73964b2 1076 }
27b8d0cd 1077 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
c73964b2 1078 {
27b8d0cd
MM
1079 /* [dcl.init.ref]
1080
34cd5ae7 1081 If the initializer expression
27b8d0cd
MM
1082
1083 -- has a class type (i.e., T2 is a class type) can be
1084 implicitly converted to an lvalue of type "cv3 T3," where
1085 "cv1 T1" is reference-compatible with "cv3 T3". (this
1086 conversion is selected by enumerating the applicable
1087 conversion functions (_over.match.ref_) and choosing the
1088 best one through overload resolution. (_over.match_).
1089
1090 the reference is bound to the lvalue result of the conversion
1091 in the second case. */
1092 conv = convert_class_to_reference (to, from, expr);
c73964b2 1093 if (conv)
7993382e 1094 return conv;
27b8d0cd 1095 }
c73964b2 1096
a7a64a77
MM
1097 /* From this point on, we conceptually need temporaries, even if we
1098 elide them. Only the cases above are "direct bindings". */
1099 if (flags & LOOKUP_NO_TEMP_BIND)
1100 return NULL_TREE;
1101
27b8d0cd
MM
1102 /* [over.ics.rank]
1103
1104 When a parameter of reference type is not bound directly to an
1105 argument expression, the conversion sequence is the one required
1106 to convert the argument expression to the underlying type of the
1107 reference according to _over.best.ics_. Conceptually, this
1108 conversion sequence corresponds to copy-initializing a temporary
1109 of the underlying type with the argument expression. Any
1110 difference in top-level cv-qualification is subsumed by the
1111 initialization itself and does not constitute a conversion. */
1112
1113 /* [dcl.init.ref]
1114
1115 Otherwise, the reference shall be to a non-volatile const type. */
1116 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1117 return NULL_TREE;
1118
1119 /* [dcl.init.ref]
1120
1121 If the initializer expression is an rvalue, with T2 a class type,
1122 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1123 is bound in one of the following ways:
1124
1125 -- The reference is bound to the object represented by the rvalue
1126 or to a sub-object within that object.
1127
aa6e8ed3 1128 -- ...
5e256996 1129
aa6e8ed3
MM
1130 We use the first alternative. The implicit conversion sequence
1131 is supposed to be same as we would obtain by generating a
1132 temporary. Fortunately, if the types are reference compatible,
1133 then this is either an identity conversion or the derived-to-base
1134 conversion, just as for direct binding. */
1135 if (CLASS_TYPE_P (from) && compatible_p)
27b8d0cd
MM
1136 {
1137 conv = build1 (IDENTITY_CONV, from, expr);
1138 return direct_reference_binding (rto, conv);
faf5394a 1139 }
d11ad92e 1140
27b8d0cd
MM
1141 /* [dcl.init.ref]
1142
1143 Otherwise, a temporary of type "cv1 T1" is created and
1144 initialized from the initializer expression using the rules for a
1145 non-reference copy initialization. If T1 is reference-related to
1146 T2, cv1 must be the same cv-qualification as, or greater
1147 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1148 if (related_p && !at_least_as_qualified_p (to, from))
1149 return NULL_TREE;
1150
1151 conv = implicit_conversion (to, from, expr, flags);
1152 if (!conv)
1153 return NULL_TREE;
1154
1155 conv = build_conv (REF_BIND, rto, conv);
1156 /* This reference binding, unlike those above, requires the
1157 creation of a temporary. */
1158 NEED_TEMPORARY_P (conv) = 1;
1159
c73964b2
MS
1160 return conv;
1161}
1162
1163/* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1164 to type TO. The optional expression EXPR may affect the conversion.
1165 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1166 significant. */
1167
824b9a4c 1168static tree
94be8403 1169implicit_conversion (tree to, tree from, tree expr, int flags)
c73964b2
MS
1170{
1171 tree conv;
c73964b2 1172
5d73aa63
MM
1173 if (from == error_mark_node || to == error_mark_node
1174 || expr == error_mark_node)
1175 return NULL_TREE;
1176
c73964b2 1177 if (TREE_CODE (to) == REFERENCE_TYPE)
aa6e8ed3 1178 conv = reference_binding (to, from, expr, flags);
c73964b2 1179 else
de22184b 1180 conv = standard_conversion (to, from, expr);
c73964b2
MS
1181
1182 if (conv)
b80f8ef3
MM
1183 return conv;
1184
1185 if (expr != NULL_TREE
1186 && (IS_AGGR_TYPE (from)
1187 || IS_AGGR_TYPE (to))
1188 && (flags & LOOKUP_NO_CONVERSION) == 0)
c73964b2 1189 {
7993382e
MM
1190 struct z_candidate *cand;
1191
eb66be0e
MS
1192 cand = build_user_type_conversion_1
1193 (to, expr, LOOKUP_ONLYCONVERTING);
1194 if (cand)
1195 conv = cand->second_conv;
5e818b93
JM
1196
1197 /* We used to try to bind a reference to a temporary here, but that
1198 is now handled by the recursive call to this function at the end
1199 of reference_binding. */
b80f8ef3 1200 return conv;
c73964b2
MS
1201 }
1202
b80f8ef3 1203 return NULL_TREE;
c73964b2
MS
1204}
1205
5ffe581d
JM
1206/* Add a new entry to the list of candidates. Used by the add_*_candidate
1207 functions. */
1208
1209static struct z_candidate *
7993382e 1210add_candidate (struct z_candidate **candidates,
b80f8ef3
MM
1211 tree fn, tree args, tree convs, tree access_path,
1212 tree conversion_path, int viable)
5ffe581d
JM
1213{
1214 struct z_candidate *cand
f8a83ee3 1215 = (struct z_candidate *) ggc_alloc_cleared (sizeof (struct z_candidate));
5ffe581d
JM
1216
1217 cand->fn = fn;
b80f8ef3 1218 cand->args = args;
5ffe581d 1219 cand->convs = convs;
4ba126e4
MM
1220 cand->access_path = access_path;
1221 cand->conversion_path = conversion_path;
5ffe581d 1222 cand->viable = viable;
7993382e
MM
1223 cand->next = *candidates;
1224 *candidates = cand;
5ffe581d
JM
1225
1226 return cand;
1227}
1228
c73964b2
MS
1229/* Create an overload candidate for the function or method FN called with
1230 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
aa52c1ff
JM
1231 to implicit_conversion.
1232
1233 CTYPE, if non-NULL, is the type we want to pretend this function
1234 comes from for purposes of overload resolution. */
c73964b2
MS
1235
1236static struct z_candidate *
7993382e 1237add_function_candidate (struct z_candidate **candidates,
4ba126e4
MM
1238 tree fn, tree ctype, tree arglist,
1239 tree access_path, tree conversion_path,
1240 int flags)
c73964b2
MS
1241{
1242 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1243 int i, len;
1244 tree convs;
8f96c7ac 1245 tree parmnode, argnode;
b80f8ef3 1246 tree orig_arglist;
c73964b2 1247 int viable = 1;
c73964b2 1248
089d6ea7
MM
1249 /* Built-in functions that haven't been declared don't really
1250 exist. */
1251 if (DECL_ANTICIPATED (fn))
1252 return NULL;
1253
e0fff4b3
JM
1254 /* The `this', `in_chrg' and VTT arguments to constructors are not
1255 considered in overload resolution. */
c73964b2
MS
1256 if (DECL_CONSTRUCTOR_P (fn))
1257 {
e0fff4b3 1258 parmlist = skip_artificial_parms_for (fn, parmlist);
b80f8ef3 1259 orig_arglist = arglist;
e0fff4b3 1260 arglist = skip_artificial_parms_for (fn, arglist);
c73964b2 1261 }
b80f8ef3
MM
1262 else
1263 orig_arglist = arglist;
c73964b2 1264
8f96c7ac 1265 len = list_length (arglist);
f31c0a32 1266 convs = make_tree_vec (len);
8f96c7ac
JM
1267
1268 /* 13.3.2 - Viable functions [over.match.viable]
1269 First, to be a viable function, a candidate function shall have enough
1270 parameters to agree in number with the arguments in the list.
1271
1272 We need to check this first; otherwise, checking the ICSes might cause
1273 us to produce an ill-formed template instantiation. */
1274
1275 parmnode = parmlist;
1276 for (i = 0; i < len; ++i)
1277 {
1278 if (parmnode == NULL_TREE || parmnode == void_list_node)
1279 break;
1280 parmnode = TREE_CHAIN (parmnode);
1281 }
1282
1283 if (i < len && parmnode)
1284 viable = 0;
1285
1286 /* Make sure there are default args for the rest of the parms. */
a11d04b5
NS
1287 else if (!sufficient_parms_p (parmnode))
1288 viable = 0;
8f96c7ac
JM
1289
1290 if (! viable)
1291 goto out;
1292
1293 /* Second, for F to be a viable function, there shall exist for each
1294 argument an implicit conversion sequence that converts that argument
1295 to the corresponding parameter of F. */
1296
1297 parmnode = parmlist;
1298 argnode = arglist;
c73964b2
MS
1299
1300 for (i = 0; i < len; ++i)
1301 {
1302 tree arg = TREE_VALUE (argnode);
8cd4c175 1303 tree argtype = lvalue_type (arg);
c73964b2 1304 tree t;
aa52c1ff 1305 int is_this;
c73964b2 1306
c73964b2
MS
1307 if (parmnode == void_list_node)
1308 break;
aa45967f 1309
aa52c1ff
JM
1310 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1311 && ! DECL_CONSTRUCTOR_P (fn));
1312
aa45967f
JM
1313 if (parmnode)
1314 {
1315 tree parmtype = TREE_VALUE (parmnode);
1316
aa52c1ff
JM
1317 /* The type of the implicit object parameter ('this') for
1318 overload resolution is not always the same as for the
1319 function itself; conversion functions are considered to
1320 be members of the class being converted, and functions
1321 introduced by a using-declaration are considered to be
1322 members of the class that uses them.
aa45967f 1323
aa52c1ff
JM
1324 Since build_over_call ignores the ICS for the `this'
1325 parameter, we can just change the parm type. */
1326 if (ctype && is_this)
aa45967f
JM
1327 {
1328 parmtype
aa52c1ff 1329 = build_qualified_type (ctype,
aa45967f
JM
1330 TYPE_QUALS (TREE_TYPE (parmtype)));
1331 parmtype = build_pointer_type (parmtype);
1332 }
1333
1334 t = implicit_conversion (parmtype, argtype, arg, flags);
1335 }
c73964b2
MS
1336 else
1337 {
1338 t = build1 (IDENTITY_CONV, argtype, arg);
1339 ICS_ELLIPSIS_FLAG (t) = 1;
1340 }
1341
aa52c1ff 1342 if (t && is_this)
d11ad92e
MS
1343 ICS_THIS_FLAG (t) = 1;
1344
c73964b2
MS
1345 TREE_VEC_ELT (convs, i) = t;
1346 if (! t)
8f96c7ac
JM
1347 {
1348 viable = 0;
1349 break;
1350 }
c73964b2 1351
d11ad92e
MS
1352 if (ICS_BAD_FLAG (t))
1353 viable = -1;
1354
c73964b2
MS
1355 if (parmnode)
1356 parmnode = TREE_CHAIN (parmnode);
1357 argnode = TREE_CHAIN (argnode);
1358 }
1359
8f96c7ac 1360 out:
b80f8ef3 1361 return add_candidate (candidates, fn, orig_arglist, convs, access_path,
4ba126e4 1362 conversion_path, viable);
c73964b2
MS
1363}
1364
1365/* Create an overload candidate for the conversion function FN which will
1366 be invoked for expression OBJ, producing a pointer-to-function which
1367 will in turn be called with the argument list ARGLIST, and add it to
37b6eb34
JM
1368 CANDIDATES. FLAGS is passed on to implicit_conversion.
1369
1370 Actually, we don't really care about FN; we care about the type it
1371 converts to. There may be multiple conversion functions that will
1372 convert to that type, and we rely on build_user_type_conversion_1 to
1373 choose the best one; so when we create our candidate, we record the type
1374 instead of the function. */
c73964b2
MS
1375
1376static struct z_candidate *
7993382e 1377add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
94be8403 1378 tree arglist, tree access_path, tree conversion_path)
c73964b2
MS
1379{
1380 tree totype = TREE_TYPE (TREE_TYPE (fn));
477f6664
JM
1381 int i, len, viable, flags;
1382 tree parmlist, convs, parmnode, argnode;
1383
1384 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1385 parmlist = TREE_TYPE (parmlist);
1386 parmlist = TYPE_ARG_TYPES (parmlist);
1387
1388 len = list_length (arglist) + 1;
1389 convs = make_tree_vec (len);
1390 parmnode = parmlist;
1391 argnode = arglist;
1392 viable = 1;
1393 flags = LOOKUP_NORMAL;
c73964b2 1394
37b6eb34 1395 /* Don't bother looking up the same type twice. */
7993382e
MM
1396 if (*candidates && (*candidates)->fn == totype)
1397 return NULL;
37b6eb34 1398
c73964b2
MS
1399 for (i = 0; i < len; ++i)
1400 {
1401 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
d11ad92e 1402 tree argtype = lvalue_type (arg);
c73964b2
MS
1403 tree t;
1404
c73964b2
MS
1405 if (i == 0)
1406 t = implicit_conversion (totype, argtype, arg, flags);
1407 else if (parmnode == void_list_node)
1408 break;
1409 else if (parmnode)
1410 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1411 else
1412 {
1413 t = build1 (IDENTITY_CONV, argtype, arg);
1414 ICS_ELLIPSIS_FLAG (t) = 1;
1415 }
1416
1417 TREE_VEC_ELT (convs, i) = t;
1418 if (! t)
1419 break;
1420
d11ad92e
MS
1421 if (ICS_BAD_FLAG (t))
1422 viable = -1;
1423
c73964b2
MS
1424 if (i == 0)
1425 continue;
1426
1427 if (parmnode)
1428 parmnode = TREE_CHAIN (parmnode);
1429 argnode = TREE_CHAIN (argnode);
1430 }
1431
1432 if (i < len)
1433 viable = 0;
1434
a11d04b5
NS
1435 if (!sufficient_parms_p (parmnode))
1436 viable = 0;
c73964b2 1437
b80f8ef3 1438 return add_candidate (candidates, totype, arglist, convs, access_path,
4ba126e4 1439 conversion_path, viable);
c73964b2
MS
1440}
1441
7993382e
MM
1442static void
1443build_builtin_candidate (struct z_candidate **candidates, tree fnname,
94be8403
GDR
1444 tree type1, tree type2, tree *args, tree *argtypes,
1445 int flags)
c73964b2
MS
1446{
1447 tree t, convs;
1448 int viable = 1, i;
c73964b2
MS
1449 tree types[2];
1450
1451 types[0] = type1;
1452 types[1] = type2;
1453
f31c0a32 1454 convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1));
c73964b2
MS
1455
1456 for (i = 0; i < 2; ++i)
1457 {
1458 if (! args[i])
1459 break;
1460
1461 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1462 if (! t)
1463 {
1464 viable = 0;
1465 /* We need something for printing the candidate. */
1466 t = build1 (IDENTITY_CONV, types[i], NULL_TREE);
1467 }
d11ad92e
MS
1468 else if (ICS_BAD_FLAG (t))
1469 viable = 0;
c73964b2
MS
1470 TREE_VEC_ELT (convs, i) = t;
1471 }
1472
1473 /* For COND_EXPR we rearranged the arguments; undo that now. */
1474 if (args[2])
1475 {
1476 TREE_VEC_ELT (convs, 2) = TREE_VEC_ELT (convs, 1);
1477 TREE_VEC_ELT (convs, 1) = TREE_VEC_ELT (convs, 0);
1478 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1479 if (t)
1480 TREE_VEC_ELT (convs, 0) = t;
1481 else
1482 viable = 0;
1483 }
1484
7993382e
MM
1485 add_candidate (candidates, fnname, /*args=*/NULL_TREE, convs,
1486 /*access_path=*/NULL_TREE,
1487 /*conversion_path=*/NULL_TREE,
1488 viable);
c73964b2
MS
1489}
1490
94be8403
GDR
1491static bool
1492is_complete (tree t)
c73964b2 1493{
d0f062fb 1494 return COMPLETE_TYPE_P (complete_type (t));
c73964b2
MS
1495}
1496
838dfd8a 1497/* Returns nonzero if TYPE is a promoted arithmetic type. */
a7a64a77 1498
94be8403
GDR
1499static bool
1500promoted_arithmetic_type_p (tree type)
a7a64a77
MM
1501{
1502 /* [over.built]
1503
1504 In this section, the term promoted integral type is used to refer
1505 to those integral types which are preserved by integral promotion
1506 (including e.g. int and long but excluding e.g. char).
1507 Similarly, the term promoted arithmetic type refers to promoted
1508 integral types plus floating types. */
1509 return ((INTEGRAL_TYPE_P (type)
1510 && same_type_p (type_promotes_to (type), type))
1511 || TREE_CODE (type) == REAL_TYPE);
1512}
1513
c73964b2
MS
1514/* Create any builtin operator overload candidates for the operator in
1515 question given the converted operand types TYPE1 and TYPE2. The other
1516 args are passed through from add_builtin_candidates to
4cff6abe
NS
1517 build_builtin_candidate.
1518
1519 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1520 If CODE is requires candidates operands of the same type of the kind
1521 of which TYPE1 and TYPE2 are, we add both candidates
1522 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
c73964b2 1523
7993382e
MM
1524static void
1525add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
94be8403
GDR
1526 enum tree_code code2, tree fnname, tree type1,
1527 tree type2, tree *args, tree *argtypes, int flags)
c73964b2
MS
1528{
1529 switch (code)
1530 {
1531 case POSTINCREMENT_EXPR:
1532 case POSTDECREMENT_EXPR:
1533 args[1] = integer_zero_node;
1534 type2 = integer_type_node;
7f85441b
KG
1535 break;
1536 default:
1537 break;
c73964b2
MS
1538 }
1539
1540 switch (code)
1541 {
1542
1543/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1544 and VQ is either volatile or empty, there exist candidate operator
1545 functions of the form
1546 VQ T& operator++(VQ T&);
1547 T operator++(VQ T&, int);
1548 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1549 type other than bool, and VQ is either volatile or empty, there exist
1550 candidate operator functions of the form
1551 VQ T& operator--(VQ T&);
1552 T operator--(VQ T&, int);
1553 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1554 complete object type, and VQ is either volatile or empty, there exist
1555 candidate operator functions of the form
1556 T*VQ& operator++(T*VQ&);
1557 T*VQ& operator--(T*VQ&);
1558 T* operator++(T*VQ&, int);
1559 T* operator--(T*VQ&, int); */
1560
1561 case POSTDECREMENT_EXPR:
1562 case PREDECREMENT_EXPR:
1563 if (TREE_CODE (type1) == BOOLEAN_TYPE)
7993382e 1564 return;
c73964b2
MS
1565 case POSTINCREMENT_EXPR:
1566 case PREINCREMENT_EXPR:
4cff6abe 1567 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
c73964b2
MS
1568 {
1569 type1 = build_reference_type (type1);
1570 break;
1571 }
7993382e 1572 return;
c73964b2
MS
1573
1574/* 7 For every cv-qualified or cv-unqualified complete object type T, there
1575 exist candidate operator functions of the form
1576
1577 T& operator*(T*);
1578
1579 8 For every function type T, there exist candidate operator functions of
1580 the form
1581 T& operator*(T*); */
1582
1583 case INDIRECT_REF:
1584 if (TREE_CODE (type1) == POINTER_TYPE
c11b6f21 1585 && (TYPE_PTROB_P (type1)
c73964b2
MS
1586 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1587 break;
7993382e 1588 return;
c73964b2
MS
1589
1590/* 9 For every type T, there exist candidate operator functions of the form
1591 T* operator+(T*);
1592
1593 10For every promoted arithmetic type T, there exist candidate operator
1594 functions of the form
1595 T operator+(T);
1596 T operator-(T); */
1597
1598 case CONVERT_EXPR: /* unary + */
1599 if (TREE_CODE (type1) == POINTER_TYPE
1600 && TREE_CODE (TREE_TYPE (type1)) != OFFSET_TYPE)
1601 break;
1602 case NEGATE_EXPR:
1603 if (ARITHMETIC_TYPE_P (type1))
1604 break;
7993382e 1605 return;
c73964b2
MS
1606
1607/* 11For every promoted integral type T, there exist candidate operator
1608 functions of the form
1609 T operator~(T); */
1610
1611 case BIT_NOT_EXPR:
1612 if (INTEGRAL_TYPE_P (type1))
1613 break;
7993382e 1614 return;
c73964b2
MS
1615
1616/* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1617 is the same type as C2 or is a derived class of C2, T is a complete
1618 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1619 there exist candidate operator functions of the form
1620 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1621 where CV12 is the union of CV1 and CV2. */
1622
1623 case MEMBER_REF:
1624 if (TREE_CODE (type1) == POINTER_TYPE
1625 && (TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2)))
1626 {
1627 tree c1 = TREE_TYPE (type1);
1628 tree c2 = (TYPE_PTRMEMFUNC_P (type2)
8e69329a 1629 ? TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2)))
c73964b2
MS
1630 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2)));
1631
1632 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1633 && (TYPE_PTRMEMFUNC_P (type2)
1634 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1635 break;
1636 }
7993382e 1637 return;
c73964b2
MS
1638
1639/* 13For every pair of promoted arithmetic types L and R, there exist can-
1640 didate operator functions of the form
1641 LR operator*(L, R);
1642 LR operator/(L, R);
1643 LR operator+(L, R);
1644 LR operator-(L, R);
1645 bool operator<(L, R);
1646 bool operator>(L, R);
1647 bool operator<=(L, R);
1648 bool operator>=(L, R);
1649 bool operator==(L, R);
1650 bool operator!=(L, R);
1651 where LR is the result of the usual arithmetic conversions between
1652 types L and R.
1653
1654 14For every pair of types T and I, where T is a cv-qualified or cv-
1655 unqualified complete object type and I is a promoted integral type,
1656 there exist candidate operator functions of the form
1657 T* operator+(T*, I);
1658 T& operator[](T*, I);
1659 T* operator-(T*, I);
1660 T* operator+(I, T*);
1661 T& operator[](I, T*);
1662
1663 15For every T, where T is a pointer to complete object type, there exist
1664 candidate operator functions of the form112)
1665 ptrdiff_t operator-(T, T);
1666
e5596aef 1667 16For every pointer or enumeration type T, there exist candidate operator
4cff6abe 1668 functions of the form
c73964b2
MS
1669 bool operator<(T, T);
1670 bool operator>(T, T);
1671 bool operator<=(T, T);
1672 bool operator>=(T, T);
1673 bool operator==(T, T);
1674 bool operator!=(T, T);
1675
1676 17For every pointer to member type T, there exist candidate operator
1677 functions of the form
1678 bool operator==(T, T);
1679 bool operator!=(T, T); */
1680
1681 case MINUS_EXPR:
c11b6f21 1682 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
c73964b2 1683 break;
c11b6f21 1684 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
c73964b2
MS
1685 {
1686 type2 = ptrdiff_type_node;
1687 break;
1688 }
1689 case MULT_EXPR:
1690 case TRUNC_DIV_EXPR:
1691 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1692 break;
7993382e 1693 return;
c73964b2
MS
1694
1695 case EQ_EXPR:
1696 case NE_EXPR:
a703fb38
KG
1697 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1698 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
c73964b2
MS
1699 break;
1700 if ((TYPE_PTRMEMFUNC_P (type1) || TYPE_PTRMEM_P (type1))
1701 && null_ptr_cst_p (args[1]))
1702 {
1703 type2 = type1;
1704 break;
1705 }
1706 if ((TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2))
1707 && null_ptr_cst_p (args[0]))
1708 {
1709 type1 = type2;
1710 break;
1711 }
4cff6abe 1712 /* FALLTHROUGH */
c73964b2
MS
1713 case LT_EXPR:
1714 case GT_EXPR:
1715 case LE_EXPR:
1716 case GE_EXPR:
1717 case MAX_EXPR:
1718 case MIN_EXPR:
4cff6abe
NS
1719 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1720 break;
1721 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
c73964b2 1722 break;
4cff6abe
NS
1723 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1724 break;
c73964b2
MS
1725 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1726 {
1727 type2 = type1;
1728 break;
1729 }
1730 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1731 {
1732 type1 = type2;
1733 break;
1734 }
7993382e 1735 return;
c73964b2
MS
1736
1737 case PLUS_EXPR:
1738 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1739 break;
1740 case ARRAY_REF:
c11b6f21 1741 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
c73964b2
MS
1742 {
1743 type1 = ptrdiff_type_node;
1744 break;
1745 }
c11b6f21 1746 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
c73964b2
MS
1747 {
1748 type2 = ptrdiff_type_node;
1749 break;
1750 }
7993382e 1751 return;
c73964b2
MS
1752
1753/* 18For every pair of promoted integral types L and R, there exist candi-
1754 date operator functions of the form
1755 LR operator%(L, R);
1756 LR operator&(L, R);
1757 LR operator^(L, R);
1758 LR operator|(L, R);
1759 L operator<<(L, R);
1760 L operator>>(L, R);
1761 where LR is the result of the usual arithmetic conversions between
1762 types L and R. */
1763
1764 case TRUNC_MOD_EXPR:
1765 case BIT_AND_EXPR:
1766 case BIT_IOR_EXPR:
1767 case BIT_XOR_EXPR:
1768 case LSHIFT_EXPR:
1769 case RSHIFT_EXPR:
1770 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1771 break;
7993382e 1772 return;
c73964b2
MS
1773
1774/* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1775 type, VQ is either volatile or empty, and R is a promoted arithmetic
1776 type, there exist candidate operator functions of the form
1777 VQ L& operator=(VQ L&, R);
1778 VQ L& operator*=(VQ L&, R);
1779 VQ L& operator/=(VQ L&, R);
1780 VQ L& operator+=(VQ L&, R);
1781 VQ L& operator-=(VQ L&, R);
1782
1783 20For every pair T, VQ), where T is any type and VQ is either volatile
1784 or empty, there exist candidate operator functions of the form
1785 T*VQ& operator=(T*VQ&, T*);
1786
1787 21For every pair T, VQ), where T is a pointer to member type and VQ is
1788 either volatile or empty, there exist candidate operator functions of
1789 the form
1790 VQ T& operator=(VQ T&, T);
1791
1792 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1793 unqualified complete object type, VQ is either volatile or empty, and
1794 I is a promoted integral type, there exist candidate operator func-
1795 tions of the form
1796 T*VQ& operator+=(T*VQ&, I);
1797 T*VQ& operator-=(T*VQ&, I);
1798
1799 23For every triple L, VQ, R), where L is an integral or enumeration
1800 type, VQ is either volatile or empty, and R is a promoted integral
1801 type, there exist candidate operator functions of the form
1802
1803 VQ L& operator%=(VQ L&, R);
1804 VQ L& operator<<=(VQ L&, R);
1805 VQ L& operator>>=(VQ L&, R);
1806 VQ L& operator&=(VQ L&, R);
1807 VQ L& operator^=(VQ L&, R);
1808 VQ L& operator|=(VQ L&, R); */
1809
1810 case MODIFY_EXPR:
1811 switch (code2)
1812 {
1813 case PLUS_EXPR:
1814 case MINUS_EXPR:
c11b6f21 1815 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
c73964b2
MS
1816 {
1817 type2 = ptrdiff_type_node;
1818 break;
1819 }
1820 case MULT_EXPR:
1821 case TRUNC_DIV_EXPR:
1822 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1823 break;
7993382e 1824 return;
c73964b2
MS
1825
1826 case TRUNC_MOD_EXPR:
1827 case BIT_AND_EXPR:
1828 case BIT_IOR_EXPR:
1829 case BIT_XOR_EXPR:
1830 case LSHIFT_EXPR:
1831 case RSHIFT_EXPR:
1832 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1833 break;
7993382e 1834 return;
c73964b2
MS
1835
1836 case NOP_EXPR:
1837 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1838 break;
1839 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1840 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1841 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1842 || ((TYPE_PTRMEMFUNC_P (type1)
1843 || TREE_CODE (type1) == POINTER_TYPE)
1844 && null_ptr_cst_p (args[1])))
1845 {
1846 type2 = type1;
1847 break;
1848 }
7993382e 1849 return;
c73964b2
MS
1850
1851 default:
a98facb0 1852 abort ();
c73964b2
MS
1853 }
1854 type1 = build_reference_type (type1);
1855 break;
1856
1857 case COND_EXPR:
5b0c5896 1858 /* [over.built]
a7a64a77
MM
1859
1860 For every pair of promoted arithmetic types L and R, there
1861 exist candidate operator functions of the form
de22184b 1862
a7a64a77
MM
1863 LR operator?(bool, L, R);
1864
1865 where LR is the result of the usual arithmetic conversions
1866 between types L and R.
1867
1868 For every type T, where T is a pointer or pointer-to-member
1869 type, there exist candidate operator functions of the form T
1870 operator?(bool, T, T); */
1871
1872 if (promoted_arithmetic_type_p (type1)
1873 && promoted_arithmetic_type_p (type2))
1874 /* That's OK. */
c73964b2 1875 break;
a7a64a77
MM
1876
1877 /* Otherwise, the types should be pointers. */
1878 if (!(TREE_CODE (type1) == POINTER_TYPE
1879 || TYPE_PTRMEM_P (type1)
1880 || TYPE_PTRMEMFUNC_P (type1))
1881 || !(TREE_CODE (type2) == POINTER_TYPE
1882 || TYPE_PTRMEM_P (type2)
1883 || TYPE_PTRMEMFUNC_P (type2)))
7993382e 1884 return;
a7a64a77
MM
1885
1886 /* We don't check that the two types are the same; the logic
1887 below will actually create two candidates; one in which both
1888 parameter types are TYPE1, and one in which both parameter
1889 types are TYPE2. */
7993382e 1890 break;
c73964b2
MS
1891
1892 default:
a98facb0 1893 abort ();
c73964b2
MS
1894 }
1895
4cff6abe
NS
1896 /* If we're dealing with two pointer types or two enumeral types,
1897 we need candidates for both of them. */
a7a64a77 1898 if (type2 && !same_type_p (type1, type2)
c73964b2
MS
1899 && TREE_CODE (type1) == TREE_CODE (type2)
1900 && (TREE_CODE (type1) == REFERENCE_TYPE
1901 || (TREE_CODE (type1) == POINTER_TYPE
1902 && TYPE_PTRMEM_P (type1) == TYPE_PTRMEM_P (type2))
1903 || TYPE_PTRMEMFUNC_P (type1)
4cff6abe
NS
1904 || IS_AGGR_TYPE (type1)
1905 || TREE_CODE (type1) == ENUMERAL_TYPE))
c73964b2 1906 {
7993382e 1907 build_builtin_candidate
c73964b2 1908 (candidates, fnname, type1, type1, args, argtypes, flags);
7993382e 1909 build_builtin_candidate
c73964b2 1910 (candidates, fnname, type2, type2, args, argtypes, flags);
7993382e 1911 return;
c73964b2
MS
1912 }
1913
7993382e 1914 build_builtin_candidate
c73964b2
MS
1915 (candidates, fnname, type1, type2, args, argtypes, flags);
1916}
1917
1918tree
94be8403 1919type_decays_to (tree type)
c73964b2
MS
1920{
1921 if (TREE_CODE (type) == ARRAY_TYPE)
1922 return build_pointer_type (TREE_TYPE (type));
1923 if (TREE_CODE (type) == FUNCTION_TYPE)
1924 return build_pointer_type (type);
1925 return type;
1926}
1927
1928/* There are three conditions of builtin candidates:
1929
1930 1) bool-taking candidates. These are the same regardless of the input.
1931 2) pointer-pair taking candidates. These are generated for each type
1932 one of the input types converts to.
cab1f180 1933 3) arithmetic candidates. According to the standard, we should generate
4cff6abe
NS
1934 all of these, but I'm trying not to...
1935
1936 Here we generate a superset of the possible candidates for this particular
1937 case. That is a subset of the full set the standard defines, plus some
1938 other cases which the standard disallows. add_builtin_candidate will
0e339752 1939 filter out the invalid set. */
c73964b2 1940
7993382e
MM
1941static void
1942add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
94be8403
GDR
1943 enum tree_code code2, tree fnname, tree *args,
1944 int flags)
c73964b2
MS
1945{
1946 int ref1, i;
4cff6abe 1947 int enum_p = 0;
a7a64a77
MM
1948 tree type, argtypes[3];
1949 /* TYPES[i] is the set of possible builtin-operator parameter types
1950 we will consider for the Ith argument. These are represented as
1951 a TREE_LIST; the TREE_VALUE of each node is the potential
1952 parameter type. */
1953 tree types[2];
c73964b2
MS
1954
1955 for (i = 0; i < 3; ++i)
1956 {
1957 if (args[i])
d11ad92e 1958 argtypes[i] = lvalue_type (args[i]);
c73964b2
MS
1959 else
1960 argtypes[i] = NULL_TREE;
1961 }
1962
1963 switch (code)
1964 {
1965/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1966 and VQ is either volatile or empty, there exist candidate operator
1967 functions of the form
1968 VQ T& operator++(VQ T&); */
1969
1970 case POSTINCREMENT_EXPR:
1971 case PREINCREMENT_EXPR:
1972 case POSTDECREMENT_EXPR:
1973 case PREDECREMENT_EXPR:
1974 case MODIFY_EXPR:
1975 ref1 = 1;
1976 break;
1977
1978/* 24There also exist candidate operator functions of the form
1979 bool operator!(bool);
1980 bool operator&&(bool, bool);
1981 bool operator||(bool, bool); */
1982
1983 case TRUTH_NOT_EXPR:
7993382e 1984 build_builtin_candidate
c73964b2
MS
1985 (candidates, fnname, boolean_type_node,
1986 NULL_TREE, args, argtypes, flags);
7993382e 1987 return;
c73964b2
MS
1988
1989 case TRUTH_ORIF_EXPR:
1990 case TRUTH_ANDIF_EXPR:
7993382e 1991 build_builtin_candidate
c73964b2
MS
1992 (candidates, fnname, boolean_type_node,
1993 boolean_type_node, args, argtypes, flags);
7993382e 1994 return;
c73964b2
MS
1995
1996 case ADDR_EXPR:
1997 case COMPOUND_EXPR:
1998 case COMPONENT_REF:
7993382e 1999 return;
c73964b2 2000
4cff6abe
NS
2001 case COND_EXPR:
2002 case EQ_EXPR:
2003 case NE_EXPR:
2004 case LT_EXPR:
2005 case LE_EXPR:
2006 case GT_EXPR:
2007 case GE_EXPR:
2008 enum_p = 1;
2009 /* FALLTHROUGH */
2010
c73964b2
MS
2011 default:
2012 ref1 = 0;
2013 }
2014
2015 types[0] = types[1] = NULL_TREE;
2016
2017 for (i = 0; i < 2; ++i)
2018 {
2019 if (! args[i])
2020 ;
2021 else if (IS_AGGR_TYPE (argtypes[i]))
2022 {
47898a19 2023 tree convs;
c73964b2 2024
02020185 2025 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
7993382e 2026 return;
02020185
JM
2027
2028 convs = lookup_conversions (argtypes[i]);
2029
c73964b2
MS
2030 if (code == COND_EXPR)
2031 {
2032 if (real_lvalue_p (args[i]))
e1b3e07d 2033 types[i] = tree_cons
c73964b2
MS
2034 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2035
e1b3e07d 2036 types[i] = tree_cons
c73964b2
MS
2037 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2038 }
02020185
JM
2039
2040 else if (! convs)
7993382e 2041 return;
c73964b2
MS
2042
2043 for (; convs; convs = TREE_CHAIN (convs))
2044 {
47898a19 2045 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
c73964b2
MS
2046
2047 if (i == 0 && ref1
2048 && (TREE_CODE (type) != REFERENCE_TYPE
91063b51 2049 || CP_TYPE_CONST_P (TREE_TYPE (type))))
c73964b2
MS
2050 continue;
2051
2052 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
e1b3e07d 2053 types[i] = tree_cons (NULL_TREE, type, types[i]);
c73964b2
MS
2054
2055 type = non_reference (type);
2056 if (i != 0 || ! ref1)
2057 {
2058 type = TYPE_MAIN_VARIANT (type_decays_to (type));
4cff6abe
NS
2059 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2060 types[i] = tree_cons (NULL_TREE, type, types[i]);
c73964b2
MS
2061 if (INTEGRAL_TYPE_P (type))
2062 type = type_promotes_to (type);
2063 }
2064
2065 if (! value_member (type, types[i]))
e1b3e07d 2066 types[i] = tree_cons (NULL_TREE, type, types[i]);
c73964b2
MS
2067 }
2068 }
2069 else
2070 {
2071 if (code == COND_EXPR && real_lvalue_p (args[i]))
e1b3e07d 2072 types[i] = tree_cons
c73964b2
MS
2073 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2074 type = non_reference (argtypes[i]);
2075 if (i != 0 || ! ref1)
2076 {
2077 type = TYPE_MAIN_VARIANT (type_decays_to (type));
4cff6abe
NS
2078 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2079 types[i] = tree_cons (NULL_TREE, type, types[i]);
c73964b2
MS
2080 if (INTEGRAL_TYPE_P (type))
2081 type = type_promotes_to (type);
2082 }
e1b3e07d 2083 types[i] = tree_cons (NULL_TREE, type, types[i]);
c73964b2
MS
2084 }
2085 }
2086
a7a64a77
MM
2087 /* Run through the possible parameter types of both arguments,
2088 creating candidates with those parameter types. */
c73964b2
MS
2089 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2090 {
2091 if (types[1])
2092 for (type = types[1]; type; type = TREE_CHAIN (type))
7993382e 2093 add_builtin_candidate
c73964b2
MS
2094 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2095 TREE_VALUE (type), args, argtypes, flags);
2096 else
7993382e 2097 add_builtin_candidate
c73964b2
MS
2098 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2099 NULL_TREE, args, argtypes, flags);
2100 }
2101
7993382e 2102 return;
c73964b2
MS
2103}
2104
e1467ff2 2105
386b8a85
JM
2106/* If TMPL can be successfully instantiated as indicated by
2107 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2108
e1467ff2
MM
2109 TMPL is the template. EXPLICIT_TARGS are any explicit template
2110 arguments. ARGLIST is the arguments provided at the call-site.
2111 The RETURN_TYPE is the desired type for conversion operators. If
aa52c1ff
JM
2112 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2113 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
e1467ff2
MM
2114 add_conv_candidate. */
2115
2116static struct z_candidate*
7993382e 2117add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
94be8403
GDR
2118 tree ctype, tree explicit_targs, tree arglist,
2119 tree return_type, tree access_path,
2120 tree conversion_path, int flags, tree obj,
2121 unification_kind_t strict)
c73964b2 2122{
98c1c668 2123 int ntparms = DECL_NTPARMS (tmpl);
f31c0a32 2124 tree targs = make_tree_vec (ntparms);
e5214479 2125 tree args_without_in_chrg = arglist;
c73964b2 2126 struct z_candidate *cand;
98c1c668 2127 int i;
c73964b2
MS
2128 tree fn;
2129
e5214479
JM
2130 /* We don't do deduction on the in-charge parameter, the VTT
2131 parameter or 'this'. */
2132 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2133 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2134
71a19881
MM
2135 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2136 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2137 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl)))
e5214479 2138 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
71a19881
MM
2139
2140 i = fn_type_unification (tmpl, explicit_targs, targs,
2141 args_without_in_chrg,
e5214479 2142 return_type, strict, -1);
98c1c668 2143
c73964b2 2144 if (i != 0)
7993382e 2145 return NULL;
c73964b2 2146
3e4a3562 2147 fn = instantiate_template (tmpl, targs, tf_none);
c73964b2 2148 if (fn == error_mark_node)
7993382e 2149 return NULL;
c73964b2 2150
9928a3d5
MM
2151 /* In [class.copy]:
2152
2153 A member function template is never instantiated to perform the
2154 copy of a class object to an object of its class type.
2155
2156 It's a little unclear what this means; the standard explicitly
2157 does allow a template to be used to copy a class. For example,
2158 in:
2159
2160 struct A {
2161 A(A&);
2162 template <class T> A(const T&);
2163 };
2164 const A f ();
2165 void g () { A a (f ()); }
2166
2167 the member template will be used to make the copy. The section
2168 quoted above appears in the paragraph that forbids constructors
2169 whose only parameter is (a possibly cv-qualified variant of) the
2170 class type, and a logical interpretation is that the intent was
2171 to forbid the instantiation of member templates which would then
2172 have that form. */
2173 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2174 {
2175 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2176 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2177 ctype))
7993382e 2178 return NULL;
9928a3d5
MM
2179 }
2180
e1467ff2
MM
2181 if (obj != NULL_TREE)
2182 /* Aha, this is a conversion function. */
4ba126e4
MM
2183 cand = add_conv_candidate (candidates, fn, obj, access_path,
2184 conversion_path, arglist);
e1467ff2 2185 else
aa52c1ff 2186 cand = add_function_candidate (candidates, fn, ctype,
4ba126e4
MM
2187 arglist, access_path,
2188 conversion_path, flags);
e1467ff2
MM
2189 if (DECL_TI_TEMPLATE (fn) != tmpl)
2190 /* This situation can occur if a member template of a template
2191 class is specialized. Then, instantiate_template might return
2192 an instantiation of the specialization, in which case the
2193 DECL_TI_TEMPLATE field will point at the original
2194 specialization. For example:
2195
2196 template <class T> struct S { template <class U> void f(U);
2197 template <> void f(int) {}; };
2198 S<double> sd;
2199 sd.f(3);
2200
2201 Here, TMPL will be template <class U> S<double>::f(U).
2202 And, instantiate template will give us the specialization
2203 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2204 for this will point at template <class T> template <> S<T>::f(int),
2205 so that we can find the definition. For the purposes of
2206 overload resolution, however, we want the original TMPL. */
2207 cand->template = tree_cons (tmpl, targs, NULL_TREE);
2208 else
2209 cand->template = DECL_TEMPLATE_INFO (fn);
2210
c73964b2
MS
2211 return cand;
2212}
2213
786b5245
MM
2214
2215static struct z_candidate *
7993382e 2216add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
94be8403
GDR
2217 tree explicit_targs, tree arglist, tree return_type,
2218 tree access_path, tree conversion_path, int flags,
2219 unification_kind_t strict)
786b5245 2220{
e1467ff2 2221 return
aa52c1ff 2222 add_template_candidate_real (candidates, tmpl, ctype,
4ba126e4
MM
2223 explicit_targs, arglist, return_type,
2224 access_path, conversion_path,
2225 flags, NULL_TREE, strict);
e1467ff2 2226}
786b5245 2227
786b5245 2228
e1467ff2 2229static struct z_candidate *
7993382e 2230add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
94be8403
GDR
2231 tree obj, tree arglist, tree return_type,
2232 tree access_path, tree conversion_path)
e1467ff2
MM
2233{
2234 return
aa52c1ff 2235 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
4ba126e4
MM
2236 arglist, return_type, access_path,
2237 conversion_path, 0, obj, DEDUCE_CONV);
786b5245
MM
2238}
2239
436f8a4c
MM
2240/* The CANDS are the set of candidates that were considered for
2241 overload resolution. Return the set of viable candidates. If none
2242 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2243 is true if a candidate should be considered viable only if it is
2244 strictly viable. */
786b5245 2245
436f8a4c
MM
2246static struct z_candidate*
2247splice_viable (struct z_candidate *cands,
2248 bool strict_p,
2249 bool *any_viable_p)
c73964b2 2250{
436f8a4c
MM
2251 struct z_candidate *viable;
2252 struct z_candidate **last_viable;
2253 struct z_candidate **cand;
2254
2255 viable = NULL;
2256 last_viable = &viable;
2257 *any_viable_p = false;
2258
2259 cand = &cands;
2260 while (*cand)
2261 {
2262 struct z_candidate *c = *cand;
2263 if (strict_p ? c->viable == 1 : c->viable)
2264 {
2265 *last_viable = c;
2266 *cand = c->next;
2267 c->next = NULL;
2268 last_viable = &c->next;
2269 *any_viable_p = true;
2270 }
2271 else
2272 cand = &c->next;
2273 }
2274
2275 return viable ? viable : cands;
c73964b2
MS
2276}
2277
94be8403
GDR
2278static bool
2279any_strictly_viable (struct z_candidate *cands)
ecc42c14
AO
2280{
2281 for (; cands; cands = cands->next)
2282 if (cands->viable == 1)
94be8403
GDR
2283 return true;
2284 return false;
ecc42c14
AO
2285}
2286
824b9a4c 2287static tree
94be8403 2288build_this (tree obj)
c73964b2
MS
2289{
2290 /* Fix this to work on non-lvalues. */
6eabb241 2291 return build_unary_op (ADDR_EXPR, obj, 0);
c73964b2
MS
2292}
2293
436f8a4c
MM
2294/* Returns true iff functions are equivalent. Equivalent functions are
2295 not '==' only if one is a function-local extern function or if
2296 both are extern "C". */
2297
2298static inline int
2299equal_functions (tree fn1, tree fn2)
2300{
2301 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2302 || DECL_EXTERN_C_FUNCTION_P (fn1))
2303 return decls_match (fn1, fn2);
2304 return fn1 == fn2;
2305}
2306
d2a6f3c0
ZW
2307/* Print information about one overload candidate CANDIDATE. MSGSTR
2308 is the text to print before the candidate itself.
2309
2310 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2311 to have been run through gettext by the caller. This wart makes
2312 life simpler in print_z_candidates and for the translators. */
b9747e59
JM
2313
2314static void
d2a6f3c0 2315print_z_candidate (const char *msgstr, struct z_candidate *candidate)
b9747e59
JM
2316{
2317 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2318 {
2319 if (TREE_VEC_LENGTH (candidate->convs) == 3)
d2a6f3c0
ZW
2320 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2321 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2322 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)),
2323 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 2)));
b9747e59 2324 else if (TREE_VEC_LENGTH (candidate->convs) == 2)
d2a6f3c0
ZW
2325 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2326 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2327 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)));
b9747e59 2328 else
d2a6f3c0
ZW
2329 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2330 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)));
b9747e59
JM
2331 }
2332 else if (TYPE_P (candidate->fn))
d2a6f3c0
ZW
2333 inform ("%s %T <conversion>", msgstr, candidate->fn);
2334 else if (candidate->viable == -1)
2335 inform ("%H%s %+#D <near match>",
2336 &DECL_SOURCE_LOCATION (candidate->fn), msgstr, candidate->fn);
b9747e59 2337 else
d2a6f3c0
ZW
2338 inform ("%H%s %+#D",
2339 &DECL_SOURCE_LOCATION (candidate->fn), msgstr, candidate->fn);
b9747e59
JM
2340}
2341
c73964b2 2342static void
94be8403 2343print_z_candidates (struct z_candidate *candidates)
c73964b2 2344{
436f8a4c
MM
2345 const char *str;
2346 struct z_candidate *cand1;
2347 struct z_candidate **cand2;
2348
2349 /* There may be duplicates in the set of candidates. We put off
2350 checking this condition as long as possible, since we have no way
2351 to eliminate duplicates from a set of functions in less than n^2
2352 time. Now we are about to emit an error message, so it is more
2353 permissible to go slowly. */
2354 for (cand1 = candidates; cand1; cand1 = cand1->next)
2355 {
2356 tree fn = cand1->fn;
2357 /* Skip builtin candidates and conversion functions. */
2358 if (TREE_CODE (fn) != FUNCTION_DECL)
2359 continue;
2360 cand2 = &cand1->next;
2361 while (*cand2)
2362 {
2363 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2364 && equal_functions (fn, (*cand2)->fn))
2365 *cand2 = (*cand2)->next;
2366 else
2367 cand2 = &(*cand2)->next;
2368 }
2369 }
2370
d2a6f3c0
ZW
2371 if (!candidates)
2372 return;
2373
2374 str = _("candidates are:");
2375 print_z_candidate (str, candidates);
2376 if (candidates->next)
c73964b2 2377 {
2bd02043
ZW
2378 /* Indent successive candidates by the width of the translation
2379 of the above string. */
2380 size_t len = gcc_gettext_width (str) + 1;
d2a6f3c0
ZW
2381 char *spaces = alloca (len);
2382 memset (spaces, ' ', len-1);
9804b5b8 2383 spaces[len - 1] = '\0';
d2a6f3c0
ZW
2384
2385 candidates = candidates->next;
2386 do
2387 {
2388 print_z_candidate (spaces, candidates);
2389 candidates = candidates->next;
2390 }
2391 while (candidates);
c73964b2
MS
2392 }
2393}
2394
3d938426
MM
2395/* USER_SEQ is a user-defined conversion sequence, beginning with a
2396 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2397 the result of the conversion function to convert it to the final
2398 desired type. Merge the the two sequences into a single sequence,
2399 and return the merged sequence. */
2400
2401static tree
2402merge_conversion_sequences (tree user_seq, tree std_seq)
2403{
2404 tree *t;
2405
2406 my_friendly_assert (TREE_CODE (user_seq) == USER_CONV,
2407 20030306);
2408
2409 /* Find the end of the second conversion sequence. */
2410 t = &(std_seq);
2411 while (TREE_CODE (*t) != IDENTITY_CONV)
2412 t = &TREE_OPERAND (*t, 0);
2413
2414 /* Replace the identity conversion with the user conversion
2415 sequence. */
2416 *t = user_seq;
2417
2418 /* The entire sequence is a user-conversion sequence. */
2419 ICS_USER_FLAG (std_seq) = 1;
2420
2421 return std_seq;
2422}
2423
c73964b2 2424/* Returns the best overload candidate to perform the requested
eb66be0e
MS
2425 conversion. This function is used for three the overloading situations
2426 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2427 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2428 per [dcl.init.ref], so we ignore temporary bindings. */
c73964b2
MS
2429
2430static struct z_candidate *
94be8403 2431build_user_type_conversion_1 (tree totype, tree expr, int flags)
c73964b2
MS
2432{
2433 struct z_candidate *candidates, *cand;
2434 tree fromtype = TREE_TYPE (expr);
3d938426 2435 tree ctors = NULL_TREE, convs = NULL_TREE;
a703fb38 2436 tree args = NULL_TREE;
436f8a4c 2437 bool any_viable_p;
c73964b2 2438
5e818b93
JM
2439 /* We represent conversion within a hierarchy using RVALUE_CONV and
2440 BASE_CONV, as specified by [over.best.ics]; these become plain
2441 constructor calls, as specified in [dcl.init]. */
41f5d4b1
NS
2442 my_friendly_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2443 || !DERIVED_FROM_P (totype, fromtype), 20011226);
5e818b93 2444
c73964b2 2445 if (IS_AGGR_TYPE (totype))
db9b2174 2446 ctors = lookup_fnfields (TYPE_BINFO (totype),
1f84ec23 2447 complete_ctor_identifier,
db9b2174
MM
2448 0);
2449
5e818b93 2450 if (IS_AGGR_TYPE (fromtype))
c73964b2
MS
2451 convs = lookup_conversions (fromtype);
2452
2453 candidates = 0;
2454 flags |= LOOKUP_NO_CONVERSION;
2455
2456 if (ctors)
2457 {
454fa7a7
MM
2458 tree t;
2459
50ad9642 2460 ctors = BASELINK_FUNCTIONS (ctors);
454fa7a7
MM
2461
2462 t = build_int_2 (0, 0);
c73964b2 2463 TREE_TYPE (t) = build_pointer_type (totype);
051e6fd7 2464 args = build_tree_list (NULL_TREE, expr);
41f5d4b1
NS
2465 /* We should never try to call the abstract or base constructor
2466 from here. */
2467 my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2468 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)),
2469 20011226);
e1b3e07d 2470 args = tree_cons (NULL_TREE, t, args);
c73964b2 2471 }
2c73f9f5 2472 for (; ctors; ctors = OVL_NEXT (ctors))
c73964b2 2473 {
2c73f9f5
ML
2474 tree ctor = OVL_CURRENT (ctors);
2475 if (DECL_NONCONVERTING_P (ctor))
c73964b2
MS
2476 continue;
2477
2c73f9f5 2478 if (TREE_CODE (ctor) == TEMPLATE_DECL)
7993382e
MM
2479 cand = add_template_candidate (&candidates, ctor, totype,
2480 NULL_TREE, args, NULL_TREE,
2481 TYPE_BINFO (totype),
2482 TYPE_BINFO (totype),
2483 flags,
2484 DEDUCE_CALL);
98c1c668 2485 else
7993382e
MM
2486 cand = add_function_candidate (&candidates, ctor, totype,
2487 args, TYPE_BINFO (totype),
2488 TYPE_BINFO (totype),
2489 flags);
98c1c668 2490
7993382e
MM
2491 if (cand)
2492 cand->second_conv = build1 (IDENTITY_CONV, totype, NULL_TREE);
c73964b2
MS
2493 }
2494
2495 if (convs)
051e6fd7 2496 args = build_tree_list (NULL_TREE, build_this (expr));
c73964b2
MS
2497
2498 for (; convs; convs = TREE_CHAIN (convs))
2499 {
4ba126e4
MM
2500 tree fns;
2501 tree conversion_path = TREE_PURPOSE (convs);
eb66be0e 2502 int convflags = LOOKUP_NO_CONVERSION;
eb66be0e
MS
2503
2504 /* If we are called to convert to a reference type, we are trying to
2505 find an lvalue binding, so don't even consider temporaries. If
2506 we don't find an lvalue binding, the caller will try again to
2507 look for a temporary binding. */
2508 if (TREE_CODE (totype) == REFERENCE_TYPE)
2509 convflags |= LOOKUP_NO_TEMP_BIND;
5dd236e2 2510
4ba126e4 2511 for (fns = TREE_VALUE (convs); fns; fns = OVL_NEXT (fns))
5dd236e2
NS
2512 {
2513 tree fn = OVL_CURRENT (fns);
5dd236e2
NS
2514
2515 /* [over.match.funcs] For conversion functions, the function
2516 is considered to be a member of the class of the implicit
2517 object argument for the purpose of defining the type of
2518 the implicit object parameter.
eb66be0e 2519
5dd236e2
NS
2520 So we pass fromtype as CTYPE to add_*_candidate. */
2521
2522 if (TREE_CODE (fn) == TEMPLATE_DECL)
7993382e
MM
2523 cand = add_template_candidate (&candidates, fn, fromtype,
2524 NULL_TREE,
2525 args, totype,
2526 TYPE_BINFO (fromtype),
2527 conversion_path,
2528 flags,
2529 DEDUCE_CONV);
5dd236e2 2530 else
7993382e
MM
2531 cand = add_function_candidate (&candidates, fn, fromtype,
2532 args,
2533 TYPE_BINFO (fromtype),
2534 conversion_path,
2535 flags);
5dd236e2 2536
7993382e 2537 if (cand)
5dd236e2 2538 {
7993382e
MM
2539 tree ics = implicit_conversion (totype,
2540 TREE_TYPE (TREE_TYPE (cand->fn)),
2541 0, convflags);
5dd236e2 2542
7993382e 2543 cand->second_conv = ics;
5dd236e2
NS
2544
2545 if (ics == NULL_TREE)
7993382e 2546 cand->viable = 0;
5dd236e2 2547 else if (candidates->viable == 1 && ICS_BAD_FLAG (ics))
7993382e 2548 cand->viable = -1;
5dd236e2
NS
2549 }
2550 }
c73964b2
MS
2551 }
2552
436f8a4c
MM
2553 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2554 if (!any_viable_p)
4ba126e4 2555 return 0;
c73964b2 2556
da20811c 2557 cand = tourney (candidates);
c73964b2
MS
2558 if (cand == 0)
2559 {
2560 if (flags & LOOKUP_COMPLAIN)
2561 {
33bd39a2 2562 error ("conversion from `%T' to `%T' is ambiguous",
c73964b2
MS
2563 fromtype, totype);
2564 print_z_candidates (candidates);
2565 }
2566
2567 cand = candidates; /* any one will do */
2568 cand->second_conv = build1 (AMBIG_CONV, totype, expr);
2569 ICS_USER_FLAG (cand->second_conv) = 1;
f576dfc4
JM
2570 if (!any_strictly_viable (candidates))
2571 ICS_BAD_FLAG (cand->second_conv) = 1;
2572 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2573 ambiguous conversion is no worse than another user-defined
2574 conversion. */
c73964b2
MS
2575
2576 return cand;
2577 }
2578
3d938426
MM
2579 /* Build the user conversion sequence. */
2580 convs = build_conv
c73964b2
MS
2581 (USER_CONV,
2582 (DECL_CONSTRUCTOR_P (cand->fn)
2583 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3d938426
MM
2584 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
2585 TREE_OPERAND (convs, 1) = build_zc_wrapper (cand);
2586
2587 /* Combine it with the second conversion sequence. */
2588 cand->second_conv = merge_conversion_sequences (convs,
2589 cand->second_conv);
2590
faf5394a 2591 if (cand->viable == -1)
3d938426 2592 ICS_BAD_FLAG (cand->second_conv) = 1;
c73964b2
MS
2593
2594 return cand;
2595}
2596
2597tree
94be8403 2598build_user_type_conversion (tree totype, tree expr, int flags)
c73964b2
MS
2599{
2600 struct z_candidate *cand
2601 = build_user_type_conversion_1 (totype, expr, flags);
2602
2603 if (cand)
2604 {
2605 if (TREE_CODE (cand->second_conv) == AMBIG_CONV)
2606 return error_mark_node;
5e818b93 2607 return convert_from_reference (convert_like (cand->second_conv, expr));
c73964b2
MS
2608 }
2609 return NULL_TREE;
2610}
2611
3e14cd30
NS
2612/* Find the possibly overloaded set of functions corresponding to a
2613 call of the form SCOPE::NAME (...). NAME might be a
9bcb9aae 2614 TEMPLATE_ID_EXPR, OVERLOAD, _DECL, IDENTIFIER_NODE or LOOKUP_EXPR. */
3e14cd30
NS
2615
2616tree
2617resolve_scoped_fn_name (tree scope, tree name)
2618{
8cd2462c 2619 tree fn = NULL_TREE;
3e14cd30
NS
2620 tree template_args = NULL_TREE;
2621 bool is_template_id = TREE_CODE (name) == TEMPLATE_ID_EXPR;
2622
2623 if (is_template_id)
2624 {
2625 template_args = TREE_OPERAND (name, 1);
2626 name = TREE_OPERAND (name, 0);
2627 }
2628 if (TREE_CODE (name) == OVERLOAD)
2629 name = DECL_NAME (get_first_fn (name));
2630 else if (TREE_CODE (name) == LOOKUP_EXPR)
2631 name = TREE_OPERAND (name, 0);
2632
2633 if (TREE_CODE (scope) == NAMESPACE_DECL)
2634 fn = lookup_namespace_name (scope, name);
62bfce90 2635 else if (!CLASS_TYPE_P (scope))
28570f7e
MM
2636 {
2637 error ("`%T' is not a class type", scope);
2638 return error_mark_node;
2639 }
3e14cd30
NS
2640 else
2641 {
2642 if (!TYPE_BEING_DEFINED (scope)
2643 && !COMPLETE_TYPE_P (complete_type (scope)))
2644 {
2645 error ("incomplete type '%T' cannot be used to name a scope",
2646 scope);
2647 return error_mark_node;
2648 }
2649
2650 if (BASELINK_P (name))
2651 fn = name;
2652 else
86ac0575 2653 fn = lookup_member (scope, name, /*protect=*/1, /*want_type=*/false);
3e14cd30
NS
2654 if (fn && current_class_type)
2655 fn = (adjust_result_of_qualified_name_lookup
2656 (fn, scope, current_class_type));
6e9554e1
JM
2657
2658 /* It might be the name of a function pointer member. */
2659 if (fn && TREE_CODE (fn) == FIELD_DECL)
d6b4ea85 2660 fn = finish_non_static_data_member (fn, scope);
3e14cd30
NS
2661 }
2662
2663 if (!fn)
2664 {
2665 error ("'%D' has no member named '%E'", scope, name);
2666 return error_mark_node;
2667 }
2668 if (is_template_id)
2669 {
2670 tree fns = fn;
2671
2672 if (BASELINK_P (fn))
2673 fns = BASELINK_FUNCTIONS (fns);
2674 fns = build_nt (TEMPLATE_ID_EXPR, fns, template_args);
2675 if (BASELINK_P (fn))
2676 BASELINK_FUNCTIONS (fn) = fns;
2677 else
2678 fn = fns;
2679 }
2680
2681 return fn;
2682}
2683
86e6f22f
JM
2684/* Do any initial processing on the arguments to a function call. */
2685
2686static tree
94be8403 2687resolve_args (tree args)
86e6f22f
JM
2688{
2689 tree t;
2690 for (t = args; t; t = TREE_CHAIN (t))
2691 {
648c2206
NS
2692 tree arg = TREE_VALUE (t);
2693
2694 if (arg == error_mark_node)
86e6f22f 2695 return error_mark_node;
648c2206 2696 else if (VOID_TYPE_P (TREE_TYPE (arg)))
86e6f22f 2697 {
8251199e 2698 error ("invalid use of void expression");
86e6f22f
JM
2699 return error_mark_node;
2700 }
648c2206
NS
2701 arg = convert_from_reference (arg);
2702 TREE_VALUE (t) = arg;
86e6f22f
JM
2703 }
2704 return args;
2705}
4ba126e4 2706
125e6594
MM
2707/* Perform overload resolution on FN, which is called with the ARGS.
2708
2709 Return the candidate function selected by overload resolution, or
2710 NULL if the event that overload resolution failed. In the case
2711 that overload resolution fails, *CANDIDATES will be the set of
2712 candidates considered, and ANY_VIABLE_P will be set to true or
2713 false to indicate whether or not any of the candidates were
2714 viable.
2715
2716 The ARGS should already have gone through RESOLVE_ARGS before this
2717 function is called. */
2718
2719static struct z_candidate *
2720perform_overload_resolution (tree fn,
2721 tree args,
2722 struct z_candidate **candidates,
2723 bool *any_viable_p)
c73964b2 2724{
125e6594 2725 struct z_candidate *cand;
386b8a85 2726 tree explicit_targs = NULL_TREE;
c32381b1 2727 int template_only = 0;
386b8a85 2728
125e6594
MM
2729 *candidates = NULL;
2730 *any_viable_p = true;
2731
4ba126e4
MM
2732 /* Check FN and ARGS. */
2733 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL
2734 || TREE_CODE (fn) == TEMPLATE_DECL
2735 || TREE_CODE (fn) == OVERLOAD
2736 || TREE_CODE (fn) == TEMPLATE_ID_EXPR,
2737 20020712);
2738 my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
2739 20020712);
2740
386b8a85
JM
2741 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2742 {
2743 explicit_targs = TREE_OPERAND (fn, 1);
2744 fn = TREE_OPERAND (fn, 0);
c32381b1 2745 template_only = 1;
386b8a85
JM
2746 }
2747
125e6594
MM
2748 /* Add the various candidate functions. */
2749 add_candidates (fn, args, explicit_targs, template_only,
2750 /*conversion_path=*/NULL_TREE,
2751 /*access_path=*/NULL_TREE,
2752 LOOKUP_NORMAL,
2753 candidates);
2754
436f8a4c
MM
2755 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2756 if (!*any_viable_p)
2757 return NULL;
c73964b2 2758
125e6594 2759 cand = tourney (*candidates);
125e6594
MM
2760 return cand;
2761}
86e6f22f 2762
125e6594
MM
2763/* Return an expression for a call to FN (a namespace-scope function,
2764 or a static member function) with the ARGS. */
2765
2766tree
2767build_new_function_call (tree fn, tree args)
2768{
2769 struct z_candidate *candidates, *cand;
2770 bool any_viable_p;
8f032717 2771
125e6594
MM
2772 args = resolve_args (args);
2773 if (args == error_mark_node)
2774 return error_mark_node;
a723baf1 2775
125e6594 2776 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
c73964b2 2777
125e6594
MM
2778 if (!cand)
2779 {
2780 if (!any_viable_p && candidates && ! candidates->next)
2781 return build_function_call (candidates->fn, args);
2782 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2783 fn = TREE_OPERAND (fn, 0);
2784 if (!any_viable_p)
2785 error ("no matching function for call to `%D(%A)'",
2786 DECL_NAME (OVL_CURRENT (fn)), args);
2787 else
2788 error ("call of overloaded `%D(%A)' is ambiguous",
436f8a4c 2789 DECL_NAME (OVL_CURRENT (fn)), args);
125e6594
MM
2790 if (candidates)
2791 print_z_candidates (candidates);
2792 return error_mark_node;
2793 }
c73964b2 2794
125e6594
MM
2795 return build_over_call (cand, LOOKUP_NORMAL);
2796}
c73964b2 2797
125e6594
MM
2798/* Build a call to a global operator new. FNNAME is the name of the
2799 operator (either "operator new" or "operator new[]") and ARGS are
2800 the arguments provided. *SIZE points to the total number of bytes
2801 required by the allocation, and is updated if that is changed here.
2802 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
34cd5ae7 2803 function determines that no cookie should be used, after all,
9bcb9aae 2804 *COOKIE_SIZE is set to NULL_TREE. */
c73964b2 2805
125e6594
MM
2806tree
2807build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2808{
2809 tree fns;
2810 struct z_candidate *candidates;
2811 struct z_candidate *cand;
2812 bool any_viable_p;
2813
2814 args = tree_cons (NULL_TREE, *size, args);
2815 args = resolve_args (args);
2816 if (args == error_mark_node)
2817 return args;
2818
2819 fns = lookup_function_nonclass (fnname, args);
2c73f9f5 2820
125e6594
MM
2821 /* Figure out what function is being called. */
2822 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2823
2824 /* If no suitable function could be found, issue an error message
2825 and give up. */
2826 if (!cand)
2827 {
2828 if (!any_viable_p)
2829 error ("no matching function for call to `%D(%A)'",
2830 DECL_NAME (OVL_CURRENT (fns)), args);
2831 else
8e854b76 2832 error ("call of overloaded `%D(%A)' is ambiguous",
436f8a4c 2833 DECL_NAME (OVL_CURRENT (fns)), args);
125e6594
MM
2834 if (candidates)
2835 print_z_candidates (candidates);
2836 return error_mark_node;
2837 }
2838
2839 /* If a cookie is required, add some extra space. Whether
2840 or not a cookie is required cannot be determined until
2841 after we know which function was called. */
2842 if (*cookie_size)
2843 {
2844 bool use_cookie = true;
2845 if (!abi_version_at_least (2))
2846 {
2847 tree placement = TREE_CHAIN (args);
2848 /* In G++ 3.2, the check was implemented incorrectly; it
2849 looked at the placement expression, rather than the
2850 type of the function. */
2851 if (placement && !TREE_CHAIN (placement)
2852 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2853 ptr_type_node))
2854 use_cookie = false;
2855 }
2856 else
2857 {
2858 tree arg_types;
2859
2860 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2861 /* Skip the size_t parameter. */
2862 arg_types = TREE_CHAIN (arg_types);
2863 /* Check the remaining parameters (if any). */
2864 if (arg_types
2865 && TREE_CHAIN (arg_types) == void_list_node
2866 && same_type_p (TREE_VALUE (arg_types),
2867 ptr_type_node))
2868 use_cookie = false;
2869 }
2870 /* If we need a cookie, adjust the number of bytes allocated. */
2871 if (use_cookie)
2872 {
2873 /* Update the total size. */
2874 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2875 /* Update the argument list to reflect the adjusted size. */
2876 TREE_VALUE (args) = *size;
2877 }
2878 else
2879 *cookie_size = NULL_TREE;
2880 }
2881
2882 /* Build the CALL_EXPR. */
2883 return build_over_call (cand, LOOKUP_NORMAL);
c73964b2
MS
2884}
2885
bd6dd845 2886static tree
94be8403 2887build_object_call (tree obj, tree args)
c73964b2
MS
2888{
2889 struct z_candidate *candidates = 0, *cand;
a703fb38 2890 tree fns, convs, mem_args = NULL_TREE;
c73964b2 2891 tree type = TREE_TYPE (obj);
436f8a4c 2892 bool any_viable_p;
c73964b2 2893
297dcfb3
MM
2894 if (TYPE_PTRMEMFUNC_P (type))
2895 {
2896 /* It's no good looking for an overloaded operator() on a
2897 pointer-to-member-function. */
33bd39a2 2898 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
297dcfb3
MM
2899 return error_mark_node;
2900 }
2901
596ea4e5 2902 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
734e8cc5
MM
2903 if (fns == error_mark_node)
2904 return error_mark_node;
c73964b2 2905
86e6f22f
JM
2906 args = resolve_args (args);
2907
2908 if (args == error_mark_node)
2909 return error_mark_node;
2910
c73964b2
MS
2911 if (fns)
2912 {
50ad9642 2913 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
e1b3e07d 2914 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
c73964b2 2915
50ad9642 2916 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
c73964b2 2917 {
2c73f9f5 2918 tree fn = OVL_CURRENT (fns);
786b5245 2919 if (TREE_CODE (fn) == TEMPLATE_DECL)
7993382e
MM
2920 add_template_candidate (&candidates, fn, base, NULL_TREE,
2921 mem_args, NULL_TREE,
2922 TYPE_BINFO (type),
2923 TYPE_BINFO (type),
2924 LOOKUP_NORMAL, DEDUCE_CALL);
786b5245 2925 else
7993382e
MM
2926 add_function_candidate
2927 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
4ba126e4 2928 TYPE_BINFO (type), LOOKUP_NORMAL);
c73964b2
MS
2929 }
2930 }
2931
2932 convs = lookup_conversions (type);
2933
2934 for (; convs; convs = TREE_CHAIN (convs))
2935 {
2c73f9f5
ML
2936 tree fns = TREE_VALUE (convs);
2937 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
c73964b2 2938
59e76fc6 2939 if ((TREE_CODE (totype) == POINTER_TYPE
477f6664
JM
2940 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2941 || (TREE_CODE (totype) == REFERENCE_TYPE
2942 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2943 || (TREE_CODE (totype) == REFERENCE_TYPE
2944 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
2945 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
d64db93f 2946 for (; fns; fns = OVL_NEXT (fns))
c73964b2 2947 {
d64db93f 2948 tree fn = OVL_CURRENT (fns);
786b5245 2949 if (TREE_CODE (fn) == TEMPLATE_DECL)
7993382e
MM
2950 add_template_conv_candidate
2951 (&candidates, fn, obj, args, totype,
2952 /*access_path=*/NULL_TREE,
2953 /*conversion_path=*/NULL_TREE);
786b5245 2954 else
7993382e
MM
2955 add_conv_candidate (&candidates, fn, obj, args,
2956 /*conversion_path=*/NULL_TREE,
2957 /*access_path=*/NULL_TREE);
c73964b2
MS
2958 }
2959 }
2960
436f8a4c
MM
2961 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2962 if (!any_viable_p)
c73964b2 2963 {
33bd39a2 2964 error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
c73964b2
MS
2965 print_z_candidates (candidates);
2966 return error_mark_node;
2967 }
2968
da20811c 2969 cand = tourney (candidates);
c73964b2
MS
2970 if (cand == 0)
2971 {
33bd39a2 2972 error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
c73964b2
MS
2973 print_z_candidates (candidates);
2974 return error_mark_node;
2975 }
2976
f0bcd168
MM
2977 /* Since cand->fn will be a type, not a function, for a conversion
2978 function, we must be careful not to unconditionally look at
2979 DECL_NAME here. */
2980 if (TREE_CODE (cand->fn) == FUNCTION_DECL
596ea4e5 2981 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
b80f8ef3 2982 return build_over_call (cand, LOOKUP_NORMAL);
c73964b2 2983
c3f08228
NS
2984 obj = convert_like_with_context
2985 (TREE_VEC_ELT (cand->convs, 0), obj, cand->fn, -1);
c73964b2
MS
2986
2987 /* FIXME */
2988 return build_function_call (obj, args);
2989}
2990
2991static void
94be8403
GDR
2992op_error (enum tree_code code, enum tree_code code2,
2993 tree arg1, tree arg2, tree arg3, const char *problem)
c73964b2 2994{
cdb71673 2995 const char *opname;
596ea4e5
AS
2996
2997 if (code == MODIFY_EXPR)
2998 opname = assignment_operator_name_info[code2].name;
2999 else
3000 opname = operator_name_info[code].name;
c73964b2
MS
3001
3002 switch (code)
3003 {
3004 case COND_EXPR:
84cc377e
GDR
3005 error ("%s for ternary 'operator?:' in '%E ? %E : %E'",
3006 problem, arg1, arg2, arg3);
c73964b2 3007 break;
84cc377e 3008
c73964b2
MS
3009 case POSTINCREMENT_EXPR:
3010 case POSTDECREMENT_EXPR:
84cc377e 3011 error ("%s for 'operator%s' in '%E%s'", problem, opname, arg1, opname);
c73964b2 3012 break;
84cc377e 3013
c73964b2 3014 case ARRAY_REF:
84cc377e 3015 error ("%s for 'operator[]' in '%E[%E]'", problem, arg1, arg2);
c73964b2 3016 break;
84cc377e 3017
c73964b2
MS
3018 default:
3019 if (arg2)
84cc377e
GDR
3020 error ("%s for 'operator%s' in '%E %s %E'",
3021 problem, opname, arg1, opname, arg2);
c73964b2 3022 else
84cc377e
GDR
3023 error ("%s for 'operator%s' in '%s%E'",
3024 problem, opname, opname, arg1);
3025 break;
c73964b2
MS
3026 }
3027}
3028
a7a64a77
MM
3029/* Return the implicit conversion sequence that could be used to
3030 convert E1 to E2 in [expr.cond]. */
3031
3032static tree
94be8403 3033conditional_conversion (tree e1, tree e2)
a7a64a77
MM
3034{
3035 tree t1 = non_reference (TREE_TYPE (e1));
3036 tree t2 = non_reference (TREE_TYPE (e2));
3037 tree conv;
9cefd2ca 3038 bool good_base;
a7a64a77
MM
3039
3040 /* [expr.cond]
3041
3042 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3043 implicitly converted (clause _conv_) to the type "reference to
3044 T2", subject to the constraint that in the conversion the
3045 reference must bind directly (_dcl.init.ref_) to E1. */
3046 if (real_lvalue_p (e2))
3047 {
3048 conv = implicit_conversion (build_reference_type (t2),
3049 t1,
3050 e1,
3051 LOOKUP_NO_TEMP_BIND);
3052 if (conv)
3053 return conv;
3054 }
3055
3056 /* [expr.cond]
3057
3058 If E1 and E2 have class type, and the underlying class types are
3059 the same or one is a base class of the other: E1 can be converted
3060 to match E2 if the class of T2 is the same type as, or a base
3061 class of, the class of T1, and the cv-qualification of T2 is the
3062 same cv-qualification as, or a greater cv-qualification than, the
3063 cv-qualification of T1. If the conversion is applied, E1 is
3064 changed to an rvalue of type T2 that still refers to the original
5f7262e6
JM
3065 source class object (or the appropriate subobject thereof).
3066
3067 FIXME we can't express an rvalue that refers to the original object;
3068 we have to create a new one. */
a7a64a77 3069 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
9cefd2ca 3070 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
a7a64a77 3071 {
9cefd2ca 3072 if (good_base && at_least_as_qualified_p (t2, t1))
a7a64a77
MM
3073 {
3074 conv = build1 (IDENTITY_CONV, t1, e1);
4f0aa416
MM
3075 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3076 TYPE_MAIN_VARIANT (t2)))
5f7262e6
JM
3077 {
3078 conv = build_conv (BASE_CONV, t2, conv);
3079 NEED_TEMPORARY_P (conv) = 1;
3080 }
3081 else
3082 conv = build_conv (RVALUE_CONV, t2, conv);
a7a64a77
MM
3083 return conv;
3084 }
3085 else
3086 return NULL_TREE;
3087 }
9cefd2ca
JM
3088 else
3089 /* [expr.cond]
a7a64a77 3090
9cefd2ca
JM
3091 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3092 converted to the type that expression E2 would have if E2 were
3093 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3094 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
a7a64a77
MM
3095}
3096
3097/* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4ba126e4 3098 arguments to the conditional expression. */
a7a64a77
MM
3099
3100tree
94be8403 3101build_conditional_expr (tree arg1, tree arg2, tree arg3)
a7a64a77
MM
3102{
3103 tree arg2_type;
3104 tree arg3_type;
3105 tree result;
3106 tree result_type = NULL_TREE;
94be8403 3107 bool lvalue_p = true;
a7a64a77
MM
3108 struct z_candidate *candidates = 0;
3109 struct z_candidate *cand;
3110
3111 /* As a G++ extension, the second argument to the conditional can be
3112 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
09dd27d4
MM
3113 c'.) If the second operand is omitted, make sure it is
3114 calculated only once. */
a7a64a77
MM
3115 if (!arg2)
3116 {
3117 if (pedantic)
cb9a3ff8 3118 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
4e8dca1c
JM
3119
3120 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3121 if (real_lvalue_p (arg1))
3122 arg2 = arg1 = stabilize_reference (arg1);
3123 else
3124 arg2 = arg1 = save_expr (arg1);
a7a64a77
MM
3125 }
3126
07c88314
MM
3127 /* [expr.cond]
3128
3129 The first expr ession is implicitly converted to bool (clause
3130 _conv_). */
3131 arg1 = cp_convert (boolean_type_node, arg1);
3132
a7a64a77
MM
3133 /* If something has already gone wrong, just pass that fact up the
3134 tree. */
3135 if (arg1 == error_mark_node
3136 || arg2 == error_mark_node
3137 || arg3 == error_mark_node
3138 || TREE_TYPE (arg1) == error_mark_node
3139 || TREE_TYPE (arg2) == error_mark_node
3140 || TREE_TYPE (arg3) == error_mark_node)
3141 return error_mark_node;
3142
a7a64a77
MM
3143 /* [expr.cond]
3144
3145 If either the second or the third operand has type (possibly
3146 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3147 array-to-pointer (_conv.array_), and function-to-pointer
3148 (_conv.func_) standard conversions are performed on the second
3149 and third operands. */
3150 arg2_type = TREE_TYPE (arg2);
3151 arg3_type = TREE_TYPE (arg3);
b72801e2 3152 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
a7a64a77 3153 {
a7a64a77
MM
3154 /* Do the conversions. We don't these for `void' type arguments
3155 since it can't have any effect and since decay_conversion
3156 does not handle that case gracefully. */
b72801e2 3157 if (!VOID_TYPE_P (arg2_type))
a7a64a77 3158 arg2 = decay_conversion (arg2);
b72801e2 3159 if (!VOID_TYPE_P (arg3_type))
a7a64a77
MM
3160 arg3 = decay_conversion (arg3);
3161 arg2_type = TREE_TYPE (arg2);
3162 arg3_type = TREE_TYPE (arg3);
3163
a7a64a77
MM
3164 /* [expr.cond]
3165
3166 One of the following shall hold:
3167
3168 --The second or the third operand (but not both) is a
3169 throw-expression (_except.throw_); the result is of the
3170 type of the other and is an rvalue.
3171
3172 --Both the second and the third operands have type void; the
00a17e31 3173 result is of type void and is an rvalue. */
a7a64a77
MM
3174 if ((TREE_CODE (arg2) == THROW_EXPR)
3175 ^ (TREE_CODE (arg3) == THROW_EXPR))
3176 result_type = ((TREE_CODE (arg2) == THROW_EXPR)
df39af7d 3177 ? arg3_type : arg2_type);
b72801e2 3178 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
a7a64a77
MM
3179 result_type = void_type_node;
3180 else
3181 {
33bd39a2 3182 error ("`%E' has type `void' and is not a throw-expression",
b72801e2 3183 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
a7a64a77
MM
3184 return error_mark_node;
3185 }
3186
94be8403 3187 lvalue_p = false;
a7a64a77
MM
3188 goto valid_operands;
3189 }
3190 /* [expr.cond]
3191
3192 Otherwise, if the second and third operand have different types,
3193 and either has (possibly cv-qualified) class type, an attempt is
3194 made to convert each of those operands to the type of the other. */
3195 else if (!same_type_p (arg2_type, arg3_type)
3196 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3197 {
3198 tree conv2 = conditional_conversion (arg2, arg3);
3199 tree conv3 = conditional_conversion (arg3, arg2);
3200
3201 /* [expr.cond]
3202
3203 If both can be converted, or one can be converted but the
3204 conversion is ambiguous, the program is ill-formed. If
3205 neither can be converted, the operands are left unchanged and
3206 further checking is performed as described below. If exactly
3207 one conversion is possible, that conversion is applied to the
3208 chosen operand and the converted operand is used in place of
3209 the original operand for the remainder of this section. */
3210 if ((conv2 && !ICS_BAD_FLAG (conv2)
3211 && conv3 && !ICS_BAD_FLAG (conv3))
3212 || (conv2 && TREE_CODE (conv2) == AMBIG_CONV)
3213 || (conv3 && TREE_CODE (conv3) == AMBIG_CONV))
3214 {
33bd39a2 3215 error ("operands to ?: have different types");
a7a64a77
MM
3216 return error_mark_node;
3217 }
3218 else if (conv2 && !ICS_BAD_FLAG (conv2))
3219 {
3220 arg2 = convert_like (conv2, arg2);
442aa4ec 3221 arg2 = convert_from_reference (arg2);
4f0aa416 3222 if (!same_type_p (TREE_TYPE (arg2), arg3_type))
5f7262e6 3223 abort ();
a7a64a77
MM
3224 arg2_type = TREE_TYPE (arg2);
3225 }
3226 else if (conv3 && !ICS_BAD_FLAG (conv3))
3227 {
3228 arg3 = convert_like (conv3, arg3);
442aa4ec 3229 arg3 = convert_from_reference (arg3);
4f0aa416 3230 if (!same_type_p (TREE_TYPE (arg3), arg2_type))
5f7262e6 3231 abort ();
a7a64a77
MM
3232 arg3_type = TREE_TYPE (arg3);
3233 }
3234 }
3235
3236 /* [expr.cond]
3237
3238 If the second and third operands are lvalues and have the same
3239 type, the result is of that type and is an lvalue. */
a7a64a77
MM
3240 if (real_lvalue_p (arg2) && real_lvalue_p (arg3) &&
3241 same_type_p (arg2_type, arg3_type))
3242 {
3243 result_type = arg2_type;
3244 goto valid_operands;
3245 }
3246
3247 /* [expr.cond]
3248
3249 Otherwise, the result is an rvalue. If the second and third
3250 operand do not have the same type, and either has (possibly
3251 cv-qualified) class type, overload resolution is used to
3252 determine the conversions (if any) to be applied to the operands
3253 (_over.match.oper_, _over.built_). */
94be8403 3254 lvalue_p = false;
a7a64a77
MM
3255 if (!same_type_p (arg2_type, arg3_type)
3256 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3257 {
3258 tree args[3];
3259 tree conv;
436f8a4c 3260 bool any_viable_p;
a7a64a77
MM
3261
3262 /* Rearrange the arguments so that add_builtin_candidate only has
3263 to know about two args. In build_builtin_candidates, the
3264 arguments are unscrambled. */
3265 args[0] = arg2;
3266 args[1] = arg3;
3267 args[2] = arg1;
7993382e
MM
3268 add_builtin_candidates (&candidates,
3269 COND_EXPR,
3270 NOP_EXPR,
3271 ansi_opname (COND_EXPR),
3272 args,
3273 LOOKUP_NORMAL);
a7a64a77
MM
3274
3275 /* [expr.cond]
3276
3277 If the overload resolution fails, the program is
3278 ill-formed. */
436f8a4c
MM
3279 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3280 if (!any_viable_p)
a7a64a77
MM
3281 {
3282 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3283 print_z_candidates (candidates);
3284 return error_mark_node;
3285 }
a7a64a77
MM
3286 cand = tourney (candidates);
3287 if (!cand)
3288 {
3289 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3290 print_z_candidates (candidates);
3291 return error_mark_node;
3292 }
3293
3294 /* [expr.cond]
3295
3296 Otherwise, the conversions thus determined are applied, and
3297 the converted operands are used in place of the original
3298 operands for the remainder of this section. */
3299 conv = TREE_VEC_ELT (cand->convs, 0);
3300 arg1 = convert_like (conv, arg1);
3301 conv = TREE_VEC_ELT (cand->convs, 1);
3302 arg2 = convert_like (conv, arg2);
3303 conv = TREE_VEC_ELT (cand->convs, 2);
3304 arg3 = convert_like (conv, arg3);
3305 }
3306
3307 /* [expr.cond]
3308
3309 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3310 and function-to-pointer (_conv.func_) standard conversions are
50fd6343
JM
3311 performed on the second and third operands.
3312
3313 We need to force the lvalue-to-rvalue conversion here for class types,
3314 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3315 that isn't wrapped with a TARGET_EXPR plays havoc with exception
db5ae31b
JM
3316 regions.
3317
3318 We use ocp_convert rather than build_user_type_conversion because the
3319 latter returns NULL_TREE on failure, while the former gives an error. */
50fd6343 3320
f7b9026e 3321 arg2 = force_rvalue (arg2);
a7a64a77 3322 arg2_type = TREE_TYPE (arg2);
50fd6343 3323
f7b9026e 3324 arg3 = force_rvalue (arg3);
a7a64a77
MM
3325 arg3_type = TREE_TYPE (arg3);
3326
40260429
NS
3327 if (arg2 == error_mark_node || arg3 == error_mark_node)
3328 return error_mark_node;
3329
a7a64a77
MM
3330 /* [expr.cond]
3331
3332 After those conversions, one of the following shall hold:
3333
3334 --The second and third operands have the same type; the result is of
3335 that type. */
3336 if (same_type_p (arg2_type, arg3_type))
3337 result_type = arg2_type;
3338 /* [expr.cond]
3339
3340 --The second and third operands have arithmetic or enumeration
3341 type; the usual arithmetic conversions are performed to bring
3342 them to a common type, and the result is of that type. */
3343 else if ((ARITHMETIC_TYPE_P (arg2_type)
3344 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3345 && (ARITHMETIC_TYPE_P (arg3_type)
3346 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3347 {
3348 /* In this case, there is always a common type. */
3349 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3350 arg3_type);
1b4d752a
NS
3351
3352 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3353 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
33bd39a2 3354 warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
1b4d752a
NS
3355 arg2_type, arg3_type);
3356 else if (extra_warnings
3357 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3358 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3359 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3360 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
33bd39a2 3361 warning ("enumeral and non-enumeral type in conditional expression");
1b4d752a 3362
4143af33
MM
3363 arg2 = perform_implicit_conversion (result_type, arg2);
3364 arg3 = perform_implicit_conversion (result_type, arg3);
a7a64a77
MM
3365 }
3366 /* [expr.cond]
3367
3368 --The second and third operands have pointer type, or one has
3369 pointer type and the other is a null pointer constant; pointer
3370 conversions (_conv.ptr_) and qualification conversions
3371 (_conv.qual_) are performed to bring them to their composite
3372 pointer type (_expr.rel_). The result is of the composite
3373 pointer type.
3374
3375 --The second and third operands have pointer to member type, or
3376 one has pointer to member type and the other is a null pointer
3377 constant; pointer to member conversions (_conv.mem_) and
3378 qualification conversions (_conv.qual_) are performed to bring
3379 them to a common type, whose cv-qualification shall match the
3380 cv-qualification of either the second or the third operand.
00a17e31 3381 The result is of the common type. */
a7a64a77
MM
3382 else if ((null_ptr_cst_p (arg2)
3383 && (TYPE_PTR_P (arg3_type) || TYPE_PTRMEM_P (arg3_type)
3384 || TYPE_PTRMEMFUNC_P (arg3_type)))
3385 || (null_ptr_cst_p (arg3)
3386 && (TYPE_PTR_P (arg2_type) || TYPE_PTRMEM_P (arg2_type)
3387 || TYPE_PTRMEMFUNC_P (arg2_type)))
3388 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3389 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3390 || (TYPE_PTRMEMFUNC_P (arg2_type)
3391 && TYPE_PTRMEMFUNC_P (arg3_type)))
3392 {
3393 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3394 arg3, "conditional expression");
4143af33
MM
3395 arg2 = perform_implicit_conversion (result_type, arg2);
3396 arg3 = perform_implicit_conversion (result_type, arg3);
a7a64a77
MM
3397 }
3398
3399 if (!result_type)
3400 {
33bd39a2 3401 error ("operands to ?: have different types");
a7a64a77
MM
3402 return error_mark_node;
3403 }
3404
3405 valid_operands:
3406 result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
a65fd2d7
JM
3407 /* We can't use result_type below, as fold might have returned a
3408 throw_expr. */
3409
a7a64a77 3410 /* Expand both sides into the same slot, hopefully the target of the
50fd6343
JM
3411 ?: expression. We used to check for TARGET_EXPRs here, but now we
3412 sometimes wrap them in NOP_EXPRs so the test would fail. */
a65fd2d7
JM
3413 if (!lvalue_p && IS_AGGR_TYPE (TREE_TYPE (result)))
3414 result = get_target_expr (result);
a7a64a77
MM
3415
3416 /* If this expression is an rvalue, but might be mistaken for an
3417 lvalue, we must add a NON_LVALUE_EXPR. */
3418 if (!lvalue_p && real_lvalue_p (result))
a65fd2d7 3419 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
a7a64a77
MM
3420
3421 return result;
3422}
3423
14d22dd6
MM
3424/* OPERAND is an operand to an expression. Perform necessary steps
3425 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3426 returned. */
3427
3428static tree
3429prep_operand (tree operand)
3430{
3431 if (operand)
3432 {
14d22dd6
MM
3433 operand = convert_from_reference (operand);
3434 if (CLASS_TYPE_P (TREE_TYPE (operand))
3435 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3436 /* Make sure the template type is instantiated now. */
3437 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3438 }
3439
3440 return operand;
3441}
3442
b80f8ef3
MM
3443/* Add each of the viable functions in FNS (a FUNCTION_DECL or
3444 OVERLOAD) to the CANDIDATES, returning an updated list of
3445 CANDIDATES. The ARGS are the arguments provided to the call,
125e6594
MM
3446 without any implicit object parameter. The EXPLICIT_TARGS are
3447 explicit template arguments provided. TEMPLATE_ONLY is true if
3448 only template fucntions should be considered. CONVERSION_PATH,
b80f8ef3
MM
3449 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3450
7993382e 3451static void
125e6594
MM
3452add_candidates (tree fns, tree args,
3453 tree explicit_targs, bool template_only,
b80f8ef3
MM
3454 tree conversion_path, tree access_path,
3455 int flags,
7993382e 3456 struct z_candidate **candidates)
b80f8ef3
MM
3457{
3458 tree ctype;
3459 tree non_static_args;
3460
3461 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3462 /* Delay creating the implicit this parameter until it is needed. */
3463 non_static_args = NULL_TREE;
3464
3465 while (fns)
3466 {
3467 tree fn;
3468 tree fn_args;
3469
3470 fn = OVL_CURRENT (fns);
3471 /* Figure out which set of arguments to use. */
125e6594 3472 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
b80f8ef3
MM
3473 {
3474 /* If this function is a non-static member, prepend the implicit
3475 object parameter. */
3476 if (!non_static_args)
3477 non_static_args = tree_cons (NULL_TREE,
3478 build_this (TREE_VALUE (args)),
3479 TREE_CHAIN (args));
3480 fn_args = non_static_args;
3481 }
3482 else
3483 /* Otherwise, just use the list of arguments provided. */
3484 fn_args = args;
3485
3486 if (TREE_CODE (fn) == TEMPLATE_DECL)
7993382e
MM
3487 add_template_candidate (candidates,
3488 fn,
3489 ctype,
125e6594 3490 explicit_targs,
7993382e
MM
3491 fn_args,
3492 NULL_TREE,
3493 access_path,
3494 conversion_path,
3495 flags,
3496 DEDUCE_CALL);
125e6594 3497 else if (!template_only)
7993382e
MM
3498 add_function_candidate (candidates,
3499 fn,
3500 ctype,
3501 fn_args,
3502 access_path,
3503 conversion_path,
3504 flags);
b80f8ef3
MM
3505 fns = OVL_NEXT (fns);
3506 }
b80f8ef3
MM
3507}
3508
c73964b2 3509tree
94be8403 3510build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3)
c73964b2
MS
3511{
3512 struct z_candidate *candidates = 0, *cand;
b80f8ef3
MM
3513 tree arglist, fnname;
3514 tree args[3];
c73964b2 3515 enum tree_code code2 = NOP_EXPR;
7e3af374 3516 tree conv;
436f8a4c
MM
3517 bool strict_p;
3518 bool any_viable_p;
c73964b2 3519
a723baf1
MM
3520 if (error_operand_p (arg1)
3521 || error_operand_p (arg2)
3522 || error_operand_p (arg3))
c73964b2
MS
3523 return error_mark_node;
3524
3525 if (code == MODIFY_EXPR)
3526 {
3527 code2 = TREE_CODE (arg3);
3528 arg3 = NULL_TREE;
596ea4e5 3529 fnname = ansi_assopname (code2);
c73964b2
MS
3530 }
3531 else
596ea4e5 3532 fnname = ansi_opname (code);
c73964b2 3533
14d22dd6 3534 arg1 = prep_operand (arg1);
648c2206 3535
c73964b2
MS
3536 switch (code)
3537 {
3538 case NEW_EXPR:
3539 case VEC_NEW_EXPR:
c73964b2
MS
3540 case VEC_DELETE_EXPR:
3541 case DELETE_EXPR:
00a17e31 3542 /* Use build_op_new_call and build_op_delete_call instead. */
a98facb0 3543 abort ();
c73964b2
MS
3544
3545 case CALL_EXPR:
3546 return build_object_call (arg1, arg2);
7f85441b
KG
3547
3548 default:
3549 break;
c73964b2
MS
3550 }
3551
14d22dd6
MM
3552 arg2 = prep_operand (arg2);
3553 arg3 = prep_operand (arg3);
4b48a93e 3554
5156628f
MS
3555 if (code == COND_EXPR)
3556 {
beb53fb8
JM
3557 if (arg2 == NULL_TREE
3558 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
5156628f
MS
3559 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3560 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3561 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3562 goto builtin;
3563 }
3564 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3565 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
c73964b2
MS
3566 goto builtin;
3567
3568 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3569 arg2 = integer_zero_node;
3570
477558bf
NS
3571 arglist = NULL_TREE;
3572 if (arg3)
3573 arglist = tree_cons (NULL_TREE, arg3, arglist);
3574 if (arg2)
3575 arglist = tree_cons (NULL_TREE, arg2, arglist);
3576 arglist = tree_cons (NULL_TREE, arg1, arglist);
c73964b2 3577
b80f8ef3
MM
3578 /* Add namespace-scope operators to the list of functions to
3579 consider. */
7993382e 3580 add_candidates (lookup_function_nonclass (fnname, arglist),
125e6594 3581 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
7993382e 3582 flags, &candidates);
b80f8ef3
MM
3583 /* Add class-member operators to the candidate set. */
3584 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
c73964b2 3585 {
b80f8ef3 3586 tree fns;
c73964b2 3587
734e8cc5
MM
3588 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3589 if (fns == error_mark_node)
3590 return fns;
b80f8ef3 3591 if (fns)
7993382e 3592 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
125e6594 3593 NULL_TREE, false,
7993382e
MM
3594 BASELINK_BINFO (fns),
3595 TYPE_BINFO (TREE_TYPE (arg1)),
3596 flags, &candidates);
734e8cc5 3597 }
c73964b2 3598
b80f8ef3
MM
3599 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3600 to know about two args; a builtin candidate will always have a first
3601 parameter of type bool. We'll handle that in
3602 build_builtin_candidate. */
3603 if (code == COND_EXPR)
c73964b2 3604 {
b80f8ef3
MM
3605 args[0] = arg2;
3606 args[1] = arg3;
3607 args[2] = arg1;
3608 }
3609 else
3610 {
3611 args[0] = arg1;
3612 args[1] = arg2;
3613 args[2] = NULL_TREE;
c73964b2
MS
3614 }
3615
7993382e 3616 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
c73964b2 3617
ecc42c14
AO
3618 switch (code)
3619 {
3620 case COMPOUND_EXPR:
3621 case ADDR_EXPR:
3622 /* For these, the built-in candidates set is empty
3623 [over.match.oper]/3. We don't want non-strict matches
3624 because exact matches are always possible with built-in
3625 operators. The built-in candidate set for COMPONENT_REF
3626 would be empty too, but since there are no such built-in
3627 operators, we accept non-strict matches for them. */
436f8a4c 3628 strict_p = true;
ecc42c14
AO
3629 break;
3630
3631 default:
436f8a4c 3632 strict_p = pedantic;
ecc42c14
AO
3633 break;
3634 }
3635
436f8a4c
MM
3636 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3637 if (!any_viable_p)
c73964b2
MS
3638 {
3639 switch (code)
3640 {
3641 case POSTINCREMENT_EXPR:
3642 case POSTDECREMENT_EXPR:
3643 /* Look for an `operator++ (int)'. If they didn't have
3644 one, then we fall back to the old way of doing things. */
3645 if (flags & LOOKUP_COMPLAIN)
33bd39a2 3646 pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
596ea4e5
AS
3647 fnname,
3648 operator_name_info[code].name);
c73964b2
MS
3649 if (code == POSTINCREMENT_EXPR)
3650 code = PREINCREMENT_EXPR;
3651 else
3652 code = PREDECREMENT_EXPR;
3653 return build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE);
3654
3655 /* The caller will deal with these. */
3656 case ADDR_EXPR:
3657 case COMPOUND_EXPR:
3658 case COMPONENT_REF:
3659 return NULL_TREE;
7f85441b
KG
3660
3661 default:
3662 break;
c73964b2
MS
3663 }
3664 if (flags & LOOKUP_COMPLAIN)
3665 {
3666 op_error (code, code2, arg1, arg2, arg3, "no match");
3667 print_z_candidates (candidates);
3668 }
3669 return error_mark_node;
3670 }
c73964b2 3671
436f8a4c 3672 cand = tourney (candidates);
c73964b2
MS
3673 if (cand == 0)
3674 {
3675 if (flags & LOOKUP_COMPLAIN)
3676 {
3677 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3678 print_z_candidates (candidates);
3679 }
3680 return error_mark_node;
3681 }
3682
3683 if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3684 {
c73964b2 3685 if (warn_synth
596ea4e5 3686 && fnname == ansi_assopname (NOP_EXPR)
c73964b2
MS
3687 && DECL_ARTIFICIAL (cand->fn)
3688 && candidates->next
3689 && ! candidates->next->next)
3690 {
33bd39a2 3691 warning ("using synthesized `%#D' for copy assignment",
c73964b2 3692 cand->fn);
8251199e 3693 cp_warning_at (" where cfront would use `%#D'",
c73964b2
MS
3694 cand == candidates
3695 ? candidates->next->fn
3696 : candidates->fn);
3697 }
3698
b80f8ef3 3699 return build_over_call (cand, LOOKUP_NORMAL);
c73964b2
MS
3700 }
3701
d11ad92e
MS
3702 /* Check for comparison of different enum types. */
3703 switch (code)
3704 {
3705 case GT_EXPR:
3706 case LT_EXPR:
3707 case GE_EXPR:
3708 case LE_EXPR:
3709 case EQ_EXPR:
3710 case NE_EXPR:
84663f74 3711 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
d11ad92e
MS
3712 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3713 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3714 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3715 {
33bd39a2 3716 warning ("comparison between `%#T' and `%#T'",
d11ad92e
MS
3717 TREE_TYPE (arg1), TREE_TYPE (arg2));
3718 }
7f85441b
KG
3719 break;
3720 default:
3721 break;
d11ad92e
MS
3722 }
3723
7e3af374
JM
3724 /* We need to strip any leading REF_BIND so that bitfields don't cause
3725 errors. This should not remove any important conversions, because
3726 builtins don't apply to class objects directly. */
3727 conv = TREE_VEC_ELT (cand->convs, 0);
3728 if (TREE_CODE (conv) == REF_BIND)
3729 conv = TREE_OPERAND (conv, 0);
3730 arg1 = convert_like (conv, arg1);
c73964b2 3731 if (arg2)
8be0a930
NS
3732 {
3733 conv = TREE_VEC_ELT (cand->convs, 1);
3734 if (TREE_CODE (conv) == REF_BIND)
3735 conv = TREE_OPERAND (conv, 0);
3736 arg2 = convert_like (conv, arg2);
3737 }
c73964b2 3738 if (arg3)
8be0a930
NS
3739 {
3740 conv = TREE_VEC_ELT (cand->convs, 2);
3741 if (TREE_CODE (conv) == REF_BIND)
3742 conv = TREE_OPERAND (conv, 0);
3743 arg3 = convert_like (conv, arg3);
3744 }
c73964b2
MS
3745
3746builtin:
3747 switch (code)
3748 {
3749 case MODIFY_EXPR:
3750 return build_modify_expr (arg1, code2, arg2);
3751
3752 case INDIRECT_REF:
3753 return build_indirect_ref (arg1, "unary *");
3754
3755 case PLUS_EXPR:
3756 case MINUS_EXPR:
3757 case MULT_EXPR:
3758 case TRUNC_DIV_EXPR:
3759 case GT_EXPR:
3760 case LT_EXPR:
3761 case GE_EXPR:
3762 case LE_EXPR:
3763 case EQ_EXPR:
3764 case NE_EXPR:
3765 case MAX_EXPR:
3766 case MIN_EXPR:
3767 case LSHIFT_EXPR:
3768 case RSHIFT_EXPR:
3769 case TRUNC_MOD_EXPR:
3770 case BIT_AND_EXPR:
3771 case BIT_IOR_EXPR:
3772 case BIT_XOR_EXPR:
3773 case TRUTH_ANDIF_EXPR:
3774 case TRUTH_ORIF_EXPR:
ab76ca54 3775 return cp_build_binary_op (code, arg1, arg2);
c73964b2
MS
3776
3777 case CONVERT_EXPR:
3778 case NEGATE_EXPR:
3779 case BIT_NOT_EXPR:
3780 case TRUTH_NOT_EXPR:
3781 case PREINCREMENT_EXPR:
3782 case POSTINCREMENT_EXPR:
3783 case PREDECREMENT_EXPR:
3784 case POSTDECREMENT_EXPR:
37c46b43
MS
3785 case REALPART_EXPR:
3786 case IMAGPART_EXPR:
c73964b2
MS
3787 return build_unary_op (code, arg1, candidates != 0);
3788
3789 case ARRAY_REF:
3790 return build_array_ref (arg1, arg2);
3791
3792 case COND_EXPR:
3793 return build_conditional_expr (arg1, arg2, arg3);
3794
3795 case MEMBER_REF:
3796 return build_m_component_ref
3e411c3f 3797 (build_indirect_ref (arg1, NULL), arg2);
c73964b2
MS
3798
3799 /* The caller will deal with these. */
3800 case ADDR_EXPR:
3801 case COMPONENT_REF:
3802 case COMPOUND_EXPR:
3803 return NULL_TREE;
3804
3805 default:
a98facb0 3806 abort ();
a703fb38 3807 return NULL_TREE;
c73964b2
MS
3808 }
3809}
3810
da4768fe
JM
3811/* Build a call to operator delete. This has to be handled very specially,
3812 because the restrictions on what signatures match are different from all
3813 other call instances. For a normal delete, only a delete taking (void *)
3814 or (void *, size_t) is accepted. For a placement delete, only an exact
3815 match with the placement new is accepted.
3816
3817 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
0ac7f923 3818 ADDR is the pointer to be deleted.
da4768fe 3819 SIZE is the size of the memory block to be deleted.
519ebd1e 3820 FLAGS are the usual overloading flags.
3f41ffd8 3821 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
da4768fe
JM
3822
3823tree
94be8403
GDR
3824build_op_delete_call (enum tree_code code, tree addr, tree size,
3825 int flags, tree placement)
da4768fe 3826{
ae0ed63a 3827 tree fn = NULL_TREE;
8f4b394d 3828 tree fns, fnname, argtypes, args, type;
52682a1b 3829 int pass;
da4768fe
JM
3830
3831 if (addr == error_mark_node)
3832 return error_mark_node;
3833
8d4ce389 3834 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
c3e899c1 3835
596ea4e5 3836 fnname = ansi_opname (code);
da4768fe
JM
3837
3838 if (IS_AGGR_TYPE (type) && ! (flags & LOOKUP_GLOBAL))
734e8cc5
MM
3839 /* In [class.free]
3840
3841 If the result of the lookup is ambiguous or inaccessible, or if
3842 the lookup selects a placement deallocation function, the
3843 program is ill-formed.
3844
3845 Therefore, we ask lookup_fnfields to complain ambout ambiguity. */
3846 {
3847 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3848 if (fns == error_mark_node)
3849 return error_mark_node;
3850 }
da4768fe
JM
3851 else
3852 fns = NULL_TREE;
3853
519ebd1e 3854 if (fns == NULL_TREE)
da4768fe
JM
3855 fns = lookup_name_nonclass (fnname);
3856
da4768fe
JM
3857 if (placement)
3858 {
cd4e8331
MM
3859 tree alloc_fn;
3860 tree call_expr;
3861
00a17e31 3862 /* Find the allocation function that is being called. */
cd4e8331
MM
3863 call_expr = placement;
3864 /* Sometimes we have a COMPOUND_EXPR, rather than a simple
00a17e31 3865 CALL_EXPR. */
cd4e8331
MM
3866 while (TREE_CODE (call_expr) == COMPOUND_EXPR)
3867 call_expr = TREE_OPERAND (call_expr, 1);
519ebd1e 3868 /* Extract the function. */
cd4e8331
MM
3869 alloc_fn = get_callee_fndecl (call_expr);
3870 my_friendly_assert (alloc_fn != NULL_TREE, 20020327);
519ebd1e 3871 /* Then the second parm type. */
cd4e8331 3872 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
519ebd1e 3873 /* Also the second argument. */
cd4e8331 3874 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
da4768fe
JM
3875 }
3876 else
3877 {
3878 /* First try it without the size argument. */
3879 argtypes = void_list_node;
3880 args = NULL_TREE;
3881 }
3882
da4768fe 3883 /* Strip const and volatile from addr. */
c3e899c1 3884 addr = cp_convert (ptr_type_node, addr);
da4768fe 3885
52682a1b 3886 /* We make two tries at finding a matching `operator delete'. On
8d4ce389 3887 the first pass, we look for a one-operator (or placement)
52682a1b
MM
3888 operator delete. If we're not doing placement delete, then on
3889 the second pass we look for a two-argument delete. */
3890 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
da4768fe 3891 {
3f41ffd8
MM
3892 /* Go through the `operator delete' functions looking for one
3893 with a matching type. */
da15dae6 3894 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
3f41ffd8
MM
3895 fn;
3896 fn = OVL_NEXT (fn))
52682a1b 3897 {
3f41ffd8
MM
3898 tree t;
3899
8f4b394d
MM
3900 /* The first argument must be "void *". */
3901 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
3902 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
3903 continue;
3904 t = TREE_CHAIN (t);
3905 /* On the first pass, check the rest of the arguments. */
3906 if (pass == 0)
3907 {
3908 while (argtypes && t)
3909 {
3910 if (!same_type_p (TREE_VALUE (argtypes),
3911 TREE_VALUE (t)))
3912 break;
3913 argtypes = TREE_CHAIN (argtypes);
3914 t = TREE_CHAIN (t);
3915 }
3916 if (!argtypes && !t)
3917 break;
3918 }
3919 /* On the second pass, the second argument must be
3920 "size_t". */
3921 else if (pass == 1
3922 && same_type_p (TREE_VALUE (t), sizetype)
3923 && TREE_CHAIN (t) == void_list_node)
3f41ffd8 3924 break;
52682a1b 3925 }
3f41ffd8
MM
3926
3927 /* If we found a match, we're done. */
3928 if (fn)
3929 break;
3930 }
3931
3932 /* If we have a matching function, call it. */
3933 if (fn)
3934 {
3935 /* Make sure we have the actual function, and not an
3936 OVERLOAD. */
3937 fn = OVL_CURRENT (fn);
3938
3939 /* If the FN is a member function, make sure that it is
3940 accessible. */
3941 if (DECL_CLASS_SCOPE_P (fn))
6df5158a 3942 perform_or_defer_access_check (TYPE_BINFO (type), fn);
3f41ffd8
MM
3943
3944 if (pass == 0)
3945 args = tree_cons (NULL_TREE, addr, args);
3946 else
3947 args = tree_cons (NULL_TREE, addr,
3948 build_tree_list (NULL_TREE, size));
3949
3950 return build_function_call (fn, args);
519ebd1e
JM
3951 }
3952
52682a1b
MM
3953 /* If we are doing placement delete we do nothing if we don't find a
3954 matching op delete. */
3955 if (placement)
519ebd1e 3956 return NULL_TREE;
da4768fe 3957
8d4ce389
NS
3958 error ("no suitable `operator %s' for `%T'",
3959 operator_name_info[(int)code].name, type);
da4768fe
JM
3960 return error_mark_node;
3961}
3962
38afd588 3963/* If the current scope isn't allowed to access DECL along
d6479fe7
MM
3964 BASETYPE_PATH, give an error. The most derived class in
3965 BASETYPE_PATH is the one used to qualify DECL. */
da4768fe 3966
94be8403
GDR
3967bool
3968enforce_access (tree basetype_path, tree decl)
c73964b2 3969{
6df5158a
NS
3970 my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624);
3971
94be8403 3972 if (!accessible_p (basetype_path, decl))
c73964b2 3973 {
d6479fe7
MM
3974 if (TREE_PRIVATE (decl))
3975 cp_error_at ("`%+#D' is private", decl);
3976 else if (TREE_PROTECTED (decl))
3977 cp_error_at ("`%+#D' is protected", decl);
3978 else
3979 cp_error_at ("`%+#D' is inaccessible", decl);
33bd39a2 3980 error ("within this context");
94be8403 3981 return false;
c73964b2 3982 }
d6479fe7 3983
94be8403 3984 return true;
c73964b2
MS
3985}
3986
3fe18f1d
MM
3987/* Perform the conversions in CONVS on the expression EXPR. FN and
3988 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
838dfd8a 3989 indicates the `this' argument of a method. INNER is nonzero when
78fe06c2 3990 being called to continue a conversion chain. It is negative when a
3fe18f1d
MM
3991 reference binding will be applied, positive otherwise. If
3992 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
3993 conversions will be emitted if appropriate. */
c73964b2
MS
3994
3995static tree
3fe18f1d
MM
3996convert_like_real (tree convs, tree expr, tree fn, int argnum, int inner,
3997 bool issue_conversion_warnings)
c73964b2 3998{
5e818b93
JM
3999 int savew, savee;
4000
4001 tree totype = TREE_TYPE (convs);
4002
d2e5ee5c
MS
4003 if (ICS_BAD_FLAG (convs)
4004 && TREE_CODE (convs) != USER_CONV
27b8d0cd
MM
4005 && TREE_CODE (convs) != AMBIG_CONV
4006 && TREE_CODE (convs) != REF_BIND)
d11ad92e
MS
4007 {
4008 tree t = convs;
4009 for (; t; t = TREE_OPERAND (t, 0))
4010 {
8a2b77e7 4011 if (TREE_CODE (t) == USER_CONV || !ICS_BAD_FLAG (t))
d11ad92e 4012 {
3fe18f1d
MM
4013 expr = convert_like_real (t, expr, fn, argnum, 1,
4014 /*issue_conversion_warnings=*/false);
d11ad92e
MS
4015 break;
4016 }
4017 else if (TREE_CODE (t) == AMBIG_CONV)
3fe18f1d
MM
4018 return convert_like_real (t, expr, fn, argnum, 1,
4019 /*issue_conversion_warnings=*/false);
d11ad92e
MS
4020 else if (TREE_CODE (t) == IDENTITY_CONV)
4021 break;
4022 }
33bd39a2 4023 pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
72a08131 4024 if (fn)
33bd39a2 4025 pedwarn (" initializing argument %P of `%D'", argnum, fn);
72a08131 4026 return cp_convert (totype, expr);
d11ad92e 4027 }
c3f08228 4028
3fe18f1d 4029 if (issue_conversion_warnings)
c3f08228 4030 expr = dubious_conversion_warnings
5e818b93 4031 (totype, expr, "argument", fn, argnum);
c73964b2
MS
4032 switch (TREE_CODE (convs))
4033 {
4034 case USER_CONV:
4035 {
7993382e 4036 struct z_candidate *cand = USER_CONV_CAND (convs);
5e818b93 4037 tree convfn = cand->fn;
c73964b2 4038 tree args;
c73964b2 4039
5e818b93 4040 if (DECL_CONSTRUCTOR_P (convfn))
c73964b2
MS
4041 {
4042 tree t = build_int_2 (0, 0);
5e818b93 4043 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn));
c73964b2 4044
051e6fd7 4045 args = build_tree_list (NULL_TREE, expr);
e0fff4b3
JM
4046 if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
4047 || DECL_HAS_VTT_PARM_P (convfn))
4048 /* We should never try to call the abstract or base constructor
4049 from here. */
4050 abort ();
e1b3e07d 4051 args = tree_cons (NULL_TREE, t, args);
c73964b2
MS
4052 }
4053 else
4054 args = build_this (expr);
b80f8ef3 4055 expr = build_over_call (cand, LOOKUP_NORMAL);
c73964b2
MS
4056
4057 /* If this is a constructor or a function returning an aggr type,
4058 we need to build up a TARGET_EXPR. */
5e818b93
JM
4059 if (DECL_CONSTRUCTOR_P (convfn))
4060 expr = build_cplus_new (totype, expr);
4061
4062 /* The result of the call is then used to direct-initialize the object
4063 that is the destination of the copy-initialization. [dcl.init]
4064
4065 Note that this step is not reflected in the conversion sequence;
4066 it affects the semantics when we actually perform the
4067 conversion, but is not considered during overload resolution.
c73964b2 4068
5e818b93 4069 If the target is a class, that means call a ctor. */
78fe06c2 4070 if (IS_AGGR_TYPE (totype)
b67db529 4071 && (inner >= 0 || !lvalue_p (expr)))
5e818b93
JM
4072 {
4073 savew = warningcount, savee = errorcount;
4ba126e4 4074 expr = build_special_member_call
5e818b93
JM
4075 (NULL_TREE, complete_ctor_identifier,
4076 build_tree_list (NULL_TREE, expr), TYPE_BINFO (totype),
4077 /* Core issue 84, now a DR, says that we don't allow UDCs
4078 for these args (which deliberately breaks copy-init of an
4079 auto_ptr<Base> from an auto_ptr<Derived>). */
4080 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION);
4081
4082 /* Tell the user where this failing constructor call came from. */
4083 if (fn)
4084 {
4085 if (warningcount > savew)
33bd39a2 4086 warning
5e818b93
JM
4087 (" initializing argument %P of `%D' from result of `%D'",
4088 argnum, fn, convfn);
4089 else if (errorcount > savee)
33bd39a2 4090 error
5e818b93
JM
4091 (" initializing argument %P of `%D' from result of `%D'",
4092 argnum, fn, convfn);
4093 }
4094 else
4095 {
4096 if (warningcount > savew)
33bd39a2 4097 warning (" initializing temporary from result of `%D'",
5e818b93
JM
4098 convfn);
4099 else if (errorcount > savee)
33bd39a2 4100 error (" initializing temporary from result of `%D'",
5e818b93
JM
4101 convfn);
4102 }
4103 expr = build_cplus_new (totype, expr);
4104 }
c73964b2
MS
4105 return expr;
4106 }
4107 case IDENTITY_CONV:
4108 if (type_unknown_p (expr))
c2ea3a40 4109 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4e8dca1c
JM
4110 /* Convert a non-array constant variable to its underlying value, unless we
4111 are about to bind it to a reference, in which case we need to
4112 leave it as an lvalue. */
4113 if (inner >= 0
4114 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
4115 expr = decl_constant_value (expr);
c73964b2
MS
4116 return expr;
4117 case AMBIG_CONV:
4118 /* Call build_user_type_conversion again for the error. */
4119 return build_user_type_conversion
5e818b93 4120 (totype, TREE_OPERAND (convs, 0), LOOKUP_NORMAL);
7f85441b
KG
4121
4122 default:
4123 break;
c73964b2
MS
4124 };
4125
78fe06c2 4126 expr = convert_like_real (TREE_OPERAND (convs, 0), expr, fn, argnum,
3fe18f1d
MM
4127 TREE_CODE (convs) == REF_BIND ? -1 : 1,
4128 /*issue_conversion_warnings=*/false);
c73964b2
MS
4129 if (expr == error_mark_node)
4130 return error_mark_node;
4131
4132 switch (TREE_CODE (convs))
4133 {
c73964b2 4134 case RVALUE_CONV:
5e818b93 4135 if (! IS_AGGR_TYPE (totype))
de22184b
MS
4136 return expr;
4137 /* else fall through */
4138 case BASE_CONV:
4f0aa416
MM
4139 if (TREE_CODE (convs) == BASE_CONV && !NEED_TEMPORARY_P (convs))
4140 {
4141 /* We are going to bind a reference directly to a base-class
4142 subobject of EXPR. */
5e818b93 4143 tree base_ptr = build_pointer_type (totype);
4f0aa416
MM
4144
4145 /* Build an expression for `*((base*) &expr)'. */
4146 expr = build_unary_op (ADDR_EXPR, expr, 0);
4147 expr = perform_implicit_conversion (base_ptr, expr);
4148 expr = build_indirect_ref (expr, "implicit conversion");
4149 return expr;
4150 }
4151
5e818b93
JM
4152 /* Copy-initialization where the cv-unqualified version of the source
4153 type is the same class as, or a derived class of, the class of the
4154 destination [is treated as direct-initialization]. [dcl.init] */
ae0ed63a 4155 savew = warningcount, savee = errorcount;
4ba126e4
MM
4156 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4157 build_tree_list (NULL_TREE, expr),
4158 TYPE_BINFO (totype),
4159 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING);
5e818b93
JM
4160 if (fn)
4161 {
4162 if (warningcount > savew)
33bd39a2 4163 warning (" initializing argument %P of `%D'", argnum, fn);
5e818b93 4164 else if (errorcount > savee)
33bd39a2 4165 error (" initializing argument %P of `%D'", argnum, fn);
5e818b93
JM
4166 }
4167 return build_cplus_new (totype, expr);
41efda8f 4168
c73964b2 4169 case REF_BIND:
27b8d0cd 4170 {
5e818b93 4171 tree ref_type = totype;
27b8d0cd
MM
4172
4173 /* If necessary, create a temporary. */
6c6e776d 4174 if (NEED_TEMPORARY_P (convs) || !non_cast_lvalue_p (expr))
27b8d0cd
MM
4175 {
4176 tree type = TREE_TYPE (TREE_OPERAND (convs, 0));
c506ca22 4177 expr = build_target_expr_with_type (expr, type);
27b8d0cd
MM
4178 }
4179
4180 /* Take the address of the thing to which we will bind the
4181 reference. */
4182 expr = build_unary_op (ADDR_EXPR, expr, 1);
4183 if (expr == error_mark_node)
4184 return error_mark_node;
4185
4186 /* Convert it to a pointer to the type referred to by the
4187 reference. This will adjust the pointer if a derived to
4188 base conversion is being performed. */
4189 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4190 expr);
4191 /* Convert the pointer to the desired reference type. */
7993382e 4192 return build_nop (ref_type, expr);
27b8d0cd
MM
4193 }
4194
c73964b2
MS
4195 case LVALUE_CONV:
4196 return decay_conversion (expr);
7f85441b 4197
d9cf7c82
JM
4198 case QUAL_CONV:
4199 /* Warn about deprecated conversion if appropriate. */
5e818b93 4200 string_conv_p (totype, expr, 1);
d9cf7c82
JM
4201 break;
4202
7f85441b
KG
4203 default:
4204 break;
c73964b2 4205 }
5e818b93 4206 return ocp_convert (totype, expr, CONV_IMPLICIT,
37c46b43 4207 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
c73964b2
MS
4208}
4209
1a55127d
JM
4210/* Build a call to __builtin_trap which can be used in an expression. */
4211
4212static tree
94be8403 4213call_builtin_trap (void)
1a55127d
JM
4214{
4215 tree fn = get_identifier ("__builtin_trap");
4216 if (IDENTIFIER_GLOBAL_VALUE (fn))
4217 fn = IDENTIFIER_GLOBAL_VALUE (fn);
4218 else
4219 abort ();
4220
4221 fn = build_call (fn, NULL_TREE);
4222 fn = build (COMPOUND_EXPR, integer_type_node, fn, integer_zero_node);
4223 return fn;
4224}
4225
41efda8f 4226/* ARG is being passed to a varargs function. Perform any conversions
0a72704b 4227 required. Return the converted value. */
41efda8f
MM
4228
4229tree
94be8403 4230convert_arg_to_ellipsis (tree arg)
41efda8f 4231{
0a72704b
MM
4232 /* [expr.call]
4233
4234 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4235 standard conversions are performed. */
4236 arg = decay_conversion (arg);
4237 /* [expr.call]
4238
4239 If the argument has integral or enumeration type that is subject
4240 to the integral promotions (_conv.prom_), or a floating point
4241 type that is subject to the floating point promotion
4242 (_conv.fpprom_), the value of the argument is converted to the
4243 promoted type before the call. */
41efda8f
MM
4244 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4245 && (TYPE_PRECISION (TREE_TYPE (arg))
4246 < TYPE_PRECISION (double_type_node)))
41efda8f 4247 arg = cp_convert (double_type_node, arg);
0a72704b
MM
4248 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4249 arg = perform_integral_promotions (arg);
41efda8f 4250
66543169
NS
4251 arg = require_complete_type (arg);
4252
1b4d752a
NS
4253 if (arg != error_mark_node && ! pod_type_p (TREE_TYPE (arg)))
4254 {
838dfd8a 4255 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
a77a9a18
JM
4256 here and do a bitwise copy, but now cp_expr_size will abort if we
4257 try to do that. */
1a55127d
JM
4258 warning ("cannot pass objects of non-POD type `%#T' through `...'; \
4259call will abort at runtime",
4260 TREE_TYPE (arg));
4261 arg = call_builtin_trap ();
1b4d752a
NS
4262 }
4263
41efda8f
MM
4264 return arg;
4265}
4266
356955cf
NS
4267/* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4268
4269tree
94be8403 4270build_x_va_arg (tree expr, tree type)
356955cf 4271{
ea333e1c
NS
4272 if (processing_template_decl)
4273 return build_min (VA_ARG_EXPR, type, expr);
4274
356955cf
NS
4275 type = complete_type_or_else (type, NULL_TREE);
4276
4277 if (expr == error_mark_node || !type)
4278 return error_mark_node;
4279
4280 if (! pod_type_p (type))
4281 {
838dfd8a 4282 /* Undefined behavior [expr.call] 5.2.2/7. */
33bd39a2 4283 warning ("cannot receive objects of non-POD type `%#T' through `...'",
356955cf
NS
4284 type);
4285 }
4286
4287 return build_va_arg (expr, type);
4288}
4289
ab393bf1
NB
4290/* TYPE has been given to va_arg. Apply the default conversions which
4291 would have happened when passed via ellipsis. Return the promoted
4292 type, or the passed type if there is no change. */
356955cf
NS
4293
4294tree
94be8403 4295cxx_type_promotes_to (tree type)
356955cf
NS
4296{
4297 tree promote;
ab393bf1 4298
356955cf 4299 if (TREE_CODE (type) == ARRAY_TYPE)
ab393bf1
NB
4300 return build_pointer_type (TREE_TYPE (type));
4301
4302 if (TREE_CODE (type) == FUNCTION_TYPE)
4303 return build_pointer_type (type);
4304
4305 promote = type_promotes_to (type);
4306 if (same_type_p (type, promote))
4307 promote = type;
356955cf 4308
ab393bf1 4309 return promote;
356955cf
NS
4310}
4311
41efda8f 4312/* ARG is a default argument expression being passed to a parameter of
297e73d8
MM
4313 the indicated TYPE, which is a parameter to FN. Do any required
4314 conversions. Return the converted value. */
41efda8f
MM
4315
4316tree
94be8403 4317convert_default_arg (tree type, tree arg, tree fn, int parmnum)
c73964b2 4318{
a723baf1
MM
4319 /* If the ARG is an unparsed default argument expression, the
4320 conversion cannot be performed. */
96a1e32d
NS
4321 if (TREE_CODE (arg) == DEFAULT_ARG)
4322 {
a723baf1
MM
4323 error ("the default argument for parameter %d of `%D' has "
4324 "not yet been parsed",
4325 parmnum, fn);
4326 return error_mark_node;
96a1e32d
NS
4327 }
4328
297e73d8 4329 if (fn && DECL_TEMPLATE_INFO (fn))
9188c363 4330 arg = tsubst_default_argument (fn, type, arg);
297e73d8 4331
c73964b2
MS
4332 arg = break_out_target_exprs (arg);
4333
4334 if (TREE_CODE (arg) == CONSTRUCTOR)
4335 {
4336 arg = digest_init (type, arg, 0);
4337 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
c3f08228 4338 "default argument", fn, parmnum);
c73964b2
MS
4339 }
4340 else
4341 {
4342 /* This could get clobbered by the following call. */
4343 if (TREE_HAS_CONSTRUCTOR (arg))
4344 arg = copy_node (arg);
4345
4346 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
c3f08228 4347 "default argument", fn, parmnum);
8e51619a 4348 arg = convert_for_arg_passing (type, arg);
c73964b2
MS
4349 }
4350
4351 return arg;
4352}
4353
8e51619a
JM
4354/* Returns the type which will really be used for passing an argument of
4355 type TYPE. */
4356
4357tree
94be8403 4358type_passed_as (tree type)
8e51619a
JM
4359{
4360 /* Pass classes with copy ctors by invisible reference. */
4361 if (TREE_ADDRESSABLE (type))
4362 type = build_reference_type (type);
4363 else if (PROMOTE_PROTOTYPES
4364 && INTEGRAL_TYPE_P (type)
4365 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4366 type = integer_type_node;
4367
4368 return type;
4369}
4370
4371/* Actually perform the appropriate conversion. */
4372
4373tree
94be8403 4374convert_for_arg_passing (tree type, tree val)
8e51619a 4375{
c246c65d
JM
4376 if (val == error_mark_node)
4377 ;
8e51619a 4378 /* Pass classes with copy ctors by invisible reference. */
c246c65d
JM
4379 else if (TREE_ADDRESSABLE (type))
4380 val = build1 (ADDR_EXPR, build_reference_type (type), val);
8e51619a
JM
4381 else if (PROMOTE_PROTOTYPES
4382 && INTEGRAL_TYPE_P (type)
4383 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
0a72704b 4384 val = perform_integral_promotions (val);
8e51619a
JM
4385 return val;
4386}
4387
c050ec51
JM
4388/* Subroutine of the various build_*_call functions. Overload resolution
4389 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4390 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4391 bitmask of various LOOKUP_* flags which apply to the call itself. */
4392
c73964b2 4393static tree
b80f8ef3 4394build_over_call (struct z_candidate *cand, int flags)
c73964b2 4395{
5ffe581d 4396 tree fn = cand->fn;
b80f8ef3 4397 tree args = cand->args;
5ffe581d 4398 tree convs = cand->convs;
c73964b2
MS
4399 tree converted_args = NULL_TREE;
4400 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4401 tree conv, arg, val;
4402 int i = 0;
d11ad92e 4403 int is_method = 0;
c73964b2 4404
5ffe581d
JM
4405 /* Give any warnings we noticed during overload resolution. */
4406 if (cand->warnings)
4407 for (val = cand->warnings; val; val = TREE_CHAIN (val))
e2500fed 4408 joust (cand, WRAPPER_ZC (TREE_VALUE (val)), 1);
5ffe581d
JM
4409
4410 if (DECL_FUNCTION_MEMBER_P (fn))
78757caa 4411 perform_or_defer_access_check (cand->access_path, fn);
5ffe581d 4412
c73964b2 4413 if (args && TREE_CODE (args) != TREE_LIST)
051e6fd7 4414 args = build_tree_list (NULL_TREE, args);
c73964b2
MS
4415 arg = args;
4416
4417 /* The implicit parameters to a constructor are not considered by overload
4418 resolution, and must be of the proper type. */
4419 if (DECL_CONSTRUCTOR_P (fn))
4420 {
e1b3e07d 4421 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
c73964b2
MS
4422 arg = TREE_CHAIN (arg);
4423 parm = TREE_CHAIN (parm);
454fa7a7 4424 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
e0fff4b3
JM
4425 /* We should never try to call the abstract constructor. */
4426 abort ();
4427 if (DECL_HAS_VTT_PARM_P (fn))
c73964b2 4428 {
e1b3e07d 4429 converted_args = tree_cons
c73964b2
MS
4430 (NULL_TREE, TREE_VALUE (arg), converted_args);
4431 arg = TREE_CHAIN (arg);
4432 parm = TREE_CHAIN (parm);
4433 }
4434 }
4435 /* Bypass access control for 'this' parameter. */
4436 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4437 {
d11ad92e
MS
4438 tree parmtype = TREE_VALUE (parm);
4439 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4ba126e4 4440 tree converted_arg;
3baab484
NS
4441 tree base_binfo;
4442
d11ad92e 4443 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
33bd39a2 4444 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
2642b9bf 4445 TREE_TYPE (argtype), fn);
91063b51 4446
51ddb82e
JM
4447 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4448 X is called for an object that is not of type X, or of a type
4449 derived from X, the behavior is undefined.
4450
4451 So we can assume that anything passed as 'this' is non-null, and
4452 optimize accordingly. */
6eabb241 4453 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4ba126e4
MM
4454 /* Convert to the base in which the function was declared. */
4455 my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730);
4456 converted_arg = build_base_path (PLUS_EXPR,
4457 TREE_VALUE (arg),
4458 cand->conversion_path,
4459 1);
3baab484
NS
4460 /* If fn was found by a using declaration, the conversion path
4461 will be to the derived class, not the base declaring fn. We
4462 must convert from derived to base. */
4463 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4464 TREE_TYPE (parmtype), ba_ignore, NULL);
4465
4466 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4467 base_binfo, 1);
4468
4ba126e4 4469 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
c73964b2
MS
4470 parm = TREE_CHAIN (parm);
4471 arg = TREE_CHAIN (arg);
4472 ++i;
d11ad92e 4473 is_method = 1;
c73964b2
MS
4474 }
4475
eb66be0e 4476 for (; arg && parm;
c73964b2
MS
4477 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4478 {
4479 tree type = TREE_VALUE (parm);
d11ad92e 4480
eb66be0e 4481 conv = TREE_VEC_ELT (convs, i);
72a08131
JM
4482 val = convert_like_with_context
4483 (conv, TREE_VALUE (arg), fn, i - is_method);
c73964b2 4484
8e51619a 4485 val = convert_for_arg_passing (type, val);
e1b3e07d 4486 converted_args = tree_cons (NULL_TREE, val, converted_args);
c73964b2
MS
4487 }
4488
4489 /* Default arguments */
c3f08228 4490 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
297e73d8 4491 converted_args
e1b3e07d
MM
4492 = tree_cons (NULL_TREE,
4493 convert_default_arg (TREE_VALUE (parm),
4494 TREE_PURPOSE (parm),
c3f08228 4495 fn, i - is_method),
e1b3e07d 4496 converted_args);
c73964b2
MS
4497
4498 /* Ellipsis */
4499 for (; arg; arg = TREE_CHAIN (arg))
41efda8f 4500 converted_args
e1b3e07d
MM
4501 = tree_cons (NULL_TREE,
4502 convert_arg_to_ellipsis (TREE_VALUE (arg)),
4503 converted_args);
c73964b2
MS
4504
4505 converted_args = nreverse (converted_args);
4506
80a497e4
JM
4507 if (warn_format)
4508 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4509 converted_args);
61cd552e 4510
c11b6f21
MS
4511 /* Avoid actually calling copy constructors and copy assignment operators,
4512 if possible. */
56ae6d77
JM
4513
4514 if (! flag_elide_constructors)
4515 /* Do things the hard way. */;
454fa7a7
MM
4516 else if (TREE_VEC_LENGTH (convs) == 1
4517 && DECL_COPY_CONSTRUCTOR_P (fn))
c11b6f21 4518 {
eb66be0e 4519 tree targ;
e0fff4b3 4520 arg = skip_artificial_parms_for (fn, converted_args);
67437d5b 4521 arg = TREE_VALUE (arg);
c11b6f21
MS
4522
4523 /* Pull out the real argument, disregarding const-correctness. */
eb66be0e
MS
4524 targ = arg;
4525 while (TREE_CODE (targ) == NOP_EXPR
4526 || TREE_CODE (targ) == NON_LVALUE_EXPR
4527 || TREE_CODE (targ) == CONVERT_EXPR)
4528 targ = TREE_OPERAND (targ, 0);
4529 if (TREE_CODE (targ) == ADDR_EXPR)
4530 {
4531 targ = TREE_OPERAND (targ, 0);
9edc3913
MM
4532 if (!same_type_ignoring_top_level_qualifiers_p
4533 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
c11b6f21
MS
4534 targ = NULL_TREE;
4535 }
eb66be0e
MS
4536 else
4537 targ = NULL_TREE;
c11b6f21
MS
4538
4539 if (targ)
4540 arg = targ;
4541 else
4542 arg = build_indirect_ref (arg, 0);
4543
bd6dd845
MS
4544 /* [class.copy]: the copy constructor is implicitly defined even if
4545 the implementation elided its use. */
4546 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4547 mark_used (fn);
4548
c11b6f21
MS
4549 /* If we're creating a temp and we already have one, don't create a
4550 new one. If we're not creating a temp but we get one, use
4551 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4552 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4553 temp or an INIT_EXPR otherwise. */
4554 if (integer_zerop (TREE_VALUE (args)))
4555 {
c246c65d 4556 if (TREE_CODE (arg) == TARGET_EXPR)
c11b6f21
MS
4557 return arg;
4558 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
c506ca22 4559 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
c11b6f21 4560 }
c246c65d 4561 else if (TREE_CODE (arg) == TARGET_EXPR
a77a9a18 4562 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
c11b6f21 4563 {
c1aa4de7 4564 tree address;
c11b6f21
MS
4565 tree to = stabilize_reference
4566 (build_indirect_ref (TREE_VALUE (args), 0));
a59ca936 4567
0830ae44 4568 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
c1aa4de7
MM
4569 address = build_unary_op (ADDR_EXPR, val, 0);
4570 /* Avoid a warning about this expression, if the address is
4571 never used. */
4572 TREE_USED (address) = 1;
4573 return address;
c11b6f21
MS
4574 }
4575 }
596ea4e5 4576 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
271e6f02 4577 && copy_fn_p (fn)
4f1c5b7d 4578 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
c11b6f21
MS
4579 {
4580 tree to = stabilize_reference
4581 (build_indirect_ref (TREE_VALUE (converted_args), 0));
a59ca936 4582
959d8796 4583 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
a77a9a18 4584 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
c11b6f21
MS
4585 return val;
4586 }
4587
bd6dd845
MS
4588 mark_used (fn);
4589
6eabb241 4590 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
c73964b2
MS
4591 {
4592 tree t, *p = &TREE_VALUE (converted_args);
338d90b8 4593 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
e93ee644 4594 DECL_CONTEXT (fn),
338d90b8
NS
4595 ba_any, NULL);
4596 my_friendly_assert (binfo && binfo != error_mark_node, 20010730);
4597
4598 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
c73964b2
MS
4599 if (TREE_SIDE_EFFECTS (*p))
4600 *p = save_expr (*p);
4601 t = build_pointer_type (TREE_TYPE (fn));
60c87482
BM
4602 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4603 fn = build_java_interface_fn_ref (fn, *p);
4604 else
67231816 4605 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
c73964b2
MS
4606 TREE_TYPE (fn) = t;
4607 }
4608 else if (DECL_INLINE (fn))
4609 fn = inline_conversion (fn);
4610 else
4611 fn = build_addr_func (fn);
4612
b2dd096b
MM
4613 return build_cxx_call (fn, args, converted_args);
4614}
4615
4616/* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4617 gives the original form of the arguments. This function performs
4618 no overload resolution, conversion, or other high-level
4619 operations. */
4620
4621tree
4622build_cxx_call(tree fn, tree args, tree converted_args)
4623{
4624 tree fndecl;
4625
387c47a3
AS
4626 /* Recognize certain built-in functions so we can make tree-codes
4627 other than CALL_EXPR. We do this when it enables fold-const.c
4628 to do something useful. */
387c47a3
AS
4629 if (TREE_CODE (fn) == ADDR_EXPR
4630 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
1eb8759b
RH
4631 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4632 {
4633 tree exp;
4634 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4635 if (exp)
4636 return exp;
4637 }
387c47a3 4638
b2dd096b
MM
4639 fn = build_call (fn, converted_args);
4640
4641 /* If this call might throw an exception, note that fact. */
4642 fndecl = get_callee_fndecl (fn);
374ca7f7
MM
4643 if ((!fndecl || !TREE_NOTHROW (fndecl))
4644 && at_function_scope_p ()
4645 && cfun)
b2dd096b
MM
4646 cp_function_chain->can_throw = 1;
4647
4648 /* Some built-in function calls will be evaluated at compile-time in
4649 fold (). */
4650 fn = fold (fn);
4651
2c92b94d 4652 if (VOID_TYPE_P (TREE_TYPE (fn)))
c73964b2 4653 return fn;
b2dd096b 4654
b82b76c6 4655 fn = require_complete_type (fn);
2c92b94d
NS
4656 if (fn == error_mark_node)
4657 return error_mark_node;
b2dd096b 4658
c73964b2
MS
4659 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4660 fn = build_cplus_new (TREE_TYPE (fn), fn);
b82b76c6 4661 return convert_from_reference (fn);
c73964b2
MS
4662}
4663
e2500fed 4664static GTY(()) tree java_iface_lookup_fn;
60c87482
BM
4665
4666/* Make an expression which yields the address of the Java interface
4667 method FN. This is achieved by generating a call to libjava's
4668 _Jv_LookupInterfaceMethodIdx(). */
4669
4670static tree
94be8403 4671build_java_interface_fn_ref (tree fn, tree instance)
60c87482
BM
4672{
4673 tree lookup_args, lookup_fn, method, idx;
4674 tree klass_ref, iface, iface_ref;
4675 int i;
4676
4677 if (!java_iface_lookup_fn)
4678 {
4679 tree endlink = build_void_list_node ();
4680 tree t = tree_cons (NULL_TREE, ptr_type_node,
4681 tree_cons (NULL_TREE, ptr_type_node,
4682 tree_cons (NULL_TREE, java_int_type_node,
4683 endlink)));
4684 java_iface_lookup_fn
4685 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4686 build_function_type (ptr_type_node, t),
6a2dd09a 4687 0, NOT_BUILT_IN, NULL, NULL_TREE);
60c87482
BM
4688 }
4689
4690 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
00a17e31 4691 This is the first entry in the vtable. */
60c87482
BM
4692 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4693 integer_zero_node);
4694
00a17e31 4695 /* Get the java.lang.Class pointer for the interface being called. */
60c87482 4696 iface = DECL_CONTEXT (fn);
86ac0575 4697 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
60c87482
BM
4698 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4699 || DECL_CONTEXT (iface_ref) != iface)
4700 {
33bd39a2 4701 error ("could not find class$ field in java interface type `%T'",
60c87482
BM
4702 iface);
4703 return error_mark_node;
4704 }
4705 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4706
00a17e31 4707 /* Determine the itable index of FN. */
60c87482
BM
4708 i = 1;
4709 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4710 {
4711 if (!DECL_VIRTUAL_P (method))
4712 continue;
4713 if (fn == method)
4714 break;
4715 i++;
4716 }
4717 idx = build_int_2 (i, 0);
4718
4719 lookup_args = tree_cons (NULL_TREE, klass_ref,
4720 tree_cons (NULL_TREE, iface_ref,
4721 build_tree_list (NULL_TREE, idx)));
4722 lookup_fn = build1 (ADDR_EXPR,
4723 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4724 java_iface_lookup_fn);
4725 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4726}
4727
298d6f60
MM
4728/* Returns the value to use for the in-charge parameter when making a
4729 call to a function with the indicated NAME. */
4730
4731tree
94be8403 4732in_charge_arg_for_name (tree name)
298d6f60
MM
4733{
4734 if (name == base_ctor_identifier
4735 || name == base_dtor_identifier)
4736 return integer_zero_node;
4737 else if (name == complete_ctor_identifier)
4738 return integer_one_node;
4739 else if (name == complete_dtor_identifier)
4740 return integer_two_node;
4741 else if (name == deleting_dtor_identifier)
4742 return integer_three_node;
4743
4744 /* This function should only be called with one of the names listed
4745 above. */
a98facb0 4746 abort ();
298d6f60
MM
4747 return NULL_TREE;
4748}
4749
4ba126e4
MM
4750/* Build a call to a constructor, destructor, or an assignment
4751 operator for INSTANCE, an expression with class type. NAME
4752 indicates the special member function to call; ARGS are the
4753 arguments. BINFO indicates the base of INSTANCE that is to be
4754 passed as the `this' parameter to the member function called.
4755
4756 FLAGS are the LOOKUP_* flags to use when processing the call.
4757
4758 If NAME indicates a complete object constructor, INSTANCE may be
4759 NULL_TREE. In this case, the caller will call build_cplus_new to
4760 store the newly constructed object into a VAR_DECL. */
4761
4762tree
4763build_special_member_call (tree instance, tree name, tree args,
4764 tree binfo, int flags)
4765{
4766 tree fns;
4767 /* The type of the subobject to be constructed or destroyed. */
4768 tree class_type;
4769
4770 my_friendly_assert (name == complete_ctor_identifier
4771 || name == base_ctor_identifier
4772 || name == complete_dtor_identifier
4773 || name == base_dtor_identifier
4774 || name == deleting_dtor_identifier
4775 || name == ansi_assopname (NOP_EXPR),
4776 20020712);
4777 my_friendly_assert (binfo != NULL_TREE, 20020712);
4778
4779 class_type = BINFO_TYPE (binfo);
4780
4781 /* Handle the special case where INSTANCE is NULL_TREE. */
4782 if (name == complete_ctor_identifier && !instance)
4783 {
4784 instance = build_int_2 (0, 0);
4785 TREE_TYPE (instance) = build_pointer_type (class_type);
4786 instance = build1 (INDIRECT_REF, class_type, instance);
4787 }
4788 else if (name == complete_dtor_identifier
4789 || name == base_dtor_identifier
4790 || name == deleting_dtor_identifier)
4791 my_friendly_assert (args == NULL_TREE, 20020712);
4792
4793 my_friendly_assert (instance != NULL_TREE, 20020712);
4794
4795 /* Resolve the name. */
4796 if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE))
4797 return error_mark_node;
4798
4799 fns = lookup_fnfields (binfo, name, 1);
4800
4801 /* When making a call to a constructor or destructor for a subobject
4802 that uses virtual base classes, pass down a pointer to a VTT for
4803 the subobject. */
4804 if ((name == base_ctor_identifier
4805 || name == base_dtor_identifier)
4806 && TYPE_USES_VIRTUAL_BASECLASSES (class_type))
4807 {
4808 tree vtt;
4809 tree sub_vtt;
4810
4811 /* If the current function is a complete object constructor
4812 or destructor, then we fetch the VTT directly.
4813 Otherwise, we look it up using the VTT we were given. */
548502d3 4814 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
4ba126e4
MM
4815 vtt = decay_conversion (vtt);
4816 vtt = build (COND_EXPR, TREE_TYPE (vtt),
4817 build (EQ_EXPR, boolean_type_node,
4818 current_in_charge_parm, integer_zero_node),
4819 current_vtt_parm,
4820 vtt);
4ba126e4
MM
4821 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110);
4822 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
4823 BINFO_SUBVTT_INDEX (binfo));
4824
4825 args = tree_cons (NULL_TREE, sub_vtt, args);
4826 }
4827
4828 return build_new_method_call (instance, fns, args, binfo, flags);
4829}
4830
a723baf1
MM
4831/* Return the NAME, as a C string. The NAME indicates a function that
4832 is a member of TYPE. *FREE_P is set to true if the caller must
4833 free the memory returned.
4834
4835 Rather than go through all of this, we should simply set the names
4836 of constructors and destructors appropriately, and dispense with
4837 ctor_identifier, dtor_identifier, etc. */
4838
4839static char *
4840name_as_c_string (tree name, tree type, bool *free_p)
4841{
4842 char *pretty_name;
4843
4844 /* Assume that we will not allocate memory. */
4845 *free_p = false;
4846 /* Constructors and destructors are special. */
4847 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
4848 {
4849 pretty_name
4850 = (char *) IDENTIFIER_POINTER (constructor_name (type));
4851 /* For a destructor, add the '~'. */
4852 if (name == complete_dtor_identifier
4853 || name == base_dtor_identifier
4854 || name == deleting_dtor_identifier)
4855 {
4856 pretty_name = concat ("~", pretty_name, NULL);
4857 /* Remember that we need to free the memory allocated. */
4858 *free_p = true;
4859 }
4860 }
4861 else
4862 pretty_name = (char *) IDENTIFIER_POINTER (name);
4863
4864 return pretty_name;
4865}
4866
4ba126e4
MM
4867/* Build a call to "INSTANCE.FN (ARGS)". */
4868
4869tree
4870build_new_method_call (tree instance, tree fns, tree args,
4871 tree conversion_path, int flags)
c73964b2
MS
4872{
4873 struct z_candidate *candidates = 0, *cand;
386b8a85 4874 tree explicit_targs = NULL_TREE;
4ba126e4
MM
4875 tree basetype = NULL_TREE;
4876 tree access_binfo;
4877 tree optype;
4878 tree mem_args = NULL_TREE, instance_ptr;
a723baf1 4879 tree name;
71a19881 4880 tree user_args;
3c8c2a0a 4881 tree call;
a723baf1
MM
4882 tree fn;
4883 tree class_type;
c32381b1 4884 int template_only = 0;
436f8a4c 4885 bool any_viable_p;
824b9a4c 4886
4ba126e4 4887 my_friendly_assert (instance != NULL_TREE, 20020729);
8f032717 4888
a723baf1
MM
4889 if (error_operand_p (instance)
4890 || error_operand_p (fns)
4ba126e4
MM
4891 || args == error_mark_node)
4892 return error_mark_node;
386b8a85 4893
4ba126e4 4894 /* Process the argument list. */
9eb71d8c 4895 user_args = args;
86e6f22f 4896 args = resolve_args (args);
86e6f22f
JM
4897 if (args == error_mark_node)
4898 return error_mark_node;
d11ad92e 4899
4ba126e4
MM
4900 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
4901 instance = convert_from_reference (instance);
4902 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
4903 instance_ptr = build_this (instance);
4904
4905 if (!BASELINK_P (fns))
c73964b2 4906 {
4ba126e4
MM
4907 call = build_field_call (instance_ptr, fns, args);
4908 if (call)
4909 return call;
4910 error ("call to non-function `%D'", fns);
4911 return error_mark_node;
4912 }
c73964b2 4913
4ba126e4
MM
4914 if (!conversion_path)
4915 conversion_path = BASELINK_BINFO (fns);
4916 access_binfo = BASELINK_ACCESS_BINFO (fns);
4917 optype = BASELINK_OPTYPE (fns);
4918 fns = BASELINK_FUNCTIONS (fns);
c73964b2 4919
4ba126e4
MM
4920 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
4921 {
4922 explicit_targs = TREE_OPERAND (fns, 1);
4923 fns = TREE_OPERAND (fns, 0);
4924 template_only = 1;
c73964b2
MS
4925 }
4926
4ba126e4
MM
4927 my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL
4928 || TREE_CODE (fns) == TEMPLATE_DECL
4929 || TREE_CODE (fns) == OVERLOAD,
4930 20020712);
c73964b2 4931
4ba126e4
MM
4932 /* XXX this should be handled before we get here. */
4933 if (! IS_AGGR_TYPE (basetype))
c73964b2 4934 {
4ba126e4
MM
4935 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
4936 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
4937 fns, instance, basetype);
c73964b2 4938
4ba126e4 4939 return error_mark_node;
c73964b2
MS
4940 }
4941
a723baf1
MM
4942 fn = get_first_fn (fns);
4943 name = DECL_NAME (fn);
9eb71d8c 4944
298d6f60 4945 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
9eb71d8c 4946 {
4ba126e4
MM
4947 /* Callers should explicitly indicate whether they want to construct
4948 the complete object or just the part without virtual bases. */
4949 my_friendly_assert (name != ctor_identifier, 20000408);
4950 /* Similarly for destructors. */
4951 my_friendly_assert (name != dtor_identifier, 20000408);
9eb71d8c 4952 }
c73964b2 4953
a723baf1
MM
4954 /* It's OK to call destructors on cv-qualified objects. Therefore,
4955 convert the INSTANCE_PTR to the unqualified type, if necessary. */
4956 if (DECL_DESTRUCTOR_P (fn))
c73964b2 4957 {
a723baf1
MM
4958 tree type = build_pointer_type (basetype);
4959 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
7993382e 4960 instance_ptr = build_nop (type, instance_ptr);
a723baf1 4961 }
4ba126e4 4962
a723baf1
MM
4963 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
4964 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
98c1c668 4965
a723baf1
MM
4966 for (fn = fns; fn; fn = OVL_NEXT (fn))
4967 {
4968 tree t = OVL_CURRENT (fn);
4969 tree this_arglist;
71a19881 4970
a723baf1
MM
4971 /* We can end up here for copy-init of same or base class. */
4972 if ((flags & LOOKUP_ONLYCONVERTING)
4973 && DECL_NONCONVERTING_P (t))
4974 continue;
98c1c668 4975
a723baf1
MM
4976 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
4977 this_arglist = mem_args;
4978 else
4979 this_arglist = args;
4980
4981 if (TREE_CODE (t) == TEMPLATE_DECL)
7993382e
MM
4982 /* A member template. */
4983 add_template_candidate (&candidates, t,
4984 class_type,
4985 explicit_targs,
4986 this_arglist, optype,
4987 access_binfo,
4988 conversion_path,
4989 flags,
4990 DEDUCE_CALL);
a723baf1 4991 else if (! template_only)
7993382e
MM
4992 add_function_candidate (&candidates, t,
4993 class_type,
4994 this_arglist,
4995 access_binfo,
4996 conversion_path,
4997 flags);
c73964b2
MS
4998 }
4999
436f8a4c
MM
5000 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5001 if (!any_viable_p)
c73964b2
MS
5002 {
5003 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5004 if (flags & LOOKUP_SPECULATIVELY)
5005 return NULL_TREE;
d0f062fb 5006 if (!COMPLETE_TYPE_P (basetype))
7a228918 5007 cxx_incomplete_type_error (instance_ptr, basetype);
c27be9b9 5008 else
a723baf1
MM
5009 {
5010 char *pretty_name;
5011 bool free_p;
5012
5013 pretty_name = name_as_c_string (name, basetype, &free_p);
5014 error ("no matching function for call to `%T::%s(%A)%#V'",
5015 basetype, pretty_name, user_args,
5016 TREE_TYPE (TREE_TYPE (instance_ptr)));
5017 if (free_p)
5018 free (pretty_name);
5019 }
c73964b2
MS
5020 print_z_candidates (candidates);
5021 return error_mark_node;
5022 }
c73964b2 5023
436f8a4c 5024 cand = tourney (candidates);
c73964b2
MS
5025 if (cand == 0)
5026 {
a723baf1
MM
5027 char *pretty_name;
5028 bool free_p;
5029
5030 pretty_name = name_as_c_string (name, basetype, &free_p);
5e8a153a 5031 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
a723baf1 5032 user_args);
c73964b2 5033 print_z_candidates (candidates);
a723baf1
MM
5034 if (free_p)
5035 free (pretty_name);
c73964b2
MS
5036 return error_mark_node;
5037 }
5038
fee7654e 5039 if (DECL_PURE_VIRTUAL_P (cand->fn)
c73964b2 5040 && instance == current_class_ref
1cb47a5c
ML
5041 && (DECL_CONSTRUCTOR_P (current_function_decl)
5042 || DECL_DESTRUCTOR_P (current_function_decl))
c73964b2 5043 && ! (flags & LOOKUP_NONVIRTUAL)
fee7654e 5044 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
33bd39a2 5045 error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
1cb47a5c
ML
5046 "abstract virtual `%#D' called from constructor"
5047 : "abstract virtual `%#D' called from destructor"),
5048 cand->fn);
c73964b2 5049 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
51924768 5050 && is_dummy_object (instance_ptr))
8f032717 5051 {
33bd39a2 5052 error ("cannot call member function `%D' without object", cand->fn);
8f032717
MM
5053 return error_mark_node;
5054 }
c73964b2
MS
5055
5056 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
a0de9d20 5057 && resolves_to_fixed_type_p (instance, 0))
c73964b2
MS
5058 flags |= LOOKUP_NONVIRTUAL;
5059
3c8c2a0a 5060 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE)
b80f8ef3 5061 call = build_over_call (cand, flags);
3c8c2a0a
JM
5062 else
5063 {
b80f8ef3 5064 call = build_over_call (cand, flags);
4ba126e4
MM
5065 /* In an expression of the form `a->f()' where `f' turns out to
5066 be a static member function, `a' is none-the-less evaluated. */
9f175208 5067 if (!is_dummy_object (instance_ptr) && TREE_SIDE_EFFECTS (instance))
3c8c2a0a
JM
5068 call = build (COMPOUND_EXPR, TREE_TYPE (call), instance, call);
5069 }
5070
5071 return call;
c73964b2
MS
5072}
5073
94be8403 5074/* Returns true iff standard conversion sequence ICS1 is a proper
ceab47eb 5075 subsequence of ICS2. */
c73964b2 5076
94be8403
GDR
5077static bool
5078is_subseq (tree ics1, tree ics2)
c73964b2 5079{
ceab47eb
MM
5080 /* We can assume that a conversion of the same code
5081 between the same types indicates a subsequence since we only get
5082 here if the types we are converting from are the same. */
549121cd 5083
ceab47eb
MM
5084 while (TREE_CODE (ics1) == RVALUE_CONV
5085 || TREE_CODE (ics1) == LVALUE_CONV)
5086 ics1 = TREE_OPERAND (ics1, 0);
c73964b2 5087
ceab47eb 5088 while (1)
c73964b2 5089 {
ceab47eb
MM
5090 while (TREE_CODE (ics2) == RVALUE_CONV
5091 || TREE_CODE (ics2) == LVALUE_CONV)
5092 ics2 = TREE_OPERAND (ics2, 0);
c73964b2 5093
ceab47eb
MM
5094 if (TREE_CODE (ics2) == USER_CONV
5095 || TREE_CODE (ics2) == AMBIG_CONV
5096 || TREE_CODE (ics2) == IDENTITY_CONV)
5097 /* At this point, ICS1 cannot be a proper subsequence of
5098 ICS2. We can get a USER_CONV when we are comparing the
5099 second standard conversion sequence of two user conversion
5100 sequences. */
94be8403 5101 return false;
f62dbf03 5102
ceab47eb 5103 ics2 = TREE_OPERAND (ics2, 0);
653cc74a 5104
f62dbf03 5105 if (TREE_CODE (ics2) == TREE_CODE (ics1)
3bfdc719
MM
5106 && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1))
5107 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)),
5108 TREE_TYPE (TREE_OPERAND (ics1, 0))))
94be8403 5109 return true;
f62dbf03
JM
5110 }
5111}
5112
838dfd8a 5113/* Returns nonzero iff DERIVED is derived from BASE. The inputs may
ceab47eb 5114 be any _TYPE nodes. */
c73964b2 5115
94be8403
GDR
5116bool
5117is_properly_derived_from (tree derived, tree base)
c73964b2 5118{
ceab47eb
MM
5119 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5120 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
94be8403 5121 return false;
c73964b2 5122
ceab47eb
MM
5123 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5124 considers every class derived from itself. */
9edc3913 5125 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
ceab47eb
MM
5126 && DERIVED_FROM_P (base, derived));
5127}
d11ad92e 5128
ceab47eb
MM
5129/* We build the ICS for an implicit object parameter as a pointer
5130 conversion sequence. However, such a sequence should be compared
5131 as if it were a reference conversion sequence. If ICS is the
5132 implicit conversion sequence for an implicit object parameter,
5133 modify it accordingly. */
d11ad92e 5134
ceab47eb 5135static void
94be8403 5136maybe_handle_implicit_object (tree *ics)
ceab47eb
MM
5137{
5138 if (ICS_THIS_FLAG (*ics))
d11ad92e 5139 {
ceab47eb
MM
5140 /* [over.match.funcs]
5141
5142 For non-static member functions, the type of the
5143 implicit object parameter is "reference to cv X"
5144 where X is the class of which the function is a
5145 member and cv is the cv-qualification on the member
5146 function declaration. */
5147 tree t = *ics;
b0385db8
MM
5148 tree reference_type;
5149
5150 /* The `this' parameter is a pointer to a class type. Make the
34cd5ae7 5151 implicit conversion talk about a reference to that same class
b0385db8
MM
5152 type. */
5153 reference_type = TREE_TYPE (TREE_TYPE (*ics));
5154 reference_type = build_reference_type (reference_type);
5155
00c15f8d
MM
5156 if (TREE_CODE (t) == QUAL_CONV)
5157 t = TREE_OPERAND (t, 0);
6633d636
MS
5158 if (TREE_CODE (t) == PTR_CONV)
5159 t = TREE_OPERAND (t, 0);
5160 t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE);
b0385db8 5161 t = direct_reference_binding (reference_type, t);
ceab47eb 5162 *ics = t;
d11ad92e 5163 }
ceab47eb
MM
5164}
5165
2d2e8123
MM
5166/* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5167 and return the type to which the reference refers. Otherwise,
5168 leave *ICS unchanged and return NULL_TREE. */
ceab47eb 5169
2d2e8123 5170static tree
94be8403 5171maybe_handle_ref_bind (tree *ics)
ceab47eb
MM
5172{
5173 if (TREE_CODE (*ics) == REF_BIND)
d11ad92e 5174 {
351a0f00 5175 tree old_ics = *ics;
2d2e8123
MM
5176 tree type = TREE_TYPE (TREE_TYPE (old_ics));
5177 *ics = TREE_OPERAND (old_ics, 0);
351a0f00
JJ
5178 ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics);
5179 ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics);
2d2e8123 5180 return type;
d11ad92e 5181 }
351a0f00 5182
2d2e8123 5183 return NULL_TREE;
ceab47eb
MM
5184}
5185
5186/* Compare two implicit conversion sequences according to the rules set out in
5187 [over.ics.rank]. Return values:
d11ad92e 5188
ceab47eb
MM
5189 1: ics1 is better than ics2
5190 -1: ics2 is better than ics1
5191 0: ics1 and ics2 are indistinguishable */
5192
5193static int
94be8403 5194compare_ics (tree ics1, tree ics2)
ceab47eb
MM
5195{
5196 tree from_type1;
5197 tree from_type2;
5198 tree to_type1;
5199 tree to_type2;
5200 tree deref_from_type1 = NULL_TREE;
87603ed0
KG
5201 tree deref_from_type2 = NULL_TREE;
5202 tree deref_to_type1 = NULL_TREE;
5203 tree deref_to_type2 = NULL_TREE;
bea09693 5204 int rank1, rank2;
ceab47eb 5205
838dfd8a 5206 /* REF_BINDING is nonzero if the result of the conversion sequence
00c15f8d
MM
5207 is a reference type. In that case TARGET_TYPE is the
5208 type referred to by the reference. */
00c15f8d
MM
5209 tree target_type1;
5210 tree target_type2;
ceab47eb
MM
5211
5212 /* Handle implicit object parameters. */
5213 maybe_handle_implicit_object (&ics1);
5214 maybe_handle_implicit_object (&ics2);
5215
5216 /* Handle reference parameters. */
2d2e8123
MM
5217 target_type1 = maybe_handle_ref_bind (&ics1);
5218 target_type2 = maybe_handle_ref_bind (&ics2);
ceab47eb
MM
5219
5220 /* [over.ics.rank]
5221
5222 When comparing the basic forms of implicit conversion sequences (as
5223 defined in _over.best.ics_)
5224
5225 --a standard conversion sequence (_over.ics.scs_) is a better
5226 conversion sequence than a user-defined conversion sequence
5227 or an ellipsis conversion sequence, and
5228
5229 --a user-defined conversion sequence (_over.ics.user_) is a
5230 better conversion sequence than an ellipsis conversion sequence
5231 (_over.ics.ellipsis_). */
bea09693
NS
5232 rank1 = ICS_RANK (ics1);
5233 rank2 = ICS_RANK (ics2);
5234
5235 if (rank1 > rank2)
c73964b2 5236 return -1;
bea09693 5237 else if (rank1 < rank2)
c73964b2
MS
5238 return 1;
5239
bea09693 5240 if (rank1 == BAD_RANK)
d11ad92e 5241 {
bea09693 5242 /* XXX Isn't this an extension? */
ceab47eb
MM
5243 /* Both ICS are bad. We try to make a decision based on what
5244 would have happenned if they'd been good. */
d11ad92e
MS
5245 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
5246 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5247 return -1;
5248 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
5249 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5250 return 1;
5251
ceab47eb 5252 /* We couldn't make up our minds; try to figure it out below. */
d11ad92e
MS
5253 }
5254
ceab47eb
MM
5255 if (ICS_ELLIPSIS_FLAG (ics1))
5256 /* Both conversions are ellipsis conversions. */
5257 return 0;
5258
c73964b2
MS
5259 /* User-defined conversion sequence U1 is a better conversion sequence
5260 than another user-defined conversion sequence U2 if they contain the
5261 same user-defined conversion operator or constructor and if the sec-
5262 ond standard conversion sequence of U1 is better than the second
5263 standard conversion sequence of U2. */
5264
d11ad92e 5265 if (ICS_USER_FLAG (ics1))
c73964b2
MS
5266 {
5267 tree t1, t2;
5268
5269 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
5270 if (TREE_CODE (t1) == AMBIG_CONV)
5271 return 0;
5272 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
5273 if (TREE_CODE (t2) == AMBIG_CONV)
5274 return 0;
5275
5276 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
5277 return 0;
c73964b2 5278
ceab47eb
MM
5279 /* We can just fall through here, after setting up
5280 FROM_TYPE1 and FROM_TYPE2. */
5281 from_type1 = TREE_TYPE (t1);
5282 from_type2 = TREE_TYPE (t2);
c73964b2 5283 }
ceab47eb
MM
5284 else
5285 {
5286 /* We're dealing with two standard conversion sequences.
c73964b2 5287
ceab47eb
MM
5288 [over.ics.rank]
5289
5290 Standard conversion sequence S1 is a better conversion
5291 sequence than standard conversion sequence S2 if
5292
5293 --S1 is a proper subsequence of S2 (comparing the conversion
5294 sequences in the canonical form defined by _over.ics.scs_,
5295 excluding any Lvalue Transformation; the identity
5296 conversion sequence is considered to be a subsequence of
5297 any non-identity conversion sequence */
5298
5299 from_type1 = ics1;
5300 while (TREE_CODE (from_type1) != IDENTITY_CONV)
5301 from_type1 = TREE_OPERAND (from_type1, 0);
5302 from_type1 = TREE_TYPE (from_type1);
5303
5304 from_type2 = ics2;
5305 while (TREE_CODE (from_type2) != IDENTITY_CONV)
5306 from_type2 = TREE_OPERAND (from_type2, 0);
5307 from_type2 = TREE_TYPE (from_type2);
5308 }
c73964b2 5309
3bfdc719 5310 if (same_type_p (from_type1, from_type2))
f62dbf03 5311 {
ceab47eb 5312 if (is_subseq (ics1, ics2))
f62dbf03 5313 return 1;
ceab47eb 5314 if (is_subseq (ics2, ics1))
f62dbf03 5315 return -1;
f62dbf03 5316 }
961ec1a5
JM
5317 /* Otherwise, one sequence cannot be a subsequence of the other; they
5318 don't start with the same type. This can happen when comparing the
5319 second standard conversion sequence in two user-defined conversion
5320 sequences. */
c73964b2 5321
ceab47eb 5322 /* [over.ics.rank]
c73964b2 5323
ceab47eb 5324 Or, if not that,
c73964b2 5325
ceab47eb
MM
5326 --the rank of S1 is better than the rank of S2 (by the rules
5327 defined below):
c73964b2 5328
ceab47eb
MM
5329 Standard conversion sequences are ordered by their ranks: an Exact
5330 Match is a better conversion than a Promotion, which is a better
5331 conversion than a Conversion.
c73964b2 5332
ceab47eb
MM
5333 Two conversion sequences with the same rank are indistinguishable
5334 unless one of the following rules applies:
c73964b2 5335
ceab47eb
MM
5336 --A conversion that is not a conversion of a pointer, or pointer
5337 to member, to bool is better than another conversion that is such
5338 a conversion.
c73964b2 5339
ceab47eb
MM
5340 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5341 so that we do not have to check it explicitly. */
5342 if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5343 return 1;
5344 else if (ICS_STD_RANK (ics2) < ICS_STD_RANK (ics1))
5345 return -1;
c73964b2 5346
ceab47eb
MM
5347 to_type1 = TREE_TYPE (ics1);
5348 to_type2 = TREE_TYPE (ics2);
c73964b2 5349
ceab47eb
MM
5350 if (TYPE_PTR_P (from_type1)
5351 && TYPE_PTR_P (from_type2)
5352 && TYPE_PTR_P (to_type1)
5353 && TYPE_PTR_P (to_type2))
5354 {
5355 deref_from_type1 = TREE_TYPE (from_type1);
5356 deref_from_type2 = TREE_TYPE (from_type2);
5357 deref_to_type1 = TREE_TYPE (to_type1);
5358 deref_to_type2 = TREE_TYPE (to_type2);
5359 }
5360 /* The rules for pointers to members A::* are just like the rules
5361 for pointers A*, except opposite: if B is derived from A then
5362 A::* converts to B::*, not vice versa. For that reason, we
5363 switch the from_ and to_ variables here. */
5364 else if (TYPE_PTRMEM_P (from_type1)
5365 && TYPE_PTRMEM_P (from_type2)
5366 && TYPE_PTRMEM_P (to_type1)
5367 && TYPE_PTRMEM_P (to_type2))
5368 {
5369 deref_to_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type1));
5370 deref_to_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type2));
5371 deref_from_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type1));
5372 deref_from_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type2));
5373 }
5374 else if (TYPE_PTRMEMFUNC_P (from_type1)
5375 && TYPE_PTRMEMFUNC_P (from_type2)
5376 && TYPE_PTRMEMFUNC_P (to_type1)
5377 && TYPE_PTRMEMFUNC_P (to_type2))
5378 {
5379 deref_to_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type1);
5380 deref_to_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type2);
5381 deref_from_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type1);
5382 deref_from_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type2);
5383 }
c73964b2 5384
ceab47eb
MM
5385 if (deref_from_type1 != NULL_TREE
5386 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5387 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5388 {
5389 /* This was one of the pointer or pointer-like conversions.
5390
5391 [over.ics.rank]
5392
5393 --If class B is derived directly or indirectly from class A,
5394 conversion of B* to A* is better than conversion of B* to
5395 void*, and conversion of A* to void* is better than
5396 conversion of B* to void*. */
5397 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5398 && TREE_CODE (deref_to_type2) == VOID_TYPE)
c73964b2 5399 {
ceab47eb
MM
5400 if (is_properly_derived_from (deref_from_type1,
5401 deref_from_type2))
c73964b2 5402 return -1;
ceab47eb
MM
5403 else if (is_properly_derived_from (deref_from_type2,
5404 deref_from_type1))
5405 return 1;
c73964b2 5406 }
ceab47eb
MM
5407 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5408 || TREE_CODE (deref_to_type2) == VOID_TYPE)
c73964b2 5409 {
3bfdc719 5410 if (same_type_p (deref_from_type1, deref_from_type2))
ceab47eb
MM
5411 {
5412 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5413 {
5414 if (is_properly_derived_from (deref_from_type1,
5415 deref_to_type1))
5416 return 1;
5417 }
5418 /* We know that DEREF_TO_TYPE1 is `void' here. */
5419 else if (is_properly_derived_from (deref_from_type1,
5420 deref_to_type2))
5421 return -1;
5422 }
c73964b2 5423 }
ceab47eb
MM
5424 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5425 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
c73964b2 5426 {
ceab47eb
MM
5427 /* [over.ics.rank]
5428
5429 --If class B is derived directly or indirectly from class A
5430 and class C is derived directly or indirectly from B,
5431
5432 --conversion of C* to B* is better than conversion of C* to
5433 A*,
5434
5435 --conversion of B* to A* is better than conversion of C* to
5436 A* */
3bfdc719 5437 if (same_type_p (deref_from_type1, deref_from_type2))
ceab47eb
MM
5438 {
5439 if (is_properly_derived_from (deref_to_type1,
5440 deref_to_type2))
5441 return 1;
5442 else if (is_properly_derived_from (deref_to_type2,
5443 deref_to_type1))
5444 return -1;
5445 }
3bfdc719 5446 else if (same_type_p (deref_to_type1, deref_to_type2))
ceab47eb
MM
5447 {
5448 if (is_properly_derived_from (deref_from_type2,
5449 deref_from_type1))
5450 return 1;
5451 else if (is_properly_derived_from (deref_from_type1,
5452 deref_from_type2))
5453 return -1;
5454 }
c73964b2 5455 }
ceab47eb 5456 }
2d2e8123 5457 else if (CLASS_TYPE_P (non_reference (from_type1))
3bfdc719 5458 && same_type_p (from_type1, from_type2))
ceab47eb 5459 {
2d2e8123
MM
5460 tree from = non_reference (from_type1);
5461
ceab47eb
MM
5462 /* [over.ics.rank]
5463
5464 --binding of an expression of type C to a reference of type
5465 B& is better than binding an expression of type C to a
5466 reference of type A&
5467
5468 --conversion of C to B is better than conversion of C to A, */
2d2e8123
MM
5469 if (is_properly_derived_from (from, to_type1)
5470 && is_properly_derived_from (from, to_type2))
c73964b2 5471 {
ceab47eb 5472 if (is_properly_derived_from (to_type1, to_type2))
c73964b2 5473 return 1;
ceab47eb 5474 else if (is_properly_derived_from (to_type2, to_type1))
c73964b2
MS
5475 return -1;
5476 }
5477 }
2d2e8123 5478 else if (CLASS_TYPE_P (non_reference (to_type1))
3bfdc719 5479 && same_type_p (to_type1, to_type2))
c73964b2 5480 {
2d2e8123
MM
5481 tree to = non_reference (to_type1);
5482
ceab47eb 5483 /* [over.ics.rank]
c73964b2 5484
ceab47eb
MM
5485 --binding of an expression of type B to a reference of type
5486 A& is better than binding an expression of type C to a
5487 reference of type A&,
5488
5489 --onversion of B to A is better than conversion of C to A */
2d2e8123
MM
5490 if (is_properly_derived_from (from_type1, to)
5491 && is_properly_derived_from (from_type2, to))
ceab47eb
MM
5492 {
5493 if (is_properly_derived_from (from_type2, from_type1))
5494 return 1;
5495 else if (is_properly_derived_from (from_type1, from_type2))
5496 return -1;
5497 }
c73964b2
MS
5498 }
5499
ceab47eb
MM
5500 /* [over.ics.rank]
5501
5502 --S1 and S2 differ only in their qualification conversion and yield
5503 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5504 qualification signature of type T1 is a proper subset of the cv-
5505 qualification signature of type T2 */
5506 if (TREE_CODE (ics1) == QUAL_CONV
5507 && TREE_CODE (ics2) == QUAL_CONV
3bfdc719 5508 && same_type_p (from_type1, from_type2))
ceab47eb
MM
5509 return comp_cv_qual_signature (to_type1, to_type2);
5510
5511 /* [over.ics.rank]
5512
5513 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5514 types to which the references refer are the same type except for
5515 top-level cv-qualifiers, and the type to which the reference
5516 initialized by S2 refers is more cv-qualified than the type to
5517 which the reference initialized by S1 refers */
5518
2d2e8123 5519 if (target_type1 && target_type2
9edc3913 5520 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
00c15f8d 5521 return comp_cv_qualification (target_type2, target_type1);
ceab47eb
MM
5522
5523 /* Neither conversion sequence is better than the other. */
c73964b2
MS
5524 return 0;
5525}
5526
03e70705
JM
5527/* The source type for this standard conversion sequence. */
5528
8e69329a 5529static tree
94be8403 5530source_type (tree t)
8e69329a
JM
5531{
5532 for (;; t = TREE_OPERAND (t, 0))
5533 {
5534 if (TREE_CODE (t) == USER_CONV
5535 || TREE_CODE (t) == AMBIG_CONV
5536 || TREE_CODE (t) == IDENTITY_CONV)
5537 return TREE_TYPE (t);
5538 }
a98facb0 5539 abort ();
8e69329a 5540}
5ffe581d
JM
5541
5542/* Note a warning about preferring WINNER to LOSER. We do this by storing
5543 a pointer to LOSER and re-running joust to produce the warning if WINNER
5544 is actually used. */
5545
5546static void
94be8403 5547add_warning (struct z_candidate *winner, struct z_candidate *loser)
5ffe581d 5548{
3e411c3f 5549 winner->warnings = tree_cons (NULL_TREE,
e2500fed 5550 build_zc_wrapper (loser),
e1b3e07d 5551 winner->warnings);
5ffe581d 5552}
8e69329a 5553
c73964b2
MS
5554/* Compare two candidates for overloading as described in
5555 [over.match.best]. Return values:
5556
5557 1: cand1 is better than cand2
5558 -1: cand2 is better than cand1
5559 0: cand1 and cand2 are indistinguishable */
5560
5561static int
94be8403 5562joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
c73964b2
MS
5563{
5564 int winner = 0;
5565 int i, off1 = 0, off2 = 0, len;
5566
d11ad92e
MS
5567 /* Candidates that involve bad conversions are always worse than those
5568 that don't. */
5569 if (cand1->viable > cand2->viable)
5570 return 1;
5571 if (cand1->viable < cand2->viable)
5572 return -1;
5573
37b6eb34 5574 /* If we have two pseudo-candidates for conversions to the same type,
6e9dcc25
JM
5575 or two candidates for the same function, arbitrarily pick one. */
5576 if (cand1->fn == cand2->fn
5577 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
37b6eb34
JM
5578 return 1;
5579
c73964b2
MS
5580 /* a viable function F1
5581 is defined to be a better function than another viable function F2 if
5582 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5583 ICSi(F2), and then */
5584
5585 /* for some argument j, ICSj(F1) is a better conversion sequence than
5586 ICSj(F2) */
5587
cab1f180
ML
5588 /* For comparing static and non-static member functions, we ignore
5589 the implicit object parameter of the non-static function. The
5590 standard says to pretend that the static function has an object
5591 parm, but that won't work with operator overloading. */
c73964b2
MS
5592 len = TREE_VEC_LENGTH (cand1->convs);
5593 if (len != TREE_VEC_LENGTH (cand2->convs))
5594 {
5595 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5596 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5597 off2 = 1;
5598 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5599 && DECL_STATIC_FUNCTION_P (cand2->fn))
5600 {
5601 off1 = 1;
5602 --len;
5603 }
5604 else
a98facb0 5605 abort ();
c73964b2
MS
5606 }
5607
5608 for (i = 0; i < len; ++i)
5609 {
da20811c
JM
5610 tree t1 = TREE_VEC_ELT (cand1->convs, i+off1);
5611 tree t2 = TREE_VEC_ELT (cand2->convs, i+off2);
5612 int comp = compare_ics (t1, t2);
c73964b2
MS
5613
5614 if (comp != 0)
5615 {
da20811c
JM
5616 if (warn_sign_promo
5617 && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK
5618 && TREE_CODE (t1) == STD_CONV
5619 && TREE_CODE (t2) == STD_CONV
5620 && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE
5621 && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE
5622 && (TYPE_PRECISION (TREE_TYPE (t1))
5623 == TYPE_PRECISION (TREE_TYPE (t2)))
5624 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0)))
5625 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0)))
5626 == ENUMERAL_TYPE)))
5627 {
5628 tree type = TREE_TYPE (TREE_OPERAND (t1, 0));
5629 tree type1, type2;
5ffe581d 5630 struct z_candidate *w, *l;
da20811c 5631 if (comp > 0)
5ffe581d
JM
5632 type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2),
5633 w = cand1, l = cand2;
da20811c 5634 else
5ffe581d
JM
5635 type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1),
5636 w = cand2, l = cand1;
da20811c 5637
5ffe581d
JM
5638 if (warn)
5639 {
33bd39a2 5640 warning ("passing `%T' chooses `%T' over `%T'",
5ffe581d 5641 type, type1, type2);
33bd39a2 5642 warning (" in call to `%D'", w->fn);
5ffe581d
JM
5643 }
5644 else
5645 add_warning (w, l);
da20811c
JM
5646 }
5647
c73964b2 5648 if (winner && comp != winner)
c11b6f21
MS
5649 {
5650 winner = 0;
5651 goto tweak;
5652 }
c73964b2
MS
5653 winner = comp;
5654 }
5655 }
5656
9a68c51f
JM
5657 /* warn about confusing overload resolution for user-defined conversions,
5658 either between a constructor and a conversion op, or between two
5659 conversion ops. */
2e2d4075 5660 if (winner && warn_conversion && cand1->second_conv
f8986275
NS
5661 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5662 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5663 {
5664 struct z_candidate *w, *l;
5665 bool give_warning = false;
5666
5667 if (winner == 1)
5668 w = cand1, l = cand2;
5669 else
5670 w = cand2, l = cand1;
5671
5672 /* We don't want to complain about `X::operator T1 ()'
5673 beating `X::operator T2 () const', when T2 is a no less
9bcb9aae 5674 cv-qualified version of T1. */
f8986275
NS
5675 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5676 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
8e69329a 5677 {
f8986275
NS
5678 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5679 tree f = TREE_TYPE (TREE_TYPE (w->fn));
5680
5681 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
5ffe581d 5682 {
f8986275
NS
5683 t = TREE_TYPE (t);
5684 f = TREE_TYPE (f);
5ffe581d 5685 }
f8986275
NS
5686 if (!comp_ptr_ttypes (t, f))
5687 give_warning = true;
5688 }
5689 else
5690 give_warning = true;
5691
5692 if (!give_warning)
5693 /*NOP*/;
2e2d4075 5694 else if (warn)
f8986275
NS
5695 {
5696 tree source = source_type (TREE_VEC_ELT (w->convs, 0));
5697 if (! DECL_CONSTRUCTOR_P (w->fn))
5698 source = TREE_TYPE (source);
5699 warning ("choosing `%D' over `%D'", w->fn, l->fn);
5700 warning (" for conversion from `%T' to `%T'",
5701 source, TREE_TYPE (w->second_conv));
5702 warning (" because conversion sequence for the argument is better");
8e69329a 5703 }
f8986275
NS
5704 else
5705 add_warning (w, l);
8e69329a
JM
5706 }
5707
c73964b2
MS
5708 if (winner)
5709 return winner;
5710
e5596aef
NS
5711 /* or, if not that,
5712 F1 is a non-template function and F2 is a template function
5713 specialization. */
5714
c73964b2
MS
5715 if (! cand1->template && cand2->template)
5716 return 1;
5717 else if (cand1->template && ! cand2->template)
5718 return -1;
e5596aef
NS
5719
5720 /* or, if not that,
5721 F1 and F2 are template functions and the function template for F1 is
5722 more specialized than the template for F2 according to the partial
5723 ordering rules. */
5724
5725 if (cand1->template && cand2->template)
4cff6abe
NS
5726 {
5727 winner = more_specialized
5728 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
5729 DEDUCE_ORDER,
fe730161
JO
5730 /* Tell the deduction code how many real function arguments
5731 we saw, not counting the implicit 'this' argument. But,
5732 add_function_candidate() suppresses the "this" argument
5733 for constructors.
d9579a59
JM
5734
5735 [temp.func.order]: The presence of unused ellipsis and default
5736 arguments has no effect on the partial ordering of function
5737 templates. */
4cff6abe 5738 TREE_VEC_LENGTH (cand1->convs)
fe730161
JO
5739 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
5740 - DECL_CONSTRUCTOR_P (cand1->fn)));
4cff6abe
NS
5741 if (winner)
5742 return winner;
5743 }
c73964b2
MS
5744
5745 /* or, if not that,
5746 the context is an initialization by user-defined conversion (see
5747 _dcl.init_ and _over.match.user_) and the standard conversion
5748 sequence from the return type of F1 to the destination type (i.e.,
5749 the type of the entity being initialized) is a better conversion
5750 sequence than the standard conversion sequence from the return type
5751 of F2 to the destination type. */
5752
4cff6abe
NS
5753 if (cand1->second_conv)
5754 {
5755 winner = compare_ics (cand1->second_conv, cand2->second_conv);
5756 if (winner)
5757 return winner;
5758 }
5759
08ac397c
JM
5760 /* Check whether we can discard a builtin candidate, either because we
5761 have two identical ones or matching builtin and non-builtin candidates.
5762
5763 (Pedantically in the latter case the builtin which matched the user
5764 function should not be added to the overload set, but we spot it here.
5765
5766 [over.match.oper]
5767 ... the builtin candidates include ...
5768 - do not have the same parameter type list as any non-template
5769 non-member candidate. */
5770
5771 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
5772 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
c73964b2 5773 {
c11b6f21 5774 for (i = 0; i < len; ++i)
3bfdc719
MM
5775 if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)),
5776 TREE_TYPE (TREE_VEC_ELT (cand2->convs, i))))
c73964b2
MS
5777 break;
5778 if (i == TREE_VEC_LENGTH (cand1->convs))
08ac397c
JM
5779 {
5780 if (cand1->fn == cand2->fn)
5781 /* Two built-in candidates; arbitrarily pick one. */
5782 return 1;
5783 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
5784 /* cand1 is built-in; prefer cand2. */
5785 return -1;
5786 else
5787 /* cand2 is built-in; prefer cand1. */
5788 return 1;
5789 }
c73964b2
MS
5790 }
5791
2c169bab
JM
5792 /* If the two functions are the same (this can happen with declarations
5793 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
5794 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
5795 && equal_functions (cand1->fn, cand2->fn))
5796 return 1;
436f8a4c 5797
c11b6f21
MS
5798tweak:
5799
5800 /* Extension: If the worst conversion for one candidate is worse than the
5801 worst conversion for the other, take the first. */
4cff6abe 5802 if (!pedantic)
c11b6f21
MS
5803 {
5804 int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK;
ae0ed63a 5805 struct z_candidate *w = 0, *l = 0;
c11b6f21
MS
5806
5807 for (i = 0; i < len; ++i)
5808 {
5809 if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1)
5810 rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1));
5811 if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2)
5812 rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2));
5813 }
c11b6f21 5814 if (rank1 < rank2)
f86fdf68 5815 winner = 1, w = cand1, l = cand2;
c11b6f21 5816 if (rank1 > rank2)
f86fdf68
NS
5817 winner = -1, w = cand2, l = cand1;
5818 if (winner)
5819 {
5820 if (warn)
5821 {
d2a6f3c0
ZW
5822 pedwarn ("\
5823ISO C++ says that these are ambiguous, even \
5824though the worst conversion for the first is better than \
5825the worst conversion for the second:");
5826 print_z_candidate (_("candidate 1:"), w);
5827 print_z_candidate (_("candidate 2:"), l);
f86fdf68
NS
5828 }
5829 else
5830 add_warning (w, l);
5831 return winner;
5832 }
c11b6f21
MS
5833 }
5834
4cff6abe
NS
5835 my_friendly_assert (!winner, 20010121);
5836 return 0;
c73964b2
MS
5837}
5838
5839/* Given a list of candidates for overloading, find the best one, if any.
5840 This algorithm has a worst case of O(2n) (winner is last), and a best
5841 case of O(n/2) (totally ambiguous); much better than a sorting
5842 algorithm. */
5843
5844static struct z_candidate *
94be8403 5845tourney (struct z_candidate *candidates)
c73964b2
MS
5846{
5847 struct z_candidate *champ = candidates, *challenger;
5848 int fate;
b265c11a 5849 int champ_compared_to_predecessor = 0;
c73964b2
MS
5850
5851 /* Walk through the list once, comparing each current champ to the next
5852 candidate, knocking out a candidate or two with each comparison. */
5853
5854 for (challenger = champ->next; challenger; )
5855 {
5ffe581d 5856 fate = joust (champ, challenger, 0);
c73964b2
MS
5857 if (fate == 1)
5858 challenger = challenger->next;
5859 else
5860 {
5861 if (fate == 0)
5862 {
5863 champ = challenger->next;
5864 if (champ == 0)
5865 return 0;
b265c11a 5866 champ_compared_to_predecessor = 0;
c73964b2
MS
5867 }
5868 else
b265c11a
MM
5869 {
5870 champ = challenger;
5871 champ_compared_to_predecessor = 1;
5872 }
c73964b2
MS
5873
5874 challenger = champ->next;
5875 }
5876 }
5877
5878 /* Make sure the champ is better than all the candidates it hasn't yet
b265c11a 5879 been compared to. */
c73964b2 5880
b265c11a
MM
5881 for (challenger = candidates;
5882 challenger != champ
5883 && !(champ_compared_to_predecessor && challenger->next == champ);
c73964b2
MS
5884 challenger = challenger->next)
5885 {
5ffe581d 5886 fate = joust (champ, challenger, 0);
c73964b2
MS
5887 if (fate != 1)
5888 return 0;
5889 }
5890
5891 return champ;
5892}
c11b6f21 5893
838dfd8a 5894/* Returns nonzero if things of type FROM can be converted to TO. */
4143af33 5895
94be8403
GDR
5896bool
5897can_convert (tree to, tree from)
c11b6f21 5898{
a7a64a77 5899 return can_convert_arg (to, from, NULL_TREE);
c11b6f21
MS
5900}
5901
838dfd8a 5902/* Returns nonzero if ARG (of type FROM) can be converted to TO. */
4143af33 5903
94be8403
GDR
5904bool
5905can_convert_arg (tree to, tree from, tree arg)
c11b6f21 5906{
277294d7
JM
5907 tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
5908 return (t && ! ICS_BAD_FLAG (t));
c11b6f21 5909}
27b8d0cd 5910
72a08131
JM
5911/* Like can_convert_arg, but allows dubious conversions as well. */
5912
94be8403
GDR
5913bool
5914can_convert_arg_bad (tree to, tree from, tree arg)
72a08131 5915{
94be8403 5916 return implicit_conversion (to, from, arg, LOOKUP_NORMAL) != 0;
72a08131
JM
5917}
5918
5919/* Convert EXPR to TYPE. Return the converted expression.
5920
5921 Note that we allow bad conversions here because by the time we get to
5922 this point we are committed to doing the conversion. If we end up
5923 doing a bad conversion, convert_like will complain. */
4143af33 5924
a7a64a77 5925tree
94be8403 5926perform_implicit_conversion (tree type, tree expr)
a7a64a77 5927{
b5534c65
NS
5928 tree conv;
5929
a723baf1 5930 if (error_operand_p (expr))
b5534c65
NS
5931 return error_mark_node;
5932 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
5933 LOOKUP_NORMAL);
72a08131 5934 if (!conv)
a7a64a77 5935 {
33bd39a2 5936 error ("could not convert `%E' to `%T'", expr, type);
a7a64a77
MM
5937 return error_mark_node;
5938 }
5939
5940 return convert_like (conv, expr);
5941}
5942
3fe18f1d
MM
5943/* Convert EXPR to TYPE (as a direct-initialization) if that is
5944 permitted. If the conversion is valid, the converted expression is
5945 returned. Otherwise, NULL_TREE is returned. */
5946
5947tree
5948perform_direct_initialization_if_possible (tree type, tree expr)
5949{
5950 tree conv;
5951
5952 if (type == error_mark_node || error_operand_p (expr))
5953 return error_mark_node;
5954 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
5955 LOOKUP_NORMAL);
5956 if (!conv || ICS_BAD_FLAG (conv))
5957 return NULL_TREE;
5958 return convert_like_real (conv, expr, NULL_TREE, 0, 0,
5959 /*issue_conversion_warnings=*/false);
5960}
5961
7993382e
MM
5962/* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
5963 is being bound to a temporary. Create and return a new VAR_DECL
aa6e8ed3
MM
5964 with the indicated TYPE; this variable will store the value to
5965 which the reference is bound. */
7993382e
MM
5966
5967tree
aa6e8ed3 5968make_temporary_var_for_ref_to_temp (tree decl, tree type)
7993382e 5969{
7993382e
MM
5970 tree var;
5971
7993382e
MM
5972 /* Create the variable. */
5973 var = build_decl (VAR_DECL, NULL_TREE, type);
5974 DECL_ARTIFICIAL (var) = 1;
5975 TREE_USED (var) = 1;
5976
5977 /* Register the variable. */
5978 if (TREE_STATIC (decl))
5979 {
5980 /* Namespace-scope or local static; give it a mangled name. */
5981 tree name;
5982
5983 TREE_STATIC (var) = 1;
5984 name = mangle_ref_init_variable (decl);
5985 DECL_NAME (var) = name;
5986 SET_DECL_ASSEMBLER_NAME (var, name);
5987 var = pushdecl_top_level (var);
5988 }
5989 else
5990 {
5991 /* Create a new cleanup level if necessary. */
5992 maybe_push_cleanup_level (type);
5993 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
5994 DECL_CONTEXT (var) = current_function_decl;
5995 }
5996
5997 return var;
5998}
5999
27b8d0cd 6000/* Convert EXPR to the indicated reference TYPE, in a way suitable for
7993382e
MM
6001 initializing a variable of that TYPE. If DECL is non-NULL, it is
6002 the VAR_DECL being initialized with the EXPR. (In that case, the
6003 type of DECL will be TYPE.)
6004
6005 Return the converted expression. */
27b8d0cd
MM
6006
6007tree
7993382e 6008initialize_reference (tree type, tree expr, tree decl)
27b8d0cd
MM
6009{
6010 tree conv;
7993382e
MM
6011
6012 if (type == error_mark_node || error_operand_p (expr))
6013 return error_mark_node;
27b8d0cd 6014
aa6e8ed3 6015 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
27b8d0cd
MM
6016 if (!conv || ICS_BAD_FLAG (conv))
6017 {
33bd39a2 6018 error ("could not convert `%E' to `%T'", expr, type);
27b8d0cd
MM
6019 return error_mark_node;
6020 }
6021
7993382e
MM
6022 /* If DECL is non-NULL, then this special rule applies:
6023
6024 [class.temporary]
6025
6026 The temporary to which the reference is bound or the temporary
aa6e8ed3 6027 that is the complete object to which the reference is bound
7993382e
MM
6028 persists for the lifetime of the reference.
6029
6030 The temporaries created during the evaluation of the expression
6031 initializing the reference, except the temporary to which the
6032 reference is bound, are destroyed at the end of the
6033 full-expression in which they are created.
6034
6035 In that case, we store the converted expression into a new
aa6e8ed3
MM
6036 VAR_DECL in a new scope.
6037
6038 However, we want to be careful not to create temporaries when
6039 they are not required. For example, given:
6040
6041 struct B {};
6042 struct D : public B {};
6043 D f();
6044 const B& b = f();
6045
6046 there is no need to copy the return value from "f"; we can just
6047 extend its lifetime. Similarly, given:
6048
6049 struct S {};
6050 struct T { operator S(); };
6051 T t;
6052 const S& s = t;
6053
170b020f 6054 we can extend the lifetime of the return value of the conversion
aa6e8ed3 6055 operator. */
7993382e 6056 my_friendly_assert (TREE_CODE (conv) == REF_BIND, 20030302);
aa6e8ed3 6057 if (decl)
7993382e
MM
6058 {
6059 tree var;
aa6e8ed3 6060 tree base_conv_type;
7993382e 6061
aa6e8ed3
MM
6062 /* Skip over the REF_BIND. */
6063 conv = TREE_OPERAND (conv, 0);
6064 /* If the next conversion is a BASE_CONV, skip that too -- but
6065 remember that the conversion was required. */
26f86471 6066 if (TREE_CODE (conv) == BASE_CONV && !NEED_TEMPORARY_P (conv))
aa6e8ed3 6067 {
aa6e8ed3
MM
6068 base_conv_type = TREE_TYPE (conv);
6069 conv = TREE_OPERAND (conv, 0);
6070 }
6071 else
6072 base_conv_type = NULL_TREE;
6073 /* Perform the remainder of the conversion. */
6074 expr = convert_like (conv, expr);
6075 if (!real_non_cast_lvalue_p (expr))
6076 {
170b020f
MM
6077 tree init;
6078 tree type;
6079
aa6e8ed3 6080 /* Create the temporary variable. */
170b020f
MM
6081 type = TREE_TYPE (expr);
6082 var = make_temporary_var_for_ref_to_temp (decl, type);
6083 layout_decl (var, 0);
6084 if (at_function_scope_p ())
6085 {
6086 tree cleanup;
6087
6088 add_decl_stmt (var);
6089 cleanup = cxx_maybe_build_cleanup (var);
6090 if (cleanup)
6091 finish_decl_cleanup (var, cleanup);
6092 }
6093 else
6094 {
6095 rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof);
6096 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6097 static_aggregates = tree_cons (NULL_TREE, var,
6098 static_aggregates);
6099 }
6100 init = build (INIT_EXPR, type, var, expr);
aa6e8ed3
MM
6101 /* Use its address to initialize the reference variable. */
6102 expr = build_address (var);
170b020f 6103 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
aa6e8ed3
MM
6104 }
6105 else
6106 /* Take the address of EXPR. */
6107 expr = build_unary_op (ADDR_EXPR, expr, 0);
6108 /* If a BASE_CONV was required, perform it now. */
6109 if (base_conv_type)
6110 expr = (perform_implicit_conversion
6111 (build_pointer_type (base_conv_type), expr));
6112 return build_nop (type, expr);
7993382e
MM
6113 }
6114
6115 /* Perform the conversion. */
27b8d0cd
MM
6116 return convert_like (conv, expr);
6117}
e2500fed
GK
6118
6119#include "gt-cp-call.h"