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