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