xref: /src/usr.bin/xlint/lint1/func.c

/*	$NetBSD: func.c,v 1.42 2021/01/01 10:55:28 rillig Exp $	*/

/*
 * Copyright (c) 1994, 1995 Jochen Pohl
 * All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Jochen Pohl for
 *	The NetBSD Project.
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#if HAVE_NBTOOL_CONFIG_H
#include "nbtool_config.h"
#endif

#include <sys/cdefs.h>
#if defined(__RCSID) && !defined(lint)
__RCSID("$NetBSD: func.c,v 1.42 2021/01/01 10:55:28 rillig Exp $");
#endif

#include <stdlib.h>
#include <string.h>

#include "lint1.h"
#include "cgram.h"

/*
 * Contains a pointer to the symbol table entry of the current function
 * definition.
 */
sym_t	*funcsym;

/* Is set as long as a statement can be reached. Must be set at level 0. */
int	reached = 1;

/*
 * Is set as long as NOTREACHED is in effect.
 * Is reset everywhere where reached can become 0.
 */
int	rchflg;

/*
 * In conjunction with reached ontrols printing of "fallthrough on ..."
 * warnings.
 * Reset by each statement and set by FALLTHROUGH, switch (switch1())
 * and case (label()).
 *
 * Control statements if, for, while and switch do not reset ftflg because
 * this must be done by the controlled statement. At least for if this is
 * important because ** FALLTHROUGH ** after "if (expr) stmnt" is evaluated
 * before the following token, wich causes reduction of above.
 * This means that ** FALLTHROUGH ** after "if ..." would always be ignored.
 */
int	ftflg;

/* Top element of stack for control statements */
cstk_t	*cstk;

/*
 * Number of arguments which will be checked for usage in following
 * function definition. -1 stands for all arguments.
 *
 * The position of the last ARGSUSED comment is stored in argsused_pos.
 */
int	nargusg = -1;
pos_t	argsused_pos;

/*
 * Number of arguments of the following function definition whose types
 * shall be checked by lint2. -1 stands for all arguments.
 *
 * The position of the last VARARGS comment is stored in vapos.
 */
int	nvararg = -1;
pos_t	vapos;

/*
 * Both prflstr and scflstrg contain the number of the argument which
 * shall be used to check the types of remaining arguments (for PRINTFLIKE
 * and SCANFLIKE).
 *
 * printflike_pos and scanflike_pos are the positions of the last PRINTFLIKE
 * or SCANFLIKE comment.
 */
int	prflstrg = -1;
int	scflstrg = -1;
pos_t	printflike_pos;
pos_t	scanflike_pos;

/*
 * If both plibflg and llibflg are set, prototypes are written as function
 * definitions to the output file.
 */
int	plibflg;

/*
 * Nonzero means that no warnings about constants in conditional
 * context are printed.
 */
int	constcond_flag;

/*
 * llibflg is set if a lint library shall be created. The effect of
 * llibflg is that all defined symbols are treated as used.
 * (The LINTLIBRARY comment also resets vflag.)
 */
int	llibflg;

/*
 * Nonzero if warnings are suppressed by a LINTED directive
 * LWARN_BAD:	error
 * LWARN_ALL:	warnings on
 * LWARN_NONE:	all warnings ignored
 * 0..n: warning n ignored
 */
int	lwarn = LWARN_ALL;

/*
 * Nonzero if bitfield type errors are suppressed by a BITFIELDTYPE
 * directive.
 */
int	bitfieldtype_ok;

/*
 * Nonzero if complaints about use of "long long" are suppressed in
 * the next statement or declaration.
 */
int	quadflg;

/*
 * Puts a new element at the top of the stack used for control statements.
 */
void
pushctrl(int env)
{
	cstk_t	*ci;

	ci = xcalloc(1, sizeof (cstk_t));
	ci->c_env = env;
	ci->c_next = cstk;
	cstk = ci;
}

