/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright (c) 2018 Facebook */

#include <linux/bpf.h>
#include <linux/btf.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/filter.h>
#include <linux/unistd.h>
#include <bpf/bpf.h>
#include <sys/resource.h>
#include <libelf.h>
#include <gelf.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>
#include <bpf/libbpf.h>
#include <bpf/btf.h>

#include "bpf_rlimit.h"
#include "bpf_util.h"
#include "test_btf.h"

#define MAX_INSNS       512
#define MAX_SUBPROGS    16

static uint32_t pass_cnt;
static uint32_t error_cnt;
static uint32_t skip_cnt;

#define CHECK(condition, format...) ({                                  \
        int __ret = !!(condition);                                      \
        if (__ret) {                                                    \
                fprintf(stderr, "%s:%d:FAIL ", __func__, __LINE__);     \
                fprintf(stderr, format);                                \
        }                                                               \
        __ret;                                                          \
})

static int count_result(int err)
{
        if (err)
                error_cnt++;
        else
                pass_cnt++;

        fprintf(stderr, "\n");
        return err;
}

static int __base_pr(enum libbpf_print_level level __attribute__((unused)),
                     const char *format, va_list args)
{
        return vfprintf(stderr, format, args);
}

#define BTF_END_RAW 0xdeadbeef
#define NAME_TBD 0xdeadb33f

#define NAME_NTH(N) (0xffff0000 | N)
#define IS_NAME_NTH(X) ((X & 0xffff0000) == 0xffff0000)
#define GET_NAME_NTH_IDX(X) (X & 0x0000ffff)

#define MAX_NR_RAW_U32 1024
#define BTF_LOG_BUF_SIZE 65535

static struct args {
        unsigned int raw_test_num;
        unsigned int file_test_num;
        unsigned int get_info_test_num;
        unsigned int info_raw_test_num;
        unsigned int dedup_test_num;
        bool raw_test;
        bool file_test;
        bool get_info_test;
        bool pprint_test;
        bool always_log;
        bool info_raw_test;
        bool dedup_test;
} args;

static char btf_log_buf[BTF_LOG_BUF_SIZE];

static struct btf_header hdr_tmpl = {
        .magic = BTF_MAGIC,
        .version = BTF_VERSION,
        .hdr_len = sizeof(struct btf_header),
};

/* several different mapv kinds(types) supported by pprint */
enum pprint_mapv_kind_t {
        PPRINT_MAPV_KIND_BASIC = 0,
        PPRINT_MAPV_KIND_INT128,
};

struct btf_raw_test {
        const char *descr;
        const char *str_sec;
        const char *map_name;
        const char *err_str;
        __u32 raw_types[MAX_NR_RAW_U32];
        __u32 str_sec_size;
        enum bpf_map_type map_type;
        __u32 key_size;
        __u32 value_size;
        __u32 key_type_id;
        __u32 value_type_id;
        __u32 max_entries;
        bool btf_load_err;
        bool map_create_err;
        bool ordered_map;
        bool lossless_map;
        bool percpu_map;
        int hdr_len_delta;
        int type_off_delta;
        int str_off_delta;
        int str_len_delta;
        enum pprint_mapv_kind_t mapv_kind;
};

#define BTF_STR_SEC(str) \
        .str_sec = str, .str_sec_size = sizeof(str)

