|
111
|
1 /* Language-level data type conversion for GNU C++.
|
|
145
|
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
|
|
111
|
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify
|
|
|
8 it under the terms of the GNU General Public License as published by
|
|
|
9 the Free Software Foundation; either version 3, or (at your option)
|
|
|
10 any later version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful,
|
|
|
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
15 GNU General Public License for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21
|
|
|
22 /* This file contains the functions for converting C++ expressions
|
|
|
23 to different data types. The only entry point is `convert'.
|
|
|
24 Every language front end must have a `convert' function
|
|
|
25 but what kind of conversions it does will depend on the language. */
|
|
|
26
|
|
|
27 #include "config.h"
|
|
|
28 #include "system.h"
|
|
|
29 #include "coretypes.h"
|
|
|
30 #include "target.h"
|
|
|
31 #include "cp-tree.h"
|
|
|
32 #include "stor-layout.h"
|
|
|
33 #include "flags.h"
|
|
|
34 #include "intl.h"
|
|
|
35 #include "convert.h"
|
|
|
36 #include "stringpool.h"
|
|
|
37 #include "attribs.h"
|
|
145
|
38 #include "escaped_string.h"
|
|
111
|
39
|
|
|
40 static tree convert_to_pointer_force (tree, tree, tsubst_flags_t);
|
|
|
41 static tree build_type_conversion (tree, tree);
|
|
|
42 static tree build_up_reference (tree, tree, int, tree, tsubst_flags_t);
|
|
|
43 static void diagnose_ref_binding (location_t, tree, tree, tree);
|
|
|
44
|
|
|
45 /* Change of width--truncation and extension of integers or reals--
|
|
|
46 is represented with NOP_EXPR. Proper functioning of many things
|
|
|
47 assumes that no other conversions can be NOP_EXPRs.
|
|
|
48
|
|
|
49 Conversion between integer and pointer is represented with CONVERT_EXPR.
|
|
|
50 Converting integer to real uses FLOAT_EXPR
|
|
|
51 and real to integer uses FIX_TRUNC_EXPR.
|
|
|
52
|
|
|
53 Here is a list of all the functions that assume that widening and
|
|
|
54 narrowing is always done with a NOP_EXPR:
|
|
|
55 In convert.c, convert_to_integer[_maybe_fold].
|
|
|
56 In c-typeck.c, build_binary_op_nodefault (boolean ops),
|
|
|
57 and c_common_truthvalue_conversion.
|
|
|
58 In expr.c: expand_expr, for operands of a MULT_EXPR.
|
|
|
59 In fold-const.c: fold.
|
|
|
60 In tree.c: get_narrower and get_unwidened.
|
|
|
61
|
|
|
62 C++: in multiple-inheritance, converting between pointers may involve
|
|
|
63 adjusting them by a delta stored within the class definition. */
|
|
|
64
|
|
|
65 /* Subroutines of `convert'. */
|
|
|
66
|
|
|
67 /* if converting pointer to pointer
|
|
|
68 if dealing with classes, check for derived->base or vice versa
|
|
|
69 else if dealing with method pointers, delegate
|
|
|
70 else convert blindly
|
|
|
71 else if converting class, pass off to build_type_conversion
|
|
|
72 else try C-style pointer conversion. */
|
|
|
73
|
|
|
74 static tree
|
|
|
75 cp_convert_to_pointer (tree type, tree expr, bool dofold,
|
|
|
76 tsubst_flags_t complain)
|
|
|
77 {
|
|
|
78 tree intype = TREE_TYPE (expr);
|
|
|
79 enum tree_code form;
|
|
|
80 tree rval;
|
|
145
|
81 location_t loc = cp_expr_loc_or_input_loc (expr);
|
|
111
|
82
|
|
|
83 if (intype == error_mark_node)
|
|
|
84 return error_mark_node;
|
|
|
85
|
|
|
86 if (MAYBE_CLASS_TYPE_P (intype))
|
|
|
87 {
|
|
|
88 intype = complete_type (intype);
|
|
|
89 if (!COMPLETE_TYPE_P (intype))
|
|
|
90 {
|
|
|
91 if (complain & tf_error)
|
|
145
|
92 error_at (loc, "cannot convert from incomplete type %qH to %qI",
|
|
111
|
93 intype, type);
|
|
|
94 return error_mark_node;
|
|
|
95 }
|
|
|
96
|
|
|
97 rval = build_type_conversion (type, expr);
|
|
|
98 if (rval)
|
|
|
99 {
|
|
|
100 if ((complain & tf_error)
|
|
|
101 && rval == error_mark_node)
|
|
|
102 error_at (loc, "conversion of %qE from %qH to %qI is ambiguous",
|
|
|
103 expr, intype, type);
|
|
|
104 return rval;
|
|
|
105 }
|
|
|
106 }
|
|
|
107
|
|
|
108 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
|
|
|
109 if (TYPE_PTR_P (type)
|
|
|
110 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
|
|
|
111 || VOID_TYPE_P (TREE_TYPE (type))))
|
|
|
112 {
|
|
|
113 if (TYPE_PTRMEMFUNC_P (intype)
|
|
|
114 || TREE_CODE (intype) == METHOD_TYPE)
|
|
|
115 return convert_member_func_to_ptr (type, expr, complain);
|
|
|
116 if (TYPE_PTR_P (TREE_TYPE (expr)))
|
|
|
117 return build_nop (type, expr);
|
|
|
118 intype = TREE_TYPE (expr);
|
|
|
119 }
|
|
|
120
|
|
|
121 if (expr == error_mark_node)
|
|
|
122 return error_mark_node;
|
|
|
123
|
|
|
124 form = TREE_CODE (intype);
|
|
|
125
|
|
131
|
126 if (INDIRECT_TYPE_P (intype))
|
|
111
|
127 {
|
|
|
128 intype = TYPE_MAIN_VARIANT (intype);
|
|
|
129
|
|
|
130 if (TYPE_MAIN_VARIANT (type) != intype
|
|
|
131 && TYPE_PTR_P (type)
|
|
|
132 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
|
|
|
133 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
|
|
|
134 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
|
|
|
135 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
|
|
|
136 {
|
|
|
137 enum tree_code code = PLUS_EXPR;
|
|
|
138 tree binfo;
|
|
|
139 tree intype_class;
|
|
|
140 tree type_class;
|
|
|
141 bool same_p;
|
|
|
142
|
|
|
143 intype_class = TREE_TYPE (intype);
|
|
|
144 type_class = TREE_TYPE (type);
|
|
|
145
|
|
|
146 same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class),
|
|
|
147 TYPE_MAIN_VARIANT (type_class));
|
|
|
148 binfo = NULL_TREE;
|
|
|
149 /* Try derived to base conversion. */
|
|
|
150 if (!same_p)
|
|
|
151 binfo = lookup_base (intype_class, type_class, ba_check,
|
|
|
152 NULL, complain);
|
|
|
153 if (!same_p && !binfo)
|
|
|
154 {
|
|
|
155 /* Try base to derived conversion. */
|
|
|
156 binfo = lookup_base (type_class, intype_class, ba_check,
|
|
|
157 NULL, complain);
|
|
|
158 code = MINUS_EXPR;
|
|
|
159 }
|
|
|
160 if (binfo == error_mark_node)
|
|
|
161 return error_mark_node;
|
|
|
162 if (binfo || same_p)
|
|
|
163 {
|
|
|
164 if (binfo)
|
|
|
165 expr = build_base_path (code, expr, binfo, 0, complain);
|
|
|
166 /* Add any qualifier conversions. */
|
|
|
167 return build_nop (type, expr);
|
|
|
168 }
|
|
|
169 }
|
|
|
170
|
|
|
171 if (TYPE_PTRMEMFUNC_P (type))
|
|
|
172 {
|
|
|
173 if (complain & tf_error)
|
|
|
174 error_at (loc, "cannot convert %qE from type %qH to type %qI",
|
|
|
175 expr, intype, type);
|
|
|
176 return error_mark_node;
|
|
|
177 }
|
|
|
178
|
|
|
179 return build_nop (type, expr);
|
|
|
180 }
|
|
|
181 else if ((TYPE_PTRDATAMEM_P (type) && TYPE_PTRDATAMEM_P (intype))
|
|
|
182 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
|
|
|
183 return convert_ptrmem (type, expr, /*allow_inverse_p=*/false,
|
|
|
184 /*c_cast_p=*/false, complain);
|
|
|
185 else if (TYPE_PTRMEMFUNC_P (intype))
|
|
|
186 {
|
|
|
187 if (!warn_pmf2ptr)
|
|
|
188 {
|
|
|
189 if (TREE_CODE (expr) == PTRMEM_CST)
|
|
|
190 return cp_convert_to_pointer (type, PTRMEM_CST_MEMBER (expr),
|
|
|
191 dofold, complain);
|
|
|
192 else if (TREE_CODE (expr) == OFFSET_REF)
|
|
|
193 {
|
|
|
194 tree object = TREE_OPERAND (expr, 0);
|
|
|
195 return get_member_function_from_ptrfunc (&object,
|
|
|
196 TREE_OPERAND (expr, 1),
|
|
|
197 complain);
|
|
|
198 }
|
|
|
199 }
|
|
|
200 if (complain & tf_error)
|
|
|
201 error_at (loc, "cannot convert %qE from type %qH to type %qI",
|
|
|
202 expr, intype, type);
|
|
|
203 return error_mark_node;
|
|
|
204 }
|
|
|
205
|
|
|
206 if (null_ptr_cst_p (expr))
|
|
|
207 {
|
|
|
208 if (TYPE_PTRMEMFUNC_P (type))
|
|
|
209 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0,
|
|
|
210 /*c_cast_p=*/false, complain);
|
|
|
211
|
|
|
212 if (complain & tf_warning)
|
|
|
213 maybe_warn_zero_as_null_pointer_constant (expr, loc);
|
|
|
214
|
|
|
215 /* A NULL pointer-to-data-member is represented by -1, not by
|
|
|
216 zero. */
|
|
|
217 tree val = (TYPE_PTRDATAMEM_P (type)
|
|
|
218 ? build_int_cst_type (type, -1)
|
|
|
219 : build_int_cst (type, 0));
|
|
|
220
|
|
|
221 return (TREE_SIDE_EFFECTS (expr)
|
|
|
222 ? build2 (COMPOUND_EXPR, type, expr, val) : val);
|
|
|
223 }
|
|
|
224 else if (TYPE_PTRMEM_P (type) && INTEGRAL_CODE_P (form))
|
|
|
225 {
|
|
|
226 if (complain & tf_error)
|
|
|
227 error_at (loc, "invalid conversion from %qH to %qI", intype, type);
|
|
|
228 return error_mark_node;
|
|
|
229 }
|
|
|
230
|
|
|
231 if (INTEGRAL_CODE_P (form))
|
|
|
232 {
|
|
|
233 if (TYPE_PRECISION (intype) == POINTER_SIZE)
|
|
|
234 return build1 (CONVERT_EXPR, type, expr);
|
|
|
235 expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr,
|
|
|
236 complain);
|
|
|
237 /* Modes may be different but sizes should be the same. There
|
|
|
238 is supposed to be some integral type that is the same width
|
|
|
239 as a pointer. */
|
|
|
240 gcc_assert (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (expr)))
|
|
|
241 == GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type)));
|
|
|
242
|
|
131
|
243 /* FIXME needed because convert_to_pointer_maybe_fold still folds
|
|
|
244 conversion of constants. */
|
|
|
245 if (!dofold)
|
|
|
246 return build1 (CONVERT_EXPR, type, expr);
|
|
|
247
|
|
111
|
248 return convert_to_pointer_maybe_fold (type, expr, dofold);
|
|
|
249 }
|
|
|
250
|
|
|
251 if (type_unknown_p (expr))
|
|
|
252 return instantiate_type (type, expr, complain);
|
|
|
253
|
|
|
254 if (complain & tf_error)
|
|
|
255 error_at (loc, "cannot convert %qE from type %qH to type %qI",
|
|
|
256 expr, intype, type);
|
|
|
257 return error_mark_node;
|
|
|
258 }
|
|
|
259
|
|
|
260 /* Like convert, except permit conversions to take place which
|
|
|
261 are not normally allowed due to access restrictions
|
|
|
262 (such as conversion from sub-type to private super-type). */
|
|
|
263
|
|
|
264 static tree
|
|
|
265 convert_to_pointer_force (tree type, tree expr, tsubst_flags_t complain)
|
|
|
266 {
|
|
|
267 tree intype = TREE_TYPE (expr);
|
|
|
268 enum tree_code form = TREE_CODE (intype);
|
|
|
269
|
|
|
270 if (form == POINTER_TYPE)
|
|
|
271 {
|
|
|
272 intype = TYPE_MAIN_VARIANT (intype);
|
|
|
273
|
|
|
274 if (TYPE_MAIN_VARIANT (type) != intype
|
|
|
275 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
|
|
|
276 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
|
|
|
277 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
|
|
|
278 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
|
|
|
279 {
|
|
|
280 enum tree_code code = PLUS_EXPR;
|
|
|
281 tree binfo;
|
|
|
282
|
|
|
283 binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type),
|
|
|
284 ba_unique, NULL, complain);
|
|
|
285 if (!binfo)
|
|
|
286 {
|
|
|
287 binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
|
|
|
288 ba_unique, NULL, complain);
|
|
|
289 code = MINUS_EXPR;
|
|
|
290 }
|
|
|
291 if (binfo == error_mark_node)
|
|
|
292 return error_mark_node;
|
|
|
293 if (binfo)
|
|
|
294 {
|
|
|
295 expr = build_base_path (code, expr, binfo, 0, complain);
|
|
|
296 if (expr == error_mark_node)
|
|
|
297 return error_mark_node;
|
|
|
298 /* Add any qualifier conversions. */
|
|
|
299 if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)),
|
|
|
300 TREE_TYPE (type)))
|
|
|
301 expr = build_nop (type, expr);
|
|
|
302 return expr;
|
|
|
303 }
|
|
|
304 }
|
|
|
305 }
|
|
|
306
|
|
|
307 return cp_convert_to_pointer (type, expr, /*fold*/false, complain);
|
|
|
308 }
|
|
|
309
|
|
|
310 /* We are passing something to a function which requires a reference.
|
|
|
311 The type we are interested in is in TYPE. The initial
|
|
|
312 value we have to begin with is in ARG.
|
|
|
313
|
|
|
314 FLAGS controls how we manage access checking.
|
|
|
315 DIRECT_BIND in FLAGS controls how any temporaries are generated.
|
|
|
316 If DIRECT_BIND is set, DECL is the reference we're binding to. */
|
|
|
317
|
|
|
318 static tree
|
|
|
319 build_up_reference (tree type, tree arg, int flags, tree decl,
|
|
|
320 tsubst_flags_t complain)
|
|
|
321 {
|
|
|
322 tree rval;
|
|
|
323 tree argtype = TREE_TYPE (arg);
|
|
|
324 tree target_type = TREE_TYPE (type);
|
|
|
325
|
|
131
|
326 gcc_assert (TYPE_REF_P (type));
|
|
111
|
327
|
|
|
328 if ((flags & DIRECT_BIND) && ! lvalue_p (arg))
|
|
|
329 {
|
|
|
330 /* Create a new temporary variable. We can't just use a TARGET_EXPR
|
|
|
331 here because it needs to live as long as DECL. */
|
|
|
332 tree targ = arg;
|
|
|
333
|
|
|
334 arg = make_temporary_var_for_ref_to_temp (decl, target_type);
|
|
|
335
|
|
|
336 /* Process the initializer for the declaration. */
|
|
|
337 DECL_INITIAL (arg) = targ;
|
|
|
338 cp_finish_decl (arg, targ, /*init_const_expr_p=*/false, NULL_TREE,
|
|
|
339 LOOKUP_ONLYCONVERTING|DIRECT_BIND);
|
|
|
340 }
|
|
|
341 else if (!(flags & DIRECT_BIND) && ! obvalue_p (arg))
|
|
|
342 return get_target_expr_sfinae (arg, complain);
|
|
|
343
|
|
|
344 /* If we had a way to wrap this up, and say, if we ever needed its
|
|
|
345 address, transform all occurrences of the register, into a memory
|
|
|
346 reference we could win better. */
|
|
|
347 rval = cp_build_addr_expr (arg, complain);
|
|
|
348 if (rval == error_mark_node)
|
|
|
349 return error_mark_node;
|
|
|
350
|
|
|
351 if ((flags & LOOKUP_PROTECT)
|
|
|
352 && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
|
|
|
353 && MAYBE_CLASS_TYPE_P (argtype)
|
|
|
354 && MAYBE_CLASS_TYPE_P (target_type))
|
|
|
355 {
|
|
|
356 /* We go through lookup_base for the access control. */
|
|
|
357 tree binfo = lookup_base (argtype, target_type, ba_check,
|
|
|
358 NULL, complain);
|
|
|
359 if (binfo == error_mark_node)
|
|
|
360 return error_mark_node;
|
|
|
361 if (binfo == NULL_TREE)
|
|
|
362 return error_not_base_type (target_type, argtype);
|
|
|
363 rval = build_base_path (PLUS_EXPR, rval, binfo, 1, complain);
|
|
|
364 }
|
|
|
365 else
|
|
|
366 rval
|
|
|
367 = convert_to_pointer_force (build_pointer_type (target_type),
|
|
|
368 rval, complain);
|
|
|
369 return build_nop (type, rval);
|
|
|
370 }
|
|
|
371
|
|
|
372 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
|
|
|
373 INTYPE is the original rvalue type and DECL is an optional _DECL node
|
|
|
374 for diagnostics.
|
|
|
375
|
|
|
376 [dcl.init.ref] says that if an rvalue is used to
|
|
|
377 initialize a reference, then the reference must be to a
|
|
|
378 non-volatile const type. */
|
|
|
379
|
|
|
380 static void
|
|
|
381 diagnose_ref_binding (location_t loc, tree reftype, tree intype, tree decl)
|
|
|
382 {
|
|
|
383 tree ttl = TREE_TYPE (reftype);
|
|
|
384
|
|
131
|
385 if (!TYPE_REF_IS_RVALUE (reftype)
|
|
|
386 && !CP_TYPE_CONST_NON_VOLATILE_P (ttl))
|
|
111
|
387 {
|
|
|
388 const char *msg;
|
|
|
389
|
|
|
390 if (CP_TYPE_VOLATILE_P (ttl) && decl)
|
|
|
391 msg = G_("initialization of volatile reference type %q#T from "
|
|
|
392 "rvalue of type %qT");
|
|
|
393 else if (CP_TYPE_VOLATILE_P (ttl))
|
|
|
394 msg = G_("conversion to volatile reference type %q#T "
|
|
|
395 "from rvalue of type %qT");
|
|
|
396 else if (decl)
|
|
|
397 msg = G_("initialization of non-const reference type %q#T from "
|
|
|
398 "rvalue of type %qT");
|
|
|
399 else
|
|
|
400 msg = G_("conversion to non-const reference type %q#T from "
|
|
|
401 "rvalue of type %qT");
|
|
|
402
|
|
|
403 permerror (loc, msg, reftype, intype);
|
|
|
404 }
|
|
|
405 }
|
|
|
406
|
|
|
407 /* For C++: Only need to do one-level references, but cannot
|
|
|
408 get tripped up on signed/unsigned differences.
|
|
|
409
|
|
|
410 DECL is either NULL_TREE or the _DECL node for a reference that is being
|
|
|
411 initialized. It can be error_mark_node if we don't know the _DECL but
|
|
|
412 we know it's an initialization. */
|
|
|
413
|
|
|
414 tree
|
|
|
415 convert_to_reference (tree reftype, tree expr, int convtype,
|
|
|
416 int flags, tree decl, tsubst_flags_t complain)
|
|
|
417 {
|
|
|
418 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
|
|
|
419 tree intype;
|
|
|
420 tree rval = NULL_TREE;
|
|
|
421 tree rval_as_conversion = NULL_TREE;
|
|
|
422 bool can_convert_intype_to_type;
|
|
145
|
423 location_t loc = cp_expr_loc_or_input_loc (expr);
|
|
111
|
424
|
|
|
425 if (TREE_CODE (type) == FUNCTION_TYPE
|
|
|
426 && TREE_TYPE (expr) == unknown_type_node)
|
|
|
427 expr = instantiate_type (type, expr, complain);
|
|
|
428
|
|
|
429 if (expr == error_mark_node)
|
|
|
430 return error_mark_node;
|
|
|
431
|
|
|
432 intype = TREE_TYPE (expr);
|
|
|
433
|
|
131
|
434 gcc_assert (!TYPE_REF_P (intype));
|
|
|
435 gcc_assert (TYPE_REF_P (reftype));
|
|
111
|
436
|
|
|
437 intype = TYPE_MAIN_VARIANT (intype);
|
|
|
438
|
|
|
439 can_convert_intype_to_type = can_convert_standard (type, intype, complain);
|
|
|
440
|
|
|
441 if (!can_convert_intype_to_type
|
|
|
442 && (convtype & CONV_IMPLICIT) && MAYBE_CLASS_TYPE_P (intype)
|
|
|
443 && ! (flags & LOOKUP_NO_CONVERSION))
|
|
|
444 {
|
|
|
445 /* Look for a user-defined conversion to lvalue that we can use. */
|
|
|
446
|
|
|
447 rval_as_conversion
|
|
|
448 = build_type_conversion (reftype, expr);
|
|
|
449
|
|
|
450 if (rval_as_conversion && rval_as_conversion != error_mark_node
|
|
|
451 && lvalue_p (rval_as_conversion))
|
|
|
452 {
|
|
|
453 expr = rval_as_conversion;
|
|
|
454 rval_as_conversion = NULL_TREE;
|
|
|
455 intype = type;
|
|
|
456 can_convert_intype_to_type = 1;
|
|
|
457 }
|
|
|
458 }
|
|
|
459
|
|
|
460 if (((convtype & CONV_STATIC)
|
|
|
461 && can_convert_standard (intype, type, complain))
|
|
|
462 || ((convtype & CONV_IMPLICIT) && can_convert_intype_to_type))
|
|
|
463 {
|
|
|
464 {
|
|
|
465 tree ttl = TREE_TYPE (reftype);
|
|
|
466 tree ttr = lvalue_type (expr);
|
|
|
467
|
|
|
468 if ((complain & tf_error)
|
|
|
469 && ! lvalue_p (expr))
|
|
|
470 diagnose_ref_binding (loc, reftype, intype, decl);
|
|
|
471
|
|
|
472 if (! (convtype & CONV_CONST)
|
|
|
473 && !at_least_as_qualified_p (ttl, ttr))
|
|
|
474 {
|
|
|
475 if (complain & tf_error)
|
|
|
476 permerror (loc, "conversion from %qH to %qI discards qualifiers",
|
|
|
477 ttr, reftype);
|
|
|
478 else
|
|
|
479 return error_mark_node;
|
|
|
480 }
|
|
|
481 }
|
|
|
482
|
|
|
483 return build_up_reference (reftype, expr, flags, decl, complain);
|
|
|
484 }
|
|
|
485 else if ((convtype & CONV_REINTERPRET) && obvalue_p (expr))
|
|
|
486 {
|
|
|
487 /* When casting an lvalue to a reference type, just convert into
|
|
|
488 a pointer to the new type and deference it. This is allowed
|
|
|
489 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
|
|
|
490 should be done directly (jason). (int &)ri ---> *(int*)&ri */
|
|
|
491
|
|
|
492 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
|
|
|
493 meant. */
|
|
|
494 if ((complain & tf_warning)
|
|
|
495 && TYPE_PTR_P (intype)
|
|
|
496 && (comptypes (TREE_TYPE (intype), type,
|
|
|
497 COMPARE_BASE | COMPARE_DERIVED)))
|
|
|
498 warning_at (loc, 0, "casting %qT to %qT does not dereference pointer",
|
|
|
499 intype, reftype);
|
|
|
500
|
|
|
501 rval = cp_build_addr_expr (expr, complain);
|
|
|
502 if (rval != error_mark_node)
|
|
|
503 rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
|
|
|
504 rval, 0, complain);
|
|
|
505 if (rval != error_mark_node)
|
|
|
506 rval = build1 (NOP_EXPR, reftype, rval);
|
|
|
507 }
|
|
|
508 else
|
|
|
509 {
|
|
|
510 rval = convert_for_initialization (NULL_TREE, type, expr, flags,
|
|
|
511 ICR_CONVERTING, 0, 0, complain);
|
|
|
512 if (rval == NULL_TREE || rval == error_mark_node)
|
|
|
513 return rval;
|
|
|
514 if (complain & tf_error)
|
|
|
515 diagnose_ref_binding (loc, reftype, intype, decl);
|
|
|
516 rval = build_up_reference (reftype, rval, flags, decl, complain);
|
|
|
517 }
|
|
|
518
|
|
|
519 if (rval)
|
|
|
520 {
|
|
|
521 /* If we found a way to convert earlier, then use it. */
|
|
|
522 return rval;
|
|
|
523 }
|
|
|
524
|
|
|
525 if (complain & tf_error)
|
|
|
526 error_at (loc, "cannot convert type %qH to type %qI", intype, reftype);
|
|
|
527
|
|
|
528 return error_mark_node;
|
|
|
529 }
|
|
|
530
|
|
|
531 /* We are using a reference VAL for its value. Bash that reference all the
|
|
|
532 way down to its lowest form. */
|
|
|
533
|
|
|
534 tree
|
|
|
535 convert_from_reference (tree val)
|
|
|
536 {
|
|
|
537 if (TREE_TYPE (val)
|
|
131
|
538 && TYPE_REF_P (TREE_TYPE (val)))
|
|
111
|
539 {
|
|
|
540 tree t = TREE_TYPE (TREE_TYPE (val));
|
|
|
541 tree ref = build1 (INDIRECT_REF, t, val);
|
|
|
542
|
|
|
543 mark_exp_read (val);
|
|
|
544 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
|
|
|
545 so that we get the proper error message if the result is used
|
|
|
546 to assign to. Also, &* is supposed to be a no-op. */
|
|
|
547 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
|
|
|
548 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
|
|
|
549 TREE_SIDE_EFFECTS (ref)
|
|
|
550 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (val));
|
|
|
551 val = ref;
|
|
|
552 }
|
|
|
553
|
|
|
554 return val;
|
|
|
555 }
|
|
|
556
|
|
|
557 /* Really perform an lvalue-to-rvalue conversion, including copying an
|
|
|
558 argument of class type into a temporary. */
|
|
|
559
|
|
|
560 tree
|
|
|
561 force_rvalue (tree expr, tsubst_flags_t complain)
|
|
|
562 {
|
|
|
563 tree type = TREE_TYPE (expr);
|
|
|
564 if (MAYBE_CLASS_TYPE_P (type) && TREE_CODE (expr) != TARGET_EXPR)
|
|
|
565 {
|
|
145
|
566 releasing_vec args (make_tree_vector_single (expr));
|
|
111
|
567 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
|
|
|
568 &args, type, LOOKUP_NORMAL, complain);
|
|
|
569 expr = build_cplus_new (type, expr, complain);
|
|
|
570 }
|
|
|
571 else
|
|
|
572 expr = decay_conversion (expr, complain);
|
|
|
573
|
|
|
574 return expr;
|
|
|
575 }
|
|
|
576
|
|
|
577
|
|
|
578 /* If EXPR and ORIG are INTEGER_CSTs, return a version of EXPR that has
|
|
|
579 TREE_OVERFLOW set only if it is set in ORIG. Otherwise, return EXPR
|
|
|
580 unchanged. */
|
|
|
581
|
|
|
582 static tree
|
|
|
583 ignore_overflows (tree expr, tree orig)
|
|
|
584 {
|
|
145
|
585 tree stripped_expr = tree_strip_any_location_wrapper (expr);
|
|
|
586 tree stripped_orig = tree_strip_any_location_wrapper (orig);
|
|
|
587
|
|
|
588 if (TREE_CODE (stripped_expr) == INTEGER_CST
|
|
|
589 && TREE_CODE (stripped_orig) == INTEGER_CST
|
|
|
590 && TREE_OVERFLOW (stripped_expr) != TREE_OVERFLOW (stripped_orig))
|
|
111
|
591 {
|
|
145
|
592 gcc_assert (!TREE_OVERFLOW (stripped_orig));
|
|
111
|
593 /* Ensure constant sharing. */
|
|
145
|
594 stripped_expr = wide_int_to_tree (TREE_TYPE (stripped_expr),
|
|
|
595 wi::to_wide (stripped_expr));
|
|
111
|
596 }
|
|
145
|
597
|
|
|
598 return preserve_any_location_wrapper (stripped_expr, expr);
|
|
111
|
599 }
|
|
|
600
|
|
|
601 /* Fold away simple conversions, but make sure TREE_OVERFLOW is set
|
|
|
602 properly. */
|
|
|
603
|
|
|
604 tree
|
|
|
605 cp_fold_convert (tree type, tree expr)
|
|
|
606 {
|
|
|
607 tree conv;
|
|
|
608 if (TREE_TYPE (expr) == type)
|
|
|
609 conv = expr;
|
|
131
|
610 else if (TREE_CODE (expr) == PTRMEM_CST
|
|
|
611 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
|
|
|
612 PTRMEM_CST_CLASS (expr)))
|
|
111
|
613 {
|
|
|
614 /* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
|
|
|
615 conv = copy_node (expr);
|
|
|
616 TREE_TYPE (conv) = type;
|
|
|
617 }
|
|
131
|
618 else if (TYPE_PTRMEM_P (type))
|
|
|
619 {
|
|
|
620 conv = convert_ptrmem (type, expr, true, false,
|
|
|
621 tf_warning_or_error);
|
|
|
622 conv = cp_fully_fold (conv);
|
|
|
623 }
|
|
111
|
624 else
|
|
|
625 {
|
|
|
626 conv = fold_convert (type, expr);
|
|
|
627 conv = ignore_overflows (conv, expr);
|
|
|
628 }
|
|
|
629 return conv;
|
|
|
630 }
|
|
|
631
|
|
|
632 /* C++ conversions, preference to static cast conversions. */
|
|
|
633
|
|
|
634 tree
|
|
|
635 cp_convert (tree type, tree expr, tsubst_flags_t complain)
|
|
|
636 {
|
|
|
637 return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL, complain);
|
|
|
638 }
|
|
|
639
|
|
|
640 /* C++ equivalent of convert_and_check but using cp_convert as the
|
|
|
641 conversion function.
|
|
|
642
|
|
|
643 Convert EXPR to TYPE, warning about conversion problems with constants.
|
|
|
644 Invoke this function on every expression that is converted implicitly,
|
|
|
645 i.e. because of language rules and not because of an explicit cast. */
|
|
|
646
|
|
|
647 tree
|
|
|
648 cp_convert_and_check (tree type, tree expr, tsubst_flags_t complain)
|
|
|
649 {
|
|
|
650 tree result;
|
|
|
651
|
|
|
652 if (TREE_TYPE (expr) == type)
|
|
|
653 return expr;
|
|
|
654 if (expr == error_mark_node)
|
|
|
655 return expr;
|
|
|
656 result = cp_convert (type, expr, complain);
|
|
|
657
|
|
|
658 if ((complain & tf_warning)
|
|
|
659 && c_inhibit_evaluation_warnings == 0)
|
|
|
660 {
|
|
|
661 tree folded = cp_fully_fold (expr);
|
|
|
662 tree folded_result;
|
|
|
663 if (folded == expr)
|
|
|
664 folded_result = result;
|
|
|
665 else
|
|
|
666 {
|
|
|
667 /* Avoid bogus -Wparentheses warnings. */
|
|
|
668 warning_sentinel w (warn_parentheses);
|
|
|
669 warning_sentinel c (warn_int_in_bool_context);
|
|
|
670 folded_result = cp_convert (type, folded, tf_none);
|
|
|
671 }
|
|
|
672 folded_result = fold_simple (folded_result);
|
|
|
673 if (!TREE_OVERFLOW_P (folded)
|
|
|
674 && folded_result != error_mark_node)
|
|
145
|
675 warnings_for_convert_and_check (cp_expr_loc_or_input_loc (expr),
|
|
111
|
676 type, folded, folded_result);
|
|
|
677 }
|
|
|
678
|
|
|
679 return result;
|
|
|
680 }
|
|
|
681
|
|
|
682 /* Conversion...
|
|
|
683
|
|
|
684 FLAGS indicates how we should behave. */
|
|
|
685
|
|
|
686 tree
|
|
|
687 ocp_convert (tree type, tree expr, int convtype, int flags,
|
|
|
688 tsubst_flags_t complain)
|
|
|
689 {
|
|
|
690 tree e = expr;
|
|
|
691 enum tree_code code = TREE_CODE (type);
|
|
|
692 const char *invalid_conv_diag;
|
|
|
693 tree e1;
|
|
145
|
694 location_t loc = cp_expr_loc_or_input_loc (expr);
|
|
111
|
695 bool dofold = (convtype & CONV_FOLD);
|
|
|
696
|
|
|
697 if (error_operand_p (e) || type == error_mark_node)
|
|
|
698 return error_mark_node;
|
|
|
699
|
|
|
700 complete_type (type);
|
|
|
701 complete_type (TREE_TYPE (expr));
|
|
|
702
|
|
|
703 if ((invalid_conv_diag
|
|
|
704 = targetm.invalid_conversion (TREE_TYPE (expr), type)))
|
|
|
705 {
|
|
|
706 if (complain & tf_error)
|
|
|
707 error (invalid_conv_diag);
|
|
|
708 return error_mark_node;
|
|
|
709 }
|
|
|
710
|
|
|
711 /* FIXME remove when moving to c_fully_fold model. */
|
|
|
712 if (!CLASS_TYPE_P (type))
|
|
131
|
713 {
|
|
|
714 e = mark_rvalue_use (e);
|
|
|
715 e = scalar_constant_value (e);
|
|
|
716 }
|
|
111
|
717 if (error_operand_p (e))
|
|
|
718 return error_mark_node;
|
|
|
719
|
|
131
|
720 if (NULLPTR_TYPE_P (type) && null_ptr_cst_p (e))
|
|
|
721 {
|
|
|
722 if (complain & tf_warning)
|
|
|
723 maybe_warn_zero_as_null_pointer_constant (e, loc);
|
|
|
724
|
|
|
725 if (!TREE_SIDE_EFFECTS (e))
|
|
|
726 return nullptr_node;
|
|
|
727 }
|
|
|
728
|
|
111
|
729 if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP))
|
|
|
730 /* We need a new temporary; don't take this shortcut. */;
|
|
|
731 else if (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (e)))
|
|
|
732 {
|
|
145
|
733 tree etype = TREE_TYPE (e);
|
|
|
734 if (same_type_p (type, etype))
|
|
111
|
735 /* The call to fold will not always remove the NOP_EXPR as
|
|
|
736 might be expected, since if one of the types is a typedef;
|
|
|
737 the comparison in fold is just equality of pointers, not a
|
|
|
738 call to comptypes. We don't call fold in this case because
|
|
|
739 that can result in infinite recursion; fold will call
|
|
|
740 convert, which will call ocp_convert, etc. */
|
|
|
741 return e;
|
|
|
742 /* For complex data types, we need to perform componentwise
|
|
|
743 conversion. */
|
|
|
744 else if (TREE_CODE (type) == COMPLEX_TYPE)
|
|
|
745 return convert_to_complex_maybe_fold (type, e, dofold);
|
|
|
746 else if (VECTOR_TYPE_P (type))
|
|
145
|
747 return convert_to_vector (type, rvalue (e));
|
|
111
|
748 else if (TREE_CODE (e) == TARGET_EXPR)
|
|
|
749 {
|
|
|
750 /* Don't build a NOP_EXPR of class type. Instead, change the
|
|
|
751 type of the temporary. */
|
|
145
|
752 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, etype));
|
|
111
|
753 TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type;
|
|
|
754 return e;
|
|
|
755 }
|
|
145
|
756 else if (TREE_CODE (e) == CONSTRUCTOR)
|
|
|
757 {
|
|
|
758 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, etype));
|
|
|
759 TREE_TYPE (e) = type;
|
|
|
760 return e;
|
|
|
761 }
|
|
111
|
762 else
|
|
|
763 {
|
|
|
764 /* We shouldn't be treating objects of ADDRESSABLE type as
|
|
|
765 rvalues. */
|
|
|
766 gcc_assert (!TREE_ADDRESSABLE (type));
|
|
|
767 return build_nop (type, e);
|
|
|
768 }
|
|
|
769 }
|
|
|
770
|
|
|
771 e1 = targetm.convert_to_type (type, e);
|
|
|
772 if (e1)
|
|
|
773 return e1;
|
|
|
774
|
|
|
775 if (code == VOID_TYPE && (convtype & CONV_STATIC))
|
|
|
776 {
|
|
|
777 e = convert_to_void (e, ICV_CAST, complain);
|
|
|
778 return e;
|
|
|
779 }
|
|
|
780
|
|
|
781 if (INTEGRAL_CODE_P (code))
|
|
|
782 {
|
|
|
783 tree intype = TREE_TYPE (e);
|
|
|
784 tree converted;
|
|
|
785
|
|
|
786 if (TREE_CODE (type) == ENUMERAL_TYPE)
|
|
|
787 {
|
|
|
788 /* enum = enum, enum = int, enum = float, (enum)pointer are all
|
|
|
789 errors. */
|
|
|
790 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
|
|
|
791 || TREE_CODE (intype) == REAL_TYPE)
|
|
|
792 && ! (convtype & CONV_STATIC))
|
|
|
793 || TYPE_PTR_P (intype))
|
|
|
794 {
|
|
|
795 if (complain & tf_error)
|
|
|
796 permerror (loc, "conversion from %q#T to %q#T", intype, type);
|
|
|
797 else
|
|
|
798 return error_mark_node;
|
|
|
799 }
|
|
|
800
|
|
|
801 /* [expr.static.cast]
|
|
|
802
|
|
|
803 8. A value of integral or enumeration type can be explicitly
|
|
|
804 converted to an enumeration type. The value is unchanged if
|
|
|
805 the original value is within the range of the enumeration
|
|
|
806 values. Otherwise, the resulting enumeration value is
|
|
|
807 unspecified. */
|
|
145
|
808 tree val = fold_for_warn (e);
|
|
111
|
809 if ((complain & tf_warning)
|
|
145
|
810 && TREE_CODE (val) == INTEGER_CST
|
|
111
|
811 && ENUM_UNDERLYING_TYPE (type)
|
|
145
|
812 && !int_fits_type_p (val, ENUM_UNDERLYING_TYPE (type)))
|
|
111
|
813 warning_at (loc, OPT_Wconversion,
|
|
|
814 "the result of the conversion is unspecified because "
|
|
|
815 "%qE is outside the range of type %qT",
|
|
|
816 expr, type);
|
|
|
817 }
|
|
|
818 if (MAYBE_CLASS_TYPE_P (intype))
|
|
|
819 {
|
|
|
820 tree rval;
|
|
|
821 rval = build_type_conversion (type, e);
|
|
|
822 if (rval)
|
|
|
823 return rval;
|
|
|
824 if (complain & tf_error)
|
|
|
825 error_at (loc, "%q#T used where a %qT was expected", intype, type);
|
|
|
826 return error_mark_node;
|
|
|
827 }
|
|
|
828 if (code == BOOLEAN_TYPE)
|
|
|
829 {
|
|
|
830 if (VOID_TYPE_P (intype))
|
|
|
831 {
|
|
|
832 if (complain & tf_error)
|
|
|
833 error_at (loc,
|
|
|
834 "could not convert %qE from %<void%> to %<bool%>",
|
|
|
835 expr);
|
|
|
836 return error_mark_node;
|
|
|
837 }
|
|
|
838
|
|
145
|
839 if (VECTOR_TYPE_P (intype) && !gnu_vector_type_p (intype))
|
|
|
840 {
|
|
|
841 if (complain & tf_error)
|
|
|
842 error_at (loc, "could not convert %qE from %qH to %qI", expr,
|
|
|
843 TREE_TYPE (expr), type);
|
|
|
844 return error_mark_node;
|
|
|
845 }
|
|
|
846
|
|
111
|
847 /* We can't implicitly convert a scoped enum to bool, so convert
|
|
|
848 to the underlying type first. */
|
|
|
849 if (SCOPED_ENUM_P (intype) && (convtype & CONV_STATIC))
|
|
|
850 e = build_nop (ENUM_UNDERLYING_TYPE (intype), e);
|
|
|
851 if (complain & tf_warning)
|
|
145
|
852 return cp_truthvalue_conversion (e, complain);
|
|
111
|
853 else
|
|
|
854 {
|
|
|
855 /* Prevent bogus -Wint-in-bool-context warnings coming
|
|
|
856 from c_common_truthvalue_conversion down the line. */
|
|
|
857 warning_sentinel w (warn_int_in_bool_context);
|
|
145
|
858 warning_sentinel c (warn_sign_compare);
|
|
|
859 return cp_truthvalue_conversion (e, complain);
|
|
111
|
860 }
|
|
|
861 }
|
|
|
862
|
|
|
863 converted = convert_to_integer_maybe_fold (type, e, dofold);
|
|
|
864
|
|
|
865 /* Ignore any integer overflow caused by the conversion. */
|
|
|
866 return ignore_overflows (converted, e);
|
|
|
867 }
|
|
131
|
868 if (INDIRECT_TYPE_P (type) || TYPE_PTRMEM_P (type))
|
|
111
|
869 return cp_convert_to_pointer (type, e, dofold, complain);
|
|
|
870 if (code == VECTOR_TYPE)
|
|
|
871 {
|
|
|
872 tree in_vtype = TREE_TYPE (e);
|
|
|
873 if (MAYBE_CLASS_TYPE_P (in_vtype))
|
|
|
874 {
|
|
|
875 tree ret_val;
|
|
|
876 ret_val = build_type_conversion (type, e);
|
|
|
877 if (ret_val)
|
|
|
878 return ret_val;
|
|
|
879 if (complain & tf_error)
|
|
|
880 error_at (loc, "%q#T used where a %qT was expected",
|
|
|
881 in_vtype, type);
|
|
|
882 return error_mark_node;
|
|
|
883 }
|
|
145
|
884 return convert_to_vector (type, rvalue (e));
|
|
111
|
885 }
|
|
|
886 if (code == REAL_TYPE || code == COMPLEX_TYPE)
|
|
|
887 {
|
|
|
888 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e)))
|
|
|
889 {
|
|
|
890 tree rval;
|
|
|
891 rval = build_type_conversion (type, e);
|
|
|
892 if (rval)
|
|
|
893 return rval;
|
|
|
894 else if (complain & tf_error)
|
|
|
895 error_at (loc,
|
|
145
|
896 "%q#T used where a floating-point value was expected",
|
|
111
|
897 TREE_TYPE (e));
|
|
|
898 }
|
|
|
899 if (code == REAL_TYPE)
|
|
|
900 return convert_to_real_maybe_fold (type, e, dofold);
|
|
|
901 else if (code == COMPLEX_TYPE)
|
|
|
902 return convert_to_complex_maybe_fold (type, e, dofold);
|
|
|
903 }
|
|
|
904
|
|
|
905 /* New C++ semantics: since assignment is now based on
|
|
|
906 memberwise copying, if the rhs type is derived from the
|
|
|
907 lhs type, then we may still do a conversion. */
|
|
|
908 if (RECORD_OR_UNION_CODE_P (code))
|
|
|
909 {
|
|
|
910 tree dtype = TREE_TYPE (e);
|
|
|
911 tree ctor = NULL_TREE;
|
|
|
912
|
|
|
913 dtype = TYPE_MAIN_VARIANT (dtype);
|
|
|
914
|
|
|
915 /* Conversion between aggregate types. New C++ semantics allow
|
|
|
916 objects of derived type to be cast to objects of base type.
|
|
|
917 Old semantics only allowed this between pointers.
|
|
|
918
|
|
|
919 There may be some ambiguity between using a constructor
|
|
|
920 vs. using a type conversion operator when both apply. */
|
|
|
921
|
|
|
922 ctor = e;
|
|
|
923
|
|
|
924 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
|
|
|
925 return error_mark_node;
|
|
|
926
|
|
|
927 if (BRACE_ENCLOSED_INITIALIZER_P (ctor))
|
|
|
928 ctor = perform_implicit_conversion (type, ctor, complain);
|
|
|
929 else if ((flags & LOOKUP_ONLYCONVERTING)
|
|
|
930 && ! (CLASS_TYPE_P (dtype) && DERIVED_FROM_P (type, dtype)))
|
|
|
931 /* For copy-initialization, first we create a temp of the proper type
|
|
|
932 with a user-defined conversion sequence, then we direct-initialize
|
|
|
933 the target with the temp (see [dcl.init]). */
|
|
|
934 ctor = build_user_type_conversion (type, ctor, flags, complain);
|
|
|
935 else
|
|
|
936 {
|
|
145
|
937 releasing_vec ctor_vec (make_tree_vector_single (ctor));
|
|
111
|
938 ctor = build_special_member_call (NULL_TREE,
|
|
|
939 complete_ctor_identifier,
|
|
|
940 &ctor_vec,
|
|
|
941 type, flags, complain);
|
|
|
942 }
|
|
|
943 if (ctor)
|
|
|
944 return build_cplus_new (type, ctor, complain);
|
|
|
945 }
|
|
|
946
|
|
|
947 if (complain & tf_error)
|
|
|
948 {
|
|
|
949 /* If the conversion failed and expr was an invalid use of pointer to
|
|
|
950 member function, try to report a meaningful error. */
|
|
|
951 if (invalid_nonstatic_memfn_p (loc, expr, complain))
|
|
|
952 /* We displayed the error message. */;
|
|
|
953 else
|
|
|
954 error_at (loc, "conversion from %qH to non-scalar type %qI requested",
|
|
|
955 TREE_TYPE (expr), type);
|
|
|
956 }
|
|
|
957 return error_mark_node;
|
|
|
958 }
|
|
|
959
|
|
|
960 /* If CALL is a call, return the callee; otherwise null. */
|
|
|
961
|
|
|
962 tree
|
|
|
963 cp_get_callee (tree call)
|
|
|
964 {
|
|
|
965 if (call == NULL_TREE)
|
|
|
966 return call;
|
|
|
967 else if (TREE_CODE (call) == CALL_EXPR)
|
|
|
968 return CALL_EXPR_FN (call);
|
|
|
969 else if (TREE_CODE (call) == AGGR_INIT_EXPR)
|
|
|
970 return AGGR_INIT_EXPR_FN (call);
|
|
|
971 return NULL_TREE;
|
|
|
972 }
|
|
|
973
|
|
|
974 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
|
|
|
975 if we can. */
|
|
|
976
|
|
|
977 tree
|
|
131
|
978 cp_get_fndecl_from_callee (tree fn, bool fold /* = true */)
|
|
111
|
979 {
|
|
|
980 if (fn == NULL_TREE)
|
|
|
981 return fn;
|
|
|
982 if (TREE_CODE (fn) == FUNCTION_DECL)
|
|
|
983 return fn;
|
|
|
984 tree type = TREE_TYPE (fn);
|
|
|
985 if (type == unknown_type_node)
|
|
|
986 return NULL_TREE;
|
|
131
|
987 gcc_assert (INDIRECT_TYPE_P (type));
|
|
|
988 if (fold)
|
|
|
989 fn = maybe_constant_init (fn);
|
|
111
|
990 STRIP_NOPS (fn);
|
|
|
991 if (TREE_CODE (fn) == ADDR_EXPR)
|
|
|
992 {
|
|
|
993 fn = TREE_OPERAND (fn, 0);
|
|
|
994 if (TREE_CODE (fn) == FUNCTION_DECL)
|
|
|
995 return fn;
|
|
|
996 }
|
|
|
997 return NULL_TREE;
|
|
|
998 }
|
|
|
999
|
|
|
1000 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
|
|
|
1001 constexpr machinery. */
|
|
|
1002
|
|
|
1003 tree
|
|
|
1004 cp_get_callee_fndecl (tree call)
|
|
|
1005 {
|
|
|
1006 return cp_get_fndecl_from_callee (cp_get_callee (call));
|
|
|
1007 }
|
|
|
1008
|
|
131
|
1009 /* As above, but not using the constexpr machinery. */
|
|
|
1010
|
|
|
1011 tree
|
|
|
1012 cp_get_callee_fndecl_nofold (tree call)
|
|
|
1013 {
|
|
|
1014 return cp_get_fndecl_from_callee (cp_get_callee (call), false);
|
|
|
1015 }
|
|
|
1016
|
|
111
|
1017 /* Subroutine of convert_to_void. Warn if we're discarding something with
|
|
|
1018 attribute [[nodiscard]]. */
|
|
|
1019
|
|
|
1020 static void
|
|
|
1021 maybe_warn_nodiscard (tree expr, impl_conv_void implicit)
|
|
|
1022 {
|
|
|
1023 tree call = expr;
|
|
|
1024 if (TREE_CODE (expr) == TARGET_EXPR)
|
|
|
1025 call = TARGET_EXPR_INITIAL (expr);
|
|
145
|
1026 location_t loc = cp_expr_loc_or_input_loc (call);
|
|
111
|
1027 tree callee = cp_get_callee (call);
|
|
|
1028 if (!callee)
|
|
|
1029 return;
|
|
|
1030
|
|
|
1031 tree type = TREE_TYPE (callee);
|
|
|
1032 if (TYPE_PTRMEMFUNC_P (type))
|
|
|
1033 type = TYPE_PTRMEMFUNC_FN_TYPE (type);
|
|
131
|
1034 if (INDIRECT_TYPE_P (type))
|
|
111
|
1035 type = TREE_TYPE (type);
|
|
|
1036
|
|
|
1037 tree rettype = TREE_TYPE (type);
|
|
|
1038 tree fn = cp_get_fndecl_from_callee (callee);
|
|
145
|
1039 tree attr;
|
|
111
|
1040 if (implicit != ICV_CAST && fn
|
|
145
|
1041 && (attr = lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn))))
|
|
111
|
1042 {
|
|
145
|
1043 escaped_string msg;
|
|
|
1044 tree args = TREE_VALUE (attr);
|
|
|
1045 if (args)
|
|
|
1046 msg.escape (TREE_STRING_POINTER (TREE_VALUE (args)));
|
|
|
1047 const char *format
|
|
|
1048 = (msg
|
|
|
1049 ? G_("ignoring return value of %qD, "
|
|
|
1050 "declared with attribute %<nodiscard%>: %<%s%>")
|
|
|
1051 : G_("ignoring return value of %qD, "
|
|
|
1052 "declared with attribute %<nodiscard%>%s"));
|
|
|
1053 const char *raw_msg = msg ? (const char *) msg : "";
|
|
131
|
1054 auto_diagnostic_group d;
|
|
145
|
1055 if (warning_at (loc, OPT_Wunused_result, format, fn, raw_msg))
|
|
111
|
1056 inform (DECL_SOURCE_LOCATION (fn), "declared here");
|
|
|
1057 }
|
|
|
1058 else if (implicit != ICV_CAST
|
|
145
|
1059 && (attr = lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype))))
|
|
111
|
1060 {
|
|
145
|
1061 escaped_string msg;
|
|
|
1062 tree args = TREE_VALUE (attr);
|
|
|
1063 if (args)
|
|
|
1064 msg.escape (TREE_STRING_POINTER (TREE_VALUE (args)));
|
|
|
1065 const char *format
|
|
|
1066 = (msg
|
|
|
1067 ? G_("ignoring returned value of type %qT, "
|
|
|
1068 "declared with attribute %<nodiscard%>: %<%s%>")
|
|
|
1069 : G_("ignoring returned value of type %qT, "
|
|
|
1070 "declared with attribute %<nodiscard%>%s"));
|
|
|
1071 const char *raw_msg = msg ? (const char *) msg : "";
|
|
131
|
1072 auto_diagnostic_group d;
|
|
145
|
1073 if (warning_at (loc, OPT_Wunused_result, format, rettype, raw_msg))
|
|
111
|
1074 {
|
|
|
1075 if (fn)
|
|
|
1076 inform (DECL_SOURCE_LOCATION (fn),
|
|
|
1077 "in call to %qD, declared here", fn);
|
|
|
1078 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype)),
|
|
|
1079 "%qT declared here", rettype);
|
|
|
1080 }
|
|
|
1081 }
|
|
|
1082 else if (TREE_CODE (expr) == TARGET_EXPR
|
|
|
1083 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type)))
|
|
|
1084 {
|
|
|
1085 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
|
|
|
1086 result is used, so handle that case here. */
|
|
|
1087 if (fn)
|
|
|
1088 {
|
|
131
|
1089 auto_diagnostic_group d;
|
|
111
|
1090 if (warning_at (loc, OPT_Wunused_result,
|
|
|
1091 "ignoring return value of %qD, "
|
|
145
|
1092 "declared with attribute %<warn_unused_result%>",
|
|
111
|
1093 fn))
|
|
|
1094 inform (DECL_SOURCE_LOCATION (fn), "declared here");
|
|
|
1095 }
|
|
|
1096 else
|
|
|
1097 warning_at (loc, OPT_Wunused_result,
|
|
|
1098 "ignoring return value of function "
|
|
145
|
1099 "declared with attribute %<warn_unused_result%>");
|
|
111
|
1100 }
|
|
|
1101 }
|
|
|
1102
|
|
|
1103 /* When an expression is used in a void context, its value is discarded and
|
|
|
1104 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
|
|
|
1105 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
|
|
|
1106 in a void context. The C++ standard does not define what an `access' to an
|
|
|
1107 object is, but there is reason to believe that it is the lvalue to rvalue
|
|
|
1108 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
|
|
|
1109 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
|
|
|
1110 indicates that volatile semantics should be the same between C and C++
|
|
|
1111 where ever possible. C leaves it implementation defined as to what
|
|
|
1112 constitutes an access to a volatile. So, we interpret `*vp' as a read of
|
|
|
1113 the volatile object `vp' points to, unless that is an incomplete type. For
|
|
|
1114 volatile references we do not do this interpretation, because that would
|
|
|
1115 make it impossible to ignore the reference return value from functions. We
|
|
|
1116 issue warnings in the confusing cases.
|
|
|
1117
|
|
|
1118 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
|
|
|
1119 to void via a cast. If an expression is being implicitly converted, IMPLICIT
|
|
|
1120 indicates the context of the implicit conversion. */
|
|
|
1121
|
|
|
1122 tree
|
|
|
1123 convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
|
|
|
1124 {
|
|
145
|
1125 location_t loc = cp_expr_loc_or_input_loc (expr);
|
|
111
|
1126
|
|
|
1127 if (expr == error_mark_node
|
|
|
1128 || TREE_TYPE (expr) == error_mark_node)
|
|
|
1129 return error_mark_node;
|
|
|
1130
|
|
131
|
1131 expr = maybe_undo_parenthesized_ref (expr);
|
|
|
1132
|
|
111
|
1133 expr = mark_discarded_use (expr);
|
|
|
1134 if (implicit == ICV_CAST)
|
|
|
1135 /* An explicit cast to void avoids all -Wunused-but-set* warnings. */
|
|
|
1136 mark_exp_read (expr);
|
|
|
1137
|
|
|
1138 if (!TREE_TYPE (expr))
|
|
|
1139 return expr;
|
|
|
1140 if (invalid_nonstatic_memfn_p (loc, expr, complain))
|
|
|
1141 return error_mark_node;
|
|
|
1142 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
|
|
|
1143 {
|
|
|
1144 if (complain & tf_error)
|
|
|
1145 error_at (loc, "pseudo-destructor is not called");
|
|
|
1146 return error_mark_node;
|
|
|
1147 }
|
|
145
|
1148
|
|
|
1149 /* Explicitly evaluate void-converted concept checks since their
|
|
|
1150 satisfaction may produce ill-formed programs. */
|
|
|
1151 if (concept_check_p (expr))
|
|
|
1152 expr = evaluate_concept_check (expr, tf_warning_or_error);
|
|
|
1153
|
|
111
|
1154 if (VOID_TYPE_P (TREE_TYPE (expr)))
|
|
|
1155 return expr;
|
|
|
1156 switch (TREE_CODE (expr))
|
|
|
1157 {
|
|
|
1158 case COND_EXPR:
|
|
|
1159 {
|
|
|
1160 /* The two parts of a cond expr might be separate lvalues. */
|
|
|
1161 tree op1 = TREE_OPERAND (expr,1);
|
|
|
1162 tree op2 = TREE_OPERAND (expr,2);
|
|
|
1163 bool side_effects = ((op1 && TREE_SIDE_EFFECTS (op1))
|
|
|
1164 || TREE_SIDE_EFFECTS (op2));
|
|
|
1165 tree new_op1, new_op2;
|
|
|
1166 new_op1 = NULL_TREE;
|
|
|
1167 if (implicit != ICV_CAST && !side_effects)
|
|
|
1168 {
|
|
|
1169 if (op1)
|
|
|
1170 new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain);
|
|
|
1171 new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain);
|
|
|
1172 }
|
|
|
1173 else
|
|
|
1174 {
|
|
|
1175 if (op1)
|
|
|
1176 new_op1 = convert_to_void (op1, ICV_CAST, complain);
|
|
|
1177 new_op2 = convert_to_void (op2, ICV_CAST, complain);
|
|
|
1178 }
|
|
|
1179
|
|
|
1180 expr = build3 (COND_EXPR, TREE_TYPE (new_op2),
|
|
|
1181 TREE_OPERAND (expr, 0), new_op1, new_op2);
|
|
|
1182 break;
|
|
|
1183 }
|
|
|
1184
|
|
|
1185 case COMPOUND_EXPR:
|
|
|
1186 {
|
|
|
1187 /* The second part of a compound expr contains the value. */
|
|
|
1188 tree op1 = TREE_OPERAND (expr,1);
|
|
|
1189 tree new_op1;
|
|
|
1190 if (implicit != ICV_CAST && !TREE_NO_WARNING (expr))
|
|
|
1191 new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain);
|
|
|
1192 else
|
|
|
1193 new_op1 = convert_to_void (op1, ICV_CAST, complain);
|
|
|
1194
|
|
|
1195 if (new_op1 != op1)
|
|
|
1196 {
|
|
|
1197 tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1),
|
|
|
1198 TREE_OPERAND (expr, 0), new_op1);
|
|
|
1199 expr = t;
|
|
|
1200 }
|
|
|
1201
|
|
|
1202 break;
|
|
|
1203 }
|
|
|
1204
|
|
|
1205 case NON_LVALUE_EXPR:
|
|
|
1206 case NOP_EXPR:
|
|
|
1207 /* These have already decayed to rvalue. */
|
|
|
1208 break;
|
|
|
1209
|
|
|
1210 case CALL_EXPR: /* We have a special meaning for volatile void fn(). */
|
|
145
|
1211 /* cdtors may return this or void, depending on
|
|
|
1212 targetm.cxx.cdtor_returns_this, but this shouldn't affect our
|
|
|
1213 decisions here: neither nodiscard warnings (nodiscard cdtors
|
|
|
1214 are nonsensical), nor should any constexpr or template
|
|
|
1215 instantiations be affected by an ABI property that is, or at
|
|
|
1216 least ought to be transparent to the language. */
|
|
|
1217 if (tree fn = cp_get_callee_fndecl_nofold (expr))
|
|
|
1218 if (DECL_DESTRUCTOR_P (fn))
|
|
|
1219 return expr;
|
|
|
1220
|
|
|
1221 if (complain & tf_warning)
|
|
|
1222 maybe_warn_nodiscard (expr, implicit);
|
|
111
|
1223 break;
|
|
|
1224
|
|
|
1225 case INDIRECT_REF:
|
|
|
1226 {
|
|
|
1227 tree type = TREE_TYPE (expr);
|
|
131
|
1228 int is_reference = TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0)));
|
|
111
|
1229 int is_volatile = TYPE_VOLATILE (type);
|
|
|
1230 int is_complete = COMPLETE_TYPE_P (complete_type (type));
|
|
|
1231
|
|
|
1232 /* Can't load the value if we don't know the type. */
|
|
|
1233 if (is_volatile && !is_complete)
|
|
|
1234 {
|
|
|
1235 if (complain & tf_warning)
|
|
|
1236 switch (implicit)
|
|
|
1237 {
|
|
|
1238 case ICV_CAST:
|
|
|
1239 warning_at (loc, 0, "conversion to void will not access "
|
|
|
1240 "object of incomplete type %qT", type);
|
|
|
1241 break;
|
|
|
1242 case ICV_SECOND_OF_COND:
|
|
|
1243 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1244 "incomplete type %qT in second operand "
|
|
|
1245 "of conditional expression", type);
|
|
|
1246 break;
|
|
|
1247 case ICV_THIRD_OF_COND:
|
|
|
1248 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1249 "incomplete type %qT in third operand "
|
|
|
1250 "of conditional expression", type);
|
|
|
1251 break;
|
|
|
1252 case ICV_RIGHT_OF_COMMA:
|
|
|
1253 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1254 "incomplete type %qT in right operand of "
|
|
|
1255 "comma operator", type);
|
|
|
1256 break;
|
|
|
1257 case ICV_LEFT_OF_COMMA:
|
|
|
1258 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1259 "incomplete type %qT in left operand of "
|
|
|
1260 "comma operator", type);
|
|
|
1261 break;
|
|
|
1262 case ICV_STATEMENT:
|
|
|
1263 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1264 "incomplete type %qT in statement", type);
|
|
|
1265 break;
|
|
|
1266 case ICV_THIRD_IN_FOR:
|
|
|
1267 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1268 "incomplete type %qT in for increment "
|
|
|
1269 "expression", type);
|
|
|
1270 break;
|
|
|
1271 default:
|
|
|
1272 gcc_unreachable ();
|
|
|
1273 }
|
|
|
1274 }
|
|
|
1275 /* Don't load the value if this is an implicit dereference, or if
|
|
|
1276 the type needs to be handled by ctors/dtors. */
|
|
|
1277 else if (is_volatile && is_reference)
|
|
|
1278 {
|
|
|
1279 if (complain & tf_warning)
|
|
|
1280 switch (implicit)
|
|
|
1281 {
|
|
|
1282 case ICV_CAST:
|
|
|
1283 warning_at (loc, 0, "conversion to void will not access "
|
|
|
1284 "object of type %qT", type);
|
|
|
1285 break;
|
|
|
1286 case ICV_SECOND_OF_COND:
|
|
|
1287 warning_at (loc, 0, "implicit dereference will not access "
|
|
|
1288 "object of type %qT in second operand of "
|
|
|
1289 "conditional expression", type);
|
|
|
1290 break;
|
|
|
1291 case ICV_THIRD_OF_COND:
|
|
|
1292 warning_at (loc, 0, "implicit dereference will not access "
|
|
|
1293 "object of type %qT in third operand of "
|
|
|
1294 "conditional expression", type);
|
|
|
1295 break;
|
|
|
1296 case ICV_RIGHT_OF_COMMA:
|
|
|
1297 warning_at (loc, 0, "implicit dereference will not access "
|
|
|
1298 "object of type %qT in right operand of "
|
|
|
1299 "comma operator", type);
|
|
|
1300 break;
|
|
|
1301 case ICV_LEFT_OF_COMMA:
|
|
|
1302 warning_at (loc, 0, "implicit dereference will not access "
|
|
|
1303 "object of type %qT in left operand of comma "
|
|
|
1304 "operator", type);
|
|
|
1305 break;
|
|
|
1306 case ICV_STATEMENT:
|
|
|
1307 warning_at (loc, 0, "implicit dereference will not access "
|
|
|
1308 "object of type %qT in statement", type);
|
|
|
1309 break;
|
|
|
1310 case ICV_THIRD_IN_FOR:
|
|
|
1311 warning_at (loc, 0, "implicit dereference will not access "
|
|
|
1312 "object of type %qT in for increment expression",
|
|
|
1313 type);
|
|
|
1314 break;
|
|
|
1315 default:
|
|
|
1316 gcc_unreachable ();
|
|
|
1317 }
|
|
|
1318 }
|
|
|
1319 else if (is_volatile && TREE_ADDRESSABLE (type))
|
|
|
1320 {
|
|
|
1321 if (complain & tf_warning)
|
|
|
1322 switch (implicit)
|
|
|
1323 {
|
|
|
1324 case ICV_CAST:
|
|
|
1325 warning_at (loc, 0, "conversion to void will not access "
|
|
|
1326 "object of non-trivially-copyable type %qT",
|
|
|
1327 type);
|
|
|
1328 break;
|
|
|
1329 case ICV_SECOND_OF_COND:
|
|
|
1330 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1331 "non-trivially-copyable type %qT in second "
|
|
|
1332 "operand of conditional expression", type);
|
|
|
1333 break;
|
|
|
1334 case ICV_THIRD_OF_COND:
|
|
|
1335 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1336 "non-trivially-copyable type %qT in third "
|
|
|
1337 "operand of conditional expression", type);
|
|
|
1338 break;
|
|
|
1339 case ICV_RIGHT_OF_COMMA:
|
|
|
1340 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1341 "non-trivially-copyable type %qT in right "
|
|
|
1342 "operand of comma operator", type);
|
|
|
1343 break;
|
|
|
1344 case ICV_LEFT_OF_COMMA:
|
|
|
1345 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1346 "non-trivially-copyable type %qT in left "
|
|
|
1347 "operand of comma operator", type);
|
|
|
1348 break;
|
|
|
1349 case ICV_STATEMENT:
|
|
|
1350 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1351 "non-trivially-copyable type %qT in statement",
|
|
|
1352 type);
|
|
|
1353 break;
|
|
|
1354 case ICV_THIRD_IN_FOR:
|
|
|
1355 warning_at (loc, 0, "indirection will not access object of "
|
|
|
1356 "non-trivially-copyable type %qT in for "
|
|
|
1357 "increment expression", type);
|
|
|
1358 break;
|
|
|
1359 default:
|
|
|
1360 gcc_unreachable ();
|
|
|
1361 }
|
|
|
1362 }
|
|
|
1363 if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
|
|
|
1364 {
|
|
|
1365 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
|
|
|
1366 operation is stripped off. Note that we don't warn about
|
|
|
1367 - an expression with TREE_NO_WARNING set. (For an example of
|
|
|
1368 such expressions, see build_over_call in call.c.)
|
|
|
1369 - automatic dereferencing of references, since the user cannot
|
|
|
1370 control it. (See also warn_if_unused_value() in c-common.c.) */
|
|
|
1371 if (warn_unused_value
|
|
|
1372 && implicit != ICV_CAST
|
|
|
1373 && (complain & tf_warning)
|
|
|
1374 && !TREE_NO_WARNING (expr)
|
|
|
1375 && !is_reference)
|
|
|
1376 warning_at (loc, OPT_Wunused_value, "value computed is not used");
|
|
|
1377 expr = TREE_OPERAND (expr, 0);
|
|
145
|
1378 if (TREE_CODE (expr) == CALL_EXPR
|
|
|
1379 && (complain & tf_warning))
|
|
111
|
1380 maybe_warn_nodiscard (expr, implicit);
|
|
|
1381 }
|
|
|
1382
|
|
|
1383 break;
|
|
|
1384 }
|
|
|
1385
|
|
|
1386 case VAR_DECL:
|
|
|
1387 {
|
|
|
1388 /* External variables might be incomplete. */
|
|
|
1389 tree type = TREE_TYPE (expr);
|
|
|
1390 int is_complete = COMPLETE_TYPE_P (complete_type (type));
|
|
|
1391
|
|
|
1392 if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
|
|
|
1393 switch (implicit)
|
|
|
1394 {
|
|
|
1395 case ICV_CAST:
|
|
|
1396 warning_at (loc, 0, "conversion to void will not access "
|
|
|
1397 "object %qE of incomplete type %qT", expr, type);
|
|
|
1398 break;
|
|
|
1399 case ICV_SECOND_OF_COND:
|
|
|
1400 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
|
|
|
1401 "not be accessed in second operand of "
|
|
|
1402 "conditional expression", expr, type);
|
|
|
1403 break;
|
|
|
1404 case ICV_THIRD_OF_COND:
|
|
|
1405 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
|
|
|
1406 "not be accessed in third operand of "
|
|
|
1407 "conditional expression", expr, type);
|
|
|
1408 break;
|
|
|
1409 case ICV_RIGHT_OF_COMMA:
|
|
|
1410 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
|
|
|
1411 "not be accessed in right operand of comma operator",
|
|
|
1412 expr, type);
|
|
|
1413 break;
|
|
|
1414 case ICV_LEFT_OF_COMMA:
|
|
|
1415 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
|
|
|
1416 "not be accessed in left operand of comma operator",
|
|
|
1417 expr, type);
|
|
|
1418 break;
|
|
|
1419 case ICV_STATEMENT:
|
|
|
1420 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
|
|
|
1421 "not be accessed in statement", expr, type);
|
|
|
1422 break;
|
|
|
1423 case ICV_THIRD_IN_FOR:
|
|
|
1424 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
|
|
|
1425 "not be accessed in for increment expression",
|
|
|
1426 expr, type);
|
|
|
1427 break;
|
|
|
1428 default:
|
|
|
1429 gcc_unreachable ();
|
|
|
1430 }
|
|
|
1431
|
|
|
1432 break;
|
|
|
1433 }
|
|
|
1434
|
|
|
1435 case TARGET_EXPR:
|
|
|
1436 /* Don't bother with the temporary object returned from a function if
|
|
|
1437 we don't use it, don't need to destroy it, and won't abort in
|
|
|
1438 assign_temp. We'll still
|
|
|
1439 allocate space for it in expand_call or declare_return_variable,
|
|
|
1440 but we don't need to track it through all the tree phases. */
|
|
|
1441 if (TARGET_EXPR_IMPLICIT_P (expr)
|
|
|
1442 && !TREE_ADDRESSABLE (TREE_TYPE (expr)))
|
|
|
1443 {
|
|
|
1444 tree init = TARGET_EXPR_INITIAL (expr);
|
|
|
1445 if (TREE_CODE (init) == AGGR_INIT_EXPR
|
|
|
1446 && !AGGR_INIT_VIA_CTOR_P (init))
|
|
|
1447 {
|
|
|
1448 tree fn = AGGR_INIT_EXPR_FN (init);
|
|
|
1449 expr = build_call_array_loc (input_location,
|
|
|
1450 TREE_TYPE (TREE_TYPE
|
|
|
1451 (TREE_TYPE (fn))),
|
|
|
1452 fn,
|
|
|
1453 aggr_init_expr_nargs (init),
|
|
|
1454 AGGR_INIT_EXPR_ARGP (init));
|
|
|
1455 }
|
|
|
1456 }
|
|
145
|
1457 if (complain & tf_warning)
|
|
|
1458 maybe_warn_nodiscard (expr, implicit);
|
|
111
|
1459 break;
|
|
|
1460
|
|
|
1461 default:;
|
|
|
1462 }
|
|
|
1463 expr = resolve_nondeduced_context (expr, complain);
|
|
|
1464 {
|
|
|
1465 tree probe = expr;
|
|
|
1466
|
|
|
1467 if (TREE_CODE (probe) == ADDR_EXPR)
|
|
|
1468 probe = TREE_OPERAND (expr, 0);
|
|
|
1469 if (type_unknown_p (probe))
|
|
|
1470 {
|
|
|
1471 /* [over.over] enumerates the places where we can take the address
|
|
|
1472 of an overloaded function, and this is not one of them. */
|
|
|
1473 if (complain & tf_error)
|
|
|
1474 switch (implicit)
|
|
|
1475 {
|
|
|
1476 case ICV_CAST:
|
|
|
1477 error_at (loc, "conversion to void "
|
|
|
1478 "cannot resolve address of overloaded function");
|
|
|
1479 break;
|
|
|
1480 case ICV_SECOND_OF_COND:
|
|
|
1481 error_at (loc, "second operand of conditional expression "
|
|
|
1482 "cannot resolve address of overloaded function");
|
|
|
1483 break;
|
|
|
1484 case ICV_THIRD_OF_COND:
|
|
|
1485 error_at (loc, "third operand of conditional expression "
|
|
|
1486 "cannot resolve address of overloaded function");
|
|
|
1487 break;
|
|
|
1488 case ICV_RIGHT_OF_COMMA:
|
|
|
1489 error_at (loc, "right operand of comma operator "
|
|
|
1490 "cannot resolve address of overloaded function");
|
|
|
1491 break;
|
|
|
1492 case ICV_LEFT_OF_COMMA:
|
|
|
1493 error_at (loc, "left operand of comma operator "
|
|
|
1494 "cannot resolve address of overloaded function");
|
|
|
1495 break;
|
|
|
1496 case ICV_STATEMENT:
|
|
|
1497 error_at (loc, "statement "
|
|
|
1498 "cannot resolve address of overloaded function");
|
|
|
1499 break;
|
|
|
1500 case ICV_THIRD_IN_FOR:
|
|
|
1501 error_at (loc, "for increment expression "
|
|
|
1502 "cannot resolve address of overloaded function");
|
|
|
1503 break;
|
|
|
1504 }
|
|
|
1505 else
|
|
|
1506 return error_mark_node;
|
|
|
1507 expr = void_node;
|
|
|
1508 }
|
|
|
1509 else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe))
|
|
|
1510 {
|
|
|
1511 /* Only warn when there is no &. */
|
|
|
1512 if (complain & tf_warning)
|
|
|
1513 switch (implicit)
|
|
|
1514 {
|
|
|
1515 case ICV_SECOND_OF_COND:
|
|
|
1516 warning_at (loc, OPT_Waddress,
|
|
|
1517 "second operand of conditional expression "
|
|
|
1518 "is a reference, not call, to function %qE", expr);
|
|
|
1519 break;
|
|
|
1520 case ICV_THIRD_OF_COND:
|
|
|
1521 warning_at (loc, OPT_Waddress,
|
|
|
1522 "third operand of conditional expression "
|
|
|
1523 "is a reference, not call, to function %qE", expr);
|
|
|
1524 break;
|
|
|
1525 case ICV_RIGHT_OF_COMMA:
|
|
|
1526 warning_at (loc, OPT_Waddress,
|
|
|
1527 "right operand of comma operator "
|
|
|
1528 "is a reference, not call, to function %qE", expr);
|
|
|
1529 break;
|
|
|
1530 case ICV_LEFT_OF_COMMA:
|
|
|
1531 warning_at (loc, OPT_Waddress,
|
|
|
1532 "left operand of comma operator "
|
|
|
1533 "is a reference, not call, to function %qE", expr);
|
|
|
1534 break;
|
|
|
1535 case ICV_STATEMENT:
|
|
|
1536 warning_at (loc, OPT_Waddress,
|
|
|
1537 "statement is a reference, not call, to function %qE",
|
|
|
1538 expr);
|
|
|
1539 break;
|
|
|
1540 case ICV_THIRD_IN_FOR:
|
|
|
1541 warning_at (loc, OPT_Waddress,
|
|
|
1542 "for increment expression "
|
|
|
1543 "is a reference, not call, to function %qE", expr);
|
|
|
1544 break;
|
|
|
1545 default:
|
|
|
1546 gcc_unreachable ();
|
|
|
1547 }
|
|
|
1548
|
|
|
1549 if (TREE_CODE (expr) == COMPONENT_REF)
|
|
|
1550 expr = TREE_OPERAND (expr, 0);
|
|
|
1551 }
|
|
|
1552 }
|
|
|
1553
|
|
|
1554 if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
|
|
|
1555 {
|
|
|
1556 if (implicit != ICV_CAST
|
|
|
1557 && warn_unused_value
|
|
|
1558 && !TREE_NO_WARNING (expr)
|
|
145
|
1559 && !processing_template_decl
|
|
|
1560 && !cp_unevaluated_operand)
|
|
111
|
1561 {
|
|
|
1562 /* The middle end does not warn about expressions that have
|
|
|
1563 been explicitly cast to void, so we must do so here. */
|
|
|
1564 if (!TREE_SIDE_EFFECTS (expr)) {
|
|
|
1565 if (complain & tf_warning)
|
|
|
1566 switch (implicit)
|
|
|
1567 {
|
|
|
1568 case ICV_SECOND_OF_COND:
|
|
|
1569 warning_at (loc, OPT_Wunused_value,
|
|
|
1570 "second operand of conditional expression "
|
|
|
1571 "has no effect");
|
|
|
1572 break;
|
|
|
1573 case ICV_THIRD_OF_COND:
|
|
|
1574 warning_at (loc, OPT_Wunused_value,
|
|
|
1575 "third operand of conditional expression "
|
|
|
1576 "has no effect");
|
|
|
1577 break;
|
|
|
1578 case ICV_RIGHT_OF_COMMA:
|
|
|
1579 warning_at (loc, OPT_Wunused_value,
|
|
|
1580 "right operand of comma operator has no effect");
|
|
|
1581 break;
|
|
|
1582 case ICV_LEFT_OF_COMMA:
|
|
|
1583 warning_at (loc, OPT_Wunused_value,
|
|
|
1584 "left operand of comma operator has no effect");
|
|
|
1585 break;
|
|
|
1586 case ICV_STATEMENT:
|
|
|
1587 warning_at (loc, OPT_Wunused_value,
|
|
|
1588 "statement has no effect");
|
|
|
1589 break;
|
|
|
1590 case ICV_THIRD_IN_FOR:
|
|
|
1591 warning_at (loc, OPT_Wunused_value,
|
|
|
1592 "for increment expression has no effect");
|
|
|
1593 break;
|
|
|
1594 default:
|
|
|
1595 gcc_unreachable ();
|
|
|
1596 }
|
|
|
1597 }
|
|
|
1598 else
|
|
|
1599 {
|
|
|
1600 tree e;
|
|
|
1601 enum tree_code code;
|
|
|
1602 enum tree_code_class tclass;
|
|
|
1603
|
|
|
1604 e = expr;
|
|
|
1605 /* We might like to warn about (say) "(int) f()", as the
|
|
|
1606 cast has no effect, but the compiler itself will
|
|
|
1607 generate implicit conversions under some
|
|
|
1608 circumstances. (For example a block copy will be
|
|
|
1609 turned into a call to "__builtin_memcpy", with a
|
|
|
1610 conversion of the return value to an appropriate
|
|
|
1611 type.) So, to avoid false positives, we strip
|
|
|
1612 conversions. Do not use STRIP_NOPs because it will
|
|
|
1613 not strip conversions to "void", as that is not a
|
|
|
1614 mode-preserving conversion. */
|
|
|
1615 while (TREE_CODE (e) == NOP_EXPR)
|
|
|
1616 e = TREE_OPERAND (e, 0);
|
|
|
1617
|
|
|
1618 code = TREE_CODE (e);
|
|
|
1619 tclass = TREE_CODE_CLASS (code);
|
|
|
1620 if ((tclass == tcc_comparison
|
|
|
1621 || tclass == tcc_unary
|
|
|
1622 || (tclass == tcc_binary
|
|
|
1623 && !(code == MODIFY_EXPR
|
|
|
1624 || code == INIT_EXPR
|
|
|
1625 || code == PREDECREMENT_EXPR
|
|
|
1626 || code == PREINCREMENT_EXPR
|
|
|
1627 || code == POSTDECREMENT_EXPR
|
|
|
1628 || code == POSTINCREMENT_EXPR))
|
|
|
1629 || code == VEC_PERM_EXPR
|
|
|
1630 || code == VEC_COND_EXPR)
|
|
|
1631 && (complain & tf_warning))
|
|
|
1632 warning_at (loc, OPT_Wunused_value, "value computed is not used");
|
|
|
1633 }
|
|
|
1634 }
|
|
|
1635 expr = build1 (CONVERT_EXPR, void_type_node, expr);
|
|
|
1636 }
|
|
|
1637 if (! TREE_SIDE_EFFECTS (expr))
|
|
|
1638 expr = void_node;
|
|
|
1639 return expr;
|
|
|
1640 }
|
|
|
1641
|
|
|
1642 /* Create an expression whose value is that of EXPR,
|
|
|
1643 converted to type TYPE. The TREE_TYPE of the value
|
|
|
1644 is always TYPE. This function implements all reasonable
|
|
|
1645 conversions; callers should filter out those that are
|
|
|
1646 not permitted by the language being compiled.
|
|
|
1647
|
|
|
1648 Most of this routine is from build_reinterpret_cast.
|
|
|
1649
|
|
|
1650 The back end cannot call cp_convert (what was convert) because
|
|
|
1651 conversions to/from basetypes may involve memory references
|
|
|
1652 (vbases) and adding or subtracting small values (multiple
|
|
|
1653 inheritance), but it calls convert from the constant folding code
|
|
|
1654 on subtrees of already built trees after it has ripped them apart.
|
|
|
1655
|
|
|
1656 Also, if we ever support range variables, we'll probably also have to
|
|
|
1657 do a little bit more work. */
|
|
|
1658
|
|
|
1659 tree
|
|
|
1660 convert (tree type, tree expr)
|
|
|
1661 {
|
|
|
1662 tree intype;
|
|
|
1663
|
|
|
1664 if (type == error_mark_node || expr == error_mark_node)
|
|
|
1665 return error_mark_node;
|
|
|
1666
|
|
|
1667 intype = TREE_TYPE (expr);
|
|
|
1668
|
|
131
|
1669 if (INDIRECT_TYPE_P (type) && INDIRECT_TYPE_P (intype))
|
|
111
|
1670 return build_nop (type, expr);
|
|
|
1671
|
|
|
1672 return ocp_convert (type, expr, CONV_BACKEND_CONVERT,
|
|
|
1673 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION,
|
|
|
1674 tf_warning_or_error);
|
|
|
1675 }
|
|
|
1676
|
|
|
1677 /* Like cp_convert, except permit conversions to take place which
|
|
|
1678 are not normally allowed due to access restrictions
|
|
|
1679 (such as conversion from sub-type to private super-type). */
|
|
|
1680
|
|
|
1681 tree
|
|
|
1682 convert_force (tree type, tree expr, int convtype, tsubst_flags_t complain)
|
|
|
1683 {
|
|
|
1684 tree e = expr;
|
|
|
1685 enum tree_code code = TREE_CODE (type);
|
|
|
1686
|
|
|
1687 if (code == REFERENCE_TYPE)
|
|
|
1688 return convert_to_reference (type, e, CONV_C_CAST, 0,
|
|
|
1689 NULL_TREE, complain);
|
|
|
1690
|
|
|
1691 if (code == POINTER_TYPE)
|
|
|
1692 return convert_to_pointer_force (type, e, complain);
|
|
|
1693
|
|
|
1694 /* From typeck.c convert_for_assignment */
|
|
|
1695 if (((TYPE_PTR_P (TREE_TYPE (e)) && TREE_CODE (e) == ADDR_EXPR
|
|
|
1696 && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
|
|
|
1697 || integer_zerop (e)
|
|
|
1698 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
|
|
|
1699 && TYPE_PTRMEMFUNC_P (type))
|
|
|
1700 /* compatible pointer to member functions. */
|
|
|
1701 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1,
|
|
|
1702 /*c_cast_p=*/1, complain);
|
|
|
1703
|
|
|
1704 return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL, complain);
|
|
|
1705 }
|
|
|
1706
|
|
|
1707 /* Convert an aggregate EXPR to type XTYPE. If a conversion
|
|
|
1708 exists, return the attempted conversion. This may
|
|
|
1709 return ERROR_MARK_NODE if the conversion is not
|
|
|
1710 allowed (references private members, etc).
|
|
|
1711 If no conversion exists, NULL_TREE is returned.
|
|
|
1712
|
|
|
1713 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
|
|
|
1714 object parameter, or by the second standard conversion sequence if
|
|
|
1715 that doesn't do it. This will probably wait for an overloading rewrite.
|
|
|
1716 (jason 8/9/95) */
|
|
|
1717
|
|
|
1718 static tree
|
|
|
1719 build_type_conversion (tree xtype, tree expr)
|
|
|
1720 {
|
|
|
1721 /* C++: check to see if we can convert this aggregate type
|
|
|
1722 into the required type. */
|
|
|
1723 return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL,
|
|
|
1724 tf_warning_or_error);
|
|
|
1725 }
|
|
|
1726
|
|
|
1727 /* Convert the given EXPR to one of a group of types suitable for use in an
|
|
|
1728 expression. DESIRES is a combination of various WANT_* flags (q.v.)
|
|
|
1729 which indicates which types are suitable. If COMPLAIN is true, complain
|
|
|
1730 about ambiguity; otherwise, the caller will deal with it. */
|
|
|
1731
|
|
|
1732 tree
|
|
|
1733 build_expr_type_conversion (int desires, tree expr, bool complain)
|
|
|
1734 {
|
|
|
1735 tree basetype = TREE_TYPE (expr);
|
|
|
1736 tree conv = NULL_TREE;
|
|
|
1737 tree winner = NULL_TREE;
|
|
|
1738
|
|
131
|
1739 if (null_node_p (expr)
|
|
111
|
1740 && (desires & WANT_INT)
|
|
|
1741 && !(desires & WANT_NULL))
|
|
|
1742 {
|
|
145
|
1743 location_t loc =
|
|
111
|
1744 expansion_point_location_if_in_system_header (input_location);
|
|
|
1745
|
|
|
1746 warning_at (loc, OPT_Wconversion_null,
|
|
|
1747 "converting NULL to non-pointer type");
|
|
|
1748 }
|
|
|
1749
|
|
|
1750 if (basetype == error_mark_node)
|
|
|
1751 return error_mark_node;
|
|
|
1752
|
|
|
1753 if (! MAYBE_CLASS_TYPE_P (basetype))
|
|
|
1754 switch (TREE_CODE (basetype))
|
|
|
1755 {
|
|
|
1756 case INTEGER_TYPE:
|
|
|
1757 if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
|
|
|
1758 return expr;
|
|
|
1759 /* fall through. */
|
|
|
1760
|
|
|
1761 case BOOLEAN_TYPE:
|
|
|
1762 return (desires & WANT_INT) ? expr : NULL_TREE;
|
|
|
1763 case ENUMERAL_TYPE:
|
|
|
1764 return (desires & WANT_ENUM) ? expr : NULL_TREE;
|
|
|
1765 case REAL_TYPE:
|
|
|
1766 return (desires & WANT_FLOAT) ? expr : NULL_TREE;
|
|
|
1767 case POINTER_TYPE:
|
|
|
1768 return (desires & WANT_POINTER) ? expr : NULL_TREE;
|
|
|
1769
|
|
|
1770 case FUNCTION_TYPE:
|
|
|
1771 case ARRAY_TYPE:
|
|
|
1772 return (desires & WANT_POINTER) ? decay_conversion (expr,
|
|
|
1773 tf_warning_or_error)
|
|
|
1774 : NULL_TREE;
|
|
|
1775
|
|
145
|
1776 case VECTOR_TYPE:
|
|
|
1777 if (!gnu_vector_type_p (basetype))
|
|
|
1778 return NULL_TREE;
|
|
|
1779 /* FALLTHROUGH */
|
|
111
|
1780 case COMPLEX_TYPE:
|
|
|
1781 if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
|
|
|
1782 return NULL_TREE;
|
|
|
1783 switch (TREE_CODE (TREE_TYPE (basetype)))
|
|
|
1784 {
|
|
|
1785 case INTEGER_TYPE:
|
|
|
1786 case BOOLEAN_TYPE:
|
|
|
1787 return (desires & WANT_INT) ? expr : NULL_TREE;
|
|
|
1788 case ENUMERAL_TYPE:
|
|
|
1789 return (desires & WANT_ENUM) ? expr : NULL_TREE;
|
|
|
1790 case REAL_TYPE:
|
|
|
1791 return (desires & WANT_FLOAT) ? expr : NULL_TREE;
|
|
|
1792 default:
|
|
|
1793 return NULL_TREE;
|
|
|
1794 }
|
|
|
1795
|
|
|
1796 default:
|
|
|
1797 return NULL_TREE;
|
|
|
1798 }
|
|
|
1799
|
|
|
1800 /* The code for conversions from class type is currently only used for
|
|
|
1801 delete expressions. Other expressions are handled by build_new_op. */
|
|
|
1802 if (!complete_type_or_maybe_complain (basetype, expr, complain))
|
|
|
1803 return error_mark_node;
|
|
|
1804 if (!TYPE_HAS_CONVERSION (basetype))
|
|
|
1805 return NULL_TREE;
|
|
|
1806
|
|
|
1807 for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
|
|
|
1808 {
|
|
|
1809 int win = 0;
|
|
|
1810 tree candidate;
|
|
|
1811 tree cand = TREE_VALUE (conv);
|
|
|
1812 cand = OVL_FIRST (cand);
|
|
|
1813
|
|
|
1814 if (winner && winner == cand)
|
|
|
1815 continue;
|
|
|
1816
|
|
|
1817 if (DECL_NONCONVERTING_P (cand))
|
|
|
1818 continue;
|
|
|
1819
|
|
|
1820 candidate = non_reference (TREE_TYPE (TREE_TYPE (cand)));
|
|
|
1821
|
|
|
1822 switch (TREE_CODE (candidate))
|
|
|
1823 {
|
|
|
1824 case BOOLEAN_TYPE:
|
|
|
1825 case INTEGER_TYPE:
|
|
|
1826 win = (desires & WANT_INT); break;
|
|
|
1827 case ENUMERAL_TYPE:
|
|
|
1828 win = (desires & WANT_ENUM); break;
|
|
|
1829 case REAL_TYPE:
|
|
|
1830 win = (desires & WANT_FLOAT); break;
|
|
|
1831 case POINTER_TYPE:
|
|
|
1832 win = (desires & WANT_POINTER); break;
|
|
|
1833
|
|
|
1834 case COMPLEX_TYPE:
|
|
|
1835 case VECTOR_TYPE:
|
|
|
1836 if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
|
|
|
1837 break;
|
|
|
1838 switch (TREE_CODE (TREE_TYPE (candidate)))
|
|
|
1839 {
|
|
|
1840 case BOOLEAN_TYPE:
|
|
|
1841 case INTEGER_TYPE:
|
|
|
1842 win = (desires & WANT_INT); break;
|
|
|
1843 case ENUMERAL_TYPE:
|
|
|
1844 win = (desires & WANT_ENUM); break;
|
|
|
1845 case REAL_TYPE:
|
|
|
1846 win = (desires & WANT_FLOAT); break;
|
|
|
1847 default:
|
|
|
1848 break;
|
|
|
1849 }
|
|
|
1850 break;
|
|
|
1851
|
|
|
1852 default:
|
|
|
1853 /* A wildcard could be instantiated to match any desired
|
|
|
1854 type, but we can't deduce the template argument. */
|
|
|
1855 if (WILDCARD_TYPE_P (candidate))
|
|
|
1856 win = true;
|
|
|
1857 break;
|
|
|
1858 }
|
|
|
1859
|
|
|
1860 if (win)
|
|
|
1861 {
|
|
|
1862 if (TREE_CODE (cand) == TEMPLATE_DECL)
|
|
|
1863 {
|
|
|
1864 if (complain)
|
|
145
|
1865 error ("default type conversion cannot deduce template"
|
|
111
|
1866 " argument for %qD", cand);
|
|
|
1867 return error_mark_node;
|
|
|
1868 }
|
|
|
1869
|
|
|
1870 if (winner)
|
|
|
1871 {
|
|
|
1872 tree winner_type
|
|
|
1873 = non_reference (TREE_TYPE (TREE_TYPE (winner)));
|
|
|
1874
|
|
|
1875 if (!same_type_ignoring_top_level_qualifiers_p (winner_type,
|
|
|
1876 candidate))
|
|
|
1877 {
|
|
|
1878 if (complain)
|
|
|
1879 {
|
|
|
1880 error ("ambiguous default type conversion from %qT",
|
|
|
1881 basetype);
|
|
|
1882 inform (input_location,
|
|
|
1883 " candidate conversions include %qD and %qD",
|
|
|
1884 winner, cand);
|
|
|
1885 }
|
|
|
1886 return error_mark_node;
|
|
|
1887 }
|
|
|
1888 }
|
|
|
1889
|
|
|
1890 winner = cand;
|
|
|
1891 }
|
|
|
1892 }
|
|
|
1893
|
|
|
1894 if (winner)
|
|
|
1895 {
|
|
|
1896 tree type = non_reference (TREE_TYPE (TREE_TYPE (winner)));
|
|
|
1897 return build_user_type_conversion (type, expr, LOOKUP_NORMAL,
|
|
|
1898 tf_warning_or_error);
|
|
|
1899 }
|
|
|
1900
|
|
|
1901 return NULL_TREE;
|
|
|
1902 }
|
|
|
1903
|
|
|
1904 /* Implements integral promotion (4.1) and float->double promotion. */
|
|
|
1905
|
|
|
1906 tree
|
|
|
1907 type_promotes_to (tree type)
|
|
|
1908 {
|
|
|
1909 tree promoted_type;
|
|
|
1910
|
|
|
1911 if (type == error_mark_node)
|
|
|
1912 return error_mark_node;
|
|
|
1913
|
|
|
1914 type = TYPE_MAIN_VARIANT (type);
|
|
|
1915
|
|
|
1916 /* Check for promotions of target-defined types first. */
|
|
|
1917 promoted_type = targetm.promoted_type (type);
|
|
|
1918 if (promoted_type)
|
|
|
1919 return promoted_type;
|
|
|
1920
|
|
|
1921 /* bool always promotes to int (not unsigned), even if it's the same
|
|
|
1922 size. */
|
|
|
1923 if (TREE_CODE (type) == BOOLEAN_TYPE)
|
|
|
1924 type = integer_type_node;
|
|
|
1925
|
|
|
1926 /* Normally convert enums to int, but convert wide enums to something
|
|
|
1927 wider. Scoped enums don't promote, but pretend they do for backward
|
|
|
1928 ABI bug compatibility wrt varargs. */
|
|
|
1929 else if (TREE_CODE (type) == ENUMERAL_TYPE
|
|
145
|
1930 || type == char8_type_node
|
|
111
|
1931 || type == char16_type_node
|
|
|
1932 || type == char32_type_node
|
|
|
1933 || type == wchar_type_node)
|
|
|
1934 {
|
|
|
1935 tree prom = type;
|
|
|
1936
|
|
|
1937 if (TREE_CODE (type) == ENUMERAL_TYPE)
|
|
|
1938 {
|
|
|
1939 prom = ENUM_UNDERLYING_TYPE (prom);
|
|
|
1940 if (!ENUM_IS_SCOPED (type)
|
|
|
1941 && ENUM_FIXED_UNDERLYING_TYPE_P (type))
|
|
|
1942 {
|
|
|
1943 /* ISO C++17, 7.6/4. A prvalue of an unscoped enumeration type
|
|
|
1944 whose underlying type is fixed (10.2) can be converted to a
|
|
|
1945 prvalue of its underlying type. Moreover, if integral promotion
|
|
|
1946 can be applied to its underlying type, a prvalue of an unscoped
|
|
|
1947 enumeration type whose underlying type is fixed can also be
|
|
|
1948 converted to a prvalue of the promoted underlying type. */
|
|
|
1949 return type_promotes_to (prom);
|
|
|
1950 }
|
|
|
1951 }
|
|
|
1952
|
|
|
1953 int precision = MAX (TYPE_PRECISION (type),
|
|
|
1954 TYPE_PRECISION (integer_type_node));
|
|
|
1955 tree totype = c_common_type_for_size (precision, 0);
|
|
|
1956 if (TYPE_UNSIGNED (prom)
|
|
|
1957 && ! int_fits_type_p (TYPE_MAX_VALUE (prom), totype))
|
|
|
1958 prom = c_common_type_for_size (precision, 1);
|
|
|
1959 else
|
|
|
1960 prom = totype;
|
|
|
1961 if (SCOPED_ENUM_P (type))
|
|
|
1962 {
|
|
|
1963 if (abi_version_crosses (6)
|
|
|
1964 && TYPE_MODE (prom) != TYPE_MODE (type))
|
|
145
|
1965 warning (OPT_Wabi, "scoped enum %qT passed through %<...%> as "
|
|
|
1966 "%qT before %<-fabi-version=6%>, %qT after",
|
|
111
|
1967 type, prom, ENUM_UNDERLYING_TYPE (type));
|
|
|
1968 if (!abi_version_at_least (6))
|
|
|
1969 type = prom;
|
|
|
1970 }
|
|
|
1971 else
|
|
|
1972 type = prom;
|
|
|
1973 }
|
|
|
1974 else if (c_promoting_integer_type_p (type))
|
|
|
1975 {
|
|
|
1976 /* Retain unsignedness if really not getting bigger. */
|
|
|
1977 if (TYPE_UNSIGNED (type)
|
|
|
1978 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
|
|
|
1979 type = unsigned_type_node;
|
|
|
1980 else
|
|
|
1981 type = integer_type_node;
|
|
|
1982 }
|
|
|
1983 else if (type == float_type_node)
|
|
|
1984 type = double_type_node;
|
|
|
1985
|
|
|
1986 return type;
|
|
|
1987 }
|
|
|
1988
|
|
|
1989 /* The routines below this point are carefully written to conform to
|
|
|
1990 the standard. They use the same terminology, and follow the rules
|
|
|
1991 closely. Although they are used only in pt.c at the moment, they
|
|
|
1992 should presumably be used everywhere in the future. */
|
|
|
1993
|
|
|
1994 /* True iff EXPR can be converted to TYPE via a qualification conversion.
|
|
|
1995 Callers should check for identical types before calling this function. */
|
|
|
1996
|
|
|
1997 bool
|
|
|
1998 can_convert_qual (tree type, tree expr)
|
|
|
1999 {
|
|
|
2000 tree expr_type = TREE_TYPE (expr);
|
|
|
2001 gcc_assert (!same_type_p (type, expr_type));
|
|
|
2002
|
|
|
2003 if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type))
|
|
|
2004 return comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type));
|
|
|
2005 else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (expr_type))
|
|
|
2006 return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
|
|
|
2007 TYPE_PTRMEM_CLASS_TYPE (expr_type))
|
|
|
2008 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type),
|
|
|
2009 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type)));
|
|
|
2010 else
|
|
|
2011 return false;
|
|
|
2012 }
|
|
|
2013
|
|
|
2014 /* Attempt to perform qualification conversions on EXPR to convert it
|
|
|
2015 to TYPE. Return the resulting expression, or error_mark_node if
|
|
131
|
2016 the conversion was impossible. Since this is only used by
|
|
|
2017 convert_nontype_argument, we fold the conversion. */
|
|
111
|
2018
|
|
|
2019 tree
|
|
|
2020 perform_qualification_conversions (tree type, tree expr)
|
|
|
2021 {
|
|
|
2022 tree expr_type;
|
|
|
2023
|
|
|
2024 expr_type = TREE_TYPE (expr);
|
|
|
2025
|
|
|
2026 if (same_type_p (type, expr_type))
|
|
|
2027 return expr;
|
|
|
2028 else if (can_convert_qual (type, expr))
|
|
131
|
2029 return cp_fold_convert (type, expr);
|
|
111
|
2030 else
|
|
|
2031 return error_mark_node;
|
|
|
2032 }
|
|
|
2033
|
|
|
2034 /* True iff T is a transaction-safe function type. */
|
|
|
2035
|
|
|
2036 bool
|
|
|
2037 tx_safe_fn_type_p (tree t)
|
|
|
2038 {
|
|
145
|
2039 if (!FUNC_OR_METHOD_TYPE_P (t))
|
|
111
|
2040 return false;
|
|
|
2041 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t));
|
|
|
2042 }
|
|
|
2043
|
|
|
2044 /* Return the transaction-unsafe variant of transaction-safe function type
|
|
|
2045 T. */
|
|
|
2046
|
|
|
2047 tree
|
|
|
2048 tx_unsafe_fn_variant (tree t)
|
|
|
2049 {
|
|
|
2050 gcc_assert (tx_safe_fn_type_p (t));
|
|
|
2051 tree attrs = remove_attribute ("transaction_safe",
|
|
|
2052 TYPE_ATTRIBUTES (t));
|
|
|
2053 return cp_build_type_attribute_variant (t, attrs);
|
|
|
2054 }
|
|
|
2055
|
|
|
2056 /* Return true iff FROM can convert to TO by a transaction-safety
|
|
|
2057 conversion. */
|
|
|
2058
|
|
|
2059 static bool
|
|
|
2060 can_convert_tx_safety (tree to, tree from)
|
|
|
2061 {
|
|
|
2062 return (flag_tm && tx_safe_fn_type_p (from)
|
|
|
2063 && same_type_p (to, tx_unsafe_fn_variant (from)));
|
|
|
2064 }
|
|
|
2065
|
|
|
2066 /* Return true iff FROM can convert to TO by dropping noexcept. */
|
|
|
2067
|
|
|
2068 static bool
|
|
|
2069 noexcept_conv_p (tree to, tree from)
|
|
|
2070 {
|
|
|
2071 if (!flag_noexcept_type)
|
|
|
2072 return false;
|
|
|
2073
|
|
|
2074 tree t = non_reference (to);
|
|
|
2075 tree f = from;
|
|
|
2076 if (TYPE_PTRMEMFUNC_P (t)
|
|
|
2077 && TYPE_PTRMEMFUNC_P (f))
|
|
|
2078 {
|
|
|
2079 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
|
|
|
2080 f = TYPE_PTRMEMFUNC_FN_TYPE (f);
|
|
|
2081 }
|
|
131
|
2082 if (TYPE_PTR_P (t)
|
|
|
2083 && TYPE_PTR_P (f))
|
|
111
|
2084 {
|
|
|
2085 t = TREE_TYPE (t);
|
|
|
2086 f = TREE_TYPE (f);
|
|
|
2087 }
|
|
|
2088 tree_code code = TREE_CODE (f);
|
|
|
2089 if (TREE_CODE (t) != code)
|
|
|
2090 return false;
|
|
|
2091 if (code != FUNCTION_TYPE && code != METHOD_TYPE)
|
|
|
2092 return false;
|
|
|
2093 if (!type_throw_all_p (t)
|
|
|
2094 || type_throw_all_p (f))
|
|
|
2095 return false;
|
|
|
2096 tree v = build_exception_variant (f, NULL_TREE);
|
|
|
2097 return same_type_p (t, v);
|
|
|
2098 }
|
|
|
2099
|
|
|
2100 /* Return true iff FROM can convert to TO by a function pointer conversion. */
|
|
|
2101
|
|
|
2102 bool
|
|
|
2103 fnptr_conv_p (tree to, tree from)
|
|
|
2104 {
|
|
|
2105 tree t = non_reference (to);
|
|
|
2106 tree f = from;
|
|
|
2107 if (TYPE_PTRMEMFUNC_P (t)
|
|
|
2108 && TYPE_PTRMEMFUNC_P (f))
|
|
|
2109 {
|
|
|
2110 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
|
|
|
2111 f = TYPE_PTRMEMFUNC_FN_TYPE (f);
|
|
|
2112 }
|
|
131
|
2113 if (TYPE_PTR_P (t)
|
|
|
2114 && TYPE_PTR_P (f))
|
|
111
|
2115 {
|
|
|
2116 t = TREE_TYPE (t);
|
|
|
2117 f = TREE_TYPE (f);
|
|
|
2118 }
|
|
|
2119
|
|
|
2120 return (noexcept_conv_p (t, f)
|
|
|
2121 || can_convert_tx_safety (t, f));
|
|
|
2122 }
|
|
|
2123
|
|
|
2124 /* Return FN with any NOP_EXPRs stripped that represent function pointer
|
|
|
2125 conversions or conversions to the same type. */
|
|
|
2126
|
|
|
2127 tree
|
|
|
2128 strip_fnptr_conv (tree fn)
|
|
|
2129 {
|
|
|
2130 while (TREE_CODE (fn) == NOP_EXPR)
|
|
|
2131 {
|
|
|
2132 tree op = TREE_OPERAND (fn, 0);
|
|
|
2133 tree ft = TREE_TYPE (fn);
|
|
|
2134 tree ot = TREE_TYPE (op);
|
|
|
2135 if (same_type_p (ft, ot)
|
|
|
2136 || fnptr_conv_p (ft, ot))
|
|
|
2137 fn = op;
|
|
|
2138 else
|
|
|
2139 break;
|
|
|
2140 }
|
|
|
2141 return fn;
|
|
|
2142 }
|
