Show function arguments which is a pointer/ref to a class

[xzwang2005]

hi,

Is it possible to show the function argument when the type is a pointer or ref to a class? e.g.,

void foo(Point* pt) {...}
or
void foo(Point& pt) {...}

Right now it seems to show the address.

A follow up question is, these functions usually modify the input. Although the return type is void, is it possible to show the value of the input argument when exit the function?

Thanks.

[namhyung]

I think it's related to #1258. Actually we print type names when the arguments are strict or class and passed by value. So it'd be possible to do that but I'm not sure how useful it is. Also tracking a correct type can be difficult and language-dependent.

[xzwang2005]

Instead of just printing the type name, is it possible to capture the value of the arguments when it's passed in as a pointer/ref ?

The use case is, say we have a batch job that process 10k accounts daily. Each account is passed in to a function as a pointer to be updated. Later it's found that one account was not updated correctly, we want to compare that account's values before and after run by the function. Does it make sense?

[namhyung]

Yeah but it's hard to do it with composite types because they can contain many members.

Actually I'm thinking of a kind of watch triggers on arguments to specify field name to track explicitly.

[namhyung]

Something like in #661 but it might accept function argument. It could display the requested (scalar) value at entry and exit of the function.

Ideally with debug info, we can do something with name -T myfunc@read=arg1/ptr->member. But without that it should be able to handle offset and type manually like -T myfunc@read=arg1/+8:int32. Maybe there's a better syntax.

Some work need to be done for parsing those syntax and detect types. Also it should make sure that it doesn't crash the program by accessing invalid memory region or something.

[xzwang2005]

yep, if uftrace can capture the requested value (struct, class) at entry and exit of the function, that would be very helpful.
I'm not familiar with the code base, would you please give a rough estimate on how much effort it would be, if it is possible?
Thanks a lot :)

[namhyung]

Are you interested in implementing it by yourself? Then I suggest to work on without debug info first. If you can work full time, I'd say that it could be a month or two.

If it's not, I cannot say how long it will take because I don't have much time to work on this project at the moment.

[xzwang2005]

Thanks for the info.

Just to be clear, there are two features mentioned so far:

1. capture the input and output values, even when the type is pointer/ref to a class, i.e., TypeA foo(const TypeB*)
2. track the changes of function arguments (class type), i.e., void bar(TypeA*)

Based on the discussion above, both are possible, is that correct?

[namhyung]

1. yes it captures the values but doesn't dereference pointers.
2. it'd dereference the pointer/ref then we need to specify a single member to follow rather than accessing the whole data.