Tagged articles
segmentation fault
13 articles · Page 1 of 1
This guide explains how to enable core dumps, preserve debug symbols, and use GDB to analyze C++ memory crashes like null pointer dereferences, heap overflows, and stack overflows, with practical code examples and step-by-step commands.
C++ debuggingStack Overflowcore dump
0 likes · 15 min read

This article explains what a Core Dump is, how Linux generates the ELF‑based snapshot when a program crashes, common causes such as memory errors or signal mishandling, essential system configurations, and step‑by‑step GDB techniques for analyzing and fixing the underlying bugs.
System Configurationcore dumpgdb
0 likes · 35 min read

This article provides a comprehensive guide to C++ debugging, covering the installation, core commands, and practical examples of GDB and Valgrind, along with advanced techniques, common pitfalls, and best‑practice recommendations to help developers efficiently locate and fix memory and segmentation errors.
C++DebuggingMemory Leaks
0 likes · 9 min read

This guide enumerates thirteen classic C segmentation fault patterns—including null pointer dereference, illegal memory access, stack overflow, buffer overrun, and misuse of dynamic memory—provides concise code examples for each, explains the underlying cause, and offers practical tips to prevent such crashes.
C++memory managementpointers
0 likes · 9 min read

This article walks through seventeen classic C programming mistakes that cause segmentation faults—such as null pointers, out‑of‑bounds array access, wild pointers, double frees, and format string bugs—and provides safe, production‑ready code examples to prevent each crash.
C++memory managementpointers
0 likes · 18 min read

This article traces the evolution of memory layout from early punched‑card computers through assembly‑level innovations, segment‑based designs, and virtual memory, then demonstrates a real 32‑bit Linux C++ program showing where globals, stack, heap, and mapped regions reside, and explains how this knowledge helps debug segmentation faults, stack overflows, and memory leaks.
BSSC++Memory Layout
0 likes · 13 min read

An amusing yet instructive narrative shows how a C program that crashes with a segmentation fault can appear to work after inserting a printf, explaining that uninitialized local variables contain leftover stack data and that debugging tools like GDB reveal the true cause.
c-programminggdbprintf
0 likes · 8 min read

A humorous tale reveals how an uninitialized stack variable caused a segmentation fault in C, how inserting a printf unintentionally altered memory to hide the bug, and why proper debugging with GDB is essential to understand such hidden issues.
C++Debuggingprintf side effect
0 likes · 9 min read

This article details the investigation and resolution of a MySQL 8.0.21 client segmentation fault on CentOS 8.4, covering missing ncurses libraries, implicit function declaration warnings, pointer truncation on 64‑bit systems, core‑file generation, gdb analysis, and the steps required to rebuild the client without crashes.
C++ClientDebugging
0 likes · 13 min read

This article investigates a Node.js V8 heap snapshot crash, tracing the segmentation fault to a faulty context extension slot, detailing the assembly analysis, reproducing the issue, and presenting a backported fix for Node‑v14.
DebuggingNode.jsV8
0 likes · 15 min read

This article presents a comprehensive analysis of real-world C/C++ core dump cases, categorizing common causes such as stack integrity, memory leaks, multithreading issues, and misuse of system libraries, and offers practical debugging strategies and code examples to help developers prevent and resolve such crashes.
Multithreadingcore dumpmemory issues
0 likes · 17 min read


ITPUBNov 4, 2016 · Fundamentals
This guide explains what core dumps are, how to enable their generation on Linux, where the core file is created, and step‑by‑step usage of GDB to pinpoint the exact location of a segmentation fault in C programs.
core dumpgdblinux debugging
0 likes · 4 min read


ITPUBAug 3, 2016 · Fundamentals
This article explains how Linux programs are loaded, the distinction between ELF sections and segments, virtual‑to‑physical address translation, the role of the MMU, brk/sbrk usage, address‑space layout, and practical steps to reproduce and avoid segmentation faults.
ELFLinuxMemory Layout
0 likes · 15 min read
