1 |
12 |
jlechner |
/* Build expressions with type checking for C++ compiler.
|
2 |
|
|
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
3 |
|
|
1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
|
4 |
|
|
Hacked by Michael Tiemann (tiemann@cygnus.com)
|
5 |
|
|
|
6 |
|
|
This file is part of GCC.
|
7 |
|
|
|
8 |
|
|
GCC is free software; you can redistribute it and/or modify
|
9 |
|
|
it under the terms of the GNU General Public License as published by
|
10 |
|
|
the Free Software Foundation; either version 2, or (at your option)
|
11 |
|
|
any later version.
|
12 |
|
|
|
13 |
|
|
GCC is distributed in the hope that it will be useful,
|
14 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
15 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
16 |
|
|
GNU General Public License for more details.
|
17 |
|
|
|
18 |
|
|
You should have received a copy of the GNU General Public License
|
19 |
|
|
along with GCC; see the file COPYING. If not, write to
|
20 |
|
|
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
|
21 |
|
|
Boston, MA 02110-1301, USA. */
|
22 |
|
|
|
23 |
|
|
|
24 |
|
|
/* This file is part of the C++ front end.
|
25 |
|
|
It contains routines to build C++ expressions given their operands,
|
26 |
|
|
including computing the types of the result, C and C++ specific error
|
27 |
|
|
checks, and some optimization. */
|
28 |
|
|
|
29 |
|
|
#include "config.h"
|
30 |
|
|
#include "system.h"
|
31 |
|
|
#include "coretypes.h"
|
32 |
|
|
#include "tm.h"
|
33 |
|
|
#include "tree.h"
|
34 |
|
|
#include "rtl.h"
|
35 |
|
|
#include "expr.h"
|
36 |
|
|
#include "cp-tree.h"
|
37 |
|
|
#include "tm_p.h"
|
38 |
|
|
#include "flags.h"
|
39 |
|
|
#include "output.h"
|
40 |
|
|
#include "toplev.h"
|
41 |
|
|
#include "diagnostic.h"
|
42 |
|
|
#include "target.h"
|
43 |
|
|
#include "convert.h"
|
44 |
|
|
#include "c-common.h"
|
45 |
|
|
|
46 |
|
|
static tree convert_for_assignment (tree, tree, const char *, tree, int);
|
47 |
|
|
static tree cp_pointer_int_sum (enum tree_code, tree, tree);
|
48 |
|
|
static tree rationalize_conditional_expr (enum tree_code, tree);
|
49 |
|
|
static int comp_ptr_ttypes_real (tree, tree, int);
|
50 |
|
|
static bool comp_except_types (tree, tree, bool);
|
51 |
|
|
static bool comp_array_types (tree, tree, bool);
|
52 |
|
|
static tree common_base_type (tree, tree);
|
53 |
|
|
static tree pointer_diff (tree, tree, tree);
|
54 |
|
|
static tree get_delta_difference (tree, tree, bool, bool);
|
55 |
|
|
static void casts_away_constness_r (tree *, tree *);
|
56 |
|
|
static bool casts_away_constness (tree, tree);
|
57 |
|
|
static void maybe_warn_about_returning_address_of_local (tree);
|
58 |
|
|
static tree lookup_destructor (tree, tree, tree);
|
59 |
|
|
static tree convert_arguments (tree, tree, tree, int);
|
60 |
|
|
|
61 |
|
|
/* Do `exp = require_complete_type (exp);' to make sure exp
|
62 |
|
|
does not have an incomplete type. (That includes void types.)
|
63 |
|
|
Returns the error_mark_node if the VALUE does not have
|
64 |
|
|
complete type when this function returns. */
|
65 |
|
|
|
66 |
|
|
tree
|
67 |
|
|
require_complete_type (tree value)
|
68 |
|
|
{
|
69 |
|
|
tree type;
|
70 |
|
|
|
71 |
|
|
if (processing_template_decl || value == error_mark_node)
|
72 |
|
|
return value;
|
73 |
|
|
|
74 |
|
|
if (TREE_CODE (value) == OVERLOAD)
|
75 |
|
|
type = unknown_type_node;
|
76 |
|
|
else
|
77 |
|
|
type = TREE_TYPE (value);
|
78 |
|
|
|
79 |
|
|
if (type == error_mark_node)
|
80 |
|
|
return error_mark_node;
|
81 |
|
|
|
82 |
|
|
/* First, detect a valid value with a complete type. */
|
83 |
|
|
if (COMPLETE_TYPE_P (type))
|
84 |
|
|
return value;
|
85 |
|
|
|
86 |
|
|
if (complete_type_or_else (type, value))
|
87 |
|
|
return value;
|
88 |
|
|
else
|
89 |
|
|
return error_mark_node;
|
90 |
|
|
}
|
91 |
|
|
|
92 |
|
|
/* Try to complete TYPE, if it is incomplete. For example, if TYPE is
|
93 |
|
|
a template instantiation, do the instantiation. Returns TYPE,
|
94 |
|
|
whether or not it could be completed, unless something goes
|
95 |
|
|
horribly wrong, in which case the error_mark_node is returned. */
|
96 |
|
|
|
97 |
|
|
tree
|
98 |
|
|
complete_type (tree type)
|
99 |
|
|
{
|
100 |
|
|
if (type == NULL_TREE)
|
101 |
|
|
/* Rather than crash, we return something sure to cause an error
|
102 |
|
|
at some point. */
|
103 |
|
|
return error_mark_node;
|
104 |
|
|
|
105 |
|
|
if (type == error_mark_node || COMPLETE_TYPE_P (type))
|
106 |
|
|
;
|
107 |
|
|
else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
|
108 |
|
|
{
|
109 |
|
|
tree t = complete_type (TREE_TYPE (type));
|
110 |
|
|
unsigned int needs_constructing, has_nontrivial_dtor;
|
111 |
|
|
if (COMPLETE_TYPE_P (t) && !dependent_type_p (type))
|
112 |
|
|
layout_type (type);
|
113 |
|
|
needs_constructing
|
114 |
|
|
= TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
|
115 |
|
|
has_nontrivial_dtor
|
116 |
|
|
= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
|
117 |
|
|
for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
|
118 |
|
|
{
|
119 |
|
|
TYPE_NEEDS_CONSTRUCTING (t) = needs_constructing;
|
120 |
|
|
TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = has_nontrivial_dtor;
|
121 |
|
|
}
|
122 |
|
|
}
|
123 |
|
|
else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
|
124 |
|
|
instantiate_class_template (TYPE_MAIN_VARIANT (type));
|
125 |
|
|
|
126 |
|
|
return type;
|
127 |
|
|
}
|
128 |
|
|
|
129 |
|
|
/* Like complete_type, but issue an error if the TYPE cannot be completed.
|
130 |
|
|
VALUE is used for informative diagnostics.
|
131 |
|
|
Returns NULL_TREE if the type cannot be made complete. */
|
132 |
|
|
|
133 |
|
|
tree
|
134 |
|
|
complete_type_or_else (tree type, tree value)
|
135 |
|
|
{
|
136 |
|
|
type = complete_type (type);
|
137 |
|
|
if (type == error_mark_node)
|
138 |
|
|
/* We already issued an error. */
|
139 |
|
|
return NULL_TREE;
|
140 |
|
|
else if (!COMPLETE_TYPE_P (type))
|
141 |
|
|
{
|
142 |
|
|
cxx_incomplete_type_diagnostic (value, type, 0);
|
143 |
|
|
return NULL_TREE;
|
144 |
|
|
}
|
145 |
|
|
else
|
146 |
|
|
return type;
|
147 |
|
|
}
|
148 |
|
|
|
149 |
|
|
/* Return truthvalue of whether type of EXP is instantiated. */
|
150 |
|
|
|
151 |
|
|
int
|
152 |
|
|
type_unknown_p (tree exp)
|
153 |
|
|
{
|
154 |
|
|
return (TREE_CODE (exp) == TREE_LIST
|
155 |
|
|
|| TREE_TYPE (exp) == unknown_type_node);
|
156 |
|
|
}
|
157 |
|
|
|
158 |
|
|
|
159 |
|
|
/* Return the common type of two parameter lists.
|
160 |
|
|
We assume that comptypes has already been done and returned 1;
|
161 |
|
|
if that isn't so, this may crash.
|
162 |
|
|
|
163 |
|
|
As an optimization, free the space we allocate if the parameter
|
164 |
|
|
lists are already common. */
|
165 |
|
|
|
166 |
|
|
static tree
|
167 |
|
|
commonparms (tree p1, tree p2)
|
168 |
|
|
{
|
169 |
|
|
tree oldargs = p1, newargs, n;
|
170 |
|
|
int i, len;
|
171 |
|
|
int any_change = 0;
|
172 |
|
|
|
173 |
|
|
len = list_length (p1);
|
174 |
|
|
newargs = tree_last (p1);
|
175 |
|
|
|
176 |
|
|
if (newargs == void_list_node)
|
177 |
|
|
i = 1;
|
178 |
|
|
else
|
179 |
|
|
{
|
180 |
|
|
i = 0;
|
181 |
|
|
newargs = 0;
|
182 |
|
|
}
|
183 |
|
|
|
184 |
|
|
for (; i < len; i++)
|
185 |
|
|
newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
|
186 |
|
|
|
187 |
|
|
n = newargs;
|
188 |
|
|
|
189 |
|
|
for (i = 0; p1;
|
190 |
|
|
p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
|
191 |
|
|
{
|
192 |
|
|
if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
|
193 |
|
|
{
|
194 |
|
|
TREE_PURPOSE (n) = TREE_PURPOSE (p1);
|
195 |
|
|
any_change = 1;
|
196 |
|
|
}
|
197 |
|
|
else if (! TREE_PURPOSE (p1))
|
198 |
|
|
{
|
199 |
|
|
if (TREE_PURPOSE (p2))
|
200 |
|
|
{
|
201 |
|
|
TREE_PURPOSE (n) = TREE_PURPOSE (p2);
|
202 |
|
|
any_change = 1;
|
203 |
|
|
}
|
204 |
|
|
}
|
205 |
|
|
else
|
206 |
|
|
{
|
207 |
|
|
if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
|
208 |
|
|
any_change = 1;
|
209 |
|
|
TREE_PURPOSE (n) = TREE_PURPOSE (p2);
|
210 |
|
|
}
|
211 |
|
|
if (TREE_VALUE (p1) != TREE_VALUE (p2))
|
212 |
|
|
{
|
213 |
|
|
any_change = 1;
|
214 |
|
|
TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2));
|
215 |
|
|
}
|
216 |
|
|
else
|
217 |
|
|
TREE_VALUE (n) = TREE_VALUE (p1);
|
218 |
|
|
}
|
219 |
|
|
if (! any_change)
|
220 |
|
|
return oldargs;
|
221 |
|
|
|
222 |
|
|
return newargs;
|
223 |
|
|
}
|
224 |
|
|
|
225 |
|
|
/* Given a type, perhaps copied for a typedef,
|
226 |
|
|
find the "original" version of it. */
|
227 |
|
|
tree
|
228 |
|
|
original_type (tree t)
|
229 |
|
|
{
|
230 |
|
|
while (TYPE_NAME (t) != NULL_TREE)
|
231 |
|
|
{
|
232 |
|
|
tree x = TYPE_NAME (t);
|
233 |
|
|
if (TREE_CODE (x) != TYPE_DECL)
|
234 |
|
|
break;
|
235 |
|
|
x = DECL_ORIGINAL_TYPE (x);
|
236 |
|
|
if (x == NULL_TREE)
|
237 |
|
|
break;
|
238 |
|
|
t = x;
|
239 |
|
|
}
|
240 |
|
|
return t;
|
241 |
|
|
}
|
242 |
|
|
|
243 |
|
|
/* T1 and T2 are arithmetic or enumeration types. Return the type
|
244 |
|
|
that will result from the "usual arithmetic conversions" on T1 and
|
245 |
|
|
T2 as described in [expr]. */
|
246 |
|
|
|
247 |
|
|
tree
|
248 |
|
|
type_after_usual_arithmetic_conversions (tree t1, tree t2)
|
249 |
|
|
{
|
250 |
|
|
enum tree_code code1 = TREE_CODE (t1);
|
251 |
|
|
enum tree_code code2 = TREE_CODE (t2);
|
252 |
|
|
tree attributes;
|
253 |
|
|
|
254 |
|
|
/* FIXME: Attributes. */
|
255 |
|
|
gcc_assert (ARITHMETIC_TYPE_P (t1)
|
256 |
|
|
|| TREE_CODE (t1) == COMPLEX_TYPE
|
257 |
|
|
|| TREE_CODE (t1) == VECTOR_TYPE
|
258 |
|
|
|| TREE_CODE (t1) == ENUMERAL_TYPE);
|
259 |
|
|
gcc_assert (ARITHMETIC_TYPE_P (t2)
|
260 |
|
|
|| TREE_CODE (t2) == COMPLEX_TYPE
|
261 |
|
|
|| TREE_CODE (t1) == VECTOR_TYPE
|
262 |
|
|
|| TREE_CODE (t2) == ENUMERAL_TYPE);
|
263 |
|
|
|
264 |
|
|
/* In what follows, we slightly generalize the rules given in [expr] so
|
265 |
|
|
as to deal with `long long' and `complex'. First, merge the
|
266 |
|
|
attributes. */
|
267 |
|
|
attributes = (*targetm.merge_type_attributes) (t1, t2);
|
268 |
|
|
|
269 |
|
|
/* If one type is complex, form the common type of the non-complex
|
270 |
|
|
components, then make that complex. Use T1 or T2 if it is the
|
271 |
|
|
required type. */
|
272 |
|
|
if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
|
273 |
|
|
{
|
274 |
|
|
tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
|
275 |
|
|
tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
|
276 |
|
|
tree subtype
|
277 |
|
|
= type_after_usual_arithmetic_conversions (subtype1, subtype2);
|
278 |
|
|
|
279 |
|
|
if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
|
280 |
|
|
return build_type_attribute_variant (t1, attributes);
|
281 |
|
|
else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
|
282 |
|
|
return build_type_attribute_variant (t2, attributes);
|
283 |
|
|
else
|
284 |
|
|
return build_type_attribute_variant (build_complex_type (subtype),
|
285 |
|
|
attributes);
|
286 |
|
|
}
|
287 |
|
|
|
288 |
|
|
if (code1 == VECTOR_TYPE)
|
289 |
|
|
{
|
290 |
|
|
/* When we get here we should have two vectors of the same size.
|
291 |
|
|
Just prefer the unsigned one if present. */
|
292 |
|
|
if (TYPE_UNSIGNED (t1))
|
293 |
|
|
return build_type_attribute_variant (t1, attributes);
|
294 |
|
|
else
|
295 |
|
|
return build_type_attribute_variant (t2, attributes);
|
296 |
|
|
}
|
297 |
|
|
|
298 |
|
|
/* If only one is real, use it as the result. */
|
299 |
|
|
if (code1 == REAL_TYPE && code2 != REAL_TYPE)
|
300 |
|
|
return build_type_attribute_variant (t1, attributes);
|
301 |
|
|
if (code2 == REAL_TYPE && code1 != REAL_TYPE)
|
302 |
|
|
return build_type_attribute_variant (t2, attributes);
|
303 |
|
|
|
304 |
|
|
/* Perform the integral promotions. */
|
305 |
|
|
if (code1 != REAL_TYPE)
|
306 |
|
|
{
|
307 |
|
|
t1 = type_promotes_to (t1);
|
308 |
|
|
t2 = type_promotes_to (t2);
|
309 |
|
|
}
|
310 |
|
|
|
311 |
|
|
/* Both real or both integers; use the one with greater precision. */
|
312 |
|
|
if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
|
313 |
|
|
return build_type_attribute_variant (t1, attributes);
|
314 |
|
|
else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
|
315 |
|
|
return build_type_attribute_variant (t2, attributes);
|
316 |
|
|
|
317 |
|
|
/* The types are the same; no need to do anything fancy. */
|
318 |
|
|
if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
|
319 |
|
|
return build_type_attribute_variant (t1, attributes);
|
320 |
|
|
|
321 |
|
|
if (code1 != REAL_TYPE)
|
322 |
|
|
{
|
323 |
|
|
/* If one is a sizetype, use it so size_binop doesn't blow up. */
|
324 |
|
|
if (TYPE_IS_SIZETYPE (t1) > TYPE_IS_SIZETYPE (t2))
|
325 |
|
|
return build_type_attribute_variant (t1, attributes);
|
326 |
|
|
if (TYPE_IS_SIZETYPE (t2) > TYPE_IS_SIZETYPE (t1))
|
327 |
|
|
return build_type_attribute_variant (t2, attributes);
|
328 |
|
|
|
329 |
|
|
/* If one is unsigned long long, then convert the other to unsigned
|
330 |
|
|
long long. */
|
331 |
|
|
if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
|
332 |
|
|
|| same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
|
333 |
|
|
return build_type_attribute_variant (long_long_unsigned_type_node,
|
334 |
|
|
attributes);
|
335 |
|
|
/* If one is a long long, and the other is an unsigned long, and
|
336 |
|
|
long long can represent all the values of an unsigned long, then
|
337 |
|
|
convert to a long long. Otherwise, convert to an unsigned long
|
338 |
|
|
long. Otherwise, if either operand is long long, convert the
|
339 |
|
|
other to long long.
|
340 |
|
|
|
341 |
|
|
Since we're here, we know the TYPE_PRECISION is the same;
|
342 |
|
|
therefore converting to long long cannot represent all the values
|
343 |
|
|
of an unsigned long, so we choose unsigned long long in that
|
344 |
|
|
case. */
|
345 |
|
|
if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
|
346 |
|
|
|| same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
|
347 |
|
|
{
|
348 |
|
|
tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
|
349 |
|
|
? long_long_unsigned_type_node
|
350 |
|
|
: long_long_integer_type_node);
|
351 |
|
|
return build_type_attribute_variant (t, attributes);
|
352 |
|
|
}
|
353 |
|
|
|
354 |
|
|
/* Go through the same procedure, but for longs. */
|
355 |
|
|
if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
|
356 |
|
|
|| same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
|
357 |
|
|
return build_type_attribute_variant (long_unsigned_type_node,
|
358 |
|
|
attributes);
|
359 |
|
|
if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
|
360 |
|
|
|| same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
|
361 |
|
|
{
|
362 |
|
|
tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
|
363 |
|
|
? long_unsigned_type_node : long_integer_type_node);
|
364 |
|
|
return build_type_attribute_variant (t, attributes);
|
365 |
|
|
}
|
366 |
|
|
/* Otherwise prefer the unsigned one. */
|
367 |
|
|
if (TYPE_UNSIGNED (t1))
|
368 |
|
|
return build_type_attribute_variant (t1, attributes);
|
369 |
|
|
else
|
370 |
|
|
return build_type_attribute_variant (t2, attributes);
|
371 |
|
|
}
|
372 |
|
|
else
|
373 |
|
|
{
|
374 |
|
|
if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
|
375 |
|
|
|| same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
|
376 |
|
|
return build_type_attribute_variant (long_double_type_node,
|
377 |
|
|
attributes);
|
378 |
|
|
if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
|
379 |
|
|
|| same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
|
380 |
|
|
return build_type_attribute_variant (double_type_node,
|
381 |
|
|
attributes);
|
382 |
|
|
if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
|
383 |
|
|
|| same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
|
384 |
|
|
return build_type_attribute_variant (float_type_node,
|
385 |
|
|
attributes);
|
386 |
|
|
|
387 |
|
|
/* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
|
388 |
|
|
the standard C++ floating-point types. Logic earlier in this
|
389 |
|
|
function has already eliminated the possibility that
|
390 |
|
|
TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
|
391 |
|
|
compelling reason to choose one or the other. */
|
392 |
|
|
return build_type_attribute_variant (t1, attributes);
|
393 |
|
|
}
|
394 |
|
|
}
|
395 |
|
|
|
396 |
|
|
/* Subroutine of composite_pointer_type to implement the recursive
|
397 |
|
|
case. See that function for documentation fo the parameters. */
|
398 |
|
|
|
399 |
|
|
static tree
|
400 |
|
|
composite_pointer_type_r (tree t1, tree t2, const char* location)
|
401 |
|
|
{
|
402 |
|
|
tree pointee1;
|
403 |
|
|
tree pointee2;
|
404 |
|
|
tree result_type;
|
405 |
|
|
tree attributes;
|
406 |
|
|
|
407 |
|
|
/* Determine the types pointed to by T1 and T2. */
|
408 |
|
|
if (TREE_CODE (t1) == POINTER_TYPE)
|
409 |
|
|
{
|
410 |
|
|
pointee1 = TREE_TYPE (t1);
|
411 |
|
|
pointee2 = TREE_TYPE (t2);
|
412 |
|
|
}
|
413 |
|
|
else
|
414 |
|
|
{
|
415 |
|
|
pointee1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
|
416 |
|
|
pointee2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
|
417 |
|
|
}
|
418 |
|
|
|
419 |
|
|
/* [expr.rel]
|
420 |
|
|
|
421 |
|
|
Otherwise, the composite pointer type is a pointer type
|
422 |
|
|
similar (_conv.qual_) to the type of one of the operands,
|
423 |
|
|
with a cv-qualification signature (_conv.qual_) that is the
|
424 |
|
|
union of the cv-qualification signatures of the operand
|
425 |
|
|
types. */
|
426 |
|
|
if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2))
|
427 |
|
|
result_type = pointee1;
|
428 |
|
|
else if ((TREE_CODE (pointee1) == POINTER_TYPE
|
429 |
|
|
&& TREE_CODE (pointee2) == POINTER_TYPE)
|
430 |
|
|
|| (TYPE_PTR_TO_MEMBER_P (pointee1)
|
431 |
|
|
&& TYPE_PTR_TO_MEMBER_P (pointee2)))
|
432 |
|
|
result_type = composite_pointer_type_r (pointee1, pointee2, location);
|
433 |
|
|
else
|
434 |
|
|
{
|
435 |
|
|
pedwarn ("%s between distinct pointer types %qT and %qT "
|
436 |
|
|
"lacks a cast",
|
437 |
|
|
location, t1, t2);
|
438 |
|
|
result_type = void_type_node;
|
439 |
|
|
}
|
440 |
|
|
result_type = cp_build_qualified_type (result_type,
|
441 |
|
|
(cp_type_quals (pointee1)
|
442 |
|
|
| cp_type_quals (pointee2)));
|
443 |
|
|
/* If the original types were pointers to members, so is the
|
444 |
|
|
result. */
|
445 |
|
|
if (TYPE_PTR_TO_MEMBER_P (t1))
|
446 |
|
|
{
|
447 |
|
|
if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
|
448 |
|
|
TYPE_PTRMEM_CLASS_TYPE (t2)))
|
449 |
|
|
pedwarn ("%s between distinct pointer types %qT and %qT "
|
450 |
|
|
"lacks a cast",
|
451 |
|
|
location, t1, t2);
|
452 |
|
|
result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
|
453 |
|
|
result_type);
|
454 |
|
|
}
|
455 |
|
|
else
|
456 |
|
|
result_type = build_pointer_type (result_type);
|
457 |
|
|
|
458 |
|
|
/* Merge the attributes. */
|
459 |
|
|
attributes = (*targetm.merge_type_attributes) (t1, t2);
|
460 |
|
|
return build_type_attribute_variant (result_type, attributes);
|
461 |
|
|
}
|
462 |
|
|
|
463 |
|
|
/* Return the composite pointer type (see [expr.rel]) for T1 and T2.
|
464 |
|
|
ARG1 and ARG2 are the values with those types. The LOCATION is a
|
465 |
|
|
string describing the current location, in case an error occurs.
|
466 |
|
|
|
467 |
|
|
This routine also implements the computation of a common type for
|
468 |
|
|
pointers-to-members as per [expr.eq]. */
|
469 |
|
|
|
470 |
|
|
tree
|
471 |
|
|
composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
|
472 |
|
|
const char* location)
|
473 |
|
|
{
|
474 |
|
|
tree class1;
|
475 |
|
|
tree class2;
|
476 |
|
|
|
477 |
|
|
/* [expr.rel]
|
478 |
|
|
|
479 |
|
|
If one operand is a null pointer constant, the composite pointer
|
480 |
|
|
type is the type of the other operand. */
|
481 |
|
|
if (null_ptr_cst_p (arg1))
|
482 |
|
|
return t2;
|
483 |
|
|
if (null_ptr_cst_p (arg2))
|
484 |
|
|
return t1;
|
485 |
|
|
|
486 |
|
|
/* We have:
|
487 |
|
|
|
488 |
|
|
[expr.rel]
|
489 |
|
|
|
490 |
|
|
If one of the operands has type "pointer to cv1 void*", then
|
491 |
|
|
the other has type "pointer to cv2T", and the composite pointer
|
492 |
|
|
type is "pointer to cv12 void", where cv12 is the union of cv1
|
493 |
|
|
and cv2.
|
494 |
|
|
|
495 |
|
|
If either type is a pointer to void, make sure it is T1. */
|
496 |
|
|
if (TREE_CODE (t2) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t2)))
|
497 |
|
|
{
|
498 |
|
|
tree t;
|
499 |
|
|
t = t1;
|
500 |
|
|
t1 = t2;
|
501 |
|
|
t2 = t;
|
502 |
|
|
}
|
503 |
|
|
|
504 |
|
|
/* Now, if T1 is a pointer to void, merge the qualifiers. */
|
505 |
|
|
if (TREE_CODE (t1) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t1)))
|
506 |
|
|
{
|
507 |
|
|
tree attributes;
|
508 |
|
|
tree result_type;
|
509 |
|
|
|
510 |
|
|
if (pedantic && TYPE_PTRFN_P (t2))
|
511 |
|
|
pedwarn ("ISO C++ forbids %s between pointer of type %<void *%> "
|
512 |
|
|
"and pointer-to-function", location);
|
513 |
|
|
result_type
|
514 |
|
|
= cp_build_qualified_type (void_type_node,
|
515 |
|
|
(cp_type_quals (TREE_TYPE (t1))
|
516 |
|
|
| cp_type_quals (TREE_TYPE (t2))));
|
517 |
|
|
result_type = build_pointer_type (result_type);
|
518 |
|
|
/* Merge the attributes. */
|
519 |
|
|
attributes = (*targetm.merge_type_attributes) (t1, t2);
|
520 |
|
|
return build_type_attribute_variant (result_type, attributes);
|
521 |
|
|
}
|
522 |
|
|
|
523 |
|
|
if (c_dialect_objc () && TREE_CODE (t1) == POINTER_TYPE
|
524 |
|
|
&& TREE_CODE (t2) == POINTER_TYPE)
|
525 |
|
|
{
|
526 |
|
|
if (objc_compare_types (t1, t2, -3, NULL_TREE))
|
527 |
|
|
return t1;
|
528 |
|
|
}
|
529 |
|
|
|
530 |
|
|
/* [expr.eq] permits the application of a pointer conversion to
|
531 |
|
|
bring the pointers to a common type. */
|
532 |
|
|
if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
|
533 |
|
|
&& CLASS_TYPE_P (TREE_TYPE (t1))
|
534 |
|
|
&& CLASS_TYPE_P (TREE_TYPE (t2))
|
535 |
|
|
&& !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1),
|
536 |
|
|
TREE_TYPE (t2)))
|
537 |
|
|
{
|
538 |
|
|
class1 = TREE_TYPE (t1);
|
539 |
|
|
class2 = TREE_TYPE (t2);
|
540 |
|
|
|
541 |
|
|
if (DERIVED_FROM_P (class1, class2))
|
542 |
|
|
t2 = (build_pointer_type
|
543 |
|
|
(cp_build_qualified_type (class1, TYPE_QUALS (class2))));
|
544 |
|
|
else if (DERIVED_FROM_P (class2, class1))
|
545 |
|
|
t1 = (build_pointer_type
|
546 |
|
|
(cp_build_qualified_type (class2, TYPE_QUALS (class1))));
|
547 |
|
|
else
|
548 |
|
|
{
|
549 |
|
|
error ("%s between distinct pointer types %qT and %qT "
|
550 |
|
|
"lacks a cast", location, t1, t2);
|
551 |
|
|
return error_mark_node;
|
552 |
|
|
}
|
553 |
|
|
}
|
554 |
|
|
/* [expr.eq] permits the application of a pointer-to-member
|
555 |
|
|
conversion to change the class type of one of the types. */
|
556 |
|
|
else if (TYPE_PTR_TO_MEMBER_P (t1)
|
557 |
|
|
&& !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
|
558 |
|
|
TYPE_PTRMEM_CLASS_TYPE (t2)))
|
559 |
|
|
{
|
560 |
|
|
class1 = TYPE_PTRMEM_CLASS_TYPE (t1);
|
561 |
|
|
class2 = TYPE_PTRMEM_CLASS_TYPE (t2);
|
562 |
|
|
|
563 |
|
|
if (DERIVED_FROM_P (class1, class2))
|
564 |
|
|
t1 = build_ptrmem_type (class2, TYPE_PTRMEM_POINTED_TO_TYPE (t1));
|
565 |
|
|
else if (DERIVED_FROM_P (class2, class1))
|
566 |
|
|
t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2));
|
567 |
|
|
else
|
568 |
|
|
{
|
569 |
|
|
error ("%s between distinct pointer-to-member types %qT and %qT "
|
570 |
|
|
"lacks a cast", location, t1, t2);
|
571 |
|
|
return error_mark_node;
|
572 |
|
|
}
|
573 |
|
|
}
|
574 |
|
|
|
575 |
|
|
return composite_pointer_type_r (t1, t2, location);
|
576 |
|
|
}
|
577 |
|
|
|
578 |
|
|
/* Return the merged type of two types.
|
579 |
|
|
We assume that comptypes has already been done and returned 1;
|
580 |
|
|
if that isn't so, this may crash.
|
581 |
|
|
|
582 |
|
|
This just combines attributes and default arguments; any other
|
583 |
|
|
differences would cause the two types to compare unalike. */
|
584 |
|
|
|
585 |
|
|
tree
|
586 |
|
|
merge_types (tree t1, tree t2)
|
587 |
|
|
{
|
588 |
|
|
enum tree_code code1;
|
589 |
|
|
enum tree_code code2;
|
590 |
|
|
tree attributes;
|
591 |
|
|
|
592 |
|
|
/* Save time if the two types are the same. */
|
593 |
|
|
if (t1 == t2)
|
594 |
|
|
return t1;
|
595 |
|
|
if (original_type (t1) == original_type (t2))
|
596 |
|
|
return t1;
|
597 |
|
|
|
598 |
|
|
/* If one type is nonsense, use the other. */
|
599 |
|
|
if (t1 == error_mark_node)
|
600 |
|
|
return t2;
|
601 |
|
|
if (t2 == error_mark_node)
|
602 |
|
|
return t1;
|
603 |
|
|
|
604 |
|
|
/* Merge the attributes. */
|
605 |
|
|
attributes = (*targetm.merge_type_attributes) (t1, t2);
|
606 |
|
|
|
607 |
|
|
if (TYPE_PTRMEMFUNC_P (t1))
|
608 |
|
|
t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
|
609 |
|
|
if (TYPE_PTRMEMFUNC_P (t2))
|
610 |
|
|
t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
|
611 |
|
|
|
612 |
|
|
code1 = TREE_CODE (t1);
|
613 |
|
|
code2 = TREE_CODE (t2);
|
614 |
|
|
|
615 |
|
|
switch (code1)
|
616 |
|
|
{
|
617 |
|
|
case POINTER_TYPE:
|
618 |
|
|
case REFERENCE_TYPE:
|
619 |
|
|
/* For two pointers, do this recursively on the target type. */
|
620 |
|
|
{
|
621 |
|
|
tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
|
622 |
|
|
int quals = cp_type_quals (t1);
|
623 |
|
|
|
624 |
|
|
if (code1 == POINTER_TYPE)
|
625 |
|
|
t1 = build_pointer_type (target);
|
626 |
|
|
else
|
627 |
|
|
t1 = build_reference_type (target);
|
628 |
|
|
t1 = build_type_attribute_variant (t1, attributes);
|
629 |
|
|
t1 = cp_build_qualified_type (t1, quals);
|
630 |
|
|
|
631 |
|
|
if (TREE_CODE (target) == METHOD_TYPE)
|
632 |
|
|
t1 = build_ptrmemfunc_type (t1);
|
633 |
|
|
|
634 |
|
|
return t1;
|
635 |
|
|
}
|
636 |
|
|
|
637 |
|
|
case OFFSET_TYPE:
|
638 |
|
|
{
|
639 |
|
|
int quals;
|
640 |
|
|
tree pointee;
|
641 |
|
|
quals = cp_type_quals (t1);
|
642 |
|
|
pointee = merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1),
|
643 |
|
|
TYPE_PTRMEM_POINTED_TO_TYPE (t2));
|
644 |
|
|
t1 = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
|
645 |
|
|
pointee);
|
646 |
|
|
t1 = cp_build_qualified_type (t1, quals);
|
647 |
|
|
break;
|
648 |
|
|
}
|
649 |
|
|
|
650 |
|
|
case ARRAY_TYPE:
|
651 |
|
|
{
|
652 |
|
|
tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
|
653 |
|
|
/* Save space: see if the result is identical to one of the args. */
|
654 |
|
|
if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
|
655 |
|
|
return build_type_attribute_variant (t1, attributes);
|
656 |
|
|
if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
|
657 |
|
|
return build_type_attribute_variant (t2, attributes);
|
658 |
|
|
/* Merge the element types, and have a size if either arg has one. */
|
659 |
|
|
t1 = build_cplus_array_type
|
660 |
|
|
(elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
|
661 |
|
|
break;
|
662 |
|
|
}
|
663 |
|
|
|
664 |
|
|
case FUNCTION_TYPE:
|
665 |
|
|
/* Function types: prefer the one that specified arg types.
|
666 |
|
|
If both do, merge the arg types. Also merge the return types. */
|
667 |
|
|
{
|
668 |
|
|
tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
|
669 |
|
|
tree p1 = TYPE_ARG_TYPES (t1);
|
670 |
|
|
tree p2 = TYPE_ARG_TYPES (t2);
|
671 |
|
|
tree rval, raises;
|
672 |
|
|
|
673 |
|
|
/* Save space: see if the result is identical to one of the args. */
|
674 |
|
|
if (valtype == TREE_TYPE (t1) && ! p2)
|
675 |
|
|
return cp_build_type_attribute_variant (t1, attributes);
|
676 |
|
|
if (valtype == TREE_TYPE (t2) && ! p1)
|
677 |
|
|
return cp_build_type_attribute_variant (t2, attributes);
|
678 |
|
|
|
679 |
|
|
/* Simple way if one arg fails to specify argument types. */
|
680 |
|
|
if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
|
681 |
|
|
{
|
682 |
|
|
rval = build_function_type (valtype, p2);
|
683 |
|
|
if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
|
684 |
|
|
rval = build_exception_variant (rval, raises);
|
685 |
|
|
return cp_build_type_attribute_variant (rval, attributes);
|
686 |
|
|
}
|
687 |
|
|
raises = TYPE_RAISES_EXCEPTIONS (t1);
|
688 |
|
|
if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
|
689 |
|
|
{
|
690 |
|
|
rval = build_function_type (valtype, p1);
|
691 |
|
|
if (raises)
|
692 |
|
|
rval = build_exception_variant (rval, raises);
|
693 |
|
|
return cp_build_type_attribute_variant (rval, attributes);
|
694 |
|
|
}
|
695 |
|
|
|
696 |
|
|
rval = build_function_type (valtype, commonparms (p1, p2));
|
697 |
|
|
t1 = build_exception_variant (rval, raises);
|
698 |
|
|
break;
|
699 |
|
|
}
|
700 |
|
|
|
701 |
|
|
case METHOD_TYPE:
|
702 |
|
|
{
|
703 |
|
|
/* Get this value the long way, since TYPE_METHOD_BASETYPE
|
704 |
|
|
is just the main variant of this. */
|
705 |
|
|
tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
|
706 |
|
|
tree raises = TYPE_RAISES_EXCEPTIONS (t1);
|
707 |
|
|
tree t3;
|
708 |
|
|
|
709 |
|
|
/* If this was a member function type, get back to the
|
710 |
|
|
original type of type member function (i.e., without
|
711 |
|
|
the class instance variable up front. */
|
712 |
|
|
t1 = build_function_type (TREE_TYPE (t1),
|
713 |
|
|
TREE_CHAIN (TYPE_ARG_TYPES (t1)));
|
714 |
|
|
t2 = build_function_type (TREE_TYPE (t2),
|
715 |
|
|
TREE_CHAIN (TYPE_ARG_TYPES (t2)));
|
716 |
|
|
t3 = merge_types (t1, t2);
|
717 |
|
|
t3 = build_method_type_directly (basetype, TREE_TYPE (t3),
|
718 |
|
|
TYPE_ARG_TYPES (t3));
|
719 |
|
|
t1 = build_exception_variant (t3, raises);
|
720 |
|
|
break;
|
721 |
|
|
}
|
722 |
|
|
|
723 |
|
|
case TYPENAME_TYPE:
|
724 |
|
|
/* There is no need to merge attributes into a TYPENAME_TYPE.
|
725 |
|
|
When the type is instantiated it will have whatever
|
726 |
|
|
attributes result from the instantiation. */
|
727 |
|
|
return t1;
|
728 |
|
|
|
729 |
|
|
default:;
|
730 |
|
|
}
|
731 |
|
|
return cp_build_type_attribute_variant (t1, attributes);
|
732 |
|
|
}
|
733 |
|
|
|
734 |
|
|
/* Return the common type of two types.
|
735 |
|
|
We assume that comptypes has already been done and returned 1;
|
736 |
|
|
if that isn't so, this may crash.
|
737 |
|
|
|
738 |
|
|
This is the type for the result of most arithmetic operations
|
739 |
|
|
if the operands have the given two types. */
|
740 |
|
|
|
741 |
|
|
tree
|
742 |
|
|
common_type (tree t1, tree t2)
|
743 |
|
|
{
|
744 |
|
|
enum tree_code code1;
|
745 |
|
|
enum tree_code code2;
|
746 |
|
|
|
747 |
|
|
/* If one type is nonsense, bail. */
|
748 |
|
|
if (t1 == error_mark_node || t2 == error_mark_node)
|
749 |
|
|
return error_mark_node;
|
750 |
|
|
|
751 |
|
|
code1 = TREE_CODE (t1);
|
752 |
|
|
code2 = TREE_CODE (t2);
|
753 |
|
|
|
754 |
|
|
if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
|
755 |
|
|
|| code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
|
756 |
|
|
&& (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
|
757 |
|
|
|| code2 == COMPLEX_TYPE || code2 == VECTOR_TYPE))
|
758 |
|
|
return type_after_usual_arithmetic_conversions (t1, t2);
|
759 |
|
|
|
760 |
|
|
else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
|
761 |
|
|
|| (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
|
762 |
|
|
|| (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)))
|
763 |
|
|
return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
|
764 |
|
|
"conversion");
|
765 |
|
|
else
|
766 |
|
|
gcc_unreachable ();
|
767 |
|
|
}
|
768 |
|
|
|
769 |
|
|
/* Compare two exception specifier types for exactness or subsetness, if
|
770 |
|
|
allowed. Returns false for mismatch, true for match (same, or
|
771 |
|
|
derived and !exact).
|
772 |
|
|
|
773 |
|
|
[except.spec] "If a class X ... objects of class X or any class publicly
|
774 |
|
|
and unambiguously derived from X. Similarly, if a pointer type Y * ...
|
775 |
|
|
exceptions of type Y * or that are pointers to any type publicly and
|
776 |
|
|
unambiguously derived from Y. Otherwise a function only allows exceptions
|
777 |
|
|
that have the same type ..."
|
778 |
|
|
This does not mention cv qualifiers and is different to what throw
|
779 |
|
|
[except.throw] and catch [except.catch] will do. They will ignore the
|
780 |
|
|
top level cv qualifiers, and allow qualifiers in the pointer to class
|
781 |
|
|
example.
|
782 |
|
|
|
783 |
|
|
We implement the letter of the standard. */
|
784 |
|
|
|
785 |
|
|
static bool
|
786 |
|
|
comp_except_types (tree a, tree b, bool exact)
|
787 |
|
|
{
|
788 |
|
|
if (same_type_p (a, b))
|
789 |
|
|
return true;
|
790 |
|
|
else if (!exact)
|
791 |
|
|
{
|
792 |
|
|
if (cp_type_quals (a) || cp_type_quals (b))
|
793 |
|
|
return false;
|
794 |
|
|
|
795 |
|
|
if (TREE_CODE (a) == POINTER_TYPE
|
796 |
|
|
&& TREE_CODE (b) == POINTER_TYPE)
|
797 |
|
|
{
|
798 |
|
|
a = TREE_TYPE (a);
|
799 |
|
|
b = TREE_TYPE (b);
|
800 |
|
|
if (cp_type_quals (a) || cp_type_quals (b))
|
801 |
|
|
return false;
|
802 |
|
|
}
|
803 |
|
|
|
804 |
|
|
if (TREE_CODE (a) != RECORD_TYPE
|
805 |
|
|
|| TREE_CODE (b) != RECORD_TYPE)
|
806 |
|
|
return false;
|
807 |
|
|
|
808 |
|
|
if (PUBLICLY_UNIQUELY_DERIVED_P (a, b))
|
809 |
|
|
return true;
|
810 |
|
|
}
|
811 |
|
|
return false;
|
812 |
|
|
}
|
813 |
|
|
|
814 |
|
|
/* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
|
815 |
|
|
If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
|
816 |
|
|
otherwise it must be exact. Exception lists are unordered, but
|
817 |
|
|
we've already filtered out duplicates. Most lists will be in order,
|
818 |
|
|
we should try to make use of that. */
|
819 |
|
|
|
820 |
|
|
bool
|
821 |
|
|
comp_except_specs (tree t1, tree t2, bool exact)
|
822 |
|
|
{
|
823 |
|
|
tree probe;
|
824 |
|
|
tree base;
|
825 |
|
|
int length = 0;
|
826 |
|
|
|
827 |
|
|
if (t1 == t2)
|
828 |
|
|
return true;
|
829 |
|
|
|
830 |
|
|
if (t1 == NULL_TREE) /* T1 is ... */
|
831 |
|
|
return t2 == NULL_TREE || !exact;
|
832 |
|
|
if (!TREE_VALUE (t1)) /* t1 is EMPTY */
|
833 |
|
|
return t2 != NULL_TREE && !TREE_VALUE (t2);
|
834 |
|
|
if (t2 == NULL_TREE) /* T2 is ... */
|
835 |
|
|
return false;
|
836 |
|
|
if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
|
837 |
|
|
return !exact;
|
838 |
|
|
|
839 |
|
|
/* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
|
840 |
|
|
Count how many we find, to determine exactness. For exact matching and
|
841 |
|
|
ordered T1, T2, this is an O(n) operation, otherwise its worst case is
|
842 |
|
|
O(nm). */
|
843 |
|
|
for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
|
844 |
|
|
{
|
845 |
|
|
for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
|
846 |
|
|
{
|
847 |
|
|
tree a = TREE_VALUE (probe);
|
848 |
|
|
tree b = TREE_VALUE (t2);
|
849 |
|
|
|
850 |
|
|
if (comp_except_types (a, b, exact))
|
851 |
|
|
{
|
852 |
|
|
if (probe == base && exact)
|
853 |
|
|
base = TREE_CHAIN (probe);
|
854 |
|
|
length++;
|
855 |
|
|
break;
|
856 |
|
|
}
|
857 |
|
|
}
|
858 |
|
|
if (probe == NULL_TREE)
|
859 |
|
|
return false;
|
860 |
|
|
}
|
861 |
|
|
return !exact || base == NULL_TREE || length == list_length (t1);
|
862 |
|
|
}
|
863 |
|
|
|
864 |
|
|
/* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
|
865 |
|
|
[] can match [size]. */
|
866 |
|
|
|
867 |
|
|
static bool
|
868 |
|
|
comp_array_types (tree t1, tree t2, bool allow_redeclaration)
|
869 |
|
|
{
|
870 |
|
|
tree d1;
|
871 |
|
|
tree d2;
|
872 |
|
|
tree max1, max2;
|
873 |
|
|
|
874 |
|
|
if (t1 == t2)
|
875 |
|
|
return true;
|
876 |
|
|
|
877 |
|
|
/* The type of the array elements must be the same. */
|
878 |
|
|
if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
879 |
|
|
return false;
|
880 |
|
|
|
881 |
|
|
d1 = TYPE_DOMAIN (t1);
|
882 |
|
|
d2 = TYPE_DOMAIN (t2);
|
883 |
|
|
|
884 |
|
|
if (d1 == d2)
|
885 |
|
|
return true;
|
886 |
|
|
|
887 |
|
|
/* If one of the arrays is dimensionless, and the other has a
|
888 |
|
|
dimension, they are of different types. However, it is valid to
|
889 |
|
|
write:
|
890 |
|
|
|
891 |
|
|
extern int a[];
|
892 |
|
|
int a[3];
|
893 |
|
|
|
894 |
|
|
by [basic.link]:
|
895 |
|
|
|
896 |
|
|
declarations for an array object can specify
|
897 |
|
|
array types that differ by the presence or absence of a major
|
898 |
|
|
array bound (_dcl.array_). */
|
899 |
|
|
if (!d1 || !d2)
|
900 |
|
|
return allow_redeclaration;
|
901 |
|
|
|
902 |
|
|
/* Check that the dimensions are the same. */
|
903 |
|
|
|
904 |
|
|
if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)))
|
905 |
|
|
return false;
|
906 |
|
|
max1 = TYPE_MAX_VALUE (d1);
|
907 |
|
|
max2 = TYPE_MAX_VALUE (d2);
|
908 |
|
|
if (processing_template_decl && !abi_version_at_least (2)
|
909 |
|
|
&& !value_dependent_expression_p (max1)
|
910 |
|
|
&& !value_dependent_expression_p (max2))
|
911 |
|
|
{
|
912 |
|
|
/* With abi-1 we do not fold non-dependent array bounds, (and
|
913 |
|
|
consequently mangle them incorrectly). We must therefore
|
914 |
|
|
fold them here, to verify the domains have the same
|
915 |
|
|
value. */
|
916 |
|
|
max1 = fold (max1);
|
917 |
|
|
max2 = fold (max2);
|
918 |
|
|
}
|
919 |
|
|
|
920 |
|
|
if (!cp_tree_equal (max1, max2))
|
921 |
|
|
return false;
|
922 |
|
|
|
923 |
|
|
return true;
|
924 |
|
|
}
|
925 |
|
|
|
926 |
|
|
/* Return true if T1 and T2 are related as allowed by STRICT. STRICT
|
927 |
|
|
is a bitwise-or of the COMPARE_* flags. */
|
928 |
|
|
|
929 |
|
|
bool
|
930 |
|
|
comptypes (tree t1, tree t2, int strict)
|
931 |
|
|
{
|
932 |
|
|
if (t1 == t2)
|
933 |
|
|
return true;
|
934 |
|
|
|
935 |
|
|
/* Suppress errors caused by previously reported errors. */
|
936 |
|
|
if (t1 == error_mark_node || t2 == error_mark_node)
|
937 |
|
|
return false;
|
938 |
|
|
|
939 |
|
|
gcc_assert (TYPE_P (t1) && TYPE_P (t2));
|
940 |
|
|
|
941 |
|
|
/* TYPENAME_TYPEs should be resolved if the qualifying scope is the
|
942 |
|
|
current instantiation. */
|
943 |
|
|
if (TREE_CODE (t1) == TYPENAME_TYPE)
|
944 |
|
|
{
|
945 |
|
|
tree resolved = resolve_typename_type (t1, /*only_current_p=*/true);
|
946 |
|
|
|
947 |
|
|
if (resolved != error_mark_node)
|
948 |
|
|
t1 = resolved;
|
949 |
|
|
}
|
950 |
|
|
|
951 |
|
|
if (TREE_CODE (t2) == TYPENAME_TYPE)
|
952 |
|
|
{
|
953 |
|
|
tree resolved = resolve_typename_type (t2, /*only_current_p=*/true);
|
954 |
|
|
|
955 |
|
|
if (resolved != error_mark_node)
|
956 |
|
|
t2 = resolved;
|
957 |
|
|
}
|
958 |
|
|
|
959 |
|
|
/* If either type is the internal version of sizetype, use the
|
960 |
|
|
language version. */
|
961 |
|
|
if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
|
962 |
|
|
&& TYPE_ORIG_SIZE_TYPE (t1))
|
963 |
|
|
t1 = TYPE_ORIG_SIZE_TYPE (t1);
|
964 |
|
|
|
965 |
|
|
if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
|
966 |
|
|
&& TYPE_ORIG_SIZE_TYPE (t2))
|
967 |
|
|
t2 = TYPE_ORIG_SIZE_TYPE (t2);
|
968 |
|
|
|
969 |
|
|
if (TYPE_PTRMEMFUNC_P (t1))
|
970 |
|
|
t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
|
971 |
|
|
if (TYPE_PTRMEMFUNC_P (t2))
|
972 |
|
|
t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
|
973 |
|
|
|
974 |
|
|
/* Different classes of types can't be compatible. */
|
975 |
|
|
if (TREE_CODE (t1) != TREE_CODE (t2))
|
976 |
|
|
return false;
|
977 |
|
|
|
978 |
|
|
/* Qualifiers must match. For array types, we will check when we
|
979 |
|
|
recur on the array element types. */
|
980 |
|
|
if (TREE_CODE (t1) != ARRAY_TYPE
|
981 |
|
|
&& TYPE_QUALS (t1) != TYPE_QUALS (t2))
|
982 |
|
|
return false;
|
983 |
|
|
if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
|
984 |
|
|
return false;
|
985 |
|
|
|
986 |
|
|
/* Allow for two different type nodes which have essentially the same
|
987 |
|
|
definition. Note that we already checked for equality of the type
|
988 |
|
|
qualifiers (just above). */
|
989 |
|
|
|
990 |
|
|
if (TREE_CODE (t1) != ARRAY_TYPE
|
991 |
|
|
&& TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
|
992 |
|
|
return true;
|
993 |
|
|
|
994 |
|
|
/* Compare the types. Break out if they could be the same. */
|
995 |
|
|
switch (TREE_CODE (t1))
|
996 |
|
|
{
|
997 |
|
|
case TEMPLATE_TEMPLATE_PARM:
|
998 |
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
999 |
|
|
if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
|
1000 |
|
|
|| TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
|
1001 |
|
|
return false;
|
1002 |
|
|
if (!comp_template_parms
|
1003 |
|
|
(DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
|
1004 |
|
|
DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
|
1005 |
|
|
return false;
|
1006 |
|
|
if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
|
1007 |
|
|
break;
|
1008 |
|
|
/* Don't check inheritance. */
|
1009 |
|
|
strict = COMPARE_STRICT;
|
1010 |
|
|
/* Fall through. */
|
1011 |
|
|
|
1012 |
|
|
case RECORD_TYPE:
|
1013 |
|
|
case UNION_TYPE:
|
1014 |
|
|
if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
|
1015 |
|
|
&& (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
|
1016 |
|
|
|| TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
|
1017 |
|
|
&& comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
|
1018 |
|
|
break;
|
1019 |
|
|
|
1020 |
|
|
if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
|
1021 |
|
|
break;
|
1022 |
|
|
else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
|
1023 |
|
|
break;
|
1024 |
|
|
|
1025 |
|
|
return false;
|
1026 |
|
|
|
1027 |
|
|
case OFFSET_TYPE:
|
1028 |
|
|
if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
|
1029 |
|
|
strict & ~COMPARE_REDECLARATION))
|
1030 |
|
|
return false;
|
1031 |
|
|
if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
1032 |
|
|
return false;
|
1033 |
|
|
break;
|
1034 |
|
|
|
1035 |
|
|
case POINTER_TYPE:
|
1036 |
|
|
case REFERENCE_TYPE:
|
1037 |
|
|
if (TYPE_MODE (t1) != TYPE_MODE (t2)
|
1038 |
|
|
|| TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
|
1039 |
|
|
|| !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
1040 |
|
|
return false;
|
1041 |
|
|
break;
|
1042 |
|
|
|
1043 |
|
|
case METHOD_TYPE:
|
1044 |
|
|
case FUNCTION_TYPE:
|
1045 |
|
|
if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
1046 |
|
|
return false;
|
1047 |
|
|
if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)))
|
1048 |
|
|
return false;
|
1049 |
|
|
break;
|
1050 |
|
|
|
1051 |
|
|
case ARRAY_TYPE:
|
1052 |
|
|
/* Target types must match incl. qualifiers. */
|
1053 |
|
|
if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)))
|
1054 |
|
|
return false;
|
1055 |
|
|
break;
|
1056 |
|
|
|
1057 |
|
|
case TEMPLATE_TYPE_PARM:
|
1058 |
|
|
if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
|
1059 |
|
|
|| TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
|
1060 |
|
|
return false;
|
1061 |
|
|
break;
|
1062 |
|
|
|
1063 |
|
|
case TYPENAME_TYPE:
|
1064 |
|
|
if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
|
1065 |
|
|
TYPENAME_TYPE_FULLNAME (t2)))
|
1066 |
|
|
return false;
|
1067 |
|
|
if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
|
1068 |
|
|
return false;
|
1069 |
|
|
break;
|
1070 |
|
|
|
1071 |
|
|
case UNBOUND_CLASS_TEMPLATE:
|
1072 |
|
|
if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
|
1073 |
|
|
return false;
|
1074 |
|
|
if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
|
1075 |
|
|
return false;
|
1076 |
|
|
break;
|
1077 |
|
|
|
1078 |
|
|
case COMPLEX_TYPE:
|
1079 |
|
|
if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
1080 |
|
|
return false;
|
1081 |
|
|
break;
|
1082 |
|
|
|
1083 |
|
|
case VECTOR_TYPE:
|
1084 |
|
|
if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2)
|
1085 |
|
|
|| !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
1086 |
|
|
return false;
|
1087 |
|
|
break;
|
1088 |
|
|
|
1089 |
|
|
default:
|
1090 |
|
|
return false;
|
1091 |
|
|
}
|
1092 |
|
|
|
1093 |
|
|
/* If we get here, we know that from a target independent POV the
|
1094 |
|
|
types are the same. Make sure the target attributes are also
|
1095 |
|
|
the same. */
|
1096 |
|
|
return targetm.comp_type_attributes (t1, t2);
|
1097 |
|
|
}
|
1098 |
|
|
|
1099 |
|
|
/* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
|
1100 |
|
|
|
1101 |
|
|
bool
|
1102 |
|
|
at_least_as_qualified_p (tree type1, tree type2)
|
1103 |
|
|
{
|
1104 |
|
|
int q1 = cp_type_quals (type1);
|
1105 |
|
|
int q2 = cp_type_quals (type2);
|
1106 |
|
|
|
1107 |
|
|
/* All qualifiers for TYPE2 must also appear in TYPE1. */
|
1108 |
|
|
return (q1 & q2) == q2;
|
1109 |
|
|
}
|
1110 |
|
|
|
1111 |
|
|
/* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
|
1112 |
|
|
more cv-qualified that TYPE1, and 0 otherwise. */
|
1113 |
|
|
|
1114 |
|
|
int
|
1115 |
|
|
comp_cv_qualification (tree type1, tree type2)
|
1116 |
|
|
{
|
1117 |
|
|
int q1 = cp_type_quals (type1);
|
1118 |
|
|
int q2 = cp_type_quals (type2);
|
1119 |
|
|
|
1120 |
|
|
if (q1 == q2)
|
1121 |
|
|
return 0;
|
1122 |
|
|
|
1123 |
|
|
if ((q1 & q2) == q2)
|
1124 |
|
|
return 1;
|
1125 |
|
|
else if ((q1 & q2) == q1)
|
1126 |
|
|
return -1;
|
1127 |
|
|
|
1128 |
|
|
return 0;
|
1129 |
|
|
}
|
1130 |
|
|
|
1131 |
|
|
/* Returns 1 if the cv-qualification signature of TYPE1 is a proper
|
1132 |
|
|
subset of the cv-qualification signature of TYPE2, and the types
|
1133 |
|
|
are similar. Returns -1 if the other way 'round, and 0 otherwise. */
|
1134 |
|
|
|
1135 |
|
|
int
|
1136 |
|
|
comp_cv_qual_signature (tree type1, tree type2)
|
1137 |
|
|
{
|
1138 |
|
|
if (comp_ptr_ttypes_real (type2, type1, -1))
|
1139 |
|
|
return 1;
|
1140 |
|
|
else if (comp_ptr_ttypes_real (type1, type2, -1))
|
1141 |
|
|
return -1;
|
1142 |
|
|
else
|
1143 |
|
|
return 0;
|
1144 |
|
|
}
|
1145 |
|
|
|
1146 |
|
|
/* If two types share a common base type, return that basetype.
|
1147 |
|
|
If there is not a unique most-derived base type, this function
|
1148 |
|
|
returns ERROR_MARK_NODE. */
|
1149 |
|
|
|
1150 |
|
|
static tree
|
1151 |
|
|
common_base_type (tree tt1, tree tt2)
|
1152 |
|
|
{
|
1153 |
|
|
tree best = NULL_TREE;
|
1154 |
|
|
int i;
|
1155 |
|
|
|
1156 |
|
|
/* If one is a baseclass of another, that's good enough. */
|
1157 |
|
|
if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
|
1158 |
|
|
return tt1;
|
1159 |
|
|
if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
|
1160 |
|
|
return tt2;
|
1161 |
|
|
|
1162 |
|
|
/* Otherwise, try to find a unique baseclass of TT1
|
1163 |
|
|
that is shared by TT2, and follow that down. */
|
1164 |
|
|
for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (tt1))-1; i >= 0; i--)
|
1165 |
|
|
{
|
1166 |
|
|
tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt1), i));
|
1167 |
|
|
tree trial = common_base_type (basetype, tt2);
|
1168 |
|
|
|
1169 |
|
|
if (trial)
|
1170 |
|
|
{
|
1171 |
|
|
if (trial == error_mark_node)
|
1172 |
|
|
return trial;
|
1173 |
|
|
if (best == NULL_TREE)
|
1174 |
|
|
best = trial;
|
1175 |
|
|
else if (best != trial)
|
1176 |
|
|
return error_mark_node;
|
1177 |
|
|
}
|
1178 |
|
|
}
|
1179 |
|
|
|
1180 |
|
|
/* Same for TT2. */
|
1181 |
|
|
for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (tt2))-1; i >= 0; i--)
|
1182 |
|
|
{
|
1183 |
|
|
tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt2), i));
|
1184 |
|
|
tree trial = common_base_type (tt1, basetype);
|
1185 |
|
|
|
1186 |
|
|
if (trial)
|
1187 |
|
|
{
|
1188 |
|
|
if (trial == error_mark_node)
|
1189 |
|
|
return trial;
|
1190 |
|
|
if (best == NULL_TREE)
|
1191 |
|
|
best = trial;
|
1192 |
|
|
else if (best != trial)
|
1193 |
|
|
return error_mark_node;
|
1194 |
|
|
}
|
1195 |
|
|
}
|
1196 |
|
|
return best;
|
1197 |
|
|
}
|
1198 |
|
|
|
1199 |
|
|
/* Subroutines of `comptypes'. */
|
1200 |
|
|
|
1201 |
|
|
/* Return true if two parameter type lists PARMS1 and PARMS2 are
|
1202 |
|
|
equivalent in the sense that functions with those parameter types
|
1203 |
|
|
can have equivalent types. The two lists must be equivalent,
|
1204 |
|
|
element by element. */
|
1205 |
|
|
|
1206 |
|
|
bool
|
1207 |
|
|
compparms (tree parms1, tree parms2)
|
1208 |
|
|
{
|
1209 |
|
|
tree t1, t2;
|
1210 |
|
|
|
1211 |
|
|
/* An unspecified parmlist matches any specified parmlist
|
1212 |
|
|
whose argument types don't need default promotions. */
|
1213 |
|
|
|
1214 |
|
|
for (t1 = parms1, t2 = parms2;
|
1215 |
|
|
t1 || t2;
|
1216 |
|
|
t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
|
1217 |
|
|
{
|
1218 |
|
|
/* If one parmlist is shorter than the other,
|
1219 |
|
|
they fail to match. */
|
1220 |
|
|
if (!t1 || !t2)
|
1221 |
|
|
return false;
|
1222 |
|
|
if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
|
1223 |
|
|
return false;
|
1224 |
|
|
}
|
1225 |
|
|
return true;
|
1226 |
|
|
}
|
1227 |
|
|
|
1228 |
|
|
|
1229 |
|
|
/* Process a sizeof or alignof expression where the operand is a
|
1230 |
|
|
type. */
|
1231 |
|
|
|
1232 |
|
|
tree
|
1233 |
|
|
cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
|
1234 |
|
|
{
|
1235 |
|
|
enum tree_code type_code;
|
1236 |
|
|
tree value;
|
1237 |
|
|
const char *op_name;
|
1238 |
|
|
|
1239 |
|
|
gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
|
1240 |
|
|
if (type == error_mark_node)
|
1241 |
|
|
return error_mark_node;
|
1242 |
|
|
|
1243 |
|
|
if (dependent_type_p (type))
|
1244 |
|
|
{
|
1245 |
|
|
value = build_min (op, size_type_node, type);
|
1246 |
|
|
TREE_READONLY (value) = 1;
|
1247 |
|
|
return value;
|
1248 |
|
|
}
|
1249 |
|
|
|
1250 |
|
|
op_name = operator_name_info[(int) op].name;
|
1251 |
|
|
|
1252 |
|
|
type = non_reference (type);
|
1253 |
|
|
type_code = TREE_CODE (type);
|
1254 |
|
|
|
1255 |
|
|
if (type_code == METHOD_TYPE)
|
1256 |
|
|
{
|
1257 |
|
|
if (complain && (pedantic || warn_pointer_arith))
|
1258 |
|
|
pedwarn ("invalid application of %qs to a member function", op_name);
|
1259 |
|
|
value = size_one_node;
|
1260 |
|
|
}
|
1261 |
|
|
else
|
1262 |
|
|
value = c_sizeof_or_alignof_type (complete_type (type),
|
1263 |
|
|
op == SIZEOF_EXPR,
|
1264 |
|
|
complain);
|
1265 |
|
|
|
1266 |
|
|
return value;
|
1267 |
|
|
}
|
1268 |
|
|
|
1269 |
|
|
/* Process a sizeof or alignof expression where the operand is an
|
1270 |
|
|
expression. */
|
1271 |
|
|
|
1272 |
|
|
tree
|
1273 |
|
|
cxx_sizeof_or_alignof_expr (tree e, enum tree_code op)
|
1274 |
|
|
{
|
1275 |
|
|
const char *op_name = operator_name_info[(int) op].name;
|
1276 |
|
|
|
1277 |
|
|
if (e == error_mark_node)
|
1278 |
|
|
return error_mark_node;
|
1279 |
|
|
|
1280 |
|
|
if (processing_template_decl)
|
1281 |
|
|
{
|
1282 |
|
|
e = build_min (op, size_type_node, e);
|
1283 |
|
|
TREE_SIDE_EFFECTS (e) = 0;
|
1284 |
|
|
TREE_READONLY (e) = 1;
|
1285 |
|
|
|
1286 |
|
|
return e;
|
1287 |
|
|
}
|
1288 |
|
|
|
1289 |
|
|
if (TREE_CODE (e) == COMPONENT_REF
|
1290 |
|
|
&& TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
|
1291 |
|
|
&& DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
|
1292 |
|
|
{
|
1293 |
|
|
error ("invalid application of %qs to a bit-field", op_name);
|
1294 |
|
|
e = char_type_node;
|
1295 |
|
|
}
|
1296 |
|
|
else if (is_overloaded_fn (e))
|
1297 |
|
|
{
|
1298 |
|
|
pedwarn ("ISO C++ forbids applying %qs to an expression of "
|
1299 |
|
|
"function type", op_name);
|
1300 |
|
|
e = char_type_node;
|
1301 |
|
|
}
|
1302 |
|
|
else if (type_unknown_p (e))
|
1303 |
|
|
{
|
1304 |
|
|
cxx_incomplete_type_error (e, TREE_TYPE (e));
|
1305 |
|
|
e = char_type_node;
|
1306 |
|
|
}
|
1307 |
|
|
else
|
1308 |
|
|
e = TREE_TYPE (e);
|
1309 |
|
|
|
1310 |
|
|
return cxx_sizeof_or_alignof_type (e, op, true);
|
1311 |
|
|
}
|
1312 |
|
|
|
1313 |
|
|
|
1314 |
|
|
/* EXPR is being used in a context that is not a function call.
|
1315 |
|
|
Enforce:
|
1316 |
|
|
|
1317 |
|
|
[expr.ref]
|
1318 |
|
|
|
1319 |
|
|
The expression can be used only as the left-hand operand of a
|
1320 |
|
|
member function call.
|
1321 |
|
|
|
1322 |
|
|
[expr.mptr.operator]
|
1323 |
|
|
|
1324 |
|
|
If the result of .* or ->* is a function, then that result can be
|
1325 |
|
|
used only as the operand for the function call operator ().
|
1326 |
|
|
|
1327 |
|
|
by issuing an error message if appropriate. Returns true iff EXPR
|
1328 |
|
|
violates these rules. */
|
1329 |
|
|
|
1330 |
|
|
bool
|
1331 |
|
|
invalid_nonstatic_memfn_p (tree expr)
|
1332 |
|
|
{
|
1333 |
|
|
if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
|
1334 |
|
|
{
|
1335 |
|
|
error ("invalid use of non-static member function");
|
1336 |
|
|
return true;
|
1337 |
|
|
}
|
1338 |
|
|
return false;
|
1339 |
|
|
}
|
1340 |
|
|
|
1341 |
|
|
/* Perform the conversions in [expr] that apply when an lvalue appears
|
1342 |
|
|
in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
|
1343 |
|
|
function-to-pointer conversions.
|
1344 |
|
|
|
1345 |
|
|
In addition manifest constants are replaced by their values. */
|
1346 |
|
|
|
1347 |
|
|
tree
|
1348 |
|
|
decay_conversion (tree exp)
|
1349 |
|
|
{
|
1350 |
|
|
tree type;
|
1351 |
|
|
enum tree_code code;
|
1352 |
|
|
|
1353 |
|
|
type = TREE_TYPE (exp);
|
1354 |
|
|
code = TREE_CODE (type);
|
1355 |
|
|
|
1356 |
|
|
if (type == error_mark_node)
|
1357 |
|
|
return error_mark_node;
|
1358 |
|
|
|
1359 |
|
|
if (type_unknown_p (exp))
|
1360 |
|
|
{
|
1361 |
|
|
cxx_incomplete_type_error (exp, TREE_TYPE (exp));
|
1362 |
|
|
return error_mark_node;
|
1363 |
|
|
}
|
1364 |
|
|
|
1365 |
|
|
exp = decl_constant_value (exp);
|
1366 |
|
|
|
1367 |
|
|
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
|
1368 |
|
|
Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
|
1369 |
|
|
|
1370 |
|
|
if (code == VOID_TYPE)
|
1371 |
|
|
{
|
1372 |
|
|
error ("void value not ignored as it ought to be");
|
1373 |
|
|
return error_mark_node;
|
1374 |
|
|
}
|
1375 |
|
|
if (invalid_nonstatic_memfn_p (exp))
|
1376 |
|
|
return error_mark_node;
|
1377 |
|
|
if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
|
1378 |
|
|
return build_unary_op (ADDR_EXPR, exp, 0);
|
1379 |
|
|
if (code == ARRAY_TYPE)
|
1380 |
|
|
{
|
1381 |
|
|
tree adr;
|
1382 |
|
|
tree ptrtype;
|
1383 |
|
|
|
1384 |
|
|
if (TREE_CODE (exp) == INDIRECT_REF)
|
1385 |
|
|
return build_nop (build_pointer_type (TREE_TYPE (type)),
|
1386 |
|
|
TREE_OPERAND (exp, 0));
|
1387 |
|
|
|
1388 |
|
|
if (TREE_CODE (exp) == COMPOUND_EXPR)
|
1389 |
|
|
{
|
1390 |
|
|
tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
|
1391 |
|
|
return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
|
1392 |
|
|
TREE_OPERAND (exp, 0), op1);
|
1393 |
|
|
}
|
1394 |
|
|
|
1395 |
|
|
if (!lvalue_p (exp)
|
1396 |
|
|
&& ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
|
1397 |
|
|
{
|
1398 |
|
|
error ("invalid use of non-lvalue array");
|
1399 |
|
|
return error_mark_node;
|
1400 |
|
|
}
|
1401 |
|
|
|
1402 |
|
|
ptrtype = build_pointer_type (TREE_TYPE (type));
|
1403 |
|
|
|
1404 |
|
|
if (TREE_CODE (exp) == VAR_DECL)
|
1405 |
|
|
{
|
1406 |
|
|
if (!cxx_mark_addressable (exp))
|
1407 |
|
|
return error_mark_node;
|
1408 |
|
|
adr = build_nop (ptrtype, build_address (exp));
|
1409 |
|
|
return adr;
|
1410 |
|
|
}
|
1411 |
|
|
/* This way is better for a COMPONENT_REF since it can
|
1412 |
|
|
simplify the offset for a component. */
|
1413 |
|
|
adr = build_unary_op (ADDR_EXPR, exp, 1);
|
1414 |
|
|
return cp_convert (ptrtype, adr);
|
1415 |
|
|
}
|
1416 |
|
|
|
1417 |
|
|
/* [basic.lval]: Class rvalues can have cv-qualified types; non-class
|
1418 |
|
|
rvalues always have cv-unqualified types. */
|
1419 |
|
|
if (! CLASS_TYPE_P (type))
|
1420 |
|
|
exp = cp_convert (TYPE_MAIN_VARIANT (type), exp);
|
1421 |
|
|
|
1422 |
|
|
return exp;
|
1423 |
|
|
}
|
1424 |
|
|
|
1425 |
|
|
tree
|
1426 |
|
|
default_conversion (tree exp)
|
1427 |
|
|
{
|
1428 |
|
|
exp = decay_conversion (exp);
|
1429 |
|
|
|
1430 |
|
|
if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
|
1431 |
|
|
exp = perform_integral_promotions (exp);
|
1432 |
|
|
|
1433 |
|
|
return exp;
|
1434 |
|
|
}
|
1435 |
|
|
|
1436 |
|
|
/* EXPR is an expression with an integral or enumeration type.
|
1437 |
|
|
Perform the integral promotions in [conv.prom], and return the
|
1438 |
|
|
converted value. */
|
1439 |
|
|
|
1440 |
|
|
tree
|
1441 |
|
|
perform_integral_promotions (tree expr)
|
1442 |
|
|
{
|
1443 |
|
|
tree type;
|
1444 |
|
|
tree promoted_type;
|
1445 |
|
|
|
1446 |
|
|
type = TREE_TYPE (expr);
|
1447 |
|
|
gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
|
1448 |
|
|
promoted_type = type_promotes_to (type);
|
1449 |
|
|
if (type != promoted_type)
|
1450 |
|
|
expr = cp_convert (promoted_type, expr);
|
1451 |
|
|
return expr;
|
1452 |
|
|
}
|
1453 |
|
|
|
1454 |
|
|
/* Take the address of an inline function without setting TREE_ADDRESSABLE
|
1455 |
|
|
or TREE_USED. */
|
1456 |
|
|
|
1457 |
|
|
tree
|
1458 |
|
|
inline_conversion (tree exp)
|
1459 |
|
|
{
|
1460 |
|
|
if (TREE_CODE (exp) == FUNCTION_DECL)
|
1461 |
|
|
exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
|
1462 |
|
|
|
1463 |
|
|
return exp;
|
1464 |
|
|
}
|
1465 |
|
|
|
1466 |
|
|
/* Returns nonzero iff exp is a STRING_CST or the result of applying
|
1467 |
|
|
decay_conversion to one. */
|
1468 |
|
|
|
1469 |
|
|
int
|
1470 |
|
|
string_conv_p (tree totype, tree exp, int warn)
|
1471 |
|
|
{
|
1472 |
|
|
tree t;
|
1473 |
|
|
|
1474 |
|
|
if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE)
|
1475 |
|
|
return 0;
|
1476 |
|
|
|
1477 |
|
|
t = TREE_TYPE (totype);
|
1478 |
|
|
if (!same_type_p (t, char_type_node)
|
1479 |
|
|
&& !same_type_p (t, wchar_type_node))
|
1480 |
|
|
return 0;
|
1481 |
|
|
|
1482 |
|
|
if (TREE_CODE (exp) == STRING_CST)
|
1483 |
|
|
{
|
1484 |
|
|
/* Make sure that we don't try to convert between char and wchar_t. */
|
1485 |
|
|
if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
|
1486 |
|
|
return 0;
|
1487 |
|
|
}
|
1488 |
|
|
else
|
1489 |
|
|
{
|
1490 |
|
|
/* Is this a string constant which has decayed to 'const char *'? */
|
1491 |
|
|
t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
|
1492 |
|
|
if (!same_type_p (TREE_TYPE (exp), t))
|
1493 |
|
|
return 0;
|
1494 |
|
|
STRIP_NOPS (exp);
|
1495 |
|
|
if (TREE_CODE (exp) != ADDR_EXPR
|
1496 |
|
|
|| TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
|
1497 |
|
|
return 0;
|
1498 |
|
|
}
|
1499 |
|
|
|
1500 |
|
|
/* This warning is not very useful, as it complains about printf. */
|
1501 |
|
|
if (warn && warn_write_strings)
|
1502 |
|
|
warning (0, "deprecated conversion from string constant to %qT'", totype);
|
1503 |
|
|
|
1504 |
|
|
return 1;
|
1505 |
|
|
}
|
1506 |
|
|
|
1507 |
|
|
/* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
|
1508 |
|
|
can, for example, use as an lvalue. This code used to be in
|
1509 |
|
|
unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
|
1510 |
|
|
expressions, where we're dealing with aggregates. But now it's again only
|
1511 |
|
|
called from unary_complex_lvalue. The case (in particular) that led to
|
1512 |
|
|
this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
|
1513 |
|
|
get it there. */
|
1514 |
|
|
|
1515 |
|
|
static tree
|
1516 |
|
|
rationalize_conditional_expr (enum tree_code code, tree t)
|
1517 |
|
|
{
|
1518 |
|
|
/* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
|
1519 |
|
|
the first operand is always the one to be used if both operands
|
1520 |
|
|
are equal, so we know what conditional expression this used to be. */
|
1521 |
|
|
if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
|
1522 |
|
|
{
|
1523 |
|
|
/* The following code is incorrect if either operand side-effects. */
|
1524 |
|
|
gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
|
1525 |
|
|
&& !TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)));
|
1526 |
|
|
return
|
1527 |
|
|
build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
|
1528 |
|
|
? LE_EXPR : GE_EXPR),
|
1529 |
|
|
TREE_OPERAND (t, 0),
|
1530 |
|
|
TREE_OPERAND (t, 1),
|
1531 |
|
|
/*overloaded_p=*/NULL),
|
1532 |
|
|
build_unary_op (code, TREE_OPERAND (t, 0), 0),
|
1533 |
|
|
build_unary_op (code, TREE_OPERAND (t, 1), 0));
|
1534 |
|
|
}
|
1535 |
|
|
|
1536 |
|
|
return
|
1537 |
|
|
build_conditional_expr (TREE_OPERAND (t, 0),
|
1538 |
|
|
build_unary_op (code, TREE_OPERAND (t, 1), 0),
|
1539 |
|
|
build_unary_op (code, TREE_OPERAND (t, 2), 0));
|
1540 |
|
|
}
|
1541 |
|
|
|
1542 |
|
|
/* Given the TYPE of an anonymous union field inside T, return the
|
1543 |
|
|
FIELD_DECL for the field. If not found return NULL_TREE. Because
|
1544 |
|
|
anonymous unions can nest, we must also search all anonymous unions
|
1545 |
|
|
that are directly reachable. */
|
1546 |
|
|
|
1547 |
|
|
tree
|
1548 |
|
|
lookup_anon_field (tree t, tree type)
|
1549 |
|
|
{
|
1550 |
|
|
tree field;
|
1551 |
|
|
|
1552 |
|
|
for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
|
1553 |
|
|
{
|
1554 |
|
|
if (TREE_STATIC (field))
|
1555 |
|
|
continue;
|
1556 |
|
|
if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
|
1557 |
|
|
continue;
|
1558 |
|
|
|
1559 |
|
|
/* If we find it directly, return the field. */
|
1560 |
|
|
if (DECL_NAME (field) == NULL_TREE
|
1561 |
|
|
&& type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
|
1562 |
|
|
{
|
1563 |
|
|
return field;
|
1564 |
|
|
}
|
1565 |
|
|
|
1566 |
|
|
/* Otherwise, it could be nested, search harder. */
|
1567 |
|
|
if (DECL_NAME (field) == NULL_TREE
|
1568 |
|
|
&& ANON_AGGR_TYPE_P (TREE_TYPE (field)))
|
1569 |
|
|
{
|
1570 |
|
|
tree subfield = lookup_anon_field (TREE_TYPE (field), type);
|
1571 |
|
|
if (subfield)
|
1572 |
|
|
return subfield;
|
1573 |
|
|
}
|
1574 |
|
|
}
|
1575 |
|
|
return NULL_TREE;
|
1576 |
|
|
}
|
1577 |
|
|
|
1578 |
|
|
/* Build an expression representing OBJECT.MEMBER. OBJECT is an
|
1579 |
|
|
expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
|
1580 |
|
|
non-NULL, it indicates the path to the base used to name MEMBER.
|
1581 |
|
|
If PRESERVE_REFERENCE is true, the expression returned will have
|
1582 |
|
|
REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
|
1583 |
|
|
returned will have the type referred to by the reference.
|
1584 |
|
|
|
1585 |
|
|
This function does not perform access control; that is either done
|
1586 |
|
|
earlier by the parser when the name of MEMBER is resolved to MEMBER
|
1587 |
|
|
itself, or later when overload resolution selects one of the
|
1588 |
|
|
functions indicated by MEMBER. */
|
1589 |
|
|
|
1590 |
|
|
tree
|
1591 |
|
|
build_class_member_access_expr (tree object, tree member,
|
1592 |
|
|
tree access_path, bool preserve_reference)
|
1593 |
|
|
{
|
1594 |
|
|
tree object_type;
|
1595 |
|
|
tree member_scope;
|
1596 |
|
|
tree result = NULL_TREE;
|
1597 |
|
|
|
1598 |
|
|
if (object == error_mark_node || member == error_mark_node)
|
1599 |
|
|
return error_mark_node;
|
1600 |
|
|
|
1601 |
|
|
gcc_assert (DECL_P (member) || BASELINK_P (member));
|
1602 |
|
|
|
1603 |
|
|
/* [expr.ref]
|
1604 |
|
|
|
1605 |
|
|
The type of the first expression shall be "class object" (of a
|
1606 |
|
|
complete type). */
|
1607 |
|
|
object_type = TREE_TYPE (object);
|
1608 |
|
|
if (!currently_open_class (object_type)
|
1609 |
|
|
&& !complete_type_or_else (object_type, object))
|
1610 |
|
|
return error_mark_node;
|
1611 |
|
|
if (!CLASS_TYPE_P (object_type))
|
1612 |
|
|
{
|
1613 |
|
|
error ("request for member %qD in %qE, which is of non-class type %qT",
|
1614 |
|
|
member, object, object_type);
|
1615 |
|
|
return error_mark_node;
|
1616 |
|
|
}
|
1617 |
|
|
|
1618 |
|
|
/* The standard does not seem to actually say that MEMBER must be a
|
1619 |
|
|
member of OBJECT_TYPE. However, that is clearly what is
|
1620 |
|
|
intended. */
|
1621 |
|
|
if (DECL_P (member))
|
1622 |
|
|
{
|
1623 |
|
|
member_scope = DECL_CLASS_CONTEXT (member);
|
1624 |
|
|
mark_used (member);
|
1625 |
|
|
if (TREE_DEPRECATED (member))
|
1626 |
|
|
warn_deprecated_use (member);
|
1627 |
|
|
}
|
1628 |
|
|
else
|
1629 |
|
|
member_scope = BINFO_TYPE (BASELINK_BINFO (member));
|
1630 |
|
|
/* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
|
1631 |
|
|
presently be the anonymous union. Go outwards until we find a
|
1632 |
|
|
type related to OBJECT_TYPE. */
|
1633 |
|
|
while (ANON_AGGR_TYPE_P (member_scope)
|
1634 |
|
|
&& !same_type_ignoring_top_level_qualifiers_p (member_scope,
|
1635 |
|
|
object_type))
|
1636 |
|
|
member_scope = TYPE_CONTEXT (member_scope);
|
1637 |
|
|
if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
|
1638 |
|
|
{
|
1639 |
|
|
if (TREE_CODE (member) == FIELD_DECL)
|
1640 |
|
|
error ("invalid use of nonstatic data member %qE", member);
|
1641 |
|
|
else
|
1642 |
|
|
error ("%qD is not a member of %qT", member, object_type);
|
1643 |
|
|
return error_mark_node;
|
1644 |
|
|
}
|
1645 |
|
|
|
1646 |
|
|
/* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
|
1647 |
|
|
`(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
|
1648 |
|
|
in the frontend; only _DECLs and _REFs are lvalues in the backend. */
|
1649 |
|
|
{
|
1650 |
|
|
tree temp = unary_complex_lvalue (ADDR_EXPR, object);
|
1651 |
|
|
if (temp)
|
1652 |
|
|
object = build_indirect_ref (temp, NULL);
|
1653 |
|
|
}
|
1654 |
|
|
|
1655 |
|
|
/* In [expr.ref], there is an explicit list of the valid choices for
|
1656 |
|
|
MEMBER. We check for each of those cases here. */
|
1657 |
|
|
if (TREE_CODE (member) == VAR_DECL)
|
1658 |
|
|
{
|
1659 |
|
|
/* A static data member. */
|
1660 |
|
|
result = member;
|
1661 |
|
|
/* If OBJECT has side-effects, they are supposed to occur. */
|
1662 |
|
|
if (TREE_SIDE_EFFECTS (object))
|
1663 |
|
|
result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result);
|
1664 |
|
|
}
|
1665 |
|
|
else if (TREE_CODE (member) == FIELD_DECL)
|
1666 |
|
|
{
|
1667 |
|
|
/* A non-static data member. */
|
1668 |
|
|
bool null_object_p;
|
1669 |
|
|
int type_quals;
|
1670 |
|
|
tree member_type;
|
1671 |
|
|
|
1672 |
|
|
null_object_p = (TREE_CODE (object) == INDIRECT_REF
|
1673 |
|
|
&& integer_zerop (TREE_OPERAND (object, 0)));
|
1674 |
|
|
|
1675 |
|
|
/* Convert OBJECT to the type of MEMBER. */
|
1676 |
|
|
if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
|
1677 |
|
|
TYPE_MAIN_VARIANT (member_scope)))
|
1678 |
|
|
{
|
1679 |
|
|
tree binfo;
|
1680 |
|
|
base_kind kind;
|
1681 |
|
|
|
1682 |
|
|
binfo = lookup_base (access_path ? access_path : object_type,
|
1683 |
|
|
member_scope, ba_unique, &kind);
|
1684 |
|
|
if (binfo == error_mark_node)
|
1685 |
|
|
return error_mark_node;
|
1686 |
|
|
|
1687 |
|
|
/* It is invalid to try to get to a virtual base of a
|
1688 |
|
|
NULL object. The most common cause is invalid use of
|
1689 |
|
|
offsetof macro. */
|
1690 |
|
|
if (null_object_p && kind == bk_via_virtual)
|
1691 |
|
|
{
|
1692 |
|
|
error ("invalid access to non-static data member %qD of "
|
1693 |
|
|
"NULL object",
|
1694 |
|
|
member);
|
1695 |
|
|
error ("(perhaps the %<offsetof%> macro was used incorrectly)");
|
1696 |
|
|
return error_mark_node;
|
1697 |
|
|
}
|
1698 |
|
|
|
1699 |
|
|
/* Convert to the base. */
|
1700 |
|
|
object = build_base_path (PLUS_EXPR, object, binfo,
|
1701 |
|
|
/*nonnull=*/1);
|
1702 |
|
|
/* If we found the base successfully then we should be able
|
1703 |
|
|
to convert to it successfully. */
|
1704 |
|
|
gcc_assert (object != error_mark_node);
|
1705 |
|
|
}
|
1706 |
|
|
|
1707 |
|
|
/* Complain about other invalid uses of offsetof, even though they will
|
1708 |
|
|
give the right answer. Note that we complain whether or not they
|
1709 |
|
|
actually used the offsetof macro, since there's no way to know at this
|
1710 |
|
|
point. So we just give a warning, instead of a pedwarn. */
|
1711 |
|
|
/* Do not produce this warning for base class field references, because
|
1712 |
|
|
we know for a fact that didn't come from offsetof. This does occur
|
1713 |
|
|
in various testsuite cases where a null object is passed where a
|
1714 |
|
|
vtable access is required. */
|
1715 |
|
|
if (null_object_p && warn_invalid_offsetof
|
1716 |
|
|
&& CLASSTYPE_NON_POD_P (object_type)
|
1717 |
|
|
&& !DECL_FIELD_IS_BASE (member)
|
1718 |
|
|
&& !skip_evaluation)
|
1719 |
|
|
{
|
1720 |
|
|
warning (0, "invalid access to non-static data member %qD of NULL object",
|
1721 |
|
|
member);
|
1722 |
|
|
warning (0, "(perhaps the %<offsetof%> macro was used incorrectly)");
|
1723 |
|
|
}
|
1724 |
|
|
|
1725 |
|
|
/* If MEMBER is from an anonymous aggregate, we have converted
|
1726 |
|
|
OBJECT so that it refers to the class containing the
|
1727 |
|
|
anonymous union. Generate a reference to the anonymous union
|
1728 |
|
|
itself, and recur to find MEMBER. */
|
1729 |
|
|
if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
|
1730 |
|
|
/* When this code is called from build_field_call, the
|
1731 |
|
|
object already has the type of the anonymous union.
|
1732 |
|
|
That is because the COMPONENT_REF was already
|
1733 |
|
|
constructed, and was then disassembled before calling
|
1734 |
|
|
build_field_call. After the function-call code is
|
1735 |
|
|
cleaned up, this waste can be eliminated. */
|
1736 |
|
|
&& (!same_type_ignoring_top_level_qualifiers_p
|
1737 |
|
|
(TREE_TYPE (object), DECL_CONTEXT (member))))
|
1738 |
|
|
{
|
1739 |
|
|
tree anonymous_union;
|
1740 |
|
|
|
1741 |
|
|
anonymous_union = lookup_anon_field (TREE_TYPE (object),
|
1742 |
|
|
DECL_CONTEXT (member));
|
1743 |
|
|
object = build_class_member_access_expr (object,
|
1744 |
|
|
anonymous_union,
|
1745 |
|
|
/*access_path=*/NULL_TREE,
|
1746 |
|
|
preserve_reference);
|
1747 |
|
|
}
|
1748 |
|
|
|
1749 |
|
|
/* Compute the type of the field, as described in [expr.ref]. */
|
1750 |
|
|
type_quals = TYPE_UNQUALIFIED;
|
1751 |
|
|
member_type = TREE_TYPE (member);
|
1752 |
|
|
if (TREE_CODE (member_type) != REFERENCE_TYPE)
|
1753 |
|
|
{
|
1754 |
|
|
type_quals = (cp_type_quals (member_type)
|
1755 |
|
|
| cp_type_quals (object_type));
|
1756 |
|
|
|
1757 |
|
|
/* A field is const (volatile) if the enclosing object, or the
|
1758 |
|
|
field itself, is const (volatile). But, a mutable field is
|
1759 |
|
|
not const, even within a const object. */
|
1760 |
|
|
if (DECL_MUTABLE_P (member))
|
1761 |
|
|
type_quals &= ~TYPE_QUAL_CONST;
|
1762 |
|
|
member_type = cp_build_qualified_type (member_type, type_quals);
|
1763 |
|
|
}
|
1764 |
|
|
|
1765 |
|
|
result = build3 (COMPONENT_REF, member_type, object, member,
|
1766 |
|
|
NULL_TREE);
|
1767 |
|
|
result = fold_if_not_in_template (result);
|
1768 |
|
|
|
1769 |
|
|
/* Mark the expression const or volatile, as appropriate. Even
|
1770 |
|
|
though we've dealt with the type above, we still have to mark the
|
1771 |
|
|
expression itself. */
|
1772 |
|
|
if (type_quals & TYPE_QUAL_CONST)
|
1773 |
|
|
TREE_READONLY (result) = 1;
|
1774 |
|
|
if (type_quals & TYPE_QUAL_VOLATILE)
|
1775 |
|
|
TREE_THIS_VOLATILE (result) = 1;
|
1776 |
|
|
}
|
1777 |
|
|
else if (BASELINK_P (member))
|
1778 |
|
|
{
|
1779 |
|
|
/* The member is a (possibly overloaded) member function. */
|
1780 |
|
|
tree functions;
|
1781 |
|
|
tree type;
|
1782 |
|
|
|
1783 |
|
|
/* If the MEMBER is exactly one static member function, then we
|
1784 |
|
|
know the type of the expression. Otherwise, we must wait
|
1785 |
|
|
until overload resolution has been performed. */
|
1786 |
|
|
functions = BASELINK_FUNCTIONS (member);
|
1787 |
|
|
if (TREE_CODE (functions) == FUNCTION_DECL
|
1788 |
|
|
&& DECL_STATIC_FUNCTION_P (functions))
|
1789 |
|
|
type = TREE_TYPE (functions);
|
1790 |
|
|
else
|
1791 |
|
|
type = unknown_type_node;
|
1792 |
|
|
/* Note that we do not convert OBJECT to the BASELINK_BINFO
|
1793 |
|
|
base. That will happen when the function is called. */
|
1794 |
|
|
result = build3 (COMPONENT_REF, type, object, member, NULL_TREE);
|
1795 |
|
|
}
|
1796 |
|
|
else if (TREE_CODE (member) == CONST_DECL)
|
1797 |
|
|
{
|
1798 |
|
|
/* The member is an enumerator. */
|
1799 |
|
|
result = member;
|
1800 |
|
|
/* If OBJECT has side-effects, they are supposed to occur. */
|
1801 |
|
|
if (TREE_SIDE_EFFECTS (object))
|
1802 |
|
|
result = build2 (COMPOUND_EXPR, TREE_TYPE (result),
|
1803 |
|
|
object, result);
|
1804 |
|
|
}
|
1805 |
|
|
else
|
1806 |
|
|
{
|
1807 |
|
|
error ("invalid use of %qD", member);
|
1808 |
|
|
return error_mark_node;
|
1809 |
|
|
}
|
1810 |
|
|
|
1811 |
|
|
if (!preserve_reference)
|
1812 |
|
|
/* [expr.ref]
|
1813 |
|
|
|
1814 |
|
|
If E2 is declared to have type "reference to T", then ... the
|
1815 |
|
|
type of E1.E2 is T. */
|
1816 |
|
|
result = convert_from_reference (result);
|
1817 |
|
|
|
1818 |
|
|
return result;
|
1819 |
|
|
}
|
1820 |
|
|
|
1821 |
|
|
/* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
|
1822 |
|
|
SCOPE is NULL, by OBJECT.~DTOR_NAME. */
|
1823 |
|
|
|
1824 |
|
|
static tree
|
1825 |
|
|
lookup_destructor (tree object, tree scope, tree dtor_name)
|
1826 |
|
|
{
|
1827 |
|
|
tree object_type = TREE_TYPE (object);
|
1828 |
|
|
tree dtor_type = TREE_OPERAND (dtor_name, 0);
|
1829 |
|
|
tree expr;
|
1830 |
|
|
|
1831 |
|
|
if (scope && !check_dtor_name (scope, dtor_type))
|
1832 |
|
|
{
|
1833 |
|
|
error ("qualified type %qT does not match destructor name ~%qT",
|
1834 |
|
|
scope, dtor_type);
|
1835 |
|
|
return error_mark_node;
|
1836 |
|
|
}
|
1837 |
|
|
if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
|
1838 |
|
|
{
|
1839 |
|
|
error ("the type being destroyed is %qT, but the destructor refers to %qT",
|
1840 |
|
|
TYPE_MAIN_VARIANT (object_type), dtor_type);
|
1841 |
|
|
return error_mark_node;
|
1842 |
|
|
}
|
1843 |
|
|
expr = lookup_member (dtor_type, complete_dtor_identifier,
|
1844 |
|
|
/*protect=*/1, /*want_type=*/false);
|
1845 |
|
|
expr = (adjust_result_of_qualified_name_lookup
|
1846 |
|
|
(expr, dtor_type, object_type));
|
1847 |
|
|
return expr;
|
1848 |
|
|
}
|
1849 |
|
|
|
1850 |
|
|
/* An expression of the form "A::template B" has been resolved to
|
1851 |
|
|
DECL. Issue a diagnostic if B is not a template or template
|
1852 |
|
|
specialization. */
|
1853 |
|
|
|
1854 |
|
|
void
|
1855 |
|
|
check_template_keyword (tree decl)
|
1856 |
|
|
{
|
1857 |
|
|
/* The standard says:
|
1858 |
|
|
|
1859 |
|
|
[temp.names]
|
1860 |
|
|
|
1861 |
|
|
If a name prefixed by the keyword template is not a member
|
1862 |
|
|
template, the program is ill-formed.
|
1863 |
|
|
|
1864 |
|
|
DR 228 removed the restriction that the template be a member
|
1865 |
|
|
template.
|
1866 |
|
|
|
1867 |
|
|
DR 96, if accepted would add the further restriction that explicit
|
1868 |
|
|
template arguments must be provided if the template keyword is
|
1869 |
|
|
used, but, as of 2005-10-16, that DR is still in "drafting". If
|
1870 |
|
|
this DR is accepted, then the semantic checks here can be
|
1871 |
|
|
simplified, as the entity named must in fact be a template
|
1872 |
|
|
specialization, rather than, as at present, a set of overloaded
|
1873 |
|
|
functions containing at least one template function. */
|
1874 |
|
|
if (TREE_CODE (decl) != TEMPLATE_DECL
|
1875 |
|
|
&& TREE_CODE (decl) != TEMPLATE_ID_EXPR)
|
1876 |
|
|
{
|
1877 |
|
|
if (!is_overloaded_fn (decl))
|
1878 |
|
|
pedwarn ("%qD is not a template", decl);
|
1879 |
|
|
else
|
1880 |
|
|
{
|
1881 |
|
|
tree fns;
|
1882 |
|
|
fns = decl;
|
1883 |
|
|
if (BASELINK_P (fns))
|
1884 |
|
|
fns = BASELINK_FUNCTIONS (fns);
|
1885 |
|
|
while (fns)
|
1886 |
|
|
{
|
1887 |
|
|
tree fn = OVL_CURRENT (fns);
|
1888 |
|
|
if (TREE_CODE (fn) == TEMPLATE_DECL
|
1889 |
|
|
|| TREE_CODE (fn) == TEMPLATE_ID_EXPR)
|
1890 |
|
|
break;
|
1891 |
|
|
if (TREE_CODE (fn) == FUNCTION_DECL
|
1892 |
|
|
&& DECL_USE_TEMPLATE (fn)
|
1893 |
|
|
&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
|
1894 |
|
|
break;
|
1895 |
|
|
fns = OVL_NEXT (fns);
|
1896 |
|
|
}
|
1897 |
|
|
if (!fns)
|
1898 |
|
|
pedwarn ("%qD is not a template", decl);
|
1899 |
|
|
}
|
1900 |
|
|
}
|
1901 |
|
|
}
|
1902 |
|
|
|
1903 |
|
|
/* This function is called by the parser to process a class member
|
1904 |
|
|
access expression of the form OBJECT.NAME. NAME is a node used by
|
1905 |
|
|
the parser to represent a name; it is not yet a DECL. It may,
|
1906 |
|
|
however, be a BASELINK where the BASELINK_FUNCTIONS is a
|
1907 |
|
|
TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
|
1908 |
|
|
there is no reason to do the lookup twice, so the parser keeps the
|
1909 |
|
|
BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
|
1910 |
|
|
be a template via the use of the "A::template B" syntax. */
|
1911 |
|
|
|
1912 |
|
|
tree
|
1913 |
|
|
finish_class_member_access_expr (tree object, tree name, bool template_p)
|
1914 |
|
|
{
|
1915 |
|
|
tree expr;
|
1916 |
|
|
tree object_type;
|
1917 |
|
|
tree member;
|
1918 |
|
|
tree access_path = NULL_TREE;
|
1919 |
|
|
tree orig_object = object;
|
1920 |
|
|
tree orig_name = name;
|
1921 |
|
|
|
1922 |
|
|
if (object == error_mark_node || name == error_mark_node)
|
1923 |
|
|
return error_mark_node;
|
1924 |
|
|
|
1925 |
|
|
/* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
|
1926 |
|
|
if (!objc_is_public (object, name))
|
1927 |
|
|
return error_mark_node;
|
1928 |
|
|
|
1929 |
|
|
object_type = TREE_TYPE (object);
|
1930 |
|
|
|
1931 |
|
|
if (processing_template_decl)
|
1932 |
|
|
{
|
1933 |
|
|
if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
|
1934 |
|
|
dependent_type_p (object_type)
|
1935 |
|
|
/* If NAME is just an IDENTIFIER_NODE, then the expression
|
1936 |
|
|
is dependent. */
|
1937 |
|
|
|| TREE_CODE (object) == IDENTIFIER_NODE
|
1938 |
|
|
/* If NAME is "f<args>", where either 'f' or 'args' is
|
1939 |
|
|
dependent, then the expression is dependent. */
|
1940 |
|
|
|| (TREE_CODE (name) == TEMPLATE_ID_EXPR
|
1941 |
|
|
&& dependent_template_id_p (TREE_OPERAND (name, 0),
|
1942 |
|
|
TREE_OPERAND (name, 1)))
|
1943 |
|
|
/* If NAME is "T::X" where "T" is dependent, then the
|
1944 |
|
|
expression is dependent. */
|
1945 |
|
|
|| (TREE_CODE (name) == SCOPE_REF
|
1946 |
|
|
&& TYPE_P (TREE_OPERAND (name, 0))
|
1947 |
|
|
&& dependent_type_p (TREE_OPERAND (name, 0))))
|
1948 |
|
|
return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
|
1949 |
|
|
object = build_non_dependent_expr (object);
|
1950 |
|
|
}
|
1951 |
|
|
|
1952 |
|
|
/* [expr.ref]
|
1953 |
|
|
|
1954 |
|
|
The type of the first expression shall be "class object" (of a
|
1955 |
|
|
complete type). */
|
1956 |
|
|
if (!currently_open_class (object_type)
|
1957 |
|
|
&& !complete_type_or_else (object_type, object))
|
1958 |
|
|
return error_mark_node;
|
1959 |
|
|
if (!CLASS_TYPE_P (object_type))
|
1960 |
|
|
{
|
1961 |
|
|
error ("request for member %qD in %qE, which is of non-class type %qT",
|
1962 |
|
|
name, object, object_type);
|
1963 |
|
|
return error_mark_node;
|
1964 |
|
|
}
|
1965 |
|
|
|
1966 |
|
|
if (BASELINK_P (name))
|
1967 |
|
|
/* A member function that has already been looked up. */
|
1968 |
|
|
member = name;
|
1969 |
|
|
else
|
1970 |
|
|
{
|
1971 |
|
|
bool is_template_id = false;
|
1972 |
|
|
tree template_args = NULL_TREE;
|
1973 |
|
|
tree scope;
|
1974 |
|
|
|
1975 |
|
|
if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
|
1976 |
|
|
{
|
1977 |
|
|
is_template_id = true;
|
1978 |
|
|
template_args = TREE_OPERAND (name, 1);
|
1979 |
|
|
name = TREE_OPERAND (name, 0);
|
1980 |
|
|
|
1981 |
|
|
if (TREE_CODE (name) == OVERLOAD)
|
1982 |
|
|
name = DECL_NAME (get_first_fn (name));
|
1983 |
|
|
else if (DECL_P (name))
|
1984 |
|
|
name = DECL_NAME (name);
|
1985 |
|
|
}
|
1986 |
|
|
|
1987 |
|
|
if (TREE_CODE (name) == SCOPE_REF)
|
1988 |
|
|
{
|
1989 |
|
|
/* A qualified name. The qualifying class or namespace `S'
|
1990 |
|
|
has already been looked up; it is either a TYPE or a
|
1991 |
|
|
NAMESPACE_DECL. */
|
1992 |
|
|
scope = TREE_OPERAND (name, 0);
|
1993 |
|
|
name = TREE_OPERAND (name, 1);
|
1994 |
|
|
|
1995 |
|
|
/* If SCOPE is a namespace, then the qualified name does not
|
1996 |
|
|
name a member of OBJECT_TYPE. */
|
1997 |
|
|
if (TREE_CODE (scope) == NAMESPACE_DECL)
|
1998 |
|
|
{
|
1999 |
|
|
error ("%<%D::%D%> is not a member of %qT",
|
2000 |
|
|
scope, name, object_type);
|
2001 |
|
|
return error_mark_node;
|
2002 |
|
|
}
|
2003 |
|
|
|
2004 |
|
|
gcc_assert (CLASS_TYPE_P (scope));
|
2005 |
|
|
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
|
2006 |
|
|
|| TREE_CODE (name) == BIT_NOT_EXPR);
|
2007 |
|
|
|
2008 |
|
|
/* Find the base of OBJECT_TYPE corresponding to SCOPE. */
|
2009 |
|
|
access_path = lookup_base (object_type, scope, ba_check, NULL);
|
2010 |
|
|
if (access_path == error_mark_node)
|
2011 |
|
|
return error_mark_node;
|
2012 |
|
|
if (!access_path)
|
2013 |
|
|
{
|
2014 |
|
|
error ("%qT is not a base of %qT", scope, object_type);
|
2015 |
|
|
return error_mark_node;
|
2016 |
|
|
}
|
2017 |
|
|
}
|
2018 |
|
|
else
|
2019 |
|
|
{
|
2020 |
|
|
scope = NULL_TREE;
|
2021 |
|
|
access_path = object_type;
|
2022 |
|
|
}
|
2023 |
|
|
|
2024 |
|
|
if (TREE_CODE (name) == BIT_NOT_EXPR)
|
2025 |
|
|
member = lookup_destructor (object, scope, name);
|
2026 |
|
|
else
|
2027 |
|
|
{
|
2028 |
|
|
/* Look up the member. */
|
2029 |
|
|
member = lookup_member (access_path, name, /*protect=*/1,
|
2030 |
|
|
/*want_type=*/false);
|
2031 |
|
|
if (member == NULL_TREE)
|
2032 |
|
|
{
|
2033 |
|
|
error ("%qD has no member named %qE", object_type, name);
|
2034 |
|
|
return error_mark_node;
|
2035 |
|
|
}
|
2036 |
|
|
if (member == error_mark_node)
|
2037 |
|
|
return error_mark_node;
|
2038 |
|
|
}
|
2039 |
|
|
|
2040 |
|
|
if (is_template_id)
|
2041 |
|
|
{
|
2042 |
|
|
tree template = member;
|
2043 |
|
|
|
2044 |
|
|
if (BASELINK_P (template))
|
2045 |
|
|
template = lookup_template_function (template, template_args);
|
2046 |
|
|
else
|
2047 |
|
|
{
|
2048 |
|
|
error ("%qD is not a member template function", name);
|
2049 |
|
|
return error_mark_node;
|
2050 |
|
|
}
|
2051 |
|
|
}
|
2052 |
|
|
}
|
2053 |
|
|
|
2054 |
|
|
if (TREE_DEPRECATED (member))
|
2055 |
|
|
warn_deprecated_use (member);
|
2056 |
|
|
|
2057 |
|
|
if (template_p)
|
2058 |
|
|
check_template_keyword (member);
|
2059 |
|
|
|
2060 |
|
|
expr = build_class_member_access_expr (object, member, access_path,
|
2061 |
|
|
/*preserve_reference=*/false);
|
2062 |
|
|
if (processing_template_decl && expr != error_mark_node)
|
2063 |
|
|
{
|
2064 |
|
|
if (BASELINK_P (member))
|
2065 |
|
|
{
|
2066 |
|
|
if (TREE_CODE (orig_name) == SCOPE_REF)
|
2067 |
|
|
BASELINK_QUALIFIED_P (member) = 1;
|
2068 |
|
|
orig_name = member;
|
2069 |
|
|
}
|
2070 |
|
|
return build_min_non_dep (COMPONENT_REF, expr,
|
2071 |
|
|
orig_object, orig_name,
|
2072 |
|
|
NULL_TREE);
|
2073 |
|
|
}
|
2074 |
|
|
|
2075 |
|
|
return expr;
|
2076 |
|
|
}
|
2077 |
|
|
|
2078 |
|
|
/* Return an expression for the MEMBER_NAME field in the internal
|
2079 |
|
|
representation of PTRMEM, a pointer-to-member function. (Each
|
2080 |
|
|
pointer-to-member function type gets its own RECORD_TYPE so it is
|
2081 |
|
|
more convenient to access the fields by name than by FIELD_DECL.)
|
2082 |
|
|
This routine converts the NAME to a FIELD_DECL and then creates the
|
2083 |
|
|
node for the complete expression. */
|
2084 |
|
|
|
2085 |
|
|
tree
|
2086 |
|
|
build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
|
2087 |
|
|
{
|
2088 |
|
|
tree ptrmem_type;
|
2089 |
|
|
tree member;
|
2090 |
|
|
tree member_type;
|
2091 |
|
|
|
2092 |
|
|
/* This code is a stripped down version of
|
2093 |
|
|
build_class_member_access_expr. It does not work to use that
|
2094 |
|
|
routine directly because it expects the object to be of class
|
2095 |
|
|
type. */
|
2096 |
|
|
ptrmem_type = TREE_TYPE (ptrmem);
|
2097 |
|
|
gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
|
2098 |
|
|
member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
|
2099 |
|
|
/*want_type=*/false);
|
2100 |
|
|
member_type = cp_build_qualified_type (TREE_TYPE (member),
|
2101 |
|
|
cp_type_quals (ptrmem_type));
|
2102 |
|
|
return fold_build3 (COMPONENT_REF, member_type,
|
2103 |
|
|
ptrmem, member, NULL_TREE);
|
2104 |
|
|
}
|
2105 |
|
|
|
2106 |
|
|
/* Given an expression PTR for a pointer, return an expression
|
2107 |
|
|
for the value pointed to.
|
2108 |
|
|
ERRORSTRING is the name of the operator to appear in error messages.
|
2109 |
|
|
|
2110 |
|
|
This function may need to overload OPERATOR_FNNAME.
|
2111 |
|
|
Must also handle REFERENCE_TYPEs for C++. */
|
2112 |
|
|
|
2113 |
|
|
tree
|
2114 |
|
|
build_x_indirect_ref (tree expr, const char *errorstring)
|
2115 |
|
|
{
|
2116 |
|
|
tree orig_expr = expr;
|
2117 |
|
|
tree rval;
|
2118 |
|
|
|
2119 |
|
|
if (processing_template_decl)
|
2120 |
|
|
{
|
2121 |
|
|
if (type_dependent_expression_p (expr))
|
2122 |
|
|
return build_min_nt (INDIRECT_REF, expr);
|
2123 |
|
|
expr = build_non_dependent_expr (expr);
|
2124 |
|
|
}
|
2125 |
|
|
|
2126 |
|
|
rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
|
2127 |
|
|
NULL_TREE, /*overloaded_p=*/NULL);
|
2128 |
|
|
if (!rval)
|
2129 |
|
|
rval = build_indirect_ref (expr, errorstring);
|
2130 |
|
|
|
2131 |
|
|
if (processing_template_decl && rval != error_mark_node)
|
2132 |
|
|
return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
|
2133 |
|
|
else
|
2134 |
|
|
return rval;
|
2135 |
|
|
}
|
2136 |
|
|
|
2137 |
|
|
tree
|
2138 |
|
|
build_indirect_ref (tree ptr, const char *errorstring)
|
2139 |
|
|
{
|
2140 |
|
|
tree pointer, type;
|
2141 |
|
|
|
2142 |
|
|
if (ptr == error_mark_node)
|
2143 |
|
|
return error_mark_node;
|
2144 |
|
|
|
2145 |
|
|
if (ptr == current_class_ptr)
|
2146 |
|
|
return current_class_ref;
|
2147 |
|
|
|
2148 |
|
|
pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
|
2149 |
|
|
? ptr : decay_conversion (ptr));
|
2150 |
|
|
type = TREE_TYPE (pointer);
|
2151 |
|
|
|
2152 |
|
|
if (POINTER_TYPE_P (type))
|
2153 |
|
|
{
|
2154 |
|
|
/* [expr.unary.op]
|
2155 |
|
|
|
2156 |
|
|
If the type of the expression is "pointer to T," the type
|
2157 |
|
|
of the result is "T."
|
2158 |
|
|
|
2159 |
|
|
We must use the canonical variant because certain parts of
|
2160 |
|
|
the back end, like fold, do pointer comparisons between
|
2161 |
|
|
types. */
|
2162 |
|
|
tree t = canonical_type_variant (TREE_TYPE (type));
|
2163 |
|
|
|
2164 |
|
|
if (VOID_TYPE_P (t))
|
2165 |
|
|
{
|
2166 |
|
|
/* A pointer to incomplete type (other than cv void) can be
|
2167 |
|
|
dereferenced [expr.unary.op]/1 */
|
2168 |
|
|
error ("%qT is not a pointer-to-object type", type);
|
2169 |
|
|
return error_mark_node;
|
2170 |
|
|
}
|
2171 |
|
|
else if (TREE_CODE (pointer) == ADDR_EXPR
|
2172 |
|
|
&& same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
|
2173 |
|
|
/* The POINTER was something like `&x'. We simplify `*&x' to
|
2174 |
|
|
`x'. */
|
2175 |
|
|
return TREE_OPERAND (pointer, 0);
|
2176 |
|
|
else
|
2177 |
|
|
{
|
2178 |
|
|
tree ref = build1 (INDIRECT_REF, t, pointer);
|
2179 |
|
|
|
2180 |
|
|
/* We *must* set TREE_READONLY when dereferencing a pointer to const,
|
2181 |
|
|
so that we get the proper error message if the result is used
|
2182 |
|
|
to assign to. Also, &* is supposed to be a no-op. */
|
2183 |
|
|
TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
|
2184 |
|
|
TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
|
2185 |
|
|
TREE_SIDE_EFFECTS (ref)
|
2186 |
|
|
= (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
|
2187 |
|
|
return ref;
|
2188 |
|
|
}
|
2189 |
|
|
}
|
2190 |
|
|
/* `pointer' won't be an error_mark_node if we were given a
|
2191 |
|
|
pointer to member, so it's cool to check for this here. */
|
2192 |
|
|
else if (TYPE_PTR_TO_MEMBER_P (type))
|
2193 |
|
|
error ("invalid use of %qs on pointer to member", errorstring);
|
2194 |
|
|
else if (pointer != error_mark_node)
|
2195 |
|
|
{
|
2196 |
|
|
if (errorstring)
|
2197 |
|
|
error ("invalid type argument of %qs", errorstring);
|
2198 |
|
|
else
|
2199 |
|
|
error ("invalid type argument");
|
2200 |
|
|
}
|
2201 |
|
|
return error_mark_node;
|
2202 |
|
|
}
|
2203 |
|
|
|
2204 |
|
|
/* This handles expressions of the form "a[i]", which denotes
|
2205 |
|
|
an array reference.
|
2206 |
|
|
|
2207 |
|
|
This is logically equivalent in C to *(a+i), but we may do it differently.
|
2208 |
|
|
If A is a variable or a member, we generate a primitive ARRAY_REF.
|
2209 |
|
|
This avoids forcing the array out of registers, and can work on
|
2210 |
|
|
arrays that are not lvalues (for example, members of structures returned
|
2211 |
|
|
by functions).
|
2212 |
|
|
|
2213 |
|
|
If INDEX is of some user-defined type, it must be converted to
|
2214 |
|
|
integer type. Otherwise, to make a compatible PLUS_EXPR, it
|
2215 |
|
|
will inherit the type of the array, which will be some pointer type. */
|
2216 |
|
|
|
2217 |
|
|
tree
|
2218 |
|
|
build_array_ref (tree array, tree idx)
|
2219 |
|
|
{
|
2220 |
|
|
if (idx == 0)
|
2221 |
|
|
{
|
2222 |
|
|
error ("subscript missing in array reference");
|
2223 |
|
|
return error_mark_node;
|
2224 |
|
|
}
|
2225 |
|
|
|
2226 |
|
|
if (TREE_TYPE (array) == error_mark_node
|
2227 |
|
|
|| TREE_TYPE (idx) == error_mark_node)
|
2228 |
|
|
return error_mark_node;
|
2229 |
|
|
|
2230 |
|
|
/* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
|
2231 |
|
|
inside it. */
|
2232 |
|
|
switch (TREE_CODE (array))
|
2233 |
|
|
{
|
2234 |
|
|
case COMPOUND_EXPR:
|
2235 |
|
|
{
|
2236 |
|
|
tree value = build_array_ref (TREE_OPERAND (array, 1), idx);
|
2237 |
|
|
return build2 (COMPOUND_EXPR, TREE_TYPE (value),
|
2238 |
|
|
TREE_OPERAND (array, 0), value);
|
2239 |
|
|
}
|
2240 |
|
|
|
2241 |
|
|
case COND_EXPR:
|
2242 |
|
|
return build_conditional_expr
|
2243 |
|
|
(TREE_OPERAND (array, 0),
|
2244 |
|
|
build_array_ref (TREE_OPERAND (array, 1), idx),
|
2245 |
|
|
build_array_ref (TREE_OPERAND (array, 2), idx));
|
2246 |
|
|
|
2247 |
|
|
default:
|
2248 |
|
|
break;
|
2249 |
|
|
}
|
2250 |
|
|
|
2251 |
|
|
if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
|
2252 |
|
|
{
|
2253 |
|
|
tree rval, type;
|
2254 |
|
|
|
2255 |
|
|
/* Subscripting with type char is likely to lose
|
2256 |
|
|
on a machine where chars are signed.
|
2257 |
|
|
So warn on any machine, but optionally.
|
2258 |
|
|
Don't warn for unsigned char since that type is safe.
|
2259 |
|
|
Don't warn for signed char because anyone who uses that
|
2260 |
|
|
must have done so deliberately. */
|
2261 |
|
|
if (warn_char_subscripts
|
2262 |
|
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
|
2263 |
|
|
warning (0, "array subscript has type %<char%>");
|
2264 |
|
|
|
2265 |
|
|
if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
|
2266 |
|
|
{
|
2267 |
|
|
error ("array subscript is not an integer");
|
2268 |
|
|
return error_mark_node;
|
2269 |
|
|
}
|
2270 |
|
|
|
2271 |
|
|
/* Apply integral promotions *after* noticing character types.
|
2272 |
|
|
(It is unclear why we do these promotions -- the standard
|
2273 |
|
|
does not say that we should. In fact, the natural thing would
|
2274 |
|
|
seem to be to convert IDX to ptrdiff_t; we're performing
|
2275 |
|
|
pointer arithmetic.) */
|
2276 |
|
|
idx = perform_integral_promotions (idx);
|
2277 |
|
|
|
2278 |
|
|
/* An array that is indexed by a non-constant
|
2279 |
|
|
cannot be stored in a register; we must be able to do
|
2280 |
|
|
address arithmetic on its address.
|
2281 |
|
|
Likewise an array of elements of variable size. */
|
2282 |
|
|
if (TREE_CODE (idx) != INTEGER_CST
|
2283 |
|
|
|| (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
|
2284 |
|
|
&& (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
|
2285 |
|
|
!= INTEGER_CST)))
|
2286 |
|
|
{
|
2287 |
|
|
if (!cxx_mark_addressable (array))
|
2288 |
|
|
return error_mark_node;
|
2289 |
|
|
}
|
2290 |
|
|
|
2291 |
|
|
/* An array that is indexed by a constant value which is not within
|
2292 |
|
|
the array bounds cannot be stored in a register either; because we
|
2293 |
|
|
would get a crash in store_bit_field/extract_bit_field when trying
|
2294 |
|
|
to access a non-existent part of the register. */
|
2295 |
|
|
if (TREE_CODE (idx) == INTEGER_CST
|
2296 |
|
|
&& TYPE_DOMAIN (TREE_TYPE (array))
|
2297 |
|
|
&& ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
|
2298 |
|
|
{
|
2299 |
|
|
if (!cxx_mark_addressable (array))
|
2300 |
|
|
return error_mark_node;
|
2301 |
|
|
}
|
2302 |
|
|
|
2303 |
|
|
if (pedantic && !lvalue_p (array))
|
2304 |
|
|
pedwarn ("ISO C++ forbids subscripting non-lvalue array");
|
2305 |
|
|
|
2306 |
|
|
/* Note in C++ it is valid to subscript a `register' array, since
|
2307 |
|
|
it is valid to take the address of something with that
|
2308 |
|
|
storage specification. */
|
2309 |
|
|
if (extra_warnings)
|
2310 |
|
|
{
|
2311 |
|
|
tree foo = array;
|
2312 |
|
|
while (TREE_CODE (foo) == COMPONENT_REF)
|
2313 |
|
|
foo = TREE_OPERAND (foo, 0);
|
2314 |
|
|
if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
|
2315 |
|
|
warning (0, "subscripting array declared %<register%>");
|
2316 |
|
|
}
|
2317 |
|
|
|
2318 |
|
|
type = TREE_TYPE (TREE_TYPE (array));
|
2319 |
|
|
rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
|
2320 |
|
|
/* Array ref is const/volatile if the array elements are
|
2321 |
|
|
or if the array is.. */
|
2322 |
|
|
TREE_READONLY (rval)
|
2323 |
|
|
|= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
|
2324 |
|
|
TREE_SIDE_EFFECTS (rval)
|
2325 |
|
|
|= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
|
2326 |
|
|
TREE_THIS_VOLATILE (rval)
|
2327 |
|
|
|= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
|
2328 |
|
|
return require_complete_type (fold_if_not_in_template (rval));
|
2329 |
|
|
}
|
2330 |
|
|
|
2331 |
|
|
{
|
2332 |
|
|
tree ar = default_conversion (array);
|
2333 |
|
|
tree ind = default_conversion (idx);
|
2334 |
|
|
|
2335 |
|
|
/* Put the integer in IND to simplify error checking. */
|
2336 |
|
|
if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
|
2337 |
|
|
{
|
2338 |
|
|
tree temp = ar;
|
2339 |
|
|
ar = ind;
|
2340 |
|
|
ind = temp;
|
2341 |
|
|
}
|
2342 |
|
|
|
2343 |
|
|
if (ar == error_mark_node)
|
2344 |
|
|
return ar;
|
2345 |
|
|
|
2346 |
|
|
if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
|
2347 |
|
|
{
|
2348 |
|
|
error ("subscripted value is neither array nor pointer");
|
2349 |
|
|
return error_mark_node;
|
2350 |
|
|
}
|
2351 |
|
|
if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
|
2352 |
|
|
{
|
2353 |
|
|
error ("array subscript is not an integer");
|
2354 |
|
|
return error_mark_node;
|
2355 |
|
|
}
|
2356 |
|
|
|
2357 |
|
|
return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
|
2358 |
|
|
"array indexing");
|
2359 |
|
|
}
|
2360 |
|
|
}
|
2361 |
|
|
|
2362 |
|
|
/* Resolve a pointer to member function. INSTANCE is the object
|
2363 |
|
|
instance to use, if the member points to a virtual member.
|
2364 |
|
|
|
2365 |
|
|
This used to avoid checking for virtual functions if basetype
|
2366 |
|
|
has no virtual functions, according to an earlier ANSI draft.
|
2367 |
|
|
With the final ISO C++ rules, such an optimization is
|
2368 |
|
|
incorrect: A pointer to a derived member can be static_cast
|
2369 |
|
|
to pointer-to-base-member, as long as the dynamic object
|
2370 |
|
|
later has the right member. */
|
2371 |
|
|
|
2372 |
|
|
tree
|
2373 |
|
|
get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
|
2374 |
|
|
{
|
2375 |
|
|
if (TREE_CODE (function) == OFFSET_REF)
|
2376 |
|
|
function = TREE_OPERAND (function, 1);
|
2377 |
|
|
|
2378 |
|
|
if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
|
2379 |
|
|
{
|
2380 |
|
|
tree idx, delta, e1, e2, e3, vtbl, basetype;
|
2381 |
|
|
tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
|
2382 |
|
|
|
2383 |
|
|
tree instance_ptr = *instance_ptrptr;
|
2384 |
|
|
tree instance_save_expr = 0;
|
2385 |
|
|
if (instance_ptr == error_mark_node)
|
2386 |
|
|
{
|
2387 |
|
|
if (TREE_CODE (function) == PTRMEM_CST)
|
2388 |
|
|
{
|
2389 |
|
|
/* Extracting the function address from a pmf is only
|
2390 |
|
|
allowed with -Wno-pmf-conversions. It only works for
|
2391 |
|
|
pmf constants. */
|
2392 |
|
|
e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
|
2393 |
|
|
e1 = convert (fntype, e1);
|
2394 |
|
|
return e1;
|
2395 |
|
|
}
|
2396 |
|
|
else
|
2397 |
|
|
{
|
2398 |
|
|
error ("object missing in use of %qE", function);
|
2399 |
|
|
return error_mark_node;
|
2400 |
|
|
}
|
2401 |
|
|
}
|
2402 |
|
|
|
2403 |
|
|
if (TREE_SIDE_EFFECTS (instance_ptr))
|
2404 |
|
|
instance_ptr = instance_save_expr = save_expr (instance_ptr);
|
2405 |
|
|
|
2406 |
|
|
if (TREE_SIDE_EFFECTS (function))
|
2407 |
|
|
function = save_expr (function);
|
2408 |
|
|
|
2409 |
|
|
/* Start by extracting all the information from the PMF itself. */
|
2410 |
|
|
e3 = pfn_from_ptrmemfunc (function);
|
2411 |
|
|
delta = build_ptrmemfunc_access_expr (function, delta_identifier);
|
2412 |
|
|
idx = build1 (NOP_EXPR, vtable_index_type, e3);
|
2413 |
|
|
switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
|
2414 |
|
|
{
|
2415 |
|
|
case ptrmemfunc_vbit_in_pfn:
|
2416 |
|
|
e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node);
|
2417 |
|
|
idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
|
2418 |
|
|
break;
|
2419 |
|
|
|
2420 |
|
|
case ptrmemfunc_vbit_in_delta:
|
2421 |
|
|
e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node);
|
2422 |
|
|
delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node);
|
2423 |
|
|
break;
|
2424 |
|
|
|
2425 |
|
|
default:
|
2426 |
|
|
gcc_unreachable ();
|
2427 |
|
|
}
|
2428 |
|
|
|
2429 |
|
|
/* Convert down to the right base before using the instance. A
|
2430 |
|
|
special case is that in a pointer to member of class C, C may
|
2431 |
|
|
be incomplete. In that case, the function will of course be
|
2432 |
|
|
a member of C, and no conversion is required. In fact,
|
2433 |
|
|
lookup_base will fail in that case, because incomplete
|
2434 |
|
|
classes do not have BINFOs. */
|
2435 |
|
|
basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
|
2436 |
|
|
if (!same_type_ignoring_top_level_qualifiers_p
|
2437 |
|
|
(basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
|
2438 |
|
|
{
|
2439 |
|
|
basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
|
2440 |
|
|
basetype, ba_check, NULL);
|
2441 |
|
|
instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
|
2442 |
|
|
1);
|
2443 |
|
|
if (instance_ptr == error_mark_node)
|
2444 |
|
|
return error_mark_node;
|
2445 |
|
|
}
|
2446 |
|
|
/* ...and then the delta in the PMF. */
|
2447 |
|
|
instance_ptr = build2 (PLUS_EXPR, TREE_TYPE (instance_ptr),
|
2448 |
|
|
instance_ptr, delta);
|
2449 |
|
|
|
2450 |
|
|
/* Hand back the adjusted 'this' argument to our caller. */
|
2451 |
|
|
*instance_ptrptr = instance_ptr;
|
2452 |
|
|
|
2453 |
|
|
/* Next extract the vtable pointer from the object. */
|
2454 |
|
|
vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
|
2455 |
|
|
instance_ptr);
|
2456 |
|
|
vtbl = build_indirect_ref (vtbl, NULL);
|
2457 |
|
|
|
2458 |
|
|
/* Finally, extract the function pointer from the vtable. */
|
2459 |
|
|
e2 = fold_build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx);
|
2460 |
|
|
e2 = build_indirect_ref (e2, NULL);
|
2461 |
|
|
TREE_CONSTANT (e2) = 1;
|
2462 |
|
|
TREE_INVARIANT (e2) = 1;
|
2463 |
|
|
|
2464 |
|
|
/* When using function descriptors, the address of the
|
2465 |
|
|
vtable entry is treated as a function pointer. */
|
2466 |
|
|
if (TARGET_VTABLE_USES_DESCRIPTORS)
|
2467 |
|
|
e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
|
2468 |
|
|
build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1));
|
2469 |
|
|
|
2470 |
|
|
TREE_TYPE (e2) = TREE_TYPE (e3);
|
2471 |
|
|
e1 = build_conditional_expr (e1, e2, e3);
|
2472 |
|
|
|
2473 |
|
|
/* Make sure this doesn't get evaluated first inside one of the
|
2474 |
|
|
branches of the COND_EXPR. */
|
2475 |
|
|
if (instance_save_expr)
|
2476 |
|
|
e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
|
2477 |
|
|
instance_save_expr, e1);
|
2478 |
|
|
|
2479 |
|
|
function = e1;
|
2480 |
|
|
}
|
2481 |
|
|
return function;
|
2482 |
|
|
}
|
2483 |
|
|
|
2484 |
|
|
tree
|
2485 |
|
|
build_function_call (tree function, tree params)
|
2486 |
|
|
{
|
2487 |
|
|
tree fntype, fndecl;
|
2488 |
|
|
tree coerced_params;
|
2489 |
|
|
tree name = NULL_TREE;
|
2490 |
|
|
int is_method;
|
2491 |
|
|
tree original = function;
|
2492 |
|
|
|
2493 |
|
|
/* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
|
2494 |
|
|
expressions, like those used for ObjC messenger dispatches. */
|
2495 |
|
|
function = objc_rewrite_function_call (function, params);
|
2496 |
|
|
|
2497 |
|
|
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
|
2498 |
|
|
Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
|
2499 |
|
|
if (TREE_CODE (function) == NOP_EXPR
|
2500 |
|
|
&& TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
|
2501 |
|
|
function = TREE_OPERAND (function, 0);
|
2502 |
|
|
|
2503 |
|
|
if (TREE_CODE (function) == FUNCTION_DECL)
|
2504 |
|
|
{
|
2505 |
|
|
name = DECL_NAME (function);
|
2506 |
|
|
|
2507 |
|
|
mark_used (function);
|
2508 |
|
|
fndecl = function;
|
2509 |
|
|
|
2510 |
|
|
/* Convert anything with function type to a pointer-to-function. */
|
2511 |
|
|
if (pedantic && DECL_MAIN_P (function))
|
2512 |
|
|
pedwarn ("ISO C++ forbids calling %<::main%> from within program");
|
2513 |
|
|
|
2514 |
|
|
/* Differs from default_conversion by not setting TREE_ADDRESSABLE
|
2515 |
|
|
(because calling an inline function does not mean the function
|
2516 |
|
|
needs to be separately compiled). */
|
2517 |
|
|
|
2518 |
|
|
if (DECL_INLINE (function))
|
2519 |
|
|
function = inline_conversion (function);
|
2520 |
|
|
else
|
2521 |
|
|
function = build_addr_func (function);
|
2522 |
|
|
}
|
2523 |
|
|
else
|
2524 |
|
|
{
|
2525 |
|
|
fndecl = NULL_TREE;
|
2526 |
|
|
|
2527 |
|
|
function = build_addr_func (function);
|
2528 |
|
|
}
|
2529 |
|
|
|
2530 |
|
|
if (function == error_mark_node)
|
2531 |
|
|
return error_mark_node;
|
2532 |
|
|
|
2533 |
|
|
fntype = TREE_TYPE (function);
|
2534 |
|
|
|
2535 |
|
|
if (TYPE_PTRMEMFUNC_P (fntype))
|
2536 |
|
|
{
|
2537 |
|
|
error ("must use %<.*%> or %<->*%> to call pointer-to-member "
|
2538 |
|
|
"function in %<%E (...)%>",
|
2539 |
|
|
original);
|
2540 |
|
|
return error_mark_node;
|
2541 |
|
|
}
|
2542 |
|
|
|
2543 |
|
|
is_method = (TREE_CODE (fntype) == POINTER_TYPE
|
2544 |
|
|
&& TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
|
2545 |
|
|
|
2546 |
|
|
if (!((TREE_CODE (fntype) == POINTER_TYPE
|
2547 |
|
|
&& TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
|
2548 |
|
|
|| is_method
|
2549 |
|
|
|| TREE_CODE (function) == TEMPLATE_ID_EXPR))
|
2550 |
|
|
{
|
2551 |
|
|
error ("%qE cannot be used as a function", original);
|
2552 |
|
|
return error_mark_node;
|
2553 |
|
|
}
|
2554 |
|
|
|
2555 |
|
|
/* fntype now gets the type of function pointed to. */
|
2556 |
|
|
fntype = TREE_TYPE (fntype);
|
2557 |
|
|
|
2558 |
|
|
/* Convert the parameters to the types declared in the
|
2559 |
|
|
function prototype, or apply default promotions. */
|
2560 |
|
|
|
2561 |
|
|
coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
|
2562 |
|
|
params, fndecl, LOOKUP_NORMAL);
|
2563 |
|
|
if (coerced_params == error_mark_node)
|
2564 |
|
|
return error_mark_node;
|
2565 |
|
|
|
2566 |
|
|
/* Check for errors in format strings and inappropriately
|
2567 |
|
|
null parameters. */
|
2568 |
|
|
|
2569 |
|
|
check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params,
|
2570 |
|
|
TYPE_ARG_TYPES (fntype));
|
2571 |
|
|
|
2572 |
|
|
return build_cxx_call (function, coerced_params);
|
2573 |
|
|
}
|
2574 |
|
|
|
2575 |
|
|
/* Convert the actual parameter expressions in the list VALUES
|
2576 |
|
|
to the types in the list TYPELIST.
|
2577 |
|
|
If parmdecls is exhausted, or when an element has NULL as its type,
|
2578 |
|
|
perform the default conversions.
|
2579 |
|
|
|
2580 |
|
|
NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
|
2581 |
|
|
|
2582 |
|
|
This is also where warnings about wrong number of args are generated.
|
2583 |
|
|
|
2584 |
|
|
Return a list of expressions for the parameters as converted.
|
2585 |
|
|
|
2586 |
|
|
Both VALUES and the returned value are chains of TREE_LIST nodes
|
2587 |
|
|
with the elements of the list in the TREE_VALUE slots of those nodes.
|
2588 |
|
|
|
2589 |
|
|
In C++, unspecified trailing parameters can be filled in with their
|
2590 |
|
|
default arguments, if such were specified. Do so here. */
|
2591 |
|
|
|
2592 |
|
|
static tree
|
2593 |
|
|
convert_arguments (tree typelist, tree values, tree fndecl, int flags)
|
2594 |
|
|
{
|
2595 |
|
|
tree typetail, valtail;
|
2596 |
|
|
tree result = NULL_TREE;
|
2597 |
|
|
const char *called_thing = 0;
|
2598 |
|
|
int i = 0;
|
2599 |
|
|
|
2600 |
|
|
/* Argument passing is always copy-initialization. */
|
2601 |
|
|
flags |= LOOKUP_ONLYCONVERTING;
|
2602 |
|
|
|
2603 |
|
|
if (fndecl)
|
2604 |
|
|
{
|
2605 |
|
|
if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
|
2606 |
|
|
{
|
2607 |
|
|
if (DECL_NAME (fndecl) == NULL_TREE
|
2608 |
|
|
|| IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
|
2609 |
|
|
called_thing = "constructor";
|
2610 |
|
|
else
|
2611 |
|
|
called_thing = "member function";
|
2612 |
|
|
}
|
2613 |
|
|
else
|
2614 |
|
|
called_thing = "function";
|
2615 |
|
|
}
|
2616 |
|
|
|
2617 |
|
|
for (valtail = values, typetail = typelist;
|
2618 |
|
|
valtail;
|
2619 |
|
|
valtail = TREE_CHAIN (valtail), i++)
|
2620 |
|
|
{
|
2621 |
|
|
tree type = typetail ? TREE_VALUE (typetail) : 0;
|
2622 |
|
|
tree val = TREE_VALUE (valtail);
|
2623 |
|
|
|
2624 |
|
|
if (val == error_mark_node || type == error_mark_node)
|
2625 |
|
|
return error_mark_node;
|
2626 |
|
|
|
2627 |
|
|
if (type == void_type_node)
|
2628 |
|
|
{
|
2629 |
|
|
if (fndecl)
|
2630 |
|
|
{
|
2631 |
|
|
error ("too many arguments to %s %q+#D", called_thing, fndecl);
|
2632 |
|
|
error ("at this point in file");
|
2633 |
|
|
}
|
2634 |
|
|
else
|
2635 |
|
|
error ("too many arguments to function");
|
2636 |
|
|
/* In case anybody wants to know if this argument
|
2637 |
|
|
list is valid. */
|
2638 |
|
|
if (result)
|
2639 |
|
|
TREE_TYPE (tree_last (result)) = error_mark_node;
|
2640 |
|
|
break;
|
2641 |
|
|
}
|
2642 |
|
|
|
2643 |
|
|
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
|
2644 |
|
|
Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
|
2645 |
|
|
if (TREE_CODE (val) == NOP_EXPR
|
2646 |
|
|
&& TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
|
2647 |
|
|
&& (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
|
2648 |
|
|
val = TREE_OPERAND (val, 0);
|
2649 |
|
|
|
2650 |
|
|
if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
|
2651 |
|
|
{
|
2652 |
|
|
if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
|
2653 |
|
|
|| TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
|
2654 |
|
|
|| TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
|
2655 |
|
|
val = decay_conversion (val);
|
2656 |
|
|
}
|
2657 |
|
|
|
2658 |
|
|
if (val == error_mark_node)
|
2659 |
|
|
return error_mark_node;
|
2660 |
|
|
|
2661 |
|
|
if (type != 0)
|
2662 |
|
|
{
|
2663 |
|
|
/* Formal parm type is specified by a function prototype. */
|
2664 |
|
|
tree parmval;
|
2665 |
|
|
|
2666 |
|
|
if (!COMPLETE_TYPE_P (complete_type (type)))
|
2667 |
|
|
{
|
2668 |
|
|
if (fndecl)
|
2669 |
|
|
error ("parameter %P of %qD has incomplete type %qT",
|
2670 |
|
|
i, fndecl, type);
|
2671 |
|
|
else
|
2672 |
|
|
error ("parameter %P has incomplete type %qT", i, type);
|
2673 |
|
|
parmval = error_mark_node;
|
2674 |
|
|
}
|
2675 |
|
|
else
|
2676 |
|
|
{
|
2677 |
|
|
parmval = convert_for_initialization
|
2678 |
|
|
(NULL_TREE, type, val, flags,
|
2679 |
|
|
"argument passing", fndecl, i);
|
2680 |
|
|
parmval = convert_for_arg_passing (type, parmval);
|
2681 |
|
|
}
|
2682 |
|
|
|
2683 |
|
|
if (parmval == error_mark_node)
|
2684 |
|
|
return error_mark_node;
|
2685 |
|
|
|
2686 |
|
|
result = tree_cons (NULL_TREE, parmval, result);
|
2687 |
|
|
}
|
2688 |
|
|
else
|
2689 |
|
|
{
|
2690 |
|
|
if (fndecl && DECL_BUILT_IN (fndecl)
|
2691 |
|
|
&& DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
|
2692 |
|
|
/* Don't do ellipsis conversion for __built_in_constant_p
|
2693 |
|
|
as this will result in spurious warnings for non-POD
|
2694 |
|
|
types. */
|
2695 |
|
|
val = require_complete_type (val);
|
2696 |
|
|
else
|
2697 |
|
|
val = convert_arg_to_ellipsis (val);
|
2698 |
|
|
|
2699 |
|
|
result = tree_cons (NULL_TREE, val, result);
|
2700 |
|
|
}
|
2701 |
|
|
|
2702 |
|
|
if (typetail)
|
2703 |
|
|
typetail = TREE_CHAIN (typetail);
|
2704 |
|
|
}
|
2705 |
|
|
|
2706 |
|
|
if (typetail != 0 && typetail != void_list_node)
|
2707 |
|
|
{
|
2708 |
|
|
/* See if there are default arguments that can be used. */
|
2709 |
|
|
if (TREE_PURPOSE (typetail)
|
2710 |
|
|
&& TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
|
2711 |
|
|
{
|
2712 |
|
|
for (; typetail != void_list_node; ++i)
|
2713 |
|
|
{
|
2714 |
|
|
tree parmval
|
2715 |
|
|
= convert_default_arg (TREE_VALUE (typetail),
|
2716 |
|
|
TREE_PURPOSE (typetail),
|
2717 |
|
|
fndecl, i);
|
2718 |
|
|
|
2719 |
|
|
if (parmval == error_mark_node)
|
2720 |
|
|
return error_mark_node;
|
2721 |
|
|
|
2722 |
|
|
result = tree_cons (0, parmval, result);
|
2723 |
|
|
typetail = TREE_CHAIN (typetail);
|
2724 |
|
|
/* ends with `...'. */
|
2725 |
|
|
if (typetail == NULL_TREE)
|
2726 |
|
|
break;
|
2727 |
|
|
}
|
2728 |
|
|
}
|
2729 |
|
|
else
|
2730 |
|
|
{
|
2731 |
|
|
if (fndecl)
|
2732 |
|
|
{
|
2733 |
|
|
error ("too few arguments to %s %q+#D", called_thing, fndecl);
|
2734 |
|
|
error ("at this point in file");
|
2735 |
|
|
}
|
2736 |
|
|
else
|
2737 |
|
|
error ("too few arguments to function");
|
2738 |
|
|
return error_mark_node;
|
2739 |
|
|
}
|
2740 |
|
|
}
|
2741 |
|
|
|
2742 |
|
|
return nreverse (result);
|
2743 |
|
|
}
|
2744 |
|
|
|
2745 |
|
|
/* Build a binary-operation expression, after performing default
|
2746 |
|
|
conversions on the operands. CODE is the kind of expression to build. */
|
2747 |
|
|
|
2748 |
|
|
tree
|
2749 |
|
|
build_x_binary_op (enum tree_code code, tree arg1, tree arg2,
|
2750 |
|
|
bool *overloaded_p)
|
2751 |
|
|
{
|
2752 |
|
|
tree orig_arg1;
|
2753 |
|
|
tree orig_arg2;
|
2754 |
|
|
tree expr;
|
2755 |
|
|
|
2756 |
|
|
orig_arg1 = arg1;
|
2757 |
|
|
orig_arg2 = arg2;
|
2758 |
|
|
|
2759 |
|
|
if (processing_template_decl)
|
2760 |
|
|
{
|
2761 |
|
|
if (type_dependent_expression_p (arg1)
|
2762 |
|
|
|| type_dependent_expression_p (arg2))
|
2763 |
|
|
return build_min_nt (code, arg1, arg2);
|
2764 |
|
|
arg1 = build_non_dependent_expr (arg1);
|
2765 |
|
|
arg2 = build_non_dependent_expr (arg2);
|
2766 |
|
|
}
|
2767 |
|
|
|
2768 |
|
|
if (code == DOTSTAR_EXPR)
|
2769 |
|
|
expr = build_m_component_ref (arg1, arg2);
|
2770 |
|
|
else
|
2771 |
|
|
expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
|
2772 |
|
|
overloaded_p);
|
2773 |
|
|
|
2774 |
|
|
if (processing_template_decl && expr != error_mark_node)
|
2775 |
|
|
return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
|
2776 |
|
|
|
2777 |
|
|
return expr;
|
2778 |
|
|
}
|
2779 |
|
|
|
2780 |
|
|
/* Build a binary-operation expression without default conversions.
|
2781 |
|
|
CODE is the kind of expression to build.
|
2782 |
|
|
This function differs from `build' in several ways:
|
2783 |
|
|
the data type of the result is computed and recorded in it,
|
2784 |
|
|
warnings are generated if arg data types are invalid,
|
2785 |
|
|
special handling for addition and subtraction of pointers is known,
|
2786 |
|
|
and some optimization is done (operations on narrow ints
|
2787 |
|
|
are done in the narrower type when that gives the same result).
|
2788 |
|
|
Constant folding is also done before the result is returned.
|
2789 |
|
|
|
2790 |
|
|
Note that the operands will never have enumeral types
|
2791 |
|
|
because either they have just had the default conversions performed
|
2792 |
|
|
or they have both just been converted to some other type in which
|
2793 |
|
|
the arithmetic is to be done.
|
2794 |
|
|
|
2795 |
|
|
C++: must do special pointer arithmetic when implementing
|
2796 |
|
|
multiple inheritance, and deal with pointer to member functions. */
|
2797 |
|
|
|
2798 |
|
|
tree
|
2799 |
|
|
build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
|
2800 |
|
|
int convert_p ATTRIBUTE_UNUSED)
|
2801 |
|
|
{
|
2802 |
|
|
tree op0, op1;
|
2803 |
|
|
enum tree_code code0, code1;
|
2804 |
|
|
tree type0, type1;
|
2805 |
|
|
const char *invalid_op_diag;
|
2806 |
|
|
|
2807 |
|
|
/* Expression code to give to the expression when it is built.
|
2808 |
|
|
Normally this is CODE, which is what the caller asked for,
|
2809 |
|
|
but in some special cases we change it. */
|
2810 |
|
|
enum tree_code resultcode = code;
|
2811 |
|
|
|
2812 |
|
|
/* Data type in which the computation is to be performed.
|
2813 |
|
|
In the simplest cases this is the common type of the arguments. */
|
2814 |
|
|
tree result_type = NULL;
|
2815 |
|
|
|
2816 |
|
|
/* Nonzero means operands have already been type-converted
|
2817 |
|
|
in whatever way is necessary.
|
2818 |
|
|
Zero means they need to be converted to RESULT_TYPE. */
|
2819 |
|
|
int converted = 0;
|
2820 |
|
|
|
2821 |
|
|
/* Nonzero means create the expression with this type, rather than
|
2822 |
|
|
RESULT_TYPE. */
|
2823 |
|
|
tree build_type = 0;
|
2824 |
|
|
|
2825 |
|
|
/* Nonzero means after finally constructing the expression
|
2826 |
|
|
convert it to this type. */
|
2827 |
|
|
tree final_type = 0;
|
2828 |
|
|
|
2829 |
|
|
tree result;
|
2830 |
|
|
|
2831 |
|
|
/* Nonzero if this is an operation like MIN or MAX which can
|
2832 |
|
|
safely be computed in short if both args are promoted shorts.
|
2833 |
|
|
Also implies COMMON.
|
2834 |
|
|
-1 indicates a bitwise operation; this makes a difference
|
2835 |
|
|
in the exact conditions for when it is safe to do the operation
|
2836 |
|
|
in a narrower mode. */
|
2837 |
|
|
int shorten = 0;
|
2838 |
|
|
|
2839 |
|
|
/* Nonzero if this is a comparison operation;
|
2840 |
|
|
if both args are promoted shorts, compare the original shorts.
|
2841 |
|
|
Also implies COMMON. */
|
2842 |
|
|
int short_compare = 0;
|
2843 |
|
|
|
2844 |
|
|
/* Nonzero if this is a right-shift operation, which can be computed on the
|
2845 |
|
|
original short and then promoted if the operand is a promoted short. */
|
2846 |
|
|
int short_shift = 0;
|
2847 |
|
|
|
2848 |
|
|
/* Nonzero means set RESULT_TYPE to the common type of the args. */
|
2849 |
|
|
int common = 0;
|
2850 |
|
|
|
2851 |
|
|
/* True if both operands have arithmetic type. */
|
2852 |
|
|
bool arithmetic_types_p;
|
2853 |
|
|
|
2854 |
|
|
/* Apply default conversions. */
|
2855 |
|
|
op0 = orig_op0;
|
2856 |
|
|
op1 = orig_op1;
|
2857 |
|
|
|
2858 |
|
|
if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
|
2859 |
|
|
|| code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
|
2860 |
|
|
|| code == TRUTH_XOR_EXPR)
|
2861 |
|
|
{
|
2862 |
|
|
if (!really_overloaded_fn (op0))
|
2863 |
|
|
op0 = decay_conversion (op0);
|
2864 |
|
|
if (!really_overloaded_fn (op1))
|
2865 |
|
|
op1 = decay_conversion (op1);
|
2866 |
|
|
}
|
2867 |
|
|
else
|
2868 |
|
|
{
|
2869 |
|
|
if (!really_overloaded_fn (op0))
|
2870 |
|
|
op0 = default_conversion (op0);
|
2871 |
|
|
if (!really_overloaded_fn (op1))
|
2872 |
|
|
op1 = default_conversion (op1);
|
2873 |
|
|
}
|
2874 |
|
|
|
2875 |
|
|
/* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
|
2876 |
|
|
STRIP_TYPE_NOPS (op0);
|
2877 |
|
|
STRIP_TYPE_NOPS (op1);
|
2878 |
|
|
|
2879 |
|
|
/* DTRT if one side is an overloaded function, but complain about it. */
|
2880 |
|
|
if (type_unknown_p (op0))
|
2881 |
|
|
{
|
2882 |
|
|
tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
|
2883 |
|
|
if (t != error_mark_node)
|
2884 |
|
|
{
|
2885 |
|
|
pedwarn ("assuming cast to type %qT from overloaded function",
|
2886 |
|
|
TREE_TYPE (t));
|
2887 |
|
|
op0 = t;
|
2888 |
|
|
}
|
2889 |
|
|
}
|
2890 |
|
|
if (type_unknown_p (op1))
|
2891 |
|
|
{
|
2892 |
|
|
tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
|
2893 |
|
|
if (t != error_mark_node)
|
2894 |
|
|
{
|
2895 |
|
|
pedwarn ("assuming cast to type %qT from overloaded function",
|
2896 |
|
|
TREE_TYPE (t));
|
2897 |
|
|
op1 = t;
|
2898 |
|
|
}
|
2899 |
|
|
}
|
2900 |
|
|
|
2901 |
|
|
type0 = TREE_TYPE (op0);
|
2902 |
|
|
type1 = TREE_TYPE (op1);
|
2903 |
|
|
|
2904 |
|
|
/* The expression codes of the data types of the arguments tell us
|
2905 |
|
|
whether the arguments are integers, floating, pointers, etc. */
|
2906 |
|
|
code0 = TREE_CODE (type0);
|
2907 |
|
|
code1 = TREE_CODE (type1);
|
2908 |
|
|
|
2909 |
|
|
/* If an error was already reported for one of the arguments,
|
2910 |
|
|
avoid reporting another error. */
|
2911 |
|
|
|
2912 |
|
|
if (code0 == ERROR_MARK || code1 == ERROR_MARK)
|
2913 |
|
|
return error_mark_node;
|
2914 |
|
|
|
2915 |
|
|
if ((invalid_op_diag
|
2916 |
|
|
= targetm.invalid_binary_op (code, type0, type1)))
|
2917 |
|
|
{
|
2918 |
|
|
error (invalid_op_diag);
|
2919 |
|
|
return error_mark_node;
|
2920 |
|
|
}
|
2921 |
|
|
|
2922 |
|
|
switch (code)
|
2923 |
|
|
{
|
2924 |
|
|
case PLUS_EXPR:
|
2925 |
|
|
/* Handle the pointer + int case. */
|
2926 |
|
|
if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
|
2927 |
|
|
return cp_pointer_int_sum (PLUS_EXPR, op0, op1);
|
2928 |
|
|
else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
|
2929 |
|
|
return cp_pointer_int_sum (PLUS_EXPR, op1, op0);
|
2930 |
|
|
else
|
2931 |
|
|
common = 1;
|
2932 |
|
|
break;
|
2933 |
|
|
|
2934 |
|
|
case MINUS_EXPR:
|
2935 |
|
|
/* Subtraction of two similar pointers.
|
2936 |
|
|
We must subtract them as integers, then divide by object size. */
|
2937 |
|
|
if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
|
2938 |
|
|
&& same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
|
2939 |
|
|
TREE_TYPE (type1)))
|
2940 |
|
|
return pointer_diff (op0, op1, common_type (type0, type1));
|
2941 |
|
|
/* Handle pointer minus int. Just like pointer plus int. */
|
2942 |
|
|
else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
|
2943 |
|
|
return cp_pointer_int_sum (MINUS_EXPR, op0, op1);
|
2944 |
|
|
else
|
2945 |
|
|
common = 1;
|
2946 |
|
|
break;
|
2947 |
|
|
|
2948 |
|
|
case MULT_EXPR:
|
2949 |
|
|
common = 1;
|
2950 |
|
|
break;
|
2951 |
|
|
|
2952 |
|
|
case TRUNC_DIV_EXPR:
|
2953 |
|
|
case CEIL_DIV_EXPR:
|
2954 |
|
|
case FLOOR_DIV_EXPR:
|
2955 |
|
|
case ROUND_DIV_EXPR:
|
2956 |
|
|
case EXACT_DIV_EXPR:
|
2957 |
|
|
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
|
2958 |
|
|
|| code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
|
2959 |
|
|
&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE
|
2960 |
|
|
|| code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
|
2961 |
|
|
{
|
2962 |
|
|
if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
|
2963 |
|
|
warning (0, "division by zero in %<%E / 0%>", op0);
|
2964 |
|
|
else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
|
2965 |
|
|
warning (0, "division by zero in %<%E / 0.%>", op0);
|
2966 |
|
|
|
2967 |
|
|
if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
|
2968 |
|
|
code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
|
2969 |
|
|
if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
|
2970 |
|
|
code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
|
2971 |
|
|
|
2972 |
|
|
if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
|
2973 |
|
|
resultcode = RDIV_EXPR;
|
2974 |
|
|
else
|
2975 |
|
|
/* When dividing two signed integers, we have to promote to int.
|
2976 |
|
|
unless we divide by a constant != -1. Note that default
|
2977 |
|
|
conversion will have been performed on the operands at this
|
2978 |
|
|
point, so we have to dig out the original type to find out if
|
2979 |
|
|
it was unsigned. */
|
2980 |
|
|
shorten = ((TREE_CODE (op0) == NOP_EXPR
|
2981 |
|
|
&& TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
|
2982 |
|
|
|| (TREE_CODE (op1) == INTEGER_CST
|
2983 |
|
|
&& ! integer_all_onesp (op1)));
|
2984 |
|
|
|
2985 |
|
|
common = 1;
|
2986 |
|
|
}
|
2987 |
|
|
break;
|
2988 |
|
|
|
2989 |
|
|
case BIT_AND_EXPR:
|
2990 |
|
|
case BIT_IOR_EXPR:
|
2991 |
|
|
case BIT_XOR_EXPR:
|
2992 |
|
|
if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
|
2993 |
|
|
|| (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE))
|
2994 |
|
|
shorten = -1;
|
2995 |
|
|
break;
|
2996 |
|
|
|
2997 |
|
|
case TRUNC_MOD_EXPR:
|
2998 |
|
|
case FLOOR_MOD_EXPR:
|
2999 |
|
|
if (code1 == INTEGER_TYPE && integer_zerop (op1))
|
3000 |
|
|
warning (0, "division by zero in %<%E %% 0%>", op0);
|
3001 |
|
|
else if (code1 == REAL_TYPE && real_zerop (op1))
|
3002 |
|
|
warning (0, "division by zero in %<%E %% 0.%>", op0);
|
3003 |
|
|
|
3004 |
|
|
if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
|
3005 |
|
|
{
|
3006 |
|
|
/* Although it would be tempting to shorten always here, that loses
|
3007 |
|
|
on some targets, since the modulo instruction is undefined if the
|
3008 |
|
|
quotient can't be represented in the computation mode. We shorten
|
3009 |
|
|
only if unsigned or if dividing by something we know != -1. */
|
3010 |
|
|
shorten = ((TREE_CODE (op0) == NOP_EXPR
|
3011 |
|
|
&& TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
|
3012 |
|
|
|| (TREE_CODE (op1) == INTEGER_CST
|
3013 |
|
|
&& ! integer_all_onesp (op1)));
|
3014 |
|
|
common = 1;
|
3015 |
|
|
}
|
3016 |
|
|
break;
|
3017 |
|
|
|
3018 |
|
|
case TRUTH_ANDIF_EXPR:
|
3019 |
|
|
case TRUTH_ORIF_EXPR:
|
3020 |
|
|
case TRUTH_AND_EXPR:
|
3021 |
|
|
case TRUTH_OR_EXPR:
|
3022 |
|
|
result_type = boolean_type_node;
|
3023 |
|
|
break;
|
3024 |
|
|
|
3025 |
|
|
/* Shift operations: result has same type as first operand;
|
3026 |
|
|
always convert second operand to int.
|
3027 |
|
|
Also set SHORT_SHIFT if shifting rightward. */
|
3028 |
|
|
|
3029 |
|
|
case RSHIFT_EXPR:
|
3030 |
|
|
if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
|
3031 |
|
|
{
|
3032 |
|
|
result_type = type0;
|
3033 |
|
|
if (TREE_CODE (op1) == INTEGER_CST)
|
3034 |
|
|
{
|
3035 |
|
|
if (tree_int_cst_lt (op1, integer_zero_node))
|
3036 |
|
|
warning (0, "right shift count is negative");
|
3037 |
|
|
else
|
3038 |
|
|
{
|
3039 |
|
|
if (! integer_zerop (op1))
|
3040 |
|
|
short_shift = 1;
|
3041 |
|
|
if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
|
3042 |
|
|
warning (0, "right shift count >= width of type");
|
3043 |
|
|
}
|
3044 |
|
|
}
|
3045 |
|
|
/* Convert the shift-count to an integer, regardless of
|
3046 |
|
|
size of value being shifted. */
|
3047 |
|
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
|
3048 |
|
|
op1 = cp_convert (integer_type_node, op1);
|
3049 |
|
|
/* Avoid converting op1 to result_type later. */
|
3050 |
|
|
converted = 1;
|
3051 |
|
|
}
|
3052 |
|
|
break;
|
3053 |
|
|
|
3054 |
|
|
case LSHIFT_EXPR:
|
3055 |
|
|
if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
|
3056 |
|
|
{
|
3057 |
|
|
result_type = type0;
|
3058 |
|
|
if (TREE_CODE (op1) == INTEGER_CST)
|
3059 |
|
|
{
|
3060 |
|
|
if (tree_int_cst_lt (op1, integer_zero_node))
|
3061 |
|
|
warning (0, "left shift count is negative");
|
3062 |
|
|
else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
|
3063 |
|
|
warning (0, "left shift count >= width of type");
|
3064 |
|
|
}
|
3065 |
|
|
/* Convert the shift-count to an integer, regardless of
|
3066 |
|
|
size of value being shifted. */
|
3067 |
|
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
|
3068 |
|
|
op1 = cp_convert (integer_type_node, op1);
|
3069 |
|
|
/* Avoid converting op1 to result_type later. */
|
3070 |
|
|
converted = 1;
|
3071 |
|
|
}
|
3072 |
|
|
break;
|
3073 |
|
|
|
3074 |
|
|
case RROTATE_EXPR:
|
3075 |
|
|
case LROTATE_EXPR:
|
3076 |
|
|
if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
|
3077 |
|
|
{
|
3078 |
|
|
result_type = type0;
|
3079 |
|
|
if (TREE_CODE (op1) == INTEGER_CST)
|
3080 |
|
|
{
|
3081 |
|
|
if (tree_int_cst_lt (op1, integer_zero_node))
|
3082 |
|
|
warning (0, "%s rotate count is negative",
|
3083 |
|
|
(code == LROTATE_EXPR) ? "left" : "right");
|
3084 |
|
|
else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
|
3085 |
|
|
warning (0, "%s rotate count >= width of type",
|
3086 |
|
|
(code == LROTATE_EXPR) ? "left" : "right");
|
3087 |
|
|
}
|
3088 |
|
|
/* Convert the shift-count to an integer, regardless of
|
3089 |
|
|
size of value being shifted. */
|
3090 |
|
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
|
3091 |
|
|
op1 = cp_convert (integer_type_node, op1);
|
3092 |
|
|
}
|
3093 |
|
|
break;
|
3094 |
|
|
|
3095 |
|
|
case EQ_EXPR:
|
3096 |
|
|
case NE_EXPR:
|
3097 |
|
|
if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
|
3098 |
|
|
warning (0, "comparing floating point with == or != is unsafe");
|
3099 |
|
|
|
3100 |
|
|
build_type = boolean_type_node;
|
3101 |
|
|
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
|
3102 |
|
|
|| code0 == COMPLEX_TYPE)
|
3103 |
|
|
&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE
|
3104 |
|
|
|| code1 == COMPLEX_TYPE))
|
3105 |
|
|
short_compare = 1;
|
3106 |
|
|
else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
|
3107 |
|
|
|| (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
|
3108 |
|
|
result_type = composite_pointer_type (type0, type1, op0, op1,
|
3109 |
|
|
"comparison");
|
3110 |
|
|
else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
|
3111 |
|
|
&& null_ptr_cst_p (op1))
|
3112 |
|
|
result_type = type0;
|
3113 |
|
|
else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
|
3114 |
|
|
&& null_ptr_cst_p (op0))
|
3115 |
|
|
result_type = type1;
|
3116 |
|
|
else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
|
3117 |
|
|
{
|
3118 |
|
|
result_type = type0;
|
3119 |
|
|
error ("ISO C++ forbids comparison between pointer and integer");
|
3120 |
|
|
}
|
3121 |
|
|
else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
|
3122 |
|
|
{
|
3123 |
|
|
result_type = type1;
|
3124 |
|
|
error ("ISO C++ forbids comparison between pointer and integer");
|
3125 |
|
|
}
|
3126 |
|
|
else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
|
3127 |
|
|
{
|
3128 |
|
|
op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
|
3129 |
|
|
op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
|
3130 |
|
|
result_type = TREE_TYPE (op0);
|
3131 |
|
|
}
|
3132 |
|
|
else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
|
3133 |
|
|
return cp_build_binary_op (code, op1, op0);
|
3134 |
|
|
else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
|
3135 |
|
|
&& same_type_p (type0, type1))
|
3136 |
|
|
{
|
3137 |
|
|
/* E will be the final comparison. */
|
3138 |
|
|
tree e;
|
3139 |
|
|
/* E1 and E2 are for scratch. */
|
3140 |
|
|
tree e1;
|
3141 |
|
|
tree e2;
|
3142 |
|
|
tree pfn0;
|
3143 |
|
|
tree pfn1;
|
3144 |
|
|
tree delta0;
|
3145 |
|
|
tree delta1;
|
3146 |
|
|
|
3147 |
|
|
if (TREE_SIDE_EFFECTS (op0))
|
3148 |
|
|
op0 = save_expr (op0);
|
3149 |
|
|
if (TREE_SIDE_EFFECTS (op1))
|
3150 |
|
|
op1 = save_expr (op1);
|
3151 |
|
|
|
3152 |
|
|
/* We generate:
|
3153 |
|
|
|
3154 |
|
|
(op0.pfn == op1.pfn
|
3155 |
|
|
&& (!op0.pfn || op0.delta == op1.delta))
|
3156 |
|
|
|
3157 |
|
|
The reason for the `!op0.pfn' bit is that a NULL
|
3158 |
|
|
pointer-to-member is any member with a zero PFN; the
|
3159 |
|
|
DELTA field is unspecified. */
|
3160 |
|
|
pfn0 = pfn_from_ptrmemfunc (op0);
|
3161 |
|
|
pfn1 = pfn_from_ptrmemfunc (op1);
|
3162 |
|
|
delta0 = build_ptrmemfunc_access_expr (op0,
|
3163 |
|
|
delta_identifier);
|
3164 |
|
|
delta1 = build_ptrmemfunc_access_expr (op1,
|
3165 |
|
|
delta_identifier);
|
3166 |
|
|
e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
|
3167 |
|
|
e2 = cp_build_binary_op (EQ_EXPR,
|
3168 |
|
|
pfn0,
|
3169 |
|
|
cp_convert (TREE_TYPE (pfn0),
|
3170 |
|
|
integer_zero_node));
|
3171 |
|
|
e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
|
3172 |
|
|
e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
|
3173 |
|
|
e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
|
3174 |
|
|
if (code == EQ_EXPR)
|
3175 |
|
|
return e;
|
3176 |
|
|
return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
|
3177 |
|
|
}
|
3178 |
|
|
else
|
3179 |
|
|
{
|
3180 |
|
|
gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
|
3181 |
|
|
|| !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
|
3182 |
|
|
type1));
|
3183 |
|
|
gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
|
3184 |
|
|
|| !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
|
3185 |
|
|
type0));
|
3186 |
|
|
}
|
3187 |
|
|
|
3188 |
|
|
break;
|
3189 |
|
|
|
3190 |
|
|
case MAX_EXPR:
|
3191 |
|
|
case MIN_EXPR:
|
3192 |
|
|
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
|
3193 |
|
|
&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
|
3194 |
|
|
shorten = 1;
|
3195 |
|
|
else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
|
3196 |
|
|
result_type = composite_pointer_type (type0, type1, op0, op1,
|
3197 |
|
|
"comparison");
|
3198 |
|
|
break;
|
3199 |
|
|
|
3200 |
|
|
case LE_EXPR:
|
3201 |
|
|
case GE_EXPR:
|
3202 |
|
|
case LT_EXPR:
|
3203 |
|
|
case GT_EXPR:
|
3204 |
|
|
build_type = boolean_type_node;
|
3205 |
|
|
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
|
3206 |
|
|
&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
|
3207 |
|
|
short_compare = 1;
|
3208 |
|
|
else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
|
3209 |
|
|
result_type = composite_pointer_type (type0, type1, op0, op1,
|
3210 |
|
|
"comparison");
|
3211 |
|
|
else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
|
3212 |
|
|
&& integer_zerop (op1))
|
3213 |
|
|
result_type = type0;
|
3214 |
|
|
else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
|
3215 |
|
|
&& integer_zerop (op0))
|
3216 |
|
|
result_type = type1;
|
3217 |
|
|
else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
|
3218 |
|
|
{
|
3219 |
|
|
result_type = type0;
|
3220 |
|
|
pedwarn ("ISO C++ forbids comparison between pointer and integer");
|
3221 |
|
|
}
|
3222 |
|
|
else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
|
3223 |
|
|
{
|
3224 |
|
|
result_type = type1;
|
3225 |
|
|
pedwarn ("ISO C++ forbids comparison between pointer and integer");
|
3226 |
|
|
}
|
3227 |
|
|
break;
|
3228 |
|
|
|
3229 |
|
|
case UNORDERED_EXPR:
|
3230 |
|
|
case ORDERED_EXPR:
|
3231 |
|
|
case UNLT_EXPR:
|
3232 |
|
|
case UNLE_EXPR:
|
3233 |
|
|
case UNGT_EXPR:
|
3234 |
|
|
case UNGE_EXPR:
|
3235 |
|
|
case UNEQ_EXPR:
|
3236 |
|
|
build_type = integer_type_node;
|
3237 |
|
|
if (code0 != REAL_TYPE || code1 != REAL_TYPE)
|
3238 |
|
|
{
|
3239 |
|
|
error ("unordered comparison on non-floating point argument");
|
3240 |
|
|
return error_mark_node;
|
3241 |
|
|
}
|
3242 |
|
|
common = 1;
|
3243 |
|
|
break;
|
3244 |
|
|
|
3245 |
|
|
default:
|
3246 |
|
|
break;
|
3247 |
|
|
}
|
3248 |
|
|
|
3249 |
|
|
if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
|
3250 |
|
|
&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE
|
3251 |
|
|
|| code1 == COMPLEX_TYPE)))
|
3252 |
|
|
arithmetic_types_p = 1;
|
3253 |
|
|
else
|
3254 |
|
|
{
|
3255 |
|
|
arithmetic_types_p = 0;
|
3256 |
|
|
/* Vector arithmetic is only allowed when both sides are vectors. */
|
3257 |
|
|
if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
|
3258 |
|
|
{
|
3259 |
|
|
if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
|
3260 |
|
|
|| !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
|
3261 |
|
|
TREE_TYPE (type1)))
|
3262 |
|
|
{
|
3263 |
|
|
binary_op_error (code);
|
3264 |
|
|
return error_mark_node;
|
3265 |
|
|
}
|
3266 |
|
|
arithmetic_types_p = 1;
|
3267 |
|
|
}
|
3268 |
|
|
}
|
3269 |
|
|
/* Determine the RESULT_TYPE, if it is not already known. */
|
3270 |
|
|
if (!result_type
|
3271 |
|
|
&& arithmetic_types_p
|
3272 |
|
|
&& (shorten || common || short_compare))
|
3273 |
|
|
result_type = common_type (type0, type1);
|
3274 |
|
|
|
3275 |
|
|
if (!result_type)
|
3276 |
|
|
{
|
3277 |
|
|
error ("invalid operands of types %qT and %qT to binary %qO",
|
3278 |
|
|
TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
|
3279 |
|
|
return error_mark_node;
|
3280 |
|
|
}
|
3281 |
|
|
|
3282 |
|
|
/* If we're in a template, the only thing we need to know is the
|
3283 |
|
|
RESULT_TYPE. */
|
3284 |
|
|
if (processing_template_decl)
|
3285 |
|
|
return build2 (resultcode,
|
3286 |
|
|
build_type ? build_type : result_type,
|
3287 |
|
|
op0, op1);
|
3288 |
|
|
|
3289 |
|
|
if (arithmetic_types_p)
|
3290 |
|
|
{
|
3291 |
|
|
int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
|
3292 |
|
|
|
3293 |
|
|
/* For certain operations (which identify themselves by shorten != 0)
|
3294 |
|
|
if both args were extended from the same smaller type,
|
3295 |
|
|
do the arithmetic in that type and then extend.
|
3296 |
|
|
|
3297 |
|
|
shorten !=0 and !=1 indicates a bitwise operation.
|
3298 |
|
|
For them, this optimization is safe only if
|
3299 |
|
|
both args are zero-extended or both are sign-extended.
|
3300 |
|
|
Otherwise, we might change the result.
|
3301 |
|
|
Eg, (short)-1 | (unsigned short)-1 is (int)-1
|
3302 |
|
|
but calculated in (unsigned short) it would be (unsigned short)-1. */
|
3303 |
|
|
|
3304 |
|
|
if (shorten && none_complex)
|
3305 |
|
|
{
|
3306 |
|
|
int unsigned0, unsigned1;
|
3307 |
|
|
tree arg0 = get_narrower (op0, &unsigned0);
|
3308 |
|
|
tree arg1 = get_narrower (op1, &unsigned1);
|
3309 |
|
|
/* UNS is 1 if the operation to be done is an unsigned one. */
|
3310 |
|
|
int uns = TYPE_UNSIGNED (result_type);
|
3311 |
|
|
tree type;
|
3312 |
|
|
|
3313 |
|
|
final_type = result_type;
|
3314 |
|
|
|
3315 |
|
|
/* Handle the case that OP0 does not *contain* a conversion
|
3316 |
|
|
but it *requires* conversion to FINAL_TYPE. */
|
3317 |
|
|
|
3318 |
|
|
if (op0 == arg0 && TREE_TYPE (op0) != final_type)
|
3319 |
|
|
unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
|
3320 |
|
|
if (op1 == arg1 && TREE_TYPE (op1) != final_type)
|
3321 |
|
|
unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
|
3322 |
|
|
|
3323 |
|
|
/* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
|
3324 |
|
|
|
3325 |
|
|
/* For bitwise operations, signedness of nominal type
|
3326 |
|
|
does not matter. Consider only how operands were extended. */
|
3327 |
|
|
if (shorten == -1)
|
3328 |
|
|
uns = unsigned0;
|
3329 |
|
|
|
3330 |
|
|
/* Note that in all three cases below we refrain from optimizing
|
3331 |
|
|
an unsigned operation on sign-extended args.
|
3332 |
|
|
That would not be valid. */
|
3333 |
|
|
|
3334 |
|
|
/* Both args variable: if both extended in same way
|
3335 |
|
|
from same width, do it in that width.
|
3336 |
|
|
Do it unsigned if args were zero-extended. */
|
3337 |
|
|
if ((TYPE_PRECISION (TREE_TYPE (arg0))
|
3338 |
|
|
< TYPE_PRECISION (result_type))
|
3339 |
|
|
&& (TYPE_PRECISION (TREE_TYPE (arg1))
|
3340 |
|
|
== TYPE_PRECISION (TREE_TYPE (arg0)))
|
3341 |
|
|
&& unsigned0 == unsigned1
|
3342 |
|
|
&& (unsigned0 || !uns))
|
3343 |
|
|
result_type = c_common_signed_or_unsigned_type
|
3344 |
|
|
(unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
|
3345 |
|
|
else if (TREE_CODE (arg0) == INTEGER_CST
|
3346 |
|
|
&& (unsigned1 || !uns)
|
3347 |
|
|
&& (TYPE_PRECISION (TREE_TYPE (arg1))
|
3348 |
|
|
< TYPE_PRECISION (result_type))
|
3349 |
|
|
&& (type = c_common_signed_or_unsigned_type
|
3350 |
|
|
(unsigned1, TREE_TYPE (arg1)),
|
3351 |
|
|
int_fits_type_p (arg0, type)))
|
3352 |
|
|
result_type = type;
|
3353 |
|
|
else if (TREE_CODE (arg1) == INTEGER_CST
|
3354 |
|
|
&& (unsigned0 || !uns)
|
3355 |
|
|
&& (TYPE_PRECISION (TREE_TYPE (arg0))
|
3356 |
|
|
< TYPE_PRECISION (result_type))
|
3357 |
|
|
&& (type = c_common_signed_or_unsigned_type
|
3358 |
|
|
(unsigned0, TREE_TYPE (arg0)),
|
3359 |
|
|
int_fits_type_p (arg1, type)))
|
3360 |
|
|
result_type = type;
|
3361 |
|
|
}
|
3362 |
|
|
|
3363 |
|
|
/* Shifts can be shortened if shifting right. */
|
3364 |
|
|
|
3365 |
|
|
if (short_shift)
|
3366 |
|
|
{
|
3367 |
|
|
int unsigned_arg;
|
3368 |
|
|
tree arg0 = get_narrower (op0, &unsigned_arg);
|
3369 |
|
|
|
3370 |
|
|
final_type = result_type;
|
3371 |
|
|
|
3372 |
|
|
if (arg0 == op0 && final_type == TREE_TYPE (op0))
|
3373 |
|
|
unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
|
3374 |
|
|
|
3375 |
|
|
if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
|
3376 |
|
|
/* We can shorten only if the shift count is less than the
|
3377 |
|
|
number of bits in the smaller type size. */
|
3378 |
|
|
&& compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
|
3379 |
|
|
/* If arg is sign-extended and then unsigned-shifted,
|
3380 |
|
|
we can simulate this with a signed shift in arg's type
|
3381 |
|
|
only if the extended result is at least twice as wide
|
3382 |
|
|
as the arg. Otherwise, the shift could use up all the
|
3383 |
|
|
ones made by sign-extension and bring in zeros.
|
3384 |
|
|
We can't optimize that case at all, but in most machines
|
3385 |
|
|
it never happens because available widths are 2**N. */
|
3386 |
|
|
&& (!TYPE_UNSIGNED (final_type)
|
3387 |
|
|
|| unsigned_arg
|
3388 |
|
|
|| (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
|
3389 |
|
|
<= TYPE_PRECISION (result_type))))
|
3390 |
|
|
{
|
3391 |
|
|
/* Do an unsigned shift if the operand was zero-extended. */
|
3392 |
|
|
result_type
|
3393 |
|
|
= c_common_signed_or_unsigned_type (unsigned_arg,
|
3394 |
|
|
TREE_TYPE (arg0));
|
3395 |
|
|
/* Convert value-to-be-shifted to that type. */
|
3396 |
|
|
if (TREE_TYPE (op0) != result_type)
|
3397 |
|
|
op0 = cp_convert (result_type, op0);
|
3398 |
|
|
converted = 1;
|
3399 |
|
|
}
|
3400 |
|
|
}
|
3401 |
|
|
|
3402 |
|
|
/* Comparison operations are shortened too but differently.
|
3403 |
|
|
They identify themselves by setting short_compare = 1. */
|
3404 |
|
|
|
3405 |
|
|
if (short_compare)
|
3406 |
|
|
{
|
3407 |
|
|
/* Don't write &op0, etc., because that would prevent op0
|
3408 |
|
|
from being kept in a register.
|
3409 |
|
|
Instead, make copies of the our local variables and
|
3410 |
|
|
pass the copies by reference, then copy them back afterward. */
|
3411 |
|
|
tree xop0 = op0, xop1 = op1, xresult_type = result_type;
|
3412 |
|
|
enum tree_code xresultcode = resultcode;
|
3413 |
|
|
tree val
|
3414 |
|
|
= shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
|
3415 |
|
|
if (val != 0)
|
3416 |
|
|
return cp_convert (boolean_type_node, val);
|
3417 |
|
|
op0 = xop0, op1 = xop1;
|
3418 |
|
|
converted = 1;
|
3419 |
|
|
resultcode = xresultcode;
|
3420 |
|
|
}
|
3421 |
|
|
|
3422 |
|
|
if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
|
3423 |
|
|
&& warn_sign_compare
|
3424 |
|
|
/* Do not warn until the template is instantiated; we cannot
|
3425 |
|
|
bound the ranges of the arguments until that point. */
|
3426 |
|
|
&& !processing_template_decl)
|
3427 |
|
|
{
|
3428 |
|
|
int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
|
3429 |
|
|
int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
|
3430 |
|
|
|
3431 |
|
|
int unsignedp0, unsignedp1;
|
3432 |
|
|
tree primop0 = get_narrower (op0, &unsignedp0);
|
3433 |
|
|
tree primop1 = get_narrower (op1, &unsignedp1);
|
3434 |
|
|
|
3435 |
|
|
/* Check for comparison of different enum types. */
|
3436 |
|
|
if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
|
3437 |
|
|
&& TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
|
3438 |
|
|
&& TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
|
3439 |
|
|
!= TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
|
3440 |
|
|
{
|
3441 |
|
|
warning (0, "comparison between types %q#T and %q#T",
|
3442 |
|
|
TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
|
3443 |
|
|
}
|
3444 |
|
|
|
3445 |
|
|
/* Give warnings for comparisons between signed and unsigned
|
3446 |
|
|
quantities that may fail. */
|
3447 |
|
|
/* Do the checking based on the original operand trees, so that
|
3448 |
|
|
casts will be considered, but default promotions won't be. */
|
3449 |
|
|
|
3450 |
|
|
/* Do not warn if the comparison is being done in a signed type,
|
3451 |
|
|
since the signed type will only be chosen if it can represent
|
3452 |
|
|
all the values of the unsigned type. */
|
3453 |
|
|
if (!TYPE_UNSIGNED (result_type))
|
3454 |
|
|
/* OK */;
|
3455 |
|
|
/* Do not warn if both operands are unsigned. */
|
3456 |
|
|
else if (op0_signed == op1_signed)
|
3457 |
|
|
/* OK */;
|
3458 |
|
|
/* Do not warn if the signed quantity is an unsuffixed
|
3459 |
|
|
integer literal (or some static constant expression
|
3460 |
|
|
involving such literals or a conditional expression
|
3461 |
|
|
involving such literals) and it is non-negative. */
|
3462 |
|
|
else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
|
3463 |
|
|
|| (op1_signed && tree_expr_nonnegative_p (orig_op1)))
|
3464 |
|
|
/* OK */;
|
3465 |
|
|
/* Do not warn if the comparison is an equality operation,
|
3466 |
|
|
the unsigned quantity is an integral constant and it does
|
3467 |
|
|
not use the most significant bit of result_type. */
|
3468 |
|
|
else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
|
3469 |
|
|
&& ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
|
3470 |
|
|
&& int_fits_type_p (orig_op1, c_common_signed_type
|
3471 |
|
|
(result_type)))
|
3472 |
|
|
|| (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
|
3473 |
|
|
&& int_fits_type_p (orig_op0, c_common_signed_type
|
3474 |
|
|
(result_type)))))
|
3475 |
|
|
/* OK */;
|
3476 |
|
|
else
|
3477 |
|
|
warning (0, "comparison between signed and unsigned integer expressions");
|
3478 |
|
|
|
3479 |
|
|
/* Warn if two unsigned values are being compared in a size
|
3480 |
|
|
larger than their original size, and one (and only one) is the
|
3481 |
|
|
result of a `~' operator. This comparison will always fail.
|
3482 |
|
|
|
3483 |
|
|
Also warn if one operand is a constant, and the constant does not
|
3484 |
|
|
have all bits set that are set in the ~ operand when it is
|
3485 |
|
|
extended. */
|
3486 |
|
|
|
3487 |
|
|
if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
|
3488 |
|
|
^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
|
3489 |
|
|
{
|
3490 |
|
|
if (TREE_CODE (primop0) == BIT_NOT_EXPR)
|
3491 |
|
|
primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
|
3492 |
|
|
if (TREE_CODE (primop1) == BIT_NOT_EXPR)
|
3493 |
|
|
primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
|
3494 |
|
|
|
3495 |
|
|
if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
|
3496 |
|
|
{
|
3497 |
|
|
tree primop;
|
3498 |
|
|
HOST_WIDE_INT constant, mask;
|
3499 |
|
|
int unsignedp;
|
3500 |
|
|
unsigned int bits;
|
3501 |
|
|
|
3502 |
|
|
if (host_integerp (primop0, 0))
|
3503 |
|
|
{
|
3504 |
|
|
primop = primop1;
|
3505 |
|
|
unsignedp = unsignedp1;
|
3506 |
|
|
constant = tree_low_cst (primop0, 0);
|
3507 |
|
|
}
|
3508 |
|
|
else
|
3509 |
|
|
{
|
3510 |
|
|
primop = primop0;
|
3511 |
|
|
unsignedp = unsignedp0;
|
3512 |
|
|
constant = tree_low_cst (primop1, 0);
|
3513 |
|
|
}
|
3514 |
|
|
|
3515 |
|
|
bits = TYPE_PRECISION (TREE_TYPE (primop));
|
3516 |
|
|
if (bits < TYPE_PRECISION (result_type)
|
3517 |
|
|
&& bits < HOST_BITS_PER_LONG && unsignedp)
|
3518 |
|
|
{
|
3519 |
|
|
mask = (~ (HOST_WIDE_INT) 0) << bits;
|
3520 |
|
|
if ((mask & constant) != mask)
|
3521 |
|
|
warning (0, "comparison of promoted ~unsigned with constant");
|
3522 |
|
|
}
|
3523 |
|
|
}
|
3524 |
|
|
else if (unsignedp0 && unsignedp1
|
3525 |
|
|
&& (TYPE_PRECISION (TREE_TYPE (primop0))
|
3526 |
|
|
< TYPE_PRECISION (result_type))
|
3527 |
|
|
&& (TYPE_PRECISION (TREE_TYPE (primop1))
|
3528 |
|
|
< TYPE_PRECISION (result_type)))
|
3529 |
|
|
warning (0, "comparison of promoted ~unsigned with unsigned");
|
3530 |
|
|
}
|
3531 |
|
|
}
|
3532 |
|
|
}
|
3533 |
|
|
|
3534 |
|
|
/* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
|
3535 |
|
|
Then the expression will be built.
|
3536 |
|
|
It will be given type FINAL_TYPE if that is nonzero;
|
3537 |
|
|
otherwise, it will be given type RESULT_TYPE. */
|
3538 |
|
|
|
3539 |
|
|
/* Issue warnings about peculiar, but valid, uses of NULL. */
|
3540 |
|
|
if (/* It's reasonable to use pointer values as operands of &&
|
3541 |
|
|
and ||, so NULL is no exception. */
|
3542 |
|
|
!(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
|
3543 |
|
|
&& (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
|
3544 |
|
|
(orig_op0 == null_node
|
3545 |
|
|
&& TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
|
3546 |
|
|
/* Or vice versa. */
|
3547 |
|
|
|| (orig_op1 == null_node
|
3548 |
|
|
&& TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
|
3549 |
|
|
/* Or, both are NULL and the operation was not a comparison. */
|
3550 |
|
|
|| (orig_op0 == null_node && orig_op1 == null_node
|
3551 |
|
|
&& code != EQ_EXPR && code != NE_EXPR)))
|
3552 |
|
|
/* Some sort of arithmetic operation involving NULL was
|
3553 |
|
|
performed. Note that pointer-difference and pointer-addition
|
3554 |
|
|
have already been handled above, and so we don't end up here in
|
3555 |
|
|
that case. */
|
3556 |
|
|
warning (0, "NULL used in arithmetic");
|
3557 |
|
|
|
3558 |
|
|
if (! converted)
|
3559 |
|
|
{
|
3560 |
|
|
if (TREE_TYPE (op0) != result_type)
|
3561 |
|
|
op0 = cp_convert (result_type, op0);
|
3562 |
|
|
if (TREE_TYPE (op1) != result_type)
|
3563 |
|
|
op1 = cp_convert (result_type, op1);
|
3564 |
|
|
|
3565 |
|
|
if (op0 == error_mark_node || op1 == error_mark_node)
|
3566 |
|
|
return error_mark_node;
|
3567 |
|
|
}
|
3568 |
|
|
|
3569 |
|
|
if (build_type == NULL_TREE)
|
3570 |
|
|
build_type = result_type;
|
3571 |
|
|
|
3572 |
|
|
result = build2 (resultcode, build_type, op0, op1);
|
3573 |
|
|
result = fold_if_not_in_template (result);
|
3574 |
|
|
if (final_type != 0)
|
3575 |
|
|
result = cp_convert (final_type, result);
|
3576 |
|
|
return result;
|
3577 |
|
|
}
|
3578 |
|
|
|
3579 |
|
|
/* Return a tree for the sum or difference (RESULTCODE says which)
|
3580 |
|
|
of pointer PTROP and integer INTOP. */
|
3581 |
|
|
|
3582 |
|
|
static tree
|
3583 |
|
|
cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
|
3584 |
|
|
{
|
3585 |
|
|
tree res_type = TREE_TYPE (ptrop);
|
3586 |
|
|
|
3587 |
|
|
/* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
|
3588 |
|
|
in certain circumstance (when it's valid to do so). So we need
|
3589 |
|
|
to make sure it's complete. We don't need to check here, if we
|
3590 |
|
|
can actually complete it at all, as those checks will be done in
|
3591 |
|
|
pointer_int_sum() anyway. */
|
3592 |
|
|
complete_type (TREE_TYPE (res_type));
|
3593 |
|
|
|
3594 |
|
|
return pointer_int_sum (resultcode, ptrop,
|
3595 |
|
|
fold_if_not_in_template (intop));
|
3596 |
|
|
}
|
3597 |
|
|
|
3598 |
|
|
/* Return a tree for the difference of pointers OP0 and OP1.
|
3599 |
|
|
The resulting tree has type int. */
|
3600 |
|
|
|
3601 |
|
|
static tree
|
3602 |
|
|
pointer_diff (tree op0, tree op1, tree ptrtype)
|
3603 |
|
|
{
|
3604 |
|
|
tree result;
|
3605 |
|
|
tree restype = ptrdiff_type_node;
|
3606 |
|
|
tree target_type = TREE_TYPE (ptrtype);
|
3607 |
|
|
|
3608 |
|
|
if (!complete_type_or_else (target_type, NULL_TREE))
|
3609 |
|
|
return error_mark_node;
|
3610 |
|
|
|
3611 |
|
|
if (pedantic || warn_pointer_arith)
|
3612 |
|
|
{
|
3613 |
|
|
if (TREE_CODE (target_type) == VOID_TYPE)
|
3614 |
|
|
pedwarn ("ISO C++ forbids using pointer of type %<void *%> in subtraction");
|
3615 |
|
|
if (TREE_CODE (target_type) == FUNCTION_TYPE)
|
3616 |
|
|
pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
|
3617 |
|
|
if (TREE_CODE (target_type) == METHOD_TYPE)
|
3618 |
|
|
pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
|
3619 |
|
|
}
|
3620 |
|
|
|
3621 |
|
|
/* First do the subtraction as integers;
|
3622 |
|
|
then drop through to build the divide operator. */
|
3623 |
|
|
|
3624 |
|
|
op0 = cp_build_binary_op (MINUS_EXPR,
|
3625 |
|
|
cp_convert (restype, op0),
|
3626 |
|
|
cp_convert (restype, op1));
|
3627 |
|
|
|
3628 |
|
|
/* This generates an error if op1 is a pointer to an incomplete type. */
|
3629 |
|
|
if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
|
3630 |
|
|
error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
|
3631 |
|
|
|
3632 |
|
|
op1 = (TYPE_PTROB_P (ptrtype)
|
3633 |
|
|
? size_in_bytes (target_type)
|
3634 |
|
|
: integer_one_node);
|
3635 |
|
|
|
3636 |
|
|
/* Do the division. */
|
3637 |
|
|
|
3638 |
|
|
result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
|
3639 |
|
|
return fold_if_not_in_template (result);
|
3640 |
|
|
}
|
3641 |
|
|
|
3642 |
|
|
/* Construct and perhaps optimize a tree representation
|
3643 |
|
|
for a unary operation. CODE, a tree_code, specifies the operation
|
3644 |
|
|
and XARG is the operand. */
|
3645 |
|
|
|
3646 |
|
|
tree
|
3647 |
|
|
build_x_unary_op (enum tree_code code, tree xarg)
|
3648 |
|
|
{
|
3649 |
|
|
tree orig_expr = xarg;
|
3650 |
|
|
tree exp;
|
3651 |
|
|
int ptrmem = 0;
|
3652 |
|
|
|
3653 |
|
|
if (processing_template_decl)
|
3654 |
|
|
{
|
3655 |
|
|
if (type_dependent_expression_p (xarg))
|
3656 |
|
|
return build_min_nt (code, xarg, NULL_TREE);
|
3657 |
|
|
|
3658 |
|
|
xarg = build_non_dependent_expr (xarg);
|
3659 |
|
|
}
|
3660 |
|
|
|
3661 |
|
|
exp = NULL_TREE;
|
3662 |
|
|
|
3663 |
|
|
/* [expr.unary.op] says:
|
3664 |
|
|
|
3665 |
|
|
The address of an object of incomplete type can be taken.
|
3666 |
|
|
|
3667 |
|
|
(And is just the ordinary address operator, not an overloaded
|
3668 |
|
|
"operator &".) However, if the type is a template
|
3669 |
|
|
specialization, we must complete the type at this point so that
|
3670 |
|
|
an overloaded "operator &" will be available if required. */
|
3671 |
|
|
if (code == ADDR_EXPR
|
3672 |
|
|
&& TREE_CODE (xarg) != TEMPLATE_ID_EXPR
|
3673 |
|
|
&& ((CLASS_TYPE_P (TREE_TYPE (xarg))
|
3674 |
|
|
&& !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
|
3675 |
|
|
|| (TREE_CODE (xarg) == OFFSET_REF)))
|
3676 |
|
|
/* Don't look for a function. */;
|
3677 |
|
|
else
|
3678 |
|
|
exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
|
3679 |
|
|
/*overloaded_p=*/NULL);
|
3680 |
|
|
if (!exp && code == ADDR_EXPR)
|
3681 |
|
|
{
|
3682 |
|
|
/* A pointer to member-function can be formed only by saying
|
3683 |
|
|
&X::mf. */
|
3684 |
|
|
if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
|
3685 |
|
|
&& (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
|
3686 |
|
|
{
|
3687 |
|
|
if (TREE_CODE (xarg) != OFFSET_REF
|
3688 |
|
|
|| !TYPE_P (TREE_OPERAND (xarg, 0)))
|
3689 |
|
|
{
|
3690 |
|
|
error ("invalid use of %qE to form a pointer-to-member-function",
|
3691 |
|
|
xarg);
|
3692 |
|
|
if (TREE_CODE (xarg) != OFFSET_REF)
|
3693 |
|
|
inform (" a qualified-id is required");
|
3694 |
|
|
return error_mark_node;
|
3695 |
|
|
}
|
3696 |
|
|
else
|
3697 |
|
|
{
|
3698 |
|
|
error ("parenthesis around %qE cannot be used to form a"
|
3699 |
|
|
" pointer-to-member-function",
|
3700 |
|
|
xarg);
|
3701 |
|
|
PTRMEM_OK_P (xarg) = 1;
|
3702 |
|
|
}
|
3703 |
|
|
}
|
3704 |
|
|
|
3705 |
|
|
if (TREE_CODE (xarg) == OFFSET_REF)
|
3706 |
|
|
{
|
3707 |
|
|
ptrmem = PTRMEM_OK_P (xarg);
|
3708 |
|
|
|
3709 |
|
|
if (!ptrmem && !flag_ms_extensions
|
3710 |
|
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
|
3711 |
|
|
{
|
3712 |
|
|
/* A single non-static member, make sure we don't allow a
|
3713 |
|
|
pointer-to-member. */
|
3714 |
|
|
xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
|
3715 |
|
|
TREE_OPERAND (xarg, 0),
|
3716 |
|
|
ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
|
3717 |
|
|
PTRMEM_OK_P (xarg) = ptrmem;
|
3718 |
|
|
}
|
3719 |
|
|
}
|
3720 |
|
|
else if (TREE_CODE (xarg) == TARGET_EXPR)
|
3721 |
|
|
warning (0, "taking address of temporary");
|
3722 |
|
|
exp = build_unary_op (ADDR_EXPR, xarg, 0);
|
3723 |
|
|
}
|
3724 |
|
|
|
3725 |
|
|
if (processing_template_decl && exp != error_mark_node)
|
3726 |
|
|
exp = build_min_non_dep (code, exp, orig_expr,
|
3727 |
|
|
/*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
|
3728 |
|
|
if (TREE_CODE (exp) == ADDR_EXPR)
|
3729 |
|
|
PTRMEM_OK_P (exp) = ptrmem;
|
3730 |
|
|
return exp;
|
3731 |
|
|
}
|
3732 |
|
|
|
3733 |
|
|
/* Like c_common_truthvalue_conversion, but handle pointer-to-member
|
3734 |
|
|
constants, where a null value is represented by an INTEGER_CST of
|
3735 |
|
|
-1. */
|
3736 |
|
|
|
3737 |
|
|
tree
|
3738 |
|
|
cp_truthvalue_conversion (tree expr)
|
3739 |
|
|
{
|
3740 |
|
|
tree type = TREE_TYPE (expr);
|
3741 |
|
|
if (TYPE_PTRMEM_P (type))
|
3742 |
|
|
return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
|
3743 |
|
|
else
|
3744 |
|
|
return c_common_truthvalue_conversion (expr);
|
3745 |
|
|
}
|
3746 |
|
|
|
3747 |
|
|
/* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
|
3748 |
|
|
|
3749 |
|
|
tree
|
3750 |
|
|
condition_conversion (tree expr)
|
3751 |
|
|
{
|
3752 |
|
|
tree t;
|
3753 |
|
|
if (processing_template_decl)
|
3754 |
|
|
return expr;
|
3755 |
|
|
t = perform_implicit_conversion (boolean_type_node, expr);
|
3756 |
|
|
t = fold_build_cleanup_point_expr (boolean_type_node, t);
|
3757 |
|
|
return t;
|
3758 |
|
|
}
|
3759 |
|
|
|
3760 |
|
|
/* Return an ADDR_EXPR giving the address of T. This function
|
3761 |
|
|
attempts no optimizations or simplifications; it is a low-level
|
3762 |
|
|
primitive. */
|
3763 |
|
|
|
3764 |
|
|
tree
|
3765 |
|
|
build_address (tree t)
|
3766 |
|
|
{
|
3767 |
|
|
tree addr;
|
3768 |
|
|
|
3769 |
|
|
if (error_operand_p (t) || !cxx_mark_addressable (t))
|
3770 |
|
|
return error_mark_node;
|
3771 |
|
|
|
3772 |
|
|
addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
|
3773 |
|
|
|
3774 |
|
|
return addr;
|
3775 |
|
|
}
|
3776 |
|
|
|
3777 |
|
|
/* Return a NOP_EXPR converting EXPR to TYPE. */
|
3778 |
|
|
|
3779 |
|
|
tree
|
3780 |
|
|
build_nop (tree type, tree expr)
|
3781 |
|
|
{
|
3782 |
|
|
if (type == error_mark_node || error_operand_p (expr))
|
3783 |
|
|
return expr;
|
3784 |
|
|
return build1 (NOP_EXPR, type, expr);
|
3785 |
|
|
}
|
3786 |
|
|
|
3787 |
|
|
/* C++: Must handle pointers to members.
|
3788 |
|
|
|
3789 |
|
|
Perhaps type instantiation should be extended to handle conversion
|
3790 |
|
|
from aggregates to types we don't yet know we want? (Or are those
|
3791 |
|
|
cases typically errors which should be reported?)
|
3792 |
|
|
|
3793 |
|
|
NOCONVERT nonzero suppresses the default promotions
|
3794 |
|
|
(such as from short to int). */
|
3795 |
|
|
|
3796 |
|
|
tree
|
3797 |
|
|
build_unary_op (enum tree_code code, tree xarg, int noconvert)
|
3798 |
|
|
{
|
3799 |
|
|
/* No default_conversion here. It causes trouble for ADDR_EXPR. */
|
3800 |
|
|
tree arg = xarg;
|
3801 |
|
|
tree argtype = 0;
|
3802 |
|
|
const char *errstring = NULL;
|
3803 |
|
|
tree val;
|
3804 |
|
|
const char *invalid_op_diag;
|
3805 |
|
|
|
3806 |
|
|
if (arg == error_mark_node)
|
3807 |
|
|
return error_mark_node;
|
3808 |
|
|
|
3809 |
|
|
if ((invalid_op_diag
|
3810 |
|
|
= targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR
|
3811 |
|
|
? CONVERT_EXPR
|
3812 |
|
|
: code),
|
3813 |
|
|
TREE_TYPE (xarg))))
|
3814 |
|
|
{
|
3815 |
|
|
error (invalid_op_diag);
|
3816 |
|
|
return error_mark_node;
|
3817 |
|
|
}
|
3818 |
|
|
|
3819 |
|
|
switch (code)
|
3820 |
|
|
{
|
3821 |
|
|
case UNARY_PLUS_EXPR:
|
3822 |
|
|
case NEGATE_EXPR:
|
3823 |
|
|
{
|
3824 |
|
|
int flags = WANT_ARITH | WANT_ENUM;
|
3825 |
|
|
/* Unary plus (but not unary minus) is allowed on pointers. */
|
3826 |
|
|
if (code == UNARY_PLUS_EXPR)
|
3827 |
|
|
flags |= WANT_POINTER;
|
3828 |
|
|
arg = build_expr_type_conversion (flags, arg, true);
|
3829 |
|
|
if (!arg)
|
3830 |
|
|
errstring = (code == NEGATE_EXPR
|
3831 |
|
|
? "wrong type argument to unary minus"
|
3832 |
|
|
: "wrong type argument to unary plus");
|
3833 |
|
|
else
|
3834 |
|
|
{
|
3835 |
|
|
if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
|
3836 |
|
|
arg = perform_integral_promotions (arg);
|
3837 |
|
|
|
3838 |
|
|
/* Make sure the result is not an lvalue: a unary plus or minus
|
3839 |
|
|
expression is always a rvalue. */
|
3840 |
|
|
arg = rvalue (arg);
|
3841 |
|
|
}
|
3842 |
|
|
}
|
3843 |
|
|
break;
|
3844 |
|
|
|
3845 |
|
|
case BIT_NOT_EXPR:
|
3846 |
|
|
if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
|
3847 |
|
|
{
|
3848 |
|
|
code = CONJ_EXPR;
|
3849 |
|
|
if (!noconvert)
|
3850 |
|
|
arg = default_conversion (arg);
|
3851 |
|
|
}
|
3852 |
|
|
else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
|
3853 |
|
|
arg, true)))
|
3854 |
|
|
errstring = "wrong type argument to bit-complement";
|
3855 |
|
|
else if (!noconvert)
|
3856 |
|
|
arg = perform_integral_promotions (arg);
|
3857 |
|
|
break;
|
3858 |
|
|
|
3859 |
|
|
case ABS_EXPR:
|
3860 |
|
|
if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
|
3861 |
|
|
errstring = "wrong type argument to abs";
|
3862 |
|
|
else if (!noconvert)
|
3863 |
|
|
arg = default_conversion (arg);
|
3864 |
|
|
break;
|
3865 |
|
|
|
3866 |
|
|
case CONJ_EXPR:
|
3867 |
|
|
/* Conjugating a real value is a no-op, but allow it anyway. */
|
3868 |
|
|
if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
|
3869 |
|
|
errstring = "wrong type argument to conjugation";
|
3870 |
|
|
else if (!noconvert)
|
3871 |
|
|
arg = default_conversion (arg);
|
3872 |
|
|
break;
|
3873 |
|
|
|
3874 |
|
|
case TRUTH_NOT_EXPR:
|
3875 |
|
|
arg = perform_implicit_conversion (boolean_type_node, arg);
|
3876 |
|
|
val = invert_truthvalue (arg);
|
3877 |
|
|
if (arg != error_mark_node)
|
3878 |
|
|
return val;
|
3879 |
|
|
errstring = "in argument to unary !";
|
3880 |
|
|
break;
|
3881 |
|
|
|
3882 |
|
|
case NOP_EXPR:
|
3883 |
|
|
break;
|
3884 |
|
|
|
3885 |
|
|
case REALPART_EXPR:
|
3886 |
|
|
if (TREE_CODE (arg) == COMPLEX_CST)
|
3887 |
|
|
return TREE_REALPART (arg);
|
3888 |
|
|
else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
|
3889 |
|
|
{
|
3890 |
|
|
arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
|
3891 |
|
|
return fold_if_not_in_template (arg);
|
3892 |
|
|
}
|
3893 |
|
|
else
|
3894 |
|
|
return arg;
|
3895 |
|
|
|
3896 |
|
|
case IMAGPART_EXPR:
|
3897 |
|
|
if (TREE_CODE (arg) == COMPLEX_CST)
|
3898 |
|
|
return TREE_IMAGPART (arg);
|
3899 |
|
|
else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
|
3900 |
|
|
{
|
3901 |
|
|
arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
|
3902 |
|
|
return fold_if_not_in_template (arg);
|
3903 |
|
|
}
|
3904 |
|
|
else
|
3905 |
|
|
return cp_convert (TREE_TYPE (arg), integer_zero_node);
|
3906 |
|
|
|
3907 |
|
|
case PREINCREMENT_EXPR:
|
3908 |
|
|
case POSTINCREMENT_EXPR:
|
3909 |
|
|
case PREDECREMENT_EXPR:
|
3910 |
|
|
case POSTDECREMENT_EXPR:
|
3911 |
|
|
/* Handle complex lvalues (when permitted)
|
3912 |
|
|
by reduction to simpler cases. */
|
3913 |
|
|
|
3914 |
|
|
val = unary_complex_lvalue (code, arg);
|
3915 |
|
|
if (val != 0)
|
3916 |
|
|
return val;
|
3917 |
|
|
|
3918 |
|
|
/* Increment or decrement the real part of the value,
|
3919 |
|
|
and don't change the imaginary part. */
|
3920 |
|
|
if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
|
3921 |
|
|
{
|
3922 |
|
|
tree real, imag;
|
3923 |
|
|
|
3924 |
|
|
arg = stabilize_reference (arg);
|
3925 |
|
|
real = build_unary_op (REALPART_EXPR, arg, 1);
|
3926 |
|
|
imag = build_unary_op (IMAGPART_EXPR, arg, 1);
|
3927 |
|
|
return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
|
3928 |
|
|
build_unary_op (code, real, 1), imag);
|
3929 |
|
|
}
|
3930 |
|
|
|
3931 |
|
|
/* Report invalid types. */
|
3932 |
|
|
|
3933 |
|
|
if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
|
3934 |
|
|
arg, true)))
|
3935 |
|
|
{
|
3936 |
|
|
if (code == PREINCREMENT_EXPR)
|
3937 |
|
|
errstring ="no pre-increment operator for type";
|
3938 |
|
|
else if (code == POSTINCREMENT_EXPR)
|
3939 |
|
|
errstring ="no post-increment operator for type";
|
3940 |
|
|
else if (code == PREDECREMENT_EXPR)
|
3941 |
|
|
errstring ="no pre-decrement operator for type";
|
3942 |
|
|
else
|
3943 |
|
|
errstring ="no post-decrement operator for type";
|
3944 |
|
|
break;
|
3945 |
|
|
}
|
3946 |
|
|
|
3947 |
|
|
/* Report something read-only. */
|
3948 |
|
|
|
3949 |
|
|
if (CP_TYPE_CONST_P (TREE_TYPE (arg))
|
3950 |
|
|
|| TREE_READONLY (arg))
|
3951 |
|
|
readonly_error (arg, ((code == PREINCREMENT_EXPR
|
3952 |
|
|
|| code == POSTINCREMENT_EXPR)
|
3953 |
|
|
? "increment" : "decrement"),
|
3954 |
|
|
0);
|
3955 |
|
|
|
3956 |
|
|
{
|
3957 |
|
|
tree inc;
|
3958 |
|
|
tree result_type = TREE_TYPE (arg);
|
3959 |
|
|
|
3960 |
|
|
arg = get_unwidened (arg, 0);
|
3961 |
|
|
argtype = TREE_TYPE (arg);
|
3962 |
|
|
|
3963 |
|
|
/* ARM $5.2.5 last annotation says this should be forbidden. */
|
3964 |
|
|
if (TREE_CODE (argtype) == ENUMERAL_TYPE)
|
3965 |
|
|
pedwarn ("ISO C++ forbids %sing an enum",
|
3966 |
|
|
(code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
|
3967 |
|
|
? "increment" : "decrement");
|
3968 |
|
|
|
3969 |
|
|
/* Compute the increment. */
|
3970 |
|
|
|
3971 |
|
|
if (TREE_CODE (argtype) == POINTER_TYPE)
|
3972 |
|
|
{
|
3973 |
|
|
tree type = complete_type (TREE_TYPE (argtype));
|
3974 |
|
|
|
3975 |
|
|
if (!COMPLETE_OR_VOID_TYPE_P (type))
|
3976 |
|
|
error ("cannot %s a pointer to incomplete type %qT",
|
3977 |
|
|
((code == PREINCREMENT_EXPR
|
3978 |
|
|
|| code == POSTINCREMENT_EXPR)
|
3979 |
|
|
? "increment" : "decrement"), TREE_TYPE (argtype));
|
3980 |
|
|
else if ((pedantic || warn_pointer_arith)
|
3981 |
|
|
&& !TYPE_PTROB_P (argtype))
|
3982 |
|
|
pedwarn ("ISO C++ forbids %sing a pointer of type %qT",
|
3983 |
|
|
((code == PREINCREMENT_EXPR
|
3984 |
|
|
|| code == POSTINCREMENT_EXPR)
|
3985 |
|
|
? "increment" : "decrement"), argtype);
|
3986 |
|
|
inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
|
3987 |
|
|
}
|
3988 |
|
|
else
|
3989 |
|
|
inc = integer_one_node;
|
3990 |
|
|
|
3991 |
|
|
inc = cp_convert (argtype, inc);
|
3992 |
|
|
|
3993 |
|
|
/* Handle incrementing a cast-expression. */
|
3994 |
|
|
|
3995 |
|
|
switch (TREE_CODE (arg))
|
3996 |
|
|
{
|
3997 |
|
|
case NOP_EXPR:
|
3998 |
|
|
case CONVERT_EXPR:
|
3999 |
|
|
case FLOAT_EXPR:
|
4000 |
|
|
case FIX_TRUNC_EXPR:
|
4001 |
|
|
case FIX_FLOOR_EXPR:
|
4002 |
|
|
case FIX_ROUND_EXPR:
|
4003 |
|
|
case FIX_CEIL_EXPR:
|
4004 |
|
|
{
|
4005 |
|
|
tree incremented, modify, value, compound;
|
4006 |
|
|
if (! lvalue_p (arg) && pedantic)
|
4007 |
|
|
pedwarn ("cast to non-reference type used as lvalue");
|
4008 |
|
|
arg = stabilize_reference (arg);
|
4009 |
|
|
if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
|
4010 |
|
|
value = arg;
|
4011 |
|
|
else
|
4012 |
|
|
value = save_expr (arg);
|
4013 |
|
|
incremented = build2 (((code == PREINCREMENT_EXPR
|
4014 |
|
|
|| code == POSTINCREMENT_EXPR)
|
4015 |
|
|
? PLUS_EXPR : MINUS_EXPR),
|
4016 |
|
|
argtype, value, inc);
|
4017 |
|
|
|
4018 |
|
|
modify = build_modify_expr (arg, NOP_EXPR, incremented);
|
4019 |
|
|
compound = build2 (COMPOUND_EXPR, TREE_TYPE (arg),
|
4020 |
|
|
modify, value);
|
4021 |
|
|
|
4022 |
|
|
/* Eliminate warning about unused result of + or -. */
|
4023 |
|
|
TREE_NO_WARNING (compound) = 1;
|
4024 |
|
|
return compound;
|
4025 |
|
|
}
|
4026 |
|
|
|
4027 |
|
|
default:
|
4028 |
|
|
break;
|
4029 |
|
|
}
|
4030 |
|
|
|
4031 |
|
|
/* Complain about anything else that is not a true lvalue. */
|
4032 |
|
|
if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
|
4033 |
|
|
|| code == POSTINCREMENT_EXPR)
|
4034 |
|
|
? lv_increment : lv_decrement)))
|
4035 |
|
|
return error_mark_node;
|
4036 |
|
|
|
4037 |
|
|
/* Forbid using -- on `bool'. */
|
4038 |
|
|
if (TREE_TYPE (arg) == boolean_type_node)
|
4039 |
|
|
{
|
4040 |
|
|
if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
|
4041 |
|
|
{
|
4042 |
|
|
error ("invalid use of %<--%> on bool variable %qD", arg);
|
4043 |
|
|
return error_mark_node;
|
4044 |
|
|
}
|
4045 |
|
|
val = boolean_increment (code, arg);
|
4046 |
|
|
}
|
4047 |
|
|
else
|
4048 |
|
|
val = build2 (code, TREE_TYPE (arg), arg, inc);
|
4049 |
|
|
|
4050 |
|
|
TREE_SIDE_EFFECTS (val) = 1;
|
4051 |
|
|
return cp_convert (result_type, val);
|
4052 |
|
|
}
|
4053 |
|
|
|
4054 |
|
|
case ADDR_EXPR:
|
4055 |
|
|
/* Note that this operation never does default_conversion
|
4056 |
|
|
regardless of NOCONVERT. */
|
4057 |
|
|
|
4058 |
|
|
argtype = lvalue_type (arg);
|
4059 |
|
|
|
4060 |
|
|
if (TREE_CODE (arg) == OFFSET_REF)
|
4061 |
|
|
goto offset_ref;
|
4062 |
|
|
|
4063 |
|
|
if (TREE_CODE (argtype) == REFERENCE_TYPE)
|
4064 |
|
|
{
|
4065 |
|
|
tree type = build_pointer_type (TREE_TYPE (argtype));
|
4066 |
|
|
arg = build1 (CONVERT_EXPR, type, arg);
|
4067 |
|
|
return arg;
|
4068 |
|
|
}
|
4069 |
|
|
else if (pedantic && DECL_MAIN_P (arg))
|
4070 |
|
|
/* ARM $3.4 */
|
4071 |
|
|
pedwarn ("ISO C++ forbids taking address of function %<::main%>");
|
4072 |
|
|
|
4073 |
|
|
/* Let &* cancel out to simplify resulting code. */
|
4074 |
|
|
if (TREE_CODE (arg) == INDIRECT_REF)
|
4075 |
|
|
{
|
4076 |
|
|
/* We don't need to have `current_class_ptr' wrapped in a
|
4077 |
|
|
NON_LVALUE_EXPR node. */
|
4078 |
|
|
if (arg == current_class_ref)
|
4079 |
|
|
return current_class_ptr;
|
4080 |
|
|
|
4081 |
|
|
arg = TREE_OPERAND (arg, 0);
|
4082 |
|
|
if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
|
4083 |
|
|
{
|
4084 |
|
|
tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
|
4085 |
|
|
arg = build1 (CONVERT_EXPR, type, arg);
|
4086 |
|
|
}
|
4087 |
|
|
else
|
4088 |
|
|
/* Don't let this be an lvalue. */
|
4089 |
|
|
arg = rvalue (arg);
|
4090 |
|
|
return arg;
|
4091 |
|
|
}
|
4092 |
|
|
|
4093 |
|
|
/* Uninstantiated types are all functions. Taking the
|
4094 |
|
|
address of a function is a no-op, so just return the
|
4095 |
|
|
argument. */
|
4096 |
|
|
|
4097 |
|
|
gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
|
4098 |
|
|
|| !IDENTIFIER_OPNAME_P (arg));
|
4099 |
|
|
|
4100 |
|
|
if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
|
4101 |
|
|
&& !really_overloaded_fn (TREE_OPERAND (arg, 1)))
|
4102 |
|
|
{
|
4103 |
|
|
/* They're trying to take the address of a unique non-static
|
4104 |
|
|
member function. This is ill-formed (except in MS-land),
|
4105 |
|
|
but let's try to DTRT.
|
4106 |
|
|
Note: We only handle unique functions here because we don't
|
4107 |
|
|
want to complain if there's a static overload; non-unique
|
4108 |
|
|
cases will be handled by instantiate_type. But we need to
|
4109 |
|
|
handle this case here to allow casts on the resulting PMF.
|
4110 |
|
|
We could defer this in non-MS mode, but it's easier to give
|
4111 |
|
|
a useful error here. */
|
4112 |
|
|
|
4113 |
|
|
/* Inside constant member functions, the `this' pointer
|
4114 |
|
|
contains an extra const qualifier. TYPE_MAIN_VARIANT
|
4115 |
|
|
is used here to remove this const from the diagnostics
|
4116 |
|
|
and the created OFFSET_REF. */
|
4117 |
|
|
tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
|
4118 |
|
|
tree name = DECL_NAME (get_first_fn (TREE_OPERAND (arg, 1)));
|
4119 |
|
|
|
4120 |
|
|
if (! flag_ms_extensions)
|
4121 |
|
|
{
|
4122 |
|
|
if (current_class_type
|
4123 |
|
|
&& TREE_OPERAND (arg, 0) == current_class_ref)
|
4124 |
|
|
/* An expression like &memfn. */
|
4125 |
|
|
pedwarn ("ISO C++ forbids taking the address of an unqualified"
|
4126 |
|
|
" or parenthesized non-static member function to form"
|
4127 |
|
|
" a pointer to member function. Say %<&%T::%D%>",
|
4128 |
|
|
base, name);
|
4129 |
|
|
else
|
4130 |
|
|
pedwarn ("ISO C++ forbids taking the address of a bound member"
|
4131 |
|
|
" function to form a pointer to member function."
|
4132 |
|
|
" Say %<&%T::%D%>",
|
4133 |
|
|
base, name);
|
4134 |
|
|
}
|
4135 |
|
|
arg = build_offset_ref (base, name, /*address_p=*/true);
|
4136 |
|
|
}
|
4137 |
|
|
|
4138 |
|
|
offset_ref:
|
4139 |
|
|
if (type_unknown_p (arg))
|
4140 |
|
|
return build1 (ADDR_EXPR, unknown_type_node, arg);
|
4141 |
|
|
|
4142 |
|
|
/* Handle complex lvalues (when permitted)
|
4143 |
|
|
by reduction to simpler cases. */
|
4144 |
|
|
val = unary_complex_lvalue (code, arg);
|
4145 |
|
|
if (val != 0)
|
4146 |
|
|
return val;
|
4147 |
|
|
|
4148 |
|
|
switch (TREE_CODE (arg))
|
4149 |
|
|
{
|
4150 |
|
|
case NOP_EXPR:
|
4151 |
|
|
case CONVERT_EXPR:
|
4152 |
|
|
case FLOAT_EXPR:
|
4153 |
|
|
case FIX_TRUNC_EXPR:
|
4154 |
|
|
case FIX_FLOOR_EXPR:
|
4155 |
|
|
case FIX_ROUND_EXPR:
|
4156 |
|
|
case FIX_CEIL_EXPR:
|
4157 |
|
|
if (! lvalue_p (arg) && pedantic)
|
4158 |
|
|
pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
|
4159 |
|
|
break;
|
4160 |
|
|
|
4161 |
|
|
case OVERLOAD:
|
4162 |
|
|
arg = OVL_CURRENT (arg);
|
4163 |
|
|
break;
|
4164 |
|
|
|
4165 |
|
|
case OFFSET_REF:
|
4166 |
|
|
/* Turn a reference to a non-static data member into a
|
4167 |
|
|
pointer-to-member. */
|
4168 |
|
|
{
|
4169 |
|
|
tree type;
|
4170 |
|
|
tree t;
|
4171 |
|
|
|
4172 |
|
|
if (!PTRMEM_OK_P (arg))
|
4173 |
|
|
return build_unary_op (code, arg, 0);
|
4174 |
|
|
|
4175 |
|
|
t = TREE_OPERAND (arg, 1);
|
4176 |
|
|
if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
|
4177 |
|
|
{
|
4178 |
|
|
error ("cannot create pointer to reference member %qD", t);
|
4179 |
|
|
return error_mark_node;
|
4180 |
|
|
}
|
4181 |
|
|
|
4182 |
|
|
type = build_ptrmem_type (context_for_name_lookup (t),
|
4183 |
|
|
TREE_TYPE (t));
|
4184 |
|
|
t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
|
4185 |
|
|
return t;
|
4186 |
|
|
}
|
4187 |
|
|
|
4188 |
|
|
default:
|
4189 |
|
|
break;
|
4190 |
|
|
}
|
4191 |
|
|
|
4192 |
|
|
/* Anything not already handled and not a true memory reference
|
4193 |
|
|
is an error. */
|
4194 |
|
|
if (TREE_CODE (argtype) != FUNCTION_TYPE
|
4195 |
|
|
&& TREE_CODE (argtype) != METHOD_TYPE
|
4196 |
|
|
&& TREE_CODE (arg) != OFFSET_REF
|
4197 |
|
|
/* Permit users to take the address of a compound-literal
|
4198 |
|
|
with sufficient simple elements. */
|
4199 |
|
|
&& !(COMPOUND_LITERAL_P (arg) && TREE_STATIC (arg))
|
4200 |
|
|
&& !lvalue_or_else (arg, lv_addressof))
|
4201 |
|
|
return error_mark_node;
|
4202 |
|
|
|
4203 |
|
|
if (argtype != error_mark_node)
|
4204 |
|
|
argtype = build_pointer_type (argtype);
|
4205 |
|
|
|
4206 |
|
|
/* In a template, we are processing a non-dependent expression
|
4207 |
|
|
so we can just form an ADDR_EXPR with the correct type. */
|
4208 |
|
|
if (processing_template_decl)
|
4209 |
|
|
{
|
4210 |
|
|
val = build_address (arg);
|
4211 |
|
|
if (TREE_CODE (arg) == OFFSET_REF)
|
4212 |
|
|
PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
|
4213 |
|
|
return val;
|
4214 |
|
|
}
|
4215 |
|
|
|
4216 |
|
|
/* If the user has taken the address of the compound literal,
|
4217 |
|
|
create a variable to contain the value of the literal and
|
4218 |
|
|
then return the address of that variable. */
|
4219 |
|
|
if (COMPOUND_LITERAL_P (arg))
|
4220 |
|
|
{
|
4221 |
|
|
tree var;
|
4222 |
|
|
gcc_assert (TREE_STATIC (arg));
|
4223 |
|
|
var = create_temporary_var (TREE_TYPE (arg));
|
4224 |
|
|
TREE_STATIC (var) = 1;
|
4225 |
|
|
set_compound_literal_name (var);
|
4226 |
|
|
initialize_artificial_var (var, arg);
|
4227 |
|
|
arg = pushdecl (var);
|
4228 |
|
|
/* Since each compound literal is unique, pushdecl should
|
4229 |
|
|
never find a pre-existing variable with the same
|
4230 |
|
|
name. */
|
4231 |
|
|
gcc_assert (arg == var);
|
4232 |
|
|
}
|
4233 |
|
|
|
4234 |
|
|
if (TREE_CODE (arg) != COMPONENT_REF)
|
4235 |
|
|
{
|
4236 |
|
|
val = build_address (arg);
|
4237 |
|
|
if (TREE_CODE (arg) == OFFSET_REF)
|
4238 |
|
|
PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
|
4239 |
|
|
}
|
4240 |
|
|
else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
|
4241 |
|
|
{
|
4242 |
|
|
tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
|
4243 |
|
|
|
4244 |
|
|
/* We can only get here with a single static member
|
4245 |
|
|
function. */
|
4246 |
|
|
gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
|
4247 |
|
|
&& DECL_STATIC_FUNCTION_P (fn));
|
4248 |
|
|
mark_used (fn);
|
4249 |
|
|
val = build_address (fn);
|
4250 |
|
|
if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
|
4251 |
|
|
/* Do not lose object's side effects. */
|
4252 |
|
|
val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
|
4253 |
|
|
TREE_OPERAND (arg, 0), val);
|
4254 |
|
|
}
|
4255 |
|
|
else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
|
4256 |
|
|
{
|
4257 |
|
|
error ("attempt to take address of bit-field structure member %qD",
|
4258 |
|
|
TREE_OPERAND (arg, 1));
|
4259 |
|
|
return error_mark_node;
|
4260 |
|
|
}
|
4261 |
|
|
else
|
4262 |
|
|
{
|
4263 |
|
|
tree object = TREE_OPERAND (arg, 0);
|
4264 |
|
|
tree field = TREE_OPERAND (arg, 1);
|
4265 |
|
|
gcc_assert (same_type_ignoring_top_level_qualifiers_p
|
4266 |
|
|
(TREE_TYPE (object), decl_type_context (field)));
|
4267 |
|
|
val = build_address (arg);
|
4268 |
|
|
}
|
4269 |
|
|
|
4270 |
|
|
if (TREE_CODE (argtype) == POINTER_TYPE
|
4271 |
|
|
&& TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
|
4272 |
|
|
{
|
4273 |
|
|
build_ptrmemfunc_type (argtype);
|
4274 |
|
|
val = build_ptrmemfunc (argtype, val, 0,
|
4275 |
|
|
/*c_cast_p=*/false);
|
4276 |
|
|
}
|
4277 |
|
|
|
4278 |
|
|
return val;
|
4279 |
|
|
|
4280 |
|
|
default:
|
4281 |
|
|
break;
|
4282 |
|
|
}
|
4283 |
|
|
|
4284 |
|
|
if (!errstring)
|
4285 |
|
|
{
|
4286 |
|
|
if (argtype == 0)
|
4287 |
|
|
argtype = TREE_TYPE (arg);
|
4288 |
|
|
return fold_if_not_in_template (build1 (code, argtype, arg));
|
4289 |
|
|
}
|
4290 |
|
|
|
4291 |
|
|
error ("%s", errstring);
|
4292 |
|
|
return error_mark_node;
|
4293 |
|
|
}
|
4294 |
|
|
|
4295 |
|
|
/* Apply unary lvalue-demanding operator CODE to the expression ARG
|
4296 |
|
|
for certain kinds of expressions which are not really lvalues
|
4297 |
|
|
but which we can accept as lvalues.
|
4298 |
|
|
|
4299 |
|
|
If ARG is not a kind of expression we can handle, return
|
4300 |
|
|
NULL_TREE. */
|
4301 |
|
|
|
4302 |
|
|
tree
|
4303 |
|
|
unary_complex_lvalue (enum tree_code code, tree arg)
|
4304 |
|
|
{
|
4305 |
|
|
/* Inside a template, making these kinds of adjustments is
|
4306 |
|
|
pointless; we are only concerned with the type of the
|
4307 |
|
|
expression. */
|
4308 |
|
|
if (processing_template_decl)
|
4309 |
|
|
return NULL_TREE;
|
4310 |
|
|
|
4311 |
|
|
/* Handle (a, b) used as an "lvalue". */
|
4312 |
|
|
if (TREE_CODE (arg) == COMPOUND_EXPR)
|
4313 |
|
|
{
|
4314 |
|
|
tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
|
4315 |
|
|
return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
|
4316 |
|
|
TREE_OPERAND (arg, 0), real_result);
|
4317 |
|
|
}
|
4318 |
|
|
|
4319 |
|
|
/* Handle (a ? b : c) used as an "lvalue". */
|
4320 |
|
|
if (TREE_CODE (arg) == COND_EXPR
|
4321 |
|
|
|| TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
|
4322 |
|
|
return rationalize_conditional_expr (code, arg);
|
4323 |
|
|
|
4324 |
|
|
/* Handle (a = b), (++a), and (--a) used as an "lvalue". */
|
4325 |
|
|
if (TREE_CODE (arg) == MODIFY_EXPR
|
4326 |
|
|
|| TREE_CODE (arg) == PREINCREMENT_EXPR
|
4327 |
|
|
|| TREE_CODE (arg) == PREDECREMENT_EXPR)
|
4328 |
|
|
{
|
4329 |
|
|
tree lvalue = TREE_OPERAND (arg, 0);
|
4330 |
|
|
if (TREE_SIDE_EFFECTS (lvalue))
|
4331 |
|
|
{
|
4332 |
|
|
lvalue = stabilize_reference (lvalue);
|
4333 |
|
|
arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
|
4334 |
|
|
lvalue, TREE_OPERAND (arg, 1));
|
4335 |
|
|
}
|
4336 |
|
|
return unary_complex_lvalue
|
4337 |
|
|
(code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
|
4338 |
|
|
}
|
4339 |
|
|
|
4340 |
|
|
if (code != ADDR_EXPR)
|
4341 |
|
|
return 0;
|
4342 |
|
|
|
4343 |
|
|
/* Handle (a = b) used as an "lvalue" for `&'. */
|
4344 |
|
|
if (TREE_CODE (arg) == MODIFY_EXPR
|
4345 |
|
|
|| TREE_CODE (arg) == INIT_EXPR)
|
4346 |
|
|
{
|
4347 |
|
|
tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
|
4348 |
|
|
arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
|
4349 |
|
|
arg, real_result);
|
4350 |
|
|
TREE_NO_WARNING (arg) = 1;
|
4351 |
|
|
return arg;
|
4352 |
|
|
}
|
4353 |
|
|
|
4354 |
|
|
if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
|
4355 |
|
|
|| TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
|
4356 |
|
|
|| TREE_CODE (arg) == OFFSET_REF)
|
4357 |
|
|
return NULL_TREE;
|
4358 |
|
|
|
4359 |
|
|
/* We permit compiler to make function calls returning
|
4360 |
|
|
objects of aggregate type look like lvalues. */
|
4361 |
|
|
{
|
4362 |
|
|
tree targ = arg;
|
4363 |
|
|
|
4364 |
|
|
if (TREE_CODE (targ) == SAVE_EXPR)
|
4365 |
|
|
targ = TREE_OPERAND (targ, 0);
|
4366 |
|
|
|
4367 |
|
|
if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
|
4368 |
|
|
{
|
4369 |
|
|
if (TREE_CODE (arg) == SAVE_EXPR)
|
4370 |
|
|
targ = arg;
|
4371 |
|
|
else
|
4372 |
|
|
targ = build_cplus_new (TREE_TYPE (arg), arg);
|
4373 |
|
|
return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
|
4374 |
|
|
}
|
4375 |
|
|
|
4376 |
|
|
if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
|
4377 |
|
|
return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
|
4378 |
|
|
TREE_OPERAND (targ, 0), current_function_decl, NULL);
|
4379 |
|
|
}
|
4380 |
|
|
|
4381 |
|
|
/* Don't let anything else be handled specially. */
|
4382 |
|
|
return 0;
|
4383 |
|
|
}
|
4384 |
|
|
|
4385 |
|
|
/* Mark EXP saying that we need to be able to take the
|
4386 |
|
|
address of it; it should not be allocated in a register.
|
4387 |
|
|
Value is true if successful.
|
4388 |
|
|
|
4389 |
|
|
C++: we do not allow `current_class_ptr' to be addressable. */
|
4390 |
|
|
|
4391 |
|
|
bool
|
4392 |
|
|
cxx_mark_addressable (tree exp)
|
4393 |
|
|
{
|
4394 |
|
|
tree x = exp;
|
4395 |
|
|
|
4396 |
|
|
while (1)
|
4397 |
|
|
switch (TREE_CODE (x))
|
4398 |
|
|
{
|
4399 |
|
|
case ADDR_EXPR:
|
4400 |
|
|
case COMPONENT_REF:
|
4401 |
|
|
case ARRAY_REF:
|
4402 |
|
|
case REALPART_EXPR:
|
4403 |
|
|
case IMAGPART_EXPR:
|
4404 |
|
|
x = TREE_OPERAND (x, 0);
|
4405 |
|
|
break;
|
4406 |
|
|
|
4407 |
|
|
case PARM_DECL:
|
4408 |
|
|
if (x == current_class_ptr)
|
4409 |
|
|
{
|
4410 |
|
|
error ("cannot take the address of %<this%>, which is an rvalue expression");
|
4411 |
|
|
TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later. */
|
4412 |
|
|
return true;
|
4413 |
|
|
}
|
4414 |
|
|
/* Fall through. */
|
4415 |
|
|
|
4416 |
|
|
case VAR_DECL:
|
4417 |
|
|
/* Caller should not be trying to mark initialized
|
4418 |
|
|
constant fields addressable. */
|
4419 |
|
|
gcc_assert (DECL_LANG_SPECIFIC (x) == 0
|
4420 |
|
|
|| DECL_IN_AGGR_P (x) == 0
|
4421 |
|
|
|| TREE_STATIC (x)
|
4422 |
|
|
|| DECL_EXTERNAL (x));
|
4423 |
|
|
/* Fall through. */
|
4424 |
|
|
|
4425 |
|
|
case CONST_DECL:
|
4426 |
|
|
case RESULT_DECL:
|
4427 |
|
|
if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
|
4428 |
|
|
&& !DECL_ARTIFICIAL (x))
|
4429 |
|
|
{
|
4430 |
|
|
if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x))
|
4431 |
|
|
{
|
4432 |
|
|
error
|
4433 |
|
|
("address of explicit register variable %qD requested", x);
|
4434 |
|
|
return false;
|
4435 |
|
|
}
|
4436 |
|
|
else if (extra_warnings)
|
4437 |
|
|
warning
|
4438 |
|
|
(0, "address requested for %qD, which is declared %<register%>", x);
|
4439 |
|
|
}
|
4440 |
|
|
TREE_ADDRESSABLE (x) = 1;
|
4441 |
|
|
return true;
|
4442 |
|
|
|
4443 |
|
|
case FUNCTION_DECL:
|
4444 |
|
|
TREE_ADDRESSABLE (x) = 1;
|
4445 |
|
|
return true;
|
4446 |
|
|
|
4447 |
|
|
case CONSTRUCTOR:
|
4448 |
|
|
TREE_ADDRESSABLE (x) = 1;
|
4449 |
|
|
return true;
|
4450 |
|
|
|
4451 |
|
|
case TARGET_EXPR:
|
4452 |
|
|
TREE_ADDRESSABLE (x) = 1;
|
4453 |
|
|
cxx_mark_addressable (TREE_OPERAND (x, 0));
|
4454 |
|
|
return true;
|
4455 |
|
|
|
4456 |
|
|
default:
|
4457 |
|
|
return true;
|
4458 |
|
|
}
|
4459 |
|
|
}
|
4460 |
|
|
|
4461 |
|
|
/* Build and return a conditional expression IFEXP ? OP1 : OP2. */
|
4462 |
|
|
|
4463 |
|
|
tree
|
4464 |
|
|
build_x_conditional_expr (tree ifexp, tree op1, tree op2)
|
4465 |
|
|
{
|
4466 |
|
|
tree orig_ifexp = ifexp;
|
4467 |
|
|
tree orig_op1 = op1;
|
4468 |
|
|
tree orig_op2 = op2;
|
4469 |
|
|
tree expr;
|
4470 |
|
|
|
4471 |
|
|
if (processing_template_decl)
|
4472 |
|
|
{
|
4473 |
|
|
/* The standard says that the expression is type-dependent if
|
4474 |
|
|
IFEXP is type-dependent, even though the eventual type of the
|
4475 |
|
|
expression doesn't dependent on IFEXP. */
|
4476 |
|
|
if (type_dependent_expression_p (ifexp)
|
4477 |
|
|
/* As a GNU extension, the middle operand may be omitted. */
|
4478 |
|
|
|| (op1 && type_dependent_expression_p (op1))
|
4479 |
|
|
|| type_dependent_expression_p (op2))
|
4480 |
|
|
return build_min_nt (COND_EXPR, ifexp, op1, op2);
|
4481 |
|
|
ifexp = build_non_dependent_expr (ifexp);
|
4482 |
|
|
if (op1)
|
4483 |
|
|
op1 = build_non_dependent_expr (op1);
|
4484 |
|
|
op2 = build_non_dependent_expr (op2);
|
4485 |
|
|
}
|
4486 |
|
|
|
4487 |
|
|
expr = build_conditional_expr (ifexp, op1, op2);
|
4488 |
|
|
if (processing_template_decl && expr != error_mark_node)
|
4489 |
|
|
return build_min_non_dep (COND_EXPR, expr,
|
4490 |
|
|
orig_ifexp, orig_op1, orig_op2);
|
4491 |
|
|
return expr;
|
4492 |
|
|
}
|
4493 |
|
|
|
4494 |
|
|
/* Given a list of expressions, return a compound expression
|
4495 |
|
|
that performs them all and returns the value of the last of them. */
|
4496 |
|
|
|
4497 |
|
|
tree build_x_compound_expr_from_list (tree list, const char *msg)
|
4498 |
|
|
{
|
4499 |
|
|
tree expr = TREE_VALUE (list);
|
4500 |
|
|
|
4501 |
|
|
if (TREE_CHAIN (list))
|
4502 |
|
|
{
|
4503 |
|
|
if (msg)
|
4504 |
|
|
pedwarn ("%s expression list treated as compound expression", msg);
|
4505 |
|
|
|
4506 |
|
|
for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
|
4507 |
|
|
expr = build_x_compound_expr (expr, TREE_VALUE (list));
|
4508 |
|
|
}
|
4509 |
|
|
|
4510 |
|
|
return expr;
|
4511 |
|
|
}
|
4512 |
|
|
|
4513 |
|
|
/* Handle overloading of the ',' operator when needed. */
|
4514 |
|
|
|
4515 |
|
|
tree
|
4516 |
|
|
build_x_compound_expr (tree op1, tree op2)
|
4517 |
|
|
{
|
4518 |
|
|
tree result;
|
4519 |
|
|
tree orig_op1 = op1;
|
4520 |
|
|
tree orig_op2 = op2;
|
4521 |
|
|
|
4522 |
|
|
if (processing_template_decl)
|
4523 |
|
|
{
|
4524 |
|
|
if (type_dependent_expression_p (op1)
|
4525 |
|
|
|| type_dependent_expression_p (op2))
|
4526 |
|
|
return build_min_nt (COMPOUND_EXPR, op1, op2);
|
4527 |
|
|
op1 = build_non_dependent_expr (op1);
|
4528 |
|
|
op2 = build_non_dependent_expr (op2);
|
4529 |
|
|
}
|
4530 |
|
|
|
4531 |
|
|
result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
|
4532 |
|
|
/*overloaded_p=*/NULL);
|
4533 |
|
|
if (!result)
|
4534 |
|
|
result = build_compound_expr (op1, op2);
|
4535 |
|
|
|
4536 |
|
|
if (processing_template_decl && result != error_mark_node)
|
4537 |
|
|
return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
|
4538 |
|
|
|
4539 |
|
|
return result;
|
4540 |
|
|
}
|
4541 |
|
|
|
4542 |
|
|
/* Build a compound expression. */
|
4543 |
|
|
|
4544 |
|
|
tree
|
4545 |
|
|
build_compound_expr (tree lhs, tree rhs)
|
4546 |
|
|
{
|
4547 |
|
|
lhs = convert_to_void (lhs, "left-hand operand of comma");
|
4548 |
|
|
|
4549 |
|
|
if (lhs == error_mark_node || rhs == error_mark_node)
|
4550 |
|
|
return error_mark_node;
|
4551 |
|
|
|
4552 |
|
|
if (TREE_CODE (rhs) == TARGET_EXPR)
|
4553 |
|
|
{
|
4554 |
|
|
/* If the rhs is a TARGET_EXPR, then build the compound
|
4555 |
|
|
expression inside the target_expr's initializer. This
|
4556 |
|
|
helps the compiler to eliminate unnecessary temporaries. */
|
4557 |
|
|
tree init = TREE_OPERAND (rhs, 1);
|
4558 |
|
|
|
4559 |
|
|
init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
|
4560 |
|
|
TREE_OPERAND (rhs, 1) = init;
|
4561 |
|
|
|
4562 |
|
|
return rhs;
|
4563 |
|
|
}
|
4564 |
|
|
|
4565 |
|
|
return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
|
4566 |
|
|
}
|
4567 |
|
|
|
4568 |
|
|
/* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
|
4569 |
|
|
casts away constness. DIAG_FN gives the function to call if we
|
4570 |
|
|
need to issue a diagnostic; if it is NULL, no diagnostic will be
|
4571 |
|
|
issued. DESCRIPTION explains what operation is taking place. */
|
4572 |
|
|
|
4573 |
|
|
static void
|
4574 |
|
|
check_for_casting_away_constness (tree src_type, tree dest_type,
|
4575 |
|
|
void (*diag_fn)(const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2),
|
4576 |
|
|
const char *description)
|
4577 |
|
|
{
|
4578 |
|
|
if (diag_fn && casts_away_constness (src_type, dest_type))
|
4579 |
|
|
diag_fn ("%s from type %qT to type %qT casts away constness",
|
4580 |
|
|
description, src_type, dest_type);
|
4581 |
|
|
}
|
4582 |
|
|
|
4583 |
|
|
/* Convert EXPR (an expression with pointer-to-member type) to TYPE
|
4584 |
|
|
(another pointer-to-member type in the same hierarchy) and return
|
4585 |
|
|
the converted expression. If ALLOW_INVERSE_P is permitted, a
|
4586 |
|
|
pointer-to-derived may be converted to pointer-to-base; otherwise,
|
4587 |
|
|
only the other direction is permitted. If C_CAST_P is true, this
|
4588 |
|
|
conversion is taking place as part of a C-style cast. */
|
4589 |
|
|
|
4590 |
|
|
tree
|
4591 |
|
|
convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
|
4592 |
|
|
bool c_cast_p)
|
4593 |
|
|
{
|
4594 |
|
|
if (TYPE_PTRMEM_P (type))
|
4595 |
|
|
{
|
4596 |
|
|
tree delta;
|
4597 |
|
|
|
4598 |
|
|
if (TREE_CODE (expr) == PTRMEM_CST)
|
4599 |
|
|
expr = cplus_expand_constant (expr);
|
4600 |
|
|
delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
|
4601 |
|
|
TYPE_PTRMEM_CLASS_TYPE (type),
|
4602 |
|
|
allow_inverse_p,
|
4603 |
|
|
c_cast_p);
|
4604 |
|
|
if (!integer_zerop (delta))
|
4605 |
|
|
expr = cp_build_binary_op (PLUS_EXPR,
|
4606 |
|
|
build_nop (ptrdiff_type_node, expr),
|
4607 |
|
|
delta);
|
4608 |
|
|
return build_nop (type, expr);
|
4609 |
|
|
}
|
4610 |
|
|
else
|
4611 |
|
|
return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
|
4612 |
|
|
allow_inverse_p, c_cast_p);
|
4613 |
|
|
}
|
4614 |
|
|
|
4615 |
|
|
/* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
|
4616 |
|
|
a version of EXPR that has TREE_OVERFLOW and/or TREE_CONSTANT_OVERFLOW
|
4617 |
|
|
set iff they are set in ORIG. Otherwise, return EXPR unchanged. */
|
4618 |
|
|
|
4619 |
|
|
static tree
|
4620 |
|
|
ignore_overflows (tree expr, tree orig)
|
4621 |
|
|
{
|
4622 |
|
|
if (TREE_CODE (expr) == INTEGER_CST
|
4623 |
|
|
&& CONSTANT_CLASS_P (orig)
|
4624 |
|
|
&& TREE_CODE (orig) != STRING_CST
|
4625 |
|
|
&& (TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig)
|
4626 |
|
|
|| TREE_CONSTANT_OVERFLOW (expr)
|
4627 |
|
|
!= TREE_CONSTANT_OVERFLOW (orig)))
|
4628 |
|
|
{
|
4629 |
|
|
if (!TREE_OVERFLOW (orig) && !TREE_CONSTANT_OVERFLOW (orig))
|
4630 |
|
|
/* Ensure constant sharing. */
|
4631 |
|
|
expr = build_int_cst_wide (TREE_TYPE (expr),
|
4632 |
|
|
TREE_INT_CST_LOW (expr),
|
4633 |
|
|
TREE_INT_CST_HIGH (expr));
|
4634 |
|
|
else
|
4635 |
|
|
{
|
4636 |
|
|
/* Avoid clobbering a shared constant. */
|
4637 |
|
|
expr = copy_node (expr);
|
4638 |
|
|
TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
|
4639 |
|
|
TREE_CONSTANT_OVERFLOW (expr)
|
4640 |
|
|
= TREE_CONSTANT_OVERFLOW (orig);
|
4641 |
|
|
}
|
4642 |
|
|
}
|
4643 |
|
|
return expr;
|
4644 |
|
|
}
|
4645 |
|
|
|
4646 |
|
|
/* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
|
4647 |
|
|
this static_cast is being attempted as one of the possible casts
|
4648 |
|
|
allowed by a C-style cast. (In that case, accessibility of base
|
4649 |
|
|
classes is not considered, and it is OK to cast away
|
4650 |
|
|
constness.) Return the result of the cast. *VALID_P is set to
|
4651 |
|
|
indicate whether or not the cast was valid. */
|
4652 |
|
|
|
4653 |
|
|
static tree
|
4654 |
|
|
build_static_cast_1 (tree type, tree expr, bool c_cast_p,
|
4655 |
|
|
bool *valid_p)
|
4656 |
|
|
{
|
4657 |
|
|
tree intype;
|
4658 |
|
|
tree result;
|
4659 |
|
|
tree orig;
|
4660 |
|
|
void (*diag_fn)(const char*, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
|
4661 |
|
|
const char *desc;
|
4662 |
|
|
|
4663 |
|
|
/* Assume the cast is valid. */
|
4664 |
|
|
*valid_p = true;
|
4665 |
|
|
|
4666 |
|
|
intype = TREE_TYPE (expr);
|
4667 |
|
|
|
4668 |
|
|
/* Determine what to do when casting away constness. */
|
4669 |
|
|
if (c_cast_p)
|
4670 |
|
|
{
|
4671 |
|
|
/* C-style casts are allowed to cast away constness. With
|
4672 |
|
|
WARN_CAST_QUAL, we still want to issue a warning. */
|
4673 |
|
|
diag_fn = warn_cast_qual ? warning0 : NULL;
|
4674 |
|
|
desc = "cast";
|
4675 |
|
|
}
|
4676 |
|
|
else
|
4677 |
|
|
{
|
4678 |
|
|
/* A static_cast may not cast away constness. */
|
4679 |
|
|
diag_fn = error;
|
4680 |
|
|
desc = "static_cast";
|
4681 |
|
|
}
|
4682 |
|
|
|
4683 |
|
|
/* [expr.static.cast]
|
4684 |
|
|
|
4685 |
|
|
An lvalue of type "cv1 B", where B is a class type, can be cast
|
4686 |
|
|
to type "reference to cv2 D", where D is a class derived (clause
|
4687 |
|
|
_class.derived_) from B, if a valid standard conversion from
|
4688 |
|
|
"pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
|
4689 |
|
|
same cv-qualification as, or greater cv-qualification than, cv1,
|
4690 |
|
|
and B is not a virtual base class of D. */
|
4691 |
|
|
/* We check this case before checking the validity of "TYPE t =
|
4692 |
|
|
EXPR;" below because for this case:
|
4693 |
|
|
|
4694 |
|
|
struct B {};
|
4695 |
|
|
struct D : public B { D(const B&); };
|
4696 |
|
|
extern B& b;
|
4697 |
|
|
void f() { static_cast<const D&>(b); }
|
4698 |
|
|
|
4699 |
|
|
we want to avoid constructing a new D. The standard is not
|
4700 |
|
|
completely clear about this issue, but our interpretation is
|
4701 |
|
|
consistent with other compilers. */
|
4702 |
|
|
if (TREE_CODE (type) == REFERENCE_TYPE
|
4703 |
|
|
&& CLASS_TYPE_P (TREE_TYPE (type))
|
4704 |
|
|
&& CLASS_TYPE_P (intype)
|
4705 |
|
|
&& real_lvalue_p (expr)
|
4706 |
|
|
&& DERIVED_FROM_P (intype, TREE_TYPE (type))
|
4707 |
|
|
&& can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
|
4708 |
|
|
build_pointer_type (TYPE_MAIN_VARIANT
|
4709 |
|
|
(TREE_TYPE (type))))
|
4710 |
|
|
&& (c_cast_p
|
4711 |
|
|
|| at_least_as_qualified_p (TREE_TYPE (type), intype)))
|
4712 |
|
|
{
|
4713 |
|
|
tree base;
|
4714 |
|
|
|
4715 |
|
|
/* There is a standard conversion from "D*" to "B*" even if "B"
|
4716 |
|
|
is ambiguous or inaccessible. If this is really a
|
4717 |
|
|
static_cast, then we check both for inaccessibility and
|
4718 |
|
|
ambiguity. However, if this is a static_cast being performed
|
4719 |
|
|
because the user wrote a C-style cast, then accessibility is
|
4720 |
|
|
not considered. */
|
4721 |
|
|
base = lookup_base (TREE_TYPE (type), intype,
|
4722 |
|
|
c_cast_p ? ba_unique : ba_check,
|
4723 |
|
|
NULL);
|
4724 |
|
|
|
4725 |
|
|
/* Convert from "B*" to "D*". This function will check that "B"
|
4726 |
|
|
is not a virtual base of "D". */
|
4727 |
|
|
expr = build_base_path (MINUS_EXPR, build_address (expr),
|
4728 |
|
|
base, /*nonnull=*/false);
|
4729 |
|
|
/* Convert the pointer to a reference -- but then remember that
|
4730 |
|
|
there are no expressions with reference type in C++. */
|
4731 |
|
|
return convert_from_reference (build_nop (type, expr));
|
4732 |
|
|
}
|
4733 |
|
|
|
4734 |
|
|
orig = expr;
|
4735 |
|
|
|
4736 |
|
|
/* [expr.static.cast]
|
4737 |
|
|
|
4738 |
|
|
An expression e can be explicitly converted to a type T using a
|
4739 |
|
|
static_cast of the form static_cast<T>(e) if the declaration T
|
4740 |
|
|
t(e);" is well-formed, for some invented temporary variable
|
4741 |
|
|
t. */
|
4742 |
|
|
result = perform_direct_initialization_if_possible (type, expr,
|
4743 |
|
|
c_cast_p);
|
4744 |
|
|
if (result)
|
4745 |
|
|
{
|
4746 |
|
|
result = convert_from_reference (result);
|
4747 |
|
|
|
4748 |
|
|
/* Ignore any integer overflow caused by the cast. */
|
4749 |
|
|
result = ignore_overflows (result, orig);
|
4750 |
|
|
|
4751 |
|
|
/* [expr.static.cast]
|
4752 |
|
|
|
4753 |
|
|
If T is a reference type, the result is an lvalue; otherwise,
|
4754 |
|
|
the result is an rvalue. */
|
4755 |
|
|
if (TREE_CODE (type) != REFERENCE_TYPE)
|
4756 |
|
|
result = rvalue (result);
|
4757 |
|
|
return result;
|
4758 |
|
|
}
|
4759 |
|
|
|
4760 |
|
|
/* [expr.static.cast]
|
4761 |
|
|
|
4762 |
|
|
Any expression can be explicitly converted to type cv void. */
|
4763 |
|
|
if (TREE_CODE (type) == VOID_TYPE)
|
4764 |
|
|
return convert_to_void (expr, /*implicit=*/NULL);
|
4765 |
|
|
|
4766 |
|
|
/* [expr.static.cast]
|
4767 |
|
|
|
4768 |
|
|
The inverse of any standard conversion sequence (clause _conv_),
|
4769 |
|
|
other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
|
4770 |
|
|
(_conv.array_), function-to-pointer (_conv.func_), and boolean
|
4771 |
|
|
(_conv.bool_) conversions, can be performed explicitly using
|
4772 |
|
|
static_cast subject to the restriction that the explicit
|
4773 |
|
|
conversion does not cast away constness (_expr.const.cast_), and
|
4774 |
|
|
the following additional rules for specific cases: */
|
4775 |
|
|
/* For reference, the conversions not excluded are: integral
|
4776 |
|
|
promotions, floating point promotion, integral conversions,
|
4777 |
|
|
floating point conversions, floating-integral conversions,
|
4778 |
|
|
pointer conversions, and pointer to member conversions. */
|
4779 |
|
|
/* DR 128
|
4780 |
|
|
|
4781 |
|
|
A value of integral _or enumeration_ type can be explicitly
|
4782 |
|
|
converted to an enumeration type. */
|
4783 |
|
|
/* The effect of all that is that any conversion between any two
|
4784 |
|
|
types which are integral, floating, or enumeration types can be
|
4785 |
|
|
performed. */
|
4786 |
|
|
if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
|
4787 |
|
|
&& (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype)))
|
4788 |
|
|
{
|
4789 |
|
|
expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
|
4790 |
|
|
|
4791 |
|
|
/* Ignore any integer overflow caused by the cast. */
|
4792 |
|
|
expr = ignore_overflows (expr, orig);
|
4793 |
|
|
return expr;
|
4794 |
|
|
}
|
4795 |
|
|
|
4796 |
|
|
if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
|
4797 |
|
|
&& CLASS_TYPE_P (TREE_TYPE (type))
|
4798 |
|
|
&& CLASS_TYPE_P (TREE_TYPE (intype))
|
4799 |
|
|
&& can_convert (build_pointer_type (TYPE_MAIN_VARIANT
|
4800 |
|
|
(TREE_TYPE (intype))),
|
4801 |
|
|
build_pointer_type (TYPE_MAIN_VARIANT
|
4802 |
|
|
(TREE_TYPE (type)))))
|
4803 |
|
|
{
|
4804 |
|
|
tree base;
|
4805 |
|
|
|
4806 |
|
|
if (!c_cast_p)
|
4807 |
|
|
check_for_casting_away_constness (intype, type, diag_fn, desc);
|
4808 |
|
|
base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
|
4809 |
|
|
c_cast_p ? ba_unique : ba_check,
|
4810 |
|
|
NULL);
|
4811 |
|
|
return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
|
4812 |
|
|
}
|
4813 |
|
|
|
4814 |
|
|
if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
|
4815 |
|
|
|| (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
|
4816 |
|
|
{
|
4817 |
|
|
tree c1;
|
4818 |
|
|
tree c2;
|
4819 |
|
|
tree t1;
|
4820 |
|
|
tree t2;
|
4821 |
|
|
|
4822 |
|
|
c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
|
4823 |
|
|
c2 = TYPE_PTRMEM_CLASS_TYPE (type);
|
4824 |
|
|
|
4825 |
|
|
if (TYPE_PTRMEM_P (type))
|
4826 |
|
|
{
|
4827 |
|
|
t1 = (build_ptrmem_type
|
4828 |
|
|
(c1,
|
4829 |
|
|
TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
|
4830 |
|
|
t2 = (build_ptrmem_type
|
4831 |
|
|
(c2,
|
4832 |
|
|
TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
|
4833 |
|
|
}
|
4834 |
|
|
else
|
4835 |
|
|
{
|
4836 |
|
|
t1 = intype;
|
4837 |
|
|
t2 = type;
|
4838 |
|
|
}
|
4839 |
|
|
if (can_convert (t1, t2))
|
4840 |
|
|
{
|
4841 |
|
|
if (!c_cast_p)
|
4842 |
|
|
check_for_casting_away_constness (intype, type, diag_fn,
|
4843 |
|
|
desc);
|
4844 |
|
|
return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
|
4845 |
|
|
c_cast_p);
|
4846 |
|
|
}
|
4847 |
|
|
}
|
4848 |
|
|
|
4849 |
|
|
/* [expr.static.cast]
|
4850 |
|
|
|
4851 |
|
|
An rvalue of type "pointer to cv void" can be explicitly
|
4852 |
|
|
converted to a pointer to object type. A value of type pointer
|
4853 |
|
|
to object converted to "pointer to cv void" and back to the
|
4854 |
|
|
original pointer type will have its original value. */
|
4855 |
|
|
if (TREE_CODE (intype) == POINTER_TYPE
|
4856 |
|
|
&& VOID_TYPE_P (TREE_TYPE (intype))
|
4857 |
|
|
&& TYPE_PTROB_P (type))
|
4858 |
|
|
{
|
4859 |
|
|
if (!c_cast_p)
|
4860 |
|
|
check_for_casting_away_constness (intype, type, diag_fn, desc);
|
4861 |
|
|
return build_nop (type, expr);
|
4862 |
|
|
}
|
4863 |
|
|
|
4864 |
|
|
*valid_p = false;
|
4865 |
|
|
return error_mark_node;
|
4866 |
|
|
}
|
4867 |
|
|
|
4868 |
|
|
/* Return an expression representing static_cast<TYPE>(EXPR). */
|
4869 |
|
|
|
4870 |
|
|
tree
|
4871 |
|
|
build_static_cast (tree type, tree expr)
|
4872 |
|
|
{
|
4873 |
|
|
tree result;
|
4874 |
|
|
bool valid_p;
|
4875 |
|
|
|
4876 |
|
|
if (type == error_mark_node || expr == error_mark_node)
|
4877 |
|
|
return error_mark_node;
|
4878 |
|
|
|
4879 |
|
|
if (processing_template_decl)
|
4880 |
|
|
{
|
4881 |
|
|
expr = build_min (STATIC_CAST_EXPR, type, expr);
|
4882 |
|
|
/* We don't know if it will or will not have side effects. */
|
4883 |
|
|
TREE_SIDE_EFFECTS (expr) = 1;
|
4884 |
|
|
return convert_from_reference (expr);
|
4885 |
|
|
}
|
4886 |
|
|
|
4887 |
|
|
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
|
4888 |
|
|
Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
|
4889 |
|
|
if (TREE_CODE (type) != REFERENCE_TYPE
|
4890 |
|
|
&& TREE_CODE (expr) == NOP_EXPR
|
4891 |
|
|
&& TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
|
4892 |
|
|
expr = TREE_OPERAND (expr, 0);
|
4893 |
|
|
|
4894 |
|
|
result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p);
|
4895 |
|
|
if (valid_p)
|
4896 |
|
|
return result;
|
4897 |
|
|
|
4898 |
|
|
error ("invalid static_cast from type %qT to type %qT",
|
4899 |
|
|
TREE_TYPE (expr), type);
|
4900 |
|
|
return error_mark_node;
|
4901 |
|
|
}
|
4902 |
|
|
|
4903 |
|
|
/* EXPR is an expression with member function or pointer-to-member
|
4904 |
|
|
function type. TYPE is a pointer type. Converting EXPR to TYPE is
|
4905 |
|
|
not permitted by ISO C++, but we accept it in some modes. If we
|
4906 |
|
|
are not in one of those modes, issue a diagnostic. Return the
|
4907 |
|
|
converted expression. */
|
4908 |
|
|
|
4909 |
|
|
tree
|
4910 |
|
|
convert_member_func_to_ptr (tree type, tree expr)
|
4911 |
|
|
{
|
4912 |
|
|
tree intype;
|
4913 |
|
|
tree decl;
|
4914 |
|
|
|
4915 |
|
|
intype = TREE_TYPE (expr);
|
4916 |
|
|
gcc_assert (TYPE_PTRMEMFUNC_P (intype)
|
4917 |
|
|
|| TREE_CODE (intype) == METHOD_TYPE);
|
4918 |
|
|
|
4919 |
|
|
if (pedantic || warn_pmf2ptr)
|
4920 |
|
|
pedwarn ("converting from %qT to %qT", intype, type);
|
4921 |
|
|
|
4922 |
|
|
if (TREE_CODE (intype) == METHOD_TYPE)
|
4923 |
|
|
expr = build_addr_func (expr);
|
4924 |
|
|
else if (TREE_CODE (expr) == PTRMEM_CST)
|
4925 |
|
|
expr = build_address (PTRMEM_CST_MEMBER (expr));
|
4926 |
|
|
else
|
4927 |
|
|
{
|
4928 |
|
|
decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
|
4929 |
|
|
decl = build_address (decl);
|
4930 |
|
|
expr = get_member_function_from_ptrfunc (&decl, expr);
|
4931 |
|
|
}
|
4932 |
|
|
|
4933 |
|
|
return build_nop (type, expr);
|
4934 |
|
|
}
|
4935 |
|
|
|
4936 |
|
|
/* Return a representation for a reinterpret_cast from EXPR to TYPE.
|
4937 |
|
|
If C_CAST_P is true, this reinterpret cast is being done as part of
|
4938 |
|
|
a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
|
4939 |
|
|
indicate whether or not reinterpret_cast was valid. */
|
4940 |
|
|
|
4941 |
|
|
static tree
|
4942 |
|
|
build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
|
4943 |
|
|
bool *valid_p)
|
4944 |
|
|
{
|
4945 |
|
|
tree intype;
|
4946 |
|
|
|
4947 |
|
|
/* Assume the cast is invalid. */
|
4948 |
|
|
if (valid_p)
|
4949 |
|
|
*valid_p = true;
|
4950 |
|
|
|
4951 |
|
|
if (type == error_mark_node || error_operand_p (expr))
|
4952 |
|
|
return error_mark_node;
|
4953 |
|
|
|
4954 |
|
|
intype = TREE_TYPE (expr);
|
4955 |
|
|
|
4956 |
|
|
/* [expr.reinterpret.cast]
|
4957 |
|
|
An lvalue expression of type T1 can be cast to the type
|
4958 |
|
|
"reference to T2" if an expression of type "pointer to T1" can be
|
4959 |
|
|
explicitly converted to the type "pointer to T2" using a
|
4960 |
|
|
reinterpret_cast. */
|
4961 |
|
|
if (TREE_CODE (type) == REFERENCE_TYPE)
|
4962 |
|
|
{
|
4963 |
|
|
if (! real_lvalue_p (expr))
|
4964 |
|
|
{
|
4965 |
|
|
error ("invalid cast of an rvalue expression of type "
|
4966 |
|
|
"%qT to type %qT",
|
4967 |
|
|
intype, type);
|
4968 |
|
|
return error_mark_node;
|
4969 |
|
|
}
|
4970 |
|
|
|
4971 |
|
|
/* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
|
4972 |
|
|
"B" are related class types; the reinterpret_cast does not
|
4973 |
|
|
adjust the pointer. */
|
4974 |
|
|
if (TYPE_PTR_P (intype)
|
4975 |
|
|
&& (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
|
4976 |
|
|
COMPARE_BASE | COMPARE_DERIVED)))
|
4977 |
|
|
warning (0, "casting %qT to %qT does not dereference pointer",
|
4978 |
|
|
intype, type);
|
4979 |
|
|
|
4980 |
|
|
expr = build_unary_op (ADDR_EXPR, expr, 0);
|
4981 |
|
|
if (expr != error_mark_node)
|
4982 |
|
|
expr = build_reinterpret_cast_1
|
4983 |
|
|
(build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
|
4984 |
|
|
valid_p);
|
4985 |
|
|
if (expr != error_mark_node)
|
4986 |
|
|
expr = build_indirect_ref (expr, 0);
|
4987 |
|
|
return expr;
|
4988 |
|
|
}
|
4989 |
|
|
|
4990 |
|
|
/* As a G++ extension, we consider conversions from member
|
4991 |
|
|
functions, and pointers to member functions to
|
4992 |
|
|
pointer-to-function and pointer-to-void types. If
|
4993 |
|
|
-Wno-pmf-conversions has not been specified,
|
4994 |
|
|
convert_member_func_to_ptr will issue an error message. */
|
4995 |
|
|
if ((TYPE_PTRMEMFUNC_P (intype)
|
4996 |
|
|
|| TREE_CODE (intype) == METHOD_TYPE)
|
4997 |
|
|
&& TYPE_PTR_P (type)
|
4998 |
|
|
&& (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
|
4999 |
|
|
|| VOID_TYPE_P (TREE_TYPE (type))))
|
5000 |
|
|
return convert_member_func_to_ptr (type, expr);
|
5001 |
|
|
|
5002 |
|
|
/* If the cast is not to a reference type, the lvalue-to-rvalue,
|
5003 |
|
|
array-to-pointer, and function-to-pointer conversions are
|
5004 |
|
|
performed. */
|
5005 |
|
|
expr = decay_conversion (expr);
|
5006 |
|
|
|
5007 |
|
|
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
|
5008 |
|
|
Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
|
5009 |
|
|
if (TREE_CODE (expr) == NOP_EXPR
|
5010 |
|
|
&& TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
|
5011 |
|
|
expr = TREE_OPERAND (expr, 0);
|
5012 |
|
|
|
5013 |
|
|
if (error_operand_p (expr))
|
5014 |
|
|
return error_mark_node;
|
5015 |
|
|
|
5016 |
|
|
intype = TREE_TYPE (expr);
|
5017 |
|
|
|
5018 |
|
|
/* [expr.reinterpret.cast]
|
5019 |
|
|
A pointer can be converted to any integral type large enough to
|
5020 |
|
|
hold it. */
|
5021 |
|
|
if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
|
5022 |
|
|
{
|
5023 |
|
|
if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
|
5024 |
|
|
pedwarn ("cast from %qT to %qT loses precision",
|
5025 |
|
|
intype, type);
|
5026 |
|
|
}
|
5027 |
|
|
/* [expr.reinterpret.cast]
|
5028 |
|
|
A value of integral or enumeration type can be explicitly
|
5029 |
|
|
converted to a pointer. */
|
5030 |
|
|
else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
|
5031 |
|
|
/* OK */
|
5032 |
|
|
;
|
5033 |
|
|
else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
|
5034 |
|
|
|| (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
|
5035 |
|
|
return fold_if_not_in_template (build_nop (type, expr));
|
5036 |
|
|
else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
|
5037 |
|
|
|| (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
|
5038 |
|
|
{
|
5039 |
|
|
tree sexpr = expr;
|
5040 |
|
|
|
5041 |
|
|
if (!c_cast_p)
|
5042 |
|
|
check_for_casting_away_constness (intype, type, error,
|
5043 |
|
|
"reinterpret_cast");
|
5044 |
|
|
/* Warn about possible alignment problems. */
|
5045 |
|
|
if (STRICT_ALIGNMENT && warn_cast_align
|
5046 |
|
|
&& !VOID_TYPE_P (type)
|
5047 |
|
|
&& TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
|
5048 |
|
|
&& COMPLETE_TYPE_P (TREE_TYPE (type))
|
5049 |
|
|
&& COMPLETE_TYPE_P (TREE_TYPE (intype))
|
5050 |
|
|
&& TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
|
5051 |
|
|
warning (0, "cast from %qT to %qT increases required alignment of "
|
5052 |
|
|
"target type",
|
5053 |
|
|
intype, type);
|
5054 |
|
|
|
5055 |
|
|
/* We need to strip nops here, because the frontend likes to
|
5056 |
|
|
create (int *)&a for array-to-pointer decay, instead of &a[0]. */
|
5057 |
|
|
STRIP_NOPS (sexpr);
|
5058 |
|
|
strict_aliasing_warning (intype, type, sexpr);
|
5059 |
|
|
|
5060 |
|
|
return fold_if_not_in_template (build_nop (type, expr));
|
5061 |
|
|
}
|
5062 |
|
|
else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
|
5063 |
|
|
|| (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
|
5064 |
|
|
{
|
5065 |
|
|
if (pedantic)
|
5066 |
|
|
/* Only issue a warning, as we have always supported this
|
5067 |
|
|
where possible, and it is necessary in some cases. DR 195
|
5068 |
|
|
addresses this issue, but as of 2004/10/26 is still in
|
5069 |
|
|
drafting. */
|
5070 |
|
|
warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
|
5071 |
|
|
return fold_if_not_in_template (build_nop (type, expr));
|
5072 |
|
|
}
|
5073 |
|
|
else if (TREE_CODE (type) == VECTOR_TYPE)
|
5074 |
|
|
return fold_if_not_in_template (convert_to_vector (type, expr));
|
5075 |
|
|
else if (TREE_CODE (intype) == VECTOR_TYPE)
|
5076 |
|
|
return fold_if_not_in_template (convert_to_integer (type, expr));
|
5077 |
|
|
else
|
5078 |
|
|
{
|
5079 |
|
|
if (valid_p)
|
5080 |
|
|
*valid_p = false;
|
5081 |
|
|
error ("invalid cast from type %qT to type %qT", intype, type);
|
5082 |
|
|
return error_mark_node;
|
5083 |
|
|
}
|
5084 |
|
|
|
5085 |
|
|
return cp_convert (type, expr);
|
5086 |
|
|
}
|
5087 |
|
|
|
5088 |
|
|
tree
|
5089 |
|
|
build_reinterpret_cast (tree type, tree expr)
|
5090 |
|
|
{
|
5091 |
|
|
if (type == error_mark_node || expr == error_mark_node)
|
5092 |
|
|
return error_mark_node;
|
5093 |
|
|
|
5094 |
|
|
if (processing_template_decl)
|
5095 |
|
|
{
|
5096 |
|
|
tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
|
5097 |
|
|
|
5098 |
|
|
if (!TREE_SIDE_EFFECTS (t)
|
5099 |
|
|
&& type_dependent_expression_p (expr))
|
5100 |
|
|
/* There might turn out to be side effects inside expr. */
|
5101 |
|
|
TREE_SIDE_EFFECTS (t) = 1;
|
5102 |
|
|
return convert_from_reference (t);
|
5103 |
|
|
}
|
5104 |
|
|
|
5105 |
|
|
return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
|
5106 |
|
|
/*valid_p=*/NULL);
|
5107 |
|
|
}
|
5108 |
|
|
|
5109 |
|
|
/* Perform a const_cast from EXPR to TYPE. If the cast is valid,
|
5110 |
|
|
return an appropriate expression. Otherwise, return
|
5111 |
|
|
error_mark_node. If the cast is not valid, and COMPLAIN is true,
|
5112 |
|
|
then a diagnostic will be issued. If VALID_P is non-NULL, we are
|
5113 |
|
|
performing a C-style cast, its value upon return will indicate
|
5114 |
|
|
whether or not the conversion succeeded. */
|
5115 |
|
|
|
5116 |
|
|
static tree
|
5117 |
|
|
build_const_cast_1 (tree dst_type, tree expr, bool complain,
|
5118 |
|
|
bool *valid_p)
|
5119 |
|
|
{
|
5120 |
|
|
tree src_type;
|
5121 |
|
|
tree reference_type;
|
5122 |
|
|
|
5123 |
|
|
/* Callers are responsible for handling error_mark_node as a
|
5124 |
|
|
destination type. */
|
5125 |
|
|
gcc_assert (dst_type != error_mark_node);
|
5126 |
|
|
/* In a template, callers should be building syntactic
|
5127 |
|
|
representations of casts, not using this machinery. */
|
5128 |
|
|
gcc_assert (!processing_template_decl);
|
5129 |
|
|
|
5130 |
|
|
/* Assume the conversion is invalid. */
|
5131 |
|
|
if (valid_p)
|
5132 |
|
|
*valid_p = false;
|
5133 |
|
|
|
5134 |
|
|
if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
|
5135 |
|
|
{
|
5136 |
|
|
if (complain)
|
5137 |
|
|
error ("invalid use of const_cast with type %qT, "
|
5138 |
|
|
"which is not a pointer, "
|
5139 |
|
|
"reference, nor a pointer-to-data-member type", dst_type);
|
5140 |
|
|
return error_mark_node;
|
5141 |
|
|
}
|
5142 |
|
|
|
5143 |
|
|
if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
|
5144 |
|
|
{
|
5145 |
|
|
if (complain)
|
5146 |
|
|
error ("invalid use of const_cast with type %qT, which is a pointer "
|
5147 |
|
|
"or reference to a function type", dst_type);
|
5148 |
|
|
return error_mark_node;
|
5149 |
|
|
}
|
5150 |
|
|
|
5151 |
|
|
src_type = TREE_TYPE (expr);
|
5152 |
|
|
/* Expressions do not really have reference types. */
|
5153 |
|
|
if (TREE_CODE (src_type) == REFERENCE_TYPE)
|
5154 |
|
|
src_type = TREE_TYPE (src_type);
|
5155 |
|
|
|
5156 |
|
|
/* [expr.const.cast]
|
5157 |
|
|
|
5158 |
|
|
An lvalue of type T1 can be explicitly converted to an lvalue of
|
5159 |
|
|
type T2 using the cast const_cast<T2&> (where T1 and T2 are object
|
5160 |
|
|
types) if a pointer to T1 can be explicitly converted to the type
|
5161 |
|
|
pointer to T2 using a const_cast. */
|
5162 |
|
|
if (TREE_CODE (dst_type) == REFERENCE_TYPE)
|
5163 |
|
|
{
|
5164 |
|
|
reference_type = dst_type;
|
5165 |
|
|
if (! real_lvalue_p (expr))
|
5166 |
|
|
{
|
5167 |
|
|
if (complain)
|
5168 |
|
|
error ("invalid const_cast of an rvalue of type %qT to type %qT",
|
5169 |
|
|
src_type, dst_type);
|
5170 |
|
|
return error_mark_node;
|
5171 |
|
|
}
|
5172 |
|
|
dst_type = build_pointer_type (TREE_TYPE (dst_type));
|
5173 |
|
|
src_type = build_pointer_type (src_type);
|
5174 |
|
|
}
|
5175 |
|
|
else
|
5176 |
|
|
{
|
5177 |
|
|
reference_type = NULL_TREE;
|
5178 |
|
|
/* If the destination type is not a reference type, the
|
5179 |
|
|
lvalue-to-rvalue, array-to-pointer, and function-to-pointer
|
5180 |
|
|
conversions are performed. */
|
5181 |
|
|
src_type = type_decays_to (src_type);
|
5182 |
|
|
if (src_type == error_mark_node)
|
5183 |
|
|
return error_mark_node;
|
5184 |
|
|
}
|
5185 |
|
|
|
5186 |
|
|
if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
|
5187 |
|
|
&& comp_ptr_ttypes_const (dst_type, src_type))
|
5188 |
|
|
{
|
5189 |
|
|
if (valid_p)
|
5190 |
|
|
{
|
5191 |
|
|
*valid_p = true;
|
5192 |
|
|
/* This cast is actually a C-style cast. Issue a warning if
|
5193 |
|
|
the user is making a potentially unsafe cast. */
|
5194 |
|
|
if (warn_cast_qual)
|
5195 |
|
|
check_for_casting_away_constness (src_type, dst_type,
|
5196 |
|
|
warning0,
|
5197 |
|
|
"cast");
|
5198 |
|
|
}
|
5199 |
|
|
if (reference_type)
|
5200 |
|
|
{
|
5201 |
|
|
expr = build_unary_op (ADDR_EXPR, expr, 0);
|
5202 |
|
|
expr = build_nop (reference_type, expr);
|
5203 |
|
|
return convert_from_reference (expr);
|
5204 |
|
|
}
|
5205 |
|
|
else
|
5206 |
|
|
{
|
5207 |
|
|
expr = decay_conversion (expr);
|
5208 |
|
|
/* build_c_cast puts on a NOP_EXPR to make the result not an
|
5209 |
|
|
lvalue. Strip such NOP_EXPRs if VALUE is being used in
|
5210 |
|
|
non-lvalue context. */
|
5211 |
|
|
if (TREE_CODE (expr) == NOP_EXPR
|
5212 |
|
|
&& TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
|
5213 |
|
|
expr = TREE_OPERAND (expr, 0);
|
5214 |
|
|
return build_nop (dst_type, expr);
|
5215 |
|
|
}
|
5216 |
|
|
}
|
5217 |
|
|
|
5218 |
|
|
if (complain)
|
5219 |
|
|
error ("invalid const_cast from type %qT to type %qT",
|
5220 |
|
|
src_type, dst_type);
|
5221 |
|
|
return error_mark_node;
|
5222 |
|
|
}
|
5223 |
|
|
|
5224 |
|
|
tree
|
5225 |
|
|
build_const_cast (tree type, tree expr)
|
5226 |
|
|
{
|
5227 |
|
|
if (type == error_mark_node || error_operand_p (expr))
|
5228 |
|
|
return error_mark_node;
|
5229 |
|
|
|
5230 |
|
|
if (processing_template_decl)
|
5231 |
|
|
{
|
5232 |
|
|
tree t = build_min (CONST_CAST_EXPR, type, expr);
|
5233 |
|
|
|
5234 |
|
|
if (!TREE_SIDE_EFFECTS (t)
|
5235 |
|
|
&& type_dependent_expression_p (expr))
|
5236 |
|
|
/* There might turn out to be side effects inside expr. */
|
5237 |
|
|
TREE_SIDE_EFFECTS (t) = 1;
|
5238 |
|
|
return convert_from_reference (t);
|
5239 |
|
|
}
|
5240 |
|
|
|
5241 |
|
|
return build_const_cast_1 (type, expr, /*complain=*/true,
|
5242 |
|
|
/*valid_p=*/NULL);
|
5243 |
|
|
}
|
5244 |
|
|
|
5245 |
|
|
/* Build an expression representing an explicit C-style cast to type
|
5246 |
|
|
TYPE of expression EXPR. */
|
5247 |
|
|
|
5248 |
|
|
tree
|
5249 |
|
|
build_c_cast (tree type, tree expr)
|
5250 |
|
|
{
|
5251 |
|
|
tree value = expr;
|
5252 |
|
|
tree result;
|
5253 |
|
|
bool valid_p;
|
5254 |
|
|
|
5255 |
|
|
if (type == error_mark_node || error_operand_p (expr))
|
5256 |
|
|
return error_mark_node;
|
5257 |
|
|
|
5258 |
|
|
if (processing_template_decl)
|
5259 |
|
|
{
|
5260 |
|
|
tree t = build_min (CAST_EXPR, type,
|
5261 |
|
|
tree_cons (NULL_TREE, value, NULL_TREE));
|
5262 |
|
|
/* We don't know if it will or will not have side effects. */
|
5263 |
|
|
TREE_SIDE_EFFECTS (t) = 1;
|
5264 |
|
|
return convert_from_reference (t);
|
5265 |
|
|
}
|
5266 |
|
|
|
5267 |
|
|
/* Casts to a (pointer to a) specific ObjC class (or 'id' or
|
5268 |
|
|
'Class') should always be retained, because this information aids
|
5269 |
|
|
in method lookup. */
|
5270 |
|
|
if (objc_is_object_ptr (type)
|
5271 |
|
|
&& objc_is_object_ptr (TREE_TYPE (expr)))
|
5272 |
|
|
return build_nop (type, expr);
|
5273 |
|
|
|
5274 |
|
|
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
|
5275 |
|
|
Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
|
5276 |
|
|
if (TREE_CODE (type) != REFERENCE_TYPE
|
5277 |
|
|
&& TREE_CODE (value) == NOP_EXPR
|
5278 |
|
|
&& TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
|
5279 |
|
|
value = TREE_OPERAND (value, 0);
|
5280 |
|
|
|
5281 |
|
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
5282 |
|
|
{
|
5283 |
|
|
/* Allow casting from T1* to T2[] because Cfront allows it.
|
5284 |
|
|
NIHCL uses it. It is not valid ISO C++ however. */
|
5285 |
|
|
if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
|
5286 |
|
|
{
|
5287 |
|
|
pedwarn ("ISO C++ forbids casting to an array type %qT", type);
|
5288 |
|
|
type = build_pointer_type (TREE_TYPE (type));
|
5289 |
|
|
}
|
5290 |
|
|
else
|
5291 |
|
|
{
|
5292 |
|
|
error ("ISO C++ forbids casting to an array type %qT", type);
|
5293 |
|
|
return error_mark_node;
|
5294 |
|
|
}
|
5295 |
|
|
}
|
5296 |
|
|
|
5297 |
|
|
if (TREE_CODE (type) == FUNCTION_TYPE
|
5298 |
|
|
|| TREE_CODE (type) == METHOD_TYPE)
|
5299 |
|
|
{
|
5300 |
|
|
error ("invalid cast to function type %qT", type);
|
5301 |
|
|
return error_mark_node;
|
5302 |
|
|
}
|
5303 |
|
|
|
5304 |
|
|
/* A C-style cast can be a const_cast. */
|
5305 |
|
|
result = build_const_cast_1 (type, value, /*complain=*/false,
|
5306 |
|
|
&valid_p);
|
5307 |
|
|
if (valid_p)
|
5308 |
|
|
return result;
|
5309 |
|
|
|
5310 |
|
|
/* Or a static cast. */
|
5311 |
|
|
result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
|
5312 |
|
|
&valid_p);
|
5313 |
|
|
/* Or a reinterpret_cast. */
|
5314 |
|
|
if (!valid_p)
|
5315 |
|
|
result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
|
5316 |
|
|
&valid_p);
|
5317 |
|
|
/* The static_cast or reinterpret_cast may be followed by a
|
5318 |
|
|
const_cast. */
|
5319 |
|
|
if (valid_p
|
5320 |
|
|
/* A valid cast may result in errors if, for example, a
|
5321 |
|
|
conversion to am ambiguous base class is required. */
|
5322 |
|
|
&& !error_operand_p (result))
|
5323 |
|
|
{
|
5324 |
|
|
tree result_type;
|
5325 |
|
|
|
5326 |
|
|
/* Non-class rvalues always have cv-unqualified type. */
|
5327 |
|
|
if (!CLASS_TYPE_P (type))
|
5328 |
|
|
type = TYPE_MAIN_VARIANT (type);
|
5329 |
|
|
result_type = TREE_TYPE (result);
|
5330 |
|
|
if (!CLASS_TYPE_P (result_type))
|
5331 |
|
|
result_type = TYPE_MAIN_VARIANT (result_type);
|
5332 |
|
|
/* If the type of RESULT does not match TYPE, perform a
|
5333 |
|
|
const_cast to make it match. If the static_cast or
|
5334 |
|
|
reinterpret_cast succeeded, we will differ by at most
|
5335 |
|
|
cv-qualification, so the follow-on const_cast is guaranteed
|
5336 |
|
|
to succeed. */
|
5337 |
|
|
if (!same_type_p (non_reference (type), non_reference (result_type)))
|
5338 |
|
|
{
|
5339 |
|
|
result = build_const_cast_1 (type, result, false, &valid_p);
|
5340 |
|
|
gcc_assert (valid_p);
|
5341 |
|
|
}
|
5342 |
|
|
return result;
|
5343 |
|
|
}
|
5344 |
|
|
|
5345 |
|
|
return error_mark_node;
|
5346 |
|
|
}
|
5347 |
|
|
|
5348 |
|
|
/* Build an assignment expression of lvalue LHS from value RHS.
|
5349 |
|
|
MODIFYCODE is the code for a binary operator that we use
|
5350 |
|
|
to combine the old value of LHS with RHS to get the new value.
|
5351 |
|
|
Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
|
5352 |
|
|
|
5353 |
|
|
C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
|
5354 |
|
|
|
5355 |
|
|
tree
|
5356 |
|
|
build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
|
5357 |
|
|
{
|
5358 |
|
|
tree result;
|
5359 |
|
|
tree newrhs = rhs;
|
5360 |
|
|
tree lhstype = TREE_TYPE (lhs);
|
5361 |
|
|
tree olhstype = lhstype;
|
5362 |
|
|
tree olhs = NULL_TREE;
|
5363 |
|
|
bool plain_assign = (modifycode == NOP_EXPR);
|
5364 |
|
|
|
5365 |
|
|
/* Avoid duplicate error messages from operands that had errors. */
|
5366 |
|
|
if (lhs == error_mark_node || rhs == error_mark_node)
|
5367 |
|
|
return error_mark_node;
|
5368 |
|
|
|
5369 |
|
|
/* Handle control structure constructs used as "lvalues". */
|
5370 |
|
|
switch (TREE_CODE (lhs))
|
5371 |
|
|
{
|
5372 |
|
|
/* Handle --foo = 5; as these are valid constructs in C++. */
|
5373 |
|
|
case PREDECREMENT_EXPR:
|
5374 |
|
|
case PREINCREMENT_EXPR:
|
5375 |
|
|
if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
|
5376 |
|
|
lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
|
5377 |
|
|
stabilize_reference (TREE_OPERAND (lhs, 0)),
|
5378 |
|
|
TREE_OPERAND (lhs, 1));
|
5379 |
|
|
return build2 (COMPOUND_EXPR, lhstype,
|
5380 |
|
|
lhs,
|
5381 |
|
|
build_modify_expr (TREE_OPERAND (lhs, 0),
|
5382 |
|
|
modifycode, rhs));
|
5383 |
|
|
|
5384 |
|
|
/* Handle (a, b) used as an "lvalue". */
|
5385 |
|
|
case COMPOUND_EXPR:
|
5386 |
|
|
newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
|
5387 |
|
|
modifycode, rhs);
|
5388 |
|
|
if (newrhs == error_mark_node)
|
5389 |
|
|
return error_mark_node;
|
5390 |
|
|
return build2 (COMPOUND_EXPR, lhstype,
|
5391 |
|
|
TREE_OPERAND (lhs, 0), newrhs);
|
5392 |
|
|
|
5393 |
|
|
case MODIFY_EXPR:
|
5394 |
|
|
if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
|
5395 |
|
|
lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
|
5396 |
|
|
stabilize_reference (TREE_OPERAND (lhs, 0)),
|
5397 |
|
|
TREE_OPERAND (lhs, 1));
|
5398 |
|
|
newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
|
5399 |
|
|
if (newrhs == error_mark_node)
|
5400 |
|
|
return error_mark_node;
|
5401 |
|
|
return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
|
5402 |
|
|
|
5403 |
|
|
case MIN_EXPR:
|
5404 |
|
|
case MAX_EXPR:
|
5405 |
|
|
/* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
|
5406 |
|
|
when neither operand has side-effects. */
|
5407 |
|
|
if (!lvalue_or_else (lhs, lv_assign))
|
5408 |
|
|
return error_mark_node;
|
5409 |
|
|
|
5410 |
|
|
gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
|
5411 |
|
|
&& !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
|
5412 |
|
|
|
5413 |
|
|
lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
|
5414 |
|
|
build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
|
5415 |
|
|
boolean_type_node,
|
5416 |
|
|
TREE_OPERAND (lhs, 0),
|
5417 |
|
|
TREE_OPERAND (lhs, 1)),
|
5418 |
|
|
TREE_OPERAND (lhs, 0),
|
5419 |
|
|
TREE_OPERAND (lhs, 1));
|
5420 |
|
|
/* Fall through. */
|
5421 |
|
|
|
5422 |
|
|
/* Handle (a ? b : c) used as an "lvalue". */
|
5423 |
|
|
case COND_EXPR:
|
5424 |
|
|
{
|
5425 |
|
|
/* Produce (a ? (b = rhs) : (c = rhs))
|
5426 |
|
|
except that the RHS goes through a save-expr
|
5427 |
|
|
so the code to compute it is only emitted once. */
|
5428 |
|
|
tree cond;
|
5429 |
|
|
tree preeval = NULL_TREE;
|
5430 |
|
|
|
5431 |
|
|
rhs = stabilize_expr (rhs, &preeval);
|
5432 |
|
|
|
5433 |
|
|
/* Check this here to avoid odd errors when trying to convert
|
5434 |
|
|
a throw to the type of the COND_EXPR. */
|
5435 |
|
|
if (!lvalue_or_else (lhs, lv_assign))
|
5436 |
|
|
return error_mark_node;
|
5437 |
|
|
|
5438 |
|
|
cond = build_conditional_expr
|
5439 |
|
|
(TREE_OPERAND (lhs, 0),
|
5440 |
|
|
build_modify_expr (cp_convert (TREE_TYPE (lhs),
|
5441 |
|
|
TREE_OPERAND (lhs, 1)),
|
5442 |
|
|
modifycode, rhs),
|
5443 |
|
|
build_modify_expr (cp_convert (TREE_TYPE (lhs),
|
5444 |
|
|
TREE_OPERAND (lhs, 2)),
|
5445 |
|
|
modifycode, rhs));
|
5446 |
|
|
|
5447 |
|
|
if (cond == error_mark_node)
|
5448 |
|
|
return cond;
|
5449 |
|
|
/* Make sure the code to compute the rhs comes out
|
5450 |
|
|
before the split. */
|
5451 |
|
|
if (preeval)
|
5452 |
|
|
cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
|
5453 |
|
|
return cond;
|
5454 |
|
|
}
|
5455 |
|
|
|
5456 |
|
|
default:
|
5457 |
|
|
break;
|
5458 |
|
|
}
|
5459 |
|
|
|
5460 |
|
|
if (modifycode == INIT_EXPR)
|
5461 |
|
|
{
|
5462 |
|
|
if (TREE_CODE (rhs) == CONSTRUCTOR)
|
5463 |
|
|
{
|
5464 |
|
|
if (! same_type_p (TREE_TYPE (rhs), lhstype))
|
5465 |
|
|
/* Call convert to generate an error; see PR 11063. */
|
5466 |
|
|
rhs = convert (lhstype, rhs);
|
5467 |
|
|
result = build2 (INIT_EXPR, lhstype, lhs, rhs);
|
5468 |
|
|
TREE_SIDE_EFFECTS (result) = 1;
|
5469 |
|
|
return result;
|
5470 |
|
|
}
|
5471 |
|
|
else if (! IS_AGGR_TYPE (lhstype))
|
5472 |
|
|
/* Do the default thing. */;
|
5473 |
|
|
else
|
5474 |
|
|
{
|
5475 |
|
|
result = build_special_member_call (lhs, complete_ctor_identifier,
|
5476 |
|
|
build_tree_list (NULL_TREE, rhs),
|
5477 |
|
|
lhstype, LOOKUP_NORMAL);
|
5478 |
|
|
if (result == NULL_TREE)
|
5479 |
|
|
return error_mark_node;
|
5480 |
|
|
return result;
|
5481 |
|
|
}
|
5482 |
|
|
}
|
5483 |
|
|
else
|
5484 |
|
|
{
|
5485 |
|
|
lhs = require_complete_type (lhs);
|
5486 |
|
|
if (lhs == error_mark_node)
|
5487 |
|
|
return error_mark_node;
|
5488 |
|
|
|
5489 |
|
|
if (modifycode == NOP_EXPR)
|
5490 |
|
|
{
|
5491 |
|
|
/* `operator=' is not an inheritable operator. */
|
5492 |
|
|
if (! IS_AGGR_TYPE (lhstype))
|
5493 |
|
|
/* Do the default thing. */;
|
5494 |
|
|
else
|
5495 |
|
|
{
|
5496 |
|
|
result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
|
5497 |
|
|
lhs, rhs, make_node (NOP_EXPR),
|
5498 |
|
|
/*overloaded_p=*/NULL);
|
5499 |
|
|
if (result == NULL_TREE)
|
5500 |
|
|
return error_mark_node;
|
5501 |
|
|
return result;
|
5502 |
|
|
}
|
5503 |
|
|
lhstype = olhstype;
|
5504 |
|
|
}
|
5505 |
|
|
else
|
5506 |
|
|
{
|
5507 |
|
|
/* A binary op has been requested. Combine the old LHS
|
5508 |
|
|
value with the RHS producing the value we should actually
|
5509 |
|
|
store into the LHS. */
|
5510 |
|
|
|
5511 |
|
|
gcc_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE));
|
5512 |
|
|
lhs = stabilize_reference (lhs);
|
5513 |
|
|
newrhs = cp_build_binary_op (modifycode, lhs, rhs);
|
5514 |
|
|
if (newrhs == error_mark_node)
|
5515 |
|
|
{
|
5516 |
|
|
error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode,
|
5517 |
|
|
TREE_TYPE (lhs), TREE_TYPE (rhs));
|
5518 |
|
|
return error_mark_node;
|
5519 |
|
|
}
|
5520 |
|
|
|
5521 |
|
|
/* Now it looks like a plain assignment. */
|
5522 |
|
|
modifycode = NOP_EXPR;
|
5523 |
|
|
}
|
5524 |
|
|
gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
|
5525 |
|
|
gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
|
5526 |
|
|
}
|
5527 |
|
|
|
5528 |
|
|
/* The left-hand side must be an lvalue. */
|
5529 |
|
|
if (!lvalue_or_else (lhs, lv_assign))
|
5530 |
|
|
return error_mark_node;
|
5531 |
|
|
|
5532 |
|
|
/* Warn about modifying something that is `const'. Don't warn if
|
5533 |
|
|
this is initialization. */
|
5534 |
|
|
if (modifycode != INIT_EXPR
|
5535 |
|
|
&& (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
|
5536 |
|
|
/* Functions are not modifiable, even though they are
|
5537 |
|
|
lvalues. */
|
5538 |
|
|
|| TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
|
5539 |
|
|
|| TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
|
5540 |
|
|
/* If it's an aggregate and any field is const, then it is
|
5541 |
|
|
effectively const. */
|
5542 |
|
|
|| (CLASS_TYPE_P (lhstype)
|
5543 |
|
|
&& C_TYPE_FIELDS_READONLY (lhstype))))
|
5544 |
|
|
readonly_error (lhs, "assignment", 0);
|
5545 |
|
|
|
5546 |
|
|
/* If storing into a structure or union member, it has probably been
|
5547 |
|
|
given type `int'. Compute the type that would go with the actual
|
5548 |
|
|
amount of storage the member occupies. */
|
5549 |
|
|
|
5550 |
|
|
if (TREE_CODE (lhs) == COMPONENT_REF
|
5551 |
|
|
&& (TREE_CODE (lhstype) == INTEGER_TYPE
|
5552 |
|
|
|| TREE_CODE (lhstype) == REAL_TYPE
|
5553 |
|
|
|| TREE_CODE (lhstype) == ENUMERAL_TYPE))
|
5554 |
|
|
{
|
5555 |
|
|
lhstype = TREE_TYPE (get_unwidened (lhs, 0));
|
5556 |
|
|
|
5557 |
|
|
/* If storing in a field that is in actuality a short or narrower
|
5558 |
|
|
than one, we must store in the field in its actual type. */
|
5559 |
|
|
|
5560 |
|
|
if (lhstype != TREE_TYPE (lhs))
|
5561 |
|
|
{
|
5562 |
|
|
/* Avoid warnings converting integral types back into enums for
|
5563 |
|
|
enum bit fields. */
|
5564 |
|
|
if (TREE_CODE (lhstype) == INTEGER_TYPE
|
5565 |
|
|
&& TREE_CODE (olhstype) == ENUMERAL_TYPE)
|
5566 |
|
|
{
|
5567 |
|
|
if (TREE_SIDE_EFFECTS (lhs))
|
5568 |
|
|
lhs = stabilize_reference (lhs);
|
5569 |
|
|
olhs = lhs;
|
5570 |
|
|
}
|
5571 |
|
|
lhs = copy_node (lhs);
|
5572 |
|
|
TREE_TYPE (lhs) = lhstype;
|
5573 |
|
|
}
|
5574 |
|
|
}
|
5575 |
|
|
|
5576 |
|
|
/* Convert new value to destination type. */
|
5577 |
|
|
|
5578 |
|
|
if (TREE_CODE (lhstype) == ARRAY_TYPE)
|
5579 |
|
|
{
|
5580 |
|
|
int from_array;
|
5581 |
|
|
|
5582 |
|
|
if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
|
5583 |
|
|
TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
|
5584 |
|
|
{
|
5585 |
|
|
error ("incompatible types in assignment of %qT to %qT",
|
5586 |
|
|
TREE_TYPE (rhs), lhstype);
|
5587 |
|
|
return error_mark_node;
|
5588 |
|
|
}
|
5589 |
|
|
|
5590 |
|
|
/* Allow array assignment in compiler-generated code. */
|
5591 |
|
|
if (! DECL_ARTIFICIAL (current_function_decl))
|
5592 |
|
|
pedwarn ("ISO C++ forbids assignment of arrays");
|
5593 |
|
|
|
5594 |
|
|
from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
|
5595 |
|
|
? 1 + (modifycode != INIT_EXPR): 0;
|
5596 |
|
|
return build_vec_init (lhs, NULL_TREE, newrhs,
|
5597 |
|
|
/*explicit_default_init_p=*/false,
|
5598 |
|
|
from_array);
|
5599 |
|
|
}
|
5600 |
|
|
|
5601 |
|
|
if (modifycode == INIT_EXPR)
|
5602 |
|
|
newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
|
5603 |
|
|
"initialization", NULL_TREE, 0);
|
5604 |
|
|
else
|
5605 |
|
|
{
|
5606 |
|
|
/* Avoid warnings on enum bit fields. */
|
5607 |
|
|
if (TREE_CODE (olhstype) == ENUMERAL_TYPE
|
5608 |
|
|
&& TREE_CODE (lhstype) == INTEGER_TYPE)
|
5609 |
|
|
{
|
5610 |
|
|
newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
|
5611 |
|
|
NULL_TREE, 0);
|
5612 |
|
|
newrhs = convert_force (lhstype, newrhs, 0);
|
5613 |
|
|
}
|
5614 |
|
|
else
|
5615 |
|
|
newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
|
5616 |
|
|
NULL_TREE, 0);
|
5617 |
|
|
if (TREE_CODE (newrhs) == CALL_EXPR
|
5618 |
|
|
&& TYPE_NEEDS_CONSTRUCTING (lhstype))
|
5619 |
|
|
newrhs = build_cplus_new (lhstype, newrhs);
|
5620 |
|
|
|
5621 |
|
|
/* Can't initialize directly from a TARGET_EXPR, since that would
|
5622 |
|
|
cause the lhs to be constructed twice, and possibly result in
|
5623 |
|
|
accidental self-initialization. So we force the TARGET_EXPR to be
|
5624 |
|
|
expanded without a target. */
|
5625 |
|
|
if (TREE_CODE (newrhs) == TARGET_EXPR)
|
5626 |
|
|
newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
|
5627 |
|
|
TREE_OPERAND (newrhs, 0));
|
5628 |
|
|
}
|
5629 |
|
|
|
5630 |
|
|
if (newrhs == error_mark_node)
|
5631 |
|
|
return error_mark_node;
|
5632 |
|
|
|
5633 |
|
|
if (TREE_CODE (lhs) == COMPONENT_REF)
|
5634 |
|
|
newrhs = adjust_bitfield_initializer (TREE_OPERAND (lhs, 1),
|
5635 |
|
|
newrhs);
|
5636 |
|
|
|
5637 |
|
|
if (c_dialect_objc () && flag_objc_gc)
|
5638 |
|
|
{
|
5639 |
|
|
result = objc_generate_write_barrier (lhs, modifycode, newrhs);
|
5640 |
|
|
|
5641 |
|
|
if (result)
|
5642 |
|
|
return result;
|
5643 |
|
|
}
|
5644 |
|
|
|
5645 |
|
|
result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
|
5646 |
|
|
lhstype, lhs, newrhs);
|
5647 |
|
|
|
5648 |
|
|
TREE_SIDE_EFFECTS (result) = 1;
|
5649 |
|
|
if (!plain_assign)
|
5650 |
|
|
TREE_NO_WARNING (result) = 1;
|
5651 |
|
|
|
5652 |
|
|
/* If we got the LHS in a different type for storing in,
|
5653 |
|
|
convert the result back to the nominal type of LHS
|
5654 |
|
|
so that the value we return always has the same type
|
5655 |
|
|
as the LHS argument. */
|
5656 |
|
|
|
5657 |
|
|
if (olhstype == TREE_TYPE (result))
|
5658 |
|
|
return result;
|
5659 |
|
|
if (olhs)
|
5660 |
|
|
{
|
5661 |
|
|
result = build2 (COMPOUND_EXPR, olhstype, result, olhs);
|
5662 |
|
|
TREE_NO_WARNING (result) = 1;
|
5663 |
|
|
return result;
|
5664 |
|
|
}
|
5665 |
|
|
return convert_for_assignment (olhstype, result, "assignment",
|
5666 |
|
|
NULL_TREE, 0);
|
5667 |
|
|
}
|
5668 |
|
|
|
5669 |
|
|
tree
|
5670 |
|
|
build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
|
5671 |
|
|
{
|
5672 |
|
|
if (processing_template_decl)
|
5673 |
|
|
return build_min_nt (MODOP_EXPR, lhs,
|
5674 |
|
|
build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
|
5675 |
|
|
|
5676 |
|
|
if (modifycode != NOP_EXPR)
|
5677 |
|
|
{
|
5678 |
|
|
tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
|
5679 |
|
|
make_node (modifycode),
|
5680 |
|
|
/*overloaded_p=*/NULL);
|
5681 |
|
|
if (rval)
|
5682 |
|
|
{
|
5683 |
|
|
TREE_NO_WARNING (rval) = 1;
|
5684 |
|
|
return rval;
|
5685 |
|
|
}
|
5686 |
|
|
}
|
5687 |
|
|
return build_modify_expr (lhs, modifycode, rhs);
|
5688 |
|
|
}
|
5689 |
|
|
|
5690 |
|
|
|
5691 |
|
|
/* Get difference in deltas for different pointer to member function
|
5692 |
|
|
types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
|
5693 |
|
|
the conversion is invalid, the constant is zero. If
|
5694 |
|
|
ALLOW_INVERSE_P is true, then allow reverse conversions as well.
|
5695 |
|
|
If C_CAST_P is true this conversion is taking place as part of a
|
5696 |
|
|
C-style cast.
|
5697 |
|
|
|
5698 |
|
|
Note that the naming of FROM and TO is kind of backwards; the return
|
5699 |
|
|
value is what we add to a TO in order to get a FROM. They are named
|
5700 |
|
|
this way because we call this function to find out how to convert from
|
5701 |
|
|
a pointer to member of FROM to a pointer to member of TO. */
|
5702 |
|
|
|
5703 |
|
|
static tree
|
5704 |
|
|
get_delta_difference (tree from, tree to,
|
5705 |
|
|
bool allow_inverse_p,
|
5706 |
|
|
bool c_cast_p)
|
5707 |
|
|
{
|
5708 |
|
|
tree binfo;
|
5709 |
|
|
base_kind kind;
|
5710 |
|
|
tree result;
|
5711 |
|
|
|
5712 |
|
|
/* Assume no conversion is required. */
|
5713 |
|
|
result = integer_zero_node;
|
5714 |
|
|
binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
|
5715 |
|
|
if (kind == bk_inaccessible || kind == bk_ambig)
|
5716 |
|
|
error (" in pointer to member function conversion");
|
5717 |
|
|
else if (binfo)
|
5718 |
|
|
{
|
5719 |
|
|
if (kind != bk_via_virtual)
|
5720 |
|
|
result = BINFO_OFFSET (binfo);
|
5721 |
|
|
else
|
5722 |
|
|
{
|
5723 |
|
|
tree virt_binfo = binfo_from_vbase (binfo);
|
5724 |
|
|
|
5725 |
|
|
/* This is a reinterpret cast, we choose to do nothing. */
|
5726 |
|
|
if (allow_inverse_p)
|
5727 |
|
|
warning (0, "pointer to member cast via virtual base %qT",
|
5728 |
|
|
BINFO_TYPE (virt_binfo));
|
5729 |
|
|
else
|
5730 |
|
|
error ("pointer to member conversion via virtual base %qT",
|
5731 |
|
|
BINFO_TYPE (virt_binfo));
|
5732 |
|
|
}
|
5733 |
|
|
}
|
5734 |
|
|
else if (same_type_ignoring_top_level_qualifiers_p (from, to))
|
5735 |
|
|
/* Pointer to member of incomplete class is permitted*/;
|
5736 |
|
|
else if (!allow_inverse_p)
|
5737 |
|
|
{
|
5738 |
|
|
error_not_base_type (from, to);
|
5739 |
|
|
error (" in pointer to member conversion");
|
5740 |
|
|
}
|
5741 |
|
|
else
|
5742 |
|
|
{
|
5743 |
|
|
binfo = lookup_base (from, to, c_cast_p ? ba_unique : ba_check, &kind);
|
5744 |
|
|
if (binfo)
|
5745 |
|
|
{
|
5746 |
|
|
if (kind != bk_via_virtual)
|
5747 |
|
|
result = size_diffop (size_zero_node, BINFO_OFFSET (binfo));
|
5748 |
|
|
else
|
5749 |
|
|
{
|
5750 |
|
|
/* This is a reinterpret cast, we choose to do nothing. */
|
5751 |
|
|
tree virt_binfo = binfo_from_vbase (binfo);
|
5752 |
|
|
|
5753 |
|
|
warning (0, "pointer to member cast via virtual base %qT",
|
5754 |
|
|
BINFO_TYPE (virt_binfo));
|
5755 |
|
|
}
|
5756 |
|
|
}
|
5757 |
|
|
}
|
5758 |
|
|
|
5759 |
|
|
return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
|
5760 |
|
|
result));
|
5761 |
|
|
}
|
5762 |
|
|
|
5763 |
|
|
/* Return a constructor for the pointer-to-member-function TYPE using
|
5764 |
|
|
the other components as specified. */
|
5765 |
|
|
|
5766 |
|
|
tree
|
5767 |
|
|
build_ptrmemfunc1 (tree type, tree delta, tree pfn)
|
5768 |
|
|
{
|
5769 |
|
|
tree u = NULL_TREE;
|
5770 |
|
|
tree delta_field;
|
5771 |
|
|
tree pfn_field;
|
5772 |
|
|
VEC(constructor_elt, gc) *v;
|
5773 |
|
|
|
5774 |
|
|
/* Pull the FIELD_DECLs out of the type. */
|
5775 |
|
|
pfn_field = TYPE_FIELDS (type);
|
5776 |
|
|
delta_field = TREE_CHAIN (pfn_field);
|
5777 |
|
|
|
5778 |
|
|
/* Make sure DELTA has the type we want. */
|
5779 |
|
|
delta = convert_and_check (delta_type_node, delta);
|
5780 |
|
|
|
5781 |
|
|
/* Finish creating the initializer. */
|
5782 |
|
|
v = VEC_alloc(constructor_elt, gc, 2);
|
5783 |
|
|
CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn);
|
5784 |
|
|
CONSTRUCTOR_APPEND_ELT(v, delta_field, delta);
|
5785 |
|
|
u = build_constructor (type, v);
|
5786 |
|
|
TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
|
5787 |
|
|
TREE_INVARIANT (u) = TREE_INVARIANT (pfn) & TREE_INVARIANT (delta);
|
5788 |
|
|
TREE_STATIC (u) = (TREE_CONSTANT (u)
|
5789 |
|
|
&& (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
|
5790 |
|
|
!= NULL_TREE)
|
5791 |
|
|
&& (initializer_constant_valid_p (delta, TREE_TYPE (delta))
|
5792 |
|
|
!= NULL_TREE));
|
5793 |
|
|
return u;
|
5794 |
|
|
}
|
5795 |
|
|
|
5796 |
|
|
/* Build a constructor for a pointer to member function. It can be
|
5797 |
|
|
used to initialize global variables, local variable, or used
|
5798 |
|
|
as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
|
5799 |
|
|
want to be.
|
5800 |
|
|
|
5801 |
|
|
If FORCE is nonzero, then force this conversion, even if
|
5802 |
|
|
we would rather not do it. Usually set when using an explicit
|
5803 |
|
|
cast. A C-style cast is being processed iff C_CAST_P is true.
|
5804 |
|
|
|
5805 |
|
|
Return error_mark_node, if something goes wrong. */
|
5806 |
|
|
|
5807 |
|
|
tree
|
5808 |
|
|
build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
|
5809 |
|
|
{
|
5810 |
|
|
tree fn;
|
5811 |
|
|
tree pfn_type;
|
5812 |
|
|
tree to_type;
|
5813 |
|
|
|
5814 |
|
|
if (error_operand_p (pfn))
|
5815 |
|
|
return error_mark_node;
|
5816 |
|
|
|
5817 |
|
|
pfn_type = TREE_TYPE (pfn);
|
5818 |
|
|
to_type = build_ptrmemfunc_type (type);
|
5819 |
|
|
|
5820 |
|
|
/* Handle multiple conversions of pointer to member functions. */
|
5821 |
|
|
if (TYPE_PTRMEMFUNC_P (pfn_type))
|
5822 |
|
|
{
|
5823 |
|
|
tree delta = NULL_TREE;
|
5824 |
|
|
tree npfn = NULL_TREE;
|
5825 |
|
|
tree n;
|
5826 |
|
|
|
5827 |
|
|
if (!force
|
5828 |
|
|
&& !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL))
|
5829 |
|
|
error ("invalid conversion to type %qT from type %qT",
|
5830 |
|
|
to_type, pfn_type);
|
5831 |
|
|
|
5832 |
|
|
n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
|
5833 |
|
|
TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
|
5834 |
|
|
force,
|
5835 |
|
|
c_cast_p);
|
5836 |
|
|
|
5837 |
|
|
/* We don't have to do any conversion to convert a
|
5838 |
|
|
pointer-to-member to its own type. But, we don't want to
|
5839 |
|
|
just return a PTRMEM_CST if there's an explicit cast; that
|
5840 |
|
|
cast should make the expression an invalid template argument. */
|
5841 |
|
|
if (TREE_CODE (pfn) != PTRMEM_CST)
|
5842 |
|
|
{
|
5843 |
|
|
if (same_type_p (to_type, pfn_type))
|
5844 |
|
|
return pfn;
|
5845 |
|
|
else if (integer_zerop (n))
|
5846 |
|
|
return build_reinterpret_cast (to_type, pfn);
|
5847 |
|
|
}
|
5848 |
|
|
|
5849 |
|
|
if (TREE_SIDE_EFFECTS (pfn))
|
5850 |
|
|
pfn = save_expr (pfn);
|
5851 |
|
|
|
5852 |
|
|
/* Obtain the function pointer and the current DELTA. */
|
5853 |
|
|
if (TREE_CODE (pfn) == PTRMEM_CST)
|
5854 |
|
|
expand_ptrmemfunc_cst (pfn, &delta, &npfn);
|
5855 |
|
|
else
|
5856 |
|
|
{
|
5857 |
|
|
npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
|
5858 |
|
|
delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
|
5859 |
|
|
}
|
5860 |
|
|
|
5861 |
|
|
/* Just adjust the DELTA field. */
|
5862 |
|
|
gcc_assert (same_type_ignoring_top_level_qualifiers_p
|
5863 |
|
|
(TREE_TYPE (delta), ptrdiff_type_node));
|
5864 |
|
|
if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
|
5865 |
|
|
n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
|
5866 |
|
|
delta = cp_build_binary_op (PLUS_EXPR, delta, n);
|
5867 |
|
|
return build_ptrmemfunc1 (to_type, delta, npfn);
|
5868 |
|
|
}
|
5869 |
|
|
|
5870 |
|
|
/* Handle null pointer to member function conversions. */
|
5871 |
|
|
if (integer_zerop (pfn))
|
5872 |
|
|
{
|
5873 |
|
|
pfn = build_c_cast (type, integer_zero_node);
|
5874 |
|
|
return build_ptrmemfunc1 (to_type,
|
5875 |
|
|
integer_zero_node,
|
5876 |
|
|
pfn);
|
5877 |
|
|
}
|
5878 |
|
|
|
5879 |
|
|
if (type_unknown_p (pfn))
|
5880 |
|
|
return instantiate_type (type, pfn, tf_error | tf_warning);
|
5881 |
|
|
|
5882 |
|
|
fn = TREE_OPERAND (pfn, 0);
|
5883 |
|
|
gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
|
5884 |
|
|
/* In a template, we will have preserved the
|
5885 |
|
|
OFFSET_REF. */
|
5886 |
|
|
|| (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
|
5887 |
|
|
return make_ptrmem_cst (to_type, fn);
|
5888 |
|
|
}
|
5889 |
|
|
|
5890 |
|
|
/* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
|
5891 |
|
|
given by CST.
|
5892 |
|
|
|
5893 |
|
|
??? There is no consistency as to the types returned for the above
|
5894 |
|
|
values. Some code acts as if it were a sizetype and some as if it were
|
5895 |
|
|
integer_type_node. */
|
5896 |
|
|
|
5897 |
|
|
void
|
5898 |
|
|
expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
|
5899 |
|
|
{
|
5900 |
|
|
tree type = TREE_TYPE (cst);
|
5901 |
|
|
tree fn = PTRMEM_CST_MEMBER (cst);
|
5902 |
|
|
tree ptr_class, fn_class;
|
5903 |
|
|
|
5904 |
|
|
gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
|
5905 |
|
|
|
5906 |
|
|
/* The class that the function belongs to. */
|
5907 |
|
|
fn_class = DECL_CONTEXT (fn);
|
5908 |
|
|
|
5909 |
|
|
/* The class that we're creating a pointer to member of. */
|
5910 |
|
|
ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
|
5911 |
|
|
|
5912 |
|
|
/* First, calculate the adjustment to the function's class. */
|
5913 |
|
|
*delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
|
5914 |
|
|
/*c_cast_p=*/0);
|
5915 |
|
|
|
5916 |
|
|
if (!DECL_VIRTUAL_P (fn))
|
5917 |
|
|
*pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
|
5918 |
|
|
else
|
5919 |
|
|
{
|
5920 |
|
|
/* If we're dealing with a virtual function, we have to adjust 'this'
|
5921 |
|
|
again, to point to the base which provides the vtable entry for
|
5922 |
|
|
fn; the call will do the opposite adjustment. */
|
5923 |
|
|
tree orig_class = DECL_CONTEXT (fn);
|
5924 |
|
|
tree binfo = binfo_or_else (orig_class, fn_class);
|
5925 |
|
|
*delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
|
5926 |
|
|
*delta, BINFO_OFFSET (binfo));
|
5927 |
|
|
*delta = fold_if_not_in_template (*delta);
|
5928 |
|
|
|
5929 |
|
|
/* We set PFN to the vtable offset at which the function can be
|
5930 |
|
|
found, plus one (unless ptrmemfunc_vbit_in_delta, in which
|
5931 |
|
|
case delta is shifted left, and then incremented). */
|
5932 |
|
|
*pfn = DECL_VINDEX (fn);
|
5933 |
|
|
*pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
|
5934 |
|
|
TYPE_SIZE_UNIT (vtable_entry_type));
|
5935 |
|
|
*pfn = fold_if_not_in_template (*pfn);
|
5936 |
|
|
|
5937 |
|
|
switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
|
5938 |
|
|
{
|
5939 |
|
|
case ptrmemfunc_vbit_in_pfn:
|
5940 |
|
|
*pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
|
5941 |
|
|
integer_one_node);
|
5942 |
|
|
*pfn = fold_if_not_in_template (*pfn);
|
5943 |
|
|
break;
|
5944 |
|
|
|
5945 |
|
|
case ptrmemfunc_vbit_in_delta:
|
5946 |
|
|
*delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
|
5947 |
|
|
*delta, integer_one_node);
|
5948 |
|
|
*delta = fold_if_not_in_template (*delta);
|
5949 |
|
|
*delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
|
5950 |
|
|
*delta, integer_one_node);
|
5951 |
|
|
*delta = fold_if_not_in_template (*delta);
|
5952 |
|
|
break;
|
5953 |
|
|
|
5954 |
|
|
default:
|
5955 |
|
|
gcc_unreachable ();
|
5956 |
|
|
}
|
5957 |
|
|
|
5958 |
|
|
*pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
|
5959 |
|
|
*pfn = fold_if_not_in_template (*pfn);
|
5960 |
|
|
}
|
5961 |
|
|
}
|
5962 |
|
|
|
5963 |
|
|
/* Return an expression for PFN from the pointer-to-member function
|
5964 |
|
|
given by T. */
|
5965 |
|
|
|
5966 |
|
|
tree
|
5967 |
|
|
pfn_from_ptrmemfunc (tree t)
|
5968 |
|
|
{
|
5969 |
|
|
if (TREE_CODE (t) == PTRMEM_CST)
|
5970 |
|
|
{
|
5971 |
|
|
tree delta;
|
5972 |
|
|
tree pfn;
|
5973 |
|
|
|
5974 |
|
|
expand_ptrmemfunc_cst (t, &delta, &pfn);
|
5975 |
|
|
if (pfn)
|
5976 |
|
|
return pfn;
|
5977 |
|
|
}
|
5978 |
|
|
|
5979 |
|
|
return build_ptrmemfunc_access_expr (t, pfn_identifier);
|
5980 |
|
|
}
|
5981 |
|
|
|
5982 |
|
|
/* Convert value RHS to type TYPE as preparation for an assignment to
|
5983 |
|
|
an lvalue of type TYPE. ERRTYPE is a string to use in error
|
5984 |
|
|
messages: "assignment", "return", etc. If FNDECL is non-NULL, we
|
5985 |
|
|
are doing the conversion in order to pass the PARMNUMth argument of
|
5986 |
|
|
FNDECL. */
|
5987 |
|
|
|
5988 |
|
|
static tree
|
5989 |
|
|
convert_for_assignment (tree type, tree rhs,
|
5990 |
|
|
const char *errtype, tree fndecl, int parmnum)
|
5991 |
|
|
{
|
5992 |
|
|
tree rhstype;
|
5993 |
|
|
enum tree_code coder;
|
5994 |
|
|
|
5995 |
|
|
/* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
|
5996 |
|
|
if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
|
5997 |
|
|
rhs = TREE_OPERAND (rhs, 0);
|
5998 |
|
|
|
5999 |
|
|
rhstype = TREE_TYPE (rhs);
|
6000 |
|
|
coder = TREE_CODE (rhstype);
|
6001 |
|
|
|
6002 |
|
|
if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
|
6003 |
|
|
&& vector_types_convertible_p (type, rhstype))
|
6004 |
|
|
return convert (type, rhs);
|
6005 |
|
|
|
6006 |
|
|
if (rhs == error_mark_node || rhstype == error_mark_node)
|
6007 |
|
|
return error_mark_node;
|
6008 |
|
|
if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
|
6009 |
|
|
return error_mark_node;
|
6010 |
|
|
|
6011 |
|
|
/* The RHS of an assignment cannot have void type. */
|
6012 |
|
|
if (coder == VOID_TYPE)
|
6013 |
|
|
{
|
6014 |
|
|
error ("void value not ignored as it ought to be");
|
6015 |
|
|
return error_mark_node;
|
6016 |
|
|
}
|
6017 |
|
|
|
6018 |
|
|
/* Simplify the RHS if possible. */
|
6019 |
|
|
if (TREE_CODE (rhs) == CONST_DECL)
|
6020 |
|
|
rhs = DECL_INITIAL (rhs);
|
6021 |
|
|
|
6022 |
|
|
if (c_dialect_objc ())
|
6023 |
|
|
{
|
6024 |
|
|
int parmno;
|
6025 |
|
|
tree rname = fndecl;
|
6026 |
|
|
|
6027 |
|
|
if (!strcmp (errtype, "assignment"))
|
6028 |
|
|
parmno = -1;
|
6029 |
|
|
else if (!strcmp (errtype, "initialization"))
|
6030 |
|
|
parmno = -2;
|
6031 |
|
|
else
|
6032 |
|
|
{
|
6033 |
|
|
tree selector = objc_message_selector ();
|
6034 |
|
|
|
6035 |
|
|
parmno = parmnum;
|
6036 |
|
|
|
6037 |
|
|
if (selector && parmno > 1)
|
6038 |
|
|
{
|
6039 |
|
|
rname = selector;
|
6040 |
|
|
parmno -= 1;
|
6041 |
|
|
}
|
6042 |
|
|
}
|
6043 |
|
|
|
6044 |
|
|
if (objc_compare_types (type, rhstype, parmno, rname))
|
6045 |
|
|
return convert (type, rhs);
|
6046 |
|
|
}
|
6047 |
|
|
|
6048 |
|
|
/* [expr.ass]
|
6049 |
|
|
|
6050 |
|
|
The expression is implicitly converted (clause _conv_) to the
|
6051 |
|
|
cv-unqualified type of the left operand.
|
6052 |
|
|
|
6053 |
|
|
We allow bad conversions here because by the time we get to this point
|
6054 |
|
|
we are committed to doing the conversion. If we end up doing a bad
|
6055 |
|
|
conversion, convert_like will complain. */
|
6056 |
|
|
if (!can_convert_arg_bad (type, rhstype, rhs))
|
6057 |
|
|
{
|
6058 |
|
|
/* When -Wno-pmf-conversions is use, we just silently allow
|
6059 |
|
|
conversions from pointers-to-members to plain pointers. If
|
6060 |
|
|
the conversion doesn't work, cp_convert will complain. */
|
6061 |
|
|
if (!warn_pmf2ptr
|
6062 |
|
|
&& TYPE_PTR_P (type)
|
6063 |
|
|
&& TYPE_PTRMEMFUNC_P (rhstype))
|
6064 |
|
|
rhs = cp_convert (strip_top_quals (type), rhs);
|
6065 |
|
|
else
|
6066 |
|
|
{
|
6067 |
|
|
/* If the right-hand side has unknown type, then it is an
|
6068 |
|
|
overloaded function. Call instantiate_type to get error
|
6069 |
|
|
messages. */
|
6070 |
|
|
if (rhstype == unknown_type_node)
|
6071 |
|
|
instantiate_type (type, rhs, tf_error | tf_warning);
|
6072 |
|
|
else if (fndecl)
|
6073 |
|
|
error ("cannot convert %qT to %qT for argument %qP to %qD",
|
6074 |
|
|
rhstype, type, parmnum, fndecl);
|
6075 |
|
|
else
|
6076 |
|
|
error ("cannot convert %qT to %qT in %s", rhstype, type, errtype);
|
6077 |
|
|
return error_mark_node;
|
6078 |
|
|
}
|
6079 |
|
|
}
|
6080 |
|
|
if (warn_missing_format_attribute)
|
6081 |
|
|
{
|
6082 |
|
|
const enum tree_code codel = TREE_CODE (type);
|
6083 |
|
|
if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
|
6084 |
|
|
&& coder == codel
|
6085 |
|
|
&& check_missing_format_attribute (type, rhstype))
|
6086 |
|
|
warning (OPT_Wmissing_format_attribute,
|
6087 |
|
|
"%s might be a candidate for a format attribute",
|
6088 |
|
|
errtype);
|
6089 |
|
|
}
|
6090 |
|
|
|
6091 |
|
|
return perform_implicit_conversion (strip_top_quals (type), rhs);
|
6092 |
|
|
}
|
6093 |
|
|
|
6094 |
|
|
/* Convert RHS to be of type TYPE.
|
6095 |
|
|
If EXP is nonzero, it is the target of the initialization.
|
6096 |
|
|
ERRTYPE is a string to use in error messages.
|
6097 |
|
|
|
6098 |
|
|
Two major differences between the behavior of
|
6099 |
|
|
`convert_for_assignment' and `convert_for_initialization'
|
6100 |
|
|
are that references are bashed in the former, while
|
6101 |
|
|
copied in the latter, and aggregates are assigned in
|
6102 |
|
|
the former (operator=) while initialized in the
|
6103 |
|
|
latter (X(X&)).
|
6104 |
|
|
|
6105 |
|
|
If using constructor make sure no conversion operator exists, if one does
|
6106 |
|
|
exist, an ambiguity exists.
|
6107 |
|
|
|
6108 |
|
|
If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
|
6109 |
|
|
|
6110 |
|
|
tree
|
6111 |
|
|
convert_for_initialization (tree exp, tree type, tree rhs, int flags,
|
6112 |
|
|
const char *errtype, tree fndecl, int parmnum)
|
6113 |
|
|
{
|
6114 |
|
|
enum tree_code codel = TREE_CODE (type);
|
6115 |
|
|
tree rhstype;
|
6116 |
|
|
enum tree_code coder;
|
6117 |
|
|
|
6118 |
|
|
/* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
|
6119 |
|
|
Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
|
6120 |
|
|
if (TREE_CODE (rhs) == NOP_EXPR
|
6121 |
|
|
&& TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
|
6122 |
|
|
&& codel != REFERENCE_TYPE)
|
6123 |
|
|
rhs = TREE_OPERAND (rhs, 0);
|
6124 |
|
|
|
6125 |
|
|
if (rhs == error_mark_node
|
6126 |
|
|
|| (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
|
6127 |
|
|
return error_mark_node;
|
6128 |
|
|
|
6129 |
|
|
if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
|
6130 |
|
|
&& TREE_CODE (type) != ARRAY_TYPE
|
6131 |
|
|
&& (TREE_CODE (type) != REFERENCE_TYPE
|
6132 |
|
|
|| TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
|
6133 |
|
|
|| (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
|
6134 |
|
|
&& (TREE_CODE (type) != REFERENCE_TYPE
|
6135 |
|
|
|| TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
|
6136 |
|
|
|| TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
|
6137 |
|
|
rhs = decay_conversion (rhs);
|
6138 |
|
|
|
6139 |
|
|
rhstype = TREE_TYPE (rhs);
|
6140 |
|
|
coder = TREE_CODE (rhstype);
|
6141 |
|
|
|
6142 |
|
|
if (coder == ERROR_MARK)
|
6143 |
|
|
return error_mark_node;
|
6144 |
|
|
|
6145 |
|
|
/* We accept references to incomplete types, so we can
|
6146 |
|
|
return here before checking if RHS is of complete type. */
|
6147 |
|
|
|
6148 |
|
|
if (codel == REFERENCE_TYPE)
|
6149 |
|
|
{
|
6150 |
|
|
/* This should eventually happen in convert_arguments. */
|
6151 |
|
|
int savew = 0, savee = 0;
|
6152 |
|
|
|
6153 |
|
|
if (fndecl)
|
6154 |
|
|
savew = warningcount, savee = errorcount;
|
6155 |
|
|
rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
|
6156 |
|
|
/*cleanup=*/NULL);
|
6157 |
|
|
if (fndecl)
|
6158 |
|
|
{
|
6159 |
|
|
if (warningcount > savew)
|
6160 |
|
|
warning (0, "in passing argument %P of %q+D", parmnum, fndecl);
|
6161 |
|
|
else if (errorcount > savee)
|
6162 |
|
|
error ("in passing argument %P of %q+D", parmnum, fndecl);
|
6163 |
|
|
}
|
6164 |
|
|
return rhs;
|
6165 |
|
|
}
|
6166 |
|
|
|
6167 |
|
|
if (exp != 0)
|
6168 |
|
|
exp = require_complete_type (exp);
|
6169 |
|
|
if (exp == error_mark_node)
|
6170 |
|
|
return error_mark_node;
|
6171 |
|
|
|
6172 |
|
|
rhstype = non_reference (rhstype);
|
6173 |
|
|
|
6174 |
|
|
type = complete_type (type);
|
6175 |
|
|
|
6176 |
|
|
if (IS_AGGR_TYPE (type))
|
6177 |
|
|
return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
|
6178 |
|
|
|
6179 |
|
|
return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
|
6180 |
|
|
}
|
6181 |
|
|
|
6182 |
|
|
/* If RETVAL is the address of, or a reference to, a local variable or
|
6183 |
|
|
temporary give an appropriate warning. */
|
6184 |
|
|
|
6185 |
|
|
static void
|
6186 |
|
|
maybe_warn_about_returning_address_of_local (tree retval)
|
6187 |
|
|
{
|
6188 |
|
|
tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
|
6189 |
|
|
tree whats_returned = retval;
|
6190 |
|
|
|
6191 |
|
|
for (;;)
|
6192 |
|
|
{
|
6193 |
|
|
if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
|
6194 |
|
|
whats_returned = TREE_OPERAND (whats_returned, 1);
|
6195 |
|
|
else if (TREE_CODE (whats_returned) == CONVERT_EXPR
|
6196 |
|
|
|| TREE_CODE (whats_returned) == NON_LVALUE_EXPR
|
6197 |
|
|
|| TREE_CODE (whats_returned) == NOP_EXPR)
|
6198 |
|
|
whats_returned = TREE_OPERAND (whats_returned, 0);
|
6199 |
|
|
else
|
6200 |
|
|
break;
|
6201 |
|
|
}
|
6202 |
|
|
|
6203 |
|
|
if (TREE_CODE (whats_returned) != ADDR_EXPR)
|
6204 |
|
|
return;
|
6205 |
|
|
whats_returned = TREE_OPERAND (whats_returned, 0);
|
6206 |
|
|
|
6207 |
|
|
if (TREE_CODE (valtype) == REFERENCE_TYPE)
|
6208 |
|
|
{
|
6209 |
|
|
if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
|
6210 |
|
|
|| TREE_CODE (whats_returned) == TARGET_EXPR)
|
6211 |
|
|
{
|
6212 |
|
|
warning (0, "returning reference to temporary");
|
6213 |
|
|
return;
|
6214 |
|
|
}
|
6215 |
|
|
if (TREE_CODE (whats_returned) == VAR_DECL
|
6216 |
|
|
&& DECL_NAME (whats_returned)
|
6217 |
|
|
&& TEMP_NAME_P (DECL_NAME (whats_returned)))
|
6218 |
|
|
{
|
6219 |
|
|
warning (0, "reference to non-lvalue returned");
|
6220 |
|
|
return;
|
6221 |
|
|
}
|
6222 |
|
|
}
|
6223 |
|
|
|
6224 |
|
|
if (DECL_P (whats_returned)
|
6225 |
|
|
&& DECL_NAME (whats_returned)
|
6226 |
|
|
&& DECL_FUNCTION_SCOPE_P (whats_returned)
|
6227 |
|
|
&& !(TREE_STATIC (whats_returned)
|
6228 |
|
|
|| TREE_PUBLIC (whats_returned)))
|
6229 |
|
|
{
|
6230 |
|
|
if (TREE_CODE (valtype) == REFERENCE_TYPE)
|
6231 |
|
|
warning (0, "reference to local variable %q+D returned",
|
6232 |
|
|
whats_returned);
|
6233 |
|
|
else
|
6234 |
|
|
warning (0, "address of local variable %q+D returned",
|
6235 |
|
|
whats_returned);
|
6236 |
|
|
return;
|
6237 |
|
|
}
|
6238 |
|
|
}
|
6239 |
|
|
|
6240 |
|
|
/* Check that returning RETVAL from the current function is valid.
|
6241 |
|
|
Return an expression explicitly showing all conversions required to
|
6242 |
|
|
change RETVAL into the function return type, and to assign it to
|
6243 |
|
|
the DECL_RESULT for the function. Set *NO_WARNING to true if
|
6244 |
|
|
code reaches end of non-void function warning shouldn't be issued
|
6245 |
|
|
on this RETURN_EXPR. */
|
6246 |
|
|
|
6247 |
|
|
tree
|
6248 |
|
|
check_return_expr (tree retval, bool *no_warning)
|
6249 |
|
|
{
|
6250 |
|
|
tree result;
|
6251 |
|
|
/* The type actually returned by the function, after any
|
6252 |
|
|
promotions. */
|
6253 |
|
|
tree valtype;
|
6254 |
|
|
int fn_returns_value_p;
|
6255 |
|
|
|
6256 |
|
|
*no_warning = false;
|
6257 |
|
|
|
6258 |
|
|
/* A `volatile' function is one that isn't supposed to return, ever.
|
6259 |
|
|
(This is a G++ extension, used to get better code for functions
|
6260 |
|
|
that call the `volatile' function.) */
|
6261 |
|
|
if (TREE_THIS_VOLATILE (current_function_decl))
|
6262 |
|
|
warning (0, "function declared %<noreturn%> has a %<return%> statement");
|
6263 |
|
|
|
6264 |
|
|
/* Check for various simple errors. */
|
6265 |
|
|
if (DECL_DESTRUCTOR_P (current_function_decl))
|
6266 |
|
|
{
|
6267 |
|
|
if (retval)
|
6268 |
|
|
error ("returning a value from a destructor");
|
6269 |
|
|
return NULL_TREE;
|
6270 |
|
|
}
|
6271 |
|
|
else if (DECL_CONSTRUCTOR_P (current_function_decl))
|
6272 |
|
|
{
|
6273 |
|
|
if (in_function_try_handler)
|
6274 |
|
|
/* If a return statement appears in a handler of the
|
6275 |
|
|
function-try-block of a constructor, the program is ill-formed. */
|
6276 |
|
|
error ("cannot return from a handler of a function-try-block of a constructor");
|
6277 |
|
|
else if (retval)
|
6278 |
|
|
/* You can't return a value from a constructor. */
|
6279 |
|
|
error ("returning a value from a constructor");
|
6280 |
|
|
return NULL_TREE;
|
6281 |
|
|
}
|
6282 |
|
|
|
6283 |
|
|
if (processing_template_decl)
|
6284 |
|
|
{
|
6285 |
|
|
current_function_returns_value = 1;
|
6286 |
|
|
return retval;
|
6287 |
|
|
}
|
6288 |
|
|
|
6289 |
|
|
/* When no explicit return-value is given in a function with a named
|
6290 |
|
|
return value, the named return value is used. */
|
6291 |
|
|
result = DECL_RESULT (current_function_decl);
|
6292 |
|
|
valtype = TREE_TYPE (result);
|
6293 |
|
|
gcc_assert (valtype != NULL_TREE);
|
6294 |
|
|
fn_returns_value_p = !VOID_TYPE_P (valtype);
|
6295 |
|
|
if (!retval && DECL_NAME (result) && fn_returns_value_p)
|
6296 |
|
|
retval = result;
|
6297 |
|
|
|
6298 |
|
|
/* Check for a return statement with no return value in a function
|
6299 |
|
|
that's supposed to return a value. */
|
6300 |
|
|
if (!retval && fn_returns_value_p)
|
6301 |
|
|
{
|
6302 |
|
|
pedwarn ("return-statement with no value, in function returning %qT",
|
6303 |
|
|
valtype);
|
6304 |
|
|
/* Clear this, so finish_function won't say that we reach the
|
6305 |
|
|
end of a non-void function (which we don't, we gave a
|
6306 |
|
|
return!). */
|
6307 |
|
|
current_function_returns_null = 0;
|
6308 |
|
|
/* And signal caller that TREE_NO_WARNING should be set on the
|
6309 |
|
|
RETURN_EXPR to avoid control reaches end of non-void function
|
6310 |
|
|
warnings in tree-cfg.c. */
|
6311 |
|
|
*no_warning = true;
|
6312 |
|
|
}
|
6313 |
|
|
/* Check for a return statement with a value in a function that
|
6314 |
|
|
isn't supposed to return a value. */
|
6315 |
|
|
else if (retval && !fn_returns_value_p)
|
6316 |
|
|
{
|
6317 |
|
|
if (VOID_TYPE_P (TREE_TYPE (retval)))
|
6318 |
|
|
/* You can return a `void' value from a function of `void'
|
6319 |
|
|
type. In that case, we have to evaluate the expression for
|
6320 |
|
|
its side-effects. */
|
6321 |
|
|
finish_expr_stmt (retval);
|
6322 |
|
|
else
|
6323 |
|
|
pedwarn ("return-statement with a value, in function "
|
6324 |
|
|
"returning 'void'");
|
6325 |
|
|
|
6326 |
|
|
current_function_returns_null = 1;
|
6327 |
|
|
|
6328 |
|
|
/* There's really no value to return, after all. */
|
6329 |
|
|
return NULL_TREE;
|
6330 |
|
|
}
|
6331 |
|
|
else if (!retval)
|
6332 |
|
|
/* Remember that this function can sometimes return without a
|
6333 |
|
|
value. */
|
6334 |
|
|
current_function_returns_null = 1;
|
6335 |
|
|
else
|
6336 |
|
|
/* Remember that this function did return a value. */
|
6337 |
|
|
current_function_returns_value = 1;
|
6338 |
|
|
|
6339 |
|
|
/* Check for erroneous operands -- but after giving ourselves a
|
6340 |
|
|
chance to provide an error about returning a value from a void
|
6341 |
|
|
function. */
|
6342 |
|
|
if (error_operand_p (retval))
|
6343 |
|
|
{
|
6344 |
|
|
current_function_return_value = error_mark_node;
|
6345 |
|
|
return error_mark_node;
|
6346 |
|
|
}
|
6347 |
|
|
|
6348 |
|
|
/* Only operator new(...) throw(), can return NULL [expr.new/13]. */
|
6349 |
|
|
if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
|
6350 |
|
|
|| DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
|
6351 |
|
|
&& !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
|
6352 |
|
|
&& ! flag_check_new
|
6353 |
|
|
&& null_ptr_cst_p (retval))
|
6354 |
|
|
warning (0, "%<operator new%> must not return NULL unless it is "
|
6355 |
|
|
"declared %<throw()%> (or -fcheck-new is in effect)");
|
6356 |
|
|
|
6357 |
|
|
/* Effective C++ rule 15. See also start_function. */
|
6358 |
|
|
if (warn_ecpp
|
6359 |
|
|
&& DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
|
6360 |
|
|
{
|
6361 |
|
|
bool warn = true;
|
6362 |
|
|
|
6363 |
|
|
/* The function return type must be a reference to the current
|
6364 |
|
|
class. */
|
6365 |
|
|
if (TREE_CODE (valtype) == REFERENCE_TYPE
|
6366 |
|
|
&& same_type_ignoring_top_level_qualifiers_p
|
6367 |
|
|
(TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
|
6368 |
|
|
{
|
6369 |
|
|
/* Returning '*this' is obviously OK. */
|
6370 |
|
|
if (retval == current_class_ref)
|
6371 |
|
|
warn = false;
|
6372 |
|
|
/* If we are calling a function whose return type is the same of
|
6373 |
|
|
the current class reference, it is ok. */
|
6374 |
|
|
else if (TREE_CODE (retval) == INDIRECT_REF
|
6375 |
|
|
&& TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
|
6376 |
|
|
warn = false;
|
6377 |
|
|
}
|
6378 |
|
|
|
6379 |
|
|
if (warn)
|
6380 |
|
|
warning (0, "%<operator=%> should return a reference to %<*this%>");
|
6381 |
|
|
}
|
6382 |
|
|
|
6383 |
|
|
/* The fabled Named Return Value optimization, as per [class.copy]/15:
|
6384 |
|
|
|
6385 |
|
|
[...] For a function with a class return type, if the expression
|
6386 |
|
|
in the return statement is the name of a local object, and the cv-
|
6387 |
|
|
unqualified type of the local object is the same as the function
|
6388 |
|
|
return type, an implementation is permitted to omit creating the tem-
|
6389 |
|
|
porary object to hold the function return value [...]
|
6390 |
|
|
|
6391 |
|
|
So, if this is a value-returning function that always returns the same
|
6392 |
|
|
local variable, remember it.
|
6393 |
|
|
|
6394 |
|
|
It might be nice to be more flexible, and choose the first suitable
|
6395 |
|
|
variable even if the function sometimes returns something else, but
|
6396 |
|
|
then we run the risk of clobbering the variable we chose if the other
|
6397 |
|
|
returned expression uses the chosen variable somehow. And people expect
|
6398 |
|
|
this restriction, anyway. (jason 2000-11-19)
|
6399 |
|
|
|
6400 |
|
|
See finish_function and finalize_nrv for the rest of this optimization. */
|
6401 |
|
|
|
6402 |
|
|
if (fn_returns_value_p && flag_elide_constructors)
|
6403 |
|
|
{
|
6404 |
|
|
if (retval != NULL_TREE
|
6405 |
|
|
&& (current_function_return_value == NULL_TREE
|
6406 |
|
|
|| current_function_return_value == retval)
|
6407 |
|
|
&& TREE_CODE (retval) == VAR_DECL
|
6408 |
|
|
&& DECL_CONTEXT (retval) == current_function_decl
|
6409 |
|
|
&& ! TREE_STATIC (retval)
|
6410 |
|
|
&& (DECL_ALIGN (retval)
|
6411 |
|
|
>= DECL_ALIGN (DECL_RESULT (current_function_decl)))
|
6412 |
|
|
&& same_type_p ((TYPE_MAIN_VARIANT
|
6413 |
|
|
(TREE_TYPE (retval))),
|
6414 |
|
|
(TYPE_MAIN_VARIANT
|
6415 |
|
|
(TREE_TYPE (TREE_TYPE (current_function_decl))))))
|
6416 |
|
|
current_function_return_value = retval;
|
6417 |
|
|
else
|
6418 |
|
|
current_function_return_value = error_mark_node;
|
6419 |
|
|
}
|
6420 |
|
|
|
6421 |
|
|
/* We don't need to do any conversions when there's nothing being
|
6422 |
|
|
returned. */
|
6423 |
|
|
if (!retval)
|
6424 |
|
|
return NULL_TREE;
|
6425 |
|
|
|
6426 |
|
|
/* Do any required conversions. */
|
6427 |
|
|
if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
|
6428 |
|
|
/* No conversions are required. */
|
6429 |
|
|
;
|
6430 |
|
|
else
|
6431 |
|
|
{
|
6432 |
|
|
/* The type the function is declared to return. */
|
6433 |
|
|
tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
|
6434 |
|
|
|
6435 |
|
|
/* The functype's return type will have been set to void, if it
|
6436 |
|
|
was an incomplete type. Just treat this as 'return;' */
|
6437 |
|
|
if (VOID_TYPE_P (functype))
|
6438 |
|
|
return error_mark_node;
|
6439 |
|
|
|
6440 |
|
|
/* First convert the value to the function's return type, then
|
6441 |
|
|
to the type of return value's location to handle the
|
6442 |
|
|
case that functype is smaller than the valtype. */
|
6443 |
|
|
retval = convert_for_initialization
|
6444 |
|
|
(NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
|
6445 |
|
|
"return", NULL_TREE, 0);
|
6446 |
|
|
retval = convert (valtype, retval);
|
6447 |
|
|
|
6448 |
|
|
/* If the conversion failed, treat this just like `return;'. */
|
6449 |
|
|
if (retval == error_mark_node)
|
6450 |
|
|
return retval;
|
6451 |
|
|
/* We can't initialize a register from a AGGR_INIT_EXPR. */
|
6452 |
|
|
else if (! current_function_returns_struct
|
6453 |
|
|
&& TREE_CODE (retval) == TARGET_EXPR
|
6454 |
|
|
&& TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
|
6455 |
|
|
retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
|
6456 |
|
|
TREE_OPERAND (retval, 0));
|
6457 |
|
|
else
|
6458 |
|
|
maybe_warn_about_returning_address_of_local (retval);
|
6459 |
|
|
}
|
6460 |
|
|
|
6461 |
|
|
/* Actually copy the value returned into the appropriate location. */
|
6462 |
|
|
if (retval && retval != result)
|
6463 |
|
|
retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
|
6464 |
|
|
|
6465 |
|
|
return retval;
|
6466 |
|
|
}
|
6467 |
|
|
|
6468 |
|
|
|
6469 |
|
|
/* Returns nonzero if the pointer-type FROM can be converted to the
|
6470 |
|
|
pointer-type TO via a qualification conversion. If CONSTP is -1,
|
6471 |
|
|
then we return nonzero if the pointers are similar, and the
|
6472 |
|
|
cv-qualification signature of FROM is a proper subset of that of TO.
|
6473 |
|
|
|
6474 |
|
|
If CONSTP is positive, then all outer pointers have been
|
6475 |
|
|
const-qualified. */
|
6476 |
|
|
|
6477 |
|
|
static int
|
6478 |
|
|
comp_ptr_ttypes_real (tree to, tree from, int constp)
|
6479 |
|
|
{
|
6480 |
|
|
bool to_more_cv_qualified = false;
|
6481 |
|
|
|
6482 |
|
|
for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
|
6483 |
|
|
{
|
6484 |
|
|
if (TREE_CODE (to) != TREE_CODE (from))
|
6485 |
|
|
return 0;
|
6486 |
|
|
|
6487 |
|
|
if (TREE_CODE (from) == OFFSET_TYPE
|
6488 |
|
|
&& !same_type_p (TYPE_OFFSET_BASETYPE (from),
|
6489 |
|
|
TYPE_OFFSET_BASETYPE (to)))
|
6490 |
|
|
return 0;
|
6491 |
|
|
|
6492 |
|
|
/* Const and volatile mean something different for function types,
|
6493 |
|
|
so the usual checks are not appropriate. */
|
6494 |
|
|
if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
|
6495 |
|
|
{
|
6496 |
|
|
/* In Objective-C++, some types may have been 'volatilized' by
|
6497 |
|
|
the compiler for EH; when comparing them here, the volatile
|
6498 |
|
|
qualification must be ignored. */
|
6499 |
|
|
bool objc_quals_match = objc_type_quals_match (to, from);
|
6500 |
|
|
|
6501 |
|
|
if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
|
6502 |
|
|
return 0;
|
6503 |
|
|
|
6504 |
|
|
if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
|
6505 |
|
|
{
|
6506 |
|
|
if (constp == 0)
|
6507 |
|
|
return 0;
|
6508 |
|
|
to_more_cv_qualified = true;
|
6509 |
|
|
}
|
6510 |
|
|
|
6511 |
|
|
if (constp > 0)
|
6512 |
|
|
constp &= TYPE_READONLY (to);
|
6513 |
|
|
}
|
6514 |
|
|
|
6515 |
|
|
if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
|
6516 |
|
|
return ((constp >= 0 || to_more_cv_qualified)
|
6517 |
|
|
&& same_type_ignoring_top_level_qualifiers_p (to, from));
|
6518 |
|
|
}
|
6519 |
|
|
}
|
6520 |
|
|
|
6521 |
|
|
/* When comparing, say, char ** to char const **, this function takes
|
6522 |
|
|
the 'char *' and 'char const *'. Do not pass non-pointer/reference
|
6523 |
|
|
types to this function. */
|
6524 |
|
|
|
6525 |
|
|
int
|
6526 |
|
|
comp_ptr_ttypes (tree to, tree from)
|
6527 |
|
|
{
|
6528 |
|
|
return comp_ptr_ttypes_real (to, from, 1);
|
6529 |
|
|
}
|
6530 |
|
|
|
6531 |
|
|
/* Returns 1 if to and from are (possibly multi-level) pointers to the same
|
6532 |
|
|
type or inheritance-related types, regardless of cv-quals. */
|
6533 |
|
|
|
6534 |
|
|
int
|
6535 |
|
|
ptr_reasonably_similar (tree to, tree from)
|
6536 |
|
|
{
|
6537 |
|
|
for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
|
6538 |
|
|
{
|
6539 |
|
|
/* Any target type is similar enough to void. */
|
6540 |
|
|
if (TREE_CODE (to) == VOID_TYPE
|
6541 |
|
|
|| TREE_CODE (from) == VOID_TYPE)
|
6542 |
|
|
return 1;
|
6543 |
|
|
|
6544 |
|
|
if (TREE_CODE (to) != TREE_CODE (from))
|
6545 |
|
|
return 0;
|
6546 |
|
|
|
6547 |
|
|
if (TREE_CODE (from) == OFFSET_TYPE
|
6548 |
|
|
&& comptypes (TYPE_OFFSET_BASETYPE (to),
|
6549 |
|
|
TYPE_OFFSET_BASETYPE (from),
|
6550 |
|
|
COMPARE_BASE | COMPARE_DERIVED))
|
6551 |
|
|
continue;
|
6552 |
|
|
|
6553 |
|
|
if (TREE_CODE (to) == VECTOR_TYPE
|
6554 |
|
|
&& vector_types_convertible_p (to, from))
|
6555 |
|
|
return 1;
|
6556 |
|
|
|
6557 |
|
|
if (TREE_CODE (to) == INTEGER_TYPE
|
6558 |
|
|
&& TYPE_PRECISION (to) == TYPE_PRECISION (from))
|
6559 |
|
|
return 1;
|
6560 |
|
|
|
6561 |
|
|
if (TREE_CODE (to) == FUNCTION_TYPE)
|
6562 |
|
|
return 1;
|
6563 |
|
|
|
6564 |
|
|
if (TREE_CODE (to) != POINTER_TYPE)
|
6565 |
|
|
return comptypes
|
6566 |
|
|
(TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
|
6567 |
|
|
COMPARE_BASE | COMPARE_DERIVED);
|
6568 |
|
|
}
|
6569 |
|
|
}
|
6570 |
|
|
|
6571 |
|
|
/* Return true if TO and FROM (both of which are POINTER_TYPEs or
|
6572 |
|
|
pointer-to-member types) are the same, ignoring cv-qualification at
|
6573 |
|
|
all levels. */
|
6574 |
|
|
|
6575 |
|
|
bool
|
6576 |
|
|
comp_ptr_ttypes_const (tree to, tree from)
|
6577 |
|
|
{
|
6578 |
|
|
for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
|
6579 |
|
|
{
|
6580 |
|
|
if (TREE_CODE (to) != TREE_CODE (from))
|
6581 |
|
|
return false;
|
6582 |
|
|
|
6583 |
|
|
if (TREE_CODE (from) == OFFSET_TYPE
|
6584 |
|
|
&& same_type_p (TYPE_OFFSET_BASETYPE (from),
|
6585 |
|
|
TYPE_OFFSET_BASETYPE (to)))
|
6586 |
|
|
continue;
|
6587 |
|
|
|
6588 |
|
|
if (TREE_CODE (to) != POINTER_TYPE)
|
6589 |
|
|
return same_type_ignoring_top_level_qualifiers_p (to, from);
|
6590 |
|
|
}
|
6591 |
|
|
}
|
6592 |
|
|
|
6593 |
|
|
/* Returns the type qualifiers for this type, including the qualifiers on the
|
6594 |
|
|
elements for an array type. */
|
6595 |
|
|
|
6596 |
|
|
int
|
6597 |
|
|
cp_type_quals (tree type)
|
6598 |
|
|
{
|
6599 |
|
|
type = strip_array_types (type);
|
6600 |
|
|
if (type == error_mark_node)
|
6601 |
|
|
return TYPE_UNQUALIFIED;
|
6602 |
|
|
return TYPE_QUALS (type);
|
6603 |
|
|
}
|
6604 |
|
|
|
6605 |
|
|
/* Returns nonzero if the TYPE contains a mutable member. */
|
6606 |
|
|
|
6607 |
|
|
bool
|
6608 |
|
|
cp_has_mutable_p (tree type)
|
6609 |
|
|
{
|
6610 |
|
|
type = strip_array_types (type);
|
6611 |
|
|
|
6612 |
|
|
return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
|
6613 |
|
|
}
|
6614 |
|
|
|
6615 |
|
|
/* Apply the TYPE_QUALS to the new DECL. */
|
6616 |
|
|
void
|
6617 |
|
|
cp_apply_type_quals_to_decl (int type_quals, tree decl)
|
6618 |
|
|
{
|
6619 |
|
|
tree type = TREE_TYPE (decl);
|
6620 |
|
|
|
6621 |
|
|
if (type == error_mark_node)
|
6622 |
|
|
return;
|
6623 |
|
|
|
6624 |
|
|
if (TREE_CODE (type) == FUNCTION_TYPE
|
6625 |
|
|
&& type_quals != TYPE_UNQUALIFIED)
|
6626 |
|
|
{
|
6627 |
|
|
/* This was an error in C++98 (cv-qualifiers cannot be added to
|
6628 |
|
|
a function type), but DR 295 makes the code well-formed by
|
6629 |
|
|
dropping the extra qualifiers. */
|
6630 |
|
|
if (pedantic)
|
6631 |
|
|
{
|
6632 |
|
|
tree bad_type = build_qualified_type (type, type_quals);
|
6633 |
|
|
pedwarn ("ignoring %qV qualifiers added to function type %qT",
|
6634 |
|
|
bad_type, type);
|
6635 |
|
|
}
|
6636 |
|
|
|
6637 |
|
|
TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
|
6638 |
|
|
return;
|
6639 |
|
|
}
|
6640 |
|
|
|
6641 |
|
|
/* Avoid setting TREE_READONLY incorrectly. */
|
6642 |
|
|
if (/* If the object has a constructor, the constructor may modify
|
6643 |
|
|
the object. */
|
6644 |
|
|
TYPE_NEEDS_CONSTRUCTING (type)
|
6645 |
|
|
/* If the type isn't complete, we don't know yet if it will need
|
6646 |
|
|
constructing. */
|
6647 |
|
|
|| !COMPLETE_TYPE_P (type)
|
6648 |
|
|
/* If the type has a mutable component, that component might be
|
6649 |
|
|
modified. */
|
6650 |
|
|
|| TYPE_HAS_MUTABLE_P (type))
|
6651 |
|
|
type_quals &= ~TYPE_QUAL_CONST;
|
6652 |
|
|
|
6653 |
|
|
c_apply_type_quals_to_decl (type_quals, decl);
|
6654 |
|
|
}
|
6655 |
|
|
|
6656 |
|
|
/* Subroutine of casts_away_constness. Make T1 and T2 point at
|
6657 |
|
|
exemplar types such that casting T1 to T2 is casting away constness
|
6658 |
|
|
if and only if there is no implicit conversion from T1 to T2. */
|
6659 |
|
|
|
6660 |
|
|
static void
|
6661 |
|
|
casts_away_constness_r (tree *t1, tree *t2)
|
6662 |
|
|
{
|
6663 |
|
|
int quals1;
|
6664 |
|
|
int quals2;
|
6665 |
|
|
|
6666 |
|
|
/* [expr.const.cast]
|
6667 |
|
|
|
6668 |
|
|
For multi-level pointer to members and multi-level mixed pointers
|
6669 |
|
|
and pointers to members (conv.qual), the "member" aspect of a
|
6670 |
|
|
pointer to member level is ignored when determining if a const
|
6671 |
|
|
cv-qualifier has been cast away. */
|
6672 |
|
|
/* [expr.const.cast]
|
6673 |
|
|
|
6674 |
|
|
For two pointer types:
|
6675 |
|
|
|
6676 |
|
|
X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
|
6677 |
|
|
X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
|
6678 |
|
|
K is min(N,M)
|
6679 |
|
|
|
6680 |
|
|
casting from X1 to X2 casts away constness if, for a non-pointer
|
6681 |
|
|
type T there does not exist an implicit conversion (clause
|
6682 |
|
|
_conv_) from:
|
6683 |
|
|
|
6684 |
|
|
Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
|
6685 |
|
|
|
6686 |
|
|
to
|
6687 |
|
|
|
6688 |
|
|
Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
|
6689 |
|
|
if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
|
6690 |
|
|
|| (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
|
6691 |
|
|
{
|
6692 |
|
|
*t1 = cp_build_qualified_type (void_type_node,
|
6693 |
|
|
cp_type_quals (*t1));
|
6694 |
|
|
*t2 = cp_build_qualified_type (void_type_node,
|
6695 |
|
|
cp_type_quals (*t2));
|
6696 |
|
|
return;
|
6697 |
|
|
}
|
6698 |
|
|
|
6699 |
|
|
quals1 = cp_type_quals (*t1);
|
6700 |
|
|
quals2 = cp_type_quals (*t2);
|
6701 |
|
|
|
6702 |
|
|
if (TYPE_PTRMEM_P (*t1))
|
6703 |
|
|
*t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
|
6704 |
|
|
else
|
6705 |
|
|
*t1 = TREE_TYPE (*t1);
|
6706 |
|
|
if (TYPE_PTRMEM_P (*t2))
|
6707 |
|
|
*t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
|
6708 |
|
|
else
|
6709 |
|
|
*t2 = TREE_TYPE (*t2);
|
6710 |
|
|
|
6711 |
|
|
casts_away_constness_r (t1, t2);
|
6712 |
|
|
*t1 = build_pointer_type (*t1);
|
6713 |
|
|
*t2 = build_pointer_type (*t2);
|
6714 |
|
|
*t1 = cp_build_qualified_type (*t1, quals1);
|
6715 |
|
|
*t2 = cp_build_qualified_type (*t2, quals2);
|
6716 |
|
|
}
|
6717 |
|
|
|
6718 |
|
|
/* Returns nonzero if casting from TYPE1 to TYPE2 casts away
|
6719 |
|
|
constness. */
|
6720 |
|
|
|
6721 |
|
|
static bool
|
6722 |
|
|
casts_away_constness (tree t1, tree t2)
|
6723 |
|
|
{
|
6724 |
|
|
if (TREE_CODE (t2) == REFERENCE_TYPE)
|
6725 |
|
|
{
|
6726 |
|
|
/* [expr.const.cast]
|
6727 |
|
|
|
6728 |
|
|
Casting from an lvalue of type T1 to an lvalue of type T2
|
6729 |
|
|
using a reference cast casts away constness if a cast from an
|
6730 |
|
|
rvalue of type "pointer to T1" to the type "pointer to T2"
|
6731 |
|
|
casts away constness. */
|
6732 |
|
|
t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
|
6733 |
|
|
return casts_away_constness (build_pointer_type (t1),
|
6734 |
|
|
build_pointer_type (TREE_TYPE (t2)));
|
6735 |
|
|
}
|
6736 |
|
|
|
6737 |
|
|
if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
|
6738 |
|
|
/* [expr.const.cast]
|
6739 |
|
|
|
6740 |
|
|
Casting from an rvalue of type "pointer to data member of X
|
6741 |
|
|
of type T1" to the type "pointer to data member of Y of type
|
6742 |
|
|
T2" casts away constness if a cast from an rvalue of type
|
6743 |
|
|
"pointer to T1" to the type "pointer to T2" casts away
|
6744 |
|
|
constness. */
|
6745 |
|
|
return casts_away_constness
|
6746 |
|
|
(build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
|
6747 |
|
|
build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
|
6748 |
|
|
|
6749 |
|
|
/* Casting away constness is only something that makes sense for
|
6750 |
|
|
pointer or reference types. */
|
6751 |
|
|
if (TREE_CODE (t1) != POINTER_TYPE
|
6752 |
|
|
|| TREE_CODE (t2) != POINTER_TYPE)
|
6753 |
|
|
return false;
|
6754 |
|
|
|
6755 |
|
|
/* Top-level qualifiers don't matter. */
|
6756 |
|
|
t1 = TYPE_MAIN_VARIANT (t1);
|
6757 |
|
|
t2 = TYPE_MAIN_VARIANT (t2);
|
6758 |
|
|
casts_away_constness_r (&t1, &t2);
|
6759 |
|
|
if (!can_convert (t2, t1))
|
6760 |
|
|
return true;
|
6761 |
|
|
|
6762 |
|
|
return false;
|
6763 |
|
|
}
|
6764 |
|
|
|
6765 |
|
|
/* If T is a REFERENCE_TYPE return the type to which T refers.
|
6766 |
|
|
Otherwise, return T itself. */
|
6767 |
|
|
|
6768 |
|
|
tree
|
6769 |
|
|
non_reference (tree t)
|
6770 |
|
|
{
|
6771 |
|
|
if (TREE_CODE (t) == REFERENCE_TYPE)
|
6772 |
|
|
t = TREE_TYPE (t);
|
6773 |
|
|
return t;
|
6774 |
|
|
}
|
6775 |
|
|
|
6776 |
|
|
|
6777 |
|
|
/* Return nonzero if REF is an lvalue valid for this language;
|
6778 |
|
|
otherwise, print an error message and return zero. USE says
|
6779 |
|
|
how the lvalue is being used and so selects the error message. */
|
6780 |
|
|
|
6781 |
|
|
int
|
6782 |
|
|
lvalue_or_else (tree ref, enum lvalue_use use)
|
6783 |
|
|
{
|
6784 |
|
|
int win = lvalue_p (ref);
|
6785 |
|
|
|
6786 |
|
|
if (!win)
|
6787 |
|
|
lvalue_error (use);
|
6788 |
|
|
|
6789 |
|
|
return win;
|
6790 |
|
|
}
|