From: pengdonglin <pengdonglin@xiaomi.com>

This introduces a new BTF sorting phase that specifically sorts
BTF types by name in ascending order, so that the binary search
can be used to look up types.

Cc: Eduard Zingerman <eddyz87@gmail.com>
Cc: Alexei Starovoitov <ast@kernel.org>
Cc: Andrii Nakryiko <andrii.nakryiko@gmail.com>
Cc: Alan Maguire <alan.maguire@oracle.com>
Cc: Ihor Solodrai <ihor.solodrai@linux.dev>
Cc: Xiaoqin Zhang <zhangxiaoqin@xiaomi.com>
Signed-off-by: pengdonglin <pengdonglin@xiaomi.com>
Acked-by: Eduard Zingerman <eddyz87@gmail.com>
---
 tools/bpf/resolve_btfids/main.c | 68 +++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/main.c
index 3e88dc862d87..659de35748ec 100644
--- a/tools/bpf/resolve_btfids/main.c
+++ b/tools/bpf/resolve_btfids/main.c
@@ -848,6 +848,71 @@ static int dump_raw_btf(struct btf *btf, const char *out_path)
 	return 0;
 }
 
+/*
+ * Sort types by name in ascending order resulting in all
+ * anonymous types being placed before named types.
+ */
+static int cmp_type_names(const void *a, const void *b, void *priv)
+{
+	struct btf *btf = (struct btf *)priv;
+	const struct btf_type *ta = btf__type_by_id(btf, *(__u32 *)a);
+	const struct btf_type *tb = btf__type_by_id(btf, *(__u32 *)b);
+	const char *na, *nb;
+
+	na = btf__str_by_offset(btf, ta->name_off);
+	nb = btf__str_by_offset(btf, tb->name_off);
+	return strcmp(na, nb);
+}
+
+static int sort_btf_by_name(struct btf *btf)
+{
+	__u32 *permute_ids = NULL, *id_map = NULL;
+	int nr_types, i, err = 0;
+	__u32 start_id = 1, id;
+
+	if (btf__base_btf(btf))
+		start_id = btf__type_cnt(btf__base_btf(btf));
+	nr_types = btf__type_cnt(btf) - start_id;
+	if (nr_types < 2)
+		goto out;
+
+	permute_ids = calloc(nr_types, sizeof(*permute_ids));
+	if (!permute_ids) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	id_map = calloc(nr_types, sizeof(*id_map));
+	if (!id_map) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	for (i = 0, id = start_id; i < nr_types; i++, id++)
+		permute_ids[i] = id;
+
+	qsort_r(permute_ids, nr_types, sizeof(*permute_ids), cmp_type_names, btf);
+
+	for (i = 0; i < nr_types; i++) {
+		id = permute_ids[i] - start_id;
+		id_map[id] = i + start_id;
+	}
+
+	err = btf__permute(btf, id_map, nr_types, NULL);
+	if (err)
+		pr_err("FAILED: btf permute: %s\n", strerror(-err));
+
+out:
+	free(permute_ids);
+	free(id_map);
+	return err;
+}
+
+static int btf2btf(struct object *obj)
+{
+	return sort_btf_by_name(obj->btf);
+}
+
 static inline int make_out_path(char *buf, u32 buf_sz, const char *in_path, const char *suffix)
 {
 	int len = snprintf(buf, buf_sz, "%s%s", in_path, suffix);
@@ -906,6 +971,9 @@ int main(int argc, const char **argv)
 	if (load_btf(&obj))
 		goto out;
 
+	if (btf2btf(&obj))
+		goto out;
+
 	if (elf_collect(&obj))
 		goto out;
 
-- 
2.34.1

On Thu, Dec 18, 2025 at 3:31 AM Donglin Peng <dolinux.peng@gmail.com> wrote:
>
> From: pengdonglin <pengdonglin@xiaomi.com>
>
> This introduces a new BTF sorting phase that specifically sorts
> BTF types by name in ascending order, so that the binary search
> can be used to look up types.
>
> Cc: Eduard Zingerman <eddyz87@gmail.com>
> Cc: Alexei Starovoitov <ast@kernel.org>
> Cc: Andrii Nakryiko <andrii.nakryiko@gmail.com>
> Cc: Alan Maguire <alan.maguire@oracle.com>
> Cc: Ihor Solodrai <ihor.solodrai@linux.dev>
> Cc: Xiaoqin Zhang <zhangxiaoqin@xiaomi.com>
> Signed-off-by: pengdonglin <pengdonglin@xiaomi.com>

Signed-off-by is supposed to use properly spelled full name, this
should be "Donglin Peng", right?

> Acked-by: Eduard Zingerman <eddyz87@gmail.com>
> ---
>  tools/bpf/resolve_btfids/main.c | 68 +++++++++++++++++++++++++++++++++
>  1 file changed, 68 insertions(+)
>
> diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/main.c
> index 3e88dc862d87..659de35748ec 100644
> --- a/tools/bpf/resolve_btfids/main.c
> +++ b/tools/bpf/resolve_btfids/main.c
> @@ -848,6 +848,71 @@ static int dump_raw_btf(struct btf *btf, const char *out_path)
>         return 0;
>  }
>
> +/*
> + * Sort types by name in ascending order resulting in all
> + * anonymous types being placed before named types.
> + */
> +static int cmp_type_names(const void *a, const void *b, void *priv)
> +{
> +       struct btf *btf = (struct btf *)priv;
> +       const struct btf_type *ta = btf__type_by_id(btf, *(__u32 *)a);
> +       const struct btf_type *tb = btf__type_by_id(btf, *(__u32 *)b);
> +       const char *na, *nb;
> +
> +       na = btf__str_by_offset(btf, ta->name_off);
> +       nb = btf__str_by_offset(btf, tb->name_off);
> +       return strcmp(na, nb);
> +}
> +
> +static int sort_btf_by_name(struct btf *btf)
> +{
> +       __u32 *permute_ids = NULL, *id_map = NULL;
> +       int nr_types, i, err = 0;
> +       __u32 start_id = 1, id;
> +
> +       if (btf__base_btf(btf))
> +               start_id = btf__type_cnt(btf__base_btf(btf));
> +       nr_types = btf__type_cnt(btf) - start_id;
> +       if (nr_types < 2)
> +               goto out;

why this check, will anything break if you don't do it?

> +
> +       permute_ids = calloc(nr_types, sizeof(*permute_ids));
> +       if (!permute_ids) {
> +               err = -ENOMEM;
> +               goto out;
> +       }
> +
> +       id_map = calloc(nr_types, sizeof(*id_map));
> +       if (!id_map) {
> +               err = -ENOMEM;
> +               goto out;
> +       }
> +
> +       for (i = 0, id = start_id; i < nr_types; i++, id++)
> +               permute_ids[i] = id;
> +
> +       qsort_r(permute_ids, nr_types, sizeof(*permute_ids), cmp_type_names, btf);
> +
> +       for (i = 0; i < nr_types; i++) {
> +               id = permute_ids[i] - start_id;
> +               id_map[id] = i + start_id;
> +       }
> +
> +       err = btf__permute(btf, id_map, nr_types, NULL);
> +       if (err)
> +               pr_err("FAILED: btf permute: %s\n", strerror(-err));
> +
> +out:
> +       free(permute_ids);
> +       free(id_map);
> +       return err;
> +}
> +
> +static int btf2btf(struct object *obj)