/*
 * Removes the top element of the stack used for control statements.
 */
void
popctrl(int env)
{
	cstk_t	*ci;
	clst_t	*cl;

	lint_assert(cstk != NULL);
	lint_assert(cstk->c_env == env);

	cstk = (ci = cstk)->c_next;

	while ((cl = ci->c_clst) != NULL) {
		ci->c_clst = cl->cl_next;
		free(cl);
	}

	if (ci->c_swtype != NULL)
		free(ci->c_swtype);

	free(ci);
}

/*
 * Prints a warning if a statement cannot be reached.
 */
void
check_statement_reachable(void)
{
	if (!reached && !rchflg) {
		/* statement not reached */
		warning(193);
		reached = 1;
	}
}

/*
 * Called after a function declaration which introduces a function definition
 * and before an (optional) old style argument declaration list.
 *
 * Puts all symbols declared in the prototype or in an old style argument
 * list back to the symbol table.
 *
 * Does the usual checking of storage class, type (return value),
 * redeclaration, etc.
 */
void
funcdef(sym_t *fsym)
{
	int	n, dowarn;
	sym_t	*arg, *sym, *rdsym;

	funcsym = fsym;

	/*
	 * Put all symbols declared in the argument list back to the
	 * symbol table.
	 */
	for (sym = dcs->d_fpsyms; sym != NULL; sym = sym->s_dlnxt) {
		if (sym->s_blklev != -1) {
			lint_assert(sym->s_blklev == 1);
			inssym(1, sym);
		}
	}

	/*
	 * In old_style_function() we did not know whether it is an old
	 * style function definition or only an old style declaration,
	 * if there are no arguments inside the argument list ("f()").
	 */
	if (!fsym->s_type->t_proto && fsym->s_args == NULL)
		fsym->s_osdef = 1;

	check_type(fsym);

	/*
	 * check_type() checks for almost all possible errors, but not for
	 * incomplete return values (these are allowed in declarations)
	 */
	if (fsym->s_type->t_subt->t_tspec != VOID &&
	    incompl(fsym->s_type->t_subt)) {
		/* cannot return incomplete type */
		error(67);
	}

	fsym->s_def = DEF;

	if (fsym->s_scl == TYPEDEF) {
		fsym->s_scl = EXTERN;
		/* illegal storage class */
		error(8);
	}

	if (dcs->d_inline)
		fsym->s_inline = 1;

	/*
	 * Arguments in new style function declarations need a name.
	 * (void is already removed from the list of arguments)
	 */
	n = 1;
	for (arg = fsym->s_type->t_args; arg != NULL; arg = arg->s_next) {
		if (arg->s_scl == ABSTRACT) {
			lint_assert(arg->s_name == unnamed);
			/* formal parameter lacks name: param #%d */
			error(59, n);
		} else {
			lint_assert(arg->s_name != unnamed);
		}
		n++;
	}

	/*
	 * We must also remember the position. s_def_pos is overwritten
	 * if this is an old style definition and we had already a
	 * prototype.
	 */
	dcs->d_fdpos = fsym->s_def_pos;

	if ((rdsym = dcs->d_rdcsym) != NULL) {

		if (!check_redeclaration(fsym, (dowarn = 0, &dowarn))) {

			/*
			 * Print nothing if the newly defined function
			 * is defined in old style. A better warning will
			 * be printed in check_func_lint_directives().
			 */
			if (dowarn && !fsym->s_osdef) {
				/* redeclaration of %s */
				(*(sflag ? error : warning))(27, fsym->s_name);
				print_previous_declaration(-1, rdsym);
			}

			/* copy usage information */
			copy_usage_info(fsym, rdsym);

			/*
			 * If the old symbol was a prototype and the new
			 * one is none, overtake the position of the
			 * declaration of the prototype.
			 */
			if (fsym->s_osdef && rdsym->s_type->t_proto)
				fsym->s_def_pos = rdsym->s_def_pos;

			/* complete the type */
			complete_type(fsym, rdsym);

			/* once a function is inline it remains inline */
			if (rdsym->s_inline)
				fsym->s_inline = 1;

		}

		/* remove the old symbol from the symbol table */
		rmsym(rdsym);

	}

	if (fsym->s_osdef && !fsym->s_type->t_proto) {
		if (sflag && hflag && strcmp(fsym->s_name, "main") != 0)
			/* function definition is not a prototype */
			warning(286);
	}

	if (dcs->d_notyp)
		/* return value is implicitly declared to be int */
		fsym->s_rimpl = 1;

	reached = 1;
}