static struct btf_raw_test raw_tests[] = {
/* enum E {
 *     E0,
 *     E1,
 * };
 *
 * struct A {
 *      unsigned long long m;
 *      int n;
 *      char o;
 *      [3 bytes hole]
 *      int p[8];
 *      int q[4][8];
 *      enum E r;
 * };
 */
{
        .descr = "struct test #1",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 6), 180),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                BTF_MEMBER_ENC(NAME_TBD, 6, 384),/* int q[4][8]         */
                BTF_MEMBER_ENC(NAME_TBD, 7, 1408), /* enum E r          */
                /* } */
                /* int[4][8] */
                BTF_TYPE_ARRAY_ENC(4, 1, 4),                    /* [6] */
                /* enum E */                                    /* [7] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), sizeof(int)),
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_ENUM_ENC(NAME_TBD, 1),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0q\0r\0E\0E0\0E1",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0q\0r\0E\0E0\0E1"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_test1_map",
        .key_size = sizeof(int),
        .value_size = 180,
        .key_type_id = 1,
        .value_type_id = 5,
        .max_entries = 4,
},

/* typedef struct b Struct_B;
 *
 * struct A {
 *     int m;
 *     struct b n[4];
 *     const Struct_B o[4];
 * };
 *
 * struct B {
 *     int m;
 *     int n;
 * };
 */
{
        .descr = "struct test #2",
        .raw_types = {
                /* int */                                       /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* struct b [4] */                              /* [2] */
                BTF_TYPE_ARRAY_ENC(4, 1, 4),

                /* struct A { */                                /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 3), 68),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m;               */
                BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct B n[4]        */
                BTF_MEMBER_ENC(NAME_TBD, 8, 288),/* const Struct_B o[4];*/
                /* } */

                /* struct B { */                                /* [4] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
                BTF_MEMBER_ENC(NAME_TBD, 1, 32),/* int n; */
                /* } */

                /* const int */                                 /* [5] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),
                /* typedef struct b Struct_B */ /* [6] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 4),
                /* const Struct_B */                            /* [7] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 6),
                /* const Struct_B [4] */                        /* [8] */
                BTF_TYPE_ARRAY_ENC(7, 1, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0B\0m\0n\0Struct_B",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0B\0m\0n\0Struct_B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_test2_map",
        .key_size = sizeof(int),
        .value_size = 68,
        .key_type_id = 1,
        .value_type_id = 3,
        .max_entries = 4,
},
{
        .descr = "struct test #3 Invalid member offset",
        .raw_types = {
                /* int */                                       /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int64 */                                     /* [2] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 64, 8),

                /* struct A { */                                /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 16),
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),        /* int m;               */
                BTF_MEMBER_ENC(NAME_TBD, 2, 0),         /* int64 n; */
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0",
        .str_sec_size = sizeof("\0A\0m\0n\0"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_test3_map",
        .key_size = sizeof(int),
        .value_size = 16,
        .key_type_id = 1,
        .value_type_id = 3,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid member bits_offset",
},
/*
 * struct A {
 *      unsigned long long m;
 *      int n;
 *      char o;
 *      [3 bytes hole]
 *      int p[8];
 * };
 */
{
        .descr = "global data test #1",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_test1_map",
        .key_size = sizeof(int),
        .value_size = 48,
        .key_type_id = 1,
        .value_type_id = 5,
        .max_entries = 4,
},
/*
 * struct A {
 *      unsigned long long m;
 *      int n;
 *      char o;
 *      [3 bytes hole]
 *      int p[8];
 * };
 * static struct A t; <- in .bss
 */
{
        .descr = "global data test #2",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                /* static struct A t */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [6] */
                /* .bss section */                              /* [7] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 48),
                BTF_VAR_SECINFO_ENC(6, 0, 48),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 48,
        .key_type_id = 0,
        .value_type_id = 7,
        .max_entries = 1,
},
{
        .descr = "global data test #3",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* static int t */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [2] */
                /* .bss section */                              /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(2, 0, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0t\0.bss",
        .str_sec_size = sizeof("\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 3,
        .max_entries = 1,
},
{
        .descr = "global data test #4, unsupported linkage",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* static int t */
                BTF_VAR_ENC(NAME_TBD, 1, 2),                    /* [2] */
                /* .bss section */                              /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(2, 0, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0t\0.bss",
        .str_sec_size = sizeof("\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 3,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Linkage not supported",
},
{
        .descr = "global data test #5, invalid var type",
        .raw_types = {
                /* static void t */
                BTF_VAR_ENC(NAME_TBD, 0, 0),                    /* [1] */
                /* .bss section */                              /* [2] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(1, 0, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0t\0.bss",
        .str_sec_size = sizeof("\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 2,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid type_id",
},
{
        .descr = "global data test #6, invalid var type (fwd type)",
        .raw_types = {
                /* union A */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0), /* [1] */
                /* static union A t */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [2] */
                /* .bss section */                              /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(2, 0, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0.bss",
        .str_sec_size = sizeof("\0A\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 2,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid type",
},
{
        .descr = "global data test #7, invalid var type (fwd type)",
        .raw_types = {
                /* union A */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0), /* [1] */
                /* static union A t */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [2] */
                /* .bss section */                              /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(1, 0, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0.bss",
        .str_sec_size = sizeof("\0A\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 2,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid type",
},
{
        .descr = "global data test #8, invalid var size",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                /* static struct A t */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [6] */
                /* .bss section */                              /* [7] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 48),
                BTF_VAR_SECINFO_ENC(6, 0, 47),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 48,
        .key_type_id = 0,
        .value_type_id = 7,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid size",
},
{
        .descr = "global data test #9, invalid var size",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                /* static struct A t */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [6] */
                /* .bss section */                              /* [7] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 46),
                BTF_VAR_SECINFO_ENC(6, 0, 48),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 48,
        .key_type_id = 0,
        .value_type_id = 7,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid size",
},
{
        .descr = "global data test #10, invalid var size",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                /* static struct A t */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [6] */
                /* .bss section */                              /* [7] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 46),
                BTF_VAR_SECINFO_ENC(6, 0, 46),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 48,
        .key_type_id = 0,
        .value_type_id = 7,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid size",
},
{
        .descr = "global data test #11, multiple section members",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                /* static struct A t */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [6] */
                /* static int u */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [7] */
                /* .bss section */                              /* [8] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
                BTF_VAR_SECINFO_ENC(6, 10, 48),
                BTF_VAR_SECINFO_ENC(7, 58, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 62,
        .key_type_id = 0,
        .value_type_id = 8,
        .max_entries = 1,
},
{
        .descr = "global data test #12, invalid offset",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                /* static struct A t */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [6] */
                /* static int u */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [7] */
                /* .bss section */                              /* [8] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
                BTF_VAR_SECINFO_ENC(6, 10, 48),
                BTF_VAR_SECINFO_ENC(7, 60, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 62,
        .key_type_id = 0,
        .value_type_id = 8,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid offset+size",
},
{
        .descr = "global data test #13, invalid offset",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                /* static struct A t */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [6] */
                /* static int u */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [7] */
                /* .bss section */                              /* [8] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
                BTF_VAR_SECINFO_ENC(6, 10, 48),
                BTF_VAR_SECINFO_ENC(7, 12, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 62,
        .key_type_id = 0,
        .value_type_id = 8,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid offset",
},
{
        .descr = "global data test #14, invalid offset",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* unsigned long long */
                BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
                /* char */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
                /* int[8] */
                BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
                /* struct A { */                                /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
                BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
                BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
                BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
                /* } */
                /* static struct A t */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [6] */
                /* static int u */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [7] */
                /* .bss section */                              /* [8] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
                BTF_VAR_SECINFO_ENC(7, 58, 4),
                BTF_VAR_SECINFO_ENC(6, 10, 48),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
        .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 62,
        .key_type_id = 0,
        .value_type_id = 8,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid offset",
},
{
        .descr = "global data test #15, not var kind",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [2] */
                /* .bss section */                              /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(1, 0, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0.bss",
        .str_sec_size = sizeof("\0A\0t\0.bss"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 3,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Not a VAR kind member",
},
{
        .descr = "global data test #16, invalid var referencing sec",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_VAR_ENC(NAME_TBD, 5, 0),                    /* [2] */
                BTF_VAR_ENC(NAME_TBD, 2, 0),                    /* [3] */
                /* a section */                                 /* [4] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(3, 0, 4),
                /* a section */                                 /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(6, 0, 4),
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [6] */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0s\0a\0a",
        .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 4,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid type_id",
},
{
        .descr = "global data test #17, invalid var referencing var",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [2] */
                BTF_VAR_ENC(NAME_TBD, 2, 0),                    /* [3] */
                /* a section */                                 /* [4] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(3, 0, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0s\0a\0a",
        .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 4,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid type_id",
},
{
        .descr = "global data test #18, invalid var loop",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_VAR_ENC(NAME_TBD, 2, 0),                    /* [2] */
                /* .bss section */                              /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
                BTF_VAR_SECINFO_ENC(2, 0, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0aaa",
        .str_sec_size = sizeof("\0A\0t\0aaa"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 4,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid type_id",
},
{
        .descr = "global data test #19, invalid var referencing var",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_VAR_ENC(NAME_TBD, 3, 0),                    /* [2] */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [3] */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0s\0a\0a",
        .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 4,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid type_id",
},
{
        .descr = "global data test #20, invalid ptr referencing var",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* PTR type_id=3        */                      /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 3),
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [3] */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0s\0a\0a",
        .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 4,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid type_id",
},
{
        .descr = "global data test #21, var included in struct",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* struct A { */                                /* [2] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
                BTF_MEMBER_ENC(NAME_TBD, 3, 32),/* VAR type_id=3; */
                /* } */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [3] */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0s\0a\0a",
        .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 4,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid member",
},
{
        .descr = "global data test #22, array of var",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_ARRAY_ENC(3, 1, 4),                    /* [2] */
                BTF_VAR_ENC(NAME_TBD, 1, 0),                    /* [3] */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0t\0s\0a\0a",
        .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = ".bss",
        .key_size = sizeof(int),
        .value_size = 4,
        .key_type_id = 0,
        .value_type_id = 4,
        .max_entries = 1,
        .btf_load_err = true,
        .err_str = "Invalid elem",
},
/* Test member exceeds the size of struct.
 *
 * struct A {
 *     int m;
 *     int n;
 * };
 */
{
        .descr = "size check test #1",
        .raw_types = {
                /* int */                                       /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* struct A { */                                /* [2] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2 -  1),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
                BTF_MEMBER_ENC(NAME_TBD, 1, 32),/* int n; */
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n",
        .str_sec_size = sizeof("\0A\0m\0n"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "size_check1_map",
        .key_size = sizeof(int),
        .value_size = 1,
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Member exceeds struct_size",
},

/* Test member exeeds the size of struct
 *
 * struct A {
 *     int m;
 *     int n[2];
 * };
 */
{
        .descr = "size check test #2",
        .raw_types = {
                /* int */                                       /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
                /* int[2] */                                    /* [2] */
                BTF_TYPE_ARRAY_ENC(1, 1, 2),
                /* struct A { */                                /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 3 - 1),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
                BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* int n[2]; */
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n",
        .str_sec_size = sizeof("\0A\0m\0n"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "size_check2_map",
        .key_size = sizeof(int),
        .value_size = 1,
        .key_type_id = 1,
        .value_type_id = 3,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Member exceeds struct_size",
},

/* Test member exeeds the size of struct
 *
 * struct A {
 *     int m;
 *     void *n;
 * };
 */
{
        .descr = "size check test #3",
        .raw_types = {
                /* int */                                       /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),

                /* void* */                                     /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
                /* struct A { */                                /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) + sizeof(void *) - 1),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
                BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* void *n; */
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0n",
        .str_sec_size = sizeof("\0A\0m\0n"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "size_check3_map",
        .key_size = sizeof(int),
        .value_size = 1,
        .key_type_id = 1,
        .value_type_id = 3,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Member exceeds struct_size",
},

/* Test member exceeds the size of struct
 *
 * enum E {
 *     E0,
 *     E1,
 * };
 *
 * struct A {
 *     int m;
 *     enum E n;
 * };
 */
{
        .descr = "size check test #4",
        .raw_types = {
                /* int */                       /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
                /* enum E { */                  /* [2] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), sizeof(int)),
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_ENUM_ENC(NAME_TBD, 1),
                /* } */
                /* struct A { */                /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2 - 1),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
                BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* enum E n; */
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0E\0E0\0E1\0A\0m\0n",
        .str_sec_size = sizeof("\0E\0E0\0E1\0A\0m\0n"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "size_check4_map",
        .key_size = sizeof(int),
        .value_size = 1,
        .key_type_id = 1,
        .value_type_id = 3,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Member exceeds struct_size",
},

/* Test member unexceeds the size of struct
 *
 * enum E {
 *     E0,
 *     E1,
 * };
 *
 * struct A {
 *     char m;
 *     enum E __attribute__((packed)) n;
 * };
 */
{
        .descr = "size check test #5",
        .raw_types = {
                /* int */                       /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
                /* char */                      /* [2] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),
                /* enum E { */                  /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 1),
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_ENUM_ENC(NAME_TBD, 1),
                /* } */
                /* struct A { */                /* [4] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 2),
                BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* char m; */
                BTF_MEMBER_ENC(NAME_TBD, 3, 8),/* enum E __attribute__((packed)) n; */
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0E\0E0\0E1\0A\0m\0n",
        .str_sec_size = sizeof("\0E\0E0\0E1\0A\0m\0n"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "size_check5_map",
        .key_size = sizeof(int),
        .value_size = 2,
        .key_type_id = 1,
        .value_type_id = 4,
        .max_entries = 4,
},

/* typedef const void * const_void_ptr;
 * struct A {
 *      const_void_ptr m;
 * };
 */
{
        .descr = "void test #1",
        .raw_types = {
                /* int */               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* const void */        /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
                /* const void* */       /* [3] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
                /* typedef const void * const_void_ptr */
                BTF_TYPEDEF_ENC(NAME_TBD, 3),   /* [4] */
                /* struct A { */        /* [5] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
                /* const_void_ptr m; */
                BTF_MEMBER_ENC(NAME_TBD, 4, 0),
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0const_void_ptr\0A\0m",
        .str_sec_size = sizeof("\0const_void_ptr\0A\0m"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "void_test1_map",
        .key_size = sizeof(int),
        .value_size = sizeof(void *),
        .key_type_id = 1,
        .value_type_id = 4,
        .max_entries = 4,
},

/* struct A {
 *     const void m;
 * };
 */
{
        .descr = "void test #2",
        .raw_types = {
                /* int */               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* const void */        /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
                /* struct A { */        /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 8),
                /* const void m; */
                BTF_MEMBER_ENC(NAME_TBD, 2, 0),
                /* } */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m",
        .str_sec_size = sizeof("\0A\0m"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "void_test2_map",
        .key_size = sizeof(int),
        .value_size = sizeof(void *),
        .key_type_id = 1,
        .value_type_id = 3,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid member",
},

/* typedef const void * const_void_ptr;
 * const_void_ptr[4]
 */
{
        .descr = "void test #3",
        .raw_types = {
                /* int */               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* const void */        /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
                /* const void* */       /* [3] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
                /* typedef const void * const_void_ptr */
                BTF_TYPEDEF_ENC(NAME_TBD, 3),   /* [4] */
                /* const_void_ptr[4] */
                BTF_TYPE_ARRAY_ENC(4, 1, 4),    /* [5] */
                BTF_END_RAW,
        },
        .str_sec = "\0const_void_ptr",
        .str_sec_size = sizeof("\0const_void_ptr"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "void_test3_map",
        .key_size = sizeof(int),
        .value_size = sizeof(void *) * 4,
        .key_type_id = 1,
        .value_type_id = 5,
        .max_entries = 4,
},

/* const void[4]  */
{
        .descr = "void test #4",
        .raw_types = {
                /* int */               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* const void */        /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
                /* const void[4] */     /* [3] */
                BTF_TYPE_ARRAY_ENC(2, 1, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m",
        .str_sec_size = sizeof("\0A\0m"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "void_test4_map",
        .key_size = sizeof(int),
        .value_size = sizeof(void *) * 4,
        .key_type_id = 1,
        .value_type_id = 3,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid elem",
},

/* Array_A  <------------------+
 *     elem_type == Array_B    |
 *                    |        |
 *                    |        |
 * Array_B  <-------- +        |
 *      elem_type == Array A --+
 */
{
        .descr = "loop test #1",
        .raw_types = {
                /* int */                       /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* Array_A */                   /* [2] */
                BTF_TYPE_ARRAY_ENC(3, 1, 8),
                /* Array_B */                   /* [3] */
                BTF_TYPE_ARRAY_ENC(2, 1, 8),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "loop_test1_map",
        .key_size = sizeof(int),
        .value_size = sizeof(sizeof(int) * 8),
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Loop detected",
},

/* typedef is _before_ the BTF type of Array_A and Array_B
 *
 * typedef Array_B int_array;
 *
 * Array_A  <------------------+
 *     elem_type == int_array  |
 *                    |        |
 *                    |        |
 * Array_B  <-------- +        |
 *      elem_type == Array_A --+
 */
{
        .descr = "loop test #2",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* typedef Array_B int_array */
                BTF_TYPEDEF_ENC(1, 4),                          /* [2] */
                /* Array_A */
                BTF_TYPE_ARRAY_ENC(2, 1, 8),                    /* [3] */
                /* Array_B */
                BTF_TYPE_ARRAY_ENC(3, 1, 8),                    /* [4] */
                BTF_END_RAW,
        },
        .str_sec = "\0int_array\0",
        .str_sec_size = sizeof("\0int_array"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "loop_test2_map",
        .key_size = sizeof(int),
        .value_size = sizeof(sizeof(int) * 8),
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Loop detected",
},

/* Array_A  <------------------+
 *     elem_type == Array_B    |
 *                    |        |
 *                    |        |
 * Array_B  <-------- +        |
 *      elem_type == Array_A --+
 */
{
        .descr = "loop test #3",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* Array_A */                           /* [2] */
                BTF_TYPE_ARRAY_ENC(3, 1, 8),
                /* Array_B */                           /* [3] */
                BTF_TYPE_ARRAY_ENC(2, 1, 8),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "loop_test3_map",
        .key_size = sizeof(int),
        .value_size = sizeof(sizeof(int) * 8),
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Loop detected",
},

/* typedef is _between_ the BTF type of Array_A and Array_B
 *
 * typedef Array_B int_array;
 *
 * Array_A  <------------------+
 *     elem_type == int_array  |
 *                    |        |
 *                    |        |
 * Array_B  <-------- +        |
 *      elem_type == Array_A --+
 */
{
        .descr = "loop test #4",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* Array_A */                           /* [2] */
                BTF_TYPE_ARRAY_ENC(3, 1, 8),
                /* typedef Array_B int_array */         /* [3] */
                BTF_TYPEDEF_ENC(NAME_TBD, 4),
                /* Array_B */                           /* [4] */
                BTF_TYPE_ARRAY_ENC(2, 1, 8),
                BTF_END_RAW,
        },
        .str_sec = "\0int_array\0",
        .str_sec_size = sizeof("\0int_array"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "loop_test4_map",
        .key_size = sizeof(int),
        .value_size = sizeof(sizeof(int) * 8),
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Loop detected",
},

/* typedef struct B Struct_B
 *
 * struct A {
 *     int x;
 *     Struct_B y;
 * };
 *
 * struct B {
 *     int x;
 *     struct A y;
 * };
 */
{
        .descr = "loop test #5",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* struct A */                                  /* [2] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x;       */
                BTF_MEMBER_ENC(NAME_TBD, 3, 32),/* Struct_B y;  */
                /* typedef struct B Struct_B */
                BTF_TYPEDEF_ENC(NAME_TBD, 4),                   /* [3] */
                /* struct B */                                  /* [4] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x;       */
                BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct A y;  */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0x\0y\0Struct_B\0B\0x\0y",
        .str_sec_size = sizeof("\0A\0x\0y\0Struct_B\0B\0x\0y"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "loop_test5_map",
        .key_size = sizeof(int),
        .value_size = 8,
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Loop detected",
},

/* struct A {
 *     int x;
 *     struct A array_a[4];
 * };
 */
{
        .descr = "loop test #6",
        .raw_types = {
                /* int */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_ARRAY_ENC(3, 1, 4),                    /* [2] */
                /* struct A */                                  /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
                BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x;               */
                BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct A array_a[4]; */
                BTF_END_RAW,
        },
        .str_sec = "\0A\0x\0y",
        .str_sec_size = sizeof("\0A\0x\0y"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "loop_test6_map",
        .key_size = sizeof(int),
        .value_size = 8,
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Loop detected",
},

{
        .descr = "loop test #7",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* struct A { */                        /* [2] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
                /*     const void *m;   */
                BTF_MEMBER_ENC(NAME_TBD, 3, 0),
                /* CONST type_id=3      */              /* [3] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
                /* PTR type_id=2        */              /* [4] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 3),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m",
        .str_sec_size = sizeof("\0A\0m"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "loop_test7_map",
        .key_size = sizeof(int),
        .value_size = sizeof(void *),
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Loop detected",
},

{
        .descr = "loop test #8",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* struct A { */                        /* [2] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
                /*     const void *m;   */
                BTF_MEMBER_ENC(NAME_TBD, 4, 0),
                /* struct B { */                        /* [3] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
                /*     const void *n;   */
                BTF_MEMBER_ENC(NAME_TBD, 6, 0),
                /* CONST type_id=5      */              /* [4] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 5),
                /* PTR type_id=6        */              /* [5] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 6),
                /* CONST type_id=7      */              /* [6] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 7),
                /* PTR type_id=4        */              /* [7] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 4),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0m\0B\0n",
        .str_sec_size = sizeof("\0A\0m\0B\0n"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "loop_test8_map",
        .key_size = sizeof(int),
        .value_size = sizeof(void *),
        .key_type_id = 1,
        .value_type_id = 2,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Loop detected",
},

{
        .descr = "string section does not end with null",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0int",
        .str_sec_size = sizeof("\0int") - 1,
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid string section",
},

{
        .descr = "empty string section",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = 0,
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid string section",
},

{
        .descr = "empty type section",
        .raw_types = {
                BTF_END_RAW,
        },
        .str_sec = "\0int",
        .str_sec_size = sizeof("\0int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "No type found",
},

{
        .descr = "btf_header test. Longer hdr_len",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0int",
        .str_sec_size = sizeof("\0int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .hdr_len_delta = 4,
        .err_str = "Unsupported btf_header",
},

{
        .descr = "btf_header test. Gap between hdr and type",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0int",
        .str_sec_size = sizeof("\0int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .type_off_delta = 4,
        .err_str = "Unsupported section found",
},

{
        .descr = "btf_header test. Gap between type and str",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0int",
        .str_sec_size = sizeof("\0int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .str_off_delta = 4,
        .err_str = "Unsupported section found",
},

{
        .descr = "btf_header test. Overlap between type and str",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0int",
        .str_sec_size = sizeof("\0int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .str_off_delta = -4,
        .err_str = "Section overlap found",
},

{
        .descr = "btf_header test. Larger BTF size",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0int",
        .str_sec_size = sizeof("\0int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .str_len_delta = -4,
        .err_str = "Unsupported section found",
},

{
        .descr = "btf_header test. Smaller BTF size",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0int",
        .str_sec_size = sizeof("\0int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "hdr_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .str_len_delta = 4,
        .err_str = "Total section length too long",
},

{
        .descr = "array test. index_type/elem_type \"int\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int[16] */                           /* [2] */
                BTF_TYPE_ARRAY_ENC(1, 1, 16),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "array test. index_type/elem_type \"const int\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int[16] */                           /* [2] */
                BTF_TYPE_ARRAY_ENC(3, 3, 16),
                /* CONST type_id=1 */                   /* [3] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "array test. index_type \"const int:31\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int:31 */                            /* [2] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 31, 4),
                /* int[16] */                           /* [3] */
                BTF_TYPE_ARRAY_ENC(1, 4, 16),
                /* CONST type_id=2 */                   /* [4] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid index",
},

{
        .descr = "array test. elem_type \"const int:31\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int:31 */                            /* [2] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 31, 4),
                /* int[16] */                           /* [3] */
                BTF_TYPE_ARRAY_ENC(4, 1, 16),
                /* CONST type_id=2 */                   /* [4] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid array of int",
},

{
        .descr = "array test. index_type \"void\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int[16] */                           /* [2] */
                BTF_TYPE_ARRAY_ENC(1, 0, 16),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid index",
},

{
        .descr = "array test. index_type \"const void\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int[16] */                           /* [2] */
                BTF_TYPE_ARRAY_ENC(1, 3, 16),
                /* CONST type_id=0 (void) */            /* [3] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid index",
},

{
        .descr = "array test. elem_type \"const void\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int[16] */                           /* [2] */
                BTF_TYPE_ARRAY_ENC(3, 1, 16),
                /* CONST type_id=0 (void) */            /* [3] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid elem",
},

{
        .descr = "array test. elem_type \"const void *\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* const void *[16] */                  /* [2] */
                BTF_TYPE_ARRAY_ENC(3, 1, 16),
                /* CONST type_id=4 */                   /* [3] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
                /* void* */                             /* [4] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "array test. index_type \"const void *\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* const void *[16] */                  /* [2] */
                BTF_TYPE_ARRAY_ENC(3, 3, 16),
                /* CONST type_id=4 */                   /* [3] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
                /* void* */                             /* [4] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid index",
},

{
        .descr = "array test. t->size != 0\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* int[16] */                           /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 1),
                BTF_ARRAY_ENC(1, 1, 16),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "size != 0",
},

{
        .descr = "int test. invalid int_data",
        .raw_types = {
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), 4),
                0x10000000,
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid int_data",
},

{
        .descr = "invalid BTF_INFO",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                BTF_TYPE_ENC(0, 0x10000000, 4),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info",
},

{
        .descr = "fwd test. t->type != 0\"",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* fwd type */                          /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 1),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "fwd_test_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "type != 0",
},

{
        .descr = "typedef (invalid name, name_off = 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPEDEF_ENC(0, 1),                          /* [2] */
                BTF_END_RAW,
        },
        .str_sec = "\0__int",
        .str_sec_size = sizeof("\0__int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "typedef_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "typedef (invalid name, invalid identifier)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPEDEF_ENC(NAME_TBD, 1),                   /* [2] */
                BTF_END_RAW,
        },
        .str_sec = "\0__!int",
        .str_sec_size = sizeof("\0__!int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "typedef_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "ptr type (invalid name, name_off <> 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 1),      /* [2] */
                BTF_END_RAW,
        },
        .str_sec = "\0__int",
        .str_sec_size = sizeof("\0__int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "ptr_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "volatile type (invalid name, name_off <> 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_VOLATILE, 0, 0), 1), /* [2] */
                BTF_END_RAW,
        },
        .str_sec = "\0__int",
        .str_sec_size = sizeof("\0__int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "volatile_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "const type (invalid name, name_off <> 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),    /* [2] */
                BTF_END_RAW,
        },
        .str_sec = "\0__int",
        .str_sec_size = sizeof("\0__int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "const_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "restrict type (invalid name, name_off <> 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 1),   /* [2] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_RESTRICT, 0, 0), 2), /* [3] */
                BTF_END_RAW,
        },
        .str_sec = "\0__int",
        .str_sec_size = sizeof("\0__int"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "restrict_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "fwd type (invalid name, name_off = 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 0),   /* [2] */
                BTF_END_RAW,
        },
        .str_sec = "\0__skb",
        .str_sec_size = sizeof("\0__skb"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "fwd_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "fwd type (invalid name, invalid identifier)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 0),      /* [2] */
                BTF_END_RAW,
        },
        .str_sec = "\0__!skb",
        .str_sec_size = sizeof("\0__!skb"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "fwd_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "array type (invalid name, name_off <> 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 0),    /* [2] */
                BTF_ARRAY_ENC(1, 1, 4),
                BTF_END_RAW,
        },
        .str_sec = "\0__skb",
        .str_sec_size = sizeof("\0__skb"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "struct type (name_off = 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0,
                             BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),   /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, 0),
                BTF_END_RAW,
        },
        .str_sec = "\0A",
        .str_sec_size = sizeof("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "struct type (invalid name, invalid identifier)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),   /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, 0),
                BTF_END_RAW,
        },
        .str_sec = "\0A!\0B",
        .str_sec_size = sizeof("\0A!\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "struct member (name_off = 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0,
                             BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),   /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, 0),
                BTF_END_RAW,
        },
        .str_sec = "\0A",
        .str_sec_size = sizeof("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "struct member (invalid name, invalid identifier)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),   /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, 0),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0B*",
        .str_sec_size = sizeof("\0A\0B*"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "enum type (name_off = 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0,
                             BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
                             sizeof(int)),                              /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_END_RAW,
        },
        .str_sec = "\0A\0B",
        .str_sec_size = sizeof("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "enum_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "enum type (invalid name, invalid identifier)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
                             sizeof(int)),                              /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_END_RAW,
        },
        .str_sec = "\0A!\0B",
        .str_sec_size = sizeof("\0A!\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "enum_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "enum member (invalid name, name_off = 0)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0,
                             BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
                             sizeof(int)),                              /* [2] */
                BTF_ENUM_ENC(0, 0),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "enum_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "enum member (invalid name, invalid identifier)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0,
                             BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
                             sizeof(int)),                              /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_END_RAW,
        },
        .str_sec = "\0A!",
        .str_sec_size = sizeof("\0A!"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "enum_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},
{
        .descr = "arraymap invalid btf key (a bit field)",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* 32 bit int with 32 bit offset */     /* [2] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 32, 32, 8),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_map_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 2,
        .value_type_id = 1,
        .max_entries = 4,
        .map_create_err = true,
},

{
        .descr = "arraymap invalid btf key (!= 32 bits)",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* 16 bit int with 0 bit offset */      /* [2] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 16, 2),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_map_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 2,
        .value_type_id = 1,
        .max_entries = 4,
        .map_create_err = true,
},

{
        .descr = "arraymap invalid btf value (too small)",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_map_check_btf",
        .key_size = sizeof(int),
        /* btf_value_size < map->value_size */
        .value_size = sizeof(__u64),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .map_create_err = true,
},

{
        .descr = "arraymap invalid btf value (too big)",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_map_check_btf",
        .key_size = sizeof(int),
        /* btf_value_size > map->value_size */
        .value_size = sizeof(__u16),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .map_create_err = true,
},

{
        .descr = "func proto (int (*)(int, unsigned int))",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* int (*)(int, unsigned int) */
                BTF_FUNC_PROTO_ENC(1, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0, 2),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "func proto (vararg)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int, unsigned int, ...) */
                BTF_FUNC_PROTO_ENC(0, 3),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0, 2),
                        BTF_FUNC_PROTO_ARG_ENC(0, 0),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "func proto (vararg with name)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, unsigned int b, ... c) */
                BTF_FUNC_PROTO_ENC(0, 3),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 0),
                BTF_END_RAW,
        },
        .str_sec = "\0a\0b\0c",
        .str_sec_size = sizeof("\0a\0b\0c"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid arg#3",
},

{
        .descr = "func proto (arg after vararg)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, ..., unsigned int b) */
                BTF_FUNC_PROTO_ENC(0, 3),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0, 0),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
                BTF_END_RAW,
        },
        .str_sec = "\0a\0b",
        .str_sec_size = sizeof("\0a\0b"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid arg#2",
},

{
        .descr = "func proto (CONST=>TYPEDEF=>PTR=>FUNC_PROTO)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* typedef void (*func_ptr)(int, unsigned int) */
                BTF_TYPEDEF_ENC(NAME_TBD, 5),                   /* [3] */
                /* const func_ptr */
                BTF_CONST_ENC(3),                               /* [4] */
                BTF_PTR_ENC(6),                                 /* [5] */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [6] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0, 2),
                BTF_END_RAW,
        },
        .str_sec = "\0func_ptr",
        .str_sec_size = sizeof("\0func_ptr"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "func proto (TYPEDEF=>FUNC_PROTO)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                BTF_TYPEDEF_ENC(NAME_TBD, 4),                   /* [3] */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [4] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0, 2),
                BTF_END_RAW,
        },
        .str_sec = "\0func_typedef",
        .str_sec_size = sizeof("\0func_typedef"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "func proto (btf_resolve(arg))",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                /* void (*)(const void *) */
                BTF_FUNC_PROTO_ENC(0, 1),                       /* [2] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 3),
                BTF_CONST_ENC(4),                               /* [3] */
                BTF_PTR_ENC(0),                                 /* [4] */
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "func proto (Not all arg has name)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int, unsigned int b) */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 1),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
                BTF_END_RAW,
        },
        .str_sec = "\0b",
        .str_sec_size = sizeof("\0b"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "func proto (Bad arg name_off)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, unsigned int <bad_name_off>) */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0x0fffffff, 2),
                BTF_END_RAW,
        },
        .str_sec = "\0a",
        .str_sec_size = sizeof("\0a"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid arg#2",
},

{
        .descr = "func proto (Bad arg name)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, unsigned int !!!) */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
                BTF_END_RAW,
        },
        .str_sec = "\0a\0!!!",
        .str_sec_size = sizeof("\0a\0!!!"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid arg#2",
},

{
        .descr = "func proto (Invalid return type)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* <bad_ret_type> (*)(int, unsigned int) */
                BTF_FUNC_PROTO_ENC(100, 2),                     /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0, 2),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid return type",
},

{
        .descr = "func proto (with func name)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void func_proto(int, unsigned int) */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 2), 0),     /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0, 2),
                BTF_END_RAW,
        },
        .str_sec = "\0func_proto",
        .str_sec_size = sizeof("\0func_proto"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "func proto (const void arg)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(const void) */
                BTF_FUNC_PROTO_ENC(0, 1),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(0, 4),
                BTF_CONST_ENC(0),                               /* [4] */
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid arg#1",
},

{
        .descr = "func (void func(int a, unsigned int b))",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, unsigned int b) */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
                /* void func(int a, unsigned int b) */
                BTF_FUNC_ENC(NAME_TBD, 3),                      /* [4] */
                BTF_END_RAW,
        },
        .str_sec = "\0a\0b\0func",
        .str_sec_size = sizeof("\0a\0b\0func"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "func (No func name)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, unsigned int b) */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
                /* void <no_name>(int a, unsigned int b) */
                BTF_FUNC_ENC(0, 3),                             /* [4] */
                BTF_END_RAW,
        },
        .str_sec = "\0a\0b",
        .str_sec_size = sizeof("\0a\0b"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "func (Invalid func name)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, unsigned int b) */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
                /* void !!!(int a, unsigned int b) */
                BTF_FUNC_ENC(NAME_TBD, 3),                      /* [4] */
                BTF_END_RAW,
        },
        .str_sec = "\0a\0b\0!!!",
        .str_sec_size = sizeof("\0a\0b\0!!!"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid name",
},

{
        .descr = "func (Some arg has no name)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, unsigned int) */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(0, 2),
                /* void func(int a, unsigned int) */
                BTF_FUNC_ENC(NAME_TBD, 3),                      /* [4] */
                BTF_END_RAW,
        },
        .str_sec = "\0a\0func",
        .str_sec_size = sizeof("\0a\0func"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid arg#2",
},

{
        .descr = "func (Non zero vlen)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),               /* [2] */
                /* void (*)(int a, unsigned int b) */
                BTF_FUNC_PROTO_ENC(0, 2),                       /* [3] */
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
                        BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
                /* void func(int a, unsigned int b) */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC, 0, 2), 3),   /* [4] */
                BTF_END_RAW,
        },
        .str_sec = "\0a\0b\0func",
        .str_sec_size = sizeof("\0a\0b\0func"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid func linkage",
},

{
        .descr = "func (Not referring to FUNC_PROTO)",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
                BTF_FUNC_ENC(NAME_TBD, 1),                      /* [2] */
                BTF_END_RAW,
        },
        .str_sec = "\0func",
        .str_sec_size = sizeof("\0func"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid type_id",
},

{
        .descr = "invalid int kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_INT, 1, 0), 4),   /* [2] */
                BTF_INT_ENC(0, 0, 32),
                BTF_END_RAW,
        },
        BTF_STR_SEC(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "int_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "invalid ptr kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 1, 0), 1),   /* [2] */
                BTF_END_RAW,
        },
        BTF_STR_SEC(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "ptr_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "invalid array kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 1, 0), 0), /* [2] */
                BTF_ARRAY_ENC(1, 1, 1),
                BTF_END_RAW,
        },
        BTF_STR_SEC(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "array_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "invalid enum kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 1, 1), 4),  /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "enum_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "valid fwd kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0),      /* [2] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "fwd_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "invalid typedef kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(NAME_TBD,
                             BTF_INFO_ENC(BTF_KIND_TYPEDEF, 1, 0), 1),  /* [2] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "typedef_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "invalid volatile kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */

                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_VOLATILE, 1, 0), 1),      /* [2] */
                BTF_END_RAW,
        },
        BTF_STR_SEC(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "volatile_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "invalid const kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 1, 0), 1), /* [2] */
                BTF_END_RAW,
        },
        BTF_STR_SEC(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "const_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "invalid restrict kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_RESTRICT, 1, 0), 1),      /* [2] */
                BTF_END_RAW,
        },
        BTF_STR_SEC(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "restrict_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "invalid func kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 0), 0),    /* [2] */
                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC, 1, 0), 2),   /* [3] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "invalid func_proto kind_flag",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 1, 0), 0),    /* [2] */
                BTF_END_RAW,
        },
        BTF_STR_SEC(""),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "func_proto_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid btf_info kind_flag",
},

