To use runtime checking, enable the type of checking you want to use before you run the program.
Use the following command to enable memory use and memory leak checking:
(dbx) check -memuse
When memory use checking or memory leak checking is enabled, the showblock command shows the details about the heap block at a given address. The details include the location of the block’s allocation and its size. For more information, see showblock Command.
Use the following command to enable memory access checking only:
(dbx) check -access
Use the following command and option to activate Discover error checking on an ADI capable machine:
(dbx) check -adi
Instrumentation is not required. The following kinds of errors can be detected:
Reading memory beyond array bounds
Writing to memory beyond array bounds
Reading from freed memory
Writing to freed memory
Stale pointer read
Staler pointer write
Reading from unallocated memory
Writing to unallocated memory
Double Free Memory
Use the following command to enable memory leak, memory use, and memory access checking:
(dbx) check -all
For more information , see check Command.
Use the following command to disable runtime checking entirely:
(dbx) uncheck -all
For more information, see uncheck Command.
After enabling the types of runtime checking you want, run the program being tested with or without breakpoints.
The program runs normally but slowly because each memory access is checked for validity just before it occurs. If dbx detects invalid access, it displays the type and location of the error. Control returns to you unless the dbxenv variable rtc_auto_continue is set to on.
You can then issue dbx commands, such as where to get the current stack trace or print to examine variables. If the error is not a fatal error, you can continue execution of the program with the cont command. The program continues to the next error or breakpoint, whichever is detected first. For more information, see cont Command.
If the rtc_auto_continue dbxenv variable is set to on, runtime checking continues to find errors and keeps running automatically. It redirects errors to the file named by the dbxenv variable rtc_error_log_file_name. The default log file name is /tmp/dbx.errlog.unique-ID.
You can limit the reporting of runtime checking errors using the suppress command. For more information, see suppress Command.
The following simple example shows how to enable memory access and memory use checking for a program called hello.c.
% cat -n hello.c 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 char *hello1, *hello2; 6 7 void 8 memory_use() 9 { 10 hello1 = (char *)malloc(32); 11 strcpy(hello1, "hello world"); 12 hello2 = (char *)malloc(strlen(hello1)+1); 13 strcpy(hello2, hello1); 14 } 15 16 void 17 memory_leak() 18 { 19 char *local; 20 local = (char *)malloc(32); 21 strcpy(local, "hello world"); 22 } 23 24 void 25 access_error() 26 { 27 int i,j; 28 29 i = j; 30 } 31 32 int 33 main() 34 { 35 memory_use(); 36 access_error(); 37 memory_leak(); 38 printf("%s\n", hello2); 39 return 0; 40 } % cc -g -o hello hello.c % dbx -C hello Reading ld.so.1 Reading librtc.so Reading libc.so.1 Reading libdl.so.1 (dbx) check -access access checking - ON (dbx) check -memuse memuse checking - ON (dbx) run Running: hello (process id 18306) Enabling Error Checking... done Read from uninitialized (rui): Attempting to read 4 bytes at address 0xeffff068 which is 96 bytes above the current stack pointer Variable is ’j’ Current function is access_error 29 i = j; (dbx) cont hello world Checking for memory leaks... Actual leaks report (actual leaks: 1 total size: 32 bytes) Total Num of Leaked Allocation call stack Size Blocks Block Address ========== ====== ========== ======================================= 32 1 0x21aa8 memory_leak < main Possible leaks report (possible leaks: 0 total size: 0 bytes) Checking for memory use... Blocks in use report (blocks in use: 2 total size: 44 bytes Total % of Num of Avg Allocation call stack Size All Blocks Size ========== ==== ====== ====== ======================================= 32 72% 1 32 memory_use < main 12 27% 1 12 memory_use < main execution completed, exit code is 0
The function access_error() reads variable j before it is initialized. Runtime checking reports this access error as a Read from uninitialized (rui) error.
The function memory_leak() does not free the variable local before it returns. When memory_leak() returns, this variable goes out of scope and the block allocated at line 20 becomes a leak.
The program uses the global variables hello1 and hello2, which are in scope all the time. They both point to dynamically allocated memory, which is reported as Blocks in use (biu).