From nobody Fri Sep 25 08:46:24 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6823D424641; Tue, 15 Sep 2026 06:40:41 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789454442; cv=none; b=J7wmfZy5kP9IajpIvYswKboeo6aJqmg7ikHkdvvuIZWGnBl0YCCirMBWo+nrPz49Bv/wed8xyflWPonbL9WtpKpBpdnw6ex52pzDq/73b9chtmTi8OB1rG8i2o/DchNc6NJtI/7wdA+l6XV1MeTAm02/8u8O95Llro9o29AMYgo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789454442; c=relaxed/simple; bh=5INeG7s+aX8SaHzUhq8rxK/zazt2ZoUWXJa/v3QX8Qg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=p8METDDl//xZ/8YjhqiG+bF+rFBUrNBP6YYB4+O+Omspbq9RHYeL7oShbIF8jMwMu0z5e9huj3dcv/bCPNcziJnUvaLjJ3XhzoovoASbTiG30flTrr4kCv+Ru939kXt0n5qL+qH6x+6hyx6yRIm50ELF8GP8BgoFqRnTUIHzOqw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=VLa/uNY9; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="VLa/uNY9" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8C0F91F00899; Tue, 15 Sep 2026 06:40:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1789454441; bh=qIENcBQsxO94LjSgl8tZtlEd/T8ffqoxUVG6SR+pF70=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=VLa/uNY9zz+NehQV9EizFSAliryGHdBW7PYEDeSs3xE/r+KSnNfOFabJ1ceTyQFFA 317amguQpUcxEEBbuEtliOE7nIHq545jmtreZQrvrKktOuDHqIRJm2d9mEcklG+chx PcoZDlwcA1f/z9+RkYlbgt1w94ZNukzLvl5CR03abPBEMIvxQmYek7iq+tmwRuw8KI tnpkMCiQXKk/asO9xhYxb8A59pvOOM6CVCJZ4LuStUBpbCKI1F9L8GRQRTBfmoCFxk xxnV3tpkmgSxn78r5u2hF7E6E1V/71RxgQS1fbWb8B4Sg8RlCdt/p3tB+yFPt1IkZi +9euZ0XO2O/LQ== From: Namhyung Kim To: Arnaldo Carvalho de Melo Cc: Ian Rogers , Jiri Olsa , Adrian Hunter , James Clark , Peter Zijlstra , Ingo Molnar , LKML , linux-perf-users@vger.kernel.org, Zecheng Li , Yanbo Zhao , Tengda Wu , Shuai Xue , Masami Hiramatsu Subject: [PATCH v3 1/3] perf dwarf-aux: Add die_has_flex_array() helper Date: Mon, 14 Sep 2026 23:40:33 -0700 Message-ID: <20260915064035.1970175-2-namhyung@kernel.org> X-Mailer: git-send-email 2.55.0.1082.g2b9226bbc0-goog In-Reply-To: <20260915064035.1970175-1-namhyung@kernel.org> References: <20260915064035.1970175-1-namhyung@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The die_has_flex_array() returns true when the given type is a compound type and contains an array at the end. To prevent an infinite recursion add a depth field to the internal function. Cc: Masami Hiramatsu Signed-off-by: Namhyung Kim Acked-by: Masami Hiramatsu (Google) --- tools/perf/util/dwarf-aux.c | 97 +++++++++++++++++++++++++++++++++++++ tools/perf/util/dwarf-aux.h | 3 ++ 2 files changed, 100 insertions(+) diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c index d7160f87ac7d7ab3..a5aefe7d1d62d090 100644 --- a/tools/perf/util/dwarf-aux.c +++ b/tools/perf/util/dwarf-aux.c @@ -7,6 +7,7 @@ #include #include #include +#include #include "debug.h" #include "dwarf-aux.h" #include "dwarf-regs.h" @@ -2180,3 +2181,99 @@ Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, in= t offset, =20 return die_get_member_type(&type_die, offset, die_mem); } + +static bool is_flex_array_member(Dwarf_Die *mb_die) +{ + Dwarf_Die type_die; + Dwarf_Word size; + + /* get the type of the member */ + if (die_get_real_type(mb_die, &type_die) =3D=3D NULL) + return false; + + if (dwarf_tag(&type_die) !=3D DW_TAG_array_type) + return false; + + return dwarf_aggregate_size(&type_die, &size) < 0 || size =3D=3D 0; +} + +#define MAX_FLEX_ARRAY_RECURSION 256 /* arbitrary */ + +static bool die_has_flex_array_recurse(Dwarf_Die *parent_die, int depth) +{ + Dwarf_Die die_mem, last_mb; + int tag =3D dwarf_tag(parent_die); + bool found =3D false; + Dwarf_Word loc, last_loc =3D 0; + + if (tag !=3D DW_TAG_structure_type && tag !=3D DW_TAG_union_type) + return false; + + /* prevent infinite recursion */ + if (depth > MAX_FLEX_ARRAY_RECURSION) + return false; + + if (dwarf_child(parent_die, &die_mem)) + return false; + + do { + if (dwarf_tag(&die_mem) !=3D DW_TAG_member) + continue; + + if (tag =3D=3D DW_TAG_union_type) { + if (is_flex_array_member(&die_mem)) + return true; + + if (die_get_real_type(&die_mem, &last_mb) && + die_has_flex_array_recurse(&last_mb, depth + 1)) + return true; + } + + if (tag =3D=3D DW_TAG_structure_type) { + if (die_get_data_member_location(&die_mem, &loc) < 0) + loc =3D 0; + + if (!found || last_loc < loc) { + memcpy(&last_mb, &die_mem, sizeof(last_mb)); + last_loc =3D loc; + } + } + + found =3D true; + } while (dwarf_siblingof(&die_mem, &die_mem) =3D=3D 0); + + if (tag =3D=3D DW_TAG_structure_type && found) { + if (is_flex_array_member(&last_mb)) + return true; + + if (die_get_real_type(&last_mb, &die_mem)) + return die_has_flex_array_recurse(&die_mem, depth + 1); + } + + return false; +} + +/** + * die_has_flex_array - Check if the given type has a flex-array at the end + * @type_die: a pointer to type DIE + * + * This function returns %true iff @type_die is a struct type and has an + * array at the end. Note that the flex-array has no element, it should h= ave + * no size and the parent size doesn't include the flex-array. So it shou= ld + * locate at the offset of the parent size. + * + * For simplicity, it assumes the parent size of aligned with the flex-arr= ay. + */ +bool die_has_flex_array(Dwarf_Die *type_die) +{ + Dwarf_Die real_type; + + if (dwarf_tag(type_die) =3D=3D DW_TAG_typedef) { + if (die_get_real_type(type_die, &real_type) =3D=3D NULL) + return false; + + type_die =3D &real_type; + } + + return die_has_flex_array_recurse(type_die, 0); +} diff --git a/tools/perf/util/dwarf-aux.h b/tools/perf/util/dwarf-aux.h index 161f0bf980b6ee6a..9b662db710220522 100644 --- a/tools/perf/util/dwarf-aux.h +++ b/tools/perf/util/dwarf-aux.h @@ -189,4 +189,7 @@ void die_collect_global_vars(Dwarf_Die *cu_die, struct = die_var_type **var_types) /* Get the frame base information from CFA */ int die_get_cfa(Dwarf *dwarf, u64 pc, int *preg, int *poffset); =20 +/* Check whether given type has a flex array */ +bool die_has_flex_array(Dwarf_Die *parent_die); + #endif /* _DWARF_AUX_H */ --=20 2.55.0.1082.g2b9226bbc0-goog From nobody Fri Sep 25 08:46:24 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BA40A42902E; Tue, 15 Sep 2026 06:40:41 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789454443; cv=none; b=X/exyE8tO8ZxiXJdHLZ0Xq+CUbuog7JFBUAB94hOgQBVB/tyv50kAqWtvxamGZxjf4nkMea6uJYla1WKei4PlOmcoj7mfxhsPBP+kjNiGcNK9gokEv0/y2cCs8hAeSCkJdjb5LSo8+BUAHqt7AYYWK3g7eeEjiIxGUv71eirADo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789454443; c=relaxed/simple; bh=RI6tZtIIzGIQFJ+xsVri2MLvcptS6c7Hi2l2YV+6MAQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BZaonzyt/y9P/a5lSr1KpLzZbh1hzDNP0FaxtOGC+R/++P8DWQg6POgqncsoctvLdMm7yElhJmyV5IQ5mOBJIufIV1Mim5HIZYs+nvortt9knqnj928bZh2JV3CU4yLybHlVCXIGv0E3+44jPpoi43yvYNDPdHHGgcakGBfAsqg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=R5IXkHxk; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="R5IXkHxk" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 337EC1F00893; Tue, 15 Sep 2026 06:40:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1789454441; bh=lidfxj0j6v8CyF9hCR2LKoYiQPRjEweGxhqs/Ke+j60=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=R5IXkHxkHLE2E0EbrHjnMj5AFgH63QlOf4TIU0/TU8bilVlDxMmjpNrZI2t37bZdb rHpTyf0wnz5isj+rBOS6pSVDIW5eeD5AjEUnlW8gIHLQFSP7OYH6Ug15kBoTWD/6Ze ORgRHHFbr532EFSce7UXAXRpBlQ5nbL2cbdKacfHor5us7LM7aSamfDy9S1/aWlmMY sf37qVmVCroDhWh4tQfHffqcrR7n8qYSvGodtOBS2IqCB6R43/B2ewCVqetlGQ5sn8 H9iP11Iv4ejjkM5gEUHmjbYh4qy6QIqqvmJ4Dvjuw4VhEyhsGso3CDi7dWMOCpTvGD SmiXPFlgrLKFw== From: Namhyung Kim To: Arnaldo Carvalho de Melo Cc: Ian Rogers , Jiri Olsa , Adrian Hunter , James Clark , Peter Zijlstra , Ingo Molnar , LKML , linux-perf-users@vger.kernel.org, Zecheng Li , Yanbo Zhao , Tengda Wu , Shuai Xue Subject: [PATCH v3 2/3] perf annotate-date: Allow out-of-size access for flex-array types Date: Mon, 14 Sep 2026 23:40:34 -0700 Message-ID: <20260915064035.1970175-3-namhyung@kernel.org> X-Mailer: git-send-email 2.55.0.1082.g2b9226bbc0-goog In-Reply-To: <20260915064035.1970175-1-namhyung@kernel.org> References: <20260915064035.1970175-1-namhyung@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Structs that have a flex array will have accesses beyond its original size as the array was declared as 0 sized. For now, it just allow any offset bigger than the size. It could be refined later. Signed-off-by: Namhyung Kim --- tools/perf/util/annotate-data.c | 63 ++++++++++++++++++--------------- tools/perf/util/annotate-data.h | 2 ++ 2 files changed, 36 insertions(+), 29 deletions(-) diff --git a/tools/perf/util/annotate-data.c b/tools/perf/util/annotate-dat= a.c index aff60a630fd05b01..1ee2b74f99205567 100644 --- a/tools/perf/util/annotate-data.c +++ b/tools/perf/util/annotate-data.c @@ -7,6 +7,7 @@ #include #include #include +#include #include #include =20 @@ -248,8 +249,15 @@ static int __add_member_cb(Dwarf_Die *die, void *arg) else die_mem =3D member_type; =20 - if (dwarf_aggregate_size(&die_mem, &size) < 0) - size =3D 0; + if (dwarf_aggregate_size(&die_mem, &size) < 0) { + if (dwarf_tag(&die_mem) =3D=3D DW_TAG_array_type) { /* flex-array? */ + die_get_real_type(&die_mem, &die_mem); + if (dwarf_aggregate_size(&die_mem, &size) < 0) + size =3D 0; + } else { + size =3D 0; + } + } =20 if (dwarf_attr_integrate(die, DW_AT_data_member_location, &attr)) { if (dwarf_formudata(&attr, &loc) !=3D 0) { @@ -399,6 +407,7 @@ static struct annotated_data_type *dso__findnew_data_ty= pe(struct dso *dso, result->self.type_name =3D type_name; result->self.size =3D size; INIT_LIST_HEAD(&result->self.children); + result->flex_array =3D die_has_flex_array(type_die); =20 if (symbol_conf.annotate_data_member) add_member_types(result, type_die); @@ -517,13 +526,30 @@ static bool is_better_type(Dwarf_Die *type_a, Dwarf_D= ie *type_b) return false; } =20 +static enum type_match_result check_type_offset(Dwarf_Die *type_die, int o= ffset) +{ + Dwarf_Word size; + + /* Get the size of the actual type */ + if (dwarf_aggregate_size(type_die, &size) < 0) + return PERF_TMR_NO_SIZE; + + /* Minimal sanity check */ + if (offset < 0) + return PERF_TMR_BAD_OFFSET; + + if ((unsigned)offset >=3D size && !die_has_flex_array(type_die)) + return PERF_TMR_BAD_OFFSET; + + return PERF_TMR_OK; +} + /* The type info will be saved in @type_die */ static enum type_match_result check_variable(struct data_loc_info *dloc, Dwarf_Die *var_die, Dwarf_Die *type_die, int reg, int offset, bool is_fbreg) { - Dwarf_Word size; bool needs_pointer =3D true; Dwarf_Die sized_type; =20 @@ -554,15 +580,7 @@ static enum type_match_result check_variable(struct da= ta_loc_info *dloc, else sized_type =3D *type_die; =20 - /* Get the size of the actual type */ - if (dwarf_aggregate_size(&sized_type, &size) < 0) - return PERF_TMR_NO_SIZE; - - /* Minimal sanity check */ - if ((unsigned)offset >=3D size) - return PERF_TMR_BAD_OFFSET; - - return PERF_TMR_OK; + return check_type_offset(&sized_type, offset); } =20 struct type_state_stack *find_stack_state(struct type_state *state, @@ -1112,7 +1130,6 @@ static enum type_match_result check_matching_type(str= uct type_state *state, struct disasm_line *dl, Dwarf_Die *type_die) { - Dwarf_Word size; u32 insn_offset =3D dl->al.offset; int reg =3D dloc->op->reg1; int offset =3D dloc->op->offset; @@ -1166,12 +1183,7 @@ static enum type_match_result check_matching_type(st= ruct type_state *state, else sized_type =3D *type_die; =20 - /* Get the size of the actual type */ - if (dwarf_aggregate_size(&sized_type, &size) < 0 || - (unsigned)dloc->type_offset >=3D size) - return PERF_TMR_BAD_OFFSET; - - return PERF_TMR_OK; + return check_type_offset(&sized_type, dloc->type_offset); } =20 if (state->regs[reg].kind =3D=3D TSR_KIND_POINTER) { @@ -1190,12 +1202,7 @@ static enum type_match_result check_matching_type(st= ruct type_state *state, =20 dloc->type_offset =3D dloc->op->offset + state->regs[reg].offset; =20 - /* Get the size of the actual type */ - if (dwarf_aggregate_size(type_die, &size) < 0 || - (unsigned)dloc->type_offset >=3D size) - return PERF_TMR_BAD_OFFSET; - - return PERF_TMR_OK; + return check_type_offset(type_die, dloc->type_offset); } =20 if (state->regs[reg].kind =3D=3D TSR_KIND_PERCPU_POINTER) { @@ -1209,9 +1216,7 @@ static enum type_match_result check_matching_type(str= uct type_state *state, =20 dloc->type_offset =3D dloc->op->offset; =20 - /* Get the size of the actual type */ - if (dwarf_aggregate_size(type_die, &size) < 0 || - (unsigned)dloc->type_offset >=3D size) + if (check_type_offset(type_die, dloc->type_offset) !=3D PERF_TMR_OK) return PERF_TMR_BAIL_OUT; =20 return PERF_TMR_OK; @@ -1839,7 +1844,7 @@ int annotated_data_type__update_samples(struct annota= ted_data_type *adt, return -1; } =20 - if (offset < 0 || offset >=3D adt->self.size) + if (offset < 0 || (offset >=3D adt->self.size && !adt->flex_array)) return -1; =20 h =3D &adt->histograms[evsel->core.idx]; diff --git a/tools/perf/util/annotate-data.h b/tools/perf/util/annotate-dat= a.h index ca2096a9ee62cbfe..957726334907cc0e 100644 --- a/tools/perf/util/annotate-data.h +++ b/tools/perf/util/annotate-data.h @@ -85,6 +85,7 @@ struct type_hist { * struct annotated_data_type - Data type to profile * @node: RB-tree node for dso->type_tree * @self: Actual type information + * @flex_array: Whether it has a flex array * @nr_histogram: Number of histogram entries * @histograms: An array of histograms * @@ -93,6 +94,7 @@ struct type_hist { struct annotated_data_type { struct rb_node node; struct annotated_member self; + bool flex_array; int nr_histograms; struct type_hist *histograms; }; --=20 2.55.0.1082.g2b9226bbc0-goog From nobody Fri Sep 25 08:46:24 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 85B6B2F8E98; Tue, 15 Sep 2026 06:40:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789454443; cv=none; b=C4Yqaxs6wXTaAOPAgijkbvbX7+EGPAMlGLzFow4DwiPFVh8KUlLaA5DlTZDS4qF48ANLUpypaHp066+undPVumDlU4VFWnPfKSTvHm4Wz3JDwDL3sIPNCeh5TAcg5HEJBGN4EFHe2X7TR/D4uLzYd7/853z8hdQqKaGK4xpyrJ8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789454443; c=relaxed/simple; bh=E9Si2OLdLKJDCRlVA+K3/QMtHNdDsTAiYITsNFszYd8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Uyd1Tyt08BBIoQB/tXTELfa3rh4QuBI5aGVZU92d0caaaSnXgn8OMI1goikIUtef2RmqGvnq+F3dSCv/4fQTe0kU2ubAydXxmFfAlFljFAs3O4V1BMma1F1kLV2g4pt0KJjlEB3TB0tx9WsRODevl8//D4uppJwxu9pKnydiGx0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=n5AJMUiw; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="n5AJMUiw" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C76171F00898; Tue, 15 Sep 2026 06:40:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1789454442; bh=UFXstwGzfVCmjcpWJEqcYHIuvCIqu0LCDSe4kkGOu+o=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=n5AJMUiwYphJRPyVhT6ZVeShyPe2r96KJCQuuqRUg/Ne//Bm0riD0EmQpGMcA3EYT eCoqvdtKUIx9yYwt8GQ59bhavtMecz2Q1xGNwvs6EqbuE2qfEETGCRyjrs8Q2S9mDK vWJXBeP3WP2TufNvoawRBg7P1SWj0mEAEottVPxisPSHSWqAddM/Ft3TxP8X43QZBP NrzB0Vc3ZWP2Du43iHJJWcKKcgCVXoDYQN2Rnwi/szpluYDHAoKunZWcbTWLJ7Q0Ao WkJ1niBtE0iMuwHytHkRC1dnQekhrM/ZZ8q/5QZCvonjFoHdIAzKSncCJiE4bkDQPp rSUHiVd4850MQ== From: Namhyung Kim To: Arnaldo Carvalho de Melo Cc: Ian Rogers , Jiri Olsa , Adrian Hunter , James Clark , Peter Zijlstra , Ingo Molnar , LKML , linux-perf-users@vger.kernel.org, Zecheng Li , Yanbo Zhao , Tengda Wu , Shuai Xue Subject: [PATCH v3 3/3] perf annotate-data: Adjust type offset for flex-array Date: Mon, 14 Sep 2026 23:40:35 -0700 Message-ID: <20260915064035.1970175-4-namhyung@kernel.org> X-Mailer: git-send-email 2.55.0.1082.g2b9226bbc0-goog In-Reply-To: <20260915064035.1970175-1-namhyung@kernel.org> References: <20260915064035.1970175-1-namhyung@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The flex array members are located beyond the original type size. Also it needs to adjust the offset in an array to find a corresponding element using module operation. Note that we focus on access to type and field, so array index is not important. Make sure to find a field name for flex arrays. Signed-off-by: Namhyung Kim --- tools/perf/util/annotate-data.c | 77 ++++++++++++++++++++++++++++++--- 1 file changed, 70 insertions(+), 7 deletions(-) diff --git a/tools/perf/util/annotate-data.c b/tools/perf/util/annotate-dat= a.c index 1ee2b74f99205567..1c19b807c4f2179d 100644 --- a/tools/perf/util/annotate-data.c +++ b/tools/perf/util/annotate-data.c @@ -241,7 +241,8 @@ static int __add_member_cb(Dwarf_Die *die, void *arg) return DIE_FIND_CB_END; =20 strbuf_init(&sb, 32); - die_get_typename(die, &sb); + if (die_get_typename(die, &sb) < 0) + strbuf_add(&sb, "(unknown type)", 14); =20 __die_get_real_type(die, &member_type); if (dwarf_tag(&member_type) =3D=3D DW_TAG_typedef) @@ -333,19 +334,40 @@ static void delete_members(struct annotated_member *m= ember) } =20 static int fill_member_name(char *buf, size_t sz, struct annotated_member = *m, - int offset, bool first) + int offset, bool first, bool has_flex_array) { struct annotated_member *child; + bool found =3D false; + int len; =20 if (list_empty(&m->children)) return 0; =20 list_for_each_entry(child, &m->children, node) { - int len; - if (offset < child->offset || offset >=3D child->offset + child->size) continue; =20 + found =3D true; + break; + } + + if (!found && has_flex_array) { + /* + * It may have an intermediate struct that has another struct that + * contains a flex array. In that case, the outer struct itself is + * has no array and the size is less than the offset so the above + * logic won't find the outer struct at the offset. Let's use the + * last struct if it couldn't find a member for the flex array. + */ + child =3D list_last_entry(&m->children, struct annotated_member, node); + + if (offset < child->offset) + return 0; + + found =3D true; + } + + if (found) { /* It can have anonymous struct/union members */ if (child->var_name) { len =3D scnprintf(buf, sz, "%s%s", @@ -355,15 +377,37 @@ static int fill_member_name(char *buf, size_t sz, str= uct annotated_member *m, len =3D 0; } =20 - return fill_member_name(buf + len, sz - len, child, offset, first) + len; + return fill_member_name(buf + len, sz - len, child, offset, first, + has_flex_array) + len; } + return 0; } =20 int annotated_data_type__get_member_name(struct annotated_data_type *adt, char *buf, size_t sz, int member_offset) { - return fill_member_name(buf, sz, &adt->self, member_offset, /*first=3D*/t= rue); + return fill_member_name(buf, sz, &adt->self, member_offset, /*first=3D*/t= rue, + adt->flex_array); +} + +static struct annotated_member *find_flex_array(struct annotated_member *m) +{ + struct annotated_member *child; + + if (list_empty(&m->children)) + return NULL; + + child =3D list_last_entry(&m->children, struct annotated_member, node); + if (strstr(child->type_name, "[]")) + return child; + + return find_flex_array(child); +} + +static struct annotated_member *get_flex_array_member(struct annotated_dat= a_type *adt) +{ + return find_flex_array(&adt->self); } =20 static struct annotated_data_type *dso__findnew_data_type(struct dso *dso, @@ -1740,6 +1784,7 @@ struct annotated_data_type *find_data_type(struct dat= a_loc_info *dloc) { struct dso *dso =3D map__dso(dloc->ms->map); Dwarf_Die type_die; + struct annotated_data_type *result; =20 /* * The type offset is the same as instruction offset by default. @@ -1752,7 +1797,25 @@ struct annotated_data_type *find_data_type(struct da= ta_loc_info *dloc) if (find_data_type_die(dloc, &type_die) < 0) return NULL; =20 - return dso__findnew_data_type(dso, &type_die); + result =3D dso__findnew_data_type(dso, &type_die); + if (result =3D=3D NULL) + return NULL; + + if (result->flex_array && dloc->type_offset > result->self.size) { + struct annotated_member *flex_array =3D get_flex_array_member(result); + + if (flex_array && flex_array->size > 0) { + int offset =3D dloc->type_offset; + + /* adjust offset in the flex array */ + offset -=3D flex_array->offset; + offset %=3D flex_array->size; + offset +=3D flex_array->offset; + + dloc->type_offset =3D offset; + } + } + return result; } =20 static size_t data_type_hash(long key, void *ctx __maybe_unused) --=20 2.55.0.1082.g2b9226bbc0-goog