{
        .descr = "valid struct, kind_flag, bitfield_size = 0",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 8),        /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(0, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(0, 32)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "valid struct, kind_flag, int member, bitfield_size != 0",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),        /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 4)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "valid union, kind_flag, int member, bitfield_size != 0",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "union_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "valid struct, kind_flag, enum member, bitfield_size != 0",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),/* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 4)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B\0C"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "valid union, kind_flag, enum member, bitfield_size != 0",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B\0C"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "union_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "valid struct, kind_flag, typedef member, bitfield_size != 0",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),/* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 4, BTF_MEMBER_OFFSET(4, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 5, BTF_MEMBER_OFFSET(4, 4)),
                BTF_TYPEDEF_ENC(NAME_TBD, 1),                           /* [4] */
                BTF_TYPEDEF_ENC(NAME_TBD, 2),                           /* [5] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B\0C\0D\0E"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "valid union, kind_flag, typedef member, bitfield_size != 0",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 4, BTF_MEMBER_OFFSET(4, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 5, BTF_MEMBER_OFFSET(4, 0)),
                BTF_TYPEDEF_ENC(NAME_TBD, 1),                           /* [4] */
                BTF_TYPEDEF_ENC(NAME_TBD, 2),                           /* [5] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B\0C\0D\0E"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "union_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "invalid struct, kind_flag, bitfield_size greater than struct size",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),        /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 20)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Member exceeds struct_size",
},

{
        .descr = "invalid struct, kind_flag, bitfield base_type int not regular",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 20, 4),                  /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),        /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(20, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(20, 20)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid member base type",
},

{
        .descr = "invalid struct, kind_flag, base_type int not regular",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 12, 4),                  /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),        /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(8, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(8, 8)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid member base type",
},

{
        .descr = "invalid union, kind_flag, bitfield_size greater than struct size",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 2), /* [2] */
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(8, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 0)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "union_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Member exceeds struct_size",
},

