C - Debugging Tools

Question 1

1. breakpoint

Answer 1

a point in the program where it will stop executing

Question 2

2. Watchpoint

Answer 2

a point where the program will stop executing when the specified memory location is modified

Question 3

3. catchpoint

Answer 3

special breakpoint that stops program execution when a certian kind of event occurs

Question 4

4. memory leak

Answer 4

a program error of repeatedly allocating memory, using it, and neglecting to free it

Question 5

5. valgrind

Answer 5

programming tool for memory debugging, memory leak detection, and profiling.

Question 6

commands 1: run

Answer 6

run [arglist]
start your program (with arglist, if specified).

Question 7

basic commands 2. continue

Answer 7

c
continue running your program (after stopping, like at a breakpoint)

Question 8

basic commands 3. finish

Answer 8

finish

continue execution until the current function returns

Question 9

basic commands 4. break

Answer 9

break [[ func | line | *addr)}] [if cond] [thread thread]
sets a breakpoint at a specified location.

break 200 // sets breakpoint at 200

Question 10

basic commands 5. next

Answer 10

next [expr]

executes the next function call, and stops when the function call finishes executing.

Question 11

basic commands 6. step/step [count]

Answer 11

step [expr]

steps forward, even into the first executable statement in a function call.

step 5 will execute step 5 times

Question 12

basic commands 7. display/undisplay

Answer 12

display [Expression]

by default, displays variable values at each step state,

undisplay removes a variable from the list of variables to be displayed automatically

Question 13

basic commands 8. print

Answer 13

print [Expression]
print $[Previous value number]
print {[Type]}[Address]
print [First element]@[Element count]
print /[Format] [Expression]

prints the value of a given expression

Question 14

basic commands 9. list

Answer 14

list
list [ file_name:]line_expression
list begin,end
list begin,
list ,end
list +[num]
list -[num]
list *address

displays lines of source code specified by the following:
position of the program counter,
last line listed (if multiple list commands listed)
the line numbers specified as the parameters to the list command

https://www.irya.unam.mx/computo/sites/manuales/fce12/debugger/cl/commandref/common_cmd/cmd_list.htm

Question 15

basic commands 10. watch

Answer 15

watch lvalue
sets a write watchpoint on the specified expression

(watch variableName)

Question 16

basic commands 11. quit

Answer 16

quit

exits the debugger

Question 17

Advanced commands 1 ptype

Answer 17

ptype [name]
prints detailed description of a type, or the type of the last value in the command history

Question 18

Advanced commands 2. catch

Answer 18

catch [signal_ID]

catches and handles the specified signal.
debugger does not make an entry in the beakpoint table for catch command,
a catch that has already being caught, does not create an additional breakpoint for that signal.

catch without parameter lists all signals currently being handled.

https://www.irya.unam.mx/computo/sites/manuales/fce12/debugger/cl/commandref/idb_mode/cmd_catch.htm

Question 19

vanced commands 3. clear

Answer 19

clear [{func | line | *addr}] [if cond] [thread thread]

clear a breakpoint at the specified location.

if none specified, removes the breakpoint from the next instruction to be executed.

Question 20

Advanced commands 4. up

Answer 20

up [num]
move (backwards) to the previous stack frame, or one of the frames preceeding it

Question 21

Advanced commands 5. down

Answer 21

opposite of up, moving to the next stack frames.

Question 22

Advanced Commands 6. where/backtrace

Answer 22

where [num] [thread { thread_id, … | all | * } ]

show the current stack trace of currently active functions.

backtrace [full] [num]

prints backtrace of stack frames

Question 23

7. until

Answer 23

until [line]

continues the debugee past the current line until the specified source line in the current stack frame.

Question 24

8. call

Answer 24

call expression (parmlist)
call a function in the dubuggee

specify the function as if you were calling it from within the appication

Question 25

9. x (examining memory)

Answer 25

x [/nfu] [addr]

prints memory

Question 26

10. disable/enable

Answer 26

disable [breakpoints][ {ID … | ID-range …} ]
disables one or more breakpoints
enable [breakpoints] [ {ID … | ID-range …} ]

Question 27

