1 You Write Software; You have Bugs . . . . . . . . . 1
2 A Systematic Approach
to Debugging . . . . . . . 5
2.1 Why Follow a Structured Process? . . . . . . . 5
2.2 Making
the Most of Your Opportunities . . . . . . 5
2.3 13 Golden Rules . . . . . . . . . . . . . 7
2.3.1 Understand
the Requirements . . . . . . 8
2.3.2 Make it Fail . . . . . . . . . . . . 8
2.3.3 Simplify
the Test Case . . . . . . . . . 9
2.3.4 Read
the Right Error Message . . . . . . 9
2.3.5 Check
the Plug . . . . . . . . . 9
2.3.6 Separate Facts from Interpretation . . . . . 10
2.3.7 Divide and Conquer . . . . . . . . 10
2.3.8 Match
the Tool
to the Bug . . . . . . . . . 12
2.3.9 One Change at a Time . . . . . . . . . 12
2.3.10 Keep an Audit Trail . . . . . . . . 12
2.3.11 Get a Fresh View . . . . . . . . . . . 13
2.3.12 If You Didn’t Fix it, it Ain’t Fixed . . . . . 13
2.3.13 Cover your Bugfix with a Regression Test . . . . . 13
2.4 Build a Good
Toolkit . . . . . . . . . . . . 14
2.4.1 Your Workshop . . . . . . . . . 15
2.4.2 Running Tests Every Day Keeps
the Bugs at Bay . . 15
2.5 Know Your Enemy – Meet
the Bug Family . . . . . . 17
2.5.1
The Common Bug . . . . . . . . . . 17
2.5.2 Sporadic Bugs . . . . . . . . . . 18
2.5.3 Heisenbugs. . . . . . . . . . 18
2.5.4 Bugs Hiding Behind Bugs . . . . . . . . . 19
2.5.5 Secret Bugs –
Debugging and Confidentiality . . . . . 20
2.5.6 Fur
ther Reading . . . . . . . . . 21
3 Getting
to the Root – Source Code Debuggers . . . . . . 23
3.1 Visualizing Program Behavior . . . . . . . . 23
3.2 Prepare a Simple Predictable Example . . . . . . . 24
3.3 Get
the Debugger
to Run with Your Program . . . . . . . 24
3.4 Learn
to do a Stack Trace on a Program Crash . . . . . . 27
3.5 Learn
to Use Breakpoints . . . . . . . . . 28
3.6 Learn
to Navigate Through
the Program. . . . . . 28
3.7 Learn
to Inspect Data
: Variables and Expressions . . . . 29
3.8 A Debug Session on a Simple Example . . . . . . 30
4 Fixing Memory Problems . . . . . . . . . . . . 33
4.1 Memory Management in C/C++ – Powerful but Dangerous . . . . 33
4.1.1 Memory Leaks . . . . . . . . . 34
4.1.2 Incorrect Use of Memory Management . . . . 34
4.1.3 Buffer Overruns . . . . . . . . . . . 34
4.1.4 Uninitialized Memory Bugs . . . . . . . . 34
4.2 Memory Debuggers
to the Rescue . . . . . . . . 35
4.3 Example 1
: Detecting Memory Access Errors . . . . . . . 36
4.3.1 Detecting an Invalid Write Access . . . . . 36
4.3.2 Detecting Uninitialized Memory Reads . . . . 37
4.3.3 Detecting Memory Leaks . . . . . . . 38
4.4 Example 2
: Broken Calls
to Memory Allocation/Deallocation . . 38
4.5 Combining Memory and Source Code Debuggers . . . . . . 40
4.6 Cutting Down
the Noise – Suppressing Errors . . . . . . . 40
4.7 When
to Use a Memory Debugger . . . . . . . 41
4.8 Restrictions . . . . . . . . . . . . . . 42
4.8.1 Prepare Test Cases with Good Code Coverage . . . . 42
4.8.2 Provide Additional Computer Resources . . . . . . 42
4.8.3 Multi-Threading May Not be Supported . . . . . . 42
4.8.4 Support for Non-standard Memory Handlers . . . 42
5 Profiling Memory Use . . . . . . . . . . . . 45
5.1 Basic Strategy –
The First Steps . . . . . . . . . 45
5.2 Example 1
: Allocating Arrays . . . . . . . . 46
5.3 Step 1
: Look for Leaks . . . . . . . . . . . 46
5.4 Step 2
: Set Your Expectations . . . . . . . . 47
5.5 Step 3
: Measure Memory Consumption . . . . . . 47
5.5.1 Use Multiple Inputs . . . . . . . . 48
5.5.2 S
topping
the Program at Regular Intervals . . . . . 48
5.5.3 Measuring Memory Consumption with Simple
Tools . . 49
5.5.4 Use
top . . . . . . . . . . . . 49
5.5.5 Use
the Windows Task Manager . . . . . . . 50
5.5.6 Select Relevant Input Values for testmalloc . . . 51
5.5.7 Determine how Memory is Deallocated on Your Machine . 51
5.5.8 Use a Memory Profiler . . . . . . . . . 53
5.6 Step 4
: Identifying Greedy Data Structures . . . . . . 54
5.6.1 Instrumenting Data Structures . . . . . . 55
5.7 Putting it
Toge
ther –
The genindex Example. . . . . . 55
5.7.1 Check that
There are No Major Leaks . . . . . 56
5.7.2 Estimate
the Expected Memory Use . . . . . . . 56
5.7.3 Measure Memory Consumption . . . . . . . 57
5.7.4 Find
the Data Structures that Consume Memory . . . 57
6 Solving Performance Problems . . . . . . . . . . 63
6.1 Finding Performance Bugs – A Step-by-Step Approach . . . . . 63
6.1.1 Do an Upfront Analysis . . . . . . . . 64
6.1.2 Use a Simple Method of Measuring Time . . . . . 64
6.1.3 Create a Test Case . . . . . . . . . . 65
6.1.4 Make
the Test Case Reproducible . . . . . . 65
6.1.5 Check
the Program for Correctness . . . . . . . 66
6.1.6 Make
the Test Case Scalable . . . . . . . 66
6.1.7 Isolate
the Test Case from Side Effects . . . . 67
6.1.8 Measurement with time can have Errors and Variations . 68
6.1.9 Select a Test Case that Exposes
the Runtime Bottleneck . . 68
6.1.10
The Difference Between Algorithm and Implementation . . 70
6.2 Using Profiling
Tools . . . . . . . . . . . . 72
6.2.1 Do Not Write Your Own Profiler . . . . . . . 72
6.2.2 How Profilers Work . . . . . . . . 73
6.2.3 Familiarize Yourself with gprof . . . . . . 74
6.2.4 Familiarize Yourself with Quantify . . . . . 79
6.2.5 Familiarize Yourself with Callgrind . . . . . . . 81
6.2.6 Familiarize Yourself with VTune . . . . . . 82
6.3 Analyzing I/O Performance . . . . . . . . . . 84
6.3.1 Do a Sanity Check of Your Measurements . . . . . 85
7
Debugging Parallel Programs . . . . . . . . . 87
7.1 Writing Parallel Programs in C/C++ . . . . . . . . . 87
7.2
Debugging Race Conditions . . . . . . . . . . 88
7.2.1 Using Basic Debugger Capabilities
to Find Race
Conditions . . . . . . . . . . 89
7.2.2 Using Log Files
to Localize Race Conditions . . . . . 91
7.3
Debugging Deadlocks . . . . . . . . . . . . 93
7.3.1 How
to Determine What
the Current Thread is Executing . 94
7.3.2 Analyzing
the Threads of
the Program . . . . . 95
7.4 Familiarize Yourself with Threading Analysis
Tools . . . . . 96
7.5 Asynchronous Events and Interrupt Handlers . . . . . . . 98
8 Finding Environment and Compiler Problems . . . . . . 101
8.1 Environment Changes – Where Problems Begin . . . . . 101
8.1.1 Environment Variables . . . . . . . . . 101
8.1.2 Local Installation Dependencies . . . . . . . 102
8.1.3 Current Working Direc
tory Dependency . . . . . . 102
8.1.4 Process ID Dependency . . . . . . . . 102
8.2 How else
to See what a Program is Doing . . . . . . . 103
8.2.1 Viewing Processes with
top . . . . . . . 103
8.2.2 Finding Multiple Processes of an Application with ps . . . 103
8.2.3 Using /proc/<pid>
to Access a Process . . . . 104
8.2.4 Use strace
to Trace Calls
to the OS . . . . . 104
8.3 Compilers and Debuggers have Bugs
too . . . . . . . . 106
8.3.1 Compiler Bugs . . . . . . . . . 106
8.3.2 Debugger and Compiler Compatibility Problems . . 107
9 Dealing with Linking Problems . . . . . . . . . . 109
9.1 How a Linker Works . . . . . . . . . . 109
9.2 Building and Linking Objects . . . . . . . . 110
9.3 Resolving Undefined Symbols . . . . . . . . 111
9.3.1 Missing Linker Arguments . . . . . . . . 111
9.3.2 Searching for Missing Symbols . . . . . . . . 112
9.3.3 Linking Order Issues . . . . . . . . . . 113
9.3.4 C++ Symbols and Name Mangling . . . . . 114
9.3.5 Demangling of Symbols . . . . . . . . 115
9.3.6 Linking C and C++ Code . . . . . . . 115
9.4 Symbols with Multiple Definitions . . . . . . . 116
9.5 Symbol Clashes . . . . . . . . . . . 117
9.6 Identifying Compiler and Linker Version Mismatches . . . 118
9.6.1 Mismatching System Libraries . . . . . . . . 119
9.6.2 Mismatching Object Files . . . . . . . . . 119
9.6.3 Runtime Crashes . . . . . . . . . . . 120
9.6.4 Determining
the Compiler Version . . . . . 120
9.7 Solving Dynamic Linking Issues . . . . . . . . . 122
9.7.1 Linking or Loading DLLs . . . . . . . . . 122
9.7.2 DLL Not Found . . . . . . . . . 124
9.7.3 Analyzing Loader Issues . . . . . . . 125
9.7.4 Setting Breakpoints in DLLs . . . . . . . 126
9.7.5 Provide Error Messages for DLL Issues . . . . 127
10 Advanced
Debugging . . . . . . . . . . . . . 129
10.1 Setting Breakpoints in C++ Functions, Methods, and Opera
tors . 129
10.2 Setting Breakpoints in Templatized Functions and C++ Classes . 131
10.3 Stepping in C++ Methods . . . . . . . . . 133
10.3.1 Stepping in
to Implicit Functions . . . . . . . 134
10.3.2 Skipping Implicit Functions with
the Step-out Command . 135
10.3.3 Skipping Implicit Functions with a Temporary Breakpoint 136
10.3.4 Returning from Implicit Function Calls . . . . 136
10.4 Conditional Breakpoints and Breakpoint Commands . . . . 137
10.5
Debugging Static Construc
tor/Destruc
tor Problems . . . . . 140
10.5.1 Bugs Due
to Order-Dependence of Static Initializers . . 140
10.5.2 Recognizing
the Stack Trace of Static Initializers . . 141
10.5.3 Attaching
the Debugger Before Static Initialization . . . 142
10.6 Using Watchpoints . . . . . . . . . . . 143
10.7 Catching Signals . . . . . . . . . . . . . 144
10.8 Catching Exceptions . . . . . . . . . . 147
10.9 Reading Stack Traces . . . . . . . . . . . . 148
10.9.1 Stack Trace of Source Code Compiled with Debug Information . . . . . . . . 148
10.9.2 Stack Trace of Source Code Compiled Without Debug Information . . . . . . . . 149
10.9.3 Frames Without Any Debug Information . . . . . . 149
10.9.4 Real-Life Stack Traces . . . . . . . . . 150
10.9.5 Mangled Function Names . . . . . . . . . 151
10.9.6 Broken Stack Traces . . . . . . . . 151
10.9.7 Core Dumps . . . . . . . . . . . . 152
10.10 Manipulating a Running Program . . . . . . . . 153
10.10.1 Changing a Variable . . . . . . . . 156
10.10.2 Calling Functions . . . . . . . . . . 156
10.10.3 Changing
the Return Value of a Function . . . . . . 157
10.10.4 Aborting Function Calls . . . . . . . . 157
10.10.5 Skipping or Repeating Individual Statements . . . . . 158
10.10.6 Printing and Modifying Memory Content . . . . . 159
10.11
Debugging Without Debug Information . . . . . . 161
10.11.1 Reading Function Arguments From
the Stack . . . . . 163
10.11.2 Reading Local/Global Variables, User-Defined Data Types 165
10.11.3 Finding
the Approximate Statement in
the Source Code . . 165
10.11.4 Stepping Through Assembly Code . . . . . 166
11 Writing Debuggable Code . . . . . . . . . . . . 169
11.1 Why Comments Count . . . . . . . . . . . 169
11.1.1 Comments on Function Signatures . . . . . 170
11.1.2 Comments on Workarounds . . . . . . . . 171
11.1.3 Comments in Case of Doubt . . . . . . . 171
11.2 Adopting a Consistent Programming Style . . . . . . 171
11.2.1 Choose Names Carefully . . . . . . . 171
11.2.2 Avoid Insanely Clever Constructs . . . . . . 172
11.2.3 Spread Out Your Code . . . . . . . . . 172
11.2.4 Use Temporary Variables for Complex Expressions . . . 172
11.3 Avoiding Preprocessor Macros . . . . . . . . . . 173
11.3.1 Use Constants or Enums Instead of Macros . . . . 173
11.3.2 Use Functions Instead of Preprocessor Macros . . . . 175
11.3.3 Debug
the Preprocessor Output . . . . . . . . 176
11.3.4 Consider Using More Powerful Preprocessors . . . . 177
11.4 Providing Additional
Debugging Functions . . . . . . 179
11.4.1 Displaying User-Defined Data Types . . . . . . 179
11.4.2 Self-Checking Code . . . . . . . . 180
11.4.3 Debug Helpers for Opera
tors . . . . . . . 181
11.5 Prepare for Post-Processing . . . . . . . . . . 181
11.5.1 Generate Log Files . . . . . . . . . 181
12 How Static Checking Can Help . . . . . . . . . . 183
12.1 Using Compilers as
Debugging Tools . . . . . . . . 183
12.1.1 Do not Assume Warnings
to be Harmless . . . . . 184
12.1.2 Use Multiple Compilers
to Check
the Code . . . . 186
12.2 Using lint . . . . . . . . . . . . . . 186
12.3 Using Static Analysis
Tools . . . . . . . . . . 187
12.3.1 Familiarize Yourself with a Static Checker . . . . 187
12.3.2 Reduce Static Checker Errors
to (Almost) Zero . . . 189
12.3.3 Rerun All Test Cases After a Code Cleanup . . . 190
12.4 Beyond Static Analysis . . . . . . . . . . . 190
13 Summary . . . . . . . . . . . . . . 191
A Debugger Commands . . . . . . . . . . . . . 193
B Access
to Tools . . . . . . . . . . . . . 195
B.1 IDEs, Compilers, Build
Tools . . . . . . . . 195
B.1.1 Microsoft Visual Studio . . . . . . . . 195
B.1.2 Eclipse . . . . . . . . . . . . . 196
B.1.3 GCC . . . . . . . . . . . . 196
B.1.4 GNU Make . . . . . . . . . . . . 196
B.2 Debuggers . . . . . . . . . . . . 196
B.2.1 dbx . . . . . . . . . . . . . 196
B.2.2 DDD . . . . . . . . . . . . 197
B.2.3 GDB . . . . . . . . . . . . 197
B.2.4 ARM RealView . . . . . . . . . 197
B.2.5
TotalView Debugger . . . . . . . . 197
B.2.6 Lauterbach TRACE32 . . . . . . . . . 197
B.3 Environments . . . . . . . . . . . . . 198
B.3.1 Cygwin . . . . . . . . . . . . . 198
B.3.2 VMware . . . . . . . . . . . . 198
B.4 Memory Debuggers . . . . . . . . . . . 198
B.4.1 Purify . . . . . . . . . . . 198
B.4.2 Valgrind . . . . . . . . . . . . 199
B.4.3 KCachegrind . . . . . . . . . . . 199
B.4.4 Insure++ . . . . . . . . . . . . 199
B.4.5 BoundsChecker . . . . . . . . . 200
B.5 Profilers . . . . . . . . . . . . . . 200
B.5.1 gprof . . . . . . . . . . . . 200
B.5.2 Quantify . . . . . . . . . . . . 200
B.5.3 Intel VTune . . . . . . . . . . . . 200
B.5.4 AQtime . . . . . . . . . . . . . 201
B.5.5 mpatrol . . . . . . . . . . . . . 201
B.6 Static Checkers . . . . . . . . . . . 201
B.6.1 Coverity . . . . . . . . . . . . 201
B.6.2 Lint . . . . . . . . . . . . . 201
B.6.3 Splint . . . . . . . . . . . 202
B.6.4 /analyze option in Visual Studio Enterprise Versions . . 202
B.6.5 Klocwork . . . . . . . . . . . 202
B.6.6 Fortify . . . . . . . . . . . . . 202
B.6.7 PC-lint/FlexeLint . . . . . . . . . . 203
B.6.8 QA C++ . . . . . . . . . . . . 203
B.6.9 Codecheck . . . . . . . . . . 203
B.6.10 Axivion Bauhaus Suite . . . . . . . . . 203
B.6.11 C++ SoftBench CodeAdvisor . . . . . . 203
B.6.12 Parasoft C++test . . . . . . . . . . . 204
B.6.13 LDRA
tool suite . . . . . . . . . . . 204
B.6.14 Understand C++ . . . . . . . . . . . 204
B.7
Tools for Parallel Programming . . . . . . . . . . 204
B.7.1 Posix Threads . . . . . . . . . . 204
B.7.2 OpenMP . . . . . . . . . . . . 204
B.7.3 Intel TBB . . . . . . . . . . . 205
B.7.4 MPI . . . . . . . . . . . . . 205
B.7.5 MapReduce . . . . . . . . . . . . 205
B.7.6 Intel Threading Analysis
Tools . . . . . . . . 205
B.8 Miscellaneous
Tools . . . . . . . . . . 206
B.8.1 GNU Binutils . . . . . . . . . . . 206
B.8.2 m4 . . . . . . . . . . . . . . 206
B.8.3 ps . . . . . . . . . . . . . . 206
B.8.4 strace / truss . . . . . . . . . . 207
B.8.5
top. . . . . . . . . . . . . 207
B.8.6 VNC . . . . . . . . . . . . 207
B.8.7 WebEx . . . . . . . . . . . . . 207
C Source Code . . . . . . . . . . . . . . . 209
C.1 testmalloc.c . . . . . . . . . . . . . . 209
C.2 genindex.c . . . . . . . . . . . . 210
C.3 isort.c . . . . . . . . . . . . . 214
C.4 filebug.c . . . . . . . . . . . . . . 216
References . . . . . . . . . . . . . . 217
Index . . . . . . . . . . . . . . . . 219
本文探讨了使用Valgrind和Massif进行内存泄漏检测的方法，深入解析了strace在系统调用跟踪上的应用，以及如何利用purify进行内存错误检查，为软件开发者提供了一套全面的内存管理和调试策略。
扫一扫
2025
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