{
        .descr = "invalid struct, kind_flag, int member, bitfield_size = 0, wrong byte alignment",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 12),       /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 36)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid member offset",
},

{
        .descr = "invalid struct, kind_flag, enum member, bitfield_size = 0, wrong byte alignment",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
                BTF_ENUM_ENC(NAME_TBD, 0),
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 12),       /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 36)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A\0B\0C"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
        .btf_load_err = true,
        .err_str = "Invalid member offset",
},

{
        .descr = "128-bit int",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16),                /* [2] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "int_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "struct, 128-bit int member",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16),                /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 16),       /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, 0),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "struct, 120-bit int member bitfield",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 120, 16),                /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 16),       /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, 0),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "struct, kind_flag, 128-bit int member",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16),                /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 16),       /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},

{
        .descr = "struct, kind_flag, 120-bit int member bitfield",
        .raw_types = {
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16),                /* [2] */
                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 16),       /* [3] */
                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(120, 0)),
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0A"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "struct_type_check_btf",
        .key_size = sizeof(int),
        .value_size = sizeof(int),
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 4,
},
/*
 * typedef int arr_t[16];
 * struct s {
 *      arr_t *a;
 * };
 */
{
        .descr = "struct->ptr->typedef->array->int size resolution",
        .raw_types = {
                BTF_STRUCT_ENC(NAME_TBD, 1, 8),                 /* [1] */
                BTF_MEMBER_ENC(NAME_TBD, 2, 0),
                BTF_PTR_ENC(3),                                 /* [2] */
                BTF_TYPEDEF_ENC(NAME_TBD, 4),                   /* [3] */
                BTF_TYPE_ARRAY_ENC(5, 5, 16),                   /* [4] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [5] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0s\0a\0arr_t"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "ptr_mod_chain_size_resolve_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int) * 16,
        .key_type_id = 5 /* int */,
        .value_type_id = 3 /* arr_t */,
        .max_entries = 4,
},
/*
 * typedef int arr_t[16][8][4];
 * struct s {
 *      arr_t *a;
 * };
 */
{
        .descr = "struct->ptr->typedef->multi-array->int size resolution",
        .raw_types = {
                BTF_STRUCT_ENC(NAME_TBD, 1, 8),                 /* [1] */
                BTF_MEMBER_ENC(NAME_TBD, 2, 0),
                BTF_PTR_ENC(3),                                 /* [2] */
                BTF_TYPEDEF_ENC(NAME_TBD, 4),                   /* [3] */
                BTF_TYPE_ARRAY_ENC(5, 7, 16),                   /* [4] */
                BTF_TYPE_ARRAY_ENC(6, 7, 8),                    /* [5] */
                BTF_TYPE_ARRAY_ENC(7, 7, 4),                    /* [6] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [7] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0s\0a\0arr_t"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "multi_arr_size_resolve_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int) * 16 * 8 * 4,
        .key_type_id = 7 /* int */,
        .value_type_id = 3 /* arr_t */,
        .max_entries = 4,
},
/*
 * typedef int int_t;
 * typedef int_t arr3_t[4];
 * typedef arr3_t arr2_t[8];
 * typedef arr2_t arr1_t[16];
 * struct s {
 *      arr1_t *a;
 * };
 */
{
        .descr = "typedef/multi-arr mix size resolution",
        .raw_types = {
                BTF_STRUCT_ENC(NAME_TBD, 1, 8),                 /* [1] */
                BTF_MEMBER_ENC(NAME_TBD, 2, 0),
                BTF_PTR_ENC(3),                                 /* [2] */
                BTF_TYPEDEF_ENC(NAME_TBD, 4),                   /* [3] */
                BTF_TYPE_ARRAY_ENC(5, 10, 16),                  /* [4] */
                BTF_TYPEDEF_ENC(NAME_TBD, 6),                   /* [5] */
                BTF_TYPE_ARRAY_ENC(7, 10, 8),                   /* [6] */
                BTF_TYPEDEF_ENC(NAME_TBD, 8),                   /* [7] */
                BTF_TYPE_ARRAY_ENC(9, 10, 4),                   /* [8] */
                BTF_TYPEDEF_ENC(NAME_TBD, 10),                  /* [9] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [10] */
                BTF_END_RAW,
        },
        BTF_STR_SEC("\0s\0a\0arr1_t\0arr2_t\0arr3_t\0int_t"),
        .map_type = BPF_MAP_TYPE_ARRAY,
        .map_name = "typedef_arra_mix_size_resolve_map",
        .key_size = sizeof(int),
        .value_size = sizeof(int) * 16 * 8 * 4,
        .key_type_id = 10 /* int */,
        .value_type_id = 3 /* arr_t */,
        .max_entries = 4,
},

}; /* struct btf_raw_test raw_tests[] */

static const char *get_next_str(const char *start, const char *end)
{
        return start < end - 1 ? start + 1 : NULL;
}

static int get_raw_sec_size(const __u32 *raw_types)
{
        int i;

        for (i = MAX_NR_RAW_U32 - 1;
             i >= 0 && raw_types[i] != BTF_END_RAW;
             i--)
                ;

        return i < 0 ? i : i * sizeof(raw_types[0]);
}

static void *btf_raw_create(const struct btf_header *hdr,
                            const __u32 *raw_types,
                            const char *str,
                            unsigned int str_sec_size,
                            unsigned int *btf_size,
                            const char **ret_next_str)
{
        const char *next_str = str, *end_str = str + str_sec_size;
        const char **strs_idx = NULL, **tmp_strs_idx;
        int strs_cap = 0, strs_cnt = 0, next_str_idx = 0;
        unsigned int size_needed, offset;
        struct btf_header *ret_hdr;
        int i, type_sec_size, err = 0;
        uint32_t *ret_types;
        void *raw_btf = NULL;

        type_sec_size = get_raw_sec_size(raw_types);
        if (CHECK(type_sec_size < 0, "Cannot get nr_raw_types"))
                return NULL;

        size_needed = sizeof(*hdr) + type_sec_size + str_sec_size;
        raw_btf = malloc(size_needed);
        if (CHECK(!raw_btf, "Cannot allocate memory for raw_btf"))
                return NULL;

        /* Copy header */
        memcpy(raw_btf, hdr, sizeof(*hdr));
        offset = sizeof(*hdr);

        /* Index strings */
        while ((next_str = get_next_str(next_str, end_str))) {
                if (strs_cnt == strs_cap) {
                        strs_cap += max(16, strs_cap / 2);
                        tmp_strs_idx = realloc(strs_idx,
                                               sizeof(*strs_idx) * strs_cap);
                        if (CHECK(!tmp_strs_idx,
                                  "Cannot allocate memory for strs_idx")) {
                                err = -1;
                                goto done;
                        }
                        strs_idx = tmp_strs_idx;
                }
                strs_idx[strs_cnt++] = next_str;
                next_str += strlen(next_str);
        }

        /* Copy type section */
        ret_types = raw_btf + offset;
        for (i = 0; i < type_sec_size / sizeof(raw_types[0]); i++) {
                if (raw_types[i] == NAME_TBD) {
                        if (CHECK(next_str_idx == strs_cnt,
                                  "Error in getting next_str #%d",
                                  next_str_idx)) {
                                err = -1;
                                goto done;
                        }
                        ret_types[i] = strs_idx[next_str_idx++] - str;
                } else if (IS_NAME_NTH(raw_types[i])) {
                        int idx = GET_NAME_NTH_IDX(raw_types[i]);

                        if (CHECK(idx <= 0 || idx > strs_cnt,
                                  "Error getting string #%d, strs_cnt:%d",
                                  idx, strs_cnt)) {
                                err = -1;
                                goto done;
                        }
                        ret_types[i] = strs_idx[idx-1] - str;
                } else {
                        ret_types[i] = raw_types[i];
                }
        }
        offset += type_sec_size;

        /* Copy string section */
        memcpy(raw_btf + offset, str, str_sec_size);

        ret_hdr = (struct btf_header *)raw_btf;
        ret_hdr->type_len = type_sec_size;
        ret_hdr->str_off = type_sec_size;
        ret_hdr->str_len = str_sec_size;

        *btf_size = size_needed;
        if (ret_next_str)
                *ret_next_str =
                        next_str_idx < strs_cnt ? strs_idx[next_str_idx] : NULL;

done:
        if (err) {
                if (raw_btf)
                        free(raw_btf);
                if (strs_idx)
                        free(strs_idx);
                return NULL;
        }
        return raw_btf;
}

static int do_test_raw(unsigned int test_num)
{
        struct btf_raw_test *test = &raw_tests[test_num - 1];
        struct bpf_create_map_attr create_attr = {};
        int map_fd = -1, btf_fd = -1;
        unsigned int raw_btf_size;
        struct btf_header *hdr;
        void *raw_btf;
        int err;

        fprintf(stderr, "BTF raw test[%u] (%s): ", test_num, test->descr);
        raw_btf = btf_raw_create(&hdr_tmpl,
                                 test->raw_types,
                                 test->str_sec,
                                 test->str_sec_size,
                                 &raw_btf_size, NULL);

        if (!raw_btf)
                return -1;

        hdr = raw_btf;

        hdr->hdr_len = (int)hdr->hdr_len + test->hdr_len_delta;
        hdr->type_off = (int)hdr->type_off + test->type_off_delta;
        hdr->str_off = (int)hdr->str_off + test->str_off_delta;
        hdr->str_len = (int)hdr->str_len + test->str_len_delta;

        *btf_log_buf = '\0';
        btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
                              btf_log_buf, BTF_LOG_BUF_SIZE,
                              args.always_log);
        free(raw_btf);

        err = ((btf_fd == -1) != test->btf_load_err);
        if (CHECK(err, "btf_fd:%d test->btf_load_err:%u",
                  btf_fd, test->btf_load_err) ||
            CHECK(test->err_str && !strstr(btf_log_buf, test->err_str),
                  "expected err_str:%s", test->err_str)) {
                err = -1;
                goto done;
        }

        if (err || btf_fd == -1)
                goto done;

        create_attr.name = test->map_name;
        create_attr.map_type = test->map_type;
        create_attr.key_size = test->key_size;
        create_attr.value_size = test->value_size;
        create_attr.max_entries = test->max_entries;
        create_attr.btf_fd = btf_fd;
        create_attr.btf_key_type_id = test->key_type_id;
        create_attr.btf_value_type_id = test->value_type_id;

        map_fd = bpf_create_map_xattr(&create_attr);

        err = ((map_fd == -1) != test->map_create_err);
        CHECK(err, "map_fd:%d test->map_create_err:%u",
              map_fd, test->map_create_err);

done:
        if (!err)
                fprintf(stderr, "OK");

        if (*btf_log_buf && (err || args.always_log))
                fprintf(stderr, "\n%s", btf_log_buf);

        if (btf_fd != -1)
                close(btf_fd);
        if (map_fd != -1)
                close(map_fd);

        return err;
}