/*
 * Called at the end of a function definition.
 */
void
funcend(void)
{
	sym_t	*arg;
	int	n;

	if (reached) {
		cstk->c_noretval = 1;
		if (funcsym->s_type->t_subt->t_tspec != VOID &&
		    !funcsym->s_rimpl) {
			/* func. %s falls off bottom without returning value */
			warning(217, funcsym->s_name);
		}
	}

	/*
	 * This warning is printed only if the return value was implicitly
	 * declared to be int. Otherwise the wrong return statement
	 * has already printed a warning.
	 */
	if (cstk->c_noretval && cstk->c_retval && funcsym->s_rimpl)
		/* function %s has return (e); and return; */
		warning(216, funcsym->s_name);

	/* Print warnings for unused arguments */
	arg = dcs->d_fargs;
	n = 0;
	while (arg != NULL && (nargusg == -1 || n < nargusg)) {
		check_usage_sym(dcs->d_asm, arg);
		arg = arg->s_next;
		n++;
	}
	nargusg = -1;

	/*
	 * write the information about the function definition to the
	 * output file
	 * inline functions explicitly declared extern are written as
	 * declarations only.
	 */
	if (dcs->d_scl == EXTERN && funcsym->s_inline) {
		outsym(funcsym, funcsym->s_scl, DECL);
	} else {
		outfdef(funcsym, &dcs->d_fdpos, cstk->c_retval,
			funcsym->s_osdef, dcs->d_fargs);
	}

	/*
	 * remove all symbols declared during argument declaration from
	 * the symbol table
	 */
	lint_assert(dcs->d_next == NULL);
	lint_assert(dcs->d_ctx == EXTERN);
	rmsyms(dcs->d_fpsyms);

	/* must be set on level 0 */
	reached = 1;
}

void
named_label(sym_t *sym)
{

	if (sym->s_set) {
		/* label %s redefined */
		error(194, sym->s_name);
	} else {
		mark_as_set(sym);
	}

	reached = 1;
}

void
case_label(tnode_t *tn)
{
	cstk_t	*ci;
	clst_t	*cl;
	val_t	*v;
	val_t	nv;
	tspec_t	t;

	/* find the stack entry for the innermost switch statement */
	for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_next)
		continue;

	if (ci == NULL) {
		/* case not in switch */
		error(195);
		tn = NULL;
	} else if (tn != NULL && tn->tn_op != CON) {
		/* non-constant case expression */
		error(197);
		tn = NULL;
	} else if (tn != NULL && !tspec_is_int(tn->tn_type->t_tspec)) {
		/* non-integral case expression */
		error(198);
		tn = NULL;
	}

	if (tn != NULL) {

		lint_assert(ci->c_swtype != NULL);

		if (reached && !ftflg) {
			if (hflag)
				/* fallthrough on case statement */
				warning(220);
		}

		t = tn->tn_type->t_tspec;
		if (t == LONG || t == ULONG ||
		    t == QUAD || t == UQUAD) {
			if (tflag)
				/* case label must be of type ... */
				warning(203);
		}

		/*
		 * get the value of the expression and convert it
		 * to the type of the switch expression
		 */
		v = constant(tn, 1);
		(void) memset(&nv, 0, sizeof nv);
		cvtcon(CASE, 0, ci->c_swtype, &nv, v);
		free(v);

		/* look if we had this value already */
		for (cl = ci->c_clst; cl != NULL; cl = cl->cl_next) {
			if (cl->cl_val.v_quad == nv.v_quad)
				break;
		}
		if (cl != NULL && tspec_is_uint(nv.v_tspec)) {
			/* duplicate case in switch: %lu */
			error(200, (u_long)nv.v_quad);
		} else if (cl != NULL) {
			/* duplicate case in switch: %ld */
			error(199, (long)nv.v_quad);
		} else {
			/*
			 * append the value to the list of
			 * case values
			 */
			cl = xcalloc(1, sizeof (clst_t));
			cl->cl_val = nv;
			cl->cl_next = ci->c_clst;
			ci->c_clst = cl;
		}
	}
	tfreeblk();

	reached = 1;
}

