Re: Additional debug info to aid cacheline analysis

Mark Wielaard
2020-10-30T09:17:45Z

Hi Namhyung,

On Fri, Oct 30, 2020 at 02:26:19PM +0900, Namhyung Kim wrote:
> On Thu, Oct 8, 2020 at 6:38 PM Mark Wielaard <mark@klomp.org> wrote:
> > GCC using -fvar-tracking and -fvar-tracking-assignments is pretty good
> > at keeping track of where variables are held (in memory or registers)
> > when in the program, even through various optimizations.
> >
> > -fvar-tracking-assignments is the default with -g -O2.
> > Except for the upstream linux kernel code. Most distros enable it
> > again, but you do want to enable it by hand when building from the
> > upstream linux git repo.
>
> Please correct me if I'm wrong. This seems to track local variables.
> But I'm not sure it's enough for this purpose as we want to know
> types of any memory references (not directly from a variable).
>
> Let's say we have a variable like below:
>
> struct xxx a;
>
> a.b->c->d++;
>
> And we have a sample where 'd' is updated, then how can we know
> it's from the variable 'a'? Maybe we don't need to know it, but we
> should know it accesses the 'd' field in the struct 'c'.
>
> Probably we can analyze the asm code and figure out it's from 'a'
> and accessing 'd' at the moment. I'm curious if there's a way in
> the DWARF to help this kind of work.

DWARF does have that information, but it stores it in a way that is
kind of opposite to how you want to access it. Given a variable and an
address, you can easily get the location where that variable is
stored. But if you want to map back from a given (memory) location and
address to the variable, that is more work.

In theory what you could do is make a list of global variables from
the top-level DWARF CUs. Then take the debug aranges to map from the
program address to the DWARF CU that covers that address. Then for
that CU you would walk the CU DIE tree while keeping track of all
variables in scope till you find the function covering that
address. Then for each global variable and all variables in scope you
get the DWARF location description at the given address (for global
ones that is most likely always a static address, but for local ones
it depends on where exactly in the program you take the sample). That
plus the type information for each variable should then make it
possible to see which variable covers the given memory location.

But that is a lot of work to do for each sample.

Cheers,

Mark