static int test_raw(void)
{
        unsigned int i;
        int err = 0;

        if (args.raw_test_num)
                return count_result(do_test_raw(args.raw_test_num));

        for (i = 1; i <= ARRAY_SIZE(raw_tests); i++)
                err |= count_result(do_test_raw(i));

        return err;
}

struct btf_get_info_test {
        const char *descr;
        const char *str_sec;
        __u32 raw_types[MAX_NR_RAW_U32];
        __u32 str_sec_size;
        int btf_size_delta;
        int (*special_test)(unsigned int test_num);
};

static int test_big_btf_info(unsigned int test_num);
static int test_btf_id(unsigned int test_num);

const struct btf_get_info_test get_info_tests[] = {
{
        .descr = "== raw_btf_size+1",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .btf_size_delta = 1,
},
{
        .descr = "== raw_btf_size-3",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .btf_size_delta = -3,
},
{
        .descr = "Large bpf_btf_info",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .special_test = test_big_btf_info,
},
{
        .descr = "BTF ID",
        .raw_types = {
                /* int */                               /* [1] */
                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
                /* unsigned int */                      /* [2] */
                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),
                BTF_END_RAW,
        },
        .str_sec = "",
        .str_sec_size = sizeof(""),
        .special_test = test_btf_id,
},
};

