AutosarC++18_10-A5.6.1¶
The right hand operand of the integer division or remainder operators shall not be equal to zero
Required inputs: IR, StaticSemanticAnalysis
| Level | required |
|---|---|
| Target | implementation |
| Enforcement | automated |
Rationale
The result is undefined if the right hand operand of the integer division or the remainder operator is zero.
Example
// $Id: A5-6-1.cpp 305629 2018-01-29 13:29:25Z piotr.serwa $
#include <cstdint>
#include <stdexcept>
std::int32_t Division1(std::int32_t a, std::int32_t b) noexcept
{
return (a / b); // Non-compliant - value of b could be zero
}
std::int32_t Division2(std::int32_t a, std::int32_t b)
{
if (b == 0)
{
throw std::runtime_error("Division by zero error");
}
return (a / b); // Compliant - value of b checked before division
}
double Fn()
{
std::int32_t x = 20 / 0; // Non-compliant - undefined behavior
x = Division1(20, 0); // Undefined behavior
x = Division2(20,
0); // Preconditions check will throw a runtime_error from
// division2() function
std::int32_t remainder = 20 % 0; // Non-compliant - undefined behavior
}
See Also
- HIC++ v4.0 [9]: 5.5.1 Ensure that the right hand operand of the division or remainder operators is demonstrably non-zero.
- C++ Core Guidelines [11]: ES.105: Don’t divide by zero.
Possible Messages
Key |
Text |
Severity |
Disabled |
|---|---|---|---|
division_by_zero |
Division by zero |
None |
False |
float_division_by_zero |
Floating point division by floating point zero |
None |
False |
modulo_by_zero |
Modulo by zero |
None |
False |
possible_division_by_zero |
Possible division by zero |
None |
False |
possible_float_division_by_zero |
Possible floating point division by zero |
None |
False |
possible_modulo_by_zero |
Possible modulo by zero |
None |
False |
Options¶
This rule shares the following common options: confidence, exclude_in_macros, exclude_messages_in_system_headers, excludes, extend_exclude_to_macro_invocations, includes, justification_checker, languages, post_processing, provider, report_at, severity
The following places define options that affect this rule: Stylechecks, Analysis-GlobalOptions
abstract_interpretation_div_by_zero¶
abstract_interpretation_div_by_zero : bool = False
abstract_interpretation_maximal_tracked_array_index¶
abstract_interpretation_maximal_tracked_array_index : int = 10
The number of explicit indices in array expressions per routine tracked by the "symbolic expression analysis". For example, consider the following program.
extern signed char a[6];
extern signed char x;
int main()
{
if (a[2] < 0)
{
x = x / a[2];
}
if (a[3] < 0)
{
x = x / a[3];
}
if (a[4] < 0)
{
x = x / a[4];
}
return 0;
}
If the value of this option is set to 2, the first two array index expressions
encountered in the routine are tracked. Hence, the analysis can use the facts
a[2] < 0 and a[3] < 0 to infer that the respective
divisions do not divide by zero, but it will not track the third array access in
this routine.
A higher value of the option can cause more consumption of memory and time for the analysis.
abstract_interpretation_overflow_unrolling_level¶
abstract_interpretation_overflow_unrolling_level : int = 0