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