static inline __u64 ptr_to_u64(const void *ptr)
{
        return (__u64)(unsigned long)ptr;
}

static int test_big_btf_info(unsigned int test_num)
{
        const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
        uint8_t *raw_btf = NULL, *user_btf = NULL;
        unsigned int raw_btf_size;
        struct {
                struct bpf_btf_info info;
                uint64_t garbage;
        } info_garbage;
        struct bpf_btf_info *info;
        int btf_fd = -1, err;
        uint32_t info_len;

        raw_btf = btf_raw_create(&hdr_tmpl,
                                 test->raw_types,
                                 test->str_sec,
                                 test->str_sec_size,
                                 &raw_btf_size, NULL);

        if (!raw_btf)
                return -1;

        *btf_log_buf = '\0';

        user_btf = malloc(raw_btf_size);
        if (CHECK(!user_btf, "!user_btf")) {
                err = -1;
                goto done;
        }

        btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
                              btf_log_buf, BTF_LOG_BUF_SIZE,
                              args.always_log);
        if (CHECK(btf_fd == -1, "errno:%d", errno)) {
                err = -1;
                goto done;
        }

        /*
         * GET_INFO should error out if the userspace info
         * has non zero tailing bytes.
         */
        info = &info_garbage.info;
        memset(info, 0, sizeof(*info));
        info_garbage.garbage = 0xdeadbeef;
        info_len = sizeof(info_garbage);
        info->btf = ptr_to_u64(user_btf);
        info->btf_size = raw_btf_size;

        err = bpf_obj_get_info_by_fd(btf_fd, info, &info_len);
        if (CHECK(!err, "!err")) {
                err = -1;
                goto done;
        }

        /*
         * GET_INFO should succeed even info_len is larger than
         * the kernel supported as long as tailing bytes are zero.
         * The kernel supported info len should also be returned
         * to userspace.
         */
        info_garbage.garbage = 0;
        err = bpf_obj_get_info_by_fd(btf_fd, info, &info_len);
        if (CHECK(err || info_len != sizeof(*info),
                  "err:%d errno:%d info_len:%u sizeof(*info):%zu",
                  err, errno, info_len, sizeof(*info))) {
                err = -1;
                goto done;
        }

        fprintf(stderr, "OK");

