xref: /netbsd-src/usr.bin/xlint/lint1/ckbool.c (revision 0ec48ab17ef7e613e686a8abfb00b0bfbd08fbc2)

/* $NetBSD: ckbool.c,v 1.32 2024/05/12 12:32:39 rillig Exp $ */

/*-
 * Copyright (c) 2021 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Roland Illig <rillig@NetBSD.org>.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``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 FOUNDATION OR CONTRIBUTORS
 * 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)
__RCSID("$NetBSD: ckbool.c,v 1.32 2024/05/12 12:32:39 rillig Exp $");
#endif

#include <string.h>

#include "lint1.h"


/*
 * The option -T treats _Bool as incompatible with all other scalar types.
 * See d_c99_bool_strict.c for the detailed rules and for examples.
 */


static bool
is_int_constant_zero(const tnode_t *tn, tspec_t t)
{
	return t == INT && tn->tn_op == CON && tn->u.value.u.integer == 0;
}

static bool
is_typeok_strict_bool_binary(op_t op,
			     const tnode_t *ln, tspec_t lt,
			     const tnode_t *rn, tspec_t rt)
{
	if ((lt == BOOL) == (rt == BOOL))
		return true;

	if (op == FARG && rn->tn_sys)
		return false;

	if ((ln->tn_sys || rn->tn_sys) &&
	    (is_int_constant_zero(ln, lt) || is_int_constant_zero(rn, rt)))
		return true;

	if (op == ASSIGN || op == ANDASS || op == XORASS || op == ORASS ||
	    op == RETURN || op == INIT || op == FARG)
		return lt != BOOL && (ln->tn_sys || rn->tn_sys);

	if (op == EQ || op == NE ||
	    op == BITAND || op == BITXOR || op == BITOR ||
	    op == COLON)
		return false;

	return true;
}

/*
 * Some operators require that either both operands are bool or both are
 * scalar.
 *
 * Code that passes this check can be compiled in a pre-C99 environment that
 * doesn't implement the special rule C99 6.3.1.2, without silent change in
 * behavior.
 */
static bool
typeok_strict_bool_binary_compatible(op_t op, int arg,
				     const tnode_t *ln, tspec_t lt,
				     const tnode_t *rn, tspec_t rt)
{
	if (is_typeok_strict_bool_binary(op, ln, lt, rn, rt))
		return true;

	if (op == FARG)
		/* parameter %d expects '%s', gets passed '%s' */
		error(334, arg, tspec_name(lt), tspec_name(rt));
	else if (op == RETURN)
		/* function has return type '%s' but returns '%s' */
		error(211, tspec_name(lt), tspec_name(rt));
	else
		/* operands of '%s' have incompatible types '%s' and '%s' */
		error(107, op_name(op), tspec_name(lt), tspec_name(rt));

	return false;
}

/*
 * In strict bool mode, check whether the types of the operands match the
 * operator.
 */
bool
typeok_scalar_strict_bool(op_t op, const mod_t *mp, int arg,
			  const tnode_t *ln,
			  const tnode_t *rn)
{
	ln = before_conversion(ln);
	tspec_t lt = ln->tn_type->t_tspec;
	tspec_t rt = NO_TSPEC;
	if (rn != NULL) {
		rn = before_conversion(rn);
		rt = rn->tn_type->t_tspec;
	}

	if (rn != NULL &&
	    !typeok_strict_bool_binary_compatible(op, arg, ln, lt, rn, rt))
		return false;

	if (mp->m_compares_with_zero) {
		bool binary = mp->m_binary;
		bool lbool = is_typeok_bool_compares_with_zero(ln, false);
		bool ok = true;

		if (!binary && !lbool) {
			/* operand of '%s' must be bool, not '%s' */
			error(330, op_name(op), tspec_name(lt));
			ok = false;
		}
		if (binary && !lbool) {
			/* left operand of '%s' must be bool, not '%s' */
			error(331, op_name(op), tspec_name(lt));
			ok = false;
		}
		if (binary && op != QUEST &&
		    !is_typeok_bool_compares_with_zero(rn, false)) {
			/* right operand of '%s' must be bool, not '%s' */
			error(332, op_name(op), tspec_name(rt));
			ok = false;
		}
		return ok;
	}

	if (!mp->m_takes_bool) {
		bool binary = mp->m_binary;
		bool lbool = lt == BOOL;
		bool ok = true;

		if (!binary && lbool) {
			/* operand of '%s' must not be bool */
			error(335, op_name(op));
			ok = false;
		}
		if (binary && lbool) {
			/* left operand of '%s' must not be bool */
			error(336, op_name(op));
			ok = false;
		}
		if (binary && rt == BOOL) {
			/* right operand of '%s' must not be bool */
			error(337, op_name(op));
			ok = false;
		}
		return ok;
	}

	return true;
}

bool
is_typeok_bool_compares_with_zero(const tnode_t *tn, bool is_do_while)
{
	while (tn->tn_op == COMMA)
		tn = tn->u.ops.right;
	tn = before_conversion(tn);

	return tn->tn_type->t_tspec == BOOL
	    || tn->tn_op == BITAND
	    || (is_do_while && is_int_constant_zero(tn, tn->tn_type->t_tspec))
	    || (tn->tn_sys && is_scalar(tn->tn_type->t_tspec));
}

bool
fallback_symbol_strict_bool(sym_t *sym)
{
	if (strcmp(sym->s_name, "__lint_false") == 0) {
		sym->s_scl = BOOL_CONST;
		sym->s_type = gettyp(BOOL);
		sym->u.s_bool_constant = false;
		return true;
	}

	if (strcmp(sym->s_name, "__lint_true") == 0) {
		sym->s_scl = BOOL_CONST;
		sym->s_type = gettyp(BOOL);
		sym->u.s_bool_constant = true;
		return true;
	}

	return false;
}