1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* Copyright (c) 2018 Facebook */
3 
4 #include <linux/bpf.h>
5 #include <linux/btf.h>
6 #include <linux/err.h>
7 #include <linux/kernel.h>
8 #include <linux/filter.h>
9 #include <linux/unistd.h>
10 #include <bpf/bpf.h>
11 #include <libelf.h>
12 #include <gelf.h>
13 #include <string.h>
14 #include <stdlib.h>
15 #include <stdio.h>
16 #include <stdarg.h>
17 #include <unistd.h>
18 #include <fcntl.h>
19 #include <errno.h>
20 #include <assert.h>
21 #include <bpf/libbpf.h>
22 #include <bpf/btf.h>
23 
24 #include "bpf_util.h"
25 #include "../test_btf.h"
26 #include "test_progs.h"
27 
28 #define MAX_INSNS	512
29 #define MAX_SUBPROGS	16
30 
31 static int duration = 0;
32 static bool always_log;
33 
34 #undef CHECK
35 #define CHECK(condition, format...) _CHECK(condition, "check", duration, format)
36 
37 #define NAME_TBD 0xdeadb33f
38 
39 #define NAME_NTH(N) (0xfffe0000 | N)
40 #define IS_NAME_NTH(X) ((X & 0xffff0000) == 0xfffe0000)
41 #define GET_NAME_NTH_IDX(X) (X & 0x0000ffff)
42 
43 #define MAX_NR_RAW_U32 1024
44 #define BTF_LOG_BUF_SIZE 65535
45 
46 static char btf_log_buf[BTF_LOG_BUF_SIZE];
47 
48 static struct btf_header hdr_tmpl = {
49 	.magic = BTF_MAGIC,
50 	.version = BTF_VERSION,
51 	.hdr_len = sizeof(struct btf_header),
52 };
53 
54 /* several different mapv kinds(types) supported by pprint */
55 enum pprint_mapv_kind_t {
56 	PPRINT_MAPV_KIND_BASIC = 0,
57 	PPRINT_MAPV_KIND_INT128,
58 };
59 
60 struct btf_raw_test {
61 	const char *descr;
62 	const char *str_sec;
63 	const char *map_name;
64 	const char *err_str;
65 	__u32 raw_types[MAX_NR_RAW_U32];
66 	__u32 str_sec_size;
67 	enum bpf_map_type map_type;
68 	__u32 key_size;
69 	__u32 value_size;
70 	__u32 key_type_id;
71 	__u32 value_type_id;
72 	__u32 max_entries;
73 	bool btf_load_err;
74 	bool map_create_err;
75 	bool ordered_map;
76 	bool lossless_map;
77 	bool percpu_map;
78 	int hdr_len_delta;
79 	int type_off_delta;
80 	int str_off_delta;
81 	int str_len_delta;
82 	enum pprint_mapv_kind_t mapv_kind;
83 };
84 
85 #define BTF_STR_SEC(str) \
86 	.str_sec = str, .str_sec_size = sizeof(str)
87 
88 static struct btf_raw_test raw_tests[] = {
89 /* enum E {
90  *     E0,
91  *     E1,
92  * };
93  *
94  * struct A {
95  *	unsigned long long m;
96  *	int n;
97  *	char o;
98  *	[3 bytes hole]
99  *	int p[8];
100  *	int q[4][8];
101  *	enum E r;
102  * };
103  */
104 {
105 	.descr = "struct test #1",
106 	.raw_types = {
107 		/* int */
108 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
109 		/* unsigned long long */
110 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
111 		/* char */
112 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
113 		/* int[8] */
114 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
115 		/* struct A { */				/* [5] */
116 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 6), 180),
117 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
118 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
119 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
120 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
121 		BTF_MEMBER_ENC(NAME_TBD, 6, 384),/* int q[4][8]		*/
122 		BTF_MEMBER_ENC(NAME_TBD, 7, 1408), /* enum E r		*/
123 		/* } */
124 		/* int[4][8] */
125 		BTF_TYPE_ARRAY_ENC(4, 1, 4),			/* [6] */
126 		/* enum E */					/* [7] */
127 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), sizeof(int)),
128 		BTF_ENUM_ENC(NAME_TBD, 0),
129 		BTF_ENUM_ENC(NAME_TBD, 1),
130 		BTF_END_RAW,
131 	},
132 	.str_sec = "\0A\0m\0n\0o\0p\0q\0r\0E\0E0\0E1",
133 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0q\0r\0E\0E0\0E1"),
134 	.map_type = BPF_MAP_TYPE_ARRAY,
135 	.map_name = "struct_test1_map",
136 	.key_size = sizeof(int),
137 	.value_size = 180,
138 	.key_type_id = 1,
139 	.value_type_id = 5,
140 	.max_entries = 4,
141 },
142 
143 /* typedef struct b Struct_B;
144  *
145  * struct A {
146  *     int m;
147  *     struct b n[4];
148  *     const Struct_B o[4];
149  * };
150  *
151  * struct B {
152  *     int m;
153  *     int n;
154  * };
155  */
156 {
157 	.descr = "struct test #2",
158 	.raw_types = {
159 		/* int */					/* [1] */
160 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
161 		/* struct b [4] */				/* [2] */
162 		BTF_TYPE_ARRAY_ENC(4, 1, 4),
163 
164 		/* struct A { */				/* [3] */
165 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 3), 68),
166 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int m;		*/
167 		BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct B n[4]	*/
168 		BTF_MEMBER_ENC(NAME_TBD, 8, 288),/* const Struct_B o[4];*/
169 		/* } */
170 
171 		/* struct B { */				/* [4] */
172 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
173 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int m; */
174 		BTF_MEMBER_ENC(NAME_TBD, 1, 32),/* int n; */
175 		/* } */
176 
177 		/* const int */					/* [5] */
178 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),
179 		/* typedef struct b Struct_B */	/* [6] */
180 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 4),
181 		/* const Struct_B */				/* [7] */
182 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 6),
183 		/* const Struct_B [4] */			/* [8] */
184 		BTF_TYPE_ARRAY_ENC(7, 1, 4),
185 		BTF_END_RAW,
186 	},
187 	.str_sec = "\0A\0m\0n\0o\0B\0m\0n\0Struct_B",
188 	.str_sec_size = sizeof("\0A\0m\0n\0o\0B\0m\0n\0Struct_B"),
189 	.map_type = BPF_MAP_TYPE_ARRAY,
190 	.map_name = "struct_test2_map",
191 	.key_size = sizeof(int),
192 	.value_size = 68,
193 	.key_type_id = 1,
194 	.value_type_id = 3,
195 	.max_entries = 4,
196 },
197 {
198 	.descr = "struct test #3 Invalid member offset",
199 	.raw_types = {
200 		/* int */					/* [1] */
201 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
202 		/* int64 */					/* [2] */
203 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 64, 8),
204 
205 		/* struct A { */				/* [3] */
206 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 16),
207 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),	/* int m;		*/
208 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),		/* int64 n; */
209 		/* } */
210 		BTF_END_RAW,
211 	},
212 	.str_sec = "\0A\0m\0n\0",
213 	.str_sec_size = sizeof("\0A\0m\0n\0"),
214 	.map_type = BPF_MAP_TYPE_ARRAY,
215 	.map_name = "struct_test3_map",
216 	.key_size = sizeof(int),
217 	.value_size = 16,
218 	.key_type_id = 1,
219 	.value_type_id = 3,
220 	.max_entries = 4,
221 	.btf_load_err = true,
222 	.err_str = "Invalid member bits_offset",
223 },
224 /*
225  * struct A {
226  *	unsigned long long m;
227  *	int n;
228  *	char o;
229  *	[3 bytes hole]
230  *	int p[8];
231  * };
232  */
233 {
234 	.descr = "global data test #1",
235 	.raw_types = {
236 		/* int */
237 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
238 		/* unsigned long long */
239 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
240 		/* char */
241 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
242 		/* int[8] */
243 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
244 		/* struct A { */				/* [5] */
245 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
246 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
247 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
248 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
249 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
250 		/* } */
251 		BTF_END_RAW,
252 	},
253 	.str_sec = "\0A\0m\0n\0o\0p",
254 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p"),
255 	.map_type = BPF_MAP_TYPE_ARRAY,
256 	.map_name = "struct_test1_map",
257 	.key_size = sizeof(int),
258 	.value_size = 48,
259 	.key_type_id = 1,
260 	.value_type_id = 5,
261 	.max_entries = 4,
262 },
263 /*
264  * struct A {
265  *	unsigned long long m;
266  *	int n;
267  *	char o;
268  *	[3 bytes hole]
269  *	int p[8];
270  * };
271  * static struct A t; <- in .bss
272  */
273 {
274 	.descr = "global data test #2",
275 	.raw_types = {
276 		/* int */
277 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
278 		/* unsigned long long */
279 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
280 		/* char */
281 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
282 		/* int[8] */
283 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
284 		/* struct A { */				/* [5] */
285 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
286 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
287 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
288 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
289 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
290 		/* } */
291 		/* static struct A t */
292 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
293 		/* .bss section */				/* [7] */
294 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 48),
295 		BTF_VAR_SECINFO_ENC(6, 0, 48),
296 		BTF_END_RAW,
297 	},
298 	.str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
299 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
300 	.map_type = BPF_MAP_TYPE_ARRAY,
301 	.map_name = ".bss",
302 	.key_size = sizeof(int),
303 	.value_size = 48,
304 	.key_type_id = 0,
305 	.value_type_id = 7,
306 	.max_entries = 1,
307 },
308 {
309 	.descr = "global data test #3",
310 	.raw_types = {
311 		/* int */
312 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
313 		/* static int t */
314 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
315 		/* .bss section */				/* [3] */
316 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
317 		BTF_VAR_SECINFO_ENC(2, 0, 4),
318 		BTF_END_RAW,
319 	},
320 	.str_sec = "\0t\0.bss",
321 	.str_sec_size = sizeof("\0t\0.bss"),
322 	.map_type = BPF_MAP_TYPE_ARRAY,
323 	.map_name = ".bss",
324 	.key_size = sizeof(int),
325 	.value_size = 4,
326 	.key_type_id = 0,
327 	.value_type_id = 3,
328 	.max_entries = 1,
329 },
330 {
331 	.descr = "global data test #4, unsupported linkage",
332 	.raw_types = {
333 		/* int */
334 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
335 		/* static int t */
336 		BTF_VAR_ENC(NAME_TBD, 1, 2),			/* [2] */
337 		/* .bss section */				/* [3] */
338 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
339 		BTF_VAR_SECINFO_ENC(2, 0, 4),
340 		BTF_END_RAW,
341 	},
342 	.str_sec = "\0t\0.bss",
343 	.str_sec_size = sizeof("\0t\0.bss"),
344 	.map_type = BPF_MAP_TYPE_ARRAY,
345 	.map_name = ".bss",
346 	.key_size = sizeof(int),
347 	.value_size = 4,
348 	.key_type_id = 0,
349 	.value_type_id = 3,
350 	.max_entries = 1,
351 	.btf_load_err = true,
352 	.err_str = "Linkage not supported",
353 },
354 {
355 	.descr = "global data test #5, invalid var type",
356 	.raw_types = {
357 		/* static void t */
358 		BTF_VAR_ENC(NAME_TBD, 0, 0),			/* [1] */
359 		/* .bss section */				/* [2] */
360 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
361 		BTF_VAR_SECINFO_ENC(1, 0, 4),
362 		BTF_END_RAW,
363 	},
364 	.str_sec = "\0t\0.bss",
365 	.str_sec_size = sizeof("\0t\0.bss"),
366 	.map_type = BPF_MAP_TYPE_ARRAY,
367 	.map_name = ".bss",
368 	.key_size = sizeof(int),
369 	.value_size = 4,
370 	.key_type_id = 0,
371 	.value_type_id = 2,
372 	.max_entries = 1,
373 	.btf_load_err = true,
374 	.err_str = "Invalid type_id",
375 },
376 {
377 	.descr = "global data test #6, invalid var type (fwd type)",
378 	.raw_types = {
379 		/* union A */
380 		BTF_TYPE_ENC(NAME_TBD,
381 			     BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0), /* [1] */
382 		/* static union A t */
383 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
384 		/* .bss section */				/* [3] */
385 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
386 		BTF_VAR_SECINFO_ENC(2, 0, 4),
387 		BTF_END_RAW,
388 	},
389 	.str_sec = "\0A\0t\0.bss",
390 	.str_sec_size = sizeof("\0A\0t\0.bss"),
391 	.map_type = BPF_MAP_TYPE_ARRAY,
392 	.map_name = ".bss",
393 	.key_size = sizeof(int),
394 	.value_size = 4,
395 	.key_type_id = 0,
396 	.value_type_id = 2,
397 	.max_entries = 1,
398 	.btf_load_err = true,
399 	.err_str = "Invalid type",
400 },
401 {
402 	.descr = "global data test #7, invalid var type (fwd type)",
403 	.raw_types = {
404 		/* union A */
405 		BTF_TYPE_ENC(NAME_TBD,
406 			     BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0), /* [1] */
407 		/* static union A t */
408 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
409 		/* .bss section */				/* [3] */
410 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
411 		BTF_VAR_SECINFO_ENC(1, 0, 4),
412 		BTF_END_RAW,
413 	},
414 	.str_sec = "\0A\0t\0.bss",
415 	.str_sec_size = sizeof("\0A\0t\0.bss"),
416 	.map_type = BPF_MAP_TYPE_ARRAY,
417 	.map_name = ".bss",
418 	.key_size = sizeof(int),
419 	.value_size = 4,
420 	.key_type_id = 0,
421 	.value_type_id = 2,
422 	.max_entries = 1,
423 	.btf_load_err = true,
424 	.err_str = "Invalid type",
425 },
426 {
427 	.descr = "global data test #8, invalid var size",
428 	.raw_types = {
429 		/* int */
430 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
431 		/* unsigned long long */
432 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
433 		/* char */
434 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
435 		/* int[8] */
436 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
437 		/* struct A { */				/* [5] */
438 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
439 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
440 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
441 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
442 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
443 		/* } */
444 		/* static struct A t */
445 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
446 		/* .bss section */				/* [7] */
447 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 48),
448 		BTF_VAR_SECINFO_ENC(6, 0, 47),
449 		BTF_END_RAW,
450 	},
451 	.str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
452 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
453 	.map_type = BPF_MAP_TYPE_ARRAY,
454 	.map_name = ".bss",
455 	.key_size = sizeof(int),
456 	.value_size = 48,
457 	.key_type_id = 0,
458 	.value_type_id = 7,
459 	.max_entries = 1,
460 	.btf_load_err = true,
461 	.err_str = "Invalid size",
462 },
463 {
464 	.descr = "global data test #9, invalid var size",
465 	.raw_types = {
466 		/* int */
467 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
468 		/* unsigned long long */
469 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
470 		/* char */
471 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
472 		/* int[8] */
473 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
474 		/* struct A { */				/* [5] */
475 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
476 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
477 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
478 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
479 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
480 		/* } */
481 		/* static struct A t */
482 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
483 		/* .bss section */				/* [7] */
484 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 46),
485 		BTF_VAR_SECINFO_ENC(6, 0, 48),
486 		BTF_END_RAW,
487 	},
488 	.str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
489 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
490 	.map_type = BPF_MAP_TYPE_ARRAY,
491 	.map_name = ".bss",
492 	.key_size = sizeof(int),
493 	.value_size = 48,
494 	.key_type_id = 0,
495 	.value_type_id = 7,
496 	.max_entries = 1,
497 	.btf_load_err = true,
498 	.err_str = "Invalid size",
499 },
500 {
501 	.descr = "global data test #10, invalid var size",
502 	.raw_types = {
503 		/* int */
504 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
505 		/* unsigned long long */
506 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
507 		/* char */
508 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
509 		/* int[8] */
510 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
511 		/* struct A { */				/* [5] */
512 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
513 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
514 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
515 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
516 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
517 		/* } */
518 		/* static struct A t */
519 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
520 		/* .bss section */				/* [7] */
521 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 46),
522 		BTF_VAR_SECINFO_ENC(6, 0, 46),
523 		BTF_END_RAW,
524 	},
525 	.str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
526 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
527 	.map_type = BPF_MAP_TYPE_ARRAY,
528 	.map_name = ".bss",
529 	.key_size = sizeof(int),
530 	.value_size = 48,
531 	.key_type_id = 0,
532 	.value_type_id = 7,
533 	.max_entries = 1,
534 	.btf_load_err = true,
535 	.err_str = "Invalid size",
536 },
537 {
538 	.descr = "global data test #11, multiple section members",
539 	.raw_types = {
540 		/* int */
541 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
542 		/* unsigned long long */
543 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
544 		/* char */
545 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
546 		/* int[8] */
547 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
548 		/* struct A { */				/* [5] */
549 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
550 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
551 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
552 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
553 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
554 		/* } */
555 		/* static struct A t */
556 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
557 		/* static int u */
558 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [7] */
559 		/* .bss section */				/* [8] */
560 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
561 		BTF_VAR_SECINFO_ENC(6, 10, 48),
562 		BTF_VAR_SECINFO_ENC(7, 58, 4),
563 		BTF_END_RAW,
564 	},
565 	.str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
566 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
567 	.map_type = BPF_MAP_TYPE_ARRAY,
568 	.map_name = ".bss",
569 	.key_size = sizeof(int),
570 	.value_size = 62,
571 	.key_type_id = 0,
572 	.value_type_id = 8,
573 	.max_entries = 1,
574 },
575 {
576 	.descr = "global data test #12, invalid offset",
577 	.raw_types = {
578 		/* int */
579 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
580 		/* unsigned long long */
581 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
582 		/* char */
583 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
584 		/* int[8] */
585 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
586 		/* struct A { */				/* [5] */
587 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
588 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
589 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
590 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
591 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
592 		/* } */
593 		/* static struct A t */
594 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
595 		/* static int u */
596 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [7] */
597 		/* .bss section */				/* [8] */
598 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
599 		BTF_VAR_SECINFO_ENC(6, 10, 48),
600 		BTF_VAR_SECINFO_ENC(7, 60, 4),
601 		BTF_END_RAW,
602 	},
603 	.str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
604 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
605 	.map_type = BPF_MAP_TYPE_ARRAY,
606 	.map_name = ".bss",
607 	.key_size = sizeof(int),
608 	.value_size = 62,
609 	.key_type_id = 0,
610 	.value_type_id = 8,
611 	.max_entries = 1,
612 	.btf_load_err = true,
613 	.err_str = "Invalid offset+size",
614 },
615 {
616 	.descr = "global data test #13, invalid offset",
617 	.raw_types = {
618 		/* int */
619 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
620 		/* unsigned long long */
621 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
622 		/* char */
623 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
624 		/* int[8] */
625 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
626 		/* struct A { */				/* [5] */
627 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
628 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
629 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
630 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
631 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
632 		/* } */
633 		/* static struct A t */
634 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
635 		/* static int u */
636 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [7] */
637 		/* .bss section */				/* [8] */
638 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
639 		BTF_VAR_SECINFO_ENC(6, 10, 48),
640 		BTF_VAR_SECINFO_ENC(7, 12, 4),
641 		BTF_END_RAW,
642 	},
643 	.str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
644 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
645 	.map_type = BPF_MAP_TYPE_ARRAY,
646 	.map_name = ".bss",
647 	.key_size = sizeof(int),
648 	.value_size = 62,
649 	.key_type_id = 0,
650 	.value_type_id = 8,
651 	.max_entries = 1,
652 	.btf_load_err = true,
653 	.err_str = "Invalid offset",
654 },
655 {
656 	.descr = "global data test #14, invalid offset",
657 	.raw_types = {
658 		/* int */
659 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
660 		/* unsigned long long */
661 		BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),		/* [2] */
662 		/* char */
663 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),	/* [3] */
664 		/* int[8] */
665 		BTF_TYPE_ARRAY_ENC(1, 1, 8),			/* [4] */
666 		/* struct A { */				/* [5] */
667 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
668 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* unsigned long long m;*/
669 		BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;		*/
670 		BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;		*/
671 		BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]		*/
672 		/* } */
673 		/* static struct A t */
674 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
675 		/* static int u */
676 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [7] */
677 		/* .bss section */				/* [8] */
678 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
679 		BTF_VAR_SECINFO_ENC(7, 58, 4),
680 		BTF_VAR_SECINFO_ENC(6, 10, 48),
681 		BTF_END_RAW,
682 	},
683 	.str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
684 	.str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
685 	.map_type = BPF_MAP_TYPE_ARRAY,
686 	.map_name = ".bss",
687 	.key_size = sizeof(int),
688 	.value_size = 62,
689 	.key_type_id = 0,
690 	.value_type_id = 8,
691 	.max_entries = 1,
692 	.btf_load_err = true,
693 	.err_str = "Invalid offset",
694 },
695 {
696 	.descr = "global data test #15, not var kind",
697 	.raw_types = {
698 		/* int */
699 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
700 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
701 		/* .bss section */				/* [3] */
702 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
703 		BTF_VAR_SECINFO_ENC(1, 0, 4),
704 		BTF_END_RAW,
705 	},
706 	.str_sec = "\0A\0t\0.bss",
707 	.str_sec_size = sizeof("\0A\0t\0.bss"),
708 	.map_type = BPF_MAP_TYPE_ARRAY,
709 	.map_name = ".bss",
710 	.key_size = sizeof(int),
711 	.value_size = 4,
712 	.key_type_id = 0,
713 	.value_type_id = 3,
714 	.max_entries = 1,
715 	.btf_load_err = true,
716 	.err_str = "Not a VAR kind member",
717 },
718 {
719 	.descr = "global data test #16, invalid var referencing sec",
720 	.raw_types = {
721 		/* int */
722 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
723 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [2] */
724 		BTF_VAR_ENC(NAME_TBD, 2, 0),			/* [3] */
725 		/* a section */					/* [4] */
726 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
727 		BTF_VAR_SECINFO_ENC(3, 0, 4),
728 		/* a section */					/* [5] */
729 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
730 		BTF_VAR_SECINFO_ENC(6, 0, 4),
731 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [6] */
732 		BTF_END_RAW,
733 	},
734 	.str_sec = "\0A\0t\0s\0a\0a",
735 	.str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
736 	.map_type = BPF_MAP_TYPE_ARRAY,
737 	.map_name = ".bss",
738 	.key_size = sizeof(int),
739 	.value_size = 4,
740 	.key_type_id = 0,
741 	.value_type_id = 4,
742 	.max_entries = 1,
743 	.btf_load_err = true,
744 	.err_str = "Invalid type_id",
745 },
746 {
747 	.descr = "global data test #17, invalid var referencing var",
748 	.raw_types = {
749 		/* int */
750 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
751 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
752 		BTF_VAR_ENC(NAME_TBD, 2, 0),			/* [3] */
753 		/* a section */					/* [4] */
754 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
755 		BTF_VAR_SECINFO_ENC(3, 0, 4),
756 		BTF_END_RAW,
757 	},
758 	.str_sec = "\0A\0t\0s\0a\0a",
759 	.str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
760 	.map_type = BPF_MAP_TYPE_ARRAY,
761 	.map_name = ".bss",
762 	.key_size = sizeof(int),
763 	.value_size = 4,
764 	.key_type_id = 0,
765 	.value_type_id = 4,
766 	.max_entries = 1,
767 	.btf_load_err = true,
768 	.err_str = "Invalid type_id",
769 },
770 {
771 	.descr = "global data test #18, invalid var loop",
772 	.raw_types = {
773 		/* int */
774 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
775 		BTF_VAR_ENC(NAME_TBD, 2, 0),			/* [2] */
776 		/* .bss section */				/* [3] */
777 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
778 		BTF_VAR_SECINFO_ENC(2, 0, 4),
779 		BTF_END_RAW,
780 	},
781 	.str_sec = "\0A\0t\0aaa",
782 	.str_sec_size = sizeof("\0A\0t\0aaa"),
783 	.map_type = BPF_MAP_TYPE_ARRAY,
784 	.map_name = ".bss",
785 	.key_size = sizeof(int),
786 	.value_size = 4,
787 	.key_type_id = 0,
788 	.value_type_id = 4,
789 	.max_entries = 1,
790 	.btf_load_err = true,
791 	.err_str = "Invalid type_id",
792 },
793 {
794 	.descr = "global data test #19, invalid var referencing var",
795 	.raw_types = {
796 		/* int */
797 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
798 		BTF_VAR_ENC(NAME_TBD, 3, 0),			/* [2] */
799 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [3] */
800 		BTF_END_RAW,
801 	},
802 	.str_sec = "\0A\0t\0s\0a\0a",
803 	.str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
804 	.map_type = BPF_MAP_TYPE_ARRAY,
805 	.map_name = ".bss",
806 	.key_size = sizeof(int),
807 	.value_size = 4,
808 	.key_type_id = 0,
809 	.value_type_id = 4,
810 	.max_entries = 1,
811 	.btf_load_err = true,
812 	.err_str = "Invalid type_id",
813 },
814 {
815 	.descr = "global data test #20, invalid ptr referencing var",
816 	.raw_types = {
817 		/* int */
818 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
819 		/* PTR type_id=3	*/			/* [2] */
820 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 3),
821 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [3] */
822 		BTF_END_RAW,
823 	},
824 	.str_sec = "\0A\0t\0s\0a\0a",
825 	.str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
826 	.map_type = BPF_MAP_TYPE_ARRAY,
827 	.map_name = ".bss",
828 	.key_size = sizeof(int),
829 	.value_size = 4,
830 	.key_type_id = 0,
831 	.value_type_id = 4,
832 	.max_entries = 1,
833 	.btf_load_err = true,
834 	.err_str = "Invalid type_id",
835 },
836 {
837 	.descr = "global data test #21, var included in struct",
838 	.raw_types = {
839 		/* int */
840 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
841 		/* struct A { */				/* [2] */
842 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2),
843 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int m; */
844 		BTF_MEMBER_ENC(NAME_TBD, 3, 32),/* VAR type_id=3; */
845 		/* } */
846 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [3] */
847 		BTF_END_RAW,
848 	},
849 	.str_sec = "\0A\0t\0s\0a\0a",
850 	.str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
851 	.map_type = BPF_MAP_TYPE_ARRAY,
852 	.map_name = ".bss",
853 	.key_size = sizeof(int),
854 	.value_size = 4,
855 	.key_type_id = 0,
856 	.value_type_id = 4,
857 	.max_entries = 1,
858 	.btf_load_err = true,
859 	.err_str = "Invalid member",
860 },
861 {
862 	.descr = "global data test #22, array of var",
863 	.raw_types = {
864 		/* int */
865 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
866 		BTF_TYPE_ARRAY_ENC(3, 1, 4),			/* [2] */
867 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [3] */
868 		BTF_END_RAW,
869 	},
870 	.str_sec = "\0A\0t\0s\0a\0a",
871 	.str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
872 	.map_type = BPF_MAP_TYPE_ARRAY,
873 	.map_name = ".bss",
874 	.key_size = sizeof(int),
875 	.value_size = 4,
876 	.key_type_id = 0,
877 	.value_type_id = 4,
878 	.max_entries = 1,
879 	.btf_load_err = true,
880 	.err_str = "Invalid elem",
881 },
882 {
883 	.descr = "var after datasec, ptr followed by modifier",
884 	.raw_types = {
885 		/* .bss section */				/* [1] */
886 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2),
887 			sizeof(void*)+4),
888 		BTF_VAR_SECINFO_ENC(4, 0, sizeof(void*)),
889 		BTF_VAR_SECINFO_ENC(6, sizeof(void*), 4),
890 		/* int */					/* [2] */
891 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
892 		/* int* */					/* [3] */
893 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
894 		BTF_VAR_ENC(NAME_TBD, 3, 0),			/* [4] */
895 		/* const int */					/* [5] */
896 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
897 		BTF_VAR_ENC(NAME_TBD, 5, 0),			/* [6] */
898 		BTF_END_RAW,
899 	},
900 	.str_sec = "\0a\0b\0c\0",
901 	.str_sec_size = sizeof("\0a\0b\0c\0"),
902 	.map_type = BPF_MAP_TYPE_ARRAY,
903 	.map_name = ".bss",
904 	.key_size = sizeof(int),
905 	.value_size = sizeof(void*)+4,
906 	.key_type_id = 0,
907 	.value_type_id = 1,
908 	.max_entries = 1,
909 },
910 /* Test member exceeds the size of struct.
911  *
912  * struct A {
913  *     int m;
914  *     int n;
915  * };
916  */
917 {
918 	.descr = "size check test #1",
919 	.raw_types = {
920 		/* int */					/* [1] */
921 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
922 		/* struct A { */				/* [2] */
923 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2 -  1),
924 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int m; */
925 		BTF_MEMBER_ENC(NAME_TBD, 1, 32),/* int n; */
926 		/* } */
927 		BTF_END_RAW,
928 	},
929 	.str_sec = "\0A\0m\0n",
930 	.str_sec_size = sizeof("\0A\0m\0n"),
931 	.map_type = BPF_MAP_TYPE_ARRAY,
932 	.map_name = "size_check1_map",
933 	.key_size = sizeof(int),
934 	.value_size = 1,
935 	.key_type_id = 1,
936 	.value_type_id = 2,
937 	.max_entries = 4,
938 	.btf_load_err = true,
939 	.err_str = "Member exceeds struct_size",
940 },
941 
942 /* Test member exceeds the size of struct
943  *
944  * struct A {
945  *     int m;
946  *     int n[2];
947  * };
948  */
949 {
950 	.descr = "size check test #2",
951 	.raw_types = {
952 		/* int */					/* [1] */
953 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
954 		/* int[2] */					/* [2] */
955 		BTF_TYPE_ARRAY_ENC(1, 1, 2),
956 		/* struct A { */				/* [3] */
957 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 3 - 1),
958 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int m; */
959 		BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* int n[2]; */
960 		/* } */
961 		BTF_END_RAW,
962 	},
963 	.str_sec = "\0A\0m\0n",
964 	.str_sec_size = sizeof("\0A\0m\0n"),
965 	.map_type = BPF_MAP_TYPE_ARRAY,
966 	.map_name = "size_check2_map",
967 	.key_size = sizeof(int),
968 	.value_size = 1,
969 	.key_type_id = 1,
970 	.value_type_id = 3,
971 	.max_entries = 4,
972 	.btf_load_err = true,
973 	.err_str = "Member exceeds struct_size",
974 },
975 
976 /* Test member exceeds the size of struct
977  *
978  * struct A {
979  *     int m;
980  *     void *n;
981  * };
982  */
983 {
984 	.descr = "size check test #3",
985 	.raw_types = {
986 		/* int */					/* [1] */
987 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
988 		/* void* */					/* [2] */
989 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
990 		/* struct A { */				/* [3] */
991 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) + sizeof(void *) - 1),
992 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int m; */
993 		BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* void *n; */
994 		/* } */
995 		BTF_END_RAW,
996 	},
997 	.str_sec = "\0A\0m\0n",
998 	.str_sec_size = sizeof("\0A\0m\0n"),
999 	.map_type = BPF_MAP_TYPE_ARRAY,
1000 	.map_name = "size_check3_map",
1001 	.key_size = sizeof(int),
1002 	.value_size = 1,
1003 	.key_type_id = 1,
1004 	.value_type_id = 3,
1005 	.max_entries = 4,
1006 	.btf_load_err = true,
1007 	.err_str = "Member exceeds struct_size",
1008 },
1009 
1010 /* Test member exceeds the size of struct
1011  *
1012  * enum E {
1013  *     E0,
1014  *     E1,
1015  * };
1016  *
1017  * struct A {
1018  *     int m;
1019  *     enum E n;
1020  * };
1021  */
1022 {
1023 	.descr = "size check test #4",
1024 	.raw_types = {
1025 		/* int */			/* [1] */
1026 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
1027 		/* enum E { */			/* [2] */
1028 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), sizeof(int)),
1029 		BTF_ENUM_ENC(NAME_TBD, 0),
1030 		BTF_ENUM_ENC(NAME_TBD, 1),
1031 		/* } */
1032 		/* struct A { */		/* [3] */
1033 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2 - 1),
1034 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int m; */
1035 		BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* enum E n; */
1036 		/* } */
1037 		BTF_END_RAW,
1038 	},
1039 	.str_sec = "\0E\0E0\0E1\0A\0m\0n",
1040 	.str_sec_size = sizeof("\0E\0E0\0E1\0A\0m\0n"),
1041 	.map_type = BPF_MAP_TYPE_ARRAY,
1042 	.map_name = "size_check4_map",
1043 	.key_size = sizeof(int),
1044 	.value_size = 1,
1045 	.key_type_id = 1,
1046 	.value_type_id = 3,
1047 	.max_entries = 4,
1048 	.btf_load_err = true,
1049 	.err_str = "Member exceeds struct_size",
1050 },
1051 
1052 /* Test member unexceeds the size of struct
1053  *
1054  * enum E {
1055  *     E0,
1056  *     E1,
1057  * };
1058  *
1059  * struct A {
1060  *     char m;
1061  *     enum E __attribute__((packed)) n;
1062  * };
1063  */
1064 {
1065 	.descr = "size check test #5",
1066 	.raw_types = {
1067 		/* int */			/* [1] */
1068 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
1069 		/* char */			/* [2] */
1070 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),
1071 		/* enum E { */			/* [3] */
1072 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 1),
1073 		BTF_ENUM_ENC(NAME_TBD, 0),
1074 		BTF_ENUM_ENC(NAME_TBD, 1),
1075 		/* } */
1076 		/* struct A { */		/* [4] */
1077 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 2),
1078 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),	/* char m; */
1079 		BTF_MEMBER_ENC(NAME_TBD, 3, 8),/* enum E __attribute__((packed)) n; */
1080 		/* } */
1081 		BTF_END_RAW,
1082 	},
1083 	.str_sec = "\0E\0E0\0E1\0A\0m\0n",
1084 	.str_sec_size = sizeof("\0E\0E0\0E1\0A\0m\0n"),
1085 	.map_type = BPF_MAP_TYPE_ARRAY,
1086 	.map_name = "size_check5_map",
1087 	.key_size = sizeof(int),
1088 	.value_size = 2,
1089 	.key_type_id = 1,
1090 	.value_type_id = 4,
1091 	.max_entries = 4,
1092 },
1093 
1094 /* typedef const void * const_void_ptr;
1095  * struct A {
1096  *	const_void_ptr m;
1097  * };
1098  */
1099 {
1100 	.descr = "void test #1",
1101 	.raw_types = {
1102 		/* int */		/* [1] */
1103 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1104 		/* const void */	/* [2] */
1105 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1106 		/* const void* */	/* [3] */
1107 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
1108 		/* typedef const void * const_void_ptr */
1109 		BTF_TYPEDEF_ENC(NAME_TBD, 3),	/* [4] */
1110 		/* struct A { */	/* [5] */
1111 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
1112 		/* const_void_ptr m; */
1113 		BTF_MEMBER_ENC(NAME_TBD, 4, 0),
1114 		/* } */
1115 		BTF_END_RAW,
1116 	},
1117 	.str_sec = "\0const_void_ptr\0A\0m",
1118 	.str_sec_size = sizeof("\0const_void_ptr\0A\0m"),
1119 	.map_type = BPF_MAP_TYPE_ARRAY,
1120 	.map_name = "void_test1_map",
1121 	.key_size = sizeof(int),
1122 	.value_size = sizeof(void *),
1123 	.key_type_id = 1,
1124 	.value_type_id = 4,
1125 	.max_entries = 4,
1126 },
1127 
1128 /* struct A {
1129  *     const void m;
1130  * };
1131  */
1132 {
1133 	.descr = "void test #2",
1134 	.raw_types = {
1135 		/* int */		/* [1] */
1136 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1137 		/* const void */	/* [2] */
1138 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1139 		/* struct A { */	/* [3] */
1140 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 8),
1141 		/* const void m; */
1142 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
1143 		/* } */
1144 		BTF_END_RAW,
1145 	},
1146 	.str_sec = "\0A\0m",
1147 	.str_sec_size = sizeof("\0A\0m"),
1148 	.map_type = BPF_MAP_TYPE_ARRAY,
1149 	.map_name = "void_test2_map",
1150 	.key_size = sizeof(int),
1151 	.value_size = sizeof(void *),
1152 	.key_type_id = 1,
1153 	.value_type_id = 3,
1154 	.max_entries = 4,
1155 	.btf_load_err = true,
1156 	.err_str = "Invalid member",
1157 },
1158 
1159 /* typedef const void * const_void_ptr;
1160  * const_void_ptr[4]
1161  */
1162 {
1163 	.descr = "void test #3",
1164 	.raw_types = {
1165 		/* int */		/* [1] */
1166 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1167 		/* const void */	/* [2] */
1168 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1169 		/* const void* */	/* [3] */
1170 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
1171 		/* typedef const void * const_void_ptr */
1172 		BTF_TYPEDEF_ENC(NAME_TBD, 3),	/* [4] */
1173 		/* const_void_ptr[4] */
1174 		BTF_TYPE_ARRAY_ENC(4, 1, 4),	/* [5] */
1175 		BTF_END_RAW,
1176 	},
1177 	.str_sec = "\0const_void_ptr",
1178 	.str_sec_size = sizeof("\0const_void_ptr"),
1179 	.map_type = BPF_MAP_TYPE_ARRAY,
1180 	.map_name = "void_test3_map",
1181 	.key_size = sizeof(int),
1182 	.value_size = sizeof(void *) * 4,
1183 	.key_type_id = 1,
1184 	.value_type_id = 5,
1185 	.max_entries = 4,
1186 },
1187 
1188 /* const void[4]  */
1189 {
1190 	.descr = "void test #4",
1191 	.raw_types = {
1192 		/* int */		/* [1] */
1193 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1194 		/* const void */	/* [2] */
1195 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1196 		/* const void[4] */	/* [3] */
1197 		BTF_TYPE_ARRAY_ENC(2, 1, 4),
1198 		BTF_END_RAW,
1199 	},
1200 	.str_sec = "\0A\0m",
1201 	.str_sec_size = sizeof("\0A\0m"),
1202 	.map_type = BPF_MAP_TYPE_ARRAY,
1203 	.map_name = "void_test4_map",
1204 	.key_size = sizeof(int),
1205 	.value_size = sizeof(void *) * 4,
1206 	.key_type_id = 1,
1207 	.value_type_id = 3,
1208 	.max_entries = 4,
1209 	.btf_load_err = true,
1210 	.err_str = "Invalid elem",
1211 },
1212 
1213 /* Array_A  <------------------+
1214  *     elem_type == Array_B    |
1215  *                    |        |
1216  *                    |        |
1217  * Array_B  <-------- +        |
1218  *      elem_type == Array A --+
1219  */
1220 {
1221 	.descr = "loop test #1",
1222 	.raw_types = {
1223 		/* int */			/* [1] */
1224 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1225 		/* Array_A */			/* [2] */
1226 		BTF_TYPE_ARRAY_ENC(3, 1, 8),
1227 		/* Array_B */			/* [3] */
1228 		BTF_TYPE_ARRAY_ENC(2, 1, 8),
1229 		BTF_END_RAW,
1230 	},
1231 	.str_sec = "",
1232 	.str_sec_size = sizeof(""),
1233 	.map_type = BPF_MAP_TYPE_ARRAY,
1234 	.map_name = "loop_test1_map",
1235 	.key_size = sizeof(int),
1236 	.value_size = sizeof(sizeof(int) * 8),
1237 	.key_type_id = 1,
1238 	.value_type_id = 2,
1239 	.max_entries = 4,
1240 	.btf_load_err = true,
1241 	.err_str = "Loop detected",
1242 },
1243 
1244 /* typedef is _before_ the BTF type of Array_A and Array_B
1245  *
1246  * typedef Array_B int_array;
1247  *
1248  * Array_A  <------------------+
1249  *     elem_type == int_array  |
1250  *                    |        |
1251  *                    |        |
1252  * Array_B  <-------- +        |
1253  *      elem_type == Array_A --+
1254  */
1255 {
1256 	.descr = "loop test #2",
1257 	.raw_types = {
1258 		/* int */
1259 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
1260 		/* typedef Array_B int_array */
1261 		BTF_TYPEDEF_ENC(1, 4),				/* [2] */
1262 		/* Array_A */
1263 		BTF_TYPE_ARRAY_ENC(2, 1, 8),			/* [3] */
1264 		/* Array_B */
1265 		BTF_TYPE_ARRAY_ENC(3, 1, 8),			/* [4] */
1266 		BTF_END_RAW,
1267 	},
1268 	.str_sec = "\0int_array\0",
1269 	.str_sec_size = sizeof("\0int_array"),
1270 	.map_type = BPF_MAP_TYPE_ARRAY,
1271 	.map_name = "loop_test2_map",
1272 	.key_size = sizeof(int),
1273 	.value_size = sizeof(sizeof(int) * 8),
1274 	.key_type_id = 1,
1275 	.value_type_id = 2,
1276 	.max_entries = 4,
1277 	.btf_load_err = true,
1278 	.err_str = "Loop detected",
1279 },
1280 
1281 /* Array_A  <------------------+
1282  *     elem_type == Array_B    |
1283  *                    |        |
1284  *                    |        |
1285  * Array_B  <-------- +        |
1286  *      elem_type == Array_A --+
1287  */
1288 {
1289 	.descr = "loop test #3",
1290 	.raw_types = {
1291 		/* int */				/* [1] */
1292 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1293 		/* Array_A */				/* [2] */
1294 		BTF_TYPE_ARRAY_ENC(3, 1, 8),
1295 		/* Array_B */				/* [3] */
1296 		BTF_TYPE_ARRAY_ENC(2, 1, 8),
1297 		BTF_END_RAW,
1298 	},
1299 	.str_sec = "",
1300 	.str_sec_size = sizeof(""),
1301 	.map_type = BPF_MAP_TYPE_ARRAY,
1302 	.map_name = "loop_test3_map",
1303 	.key_size = sizeof(int),
1304 	.value_size = sizeof(sizeof(int) * 8),
1305 	.key_type_id = 1,
1306 	.value_type_id = 2,
1307 	.max_entries = 4,
1308 	.btf_load_err = true,
1309 	.err_str = "Loop detected",
1310 },
1311 
1312 /* typedef is _between_ the BTF type of Array_A and Array_B
1313  *
1314  * typedef Array_B int_array;
1315  *
1316  * Array_A  <------------------+
1317  *     elem_type == int_array  |
1318  *                    |        |
1319  *                    |        |
1320  * Array_B  <-------- +        |
1321  *      elem_type == Array_A --+
1322  */
1323 {
1324 	.descr = "loop test #4",
1325 	.raw_types = {
1326 		/* int */				/* [1] */
1327 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1328 		/* Array_A */				/* [2] */
1329 		BTF_TYPE_ARRAY_ENC(3, 1, 8),
1330 		/* typedef Array_B int_array */		/* [3] */
1331 		BTF_TYPEDEF_ENC(NAME_TBD, 4),
1332 		/* Array_B */				/* [4] */
1333 		BTF_TYPE_ARRAY_ENC(2, 1, 8),
1334 		BTF_END_RAW,
1335 	},
1336 	.str_sec = "\0int_array\0",
1337 	.str_sec_size = sizeof("\0int_array"),
1338 	.map_type = BPF_MAP_TYPE_ARRAY,
1339 	.map_name = "loop_test4_map",
1340 	.key_size = sizeof(int),
1341 	.value_size = sizeof(sizeof(int) * 8),
1342 	.key_type_id = 1,
1343 	.value_type_id = 2,
1344 	.max_entries = 4,
1345 	.btf_load_err = true,
1346 	.err_str = "Loop detected",
1347 },
1348 
1349 /* typedef struct B Struct_B
1350  *
1351  * struct A {
1352  *     int x;
1353  *     Struct_B y;
1354  * };
1355  *
1356  * struct B {
1357  *     int x;
1358  *     struct A y;
1359  * };
1360  */
1361 {
1362 	.descr = "loop test #5",
1363 	.raw_types = {
1364 		/* int */
1365 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
1366 		/* struct A */					/* [2] */
1367 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
1368 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int x;	*/
1369 		BTF_MEMBER_ENC(NAME_TBD, 3, 32),/* Struct_B y;	*/
1370 		/* typedef struct B Struct_B */
1371 		BTF_TYPEDEF_ENC(NAME_TBD, 4),			/* [3] */
1372 		/* struct B */					/* [4] */
1373 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
1374 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int x;	*/
1375 		BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct A y;	*/
1376 		BTF_END_RAW,
1377 	},
1378 	.str_sec = "\0A\0x\0y\0Struct_B\0B\0x\0y",
1379 	.str_sec_size = sizeof("\0A\0x\0y\0Struct_B\0B\0x\0y"),
1380 	.map_type = BPF_MAP_TYPE_ARRAY,
1381 	.map_name = "loop_test5_map",
1382 	.key_size = sizeof(int),
1383 	.value_size = 8,
1384 	.key_type_id = 1,
1385 	.value_type_id = 2,
1386 	.max_entries = 4,
1387 	.btf_load_err = true,
1388 	.err_str = "Loop detected",
1389 },
1390 
1391 /* struct A {
1392  *     int x;
1393  *     struct A array_a[4];
1394  * };
1395  */
1396 {
1397 	.descr = "loop test #6",
1398 	.raw_types = {
1399 		/* int */
1400 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
1401 		BTF_TYPE_ARRAY_ENC(3, 1, 4),			/* [2] */
1402 		/* struct A */					/* [3] */
1403 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
1404 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),	/* int x;		*/
1405 		BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct A array_a[4];	*/
1406 		BTF_END_RAW,
1407 	},
1408 	.str_sec = "\0A\0x\0y",
1409 	.str_sec_size = sizeof("\0A\0x\0y"),
1410 	.map_type = BPF_MAP_TYPE_ARRAY,
1411 	.map_name = "loop_test6_map",
1412 	.key_size = sizeof(int),
1413 	.value_size = 8,
1414 	.key_type_id = 1,
1415 	.value_type_id = 2,
1416 	.max_entries = 4,
1417 	.btf_load_err = true,
1418 	.err_str = "Loop detected",
1419 },
1420 
1421 {
1422 	.descr = "loop test #7",
1423 	.raw_types = {
1424 		/* int */				/* [1] */
1425 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1426 		/* struct A { */			/* [2] */
1427 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
1428 		/*     const void *m;	*/
1429 		BTF_MEMBER_ENC(NAME_TBD, 3, 0),
1430 		/* CONST type_id=3	*/		/* [3] */
1431 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
1432 		/* PTR type_id=2	*/		/* [4] */
1433 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 3),
1434 		BTF_END_RAW,
1435 	},
1436 	.str_sec = "\0A\0m",
1437 	.str_sec_size = sizeof("\0A\0m"),
1438 	.map_type = BPF_MAP_TYPE_ARRAY,
1439 	.map_name = "loop_test7_map",
1440 	.key_size = sizeof(int),
1441 	.value_size = sizeof(void *),
1442 	.key_type_id = 1,
1443 	.value_type_id = 2,
1444 	.max_entries = 4,
1445 	.btf_load_err = true,
1446 	.err_str = "Loop detected",
1447 },
1448 
1449 {
1450 	.descr = "loop test #8",
1451 	.raw_types = {
1452 		/* int */				/* [1] */
1453 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1454 		/* struct A { */			/* [2] */
1455 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
1456 		/*     const void *m;	*/
1457 		BTF_MEMBER_ENC(NAME_TBD, 4, 0),
1458 		/* struct B { */			/* [3] */
1459 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
1460 		/*     const void *n;	*/
1461 		BTF_MEMBER_ENC(NAME_TBD, 6, 0),
1462 		/* CONST type_id=5	*/		/* [4] */
1463 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 5),
1464 		/* PTR type_id=6	*/		/* [5] */
1465 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 6),
1466 		/* CONST type_id=7	*/		/* [6] */
1467 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 7),
1468 		/* PTR type_id=4	*/		/* [7] */
1469 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 4),
1470 		BTF_END_RAW,
1471 	},
1472 	.str_sec = "\0A\0m\0B\0n",
1473 	.str_sec_size = sizeof("\0A\0m\0B\0n"),
1474 	.map_type = BPF_MAP_TYPE_ARRAY,
1475 	.map_name = "loop_test8_map",
1476 	.key_size = sizeof(int),
1477 	.value_size = sizeof(void *),
1478 	.key_type_id = 1,
1479 	.value_type_id = 2,
1480 	.max_entries = 4,
1481 	.btf_load_err = true,
1482 	.err_str = "Loop detected",
1483 },
1484 
1485 {
1486 	.descr = "string section does not end with null",
1487 	.raw_types = {
1488 		/* int */				/* [1] */
1489 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1490 		BTF_END_RAW,
1491 	},
1492 	.str_sec = "\0int",
1493 	.str_sec_size = sizeof("\0int") - 1,
1494 	.map_type = BPF_MAP_TYPE_ARRAY,
1495 	.map_name = "hdr_test_map",
1496 	.key_size = sizeof(int),
1497 	.value_size = sizeof(int),
1498 	.key_type_id = 1,
1499 	.value_type_id = 1,
1500 	.max_entries = 4,
1501 	.btf_load_err = true,
1502 	.err_str = "Invalid string section",
1503 },
1504 
1505 {
1506 	.descr = "empty string section",
1507 	.raw_types = {
1508 		/* int */				/* [1] */
1509 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1510 		BTF_END_RAW,
1511 	},
1512 	.str_sec = "",
1513 	.str_sec_size = 0,
1514 	.map_type = BPF_MAP_TYPE_ARRAY,
1515 	.map_name = "hdr_test_map",
1516 	.key_size = sizeof(int),
1517 	.value_size = sizeof(int),
1518 	.key_type_id = 1,
1519 	.value_type_id = 1,
1520 	.max_entries = 4,
1521 	.btf_load_err = true,
1522 	.err_str = "Invalid string section",
1523 },
1524 
1525 {
1526 	.descr = "empty type section",
1527 	.raw_types = {
1528 		BTF_END_RAW,
1529 	},
1530 	.str_sec = "\0int",
1531 	.str_sec_size = sizeof("\0int"),
1532 	.map_type = BPF_MAP_TYPE_ARRAY,
1533 	.map_name = "hdr_test_map",
1534 	.key_size = sizeof(int),
1535 	.value_size = sizeof(int),
1536 	.key_type_id = 1,
1537 	.value_type_id = 1,
1538 	.max_entries = 4,
1539 	.btf_load_err = true,
1540 	.err_str = "No type found",
1541 },
1542 
1543 {
1544 	.descr = "btf_header test. Longer hdr_len",
1545 	.raw_types = {
1546 		/* int */				/* [1] */
1547 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1548 		BTF_END_RAW,
1549 	},
1550 	.str_sec = "\0int",
1551 	.str_sec_size = sizeof("\0int"),
1552 	.map_type = BPF_MAP_TYPE_ARRAY,
1553 	.map_name = "hdr_test_map",
1554 	.key_size = sizeof(int),
1555 	.value_size = sizeof(int),
1556 	.key_type_id = 1,
1557 	.value_type_id = 1,
1558 	.max_entries = 4,
1559 	.btf_load_err = true,
1560 	.hdr_len_delta = 4,
1561 	.err_str = "Unsupported btf_header",
1562 },
1563 
1564 {
1565 	.descr = "btf_header test. Gap between hdr and type",
1566 	.raw_types = {
1567 		/* int */				/* [1] */
1568 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1569 		BTF_END_RAW,
1570 	},
1571 	.str_sec = "\0int",
1572 	.str_sec_size = sizeof("\0int"),
1573 	.map_type = BPF_MAP_TYPE_ARRAY,
1574 	.map_name = "hdr_test_map",
1575 	.key_size = sizeof(int),
1576 	.value_size = sizeof(int),
1577 	.key_type_id = 1,
1578 	.value_type_id = 1,
1579 	.max_entries = 4,
1580 	.btf_load_err = true,
1581 	.type_off_delta = 4,
1582 	.err_str = "Unsupported section found",
1583 },
1584 
1585 {
1586 	.descr = "btf_header test. Gap between type and str",
1587 	.raw_types = {
1588 		/* int */				/* [1] */
1589 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1590 		BTF_END_RAW,
1591 	},
1592 	.str_sec = "\0int",
1593 	.str_sec_size = sizeof("\0int"),
1594 	.map_type = BPF_MAP_TYPE_ARRAY,
1595 	.map_name = "hdr_test_map",
1596 	.key_size = sizeof(int),
1597 	.value_size = sizeof(int),
1598 	.key_type_id = 1,
1599 	.value_type_id = 1,
1600 	.max_entries = 4,
1601 	.btf_load_err = true,
1602 	.str_off_delta = 4,
1603 	.err_str = "Unsupported section found",
1604 },
1605 
1606 {
1607 	.descr = "btf_header test. Overlap between type and str",
1608 	.raw_types = {
1609 		/* int */				/* [1] */
1610 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1611 		BTF_END_RAW,
1612 	},
1613 	.str_sec = "\0int",
1614 	.str_sec_size = sizeof("\0int"),
1615 	.map_type = BPF_MAP_TYPE_ARRAY,
1616 	.map_name = "hdr_test_map",
1617 	.key_size = sizeof(int),
1618 	.value_size = sizeof(int),
1619 	.key_type_id = 1,
1620 	.value_type_id = 1,
1621 	.max_entries = 4,
1622 	.btf_load_err = true,
1623 	.str_off_delta = -4,
1624 	.err_str = "Section overlap found",
1625 },
1626 
1627 {
1628 	.descr = "btf_header test. Larger BTF size",
1629 	.raw_types = {
1630 		/* int */				/* [1] */
1631 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1632 		BTF_END_RAW,
1633 	},
1634 	.str_sec = "\0int",
1635 	.str_sec_size = sizeof("\0int"),
1636 	.map_type = BPF_MAP_TYPE_ARRAY,
1637 	.map_name = "hdr_test_map",
1638 	.key_size = sizeof(int),
1639 	.value_size = sizeof(int),
1640 	.key_type_id = 1,
1641 	.value_type_id = 1,
1642 	.max_entries = 4,
1643 	.btf_load_err = true,
1644 	.str_len_delta = -4,
1645 	.err_str = "Unsupported section found",
1646 },
1647 
1648 {
1649 	.descr = "btf_header test. Smaller BTF size",
1650 	.raw_types = {
1651 		/* int */				/* [1] */
1652 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1653 		BTF_END_RAW,
1654 	},
1655 	.str_sec = "\0int",
1656 	.str_sec_size = sizeof("\0int"),
1657 	.map_type = BPF_MAP_TYPE_ARRAY,
1658 	.map_name = "hdr_test_map",
1659 	.key_size = sizeof(int),
1660 	.value_size = sizeof(int),
1661 	.key_type_id = 1,
1662 	.value_type_id = 1,
1663 	.max_entries = 4,
1664 	.btf_load_err = true,
1665 	.str_len_delta = 4,
1666 	.err_str = "Total section length too long",
1667 },
1668 
1669 {
1670 	.descr = "array test. index_type/elem_type \"int\"",
1671 	.raw_types = {
1672 		/* int */				/* [1] */
1673 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1674 		/* int[16] */				/* [2] */
1675 		BTF_TYPE_ARRAY_ENC(1, 1, 16),
1676 		BTF_END_RAW,
1677 	},
1678 	.str_sec = "",
1679 	.str_sec_size = sizeof(""),
1680 	.map_type = BPF_MAP_TYPE_ARRAY,
1681 	.map_name = "array_test_map",
1682 	.key_size = sizeof(int),
1683 	.value_size = sizeof(int),
1684 	.key_type_id = 1,
1685 	.value_type_id = 1,
1686 	.max_entries = 4,
1687 },
1688 
1689 {
1690 	.descr = "array test. index_type/elem_type \"const int\"",
1691 	.raw_types = {
1692 		/* int */				/* [1] */
1693 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1694 		/* int[16] */				/* [2] */
1695 		BTF_TYPE_ARRAY_ENC(3, 3, 16),
1696 		/* CONST type_id=1 */			/* [3] */
1697 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),
1698 		BTF_END_RAW,
1699 	},
1700 	.str_sec = "",
1701 	.str_sec_size = sizeof(""),
1702 	.map_type = BPF_MAP_TYPE_ARRAY,
1703 	.map_name = "array_test_map",
1704 	.key_size = sizeof(int),
1705 	.value_size = sizeof(int),
1706 	.key_type_id = 1,
1707 	.value_type_id = 1,
1708 	.max_entries = 4,
1709 },
1710 
1711 {
1712 	.descr = "array test. index_type \"const int:31\"",
1713 	.raw_types = {
1714 		/* int */				/* [1] */
1715 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1716 		/* int:31 */				/* [2] */
1717 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 31, 4),
1718 		/* int[16] */				/* [3] */
1719 		BTF_TYPE_ARRAY_ENC(1, 4, 16),
1720 		/* CONST type_id=2 */			/* [4] */
1721 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
1722 		BTF_END_RAW,
1723 	},
1724 	.str_sec = "",
1725 	.str_sec_size = sizeof(""),
1726 	.map_type = BPF_MAP_TYPE_ARRAY,
1727 	.map_name = "array_test_map",
1728 	.key_size = sizeof(int),
1729 	.value_size = sizeof(int),
1730 	.key_type_id = 1,
1731 	.value_type_id = 1,
1732 	.max_entries = 4,
1733 	.btf_load_err = true,
1734 	.err_str = "Invalid index",
1735 },
1736 
1737 {
1738 	.descr = "array test. elem_type \"const int:31\"",
1739 	.raw_types = {
1740 		/* int */				/* [1] */
1741 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1742 		/* int:31 */				/* [2] */
1743 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 31, 4),
1744 		/* int[16] */				/* [3] */
1745 		BTF_TYPE_ARRAY_ENC(4, 1, 16),
1746 		/* CONST type_id=2 */			/* [4] */
1747 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
1748 		BTF_END_RAW,
1749 	},
1750 	.str_sec = "",
1751 	.str_sec_size = sizeof(""),
1752 	.map_type = BPF_MAP_TYPE_ARRAY,
1753 	.map_name = "array_test_map",
1754 	.key_size = sizeof(int),
1755 	.value_size = sizeof(int),
1756 	.key_type_id = 1,
1757 	.value_type_id = 1,
1758 	.max_entries = 4,
1759 	.btf_load_err = true,
1760 	.err_str = "Invalid array of int",
1761 },
1762 
1763 {
1764 	.descr = "array test. index_type \"void\"",
1765 	.raw_types = {
1766 		/* int */				/* [1] */
1767 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1768 		/* int[16] */				/* [2] */
1769 		BTF_TYPE_ARRAY_ENC(1, 0, 16),
1770 		BTF_END_RAW,
1771 	},
1772 	.str_sec = "",
1773 	.str_sec_size = sizeof(""),
1774 	.map_type = BPF_MAP_TYPE_ARRAY,
1775 	.map_name = "array_test_map",
1776 	.key_size = sizeof(int),
1777 	.value_size = sizeof(int),
1778 	.key_type_id = 1,
1779 	.value_type_id = 1,
1780 	.max_entries = 4,
1781 	.btf_load_err = true,
1782 	.err_str = "Invalid index",
1783 },
1784 
1785 {
1786 	.descr = "array test. index_type \"const void\"",
1787 	.raw_types = {
1788 		/* int */				/* [1] */
1789 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1790 		/* int[16] */				/* [2] */
1791 		BTF_TYPE_ARRAY_ENC(1, 3, 16),
1792 		/* CONST type_id=0 (void) */		/* [3] */
1793 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1794 		BTF_END_RAW,
1795 	},
1796 	.str_sec = "",
1797 	.str_sec_size = sizeof(""),
1798 	.map_type = BPF_MAP_TYPE_ARRAY,
1799 	.map_name = "array_test_map",
1800 	.key_size = sizeof(int),
1801 	.value_size = sizeof(int),
1802 	.key_type_id = 1,
1803 	.value_type_id = 1,
1804 	.max_entries = 4,
1805 	.btf_load_err = true,
1806 	.err_str = "Invalid index",
1807 },
1808 
1809 {
1810 	.descr = "array test. elem_type \"const void\"",
1811 	.raw_types = {
1812 		/* int */				/* [1] */
1813 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1814 		/* int[16] */				/* [2] */
1815 		BTF_TYPE_ARRAY_ENC(3, 1, 16),
1816 		/* CONST type_id=0 (void) */		/* [3] */
1817 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1818 		BTF_END_RAW,
1819 	},
1820 	.str_sec = "",
1821 	.str_sec_size = sizeof(""),
1822 	.map_type = BPF_MAP_TYPE_ARRAY,
1823 	.map_name = "array_test_map",
1824 	.key_size = sizeof(int),
1825 	.value_size = sizeof(int),
1826 	.key_type_id = 1,
1827 	.value_type_id = 1,
1828 	.max_entries = 4,
1829 	.btf_load_err = true,
1830 	.err_str = "Invalid elem",
1831 },
1832 
1833 {
1834 	.descr = "array test. elem_type \"const void *\"",
1835 	.raw_types = {
1836 		/* int */				/* [1] */
1837 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1838 		/* const void *[16] */			/* [2] */
1839 		BTF_TYPE_ARRAY_ENC(3, 1, 16),
1840 		/* CONST type_id=4 */			/* [3] */
1841 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
1842 		/* void* */				/* [4] */
1843 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
1844 		BTF_END_RAW,
1845 	},
1846 	.str_sec = "",
1847 	.str_sec_size = sizeof(""),
1848 	.map_type = BPF_MAP_TYPE_ARRAY,
1849 	.map_name = "array_test_map",
1850 	.key_size = sizeof(int),
1851 	.value_size = sizeof(int),
1852 	.key_type_id = 1,
1853 	.value_type_id = 1,
1854 	.max_entries = 4,
1855 },
1856 
1857 {
1858 	.descr = "array test. index_type \"const void *\"",
1859 	.raw_types = {
1860 		/* int */				/* [1] */
1861 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1862 		/* const void *[16] */			/* [2] */
1863 		BTF_TYPE_ARRAY_ENC(3, 3, 16),
1864 		/* CONST type_id=4 */			/* [3] */
1865 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
1866 		/* void* */				/* [4] */
1867 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
1868 		BTF_END_RAW,
1869 	},
1870 	.str_sec = "",
1871 	.str_sec_size = sizeof(""),
1872 	.map_type = BPF_MAP_TYPE_ARRAY,
1873 	.map_name = "array_test_map",
1874 	.key_size = sizeof(int),
1875 	.value_size = sizeof(int),
1876 	.key_type_id = 1,
1877 	.value_type_id = 1,
1878 	.max_entries = 4,
1879 	.btf_load_err = true,
1880 	.err_str = "Invalid index",
1881 },
1882 
1883 {
1884 	.descr = "array test. t->size != 0\"",
1885 	.raw_types = {
1886 		/* int */				/* [1] */
1887 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1888 		/* int[16] */				/* [2] */
1889 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 1),
1890 		BTF_ARRAY_ENC(1, 1, 16),
1891 		BTF_END_RAW,
1892 	},
1893 	.str_sec = "",
1894 	.str_sec_size = sizeof(""),
1895 	.map_type = BPF_MAP_TYPE_ARRAY,
1896 	.map_name = "array_test_map",
1897 	.key_size = sizeof(int),
1898 	.value_size = sizeof(int),
1899 	.key_type_id = 1,
1900 	.value_type_id = 1,
1901 	.max_entries = 4,
1902 	.btf_load_err = true,
1903 	.err_str = "size != 0",
1904 },
1905 
1906 {
1907 	.descr = "int test. invalid int_data",
1908 	.raw_types = {
1909 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), 4),
1910 		0x10000000,
1911 		BTF_END_RAW,
1912 	},
1913 	.str_sec = "",
1914 	.str_sec_size = sizeof(""),
1915 	.map_type = BPF_MAP_TYPE_ARRAY,
1916 	.map_name = "array_test_map",
1917 	.key_size = sizeof(int),
1918 	.value_size = sizeof(int),
1919 	.key_type_id = 1,
1920 	.value_type_id = 1,
1921 	.max_entries = 4,
1922 	.btf_load_err = true,
1923 	.err_str = "Invalid int_data",
1924 },
1925 
1926 {
1927 	.descr = "invalid BTF_INFO",
1928 	.raw_types = {
1929 		/* int */				/* [1] */
1930 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1931 		BTF_TYPE_ENC(0, 0x20000000, 4),
1932 		BTF_END_RAW,
1933 	},
1934 	.str_sec = "",
1935 	.str_sec_size = sizeof(""),
1936 	.map_type = BPF_MAP_TYPE_ARRAY,
1937 	.map_name = "array_test_map",
1938 	.key_size = sizeof(int),
1939 	.value_size = sizeof(int),
1940 	.key_type_id = 1,
1941 	.value_type_id = 1,
1942 	.max_entries = 4,
1943 	.btf_load_err = true,
1944 	.err_str = "Invalid btf_info",
1945 },
1946 
1947 {
1948 	.descr = "fwd test. t->type != 0\"",
1949 	.raw_types = {
1950 		/* int */				/* [1] */
1951 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1952 		/* fwd type */				/* [2] */
1953 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 1),
1954 		BTF_END_RAW,
1955 	},
1956 	.str_sec = "",
1957 	.str_sec_size = sizeof(""),
1958 	.map_type = BPF_MAP_TYPE_ARRAY,
1959 	.map_name = "fwd_test_map",
1960 	.key_size = sizeof(int),
1961 	.value_size = sizeof(int),
1962 	.key_type_id = 1,
1963 	.value_type_id = 1,
1964 	.max_entries = 4,
1965 	.btf_load_err = true,
1966 	.err_str = "type != 0",
1967 },
1968 
1969 {
1970 	.descr = "typedef (invalid name, name_off = 0)",
1971 	.raw_types = {
1972 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
1973 		BTF_TYPEDEF_ENC(0, 1),				/* [2] */
1974 		BTF_END_RAW,
1975 	},
1976 	.str_sec = "\0__int",
1977 	.str_sec_size = sizeof("\0__int"),
1978 	.map_type = BPF_MAP_TYPE_ARRAY,
1979 	.map_name = "typedef_check_btf",
1980 	.key_size = sizeof(int),
1981 	.value_size = sizeof(int),
1982 	.key_type_id = 1,
1983 	.value_type_id = 1,
1984 	.max_entries = 4,
1985 	.btf_load_err = true,
1986 	.err_str = "Invalid name",
1987 },
1988 
1989 {
1990 	.descr = "typedef (invalid name, invalid identifier)",
1991 	.raw_types = {
1992 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
1993 		BTF_TYPEDEF_ENC(NAME_TBD, 1),			/* [2] */
1994 		BTF_END_RAW,
1995 	},
1996 	.str_sec = "\0__!int",
1997 	.str_sec_size = sizeof("\0__!int"),
1998 	.map_type = BPF_MAP_TYPE_ARRAY,
1999 	.map_name = "typedef_check_btf",
2000 	.key_size = sizeof(int),
2001 	.value_size = sizeof(int),
2002 	.key_type_id = 1,
2003 	.value_type_id = 1,
2004 	.max_entries = 4,
2005 	.btf_load_err = true,
2006 	.err_str = "Invalid name",
2007 },
2008 
2009 {
2010 	.descr = "ptr type (invalid name, name_off <> 0)",
2011 	.raw_types = {
2012 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2013 		BTF_TYPE_ENC(NAME_TBD,
2014 			     BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 1),	/* [2] */
2015 		BTF_END_RAW,
2016 	},
2017 	.str_sec = "\0__int",
2018 	.str_sec_size = sizeof("\0__int"),
2019 	.map_type = BPF_MAP_TYPE_ARRAY,
2020 	.map_name = "ptr_type_check_btf",
2021 	.key_size = sizeof(int),
2022 	.value_size = sizeof(int),
2023 	.key_type_id = 1,
2024 	.value_type_id = 1,
2025 	.max_entries = 4,
2026 	.btf_load_err = true,
2027 	.err_str = "Invalid name",
2028 },
2029 
2030 {
2031 	.descr = "volatile type (invalid name, name_off <> 0)",
2032 	.raw_types = {
2033 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2034 		BTF_TYPE_ENC(NAME_TBD,
2035 			     BTF_INFO_ENC(BTF_KIND_VOLATILE, 0, 0), 1),	/* [2] */
2036 		BTF_END_RAW,
2037 	},
2038 	.str_sec = "\0__int",
2039 	.str_sec_size = sizeof("\0__int"),
2040 	.map_type = BPF_MAP_TYPE_ARRAY,
2041 	.map_name = "volatile_type_check_btf",
2042 	.key_size = sizeof(int),
2043 	.value_size = sizeof(int),
2044 	.key_type_id = 1,
2045 	.value_type_id = 1,
2046 	.max_entries = 4,
2047 	.btf_load_err = true,
2048 	.err_str = "Invalid name",
2049 },
2050 
2051 {
2052 	.descr = "const type (invalid name, name_off <> 0)",
2053 	.raw_types = {
2054 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2055 		BTF_TYPE_ENC(NAME_TBD,
2056 			     BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),	/* [2] */
2057 		BTF_END_RAW,
2058 	},
2059 	.str_sec = "\0__int",
2060 	.str_sec_size = sizeof("\0__int"),
2061 	.map_type = BPF_MAP_TYPE_ARRAY,
2062 	.map_name = "const_type_check_btf",
2063 	.key_size = sizeof(int),
2064 	.value_size = sizeof(int),
2065 	.key_type_id = 1,
2066 	.value_type_id = 1,
2067 	.max_entries = 4,
2068 	.btf_load_err = true,
2069 	.err_str = "Invalid name",
2070 },
2071 
2072 {
2073 	.descr = "restrict type (invalid name, name_off <> 0)",
2074 	.raw_types = {
2075 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2076 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 1),	/* [2] */
2077 		BTF_TYPE_ENC(NAME_TBD,
2078 			     BTF_INFO_ENC(BTF_KIND_RESTRICT, 0, 0), 2),	/* [3] */
2079 		BTF_END_RAW,
2080 	},
2081 	.str_sec = "\0__int",
2082 	.str_sec_size = sizeof("\0__int"),
2083 	.map_type = BPF_MAP_TYPE_ARRAY,
2084 	.map_name = "restrict_type_check_btf",
2085 	.key_size = sizeof(int),
2086 	.value_size = sizeof(int),
2087 	.key_type_id = 1,
2088 	.value_type_id = 1,
2089 	.max_entries = 4,
2090 	.btf_load_err = true,
2091 	.err_str = "Invalid name",
2092 },
2093 
2094 {
2095 	.descr = "fwd type (invalid name, name_off = 0)",
2096 	.raw_types = {
2097 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2098 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 0),	/* [2] */
2099 		BTF_END_RAW,
2100 	},
2101 	.str_sec = "\0__skb",
2102 	.str_sec_size = sizeof("\0__skb"),
2103 	.map_type = BPF_MAP_TYPE_ARRAY,
2104 	.map_name = "fwd_type_check_btf",
2105 	.key_size = sizeof(int),
2106 	.value_size = sizeof(int),
2107 	.key_type_id = 1,
2108 	.value_type_id = 1,
2109 	.max_entries = 4,
2110 	.btf_load_err = true,
2111 	.err_str = "Invalid name",
2112 },
2113 
2114 {
2115 	.descr = "fwd type (invalid name, invalid identifier)",
2116 	.raw_types = {
2117 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2118 		BTF_TYPE_ENC(NAME_TBD,
2119 			     BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 0),	/* [2] */
2120 		BTF_END_RAW,
2121 	},
2122 	.str_sec = "\0__!skb",
2123 	.str_sec_size = sizeof("\0__!skb"),
2124 	.map_type = BPF_MAP_TYPE_ARRAY,
2125 	.map_name = "fwd_type_check_btf",
2126 	.key_size = sizeof(int),
2127 	.value_size = sizeof(int),
2128 	.key_type_id = 1,
2129 	.value_type_id = 1,
2130 	.max_entries = 4,
2131 	.btf_load_err = true,
2132 	.err_str = "Invalid name",
2133 },
2134 
2135 {
2136 	.descr = "array type (invalid name, name_off <> 0)",
2137 	.raw_types = {
2138 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2139 		BTF_TYPE_ENC(NAME_TBD,
2140 			     BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 0),	/* [2] */
2141 		BTF_ARRAY_ENC(1, 1, 4),
2142 		BTF_END_RAW,
2143 	},
2144 	.str_sec = "\0__skb",
2145 	.str_sec_size = sizeof("\0__skb"),
2146 	.map_type = BPF_MAP_TYPE_ARRAY,
2147 	.map_name = "array_type_check_btf",
2148 	.key_size = sizeof(int),
2149 	.value_size = sizeof(int),
2150 	.key_type_id = 1,
2151 	.value_type_id = 1,
2152 	.max_entries = 4,
2153 	.btf_load_err = true,
2154 	.err_str = "Invalid name",
2155 },
2156 
2157 {
2158 	.descr = "struct type (name_off = 0)",
2159 	.raw_types = {
2160 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2161 		BTF_TYPE_ENC(0,
2162 			     BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),	/* [2] */
2163 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
2164 		BTF_END_RAW,
2165 	},
2166 	.str_sec = "\0A",
2167 	.str_sec_size = sizeof("\0A"),
2168 	.map_type = BPF_MAP_TYPE_ARRAY,
2169 	.map_name = "struct_type_check_btf",
2170 	.key_size = sizeof(int),
2171 	.value_size = sizeof(int),
2172 	.key_type_id = 1,
2173 	.value_type_id = 1,
2174 	.max_entries = 4,
2175 },
2176 
2177 {
2178 	.descr = "struct type (invalid name, invalid identifier)",
2179 	.raw_types = {
2180 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2181 		BTF_TYPE_ENC(NAME_TBD,
2182 			     BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),	/* [2] */
2183 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
2184 		BTF_END_RAW,
2185 	},
2186 	.str_sec = "\0A!\0B",
2187 	.str_sec_size = sizeof("\0A!\0B"),
2188 	.map_type = BPF_MAP_TYPE_ARRAY,
2189 	.map_name = "struct_type_check_btf",
2190 	.key_size = sizeof(int),
2191 	.value_size = sizeof(int),
2192 	.key_type_id = 1,
2193 	.value_type_id = 1,
2194 	.max_entries = 4,
2195 	.btf_load_err = true,
2196 	.err_str = "Invalid name",
2197 },
2198 
2199 {
2200 	.descr = "struct member (name_off = 0)",
2201 	.raw_types = {
2202 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2203 		BTF_TYPE_ENC(0,
2204 			     BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),	/* [2] */
2205 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
2206 		BTF_END_RAW,
2207 	},
2208 	.str_sec = "\0A",
2209 	.str_sec_size = sizeof("\0A"),
2210 	.map_type = BPF_MAP_TYPE_ARRAY,
2211 	.map_name = "struct_type_check_btf",
2212 	.key_size = sizeof(int),
2213 	.value_size = sizeof(int),
2214 	.key_type_id = 1,
2215 	.value_type_id = 1,
2216 	.max_entries = 4,
2217 },
2218 
2219 {
2220 	.descr = "struct member (invalid name, invalid identifier)",
2221 	.raw_types = {
2222 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2223 		BTF_TYPE_ENC(NAME_TBD,
2224 			     BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),	/* [2] */
2225 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
2226 		BTF_END_RAW,
2227 	},
2228 	.str_sec = "\0A\0B*",
2229 	.str_sec_size = sizeof("\0A\0B*"),
2230 	.map_type = BPF_MAP_TYPE_ARRAY,
2231 	.map_name = "struct_type_check_btf",
2232 	.key_size = sizeof(int),
2233 	.value_size = sizeof(int),
2234 	.key_type_id = 1,
2235 	.value_type_id = 1,
2236 	.max_entries = 4,
2237 	.btf_load_err = true,
2238 	.err_str = "Invalid name",
2239 },
2240 
2241 {
2242 	.descr = "enum type (name_off = 0)",
2243 	.raw_types = {
2244 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2245 		BTF_TYPE_ENC(0,
2246 			     BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
2247 			     sizeof(int)),				/* [2] */
2248 		BTF_ENUM_ENC(NAME_TBD, 0),
2249 		BTF_END_RAW,
2250 	},
2251 	.str_sec = "\0A\0B",
2252 	.str_sec_size = sizeof("\0A\0B"),
2253 	.map_type = BPF_MAP_TYPE_ARRAY,
2254 	.map_name = "enum_type_check_btf",
2255 	.key_size = sizeof(int),
2256 	.value_size = sizeof(int),
2257 	.key_type_id = 1,
2258 	.value_type_id = 1,
2259 	.max_entries = 4,
2260 },
2261 
2262 {
2263 	.descr = "enum type (invalid name, invalid identifier)",
2264 	.raw_types = {
2265 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2266 		BTF_TYPE_ENC(NAME_TBD,
2267 			     BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
2268 			     sizeof(int)),				/* [2] */
2269 		BTF_ENUM_ENC(NAME_TBD, 0),
2270 		BTF_END_RAW,
2271 	},
2272 	.str_sec = "\0A!\0B",
2273 	.str_sec_size = sizeof("\0A!\0B"),
2274 	.map_type = BPF_MAP_TYPE_ARRAY,
2275 	.map_name = "enum_type_check_btf",
2276 	.key_size = sizeof(int),
2277 	.value_size = sizeof(int),
2278 	.key_type_id = 1,
2279 	.value_type_id = 1,
2280 	.max_entries = 4,
2281 	.btf_load_err = true,
2282 	.err_str = "Invalid name",
2283 },
2284 
2285 {
2286 	.descr = "enum member (invalid name, name_off = 0)",
2287 	.raw_types = {
2288 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2289 		BTF_TYPE_ENC(0,
2290 			     BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
2291 			     sizeof(int)),				/* [2] */
2292 		BTF_ENUM_ENC(0, 0),
2293 		BTF_END_RAW,
2294 	},
2295 	.str_sec = "",
2296 	.str_sec_size = sizeof(""),
2297 	.map_type = BPF_MAP_TYPE_ARRAY,
2298 	.map_name = "enum_type_check_btf",
2299 	.key_size = sizeof(int),
2300 	.value_size = sizeof(int),
2301 	.key_type_id = 1,
2302 	.value_type_id = 1,
2303 	.max_entries = 4,
2304 	.btf_load_err = true,
2305 	.err_str = "Invalid name",
2306 },
2307 
2308 {
2309 	.descr = "enum member (invalid name, invalid identifier)",
2310 	.raw_types = {
2311 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2312 		BTF_TYPE_ENC(0,
2313 			     BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
2314 			     sizeof(int)),				/* [2] */
2315 		BTF_ENUM_ENC(NAME_TBD, 0),
2316 		BTF_END_RAW,
2317 	},
2318 	.str_sec = "\0A!",
2319 	.str_sec_size = sizeof("\0A!"),
2320 	.map_type = BPF_MAP_TYPE_ARRAY,
2321 	.map_name = "enum_type_check_btf",
2322 	.key_size = sizeof(int),
2323 	.value_size = sizeof(int),
2324 	.key_type_id = 1,
2325 	.value_type_id = 1,
2326 	.max_entries = 4,
2327 	.btf_load_err = true,
2328 	.err_str = "Invalid name",
2329 },
2330 {
2331 	.descr = "arraymap invalid btf key (a bit field)",
2332 	.raw_types = {
2333 		/* int */				/* [1] */
2334 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
2335 		/* 32 bit int with 32 bit offset */	/* [2] */
2336 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 32, 32, 8),
2337 		BTF_END_RAW,
2338 	},
2339 	.str_sec = "",
2340 	.str_sec_size = sizeof(""),
2341 	.map_type = BPF_MAP_TYPE_ARRAY,
2342 	.map_name = "array_map_check_btf",
2343 	.key_size = sizeof(int),
2344 	.value_size = sizeof(int),
2345 	.key_type_id = 2,
2346 	.value_type_id = 1,
2347 	.max_entries = 4,
2348 	.map_create_err = true,
2349 },
2350 
2351 {
2352 	.descr = "arraymap invalid btf key (!= 32 bits)",
2353 	.raw_types = {
2354 		/* int */				/* [1] */
2355 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
2356 		/* 16 bit int with 0 bit offset */	/* [2] */
2357 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 16, 2),
2358 		BTF_END_RAW,
2359 	},
2360 	.str_sec = "",
2361 	.str_sec_size = sizeof(""),
2362 	.map_type = BPF_MAP_TYPE_ARRAY,
2363 	.map_name = "array_map_check_btf",
2364 	.key_size = sizeof(int),
2365 	.value_size = sizeof(int),
2366 	.key_type_id = 2,
2367 	.value_type_id = 1,
2368 	.max_entries = 4,
2369 	.map_create_err = true,
2370 },
2371 
2372 {
2373 	.descr = "arraymap invalid btf value (too small)",
2374 	.raw_types = {
2375 		/* int */				/* [1] */
2376 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
2377 		BTF_END_RAW,
2378 	},
2379 	.str_sec = "",
2380 	.str_sec_size = sizeof(""),
2381 	.map_type = BPF_MAP_TYPE_ARRAY,
2382 	.map_name = "array_map_check_btf",
2383 	.key_size = sizeof(int),
2384 	/* btf_value_size < map->value_size */
2385 	.value_size = sizeof(__u64),
2386 	.key_type_id = 1,
2387 	.value_type_id = 1,
2388 	.max_entries = 4,
2389 	.map_create_err = true,
2390 },
2391 
2392 {
2393 	.descr = "arraymap invalid btf value (too big)",
2394 	.raw_types = {
2395 		/* int */				/* [1] */
2396 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
2397 		BTF_END_RAW,
2398 	},
2399 	.str_sec = "",
2400 	.str_sec_size = sizeof(""),
2401 	.map_type = BPF_MAP_TYPE_ARRAY,
2402 	.map_name = "array_map_check_btf",
2403 	.key_size = sizeof(int),
2404 	/* btf_value_size > map->value_size */
2405 	.value_size = sizeof(__u16),
2406 	.key_type_id = 1,
2407 	.value_type_id = 1,
2408 	.max_entries = 4,
2409 	.map_create_err = true,
2410 },
2411 
2412 {
2413 	.descr = "func proto (int (*)(int, unsigned int))",
2414 	.raw_types = {
2415 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2416 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2417 		/* int (*)(int, unsigned int) */
2418 		BTF_FUNC_PROTO_ENC(1, 2),			/* [3] */
2419 			BTF_FUNC_PROTO_ARG_ENC(0, 1),
2420 			BTF_FUNC_PROTO_ARG_ENC(0, 2),
2421 		BTF_END_RAW,
2422 	},
2423 	.str_sec = "",
2424 	.str_sec_size = sizeof(""),
2425 	.map_type = BPF_MAP_TYPE_ARRAY,
2426 	.map_name = "func_proto_type_check_btf",
2427 	.key_size = sizeof(int),
2428 	.value_size = sizeof(int),
2429 	.key_type_id = 1,
2430 	.value_type_id = 1,
2431 	.max_entries = 4,
2432 },
2433 
2434 {
2435 	.descr = "func proto (vararg)",
2436 	.raw_types = {
2437 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2438 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2439 		/* void (*)(int, unsigned int, ...) */
2440 		BTF_FUNC_PROTO_ENC(0, 3),			/* [3] */
2441 			BTF_FUNC_PROTO_ARG_ENC(0, 1),
2442 			BTF_FUNC_PROTO_ARG_ENC(0, 2),
2443 			BTF_FUNC_PROTO_ARG_ENC(0, 0),
2444 		BTF_END_RAW,
2445 	},
2446 	.str_sec = "",
2447 	.str_sec_size = sizeof(""),
2448 	.map_type = BPF_MAP_TYPE_ARRAY,
2449 	.map_name = "func_proto_type_check_btf",
2450 	.key_size = sizeof(int),
2451 	.value_size = sizeof(int),
2452 	.key_type_id = 1,
2453 	.value_type_id = 1,
2454 	.max_entries = 4,
2455 },
2456 
2457 {
2458 	.descr = "func proto (vararg with name)",
2459 	.raw_types = {
2460 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2461 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2462 		/* void (*)(int a, unsigned int b, ... c) */
2463 		BTF_FUNC_PROTO_ENC(0, 3),			/* [3] */
2464 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2465 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2466 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 0),
2467 		BTF_END_RAW,
2468 	},
2469 	.str_sec = "\0a\0b\0c",
2470 	.str_sec_size = sizeof("\0a\0b\0c"),
2471 	.map_type = BPF_MAP_TYPE_ARRAY,
2472 	.map_name = "func_proto_type_check_btf",
2473 	.key_size = sizeof(int),
2474 	.value_size = sizeof(int),
2475 	.key_type_id = 1,
2476 	.value_type_id = 1,
2477 	.max_entries = 4,
2478 	.btf_load_err = true,
2479 	.err_str = "Invalid arg#3",
2480 },
2481 
2482 {
2483 	.descr = "func proto (arg after vararg)",
2484 	.raw_types = {
2485 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2486 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2487 		/* void (*)(int a, ..., unsigned int b) */
2488 		BTF_FUNC_PROTO_ENC(0, 3),			/* [3] */
2489 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2490 			BTF_FUNC_PROTO_ARG_ENC(0, 0),
2491 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2492 		BTF_END_RAW,
2493 	},
2494 	.str_sec = "\0a\0b",
2495 	.str_sec_size = sizeof("\0a\0b"),
2496 	.map_type = BPF_MAP_TYPE_ARRAY,
2497 	.map_name = "func_proto_type_check_btf",
2498 	.key_size = sizeof(int),
2499 	.value_size = sizeof(int),
2500 	.key_type_id = 1,
2501 	.value_type_id = 1,
2502 	.max_entries = 4,
2503 	.btf_load_err = true,
2504 	.err_str = "Invalid arg#2",
2505 },
2506 
2507 {
2508 	.descr = "func proto (CONST=>TYPEDEF=>PTR=>FUNC_PROTO)",
2509 	.raw_types = {
2510 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2511 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2512 		/* typedef void (*func_ptr)(int, unsigned int) */
2513 		BTF_TYPEDEF_ENC(NAME_TBD, 5),			/* [3] */
2514 		/* const func_ptr */
2515 		BTF_CONST_ENC(3),				/* [4] */
2516 		BTF_PTR_ENC(6),					/* [5] */
2517 		BTF_FUNC_PROTO_ENC(0, 2),			/* [6] */
2518 			BTF_FUNC_PROTO_ARG_ENC(0, 1),
2519 			BTF_FUNC_PROTO_ARG_ENC(0, 2),
2520 		BTF_END_RAW,
2521 	},
2522 	.str_sec = "\0func_ptr",
2523 	.str_sec_size = sizeof("\0func_ptr"),
2524 	.map_type = BPF_MAP_TYPE_ARRAY,
2525 	.map_name = "func_proto_type_check_btf",
2526 	.key_size = sizeof(int),
2527 	.value_size = sizeof(int),
2528 	.key_type_id = 1,
2529 	.value_type_id = 1,
2530 	.max_entries = 4,
2531 },
2532 
2533 {
2534 	.descr = "func proto (TYPEDEF=>FUNC_PROTO)",
2535 	.raw_types = {
2536 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2537 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2538 		BTF_TYPEDEF_ENC(NAME_TBD, 4),			/* [3] */
2539 		BTF_FUNC_PROTO_ENC(0, 2),			/* [4] */
2540 			BTF_FUNC_PROTO_ARG_ENC(0, 1),
2541 			BTF_FUNC_PROTO_ARG_ENC(0, 2),
2542 		BTF_END_RAW,
2543 	},
2544 	.str_sec = "\0func_typedef",
2545 	.str_sec_size = sizeof("\0func_typedef"),
2546 	.map_type = BPF_MAP_TYPE_ARRAY,
2547 	.map_name = "func_proto_type_check_btf",
2548 	.key_size = sizeof(int),
2549 	.value_size = sizeof(int),
2550 	.key_type_id = 1,
2551 	.value_type_id = 1,
2552 	.max_entries = 4,
2553 },
2554 
2555 {
2556 	.descr = "func proto (btf_resolve(arg))",
2557 	.raw_types = {
2558 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2559 		/* void (*)(const void *) */
2560 		BTF_FUNC_PROTO_ENC(0, 1),			/* [2] */
2561 			BTF_FUNC_PROTO_ARG_ENC(0, 3),
2562 		BTF_CONST_ENC(4),				/* [3] */
2563 		BTF_PTR_ENC(0),					/* [4] */
2564 		BTF_END_RAW,
2565 	},
2566 	.str_sec = "",
2567 	.str_sec_size = sizeof(""),
2568 	.map_type = BPF_MAP_TYPE_ARRAY,
2569 	.map_name = "func_proto_type_check_btf",
2570 	.key_size = sizeof(int),
2571 	.value_size = sizeof(int),
2572 	.key_type_id = 1,
2573 	.value_type_id = 1,
2574 	.max_entries = 4,
2575 },
2576 
2577 {
2578 	.descr = "func proto (Not all arg has name)",
2579 	.raw_types = {
2580 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2581 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2582 		/* void (*)(int, unsigned int b) */
2583 		BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
2584 			BTF_FUNC_PROTO_ARG_ENC(0, 1),
2585 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2586 		BTF_END_RAW,
2587 	},
2588 	.str_sec = "\0b",
2589 	.str_sec_size = sizeof("\0b"),
2590 	.map_type = BPF_MAP_TYPE_ARRAY,
2591 	.map_name = "func_proto_type_check_btf",
2592 	.key_size = sizeof(int),
2593 	.value_size = sizeof(int),
2594 	.key_type_id = 1,
2595 	.value_type_id = 1,
2596 	.max_entries = 4,
2597 },
2598 
2599 {
2600 	.descr = "func proto (Bad arg name_off)",
2601 	.raw_types = {
2602 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2603 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2604 		/* void (*)(int a, unsigned int <bad_name_off>) */
2605 		BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
2606 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2607 			BTF_FUNC_PROTO_ARG_ENC(0x0fffffff, 2),
2608 		BTF_END_RAW,
2609 	},
2610 	.str_sec = "\0a",
2611 	.str_sec_size = sizeof("\0a"),
2612 	.map_type = BPF_MAP_TYPE_ARRAY,
2613 	.map_name = "func_proto_type_check_btf",
2614 	.key_size = sizeof(int),
2615 	.value_size = sizeof(int),
2616 	.key_type_id = 1,
2617 	.value_type_id = 1,
2618 	.max_entries = 4,
2619 	.btf_load_err = true,
2620 	.err_str = "Invalid arg#2",
2621 },
2622 
2623 {
2624 	.descr = "func proto (Bad arg name)",
2625 	.raw_types = {
2626 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2627 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2628 		/* void (*)(int a, unsigned int !!!) */
2629 		BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
2630 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2631 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2632 		BTF_END_RAW,
2633 	},
2634 	.str_sec = "\0a\0!!!",
2635 	.str_sec_size = sizeof("\0a\0!!!"),
2636 	.map_type = BPF_MAP_TYPE_ARRAY,
2637 	.map_name = "func_proto_type_check_btf",
2638 	.key_size = sizeof(int),
2639 	.value_size = sizeof(int),
2640 	.key_type_id = 1,
2641 	.value_type_id = 1,
2642 	.max_entries = 4,
2643 	.btf_load_err = true,
2644 	.err_str = "Invalid arg#2",
2645 },
2646 
2647 {
2648 	.descr = "func proto (Invalid return type)",
2649 	.raw_types = {
2650 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2651 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2652 		/* <bad_ret_type> (*)(int, unsigned int) */
2653 		BTF_FUNC_PROTO_ENC(100, 2),			/* [3] */
2654 			BTF_FUNC_PROTO_ARG_ENC(0, 1),
2655 			BTF_FUNC_PROTO_ARG_ENC(0, 2),
2656 		BTF_END_RAW,
2657 	},
2658 	.str_sec = "",
2659 	.str_sec_size = sizeof(""),
2660 	.map_type = BPF_MAP_TYPE_ARRAY,
2661 	.map_name = "func_proto_type_check_btf",
2662 	.key_size = sizeof(int),
2663 	.value_size = sizeof(int),
2664 	.key_type_id = 1,
2665 	.value_type_id = 1,
2666 	.max_entries = 4,
2667 	.btf_load_err = true,
2668 	.err_str = "Invalid return type",
2669 },
2670 
2671 {
2672 	.descr = "func proto (with func name)",
2673 	.raw_types = {
2674 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2675 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2676 		/* void func_proto(int, unsigned int) */
2677 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 2), 0),	/* [3] */
2678 			BTF_FUNC_PROTO_ARG_ENC(0, 1),
2679 			BTF_FUNC_PROTO_ARG_ENC(0, 2),
2680 		BTF_END_RAW,
2681 	},
2682 	.str_sec = "\0func_proto",
2683 	.str_sec_size = sizeof("\0func_proto"),
2684 	.map_type = BPF_MAP_TYPE_ARRAY,
2685 	.map_name = "func_proto_type_check_btf",
2686 	.key_size = sizeof(int),
2687 	.value_size = sizeof(int),
2688 	.key_type_id = 1,
2689 	.value_type_id = 1,
2690 	.max_entries = 4,
2691 	.btf_load_err = true,
2692 	.err_str = "Invalid name",
2693 },
2694 
2695 {
2696 	.descr = "func proto (const void arg)",
2697 	.raw_types = {
2698 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2699 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2700 		/* void (*)(const void) */
2701 		BTF_FUNC_PROTO_ENC(0, 1),			/* [3] */
2702 			BTF_FUNC_PROTO_ARG_ENC(0, 4),
2703 		BTF_CONST_ENC(0),				/* [4] */
2704 		BTF_END_RAW,
2705 	},
2706 	.str_sec = "",
2707 	.str_sec_size = sizeof(""),
2708 	.map_type = BPF_MAP_TYPE_ARRAY,
2709 	.map_name = "func_proto_type_check_btf",
2710 	.key_size = sizeof(int),
2711 	.value_size = sizeof(int),
2712 	.key_type_id = 1,
2713 	.value_type_id = 1,
2714 	.max_entries = 4,
2715 	.btf_load_err = true,
2716 	.err_str = "Invalid arg#1",
2717 },
2718 
2719 {
2720 	.descr = "func (void func(int a, unsigned int b))",
2721 	.raw_types = {
2722 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2723 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2724 		/* void (*)(int a, unsigned int b) */
2725 		BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
2726 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2727 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2728 		/* void func(int a, unsigned int b) */
2729 		BTF_FUNC_ENC(NAME_TBD, 3),			/* [4] */
2730 		BTF_END_RAW,
2731 	},
2732 	.str_sec = "\0a\0b\0func",
2733 	.str_sec_size = sizeof("\0a\0b\0func"),
2734 	.map_type = BPF_MAP_TYPE_ARRAY,
2735 	.map_name = "func_type_check_btf",
2736 	.key_size = sizeof(int),
2737 	.value_size = sizeof(int),
2738 	.key_type_id = 1,
2739 	.value_type_id = 1,
2740 	.max_entries = 4,
2741 },
2742 
2743 {
2744 	.descr = "func (No func name)",
2745 	.raw_types = {
2746 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2747 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2748 		/* void (*)(int a, unsigned int b) */
2749 		BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
2750 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2751 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2752 		/* void <no_name>(int a, unsigned int b) */
2753 		BTF_FUNC_ENC(0, 3),				/* [4] */
2754 		BTF_END_RAW,
2755 	},
2756 	.str_sec = "\0a\0b",
2757 	.str_sec_size = sizeof("\0a\0b"),
2758 	.map_type = BPF_MAP_TYPE_ARRAY,
2759 	.map_name = "func_type_check_btf",
2760 	.key_size = sizeof(int),
2761 	.value_size = sizeof(int),
2762 	.key_type_id = 1,
2763 	.value_type_id = 1,
2764 	.max_entries = 4,
2765 	.btf_load_err = true,
2766 	.err_str = "Invalid name",
2767 },
2768 
2769 {
2770 	.descr = "func (Invalid func name)",
2771 	.raw_types = {
2772 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2773 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2774 		/* void (*)(int a, unsigned int b) */
2775 		BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
2776 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2777 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2778 		/* void !!!(int a, unsigned int b) */
2779 		BTF_FUNC_ENC(NAME_TBD, 3),			/* [4] */
2780 		BTF_END_RAW,
2781 	},
2782 	.str_sec = "\0a\0b\0!!!",
2783 	.str_sec_size = sizeof("\0a\0b\0!!!"),
2784 	.map_type = BPF_MAP_TYPE_ARRAY,
2785 	.map_name = "func_type_check_btf",
2786 	.key_size = sizeof(int),
2787 	.value_size = sizeof(int),
2788 	.key_type_id = 1,
2789 	.value_type_id = 1,
2790 	.max_entries = 4,
2791 	.btf_load_err = true,
2792 	.err_str = "Invalid name",
2793 },
2794 
2795 {
2796 	.descr = "func (Some arg has no name)",
2797 	.raw_types = {
2798 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2799 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2800 		/* void (*)(int a, unsigned int) */
2801 		BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
2802 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2803 			BTF_FUNC_PROTO_ARG_ENC(0, 2),
2804 		/* void func(int a, unsigned int) */
2805 		BTF_FUNC_ENC(NAME_TBD, 3),			/* [4] */
2806 		BTF_END_RAW,
2807 	},
2808 	.str_sec = "\0a\0func",
2809 	.str_sec_size = sizeof("\0a\0func"),
2810 	.map_type = BPF_MAP_TYPE_ARRAY,
2811 	.map_name = "func_type_check_btf",
2812 	.key_size = sizeof(int),
2813 	.value_size = sizeof(int),
2814 	.key_type_id = 1,
2815 	.value_type_id = 1,
2816 	.max_entries = 4,
2817 	.btf_load_err = true,
2818 	.err_str = "Invalid arg#2",
2819 },
2820 
2821 {
2822 	.descr = "func (Non zero vlen)",
2823 	.raw_types = {
2824 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2825 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),		/* [2] */
2826 		/* void (*)(int a, unsigned int b) */
2827 		BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
2828 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2829 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2830 		/* void func(int a, unsigned int b) */
2831 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC, 0, 2), 3), 	/* [4] */
2832 		BTF_END_RAW,
2833 	},
2834 	.str_sec = "\0a\0b\0func",
2835 	.str_sec_size = sizeof("\0a\0b\0func"),
2836 	.map_type = BPF_MAP_TYPE_ARRAY,
2837 	.map_name = "func_type_check_btf",
2838 	.key_size = sizeof(int),
2839 	.value_size = sizeof(int),
2840 	.key_type_id = 1,
2841 	.value_type_id = 1,
2842 	.max_entries = 4,
2843 	.btf_load_err = true,
2844 	.err_str = "Invalid func linkage",
2845 },
2846 
2847 {
2848 	.descr = "func (Not referring to FUNC_PROTO)",
2849 	.raw_types = {
2850 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
2851 		BTF_FUNC_ENC(NAME_TBD, 1),			/* [2] */
2852 		BTF_END_RAW,
2853 	},
2854 	.str_sec = "\0func",
2855 	.str_sec_size = sizeof("\0func"),
2856 	.map_type = BPF_MAP_TYPE_ARRAY,
2857 	.map_name = "func_type_check_btf",
2858 	.key_size = sizeof(int),
2859 	.value_size = sizeof(int),
2860 	.key_type_id = 1,
2861 	.value_type_id = 1,
2862 	.max_entries = 4,
2863 	.btf_load_err = true,
2864 	.err_str = "Invalid type_id",
2865 },
2866 
2867 {
2868 	.descr = "invalid int kind_flag",
2869 	.raw_types = {
2870 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2871 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_INT, 1, 0), 4),	/* [2] */
2872 		BTF_INT_ENC(0, 0, 32),
2873 		BTF_END_RAW,
2874 	},
2875 	BTF_STR_SEC(""),
2876 	.map_type = BPF_MAP_TYPE_ARRAY,
2877 	.map_name = "int_type_check_btf",
2878 	.key_size = sizeof(int),
2879 	.value_size = sizeof(int),
2880 	.key_type_id = 1,
2881 	.value_type_id = 1,
2882 	.max_entries = 4,
2883 	.btf_load_err = true,
2884 	.err_str = "Invalid btf_info kind_flag",
2885 },
2886 
2887 {
2888 	.descr = "invalid ptr kind_flag",
2889 	.raw_types = {
2890 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2891 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 1, 0), 1),	/* [2] */
2892 		BTF_END_RAW,
2893 	},
2894 	BTF_STR_SEC(""),
2895 	.map_type = BPF_MAP_TYPE_ARRAY,
2896 	.map_name = "ptr_type_check_btf",
2897 	.key_size = sizeof(int),
2898 	.value_size = sizeof(int),
2899 	.key_type_id = 1,
2900 	.value_type_id = 1,
2901 	.max_entries = 4,
2902 	.btf_load_err = true,
2903 	.err_str = "Invalid btf_info kind_flag",
2904 },
2905 
2906 {
2907 	.descr = "invalid array kind_flag",
2908 	.raw_types = {
2909 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2910 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 1, 0), 0),	/* [2] */
2911 		BTF_ARRAY_ENC(1, 1, 1),
2912 		BTF_END_RAW,
2913 	},
2914 	BTF_STR_SEC(""),
2915 	.map_type = BPF_MAP_TYPE_ARRAY,
2916 	.map_name = "array_type_check_btf",
2917 	.key_size = sizeof(int),
2918 	.value_size = sizeof(int),
2919 	.key_type_id = 1,
2920 	.value_type_id = 1,
2921 	.max_entries = 4,
2922 	.btf_load_err = true,
2923 	.err_str = "Invalid btf_info kind_flag",
2924 },
2925 
2926 {
2927 	.descr = "valid fwd kind_flag",
2928 	.raw_types = {
2929 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2930 		BTF_TYPE_ENC(NAME_TBD,
2931 			     BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0),	/* [2] */
2932 		BTF_END_RAW,
2933 	},
2934 	BTF_STR_SEC("\0A"),
2935 	.map_type = BPF_MAP_TYPE_ARRAY,
2936 	.map_name = "fwd_type_check_btf",
2937 	.key_size = sizeof(int),
2938 	.value_size = sizeof(int),
2939 	.key_type_id = 1,
2940 	.value_type_id = 1,
2941 	.max_entries = 4,
2942 },
2943 
2944 {
2945 	.descr = "invalid typedef kind_flag",
2946 	.raw_types = {
2947 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2948 		BTF_TYPE_ENC(NAME_TBD,
2949 			     BTF_INFO_ENC(BTF_KIND_TYPEDEF, 1, 0), 1),	/* [2] */
2950 		BTF_END_RAW,
2951 	},
2952 	BTF_STR_SEC("\0A"),
2953 	.map_type = BPF_MAP_TYPE_ARRAY,
2954 	.map_name = "typedef_type_check_btf",
2955 	.key_size = sizeof(int),
2956 	.value_size = sizeof(int),
2957 	.key_type_id = 1,
2958 	.value_type_id = 1,
2959 	.max_entries = 4,
2960 	.btf_load_err = true,
2961 	.err_str = "Invalid btf_info kind_flag",
2962 },
2963 
2964 {
2965 	.descr = "invalid volatile kind_flag",
2966 	.raw_types = {
2967 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
2968 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_VOLATILE, 1, 0), 1),	/* [2] */
2969 		BTF_END_RAW,
2970 	},
2971 	BTF_STR_SEC(""),
2972 	.map_type = BPF_MAP_TYPE_ARRAY,
2973 	.map_name = "volatile_type_check_btf",
2974 	.key_size = sizeof(int),
2975 	.value_size = sizeof(int),
2976 	.key_type_id = 1,
2977 	.value_type_id = 1,
2978 	.max_entries = 4,
2979 	.btf_load_err = true,
2980 	.err_str = "Invalid btf_info kind_flag",
2981 },
2982 
2983 {
2984 	.descr = "invalid const kind_flag",
2985 	.raw_types = {
2986 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
2987 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 1, 0), 1),	/* [2] */
2988 		BTF_END_RAW,
2989 	},
2990 	BTF_STR_SEC(""),
2991 	.map_type = BPF_MAP_TYPE_ARRAY,
2992 	.map_name = "const_type_check_btf",
2993 	.key_size = sizeof(int),
2994 	.value_size = sizeof(int),
2995 	.key_type_id = 1,
2996 	.value_type_id = 1,
2997 	.max_entries = 4,
2998 	.btf_load_err = true,
2999 	.err_str = "Invalid btf_info kind_flag",
3000 },
3001 
3002 {
3003 	.descr = "invalid restrict kind_flag",
3004 	.raw_types = {
3005 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3006 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_RESTRICT, 1, 0), 1),	/* [2] */
3007 		BTF_END_RAW,
3008 	},
3009 	BTF_STR_SEC(""),
3010 	.map_type = BPF_MAP_TYPE_ARRAY,
3011 	.map_name = "restrict_type_check_btf",
3012 	.key_size = sizeof(int),
3013 	.value_size = sizeof(int),
3014 	.key_type_id = 1,
3015 	.value_type_id = 1,
3016 	.max_entries = 4,
3017 	.btf_load_err = true,
3018 	.err_str = "Invalid btf_info kind_flag",
3019 },
3020 
3021 {
3022 	.descr = "invalid func kind_flag",
3023 	.raw_types = {
3024 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3025 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 0), 0),	/* [2] */
3026 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC, 1, 0), 2),	/* [3] */
3027 		BTF_END_RAW,
3028 	},
3029 	BTF_STR_SEC("\0A"),
3030 	.map_type = BPF_MAP_TYPE_ARRAY,
3031 	.map_name = "func_type_check_btf",
3032 	.key_size = sizeof(int),
3033 	.value_size = sizeof(int),
3034 	.key_type_id = 1,
3035 	.value_type_id = 1,
3036 	.max_entries = 4,
3037 	.btf_load_err = true,
3038 	.err_str = "Invalid btf_info kind_flag",
3039 },
3040 
3041 {
3042 	.descr = "invalid func_proto kind_flag",
3043 	.raw_types = {
3044 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3045 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 1, 0), 0),	/* [2] */
3046 		BTF_END_RAW,
3047 	},
3048 	BTF_STR_SEC(""),
3049 	.map_type = BPF_MAP_TYPE_ARRAY,
3050 	.map_name = "func_proto_type_check_btf",
3051 	.key_size = sizeof(int),
3052 	.value_size = sizeof(int),
3053 	.key_type_id = 1,
3054 	.value_type_id = 1,
3055 	.max_entries = 4,
3056 	.btf_load_err = true,
3057 	.err_str = "Invalid btf_info kind_flag",
3058 },
3059 
3060 {
3061 	.descr = "valid struct, kind_flag, bitfield_size = 0",
3062 	.raw_types = {
3063 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3064 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 8),	/* [2] */
3065 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(0, 0)),
3066 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(0, 32)),
3067 		BTF_END_RAW,
3068 	},
3069 	BTF_STR_SEC("\0A\0B"),
3070 	.map_type = BPF_MAP_TYPE_ARRAY,
3071 	.map_name = "struct_type_check_btf",
3072 	.key_size = sizeof(int),
3073 	.value_size = sizeof(int),
3074 	.key_type_id = 1,
3075 	.value_type_id = 1,
3076 	.max_entries = 4,
3077 },
3078 
3079 {
3080 	.descr = "valid struct, kind_flag, int member, bitfield_size != 0",
3081 	.raw_types = {
3082 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3083 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),	/* [2] */
3084 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
3085 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 4)),
3086 		BTF_END_RAW,
3087 	},
3088 	BTF_STR_SEC("\0A\0B"),
3089 	.map_type = BPF_MAP_TYPE_ARRAY,
3090 	.map_name = "struct_type_check_btf",
3091 	.key_size = sizeof(int),
3092 	.value_size = sizeof(int),
3093 	.key_type_id = 1,
3094 	.value_type_id = 1,
3095 	.max_entries = 4,
3096 },
3097 
3098 {
3099 	.descr = "valid union, kind_flag, int member, bitfield_size != 0",
3100 	.raw_types = {
3101 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
3102 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4),	/* [2] */
3103 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
3104 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
3105 		BTF_END_RAW,
3106 	},
3107 	BTF_STR_SEC("\0A\0B"),
3108 	.map_type = BPF_MAP_TYPE_ARRAY,
3109 	.map_name = "union_type_check_btf",
3110 	.key_size = sizeof(int),
3111 	.value_size = sizeof(int),
3112 	.key_type_id = 1,
3113 	.value_type_id = 1,
3114 	.max_entries = 4,
3115 },
3116 
3117 {
3118 	.descr = "valid struct, kind_flag, enum member, bitfield_size != 0",
3119 	.raw_types = {
3120 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
3121 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),	/* [2] */
3122 		BTF_ENUM_ENC(NAME_TBD, 0),
3123 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),/* [3] */
3124 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
3125 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 4)),
3126 		BTF_END_RAW,
3127 	},
3128 	BTF_STR_SEC("\0A\0B\0C"),
3129 	.map_type = BPF_MAP_TYPE_ARRAY,
3130 	.map_name = "struct_type_check_btf",
3131 	.key_size = sizeof(int),
3132 	.value_size = sizeof(int),
3133 	.key_type_id = 1,
3134 	.value_type_id = 1,
3135 	.max_entries = 4,
3136 },
3137 
3138 {
3139 	.descr = "valid union, kind_flag, enum member, bitfield_size != 0",
3140 	.raw_types = {
3141 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
3142 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),	/* [2] */
3143 		BTF_ENUM_ENC(NAME_TBD, 0),
3144 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4),	/* [3] */
3145 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
3146 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
3147 		BTF_END_RAW,
3148 	},
3149 	BTF_STR_SEC("\0A\0B\0C"),
3150 	.map_type = BPF_MAP_TYPE_ARRAY,
3151 	.map_name = "union_type_check_btf",
3152 	.key_size = sizeof(int),
3153 	.value_size = sizeof(int),
3154 	.key_type_id = 1,
3155 	.value_type_id = 1,
3156 	.max_entries = 4,
3157 },
3158 
3159 {
3160 	.descr = "valid struct, kind_flag, typedef member, bitfield_size != 0",
3161 	.raw_types = {
3162 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
3163 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),	/* [2] */
3164 		BTF_ENUM_ENC(NAME_TBD, 0),
3165 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),/* [3] */
3166 		BTF_MEMBER_ENC(NAME_TBD, 4, BTF_MEMBER_OFFSET(4, 0)),
3167 		BTF_MEMBER_ENC(NAME_TBD, 5, BTF_MEMBER_OFFSET(4, 4)),
3168 		BTF_TYPEDEF_ENC(NAME_TBD, 1),				/* [4] */
3169 		BTF_TYPEDEF_ENC(NAME_TBD, 2),				/* [5] */
3170 		BTF_END_RAW,
3171 	},
3172 	BTF_STR_SEC("\0A\0B\0C\0D\0E"),
3173 	.map_type = BPF_MAP_TYPE_ARRAY,
3174 	.map_name = "struct_type_check_btf",
3175 	.key_size = sizeof(int),
3176 	.value_size = sizeof(int),
3177 	.key_type_id = 1,
3178 	.value_type_id = 1,
3179 	.max_entries = 4,
3180 },
3181 
3182 {
3183 	.descr = "valid union, kind_flag, typedef member, bitfield_size != 0",
3184 	.raw_types = {
3185 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
3186 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),	/* [2] */
3187 		BTF_ENUM_ENC(NAME_TBD, 0),
3188 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4),	/* [3] */
3189 		BTF_MEMBER_ENC(NAME_TBD, 4, BTF_MEMBER_OFFSET(4, 0)),
3190 		BTF_MEMBER_ENC(NAME_TBD, 5, BTF_MEMBER_OFFSET(4, 0)),
3191 		BTF_TYPEDEF_ENC(NAME_TBD, 1),				/* [4] */
3192 		BTF_TYPEDEF_ENC(NAME_TBD, 2),				/* [5] */
3193 		BTF_END_RAW,
3194 	},
3195 	BTF_STR_SEC("\0A\0B\0C\0D\0E"),
3196 	.map_type = BPF_MAP_TYPE_ARRAY,
3197 	.map_name = "union_type_check_btf",
3198 	.key_size = sizeof(int),
3199 	.value_size = sizeof(int),
3200 	.key_type_id = 1,
3201 	.value_type_id = 1,
3202 	.max_entries = 4,
3203 },
3204 
3205 {
3206 	.descr = "invalid struct, kind_flag, bitfield_size greater than struct size",
3207 	.raw_types = {
3208 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3209 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),	/* [2] */
3210 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 0)),
3211 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 20)),
3212 		BTF_END_RAW,
3213 	},
3214 	BTF_STR_SEC("\0A\0B"),
3215 	.map_type = BPF_MAP_TYPE_ARRAY,
3216 	.map_name = "struct_type_check_btf",
3217 	.key_size = sizeof(int),
3218 	.value_size = sizeof(int),
3219 	.key_type_id = 1,
3220 	.value_type_id = 1,
3221 	.max_entries = 4,
3222 	.btf_load_err = true,
3223 	.err_str = "Member exceeds struct_size",
3224 },
3225 
3226 {
3227 	.descr = "invalid struct, kind_flag, bitfield base_type int not regular",
3228 	.raw_types = {
3229 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3230 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 20, 4),			/* [2] */
3231 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),	/* [3] */
3232 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(20, 0)),
3233 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(20, 20)),
3234 		BTF_END_RAW,
3235 	},
3236 	BTF_STR_SEC("\0A\0B"),
3237 	.map_type = BPF_MAP_TYPE_ARRAY,
3238 	.map_name = "struct_type_check_btf",
3239 	.key_size = sizeof(int),
3240 	.value_size = sizeof(int),
3241 	.key_type_id = 1,
3242 	.value_type_id = 1,
3243 	.max_entries = 4,
3244 	.btf_load_err = true,
3245 	.err_str = "Invalid member base type",
3246 },
3247 
3248 {
3249 	.descr = "invalid struct, kind_flag, base_type int not regular",
3250 	.raw_types = {
3251 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3252 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 12, 4),			/* [2] */
3253 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),	/* [3] */
3254 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(8, 0)),
3255 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(8, 8)),
3256 		BTF_END_RAW,
3257 	},
3258 	BTF_STR_SEC("\0A\0B"),
3259 	.map_type = BPF_MAP_TYPE_ARRAY,
3260 	.map_name = "struct_type_check_btf",
3261 	.key_size = sizeof(int),
3262 	.value_size = sizeof(int),
3263 	.key_type_id = 1,
3264 	.value_type_id = 1,
3265 	.max_entries = 4,
3266 	.btf_load_err = true,
3267 	.err_str = "Invalid member base type",
3268 },
3269 
3270 {
3271 	.descr = "invalid union, kind_flag, bitfield_size greater than struct size",
3272 	.raw_types = {
3273 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
3274 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 2),	/* [2] */
3275 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(8, 0)),
3276 		BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 0)),
3277 		BTF_END_RAW,
3278 	},
3279 	BTF_STR_SEC("\0A\0B"),
3280 	.map_type = BPF_MAP_TYPE_ARRAY,
3281 	.map_name = "union_type_check_btf",
3282 	.key_size = sizeof(int),
3283 	.value_size = sizeof(int),
3284 	.key_type_id = 1,
3285 	.value_type_id = 1,
3286 	.max_entries = 4,
3287 	.btf_load_err = true,
3288 	.err_str = "Member exceeds struct_size",
3289 },
3290 
3291 {
3292 	.descr = "invalid struct, kind_flag, int member, bitfield_size = 0, wrong byte alignment",
3293 	.raw_types = {
3294 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3295 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [2] */
3296 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 12),	/* [3] */
3297 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
3298 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 36)),
3299 		BTF_END_RAW,
3300 	},
3301 	BTF_STR_SEC("\0A\0B"),
3302 	.map_type = BPF_MAP_TYPE_ARRAY,
3303 	.map_name = "struct_type_check_btf",
3304 	.key_size = sizeof(int),
3305 	.value_size = sizeof(int),
3306 	.key_type_id = 1,
3307 	.value_type_id = 1,
3308 	.max_entries = 4,
3309 	.btf_load_err = true,
3310 	.err_str = "Invalid member offset",
3311 },
3312 
3313 {
3314 	.descr = "invalid struct, kind_flag, enum member, bitfield_size = 0, wrong byte alignment",
3315 	.raw_types = {
3316 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3317 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [2] */
3318 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),	/* [2] */
3319 		BTF_ENUM_ENC(NAME_TBD, 0),
3320 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 12),	/* [3] */
3321 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
3322 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 36)),
3323 		BTF_END_RAW,
3324 	},
3325 	BTF_STR_SEC("\0A\0B\0C"),
3326 	.map_type = BPF_MAP_TYPE_ARRAY,
3327 	.map_name = "struct_type_check_btf",
3328 	.key_size = sizeof(int),
3329 	.value_size = sizeof(int),
3330 	.key_type_id = 1,
3331 	.value_type_id = 1,
3332 	.max_entries = 4,
3333 	.btf_load_err = true,
3334 	.err_str = "Invalid member offset",
3335 },
3336 
3337 {
3338 	.descr = "128-bit int",
3339 	.raw_types = {
3340 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3341 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16),		/* [2] */
3342 		BTF_END_RAW,
3343 	},
3344 	BTF_STR_SEC("\0A"),
3345 	.map_type = BPF_MAP_TYPE_ARRAY,
3346 	.map_name = "int_type_check_btf",
3347 	.key_size = sizeof(int),
3348 	.value_size = sizeof(int),
3349 	.key_type_id = 1,
3350 	.value_type_id = 1,
3351 	.max_entries = 4,
3352 },
3353 
3354 {
3355 	.descr = "struct, 128-bit int member",
3356 	.raw_types = {
3357 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3358 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16),		/* [2] */
3359 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 16),	/* [3] */
3360 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3361 		BTF_END_RAW,
3362 	},
3363 	BTF_STR_SEC("\0A"),
3364 	.map_type = BPF_MAP_TYPE_ARRAY,
3365 	.map_name = "struct_type_check_btf",
3366 	.key_size = sizeof(int),
3367 	.value_size = sizeof(int),
3368 	.key_type_id = 1,
3369 	.value_type_id = 1,
3370 	.max_entries = 4,
3371 },
3372 
3373 {
3374 	.descr = "struct, 120-bit int member bitfield",
3375 	.raw_types = {
3376 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3377 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 120, 16),		/* [2] */
3378 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 16),	/* [3] */
3379 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3380 		BTF_END_RAW,
3381 	},
3382 	BTF_STR_SEC("\0A"),
3383 	.map_type = BPF_MAP_TYPE_ARRAY,
3384 	.map_name = "struct_type_check_btf",
3385 	.key_size = sizeof(int),
3386 	.value_size = sizeof(int),
3387 	.key_type_id = 1,
3388 	.value_type_id = 1,
3389 	.max_entries = 4,
3390 },
3391 
3392 {
3393 	.descr = "struct, kind_flag, 128-bit int member",
3394 	.raw_types = {
3395 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3396 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16),		/* [2] */
3397 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 16),	/* [3] */
3398 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
3399 		BTF_END_RAW,
3400 	},
3401 	BTF_STR_SEC("\0A"),
3402 	.map_type = BPF_MAP_TYPE_ARRAY,
3403 	.map_name = "struct_type_check_btf",
3404 	.key_size = sizeof(int),
3405 	.value_size = sizeof(int),
3406 	.key_type_id = 1,
3407 	.value_type_id = 1,
3408 	.max_entries = 4,
3409 },
3410 
3411 {
3412 	.descr = "struct, kind_flag, 120-bit int member bitfield",
3413 	.raw_types = {
3414 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
3415 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16),		/* [2] */
3416 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 16),	/* [3] */
3417 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(120, 0)),
3418 		BTF_END_RAW,
3419 	},
3420 	BTF_STR_SEC("\0A"),
3421 	.map_type = BPF_MAP_TYPE_ARRAY,
3422 	.map_name = "struct_type_check_btf",
3423 	.key_size = sizeof(int),
3424 	.value_size = sizeof(int),
3425 	.key_type_id = 1,
3426 	.value_type_id = 1,
3427 	.max_entries = 4,
3428 },
3429 /*
3430  * typedef int arr_t[16];
3431  * struct s {
3432  *	arr_t *a;
3433  * };
3434  */
3435 {
3436 	.descr = "struct->ptr->typedef->array->int size resolution",
3437 	.raw_types = {
3438 		BTF_STRUCT_ENC(NAME_TBD, 1, 8),			/* [1] */
3439 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3440 		BTF_PTR_ENC(3),					/* [2] */
3441 		BTF_TYPEDEF_ENC(NAME_TBD, 4),			/* [3] */
3442 		BTF_TYPE_ARRAY_ENC(5, 5, 16),			/* [4] */
3443 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [5] */
3444 		BTF_END_RAW,
3445 	},
3446 	BTF_STR_SEC("\0s\0a\0arr_t"),
3447 	.map_type = BPF_MAP_TYPE_ARRAY,
3448 	.map_name = "ptr_mod_chain_size_resolve_map",
3449 	.key_size = sizeof(int),
3450 	.value_size = sizeof(int) * 16,
3451 	.key_type_id = 5 /* int */,
3452 	.value_type_id = 3 /* arr_t */,
3453 	.max_entries = 4,
3454 },
3455 /*
3456  * typedef int arr_t[16][8][4];
3457  * struct s {
3458  *	arr_t *a;
3459  * };
3460  */
3461 {
3462 	.descr = "struct->ptr->typedef->multi-array->int size resolution",
3463 	.raw_types = {
3464 		BTF_STRUCT_ENC(NAME_TBD, 1, 8),			/* [1] */
3465 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3466 		BTF_PTR_ENC(3),					/* [2] */
3467 		BTF_TYPEDEF_ENC(NAME_TBD, 4),			/* [3] */
3468 		BTF_TYPE_ARRAY_ENC(5, 7, 16),			/* [4] */
3469 		BTF_TYPE_ARRAY_ENC(6, 7, 8),			/* [5] */
3470 		BTF_TYPE_ARRAY_ENC(7, 7, 4),			/* [6] */
3471 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [7] */
3472 		BTF_END_RAW,
3473 	},
3474 	BTF_STR_SEC("\0s\0a\0arr_t"),
3475 	.map_type = BPF_MAP_TYPE_ARRAY,
3476 	.map_name = "multi_arr_size_resolve_map",
3477 	.key_size = sizeof(int),
3478 	.value_size = sizeof(int) * 16 * 8 * 4,
3479 	.key_type_id = 7 /* int */,
3480 	.value_type_id = 3 /* arr_t */,
3481 	.max_entries = 4,
3482 },
3483 /*
3484  * typedef int int_t;
3485  * typedef int_t arr3_t[4];
3486  * typedef arr3_t arr2_t[8];
3487  * typedef arr2_t arr1_t[16];
3488  * struct s {
3489  *	arr1_t *a;
3490  * };
3491  */
3492 {
3493 	.descr = "typedef/multi-arr mix size resolution",
3494 	.raw_types = {
3495 		BTF_STRUCT_ENC(NAME_TBD, 1, 8),			/* [1] */
3496 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3497 		BTF_PTR_ENC(3),					/* [2] */
3498 		BTF_TYPEDEF_ENC(NAME_TBD, 4),			/* [3] */
3499 		BTF_TYPE_ARRAY_ENC(5, 10, 16),			/* [4] */
3500 		BTF_TYPEDEF_ENC(NAME_TBD, 6),			/* [5] */
3501 		BTF_TYPE_ARRAY_ENC(7, 10, 8),			/* [6] */
3502 		BTF_TYPEDEF_ENC(NAME_TBD, 8),			/* [7] */
3503 		BTF_TYPE_ARRAY_ENC(9, 10, 4),			/* [8] */
3504 		BTF_TYPEDEF_ENC(NAME_TBD, 10),			/* [9] */
3505 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [10] */
3506 		BTF_END_RAW,
3507 	},
3508 	BTF_STR_SEC("\0s\0a\0arr1_t\0arr2_t\0arr3_t\0int_t"),
3509 	.map_type = BPF_MAP_TYPE_ARRAY,
3510 	.map_name = "typedef_arra_mix_size_resolve_map",
3511 	.key_size = sizeof(int),
3512 	.value_size = sizeof(int) * 16 * 8 * 4,
3513 	.key_type_id = 10 /* int */,
3514 	.value_type_id = 3 /* arr_t */,
3515 	.max_entries = 4,
3516 },
3517 /*
3518  * elf .rodata section size 4 and btf .rodata section vlen 0.
3519  */
3520 {
3521 	.descr = "datasec: vlen == 0",
3522 	.raw_types = {
3523 		/* int */
3524 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3525 		/* .rodata section */
3526 		BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 0), 4),
3527 								 /* [2] */
3528 		BTF_END_RAW,
3529 	},
3530 	BTF_STR_SEC("\0.rodata"),
3531 	.map_type = BPF_MAP_TYPE_ARRAY,
3532 	.key_size = sizeof(int),
3533 	.value_size = sizeof(int),
3534 	.key_type_id = 1,
3535 	.value_type_id = 1,
3536 	.max_entries = 1,
3537 },
3538 
3539 {
3540 	.descr = "float test #1, well-formed",
3541 	.raw_types = {
3542 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3543 								/* [1] */
3544 		BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),		/* [2] */
3545 		BTF_TYPE_FLOAT_ENC(NAME_TBD, 4),		/* [3] */
3546 		BTF_TYPE_FLOAT_ENC(NAME_TBD, 8),		/* [4] */
3547 		BTF_TYPE_FLOAT_ENC(NAME_TBD, 12),		/* [5] */
3548 		BTF_TYPE_FLOAT_ENC(NAME_TBD, 16),		/* [6] */
3549 		BTF_STRUCT_ENC(NAME_TBD, 5, 48),		/* [7] */
3550 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3551 		BTF_MEMBER_ENC(NAME_TBD, 3, 32),
3552 		BTF_MEMBER_ENC(NAME_TBD, 4, 64),
3553 		BTF_MEMBER_ENC(NAME_TBD, 5, 128),
3554 		BTF_MEMBER_ENC(NAME_TBD, 6, 256),
3555 		BTF_END_RAW,
3556 	},
3557 	BTF_STR_SEC("\0int\0_Float16\0float\0double\0_Float80\0long_double"
3558 		    "\0floats\0a\0b\0c\0d\0e"),
3559 	.map_type = BPF_MAP_TYPE_ARRAY,
3560 	.map_name = "float_type_check_btf",
3561 	.key_size = sizeof(int),
3562 	.value_size = 48,
3563 	.key_type_id = 1,
3564 	.value_type_id = 7,
3565 	.max_entries = 1,
3566 },
3567 {
3568 	.descr = "float test #2, invalid vlen",
3569 	.raw_types = {
3570 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3571 								/* [1] */
3572 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 1), 4),
3573 								/* [2] */
3574 		BTF_END_RAW,
3575 	},
3576 	BTF_STR_SEC("\0int\0float"),
3577 	.map_type = BPF_MAP_TYPE_ARRAY,
3578 	.map_name = "float_type_check_btf",
3579 	.key_size = sizeof(int),
3580 	.value_size = 4,
3581 	.key_type_id = 1,
3582 	.value_type_id = 2,
3583 	.max_entries = 1,
3584 	.btf_load_err = true,
3585 	.err_str = "vlen != 0",
3586 },
3587 {
3588 	.descr = "float test #3, invalid kind_flag",
3589 	.raw_types = {
3590 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3591 								/* [1] */
3592 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FLOAT, 1, 0), 4),
3593 								/* [2] */
3594 		BTF_END_RAW,
3595 	},
3596 	BTF_STR_SEC("\0int\0float"),
3597 	.map_type = BPF_MAP_TYPE_ARRAY,
3598 	.map_name = "float_type_check_btf",
3599 	.key_size = sizeof(int),
3600 	.value_size = 4,
3601 	.key_type_id = 1,
3602 	.value_type_id = 2,
3603 	.max_entries = 1,
3604 	.btf_load_err = true,
3605 	.err_str = "Invalid btf_info kind_flag",
3606 },
3607 {
3608 	.descr = "float test #4, member does not fit",
3609 	.raw_types = {
3610 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3611 								/* [1] */
3612 		BTF_TYPE_FLOAT_ENC(NAME_TBD, 4),		/* [2] */
3613 		BTF_STRUCT_ENC(NAME_TBD, 1, 2),			/* [3] */
3614 		BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3615 		BTF_END_RAW,
3616 	},
3617 	BTF_STR_SEC("\0int\0float\0floats\0x"),
3618 	.map_type = BPF_MAP_TYPE_ARRAY,
3619 	.map_name = "float_type_check_btf",
3620 	.key_size = sizeof(int),
3621 	.value_size = 4,
3622 	.key_type_id = 1,
3623 	.value_type_id = 3,
3624 	.max_entries = 1,
3625 	.btf_load_err = true,
3626 	.err_str = "Member exceeds struct_size",
3627 },
3628 {
3629 	.descr = "float test #5, member is not properly aligned",
3630 	.raw_types = {
3631 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3632 								/* [1] */
3633 		BTF_TYPE_FLOAT_ENC(NAME_TBD, 4),		/* [2] */
3634 		BTF_STRUCT_ENC(NAME_TBD, 1, 8),			/* [3] */
3635 		BTF_MEMBER_ENC(NAME_TBD, 2, 8),
3636 		BTF_END_RAW,
3637 	},
3638 	BTF_STR_SEC("\0int\0float\0floats\0x"),
3639 	.map_type = BPF_MAP_TYPE_ARRAY,
3640 	.map_name = "float_type_check_btf",
3641 	.key_size = sizeof(int),
3642 	.value_size = 4,
3643 	.key_type_id = 1,
3644 	.value_type_id = 3,
3645 	.max_entries = 1,
3646 	.btf_load_err = true,
3647 	.err_str = "Member is not properly aligned",
3648 },
3649 {
3650 	.descr = "float test #6, invalid size",
3651 	.raw_types = {
3652 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3653 								/* [1] */
3654 		BTF_TYPE_FLOAT_ENC(NAME_TBD, 6),		/* [2] */
3655 		BTF_END_RAW,
3656 	},
3657 	BTF_STR_SEC("\0int\0float"),
3658 	.map_type = BPF_MAP_TYPE_ARRAY,
3659 	.map_name = "float_type_check_btf",
3660 	.key_size = sizeof(int),
3661 	.value_size = 6,
3662 	.key_type_id = 1,
3663 	.value_type_id = 2,
3664 	.max_entries = 1,
3665 	.btf_load_err = true,
3666 	.err_str = "Invalid type_size",
3667 },
3668 
3669 {
3670 	.descr = "decl_tag test #1, struct/member, well-formed",
3671 	.raw_types = {
3672 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3673 		BTF_STRUCT_ENC(0, 2, 8),			/* [2] */
3674 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3675 		BTF_MEMBER_ENC(NAME_TBD, 1, 32),
3676 		BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
3677 		BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
3678 		BTF_DECL_TAG_ENC(NAME_TBD, 2, 1),
3679 		BTF_END_RAW,
3680 	},
3681 	BTF_STR_SEC("\0m1\0m2\0tag1\0tag2\0tag3"),
3682 	.map_type = BPF_MAP_TYPE_ARRAY,
3683 	.map_name = "tag_type_check_btf",
3684 	.key_size = sizeof(int),
3685 	.value_size = 8,
3686 	.key_type_id = 1,
3687 	.value_type_id = 2,
3688 	.max_entries = 1,
3689 },
3690 {
3691 	.descr = "decl_tag test #2, union/member, well-formed",
3692 	.raw_types = {
3693 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3694 		BTF_UNION_ENC(NAME_TBD, 2, 4),			/* [2] */
3695 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3696 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3697 		BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
3698 		BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
3699 		BTF_DECL_TAG_ENC(NAME_TBD, 2, 1),
3700 		BTF_END_RAW,
3701 	},
3702 	BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
3703 	.map_type = BPF_MAP_TYPE_ARRAY,
3704 	.map_name = "tag_type_check_btf",
3705 	.key_size = sizeof(int),
3706 	.value_size = 4,
3707 	.key_type_id = 1,
3708 	.value_type_id = 2,
3709 	.max_entries = 1,
3710 },
3711 {
3712 	.descr = "decl_tag test #3, variable, well-formed",
3713 	.raw_types = {
3714 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3715 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
3716 		BTF_VAR_ENC(NAME_TBD, 1, 1),			/* [3] */
3717 		BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
3718 		BTF_DECL_TAG_ENC(NAME_TBD, 3, -1),
3719 		BTF_END_RAW,
3720 	},
3721 	BTF_STR_SEC("\0local\0global\0tag1\0tag2"),
3722 	.map_type = BPF_MAP_TYPE_ARRAY,
3723 	.map_name = "tag_type_check_btf",
3724 	.key_size = sizeof(int),
3725 	.value_size = 4,
3726 	.key_type_id = 1,
3727 	.value_type_id = 1,
3728 	.max_entries = 1,
3729 },
3730 {
3731 	.descr = "decl_tag test #4, func/parameter, well-formed",
3732 	.raw_types = {
3733 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3734 		BTF_FUNC_PROTO_ENC(0, 2),			/* [2] */
3735 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3736 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3737 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
3738 		BTF_DECL_TAG_ENC(NAME_TBD, 3, -1),
3739 		BTF_DECL_TAG_ENC(NAME_TBD, 3, 0),
3740 		BTF_DECL_TAG_ENC(NAME_TBD, 3, 1),
3741 		BTF_END_RAW,
3742 	},
3743 	BTF_STR_SEC("\0arg1\0arg2\0f\0tag1\0tag2\0tag3"),
3744 	.map_type = BPF_MAP_TYPE_ARRAY,
3745 	.map_name = "tag_type_check_btf",
3746 	.key_size = sizeof(int),
3747 	.value_size = 4,
3748 	.key_type_id = 1,
3749 	.value_type_id = 1,
3750 	.max_entries = 1,
3751 },
3752 {
3753 	.descr = "decl_tag test #5, invalid value",
3754 	.raw_types = {
3755 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3756 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
3757 		BTF_DECL_TAG_ENC(0, 2, -1),
3758 		BTF_END_RAW,
3759 	},
3760 	BTF_STR_SEC("\0local\0tag"),
3761 	.map_type = BPF_MAP_TYPE_ARRAY,
3762 	.map_name = "tag_type_check_btf",
3763 	.key_size = sizeof(int),
3764 	.value_size = 4,
3765 	.key_type_id = 1,
3766 	.value_type_id = 1,
3767 	.max_entries = 1,
3768 	.btf_load_err = true,
3769 	.err_str = "Invalid value",
3770 },
3771 {
3772 	.descr = "decl_tag test #6, invalid target type",
3773 	.raw_types = {
3774 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3775 		BTF_DECL_TAG_ENC(NAME_TBD, 1, -1),
3776 		BTF_END_RAW,
3777 	},
3778 	BTF_STR_SEC("\0tag1"),
3779 	.map_type = BPF_MAP_TYPE_ARRAY,
3780 	.map_name = "tag_type_check_btf",
3781 	.key_size = sizeof(int),
3782 	.value_size = 4,
3783 	.key_type_id = 1,
3784 	.value_type_id = 1,
3785 	.max_entries = 1,
3786 	.btf_load_err = true,
3787 	.err_str = "Invalid type",
3788 },
3789 {
3790 	.descr = "decl_tag test #7, invalid vlen",
3791 	.raw_types = {
3792 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3793 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
3794 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 1), 2), (0),
3795 		BTF_END_RAW,
3796 	},
3797 	BTF_STR_SEC("\0local\0tag1"),
3798 	.map_type = BPF_MAP_TYPE_ARRAY,
3799 	.map_name = "tag_type_check_btf",
3800 	.key_size = sizeof(int),
3801 	.value_size = 4,
3802 	.key_type_id = 1,
3803 	.value_type_id = 1,
3804 	.max_entries = 1,
3805 	.btf_load_err = true,
3806 	.err_str = "vlen != 0",
3807 },
3808 {
3809 	.descr = "decl_tag test #8, invalid kflag",
3810 	.raw_types = {
3811 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3812 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
3813 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 1, 0), 2), (-1),
3814 		BTF_END_RAW,
3815 	},
3816 	BTF_STR_SEC("\0local\0tag1"),
3817 	.map_type = BPF_MAP_TYPE_ARRAY,
3818 	.map_name = "tag_type_check_btf",
3819 	.key_size = sizeof(int),
3820 	.value_size = 4,
3821 	.key_type_id = 1,
3822 	.value_type_id = 1,
3823 	.max_entries = 1,
3824 	.btf_load_err = true,
3825 	.err_str = "Invalid btf_info kind_flag",
3826 },
3827 {
3828 	.descr = "decl_tag test #9, var, invalid component_idx",
3829 	.raw_types = {
3830 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3831 		BTF_VAR_ENC(NAME_TBD, 1, 0),			/* [2] */
3832 		BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
3833 		BTF_END_RAW,
3834 	},
3835 	BTF_STR_SEC("\0local\0tag"),
3836 	.map_type = BPF_MAP_TYPE_ARRAY,
3837 	.map_name = "tag_type_check_btf",
3838 	.key_size = sizeof(int),
3839 	.value_size = 4,
3840 	.key_type_id = 1,
3841 	.value_type_id = 1,
3842 	.max_entries = 1,
3843 	.btf_load_err = true,
3844 	.err_str = "Invalid component_idx",
3845 },
3846 {
3847 	.descr = "decl_tag test #10, struct member, invalid component_idx",
3848 	.raw_types = {
3849 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3850 		BTF_STRUCT_ENC(0, 2, 8),			/* [2] */
3851 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3852 		BTF_MEMBER_ENC(NAME_TBD, 1, 32),
3853 		BTF_DECL_TAG_ENC(NAME_TBD, 2, 2),
3854 		BTF_END_RAW,
3855 	},
3856 	BTF_STR_SEC("\0m1\0m2\0tag"),
3857 	.map_type = BPF_MAP_TYPE_ARRAY,
3858 	.map_name = "tag_type_check_btf",
3859 	.key_size = sizeof(int),
3860 	.value_size = 8,
3861 	.key_type_id = 1,
3862 	.value_type_id = 2,
3863 	.max_entries = 1,
3864 	.btf_load_err = true,
3865 	.err_str = "Invalid component_idx",
3866 },
3867 {
3868 	.descr = "decl_tag test #11, func parameter, invalid component_idx",
3869 	.raw_types = {
3870 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3871 		BTF_FUNC_PROTO_ENC(0, 2),			/* [2] */
3872 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3873 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3874 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
3875 		BTF_DECL_TAG_ENC(NAME_TBD, 3, 2),
3876 		BTF_END_RAW,
3877 	},
3878 	BTF_STR_SEC("\0arg1\0arg2\0f\0tag"),
3879 	.map_type = BPF_MAP_TYPE_ARRAY,
3880 	.map_name = "tag_type_check_btf",
3881 	.key_size = sizeof(int),
3882 	.value_size = 4,
3883 	.key_type_id = 1,
3884 	.value_type_id = 1,
3885 	.max_entries = 1,
3886 	.btf_load_err = true,
3887 	.err_str = "Invalid component_idx",
3888 },
3889 {
3890 	.descr = "decl_tag test #12, < -1 component_idx",
3891 	.raw_types = {
3892 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3893 		BTF_FUNC_PROTO_ENC(0, 2),			/* [2] */
3894 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3895 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3896 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
3897 		BTF_DECL_TAG_ENC(NAME_TBD, 3, -2),
3898 		BTF_END_RAW,
3899 	},
3900 	BTF_STR_SEC("\0arg1\0arg2\0f\0tag"),
3901 	.map_type = BPF_MAP_TYPE_ARRAY,
3902 	.map_name = "tag_type_check_btf",
3903 	.key_size = sizeof(int),
3904 	.value_size = 4,
3905 	.key_type_id = 1,
3906 	.value_type_id = 1,
3907 	.max_entries = 1,
3908 	.btf_load_err = true,
3909 	.err_str = "Invalid component_idx",
3910 },
3911 {
3912 	.descr = "decl_tag test #13, typedef, well-formed",
3913 	.raw_types = {
3914 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3915 		BTF_TYPEDEF_ENC(NAME_TBD, 1),			/* [2] */
3916 		BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
3917 		BTF_END_RAW,
3918 	},
3919 	BTF_STR_SEC("\0t\0tag"),
3920 	.map_type = BPF_MAP_TYPE_ARRAY,
3921 	.map_name = "tag_type_check_btf",
3922 	.key_size = sizeof(int),
3923 	.value_size = 4,
3924 	.key_type_id = 1,
3925 	.value_type_id = 1,
3926 	.max_entries = 1,
3927 },
3928 {
3929 	.descr = "decl_tag test #14, typedef, invalid component_idx",
3930 	.raw_types = {
3931 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3932 		BTF_TYPEDEF_ENC(NAME_TBD, 1),			/* [2] */
3933 		BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
3934 		BTF_END_RAW,
3935 	},
3936 	BTF_STR_SEC("\0local\0tag"),
3937 	.map_type = BPF_MAP_TYPE_ARRAY,
3938 	.map_name = "tag_type_check_btf",
3939 	.key_size = sizeof(int),
3940 	.value_size = 4,
3941 	.key_type_id = 1,
3942 	.value_type_id = 1,
3943 	.max_entries = 1,
3944 	.btf_load_err = true,
3945 	.err_str = "Invalid component_idx",
3946 },
3947 {
3948 	.descr = "decl_tag test #15, func, invalid func proto",
3949 	.raw_types = {
3950 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3951 		BTF_DECL_TAG_ENC(NAME_TBD, 3, 0),		/* [2] */
3952 		BTF_FUNC_ENC(NAME_TBD, 8),			/* [3] */
3953 		BTF_END_RAW,
3954 	},
3955 	BTF_STR_SEC("\0tag\0func"),
3956 	.map_type = BPF_MAP_TYPE_ARRAY,
3957 	.map_name = "tag_type_check_btf",
3958 	.key_size = sizeof(int),
3959 	.value_size = 4,
3960 	.key_type_id = 1,
3961 	.value_type_id = 1,
3962 	.max_entries = 1,
3963 	.btf_load_err = true,
3964 	.err_str = "Invalid type_id",
3965 },
3966 {
3967 	.descr = "decl_tag test #16, func proto, return type",
3968 	.raw_types = {
3969 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),				/* [1] */
3970 		BTF_VAR_ENC(NAME_TBD, 1, 0),						/* [2] */
3971 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 0), 2), (-1),	/* [3] */
3972 		BTF_FUNC_PROTO_ENC(3, 0),						/* [4] */
3973 		BTF_END_RAW,
3974 	},
3975 	BTF_STR_SEC("\0local\0tag1"),
3976 	.btf_load_err = true,
3977 	.err_str = "Invalid return type",
3978 },
3979 {
3980 	.descr = "decl_tag test #17, func proto, argument",
3981 	.raw_types = {
3982 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 0), 4), (-1),	/* [1] */
3983 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0), /* [2] */
3984 		BTF_FUNC_PROTO_ENC(0, 1),			/* [3] */
3985 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3986 		BTF_VAR_ENC(NAME_TBD, 2, 0),			/* [4] */
3987 		BTF_END_RAW,
3988 	},
3989 	BTF_STR_SEC("\0local\0tag1\0var"),
3990 	.btf_load_err = true,
3991 	.err_str = "Invalid arg#1",
3992 },
3993 {
3994 	.descr = "decl_tag test #18, decl_tag as the map key type",
3995 	.raw_types = {
3996 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
3997 		BTF_STRUCT_ENC(0, 2, 8),			/* [2] */
3998 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3999 		BTF_MEMBER_ENC(NAME_TBD, 1, 32),
4000 		BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),		/* [3] */
4001 		BTF_END_RAW,
4002 	},
4003 	BTF_STR_SEC("\0m1\0m2\0tag"),
4004 	.map_type = BPF_MAP_TYPE_HASH,
4005 	.map_name = "tag_type_check_btf",
4006 	.key_size = 8,
4007 	.value_size = 4,
4008 	.key_type_id = 3,
4009 	.value_type_id = 1,
4010 	.max_entries = 1,
4011 	.map_create_err = true,
4012 },
4013 {
4014 	.descr = "decl_tag test #19, decl_tag as the map value type",
4015 	.raw_types = {
4016 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
4017 		BTF_STRUCT_ENC(0, 2, 8),			/* [2] */
4018 		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
4019 		BTF_MEMBER_ENC(NAME_TBD, 1, 32),
4020 		BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),		/* [3] */
4021 		BTF_END_RAW,
4022 	},
4023 	BTF_STR_SEC("\0m1\0m2\0tag"),
4024 	.map_type = BPF_MAP_TYPE_HASH,
4025 	.map_name = "tag_type_check_btf",
4026 	.key_size = 4,
4027 	.value_size = 8,
4028 	.key_type_id = 1,
4029 	.value_type_id = 3,
4030 	.max_entries = 1,
4031 	.map_create_err = true,
4032 },
4033 {
4034 	.descr = "type_tag test #1",
4035 	.raw_types = {
4036 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
4037 		BTF_TYPE_TAG_ENC(NAME_TBD, 1),			/* [2] */
4038 		BTF_PTR_ENC(2),					/* [3] */
4039 		BTF_END_RAW,
4040 	},
4041 	BTF_STR_SEC("\0tag"),
4042 	.map_type = BPF_MAP_TYPE_ARRAY,
4043 	.map_name = "tag_type_check_btf",
4044 	.key_size = sizeof(int),
4045 	.value_size = 4,
4046 	.key_type_id = 1,
4047 	.value_type_id = 1,
4048 	.max_entries = 1,
4049 },
4050 {
4051 	.descr = "type_tag test #2, type tag order",
4052 	.raw_types = {
4053 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
4054 		BTF_CONST_ENC(3),				/* [2] */
4055 		BTF_TYPE_TAG_ENC(NAME_TBD, 1),			/* [3] */
4056 		BTF_END_RAW,
4057 	},
4058 	BTF_STR_SEC("\0tag"),
4059 	.map_type = BPF_MAP_TYPE_ARRAY,
4060 	.map_name = "tag_type_check_btf",
4061 	.key_size = sizeof(int),
4062 	.value_size = 4,
4063 	.key_type_id = 1,
4064 	.value_type_id = 1,
4065 	.max_entries = 1,
4066 	.btf_load_err = true,
4067 	.err_str = "Type tags don't precede modifiers",
4068 },
4069 {
4070 	.descr = "type_tag test #3, type tag order",
4071 	.raw_types = {
4072 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
4073 		BTF_TYPE_TAG_ENC(NAME_TBD, 3),			/* [2] */
4074 		BTF_CONST_ENC(4),				/* [3] */
4075 		BTF_TYPE_TAG_ENC(NAME_TBD, 1),			/* [4] */
4076 		BTF_END_RAW,
4077 	},
4078 	BTF_STR_SEC("\0tag\0tag"),
4079 	.map_type = BPF_MAP_TYPE_ARRAY,
4080 	.map_name = "tag_type_check_btf",
4081 	.key_size = sizeof(int),
4082 	.value_size = 4,
4083 	.key_type_id = 1,
4084 	.value_type_id = 1,
4085 	.max_entries = 1,
4086 	.btf_load_err = true,
4087 	.err_str = "Type tags don't precede modifiers",
4088 },
4089 {
4090 	.descr = "type_tag test #4, type tag order",
4091 	.raw_types = {
4092 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
4093 		BTF_TYPEDEF_ENC(NAME_TBD, 3),			/* [2] */
4094 		BTF_CONST_ENC(4),				/* [3] */
4095 		BTF_TYPE_TAG_ENC(NAME_TBD, 1),			/* [4] */
4096 		BTF_END_RAW,
4097 	},
4098 	BTF_STR_SEC("\0tag\0tag"),
4099 	.map_type = BPF_MAP_TYPE_ARRAY,
4100 	.map_name = "tag_type_check_btf",
4101 	.key_size = sizeof(int),
4102 	.value_size = 4,
4103 	.key_type_id = 1,
4104 	.value_type_id = 1,
4105 	.max_entries = 1,
4106 	.btf_load_err = true,
4107 	.err_str = "Type tags don't precede modifiers",
4108 },
4109 {
4110 	.descr = "type_tag test #5, type tag order",
4111 	.raw_types = {
4112 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
4113 		BTF_TYPE_TAG_ENC(NAME_TBD, 3),			/* [2] */
4114 		BTF_CONST_ENC(1),				/* [3] */
4115 		BTF_TYPE_TAG_ENC(NAME_TBD, 2),			/* [4] */
4116 		BTF_END_RAW,
4117 	},
4118 	BTF_STR_SEC("\0tag\0tag"),
4119 	.map_type = BPF_MAP_TYPE_ARRAY,
4120 	.map_name = "tag_type_check_btf",
4121 	.key_size = sizeof(int),
4122 	.value_size = 4,
4123 	.key_type_id = 1,
4124 	.value_type_id = 1,
4125 	.max_entries = 1,
4126 },
4127 {
4128 	.descr = "type_tag test #6, type tag order",
4129 	.raw_types = {
4130 		BTF_PTR_ENC(2),					/* [1] */
4131 		BTF_TYPE_TAG_ENC(NAME_TBD, 3),			/* [2] */
4132 		BTF_CONST_ENC(4),				/* [3] */
4133 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [4] */
4134 		BTF_PTR_ENC(6),					/* [5] */
4135 		BTF_CONST_ENC(2),				/* [6] */
4136 		BTF_END_RAW,
4137 	},
4138 	BTF_STR_SEC("\0tag"),
4139 	.map_type = BPF_MAP_TYPE_ARRAY,
4140 	.map_name = "tag_type_check_btf",
4141 	.key_size = sizeof(int),
4142 	.value_size = 4,
4143 	.key_type_id = 1,
4144 	.value_type_id = 1,
4145 	.max_entries = 1,
4146 	.btf_load_err = true,
4147 	.err_str = "Type tags don't precede modifiers",
4148 },
4149 {
4150 	.descr = "enum64 test #1, unsigned, size 8",
4151 	.raw_types = {
4152 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
4153 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 2), 8),	/* [2] */
4154 		BTF_ENUM64_ENC(NAME_TBD, 0, 0),
4155 		BTF_ENUM64_ENC(NAME_TBD, 1, 1),
4156 		BTF_END_RAW,
4157 	},
4158 	BTF_STR_SEC("\0a\0b\0c"),
4159 	.map_type = BPF_MAP_TYPE_ARRAY,
4160 	.map_name = "tag_type_check_btf",
4161 	.key_size = sizeof(int),
4162 	.value_size = 8,
4163 	.key_type_id = 1,
4164 	.value_type_id = 2,
4165 	.max_entries = 1,
4166 },
4167 {
4168 	.descr = "enum64 test #2, signed, size 4",
4169 	.raw_types = {
4170 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),			/* [1] */
4171 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM64, 1, 2), 4),	/* [2] */
4172 		BTF_ENUM64_ENC(NAME_TBD, -1, 0),
4173 		BTF_ENUM64_ENC(NAME_TBD, 1, 0),
4174 		BTF_END_RAW,
4175 	},
4176 	BTF_STR_SEC("\0a\0b\0c"),
4177 	.map_type = BPF_MAP_TYPE_ARRAY,
4178 	.map_name = "tag_type_check_btf",
4179 	.key_size = sizeof(int),
4180 	.value_size = 4,
4181 	.key_type_id = 1,
4182 	.value_type_id = 2,
4183 	.max_entries = 1,
4184 },
4185 
4186 }; /* struct btf_raw_test raw_tests[] */
4187 
4188 static const char *get_next_str(const char *start, const char *end)
4189 {
4190 	return start < end - 1 ? start + 1 : NULL;
4191 }
4192 
4193 static int get_raw_sec_size(const __u32 *raw_types)
4194 {
4195 	int i;
4196 
4197 	for (i = MAX_NR_RAW_U32 - 1;
4198 	     i >= 0 && raw_types[i] != BTF_END_RAW;
4199 	     i--)
4200 		;
4201 
4202 	return i < 0 ? i : i * sizeof(raw_types[0]);
4203 }
4204 
4205 static void *btf_raw_create(const struct btf_header *hdr,
4206 			    const __u32 *raw_types,
4207 			    const char *str,
4208 			    unsigned int str_sec_size,
4209 			    unsigned int *btf_size,
4210 			    const char **ret_next_str)
4211 {
4212 	const char *next_str = str, *end_str = str + str_sec_size;
4213 	const char **strs_idx = NULL, **tmp_strs_idx;
4214 	int strs_cap = 0, strs_cnt = 0, next_str_idx = 0;
4215 	unsigned int size_needed, offset;
4216 	struct btf_header *ret_hdr;
4217 	int i, type_sec_size, err = 0;
4218 	uint32_t *ret_types;
4219 	void *raw_btf = NULL;
4220 
4221 	type_sec_size = get_raw_sec_size(raw_types);
4222 	if (CHECK(type_sec_size < 0, "Cannot get nr_raw_types"))
4223 		return NULL;
4224 
4225 	size_needed = sizeof(*hdr) + type_sec_size + str_sec_size;
4226 	raw_btf = malloc(size_needed);
4227 	if (CHECK(!raw_btf, "Cannot allocate memory for raw_btf"))
4228 		return NULL;
4229 
4230 	/* Copy header */
4231 	memcpy(raw_btf, hdr, sizeof(*hdr));
4232 	offset = sizeof(*hdr);
4233 
4234 	/* Index strings */
4235 	while ((next_str = get_next_str(next_str, end_str))) {
4236 		if (strs_cnt == strs_cap) {
4237 			strs_cap += max(16, strs_cap / 2);
4238 			tmp_strs_idx = realloc(strs_idx,
4239 					       sizeof(*strs_idx) * strs_cap);
4240 			if (CHECK(!tmp_strs_idx,
4241 				  "Cannot allocate memory for strs_idx")) {
4242 				err = -1;
4243 				goto done;
4244 			}
4245 			strs_idx = tmp_strs_idx;
4246 		}
4247 		strs_idx[strs_cnt++] = next_str;
4248 		next_str += strlen(next_str);
4249 	}
4250 
4251 	/* Copy type section */
4252 	ret_types = raw_btf + offset;
4253 	for (i = 0; i < type_sec_size / sizeof(raw_types[0]); i++) {
4254 		if (raw_types[i] == NAME_TBD) {
4255 			if (CHECK(next_str_idx == strs_cnt,
4256 				  "Error in getting next_str #%d",
4257 				  next_str_idx)) {
4258 				err = -1;
4259 				goto done;
4260 			}
4261 			ret_types[i] = strs_idx[next_str_idx++] - str;
4262 		} else if (IS_NAME_NTH(raw_types[i])) {
4263 			int idx = GET_NAME_NTH_IDX(raw_types[i]);
4264 
4265 			if (CHECK(idx <= 0 || idx > strs_cnt,
4266 				  "Error getting string #%d, strs_cnt:%d",
4267 				  idx, strs_cnt)) {
4268 				err = -1;
4269 				goto done;
4270 			}
4271 			ret_types[i] = strs_idx[idx-1] - str;
4272 		} else {
4273 			ret_types[i] = raw_types[i];
4274 		}
4275 	}
4276 	offset += type_sec_size;
4277 
4278 	/* Copy string section */
4279 	memcpy(raw_btf + offset, str, str_sec_size);
4280 
4281 	ret_hdr = (struct btf_header *)raw_btf;
4282 	ret_hdr->type_len = type_sec_size;
4283 	ret_hdr->str_off = type_sec_size;
4284 	ret_hdr->str_len = str_sec_size;
4285 
4286 	*btf_size = size_needed;
4287 	if (ret_next_str)
4288 		*ret_next_str =
4289 			next_str_idx < strs_cnt ? strs_idx[next_str_idx] : NULL;
4290 
4291 done:
4292 	free(strs_idx);
4293 	if (err) {
4294 		free(raw_btf);
4295 		return NULL;
4296 	}
4297 	return raw_btf;
4298 }
4299 
4300 static int load_raw_btf(const void *raw_data, size_t raw_size)
4301 {
4302 	LIBBPF_OPTS(bpf_btf_load_opts, opts);
4303 	int btf_fd;
4304 
4305 	if (always_log) {
4306 		opts.log_buf = btf_log_buf,
4307 		opts.log_size = BTF_LOG_BUF_SIZE,
4308 		opts.log_level = 1;
4309 	}
4310 
4311 	btf_fd = bpf_btf_load(raw_data, raw_size, &opts);
4312 	if (btf_fd < 0 && !always_log) {
4313 		opts.log_buf = btf_log_buf,
4314 		opts.log_size = BTF_LOG_BUF_SIZE,
4315 		opts.log_level = 1;
4316 		btf_fd = bpf_btf_load(raw_data, raw_size, &opts);
4317 	}
4318 
4319 	return btf_fd;
4320 }
4321 
4322 static void do_test_raw(unsigned int test_num)
4323 {
4324 	struct btf_raw_test *test = &raw_tests[test_num - 1];
4325 	LIBBPF_OPTS(bpf_map_create_opts, opts);
4326 	int map_fd = -1, btf_fd = -1;
4327 	unsigned int raw_btf_size;
4328 	struct btf_header *hdr;
4329 	void *raw_btf;
4330 	int err;
4331 
4332 	if (!test__start_subtest(test->descr))
4333 		return;
4334 
4335 	raw_btf = btf_raw_create(&hdr_tmpl,
4336 				 test->raw_types,
4337 				 test->str_sec,
4338 				 test->str_sec_size,
4339 				 &raw_btf_size, NULL);
4340 	if (!raw_btf)
4341 		return;
4342 
4343 	hdr = raw_btf;
4344 
4345 	hdr->hdr_len = (int)hdr->hdr_len + test->hdr_len_delta;
4346 	hdr->type_off = (int)hdr->type_off + test->type_off_delta;
4347 	hdr->str_off = (int)hdr->str_off + test->str_off_delta;
4348 	hdr->str_len = (int)hdr->str_len + test->str_len_delta;
4349 
4350 	*btf_log_buf = '\0';
4351 	btf_fd = load_raw_btf(raw_btf, raw_btf_size);
4352 	free(raw_btf);
4353 
4354 	err = ((btf_fd < 0) != test->btf_load_err);
4355 	if (CHECK(err, "btf_fd:%d test->btf_load_err:%u",
4356 		  btf_fd, test->btf_load_err) ||
4357 	    CHECK(test->err_str && !strstr(btf_log_buf, test->err_str),
4358 		  "expected err_str:%s\n", test->err_str)) {
4359 		err = -1;
4360 		goto done;
4361 	}
4362 
4363 	if (err || btf_fd < 0)
4364 		goto done;
4365 
4366 	opts.btf_fd = btf_fd;
4367 	opts.btf_key_type_id = test->key_type_id;
4368 	opts.btf_value_type_id = test->value_type_id;
4369 	map_fd = bpf_map_create(test->map_type, test->map_name,
4370 				test->key_size, test->value_size, test->max_entries, &opts);
4371 
4372 	err = ((map_fd < 0) != test->map_create_err);
4373 	CHECK(err, "map_fd:%d test->map_create_err:%u",
4374 	      map_fd, test->map_create_err);
4375 
4376 done:
4377 	if (*btf_log_buf && (err || always_log))
4378 		fprintf(stderr, "\n%s", btf_log_buf);
4379 	if (btf_fd >= 0)
4380 		close(btf_fd);
4381 	if (map_fd >= 0)
4382 		close(map_fd);
4383 }
4384 
4385 struct btf_get_info_test {
4386 	const char *descr;
4387 	const char *str_sec;
4388 	__u32 raw_types[MAX_NR_RAW_U32];
4389 	__u32 str_sec_size;
4390 	int btf_size_delta;
4391 	int (*special_test)(unsigned int test_num);
4392 };
4393 
4394 static int test_big_btf_info(unsigned int test_num);
4395 static int test_btf_id(unsigned int test_num);
4396 
4397 const struct btf_get_info_test get_info_tests[] = {
4398 {
4399 	.descr = "== raw_btf_size+1",
4400 	.raw_types = {
4401 		/* int */				/* [1] */
4402 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
4403 		BTF_END_RAW,
4404 	},
4405 	.str_sec = "",
4406 	.str_sec_size = sizeof(""),
4407 	.btf_size_delta = 1,
4408 },
4409 {
4410 	.descr = "== raw_btf_size-3",
4411 	.raw_types = {
4412 		/* int */				/* [1] */
4413 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
4414 		BTF_END_RAW,
4415 	},
4416 	.str_sec = "",
4417 	.str_sec_size = sizeof(""),
4418 	.btf_size_delta = -3,
4419 },
4420 {
4421 	.descr = "Large bpf_btf_info",
4422 	.raw_types = {
4423 		/* int */				/* [1] */
4424 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
4425 		BTF_END_RAW,
4426 	},
4427 	.str_sec = "",
4428 	.str_sec_size = sizeof(""),
4429 	.special_test = test_big_btf_info,
4430 },
4431 {
4432 	.descr = "BTF ID",
4433 	.raw_types = {
4434 		/* int */				/* [1] */
4435 		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
4436 		/* unsigned int */			/* [2] */
4437 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),
4438 		BTF_END_RAW,
4439 	},
4440 	.str_sec = "",
4441 	.str_sec_size = sizeof(""),
4442 	.special_test = test_btf_id,
4443 },
4444 };
4445 
4446 static int test_big_btf_info(unsigned int test_num)
4447 {
4448 	const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
4449 	uint8_t *raw_btf = NULL, *user_btf = NULL;
4450 	unsigned int raw_btf_size;
4451 	struct {
4452 		struct bpf_btf_info info;
4453 		uint64_t garbage;
4454 	} info_garbage;
4455 	struct bpf_btf_info *info;
4456 	int btf_fd = -1, err;
4457 	uint32_t info_len;
4458 
4459 	raw_btf = btf_raw_create(&hdr_tmpl,
4460 				 test->raw_types,
4461 				 test->str_sec,
4462 				 test->str_sec_size,
4463 				 &raw_btf_size, NULL);
4464 
4465 	if (!raw_btf)
4466 		return -1;
4467 
4468 	*btf_log_buf = '\0';
4469 
4470 	user_btf = malloc(raw_btf_size);
4471 	if (CHECK(!user_btf, "!user_btf")) {
4472 		err = -1;
4473 		goto done;
4474 	}
4475 
4476 	btf_fd = load_raw_btf(raw_btf, raw_btf_size);
4477 	if (CHECK(btf_fd < 0, "errno:%d", errno)) {
4478 		err = -1;
4479 		goto done;
4480 	}
4481 
4482 	/*
4483 	 * GET_INFO should error out if the userspace info
4484 	 * has non zero tailing bytes.
4485 	 */
4486 	info = &info_garbage.info;
4487 	memset(info, 0, sizeof(*info));
4488 	info_garbage.garbage = 0xdeadbeef;
4489 	info_len = sizeof(info_garbage);
4490 	info->btf = ptr_to_u64(user_btf);
4491 	info->btf_size = raw_btf_size;
4492 
4493 	err = bpf_btf_get_info_by_fd(btf_fd, info, &info_len);
4494 	if (CHECK(!err, "!err")) {
4495 		err = -1;
4496 		goto done;
4497 	}
4498 
4499 	/*
4500 	 * GET_INFO should succeed even info_len is larger than
4501 	 * the kernel supported as long as tailing bytes are zero.
4502 	 * The kernel supported info len should also be returned
4503 	 * to userspace.
4504 	 */
4505 	info_garbage.garbage = 0;
4506 	err = bpf_btf_get_info_by_fd(btf_fd, info, &info_len);
4507 	if (CHECK(err || info_len != sizeof(*info),
4508 		  "err:%d errno:%d info_len:%u sizeof(*info):%zu",
4509 		  err, errno, info_len, sizeof(*info))) {
4510 		err = -1;
4511 		goto done;
4512 	}
4513 
4514 	fprintf(stderr, "OK");
4515 
4516 done:
4517 	if (*btf_log_buf && (err || always_log))
4518 		fprintf(stderr, "\n%s", btf_log_buf);
4519 
4520 	free(raw_btf);
4521 	free(user_btf);
4522 
4523 	if (btf_fd >= 0)
4524 		close(btf_fd);
4525 
4526 	return err;
4527 }
4528 
4529 static int test_btf_id(unsigned int test_num)
4530 {
4531 	const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
4532 	LIBBPF_OPTS(bpf_map_create_opts, opts);
4533 	uint8_t *raw_btf = NULL, *user_btf[2] = {};
4534 	int btf_fd[2] = {-1, -1}, map_fd = -1;
4535 	struct bpf_map_info map_info = {};
4536 	struct bpf_btf_info info[2] = {};
4537 	unsigned int raw_btf_size;
4538 	uint32_t info_len;
4539 	int err, i, ret;
4540 
4541 	raw_btf = btf_raw_create(&hdr_tmpl,
4542 				 test->raw_types,
4543 				 test->str_sec,
4544 				 test->str_sec_size,
4545 				 &raw_btf_size, NULL);
4546 
4547 	if (!raw_btf)
4548 		return -1;
4549 
4550 	*btf_log_buf = '\0';
4551 
4552 	for (i = 0; i < 2; i++) {
4553 		user_btf[i] = malloc(raw_btf_size);
4554 		if (CHECK(!user_btf[i], "!user_btf[%d]", i)) {
4555 			err = -1;
4556 			goto done;
4557 		}
4558 		info[i].btf = ptr_to_u64(user_btf[i]);
4559 		info[i].btf_size = raw_btf_size;
4560 	}
4561 
4562 	btf_fd[0] = load_raw_btf(raw_btf, raw_btf_size);
4563 	if (CHECK(btf_fd[0] < 0, "errno:%d", errno)) {
4564 		err = -1;
4565 		goto done;
4566 	}
4567 
4568 	/* Test BPF_OBJ_GET_INFO_BY_ID on btf_id */
4569 	info_len = sizeof(info[0]);
4570 	err = bpf_btf_get_info_by_fd(btf_fd[0], &info[0], &info_len);
4571 	if (CHECK(err, "errno:%d", errno)) {
4572 		err = -1;
4573 		goto done;
4574 	}
4575 
4576 	btf_fd[1] = bpf_btf_get_fd_by_id(info[0].id);
4577 	if (CHECK(btf_fd[1] < 0, "errno:%d", errno)) {
4578 		err = -1;
4579 		goto done;
4580 	}
4581 
4582 	ret = 0;
4583 	err = bpf_btf_get_info_by_fd(btf_fd[1], &info[1], &info_len);
4584 	if (CHECK(err || info[0].id != info[1].id ||
4585 		  info[0].btf_size != info[1].btf_size ||
4586 		  (ret = memcmp(user_btf[0], user_btf[1], info[0].btf_size)),
4587 		  "err:%d errno:%d id0:%u id1:%u btf_size0:%u btf_size1:%u memcmp:%d",
4588 		  err, errno, info[0].id, info[1].id,
4589 		  info[0].btf_size, info[1].btf_size, ret)) {
4590 		err = -1;
4591 		goto done;
4592 	}
4593 
4594 	/* Test btf members in struct bpf_map_info */
4595 	opts.btf_fd = btf_fd[0];
4596 	opts.btf_key_type_id = 1;
4597 	opts.btf_value_type_id = 2;
4598 	map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "test_btf_id",
4599 				sizeof(int), sizeof(int), 4, &opts);
4600 	if (CHECK(map_fd < 0, "errno:%d", errno)) {
4601 		err = -1;
4602 		goto done;
4603 	}
4604 
4605 	info_len = sizeof(map_info);
4606 	err = bpf_map_get_info_by_fd(map_fd, &map_info, &info_len);
4607 	if (CHECK(err || map_info.btf_id != info[0].id ||
4608 		  map_info.btf_key_type_id != 1 || map_info.btf_value_type_id != 2,
4609 		  "err:%d errno:%d info.id:%u btf_id:%u btf_key_type_id:%u btf_value_type_id:%u",
4610 		  err, errno, info[0].id, map_info.btf_id, map_info.btf_key_type_id,
4611 		  map_info.btf_value_type_id)) {
4612 		err = -1;
4613 		goto done;
4614 	}
4615 
4616 	for (i = 0; i < 2; i++) {
4617 		close(btf_fd[i]);
4618 		btf_fd[i] = -1;
4619 	}
4620 
4621 	/* Test BTF ID is removed from the kernel */
4622 	btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);
4623 	if (CHECK(btf_fd[0] < 0, "errno:%d", errno)) {
4624 		err = -1;
4625 		goto done;
4626 	}
4627 	close(btf_fd[0]);
4628 	btf_fd[0] = -1;
4629 
4630 	/* The map holds the last ref to BTF and its btf_id */
4631 	close(map_fd);
4632 	map_fd = -1;
4633 	btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);
4634 	if (CHECK(btf_fd[0] >= 0, "BTF lingers")) {
4635 		err = -1;
4636 		goto done;
4637 	}
4638 
4639 	fprintf(stderr, "OK");
4640 
4641 done:
4642 	if (*btf_log_buf && (err || always_log))
4643 		fprintf(stderr, "\n%s", btf_log_buf);
4644 
4645 	free(raw_btf);
4646 	if (map_fd >= 0)
4647 		close(map_fd);
4648 	for (i = 0; i < 2; i++) {
4649 		free(user_btf[i]);
4650 		if (btf_fd[i] >= 0)
4651 			close(btf_fd[i]);
4652 	}
4653 
4654 	return err;
4655 }
4656 
4657 static void do_test_get_info(unsigned int test_num)
4658 {
4659 	const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
4660 	unsigned int raw_btf_size, user_btf_size, expected_nbytes;
4661 	uint8_t *raw_btf = NULL, *user_btf = NULL;
4662 	struct bpf_btf_info info = {};
4663 	int btf_fd = -1, err, ret;
4664 	uint32_t info_len;
4665 
4666 	if (!test__start_subtest(test->descr))
4667 		return;
4668 
4669 	if (test->special_test) {
4670 		err = test->special_test(test_num);
4671 		if (CHECK(err, "failed: %d\n", err))
4672 			return;
4673 	}
4674 
4675 	raw_btf = btf_raw_create(&hdr_tmpl,
4676 				 test->raw_types,
4677 				 test->str_sec,
4678 				 test->str_sec_size,
4679 				 &raw_btf_size, NULL);
4680 
4681 	if (!raw_btf)
4682 		return;
4683 
4684 	*btf_log_buf = '\0';
4685 
4686 	user_btf = malloc(raw_btf_size);
4687 	if (CHECK(!user_btf, "!user_btf")) {
4688 		err = -1;
4689 		goto done;
4690 	}
4691 
4692 	btf_fd = load_raw_btf(raw_btf, raw_btf_size);
4693 	if (CHECK(btf_fd <= 0, "errno:%d", errno)) {
4694 		err = -1;
4695 		goto done;
4696 	}
4697 
4698 	user_btf_size = (int)raw_btf_size + test->btf_size_delta;
4699 	expected_nbytes = min(raw_btf_size, user_btf_size);
4700 	if (raw_btf_size > expected_nbytes)
4701 		memset(user_btf + expected_nbytes, 0xff,
4702 		       raw_btf_size - expected_nbytes);
4703 
4704 	info_len = sizeof(info);
4705 	info.btf = ptr_to_u64(user_btf);
4706 	info.btf_size = user_btf_size;
4707 
4708 	ret = 0;
4709 	err = bpf_btf_get_info_by_fd(btf_fd, &info, &info_len);
4710 	if (CHECK(err || !info.id || info_len != sizeof(info) ||
4711 		  info.btf_size != raw_btf_size ||
4712 		  (ret = memcmp(raw_btf, user_btf, expected_nbytes)),
4713 		  "err:%d errno:%d info.id:%u info_len:%u sizeof(info):%zu raw_btf_size:%u info.btf_size:%u expected_nbytes:%u memcmp:%d",
4714 		  err, errno, info.id, info_len, sizeof(info),
4715 		  raw_btf_size, info.btf_size, expected_nbytes, ret)) {
4716 		err = -1;
4717 		goto done;
4718 	}
4719 
4720 	while (expected_nbytes < raw_btf_size) {
4721 		fprintf(stderr, "%u...", expected_nbytes);
4722 		if (CHECK(user_btf[expected_nbytes++] != 0xff,
4723 			  "user_btf[%u]:%x != 0xff", expected_nbytes - 1,
4724 			  user_btf[expected_nbytes - 1])) {
4725 			err = -1;
4726 			goto done;
4727 		}
4728 	}
4729 
4730 	fprintf(stderr, "OK");
4731 
4732 done:
4733 	if (*btf_log_buf && (err || always_log))
4734 		fprintf(stderr, "\n%s", btf_log_buf);
4735 
4736 	free(raw_btf);
4737 	free(user_btf);
4738 
4739 	if (btf_fd >= 0)
4740 		close(btf_fd);
4741 }
4742 
4743 struct btf_file_test {
4744 	const char *file;
4745 	bool btf_kv_notfound;
4746 };
4747 
4748 static struct btf_file_test file_tests[] = {
4749 	{ .file = "test_btf_newkv.bpf.o", },
4750 	{ .file = "test_btf_nokv.bpf.o", .btf_kv_notfound = true, },
4751 };
4752 
4753 static void do_test_file(unsigned int test_num)
4754 {
4755 	const struct btf_file_test *test = &file_tests[test_num - 1];
4756 	const char *expected_fnames[] = {"_dummy_tracepoint",
4757 					 "test_long_fname_1",
4758 					 "test_long_fname_2"};
4759 	struct btf_ext *btf_ext = NULL;
4760 	struct bpf_prog_info info = {};
4761 	struct bpf_object *obj = NULL;
4762 	struct bpf_func_info *finfo;
4763 	struct bpf_program *prog;
4764 	__u32 info_len, rec_size;
4765 	bool has_btf_ext = false;
4766 	struct btf *btf = NULL;
4767 	void *func_info = NULL;
4768 	struct bpf_map *map;
4769 	int i, err, prog_fd;
4770 
4771 	if (!test__start_subtest(test->file))
4772 		return;
4773 
4774 	btf = btf__parse_elf(test->file, &btf_ext);
4775 	err = libbpf_get_error(btf);
4776 	if (err) {
4777 		if (err == -ENOENT) {
4778 			printf("%s:SKIP: No ELF %s found", __func__, BTF_ELF_SEC);
4779 			test__skip();
4780 			return;
4781 		}
4782 		return;
4783 	}
4784 	btf__free(btf);
4785 
4786 	has_btf_ext = btf_ext != NULL;
4787 	btf_ext__free(btf_ext);
4788 
4789 	/* temporary disable LIBBPF_STRICT_MAP_DEFINITIONS to test legacy maps */
4790 	libbpf_set_strict_mode(LIBBPF_STRICT_ALL & ~LIBBPF_STRICT_MAP_DEFINITIONS);
4791 	obj = bpf_object__open(test->file);
4792 	err = libbpf_get_error(obj);
4793 	if (CHECK(err, "obj: %d", err))
4794 		return;
4795 
4796 	prog = bpf_object__next_program(obj, NULL);
4797 	if (CHECK(!prog, "Cannot find bpf_prog")) {
4798 		err = -1;
4799 		goto done;
4800 	}
4801 
4802 	bpf_program__set_type(prog, BPF_PROG_TYPE_TRACEPOINT);
4803 	err = bpf_object__load(obj);
4804 	if (CHECK(err < 0, "bpf_object__load: %d", err))
4805 		goto done;
4806 	prog_fd = bpf_program__fd(prog);
4807 
4808 	map = bpf_object__find_map_by_name(obj, "btf_map");
4809 	if (CHECK(!map, "btf_map not found")) {
4810 		err = -1;
4811 		goto done;
4812 	}
4813 
4814 	err = (bpf_map__btf_key_type_id(map) == 0 || bpf_map__btf_value_type_id(map) == 0)
4815 		!= test->btf_kv_notfound;
4816 	if (CHECK(err, "btf_key_type_id:%u btf_value_type_id:%u test->btf_kv_notfound:%u",
4817 		  bpf_map__btf_key_type_id(map), bpf_map__btf_value_type_id(map),
4818 		  test->btf_kv_notfound))
4819 		goto done;
4820 
4821 	if (!has_btf_ext)
4822 		goto skip;
4823 
4824 	/* get necessary program info */
4825 	info_len = sizeof(struct bpf_prog_info);
4826 	err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
4827 
4828 	if (CHECK(err < 0, "invalid get info (1st) errno:%d", errno)) {
4829 		fprintf(stderr, "%s\n", btf_log_buf);
4830 		err = -1;
4831 		goto done;
4832 	}
4833 	if (CHECK(info.nr_func_info != 3,
4834 		  "incorrect info.nr_func_info (1st) %d",
4835 		  info.nr_func_info)) {
4836 		err = -1;
4837 		goto done;
4838 	}
4839 	rec_size = info.func_info_rec_size;
4840 	if (CHECK(rec_size != sizeof(struct bpf_func_info),
4841 		  "incorrect info.func_info_rec_size (1st) %d\n", rec_size)) {
4842 		err = -1;
4843 		goto done;
4844 	}
4845 
4846 	func_info = malloc(info.nr_func_info * rec_size);
4847 	if (CHECK(!func_info, "out of memory")) {
4848 		err = -1;
4849 		goto done;
4850 	}
4851 
4852 	/* reset info to only retrieve func_info related data */
4853 	memset(&info, 0, sizeof(info));
4854 	info.nr_func_info = 3;
4855 	info.func_info_rec_size = rec_size;
4856 	info.func_info = ptr_to_u64(func_info);
4857 
4858 	err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
4859 
4860 	if (CHECK(err < 0, "invalid get info (2nd) errno:%d", errno)) {
4861 		fprintf(stderr, "%s\n", btf_log_buf);
4862 		err = -1;
4863 		goto done;
4864 	}
4865 	if (CHECK(info.nr_func_info != 3,
4866 		  "incorrect info.nr_func_info (2nd) %d",
4867 		  info.nr_func_info)) {
4868 		err = -1;
4869 		goto done;
4870 	}
4871 	if (CHECK(info.func_info_rec_size != rec_size,
4872 		  "incorrect info.func_info_rec_size (2nd) %d",
4873 		  info.func_info_rec_size)) {
4874 		err = -1;
4875 		goto done;
4876 	}
4877 
4878 	btf = btf__load_from_kernel_by_id(info.btf_id);
4879 	err = libbpf_get_error(btf);
4880 	if (CHECK(err, "cannot get btf from kernel, err: %d", err))
4881 		goto done;
4882 
4883 	/* check three functions */
4884 	finfo = func_info;
4885 	for (i = 0; i < 3; i++) {
4886 		const struct btf_type *t;
4887 		const char *fname;
4888 
4889 		t = btf__type_by_id(btf, finfo->type_id);
4890 		if (CHECK(!t, "btf__type_by_id failure: id %u",
4891 			  finfo->type_id)) {
4892 			err = -1;
4893 			goto done;
4894 		}
4895 
4896 		fname = btf__name_by_offset(btf, t->name_off);
4897 		err = strcmp(fname, expected_fnames[i]);
4898 		/* for the second and third functions in .text section,
4899 		 * the compiler may order them either way.
4900 		 */
4901 		if (i && err)
4902 			err = strcmp(fname, expected_fnames[3 - i]);
4903 		if (CHECK(err, "incorrect fname %s", fname ? : "")) {
4904 			err = -1;
4905 			goto done;
4906 		}
4907 
4908 		finfo = (void *)finfo + rec_size;
4909 	}
4910 
4911 skip:
4912 	fprintf(stderr, "OK");
4913 
4914 done:
4915 	libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
4916 
4917 	btf__free(btf);
4918 	free(func_info);
4919 	bpf_object__close(obj);
4920 }
4921 
4922 const char *pprint_enum_str[] = {
4923 	"ENUM_ZERO",
4924 	"ENUM_ONE",
4925 	"ENUM_TWO",
4926 	"ENUM_THREE",
4927 };
4928 
4929 struct pprint_mapv {
4930 	uint32_t ui32;
4931 	uint16_t ui16;
4932 	/* 2 bytes hole */
4933 	int32_t si32;
4934 	uint32_t unused_bits2a:2,
4935 		bits28:28,
4936 		unused_bits2b:2;
4937 	union {
4938 		uint64_t ui64;
4939 		uint8_t ui8a[8];
4940 	};
4941 	enum {
4942 		ENUM_ZERO,
4943 		ENUM_ONE,
4944 		ENUM_TWO,
4945 		ENUM_THREE,
4946 	} aenum;
4947 	uint32_t ui32b;
4948 	uint32_t bits2c:2;
4949 	uint8_t si8_4[2][2];
4950 };
4951 
4952 #ifdef __SIZEOF_INT128__
4953 struct pprint_mapv_int128 {
4954 	__int128 si128a;
4955 	__int128 si128b;
4956 	unsigned __int128 bits3:3;
4957 	unsigned __int128 bits80:80;
4958 	unsigned __int128 ui128;
4959 };
4960 #endif
4961 
4962 static struct btf_raw_test pprint_test_template[] = {
4963 {
4964 	.raw_types = {
4965 		/* unsighed char */			/* [1] */
4966 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
4967 		/* unsigned short */			/* [2] */
4968 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
4969 		/* unsigned int */			/* [3] */
4970 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
4971 		/* int */				/* [4] */
4972 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
4973 		/* unsigned long long */		/* [5] */
4974 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
4975 		/* 2 bits */				/* [6] */
4976 		BTF_TYPE_INT_ENC(0, 0, 0, 2, 2),
4977 		/* 28 bits */				/* [7] */
4978 		BTF_TYPE_INT_ENC(0, 0, 0, 28, 4),
4979 		/* uint8_t[8] */			/* [8] */
4980 		BTF_TYPE_ARRAY_ENC(9, 1, 8),
4981 		/* typedef unsigned char uint8_t */	/* [9] */
4982 		BTF_TYPEDEF_ENC(NAME_TBD, 1),
4983 		/* typedef unsigned short uint16_t */	/* [10] */
4984 		BTF_TYPEDEF_ENC(NAME_TBD, 2),
4985 		/* typedef unsigned int uint32_t */	/* [11] */
4986 		BTF_TYPEDEF_ENC(NAME_TBD, 3),
4987 		/* typedef int int32_t */		/* [12] */
4988 		BTF_TYPEDEF_ENC(NAME_TBD, 4),
4989 		/* typedef unsigned long long uint64_t *//* [13] */
4990 		BTF_TYPEDEF_ENC(NAME_TBD, 5),
4991 		/* union (anon) */			/* [14] */
4992 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
4993 		BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
4994 		BTF_MEMBER_ENC(NAME_TBD, 8, 0),	/* uint8_t ui8a[8]; */
4995 		/* enum (anon) */			/* [15] */
4996 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
4997 		BTF_ENUM_ENC(NAME_TBD, 0),
4998 		BTF_ENUM_ENC(NAME_TBD, 1),
4999 		BTF_ENUM_ENC(NAME_TBD, 2),
5000 		BTF_ENUM_ENC(NAME_TBD, 3),
5001 		/* struct pprint_mapv */		/* [16] */
5002 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 11), 40),
5003 		BTF_MEMBER_ENC(NAME_TBD, 11, 0),	/* uint32_t ui32 */
5004 		BTF_MEMBER_ENC(NAME_TBD, 10, 32),	/* uint16_t ui16 */
5005 		BTF_MEMBER_ENC(NAME_TBD, 12, 64),	/* int32_t si32 */
5006 		BTF_MEMBER_ENC(NAME_TBD, 6, 96),	/* unused_bits2a */
5007 		BTF_MEMBER_ENC(NAME_TBD, 7, 98),	/* bits28 */
5008 		BTF_MEMBER_ENC(NAME_TBD, 6, 126),	/* unused_bits2b */
5009 		BTF_MEMBER_ENC(0, 14, 128),		/* union (anon) */
5010 		BTF_MEMBER_ENC(NAME_TBD, 15, 192),	/* aenum */
5011 		BTF_MEMBER_ENC(NAME_TBD, 11, 224),	/* uint32_t ui32b */
5012 		BTF_MEMBER_ENC(NAME_TBD, 6, 256),	/* bits2c */
5013 		BTF_MEMBER_ENC(NAME_TBD, 17, 264),	/* si8_4 */
5014 		BTF_TYPE_ARRAY_ENC(18, 1, 2),		/* [17] */
5015 		BTF_TYPE_ARRAY_ENC(1, 1, 2),		/* [18] */
5016 		BTF_END_RAW,
5017 	},
5018 	BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum\0ui32b\0bits2c\0si8_4"),
5019 	.key_size = sizeof(unsigned int),
5020 	.value_size = sizeof(struct pprint_mapv),
5021 	.key_type_id = 3,	/* unsigned int */
5022 	.value_type_id = 16,	/* struct pprint_mapv */
5023 	.max_entries = 128,
5024 },
5025 
5026 {
5027 	/* this type will have the same type as the
5028 	 * first .raw_types definition, but struct type will
5029 	 * be encoded with kind_flag set.
5030 	 */
5031 	.raw_types = {
5032 		/* unsighed char */			/* [1] */
5033 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
5034 		/* unsigned short */			/* [2] */
5035 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
5036 		/* unsigned int */			/* [3] */
5037 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
5038 		/* int */				/* [4] */
5039 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
5040 		/* unsigned long long */		/* [5] */
5041 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
5042 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),	/* [6] */
5043 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),	/* [7] */
5044 		/* uint8_t[8] */			/* [8] */
5045 		BTF_TYPE_ARRAY_ENC(9, 1, 8),
5046 		/* typedef unsigned char uint8_t */	/* [9] */
5047 		BTF_TYPEDEF_ENC(NAME_TBD, 1),
5048 		/* typedef unsigned short uint16_t */	/* [10] */
5049 		BTF_TYPEDEF_ENC(NAME_TBD, 2),
5050 		/* typedef unsigned int uint32_t */	/* [11] */
5051 		BTF_TYPEDEF_ENC(NAME_TBD, 3),
5052 		/* typedef int int32_t */		/* [12] */
5053 		BTF_TYPEDEF_ENC(NAME_TBD, 4),
5054 		/* typedef unsigned long long uint64_t *//* [13] */
5055 		BTF_TYPEDEF_ENC(NAME_TBD, 5),
5056 		/* union (anon) */			/* [14] */
5057 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
5058 		BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
5059 		BTF_MEMBER_ENC(NAME_TBD, 8, 0),	/* uint8_t ui8a[8]; */
5060 		/* enum (anon) */			/* [15] */
5061 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
5062 		BTF_ENUM_ENC(NAME_TBD, 0),
5063 		BTF_ENUM_ENC(NAME_TBD, 1),
5064 		BTF_ENUM_ENC(NAME_TBD, 2),
5065 		BTF_ENUM_ENC(NAME_TBD, 3),
5066 		/* struct pprint_mapv */		/* [16] */
5067 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 11), 40),
5068 		BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 0)),	/* uint32_t ui32 */
5069 		BTF_MEMBER_ENC(NAME_TBD, 10, BTF_MEMBER_OFFSET(0, 32)),	/* uint16_t ui16 */
5070 		BTF_MEMBER_ENC(NAME_TBD, 12, BTF_MEMBER_OFFSET(0, 64)),	/* int32_t si32 */
5071 		BTF_MEMBER_ENC(NAME_TBD, 6, BTF_MEMBER_OFFSET(2, 96)),	/* unused_bits2a */
5072 		BTF_MEMBER_ENC(NAME_TBD, 7, BTF_MEMBER_OFFSET(28, 98)),	/* bits28 */
5073 		BTF_MEMBER_ENC(NAME_TBD, 6, BTF_MEMBER_OFFSET(2, 126)),	/* unused_bits2b */
5074 		BTF_MEMBER_ENC(0, 14, BTF_MEMBER_OFFSET(0, 128)),	/* union (anon) */
5075 		BTF_MEMBER_ENC(NAME_TBD, 15, BTF_MEMBER_OFFSET(0, 192)),	/* aenum */
5076 		BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 224)),	/* uint32_t ui32b */
5077 		BTF_MEMBER_ENC(NAME_TBD, 6, BTF_MEMBER_OFFSET(2, 256)),	/* bits2c */
5078 		BTF_MEMBER_ENC(NAME_TBD, 17, 264),	/* si8_4 */
5079 		BTF_TYPE_ARRAY_ENC(18, 1, 2),		/* [17] */
5080 		BTF_TYPE_ARRAY_ENC(1, 1, 2),		/* [18] */
5081 		BTF_END_RAW,
5082 	},
5083 	BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum\0ui32b\0bits2c\0si8_4"),
5084 	.key_size = sizeof(unsigned int),
5085 	.value_size = sizeof(struct pprint_mapv),
5086 	.key_type_id = 3,	/* unsigned int */
5087 	.value_type_id = 16,	/* struct pprint_mapv */
5088 	.max_entries = 128,
5089 },
5090 
5091 {
5092 	/* this type will have the same layout as the
5093 	 * first .raw_types definition. The struct type will
5094 	 * be encoded with kind_flag set, bitfield members
5095 	 * are added typedef/const/volatile, and bitfield members
5096 	 * will have both int and enum types.
5097 	 */
5098 	.raw_types = {
5099 		/* unsighed char */			/* [1] */
5100 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
5101 		/* unsigned short */			/* [2] */
5102 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
5103 		/* unsigned int */			/* [3] */
5104 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
5105 		/* int */				/* [4] */
5106 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
5107 		/* unsigned long long */		/* [5] */
5108 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
5109 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),	/* [6] */
5110 		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),	/* [7] */
5111 		/* uint8_t[8] */			/* [8] */
5112 		BTF_TYPE_ARRAY_ENC(9, 1, 8),
5113 		/* typedef unsigned char uint8_t */	/* [9] */
5114 		BTF_TYPEDEF_ENC(NAME_TBD, 1),
5115 		/* typedef unsigned short uint16_t */	/* [10] */
5116 		BTF_TYPEDEF_ENC(NAME_TBD, 2),
5117 		/* typedef unsigned int uint32_t */	/* [11] */
5118 		BTF_TYPEDEF_ENC(NAME_TBD, 3),
5119 		/* typedef int int32_t */		/* [12] */
5120 		BTF_TYPEDEF_ENC(NAME_TBD, 4),
5121 		/* typedef unsigned long long uint64_t *//* [13] */
5122 		BTF_TYPEDEF_ENC(NAME_TBD, 5),
5123 		/* union (anon) */			/* [14] */
5124 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
5125 		BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
5126 		BTF_MEMBER_ENC(NAME_TBD, 8, 0),	/* uint8_t ui8a[8]; */
5127 		/* enum (anon) */			/* [15] */
5128 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
5129 		BTF_ENUM_ENC(NAME_TBD, 0),
5130 		BTF_ENUM_ENC(NAME_TBD, 1),
5131 		BTF_ENUM_ENC(NAME_TBD, 2),
5132 		BTF_ENUM_ENC(NAME_TBD, 3),
5133 		/* struct pprint_mapv */		/* [16] */
5134 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 11), 40),
5135 		BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 0)),	/* uint32_t ui32 */
5136 		BTF_MEMBER_ENC(NAME_TBD, 10, BTF_MEMBER_OFFSET(0, 32)),	/* uint16_t ui16 */
5137 		BTF_MEMBER_ENC(NAME_TBD, 12, BTF_MEMBER_OFFSET(0, 64)),	/* int32_t si32 */
5138 		BTF_MEMBER_ENC(NAME_TBD, 17, BTF_MEMBER_OFFSET(2, 96)),	/* unused_bits2a */
5139 		BTF_MEMBER_ENC(NAME_TBD, 7, BTF_MEMBER_OFFSET(28, 98)),	/* bits28 */
5140 		BTF_MEMBER_ENC(NAME_TBD, 19, BTF_MEMBER_OFFSET(2, 126)),/* unused_bits2b */
5141 		BTF_MEMBER_ENC(0, 14, BTF_MEMBER_OFFSET(0, 128)),	/* union (anon) */
5142 		BTF_MEMBER_ENC(NAME_TBD, 15, BTF_MEMBER_OFFSET(0, 192)),	/* aenum */
5143 		BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 224)),	/* uint32_t ui32b */
5144 		BTF_MEMBER_ENC(NAME_TBD, 17, BTF_MEMBER_OFFSET(2, 256)),	/* bits2c */
5145 		BTF_MEMBER_ENC(NAME_TBD, 20, BTF_MEMBER_OFFSET(0, 264)),	/* si8_4 */
5146 		/* typedef unsigned int ___int */	/* [17] */
5147 		BTF_TYPEDEF_ENC(NAME_TBD, 18),
5148 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_VOLATILE, 0, 0), 6),	/* [18] */
5149 		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 15),	/* [19] */
5150 		BTF_TYPE_ARRAY_ENC(21, 1, 2),					/* [20] */
5151 		BTF_TYPE_ARRAY_ENC(1, 1, 2),					/* [21] */
5152 		BTF_END_RAW,
5153 	},
5154 	BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum\0ui32b\0bits2c\0___int\0si8_4"),
5155 	.key_size = sizeof(unsigned int),
5156 	.value_size = sizeof(struct pprint_mapv),
5157 	.key_type_id = 3,	/* unsigned int */
5158 	.value_type_id = 16,	/* struct pprint_mapv */
5159 	.max_entries = 128,
5160 },
5161 
5162 #ifdef __SIZEOF_INT128__
5163 {
5164 	/* test int128 */
5165 	.raw_types = {
5166 		/* unsigned int */				/* [1] */
5167 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
5168 		/* __int128 */					/* [2] */
5169 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 128, 16),
5170 		/* unsigned __int128 */				/* [3] */
5171 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 128, 16),
5172 		/* struct pprint_mapv_int128 */			/* [4] */
5173 		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 5), 64),
5174 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),		/* si128a */
5175 		BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 128)),		/* si128b */
5176 		BTF_MEMBER_ENC(NAME_TBD, 3, BTF_MEMBER_OFFSET(3, 256)),		/* bits3 */
5177 		BTF_MEMBER_ENC(NAME_TBD, 3, BTF_MEMBER_OFFSET(80, 259)),	/* bits80 */
5178 		BTF_MEMBER_ENC(NAME_TBD, 3, BTF_MEMBER_OFFSET(0, 384)),		/* ui128 */
5179 		BTF_END_RAW,
5180 	},
5181 	BTF_STR_SEC("\0unsigned int\0__int128\0unsigned __int128\0pprint_mapv_int128\0si128a\0si128b\0bits3\0bits80\0ui128"),
5182 	.key_size = sizeof(unsigned int),
5183 	.value_size = sizeof(struct pprint_mapv_int128),
5184 	.key_type_id = 1,
5185 	.value_type_id = 4,
5186 	.max_entries = 128,
5187 	.mapv_kind = PPRINT_MAPV_KIND_INT128,
5188 },
5189 #endif
5190 
5191 };
5192 
5193 static struct btf_pprint_test_meta {
5194 	const char *descr;
5195 	enum bpf_map_type map_type;
5196 	const char *map_name;
5197 	bool ordered_map;
5198 	bool lossless_map;
5199 	bool percpu_map;
5200 } pprint_tests_meta[] = {
5201 {
5202 	.descr = "BTF pretty print array",
5203 	.map_type = BPF_MAP_TYPE_ARRAY,
5204 	.map_name = "pprint_test_array",
5205 	.ordered_map = true,
5206 	.lossless_map = true,
5207 	.percpu_map = false,
5208 },
5209 
5210 {
5211 	.descr = "BTF pretty print hash",
5212 	.map_type = BPF_MAP_TYPE_HASH,
5213 	.map_name = "pprint_test_hash",
5214 	.ordered_map = false,
5215 	.lossless_map = true,
5216 	.percpu_map = false,
5217 },
5218 
5219 {
5220 	.descr = "BTF pretty print lru hash",
5221 	.map_type = BPF_MAP_TYPE_LRU_HASH,
5222 	.map_name = "pprint_test_lru_hash",
5223 	.ordered_map = false,
5224 	.lossless_map = false,
5225 	.percpu_map = false,
5226 },
5227 
5228 {
5229 	.descr = "BTF pretty print percpu array",
5230 	.map_type = BPF_MAP_TYPE_PERCPU_ARRAY,
5231 	.map_name = "pprint_test_percpu_array",
5232 	.ordered_map = true,
5233 	.lossless_map = true,
5234 	.percpu_map = true,
5235 },
5236 
5237 {
5238 	.descr = "BTF pretty print percpu hash",
5239 	.map_type = BPF_MAP_TYPE_PERCPU_HASH,
5240 	.map_name = "pprint_test_percpu_hash",
5241 	.ordered_map = false,
5242 	.lossless_map = true,
5243 	.percpu_map = true,
5244 },
5245 
5246 {
5247 	.descr = "BTF pretty print lru percpu hash",
5248 	.map_type = BPF_MAP_TYPE_LRU_PERCPU_HASH,
5249 	.map_name = "pprint_test_lru_percpu_hash",
5250 	.ordered_map = false,
5251 	.lossless_map = false,
5252 	.percpu_map = true,
5253 },
5254 
5255 };
5256 
5257 static size_t get_pprint_mapv_size(enum pprint_mapv_kind_t mapv_kind)
5258 {
5259 	if (mapv_kind == PPRINT_MAPV_KIND_BASIC)
5260 		return sizeof(struct pprint_mapv);
5261 
5262 #ifdef __SIZEOF_INT128__
5263 	if (mapv_kind == PPRINT_MAPV_KIND_INT128)
5264 		return sizeof(struct pprint_mapv_int128);
5265 #endif
5266 
5267 	assert(0);
5268 }
5269 
5270 static void set_pprint_mapv(enum pprint_mapv_kind_t mapv_kind,
5271 			    void *mapv, uint32_t i,
5272 			    int num_cpus, int rounded_value_size)
5273 {
5274 	int cpu;
5275 
5276 	if (mapv_kind == PPRINT_MAPV_KIND_BASIC) {
5277 		struct pprint_mapv *v = mapv;
5278 
5279 		for (cpu = 0; cpu < num_cpus; cpu++) {
5280 			v->ui32 = i + cpu;
5281 			v->si32 = -i;
5282 			v->unused_bits2a = 3;
5283 			v->bits28 = i;
5284 			v->unused_bits2b = 3;
5285 			v->ui64 = i;
5286 			v->aenum = i & 0x03;
5287 			v->ui32b = 4;
5288 			v->bits2c = 1;
5289 			v->si8_4[0][0] = (cpu + i) & 0xff;
5290 			v->si8_4[0][1] = (cpu + i + 1) & 0xff;
5291 			v->si8_4[1][0] = (cpu + i + 2) & 0xff;
5292 			v->si8_4[1][1] = (cpu + i + 3) & 0xff;
5293 			v = (void *)v + rounded_value_size;
5294 		}
5295 	}
5296 
5297 #ifdef __SIZEOF_INT128__
5298 	if (mapv_kind == PPRINT_MAPV_KIND_INT128) {
5299 		struct pprint_mapv_int128 *v = mapv;
5300 
5301 		for (cpu = 0; cpu < num_cpus; cpu++) {
5302 			v->si128a = i;
5303 			v->si128b = -i;
5304 			v->bits3 = i & 0x07;
5305 			v->bits80 = (((unsigned __int128)1) << 64) + i;
5306 			v->ui128 = (((unsigned __int128)2) << 64) + i;
5307 			v = (void *)v + rounded_value_size;
5308 		}
5309 	}
5310 #endif
5311 }
5312 
5313 ssize_t get_pprint_expected_line(enum pprint_mapv_kind_t mapv_kind,
5314 				 char *expected_line, ssize_t line_size,
5315 				 bool percpu_map, unsigned int next_key,
5316 				 int cpu, void *mapv)
5317 {
5318 	ssize_t nexpected_line = -1;
5319 
5320 	if (mapv_kind == PPRINT_MAPV_KIND_BASIC) {
5321 		struct pprint_mapv *v = mapv;
5322 
5323 		nexpected_line = snprintf(expected_line, line_size,
5324 					  "%s%u: {%u,0,%d,0x%x,0x%x,0x%x,"
5325 					  "{%llu|[%u,%u,%u,%u,%u,%u,%u,%u]},%s,"
5326 					  "%u,0x%x,[[%d,%d],[%d,%d]]}\n",
5327 					  percpu_map ? "\tcpu" : "",
5328 					  percpu_map ? cpu : next_key,
5329 					  v->ui32, v->si32,
5330 					  v->unused_bits2a,
5331 					  v->bits28,
5332 					  v->unused_bits2b,
5333 					  (__u64)v->ui64,
5334 					  v->ui8a[0], v->ui8a[1],
5335 					  v->ui8a[2], v->ui8a[3],
5336 					  v->ui8a[4], v->ui8a[5],
5337 					  v->ui8a[6], v->ui8a[7],
5338 					  pprint_enum_str[v->aenum],
5339 					  v->ui32b,
5340 					  v->bits2c,
5341 					  v->si8_4[0][0], v->si8_4[0][1],
5342 					  v->si8_4[1][0], v->si8_4[1][1]);
5343 	}
5344 
5345 #ifdef __SIZEOF_INT128__
5346 	if (mapv_kind == PPRINT_MAPV_KIND_INT128) {
5347 		struct pprint_mapv_int128 *v = mapv;
5348 
5349 		nexpected_line = snprintf(expected_line, line_size,
5350 					  "%s%u: {0x%lx,0x%lx,0x%lx,"
5351 					  "0x%lx%016lx,0x%lx%016lx}\n",
5352 					  percpu_map ? "\tcpu" : "",
5353 					  percpu_map ? cpu : next_key,
5354 					  (uint64_t)v->si128a,
5355 					  (uint64_t)v->si128b,
5356 					  (uint64_t)v->bits3,
5357 					  (uint64_t)(v->bits80 >> 64),
5358 					  (uint64_t)v->bits80,
5359 					  (uint64_t)(v->ui128 >> 64),
5360 					  (uint64_t)v->ui128);
5361 	}
5362 #endif
5363 
5364 	return nexpected_line;
5365 }
5366 
5367 static int check_line(const char *expected_line, int nexpected_line,
5368 		      int expected_line_len, const char *line)
5369 {
5370 	if (CHECK(nexpected_line == expected_line_len,
5371 		  "expected_line is too long"))
5372 		return -1;
5373 
5374 	if (strcmp(expected_line, line)) {
5375 		fprintf(stderr, "unexpected pprint output\n");
5376 		fprintf(stderr, "expected: %s", expected_line);
5377 		fprintf(stderr, "    read: %s", line);
5378 		return -1;
5379 	}
5380 
5381 	return 0;
5382 }
5383 
5384 
5385 static void do_test_pprint(int test_num)
5386 {
5387 	const struct btf_raw_test *test = &pprint_test_template[test_num];
5388 	enum pprint_mapv_kind_t mapv_kind = test->mapv_kind;
5389 	LIBBPF_OPTS(bpf_map_create_opts, opts);
5390 	bool ordered_map, lossless_map, percpu_map;
5391 	int err, ret, num_cpus, rounded_value_size;
5392 	unsigned int key, nr_read_elems;
5393 	int map_fd = -1, btf_fd = -1;
5394 	unsigned int raw_btf_size;
5395 	char expected_line[255];
5396 	FILE *pin_file = NULL;
5397 	char pin_path[255];
5398 	size_t line_len = 0;
5399 	char *line = NULL;
5400 	void *mapv = NULL;
5401 	uint8_t *raw_btf;
5402 	ssize_t nread;
5403 
5404 	if (!test__start_subtest(test->descr))
5405 		return;
5406 
5407 	raw_btf = btf_raw_create(&hdr_tmpl, test->raw_types,
5408 				 test->str_sec, test->str_sec_size,
5409 				 &raw_btf_size, NULL);
5410 
5411 	if (!raw_btf)
5412 		return;
5413 
5414 	*btf_log_buf = '\0';
5415 	btf_fd = load_raw_btf(raw_btf, raw_btf_size);
5416 	free(raw_btf);
5417 
5418 	if (CHECK(btf_fd < 0, "errno:%d\n", errno)) {
5419 		err = -1;
5420 		goto done;
5421 	}
5422 
5423 	opts.btf_fd = btf_fd;
5424 	opts.btf_key_type_id = test->key_type_id;
5425 	opts.btf_value_type_id = test->value_type_id;
5426 	map_fd = bpf_map_create(test->map_type, test->map_name,
5427 				test->key_size, test->value_size, test->max_entries, &opts);
5428 	if (CHECK(map_fd < 0, "errno:%d", errno)) {
5429 		err = -1;
5430 		goto done;
5431 	}
5432 
5433 	ret = snprintf(pin_path, sizeof(pin_path), "%s/%s",
5434 		       "/sys/fs/bpf", test->map_name);
5435 
5436 	if (CHECK(ret >= sizeof(pin_path), "pin_path %s/%s is too long",
5437 		  "/sys/fs/bpf", test->map_name)) {
5438 		err = -1;
5439 		goto done;
5440 	}
5441 
5442 	err = bpf_obj_pin(map_fd, pin_path);
5443 	if (CHECK(err, "bpf_obj_pin(%s): errno:%d.", pin_path, errno))
5444 		goto done;
5445 
5446 	percpu_map = test->percpu_map;
5447 	num_cpus = percpu_map ? bpf_num_possible_cpus() : 1;
5448 	rounded_value_size = round_up(get_pprint_mapv_size(mapv_kind), 8);
5449 	mapv = calloc(num_cpus, rounded_value_size);
5450 	if (CHECK(!mapv, "mapv allocation failure")) {
5451 		err = -1;
5452 		goto done;
5453 	}
5454 
5455 	for (key = 0; key < test->max_entries; key++) {
5456 		set_pprint_mapv(mapv_kind, mapv, key, num_cpus, rounded_value_size);
5457 		bpf_map_update_elem(map_fd, &key, mapv, 0);
5458 	}
5459 
5460 	pin_file = fopen(pin_path, "r");
5461 	if (CHECK(!pin_file, "fopen(%s): errno:%d", pin_path, errno)) {
5462 		err = -1;
5463 		goto done;
5464 	}
5465 
5466 	/* Skip lines start with '#' */
5467 	while ((nread = getline(&line, &line_len, pin_file)) > 0 &&
5468 	       *line == '#')
5469 		;
5470 
5471 	if (CHECK(nread <= 0, "Unexpected EOF")) {
5472 		err = -1;
5473 		goto done;
5474 	}
5475 
5476 	nr_read_elems = 0;
5477 	ordered_map = test->ordered_map;
5478 	lossless_map = test->lossless_map;
5479 	do {
5480 		ssize_t nexpected_line;
5481 		unsigned int next_key;
5482 		void *cmapv;
5483 		int cpu;
5484 
5485 		next_key = ordered_map ? nr_read_elems : atoi(line);
5486 		set_pprint_mapv(mapv_kind, mapv, next_key, num_cpus, rounded_value_size);
5487 		cmapv = mapv;
5488 
5489 		for (cpu = 0; cpu < num_cpus; cpu++) {
5490 			if (percpu_map) {
5491 				/* for percpu map, the format looks like:
5492 				 * <key>: {
5493 				 *	cpu0: <value_on_cpu0>
5494 				 *	cpu1: <value_on_cpu1>
5495 				 *	...
5496 				 *	cpun: <value_on_cpun>
5497 				 * }
5498 				 *
5499 				 * let us verify the line containing the key here.
5500 				 */
5501 				if (cpu == 0) {
5502 					nexpected_line = snprintf(expected_line,
5503 								  sizeof(expected_line),
5504 								  "%u: {\n",
5505 								  next_key);
5506 
5507 					err = check_line(expected_line, nexpected_line,
5508 							 sizeof(expected_line), line);
5509 					if (err < 0)
5510 						goto done;
5511 				}
5512 
5513 				/* read value@cpu */
5514 				nread = getline(&line, &line_len, pin_file);
5515 				if (nread < 0)
5516 					break;
5517 			}
5518 
5519 			nexpected_line = get_pprint_expected_line(mapv_kind, expected_line,
5520 								  sizeof(expected_line),
5521 								  percpu_map, next_key,
5522 								  cpu, cmapv);
5523 			err = check_line(expected_line, nexpected_line,
5524 					 sizeof(expected_line), line);
5525 			if (err < 0)
5526 				goto done;
5527 
5528 			cmapv = cmapv + rounded_value_size;
5529 		}
5530 
5531 		if (percpu_map) {
5532 			/* skip the last bracket for the percpu map */
5533 			nread = getline(&line, &line_len, pin_file);
5534 			if (nread < 0)
5535 				break;
5536 		}
5537 
5538 		nread = getline(&line, &line_len, pin_file);
5539 	} while (++nr_read_elems < test->max_entries && nread > 0);
5540 
5541 	if (lossless_map &&
5542 	    CHECK(nr_read_elems < test->max_entries,
5543 		  "Unexpected EOF. nr_read_elems:%u test->max_entries:%u",
5544 		  nr_read_elems, test->max_entries)) {
5545 		err = -1;
5546 		goto done;
5547 	}
5548 
5549 	if (CHECK(nread > 0, "Unexpected extra pprint output: %s", line)) {
5550 		err = -1;
5551 		goto done;
5552 	}
5553 
5554 	err = 0;
5555 
5556 done:
5557 	if (mapv)
5558 		free(mapv);
5559 	if (!err)
5560 		fprintf(stderr, "OK");
5561 	if (*btf_log_buf && (err || always_log))
5562 		fprintf(stderr, "\n%s", btf_log_buf);
5563 	if (btf_fd >= 0)
5564 		close(btf_fd);
5565 	if (map_fd >= 0)
5566 		close(map_fd);
5567 	if (pin_file)
5568 		fclose(pin_file);
5569 	unlink(pin_path);
5570 	free(line);
5571 }
5572 
5573 static void test_pprint(void)
5574 {
5575 	unsigned int i;
5576 
5577 	/* test various maps with the first test template */
5578 	for (i = 0; i < ARRAY_SIZE(pprint_tests_meta); i++) {
5579 		pprint_test_template[0].descr = pprint_tests_meta[i].descr;
5580 		pprint_test_template[0].map_type = pprint_tests_meta[i].map_type;
5581 		pprint_test_template[0].map_name = pprint_tests_meta[i].map_name;
5582 		pprint_test_template[0].ordered_map = pprint_tests_meta[i].ordered_map;
5583 		pprint_test_template[0].lossless_map = pprint_tests_meta[i].lossless_map;
5584 		pprint_test_template[0].percpu_map = pprint_tests_meta[i].percpu_map;
5585 
5586 		do_test_pprint(0);
5587 	}
5588 
5589 	/* test rest test templates with the first map */
5590 	for (i = 1; i < ARRAY_SIZE(pprint_test_template); i++) {
5591 		pprint_test_template[i].descr = pprint_tests_meta[0].descr;
5592 		pprint_test_template[i].map_type = pprint_tests_meta[0].map_type;
5593 		pprint_test_template[i].map_name = pprint_tests_meta[0].map_name;
5594 		pprint_test_template[i].ordered_map = pprint_tests_meta[0].ordered_map;
5595 		pprint_test_template[i].lossless_map = pprint_tests_meta[0].lossless_map;
5596 		pprint_test_template[i].percpu_map = pprint_tests_meta[0].percpu_map;
5597 		do_test_pprint(i);
5598 	}
5599 }
5600 
5601 #define BPF_LINE_INFO_ENC(insn_off, file_off, line_off, line_num, line_col) \
5602 	(insn_off), (file_off), (line_off), ((line_num) << 10 | ((line_col) & 0x3ff))
5603 
5604 static struct prog_info_raw_test {
5605 	const char *descr;
5606 	const char *str_sec;
5607 	const char *err_str;
5608 	__u32 raw_types[MAX_NR_RAW_U32];
5609 	__u32 str_sec_size;
5610 	struct bpf_insn insns[MAX_INSNS];
5611 	__u32 prog_type;
5612 	__u32 func_info[MAX_SUBPROGS][2];
5613 	__u32 func_info_rec_size;
5614 	__u32 func_info_cnt;
5615 	__u32 line_info[MAX_NR_RAW_U32];
5616 	__u32 line_info_rec_size;
5617 	__u32 nr_jited_ksyms;
5618 	bool expected_prog_load_failure;
5619 	__u32 dead_code_cnt;
5620 	__u32 dead_code_mask;
5621 	__u32 dead_func_cnt;
5622 	__u32 dead_func_mask;
5623 } info_raw_tests[] = {
5624 {
5625 	.descr = "func_type (main func + one sub)",
5626 	.raw_types = {
5627 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5628 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),	/* [2] */
5629 		BTF_FUNC_PROTO_ENC(1, 2),			/* [3] */
5630 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5631 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5632 		BTF_FUNC_PROTO_ENC(1, 2),			/* [4] */
5633 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5634 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5635 		BTF_FUNC_ENC(NAME_TBD, 3),			/* [5] */
5636 		BTF_FUNC_ENC(NAME_TBD, 4),			/* [6] */
5637 		BTF_END_RAW,
5638 	},
5639 	.str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
5640 	.str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
5641 	.insns = {
5642 		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
5643 		BPF_MOV64_IMM(BPF_REG_0, 1),
5644 		BPF_EXIT_INSN(),
5645 		BPF_MOV64_IMM(BPF_REG_0, 2),
5646 		BPF_EXIT_INSN(),
5647 	},
5648 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5649 	.func_info = { {0, 5}, {3, 6} },
5650 	.func_info_rec_size = 8,
5651 	.func_info_cnt = 2,
5652 	.line_info = { BTF_END_RAW },
5653 },
5654 
5655 {
5656 	.descr = "func_type (Incorrect func_info_rec_size)",
5657 	.raw_types = {
5658 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5659 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),	/* [2] */
5660 		BTF_FUNC_PROTO_ENC(1, 2),			/* [3] */
5661 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5662 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5663 		BTF_FUNC_PROTO_ENC(1, 2),			/* [4] */
5664 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5665 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5666 		BTF_FUNC_ENC(NAME_TBD, 3),			/* [5] */
5667 		BTF_FUNC_ENC(NAME_TBD, 4),			/* [6] */
5668 		BTF_END_RAW,
5669 	},
5670 	.str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
5671 	.str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
5672 	.insns = {
5673 		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
5674 		BPF_MOV64_IMM(BPF_REG_0, 1),
5675 		BPF_EXIT_INSN(),
5676 		BPF_MOV64_IMM(BPF_REG_0, 2),
5677 		BPF_EXIT_INSN(),
5678 	},
5679 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5680 	.func_info = { {0, 5}, {3, 6} },
5681 	.func_info_rec_size = 4,
5682 	.func_info_cnt = 2,
5683 	.line_info = { BTF_END_RAW },
5684 	.expected_prog_load_failure = true,
5685 },
5686 
5687 {
5688 	.descr = "func_type (Incorrect func_info_cnt)",
5689 	.raw_types = {
5690 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5691 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),	/* [2] */
5692 		BTF_FUNC_PROTO_ENC(1, 2),			/* [3] */
5693 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5694 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5695 		BTF_FUNC_PROTO_ENC(1, 2),			/* [4] */
5696 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5697 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5698 		BTF_FUNC_ENC(NAME_TBD, 3),			/* [5] */
5699 		BTF_FUNC_ENC(NAME_TBD, 4),			/* [6] */
5700 		BTF_END_RAW,
5701 	},
5702 	.str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
5703 	.str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
5704 	.insns = {
5705 		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
5706 		BPF_MOV64_IMM(BPF_REG_0, 1),
5707 		BPF_EXIT_INSN(),
5708 		BPF_MOV64_IMM(BPF_REG_0, 2),
5709 		BPF_EXIT_INSN(),
5710 	},
5711 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5712 	.func_info = { {0, 5}, {3, 6} },
5713 	.func_info_rec_size = 8,
5714 	.func_info_cnt = 1,
5715 	.line_info = { BTF_END_RAW },
5716 	.expected_prog_load_failure = true,
5717 },
5718 
5719 {
5720 	.descr = "func_type (Incorrect bpf_func_info.insn_off)",
5721 	.raw_types = {
5722 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5723 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),	/* [2] */
5724 		BTF_FUNC_PROTO_ENC(1, 2),			/* [3] */
5725 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5726 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5727 		BTF_FUNC_PROTO_ENC(1, 2),			/* [4] */
5728 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5729 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5730 		BTF_FUNC_ENC(NAME_TBD, 3),			/* [5] */
5731 		BTF_FUNC_ENC(NAME_TBD, 4),			/* [6] */
5732 		BTF_END_RAW,
5733 	},
5734 	.str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
5735 	.str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
5736 	.insns = {
5737 		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
5738 		BPF_MOV64_IMM(BPF_REG_0, 1),
5739 		BPF_EXIT_INSN(),
5740 		BPF_MOV64_IMM(BPF_REG_0, 2),
5741 		BPF_EXIT_INSN(),
5742 	},
5743 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5744 	.func_info = { {0, 5}, {2, 6} },
5745 	.func_info_rec_size = 8,
5746 	.func_info_cnt = 2,
5747 	.line_info = { BTF_END_RAW },
5748 	.expected_prog_load_failure = true,
5749 },
5750 
5751 {
5752 	.descr = "line_info (No subprog)",
5753 	.raw_types = {
5754 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5755 		BTF_END_RAW,
5756 	},
5757 	BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
5758 	.insns = {
5759 		BPF_MOV64_IMM(BPF_REG_0, 1),
5760 		BPF_MOV64_IMM(BPF_REG_1, 2),
5761 		BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
5762 		BPF_EXIT_INSN(),
5763 	},
5764 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5765 	.func_info_cnt = 0,
5766 	.line_info = {
5767 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
5768 		BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9),
5769 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
5770 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7),
5771 		BTF_END_RAW,
5772 	},
5773 	.line_info_rec_size = sizeof(struct bpf_line_info),
5774 	.nr_jited_ksyms = 1,
5775 },
5776 
5777 {
5778 	.descr = "line_info (No subprog. insn_off >= prog->len)",
5779 	.raw_types = {
5780 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5781 		BTF_END_RAW,
5782 	},
5783 	BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
5784 	.insns = {
5785 		BPF_MOV64_IMM(BPF_REG_0, 1),
5786 		BPF_MOV64_IMM(BPF_REG_1, 2),
5787 		BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
5788 		BPF_EXIT_INSN(),
5789 	},
5790 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5791 	.func_info_cnt = 0,
5792 	.line_info = {
5793 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
5794 		BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9),
5795 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
5796 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7),
5797 		BPF_LINE_INFO_ENC(4, 0, 0, 5, 6),
5798 		BTF_END_RAW,
5799 	},
5800 	.line_info_rec_size = sizeof(struct bpf_line_info),
5801 	.nr_jited_ksyms = 1,
5802 	.err_str = "line_info[4].insn_off",
5803 	.expected_prog_load_failure = true,
5804 },
5805 
5806 {
5807 	.descr = "line_info (Zero bpf insn code)",
5808 	.raw_types = {
5809 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5810 		BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),	/* [2] */
5811 		BTF_TYPEDEF_ENC(NAME_TBD, 2),			/* [3] */
5812 		BTF_END_RAW,
5813 	},
5814 	BTF_STR_SEC("\0int\0unsigned long\0u64\0u64 a=1;\0return a;"),
5815 	.insns = {
5816 		BPF_LD_IMM64(BPF_REG_0, 1),
5817 		BPF_EXIT_INSN(),
5818 	},
5819 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5820 	.func_info_cnt = 0,
5821 	.line_info = {
5822 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
5823 		BPF_LINE_INFO_ENC(1, 0, 0, 2, 9),
5824 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
5825 		BTF_END_RAW,
5826 	},
5827 	.line_info_rec_size = sizeof(struct bpf_line_info),
5828 	.nr_jited_ksyms = 1,
5829 	.err_str = "Invalid insn code at line_info[1]",
5830 	.expected_prog_load_failure = true,
5831 },
5832 
5833 {
5834 	.descr = "line_info (No subprog. zero tailing line_info",
5835 	.raw_types = {
5836 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5837 		BTF_END_RAW,
5838 	},
5839 	BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
5840 	.insns = {
5841 		BPF_MOV64_IMM(BPF_REG_0, 1),
5842 		BPF_MOV64_IMM(BPF_REG_1, 2),
5843 		BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
5844 		BPF_EXIT_INSN(),
5845 	},
5846 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5847 	.func_info_cnt = 0,
5848 	.line_info = {
5849 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10), 0,
5850 		BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9), 0,
5851 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8), 0,
5852 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7), 0,
5853 		BTF_END_RAW,
5854 	},
5855 	.line_info_rec_size = sizeof(struct bpf_line_info) + sizeof(__u32),
5856 	.nr_jited_ksyms = 1,
5857 },
5858 
5859 {
5860 	.descr = "line_info (No subprog. nonzero tailing line_info)",
5861 	.raw_types = {
5862 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5863 		BTF_END_RAW,
5864 	},
5865 	BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
5866 	.insns = {
5867 		BPF_MOV64_IMM(BPF_REG_0, 1),
5868 		BPF_MOV64_IMM(BPF_REG_1, 2),
5869 		BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
5870 		BPF_EXIT_INSN(),
5871 	},
5872 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5873 	.func_info_cnt = 0,
5874 	.line_info = {
5875 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10), 0,
5876 		BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9), 0,
5877 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8), 0,
5878 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7), 1,
5879 		BTF_END_RAW,
5880 	},
5881 	.line_info_rec_size = sizeof(struct bpf_line_info) + sizeof(__u32),
5882 	.nr_jited_ksyms = 1,
5883 	.err_str = "nonzero tailing record in line_info",
5884 	.expected_prog_load_failure = true,
5885 },
5886 
5887 {
5888 	.descr = "line_info (subprog)",
5889 	.raw_types = {
5890 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5891 		BTF_END_RAW,
5892 	},
5893 	BTF_STR_SEC("\0int\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
5894 	.insns = {
5895 		BPF_MOV64_IMM(BPF_REG_2, 1),
5896 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
5897 		BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
5898 		BPF_CALL_REL(1),
5899 		BPF_EXIT_INSN(),
5900 		BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
5901 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
5902 		BPF_EXIT_INSN(),
5903 	},
5904 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5905 	.func_info_cnt = 0,
5906 	.line_info = {
5907 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
5908 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 2, 9),
5909 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 3, 8),
5910 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
5911 		BTF_END_RAW,
5912 	},
5913 	.line_info_rec_size = sizeof(struct bpf_line_info),
5914 	.nr_jited_ksyms = 2,
5915 },
5916 
5917 {
5918 	.descr = "line_info (subprog + func_info)",
5919 	.raw_types = {
5920 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5921 		BTF_FUNC_PROTO_ENC(1, 1),			/* [2] */
5922 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5923 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
5924 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [4] */
5925 		BTF_END_RAW,
5926 	},
5927 	BTF_STR_SEC("\0int\0x\0sub\0main\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
5928 	.insns = {
5929 		BPF_MOV64_IMM(BPF_REG_2, 1),
5930 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
5931 		BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
5932 		BPF_CALL_REL(1),
5933 		BPF_EXIT_INSN(),
5934 		BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
5935 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
5936 		BPF_EXIT_INSN(),
5937 	},
5938 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5939 	.func_info_cnt = 2,
5940 	.func_info_rec_size = 8,
5941 	.func_info = { {0, 4}, {5, 3} },
5942 	.line_info = {
5943 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
5944 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 2, 9),
5945 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 3, 8),
5946 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
5947 		BTF_END_RAW,
5948 	},
5949 	.line_info_rec_size = sizeof(struct bpf_line_info),
5950 	.nr_jited_ksyms = 2,
5951 },
5952 
5953 {
5954 	.descr = "line_info (subprog. missing 1st func line info)",
5955 	.raw_types = {
5956 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5957 		BTF_END_RAW,
5958 	},
5959 	BTF_STR_SEC("\0int\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
5960 	.insns = {
5961 		BPF_MOV64_IMM(BPF_REG_2, 1),
5962 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
5963 		BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
5964 		BPF_CALL_REL(1),
5965 		BPF_EXIT_INSN(),
5966 		BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
5967 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
5968 		BPF_EXIT_INSN(),
5969 	},
5970 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
5971 	.func_info_cnt = 0,
5972 	.line_info = {
5973 		BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 1, 10),
5974 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 2, 9),
5975 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 3, 8),
5976 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
5977 		BTF_END_RAW,
5978 	},
5979 	.line_info_rec_size = sizeof(struct bpf_line_info),
5980 	.nr_jited_ksyms = 2,
5981 	.err_str = "missing bpf_line_info for func#0",
5982 	.expected_prog_load_failure = true,
5983 },
5984 
5985 {
5986 	.descr = "line_info (subprog. missing 2nd func line info)",
5987 	.raw_types = {
5988 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
5989 		BTF_END_RAW,
5990 	},
5991 	BTF_STR_SEC("\0int\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
5992 	.insns = {
5993 		BPF_MOV64_IMM(BPF_REG_2, 1),
5994 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
5995 		BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
5996 		BPF_CALL_REL(1),
5997 		BPF_EXIT_INSN(),
5998 		BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
5999 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6000 		BPF_EXIT_INSN(),
6001 	},
6002 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6003 	.func_info_cnt = 0,
6004 	.line_info = {
6005 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6006 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 2, 9),
6007 		BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 3, 8),
6008 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
6009 		BTF_END_RAW,
6010 	},
6011 	.line_info_rec_size = sizeof(struct bpf_line_info),
6012 	.nr_jited_ksyms = 2,
6013 	.err_str = "missing bpf_line_info for func#1",
6014 	.expected_prog_load_failure = true,
6015 },
6016 
6017 {
6018 	.descr = "line_info (subprog. unordered insn offset)",
6019 	.raw_types = {
6020 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6021 		BTF_END_RAW,
6022 	},
6023 	BTF_STR_SEC("\0int\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
6024 	.insns = {
6025 		BPF_MOV64_IMM(BPF_REG_2, 1),
6026 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
6027 		BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
6028 		BPF_CALL_REL(1),
6029 		BPF_EXIT_INSN(),
6030 		BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
6031 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6032 		BPF_EXIT_INSN(),
6033 	},
6034 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6035 	.func_info_cnt = 0,
6036 	.line_info = {
6037 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6038 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 2, 9),
6039 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
6040 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
6041 		BTF_END_RAW,
6042 	},
6043 	.line_info_rec_size = sizeof(struct bpf_line_info),
6044 	.nr_jited_ksyms = 2,
6045 	.err_str = "Invalid line_info[2].insn_off",
6046 	.expected_prog_load_failure = true,
6047 },
6048 
6049 {
6050 	.descr = "line_info (dead start)",
6051 	.raw_types = {
6052 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6053 		BTF_END_RAW,
6054 	},
6055 	BTF_STR_SEC("\0int\0/* dead jmp */\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
6056 	.insns = {
6057 		BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6058 		BPF_MOV64_IMM(BPF_REG_0, 1),
6059 		BPF_MOV64_IMM(BPF_REG_1, 2),
6060 		BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
6061 		BPF_EXIT_INSN(),
6062 	},
6063 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6064 	.func_info_cnt = 0,
6065 	.line_info = {
6066 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6067 		BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9),
6068 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
6069 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7),
6070 		BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 5, 6),
6071 		BTF_END_RAW,
6072 	},
6073 	.line_info_rec_size = sizeof(struct bpf_line_info),
6074 	.nr_jited_ksyms = 1,
6075 	.dead_code_cnt = 1,
6076 	.dead_code_mask = 0x01,
6077 },
6078 
6079 {
6080 	.descr = "line_info (dead end)",
6081 	.raw_types = {
6082 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6083 		BTF_END_RAW,
6084 	},
6085 	BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0/* dead jmp */\0return a + b;\0/* dead exit */"),
6086 	.insns = {
6087 		BPF_MOV64_IMM(BPF_REG_0, 1),
6088 		BPF_MOV64_IMM(BPF_REG_1, 2),
6089 		BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
6090 		BPF_JMP_IMM(BPF_JGE, BPF_REG_0, 10, 1),
6091 		BPF_EXIT_INSN(),
6092 		BPF_EXIT_INSN(),
6093 	},
6094 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6095 	.func_info_cnt = 0,
6096 	.line_info = {
6097 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 12),
6098 		BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 11),
6099 		BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 10),
6100 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 9),
6101 		BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 5, 8),
6102 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 6, 7),
6103 		BTF_END_RAW,
6104 	},
6105 	.line_info_rec_size = sizeof(struct bpf_line_info),
6106 	.nr_jited_ksyms = 1,
6107 	.dead_code_cnt = 2,
6108 	.dead_code_mask = 0x28,
6109 },
6110 
6111 {
6112 	.descr = "line_info (dead code + subprog + func_info)",
6113 	.raw_types = {
6114 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6115 		BTF_FUNC_PROTO_ENC(1, 1),			/* [2] */
6116 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6117 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
6118 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [4] */
6119 		BTF_END_RAW,
6120 	},
6121 	BTF_STR_SEC("\0int\0x\0sub\0main\0int a=1+1;\0/* dead jmp */"
6122 		    "\0/* dead */\0/* dead */\0/* dead */\0/* dead */"
6123 		    "\0/* dead */\0/* dead */\0/* dead */\0/* dead */"
6124 		    "\0return func(a);\0b+=1;\0return b;"),
6125 	.insns = {
6126 		BPF_MOV64_IMM(BPF_REG_2, 1),
6127 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
6128 		BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
6129 		BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 8),
6130 		BPF_MOV64_IMM(BPF_REG_2, 1),
6131 		BPF_MOV64_IMM(BPF_REG_2, 1),
6132 		BPF_MOV64_IMM(BPF_REG_2, 1),
6133 		BPF_MOV64_IMM(BPF_REG_2, 1),
6134 		BPF_MOV64_IMM(BPF_REG_2, 1),
6135 		BPF_MOV64_IMM(BPF_REG_2, 1),
6136 		BPF_MOV64_IMM(BPF_REG_2, 1),
6137 		BPF_MOV64_IMM(BPF_REG_2, 1),
6138 		BPF_CALL_REL(1),
6139 		BPF_EXIT_INSN(),
6140 		BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
6141 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6142 		BPF_EXIT_INSN(),
6143 	},
6144 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6145 	.func_info_cnt = 2,
6146 	.func_info_rec_size = 8,
6147 	.func_info = { {0, 4}, {14, 3} },
6148 	.line_info = {
6149 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6150 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6151 		BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6152 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6153 		BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6154 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 1, 10),
6155 		BPF_LINE_INFO_ENC(8, 0, NAME_TBD, 1, 10),
6156 		BPF_LINE_INFO_ENC(9, 0, NAME_TBD, 1, 10),
6157 		BPF_LINE_INFO_ENC(10, 0, NAME_TBD, 1, 10),
6158 		BPF_LINE_INFO_ENC(11, 0, NAME_TBD, 2, 9),
6159 		BPF_LINE_INFO_ENC(12, 0, NAME_TBD, 2, 9),
6160 		BPF_LINE_INFO_ENC(14, 0, NAME_TBD, 3, 8),
6161 		BPF_LINE_INFO_ENC(16, 0, NAME_TBD, 4, 7),
6162 		BTF_END_RAW,
6163 	},
6164 	.line_info_rec_size = sizeof(struct bpf_line_info),
6165 	.nr_jited_ksyms = 2,
6166 	.dead_code_cnt = 9,
6167 	.dead_code_mask = 0x3fe,
6168 },
6169 
6170 {
6171 	.descr = "line_info (dead subprog)",
6172 	.raw_types = {
6173 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6174 		BTF_FUNC_PROTO_ENC(1, 1),			/* [2] */
6175 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6176 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
6177 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [4] */
6178 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [5] */
6179 		BTF_END_RAW,
6180 	},
6181 	BTF_STR_SEC("\0int\0x\0dead\0main\0func\0int a=1+1;\0/* live call */"
6182 		    "\0return 0;\0return 0;\0/* dead */\0/* dead */"
6183 		    "\0/* dead */\0return bla + 1;\0return bla + 1;"
6184 		    "\0return bla + 1;\0return func(a);\0b+=1;\0return b;"),
6185 	.insns = {
6186 		BPF_MOV64_IMM(BPF_REG_2, 1),
6187 		BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 1),
6188 		BPF_CALL_REL(3),
6189 		BPF_CALL_REL(5),
6190 		BPF_MOV64_IMM(BPF_REG_0, 0),
6191 		BPF_EXIT_INSN(),
6192 		BPF_MOV64_IMM(BPF_REG_0, 0),
6193 		BPF_CALL_REL(1),
6194 		BPF_EXIT_INSN(),
6195 		BPF_MOV64_REG(BPF_REG_0, 2),
6196 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6197 		BPF_EXIT_INSN(),
6198 	},
6199 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6200 	.func_info_cnt = 3,
6201 	.func_info_rec_size = 8,
6202 		.func_info = { {0, 4}, {6, 3}, {9, 5} },
6203 	.line_info = {
6204 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6205 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6206 		BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6207 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6208 		BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6209 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 1, 10),
6210 		BPF_LINE_INFO_ENC(8, 0, NAME_TBD, 1, 10),
6211 		BPF_LINE_INFO_ENC(9, 0, NAME_TBD, 1, 10),
6212 		BPF_LINE_INFO_ENC(10, 0, NAME_TBD, 1, 10),
6213 		BPF_LINE_INFO_ENC(11, 0, NAME_TBD, 2, 9),
6214 		BTF_END_RAW,
6215 	},
6216 	.line_info_rec_size = sizeof(struct bpf_line_info),
6217 	.nr_jited_ksyms = 2,
6218 	.dead_code_cnt = 3,
6219 	.dead_code_mask = 0x70,
6220 	.dead_func_cnt = 1,
6221 	.dead_func_mask = 0x2,
6222 },
6223 
6224 {
6225 	.descr = "line_info (dead last subprog)",
6226 	.raw_types = {
6227 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6228 		BTF_FUNC_PROTO_ENC(1, 1),			/* [2] */
6229 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6230 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
6231 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [5] */
6232 		BTF_END_RAW,
6233 	},
6234 	BTF_STR_SEC("\0int\0x\0dead\0main\0int a=1+1;\0/* live call */"
6235 		    "\0return 0;\0/* dead */\0/* dead */"),
6236 	.insns = {
6237 		BPF_MOV64_IMM(BPF_REG_2, 1),
6238 		BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 1),
6239 		BPF_CALL_REL(2),
6240 		BPF_MOV64_IMM(BPF_REG_0, 0),
6241 		BPF_EXIT_INSN(),
6242 		BPF_MOV64_IMM(BPF_REG_0, 0),
6243 		BPF_EXIT_INSN(),
6244 	},
6245 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6246 	.func_info_cnt = 2,
6247 	.func_info_rec_size = 8,
6248 		.func_info = { {0, 4}, {5, 3} },
6249 	.line_info = {
6250 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6251 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6252 		BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6253 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6254 		BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6255 		BTF_END_RAW,
6256 	},
6257 	.line_info_rec_size = sizeof(struct bpf_line_info),
6258 	.nr_jited_ksyms = 1,
6259 	.dead_code_cnt = 2,
6260 	.dead_code_mask = 0x18,
6261 	.dead_func_cnt = 1,
6262 	.dead_func_mask = 0x2,
6263 },
6264 
6265 {
6266 	.descr = "line_info (dead subprog + dead start)",
6267 	.raw_types = {
6268 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6269 		BTF_FUNC_PROTO_ENC(1, 1),			/* [2] */
6270 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6271 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
6272 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [4] */
6273 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [5] */
6274 		BTF_END_RAW,
6275 	},
6276 	BTF_STR_SEC("\0int\0x\0dead\0main\0func\0int a=1+1;\0/* dead */"
6277 		    "\0return 0;\0return 0;\0return 0;"
6278 		    "\0/* dead */\0/* dead */\0/* dead */\0/* dead */"
6279 		    "\0return b + 1;\0return b + 1;\0return b + 1;"),
6280 	.insns = {
6281 		BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6282 		BPF_MOV64_IMM(BPF_REG_2, 1),
6283 		BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 1),
6284 		BPF_CALL_REL(3),
6285 		BPF_CALL_REL(5),
6286 		BPF_MOV64_IMM(BPF_REG_0, 0),
6287 		BPF_EXIT_INSN(),
6288 		BPF_MOV64_IMM(BPF_REG_0, 0),
6289 		BPF_CALL_REL(1),
6290 		BPF_EXIT_INSN(),
6291 		BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6292 		BPF_MOV64_REG(BPF_REG_0, 2),
6293 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6294 		BPF_EXIT_INSN(),
6295 	},
6296 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6297 	.func_info_cnt = 3,
6298 	.func_info_rec_size = 8,
6299 		.func_info = { {0, 4}, {7, 3}, {10, 5} },
6300 	.line_info = {
6301 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6302 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6303 		BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6304 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6305 		BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6306 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 1, 10),
6307 		BPF_LINE_INFO_ENC(8, 0, NAME_TBD, 1, 10),
6308 		BPF_LINE_INFO_ENC(9, 0, NAME_TBD, 1, 10),
6309 		BPF_LINE_INFO_ENC(10, 0, NAME_TBD, 1, 10),
6310 		BPF_LINE_INFO_ENC(11, 0, NAME_TBD, 2, 9),
6311 		BPF_LINE_INFO_ENC(12, 0, NAME_TBD, 2, 9),
6312 		BPF_LINE_INFO_ENC(13, 0, NAME_TBD, 2, 9),
6313 		BTF_END_RAW,
6314 	},
6315 	.line_info_rec_size = sizeof(struct bpf_line_info),
6316 	.nr_jited_ksyms = 2,
6317 	.dead_code_cnt = 5,
6318 	.dead_code_mask = 0x1e2,
6319 	.dead_func_cnt = 1,
6320 	.dead_func_mask = 0x2,
6321 },
6322 
6323 {
6324 	.descr = "line_info (dead subprog + dead start w/ move)",
6325 	.raw_types = {
6326 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6327 		BTF_FUNC_PROTO_ENC(1, 1),			/* [2] */
6328 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6329 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
6330 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [4] */
6331 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [5] */
6332 		BTF_END_RAW,
6333 	},
6334 	BTF_STR_SEC("\0int\0x\0dead\0main\0func\0int a=1+1;\0/* live call */"
6335 		    "\0return 0;\0return 0;\0/* dead */\0/* dead */"
6336 		    "\0/* dead */\0return bla + 1;\0return bla + 1;"
6337 		    "\0return bla + 1;\0return func(a);\0b+=1;\0return b;"),
6338 	.insns = {
6339 		BPF_MOV64_IMM(BPF_REG_2, 1),
6340 		BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 1),
6341 		BPF_CALL_REL(3),
6342 		BPF_CALL_REL(5),
6343 		BPF_MOV64_IMM(BPF_REG_0, 0),
6344 		BPF_EXIT_INSN(),
6345 		BPF_MOV64_IMM(BPF_REG_0, 0),
6346 		BPF_CALL_REL(1),
6347 		BPF_EXIT_INSN(),
6348 		BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6349 		BPF_MOV64_REG(BPF_REG_0, 2),
6350 		BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6351 		BPF_EXIT_INSN(),
6352 	},
6353 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6354 	.func_info_cnt = 3,
6355 	.func_info_rec_size = 8,
6356 		.func_info = { {0, 4}, {6, 3}, {9, 5} },
6357 	.line_info = {
6358 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6359 		BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6360 		BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6361 		BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6362 		BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6363 		BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 1, 10),
6364 		BPF_LINE_INFO_ENC(8, 0, NAME_TBD, 1, 10),
6365 		BPF_LINE_INFO_ENC(9, 0, NAME_TBD, 1, 10),
6366 		BPF_LINE_INFO_ENC(11, 0, NAME_TBD, 1, 10),
6367 		BPF_LINE_INFO_ENC(12, 0, NAME_TBD, 2, 9),
6368 		BTF_END_RAW,
6369 	},
6370 	.line_info_rec_size = sizeof(struct bpf_line_info),
6371 	.nr_jited_ksyms = 2,
6372 	.dead_code_cnt = 3,
6373 	.dead_code_mask = 0x70,
6374 	.dead_func_cnt = 1,
6375 	.dead_func_mask = 0x2,
6376 },
6377 
6378 {
6379 	.descr = "line_info (dead end + subprog start w/ no linfo)",
6380 	.raw_types = {
6381 		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6382 		BTF_FUNC_PROTO_ENC(1, 1),			/* [2] */
6383 			BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6384 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [3] */
6385 		BTF_FUNC_ENC(NAME_TBD, 2),			/* [4] */
6386 		BTF_END_RAW,
6387 	},
6388 	BTF_STR_SEC("\0int\0x\0main\0func\0/* main linfo */\0/* func linfo */"),
6389 	.insns = {
6390 		BPF_MOV64_IMM(BPF_REG_0, 0),
6391 		BPF_JMP_IMM(BPF_JGE, BPF_REG_0, 1, 3),
6392 		BPF_CALL_REL(3),
6393 		BPF_MOV64_IMM(BPF_REG_0, 0),
6394 		BPF_EXIT_INSN(),
6395 		BPF_EXIT_INSN(),
6396 		BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6397 		BPF_EXIT_INSN(),
6398 	},
6399 	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
6400 	.func_info_cnt = 2,
6401 	.func_info_rec_size = 8,
6402 	.func_info = { {0, 3}, {6, 4}, },
6403 	.line_info = {
6404 		BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6405 		BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6406 		BTF_END_RAW,
6407 	},
6408 	.line_info_rec_size = sizeof(struct bpf_line_info),
6409 	.nr_jited_ksyms = 2,
6410 },
6411 
6412 };
6413 
6414 static size_t probe_prog_length(const struct bpf_insn *fp)
6415 {
6416 	size_t len;
6417 
6418 	for (len = MAX_INSNS - 1; len > 0; --len)
6419 		if (fp[len].code != 0 || fp[len].imm != 0)
6420 			break;
6421 	return len + 1;
6422 }
6423 
6424 static __u32 *patch_name_tbd(const __u32 *raw_u32,
6425 			     const char *str, __u32 str_off,
6426 			     unsigned int str_sec_size,
6427 			     unsigned int *ret_size)
6428 {
6429 	int i, raw_u32_size = get_raw_sec_size(raw_u32);
6430 	const char *end_str = str + str_sec_size;
6431 	const char *next_str = str + str_off;
6432 	__u32 *new_u32 = NULL;
6433 
6434 	if (raw_u32_size == -1)
6435 		return ERR_PTR(-EINVAL);
6436 
6437 	if (!raw_u32_size) {
6438 		*ret_size = 0;
6439 		return NULL;
6440 	}
6441 
6442 	new_u32 = malloc(raw_u32_size);
6443 	if (!new_u32)
6444 		return ERR_PTR(-ENOMEM);
6445 
6446 	for (i = 0; i < raw_u32_size / sizeof(raw_u32[0]); i++) {
6447 		if (raw_u32[i] == NAME_TBD) {
6448 			next_str = get_next_str(next_str, end_str);
6449 			if (CHECK(!next_str, "Error in getting next_str\n")) {
6450 				free(new_u32);
6451 				return ERR_PTR(-EINVAL);
6452 			}
6453 			new_u32[i] = next_str - str;
6454 			next_str += strlen(next_str);
6455 		} else {
6456 			new_u32[i] = raw_u32[i];
6457 		}
6458 	}
6459 
6460 	*ret_size = raw_u32_size;
6461 	return new_u32;
6462 }
6463 
6464 static int test_get_finfo(const struct prog_info_raw_test *test,
6465 			  int prog_fd)
6466 {
6467 	struct bpf_prog_info info = {};
6468 	struct bpf_func_info *finfo;
6469 	__u32 info_len, rec_size, i;
6470 	void *func_info = NULL;
6471 	__u32 nr_func_info;
6472 	int err;
6473 
6474 	/* get necessary lens */
6475 	info_len = sizeof(struct bpf_prog_info);
6476 	err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
6477 	if (CHECK(err < 0, "invalid get info (1st) errno:%d", errno)) {
6478 		fprintf(stderr, "%s\n", btf_log_buf);
6479 		return -1;
6480 	}
6481 	nr_func_info = test->func_info_cnt - test->dead_func_cnt;
6482 	if (CHECK(info.nr_func_info != nr_func_info,
6483 		  "incorrect info.nr_func_info (1st) %d",
6484 		  info.nr_func_info)) {
6485 		return -1;
6486 	}
6487 
6488 	rec_size = info.func_info_rec_size;
6489 	if (CHECK(rec_size != sizeof(struct bpf_func_info),
6490 		  "incorrect info.func_info_rec_size (1st) %d", rec_size)) {
6491 		return -1;
6492 	}
6493 
6494 	if (!info.nr_func_info)
6495 		return 0;
6496 
6497 	func_info = malloc(info.nr_func_info * rec_size);
6498 	if (CHECK(!func_info, "out of memory"))
6499 		return -1;
6500 
6501 	/* reset info to only retrieve func_info related data */
6502 	memset(&info, 0, sizeof(info));
6503 	info.nr_func_info = nr_func_info;
6504 	info.func_info_rec_size = rec_size;
6505 	info.func_info = ptr_to_u64(func_info);
6506 	err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
6507 	if (CHECK(err < 0, "invalid get info (2nd) errno:%d", errno)) {
6508 		fprintf(stderr, "%s\n", btf_log_buf);
6509 		err = -1;
6510 		goto done;
6511 	}
6512 	if (CHECK(info.nr_func_info != nr_func_info,
6513 		  "incorrect info.nr_func_info (2nd) %d",
6514 		  info.nr_func_info)) {
6515 		err = -1;
6516 		goto done;
6517 	}
6518 	if (CHECK(info.func_info_rec_size != rec_size,
6519 		  "incorrect info.func_info_rec_size (2nd) %d",
6520 		  info.func_info_rec_size)) {
6521 		err = -1;
6522 		goto done;
6523 	}
6524 
6525 	finfo = func_info;
6526 	for (i = 0; i < nr_func_info; i++) {
6527 		if (test->dead_func_mask & (1 << i))
6528 			continue;
6529 		if (CHECK(finfo->type_id != test->func_info[i][1],
6530 			  "incorrect func_type %u expected %u",
6531 			  finfo->type_id, test->func_info[i][1])) {
6532 			err = -1;
6533 			goto done;
6534 		}
6535 		finfo = (void *)finfo + rec_size;
6536 	}
6537 
6538 	err = 0;
6539 
6540 done:
6541 	free(func_info);
6542 	return err;
6543 }
6544 
6545 static int test_get_linfo(const struct prog_info_raw_test *test,
6546 			  const void *patched_linfo,
6547 			  __u32 cnt, int prog_fd)
6548 {
6549 	__u32 i, info_len, nr_jited_ksyms, nr_jited_func_lens;
6550 	__u64 *jited_linfo = NULL, *jited_ksyms = NULL;
6551 	__u32 rec_size, jited_rec_size, jited_cnt;
6552 	struct bpf_line_info *linfo = NULL;
6553 	__u32 cur_func_len, ksyms_found;
6554 	struct bpf_prog_info info = {};
6555 	__u32 *jited_func_lens = NULL;
6556 	__u64 cur_func_ksyms;
6557 	__u32 dead_insns;
6558 	int err;
6559 
6560 	jited_cnt = cnt;
6561 	rec_size = sizeof(*linfo);
6562 	jited_rec_size = sizeof(*jited_linfo);
6563 	if (test->nr_jited_ksyms)
6564 		nr_jited_ksyms = test->nr_jited_ksyms;
6565 	else
6566 		nr_jited_ksyms = test->func_info_cnt - test->dead_func_cnt;
6567 	nr_jited_func_lens = nr_jited_ksyms;
6568 
6569 	info_len = sizeof(struct bpf_prog_info);
6570 	err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
6571 	if (CHECK(err < 0, "err:%d errno:%d", err, errno)) {
6572 		err = -1;
6573 		goto done;
6574 	}
6575 
6576 	if (!info.jited_prog_len) {
6577 		/* prog is not jited */
6578 		jited_cnt = 0;
6579 		nr_jited_ksyms = 1;
6580 		nr_jited_func_lens = 1;
6581 	}
6582 
6583 	if (CHECK(info.nr_line_info != cnt ||
6584 		  info.nr_jited_line_info != jited_cnt ||
6585 		  info.nr_jited_ksyms != nr_jited_ksyms ||
6586 		  info.nr_jited_func_lens != nr_jited_func_lens ||
6587 		  (!info.nr_line_info && info.nr_jited_line_info),
6588 		  "info: nr_line_info:%u(expected:%u) nr_jited_line_info:%u(expected:%u) nr_jited_ksyms:%u(expected:%u) nr_jited_func_lens:%u(expected:%u)",
6589 		  info.nr_line_info, cnt,
6590 		  info.nr_jited_line_info, jited_cnt,
6591 		  info.nr_jited_ksyms, nr_jited_ksyms,
6592 		  info.nr_jited_func_lens, nr_jited_func_lens)) {
6593 		err = -1;
6594 		goto done;
6595 	}
6596 
6597 	if (CHECK(info.line_info_rec_size != sizeof(struct bpf_line_info) ||
6598 		  info.jited_line_info_rec_size != sizeof(__u64),
6599 		  "info: line_info_rec_size:%u(userspace expected:%u) jited_line_info_rec_size:%u(userspace expected:%u)",
6600 		  info.line_info_rec_size, rec_size,
6601 		  info.jited_line_info_rec_size, jited_rec_size)) {
6602 		err = -1;
6603 		goto done;
6604 	}
6605 
6606 	if (!cnt)
6607 		return 0;
6608 
6609 	rec_size = info.line_info_rec_size;
6610 	jited_rec_size = info.jited_line_info_rec_size;
6611 
6612 	memset(&info, 0, sizeof(info));
6613 
6614 	linfo = calloc(cnt, rec_size);
6615 	if (CHECK(!linfo, "!linfo")) {
6616 		err = -1;
6617 		goto done;
6618 	}
6619 	info.nr_line_info = cnt;
6620 	info.line_info_rec_size = rec_size;
6621 	info.line_info = ptr_to_u64(linfo);
6622 
6623 	if (jited_cnt) {
6624 		jited_linfo = calloc(jited_cnt, jited_rec_size);
6625 		jited_ksyms = calloc(nr_jited_ksyms, sizeof(*jited_ksyms));
6626 		jited_func_lens = calloc(nr_jited_func_lens,
6627 					 sizeof(*jited_func_lens));
6628 		if (CHECK(!jited_linfo || !jited_ksyms || !jited_func_lens,
6629 			  "jited_linfo:%p jited_ksyms:%p jited_func_lens:%p",
6630 			  jited_linfo, jited_ksyms, jited_func_lens)) {
6631 			err = -1;
6632 			goto done;
6633 		}
6634 
6635 		info.nr_jited_line_info = jited_cnt;
6636 		info.jited_line_info_rec_size = jited_rec_size;
6637 		info.jited_line_info = ptr_to_u64(jited_linfo);
6638 		info.nr_jited_ksyms = nr_jited_ksyms;
6639 		info.jited_ksyms = ptr_to_u64(jited_ksyms);
6640 		info.nr_jited_func_lens = nr_jited_func_lens;
6641 		info.jited_func_lens = ptr_to_u64(jited_func_lens);
6642 	}
6643 
6644 	err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
6645 
6646 	/*
6647 	 * Only recheck the info.*line_info* fields.
6648 	 * Other fields are not the concern of this test.
6649 	 */
6650 	if (CHECK(err < 0 ||
6651 		  info.nr_line_info != cnt ||
6652 		  (jited_cnt && !info.jited_line_info) ||
6653 		  info.nr_jited_line_info != jited_cnt ||
6654 		  info.line_info_rec_size != rec_size ||
6655 		  info.jited_line_info_rec_size != jited_rec_size,
6656 		  "err:%d errno:%d info: nr_line_info:%u(expected:%u) nr_jited_line_info:%u(expected:%u) line_info_rec_size:%u(expected:%u) jited_linfo_rec_size:%u(expected:%u) line_info:%p jited_line_info:%p",
6657 		  err, errno,
6658 		  info.nr_line_info, cnt,
6659 		  info.nr_jited_line_info, jited_cnt,
6660 		  info.line_info_rec_size, rec_size,
6661 		  info.jited_line_info_rec_size, jited_rec_size,
6662 		  (void *)(long)info.line_info,
6663 		  (void *)(long)info.jited_line_info)) {
6664 		err = -1;
6665 		goto done;
6666 	}
6667 
6668 	dead_insns = 0;
6669 	while (test->dead_code_mask & (1 << dead_insns))
6670 		dead_insns++;
6671 
6672 	CHECK(linfo[0].insn_off, "linfo[0].insn_off:%u",
6673 	      linfo[0].insn_off);
6674 	for (i = 1; i < cnt; i++) {
6675 		const struct bpf_line_info *expected_linfo;
6676 
6677 		while (test->dead_code_mask & (1 << (i + dead_insns)))
6678 			dead_insns++;
6679 
6680 		expected_linfo = patched_linfo +
6681 			((i + dead_insns) * test->line_info_rec_size);
6682 		if (CHECK(linfo[i].insn_off <= linfo[i - 1].insn_off,
6683 			  "linfo[%u].insn_off:%u <= linfo[%u].insn_off:%u",
6684 			  i, linfo[i].insn_off,
6685 			  i - 1, linfo[i - 1].insn_off)) {
6686 			err = -1;
6687 			goto done;
6688 		}
6689 		if (CHECK(linfo[i].file_name_off != expected_linfo->file_name_off ||
6690 			  linfo[i].line_off != expected_linfo->line_off ||
6691 			  linfo[i].line_col != expected_linfo->line_col,
6692 			  "linfo[%u] (%u, %u, %u) != (%u, %u, %u)", i,
6693 			  linfo[i].file_name_off,
6694 			  linfo[i].line_off,
6695 			  linfo[i].line_col,
6696 			  expected_linfo->file_name_off,
6697 			  expected_linfo->line_off,
6698 			  expected_linfo->line_col)) {
6699 			err = -1;
6700 			goto done;
6701 		}
6702 	}
6703 
6704 	if (!jited_cnt) {
6705 		fprintf(stderr, "not jited. skipping jited_line_info check. ");
6706 		err = 0;
6707 		goto done;
6708 	}
6709 
6710 	if (CHECK(jited_linfo[0] != jited_ksyms[0],
6711 		  "jited_linfo[0]:%lx != jited_ksyms[0]:%lx",
6712 		  (long)(jited_linfo[0]), (long)(jited_ksyms[0]))) {
6713 		err = -1;
6714 		goto done;
6715 	}
6716 
6717 	ksyms_found = 1;
6718 	cur_func_len = jited_func_lens[0];
6719 	cur_func_ksyms = jited_ksyms[0];
6720 	for (i = 1; i < jited_cnt; i++) {
6721 		if (ksyms_found < nr_jited_ksyms &&
6722 		    jited_linfo[i] == jited_ksyms[ksyms_found]) {
6723 			cur_func_ksyms = jited_ksyms[ksyms_found];
6724 			cur_func_len = jited_ksyms[ksyms_found];
6725 			ksyms_found++;
6726 			continue;
6727 		}
6728 
6729 		if (CHECK(jited_linfo[i] <= jited_linfo[i - 1],
6730 			  "jited_linfo[%u]:%lx <= jited_linfo[%u]:%lx",
6731 			  i, (long)jited_linfo[i],
6732 			  i - 1, (long)(jited_linfo[i - 1]))) {
6733 			err = -1;
6734 			goto done;
6735 		}
6736 
6737 		if (CHECK(jited_linfo[i] - cur_func_ksyms > cur_func_len,
6738 			  "jited_linfo[%u]:%lx - %lx > %u",
6739 			  i, (long)jited_linfo[i], (long)cur_func_ksyms,
6740 			  cur_func_len)) {
6741 			err = -1;
6742 			goto done;
6743 		}
6744 	}
6745 
6746 	if (CHECK(ksyms_found != nr_jited_ksyms,
6747 		  "ksyms_found:%u != nr_jited_ksyms:%u",
6748 		  ksyms_found, nr_jited_ksyms)) {
6749 		err = -1;
6750 		goto done;
6751 	}
6752 
6753 	err = 0;
6754 
6755 done:
6756 	free(linfo);
6757 	free(jited_linfo);
6758 	free(jited_ksyms);
6759 	free(jited_func_lens);
6760 	return err;
6761 }
6762 
6763 static void do_test_info_raw(unsigned int test_num)
6764 {
6765 	const struct prog_info_raw_test *test = &info_raw_tests[test_num - 1];
6766 	unsigned int raw_btf_size, linfo_str_off, linfo_size = 0;
6767 	int btf_fd = -1, prog_fd = -1, err = 0;
6768 	void *raw_btf, *patched_linfo = NULL;
6769 	const char *ret_next_str;
6770 	union bpf_attr attr = {};
6771 
6772 	if (!test__start_subtest(test->descr))
6773 		return;
6774 
6775 	raw_btf = btf_raw_create(&hdr_tmpl, test->raw_types,
6776 				 test->str_sec, test->str_sec_size,
6777 				 &raw_btf_size, &ret_next_str);
6778 	if (!raw_btf)
6779 		return;
6780 
6781 	*btf_log_buf = '\0';
6782 	btf_fd = load_raw_btf(raw_btf, raw_btf_size);
6783 	free(raw_btf);
6784 
6785 	if (CHECK(btf_fd < 0, "invalid btf_fd errno:%d", errno)) {
6786 		err = -1;
6787 		goto done;
6788 	}
6789 
6790 	if (*btf_log_buf && always_log)
6791 		fprintf(stderr, "\n%s", btf_log_buf);
6792 	*btf_log_buf = '\0';
6793 
6794 	linfo_str_off = ret_next_str - test->str_sec;
6795 	patched_linfo = patch_name_tbd(test->line_info,
6796 				       test->str_sec, linfo_str_off,
6797 				       test->str_sec_size, &linfo_size);
6798 	err = libbpf_get_error(patched_linfo);
6799 	if (err) {
6800 		fprintf(stderr, "error in creating raw bpf_line_info");
6801 		err = -1;
6802 		goto done;
6803 	}
6804 
6805 	attr.prog_type = test->prog_type;
6806 	attr.insns = ptr_to_u64(test->insns);
6807 	attr.insn_cnt = probe_prog_length(test->insns);
6808 	attr.license = ptr_to_u64("GPL");
6809 	attr.prog_btf_fd = btf_fd;
6810 	attr.func_info_rec_size = test->func_info_rec_size;
6811 	attr.func_info_cnt = test->func_info_cnt;
6812 	attr.func_info = ptr_to_u64(test->func_info);
6813 	attr.log_buf = ptr_to_u64(btf_log_buf);
6814 	attr.log_size = BTF_LOG_BUF_SIZE;
6815 	attr.log_level = 1;
6816 	if (linfo_size) {
6817 		attr.line_info_rec_size = test->line_info_rec_size;
6818 		attr.line_info = ptr_to_u64(patched_linfo);
6819 		attr.line_info_cnt = linfo_size / attr.line_info_rec_size;
6820 	}
6821 
6822 	prog_fd = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
6823 	err = ((prog_fd < 0) != test->expected_prog_load_failure);
6824 	if (CHECK(err, "prog_fd:%d expected_prog_load_failure:%u errno:%d",
6825 		  prog_fd, test->expected_prog_load_failure, errno) ||
6826 	    CHECK(test->err_str && !strstr(btf_log_buf, test->err_str),
6827 		  "expected err_str:%s", test->err_str)) {
6828 		err = -1;
6829 		goto done;
6830 	}
6831 
6832 	if (prog_fd < 0)
6833 		goto done;
6834 
6835 	err = test_get_finfo(test, prog_fd);
6836 	if (err)
6837 		goto done;
6838 
6839 	err = test_get_linfo(test, patched_linfo,
6840 			     attr.line_info_cnt - test->dead_code_cnt,
6841 			     prog_fd);
6842 	if (err)
6843 		goto done;
6844 
6845 done:
6846 	if (*btf_log_buf && (err || always_log))
6847 		fprintf(stderr, "\n%s", btf_log_buf);
6848 
6849 	if (btf_fd >= 0)
6850 		close(btf_fd);
6851 	if (prog_fd >= 0)
6852 		close(prog_fd);
6853 
6854 	if (!libbpf_get_error(patched_linfo))
6855 		free(patched_linfo);
6856 }
6857 
6858 struct btf_raw_data {
6859 	__u32 raw_types[MAX_NR_RAW_U32];
6860 	const char *str_sec;
6861 	__u32 str_sec_size;
6862 };
6863 
6864 struct btf_dedup_test {
6865 	const char *descr;
6866 	struct btf_raw_data input;
6867 	struct btf_raw_data expect;
6868 	struct btf_dedup_opts opts;
6869 };
6870 
6871 static struct btf_dedup_test dedup_tests[] = {
6872 
6873 {
6874 	.descr = "dedup: unused strings filtering",
6875 	.input = {
6876 		.raw_types = {
6877 			BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 4),
6878 			BTF_TYPE_INT_ENC(NAME_NTH(5), BTF_INT_SIGNED, 0, 64, 8),
6879 			BTF_END_RAW,
6880 		},
6881 		BTF_STR_SEC("\0unused\0int\0foo\0bar\0long"),
6882 	},
6883 	.expect = {
6884 		.raw_types = {
6885 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
6886 			BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
6887 			BTF_END_RAW,
6888 		},
6889 		BTF_STR_SEC("\0int\0long"),
6890 	},
6891 },
6892 {
6893 	.descr = "dedup: strings deduplication",
6894 	.input = {
6895 		.raw_types = {
6896 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
6897 			BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
6898 			BTF_TYPE_INT_ENC(NAME_NTH(3), BTF_INT_SIGNED, 0, 32, 4),
6899 			BTF_TYPE_INT_ENC(NAME_NTH(4), BTF_INT_SIGNED, 0, 64, 8),
6900 			BTF_TYPE_INT_ENC(NAME_NTH(5), BTF_INT_SIGNED, 0, 32, 4),
6901 			BTF_END_RAW,
6902 		},
6903 		BTF_STR_SEC("\0int\0long int\0int\0long int\0int"),
6904 	},
6905 	.expect = {
6906 		.raw_types = {
6907 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
6908 			BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
6909 			BTF_END_RAW,
6910 		},
6911 		BTF_STR_SEC("\0int\0long int"),
6912 	},
6913 },
6914 {
6915 	.descr = "dedup: struct example #1",
6916 	/*
6917 	 * struct s {
6918 	 *	struct s *next;
6919 	 *	const int *a;
6920 	 *	int b[16];
6921 	 *	int c;
6922 	 * }
6923 	 */
6924 	.input = {
6925 		.raw_types = {
6926 			/* int */
6927 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6928 			/* int[16] */
6929 			BTF_TYPE_ARRAY_ENC(1, 1, 16),					/* [2] */
6930 			/* struct s { */
6931 			BTF_STRUCT_ENC(NAME_NTH(2), 5, 88),				/* [3] */
6932 				BTF_MEMBER_ENC(NAME_NTH(3), 4, 0),	/* struct s *next;	*/
6933 				BTF_MEMBER_ENC(NAME_NTH(4), 5, 64),	/* const int *a;	*/
6934 				BTF_MEMBER_ENC(NAME_NTH(5), 2, 128),	/* int b[16];		*/
6935 				BTF_MEMBER_ENC(NAME_NTH(6), 1, 640),	/* int c;		*/
6936 				BTF_MEMBER_ENC(NAME_NTH(8), 15, 672),	/* float d;		*/
6937 			/* ptr -> [3] struct s */
6938 			BTF_PTR_ENC(3),							/* [4] */
6939 			/* ptr -> [6] const int */
6940 			BTF_PTR_ENC(6),							/* [5] */
6941 			/* const -> [1] int */
6942 			BTF_CONST_ENC(1),						/* [6] */
6943 			/* tag -> [3] struct s */
6944 			BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1),				/* [7] */
6945 			/* tag -> [3] struct s, member 1 */
6946 			BTF_DECL_TAG_ENC(NAME_NTH(2), 3, 1),				/* [8] */
6947 
6948 			/* full copy of the above */
6949 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),	/* [9] */
6950 			BTF_TYPE_ARRAY_ENC(9, 9, 16),					/* [10] */
6951 			BTF_STRUCT_ENC(NAME_NTH(2), 5, 88),				/* [11] */
6952 				BTF_MEMBER_ENC(NAME_NTH(3), 12, 0),
6953 				BTF_MEMBER_ENC(NAME_NTH(4), 13, 64),
6954 				BTF_MEMBER_ENC(NAME_NTH(5), 10, 128),
6955 				BTF_MEMBER_ENC(NAME_NTH(6), 9, 640),
6956 				BTF_MEMBER_ENC(NAME_NTH(8), 15, 672),
6957 			BTF_PTR_ENC(11),						/* [12] */
6958 			BTF_PTR_ENC(14),						/* [13] */
6959 			BTF_CONST_ENC(9),						/* [14] */
6960 			BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4),				/* [15] */
6961 			BTF_DECL_TAG_ENC(NAME_NTH(2), 11, -1),				/* [16] */
6962 			BTF_DECL_TAG_ENC(NAME_NTH(2), 11, 1),				/* [17] */
6963 			BTF_END_RAW,
6964 		},
6965 		BTF_STR_SEC("\0int\0s\0next\0a\0b\0c\0float\0d"),
6966 	},
6967 	.expect = {
6968 		.raw_types = {
6969 			/* int */
6970 			BTF_TYPE_INT_ENC(NAME_NTH(5), BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
6971 			/* int[16] */
6972 			BTF_TYPE_ARRAY_ENC(1, 1, 16),					/* [2] */
6973 			/* struct s { */
6974 			BTF_STRUCT_ENC(NAME_NTH(8), 5, 88),				/* [3] */
6975 				BTF_MEMBER_ENC(NAME_NTH(7), 4, 0),	/* struct s *next;	*/
6976 				BTF_MEMBER_ENC(NAME_NTH(1), 5, 64),	/* const int *a;	*/
6977 				BTF_MEMBER_ENC(NAME_NTH(2), 2, 128),	/* int b[16];		*/
6978 				BTF_MEMBER_ENC(NAME_NTH(3), 1, 640),	/* int c;		*/
6979 				BTF_MEMBER_ENC(NAME_NTH(4), 9, 672),	/* float d;		*/
6980 			/* ptr -> [3] struct s */
6981 			BTF_PTR_ENC(3),							/* [4] */
6982 			/* ptr -> [6] const int */
6983 			BTF_PTR_ENC(6),							/* [5] */
6984 			/* const -> [1] int */
6985 			BTF_CONST_ENC(1),						/* [6] */
6986 			BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1),				/* [7] */
6987 			BTF_DECL_TAG_ENC(NAME_NTH(2), 3, 1),				/* [8] */
6988 			BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4),				/* [9] */
6989 			BTF_END_RAW,
6990 		},
6991 		BTF_STR_SEC("\0a\0b\0c\0d\0int\0float\0next\0s"),
6992 	},
6993 },
6994 {
6995 	.descr = "dedup: struct <-> fwd resolution w/ hash collision",
6996 	/*
6997 	 * // CU 1:
6998 	 * struct x;
6999 	 * struct s {
7000 	 *	struct x *x;
7001 	 * };
7002 	 * // CU 2:
7003 	 * struct x {};
7004 	 * struct s {
7005 	 *	struct x *x;
7006 	 * };
7007 	 */
7008 	.input = {
7009 		.raw_types = {
7010 			/* CU 1 */
7011 			BTF_FWD_ENC(NAME_TBD, 0 /* struct fwd */),	/* [1] fwd x      */
7012 			BTF_PTR_ENC(1),					/* [2] ptr -> [1] */
7013 			BTF_STRUCT_ENC(NAME_TBD, 1, 8),			/* [3] struct s   */
7014 				BTF_MEMBER_ENC(NAME_TBD, 2, 0),
7015 			/* CU 2 */
7016 			BTF_STRUCT_ENC(NAME_TBD, 0, 0),			/* [4] struct x   */
7017 			BTF_PTR_ENC(4),					/* [5] ptr -> [4] */
7018 			BTF_STRUCT_ENC(NAME_TBD, 1, 8),			/* [6] struct s   */
7019 				BTF_MEMBER_ENC(NAME_TBD, 5, 0),
7020 			BTF_END_RAW,
7021 		},
7022 		BTF_STR_SEC("\0x\0s\0x\0x\0s\0x\0"),
7023 	},
7024 	.expect = {
7025 		.raw_types = {
7026 			BTF_PTR_ENC(3),					/* [1] ptr -> [3] */
7027 			BTF_STRUCT_ENC(NAME_TBD, 1, 8),			/* [2] struct s   */
7028 				BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7029 			BTF_STRUCT_ENC(NAME_NTH(2), 0, 0),		/* [3] struct x   */
7030 			BTF_END_RAW,
7031 		},
7032 		BTF_STR_SEC("\0s\0x"),
7033 	},
7034 	.opts = {
7035 		.force_collisions = true, /* force hash collisions */
7036 	},
7037 },
7038 {
7039 	.descr = "dedup: void equiv check",
7040 	/*
7041 	 * // CU 1:
7042 	 * struct s {
7043 	 *	struct {} *x;
7044 	 * };
7045 	 * // CU 2:
7046 	 * struct s {
7047 	 *	int *x;
7048 	 * };
7049 	 */
7050 	.input = {
7051 		.raw_types = {
7052 			/* CU 1 */
7053 			BTF_STRUCT_ENC(0, 0, 1),				/* [1] struct {}  */
7054 			BTF_PTR_ENC(1),						/* [2] ptr -> [1] */
7055 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 8),			/* [3] struct s   */
7056 				BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7057 			/* CU 2 */
7058 			BTF_PTR_ENC(0),						/* [4] ptr -> void */
7059 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 8),			/* [5] struct s   */
7060 				BTF_MEMBER_ENC(NAME_NTH(2), 4, 0),
7061 			BTF_END_RAW,
7062 		},
7063 		BTF_STR_SEC("\0s\0x"),
7064 	},
7065 	.expect = {
7066 		.raw_types = {
7067 			/* CU 1 */
7068 			BTF_STRUCT_ENC(0, 0, 1),				/* [1] struct {}  */
7069 			BTF_PTR_ENC(1),						/* [2] ptr -> [1] */
7070 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 8),			/* [3] struct s   */
7071 				BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7072 			/* CU 2 */
7073 			BTF_PTR_ENC(0),						/* [4] ptr -> void */
7074 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 8),			/* [5] struct s   */
7075 				BTF_MEMBER_ENC(NAME_NTH(2), 4, 0),
7076 			BTF_END_RAW,
7077 		},
7078 		BTF_STR_SEC("\0s\0x"),
7079 	},
7080 	.opts = {
7081 		.force_collisions = true, /* force hash collisions */
7082 	},
7083 },
7084 {
7085 	.descr = "dedup: all possible kinds (no duplicates)",
7086 	.input = {
7087 		.raw_types = {
7088 			BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 8),		/* [1] int */
7089 			BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 4),	/* [2] enum */
7090 				BTF_ENUM_ENC(NAME_TBD, 0),
7091 				BTF_ENUM_ENC(NAME_TBD, 1),
7092 			BTF_FWD_ENC(NAME_TBD, 1 /* union kind_flag */),			/* [3] fwd */
7093 			BTF_TYPE_ARRAY_ENC(2, 1, 7),					/* [4] array */
7094 			BTF_STRUCT_ENC(NAME_TBD, 1, 4),					/* [5] struct */
7095 				BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7096 			BTF_UNION_ENC(NAME_TBD, 1, 4),					/* [6] union */
7097 				BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7098 			BTF_TYPEDEF_ENC(NAME_TBD, 1),					/* [7] typedef */
7099 			BTF_PTR_ENC(0),							/* [8] ptr */
7100 			BTF_CONST_ENC(8),						/* [9] const */
7101 			BTF_VOLATILE_ENC(8),						/* [10] volatile */
7102 			BTF_RESTRICT_ENC(8),						/* [11] restrict */
7103 			BTF_FUNC_PROTO_ENC(1, 2),					/* [12] func_proto */
7104 				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
7105 				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
7106 			BTF_FUNC_ENC(NAME_TBD, 12),					/* [13] func */
7107 			BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),				/* [14] float */
7108 			BTF_DECL_TAG_ENC(NAME_TBD, 13, -1),				/* [15] decl_tag */
7109 			BTF_DECL_TAG_ENC(NAME_TBD, 13, 1),				/* [16] decl_tag */
7110 			BTF_DECL_TAG_ENC(NAME_TBD, 7, -1),				/* [17] decl_tag */
7111 			BTF_TYPE_TAG_ENC(NAME_TBD, 8),					/* [18] type_tag */
7112 			BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 2), 8),	/* [19] enum64 */
7113 				BTF_ENUM64_ENC(NAME_TBD, 0, 0),
7114 				BTF_ENUM64_ENC(NAME_TBD, 1, 1),
7115 			BTF_END_RAW,
7116 		},
7117 		BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R\0S\0T\0U"),
7118 	},
7119 	.expect = {
7120 		.raw_types = {
7121 			BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 8),		/* [1] int */
7122 			BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 4),	/* [2] enum */
7123 				BTF_ENUM_ENC(NAME_TBD, 0),
7124 				BTF_ENUM_ENC(NAME_TBD, 1),
7125 			BTF_FWD_ENC(NAME_TBD, 1 /* union kind_flag */),			/* [3] fwd */
7126 			BTF_TYPE_ARRAY_ENC(2, 1, 7),					/* [4] array */
7127 			BTF_STRUCT_ENC(NAME_TBD, 1, 4),					/* [5] struct */
7128 				BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7129 			BTF_UNION_ENC(NAME_TBD, 1, 4),					/* [6] union */
7130 				BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7131 			BTF_TYPEDEF_ENC(NAME_TBD, 1),					/* [7] typedef */
7132 			BTF_PTR_ENC(0),							/* [8] ptr */
7133 			BTF_CONST_ENC(8),						/* [9] const */
7134 			BTF_VOLATILE_ENC(8),						/* [10] volatile */
7135 			BTF_RESTRICT_ENC(8),						/* [11] restrict */
7136 			BTF_FUNC_PROTO_ENC(1, 2),					/* [12] func_proto */
7137 				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
7138 				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
7139 			BTF_FUNC_ENC(NAME_TBD, 12),					/* [13] func */
7140 			BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),				/* [14] float */
7141 			BTF_DECL_TAG_ENC(NAME_TBD, 13, -1),				/* [15] decl_tag */
7142 			BTF_DECL_TAG_ENC(NAME_TBD, 13, 1),				/* [16] decl_tag */
7143 			BTF_DECL_TAG_ENC(NAME_TBD, 7, -1),				/* [17] decl_tag */
7144 			BTF_TYPE_TAG_ENC(NAME_TBD, 8),					/* [18] type_tag */
7145 			BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 2), 8),	/* [19] enum64 */
7146 				BTF_ENUM64_ENC(NAME_TBD, 0, 0),
7147 				BTF_ENUM64_ENC(NAME_TBD, 1, 1),
7148 			BTF_END_RAW,
7149 		},
7150 		BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R\0S\0T\0U"),
7151 	},
7152 },
7153 {
7154 	.descr = "dedup: no int/float duplicates",
7155 	.input = {
7156 		.raw_types = {
7157 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 8),
7158 			/* different name */
7159 			BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 8),
7160 			/* different encoding */
7161 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_CHAR, 0, 32, 8),
7162 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_BOOL, 0, 32, 8),
7163 			/* different bit offset */
7164 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 8, 32, 8),
7165 			/* different bit size */
7166 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 27, 8),
7167 			/* different byte size */
7168 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
7169 			/* all allowed sizes */
7170 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 2),
7171 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 4),
7172 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 8),
7173 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 12),
7174 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 16),
7175 			BTF_END_RAW,
7176 		},
7177 		BTF_STR_SEC("\0int\0some other int\0float"),
7178 	},
7179 	.expect = {
7180 		.raw_types = {
7181 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 8),
7182 			/* different name */
7183 			BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 8),
7184 			/* different encoding */
7185 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_CHAR, 0, 32, 8),
7186 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_BOOL, 0, 32, 8),
7187 			/* different bit offset */
7188 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 8, 32, 8),
7189 			/* different bit size */
7190 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 27, 8),
7191 			/* different byte size */
7192 			BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
7193 			/* all allowed sizes */
7194 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 2),
7195 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 4),
7196 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 8),
7197 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 12),
7198 			BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 16),
7199 			BTF_END_RAW,
7200 		},
7201 		BTF_STR_SEC("\0int\0some other int\0float"),
7202 	},
7203 },
7204 {
7205 	.descr = "dedup: enum fwd resolution",
7206 	.input = {
7207 		.raw_types = {
7208 			/* [1] fwd enum 'e1' before full enum */
7209 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 0), 4),
7210 			/* [2] full enum 'e1' after fwd */
7211 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7212 				BTF_ENUM_ENC(NAME_NTH(2), 123),
7213 			/* [3] full enum 'e2' before fwd */
7214 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7215 				BTF_ENUM_ENC(NAME_NTH(4), 456),
7216 			/* [4] fwd enum 'e2' after full enum */
7217 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 0), 4),
7218 			/* [5] fwd enum with different size, size does not matter for fwd */
7219 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 0), 1),
7220 			/* [6] incompatible full enum with different value */
7221 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7222 				BTF_ENUM_ENC(NAME_NTH(2), 321),
7223 			BTF_END_RAW,
7224 		},
7225 		BTF_STR_SEC("\0e1\0e1_val\0e2\0e2_val"),
7226 	},
7227 	.expect = {
7228 		.raw_types = {
7229 			/* [1] full enum 'e1' */
7230 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7231 				BTF_ENUM_ENC(NAME_NTH(2), 123),
7232 			/* [2] full enum 'e2' */
7233 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7234 				BTF_ENUM_ENC(NAME_NTH(4), 456),
7235 			/* [3] incompatible full enum with different value */
7236 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7237 				BTF_ENUM_ENC(NAME_NTH(2), 321),
7238 			BTF_END_RAW,
7239 		},
7240 		BTF_STR_SEC("\0e1\0e1_val\0e2\0e2_val"),
7241 	},
7242 },
7243 {
7244 	.descr = "dedup: datasec and vars pass-through",
7245 	.input = {
7246 		.raw_types = {
7247 			/* int */
7248 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7249 			/* static int t */
7250 			BTF_VAR_ENC(NAME_NTH(2), 1, 0),			/* [2] */
7251 			/* .bss section */				/* [3] */
7252 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
7253 			BTF_VAR_SECINFO_ENC(2, 0, 4),
7254 			/* int, referenced from [5] */
7255 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [4] */
7256 			/* another static int t */
7257 			BTF_VAR_ENC(NAME_NTH(2), 4, 0),			/* [5] */
7258 			/* another .bss section */			/* [6] */
7259 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
7260 			BTF_VAR_SECINFO_ENC(5, 0, 4),
7261 			BTF_END_RAW,
7262 		},
7263 		BTF_STR_SEC("\0.bss\0t"),
7264 	},
7265 	.expect = {
7266 		.raw_types = {
7267 			/* int */
7268 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7269 			/* static int t */
7270 			BTF_VAR_ENC(NAME_NTH(2), 1, 0),			/* [2] */
7271 			/* .bss section */				/* [3] */
7272 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
7273 			BTF_VAR_SECINFO_ENC(2, 0, 4),
7274 			/* another static int t */
7275 			BTF_VAR_ENC(NAME_NTH(2), 1, 0),			/* [4] */
7276 			/* another .bss section */			/* [5] */
7277 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
7278 			BTF_VAR_SECINFO_ENC(4, 0, 4),
7279 			BTF_END_RAW,
7280 		},
7281 		BTF_STR_SEC("\0.bss\0t"),
7282 	},
7283 	.opts = {
7284 		.force_collisions = true
7285 	},
7286 },
7287 {
7288 	.descr = "dedup: func/func_arg/var tags",
7289 	.input = {
7290 		.raw_types = {
7291 			/* int */
7292 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7293 			/* static int t */
7294 			BTF_VAR_ENC(NAME_NTH(1), 1, 0),			/* [2] */
7295 			/* void f(int a1, int a2) */
7296 			BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
7297 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7298 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(3), 1),
7299 			BTF_FUNC_ENC(NAME_NTH(4), 2),			/* [4] */
7300 			/* tag -> t */
7301 			BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1),		/* [5] */
7302 			BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1),		/* [6] */
7303 			/* tag -> func */
7304 			BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1),		/* [7] */
7305 			BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1),		/* [8] */
7306 			/* tag -> func arg a1 */
7307 			BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1),		/* [9] */
7308 			BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1),		/* [10] */
7309 			BTF_END_RAW,
7310 		},
7311 		BTF_STR_SEC("\0t\0a1\0a2\0f\0tag"),
7312 	},
7313 	.expect = {
7314 		.raw_types = {
7315 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7316 			BTF_VAR_ENC(NAME_NTH(1), 1, 0),			/* [2] */
7317 			BTF_FUNC_PROTO_ENC(0, 2),			/* [3] */
7318 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7319 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(3), 1),
7320 			BTF_FUNC_ENC(NAME_NTH(4), 2),			/* [4] */
7321 			BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1),		/* [5] */
7322 			BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1),		/* [6] */
7323 			BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1),		/* [7] */
7324 			BTF_END_RAW,
7325 		},
7326 		BTF_STR_SEC("\0t\0a1\0a2\0f\0tag"),
7327 	},
7328 },
7329 {
7330 	.descr = "dedup: func/func_param tags",
7331 	.input = {
7332 		.raw_types = {
7333 			/* int */
7334 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7335 			/* void f(int a1, int a2) */
7336 			BTF_FUNC_PROTO_ENC(0, 2),			/* [2] */
7337 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
7338 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7339 			BTF_FUNC_ENC(NAME_NTH(3), 2),			/* [3] */
7340 			/* void f(int a1, int a2) */
7341 			BTF_FUNC_PROTO_ENC(0, 2),			/* [4] */
7342 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
7343 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7344 			BTF_FUNC_ENC(NAME_NTH(3), 4),			/* [5] */
7345 			/* tag -> f: tag1, tag2 */
7346 			BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1),		/* [6] */
7347 			BTF_DECL_TAG_ENC(NAME_NTH(5), 3, -1),		/* [7] */
7348 			/* tag -> f/a2: tag1, tag2 */
7349 			BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1),		/* [8] */
7350 			BTF_DECL_TAG_ENC(NAME_NTH(5), 3, 1),		/* [9] */
7351 			/* tag -> f: tag1, tag3 */
7352 			BTF_DECL_TAG_ENC(NAME_NTH(4), 5, -1),		/* [10] */
7353 			BTF_DECL_TAG_ENC(NAME_NTH(6), 5, -1),		/* [11] */
7354 			/* tag -> f/a2: tag1, tag3 */
7355 			BTF_DECL_TAG_ENC(NAME_NTH(4), 5, 1),		/* [12] */
7356 			BTF_DECL_TAG_ENC(NAME_NTH(6), 5, 1),		/* [13] */
7357 			BTF_END_RAW,
7358 		},
7359 		BTF_STR_SEC("\0a1\0a2\0f\0tag1\0tag2\0tag3"),
7360 	},
7361 	.expect = {
7362 		.raw_types = {
7363 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7364 			BTF_FUNC_PROTO_ENC(0, 2),			/* [2] */
7365 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
7366 				BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7367 			BTF_FUNC_ENC(NAME_NTH(3), 2),			/* [3] */
7368 			BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1),		/* [4] */
7369 			BTF_DECL_TAG_ENC(NAME_NTH(5), 3, -1),		/* [5] */
7370 			BTF_DECL_TAG_ENC(NAME_NTH(6), 3, -1),		/* [6] */
7371 			BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1),		/* [7] */
7372 			BTF_DECL_TAG_ENC(NAME_NTH(5), 3, 1),		/* [8] */
7373 			BTF_DECL_TAG_ENC(NAME_NTH(6), 3, 1),		/* [9] */
7374 			BTF_END_RAW,
7375 		},
7376 		BTF_STR_SEC("\0a1\0a2\0f\0tag1\0tag2\0tag3"),
7377 	},
7378 },
7379 {
7380 	.descr = "dedup: struct/struct_member tags",
7381 	.input = {
7382 		.raw_types = {
7383 			/* int */
7384 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7385 			BTF_STRUCT_ENC(NAME_NTH(1), 2, 8),		/* [2] */
7386 				BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
7387 				BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
7388 			BTF_STRUCT_ENC(NAME_NTH(1), 2, 8),		/* [3] */
7389 				BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
7390 				BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
7391 			/* tag -> t: tag1, tag2 */
7392 			BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1),		/* [4] */
7393 			BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1),		/* [5] */
7394 			/* tag -> t/m2: tag1, tag2 */
7395 			BTF_DECL_TAG_ENC(NAME_NTH(4), 2, 1),		/* [6] */
7396 			BTF_DECL_TAG_ENC(NAME_NTH(5), 2, 1),		/* [7] */
7397 			/* tag -> t: tag1, tag3 */
7398 			BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1),		/* [8] */
7399 			BTF_DECL_TAG_ENC(NAME_NTH(6), 3, -1),		/* [9] */
7400 			/* tag -> t/m2: tag1, tag3 */
7401 			BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1),		/* [10] */
7402 			BTF_DECL_TAG_ENC(NAME_NTH(6), 3, 1),		/* [11] */
7403 			BTF_END_RAW,
7404 		},
7405 		BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
7406 	},
7407 	.expect = {
7408 		.raw_types = {
7409 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7410 			BTF_STRUCT_ENC(NAME_NTH(1), 2, 8),		/* [2] */
7411 				BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
7412 				BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
7413 			BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1),		/* [3] */
7414 			BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1),		/* [4] */
7415 			BTF_DECL_TAG_ENC(NAME_NTH(6), 2, -1),		/* [5] */
7416 			BTF_DECL_TAG_ENC(NAME_NTH(4), 2, 1),		/* [6] */
7417 			BTF_DECL_TAG_ENC(NAME_NTH(5), 2, 1),		/* [7] */
7418 			BTF_DECL_TAG_ENC(NAME_NTH(6), 2, 1),		/* [8] */
7419 			BTF_END_RAW,
7420 		},
7421 		BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
7422 	},
7423 },
7424 {
7425 	.descr = "dedup: typedef tags",
7426 	.input = {
7427 		.raw_types = {
7428 			/* int */
7429 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7430 			BTF_TYPEDEF_ENC(NAME_NTH(1), 1),		/* [2] */
7431 			BTF_TYPEDEF_ENC(NAME_NTH(1), 1),		/* [3] */
7432 			/* tag -> t: tag1, tag2 */
7433 			BTF_DECL_TAG_ENC(NAME_NTH(2), 2, -1),		/* [4] */
7434 			BTF_DECL_TAG_ENC(NAME_NTH(3), 2, -1),		/* [5] */
7435 			/* tag -> t: tag1, tag3 */
7436 			BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1),		/* [6] */
7437 			BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1),		/* [7] */
7438 			BTF_END_RAW,
7439 		},
7440 		BTF_STR_SEC("\0t\0tag1\0tag2\0tag3"),
7441 	},
7442 	.expect = {
7443 		.raw_types = {
7444 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7445 			BTF_TYPEDEF_ENC(NAME_NTH(1), 1),		/* [2] */
7446 			BTF_DECL_TAG_ENC(NAME_NTH(2), 2, -1),		/* [3] */
7447 			BTF_DECL_TAG_ENC(NAME_NTH(3), 2, -1),		/* [4] */
7448 			BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1),		/* [5] */
7449 			BTF_END_RAW,
7450 		},
7451 		BTF_STR_SEC("\0t\0tag1\0tag2\0tag3"),
7452 	},
7453 },
7454 {
7455 	.descr = "dedup: btf_type_tag #1",
7456 	.input = {
7457 		.raw_types = {
7458 			/* ptr -> tag2 -> tag1 -> int */
7459 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7460 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
7461 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),		/* [3] */
7462 			BTF_PTR_ENC(3),					/* [4] */
7463 			/* ptr -> tag2 -> tag1 -> int */
7464 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [5] */
7465 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 5),		/* [6] */
7466 			BTF_PTR_ENC(6),					/* [7] */
7467 			/* ptr -> tag1 -> int */
7468 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [8] */
7469 			BTF_PTR_ENC(8),					/* [9] */
7470 			BTF_END_RAW,
7471 		},
7472 		BTF_STR_SEC("\0tag1\0tag2"),
7473 	},
7474 	.expect = {
7475 		.raw_types = {
7476 			/* ptr -> tag2 -> tag1 -> int */
7477 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7478 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
7479 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),		/* [3] */
7480 			BTF_PTR_ENC(3),					/* [4] */
7481 			/* ptr -> tag1 -> int */
7482 			BTF_PTR_ENC(2),					/* [5] */
7483 			BTF_END_RAW,
7484 		},
7485 		BTF_STR_SEC("\0tag1\0tag2"),
7486 	},
7487 },
7488 {
7489 	.descr = "dedup: btf_type_tag #2",
7490 	.input = {
7491 		.raw_types = {
7492 			/* ptr -> tag2 -> tag1 -> int */
7493 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7494 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
7495 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),		/* [3] */
7496 			BTF_PTR_ENC(3),					/* [4] */
7497 			/* ptr -> tag2 -> int */
7498 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 1),		/* [5] */
7499 			BTF_PTR_ENC(5),					/* [6] */
7500 			BTF_END_RAW,
7501 		},
7502 		BTF_STR_SEC("\0tag1\0tag2"),
7503 	},
7504 	.expect = {
7505 		.raw_types = {
7506 			/* ptr -> tag2 -> tag1 -> int */
7507 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7508 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
7509 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),		/* [3] */
7510 			BTF_PTR_ENC(3),					/* [4] */
7511 			/* ptr -> tag2 -> int */
7512 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 1),		/* [5] */
7513 			BTF_PTR_ENC(5),					/* [6] */
7514 			BTF_END_RAW,
7515 		},
7516 		BTF_STR_SEC("\0tag1\0tag2"),
7517 	},
7518 },
7519 {
7520 	.descr = "dedup: btf_type_tag #3",
7521 	.input = {
7522 		.raw_types = {
7523 			/* ptr -> tag2 -> tag1 -> int */
7524 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7525 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
7526 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),		/* [3] */
7527 			BTF_PTR_ENC(3),					/* [4] */
7528 			/* ptr -> tag1 -> tag2 -> int */
7529 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 1),		/* [5] */
7530 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 5),		/* [6] */
7531 			BTF_PTR_ENC(6),					/* [7] */
7532 			BTF_END_RAW,
7533 		},
7534 		BTF_STR_SEC("\0tag1\0tag2"),
7535 	},
7536 	.expect = {
7537 		.raw_types = {
7538 			/* ptr -> tag2 -> tag1 -> int */
7539 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7540 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
7541 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),		/* [3] */
7542 			BTF_PTR_ENC(3),					/* [4] */
7543 			/* ptr -> tag1 -> tag2 -> int */
7544 			BTF_TYPE_TAG_ENC(NAME_NTH(2), 1),		/* [5] */
7545 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 5),		/* [6] */
7546 			BTF_PTR_ENC(6),					/* [7] */
7547 			BTF_END_RAW,
7548 		},
7549 		BTF_STR_SEC("\0tag1\0tag2"),
7550 	},
7551 },
7552 {
7553 	.descr = "dedup: btf_type_tag #4",
7554 	.input = {
7555 		.raw_types = {
7556 			/* ptr -> tag1 -> int */
7557 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7558 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
7559 			BTF_PTR_ENC(2),					/* [3] */
7560 			/* ptr -> tag1 -> long */
7561 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 64, 8),	/* [4] */
7562 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 4),		/* [5] */
7563 			BTF_PTR_ENC(5),					/* [6] */
7564 			BTF_END_RAW,
7565 		},
7566 		BTF_STR_SEC("\0tag1"),
7567 	},
7568 	.expect = {
7569 		.raw_types = {
7570 			/* ptr -> tag1 -> int */
7571 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
7572 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
7573 			BTF_PTR_ENC(2),					/* [3] */
7574 			/* ptr -> tag1 -> long */
7575 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 64, 8),	/* [4] */
7576 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 4),		/* [5] */
7577 			BTF_PTR_ENC(5),					/* [6] */
7578 			BTF_END_RAW,
7579 		},
7580 		BTF_STR_SEC("\0tag1"),
7581 	},
7582 },
7583 {
7584 	.descr = "dedup: btf_type_tag #5, struct",
7585 	.input = {
7586 		.raw_types = {
7587 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),				/* [1] */
7588 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),					/* [2] */
7589 			BTF_TYPE_ENC(NAME_NTH(2), BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 4),	/* [3] */
7590 			BTF_MEMBER_ENC(NAME_NTH(3), 2, BTF_MEMBER_OFFSET(0, 0)),
7591 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),					/* [4] */
7592 			BTF_TYPE_ENC(NAME_NTH(2), BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 4),	/* [5] */
7593 			BTF_MEMBER_ENC(NAME_NTH(3), 4, BTF_MEMBER_OFFSET(0, 0)),
7594 			BTF_END_RAW,
7595 		},
7596 		BTF_STR_SEC("\0tag1\0t\0m"),
7597 	},
7598 	.expect = {
7599 		.raw_types = {
7600 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),				/* [1] */
7601 			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),					/* [2] */
7602 			BTF_TYPE_ENC(NAME_NTH(2), BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 4),	/* [3] */
7603 			BTF_MEMBER_ENC(NAME_NTH(3), 2, BTF_MEMBER_OFFSET(0, 0)),
7604 			BTF_END_RAW,
7605 		},
7606 		BTF_STR_SEC("\0tag1\0t\0m"),
7607 	},
7608 },
7609 {
7610 	.descr = "dedup: enum64, standalone",
7611 	.input = {
7612 		.raw_types = {
7613 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7614 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7615 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7616 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7617 			BTF_END_RAW,
7618 		},
7619 		BTF_STR_SEC("\0e1\0e1_val"),
7620 	},
7621 	.expect = {
7622 		.raw_types = {
7623 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7624 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7625 			BTF_END_RAW,
7626 		},
7627 		BTF_STR_SEC("\0e1\0e1_val"),
7628 	},
7629 },
7630 {
7631 	.descr = "dedup: enum64, fwd resolution",
7632 	.input = {
7633 		.raw_types = {
7634 			/* [1] fwd enum64 'e1' before full enum */
7635 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 0), 8),
7636 			/* [2] full enum64 'e1' after fwd */
7637 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7638 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7639 			/* [3] full enum64 'e2' before fwd */
7640 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7641 				BTF_ENUM64_ENC(NAME_NTH(4), 0, 456),
7642 			/* [4] fwd enum64 'e2' after full enum */
7643 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 0), 8),
7644 			/* [5] incompatible full enum64 with different value */
7645 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7646 				BTF_ENUM64_ENC(NAME_NTH(2), 0, 321),
7647 			BTF_END_RAW,
7648 		},
7649 		BTF_STR_SEC("\0e1\0e1_val\0e2\0e2_val"),
7650 	},
7651 	.expect = {
7652 		.raw_types = {
7653 			/* [1] full enum64 'e1' */
7654 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7655 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7656 			/* [2] full enum64 'e2' */
7657 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7658 				BTF_ENUM64_ENC(NAME_NTH(4), 0, 456),
7659 			/* [3] incompatible full enum64 with different value */
7660 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7661 				BTF_ENUM64_ENC(NAME_NTH(2), 0, 321),
7662 			BTF_END_RAW,
7663 		},
7664 		BTF_STR_SEC("\0e1\0e1_val\0e2\0e2_val"),
7665 	},
7666 },
7667 {
7668 	.descr = "dedup: enum and enum64, no dedup",
7669 	.input = {
7670 		.raw_types = {
7671 			/* [1] enum 'e1' */
7672 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7673 				BTF_ENUM_ENC(NAME_NTH(2), 1),
7674 			/* [2] enum64 'e1' */
7675 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 4),
7676 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 0),
7677 			BTF_END_RAW,
7678 		},
7679 		BTF_STR_SEC("\0e1\0e1_val"),
7680 	},
7681 	.expect = {
7682 		.raw_types = {
7683 			/* [1] enum 'e1' */
7684 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7685 				BTF_ENUM_ENC(NAME_NTH(2), 1),
7686 			/* [2] enum64 'e1' */
7687 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 4),
7688 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 0),
7689 			BTF_END_RAW,
7690 		},
7691 		BTF_STR_SEC("\0e1\0e1_val"),
7692 	},
7693 },
7694 {
7695 	.descr = "dedup: enum of different size: no dedup",
7696 	.input = {
7697 		.raw_types = {
7698 			/* [1] enum 'e1' */
7699 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7700 				BTF_ENUM_ENC(NAME_NTH(2), 1),
7701 			/* [2] enum 'e1' */
7702 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 2),
7703 				BTF_ENUM_ENC(NAME_NTH(2), 1),
7704 			BTF_END_RAW,
7705 		},
7706 		BTF_STR_SEC("\0e1\0e1_val"),
7707 	},
7708 	.expect = {
7709 		.raw_types = {
7710 			/* [1] enum 'e1' */
7711 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7712 				BTF_ENUM_ENC(NAME_NTH(2), 1),
7713 			/* [2] enum 'e1' */
7714 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 2),
7715 				BTF_ENUM_ENC(NAME_NTH(2), 1),
7716 			BTF_END_RAW,
7717 		},
7718 		BTF_STR_SEC("\0e1\0e1_val"),
7719 	},
7720 },
7721 {
7722 	.descr = "dedup: enum fwd to enum64",
7723 	.input = {
7724 		.raw_types = {
7725 			/* [1] enum64 'e1' */
7726 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7727 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 0),
7728 			/* [2] enum 'e1' fwd */
7729 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 0), 4),
7730 			/* [3] typedef enum 'e1' td */
7731 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 2),
7732 			BTF_END_RAW,
7733 		},
7734 		BTF_STR_SEC("\0e1\0e1_val\0td"),
7735 	},
7736 	.expect = {
7737 		.raw_types = {
7738 			/* [1] enum64 'e1' */
7739 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7740 				BTF_ENUM64_ENC(NAME_NTH(2), 1, 0),
7741 			/* [2] typedef enum 'e1' td */
7742 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 1),
7743 			BTF_END_RAW,
7744 		},
7745 		BTF_STR_SEC("\0e1\0e1_val\0td"),
7746 	},
7747 },
7748 {
7749 	.descr = "dedup: enum64 fwd to enum",
7750 	.input = {
7751 		.raw_types = {
7752 			/* [1] enum 'e1' */
7753 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7754 				BTF_ENUM_ENC(NAME_NTH(2), 1),
7755 			/* [2] enum64 'e1' fwd */
7756 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 0), 8),
7757 			/* [3] typedef enum 'e1' td */
7758 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 2),
7759 			BTF_END_RAW,
7760 		},
7761 		BTF_STR_SEC("\0e1\0e1_val\0td"),
7762 	},
7763 	.expect = {
7764 		.raw_types = {
7765 			/* [1] enum 'e1' */
7766 			BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7767 				BTF_ENUM_ENC(NAME_NTH(2), 1),
7768 			/* [2] typedef enum 'e1' td */
7769 			BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 1),
7770 			BTF_END_RAW,
7771 		},
7772 		BTF_STR_SEC("\0e1\0e1_val\0td"),
7773 	},
7774 },
7775 {
7776 	.descr = "dedup: standalone fwd declaration struct",
7777 	/*
7778 	 * Verify that CU1:foo and CU2:foo would be unified and that
7779 	 * typedef/ptr would be updated to point to CU1:foo.
7780 	 *
7781 	 * // CU 1:
7782 	 * struct foo { int x; };
7783 	 *
7784 	 * // CU 2:
7785 	 * struct foo;
7786 	 * typedef struct foo *foo_ptr;
7787 	 */
7788 	.input = {
7789 		.raw_types = {
7790 			/* CU 1 */
7791 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
7792 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7793 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
7794 			/* CU 2 */
7795 			BTF_FWD_ENC(NAME_NTH(1), 0),                   /* [3] */
7796 			BTF_PTR_ENC(3),                                /* [4] */
7797 			BTF_TYPEDEF_ENC(NAME_NTH(3), 4),               /* [5] */
7798 			BTF_END_RAW,
7799 		},
7800 		BTF_STR_SEC("\0foo\0x\0foo_ptr"),
7801 	},
7802 	.expect = {
7803 		.raw_types = {
7804 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
7805 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7806 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
7807 			BTF_PTR_ENC(1),                                /* [3] */
7808 			BTF_TYPEDEF_ENC(NAME_NTH(3), 3),               /* [4] */
7809 			BTF_END_RAW,
7810 		},
7811 		BTF_STR_SEC("\0foo\0x\0foo_ptr"),
7812 	},
7813 },
7814 {
7815 	.descr = "dedup: standalone fwd declaration union",
7816 	/*
7817 	 * Verify that CU1:foo and CU2:foo would be unified and that
7818 	 * typedef/ptr would be updated to point to CU1:foo.
7819 	 * Same as "dedup: standalone fwd declaration struct" but for unions.
7820 	 *
7821 	 * // CU 1:
7822 	 * union foo { int x; };
7823 	 *
7824 	 * // CU 2:
7825 	 * union foo;
7826 	 * typedef union foo *foo_ptr;
7827 	 */
7828 	.input = {
7829 		.raw_types = {
7830 			/* CU 1 */
7831 			BTF_UNION_ENC(NAME_NTH(1), 1, 4),              /* [1] */
7832 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7833 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
7834 			/* CU 2 */
7835 			BTF_FWD_ENC(NAME_TBD, 1),                      /* [3] */
7836 			BTF_PTR_ENC(3),                                /* [4] */
7837 			BTF_TYPEDEF_ENC(NAME_NTH(3), 4),               /* [5] */
7838 			BTF_END_RAW,
7839 		},
7840 		BTF_STR_SEC("\0foo\0x\0foo_ptr"),
7841 	},
7842 	.expect = {
7843 		.raw_types = {
7844 			BTF_UNION_ENC(NAME_NTH(1), 1, 4),              /* [1] */
7845 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7846 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
7847 			BTF_PTR_ENC(1),                                /* [3] */
7848 			BTF_TYPEDEF_ENC(NAME_NTH(3), 3),               /* [4] */
7849 			BTF_END_RAW,
7850 		},
7851 		BTF_STR_SEC("\0foo\0x\0foo_ptr"),
7852 	},
7853 },
7854 {
7855 	.descr = "dedup: standalone fwd declaration wrong kind",
7856 	/*
7857 	 * Negative test for btf_dedup_resolve_fwds:
7858 	 * - CU1:foo is a struct, C2:foo is a union, thus CU2:foo is not deduped;
7859 	 * - typedef/ptr should remain unchanged as well.
7860 	 *
7861 	 * // CU 1:
7862 	 * struct foo { int x; };
7863 	 *
7864 	 * // CU 2:
7865 	 * union foo;
7866 	 * typedef union foo *foo_ptr;
7867 	 */
7868 	.input = {
7869 		.raw_types = {
7870 			/* CU 1 */
7871 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
7872 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7873 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
7874 			/* CU 2 */
7875 			BTF_FWD_ENC(NAME_NTH(3), 1),                   /* [3] */
7876 			BTF_PTR_ENC(3),                                /* [4] */
7877 			BTF_TYPEDEF_ENC(NAME_NTH(3), 4),               /* [5] */
7878 			BTF_END_RAW,
7879 		},
7880 		BTF_STR_SEC("\0foo\0x\0foo_ptr"),
7881 	},
7882 	.expect = {
7883 		.raw_types = {
7884 			/* CU 1 */
7885 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
7886 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7887 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
7888 			/* CU 2 */
7889 			BTF_FWD_ENC(NAME_NTH(3), 1),                   /* [3] */
7890 			BTF_PTR_ENC(3),                                /* [4] */
7891 			BTF_TYPEDEF_ENC(NAME_NTH(3), 4),               /* [5] */
7892 			BTF_END_RAW,
7893 		},
7894 		BTF_STR_SEC("\0foo\0x\0foo_ptr"),
7895 	},
7896 },
7897 {
7898 	.descr = "dedup: standalone fwd declaration name conflict",
7899 	/*
7900 	 * Negative test for btf_dedup_resolve_fwds:
7901 	 * - two candidates for CU2:foo dedup, thus it is unchanged;
7902 	 * - typedef/ptr should remain unchanged as well.
7903 	 *
7904 	 * // CU 1:
7905 	 * struct foo { int x; };
7906 	 *
7907 	 * // CU 2:
7908 	 * struct foo;
7909 	 * typedef struct foo *foo_ptr;
7910 	 *
7911 	 * // CU 3:
7912 	 * struct foo { int x; int y; };
7913 	 */
7914 	.input = {
7915 		.raw_types = {
7916 			/* CU 1 */
7917 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
7918 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7919 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
7920 			/* CU 2 */
7921 			BTF_FWD_ENC(NAME_NTH(1), 0),                   /* [3] */
7922 			BTF_PTR_ENC(3),                                /* [4] */
7923 			BTF_TYPEDEF_ENC(NAME_NTH(4), 4),               /* [5] */
7924 			/* CU 3 */
7925 			BTF_STRUCT_ENC(NAME_NTH(1), 2, 8),             /* [6] */
7926 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7927 			BTF_MEMBER_ENC(NAME_NTH(3), 2, 0),
7928 			BTF_END_RAW,
7929 		},
7930 		BTF_STR_SEC("\0foo\0x\0y\0foo_ptr"),
7931 	},
7932 	.expect = {
7933 		.raw_types = {
7934 			/* CU 1 */
7935 			BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
7936 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7937 			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
7938 			/* CU 2 */
7939 			BTF_FWD_ENC(NAME_NTH(1), 0),                   /* [3] */
7940 			BTF_PTR_ENC(3),                                /* [4] */
7941 			BTF_TYPEDEF_ENC(NAME_NTH(4), 4),               /* [5] */
7942 			/* CU 3 */
7943 			BTF_STRUCT_ENC(NAME_NTH(1), 2, 8),             /* [6] */
7944 			BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7945 			BTF_MEMBER_ENC(NAME_NTH(3), 2, 0),
7946 			BTF_END_RAW,
7947 		},
7948 		BTF_STR_SEC("\0foo\0x\0y\0foo_ptr"),
7949 	},
7950 },
7951 };
7952 
7953 static int btf_type_size(const struct btf_type *t)
7954 {
7955 	int base_size = sizeof(struct btf_type);
7956 	__u16 vlen = BTF_INFO_VLEN(t->info);
7957 	__u16 kind = BTF_INFO_KIND(t->info);
7958 
7959 	switch (kind) {
7960 	case BTF_KIND_FWD:
7961 	case BTF_KIND_CONST:
7962 	case BTF_KIND_VOLATILE:
7963 	case BTF_KIND_RESTRICT:
7964 	case BTF_KIND_PTR:
7965 	case BTF_KIND_TYPEDEF:
7966 	case BTF_KIND_FUNC:
7967 	case BTF_KIND_FLOAT:
7968 	case BTF_KIND_TYPE_TAG:
7969 		return base_size;
7970 	case BTF_KIND_INT:
7971 		return base_size + sizeof(__u32);
7972 	case BTF_KIND_ENUM:
7973 		return base_size + vlen * sizeof(struct btf_enum);
7974 	case BTF_KIND_ENUM64:
7975 		return base_size + vlen * sizeof(struct btf_enum64);
7976 	case BTF_KIND_ARRAY:
7977 		return base_size + sizeof(struct btf_array);
7978 	case BTF_KIND_STRUCT:
7979 	case BTF_KIND_UNION:
7980 		return base_size + vlen * sizeof(struct btf_member);
7981 	case BTF_KIND_FUNC_PROTO:
7982 		return base_size + vlen * sizeof(struct btf_param);
7983 	case BTF_KIND_VAR:
7984 		return base_size + sizeof(struct btf_var);
7985 	case BTF_KIND_DATASEC:
7986 		return base_size + vlen * sizeof(struct btf_var_secinfo);
7987 	case BTF_KIND_DECL_TAG:
7988 		return base_size + sizeof(struct btf_decl_tag);
7989 	default:
7990 		fprintf(stderr, "Unsupported BTF_KIND:%u\n", kind);
7991 		return -EINVAL;
7992 	}
7993 }
7994 
7995 static void dump_btf_strings(const char *strs, __u32 len)
7996 {
7997 	const char *cur = strs;
7998 	int i = 0;
7999 
8000 	while (cur < strs + len) {
8001 		fprintf(stderr, "string #%d: '%s'\n", i, cur);
8002 		cur += strlen(cur) + 1;
8003 		i++;
8004 	}
8005 }
8006 
8007 static void do_test_dedup(unsigned int test_num)
8008 {
8009 	struct btf_dedup_test *test = &dedup_tests[test_num - 1];
8010 	__u32 test_nr_types, expect_nr_types, test_btf_size, expect_btf_size;
8011 	const struct btf_header *test_hdr, *expect_hdr;
8012 	struct btf *test_btf = NULL, *expect_btf = NULL;
8013 	const void *test_btf_data, *expect_btf_data;
8014 	const char *ret_test_next_str, *ret_expect_next_str;
8015 	const char *test_strs, *expect_strs;
8016 	const char *test_str_cur;
8017 	const char *expect_str_cur, *expect_str_end;
8018 	unsigned int raw_btf_size;
8019 	void *raw_btf;
8020 	int err = 0, i;
8021 
8022 	if (!test__start_subtest(test->descr))
8023 		return;
8024 
8025 	raw_btf = btf_raw_create(&hdr_tmpl, test->input.raw_types,
8026 				 test->input.str_sec, test->input.str_sec_size,
8027 				 &raw_btf_size, &ret_test_next_str);
8028 	if (!raw_btf)
8029 		return;
8030 
8031 	test_btf = btf__new((__u8 *)raw_btf, raw_btf_size);
8032 	err = libbpf_get_error(test_btf);
8033 	free(raw_btf);
8034 	if (CHECK(err, "invalid test_btf errno:%d", err)) {
8035 		err = -1;
8036 		goto done;
8037 	}
8038 
8039 	raw_btf = btf_raw_create(&hdr_tmpl, test->expect.raw_types,
8040 				 test->expect.str_sec,
8041 				 test->expect.str_sec_size,
8042 				 &raw_btf_size, &ret_expect_next_str);
8043 	if (!raw_btf)
8044 		return;
8045 	expect_btf = btf__new((__u8 *)raw_btf, raw_btf_size);
8046 	err = libbpf_get_error(expect_btf);
8047 	free(raw_btf);
8048 	if (CHECK(err, "invalid expect_btf errno:%d", err)) {
8049 		err = -1;
8050 		goto done;
8051 	}
8052 
8053 	test->opts.sz = sizeof(test->opts);
8054 	err = btf__dedup(test_btf, &test->opts);
8055 	if (CHECK(err, "btf_dedup failed errno:%d", err)) {
8056 		err = -1;
8057 		goto done;
8058 	}
8059 
8060 	test_btf_data = btf__raw_data(test_btf, &test_btf_size);
8061 	expect_btf_data = btf__raw_data(expect_btf, &expect_btf_size);
8062 	if (CHECK(test_btf_size != expect_btf_size,
8063 		  "test_btf_size:%u != expect_btf_size:%u",
8064 		  test_btf_size, expect_btf_size)) {
8065 		err = -1;
8066 		goto done;
8067 	}
8068 
8069 	test_hdr = test_btf_data;
8070 	test_strs = test_btf_data + sizeof(*test_hdr) + test_hdr->str_off;
8071 	expect_hdr = expect_btf_data;
8072 	expect_strs = expect_btf_data + sizeof(*test_hdr) + expect_hdr->str_off;
8073 	if (CHECK(test_hdr->str_len != expect_hdr->str_len,
8074 		  "test_hdr->str_len:%u != expect_hdr->str_len:%u",
8075 		  test_hdr->str_len, expect_hdr->str_len)) {
8076 		fprintf(stderr, "\ntest strings:\n");
8077 		dump_btf_strings(test_strs, test_hdr->str_len);
8078 		fprintf(stderr, "\nexpected strings:\n");
8079 		dump_btf_strings(expect_strs, expect_hdr->str_len);
8080 		err = -1;
8081 		goto done;
8082 	}
8083 
8084 	expect_str_cur = expect_strs;
8085 	expect_str_end = expect_strs + expect_hdr->str_len;
8086 	while (expect_str_cur < expect_str_end) {
8087 		size_t test_len, expect_len;
8088 		int off;
8089 
8090 		off = btf__find_str(test_btf, expect_str_cur);
8091 		if (CHECK(off < 0, "exp str '%s' not found: %d\n", expect_str_cur, off)) {
8092 			err = -1;
8093 			goto done;
8094 		}
8095 		test_str_cur = btf__str_by_offset(test_btf, off);
8096 
8097 		test_len = strlen(test_str_cur);
8098 		expect_len = strlen(expect_str_cur);
8099 		if (CHECK(test_len != expect_len,
8100 			  "test_len:%zu != expect_len:%zu "
8101 			  "(test_str:%s, expect_str:%s)",
8102 			  test_len, expect_len, test_str_cur, expect_str_cur)) {
8103 			err = -1;
8104 			goto done;
8105 		}
8106 		if (CHECK(strcmp(test_str_cur, expect_str_cur),
8107 			  "test_str:%s != expect_str:%s",
8108 			  test_str_cur, expect_str_cur)) {
8109 			err = -1;
8110 			goto done;
8111 		}
8112 		expect_str_cur += expect_len + 1;
8113 	}
8114 
8115 	test_nr_types = btf__type_cnt(test_btf);
8116 	expect_nr_types = btf__type_cnt(expect_btf);
8117 	if (CHECK(test_nr_types != expect_nr_types,
8118 		  "test_nr_types:%u != expect_nr_types:%u",
8119 		  test_nr_types, expect_nr_types)) {
8120 		err = -1;
8121 		goto done;
8122 	}
8123 
8124 	for (i = 1; i < test_nr_types; i++) {
8125 		const struct btf_type *test_type, *expect_type;
8126 		int test_size, expect_size;
8127 
8128 		test_type = btf__type_by_id(test_btf, i);
8129 		expect_type = btf__type_by_id(expect_btf, i);
8130 		test_size = btf_type_size(test_type);
8131 		expect_size = btf_type_size(expect_type);
8132 
8133 		if (CHECK(test_size != expect_size,
8134 			  "type #%d: test_size:%d != expect_size:%u",
8135 			  i, test_size, expect_size)) {
8136 			err = -1;
8137 			goto done;
8138 		}
8139 		if (CHECK(btf_kind(test_type) != btf_kind(expect_type),
8140 			  "type %d kind: exp %d != got %u\n",
8141 			  i, btf_kind(expect_type), btf_kind(test_type))) {
8142 			err = -1;
8143 			goto done;
8144 		}
8145 		if (CHECK(test_type->info != expect_type->info,
8146 			  "type %d info: exp %d != got %u\n",
8147 			  i, expect_type->info, test_type->info)) {
8148 			err = -1;
8149 			goto done;
8150 		}
8151 		if (CHECK(test_type->size != expect_type->size,
8152 			  "type %d size/type: exp %d != got %u\n",
8153 			  i, expect_type->size, test_type->size)) {
8154 			err = -1;
8155 			goto done;
8156 		}
8157 	}
8158 
8159 done:
8160 	btf__free(test_btf);
8161 	btf__free(expect_btf);
8162 }
8163 
8164 void test_btf(void)
8165 {
8166 	int i;
8167 
8168 	always_log = env.verbosity > VERBOSE_NONE;
8169 
8170 	for (i = 1; i <= ARRAY_SIZE(raw_tests); i++)
8171 		do_test_raw(i);
8172 	for (i = 1; i <= ARRAY_SIZE(get_info_tests); i++)
8173 		do_test_get_info(i);
8174 	for (i = 1; i <= ARRAY_SIZE(file_tests); i++)
8175 		do_test_file(i);
8176 	for (i = 1; i <= ARRAY_SIZE(info_raw_tests); i++)
8177 		do_test_info_raw(i);
8178 	for (i = 1; i <= ARRAY_SIZE(dedup_tests); i++)
8179 		do_test_dedup(i);
8180 	test_pprint();
8181 }
8182