void
default_label(void)
{
	cstk_t	*ci;

	/* find the stack entry for the innermost switch statement */
	for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_next)
		continue;

	if (ci == NULL) {
		/* default outside switch */
		error(201);
	} else if (ci->c_default) {
		/* duplicate default in switch */
		error(202);
	} else {
		if (reached && !ftflg) {
			if (hflag)
				/* fallthrough on default statement */
				warning(284);
		}
		ci->c_default = 1;
	}

	reached = 1;
}

static tnode_t *
check_controlling_expression(tnode_t *tn)
{
	tspec_t t = tn->tn_type->t_tspec;

	if (tn != NULL)
		tn = cconv(tn);
	if (tn != NULL)
		tn = promote(NOOP, 0, tn);

	if (tn != NULL && !tspec_is_scalar(t)) {
		/* C99 6.5.15p4 for the ?: operator; see typeok:QUEST */
		/* C99 6.8.4.1p1 for if statements */
		/* C99 6.8.5p2 for while, do and for loops */
		/* controlling expressions must have scalar type */
		error(204);
		return NULL;
	}

	return tn;
}

/*
 * T_IF T_LPARN expr T_RPARN
 */
void
if1(tnode_t *tn)
{

	if (tn != NULL)
		tn = check_controlling_expression(tn);
	if (tn != NULL)
		expr(tn, 0, 1, 0);
	pushctrl(T_IF);
}

/*
 * if_without_else
 * if_without_else T_ELSE
 */
void
if2(void)
{

	cstk->c_rchif = reached ? 1 : 0;
	reached = 1;
}

/*
 * if_without_else
 * if_without_else T_ELSE stmnt
 */
void
if3(int els)
{

	if (els) {
		reached |= cstk->c_rchif;
	} else {
		reached = 1;
	}
	popctrl(T_IF);
}

/*
 * T_SWITCH T_LPARN expr T_RPARN
 */
void
switch1(tnode_t *tn)
{
	tspec_t	t;
	type_t	*tp;

	if (tn != NULL)
		tn = cconv(tn);
	if (tn != NULL)
		tn = promote(NOOP, 0, tn);
	if (tn != NULL && !tspec_is_int(tn->tn_type->t_tspec)) {
		/* switch expression must have integral type */
		error(205);
		tn = NULL;
	}
	if (tn != NULL && tflag) {
		t = tn->tn_type->t_tspec;
		if (t == LONG || t == ULONG || t == QUAD || t == UQUAD) {
			/* switch expr. must be of type `int' in trad. C */
			warning(271);
		}
	}

	/*
	 * Remember the type of the expression. Because it's possible
	 * that (*tp) is allocated on tree memory, the type must be
	 * duplicated. This is not too complicated because it is
	 * only an integer type.
	 */
	tp = xcalloc(1, sizeof (type_t));
	if (tn != NULL) {
		tp->t_tspec = tn->tn_type->t_tspec;
		if ((tp->t_isenum = tn->tn_type->t_isenum) != 0)
			tp->t_enum = tn->tn_type->t_enum;
	} else {
		tp->t_tspec = INT;
	}

	expr(tn, 1, 0, 1);

	pushctrl(T_SWITCH);
	cstk->c_switch = 1;
	cstk->c_swtype = tp;

	reached = rchflg = 0;
	ftflg = 1;
}

