Analysis and Resolution of Floating Point Exception Core Dump: Debugging and Fixing Division by Zero Errors in C

Problem Background and Error Phenomenon

In C program development, floating point exception core dump is a common runtime error. This error typically occurs when a program executes illegal mathematical operations, such as division by zero or invalid floating-point calculations. When encountering such errors, the operating system terminates program execution and generates core dump files for subsequent debugging analysis.

Specific Case Analysis

Consider a spiral matrix filling program that takes two parameters: array size N and starting value L. The program begins from the center of a two-dimensional array and fills values in a counter-clockwise spiral pattern. If the current value is prime, it stores the value at the corresponding position; otherwise, it stores a special marker value.

The original code contained a critical flaw in the prime number detection function:

int Is_Prime(int Number){
  int i;
  for(i = 0; i < Number / 2; i++){
    if(Number % i != 0) return -1;
  }
  return Number;
}

This code starts the loop from i = 0. When executing Number % i, if i is 0, it triggers a division by zero exception, causing a floating point exception core dump.

Root Cause Analysis

Division by zero is considered an illegal operation in computer systems. In C language, integer division by zero raises the SIGFPE signal (floating point exception signal), even when all operands are integer types. This is because underlying hardware classifies all arithmetic exceptions as floating point exceptions.

In prime number detection algorithms, valid divisors should start from 2 because:

• All integers are divisible by 1, making i = 1 meaningless for detection
• i = 0 causes division by zero exception
• Only need to check up to sqrt(Number), though Number/2 is a conservative boundary

Solution Implementation

The repaired prime number detection function should start the loop from i = 2:

int Is_Prime(int Number){
  int i;
  
  if(Number < 2) return -1;  // Handle boundary cases
  
  for(i = 2; i <= Number / 2; i++){
    if(Number % i == 0) return -1;  // Found factor, not prime
  }
  
  return Number;  // Is prime
}

This fixed version resolves the division by zero issue while:

• Properly handling numbers less than 2 (none are prime)
• Using correct comparison operator == 0 to check divisibility
• Maintaining algorithm simplicity and correctness

Related Technical Extensions

Floating point exceptions are not limited to division by zero operations. In complex computing environments, such as the PyTorch deep learning framework mentioned in the reference article, floating point exceptions can be caused by various factors:

• Hardware instruction set compatibility issues (e.g., AVX instruction set)
• Mathematical library version conflicts
• GPU computing related CUDA library problems
• Memory access violations causing unexpected values

On Linux systems, specific causes of floating point exceptions can be located by checking system logs and using debugging tools like gdb.

Programming Best Practices

To avoid similar runtime errors, developers are advised to:

1. Input Validation: Check validity of all function parameters
2. Boundary Condition Handling: Pay special attention to loop starting values, division by zero possibilities, etc.
3. Defensive Programming: Add protective code where exceptions might occur
4. Test Coverage: Write comprehensive test cases including boundary value testing
5. Code Review: Focus on mathematical operations and loop control logic

Conclusion

Although floating point exception core dump errors manifest similarly, their root causes can vary significantly. In the case discussed in this paper, the problem originated from division by zero operations in the prime number detection function. By changing the loop starting value from 0 to 2 and adding appropriate boundary checks, this issue can be completely resolved. This detailed error analysis and repair process demonstrates the importance of high-quality software development practices.