Using `fix` and `continue`

10

Using fix allows you to quickly recompile edited source code without stopping the debugging process.

This chapter is organized into the following sections:

Basic Concepts

page 143

Fixing Your Program

page 145

Continuing after Fixing

page 145

Changing Variables after Fixing

page 147

Command Reference

page 148

Basic Concepts	page 143
Fixing Your Program	page 145
Continuing after Fixing	page 145
Changing Variables after Fixing	page 147
Command Reference	page 148

Basic Concepts

The fix and continue feature allows you to modify and recompile a source file and continue executing without rebuilding the entire program. By updating the .o files and splicing them into your program, you don't need to relink.

The advantages of using fix and continue are:

You do not have to relink the program.
You do not have to reload the program for debugging.
You can resume running the program from the fix location.

Note - Do not use fix if a build is in process; the output from the two processes will intermingle in the Building window.

Fixing Your Program

To fix your file:

: 1. Save the changes to your source.

WorkShop automatically saves your changes if you forget this step.

: 2. Type fix at the dbx prompt.

Although you can do an unlimited number of fixes, if you have done several fixes in a row, consider rebuilding your program. fix changes the program image in memory, but not on the disk. As you do more fixes, the memory image gets out of sync with what is on the disk.

fix does not make the changes within your executable file, but only changes the .o files and the memory image. Once you have finished debugging a program, you need to rebuild your program to merge the changes into the executable. When you quit debugging, a message reminds you to rebuild your program.

Continuing after Fixing

You can continue executing using continue.

Before resuming program execution, you should be aware of the following conditions:

Changing an executed function

If you made changes in a function that has already executed, the changes have no effect until:

You run the program again.
That function is called the next time.

If your modifications involve more than simple changes to variables, use fix then run. Using run is faster because it does not relink the program.

Changing a function not yet called

If you made changes in a function not yet called, the changes will be in effect when that function is called.

Changing a function currently being executed

If you made changes to the function currently being executed, fix's impact depends on where the change is relative to the stopped in function:

If the change is in already executed code, the code is not re-executed. Execute the code by popping the current function off the stack and continuing from where the changed function is called. You need to know your code well enough to figure out whether the function has side effects that can't be undone (for example, opening a file).
If the change is in code yet to be executed, the new code is run.

Changing a function presently on the stack

If you made changes to a function presently on the stack, but not the stopped in function, the changed code will not be used for the present call of that function. When the stopped in function returns, the old versions of the function on the stack execute.

There are several ways to solve this problem:

pop the stack until all changed functions are removed from the stack. You need to know your code to be sure that there are no ill effects.
Use the cont at linenum command to continue from another line.
Manually repair data structures (use the assign command) before continuing.
Rerun the program using start.

If there are breakpoints in modified functions on the stack, the breakpoints are moved to the new versions of the functions. If the old versions are executed, the program does not stop in those functions.

Changing Variables after Fixing

Changes made to global variables are not undone by the pop or fix command. To manually reassign correct values to global variables, use the assign command.

The following example shows how a simple bug can be fixed. The application gets a segmentation violation in line 6 when trying to dereference a NULL pointer:

dbx[1] list 1,$

1 #include <stdio.h>

2

3 char *from = "ships";

4 void copy(char *to)

5 {

6 while ((*to++ = *from++) != '\0');

7 *to = '\0';

8 }

9

10 main()

11 {

12 char buf[100];

13

14 copy(0);

15 printf("%s\n", buf);

16 return 0;

17 }

(dbx) run

Running: testfix

(process id 4842)

signal SEGV (no mapping at the fault address) in copy at line 6 in file "testfix.cc"

6 while ((*to++ = *from++) != '\0');

