Comment by jvns | Hacker News Reader

Comment by jvns | Hacker News Reader

Parent Full thread

Thanks for the link to `call_function_by_hand`, that's super helpful! In retrospect, I could have found this file by grepping for 'When the function is done executing, GDB will silently stop' (the very useful "grep for UI text" trick!)

the choice between whether to try to understand something by running or by reading the code is a super interesting one (though if I'm seriously interested in understanding exactly what some software does of course I'll do both!).

I think experimentation/stracing a program to understand it has a lot of advantages:

* It can be helpful to look at the system calls as a way to maybe see the big picture before diving into the code.("ok, it's setting some registers somehow, it's putting in some int3 instructions, then it does PTRACE_CONT, then it undoes all the changes it made").

* it lets me focus on what the program actually does instead of understanding how the code is organized (figuring out how the code in a large project I've never looked at before is organized can be time consuming!)

* It's easy to make incorrect conclusions when reading the source. This happens to me a lot when reading distributed systems code -- often I'll think "ok, if I do X, then Y will happen" but that turns out not to be true in practice. So I think even when you are reading code, doing experimentation as you go is a key part of making sure that your understanding of the code is actually correct.

* I find exploring programs interactively fun!

In this specific example -- I think it's really interesting that gdb modifies the `longjmp` function in libc when running a function. The string `longjmp` doesn't appear anywhere in infcall.c. So even though reading infcall.c seems like a great overview, it just has different information that I get from using strace!

I see where you're coming from, in the past I've gdb'd... gdb itself to figure out an obscure bug. It gets a bit confusing at times (better use different prompts at least) but this way you could step through the debugger's code itself instead of deciphering strace's output for instance.

longjmp() (and friends) is trapped because it causes a non-local transfer of control. Basically, it can go anywhere. the "p foo()" would then not return to the prompt. What we know is that longjmp() will leave the function (it goes to where the setjmp() was called from).

Also, look into libffi for how to call a C function by building a call.

>very useful "grep for UI text" trick

Just, one thing: for C/C++ code-bases such as gdb, stop using grep for things, people! Use cscope! 'tis a brilliant means of navigating files and scoping out the contents of a project.

http://cscope.sourceforge.net

$ cd gdb/src; cscope -R

Looks handy! I think I'll start using it for a few things. But, I probably won't stop using grep, these tools don't really compete.

Ooh, grep is definitely useful, no question .. but cscope, in the right hands, can be far, far more productive .. try it and see!

cscope is a sine qua non of C (and even C++ and Java) development. Of course, with OOP languages a dumb lexical indexer is not that useful (this applies to OpenGrok and many others too) -- if you're looking for calls to the getName() method of a particular class (and sub-classes) in a huge codebase then you'll be in for a lot of pain. But for C cscope is absolutely fantastic and much much better than etags/ctags.

I use cscope in conjunction w ctags. cscope (which will launch an editor, appropriately ) for a top-level overview/dive, and ctags (from w/i my vi instance, whether vi was launched from cscope or not) when I’m zeroing-in on a problem and can chase down thoughts and maintain my way back out because navigation is pushing/popping on a stack. No need for either/or; use them both.

I find that cscope integration in vim supersedes any need for ctags. For why is ctags not just a subset?

I'm a BSD nvi user, so no vim for me. I do apparently have access to cscope database from w/i nvi, but my finger muscle memory wrt (ex)ctags support gets me a long way (perhaps I could do better w/ cscope? Something to look into.)

I'm not sure how to parse your last question -- rephrase ?

You would do better with cscope. Just try it. If you want I'll post the $CSCOPE_EDITOR wrapper script I use.

I did work out the (ex) usage for in-editor cscope in nvi (for the curious, in nvi(1) after building the cscope db:

  :cscope add ./cscope.out
  :cscope find g myfunc
  :cscope find e [Ss]ome.expres*ion

Anyway, otherwise - yes, interested to see your $EDITOR script.

https://github.com/cryptonector/cscope_editor

Last question: ctags is a sub-set of cscope, in that cscope does all that ctags does, and more.

Anyway, I concur with your reasoning: bsd vi and muscle memory. Works for me!

I find it easier to cut-n-paste (with tmux) the symbol I want to chase down, pasting it into cscope.

The reason this is better is that ctags doesn't do what I want. I may want to see functions called by some symbol (ctags no help), functions calling that symbol (two ctags operations required), or assignments to a variable (ctags no help) or even just a full-text search (again, ctags no help).

I don't need $EDITOR cscope integration because I have an easier time tracking appropriately-titled tmux windows than I do tracking $EDITOR buffers (not least because tmux windows are more general!), so I really want a new tmux window with a new $EDITOR instance. Thus the cut-n-paste approach, while it requires a few more keystrokes than I might like, works best. I could always do my own integration that uses tmux to programmatically write the symbol I want to the cscope window, but I don't feel the need.

Upvote for cscope mention.

I prefer cscope -Rqk. I run cscope on the zeroth window of a tmux/screen session with a $CSCOPE_EDITOR program that's a script that starts the real $EDITOR in a new window in the same session (with an appropriate window name) and in the background so that cscope gets control back immediately. This allows me to use cscope to drive large code investigations very easily.

Sounds cool. I use it in vim as a 'grok this C/C++/Lua/Textfiles' utility, pretty much every day. grep too of course, and there are times when you just wanna ack, but for full grok, cscope is cool however you do it.

I have a shell function that generates shell functions that do find | xargs ... patterns. Thus I have 'fsg' == find source grep -- that is, find with -name arguments matching source | xargs grep ..., and fseg (find source egrep) and fmg (find make stuff grep). These functions take all non-option looking arguments and use them as directory arguments for find, then all remaining arguments are passed to grep, so I get to write:

    $ fsg foo bar -w foo

which translates into something like:

    find foo bar \( -name '*.[chylm]' -o -name ... \) -print0 | xargs -0 grep "$@"

Still, cscope is fantastic, and the first tool I reach for.

Cscope feels kind of lousy nowadays after I have been using opengrok. It handles multilang repos so much nicer and allows you to search all the codebases instead of just one.

Reply on news.ycombinator.com