what's the point of having this function?

> +{
> +       return sort_btf_by_name(obj->btf);
> +}
> +
>  static inline int make_out_path(char *buf, u32 buf_sz, const char *in_path, const char *suffix)
>  {
>         int len = snprintf(buf, buf_sz, "%s%s", in_path, suffix);
> @@ -906,6 +971,9 @@ int main(int argc, const char **argv)
>         if (load_btf(&obj))
>                 goto out;
>
> +       if (btf2btf(&obj))
> +               goto out;
> +
>         if (elf_collect(&obj))
>                 goto out;
>
> --
> 2.34.1
>

On Fri, Dec 19, 2025 at 7:09 AM Andrii Nakryiko
<andrii.nakryiko@gmail.com> wrote:
>
> On Thu, Dec 18, 2025 at 3:31 AM Donglin Peng <dolinux.peng@gmail.com> wrote:
> >
> > From: pengdonglin <pengdonglin@xiaomi.com>
> >
> > This introduces a new BTF sorting phase that specifically sorts
> > BTF types by name in ascending order, so that the binary search
> > can be used to look up types.
> >
> > Cc: Eduard Zingerman <eddyz87@gmail.com>
> > Cc: Alexei Starovoitov <ast@kernel.org>
> > Cc: Andrii Nakryiko <andrii.nakryiko@gmail.com>
> > Cc: Alan Maguire <alan.maguire@oracle.com>
> > Cc: Ihor Solodrai <ihor.solodrai@linux.dev>
> > Cc: Xiaoqin Zhang <zhangxiaoqin@xiaomi.com>
> > Signed-off-by: pengdonglin <pengdonglin@xiaomi.com>
>
> Signed-off-by is supposed to use properly spelled full name, this
> should be "Donglin Peng", right?

Sorry, I will fix this in the next version. The reason is that our
company's Gerrit only accepts "pengdonglin" and does not
accept "Donglin Peng".

>
> > Acked-by: Eduard Zingerman <eddyz87@gmail.com>
> > ---
> >  tools/bpf/resolve_btfids/main.c | 68 +++++++++++++++++++++++++++++++++
> >  1 file changed, 68 insertions(+)
> >
> > diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/main.c
> > index 3e88dc862d87..659de35748ec 100644
> > --- a/tools/bpf/resolve_btfids/main.c
> > +++ b/tools/bpf/resolve_btfids/main.c
> > @@ -848,6 +848,71 @@ static int dump_raw_btf(struct btf *btf, const char *out_path)
> >         return 0;
> >  }
> >
> > +/*
> > + * Sort types by name in ascending order resulting in all
> > + * anonymous types being placed before named types.
> > + */
> > +static int cmp_type_names(const void *a, const void *b, void *priv)
> > +{
> > +       struct btf *btf = (struct btf *)priv;
> > +       const struct btf_type *ta = btf__type_by_id(btf, *(__u32 *)a);
> > +       const struct btf_type *tb = btf__type_by_id(btf, *(__u32 *)b);
> > +       const char *na, *nb;
> > +
> > +       na = btf__str_by_offset(btf, ta->name_off);
> > +       nb = btf__str_by_offset(btf, tb->name_off);
> > +       return strcmp(na, nb);
> > +}
> > +
> > +static int sort_btf_by_name(struct btf *btf)
> > +{
> > +       __u32 *permute_ids = NULL, *id_map = NULL;
> > +       int nr_types, i, err = 0;
> > +       __u32 start_id = 1, id;
> > +
> > +       if (btf__base_btf(btf))
> > +               start_id = btf__type_cnt(btf__base_btf(btf));
> > +       nr_types = btf__type_cnt(btf) - start_id;
> > +       if (nr_types < 2)
> > +               goto out;
>
> why this check, will anything break if you don't do it?

Because I think that if there are zero or only one type,
there is no need to sort.

>
> > +
> > +       permute_ids = calloc(nr_types, sizeof(*permute_ids));
> > +       if (!permute_ids) {
> > +               err = -ENOMEM;
> > +               goto out;
> > +       }
> > +
> > +       id_map = calloc(nr_types, sizeof(*id_map));
> > +       if (!id_map) {
> > +               err = -ENOMEM;
> > +               goto out;
> > +       }
> > +
> > +       for (i = 0, id = start_id; i < nr_types; i++, id++)
> > +               permute_ids[i] = id;
> > +
> > +       qsort_r(permute_ids, nr_types, sizeof(*permute_ids), cmp_type_names, btf);
> > +
> > +       for (i = 0; i < nr_types; i++) {
> > +               id = permute_ids[i] - start_id;
> > +               id_map[id] = i + start_id;
> > +       }
> > +
> > +       err = btf__permute(btf, id_map, nr_types, NULL);
> > +       if (err)
> > +               pr_err("FAILED: btf permute: %s\n", strerror(-err));
> > +
> > +out:
> > +       free(permute_ids);
> > +       free(id_map);
> > +       return err;
> > +}
> > +
> > +static int btf2btf(struct object *obj)
>
> what's the point of having this function?

