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