LANG.TYPE.OWID : Expression Value Widened by Other Operand

JavaScript is not currently enabled, but is required for full CodeSonar manual search and browse functionality.

If you are viewing this file in your hub's Web GUI, enable JavaScript in your browser: you will also need it for GUI functionality.

If you opened this file directly from disk, your browser may be directly suppressing JavaScript functionality: certain browsers perform this suppression on local files (but not files delivered by web servers) for security reasons.

If you access the manual through the hub's Web GUI, the functionality will not be suppressed because the hub is a web server.
Alternatively, your browser may allow you to explicitly disable the security setting that suppresses functionality. See the CodeSonar FAQ for more information.

CodeSonar^® 9.2p0

CONFIDENTIAL

CodeSecure Inc

C and C++

LANG.TYPE.OWID : Expression Value Widened by Other Operand

Summary

For an operator that performs the 'usual arithmetic conversions' (as described in the C90 and C99 standards):

one operand is a composite expression, and
the other operand has wider essential type.

This check applies to

all binary operators except for {<<, <<=, >>=, >>, &&, ||, <comma>}
the ternary ?: operator (second and third operands)

This warning class is based on the notions of essential type category and composite expression as described in MISRA C:2012 Guidelines for the use of the C language in critical systems.

Properties

Class Name

Expression Value Widened by Other Operand

Significance

style

Mnemonic

LANG.TYPE.OWID

Categories

MisraC2025	MisraC2025:10.7	If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type
MisraC2023	MisraC2023:10.7	If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type
Misra2012	Misra2012:10.7	If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type
Misra2004	Misra2004:10.1	The value of an expression of integer type shall not be implicitly converted to a different underlying type if: (a) it is not a conversion to a wider integer type of the same signedness, or (b) the expression is complex, or (c) the expression is not constant and is a function argument, or (d) the expression is not constant and is a return expression
	Misra2004:10.2	The value of an expression of floating type shall not be implicitly converted to a different type if: (a) it is not a conversion to a wider floating type, or (b) the expression is complex, or (c) the expression is a function argument, or (d) the expression is a return expression
AUTOSARC++14	AUTOSARC++14:M5-0-3	A cvalue expression shall not be implicitly converted to a different underlying type.
	AUTOSARC++14:M5-0-5	There shall be no implicit floating-integral conversions.
MisraC++2008	MisraC++2008:5-0-3	A cvalue expression shall not be implicitly converted to a different underlying type.
	MisraC++2008:5-0-5	There shall be no implicit floating-integral conversions.
CWE	CWE:704	Incorrect Type Conversion or Cast
CERT-C	CERT-C:INT18-C	Evaluate integer expressions in a larger size before comparing or assigning to that size

Availability

Available for C and C++.

Enabling

Checks for this warning class are disabled by default, and require the unnormalized C ASTs for the project. To enable them, add the following WARNING_FILTER rule and RETAIN_UNNORMALIZED_C_AST specification to the project configuration file.

RETAIN_UNNORMALIZED_C_AST = Yes
WARNING_FILTER += allow class="Expression Value Widened by Other Operand"

Note that retaining the unnormalized ASTs will increase the disk space used to store the project representation, and may make the analysis take longer.

Example

void use_longs(long long1, long long2, long long3);

void TYPE_OWID(short sa, long la){
    long l1;
    long l2;
    long l3;

    l1 = sa + la;                             /* neither operand is a composite expression */

    l2 = (2*sa) / la; /* 'Expression Value Widened by Other Operand' warning issued here */

    l3 = (2*la) / sa;                         /* type of sa is not wider than  type of (2*la) */

    use_longs(l1, l2, l3);
}

Relevant Configuration File Parameters

The following configuration file parameters affect checks for this warning class.

To report problems with this documentation, please visit https://support.codesecure.com/.