[SUGGESTION] Add runtime checks for C++ integer division by zero

[nullicist-aakash]

I want to mention this before going ahead:

• I know that behavior of integer division is dependent on computer architectures and operating system.

As the title suggests, this suggestion is about adding runtime checks on integer division.

Since cpp2 is about safety, I think that defining the exact behavior of this operation will be a good thing to have. (In C++, as per standard, integer division by zero is undefined behavior).

I can think of two ways to "define" what will happen, in case there is integer division by zero at runtime:

• Throw an exception: This will be a breaking change because operations on built-in data types are not supposed to throw exceptions in C++ (I am unable to find this guarantee written on cppreference, but it was mentioned in Back to Basics: Exception Handling and Exception Safety, 43:49).
• call std::terminate(), which is consistent with "noexcept" guarantee of built-in data types.

Potential downfalls: This will obviously increase the runtime of program, if the integer division is performed extensively in the program.

The same reasoning is also applicable to integer overflows, but that is a different beast to handle. I am only considering the integer division for this suggestion.

[hsutter]

Thanks! While I worry about the performance cost of checking integer operations in general, if all we'd be doing is checking expressions of the form expr1 / expr2 and changing them to expr1 / CPP2_NOT_ZERO(expr2) (which does nothing if expr2 is not std::integral), that would be very much like the null dereference checking we already do, and would only affect / expressions. Is that what you had in mind?

[nullicist-aakash]

Yes, precisely. We should have additional check on numerator being std::integral too. If numerator is of user defined type, it will be something that we don't want to change.

[hsutter]

Thanks, done... I've added integer division-by-zero checks, which work similarly to the null-dereference and bounds checks, including their support for literals and that they're on by default but you can turn them off with a -no switch. The check happens only if the numerator and denominator are both integers. For example:

divide_42_by: (i) 42/i;

main: () = {
    std::cout << divide_42_by(24);  // ok
    std::cout << divide_42_by(0);   // caues div-by-0 in callee
}
//  On MSVC 2022, prints:
//      1demo.cpp2(2) auto __cdecl divide_42_by<int>(const int &): 
//      Type safety violation: integer division by zero attempt detected
//  On GCC 14, prints:
//      1demo.cpp2(2) auto divide_42_by(const auto:256&) [with 
//      auto:256 = int]: Type safety violation: integer division by 
//      zero attempt detected

[hsutter]

P.S.:

I can think of two ways to "define" what will happen, in case there is integer division by zero at runtime

The way we do it in Cpp2 is to use contracts, in this case if there's a violation it's a cpp2::type_safety violation. The default semantics are to terminate, but you can install a violation handler to make it do what you need (including to integrate into an existing logging/reporting framework you might have).