`dbx[1]` `list 1,$` 1 #include <stdio.h> 2 3 char from = "ships"; 4 void copy(char to) 5 { 6 while ((to++ = from++) != '\0'); 7 to = '\0'; 8 } 9 10 main() 11 { 12 char buf[100]; 13 14 copy(0); 15 printf("%s\n", buf); 16 return 0; 17 } `(dbx)` `run` `Running: testfix` `(process id 4842)` `signal SEGV (no mapping at the fault address) in copy at line 6 in file "testfix.cc"` 6 while ((to++ = *from++) != '\0');

Change line 14 to copy to buf instead of 0 and save the file, then do a fix:

14 copy(buf); <=== modified line

(dbx) fix

fixing "testfix.cc" .....

pc moved to "testfix.cc":6

stopped in copy at line 6 in file "testfix.cc"

6 while ((*to++ = *from++) != '\0')

`14 copy(buf);` <=== modified line (dbx) `fix` `fixing "testfix.cc" .....` `pc moved to "testfix.cc":6` `stopped in copy at line 6 in file "testfix.cc"` `6 while ((to++ = from++) != '\0')`

If the program is continued from here, it still gets a SEGV because the zero-pointer is still pushed on the stack. Use the pop command to pop one frame of the stack:

(dbx) pop

stopped in main at line 14 in file "testfix.cc"

14 copy(buf);

`(dbx)` `pop` `stopped in main at line 14 in file "testfix.cc"` `14 copy(buf);`

If the program is continued from here, it will run, but it will not print the correct value because the global variable from has already been incremented by one. The program would print hips and not ships. Use the assign command to restore the global variable and then continue. Now the program prints the correct string:

(dbx) assign from = from-1(dbx) contships

`(dbx)` `assign from = from-1(dbx)` `contships`

Command Reference

The fix command takes the following options:


`fix [`options`] [`file1`,` file2`,...]`

-a

Fixes all modified files.

-f

Forces fixing the file, even if the source was not changed.

-c

Prints the compilation line, which may include some options added internally for use by dbx.

-g

Strips -O flags from the compilation line and adds the -g flag to it.

-n

Sets a no execution mode. Use this option when you want to list the source files to be fixed without actually fixing them.

file1, file2,...

Specifies a list of modified source files to fix.

`-a`	Fixes all modified files.
`-f`	Forces fixing the file, even if the source was not changed.
`-c`	Prints the compilation line, which may include some options added internally for use by `dbx`.
`-g`	Strips `-O` flags from the compilation line and adds the `-g` flag to it.
`-n`	Sets a no execution mode. Use this option when you want to list the source files to be fixed without actually fixing them.
`file1, file2,...`	Specifies a list of modified source files to fix.

If fix is invoked with an option other than -a and without a filename argument, only the current modified source file is fixed.

Note - Sometimes it may be necessary to modify a header (.h) file as well as a source file. To be sure that the modified header file is accessed by all source files in the program that include it, you must give as an argument to the fix command a list of all the source files that include that header file. If you do not include the list of source files, only the primary source file is recompiled and only it includes the modified version of the header file. Other source files in the program continue to include the original version of that header file.

Note - C++ template definitions cannot be fixed directly. Fix the files with the template instances instead. You can use the -f option to overwrite the date-checking if the template definition file has not changed. dbx looks for template definition .o files in the default repository directory Templates.DB. The
-ptr compiler switch is not supported by the fix command in dbx.

When fix is invoked, the current working directory of the file that was current at the time of compilation is searched before executing the compilation line. There might be problems locating the correct directory due to a change in the file system structure from compilation time to debugging time. To avoid this problem, use the command pathmap, which creates a mapping from one pathname to another. Mapping is applied to source paths and object file paths.

Using fix and continue

10

Basic Concepts

How fix and continue Operates

Modifying Source Using fix and continue

Restrictions

Fixing Your Program

Continuing after Fixing

Changing an executed function

Changing a function not yet called

Changing a function currently being executed

Changing a function presently on the stack

Changing Variables after Fixing

Command Reference

Using `fix` and `continue`

How `fix` and `continue` Operates

Modifying Source Using `fix` and `continue`