Sorting BTF is a type of `btf2btf` process. There may be other
types of `btf2btf` processes, which could be grouped together
here. If we currently don't care about these other processes,
I will retain only `sort_btf_by_name` in the next version.

>
> > +{
> > +       return sort_btf_by_name(obj->btf);
> > +}
> > +
> >  static inline int make_out_path(char *buf, u32 buf_sz, const char *in_path, const char *suffix)
> >  {
> >         int len = snprintf(buf, buf_sz, "%s%s", in_path, suffix);
> > @@ -906,6 +971,9 @@ int main(int argc, const char **argv)
> >         if (load_btf(&obj))
> >                 goto out;
> >
> > +       if (btf2btf(&obj))
> > +               goto out;
> > +
> >         if (elf_collect(&obj))
> >                 goto out;
> >
> > --
> > 2.34.1
> >

On Thu, Dec 18, 2025 at 7:42 PM Donglin Peng <dolinux.peng@gmail.com> wrote:
>
> On Fri, Dec 19, 2025 at 7:09 AM Andrii Nakryiko
> <andrii.nakryiko@gmail.com> wrote:
> >
> > On Thu, Dec 18, 2025 at 3:31 AM Donglin Peng <dolinux.peng@gmail.com> wrote:
> > >
> > > From: pengdonglin <pengdonglin@xiaomi.com>
> > >
> > > This introduces a new BTF sorting phase that specifically sorts
> > > BTF types by name in ascending order, so that the binary search
> > > can be used to look up types.
> > >
> > > Cc: Eduard Zingerman <eddyz87@gmail.com>
> > > Cc: Alexei Starovoitov <ast@kernel.org>
> > > Cc: Andrii Nakryiko <andrii.nakryiko@gmail.com>
> > > Cc: Alan Maguire <alan.maguire@oracle.com>
> > > Cc: Ihor Solodrai <ihor.solodrai@linux.dev>
> > > Cc: Xiaoqin Zhang <zhangxiaoqin@xiaomi.com>
> > > Signed-off-by: pengdonglin <pengdonglin@xiaomi.com>
> >
> > Signed-off-by is supposed to use properly spelled full name, this
> > should be "Donglin Peng", right?
>
> Sorry, I will fix this in the next version. The reason is that our
> company's Gerrit only accepts "pengdonglin" and does not
> accept "Donglin Peng".
>
> >
> > > Acked-by: Eduard Zingerman <eddyz87@gmail.com>
> > > ---
> > >  tools/bpf/resolve_btfids/main.c | 68 +++++++++++++++++++++++++++++++++
> > >  1 file changed, 68 insertions(+)
> > >
> > > diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/main.c
> > > index 3e88dc862d87..659de35748ec 100644
> > > --- a/tools/bpf/resolve_btfids/main.c
> > > +++ b/tools/bpf/resolve_btfids/main.c
> > > @@ -848,6 +848,71 @@ static int dump_raw_btf(struct btf *btf, const char *out_path)
> > >         return 0;
> > >  }
> > >
> > > +/*
> > > + * Sort types by name in ascending order resulting in all
> > > + * anonymous types being placed before named types.
> > > + */
> > > +static int cmp_type_names(const void *a, const void *b, void *priv)
> > > +{
> > > +       struct btf *btf = (struct btf *)priv;
> > > +       const struct btf_type *ta = btf__type_by_id(btf, *(__u32 *)a);
> > > +       const struct btf_type *tb = btf__type_by_id(btf, *(__u32 *)b);
> > > +       const char *na, *nb;
> > > +
> > > +       na = btf__str_by_offset(btf, ta->name_off);
> > > +       nb = btf__str_by_offset(btf, tb->name_off);
> > > +       return strcmp(na, nb);
> > > +}
> > > +
> > > +static int sort_btf_by_name(struct btf *btf)
> > > +{
> > > +       __u32 *permute_ids = NULL, *id_map = NULL;
> > > +       int nr_types, i, err = 0;
> > > +       __u32 start_id = 1, id;
> > > +
> > > +       if (btf__base_btf(btf))
> > > +               start_id = btf__type_cnt(btf__base_btf(btf));
> > > +       nr_types = btf__type_cnt(btf) - start_id;
> > > +       if (nr_types < 2)
> > > +               goto out;
> >
> > why this check, will anything break if you don't do it?
>
> Because I think that if there are zero or only one type,
> there is no need to sort.

There is also no need to special-case and add more checks just for
these corner cases. Keep it simple.


>
> >
> > > +
> > > +       permute_ids = calloc(nr_types, sizeof(*permute_ids));
> > > +       if (!permute_ids) {
> > > +               err = -ENOMEM;
> > > +               goto out;
> > > +       }
> > > +
> > > +       id_map = calloc(nr_types, sizeof(*id_map));
> > > +       if (!id_map) {
> > > +               err = -ENOMEM;
> > > +               goto out;
> > > +       }
> > > +
> > > +       for (i = 0, id = start_id; i < nr_types; i++, id++)
> > > +               permute_ids[i] = id;
> > > +
> > > +       qsort_r(permute_ids, nr_types, sizeof(*permute_ids), cmp_type_names, btf);
> > > +
> > > +       for (i = 0; i < nr_types; i++) {
> > > +               id = permute_ids[i] - start_id;
> > > +               id_map[id] = i + start_id;
> > > +       }
> > > +
> > > +       err = btf__permute(btf, id_map, nr_types, NULL);
> > > +       if (err)
> > > +               pr_err("FAILED: btf permute: %s\n", strerror(-err));
> > > +
> > > +out:
> > > +       free(permute_ids);
> > > +       free(id_map);
> > > +       return err;
> > > +}
> > > +
> > > +static int btf2btf(struct object *obj)
> >
> > what's the point of having this function?
>
> Sorting BTF is a type of `btf2btf` process. There may be other
> types of `btf2btf` processes, which could be grouped together
> here. If we currently don't care about these other processes,
> I will retain only `sort_btf_by_name` in the next version.