/*
 * switch_expr stmnt
 */
void
switch2(void)
{
	int	nenum = 0, nclab = 0;
	sym_t	*esym;
	clst_t	*cl;

	lint_assert(cstk->c_swtype != NULL);

	/*
	 * If the switch expression was of type enumeration, count the case
	 * labels and the number of enumerators. If both counts are not
	 * equal print a warning.
	 */
	if (cstk->c_swtype->t_isenum) {
		nenum = nclab = 0;
		lint_assert(cstk->c_swtype->t_enum != NULL);
		for (esym = cstk->c_swtype->t_enum->elem;
		     esym != NULL; esym = esym->s_next) {
			nenum++;
		}
		for (cl = cstk->c_clst; cl != NULL; cl = cl->cl_next)
			nclab++;
		if (hflag && eflag && nenum != nclab && !cstk->c_default) {
			/* enumeration value(s) not handled in switch */
			warning(206);
		}
	}

	if (cstk->c_break) {
		/*
		 * end of switch alway reached (c_break is only set if the
		 * break statement can be reached).
		 */
		reached = 1;
	} else if (!cstk->c_default &&
		   (!hflag || !cstk->c_swtype->t_isenum || nenum != nclab)) {
		/*
		 * there are possible values which are not handled in
		 * switch
		 */
		reached = 1;
	}	/*
		 * otherwise the end of the switch expression is reached
		 * if the end of the last statement inside it is reached.
		 */

	popctrl(T_SWITCH);
}

/*
 * T_WHILE T_LPARN expr T_RPARN
 */
void
while1(tnode_t *tn)
{

	if (!reached) {
		/* loop not entered at top */
		warning(207);
		reached = 1;
	}

	if (tn != NULL)
		tn = check_controlling_expression(tn);

	pushctrl(T_WHILE);
	cstk->c_loop = 1;
	if (tn != NULL && tn->tn_op == CON) {
		if (tspec_is_int(tn->tn_type->t_tspec)) {
			cstk->c_infinite = tn->tn_val->v_quad != 0;
		} else {
			cstk->c_infinite = tn->tn_val->v_ldbl != 0.0;
		}
	}

	expr(tn, 0, 1, 1);
}

/*
 * while_expr stmnt
 * while_expr error
 */
void
while2(void)
{

	/*
	 * The end of the loop can be reached if it is no endless loop
	 * or there was a break statement which was reached.
	 */
	reached = !cstk->c_infinite || cstk->c_break;
	rchflg = 0;

	popctrl(T_WHILE);
}

/*
 * T_DO
 */
void
do1(void)
{

	if (!reached) {
		/* loop not entered at top */
		warning(207);
		reached = 1;
	}

	pushctrl(T_DO);
	cstk->c_loop = 1;
}

/*
 * do stmnt do_while_expr
 * do error
 */
void
do2(tnode_t *tn)
{

	/*
	 * If there was a continue statement, the expression controlling the
	 * loop is reached.
	 */
	if (cstk->c_cont)
		reached = 1;

	if (tn != NULL)
		tn = check_controlling_expression(tn);

	if (tn != NULL && tn->tn_op == CON) {
		if (tspec_is_int(tn->tn_type->t_tspec)) {
			cstk->c_infinite = tn->tn_val->v_quad != 0;
		} else {
			cstk->c_infinite = tn->tn_val->v_ldbl != 0.0;
		}
		if (!cstk->c_infinite && cstk->c_cont)
		    error(323);
	}

	expr(tn, 0, 1, 1);

	/*
	 * The end of the loop is only reached if it is no endless loop
	 * or there was a break statement which could be reached.
	 */
	reached = !cstk->c_infinite || cstk->c_break;
	rchflg = 0;

	popctrl(T_DO);
}

