linux/tools/lib/bpf/btf_dump.c
<<
>>
Prefs
   1// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
   2
   3/*
   4 * BTF-to-C type converter.
   5 *
   6 * Copyright (c) 2019 Facebook
   7 */
   8
   9#include <stdbool.h>
  10#include <stddef.h>
  11#include <stdlib.h>
  12#include <string.h>
  13#include <errno.h>
  14#include <linux/err.h>
  15#include <linux/btf.h>
  16#include "btf.h"
  17#include "hashmap.h"
  18#include "libbpf.h"
  19#include "libbpf_internal.h"
  20
  21static const char PREFIXES[] = "\t\t\t\t\t\t\t\t\t\t\t\t\t";
  22static const size_t PREFIX_CNT = sizeof(PREFIXES) - 1;
  23
  24static const char *pfx(int lvl)
  25{
  26        return lvl >= PREFIX_CNT ? PREFIXES : &PREFIXES[PREFIX_CNT - lvl];
  27}
  28
  29enum btf_dump_type_order_state {
  30        NOT_ORDERED,
  31        ORDERING,
  32        ORDERED,
  33};
  34
  35enum btf_dump_type_emit_state {
  36        NOT_EMITTED,
  37        EMITTING,
  38        EMITTED,
  39};
  40
  41/* per-type auxiliary state */
  42struct btf_dump_type_aux_state {
  43        /* topological sorting state */
  44        enum btf_dump_type_order_state order_state: 2;
  45        /* emitting state used to determine the need for forward declaration */
  46        enum btf_dump_type_emit_state emit_state: 2;
  47        /* whether forward declaration was already emitted */
  48        __u8 fwd_emitted: 1;
  49        /* whether unique non-duplicate name was already assigned */
  50        __u8 name_resolved: 1;
  51        /* whether type is referenced from any other type */
  52        __u8 referenced: 1;
  53};
  54
  55struct btf_dump {
  56        const struct btf *btf;
  57        const struct btf_ext *btf_ext;
  58        btf_dump_printf_fn_t printf_fn;
  59        struct btf_dump_opts opts;
  60
  61        /* per-type auxiliary state */
  62        struct btf_dump_type_aux_state *type_states;
  63        /* per-type optional cached unique name, must be freed, if present */
  64        const char **cached_names;
  65
  66        /* topo-sorted list of dependent type definitions */
  67        __u32 *emit_queue;
  68        int emit_queue_cap;
  69        int emit_queue_cnt;
  70
  71        /*
  72         * stack of type declarations (e.g., chain of modifiers, arrays,
  73         * funcs, etc)
  74         */
  75        __u32 *decl_stack;
  76        int decl_stack_cap;
  77        int decl_stack_cnt;
  78
  79        /* maps struct/union/enum name to a number of name occurrences */
  80        struct hashmap *type_names;
  81        /*
  82         * maps typedef identifiers and enum value names to a number of such
  83         * name occurrences
  84         */
  85        struct hashmap *ident_names;
  86};
  87
  88static size_t str_hash_fn(const void *key, void *ctx)
  89{
  90        const char *s = key;
  91        size_t h = 0;
  92
  93        while (*s) {
  94                h = h * 31 + *s;
  95                s++;
  96        }
  97        return h;
  98}
  99
 100static bool str_equal_fn(const void *a, const void *b, void *ctx)
 101{
 102        return strcmp(a, b) == 0;
 103}
 104
 105static const char *btf_name_of(const struct btf_dump *d, __u32 name_off)
 106{
 107        return btf__name_by_offset(d->btf, name_off);
 108}
 109
 110static void btf_dump_printf(const struct btf_dump *d, const char *fmt, ...)
 111{
 112        va_list args;
 113
 114        va_start(args, fmt);
 115        d->printf_fn(d->opts.ctx, fmt, args);
 116        va_end(args);
 117}
 118
 119struct btf_dump *btf_dump__new(const struct btf *btf,
 120                               const struct btf_ext *btf_ext,
 121                               const struct btf_dump_opts *opts,
 122                               btf_dump_printf_fn_t printf_fn)
 123{
 124        struct btf_dump *d;
 125        int err;
 126
 127        d = calloc(1, sizeof(struct btf_dump));
 128        if (!d)
 129                return ERR_PTR(-ENOMEM);
 130
 131        d->btf = btf;
 132        d->btf_ext = btf_ext;
 133        d->printf_fn = printf_fn;
 134        d->opts.ctx = opts ? opts->ctx : NULL;
 135
 136        d->type_names = hashmap__new(str_hash_fn, str_equal_fn, NULL);
 137        if (IS_ERR(d->type_names)) {
 138                err = PTR_ERR(d->type_names);
 139                d->type_names = NULL;
 140                btf_dump__free(d);
 141                return ERR_PTR(err);
 142        }
 143        d->ident_names = hashmap__new(str_hash_fn, str_equal_fn, NULL);
 144        if (IS_ERR(d->ident_names)) {
 145                err = PTR_ERR(d->ident_names);
 146                d->ident_names = NULL;
 147                btf_dump__free(d);
 148                return ERR_PTR(err);
 149        }
 150
 151        return d;
 152}
 153
 154void btf_dump__free(struct btf_dump *d)
 155{
 156        int i, cnt;
 157
 158        if (!d)
 159                return;
 160
 161        free(d->type_states);
 162        if (d->cached_names) {
 163                /* any set cached name is owned by us and should be freed */
 164                for (i = 0, cnt = btf__get_nr_types(d->btf); i <= cnt; i++) {
 165                        if (d->cached_names[i])
 166                                free((void *)d->cached_names[i]);
 167                }
 168        }
 169        free(d->cached_names);
 170        free(d->emit_queue);
 171        free(d->decl_stack);
 172        hashmap__free(d->type_names);
 173        hashmap__free(d->ident_names);
 174
 175        free(d);
 176}
 177
 178static int btf_dump_mark_referenced(struct btf_dump *d);
 179static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr);
 180static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id);
 181
 182/*
 183 * Dump BTF type in a compilable C syntax, including all the necessary
 184 * dependent types, necessary for compilation. If some of the dependent types
 185 * were already emitted as part of previous btf_dump__dump_type() invocation
 186 * for another type, they won't be emitted again. This API allows callers to
 187 * filter out BTF types according to user-defined criterias and emitted only
 188 * minimal subset of types, necessary to compile everything. Full struct/union
 189 * definitions will still be emitted, even if the only usage is through
 190 * pointer and could be satisfied with just a forward declaration.
 191 *
 192 * Dumping is done in two high-level passes:
 193 *   1. Topologically sort type definitions to satisfy C rules of compilation.
 194 *   2. Emit type definitions in C syntax.
 195 *
 196 * Returns 0 on success; <0, otherwise.
 197 */
 198int btf_dump__dump_type(struct btf_dump *d, __u32 id)
 199{
 200        int err, i;
 201
 202        if (id > btf__get_nr_types(d->btf))
 203                return -EINVAL;
 204
 205        /* type states are lazily allocated, as they might not be needed */
 206        if (!d->type_states) {
 207                d->type_states = calloc(1 + btf__get_nr_types(d->btf),
 208                                        sizeof(d->type_states[0]));
 209                if (!d->type_states)
 210                        return -ENOMEM;
 211                d->cached_names = calloc(1 + btf__get_nr_types(d->btf),
 212                                         sizeof(d->cached_names[0]));
 213                if (!d->cached_names)
 214                        return -ENOMEM;
 215
 216                /* VOID is special */
 217                d->type_states[0].order_state = ORDERED;
 218                d->type_states[0].emit_state = EMITTED;
 219
 220                /* eagerly determine referenced types for anon enums */
 221                err = btf_dump_mark_referenced(d);
 222                if (err)
 223                        return err;
 224        }
 225
 226        d->emit_queue_cnt = 0;
 227        err = btf_dump_order_type(d, id, false);
 228        if (err < 0)
 229                return err;
 230
 231        for (i = 0; i < d->emit_queue_cnt; i++)
 232                btf_dump_emit_type(d, d->emit_queue[i], 0 /*top-level*/);
 233
 234        return 0;
 235}
 236
 237/*
 238 * Mark all types that are referenced from any other type. This is used to
 239 * determine top-level anonymous enums that need to be emitted as an
 240 * independent type declarations.
 241 * Anonymous enums come in two flavors: either embedded in a struct's field
 242 * definition, in which case they have to be declared inline as part of field
 243 * type declaration; or as a top-level anonymous enum, typically used for
 244 * declaring global constants. It's impossible to distinguish between two
 245 * without knowning whether given enum type was referenced from other type:
 246 * top-level anonymous enum won't be referenced by anything, while embedded
 247 * one will.
 248 */
 249static int btf_dump_mark_referenced(struct btf_dump *d)
 250{
 251        int i, j, n = btf__get_nr_types(d->btf);
 252        const struct btf_type *t;
 253        __u16 vlen;
 254
 255        for (i = 1; i <= n; i++) {
 256                t = btf__type_by_id(d->btf, i);
 257                vlen = btf_vlen(t);
 258
 259                switch (btf_kind(t)) {
 260                case BTF_KIND_INT:
 261                case BTF_KIND_ENUM:
 262                case BTF_KIND_FWD:
 263                        break;
 264
 265                case BTF_KIND_VOLATILE:
 266                case BTF_KIND_CONST:
 267                case BTF_KIND_RESTRICT:
 268                case BTF_KIND_PTR:
 269                case BTF_KIND_TYPEDEF:
 270                case BTF_KIND_FUNC:
 271                case BTF_KIND_VAR:
 272                        d->type_states[t->type].referenced = 1;
 273                        break;
 274
 275                case BTF_KIND_ARRAY: {
 276                        const struct btf_array *a = btf_array(t);
 277
 278                        d->type_states[a->index_type].referenced = 1;
 279                        d->type_states[a->type].referenced = 1;
 280                        break;
 281                }
 282                case BTF_KIND_STRUCT:
 283                case BTF_KIND_UNION: {
 284                        const struct btf_member *m = btf_members(t);
 285
 286                        for (j = 0; j < vlen; j++, m++)
 287                                d->type_states[m->type].referenced = 1;
 288                        break;
 289                }
 290                case BTF_KIND_FUNC_PROTO: {
 291                        const struct btf_param *p = btf_params(t);
 292
 293                        for (j = 0; j < vlen; j++, p++)
 294                                d->type_states[p->type].referenced = 1;
 295                        break;
 296                }
 297                case BTF_KIND_DATASEC: {
 298                        const struct btf_var_secinfo *v = btf_var_secinfos(t);
 299
 300                        for (j = 0; j < vlen; j++, v++)
 301                                d->type_states[v->type].referenced = 1;
 302                        break;
 303                }
 304                default:
 305                        return -EINVAL;
 306                }
 307        }
 308        return 0;
 309}
 310static int btf_dump_add_emit_queue_id(struct btf_dump *d, __u32 id)
 311{
 312        __u32 *new_queue;
 313        size_t new_cap;
 314
 315        if (d->emit_queue_cnt >= d->emit_queue_cap) {
 316                new_cap = max(16, d->emit_queue_cap * 3 / 2);
 317                new_queue = realloc(d->emit_queue,
 318                                    new_cap * sizeof(new_queue[0]));
 319                if (!new_queue)
 320                        return -ENOMEM;
 321                d->emit_queue = new_queue;
 322                d->emit_queue_cap = new_cap;
 323        }
 324
 325        d->emit_queue[d->emit_queue_cnt++] = id;
 326        return 0;
 327}
 328
 329/*
 330 * Determine order of emitting dependent types and specified type to satisfy
 331 * C compilation rules.  This is done through topological sorting with an
 332 * additional complication which comes from C rules. The main idea for C is
 333 * that if some type is "embedded" into a struct/union, it's size needs to be
 334 * known at the time of definition of containing type. E.g., for:
 335 *
 336 *      struct A {};
 337 *      struct B { struct A x; }
 338 *
 339 * struct A *HAS* to be defined before struct B, because it's "embedded",
 340 * i.e., it is part of struct B layout. But in the following case:
 341 *
 342 *      struct A;
 343 *      struct B { struct A *x; }
 344 *      struct A {};
 345 *
 346 * it's enough to just have a forward declaration of struct A at the time of
 347 * struct B definition, as struct B has a pointer to struct A, so the size of
 348 * field x is known without knowing struct A size: it's sizeof(void *).
 349 *
 350 * Unfortunately, there are some trickier cases we need to handle, e.g.:
 351 *
 352 *      struct A {}; // if this was forward-declaration: compilation error
 353 *      struct B {
 354 *              struct { // anonymous struct
 355 *                      struct A y;
 356 *              } *x;
 357 *      };
 358 *
 359 * In this case, struct B's field x is a pointer, so it's size is known
 360 * regardless of the size of (anonymous) struct it points to. But because this
 361 * struct is anonymous and thus defined inline inside struct B, *and* it
 362 * embeds struct A, compiler requires full definition of struct A to be known
 363 * before struct B can be defined. This creates a transitive dependency
 364 * between struct A and struct B. If struct A was forward-declared before
 365 * struct B definition and fully defined after struct B definition, that would
 366 * trigger compilation error.
 367 *
 368 * All this means that while we are doing topological sorting on BTF type
 369 * graph, we need to determine relationships between different types (graph
 370 * nodes):
 371 *   - weak link (relationship) between X and Y, if Y *CAN* be
 372 *   forward-declared at the point of X definition;
 373 *   - strong link, if Y *HAS* to be fully-defined before X can be defined.
 374 *
 375 * The rule is as follows. Given a chain of BTF types from X to Y, if there is
 376 * BTF_KIND_PTR type in the chain and at least one non-anonymous type
 377 * Z (excluding X, including Y), then link is weak. Otherwise, it's strong.
 378 * Weak/strong relationship is determined recursively during DFS traversal and
 379 * is returned as a result from btf_dump_order_type().
 380 *
 381 * btf_dump_order_type() is trying to avoid unnecessary forward declarations,
 382 * but it is not guaranteeing that no extraneous forward declarations will be
 383 * emitted.
 384 *
 385 * To avoid extra work, algorithm marks some of BTF types as ORDERED, when
 386 * it's done with them, but not for all (e.g., VOLATILE, CONST, RESTRICT,
 387 * ARRAY, FUNC_PROTO), as weak/strong semantics for those depends on the
 388 * entire graph path, so depending where from one came to that BTF type, it
 389 * might cause weak or strong ordering. For types like STRUCT/UNION/INT/ENUM,
 390 * once they are processed, there is no need to do it again, so they are
 391 * marked as ORDERED. We can mark PTR as ORDERED as well, as it semi-forces
 392 * weak link, unless subsequent referenced STRUCT/UNION/ENUM is anonymous. But
 393 * in any case, once those are processed, no need to do it again, as the
 394 * result won't change.
 395 *
 396 * Returns:
 397 *   - 1, if type is part of strong link (so there is strong topological
 398 *   ordering requirements);
 399 *   - 0, if type is part of weak link (so can be satisfied through forward
 400 *   declaration);
 401 *   - <0, on error (e.g., unsatisfiable type loop detected).
 402 */
 403static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr)
 404{
 405        /*
 406         * Order state is used to detect strong link cycles, but only for BTF
 407         * kinds that are or could be an independent definition (i.e.,
 408         * stand-alone fwd decl, enum, typedef, struct, union). Ptrs, arrays,
 409         * func_protos, modifiers are just means to get to these definitions.
 410         * Int/void don't need definitions, they are assumed to be always
 411         * properly defined.  We also ignore datasec, var, and funcs for now.
 412         * So for all non-defining kinds, we never even set ordering state,
 413         * for defining kinds we set ORDERING and subsequently ORDERED if it
 414         * forms a strong link.
 415         */
 416        struct btf_dump_type_aux_state *tstate = &d->type_states[id];
 417        const struct btf_type *t;
 418        __u16 vlen;
 419        int err, i;
 420
 421        /* return true, letting typedefs know that it's ok to be emitted */
 422        if (tstate->order_state == ORDERED)
 423                return 1;
 424
 425        t = btf__type_by_id(d->btf, id);
 426
 427        if (tstate->order_state == ORDERING) {
 428                /* type loop, but resolvable through fwd declaration */
 429                if (btf_is_composite(t) && through_ptr && t->name_off != 0)
 430                        return 0;
 431                pr_warning("unsatisfiable type cycle, id:[%u]\n", id);
 432                return -ELOOP;
 433        }
 434
 435        switch (btf_kind(t)) {
 436        case BTF_KIND_INT:
 437                tstate->order_state = ORDERED;
 438                return 0;
 439
 440        case BTF_KIND_PTR:
 441                err = btf_dump_order_type(d, t->type, true);
 442                tstate->order_state = ORDERED;
 443                return err;
 444
 445        case BTF_KIND_ARRAY:
 446                return btf_dump_order_type(d, btf_array(t)->type, through_ptr);
 447
 448        case BTF_KIND_STRUCT:
 449        case BTF_KIND_UNION: {
 450                const struct btf_member *m = btf_members(t);
 451                /*
 452                 * struct/union is part of strong link, only if it's embedded
 453                 * (so no ptr in a path) or it's anonymous (so has to be
 454                 * defined inline, even if declared through ptr)
 455                 */
 456                if (through_ptr && t->name_off != 0)
 457                        return 0;
 458
 459                tstate->order_state = ORDERING;
 460
 461                vlen = btf_vlen(t);
 462                for (i = 0; i < vlen; i++, m++) {
 463                        err = btf_dump_order_type(d, m->type, false);
 464                        if (err < 0)
 465                                return err;
 466                }
 467
 468                if (t->name_off != 0) {
 469                        err = btf_dump_add_emit_queue_id(d, id);
 470                        if (err < 0)
 471                                return err;
 472                }
 473
 474                tstate->order_state = ORDERED;
 475                return 1;
 476        }
 477        case BTF_KIND_ENUM:
 478        case BTF_KIND_FWD:
 479                /*
 480                 * non-anonymous or non-referenced enums are top-level
 481                 * declarations and should be emitted. Same logic can be
 482                 * applied to FWDs, it won't hurt anyways.
 483                 */
 484                if (t->name_off != 0 || !tstate->referenced) {
 485                        err = btf_dump_add_emit_queue_id(d, id);
 486                        if (err)
 487                                return err;
 488                }
 489                tstate->order_state = ORDERED;
 490                return 1;
 491
 492        case BTF_KIND_TYPEDEF: {
 493                int is_strong;
 494
 495                is_strong = btf_dump_order_type(d, t->type, through_ptr);
 496                if (is_strong < 0)
 497                        return is_strong;
 498
 499                /* typedef is similar to struct/union w.r.t. fwd-decls */
 500                if (through_ptr && !is_strong)
 501                        return 0;
 502
 503                /* typedef is always a named definition */
 504                err = btf_dump_add_emit_queue_id(d, id);
 505                if (err)
 506                        return err;
 507
 508                d->type_states[id].order_state = ORDERED;
 509                return 1;
 510        }
 511        case BTF_KIND_VOLATILE:
 512        case BTF_KIND_CONST:
 513        case BTF_KIND_RESTRICT:
 514                return btf_dump_order_type(d, t->type, through_ptr);
 515
 516        case BTF_KIND_FUNC_PROTO: {
 517                const struct btf_param *p = btf_params(t);
 518                bool is_strong;
 519
 520                err = btf_dump_order_type(d, t->type, through_ptr);
 521                if (err < 0)
 522                        return err;
 523                is_strong = err > 0;
 524
 525                vlen = btf_vlen(t);
 526                for (i = 0; i < vlen; i++, p++) {
 527                        err = btf_dump_order_type(d, p->type, through_ptr);
 528                        if (err < 0)
 529                                return err;
 530                        if (err > 0)
 531                                is_strong = true;
 532                }
 533                return is_strong;
 534        }
 535        case BTF_KIND_FUNC:
 536        case BTF_KIND_VAR:
 537        case BTF_KIND_DATASEC:
 538                d->type_states[id].order_state = ORDERED;
 539                return 0;
 540
 541        default:
 542                return -EINVAL;
 543        }
 544}
 545
 546static void btf_dump_emit_struct_fwd(struct btf_dump *d, __u32 id,
 547                                     const struct btf_type *t);
 548static void btf_dump_emit_struct_def(struct btf_dump *d, __u32 id,
 549                                     const struct btf_type *t, int lvl);
 550
 551static void btf_dump_emit_enum_fwd(struct btf_dump *d, __u32 id,
 552                                   const struct btf_type *t);
 553static void btf_dump_emit_enum_def(struct btf_dump *d, __u32 id,
 554                                   const struct btf_type *t, int lvl);
 555
 556static void btf_dump_emit_fwd_def(struct btf_dump *d, __u32 id,
 557                                  const struct btf_type *t);
 558
 559static void btf_dump_emit_typedef_def(struct btf_dump *d, __u32 id,
 560                                      const struct btf_type *t, int lvl);
 561
 562/* a local view into a shared stack */
 563struct id_stack {
 564        const __u32 *ids;
 565        int cnt;
 566};
 567
 568static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id,
 569                                    const char *fname, int lvl);
 570static void btf_dump_emit_type_chain(struct btf_dump *d,
 571                                     struct id_stack *decl_stack,
 572                                     const char *fname, int lvl);
 573
 574static const char *btf_dump_type_name(struct btf_dump *d, __u32 id);
 575static const char *btf_dump_ident_name(struct btf_dump *d, __u32 id);
 576static size_t btf_dump_name_dups(struct btf_dump *d, struct hashmap *name_map,
 577                                 const char *orig_name);
 578
 579static bool btf_dump_is_blacklisted(struct btf_dump *d, __u32 id)
 580{
 581        const struct btf_type *t = btf__type_by_id(d->btf, id);
 582
 583        /* __builtin_va_list is a compiler built-in, which causes compilation
 584         * errors, when compiling w/ different compiler, then used to compile
 585         * original code (e.g., GCC to compile kernel, Clang to use generated
 586         * C header from BTF). As it is built-in, it should be already defined
 587         * properly internally in compiler.
 588         */
 589        if (t->name_off == 0)
 590                return false;
 591        return strcmp(btf_name_of(d, t->name_off), "__builtin_va_list") == 0;
 592}
 593
 594/*
 595 * Emit C-syntax definitions of types from chains of BTF types.
 596 *
 597 * High-level handling of determining necessary forward declarations are handled
 598 * by btf_dump_emit_type() itself, but all nitty-gritty details of emitting type
 599 * declarations/definitions in C syntax  are handled by a combo of
 600 * btf_dump_emit_type_decl()/btf_dump_emit_type_chain() w/ delegation to
 601 * corresponding btf_dump_emit_*_{def,fwd}() functions.
 602 *
 603 * We also keep track of "containing struct/union type ID" to determine when
 604 * we reference it from inside and thus can avoid emitting unnecessary forward
 605 * declaration.
 606 *
 607 * This algorithm is designed in such a way, that even if some error occurs
 608 * (either technical, e.g., out of memory, or logical, i.e., malformed BTF
 609 * that doesn't comply to C rules completely), algorithm will try to proceed
 610 * and produce as much meaningful output as possible.
 611 */
 612static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id)
 613{
 614        struct btf_dump_type_aux_state *tstate = &d->type_states[id];
 615        bool top_level_def = cont_id == 0;
 616        const struct btf_type *t;
 617        __u16 kind;
 618
 619        if (tstate->emit_state == EMITTED)
 620                return;
 621
 622        t = btf__type_by_id(d->btf, id);
 623        kind = btf_kind(t);
 624
 625        if (tstate->emit_state == EMITTING) {
 626                if (tstate->fwd_emitted)
 627                        return;
 628
 629                switch (kind) {
 630                case BTF_KIND_STRUCT:
 631                case BTF_KIND_UNION:
 632                        /*
 633                         * if we are referencing a struct/union that we are
 634                         * part of - then no need for fwd declaration
 635                         */
 636                        if (id == cont_id)
 637                                return;
 638                        if (t->name_off == 0) {
 639                                pr_warning("anonymous struct/union loop, id:[%u]\n",
 640                                           id);
 641                                return;
 642                        }
 643                        btf_dump_emit_struct_fwd(d, id, t);
 644                        btf_dump_printf(d, ";\n\n");
 645                        tstate->fwd_emitted = 1;
 646                        break;
 647                case BTF_KIND_TYPEDEF:
 648                        /*
 649                         * for typedef fwd_emitted means typedef definition
 650                         * was emitted, but it can be used only for "weak"
 651                         * references through pointer only, not for embedding
 652                         */
 653                        if (!btf_dump_is_blacklisted(d, id)) {
 654                                btf_dump_emit_typedef_def(d, id, t, 0);
 655                                btf_dump_printf(d, ";\n\n");
 656                        };
 657                        tstate->fwd_emitted = 1;
 658                        break;
 659                default:
 660                        break;
 661                }
 662
 663                return;
 664        }
 665
 666        switch (kind) {
 667        case BTF_KIND_INT:
 668                tstate->emit_state = EMITTED;
 669                break;
 670        case BTF_KIND_ENUM:
 671                if (top_level_def) {
 672                        btf_dump_emit_enum_def(d, id, t, 0);
 673                        btf_dump_printf(d, ";\n\n");
 674                }
 675                tstate->emit_state = EMITTED;
 676                break;
 677        case BTF_KIND_PTR:
 678        case BTF_KIND_VOLATILE:
 679        case BTF_KIND_CONST:
 680        case BTF_KIND_RESTRICT:
 681                btf_dump_emit_type(d, t->type, cont_id);
 682                break;
 683        case BTF_KIND_ARRAY:
 684                btf_dump_emit_type(d, btf_array(t)->type, cont_id);
 685                break;
 686        case BTF_KIND_FWD:
 687                btf_dump_emit_fwd_def(d, id, t);
 688                btf_dump_printf(d, ";\n\n");
 689                tstate->emit_state = EMITTED;
 690                break;
 691        case BTF_KIND_TYPEDEF:
 692                tstate->emit_state = EMITTING;
 693                btf_dump_emit_type(d, t->type, id);
 694                /*
 695                 * typedef can server as both definition and forward
 696                 * declaration; at this stage someone depends on
 697                 * typedef as a forward declaration (refers to it
 698                 * through pointer), so unless we already did it,
 699                 * emit typedef as a forward declaration
 700                 */
 701                if (!tstate->fwd_emitted && !btf_dump_is_blacklisted(d, id)) {
 702                        btf_dump_emit_typedef_def(d, id, t, 0);
 703                        btf_dump_printf(d, ";\n\n");
 704                }
 705                tstate->emit_state = EMITTED;
 706                break;
 707        case BTF_KIND_STRUCT:
 708        case BTF_KIND_UNION:
 709                tstate->emit_state = EMITTING;
 710                /* if it's a top-level struct/union definition or struct/union
 711                 * is anonymous, then in C we'll be emitting all fields and
 712                 * their types (as opposed to just `struct X`), so we need to
 713                 * make sure that all types, referenced from struct/union
 714                 * members have necessary forward-declarations, where
 715                 * applicable
 716                 */
 717                if (top_level_def || t->name_off == 0) {
 718                        const struct btf_member *m = btf_members(t);
 719                        __u16 vlen = btf_vlen(t);
 720                        int i, new_cont_id;
 721
 722                        new_cont_id = t->name_off == 0 ? cont_id : id;
 723                        for (i = 0; i < vlen; i++, m++)
 724                                btf_dump_emit_type(d, m->type, new_cont_id);
 725                } else if (!tstate->fwd_emitted && id != cont_id) {
 726                        btf_dump_emit_struct_fwd(d, id, t);
 727                        btf_dump_printf(d, ";\n\n");
 728                        tstate->fwd_emitted = 1;
 729                }
 730
 731                if (top_level_def) {
 732                        btf_dump_emit_struct_def(d, id, t, 0);
 733                        btf_dump_printf(d, ";\n\n");
 734                        tstate->emit_state = EMITTED;
 735                } else {
 736                        tstate->emit_state = NOT_EMITTED;
 737                }
 738                break;
 739        case BTF_KIND_FUNC_PROTO: {
 740                const struct btf_param *p = btf_params(t);
 741                __u16 vlen = btf_vlen(t);
 742                int i;
 743
 744                btf_dump_emit_type(d, t->type, cont_id);
 745                for (i = 0; i < vlen; i++, p++)
 746                        btf_dump_emit_type(d, p->type, cont_id);
 747
 748                break;
 749        }
 750        default:
 751                break;
 752        }
 753}
 754
 755static int btf_align_of(const struct btf *btf, __u32 id)
 756{
 757        const struct btf_type *t = btf__type_by_id(btf, id);
 758        __u16 kind = btf_kind(t);
 759
 760        switch (kind) {
 761        case BTF_KIND_INT:
 762        case BTF_KIND_ENUM:
 763                return min(sizeof(void *), t->size);
 764        case BTF_KIND_PTR:
 765                return sizeof(void *);
 766        case BTF_KIND_TYPEDEF:
 767        case BTF_KIND_VOLATILE:
 768        case BTF_KIND_CONST:
 769        case BTF_KIND_RESTRICT:
 770                return btf_align_of(btf, t->type);
 771        case BTF_KIND_ARRAY:
 772                return btf_align_of(btf, btf_array(t)->type);
 773        case BTF_KIND_STRUCT:
 774        case BTF_KIND_UNION: {
 775                const struct btf_member *m = btf_members(t);
 776                __u16 vlen = btf_vlen(t);
 777                int i, align = 1;
 778
 779                for (i = 0; i < vlen; i++, m++)
 780                        align = max(align, btf_align_of(btf, m->type));
 781
 782                return align;
 783        }
 784        default:
 785                pr_warning("unsupported BTF_KIND:%u\n", btf_kind(t));
 786                return 1;
 787        }
 788}
 789
 790static bool btf_is_struct_packed(const struct btf *btf, __u32 id,
 791                                 const struct btf_type *t)
 792{
 793        const struct btf_member *m;
 794        int align, i, bit_sz;
 795        __u16 vlen;
 796
 797        align = btf_align_of(btf, id);
 798        /* size of a non-packed struct has to be a multiple of its alignment*/
 799        if (t->size % align)
 800                return true;
 801
 802        m = btf_members(t);
 803        vlen = btf_vlen(t);
 804        /* all non-bitfield fields have to be naturally aligned */
 805        for (i = 0; i < vlen; i++, m++) {
 806                align = btf_align_of(btf, m->type);
 807                bit_sz = btf_member_bitfield_size(t, i);
 808                if (bit_sz == 0 && m->offset % (8 * align) != 0)
 809                        return true;
 810        }
 811
 812        /*
 813         * if original struct was marked as packed, but its layout is
 814         * naturally aligned, we'll detect that it's not packed
 815         */
 816        return false;
 817}
 818
 819static int chip_away_bits(int total, int at_most)
 820{
 821        return total % at_most ? : at_most;
 822}
 823
 824static void btf_dump_emit_bit_padding(const struct btf_dump *d,
 825                                      int cur_off, int m_off, int m_bit_sz,
 826                                      int align, int lvl)
 827{
 828        int off_diff = m_off - cur_off;
 829        int ptr_bits = sizeof(void *) * 8;
 830
 831        if (off_diff <= 0)
 832                /* no gap */
 833                return;
 834        if (m_bit_sz == 0 && off_diff < align * 8)
 835                /* natural padding will take care of a gap */
 836                return;
 837
 838        while (off_diff > 0) {
 839                const char *pad_type;
 840                int pad_bits;
 841
 842                if (ptr_bits > 32 && off_diff > 32) {
 843                        pad_type = "long";
 844                        pad_bits = chip_away_bits(off_diff, ptr_bits);
 845                } else if (off_diff > 16) {
 846                        pad_type = "int";
 847                        pad_bits = chip_away_bits(off_diff, 32);
 848                } else if (off_diff > 8) {
 849                        pad_type = "short";
 850                        pad_bits = chip_away_bits(off_diff, 16);
 851                } else {
 852                        pad_type = "char";
 853                        pad_bits = chip_away_bits(off_diff, 8);
 854                }
 855                btf_dump_printf(d, "\n%s%s: %d;", pfx(lvl), pad_type, pad_bits);
 856                off_diff -= pad_bits;
 857        }
 858}
 859
 860static void btf_dump_emit_struct_fwd(struct btf_dump *d, __u32 id,
 861                                     const struct btf_type *t)
 862{
 863        btf_dump_printf(d, "%s %s",
 864                        btf_is_struct(t) ? "struct" : "union",
 865                        btf_dump_type_name(d, id));
 866}
 867
 868static void btf_dump_emit_struct_def(struct btf_dump *d,
 869                                     __u32 id,
 870                                     const struct btf_type *t,
 871                                     int lvl)
 872{
 873        const struct btf_member *m = btf_members(t);
 874        bool is_struct = btf_is_struct(t);
 875        int align, i, packed, off = 0;
 876        __u16 vlen = btf_vlen(t);
 877
 878        packed = is_struct ? btf_is_struct_packed(d->btf, id, t) : 0;
 879        align = packed ? 1 : btf_align_of(d->btf, id);
 880
 881        btf_dump_printf(d, "%s%s%s {",
 882                        is_struct ? "struct" : "union",
 883                        t->name_off ? " " : "",
 884                        btf_dump_type_name(d, id));
 885
 886        for (i = 0; i < vlen; i++, m++) {
 887                const char *fname;
 888                int m_off, m_sz;
 889
 890                fname = btf_name_of(d, m->name_off);
 891                m_sz = btf_member_bitfield_size(t, i);
 892                m_off = btf_member_bit_offset(t, i);
 893                align = packed ? 1 : btf_align_of(d->btf, m->type);
 894
 895                btf_dump_emit_bit_padding(d, off, m_off, m_sz, align, lvl + 1);
 896                btf_dump_printf(d, "\n%s", pfx(lvl + 1));
 897                btf_dump_emit_type_decl(d, m->type, fname, lvl + 1);
 898
 899                if (m_sz) {
 900                        btf_dump_printf(d, ": %d", m_sz);
 901                        off = m_off + m_sz;
 902                } else {
 903                        m_sz = max(0, btf__resolve_size(d->btf, m->type));
 904                        off = m_off + m_sz * 8;
 905                }
 906                btf_dump_printf(d, ";");
 907        }
 908
 909        if (vlen)
 910                btf_dump_printf(d, "\n");
 911        btf_dump_printf(d, "%s}", pfx(lvl));
 912        if (packed)
 913                btf_dump_printf(d, " __attribute__((packed))");
 914}
 915
 916static void btf_dump_emit_enum_fwd(struct btf_dump *d, __u32 id,
 917                                   const struct btf_type *t)
 918{
 919        btf_dump_printf(d, "enum %s", btf_dump_type_name(d, id));
 920}
 921
 922static void btf_dump_emit_enum_def(struct btf_dump *d, __u32 id,
 923                                   const struct btf_type *t,
 924                                   int lvl)
 925{
 926        const struct btf_enum *v = btf_enum(t);
 927        __u16 vlen = btf_vlen(t);
 928        const char *name;
 929        size_t dup_cnt;
 930        int i;
 931
 932        btf_dump_printf(d, "enum%s%s",
 933                        t->name_off ? " " : "",
 934                        btf_dump_type_name(d, id));
 935
 936        if (vlen) {
 937                btf_dump_printf(d, " {");
 938                for (i = 0; i < vlen; i++, v++) {
 939                        name = btf_name_of(d, v->name_off);
 940                        /* enumerators share namespace with typedef idents */
 941                        dup_cnt = btf_dump_name_dups(d, d->ident_names, name);
 942                        if (dup_cnt > 1) {
 943                                btf_dump_printf(d, "\n%s%s___%zu = %d,",
 944                                                pfx(lvl + 1), name, dup_cnt,
 945                                                (__s32)v->val);
 946                        } else {
 947                                btf_dump_printf(d, "\n%s%s = %d,",
 948                                                pfx(lvl + 1), name,
 949                                                (__s32)v->val);
 950                        }
 951                }
 952                btf_dump_printf(d, "\n%s}", pfx(lvl));
 953        }
 954}
 955
 956static void btf_dump_emit_fwd_def(struct btf_dump *d, __u32 id,
 957                                  const struct btf_type *t)
 958{
 959        const char *name = btf_dump_type_name(d, id);
 960
 961        if (btf_kflag(t))
 962                btf_dump_printf(d, "union %s", name);
 963        else
 964                btf_dump_printf(d, "struct %s", name);
 965}
 966
 967static void btf_dump_emit_typedef_def(struct btf_dump *d, __u32 id,
 968                                     const struct btf_type *t, int lvl)
 969{
 970        const char *name = btf_dump_ident_name(d, id);
 971
 972        btf_dump_printf(d, "typedef ");
 973        btf_dump_emit_type_decl(d, t->type, name, lvl);
 974}
 975
 976static int btf_dump_push_decl_stack_id(struct btf_dump *d, __u32 id)
 977{
 978        __u32 *new_stack;
 979        size_t new_cap;
 980
 981        if (d->decl_stack_cnt >= d->decl_stack_cap) {
 982                new_cap = max(16, d->decl_stack_cap * 3 / 2);
 983                new_stack = realloc(d->decl_stack,
 984                                    new_cap * sizeof(new_stack[0]));
 985                if (!new_stack)
 986                        return -ENOMEM;
 987                d->decl_stack = new_stack;
 988                d->decl_stack_cap = new_cap;
 989        }
 990
 991        d->decl_stack[d->decl_stack_cnt++] = id;
 992
 993        return 0;
 994}
 995
 996/*
 997 * Emit type declaration (e.g., field type declaration in a struct or argument
 998 * declaration in function prototype) in correct C syntax.
 999 *
1000 * For most types it's trivial, but there are few quirky type declaration
1001 * cases worth mentioning:
1002 *   - function prototypes (especially nesting of function prototypes);
1003 *   - arrays;
1004 *   - const/volatile/restrict for pointers vs other types.
1005 *
1006 * For a good discussion of *PARSING* C syntax (as a human), see
1007 * Peter van der Linden's "Expert C Programming: Deep C Secrets",
1008 * Ch.3 "Unscrambling Declarations in C".
1009 *
1010 * It won't help with BTF to C conversion much, though, as it's an opposite
1011 * problem. So we came up with this algorithm in reverse to van der Linden's
1012 * parsing algorithm. It goes from structured BTF representation of type
1013 * declaration to a valid compilable C syntax.
1014 *
1015 * For instance, consider this C typedef:
1016 *      typedef const int * const * arr[10] arr_t;
1017 * It will be represented in BTF with this chain of BTF types:
1018 *      [typedef] -> [array] -> [ptr] -> [const] -> [ptr] -> [const] -> [int]
1019 *
1020 * Notice how [const] modifier always goes before type it modifies in BTF type
1021 * graph, but in C syntax, const/volatile/restrict modifiers are written to
1022 * the right of pointers, but to the left of other types. There are also other
1023 * quirks, like function pointers, arrays of them, functions returning other
1024 * functions, etc.
1025 *
1026 * We handle that by pushing all the types to a stack, until we hit "terminal"
1027 * type (int/enum/struct/union/fwd). Then depending on the kind of a type on
1028 * top of a stack, modifiers are handled differently. Array/function pointers
1029 * have also wildly different syntax and how nesting of them are done. See
1030 * code for authoritative definition.
1031 *
1032 * To avoid allocating new stack for each independent chain of BTF types, we
1033 * share one bigger stack, with each chain working only on its own local view
1034 * of a stack frame. Some care is required to "pop" stack frames after
1035 * processing type declaration chain.
1036 */
1037static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id,
1038                                    const char *fname, int lvl)
1039{
1040        struct id_stack decl_stack;
1041        const struct btf_type *t;
1042        int err, stack_start;
1043
1044        stack_start = d->decl_stack_cnt;
1045        for (;;) {
1046                err = btf_dump_push_decl_stack_id(d, id);
1047                if (err < 0) {
1048                        /*
1049                         * if we don't have enough memory for entire type decl
1050                         * chain, restore stack, emit warning, and try to
1051                         * proceed nevertheless
1052                         */
1053                        pr_warning("not enough memory for decl stack:%d", err);
1054                        d->decl_stack_cnt = stack_start;
1055                        return;
1056                }
1057
1058                /* VOID */
1059                if (id == 0)
1060                        break;
1061
1062                t = btf__type_by_id(d->btf, id);
1063                switch (btf_kind(t)) {
1064                case BTF_KIND_PTR:
1065                case BTF_KIND_VOLATILE:
1066                case BTF_KIND_CONST:
1067                case BTF_KIND_RESTRICT:
1068                case BTF_KIND_FUNC_PROTO:
1069                        id = t->type;
1070                        break;
1071                case BTF_KIND_ARRAY:
1072                        id = btf_array(t)->type;
1073                        break;
1074                case BTF_KIND_INT:
1075                case BTF_KIND_ENUM:
1076                case BTF_KIND_FWD:
1077                case BTF_KIND_STRUCT:
1078                case BTF_KIND_UNION:
1079                case BTF_KIND_TYPEDEF:
1080                        goto done;
1081                default:
1082                        pr_warning("unexpected type in decl chain, kind:%u, id:[%u]\n",
1083                                   btf_kind(t), id);
1084                        goto done;
1085                }
1086        }
1087done:
1088        /*
1089         * We might be inside a chain of declarations (e.g., array of function
1090         * pointers returning anonymous (so inlined) structs, having another
1091         * array field). Each of those needs its own "stack frame" to handle
1092         * emitting of declarations. Those stack frames are non-overlapping
1093         * portions of shared btf_dump->decl_stack. To make it a bit nicer to
1094         * handle this set of nested stacks, we create a view corresponding to
1095         * our own "stack frame" and work with it as an independent stack.
1096         * We'll need to clean up after emit_type_chain() returns, though.
1097         */
1098        decl_stack.ids = d->decl_stack + stack_start;
1099        decl_stack.cnt = d->decl_stack_cnt - stack_start;
1100        btf_dump_emit_type_chain(d, &decl_stack, fname, lvl);
1101        /*
1102         * emit_type_chain() guarantees that it will pop its entire decl_stack
1103         * frame before returning. But it works with a read-only view into
1104         * decl_stack, so it doesn't actually pop anything from the
1105         * perspective of shared btf_dump->decl_stack, per se. We need to
1106         * reset decl_stack state to how it was before us to avoid it growing
1107         * all the time.
1108         */
1109        d->decl_stack_cnt = stack_start;
1110}
1111
1112static void btf_dump_emit_mods(struct btf_dump *d, struct id_stack *decl_stack)
1113{
1114        const struct btf_type *t;
1115        __u32 id;
1116
1117        while (decl_stack->cnt) {
1118                id = decl_stack->ids[decl_stack->cnt - 1];
1119                t = btf__type_by_id(d->btf, id);
1120
1121                switch (btf_kind(t)) {
1122                case BTF_KIND_VOLATILE:
1123                        btf_dump_printf(d, "volatile ");
1124                        break;
1125                case BTF_KIND_CONST:
1126                        btf_dump_printf(d, "const ");
1127                        break;
1128                case BTF_KIND_RESTRICT:
1129                        btf_dump_printf(d, "restrict ");
1130                        break;
1131                default:
1132                        return;
1133                }
1134                decl_stack->cnt--;
1135        }
1136}
1137
1138static void btf_dump_emit_name(const struct btf_dump *d,
1139                               const char *name, bool last_was_ptr)
1140{
1141        bool separate = name[0] && !last_was_ptr;
1142
1143        btf_dump_printf(d, "%s%s", separate ? " " : "", name);
1144}
1145
1146static void btf_dump_emit_type_chain(struct btf_dump *d,
1147                                     struct id_stack *decls,
1148                                     const char *fname, int lvl)
1149{
1150        /*
1151         * last_was_ptr is used to determine if we need to separate pointer
1152         * asterisk (*) from previous part of type signature with space, so
1153         * that we get `int ***`, instead of `int * * *`. We default to true
1154         * for cases where we have single pointer in a chain. E.g., in ptr ->
1155         * func_proto case. func_proto will start a new emit_type_chain call
1156         * with just ptr, which should be emitted as (*) or (*<fname>), so we
1157         * don't want to prepend space for that last pointer.
1158         */
1159        bool last_was_ptr = true;
1160        const struct btf_type *t;
1161        const char *name;
1162        __u16 kind;
1163        __u32 id;
1164
1165        while (decls->cnt) {
1166                id = decls->ids[--decls->cnt];
1167                if (id == 0) {
1168                        /* VOID is a special snowflake */
1169                        btf_dump_emit_mods(d, decls);
1170                        btf_dump_printf(d, "void");
1171                        last_was_ptr = false;
1172                        continue;
1173                }
1174
1175                t = btf__type_by_id(d->btf, id);
1176                kind = btf_kind(t);
1177
1178                switch (kind) {
1179                case BTF_KIND_INT:
1180                        btf_dump_emit_mods(d, decls);
1181                        name = btf_name_of(d, t->name_off);
1182                        btf_dump_printf(d, "%s", name);
1183                        break;
1184                case BTF_KIND_STRUCT:
1185                case BTF_KIND_UNION:
1186                        btf_dump_emit_mods(d, decls);
1187                        /* inline anonymous struct/union */
1188                        if (t->name_off == 0)
1189                                btf_dump_emit_struct_def(d, id, t, lvl);
1190                        else
1191                                btf_dump_emit_struct_fwd(d, id, t);
1192                        break;
1193                case BTF_KIND_ENUM:
1194                        btf_dump_emit_mods(d, decls);
1195                        /* inline anonymous enum */
1196                        if (t->name_off == 0)
1197                                btf_dump_emit_enum_def(d, id, t, lvl);
1198                        else
1199                                btf_dump_emit_enum_fwd(d, id, t);
1200                        break;
1201                case BTF_KIND_FWD:
1202                        btf_dump_emit_mods(d, decls);
1203                        btf_dump_emit_fwd_def(d, id, t);
1204                        break;
1205                case BTF_KIND_TYPEDEF:
1206                        btf_dump_emit_mods(d, decls);
1207                        btf_dump_printf(d, "%s", btf_dump_ident_name(d, id));
1208                        break;
1209                case BTF_KIND_PTR:
1210                        btf_dump_printf(d, "%s", last_was_ptr ? "*" : " *");
1211                        break;
1212                case BTF_KIND_VOLATILE:
1213                        btf_dump_printf(d, " volatile");
1214                        break;
1215                case BTF_KIND_CONST:
1216                        btf_dump_printf(d, " const");
1217                        break;
1218                case BTF_KIND_RESTRICT:
1219                        btf_dump_printf(d, " restrict");
1220                        break;
1221                case BTF_KIND_ARRAY: {
1222                        const struct btf_array *a = btf_array(t);
1223                        const struct btf_type *next_t;
1224                        __u32 next_id;
1225                        bool multidim;
1226                        /*
1227                         * GCC has a bug
1228                         * (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=8354)
1229                         * which causes it to emit extra const/volatile
1230                         * modifiers for an array, if array's element type has
1231                         * const/volatile modifiers. Clang doesn't do that.
1232                         * In general, it doesn't seem very meaningful to have
1233                         * a const/volatile modifier for array, so we are
1234                         * going to silently skip them here.
1235                         */
1236                        while (decls->cnt) {
1237                                next_id = decls->ids[decls->cnt - 1];
1238                                next_t = btf__type_by_id(d->btf, next_id);
1239                                if (btf_is_mod(next_t))
1240                                        decls->cnt--;
1241                                else
1242                                        break;
1243                        }
1244
1245                        if (decls->cnt == 0) {
1246                                btf_dump_emit_name(d, fname, last_was_ptr);
1247                                btf_dump_printf(d, "[%u]", a->nelems);
1248                                return;
1249                        }
1250
1251                        next_id = decls->ids[decls->cnt - 1];
1252                        next_t = btf__type_by_id(d->btf, next_id);
1253                        multidim = btf_is_array(next_t);
1254                        /* we need space if we have named non-pointer */
1255                        if (fname[0] && !last_was_ptr)
1256                                btf_dump_printf(d, " ");
1257                        /* no parentheses for multi-dimensional array */
1258                        if (!multidim)
1259                                btf_dump_printf(d, "(");
1260                        btf_dump_emit_type_chain(d, decls, fname, lvl);
1261                        if (!multidim)
1262                                btf_dump_printf(d, ")");
1263                        btf_dump_printf(d, "[%u]", a->nelems);
1264                        return;
1265                }
1266                case BTF_KIND_FUNC_PROTO: {
1267                        const struct btf_param *p = btf_params(t);
1268                        __u16 vlen = btf_vlen(t);
1269                        int i;
1270
1271                        btf_dump_emit_mods(d, decls);
1272                        if (decls->cnt) {
1273                                btf_dump_printf(d, " (");
1274                                btf_dump_emit_type_chain(d, decls, fname, lvl);
1275                                btf_dump_printf(d, ")");
1276                        } else {
1277                                btf_dump_emit_name(d, fname, last_was_ptr);
1278                        }
1279                        btf_dump_printf(d, "(");
1280                        /*
1281                         * Clang for BPF target generates func_proto with no
1282                         * args as a func_proto with a single void arg (e.g.,
1283                         * `int (*f)(void)` vs just `int (*f)()`). We are
1284                         * going to pretend there are no args for such case.
1285                         */
1286                        if (vlen == 1 && p->type == 0) {
1287                                btf_dump_printf(d, ")");
1288                                return;
1289                        }
1290
1291                        for (i = 0; i < vlen; i++, p++) {
1292                                if (i > 0)
1293                                        btf_dump_printf(d, ", ");
1294
1295                                /* last arg of type void is vararg */
1296                                if (i == vlen - 1 && p->type == 0) {
1297                                        btf_dump_printf(d, "...");
1298                                        break;
1299                                }
1300
1301                                name = btf_name_of(d, p->name_off);
1302                                btf_dump_emit_type_decl(d, p->type, name, lvl);
1303                        }
1304
1305                        btf_dump_printf(d, ")");
1306                        return;
1307                }
1308                default:
1309                        pr_warning("unexpected type in decl chain, kind:%u, id:[%u]\n",
1310                                   kind, id);
1311                        return;
1312                }
1313
1314                last_was_ptr = kind == BTF_KIND_PTR;
1315        }
1316
1317        btf_dump_emit_name(d, fname, last_was_ptr);
1318}
1319
1320/* return number of duplicates (occurrences) of a given name */
1321static size_t btf_dump_name_dups(struct btf_dump *d, struct hashmap *name_map,
1322                                 const char *orig_name)
1323{
1324        size_t dup_cnt = 0;
1325
1326        hashmap__find(name_map, orig_name, (void **)&dup_cnt);
1327        dup_cnt++;
1328        hashmap__set(name_map, orig_name, (void *)dup_cnt, NULL, NULL);
1329
1330        return dup_cnt;
1331}
1332
1333static const char *btf_dump_resolve_name(struct btf_dump *d, __u32 id,
1334                                         struct hashmap *name_map)
1335{
1336        struct btf_dump_type_aux_state *s = &d->type_states[id];
1337        const struct btf_type *t = btf__type_by_id(d->btf, id);
1338        const char *orig_name = btf_name_of(d, t->name_off);
1339        const char **cached_name = &d->cached_names[id];
1340        size_t dup_cnt;
1341
1342        if (t->name_off == 0)
1343                return "";
1344
1345        if (s->name_resolved)
1346                return *cached_name ? *cached_name : orig_name;
1347
1348        dup_cnt = btf_dump_name_dups(d, name_map, orig_name);
1349        if (dup_cnt > 1) {
1350                const size_t max_len = 256;
1351                char new_name[max_len];
1352
1353                snprintf(new_name, max_len, "%s___%zu", orig_name, dup_cnt);
1354                *cached_name = strdup(new_name);
1355        }
1356
1357        s->name_resolved = 1;
1358        return *cached_name ? *cached_name : orig_name;
1359}
1360
1361static const char *btf_dump_type_name(struct btf_dump *d, __u32 id)
1362{
1363        return btf_dump_resolve_name(d, id, d->type_names);
1364}
1365
1366static const char *btf_dump_ident_name(struct btf_dump *d, __u32 id)
1367{
1368        return btf_dump_resolve_name(d, id, d->ident_names);
1369}
1370