Let's have sort as is, when necessary we can refactor this into
logical steps further (or perhaps sorting will be its own logical
step, I don't know, but let's not over design it just yet)

>
> >
> > > +{
> > > +       return sort_btf_by_name(obj->btf);
> > > +}
> > > +
> > >  static inline int make_out_path(char *buf, u32 buf_sz, const char *in_path, const char *suffix)
> > >  {
> > >         int len = snprintf(buf, buf_sz, "%s%s", in_path, suffix);
> > > @@ -906,6 +971,9 @@ int main(int argc, const char **argv)
> > >         if (load_btf(&obj))
> > >                 goto out;
> > >
> > > +       if (btf2btf(&obj))
> > > +               goto out;
> > > +
> > >         if (elf_collect(&obj))
> > >                 goto out;
> > >
> > > --
> > > 2.34.1
> > >

On Sat, Dec 20, 2025 at 1:12 AM Andrii Nakryiko
<andrii.nakryiko@gmail.com> wrote:
>
> On Thu, Dec 18, 2025 at 7:42 PM Donglin Peng <dolinux.peng@gmail.com> wrote:
> >
> > On Fri, Dec 19, 2025 at 7:09 AM Andrii Nakryiko
> > <andrii.nakryiko@gmail.com> wrote:
> > >
> > > On Thu, Dec 18, 2025 at 3:31 AM Donglin Peng <dolinux.peng@gmail.com> wrote:
> > > >
> > > > From: pengdonglin <pengdonglin@xiaomi.com>
> > > >
> > > > This introduces a new BTF sorting phase that specifically sorts
> > > > BTF types by name in ascending order, so that the binary search
> > > > can be used to look up types.
> > > >
> > > > Cc: Eduard Zingerman <eddyz87@gmail.com>
> > > > Cc: Alexei Starovoitov <ast@kernel.org>
> > > > Cc: Andrii Nakryiko <andrii.nakryiko@gmail.com>
> > > > Cc: Alan Maguire <alan.maguire@oracle.com>
> > > > Cc: Ihor Solodrai <ihor.solodrai@linux.dev>
> > > > Cc: Xiaoqin Zhang <zhangxiaoqin@xiaomi.com>
> > > > Signed-off-by: pengdonglin <pengdonglin@xiaomi.com>
> > >
> > > Signed-off-by is supposed to use properly spelled full name, this
> > > should be "Donglin Peng", right?
> >
> > Sorry, I will fix this in the next version. The reason is that our
> > company's Gerrit only accepts "pengdonglin" and does not
> > accept "Donglin Peng".
> >
> > >
> > > > Acked-by: Eduard Zingerman <eddyz87@gmail.com>
> > > > ---
> > > >  tools/bpf/resolve_btfids/main.c | 68 +++++++++++++++++++++++++++++++++
> > > >  1 file changed, 68 insertions(+)
> > > >
> > > > diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/main.c
> > > > index 3e88dc862d87..659de35748ec 100644
> > > > --- a/tools/bpf/resolve_btfids/main.c
> > > > +++ b/tools/bpf/resolve_btfids/main.c
> > > > @@ -848,6 +848,71 @@ static int dump_raw_btf(struct btf *btf, const char *out_path)
> > > >         return 0;
> > > >  }
> > > >
> > > > +/*
> > > > + * Sort types by name in ascending order resulting in all
> > > > + * anonymous types being placed before named types.
> > > > + */
> > > > +static int cmp_type_names(const void *a, const void *b, void *priv)
> > > > +{
> > > > +       struct btf *btf = (struct btf *)priv;
> > > > +       const struct btf_type *ta = btf__type_by_id(btf, *(__u32 *)a);
> > > > +       const struct btf_type *tb = btf__type_by_id(btf, *(__u32 *)b);
> > > > +       const char *na, *nb;
> > > > +
> > > > +       na = btf__str_by_offset(btf, ta->name_off);
> > > > +       nb = btf__str_by_offset(btf, tb->name_off);
> > > > +       return strcmp(na, nb);
> > > > +}
> > > > +
> > > > +static int sort_btf_by_name(struct btf *btf)
> > > > +{
> > > > +       __u32 *permute_ids = NULL, *id_map = NULL;
> > > > +       int nr_types, i, err = 0;
> > > > +       __u32 start_id = 1, id;
> > > > +
> > > > +       if (btf__base_btf(btf))
> > > > +               start_id = btf__type_cnt(btf__base_btf(btf));
> > > > +       nr_types = btf__type_cnt(btf) - start_id;
> > > > +       if (nr_types < 2)
> > > > +               goto out;
> > >
> > > why this check, will anything break if you don't do it?
> >
> > Because I think that if there are zero or only one type,
> > there is no need to sort.
>
> There is also no need to special-case and add more checks just for
> these corner cases. Keep it simple.

Thanks, I agree and and will fix it.

>
>
> >
> > >
> > > > +
> > > > +       permute_ids = calloc(nr_types, sizeof(*permute_ids));
> > > > +       if (!permute_ids) {
> > > > +               err = -ENOMEM;
> > > > +               goto out;
> > > > +       }
> > > > +
> > > > +       id_map = calloc(nr_types, sizeof(*id_map));
> > > > +       if (!id_map) {
> > > > +               err = -ENOMEM;
> > > > +               goto out;
> > > > +       }
> > > > +
> > > > +       for (i = 0, id = start_id; i < nr_types; i++, id++)
> > > > +               permute_ids[i] = id;
> > > > +
> > > > +       qsort_r(permute_ids, nr_types, sizeof(*permute_ids), cmp_type_names, btf);
> > > > +
> > > > +       for (i = 0; i < nr_types; i++) {
> > > > +               id = permute_ids[i] - start_id;
> > > > +               id_map[id] = i + start_id;
> > > > +       }
> > > > +
> > > > +       err = btf__permute(btf, id_map, nr_types, NULL);
> > > > +       if (err)
> > > > +               pr_err("FAILED: btf permute: %s\n", strerror(-err));
> > > > +
> > > > +out:
> > > > +       free(permute_ids);
> > > > +       free(id_map);
> > > > +       return err;
> > > > +}
> > > > +
> > > > +static int btf2btf(struct object *obj)
> > >
> > > what's the point of having this function?
> >
> > Sorting BTF is a type of `btf2btf` process. There may be other
> > types of `btf2btf` processes, which could be grouped together
> > here. If we currently don't care about these other processes,
> > I will retain only `sort_btf_by_name` in the next version.
>
> Let's have sort as is, when necessary we can refactor this into
> logical steps further (or perhaps sorting will be its own logical
> step, I don't know, but let's not over design it just yet)

Okay, I will invoke sort_btf_by_name directly in the next version.

>
> >
> > >
> > > > +{
> > > > +       return sort_btf_by_name(obj->btf);
> > > > +}
> > > > +
> > > >  static inline int make_out_path(char *buf, u32 buf_sz, const char *in_path, const char *suffix)
> > > >  {
> > > >         int len = snprintf(buf, buf_sz, "%s%s", in_path, suffix);
> > > > @@ -906,6 +971,9 @@ int main(int argc, const char **argv)
> > > >         if (load_btf(&obj))
> > > >                 goto out;
> > > >
> > > > +       if (btf2btf(&obj))
> > > > +               goto out;
> > > > +
> > > >         if (elf_collect(&obj))
> > > >                 goto out;
> > > >
> > > > --
> > > > 2.34.1
> > > >