I have a program and want to debug it in gdb.
Will I see usual program output? How can I enable/disable this output, leaving only gdb messages.
You can redirect output from within gdb:
(gdb) run > somefile.txt
will redirect standard output to somefile.txt. You can also specify a terminal to send output to:
(gdb) tty /dev/ttyb
Yes, you will see all output from your program.
You can disable this by sending it off elsewhere. For example:
(gdb) run > /dev/null
If you just want to see the output of the program as you step through it without gdb's output, this script can be useful.
#!/bin/bash
file=$1
delay=1 #seconds
lastTime=`stat --printf=%y "$file"`
while [ 1 ]
do
thisTime=`stat --printf=%y "$file"`
if [ "$thisTime" != "$lastTime" ]
then
clear
cat "$file"
fi
lastTime="$thisTime"
sleep $delay
done
lastTime="$thisTime"
sleep $delay
done
Ignore stdout and stderr
run &>/dev/null
Analogous to the Bash syntax.
Tested on GDB 7.10.
Related
I'm not very into unix/linux, I'm using rhat linux with sh, tcsh shells.
What I'm trying to do is to debug lifecycle of the object of the class by breaking on it's default, copy c-tors, on d-tor and on operator=; move operations are not defined neither by compiler or me. I break on these functions and printf some lines and also print backtrace
br /project/src/some_file.c:408
commands
silent
printf "<%p> D E F A U L T c-tor bt:\n", this
bt
cont
end
The thing is there're a lot objects of this class, so there is a lot of output, and nothing helps me to disable output to the terminal, so I want see gdb output only in the file, not in the shell. Is it possible to achieve using sh or tcsh? - I can't really impact on the environment and use some other debugger or shell. The reason I want to disable any output from gdb and process being debugged to the shell is because I believe it slows down gdb and execution of the debugged process, which breaks behavior of debugged application.
Using gdb 8.1. I tried logging options of gdb, redirecting output by
run > somefile
and I tried to run gdb like this
gdb -p 1000 -x breakpoint.txt | tee somefile.txt
Thanks many times!
this link has various option for logging
http://sourceware.org/gdb/onlinedocs/gdb/Logging-Output.html
simple one is
set logging file file
Change the name of the current logfile. The default logfile is gdb.txt.
then
set logging on
Enable logging.
I need to debug a program that feeds on the output of another program. Hence, writing the output of the 'feeder' into a file, and piping that to the 'reader' doesn't work.
Normal run:
# feeder | ./reader
This is NOT an option here:
# feeder > data
# gdb ./reader
(gdb) run < data
You can make the reader pause and wait for GDB to attach, as described here.
Then run:
feeder | ./reader
in one terminal, and gdb -p $(pgrep reader) in another terminal.
Once gdb is attached, let the reader proceed, and debug it normally.
Update:
Now that you've clarified your constraint, another way is to use named pipe:
mknod /tmp/.pipe p
feeder > /tmp/.pipe
gdb reader
(gdb) run < /tmp/.pipe
I am running someone's code and the code crashes on a specific dataset, but the crash message as-is is not informative. I cannot call GDB and then wait (for GDB) to pass r to it (things are running on a cluster). Is there a way to pass r to GDB in the runtime by default, something like the following?
gdb r ./run
You can load your program in GDB, like:
$ gdb your_program_name
and then attach to process which you want to debug
attach pid
You may use a commands file. Write all the commands you want to execute sequentially in the file. And use that file to pass the command to GDB with input redirection:
echo "r" > cmds
gdb r --args ./run -arg1 -arg2 -arg3 < cmds
I have a program and I am trying to debug it using gdb. Inside the program I have methods that require the user to enter an input using stdin. How can I enter this input when I am in gdb? So that I can trace how my methods work?
$ cat >foo <<EOF
something
EOF
$ gdb -quiet /bin/cat
Reading symbols from /bin/cat...(no debugging symbols found)...done.
Missing separate debuginfos, use: debuginfo-install coreutils-8.12-7.fc16.x86_64
(gdb) run <foo
Starting program: /bin/cat <foo
something
[Inferior 1 (process 22436) exited normally]
(gdb)
You can also run your program first, then attach GDB to it:
gdb --pid $(pgrep your_program)
This way you will be able to run your program interactively in a separate terminal.
I just went through something like this yesterday and recursed through a bunch of "help" commands in gdb because I couldn't find exactly what I needed on the Internet.
I used set variable *your_variable* = *your desired input* after I had started gdb and began running my code. Worked like a charm.
I know this is late, but maybe it'll help someone else.
I usually run a program as :
./a.out arg1 arg2 <file
I would like to debug it using gdb.
I am aware of the set args functionality, but that only works from the gdb prompt.
You can do this:
gdb --args path/to/executable -every -arg you can=think < of
The magic bit being --args.
Just type run in the gdb command console to start debugging.
Pass the arguments to the run command from within gdb.
$ gdb ./a.out
(gdb) r < t
Starting program: /dir/a.out < t
If you want to have bare run command in gdb to execute your program with redirections and arguments, you can use set args:
% gdb ./a.out
(gdb) set args arg1 arg2 <file
(gdb) run
I was unable to achieve the same behaviour with --args parameter, gdb fiercely escapes the redirections, i.e.
% gdb --args echo 1 2 "<file"
(gdb) show args
Argument list to give program being debugged when it is started is "1 2 \<file".
(gdb) run
...
1 2 <file
...
This one actually redirects the input of gdb itself, not what we really want here
% gdb --args echo 1 2 <file
zsh: no such file or directory: file
Start GDB on your project.
Go to project directory, where you've already compiled the project executable. Issue the command gdb and the name of the executable as below:
gdb projectExecutablename
This starts up gdb, prints the following:
GNU gdb (Ubuntu 7.11.1-0ubuntu1~16.04) 7.11.1
Copyright (C) 2016 Free Software Foundation, Inc.
.................................................
Type "apropos word" to search for commands related to "word"...
Reading symbols from projectExecutablename...done.
(gdb)
Before you start your program running, you want to set up your breakpoints. The break command allows you to do so. To set a breakpoint at the beginning of the function named main:
(gdb) b main
Once you've have the (gdb) prompt, the run command starts the executable running. If the program you are debugging requires any command-line arguments, you specify them to the run command. If you wanted to run my program on the "xfiles" file (which is in a folder "mulder" in the project directory), you'd do the following:
(gdb) r mulder/xfiles
Hope this helps.
Disclaimer: This solution is not mine, it is adapted from https://web.stanford.edu/class/cs107/guide_gdb.html
This short guide to gdb was, most probably, developed at Stanford University.
Wouldn't it be nice to just type debug in front of any command to be able to debug it with gdb on shell level?
Below it this function. It even works with following:
"$program" "$#" < <(in) 1> >(out) 2> >(two) 3> >(three)
This is a call where you cannot control anything, everything is variable, can contain spaces, linefeeds and shell metacharacters. In this example, in, out, two, and three are arbitrary other commands which consume or produce data which must not be harmed.
Following bash function invokes gdb nearly cleanly in such an environment [Gist]:
debug()
{
1000<&0 1001>&1 1002>&2 \
0</dev/tty 1>/dev/tty 2>&0 \
/usr/bin/gdb -q -nx -nw \
-ex 'set exec-wrapper /bin/bash -c "exec 0<&1000 1>&1001 2>&1002 \"\$#\"" exec' \
-ex r \
--args "$#";
}
Example on how to apply this: Just type debug in front:
Before:
p=($'\n' $'I\'am\'evil' " yay ")
"b u g" "${p[#]}" < <(in) 1> >(out) 2> >(two) 3> >(three)
After:
p=($'\n' $'I\'am\'evil' " yay ")
debug "b u g" "${p[#]}" < <(in) 1> >(out) 2> >(two) 3> >(three)
That's it. Now it's an absolute no-brainer to debug with gdb. Except for a few details or more:
gdb does not quit automatically and hence keeps the IO redirection open until you exit gdb. But I call this a feature.
You cannot easily pass argv0 to the program like with exec -a arg0 command args. Following should do this trick: After exec-wrapper change "exec to "exec -a \"\${DEBUG_ARG0:-\$1}\".
There are FDs above 1000 open, which are normally closed. If this is a problem, change 0<&1000 1>&1001 2>&1002 to read 0<&1000 1>&1001 2>&1002 1000<&- 1001>&- 1002>&-
You cannot run two debuggers in parallel. There also might be issues, if some other command consumes /dev/tty (or STDIN). To fix that, replace /dev/tty with "${DEBUGTTY:-/dev/tty}". In some other TTY type tty; sleep inf and then use the printed TTY (i. E. /dev/pts/60) for debugging, as in DEBUGTTY=/dev/pts/60 debug command arg... That's the Power of Shell, get used to it!
Function explained:
1000<&0 1001>&1 1002>&2 moves away the first 3 FDs
This assumes, that FDs 1000, 1001 and 1002 are free
0</dev/tty 1>/dev/tty 2>&0 restores the first 3 FDs to point to your current TTY. So you can control gdb.
/usr/bin/gdb -q -nx -nw runs gdb invokes gdb on shell
-ex 'set exec-wrapper /bin/bash -c "exec 0<&1000 1>&1001 2>&1002 \"\$#\"" creates a startup wrapper, which restores the first 3 FDs which were saved to 1000 and above
-ex r starts the program using the exec-wrapper
--args "$#" passes the arguments as given
Wasn't that easy?