Why integer division by zero doesn't crash the program compiled with gcc?

Question

Integer division by zero is undefined and should result floating point exception and this is what happens why I write the following code

 int j = 0 ;
 int x = 1 / j;

In this case the program just crashes with FPE, but if I won't use variable and will go with literal values like this int x = 1 / 0; the the program doesn't crash, but just assigns some random value to x ! I tried to detect if int x = 1 / 0; really causes a crash by adding custom SIGFPE handler, but as I thought it is never invoked during literal zero division, but it does when I store 0 in a variable first. So, it seems that the literal zero division never actually crashes the program( I mean the division itself never happens), so does the compiler(GCC in my case) performs any tricks(e.g. substituting 0 with random number) in this case? or I misunderstood something ?

Use float, integer division by zero is UB thus compiler is not obligated to raise any signal — tstanisl, Mar 28 '21 at 09:53
`1 / 0` might not be done at runtime but by the compiler. Its value is undefined. — Weather Vane, Mar 28 '21 at 10:08
@Weather Vane Thank you, I was also thinking about this, but then I run the same executable(without recompiling) and every time got different random values for `x`. So, if `x` is resolved at compile time then I guess the value should be the same for every run — Andre Liberty, Mar 28 '21 at 10:11
MS Visual C issues a **compiler** error: *divide or mod by zero*. — Weather Vane, Mar 28 '21 at 10:11
How is this undefined behaviour different from all other undefined behaviours? — n. m. could be an AI, Mar 28 '21 at 10:49

score 3 · Answer 1 · answered Mar 28 '21 at 10:10

Why integer division by zero doesn't crash the program compiled with gcc?

Well, I think the answer would be: because it can. It can crash. It can not crash.

or I misunderstood something ?

From C11 6.5.5p5 (emphasis mine :p) :

The result of the / operator is the quotient from the division of the first operand by the second; the result of the % operator is the remainder. In both operations, if the value of the second operand is zero, the behavior is undefined.

The behavior is not defined. It is not defined what should happen. It can "crash". It can not crash. It can spawn nasal demons. The program can do anything.

You should write only programs that you know how will they behave. If you want your program to "crash", call abort().

so does the compiler(GCC in my case) performs any tricks(e.g. substituting 0 with random number) in this case?

The only way to know is to inspect the generated assembly code. You could use https://godbolt.org/

Nice job on the citations. – David C. Rankin Mar 28 '21 at 10:17 — David C. Rankin, Mar 28 '21 at 10:17

score -2 · Answer 2 · answered Mar 28 '21 at 10:19

-2

Since the expression contains division by zero constant, gcc could handle the issue at compile time.

If the division by variable valued 0, the compiler will give the responsibility to the exception handler because the evaluation is unpredictable.

answered Mar 28 '21 at 10:19

Drink Wine

1
1

Why integer division by zero doesn't crash the program compiled with gcc?

2 Answers2