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