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