Received-SPF: pass (google.com: domain of linux-kernel+bounces-107936-linux.lists.archive=gmail.com@vger.kernel.org designates 147.75.80.249 as permitted sender) client-ip=147.75.80.249;
Precedence: bulk
MIME-Version: 1.0
References: <20240319055115.4063940-1-namhyung@kernel.org> <20240319055115.4063940-4-namhyung@kernel.org>
 <ZfmZNp1DaKYZCwyf@x1>
In-Reply-To: <ZfmZNp1DaKYZCwyf@x1>
From: Namhyung Kim <namhyung@kernel.org>
Date: Tue, 19 Mar 2024 10:41:06 -0700
Message-ID: <CAM9d7cg50Smf7A-ihrxO9Lw5RmXf56NahL7U13qDJHtCL8C=LQ@mail.gmail.com>
Subject: Re: [PATCH 03/23] perf dwarf-aux: Handle type transfer for memory access
To: Arnaldo Carvalho de Melo <acme@kernel.org>
Cc: Ian Rogers <irogers@google.com>, Jiri Olsa <jolsa@kernel.org>, 
	Adrian Hunter <adrian.hunter@intel.com>, Peter Zijlstra <peterz@infradead.org>, 
	Ingo Molnar <mingo@kernel.org>, LKML <linux-kernel@vger.kernel.org>, 
	linux-perf-users@vger.kernel.org, 
	Linus Torvalds <torvalds@linux-foundation.org>, Stephane Eranian <eranian@google.com>, 
	Masami Hiramatsu <mhiramat@kernel.org>, linux-toolchains@vger.kernel.org, 
	linux-trace-devel@vger.kernel.org
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Tue, Mar 19, 2024 at 6:55=E2=80=AFAM Arnaldo Carvalho de Melo
<acme@kernel.org> wrote:
>
> On Mon, Mar 18, 2024 at 10:50:55PM -0700, Namhyung Kim wrote:
> > We want to track type states as instructions are executed.  Each
> > instruction can access compound types like struct or union and load/
> > store its members to a different location.
> >
> > The die_deref_ptr_type() is to find a type of memory access with a
> > pointer variable.  If it points to a compound type like struct, the
> > target memory is a member in the struct.  The access will happen
> > with an offset indicating which member it refers.  Let's follow the
> > DWARF info to figure out the type of the pointer target.
> >
> > For example, say we have the following code.
> >
> >   struct foo {
> >     int a;
> >     int b;
> >   };
> >
> >   struct foo *p =3D malloc(sizeof(*p));
> >   p->b =3D 0;
> >
> > The last pointer access should produce x86 asm like below:
> >
> >   mov  0x0, 4(%rbx)
> >
> > And we know %rbx register has a pointer to struct foo.  Then offset 4
> > should return the debug info of member 'b'.
> >
> > Also variables of compound types can be accessed directly without a
> > pointer.  The die_get_member_type() is to handle a such case.
> >
> > Acked-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>
> > Signed-off-by: Namhyung Kim <namhyung@kernel.org>
> > ---
> >  tools/perf/util/dwarf-aux.c | 110 ++++++++++++++++++++++++++++++++++++
> >  tools/perf/util/dwarf-aux.h |   6 ++
> >  2 files changed, 116 insertions(+)
> >
> > diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
> > index 785aa7a3d725..cd9364d296b6 100644
> > --- a/tools/perf/util/dwarf-aux.c
> > +++ b/tools/perf/util/dwarf-aux.c
> > @@ -1838,3 +1838,113 @@ int die_get_scopes(Dwarf_Die *cu_die, Dwarf_Add=
r pc, Dwarf_Die **scopes)
> >       *scopes =3D data.scopes;
> >       return data.nr;
> >  }
> > +
> > +static int __die_find_member_offset_cb(Dwarf_Die *die_mem, void *arg)
> > +{
> > +     Dwarf_Die type_die;
> > +     Dwarf_Word size, loc;
> > +     Dwarf_Word offset =3D (long)arg;
> > +     int tag =3D dwarf_tag(die_mem);
> > +
> > +     if (tag !=3D DW_TAG_member)
> > +             return DIE_FIND_CB_SIBLING;
> > +
> > +     /* Unions might not have location */
> > +     if (die_get_data_member_location(die_mem, &loc) < 0)
> > +             loc =3D 0;
> > +
> > +     if (offset =3D=3D loc)
> > +             return DIE_FIND_CB_END;
> > +
> > +     die_get_real_type(die_mem, &type_die);
>
> Don't we have to check that the type_die was initialized? From what I
> can see there is the possibility it isn't:

Right, it might return NULL if the entry doesn't have a valid
DW_AT_type.  I'll check the return value and skip.

Thanks,
Namhyung

>
>   Dwarf_Die type_die;
>   die_get_real_type(die_mem, &type_die);
>         do {
>                 vr_die =3D __die_get_real_type(vr_die, die_mem);
>         } while (vr_die && dwarf_tag(vr_die) =3D=3D DW_TAG_typedef);
>
>         return vr_die;
>
>     static Dwarf_Die *__die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *d=
ie_mem)
>
>         do {
>                 vr_die =3D die_get_type(vr_die, die_mem);
>                 if (!vr_die)
>                         break;
>
>    Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
>
>         Dwarf_Attribute attr;
>
>         if (dwarf_attr_integrate(vr_die, DW_AT_type, &attr) &&
>             dwarf_formref_die(&attr, die_mem))
>                 return die_mem;
>         else
>                 return NULL;
>   }
>
> > +     if (dwarf_aggregate_size(&type_die, &size) < 0)
> > +             size =3D 0;
> > +
> > +     if (loc < offset && offset < (loc + size))
> > +             return DIE_FIND_CB_END;
> > +
> > +     return DIE_FIND_CB_SIBLING;
> > +}
> > +
> > +/**
> > + * die_get_member_type - Return type info of struct member
> > + * @type_die: a type DIE
> > + * @offset: offset in the type
> > + * @die_mem: a buffer to save the resulting DIE
> > + *
> > + * This function returns a type of a member in @type_die where it's lo=
cated at
> > + * @offset if it's a struct.  For now, it just returns the first match=
ing
> > + * member in a union.  For other types, it'd return the given type dir=
ectly
> > + * if it's within the size of the type or NULL otherwise.
> > + */
> > +Dwarf_Die *die_get_member_type(Dwarf_Die *type_die, int offset,
> > +                            Dwarf_Die *die_mem)
> > +{
> > +     Dwarf_Die *member;
> > +     Dwarf_Die mb_type;
> > +     int tag;
> > +
> > +     tag =3D dwarf_tag(type_die);
> > +     /* If it's not a compound type, return the type directly */
> > +     if (tag !=3D DW_TAG_structure_type && tag !=3D DW_TAG_union_type)=
 {
> > +             Dwarf_Word size;
> > +
> > +             if (dwarf_aggregate_size(type_die, &size) < 0)
> > +                     size =3D 0;
> > +
> > +             if ((unsigned)offset >=3D size)
> > +                     return NULL;
> > +
> > +             *die_mem =3D *type_die;
> > +             return die_mem;
> > +     }
> > +
> > +     mb_type =3D *type_die;
> > +     /* TODO: Handle union types better? */
> > +     while (tag =3D=3D DW_TAG_structure_type || tag =3D=3D DW_TAG_unio=
n_type) {
> > +             member =3D die_find_child(&mb_type, __die_find_member_off=
set_cb,
> > +                                     (void *)(long)offset, die_mem);
> > +             if (member =3D=3D NULL)
> > +                     return NULL;
> > +
> > +             if (die_get_real_type(member, &mb_type) =3D=3D NULL)
> > +                     return NULL;
> > +
> > +             tag =3D dwarf_tag(&mb_type);
> > +
> > +             if (tag =3D=3D DW_TAG_structure_type || tag =3D=3D DW_TAG=
_union_type) {
> > +                     Dwarf_Word loc;
> > +
> > +                     /* Update offset for the start of the member stru=
ct */
> > +                     if (die_get_data_member_location(member, &loc) =
=3D=3D 0)
> > +                             offset -=3D loc;
> > +             }
> > +     }
> > +     *die_mem =3D mb_type;
> > +     return die_mem;
> > +}
> > +
> > +/**
> > + * die_deref_ptr_type - Return type info for pointer access
> > + * @ptr_die: a pointer type DIE
> > + * @offset: access offset for the pointer
> > + * @die_mem: a buffer to save the resulting DIE
> > + *
> > + * This function follows the pointer in @ptr_die with given @offset
> > + * and saves the resulting type in @die_mem.  If the pointer points
> > + * a struct type, actual member at the offset would be returned.
> > + */
> > +Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset,
> > +                           Dwarf_Die *die_mem)
> > +{
> > +     Dwarf_Die type_die;
> > +
> > +     if (dwarf_tag(ptr_die) !=3D DW_TAG_pointer_type)
> > +             return NULL;
> > +
> > +     if (die_get_real_type(ptr_die, &type_die) =3D=3D NULL)
> > +             return NULL;
> > +
> > +     return die_get_member_type(&type_die, offset, die_mem);
> > +}
> > diff --git a/tools/perf/util/dwarf-aux.h b/tools/perf/util/dwarf-aux.h
> > index cd171b06fd4c..16c916311bc0 100644
> > --- a/tools/perf/util/dwarf-aux.h
> > +++ b/tools/perf/util/dwarf-aux.h
> > @@ -144,6 +144,12 @@ struct die_var_type {
> >       int offset;
> >  };
> >
> > +/* Return type info of a member at offset */
> > +Dwarf_Die *die_get_member_type(Dwarf_Die *type_die, int offset, Dwarf_=
Die *die_mem);
> > +
> > +/* Return type info where the pointer and offset point to */
> > +Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset, Dwarf_Di=
e *die_mem);
> > +
> >  #ifdef HAVE_DWARF_GETLOCATIONS_SUPPORT
> >
> >  /* Get byte offset range of given variable DIE */
> > --
> > 2.44.0.291.gc1ea87d7ee-goog