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