Received-SPF: pass (google.com: domain of linux-kernel+bounces-50879-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: <20240202220459.527138-1-namhyung@kernel.org> <20240202220459.527138-7-namhyung@kernel.org>
In-Reply-To: <20240202220459.527138-7-namhyung@kernel.org>
From: Ian Rogers <irogers@google.com>
Date: Fri, 2 Feb 2024 18:44:53 -0800
Message-ID: <CAP-5=fX-LASq92NCAd-8+41S9Bo_8xiH7iEGvKZqRbSdM-9zkw@mail.gmail.com>
Subject: Re: [PATCH 06/14] perf annotate-data: Maintain variable type info
To: Namhyung Kim <namhyung@kernel.org>
Cc: Arnaldo Carvalho de Melo <acme@kernel.org>, 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 Fri, Feb 2, 2024 at 2:05=E2=80=AFPM Namhyung Kim <namhyung@kernel.org> w=
rote:
>
> As it collected basic block and variable information in each scope, it
> now can build a state table to find matching variable at the location.
>
> The struct type_state is to keep the type info saved in each register
> and stack slot.  The update_var_state() updates the table when it finds
> variables in the current address.  It expects die_collect_vars() filled
> a list of variables with type info and starting address.
>
> Signed-off-by: Namhyung Kim <namhyung@kernel.org>
> ---
>  tools/perf/util/annotate-data.c | 155 ++++++++++++++++++++++++++++++++
>  tools/perf/util/annotate-data.h |  29 ++++++
>  tools/perf/util/dwarf-aux.c     |   4 +
>  3 files changed, 188 insertions(+)
>
> diff --git a/tools/perf/util/annotate-data.c b/tools/perf/util/annotate-d=
ata.c
> index b8e60c42af8c..f8768c224bcc 100644
> --- a/tools/perf/util/annotate-data.c
> +++ b/tools/perf/util/annotate-data.c
> @@ -23,6 +23,57 @@
>  #include "symbol.h"
>  #include "symbol_conf.h"
>
> +/* Type information in a register, valid when ok is true */
> +struct type_state_reg {
> +       Dwarf_Die type;
> +       bool ok;
> +       bool scratch;
> +};
> +
> +/* Type information in a stack location, dynamically allocated */
> +struct type_state_stack {
> +       struct list_head list;
> +       Dwarf_Die type;
> +       int offset;
> +       int size;
> +       bool compound;
> +};
> +
> +/* FIXME: This should be arch-dependent */
> +#define TYPE_STATE_MAX_REGS  16

Perhaps 32, presumably 16 won't work on Arm64.

Thanks,
Ian

> +
> +/*
> + * State table to maintain type info in each register and stack location=
.
> + * It'll be updated when new variable is allocated or type info is moved
> + * to a new location (register or stack).  As it'd be used with the
> + * shortest path of basic blocks, it only maintains a single table.
> + */
> +struct type_state {
> +       struct type_state_reg regs[TYPE_STATE_MAX_REGS];
> +       struct list_head stack_vars;
> +};
> +
> +static bool has_reg_type(struct type_state *state, int reg)
> +{
> +       return (unsigned)reg < ARRAY_SIZE(state->regs);
> +}
> +
> +void init_type_state(struct type_state *state, struct arch *arch __maybe=
_unused)
> +{
> +       memset(state, 0, sizeof(*state));
> +       INIT_LIST_HEAD(&state->stack_vars);
> +}
> +
> +void exit_type_state(struct type_state *state)
> +{
> +       struct type_state_stack *stack, *tmp;
> +
> +       list_for_each_entry_safe(stack, tmp, &state->stack_vars, list) {
> +               list_del(&stack->list);
> +               free(stack);
> +       }
> +}
> +
>  /*
>   * Compare type name and size to maintain them in a tree.
>   * I'm not sure if DWARF would have information of a single type in many
> @@ -238,6 +289,110 @@ static int check_variable(Dwarf_Die *var_die, Dwarf=
_Die *type_die, int offset,
>         return 0;
>  }
>
> +static struct type_state_stack *find_stack_state(struct type_state *stat=
e,
> +                                                int offset)
> +{
> +       struct type_state_stack *stack;
> +
> +       list_for_each_entry(stack, &state->stack_vars, list) {
> +               if (offset =3D=3D stack->offset)
> +                       return stack;
> +
> +               if (stack->compound && stack->offset < offset &&
> +                   offset < stack->offset + stack->size)
> +                       return stack;
> +       }
> +       return NULL;
> +}
> +
> +static void set_stack_state(struct type_state_stack *stack, int offset,
> +                           Dwarf_Die *type_die)
> +{
> +       int tag;
> +       Dwarf_Word size;
> +
> +       if (dwarf_aggregate_size(type_die, &size) < 0)
> +               size =3D 0;
> +
> +       tag =3D dwarf_tag(type_die);
> +
> +       stack->type =3D *type_die;
> +       stack->size =3D size;
> +       stack->offset =3D offset;
> +
> +       switch (tag) {
> +       case DW_TAG_structure_type:
> +       case DW_TAG_union_type:
> +               stack->compound =3D true;
> +               break;
> +       default:
> +               stack->compound =3D false;
> +               break;
> +       }
> +}
> +
> +static struct type_state_stack *findnew_stack_state(struct type_state *s=
tate,
> +                                                   int offset, Dwarf_Die=
 *type_die)
> +{
> +       struct type_state_stack *stack =3D find_stack_state(state, offset=
);
> +
> +       if (stack) {
> +               set_stack_state(stack, offset, type_die);
> +               return stack;
> +       }
> +
> +       stack =3D malloc(sizeof(*stack));
> +       if (stack) {
> +               set_stack_state(stack, offset, type_die);
> +               list_add(&stack->list, &state->stack_vars);
> +       }
> +       return stack;
> +}
> +
> +/**
> + * update_var_state - Update type state using given variables
> + * @state: type state table
> + * @dloc: data location info
> + * @addr: instruction address to update
> + * @var_types: list of variables with type info
> + *
> + * This function fills the @state table using @var_types info.  Each var=
iable
> + * is used only at the given location and updates an entry in the table.
> + */
> +void update_var_state(struct type_state *state, struct data_loc_info *dl=
oc,
> +                     u64 addr, struct die_var_type *var_types)
> +{
> +       Dwarf_Die mem_die;
> +       struct die_var_type *var;
> +       int fbreg =3D dloc->fbreg;
> +       int fb_offset =3D 0;
> +
> +       if (dloc->fb_cfa) {
> +               if (die_get_cfa(dloc->di->dbg, addr, &fbreg, &fb_offset) =
< 0)
> +                       fbreg =3D -1;
> +       }
> +
> +       for (var =3D var_types; var !=3D NULL; var =3D var->next) {
> +               if (var->addr !=3D addr)
> +                       continue;
> +               /* Get the type DIE using the offset */
> +               if (!dwarf_offdie(dloc->di->dbg, var->die_off, &mem_die))
> +                       continue;
> +
> +               if (var->reg =3D=3D DWARF_REG_FB) {
> +                       findnew_stack_state(state, var->offset, &mem_die)=
;
> +               } else if (var->reg =3D=3D fbreg) {
> +                       findnew_stack_state(state, var->offset - fb_offse=
t, &mem_die);
> +               } else if (has_reg_type(state, var->reg)) {
> +                       struct type_state_reg *reg;
> +
> +                       reg =3D &state->regs[var->reg];
> +                       reg->type =3D mem_die;
> +                       reg->ok =3D true;
> +               }
> +       }
> +}
> +
>  /* The result will be saved in @type_die */
>  static int find_data_type_die(struct data_loc_info *dloc, Dwarf_Die *typ=
e_die)
>  {
> diff --git a/tools/perf/util/annotate-data.h b/tools/perf/util/annotate-d=
ata.h
> index ad6493ea2c8e..7fbb9eb2e96f 100644
> --- a/tools/perf/util/annotate-data.h
> +++ b/tools/perf/util/annotate-data.h
> @@ -8,9 +8,12 @@
>  #include <linux/types.h>
>
>  struct annotated_op_loc;
> +struct arch;
>  struct debuginfo;
> +struct die_var_type;
>  struct evsel;
>  struct map_symbol;
> +struct type_state;
>
>  /**
>   * struct annotated_member - Type of member field
> @@ -146,6 +149,16 @@ int annotated_data_type__update_samples(struct annot=
ated_data_type *adt,
>  /* Release all data type information in the tree */
>  void annotated_data_type__tree_delete(struct rb_root *root);
>
> +/* Initialize type state table */
> +void init_type_state(struct type_state *state, struct arch *arch);
> +
> +/* Destroy type state table */
> +void exit_type_state(struct type_state *state);
> +
> +/* Update type state table using variables */
> +void update_var_state(struct type_state *state, struct data_loc_info *dl=
oc,
> +                     u64 addr, struct die_var_type *var_types);
> +
>  #else /* HAVE_DWARF_SUPPORT */
>
>  static inline struct annotated_data_type *
> @@ -168,6 +181,22 @@ static inline void annotated_data_type__tree_delete(=
struct rb_root *root __maybe
>  {
>  }
>
> +static inline void init_type_state(struct type_state *state __maybe_unus=
ed,
> +                                  struct arch *arch __maybe_unused)
> +{
> +}
> +
> +static inline void exit_type_state(struct type_state *state __maybe_unus=
ed)
> +{
> +}
> +
> +static inline void update_var_state(struct type_state *state __maybe_unu=
sed,
> +                                   struct data_loc_info *dloc __maybe_un=
used,
> +                                   u64 addr __maybe_unused,
> +                                   struct die_var_type *var_types __mayb=
e_unused)
> +{
> +}
> +
>  #endif /* HAVE_DWARF_SUPPORT */
>
>  #endif /* _PERF_ANNOTATE_DATA_H */
> diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
> index 39851ff1d5c4..f88a8fb4a350 100644
> --- a/tools/perf/util/dwarf-aux.c
> +++ b/tools/perf/util/dwarf-aux.c
> @@ -9,6 +9,7 @@
>  #include <stdlib.h>
>  #include "debug.h"
>  #include "dwarf-aux.h"
> +#include "dwarf-regs.h"
>  #include "strbuf.h"
>  #include "string2.h"
>
> @@ -1147,6 +1148,8 @@ static int reg_from_dwarf_op(Dwarf_Op *op)
>         case DW_OP_regx:
>         case DW_OP_bregx:
>                 return op->number;
> +       case DW_OP_fbreg:
> +               return DWARF_REG_FB;
>         default:
>                 break;
>         }
> @@ -1160,6 +1163,7 @@ static int offset_from_dwarf_op(Dwarf_Op *op)
>         case DW_OP_regx:
>                 return 0;
>         case DW_OP_breg0 ... DW_OP_breg31:
> +       case DW_OP_fbreg:
>                 return op->number;
>         case DW_OP_bregx:
>                 return op->number2;
> --
> 2.43.0.594.gd9cf4e227d-goog
>