Segmentation Fault (Core Dumped): What Does It Mean?

A segmentation fault (core dumped) is a common runtime error that occurs when a program attempts to access a memory location it is not permitted to use. It is particularly common in languages such as C and C++, where developers have direct control over memory through pointers, arrays, and dynamic allocation.

When this error occurs, the operating system terminates the program to prevent it from corrupting other memory. The message may appear in a terminal as:

Segmentation fault (core dumped)

The phrase “core dumped” means that the operating system may have created a core dump containing information about the program’s state when it crashed. This information can be useful for debugging.

What is a Segmentation Fault?

A segmentation fault, often abbreviated as segfault, happens when a program tries to access memory outside the boundaries or permissions assigned to it.

For example, dereferencing an invalid pointer can cause a segmentation fault:

#include 

int main() {

int *ptr = NULL;

printf("%d\n", *ptr);

return 0;

}

Here, ptr contains a null address. Attempting to read the value using *ptr causes the program to access an invalid memory location.

The operating system detects the invalid access and terminates the program.

What Does “Core Dumped” Mean?

A core dump is a file containing information about a process at the time it crashes. It can include details such as:

• Memory information
• CPU register values
• Stack information
• Program state
• Threads
• Variable and function information, when debugging symbols are available

For example:

Segmentation fault (core dumped)

does not necessarily mean that a core dump file is always available. Whether one is generated depends on the operating system configuration and settings such as the core dump size limit.

On Linux, you can check the current core dump limit with:

ulimit -c

A value of 0 generally means core dumps are disabled for the current shell.

You can enable core dumps for the current shell with:

ulimit -c unlimited

What Causes a Segmentation Fault?

There are several common causes of a segmentation fault.

#include 

int main() {

int *number = NULL;

*number = 100;

return 0;

}

if (number != NULL) {

*number = 100;

}

#include 

int main() {

int values[3] = {10, 20, 30};

printf("%d\n", values[10]);

return 0;

}

for (int i = 0; i < 3; i++) {

printf("%d\n", values[i]);

}

#include 

int main() {

int *value = malloc(sizeof(int));

*value = 42;

free(value);

*value = 100;

return 0;

}

free(value);

value = NULL;

void process() {

process();

}

int main() {

process();

return 0;

}

void process(int count) {

if (count <= 0) {

return;

}

process(count - 1);

}

int values[5] = {1, 2, 3, 4, 5};

int *ptr = values;

printf("%d\n", *(ptr + 10));

How Do You Fix “Segmentation Fault (Core Dumped)”?

The correct solution depends on what caused the invalid memory access. The first step is to identify the exact location where the program crashes.

gcc -g program.c -o program

For C++:

g++ -g program.cpp -o program

gdb ./program

run

backtrace

or:

bt

#0  process_data () at program.c:15

#1  main () at program.c:28

gcc -g -fsanitize=address program.c -o program

./program

int *data;

printf("%d\n", *data);

int value = 25;

int *data = &value;

printf("%d\n", *data);

#include 

#include 

int main() {

int *data = malloc(100 * sizeof(int));

if (data == NULL) {

fprintf(stderr, "Memory allocation failed\n");

return 1;

}

data[0] = 100;

free(data);

data = NULL;

return 0;

}

How Can You Debug a Core Dump?

If the operating system generates a core dump, you can inspect it using GDB.

For example:

gdb ./program core

Then use:

bt

to display the call stack.

You can inspect the current frame with:

frame 0

and examine variables with:

print variable_name

For example:

print ptr

You can also inspect source code around the current location:

list

This can help determine which pointer, array, or memory operation caused the crash.

How Is a Segmentation Fault Different From a Compilation Error?

A compilation error occurs while the source code is being compiled. A segmentation fault normally occurs while the compiled program is running.

For example, this produces a compilation error:

#include 

int main() {

printf("Hello"

return 0;

}

The syntax is incomplete, so the compiler reports an error.

By contrast, this program can compile successfully but crash at runtime:

#include 

int main() {

int *ptr = NULL;

printf("%d\n", *ptr);

return 0;

}

The difference is important because debugging approaches are different. Compilation errors require fixing source-code syntax or type problems, while segmentation faults generally require investigating runtime memory access.

Common Ways to Prevent Segmentation Faults

Developers can reduce the risk of segmentation faults by following good memory-management practices.

int *ptr = NULL;

if (index >= 0 && index < size) {

data[index] = value;

}

free(data);

data = NULL;

Quick Reference: Segmentation Fault Debugging