Using `GDB` under `Emacs`
(or: how to be even more efficient with `Emacs`)

Today's plan is to walk-through how to compile programs under emacs, and also how to debug using gdb under emacs.

Setting up

If you decide to use emacs for coding, you can optionally put a configuration/preferences file in your home directory (call it ".emacs", and give it r+w permissions to the world). For the purposes of today's lab, please use a copy of my .emacs file.

As well, the program that we will be compiling & debugging can be downloaded from here.

Emacs Basics

Since not all of you have previous experience with emacs, we will briefly review the basics that you'll need to know. If you are already familiar with emacs, you can skip this section.

To start emacs, type "emacs" (after placing the .emacs file in your home directory)
There are two kind of special keys:
1. M-x : This stands for "meta" key. On some keyboards, there is an explicit key for this. On our keyboards (and most keyboards), this is simulated by pressing & releasing the ESC key, and then pressing & releasing the x key.
2. C-x : This stands for the "control" key. This just means pressing both the CTRL key and the x key at the same time. (similarly, C-c stands for the CTRL key and the c key at the same time).
At any time, if you press some keys by accident (and emacs is prompting you for information at the bottom of the screen), then you can abort/cancel by typing C-g (CTRL & g).
Working with files:
- To open a file: C-f
- To write a file: C-w
- To save a file: C-s (same as writing a file, but you don't choose a filename -- unless this is the first time that you are saving).
Editing commands:
- To insert text in your document, type into the emacs window. Pressing the "insert" key toggles the overwrite/insert mode (and is displayed at the bottom of the emacs window).
- To move the cursor around: use the arrow keys.
- To cut the remainder of the line: use C-k
- To paste (yank) a line from memory: use C-y
- To undo something: CTRL+SHIFT+_ (CTRL key and the SHIFT key and the underscore key). You can undo multiple changes.
To quit emacs: C-x C-c (CTRL & x followed by CTRL & c)

Well, I think that's enough to get started.

Compiling

The standard way to invoke the compiler is to type: "M-x compile". You then specify the compile command you want to use (in our case, type in "g++ -g prob.c -o prob". Thereafter, emacs remembers and reuses your compile command.

As a shortcut (and thanks to the .emacs file we copied at the beginning), you can just type C-c C-v.

Once you compile, the emacs window automatically divides into 2 separate windows. The top window is your source code, and the bottom window is your interface to the compiler. If you want to remove the bottom window, click on the top window and then enter "M-x 1"

With 2 separate windows, you can toggle control between the windows by typing "C-x o".

Ok, at this point to the following:

load the file "prob.c" (provided above) into an emacs window
compile via C-c C-v (or "M-x compile")
you should seem some problems on the bottom screen. Type "C-x o" to ensure the bottom screen is active. Highlight the error that interests you, and type either C-c C-c or [ENTER]. The top screen automatically scrolls to the offending line of code.
Repeat this until all of the compile errors are gone away
(there should be two. The first needs a replacement of "." by "->". The second is a missing semi-colon)

Once the program compiles successfully, we can advance to the next level: debugging.

Debugging

Do:

Start the debugger by clicking in the bottom window, and then type "M-x gdb"
emacs asks you for the exact debug command. Enter "gdb a.out" (or whatever the name of your executable is).
Start by executing "run". The program should find a segmentation fault. The top window should display the line of code that the debugger died on (indicated by an arrow on the left side). If you don't see an arrow, you probably forgot to compile with the -g flag.
At this point, the arrow should be pointing to the line of code that calls malloc. Hmm. Nothing unusual looking. How about we add a breakpoint, and try tracing through the code just before the error? In the bottom (gdb) window, type: break initializeArray. This adds a breakpoint at the start of the function. To confirm the breakpoint, in the gdb window, type: info breakpoints.
Execute run. The gdb program asks for confirmation, and then re-executes, this time stopping as soon as the initializeArray function is entered.
We want to monitor that changes that occur in the variable i. In the gdb window, enter: display i. To confirm that this was successful, we can type: info display.
Now let's step forward through a command. In the gdb window, press C-c C-s. You should see the arrow move to the for expression.
Keep hitting C-c C-s a few more times, until eventually you get stuck "in malloc.c". One way to get out of this is to set a breakpoint at some later point in the program, and then resume execution.
...Instead of using the break command to set a breakpoint (like we did above), we'll instead use an emacs shortcut. Inside the source code window, click on line 58 (this is the closing brace for the for loop). Enter C-x and then press the [space] key. This sets a breakpoint at that line. Again, to confirm this, you can use the gdb command "info breakpoints".
Resume the program execution, either by entering C-c C-r, or by typing cont (or continue) in the gdb window.
The program should stop at the 2nd breakpoint that we set (line 58). The value of the variable i is displayed as 0.
Resume the program execution again. This time, instead of the program stopping at our 2nd breakpoint again (like we would expect), it stops on the malloc line, indicating a segmentation fault. Hmm. That's funny. That line of code executed fine on the first iteration. What would cause it to die on the 2nd iteration?
After some hair-scratching, it suddenly hits me that the myArray structure is being referenced by the wrong syntax. It is a parameter being passed by reference, and references a list of pointers to structures. We need to replace all occurrences of *(myArray[i]) with (*myArray)[i].
After replacing 4 occurrences of the wrong code, we re-compile the program via C-c C-v. On a successful compile, re-run the gdb program by typing run. The program stops at the first breakpoint. Being reasonably confident that we solved the problem, we can remove the breakpoints by typing:
It works! Enter quit to terminate the gdb application. Click on the source code window, and enter C-x 1 (to remove the gdb window).

We can now continue with our coding..

References