done:
        if (*btf_log_buf && (err || args.always_log))
                fprintf(stderr, "\n%s", btf_log_buf);

        free(raw_btf);
        free(user_btf);

        if (btf_fd != -1)
                close(btf_fd);

        return err;
}

static int test_btf_id(unsigned int test_num)
{
        const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
        struct bpf_create_map_attr create_attr = {};
        uint8_t *raw_btf = NULL, *user_btf[2] = {};
        int btf_fd[2] = {-1, -1}, map_fd = -1;
        struct bpf_map_info map_info = {};
        struct bpf_btf_info info[2] = {};
        unsigned int raw_btf_size;
        uint32_t info_len;
        int err, i, ret;

        raw_btf = btf_raw_create(&hdr_tmpl,
                                 test->raw_types,
                                 test->str_sec,
                                 test->str_sec_size,
                                 &raw_btf_size, NULL);

        if (!raw_btf)
                return -1;

        *btf_log_buf = '\0';

        for (i = 0; i < 2; i++) {
                user_btf[i] = malloc(raw_btf_size);
                if (CHECK(!user_btf[i], "!user_btf[%d]", i)) {
                        err = -1;
                        goto done;
                }
                info[i].btf = ptr_to_u64(user_btf[i]);
                info[i].btf_size = raw_btf_size;
        }

        btf_fd[0] = bpf_load_btf(raw_btf, raw_btf_size,
                                 btf_log_buf, BTF_LOG_BUF_SIZE,
                                 args.always_log);
        if (CHECK(btf_fd[0] == -1, "errno:%d", errno)) {
                err = -1;
                goto done;
        }

        /* Test BPF_OBJ_GET_INFO_BY_ID on btf_id */
        info_len = sizeof(info[0]);
        err = bpf_obj_get_info_by_fd(btf_fd[0], &info[0], &info_len);
        if (CHECK(err, "errno:%d", errno)) {
                err = -1;
                goto done;
        }

        btf_fd[1] = bpf_btf_get_fd_by_id(info[0].id);
        if (CHECK(btf_fd[1] == -1, "errno:%d", errno)) {
                err = -1;
                goto done;
        }

        ret = 0;
        err = bpf_obj_get_info_by_fd(btf_fd[1], &info[1], &info_len);
        if (CHECK(err || info[0].id != info[1].id ||
                  info[0].btf_size != info[1].btf_size ||
                  (ret = memcmp(user_btf[0], user_btf[1], info[0].btf_size)),
                  "err:%d errno:%d id0:%u id1:%u btf_size0:%u btf_size1:%u memcmp:%d",
                  err, errno, info[0].id, info[1].id,
                  info[0].btf_size, info[1].btf_size, ret)) {
                err = -1;
                goto done;
        }

        /* Test btf members in struct bpf_map_info */
        create_attr.name = "test_btf_id";
        create_attr.map_type = BPF_MAP_TYPE_ARRAY;
        create_attr.key_size = sizeof(int);
        create_attr.value_size = sizeof(unsigned int);
        create_attr.max_entries = 4;
        create_attr.btf_fd = btf_fd[0];
        create_attr.btf_key_type_id = 1;
        create_attr.btf_value_type_id = 2;

        map_fd = bpf_create_map_xattr(&create_attr);
        if (CHECK(map_fd == -1, "errno:%d", errno)) {
                err = -1;
                goto done;
        }

        info_len = sizeof(map_info);
        err = bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len);
        if (CHECK(err || map_info.btf_id != info[0].id ||
                  map_info.btf_key_type_id != 1 || map_info.btf_value_type_id != 2,
                  "err:%d errno:%d info.id:%u btf_id:%u btf_key_type_id:%u btf_value_type_id:%u",
                  err, errno, info[0].id, map_info.btf_id, map_info.btf_key_type_id,
                  map_info.btf_value_type_id)) {
                err = -1;
                goto done;
        }