应用程序调试技术

前言                  
 结论                  
 第l部分   调试概论                  
 第1章   错误：问题出在那里, 如何解决                  
   1. l   错误及其调试                  
   1. 1. l   什么是错误                  
   1. 1. 2   进程错误及其解决方案                  
   1. 1. 3   制定调试计划                  
   1. 2   调试的先决条件                  
   1. 2. l   技能组合                  
   l. 2. 2   学习技能组合                  
   1. 3   调试过程                  
   1. 3. l   第1步：复制错误                  
   1. 3. 2   第2步：描述错误                  
   1. 3. 3   第3步：始终假定错误是你自己的问题                  
   1. 3. 4   第4步：分解并解决错误                  
   1. 3. 5   第5步：进行有创见的思考                  
   1. 3. 6   第6步：杠杆工具                  
   1. 3. 7   第7步：开始繁重的调试工作                  
   1. 3. 8   第8步：校验错误已被更正                  
   1. 3. 9   第9步：学习与交流                  
   1. 3. 10   调试过程的决定性秘诀                  
   1. 4   小结                  
 第2章   开始调试                  
   2. 1   跟踪变更直到项目结束                  
   2. 1. l   版本控制系统                  
   2. 1. 2   错误跟踪系统                  
   2. 1. 3   选择正确的系统                  
   2. 2   制定构建调试系统的进度表                  
   2. 2. l   用调试符来连编所有的构件                  
   2. 2. 2   警告与错误同等重要                  
   2. 2. 3   了解在何处装载DLL                  
   2. 2. 4   设计发布构件的轻便诊断系统                  
   2. 3   日常连编和冒烟测试是必须遵循的                  
   2. 3. l   日常构件                  
   2. 3. 2   冒烟测试                  
   2. 4   立即连编安装程序                  
   2. 5   QA必须对调试构件进行测试                  
   2. 6   小结                  
 第3章   边编码边调试                  
   3. 1   注意声明                  
   3. 1. l   如何声明, 声明什么                  
   3. l. 2   不同类型的Visual C＋十和Visual Basic声明                  
   3. l. 3   SUPERASSERT                  
   3. 2   跟踪. 跟踪. 跟踪. 再跟踪                  
   3. 3   注意注释                  
   3. 4   相信自己, 但要校验（单元测试）                  
   3. 5   小结                  
 第II部分   高效率的调试                  
 第4章   调试器的工作原理                  
   4. 1   Windows调试器的类型                  
   4. 1. 1   用户模式调试器                  
   4. 1. 2   内核模式调试器                  
   4. 2   Windows 2000操作系统为调试对象提供的支持                  
   4. 2. 1   Windows 2000堆阵检查                  
   4. 2. 2   在调试器中自动启动                  
   4. 2. 3   快速中断项                  
   4. 3   MinDBG：一个简单的Win32调试器                  
   4. 4   WDBG：真正的调试器                  
   4. 4. l   内存读写操作                  
   4. 4. 2   断点和单步执行                  
   4. 4. 3   符号表. 符号引擎和堆栈遍历                  
   4. 4. 4   Step Into. Step Over和Stap Out功能                  
   4. 4. 5   WDBG调试器的一个有趣的开发问题                  
   4. 5   如果需要编写自己的调试器                  
   4. 6   WDBG调试器之后是什么？                  
   4. 7   小结                  
 第5章   使用Visual　C＋十调试器进行强有力的调试                  
   5. 1   高级断点及其用法                  
   5. 1. l   高级断点语法和位置断点                  
   5. 1. 2   在任何函数上快速中断                  
   5. 1. 3   在系统或输出的函数中设置断点                  
   5. 1. 4   位置断点修饰符                  
   5. 1. 5   全局表达式和条件断点                  
   5. 1. 6   Windows消息断点                  
   5. 2   远程调试                  
   5. 3   技巧及窍门                  
   5. 3. 1   设置断点                  
   5. 3. 2   Watch窗口                  
   5. 4   小结                  
 第6章   使用x86汇编语言和Visual　C++调试器Disassembly窗口进行强有力的调试                  
   6. 1   CPU的基础知识                  
   6. 1. l   寄存器                  
   6. 1. 2   指令格式和内存编址                  
   6. 2   关于Visual C＋十内联汇编器                  
   6. 3   需要了解的指令                  
   6. 3. 1   堆栈处理                  
   6. 3. 2   最常用的几个简单指令                  
   6. 3. 3   常见的序列：函数入口和出口                  
   6. 3. 4   变量访问：全局变量. 参数和局部变量                  
   6. 3. 5   调用进程和返回指令                  
   6. 4   调用约定                  
   6. 5   需要了解的其他指令                  
   6. 5. l   数据处理                  
   6. 5. 2   指针处理                  
   6. 5. 3   比较和测试                  
   6. 5. 4   条约和分文指令                  
   6. 5. 5   循环                  
   6. 5. 6   字符串处理                  
   6. 6   常见的汇编语言结构                  
   6. 6. 1   FS寄存器访问                  
   6. 6. 2   结构和类引用                  
   6. 7   完整的例子                  
   6. 8   Disassembly窗口                  
   6. 8. 1   导航功能                  
   6. 8. 2   在堆栈上查看参数                  
   6. 8. 3   Set Next Statement命令                  
   6. 8. 4   Memory窗口和Disassembly窗口                  
   6. 9   技巧和诀窍                  
   6. 9. 1   Endians                  
   6. 9. 2   垃圾代码                  
   6. 9. 3   寄存器和Watch窗口                  
   6. 9. 4   从ASM文件中学习                  
   6. 10   小结                  
 第7章   使用Visual Basic调试器进行强有力的调试                  
   7. 1   Visual Basic P代码                  
   7. 1. l   关于P代码的历史教训                  
   7. 1. 2   使用P代码衍生出来的问题                  
   7. 2   错误陷阶：Break In或Break On选项                  
   7. 2. 1   Break On All Errors功能