/*
 * T_FOR T_LPARN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPARN
 */
void
for1(tnode_t *tn1, tnode_t *tn2, tnode_t *tn3)
{

	/*
	 * If there is no initialisation expression it is possible that
	 * it is intended not to enter the loop at top.
	 */
	if (tn1 != NULL && !reached) {
		/* loop not entered at top */
		warning(207);
		reached = 1;
	}

	pushctrl(T_FOR);
	cstk->c_loop = 1;

	/*
	 * Store the tree memory for the reinitialisation expression.
	 * Also remember this expression itself. We must check it at
	 * the end of the loop to get "used but not set" warnings correct.
	 */
	cstk->c_fexprm = tsave();
	cstk->c_f3expr = tn3;
	cstk->c_fpos = curr_pos;
	cstk->c_cfpos = csrc_pos;

	if (tn1 != NULL)
		expr(tn1, 0, 0, 1);

	if (tn2 != NULL)
		tn2 = check_controlling_expression(tn2);
	if (tn2 != NULL)
		expr(tn2, 0, 1, 1);

	if (tn2 == NULL) {
		cstk->c_infinite = 1;
	} else if (tn2->tn_op == CON) {
		if (tspec_is_int(tn2->tn_type->t_tspec)) {
			cstk->c_infinite = tn2->tn_val->v_quad != 0;
		} else {
			cstk->c_infinite = tn2->tn_val->v_ldbl != 0.0;
		}
	}

	/* Checking the reinitialisation expression is done in for2() */

	reached = 1;
}

/*
 * for_exprs stmnt
 * for_exprs error
 */
void
for2(void)
{
	pos_t	cpos, cspos;
	tnode_t	*tn3;

	if (cstk->c_cont)
		reached = 1;

	cpos = curr_pos;
	cspos = csrc_pos;

	/* Restore the tree memory for the reinitialisation expression */
	trestor(cstk->c_fexprm);
	tn3 = cstk->c_f3expr;
	curr_pos = cstk->c_fpos;
	csrc_pos = cstk->c_cfpos;

	/* simply "statement not reached" would be confusing */
	if (!reached && !rchflg) {
		/* end-of-loop code not reached */
		warning(223);
		reached = 1;
	}

	if (tn3 != NULL) {
		expr(tn3, 0, 0, 1);
	} else {
		tfreeblk();
	}

	curr_pos = cpos;
	csrc_pos = cspos;

	/* An endless loop without break will never terminate */
	reached = cstk->c_break || !cstk->c_infinite;
	rchflg = 0;

	popctrl(T_FOR);
}

/*
 * T_GOTO identifier T_SEMI
 * T_GOTO error T_SEMI
 */
void
dogoto(sym_t *lab)
{

	mark_as_used(lab, 0, 0);

	check_statement_reachable();

	reached = rchflg = 0;
}

/*
 * T_BREAK T_SEMI
 */
void
dobreak(void)
{
	cstk_t	*ci;

	ci = cstk;
	while (ci != NULL && !ci->c_loop && !ci->c_switch)
		ci = ci->c_next;

	if (ci == NULL) {
		/* break outside loop or switch */
		error(208);
	} else {
		if (reached)
			ci->c_break = 1;
	}

	if (bflag)
		check_statement_reachable();

	reached = rchflg = 0;
}

/*
 * T_CONTINUE T_SEMI
 */
void
docont(void)
{
	cstk_t	*ci;

	for (ci = cstk; ci != NULL && !ci->c_loop; ci = ci->c_next)
		continue;

	if (ci == NULL) {
		/* continue outside loop */
		error(209);
	} else {
		ci->c_cont = 1;
	}

	check_statement_reachable();

	reached = rchflg = 0;
}

