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