tree.c revision 1.378 1 1.378 rillig /* $NetBSD: tree.c,v 1.378 2021/09/05 16:03:55 rillig Exp $ */
2 1.2 cgd
3 1.1 cgd /*
4 1.1 cgd * Copyright (c) 1994, 1995 Jochen Pohl
5 1.1 cgd * All Rights Reserved.
6 1.1 cgd *
7 1.1 cgd * Redistribution and use in source and binary forms, with or without
8 1.1 cgd * modification, are permitted provided that the following conditions
9 1.1 cgd * are met:
10 1.1 cgd * 1. Redistributions of source code must retain the above copyright
11 1.1 cgd * notice, this list of conditions and the following disclaimer.
12 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 cgd * notice, this list of conditions and the following disclaimer in the
14 1.1 cgd * documentation and/or other materials provided with the distribution.
15 1.1 cgd * 3. All advertising materials mentioning features or use of this software
16 1.1 cgd * must display the following acknowledgement:
17 1.1 cgd * This product includes software developed by Jochen Pohl for
18 1.1 cgd * The NetBSD Project.
19 1.1 cgd * 4. The name of the author may not be used to endorse or promote products
20 1.1 cgd * derived from this software without specific prior written permission.
21 1.1 cgd *
22 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 1.1 cgd * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 1.1 cgd * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 1.1 cgd * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 1.1 cgd * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 1.1 cgd * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 1.1 cgd * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 1.1 cgd * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 1.1 cgd * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 1.1 cgd * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 1.1 cgd */
33 1.1 cgd
34 1.37 jmc #if HAVE_NBTOOL_CONFIG_H
35 1.37 jmc #include "nbtool_config.h"
36 1.37 jmc #endif
37 1.37 jmc
38 1.14 christos #include <sys/cdefs.h>
39 1.23 tv #if defined(__RCSID) && !defined(lint)
40 1.378 rillig __RCSID("$NetBSD: tree.c,v 1.378 2021/09/05 16:03:55 rillig Exp $");
41 1.1 cgd #endif
42 1.1 cgd
43 1.1 cgd #include <float.h>
44 1.1 cgd #include <limits.h>
45 1.1 cgd #include <math.h>
46 1.49 christos #include <signal.h>
47 1.92 rillig #include <stdlib.h>
48 1.92 rillig #include <string.h>
49 1.1 cgd
50 1.1 cgd #include "lint1.h"
51 1.15 tv #include "cgram.h"
52 1.1 cgd
53 1.318 rillig static tnode_t *build_integer_constant(tspec_t, int64_t);
54 1.149 rillig static void check_pointer_comparison(op_t,
55 1.149 rillig const tnode_t *, const tnode_t *);
56 1.154 rillig static bool check_assign_types_compatible(op_t, int,
57 1.149 rillig const tnode_t *, const tnode_t *);
58 1.149 rillig static void check_bad_enum_operation(op_t,
59 1.149 rillig const tnode_t *, const tnode_t *);
60 1.149 rillig static void check_enum_type_mismatch(op_t, int,
61 1.149 rillig const tnode_t *, const tnode_t *);
62 1.149 rillig static void check_enum_int_mismatch(op_t, int,
63 1.149 rillig const tnode_t *, const tnode_t *);
64 1.100 rillig static tnode_t *new_tnode(op_t, type_t *, tnode_t *, tnode_t *);
65 1.20 lukem static void balance(op_t, tnode_t **, tnode_t **);
66 1.246 rillig static void warn_incompatible_types(op_t, const type_t *, tspec_t,
67 1.246 rillig const type_t *, tspec_t);
68 1.149 rillig static void warn_incompatible_pointers(const mod_t *,
69 1.149 rillig const type_t *, const type_t *);
70 1.149 rillig static bool has_constant_member(const type_t *);
71 1.100 rillig static void check_prototype_conversion(int, tspec_t, tspec_t, type_t *,
72 1.100 rillig tnode_t *);
73 1.100 rillig static void check_integer_conversion(op_t, int, tspec_t, tspec_t, type_t *,
74 1.100 rillig tnode_t *);
75 1.100 rillig static void check_pointer_integer_conversion(op_t, tspec_t, type_t *,
76 1.100 rillig tnode_t *);
77 1.273 rillig static void check_pointer_conversion(tnode_t *, type_t *);
78 1.100 rillig static tnode_t *build_struct_access(op_t, tnode_t *, tnode_t *);
79 1.100 rillig static tnode_t *build_prepost_incdec(op_t, tnode_t *);
80 1.100 rillig static tnode_t *build_real_imag(op_t, tnode_t *);
81 1.168 rillig static tnode_t *build_address(tnode_t *, bool);
82 1.100 rillig static tnode_t *build_plus_minus(op_t, tnode_t *, tnode_t *);
83 1.100 rillig static tnode_t *build_bit_shift(op_t, tnode_t *, tnode_t *);
84 1.100 rillig static tnode_t *build_colon(tnode_t *, tnode_t *);
85 1.100 rillig static tnode_t *build_assignment(op_t, tnode_t *, tnode_t *);
86 1.20 lukem static tnode_t *plength(type_t *);
87 1.20 lukem static tnode_t *fold(tnode_t *);
88 1.100 rillig static tnode_t *fold_test(tnode_t *);
89 1.100 rillig static tnode_t *fold_float(tnode_t *);
90 1.100 rillig static tnode_t *check_function_arguments(type_t *, tnode_t *);
91 1.100 rillig static tnode_t *check_prototype_argument(int, type_t *, tnode_t *);
92 1.149 rillig static void check_null_effect(const tnode_t *);
93 1.154 rillig static void check_array_index(tnode_t *, bool);
94 1.100 rillig static void check_integer_comparison(op_t, tnode_t *, tnode_t *);
95 1.100 rillig static void check_precedence_confusion(tnode_t *);
96 1.1 cgd
97 1.49 christos extern sig_atomic_t fpe;
98 1.49 christos
99 1.241 rillig static const char *
100 1.260 rillig op_name(op_t op)
101 1.241 rillig {
102 1.241 rillig return modtab[op].m_name;
103 1.241 rillig }
104 1.241 rillig
105 1.257 rillig /* Build 'pointer to tp', 'array of tp' or 'function returning tp'. */
106 1.1 cgd type_t *
107 1.257 rillig derive_type(type_t *tp, tspec_t t)
108 1.1 cgd {
109 1.1 cgd type_t *tp2;
110 1.1 cgd
111 1.259 rillig tp2 = getblk(sizeof(*tp2));
112 1.1 cgd tp2->t_tspec = t;
113 1.1 cgd tp2->t_subt = tp;
114 1.95 rillig return tp2;
115 1.1 cgd }
116 1.1 cgd
117 1.1 cgd /*
118 1.365 rillig * Derive 'pointer to tp' or 'function returning tp'.
119 1.365 rillig * The memory is freed at the end of the current expression.
120 1.1 cgd */
121 1.1 cgd type_t *
122 1.257 rillig expr_derive_type(type_t *tp, tspec_t t)
123 1.1 cgd {
124 1.1 cgd type_t *tp2;
125 1.1 cgd
126 1.259 rillig tp2 = expr_zalloc(sizeof(*tp2));
127 1.1 cgd tp2->t_tspec = t;
128 1.1 cgd tp2->t_subt = tp;
129 1.95 rillig return tp2;
130 1.1 cgd }
131 1.1 cgd
132 1.1 cgd /*
133 1.1 cgd * Create a node for a constant.
134 1.1 cgd */
135 1.1 cgd tnode_t *
136 1.318 rillig build_constant(type_t *tp, val_t *v)
137 1.1 cgd {
138 1.1 cgd tnode_t *n;
139 1.1 cgd
140 1.256 rillig n = expr_zalloc_tnode();
141 1.1 cgd n->tn_op = CON;
142 1.1 cgd n->tn_type = tp;
143 1.259 rillig n->tn_val = expr_zalloc(sizeof(*n->tn_val));
144 1.1 cgd n->tn_val->v_tspec = tp->t_tspec;
145 1.289 rillig n->tn_val->v_unsigned_since_c90 = v->v_unsigned_since_c90;
146 1.1 cgd n->tn_val->v_u = v->v_u;
147 1.1 cgd free(v);
148 1.95 rillig return n;
149 1.1 cgd }
150 1.1 cgd
151 1.1 cgd static tnode_t *
152 1.318 rillig build_integer_constant(tspec_t t, int64_t q)
153 1.1 cgd {
154 1.1 cgd tnode_t *n;
155 1.1 cgd
156 1.256 rillig n = expr_zalloc_tnode();
157 1.1 cgd n->tn_op = CON;
158 1.1 cgd n->tn_type = gettyp(t);
159 1.259 rillig n->tn_val = expr_zalloc(sizeof(*n->tn_val));
160 1.1 cgd n->tn_val->v_tspec = t;
161 1.1 cgd n->tn_val->v_quad = q;
162 1.95 rillig return n;
163 1.1 cgd }
164 1.1 cgd
165 1.167 rillig static void
166 1.167 rillig fallback_symbol(sym_t *sym)
167 1.167 rillig {
168 1.167 rillig
169 1.267 rillig if (fallback_symbol_strict_bool(sym))
170 1.167 rillig return;
171 1.167 rillig
172 1.233 rillig if (block_level > 0 && (strcmp(sym->s_name, "__FUNCTION__") == 0 ||
173 1.167 rillig strcmp(sym->s_name, "__PRETTY_FUNCTION__") == 0)) {
174 1.167 rillig /* __FUNCTION__/__PRETTY_FUNCTION__ is a GCC extension */
175 1.167 rillig gnuism(316);
176 1.257 rillig sym->s_type = derive_type(gettyp(CHAR), PTR);
177 1.167 rillig sym->s_type->t_const = true;
178 1.167 rillig return;
179 1.167 rillig }
180 1.167 rillig
181 1.233 rillig if (block_level > 0 && strcmp(sym->s_name, "__func__") == 0) {
182 1.167 rillig if (!Sflag)
183 1.167 rillig /* __func__ is a C9X feature */
184 1.167 rillig warning(317);
185 1.257 rillig sym->s_type = derive_type(gettyp(CHAR), PTR);
186 1.167 rillig sym->s_type->t_const = true;
187 1.167 rillig return;
188 1.167 rillig }
189 1.167 rillig
190 1.251 rillig /* '%s' undefined */
191 1.167 rillig error(99, sym->s_name);
192 1.167 rillig }
193 1.167 rillig
194 1.358 rillig /*
195 1.361 rillig * Functions that are predeclared by GCC or other compilers can be called
196 1.361 rillig * with arbitrary arguments. Since lint usually runs after a successful
197 1.361 rillig * compilation, it's the compiler's job to catch any errors.
198 1.358 rillig */
199 1.358 rillig bool
200 1.361 rillig is_compiler_builtin(const char *name)
201 1.303 rillig {
202 1.361 rillig /* https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html */
203 1.362 rillig if (gflag) {
204 1.362 rillig if (strncmp(name, "__atomic_", 9) == 0 ||
205 1.362 rillig strncmp(name, "__builtin_", 10) == 0 ||
206 1.362 rillig /* obsolete but still in use, as of 2021 */
207 1.362 rillig strncmp(name, "__sync_", 7) == 0)
208 1.362 rillig return true;
209 1.362 rillig }
210 1.361 rillig
211 1.361 rillig /* https://software.intel.com/sites/landingpage/IntrinsicsGuide/ */
212 1.361 rillig if (strncmp(name, "_mm_", 4) == 0)
213 1.361 rillig return true;
214 1.361 rillig
215 1.361 rillig return false;
216 1.303 rillig }
217 1.303 rillig
218 1.372 rillig static bool
219 1.372 rillig str_endswith(const char *haystack, const char *needle)
220 1.372 rillig {
221 1.372 rillig size_t hlen = strlen(haystack);
222 1.372 rillig size_t nlen = strlen(needle);
223 1.372 rillig
224 1.372 rillig return nlen <= hlen &&
225 1.372 rillig memcmp(haystack + hlen - nlen, needle, nlen) == 0;
226 1.372 rillig }
227 1.372 rillig
228 1.372 rillig /* https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html */
229 1.372 rillig static bool
230 1.372 rillig is_gcc_bool_builtin(const char *name)
231 1.372 rillig {
232 1.372 rillig return strncmp(name, "__builtin_", 10) == 0 &&
233 1.372 rillig (str_endswith(name, "_overflow") ||
234 1.372 rillig str_endswith(name, "_overflow_p"));
235 1.372 rillig }
236 1.372 rillig
237 1.371 rillig static void
238 1.371 rillig build_name_call(sym_t *sym)
239 1.371 rillig {
240 1.371 rillig
241 1.371 rillig if (is_compiler_builtin(sym->s_name)) {
242 1.371 rillig /*
243 1.371 rillig * Do not warn about these, just assume that
244 1.371 rillig * they are regular functions compatible with
245 1.371 rillig * non-prototype calling conventions.
246 1.371 rillig */
247 1.372 rillig
248 1.372 rillig if (is_gcc_bool_builtin(sym->s_name))
249 1.372 rillig sym->s_type = gettyp(BOOL);
250 1.372 rillig
251 1.371 rillig } else if (Sflag) {
252 1.371 rillig /* function '%s' implicitly declared to return int */
253 1.371 rillig error(215, sym->s_name);
254 1.371 rillig } else if (sflag) {
255 1.371 rillig /* function '%s' implicitly declared to return int */
256 1.371 rillig warning(215, sym->s_name);
257 1.371 rillig }
258 1.371 rillig
259 1.371 rillig /* XXX if tflag is set, the symbol should be exported to level 0 */
260 1.371 rillig sym->s_type = derive_type(sym->s_type, FUNC);
261 1.371 rillig }
262 1.371 rillig
263 1.1 cgd /*
264 1.1 cgd * Create a node for a name (symbol table entry).
265 1.242 rillig * follow_token is the token which follows the name.
266 1.1 cgd */
267 1.1 cgd tnode_t *
268 1.318 rillig build_name(sym_t *sym, int follow_token)
269 1.1 cgd {
270 1.1 cgd tnode_t *n;
271 1.1 cgd
272 1.1 cgd if (sym->s_scl == NOSCL) {
273 1.1 cgd sym->s_scl = EXTERN;
274 1.1 cgd sym->s_def = DECL;
275 1.242 rillig if (follow_token == T_LPAREN) {
276 1.371 rillig build_name_call(sym);
277 1.1 cgd } else {
278 1.167 rillig fallback_symbol(sym);
279 1.1 cgd }
280 1.1 cgd }
281 1.1 cgd
282 1.242 rillig lint_assert(sym->s_kind == FVFT || sym->s_kind == FMEMBER);
283 1.1 cgd
284 1.256 rillig n = expr_zalloc_tnode();
285 1.1 cgd n->tn_type = sym->s_type;
286 1.156 rillig if (sym->s_scl != CTCONST) {
287 1.1 cgd n->tn_op = NAME;
288 1.1 cgd n->tn_sym = sym;
289 1.1 cgd if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC)
290 1.154 rillig n->tn_lvalue = true;
291 1.1 cgd } else {
292 1.1 cgd n->tn_op = CON;
293 1.259 rillig n->tn_val = expr_zalloc(sizeof(*n->tn_val));
294 1.1 cgd *n->tn_val = sym->s_value;
295 1.1 cgd }
296 1.1 cgd
297 1.95 rillig return n;
298 1.1 cgd }
299 1.1 cgd
300 1.1 cgd tnode_t *
301 1.318 rillig build_string(strg_t *strg)
302 1.1 cgd {
303 1.1 cgd size_t len;
304 1.1 cgd tnode_t *n;
305 1.365 rillig type_t *tp;
306 1.1 cgd
307 1.1 cgd len = strg->st_len;
308 1.1 cgd
309 1.256 rillig n = expr_zalloc_tnode();
310 1.1 cgd
311 1.365 rillig tp = expr_zalloc(sizeof(*tp));
312 1.365 rillig tp->t_tspec = ARRAY;
313 1.365 rillig tp->t_subt = gettyp(strg->st_tspec);
314 1.378 rillig tp->t_dim = (int)(len + 1);
315 1.365 rillig
316 1.1 cgd n->tn_op = STRING;
317 1.365 rillig n->tn_type = tp;
318 1.154 rillig n->tn_lvalue = true;
319 1.1 cgd
320 1.259 rillig n->tn_string = expr_zalloc(sizeof(*n->tn_string));
321 1.104 rillig n->tn_string->st_tspec = strg->st_tspec;
322 1.104 rillig n->tn_string->st_len = len;
323 1.1 cgd
324 1.1 cgd if (strg->st_tspec == CHAR) {
325 1.257 rillig n->tn_string->st_cp = expr_zalloc(len + 1);
326 1.104 rillig (void)memcpy(n->tn_string->st_cp, strg->st_cp, len + 1);
327 1.1 cgd free(strg->st_cp);
328 1.1 cgd } else {
329 1.259 rillig size_t size = (len + 1) * sizeof(*n->tn_string->st_wcp);
330 1.257 rillig n->tn_string->st_wcp = expr_zalloc(size);
331 1.250 rillig (void)memcpy(n->tn_string->st_wcp, strg->st_wcp, size);
332 1.1 cgd free(strg->st_wcp);
333 1.1 cgd }
334 1.1 cgd free(strg);
335 1.1 cgd
336 1.95 rillig return n;
337 1.1 cgd }
338 1.1 cgd
339 1.1 cgd /*
340 1.1 cgd * Returns a symbol which has the same name as the msym argument and is a
341 1.1 cgd * member of the struct or union specified by the tn argument.
342 1.1 cgd */
343 1.1 cgd sym_t *
344 1.98 rillig struct_or_union_member(tnode_t *tn, op_t op, sym_t *msym)
345 1.1 cgd {
346 1.208 rillig struct_or_union *str;
347 1.1 cgd type_t *tp;
348 1.1 cgd sym_t *sym, *csym;
349 1.154 rillig bool eq;
350 1.1 cgd tspec_t t;
351 1.1 cgd
352 1.1 cgd /*
353 1.182 rillig * Remove the member if it was unknown until now, which means
354 1.182 rillig * that no defined struct or union has a member with the same name.
355 1.1 cgd */
356 1.1 cgd if (msym->s_scl == NOSCL) {
357 1.254 rillig /* type '%s' does not have member '%s' */
358 1.300 rillig error(101, type_name(tn->tn_type), msym->s_name);
359 1.1 cgd rmsym(msym);
360 1.102 rillig msym->s_kind = FMEMBER;
361 1.1 cgd msym->s_scl = MOS;
362 1.259 rillig msym->s_styp = expr_zalloc(sizeof(*msym->s_styp));
363 1.257 rillig msym->s_styp->sou_tag = expr_zalloc(
364 1.259 rillig sizeof(*msym->s_styp->sou_tag));
365 1.208 rillig msym->s_styp->sou_tag->s_name = unnamed;
366 1.1 cgd msym->s_value.v_tspec = INT;
367 1.95 rillig return msym;
368 1.1 cgd }
369 1.1 cgd
370 1.1 cgd /* Set str to the tag of which msym is expected to be a member. */
371 1.1 cgd str = NULL;
372 1.1 cgd t = (tp = tn->tn_type)->t_tspec;
373 1.1 cgd if (op == POINT) {
374 1.1 cgd if (t == STRUCT || t == UNION)
375 1.1 cgd str = tp->t_str;
376 1.1 cgd } else if (op == ARROW && t == PTR) {
377 1.1 cgd t = (tp = tp->t_subt)->t_tspec;
378 1.1 cgd if (t == STRUCT || t == UNION)
379 1.1 cgd str = tp->t_str;
380 1.1 cgd }
381 1.1 cgd
382 1.1 cgd /*
383 1.182 rillig * If this struct/union has a member with the name of msym, return it.
384 1.1 cgd */
385 1.1 cgd if (str != NULL) {
386 1.1 cgd for (sym = msym; sym != NULL; sym = sym->s_link) {
387 1.1 cgd if (sym->s_scl != MOS && sym->s_scl != MOU)
388 1.1 cgd continue;
389 1.1 cgd if (sym->s_styp != str)
390 1.1 cgd continue;
391 1.1 cgd if (strcmp(sym->s_name, msym->s_name) != 0)
392 1.1 cgd continue;
393 1.95 rillig return sym;
394 1.1 cgd }
395 1.1 cgd }
396 1.1 cgd
397 1.1 cgd /*
398 1.185 rillig * Set eq to false if there are struct/union members with the same
399 1.185 rillig * name and different types and/or offsets.
400 1.1 cgd */
401 1.154 rillig eq = true;
402 1.1 cgd for (csym = msym; csym != NULL; csym = csym->s_link) {
403 1.1 cgd if (csym->s_scl != MOS && csym->s_scl != MOU)
404 1.1 cgd continue;
405 1.1 cgd if (strcmp(msym->s_name, csym->s_name) != 0)
406 1.1 cgd continue;
407 1.342 rillig for (sym = csym->s_link; sym != NULL; sym = sym->s_link) {
408 1.154 rillig bool w;
409 1.1 cgd
410 1.1 cgd if (sym->s_scl != MOS && sym->s_scl != MOU)
411 1.1 cgd continue;
412 1.1 cgd if (strcmp(csym->s_name, sym->s_name) != 0)
413 1.1 cgd continue;
414 1.1 cgd if (csym->s_value.v_quad != sym->s_value.v_quad) {
415 1.154 rillig eq = false;
416 1.1 cgd break;
417 1.1 cgd }
418 1.154 rillig w = false;
419 1.154 rillig eq = eqtype(csym->s_type, sym->s_type,
420 1.154 rillig false, false, &w) && !w;
421 1.1 cgd if (!eq)
422 1.1 cgd break;
423 1.105 rillig if (csym->s_bitfield != sym->s_bitfield) {
424 1.154 rillig eq = false;
425 1.1 cgd break;
426 1.1 cgd }
427 1.105 rillig if (csym->s_bitfield) {
428 1.1 cgd type_t *tp1, *tp2;
429 1.1 cgd
430 1.1 cgd tp1 = csym->s_type;
431 1.1 cgd tp2 = sym->s_type;
432 1.1 cgd if (tp1->t_flen != tp2->t_flen) {
433 1.154 rillig eq = false;
434 1.1 cgd break;
435 1.1 cgd }
436 1.1 cgd if (tp1->t_foffs != tp2->t_foffs) {
437 1.154 rillig eq = false;
438 1.1 cgd break;
439 1.1 cgd }
440 1.1 cgd }
441 1.1 cgd }
442 1.1 cgd if (!eq)
443 1.1 cgd break;
444 1.1 cgd }
445 1.1 cgd
446 1.1 cgd /*
447 1.1 cgd * Now handle the case in which the left operand refers really
448 1.1 cgd * to a struct/union, but the right operand is not member of it.
449 1.1 cgd */
450 1.1 cgd if (str != NULL) {
451 1.1 cgd if (eq && tflag) {
452 1.113 rillig /* illegal member use: %s */
453 1.1 cgd warning(102, msym->s_name);
454 1.1 cgd } else {
455 1.113 rillig /* illegal member use: %s */
456 1.1 cgd error(102, msym->s_name);
457 1.1 cgd }
458 1.95 rillig return msym;
459 1.1 cgd }
460 1.1 cgd
461 1.1 cgd /*
462 1.1 cgd * Now the left operand of ARROW does not point to a struct/union
463 1.1 cgd * or the left operand of POINT is no struct/union.
464 1.1 cgd */
465 1.1 cgd if (eq) {
466 1.1 cgd if (op == POINT) {
467 1.1 cgd if (tflag) {
468 1.310 rillig /* left operand of '.' must be struct ... */
469 1.310 rillig warning(103, type_name(tn->tn_type));
470 1.1 cgd } else {
471 1.310 rillig /* left operand of '.' must be struct ... */
472 1.310 rillig error(103, type_name(tn->tn_type));
473 1.1 cgd }
474 1.1 cgd } else {
475 1.1 cgd if (tflag && tn->tn_type->t_tspec == PTR) {
476 1.113 rillig /* left operand of '->' must be pointer ... */
477 1.115 rillig warning(104, type_name(tn->tn_type));
478 1.1 cgd } else {
479 1.113 rillig /* left operand of '->' must be pointer ... */
480 1.115 rillig error(104, type_name(tn->tn_type));
481 1.1 cgd }
482 1.1 cgd }
483 1.1 cgd } else {
484 1.1 cgd if (tflag) {
485 1.1 cgd /* non-unique member requires struct/union %s */
486 1.1 cgd error(105, op == POINT ? "object" : "pointer");
487 1.1 cgd } else {
488 1.108 rillig /* unacceptable operand of '%s' */
489 1.260 rillig error(111, op_name(op));
490 1.1 cgd }
491 1.1 cgd }
492 1.1 cgd
493 1.95 rillig return msym;
494 1.1 cgd }
495 1.1 cgd
496 1.291 rillig tnode_t *
497 1.291 rillig build_generic_selection(const tnode_t *expr,
498 1.313 rillig struct generic_association *sel)
499 1.291 rillig {
500 1.291 rillig tnode_t *default_result = NULL;
501 1.291 rillig
502 1.313 rillig for (; sel != NULL; sel = sel->ga_prev)
503 1.292 rillig if (expr != NULL &&
504 1.313 rillig eqtype(sel->ga_arg, expr->tn_type, false, false, NULL))
505 1.313 rillig return sel->ga_result;
506 1.313 rillig else if (sel->ga_arg == NULL)
507 1.313 rillig default_result = sel->ga_result;
508 1.291 rillig return default_result;
509 1.291 rillig }
510 1.291 rillig
511 1.1 cgd /*
512 1.1 cgd * Create a tree node. Called for most operands except function calls,
513 1.1 cgd * sizeof and casts.
514 1.1 cgd *
515 1.1 cgd * op operator
516 1.1 cgd * ln left operand
517 1.1 cgd * rn if not NULL, right operand
518 1.1 cgd */
519 1.1 cgd tnode_t *
520 1.317 rillig build_binary(tnode_t *ln, op_t op, tnode_t *rn)
521 1.1 cgd {
522 1.240 rillig const mod_t *mp;
523 1.1 cgd tnode_t *ntn;
524 1.219 rillig type_t *rettp;
525 1.1 cgd
526 1.1 cgd mp = &modtab[op];
527 1.1 cgd
528 1.1 cgd /* If there was an error in one of the operands, return. */
529 1.1 cgd if (ln == NULL || (mp->m_binary && rn == NULL))
530 1.95 rillig return NULL;
531 1.1 cgd
532 1.1 cgd /*
533 1.1 cgd * Apply class conversions to the left operand, but only if its
534 1.106 rillig * value is needed or it is compared with null.
535 1.1 cgd */
536 1.164 rillig if (mp->m_left_value_context || mp->m_left_test_context)
537 1.1 cgd ln = cconv(ln);
538 1.1 cgd /*
539 1.1 cgd * The right operand is almost always in a test or value context,
540 1.1 cgd * except if it is a struct or union member.
541 1.1 cgd */
542 1.1 cgd if (mp->m_binary && op != ARROW && op != POINT)
543 1.1 cgd rn = cconv(rn);
544 1.1 cgd
545 1.1 cgd /*
546 1.17 mycroft * Print some warnings for comparisons of unsigned values with
547 1.1 cgd * constants lower than or equal to null. This must be done
548 1.1 cgd * before promote() because otherwise unsigned char and unsigned
549 1.1 cgd * short would be promoted to int. Also types are tested to be
550 1.1 cgd * CHAR, which would also become int.
551 1.1 cgd */
552 1.164 rillig if (mp->m_comparison)
553 1.100 rillig check_integer_comparison(op, ln, rn);
554 1.1 cgd
555 1.1 cgd /*
556 1.1 cgd * Promote the left operand if it is in a test or value context
557 1.1 cgd */
558 1.164 rillig if (mp->m_left_value_context || mp->m_left_test_context)
559 1.172 rillig ln = promote(op, false, ln);
560 1.1 cgd /*
561 1.1 cgd * Promote the right operand, but only if it is no struct or
562 1.1 cgd * union member, or if it is not to be assigned to the left operand
563 1.1 cgd */
564 1.1 cgd if (mp->m_binary && op != ARROW && op != POINT &&
565 1.333 rillig op != ASSIGN && op != RETURN && op != INIT) {
566 1.172 rillig rn = promote(op, false, rn);
567 1.1 cgd }
568 1.1 cgd
569 1.1 cgd /*
570 1.1 cgd * If the result of the operation is different for signed or
571 1.1 cgd * unsigned operands and one of the operands is signed only in
572 1.1 cgd * ANSI C, print a warning.
573 1.1 cgd */
574 1.164 rillig if (mp->m_warn_if_left_unsigned_in_c90 &&
575 1.289 rillig ln->tn_op == CON && ln->tn_val->v_unsigned_since_c90) {
576 1.1 cgd /* ANSI C treats constant as unsigned, op %s */
577 1.1 cgd warning(218, mp->m_name);
578 1.289 rillig ln->tn_val->v_unsigned_since_c90 = false;
579 1.1 cgd }
580 1.164 rillig if (mp->m_warn_if_right_unsigned_in_c90 &&
581 1.289 rillig rn->tn_op == CON && rn->tn_val->v_unsigned_since_c90) {
582 1.1 cgd /* ANSI C treats constant as unsigned, op %s */
583 1.1 cgd warning(218, mp->m_name);
584 1.289 rillig rn->tn_val->v_unsigned_since_c90 = false;
585 1.1 cgd }
586 1.1 cgd
587 1.1 cgd /* Make sure both operands are of the same type */
588 1.164 rillig if (mp->m_balance_operands || (tflag && (op == SHL || op == SHR)))
589 1.1 cgd balance(op, &ln, &rn);
590 1.1 cgd
591 1.1 cgd /*
592 1.1 cgd * Check types for compatibility with the operation and mutual
593 1.106 rillig * compatibility. Return if there are serious problems.
594 1.1 cgd */
595 1.1 cgd if (!typeok(op, 0, ln, rn))
596 1.95 rillig return NULL;
597 1.1 cgd
598 1.1 cgd /* And now create the node. */
599 1.1 cgd switch (op) {
600 1.1 cgd case POINT:
601 1.1 cgd case ARROW:
602 1.100 rillig ntn = build_struct_access(op, ln, rn);
603 1.1 cgd break;
604 1.1 cgd case INCAFT:
605 1.1 cgd case DECAFT:
606 1.1 cgd case INCBEF:
607 1.1 cgd case DECBEF:
608 1.100 rillig ntn = build_prepost_incdec(op, ln);
609 1.1 cgd break;
610 1.169 rillig case ADDR:
611 1.172 rillig ntn = build_address(ln, false);
612 1.1 cgd break;
613 1.170 rillig case INDIR:
614 1.170 rillig ntn = new_tnode(INDIR, ln->tn_type->t_subt, ln, NULL);
615 1.1 cgd break;
616 1.1 cgd case PLUS:
617 1.1 cgd case MINUS:
618 1.100 rillig ntn = build_plus_minus(op, ln, rn);
619 1.1 cgd break;
620 1.1 cgd case SHL:
621 1.1 cgd case SHR:
622 1.100 rillig ntn = build_bit_shift(op, ln, rn);
623 1.1 cgd break;
624 1.1 cgd case COLON:
625 1.100 rillig ntn = build_colon(ln, rn);
626 1.1 cgd break;
627 1.1 cgd case ASSIGN:
628 1.1 cgd case MULASS:
629 1.1 cgd case DIVASS:
630 1.1 cgd case MODASS:
631 1.1 cgd case ADDASS:
632 1.1 cgd case SUBASS:
633 1.1 cgd case SHLASS:
634 1.1 cgd case SHRASS:
635 1.1 cgd case ANDASS:
636 1.1 cgd case XORASS:
637 1.1 cgd case ORASS:
638 1.1 cgd case RETURN:
639 1.333 rillig case INIT:
640 1.100 rillig ntn = build_assignment(op, ln, rn);
641 1.1 cgd break;
642 1.1 cgd case COMMA:
643 1.1 cgd case QUEST:
644 1.100 rillig ntn = new_tnode(op, rn->tn_type, ln, rn);
645 1.1 cgd break;
646 1.46 christos case REAL:
647 1.46 christos case IMAG:
648 1.100 rillig ntn = build_real_imag(op, ln);
649 1.46 christos break;
650 1.1 cgd default:
651 1.219 rillig rettp = mp->m_returns_bool
652 1.151 rillig ? gettyp(Tflag ? BOOL : INT) : ln->tn_type;
653 1.107 rillig lint_assert(mp->m_binary || rn == NULL);
654 1.219 rillig ntn = new_tnode(op, rettp, ln, rn);
655 1.1 cgd break;
656 1.1 cgd }
657 1.1 cgd
658 1.21 wiz /* Return if an error occurred. */
659 1.1 cgd if (ntn == NULL)
660 1.95 rillig return NULL;
661 1.1 cgd
662 1.1 cgd /* Print a warning if precedence confusion is possible */
663 1.133 rillig if (mp->m_possible_precedence_confusion)
664 1.100 rillig check_precedence_confusion(ntn);
665 1.1 cgd
666 1.1 cgd /*
667 1.1 cgd * Print a warning if one of the operands is in a context where
668 1.1 cgd * it is compared with null and if this operand is a constant.
669 1.1 cgd */
670 1.164 rillig if (mp->m_left_test_context) {
671 1.1 cgd if (ln->tn_op == CON ||
672 1.1 cgd ((mp->m_binary && op != QUEST) && rn->tn_op == CON)) {
673 1.227 rillig if (hflag && !constcond_flag &&
674 1.227 rillig !ln->tn_system_dependent)
675 1.1 cgd /* constant in conditional context */
676 1.1 cgd warning(161);
677 1.1 cgd }
678 1.1 cgd }
679 1.1 cgd
680 1.1 cgd /* Fold if the operator requires it */
681 1.164 rillig if (mp->m_fold_constant_operands) {
682 1.1 cgd if (ln->tn_op == CON && (!mp->m_binary || rn->tn_op == CON)) {
683 1.164 rillig if (mp->m_left_test_context) {
684 1.100 rillig ntn = fold_test(ntn);
685 1.144 rillig } else if (is_floating(ntn->tn_type->t_tspec)) {
686 1.100 rillig ntn = fold_float(ntn);
687 1.1 cgd } else {
688 1.1 cgd ntn = fold(ntn);
689 1.1 cgd }
690 1.1 cgd } else if (op == QUEST && ln->tn_op == CON) {
691 1.154 rillig ntn = ln->tn_val->v_quad != 0
692 1.154 rillig ? rn->tn_left : rn->tn_right;
693 1.1 cgd }
694 1.1 cgd }
695 1.1 cgd
696 1.95 rillig return ntn;
697 1.1 cgd }
698 1.1 cgd
699 1.314 rillig tnode_t *
700 1.317 rillig build_unary(op_t op, tnode_t *tn)
701 1.317 rillig {
702 1.317 rillig return build_binary(tn, op, NULL);
703 1.317 rillig }
704 1.317 rillig
705 1.317 rillig tnode_t *
706 1.314 rillig build_member_access(tnode_t *ln, op_t op, sbuf_t *member)
707 1.314 rillig {
708 1.314 rillig sym_t *msym;
709 1.314 rillig
710 1.314 rillig if (ln == NULL)
711 1.314 rillig return NULL;
712 1.314 rillig
713 1.314 rillig if (op == ARROW) {
714 1.314 rillig /* must do this before struct_or_union_member is called */
715 1.314 rillig ln = cconv(ln);
716 1.314 rillig }
717 1.314 rillig msym = struct_or_union_member(ln, op, getsym(member));
718 1.318 rillig return build_binary(ln, op, build_name(msym, 0));
719 1.314 rillig }
720 1.314 rillig
721 1.1 cgd /*
722 1.1 cgd * Perform class conversions.
723 1.1 cgd *
724 1.1 cgd * Arrays of type T are converted into pointers to type T.
725 1.1 cgd * Functions are converted to pointers to functions.
726 1.1 cgd * Lvalues are converted to rvalues.
727 1.231 rillig *
728 1.231 rillig * C99 6.3 "Conversions"
729 1.231 rillig * C99 6.3.2 "Other operands"
730 1.231 rillig * C99 6.3.2.1 "Lvalues, arrays, and function designators"
731 1.1 cgd */
732 1.1 cgd tnode_t *
733 1.20 lukem cconv(tnode_t *tn)
734 1.1 cgd {
735 1.1 cgd type_t *tp;
736 1.1 cgd
737 1.1 cgd /*
738 1.1 cgd * Array-lvalue (array of type T) is converted into rvalue
739 1.1 cgd * (pointer to type T)
740 1.1 cgd */
741 1.1 cgd if (tn->tn_type->t_tspec == ARRAY) {
742 1.1 cgd if (!tn->tn_lvalue) {
743 1.118 rillig /* XXX print correct operator */
744 1.1 cgd /* %soperand of '%s' must be lvalue */
745 1.261 rillig gnuism(114, "", op_name(ADDR));
746 1.1 cgd }
747 1.257 rillig tn = new_tnode(ADDR,
748 1.257 rillig expr_derive_type(tn->tn_type->t_subt, PTR), tn, NULL);
749 1.1 cgd }
750 1.1 cgd
751 1.1 cgd /*
752 1.1 cgd * Expression of type function (function with return value of type T)
753 1.1 cgd * in rvalue-expression (pointer to function with return value
754 1.1 cgd * of type T)
755 1.1 cgd */
756 1.1 cgd if (tn->tn_type->t_tspec == FUNC)
757 1.172 rillig tn = build_address(tn, true);
758 1.1 cgd
759 1.1 cgd /* lvalue to rvalue */
760 1.1 cgd if (tn->tn_lvalue) {
761 1.258 rillig tp = expr_dup_type(tn->tn_type);
762 1.312 rillig /* C99 6.3.2.1p2 sentence 2 says to remove the qualifiers. */
763 1.154 rillig tp->t_const = tp->t_volatile = false;
764 1.100 rillig tn = new_tnode(LOAD, tp, tn, NULL);
765 1.1 cgd }
766 1.1 cgd
767 1.95 rillig return tn;
768 1.1 cgd }
769 1.1 cgd
770 1.266 rillig const tnode_t *
771 1.151 rillig before_conversion(const tnode_t *tn)
772 1.151 rillig {
773 1.151 rillig while (tn->tn_op == CVT && !tn->tn_cast)
774 1.151 rillig tn = tn->tn_left;
775 1.151 rillig return tn;
776 1.151 rillig }
777 1.151 rillig
778 1.190 rillig static bool
779 1.190 rillig is_null_pointer(const tnode_t *tn)
780 1.190 rillig {
781 1.190 rillig tspec_t t = tn->tn_type->t_tspec;
782 1.190 rillig
783 1.190 rillig return ((t == PTR && tn->tn_type->t_subt->t_tspec == VOID) ||
784 1.190 rillig is_integer(t))
785 1.190 rillig && (tn->tn_op == CON && tn->tn_val->v_quad == 0);
786 1.190 rillig }
787 1.190 rillig
788 1.375 rillig /*
789 1.375 rillig * Most errors required by ANSI C are reported in struct_or_union_member().
790 1.375 rillig * Here we only check for totally wrong things.
791 1.375 rillig */
792 1.375 rillig static bool
793 1.375 rillig typeok_point(const tnode_t *ln, const type_t *ltp, tspec_t lt)
794 1.375 rillig {
795 1.375 rillig if (lt == FUNC || lt == VOID || ltp->t_bitfield ||
796 1.375 rillig ((lt != STRUCT && lt != UNION) && !ln->tn_lvalue)) {
797 1.375 rillig /* Without tflag we got already an error */
798 1.375 rillig if (tflag)
799 1.375 rillig /* unacceptable operand of '%s' */
800 1.375 rillig error(111, op_name(POINT));
801 1.375 rillig return false;
802 1.375 rillig }
803 1.375 rillig return true;
804 1.375 rillig }
805 1.375 rillig
806 1.375 rillig static bool
807 1.375 rillig typeok_arrow(tspec_t lt)
808 1.375 rillig {
809 1.375 rillig if (lt == PTR || (tflag && is_integer(lt)))
810 1.375 rillig return true;
811 1.375 rillig
812 1.375 rillig /* Without tflag we got already an error */
813 1.375 rillig if (tflag)
814 1.375 rillig /* unacceptable operand of '%s' */
815 1.375 rillig error(111, op_name(ARROW));
816 1.375 rillig return false;
817 1.375 rillig }
818 1.375 rillig
819 1.138 rillig static bool
820 1.261 rillig typeok_incdec(op_t op, const tnode_t *tn, const type_t *tp)
821 1.138 rillig {
822 1.138 rillig /* operand has scalar type (checked in typeok) */
823 1.149 rillig if (!tn->tn_lvalue) {
824 1.149 rillig if (tn->tn_op == CVT && tn->tn_cast &&
825 1.149 rillig tn->tn_left->tn_op == LOAD) {
826 1.138 rillig /* a cast does not yield an lvalue */
827 1.138 rillig error(163);
828 1.138 rillig }
829 1.138 rillig /* %soperand of '%s' must be lvalue */
830 1.261 rillig error(114, "", op_name(op));
831 1.138 rillig return false;
832 1.149 rillig } else if (tp->t_const) {
833 1.138 rillig if (!tflag)
834 1.176 rillig /* %soperand of '%s' must be modifiable lvalue */
835 1.261 rillig warning(115, "", op_name(op));
836 1.138 rillig }
837 1.138 rillig return true;
838 1.138 rillig }
839 1.138 rillig
840 1.139 rillig static bool
841 1.180 rillig typeok_address(const mod_t *mp,
842 1.342 rillig const tnode_t *tn, const type_t *tp, tspec_t t)
843 1.139 rillig {
844 1.149 rillig if (t == ARRAY || t == FUNC) {
845 1.168 rillig /* ok, a warning comes later (in build_address()) */
846 1.149 rillig } else if (!tn->tn_lvalue) {
847 1.149 rillig if (tn->tn_op == CVT && tn->tn_cast &&
848 1.149 rillig tn->tn_left->tn_op == LOAD) {
849 1.139 rillig /* a cast does not yield an lvalue */
850 1.139 rillig error(163);
851 1.139 rillig }
852 1.139 rillig /* %soperand of '%s' must be lvalue */
853 1.139 rillig error(114, "", mp->m_name);
854 1.139 rillig return false;
855 1.149 rillig } else if (is_scalar(t)) {
856 1.149 rillig if (tp->t_bitfield) {
857 1.139 rillig /* cannot take address of bit-field */
858 1.139 rillig error(112);
859 1.139 rillig return false;
860 1.139 rillig }
861 1.149 rillig } else if (t != STRUCT && t != UNION) {
862 1.139 rillig /* unacceptable operand of '%s' */
863 1.139 rillig error(111, mp->m_name);
864 1.139 rillig return false;
865 1.139 rillig }
866 1.149 rillig if (tn->tn_op == NAME && tn->tn_sym->s_reg) {
867 1.139 rillig /* cannot take address of register %s */
868 1.149 rillig error(113, tn->tn_sym->s_name);
869 1.139 rillig return false;
870 1.139 rillig }
871 1.139 rillig return true;
872 1.139 rillig }
873 1.139 rillig
874 1.140 rillig static bool
875 1.375 rillig typeok_indir(tspec_t t)
876 1.140 rillig {
877 1.140 rillig /* until now there were no type checks for this operator */
878 1.149 rillig if (t != PTR) {
879 1.140 rillig /* cannot dereference non-pointer type */
880 1.140 rillig error(96);
881 1.140 rillig return false;
882 1.140 rillig }
883 1.140 rillig return true;
884 1.140 rillig }
885 1.140 rillig
886 1.140 rillig static bool
887 1.246 rillig typeok_plus(op_t op,
888 1.246 rillig const type_t *ltp, tspec_t lt,
889 1.246 rillig const type_t *rtp, tspec_t rt)
890 1.140 rillig {
891 1.140 rillig /* operands have scalar types (checked above) */
892 1.144 rillig if ((lt == PTR && !is_integer(rt)) || (rt == PTR && !is_integer(lt))) {
893 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
894 1.140 rillig return false;
895 1.140 rillig }
896 1.140 rillig return true;
897 1.140 rillig }
898 1.140 rillig
899 1.140 rillig static bool
900 1.149 rillig typeok_minus(op_t op,
901 1.149 rillig const type_t *ltp, tspec_t lt,
902 1.149 rillig const type_t *rtp, tspec_t rt)
903 1.140 rillig {
904 1.140 rillig /* operands have scalar types (checked above) */
905 1.144 rillig if (lt == PTR && (!is_integer(rt) && rt != PTR)) {
906 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
907 1.140 rillig return false;
908 1.140 rillig } else if (rt == PTR && lt != PTR) {
909 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
910 1.140 rillig return false;
911 1.140 rillig }
912 1.140 rillig if (lt == PTR && rt == PTR) {
913 1.172 rillig if (!eqtype(ltp->t_subt, rtp->t_subt, true, false, NULL)) {
914 1.140 rillig /* illegal pointer subtraction */
915 1.140 rillig error(116);
916 1.140 rillig }
917 1.140 rillig }
918 1.140 rillig return true;
919 1.140 rillig }
920 1.140 rillig
921 1.140 rillig static void
922 1.149 rillig typeok_shr(const mod_t *mp,
923 1.149 rillig const tnode_t *ln, tspec_t lt,
924 1.149 rillig const tnode_t *rn, tspec_t rt)
925 1.140 rillig {
926 1.143 rillig tspec_t olt, ort;
927 1.143 rillig
928 1.151 rillig olt = before_conversion(ln)->tn_type->t_tspec;
929 1.151 rillig ort = before_conversion(rn)->tn_type->t_tspec;
930 1.143 rillig
931 1.140 rillig /* operands have integer types (checked above) */
932 1.335 rillig if (pflag && !is_uinteger(olt)) {
933 1.140 rillig /*
934 1.140 rillig * The left operand is signed. This means that
935 1.140 rillig * the operation is (possibly) nonportable.
936 1.140 rillig */
937 1.140 rillig if (ln->tn_op != CON) {
938 1.200 rillig /* bitwise '%s' on signed value possibly nonportable */
939 1.200 rillig warning(117, mp->m_name);
940 1.140 rillig } else if (ln->tn_val->v_quad < 0) {
941 1.200 rillig /* bitwise '%s' on signed value nonportable */
942 1.200 rillig warning(120, mp->m_name);
943 1.140 rillig }
944 1.144 rillig } else if (!tflag && !sflag && !is_uinteger(olt) && is_uinteger(ort)) {
945 1.140 rillig /*
946 1.140 rillig * The left operand would become unsigned in
947 1.140 rillig * traditional C.
948 1.140 rillig */
949 1.271 rillig if (hflag && !Sflag &&
950 1.140 rillig (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
951 1.177 rillig /* semantics of '%s' change in ANSI C; use ... */
952 1.140 rillig warning(118, mp->m_name);
953 1.140 rillig }
954 1.144 rillig } else if (!tflag && !sflag && !is_uinteger(olt) && !is_uinteger(ort) &&
955 1.228 rillig portable_size_in_bits(lt) < portable_size_in_bits(rt)) {
956 1.140 rillig /*
957 1.140 rillig * In traditional C the left operand would be extended,
958 1.140 rillig * possibly with 1, and then shifted.
959 1.140 rillig */
960 1.271 rillig if (hflag && !Sflag &&
961 1.140 rillig (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
962 1.140 rillig /* semantics of '%s' change in ANSI C; use ... */
963 1.140 rillig warning(118, mp->m_name);
964 1.140 rillig }
965 1.140 rillig }
966 1.140 rillig }
967 1.140 rillig
968 1.140 rillig static void
969 1.182 rillig typeok_shl(const mod_t *mp, tspec_t lt, tspec_t rt)
970 1.182 rillig {
971 1.140 rillig /*
972 1.182 rillig * C90 does not perform balancing for shift operations,
973 1.140 rillig * but traditional C does. If the width of the right operand
974 1.182 rillig * is greater than the width of the left operand, then in
975 1.140 rillig * traditional C the left operand would be extended to the
976 1.140 rillig * width of the right operand. For SHL this may result in
977 1.140 rillig * different results.
978 1.140 rillig */
979 1.228 rillig if (portable_size_in_bits(lt) < portable_size_in_bits(rt)) {
980 1.140 rillig /*
981 1.140 rillig * XXX If both operands are constant, make sure
982 1.140 rillig * that there is really a difference between
983 1.140 rillig * ANSI C and traditional C.
984 1.140 rillig */
985 1.271 rillig if (hflag && !Sflag)
986 1.140 rillig /* semantics of '%s' change in ANSI C; use ... */
987 1.140 rillig warning(118, mp->m_name);
988 1.140 rillig }
989 1.140 rillig }
990 1.140 rillig
991 1.140 rillig static void
992 1.149 rillig typeok_shift(tspec_t lt, const tnode_t *rn, tspec_t rt)
993 1.140 rillig {
994 1.270 rillig if (rn->tn_op != CON)
995 1.270 rillig return;
996 1.270 rillig
997 1.270 rillig if (!is_uinteger(rt) && rn->tn_val->v_quad < 0) {
998 1.270 rillig /* negative shift */
999 1.270 rillig warning(121);
1000 1.270 rillig } else if ((uint64_t)rn->tn_val->v_quad ==
1001 1.270 rillig (uint64_t)size_in_bits(lt)) {
1002 1.270 rillig /* shift equal to size of object */
1003 1.270 rillig warning(267);
1004 1.270 rillig } else if ((uint64_t)rn->tn_val->v_quad > (uint64_t)size_in_bits(lt)) {
1005 1.270 rillig /* shift amount %llu is greater than bit-size %llu of '%s' */
1006 1.270 rillig warning(122, (unsigned long long)rn->tn_val->v_quad,
1007 1.270 rillig (unsigned long long)size_in_bits(lt),
1008 1.270 rillig tspec_name(lt));
1009 1.140 rillig }
1010 1.140 rillig }
1011 1.140 rillig
1012 1.140 rillig static bool
1013 1.187 rillig is_typeok_eq(const tnode_t *ln, tspec_t lt, const tnode_t *rn, tspec_t rt)
1014 1.140 rillig {
1015 1.190 rillig if (lt == PTR && is_null_pointer(rn))
1016 1.190 rillig return true;
1017 1.190 rillig if (rt == PTR && is_null_pointer(ln))
1018 1.190 rillig return true;
1019 1.140 rillig return false;
1020 1.140 rillig }
1021 1.140 rillig
1022 1.140 rillig static bool
1023 1.375 rillig typeok_compare(op_t op,
1024 1.375 rillig const tnode_t *ln, const type_t *ltp, tspec_t lt,
1025 1.375 rillig const tnode_t *rn, const type_t *rtp, tspec_t rt)
1026 1.140 rillig {
1027 1.178 rillig if (lt == PTR && rt == PTR) {
1028 1.140 rillig check_pointer_comparison(op, ln, rn);
1029 1.178 rillig return true;
1030 1.140 rillig }
1031 1.178 rillig
1032 1.178 rillig if (lt != PTR && rt != PTR)
1033 1.178 rillig return true;
1034 1.178 rillig
1035 1.178 rillig if (!is_integer(lt) && !is_integer(rt)) {
1036 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
1037 1.178 rillig return false;
1038 1.178 rillig }
1039 1.178 rillig
1040 1.178 rillig const char *lx = lt == PTR ? "pointer" : "integer";
1041 1.178 rillig const char *rx = rt == PTR ? "pointer" : "integer";
1042 1.178 rillig /* illegal combination of %s (%s) and %s (%s), op %s */
1043 1.260 rillig warning(123, lx, type_name(ltp), rx, type_name(rtp), op_name(op));
1044 1.140 rillig return true;
1045 1.140 rillig }
1046 1.140 rillig
1047 1.140 rillig static bool
1048 1.373 rillig typeok_quest(tspec_t lt, const tnode_t *rn)
1049 1.140 rillig {
1050 1.144 rillig if (!is_scalar(lt)) {
1051 1.140 rillig /* first operand must have scalar type, op ? : */
1052 1.140 rillig error(170);
1053 1.140 rillig return false;
1054 1.140 rillig }
1055 1.373 rillig lint_assert(before_conversion(rn)->tn_op == COLON);
1056 1.140 rillig return true;
1057 1.140 rillig }
1058 1.140 rillig
1059 1.206 rillig static void
1060 1.212 rillig typeok_colon_pointer(const mod_t *mp, const type_t *ltp, const type_t *rtp)
1061 1.206 rillig {
1062 1.206 rillig type_t *lstp = ltp->t_subt;
1063 1.206 rillig type_t *rstp = rtp->t_subt;
1064 1.206 rillig tspec_t lst = lstp->t_tspec;
1065 1.206 rillig tspec_t rst = rstp->t_tspec;
1066 1.206 rillig
1067 1.206 rillig if ((lst == VOID && rst == FUNC) || (lst == FUNC && rst == VOID)) {
1068 1.206 rillig /* (void *)0 handled above */
1069 1.206 rillig if (sflag)
1070 1.377 rillig /* ANSI C forbids conversion of %s to %s, op %s */
1071 1.206 rillig warning(305, "function pointer", "'void *'",
1072 1.206 rillig mp->m_name);
1073 1.206 rillig return;
1074 1.206 rillig }
1075 1.206 rillig
1076 1.206 rillig if (eqptrtype(lstp, rstp, true))
1077 1.206 rillig return;
1078 1.206 rillig if (!eqtype(lstp, rstp, true, false, NULL))
1079 1.206 rillig warn_incompatible_pointers(mp, ltp, rtp);
1080 1.206 rillig }
1081 1.206 rillig
1082 1.140 rillig static bool
1083 1.149 rillig typeok_colon(const mod_t *mp,
1084 1.149 rillig const tnode_t *ln, const type_t *ltp, tspec_t lt,
1085 1.149 rillig const tnode_t *rn, const type_t *rtp, tspec_t rt)
1086 1.140 rillig {
1087 1.142 rillig
1088 1.144 rillig if (is_arithmetic(lt) && is_arithmetic(rt))
1089 1.140 rillig return true;
1090 1.165 rillig if (lt == BOOL && rt == BOOL)
1091 1.165 rillig return true;
1092 1.140 rillig
1093 1.140 rillig if (lt == STRUCT && rt == STRUCT && ltp->t_str == rtp->t_str)
1094 1.140 rillig return true;
1095 1.140 rillig if (lt == UNION && rt == UNION && ltp->t_str == rtp->t_str)
1096 1.140 rillig return true;
1097 1.140 rillig
1098 1.190 rillig if (lt == PTR && is_null_pointer(rn))
1099 1.190 rillig return true;
1100 1.190 rillig if (rt == PTR && is_null_pointer(ln))
1101 1.190 rillig return true;
1102 1.140 rillig
1103 1.144 rillig if ((lt == PTR && is_integer(rt)) || (is_integer(lt) && rt == PTR)) {
1104 1.342 rillig const char *lx = lt == PTR ? "pointer" : "integer";
1105 1.342 rillig const char *rx = rt == PTR ? "pointer" : "integer";
1106 1.140 rillig /* illegal combination of %s (%s) and %s (%s), op %s */
1107 1.140 rillig warning(123, lx, type_name(ltp),
1108 1.140 rillig rx, type_name(rtp), mp->m_name);
1109 1.140 rillig return true;
1110 1.140 rillig }
1111 1.140 rillig
1112 1.140 rillig if (lt == VOID || rt == VOID) {
1113 1.140 rillig if (lt != VOID || rt != VOID)
1114 1.179 rillig /* incompatible types '%s' and '%s' in conditional */
1115 1.179 rillig warning(126, type_name(ltp), type_name(rtp));
1116 1.140 rillig return true;
1117 1.140 rillig }
1118 1.140 rillig
1119 1.206 rillig if (lt == PTR && rt == PTR) {
1120 1.212 rillig typeok_colon_pointer(mp, ltp, rtp);
1121 1.140 rillig return true;
1122 1.140 rillig }
1123 1.140 rillig
1124 1.179 rillig /* incompatible types '%s' and '%s' in conditional */
1125 1.179 rillig error(126, type_name(ltp), type_name(rtp));
1126 1.140 rillig return false;
1127 1.140 rillig }
1128 1.140 rillig
1129 1.140 rillig static bool
1130 1.332 rillig typeok_assign(op_t op, const tnode_t *ln, const type_t *ltp, tspec_t lt)
1131 1.140 rillig {
1132 1.332 rillig if (op == RETURN || op == INIT || op == FARG)
1133 1.332 rillig return true;
1134 1.332 rillig
1135 1.140 rillig if (!ln->tn_lvalue) {
1136 1.140 rillig if (ln->tn_op == CVT && ln->tn_cast &&
1137 1.140 rillig ln->tn_left->tn_op == LOAD) {
1138 1.140 rillig /* a cast does not yield an lvalue */
1139 1.140 rillig error(163);
1140 1.140 rillig }
1141 1.140 rillig /* %soperand of '%s' must be lvalue */
1142 1.332 rillig error(114, "left ", op_name(op));
1143 1.140 rillig return false;
1144 1.140 rillig } else if (ltp->t_const || ((lt == STRUCT || lt == UNION) &&
1145 1.140 rillig has_constant_member(ltp))) {
1146 1.140 rillig if (!tflag)
1147 1.140 rillig /* %soperand of '%s' must be modifiable lvalue */
1148 1.332 rillig warning(115, "left ", op_name(op));
1149 1.140 rillig }
1150 1.140 rillig return true;
1151 1.140 rillig }
1152 1.140 rillig
1153 1.150 rillig /* Check the types using the information from modtab[]. */
1154 1.150 rillig static bool
1155 1.246 rillig typeok_scalar(op_t op, const mod_t *mp,
1156 1.246 rillig const type_t *ltp, tspec_t lt,
1157 1.246 rillig const type_t *rtp, tspec_t rt)
1158 1.1 cgd {
1159 1.165 rillig if (mp->m_takes_bool && lt == BOOL && rt == BOOL)
1160 1.165 rillig return true;
1161 1.93 rillig if (mp->m_requires_integer) {
1162 1.144 rillig if (!is_integer(lt) || (mp->m_binary && !is_integer(rt))) {
1163 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
1164 1.141 rillig return false;
1165 1.1 cgd }
1166 1.93 rillig } else if (mp->m_requires_integer_or_complex) {
1167 1.144 rillig if ((!is_integer(lt) && !is_complex(lt)) ||
1168 1.144 rillig (mp->m_binary && (!is_integer(rt) && !is_complex(rt)))) {
1169 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
1170 1.141 rillig return false;
1171 1.46 christos }
1172 1.93 rillig } else if (mp->m_requires_scalar) {
1173 1.144 rillig if (!is_scalar(lt) || (mp->m_binary && !is_scalar(rt))) {
1174 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
1175 1.141 rillig return false;
1176 1.1 cgd }
1177 1.93 rillig } else if (mp->m_requires_arith) {
1178 1.144 rillig if (!is_arithmetic(lt) ||
1179 1.144 rillig (mp->m_binary && !is_arithmetic(rt))) {
1180 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
1181 1.141 rillig return false;
1182 1.1 cgd }
1183 1.1 cgd }
1184 1.150 rillig return true;
1185 1.150 rillig }
1186 1.1 cgd
1187 1.375 rillig /*
1188 1.375 rillig * Check the types for specific operators and type combinations.
1189 1.375 rillig *
1190 1.375 rillig * At this point, the operands already conform to the type requirements of
1191 1.375 rillig * the operator, such as being integer, floating or scalar.
1192 1.375 rillig */
1193 1.150 rillig static bool
1194 1.150 rillig typeok_op(op_t op, const mod_t *mp, int arg,
1195 1.150 rillig const tnode_t *ln, const type_t *ltp, tspec_t lt,
1196 1.150 rillig const tnode_t *rn, const type_t *rtp, tspec_t rt)
1197 1.150 rillig {
1198 1.1 cgd switch (op) {
1199 1.376 rillig case ARROW:
1200 1.376 rillig return typeok_arrow(lt);
1201 1.1 cgd case POINT:
1202 1.375 rillig return typeok_point(ln, ltp, lt);
1203 1.376 rillig case INCBEF:
1204 1.376 rillig case DECBEF:
1205 1.1 cgd case INCAFT:
1206 1.1 cgd case DECAFT:
1207 1.374 rillig return typeok_incdec(op, ln, ltp);
1208 1.376 rillig case INDIR:
1209 1.376 rillig return typeok_indir(lt);
1210 1.169 rillig case ADDR:
1211 1.374 rillig return typeok_address(mp, ln, ltp, lt);
1212 1.1 cgd case PLUS:
1213 1.374 rillig return typeok_plus(op, ltp, lt, rtp, rt);
1214 1.1 cgd case MINUS:
1215 1.374 rillig return typeok_minus(op, ltp, lt, rtp, rt);
1216 1.376 rillig case SHL:
1217 1.376 rillig typeok_shl(mp, lt, rt);
1218 1.376 rillig goto shift;
1219 1.1 cgd case SHR:
1220 1.143 rillig typeok_shr(mp, ln, lt, rn, rt);
1221 1.1 cgd shift:
1222 1.140 rillig typeok_shift(lt, rn, rt);
1223 1.1 cgd break;
1224 1.376 rillig case LT:
1225 1.376 rillig case LE:
1226 1.376 rillig case GT:
1227 1.376 rillig case GE:
1228 1.376 rillig compare:
1229 1.376 rillig return typeok_compare(op, ln, ltp, lt, rn, rtp, rt);
1230 1.1 cgd case EQ:
1231 1.1 cgd case NE:
1232 1.187 rillig if (is_typeok_eq(ln, lt, rn, rt))
1233 1.140 rillig break;
1234 1.376 rillig goto compare;
1235 1.1 cgd case QUEST:
1236 1.374 rillig return typeok_quest(lt, rn);
1237 1.1 cgd case COLON:
1238 1.374 rillig return typeok_colon(mp, ln, ltp, lt, rn, rtp, rt);
1239 1.1 cgd case ASSIGN:
1240 1.1 cgd case INIT:
1241 1.1 cgd case FARG:
1242 1.1 cgd case RETURN:
1243 1.100 rillig if (!check_assign_types_compatible(op, arg, ln, rn))
1244 1.141 rillig return false;
1245 1.1 cgd goto assign;
1246 1.1 cgd case MULASS:
1247 1.1 cgd case DIVASS:
1248 1.1 cgd case MODASS:
1249 1.1 cgd goto assign;
1250 1.1 cgd case ADDASS:
1251 1.1 cgd case SUBASS:
1252 1.144 rillig if ((lt == PTR && !is_integer(rt)) || rt == PTR) {
1253 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
1254 1.141 rillig return false;
1255 1.1 cgd }
1256 1.1 cgd goto assign;
1257 1.1 cgd case SHLASS:
1258 1.1 cgd goto assign;
1259 1.1 cgd case SHRASS:
1260 1.144 rillig if (pflag && !is_uinteger(lt) && !(tflag && is_uinteger(rt))) {
1261 1.200 rillig /* bitwise '%s' on signed value possibly nonportable */
1262 1.200 rillig warning(117, mp->m_name);
1263 1.1 cgd }
1264 1.1 cgd goto assign;
1265 1.1 cgd case ANDASS:
1266 1.1 cgd case XORASS:
1267 1.1 cgd case ORASS:
1268 1.1 cgd assign:
1269 1.374 rillig return typeok_assign(op, ln, ltp, lt);
1270 1.1 cgd case COMMA:
1271 1.164 rillig if (!modtab[ln->tn_op].m_has_side_effect)
1272 1.100 rillig check_null_effect(ln);
1273 1.1 cgd break;
1274 1.375 rillig default:
1275 1.14 christos break;
1276 1.1 cgd }
1277 1.150 rillig return true;
1278 1.150 rillig }
1279 1.1 cgd
1280 1.150 rillig static void
1281 1.150 rillig typeok_enum(op_t op, const mod_t *mp, int arg,
1282 1.150 rillig const tnode_t *ln, const type_t *ltp,
1283 1.150 rillig const tnode_t *rn, const type_t *rtp)
1284 1.150 rillig {
1285 1.93 rillig if (mp->m_bad_on_enum &&
1286 1.209 rillig (ltp->t_is_enum || (mp->m_binary && rtp->t_is_enum))) {
1287 1.100 rillig check_bad_enum_operation(op, ln, rn);
1288 1.93 rillig } else if (mp->m_valid_on_enum &&
1289 1.209 rillig (ltp->t_is_enum && rtp != NULL && rtp->t_is_enum)) {
1290 1.100 rillig check_enum_type_mismatch(op, arg, ln, rn);
1291 1.93 rillig } else if (mp->m_valid_on_enum &&
1292 1.209 rillig (ltp->t_is_enum || (rtp != NULL && rtp->t_is_enum))) {
1293 1.100 rillig check_enum_int_mismatch(op, arg, ln, rn);
1294 1.1 cgd }
1295 1.150 rillig }
1296 1.150 rillig
1297 1.150 rillig /* Perform most type checks. Return whether the types are ok. */
1298 1.150 rillig bool
1299 1.150 rillig typeok(op_t op, int arg, const tnode_t *ln, const tnode_t *rn)
1300 1.150 rillig {
1301 1.240 rillig const mod_t *mp;
1302 1.150 rillig tspec_t lt, rt;
1303 1.150 rillig type_t *ltp, *rtp;
1304 1.150 rillig
1305 1.150 rillig mp = &modtab[op];
1306 1.150 rillig
1307 1.150 rillig lint_assert((ltp = ln->tn_type) != NULL);
1308 1.150 rillig lt = ltp->t_tspec;
1309 1.150 rillig
1310 1.150 rillig if (mp->m_binary) {
1311 1.150 rillig lint_assert((rtp = rn->tn_type) != NULL);
1312 1.150 rillig rt = rtp->t_tspec;
1313 1.150 rillig } else {
1314 1.150 rillig rtp = NULL;
1315 1.150 rillig rt = NOTSPEC;
1316 1.150 rillig }
1317 1.150 rillig
1318 1.151 rillig if (Tflag && !typeok_scalar_strict_bool(op, mp, arg, ln, rn))
1319 1.151 rillig return false;
1320 1.246 rillig if (!typeok_scalar(op, mp, ltp, lt, rtp, rt))
1321 1.150 rillig return false;
1322 1.150 rillig
1323 1.150 rillig if (!typeok_op(op, mp, arg, ln, ltp, lt, rn, rtp, rt))
1324 1.150 rillig return false;
1325 1.1 cgd
1326 1.150 rillig typeok_enum(op, mp, arg, ln, ltp, rn, rtp);
1327 1.141 rillig return true;
1328 1.1 cgd }
1329 1.1 cgd
1330 1.1 cgd static void
1331 1.149 rillig check_pointer_comparison(op_t op, const tnode_t *ln, const tnode_t *rn)
1332 1.1 cgd {
1333 1.1 cgd type_t *ltp, *rtp;
1334 1.187 rillig tspec_t lst, rst;
1335 1.188 rillig const char *lsts, *rsts;
1336 1.1 cgd
1337 1.187 rillig lst = (ltp = ln->tn_type)->t_subt->t_tspec;
1338 1.187 rillig rst = (rtp = rn->tn_type)->t_subt->t_tspec;
1339 1.1 cgd
1340 1.187 rillig if (lst == VOID || rst == VOID) {
1341 1.187 rillig if (sflag && (lst == FUNC || rst == FUNC)) {
1342 1.1 cgd /* (void *)0 already handled in typeok() */
1343 1.188 rillig *(lst == FUNC ? &lsts : &rsts) = "function pointer";
1344 1.188 rillig *(lst == VOID ? &lsts : &rsts) = "'void *'";
1345 1.17 mycroft /* ANSI C forbids comparison of %s with %s */
1346 1.188 rillig warning(274, lsts, rsts);
1347 1.1 cgd }
1348 1.1 cgd return;
1349 1.1 cgd }
1350 1.1 cgd
1351 1.172 rillig if (!eqtype(ltp->t_subt, rtp->t_subt, true, false, NULL)) {
1352 1.98 rillig warn_incompatible_pointers(&modtab[op], ltp, rtp);
1353 1.1 cgd return;
1354 1.1 cgd }
1355 1.1 cgd
1356 1.187 rillig if (lst == FUNC && rst == FUNC) {
1357 1.1 cgd if (sflag && op != EQ && op != NE)
1358 1.108 rillig /* ANSI C forbids ordered comparisons of ... */
1359 1.1 cgd warning(125);
1360 1.1 cgd }
1361 1.1 cgd }
1362 1.1 cgd
1363 1.331 rillig static bool
1364 1.336 rillig is_direct_function_call(const tnode_t *tn, const char **out_name)
1365 1.331 rillig {
1366 1.336 rillig
1367 1.336 rillig if (!(tn->tn_op == CALL &&
1368 1.336 rillig tn->tn_left->tn_op == ADDR &&
1369 1.336 rillig tn->tn_left->tn_left->tn_op == NAME))
1370 1.336 rillig return false;
1371 1.336 rillig
1372 1.336 rillig *out_name = tn->tn_left->tn_left->tn_sym->s_name;
1373 1.336 rillig return true;
1374 1.336 rillig }
1375 1.336 rillig
1376 1.336 rillig static bool
1377 1.336 rillig is_unconst_function(const char *name)
1378 1.336 rillig {
1379 1.336 rillig
1380 1.336 rillig return strcmp(name, "memchr") == 0 ||
1381 1.336 rillig strcmp(name, "strchr") == 0 ||
1382 1.336 rillig strcmp(name, "strpbrk") == 0 ||
1383 1.336 rillig strcmp(name, "strrchr") == 0 ||
1384 1.336 rillig strcmp(name, "strstr") == 0;
1385 1.331 rillig }
1386 1.331 rillig
1387 1.331 rillig static bool
1388 1.331 rillig is_const_char_pointer(const tnode_t *tn)
1389 1.331 rillig {
1390 1.331 rillig const type_t *tp;
1391 1.331 rillig
1392 1.331 rillig /*
1393 1.331 rillig * For traditional reasons, C99 6.4.5p5 defines that string literals
1394 1.331 rillig * have type 'char[]'. They are often implicitly converted to
1395 1.331 rillig * 'char *', for example when they are passed as function arguments.
1396 1.331 rillig *
1397 1.331 rillig * C99 6.4.5p6 further defines that modifying a string that is
1398 1.331 rillig * constructed from a string literal invokes undefined behavior.
1399 1.331 rillig *
1400 1.331 rillig * Out of these reasons, string literals are treated as 'effectively
1401 1.331 rillig * const' here.
1402 1.331 rillig */
1403 1.331 rillig if (tn->tn_op == CVT &&
1404 1.331 rillig tn->tn_left->tn_op == ADDR &&
1405 1.331 rillig tn->tn_left->tn_left->tn_op == STRING)
1406 1.331 rillig return true;
1407 1.331 rillig
1408 1.331 rillig tp = before_conversion(tn)->tn_type;
1409 1.331 rillig return tp->t_tspec == PTR &&
1410 1.331 rillig tp->t_subt->t_tspec == CHAR &&
1411 1.331 rillig tp->t_subt->t_const;
1412 1.331 rillig }
1413 1.331 rillig
1414 1.331 rillig static bool
1415 1.336 rillig is_first_arg_const(const tnode_t *tn)
1416 1.331 rillig {
1417 1.336 rillig const tnode_t *an;
1418 1.336 rillig
1419 1.336 rillig an = tn->tn_right;
1420 1.336 rillig if (an == NULL)
1421 1.336 rillig return false;
1422 1.336 rillig
1423 1.336 rillig while (an->tn_right != NULL)
1424 1.336 rillig an = an->tn_right;
1425 1.336 rillig return is_const_char_pointer(an->tn_left);
1426 1.331 rillig }
1427 1.331 rillig
1428 1.331 rillig static void
1429 1.378 rillig check_unconst_function(const type_t *lstp, const tnode_t *rn)
1430 1.331 rillig {
1431 1.336 rillig const char *function_name;
1432 1.336 rillig
1433 1.331 rillig if (lstp->t_tspec == CHAR && !lstp->t_const &&
1434 1.336 rillig is_direct_function_call(rn, &function_name) &&
1435 1.336 rillig is_unconst_function(function_name) &&
1436 1.336 rillig is_first_arg_const(rn)) {
1437 1.331 rillig /* call to '%s' effectively discards 'const' from argument */
1438 1.336 rillig warning(346, function_name);
1439 1.331 rillig }
1440 1.331 rillig }
1441 1.331 rillig
1442 1.369 rillig static void
1443 1.369 rillig check_assign_void_pointer(op_t op, int arg,
1444 1.369 rillig tspec_t lt, tspec_t lst,
1445 1.369 rillig tspec_t rt, tspec_t rst)
1446 1.1 cgd {
1447 1.369 rillig const char *lts, *rts;
1448 1.1 cgd
1449 1.369 rillig if (!(lt == PTR && rt == PTR && (lst == VOID || rst == VOID)))
1450 1.369 rillig return;
1451 1.369 rillig /* two pointers, at least one pointer to void */
1452 1.1 cgd
1453 1.369 rillig if (!(sflag && (lst == FUNC || rst == FUNC)))
1454 1.369 rillig return;
1455 1.369 rillig /* comb. of ptr to func and ptr to void */
1456 1.148 rillig
1457 1.369 rillig *(lst == FUNC ? <s : &rts) = "function pointer";
1458 1.369 rillig *(lst == VOID ? <s : &rts) = "'void *'";
1459 1.1 cgd
1460 1.369 rillig switch (op) {
1461 1.369 rillig case INIT:
1462 1.369 rillig case RETURN:
1463 1.369 rillig /* ANSI C forbids conversion of %s to %s */
1464 1.369 rillig warning(303, rts, lts);
1465 1.369 rillig break;
1466 1.369 rillig case FARG:
1467 1.377 rillig /* ANSI C forbids conversion of %s to %s, arg #%d */
1468 1.369 rillig warning(304, rts, lts, arg);
1469 1.369 rillig break;
1470 1.369 rillig default:
1471 1.377 rillig /* ANSI C forbids conversion of %s to %s, op %s */
1472 1.369 rillig warning(305, rts, lts, op_name(op));
1473 1.369 rillig break;
1474 1.1 cgd }
1475 1.369 rillig }
1476 1.1 cgd
1477 1.369 rillig static bool
1478 1.369 rillig check_assign_void_pointer_compat(op_t op, int arg,
1479 1.369 rillig const type_t *const ltp, tspec_t const lt,
1480 1.369 rillig const type_t *const lstp, tspec_t const lst,
1481 1.369 rillig const tnode_t *const rn,
1482 1.369 rillig const type_t *const rtp, tspec_t const rt,
1483 1.369 rillig const type_t *const rstp, tspec_t const rst)
1484 1.369 rillig {
1485 1.369 rillig if (!(lt == PTR && rt == PTR && (lst == VOID || rst == VOID ||
1486 1.369 rillig eqtype(lstp, rstp, true, false, NULL))))
1487 1.369 rillig return false;
1488 1.82 christos
1489 1.369 rillig /* compatible pointer types (qualifiers ignored) */
1490 1.369 rillig if (!tflag &&
1491 1.369 rillig ((!lstp->t_const && rstp->t_const) ||
1492 1.369 rillig (!lstp->t_volatile && rstp->t_volatile))) {
1493 1.369 rillig /* left side has not all qualifiers of right */
1494 1.1 cgd switch (op) {
1495 1.1 cgd case INIT:
1496 1.1 cgd case RETURN:
1497 1.369 rillig /* incompatible pointer types (%s != %s) */
1498 1.369 rillig warning(182, type_name(lstp), type_name(rstp));
1499 1.1 cgd break;
1500 1.1 cgd case FARG:
1501 1.369 rillig /* converting '%s' to incompatible '%s' ... */
1502 1.369 rillig warning(153,
1503 1.369 rillig type_name(rtp), type_name(ltp), arg);
1504 1.1 cgd break;
1505 1.1 cgd default:
1506 1.369 rillig /* operands have incompatible pointer type... */
1507 1.369 rillig warning(128, op_name(op),
1508 1.369 rillig type_name(lstp), type_name(rstp));
1509 1.1 cgd break;
1510 1.1 cgd }
1511 1.1 cgd }
1512 1.1 cgd
1513 1.369 rillig if (!tflag)
1514 1.378 rillig check_unconst_function(lstp, rn);
1515 1.369 rillig
1516 1.369 rillig return true;
1517 1.369 rillig }
1518 1.369 rillig
1519 1.369 rillig static bool
1520 1.369 rillig check_assign_pointer_integer(op_t op, int arg,
1521 1.369 rillig const type_t *const ltp, tspec_t const lt,
1522 1.369 rillig const type_t *const rtp, tspec_t const rt)
1523 1.369 rillig {
1524 1.369 rillig if (!((lt == PTR && is_integer(rt)) || (is_integer(lt) && rt == PTR)))
1525 1.369 rillig return false;
1526 1.369 rillig
1527 1.369 rillig const char *lx = lt == PTR ? "pointer" : "integer";
1528 1.369 rillig const char *rx = rt == PTR ? "pointer" : "integer";
1529 1.369 rillig
1530 1.369 rillig switch (op) {
1531 1.369 rillig case INIT:
1532 1.369 rillig case RETURN:
1533 1.369 rillig /* illegal combination of %s (%s) and %s (%s) */
1534 1.369 rillig warning(183, lx, type_name(ltp), rx, type_name(rtp));
1535 1.369 rillig break;
1536 1.369 rillig case FARG:
1537 1.377 rillig /* illegal combination of %s (%s) and %s (%s), arg #%d */
1538 1.369 rillig warning(154,
1539 1.369 rillig lx, type_name(ltp), rx, type_name(rtp), arg);
1540 1.369 rillig break;
1541 1.369 rillig default:
1542 1.369 rillig /* illegal combination of %s (%s) and %s (%s), op %s */
1543 1.369 rillig warning(123,
1544 1.369 rillig lx, type_name(ltp), rx, type_name(rtp), op_name(op));
1545 1.369 rillig break;
1546 1.369 rillig }
1547 1.369 rillig return true;
1548 1.369 rillig }
1549 1.369 rillig
1550 1.369 rillig static bool
1551 1.369 rillig check_assign_pointer(op_t op, int arg,
1552 1.369 rillig const type_t *ltp, tspec_t lt,
1553 1.369 rillig const type_t *rtp, tspec_t rt)
1554 1.369 rillig {
1555 1.369 rillig if (!(lt == PTR && rt == PTR))
1556 1.369 rillig return false;
1557 1.369 rillig
1558 1.369 rillig switch (op) {
1559 1.369 rillig case RETURN:
1560 1.369 rillig warn_incompatible_pointers(NULL, ltp, rtp);
1561 1.369 rillig break;
1562 1.369 rillig case FARG:
1563 1.369 rillig /* converting '%s' to incompatible '%s' for ... */
1564 1.369 rillig warning(153, type_name(rtp), type_name(ltp), arg);
1565 1.369 rillig break;
1566 1.369 rillig default:
1567 1.369 rillig warn_incompatible_pointers(&modtab[op], ltp, rtp);
1568 1.369 rillig break;
1569 1.1 cgd }
1570 1.369 rillig return true;
1571 1.369 rillig }
1572 1.1 cgd
1573 1.369 rillig static void
1574 1.369 rillig warn_assign(op_t op, int arg,
1575 1.369 rillig const type_t *ltp, tspec_t lt,
1576 1.369 rillig const type_t *rtp, tspec_t rt)
1577 1.369 rillig {
1578 1.1 cgd switch (op) {
1579 1.1 cgd case INIT:
1580 1.234 rillig /* cannot initialize '%s' from '%s' */
1581 1.115 rillig error(185, type_name(ltp), type_name(rtp));
1582 1.1 cgd break;
1583 1.1 cgd case RETURN:
1584 1.108 rillig /* return value type mismatch (%s) and (%s) */
1585 1.115 rillig error(211, type_name(ltp), type_name(rtp));
1586 1.1 cgd break;
1587 1.1 cgd case FARG:
1588 1.293 rillig /* passing '%s' to incompatible '%s', arg #%d */
1589 1.293 rillig warning(155, type_name(rtp), type_name(ltp), arg);
1590 1.1 cgd break;
1591 1.1 cgd default:
1592 1.246 rillig warn_incompatible_types(op, ltp, lt, rtp, rt);
1593 1.1 cgd break;
1594 1.1 cgd }
1595 1.369 rillig }
1596 1.369 rillig
1597 1.369 rillig /*
1598 1.369 rillig * Checks type compatibility for ASSIGN, INIT, FARG and RETURN
1599 1.369 rillig * and prints warnings/errors if necessary.
1600 1.369 rillig * Returns whether the types are (almost) compatible.
1601 1.369 rillig */
1602 1.369 rillig static bool
1603 1.369 rillig check_assign_types_compatible(op_t op, int arg,
1604 1.369 rillig const tnode_t *ln, const tnode_t *rn)
1605 1.369 rillig {
1606 1.369 rillig tspec_t lt, rt, lst = NOTSPEC, rst = NOTSPEC;
1607 1.369 rillig type_t *ltp, *rtp, *lstp = NULL, *rstp = NULL;
1608 1.369 rillig
1609 1.369 rillig if ((lt = (ltp = ln->tn_type)->t_tspec) == PTR)
1610 1.369 rillig lst = (lstp = ltp->t_subt)->t_tspec;
1611 1.369 rillig if ((rt = (rtp = rn->tn_type)->t_tspec) == PTR)
1612 1.369 rillig rst = (rstp = rtp->t_subt)->t_tspec;
1613 1.369 rillig
1614 1.369 rillig if (lt == BOOL && is_scalar(rt)) /* C99 6.3.1.2 */
1615 1.369 rillig return true;
1616 1.369 rillig
1617 1.369 rillig if (is_arithmetic(lt) && (is_arithmetic(rt) || rt == BOOL))
1618 1.369 rillig return true;
1619 1.369 rillig
1620 1.369 rillig if ((lt == STRUCT || lt == UNION) && (rt == STRUCT || rt == UNION))
1621 1.369 rillig /* both are struct or union */
1622 1.369 rillig return ltp->t_str == rtp->t_str;
1623 1.369 rillig
1624 1.369 rillig /* a null pointer may be assigned to any pointer */
1625 1.369 rillig if (lt == PTR && is_null_pointer(rn))
1626 1.369 rillig return true;
1627 1.369 rillig
1628 1.369 rillig check_assign_void_pointer(op, arg, lt, lst, rt, rst);
1629 1.369 rillig
1630 1.369 rillig if (check_assign_void_pointer_compat(op, arg,
1631 1.369 rillig ltp, lt, lstp, lst, rn, rtp, rt, rstp, rst))
1632 1.369 rillig return true;
1633 1.369 rillig
1634 1.369 rillig if (check_assign_pointer_integer(op, arg, ltp, lt, rtp, rt))
1635 1.369 rillig return true;
1636 1.369 rillig
1637 1.369 rillig if (check_assign_pointer(op, arg, ltp, lt, rtp, rt))
1638 1.369 rillig return true;
1639 1.1 cgd
1640 1.369 rillig warn_assign(op, arg, ltp, lt, rtp, rt);
1641 1.154 rillig return false;
1642 1.1 cgd }
1643 1.1 cgd
1644 1.182 rillig /* Prints a warning if a strange operator is used on an enum type. */
1645 1.1 cgd static void
1646 1.149 rillig check_bad_enum_operation(op_t op, const tnode_t *ln, const tnode_t *rn)
1647 1.1 cgd {
1648 1.1 cgd
1649 1.1 cgd if (!eflag)
1650 1.1 cgd return;
1651 1.1 cgd
1652 1.1 cgd /*
1653 1.1 cgd * Enum as offset to a pointer is an exception (otherwise enums
1654 1.127 rillig * could not be used as array indices).
1655 1.1 cgd */
1656 1.1 cgd if (op == PLUS &&
1657 1.209 rillig ((ln->tn_type->t_is_enum && rn->tn_type->t_tspec == PTR) ||
1658 1.209 rillig (rn->tn_type->t_is_enum && ln->tn_type->t_tspec == PTR))) {
1659 1.1 cgd return;
1660 1.1 cgd }
1661 1.1 cgd
1662 1.1 cgd /* dubious operation on enum, op %s */
1663 1.260 rillig warning(241, op_name(op));
1664 1.1 cgd }
1665 1.1 cgd
1666 1.1 cgd /*
1667 1.1 cgd * Prints a warning if an operator is applied to two different enum types.
1668 1.1 cgd */
1669 1.1 cgd static void
1670 1.149 rillig check_enum_type_mismatch(op_t op, int arg, const tnode_t *ln, const tnode_t *rn)
1671 1.1 cgd {
1672 1.240 rillig const mod_t *mp;
1673 1.1 cgd
1674 1.1 cgd mp = &modtab[op];
1675 1.1 cgd
1676 1.1 cgd if (ln->tn_type->t_enum != rn->tn_type->t_enum) {
1677 1.1 cgd switch (op) {
1678 1.1 cgd case INIT:
1679 1.214 rillig /* enum type mismatch between '%s' and '%s' in ... */
1680 1.214 rillig warning(210,
1681 1.214 rillig type_name(ln->tn_type), type_name(rn->tn_type));
1682 1.1 cgd break;
1683 1.1 cgd case FARG:
1684 1.152 rillig /* enum type mismatch, arg #%d (%s != %s) */
1685 1.152 rillig warning(156, arg,
1686 1.152 rillig type_name(ln->tn_type), type_name(rn->tn_type));
1687 1.1 cgd break;
1688 1.1 cgd case RETURN:
1689 1.108 rillig /* return value type mismatch (%s) and (%s) */
1690 1.115 rillig warning(211,
1691 1.115 rillig type_name(ln->tn_type), type_name(rn->tn_type));
1692 1.1 cgd break;
1693 1.1 cgd default:
1694 1.224 rillig /* enum type mismatch: '%s' '%s' '%s' */
1695 1.224 rillig warning(130, type_name(ln->tn_type), mp->m_name,
1696 1.224 rillig type_name(rn->tn_type));
1697 1.1 cgd break;
1698 1.1 cgd }
1699 1.164 rillig } else if (Pflag && mp->m_comparison && op != EQ && op != NE) {
1700 1.1 cgd if (eflag)
1701 1.108 rillig /* dubious comparison of enums, op %s */
1702 1.1 cgd warning(243, mp->m_name);
1703 1.1 cgd }
1704 1.1 cgd }
1705 1.1 cgd
1706 1.182 rillig /* Prints a warning if the operands mix between enum and integer. */
1707 1.1 cgd static void
1708 1.149 rillig check_enum_int_mismatch(op_t op, int arg, const tnode_t *ln, const tnode_t *rn)
1709 1.1 cgd {
1710 1.20 lukem
1711 1.1 cgd if (!eflag)
1712 1.1 cgd return;
1713 1.1 cgd
1714 1.1 cgd switch (op) {
1715 1.1 cgd case INIT:
1716 1.1 cgd /*
1717 1.182 rillig * Initialization with 0 is allowed. Otherwise, all implicit
1718 1.182 rillig * initializations would need to be warned upon as well.
1719 1.1 cgd */
1720 1.209 rillig if (!rn->tn_type->t_is_enum && rn->tn_op == CON &&
1721 1.144 rillig is_integer(rn->tn_type->t_tspec) &&
1722 1.90 rillig rn->tn_val->v_quad == 0) {
1723 1.1 cgd return;
1724 1.1 cgd }
1725 1.218 rillig /* initialization of '%s' with '%s' */
1726 1.115 rillig warning(277, type_name(ln->tn_type), type_name(rn->tn_type));
1727 1.1 cgd break;
1728 1.1 cgd case FARG:
1729 1.1 cgd /* combination of '%s' and '%s', arg #%d */
1730 1.115 rillig warning(278,
1731 1.115 rillig type_name(ln->tn_type), type_name(rn->tn_type), arg);
1732 1.1 cgd break;
1733 1.1 cgd case RETURN:
1734 1.1 cgd /* combination of '%s' and '%s' in return */
1735 1.115 rillig warning(279, type_name(ln->tn_type), type_name(rn->tn_type));
1736 1.1 cgd break;
1737 1.1 cgd default:
1738 1.108 rillig /* combination of '%s' and '%s', op %s */
1739 1.115 rillig warning(242, type_name(ln->tn_type), type_name(rn->tn_type),
1740 1.260 rillig op_name(op));
1741 1.1 cgd break;
1742 1.1 cgd }
1743 1.1 cgd }
1744 1.1 cgd
1745 1.1 cgd /*
1746 1.1 cgd * Build and initialize a new node.
1747 1.1 cgd */
1748 1.1 cgd static tnode_t *
1749 1.100 rillig new_tnode(op_t op, type_t *type, tnode_t *ln, tnode_t *rn)
1750 1.1 cgd {
1751 1.1 cgd tnode_t *ntn;
1752 1.1 cgd tspec_t t;
1753 1.309 rillig #if 0 /* not yet */
1754 1.63 christos size_t l;
1755 1.63 christos uint64_t rnum;
1756 1.64 christos #endif
1757 1.1 cgd
1758 1.256 rillig ntn = expr_zalloc_tnode();
1759 1.1 cgd
1760 1.1 cgd ntn->tn_op = op;
1761 1.1 cgd ntn->tn_type = type;
1762 1.309 rillig ntn->tn_relaxed = ln->tn_relaxed || (rn != NULL && rn->tn_relaxed);
1763 1.1 cgd ntn->tn_left = ln;
1764 1.1 cgd ntn->tn_right = rn;
1765 1.1 cgd
1766 1.63 christos switch (op) {
1767 1.309 rillig #if 0 /* not yet */
1768 1.63 christos case SHR:
1769 1.63 christos if (rn->tn_op != CON)
1770 1.63 christos break;
1771 1.63 christos rnum = rn->tn_val->v_quad;
1772 1.236 rillig l = type_size_in_bits(ln->tn_type) / CHAR_SIZE;
1773 1.63 christos t = ln->tn_type->t_tspec;
1774 1.63 christos switch (l) {
1775 1.63 christos case 8:
1776 1.63 christos if (rnum >= 56)
1777 1.63 christos t = UCHAR;
1778 1.63 christos else if (rnum >= 48)
1779 1.63 christos t = USHORT;
1780 1.63 christos else if (rnum >= 32)
1781 1.63 christos t = UINT;
1782 1.63 christos break;
1783 1.63 christos case 4:
1784 1.63 christos if (rnum >= 24)
1785 1.63 christos t = UCHAR;
1786 1.63 christos else if (rnum >= 16)
1787 1.63 christos t = USHORT;
1788 1.63 christos break;
1789 1.63 christos case 2:
1790 1.63 christos if (rnum >= 8)
1791 1.63 christos t = UCHAR;
1792 1.63 christos break;
1793 1.63 christos default:
1794 1.63 christos break;
1795 1.63 christos }
1796 1.63 christos if (t != ln->tn_type->t_tspec)
1797 1.63 christos ntn->tn_type->t_tspec = t;
1798 1.63 christos break;
1799 1.64 christos #endif
1800 1.170 rillig case INDIR:
1801 1.63 christos case FSEL:
1802 1.107 rillig lint_assert(ln->tn_type->t_tspec == PTR);
1803 1.107 rillig t = ln->tn_type->t_subt->t_tspec;
1804 1.107 rillig if (t != FUNC && t != VOID)
1805 1.154 rillig ntn->tn_lvalue = true;
1806 1.63 christos break;
1807 1.63 christos default:
1808 1.63 christos break;
1809 1.1 cgd }
1810 1.1 cgd
1811 1.63 christos return ntn;
1812 1.1 cgd }
1813 1.1 cgd
1814 1.1 cgd /*
1815 1.182 rillig * Performs the "integer promotions" (C99 6.3.1.1p2), which convert small
1816 1.182 rillig * integer types to either int or unsigned int.
1817 1.1 cgd *
1818 1.182 rillig * If tflag is set or the operand is a function argument with no type
1819 1.182 rillig * information (no prototype or variable # of args), converts float to double.
1820 1.1 cgd */
1821 1.1 cgd tnode_t *
1822 1.154 rillig promote(op_t op, bool farg, tnode_t *tn)
1823 1.1 cgd {
1824 1.1 cgd tspec_t t;
1825 1.1 cgd type_t *ntp;
1826 1.353 rillig unsigned int len;
1827 1.1 cgd
1828 1.1 cgd t = tn->tn_type->t_tspec;
1829 1.1 cgd
1830 1.144 rillig if (!is_arithmetic(t))
1831 1.95 rillig return tn;
1832 1.1 cgd
1833 1.1 cgd if (!tflag) {
1834 1.1 cgd /*
1835 1.281 rillig * C99 6.3.1.1p2 requires for types with lower rank than int
1836 1.281 rillig * that "If an int can represent all the values of the
1837 1.281 rillig * original type, the value is converted to an int; otherwise
1838 1.281 rillig * it is converted to an unsigned int", and that "All other
1839 1.281 rillig * types are unchanged by the integer promotions".
1840 1.1 cgd */
1841 1.120 rillig if (tn->tn_type->t_bitfield) {
1842 1.1 cgd len = tn->tn_type->t_flen;
1843 1.281 rillig if (len < size_in_bits(INT)) {
1844 1.1 cgd t = INT;
1845 1.281 rillig } else if (len == size_in_bits(INT)) {
1846 1.281 rillig t = is_uinteger(t) ? UINT : INT;
1847 1.1 cgd }
1848 1.1 cgd } else if (t == CHAR || t == UCHAR || t == SCHAR) {
1849 1.228 rillig t = (size_in_bits(CHAR) < size_in_bits(INT)
1850 1.228 rillig || t != UCHAR) ? INT : UINT;
1851 1.1 cgd } else if (t == SHORT || t == USHORT) {
1852 1.228 rillig t = (size_in_bits(SHORT) < size_in_bits(INT)
1853 1.228 rillig || t == SHORT) ? INT : UINT;
1854 1.1 cgd } else if (t == ENUM) {
1855 1.1 cgd t = INT;
1856 1.1 cgd } else if (farg && t == FLOAT) {
1857 1.1 cgd t = DOUBLE;
1858 1.1 cgd }
1859 1.1 cgd } else {
1860 1.1 cgd /*
1861 1.1 cgd * In traditional C, keep unsigned and promote FLOAT
1862 1.1 cgd * to DOUBLE.
1863 1.1 cgd */
1864 1.1 cgd if (t == UCHAR || t == USHORT) {
1865 1.1 cgd t = UINT;
1866 1.1 cgd } else if (t == CHAR || t == SCHAR || t == SHORT) {
1867 1.1 cgd t = INT;
1868 1.1 cgd } else if (t == FLOAT) {
1869 1.1 cgd t = DOUBLE;
1870 1.1 cgd } else if (t == ENUM) {
1871 1.1 cgd t = INT;
1872 1.1 cgd }
1873 1.1 cgd }
1874 1.1 cgd
1875 1.1 cgd if (t != tn->tn_type->t_tspec) {
1876 1.258 rillig ntp = expr_dup_type(tn->tn_type);
1877 1.1 cgd ntp->t_tspec = t;
1878 1.1 cgd /*
1879 1.299 rillig * Keep t_is_enum even though t_tspec gets converted from
1880 1.299 rillig * ENUM to INT, so we are later able to check compatibility
1881 1.1 cgd * of enum types.
1882 1.1 cgd */
1883 1.1 cgd tn = convert(op, 0, ntp, tn);
1884 1.1 cgd }
1885 1.1 cgd
1886 1.95 rillig return tn;
1887 1.1 cgd }
1888 1.1 cgd
1889 1.1 cgd /*
1890 1.182 rillig * Apply the "usual arithmetic conversions" (C99 6.3.1.8).
1891 1.182 rillig *
1892 1.182 rillig * This gives both operands the same type.
1893 1.182 rillig * This is done in different ways for traditional C and C90.
1894 1.1 cgd */
1895 1.1 cgd static void
1896 1.20 lukem balance(op_t op, tnode_t **lnp, tnode_t **rnp)
1897 1.1 cgd {
1898 1.1 cgd tspec_t lt, rt, t;
1899 1.154 rillig int i;
1900 1.154 rillig bool u;
1901 1.1 cgd type_t *ntp;
1902 1.182 rillig static const tspec_t tl[] = {
1903 1.323 rillig LDOUBLE, DOUBLE, FLOAT,
1904 1.323 rillig #ifdef INT128_SIZE
1905 1.323 rillig UINT128, INT128,
1906 1.323 rillig #endif
1907 1.323 rillig UQUAD, QUAD,
1908 1.323 rillig ULONG, LONG,
1909 1.323 rillig UINT, INT,
1910 1.1 cgd };
1911 1.1 cgd
1912 1.1 cgd lt = (*lnp)->tn_type->t_tspec;
1913 1.1 cgd rt = (*rnp)->tn_type->t_tspec;
1914 1.1 cgd
1915 1.144 rillig if (!is_arithmetic(lt) || !is_arithmetic(rt))
1916 1.1 cgd return;
1917 1.1 cgd
1918 1.1 cgd if (!tflag) {
1919 1.1 cgd if (lt == rt) {
1920 1.1 cgd t = lt;
1921 1.53 matt } else if (lt == LCOMPLEX || rt == LCOMPLEX) {
1922 1.53 matt t = LCOMPLEX;
1923 1.53 matt } else if (lt == DCOMPLEX || rt == DCOMPLEX) {
1924 1.53 matt t = DCOMPLEX;
1925 1.53 matt } else if (lt == FCOMPLEX || rt == FCOMPLEX) {
1926 1.53 matt t = FCOMPLEX;
1927 1.1 cgd } else if (lt == LDOUBLE || rt == LDOUBLE) {
1928 1.1 cgd t = LDOUBLE;
1929 1.1 cgd } else if (lt == DOUBLE || rt == DOUBLE) {
1930 1.1 cgd t = DOUBLE;
1931 1.1 cgd } else if (lt == FLOAT || rt == FLOAT) {
1932 1.1 cgd t = FLOAT;
1933 1.1 cgd } else {
1934 1.1 cgd /*
1935 1.1 cgd * If type A has more bits than type B it should
1936 1.1 cgd * be able to hold all possible values of type B.
1937 1.1 cgd */
1938 1.228 rillig if (size_in_bits(lt) > size_in_bits(rt)) {
1939 1.1 cgd t = lt;
1940 1.228 rillig } else if (size_in_bits(lt) < size_in_bits(rt)) {
1941 1.1 cgd t = rt;
1942 1.1 cgd } else {
1943 1.1 cgd for (i = 3; tl[i] != INT; i++) {
1944 1.1 cgd if (tl[i] == lt || tl[i] == rt)
1945 1.1 cgd break;
1946 1.1 cgd }
1947 1.144 rillig if ((is_uinteger(lt) || is_uinteger(rt)) &&
1948 1.144 rillig !is_uinteger(tl[i])) {
1949 1.1 cgd i--;
1950 1.1 cgd }
1951 1.1 cgd t = tl[i];
1952 1.1 cgd }
1953 1.1 cgd }
1954 1.1 cgd } else {
1955 1.1 cgd /* Keep unsigned in traditional C */
1956 1.144 rillig u = is_uinteger(lt) || is_uinteger(rt);
1957 1.1 cgd for (i = 0; tl[i] != INT; i++) {
1958 1.1 cgd if (lt == tl[i] || rt == tl[i])
1959 1.1 cgd break;
1960 1.1 cgd }
1961 1.1 cgd t = tl[i];
1962 1.144 rillig if (u && is_integer(t) && !is_uinteger(t))
1963 1.114 rillig t = unsigned_type(t);
1964 1.1 cgd }
1965 1.1 cgd
1966 1.1 cgd if (t != lt) {
1967 1.258 rillig ntp = expr_dup_type((*lnp)->tn_type);
1968 1.1 cgd ntp->t_tspec = t;
1969 1.1 cgd *lnp = convert(op, 0, ntp, *lnp);
1970 1.1 cgd }
1971 1.1 cgd if (t != rt) {
1972 1.258 rillig ntp = expr_dup_type((*rnp)->tn_type);
1973 1.1 cgd ntp->t_tspec = t;
1974 1.1 cgd *rnp = convert(op, 0, ntp, *rnp);
1975 1.1 cgd }
1976 1.1 cgd }
1977 1.1 cgd
1978 1.1 cgd /*
1979 1.1 cgd * Insert a conversion operator, which converts the type of the node
1980 1.1 cgd * to another given type.
1981 1.1 cgd * If op is FARG, arg is the number of the argument (used for warnings).
1982 1.1 cgd */
1983 1.1 cgd tnode_t *
1984 1.20 lukem convert(op_t op, int arg, type_t *tp, tnode_t *tn)
1985 1.1 cgd {
1986 1.1 cgd tnode_t *ntn;
1987 1.190 rillig tspec_t nt, ot;
1988 1.1 cgd
1989 1.1 cgd nt = tp->t_tspec;
1990 1.190 rillig ot = tn->tn_type->t_tspec;
1991 1.1 cgd
1992 1.1 cgd if (!tflag && !sflag && op == FARG)
1993 1.100 rillig check_prototype_conversion(arg, nt, ot, tp, tn);
1994 1.144 rillig if (is_integer(nt) && is_integer(ot)) {
1995 1.100 rillig check_integer_conversion(op, arg, nt, ot, tp, tn);
1996 1.190 rillig } else if (nt == PTR && is_null_pointer(tn)) {
1997 1.190 rillig /* a null pointer may be assigned to any pointer. */
1998 1.148 rillig } else if (is_integer(nt) && nt != BOOL && ot == PTR) {
1999 1.100 rillig check_pointer_integer_conversion(op, nt, tp, tn);
2000 1.273 rillig } else if (nt == PTR && ot == PTR && op == CVT) {
2001 1.273 rillig check_pointer_conversion(tn, tp);
2002 1.1 cgd }
2003 1.1 cgd
2004 1.256 rillig ntn = expr_zalloc_tnode();
2005 1.1 cgd ntn->tn_op = CVT;
2006 1.1 cgd ntn->tn_type = tp;
2007 1.1 cgd ntn->tn_cast = op == CVT;
2008 1.306 rillig ntn->tn_relaxed |= tn->tn_relaxed;
2009 1.76 christos ntn->tn_right = NULL;
2010 1.1 cgd if (tn->tn_op != CON || nt == VOID) {
2011 1.1 cgd ntn->tn_left = tn;
2012 1.1 cgd } else {
2013 1.1 cgd ntn->tn_op = CON;
2014 1.259 rillig ntn->tn_val = expr_zalloc(sizeof(*ntn->tn_val));
2015 1.146 rillig convert_constant(op, arg, ntn->tn_type, ntn->tn_val,
2016 1.146 rillig tn->tn_val);
2017 1.1 cgd }
2018 1.1 cgd
2019 1.95 rillig return ntn;
2020 1.1 cgd }
2021 1.1 cgd
2022 1.364 rillig static bool
2023 1.366 rillig should_warn_about_prototype_conversion(tspec_t nt,
2024 1.366 rillig tspec_t ot, const tnode_t *ptn)
2025 1.344 rillig {
2026 1.344 rillig
2027 1.367 rillig if (nt == ot)
2028 1.367 rillig return false;
2029 1.367 rillig
2030 1.367 rillig if (nt == ENUM && ot == INT)
2031 1.367 rillig return false;
2032 1.367 rillig
2033 1.364 rillig if (is_floating(nt) != is_floating(ot) ||
2034 1.364 rillig portable_size_in_bits(nt) != portable_size_in_bits(ot)) {
2035 1.364 rillig /* representation and/or width change */
2036 1.364 rillig if (!is_integer(ot))
2037 1.364 rillig return true;
2038 1.364 rillig return portable_size_in_bits(ot) > portable_size_in_bits(INT);
2039 1.364 rillig }
2040 1.364 rillig
2041 1.344 rillig if (!hflag)
2042 1.364 rillig return false;
2043 1.344 rillig
2044 1.344 rillig /*
2045 1.344 rillig * If the types differ only in sign and the argument has the same
2046 1.344 rillig * representation in both types, print no warning.
2047 1.344 rillig */
2048 1.344 rillig if (ptn->tn_op == CON && is_integer(nt) &&
2049 1.344 rillig signed_type(nt) == signed_type(ot) &&
2050 1.348 rillig !msb(ptn->tn_val->v_quad, ot))
2051 1.364 rillig return false;
2052 1.344 rillig
2053 1.364 rillig return true;
2054 1.344 rillig }
2055 1.344 rillig
2056 1.344 rillig /*
2057 1.367 rillig * Warn if a prototype causes a type conversion that is different from what
2058 1.367 rillig * would happen to the same argument in the absence of a prototype. This
2059 1.367 rillig * check is intended for code that needs to stay compatible with pre-C90 C.
2060 1.1 cgd *
2061 1.182 rillig * Errors/warnings about illegal type combinations are already printed
2062 1.100 rillig * in check_assign_types_compatible().
2063 1.1 cgd */
2064 1.1 cgd static void
2065 1.100 rillig check_prototype_conversion(int arg, tspec_t nt, tspec_t ot, type_t *tp,
2066 1.100 rillig tnode_t *tn)
2067 1.1 cgd {
2068 1.1 cgd tnode_t *ptn;
2069 1.1 cgd
2070 1.144 rillig if (!is_arithmetic(nt) || !is_arithmetic(ot))
2071 1.1 cgd return;
2072 1.1 cgd
2073 1.1 cgd /*
2074 1.1 cgd * If the type of the formal parameter is char/short, a warning
2075 1.1 cgd * would be useless, because functions declared the old style
2076 1.1 cgd * can't expect char/short arguments.
2077 1.1 cgd */
2078 1.368 rillig if (nt == CHAR || nt == SCHAR || nt == UCHAR ||
2079 1.368 rillig nt == SHORT || nt == USHORT)
2080 1.1 cgd return;
2081 1.1 cgd
2082 1.367 rillig /* apply the default promotion */
2083 1.172 rillig ptn = promote(NOOP, true, tn);
2084 1.1 cgd ot = ptn->tn_type->t_tspec;
2085 1.1 cgd
2086 1.366 rillig if (should_warn_about_prototype_conversion(nt, ot, ptn)) {
2087 1.364 rillig /* argument #%d is converted from '%s' to '%s' ... */
2088 1.364 rillig warning(259, arg, type_name(tn->tn_type), type_name(tp));
2089 1.364 rillig }
2090 1.1 cgd }
2091 1.1 cgd
2092 1.1 cgd /*
2093 1.96 rillig * Print warnings for conversions of integer types which may cause problems.
2094 1.1 cgd */
2095 1.1 cgd static void
2096 1.100 rillig check_integer_conversion(op_t op, int arg, tspec_t nt, tspec_t ot, type_t *tp,
2097 1.100 rillig tnode_t *tn)
2098 1.1 cgd {
2099 1.115 rillig
2100 1.1 cgd if (tn->tn_op == CON)
2101 1.1 cgd return;
2102 1.1 cgd
2103 1.1 cgd if (op == CVT)
2104 1.1 cgd return;
2105 1.1 cgd
2106 1.268 rillig if (Sflag && nt == BOOL)
2107 1.268 rillig return; /* See C99 6.3.1.2 */
2108 1.268 rillig
2109 1.228 rillig if (Pflag && portable_size_in_bits(nt) > portable_size_in_bits(ot) &&
2110 1.144 rillig is_uinteger(nt) != is_uinteger(ot)) {
2111 1.154 rillig if (aflag > 0 && pflag) {
2112 1.1 cgd if (op == FARG) {
2113 1.113 rillig /* conversion to '%s' may sign-extend ... */
2114 1.115 rillig warning(297, type_name(tp), arg);
2115 1.1 cgd } else {
2116 1.113 rillig /* conversion to '%s' may sign-extend ... */
2117 1.115 rillig warning(131, type_name(tp));
2118 1.1 cgd }
2119 1.1 cgd }
2120 1.1 cgd }
2121 1.51 christos
2122 1.228 rillig if (Pflag && portable_size_in_bits(nt) > portable_size_in_bits(ot)) {
2123 1.51 christos switch (tn->tn_op) {
2124 1.51 christos case PLUS:
2125 1.51 christos case MINUS:
2126 1.51 christos case MULT:
2127 1.51 christos case SHL:
2128 1.113 rillig /* suggest cast from '%s' to '%s' on op %s to ... */
2129 1.115 rillig warning(324, type_name(gettyp(ot)), type_name(tp),
2130 1.290 rillig op_name(tn->tn_op));
2131 1.51 christos break;
2132 1.51 christos default:
2133 1.51 christos break;
2134 1.51 christos }
2135 1.51 christos }
2136 1.1 cgd
2137 1.228 rillig if (portable_size_in_bits(nt) < portable_size_in_bits(ot) &&
2138 1.1 cgd (ot == LONG || ot == ULONG || ot == QUAD || ot == UQUAD ||
2139 1.1 cgd aflag > 1)) {
2140 1.1 cgd /* conversion from '%s' may lose accuracy */
2141 1.154 rillig if (aflag > 0) {
2142 1.1 cgd if (op == FARG) {
2143 1.377 rillig /* conversion from '%s' to '%s' may ... */
2144 1.39 christos warning(298,
2145 1.115 rillig type_name(tn->tn_type), type_name(tp), arg);
2146 1.1 cgd } else {
2147 1.377 rillig /* conversion from '%s' to '%s' may ... */
2148 1.39 christos warning(132,
2149 1.115 rillig type_name(tn->tn_type), type_name(tp));
2150 1.1 cgd }
2151 1.20 lukem }
2152 1.1 cgd }
2153 1.1 cgd }
2154 1.1 cgd
2155 1.1 cgd /*
2156 1.1 cgd * Print warnings for dubious conversions of pointer to integer.
2157 1.1 cgd */
2158 1.1 cgd static void
2159 1.100 rillig check_pointer_integer_conversion(op_t op, tspec_t nt, type_t *tp, tnode_t *tn)
2160 1.1 cgd {
2161 1.20 lukem
2162 1.1 cgd if (tn->tn_op == CON)
2163 1.1 cgd return;
2164 1.166 rillig if (op != CVT)
2165 1.166 rillig return; /* We got already an error. */
2166 1.228 rillig if (portable_size_in_bits(nt) >= portable_size_in_bits(PTR))
2167 1.1 cgd return;
2168 1.1 cgd
2169 1.228 rillig if (pflag && size_in_bits(nt) >= size_in_bits(PTR)) {
2170 1.166 rillig /* conversion of pointer to '%s' may lose bits */
2171 1.166 rillig warning(134, type_name(tp));
2172 1.166 rillig } else {
2173 1.166 rillig /* conversion of pointer to '%s' loses bits */
2174 1.166 rillig warning(133, type_name(tp));
2175 1.1 cgd }
2176 1.1 cgd }
2177 1.1 cgd
2178 1.247 rillig static bool
2179 1.273 rillig should_warn_about_pointer_cast(const type_t *nstp, tspec_t nst,
2180 1.273 rillig const type_t *ostp, tspec_t ost)
2181 1.247 rillig {
2182 1.272 rillig /*
2183 1.272 rillig * Casting a pointer to 'struct S' to a pointer to another struct that
2184 1.272 rillig * has 'struct S' as its first member is ok, see msg_247.c, 'struct
2185 1.272 rillig * counter'.
2186 1.272 rillig */
2187 1.272 rillig if (nst == STRUCT && ost == STRUCT &&
2188 1.273 rillig nstp->t_str->sou_first_member != NULL &&
2189 1.273 rillig nstp->t_str->sou_first_member->s_type == ostp)
2190 1.272 rillig return false;
2191 1.272 rillig
2192 1.274 rillig if (is_incomplete(nstp) || is_incomplete(ostp))
2193 1.274 rillig return false;
2194 1.274 rillig
2195 1.273 rillig if ((nst == STRUCT || nst == UNION) && nstp->t_str != ostp->t_str)
2196 1.273 rillig return true;
2197 1.247 rillig
2198 1.249 rillig if (nst == CHAR || nst == UCHAR)
2199 1.249 rillig return false; /* for the sake of traditional C code */
2200 1.316 rillig if (ost == CHAR || ost == UCHAR)
2201 1.316 rillig return false; /* for the sake of traditional C code */
2202 1.249 rillig
2203 1.247 rillig return portable_size_in_bits(nst) != portable_size_in_bits(ost);
2204 1.247 rillig }
2205 1.247 rillig
2206 1.1 cgd /*
2207 1.248 rillig * Warn about questionable pointer conversions.
2208 1.1 cgd */
2209 1.1 cgd static void
2210 1.273 rillig check_pointer_conversion(tnode_t *tn, type_t *ntp)
2211 1.1 cgd {
2212 1.273 rillig const type_t *nstp, *otp, *ostp;
2213 1.248 rillig tspec_t nst, ost;
2214 1.248 rillig const char *nts, *ots;
2215 1.1 cgd
2216 1.273 rillig nstp = ntp->t_subt;
2217 1.273 rillig otp = tn->tn_type;
2218 1.273 rillig ostp = otp->t_subt;
2219 1.273 rillig nst = nstp->t_tspec;
2220 1.273 rillig ost = ostp->t_tspec;
2221 1.248 rillig
2222 1.248 rillig if (nst == VOID || ost == VOID) {
2223 1.248 rillig if (sflag && (nst == FUNC || ost == FUNC)) {
2224 1.248 rillig /* null pointers are already handled in convert() */
2225 1.248 rillig *(nst == FUNC ? &nts : &ots) = "function pointer";
2226 1.248 rillig *(nst == VOID ? &nts : &ots) = "'void *'";
2227 1.1 cgd /* ANSI C forbids conversion of %s to %s */
2228 1.1 cgd warning(303, ots, nts);
2229 1.1 cgd }
2230 1.1 cgd return;
2231 1.248 rillig } else if (nst == FUNC && ost == FUNC) {
2232 1.1 cgd return;
2233 1.248 rillig } else if (nst == FUNC || ost == FUNC) {
2234 1.223 rillig /* converting '%s' to '%s' is questionable */
2235 1.273 rillig warning(229, type_name(otp), type_name(ntp));
2236 1.1 cgd return;
2237 1.1 cgd }
2238 1.20 lukem
2239 1.277 rillig if (hflag && alignment_in_bits(nstp) > alignment_in_bits(ostp) &&
2240 1.316 rillig ost != CHAR && ost != UCHAR &&
2241 1.277 rillig !is_incomplete(ostp)) {
2242 1.222 rillig /* converting '%s' to '%s' may cause alignment problem */
2243 1.273 rillig warning(135, type_name(otp), type_name(ntp));
2244 1.1 cgd }
2245 1.221 rillig
2246 1.273 rillig if (cflag && should_warn_about_pointer_cast(nstp, nst, ostp, ost)) {
2247 1.247 rillig /* pointer cast from '%s' to '%s' may be troublesome */
2248 1.273 rillig warning(247, type_name(otp), type_name(ntp));
2249 1.1 cgd }
2250 1.1 cgd }
2251 1.1 cgd
2252 1.282 rillig static void
2253 1.285 rillig convert_constant_floating(op_t op, int arg, tspec_t ot, const type_t *tp,
2254 1.285 rillig tspec_t nt, val_t *v, val_t *nv)
2255 1.282 rillig {
2256 1.282 rillig ldbl_t max = 0.0, min = 0.0;
2257 1.282 rillig
2258 1.282 rillig switch (nt) {
2259 1.282 rillig case CHAR:
2260 1.282 rillig max = TARG_CHAR_MAX; min = TARG_CHAR_MIN; break;
2261 1.282 rillig case UCHAR:
2262 1.282 rillig max = TARG_UCHAR_MAX; min = 0; break;
2263 1.282 rillig case SCHAR:
2264 1.282 rillig max = TARG_SCHAR_MAX; min = TARG_SCHAR_MIN; break;
2265 1.282 rillig case SHORT:
2266 1.282 rillig max = TARG_SHRT_MAX; min = TARG_SHRT_MIN; break;
2267 1.282 rillig case USHORT:
2268 1.282 rillig max = TARG_USHRT_MAX; min = 0; break;
2269 1.282 rillig case ENUM:
2270 1.282 rillig case INT:
2271 1.282 rillig max = TARG_INT_MAX; min = TARG_INT_MIN; break;
2272 1.282 rillig case UINT:
2273 1.354 rillig max = TARG_UINT_MAX; min = 0; break;
2274 1.282 rillig case LONG:
2275 1.282 rillig max = TARG_LONG_MAX; min = TARG_LONG_MIN; break;
2276 1.282 rillig case ULONG:
2277 1.354 rillig max = TARG_ULONG_MAX; min = 0; break;
2278 1.282 rillig case QUAD:
2279 1.282 rillig max = QUAD_MAX; min = QUAD_MIN; break;
2280 1.282 rillig case UQUAD:
2281 1.354 rillig max = UQUAD_MAX; min = 0; break;
2282 1.282 rillig case FLOAT:
2283 1.282 rillig case FCOMPLEX:
2284 1.282 rillig max = FLT_MAX; min = -FLT_MAX; break;
2285 1.282 rillig case DOUBLE:
2286 1.282 rillig case DCOMPLEX:
2287 1.282 rillig max = DBL_MAX; min = -DBL_MAX; break;
2288 1.282 rillig case PTR:
2289 1.282 rillig /* Got already an error because of float --> ptr */
2290 1.282 rillig case LDOUBLE:
2291 1.282 rillig case LCOMPLEX:
2292 1.378 rillig /* LINTED 248 */
2293 1.378 rillig max = LDBL_MAX; min = -max; break;
2294 1.282 rillig default:
2295 1.282 rillig lint_assert(/*CONSTCOND*/false);
2296 1.282 rillig }
2297 1.282 rillig if (v->v_ldbl > max || v->v_ldbl < min) {
2298 1.282 rillig lint_assert(nt != LDOUBLE);
2299 1.282 rillig if (op == FARG) {
2300 1.377 rillig /* conversion of '%s' to '%s' is out of range, ... */
2301 1.282 rillig warning(295,
2302 1.282 rillig type_name(gettyp(ot)), type_name(tp), arg);
2303 1.282 rillig } else {
2304 1.282 rillig /* conversion of '%s' to '%s' is out of range */
2305 1.282 rillig warning(119,
2306 1.282 rillig type_name(gettyp(ot)), type_name(tp));
2307 1.282 rillig }
2308 1.282 rillig v->v_ldbl = v->v_ldbl > 0 ? max : min;
2309 1.282 rillig }
2310 1.357 rillig
2311 1.282 rillig if (nt == FLOAT) {
2312 1.282 rillig nv->v_ldbl = (float)v->v_ldbl;
2313 1.282 rillig } else if (nt == DOUBLE) {
2314 1.282 rillig nv->v_ldbl = (double)v->v_ldbl;
2315 1.282 rillig } else if (nt == LDOUBLE) {
2316 1.282 rillig nv->v_ldbl = v->v_ldbl;
2317 1.282 rillig } else {
2318 1.357 rillig nv->v_quad = (int64_t)v->v_ldbl;
2319 1.282 rillig }
2320 1.282 rillig }
2321 1.282 rillig
2322 1.286 rillig static bool
2323 1.286 rillig convert_constant_to_floating(tspec_t nt, val_t *nv,
2324 1.286 rillig tspec_t ot, const val_t *v)
2325 1.286 rillig {
2326 1.286 rillig if (nt == FLOAT) {
2327 1.286 rillig nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ?
2328 1.286 rillig (float)(uint64_t)v->v_quad : (float)v->v_quad;
2329 1.286 rillig } else if (nt == DOUBLE) {
2330 1.286 rillig nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ?
2331 1.286 rillig (double)(uint64_t)v->v_quad : (double)v->v_quad;
2332 1.286 rillig } else if (nt == LDOUBLE) {
2333 1.286 rillig nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ?
2334 1.286 rillig (ldbl_t)(uint64_t)v->v_quad : (ldbl_t)v->v_quad;
2335 1.286 rillig } else
2336 1.286 rillig return false;
2337 1.286 rillig return true;
2338 1.286 rillig }
2339 1.286 rillig
2340 1.285 rillig /*
2341 1.285 rillig * Print a warning if bits which were set are lost due to the conversion.
2342 1.285 rillig * This can happen with operator ORASS only.
2343 1.285 rillig */
2344 1.285 rillig static void
2345 1.285 rillig convert_constant_check_range_bitor(size_t nsz, size_t osz, const val_t *v,
2346 1.285 rillig uint64_t xmask, op_t op)
2347 1.285 rillig {
2348 1.285 rillig if (nsz < osz && (v->v_quad & xmask) != 0) {
2349 1.377 rillig /* constant truncated by conversion, op %s */
2350 1.285 rillig warning(306, op_name(op));
2351 1.285 rillig }
2352 1.285 rillig }
2353 1.285 rillig
2354 1.285 rillig /*
2355 1.285 rillig * Print a warning if additional bits are not all 1
2356 1.285 rillig * and the most significant bit of the old value is 1,
2357 1.285 rillig * or if at least one (but not all) removed bit was 0.
2358 1.285 rillig */
2359 1.285 rillig static void
2360 1.285 rillig convert_constant_check_range_bitand(size_t nsz, size_t osz,
2361 1.285 rillig uint64_t xmask, const val_t *nv,
2362 1.285 rillig tspec_t ot, const val_t *v,
2363 1.285 rillig const type_t *tp, op_t op)
2364 1.285 rillig {
2365 1.285 rillig if (nsz > osz &&
2366 1.378 rillig (nv->v_quad & bit((unsigned int)(osz - 1))) != 0 &&
2367 1.285 rillig (nv->v_quad & xmask) != xmask) {
2368 1.285 rillig /* extra bits set to 0 in conversion of '%s' to '%s', ... */
2369 1.285 rillig warning(309, type_name(gettyp(ot)),
2370 1.285 rillig type_name(tp), op_name(op));
2371 1.285 rillig } else if (nsz < osz &&
2372 1.285 rillig (v->v_quad & xmask) != xmask &&
2373 1.285 rillig (v->v_quad & xmask) != 0) {
2374 1.285 rillig /* constant truncated by conversion, op %s */
2375 1.285 rillig warning(306, op_name(op));
2376 1.285 rillig }
2377 1.285 rillig }
2378 1.285 rillig
2379 1.285 rillig static void
2380 1.285 rillig convert_constant_check_range_signed(op_t op, int arg)
2381 1.285 rillig {
2382 1.285 rillig if (op == ASSIGN) {
2383 1.285 rillig /* assignment of negative constant to unsigned type */
2384 1.285 rillig warning(164);
2385 1.285 rillig } else if (op == INIT) {
2386 1.285 rillig /* initialization of unsigned with negative constant */
2387 1.285 rillig warning(221);
2388 1.285 rillig } else if (op == FARG) {
2389 1.285 rillig /* conversion of negative constant to unsigned type, ... */
2390 1.285 rillig warning(296, arg);
2391 1.285 rillig } else if (modtab[op].m_comparison) {
2392 1.285 rillig /* handled by check_integer_comparison() */
2393 1.285 rillig } else {
2394 1.285 rillig /* conversion of negative constant to unsigned type */
2395 1.285 rillig warning(222);
2396 1.285 rillig }
2397 1.285 rillig }
2398 1.285 rillig
2399 1.285 rillig /*
2400 1.285 rillig * Loss of significant bit(s). All truncated bits
2401 1.285 rillig * of unsigned types or all truncated bits plus the
2402 1.285 rillig * msb of the target for signed types are considered
2403 1.285 rillig * to be significant bits. Loss of significant bits
2404 1.295 rillig * means that at least one of the bits was set in an
2405 1.295 rillig * unsigned type or that at least one but not all of
2406 1.295 rillig * the bits was set in a signed type.
2407 1.285 rillig * Loss of significant bits means that it is not
2408 1.285 rillig * possible, also not with necessary casts, to convert
2409 1.285 rillig * back to the original type. A example for a
2410 1.285 rillig * necessary cast is:
2411 1.285 rillig * char c; int i; c = 128;
2412 1.285 rillig * i = c; ** yields -128 **
2413 1.285 rillig * i = (unsigned char)c; ** yields 128 **
2414 1.285 rillig */
2415 1.285 rillig static void
2416 1.285 rillig convert_constant_check_range_truncated(op_t op, int arg, const type_t *tp,
2417 1.285 rillig tspec_t ot)
2418 1.285 rillig {
2419 1.285 rillig if (op == ASSIGN && tp->t_bitfield) {
2420 1.285 rillig /* precision lost in bit-field assignment */
2421 1.285 rillig warning(166);
2422 1.285 rillig } else if (op == ASSIGN) {
2423 1.285 rillig /* constant truncated by assignment */
2424 1.285 rillig warning(165);
2425 1.285 rillig } else if (op == INIT && tp->t_bitfield) {
2426 1.285 rillig /* bit-field initializer does not fit */
2427 1.285 rillig warning(180);
2428 1.285 rillig } else if (op == INIT) {
2429 1.285 rillig /* initializer does not fit */
2430 1.285 rillig warning(178);
2431 1.285 rillig } else if (op == CASE) {
2432 1.285 rillig /* case label affected by conversion */
2433 1.285 rillig warning(196);
2434 1.285 rillig } else if (op == FARG) {
2435 1.285 rillig /* conversion of '%s' to '%s' is out of range, arg #%d */
2436 1.285 rillig warning(295,
2437 1.285 rillig type_name(gettyp(ot)), type_name(tp), arg);
2438 1.285 rillig } else {
2439 1.285 rillig /* conversion of '%s' to '%s' is out of range */
2440 1.285 rillig warning(119,
2441 1.285 rillig type_name(gettyp(ot)), type_name(tp));
2442 1.285 rillig }
2443 1.285 rillig }
2444 1.285 rillig
2445 1.285 rillig static void
2446 1.285 rillig convert_constant_check_range_loss(op_t op, int arg, const type_t *tp,
2447 1.285 rillig tspec_t ot)
2448 1.285 rillig {
2449 1.285 rillig if (op == ASSIGN && tp->t_bitfield) {
2450 1.285 rillig /* precision lost in bit-field assignment */
2451 1.285 rillig warning(166);
2452 1.285 rillig } else if (op == INIT && tp->t_bitfield) {
2453 1.285 rillig /* bit-field initializer out of range */
2454 1.285 rillig warning(11);
2455 1.285 rillig } else if (op == CASE) {
2456 1.285 rillig /* case label affected by conversion */
2457 1.285 rillig warning(196);
2458 1.285 rillig } else if (op == FARG) {
2459 1.285 rillig /* conversion of '%s' to '%s' is out of range, arg #%d */
2460 1.285 rillig warning(295,
2461 1.285 rillig type_name(gettyp(ot)), type_name(tp), arg);
2462 1.285 rillig } else {
2463 1.285 rillig /* conversion of '%s' to '%s' is out of range */
2464 1.285 rillig warning(119,
2465 1.285 rillig type_name(gettyp(ot)), type_name(tp));
2466 1.285 rillig }
2467 1.285 rillig }
2468 1.285 rillig
2469 1.283 rillig static void
2470 1.285 rillig convert_constant_check_range(tspec_t ot, const type_t *tp, tspec_t nt,
2471 1.285 rillig op_t op, int arg, const val_t *v, val_t *nv)
2472 1.283 rillig {
2473 1.378 rillig unsigned int osz, nsz;
2474 1.378 rillig uint64_t xmask, xmsk1;
2475 1.283 rillig
2476 1.283 rillig osz = size_in_bits(ot);
2477 1.283 rillig nsz = tp->t_bitfield ? tp->t_flen : size_in_bits(nt);
2478 1.287 rillig xmask = value_bits(nsz) ^ value_bits(osz);
2479 1.287 rillig xmsk1 = value_bits(nsz) ^ value_bits(osz - 1);
2480 1.283 rillig /*
2481 1.283 rillig * For bitwise operations we are not interested in the
2482 1.283 rillig * value, but in the bits itself.
2483 1.283 rillig */
2484 1.283 rillig if (op == ORASS || op == BITOR || op == BITXOR) {
2485 1.285 rillig convert_constant_check_range_bitor(nsz, osz, v, xmask, op);
2486 1.283 rillig } else if (op == ANDASS || op == BITAND) {
2487 1.285 rillig convert_constant_check_range_bitand(nsz, osz, xmask, nv, ot,
2488 1.285 rillig v, tp, op);
2489 1.283 rillig } else if ((nt != PTR && is_uinteger(nt)) &&
2490 1.283 rillig (ot != PTR && !is_uinteger(ot)) &&
2491 1.283 rillig v->v_quad < 0) {
2492 1.285 rillig convert_constant_check_range_signed(op, arg);
2493 1.283 rillig } else if (nv->v_quad != v->v_quad && nsz <= osz &&
2494 1.283 rillig (v->v_quad & xmask) != 0 &&
2495 1.283 rillig (is_uinteger(ot) || (v->v_quad & xmsk1) != xmsk1)) {
2496 1.285 rillig convert_constant_check_range_truncated(op, arg, tp, ot);
2497 1.283 rillig } else if (nv->v_quad != v->v_quad) {
2498 1.285 rillig convert_constant_check_range_loss(op, arg, tp, ot);
2499 1.283 rillig }
2500 1.283 rillig }
2501 1.283 rillig
2502 1.1 cgd /*
2503 1.166 rillig * Converts a typed constant to a constant of another type.
2504 1.1 cgd *
2505 1.1 cgd * op operator which requires conversion
2506 1.1 cgd * arg if op is FARG, # of argument
2507 1.1 cgd * tp type in which to convert the constant
2508 1.1 cgd * nv new constant
2509 1.1 cgd * v old constant
2510 1.1 cgd */
2511 1.1 cgd void
2512 1.253 rillig convert_constant(op_t op, int arg, const type_t *tp, val_t *nv, val_t *v)
2513 1.1 cgd {
2514 1.378 rillig tspec_t ot, nt;
2515 1.378 rillig unsigned int sz;
2516 1.378 rillig bool range_check;
2517 1.1 cgd
2518 1.276 rillig /*
2519 1.276 rillig * TODO: make 'v' const; the name of this function does not suggest
2520 1.276 rillig * that it modifies 'v'.
2521 1.276 rillig */
2522 1.1 cgd ot = v->v_tspec;
2523 1.1 cgd nt = nv->v_tspec = tp->t_tspec;
2524 1.283 rillig range_check = false;
2525 1.1 cgd
2526 1.147 rillig if (nt == BOOL) { /* C99 6.3.1.2 */
2527 1.289 rillig nv->v_unsigned_since_c90 = false;
2528 1.230 rillig nv->v_quad = is_nonzero_val(v) ? 1 : 0;
2529 1.147 rillig return;
2530 1.147 rillig }
2531 1.147 rillig
2532 1.1 cgd if (ot == FLOAT || ot == DOUBLE || ot == LDOUBLE) {
2533 1.282 rillig convert_constant_floating(op, arg, ot, tp, nt, v, nv);
2534 1.286 rillig } else if (!convert_constant_to_floating(nt, nv, ot, v)) {
2535 1.286 rillig range_check = true; /* Check for lost precision. */
2536 1.286 rillig nv->v_quad = v->v_quad;
2537 1.1 cgd }
2538 1.1 cgd
2539 1.289 rillig if ((v->v_unsigned_since_c90 && is_floating(nt)) ||
2540 1.289 rillig (v->v_unsigned_since_c90 && (is_integer(nt) && !is_uinteger(nt) &&
2541 1.284 rillig portable_size_in_bits(nt) >
2542 1.284 rillig portable_size_in_bits(ot)))) {
2543 1.1 cgd /* ANSI C treats constant as unsigned */
2544 1.1 cgd warning(157);
2545 1.289 rillig v->v_unsigned_since_c90 = false;
2546 1.1 cgd }
2547 1.1 cgd
2548 1.297 rillig if (is_integer(nt)) {
2549 1.228 rillig sz = tp->t_bitfield ? tp->t_flen : size_in_bits(nt);
2550 1.298 rillig nv->v_quad = convert_integer(nv->v_quad, nt, sz);
2551 1.1 cgd }
2552 1.20 lukem
2553 1.283 rillig if (range_check && op != CVT)
2554 1.283 rillig convert_constant_check_range(ot, tp, nt, op, arg, v, nv);
2555 1.1 cgd }
2556 1.1 cgd
2557 1.1 cgd /*
2558 1.1 cgd * Called if incompatible types were detected.
2559 1.1 cgd * Prints a appropriate warning.
2560 1.1 cgd */
2561 1.1 cgd static void
2562 1.246 rillig warn_incompatible_types(op_t op,
2563 1.246 rillig const type_t *ltp, tspec_t lt,
2564 1.246 rillig const type_t *rtp, tspec_t rt)
2565 1.1 cgd {
2566 1.240 rillig const mod_t *mp;
2567 1.1 cgd
2568 1.1 cgd mp = &modtab[op];
2569 1.1 cgd
2570 1.1 cgd if (lt == VOID || (mp->m_binary && rt == VOID)) {
2571 1.1 cgd /* void type illegal in expression */
2572 1.110 rillig error(109);
2573 1.1 cgd } else if (op == ASSIGN) {
2574 1.1 cgd if ((lt == STRUCT || lt == UNION) &&
2575 1.1 cgd (rt == STRUCT || rt == UNION)) {
2576 1.110 rillig /* assignment of different structures (%s != %s) */
2577 1.111 rillig error(240, tspec_name(lt), tspec_name(rt));
2578 1.1 cgd } else {
2579 1.246 rillig /* cannot assign to '%s' from '%s' */
2580 1.246 rillig error(171, type_name(ltp), type_name(rtp));
2581 1.1 cgd }
2582 1.1 cgd } else if (mp->m_binary) {
2583 1.110 rillig /* operands of '%s' have incompatible types (%s != %s) */
2584 1.111 rillig error(107, mp->m_name, tspec_name(lt), tspec_name(rt));
2585 1.1 cgd } else {
2586 1.137 rillig lint_assert(rt == NOTSPEC);
2587 1.137 rillig /* operand of '%s' has invalid type (%s) */
2588 1.137 rillig error(108, mp->m_name, tspec_name(lt));
2589 1.1 cgd }
2590 1.1 cgd }
2591 1.1 cgd
2592 1.1 cgd /*
2593 1.1 cgd * Called if incompatible pointer types are detected.
2594 1.1 cgd * Print an appropriate warning.
2595 1.1 cgd */
2596 1.1 cgd static void
2597 1.149 rillig warn_incompatible_pointers(const mod_t *mp,
2598 1.149 rillig const type_t *ltp, const type_t *rtp)
2599 1.1 cgd {
2600 1.1 cgd tspec_t lt, rt;
2601 1.1 cgd
2602 1.107 rillig lint_assert(ltp->t_tspec == PTR);
2603 1.107 rillig lint_assert(rtp->t_tspec == PTR);
2604 1.1 cgd
2605 1.1 cgd lt = ltp->t_subt->t_tspec;
2606 1.1 cgd rt = rtp->t_subt->t_tspec;
2607 1.1 cgd
2608 1.1 cgd if ((lt == STRUCT || lt == UNION) && (rt == STRUCT || rt == UNION)) {
2609 1.1 cgd if (mp == NULL) {
2610 1.1 cgd /* illegal structure pointer combination */
2611 1.1 cgd warning(244);
2612 1.1 cgd } else {
2613 1.225 rillig /* incompatible structure pointers: '%s' '%s' '%s' */
2614 1.225 rillig warning(245, type_name(ltp), mp->m_name, type_name(rtp));
2615 1.1 cgd }
2616 1.1 cgd } else {
2617 1.1 cgd if (mp == NULL) {
2618 1.334 rillig /* illegal combination of '%s' and '%s' */
2619 1.334 rillig warning(184, type_name(ltp), type_name(rtp));
2620 1.1 cgd } else {
2621 1.334 rillig /* illegal combination of '%s' and '%s', op '%s' */
2622 1.117 rillig warning(124,
2623 1.117 rillig type_name(ltp), type_name(rtp), mp->m_name);
2624 1.1 cgd }
2625 1.1 cgd }
2626 1.1 cgd }
2627 1.1 cgd
2628 1.263 rillig /* Return a type based on tp1, with added qualifiers from tp2. */
2629 1.263 rillig static type_t *
2630 1.263 rillig merge_qualifiers(type_t *tp1, const type_t *tp2)
2631 1.1 cgd {
2632 1.263 rillig type_t *ntp, *nstp;
2633 1.20 lukem
2634 1.107 rillig lint_assert(tp1->t_tspec == PTR);
2635 1.107 rillig lint_assert(tp2->t_tspec == PTR);
2636 1.1 cgd
2637 1.263 rillig bool c1 = tp1->t_subt->t_const;
2638 1.263 rillig bool c2 = tp2->t_subt->t_const;
2639 1.263 rillig bool v1 = tp1->t_subt->t_volatile;
2640 1.263 rillig bool v2 = tp2->t_subt->t_volatile;
2641 1.263 rillig
2642 1.264 rillig if (c1 == (c1 | c2) && v1 == (v1 | v2))
2643 1.263 rillig return tp1;
2644 1.263 rillig
2645 1.263 rillig nstp = expr_dup_type(tp1->t_subt);
2646 1.264 rillig nstp->t_const |= c2;
2647 1.264 rillig nstp->t_volatile |= v2;
2648 1.263 rillig
2649 1.263 rillig ntp = expr_dup_type(tp1);
2650 1.263 rillig ntp->t_subt = nstp;
2651 1.263 rillig return ntp;
2652 1.1 cgd }
2653 1.1 cgd
2654 1.1 cgd /*
2655 1.185 rillig * Returns true if the given structure or union has a constant member
2656 1.1 cgd * (maybe recursively).
2657 1.1 cgd */
2658 1.149 rillig static bool
2659 1.149 rillig has_constant_member(const type_t *tp)
2660 1.1 cgd {
2661 1.321 rillig sym_t *m;
2662 1.1 cgd
2663 1.321 rillig lint_assert(is_struct_or_union(tp->t_tspec));
2664 1.107 rillig
2665 1.208 rillig for (m = tp->t_str->sou_first_member; m != NULL; m = m->s_next) {
2666 1.321 rillig const type_t *mtp = m->s_type;
2667 1.321 rillig if (mtp->t_const)
2668 1.321 rillig return true;
2669 1.321 rillig if (is_struct_or_union(mtp->t_tspec) &&
2670 1.321 rillig has_constant_member(mtp))
2671 1.149 rillig return true;
2672 1.1 cgd }
2673 1.149 rillig return false;
2674 1.1 cgd }
2675 1.1 cgd
2676 1.1 cgd /*
2677 1.1 cgd * Create a new node for one of the operators POINT and ARROW.
2678 1.1 cgd */
2679 1.1 cgd static tnode_t *
2680 1.100 rillig build_struct_access(op_t op, tnode_t *ln, tnode_t *rn)
2681 1.1 cgd {
2682 1.1 cgd tnode_t *ntn, *ctn;
2683 1.154 rillig bool nolval;
2684 1.1 cgd
2685 1.107 rillig lint_assert(rn->tn_op == NAME);
2686 1.107 rillig lint_assert(rn->tn_sym->s_value.v_tspec == INT);
2687 1.107 rillig lint_assert(rn->tn_sym->s_scl == MOS || rn->tn_sym->s_scl == MOU);
2688 1.1 cgd
2689 1.1 cgd /*
2690 1.1 cgd * Remember if the left operand is an lvalue (structure members
2691 1.1 cgd * are lvalues if and only if the structure itself is an lvalue).
2692 1.1 cgd */
2693 1.1 cgd nolval = op == POINT && !ln->tn_lvalue;
2694 1.1 cgd
2695 1.1 cgd if (op == POINT) {
2696 1.172 rillig ln = build_address(ln, true);
2697 1.1 cgd } else if (ln->tn_type->t_tspec != PTR) {
2698 1.107 rillig lint_assert(tflag);
2699 1.144 rillig lint_assert(is_integer(ln->tn_type->t_tspec));
2700 1.257 rillig ln = convert(NOOP, 0, expr_derive_type(gettyp(VOID), PTR), ln);
2701 1.1 cgd }
2702 1.1 cgd
2703 1.318 rillig ctn = build_integer_constant(PTRDIFF_TSPEC,
2704 1.136 rillig rn->tn_sym->s_value.v_quad / CHAR_SIZE);
2705 1.1 cgd
2706 1.257 rillig ntn = new_tnode(PLUS, expr_derive_type(rn->tn_type, PTR), ln, ctn);
2707 1.1 cgd if (ln->tn_op == CON)
2708 1.1 cgd ntn = fold(ntn);
2709 1.1 cgd
2710 1.120 rillig if (rn->tn_type->t_bitfield) {
2711 1.100 rillig ntn = new_tnode(FSEL, ntn->tn_type->t_subt, ntn, NULL);
2712 1.1 cgd } else {
2713 1.170 rillig ntn = new_tnode(INDIR, ntn->tn_type->t_subt, ntn, NULL);
2714 1.1 cgd }
2715 1.1 cgd
2716 1.1 cgd if (nolval)
2717 1.154 rillig ntn->tn_lvalue = false;
2718 1.1 cgd
2719 1.95 rillig return ntn;
2720 1.1 cgd }
2721 1.1 cgd
2722 1.1 cgd /*
2723 1.1 cgd * Create a node for INCAFT, INCBEF, DECAFT and DECBEF.
2724 1.1 cgd */
2725 1.1 cgd static tnode_t *
2726 1.100 rillig build_prepost_incdec(op_t op, tnode_t *ln)
2727 1.1 cgd {
2728 1.1 cgd tnode_t *cn, *ntn;
2729 1.1 cgd
2730 1.107 rillig lint_assert(ln != NULL);
2731 1.1 cgd
2732 1.1 cgd if (ln->tn_type->t_tspec == PTR) {
2733 1.1 cgd cn = plength(ln->tn_type);
2734 1.1 cgd } else {
2735 1.318 rillig cn = build_integer_constant(INT, (int64_t)1);
2736 1.1 cgd }
2737 1.100 rillig ntn = new_tnode(op, ln->tn_type, ln, cn);
2738 1.1 cgd
2739 1.95 rillig return ntn;
2740 1.1 cgd }
2741 1.1 cgd
2742 1.1 cgd /*
2743 1.46 christos * Create a node for REAL, IMAG
2744 1.46 christos */
2745 1.46 christos static tnode_t *
2746 1.100 rillig build_real_imag(op_t op, tnode_t *ln)
2747 1.46 christos {
2748 1.46 christos tnode_t *cn, *ntn;
2749 1.46 christos
2750 1.107 rillig lint_assert(ln != NULL);
2751 1.46 christos
2752 1.275 rillig if (ln->tn_op == NAME) {
2753 1.275 rillig /*
2754 1.275 rillig * This may be too much, but it avoids wrong warnings.
2755 1.275 rillig * See d_c99_complex_split.c.
2756 1.275 rillig */
2757 1.275 rillig mark_as_used(ln->tn_sym, false, false);
2758 1.275 rillig mark_as_set(ln->tn_sym);
2759 1.275 rillig }
2760 1.275 rillig
2761 1.46 christos switch (ln->tn_type->t_tspec) {
2762 1.52 matt case LCOMPLEX:
2763 1.182 rillig /* XXX: integer and LDOUBLE don't match. */
2764 1.318 rillig cn = build_integer_constant(LDOUBLE, (int64_t)1);
2765 1.52 matt break;
2766 1.46 christos case DCOMPLEX:
2767 1.257 rillig /* XXX: integer and DOUBLE don't match. */
2768 1.318 rillig cn = build_integer_constant(DOUBLE, (int64_t)1);
2769 1.46 christos break;
2770 1.46 christos case FCOMPLEX:
2771 1.257 rillig /* XXX: integer and FLOAT don't match. */
2772 1.318 rillig cn = build_integer_constant(FLOAT, (int64_t)1);
2773 1.46 christos break;
2774 1.46 christos default:
2775 1.113 rillig /* __%s__ is illegal for type %s */
2776 1.47 christos error(276, op == REAL ? "real" : "imag",
2777 1.115 rillig type_name(ln->tn_type));
2778 1.46 christos return NULL;
2779 1.46 christos }
2780 1.100 rillig ntn = new_tnode(op, cn->tn_type, ln, cn);
2781 1.154 rillig ntn->tn_lvalue = true;
2782 1.46 christos
2783 1.95 rillig return ntn;
2784 1.46 christos }
2785 1.342 rillig
2786 1.46 christos /*
2787 1.182 rillig * Create a tree node for the unary & operator
2788 1.1 cgd */
2789 1.1 cgd static tnode_t *
2790 1.168 rillig build_address(tnode_t *tn, bool noign)
2791 1.1 cgd {
2792 1.1 cgd tspec_t t;
2793 1.20 lukem
2794 1.1 cgd if (!noign && ((t = tn->tn_type->t_tspec) == ARRAY || t == FUNC)) {
2795 1.1 cgd if (tflag)
2796 1.113 rillig /* '&' before array or function: ignored */
2797 1.1 cgd warning(127);
2798 1.95 rillig return tn;
2799 1.1 cgd }
2800 1.1 cgd
2801 1.1 cgd /* eliminate &* */
2802 1.170 rillig if (tn->tn_op == INDIR &&
2803 1.1 cgd tn->tn_left->tn_type->t_tspec == PTR &&
2804 1.1 cgd tn->tn_left->tn_type->t_subt == tn->tn_type) {
2805 1.95 rillig return tn->tn_left;
2806 1.1 cgd }
2807 1.20 lukem
2808 1.257 rillig return new_tnode(ADDR, expr_derive_type(tn->tn_type, PTR), tn, NULL);
2809 1.1 cgd }
2810 1.1 cgd
2811 1.1 cgd /*
2812 1.1 cgd * Create a node for operators PLUS and MINUS.
2813 1.1 cgd */
2814 1.1 cgd static tnode_t *
2815 1.100 rillig build_plus_minus(op_t op, tnode_t *ln, tnode_t *rn)
2816 1.1 cgd {
2817 1.1 cgd tnode_t *ntn, *ctn;
2818 1.1 cgd type_t *tp;
2819 1.1 cgd
2820 1.1 cgd /* If pointer and integer, then pointer to the lhs. */
2821 1.144 rillig if (rn->tn_type->t_tspec == PTR && is_integer(ln->tn_type->t_tspec)) {
2822 1.1 cgd ntn = ln;
2823 1.1 cgd ln = rn;
2824 1.1 cgd rn = ntn;
2825 1.1 cgd }
2826 1.1 cgd
2827 1.1 cgd if (ln->tn_type->t_tspec == PTR && rn->tn_type->t_tspec != PTR) {
2828 1.144 rillig lint_assert(is_integer(rn->tn_type->t_tspec));
2829 1.1 cgd
2830 1.266 rillig check_ctype_macro_invocation(ln, rn);
2831 1.266 rillig
2832 1.1 cgd ctn = plength(ln->tn_type);
2833 1.1 cgd if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec)
2834 1.1 cgd rn = convert(NOOP, 0, ctn->tn_type, rn);
2835 1.100 rillig rn = new_tnode(MULT, rn->tn_type, rn, ctn);
2836 1.1 cgd if (rn->tn_left->tn_op == CON)
2837 1.1 cgd rn = fold(rn);
2838 1.100 rillig ntn = new_tnode(op, ln->tn_type, ln, rn);
2839 1.1 cgd
2840 1.1 cgd } else if (rn->tn_type->t_tspec == PTR) {
2841 1.1 cgd
2842 1.107 rillig lint_assert(ln->tn_type->t_tspec == PTR);
2843 1.107 rillig lint_assert(op == MINUS);
2844 1.191 rillig tp = gettyp(PTRDIFF_TSPEC);
2845 1.100 rillig ntn = new_tnode(op, tp, ln, rn);
2846 1.1 cgd if (ln->tn_op == CON && rn->tn_op == CON)
2847 1.1 cgd ntn = fold(ntn);
2848 1.1 cgd ctn = plength(ln->tn_type);
2849 1.1 cgd balance(NOOP, &ntn, &ctn);
2850 1.100 rillig ntn = new_tnode(DIV, tp, ntn, ctn);
2851 1.1 cgd
2852 1.1 cgd } else {
2853 1.1 cgd
2854 1.100 rillig ntn = new_tnode(op, ln->tn_type, ln, rn);
2855 1.1 cgd
2856 1.1 cgd }
2857 1.95 rillig return ntn;
2858 1.1 cgd }
2859 1.1 cgd
2860 1.1 cgd /*
2861 1.1 cgd * Create a node for operators SHL and SHR.
2862 1.1 cgd */
2863 1.1 cgd static tnode_t *
2864 1.100 rillig build_bit_shift(op_t op, tnode_t *ln, tnode_t *rn)
2865 1.1 cgd {
2866 1.1 cgd tspec_t t;
2867 1.1 cgd tnode_t *ntn;
2868 1.1 cgd
2869 1.1 cgd if ((t = rn->tn_type->t_tspec) != INT && t != UINT)
2870 1.1 cgd rn = convert(CVT, 0, gettyp(INT), rn);
2871 1.100 rillig ntn = new_tnode(op, ln->tn_type, ln, rn);
2872 1.95 rillig return ntn;
2873 1.1 cgd }
2874 1.1 cgd
2875 1.1 cgd /*
2876 1.1 cgd * Create a node for COLON.
2877 1.1 cgd */
2878 1.1 cgd static tnode_t *
2879 1.100 rillig build_colon(tnode_t *ln, tnode_t *rn)
2880 1.1 cgd {
2881 1.1 cgd tspec_t lt, rt, pdt;
2882 1.262 rillig type_t *tp;
2883 1.1 cgd tnode_t *ntn;
2884 1.1 cgd
2885 1.1 cgd lt = ln->tn_type->t_tspec;
2886 1.1 cgd rt = rn->tn_type->t_tspec;
2887 1.191 rillig pdt = PTRDIFF_TSPEC;
2888 1.1 cgd
2889 1.1 cgd /*
2890 1.1 cgd * Arithmetic types are balanced, all other type combinations
2891 1.1 cgd * still need to be handled.
2892 1.1 cgd */
2893 1.144 rillig if (is_arithmetic(lt) && is_arithmetic(rt)) {
2894 1.262 rillig tp = ln->tn_type;
2895 1.165 rillig } else if (lt == BOOL && rt == BOOL) {
2896 1.262 rillig tp = ln->tn_type;
2897 1.1 cgd } else if (lt == VOID || rt == VOID) {
2898 1.262 rillig tp = gettyp(VOID);
2899 1.1 cgd } else if (lt == STRUCT || lt == UNION) {
2900 1.1 cgd /* Both types must be identical. */
2901 1.107 rillig lint_assert(rt == STRUCT || rt == UNION);
2902 1.107 rillig lint_assert(ln->tn_type->t_str == rn->tn_type->t_str);
2903 1.194 rillig if (is_incomplete(ln->tn_type)) {
2904 1.1 cgd /* unknown operand size, op %s */
2905 1.261 rillig error(138, op_name(COLON));
2906 1.95 rillig return NULL;
2907 1.1 cgd }
2908 1.262 rillig tp = ln->tn_type;
2909 1.144 rillig } else if (lt == PTR && is_integer(rt)) {
2910 1.1 cgd if (rt != pdt) {
2911 1.1 cgd rn = convert(NOOP, 0, gettyp(pdt), rn);
2912 1.1 cgd rt = pdt;
2913 1.1 cgd }
2914 1.262 rillig tp = ln->tn_type;
2915 1.144 rillig } else if (rt == PTR && is_integer(lt)) {
2916 1.1 cgd if (lt != pdt) {
2917 1.1 cgd ln = convert(NOOP, 0, gettyp(pdt), ln);
2918 1.1 cgd lt = pdt;
2919 1.1 cgd }
2920 1.262 rillig tp = rn->tn_type;
2921 1.1 cgd } else if (lt == PTR && ln->tn_type->t_subt->t_tspec == VOID) {
2922 1.263 rillig tp = merge_qualifiers(rn->tn_type, ln->tn_type);
2923 1.1 cgd } else if (rt == PTR && rn->tn_type->t_subt->t_tspec == VOID) {
2924 1.263 rillig tp = merge_qualifiers(ln->tn_type, rn->tn_type);
2925 1.1 cgd } else {
2926 1.1 cgd /*
2927 1.1 cgd * XXX For now we simply take the left type. This is
2928 1.106 rillig * probably wrong, if one type contains a function prototype
2929 1.1 cgd * and the other one, at the same place, only an old style
2930 1.1 cgd * declaration.
2931 1.1 cgd */
2932 1.263 rillig tp = merge_qualifiers(ln->tn_type, rn->tn_type);
2933 1.1 cgd }
2934 1.1 cgd
2935 1.262 rillig ntn = new_tnode(COLON, tp, ln, rn);
2936 1.1 cgd
2937 1.95 rillig return ntn;
2938 1.1 cgd }
2939 1.1 cgd
2940 1.1 cgd /*
2941 1.1 cgd * Create a node for an assignment operator (both = and op= ).
2942 1.1 cgd */
2943 1.1 cgd static tnode_t *
2944 1.100 rillig build_assignment(op_t op, tnode_t *ln, tnode_t *rn)
2945 1.1 cgd {
2946 1.1 cgd tspec_t lt, rt;
2947 1.1 cgd tnode_t *ntn, *ctn;
2948 1.1 cgd
2949 1.107 rillig lint_assert(ln != NULL);
2950 1.107 rillig lint_assert(rn != NULL);
2951 1.1 cgd
2952 1.1 cgd lt = ln->tn_type->t_tspec;
2953 1.1 cgd rt = rn->tn_type->t_tspec;
2954 1.1 cgd
2955 1.1 cgd if ((op == ADDASS || op == SUBASS) && lt == PTR) {
2956 1.144 rillig lint_assert(is_integer(rt));
2957 1.1 cgd ctn = plength(ln->tn_type);
2958 1.1 cgd if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec)
2959 1.1 cgd rn = convert(NOOP, 0, ctn->tn_type, rn);
2960 1.100 rillig rn = new_tnode(MULT, rn->tn_type, rn, ctn);
2961 1.1 cgd if (rn->tn_left->tn_op == CON)
2962 1.1 cgd rn = fold(rn);
2963 1.1 cgd }
2964 1.1 cgd
2965 1.333 rillig if ((op == ASSIGN || op == RETURN || op == INIT) &&
2966 1.333 rillig (lt == STRUCT || rt == STRUCT)) {
2967 1.107 rillig lint_assert(lt == rt);
2968 1.107 rillig lint_assert(ln->tn_type->t_str == rn->tn_type->t_str);
2969 1.194 rillig if (is_incomplete(ln->tn_type)) {
2970 1.1 cgd if (op == RETURN) {
2971 1.1 cgd /* cannot return incomplete type */
2972 1.1 cgd error(212);
2973 1.1 cgd } else {
2974 1.1 cgd /* unknown operand size, op %s */
2975 1.260 rillig error(138, op_name(op));
2976 1.1 cgd }
2977 1.95 rillig return NULL;
2978 1.1 cgd }
2979 1.1 cgd }
2980 1.1 cgd
2981 1.40 christos if (op == SHLASS) {
2982 1.228 rillig if (portable_size_in_bits(lt) < portable_size_in_bits(rt)) {
2983 1.40 christos if (hflag)
2984 1.108 rillig /* semantics of '%s' change in ANSI C; ... */
2985 1.40 christos warning(118, "<<=");
2986 1.1 cgd }
2987 1.40 christos } else if (op != SHRASS) {
2988 1.1 cgd if (op == ASSIGN || lt != PTR) {
2989 1.1 cgd if (lt != rt ||
2990 1.120 rillig (ln->tn_type->t_bitfield && rn->tn_op == CON)) {
2991 1.1 cgd rn = convert(op, 0, ln->tn_type, rn);
2992 1.1 cgd rt = lt;
2993 1.1 cgd }
2994 1.1 cgd }
2995 1.1 cgd }
2996 1.1 cgd
2997 1.100 rillig ntn = new_tnode(op, ln->tn_type, ln, rn);
2998 1.1 cgd
2999 1.95 rillig return ntn;
3000 1.1 cgd }
3001 1.1 cgd
3002 1.1 cgd /*
3003 1.352 rillig * Get length of type tp->t_subt, as a constant expression of type ptrdiff_t
3004 1.352 rillig * as seen from the target platform.
3005 1.1 cgd */
3006 1.1 cgd static tnode_t *
3007 1.20 lukem plength(type_t *tp)
3008 1.1 cgd {
3009 1.352 rillig int elem, elsz_in_bits;
3010 1.1 cgd
3011 1.107 rillig lint_assert(tp->t_tspec == PTR);
3012 1.1 cgd tp = tp->t_subt;
3013 1.1 cgd
3014 1.1 cgd elem = 1;
3015 1.352 rillig elsz_in_bits = 0;
3016 1.1 cgd
3017 1.1 cgd while (tp->t_tspec == ARRAY) {
3018 1.1 cgd elem *= tp->t_dim;
3019 1.1 cgd tp = tp->t_subt;
3020 1.1 cgd }
3021 1.1 cgd
3022 1.1 cgd switch (tp->t_tspec) {
3023 1.1 cgd case FUNC:
3024 1.1 cgd /* pointer to function is not allowed here */
3025 1.1 cgd error(110);
3026 1.1 cgd break;
3027 1.1 cgd case VOID:
3028 1.177 rillig /* cannot do pointer arithmetic on operand of unknown size */
3029 1.118 rillig gnuism(136);
3030 1.1 cgd break;
3031 1.1 cgd case STRUCT:
3032 1.1 cgd case UNION:
3033 1.352 rillig if ((elsz_in_bits = tp->t_str->sou_size_in_bits) == 0)
3034 1.1 cgd /* cannot do pointer arithmetic on operand of ... */
3035 1.1 cgd error(136);
3036 1.1 cgd break;
3037 1.1 cgd case ENUM:
3038 1.194 rillig if (is_incomplete(tp)) {
3039 1.1 cgd /* cannot do pointer arithmetic on operand of ... */
3040 1.1 cgd warning(136);
3041 1.1 cgd }
3042 1.1 cgd /* FALLTHROUGH */
3043 1.1 cgd default:
3044 1.352 rillig if ((elsz_in_bits = size_in_bits(tp->t_tspec)) == 0) {
3045 1.1 cgd /* cannot do pointer arithmetic on operand of ... */
3046 1.1 cgd error(136);
3047 1.107 rillig } else {
3048 1.352 rillig lint_assert(elsz_in_bits != -1);
3049 1.1 cgd }
3050 1.1 cgd break;
3051 1.1 cgd }
3052 1.1 cgd
3053 1.352 rillig if (elem == 0 && elsz_in_bits != 0) {
3054 1.177 rillig /* cannot do pointer arithmetic on operand of unknown size */
3055 1.1 cgd error(136);
3056 1.1 cgd }
3057 1.1 cgd
3058 1.352 rillig if (elsz_in_bits == 0)
3059 1.352 rillig elsz_in_bits = CHAR_SIZE;
3060 1.1 cgd
3061 1.318 rillig return build_integer_constant(PTRDIFF_TSPEC,
3062 1.352 rillig (int64_t)(elem * elsz_in_bits / CHAR_SIZE));
3063 1.1 cgd }
3064 1.1 cgd
3065 1.1 cgd /*
3066 1.22 perry * XXX
3067 1.22 perry * Note: There appear to be a number of bugs in detecting overflow in
3068 1.22 perry * this function. An audit and a set of proper regression tests are needed.
3069 1.22 perry * --Perry Metzger, Nov. 16, 2001
3070 1.22 perry */
3071 1.22 perry /*
3072 1.1 cgd * Do only as much as necessary to compute constant expressions.
3073 1.182 rillig * Called only if the operator allows folding and all operands are constants.
3074 1.1 cgd */
3075 1.1 cgd static tnode_t *
3076 1.20 lukem fold(tnode_t *tn)
3077 1.1 cgd {
3078 1.339 rillig val_t *v;
3079 1.339 rillig tspec_t t;
3080 1.339 rillig bool utyp, ovfl;
3081 1.339 rillig int64_t sl, sr = 0, q = 0, mask;
3082 1.25 thorpej uint64_t ul, ur = 0;
3083 1.339 rillig tnode_t *cn;
3084 1.1 cgd
3085 1.259 rillig v = xcalloc(1, sizeof(*v));
3086 1.345 rillig v->v_tspec = tn->tn_type->t_tspec;
3087 1.1 cgd
3088 1.345 rillig t = tn->tn_left->tn_type->t_tspec;
3089 1.345 rillig utyp = !is_integer(t) || is_uinteger(t);
3090 1.1 cgd ul = sl = tn->tn_left->tn_val->v_quad;
3091 1.346 rillig if (is_binary(tn))
3092 1.1 cgd ur = sr = tn->tn_right->tn_val->v_quad;
3093 1.1 cgd
3094 1.287 rillig mask = value_bits(size_in_bits(t));
3095 1.154 rillig ovfl = false;
3096 1.1 cgd
3097 1.1 cgd switch (tn->tn_op) {
3098 1.1 cgd case UPLUS:
3099 1.1 cgd q = sl;
3100 1.1 cgd break;
3101 1.1 cgd case UMINUS:
3102 1.1 cgd q = -sl;
3103 1.348 rillig if (sl != 0 && msb(q, t) == msb(sl, t))
3104 1.154 rillig ovfl = true;
3105 1.1 cgd break;
3106 1.1 cgd case COMPL:
3107 1.1 cgd q = ~sl;
3108 1.1 cgd break;
3109 1.1 cgd case MULT:
3110 1.22 perry if (utyp) {
3111 1.22 perry q = ul * ur;
3112 1.22 perry if (q != (q & mask))
3113 1.154 rillig ovfl = true;
3114 1.22 perry else if ((ul != 0) && ((q / ul) != ur))
3115 1.154 rillig ovfl = true;
3116 1.22 perry } else {
3117 1.22 perry q = sl * sr;
3118 1.348 rillig if (msb(q, t) != (msb(sl, t) ^ msb(sr, t)))
3119 1.154 rillig ovfl = true;
3120 1.22 perry }
3121 1.1 cgd break;
3122 1.1 cgd case DIV:
3123 1.1 cgd if (sr == 0) {
3124 1.1 cgd /* division by 0 */
3125 1.1 cgd error(139);
3126 1.378 rillig q = utyp ? -1 : INT64_MAX;
3127 1.1 cgd } else {
3128 1.57 christos q = utyp ? (int64_t)(ul / ur) : sl / sr;
3129 1.1 cgd }
3130 1.1 cgd break;
3131 1.1 cgd case MOD:
3132 1.1 cgd if (sr == 0) {
3133 1.1 cgd /* modulus by 0 */
3134 1.1 cgd error(140);
3135 1.1 cgd q = 0;
3136 1.1 cgd } else {
3137 1.57 christos q = utyp ? (int64_t)(ul % ur) : sl % sr;
3138 1.1 cgd }
3139 1.1 cgd break;
3140 1.1 cgd case PLUS:
3141 1.57 christos q = utyp ? (int64_t)(ul + ur) : sl + sr;
3142 1.349 rillig if (msb(sl, t) && msb(sr, t) && !msb(q, t))
3143 1.349 rillig ovfl = true;
3144 1.349 rillig if (!utyp && !msb(sl, t) && !msb(sr, t) && msb(q, t))
3145 1.349 rillig ovfl = true;
3146 1.1 cgd break;
3147 1.1 cgd case MINUS:
3148 1.57 christos q = utyp ? (int64_t)(ul - ur) : sl - sr;
3149 1.348 rillig if (!utyp && msb(sl, t) && !msb(sr, t) && !msb(q, t))
3150 1.347 rillig ovfl = true;
3151 1.348 rillig if (!msb(sl, t) && msb(sr, t) && msb(q, t))
3152 1.347 rillig ovfl = true;
3153 1.1 cgd break;
3154 1.1 cgd case SHL:
3155 1.57 christos q = utyp ? (int64_t)(ul << sr) : sl << sr;
3156 1.1 cgd break;
3157 1.1 cgd case SHR:
3158 1.1 cgd /*
3159 1.22 perry * The sign must be explicitly extended because
3160 1.1 cgd * shifts of signed values are implementation dependent.
3161 1.1 cgd */
3162 1.1 cgd q = ul >> sr;
3163 1.298 rillig q = convert_integer(q, t, size_in_bits(t) - (int)sr);
3164 1.1 cgd break;
3165 1.1 cgd case LT:
3166 1.154 rillig q = (utyp ? ul < ur : sl < sr) ? 1 : 0;
3167 1.1 cgd break;
3168 1.1 cgd case LE:
3169 1.154 rillig q = (utyp ? ul <= ur : sl <= sr) ? 1 : 0;
3170 1.1 cgd break;
3171 1.1 cgd case GE:
3172 1.154 rillig q = (utyp ? ul >= ur : sl >= sr) ? 1 : 0;
3173 1.1 cgd break;
3174 1.1 cgd case GT:
3175 1.154 rillig q = (utyp ? ul > ur : sl > sr) ? 1 : 0;
3176 1.1 cgd break;
3177 1.1 cgd case EQ:
3178 1.154 rillig q = (utyp ? ul == ur : sl == sr) ? 1 : 0;
3179 1.1 cgd break;
3180 1.1 cgd case NE:
3181 1.154 rillig q = (utyp ? ul != ur : sl != sr) ? 1 : 0;
3182 1.1 cgd break;
3183 1.171 rillig case BITAND:
3184 1.57 christos q = utyp ? (int64_t)(ul & ur) : sl & sr;
3185 1.1 cgd break;
3186 1.171 rillig case BITXOR:
3187 1.57 christos q = utyp ? (int64_t)(ul ^ ur) : sl ^ sr;
3188 1.1 cgd break;
3189 1.171 rillig case BITOR:
3190 1.57 christos q = utyp ? (int64_t)(ul | ur) : sl | sr;
3191 1.1 cgd break;
3192 1.1 cgd default:
3193 1.157 rillig lint_assert(/*CONSTCOND*/false);
3194 1.1 cgd }
3195 1.1 cgd
3196 1.1 cgd /* XXX does not work for quads. */
3197 1.339 rillig if (ovfl ||
3198 1.339 rillig ((uint64_t)(q | mask) != ~(uint64_t)0 && (q & ~mask) != 0)) {
3199 1.1 cgd if (hflag)
3200 1.350 rillig /* integer overflow detected, op '%s' */
3201 1.261 rillig warning(141, op_name(tn->tn_op));
3202 1.1 cgd }
3203 1.1 cgd
3204 1.356 rillig v->v_quad = convert_integer(q, t, 0);
3205 1.1 cgd
3206 1.318 rillig cn = build_constant(tn->tn_type, v);
3207 1.227 rillig if (tn->tn_left->tn_system_dependent)
3208 1.227 rillig cn->tn_system_dependent = true;
3209 1.346 rillig if (is_binary(tn) && tn->tn_right->tn_system_dependent)
3210 1.227 rillig cn->tn_system_dependent = true;
3211 1.1 cgd
3212 1.95 rillig return cn;
3213 1.1 cgd }
3214 1.1 cgd
3215 1.1 cgd /*
3216 1.182 rillig * Fold constant nodes, as much as is needed for comparing the value with 0
3217 1.182 rillig * (test context, for controlling expressions).
3218 1.1 cgd */
3219 1.1 cgd static tnode_t *
3220 1.100 rillig fold_test(tnode_t *tn)
3221 1.1 cgd {
3222 1.153 rillig bool l, r;
3223 1.1 cgd val_t *v;
3224 1.1 cgd
3225 1.259 rillig v = xcalloc(1, sizeof(*v));
3226 1.1 cgd v->v_tspec = tn->tn_type->t_tspec;
3227 1.151 rillig lint_assert(v->v_tspec == INT || (Tflag && v->v_tspec == BOOL));
3228 1.1 cgd
3229 1.229 rillig l = constant_is_nonzero(tn->tn_left);
3230 1.346 rillig r = is_binary(tn) && constant_is_nonzero(tn->tn_right);
3231 1.1 cgd
3232 1.1 cgd switch (tn->tn_op) {
3233 1.1 cgd case NOT:
3234 1.98 rillig if (hflag && !constcond_flag)
3235 1.265 rillig /* constant argument to '!' */
3236 1.1 cgd warning(239);
3237 1.154 rillig v->v_quad = !l ? 1 : 0;
3238 1.1 cgd break;
3239 1.1 cgd case LOGAND:
3240 1.154 rillig v->v_quad = l && r ? 1 : 0;
3241 1.1 cgd break;
3242 1.1 cgd case LOGOR:
3243 1.154 rillig v->v_quad = l || r ? 1 : 0;
3244 1.1 cgd break;
3245 1.1 cgd default:
3246 1.157 rillig lint_assert(/*CONSTCOND*/false);
3247 1.1 cgd }
3248 1.1 cgd
3249 1.318 rillig return build_constant(tn->tn_type, v);
3250 1.1 cgd }
3251 1.1 cgd
3252 1.378 rillig static ldbl_t
3253 1.378 rillig floating_error_value(tspec_t t, ldbl_t lv)
3254 1.378 rillig {
3255 1.378 rillig if (t == FLOAT) {
3256 1.378 rillig return lv < 0 ? -FLT_MAX : FLT_MAX;
3257 1.378 rillig } else if (t == DOUBLE) {
3258 1.378 rillig return lv < 0 ? -DBL_MAX : DBL_MAX;
3259 1.378 rillig } else {
3260 1.378 rillig /* LINTED 248: floating-point constant out of range */
3261 1.378 rillig ldbl_t max = LDBL_MAX;
3262 1.378 rillig return lv < 0 ? -max : max;
3263 1.378 rillig }
3264 1.378 rillig }
3265 1.378 rillig
3266 1.1 cgd /*
3267 1.182 rillig * Fold constant nodes having operands with floating point type.
3268 1.1 cgd */
3269 1.1 cgd static tnode_t *
3270 1.100 rillig fold_float(tnode_t *tn)
3271 1.1 cgd {
3272 1.1 cgd val_t *v;
3273 1.1 cgd tspec_t t;
3274 1.343 rillig ldbl_t lv, rv = 0;
3275 1.1 cgd
3276 1.157 rillig fpe = 0;
3277 1.259 rillig v = xcalloc(1, sizeof(*v));
3278 1.1 cgd v->v_tspec = t = tn->tn_type->t_tspec;
3279 1.1 cgd
3280 1.144 rillig lint_assert(is_floating(t));
3281 1.107 rillig lint_assert(t == tn->tn_left->tn_type->t_tspec);
3282 1.346 rillig lint_assert(!is_binary(tn) || t == tn->tn_right->tn_type->t_tspec);
3283 1.1 cgd
3284 1.343 rillig lv = tn->tn_left->tn_val->v_ldbl;
3285 1.346 rillig if (is_binary(tn))
3286 1.343 rillig rv = tn->tn_right->tn_val->v_ldbl;
3287 1.1 cgd
3288 1.1 cgd switch (tn->tn_op) {
3289 1.1 cgd case UPLUS:
3290 1.343 rillig v->v_ldbl = lv;
3291 1.1 cgd break;
3292 1.1 cgd case UMINUS:
3293 1.343 rillig v->v_ldbl = -lv;
3294 1.1 cgd break;
3295 1.1 cgd case MULT:
3296 1.343 rillig v->v_ldbl = lv * rv;
3297 1.1 cgd break;
3298 1.1 cgd case DIV:
3299 1.343 rillig if (rv == 0.0) {
3300 1.1 cgd /* division by 0 */
3301 1.1 cgd error(139);
3302 1.378 rillig v->v_ldbl = floating_error_value(t, lv);
3303 1.1 cgd } else {
3304 1.343 rillig v->v_ldbl = lv / rv;
3305 1.1 cgd }
3306 1.1 cgd break;
3307 1.1 cgd case PLUS:
3308 1.343 rillig v->v_ldbl = lv + rv;
3309 1.1 cgd break;
3310 1.1 cgd case MINUS:
3311 1.343 rillig v->v_ldbl = lv - rv;
3312 1.1 cgd break;
3313 1.1 cgd case LT:
3314 1.343 rillig v->v_quad = lv < rv ? 1 : 0;
3315 1.1 cgd break;
3316 1.1 cgd case LE:
3317 1.343 rillig v->v_quad = lv <= rv ? 1 : 0;
3318 1.1 cgd break;
3319 1.1 cgd case GE:
3320 1.343 rillig v->v_quad = lv >= rv ? 1 : 0;
3321 1.1 cgd break;
3322 1.1 cgd case GT:
3323 1.343 rillig v->v_quad = lv > rv ? 1 : 0;
3324 1.1 cgd break;
3325 1.1 cgd case EQ:
3326 1.343 rillig v->v_quad = lv == rv ? 1 : 0;
3327 1.1 cgd break;
3328 1.1 cgd case NE:
3329 1.343 rillig v->v_quad = lv != rv ? 1 : 0;
3330 1.1 cgd break;
3331 1.1 cgd default:
3332 1.157 rillig lint_assert(/*CONSTCOND*/false);
3333 1.1 cgd }
3334 1.1 cgd
3335 1.172 rillig lint_assert(fpe != 0 || isnan((double)v->v_ldbl) == 0);
3336 1.172 rillig if (fpe != 0 || finite((double)v->v_ldbl) == 0 ||
3337 1.1 cgd (t == FLOAT &&
3338 1.1 cgd (v->v_ldbl > FLT_MAX || v->v_ldbl < -FLT_MAX)) ||
3339 1.1 cgd (t == DOUBLE &&
3340 1.1 cgd (v->v_ldbl > DBL_MAX || v->v_ldbl < -DBL_MAX))) {
3341 1.1 cgd /* floating point overflow detected, op %s */
3342 1.261 rillig warning(142, op_name(tn->tn_op));
3343 1.378 rillig v->v_ldbl = floating_error_value(t, v->v_ldbl);
3344 1.342 rillig fpe = 0;
3345 1.1 cgd }
3346 1.1 cgd
3347 1.318 rillig return build_constant(tn->tn_type, v);
3348 1.1 cgd }
3349 1.1 cgd
3350 1.62 christos
3351 1.1 cgd /*
3352 1.1 cgd * Create a constant node for sizeof.
3353 1.1 cgd */
3354 1.1 cgd tnode_t *
3355 1.253 rillig build_sizeof(const type_t *tp)
3356 1.1 cgd {
3357 1.355 rillig unsigned int size_in_bytes = type_size_in_bits(tp) / CHAR_SIZE;
3358 1.318 rillig tnode_t *tn = build_integer_constant(SIZEOF_TSPEC, size_in_bytes);
3359 1.227 rillig tn->tn_system_dependent = true;
3360 1.227 rillig return tn;
3361 1.62 christos }
3362 1.62 christos
3363 1.84 christos /*
3364 1.84 christos * Create a constant node for offsetof.
3365 1.84 christos */
3366 1.378 rillig /* ARGSUSED */ /* See implementation comments. */
3367 1.84 christos tnode_t *
3368 1.253 rillig build_offsetof(const type_t *tp, const sym_t *sym)
3369 1.84 christos {
3370 1.84 christos tspec_t t = tp->t_tspec;
3371 1.84 christos if (t != STRUCT && t != UNION)
3372 1.113 rillig /* unacceptable operand of '%s' */
3373 1.84 christos error(111, "offsetof");
3374 1.89 rillig
3375 1.84 christos // XXX: wrong size, no checking for sym fixme
3376 1.355 rillig unsigned int offset_in_bytes = type_size_in_bits(tp) / CHAR_SIZE;
3377 1.318 rillig tnode_t *tn = build_integer_constant(SIZEOF_TSPEC, offset_in_bytes);
3378 1.227 rillig tn->tn_system_dependent = true;
3379 1.227 rillig return tn;
3380 1.84 christos }
3381 1.84 christos
3382 1.355 rillig unsigned int
3383 1.253 rillig type_size_in_bits(const type_t *tp)
3384 1.62 christos {
3385 1.355 rillig unsigned int elem, elsz;
3386 1.154 rillig bool flex;
3387 1.1 cgd
3388 1.1 cgd elem = 1;
3389 1.154 rillig flex = false;
3390 1.1 cgd while (tp->t_tspec == ARRAY) {
3391 1.154 rillig flex = true; /* allow c99 flex arrays [] [0] */
3392 1.1 cgd elem *= tp->t_dim;
3393 1.1 cgd tp = tp->t_subt;
3394 1.1 cgd }
3395 1.1 cgd if (elem == 0) {
3396 1.77 christos if (!flex) {
3397 1.108 rillig /* cannot take size/alignment of incomplete type */
3398 1.77 christos error(143);
3399 1.77 christos elem = 1;
3400 1.77 christos }
3401 1.1 cgd }
3402 1.1 cgd switch (tp->t_tspec) {
3403 1.1 cgd case FUNC:
3404 1.108 rillig /* cannot take size/alignment of function */
3405 1.1 cgd error(144);
3406 1.1 cgd elsz = 1;
3407 1.1 cgd break;
3408 1.1 cgd case STRUCT:
3409 1.1 cgd case UNION:
3410 1.194 rillig if (is_incomplete(tp)) {
3411 1.108 rillig /* cannot take size/alignment of incomplete type */
3412 1.1 cgd error(143);
3413 1.1 cgd elsz = 1;
3414 1.1 cgd } else {
3415 1.237 rillig elsz = tp->t_str->sou_size_in_bits;
3416 1.1 cgd }
3417 1.1 cgd break;
3418 1.1 cgd case ENUM:
3419 1.194 rillig if (is_incomplete(tp)) {
3420 1.108 rillig /* cannot take size/alignment of incomplete type */
3421 1.1 cgd warning(143);
3422 1.1 cgd }
3423 1.1 cgd /* FALLTHROUGH */
3424 1.1 cgd default:
3425 1.120 rillig if (tp->t_bitfield) {
3426 1.108 rillig /* cannot take size/alignment of bit-field */
3427 1.1 cgd error(145);
3428 1.1 cgd }
3429 1.1 cgd if (tp->t_tspec == VOID) {
3430 1.108 rillig /* cannot take size/alignment of void */
3431 1.1 cgd error(146);
3432 1.1 cgd elsz = 1;
3433 1.1 cgd } else {
3434 1.228 rillig elsz = size_in_bits(tp->t_tspec);
3435 1.107 rillig lint_assert(elsz > 0);
3436 1.1 cgd }
3437 1.1 cgd break;
3438 1.1 cgd }
3439 1.1 cgd
3440 1.355 rillig return elem * elsz;
3441 1.1 cgd }
3442 1.1 cgd
3443 1.59 christos tnode_t *
3444 1.253 rillig build_alignof(const type_t *tp)
3445 1.59 christos {
3446 1.59 christos switch (tp->t_tspec) {
3447 1.59 christos case ARRAY:
3448 1.59 christos break;
3449 1.59 christos
3450 1.59 christos case FUNC:
3451 1.108 rillig /* cannot take size/alignment of function */
3452 1.59 christos error(144);
3453 1.59 christos return 0;
3454 1.59 christos
3455 1.59 christos case STRUCT:
3456 1.59 christos case UNION:
3457 1.194 rillig if (is_incomplete(tp)) {
3458 1.108 rillig /* cannot take size/alignment of incomplete type */
3459 1.59 christos error(143);
3460 1.59 christos return 0;
3461 1.59 christos }
3462 1.59 christos break;
3463 1.59 christos case ENUM:
3464 1.59 christos break;
3465 1.59 christos default:
3466 1.120 rillig if (tp->t_bitfield) {
3467 1.108 rillig /* cannot take size/alignment of bit-field */
3468 1.59 christos error(145);
3469 1.59 christos return 0;
3470 1.59 christos }
3471 1.59 christos if (tp->t_tspec == VOID) {
3472 1.108 rillig /* cannot take size/alignment of void */
3473 1.59 christos error(146);
3474 1.59 christos return 0;
3475 1.59 christos }
3476 1.59 christos break;
3477 1.59 christos }
3478 1.59 christos
3479 1.318 rillig return build_integer_constant(SIZEOF_TSPEC,
3480 1.220 rillig (int64_t)alignment_in_bits(tp) / CHAR_SIZE);
3481 1.59 christos }
3482 1.59 christos
3483 1.59 christos /*
3484 1.1 cgd * Type casts.
3485 1.1 cgd */
3486 1.1 cgd tnode_t *
3487 1.20 lukem cast(tnode_t *tn, type_t *tp)
3488 1.1 cgd {
3489 1.1 cgd tspec_t nt, ot;
3490 1.1 cgd
3491 1.1 cgd if (tn == NULL)
3492 1.95 rillig return NULL;
3493 1.1 cgd
3494 1.232 rillig /*
3495 1.232 rillig * XXX: checking for tp == NULL is only a quick fix for PR 22119.
3496 1.232 rillig * The proper fix needs to be investigated properly.
3497 1.232 rillig * See d_pr_22119.c for how to get here.
3498 1.232 rillig */
3499 1.232 rillig if (tp == NULL)
3500 1.232 rillig return NULL;
3501 1.232 rillig
3502 1.1 cgd tn = cconv(tn);
3503 1.1 cgd
3504 1.1 cgd nt = tp->t_tspec;
3505 1.1 cgd ot = tn->tn_type->t_tspec;
3506 1.1 cgd
3507 1.1 cgd if (nt == VOID) {
3508 1.1 cgd /*
3509 1.106 rillig * XXX ANSI C requires scalar types or void (Plauger & Brodie).
3510 1.182 rillig * But this seems really questionable.
3511 1.1 cgd */
3512 1.83 christos } else if (nt == UNION) {
3513 1.83 christos sym_t *m;
3514 1.208 rillig struct_or_union *str = tp->t_str;
3515 1.329 rillig if (!gflag) {
3516 1.329 rillig /* union cast is a GCC extension */
3517 1.83 christos error(328);
3518 1.83 christos return NULL;
3519 1.83 christos }
3520 1.208 rillig for (m = str->sou_first_member; m != NULL; m = m->s_next) {
3521 1.330 rillig if (eqtype(m->s_type, tn->tn_type,
3522 1.330 rillig false, false, NULL)) {
3523 1.256 rillig tn = expr_zalloc_tnode();
3524 1.83 christos tn->tn_op = CVT;
3525 1.83 christos tn->tn_type = tp;
3526 1.154 rillig tn->tn_cast = true;
3527 1.83 christos tn->tn_right = NULL;
3528 1.83 christos return tn;
3529 1.83 christos }
3530 1.83 christos }
3531 1.113 rillig /* type '%s' is not a member of '%s' */
3532 1.115 rillig error(329, type_name(tn->tn_type), type_name(tp));
3533 1.83 christos return NULL;
3534 1.83 christos } else if (nt == STRUCT || nt == ARRAY || nt == FUNC) {
3535 1.328 rillig /* Casting to a struct is an undocumented GCC extension. */
3536 1.328 rillig if (!(gflag && nt == STRUCT))
3537 1.319 rillig goto invalid_cast;
3538 1.1 cgd } else if (ot == STRUCT || ot == UNION) {
3539 1.319 rillig goto invalid_cast;
3540 1.1 cgd } else if (ot == VOID) {
3541 1.1 cgd /* improper cast of void expression */
3542 1.1 cgd error(148);
3543 1.95 rillig return NULL;
3544 1.144 rillig } else if (is_integer(nt) && is_scalar(ot)) {
3545 1.1 cgd /* ok */
3546 1.144 rillig } else if (is_floating(nt) && is_arithmetic(ot)) {
3547 1.1 cgd /* ok */
3548 1.144 rillig } else if (nt == PTR && is_integer(ot)) {
3549 1.1 cgd /* ok */
3550 1.1 cgd } else if (nt == PTR && ot == PTR) {
3551 1.7 jpo if (!tp->t_subt->t_const && tn->tn_type->t_subt->t_const) {
3552 1.7 jpo if (hflag)
3553 1.196 rillig /* cast discards 'const' from type '%s' */
3554 1.196 rillig warning(275, type_name(tn->tn_type));
3555 1.7 jpo }
3556 1.319 rillig } else
3557 1.319 rillig goto invalid_cast;
3558 1.1 cgd
3559 1.1 cgd tn = convert(CVT, 0, tp, tn);
3560 1.154 rillig tn->tn_cast = true;
3561 1.1 cgd
3562 1.95 rillig return tn;
3563 1.319 rillig
3564 1.319 rillig invalid_cast:
3565 1.319 rillig /* invalid cast from '%s' to '%s' */
3566 1.319 rillig error(147, type_name(tn->tn_type), type_name(tp));
3567 1.319 rillig return NULL;
3568 1.1 cgd }
3569 1.1 cgd
3570 1.1 cgd /*
3571 1.1 cgd * Create the node for a function argument.
3572 1.122 rillig * All necessary conversions and type checks are done in
3573 1.318 rillig * build_function_call because build_function_argument has no
3574 1.122 rillig * information about expected argument types.
3575 1.1 cgd */
3576 1.1 cgd tnode_t *
3577 1.318 rillig build_function_argument(tnode_t *args, tnode_t *arg)
3578 1.1 cgd {
3579 1.1 cgd tnode_t *ntn;
3580 1.1 cgd
3581 1.1 cgd /*
3582 1.1 cgd * If there was a serious error in the expression for the argument,
3583 1.1 cgd * create a dummy argument so the positions of the remaining arguments
3584 1.1 cgd * will not change.
3585 1.1 cgd */
3586 1.1 cgd if (arg == NULL)
3587 1.318 rillig arg = build_integer_constant(INT, 0);
3588 1.1 cgd
3589 1.100 rillig ntn = new_tnode(PUSH, arg->tn_type, arg, args);
3590 1.1 cgd
3591 1.95 rillig return ntn;
3592 1.1 cgd }
3593 1.1 cgd
3594 1.1 cgd /*
3595 1.1 cgd * Create the node for a function call. Also check types of
3596 1.1 cgd * function arguments and insert conversions, if necessary.
3597 1.1 cgd */
3598 1.1 cgd tnode_t *
3599 1.318 rillig build_function_call(tnode_t *func, tnode_t *args)
3600 1.1 cgd {
3601 1.1 cgd tnode_t *ntn;
3602 1.1 cgd op_t fcop;
3603 1.1 cgd
3604 1.1 cgd if (func == NULL)
3605 1.95 rillig return NULL;
3606 1.1 cgd
3607 1.1 cgd if (func->tn_op == NAME && func->tn_type->t_tspec == FUNC) {
3608 1.1 cgd fcop = CALL;
3609 1.1 cgd } else {
3610 1.1 cgd fcop = ICALL;
3611 1.1 cgd }
3612 1.1 cgd
3613 1.266 rillig check_ctype_function_call(func, args);
3614 1.266 rillig
3615 1.1 cgd /*
3616 1.1 cgd * after cconv() func will always be a pointer to a function
3617 1.1 cgd * if it is a valid function designator.
3618 1.1 cgd */
3619 1.1 cgd func = cconv(func);
3620 1.1 cgd
3621 1.1 cgd if (func->tn_type->t_tspec != PTR ||
3622 1.1 cgd func->tn_type->t_subt->t_tspec != FUNC) {
3623 1.108 rillig /* illegal function (type %s) */
3624 1.115 rillig error(149, type_name(func->tn_type));
3625 1.95 rillig return NULL;
3626 1.1 cgd }
3627 1.1 cgd
3628 1.100 rillig args = check_function_arguments(func->tn_type->t_subt, args);
3629 1.1 cgd
3630 1.100 rillig ntn = new_tnode(fcop, func->tn_type->t_subt->t_subt, func, args);
3631 1.1 cgd
3632 1.95 rillig return ntn;
3633 1.1 cgd }
3634 1.1 cgd
3635 1.1 cgd /*
3636 1.1 cgd * Check types of all function arguments and insert conversions,
3637 1.1 cgd * if necessary.
3638 1.1 cgd */
3639 1.1 cgd static tnode_t *
3640 1.100 rillig check_function_arguments(type_t *ftp, tnode_t *args)
3641 1.1 cgd {
3642 1.1 cgd tnode_t *arg;
3643 1.1 cgd sym_t *asym;
3644 1.1 cgd tspec_t at;
3645 1.1 cgd int narg, npar, n, i;
3646 1.1 cgd
3647 1.1 cgd /* get # of args in the prototype */
3648 1.1 cgd npar = 0;
3649 1.101 rillig for (asym = ftp->t_args; asym != NULL; asym = asym->s_next)
3650 1.1 cgd npar++;
3651 1.1 cgd
3652 1.1 cgd /* get # of args in function call */
3653 1.1 cgd narg = 0;
3654 1.1 cgd for (arg = args; arg != NULL; arg = arg->tn_right)
3655 1.1 cgd narg++;
3656 1.1 cgd
3657 1.1 cgd asym = ftp->t_args;
3658 1.1 cgd if (ftp->t_proto && npar != narg && !(ftp->t_vararg && npar < narg)) {
3659 1.1 cgd /* argument mismatch: %d arg%s passed, %d expected */
3660 1.1 cgd error(150, narg, narg > 1 ? "s" : "", npar);
3661 1.1 cgd asym = NULL;
3662 1.1 cgd }
3663 1.20 lukem
3664 1.1 cgd for (n = 1; n <= narg; n++) {
3665 1.1 cgd
3666 1.1 cgd /*
3667 1.1 cgd * The rightmost argument is at the top of the argument
3668 1.1 cgd * subtree.
3669 1.1 cgd */
3670 1.20 lukem for (i = narg, arg = args; i > n; i--, arg = arg->tn_right)
3671 1.20 lukem continue;
3672 1.1 cgd
3673 1.106 rillig /* some things which are always not allowed */
3674 1.1 cgd if ((at = arg->tn_left->tn_type->t_tspec) == VOID) {
3675 1.1 cgd /* void expressions may not be arguments, arg #%d */
3676 1.1 cgd error(151, n);
3677 1.95 rillig return NULL;
3678 1.1 cgd } else if ((at == STRUCT || at == UNION) &&
3679 1.194 rillig is_incomplete(arg->tn_left->tn_type)) {
3680 1.1 cgd /* argument cannot have unknown size, arg #%d */
3681 1.1 cgd error(152, n);
3682 1.95 rillig return NULL;
3683 1.144 rillig } else if (is_integer(at) &&
3684 1.209 rillig arg->tn_left->tn_type->t_is_enum &&
3685 1.194 rillig is_incomplete(arg->tn_left->tn_type)) {
3686 1.1 cgd /* argument cannot have unknown size, arg #%d */
3687 1.1 cgd warning(152, n);
3688 1.1 cgd }
3689 1.1 cgd
3690 1.1 cgd /* class conversions (arg in value context) */
3691 1.1 cgd arg->tn_left = cconv(arg->tn_left);
3692 1.1 cgd
3693 1.1 cgd if (asym != NULL) {
3694 1.100 rillig arg->tn_left = check_prototype_argument(
3695 1.100 rillig n, asym->s_type, arg->tn_left);
3696 1.1 cgd } else {
3697 1.172 rillig arg->tn_left = promote(NOOP, true, arg->tn_left);
3698 1.1 cgd }
3699 1.1 cgd arg->tn_type = arg->tn_left->tn_type;
3700 1.1 cgd
3701 1.1 cgd if (asym != NULL)
3702 1.101 rillig asym = asym->s_next;
3703 1.1 cgd }
3704 1.1 cgd
3705 1.95 rillig return args;
3706 1.1 cgd }
3707 1.1 cgd
3708 1.1 cgd /*
3709 1.1 cgd * Compare the type of an argument with the corresponding type of a
3710 1.1 cgd * prototype parameter. If it is a valid combination, but both types
3711 1.1 cgd * are not the same, insert a conversion to convert the argument into
3712 1.1 cgd * the type of the parameter.
3713 1.1 cgd */
3714 1.1 cgd static tnode_t *
3715 1.100 rillig check_prototype_argument(
3716 1.100 rillig int n, /* pos of arg */
3717 1.20 lukem type_t *tp, /* expected type (from prototype) */
3718 1.20 lukem tnode_t *tn) /* argument */
3719 1.1 cgd {
3720 1.1 cgd tnode_t *ln;
3721 1.154 rillig bool dowarn;
3722 1.1 cgd
3723 1.259 rillig ln = xcalloc(1, sizeof(*ln));
3724 1.320 rillig ln->tn_type = expr_unqualified_type(tp);
3725 1.154 rillig ln->tn_lvalue = true;
3726 1.1 cgd if (typeok(FARG, n, ln, tn)) {
3727 1.154 rillig if (!eqtype(tp, tn->tn_type,
3728 1.154 rillig true, false, (dowarn = false, &dowarn)) || dowarn)
3729 1.1 cgd tn = convert(FARG, n, tp, tn);
3730 1.1 cgd }
3731 1.1 cgd free(ln);
3732 1.95 rillig return tn;
3733 1.1 cgd }
3734 1.1 cgd
3735 1.1 cgd /*
3736 1.1 cgd * Return the value of an integral constant expression.
3737 1.1 cgd * If the expression is not constant or its type is not an integer
3738 1.1 cgd * type, an error message is printed.
3739 1.1 cgd */
3740 1.1 cgd val_t *
3741 1.154 rillig constant(tnode_t *tn, bool required)
3742 1.1 cgd {
3743 1.1 cgd val_t *v;
3744 1.1 cgd
3745 1.1 cgd if (tn != NULL)
3746 1.1 cgd tn = cconv(tn);
3747 1.1 cgd if (tn != NULL)
3748 1.172 rillig tn = promote(NOOP, false, tn);
3749 1.1 cgd
3750 1.259 rillig v = xcalloc(1, sizeof(*v));
3751 1.1 cgd
3752 1.1 cgd if (tn == NULL) {
3753 1.107 rillig lint_assert(nerr != 0);
3754 1.325 rillig debug_step("constant node is null; returning 1 instead");
3755 1.1 cgd v->v_tspec = INT;
3756 1.1 cgd v->v_quad = 1;
3757 1.95 rillig return v;
3758 1.1 cgd }
3759 1.1 cgd
3760 1.1 cgd v->v_tspec = tn->tn_type->t_tspec;
3761 1.1 cgd
3762 1.1 cgd if (tn->tn_op == CON) {
3763 1.107 rillig lint_assert(tn->tn_type->t_tspec == tn->tn_val->v_tspec);
3764 1.144 rillig if (is_integer(tn->tn_val->v_tspec)) {
3765 1.289 rillig v->v_unsigned_since_c90 =
3766 1.289 rillig tn->tn_val->v_unsigned_since_c90;
3767 1.1 cgd v->v_quad = tn->tn_val->v_quad;
3768 1.95 rillig return v;
3769 1.1 cgd }
3770 1.1 cgd v->v_quad = tn->tn_val->v_ldbl;
3771 1.1 cgd } else {
3772 1.1 cgd v->v_quad = 1;
3773 1.1 cgd }
3774 1.1 cgd
3775 1.31 christos if (required)
3776 1.113 rillig /* integral constant expression expected */
3777 1.31 christos error(55);
3778 1.31 christos else
3779 1.113 rillig /* variable array dimension is a C99/GCC extension */
3780 1.45 christos c99ism(318);
3781 1.1 cgd
3782 1.144 rillig if (!is_integer(v->v_tspec))
3783 1.1 cgd v->v_tspec = INT;
3784 1.1 cgd
3785 1.95 rillig return v;
3786 1.1 cgd }
3787 1.1 cgd
3788 1.211 rillig static bool
3789 1.211 rillig is_constcond_false(const tnode_t *tn, tspec_t t)
3790 1.211 rillig {
3791 1.211 rillig return (t == BOOL || t == INT) &&
3792 1.211 rillig tn->tn_op == CON && tn->tn_val->v_quad == 0;
3793 1.211 rillig }
3794 1.211 rillig
3795 1.1 cgd /*
3796 1.317 rillig * Perform some tests on expressions which can't be done in build_binary()
3797 1.317 rillig * and functions called by build_binary(). These tests must be done here
3798 1.317 rillig * because we need some information about the context in which the operations
3799 1.1 cgd * are performed.
3800 1.217 rillig * After all tests are performed and dofreeblk is true, expr() frees the
3801 1.217 rillig * memory which is used for the expression.
3802 1.1 cgd */
3803 1.1 cgd void
3804 1.280 rillig expr(tnode_t *tn, bool vctx, bool tctx, bool dofreeblk, bool is_do_while)
3805 1.1 cgd {
3806 1.20 lukem
3807 1.305 rillig if (tn == NULL) { /* in case of errors */
3808 1.257 rillig expr_free_all();
3809 1.1 cgd return;
3810 1.1 cgd }
3811 1.1 cgd
3812 1.218 rillig /* expr() is also called in global initializations */
3813 1.280 rillig if (dcs->d_ctx != EXTERN && !is_do_while)
3814 1.98 rillig check_statement_reachable();
3815 1.1 cgd
3816 1.172 rillig check_expr_misc(tn, vctx, tctx, !tctx, false, false, false);
3817 1.1 cgd if (tn->tn_op == ASSIGN) {
3818 1.1 cgd if (hflag && tctx)
3819 1.1 cgd /* assignment in conditional context */
3820 1.1 cgd warning(159);
3821 1.1 cgd } else if (tn->tn_op == CON) {
3822 1.202 rillig if (hflag && tctx && !constcond_flag &&
3823 1.227 rillig !tn->tn_system_dependent &&
3824 1.280 rillig !(is_do_while &&
3825 1.211 rillig is_constcond_false(tn, tn->tn_type->t_tspec)))
3826 1.1 cgd /* constant in conditional context */
3827 1.1 cgd warning(161);
3828 1.1 cgd }
3829 1.164 rillig if (!modtab[tn->tn_op].m_has_side_effect) {
3830 1.1 cgd /*
3831 1.1 cgd * for left operands of COMMA this warning is already
3832 1.1 cgd * printed
3833 1.1 cgd */
3834 1.1 cgd if (tn->tn_op != COMMA && !vctx && !tctx)
3835 1.100 rillig check_null_effect(tn);
3836 1.1 cgd }
3837 1.326 rillig debug_node(tn);
3838 1.1 cgd
3839 1.1 cgd /* free the tree memory */
3840 1.54 dholland if (dofreeblk)
3841 1.257 rillig expr_free_all();
3842 1.1 cgd }
3843 1.1 cgd
3844 1.197 rillig static bool
3845 1.199 rillig has_side_effect(const tnode_t *tn) // NOLINT(misc-no-recursion)
3846 1.1 cgd {
3847 1.199 rillig op_t op = tn->tn_op;
3848 1.199 rillig
3849 1.199 rillig if (modtab[op].m_has_side_effect)
3850 1.199 rillig return true;
3851 1.199 rillig
3852 1.199 rillig if (op == CVT && tn->tn_type->t_tspec == VOID)
3853 1.199 rillig return has_side_effect(tn->tn_left);
3854 1.199 rillig
3855 1.199 rillig /* XXX: Why not has_side_effect(tn->tn_left) as well? */
3856 1.199 rillig if (op == LOGAND || op == LOGOR)
3857 1.199 rillig return has_side_effect(tn->tn_right);
3858 1.199 rillig
3859 1.199 rillig /* XXX: Why not has_side_effect(tn->tn_left) as well? */
3860 1.199 rillig if (op == QUEST)
3861 1.199 rillig return has_side_effect(tn->tn_right);
3862 1.199 rillig
3863 1.199 rillig if (op == COLON || op == COMMA) {
3864 1.199 rillig return has_side_effect(tn->tn_left) ||
3865 1.199 rillig has_side_effect(tn->tn_right);
3866 1.1 cgd }
3867 1.197 rillig
3868 1.199 rillig return false;
3869 1.197 rillig }
3870 1.197 rillig
3871 1.341 rillig static bool
3872 1.341 rillig is_void_cast(const tnode_t *tn)
3873 1.341 rillig {
3874 1.341 rillig
3875 1.341 rillig return tn->tn_op == CVT && tn->tn_cast &&
3876 1.341 rillig tn->tn_type->t_tspec == VOID;
3877 1.341 rillig }
3878 1.341 rillig
3879 1.341 rillig static bool
3880 1.341 rillig is_local_symbol(const tnode_t *tn)
3881 1.341 rillig {
3882 1.341 rillig
3883 1.341 rillig return tn->tn_op == LOAD &&
3884 1.341 rillig tn->tn_left->tn_op == NAME &&
3885 1.341 rillig tn->tn_left->tn_sym->s_scl == AUTO;
3886 1.341 rillig }
3887 1.341 rillig
3888 1.341 rillig static bool
3889 1.341 rillig is_int_constant_zero(const tnode_t *tn)
3890 1.341 rillig {
3891 1.341 rillig
3892 1.341 rillig return tn->tn_op == CON &&
3893 1.341 rillig tn->tn_type->t_tspec == INT &&
3894 1.341 rillig tn->tn_val->v_quad == 0;
3895 1.341 rillig }
3896 1.341 rillig
3897 1.197 rillig static void
3898 1.197 rillig check_null_effect(const tnode_t *tn)
3899 1.197 rillig {
3900 1.197 rillig
3901 1.341 rillig if (!hflag)
3902 1.341 rillig return;
3903 1.342 rillig if (has_side_effect(tn))
3904 1.341 rillig return;
3905 1.341 rillig if (is_void_cast(tn) && is_local_symbol(tn->tn_left))
3906 1.341 rillig return;
3907 1.341 rillig if (is_void_cast(tn) && is_int_constant_zero(tn->tn_left))
3908 1.341 rillig return;
3909 1.341 rillig
3910 1.341 rillig /* expression has null effect */
3911 1.341 rillig warning(129);
3912 1.1 cgd }
3913 1.1 cgd
3914 1.370 rillig static void
3915 1.370 rillig check_expr_addr(const tnode_t *ln, bool szof, bool fcall)
3916 1.370 rillig {
3917 1.370 rillig /* XXX: Taking warn_about_unreachable into account here feels wrong. */
3918 1.370 rillig if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) {
3919 1.370 rillig if (!szof)
3920 1.370 rillig mark_as_set(ln->tn_sym);
3921 1.370 rillig mark_as_used(ln->tn_sym, fcall, szof);
3922 1.370 rillig }
3923 1.370 rillig if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS)
3924 1.370 rillig /* check the range of array indices */
3925 1.370 rillig check_array_index(ln->tn_left, true);
3926 1.370 rillig }
3927 1.370 rillig
3928 1.370 rillig static void
3929 1.370 rillig check_expr_load(const tnode_t *ln)
3930 1.370 rillig {
3931 1.370 rillig if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS)
3932 1.370 rillig /* check the range of array indices */
3933 1.370 rillig check_array_index(ln->tn_left, false);
3934 1.370 rillig }
3935 1.370 rillig
3936 1.370 rillig static void
3937 1.370 rillig check_expr_side_effect(const tnode_t *ln, bool szof)
3938 1.1 cgd {
3939 1.370 rillig scl_t sc;
3940 1.370 rillig dinfo_t *di;
3941 1.370 rillig
3942 1.370 rillig /* XXX: Taking warn_about_unreachable into account here feels wrong. */
3943 1.370 rillig if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) {
3944 1.370 rillig sc = ln->tn_sym->s_scl;
3945 1.370 rillig /*
3946 1.370 rillig * Look if there was a asm statement in one of the
3947 1.370 rillig * compound statements we are in. If not, we don't
3948 1.370 rillig * print a warning.
3949 1.370 rillig */
3950 1.370 rillig for (di = dcs; di != NULL; di = di->d_next) {
3951 1.370 rillig if (di->d_asm)
3952 1.370 rillig break;
3953 1.370 rillig }
3954 1.370 rillig if (sc != EXTERN && sc != STATIC &&
3955 1.370 rillig !ln->tn_sym->s_set && !szof && di == NULL) {
3956 1.370 rillig /* %s may be used before set */
3957 1.370 rillig warning(158, ln->tn_sym->s_name);
3958 1.370 rillig mark_as_set(ln->tn_sym);
3959 1.370 rillig }
3960 1.370 rillig mark_as_used(ln->tn_sym, false, false);
3961 1.370 rillig }
3962 1.370 rillig }
3963 1.1 cgd
3964 1.370 rillig static void
3965 1.370 rillig check_expr_assign(const tnode_t *ln, bool szof)
3966 1.370 rillig {
3967 1.370 rillig /* XXX: Taking warn_about_unreachable into account here feels wrong. */
3968 1.370 rillig if (ln->tn_op == NAME && !szof && (reached || !warn_about_unreachable)) {
3969 1.370 rillig mark_as_set(ln->tn_sym);
3970 1.370 rillig if (ln->tn_sym->s_scl == EXTERN)
3971 1.370 rillig outusg(ln->tn_sym);
3972 1.370 rillig }
3973 1.370 rillig if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS)
3974 1.370 rillig /* check the range of array indices */
3975 1.370 rillig check_array_index(ln->tn_left, false);
3976 1.370 rillig }
3977 1.1 cgd
3978 1.370 rillig static void
3979 1.370 rillig check_expr_call(const tnode_t *tn, const tnode_t *ln,
3980 1.370 rillig bool szof, bool vctx, bool tctx, bool rvdisc)
3981 1.370 rillig {
3982 1.370 rillig lint_assert(ln->tn_op == ADDR);
3983 1.370 rillig lint_assert(ln->tn_left->tn_op == NAME);
3984 1.370 rillig if (!szof &&
3985 1.370 rillig !is_compiler_builtin(ln->tn_left->tn_sym->s_name))
3986 1.370 rillig outcall(tn, vctx || tctx, rvdisc);
3987 1.370 rillig }
3988 1.1 cgd
3989 1.370 rillig static bool
3990 1.370 rillig check_expr_op(const tnode_t *tn, op_t op, const tnode_t *ln,
3991 1.370 rillig bool szof, bool fcall, bool vctx, bool tctx, bool rvdisc,
3992 1.370 rillig bool eqwarn)
3993 1.370 rillig {
3994 1.1 cgd switch (op) {
3995 1.169 rillig case ADDR:
3996 1.370 rillig check_expr_addr(ln, szof, fcall);
3997 1.1 cgd break;
3998 1.1 cgd case LOAD:
3999 1.370 rillig check_expr_load(ln);
4000 1.1 cgd /* FALLTHROUGH */
4001 1.1 cgd case PUSH:
4002 1.1 cgd case INCBEF:
4003 1.1 cgd case DECBEF:
4004 1.1 cgd case INCAFT:
4005 1.1 cgd case DECAFT:
4006 1.1 cgd case ADDASS:
4007 1.1 cgd case SUBASS:
4008 1.1 cgd case MULASS:
4009 1.1 cgd case DIVASS:
4010 1.1 cgd case MODASS:
4011 1.1 cgd case ANDASS:
4012 1.1 cgd case ORASS:
4013 1.1 cgd case XORASS:
4014 1.1 cgd case SHLASS:
4015 1.1 cgd case SHRASS:
4016 1.46 christos case REAL:
4017 1.46 christos case IMAG:
4018 1.370 rillig check_expr_side_effect(ln, szof);
4019 1.1 cgd break;
4020 1.1 cgd case ASSIGN:
4021 1.370 rillig check_expr_assign(ln, szof);
4022 1.1 cgd break;
4023 1.1 cgd case CALL:
4024 1.370 rillig check_expr_call(tn, ln, szof, vctx, tctx, rvdisc);
4025 1.1 cgd break;
4026 1.1 cgd case EQ:
4027 1.1 cgd if (hflag && eqwarn)
4028 1.113 rillig /* operator '==' found where '=' was expected */
4029 1.1 cgd warning(160);
4030 1.1 cgd break;
4031 1.1 cgd case CON:
4032 1.1 cgd case NAME:
4033 1.1 cgd case STRING:
4034 1.370 rillig return false;
4035 1.73 christos /* LINTED206: (enumeration values not handled in switch) */
4036 1.171 rillig case BITOR:
4037 1.171 rillig case BITXOR:
4038 1.14 christos case NE:
4039 1.14 christos case GE:
4040 1.14 christos case GT:
4041 1.14 christos case LE:
4042 1.14 christos case LT:
4043 1.14 christos case SHR:
4044 1.14 christos case SHL:
4045 1.14 christos case MINUS:
4046 1.14 christos case PLUS:
4047 1.14 christos case MOD:
4048 1.14 christos case DIV:
4049 1.14 christos case MULT:
4050 1.170 rillig case INDIR:
4051 1.14 christos case UMINUS:
4052 1.14 christos case UPLUS:
4053 1.14 christos case DEC:
4054 1.14 christos case INC:
4055 1.14 christos case COMPL:
4056 1.14 christos case NOT:
4057 1.14 christos case POINT:
4058 1.14 christos case ARROW:
4059 1.14 christos case NOOP:
4060 1.171 rillig case BITAND:
4061 1.14 christos case FARG:
4062 1.14 christos case CASE:
4063 1.14 christos case INIT:
4064 1.14 christos case RETURN:
4065 1.14 christos case ICALL:
4066 1.14 christos case CVT:
4067 1.14 christos case COMMA:
4068 1.14 christos case FSEL:
4069 1.14 christos case COLON:
4070 1.14 christos case QUEST:
4071 1.14 christos case LOGOR:
4072 1.14 christos case LOGAND:
4073 1.14 christos break;
4074 1.1 cgd }
4075 1.370 rillig return true;
4076 1.370 rillig }
4077 1.370 rillig
4078 1.370 rillig /* ARGSUSED */
4079 1.370 rillig void
4080 1.370 rillig check_expr_misc(const tnode_t *tn, bool vctx, bool tctx,
4081 1.370 rillig bool eqwarn, bool fcall, bool rvdisc, bool szof)
4082 1.370 rillig {
4083 1.370 rillig tnode_t *ln, *rn;
4084 1.370 rillig const mod_t *mp;
4085 1.370 rillig op_t op;
4086 1.370 rillig
4087 1.370 rillig if (tn == NULL)
4088 1.370 rillig return;
4089 1.370 rillig
4090 1.370 rillig ln = tn->tn_left;
4091 1.370 rillig rn = tn->tn_right;
4092 1.370 rillig mp = &modtab[op = tn->tn_op];
4093 1.370 rillig
4094 1.370 rillig if (!check_expr_op(tn, op, ln,
4095 1.370 rillig szof, fcall, vctx, tctx, rvdisc, eqwarn))
4096 1.370 rillig return;
4097 1.1 cgd
4098 1.173 rillig bool cvctx = mp->m_left_value_context;
4099 1.173 rillig bool ctctx = mp->m_left_test_context;
4100 1.201 rillig bool eq = mp->m_warn_if_operand_eq &&
4101 1.201 rillig !ln->tn_parenthesized &&
4102 1.201 rillig rn != NULL && !rn->tn_parenthesized;
4103 1.173 rillig
4104 1.1 cgd /*
4105 1.1 cgd * values of operands of ':' are not used if the type of at least
4106 1.1 cgd * one of the operands (for gcc compatibility) is void
4107 1.1 cgd * XXX test/value context of QUEST should probably be used as
4108 1.1 cgd * context for both operands of COLON
4109 1.1 cgd */
4110 1.1 cgd if (op == COLON && tn->tn_type->t_tspec == VOID)
4111 1.154 rillig cvctx = ctctx = false;
4112 1.173 rillig bool discard = op == CVT && tn->tn_type->t_tspec == VOID;
4113 1.173 rillig check_expr_misc(ln, cvctx, ctctx, eq, op == CALL, discard, szof);
4114 1.1 cgd
4115 1.1 cgd switch (op) {
4116 1.1 cgd case PUSH:
4117 1.1 cgd if (rn != NULL)
4118 1.173 rillig check_expr_misc(rn, false, false, eq, false, false,
4119 1.173 rillig szof);
4120 1.1 cgd break;
4121 1.1 cgd case LOGAND:
4122 1.1 cgd case LOGOR:
4123 1.173 rillig check_expr_misc(rn, false, true, eq, false, false, szof);
4124 1.1 cgd break;
4125 1.1 cgd case COLON:
4126 1.173 rillig check_expr_misc(rn, cvctx, ctctx, eq, false, false, szof);
4127 1.19 mycroft break;
4128 1.19 mycroft case COMMA:
4129 1.173 rillig check_expr_misc(rn, vctx, tctx, eq, false, false, szof);
4130 1.1 cgd break;
4131 1.1 cgd default:
4132 1.1 cgd if (mp->m_binary)
4133 1.173 rillig check_expr_misc(rn, true, false, eq, false, false,
4134 1.173 rillig szof);
4135 1.1 cgd break;
4136 1.1 cgd }
4137 1.1 cgd }
4138 1.1 cgd
4139 1.1 cgd /*
4140 1.1 cgd * Checks the range of array indices, if possible.
4141 1.1 cgd * amper is set if only the address of the element is used. This
4142 1.106 rillig * means that the index is allowed to refer to the first element
4143 1.1 cgd * after the array.
4144 1.1 cgd */
4145 1.1 cgd static void
4146 1.154 rillig check_array_index(tnode_t *tn, bool amper)
4147 1.1 cgd {
4148 1.1 cgd int dim;
4149 1.1 cgd tnode_t *ln, *rn;
4150 1.1 cgd int elsz;
4151 1.25 thorpej int64_t con;
4152 1.1 cgd
4153 1.1 cgd ln = tn->tn_left;
4154 1.1 cgd rn = tn->tn_right;
4155 1.1 cgd
4156 1.1 cgd /* We can only check constant indices. */
4157 1.1 cgd if (rn->tn_op != CON)
4158 1.1 cgd return;
4159 1.1 cgd
4160 1.1 cgd /* Return if the left node does not stem from an array. */
4161 1.169 rillig if (ln->tn_op != ADDR)
4162 1.1 cgd return;
4163 1.1 cgd if (ln->tn_left->tn_op != STRING && ln->tn_left->tn_op != NAME)
4164 1.1 cgd return;
4165 1.1 cgd if (ln->tn_left->tn_type->t_tspec != ARRAY)
4166 1.1 cgd return;
4167 1.20 lukem
4168 1.1 cgd /*
4169 1.1 cgd * For incomplete array types, we can print a warning only if
4170 1.1 cgd * the index is negative.
4171 1.1 cgd */
4172 1.194 rillig if (is_incomplete(ln->tn_left->tn_type) && rn->tn_val->v_quad >= 0)
4173 1.1 cgd return;
4174 1.1 cgd
4175 1.1 cgd /* Get the size of one array element */
4176 1.1 cgd if ((elsz = length(ln->tn_type->t_subt, NULL)) == 0)
4177 1.1 cgd return;
4178 1.136 rillig elsz /= CHAR_SIZE;
4179 1.1 cgd
4180 1.1 cgd /* Change the unit of the index from bytes to element size. */
4181 1.144 rillig if (is_uinteger(rn->tn_type->t_tspec)) {
4182 1.25 thorpej con = (uint64_t)rn->tn_val->v_quad / elsz;
4183 1.1 cgd } else {
4184 1.1 cgd con = rn->tn_val->v_quad / elsz;
4185 1.1 cgd }
4186 1.1 cgd
4187 1.1 cgd dim = ln->tn_left->tn_type->t_dim + (amper ? 1 : 0);
4188 1.1 cgd
4189 1.144 rillig if (!is_uinteger(rn->tn_type->t_tspec) && con < 0) {
4190 1.1 cgd /* array subscript cannot be negative: %ld */
4191 1.1 cgd warning(167, (long)con);
4192 1.57 christos } else if (dim > 0 && (uint64_t)con >= (uint64_t)dim) {
4193 1.1 cgd /* array subscript cannot be > %d: %ld */
4194 1.1 cgd warning(168, dim - 1, (long)con);
4195 1.1 cgd }
4196 1.1 cgd }
4197 1.1 cgd
4198 1.359 rillig static bool
4199 1.359 rillig is_out_of_char_range(const tnode_t *tn)
4200 1.359 rillig {
4201 1.359 rillig return tn->tn_op == CON &&
4202 1.360 rillig !(0 <= tn->tn_val->v_quad &&
4203 1.360 rillig tn->tn_val->v_quad < 1 << (CHAR_SIZE - 1));
4204 1.359 rillig }
4205 1.359 rillig
4206 1.1 cgd /*
4207 1.17 mycroft * Check for ordered comparisons of unsigned values with 0.
4208 1.1 cgd */
4209 1.1 cgd static void
4210 1.100 rillig check_integer_comparison(op_t op, tnode_t *ln, tnode_t *rn)
4211 1.1 cgd {
4212 1.1 cgd tspec_t lt, rt;
4213 1.1 cgd
4214 1.1 cgd lt = ln->tn_type->t_tspec;
4215 1.1 cgd rt = rn->tn_type->t_tspec;
4216 1.1 cgd
4217 1.1 cgd if (ln->tn_op != CON && rn->tn_op != CON)
4218 1.1 cgd return;
4219 1.1 cgd
4220 1.144 rillig if (!is_integer(lt) || !is_integer(rt))
4221 1.1 cgd return;
4222 1.1 cgd
4223 1.359 rillig if ((hflag || pflag) && ((lt == CHAR && is_out_of_char_range(rn)) ||
4224 1.359 rillig (rt == CHAR && is_out_of_char_range(ln)))) {
4225 1.17 mycroft /* nonportable character comparison, op %s */
4226 1.261 rillig warning(230, op_name(op));
4227 1.1 cgd return;
4228 1.1 cgd }
4229 1.144 rillig if (is_uinteger(lt) && !is_uinteger(rt) &&
4230 1.1 cgd rn->tn_op == CON && rn->tn_val->v_quad <= 0) {
4231 1.1 cgd if (rn->tn_val->v_quad < 0) {
4232 1.17 mycroft /* comparison of %s with %s, op %s */
4233 1.115 rillig warning(162, type_name(ln->tn_type),
4234 1.261 rillig "negative constant", op_name(op));
4235 1.1 cgd } else if (op == LT || op == GE || (hflag && op == LE)) {
4236 1.17 mycroft /* comparison of %s with %s, op %s */
4237 1.261 rillig warning(162, type_name(ln->tn_type), "0", op_name(op));
4238 1.1 cgd }
4239 1.1 cgd return;
4240 1.1 cgd }
4241 1.144 rillig if (is_uinteger(rt) && !is_uinteger(lt) &&
4242 1.1 cgd ln->tn_op == CON && ln->tn_val->v_quad <= 0) {
4243 1.1 cgd if (ln->tn_val->v_quad < 0) {
4244 1.17 mycroft /* comparison of %s with %s, op %s */
4245 1.26 christos warning(162, "negative constant",
4246 1.261 rillig type_name(rn->tn_type), op_name(op));
4247 1.1 cgd } else if (op == GT || op == LE || (hflag && op == GE)) {
4248 1.17 mycroft /* comparison of %s with %s, op %s */
4249 1.261 rillig warning(162, "0", type_name(rn->tn_type), op_name(op));
4250 1.1 cgd }
4251 1.1 cgd return;
4252 1.1 cgd }
4253 1.1 cgd }
4254 1.1 cgd
4255 1.1 cgd /*
4256 1.218 rillig * Return whether the expression can be used for static initialization.
4257 1.1 cgd *
4258 1.218 rillig * Constant initialization expressions must be constant or an address
4259 1.1 cgd * of a static object with an optional offset. In the first case,
4260 1.1 cgd * the result is returned in *offsp. In the second case, the static
4261 1.1 cgd * object is returned in *symp and the offset in *offsp.
4262 1.1 cgd *
4263 1.169 rillig * The expression can consist of PLUS, MINUS, ADDR, NAME, STRING and
4264 1.1 cgd * CON. Type conversions are allowed if they do not change binary
4265 1.1 cgd * representation (including width).
4266 1.278 rillig *
4267 1.278 rillig * C99 6.6 "Constant expressions"
4268 1.278 rillig * C99 6.7.8p4 restricts initializers for static storage duration
4269 1.1 cgd */
4270 1.174 rillig bool
4271 1.253 rillig constant_addr(const tnode_t *tn, const sym_t **symp, ptrdiff_t *offsp)
4272 1.1 cgd {
4273 1.253 rillig const sym_t *sym;
4274 1.1 cgd ptrdiff_t offs1, offs2;
4275 1.1 cgd tspec_t t, ot;
4276 1.1 cgd
4277 1.1 cgd switch (tn->tn_op) {
4278 1.1 cgd case MINUS:
4279 1.28 christos if (tn->tn_right->tn_op == CVT)
4280 1.174 rillig return constant_addr(tn->tn_right, symp, offsp);
4281 1.28 christos else if (tn->tn_right->tn_op != CON)
4282 1.174 rillig return false;
4283 1.1 cgd /* FALLTHROUGH */
4284 1.1 cgd case PLUS:
4285 1.1 cgd offs1 = offs2 = 0;
4286 1.1 cgd if (tn->tn_left->tn_op == CON) {
4287 1.1 cgd offs1 = (ptrdiff_t)tn->tn_left->tn_val->v_quad;
4288 1.174 rillig if (!constant_addr(tn->tn_right, &sym, &offs2))
4289 1.174 rillig return false;
4290 1.1 cgd } else if (tn->tn_right->tn_op == CON) {
4291 1.1 cgd offs2 = (ptrdiff_t)tn->tn_right->tn_val->v_quad;
4292 1.1 cgd if (tn->tn_op == MINUS)
4293 1.1 cgd offs2 = -offs2;
4294 1.174 rillig if (!constant_addr(tn->tn_left, &sym, &offs1))
4295 1.174 rillig return false;
4296 1.1 cgd } else {
4297 1.174 rillig return false;
4298 1.1 cgd }
4299 1.1 cgd *symp = sym;
4300 1.1 cgd *offsp = offs1 + offs2;
4301 1.215 rillig return true;
4302 1.169 rillig case ADDR:
4303 1.1 cgd if (tn->tn_left->tn_op == NAME) {
4304 1.1 cgd *symp = tn->tn_left->tn_sym;
4305 1.1 cgd *offsp = 0;
4306 1.215 rillig return true;
4307 1.215 rillig } else {
4308 1.1 cgd /*
4309 1.1 cgd * If this would be the front end of a compiler we
4310 1.215 rillig * would return a label instead of 0, at least if
4311 1.215 rillig * 'tn->tn_left->tn_op == STRING'.
4312 1.1 cgd */
4313 1.215 rillig *symp = NULL;
4314 1.1 cgd *offsp = 0;
4315 1.215 rillig return true;
4316 1.1 cgd }
4317 1.1 cgd case CVT:
4318 1.1 cgd t = tn->tn_type->t_tspec;
4319 1.1 cgd ot = tn->tn_left->tn_type->t_tspec;
4320 1.144 rillig if ((!is_integer(t) && t != PTR) ||
4321 1.144 rillig (!is_integer(ot) && ot != PTR)) {
4322 1.174 rillig return false;
4323 1.90 rillig }
4324 1.27 christos #ifdef notdef
4325 1.89 rillig /*
4326 1.27 christos * consider:
4327 1.97 rillig * struct foo {
4328 1.97 rillig * unsigned char a;
4329 1.97 rillig * } f = {
4330 1.353 rillig * (unsigned char)(unsigned long)
4331 1.353 rillig * (&(((struct foo *)0)->a))
4332 1.27 christos * };
4333 1.353 rillig * since psize(unsigned long) != psize(unsigned char),
4334 1.353 rillig * this fails.
4335 1.27 christos */
4336 1.27 christos else if (psize(t) != psize(ot))
4337 1.95 rillig return -1;
4338 1.27 christos #endif
4339 1.215 rillig return constant_addr(tn->tn_left, symp, offsp);
4340 1.1 cgd default:
4341 1.174 rillig return false;
4342 1.1 cgd }
4343 1.1 cgd }
4344 1.1 cgd
4345 1.351 rillig /* Append s2 to s1, then free s2. */
4346 1.1 cgd strg_t *
4347 1.351 rillig cat_strings(strg_t *s1, strg_t *s2)
4348 1.1 cgd {
4349 1.351 rillig size_t len1, len2, sz;
4350 1.1 cgd
4351 1.351 rillig if (s1->st_tspec != s2->st_tspec) {
4352 1.1 cgd /* cannot concatenate wide and regular string literals */
4353 1.1 cgd error(292);
4354 1.351 rillig return s1;
4355 1.1 cgd }
4356 1.1 cgd
4357 1.351 rillig len1 = s1->st_len;
4358 1.351 rillig len2 = s2->st_len;
4359 1.66 christos
4360 1.351 rillig if (s1->st_tspec == CHAR) {
4361 1.351 rillig sz = sizeof(*s1->st_cp);
4362 1.351 rillig s1->st_cp = xrealloc(s1->st_cp, (len1 + len2 + 1) * sz);
4363 1.351 rillig memcpy(s1->st_cp + len1, s2->st_cp, (len2 + 1) * sz);
4364 1.351 rillig free(s2->st_cp);
4365 1.351 rillig } else {
4366 1.351 rillig sz = sizeof(*s1->st_wcp);
4367 1.351 rillig s1->st_wcp = xrealloc(s1->st_wcp, (len1 + len2 + 1) * sz);
4368 1.351 rillig memcpy(s1->st_wcp + len1, s2->st_wcp, (len2 + 1) * sz);
4369 1.351 rillig free(s2->st_wcp);
4370 1.351 rillig }
4371 1.66 christos
4372 1.351 rillig s1->st_len = len1 + len2;
4373 1.351 rillig free(s2);
4374 1.1 cgd
4375 1.351 rillig return s1;
4376 1.1 cgd }
4377 1.1 cgd
4378 1.134 rillig static bool
4379 1.134 rillig is_confusing_precedence(op_t op, op_t lop, bool lparen, op_t rop, bool rparen)
4380 1.134 rillig {
4381 1.134 rillig
4382 1.134 rillig if (op == SHL || op == SHR) {
4383 1.145 rillig if (!lparen && (lop == PLUS || lop == MINUS))
4384 1.134 rillig return true;
4385 1.145 rillig if (!rparen && (rop == PLUS || rop == MINUS))
4386 1.134 rillig return true;
4387 1.134 rillig return false;
4388 1.134 rillig }
4389 1.134 rillig
4390 1.134 rillig if (op == LOGOR) {
4391 1.145 rillig if (!lparen && lop == LOGAND)
4392 1.134 rillig return true;
4393 1.145 rillig if (!rparen && rop == LOGAND)
4394 1.134 rillig return true;
4395 1.134 rillig return false;
4396 1.134 rillig }
4397 1.134 rillig
4398 1.171 rillig lint_assert(op == BITAND || op == BITXOR || op == BITOR);
4399 1.134 rillig if (!lparen && lop != op) {
4400 1.145 rillig if (lop == PLUS || lop == MINUS)
4401 1.134 rillig return true;
4402 1.171 rillig if (lop == BITAND || lop == BITXOR)
4403 1.134 rillig return true;
4404 1.134 rillig }
4405 1.134 rillig if (!rparen && rop != op) {
4406 1.145 rillig if (rop == PLUS || rop == MINUS)
4407 1.134 rillig return true;
4408 1.171 rillig if (rop == BITAND || rop == BITXOR)
4409 1.134 rillig return true;
4410 1.134 rillig }
4411 1.134 rillig return false;
4412 1.134 rillig }
4413 1.134 rillig
4414 1.1 cgd /*
4415 1.1 cgd * Print a warning if the given node has operands which should be
4416 1.1 cgd * parenthesized.
4417 1.1 cgd *
4418 1.1 cgd * XXX Does not work if an operand is a constant expression. Constant
4419 1.1 cgd * expressions are already folded.
4420 1.1 cgd */
4421 1.1 cgd static void
4422 1.100 rillig check_precedence_confusion(tnode_t *tn)
4423 1.1 cgd {
4424 1.135 rillig tnode_t *ln, *rn;
4425 1.1 cgd
4426 1.1 cgd if (!hflag)
4427 1.1 cgd return;
4428 1.1 cgd
4429 1.326 rillig debug_node(tn);
4430 1.1 cgd
4431 1.346 rillig lint_assert(is_binary(tn));
4432 1.1 cgd for (ln = tn->tn_left; ln->tn_op == CVT; ln = ln->tn_left)
4433 1.135 rillig continue;
4434 1.133 rillig for (rn = tn->tn_right; rn->tn_op == CVT; rn = rn->tn_left)
4435 1.135 rillig continue;
4436 1.1 cgd
4437 1.135 rillig if (is_confusing_precedence(tn->tn_op,
4438 1.135 rillig ln->tn_op, ln->tn_parenthesized,
4439 1.135 rillig rn->tn_op, rn->tn_parenthesized)) {
4440 1.1 cgd /* precedence confusion possible: parenthesize! */
4441 1.1 cgd warning(169);
4442 1.1 cgd }
4443 1.1 cgd }
4444