Running expressions has all sorts of side effects like storing data in the
inferior program and it also involves running the clang expression parser which
can be expensive.
You can, from a frame, get a SBValue for a variable without using the
expression parser:
lldb::SBValue
SBFrame.GetValueForVariablePath (const char *var_path);
So you can change your code to this:
heaps_used =
lldb.frame.GetValueForVariablePath('ruby_current_vm->objspace->heap_pages.used').GetValueAsUnsigned(0)
for i in xrange(heaps_used):
page =
lldb.frame.GetValueForVariablePath('*ruby_current_vm->objspace->heap_pages.sorted[%i]'
% i)
The GetValueForVariablePath() will find the variable and not create a temporary
each time. It also doesn't use the expression parser at all so it won't call
any code. The objects you access must be available in the hierarchy of the
struct or class and the struct or class can't override the "->" operator. Other
than that, the GetValueForVariablePath() knows how to access members
("ruby_current_vm->objspace->heap_pages.sorted"), dereference pointers using
the array syntax ("my_ptr[12]"), deref a pointer ("*this->other_ptr"), and take
the address of something ("&ruby_current_vm->objspace->heap_pages.sorted[12]").
So give the GetValueForVariablePath a try. The SBValue returned is something
that represents the live variable value, not a const result like you get back
from expression. SBValue you get back is tied to the frame from which you got
it, so it will continue to evaluate correctly and its value will change if you
step between calling functions with it. If the frame it came from goes away
(step out), then it won't return any valid values again as it will detect the
frame is gone and stop answering any questions. So you should always fetch a
fresh value from the frame each time you want to use it.
Greg
On Apr 17, 2014, at 7:57 AM, Scott Knight <[email protected]> wrote:
> I was recently using lldb to connect to a debug build of ruby to inspect the
> heap. In order to do this I was doing something like this
>
> -----------
> heaps_used =
> lldb.frame.EvaluateExpression('ruby_current_vm->objspace->heap_pages.used').GetValueAsUnsigned(0)
>
> for i in xrange(heaps_used):
> page =
> lldb.frame.EvaluateExpression('*ruby_current_vm->objspace->heap_pages.sorted[%i]'
> % i)
> -----------
>
> What I noticed was that for each EvaluateExpression a temporary $0, $1, $2,
> etc.. variable is created. If I ended up calling my python code multiple
> times more and more variables seemed to pile up and every EvaluateExpression
> call seemed to take longer and longer.
>
> I tried calling EvaluateExpression how I would call expr from the lldb
> command line setting my own variable, so something like
>
> lldb.frame.EvaluateExpression('int $test = 5')
>
> But that seemed to error out. So is there some other way in the API that is
> better for accessing global variables that won't slow down. Is this something
> actually wrong with the debugger? I can create an actual test case similar to
> the test suite in lldb if that would be helpful.
>
> Thanks,
> Scott Knight
>
> _______________________________________________
> lldb-dev mailing list
> [email protected]
> http://lists.cs.uiuc.edu/mailman/listinfo/lldb-dev
_______________________________________________
lldb-dev mailing list
[email protected]
http://lists.cs.uiuc.edu/mailman/listinfo/lldb-dev