/*
 * T_RETURN T_SEMI
 * T_RETURN expr T_SEMI
 */
void
doreturn(tnode_t *tn)
{
	tnode_t	*ln, *rn;
	cstk_t	*ci;
	op_t	op;

	for (ci = cstk; ci->c_next != NULL; ci = ci->c_next)
		continue;

	if (tn != NULL) {
		ci->c_retval = 1;
	} else {
		ci->c_noretval = 1;
	}

	if (tn != NULL && funcsym->s_type->t_subt->t_tspec == VOID) {
		/* void function %s cannot return value */
		error(213, funcsym->s_name);
		tfreeblk();
		tn = NULL;
	} else if (tn == NULL && funcsym->s_type->t_subt->t_tspec != VOID) {
		/*
		 * Assume that the function has a return value only if it
		 * is explicitly declared.
		 */
		if (!funcsym->s_rimpl)
			/* function %s expects to return value */
			warning(214, funcsym->s_name);
	}

	if (tn != NULL) {

		/* Create a temporary node for the left side */
		ln = tgetblk(sizeof (tnode_t));
		ln->tn_op = NAME;
		ln->tn_type = tduptyp(funcsym->s_type->t_subt);
		ln->tn_type->t_const = 0;
		ln->tn_lvalue = 1;
		ln->tn_sym = funcsym;		/* better than nothing */

		tn = build(RETURN, ln, tn);

		if (tn != NULL) {
			rn = tn->tn_right;
			while ((op = rn->tn_op) == CVT || op == PLUS)
				rn = rn->tn_left;
			if (rn->tn_op == AMPER && rn->tn_left->tn_op == NAME &&
			    rn->tn_left->tn_sym->s_scl == AUTO) {
				/* %s returns pointer to automatic object */
				warning(302, funcsym->s_name);
			}
		}

		expr(tn, 1, 0, 1);

	} else {

		check_statement_reachable();

	}

	reached = rchflg = 0;
}

/*
 * Do some cleanup after a global declaration or definition.
 * Especially remove information about unused lint comments.
 */
void
global_clean_up_decl(int silent)
{
	pos_t	cpos;

	cpos = curr_pos;

	if (nargusg != -1) {
		if (!silent) {
			curr_pos = argsused_pos;
			/* must precede function definition: ** %s ** */
			warning(282, "ARGSUSED");
		}
		nargusg = -1;
	}
	if (nvararg != -1) {
		if (!silent) {
			curr_pos = vapos;
			/* must precede function definition: ** %s ** */
			warning(282, "VARARGS");
		}
		nvararg = -1;
	}
	if (prflstrg != -1) {
		if (!silent) {
			curr_pos = printflike_pos;
			/* must precede function definition: ** %s ** */
			warning(282, "PRINTFLIKE");
		}
		prflstrg = -1;
	}
	if (scflstrg != -1) {
		if (!silent) {
			curr_pos = scanflike_pos;
			/* must precede function definition: ** %s ** */
			warning(282, "SCANFLIKE");
		}
		scflstrg = -1;
	}

	curr_pos = cpos;

	dcs->d_asm = 0;
}

/*
 * ARGSUSED comment
 *
 * Only the first n arguments of the following function are checked
 * for usage. A missing argument is taken to be 0.
 */
void
argsused(int n)
{

	if (n == -1)
		n = 0;

	if (dcs->d_ctx != EXTERN) {
		/* must be outside function: ** %s ** */
		warning(280, "ARGSUSED");
		return;
	}
	if (nargusg != -1) {
		/* duplicate use of ** %s ** */
		warning(281, "ARGSUSED");
	}
	nargusg = n;
	argsused_pos = curr_pos;
}

/*
 * VARARGS comment
 *
 * Causes lint2 to check only the first n arguments for compatibility
 * with the function definition. A missing argument is taken to be 0.
 */