11. set/show args

Answer 27

set args [arguments] [IO_redirection]
specifies arguments for debuggee program

show args
show arguments and input/output redirections.

Question 28

12. set var

Answer 28

set variable variable = [expression]
set variables mid-debug

Question 29

Q1 How would you compile a source file with debug information?

Answer 29

gcc -g -o fileName Exercises.c
./fileName

gdb -tui fileName

Question 30

Q2 What is the difference between step and next?

Answer 30

step will step once line through the code, even into function calls.
next will skim through the entire next function call if there is one.

Question 31

!3 what is the difference between a breakpoint, watchpoint and catchpoint?

Answer 31

a break point will pause the program when reached.
watchpoint stops the program when the value of an expression changes.
catchpoint stops when a certain kind of event occurs, like when an exception is thrown or a library is loaded.

Question 32

Q4 What is the difference between until and step?

Answer 32

step will step once line through the code, even into function calls.
until will skip/step through several lines of code until the specified in a stack frame

Question 33

Valgrind 1: alias vlg=’valgrind –leak-check=yes –track-origins=yes’

Answer 33

leak-check: searches for memory leaks when the program finishes. by default, says how many leaks occured. set to yes, each leak is shown in detail and/or counted as an error

track-origins: if an uninitialised value is encountered, it describes:
if from heap block, shows where the block was allocated.
if from stack allocations, tells which function allocated the value.
if from client request or other sources, just where they came from.

alias vlg=’valgrind –leak-check=yes –track-origins=yes’

Question 34

Valgrind 2: Do an alocation of memory and don’t free it

Answer 34

int *ptr2 = (int *)malloc(sizeof(int));

lost 4 bytes in 1 block.

Question 35

Valgrind 3: Create an array of size 10 and try to read its 11th member

Answer 35

int array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
printf(“%d”, array[10);

valgrind doesn’t seem to recognize the issue

Question 36

Valgrind 4: Free a pointer, then dereference that pointer

Answer 36

free(ptr2);
int x = *ptr2;

invalid read of size 4,
in reverse order, displays where and by who the address was assigned,
free’d,
alloc’d

Question 37

Valgrind 5: perform an if statement based on a memory address that was not initialized. for example, an array allocated with malloc() but not initialized, and then if *arr …

Answer 37

int *ptr2 = (int *)malloc(sizeof(int));
if (ptr2[0]){printf(“oopsie, stinky.”);}

conditional jump or move depends on uninitialised values,
uninitialised value was created a heap allocation,

4 bytes are definitely lost in los record 1 of 1 at x malloc by y main

Question 38

Valgrind 6:

Answer 38

indeed, tested and checked, all functions in 2s2 are fine

Question 39

Core dump 1: read man core dump

Question 40

Code dump 2: Write a program that loops infinitely. run it.

Answer 40

while(1){printf(“A”);

Question 41

Core dump 3: send a SIGABRT signall to the process running your program. set ulimit to allow for core-file to be generated

Answer 41

kill SIGABRT <pid></pid>

Question 42

Core dump 4: debug the generated file

Answer 42

suffering.

ulimit -c unlimited
strl+\

Question 43

Extra: Fix the thing

Answer 43

include <stdio.h></stdio.h>

#include <stdlib.h>
#include <assert.h></assert.h></stdlib.h>

void whatSouldWeFixHere(int *arr, size_t arr_length)
{
int i = 0;
int *p;

assert(arr);

p = (int *)malloc(sizeof(int) * arr_length);

for(i = 0; i < (int)arr_length; ++i)
{
	p[arr_length - 1 - i] = arr[i];
}

for(i = 0; i < (int)arr_length; ++i)
{
	arr[i] = p[i];
} 
free(p);/*added free(p)*/ }

int main(int argc, char *argv[])
{
int i = 0;
int arr[] = {0, 1, 2, 3, 4, 5};

whatSouldWeFixHere(arr, sizeof(arr)/sizeof(int)); 

for(i = 0; i < sizeof(arr)/sizeof(int); ++i) /*less than, not less than or equal to.*/
{
	printf("%d,", arr[i]);
}

return 0; }