void
varargs(int n)
{

	if (n == -1)
		n = 0;

	if (dcs->d_ctx != EXTERN) {
		/* must be outside function: ** %s ** */
		warning(280, "VARARGS");
		return;
	}
	if (nvararg != -1) {
		/* duplicate use of ** %s ** */
		warning(281, "VARARGS");
	}
	nvararg = n;
	vapos = curr_pos;
}

/*
 * PRINTFLIKE comment
 *
 * Check all arguments until the (n-1)-th as usual. The n-th argument is
 * used the check the types of remaining arguments.
 */
void
printflike(int n)
{

	if (n == -1)
		n = 0;

	if (dcs->d_ctx != EXTERN) {
		/* must be outside function: ** %s ** */
		warning(280, "PRINTFLIKE");
		return;
	}
	if (prflstrg != -1) {
		/* duplicate use of ** %s ** */
		warning(281, "PRINTFLIKE");
	}
	prflstrg = n;
	printflike_pos = curr_pos;
}

/*
 * SCANFLIKE comment
 *
 * Check all arguments until the (n-1)-th as usual. The n-th argument is
 * used the check the types of remaining arguments.
 */
void
scanflike(int n)
{

	if (n == -1)
		n = 0;

	if (dcs->d_ctx != EXTERN) {
		/* must be outside function: ** %s ** */
		warning(280, "SCANFLIKE");
		return;
	}
	if (scflstrg != -1) {
		/* duplicate use of ** %s ** */
		warning(281, "SCANFLIKE");
	}
	scflstrg = n;
	scanflike_pos = curr_pos;
}

/*
 * Set the linenumber for a CONSTCOND comment. At this and the following
 * line no warnings about constants in conditional contexts are printed.
 */
/* ARGSUSED */
void
constcond(int n)
{

	constcond_flag = 1;
}

/*
 * Suppress printing of "fallthrough on ..." warnings until next
 * statement.
 */
/* ARGSUSED */
void
fallthru(int n)
{

	ftflg = 1;
}

/*
 * Stop warnings about statements which cannot be reached. Also tells lint
 * that the following statements cannot be reached (e.g. after exit()).
 */
/* ARGSUSED */
void
notreach(int n)
{

	reached = 0;
	rchflg = 1;
}

/* ARGSUSED */
void
lintlib(int n)
{

	if (dcs->d_ctx != EXTERN) {
		/* must be outside function: ** %s ** */
		warning(280, "LINTLIBRARY");
		return;
	}
	llibflg = 1;
	vflag = 0;
}

/*
 * Suppress most warnings at the current and the following line.
 */
/* ARGSUSED */
void
linted(int n)
{

#ifdef DEBUG
	printf("%s, %d: lwarn = %d\n", curr_pos.p_file, curr_pos.p_line, n);
#endif
	lwarn = n;
}

/*
 * Suppress bitfield type errors on the current line.
 */
/* ARGSUSED */
void
bitfieldtype(int n)
{

#ifdef DEBUG
	printf("%s, %d: bitfieldtype_ok = 1\n", curr_pos.p_file,
	    curr_pos.p_line);
#endif
	bitfieldtype_ok = 1;
}

/*
 * PROTOLIB in conjunction with LINTLIBRARY can be used to handle
 * prototypes like function definitions. This is done if the argument
 * to PROTOLIB is nonzero. Otherwise prototypes are handled normally.
 */
void
protolib(int n)
{

	if (dcs->d_ctx != EXTERN) {
		/* must be outside function: ** %s ** */
		warning(280, "PROTOLIB");
		return;
	}
	plibflg = n == 0 ? 0 : 1;
}

/*
 * Set quadflg to nonzero which means that the next statement/declaration
 * may use "long long" without an error or warning.
 */
/* ARGSUSED */
void
longlong(int n)
{

	quadflg = 1;
}