]> git.ipfire.org Git - thirdparty/linux.git/blob - lib/test_bpf.c
projects / thirdparty / linux.git / blob
? search:


af0041df2b72ee0c55e8efbabab4554e5e929dff
[thirdparty/linux.git] / lib / test_bpf.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Testsuite for BPF interpreter and BPF JIT compiler
4 *
5 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
6 */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/filter.h>
13 #include <linux/bpf.h>
14 #include <linux/skbuff.h>
15 #include <linux/netdevice.h>
16 #include <linux/if_vlan.h>
17 #include <linux/prandom.h>
18 #include <linux/highmem.h>
19 #include <linux/sched.h>
20
21 /* General test specific settings */
22 #define MAX_SUBTESTS 3
23 #define MAX_TESTRUNS 1000
24 #define MAX_DATA 128
25 #define MAX_INSNS 512
26 #define MAX_K 0xffffFFFF
27
28 /* Few constants used to init test 'skb' */
29 #define SKB_TYPE 3
30 #define SKB_MARK 0x1234aaaa
31 #define SKB_HASH 0x1234aaab
32 #define SKB_QUEUE_MAP 123
33 #define SKB_VLAN_TCI 0xffff
34 #define SKB_VLAN_PRESENT 1
35 #define SKB_DEV_IFINDEX 577
36 #define SKB_DEV_TYPE 588
37
38 /* Redefine REGs to make tests less verbose */
39 #define R0 BPF_REG_0
40 #define R1 BPF_REG_1
41 #define R2 BPF_REG_2
42 #define R3 BPF_REG_3
43 #define R4 BPF_REG_4
44 #define R5 BPF_REG_5
45 #define R6 BPF_REG_6
46 #define R7 BPF_REG_7
47 #define R8 BPF_REG_8
48 #define R9 BPF_REG_9
49 #define R10 BPF_REG_10
50
51 /* Flags that can be passed to test cases */
52 #define FLAG_NO_DATA BIT(0)
53 #define FLAG_EXPECTED_FAIL BIT(1)
54 #define FLAG_SKB_FRAG BIT(2)
55 #define FLAG_VERIFIER_ZEXT BIT(3)
56 #define FLAG_LARGE_MEM BIT(4)
57
58 enum {
59 CLASSIC = BIT(6), /* Old BPF instructions only. */
60 INTERNAL = BIT(7), /* Extended instruction set. */
61 };
62
63 #define TEST_TYPE_MASK (CLASSIC | INTERNAL)
64
65 struct bpf_test {
66 const char *descr;
67 union {
68 struct sock_filter insns[MAX_INSNS];
69 struct bpf_insn insns_int[MAX_INSNS];
70 struct {
71 void *insns;
72 unsigned int len;
73 } ptr;
74 } u;
75 __u8 aux;
76 __u8 data[MAX_DATA];
77 struct {
78 int data_size;
79 __u32 result;
80 } test[MAX_SUBTESTS];
81 int (*fill_helper)(struct bpf_test *self);
82 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
83 __u8 frag_data[MAX_DATA];
84 int stack_depth; /* for eBPF only, since tests don't call verifier */
85 int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
86 };
87
88 /* Large test cases need separate allocation and fill handler. */
89
90 static int bpf_fill_maxinsns1(struct bpf_test *self)
91 {
92 unsigned int len = BPF_MAXINSNS;
93 struct sock_filter *insn;
94 __u32 k = ~0;
95 int i;
96
97 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
98 if (!insn)
99 return -ENOMEM;
100
101 for (i = 0; i < len; i++, k--)
102 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
103
104 self->u.ptr.insns = insn;
105 self->u.ptr.len = len;
106
107 return 0;
108 }
109
110 static int bpf_fill_maxinsns2(struct bpf_test *self)
111 {
112 unsigned int len = BPF_MAXINSNS;
113 struct sock_filter *insn;
114 int i;
115
116 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
117 if (!insn)
118 return -ENOMEM;
119
120 for (i = 0; i < len; i++)
121 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
122
123 self->u.ptr.insns = insn;
124 self->u.ptr.len = len;
125
126 return 0;
127 }
128
129 static int bpf_fill_maxinsns3(struct bpf_test *self)
130 {
131 unsigned int len = BPF_MAXINSNS;
132 struct sock_filter *insn;
133 struct rnd_state rnd;
134 int i;
135
136 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
137 if (!insn)
138 return -ENOMEM;
139
140 prandom_seed_state(&rnd, 3141592653589793238ULL);
141
142 for (i = 0; i < len - 1; i++) {
143 __u32 k = prandom_u32_state(&rnd);
144
145 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
146 }
147
148 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
149
150 self->u.ptr.insns = insn;
151 self->u.ptr.len = len;
152
153 return 0;
154 }
155
156 static int bpf_fill_maxinsns4(struct bpf_test *self)
157 {
158 unsigned int len = BPF_MAXINSNS + 1;
159 struct sock_filter *insn;
160 int i;
161
162 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
163 if (!insn)
164 return -ENOMEM;
165
166 for (i = 0; i < len; i++)
167 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
168
169 self->u.ptr.insns = insn;
170 self->u.ptr.len = len;
171
172 return 0;
173 }
174
175 static int bpf_fill_maxinsns5(struct bpf_test *self)
176 {
177 unsigned int len = BPF_MAXINSNS;
178 struct sock_filter *insn;
179 int i;
180
181 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
182 if (!insn)
183 return -ENOMEM;
184
185 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
186
187 for (i = 1; i < len - 1; i++)
188 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
189
190 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
191
192 self->u.ptr.insns = insn;
193 self->u.ptr.len = len;
194
195 return 0;
196 }
197
198 static int bpf_fill_maxinsns6(struct bpf_test *self)
199 {
200 unsigned int len = BPF_MAXINSNS;
201 struct sock_filter *insn;
202 int i;
203
204 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
205 if (!insn)
206 return -ENOMEM;
207
208 for (i = 0; i < len - 1; i++)
209 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
210 SKF_AD_VLAN_TAG_PRESENT);
211
212 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
213
214 self->u.ptr.insns = insn;
215 self->u.ptr.len = len;
216
217 return 0;
218 }
219
220 static int bpf_fill_maxinsns7(struct bpf_test *self)
221 {
222 unsigned int len = BPF_MAXINSNS;
223 struct sock_filter *insn;
224 int i;
225
226 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
227 if (!insn)
228 return -ENOMEM;
229
230 for (i = 0; i < len - 4; i++)
231 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
232 SKF_AD_CPU);
233
234 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
235 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
236 SKF_AD_CPU);
237 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
238 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
239
240 self->u.ptr.insns = insn;
241 self->u.ptr.len = len;
242
243 return 0;
244 }
245
246 static int bpf_fill_maxinsns8(struct bpf_test *self)
247 {
248 unsigned int len = BPF_MAXINSNS;
249 struct sock_filter *insn;
250 int i, jmp_off = len - 3;
251
252 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
253 if (!insn)
254 return -ENOMEM;
255
256 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
257
258 for (i = 1; i < len - 1; i++)
259 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
260
261 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
262
263 self->u.ptr.insns = insn;
264 self->u.ptr.len = len;
265
266 return 0;
267 }
268
269 static int bpf_fill_maxinsns9(struct bpf_test *self)
270 {
271 unsigned int len = BPF_MAXINSNS;
272 struct bpf_insn *insn;
273 int i;
274
275 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
276 if (!insn)
277 return -ENOMEM;
278
279 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
280 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
281 insn[2] = BPF_EXIT_INSN();
282
283 for (i = 3; i < len - 2; i++)
284 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
285
286 insn[len - 2] = BPF_EXIT_INSN();
287 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
288
289 self->u.ptr.insns = insn;
290 self->u.ptr.len = len;
291
292 return 0;
293 }
294
295 static int bpf_fill_maxinsns10(struct bpf_test *self)
296 {
297 unsigned int len = BPF_MAXINSNS, hlen = len - 2;
298 struct bpf_insn *insn;
299 int i;
300
301 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
302 if (!insn)
303 return -ENOMEM;
304
305 for (i = 0; i < hlen / 2; i++)
306 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
307 for (i = hlen - 1; i > hlen / 2; i--)
308 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
309
310 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
311 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
312 insn[hlen + 1] = BPF_EXIT_INSN();
313
314 self->u.ptr.insns = insn;
315 self->u.ptr.len = len;
316
317 return 0;
318 }
319
320 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
321 unsigned int plen)
322 {
323 struct sock_filter *insn;
324 unsigned int rlen;
325 int i, j;
326
327 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
328 if (!insn)
329 return -ENOMEM;
330
331 rlen = (len % plen) - 1;
332
333 for (i = 0; i + plen < len; i += plen)
334 for (j = 0; j < plen; j++)
335 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
336 plen - 1 - j, 0, 0);
337 for (j = 0; j < rlen; j++)
338 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
339 0, 0);
340
341 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
342
343 self->u.ptr.insns = insn;
344 self->u.ptr.len = len;
345
346 return 0;
347 }
348
349 static int bpf_fill_maxinsns11(struct bpf_test *self)
350 {
351 /* Hits 70 passes on x86_64 and triggers NOPs padding. */
352 return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
353 }
354
355 static int bpf_fill_maxinsns12(struct bpf_test *self)
356 {
357 unsigned int len = BPF_MAXINSNS;
358 struct sock_filter *insn;
359 int i = 0;
360
361 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
362 if (!insn)
363 return -ENOMEM;
364
365 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
366
367 for (i = 1; i < len - 1; i++)
368 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
369
370 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
371
372 self->u.ptr.insns = insn;
373 self->u.ptr.len = len;
374
375 return 0;
376 }
377
378 static int bpf_fill_maxinsns13(struct bpf_test *self)
379 {
380 unsigned int len = BPF_MAXINSNS;
381 struct sock_filter *insn;
382 int i = 0;
383
384 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
385 if (!insn)
386 return -ENOMEM;
387
388 for (i = 0; i < len - 3; i++)
389 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
390
391 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
392 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
393 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
394
395 self->u.ptr.insns = insn;
396 self->u.ptr.len = len;
397
398 return 0;
399 }
400
401 static int bpf_fill_ja(struct bpf_test *self)
402 {
403 /* Hits exactly 11 passes on x86_64 JIT. */
404 return __bpf_fill_ja(self, 12, 9);
405 }
406
407 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
408 {
409 unsigned int len = BPF_MAXINSNS;
410 struct sock_filter *insn;
411 int i;
412
413 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
414 if (!insn)
415 return -ENOMEM;
416
417 for (i = 0; i < len - 1; i += 2) {
418 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
419 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
420 SKF_AD_OFF + SKF_AD_CPU);
421 }
422
423 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
424
425 self->u.ptr.insns = insn;
426 self->u.ptr.len = len;
427
428 return 0;
429 }
430
431 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
432 {
433 unsigned int len = BPF_MAXINSNS;
434 struct bpf_insn *insn;
435 int i;
436
437 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
438 if (!insn)
439 return -ENOMEM;
440
441 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
442 insn[1] = BPF_ST_MEM(size, R10, -40, 42);
443
444 for (i = 2; i < len - 2; i++)
445 insn[i] = BPF_STX_XADD(size, R10, R0, -40);
446
447 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
448 insn[len - 1] = BPF_EXIT_INSN();
449
450 self->u.ptr.insns = insn;
451 self->u.ptr.len = len;
452 self->stack_depth = 40;
453
454 return 0;
455 }
456
457 static int bpf_fill_stxw(struct bpf_test *self)
458 {
459 return __bpf_fill_stxdw(self, BPF_W);
460 }
461
462 static int bpf_fill_stxdw(struct bpf_test *self)
463 {
464 return __bpf_fill_stxdw(self, BPF_DW);
465 }
466
467 static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
468 {
469 struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
470
471 memcpy(insns, tmp, sizeof(tmp));
472 return 2;
473 }
474
475 /*
476 * Branch conversion tests. Complex operations can expand to a lot
477 * of instructions when JITed. This in turn may cause jump offsets
478 * to overflow the field size of the native instruction, triggering
479 * a branch conversion mechanism in some JITs.
480 */
481 static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm, bool alu32)
482 {
483 struct bpf_insn *insns;
484 int len = S16_MAX + 5;
485 int i;
486
487 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
488 if (!insns)
489 return -ENOMEM;
490
491 i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);
492 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
493 insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX);
494 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2);
495 insns[i++] = BPF_EXIT_INSN();
496
497 while (i < len - 1) {
498 static const int ops[] = {
499 BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD,
500 BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD,
501 };
502 int op = ops[(i >> 1) % ARRAY_SIZE(ops)];
503
504 if ((i & 1) || alu32)
505 insns[i++] = BPF_ALU32_REG(op, R0, R1);
506 else
507 insns[i++] = BPF_ALU64_REG(op, R0, R1);
508 }
509
510 insns[i++] = BPF_EXIT_INSN();
511 self->u.ptr.insns = insns;
512 self->u.ptr.len = len;
513 BUG_ON(i != len);
514
515 return 0;
516 }
517
518 /* Branch taken by runtime decision */
519 static int bpf_fill_max_jmp_taken_32(struct bpf_test *self)
520 {
521 return __bpf_fill_max_jmp(self, BPF_JEQ, 1, true);
522 }
523
524 static int bpf_fill_max_jmp_taken(struct bpf_test *self)
525 {
526 return __bpf_fill_max_jmp(self, BPF_JEQ, 1, false);
527 }
528
529 /* Branch not taken by runtime decision */
530 static int bpf_fill_max_jmp_not_taken_32(struct bpf_test *self)
531 {
532 return __bpf_fill_max_jmp(self, BPF_JEQ, 0, true);
533 }
534
535 static int bpf_fill_max_jmp_not_taken(struct bpf_test *self)
536 {
537 return __bpf_fill_max_jmp(self, BPF_JEQ, 0, false);
538 }
539
540 /* Branch always taken, known at JIT time */
541 static int bpf_fill_max_jmp_always_taken_32(struct bpf_test *self)
542 {
543 return __bpf_fill_max_jmp(self, BPF_JGE, 0, true);
544 }
545
546 static int bpf_fill_max_jmp_always_taken(struct bpf_test *self)
547 {
548 return __bpf_fill_max_jmp(self, BPF_JGE, 0, false);
549 }
550
551 /* Branch never taken, known at JIT time */
552 static int bpf_fill_max_jmp_never_taken_32(struct bpf_test *self)
553 {
554 return __bpf_fill_max_jmp(self, BPF_JLT, 0, true);
555 }
556
557 static int bpf_fill_max_jmp_never_taken(struct bpf_test *self)
558 {
559 return __bpf_fill_max_jmp(self, BPF_JLT, 0, false);
560 }
561
562 /* ALU result computation used in tests */
563 static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op)
564 {
565 *res = 0;
566 switch (op) {
567 case BPF_MOV:
568 *res = v2;
569 break;
570 case BPF_AND:
571 *res = v1 & v2;
572 break;
573 case BPF_OR:
574 *res = v1 | v2;
575 break;
576 case BPF_XOR:
577 *res = v1 ^ v2;
578 break;
579 case BPF_LSH:
580 *res = v1 << v2;
581 break;
582 case BPF_RSH:
583 *res = v1 >> v2;
584 break;
585 case BPF_ARSH:
586 *res = v1 >> v2;
587 if (v2 > 0 && v1 > S64_MAX)
588 *res |= ~0ULL << (64 - v2);
589 break;
590 case BPF_ADD:
591 *res = v1 + v2;
592 break;
593 case BPF_SUB:
594 *res = v1 - v2;
595 break;
596 case BPF_MUL:
597 *res = v1 * v2;
598 break;
599 case BPF_DIV:
600 if (v2 == 0)
601 return false;
602 *res = div64_u64(v1, v2);
603 break;
604 case BPF_MOD:
605 if (v2 == 0)
606 return false;
607 div64_u64_rem(v1, v2, res);
608 break;
609 }
610 return true;
611 }
612
613 /* Test an ALU shift operation for all valid shift values */
614 static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
615 u8 mode, bool alu32)
616 {
617 static const s64 regs[] = {
618 0x0123456789abcdefLL, /* dword > 0, word < 0 */
619 0xfedcba9876543210LL, /* dword < 0, word > 0 */
620 0xfedcba0198765432LL, /* dword < 0, word < 0 */
621 0x0123458967abcdefLL, /* dword > 0, word > 0 */
622 };
623 int bits = alu32 ? 32 : 64;
624 int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
625 struct bpf_insn *insn;
626 int imm, k;
627 int i = 0;
628
629 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
630 if (!insn)
631 return -ENOMEM;
632
633 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
634
635 for (k = 0; k < ARRAY_SIZE(regs); k++) {
636 s64 reg = regs[k];
637
638 i += __bpf_ld_imm64(&insn[i], R3, reg);
639
640 for (imm = 0; imm < bits; imm++) {
641 u64 val;
642
643 /* Perform operation */
644 insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
645 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
646 if (alu32) {
647 if (mode == BPF_K)
648 insn[i++] = BPF_ALU32_IMM(op, R1, imm);
649 else
650 insn[i++] = BPF_ALU32_REG(op, R1, R2);
651
652 if (op == BPF_ARSH)
653 reg = (s32)reg;
654 else
655 reg = (u32)reg;
656 __bpf_alu_result(&val, reg, imm, op);
657 val = (u32)val;
658 } else {
659 if (mode == BPF_K)
660 insn[i++] = BPF_ALU64_IMM(op, R1, imm);
661 else
662 insn[i++] = BPF_ALU64_REG(op, R1, R2);
663 __bpf_alu_result(&val, reg, imm, op);
664 }
665
666 /*
667 * When debugging a JIT that fails this test, one
668 * can write the immediate value to R0 here to find
669 * out which operand values that fail.
670 */
671
672 /* Load reference and check the result */
673 i += __bpf_ld_imm64(&insn[i], R4, val);
674 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
675 insn[i++] = BPF_EXIT_INSN();
676 }
677 }
678
679 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
680 insn[i++] = BPF_EXIT_INSN();
681
682 self->u.ptr.insns = insn;
683 self->u.ptr.len = len;
684 BUG_ON(i != len);
685
686 return 0;
687 }
688
689 static int bpf_fill_alu64_lsh_imm(struct bpf_test *self)
690 {
691 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false);
692 }
693
694 static int bpf_fill_alu64_rsh_imm(struct bpf_test *self)
695 {
696 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false);
697 }
698
699 static int bpf_fill_alu64_arsh_imm(struct bpf_test *self)
700 {
701 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false);
702 }
703
704 static int bpf_fill_alu64_lsh_reg(struct bpf_test *self)
705 {
706 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false);
707 }
708
709 static int bpf_fill_alu64_rsh_reg(struct bpf_test *self)
710 {
711 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false);
712 }
713
714 static int bpf_fill_alu64_arsh_reg(struct bpf_test *self)
715 {
716 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false);
717 }
718
719 static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
720 {
721 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true);
722 }
723
724 static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
725 {
726 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true);
727 }
728
729 static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
730 {
731 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true);
732 }
733
734 static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
735 {
736 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true);
737 }
738
739 static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
740 {
741 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true);
742 }
743
744 static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
745 {
746 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true);
747 }
748
749 /*
750 * Test an ALU register shift operation for all valid shift values
751 * for the case when the source and destination are the same.
752 */
753 static int __bpf_fill_alu_shift_same_reg(struct bpf_test *self, u8 op,
754 bool alu32)
755 {
756 int bits = alu32 ? 32 : 64;
757 int len = 3 + 6 * bits;
758 struct bpf_insn *insn;
759 int i = 0;
760 u64 val;
761
762 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
763 if (!insn)
764 return -ENOMEM;
765
766 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
767
768 for (val = 0; val < bits; val++) {
769 u64 res;
770
771 /* Perform operation */
772 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R1, val);
773 if (alu32)
774 insn[i++] = BPF_ALU32_REG(op, R1, R1);
775 else
776 insn[i++] = BPF_ALU64_REG(op, R1, R1);
777
778 /* Compute the reference result */
779 __bpf_alu_result(&res, val, val, op);
780 if (alu32)
781 res = (u32)res;
782 i += __bpf_ld_imm64(&insn[i], R2, res);
783
784 /* Check the actual result */
785 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
786 insn[i++] = BPF_EXIT_INSN();
787 }
788
789 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
790 insn[i++] = BPF_EXIT_INSN();
791
792 self->u.ptr.insns = insn;
793 self->u.ptr.len = len;
794 BUG_ON(i != len);
795
796 return 0;
797 }
798
799 static int bpf_fill_alu64_lsh_same_reg(struct bpf_test *self)
800 {
801 return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, false);
802 }
803
804 static int bpf_fill_alu64_rsh_same_reg(struct bpf_test *self)
805 {
806 return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, false);
807 }
808
809 static int bpf_fill_alu64_arsh_same_reg(struct bpf_test *self)
810 {
811 return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, false);
812 }
813
814 static int bpf_fill_alu32_lsh_same_reg(struct bpf_test *self)
815 {
816 return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, true);
817 }
818
819 static int bpf_fill_alu32_rsh_same_reg(struct bpf_test *self)
820 {
821 return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, true);
822 }
823
824 static int bpf_fill_alu32_arsh_same_reg(struct bpf_test *self)
825 {
826 return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, true);
827 }
828
829 /*
830 * Common operand pattern generator for exhaustive power-of-two magnitudes
831 * tests. The block size parameters can be adjusted to increase/reduce the
832 * number of combinatons tested and thereby execution speed and memory
833 * footprint.
834 */
835
836 static inline s64 value(int msb, int delta, int sign)
837 {
838 return sign * (1LL << msb) + delta;
839 }
840
841 static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
842 int dbits, int sbits, int block1, int block2,
843 int (*emit)(struct bpf_test*, void*,
844 struct bpf_insn*, s64, s64))
845 {
846 static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
847 struct bpf_insn *insns;
848 int di, si, bt, db, sb;
849 int count, len, k;
850 int extra = 1 + 2;
851 int i = 0;
852
853 /* Total number of iterations for the two pattern */
854 count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
855 count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
856
857 /* Compute the maximum number of insns and allocate the buffer */
858 len = extra + count * (*emit)(self, arg, NULL, 0, 0);
859 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
860 if (!insns)
861 return -ENOMEM;
862
863 /* Add head instruction(s) */
864 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
865
866 /*
867 * Pattern 1: all combinations of power-of-two magnitudes and sign,
868 * and with a block of contiguous values around each magnitude.
869 */
870 for (di = 0; di < dbits - 1; di++) /* Dst magnitudes */
871 for (si = 0; si < sbits - 1; si++) /* Src magnitudes */
872 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
873 for (db = -(block1 / 2);
874 db < (block1 + 1) / 2; db++)
875 for (sb = -(block1 / 2);
876 sb < (block1 + 1) / 2; sb++) {
877 s64 dst, src;
878
879 dst = value(di, db, sgn[k][0]);
880 src = value(si, sb, sgn[k][1]);
881 i += (*emit)(self, arg,
882 &insns[i],
883 dst, src);
884 }
885 /*
886 * Pattern 2: all combinations for a larger block of values
887 * for each power-of-two magnitude and sign, where the magnitude is
888 * the same for both operands.
889 */
890 for (bt = 0; bt < max(dbits, sbits) - 1; bt++) /* Magnitude */
891 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
892 for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
893 for (sb = -(block2 / 2);
894 sb < (block2 + 1) / 2; sb++) {
895 s64 dst, src;
896
897 dst = value(bt % dbits, db, sgn[k][0]);
898 src = value(bt % sbits, sb, sgn[k][1]);
899 i += (*emit)(self, arg, &insns[i],
900 dst, src);
901 }
902
903 /* Append tail instructions */
904 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
905 insns[i++] = BPF_EXIT_INSN();
906 BUG_ON(i > len);
907
908 self->u.ptr.insns = insns;
909 self->u.ptr.len = i;
910
911 return 0;
912 }
913
914 /*
915 * Block size parameters used in pattern tests below. une as needed to
916 * increase/reduce the number combinations tested, see following examples.
917 * block values per operand MSB
918 * ----------------------------------------
919 * 0 none
920 * 1 (1 << MSB)
921 * 2 (1 << MSB) + [-1, 0]
922 * 3 (1 << MSB) + [-1, 0, 1]
923 */
924 #define PATTERN_BLOCK1 1
925 #define PATTERN_BLOCK2 5
926
927 /* Number of test runs for a pattern test */
928 #define NR_PATTERN_RUNS 1
929
930 /*
931 * Exhaustive tests of ALU operations for all combinations of power-of-two
932 * magnitudes of the operands, both for positive and negative values. The
933 * test is designed to verify e.g. the ALU and ALU64 operations for JITs that
934 * emit different code depending on the magnitude of the immediate value.
935 */
936 static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
937 struct bpf_insn *insns, s64 dst, s64 imm)
938 {
939 int op = *(int *)arg;
940 int i = 0;
941 u64 res;
942
943 if (!insns)
944 return 7;
945
946 if (__bpf_alu_result(&res, dst, (s32)imm, op)) {
947 i += __bpf_ld_imm64(&insns[i], R1, dst);
948 i += __bpf_ld_imm64(&insns[i], R3, res);
949 insns[i++] = BPF_ALU64_IMM(op, R1, imm);
950 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
951 insns[i++] = BPF_EXIT_INSN();
952 }
953
954 return i;
955 }
956
957 static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
958 struct bpf_insn *insns, s64 dst, s64 imm)
959 {
960 int op = *(int *)arg;
961 int i = 0;
962 u64 res;
963
964 if (!insns)
965 return 7;
966
967 if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {
968 i += __bpf_ld_imm64(&insns[i], R1, dst);
969 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
970 insns[i++] = BPF_ALU32_IMM(op, R1, imm);
971 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
972 insns[i++] = BPF_EXIT_INSN();
973 }
974
975 return i;
976 }
977
978 static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
979 struct bpf_insn *insns, s64 dst, s64 src)
980 {
981 int op = *(int *)arg;
982 int i = 0;
983 u64 res;
984
985 if (!insns)
986 return 9;
987
988 if (__bpf_alu_result(&res, dst, src, op)) {
989 i += __bpf_ld_imm64(&insns[i], R1, dst);
990 i += __bpf_ld_imm64(&insns[i], R2, src);
991 i += __bpf_ld_imm64(&insns[i], R3, res);
992 insns[i++] = BPF_ALU64_REG(op, R1, R2);
993 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
994 insns[i++] = BPF_EXIT_INSN();
995 }
996
997 return i;
998 }
999
1000 static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
1001 struct bpf_insn *insns, s64 dst, s64 src)
1002 {
1003 int op = *(int *)arg;
1004 int i = 0;
1005 u64 res;
1006
1007 if (!insns)
1008 return 9;
1009
1010 if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {
1011 i += __bpf_ld_imm64(&insns[i], R1, dst);
1012 i += __bpf_ld_imm64(&insns[i], R2, src);
1013 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1014 insns[i++] = BPF_ALU32_REG(op, R1, R2);
1015 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1016 insns[i++] = BPF_EXIT_INSN();
1017 }
1018
1019 return i;
1020 }
1021
1022 static int __bpf_fill_alu64_imm(struct bpf_test *self, int op)
1023 {
1024 return __bpf_fill_pattern(self, &op, 64, 32,
1025 PATTERN_BLOCK1, PATTERN_BLOCK2,
1026 &__bpf_emit_alu64_imm);
1027 }
1028
1029 static int __bpf_fill_alu32_imm(struct bpf_test *self, int op)
1030 {
1031 return __bpf_fill_pattern(self, &op, 64, 32,
1032 PATTERN_BLOCK1, PATTERN_BLOCK2,
1033 &__bpf_emit_alu32_imm);
1034 }
1035
1036 static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
1037 {
1038 return __bpf_fill_pattern(self, &op, 64, 64,
1039 PATTERN_BLOCK1, PATTERN_BLOCK2,
1040 &__bpf_emit_alu64_reg);
1041 }
1042
1043 static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
1044 {
1045 return __bpf_fill_pattern(self, &op, 64, 64,
1046 PATTERN_BLOCK1, PATTERN_BLOCK2,
1047 &__bpf_emit_alu32_reg);
1048 }
1049
1050 /* ALU64 immediate operations */
1051 static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
1052 {
1053 return __bpf_fill_alu64_imm(self, BPF_MOV);
1054 }
1055
1056 static int bpf_fill_alu64_and_imm(struct bpf_test *self)
1057 {
1058 return __bpf_fill_alu64_imm(self, BPF_AND);
1059 }
1060
1061 static int bpf_fill_alu64_or_imm(struct bpf_test *self)
1062 {
1063 return __bpf_fill_alu64_imm(self, BPF_OR);
1064 }
1065
1066 static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
1067 {
1068 return __bpf_fill_alu64_imm(self, BPF_XOR);
1069 }
1070
1071 static int bpf_fill_alu64_add_imm(struct bpf_test *self)
1072 {
1073 return __bpf_fill_alu64_imm(self, BPF_ADD);
1074 }
1075
1076 static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
1077 {
1078 return __bpf_fill_alu64_imm(self, BPF_SUB);
1079 }
1080
1081 static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
1082 {
1083 return __bpf_fill_alu64_imm(self, BPF_MUL);
1084 }
1085
1086 static int bpf_fill_alu64_div_imm(struct bpf_test *self)
1087 {
1088 return __bpf_fill_alu64_imm(self, BPF_DIV);
1089 }
1090
1091 static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
1092 {
1093 return __bpf_fill_alu64_imm(self, BPF_MOD);
1094 }
1095
1096 /* ALU32 immediate operations */
1097 static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
1098 {
1099 return __bpf_fill_alu32_imm(self, BPF_MOV);
1100 }
1101
1102 static int bpf_fill_alu32_and_imm(struct bpf_test *self)
1103 {
1104 return __bpf_fill_alu32_imm(self, BPF_AND);
1105 }
1106
1107 static int bpf_fill_alu32_or_imm(struct bpf_test *self)
1108 {
1109 return __bpf_fill_alu32_imm(self, BPF_OR);
1110 }
1111
1112 static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
1113 {
1114 return __bpf_fill_alu32_imm(self, BPF_XOR);
1115 }
1116
1117 static int bpf_fill_alu32_add_imm(struct bpf_test *self)
1118 {
1119 return __bpf_fill_alu32_imm(self, BPF_ADD);
1120 }
1121
1122 static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
1123 {
1124 return __bpf_fill_alu32_imm(self, BPF_SUB);
1125 }
1126
1127 static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1128 {
1129 return __bpf_fill_alu32_imm(self, BPF_MUL);
1130 }
1131
1132 static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1133 {
1134 return __bpf_fill_alu32_imm(self, BPF_DIV);
1135 }
1136
1137 static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1138 {
1139 return __bpf_fill_alu32_imm(self, BPF_MOD);
1140 }
1141
1142 /* ALU64 register operations */
1143 static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1144 {
1145 return __bpf_fill_alu64_reg(self, BPF_MOV);
1146 }
1147
1148 static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1149 {
1150 return __bpf_fill_alu64_reg(self, BPF_AND);
1151 }
1152
1153 static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1154 {
1155 return __bpf_fill_alu64_reg(self, BPF_OR);
1156 }
1157
1158 static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1159 {
1160 return __bpf_fill_alu64_reg(self, BPF_XOR);
1161 }
1162
1163 static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1164 {
1165 return __bpf_fill_alu64_reg(self, BPF_ADD);
1166 }
1167
1168 static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1169 {
1170 return __bpf_fill_alu64_reg(self, BPF_SUB);
1171 }
1172
1173 static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1174 {
1175 return __bpf_fill_alu64_reg(self, BPF_MUL);
1176 }
1177
1178 static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1179 {
1180 return __bpf_fill_alu64_reg(self, BPF_DIV);
1181 }
1182
1183 static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1184 {
1185 return __bpf_fill_alu64_reg(self, BPF_MOD);
1186 }
1187
1188 /* ALU32 register operations */
1189 static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1190 {
1191 return __bpf_fill_alu32_reg(self, BPF_MOV);
1192 }
1193
1194 static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1195 {
1196 return __bpf_fill_alu32_reg(self, BPF_AND);
1197 }
1198
1199 static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1200 {
1201 return __bpf_fill_alu32_reg(self, BPF_OR);
1202 }
1203
1204 static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1205 {
1206 return __bpf_fill_alu32_reg(self, BPF_XOR);
1207 }
1208
1209 static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1210 {
1211 return __bpf_fill_alu32_reg(self, BPF_ADD);
1212 }
1213
1214 static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1215 {
1216 return __bpf_fill_alu32_reg(self, BPF_SUB);
1217 }
1218
1219 static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1220 {
1221 return __bpf_fill_alu32_reg(self, BPF_MUL);
1222 }
1223
1224 static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1225 {
1226 return __bpf_fill_alu32_reg(self, BPF_DIV);
1227 }
1228
1229 static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1230 {
1231 return __bpf_fill_alu32_reg(self, BPF_MOD);
1232 }
1233
1234 /*
1235 * Test JITs that implement complex ALU operations as function
1236 * calls, and must re-arrange operands for argument passing.
1237 */
1238 static int __bpf_fill_alu_imm_regs(struct bpf_test *self, u8 op, bool alu32)
1239 {
1240 int len = 2 + 10 * 10;
1241 struct bpf_insn *insns;
1242 u64 dst, res;
1243 int i = 0;
1244 u32 imm;
1245 int rd;
1246
1247 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1248 if (!insns)
1249 return -ENOMEM;
1250
1251 /* Operand and result values according to operation */
1252 if (alu32)
1253 dst = 0x76543210U;
1254 else
1255 dst = 0x7edcba9876543210ULL;
1256 imm = 0x01234567U;
1257
1258 if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1259 imm &= 31;
1260
1261 __bpf_alu_result(&res, dst, imm, op);
1262
1263 if (alu32)
1264 res = (u32)res;
1265
1266 /* Check all operand registers */
1267 for (rd = R0; rd <= R9; rd++) {
1268 i += __bpf_ld_imm64(&insns[i], rd, dst);
1269
1270 if (alu32)
1271 insns[i++] = BPF_ALU32_IMM(op, rd, imm);
1272 else
1273 insns[i++] = BPF_ALU64_IMM(op, rd, imm);
1274
1275 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res, 2);
1276 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1277 insns[i++] = BPF_EXIT_INSN();
1278
1279 insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1280 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res >> 32, 2);
1281 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1282 insns[i++] = BPF_EXIT_INSN();
1283 }
1284
1285 insns[i++] = BPF_MOV64_IMM(R0, 1);
1286 insns[i++] = BPF_EXIT_INSN();
1287
1288 self->u.ptr.insns = insns;
1289 self->u.ptr.len = len;
1290 BUG_ON(i != len);
1291
1292 return 0;
1293 }
1294
1295 /* ALU64 K registers */
1296 static int bpf_fill_alu64_mov_imm_regs(struct bpf_test *self)
1297 {
1298 return __bpf_fill_alu_imm_regs(self, BPF_MOV, false);
1299 }
1300
1301 static int bpf_fill_alu64_and_imm_regs(struct bpf_test *self)
1302 {
1303 return __bpf_fill_alu_imm_regs(self, BPF_AND, false);
1304 }
1305
1306 static int bpf_fill_alu64_or_imm_regs(struct bpf_test *self)
1307 {
1308 return __bpf_fill_alu_imm_regs(self, BPF_OR, false);
1309 }
1310
1311 static int bpf_fill_alu64_xor_imm_regs(struct bpf_test *self)
1312 {
1313 return __bpf_fill_alu_imm_regs(self, BPF_XOR, false);
1314 }
1315
1316 static int bpf_fill_alu64_lsh_imm_regs(struct bpf_test *self)
1317 {
1318 return __bpf_fill_alu_imm_regs(self, BPF_LSH, false);
1319 }
1320
1321 static int bpf_fill_alu64_rsh_imm_regs(struct bpf_test *self)
1322 {
1323 return __bpf_fill_alu_imm_regs(self, BPF_RSH, false);
1324 }
1325
1326 static int bpf_fill_alu64_arsh_imm_regs(struct bpf_test *self)
1327 {
1328 return __bpf_fill_alu_imm_regs(self, BPF_ARSH, false);
1329 }
1330
1331 static int bpf_fill_alu64_add_imm_regs(struct bpf_test *self)
1332 {
1333 return __bpf_fill_alu_imm_regs(self, BPF_ADD, false);
1334 }
1335
1336 static int bpf_fill_alu64_sub_imm_regs(struct bpf_test *self)
1337 {
1338 return __bpf_fill_alu_imm_regs(self, BPF_SUB, false);
1339 }
1340
1341 static int bpf_fill_alu64_mul_imm_regs(struct bpf_test *self)
1342 {
1343 return __bpf_fill_alu_imm_regs(self, BPF_MUL, false);
1344 }
1345
1346 static int bpf_fill_alu64_div_imm_regs(struct bpf_test *self)
1347 {
1348 return __bpf_fill_alu_imm_regs(self, BPF_DIV, false);
1349 }
1350
1351 static int bpf_fill_alu64_mod_imm_regs(struct bpf_test *self)
1352 {
1353 return __bpf_fill_alu_imm_regs(self, BPF_MOD, false);
1354 }
1355
1356 /* ALU32 K registers */
1357 static int bpf_fill_alu32_mov_imm_regs(struct bpf_test *self)
1358 {
1359 return __bpf_fill_alu_imm_regs(self, BPF_MOV, true);
1360 }
1361
1362 static int bpf_fill_alu32_and_imm_regs(struct bpf_test *self)
1363 {
1364 return __bpf_fill_alu_imm_regs(self, BPF_AND, true);
1365 }
1366
1367 static int bpf_fill_alu32_or_imm_regs(struct bpf_test *self)
1368 {
1369 return __bpf_fill_alu_imm_regs(self, BPF_OR, true);
1370 }
1371
1372 static int bpf_fill_alu32_xor_imm_regs(struct bpf_test *self)
1373 {
1374 return __bpf_fill_alu_imm_regs(self, BPF_XOR, true);
1375 }
1376
1377 static int bpf_fill_alu32_lsh_imm_regs(struct bpf_test *self)
1378 {
1379 return __bpf_fill_alu_imm_regs(self, BPF_LSH, true);
1380 }
1381
1382 static int bpf_fill_alu32_rsh_imm_regs(struct bpf_test *self)
1383 {
1384 return __bpf_fill_alu_imm_regs(self, BPF_RSH, true);
1385 }
1386
1387 static int bpf_fill_alu32_arsh_imm_regs(struct bpf_test *self)
1388 {
1389 return __bpf_fill_alu_imm_regs(self, BPF_ARSH, true);
1390 }
1391
1392 static int bpf_fill_alu32_add_imm_regs(struct bpf_test *self)
1393 {
1394 return __bpf_fill_alu_imm_regs(self, BPF_ADD, true);
1395 }
1396
1397 static int bpf_fill_alu32_sub_imm_regs(struct bpf_test *self)
1398 {
1399 return __bpf_fill_alu_imm_regs(self, BPF_SUB, true);
1400 }
1401
1402 static int bpf_fill_alu32_mul_imm_regs(struct bpf_test *self)
1403 {
1404 return __bpf_fill_alu_imm_regs(self, BPF_MUL, true);
1405 }
1406
1407 static int bpf_fill_alu32_div_imm_regs(struct bpf_test *self)
1408 {
1409 return __bpf_fill_alu_imm_regs(self, BPF_DIV, true);
1410 }
1411
1412 static int bpf_fill_alu32_mod_imm_regs(struct bpf_test *self)
1413 {
1414 return __bpf_fill_alu_imm_regs(self, BPF_MOD, true);
1415 }
1416
1417 /*
1418 * Test JITs that implement complex ALU operations as function
1419 * calls, and must re-arrange operands for argument passing.
1420 */
1421 static int __bpf_fill_alu_reg_pairs(struct bpf_test *self, u8 op, bool alu32)
1422 {
1423 int len = 2 + 10 * 10 * 12;
1424 u64 dst, src, res, same;
1425 struct bpf_insn *insns;
1426 int rd, rs;
1427 int i = 0;
1428
1429 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1430 if (!insns)
1431 return -ENOMEM;
1432
1433 /* Operand and result values according to operation */
1434 if (alu32) {
1435 dst = 0x76543210U;
1436 src = 0x01234567U;
1437 } else {
1438 dst = 0x7edcba9876543210ULL;
1439 src = 0x0123456789abcdefULL;
1440 }
1441
1442 if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH)
1443 src &= 31;
1444
1445 __bpf_alu_result(&res, dst, src, op);
1446 __bpf_alu_result(&same, src, src, op);
1447
1448 if (alu32) {
1449 res = (u32)res;
1450 same = (u32)same;
1451 }
1452
1453 /* Check all combinations of operand registers */
1454 for (rd = R0; rd <= R9; rd++) {
1455 for (rs = R0; rs <= R9; rs++) {
1456 u64 val = rd == rs ? same : res;
1457
1458 i += __bpf_ld_imm64(&insns[i], rd, dst);
1459 i += __bpf_ld_imm64(&insns[i], rs, src);
1460
1461 if (alu32)
1462 insns[i++] = BPF_ALU32_REG(op, rd, rs);
1463 else
1464 insns[i++] = BPF_ALU64_REG(op, rd, rs);
1465
1466 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val, 2);
1467 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1468 insns[i++] = BPF_EXIT_INSN();
1469
1470 insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32);
1471 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val >> 32, 2);
1472 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1473 insns[i++] = BPF_EXIT_INSN();
1474 }
1475 }
1476
1477 insns[i++] = BPF_MOV64_IMM(R0, 1);
1478 insns[i++] = BPF_EXIT_INSN();
1479
1480 self->u.ptr.insns = insns;
1481 self->u.ptr.len = len;
1482 BUG_ON(i != len);
1483
1484 return 0;
1485 }
1486
1487 /* ALU64 X register combinations */
1488 static int bpf_fill_alu64_mov_reg_pairs(struct bpf_test *self)
1489 {
1490 return __bpf_fill_alu_reg_pairs(self, BPF_MOV, false);
1491 }
1492
1493 static int bpf_fill_alu64_and_reg_pairs(struct bpf_test *self)
1494 {
1495 return __bpf_fill_alu_reg_pairs(self, BPF_AND, false);
1496 }
1497
1498 static int bpf_fill_alu64_or_reg_pairs(struct bpf_test *self)
1499 {
1500 return __bpf_fill_alu_reg_pairs(self, BPF_OR, false);
1501 }
1502
1503 static int bpf_fill_alu64_xor_reg_pairs(struct bpf_test *self)
1504 {
1505 return __bpf_fill_alu_reg_pairs(self, BPF_XOR, false);
1506 }
1507
1508 static int bpf_fill_alu64_lsh_reg_pairs(struct bpf_test *self)
1509 {
1510 return __bpf_fill_alu_reg_pairs(self, BPF_LSH, false);
1511 }
1512
1513 static int bpf_fill_alu64_rsh_reg_pairs(struct bpf_test *self)
1514 {
1515 return __bpf_fill_alu_reg_pairs(self, BPF_RSH, false);
1516 }
1517
1518 static int bpf_fill_alu64_arsh_reg_pairs(struct bpf_test *self)
1519 {
1520 return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, false);
1521 }
1522
1523 static int bpf_fill_alu64_add_reg_pairs(struct bpf_test *self)
1524 {
1525 return __bpf_fill_alu_reg_pairs(self, BPF_ADD, false);
1526 }
1527
1528 static int bpf_fill_alu64_sub_reg_pairs(struct bpf_test *self)
1529 {
1530 return __bpf_fill_alu_reg_pairs(self, BPF_SUB, false);
1531 }
1532
1533 static int bpf_fill_alu64_mul_reg_pairs(struct bpf_test *self)
1534 {
1535 return __bpf_fill_alu_reg_pairs(self, BPF_MUL, false);
1536 }
1537
1538 static int bpf_fill_alu64_div_reg_pairs(struct bpf_test *self)
1539 {
1540 return __bpf_fill_alu_reg_pairs(self, BPF_DIV, false);
1541 }
1542
1543 static int bpf_fill_alu64_mod_reg_pairs(struct bpf_test *self)
1544 {
1545 return __bpf_fill_alu_reg_pairs(self, BPF_MOD, false);
1546 }
1547
1548 /* ALU32 X register combinations */
1549 static int bpf_fill_alu32_mov_reg_pairs(struct bpf_test *self)
1550 {
1551 return __bpf_fill_alu_reg_pairs(self, BPF_MOV, true);
1552 }
1553
1554 static int bpf_fill_alu32_and_reg_pairs(struct bpf_test *self)
1555 {
1556 return __bpf_fill_alu_reg_pairs(self, BPF_AND, true);
1557 }
1558
1559 static int bpf_fill_alu32_or_reg_pairs(struct bpf_test *self)
1560 {
1561 return __bpf_fill_alu_reg_pairs(self, BPF_OR, true);
1562 }
1563
1564 static int bpf_fill_alu32_xor_reg_pairs(struct bpf_test *self)
1565 {
1566 return __bpf_fill_alu_reg_pairs(self, BPF_XOR, true);
1567 }
1568
1569 static int bpf_fill_alu32_lsh_reg_pairs(struct bpf_test *self)
1570 {
1571 return __bpf_fill_alu_reg_pairs(self, BPF_LSH, true);
1572 }
1573
1574 static int bpf_fill_alu32_rsh_reg_pairs(struct bpf_test *self)
1575 {
1576 return __bpf_fill_alu_reg_pairs(self, BPF_RSH, true);
1577 }
1578
1579 static int bpf_fill_alu32_arsh_reg_pairs(struct bpf_test *self)
1580 {
1581 return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, true);
1582 }
1583
1584 static int bpf_fill_alu32_add_reg_pairs(struct bpf_test *self)
1585 {
1586 return __bpf_fill_alu_reg_pairs(self, BPF_ADD, true);
1587 }
1588
1589 static int bpf_fill_alu32_sub_reg_pairs(struct bpf_test *self)
1590 {
1591 return __bpf_fill_alu_reg_pairs(self, BPF_SUB, true);
1592 }
1593
1594 static int bpf_fill_alu32_mul_reg_pairs(struct bpf_test *self)
1595 {
1596 return __bpf_fill_alu_reg_pairs(self, BPF_MUL, true);
1597 }
1598
1599 static int bpf_fill_alu32_div_reg_pairs(struct bpf_test *self)
1600 {
1601 return __bpf_fill_alu_reg_pairs(self, BPF_DIV, true);
1602 }
1603
1604 static int bpf_fill_alu32_mod_reg_pairs(struct bpf_test *self)
1605 {
1606 return __bpf_fill_alu_reg_pairs(self, BPF_MOD, true);
1607 }
1608
1609 /*
1610 * Exhaustive tests of atomic operations for all power-of-two operand
1611 * magnitudes, both for positive and negative values.
1612 */
1613
1614 static int __bpf_emit_atomic64(struct bpf_test *self, void *arg,
1615 struct bpf_insn *insns, s64 dst, s64 src)
1616 {
1617 int op = *(int *)arg;
1618 u64 keep, fetch, res;
1619 int i = 0;
1620
1621 if (!insns)
1622 return 21;
1623
1624 switch (op) {
1625 case BPF_XCHG:
1626 res = src;
1627 break;
1628 default:
1629 __bpf_alu_result(&res, dst, src, BPF_OP(op));
1630 }
1631
1632 keep = 0x0123456789abcdefULL;
1633 if (op & BPF_FETCH)
1634 fetch = dst;
1635 else
1636 fetch = src;
1637
1638 i += __bpf_ld_imm64(&insns[i], R0, keep);
1639 i += __bpf_ld_imm64(&insns[i], R1, dst);
1640 i += __bpf_ld_imm64(&insns[i], R2, src);
1641 i += __bpf_ld_imm64(&insns[i], R3, res);
1642 i += __bpf_ld_imm64(&insns[i], R4, fetch);
1643 i += __bpf_ld_imm64(&insns[i], R5, keep);
1644
1645 insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1646 insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8);
1647 insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8);
1648
1649 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1650 insns[i++] = BPF_EXIT_INSN();
1651
1652 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1653 insns[i++] = BPF_EXIT_INSN();
1654
1655 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1656 insns[i++] = BPF_EXIT_INSN();
1657
1658 return i;
1659 }
1660
1661 static int __bpf_emit_atomic32(struct bpf_test *self, void *arg,
1662 struct bpf_insn *insns, s64 dst, s64 src)
1663 {
1664 int op = *(int *)arg;
1665 u64 keep, fetch, res;
1666 int i = 0;
1667
1668 if (!insns)
1669 return 21;
1670
1671 switch (op) {
1672 case BPF_XCHG:
1673 res = src;
1674 break;
1675 default:
1676 __bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op));
1677 }
1678
1679 keep = 0x0123456789abcdefULL;
1680 if (op & BPF_FETCH)
1681 fetch = (u32)dst;
1682 else
1683 fetch = src;
1684
1685 i += __bpf_ld_imm64(&insns[i], R0, keep);
1686 i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1687 i += __bpf_ld_imm64(&insns[i], R2, src);
1688 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1689 i += __bpf_ld_imm64(&insns[i], R4, fetch);
1690 i += __bpf_ld_imm64(&insns[i], R5, keep);
1691
1692 insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1693 insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4);
1694 insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4);
1695
1696 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1697 insns[i++] = BPF_EXIT_INSN();
1698
1699 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1700 insns[i++] = BPF_EXIT_INSN();
1701
1702 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1703 insns[i++] = BPF_EXIT_INSN();
1704
1705 return i;
1706 }
1707
1708 static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg,
1709 struct bpf_insn *insns, s64 dst, s64 src)
1710 {
1711 int i = 0;
1712
1713 if (!insns)
1714 return 23;
1715
1716 i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1717 i += __bpf_ld_imm64(&insns[i], R1, dst);
1718 i += __bpf_ld_imm64(&insns[i], R2, src);
1719
1720 /* Result unsuccessful */
1721 insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1722 insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1723 insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1724
1725 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
1726 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1727 insns[i++] = BPF_EXIT_INSN();
1728
1729 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1730 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1731 insns[i++] = BPF_EXIT_INSN();
1732
1733 /* Result successful */
1734 insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1735 insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1736
1737 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
1738 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1739 insns[i++] = BPF_EXIT_INSN();
1740
1741 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1742 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1743 insns[i++] = BPF_EXIT_INSN();
1744
1745 return i;
1746 }
1747
1748 static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg,
1749 struct bpf_insn *insns, s64 dst, s64 src)
1750 {
1751 int i = 0;
1752
1753 if (!insns)
1754 return 27;
1755
1756 i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1757 i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1758 i += __bpf_ld_imm64(&insns[i], R2, src);
1759
1760 /* Result unsuccessful */
1761 insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1762 insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1763 insns[i++] = BPF_ZEXT_REG(R0); /* Zext always inserted by verifier */
1764 insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1765
1766 insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
1767 insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1768 insns[i++] = BPF_EXIT_INSN();
1769
1770 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1771 insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1772 insns[i++] = BPF_EXIT_INSN();
1773
1774 /* Result successful */
1775 i += __bpf_ld_imm64(&insns[i], R0, dst);
1776 insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1777 insns[i++] = BPF_ZEXT_REG(R0); /* Zext always inserted by verifier */
1778 insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1779
1780 insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
1781 insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1782 insns[i++] = BPF_EXIT_INSN();
1783
1784 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1785 insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1786 insns[i++] = BPF_EXIT_INSN();
1787
1788 return i;
1789 }
1790
1791 static int __bpf_fill_atomic64(struct bpf_test *self, int op)
1792 {
1793 return __bpf_fill_pattern(self, &op, 64, 64,
1794 0, PATTERN_BLOCK2,
1795 &__bpf_emit_atomic64);
1796 }
1797
1798 static int __bpf_fill_atomic32(struct bpf_test *self, int op)
1799 {
1800 return __bpf_fill_pattern(self, &op, 64, 64,
1801 0, PATTERN_BLOCK2,
1802 &__bpf_emit_atomic32);
1803 }
1804
1805 /* 64-bit atomic operations */
1806 static int bpf_fill_atomic64_add(struct bpf_test *self)
1807 {
1808 return __bpf_fill_atomic64(self, BPF_ADD);
1809 }
1810
1811 static int bpf_fill_atomic64_and(struct bpf_test *self)
1812 {
1813 return __bpf_fill_atomic64(self, BPF_AND);
1814 }
1815
1816 static int bpf_fill_atomic64_or(struct bpf_test *self)
1817 {
1818 return __bpf_fill_atomic64(self, BPF_OR);
1819 }
1820
1821 static int bpf_fill_atomic64_xor(struct bpf_test *self)
1822 {
1823 return __bpf_fill_atomic64(self, BPF_XOR);
1824 }
1825
1826 static int bpf_fill_atomic64_add_fetch(struct bpf_test *self)
1827 {
1828 return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH);
1829 }
1830
1831 static int bpf_fill_atomic64_and_fetch(struct bpf_test *self)
1832 {
1833 return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH);
1834 }
1835
1836 static int bpf_fill_atomic64_or_fetch(struct bpf_test *self)
1837 {
1838 return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH);
1839 }
1840
1841 static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self)
1842 {
1843 return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH);
1844 }
1845
1846 static int bpf_fill_atomic64_xchg(struct bpf_test *self)
1847 {
1848 return __bpf_fill_atomic64(self, BPF_XCHG);
1849 }
1850
1851 static int bpf_fill_cmpxchg64(struct bpf_test *self)
1852 {
1853 return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1854 &__bpf_emit_cmpxchg64);
1855 }
1856
1857 /* 32-bit atomic operations */
1858 static int bpf_fill_atomic32_add(struct bpf_test *self)
1859 {
1860 return __bpf_fill_atomic32(self, BPF_ADD);
1861 }
1862
1863 static int bpf_fill_atomic32_and(struct bpf_test *self)
1864 {
1865 return __bpf_fill_atomic32(self, BPF_AND);
1866 }
1867
1868 static int bpf_fill_atomic32_or(struct bpf_test *self)
1869 {
1870 return __bpf_fill_atomic32(self, BPF_OR);
1871 }
1872
1873 static int bpf_fill_atomic32_xor(struct bpf_test *self)
1874 {
1875 return __bpf_fill_atomic32(self, BPF_XOR);
1876 }
1877
1878 static int bpf_fill_atomic32_add_fetch(struct bpf_test *self)
1879 {
1880 return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH);
1881 }
1882
1883 static int bpf_fill_atomic32_and_fetch(struct bpf_test *self)
1884 {
1885 return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH);
1886 }
1887
1888 static int bpf_fill_atomic32_or_fetch(struct bpf_test *self)
1889 {
1890 return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH);
1891 }
1892
1893 static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self)
1894 {
1895 return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH);
1896 }
1897
1898 static int bpf_fill_atomic32_xchg(struct bpf_test *self)
1899 {
1900 return __bpf_fill_atomic32(self, BPF_XCHG);
1901 }
1902
1903 static int bpf_fill_cmpxchg32(struct bpf_test *self)
1904 {
1905 return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1906 &__bpf_emit_cmpxchg32);
1907 }
1908
1909 /*
1910 * Test JITs that implement ATOMIC operations as function calls or
1911 * other primitives, and must re-arrange operands for argument passing.
1912 */
1913 static int __bpf_fill_atomic_reg_pairs(struct bpf_test *self, u8 width, u8 op)
1914 {
1915 struct bpf_insn *insn;
1916 int len = 2 + 34 * 10 * 10;
1917 u64 mem, upd, res;
1918 int rd, rs, i = 0;
1919
1920 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
1921 if (!insn)
1922 return -ENOMEM;
1923
1924 /* Operand and memory values */
1925 if (width == BPF_DW) {
1926 mem = 0x0123456789abcdefULL;
1927 upd = 0xfedcba9876543210ULL;
1928 } else { /* BPF_W */
1929 mem = 0x01234567U;
1930 upd = 0x76543210U;
1931 }
1932
1933 /* Memory updated according to operation */
1934 switch (op) {
1935 case BPF_XCHG:
1936 res = upd;
1937 break;
1938 case BPF_CMPXCHG:
1939 res = mem;
1940 break;
1941 default:
1942 __bpf_alu_result(&res, mem, upd, BPF_OP(op));
1943 }
1944
1945 /* Test all operand registers */
1946 for (rd = R0; rd <= R9; rd++) {
1947 for (rs = R0; rs <= R9; rs++) {
1948 u64 cmp, src;
1949
1950 /* Initialize value in memory */
1951 i += __bpf_ld_imm64(&insn[i], R0, mem);
1952 insn[i++] = BPF_STX_MEM(width, R10, R0, -8);
1953
1954 /* Initialize registers in order */
1955 i += __bpf_ld_imm64(&insn[i], R0, ~mem);
1956 i += __bpf_ld_imm64(&insn[i], rs, upd);
1957 insn[i++] = BPF_MOV64_REG(rd, R10);
1958
1959 /* Perform atomic operation */
1960 insn[i++] = BPF_ATOMIC_OP(width, op, rd, rs, -8);
1961 if (op == BPF_CMPXCHG && width == BPF_W)
1962 insn[i++] = BPF_ZEXT_REG(R0);
1963
1964 /* Check R0 register value */
1965 if (op == BPF_CMPXCHG)
1966 cmp = mem; /* Expect value from memory */
1967 else if (R0 == rd || R0 == rs)
1968 cmp = 0; /* Aliased, checked below */
1969 else
1970 cmp = ~mem; /* Expect value to be preserved */
1971 if (cmp) {
1972 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1973 (u32)cmp, 2);
1974 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1975 insn[i++] = BPF_EXIT_INSN();
1976 insn[i++] = BPF_ALU64_IMM(BPF_RSH, R0, 32);
1977 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0,
1978 cmp >> 32, 2);
1979 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1980 insn[i++] = BPF_EXIT_INSN();
1981 }
1982
1983 /* Check source register value */
1984 if (rs == R0 && op == BPF_CMPXCHG)
1985 src = 0; /* Aliased with R0, checked above */
1986 else if (rs == rd && (op == BPF_CMPXCHG ||
1987 !(op & BPF_FETCH)))
1988 src = 0; /* Aliased with rd, checked below */
1989 else if (op == BPF_CMPXCHG)
1990 src = upd; /* Expect value to be preserved */
1991 else if (op & BPF_FETCH)
1992 src = mem; /* Expect fetched value from mem */
1993 else /* no fetch */
1994 src = upd; /* Expect value to be preserved */
1995 if (src) {
1996 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
1997 (u32)src, 2);
1998 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
1999 insn[i++] = BPF_EXIT_INSN();
2000 insn[i++] = BPF_ALU64_IMM(BPF_RSH, rs, 32);
2001 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs,
2002 src >> 32, 2);
2003 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2004 insn[i++] = BPF_EXIT_INSN();
2005 }
2006
2007 /* Check destination register value */
2008 if (!(rd == R0 && op == BPF_CMPXCHG) &&
2009 !(rd == rs && (op & BPF_FETCH))) {
2010 insn[i++] = BPF_JMP_REG(BPF_JEQ, rd, R10, 2);
2011 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2012 insn[i++] = BPF_EXIT_INSN();
2013 }
2014
2015 /* Check value in memory */
2016 if (rs != rd) { /* No aliasing */
2017 i += __bpf_ld_imm64(&insn[i], R1, res);
2018 } else if (op == BPF_XCHG) { /* Aliased, XCHG */
2019 insn[i++] = BPF_MOV64_REG(R1, R10);
2020 } else if (op == BPF_CMPXCHG) { /* Aliased, CMPXCHG */
2021 i += __bpf_ld_imm64(&insn[i], R1, mem);
2022 } else { /* Aliased, ALU oper */
2023 i += __bpf_ld_imm64(&insn[i], R1, mem);
2024 insn[i++] = BPF_ALU64_REG(BPF_OP(op), R1, R10);
2025 }
2026
2027 insn[i++] = BPF_LDX_MEM(width, R0, R10, -8);
2028 if (width == BPF_DW)
2029 insn[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
2030 else /* width == BPF_W */
2031 insn[i++] = BPF_JMP32_REG(BPF_JEQ, R0, R1, 2);
2032 insn[i++] = BPF_MOV32_IMM(R0, __LINE__);
2033 insn[i++] = BPF_EXIT_INSN();
2034 }
2035 }
2036
2037 insn[i++] = BPF_MOV64_IMM(R0, 1);
2038 insn[i++] = BPF_EXIT_INSN();
2039
2040 self->u.ptr.insns = insn;
2041 self->u.ptr.len = i;
2042 BUG_ON(i > len);
2043
2044 return 0;
2045 }
2046
2047 /* 64-bit atomic register tests */
2048 static int bpf_fill_atomic64_add_reg_pairs(struct bpf_test *self)
2049 {
2050 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD);
2051 }
2052
2053 static int bpf_fill_atomic64_and_reg_pairs(struct bpf_test *self)
2054 {
2055 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND);
2056 }
2057
2058 static int bpf_fill_atomic64_or_reg_pairs(struct bpf_test *self)
2059 {
2060 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR);
2061 }
2062
2063 static int bpf_fill_atomic64_xor_reg_pairs(struct bpf_test *self)
2064 {
2065 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR);
2066 }
2067
2068 static int bpf_fill_atomic64_add_fetch_reg_pairs(struct bpf_test *self)
2069 {
2070 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD | BPF_FETCH);
2071 }
2072
2073 static int bpf_fill_atomic64_and_fetch_reg_pairs(struct bpf_test *self)
2074 {
2075 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND | BPF_FETCH);
2076 }
2077
2078 static int bpf_fill_atomic64_or_fetch_reg_pairs(struct bpf_test *self)
2079 {
2080 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR | BPF_FETCH);
2081 }
2082
2083 static int bpf_fill_atomic64_xor_fetch_reg_pairs(struct bpf_test *self)
2084 {
2085 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR | BPF_FETCH);
2086 }
2087
2088 static int bpf_fill_atomic64_xchg_reg_pairs(struct bpf_test *self)
2089 {
2090 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XCHG);
2091 }
2092
2093 static int bpf_fill_atomic64_cmpxchg_reg_pairs(struct bpf_test *self)
2094 {
2095 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_CMPXCHG);
2096 }
2097
2098 /* 32-bit atomic register tests */
2099 static int bpf_fill_atomic32_add_reg_pairs(struct bpf_test *self)
2100 {
2101 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD);
2102 }
2103
2104 static int bpf_fill_atomic32_and_reg_pairs(struct bpf_test *self)
2105 {
2106 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND);
2107 }
2108
2109 static int bpf_fill_atomic32_or_reg_pairs(struct bpf_test *self)
2110 {
2111 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR);
2112 }
2113
2114 static int bpf_fill_atomic32_xor_reg_pairs(struct bpf_test *self)
2115 {
2116 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR);
2117 }
2118
2119 static int bpf_fill_atomic32_add_fetch_reg_pairs(struct bpf_test *self)
2120 {
2121 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD | BPF_FETCH);
2122 }
2123
2124 static int bpf_fill_atomic32_and_fetch_reg_pairs(struct bpf_test *self)
2125 {
2126 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND | BPF_FETCH);
2127 }
2128
2129 static int bpf_fill_atomic32_or_fetch_reg_pairs(struct bpf_test *self)
2130 {
2131 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR | BPF_FETCH);
2132 }
2133
2134 static int bpf_fill_atomic32_xor_fetch_reg_pairs(struct bpf_test *self)
2135 {
2136 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR | BPF_FETCH);
2137 }
2138
2139 static int bpf_fill_atomic32_xchg_reg_pairs(struct bpf_test *self)
2140 {
2141 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XCHG);
2142 }
2143
2144 static int bpf_fill_atomic32_cmpxchg_reg_pairs(struct bpf_test *self)
2145 {
2146 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_CMPXCHG);
2147 }
2148
2149 /*
2150 * Test the two-instruction 64-bit immediate load operation for all
2151 * power-of-two magnitudes of the immediate operand. For each MSB, a block
2152 * of immediate values centered around the power-of-two MSB are tested,
2153 * both for positive and negative values. The test is designed to verify
2154 * the operation for JITs that emit different code depending on the magnitude
2155 * of the immediate value. This is often the case if the native instruction
2156 * immediate field width is narrower than 32 bits.
2157 */
2158 static int bpf_fill_ld_imm64_magn(struct bpf_test *self)
2159 {
2160 int block = 64; /* Increase for more tests per MSB position */
2161 int len = 3 + 8 * 63 * block * 2;
2162 struct bpf_insn *insn;
2163 int bit, adj, sign;
2164 int i = 0;
2165
2166 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2167 if (!insn)
2168 return -ENOMEM;
2169
2170 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2171
2172 for (bit = 0; bit <= 62; bit++) {
2173 for (adj = -block / 2; adj < block / 2; adj++) {
2174 for (sign = -1; sign <= 1; sign += 2) {
2175 s64 imm = sign * ((1LL << bit) + adj);
2176
2177 /* Perform operation */
2178 i += __bpf_ld_imm64(&insn[i], R1, imm);
2179
2180 /* Load reference */
2181 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2182 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
2183 (u32)(imm >> 32));
2184 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2185 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2186
2187 /* Check result */
2188 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2189 insn[i++] = BPF_EXIT_INSN();
2190 }
2191 }
2192 }
2193
2194 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2195 insn[i++] = BPF_EXIT_INSN();
2196
2197 self->u.ptr.insns = insn;
2198 self->u.ptr.len = len;
2199 BUG_ON(i != len);
2200
2201 return 0;
2202 }
2203
2204 /*
2205 * Test the two-instruction 64-bit immediate load operation for different
2206 * combinations of bytes. Each byte in the 64-bit word is constructed as
2207 * (base & mask) | (rand() & ~mask), where rand() is a deterministic LCG.
2208 * All patterns (base1, mask1) and (base2, mask2) bytes are tested.
2209 */
2210 static int __bpf_fill_ld_imm64_bytes(struct bpf_test *self,
2211 u8 base1, u8 mask1,
2212 u8 base2, u8 mask2)
2213 {
2214 struct bpf_insn *insn;
2215 int len = 3 + 8 * BIT(8);
2216 int pattern, index;
2217 u32 rand = 1;
2218 int i = 0;
2219
2220 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
2221 if (!insn)
2222 return -ENOMEM;
2223
2224 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2225
2226 for (pattern = 0; pattern < BIT(8); pattern++) {
2227 u64 imm = 0;
2228
2229 for (index = 0; index < 8; index++) {
2230 int byte;
2231
2232 if (pattern & BIT(index))
2233 byte = (base1 & mask1) | (rand & ~mask1);
2234 else
2235 byte = (base2 & mask2) | (rand & ~mask2);
2236 imm = (imm << 8) | byte;
2237 }
2238
2239 /* Update our LCG */
2240 rand = rand * 1664525 + 1013904223;
2241
2242 /* Perform operation */
2243 i += __bpf_ld_imm64(&insn[i], R1, imm);
2244
2245 /* Load reference */
2246 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
2247 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, (u32)(imm >> 32));
2248 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
2249 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
2250
2251 /* Check result */
2252 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
2253 insn[i++] = BPF_EXIT_INSN();
2254 }
2255
2256 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
2257 insn[i++] = BPF_EXIT_INSN();
2258
2259 self->u.ptr.insns = insn;
2260 self->u.ptr.len = len;
2261 BUG_ON(i != len);
2262
2263 return 0;
2264 }
2265
2266 static int bpf_fill_ld_imm64_checker(struct bpf_test *self)
2267 {
2268 return __bpf_fill_ld_imm64_bytes(self, 0, 0xff, 0xff, 0xff);
2269 }
2270
2271 static int bpf_fill_ld_imm64_pos_neg(struct bpf_test *self)
2272 {
2273 return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0x80, 0x80);
2274 }
2275
2276 static int bpf_fill_ld_imm64_pos_zero(struct bpf_test *self)
2277 {
2278 return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0, 0xff);
2279 }
2280
2281 static int bpf_fill_ld_imm64_neg_zero(struct bpf_test *self)
2282 {
2283 return __bpf_fill_ld_imm64_bytes(self, 0x80, 0x80, 0, 0xff);
2284 }
2285
2286 /*
2287 * Exhaustive tests of JMP operations for all combinations of power-of-two
2288 * magnitudes of the operands, both for positive and negative values. The
2289 * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
2290 * emit different code depending on the magnitude of the immediate value.
2291 */
2292
2293 static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
2294 {
2295 switch (op) {
2296 case BPF_JSET:
2297 return !!(v1 & v2);
2298 case BPF_JEQ:
2299 return v1 == v2;
2300 case BPF_JNE:
2301 return v1 != v2;
2302 case BPF_JGT:
2303 return (u64)v1 > (u64)v2;
2304 case BPF_JGE:
2305 return (u64)v1 >= (u64)v2;
2306 case BPF_JLT:
2307 return (u64)v1 < (u64)v2;
2308 case BPF_JLE:
2309 return (u64)v1 <= (u64)v2;
2310 case BPF_JSGT:
2311 return v1 > v2;
2312 case BPF_JSGE:
2313 return v1 >= v2;
2314 case BPF_JSLT:
2315 return v1 < v2;
2316 case BPF_JSLE:
2317 return v1 <= v2;
2318 }
2319 return false;
2320 }
2321
2322 static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
2323 struct bpf_insn *insns, s64 dst, s64 imm)
2324 {
2325 int op = *(int *)arg;
2326
2327 if (insns) {
2328 bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
2329 int i = 0;
2330
2331 insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
2332
2333 i += __bpf_ld_imm64(&insns[i], R1, dst);
2334 insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
2335 if (!match)
2336 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2337 insns[i++] = BPF_EXIT_INSN();
2338
2339 return i;
2340 }
2341
2342 return 5 + 1;
2343 }
2344
2345 static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
2346 struct bpf_insn *insns, s64 dst, s64 imm)
2347 {
2348 int op = *(int *)arg;
2349
2350 if (insns) {
2351 bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
2352 int i = 0;
2353
2354 i += __bpf_ld_imm64(&insns[i], R1, dst);
2355 insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
2356 if (!match)
2357 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2358 insns[i++] = BPF_EXIT_INSN();
2359
2360 return i;
2361 }
2362
2363 return 5;
2364 }
2365
2366 static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
2367 struct bpf_insn *insns, s64 dst, s64 src)
2368 {
2369 int op = *(int *)arg;
2370
2371 if (insns) {
2372 bool match = __bpf_match_jmp_cond(dst, src, op);
2373 int i = 0;
2374
2375 i += __bpf_ld_imm64(&insns[i], R1, dst);
2376 i += __bpf_ld_imm64(&insns[i], R2, src);
2377 insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
2378 if (!match)
2379 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2380 insns[i++] = BPF_EXIT_INSN();
2381
2382 return i;
2383 }
2384
2385 return 7;
2386 }
2387
2388 static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
2389 struct bpf_insn *insns, s64 dst, s64 src)
2390 {
2391 int op = *(int *)arg;
2392
2393 if (insns) {
2394 bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
2395 int i = 0;
2396
2397 i += __bpf_ld_imm64(&insns[i], R1, dst);
2398 i += __bpf_ld_imm64(&insns[i], R2, src);
2399 insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
2400 if (!match)
2401 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
2402 insns[i++] = BPF_EXIT_INSN();
2403
2404 return i;
2405 }
2406
2407 return 7;
2408 }
2409
2410 static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
2411 {
2412 return __bpf_fill_pattern(self, &op, 64, 32,
2413 PATTERN_BLOCK1, PATTERN_BLOCK2,
2414 &__bpf_emit_jmp_imm);
2415 }
2416
2417 static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
2418 {
2419 return __bpf_fill_pattern(self, &op, 64, 32,
2420 PATTERN_BLOCK1, PATTERN_BLOCK2,
2421 &__bpf_emit_jmp32_imm);
2422 }
2423
2424 static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
2425 {
2426 return __bpf_fill_pattern(self, &op, 64, 64,
2427 PATTERN_BLOCK1, PATTERN_BLOCK2,
2428 &__bpf_emit_jmp_reg);
2429 }
2430
2431 static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
2432 {
2433 return __bpf_fill_pattern(self, &op, 64, 64,
2434 PATTERN_BLOCK1, PATTERN_BLOCK2,
2435 &__bpf_emit_jmp32_reg);
2436 }
2437
2438 /* JMP immediate tests */
2439 static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
2440 {
2441 return __bpf_fill_jmp_imm(self, BPF_JSET);
2442 }
2443
2444 static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
2445 {
2446 return __bpf_fill_jmp_imm(self, BPF_JEQ);
2447 }
2448
2449 static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
2450 {
2451 return __bpf_fill_jmp_imm(self, BPF_JNE);
2452 }
2453
2454 static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
2455 {
2456 return __bpf_fill_jmp_imm(self, BPF_JGT);
2457 }
2458
2459 static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
2460 {
2461 return __bpf_fill_jmp_imm(self, BPF_JGE);
2462 }
2463
2464 static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
2465 {
2466 return __bpf_fill_jmp_imm(self, BPF_JLT);
2467 }
2468
2469 static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
2470 {
2471 return __bpf_fill_jmp_imm(self, BPF_JLE);
2472 }
2473
2474 static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
2475 {
2476 return __bpf_fill_jmp_imm(self, BPF_JSGT);
2477 }
2478
2479 static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
2480 {
2481 return __bpf_fill_jmp_imm(self, BPF_JSGE);
2482 }
2483
2484 static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
2485 {
2486 return __bpf_fill_jmp_imm(self, BPF_JSLT);
2487 }
2488
2489 static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
2490 {
2491 return __bpf_fill_jmp_imm(self, BPF_JSLE);
2492 }
2493
2494 /* JMP32 immediate tests */
2495 static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
2496 {
2497 return __bpf_fill_jmp32_imm(self, BPF_JSET);
2498 }
2499
2500 static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
2501 {
2502 return __bpf_fill_jmp32_imm(self, BPF_JEQ);
2503 }
2504
2505 static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
2506 {
2507 return __bpf_fill_jmp32_imm(self, BPF_JNE);
2508 }
2509
2510 static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
2511 {
2512 return __bpf_fill_jmp32_imm(self, BPF_JGT);
2513 }
2514
2515 static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
2516 {
2517 return __bpf_fill_jmp32_imm(self, BPF_JGE);
2518 }
2519
2520 static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
2521 {
2522 return __bpf_fill_jmp32_imm(self, BPF_JLT);
2523 }
2524
2525 static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
2526 {
2527 return __bpf_fill_jmp32_imm(self, BPF_JLE);
2528 }
2529
2530 static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
2531 {
2532 return __bpf_fill_jmp32_imm(self, BPF_JSGT);
2533 }
2534
2535 static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
2536 {
2537 return __bpf_fill_jmp32_imm(self, BPF_JSGE);
2538 }
2539
2540 static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
2541 {
2542 return __bpf_fill_jmp32_imm(self, BPF_JSLT);
2543 }
2544
2545 static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
2546 {
2547 return __bpf_fill_jmp32_imm(self, BPF_JSLE);
2548 }
2549
2550 /* JMP register tests */
2551 static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
2552 {
2553 return __bpf_fill_jmp_reg(self, BPF_JSET);
2554 }
2555
2556 static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
2557 {
2558 return __bpf_fill_jmp_reg(self, BPF_JEQ);
2559 }
2560
2561 static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
2562 {
2563 return __bpf_fill_jmp_reg(self, BPF_JNE);
2564 }
2565
2566 static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
2567 {
2568 return __bpf_fill_jmp_reg(self, BPF_JGT);
2569 }
2570
2571 static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
2572 {
2573 return __bpf_fill_jmp_reg(self, BPF_JGE);
2574 }
2575
2576 static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
2577 {
2578 return __bpf_fill_jmp_reg(self, BPF_JLT);
2579 }
2580
2581 static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
2582 {
2583 return __bpf_fill_jmp_reg(self, BPF_JLE);
2584 }
2585
2586 static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
2587 {
2588 return __bpf_fill_jmp_reg(self, BPF_JSGT);
2589 }
2590
2591 static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
2592 {
2593 return __bpf_fill_jmp_reg(self, BPF_JSGE);
2594 }
2595
2596 static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
2597 {
2598 return __bpf_fill_jmp_reg(self, BPF_JSLT);
2599 }
2600
2601 static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
2602 {
2603 return __bpf_fill_jmp_reg(self, BPF_JSLE);
2604 }
2605
2606 /* JMP32 register tests */
2607 static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
2608 {
2609 return __bpf_fill_jmp32_reg(self, BPF_JSET);
2610 }
2611
2612 static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
2613 {
2614 return __bpf_fill_jmp32_reg(self, BPF_JEQ);
2615 }
2616
2617 static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
2618 {
2619 return __bpf_fill_jmp32_reg(self, BPF_JNE);
2620 }
2621
2622 static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
2623 {
2624 return __bpf_fill_jmp32_reg(self, BPF_JGT);
2625 }
2626
2627 static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
2628 {
2629 return __bpf_fill_jmp32_reg(self, BPF_JGE);
2630 }
2631
2632 static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
2633 {
2634 return __bpf_fill_jmp32_reg(self, BPF_JLT);
2635 }
2636
2637 static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
2638 {
2639 return __bpf_fill_jmp32_reg(self, BPF_JLE);
2640 }
2641
2642 static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
2643 {
2644 return __bpf_fill_jmp32_reg(self, BPF_JSGT);
2645 }
2646
2647 static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
2648 {
2649 return __bpf_fill_jmp32_reg(self, BPF_JSGE);
2650 }
2651
2652 static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
2653 {
2654 return __bpf_fill_jmp32_reg(self, BPF_JSLT);
2655 }
2656
2657 static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
2658 {
2659 return __bpf_fill_jmp32_reg(self, BPF_JSLE);
2660 }
2661
2662 /*
2663 * Set up a sequence of staggered jumps, forwards and backwards with
2664 * increasing offset. This tests the conversion of relative jumps to
2665 * JITed native jumps. On some architectures, for example MIPS, a large
2666 * PC-relative jump offset may overflow the immediate field of the native
2667 * conditional branch instruction, triggering a conversion to use an
2668 * absolute jump instead. Since this changes the jump offsets, another
2669 * offset computation pass is necessary, and that may in turn trigger
2670 * another branch conversion. This jump sequence is particularly nasty
2671 * in that regard.
2672 *
2673 * The sequence generation is parameterized by size and jump type.
2674 * The size must be even, and the expected result is always size + 1.
2675 * Below is an example with size=8 and result=9.
2676 *
2677 * ________________________Start
2678 * R0 = 0
2679 * R1 = r1
2680 * R2 = r2
2681 * ,------- JMP +4 * 3______________Preamble: 4 insns
2682 * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
2683 * | | R0 = 8 |
2684 * | | JMP +7 * 3 ------------------------.
2685 * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------. | |
2686 * | | | R0 = 6 | | |
2687 * | | | JMP +5 * 3 ------------------. | |
2688 * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------. | | | |
2689 * | | | | R0 = 4 | | | | |
2690 * | | | | JMP +3 * 3 ------------. | | | |
2691 * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--. | | | | | |
2692 * | | | | | R0 = 2 | | | | | | |
2693 * | | | | | JMP +1 * 3 ------. | | | | | |
2694 * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1 1 2 3 4 5 6 7 8 loc
2695 * | | | | | R0 = 1 -1 +2 -3 +4 -5 +6 -7 +8 off
2696 * | | | | | JMP -2 * 3 ---' | | | | | | |
2697 * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----' | | | | | |
2698 * | | | | | | R0 = 3 | | | | | |
2699 * | | | | | | JMP -4 * 3 ---------' | | | | |
2700 * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------' | | | |
2701 * | | | | | | | R0 = 5 | | | |
2702 * | | | | | | | JMP -6 * 3 ---------------' | | |
2703 * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------' | |
2704 * | | | | | | | | R0 = 7 | |
2705 * | | Error | | | JMP -8 * 3 ---------------------' |
2706 * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
2707 * | | | | | | | | | R0 = 9__________________Sequence: 3 * size - 1 insns
2708 * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
2709 *
2710 */
2711
2712 /* The maximum size parameter */
2713 #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
2714
2715 /* We use a reduced number of iterations to get a reasonable execution time */
2716 #define NR_STAGGERED_JMP_RUNS 10
2717
2718 static int __bpf_fill_staggered_jumps(struct bpf_test *self,
2719 const struct bpf_insn *jmp,
2720 u64 r1, u64 r2)
2721 {
2722 int size = self->test[0].result - 1;
2723 int len = 4 + 3 * (size + 1);
2724 struct bpf_insn *insns;
2725 int off, ind;
2726
2727 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
2728 if (!insns)
2729 return -ENOMEM;
2730
2731 /* Preamble */
2732 insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
2733 insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
2734 insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
2735 insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
2736
2737 /* Sequence */
2738 for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
2739 struct bpf_insn *ins = &insns[4 + 3 * ind];
2740 int loc;
2741
2742 if (off == 0)
2743 off--;
2744
2745 loc = abs(off);
2746 ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
2747 3 * (size - ind) + 1);
2748 ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
2749 ins[2] = *jmp;
2750 ins[2].off = 3 * (off - 1);
2751 }
2752
2753 /* Return */
2754 insns[len - 1] = BPF_EXIT_INSN();
2755
2756 self->u.ptr.insns = insns;
2757 self->u.ptr.len = len;
2758
2759 return 0;
2760 }
2761
2762 /* 64-bit unconditional jump */
2763 static int bpf_fill_staggered_ja(struct bpf_test *self)
2764 {
2765 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
2766
2767 return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
2768 }
2769
2770 /* 64-bit immediate jumps */
2771 static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
2772 {
2773 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
2774
2775 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2776 }
2777
2778 static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
2779 {
2780 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
2781
2782 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2783 }
2784
2785 static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
2786 {
2787 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
2788
2789 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2790 }
2791
2792 static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
2793 {
2794 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
2795
2796 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2797 }
2798
2799 static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
2800 {
2801 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
2802
2803 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2804 }
2805
2806 static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
2807 {
2808 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
2809
2810 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2811 }
2812
2813 static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
2814 {
2815 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
2816
2817 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2818 }
2819
2820 static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
2821 {
2822 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
2823
2824 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2825 }
2826
2827 static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
2828 {
2829 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
2830
2831 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2832 }
2833
2834 static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
2835 {
2836 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
2837
2838 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2839 }
2840
2841 static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
2842 {
2843 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
2844
2845 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2846 }
2847
2848 /* 64-bit register jumps */
2849 static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
2850 {
2851 struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
2852
2853 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2854 }
2855
2856 static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
2857 {
2858 struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
2859
2860 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2861 }
2862
2863 static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
2864 {
2865 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
2866
2867 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2868 }
2869
2870 static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
2871 {
2872 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
2873
2874 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2875 }
2876
2877 static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
2878 {
2879 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
2880
2881 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2882 }
2883
2884 static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
2885 {
2886 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
2887
2888 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2889 }
2890
2891 static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
2892 {
2893 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
2894
2895 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2896 }
2897
2898 static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
2899 {
2900 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
2901
2902 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2903 }
2904
2905 static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
2906 {
2907 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
2908
2909 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2910 }
2911
2912 static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
2913 {
2914 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
2915
2916 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2917 }
2918
2919 static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
2920 {
2921 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
2922
2923 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2924 }
2925
2926 /* 32-bit immediate jumps */
2927 static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
2928 {
2929 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
2930
2931 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2932 }
2933
2934 static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
2935 {
2936 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
2937
2938 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2939 }
2940
2941 static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
2942 {
2943 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
2944
2945 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2946 }
2947
2948 static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
2949 {
2950 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
2951
2952 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2953 }
2954
2955 static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
2956 {
2957 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
2958
2959 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2960 }
2961
2962 static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
2963 {
2964 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
2965
2966 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2967 }
2968
2969 static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
2970 {
2971 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
2972
2973 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2974 }
2975
2976 static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
2977 {
2978 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
2979
2980 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2981 }
2982
2983 static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
2984 {
2985 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
2986
2987 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2988 }
2989
2990 static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
2991 {
2992 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
2993
2994 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2995 }
2996
2997 static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
2998 {
2999 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
3000
3001 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
3002 }
3003
3004 /* 32-bit register jumps */
3005 static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
3006 {
3007 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
3008
3009 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3010 }
3011
3012 static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
3013 {
3014 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
3015
3016 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
3017 }
3018
3019 static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
3020 {
3021 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
3022
3023 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
3024 }
3025
3026 static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
3027 {
3028 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
3029
3030 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
3031 }
3032
3033 static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
3034 {
3035 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
3036
3037 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3038 }
3039
3040 static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
3041 {
3042 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
3043
3044 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
3045 }
3046
3047 static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
3048 {
3049 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
3050
3051 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
3052 }
3053
3054 static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
3055 {
3056 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
3057
3058 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
3059 }
3060
3061 static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
3062 {
3063 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
3064
3065 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
3066 }
3067
3068 static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
3069 {
3070 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
3071
3072 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
3073 }
3074
3075 static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
3076 {
3077 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
3078
3079 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
3080 }
3081
3082
3083 static struct bpf_test tests[] = {
3084 {
3085 "TAX",
3086 .u.insns = {
3087 BPF_STMT(BPF_LD | BPF_IMM, 1),
3088 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3089 BPF_STMT(BPF_LD | BPF_IMM, 2),
3090 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3091 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
3092 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3093 BPF_STMT(BPF_LD | BPF_LEN, 0),
3094 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3095 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
3096 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
3097 BPF_STMT(BPF_RET | BPF_A, 0)
3098 },
3099 CLASSIC,
3100 { 10, 20, 30, 40, 50 },
3101 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
3102 },
3103 {
3104 "TXA",
3105 .u.insns = {
3106 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3107 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3108 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3109 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
3110 },
3111 CLASSIC,
3112 { 10, 20, 30, 40, 50 },
3113 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
3114 },
3115 {
3116 "ADD_SUB_MUL_K",
3117 .u.insns = {
3118 BPF_STMT(BPF_LD | BPF_IMM, 1),
3119 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
3120 BPF_STMT(BPF_LDX | BPF_IMM, 3),
3121 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3122 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
3123 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
3124 BPF_STMT(BPF_RET | BPF_A, 0)
3125 },
3126 CLASSIC | FLAG_NO_DATA,
3127 { },
3128 { { 0, 0xfffffffd } }
3129 },
3130 {
3131 "DIV_MOD_KX",
3132 .u.insns = {
3133 BPF_STMT(BPF_LD | BPF_IMM, 8),
3134 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
3135 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3136 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3137 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
3138 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3139 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3140 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
3141 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3142 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3143 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
3144 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3145 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
3146 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
3147 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3148 BPF_STMT(BPF_RET | BPF_A, 0)
3149 },
3150 CLASSIC | FLAG_NO_DATA,
3151 { },
3152 { { 0, 0x20000000 } }
3153 },
3154 {
3155 "AND_OR_LSH_K",
3156 .u.insns = {
3157 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
3158 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3159 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
3160 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3161 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
3162 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
3163 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3164 BPF_STMT(BPF_RET | BPF_A, 0)
3165 },
3166 CLASSIC | FLAG_NO_DATA,
3167 { },
3168 { { 0, 0x800000ff }, { 1, 0x800000ff } },
3169 },
3170 {
3171 "LD_IMM_0",
3172 .u.insns = {
3173 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
3174 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
3175 BPF_STMT(BPF_RET | BPF_K, 0),
3176 BPF_STMT(BPF_RET | BPF_K, 1),
3177 },
3178 CLASSIC,
3179 { },
3180 { { 1, 1 } },
3181 },
3182 {
3183 "LD_IND",
3184 .u.insns = {
3185 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3186 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
3187 BPF_STMT(BPF_RET | BPF_K, 1)
3188 },
3189 CLASSIC,
3190 { },
3191 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
3192 },
3193 {
3194 "LD_ABS",
3195 .u.insns = {
3196 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
3197 BPF_STMT(BPF_RET | BPF_K, 1)
3198 },
3199 CLASSIC,
3200 { },
3201 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
3202 },
3203 {
3204 "LD_ABS_LL",
3205 .u.insns = {
3206 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
3207 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3208 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
3209 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3210 BPF_STMT(BPF_RET | BPF_A, 0)
3211 },
3212 CLASSIC,
3213 { 1, 2, 3 },
3214 { { 1, 0 }, { 2, 3 } },
3215 },
3216 {
3217 "LD_IND_LL",
3218 .u.insns = {
3219 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
3220 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3221 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3222 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3223 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3224 BPF_STMT(BPF_RET | BPF_A, 0)
3225 },
3226 CLASSIC,
3227 { 1, 2, 3, 0xff },
3228 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
3229 },
3230 {
3231 "LD_ABS_NET",
3232 .u.insns = {
3233 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
3234 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3235 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
3236 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3237 BPF_STMT(BPF_RET | BPF_A, 0)
3238 },
3239 CLASSIC,
3240 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3241 { { 15, 0 }, { 16, 3 } },
3242 },
3243 {
3244 "LD_IND_NET",
3245 .u.insns = {
3246 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
3247 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3248 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3249 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3250 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
3251 BPF_STMT(BPF_RET | BPF_A, 0)
3252 },
3253 CLASSIC,
3254 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
3255 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
3256 },
3257 {
3258 "LD_PKTTYPE",
3259 .u.insns = {
3260 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3261 SKF_AD_OFF + SKF_AD_PKTTYPE),
3262 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3263 BPF_STMT(BPF_RET | BPF_K, 1),
3264 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3265 SKF_AD_OFF + SKF_AD_PKTTYPE),
3266 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3267 BPF_STMT(BPF_RET | BPF_K, 1),
3268 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3269 SKF_AD_OFF + SKF_AD_PKTTYPE),
3270 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
3271 BPF_STMT(BPF_RET | BPF_K, 1),
3272 BPF_STMT(BPF_RET | BPF_A, 0)
3273 },
3274 CLASSIC,
3275 { },
3276 { { 1, 3 }, { 10, 3 } },
3277 },
3278 {
3279 "LD_MARK",
3280 .u.insns = {
3281 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3282 SKF_AD_OFF + SKF_AD_MARK),
3283 BPF_STMT(BPF_RET | BPF_A, 0)
3284 },
3285 CLASSIC,
3286 { },
3287 { { 1, SKB_MARK}, { 10, SKB_MARK} },
3288 },
3289 {
3290 "LD_RXHASH",
3291 .u.insns = {
3292 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3293 SKF_AD_OFF + SKF_AD_RXHASH),
3294 BPF_STMT(BPF_RET | BPF_A, 0)
3295 },
3296 CLASSIC,
3297 { },
3298 { { 1, SKB_HASH}, { 10, SKB_HASH} },
3299 },
3300 {
3301 "LD_QUEUE",
3302 .u.insns = {
3303 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3304 SKF_AD_OFF + SKF_AD_QUEUE),
3305 BPF_STMT(BPF_RET | BPF_A, 0)
3306 },
3307 CLASSIC,
3308 { },
3309 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
3310 },
3311 {
3312 "LD_PROTOCOL",
3313 .u.insns = {
3314 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
3315 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
3316 BPF_STMT(BPF_RET | BPF_K, 0),
3317 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3318 SKF_AD_OFF + SKF_AD_PROTOCOL),
3319 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3320 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3321 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
3322 BPF_STMT(BPF_RET | BPF_K, 0),
3323 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3324 BPF_STMT(BPF_RET | BPF_A, 0)
3325 },
3326 CLASSIC,
3327 { 10, 20, 30 },
3328 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
3329 },
3330 {
3331 "LD_VLAN_TAG",
3332 .u.insns = {
3333 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3334 SKF_AD_OFF + SKF_AD_VLAN_TAG),
3335 BPF_STMT(BPF_RET | BPF_A, 0)
3336 },
3337 CLASSIC,
3338 { },
3339 {
3340 { 1, SKB_VLAN_TCI },
3341 { 10, SKB_VLAN_TCI }
3342 },
3343 },
3344 {
3345 "LD_VLAN_TAG_PRESENT",
3346 .u.insns = {
3347 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3348 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
3349 BPF_STMT(BPF_RET | BPF_A, 0)
3350 },
3351 CLASSIC,
3352 { },
3353 {
3354 { 1, SKB_VLAN_PRESENT },
3355 { 10, SKB_VLAN_PRESENT }
3356 },
3357 },
3358 {
3359 "LD_IFINDEX",
3360 .u.insns = {
3361 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3362 SKF_AD_OFF + SKF_AD_IFINDEX),
3363 BPF_STMT(BPF_RET | BPF_A, 0)
3364 },
3365 CLASSIC,
3366 { },
3367 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
3368 },
3369 {
3370 "LD_HATYPE",
3371 .u.insns = {
3372 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3373 SKF_AD_OFF + SKF_AD_HATYPE),
3374 BPF_STMT(BPF_RET | BPF_A, 0)
3375 },
3376 CLASSIC,
3377 { },
3378 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
3379 },
3380 {
3381 "LD_CPU",
3382 .u.insns = {
3383 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3384 SKF_AD_OFF + SKF_AD_CPU),
3385 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3386 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3387 SKF_AD_OFF + SKF_AD_CPU),
3388 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3389 BPF_STMT(BPF_RET | BPF_A, 0)
3390 },
3391 CLASSIC,
3392 { },
3393 { { 1, 0 }, { 10, 0 } },
3394 },
3395 {
3396 "LD_NLATTR",
3397 .u.insns = {
3398 BPF_STMT(BPF_LDX | BPF_IMM, 2),
3399 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3400 BPF_STMT(BPF_LDX | BPF_IMM, 3),
3401 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3402 SKF_AD_OFF + SKF_AD_NLATTR),
3403 BPF_STMT(BPF_RET | BPF_A, 0)
3404 },
3405 CLASSIC,
3406 #ifdef __BIG_ENDIAN
3407 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
3408 #else
3409 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
3410 #endif
3411 { { 4, 0 }, { 20, 6 } },
3412 },
3413 {
3414 "LD_NLATTR_NEST",
3415 .u.insns = {
3416 BPF_STMT(BPF_LD | BPF_IMM, 2),
3417 BPF_STMT(BPF_LDX | BPF_IMM, 3),
3418 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3419 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3420 BPF_STMT(BPF_LD | BPF_IMM, 2),
3421 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3422 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3423 BPF_STMT(BPF_LD | BPF_IMM, 2),
3424 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3425 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3426 BPF_STMT(BPF_LD | BPF_IMM, 2),
3427 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3428 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3429 BPF_STMT(BPF_LD | BPF_IMM, 2),
3430 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3431 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3432 BPF_STMT(BPF_LD | BPF_IMM, 2),
3433 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3434 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3435 BPF_STMT(BPF_LD | BPF_IMM, 2),
3436 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3437 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3438 BPF_STMT(BPF_LD | BPF_IMM, 2),
3439 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3440 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
3441 BPF_STMT(BPF_RET | BPF_A, 0)
3442 },
3443 CLASSIC,
3444 #ifdef __BIG_ENDIAN
3445 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
3446 #else
3447 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
3448 #endif
3449 { { 4, 0 }, { 20, 10 } },
3450 },
3451 {
3452 "LD_PAYLOAD_OFF",
3453 .u.insns = {
3454 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3455 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3456 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3457 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3458 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3459 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3460 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3461 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3462 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3463 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
3464 BPF_STMT(BPF_RET | BPF_A, 0)
3465 },
3466 CLASSIC,
3467 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
3468 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
3469 * id 9737, seq 1, length 64
3470 */
3471 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3472 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3473 0x08, 0x00,
3474 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
3475 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
3476 { { 30, 0 }, { 100, 42 } },
3477 },
3478 {
3479 "LD_ANC_XOR",
3480 .u.insns = {
3481 BPF_STMT(BPF_LD | BPF_IMM, 10),
3482 BPF_STMT(BPF_LDX | BPF_IMM, 300),
3483 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3484 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
3485 BPF_STMT(BPF_RET | BPF_A, 0)
3486 },
3487 CLASSIC,
3488 { },
3489 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
3490 },
3491 {
3492 "SPILL_FILL",
3493 .u.insns = {
3494 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3495 BPF_STMT(BPF_LD | BPF_IMM, 2),
3496 BPF_STMT(BPF_ALU | BPF_RSH, 1),
3497 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3498 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
3499 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
3500 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
3501 BPF_STMT(BPF_STX, 15), /* M3 = len */
3502 BPF_STMT(BPF_LDX | BPF_MEM, 1),
3503 BPF_STMT(BPF_LD | BPF_MEM, 2),
3504 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3505 BPF_STMT(BPF_LDX | BPF_MEM, 15),
3506 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
3507 BPF_STMT(BPF_RET | BPF_A, 0)
3508 },
3509 CLASSIC,
3510 { },
3511 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
3512 },
3513 {
3514 "JEQ",
3515 .u.insns = {
3516 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3517 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3518 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
3519 BPF_STMT(BPF_RET | BPF_K, 1),
3520 BPF_STMT(BPF_RET | BPF_K, MAX_K)
3521 },
3522 CLASSIC,
3523 { 3, 3, 3, 3, 3 },
3524 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
3525 },
3526 {
3527 "JGT",
3528 .u.insns = {
3529 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3530 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3531 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
3532 BPF_STMT(BPF_RET | BPF_K, 1),
3533 BPF_STMT(BPF_RET | BPF_K, MAX_K)
3534 },
3535 CLASSIC,
3536 { 4, 4, 4, 3, 3 },
3537 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
3538 },
3539 {
3540 "JGE (jt 0), test 1",
3541 .u.insns = {
3542 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3543 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3544 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3545 BPF_STMT(BPF_RET | BPF_K, 1),
3546 BPF_STMT(BPF_RET | BPF_K, MAX_K)
3547 },
3548 CLASSIC,
3549 { 4, 4, 4, 3, 3 },
3550 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
3551 },
3552 {
3553 "JGE (jt 0), test 2",
3554 .u.insns = {
3555 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3556 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
3557 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
3558 BPF_STMT(BPF_RET | BPF_K, 1),
3559 BPF_STMT(BPF_RET | BPF_K, MAX_K)
3560 },
3561 CLASSIC,
3562 { 4, 4, 5, 3, 3 },
3563 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
3564 },
3565 {
3566 "JGE",
3567 .u.insns = {
3568 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3569 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
3570 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
3571 BPF_STMT(BPF_RET | BPF_K, 10),
3572 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
3573 BPF_STMT(BPF_RET | BPF_K, 20),
3574 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
3575 BPF_STMT(BPF_RET | BPF_K, 30),
3576 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
3577 BPF_STMT(BPF_RET | BPF_K, 40),
3578 BPF_STMT(BPF_RET | BPF_K, MAX_K)
3579 },
3580 CLASSIC,
3581 { 1, 2, 3, 4, 5 },
3582 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
3583 },
3584 {
3585 "JSET",
3586 .u.insns = {
3587 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3588 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
3589 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3590 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
3591 BPF_STMT(BPF_LDX | BPF_LEN, 0),
3592 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3593 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
3594 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3595 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
3596 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
3597 BPF_STMT(BPF_RET | BPF_K, 10),
3598 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
3599 BPF_STMT(BPF_RET | BPF_K, 20),
3600 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3601 BPF_STMT(BPF_RET | BPF_K, 30),
3602 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3603 BPF_STMT(BPF_RET | BPF_K, 30),
3604 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3605 BPF_STMT(BPF_RET | BPF_K, 30),
3606 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3607 BPF_STMT(BPF_RET | BPF_K, 30),
3608 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
3609 BPF_STMT(BPF_RET | BPF_K, 30),
3610 BPF_STMT(BPF_RET | BPF_K, MAX_K)
3611 },
3612 CLASSIC,
3613 { 0, 0xAA, 0x55, 1 },
3614 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
3615 },
3616 {
3617 "tcpdump port 22",
3618 .u.insns = {
3619 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3620 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
3621 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
3622 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3623 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3624 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
3625 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
3626 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
3627 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
3628 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
3629 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
3630 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3631 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
3632 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
3633 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
3634 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3635 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
3636 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3637 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3638 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3639 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3640 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
3641 BPF_STMT(BPF_RET | BPF_K, 0xffff),
3642 BPF_STMT(BPF_RET | BPF_K, 0),
3643 },
3644 CLASSIC,
3645 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
3646 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
3647 * seq 1305692979:1305693027, ack 3650467037, win 65535,
3648 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
3649 */
3650 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3651 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3652 0x08, 0x00,
3653 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3654 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3655 0x0a, 0x01, 0x01, 0x95, /* ip src */
3656 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3657 0xc2, 0x24,
3658 0x00, 0x16 /* dst port */ },
3659 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3660 },
3661 {
3662 "tcpdump complex",
3663 .u.insns = {
3664 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
3665 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
3666 * (len > 115 or len < 30000000000)' -d
3667 */
3668 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
3669 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
3670 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
3671 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
3672 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
3673 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
3674 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
3675 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3676 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
3677 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
3678 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
3679 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
3680 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
3681 BPF_STMT(BPF_ST, 1),
3682 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
3683 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
3684 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
3685 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
3686 BPF_STMT(BPF_LD | BPF_MEM, 1),
3687 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
3688 BPF_STMT(BPF_ST, 5),
3689 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
3690 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
3691 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
3692 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
3693 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
3694 BPF_STMT(BPF_LD | BPF_MEM, 5),
3695 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
3696 BPF_STMT(BPF_LD | BPF_LEN, 0),
3697 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
3698 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
3699 BPF_STMT(BPF_RET | BPF_K, 0xffff),
3700 BPF_STMT(BPF_RET | BPF_K, 0),
3701 },
3702 CLASSIC,
3703 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
3704 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
3705 0x08, 0x00,
3706 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
3707 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
3708 0x0a, 0x01, 0x01, 0x95, /* ip src */
3709 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
3710 0xc2, 0x24,
3711 0x00, 0x16 /* dst port */ },
3712 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
3713 },
3714 {
3715 "RET_A",
3716 .u.insns = {
3717 /* check that uninitialized X and A contain zeros */
3718 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3719 BPF_STMT(BPF_RET | BPF_A, 0)
3720 },
3721 CLASSIC,
3722 { },
3723 { {1, 0}, {2, 0} },
3724 },
3725 {
3726 "INT: ADD trivial",
3727 .u.insns_int = {
3728 BPF_ALU64_IMM(BPF_MOV, R1, 1),
3729 BPF_ALU64_IMM(BPF_ADD, R1, 2),
3730 BPF_ALU64_IMM(BPF_MOV, R2, 3),
3731 BPF_ALU64_REG(BPF_SUB, R1, R2),
3732 BPF_ALU64_IMM(BPF_ADD, R1, -1),
3733 BPF_ALU64_IMM(BPF_MUL, R1, 3),
3734 BPF_ALU64_REG(BPF_MOV, R0, R1),
3735 BPF_EXIT_INSN(),
3736 },
3737 INTERNAL,
3738 { },
3739 { { 0, 0xfffffffd } }
3740 },
3741 {
3742 "INT: MUL_X",
3743 .u.insns_int = {
3744 BPF_ALU64_IMM(BPF_MOV, R0, -1),
3745 BPF_ALU64_IMM(BPF_MOV, R1, -1),
3746 BPF_ALU64_IMM(BPF_MOV, R2, 3),
3747 BPF_ALU64_REG(BPF_MUL, R1, R2),
3748 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
3749 BPF_EXIT_INSN(),
3750 BPF_ALU64_IMM(BPF_MOV, R0, 1),
3751 BPF_EXIT_INSN(),
3752 },
3753 INTERNAL,
3754 { },
3755 { { 0, 1 } }
3756 },
3757 {
3758 "INT: MUL_X2",
3759 .u.insns_int = {
3760 BPF_ALU32_IMM(BPF_MOV, R0, -1),
3761 BPF_ALU32_IMM(BPF_MOV, R1, -1),
3762 BPF_ALU32_IMM(BPF_MOV, R2, 3),
3763 BPF_ALU64_REG(BPF_MUL, R1, R2),
3764 BPF_ALU64_IMM(BPF_RSH, R1, 8),
3765 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
3766 BPF_EXIT_INSN(),
3767 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3768 BPF_EXIT_INSN(),
3769 },
3770 INTERNAL,
3771 { },
3772 { { 0, 1 } }
3773 },
3774 {
3775 "INT: MUL32_X",
3776 .u.insns_int = {
3777 BPF_ALU32_IMM(BPF_MOV, R0, -1),
3778 BPF_ALU64_IMM(BPF_MOV, R1, -1),
3779 BPF_ALU32_IMM(BPF_MOV, R2, 3),
3780 BPF_ALU32_REG(BPF_MUL, R1, R2),
3781 BPF_ALU64_IMM(BPF_RSH, R1, 8),
3782 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
3783 BPF_EXIT_INSN(),
3784 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3785 BPF_EXIT_INSN(),
3786 },
3787 INTERNAL,
3788 { },
3789 { { 0, 1 } }
3790 },
3791 {
3792 /* Have to test all register combinations, since
3793 * JITing of different registers will produce
3794 * different asm code.
3795 */
3796 "INT: ADD 64-bit",
3797 .u.insns_int = {
3798 BPF_ALU64_IMM(BPF_MOV, R0, 0),
3799 BPF_ALU64_IMM(BPF_MOV, R1, 1),
3800 BPF_ALU64_IMM(BPF_MOV, R2, 2),
3801 BPF_ALU64_IMM(BPF_MOV, R3, 3),
3802 BPF_ALU64_IMM(BPF_MOV, R4, 4),
3803 BPF_ALU64_IMM(BPF_MOV, R5, 5),
3804 BPF_ALU64_IMM(BPF_MOV, R6, 6),
3805 BPF_ALU64_IMM(BPF_MOV, R7, 7),
3806 BPF_ALU64_IMM(BPF_MOV, R8, 8),
3807 BPF_ALU64_IMM(BPF_MOV, R9, 9),
3808 BPF_ALU64_IMM(BPF_ADD, R0, 20),
3809 BPF_ALU64_IMM(BPF_ADD, R1, 20),
3810 BPF_ALU64_IMM(BPF_ADD, R2, 20),
3811 BPF_ALU64_IMM(BPF_ADD, R3, 20),
3812 BPF_ALU64_IMM(BPF_ADD, R4, 20),
3813 BPF_ALU64_IMM(BPF_ADD, R5, 20),
3814 BPF_ALU64_IMM(BPF_ADD, R6, 20),
3815 BPF_ALU64_IMM(BPF_ADD, R7, 20),
3816 BPF_ALU64_IMM(BPF_ADD, R8, 20),
3817 BPF_ALU64_IMM(BPF_ADD, R9, 20),
3818 BPF_ALU64_IMM(BPF_SUB, R0, 10),
3819 BPF_ALU64_IMM(BPF_SUB, R1, 10),
3820 BPF_ALU64_IMM(BPF_SUB, R2, 10),
3821 BPF_ALU64_IMM(BPF_SUB, R3, 10),
3822 BPF_ALU64_IMM(BPF_SUB, R4, 10),
3823 BPF_ALU64_IMM(BPF_SUB, R5, 10),
3824 BPF_ALU64_IMM(BPF_SUB, R6, 10),
3825 BPF_ALU64_IMM(BPF_SUB, R7, 10),
3826 BPF_ALU64_IMM(BPF_SUB, R8, 10),
3827 BPF_ALU64_IMM(BPF_SUB, R9, 10),
3828 BPF_ALU64_REG(BPF_ADD, R0, R0),
3829 BPF_ALU64_REG(BPF_ADD, R0, R1),
3830 BPF_ALU64_REG(BPF_ADD, R0, R2),
3831 BPF_ALU64_REG(BPF_ADD, R0, R3),
3832 BPF_ALU64_REG(BPF_ADD, R0, R4),
3833 BPF_ALU64_REG(BPF_ADD, R0, R5),
3834 BPF_ALU64_REG(BPF_ADD, R0, R6),
3835 BPF_ALU64_REG(BPF_ADD, R0, R7),
3836 BPF_ALU64_REG(BPF_ADD, R0, R8),
3837 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3838 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3839 BPF_EXIT_INSN(),
3840 BPF_ALU64_REG(BPF_ADD, R1, R0),
3841 BPF_ALU64_REG(BPF_ADD, R1, R1),
3842 BPF_ALU64_REG(BPF_ADD, R1, R2),
3843 BPF_ALU64_REG(BPF_ADD, R1, R3),
3844 BPF_ALU64_REG(BPF_ADD, R1, R4),
3845 BPF_ALU64_REG(BPF_ADD, R1, R5),
3846 BPF_ALU64_REG(BPF_ADD, R1, R6),
3847 BPF_ALU64_REG(BPF_ADD, R1, R7),
3848 BPF_ALU64_REG(BPF_ADD, R1, R8),
3849 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3850 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3851 BPF_EXIT_INSN(),
3852 BPF_ALU64_REG(BPF_ADD, R2, R0),
3853 BPF_ALU64_REG(BPF_ADD, R2, R1),
3854 BPF_ALU64_REG(BPF_ADD, R2, R2),
3855 BPF_ALU64_REG(BPF_ADD, R2, R3),
3856 BPF_ALU64_REG(BPF_ADD, R2, R4),
3857 BPF_ALU64_REG(BPF_ADD, R2, R5),
3858 BPF_ALU64_REG(BPF_ADD, R2, R6),
3859 BPF_ALU64_REG(BPF_ADD, R2, R7),
3860 BPF_ALU64_REG(BPF_ADD, R2, R8),
3861 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3862 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3863 BPF_EXIT_INSN(),
3864 BPF_ALU64_REG(BPF_ADD, R3, R0),
3865 BPF_ALU64_REG(BPF_ADD, R3, R1),
3866 BPF_ALU64_REG(BPF_ADD, R3, R2),
3867 BPF_ALU64_REG(BPF_ADD, R3, R3),
3868 BPF_ALU64_REG(BPF_ADD, R3, R4),
3869 BPF_ALU64_REG(BPF_ADD, R3, R5),
3870 BPF_ALU64_REG(BPF_ADD, R3, R6),
3871 BPF_ALU64_REG(BPF_ADD, R3, R7),
3872 BPF_ALU64_REG(BPF_ADD, R3, R8),
3873 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3874 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3875 BPF_EXIT_INSN(),
3876 BPF_ALU64_REG(BPF_ADD, R4, R0),
3877 BPF_ALU64_REG(BPF_ADD, R4, R1),
3878 BPF_ALU64_REG(BPF_ADD, R4, R2),
3879 BPF_ALU64_REG(BPF_ADD, R4, R3),
3880 BPF_ALU64_REG(BPF_ADD, R4, R4),
3881 BPF_ALU64_REG(BPF_ADD, R4, R5),
3882 BPF_ALU64_REG(BPF_ADD, R4, R6),
3883 BPF_ALU64_REG(BPF_ADD, R4, R7),
3884 BPF_ALU64_REG(BPF_ADD, R4, R8),
3885 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3886 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3887 BPF_EXIT_INSN(),
3888 BPF_ALU64_REG(BPF_ADD, R5, R0),
3889 BPF_ALU64_REG(BPF_ADD, R5, R1),
3890 BPF_ALU64_REG(BPF_ADD, R5, R2),
3891 BPF_ALU64_REG(BPF_ADD, R5, R3),
3892 BPF_ALU64_REG(BPF_ADD, R5, R4),
3893 BPF_ALU64_REG(BPF_ADD, R5, R5),
3894 BPF_ALU64_REG(BPF_ADD, R5, R6),
3895 BPF_ALU64_REG(BPF_ADD, R5, R7),
3896 BPF_ALU64_REG(BPF_ADD, R5, R8),
3897 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3898 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3899 BPF_EXIT_INSN(),
3900 BPF_ALU64_REG(BPF_ADD, R6, R0),
3901 BPF_ALU64_REG(BPF_ADD, R6, R1),
3902 BPF_ALU64_REG(BPF_ADD, R6, R2),
3903 BPF_ALU64_REG(BPF_ADD, R6, R3),
3904 BPF_ALU64_REG(BPF_ADD, R6, R4),
3905 BPF_ALU64_REG(BPF_ADD, R6, R5),
3906 BPF_ALU64_REG(BPF_ADD, R6, R6),
3907 BPF_ALU64_REG(BPF_ADD, R6, R7),
3908 BPF_ALU64_REG(BPF_ADD, R6, R8),
3909 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3910 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3911 BPF_EXIT_INSN(),
3912 BPF_ALU64_REG(BPF_ADD, R7, R0),
3913 BPF_ALU64_REG(BPF_ADD, R7, R1),
3914 BPF_ALU64_REG(BPF_ADD, R7, R2),
3915 BPF_ALU64_REG(BPF_ADD, R7, R3),
3916 BPF_ALU64_REG(BPF_ADD, R7, R4),
3917 BPF_ALU64_REG(BPF_ADD, R7, R5),
3918 BPF_ALU64_REG(BPF_ADD, R7, R6),
3919 BPF_ALU64_REG(BPF_ADD, R7, R7),
3920 BPF_ALU64_REG(BPF_ADD, R7, R8),
3921 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3922 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3923 BPF_EXIT_INSN(),
3924 BPF_ALU64_REG(BPF_ADD, R8, R0),
3925 BPF_ALU64_REG(BPF_ADD, R8, R1),
3926 BPF_ALU64_REG(BPF_ADD, R8, R2),
3927 BPF_ALU64_REG(BPF_ADD, R8, R3),
3928 BPF_ALU64_REG(BPF_ADD, R8, R4),
3929 BPF_ALU64_REG(BPF_ADD, R8, R5),
3930 BPF_ALU64_REG(BPF_ADD, R8, R6),
3931 BPF_ALU64_REG(BPF_ADD, R8, R7),
3932 BPF_ALU64_REG(BPF_ADD, R8, R8),
3933 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3934 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3935 BPF_EXIT_INSN(),
3936 BPF_ALU64_REG(BPF_ADD, R9, R0),
3937 BPF_ALU64_REG(BPF_ADD, R9, R1),
3938 BPF_ALU64_REG(BPF_ADD, R9, R2),
3939 BPF_ALU64_REG(BPF_ADD, R9, R3),
3940 BPF_ALU64_REG(BPF_ADD, R9, R4),
3941 BPF_ALU64_REG(BPF_ADD, R9, R5),
3942 BPF_ALU64_REG(BPF_ADD, R9, R6),
3943 BPF_ALU64_REG(BPF_ADD, R9, R7),
3944 BPF_ALU64_REG(BPF_ADD, R9, R8),
3945 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3946 BPF_ALU64_REG(BPF_MOV, R0, R9),
3947 BPF_EXIT_INSN(),
3948 },
3949 INTERNAL,
3950 { },
3951 { { 0, 2957380 } }
3952 },
3953 {
3954 "INT: ADD 32-bit",
3955 .u.insns_int = {
3956 BPF_ALU32_IMM(BPF_MOV, R0, 20),
3957 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3958 BPF_ALU32_IMM(BPF_MOV, R2, 2),
3959 BPF_ALU32_IMM(BPF_MOV, R3, 3),
3960 BPF_ALU32_IMM(BPF_MOV, R4, 4),
3961 BPF_ALU32_IMM(BPF_MOV, R5, 5),
3962 BPF_ALU32_IMM(BPF_MOV, R6, 6),
3963 BPF_ALU32_IMM(BPF_MOV, R7, 7),
3964 BPF_ALU32_IMM(BPF_MOV, R8, 8),
3965 BPF_ALU32_IMM(BPF_MOV, R9, 9),
3966 BPF_ALU64_IMM(BPF_ADD, R1, 10),
3967 BPF_ALU64_IMM(BPF_ADD, R2, 10),
3968 BPF_ALU64_IMM(BPF_ADD, R3, 10),
3969 BPF_ALU64_IMM(BPF_ADD, R4, 10),
3970 BPF_ALU64_IMM(BPF_ADD, R5, 10),
3971 BPF_ALU64_IMM(BPF_ADD, R6, 10),
3972 BPF_ALU64_IMM(BPF_ADD, R7, 10),
3973 BPF_ALU64_IMM(BPF_ADD, R8, 10),
3974 BPF_ALU64_IMM(BPF_ADD, R9, 10),
3975 BPF_ALU32_REG(BPF_ADD, R0, R1),
3976 BPF_ALU32_REG(BPF_ADD, R0, R2),
3977 BPF_ALU32_REG(BPF_ADD, R0, R3),
3978 BPF_ALU32_REG(BPF_ADD, R0, R4),
3979 BPF_ALU32_REG(BPF_ADD, R0, R5),
3980 BPF_ALU32_REG(BPF_ADD, R0, R6),
3981 BPF_ALU32_REG(BPF_ADD, R0, R7),
3982 BPF_ALU32_REG(BPF_ADD, R0, R8),
3983 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3984 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3985 BPF_EXIT_INSN(),
3986 BPF_ALU32_REG(BPF_ADD, R1, R0),
3987 BPF_ALU32_REG(BPF_ADD, R1, R1),
3988 BPF_ALU32_REG(BPF_ADD, R1, R2),
3989 BPF_ALU32_REG(BPF_ADD, R1, R3),
3990 BPF_ALU32_REG(BPF_ADD, R1, R4),
3991 BPF_ALU32_REG(BPF_ADD, R1, R5),
3992 BPF_ALU32_REG(BPF_ADD, R1, R6),
3993 BPF_ALU32_REG(BPF_ADD, R1, R7),
3994 BPF_ALU32_REG(BPF_ADD, R1, R8),
3995 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3996 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3997 BPF_EXIT_INSN(),
3998 BPF_ALU32_REG(BPF_ADD, R2, R0),
3999 BPF_ALU32_REG(BPF_ADD, R2, R1),
4000 BPF_ALU32_REG(BPF_ADD, R2, R2),
4001 BPF_ALU32_REG(BPF_ADD, R2, R3),
4002 BPF_ALU32_REG(BPF_ADD, R2, R4),
4003 BPF_ALU32_REG(BPF_ADD, R2, R5),
4004 BPF_ALU32_REG(BPF_ADD, R2, R6),
4005 BPF_ALU32_REG(BPF_ADD, R2, R7),
4006 BPF_ALU32_REG(BPF_ADD, R2, R8),
4007 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
4008 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
4009 BPF_EXIT_INSN(),
4010 BPF_ALU32_REG(BPF_ADD, R3, R0),
4011 BPF_ALU32_REG(BPF_ADD, R3, R1),
4012 BPF_ALU32_REG(BPF_ADD, R3, R2),
4013 BPF_ALU32_REG(BPF_ADD, R3, R3),
4014 BPF_ALU32_REG(BPF_ADD, R3, R4),
4015 BPF_ALU32_REG(BPF_ADD, R3, R5),
4016 BPF_ALU32_REG(BPF_ADD, R3, R6),
4017 BPF_ALU32_REG(BPF_ADD, R3, R7),
4018 BPF_ALU32_REG(BPF_ADD, R3, R8),
4019 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
4020 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
4021 BPF_EXIT_INSN(),
4022 BPF_ALU32_REG(BPF_ADD, R4, R0),
4023 BPF_ALU32_REG(BPF_ADD, R4, R1),
4024 BPF_ALU32_REG(BPF_ADD, R4, R2),
4025 BPF_ALU32_REG(BPF_ADD, R4, R3),
4026 BPF_ALU32_REG(BPF_ADD, R4, R4),
4027 BPF_ALU32_REG(BPF_ADD, R4, R5),
4028 BPF_ALU32_REG(BPF_ADD, R4, R6),
4029 BPF_ALU32_REG(BPF_ADD, R4, R7),
4030 BPF_ALU32_REG(BPF_ADD, R4, R8),
4031 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
4032 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
4033 BPF_EXIT_INSN(),
4034 BPF_ALU32_REG(BPF_ADD, R5, R0),
4035 BPF_ALU32_REG(BPF_ADD, R5, R1),
4036 BPF_ALU32_REG(BPF_ADD, R5, R2),
4037 BPF_ALU32_REG(BPF_ADD, R5, R3),
4038 BPF_ALU32_REG(BPF_ADD, R5, R4),
4039 BPF_ALU32_REG(BPF_ADD, R5, R5),
4040 BPF_ALU32_REG(BPF_ADD, R5, R6),
4041 BPF_ALU32_REG(BPF_ADD, R5, R7),
4042 BPF_ALU32_REG(BPF_ADD, R5, R8),
4043 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
4044 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
4045 BPF_EXIT_INSN(),
4046 BPF_ALU32_REG(BPF_ADD, R6, R0),
4047 BPF_ALU32_REG(BPF_ADD, R6, R1),
4048 BPF_ALU32_REG(BPF_ADD, R6, R2),
4049 BPF_ALU32_REG(BPF_ADD, R6, R3),
4050 BPF_ALU32_REG(BPF_ADD, R6, R4),
4051 BPF_ALU32_REG(BPF_ADD, R6, R5),
4052 BPF_ALU32_REG(BPF_ADD, R6, R6),
4053 BPF_ALU32_REG(BPF_ADD, R6, R7),
4054 BPF_ALU32_REG(BPF_ADD, R6, R8),
4055 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
4056 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
4057 BPF_EXIT_INSN(),
4058 BPF_ALU32_REG(BPF_ADD, R7, R0),
4059 BPF_ALU32_REG(BPF_ADD, R7, R1),
4060 BPF_ALU32_REG(BPF_ADD, R7, R2),
4061 BPF_ALU32_REG(BPF_ADD, R7, R3),
4062 BPF_ALU32_REG(BPF_ADD, R7, R4),
4063 BPF_ALU32_REG(BPF_ADD, R7, R5),
4064 BPF_ALU32_REG(BPF_ADD, R7, R6),
4065 BPF_ALU32_REG(BPF_ADD, R7, R7),
4066 BPF_ALU32_REG(BPF_ADD, R7, R8),
4067 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
4068 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
4069 BPF_EXIT_INSN(),
4070 BPF_ALU32_REG(BPF_ADD, R8, R0),
4071 BPF_ALU32_REG(BPF_ADD, R8, R1),
4072 BPF_ALU32_REG(BPF_ADD, R8, R2),
4073 BPF_ALU32_REG(BPF_ADD, R8, R3),
4074 BPF_ALU32_REG(BPF_ADD, R8, R4),
4075 BPF_ALU32_REG(BPF_ADD, R8, R5),
4076 BPF_ALU32_REG(BPF_ADD, R8, R6),
4077 BPF_ALU32_REG(BPF_ADD, R8, R7),
4078 BPF_ALU32_REG(BPF_ADD, R8, R8),
4079 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
4080 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
4081 BPF_EXIT_INSN(),
4082 BPF_ALU32_REG(BPF_ADD, R9, R0),
4083 BPF_ALU32_REG(BPF_ADD, R9, R1),
4084 BPF_ALU32_REG(BPF_ADD, R9, R2),
4085 BPF_ALU32_REG(BPF_ADD, R9, R3),
4086 BPF_ALU32_REG(BPF_ADD, R9, R4),
4087 BPF_ALU32_REG(BPF_ADD, R9, R5),
4088 BPF_ALU32_REG(BPF_ADD, R9, R6),
4089 BPF_ALU32_REG(BPF_ADD, R9, R7),
4090 BPF_ALU32_REG(BPF_ADD, R9, R8),
4091 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
4092 BPF_ALU32_REG(BPF_MOV, R0, R9),
4093 BPF_EXIT_INSN(),
4094 },
4095 INTERNAL,
4096 { },
4097 { { 0, 2957380 } }
4098 },
4099 { /* Mainly checking JIT here. */
4100 "INT: SUB",
4101 .u.insns_int = {
4102 BPF_ALU64_IMM(BPF_MOV, R0, 0),
4103 BPF_ALU64_IMM(BPF_MOV, R1, 1),
4104 BPF_ALU64_IMM(BPF_MOV, R2, 2),
4105 BPF_ALU64_IMM(BPF_MOV, R3, 3),
4106 BPF_ALU64_IMM(BPF_MOV, R4, 4),
4107 BPF_ALU64_IMM(BPF_MOV, R5, 5),
4108 BPF_ALU64_IMM(BPF_MOV, R6, 6),
4109 BPF_ALU64_IMM(BPF_MOV, R7, 7),
4110 BPF_ALU64_IMM(BPF_MOV, R8, 8),
4111 BPF_ALU64_IMM(BPF_MOV, R9, 9),
4112 BPF_ALU64_REG(BPF_SUB, R0, R0),
4113 BPF_ALU64_REG(BPF_SUB, R0, R1),
4114 BPF_ALU64_REG(BPF_SUB, R0, R2),
4115 BPF_ALU64_REG(BPF_SUB, R0, R3),
4116 BPF_ALU64_REG(BPF_SUB, R0, R4),
4117 BPF_ALU64_REG(BPF_SUB, R0, R5),
4118 BPF_ALU64_REG(BPF_SUB, R0, R6),
4119 BPF_ALU64_REG(BPF_SUB, R0, R7),
4120 BPF_ALU64_REG(BPF_SUB, R0, R8),
4121 BPF_ALU64_REG(BPF_SUB, R0, R9),
4122 BPF_ALU64_IMM(BPF_SUB, R0, 10),
4123 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
4124 BPF_EXIT_INSN(),
4125 BPF_ALU64_REG(BPF_SUB, R1, R0),
4126 BPF_ALU64_REG(BPF_SUB, R1, R2),
4127 BPF_ALU64_REG(BPF_SUB, R1, R3),
4128 BPF_ALU64_REG(BPF_SUB, R1, R4),
4129 BPF_ALU64_REG(BPF_SUB, R1, R5),
4130 BPF_ALU64_REG(BPF_SUB, R1, R6),
4131 BPF_ALU64_REG(BPF_SUB, R1, R7),
4132 BPF_ALU64_REG(BPF_SUB, R1, R8),
4133 BPF_ALU64_REG(BPF_SUB, R1, R9),
4134 BPF_ALU64_IMM(BPF_SUB, R1, 10),
4135 BPF_ALU64_REG(BPF_SUB, R2, R0),
4136 BPF_ALU64_REG(BPF_SUB, R2, R1),
4137 BPF_ALU64_REG(BPF_SUB, R2, R3),
4138 BPF_ALU64_REG(BPF_SUB, R2, R4),
4139 BPF_ALU64_REG(BPF_SUB, R2, R5),
4140 BPF_ALU64_REG(BPF_SUB, R2, R6),
4141 BPF_ALU64_REG(BPF_SUB, R2, R7),
4142 BPF_ALU64_REG(BPF_SUB, R2, R8),
4143 BPF_ALU64_REG(BPF_SUB, R2, R9),
4144 BPF_ALU64_IMM(BPF_SUB, R2, 10),
4145 BPF_ALU64_REG(BPF_SUB, R3, R0),
4146 BPF_ALU64_REG(BPF_SUB, R3, R1),
4147 BPF_ALU64_REG(BPF_SUB, R3, R2),
4148 BPF_ALU64_REG(BPF_SUB, R3, R4),
4149 BPF_ALU64_REG(BPF_SUB, R3, R5),
4150 BPF_ALU64_REG(BPF_SUB, R3, R6),
4151 BPF_ALU64_REG(BPF_SUB, R3, R7),
4152 BPF_ALU64_REG(BPF_SUB, R3, R8),
4153 BPF_ALU64_REG(BPF_SUB, R3, R9),
4154 BPF_ALU64_IMM(BPF_SUB, R3, 10),
4155 BPF_ALU64_REG(BPF_SUB, R4, R0),
4156 BPF_ALU64_REG(BPF_SUB, R4, R1),
4157 BPF_ALU64_REG(BPF_SUB, R4, R2),
4158 BPF_ALU64_REG(BPF_SUB, R4, R3),
4159 BPF_ALU64_REG(BPF_SUB, R4, R5),
4160 BPF_ALU64_REG(BPF_SUB, R4, R6),
4161 BPF_ALU64_REG(BPF_SUB, R4, R7),
4162 BPF_ALU64_REG(BPF_SUB, R4, R8),
4163 BPF_ALU64_REG(BPF_SUB, R4, R9),
4164 BPF_ALU64_IMM(BPF_SUB, R4, 10),
4165 BPF_ALU64_REG(BPF_SUB, R5, R0),
4166 BPF_ALU64_REG(BPF_SUB, R5, R1),
4167 BPF_ALU64_REG(BPF_SUB, R5, R2),
4168 BPF_ALU64_REG(BPF_SUB, R5, R3),
4169 BPF_ALU64_REG(BPF_SUB, R5, R4),
4170 BPF_ALU64_REG(BPF_SUB, R5, R6),
4171 BPF_ALU64_REG(BPF_SUB, R5, R7),
4172 BPF_ALU64_REG(BPF_SUB, R5, R8),
4173 BPF_ALU64_REG(BPF_SUB, R5, R9),
4174 BPF_ALU64_IMM(BPF_SUB, R5, 10),
4175 BPF_ALU64_REG(BPF_SUB, R6, R0),
4176 BPF_ALU64_REG(BPF_SUB, R6, R1),
4177 BPF_ALU64_REG(BPF_SUB, R6, R2),
4178 BPF_ALU64_REG(BPF_SUB, R6, R3),
4179 BPF_ALU64_REG(BPF_SUB, R6, R4),
4180 BPF_ALU64_REG(BPF_SUB, R6, R5),
4181 BPF_ALU64_REG(BPF_SUB, R6, R7),
4182 BPF_ALU64_REG(BPF_SUB, R6, R8),
4183 BPF_ALU64_REG(BPF_SUB, R6, R9),
4184 BPF_ALU64_IMM(BPF_SUB, R6, 10),
4185 BPF_ALU64_REG(BPF_SUB, R7, R0),
4186 BPF_ALU64_REG(BPF_SUB, R7, R1),
4187 BPF_ALU64_REG(BPF_SUB, R7, R2),
4188 BPF_ALU64_REG(BPF_SUB, R7, R3),
4189 BPF_ALU64_REG(BPF_SUB, R7, R4),
4190 BPF_ALU64_REG(BPF_SUB, R7, R5),
4191 BPF_ALU64_REG(BPF_SUB, R7, R6),
4192 BPF_ALU64_REG(BPF_SUB, R7, R8),
4193 BPF_ALU64_REG(BPF_SUB, R7, R9),
4194 BPF_ALU64_IMM(BPF_SUB, R7, 10),
4195 BPF_ALU64_REG(BPF_SUB, R8, R0),
4196 BPF_ALU64_REG(BPF_SUB, R8, R1),
4197 BPF_ALU64_REG(BPF_SUB, R8, R2),
4198 BPF_ALU64_REG(BPF_SUB, R8, R3),
4199 BPF_ALU64_REG(BPF_SUB, R8, R4),
4200 BPF_ALU64_REG(BPF_SUB, R8, R5),
4201 BPF_ALU64_REG(BPF_SUB, R8, R6),
4202 BPF_ALU64_REG(BPF_SUB, R8, R7),
4203 BPF_ALU64_REG(BPF_SUB, R8, R9),
4204 BPF_ALU64_IMM(BPF_SUB, R8, 10),
4205 BPF_ALU64_REG(BPF_SUB, R9, R0),
4206 BPF_ALU64_REG(BPF_SUB, R9, R1),
4207 BPF_ALU64_REG(BPF_SUB, R9, R2),
4208 BPF_ALU64_REG(BPF_SUB, R9, R3),
4209 BPF_ALU64_REG(BPF_SUB, R9, R4),
4210 BPF_ALU64_REG(BPF_SUB, R9, R5),
4211 BPF_ALU64_REG(BPF_SUB, R9, R6),
4212 BPF_ALU64_REG(BPF_SUB, R9, R7),
4213 BPF_ALU64_REG(BPF_SUB, R9, R8),
4214 BPF_ALU64_IMM(BPF_SUB, R9, 10),
4215 BPF_ALU64_IMM(BPF_SUB, R0, 10),
4216 BPF_ALU64_IMM(BPF_NEG, R0, 0),
4217 BPF_ALU64_REG(BPF_SUB, R0, R1),
4218 BPF_ALU64_REG(BPF_SUB, R0, R2),
4219 BPF_ALU64_REG(BPF_SUB, R0, R3),
4220 BPF_ALU64_REG(BPF_SUB, R0, R4),
4221 BPF_ALU64_REG(BPF_SUB, R0, R5),
4222 BPF_ALU64_REG(BPF_SUB, R0, R6),
4223 BPF_ALU64_REG(BPF_SUB, R0, R7),
4224 BPF_ALU64_REG(BPF_SUB, R0, R8),
4225 BPF_ALU64_REG(BPF_SUB, R0, R9),
4226 BPF_EXIT_INSN(),
4227 },
4228 INTERNAL,
4229 { },
4230 { { 0, 11 } }
4231 },
4232 { /* Mainly checking JIT here. */
4233 "INT: XOR",
4234 .u.insns_int = {
4235 BPF_ALU64_REG(BPF_SUB, R0, R0),
4236 BPF_ALU64_REG(BPF_XOR, R1, R1),
4237 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
4238 BPF_EXIT_INSN(),
4239 BPF_ALU64_IMM(BPF_MOV, R0, 10),
4240 BPF_ALU64_IMM(BPF_MOV, R1, -1),
4241 BPF_ALU64_REG(BPF_SUB, R1, R1),
4242 BPF_ALU64_REG(BPF_XOR, R2, R2),
4243 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4244 BPF_EXIT_INSN(),
4245 BPF_ALU64_REG(BPF_SUB, R2, R2),
4246 BPF_ALU64_REG(BPF_XOR, R3, R3),
4247 BPF_ALU64_IMM(BPF_MOV, R0, 10),
4248 BPF_ALU64_IMM(BPF_MOV, R1, -1),
4249 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
4250 BPF_EXIT_INSN(),
4251 BPF_ALU64_REG(BPF_SUB, R3, R3),
4252 BPF_ALU64_REG(BPF_XOR, R4, R4),
4253 BPF_ALU64_IMM(BPF_MOV, R2, 1),
4254 BPF_ALU64_IMM(BPF_MOV, R5, -1),
4255 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
4256 BPF_EXIT_INSN(),
4257 BPF_ALU64_REG(BPF_SUB, R4, R4),
4258 BPF_ALU64_REG(BPF_XOR, R5, R5),
4259 BPF_ALU64_IMM(BPF_MOV, R3, 1),
4260 BPF_ALU64_IMM(BPF_MOV, R7, -1),
4261 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
4262 BPF_EXIT_INSN(),
4263 BPF_ALU64_IMM(BPF_MOV, R5, 1),
4264 BPF_ALU64_REG(BPF_SUB, R5, R5),
4265 BPF_ALU64_REG(BPF_XOR, R6, R6),
4266 BPF_ALU64_IMM(BPF_MOV, R1, 1),
4267 BPF_ALU64_IMM(BPF_MOV, R8, -1),
4268 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
4269 BPF_EXIT_INSN(),
4270 BPF_ALU64_REG(BPF_SUB, R6, R6),
4271 BPF_ALU64_REG(BPF_XOR, R7, R7),
4272 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
4273 BPF_EXIT_INSN(),
4274 BPF_ALU64_REG(BPF_SUB, R7, R7),
4275 BPF_ALU64_REG(BPF_XOR, R8, R8),
4276 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
4277 BPF_EXIT_INSN(),
4278 BPF_ALU64_REG(BPF_SUB, R8, R8),
4279 BPF_ALU64_REG(BPF_XOR, R9, R9),
4280 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
4281 BPF_EXIT_INSN(),
4282 BPF_ALU64_REG(BPF_SUB, R9, R9),
4283 BPF_ALU64_REG(BPF_XOR, R0, R0),
4284 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
4285 BPF_EXIT_INSN(),
4286 BPF_ALU64_REG(BPF_SUB, R1, R1),
4287 BPF_ALU64_REG(BPF_XOR, R0, R0),
4288 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
4289 BPF_ALU64_IMM(BPF_MOV, R0, 0),
4290 BPF_EXIT_INSN(),
4291 BPF_ALU64_IMM(BPF_MOV, R0, 1),
4292 BPF_EXIT_INSN(),
4293 },
4294 INTERNAL,
4295 { },
4296 { { 0, 1 } }
4297 },
4298 { /* Mainly checking JIT here. */
4299 "INT: MUL",
4300 .u.insns_int = {
4301 BPF_ALU64_IMM(BPF_MOV, R0, 11),
4302 BPF_ALU64_IMM(BPF_MOV, R1, 1),
4303 BPF_ALU64_IMM(BPF_MOV, R2, 2),
4304 BPF_ALU64_IMM(BPF_MOV, R3, 3),
4305 BPF_ALU64_IMM(BPF_MOV, R4, 4),
4306 BPF_ALU64_IMM(BPF_MOV, R5, 5),
4307 BPF_ALU64_IMM(BPF_MOV, R6, 6),
4308 BPF_ALU64_IMM(BPF_MOV, R7, 7),
4309 BPF_ALU64_IMM(BPF_MOV, R8, 8),
4310 BPF_ALU64_IMM(BPF_MOV, R9, 9),
4311 BPF_ALU64_REG(BPF_MUL, R0, R0),
4312 BPF_ALU64_REG(BPF_MUL, R0, R1),
4313 BPF_ALU64_REG(BPF_MUL, R0, R2),
4314 BPF_ALU64_REG(BPF_MUL, R0, R3),
4315 BPF_ALU64_REG(BPF_MUL, R0, R4),
4316 BPF_ALU64_REG(BPF_MUL, R0, R5),
4317 BPF_ALU64_REG(BPF_MUL, R0, R6),
4318 BPF_ALU64_REG(BPF_MUL, R0, R7),
4319 BPF_ALU64_REG(BPF_MUL, R0, R8),
4320 BPF_ALU64_REG(BPF_MUL, R0, R9),
4321 BPF_ALU64_IMM(BPF_MUL, R0, 10),
4322 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
4323 BPF_EXIT_INSN(),
4324 BPF_ALU64_REG(BPF_MUL, R1, R0),
4325 BPF_ALU64_REG(BPF_MUL, R1, R2),
4326 BPF_ALU64_REG(BPF_MUL, R1, R3),
4327 BPF_ALU64_REG(BPF_MUL, R1, R4),
4328 BPF_ALU64_REG(BPF_MUL, R1, R5),
4329 BPF_ALU64_REG(BPF_MUL, R1, R6),
4330 BPF_ALU64_REG(BPF_MUL, R1, R7),
4331 BPF_ALU64_REG(BPF_MUL, R1, R8),
4332 BPF_ALU64_REG(BPF_MUL, R1, R9),
4333 BPF_ALU64_IMM(BPF_MUL, R1, 10),
4334 BPF_ALU64_REG(BPF_MOV, R2, R1),
4335 BPF_ALU64_IMM(BPF_RSH, R2, 32),
4336 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
4337 BPF_EXIT_INSN(),
4338 BPF_ALU64_IMM(BPF_LSH, R1, 32),
4339 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
4340 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
4341 BPF_EXIT_INSN(),
4342 BPF_ALU64_REG(BPF_MUL, R2, R0),
4343 BPF_ALU64_REG(BPF_MUL, R2, R1),
4344 BPF_ALU64_REG(BPF_MUL, R2, R3),
4345 BPF_ALU64_REG(BPF_MUL, R2, R4),
4346 BPF_ALU64_REG(BPF_MUL, R2, R5),
4347 BPF_ALU64_REG(BPF_MUL, R2, R6),
4348 BPF_ALU64_REG(BPF_MUL, R2, R7),
4349 BPF_ALU64_REG(BPF_MUL, R2, R8),
4350 BPF_ALU64_REG(BPF_MUL, R2, R9),
4351 BPF_ALU64_IMM(BPF_MUL, R2, 10),
4352 BPF_ALU64_IMM(BPF_RSH, R2, 32),
4353 BPF_ALU64_REG(BPF_MOV, R0, R2),
4354 BPF_EXIT_INSN(),
4355 },
4356 INTERNAL,
4357 { },
4358 { { 0, 0x35d97ef2 } }
4359 },
4360 { /* Mainly checking JIT here. */
4361 "MOV REG64",
4362 .u.insns_int = {
4363 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4364 BPF_MOV64_REG(R1, R0),
4365 BPF_MOV64_REG(R2, R1),
4366 BPF_MOV64_REG(R3, R2),
4367 BPF_MOV64_REG(R4, R3),
4368 BPF_MOV64_REG(R5, R4),
4369 BPF_MOV64_REG(R6, R5),
4370 BPF_MOV64_REG(R7, R6),
4371 BPF_MOV64_REG(R8, R7),
4372 BPF_MOV64_REG(R9, R8),
4373 BPF_ALU64_IMM(BPF_MOV, R0, 0),
4374 BPF_ALU64_IMM(BPF_MOV, R1, 0),
4375 BPF_ALU64_IMM(BPF_MOV, R2, 0),
4376 BPF_ALU64_IMM(BPF_MOV, R3, 0),
4377 BPF_ALU64_IMM(BPF_MOV, R4, 0),
4378 BPF_ALU64_IMM(BPF_MOV, R5, 0),
4379 BPF_ALU64_IMM(BPF_MOV, R6, 0),
4380 BPF_ALU64_IMM(BPF_MOV, R7, 0),
4381 BPF_ALU64_IMM(BPF_MOV, R8, 0),
4382 BPF_ALU64_IMM(BPF_MOV, R9, 0),
4383 BPF_ALU64_REG(BPF_ADD, R0, R0),
4384 BPF_ALU64_REG(BPF_ADD, R0, R1),
4385 BPF_ALU64_REG(BPF_ADD, R0, R2),
4386 BPF_ALU64_REG(BPF_ADD, R0, R3),
4387 BPF_ALU64_REG(BPF_ADD, R0, R4),
4388 BPF_ALU64_REG(BPF_ADD, R0, R5),
4389 BPF_ALU64_REG(BPF_ADD, R0, R6),
4390 BPF_ALU64_REG(BPF_ADD, R0, R7),
4391 BPF_ALU64_REG(BPF_ADD, R0, R8),
4392 BPF_ALU64_REG(BPF_ADD, R0, R9),
4393 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4394 BPF_EXIT_INSN(),
4395 },
4396 INTERNAL,
4397 { },
4398 { { 0, 0xfefe } }
4399 },
4400 { /* Mainly checking JIT here. */
4401 "MOV REG32",
4402 .u.insns_int = {
4403 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4404 BPF_MOV64_REG(R1, R0),
4405 BPF_MOV64_REG(R2, R1),
4406 BPF_MOV64_REG(R3, R2),
4407 BPF_MOV64_REG(R4, R3),
4408 BPF_MOV64_REG(R5, R4),
4409 BPF_MOV64_REG(R6, R5),
4410 BPF_MOV64_REG(R7, R6),
4411 BPF_MOV64_REG(R8, R7),
4412 BPF_MOV64_REG(R9, R8),
4413 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4414 BPF_ALU32_IMM(BPF_MOV, R1, 0),
4415 BPF_ALU32_IMM(BPF_MOV, R2, 0),
4416 BPF_ALU32_IMM(BPF_MOV, R3, 0),
4417 BPF_ALU32_IMM(BPF_MOV, R4, 0),
4418 BPF_ALU32_IMM(BPF_MOV, R5, 0),
4419 BPF_ALU32_IMM(BPF_MOV, R6, 0),
4420 BPF_ALU32_IMM(BPF_MOV, R7, 0),
4421 BPF_ALU32_IMM(BPF_MOV, R8, 0),
4422 BPF_ALU32_IMM(BPF_MOV, R9, 0),
4423 BPF_ALU64_REG(BPF_ADD, R0, R0),
4424 BPF_ALU64_REG(BPF_ADD, R0, R1),
4425 BPF_ALU64_REG(BPF_ADD, R0, R2),
4426 BPF_ALU64_REG(BPF_ADD, R0, R3),
4427 BPF_ALU64_REG(BPF_ADD, R0, R4),
4428 BPF_ALU64_REG(BPF_ADD, R0, R5),
4429 BPF_ALU64_REG(BPF_ADD, R0, R6),
4430 BPF_ALU64_REG(BPF_ADD, R0, R7),
4431 BPF_ALU64_REG(BPF_ADD, R0, R8),
4432 BPF_ALU64_REG(BPF_ADD, R0, R9),
4433 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4434 BPF_EXIT_INSN(),
4435 },
4436 INTERNAL,
4437 { },
4438 { { 0, 0xfefe } }
4439 },
4440 { /* Mainly checking JIT here. */
4441 "LD IMM64",
4442 .u.insns_int = {
4443 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
4444 BPF_MOV64_REG(R1, R0),
4445 BPF_MOV64_REG(R2, R1),
4446 BPF_MOV64_REG(R3, R2),
4447 BPF_MOV64_REG(R4, R3),
4448 BPF_MOV64_REG(R5, R4),
4449 BPF_MOV64_REG(R6, R5),
4450 BPF_MOV64_REG(R7, R6),
4451 BPF_MOV64_REG(R8, R7),
4452 BPF_MOV64_REG(R9, R8),
4453 BPF_LD_IMM64(R0, 0x0LL),
4454 BPF_LD_IMM64(R1, 0x0LL),
4455 BPF_LD_IMM64(R2, 0x0LL),
4456 BPF_LD_IMM64(R3, 0x0LL),
4457 BPF_LD_IMM64(R4, 0x0LL),
4458 BPF_LD_IMM64(R5, 0x0LL),
4459 BPF_LD_IMM64(R6, 0x0LL),
4460 BPF_LD_IMM64(R7, 0x0LL),
4461 BPF_LD_IMM64(R8, 0x0LL),
4462 BPF_LD_IMM64(R9, 0x0LL),
4463 BPF_ALU64_REG(BPF_ADD, R0, R0),
4464 BPF_ALU64_REG(BPF_ADD, R0, R1),
4465 BPF_ALU64_REG(BPF_ADD, R0, R2),
4466 BPF_ALU64_REG(BPF_ADD, R0, R3),
4467 BPF_ALU64_REG(BPF_ADD, R0, R4),
4468 BPF_ALU64_REG(BPF_ADD, R0, R5),
4469 BPF_ALU64_REG(BPF_ADD, R0, R6),
4470 BPF_ALU64_REG(BPF_ADD, R0, R7),
4471 BPF_ALU64_REG(BPF_ADD, R0, R8),
4472 BPF_ALU64_REG(BPF_ADD, R0, R9),
4473 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
4474 BPF_EXIT_INSN(),
4475 },
4476 INTERNAL,
4477 { },
4478 { { 0, 0xfefe } }
4479 },
4480 {
4481 "INT: ALU MIX",
4482 .u.insns_int = {
4483 BPF_ALU64_IMM(BPF_MOV, R0, 11),
4484 BPF_ALU64_IMM(BPF_ADD, R0, -1),
4485 BPF_ALU64_IMM(BPF_MOV, R2, 2),
4486 BPF_ALU64_IMM(BPF_XOR, R2, 3),
4487 BPF_ALU64_REG(BPF_DIV, R0, R2),
4488 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
4489 BPF_EXIT_INSN(),
4490 BPF_ALU64_IMM(BPF_MOD, R0, 3),
4491 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
4492 BPF_EXIT_INSN(),
4493 BPF_ALU64_IMM(BPF_MOV, R0, -1),
4494 BPF_EXIT_INSN(),
4495 },
4496 INTERNAL,
4497 { },
4498 { { 0, -1 } }
4499 },
4500 {
4501 "INT: shifts by register",
4502 .u.insns_int = {
4503 BPF_MOV64_IMM(R0, -1234),
4504 BPF_MOV64_IMM(R1, 1),
4505 BPF_ALU32_REG(BPF_RSH, R0, R1),
4506 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
4507 BPF_EXIT_INSN(),
4508 BPF_MOV64_IMM(R2, 1),
4509 BPF_ALU64_REG(BPF_LSH, R0, R2),
4510 BPF_MOV32_IMM(R4, -1234),
4511 BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
4512 BPF_EXIT_INSN(),
4513 BPF_ALU64_IMM(BPF_AND, R4, 63),
4514 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
4515 BPF_MOV64_IMM(R3, 47),
4516 BPF_ALU64_REG(BPF_ARSH, R0, R3),
4517 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
4518 BPF_EXIT_INSN(),
4519 BPF_MOV64_IMM(R2, 1),
4520 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
4521 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
4522 BPF_EXIT_INSN(),
4523 BPF_MOV64_IMM(R4, 4),
4524 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
4525 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
4526 BPF_EXIT_INSN(),
4527 BPF_MOV64_IMM(R4, 5),
4528 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
4529 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
4530 BPF_EXIT_INSN(),
4531 BPF_MOV64_IMM(R0, -1),
4532 BPF_EXIT_INSN(),
4533 },
4534 INTERNAL,
4535 { },
4536 { { 0, -1 } }
4537 },
4538 #ifdef CONFIG_32BIT
4539 {
4540 "INT: 32-bit context pointer word order and zero-extension",
4541 .u.insns_int = {
4542 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4543 BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
4544 BPF_ALU64_IMM(BPF_RSH, R1, 32),
4545 BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
4546 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4547 BPF_EXIT_INSN(),
4548 },
4549 INTERNAL,
4550 { },
4551 { { 0, 1 } }
4552 },
4553 #endif
4554 {
4555 "check: missing ret",
4556 .u.insns = {
4557 BPF_STMT(BPF_LD | BPF_IMM, 1),
4558 },
4559 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4560 { },
4561 { },
4562 .fill_helper = NULL,
4563 .expected_errcode = -EINVAL,
4564 },
4565 {
4566 "check: div_k_0",
4567 .u.insns = {
4568 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
4569 BPF_STMT(BPF_RET | BPF_K, 0)
4570 },
4571 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4572 { },
4573 { },
4574 .fill_helper = NULL,
4575 .expected_errcode = -EINVAL,
4576 },
4577 {
4578 "check: unknown insn",
4579 .u.insns = {
4580 /* seccomp insn, rejected in socket filter */
4581 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
4582 BPF_STMT(BPF_RET | BPF_K, 0)
4583 },
4584 CLASSIC | FLAG_EXPECTED_FAIL,
4585 { },
4586 { },
4587 .fill_helper = NULL,
4588 .expected_errcode = -EINVAL,
4589 },
4590 {
4591 "check: out of range spill/fill",
4592 .u.insns = {
4593 BPF_STMT(BPF_STX, 16),
4594 BPF_STMT(BPF_RET | BPF_K, 0)
4595 },
4596 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4597 { },
4598 { },
4599 .fill_helper = NULL,
4600 .expected_errcode = -EINVAL,
4601 },
4602 {
4603 "JUMPS + HOLES",
4604 .u.insns = {
4605 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4606 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
4607 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4608 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4609 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4610 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4611 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4612 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4613 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4614 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4615 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4616 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4617 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4618 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4619 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4620 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
4621 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4622 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
4623 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4624 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4625 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4626 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4627 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4628 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4629 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4630 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4631 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4632 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4633 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4634 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4635 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4636 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4637 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4638 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4639 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
4640 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
4641 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4642 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
4643 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
4644 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4645 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4646 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4647 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4648 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4649 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4650 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4651 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4652 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4653 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4654 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4655 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4656 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4657 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
4658 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
4659 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
4660 BPF_STMT(BPF_RET | BPF_A, 0),
4661 BPF_STMT(BPF_RET | BPF_A, 0),
4662 },
4663 CLASSIC,
4664 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
4665 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
4666 0x08, 0x00,
4667 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
4668 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
4669 0xc0, 0xa8, 0x33, 0x01,
4670 0xc0, 0xa8, 0x33, 0x02,
4671 0xbb, 0xb6,
4672 0xa9, 0xfa,
4673 0x00, 0x14, 0x00, 0x00,
4674 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4675 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4676 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4677 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4678 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4679 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4680 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
4681 0xcc, 0xcc, 0xcc, 0xcc },
4682 { { 88, 0x001b } }
4683 },
4684 {
4685 "check: RET X",
4686 .u.insns = {
4687 BPF_STMT(BPF_RET | BPF_X, 0),
4688 },
4689 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4690 { },
4691 { },
4692 .fill_helper = NULL,
4693 .expected_errcode = -EINVAL,
4694 },
4695 {
4696 "check: LDX + RET X",
4697 .u.insns = {
4698 BPF_STMT(BPF_LDX | BPF_IMM, 42),
4699 BPF_STMT(BPF_RET | BPF_X, 0),
4700 },
4701 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4702 { },
4703 { },
4704 .fill_helper = NULL,
4705 .expected_errcode = -EINVAL,
4706 },
4707 { /* Mainly checking JIT here. */
4708 "M[]: alt STX + LDX",
4709 .u.insns = {
4710 BPF_STMT(BPF_LDX | BPF_IMM, 100),
4711 BPF_STMT(BPF_STX, 0),
4712 BPF_STMT(BPF_LDX | BPF_MEM, 0),
4713 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4714 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4715 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4716 BPF_STMT(BPF_STX, 1),
4717 BPF_STMT(BPF_LDX | BPF_MEM, 1),
4718 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4719 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4720 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4721 BPF_STMT(BPF_STX, 2),
4722 BPF_STMT(BPF_LDX | BPF_MEM, 2),
4723 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4724 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4725 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4726 BPF_STMT(BPF_STX, 3),
4727 BPF_STMT(BPF_LDX | BPF_MEM, 3),
4728 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4729 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4730 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4731 BPF_STMT(BPF_STX, 4),
4732 BPF_STMT(BPF_LDX | BPF_MEM, 4),
4733 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4734 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4735 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4736 BPF_STMT(BPF_STX, 5),
4737 BPF_STMT(BPF_LDX | BPF_MEM, 5),
4738 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4739 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4740 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4741 BPF_STMT(BPF_STX, 6),
4742 BPF_STMT(BPF_LDX | BPF_MEM, 6),
4743 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4744 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4745 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4746 BPF_STMT(BPF_STX, 7),
4747 BPF_STMT(BPF_LDX | BPF_MEM, 7),
4748 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4749 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4750 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4751 BPF_STMT(BPF_STX, 8),
4752 BPF_STMT(BPF_LDX | BPF_MEM, 8),
4753 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4754 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4755 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4756 BPF_STMT(BPF_STX, 9),
4757 BPF_STMT(BPF_LDX | BPF_MEM, 9),
4758 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4759 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4760 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4761 BPF_STMT(BPF_STX, 10),
4762 BPF_STMT(BPF_LDX | BPF_MEM, 10),
4763 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4764 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4765 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4766 BPF_STMT(BPF_STX, 11),
4767 BPF_STMT(BPF_LDX | BPF_MEM, 11),
4768 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4769 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4770 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4771 BPF_STMT(BPF_STX, 12),
4772 BPF_STMT(BPF_LDX | BPF_MEM, 12),
4773 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4774 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4775 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4776 BPF_STMT(BPF_STX, 13),
4777 BPF_STMT(BPF_LDX | BPF_MEM, 13),
4778 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4779 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4780 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4781 BPF_STMT(BPF_STX, 14),
4782 BPF_STMT(BPF_LDX | BPF_MEM, 14),
4783 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4784 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4785 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4786 BPF_STMT(BPF_STX, 15),
4787 BPF_STMT(BPF_LDX | BPF_MEM, 15),
4788 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4789 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4790 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4791 BPF_STMT(BPF_RET | BPF_A, 0),
4792 },
4793 CLASSIC | FLAG_NO_DATA,
4794 { },
4795 { { 0, 116 } },
4796 },
4797 { /* Mainly checking JIT here. */
4798 "M[]: full STX + full LDX",
4799 .u.insns = {
4800 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4801 BPF_STMT(BPF_STX, 0),
4802 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4803 BPF_STMT(BPF_STX, 1),
4804 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4805 BPF_STMT(BPF_STX, 2),
4806 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4807 BPF_STMT(BPF_STX, 3),
4808 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4809 BPF_STMT(BPF_STX, 4),
4810 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4811 BPF_STMT(BPF_STX, 5),
4812 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4813 BPF_STMT(BPF_STX, 6),
4814 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4815 BPF_STMT(BPF_STX, 7),
4816 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4817 BPF_STMT(BPF_STX, 8),
4818 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4819 BPF_STMT(BPF_STX, 9),
4820 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4821 BPF_STMT(BPF_STX, 10),
4822 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4823 BPF_STMT(BPF_STX, 11),
4824 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4825 BPF_STMT(BPF_STX, 12),
4826 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4827 BPF_STMT(BPF_STX, 13),
4828 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4829 BPF_STMT(BPF_STX, 14),
4830 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4831 BPF_STMT(BPF_STX, 15),
4832 BPF_STMT(BPF_LDX | BPF_MEM, 0),
4833 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4834 BPF_STMT(BPF_LDX | BPF_MEM, 1),
4835 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4836 BPF_STMT(BPF_LDX | BPF_MEM, 2),
4837 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4838 BPF_STMT(BPF_LDX | BPF_MEM, 3),
4839 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4840 BPF_STMT(BPF_LDX | BPF_MEM, 4),
4841 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4842 BPF_STMT(BPF_LDX | BPF_MEM, 5),
4843 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4844 BPF_STMT(BPF_LDX | BPF_MEM, 6),
4845 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4846 BPF_STMT(BPF_LDX | BPF_MEM, 7),
4847 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4848 BPF_STMT(BPF_LDX | BPF_MEM, 8),
4849 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4850 BPF_STMT(BPF_LDX | BPF_MEM, 9),
4851 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4852 BPF_STMT(BPF_LDX | BPF_MEM, 10),
4853 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4854 BPF_STMT(BPF_LDX | BPF_MEM, 11),
4855 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4856 BPF_STMT(BPF_LDX | BPF_MEM, 12),
4857 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4858 BPF_STMT(BPF_LDX | BPF_MEM, 13),
4859 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4860 BPF_STMT(BPF_LDX | BPF_MEM, 14),
4861 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4862 BPF_STMT(BPF_LDX | BPF_MEM, 15),
4863 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4864 BPF_STMT(BPF_RET | BPF_A, 0),
4865 },
4866 CLASSIC | FLAG_NO_DATA,
4867 { },
4868 { { 0, 0x2a5a5e5 } },
4869 },
4870 {
4871 "check: SKF_AD_MAX",
4872 .u.insns = {
4873 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4874 SKF_AD_OFF + SKF_AD_MAX),
4875 BPF_STMT(BPF_RET | BPF_A, 0),
4876 },
4877 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4878 { },
4879 { },
4880 .fill_helper = NULL,
4881 .expected_errcode = -EINVAL,
4882 },
4883 { /* Passes checker but fails during runtime. */
4884 "LD [SKF_AD_OFF-1]",
4885 .u.insns = {
4886 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4887 SKF_AD_OFF - 1),
4888 BPF_STMT(BPF_RET | BPF_K, 1),
4889 },
4890 CLASSIC,
4891 { },
4892 { { 1, 0 } },
4893 },
4894 {
4895 "load 64-bit immediate",
4896 .u.insns_int = {
4897 BPF_LD_IMM64(R1, 0x567800001234LL),
4898 BPF_MOV64_REG(R2, R1),
4899 BPF_MOV64_REG(R3, R2),
4900 BPF_ALU64_IMM(BPF_RSH, R2, 32),
4901 BPF_ALU64_IMM(BPF_LSH, R3, 32),
4902 BPF_ALU64_IMM(BPF_RSH, R3, 32),
4903 BPF_ALU64_IMM(BPF_MOV, R0, 0),
4904 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
4905 BPF_EXIT_INSN(),
4906 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
4907 BPF_EXIT_INSN(),
4908 BPF_LD_IMM64(R0, 0x1ffffffffLL),
4909 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
4910 BPF_EXIT_INSN(),
4911 },
4912 INTERNAL,
4913 { },
4914 { { 0, 1 } }
4915 },
4916 /* BPF_ALU | BPF_MOV | BPF_X */
4917 {
4918 "ALU_MOV_X: dst = 2",
4919 .u.insns_int = {
4920 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4921 BPF_ALU32_REG(BPF_MOV, R0, R1),
4922 BPF_EXIT_INSN(),
4923 },
4924 INTERNAL,
4925 { },
4926 { { 0, 2 } },
4927 },
4928 {
4929 "ALU_MOV_X: dst = 4294967295",
4930 .u.insns_int = {
4931 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4932 BPF_ALU32_REG(BPF_MOV, R0, R1),
4933 BPF_EXIT_INSN(),
4934 },
4935 INTERNAL,
4936 { },
4937 { { 0, 4294967295U } },
4938 },
4939 {
4940 "ALU64_MOV_X: dst = 2",
4941 .u.insns_int = {
4942 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4943 BPF_ALU64_REG(BPF_MOV, R0, R1),
4944 BPF_EXIT_INSN(),
4945 },
4946 INTERNAL,
4947 { },
4948 { { 0, 2 } },
4949 },
4950 {
4951 "ALU64_MOV_X: dst = 4294967295",
4952 .u.insns_int = {
4953 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
4954 BPF_ALU64_REG(BPF_MOV, R0, R1),
4955 BPF_EXIT_INSN(),
4956 },
4957 INTERNAL,
4958 { },
4959 { { 0, 4294967295U } },
4960 },
4961 /* BPF_ALU | BPF_MOV | BPF_K */
4962 {
4963 "ALU_MOV_K: dst = 2",
4964 .u.insns_int = {
4965 BPF_ALU32_IMM(BPF_MOV, R0, 2),
4966 BPF_EXIT_INSN(),
4967 },
4968 INTERNAL,
4969 { },
4970 { { 0, 2 } },
4971 },
4972 {
4973 "ALU_MOV_K: dst = 4294967295",
4974 .u.insns_int = {
4975 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
4976 BPF_EXIT_INSN(),
4977 },
4978 INTERNAL,
4979 { },
4980 { { 0, 4294967295U } },
4981 },
4982 {
4983 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4984 .u.insns_int = {
4985 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4986 BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
4987 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4988 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4989 BPF_MOV32_IMM(R0, 2),
4990 BPF_EXIT_INSN(),
4991 BPF_MOV32_IMM(R0, 1),
4992 BPF_EXIT_INSN(),
4993 },
4994 INTERNAL,
4995 { },
4996 { { 0, 0x1 } },
4997 },
4998 {
4999 "ALU_MOV_K: small negative",
5000 .u.insns_int = {
5001 BPF_ALU32_IMM(BPF_MOV, R0, -123),
5002 BPF_EXIT_INSN(),
5003 },
5004 INTERNAL,
5005 { },
5006 { { 0, -123 } }
5007 },
5008 {
5009 "ALU_MOV_K: small negative zero extension",
5010 .u.insns_int = {
5011 BPF_ALU32_IMM(BPF_MOV, R0, -123),
5012 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5013 BPF_EXIT_INSN(),
5014 },
5015 INTERNAL,
5016 { },
5017 { { 0, 0 } }
5018 },
5019 {
5020 "ALU_MOV_K: large negative",
5021 .u.insns_int = {
5022 BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5023 BPF_EXIT_INSN(),
5024 },
5025 INTERNAL,
5026 { },
5027 { { 0, -123456789 } }
5028 },
5029 {
5030 "ALU_MOV_K: large negative zero extension",
5031 .u.insns_int = {
5032 BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
5033 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5034 BPF_EXIT_INSN(),
5035 },
5036 INTERNAL,
5037 { },
5038 { { 0, 0 } }
5039 },
5040 {
5041 "ALU64_MOV_K: dst = 2",
5042 .u.insns_int = {
5043 BPF_ALU64_IMM(BPF_MOV, R0, 2),
5044 BPF_EXIT_INSN(),
5045 },
5046 INTERNAL,
5047 { },
5048 { { 0, 2 } },
5049 },
5050 {
5051 "ALU64_MOV_K: dst = 2147483647",
5052 .u.insns_int = {
5053 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
5054 BPF_EXIT_INSN(),
5055 },
5056 INTERNAL,
5057 { },
5058 { { 0, 2147483647 } },
5059 },
5060 {
5061 "ALU64_OR_K: dst = 0x0",
5062 .u.insns_int = {
5063 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5064 BPF_LD_IMM64(R3, 0x0),
5065 BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
5066 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5067 BPF_MOV32_IMM(R0, 2),
5068 BPF_EXIT_INSN(),
5069 BPF_MOV32_IMM(R0, 1),
5070 BPF_EXIT_INSN(),
5071 },
5072 INTERNAL,
5073 { },
5074 { { 0, 0x1 } },
5075 },
5076 {
5077 "ALU64_MOV_K: dst = -1",
5078 .u.insns_int = {
5079 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5080 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5081 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
5082 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5083 BPF_MOV32_IMM(R0, 2),
5084 BPF_EXIT_INSN(),
5085 BPF_MOV32_IMM(R0, 1),
5086 BPF_EXIT_INSN(),
5087 },
5088 INTERNAL,
5089 { },
5090 { { 0, 0x1 } },
5091 },
5092 {
5093 "ALU64_MOV_K: small negative",
5094 .u.insns_int = {
5095 BPF_ALU64_IMM(BPF_MOV, R0, -123),
5096 BPF_EXIT_INSN(),
5097 },
5098 INTERNAL,
5099 { },
5100 { { 0, -123 } }
5101 },
5102 {
5103 "ALU64_MOV_K: small negative sign extension",
5104 .u.insns_int = {
5105 BPF_ALU64_IMM(BPF_MOV, R0, -123),
5106 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5107 BPF_EXIT_INSN(),
5108 },
5109 INTERNAL,
5110 { },
5111 { { 0, 0xffffffff } }
5112 },
5113 {
5114 "ALU64_MOV_K: large negative",
5115 .u.insns_int = {
5116 BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5117 BPF_EXIT_INSN(),
5118 },
5119 INTERNAL,
5120 { },
5121 { { 0, -123456789 } }
5122 },
5123 {
5124 "ALU64_MOV_K: large negative sign extension",
5125 .u.insns_int = {
5126 BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
5127 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5128 BPF_EXIT_INSN(),
5129 },
5130 INTERNAL,
5131 { },
5132 { { 0, 0xffffffff } }
5133 },
5134 /* MOVSX32 */
5135 {
5136 "ALU_MOVSX | BPF_B",
5137 .u.insns_int = {
5138 BPF_LD_IMM64(R2, 0x00000000ffffffefLL),
5139 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5140 BPF_MOVSX32_REG(R1, R3, 8),
5141 BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5142 BPF_MOV32_IMM(R0, 2),
5143 BPF_EXIT_INSN(),
5144 BPF_MOV32_IMM(R0, 1),
5145 BPF_EXIT_INSN(),
5146 },
5147 INTERNAL,
5148 { },
5149 { { 0, 0x1 } },
5150 },
5151 {
5152 "ALU_MOVSX | BPF_H",
5153 .u.insns_int = {
5154 BPF_LD_IMM64(R2, 0x00000000ffffbeefLL),
5155 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5156 BPF_MOVSX32_REG(R1, R3, 16),
5157 BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5158 BPF_MOV32_IMM(R0, 2),
5159 BPF_EXIT_INSN(),
5160 BPF_MOV32_IMM(R0, 1),
5161 BPF_EXIT_INSN(),
5162 },
5163 INTERNAL,
5164 { },
5165 { { 0, 0x1 } },
5166 },
5167 /* MOVSX64 REG */
5168 {
5169 "ALU64_MOVSX | BPF_B",
5170 .u.insns_int = {
5171 BPF_LD_IMM64(R2, 0xffffffffffffffefLL),
5172 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5173 BPF_MOVSX64_REG(R1, R3, 8),
5174 BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5175 BPF_MOV32_IMM(R0, 2),
5176 BPF_EXIT_INSN(),
5177 BPF_MOV32_IMM(R0, 1),
5178 BPF_EXIT_INSN(),
5179 },
5180 INTERNAL,
5181 { },
5182 { { 0, 0x1 } },
5183 },
5184 {
5185 "ALU64_MOVSX | BPF_H",
5186 .u.insns_int = {
5187 BPF_LD_IMM64(R2, 0xffffffffffffbeefLL),
5188 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5189 BPF_MOVSX64_REG(R1, R3, 16),
5190 BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5191 BPF_MOV32_IMM(R0, 2),
5192 BPF_EXIT_INSN(),
5193 BPF_MOV32_IMM(R0, 1),
5194 BPF_EXIT_INSN(),
5195 },
5196 INTERNAL,
5197 { },
5198 { { 0, 0x1 } },
5199 },
5200 {
5201 "ALU64_MOVSX | BPF_W",
5202 .u.insns_int = {
5203 BPF_LD_IMM64(R2, 0xffffffffdeadbeefLL),
5204 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
5205 BPF_MOVSX64_REG(R1, R3, 32),
5206 BPF_JMP_REG(BPF_JEQ, R2, R1, 2),
5207 BPF_MOV32_IMM(R0, 2),
5208 BPF_EXIT_INSN(),
5209 BPF_MOV32_IMM(R0, 1),
5210 BPF_EXIT_INSN(),
5211 },
5212 INTERNAL,
5213 { },
5214 { { 0, 0x1 } },
5215 },
5216 /* BPF_ALU | BPF_ADD | BPF_X */
5217 {
5218 "ALU_ADD_X: 1 + 2 = 3",
5219 .u.insns_int = {
5220 BPF_LD_IMM64(R0, 1),
5221 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5222 BPF_ALU32_REG(BPF_ADD, R0, R1),
5223 BPF_EXIT_INSN(),
5224 },
5225 INTERNAL,
5226 { },
5227 { { 0, 3 } },
5228 },
5229 {
5230 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
5231 .u.insns_int = {
5232 BPF_LD_IMM64(R0, 1),
5233 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5234 BPF_ALU32_REG(BPF_ADD, R0, R1),
5235 BPF_EXIT_INSN(),
5236 },
5237 INTERNAL,
5238 { },
5239 { { 0, 4294967295U } },
5240 },
5241 {
5242 "ALU_ADD_X: 2 + 4294967294 = 0",
5243 .u.insns_int = {
5244 BPF_LD_IMM64(R0, 2),
5245 BPF_LD_IMM64(R1, 4294967294U),
5246 BPF_ALU32_REG(BPF_ADD, R0, R1),
5247 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5248 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5249 BPF_EXIT_INSN(),
5250 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5251 BPF_EXIT_INSN(),
5252 },
5253 INTERNAL,
5254 { },
5255 { { 0, 1 } },
5256 },
5257 {
5258 "ALU64_ADD_X: 1 + 2 = 3",
5259 .u.insns_int = {
5260 BPF_LD_IMM64(R0, 1),
5261 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5262 BPF_ALU64_REG(BPF_ADD, R0, R1),
5263 BPF_EXIT_INSN(),
5264 },
5265 INTERNAL,
5266 { },
5267 { { 0, 3 } },
5268 },
5269 {
5270 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
5271 .u.insns_int = {
5272 BPF_LD_IMM64(R0, 1),
5273 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5274 BPF_ALU64_REG(BPF_ADD, R0, R1),
5275 BPF_EXIT_INSN(),
5276 },
5277 INTERNAL,
5278 { },
5279 { { 0, 4294967295U } },
5280 },
5281 {
5282 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
5283 .u.insns_int = {
5284 BPF_LD_IMM64(R0, 2),
5285 BPF_LD_IMM64(R1, 4294967294U),
5286 BPF_LD_IMM64(R2, 4294967296ULL),
5287 BPF_ALU64_REG(BPF_ADD, R0, R1),
5288 BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
5289 BPF_MOV32_IMM(R0, 0),
5290 BPF_EXIT_INSN(),
5291 BPF_MOV32_IMM(R0, 1),
5292 BPF_EXIT_INSN(),
5293 },
5294 INTERNAL,
5295 { },
5296 { { 0, 1 } },
5297 },
5298 /* BPF_ALU | BPF_ADD | BPF_K */
5299 {
5300 "ALU_ADD_K: 1 + 2 = 3",
5301 .u.insns_int = {
5302 BPF_LD_IMM64(R0, 1),
5303 BPF_ALU32_IMM(BPF_ADD, R0, 2),
5304 BPF_EXIT_INSN(),
5305 },
5306 INTERNAL,
5307 { },
5308 { { 0, 3 } },
5309 },
5310 {
5311 "ALU_ADD_K: 3 + 0 = 3",
5312 .u.insns_int = {
5313 BPF_LD_IMM64(R0, 3),
5314 BPF_ALU32_IMM(BPF_ADD, R0, 0),
5315 BPF_EXIT_INSN(),
5316 },
5317 INTERNAL,
5318 { },
5319 { { 0, 3 } },
5320 },
5321 {
5322 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
5323 .u.insns_int = {
5324 BPF_LD_IMM64(R0, 1),
5325 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
5326 BPF_EXIT_INSN(),
5327 },
5328 INTERNAL,
5329 { },
5330 { { 0, 4294967295U } },
5331 },
5332 {
5333 "ALU_ADD_K: 4294967294 + 2 = 0",
5334 .u.insns_int = {
5335 BPF_LD_IMM64(R0, 4294967294U),
5336 BPF_ALU32_IMM(BPF_ADD, R0, 2),
5337 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
5338 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5339 BPF_EXIT_INSN(),
5340 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5341 BPF_EXIT_INSN(),
5342 },
5343 INTERNAL,
5344 { },
5345 { { 0, 1 } },
5346 },
5347 {
5348 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
5349 .u.insns_int = {
5350 BPF_LD_IMM64(R2, 0x0),
5351 BPF_LD_IMM64(R3, 0x00000000ffffffff),
5352 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
5353 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5354 BPF_MOV32_IMM(R0, 2),
5355 BPF_EXIT_INSN(),
5356 BPF_MOV32_IMM(R0, 1),
5357 BPF_EXIT_INSN(),
5358 },
5359 INTERNAL,
5360 { },
5361 { { 0, 0x1 } },
5362 },
5363 {
5364 "ALU_ADD_K: 0 + 0xffff = 0xffff",
5365 .u.insns_int = {
5366 BPF_LD_IMM64(R2, 0x0),
5367 BPF_LD_IMM64(R3, 0xffff),
5368 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
5369 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5370 BPF_MOV32_IMM(R0, 2),
5371 BPF_EXIT_INSN(),
5372 BPF_MOV32_IMM(R0, 1),
5373 BPF_EXIT_INSN(),
5374 },
5375 INTERNAL,
5376 { },
5377 { { 0, 0x1 } },
5378 },
5379 {
5380 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5381 .u.insns_int = {
5382 BPF_LD_IMM64(R2, 0x0),
5383 BPF_LD_IMM64(R3, 0x7fffffff),
5384 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
5385 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5386 BPF_MOV32_IMM(R0, 2),
5387 BPF_EXIT_INSN(),
5388 BPF_MOV32_IMM(R0, 1),
5389 BPF_EXIT_INSN(),
5390 },
5391 INTERNAL,
5392 { },
5393 { { 0, 0x1 } },
5394 },
5395 {
5396 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
5397 .u.insns_int = {
5398 BPF_LD_IMM64(R2, 0x0),
5399 BPF_LD_IMM64(R3, 0x80000000),
5400 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
5401 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5402 BPF_MOV32_IMM(R0, 2),
5403 BPF_EXIT_INSN(),
5404 BPF_MOV32_IMM(R0, 1),
5405 BPF_EXIT_INSN(),
5406 },
5407 INTERNAL,
5408 { },
5409 { { 0, 0x1 } },
5410 },
5411 {
5412 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
5413 .u.insns_int = {
5414 BPF_LD_IMM64(R2, 0x0),
5415 BPF_LD_IMM64(R3, 0x80008000),
5416 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
5417 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5418 BPF_MOV32_IMM(R0, 2),
5419 BPF_EXIT_INSN(),
5420 BPF_MOV32_IMM(R0, 1),
5421 BPF_EXIT_INSN(),
5422 },
5423 INTERNAL,
5424 { },
5425 { { 0, 0x1 } },
5426 },
5427 {
5428 "ALU64_ADD_K: 1 + 2 = 3",
5429 .u.insns_int = {
5430 BPF_LD_IMM64(R0, 1),
5431 BPF_ALU64_IMM(BPF_ADD, R0, 2),
5432 BPF_EXIT_INSN(),
5433 },
5434 INTERNAL,
5435 { },
5436 { { 0, 3 } },
5437 },
5438 {
5439 "ALU64_ADD_K: 3 + 0 = 3",
5440 .u.insns_int = {
5441 BPF_LD_IMM64(R0, 3),
5442 BPF_ALU64_IMM(BPF_ADD, R0, 0),
5443 BPF_EXIT_INSN(),
5444 },
5445 INTERNAL,
5446 { },
5447 { { 0, 3 } },
5448 },
5449 {
5450 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
5451 .u.insns_int = {
5452 BPF_LD_IMM64(R0, 1),
5453 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
5454 BPF_EXIT_INSN(),
5455 },
5456 INTERNAL,
5457 { },
5458 { { 0, 2147483647 } },
5459 },
5460 {
5461 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
5462 .u.insns_int = {
5463 BPF_LD_IMM64(R0, 4294967294U),
5464 BPF_LD_IMM64(R1, 4294967296ULL),
5465 BPF_ALU64_IMM(BPF_ADD, R0, 2),
5466 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5467 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5468 BPF_EXIT_INSN(),
5469 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5470 BPF_EXIT_INSN(),
5471 },
5472 INTERNAL,
5473 { },
5474 { { 0, 1 } },
5475 },
5476 {
5477 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
5478 .u.insns_int = {
5479 BPF_LD_IMM64(R0, 2147483646),
5480 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
5481 BPF_EXIT_INSN(),
5482 },
5483 INTERNAL,
5484 { },
5485 { { 0, -1 } },
5486 },
5487 {
5488 "ALU64_ADD_K: 1 + 0 = 1",
5489 .u.insns_int = {
5490 BPF_LD_IMM64(R2, 0x1),
5491 BPF_LD_IMM64(R3, 0x1),
5492 BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
5493 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5494 BPF_MOV32_IMM(R0, 2),
5495 BPF_EXIT_INSN(),
5496 BPF_MOV32_IMM(R0, 1),
5497 BPF_EXIT_INSN(),
5498 },
5499 INTERNAL,
5500 { },
5501 { { 0, 0x1 } },
5502 },
5503 {
5504 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
5505 .u.insns_int = {
5506 BPF_LD_IMM64(R2, 0x0),
5507 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5508 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
5509 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5510 BPF_MOV32_IMM(R0, 2),
5511 BPF_EXIT_INSN(),
5512 BPF_MOV32_IMM(R0, 1),
5513 BPF_EXIT_INSN(),
5514 },
5515 INTERNAL,
5516 { },
5517 { { 0, 0x1 } },
5518 },
5519 {
5520 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
5521 .u.insns_int = {
5522 BPF_LD_IMM64(R2, 0x0),
5523 BPF_LD_IMM64(R3, 0xffff),
5524 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
5525 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5526 BPF_MOV32_IMM(R0, 2),
5527 BPF_EXIT_INSN(),
5528 BPF_MOV32_IMM(R0, 1),
5529 BPF_EXIT_INSN(),
5530 },
5531 INTERNAL,
5532 { },
5533 { { 0, 0x1 } },
5534 },
5535 {
5536 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
5537 .u.insns_int = {
5538 BPF_LD_IMM64(R2, 0x0),
5539 BPF_LD_IMM64(R3, 0x7fffffff),
5540 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
5541 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5542 BPF_MOV32_IMM(R0, 2),
5543 BPF_EXIT_INSN(),
5544 BPF_MOV32_IMM(R0, 1),
5545 BPF_EXIT_INSN(),
5546 },
5547 INTERNAL,
5548 { },
5549 { { 0, 0x1 } },
5550 },
5551 {
5552 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
5553 .u.insns_int = {
5554 BPF_LD_IMM64(R2, 0x0),
5555 BPF_LD_IMM64(R3, 0xffffffff80000000LL),
5556 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
5557 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5558 BPF_MOV32_IMM(R0, 2),
5559 BPF_EXIT_INSN(),
5560 BPF_MOV32_IMM(R0, 1),
5561 BPF_EXIT_INSN(),
5562 },
5563 INTERNAL,
5564 { },
5565 { { 0, 0x1 } },
5566 },
5567 {
5568 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
5569 .u.insns_int = {
5570 BPF_LD_IMM64(R2, 0x0),
5571 BPF_LD_IMM64(R3, 0xffffffff80008000LL),
5572 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
5573 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5574 BPF_MOV32_IMM(R0, 2),
5575 BPF_EXIT_INSN(),
5576 BPF_MOV32_IMM(R0, 1),
5577 BPF_EXIT_INSN(),
5578 },
5579 INTERNAL,
5580 { },
5581 { { 0, 0x1 } },
5582 },
5583 /* BPF_ALU | BPF_SUB | BPF_X */
5584 {
5585 "ALU_SUB_X: 3 - 1 = 2",
5586 .u.insns_int = {
5587 BPF_LD_IMM64(R0, 3),
5588 BPF_ALU32_IMM(BPF_MOV, R1, 1),
5589 BPF_ALU32_REG(BPF_SUB, R0, R1),
5590 BPF_EXIT_INSN(),
5591 },
5592 INTERNAL,
5593 { },
5594 { { 0, 2 } },
5595 },
5596 {
5597 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
5598 .u.insns_int = {
5599 BPF_LD_IMM64(R0, 4294967295U),
5600 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5601 BPF_ALU32_REG(BPF_SUB, R0, R1),
5602 BPF_EXIT_INSN(),
5603 },
5604 INTERNAL,
5605 { },
5606 { { 0, 1 } },
5607 },
5608 {
5609 "ALU64_SUB_X: 3 - 1 = 2",
5610 .u.insns_int = {
5611 BPF_LD_IMM64(R0, 3),
5612 BPF_ALU32_IMM(BPF_MOV, R1, 1),
5613 BPF_ALU64_REG(BPF_SUB, R0, R1),
5614 BPF_EXIT_INSN(),
5615 },
5616 INTERNAL,
5617 { },
5618 { { 0, 2 } },
5619 },
5620 {
5621 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
5622 .u.insns_int = {
5623 BPF_LD_IMM64(R0, 4294967295U),
5624 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
5625 BPF_ALU64_REG(BPF_SUB, R0, R1),
5626 BPF_EXIT_INSN(),
5627 },
5628 INTERNAL,
5629 { },
5630 { { 0, 1 } },
5631 },
5632 /* BPF_ALU | BPF_SUB | BPF_K */
5633 {
5634 "ALU_SUB_K: 3 - 1 = 2",
5635 .u.insns_int = {
5636 BPF_LD_IMM64(R0, 3),
5637 BPF_ALU32_IMM(BPF_SUB, R0, 1),
5638 BPF_EXIT_INSN(),
5639 },
5640 INTERNAL,
5641 { },
5642 { { 0, 2 } },
5643 },
5644 {
5645 "ALU_SUB_K: 3 - 0 = 3",
5646 .u.insns_int = {
5647 BPF_LD_IMM64(R0, 3),
5648 BPF_ALU32_IMM(BPF_SUB, R0, 0),
5649 BPF_EXIT_INSN(),
5650 },
5651 INTERNAL,
5652 { },
5653 { { 0, 3 } },
5654 },
5655 {
5656 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
5657 .u.insns_int = {
5658 BPF_LD_IMM64(R0, 4294967295U),
5659 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
5660 BPF_EXIT_INSN(),
5661 },
5662 INTERNAL,
5663 { },
5664 { { 0, 1 } },
5665 },
5666 {
5667 "ALU64_SUB_K: 3 - 1 = 2",
5668 .u.insns_int = {
5669 BPF_LD_IMM64(R0, 3),
5670 BPF_ALU64_IMM(BPF_SUB, R0, 1),
5671 BPF_EXIT_INSN(),
5672 },
5673 INTERNAL,
5674 { },
5675 { { 0, 2 } },
5676 },
5677 {
5678 "ALU64_SUB_K: 3 - 0 = 3",
5679 .u.insns_int = {
5680 BPF_LD_IMM64(R0, 3),
5681 BPF_ALU64_IMM(BPF_SUB, R0, 0),
5682 BPF_EXIT_INSN(),
5683 },
5684 INTERNAL,
5685 { },
5686 { { 0, 3 } },
5687 },
5688 {
5689 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
5690 .u.insns_int = {
5691 BPF_LD_IMM64(R0, 4294967294U),
5692 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
5693 BPF_EXIT_INSN(),
5694 },
5695 INTERNAL,
5696 { },
5697 { { 0, -1 } },
5698 },
5699 {
5700 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
5701 .u.insns_int = {
5702 BPF_LD_IMM64(R0, 2147483646),
5703 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
5704 BPF_EXIT_INSN(),
5705 },
5706 INTERNAL,
5707 { },
5708 { { 0, -1 } },
5709 },
5710 /* BPF_ALU | BPF_MUL | BPF_X */
5711 {
5712 "ALU_MUL_X: 2 * 3 = 6",
5713 .u.insns_int = {
5714 BPF_LD_IMM64(R0, 2),
5715 BPF_ALU32_IMM(BPF_MOV, R1, 3),
5716 BPF_ALU32_REG(BPF_MUL, R0, R1),
5717 BPF_EXIT_INSN(),
5718 },
5719 INTERNAL,
5720 { },
5721 { { 0, 6 } },
5722 },
5723 {
5724 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5725 .u.insns_int = {
5726 BPF_LD_IMM64(R0, 2),
5727 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
5728 BPF_ALU32_REG(BPF_MUL, R0, R1),
5729 BPF_EXIT_INSN(),
5730 },
5731 INTERNAL,
5732 { },
5733 { { 0, 0xFFFFFFF0 } },
5734 },
5735 {
5736 "ALU_MUL_X: -1 * -1 = 1",
5737 .u.insns_int = {
5738 BPF_LD_IMM64(R0, -1),
5739 BPF_ALU32_IMM(BPF_MOV, R1, -1),
5740 BPF_ALU32_REG(BPF_MUL, R0, R1),
5741 BPF_EXIT_INSN(),
5742 },
5743 INTERNAL,
5744 { },
5745 { { 0, 1 } },
5746 },
5747 {
5748 "ALU64_MUL_X: 2 * 3 = 6",
5749 .u.insns_int = {
5750 BPF_LD_IMM64(R0, 2),
5751 BPF_ALU32_IMM(BPF_MOV, R1, 3),
5752 BPF_ALU64_REG(BPF_MUL, R0, R1),
5753 BPF_EXIT_INSN(),
5754 },
5755 INTERNAL,
5756 { },
5757 { { 0, 6 } },
5758 },
5759 {
5760 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
5761 .u.insns_int = {
5762 BPF_LD_IMM64(R0, 1),
5763 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5764 BPF_ALU64_REG(BPF_MUL, R0, R1),
5765 BPF_EXIT_INSN(),
5766 },
5767 INTERNAL,
5768 { },
5769 { { 0, 2147483647 } },
5770 },
5771 {
5772 "ALU64_MUL_X: 64x64 multiply, low word",
5773 .u.insns_int = {
5774 BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5775 BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5776 BPF_ALU64_REG(BPF_MUL, R0, R1),
5777 BPF_EXIT_INSN(),
5778 },
5779 INTERNAL,
5780 { },
5781 { { 0, 0xe5618cf0 } }
5782 },
5783 {
5784 "ALU64_MUL_X: 64x64 multiply, high word",
5785 .u.insns_int = {
5786 BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
5787 BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
5788 BPF_ALU64_REG(BPF_MUL, R0, R1),
5789 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5790 BPF_EXIT_INSN(),
5791 },
5792 INTERNAL,
5793 { },
5794 { { 0, 0x2236d88f } }
5795 },
5796 /* BPF_ALU | BPF_MUL | BPF_K */
5797 {
5798 "ALU_MUL_K: 2 * 3 = 6",
5799 .u.insns_int = {
5800 BPF_LD_IMM64(R0, 2),
5801 BPF_ALU32_IMM(BPF_MUL, R0, 3),
5802 BPF_EXIT_INSN(),
5803 },
5804 INTERNAL,
5805 { },
5806 { { 0, 6 } },
5807 },
5808 {
5809 "ALU_MUL_K: 3 * 1 = 3",
5810 .u.insns_int = {
5811 BPF_LD_IMM64(R0, 3),
5812 BPF_ALU32_IMM(BPF_MUL, R0, 1),
5813 BPF_EXIT_INSN(),
5814 },
5815 INTERNAL,
5816 { },
5817 { { 0, 3 } },
5818 },
5819 {
5820 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5821 .u.insns_int = {
5822 BPF_LD_IMM64(R0, 2),
5823 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5824 BPF_EXIT_INSN(),
5825 },
5826 INTERNAL,
5827 { },
5828 { { 0, 0xFFFFFFF0 } },
5829 },
5830 {
5831 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5832 .u.insns_int = {
5833 BPF_LD_IMM64(R2, 0x1),
5834 BPF_LD_IMM64(R3, 0x00000000ffffffff),
5835 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5836 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5837 BPF_MOV32_IMM(R0, 2),
5838 BPF_EXIT_INSN(),
5839 BPF_MOV32_IMM(R0, 1),
5840 BPF_EXIT_INSN(),
5841 },
5842 INTERNAL,
5843 { },
5844 { { 0, 0x1 } },
5845 },
5846 {
5847 "ALU64_MUL_K: 2 * 3 = 6",
5848 .u.insns_int = {
5849 BPF_LD_IMM64(R0, 2),
5850 BPF_ALU64_IMM(BPF_MUL, R0, 3),
5851 BPF_EXIT_INSN(),
5852 },
5853 INTERNAL,
5854 { },
5855 { { 0, 6 } },
5856 },
5857 {
5858 "ALU64_MUL_K: 3 * 1 = 3",
5859 .u.insns_int = {
5860 BPF_LD_IMM64(R0, 3),
5861 BPF_ALU64_IMM(BPF_MUL, R0, 1),
5862 BPF_EXIT_INSN(),
5863 },
5864 INTERNAL,
5865 { },
5866 { { 0, 3 } },
5867 },
5868 {
5869 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
5870 .u.insns_int = {
5871 BPF_LD_IMM64(R0, 1),
5872 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
5873 BPF_EXIT_INSN(),
5874 },
5875 INTERNAL,
5876 { },
5877 { { 0, 2147483647 } },
5878 },
5879 {
5880 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
5881 .u.insns_int = {
5882 BPF_LD_IMM64(R0, 1),
5883 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
5884 BPF_EXIT_INSN(),
5885 },
5886 INTERNAL,
5887 { },
5888 { { 0, -2147483647 } },
5889 },
5890 {
5891 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5892 .u.insns_int = {
5893 BPF_LD_IMM64(R2, 0x1),
5894 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5895 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5896 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5897 BPF_MOV32_IMM(R0, 2),
5898 BPF_EXIT_INSN(),
5899 BPF_MOV32_IMM(R0, 1),
5900 BPF_EXIT_INSN(),
5901 },
5902 INTERNAL,
5903 { },
5904 { { 0, 0x1 } },
5905 },
5906 {
5907 "ALU64_MUL_K: 64x32 multiply, low word",
5908 .u.insns_int = {
5909 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5910 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5911 BPF_EXIT_INSN(),
5912 },
5913 INTERNAL,
5914 { },
5915 { { 0, 0xe242d208 } }
5916 },
5917 {
5918 "ALU64_MUL_K: 64x32 multiply, high word",
5919 .u.insns_int = {
5920 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5921 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5922 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5923 BPF_EXIT_INSN(),
5924 },
5925 INTERNAL,
5926 { },
5927 { { 0, 0xc28f5c28 } }
5928 },
5929 /* BPF_ALU | BPF_DIV | BPF_X */
5930 {
5931 "ALU_DIV_X: 6 / 2 = 3",
5932 .u.insns_int = {
5933 BPF_LD_IMM64(R0, 6),
5934 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5935 BPF_ALU32_REG(BPF_DIV, R0, R1),
5936 BPF_EXIT_INSN(),
5937 },
5938 INTERNAL,
5939 { },
5940 { { 0, 3 } },
5941 },
5942 {
5943 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
5944 .u.insns_int = {
5945 BPF_LD_IMM64(R0, 4294967295U),
5946 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
5947 BPF_ALU32_REG(BPF_DIV, R0, R1),
5948 BPF_EXIT_INSN(),
5949 },
5950 INTERNAL,
5951 { },
5952 { { 0, 1 } },
5953 },
5954 {
5955 "ALU64_DIV_X: 6 / 2 = 3",
5956 .u.insns_int = {
5957 BPF_LD_IMM64(R0, 6),
5958 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5959 BPF_ALU64_REG(BPF_DIV, R0, R1),
5960 BPF_EXIT_INSN(),
5961 },
5962 INTERNAL,
5963 { },
5964 { { 0, 3 } },
5965 },
5966 {
5967 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
5968 .u.insns_int = {
5969 BPF_LD_IMM64(R0, 2147483647),
5970 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5971 BPF_ALU64_REG(BPF_DIV, R0, R1),
5972 BPF_EXIT_INSN(),
5973 },
5974 INTERNAL,
5975 { },
5976 { { 0, 1 } },
5977 },
5978 {
5979 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5980 .u.insns_int = {
5981 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5982 BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
5983 BPF_LD_IMM64(R3, 0x0000000000000001LL),
5984 BPF_ALU64_REG(BPF_DIV, R2, R4),
5985 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5986 BPF_MOV32_IMM(R0, 2),
5987 BPF_EXIT_INSN(),
5988 BPF_MOV32_IMM(R0, 1),
5989 BPF_EXIT_INSN(),
5990 },
5991 INTERNAL,
5992 { },
5993 { { 0, 0x1 } },
5994 },
5995 /* BPF_ALU | BPF_DIV | BPF_K */
5996 {
5997 "ALU_DIV_K: 6 / 2 = 3",
5998 .u.insns_int = {
5999 BPF_LD_IMM64(R0, 6),
6000 BPF_ALU32_IMM(BPF_DIV, R0, 2),
6001 BPF_EXIT_INSN(),
6002 },
6003 INTERNAL,
6004 { },
6005 { { 0, 3 } },
6006 },
6007 {
6008 "ALU_DIV_K: 3 / 1 = 3",
6009 .u.insns_int = {
6010 BPF_LD_IMM64(R0, 3),
6011 BPF_ALU32_IMM(BPF_DIV, R0, 1),
6012 BPF_EXIT_INSN(),
6013 },
6014 INTERNAL,
6015 { },
6016 { { 0, 3 } },
6017 },
6018 {
6019 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
6020 .u.insns_int = {
6021 BPF_LD_IMM64(R0, 4294967295U),
6022 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
6023 BPF_EXIT_INSN(),
6024 },
6025 INTERNAL,
6026 { },
6027 { { 0, 1 } },
6028 },
6029 {
6030 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
6031 .u.insns_int = {
6032 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6033 BPF_LD_IMM64(R3, 0x1UL),
6034 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
6035 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6036 BPF_MOV32_IMM(R0, 2),
6037 BPF_EXIT_INSN(),
6038 BPF_MOV32_IMM(R0, 1),
6039 BPF_EXIT_INSN(),
6040 },
6041 INTERNAL,
6042 { },
6043 { { 0, 0x1 } },
6044 },
6045 {
6046 "ALU64_DIV_K: 6 / 2 = 3",
6047 .u.insns_int = {
6048 BPF_LD_IMM64(R0, 6),
6049 BPF_ALU64_IMM(BPF_DIV, R0, 2),
6050 BPF_EXIT_INSN(),
6051 },
6052 INTERNAL,
6053 { },
6054 { { 0, 3 } },
6055 },
6056 {
6057 "ALU64_DIV_K: 3 / 1 = 3",
6058 .u.insns_int = {
6059 BPF_LD_IMM64(R0, 3),
6060 BPF_ALU64_IMM(BPF_DIV, R0, 1),
6061 BPF_EXIT_INSN(),
6062 },
6063 INTERNAL,
6064 { },
6065 { { 0, 3 } },
6066 },
6067 {
6068 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
6069 .u.insns_int = {
6070 BPF_LD_IMM64(R0, 2147483647),
6071 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
6072 BPF_EXIT_INSN(),
6073 },
6074 INTERNAL,
6075 { },
6076 { { 0, 1 } },
6077 },
6078 {
6079 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
6080 .u.insns_int = {
6081 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6082 BPF_LD_IMM64(R3, 0x0000000000000001LL),
6083 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
6084 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6085 BPF_MOV32_IMM(R0, 2),
6086 BPF_EXIT_INSN(),
6087 BPF_MOV32_IMM(R0, 1),
6088 BPF_EXIT_INSN(),
6089 },
6090 INTERNAL,
6091 { },
6092 { { 0, 0x1 } },
6093 },
6094 /* BPF_ALU | BPF_MOD | BPF_X */
6095 {
6096 "ALU_MOD_X: 3 % 2 = 1",
6097 .u.insns_int = {
6098 BPF_LD_IMM64(R0, 3),
6099 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6100 BPF_ALU32_REG(BPF_MOD, R0, R1),
6101 BPF_EXIT_INSN(),
6102 },
6103 INTERNAL,
6104 { },
6105 { { 0, 1 } },
6106 },
6107 {
6108 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
6109 .u.insns_int = {
6110 BPF_LD_IMM64(R0, 4294967295U),
6111 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
6112 BPF_ALU32_REG(BPF_MOD, R0, R1),
6113 BPF_EXIT_INSN(),
6114 },
6115 INTERNAL,
6116 { },
6117 { { 0, 2 } },
6118 },
6119 {
6120 "ALU64_MOD_X: 3 % 2 = 1",
6121 .u.insns_int = {
6122 BPF_LD_IMM64(R0, 3),
6123 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6124 BPF_ALU64_REG(BPF_MOD, R0, R1),
6125 BPF_EXIT_INSN(),
6126 },
6127 INTERNAL,
6128 { },
6129 { { 0, 1 } },
6130 },
6131 {
6132 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
6133 .u.insns_int = {
6134 BPF_LD_IMM64(R0, 2147483647),
6135 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
6136 BPF_ALU64_REG(BPF_MOD, R0, R1),
6137 BPF_EXIT_INSN(),
6138 },
6139 INTERNAL,
6140 { },
6141 { { 0, 2 } },
6142 },
6143 /* BPF_ALU | BPF_MOD | BPF_K */
6144 {
6145 "ALU_MOD_K: 3 % 2 = 1",
6146 .u.insns_int = {
6147 BPF_LD_IMM64(R0, 3),
6148 BPF_ALU32_IMM(BPF_MOD, R0, 2),
6149 BPF_EXIT_INSN(),
6150 },
6151 INTERNAL,
6152 { },
6153 { { 0, 1 } },
6154 },
6155 {
6156 "ALU_MOD_K: 3 % 1 = 0",
6157 .u.insns_int = {
6158 BPF_LD_IMM64(R0, 3),
6159 BPF_ALU32_IMM(BPF_MOD, R0, 1),
6160 BPF_EXIT_INSN(),
6161 },
6162 INTERNAL,
6163 { },
6164 { { 0, 0 } },
6165 },
6166 {
6167 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
6168 .u.insns_int = {
6169 BPF_LD_IMM64(R0, 4294967295U),
6170 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
6171 BPF_EXIT_INSN(),
6172 },
6173 INTERNAL,
6174 { },
6175 { { 0, 2 } },
6176 },
6177 {
6178 "ALU64_MOD_K: 3 % 2 = 1",
6179 .u.insns_int = {
6180 BPF_LD_IMM64(R0, 3),
6181 BPF_ALU64_IMM(BPF_MOD, R0, 2),
6182 BPF_EXIT_INSN(),
6183 },
6184 INTERNAL,
6185 { },
6186 { { 0, 1 } },
6187 },
6188 {
6189 "ALU64_MOD_K: 3 % 1 = 0",
6190 .u.insns_int = {
6191 BPF_LD_IMM64(R0, 3),
6192 BPF_ALU64_IMM(BPF_MOD, R0, 1),
6193 BPF_EXIT_INSN(),
6194 },
6195 INTERNAL,
6196 { },
6197 { { 0, 0 } },
6198 },
6199 {
6200 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
6201 .u.insns_int = {
6202 BPF_LD_IMM64(R0, 2147483647),
6203 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
6204 BPF_EXIT_INSN(),
6205 },
6206 INTERNAL,
6207 { },
6208 { { 0, 2 } },
6209 },
6210 /* BPF_ALU | BPF_DIV | BPF_X off=1 (SDIV) */
6211 {
6212 "ALU_SDIV_X: -6 / 2 = -3",
6213 .u.insns_int = {
6214 BPF_LD_IMM64(R0, -6),
6215 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6216 BPF_ALU32_REG_OFF(BPF_DIV, R0, R1, 1),
6217 BPF_EXIT_INSN(),
6218 },
6219 INTERNAL,
6220 { },
6221 { { 0, -3 } },
6222 },
6223 /* BPF_ALU | BPF_DIV | BPF_K off=1 (SDIV) */
6224 {
6225 "ALU_SDIV_K: -6 / 2 = -3",
6226 .u.insns_int = {
6227 BPF_LD_IMM64(R0, -6),
6228 BPF_ALU32_IMM_OFF(BPF_DIV, R0, 2, 1),
6229 BPF_EXIT_INSN(),
6230 },
6231 INTERNAL,
6232 { },
6233 { { 0, -3 } },
6234 },
6235 /* BPF_ALU64 | BPF_DIV | BPF_X off=1 (SDIV64) */
6236 {
6237 "ALU64_SDIV_X: -6 / 2 = -3",
6238 .u.insns_int = {
6239 BPF_LD_IMM64(R0, -6),
6240 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6241 BPF_ALU64_REG_OFF(BPF_DIV, R0, R1, 1),
6242 BPF_EXIT_INSN(),
6243 },
6244 INTERNAL,
6245 { },
6246 { { 0, -3 } },
6247 },
6248 /* BPF_ALU64 | BPF_DIV | BPF_K off=1 (SDIV64) */
6249 {
6250 "ALU64_SDIV_K: -6 / 2 = -3",
6251 .u.insns_int = {
6252 BPF_LD_IMM64(R0, -6),
6253 BPF_ALU64_IMM_OFF(BPF_DIV, R0, 2, 1),
6254 BPF_EXIT_INSN(),
6255 },
6256 INTERNAL,
6257 { },
6258 { { 0, -3 } },
6259 },
6260 /* BPF_ALU | BPF_MOD | BPF_X off=1 (SMOD) */
6261 {
6262 "ALU_SMOD_X: -7 % 2 = -1",
6263 .u.insns_int = {
6264 BPF_LD_IMM64(R0, -7),
6265 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6266 BPF_ALU32_REG_OFF(BPF_MOD, R0, R1, 1),
6267 BPF_EXIT_INSN(),
6268 },
6269 INTERNAL,
6270 { },
6271 { { 0, -1 } },
6272 },
6273 /* BPF_ALU | BPF_MOD | BPF_K off=1 (SMOD) */
6274 {
6275 "ALU_SMOD_K: -7 % 2 = -1",
6276 .u.insns_int = {
6277 BPF_LD_IMM64(R0, -7),
6278 BPF_ALU32_IMM_OFF(BPF_MOD, R0, 2, 1),
6279 BPF_EXIT_INSN(),
6280 },
6281 INTERNAL,
6282 { },
6283 { { 0, -1 } },
6284 },
6285 /* BPF_ALU64 | BPF_MOD | BPF_X off=1 (SMOD64) */
6286 {
6287 "ALU64_SMOD_X: -7 % 2 = -1",
6288 .u.insns_int = {
6289 BPF_LD_IMM64(R0, -7),
6290 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6291 BPF_ALU64_REG_OFF(BPF_MOD, R0, R1, 1),
6292 BPF_EXIT_INSN(),
6293 },
6294 INTERNAL,
6295 { },
6296 { { 0, -1 } },
6297 },
6298 /* BPF_ALU64 | BPF_MOD | BPF_K off=1 (SMOD64) */
6299 {
6300 "ALU64_SMOD_K: -7 % 2 = -1",
6301 .u.insns_int = {
6302 BPF_LD_IMM64(R0, -7),
6303 BPF_ALU64_IMM_OFF(BPF_MOD, R0, 2, 1),
6304 BPF_EXIT_INSN(),
6305 },
6306 INTERNAL,
6307 { },
6308 { { 0, -1 } },
6309 },
6310 /* BPF_ALU | BPF_AND | BPF_X */
6311 {
6312 "ALU_AND_X: 3 & 2 = 2",
6313 .u.insns_int = {
6314 BPF_LD_IMM64(R0, 3),
6315 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6316 BPF_ALU32_REG(BPF_AND, R0, R1),
6317 BPF_EXIT_INSN(),
6318 },
6319 INTERNAL,
6320 { },
6321 { { 0, 2 } },
6322 },
6323 {
6324 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6325 .u.insns_int = {
6326 BPF_LD_IMM64(R0, 0xffffffff),
6327 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6328 BPF_ALU32_REG(BPF_AND, R0, R1),
6329 BPF_EXIT_INSN(),
6330 },
6331 INTERNAL,
6332 { },
6333 { { 0, 0xffffffff } },
6334 },
6335 {
6336 "ALU64_AND_X: 3 & 2 = 2",
6337 .u.insns_int = {
6338 BPF_LD_IMM64(R0, 3),
6339 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6340 BPF_ALU64_REG(BPF_AND, R0, R1),
6341 BPF_EXIT_INSN(),
6342 },
6343 INTERNAL,
6344 { },
6345 { { 0, 2 } },
6346 },
6347 {
6348 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
6349 .u.insns_int = {
6350 BPF_LD_IMM64(R0, 0xffffffff),
6351 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6352 BPF_ALU64_REG(BPF_AND, R0, R1),
6353 BPF_EXIT_INSN(),
6354 },
6355 INTERNAL,
6356 { },
6357 { { 0, 0xffffffff } },
6358 },
6359 /* BPF_ALU | BPF_AND | BPF_K */
6360 {
6361 "ALU_AND_K: 3 & 2 = 2",
6362 .u.insns_int = {
6363 BPF_LD_IMM64(R0, 3),
6364 BPF_ALU32_IMM(BPF_AND, R0, 2),
6365 BPF_EXIT_INSN(),
6366 },
6367 INTERNAL,
6368 { },
6369 { { 0, 2 } },
6370 },
6371 {
6372 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6373 .u.insns_int = {
6374 BPF_LD_IMM64(R0, 0xffffffff),
6375 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
6376 BPF_EXIT_INSN(),
6377 },
6378 INTERNAL,
6379 { },
6380 { { 0, 0xffffffff } },
6381 },
6382 {
6383 "ALU_AND_K: Small immediate",
6384 .u.insns_int = {
6385 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6386 BPF_ALU32_IMM(BPF_AND, R0, 15),
6387 BPF_EXIT_INSN(),
6388 },
6389 INTERNAL,
6390 { },
6391 { { 0, 4 } }
6392 },
6393 {
6394 "ALU_AND_K: Large immediate",
6395 .u.insns_int = {
6396 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6397 BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
6398 BPF_EXIT_INSN(),
6399 },
6400 INTERNAL,
6401 { },
6402 { { 0, 0xa1b2c3d4 } }
6403 },
6404 {
6405 "ALU_AND_K: Zero extension",
6406 .u.insns_int = {
6407 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6408 BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
6409 BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
6410 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6411 BPF_MOV32_IMM(R0, 2),
6412 BPF_EXIT_INSN(),
6413 BPF_MOV32_IMM(R0, 1),
6414 BPF_EXIT_INSN(),
6415 },
6416 INTERNAL,
6417 { },
6418 { { 0, 1 } }
6419 },
6420 {
6421 "ALU64_AND_K: 3 & 2 = 2",
6422 .u.insns_int = {
6423 BPF_LD_IMM64(R0, 3),
6424 BPF_ALU64_IMM(BPF_AND, R0, 2),
6425 BPF_EXIT_INSN(),
6426 },
6427 INTERNAL,
6428 { },
6429 { { 0, 2 } },
6430 },
6431 {
6432 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
6433 .u.insns_int = {
6434 BPF_LD_IMM64(R0, 0xffffffff),
6435 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
6436 BPF_EXIT_INSN(),
6437 },
6438 INTERNAL,
6439 { },
6440 { { 0, 0xffffffff } },
6441 },
6442 {
6443 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
6444 .u.insns_int = {
6445 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6446 BPF_LD_IMM64(R3, 0x0000000000000000LL),
6447 BPF_ALU64_IMM(BPF_AND, R2, 0x0),
6448 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6449 BPF_MOV32_IMM(R0, 2),
6450 BPF_EXIT_INSN(),
6451 BPF_MOV32_IMM(R0, 1),
6452 BPF_EXIT_INSN(),
6453 },
6454 INTERNAL,
6455 { },
6456 { { 0, 0x1 } },
6457 },
6458 {
6459 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
6460 .u.insns_int = {
6461 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6462 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6463 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6464 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6465 BPF_MOV32_IMM(R0, 2),
6466 BPF_EXIT_INSN(),
6467 BPF_MOV32_IMM(R0, 1),
6468 BPF_EXIT_INSN(),
6469 },
6470 INTERNAL,
6471 { },
6472 { { 0, 0x1 } },
6473 },
6474 {
6475 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
6476 .u.insns_int = {
6477 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
6478 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6479 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
6480 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6481 BPF_MOV32_IMM(R0, 2),
6482 BPF_EXIT_INSN(),
6483 BPF_MOV32_IMM(R0, 1),
6484 BPF_EXIT_INSN(),
6485 },
6486 INTERNAL,
6487 { },
6488 { { 0, 0x1 } },
6489 },
6490 {
6491 "ALU64_AND_K: Sign extension 1",
6492 .u.insns_int = {
6493 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6494 BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
6495 BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
6496 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6497 BPF_MOV32_IMM(R0, 2),
6498 BPF_EXIT_INSN(),
6499 BPF_MOV32_IMM(R0, 1),
6500 BPF_EXIT_INSN(),
6501 },
6502 INTERNAL,
6503 { },
6504 { { 0, 1 } }
6505 },
6506 {
6507 "ALU64_AND_K: Sign extension 2",
6508 .u.insns_int = {
6509 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6510 BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
6511 BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
6512 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6513 BPF_MOV32_IMM(R0, 2),
6514 BPF_EXIT_INSN(),
6515 BPF_MOV32_IMM(R0, 1),
6516 BPF_EXIT_INSN(),
6517 },
6518 INTERNAL,
6519 { },
6520 { { 0, 1 } }
6521 },
6522 /* BPF_ALU | BPF_OR | BPF_X */
6523 {
6524 "ALU_OR_X: 1 | 2 = 3",
6525 .u.insns_int = {
6526 BPF_LD_IMM64(R0, 1),
6527 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6528 BPF_ALU32_REG(BPF_OR, R0, R1),
6529 BPF_EXIT_INSN(),
6530 },
6531 INTERNAL,
6532 { },
6533 { { 0, 3 } },
6534 },
6535 {
6536 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
6537 .u.insns_int = {
6538 BPF_LD_IMM64(R0, 0),
6539 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6540 BPF_ALU32_REG(BPF_OR, R0, R1),
6541 BPF_EXIT_INSN(),
6542 },
6543 INTERNAL,
6544 { },
6545 { { 0, 0xffffffff } },
6546 },
6547 {
6548 "ALU64_OR_X: 1 | 2 = 3",
6549 .u.insns_int = {
6550 BPF_LD_IMM64(R0, 1),
6551 BPF_ALU32_IMM(BPF_MOV, R1, 2),
6552 BPF_ALU64_REG(BPF_OR, R0, R1),
6553 BPF_EXIT_INSN(),
6554 },
6555 INTERNAL,
6556 { },
6557 { { 0, 3 } },
6558 },
6559 {
6560 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
6561 .u.insns_int = {
6562 BPF_LD_IMM64(R0, 0),
6563 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6564 BPF_ALU64_REG(BPF_OR, R0, R1),
6565 BPF_EXIT_INSN(),
6566 },
6567 INTERNAL,
6568 { },
6569 { { 0, 0xffffffff } },
6570 },
6571 /* BPF_ALU | BPF_OR | BPF_K */
6572 {
6573 "ALU_OR_K: 1 | 2 = 3",
6574 .u.insns_int = {
6575 BPF_LD_IMM64(R0, 1),
6576 BPF_ALU32_IMM(BPF_OR, R0, 2),
6577 BPF_EXIT_INSN(),
6578 },
6579 INTERNAL,
6580 { },
6581 { { 0, 3 } },
6582 },
6583 {
6584 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
6585 .u.insns_int = {
6586 BPF_LD_IMM64(R0, 0),
6587 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
6588 BPF_EXIT_INSN(),
6589 },
6590 INTERNAL,
6591 { },
6592 { { 0, 0xffffffff } },
6593 },
6594 {
6595 "ALU_OR_K: Small immediate",
6596 .u.insns_int = {
6597 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6598 BPF_ALU32_IMM(BPF_OR, R0, 1),
6599 BPF_EXIT_INSN(),
6600 },
6601 INTERNAL,
6602 { },
6603 { { 0, 0x01020305 } }
6604 },
6605 {
6606 "ALU_OR_K: Large immediate",
6607 .u.insns_int = {
6608 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6609 BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
6610 BPF_EXIT_INSN(),
6611 },
6612 INTERNAL,
6613 { },
6614 { { 0, 0xa1b2c3d4 } }
6615 },
6616 {
6617 "ALU_OR_K: Zero extension",
6618 .u.insns_int = {
6619 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6620 BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
6621 BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
6622 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6623 BPF_MOV32_IMM(R0, 2),
6624 BPF_EXIT_INSN(),
6625 BPF_MOV32_IMM(R0, 1),
6626 BPF_EXIT_INSN(),
6627 },
6628 INTERNAL,
6629 { },
6630 { { 0, 1 } }
6631 },
6632 {
6633 "ALU64_OR_K: 1 | 2 = 3",
6634 .u.insns_int = {
6635 BPF_LD_IMM64(R0, 1),
6636 BPF_ALU64_IMM(BPF_OR, R0, 2),
6637 BPF_EXIT_INSN(),
6638 },
6639 INTERNAL,
6640 { },
6641 { { 0, 3 } },
6642 },
6643 {
6644 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
6645 .u.insns_int = {
6646 BPF_LD_IMM64(R0, 0),
6647 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
6648 BPF_EXIT_INSN(),
6649 },
6650 INTERNAL,
6651 { },
6652 { { 0, 0xffffffff } },
6653 },
6654 {
6655 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
6656 .u.insns_int = {
6657 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6658 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6659 BPF_ALU64_IMM(BPF_OR, R2, 0x0),
6660 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6661 BPF_MOV32_IMM(R0, 2),
6662 BPF_EXIT_INSN(),
6663 BPF_MOV32_IMM(R0, 1),
6664 BPF_EXIT_INSN(),
6665 },
6666 INTERNAL,
6667 { },
6668 { { 0, 0x1 } },
6669 },
6670 {
6671 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
6672 .u.insns_int = {
6673 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6674 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6675 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6676 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6677 BPF_MOV32_IMM(R0, 2),
6678 BPF_EXIT_INSN(),
6679 BPF_MOV32_IMM(R0, 1),
6680 BPF_EXIT_INSN(),
6681 },
6682 INTERNAL,
6683 { },
6684 { { 0, 0x1 } },
6685 },
6686 {
6687 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
6688 .u.insns_int = {
6689 BPF_LD_IMM64(R2, 0x0000000000000000LL),
6690 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6691 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
6692 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6693 BPF_MOV32_IMM(R0, 2),
6694 BPF_EXIT_INSN(),
6695 BPF_MOV32_IMM(R0, 1),
6696 BPF_EXIT_INSN(),
6697 },
6698 INTERNAL,
6699 { },
6700 { { 0, 0x1 } },
6701 },
6702 {
6703 "ALU64_OR_K: Sign extension 1",
6704 .u.insns_int = {
6705 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6706 BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
6707 BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
6708 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6709 BPF_MOV32_IMM(R0, 2),
6710 BPF_EXIT_INSN(),
6711 BPF_MOV32_IMM(R0, 1),
6712 BPF_EXIT_INSN(),
6713 },
6714 INTERNAL,
6715 { },
6716 { { 0, 1 } }
6717 },
6718 {
6719 "ALU64_OR_K: Sign extension 2",
6720 .u.insns_int = {
6721 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6722 BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
6723 BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
6724 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6725 BPF_MOV32_IMM(R0, 2),
6726 BPF_EXIT_INSN(),
6727 BPF_MOV32_IMM(R0, 1),
6728 BPF_EXIT_INSN(),
6729 },
6730 INTERNAL,
6731 { },
6732 { { 0, 1 } }
6733 },
6734 /* BPF_ALU | BPF_XOR | BPF_X */
6735 {
6736 "ALU_XOR_X: 5 ^ 6 = 3",
6737 .u.insns_int = {
6738 BPF_LD_IMM64(R0, 5),
6739 BPF_ALU32_IMM(BPF_MOV, R1, 6),
6740 BPF_ALU32_REG(BPF_XOR, R0, R1),
6741 BPF_EXIT_INSN(),
6742 },
6743 INTERNAL,
6744 { },
6745 { { 0, 3 } },
6746 },
6747 {
6748 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
6749 .u.insns_int = {
6750 BPF_LD_IMM64(R0, 1),
6751 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6752 BPF_ALU32_REG(BPF_XOR, R0, R1),
6753 BPF_EXIT_INSN(),
6754 },
6755 INTERNAL,
6756 { },
6757 { { 0, 0xfffffffe } },
6758 },
6759 {
6760 "ALU64_XOR_X: 5 ^ 6 = 3",
6761 .u.insns_int = {
6762 BPF_LD_IMM64(R0, 5),
6763 BPF_ALU32_IMM(BPF_MOV, R1, 6),
6764 BPF_ALU64_REG(BPF_XOR, R0, R1),
6765 BPF_EXIT_INSN(),
6766 },
6767 INTERNAL,
6768 { },
6769 { { 0, 3 } },
6770 },
6771 {
6772 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
6773 .u.insns_int = {
6774 BPF_LD_IMM64(R0, 1),
6775 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6776 BPF_ALU64_REG(BPF_XOR, R0, R1),
6777 BPF_EXIT_INSN(),
6778 },
6779 INTERNAL,
6780 { },
6781 { { 0, 0xfffffffe } },
6782 },
6783 /* BPF_ALU | BPF_XOR | BPF_K */
6784 {
6785 "ALU_XOR_K: 5 ^ 6 = 3",
6786 .u.insns_int = {
6787 BPF_LD_IMM64(R0, 5),
6788 BPF_ALU32_IMM(BPF_XOR, R0, 6),
6789 BPF_EXIT_INSN(),
6790 },
6791 INTERNAL,
6792 { },
6793 { { 0, 3 } },
6794 },
6795 {
6796 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6797 .u.insns_int = {
6798 BPF_LD_IMM64(R0, 1),
6799 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
6800 BPF_EXIT_INSN(),
6801 },
6802 INTERNAL,
6803 { },
6804 { { 0, 0xfffffffe } },
6805 },
6806 {
6807 "ALU_XOR_K: Small immediate",
6808 .u.insns_int = {
6809 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
6810 BPF_ALU32_IMM(BPF_XOR, R0, 15),
6811 BPF_EXIT_INSN(),
6812 },
6813 INTERNAL,
6814 { },
6815 { { 0, 0x0102030b } }
6816 },
6817 {
6818 "ALU_XOR_K: Large immediate",
6819 .u.insns_int = {
6820 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
6821 BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
6822 BPF_EXIT_INSN(),
6823 },
6824 INTERNAL,
6825 { },
6826 { { 0, 0x5e4d3c2b } }
6827 },
6828 {
6829 "ALU_XOR_K: Zero extension",
6830 .u.insns_int = {
6831 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6832 BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
6833 BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6834 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6835 BPF_MOV32_IMM(R0, 2),
6836 BPF_EXIT_INSN(),
6837 BPF_MOV32_IMM(R0, 1),
6838 BPF_EXIT_INSN(),
6839 },
6840 INTERNAL,
6841 { },
6842 { { 0, 1 } }
6843 },
6844 {
6845 "ALU64_XOR_K: 5 ^ 6 = 3",
6846 .u.insns_int = {
6847 BPF_LD_IMM64(R0, 5),
6848 BPF_ALU64_IMM(BPF_XOR, R0, 6),
6849 BPF_EXIT_INSN(),
6850 },
6851 INTERNAL,
6852 { },
6853 { { 0, 3 } },
6854 },
6855 {
6856 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
6857 .u.insns_int = {
6858 BPF_LD_IMM64(R0, 1),
6859 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
6860 BPF_EXIT_INSN(),
6861 },
6862 INTERNAL,
6863 { },
6864 { { 0, 0xfffffffe } },
6865 },
6866 {
6867 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
6868 .u.insns_int = {
6869 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6870 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
6871 BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
6872 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6873 BPF_MOV32_IMM(R0, 2),
6874 BPF_EXIT_INSN(),
6875 BPF_MOV32_IMM(R0, 1),
6876 BPF_EXIT_INSN(),
6877 },
6878 INTERNAL,
6879 { },
6880 { { 0, 0x1 } },
6881 },
6882 {
6883 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
6884 .u.insns_int = {
6885 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
6886 BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
6887 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6888 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6889 BPF_MOV32_IMM(R0, 2),
6890 BPF_EXIT_INSN(),
6891 BPF_MOV32_IMM(R0, 1),
6892 BPF_EXIT_INSN(),
6893 },
6894 INTERNAL,
6895 { },
6896 { { 0, 0x1 } },
6897 },
6898 {
6899 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
6900 .u.insns_int = {
6901 BPF_LD_IMM64(R2, 0x0000000000000000LL),
6902 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
6903 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
6904 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6905 BPF_MOV32_IMM(R0, 2),
6906 BPF_EXIT_INSN(),
6907 BPF_MOV32_IMM(R0, 1),
6908 BPF_EXIT_INSN(),
6909 },
6910 INTERNAL,
6911 { },
6912 { { 0, 0x1 } },
6913 },
6914 {
6915 "ALU64_XOR_K: Sign extension 1",
6916 .u.insns_int = {
6917 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6918 BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
6919 BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
6920 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6921 BPF_MOV32_IMM(R0, 2),
6922 BPF_EXIT_INSN(),
6923 BPF_MOV32_IMM(R0, 1),
6924 BPF_EXIT_INSN(),
6925 },
6926 INTERNAL,
6927 { },
6928 { { 0, 1 } }
6929 },
6930 {
6931 "ALU64_XOR_K: Sign extension 2",
6932 .u.insns_int = {
6933 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6934 BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
6935 BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6936 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6937 BPF_MOV32_IMM(R0, 2),
6938 BPF_EXIT_INSN(),
6939 BPF_MOV32_IMM(R0, 1),
6940 BPF_EXIT_INSN(),
6941 },
6942 INTERNAL,
6943 { },
6944 { { 0, 1 } }
6945 },
6946 /* BPF_ALU | BPF_LSH | BPF_X */
6947 {
6948 "ALU_LSH_X: 1 << 1 = 2",
6949 .u.insns_int = {
6950 BPF_LD_IMM64(R0, 1),
6951 BPF_ALU32_IMM(BPF_MOV, R1, 1),
6952 BPF_ALU32_REG(BPF_LSH, R0, R1),
6953 BPF_EXIT_INSN(),
6954 },
6955 INTERNAL,
6956 { },
6957 { { 0, 2 } },
6958 },
6959 {
6960 "ALU_LSH_X: 1 << 31 = 0x80000000",
6961 .u.insns_int = {
6962 BPF_LD_IMM64(R0, 1),
6963 BPF_ALU32_IMM(BPF_MOV, R1, 31),
6964 BPF_ALU32_REG(BPF_LSH, R0, R1),
6965 BPF_EXIT_INSN(),
6966 },
6967 INTERNAL,
6968 { },
6969 { { 0, 0x80000000 } },
6970 },
6971 {
6972 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
6973 .u.insns_int = {
6974 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6975 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6976 BPF_ALU32_REG(BPF_LSH, R0, R1),
6977 BPF_EXIT_INSN(),
6978 },
6979 INTERNAL,
6980 { },
6981 { { 0, 0x45678000 } }
6982 },
6983 {
6984 "ALU64_LSH_X: 1 << 1 = 2",
6985 .u.insns_int = {
6986 BPF_LD_IMM64(R0, 1),
6987 BPF_ALU32_IMM(BPF_MOV, R1, 1),
6988 BPF_ALU64_REG(BPF_LSH, R0, R1),
6989 BPF_EXIT_INSN(),
6990 },
6991 INTERNAL,
6992 { },
6993 { { 0, 2 } },
6994 },
6995 {
6996 "ALU64_LSH_X: 1 << 31 = 0x80000000",
6997 .u.insns_int = {
6998 BPF_LD_IMM64(R0, 1),
6999 BPF_ALU32_IMM(BPF_MOV, R1, 31),
7000 BPF_ALU64_REG(BPF_LSH, R0, R1),
7001 BPF_EXIT_INSN(),
7002 },
7003 INTERNAL,
7004 { },
7005 { { 0, 0x80000000 } },
7006 },
7007 {
7008 "ALU64_LSH_X: Shift < 32, low word",
7009 .u.insns_int = {
7010 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7011 BPF_ALU32_IMM(BPF_MOV, R1, 12),
7012 BPF_ALU64_REG(BPF_LSH, R0, R1),
7013 BPF_EXIT_INSN(),
7014 },
7015 INTERNAL,
7016 { },
7017 { { 0, 0xbcdef000 } }
7018 },
7019 {
7020 "ALU64_LSH_X: Shift < 32, high word",
7021 .u.insns_int = {
7022 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7023 BPF_ALU32_IMM(BPF_MOV, R1, 12),
7024 BPF_ALU64_REG(BPF_LSH, R0, R1),
7025 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7026 BPF_EXIT_INSN(),
7027 },
7028 INTERNAL,
7029 { },
7030 { { 0, 0x3456789a } }
7031 },
7032 {
7033 "ALU64_LSH_X: Shift > 32, low word",
7034 .u.insns_int = {
7035 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7036 BPF_ALU32_IMM(BPF_MOV, R1, 36),
7037 BPF_ALU64_REG(BPF_LSH, R0, R1),
7038 BPF_EXIT_INSN(),
7039 },
7040 INTERNAL,
7041 { },
7042 { { 0, 0 } }
7043 },
7044 {
7045 "ALU64_LSH_X: Shift > 32, high word",
7046 .u.insns_int = {
7047 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7048 BPF_ALU32_IMM(BPF_MOV, R1, 36),
7049 BPF_ALU64_REG(BPF_LSH, R0, R1),
7050 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7051 BPF_EXIT_INSN(),
7052 },
7053 INTERNAL,
7054 { },
7055 { { 0, 0x9abcdef0 } }
7056 },
7057 {
7058 "ALU64_LSH_X: Shift == 32, low word",
7059 .u.insns_int = {
7060 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7061 BPF_ALU32_IMM(BPF_MOV, R1, 32),
7062 BPF_ALU64_REG(BPF_LSH, R0, R1),
7063 BPF_EXIT_INSN(),
7064 },
7065 INTERNAL,
7066 { },
7067 { { 0, 0 } }
7068 },
7069 {
7070 "ALU64_LSH_X: Shift == 32, high word",
7071 .u.insns_int = {
7072 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7073 BPF_ALU32_IMM(BPF_MOV, R1, 32),
7074 BPF_ALU64_REG(BPF_LSH, R0, R1),
7075 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7076 BPF_EXIT_INSN(),
7077 },
7078 INTERNAL,
7079 { },
7080 { { 0, 0x89abcdef } }
7081 },
7082 {
7083 "ALU64_LSH_X: Zero shift, low word",
7084 .u.insns_int = {
7085 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7086 BPF_ALU32_IMM(BPF_MOV, R1, 0),
7087 BPF_ALU64_REG(BPF_LSH, R0, R1),
7088 BPF_EXIT_INSN(),
7089 },
7090 INTERNAL,
7091 { },
7092 { { 0, 0x89abcdef } }
7093 },
7094 {
7095 "ALU64_LSH_X: Zero shift, high word",
7096 .u.insns_int = {
7097 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7098 BPF_ALU32_IMM(BPF_MOV, R1, 0),
7099 BPF_ALU64_REG(BPF_LSH, R0, R1),
7100 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7101 BPF_EXIT_INSN(),
7102 },
7103 INTERNAL,
7104 { },
7105 { { 0, 0x01234567 } }
7106 },
7107 /* BPF_ALU | BPF_LSH | BPF_K */
7108 {
7109 "ALU_LSH_K: 1 << 1 = 2",
7110 .u.insns_int = {
7111 BPF_LD_IMM64(R0, 1),
7112 BPF_ALU32_IMM(BPF_LSH, R0, 1),
7113 BPF_EXIT_INSN(),
7114 },
7115 INTERNAL,
7116 { },
7117 { { 0, 2 } },
7118 },
7119 {
7120 "ALU_LSH_K: 1 << 31 = 0x80000000",
7121 .u.insns_int = {
7122 BPF_LD_IMM64(R0, 1),
7123 BPF_ALU32_IMM(BPF_LSH, R0, 31),
7124 BPF_EXIT_INSN(),
7125 },
7126 INTERNAL,
7127 { },
7128 { { 0, 0x80000000 } },
7129 },
7130 {
7131 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
7132 .u.insns_int = {
7133 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7134 BPF_ALU32_IMM(BPF_LSH, R0, 12),
7135 BPF_EXIT_INSN(),
7136 },
7137 INTERNAL,
7138 { },
7139 { { 0, 0x45678000 } }
7140 },
7141 {
7142 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
7143 .u.insns_int = {
7144 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7145 BPF_ALU32_IMM(BPF_LSH, R0, 0),
7146 BPF_EXIT_INSN(),
7147 },
7148 INTERNAL,
7149 { },
7150 { { 0, 0x12345678 } }
7151 },
7152 {
7153 "ALU64_LSH_K: 1 << 1 = 2",
7154 .u.insns_int = {
7155 BPF_LD_IMM64(R0, 1),
7156 BPF_ALU64_IMM(BPF_LSH, R0, 1),
7157 BPF_EXIT_INSN(),
7158 },
7159 INTERNAL,
7160 { },
7161 { { 0, 2 } },
7162 },
7163 {
7164 "ALU64_LSH_K: 1 << 31 = 0x80000000",
7165 .u.insns_int = {
7166 BPF_LD_IMM64(R0, 1),
7167 BPF_ALU64_IMM(BPF_LSH, R0, 31),
7168 BPF_EXIT_INSN(),
7169 },
7170 INTERNAL,
7171 { },
7172 { { 0, 0x80000000 } },
7173 },
7174 {
7175 "ALU64_LSH_K: Shift < 32, low word",
7176 .u.insns_int = {
7177 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7178 BPF_ALU64_IMM(BPF_LSH, R0, 12),
7179 BPF_EXIT_INSN(),
7180 },
7181 INTERNAL,
7182 { },
7183 { { 0, 0xbcdef000 } }
7184 },
7185 {
7186 "ALU64_LSH_K: Shift < 32, high word",
7187 .u.insns_int = {
7188 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7189 BPF_ALU64_IMM(BPF_LSH, R0, 12),
7190 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7191 BPF_EXIT_INSN(),
7192 },
7193 INTERNAL,
7194 { },
7195 { { 0, 0x3456789a } }
7196 },
7197 {
7198 "ALU64_LSH_K: Shift > 32, low word",
7199 .u.insns_int = {
7200 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7201 BPF_ALU64_IMM(BPF_LSH, R0, 36),
7202 BPF_EXIT_INSN(),
7203 },
7204 INTERNAL,
7205 { },
7206 { { 0, 0 } }
7207 },
7208 {
7209 "ALU64_LSH_K: Shift > 32, high word",
7210 .u.insns_int = {
7211 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7212 BPF_ALU64_IMM(BPF_LSH, R0, 36),
7213 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7214 BPF_EXIT_INSN(),
7215 },
7216 INTERNAL,
7217 { },
7218 { { 0, 0x9abcdef0 } }
7219 },
7220 {
7221 "ALU64_LSH_K: Shift == 32, low word",
7222 .u.insns_int = {
7223 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7224 BPF_ALU64_IMM(BPF_LSH, R0, 32),
7225 BPF_EXIT_INSN(),
7226 },
7227 INTERNAL,
7228 { },
7229 { { 0, 0 } }
7230 },
7231 {
7232 "ALU64_LSH_K: Shift == 32, high word",
7233 .u.insns_int = {
7234 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7235 BPF_ALU64_IMM(BPF_LSH, R0, 32),
7236 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7237 BPF_EXIT_INSN(),
7238 },
7239 INTERNAL,
7240 { },
7241 { { 0, 0x89abcdef } }
7242 },
7243 {
7244 "ALU64_LSH_K: Zero shift",
7245 .u.insns_int = {
7246 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7247 BPF_ALU64_IMM(BPF_LSH, R0, 0),
7248 BPF_EXIT_INSN(),
7249 },
7250 INTERNAL,
7251 { },
7252 { { 0, 0x89abcdef } }
7253 },
7254 /* BPF_ALU | BPF_RSH | BPF_X */
7255 {
7256 "ALU_RSH_X: 2 >> 1 = 1",
7257 .u.insns_int = {
7258 BPF_LD_IMM64(R0, 2),
7259 BPF_ALU32_IMM(BPF_MOV, R1, 1),
7260 BPF_ALU32_REG(BPF_RSH, R0, R1),
7261 BPF_EXIT_INSN(),
7262 },
7263 INTERNAL,
7264 { },
7265 { { 0, 1 } },
7266 },
7267 {
7268 "ALU_RSH_X: 0x80000000 >> 31 = 1",
7269 .u.insns_int = {
7270 BPF_LD_IMM64(R0, 0x80000000),
7271 BPF_ALU32_IMM(BPF_MOV, R1, 31),
7272 BPF_ALU32_REG(BPF_RSH, R0, R1),
7273 BPF_EXIT_INSN(),
7274 },
7275 INTERNAL,
7276 { },
7277 { { 0, 1 } },
7278 },
7279 {
7280 "ALU_RSH_X: 0x12345678 >> 20 = 0x123",
7281 .u.insns_int = {
7282 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7283 BPF_ALU32_IMM(BPF_MOV, R1, 20),
7284 BPF_ALU32_REG(BPF_RSH, R0, R1),
7285 BPF_EXIT_INSN(),
7286 },
7287 INTERNAL,
7288 { },
7289 { { 0, 0x123 } }
7290 },
7291 {
7292 "ALU64_RSH_X: 2 >> 1 = 1",
7293 .u.insns_int = {
7294 BPF_LD_IMM64(R0, 2),
7295 BPF_ALU32_IMM(BPF_MOV, R1, 1),
7296 BPF_ALU64_REG(BPF_RSH, R0, R1),
7297 BPF_EXIT_INSN(),
7298 },
7299 INTERNAL,
7300 { },
7301 { { 0, 1 } },
7302 },
7303 {
7304 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
7305 .u.insns_int = {
7306 BPF_LD_IMM64(R0, 0x80000000),
7307 BPF_ALU32_IMM(BPF_MOV, R1, 31),
7308 BPF_ALU64_REG(BPF_RSH, R0, R1),
7309 BPF_EXIT_INSN(),
7310 },
7311 INTERNAL,
7312 { },
7313 { { 0, 1 } },
7314 },
7315 {
7316 "ALU64_RSH_X: Shift < 32, low word",
7317 .u.insns_int = {
7318 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7319 BPF_ALU32_IMM(BPF_MOV, R1, 12),
7320 BPF_ALU64_REG(BPF_RSH, R0, R1),
7321 BPF_EXIT_INSN(),
7322 },
7323 INTERNAL,
7324 { },
7325 { { 0, 0x56789abc } }
7326 },
7327 {
7328 "ALU64_RSH_X: Shift < 32, high word",
7329 .u.insns_int = {
7330 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7331 BPF_ALU32_IMM(BPF_MOV, R1, 12),
7332 BPF_ALU64_REG(BPF_RSH, R0, R1),
7333 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7334 BPF_EXIT_INSN(),
7335 },
7336 INTERNAL,
7337 { },
7338 { { 0, 0x00081234 } }
7339 },
7340 {
7341 "ALU64_RSH_X: Shift > 32, low word",
7342 .u.insns_int = {
7343 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7344 BPF_ALU32_IMM(BPF_MOV, R1, 36),
7345 BPF_ALU64_REG(BPF_RSH, R0, R1),
7346 BPF_EXIT_INSN(),
7347 },
7348 INTERNAL,
7349 { },
7350 { { 0, 0x08123456 } }
7351 },
7352 {
7353 "ALU64_RSH_X: Shift > 32, high word",
7354 .u.insns_int = {
7355 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7356 BPF_ALU32_IMM(BPF_MOV, R1, 36),
7357 BPF_ALU64_REG(BPF_RSH, R0, R1),
7358 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7359 BPF_EXIT_INSN(),
7360 },
7361 INTERNAL,
7362 { },
7363 { { 0, 0 } }
7364 },
7365 {
7366 "ALU64_RSH_X: Shift == 32, low word",
7367 .u.insns_int = {
7368 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7369 BPF_ALU32_IMM(BPF_MOV, R1, 32),
7370 BPF_ALU64_REG(BPF_RSH, R0, R1),
7371 BPF_EXIT_INSN(),
7372 },
7373 INTERNAL,
7374 { },
7375 { { 0, 0x81234567 } }
7376 },
7377 {
7378 "ALU64_RSH_X: Shift == 32, high word",
7379 .u.insns_int = {
7380 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7381 BPF_ALU32_IMM(BPF_MOV, R1, 32),
7382 BPF_ALU64_REG(BPF_RSH, R0, R1),
7383 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7384 BPF_EXIT_INSN(),
7385 },
7386 INTERNAL,
7387 { },
7388 { { 0, 0 } }
7389 },
7390 {
7391 "ALU64_RSH_X: Zero shift, low word",
7392 .u.insns_int = {
7393 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7394 BPF_ALU32_IMM(BPF_MOV, R1, 0),
7395 BPF_ALU64_REG(BPF_RSH, R0, R1),
7396 BPF_EXIT_INSN(),
7397 },
7398 INTERNAL,
7399 { },
7400 { { 0, 0x89abcdef } }
7401 },
7402 {
7403 "ALU64_RSH_X: Zero shift, high word",
7404 .u.insns_int = {
7405 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7406 BPF_ALU32_IMM(BPF_MOV, R1, 0),
7407 BPF_ALU64_REG(BPF_RSH, R0, R1),
7408 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7409 BPF_EXIT_INSN(),
7410 },
7411 INTERNAL,
7412 { },
7413 { { 0, 0x81234567 } }
7414 },
7415 /* BPF_ALU | BPF_RSH | BPF_K */
7416 {
7417 "ALU_RSH_K: 2 >> 1 = 1",
7418 .u.insns_int = {
7419 BPF_LD_IMM64(R0, 2),
7420 BPF_ALU32_IMM(BPF_RSH, R0, 1),
7421 BPF_EXIT_INSN(),
7422 },
7423 INTERNAL,
7424 { },
7425 { { 0, 1 } },
7426 },
7427 {
7428 "ALU_RSH_K: 0x80000000 >> 31 = 1",
7429 .u.insns_int = {
7430 BPF_LD_IMM64(R0, 0x80000000),
7431 BPF_ALU32_IMM(BPF_RSH, R0, 31),
7432 BPF_EXIT_INSN(),
7433 },
7434 INTERNAL,
7435 { },
7436 { { 0, 1 } },
7437 },
7438 {
7439 "ALU_RSH_K: 0x12345678 >> 20 = 0x123",
7440 .u.insns_int = {
7441 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7442 BPF_ALU32_IMM(BPF_RSH, R0, 20),
7443 BPF_EXIT_INSN(),
7444 },
7445 INTERNAL,
7446 { },
7447 { { 0, 0x123 } }
7448 },
7449 {
7450 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
7451 .u.insns_int = {
7452 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
7453 BPF_ALU32_IMM(BPF_RSH, R0, 0),
7454 BPF_EXIT_INSN(),
7455 },
7456 INTERNAL,
7457 { },
7458 { { 0, 0x12345678 } }
7459 },
7460 {
7461 "ALU64_RSH_K: 2 >> 1 = 1",
7462 .u.insns_int = {
7463 BPF_LD_IMM64(R0, 2),
7464 BPF_ALU64_IMM(BPF_RSH, R0, 1),
7465 BPF_EXIT_INSN(),
7466 },
7467 INTERNAL,
7468 { },
7469 { { 0, 1 } },
7470 },
7471 {
7472 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
7473 .u.insns_int = {
7474 BPF_LD_IMM64(R0, 0x80000000),
7475 BPF_ALU64_IMM(BPF_RSH, R0, 31),
7476 BPF_EXIT_INSN(),
7477 },
7478 INTERNAL,
7479 { },
7480 { { 0, 1 } },
7481 },
7482 {
7483 "ALU64_RSH_K: Shift < 32, low word",
7484 .u.insns_int = {
7485 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7486 BPF_ALU64_IMM(BPF_RSH, R0, 12),
7487 BPF_EXIT_INSN(),
7488 },
7489 INTERNAL,
7490 { },
7491 { { 0, 0x56789abc } }
7492 },
7493 {
7494 "ALU64_RSH_K: Shift < 32, high word",
7495 .u.insns_int = {
7496 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7497 BPF_ALU64_IMM(BPF_RSH, R0, 12),
7498 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7499 BPF_EXIT_INSN(),
7500 },
7501 INTERNAL,
7502 { },
7503 { { 0, 0x00081234 } }
7504 },
7505 {
7506 "ALU64_RSH_K: Shift > 32, low word",
7507 .u.insns_int = {
7508 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7509 BPF_ALU64_IMM(BPF_RSH, R0, 36),
7510 BPF_EXIT_INSN(),
7511 },
7512 INTERNAL,
7513 { },
7514 { { 0, 0x08123456 } }
7515 },
7516 {
7517 "ALU64_RSH_K: Shift > 32, high word",
7518 .u.insns_int = {
7519 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7520 BPF_ALU64_IMM(BPF_RSH, R0, 36),
7521 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7522 BPF_EXIT_INSN(),
7523 },
7524 INTERNAL,
7525 { },
7526 { { 0, 0 } }
7527 },
7528 {
7529 "ALU64_RSH_K: Shift == 32, low word",
7530 .u.insns_int = {
7531 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7532 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7533 BPF_EXIT_INSN(),
7534 },
7535 INTERNAL,
7536 { },
7537 { { 0, 0x81234567 } }
7538 },
7539 {
7540 "ALU64_RSH_K: Shift == 32, high word",
7541 .u.insns_int = {
7542 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7543 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7544 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7545 BPF_EXIT_INSN(),
7546 },
7547 INTERNAL,
7548 { },
7549 { { 0, 0 } }
7550 },
7551 {
7552 "ALU64_RSH_K: Zero shift",
7553 .u.insns_int = {
7554 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7555 BPF_ALU64_IMM(BPF_RSH, R0, 0),
7556 BPF_EXIT_INSN(),
7557 },
7558 INTERNAL,
7559 { },
7560 { { 0, 0x89abcdef } }
7561 },
7562 /* BPF_ALU | BPF_ARSH | BPF_X */
7563 {
7564 "ALU32_ARSH_X: -1234 >> 7 = -10",
7565 .u.insns_int = {
7566 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7567 BPF_ALU32_IMM(BPF_MOV, R1, 7),
7568 BPF_ALU32_REG(BPF_ARSH, R0, R1),
7569 BPF_EXIT_INSN(),
7570 },
7571 INTERNAL,
7572 { },
7573 { { 0, -10 } }
7574 },
7575 {
7576 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7577 .u.insns_int = {
7578 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7579 BPF_ALU32_IMM(BPF_MOV, R1, 40),
7580 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7581 BPF_EXIT_INSN(),
7582 },
7583 INTERNAL,
7584 { },
7585 { { 0, 0xffff00ff } },
7586 },
7587 {
7588 "ALU64_ARSH_X: Shift < 32, low word",
7589 .u.insns_int = {
7590 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7591 BPF_ALU32_IMM(BPF_MOV, R1, 12),
7592 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7593 BPF_EXIT_INSN(),
7594 },
7595 INTERNAL,
7596 { },
7597 { { 0, 0x56789abc } }
7598 },
7599 {
7600 "ALU64_ARSH_X: Shift < 32, high word",
7601 .u.insns_int = {
7602 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7603 BPF_ALU32_IMM(BPF_MOV, R1, 12),
7604 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7605 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7606 BPF_EXIT_INSN(),
7607 },
7608 INTERNAL,
7609 { },
7610 { { 0, 0xfff81234 } }
7611 },
7612 {
7613 "ALU64_ARSH_X: Shift > 32, low word",
7614 .u.insns_int = {
7615 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7616 BPF_ALU32_IMM(BPF_MOV, R1, 36),
7617 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7618 BPF_EXIT_INSN(),
7619 },
7620 INTERNAL,
7621 { },
7622 { { 0, 0xf8123456 } }
7623 },
7624 {
7625 "ALU64_ARSH_X: Shift > 32, high word",
7626 .u.insns_int = {
7627 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7628 BPF_ALU32_IMM(BPF_MOV, R1, 36),
7629 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7630 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7631 BPF_EXIT_INSN(),
7632 },
7633 INTERNAL,
7634 { },
7635 { { 0, -1 } }
7636 },
7637 {
7638 "ALU64_ARSH_X: Shift == 32, low word",
7639 .u.insns_int = {
7640 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7641 BPF_ALU32_IMM(BPF_MOV, R1, 32),
7642 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7643 BPF_EXIT_INSN(),
7644 },
7645 INTERNAL,
7646 { },
7647 { { 0, 0x81234567 } }
7648 },
7649 {
7650 "ALU64_ARSH_X: Shift == 32, high word",
7651 .u.insns_int = {
7652 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7653 BPF_ALU32_IMM(BPF_MOV, R1, 32),
7654 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7655 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7656 BPF_EXIT_INSN(),
7657 },
7658 INTERNAL,
7659 { },
7660 { { 0, -1 } }
7661 },
7662 {
7663 "ALU64_ARSH_X: Zero shift, low word",
7664 .u.insns_int = {
7665 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7666 BPF_ALU32_IMM(BPF_MOV, R1, 0),
7667 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7668 BPF_EXIT_INSN(),
7669 },
7670 INTERNAL,
7671 { },
7672 { { 0, 0x89abcdef } }
7673 },
7674 {
7675 "ALU64_ARSH_X: Zero shift, high word",
7676 .u.insns_int = {
7677 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7678 BPF_ALU32_IMM(BPF_MOV, R1, 0),
7679 BPF_ALU64_REG(BPF_ARSH, R0, R1),
7680 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7681 BPF_EXIT_INSN(),
7682 },
7683 INTERNAL,
7684 { },
7685 { { 0, 0x81234567 } }
7686 },
7687 /* BPF_ALU | BPF_ARSH | BPF_K */
7688 {
7689 "ALU32_ARSH_K: -1234 >> 7 = -10",
7690 .u.insns_int = {
7691 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7692 BPF_ALU32_IMM(BPF_ARSH, R0, 7),
7693 BPF_EXIT_INSN(),
7694 },
7695 INTERNAL,
7696 { },
7697 { { 0, -10 } }
7698 },
7699 {
7700 "ALU32_ARSH_K: -1234 >> 0 = -1234",
7701 .u.insns_int = {
7702 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
7703 BPF_ALU32_IMM(BPF_ARSH, R0, 0),
7704 BPF_EXIT_INSN(),
7705 },
7706 INTERNAL,
7707 { },
7708 { { 0, -1234 } }
7709 },
7710 {
7711 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
7712 .u.insns_int = {
7713 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
7714 BPF_ALU64_IMM(BPF_ARSH, R0, 40),
7715 BPF_EXIT_INSN(),
7716 },
7717 INTERNAL,
7718 { },
7719 { { 0, 0xffff00ff } },
7720 },
7721 {
7722 "ALU64_ARSH_K: Shift < 32, low word",
7723 .u.insns_int = {
7724 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7725 BPF_ALU64_IMM(BPF_RSH, R0, 12),
7726 BPF_EXIT_INSN(),
7727 },
7728 INTERNAL,
7729 { },
7730 { { 0, 0x56789abc } }
7731 },
7732 {
7733 "ALU64_ARSH_K: Shift < 32, high word",
7734 .u.insns_int = {
7735 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7736 BPF_ALU64_IMM(BPF_ARSH, R0, 12),
7737 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7738 BPF_EXIT_INSN(),
7739 },
7740 INTERNAL,
7741 { },
7742 { { 0, 0xfff81234 } }
7743 },
7744 {
7745 "ALU64_ARSH_K: Shift > 32, low word",
7746 .u.insns_int = {
7747 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7748 BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7749 BPF_EXIT_INSN(),
7750 },
7751 INTERNAL,
7752 { },
7753 { { 0, 0xf8123456 } }
7754 },
7755 {
7756 "ALU64_ARSH_K: Shift > 32, high word",
7757 .u.insns_int = {
7758 BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
7759 BPF_ALU64_IMM(BPF_ARSH, R0, 36),
7760 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7761 BPF_EXIT_INSN(),
7762 },
7763 INTERNAL,
7764 { },
7765 { { 0, -1 } }
7766 },
7767 {
7768 "ALU64_ARSH_K: Shift == 32, low word",
7769 .u.insns_int = {
7770 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7771 BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7772 BPF_EXIT_INSN(),
7773 },
7774 INTERNAL,
7775 { },
7776 { { 0, 0x81234567 } }
7777 },
7778 {
7779 "ALU64_ARSH_K: Shift == 32, high word",
7780 .u.insns_int = {
7781 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7782 BPF_ALU64_IMM(BPF_ARSH, R0, 32),
7783 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7784 BPF_EXIT_INSN(),
7785 },
7786 INTERNAL,
7787 { },
7788 { { 0, -1 } }
7789 },
7790 {
7791 "ALU64_ARSH_K: Zero shift",
7792 .u.insns_int = {
7793 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
7794 BPF_ALU64_IMM(BPF_ARSH, R0, 0),
7795 BPF_EXIT_INSN(),
7796 },
7797 INTERNAL,
7798 { },
7799 { { 0, 0x89abcdef } }
7800 },
7801 /* BPF_ALU | BPF_NEG */
7802 {
7803 "ALU_NEG: -(3) = -3",
7804 .u.insns_int = {
7805 BPF_ALU32_IMM(BPF_MOV, R0, 3),
7806 BPF_ALU32_IMM(BPF_NEG, R0, 0),
7807 BPF_EXIT_INSN(),
7808 },
7809 INTERNAL,
7810 { },
7811 { { 0, -3 } },
7812 },
7813 {
7814 "ALU_NEG: -(-3) = 3",
7815 .u.insns_int = {
7816 BPF_ALU32_IMM(BPF_MOV, R0, -3),
7817 BPF_ALU32_IMM(BPF_NEG, R0, 0),
7818 BPF_EXIT_INSN(),
7819 },
7820 INTERNAL,
7821 { },
7822 { { 0, 3 } },
7823 },
7824 {
7825 "ALU64_NEG: -(3) = -3",
7826 .u.insns_int = {
7827 BPF_LD_IMM64(R0, 3),
7828 BPF_ALU64_IMM(BPF_NEG, R0, 0),
7829 BPF_EXIT_INSN(),
7830 },
7831 INTERNAL,
7832 { },
7833 { { 0, -3 } },
7834 },
7835 {
7836 "ALU64_NEG: -(-3) = 3",
7837 .u.insns_int = {
7838 BPF_LD_IMM64(R0, -3),
7839 BPF_ALU64_IMM(BPF_NEG, R0, 0),
7840 BPF_EXIT_INSN(),
7841 },
7842 INTERNAL,
7843 { },
7844 { { 0, 3 } },
7845 },
7846 /* BPF_ALU | BPF_END | BPF_FROM_BE */
7847 {
7848 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
7849 .u.insns_int = {
7850 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7851 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7852 BPF_EXIT_INSN(),
7853 },
7854 INTERNAL,
7855 { },
7856 { { 0, cpu_to_be16(0xcdef) } },
7857 },
7858 {
7859 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
7860 .u.insns_int = {
7861 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7862 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7863 BPF_ALU64_REG(BPF_MOV, R1, R0),
7864 BPF_ALU64_IMM(BPF_RSH, R1, 32),
7865 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7866 BPF_EXIT_INSN(),
7867 },
7868 INTERNAL,
7869 { },
7870 { { 0, cpu_to_be32(0x89abcdef) } },
7871 },
7872 {
7873 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
7874 .u.insns_int = {
7875 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7876 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7877 BPF_EXIT_INSN(),
7878 },
7879 INTERNAL,
7880 { },
7881 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
7882 },
7883 {
7884 "ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
7885 .u.insns_int = {
7886 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7887 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7888 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7889 BPF_EXIT_INSN(),
7890 },
7891 INTERNAL,
7892 { },
7893 { { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
7894 },
7895 /* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
7896 {
7897 "ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
7898 .u.insns_int = {
7899 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7900 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
7901 BPF_EXIT_INSN(),
7902 },
7903 INTERNAL,
7904 { },
7905 { { 0, cpu_to_be16(0x3210) } },
7906 },
7907 {
7908 "ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
7909 .u.insns_int = {
7910 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7911 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7912 BPF_ALU64_REG(BPF_MOV, R1, R0),
7913 BPF_ALU64_IMM(BPF_RSH, R1, 32),
7914 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7915 BPF_EXIT_INSN(),
7916 },
7917 INTERNAL,
7918 { },
7919 { { 0, cpu_to_be32(0x76543210) } },
7920 },
7921 {
7922 "ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
7923 .u.insns_int = {
7924 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7925 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7926 BPF_EXIT_INSN(),
7927 },
7928 INTERNAL,
7929 { },
7930 { { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
7931 },
7932 {
7933 "ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
7934 .u.insns_int = {
7935 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7936 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7937 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7938 BPF_EXIT_INSN(),
7939 },
7940 INTERNAL,
7941 { },
7942 { { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
7943 },
7944 /* BPF_ALU | BPF_END | BPF_FROM_LE */
7945 {
7946 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
7947 .u.insns_int = {
7948 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7949 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7950 BPF_EXIT_INSN(),
7951 },
7952 INTERNAL,
7953 { },
7954 { { 0, cpu_to_le16(0xcdef) } },
7955 },
7956 {
7957 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
7958 .u.insns_int = {
7959 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7960 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7961 BPF_ALU64_REG(BPF_MOV, R1, R0),
7962 BPF_ALU64_IMM(BPF_RSH, R1, 32),
7963 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7964 BPF_EXIT_INSN(),
7965 },
7966 INTERNAL,
7967 { },
7968 { { 0, cpu_to_le32(0x89abcdef) } },
7969 },
7970 {
7971 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
7972 .u.insns_int = {
7973 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7974 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7975 BPF_EXIT_INSN(),
7976 },
7977 INTERNAL,
7978 { },
7979 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
7980 },
7981 {
7982 "ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
7983 .u.insns_int = {
7984 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7985 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7986 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7987 BPF_EXIT_INSN(),
7988 },
7989 INTERNAL,
7990 { },
7991 { { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
7992 },
7993 /* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
7994 {
7995 "ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
7996 .u.insns_int = {
7997 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7998 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7999 BPF_EXIT_INSN(),
8000 },
8001 INTERNAL,
8002 { },
8003 { { 0, cpu_to_le16(0x3210) } },
8004 },
8005 {
8006 "ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
8007 .u.insns_int = {
8008 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8009 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
8010 BPF_ALU64_REG(BPF_MOV, R1, R0),
8011 BPF_ALU64_IMM(BPF_RSH, R1, 32),
8012 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8013 BPF_EXIT_INSN(),
8014 },
8015 INTERNAL,
8016 { },
8017 { { 0, cpu_to_le32(0x76543210) } },
8018 },
8019 {
8020 "ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
8021 .u.insns_int = {
8022 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8023 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
8024 BPF_EXIT_INSN(),
8025 },
8026 INTERNAL,
8027 { },
8028 { { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
8029 },
8030 {
8031 "ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
8032 .u.insns_int = {
8033 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8034 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
8035 BPF_ALU64_IMM(BPF_RSH, R0, 32),
8036 BPF_EXIT_INSN(),
8037 },
8038 INTERNAL,
8039 { },
8040 { { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
8041 },
8042 /* BSWAP */
8043 {
8044 "BSWAP 16: 0x0123456789abcdef -> 0xefcd",
8045 .u.insns_int = {
8046 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8047 BPF_BSWAP(R0, 16),
8048 BPF_EXIT_INSN(),
8049 },
8050 INTERNAL,
8051 { },
8052 { { 0, 0xefcd } },
8053 },
8054 {
8055 "BSWAP 32: 0x0123456789abcdef -> 0xefcdab89",
8056 .u.insns_int = {
8057 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8058 BPF_BSWAP(R0, 32),
8059 BPF_ALU64_REG(BPF_MOV, R1, R0),
8060 BPF_ALU64_IMM(BPF_RSH, R1, 32),
8061 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8062 BPF_EXIT_INSN(),
8063 },
8064 INTERNAL,
8065 { },
8066 { { 0, 0xefcdab89 } },
8067 },
8068 {
8069 "BSWAP 64: 0x0123456789abcdef -> 0x67452301",
8070 .u.insns_int = {
8071 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8072 BPF_BSWAP(R0, 64),
8073 BPF_EXIT_INSN(),
8074 },
8075 INTERNAL,
8076 { },
8077 { { 0, 0x67452301 } },
8078 },
8079 {
8080 "BSWAP 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
8081 .u.insns_int = {
8082 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
8083 BPF_BSWAP(R0, 64),
8084 BPF_ALU64_IMM(BPF_RSH, R0, 32),
8085 BPF_EXIT_INSN(),
8086 },
8087 INTERNAL,
8088 { },
8089 { { 0, 0xefcdab89 } },
8090 },
8091 /* BSWAP, reversed */
8092 {
8093 "BSWAP 16: 0xfedcba9876543210 -> 0x1032",
8094 .u.insns_int = {
8095 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8096 BPF_BSWAP(R0, 16),
8097 BPF_EXIT_INSN(),
8098 },
8099 INTERNAL,
8100 { },
8101 { { 0, 0x1032 } },
8102 },
8103 {
8104 "BSWAP 32: 0xfedcba9876543210 -> 0x10325476",
8105 .u.insns_int = {
8106 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8107 BPF_BSWAP(R0, 32),
8108 BPF_ALU64_REG(BPF_MOV, R1, R0),
8109 BPF_ALU64_IMM(BPF_RSH, R1, 32),
8110 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
8111 BPF_EXIT_INSN(),
8112 },
8113 INTERNAL,
8114 { },
8115 { { 0, 0x10325476 } },
8116 },
8117 {
8118 "BSWAP 64: 0xfedcba9876543210 -> 0x98badcfe",
8119 .u.insns_int = {
8120 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8121 BPF_BSWAP(R0, 64),
8122 BPF_EXIT_INSN(),
8123 },
8124 INTERNAL,
8125 { },
8126 { { 0, 0x98badcfe } },
8127 },
8128 {
8129 "BSWAP 64: 0xfedcba9876543210 >> 32 -> 0x10325476",
8130 .u.insns_int = {
8131 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
8132 BPF_BSWAP(R0, 64),
8133 BPF_ALU64_IMM(BPF_RSH, R0, 32),
8134 BPF_EXIT_INSN(),
8135 },
8136 INTERNAL,
8137 { },
8138 { { 0, 0x10325476 } },
8139 },
8140 /* BPF_LDX_MEM B/H/W/DW */
8141 {
8142 "BPF_LDX_MEM | BPF_B, base",
8143 .u.insns_int = {
8144 BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8145 BPF_LD_IMM64(R2, 0x0000000000000008ULL),
8146 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8147 #ifdef __BIG_ENDIAN
8148 BPF_LDX_MEM(BPF_B, R0, R10, -1),
8149 #else
8150 BPF_LDX_MEM(BPF_B, R0, R10, -8),
8151 #endif
8152 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8153 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8154 BPF_EXIT_INSN(),
8155 },
8156 INTERNAL,
8157 { },
8158 { { 0, 0 } },
8159 .stack_depth = 8,
8160 },
8161 {
8162 "BPF_LDX_MEM | BPF_B, MSB set",
8163 .u.insns_int = {
8164 BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8165 BPF_LD_IMM64(R2, 0x0000000000000088ULL),
8166 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8167 #ifdef __BIG_ENDIAN
8168 BPF_LDX_MEM(BPF_B, R0, R10, -1),
8169 #else
8170 BPF_LDX_MEM(BPF_B, R0, R10, -8),
8171 #endif
8172 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8173 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8174 BPF_EXIT_INSN(),
8175 },
8176 INTERNAL,
8177 { },
8178 { { 0, 0 } },
8179 .stack_depth = 8,
8180 },
8181 {
8182 "BPF_LDX_MEM | BPF_B, negative offset",
8183 .u.insns_int = {
8184 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8185 BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8186 BPF_ALU64_IMM(BPF_ADD, R1, 512),
8187 BPF_STX_MEM(BPF_B, R1, R2, -256),
8188 BPF_LDX_MEM(BPF_B, R0, R1, -256),
8189 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8190 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8191 BPF_EXIT_INSN(),
8192 },
8193 INTERNAL | FLAG_LARGE_MEM,
8194 { },
8195 { { 512, 0 } },
8196 .stack_depth = 0,
8197 },
8198 {
8199 "BPF_LDX_MEM | BPF_B, small positive offset",
8200 .u.insns_int = {
8201 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8202 BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8203 BPF_STX_MEM(BPF_B, R1, R2, 256),
8204 BPF_LDX_MEM(BPF_B, R0, R1, 256),
8205 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8206 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8207 BPF_EXIT_INSN(),
8208 },
8209 INTERNAL | FLAG_LARGE_MEM,
8210 { },
8211 { { 512, 0 } },
8212 .stack_depth = 0,
8213 },
8214 {
8215 "BPF_LDX_MEM | BPF_B, large positive offset",
8216 .u.insns_int = {
8217 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8218 BPF_LD_IMM64(R3, 0x0000000000000088ULL),
8219 BPF_STX_MEM(BPF_B, R1, R2, 4096),
8220 BPF_LDX_MEM(BPF_B, R0, R1, 4096),
8221 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8222 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8223 BPF_EXIT_INSN(),
8224 },
8225 INTERNAL | FLAG_LARGE_MEM,
8226 { },
8227 { { 4096 + 16, 0 } },
8228 .stack_depth = 0,
8229 },
8230 {
8231 "BPF_LDX_MEM | BPF_H, base",
8232 .u.insns_int = {
8233 BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8234 BPF_LD_IMM64(R2, 0x0000000000000708ULL),
8235 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8236 #ifdef __BIG_ENDIAN
8237 BPF_LDX_MEM(BPF_H, R0, R10, -2),
8238 #else
8239 BPF_LDX_MEM(BPF_H, R0, R10, -8),
8240 #endif
8241 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8242 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8243 BPF_EXIT_INSN(),
8244 },
8245 INTERNAL,
8246 { },
8247 { { 0, 0 } },
8248 .stack_depth = 8,
8249 },
8250 {
8251 "BPF_LDX_MEM | BPF_H, MSB set",
8252 .u.insns_int = {
8253 BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8254 BPF_LD_IMM64(R2, 0x0000000000008788ULL),
8255 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8256 #ifdef __BIG_ENDIAN
8257 BPF_LDX_MEM(BPF_H, R0, R10, -2),
8258 #else
8259 BPF_LDX_MEM(BPF_H, R0, R10, -8),
8260 #endif
8261 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8262 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8263 BPF_EXIT_INSN(),
8264 },
8265 INTERNAL,
8266 { },
8267 { { 0, 0 } },
8268 .stack_depth = 8,
8269 },
8270 {
8271 "BPF_LDX_MEM | BPF_H, negative offset",
8272 .u.insns_int = {
8273 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8274 BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8275 BPF_ALU64_IMM(BPF_ADD, R1, 512),
8276 BPF_STX_MEM(BPF_H, R1, R2, -256),
8277 BPF_LDX_MEM(BPF_H, R0, R1, -256),
8278 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8279 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8280 BPF_EXIT_INSN(),
8281 },
8282 INTERNAL | FLAG_LARGE_MEM,
8283 { },
8284 { { 512, 0 } },
8285 .stack_depth = 0,
8286 },
8287 {
8288 "BPF_LDX_MEM | BPF_H, small positive offset",
8289 .u.insns_int = {
8290 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8291 BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8292 BPF_STX_MEM(BPF_H, R1, R2, 256),
8293 BPF_LDX_MEM(BPF_H, R0, R1, 256),
8294 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8295 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8296 BPF_EXIT_INSN(),
8297 },
8298 INTERNAL | FLAG_LARGE_MEM,
8299 { },
8300 { { 512, 0 } },
8301 .stack_depth = 0,
8302 },
8303 {
8304 "BPF_LDX_MEM | BPF_H, large positive offset",
8305 .u.insns_int = {
8306 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8307 BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8308 BPF_STX_MEM(BPF_H, R1, R2, 8192),
8309 BPF_LDX_MEM(BPF_H, R0, R1, 8192),
8310 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8311 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8312 BPF_EXIT_INSN(),
8313 },
8314 INTERNAL | FLAG_LARGE_MEM,
8315 { },
8316 { { 8192 + 16, 0 } },
8317 .stack_depth = 0,
8318 },
8319 {
8320 "BPF_LDX_MEM | BPF_H, unaligned positive offset",
8321 .u.insns_int = {
8322 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8323 BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8324 BPF_STX_MEM(BPF_H, R1, R2, 13),
8325 BPF_LDX_MEM(BPF_H, R0, R1, 13),
8326 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8327 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8328 BPF_EXIT_INSN(),
8329 },
8330 INTERNAL | FLAG_LARGE_MEM,
8331 { },
8332 { { 32, 0 } },
8333 .stack_depth = 0,
8334 },
8335 {
8336 "BPF_LDX_MEM | BPF_W, base",
8337 .u.insns_int = {
8338 BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8339 BPF_LD_IMM64(R2, 0x0000000005060708ULL),
8340 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8341 #ifdef __BIG_ENDIAN
8342 BPF_LDX_MEM(BPF_W, R0, R10, -4),
8343 #else
8344 BPF_LDX_MEM(BPF_W, R0, R10, -8),
8345 #endif
8346 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8347 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8348 BPF_EXIT_INSN(),
8349 },
8350 INTERNAL,
8351 { },
8352 { { 0, 0 } },
8353 .stack_depth = 8,
8354 },
8355 {
8356 "BPF_LDX_MEM | BPF_W, MSB set",
8357 .u.insns_int = {
8358 BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8359 BPF_LD_IMM64(R2, 0x0000000085868788ULL),
8360 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8361 #ifdef __BIG_ENDIAN
8362 BPF_LDX_MEM(BPF_W, R0, R10, -4),
8363 #else
8364 BPF_LDX_MEM(BPF_W, R0, R10, -8),
8365 #endif
8366 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8367 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8368 BPF_EXIT_INSN(),
8369 },
8370 INTERNAL,
8371 { },
8372 { { 0, 0 } },
8373 .stack_depth = 8,
8374 },
8375 {
8376 "BPF_LDX_MEM | BPF_W, negative offset",
8377 .u.insns_int = {
8378 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8379 BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8380 BPF_ALU64_IMM(BPF_ADD, R1, 512),
8381 BPF_STX_MEM(BPF_W, R1, R2, -256),
8382 BPF_LDX_MEM(BPF_W, R0, R1, -256),
8383 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8384 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8385 BPF_EXIT_INSN(),
8386 },
8387 INTERNAL | FLAG_LARGE_MEM,
8388 { },
8389 { { 512, 0 } },
8390 .stack_depth = 0,
8391 },
8392 {
8393 "BPF_LDX_MEM | BPF_W, small positive offset",
8394 .u.insns_int = {
8395 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8396 BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8397 BPF_STX_MEM(BPF_W, R1, R2, 256),
8398 BPF_LDX_MEM(BPF_W, R0, R1, 256),
8399 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8400 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8401 BPF_EXIT_INSN(),
8402 },
8403 INTERNAL | FLAG_LARGE_MEM,
8404 { },
8405 { { 512, 0 } },
8406 .stack_depth = 0,
8407 },
8408 {
8409 "BPF_LDX_MEM | BPF_W, large positive offset",
8410 .u.insns_int = {
8411 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8412 BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8413 BPF_STX_MEM(BPF_W, R1, R2, 16384),
8414 BPF_LDX_MEM(BPF_W, R0, R1, 16384),
8415 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8416 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8417 BPF_EXIT_INSN(),
8418 },
8419 INTERNAL | FLAG_LARGE_MEM,
8420 { },
8421 { { 16384 + 16, 0 } },
8422 .stack_depth = 0,
8423 },
8424 {
8425 "BPF_LDX_MEM | BPF_W, unaligned positive offset",
8426 .u.insns_int = {
8427 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8428 BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8429 BPF_STX_MEM(BPF_W, R1, R2, 13),
8430 BPF_LDX_MEM(BPF_W, R0, R1, 13),
8431 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8432 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8433 BPF_EXIT_INSN(),
8434 },
8435 INTERNAL | FLAG_LARGE_MEM,
8436 { },
8437 { { 32, 0 } },
8438 .stack_depth = 0,
8439 },
8440 {
8441 "BPF_LDX_MEM | BPF_DW, base",
8442 .u.insns_int = {
8443 BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8444 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8445 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8446 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8447 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8448 BPF_EXIT_INSN(),
8449 },
8450 INTERNAL,
8451 { },
8452 { { 0, 0 } },
8453 .stack_depth = 8,
8454 },
8455 {
8456 "BPF_LDX_MEM | BPF_DW, MSB set",
8457 .u.insns_int = {
8458 BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8459 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8460 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8461 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8462 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8463 BPF_EXIT_INSN(),
8464 },
8465 INTERNAL,
8466 { },
8467 { { 0, 0 } },
8468 .stack_depth = 8,
8469 },
8470 {
8471 "BPF_LDX_MEM | BPF_DW, negative offset",
8472 .u.insns_int = {
8473 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8474 BPF_ALU64_IMM(BPF_ADD, R1, 512),
8475 BPF_STX_MEM(BPF_DW, R1, R2, -256),
8476 BPF_LDX_MEM(BPF_DW, R0, R1, -256),
8477 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8478 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8479 BPF_EXIT_INSN(),
8480 },
8481 INTERNAL | FLAG_LARGE_MEM,
8482 { },
8483 { { 512, 0 } },
8484 .stack_depth = 0,
8485 },
8486 {
8487 "BPF_LDX_MEM | BPF_DW, small positive offset",
8488 .u.insns_int = {
8489 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8490 BPF_STX_MEM(BPF_DW, R1, R2, 256),
8491 BPF_LDX_MEM(BPF_DW, R0, R1, 256),
8492 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8493 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8494 BPF_EXIT_INSN(),
8495 },
8496 INTERNAL | FLAG_LARGE_MEM,
8497 { },
8498 { { 512, 0 } },
8499 .stack_depth = 8,
8500 },
8501 {
8502 "BPF_LDX_MEM | BPF_DW, large positive offset",
8503 .u.insns_int = {
8504 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8505 BPF_STX_MEM(BPF_DW, R1, R2, 32760),
8506 BPF_LDX_MEM(BPF_DW, R0, R1, 32760),
8507 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8508 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8509 BPF_EXIT_INSN(),
8510 },
8511 INTERNAL | FLAG_LARGE_MEM,
8512 { },
8513 { { 32768, 0 } },
8514 .stack_depth = 0,
8515 },
8516 {
8517 "BPF_LDX_MEM | BPF_DW, unaligned positive offset",
8518 .u.insns_int = {
8519 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8520 BPF_STX_MEM(BPF_DW, R1, R2, 13),
8521 BPF_LDX_MEM(BPF_DW, R0, R1, 13),
8522 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8523 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8524 BPF_EXIT_INSN(),
8525 },
8526 INTERNAL | FLAG_LARGE_MEM,
8527 { },
8528 { { 32, 0 } },
8529 .stack_depth = 0,
8530 },
8531 /* BPF_LDX_MEMSX B/H/W */
8532 {
8533 "BPF_LDX_MEMSX | BPF_B",
8534 .u.insns_int = {
8535 BPF_LD_IMM64(R1, 0xdead0000000000f0ULL),
8536 BPF_LD_IMM64(R2, 0xfffffffffffffff0ULL),
8537 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8538 #ifdef __BIG_ENDIAN
8539 BPF_LDX_MEMSX(BPF_B, R0, R10, -1),
8540 #else
8541 BPF_LDX_MEMSX(BPF_B, R0, R10, -8),
8542 #endif
8543 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8544 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8545 BPF_EXIT_INSN(),
8546 },
8547 INTERNAL,
8548 { },
8549 { { 0, 0 } },
8550 .stack_depth = 8,
8551 },
8552 {
8553 "BPF_LDX_MEMSX | BPF_H",
8554 .u.insns_int = {
8555 BPF_LD_IMM64(R1, 0xdead00000000f123ULL),
8556 BPF_LD_IMM64(R2, 0xfffffffffffff123ULL),
8557 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8558 #ifdef __BIG_ENDIAN
8559 BPF_LDX_MEMSX(BPF_H, R0, R10, -2),
8560 #else
8561 BPF_LDX_MEMSX(BPF_H, R0, R10, -8),
8562 #endif
8563 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8564 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8565 BPF_EXIT_INSN(),
8566 },
8567 INTERNAL,
8568 { },
8569 { { 0, 0 } },
8570 .stack_depth = 8,
8571 },
8572 {
8573 "BPF_LDX_MEMSX | BPF_W",
8574 .u.insns_int = {
8575 BPF_LD_IMM64(R1, 0x00000000deadbeefULL),
8576 BPF_LD_IMM64(R2, 0xffffffffdeadbeefULL),
8577 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8578 #ifdef __BIG_ENDIAN
8579 BPF_LDX_MEMSX(BPF_W, R0, R10, -4),
8580 #else
8581 BPF_LDX_MEMSX(BPF_W, R0, R10, -8),
8582 #endif
8583 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8584 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8585 BPF_EXIT_INSN(),
8586 },
8587 INTERNAL,
8588 { },
8589 { { 0, 0 } },
8590 .stack_depth = 8,
8591 },
8592 /* BPF_STX_MEM B/H/W/DW */
8593 {
8594 "BPF_STX_MEM | BPF_B",
8595 .u.insns_int = {
8596 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8597 BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8598 BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
8599 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8600 #ifdef __BIG_ENDIAN
8601 BPF_STX_MEM(BPF_B, R10, R2, -1),
8602 #else
8603 BPF_STX_MEM(BPF_B, R10, R2, -8),
8604 #endif
8605 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8606 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8607 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8608 BPF_EXIT_INSN(),
8609 },
8610 INTERNAL,
8611 { },
8612 { { 0, 0 } },
8613 .stack_depth = 8,
8614 },
8615 {
8616 "BPF_STX_MEM | BPF_B, MSB set",
8617 .u.insns_int = {
8618 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8619 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8620 BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
8621 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8622 #ifdef __BIG_ENDIAN
8623 BPF_STX_MEM(BPF_B, R10, R2, -1),
8624 #else
8625 BPF_STX_MEM(BPF_B, R10, R2, -8),
8626 #endif
8627 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8628 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8629 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8630 BPF_EXIT_INSN(),
8631 },
8632 INTERNAL,
8633 { },
8634 { { 0, 0 } },
8635 .stack_depth = 8,
8636 },
8637 {
8638 "BPF_STX_MEM | BPF_H",
8639 .u.insns_int = {
8640 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8641 BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8642 BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
8643 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8644 #ifdef __BIG_ENDIAN
8645 BPF_STX_MEM(BPF_H, R10, R2, -2),
8646 #else
8647 BPF_STX_MEM(BPF_H, R10, R2, -8),
8648 #endif
8649 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8650 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8651 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8652 BPF_EXIT_INSN(),
8653 },
8654 INTERNAL,
8655 { },
8656 { { 0, 0 } },
8657 .stack_depth = 8,
8658 },
8659 {
8660 "BPF_STX_MEM | BPF_H, MSB set",
8661 .u.insns_int = {
8662 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8663 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8664 BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
8665 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8666 #ifdef __BIG_ENDIAN
8667 BPF_STX_MEM(BPF_H, R10, R2, -2),
8668 #else
8669 BPF_STX_MEM(BPF_H, R10, R2, -8),
8670 #endif
8671 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8672 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8673 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8674 BPF_EXIT_INSN(),
8675 },
8676 INTERNAL,
8677 { },
8678 { { 0, 0 } },
8679 .stack_depth = 8,
8680 },
8681 {
8682 "BPF_STX_MEM | BPF_W",
8683 .u.insns_int = {
8684 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8685 BPF_LD_IMM64(R2, 0x0102030405060708ULL),
8686 BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
8687 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8688 #ifdef __BIG_ENDIAN
8689 BPF_STX_MEM(BPF_W, R10, R2, -4),
8690 #else
8691 BPF_STX_MEM(BPF_W, R10, R2, -8),
8692 #endif
8693 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8694 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8695 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8696 BPF_EXIT_INSN(),
8697 },
8698 INTERNAL,
8699 { },
8700 { { 0, 0 } },
8701 .stack_depth = 8,
8702 },
8703 {
8704 "BPF_STX_MEM | BPF_W, MSB set",
8705 .u.insns_int = {
8706 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
8707 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8708 BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
8709 BPF_STX_MEM(BPF_DW, R10, R1, -8),
8710 #ifdef __BIG_ENDIAN
8711 BPF_STX_MEM(BPF_W, R10, R2, -4),
8712 #else
8713 BPF_STX_MEM(BPF_W, R10, R2, -8),
8714 #endif
8715 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8716 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8717 BPF_ALU64_IMM(BPF_MOV, R0, 0),
8718 BPF_EXIT_INSN(),
8719 },
8720 INTERNAL,
8721 { },
8722 { { 0, 0 } },
8723 .stack_depth = 8,
8724 },
8725 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
8726 {
8727 "ST_MEM_B: Store/Load byte: max negative",
8728 .u.insns_int = {
8729 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8730 BPF_ST_MEM(BPF_B, R10, -40, 0xff),
8731 BPF_LDX_MEM(BPF_B, R0, R10, -40),
8732 BPF_EXIT_INSN(),
8733 },
8734 INTERNAL,
8735 { },
8736 { { 0, 0xff } },
8737 .stack_depth = 40,
8738 },
8739 {
8740 "ST_MEM_B: Store/Load byte: max positive",
8741 .u.insns_int = {
8742 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8743 BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
8744 BPF_LDX_MEM(BPF_H, R0, R10, -40),
8745 BPF_EXIT_INSN(),
8746 },
8747 INTERNAL,
8748 { },
8749 { { 0, 0x7f } },
8750 .stack_depth = 40,
8751 },
8752 {
8753 "STX_MEM_B: Store/Load byte: max negative",
8754 .u.insns_int = {
8755 BPF_LD_IMM64(R0, 0),
8756 BPF_LD_IMM64(R1, 0xffLL),
8757 BPF_STX_MEM(BPF_B, R10, R1, -40),
8758 BPF_LDX_MEM(BPF_B, R0, R10, -40),
8759 BPF_EXIT_INSN(),
8760 },
8761 INTERNAL,
8762 { },
8763 { { 0, 0xff } },
8764 .stack_depth = 40,
8765 },
8766 {
8767 "ST_MEM_H: Store/Load half word: max negative",
8768 .u.insns_int = {
8769 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8770 BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
8771 BPF_LDX_MEM(BPF_H, R0, R10, -40),
8772 BPF_EXIT_INSN(),
8773 },
8774 INTERNAL,
8775 { },
8776 { { 0, 0xffff } },
8777 .stack_depth = 40,
8778 },
8779 {
8780 "ST_MEM_H: Store/Load half word: max positive",
8781 .u.insns_int = {
8782 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8783 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
8784 BPF_LDX_MEM(BPF_H, R0, R10, -40),
8785 BPF_EXIT_INSN(),
8786 },
8787 INTERNAL,
8788 { },
8789 { { 0, 0x7fff } },
8790 .stack_depth = 40,
8791 },
8792 {
8793 "STX_MEM_H: Store/Load half word: max negative",
8794 .u.insns_int = {
8795 BPF_LD_IMM64(R0, 0),
8796 BPF_LD_IMM64(R1, 0xffffLL),
8797 BPF_STX_MEM(BPF_H, R10, R1, -40),
8798 BPF_LDX_MEM(BPF_H, R0, R10, -40),
8799 BPF_EXIT_INSN(),
8800 },
8801 INTERNAL,
8802 { },
8803 { { 0, 0xffff } },
8804 .stack_depth = 40,
8805 },
8806 {
8807 "ST_MEM_W: Store/Load word: max negative",
8808 .u.insns_int = {
8809 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8810 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
8811 BPF_LDX_MEM(BPF_W, R0, R10, -40),
8812 BPF_EXIT_INSN(),
8813 },
8814 INTERNAL,
8815 { },
8816 { { 0, 0xffffffff } },
8817 .stack_depth = 40,
8818 },
8819 {
8820 "ST_MEM_W: Store/Load word: max positive",
8821 .u.insns_int = {
8822 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8823 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
8824 BPF_LDX_MEM(BPF_W, R0, R10, -40),
8825 BPF_EXIT_INSN(),
8826 },
8827 INTERNAL,
8828 { },
8829 { { 0, 0x7fffffff } },
8830 .stack_depth = 40,
8831 },
8832 {
8833 "STX_MEM_W: Store/Load word: max negative",
8834 .u.insns_int = {
8835 BPF_LD_IMM64(R0, 0),
8836 BPF_LD_IMM64(R1, 0xffffffffLL),
8837 BPF_STX_MEM(BPF_W, R10, R1, -40),
8838 BPF_LDX_MEM(BPF_W, R0, R10, -40),
8839 BPF_EXIT_INSN(),
8840 },
8841 INTERNAL,
8842 { },
8843 { { 0, 0xffffffff } },
8844 .stack_depth = 40,
8845 },
8846 {
8847 "ST_MEM_DW: Store/Load double word: max negative",
8848 .u.insns_int = {
8849 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8850 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8851 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8852 BPF_EXIT_INSN(),
8853 },
8854 INTERNAL,
8855 { },
8856 { { 0, 0xffffffff } },
8857 .stack_depth = 40,
8858 },
8859 {
8860 "ST_MEM_DW: Store/Load double word: max negative 2",
8861 .u.insns_int = {
8862 BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
8863 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
8864 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
8865 BPF_LDX_MEM(BPF_DW, R2, R10, -40),
8866 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
8867 BPF_MOV32_IMM(R0, 2),
8868 BPF_EXIT_INSN(),
8869 BPF_MOV32_IMM(R0, 1),
8870 BPF_EXIT_INSN(),
8871 },
8872 INTERNAL,
8873 { },
8874 { { 0, 0x1 } },
8875 .stack_depth = 40,
8876 },
8877 {
8878 "ST_MEM_DW: Store/Load double word: max positive",
8879 .u.insns_int = {
8880 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8881 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
8882 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8883 BPF_EXIT_INSN(),
8884 },
8885 INTERNAL,
8886 { },
8887 { { 0, 0x7fffffff } },
8888 .stack_depth = 40,
8889 },
8890 {
8891 "STX_MEM_DW: Store/Load double word: max negative",
8892 .u.insns_int = {
8893 BPF_LD_IMM64(R0, 0),
8894 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8895 BPF_STX_MEM(BPF_DW, R10, R1, -40),
8896 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
8897 BPF_EXIT_INSN(),
8898 },
8899 INTERNAL,
8900 { },
8901 { { 0, 0xffffffff } },
8902 .stack_depth = 40,
8903 },
8904 {
8905 "STX_MEM_DW: Store double word: first word in memory",
8906 .u.insns_int = {
8907 BPF_LD_IMM64(R0, 0),
8908 BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8909 BPF_STX_MEM(BPF_DW, R10, R1, -40),
8910 BPF_LDX_MEM(BPF_W, R0, R10, -40),
8911 BPF_EXIT_INSN(),
8912 },
8913 INTERNAL,
8914 { },
8915 #ifdef __BIG_ENDIAN
8916 { { 0, 0x01234567 } },
8917 #else
8918 { { 0, 0x89abcdef } },
8919 #endif
8920 .stack_depth = 40,
8921 },
8922 {
8923 "STX_MEM_DW: Store double word: second word in memory",
8924 .u.insns_int = {
8925 BPF_LD_IMM64(R0, 0),
8926 BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
8927 BPF_STX_MEM(BPF_DW, R10, R1, -40),
8928 BPF_LDX_MEM(BPF_W, R0, R10, -36),
8929 BPF_EXIT_INSN(),
8930 },
8931 INTERNAL,
8932 { },
8933 #ifdef __BIG_ENDIAN
8934 { { 0, 0x89abcdef } },
8935 #else
8936 { { 0, 0x01234567 } },
8937 #endif
8938 .stack_depth = 40,
8939 },
8940 /* BPF_STX | BPF_ATOMIC | BPF_W/DW */
8941 {
8942 "STX_XADD_W: X + 1 + 1 + 1 + ...",
8943 { },
8944 INTERNAL,
8945 { },
8946 { { 0, 4134 } },
8947 .fill_helper = bpf_fill_stxw,
8948 },
8949 {
8950 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
8951 { },
8952 INTERNAL,
8953 { },
8954 { { 0, 4134 } },
8955 .fill_helper = bpf_fill_stxdw,
8956 },
8957 /*
8958 * Exhaustive tests of atomic operation variants.
8959 * Individual tests are expanded from template macros for all
8960 * combinations of ALU operation, word size and fetching.
8961 */
8962 #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
8963
8964 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result) \
8965 { \
8966 "BPF_ATOMIC | " #width ", " #op ": Test: " \
8967 #old " " #logic " " #update " = " #result, \
8968 .u.insns_int = { \
8969 BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)), \
8970 BPF_ST_MEM(width, R10, -40, old), \
8971 BPF_ATOMIC_OP(width, op, R10, R5, -40), \
8972 BPF_LDX_MEM(width, R0, R10, -40), \
8973 BPF_ALU64_REG(BPF_MOV, R1, R0), \
8974 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
8975 BPF_ALU64_REG(BPF_OR, R0, R1), \
8976 BPF_EXIT_INSN(), \
8977 }, \
8978 INTERNAL, \
8979 { }, \
8980 { { 0, result } }, \
8981 .stack_depth = 40, \
8982 }
8983 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result) \
8984 { \
8985 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: " \
8986 #old " " #logic " " #update " = " #result, \
8987 .u.insns_int = { \
8988 BPF_ALU64_REG(BPF_MOV, R1, R10), \
8989 BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)), \
8990 BPF_ST_MEM(BPF_W, R10, -40, old), \
8991 BPF_ATOMIC_OP(width, op, R10, R0, -40), \
8992 BPF_ALU64_REG(BPF_MOV, R0, R10), \
8993 BPF_ALU64_REG(BPF_SUB, R0, R1), \
8994 BPF_ALU64_REG(BPF_MOV, R1, R0), \
8995 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
8996 BPF_ALU64_REG(BPF_OR, R0, R1), \
8997 BPF_EXIT_INSN(), \
8998 }, \
8999 INTERNAL, \
9000 { }, \
9001 { { 0, 0 } }, \
9002 .stack_depth = 40, \
9003 }
9004 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result) \
9005 { \
9006 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: " \
9007 #old " " #logic " " #update " = " #result, \
9008 .u.insns_int = { \
9009 BPF_ALU64_REG(BPF_MOV, R0, R10), \
9010 BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)), \
9011 BPF_ST_MEM(width, R10, -40, old), \
9012 BPF_ATOMIC_OP(width, op, R10, R1, -40), \
9013 BPF_ALU64_REG(BPF_SUB, R0, R10), \
9014 BPF_ALU64_REG(BPF_MOV, R1, R0), \
9015 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
9016 BPF_ALU64_REG(BPF_OR, R0, R1), \
9017 BPF_EXIT_INSN(), \
9018 }, \
9019 INTERNAL, \
9020 { }, \
9021 { { 0, 0 } }, \
9022 .stack_depth = 40, \
9023 }
9024 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result) \
9025 { \
9026 "BPF_ATOMIC | " #width ", " #op ": Test fetch: " \
9027 #old " " #logic " " #update " = " #result, \
9028 .u.insns_int = { \
9029 BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)), \
9030 BPF_ST_MEM(width, R10, -40, old), \
9031 BPF_ATOMIC_OP(width, op, R10, R3, -40), \
9032 BPF_ALU32_REG(BPF_MOV, R0, R3), \
9033 BPF_EXIT_INSN(), \
9034 }, \
9035 INTERNAL, \
9036 { }, \
9037 { { 0, (op) & BPF_FETCH ? old : update } }, \
9038 .stack_depth = 40, \
9039 }
9040 /* BPF_ATOMIC | BPF_W: BPF_ADD */
9041 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9042 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9043 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9044 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
9045 /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
9046 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9047 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9048 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9049 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9050 /* BPF_ATOMIC | BPF_DW: BPF_ADD */
9051 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9052 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9053 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9054 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
9055 /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
9056 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9057 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9058 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9059 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
9060 /* BPF_ATOMIC | BPF_W: BPF_AND */
9061 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9062 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9063 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9064 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
9065 /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
9066 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9067 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9068 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9069 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9070 /* BPF_ATOMIC | BPF_DW: BPF_AND */
9071 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9072 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9073 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9074 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
9075 /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
9076 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9077 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9078 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9079 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
9080 /* BPF_ATOMIC | BPF_W: BPF_OR */
9081 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9082 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9083 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9084 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
9085 /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
9086 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9087 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9088 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9089 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9090 /* BPF_ATOMIC | BPF_DW: BPF_OR */
9091 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9092 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9093 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9094 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
9095 /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
9096 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9097 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9098 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9099 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
9100 /* BPF_ATOMIC | BPF_W: BPF_XOR */
9101 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9102 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9103 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9104 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9105 /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
9106 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9107 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9108 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9109 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9110 /* BPF_ATOMIC | BPF_DW: BPF_XOR */
9111 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9112 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9113 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9114 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
9115 /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
9116 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9117 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9118 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9119 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
9120 /* BPF_ATOMIC | BPF_W: BPF_XCHG */
9121 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9122 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9123 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9124 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9125 /* BPF_ATOMIC | BPF_DW: BPF_XCHG */
9126 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9127 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9128 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9129 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
9130 #undef BPF_ATOMIC_POISON
9131 #undef BPF_ATOMIC_OP_TEST1
9132 #undef BPF_ATOMIC_OP_TEST2
9133 #undef BPF_ATOMIC_OP_TEST3
9134 #undef BPF_ATOMIC_OP_TEST4
9135 /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
9136 {
9137 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
9138 .u.insns_int = {
9139 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9140 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9141 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9142 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9143 BPF_EXIT_INSN(),
9144 },
9145 INTERNAL,
9146 { },
9147 { { 0, 0x01234567 } },
9148 .stack_depth = 40,
9149 },
9150 {
9151 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
9152 .u.insns_int = {
9153 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9154 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9155 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9156 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9157 BPF_LDX_MEM(BPF_W, R0, R10, -40),
9158 BPF_EXIT_INSN(),
9159 },
9160 INTERNAL,
9161 { },
9162 { { 0, 0x89abcdef } },
9163 .stack_depth = 40,
9164 },
9165 {
9166 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
9167 .u.insns_int = {
9168 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9169 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
9170 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9171 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9172 BPF_EXIT_INSN(),
9173 },
9174 INTERNAL,
9175 { },
9176 { { 0, 0x01234567 } },
9177 .stack_depth = 40,
9178 },
9179 {
9180 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
9181 .u.insns_int = {
9182 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9183 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
9184 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9185 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9186 BPF_LDX_MEM(BPF_W, R0, R10, -40),
9187 BPF_EXIT_INSN(),
9188 },
9189 INTERNAL,
9190 { },
9191 { { 0, 0x01234567 } },
9192 .stack_depth = 40,
9193 },
9194 {
9195 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
9196 .u.insns_int = {
9197 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
9198 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
9199 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
9200 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9201 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
9202 BPF_ALU32_REG(BPF_MOV, R0, R3),
9203 BPF_EXIT_INSN(),
9204 },
9205 INTERNAL,
9206 { },
9207 { { 0, 0x89abcdef } },
9208 .stack_depth = 40,
9209 },
9210 /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
9211 {
9212 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
9213 .u.insns_int = {
9214 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9215 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9216 BPF_ALU64_REG(BPF_MOV, R0, R1),
9217 BPF_STX_MEM(BPF_DW, R10, R1, -40),
9218 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9219 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9220 BPF_ALU64_REG(BPF_SUB, R0, R1),
9221 BPF_EXIT_INSN(),
9222 },
9223 INTERNAL,
9224 { },
9225 { { 0, 0 } },
9226 .stack_depth = 40,
9227 },
9228 {
9229 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
9230 .u.insns_int = {
9231 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9232 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9233 BPF_ALU64_REG(BPF_MOV, R0, R1),
9234 BPF_STX_MEM(BPF_DW, R10, R0, -40),
9235 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9236 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
9237 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
9238 BPF_ALU64_REG(BPF_SUB, R0, R2),
9239 BPF_EXIT_INSN(),
9240 },
9241 INTERNAL,
9242 { },
9243 { { 0, 0 } },
9244 .stack_depth = 40,
9245 },
9246 {
9247 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
9248 .u.insns_int = {
9249 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9250 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9251 BPF_ALU64_REG(BPF_MOV, R0, R1),
9252 BPF_ALU64_IMM(BPF_ADD, R0, 1),
9253 BPF_STX_MEM(BPF_DW, R10, R1, -40),
9254 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9255 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9256 BPF_ALU64_REG(BPF_SUB, R0, R1),
9257 BPF_EXIT_INSN(),
9258 },
9259 INTERNAL,
9260 { },
9261 { { 0, 0 } },
9262 .stack_depth = 40,
9263 },
9264 {
9265 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
9266 .u.insns_int = {
9267 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9268 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9269 BPF_ALU64_REG(BPF_MOV, R0, R1),
9270 BPF_ALU64_IMM(BPF_ADD, R0, 1),
9271 BPF_STX_MEM(BPF_DW, R10, R1, -40),
9272 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9273 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
9274 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
9275 BPF_ALU64_REG(BPF_SUB, R0, R1),
9276 BPF_EXIT_INSN(),
9277 },
9278 INTERNAL,
9279 { },
9280 { { 0, 0 } },
9281 .stack_depth = 40,
9282 },
9283 {
9284 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
9285 .u.insns_int = {
9286 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
9287 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
9288 BPF_ALU64_REG(BPF_MOV, R0, R1),
9289 BPF_STX_MEM(BPF_DW, R10, R1, -40),
9290 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
9291 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
9292 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
9293 BPF_ALU64_REG(BPF_SUB, R0, R2),
9294 BPF_EXIT_INSN(),
9295 },
9296 INTERNAL,
9297 { },
9298 { { 0, 0 } },
9299 .stack_depth = 40,
9300 },
9301 /* BPF_JMP32 | BPF_JEQ | BPF_K */
9302 {
9303 "JMP32_JEQ_K: Small immediate",
9304 .u.insns_int = {
9305 BPF_ALU32_IMM(BPF_MOV, R0, 123),
9306 BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
9307 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
9308 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9309 BPF_EXIT_INSN(),
9310 },
9311 INTERNAL,
9312 { },
9313 { { 0, 123 } }
9314 },
9315 {
9316 "JMP32_JEQ_K: Large immediate",
9317 .u.insns_int = {
9318 BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
9319 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
9320 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
9321 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9322 BPF_EXIT_INSN(),
9323 },
9324 INTERNAL,
9325 { },
9326 { { 0, 12345678 } }
9327 },
9328 {
9329 "JMP32_JEQ_K: negative immediate",
9330 .u.insns_int = {
9331 BPF_ALU32_IMM(BPF_MOV, R0, -123),
9332 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
9333 BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
9334 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9335 BPF_EXIT_INSN(),
9336 },
9337 INTERNAL,
9338 { },
9339 { { 0, -123 } }
9340 },
9341 /* BPF_JMP32 | BPF_JEQ | BPF_X */
9342 {
9343 "JMP32_JEQ_X",
9344 .u.insns_int = {
9345 BPF_ALU32_IMM(BPF_MOV, R0, 1234),
9346 BPF_ALU32_IMM(BPF_MOV, R1, 4321),
9347 BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
9348 BPF_ALU32_IMM(BPF_MOV, R1, 1234),
9349 BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
9350 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9351 BPF_EXIT_INSN(),
9352 },
9353 INTERNAL,
9354 { },
9355 { { 0, 1234 } }
9356 },
9357 /* BPF_JMP32 | BPF_JNE | BPF_K */
9358 {
9359 "JMP32_JNE_K: Small immediate",
9360 .u.insns_int = {
9361 BPF_ALU32_IMM(BPF_MOV, R0, 123),
9362 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
9363 BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
9364 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9365 BPF_EXIT_INSN(),
9366 },
9367 INTERNAL,
9368 { },
9369 { { 0, 123 } }
9370 },
9371 {
9372 "JMP32_JNE_K: Large immediate",
9373 .u.insns_int = {
9374 BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
9375 BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
9376 BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
9377 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9378 BPF_EXIT_INSN(),
9379 },
9380 INTERNAL,
9381 { },
9382 { { 0, 12345678 } }
9383 },
9384 {
9385 "JMP32_JNE_K: negative immediate",
9386 .u.insns_int = {
9387 BPF_ALU32_IMM(BPF_MOV, R0, -123),
9388 BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
9389 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
9390 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9391 BPF_EXIT_INSN(),
9392 },
9393 INTERNAL,
9394 { },
9395 { { 0, -123 } }
9396 },
9397 /* BPF_JMP32 | BPF_JNE | BPF_X */
9398 {
9399 "JMP32_JNE_X",
9400 .u.insns_int = {
9401 BPF_ALU32_IMM(BPF_MOV, R0, 1234),
9402 BPF_ALU32_IMM(BPF_MOV, R1, 1234),
9403 BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
9404 BPF_ALU32_IMM(BPF_MOV, R1, 4321),
9405 BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
9406 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9407 BPF_EXIT_INSN(),
9408 },
9409 INTERNAL,
9410 { },
9411 { { 0, 1234 } }
9412 },
9413 /* BPF_JMP32 | BPF_JSET | BPF_K */
9414 {
9415 "JMP32_JSET_K: Small immediate",
9416 .u.insns_int = {
9417 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9418 BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
9419 BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
9420 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9421 BPF_EXIT_INSN(),
9422 },
9423 INTERNAL,
9424 { },
9425 { { 0, 1 } }
9426 },
9427 {
9428 "JMP32_JSET_K: Large immediate",
9429 .u.insns_int = {
9430 BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
9431 BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
9432 BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
9433 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9434 BPF_EXIT_INSN(),
9435 },
9436 INTERNAL,
9437 { },
9438 { { 0, 0x40000000 } }
9439 },
9440 {
9441 "JMP32_JSET_K: negative immediate",
9442 .u.insns_int = {
9443 BPF_ALU32_IMM(BPF_MOV, R0, -123),
9444 BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
9445 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9446 BPF_EXIT_INSN(),
9447 },
9448 INTERNAL,
9449 { },
9450 { { 0, -123 } }
9451 },
9452 /* BPF_JMP32 | BPF_JSET | BPF_X */
9453 {
9454 "JMP32_JSET_X",
9455 .u.insns_int = {
9456 BPF_ALU32_IMM(BPF_MOV, R0, 8),
9457 BPF_ALU32_IMM(BPF_MOV, R1, 7),
9458 BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
9459 BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
9460 BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
9461 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9462 BPF_EXIT_INSN(),
9463 },
9464 INTERNAL,
9465 { },
9466 { { 0, 8 } }
9467 },
9468 /* BPF_JMP32 | BPF_JGT | BPF_K */
9469 {
9470 "JMP32_JGT_K: Small immediate",
9471 .u.insns_int = {
9472 BPF_ALU32_IMM(BPF_MOV, R0, 123),
9473 BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
9474 BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
9475 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9476 BPF_EXIT_INSN(),
9477 },
9478 INTERNAL,
9479 { },
9480 { { 0, 123 } }
9481 },
9482 {
9483 "JMP32_JGT_K: Large immediate",
9484 .u.insns_int = {
9485 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9486 BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
9487 BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
9488 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9489 BPF_EXIT_INSN(),
9490 },
9491 INTERNAL,
9492 { },
9493 { { 0, 0xfffffffe } }
9494 },
9495 /* BPF_JMP32 | BPF_JGT | BPF_X */
9496 {
9497 "JMP32_JGT_X",
9498 .u.insns_int = {
9499 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9500 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9501 BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
9502 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9503 BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
9504 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9505 BPF_EXIT_INSN(),
9506 },
9507 INTERNAL,
9508 { },
9509 { { 0, 0xfffffffe } }
9510 },
9511 /* BPF_JMP32 | BPF_JGE | BPF_K */
9512 {
9513 "JMP32_JGE_K: Small immediate",
9514 .u.insns_int = {
9515 BPF_ALU32_IMM(BPF_MOV, R0, 123),
9516 BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
9517 BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
9518 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9519 BPF_EXIT_INSN(),
9520 },
9521 INTERNAL,
9522 { },
9523 { { 0, 123 } }
9524 },
9525 {
9526 "JMP32_JGE_K: Large immediate",
9527 .u.insns_int = {
9528 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9529 BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
9530 BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
9531 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9532 BPF_EXIT_INSN(),
9533 },
9534 INTERNAL,
9535 { },
9536 { { 0, 0xfffffffe } }
9537 },
9538 /* BPF_JMP32 | BPF_JGE | BPF_X */
9539 {
9540 "JMP32_JGE_X",
9541 .u.insns_int = {
9542 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9543 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9544 BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
9545 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9546 BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
9547 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9548 BPF_EXIT_INSN(),
9549 },
9550 INTERNAL,
9551 { },
9552 { { 0, 0xfffffffe } }
9553 },
9554 /* BPF_JMP32 | BPF_JLT | BPF_K */
9555 {
9556 "JMP32_JLT_K: Small immediate",
9557 .u.insns_int = {
9558 BPF_ALU32_IMM(BPF_MOV, R0, 123),
9559 BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
9560 BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
9561 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9562 BPF_EXIT_INSN(),
9563 },
9564 INTERNAL,
9565 { },
9566 { { 0, 123 } }
9567 },
9568 {
9569 "JMP32_JLT_K: Large immediate",
9570 .u.insns_int = {
9571 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9572 BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
9573 BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
9574 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9575 BPF_EXIT_INSN(),
9576 },
9577 INTERNAL,
9578 { },
9579 { { 0, 0xfffffffe } }
9580 },
9581 /* BPF_JMP32 | BPF_JLT | BPF_X */
9582 {
9583 "JMP32_JLT_X",
9584 .u.insns_int = {
9585 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9586 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9587 BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
9588 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
9589 BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
9590 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9591 BPF_EXIT_INSN(),
9592 },
9593 INTERNAL,
9594 { },
9595 { { 0, 0xfffffffe } }
9596 },
9597 /* BPF_JMP32 | BPF_JLE | BPF_K */
9598 {
9599 "JMP32_JLE_K: Small immediate",
9600 .u.insns_int = {
9601 BPF_ALU32_IMM(BPF_MOV, R0, 123),
9602 BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
9603 BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
9604 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9605 BPF_EXIT_INSN(),
9606 },
9607 INTERNAL,
9608 { },
9609 { { 0, 123 } }
9610 },
9611 {
9612 "JMP32_JLE_K: Large immediate",
9613 .u.insns_int = {
9614 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9615 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
9616 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
9617 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9618 BPF_EXIT_INSN(),
9619 },
9620 INTERNAL,
9621 { },
9622 { { 0, 0xfffffffe } }
9623 },
9624 /* BPF_JMP32 | BPF_JLE | BPF_X */
9625 {
9626 "JMP32_JLE_X",
9627 .u.insns_int = {
9628 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
9629 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
9630 BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
9631 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
9632 BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
9633 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9634 BPF_EXIT_INSN(),
9635 },
9636 INTERNAL,
9637 { },
9638 { { 0, 0xfffffffe } }
9639 },
9640 /* BPF_JMP32 | BPF_JSGT | BPF_K */
9641 {
9642 "JMP32_JSGT_K: Small immediate",
9643 .u.insns_int = {
9644 BPF_ALU32_IMM(BPF_MOV, R0, -123),
9645 BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
9646 BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
9647 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9648 BPF_EXIT_INSN(),
9649 },
9650 INTERNAL,
9651 { },
9652 { { 0, -123 } }
9653 },
9654 {
9655 "JMP32_JSGT_K: Large immediate",
9656 .u.insns_int = {
9657 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9658 BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
9659 BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
9660 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9661 BPF_EXIT_INSN(),
9662 },
9663 INTERNAL,
9664 { },
9665 { { 0, -12345678 } }
9666 },
9667 /* BPF_JMP32 | BPF_JSGT | BPF_X */
9668 {
9669 "JMP32_JSGT_X",
9670 .u.insns_int = {
9671 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9672 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9673 BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
9674 BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9675 BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
9676 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9677 BPF_EXIT_INSN(),
9678 },
9679 INTERNAL,
9680 { },
9681 { { 0, -12345678 } }
9682 },
9683 /* BPF_JMP32 | BPF_JSGE | BPF_K */
9684 {
9685 "JMP32_JSGE_K: Small immediate",
9686 .u.insns_int = {
9687 BPF_ALU32_IMM(BPF_MOV, R0, -123),
9688 BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
9689 BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
9690 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9691 BPF_EXIT_INSN(),
9692 },
9693 INTERNAL,
9694 { },
9695 { { 0, -123 } }
9696 },
9697 {
9698 "JMP32_JSGE_K: Large immediate",
9699 .u.insns_int = {
9700 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9701 BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
9702 BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
9703 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9704 BPF_EXIT_INSN(),
9705 },
9706 INTERNAL,
9707 { },
9708 { { 0, -12345678 } }
9709 },
9710 /* BPF_JMP32 | BPF_JSGE | BPF_X */
9711 {
9712 "JMP32_JSGE_X",
9713 .u.insns_int = {
9714 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9715 BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9716 BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
9717 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9718 BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
9719 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9720 BPF_EXIT_INSN(),
9721 },
9722 INTERNAL,
9723 { },
9724 { { 0, -12345678 } }
9725 },
9726 /* BPF_JMP32 | BPF_JSLT | BPF_K */
9727 {
9728 "JMP32_JSLT_K: Small immediate",
9729 .u.insns_int = {
9730 BPF_ALU32_IMM(BPF_MOV, R0, -123),
9731 BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
9732 BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
9733 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9734 BPF_EXIT_INSN(),
9735 },
9736 INTERNAL,
9737 { },
9738 { { 0, -123 } }
9739 },
9740 {
9741 "JMP32_JSLT_K: Large immediate",
9742 .u.insns_int = {
9743 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9744 BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
9745 BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
9746 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9747 BPF_EXIT_INSN(),
9748 },
9749 INTERNAL,
9750 { },
9751 { { 0, -12345678 } }
9752 },
9753 /* BPF_JMP32 | BPF_JSLT | BPF_X */
9754 {
9755 "JMP32_JSLT_X",
9756 .u.insns_int = {
9757 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9758 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9759 BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
9760 BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
9761 BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
9762 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9763 BPF_EXIT_INSN(),
9764 },
9765 INTERNAL,
9766 { },
9767 { { 0, -12345678 } }
9768 },
9769 /* BPF_JMP32 | BPF_JSLE | BPF_K */
9770 {
9771 "JMP32_JSLE_K: Small immediate",
9772 .u.insns_int = {
9773 BPF_ALU32_IMM(BPF_MOV, R0, -123),
9774 BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
9775 BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
9776 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9777 BPF_EXIT_INSN(),
9778 },
9779 INTERNAL,
9780 { },
9781 { { 0, -123 } }
9782 },
9783 {
9784 "JMP32_JSLE_K: Large immediate",
9785 .u.insns_int = {
9786 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9787 BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
9788 BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
9789 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9790 BPF_EXIT_INSN(),
9791 },
9792 INTERNAL,
9793 { },
9794 { { 0, -12345678 } }
9795 },
9796 /* BPF_JMP32 | BPF_JSLE | BPF_K */
9797 {
9798 "JMP32_JSLE_X",
9799 .u.insns_int = {
9800 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
9801 BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
9802 BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
9803 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
9804 BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
9805 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9806 BPF_EXIT_INSN(),
9807 },
9808 INTERNAL,
9809 { },
9810 { { 0, -12345678 } }
9811 },
9812 /* BPF_JMP | BPF_EXIT */
9813 {
9814 "JMP_EXIT",
9815 .u.insns_int = {
9816 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
9817 BPF_EXIT_INSN(),
9818 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
9819 },
9820 INTERNAL,
9821 { },
9822 { { 0, 0x4711 } },
9823 },
9824 /* BPF_JMP | BPF_JA */
9825 {
9826 "JMP_JA: Unconditional jump: if (true) return 1",
9827 .u.insns_int = {
9828 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9829 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
9830 BPF_EXIT_INSN(),
9831 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9832 BPF_EXIT_INSN(),
9833 },
9834 INTERNAL,
9835 { },
9836 { { 0, 1 } },
9837 },
9838 /* BPF_JMP32 | BPF_JA */
9839 {
9840 "JMP32_JA: Unconditional jump: if (true) return 1",
9841 .u.insns_int = {
9842 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9843 BPF_JMP32_IMM(BPF_JA, 0, 1, 0),
9844 BPF_EXIT_INSN(),
9845 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9846 BPF_EXIT_INSN(),
9847 },
9848 INTERNAL,
9849 { },
9850 { { 0, 1 } },
9851 },
9852 /* BPF_JMP | BPF_JSLT | BPF_K */
9853 {
9854 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
9855 .u.insns_int = {
9856 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9857 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9858 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9859 BPF_EXIT_INSN(),
9860 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9861 BPF_EXIT_INSN(),
9862 },
9863 INTERNAL,
9864 { },
9865 { { 0, 1 } },
9866 },
9867 {
9868 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
9869 .u.insns_int = {
9870 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9871 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9872 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
9873 BPF_EXIT_INSN(),
9874 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9875 BPF_EXIT_INSN(),
9876 },
9877 INTERNAL,
9878 { },
9879 { { 0, 1 } },
9880 },
9881 /* BPF_JMP | BPF_JSGT | BPF_K */
9882 {
9883 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
9884 .u.insns_int = {
9885 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9886 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9887 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
9888 BPF_EXIT_INSN(),
9889 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9890 BPF_EXIT_INSN(),
9891 },
9892 INTERNAL,
9893 { },
9894 { { 0, 1 } },
9895 },
9896 {
9897 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
9898 .u.insns_int = {
9899 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9900 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9901 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
9902 BPF_EXIT_INSN(),
9903 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9904 BPF_EXIT_INSN(),
9905 },
9906 INTERNAL,
9907 { },
9908 { { 0, 1 } },
9909 },
9910 /* BPF_JMP | BPF_JSLE | BPF_K */
9911 {
9912 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
9913 .u.insns_int = {
9914 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9915 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
9916 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9917 BPF_EXIT_INSN(),
9918 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9919 BPF_EXIT_INSN(),
9920 },
9921 INTERNAL,
9922 { },
9923 { { 0, 1 } },
9924 },
9925 {
9926 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
9927 .u.insns_int = {
9928 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9929 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9930 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
9931 BPF_EXIT_INSN(),
9932 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9933 BPF_EXIT_INSN(),
9934 },
9935 INTERNAL,
9936 { },
9937 { { 0, 1 } },
9938 },
9939 {
9940 "JMP_JSLE_K: Signed jump: value walk 1",
9941 .u.insns_int = {
9942 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9943 BPF_LD_IMM64(R1, 3),
9944 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
9945 BPF_ALU64_IMM(BPF_SUB, R1, 1),
9946 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9947 BPF_ALU64_IMM(BPF_SUB, R1, 1),
9948 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9949 BPF_ALU64_IMM(BPF_SUB, R1, 1),
9950 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9951 BPF_EXIT_INSN(), /* bad exit */
9952 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
9953 BPF_EXIT_INSN(),
9954 },
9955 INTERNAL,
9956 { },
9957 { { 0, 1 } },
9958 },
9959 {
9960 "JMP_JSLE_K: Signed jump: value walk 2",
9961 .u.insns_int = {
9962 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9963 BPF_LD_IMM64(R1, 3),
9964 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
9965 BPF_ALU64_IMM(BPF_SUB, R1, 2),
9966 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
9967 BPF_ALU64_IMM(BPF_SUB, R1, 2),
9968 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
9969 BPF_EXIT_INSN(), /* bad exit */
9970 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
9971 BPF_EXIT_INSN(),
9972 },
9973 INTERNAL,
9974 { },
9975 { { 0, 1 } },
9976 },
9977 /* BPF_JMP | BPF_JSGE | BPF_K */
9978 {
9979 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
9980 .u.insns_int = {
9981 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9982 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9983 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
9984 BPF_EXIT_INSN(),
9985 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9986 BPF_EXIT_INSN(),
9987 },
9988 INTERNAL,
9989 { },
9990 { { 0, 1 } },
9991 },
9992 {
9993 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
9994 .u.insns_int = {
9995 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9996 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
9997 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
9998 BPF_EXIT_INSN(),
9999 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10000 BPF_EXIT_INSN(),
10001 },
10002 INTERNAL,
10003 { },
10004 { { 0, 1 } },
10005 },
10006 {
10007 "JMP_JSGE_K: Signed jump: value walk 1",
10008 .u.insns_int = {
10009 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10010 BPF_LD_IMM64(R1, -3),
10011 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
10012 BPF_ALU64_IMM(BPF_ADD, R1, 1),
10013 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
10014 BPF_ALU64_IMM(BPF_ADD, R1, 1),
10015 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
10016 BPF_ALU64_IMM(BPF_ADD, R1, 1),
10017 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
10018 BPF_EXIT_INSN(), /* bad exit */
10019 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
10020 BPF_EXIT_INSN(),
10021 },
10022 INTERNAL,
10023 { },
10024 { { 0, 1 } },
10025 },
10026 {
10027 "JMP_JSGE_K: Signed jump: value walk 2",
10028 .u.insns_int = {
10029 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10030 BPF_LD_IMM64(R1, -3),
10031 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
10032 BPF_ALU64_IMM(BPF_ADD, R1, 2),
10033 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
10034 BPF_ALU64_IMM(BPF_ADD, R1, 2),
10035 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
10036 BPF_EXIT_INSN(), /* bad exit */
10037 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
10038 BPF_EXIT_INSN(),
10039 },
10040 INTERNAL,
10041 { },
10042 { { 0, 1 } },
10043 },
10044 /* BPF_JMP | BPF_JGT | BPF_K */
10045 {
10046 "JMP_JGT_K: if (3 > 2) return 1",
10047 .u.insns_int = {
10048 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10049 BPF_LD_IMM64(R1, 3),
10050 BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
10051 BPF_EXIT_INSN(),
10052 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10053 BPF_EXIT_INSN(),
10054 },
10055 INTERNAL,
10056 { },
10057 { { 0, 1 } },
10058 },
10059 {
10060 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
10061 .u.insns_int = {
10062 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10063 BPF_LD_IMM64(R1, -1),
10064 BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
10065 BPF_EXIT_INSN(),
10066 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10067 BPF_EXIT_INSN(),
10068 },
10069 INTERNAL,
10070 { },
10071 { { 0, 1 } },
10072 },
10073 /* BPF_JMP | BPF_JLT | BPF_K */
10074 {
10075 "JMP_JLT_K: if (2 < 3) return 1",
10076 .u.insns_int = {
10077 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10078 BPF_LD_IMM64(R1, 2),
10079 BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
10080 BPF_EXIT_INSN(),
10081 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10082 BPF_EXIT_INSN(),
10083 },
10084 INTERNAL,
10085 { },
10086 { { 0, 1 } },
10087 },
10088 {
10089 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
10090 .u.insns_int = {
10091 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10092 BPF_LD_IMM64(R1, 1),
10093 BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
10094 BPF_EXIT_INSN(),
10095 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10096 BPF_EXIT_INSN(),
10097 },
10098 INTERNAL,
10099 { },
10100 { { 0, 1 } },
10101 },
10102 /* BPF_JMP | BPF_JGE | BPF_K */
10103 {
10104 "JMP_JGE_K: if (3 >= 2) return 1",
10105 .u.insns_int = {
10106 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10107 BPF_LD_IMM64(R1, 3),
10108 BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
10109 BPF_EXIT_INSN(),
10110 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10111 BPF_EXIT_INSN(),
10112 },
10113 INTERNAL,
10114 { },
10115 { { 0, 1 } },
10116 },
10117 /* BPF_JMP | BPF_JLE | BPF_K */
10118 {
10119 "JMP_JLE_K: if (2 <= 3) return 1",
10120 .u.insns_int = {
10121 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10122 BPF_LD_IMM64(R1, 2),
10123 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
10124 BPF_EXIT_INSN(),
10125 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10126 BPF_EXIT_INSN(),
10127 },
10128 INTERNAL,
10129 { },
10130 { { 0, 1 } },
10131 },
10132 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
10133 {
10134 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
10135 .u.insns_int = {
10136 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
10137 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
10138 BPF_EXIT_INSN(),
10139 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
10140 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
10141 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
10142 BPF_EXIT_INSN(),
10143 },
10144 INTERNAL,
10145 { },
10146 { { 0, 1 } },
10147 },
10148 {
10149 "JMP_JGE_K: if (3 >= 3) return 1",
10150 .u.insns_int = {
10151 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10152 BPF_LD_IMM64(R1, 3),
10153 BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
10154 BPF_EXIT_INSN(),
10155 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10156 BPF_EXIT_INSN(),
10157 },
10158 INTERNAL,
10159 { },
10160 { { 0, 1 } },
10161 },
10162 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
10163 {
10164 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
10165 .u.insns_int = {
10166 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
10167 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
10168 BPF_EXIT_INSN(),
10169 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
10170 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
10171 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
10172 BPF_EXIT_INSN(),
10173 },
10174 INTERNAL,
10175 { },
10176 { { 0, 1 } },
10177 },
10178 {
10179 "JMP_JLE_K: if (3 <= 3) return 1",
10180 .u.insns_int = {
10181 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10182 BPF_LD_IMM64(R1, 3),
10183 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
10184 BPF_EXIT_INSN(),
10185 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10186 BPF_EXIT_INSN(),
10187 },
10188 INTERNAL,
10189 { },
10190 { { 0, 1 } },
10191 },
10192 /* BPF_JMP | BPF_JNE | BPF_K */
10193 {
10194 "JMP_JNE_K: if (3 != 2) return 1",
10195 .u.insns_int = {
10196 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10197 BPF_LD_IMM64(R1, 3),
10198 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
10199 BPF_EXIT_INSN(),
10200 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10201 BPF_EXIT_INSN(),
10202 },
10203 INTERNAL,
10204 { },
10205 { { 0, 1 } },
10206 },
10207 /* BPF_JMP | BPF_JEQ | BPF_K */
10208 {
10209 "JMP_JEQ_K: if (3 == 3) return 1",
10210 .u.insns_int = {
10211 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10212 BPF_LD_IMM64(R1, 3),
10213 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
10214 BPF_EXIT_INSN(),
10215 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10216 BPF_EXIT_INSN(),
10217 },
10218 INTERNAL,
10219 { },
10220 { { 0, 1 } },
10221 },
10222 /* BPF_JMP | BPF_JSET | BPF_K */
10223 {
10224 "JMP_JSET_K: if (0x3 & 0x2) return 1",
10225 .u.insns_int = {
10226 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10227 BPF_LD_IMM64(R1, 3),
10228 BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
10229 BPF_EXIT_INSN(),
10230 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10231 BPF_EXIT_INSN(),
10232 },
10233 INTERNAL,
10234 { },
10235 { { 0, 1 } },
10236 },
10237 {
10238 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
10239 .u.insns_int = {
10240 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10241 BPF_LD_IMM64(R1, 3),
10242 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
10243 BPF_EXIT_INSN(),
10244 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10245 BPF_EXIT_INSN(),
10246 },
10247 INTERNAL,
10248 { },
10249 { { 0, 1 } },
10250 },
10251 /* BPF_JMP | BPF_JSGT | BPF_X */
10252 {
10253 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
10254 .u.insns_int = {
10255 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10256 BPF_LD_IMM64(R1, -1),
10257 BPF_LD_IMM64(R2, -2),
10258 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
10259 BPF_EXIT_INSN(),
10260 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10261 BPF_EXIT_INSN(),
10262 },
10263 INTERNAL,
10264 { },
10265 { { 0, 1 } },
10266 },
10267 {
10268 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
10269 .u.insns_int = {
10270 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10271 BPF_LD_IMM64(R1, -1),
10272 BPF_LD_IMM64(R2, -1),
10273 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
10274 BPF_EXIT_INSN(),
10275 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10276 BPF_EXIT_INSN(),
10277 },
10278 INTERNAL,
10279 { },
10280 { { 0, 1 } },
10281 },
10282 /* BPF_JMP | BPF_JSLT | BPF_X */
10283 {
10284 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
10285 .u.insns_int = {
10286 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10287 BPF_LD_IMM64(R1, -1),
10288 BPF_LD_IMM64(R2, -2),
10289 BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
10290 BPF_EXIT_INSN(),
10291 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10292 BPF_EXIT_INSN(),
10293 },
10294 INTERNAL,
10295 { },
10296 { { 0, 1 } },
10297 },
10298 {
10299 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
10300 .u.insns_int = {
10301 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10302 BPF_LD_IMM64(R1, -1),
10303 BPF_LD_IMM64(R2, -1),
10304 BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
10305 BPF_EXIT_INSN(),
10306 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10307 BPF_EXIT_INSN(),
10308 },
10309 INTERNAL,
10310 { },
10311 { { 0, 1 } },
10312 },
10313 /* BPF_JMP | BPF_JSGE | BPF_X */
10314 {
10315 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
10316 .u.insns_int = {
10317 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10318 BPF_LD_IMM64(R1, -1),
10319 BPF_LD_IMM64(R2, -2),
10320 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
10321 BPF_EXIT_INSN(),
10322 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10323 BPF_EXIT_INSN(),
10324 },
10325 INTERNAL,
10326 { },
10327 { { 0, 1 } },
10328 },
10329 {
10330 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
10331 .u.insns_int = {
10332 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10333 BPF_LD_IMM64(R1, -1),
10334 BPF_LD_IMM64(R2, -1),
10335 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
10336 BPF_EXIT_INSN(),
10337 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10338 BPF_EXIT_INSN(),
10339 },
10340 INTERNAL,
10341 { },
10342 { { 0, 1 } },
10343 },
10344 /* BPF_JMP | BPF_JSLE | BPF_X */
10345 {
10346 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
10347 .u.insns_int = {
10348 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10349 BPF_LD_IMM64(R1, -1),
10350 BPF_LD_IMM64(R2, -2),
10351 BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
10352 BPF_EXIT_INSN(),
10353 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10354 BPF_EXIT_INSN(),
10355 },
10356 INTERNAL,
10357 { },
10358 { { 0, 1 } },
10359 },
10360 {
10361 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
10362 .u.insns_int = {
10363 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10364 BPF_LD_IMM64(R1, -1),
10365 BPF_LD_IMM64(R2, -1),
10366 BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
10367 BPF_EXIT_INSN(),
10368 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10369 BPF_EXIT_INSN(),
10370 },
10371 INTERNAL,
10372 { },
10373 { { 0, 1 } },
10374 },
10375 /* BPF_JMP | BPF_JGT | BPF_X */
10376 {
10377 "JMP_JGT_X: if (3 > 2) return 1",
10378 .u.insns_int = {
10379 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10380 BPF_LD_IMM64(R1, 3),
10381 BPF_LD_IMM64(R2, 2),
10382 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
10383 BPF_EXIT_INSN(),
10384 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10385 BPF_EXIT_INSN(),
10386 },
10387 INTERNAL,
10388 { },
10389 { { 0, 1 } },
10390 },
10391 {
10392 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
10393 .u.insns_int = {
10394 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10395 BPF_LD_IMM64(R1, -1),
10396 BPF_LD_IMM64(R2, 1),
10397 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
10398 BPF_EXIT_INSN(),
10399 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10400 BPF_EXIT_INSN(),
10401 },
10402 INTERNAL,
10403 { },
10404 { { 0, 1 } },
10405 },
10406 /* BPF_JMP | BPF_JLT | BPF_X */
10407 {
10408 "JMP_JLT_X: if (2 < 3) return 1",
10409 .u.insns_int = {
10410 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10411 BPF_LD_IMM64(R1, 3),
10412 BPF_LD_IMM64(R2, 2),
10413 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
10414 BPF_EXIT_INSN(),
10415 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10416 BPF_EXIT_INSN(),
10417 },
10418 INTERNAL,
10419 { },
10420 { { 0, 1 } },
10421 },
10422 {
10423 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
10424 .u.insns_int = {
10425 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10426 BPF_LD_IMM64(R1, -1),
10427 BPF_LD_IMM64(R2, 1),
10428 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
10429 BPF_EXIT_INSN(),
10430 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10431 BPF_EXIT_INSN(),
10432 },
10433 INTERNAL,
10434 { },
10435 { { 0, 1 } },
10436 },
10437 /* BPF_JMP | BPF_JGE | BPF_X */
10438 {
10439 "JMP_JGE_X: if (3 >= 2) return 1",
10440 .u.insns_int = {
10441 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10442 BPF_LD_IMM64(R1, 3),
10443 BPF_LD_IMM64(R2, 2),
10444 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
10445 BPF_EXIT_INSN(),
10446 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10447 BPF_EXIT_INSN(),
10448 },
10449 INTERNAL,
10450 { },
10451 { { 0, 1 } },
10452 },
10453 {
10454 "JMP_JGE_X: if (3 >= 3) return 1",
10455 .u.insns_int = {
10456 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10457 BPF_LD_IMM64(R1, 3),
10458 BPF_LD_IMM64(R2, 3),
10459 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
10460 BPF_EXIT_INSN(),
10461 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10462 BPF_EXIT_INSN(),
10463 },
10464 INTERNAL,
10465 { },
10466 { { 0, 1 } },
10467 },
10468 /* BPF_JMP | BPF_JLE | BPF_X */
10469 {
10470 "JMP_JLE_X: if (2 <= 3) return 1",
10471 .u.insns_int = {
10472 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10473 BPF_LD_IMM64(R1, 3),
10474 BPF_LD_IMM64(R2, 2),
10475 BPF_JMP_REG(BPF_JLE, R2, R1, 1),
10476 BPF_EXIT_INSN(),
10477 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10478 BPF_EXIT_INSN(),
10479 },
10480 INTERNAL,
10481 { },
10482 { { 0, 1 } },
10483 },
10484 {
10485 "JMP_JLE_X: if (3 <= 3) return 1",
10486 .u.insns_int = {
10487 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10488 BPF_LD_IMM64(R1, 3),
10489 BPF_LD_IMM64(R2, 3),
10490 BPF_JMP_REG(BPF_JLE, R1, R2, 1),
10491 BPF_EXIT_INSN(),
10492 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10493 BPF_EXIT_INSN(),
10494 },
10495 INTERNAL,
10496 { },
10497 { { 0, 1 } },
10498 },
10499 {
10500 /* Mainly testing JIT + imm64 here. */
10501 "JMP_JGE_X: ldimm64 test 1",
10502 .u.insns_int = {
10503 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10504 BPF_LD_IMM64(R1, 3),
10505 BPF_LD_IMM64(R2, 2),
10506 BPF_JMP_REG(BPF_JGE, R1, R2, 2),
10507 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10508 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10509 BPF_EXIT_INSN(),
10510 },
10511 INTERNAL,
10512 { },
10513 { { 0, 0xeeeeeeeeU } },
10514 },
10515 {
10516 "JMP_JGE_X: ldimm64 test 2",
10517 .u.insns_int = {
10518 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10519 BPF_LD_IMM64(R1, 3),
10520 BPF_LD_IMM64(R2, 2),
10521 BPF_JMP_REG(BPF_JGE, R1, R2, 0),
10522 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10523 BPF_EXIT_INSN(),
10524 },
10525 INTERNAL,
10526 { },
10527 { { 0, 0xffffffffU } },
10528 },
10529 {
10530 "JMP_JGE_X: ldimm64 test 3",
10531 .u.insns_int = {
10532 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10533 BPF_LD_IMM64(R1, 3),
10534 BPF_LD_IMM64(R2, 2),
10535 BPF_JMP_REG(BPF_JGE, R1, R2, 4),
10536 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10537 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10538 BPF_EXIT_INSN(),
10539 },
10540 INTERNAL,
10541 { },
10542 { { 0, 1 } },
10543 },
10544 {
10545 "JMP_JLE_X: ldimm64 test 1",
10546 .u.insns_int = {
10547 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10548 BPF_LD_IMM64(R1, 3),
10549 BPF_LD_IMM64(R2, 2),
10550 BPF_JMP_REG(BPF_JLE, R2, R1, 2),
10551 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10552 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10553 BPF_EXIT_INSN(),
10554 },
10555 INTERNAL,
10556 { },
10557 { { 0, 0xeeeeeeeeU } },
10558 },
10559 {
10560 "JMP_JLE_X: ldimm64 test 2",
10561 .u.insns_int = {
10562 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10563 BPF_LD_IMM64(R1, 3),
10564 BPF_LD_IMM64(R2, 2),
10565 BPF_JMP_REG(BPF_JLE, R2, R1, 0),
10566 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10567 BPF_EXIT_INSN(),
10568 },
10569 INTERNAL,
10570 { },
10571 { { 0, 0xffffffffU } },
10572 },
10573 {
10574 "JMP_JLE_X: ldimm64 test 3",
10575 .u.insns_int = {
10576 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10577 BPF_LD_IMM64(R1, 3),
10578 BPF_LD_IMM64(R2, 2),
10579 BPF_JMP_REG(BPF_JLE, R2, R1, 4),
10580 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
10581 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
10582 BPF_EXIT_INSN(),
10583 },
10584 INTERNAL,
10585 { },
10586 { { 0, 1 } },
10587 },
10588 /* BPF_JMP | BPF_JNE | BPF_X */
10589 {
10590 "JMP_JNE_X: if (3 != 2) return 1",
10591 .u.insns_int = {
10592 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10593 BPF_LD_IMM64(R1, 3),
10594 BPF_LD_IMM64(R2, 2),
10595 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
10596 BPF_EXIT_INSN(),
10597 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10598 BPF_EXIT_INSN(),
10599 },
10600 INTERNAL,
10601 { },
10602 { { 0, 1 } },
10603 },
10604 /* BPF_JMP | BPF_JEQ | BPF_X */
10605 {
10606 "JMP_JEQ_X: if (3 == 3) return 1",
10607 .u.insns_int = {
10608 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10609 BPF_LD_IMM64(R1, 3),
10610 BPF_LD_IMM64(R2, 3),
10611 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
10612 BPF_EXIT_INSN(),
10613 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10614 BPF_EXIT_INSN(),
10615 },
10616 INTERNAL,
10617 { },
10618 { { 0, 1 } },
10619 },
10620 /* BPF_JMP | BPF_JSET | BPF_X */
10621 {
10622 "JMP_JSET_X: if (0x3 & 0x2) return 1",
10623 .u.insns_int = {
10624 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10625 BPF_LD_IMM64(R1, 3),
10626 BPF_LD_IMM64(R2, 2),
10627 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
10628 BPF_EXIT_INSN(),
10629 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10630 BPF_EXIT_INSN(),
10631 },
10632 INTERNAL,
10633 { },
10634 { { 0, 1 } },
10635 },
10636 {
10637 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
10638 .u.insns_int = {
10639 BPF_ALU32_IMM(BPF_MOV, R0, 0),
10640 BPF_LD_IMM64(R1, 3),
10641 BPF_LD_IMM64(R2, 0xffffffff),
10642 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
10643 BPF_EXIT_INSN(),
10644 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10645 BPF_EXIT_INSN(),
10646 },
10647 INTERNAL,
10648 { },
10649 { { 0, 1 } },
10650 },
10651 {
10652 "JMP_JA: Jump, gap, jump, ...",
10653 { },
10654 CLASSIC | FLAG_NO_DATA,
10655 { },
10656 { { 0, 0xababcbac } },
10657 .fill_helper = bpf_fill_ja,
10658 },
10659 { /* Mainly checking JIT here. */
10660 "BPF_MAXINSNS: Maximum possible literals",
10661 { },
10662 CLASSIC | FLAG_NO_DATA,
10663 { },
10664 { { 0, 0xffffffff } },
10665 .fill_helper = bpf_fill_maxinsns1,
10666 },
10667 { /* Mainly checking JIT here. */
10668 "BPF_MAXINSNS: Single literal",
10669 { },
10670 CLASSIC | FLAG_NO_DATA,
10671 { },
10672 { { 0, 0xfefefefe } },
10673 .fill_helper = bpf_fill_maxinsns2,
10674 },
10675 { /* Mainly checking JIT here. */
10676 "BPF_MAXINSNS: Run/add until end",
10677 { },
10678 CLASSIC | FLAG_NO_DATA,
10679 { },
10680 { { 0, 0x947bf368 } },
10681 .fill_helper = bpf_fill_maxinsns3,
10682 },
10683 {
10684 "BPF_MAXINSNS: Too many instructions",
10685 { },
10686 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
10687 { },
10688 { },
10689 .fill_helper = bpf_fill_maxinsns4,
10690 .expected_errcode = -EINVAL,
10691 },
10692 { /* Mainly checking JIT here. */
10693 "BPF_MAXINSNS: Very long jump",
10694 { },
10695 CLASSIC | FLAG_NO_DATA,
10696 { },
10697 { { 0, 0xabababab } },
10698 .fill_helper = bpf_fill_maxinsns5,
10699 },
10700 { /* Mainly checking JIT here. */
10701 "BPF_MAXINSNS: Ctx heavy transformations",
10702 { },
10703 CLASSIC,
10704 { },
10705 {
10706 { 1, SKB_VLAN_PRESENT },
10707 { 10, SKB_VLAN_PRESENT }
10708 },
10709 .fill_helper = bpf_fill_maxinsns6,
10710 },
10711 { /* Mainly checking JIT here. */
10712 "BPF_MAXINSNS: Call heavy transformations",
10713 { },
10714 CLASSIC | FLAG_NO_DATA,
10715 { },
10716 { { 1, 0 }, { 10, 0 } },
10717 .fill_helper = bpf_fill_maxinsns7,
10718 },
10719 { /* Mainly checking JIT here. */
10720 "BPF_MAXINSNS: Jump heavy test",
10721 { },
10722 CLASSIC | FLAG_NO_DATA,
10723 { },
10724 { { 0, 0xffffffff } },
10725 .fill_helper = bpf_fill_maxinsns8,
10726 },
10727 { /* Mainly checking JIT here. */
10728 "BPF_MAXINSNS: Very long jump backwards",
10729 { },
10730 INTERNAL | FLAG_NO_DATA,
10731 { },
10732 { { 0, 0xcbababab } },
10733 .fill_helper = bpf_fill_maxinsns9,
10734 },
10735 { /* Mainly checking JIT here. */
10736 "BPF_MAXINSNS: Edge hopping nuthouse",
10737 { },
10738 INTERNAL | FLAG_NO_DATA,
10739 { },
10740 { { 0, 0xabababac } },
10741 .fill_helper = bpf_fill_maxinsns10,
10742 },
10743 {
10744 "BPF_MAXINSNS: Jump, gap, jump, ...",
10745 { },
10746 CLASSIC | FLAG_NO_DATA,
10747 { },
10748 { { 0, 0xababcbac } },
10749 .fill_helper = bpf_fill_maxinsns11,
10750 },
10751 {
10752 "BPF_MAXINSNS: jump over MSH",
10753 { },
10754 CLASSIC | FLAG_EXPECTED_FAIL,
10755 { 0xfa, 0xfb, 0xfc, 0xfd, },
10756 { { 4, 0xabababab } },
10757 .fill_helper = bpf_fill_maxinsns12,
10758 .expected_errcode = -EINVAL,
10759 },
10760 {
10761 "BPF_MAXINSNS: exec all MSH",
10762 { },
10763 CLASSIC,
10764 { 0xfa, 0xfb, 0xfc, 0xfd, },
10765 { { 4, 0xababab83 } },
10766 .fill_helper = bpf_fill_maxinsns13,
10767 },
10768 {
10769 "BPF_MAXINSNS: ld_abs+get_processor_id",
10770 { },
10771 CLASSIC,
10772 { },
10773 { { 1, 0xbee } },
10774 .fill_helper = bpf_fill_ld_abs_get_processor_id,
10775 },
10776 /*
10777 * LD_IND / LD_ABS on fragmented SKBs
10778 */
10779 {
10780 "LD_IND byte frag",
10781 .u.insns = {
10782 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10783 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
10784 BPF_STMT(BPF_RET | BPF_A, 0x0),
10785 },
10786 CLASSIC | FLAG_SKB_FRAG,
10787 { },
10788 { {0x40, 0x42} },
10789 .frag_data = {
10790 0x42, 0x00, 0x00, 0x00,
10791 0x43, 0x44, 0x00, 0x00,
10792 0x21, 0x07, 0x19, 0x83,
10793 },
10794 },
10795 {
10796 "LD_IND halfword frag",
10797 .u.insns = {
10798 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10799 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
10800 BPF_STMT(BPF_RET | BPF_A, 0x0),
10801 },
10802 CLASSIC | FLAG_SKB_FRAG,
10803 { },
10804 { {0x40, 0x4344} },
10805 .frag_data = {
10806 0x42, 0x00, 0x00, 0x00,
10807 0x43, 0x44, 0x00, 0x00,
10808 0x21, 0x07, 0x19, 0x83,
10809 },
10810 },
10811 {
10812 "LD_IND word frag",
10813 .u.insns = {
10814 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10815 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
10816 BPF_STMT(BPF_RET | BPF_A, 0x0),
10817 },
10818 CLASSIC | FLAG_SKB_FRAG,
10819 { },
10820 { {0x40, 0x21071983} },
10821 .frag_data = {
10822 0x42, 0x00, 0x00, 0x00,
10823 0x43, 0x44, 0x00, 0x00,
10824 0x21, 0x07, 0x19, 0x83,
10825 },
10826 },
10827 {
10828 "LD_IND halfword mixed head/frag",
10829 .u.insns = {
10830 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10831 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
10832 BPF_STMT(BPF_RET | BPF_A, 0x0),
10833 },
10834 CLASSIC | FLAG_SKB_FRAG,
10835 { [0x3e] = 0x25, [0x3f] = 0x05, },
10836 { {0x40, 0x0519} },
10837 .frag_data = { 0x19, 0x82 },
10838 },
10839 {
10840 "LD_IND word mixed head/frag",
10841 .u.insns = {
10842 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
10843 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
10844 BPF_STMT(BPF_RET | BPF_A, 0x0),
10845 },
10846 CLASSIC | FLAG_SKB_FRAG,
10847 { [0x3e] = 0x25, [0x3f] = 0x05, },
10848 { {0x40, 0x25051982} },
10849 .frag_data = { 0x19, 0x82 },
10850 },
10851 {
10852 "LD_ABS byte frag",
10853 .u.insns = {
10854 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
10855 BPF_STMT(BPF_RET | BPF_A, 0x0),
10856 },
10857 CLASSIC | FLAG_SKB_FRAG,
10858 { },
10859 { {0x40, 0x42} },
10860 .frag_data = {
10861 0x42, 0x00, 0x00, 0x00,
10862 0x43, 0x44, 0x00, 0x00,
10863 0x21, 0x07, 0x19, 0x83,
10864 },
10865 },
10866 {
10867 "LD_ABS halfword frag",
10868 .u.insns = {
10869 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
10870 BPF_STMT(BPF_RET | BPF_A, 0x0),
10871 },
10872 CLASSIC | FLAG_SKB_FRAG,
10873 { },
10874 { {0x40, 0x4344} },
10875 .frag_data = {
10876 0x42, 0x00, 0x00, 0x00,
10877 0x43, 0x44, 0x00, 0x00,
10878 0x21, 0x07, 0x19, 0x83,
10879 },
10880 },
10881 {
10882 "LD_ABS word frag",
10883 .u.insns = {
10884 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
10885 BPF_STMT(BPF_RET | BPF_A, 0x0),
10886 },
10887 CLASSIC | FLAG_SKB_FRAG,
10888 { },
10889 { {0x40, 0x21071983} },
10890 .frag_data = {
10891 0x42, 0x00, 0x00, 0x00,
10892 0x43, 0x44, 0x00, 0x00,
10893 0x21, 0x07, 0x19, 0x83,
10894 },
10895 },
10896 {
10897 "LD_ABS halfword mixed head/frag",
10898 .u.insns = {
10899 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
10900 BPF_STMT(BPF_RET | BPF_A, 0x0),
10901 },
10902 CLASSIC | FLAG_SKB_FRAG,
10903 { [0x3e] = 0x25, [0x3f] = 0x05, },
10904 { {0x40, 0x0519} },
10905 .frag_data = { 0x19, 0x82 },
10906 },
10907 {
10908 "LD_ABS word mixed head/frag",
10909 .u.insns = {
10910 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
10911 BPF_STMT(BPF_RET | BPF_A, 0x0),
10912 },
10913 CLASSIC | FLAG_SKB_FRAG,
10914 { [0x3e] = 0x25, [0x3f] = 0x05, },
10915 { {0x40, 0x25051982} },
10916 .frag_data = { 0x19, 0x82 },
10917 },
10918 /*
10919 * LD_IND / LD_ABS on non fragmented SKBs
10920 */
10921 {
10922 /*
10923 * this tests that the JIT/interpreter correctly resets X
10924 * before using it in an LD_IND instruction.
10925 */
10926 "LD_IND byte default X",
10927 .u.insns = {
10928 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10929 BPF_STMT(BPF_RET | BPF_A, 0x0),
10930 },
10931 CLASSIC,
10932 { [0x1] = 0x42 },
10933 { {0x40, 0x42 } },
10934 },
10935 {
10936 "LD_IND byte positive offset",
10937 .u.insns = {
10938 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10939 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10940 BPF_STMT(BPF_RET | BPF_A, 0x0),
10941 },
10942 CLASSIC,
10943 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10944 { {0x40, 0x82 } },
10945 },
10946 {
10947 "LD_IND byte negative offset",
10948 .u.insns = {
10949 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10950 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
10951 BPF_STMT(BPF_RET | BPF_A, 0x0),
10952 },
10953 CLASSIC,
10954 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10955 { {0x40, 0x05 } },
10956 },
10957 {
10958 "LD_IND byte positive offset, all ff",
10959 .u.insns = {
10960 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10961 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10962 BPF_STMT(BPF_RET | BPF_A, 0x0),
10963 },
10964 CLASSIC,
10965 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
10966 { {0x40, 0xff } },
10967 },
10968 {
10969 "LD_IND byte positive offset, out of bounds",
10970 .u.insns = {
10971 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10972 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
10973 BPF_STMT(BPF_RET | BPF_A, 0x0),
10974 },
10975 CLASSIC,
10976 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10977 { {0x3f, 0 }, },
10978 },
10979 {
10980 "LD_IND byte negative offset, out of bounds",
10981 .u.insns = {
10982 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
10983 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
10984 BPF_STMT(BPF_RET | BPF_A, 0x0),
10985 },
10986 CLASSIC,
10987 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10988 { {0x3f, 0 } },
10989 },
10990 {
10991 "LD_IND byte negative offset, multiple calls",
10992 .u.insns = {
10993 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
10994 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
10995 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
10996 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
10997 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
10998 BPF_STMT(BPF_RET | BPF_A, 0x0),
10999 },
11000 CLASSIC,
11001 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11002 { {0x40, 0x82 }, },
11003 },
11004 {
11005 "LD_IND halfword positive offset",
11006 .u.insns = {
11007 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11008 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
11009 BPF_STMT(BPF_RET | BPF_A, 0x0),
11010 },
11011 CLASSIC,
11012 {
11013 [0x1c] = 0xaa, [0x1d] = 0x55,
11014 [0x1e] = 0xbb, [0x1f] = 0x66,
11015 [0x20] = 0xcc, [0x21] = 0x77,
11016 [0x22] = 0xdd, [0x23] = 0x88,
11017 },
11018 { {0x40, 0xdd88 } },
11019 },
11020 {
11021 "LD_IND halfword negative offset",
11022 .u.insns = {
11023 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11024 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
11025 BPF_STMT(BPF_RET | BPF_A, 0x0),
11026 },
11027 CLASSIC,
11028 {
11029 [0x1c] = 0xaa, [0x1d] = 0x55,
11030 [0x1e] = 0xbb, [0x1f] = 0x66,
11031 [0x20] = 0xcc, [0x21] = 0x77,
11032 [0x22] = 0xdd, [0x23] = 0x88,
11033 },
11034 { {0x40, 0xbb66 } },
11035 },
11036 {
11037 "LD_IND halfword unaligned",
11038 .u.insns = {
11039 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11040 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
11041 BPF_STMT(BPF_RET | BPF_A, 0x0),
11042 },
11043 CLASSIC,
11044 {
11045 [0x1c] = 0xaa, [0x1d] = 0x55,
11046 [0x1e] = 0xbb, [0x1f] = 0x66,
11047 [0x20] = 0xcc, [0x21] = 0x77,
11048 [0x22] = 0xdd, [0x23] = 0x88,
11049 },
11050 { {0x40, 0x66cc } },
11051 },
11052 {
11053 "LD_IND halfword positive offset, all ff",
11054 .u.insns = {
11055 BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
11056 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
11057 BPF_STMT(BPF_RET | BPF_A, 0x0),
11058 },
11059 CLASSIC,
11060 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
11061 { {0x40, 0xffff } },
11062 },
11063 {
11064 "LD_IND halfword positive offset, out of bounds",
11065 .u.insns = {
11066 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11067 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
11068 BPF_STMT(BPF_RET | BPF_A, 0x0),
11069 },
11070 CLASSIC,
11071 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11072 { {0x3f, 0 }, },
11073 },
11074 {
11075 "LD_IND halfword negative offset, out of bounds",
11076 .u.insns = {
11077 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11078 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
11079 BPF_STMT(BPF_RET | BPF_A, 0x0),
11080 },
11081 CLASSIC,
11082 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11083 { {0x3f, 0 } },
11084 },
11085 {
11086 "LD_IND word positive offset",
11087 .u.insns = {
11088 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11089 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
11090 BPF_STMT(BPF_RET | BPF_A, 0x0),
11091 },
11092 CLASSIC,
11093 {
11094 [0x1c] = 0xaa, [0x1d] = 0x55,
11095 [0x1e] = 0xbb, [0x1f] = 0x66,
11096 [0x20] = 0xcc, [0x21] = 0x77,
11097 [0x22] = 0xdd, [0x23] = 0x88,
11098 [0x24] = 0xee, [0x25] = 0x99,
11099 [0x26] = 0xff, [0x27] = 0xaa,
11100 },
11101 { {0x40, 0xee99ffaa } },
11102 },
11103 {
11104 "LD_IND word negative offset",
11105 .u.insns = {
11106 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11107 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
11108 BPF_STMT(BPF_RET | BPF_A, 0x0),
11109 },
11110 CLASSIC,
11111 {
11112 [0x1c] = 0xaa, [0x1d] = 0x55,
11113 [0x1e] = 0xbb, [0x1f] = 0x66,
11114 [0x20] = 0xcc, [0x21] = 0x77,
11115 [0x22] = 0xdd, [0x23] = 0x88,
11116 [0x24] = 0xee, [0x25] = 0x99,
11117 [0x26] = 0xff, [0x27] = 0xaa,
11118 },
11119 { {0x40, 0xaa55bb66 } },
11120 },
11121 {
11122 "LD_IND word unaligned (addr & 3 == 2)",
11123 .u.insns = {
11124 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11125 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
11126 BPF_STMT(BPF_RET | BPF_A, 0x0),
11127 },
11128 CLASSIC,
11129 {
11130 [0x1c] = 0xaa, [0x1d] = 0x55,
11131 [0x1e] = 0xbb, [0x1f] = 0x66,
11132 [0x20] = 0xcc, [0x21] = 0x77,
11133 [0x22] = 0xdd, [0x23] = 0x88,
11134 [0x24] = 0xee, [0x25] = 0x99,
11135 [0x26] = 0xff, [0x27] = 0xaa,
11136 },
11137 { {0x40, 0xbb66cc77 } },
11138 },
11139 {
11140 "LD_IND word unaligned (addr & 3 == 1)",
11141 .u.insns = {
11142 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11143 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
11144 BPF_STMT(BPF_RET | BPF_A, 0x0),
11145 },
11146 CLASSIC,
11147 {
11148 [0x1c] = 0xaa, [0x1d] = 0x55,
11149 [0x1e] = 0xbb, [0x1f] = 0x66,
11150 [0x20] = 0xcc, [0x21] = 0x77,
11151 [0x22] = 0xdd, [0x23] = 0x88,
11152 [0x24] = 0xee, [0x25] = 0x99,
11153 [0x26] = 0xff, [0x27] = 0xaa,
11154 },
11155 { {0x40, 0x55bb66cc } },
11156 },
11157 {
11158 "LD_IND word unaligned (addr & 3 == 3)",
11159 .u.insns = {
11160 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
11161 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
11162 BPF_STMT(BPF_RET | BPF_A, 0x0),
11163 },
11164 CLASSIC,
11165 {
11166 [0x1c] = 0xaa, [0x1d] = 0x55,
11167 [0x1e] = 0xbb, [0x1f] = 0x66,
11168 [0x20] = 0xcc, [0x21] = 0x77,
11169 [0x22] = 0xdd, [0x23] = 0x88,
11170 [0x24] = 0xee, [0x25] = 0x99,
11171 [0x26] = 0xff, [0x27] = 0xaa,
11172 },
11173 { {0x40, 0x66cc77dd } },
11174 },
11175 {
11176 "LD_IND word positive offset, all ff",
11177 .u.insns = {
11178 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
11179 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
11180 BPF_STMT(BPF_RET | BPF_A, 0x0),
11181 },
11182 CLASSIC,
11183 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
11184 { {0x40, 0xffffffff } },
11185 },
11186 {
11187 "LD_IND word positive offset, out of bounds",
11188 .u.insns = {
11189 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11190 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
11191 BPF_STMT(BPF_RET | BPF_A, 0x0),
11192 },
11193 CLASSIC,
11194 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11195 { {0x3f, 0 }, },
11196 },
11197 {
11198 "LD_IND word negative offset, out of bounds",
11199 .u.insns = {
11200 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
11201 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
11202 BPF_STMT(BPF_RET | BPF_A, 0x0),
11203 },
11204 CLASSIC,
11205 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11206 { {0x3f, 0 } },
11207 },
11208 {
11209 "LD_ABS byte",
11210 .u.insns = {
11211 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
11212 BPF_STMT(BPF_RET | BPF_A, 0x0),
11213 },
11214 CLASSIC,
11215 {
11216 [0x1c] = 0xaa, [0x1d] = 0x55,
11217 [0x1e] = 0xbb, [0x1f] = 0x66,
11218 [0x20] = 0xcc, [0x21] = 0x77,
11219 [0x22] = 0xdd, [0x23] = 0x88,
11220 [0x24] = 0xee, [0x25] = 0x99,
11221 [0x26] = 0xff, [0x27] = 0xaa,
11222 },
11223 { {0x40, 0xcc } },
11224 },
11225 {
11226 "LD_ABS byte positive offset, all ff",
11227 .u.insns = {
11228 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
11229 BPF_STMT(BPF_RET | BPF_A, 0x0),
11230 },
11231 CLASSIC,
11232 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
11233 { {0x40, 0xff } },
11234 },
11235 {
11236 "LD_ABS byte positive offset, out of bounds",
11237 .u.insns = {
11238 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
11239 BPF_STMT(BPF_RET | BPF_A, 0x0),
11240 },
11241 CLASSIC,
11242 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11243 { {0x3f, 0 }, },
11244 },
11245 {
11246 "LD_ABS byte negative offset, out of bounds load",
11247 .u.insns = {
11248 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
11249 BPF_STMT(BPF_RET | BPF_A, 0x0),
11250 },
11251 CLASSIC | FLAG_EXPECTED_FAIL,
11252 .expected_errcode = -EINVAL,
11253 },
11254 {
11255 "LD_ABS byte negative offset, in bounds",
11256 .u.insns = {
11257 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11258 BPF_STMT(BPF_RET | BPF_A, 0x0),
11259 },
11260 CLASSIC,
11261 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11262 { {0x40, 0x82 }, },
11263 },
11264 {
11265 "LD_ABS byte negative offset, out of bounds",
11266 .u.insns = {
11267 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11268 BPF_STMT(BPF_RET | BPF_A, 0x0),
11269 },
11270 CLASSIC,
11271 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11272 { {0x3f, 0 }, },
11273 },
11274 {
11275 "LD_ABS byte negative offset, multiple calls",
11276 .u.insns = {
11277 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
11278 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
11279 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
11280 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
11281 BPF_STMT(BPF_RET | BPF_A, 0x0),
11282 },
11283 CLASSIC,
11284 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11285 { {0x40, 0x82 }, },
11286 },
11287 {
11288 "LD_ABS halfword",
11289 .u.insns = {
11290 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
11291 BPF_STMT(BPF_RET | BPF_A, 0x0),
11292 },
11293 CLASSIC,
11294 {
11295 [0x1c] = 0xaa, [0x1d] = 0x55,
11296 [0x1e] = 0xbb, [0x1f] = 0x66,
11297 [0x20] = 0xcc, [0x21] = 0x77,
11298 [0x22] = 0xdd, [0x23] = 0x88,
11299 [0x24] = 0xee, [0x25] = 0x99,
11300 [0x26] = 0xff, [0x27] = 0xaa,
11301 },
11302 { {0x40, 0xdd88 } },
11303 },
11304 {
11305 "LD_ABS halfword unaligned",
11306 .u.insns = {
11307 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
11308 BPF_STMT(BPF_RET | BPF_A, 0x0),
11309 },
11310 CLASSIC,
11311 {
11312 [0x1c] = 0xaa, [0x1d] = 0x55,
11313 [0x1e] = 0xbb, [0x1f] = 0x66,
11314 [0x20] = 0xcc, [0x21] = 0x77,
11315 [0x22] = 0xdd, [0x23] = 0x88,
11316 [0x24] = 0xee, [0x25] = 0x99,
11317 [0x26] = 0xff, [0x27] = 0xaa,
11318 },
11319 { {0x40, 0x99ff } },
11320 },
11321 {
11322 "LD_ABS halfword positive offset, all ff",
11323 .u.insns = {
11324 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
11325 BPF_STMT(BPF_RET | BPF_A, 0x0),
11326 },
11327 CLASSIC,
11328 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
11329 { {0x40, 0xffff } },
11330 },
11331 {
11332 "LD_ABS halfword positive offset, out of bounds",
11333 .u.insns = {
11334 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
11335 BPF_STMT(BPF_RET | BPF_A, 0x0),
11336 },
11337 CLASSIC,
11338 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11339 { {0x3f, 0 }, },
11340 },
11341 {
11342 "LD_ABS halfword negative offset, out of bounds load",
11343 .u.insns = {
11344 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
11345 BPF_STMT(BPF_RET | BPF_A, 0x0),
11346 },
11347 CLASSIC | FLAG_EXPECTED_FAIL,
11348 .expected_errcode = -EINVAL,
11349 },
11350 {
11351 "LD_ABS halfword negative offset, in bounds",
11352 .u.insns = {
11353 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
11354 BPF_STMT(BPF_RET | BPF_A, 0x0),
11355 },
11356 CLASSIC,
11357 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11358 { {0x40, 0x1982 }, },
11359 },
11360 {
11361 "LD_ABS halfword negative offset, out of bounds",
11362 .u.insns = {
11363 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
11364 BPF_STMT(BPF_RET | BPF_A, 0x0),
11365 },
11366 CLASSIC,
11367 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11368 { {0x3f, 0 }, },
11369 },
11370 {
11371 "LD_ABS word",
11372 .u.insns = {
11373 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
11374 BPF_STMT(BPF_RET | BPF_A, 0x0),
11375 },
11376 CLASSIC,
11377 {
11378 [0x1c] = 0xaa, [0x1d] = 0x55,
11379 [0x1e] = 0xbb, [0x1f] = 0x66,
11380 [0x20] = 0xcc, [0x21] = 0x77,
11381 [0x22] = 0xdd, [0x23] = 0x88,
11382 [0x24] = 0xee, [0x25] = 0x99,
11383 [0x26] = 0xff, [0x27] = 0xaa,
11384 },
11385 { {0x40, 0xaa55bb66 } },
11386 },
11387 {
11388 "LD_ABS word unaligned (addr & 3 == 2)",
11389 .u.insns = {
11390 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
11391 BPF_STMT(BPF_RET | BPF_A, 0x0),
11392 },
11393 CLASSIC,
11394 {
11395 [0x1c] = 0xaa, [0x1d] = 0x55,
11396 [0x1e] = 0xbb, [0x1f] = 0x66,
11397 [0x20] = 0xcc, [0x21] = 0x77,
11398 [0x22] = 0xdd, [0x23] = 0x88,
11399 [0x24] = 0xee, [0x25] = 0x99,
11400 [0x26] = 0xff, [0x27] = 0xaa,
11401 },
11402 { {0x40, 0xdd88ee99 } },
11403 },
11404 {
11405 "LD_ABS word unaligned (addr & 3 == 1)",
11406 .u.insns = {
11407 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
11408 BPF_STMT(BPF_RET | BPF_A, 0x0),
11409 },
11410 CLASSIC,
11411 {
11412 [0x1c] = 0xaa, [0x1d] = 0x55,
11413 [0x1e] = 0xbb, [0x1f] = 0x66,
11414 [0x20] = 0xcc, [0x21] = 0x77,
11415 [0x22] = 0xdd, [0x23] = 0x88,
11416 [0x24] = 0xee, [0x25] = 0x99,
11417 [0x26] = 0xff, [0x27] = 0xaa,
11418 },
11419 { {0x40, 0x77dd88ee } },
11420 },
11421 {
11422 "LD_ABS word unaligned (addr & 3 == 3)",
11423 .u.insns = {
11424 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
11425 BPF_STMT(BPF_RET | BPF_A, 0x0),
11426 },
11427 CLASSIC,
11428 {
11429 [0x1c] = 0xaa, [0x1d] = 0x55,
11430 [0x1e] = 0xbb, [0x1f] = 0x66,
11431 [0x20] = 0xcc, [0x21] = 0x77,
11432 [0x22] = 0xdd, [0x23] = 0x88,
11433 [0x24] = 0xee, [0x25] = 0x99,
11434 [0x26] = 0xff, [0x27] = 0xaa,
11435 },
11436 { {0x40, 0x88ee99ff } },
11437 },
11438 {
11439 "LD_ABS word positive offset, all ff",
11440 .u.insns = {
11441 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
11442 BPF_STMT(BPF_RET | BPF_A, 0x0),
11443 },
11444 CLASSIC,
11445 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
11446 { {0x40, 0xffffffff } },
11447 },
11448 {
11449 "LD_ABS word positive offset, out of bounds",
11450 .u.insns = {
11451 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
11452 BPF_STMT(BPF_RET | BPF_A, 0x0),
11453 },
11454 CLASSIC,
11455 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11456 { {0x3f, 0 }, },
11457 },
11458 {
11459 "LD_ABS word negative offset, out of bounds load",
11460 .u.insns = {
11461 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
11462 BPF_STMT(BPF_RET | BPF_A, 0x0),
11463 },
11464 CLASSIC | FLAG_EXPECTED_FAIL,
11465 .expected_errcode = -EINVAL,
11466 },
11467 {
11468 "LD_ABS word negative offset, in bounds",
11469 .u.insns = {
11470 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11471 BPF_STMT(BPF_RET | BPF_A, 0x0),
11472 },
11473 CLASSIC,
11474 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11475 { {0x40, 0x25051982 }, },
11476 },
11477 {
11478 "LD_ABS word negative offset, out of bounds",
11479 .u.insns = {
11480 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
11481 BPF_STMT(BPF_RET | BPF_A, 0x0),
11482 },
11483 CLASSIC,
11484 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11485 { {0x3f, 0 }, },
11486 },
11487 {
11488 "LDX_MSH standalone, preserved A",
11489 .u.insns = {
11490 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11491 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11492 BPF_STMT(BPF_RET | BPF_A, 0x0),
11493 },
11494 CLASSIC,
11495 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11496 { {0x40, 0xffeebbaa }, },
11497 },
11498 {
11499 "LDX_MSH standalone, preserved A 2",
11500 .u.insns = {
11501 BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
11502 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11503 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
11504 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11505 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
11506 BPF_STMT(BPF_RET | BPF_A, 0x0),
11507 },
11508 CLASSIC,
11509 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11510 { {0x40, 0x175e9d63 }, },
11511 },
11512 {
11513 "LDX_MSH standalone, test result 1",
11514 .u.insns = {
11515 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11516 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
11517 BPF_STMT(BPF_MISC | BPF_TXA, 0),
11518 BPF_STMT(BPF_RET | BPF_A, 0x0),
11519 },
11520 CLASSIC,
11521 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11522 { {0x40, 0x14 }, },
11523 },
11524 {
11525 "LDX_MSH standalone, test result 2",
11526 .u.insns = {
11527 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11528 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
11529 BPF_STMT(BPF_MISC | BPF_TXA, 0),
11530 BPF_STMT(BPF_RET | BPF_A, 0x0),
11531 },
11532 CLASSIC,
11533 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11534 { {0x40, 0x24 }, },
11535 },
11536 {
11537 "LDX_MSH standalone, negative offset",
11538 .u.insns = {
11539 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11540 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
11541 BPF_STMT(BPF_MISC | BPF_TXA, 0),
11542 BPF_STMT(BPF_RET | BPF_A, 0x0),
11543 },
11544 CLASSIC,
11545 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11546 { {0x40, 0 }, },
11547 },
11548 {
11549 "LDX_MSH standalone, negative offset 2",
11550 .u.insns = {
11551 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11552 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
11553 BPF_STMT(BPF_MISC | BPF_TXA, 0),
11554 BPF_STMT(BPF_RET | BPF_A, 0x0),
11555 },
11556 CLASSIC,
11557 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11558 { {0x40, 0x24 }, },
11559 },
11560 {
11561 "LDX_MSH standalone, out of bounds",
11562 .u.insns = {
11563 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
11564 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
11565 BPF_STMT(BPF_MISC | BPF_TXA, 0),
11566 BPF_STMT(BPF_RET | BPF_A, 0x0),
11567 },
11568 CLASSIC,
11569 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
11570 { {0x40, 0 }, },
11571 },
11572 /*
11573 * verify that the interpreter or JIT correctly sets A and X
11574 * to 0.
11575 */
11576 {
11577 "ADD default X",
11578 .u.insns = {
11579 /*
11580 * A = 0x42
11581 * A = A + X
11582 * ret A
11583 */
11584 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11585 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
11586 BPF_STMT(BPF_RET | BPF_A, 0x0),
11587 },
11588 CLASSIC | FLAG_NO_DATA,
11589 {},
11590 { {0x1, 0x42 } },
11591 },
11592 {
11593 "ADD default A",
11594 .u.insns = {
11595 /*
11596 * A = A + 0x42
11597 * ret A
11598 */
11599 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
11600 BPF_STMT(BPF_RET | BPF_A, 0x0),
11601 },
11602 CLASSIC | FLAG_NO_DATA,
11603 {},
11604 { {0x1, 0x42 } },
11605 },
11606 {
11607 "SUB default X",
11608 .u.insns = {
11609 /*
11610 * A = 0x66
11611 * A = A - X
11612 * ret A
11613 */
11614 BPF_STMT(BPF_LD | BPF_IMM, 0x66),
11615 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
11616 BPF_STMT(BPF_RET | BPF_A, 0x0),
11617 },
11618 CLASSIC | FLAG_NO_DATA,
11619 {},
11620 { {0x1, 0x66 } },
11621 },
11622 {
11623 "SUB default A",
11624 .u.insns = {
11625 /*
11626 * A = A - -0x66
11627 * ret A
11628 */
11629 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
11630 BPF_STMT(BPF_RET | BPF_A, 0x0),
11631 },
11632 CLASSIC | FLAG_NO_DATA,
11633 {},
11634 { {0x1, 0x66 } },
11635 },
11636 {
11637 "MUL default X",
11638 .u.insns = {
11639 /*
11640 * A = 0x42
11641 * A = A * X
11642 * ret A
11643 */
11644 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11645 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
11646 BPF_STMT(BPF_RET | BPF_A, 0x0),
11647 },
11648 CLASSIC | FLAG_NO_DATA,
11649 {},
11650 { {0x1, 0x0 } },
11651 },
11652 {
11653 "MUL default A",
11654 .u.insns = {
11655 /*
11656 * A = A * 0x66
11657 * ret A
11658 */
11659 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
11660 BPF_STMT(BPF_RET | BPF_A, 0x0),
11661 },
11662 CLASSIC | FLAG_NO_DATA,
11663 {},
11664 { {0x1, 0x0 } },
11665 },
11666 {
11667 "DIV default X",
11668 .u.insns = {
11669 /*
11670 * A = 0x42
11671 * A = A / X ; this halt the filter execution if X is 0
11672 * ret 0x42
11673 */
11674 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11675 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
11676 BPF_STMT(BPF_RET | BPF_K, 0x42),
11677 },
11678 CLASSIC | FLAG_NO_DATA,
11679 {},
11680 { {0x1, 0x0 } },
11681 },
11682 {
11683 "DIV default A",
11684 .u.insns = {
11685 /*
11686 * A = A / 1
11687 * ret A
11688 */
11689 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
11690 BPF_STMT(BPF_RET | BPF_A, 0x0),
11691 },
11692 CLASSIC | FLAG_NO_DATA,
11693 {},
11694 { {0x1, 0x0 } },
11695 },
11696 {
11697 "MOD default X",
11698 .u.insns = {
11699 /*
11700 * A = 0x42
11701 * A = A mod X ; this halt the filter execution if X is 0
11702 * ret 0x42
11703 */
11704 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
11705 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
11706 BPF_STMT(BPF_RET | BPF_K, 0x42),
11707 },
11708 CLASSIC | FLAG_NO_DATA,
11709 {},
11710 { {0x1, 0x0 } },
11711 },
11712 {
11713 "MOD default A",
11714 .u.insns = {
11715 /*
11716 * A = A mod 1
11717 * ret A
11718 */
11719 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
11720 BPF_STMT(BPF_RET | BPF_A, 0x0),
11721 },
11722 CLASSIC | FLAG_NO_DATA,
11723 {},
11724 { {0x1, 0x0 } },
11725 },
11726 {
11727 "JMP EQ default A",
11728 .u.insns = {
11729 /*
11730 * cmp A, 0x0, 0, 1
11731 * ret 0x42
11732 * ret 0x66
11733 */
11734 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
11735 BPF_STMT(BPF_RET | BPF_K, 0x42),
11736 BPF_STMT(BPF_RET | BPF_K, 0x66),
11737 },
11738 CLASSIC | FLAG_NO_DATA,
11739 {},
11740 { {0x1, 0x42 } },
11741 },
11742 {
11743 "JMP EQ default X",
11744 .u.insns = {
11745 /*
11746 * A = 0x0
11747 * cmp A, X, 0, 1
11748 * ret 0x42
11749 * ret 0x66
11750 */
11751 BPF_STMT(BPF_LD | BPF_IMM, 0x0),
11752 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
11753 BPF_STMT(BPF_RET | BPF_K, 0x42),
11754 BPF_STMT(BPF_RET | BPF_K, 0x66),
11755 },
11756 CLASSIC | FLAG_NO_DATA,
11757 {},
11758 { {0x1, 0x42 } },
11759 },
11760 /* Checking interpreter vs JIT wrt signed extended imms. */
11761 {
11762 "JNE signed compare, test 1",
11763 .u.insns_int = {
11764 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11765 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11766 BPF_MOV64_REG(R2, R1),
11767 BPF_ALU64_REG(BPF_AND, R2, R3),
11768 BPF_ALU32_IMM(BPF_MOV, R0, 1),
11769 BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
11770 BPF_ALU32_IMM(BPF_MOV, R0, 2),
11771 BPF_EXIT_INSN(),
11772 },
11773 INTERNAL,
11774 { },
11775 { { 0, 1 } },
11776 },
11777 {
11778 "JNE signed compare, test 2",
11779 .u.insns_int = {
11780 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11781 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11782 BPF_MOV64_REG(R2, R1),
11783 BPF_ALU64_REG(BPF_AND, R2, R3),
11784 BPF_ALU32_IMM(BPF_MOV, R0, 1),
11785 BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
11786 BPF_ALU32_IMM(BPF_MOV, R0, 2),
11787 BPF_EXIT_INSN(),
11788 },
11789 INTERNAL,
11790 { },
11791 { { 0, 1 } },
11792 },
11793 {
11794 "JNE signed compare, test 3",
11795 .u.insns_int = {
11796 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
11797 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
11798 BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
11799 BPF_MOV64_REG(R2, R1),
11800 BPF_ALU64_REG(BPF_AND, R2, R3),
11801 BPF_ALU32_IMM(BPF_MOV, R0, 1),
11802 BPF_JMP_REG(BPF_JNE, R2, R4, 1),
11803 BPF_ALU32_IMM(BPF_MOV, R0, 2),
11804 BPF_EXIT_INSN(),
11805 },
11806 INTERNAL,
11807 { },
11808 { { 0, 2 } },
11809 },
11810 {
11811 "JNE signed compare, test 4",
11812 .u.insns_int = {
11813 BPF_LD_IMM64(R1, -17104896),
11814 BPF_ALU32_IMM(BPF_MOV, R0, 1),
11815 BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
11816 BPF_ALU32_IMM(BPF_MOV, R0, 2),
11817 BPF_EXIT_INSN(),
11818 },
11819 INTERNAL,
11820 { },
11821 { { 0, 2 } },
11822 },
11823 {
11824 "JNE signed compare, test 5",
11825 .u.insns_int = {
11826 BPF_LD_IMM64(R1, 0xfefb0000),
11827 BPF_ALU32_IMM(BPF_MOV, R0, 1),
11828 BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
11829 BPF_ALU32_IMM(BPF_MOV, R0, 2),
11830 BPF_EXIT_INSN(),
11831 },
11832 INTERNAL,
11833 { },
11834 { { 0, 1 } },
11835 },
11836 {
11837 "JNE signed compare, test 6",
11838 .u.insns_int = {
11839 BPF_LD_IMM64(R1, 0x7efb0000),
11840 BPF_ALU32_IMM(BPF_MOV, R0, 1),
11841 BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
11842 BPF_ALU32_IMM(BPF_MOV, R0, 2),
11843 BPF_EXIT_INSN(),
11844 },
11845 INTERNAL,
11846 { },
11847 { { 0, 2 } },
11848 },
11849 {
11850 "JNE signed compare, test 7",
11851 .u.insns = {
11852 BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
11853 BPF_STMT(BPF_MISC | BPF_TAX, 0),
11854 BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
11855 BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
11856 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
11857 BPF_STMT(BPF_RET | BPF_K, 1),
11858 BPF_STMT(BPF_RET | BPF_K, 2),
11859 },
11860 CLASSIC | FLAG_NO_DATA,
11861 {},
11862 { { 0, 2 } },
11863 },
11864 /* BPF_LDX_MEM with operand aliasing */
11865 {
11866 "LDX_MEM_B: operand register aliasing",
11867 .u.insns_int = {
11868 BPF_ST_MEM(BPF_B, R10, -8, 123),
11869 BPF_MOV64_REG(R0, R10),
11870 BPF_LDX_MEM(BPF_B, R0, R0, -8),
11871 BPF_EXIT_INSN(),
11872 },
11873 INTERNAL,
11874 { },
11875 { { 0, 123 } },
11876 .stack_depth = 8,
11877 },
11878 {
11879 "LDX_MEM_H: operand register aliasing",
11880 .u.insns_int = {
11881 BPF_ST_MEM(BPF_H, R10, -8, 12345),
11882 BPF_MOV64_REG(R0, R10),
11883 BPF_LDX_MEM(BPF_H, R0, R0, -8),
11884 BPF_EXIT_INSN(),
11885 },
11886 INTERNAL,
11887 { },
11888 { { 0, 12345 } },
11889 .stack_depth = 8,
11890 },
11891 {
11892 "LDX_MEM_W: operand register aliasing",
11893 .u.insns_int = {
11894 BPF_ST_MEM(BPF_W, R10, -8, 123456789),
11895 BPF_MOV64_REG(R0, R10),
11896 BPF_LDX_MEM(BPF_W, R0, R0, -8),
11897 BPF_EXIT_INSN(),
11898 },
11899 INTERNAL,
11900 { },
11901 { { 0, 123456789 } },
11902 .stack_depth = 8,
11903 },
11904 {
11905 "LDX_MEM_DW: operand register aliasing",
11906 .u.insns_int = {
11907 BPF_LD_IMM64(R1, 0x123456789abcdefULL),
11908 BPF_STX_MEM(BPF_DW, R10, R1, -8),
11909 BPF_MOV64_REG(R0, R10),
11910 BPF_LDX_MEM(BPF_DW, R0, R0, -8),
11911 BPF_ALU64_REG(BPF_SUB, R0, R1),
11912 BPF_MOV64_REG(R1, R0),
11913 BPF_ALU64_IMM(BPF_RSH, R1, 32),
11914 BPF_ALU64_REG(BPF_OR, R0, R1),
11915 BPF_EXIT_INSN(),
11916 },
11917 INTERNAL,
11918 { },
11919 { { 0, 0 } },
11920 .stack_depth = 8,
11921 },
11922 /*
11923 * Register (non-)clobbering tests for the case where a JIT implements
11924 * complex ALU or ATOMIC operations via function calls. If so, the
11925 * function call must be transparent to the eBPF registers. The JIT
11926 * must therefore save and restore relevant registers across the call.
11927 * The following tests check that the eBPF registers retain their
11928 * values after such an operation. Mainly intended for complex ALU
11929 * and atomic operation, but we run it for all. You never know...
11930 *
11931 * Note that each operations should be tested twice with different
11932 * destinations, to check preservation for all registers.
11933 */
11934 #define BPF_TEST_CLOBBER_ALU(alu, op, dst, src) \
11935 { \
11936 #alu "_" #op " to " #dst ": no clobbering", \
11937 .u.insns_int = { \
11938 BPF_ALU64_IMM(BPF_MOV, R0, R0), \
11939 BPF_ALU64_IMM(BPF_MOV, R1, R1), \
11940 BPF_ALU64_IMM(BPF_MOV, R2, R2), \
11941 BPF_ALU64_IMM(BPF_MOV, R3, R3), \
11942 BPF_ALU64_IMM(BPF_MOV, R4, R4), \
11943 BPF_ALU64_IMM(BPF_MOV, R5, R5), \
11944 BPF_ALU64_IMM(BPF_MOV, R6, R6), \
11945 BPF_ALU64_IMM(BPF_MOV, R7, R7), \
11946 BPF_ALU64_IMM(BPF_MOV, R8, R8), \
11947 BPF_ALU64_IMM(BPF_MOV, R9, R9), \
11948 BPF_##alu(BPF_ ##op, dst, src), \
11949 BPF_ALU32_IMM(BPF_MOV, dst, dst), \
11950 BPF_JMP_IMM(BPF_JNE, R0, R0, 10), \
11951 BPF_JMP_IMM(BPF_JNE, R1, R1, 9), \
11952 BPF_JMP_IMM(BPF_JNE, R2, R2, 8), \
11953 BPF_JMP_IMM(BPF_JNE, R3, R3, 7), \
11954 BPF_JMP_IMM(BPF_JNE, R4, R4, 6), \
11955 BPF_JMP_IMM(BPF_JNE, R5, R5, 5), \
11956 BPF_JMP_IMM(BPF_JNE, R6, R6, 4), \
11957 BPF_JMP_IMM(BPF_JNE, R7, R7, 3), \
11958 BPF_JMP_IMM(BPF_JNE, R8, R8, 2), \
11959 BPF_JMP_IMM(BPF_JNE, R9, R9, 1), \
11960 BPF_ALU64_IMM(BPF_MOV, R0, 1), \
11961 BPF_EXIT_INSN(), \
11962 }, \
11963 INTERNAL, \
11964 { }, \
11965 { { 0, 1 } } \
11966 }
11967 /* ALU64 operations, register clobbering */
11968 BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R8, 123456789),
11969 BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R9, 123456789),
11970 BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R8, 123456789),
11971 BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R9, 123456789),
11972 BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R8, 123456789),
11973 BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R9, 123456789),
11974 BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R8, 12),
11975 BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R9, 12),
11976 BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R8, 12),
11977 BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R9, 12),
11978 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R8, 12),
11979 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R9, 12),
11980 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R8, 123456789),
11981 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R9, 123456789),
11982 BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R8, 123456789),
11983 BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R9, 123456789),
11984 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R8, 123456789),
11985 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R9, 123456789),
11986 BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R8, 123456789),
11987 BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R9, 123456789),
11988 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R8, 123456789),
11989 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R9, 123456789),
11990 /* ALU32 immediate operations, register clobbering */
11991 BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R8, 123456789),
11992 BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R9, 123456789),
11993 BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R8, 123456789),
11994 BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R9, 123456789),
11995 BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R8, 123456789),
11996 BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R9, 123456789),
11997 BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R8, 12),
11998 BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R9, 12),
11999 BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R8, 12),
12000 BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R9, 12),
12001 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R8, 12),
12002 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R9, 12),
12003 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R8, 123456789),
12004 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R9, 123456789),
12005 BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R8, 123456789),
12006 BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R9, 123456789),
12007 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R8, 123456789),
12008 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R9, 123456789),
12009 BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R8, 123456789),
12010 BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R9, 123456789),
12011 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R8, 123456789),
12012 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R9, 123456789),
12013 /* ALU64 register operations, register clobbering */
12014 BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R8, R1),
12015 BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R9, R1),
12016 BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R8, R1),
12017 BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R9, R1),
12018 BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R8, R1),
12019 BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R9, R1),
12020 BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R8, R1),
12021 BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R9, R1),
12022 BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R8, R1),
12023 BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R9, R1),
12024 BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R8, R1),
12025 BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R9, R1),
12026 BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R8, R1),
12027 BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R9, R1),
12028 BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R8, R1),
12029 BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R9, R1),
12030 BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R8, R1),
12031 BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R9, R1),
12032 BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R8, R1),
12033 BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R9, R1),
12034 BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R8, R1),
12035 BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R9, R1),
12036 /* ALU32 register operations, register clobbering */
12037 BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R8, R1),
12038 BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R9, R1),
12039 BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R8, R1),
12040 BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R9, R1),
12041 BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R8, R1),
12042 BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R9, R1),
12043 BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R8, R1),
12044 BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R9, R1),
12045 BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R8, R1),
12046 BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R9, R1),
12047 BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R8, R1),
12048 BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R9, R1),
12049 BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R8, R1),
12050 BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R9, R1),
12051 BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R8, R1),
12052 BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R9, R1),
12053 BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R8, R1),
12054 BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R9, R1),
12055 BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R8, R1),
12056 BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R9, R1),
12057 BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R8, R1),
12058 BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R9, R1),
12059 #undef BPF_TEST_CLOBBER_ALU
12060 #define BPF_TEST_CLOBBER_ATOMIC(width, op) \
12061 { \
12062 "Atomic_" #width " " #op ": no clobbering", \
12063 .u.insns_int = { \
12064 BPF_ALU64_IMM(BPF_MOV, R0, 0), \
12065 BPF_ALU64_IMM(BPF_MOV, R1, 1), \
12066 BPF_ALU64_IMM(BPF_MOV, R2, 2), \
12067 BPF_ALU64_IMM(BPF_MOV, R3, 3), \
12068 BPF_ALU64_IMM(BPF_MOV, R4, 4), \
12069 BPF_ALU64_IMM(BPF_MOV, R5, 5), \
12070 BPF_ALU64_IMM(BPF_MOV, R6, 6), \
12071 BPF_ALU64_IMM(BPF_MOV, R7, 7), \
12072 BPF_ALU64_IMM(BPF_MOV, R8, 8), \
12073 BPF_ALU64_IMM(BPF_MOV, R9, 9), \
12074 BPF_ST_MEM(width, R10, -8, \
12075 (op) == BPF_CMPXCHG ? 0 : \
12076 (op) & BPF_FETCH ? 1 : 0), \
12077 BPF_ATOMIC_OP(width, op, R10, R1, -8), \
12078 BPF_JMP_IMM(BPF_JNE, R0, 0, 10), \
12079 BPF_JMP_IMM(BPF_JNE, R1, 1, 9), \
12080 BPF_JMP_IMM(BPF_JNE, R2, 2, 8), \
12081 BPF_JMP_IMM(BPF_JNE, R3, 3, 7), \
12082 BPF_JMP_IMM(BPF_JNE, R4, 4, 6), \
12083 BPF_JMP_IMM(BPF_JNE, R5, 5, 5), \
12084 BPF_JMP_IMM(BPF_JNE, R6, 6, 4), \
12085 BPF_JMP_IMM(BPF_JNE, R7, 7, 3), \
12086 BPF_JMP_IMM(BPF_JNE, R8, 8, 2), \
12087 BPF_JMP_IMM(BPF_JNE, R9, 9, 1), \
12088 BPF_ALU64_IMM(BPF_MOV, R0, 1), \
12089 BPF_EXIT_INSN(), \
12090 }, \
12091 INTERNAL, \
12092 { }, \
12093 { { 0, 1 } }, \
12094 .stack_depth = 8, \
12095 }
12096 /* 64-bit atomic operations, register clobbering */
12097 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD),
12098 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND),
12099 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR),
12100 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR),
12101 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD | BPF_FETCH),
12102 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND | BPF_FETCH),
12103 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR | BPF_FETCH),
12104 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR | BPF_FETCH),
12105 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XCHG),
12106 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_CMPXCHG),
12107 /* 32-bit atomic operations, register clobbering */
12108 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD),
12109 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND),
12110 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR),
12111 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR),
12112 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD | BPF_FETCH),
12113 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND | BPF_FETCH),
12114 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR | BPF_FETCH),
12115 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR | BPF_FETCH),
12116 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XCHG),
12117 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_CMPXCHG),
12118 #undef BPF_TEST_CLOBBER_ATOMIC
12119 /* Checking that ALU32 src is not zero extended in place */
12120 #define BPF_ALU32_SRC_ZEXT(op) \
12121 { \
12122 "ALU32_" #op "_X: src preserved in zext", \
12123 .u.insns_int = { \
12124 BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
12125 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
12126 BPF_ALU64_REG(BPF_MOV, R0, R1), \
12127 BPF_ALU32_REG(BPF_##op, R2, R1), \
12128 BPF_ALU64_REG(BPF_SUB, R0, R1), \
12129 BPF_ALU64_REG(BPF_MOV, R1, R0), \
12130 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
12131 BPF_ALU64_REG(BPF_OR, R0, R1), \
12132 BPF_EXIT_INSN(), \
12133 }, \
12134 INTERNAL, \
12135 { }, \
12136 { { 0, 0 } }, \
12137 }
12138 BPF_ALU32_SRC_ZEXT(MOV),
12139 BPF_ALU32_SRC_ZEXT(AND),
12140 BPF_ALU32_SRC_ZEXT(OR),
12141 BPF_ALU32_SRC_ZEXT(XOR),
12142 BPF_ALU32_SRC_ZEXT(ADD),
12143 BPF_ALU32_SRC_ZEXT(SUB),
12144 BPF_ALU32_SRC_ZEXT(MUL),
12145 BPF_ALU32_SRC_ZEXT(DIV),
12146 BPF_ALU32_SRC_ZEXT(MOD),
12147 #undef BPF_ALU32_SRC_ZEXT
12148 /* Checking that ATOMIC32 src is not zero extended in place */
12149 #define BPF_ATOMIC32_SRC_ZEXT(op) \
12150 { \
12151 "ATOMIC_W_" #op ": src preserved in zext", \
12152 .u.insns_int = { \
12153 BPF_LD_IMM64(R0, 0x0123456789acbdefULL), \
12154 BPF_ALU64_REG(BPF_MOV, R1, R0), \
12155 BPF_ST_MEM(BPF_W, R10, -4, 0), \
12156 BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4), \
12157 BPF_ALU64_REG(BPF_SUB, R0, R1), \
12158 BPF_ALU64_REG(BPF_MOV, R1, R0), \
12159 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
12160 BPF_ALU64_REG(BPF_OR, R0, R1), \
12161 BPF_EXIT_INSN(), \
12162 }, \
12163 INTERNAL, \
12164 { }, \
12165 { { 0, 0 } }, \
12166 .stack_depth = 8, \
12167 }
12168 BPF_ATOMIC32_SRC_ZEXT(ADD),
12169 BPF_ATOMIC32_SRC_ZEXT(AND),
12170 BPF_ATOMIC32_SRC_ZEXT(OR),
12171 BPF_ATOMIC32_SRC_ZEXT(XOR),
12172 #undef BPF_ATOMIC32_SRC_ZEXT
12173 /* Checking that CMPXCHG32 src is not zero extended in place */
12174 {
12175 "ATOMIC_W_CMPXCHG: src preserved in zext",
12176 .u.insns_int = {
12177 BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
12178 BPF_ALU64_REG(BPF_MOV, R2, R1),
12179 BPF_ALU64_REG(BPF_MOV, R0, 0),
12180 BPF_ST_MEM(BPF_W, R10, -4, 0),
12181 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4),
12182 BPF_ALU64_REG(BPF_SUB, R1, R2),
12183 BPF_ALU64_REG(BPF_MOV, R2, R1),
12184 BPF_ALU64_IMM(BPF_RSH, R2, 32),
12185 BPF_ALU64_REG(BPF_OR, R1, R2),
12186 BPF_ALU64_REG(BPF_MOV, R0, R1),
12187 BPF_EXIT_INSN(),
12188 },
12189 INTERNAL,
12190 { },
12191 { { 0, 0 } },
12192 .stack_depth = 8,
12193 },
12194 /* Checking that JMP32 immediate src is not zero extended in place */
12195 #define BPF_JMP32_IMM_ZEXT(op) \
12196 { \
12197 "JMP32_" #op "_K: operand preserved in zext", \
12198 .u.insns_int = { \
12199 BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
12200 BPF_ALU64_REG(BPF_MOV, R1, R0), \
12201 BPF_JMP32_IMM(BPF_##op, R0, 1234, 1), \
12202 BPF_JMP_A(0), /* Nop */ \
12203 BPF_ALU64_REG(BPF_SUB, R0, R1), \
12204 BPF_ALU64_REG(BPF_MOV, R1, R0), \
12205 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
12206 BPF_ALU64_REG(BPF_OR, R0, R1), \
12207 BPF_EXIT_INSN(), \
12208 }, \
12209 INTERNAL, \
12210 { }, \
12211 { { 0, 0 } }, \
12212 }
12213 BPF_JMP32_IMM_ZEXT(JEQ),
12214 BPF_JMP32_IMM_ZEXT(JNE),
12215 BPF_JMP32_IMM_ZEXT(JSET),
12216 BPF_JMP32_IMM_ZEXT(JGT),
12217 BPF_JMP32_IMM_ZEXT(JGE),
12218 BPF_JMP32_IMM_ZEXT(JLT),
12219 BPF_JMP32_IMM_ZEXT(JLE),
12220 BPF_JMP32_IMM_ZEXT(JSGT),
12221 BPF_JMP32_IMM_ZEXT(JSGE),
12222 BPF_JMP32_IMM_ZEXT(JSLT),
12223 BPF_JMP32_IMM_ZEXT(JSLE),
12224 #undef BPF_JMP2_IMM_ZEXT
12225 /* Checking that JMP32 dst & src are not zero extended in place */
12226 #define BPF_JMP32_REG_ZEXT(op) \
12227 { \
12228 "JMP32_" #op "_X: operands preserved in zext", \
12229 .u.insns_int = { \
12230 BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
12231 BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
12232 BPF_ALU64_REG(BPF_MOV, R2, R0), \
12233 BPF_ALU64_REG(BPF_MOV, R3, R1), \
12234 BPF_JMP32_IMM(BPF_##op, R0, R1, 1), \
12235 BPF_JMP_A(0), /* Nop */ \
12236 BPF_ALU64_REG(BPF_SUB, R0, R2), \
12237 BPF_ALU64_REG(BPF_SUB, R1, R3), \
12238 BPF_ALU64_REG(BPF_OR, R0, R1), \
12239 BPF_ALU64_REG(BPF_MOV, R1, R0), \
12240 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
12241 BPF_ALU64_REG(BPF_OR, R0, R1), \
12242 BPF_EXIT_INSN(), \
12243 }, \
12244 INTERNAL, \
12245 { }, \
12246 { { 0, 0 } }, \
12247 }
12248 BPF_JMP32_REG_ZEXT(JEQ),
12249 BPF_JMP32_REG_ZEXT(JNE),
12250 BPF_JMP32_REG_ZEXT(JSET),
12251 BPF_JMP32_REG_ZEXT(JGT),
12252 BPF_JMP32_REG_ZEXT(JGE),
12253 BPF_JMP32_REG_ZEXT(JLT),
12254 BPF_JMP32_REG_ZEXT(JLE),
12255 BPF_JMP32_REG_ZEXT(JSGT),
12256 BPF_JMP32_REG_ZEXT(JSGE),
12257 BPF_JMP32_REG_ZEXT(JSLT),
12258 BPF_JMP32_REG_ZEXT(JSLE),
12259 #undef BPF_JMP2_REG_ZEXT
12260 /* ALU64 K register combinations */
12261 {
12262 "ALU64_MOV_K: registers",
12263 { },
12264 INTERNAL,
12265 { },
12266 { { 0, 1 } },
12267 .fill_helper = bpf_fill_alu64_mov_imm_regs,
12268 },
12269 {
12270 "ALU64_AND_K: registers",
12271 { },
12272 INTERNAL,
12273 { },
12274 { { 0, 1 } },
12275 .fill_helper = bpf_fill_alu64_and_imm_regs,
12276 },
12277 {
12278 "ALU64_OR_K: registers",
12279 { },
12280 INTERNAL,
12281 { },
12282 { { 0, 1 } },
12283 .fill_helper = bpf_fill_alu64_or_imm_regs,
12284 },
12285 {
12286 "ALU64_XOR_K: registers",
12287 { },
12288 INTERNAL,
12289 { },
12290 { { 0, 1 } },
12291 .fill_helper = bpf_fill_alu64_xor_imm_regs,
12292 },
12293 {
12294 "ALU64_LSH_K: registers",
12295 { },
12296 INTERNAL,
12297 { },
12298 { { 0, 1 } },
12299 .fill_helper = bpf_fill_alu64_lsh_imm_regs,
12300 },
12301 {
12302 "ALU64_RSH_K: registers",
12303 { },
12304 INTERNAL,
12305 { },
12306 { { 0, 1 } },
12307 .fill_helper = bpf_fill_alu64_rsh_imm_regs,
12308 },
12309 {
12310 "ALU64_ARSH_K: registers",
12311 { },
12312 INTERNAL,
12313 { },
12314 { { 0, 1 } },
12315 .fill_helper = bpf_fill_alu64_arsh_imm_regs,
12316 },
12317 {
12318 "ALU64_ADD_K: registers",
12319 { },
12320 INTERNAL,
12321 { },
12322 { { 0, 1 } },
12323 .fill_helper = bpf_fill_alu64_add_imm_regs,
12324 },
12325 {
12326 "ALU64_SUB_K: registers",
12327 { },
12328 INTERNAL,
12329 { },
12330 { { 0, 1 } },
12331 .fill_helper = bpf_fill_alu64_sub_imm_regs,
12332 },
12333 {
12334 "ALU64_MUL_K: registers",
12335 { },
12336 INTERNAL,
12337 { },
12338 { { 0, 1 } },
12339 .fill_helper = bpf_fill_alu64_mul_imm_regs,
12340 },
12341 {
12342 "ALU64_DIV_K: registers",
12343 { },
12344 INTERNAL,
12345 { },
12346 { { 0, 1 } },
12347 .fill_helper = bpf_fill_alu64_div_imm_regs,
12348 },
12349 {
12350 "ALU64_MOD_K: registers",
12351 { },
12352 INTERNAL,
12353 { },
12354 { { 0, 1 } },
12355 .fill_helper = bpf_fill_alu64_mod_imm_regs,
12356 },
12357 /* ALU32 K registers */
12358 {
12359 "ALU32_MOV_K: registers",
12360 { },
12361 INTERNAL,
12362 { },
12363 { { 0, 1 } },
12364 .fill_helper = bpf_fill_alu32_mov_imm_regs,
12365 },
12366 {
12367 "ALU32_AND_K: registers",
12368 { },
12369 INTERNAL,
12370 { },
12371 { { 0, 1 } },
12372 .fill_helper = bpf_fill_alu32_and_imm_regs,
12373 },
12374 {
12375 "ALU32_OR_K: registers",
12376 { },
12377 INTERNAL,
12378 { },
12379 { { 0, 1 } },
12380 .fill_helper = bpf_fill_alu32_or_imm_regs,
12381 },
12382 {
12383 "ALU32_XOR_K: registers",
12384 { },
12385 INTERNAL,
12386 { },
12387 { { 0, 1 } },
12388 .fill_helper = bpf_fill_alu32_xor_imm_regs,
12389 },
12390 {
12391 "ALU32_LSH_K: registers",
12392 { },
12393 INTERNAL,
12394 { },
12395 { { 0, 1 } },
12396 .fill_helper = bpf_fill_alu32_lsh_imm_regs,
12397 },
12398 {
12399 "ALU32_RSH_K: registers",
12400 { },
12401 INTERNAL,
12402 { },
12403 { { 0, 1 } },
12404 .fill_helper = bpf_fill_alu32_rsh_imm_regs,
12405 },
12406 {
12407 "ALU32_ARSH_K: registers",
12408 { },
12409 INTERNAL,
12410 { },
12411 { { 0, 1 } },
12412 .fill_helper = bpf_fill_alu32_arsh_imm_regs,
12413 },
12414 {
12415 "ALU32_ADD_K: registers",
12416 { },
12417 INTERNAL,
12418 { },
12419 { { 0, 1 } },
12420 .fill_helper = bpf_fill_alu32_add_imm_regs,
12421 },
12422 {
12423 "ALU32_SUB_K: registers",
12424 { },
12425 INTERNAL,
12426 { },
12427 { { 0, 1 } },
12428 .fill_helper = bpf_fill_alu32_sub_imm_regs,
12429 },
12430 {
12431 "ALU32_MUL_K: registers",
12432 { },
12433 INTERNAL,
12434 { },
12435 { { 0, 1 } },
12436 .fill_helper = bpf_fill_alu32_mul_imm_regs,
12437 },
12438 {
12439 "ALU32_DIV_K: registers",
12440 { },
12441 INTERNAL,
12442 { },
12443 { { 0, 1 } },
12444 .fill_helper = bpf_fill_alu32_div_imm_regs,
12445 },
12446 {
12447 "ALU32_MOD_K: registers",
12448 { },
12449 INTERNAL,
12450 { },
12451 { { 0, 1 } },
12452 .fill_helper = bpf_fill_alu32_mod_imm_regs,
12453 },
12454 /* ALU64 X register combinations */
12455 {
12456 "ALU64_MOV_X: register combinations",
12457 { },
12458 INTERNAL,
12459 { },
12460 { { 0, 1 } },
12461 .fill_helper = bpf_fill_alu64_mov_reg_pairs,
12462 },
12463 {
12464 "ALU64_AND_X: register combinations",
12465 { },
12466 INTERNAL,
12467 { },
12468 { { 0, 1 } },
12469 .fill_helper = bpf_fill_alu64_and_reg_pairs,
12470 },
12471 {
12472 "ALU64_OR_X: register combinations",
12473 { },
12474 INTERNAL,
12475 { },
12476 { { 0, 1 } },
12477 .fill_helper = bpf_fill_alu64_or_reg_pairs,
12478 },
12479 {
12480 "ALU64_XOR_X: register combinations",
12481 { },
12482 INTERNAL,
12483 { },
12484 { { 0, 1 } },
12485 .fill_helper = bpf_fill_alu64_xor_reg_pairs,
12486 },
12487 {
12488 "ALU64_LSH_X: register combinations",
12489 { },
12490 INTERNAL,
12491 { },
12492 { { 0, 1 } },
12493 .fill_helper = bpf_fill_alu64_lsh_reg_pairs,
12494 },
12495 {
12496 "ALU64_RSH_X: register combinations",
12497 { },
12498 INTERNAL,
12499 { },
12500 { { 0, 1 } },
12501 .fill_helper = bpf_fill_alu64_rsh_reg_pairs,
12502 },
12503 {
12504 "ALU64_ARSH_X: register combinations",
12505 { },
12506 INTERNAL,
12507 { },
12508 { { 0, 1 } },
12509 .fill_helper = bpf_fill_alu64_arsh_reg_pairs,
12510 },
12511 {
12512 "ALU64_ADD_X: register combinations",
12513 { },
12514 INTERNAL,
12515 { },
12516 { { 0, 1 } },
12517 .fill_helper = bpf_fill_alu64_add_reg_pairs,
12518 },
12519 {
12520 "ALU64_SUB_X: register combinations",
12521 { },
12522 INTERNAL,
12523 { },
12524 { { 0, 1 } },
12525 .fill_helper = bpf_fill_alu64_sub_reg_pairs,
12526 },
12527 {
12528 "ALU64_MUL_X: register combinations",
12529 { },
12530 INTERNAL,
12531 { },
12532 { { 0, 1 } },
12533 .fill_helper = bpf_fill_alu64_mul_reg_pairs,
12534 },
12535 {
12536 "ALU64_DIV_X: register combinations",
12537 { },
12538 INTERNAL,
12539 { },
12540 { { 0, 1 } },
12541 .fill_helper = bpf_fill_alu64_div_reg_pairs,
12542 },
12543 {
12544 "ALU64_MOD_X: register combinations",
12545 { },
12546 INTERNAL,
12547 { },
12548 { { 0, 1 } },
12549 .fill_helper = bpf_fill_alu64_mod_reg_pairs,
12550 },
12551 /* ALU32 X register combinations */
12552 {
12553 "ALU32_MOV_X: register combinations",
12554 { },
12555 INTERNAL,
12556 { },
12557 { { 0, 1 } },
12558 .fill_helper = bpf_fill_alu32_mov_reg_pairs,
12559 },
12560 {
12561 "ALU32_AND_X: register combinations",
12562 { },
12563 INTERNAL,
12564 { },
12565 { { 0, 1 } },
12566 .fill_helper = bpf_fill_alu32_and_reg_pairs,
12567 },
12568 {
12569 "ALU32_OR_X: register combinations",
12570 { },
12571 INTERNAL,
12572 { },
12573 { { 0, 1 } },
12574 .fill_helper = bpf_fill_alu32_or_reg_pairs,
12575 },
12576 {
12577 "ALU32_XOR_X: register combinations",
12578 { },
12579 INTERNAL,
12580 { },
12581 { { 0, 1 } },
12582 .fill_helper = bpf_fill_alu32_xor_reg_pairs,
12583 },
12584 {
12585 "ALU32_LSH_X: register combinations",
12586 { },
12587 INTERNAL,
12588 { },
12589 { { 0, 1 } },
12590 .fill_helper = bpf_fill_alu32_lsh_reg_pairs,
12591 },
12592 {
12593 "ALU32_RSH_X: register combinations",
12594 { },
12595 INTERNAL,
12596 { },
12597 { { 0, 1 } },
12598 .fill_helper = bpf_fill_alu32_rsh_reg_pairs,
12599 },
12600 {
12601 "ALU32_ARSH_X: register combinations",
12602 { },
12603 INTERNAL,
12604 { },
12605 { { 0, 1 } },
12606 .fill_helper = bpf_fill_alu32_arsh_reg_pairs,
12607 },
12608 {
12609 "ALU32_ADD_X: register combinations",
12610 { },
12611 INTERNAL,
12612 { },
12613 { { 0, 1 } },
12614 .fill_helper = bpf_fill_alu32_add_reg_pairs,
12615 },
12616 {
12617 "ALU32_SUB_X: register combinations",
12618 { },
12619 INTERNAL,
12620 { },
12621 { { 0, 1 } },
12622 .fill_helper = bpf_fill_alu32_sub_reg_pairs,
12623 },
12624 {
12625 "ALU32_MUL_X: register combinations",
12626 { },
12627 INTERNAL,
12628 { },
12629 { { 0, 1 } },
12630 .fill_helper = bpf_fill_alu32_mul_reg_pairs,
12631 },
12632 {
12633 "ALU32_DIV_X: register combinations",
12634 { },
12635 INTERNAL,
12636 { },
12637 { { 0, 1 } },
12638 .fill_helper = bpf_fill_alu32_div_reg_pairs,
12639 },
12640 {
12641 "ALU32_MOD_X register combinations",
12642 { },
12643 INTERNAL,
12644 { },
12645 { { 0, 1 } },
12646 .fill_helper = bpf_fill_alu32_mod_reg_pairs,
12647 },
12648 /* Exhaustive test of ALU64 shift operations */
12649 {
12650 "ALU64_LSH_K: all shift values",
12651 { },
12652 INTERNAL | FLAG_NO_DATA,
12653 { },
12654 { { 0, 1 } },
12655 .fill_helper = bpf_fill_alu64_lsh_imm,
12656 },
12657 {
12658 "ALU64_RSH_K: all shift values",
12659 { },
12660 INTERNAL | FLAG_NO_DATA,
12661 { },
12662 { { 0, 1 } },
12663 .fill_helper = bpf_fill_alu64_rsh_imm,
12664 },
12665 {
12666 "ALU64_ARSH_K: all shift values",
12667 { },
12668 INTERNAL | FLAG_NO_DATA,
12669 { },
12670 { { 0, 1 } },
12671 .fill_helper = bpf_fill_alu64_arsh_imm,
12672 },
12673 {
12674 "ALU64_LSH_X: all shift values",
12675 { },
12676 INTERNAL | FLAG_NO_DATA,
12677 { },
12678 { { 0, 1 } },
12679 .fill_helper = bpf_fill_alu64_lsh_reg,
12680 },
12681 {
12682 "ALU64_RSH_X: all shift values",
12683 { },
12684 INTERNAL | FLAG_NO_DATA,
12685 { },
12686 { { 0, 1 } },
12687 .fill_helper = bpf_fill_alu64_rsh_reg,
12688 },
12689 {
12690 "ALU64_ARSH_X: all shift values",
12691 { },
12692 INTERNAL | FLAG_NO_DATA,
12693 { },
12694 { { 0, 1 } },
12695 .fill_helper = bpf_fill_alu64_arsh_reg,
12696 },
12697 /* Exhaustive test of ALU32 shift operations */
12698 {
12699 "ALU32_LSH_K: all shift values",
12700 { },
12701 INTERNAL | FLAG_NO_DATA,
12702 { },
12703 { { 0, 1 } },
12704 .fill_helper = bpf_fill_alu32_lsh_imm,
12705 },
12706 {
12707 "ALU32_RSH_K: all shift values",
12708 { },
12709 INTERNAL | FLAG_NO_DATA,
12710 { },
12711 { { 0, 1 } },
12712 .fill_helper = bpf_fill_alu32_rsh_imm,
12713 },
12714 {
12715 "ALU32_ARSH_K: all shift values",
12716 { },
12717 INTERNAL | FLAG_NO_DATA,
12718 { },
12719 { { 0, 1 } },
12720 .fill_helper = bpf_fill_alu32_arsh_imm,
12721 },
12722 {
12723 "ALU32_LSH_X: all shift values",
12724 { },
12725 INTERNAL | FLAG_NO_DATA,
12726 { },
12727 { { 0, 1 } },
12728 .fill_helper = bpf_fill_alu32_lsh_reg,
12729 },
12730 {
12731 "ALU32_RSH_X: all shift values",
12732 { },
12733 INTERNAL | FLAG_NO_DATA,
12734 { },
12735 { { 0, 1 } },
12736 .fill_helper = bpf_fill_alu32_rsh_reg,
12737 },
12738 {
12739 "ALU32_ARSH_X: all shift values",
12740 { },
12741 INTERNAL | FLAG_NO_DATA,
12742 { },
12743 { { 0, 1 } },
12744 .fill_helper = bpf_fill_alu32_arsh_reg,
12745 },
12746 /*
12747 * Exhaustive test of ALU64 shift operations when
12748 * source and destination register are the same.
12749 */
12750 {
12751 "ALU64_LSH_X: all shift values with the same register",
12752 { },
12753 INTERNAL | FLAG_NO_DATA,
12754 { },
12755 { { 0, 1 } },
12756 .fill_helper = bpf_fill_alu64_lsh_same_reg,
12757 },
12758 {
12759 "ALU64_RSH_X: all shift values with the same register",
12760 { },
12761 INTERNAL | FLAG_NO_DATA,
12762 { },
12763 { { 0, 1 } },
12764 .fill_helper = bpf_fill_alu64_rsh_same_reg,
12765 },
12766 {
12767 "ALU64_ARSH_X: all shift values with the same register",
12768 { },
12769 INTERNAL | FLAG_NO_DATA,
12770 { },
12771 { { 0, 1 } },
12772 .fill_helper = bpf_fill_alu64_arsh_same_reg,
12773 },
12774 /*
12775 * Exhaustive test of ALU32 shift operations when
12776 * source and destination register are the same.
12777 */
12778 {
12779 "ALU32_LSH_X: all shift values with the same register",
12780 { },
12781 INTERNAL | FLAG_NO_DATA,
12782 { },
12783 { { 0, 1 } },
12784 .fill_helper = bpf_fill_alu32_lsh_same_reg,
12785 },
12786 {
12787 "ALU32_RSH_X: all shift values with the same register",
12788 { },
12789 INTERNAL | FLAG_NO_DATA,
12790 { },
12791 { { 0, 1 } },
12792 .fill_helper = bpf_fill_alu32_rsh_same_reg,
12793 },
12794 {
12795 "ALU32_ARSH_X: all shift values with the same register",
12796 { },
12797 INTERNAL | FLAG_NO_DATA,
12798 { },
12799 { { 0, 1 } },
12800 .fill_helper = bpf_fill_alu32_arsh_same_reg,
12801 },
12802 /* ALU64 immediate magnitudes */
12803 {
12804 "ALU64_MOV_K: all immediate value magnitudes",
12805 { },
12806 INTERNAL | FLAG_NO_DATA,
12807 { },
12808 { { 0, 1 } },
12809 .fill_helper = bpf_fill_alu64_mov_imm,
12810 .nr_testruns = NR_PATTERN_RUNS,
12811 },
12812 {
12813 "ALU64_AND_K: all immediate value magnitudes",
12814 { },
12815 INTERNAL | FLAG_NO_DATA,
12816 { },
12817 { { 0, 1 } },
12818 .fill_helper = bpf_fill_alu64_and_imm,
12819 .nr_testruns = NR_PATTERN_RUNS,
12820 },
12821 {
12822 "ALU64_OR_K: all immediate value magnitudes",
12823 { },
12824 INTERNAL | FLAG_NO_DATA,
12825 { },
12826 { { 0, 1 } },
12827 .fill_helper = bpf_fill_alu64_or_imm,
12828 .nr_testruns = NR_PATTERN_RUNS,
12829 },
12830 {
12831 "ALU64_XOR_K: all immediate value magnitudes",
12832 { },
12833 INTERNAL | FLAG_NO_DATA,
12834 { },
12835 { { 0, 1 } },
12836 .fill_helper = bpf_fill_alu64_xor_imm,
12837 .nr_testruns = NR_PATTERN_RUNS,
12838 },
12839 {
12840 "ALU64_ADD_K: all immediate value magnitudes",
12841 { },
12842 INTERNAL | FLAG_NO_DATA,
12843 { },
12844 { { 0, 1 } },
12845 .fill_helper = bpf_fill_alu64_add_imm,
12846 .nr_testruns = NR_PATTERN_RUNS,
12847 },
12848 {
12849 "ALU64_SUB_K: all immediate value magnitudes",
12850 { },
12851 INTERNAL | FLAG_NO_DATA,
12852 { },
12853 { { 0, 1 } },
12854 .fill_helper = bpf_fill_alu64_sub_imm,
12855 .nr_testruns = NR_PATTERN_RUNS,
12856 },
12857 {
12858 "ALU64_MUL_K: all immediate value magnitudes",
12859 { },
12860 INTERNAL | FLAG_NO_DATA,
12861 { },
12862 { { 0, 1 } },
12863 .fill_helper = bpf_fill_alu64_mul_imm,
12864 .nr_testruns = NR_PATTERN_RUNS,
12865 },
12866 {
12867 "ALU64_DIV_K: all immediate value magnitudes",
12868 { },
12869 INTERNAL | FLAG_NO_DATA,
12870 { },
12871 { { 0, 1 } },
12872 .fill_helper = bpf_fill_alu64_div_imm,
12873 .nr_testruns = NR_PATTERN_RUNS,
12874 },
12875 {
12876 "ALU64_MOD_K: all immediate value magnitudes",
12877 { },
12878 INTERNAL | FLAG_NO_DATA,
12879 { },
12880 { { 0, 1 } },
12881 .fill_helper = bpf_fill_alu64_mod_imm,
12882 .nr_testruns = NR_PATTERN_RUNS,
12883 },
12884 /* ALU32 immediate magnitudes */
12885 {
12886 "ALU32_MOV_K: all immediate value magnitudes",
12887 { },
12888 INTERNAL | FLAG_NO_DATA,
12889 { },
12890 { { 0, 1 } },
12891 .fill_helper = bpf_fill_alu32_mov_imm,
12892 .nr_testruns = NR_PATTERN_RUNS,
12893 },
12894 {
12895 "ALU32_AND_K: all immediate value magnitudes",
12896 { },
12897 INTERNAL | FLAG_NO_DATA,
12898 { },
12899 { { 0, 1 } },
12900 .fill_helper = bpf_fill_alu32_and_imm,
12901 .nr_testruns = NR_PATTERN_RUNS,
12902 },
12903 {
12904 "ALU32_OR_K: all immediate value magnitudes",
12905 { },
12906 INTERNAL | FLAG_NO_DATA,
12907 { },
12908 { { 0, 1 } },
12909 .fill_helper = bpf_fill_alu32_or_imm,
12910 .nr_testruns = NR_PATTERN_RUNS,
12911 },
12912 {
12913 "ALU32_XOR_K: all immediate value magnitudes",
12914 { },
12915 INTERNAL | FLAG_NO_DATA,
12916 { },
12917 { { 0, 1 } },
12918 .fill_helper = bpf_fill_alu32_xor_imm,
12919 .nr_testruns = NR_PATTERN_RUNS,
12920 },
12921 {
12922 "ALU32_ADD_K: all immediate value magnitudes",
12923 { },
12924 INTERNAL | FLAG_NO_DATA,
12925 { },
12926 { { 0, 1 } },
12927 .fill_helper = bpf_fill_alu32_add_imm,
12928 .nr_testruns = NR_PATTERN_RUNS,
12929 },
12930 {
12931 "ALU32_SUB_K: all immediate value magnitudes",
12932 { },
12933 INTERNAL | FLAG_NO_DATA,
12934 { },
12935 { { 0, 1 } },
12936 .fill_helper = bpf_fill_alu32_sub_imm,
12937 .nr_testruns = NR_PATTERN_RUNS,
12938 },
12939 {
12940 "ALU32_MUL_K: all immediate value magnitudes",
12941 { },
12942 INTERNAL | FLAG_NO_DATA,
12943 { },
12944 { { 0, 1 } },
12945 .fill_helper = bpf_fill_alu32_mul_imm,
12946 .nr_testruns = NR_PATTERN_RUNS,
12947 },
12948 {
12949 "ALU32_DIV_K: all immediate value magnitudes",
12950 { },
12951 INTERNAL | FLAG_NO_DATA,
12952 { },
12953 { { 0, 1 } },
12954 .fill_helper = bpf_fill_alu32_div_imm,
12955 .nr_testruns = NR_PATTERN_RUNS,
12956 },
12957 {
12958 "ALU32_MOD_K: all immediate value magnitudes",
12959 { },
12960 INTERNAL | FLAG_NO_DATA,
12961 { },
12962 { { 0, 1 } },
12963 .fill_helper = bpf_fill_alu32_mod_imm,
12964 .nr_testruns = NR_PATTERN_RUNS,
12965 },
12966 /* ALU64 register magnitudes */
12967 {
12968 "ALU64_MOV_X: all register value magnitudes",
12969 { },
12970 INTERNAL | FLAG_NO_DATA,
12971 { },
12972 { { 0, 1 } },
12973 .fill_helper = bpf_fill_alu64_mov_reg,
12974 .nr_testruns = NR_PATTERN_RUNS,
12975 },
12976 {
12977 "ALU64_AND_X: all register value magnitudes",
12978 { },
12979 INTERNAL | FLAG_NO_DATA,
12980 { },
12981 { { 0, 1 } },
12982 .fill_helper = bpf_fill_alu64_and_reg,
12983 .nr_testruns = NR_PATTERN_RUNS,
12984 },
12985 {
12986 "ALU64_OR_X: all register value magnitudes",
12987 { },
12988 INTERNAL | FLAG_NO_DATA,
12989 { },
12990 { { 0, 1 } },
12991 .fill_helper = bpf_fill_alu64_or_reg,
12992 .nr_testruns = NR_PATTERN_RUNS,
12993 },
12994 {
12995 "ALU64_XOR_X: all register value magnitudes",
12996 { },
12997 INTERNAL | FLAG_NO_DATA,
12998 { },
12999 { { 0, 1 } },
13000 .fill_helper = bpf_fill_alu64_xor_reg,
13001 .nr_testruns = NR_PATTERN_RUNS,
13002 },
13003 {
13004 "ALU64_ADD_X: all register value magnitudes",
13005 { },
13006 INTERNAL | FLAG_NO_DATA,
13007 { },
13008 { { 0, 1 } },
13009 .fill_helper = bpf_fill_alu64_add_reg,
13010 .nr_testruns = NR_PATTERN_RUNS,
13011 },
13012 {
13013 "ALU64_SUB_X: all register value magnitudes",
13014 { },
13015 INTERNAL | FLAG_NO_DATA,
13016 { },
13017 { { 0, 1 } },
13018 .fill_helper = bpf_fill_alu64_sub_reg,
13019 .nr_testruns = NR_PATTERN_RUNS,
13020 },
13021 {
13022 "ALU64_MUL_X: all register value magnitudes",
13023 { },
13024 INTERNAL | FLAG_NO_DATA,
13025 { },
13026 { { 0, 1 } },
13027 .fill_helper = bpf_fill_alu64_mul_reg,
13028 .nr_testruns = NR_PATTERN_RUNS,
13029 },
13030 {
13031 "ALU64_DIV_X: all register value magnitudes",
13032 { },
13033 INTERNAL | FLAG_NO_DATA,
13034 { },
13035 { { 0, 1 } },
13036 .fill_helper = bpf_fill_alu64_div_reg,
13037 .nr_testruns = NR_PATTERN_RUNS,
13038 },
13039 {
13040 "ALU64_MOD_X: all register value magnitudes",
13041 { },
13042 INTERNAL | FLAG_NO_DATA,
13043 { },
13044 { { 0, 1 } },
13045 .fill_helper = bpf_fill_alu64_mod_reg,
13046 .nr_testruns = NR_PATTERN_RUNS,
13047 },
13048 /* ALU32 register magnitudes */
13049 {
13050 "ALU32_MOV_X: all register value magnitudes",
13051 { },
13052 INTERNAL | FLAG_NO_DATA,
13053 { },
13054 { { 0, 1 } },
13055 .fill_helper = bpf_fill_alu32_mov_reg,
13056 .nr_testruns = NR_PATTERN_RUNS,
13057 },
13058 {
13059 "ALU32_AND_X: all register value magnitudes",
13060 { },
13061 INTERNAL | FLAG_NO_DATA,
13062 { },
13063 { { 0, 1 } },
13064 .fill_helper = bpf_fill_alu32_and_reg,
13065 .nr_testruns = NR_PATTERN_RUNS,
13066 },
13067 {
13068 "ALU32_OR_X: all register value magnitudes",
13069 { },
13070 INTERNAL | FLAG_NO_DATA,
13071 { },
13072 { { 0, 1 } },
13073 .fill_helper = bpf_fill_alu32_or_reg,
13074 .nr_testruns = NR_PATTERN_RUNS,
13075 },
13076 {
13077 "ALU32_XOR_X: all register value magnitudes",
13078 { },
13079 INTERNAL | FLAG_NO_DATA,
13080 { },
13081 { { 0, 1 } },
13082 .fill_helper = bpf_fill_alu32_xor_reg,
13083 .nr_testruns = NR_PATTERN_RUNS,
13084 },
13085 {
13086 "ALU32_ADD_X: all register value magnitudes",
13087 { },
13088 INTERNAL | FLAG_NO_DATA,
13089 { },
13090 { { 0, 1 } },
13091 .fill_helper = bpf_fill_alu32_add_reg,
13092 .nr_testruns = NR_PATTERN_RUNS,
13093 },
13094 {
13095 "ALU32_SUB_X: all register value magnitudes",
13096 { },
13097 INTERNAL | FLAG_NO_DATA,
13098 { },
13099 { { 0, 1 } },
13100 .fill_helper = bpf_fill_alu32_sub_reg,
13101 .nr_testruns = NR_PATTERN_RUNS,
13102 },
13103 {
13104 "ALU32_MUL_X: all register value magnitudes",
13105 { },
13106 INTERNAL | FLAG_NO_DATA,
13107 { },
13108 { { 0, 1 } },
13109 .fill_helper = bpf_fill_alu32_mul_reg,
13110 .nr_testruns = NR_PATTERN_RUNS,
13111 },
13112 {
13113 "ALU32_DIV_X: all register value magnitudes",
13114 { },
13115 INTERNAL | FLAG_NO_DATA,
13116 { },
13117 { { 0, 1 } },
13118 .fill_helper = bpf_fill_alu32_div_reg,
13119 .nr_testruns = NR_PATTERN_RUNS,
13120 },
13121 {
13122 "ALU32_MOD_X: all register value magnitudes",
13123 { },
13124 INTERNAL | FLAG_NO_DATA,
13125 { },
13126 { { 0, 1 } },
13127 .fill_helper = bpf_fill_alu32_mod_reg,
13128 .nr_testruns = NR_PATTERN_RUNS,
13129 },
13130 /* LD_IMM64 immediate magnitudes and byte patterns */
13131 {
13132 "LD_IMM64: all immediate value magnitudes",
13133 { },
13134 INTERNAL | FLAG_NO_DATA,
13135 { },
13136 { { 0, 1 } },
13137 .fill_helper = bpf_fill_ld_imm64_magn,
13138 },
13139 {
13140 "LD_IMM64: checker byte patterns",
13141 { },
13142 INTERNAL | FLAG_NO_DATA,
13143 { },
13144 { { 0, 1 } },
13145 .fill_helper = bpf_fill_ld_imm64_checker,
13146 },
13147 {
13148 "LD_IMM64: random positive and zero byte patterns",
13149 { },
13150 INTERNAL | FLAG_NO_DATA,
13151 { },
13152 { { 0, 1 } },
13153 .fill_helper = bpf_fill_ld_imm64_pos_zero,
13154 },
13155 {
13156 "LD_IMM64: random negative and zero byte patterns",
13157 { },
13158 INTERNAL | FLAG_NO_DATA,
13159 { },
13160 { { 0, 1 } },
13161 .fill_helper = bpf_fill_ld_imm64_neg_zero,
13162 },
13163 {
13164 "LD_IMM64: random positive and negative byte patterns",
13165 { },
13166 INTERNAL | FLAG_NO_DATA,
13167 { },
13168 { { 0, 1 } },
13169 .fill_helper = bpf_fill_ld_imm64_pos_neg,
13170 },
13171 /* 64-bit ATOMIC register combinations */
13172 {
13173 "ATOMIC_DW_ADD: register combinations",
13174 { },
13175 INTERNAL,
13176 { },
13177 { { 0, 1 } },
13178 .fill_helper = bpf_fill_atomic64_add_reg_pairs,
13179 .stack_depth = 8,
13180 },
13181 {
13182 "ATOMIC_DW_AND: register combinations",
13183 { },
13184 INTERNAL,
13185 { },
13186 { { 0, 1 } },
13187 .fill_helper = bpf_fill_atomic64_and_reg_pairs,
13188 .stack_depth = 8,
13189 },
13190 {
13191 "ATOMIC_DW_OR: register combinations",
13192 { },
13193 INTERNAL,
13194 { },
13195 { { 0, 1 } },
13196 .fill_helper = bpf_fill_atomic64_or_reg_pairs,
13197 .stack_depth = 8,
13198 },
13199 {
13200 "ATOMIC_DW_XOR: register combinations",
13201 { },
13202 INTERNAL,
13203 { },
13204 { { 0, 1 } },
13205 .fill_helper = bpf_fill_atomic64_xor_reg_pairs,
13206 .stack_depth = 8,
13207 },
13208 {
13209 "ATOMIC_DW_ADD_FETCH: register combinations",
13210 { },
13211 INTERNAL,
13212 { },
13213 { { 0, 1 } },
13214 .fill_helper = bpf_fill_atomic64_add_fetch_reg_pairs,
13215 .stack_depth = 8,
13216 },
13217 {
13218 "ATOMIC_DW_AND_FETCH: register combinations",
13219 { },
13220 INTERNAL,
13221 { },
13222 { { 0, 1 } },
13223 .fill_helper = bpf_fill_atomic64_and_fetch_reg_pairs,
13224 .stack_depth = 8,
13225 },
13226 {
13227 "ATOMIC_DW_OR_FETCH: register combinations",
13228 { },
13229 INTERNAL,
13230 { },
13231 { { 0, 1 } },
13232 .fill_helper = bpf_fill_atomic64_or_fetch_reg_pairs,
13233 .stack_depth = 8,
13234 },
13235 {
13236 "ATOMIC_DW_XOR_FETCH: register combinations",
13237 { },
13238 INTERNAL,
13239 { },
13240 { { 0, 1 } },
13241 .fill_helper = bpf_fill_atomic64_xor_fetch_reg_pairs,
13242 .stack_depth = 8,
13243 },
13244 {
13245 "ATOMIC_DW_XCHG: register combinations",
13246 { },
13247 INTERNAL,
13248 { },
13249 { { 0, 1 } },
13250 .fill_helper = bpf_fill_atomic64_xchg_reg_pairs,
13251 .stack_depth = 8,
13252 },
13253 {
13254 "ATOMIC_DW_CMPXCHG: register combinations",
13255 { },
13256 INTERNAL,
13257 { },
13258 { { 0, 1 } },
13259 .fill_helper = bpf_fill_atomic64_cmpxchg_reg_pairs,
13260 .stack_depth = 8,
13261 },
13262 /* 32-bit ATOMIC register combinations */
13263 {
13264 "ATOMIC_W_ADD: register combinations",
13265 { },
13266 INTERNAL,
13267 { },
13268 { { 0, 1 } },
13269 .fill_helper = bpf_fill_atomic32_add_reg_pairs,
13270 .stack_depth = 8,
13271 },
13272 {
13273 "ATOMIC_W_AND: register combinations",
13274 { },
13275 INTERNAL,
13276 { },
13277 { { 0, 1 } },
13278 .fill_helper = bpf_fill_atomic32_and_reg_pairs,
13279 .stack_depth = 8,
13280 },
13281 {
13282 "ATOMIC_W_OR: register combinations",
13283 { },
13284 INTERNAL,
13285 { },
13286 { { 0, 1 } },
13287 .fill_helper = bpf_fill_atomic32_or_reg_pairs,
13288 .stack_depth = 8,
13289 },
13290 {
13291 "ATOMIC_W_XOR: register combinations",
13292 { },
13293 INTERNAL,
13294 { },
13295 { { 0, 1 } },
13296 .fill_helper = bpf_fill_atomic32_xor_reg_pairs,
13297 .stack_depth = 8,
13298 },
13299 {
13300 "ATOMIC_W_ADD_FETCH: register combinations",
13301 { },
13302 INTERNAL,
13303 { },
13304 { { 0, 1 } },
13305 .fill_helper = bpf_fill_atomic32_add_fetch_reg_pairs,
13306 .stack_depth = 8,
13307 },
13308 {
13309 "ATOMIC_W_AND_FETCH: register combinations",
13310 { },
13311 INTERNAL,
13312 { },
13313 { { 0, 1 } },
13314 .fill_helper = bpf_fill_atomic32_and_fetch_reg_pairs,
13315 .stack_depth = 8,
13316 },
13317 {
13318 "ATOMIC_W_OR_FETCH: register combinations",
13319 { },
13320 INTERNAL,
13321 { },
13322 { { 0, 1 } },
13323 .fill_helper = bpf_fill_atomic32_or_fetch_reg_pairs,
13324 .stack_depth = 8,
13325 },
13326 {
13327 "ATOMIC_W_XOR_FETCH: register combinations",
13328 { },
13329 INTERNAL,
13330 { },
13331 { { 0, 1 } },
13332 .fill_helper = bpf_fill_atomic32_xor_fetch_reg_pairs,
13333 .stack_depth = 8,
13334 },
13335 {
13336 "ATOMIC_W_XCHG: register combinations",
13337 { },
13338 INTERNAL,
13339 { },
13340 { { 0, 1 } },
13341 .fill_helper = bpf_fill_atomic32_xchg_reg_pairs,
13342 .stack_depth = 8,
13343 },
13344 {
13345 "ATOMIC_W_CMPXCHG: register combinations",
13346 { },
13347 INTERNAL,
13348 { },
13349 { { 0, 1 } },
13350 .fill_helper = bpf_fill_atomic32_cmpxchg_reg_pairs,
13351 .stack_depth = 8,
13352 },
13353 /* 64-bit ATOMIC magnitudes */
13354 {
13355 "ATOMIC_DW_ADD: all operand magnitudes",
13356 { },
13357 INTERNAL | FLAG_NO_DATA,
13358 { },
13359 { { 0, 1 } },
13360 .fill_helper = bpf_fill_atomic64_add,
13361 .stack_depth = 8,
13362 .nr_testruns = NR_PATTERN_RUNS,
13363 },
13364 {
13365 "ATOMIC_DW_AND: all operand magnitudes",
13366 { },
13367 INTERNAL | FLAG_NO_DATA,
13368 { },
13369 { { 0, 1 } },
13370 .fill_helper = bpf_fill_atomic64_and,
13371 .stack_depth = 8,
13372 .nr_testruns = NR_PATTERN_RUNS,
13373 },
13374 {
13375 "ATOMIC_DW_OR: all operand magnitudes",
13376 { },
13377 INTERNAL | FLAG_NO_DATA,
13378 { },
13379 { { 0, 1 } },
13380 .fill_helper = bpf_fill_atomic64_or,
13381 .stack_depth = 8,
13382 .nr_testruns = NR_PATTERN_RUNS,
13383 },
13384 {
13385 "ATOMIC_DW_XOR: all operand magnitudes",
13386 { },
13387 INTERNAL | FLAG_NO_DATA,
13388 { },
13389 { { 0, 1 } },
13390 .fill_helper = bpf_fill_atomic64_xor,
13391 .stack_depth = 8,
13392 .nr_testruns = NR_PATTERN_RUNS,
13393 },
13394 {
13395 "ATOMIC_DW_ADD_FETCH: all operand magnitudes",
13396 { },
13397 INTERNAL | FLAG_NO_DATA,
13398 { },
13399 { { 0, 1 } },
13400 .fill_helper = bpf_fill_atomic64_add_fetch,
13401 .stack_depth = 8,
13402 .nr_testruns = NR_PATTERN_RUNS,
13403 },
13404 {
13405 "ATOMIC_DW_AND_FETCH: all operand magnitudes",
13406 { },
13407 INTERNAL | FLAG_NO_DATA,
13408 { },
13409 { { 0, 1 } },
13410 .fill_helper = bpf_fill_atomic64_and_fetch,
13411 .stack_depth = 8,
13412 .nr_testruns = NR_PATTERN_RUNS,
13413 },
13414 {
13415 "ATOMIC_DW_OR_FETCH: all operand magnitudes",
13416 { },
13417 INTERNAL | FLAG_NO_DATA,
13418 { },
13419 { { 0, 1 } },
13420 .fill_helper = bpf_fill_atomic64_or_fetch,
13421 .stack_depth = 8,
13422 .nr_testruns = NR_PATTERN_RUNS,
13423 },
13424 {
13425 "ATOMIC_DW_XOR_FETCH: all operand magnitudes",
13426 { },
13427 INTERNAL | FLAG_NO_DATA,
13428 { },
13429 { { 0, 1 } },
13430 .fill_helper = bpf_fill_atomic64_xor_fetch,
13431 .stack_depth = 8,
13432 .nr_testruns = NR_PATTERN_RUNS,
13433 },
13434 {
13435 "ATOMIC_DW_XCHG: all operand magnitudes",
13436 { },
13437 INTERNAL | FLAG_NO_DATA,
13438 { },
13439 { { 0, 1 } },
13440 .fill_helper = bpf_fill_atomic64_xchg,
13441 .stack_depth = 8,
13442 .nr_testruns = NR_PATTERN_RUNS,
13443 },
13444 {
13445 "ATOMIC_DW_CMPXCHG: all operand magnitudes",
13446 { },
13447 INTERNAL | FLAG_NO_DATA,
13448 { },
13449 { { 0, 1 } },
13450 .fill_helper = bpf_fill_cmpxchg64,
13451 .stack_depth = 8,
13452 .nr_testruns = NR_PATTERN_RUNS,
13453 },
13454 /* 32-bit atomic magnitudes */
13455 {
13456 "ATOMIC_W_ADD: all operand magnitudes",
13457 { },
13458 INTERNAL | FLAG_NO_DATA,
13459 { },
13460 { { 0, 1 } },
13461 .fill_helper = bpf_fill_atomic32_add,
13462 .stack_depth = 8,
13463 .nr_testruns = NR_PATTERN_RUNS,
13464 },
13465 {
13466 "ATOMIC_W_AND: all operand magnitudes",
13467 { },
13468 INTERNAL | FLAG_NO_DATA,
13469 { },
13470 { { 0, 1 } },
13471 .fill_helper = bpf_fill_atomic32_and,
13472 .stack_depth = 8,
13473 .nr_testruns = NR_PATTERN_RUNS,
13474 },
13475 {
13476 "ATOMIC_W_OR: all operand magnitudes",
13477 { },
13478 INTERNAL | FLAG_NO_DATA,
13479 { },
13480 { { 0, 1 } },
13481 .fill_helper = bpf_fill_atomic32_or,
13482 .stack_depth = 8,
13483 .nr_testruns = NR_PATTERN_RUNS,
13484 },
13485 {
13486 "ATOMIC_W_XOR: all operand magnitudes",
13487 { },
13488 INTERNAL | FLAG_NO_DATA,
13489 { },
13490 { { 0, 1 } },
13491 .fill_helper = bpf_fill_atomic32_xor,
13492 .stack_depth = 8,
13493 .nr_testruns = NR_PATTERN_RUNS,
13494 },
13495 {
13496 "ATOMIC_W_ADD_FETCH: all operand magnitudes",
13497 { },
13498 INTERNAL | FLAG_NO_DATA,
13499 { },
13500 { { 0, 1 } },
13501 .fill_helper = bpf_fill_atomic32_add_fetch,
13502 .stack_depth = 8,
13503 .nr_testruns = NR_PATTERN_RUNS,
13504 },
13505 {
13506 "ATOMIC_W_AND_FETCH: all operand magnitudes",
13507 { },
13508 INTERNAL | FLAG_NO_DATA,
13509 { },
13510 { { 0, 1 } },
13511 .fill_helper = bpf_fill_atomic32_and_fetch,
13512 .stack_depth = 8,
13513 .nr_testruns = NR_PATTERN_RUNS,
13514 },
13515 {
13516 "ATOMIC_W_OR_FETCH: all operand magnitudes",
13517 { },
13518 INTERNAL | FLAG_NO_DATA,
13519 { },
13520 { { 0, 1 } },
13521 .fill_helper = bpf_fill_atomic32_or_fetch,
13522 .stack_depth = 8,
13523 .nr_testruns = NR_PATTERN_RUNS,
13524 },
13525 {
13526 "ATOMIC_W_XOR_FETCH: all operand magnitudes",
13527 { },
13528 INTERNAL | FLAG_NO_DATA,
13529 { },
13530 { { 0, 1 } },
13531 .fill_helper = bpf_fill_atomic32_xor_fetch,
13532 .stack_depth = 8,
13533 .nr_testruns = NR_PATTERN_RUNS,
13534 },
13535 {
13536 "ATOMIC_W_XCHG: all operand magnitudes",
13537 { },
13538 INTERNAL | FLAG_NO_DATA,
13539 { },
13540 { { 0, 1 } },
13541 .fill_helper = bpf_fill_atomic32_xchg,
13542 .stack_depth = 8,
13543 .nr_testruns = NR_PATTERN_RUNS,
13544 },
13545 {
13546 "ATOMIC_W_CMPXCHG: all operand magnitudes",
13547 { },
13548 INTERNAL | FLAG_NO_DATA,
13549 { },
13550 { { 0, 1 } },
13551 .fill_helper = bpf_fill_cmpxchg32,
13552 .stack_depth = 8,
13553 .nr_testruns = NR_PATTERN_RUNS,
13554 },
13555 /* JMP immediate magnitudes */
13556 {
13557 "JMP_JSET_K: all immediate value magnitudes",
13558 { },
13559 INTERNAL | FLAG_NO_DATA,
13560 { },
13561 { { 0, 1 } },
13562 .fill_helper = bpf_fill_jmp_jset_imm,
13563 .nr_testruns = NR_PATTERN_RUNS,
13564 },
13565 {
13566 "JMP_JEQ_K: all immediate value magnitudes",
13567 { },
13568 INTERNAL | FLAG_NO_DATA,
13569 { },
13570 { { 0, 1 } },
13571 .fill_helper = bpf_fill_jmp_jeq_imm,
13572 .nr_testruns = NR_PATTERN_RUNS,
13573 },
13574 {
13575 "JMP_JNE_K: all immediate value magnitudes",
13576 { },
13577 INTERNAL | FLAG_NO_DATA,
13578 { },
13579 { { 0, 1 } },
13580 .fill_helper = bpf_fill_jmp_jne_imm,
13581 .nr_testruns = NR_PATTERN_RUNS,
13582 },
13583 {
13584 "JMP_JGT_K: all immediate value magnitudes",
13585 { },
13586 INTERNAL | FLAG_NO_DATA,
13587 { },
13588 { { 0, 1 } },
13589 .fill_helper = bpf_fill_jmp_jgt_imm,
13590 .nr_testruns = NR_PATTERN_RUNS,
13591 },
13592 {
13593 "JMP_JGE_K: all immediate value magnitudes",
13594 { },
13595 INTERNAL | FLAG_NO_DATA,
13596 { },
13597 { { 0, 1 } },
13598 .fill_helper = bpf_fill_jmp_jge_imm,
13599 .nr_testruns = NR_PATTERN_RUNS,
13600 },
13601 {
13602 "JMP_JLT_K: all immediate value magnitudes",
13603 { },
13604 INTERNAL | FLAG_NO_DATA,
13605 { },
13606 { { 0, 1 } },
13607 .fill_helper = bpf_fill_jmp_jlt_imm,
13608 .nr_testruns = NR_PATTERN_RUNS,
13609 },
13610 {
13611 "JMP_JLE_K: all immediate value magnitudes",
13612 { },
13613 INTERNAL | FLAG_NO_DATA,
13614 { },
13615 { { 0, 1 } },
13616 .fill_helper = bpf_fill_jmp_jle_imm,
13617 .nr_testruns = NR_PATTERN_RUNS,
13618 },
13619 {
13620 "JMP_JSGT_K: all immediate value magnitudes",
13621 { },
13622 INTERNAL | FLAG_NO_DATA,
13623 { },
13624 { { 0, 1 } },
13625 .fill_helper = bpf_fill_jmp_jsgt_imm,
13626 .nr_testruns = NR_PATTERN_RUNS,
13627 },
13628 {
13629 "JMP_JSGE_K: all immediate value magnitudes",
13630 { },
13631 INTERNAL | FLAG_NO_DATA,
13632 { },
13633 { { 0, 1 } },
13634 .fill_helper = bpf_fill_jmp_jsge_imm,
13635 .nr_testruns = NR_PATTERN_RUNS,
13636 },
13637 {
13638 "JMP_JSLT_K: all immediate value magnitudes",
13639 { },
13640 INTERNAL | FLAG_NO_DATA,
13641 { },
13642 { { 0, 1 } },
13643 .fill_helper = bpf_fill_jmp_jslt_imm,
13644 .nr_testruns = NR_PATTERN_RUNS,
13645 },
13646 {
13647 "JMP_JSLE_K: all immediate value magnitudes",
13648 { },
13649 INTERNAL | FLAG_NO_DATA,
13650 { },
13651 { { 0, 1 } },
13652 .fill_helper = bpf_fill_jmp_jsle_imm,
13653 .nr_testruns = NR_PATTERN_RUNS,
13654 },
13655 /* JMP register magnitudes */
13656 {
13657 "JMP_JSET_X: all register value magnitudes",
13658 { },
13659 INTERNAL | FLAG_NO_DATA,
13660 { },
13661 { { 0, 1 } },
13662 .fill_helper = bpf_fill_jmp_jset_reg,
13663 .nr_testruns = NR_PATTERN_RUNS,
13664 },
13665 {
13666 "JMP_JEQ_X: all register value magnitudes",
13667 { },
13668 INTERNAL | FLAG_NO_DATA,
13669 { },
13670 { { 0, 1 } },
13671 .fill_helper = bpf_fill_jmp_jeq_reg,
13672 .nr_testruns = NR_PATTERN_RUNS,
13673 },
13674 {
13675 "JMP_JNE_X: all register value magnitudes",
13676 { },
13677 INTERNAL | FLAG_NO_DATA,
13678 { },
13679 { { 0, 1 } },
13680 .fill_helper = bpf_fill_jmp_jne_reg,
13681 .nr_testruns = NR_PATTERN_RUNS,
13682 },
13683 {
13684 "JMP_JGT_X: all register value magnitudes",
13685 { },
13686 INTERNAL | FLAG_NO_DATA,
13687 { },
13688 { { 0, 1 } },
13689 .fill_helper = bpf_fill_jmp_jgt_reg,
13690 .nr_testruns = NR_PATTERN_RUNS,
13691 },
13692 {
13693 "JMP_JGE_X: all register value magnitudes",
13694 { },
13695 INTERNAL | FLAG_NO_DATA,
13696 { },
13697 { { 0, 1 } },
13698 .fill_helper = bpf_fill_jmp_jge_reg,
13699 .nr_testruns = NR_PATTERN_RUNS,
13700 },
13701 {
13702 "JMP_JLT_X: all register value magnitudes",
13703 { },
13704 INTERNAL | FLAG_NO_DATA,
13705 { },
13706 { { 0, 1 } },
13707 .fill_helper = bpf_fill_jmp_jlt_reg,
13708 .nr_testruns = NR_PATTERN_RUNS,
13709 },
13710 {
13711 "JMP_JLE_X: all register value magnitudes",
13712 { },
13713 INTERNAL | FLAG_NO_DATA,
13714 { },
13715 { { 0, 1 } },
13716 .fill_helper = bpf_fill_jmp_jle_reg,
13717 .nr_testruns = NR_PATTERN_RUNS,
13718 },
13719 {
13720 "JMP_JSGT_X: all register value magnitudes",
13721 { },
13722 INTERNAL | FLAG_NO_DATA,
13723 { },
13724 { { 0, 1 } },
13725 .fill_helper = bpf_fill_jmp_jsgt_reg,
13726 .nr_testruns = NR_PATTERN_RUNS,
13727 },
13728 {
13729 "JMP_JSGE_X: all register value magnitudes",
13730 { },
13731 INTERNAL | FLAG_NO_DATA,
13732 { },
13733 { { 0, 1 } },
13734 .fill_helper = bpf_fill_jmp_jsge_reg,
13735 .nr_testruns = NR_PATTERN_RUNS,
13736 },
13737 {
13738 "JMP_JSLT_X: all register value magnitudes",
13739 { },
13740 INTERNAL | FLAG_NO_DATA,
13741 { },
13742 { { 0, 1 } },
13743 .fill_helper = bpf_fill_jmp_jslt_reg,
13744 .nr_testruns = NR_PATTERN_RUNS,
13745 },
13746 {
13747 "JMP_JSLE_X: all register value magnitudes",
13748 { },
13749 INTERNAL | FLAG_NO_DATA,
13750 { },
13751 { { 0, 1 } },
13752 .fill_helper = bpf_fill_jmp_jsle_reg,
13753 .nr_testruns = NR_PATTERN_RUNS,
13754 },
13755 /* JMP32 immediate magnitudes */
13756 {
13757 "JMP32_JSET_K: all immediate value magnitudes",
13758 { },
13759 INTERNAL | FLAG_NO_DATA,
13760 { },
13761 { { 0, 1 } },
13762 .fill_helper = bpf_fill_jmp32_jset_imm,
13763 .nr_testruns = NR_PATTERN_RUNS,
13764 },
13765 {
13766 "JMP32_JEQ_K: all immediate value magnitudes",
13767 { },
13768 INTERNAL | FLAG_NO_DATA,
13769 { },
13770 { { 0, 1 } },
13771 .fill_helper = bpf_fill_jmp32_jeq_imm,
13772 .nr_testruns = NR_PATTERN_RUNS,
13773 },
13774 {
13775 "JMP32_JNE_K: all immediate value magnitudes",
13776 { },
13777 INTERNAL | FLAG_NO_DATA,
13778 { },
13779 { { 0, 1 } },
13780 .fill_helper = bpf_fill_jmp32_jne_imm,
13781 .nr_testruns = NR_PATTERN_RUNS,
13782 },
13783 {
13784 "JMP32_JGT_K: all immediate value magnitudes",
13785 { },
13786 INTERNAL | FLAG_NO_DATA,
13787 { },
13788 { { 0, 1 } },
13789 .fill_helper = bpf_fill_jmp32_jgt_imm,
13790 .nr_testruns = NR_PATTERN_RUNS,
13791 },
13792 {
13793 "JMP32_JGE_K: all immediate value magnitudes",
13794 { },
13795 INTERNAL | FLAG_NO_DATA,
13796 { },
13797 { { 0, 1 } },
13798 .fill_helper = bpf_fill_jmp32_jge_imm,
13799 .nr_testruns = NR_PATTERN_RUNS,
13800 },
13801 {
13802 "JMP32_JLT_K: all immediate value magnitudes",
13803 { },
13804 INTERNAL | FLAG_NO_DATA,
13805 { },
13806 { { 0, 1 } },
13807 .fill_helper = bpf_fill_jmp32_jlt_imm,
13808 .nr_testruns = NR_PATTERN_RUNS,
13809 },
13810 {
13811 "JMP32_JLE_K: all immediate value magnitudes",
13812 { },
13813 INTERNAL | FLAG_NO_DATA,
13814 { },
13815 { { 0, 1 } },
13816 .fill_helper = bpf_fill_jmp32_jle_imm,
13817 .nr_testruns = NR_PATTERN_RUNS,
13818 },
13819 {
13820 "JMP32_JSGT_K: all immediate value magnitudes",
13821 { },
13822 INTERNAL | FLAG_NO_DATA,
13823 { },
13824 { { 0, 1 } },
13825 .fill_helper = bpf_fill_jmp32_jsgt_imm,
13826 .nr_testruns = NR_PATTERN_RUNS,
13827 },
13828 {
13829 "JMP32_JSGE_K: all immediate value magnitudes",
13830 { },
13831 INTERNAL | FLAG_NO_DATA,
13832 { },
13833 { { 0, 1 } },
13834 .fill_helper = bpf_fill_jmp32_jsge_imm,
13835 .nr_testruns = NR_PATTERN_RUNS,
13836 },
13837 {
13838 "JMP32_JSLT_K: all immediate value magnitudes",
13839 { },
13840 INTERNAL | FLAG_NO_DATA,
13841 { },
13842 { { 0, 1 } },
13843 .fill_helper = bpf_fill_jmp32_jslt_imm,
13844 .nr_testruns = NR_PATTERN_RUNS,
13845 },
13846 {
13847 "JMP32_JSLE_K: all immediate value magnitudes",
13848 { },
13849 INTERNAL | FLAG_NO_DATA,
13850 { },
13851 { { 0, 1 } },
13852 .fill_helper = bpf_fill_jmp32_jsle_imm,
13853 .nr_testruns = NR_PATTERN_RUNS,
13854 },
13855 /* JMP32 register magnitudes */
13856 {
13857 "JMP32_JSET_X: all register value magnitudes",
13858 { },
13859 INTERNAL | FLAG_NO_DATA,
13860 { },
13861 { { 0, 1 } },
13862 .fill_helper = bpf_fill_jmp32_jset_reg,
13863 .nr_testruns = NR_PATTERN_RUNS,
13864 },
13865 {
13866 "JMP32_JEQ_X: all register value magnitudes",
13867 { },
13868 INTERNAL | FLAG_NO_DATA,
13869 { },
13870 { { 0, 1 } },
13871 .fill_helper = bpf_fill_jmp32_jeq_reg,
13872 .nr_testruns = NR_PATTERN_RUNS,
13873 },
13874 {
13875 "JMP32_JNE_X: all register value magnitudes",
13876 { },
13877 INTERNAL | FLAG_NO_DATA,
13878 { },
13879 { { 0, 1 } },
13880 .fill_helper = bpf_fill_jmp32_jne_reg,
13881 .nr_testruns = NR_PATTERN_RUNS,
13882 },
13883 {
13884 "JMP32_JGT_X: all register value magnitudes",
13885 { },
13886 INTERNAL | FLAG_NO_DATA,
13887 { },
13888 { { 0, 1 } },
13889 .fill_helper = bpf_fill_jmp32_jgt_reg,
13890 .nr_testruns = NR_PATTERN_RUNS,
13891 },
13892 {
13893 "JMP32_JGE_X: all register value magnitudes",
13894 { },
13895 INTERNAL | FLAG_NO_DATA,
13896 { },
13897 { { 0, 1 } },
13898 .fill_helper = bpf_fill_jmp32_jge_reg,
13899 .nr_testruns = NR_PATTERN_RUNS,
13900 },
13901 {
13902 "JMP32_JLT_X: all register value magnitudes",
13903 { },
13904 INTERNAL | FLAG_NO_DATA,
13905 { },
13906 { { 0, 1 } },
13907 .fill_helper = bpf_fill_jmp32_jlt_reg,
13908 .nr_testruns = NR_PATTERN_RUNS,
13909 },
13910 {
13911 "JMP32_JLE_X: all register value magnitudes",
13912 { },
13913 INTERNAL | FLAG_NO_DATA,
13914 { },
13915 { { 0, 1 } },
13916 .fill_helper = bpf_fill_jmp32_jle_reg,
13917 .nr_testruns = NR_PATTERN_RUNS,
13918 },
13919 {
13920 "JMP32_JSGT_X: all register value magnitudes",
13921 { },
13922 INTERNAL | FLAG_NO_DATA,
13923 { },
13924 { { 0, 1 } },
13925 .fill_helper = bpf_fill_jmp32_jsgt_reg,
13926 .nr_testruns = NR_PATTERN_RUNS,
13927 },
13928 {
13929 "JMP32_JSGE_X: all register value magnitudes",
13930 { },
13931 INTERNAL | FLAG_NO_DATA,
13932 { },
13933 { { 0, 1 } },
13934 .fill_helper = bpf_fill_jmp32_jsge_reg,
13935 .nr_testruns = NR_PATTERN_RUNS,
13936 },
13937 {
13938 "JMP32_JSLT_X: all register value magnitudes",
13939 { },
13940 INTERNAL | FLAG_NO_DATA,
13941 { },
13942 { { 0, 1 } },
13943 .fill_helper = bpf_fill_jmp32_jslt_reg,
13944 .nr_testruns = NR_PATTERN_RUNS,
13945 },
13946 {
13947 "JMP32_JSLE_X: all register value magnitudes",
13948 { },
13949 INTERNAL | FLAG_NO_DATA,
13950 { },
13951 { { 0, 1 } },
13952 .fill_helper = bpf_fill_jmp32_jsle_reg,
13953 .nr_testruns = NR_PATTERN_RUNS,
13954 },
13955 /* Conditional jumps with constant decision */
13956 {
13957 "JMP_JSET_K: imm = 0 -> never taken",
13958 .u.insns_int = {
13959 BPF_ALU64_IMM(BPF_MOV, R0, 1),
13960 BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
13961 BPF_ALU64_IMM(BPF_MOV, R0, 0),
13962 BPF_EXIT_INSN(),
13963 },
13964 INTERNAL | FLAG_NO_DATA,
13965 { },
13966 { { 0, 0 } },
13967 },
13968 {
13969 "JMP_JLT_K: imm = 0 -> never taken",
13970 .u.insns_int = {
13971 BPF_ALU64_IMM(BPF_MOV, R0, 1),
13972 BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
13973 BPF_ALU64_IMM(BPF_MOV, R0, 0),
13974 BPF_EXIT_INSN(),
13975 },
13976 INTERNAL | FLAG_NO_DATA,
13977 { },
13978 { { 0, 0 } },
13979 },
13980 {
13981 "JMP_JGE_K: imm = 0 -> always taken",
13982 .u.insns_int = {
13983 BPF_ALU64_IMM(BPF_MOV, R0, 1),
13984 BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
13985 BPF_ALU64_IMM(BPF_MOV, R0, 0),
13986 BPF_EXIT_INSN(),
13987 },
13988 INTERNAL | FLAG_NO_DATA,
13989 { },
13990 { { 0, 1 } },
13991 },
13992 {
13993 "JMP_JGT_K: imm = 0xffffffff -> never taken",
13994 .u.insns_int = {
13995 BPF_ALU64_IMM(BPF_MOV, R0, 1),
13996 BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
13997 BPF_ALU64_IMM(BPF_MOV, R0, 0),
13998 BPF_EXIT_INSN(),
13999 },
14000 INTERNAL | FLAG_NO_DATA,
14001 { },
14002 { { 0, 0 } },
14003 },
14004 {
14005 "JMP_JLE_K: imm = 0xffffffff -> always taken",
14006 .u.insns_int = {
14007 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14008 BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
14009 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14010 BPF_EXIT_INSN(),
14011 },
14012 INTERNAL | FLAG_NO_DATA,
14013 { },
14014 { { 0, 1 } },
14015 },
14016 {
14017 "JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
14018 .u.insns_int = {
14019 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14020 BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
14021 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14022 BPF_EXIT_INSN(),
14023 },
14024 INTERNAL | FLAG_NO_DATA,
14025 { },
14026 { { 0, 0 } },
14027 },
14028 {
14029 "JMP32_JSGE_K: imm = -0x80000000 -> always taken",
14030 .u.insns_int = {
14031 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14032 BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
14033 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14034 BPF_EXIT_INSN(),
14035 },
14036 INTERNAL | FLAG_NO_DATA,
14037 { },
14038 { { 0, 1 } },
14039 },
14040 {
14041 "JMP32_JSLT_K: imm = -0x80000000 -> never taken",
14042 .u.insns_int = {
14043 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14044 BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
14045 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14046 BPF_EXIT_INSN(),
14047 },
14048 INTERNAL | FLAG_NO_DATA,
14049 { },
14050 { { 0, 0 } },
14051 },
14052 {
14053 "JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
14054 .u.insns_int = {
14055 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14056 BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
14057 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14058 BPF_EXIT_INSN(),
14059 },
14060 INTERNAL | FLAG_NO_DATA,
14061 { },
14062 { { 0, 1 } },
14063 },
14064 {
14065 "JMP_JEQ_X: dst = src -> always taken",
14066 .u.insns_int = {
14067 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14068 BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
14069 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14070 BPF_EXIT_INSN(),
14071 },
14072 INTERNAL | FLAG_NO_DATA,
14073 { },
14074 { { 0, 1 } },
14075 },
14076 {
14077 "JMP_JGE_X: dst = src -> always taken",
14078 .u.insns_int = {
14079 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14080 BPF_JMP_REG(BPF_JGE, R1, R1, 1),
14081 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14082 BPF_EXIT_INSN(),
14083 },
14084 INTERNAL | FLAG_NO_DATA,
14085 { },
14086 { { 0, 1 } },
14087 },
14088 {
14089 "JMP_JLE_X: dst = src -> always taken",
14090 .u.insns_int = {
14091 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14092 BPF_JMP_REG(BPF_JLE, R1, R1, 1),
14093 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14094 BPF_EXIT_INSN(),
14095 },
14096 INTERNAL | FLAG_NO_DATA,
14097 { },
14098 { { 0, 1 } },
14099 },
14100 {
14101 "JMP_JSGE_X: dst = src -> always taken",
14102 .u.insns_int = {
14103 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14104 BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
14105 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14106 BPF_EXIT_INSN(),
14107 },
14108 INTERNAL | FLAG_NO_DATA,
14109 { },
14110 { { 0, 1 } },
14111 },
14112 {
14113 "JMP_JSLE_X: dst = src -> always taken",
14114 .u.insns_int = {
14115 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14116 BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
14117 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14118 BPF_EXIT_INSN(),
14119 },
14120 INTERNAL | FLAG_NO_DATA,
14121 { },
14122 { { 0, 1 } },
14123 },
14124 {
14125 "JMP_JNE_X: dst = src -> never taken",
14126 .u.insns_int = {
14127 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14128 BPF_JMP_REG(BPF_JNE, R1, R1, 1),
14129 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14130 BPF_EXIT_INSN(),
14131 },
14132 INTERNAL | FLAG_NO_DATA,
14133 { },
14134 { { 0, 0 } },
14135 },
14136 {
14137 "JMP_JGT_X: dst = src -> never taken",
14138 .u.insns_int = {
14139 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14140 BPF_JMP_REG(BPF_JGT, R1, R1, 1),
14141 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14142 BPF_EXIT_INSN(),
14143 },
14144 INTERNAL | FLAG_NO_DATA,
14145 { },
14146 { { 0, 0 } },
14147 },
14148 {
14149 "JMP_JLT_X: dst = src -> never taken",
14150 .u.insns_int = {
14151 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14152 BPF_JMP_REG(BPF_JLT, R1, R1, 1),
14153 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14154 BPF_EXIT_INSN(),
14155 },
14156 INTERNAL | FLAG_NO_DATA,
14157 { },
14158 { { 0, 0 } },
14159 },
14160 {
14161 "JMP_JSGT_X: dst = src -> never taken",
14162 .u.insns_int = {
14163 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14164 BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
14165 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14166 BPF_EXIT_INSN(),
14167 },
14168 INTERNAL | FLAG_NO_DATA,
14169 { },
14170 { { 0, 0 } },
14171 },
14172 {
14173 "JMP_JSLT_X: dst = src -> never taken",
14174 .u.insns_int = {
14175 BPF_ALU64_IMM(BPF_MOV, R0, 1),
14176 BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
14177 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14178 BPF_EXIT_INSN(),
14179 },
14180 INTERNAL | FLAG_NO_DATA,
14181 { },
14182 { { 0, 0 } },
14183 },
14184 /* Short relative jumps */
14185 {
14186 "Short relative jump: offset=0",
14187 .u.insns_int = {
14188 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14189 BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
14190 BPF_EXIT_INSN(),
14191 BPF_ALU32_IMM(BPF_MOV, R0, -1),
14192 },
14193 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14194 { },
14195 { { 0, 0 } },
14196 },
14197 {
14198 "Short relative jump: offset=1",
14199 .u.insns_int = {
14200 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14201 BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
14202 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14203 BPF_EXIT_INSN(),
14204 BPF_ALU32_IMM(BPF_MOV, R0, -1),
14205 },
14206 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14207 { },
14208 { { 0, 0 } },
14209 },
14210 {
14211 "Short relative jump: offset=2",
14212 .u.insns_int = {
14213 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14214 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
14215 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14216 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14217 BPF_EXIT_INSN(),
14218 BPF_ALU32_IMM(BPF_MOV, R0, -1),
14219 },
14220 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14221 { },
14222 { { 0, 0 } },
14223 },
14224 {
14225 "Short relative jump: offset=3",
14226 .u.insns_int = {
14227 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14228 BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
14229 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14230 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14231 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14232 BPF_EXIT_INSN(),
14233 BPF_ALU32_IMM(BPF_MOV, R0, -1),
14234 },
14235 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14236 { },
14237 { { 0, 0 } },
14238 },
14239 {
14240 "Short relative jump: offset=4",
14241 .u.insns_int = {
14242 BPF_ALU64_IMM(BPF_MOV, R0, 0),
14243 BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
14244 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14245 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14246 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14247 BPF_ALU32_IMM(BPF_ADD, R0, 1),
14248 BPF_EXIT_INSN(),
14249 BPF_ALU32_IMM(BPF_MOV, R0, -1),
14250 },
14251 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
14252 { },
14253 { { 0, 0 } },
14254 },
14255 /* Conditional branch conversions */
14256 {
14257 "Long conditional jump: taken at runtime (32 bits)",
14258 { },
14259 INTERNAL | FLAG_NO_DATA,
14260 { },
14261 { { 0, 1 } },
14262 .fill_helper = bpf_fill_max_jmp_taken_32,
14263 },
14264 {
14265 "Long conditional jump: not taken at runtime (32 bits)",
14266 { },
14267 INTERNAL | FLAG_NO_DATA,
14268 { },
14269 { { 0, 2 } },
14270 .fill_helper = bpf_fill_max_jmp_not_taken_32,
14271 },
14272 {
14273 "Long conditional jump: always taken, known at JIT time (32 bits)",
14274 { },
14275 INTERNAL | FLAG_NO_DATA,
14276 { },
14277 { { 0, 1 } },
14278 .fill_helper = bpf_fill_max_jmp_always_taken_32,
14279 },
14280 {
14281 "Long conditional jump: never taken, known at JIT time (32 bits)",
14282 { },
14283 INTERNAL | FLAG_NO_DATA,
14284 { },
14285 { { 0, 2 } },
14286 .fill_helper = bpf_fill_max_jmp_never_taken_32,
14287 },
14288 {
14289 "Long conditional jump: taken at runtime",
14290 { },
14291 INTERNAL | FLAG_NO_DATA,
14292 { },
14293 { { 0, 1 } },
14294 .fill_helper = bpf_fill_max_jmp_taken,
14295 },
14296 {
14297 "Long conditional jump: not taken at runtime",
14298 { },
14299 INTERNAL | FLAG_NO_DATA,
14300 { },
14301 { { 0, 2 } },
14302 .fill_helper = bpf_fill_max_jmp_not_taken,
14303 },
14304 {
14305 "Long conditional jump: always taken, known at JIT time",
14306 { },
14307 INTERNAL | FLAG_NO_DATA,
14308 { },
14309 { { 0, 1 } },
14310 .fill_helper = bpf_fill_max_jmp_always_taken,
14311 },
14312 {
14313 "Long conditional jump: never taken, known at JIT time",
14314 { },
14315 INTERNAL | FLAG_NO_DATA,
14316 { },
14317 { { 0, 2 } },
14318 .fill_helper = bpf_fill_max_jmp_never_taken,
14319 },
14320 /* Staggered jump sequences, immediate */
14321 {
14322 "Staggered jumps: JMP_JA",
14323 { },
14324 INTERNAL | FLAG_NO_DATA,
14325 { },
14326 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14327 .fill_helper = bpf_fill_staggered_ja,
14328 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14329 },
14330 {
14331 "Staggered jumps: JMP_JEQ_K",
14332 { },
14333 INTERNAL | FLAG_NO_DATA,
14334 { },
14335 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14336 .fill_helper = bpf_fill_staggered_jeq_imm,
14337 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14338 },
14339 {
14340 "Staggered jumps: JMP_JNE_K",
14341 { },
14342 INTERNAL | FLAG_NO_DATA,
14343 { },
14344 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14345 .fill_helper = bpf_fill_staggered_jne_imm,
14346 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14347 },
14348 {
14349 "Staggered jumps: JMP_JSET_K",
14350 { },
14351 INTERNAL | FLAG_NO_DATA,
14352 { },
14353 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14354 .fill_helper = bpf_fill_staggered_jset_imm,
14355 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14356 },
14357 {
14358 "Staggered jumps: JMP_JGT_K",
14359 { },
14360 INTERNAL | FLAG_NO_DATA,
14361 { },
14362 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14363 .fill_helper = bpf_fill_staggered_jgt_imm,
14364 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14365 },
14366 {
14367 "Staggered jumps: JMP_JGE_K",
14368 { },
14369 INTERNAL | FLAG_NO_DATA,
14370 { },
14371 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14372 .fill_helper = bpf_fill_staggered_jge_imm,
14373 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14374 },
14375 {
14376 "Staggered jumps: JMP_JLT_K",
14377 { },
14378 INTERNAL | FLAG_NO_DATA,
14379 { },
14380 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14381 .fill_helper = bpf_fill_staggered_jlt_imm,
14382 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14383 },
14384 {
14385 "Staggered jumps: JMP_JLE_K",
14386 { },
14387 INTERNAL | FLAG_NO_DATA,
14388 { },
14389 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14390 .fill_helper = bpf_fill_staggered_jle_imm,
14391 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14392 },
14393 {
14394 "Staggered jumps: JMP_JSGT_K",
14395 { },
14396 INTERNAL | FLAG_NO_DATA,
14397 { },
14398 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14399 .fill_helper = bpf_fill_staggered_jsgt_imm,
14400 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14401 },
14402 {
14403 "Staggered jumps: JMP_JSGE_K",
14404 { },
14405 INTERNAL | FLAG_NO_DATA,
14406 { },
14407 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14408 .fill_helper = bpf_fill_staggered_jsge_imm,
14409 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14410 },
14411 {
14412 "Staggered jumps: JMP_JSLT_K",
14413 { },
14414 INTERNAL | FLAG_NO_DATA,
14415 { },
14416 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14417 .fill_helper = bpf_fill_staggered_jslt_imm,
14418 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14419 },
14420 {
14421 "Staggered jumps: JMP_JSLE_K",
14422 { },
14423 INTERNAL | FLAG_NO_DATA,
14424 { },
14425 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14426 .fill_helper = bpf_fill_staggered_jsle_imm,
14427 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14428 },
14429 /* Staggered jump sequences, register */
14430 {
14431 "Staggered jumps: JMP_JEQ_X",
14432 { },
14433 INTERNAL | FLAG_NO_DATA,
14434 { },
14435 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14436 .fill_helper = bpf_fill_staggered_jeq_reg,
14437 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14438 },
14439 {
14440 "Staggered jumps: JMP_JNE_X",
14441 { },
14442 INTERNAL | FLAG_NO_DATA,
14443 { },
14444 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14445 .fill_helper = bpf_fill_staggered_jne_reg,
14446 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14447 },
14448 {
14449 "Staggered jumps: JMP_JSET_X",
14450 { },
14451 INTERNAL | FLAG_NO_DATA,
14452 { },
14453 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14454 .fill_helper = bpf_fill_staggered_jset_reg,
14455 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14456 },
14457 {
14458 "Staggered jumps: JMP_JGT_X",
14459 { },
14460 INTERNAL | FLAG_NO_DATA,
14461 { },
14462 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14463 .fill_helper = bpf_fill_staggered_jgt_reg,
14464 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14465 },
14466 {
14467 "Staggered jumps: JMP_JGE_X",
14468 { },
14469 INTERNAL | FLAG_NO_DATA,
14470 { },
14471 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14472 .fill_helper = bpf_fill_staggered_jge_reg,
14473 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14474 },
14475 {
14476 "Staggered jumps: JMP_JLT_X",
14477 { },
14478 INTERNAL | FLAG_NO_DATA,
14479 { },
14480 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14481 .fill_helper = bpf_fill_staggered_jlt_reg,
14482 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14483 },
14484 {
14485 "Staggered jumps: JMP_JLE_X",
14486 { },
14487 INTERNAL | FLAG_NO_DATA,
14488 { },
14489 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14490 .fill_helper = bpf_fill_staggered_jle_reg,
14491 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14492 },
14493 {
14494 "Staggered jumps: JMP_JSGT_X",
14495 { },
14496 INTERNAL | FLAG_NO_DATA,
14497 { },
14498 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14499 .fill_helper = bpf_fill_staggered_jsgt_reg,
14500 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14501 },
14502 {
14503 "Staggered jumps: JMP_JSGE_X",
14504 { },
14505 INTERNAL | FLAG_NO_DATA,
14506 { },
14507 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14508 .fill_helper = bpf_fill_staggered_jsge_reg,
14509 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14510 },
14511 {
14512 "Staggered jumps: JMP_JSLT_X",
14513 { },
14514 INTERNAL | FLAG_NO_DATA,
14515 { },
14516 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14517 .fill_helper = bpf_fill_staggered_jslt_reg,
14518 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14519 },
14520 {
14521 "Staggered jumps: JMP_JSLE_X",
14522 { },
14523 INTERNAL | FLAG_NO_DATA,
14524 { },
14525 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14526 .fill_helper = bpf_fill_staggered_jsle_reg,
14527 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14528 },
14529 /* Staggered jump sequences, JMP32 immediate */
14530 {
14531 "Staggered jumps: JMP32_JEQ_K",
14532 { },
14533 INTERNAL | FLAG_NO_DATA,
14534 { },
14535 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14536 .fill_helper = bpf_fill_staggered_jeq32_imm,
14537 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14538 },
14539 {
14540 "Staggered jumps: JMP32_JNE_K",
14541 { },
14542 INTERNAL | FLAG_NO_DATA,
14543 { },
14544 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14545 .fill_helper = bpf_fill_staggered_jne32_imm,
14546 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14547 },
14548 {
14549 "Staggered jumps: JMP32_JSET_K",
14550 { },
14551 INTERNAL | FLAG_NO_DATA,
14552 { },
14553 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14554 .fill_helper = bpf_fill_staggered_jset32_imm,
14555 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14556 },
14557 {
14558 "Staggered jumps: JMP32_JGT_K",
14559 { },
14560 INTERNAL | FLAG_NO_DATA,
14561 { },
14562 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14563 .fill_helper = bpf_fill_staggered_jgt32_imm,
14564 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14565 },
14566 {
14567 "Staggered jumps: JMP32_JGE_K",
14568 { },
14569 INTERNAL | FLAG_NO_DATA,
14570 { },
14571 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14572 .fill_helper = bpf_fill_staggered_jge32_imm,
14573 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14574 },
14575 {
14576 "Staggered jumps: JMP32_JLT_K",
14577 { },
14578 INTERNAL | FLAG_NO_DATA,
14579 { },
14580 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14581 .fill_helper = bpf_fill_staggered_jlt32_imm,
14582 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14583 },
14584 {
14585 "Staggered jumps: JMP32_JLE_K",
14586 { },
14587 INTERNAL | FLAG_NO_DATA,
14588 { },
14589 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14590 .fill_helper = bpf_fill_staggered_jle32_imm,
14591 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14592 },
14593 {
14594 "Staggered jumps: JMP32_JSGT_K",
14595 { },
14596 INTERNAL | FLAG_NO_DATA,
14597 { },
14598 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14599 .fill_helper = bpf_fill_staggered_jsgt32_imm,
14600 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14601 },
14602 {
14603 "Staggered jumps: JMP32_JSGE_K",
14604 { },
14605 INTERNAL | FLAG_NO_DATA,
14606 { },
14607 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14608 .fill_helper = bpf_fill_staggered_jsge32_imm,
14609 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14610 },
14611 {
14612 "Staggered jumps: JMP32_JSLT_K",
14613 { },
14614 INTERNAL | FLAG_NO_DATA,
14615 { },
14616 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14617 .fill_helper = bpf_fill_staggered_jslt32_imm,
14618 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14619 },
14620 {
14621 "Staggered jumps: JMP32_JSLE_K",
14622 { },
14623 INTERNAL | FLAG_NO_DATA,
14624 { },
14625 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14626 .fill_helper = bpf_fill_staggered_jsle32_imm,
14627 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14628 },
14629 /* Staggered jump sequences, JMP32 register */
14630 {
14631 "Staggered jumps: JMP32_JEQ_X",
14632 { },
14633 INTERNAL | FLAG_NO_DATA,
14634 { },
14635 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14636 .fill_helper = bpf_fill_staggered_jeq32_reg,
14637 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14638 },
14639 {
14640 "Staggered jumps: JMP32_JNE_X",
14641 { },
14642 INTERNAL | FLAG_NO_DATA,
14643 { },
14644 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14645 .fill_helper = bpf_fill_staggered_jne32_reg,
14646 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14647 },
14648 {
14649 "Staggered jumps: JMP32_JSET_X",
14650 { },
14651 INTERNAL | FLAG_NO_DATA,
14652 { },
14653 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14654 .fill_helper = bpf_fill_staggered_jset32_reg,
14655 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14656 },
14657 {
14658 "Staggered jumps: JMP32_JGT_X",
14659 { },
14660 INTERNAL | FLAG_NO_DATA,
14661 { },
14662 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14663 .fill_helper = bpf_fill_staggered_jgt32_reg,
14664 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14665 },
14666 {
14667 "Staggered jumps: JMP32_JGE_X",
14668 { },
14669 INTERNAL | FLAG_NO_DATA,
14670 { },
14671 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14672 .fill_helper = bpf_fill_staggered_jge32_reg,
14673 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14674 },
14675 {
14676 "Staggered jumps: JMP32_JLT_X",
14677 { },
14678 INTERNAL | FLAG_NO_DATA,
14679 { },
14680 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14681 .fill_helper = bpf_fill_staggered_jlt32_reg,
14682 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14683 },
14684 {
14685 "Staggered jumps: JMP32_JLE_X",
14686 { },
14687 INTERNAL | FLAG_NO_DATA,
14688 { },
14689 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14690 .fill_helper = bpf_fill_staggered_jle32_reg,
14691 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14692 },
14693 {
14694 "Staggered jumps: JMP32_JSGT_X",
14695 { },
14696 INTERNAL | FLAG_NO_DATA,
14697 { },
14698 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14699 .fill_helper = bpf_fill_staggered_jsgt32_reg,
14700 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14701 },
14702 {
14703 "Staggered jumps: JMP32_JSGE_X",
14704 { },
14705 INTERNAL | FLAG_NO_DATA,
14706 { },
14707 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14708 .fill_helper = bpf_fill_staggered_jsge32_reg,
14709 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14710 },
14711 {
14712 "Staggered jumps: JMP32_JSLT_X",
14713 { },
14714 INTERNAL | FLAG_NO_DATA,
14715 { },
14716 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14717 .fill_helper = bpf_fill_staggered_jslt32_reg,
14718 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14719 },
14720 {
14721 "Staggered jumps: JMP32_JSLE_X",
14722 { },
14723 INTERNAL | FLAG_NO_DATA,
14724 { },
14725 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
14726 .fill_helper = bpf_fill_staggered_jsle32_reg,
14727 .nr_testruns = NR_STAGGERED_JMP_RUNS,
14728 },
14729 };
14730
14731 static struct net_device dev;
14732
14733 static struct sk_buff *populate_skb(char *buf, int size)
14734 {
14735 struct sk_buff *skb;
14736
14737 if (size >= MAX_DATA)
14738 return NULL;
14739
14740 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
14741 if (!skb)
14742 return NULL;
14743
14744 __skb_put_data(skb, buf, size);
14745
14746 /* Initialize a fake skb with test pattern. */
14747 skb_reset_mac_header(skb);
14748 skb->protocol = htons(ETH_P_IP);
14749 skb->pkt_type = SKB_TYPE;
14750 skb->mark = SKB_MARK;
14751 skb->hash = SKB_HASH;
14752 skb->queue_mapping = SKB_QUEUE_MAP;
14753 skb->vlan_tci = SKB_VLAN_TCI;
14754 skb->vlan_proto = htons(ETH_P_IP);
14755 dev_net_set(&dev, &init_net);
14756 skb->dev = &dev;
14757 skb->dev->ifindex = SKB_DEV_IFINDEX;
14758 skb->dev->type = SKB_DEV_TYPE;
14759 skb_set_network_header(skb, min(size, ETH_HLEN));
14760
14761 return skb;
14762 }
14763
14764 static void *generate_test_data(struct bpf_test *test, int sub)
14765 {
14766 struct sk_buff *skb;
14767 struct page *page;
14768
14769 if (test->aux & FLAG_NO_DATA)
14770 return NULL;
14771
14772 if (test->aux & FLAG_LARGE_MEM)
14773 return kmalloc(test->test[sub].data_size, GFP_KERNEL);
14774
14775 /* Test case expects an skb, so populate one. Various
14776 * subtests generate skbs of different sizes based on
14777 * the same data.
14778 */
14779 skb = populate_skb(test->data, test->test[sub].data_size);
14780 if (!skb)
14781 return NULL;
14782
14783 if (test->aux & FLAG_SKB_FRAG) {
14784 /*
14785 * when the test requires a fragmented skb, add a
14786 * single fragment to the skb, filled with
14787 * test->frag_data.
14788 */
14789 page = alloc_page(GFP_KERNEL);
14790 if (!page)
14791 goto err_kfree_skb;
14792
14793 memcpy(page_address(page), test->frag_data, MAX_DATA);
14794 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
14795 }
14796
14797 return skb;
14798 err_kfree_skb:
14799 kfree_skb(skb);
14800 return NULL;
14801 }
14802
14803 static void release_test_data(const struct bpf_test *test, void *data)
14804 {
14805 if (test->aux & FLAG_NO_DATA)
14806 return;
14807
14808 if (test->aux & FLAG_LARGE_MEM)
14809 kfree(data);
14810 else
14811 kfree_skb(data);
14812 }
14813
14814 static int filter_length(int which)
14815 {
14816 struct sock_filter *fp;
14817 int len;
14818
14819 if (tests[which].fill_helper)
14820 return tests[which].u.ptr.len;
14821
14822 fp = tests[which].u.insns;
14823 for (len = MAX_INSNS - 1; len > 0; --len)
14824 if (fp[len].code != 0 || fp[len].k != 0)
14825 break;
14826
14827 return len + 1;
14828 }
14829
14830 static void *filter_pointer(int which)
14831 {
14832 if (tests[which].fill_helper)
14833 return tests[which].u.ptr.insns;
14834 else
14835 return tests[which].u.insns;
14836 }
14837
14838 static struct bpf_prog *generate_filter(int which, int *err)
14839 {
14840 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14841 unsigned int flen = filter_length(which);
14842 void *fptr = filter_pointer(which);
14843 struct sock_fprog_kern fprog;
14844 struct bpf_prog *fp;
14845
14846 switch (test_type) {
14847 case CLASSIC:
14848 fprog.filter = fptr;
14849 fprog.len = flen;
14850
14851 *err = bpf_prog_create(&fp, &fprog);
14852 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
14853 if (*err == tests[which].expected_errcode) {
14854 pr_cont("PASS\n");
14855 /* Verifier rejected filter as expected. */
14856 *err = 0;
14857 return NULL;
14858 } else {
14859 pr_cont("UNEXPECTED_PASS\n");
14860 /* Verifier didn't reject the test that's
14861 * bad enough, just return!
14862 */
14863 *err = -EINVAL;
14864 return NULL;
14865 }
14866 }
14867 if (*err) {
14868 pr_cont("FAIL to prog_create err=%d len=%d\n",
14869 *err, fprog.len);
14870 return NULL;
14871 }
14872 break;
14873
14874 case INTERNAL:
14875 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
14876 if (fp == NULL) {
14877 pr_cont("UNEXPECTED_FAIL no memory left\n");
14878 *err = -ENOMEM;
14879 return NULL;
14880 }
14881
14882 fp->len = flen;
14883 /* Type doesn't really matter here as long as it's not unspec. */
14884 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
14885 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
14886 fp->aux->stack_depth = tests[which].stack_depth;
14887 fp->aux->verifier_zext = !!(tests[which].aux &
14888 FLAG_VERIFIER_ZEXT);
14889
14890 /* We cannot error here as we don't need type compatibility
14891 * checks.
14892 */
14893 fp = bpf_prog_select_runtime(fp, err);
14894 if (*err) {
14895 pr_cont("FAIL to select_runtime err=%d\n", *err);
14896 return NULL;
14897 }
14898 break;
14899 }
14900
14901 *err = 0;
14902 return fp;
14903 }
14904
14905 static void release_filter(struct bpf_prog *fp, int which)
14906 {
14907 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
14908
14909 switch (test_type) {
14910 case CLASSIC:
14911 bpf_prog_destroy(fp);
14912 break;
14913 case INTERNAL:
14914 bpf_prog_free(fp);
14915 break;
14916 }
14917 }
14918
14919 static int __run_one(const struct bpf_prog *fp, const void *data,
14920 int runs, u64 *duration)
14921 {
14922 u64 start, finish;
14923 int ret = 0, i;
14924
14925 migrate_disable();
14926 start = ktime_get_ns();
14927
14928 for (i = 0; i < runs; i++)
14929 ret = bpf_prog_run(fp, data);
14930
14931 finish = ktime_get_ns();
14932 migrate_enable();
14933
14934 *duration = finish - start;
14935 do_div(*duration, runs);
14936
14937 return ret;
14938 }
14939
14940 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
14941 {
14942 int err_cnt = 0, i, runs = MAX_TESTRUNS;
14943
14944 if (test->nr_testruns)
14945 runs = min(test->nr_testruns, MAX_TESTRUNS);
14946
14947 for (i = 0; i < MAX_SUBTESTS; i++) {
14948 void *data;
14949 u64 duration;
14950 u32 ret;
14951
14952 /*
14953 * NOTE: Several sub-tests may be present, in which case
14954 * a zero {data_size, result} tuple indicates the end of
14955 * the sub-test array. The first test is always run,
14956 * even if both data_size and result happen to be zero.
14957 */
14958 if (i > 0 &&
14959 test->test[i].data_size == 0 &&
14960 test->test[i].result == 0)
14961 break;
14962
14963 data = generate_test_data(test, i);
14964 if (!data && !(test->aux & FLAG_NO_DATA)) {
14965 pr_cont("data generation failed ");
14966 err_cnt++;
14967 break;
14968 }
14969 ret = __run_one(fp, data, runs, &duration);
14970 release_test_data(test, data);
14971
14972 if (ret == test->test[i].result) {
14973 pr_cont("%lld ", duration);
14974 } else {
14975 s32 res = test->test[i].result;
14976
14977 pr_cont("ret %d != %d (%#x != %#x)",
14978 ret, res, ret, res);
14979 err_cnt++;
14980 }
14981 }
14982
14983 return err_cnt;
14984 }
14985
14986 static char test_name[64];
14987 module_param_string(test_name, test_name, sizeof(test_name), 0);
14988
14989 static int test_id = -1;
14990 module_param(test_id, int, 0);
14991
14992 static int test_range[2] = { 0, INT_MAX };
14993 module_param_array(test_range, int, NULL, 0);
14994
14995 static bool exclude_test(int test_id)
14996 {
14997 return test_id < test_range[0] || test_id > test_range[1];
14998 }
14999
15000 static __init struct sk_buff *build_test_skb(void)
15001 {
15002 u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
15003 struct sk_buff *skb[2];
15004 struct page *page[2];
15005 int i, data_size = 8;
15006
15007 for (i = 0; i < 2; i++) {
15008 page[i] = alloc_page(GFP_KERNEL);
15009 if (!page[i]) {
15010 if (i == 0)
15011 goto err_page0;
15012 else
15013 goto err_page1;
15014 }
15015
15016 /* this will set skb[i]->head_frag */
15017 skb[i] = dev_alloc_skb(headroom + data_size);
15018 if (!skb[i]) {
15019 if (i == 0)
15020 goto err_skb0;
15021 else
15022 goto err_skb1;
15023 }
15024
15025 skb_reserve(skb[i], headroom);
15026 skb_put(skb[i], data_size);
15027 skb[i]->protocol = htons(ETH_P_IP);
15028 skb_reset_network_header(skb[i]);
15029 skb_set_mac_header(skb[i], -ETH_HLEN);
15030
15031 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
15032 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
15033 }
15034
15035 /* setup shinfo */
15036 skb_shinfo(skb[0])->gso_size = 1448;
15037 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
15038 skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
15039 skb_shinfo(skb[0])->gso_segs = 0;
15040 skb_shinfo(skb[0])->frag_list = skb[1];
15041 skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
15042
15043 /* adjust skb[0]'s len */
15044 skb[0]->len += skb[1]->len;
15045 skb[0]->data_len += skb[1]->data_len;
15046 skb[0]->truesize += skb[1]->truesize;
15047
15048 return skb[0];
15049
15050 err_skb1:
15051 __free_page(page[1]);
15052 err_page1:
15053 kfree_skb(skb[0]);
15054 err_skb0:
15055 __free_page(page[0]);
15056 err_page0:
15057 return NULL;
15058 }
15059
15060 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
15061 {
15062 unsigned int alloc_size = 2000;
15063 unsigned int headroom = 102, doffset = 72, data_size = 1308;
15064 struct sk_buff *skb[2];
15065 int i;
15066
15067 /* skbs linked in a frag_list, both with linear data, with head_frag=0
15068 * (data allocated by kmalloc), both have tcp data of 1308 bytes
15069 * (total payload is 2616 bytes).
15070 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
15071 */
15072 for (i = 0; i < 2; i++) {
15073 skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
15074 if (!skb[i]) {
15075 if (i == 0)
15076 goto err_skb0;
15077 else
15078 goto err_skb1;
15079 }
15080
15081 skb[i]->protocol = htons(ETH_P_IPV6);
15082 skb_reserve(skb[i], headroom);
15083 skb_put(skb[i], doffset + data_size);
15084 skb_reset_network_header(skb[i]);
15085 if (i == 0)
15086 skb_reset_mac_header(skb[i]);
15087 else
15088 skb_set_mac_header(skb[i], -ETH_HLEN);
15089 __skb_pull(skb[i], doffset);
15090 }
15091
15092 /* setup shinfo.
15093 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
15094 * reduced gso_size.
15095 */
15096 skb_shinfo(skb[0])->gso_size = 1288;
15097 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
15098 skb_shinfo(skb[0])->gso_segs = 0;
15099 skb_shinfo(skb[0])->frag_list = skb[1];
15100
15101 /* adjust skb[0]'s len */
15102 skb[0]->len += skb[1]->len;
15103 skb[0]->data_len += skb[1]->len;
15104 skb[0]->truesize += skb[1]->truesize;
15105
15106 return skb[0];
15107
15108 err_skb1:
15109 kfree_skb(skb[0]);
15110 err_skb0:
15111 return NULL;
15112 }
15113
15114 struct skb_segment_test {
15115 const char *descr;
15116 struct sk_buff *(*build_skb)(void);
15117 netdev_features_t features;
15118 };
15119
15120 static struct skb_segment_test skb_segment_tests[] __initconst = {
15121 {
15122 .descr = "gso_with_rx_frags",
15123 .build_skb = build_test_skb,
15124 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
15125 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
15126 },
15127 {
15128 .descr = "gso_linear_no_head_frag",
15129 .build_skb = build_test_skb_linear_no_head_frag,
15130 .features = NETIF_F_SG | NETIF_F_FRAGLIST |
15131 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
15132 NETIF_F_GRO | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
15133 NETIF_F_HW_VLAN_STAG_TX
15134 }
15135 };
15136
15137 static __init int test_skb_segment_single(const struct skb_segment_test *test)
15138 {
15139 struct sk_buff *skb, *segs;
15140 int ret = -1;
15141
15142 skb = test->build_skb();
15143 if (!skb) {
15144 pr_info("%s: failed to build_test_skb", __func__);
15145 goto done;
15146 }
15147
15148 segs = skb_segment(skb, test->features);
15149 if (!IS_ERR(segs)) {
15150 kfree_skb_list(segs);
15151 ret = 0;
15152 }
15153 kfree_skb(skb);
15154 done:
15155 return ret;
15156 }
15157
15158 static __init int test_skb_segment(void)
15159 {
15160 int i, err_cnt = 0, pass_cnt = 0;
15161
15162 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
15163 const struct skb_segment_test *test = &skb_segment_tests[i];
15164
15165 cond_resched();
15166 if (exclude_test(i))
15167 continue;
15168
15169 pr_info("#%d %s ", i, test->descr);
15170
15171 if (test_skb_segment_single(test)) {
15172 pr_cont("FAIL\n");
15173 err_cnt++;
15174 } else {
15175 pr_cont("PASS\n");
15176 pass_cnt++;
15177 }
15178 }
15179
15180 pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
15181 pass_cnt, err_cnt);
15182 return err_cnt ? -EINVAL : 0;
15183 }
15184
15185 static __init int test_bpf(void)
15186 {
15187 int i, err_cnt = 0, pass_cnt = 0;
15188 int jit_cnt = 0, run_cnt = 0;
15189
15190 for (i = 0; i < ARRAY_SIZE(tests); i++) {
15191 struct bpf_prog *fp;
15192 int err;
15193
15194 cond_resched();
15195 if (exclude_test(i))
15196 continue;
15197
15198 pr_info("#%d %s ", i, tests[i].descr);
15199
15200 if (tests[i].fill_helper &&
15201 tests[i].fill_helper(&tests[i]) < 0) {
15202 pr_cont("FAIL to prog_fill\n");
15203 continue;
15204 }
15205
15206 fp = generate_filter(i, &err);
15207
15208 if (tests[i].fill_helper) {
15209 kfree(tests[i].u.ptr.insns);
15210 tests[i].u.ptr.insns = NULL;
15211 }
15212
15213 if (fp == NULL) {
15214 if (err == 0) {
15215 pass_cnt++;
15216 continue;
15217 }
15218 err_cnt++;
15219 continue;
15220 }
15221
15222 pr_cont("jited:%u ", fp->jited);
15223
15224 run_cnt++;
15225 if (fp->jited)
15226 jit_cnt++;
15227
15228 err = run_one(fp, &tests[i]);
15229 release_filter(fp, i);
15230
15231 if (err) {
15232 pr_cont("FAIL (%d times)\n", err);
15233 err_cnt++;
15234 } else {
15235 pr_cont("PASS\n");
15236 pass_cnt++;
15237 }
15238 }
15239
15240 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
15241 pass_cnt, err_cnt, jit_cnt, run_cnt);
15242
15243 return err_cnt ? -EINVAL : 0;
15244 }
15245
15246 struct tail_call_test {
15247 const char *descr;
15248 struct bpf_insn insns[MAX_INSNS];
15249 int flags;
15250 int result;
15251 int stack_depth;
15252 bool has_tail_call;
15253 };
15254
15255 /* Flags that can be passed to tail call test cases */
15256 #define FLAG_NEED_STATE BIT(0)
15257 #define FLAG_RESULT_IN_STATE BIT(1)
15258
15259 /*
15260 * Magic marker used in test snippets for tail calls below.
15261 * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
15262 * with the proper values by the test runner.
15263 */
15264 #define TAIL_CALL_MARKER 0x7a11ca11
15265
15266 /* Special offset to indicate a NULL call target */
15267 #define TAIL_CALL_NULL 0x7fff
15268
15269 /* Special offset to indicate an out-of-range index */
15270 #define TAIL_CALL_INVALID 0x7ffe
15271
15272 #define TAIL_CALL(offset) \
15273 BPF_LD_IMM64(R2, TAIL_CALL_MARKER), \
15274 BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
15275 offset, TAIL_CALL_MARKER), \
15276 BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
15277
15278 /*
15279 * A test function to be called from a BPF program, clobbering a lot of
15280 * CPU registers in the process. A JITed BPF program calling this function
15281 * must save and restore any caller-saved registers it uses for internal
15282 * state, for example the current tail call count.
15283 */
15284 BPF_CALL_1(bpf_test_func, u64, arg)
15285 {
15286 char buf[64];
15287 long a = 0;
15288 long b = 1;
15289 long c = 2;
15290 long d = 3;
15291 long e = 4;
15292 long f = 5;
15293 long g = 6;
15294 long h = 7;
15295
15296 return snprintf(buf, sizeof(buf),
15297 "%ld %lu %lx %ld %lu %lx %ld %lu %x",
15298 a, b, c, d, e, f, g, h, (int)arg);
15299 }
15300 #define BPF_FUNC_test_func __BPF_FUNC_MAX_ID
15301
15302 /*
15303 * Tail call tests. Each test case may call any other test in the table,
15304 * including itself, specified as a relative index offset from the calling
15305 * test. The index TAIL_CALL_NULL can be used to specify a NULL target
15306 * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
15307 * results in a target index that is out of range.
15308 */
15309 static struct tail_call_test tail_call_tests[] = {
15310 {
15311 "Tail call leaf",
15312 .insns = {
15313 BPF_ALU64_REG(BPF_MOV, R0, R1),
15314 BPF_ALU64_IMM(BPF_ADD, R0, 1),
15315 BPF_EXIT_INSN(),
15316 },
15317 .result = 1,
15318 },
15319 {
15320 "Tail call 2",
15321 .insns = {
15322 BPF_ALU64_IMM(BPF_ADD, R1, 2),
15323 TAIL_CALL(-1),
15324 BPF_ALU64_IMM(BPF_MOV, R0, -1),
15325 BPF_EXIT_INSN(),
15326 },
15327 .result = 3,
15328 .has_tail_call = true,
15329 },
15330 {
15331 "Tail call 3",
15332 .insns = {
15333 BPF_ALU64_IMM(BPF_ADD, R1, 3),
15334 TAIL_CALL(-1),
15335 BPF_ALU64_IMM(BPF_MOV, R0, -1),
15336 BPF_EXIT_INSN(),
15337 },
15338 .result = 6,
15339 .has_tail_call = true,
15340 },
15341 {
15342 "Tail call 4",
15343 .insns = {
15344 BPF_ALU64_IMM(BPF_ADD, R1, 4),
15345 TAIL_CALL(-1),
15346 BPF_ALU64_IMM(BPF_MOV, R0, -1),
15347 BPF_EXIT_INSN(),
15348 },
15349 .result = 10,
15350 .has_tail_call = true,
15351 },
15352 {
15353 "Tail call load/store leaf",
15354 .insns = {
15355 BPF_ALU64_IMM(BPF_MOV, R1, 1),
15356 BPF_ALU64_IMM(BPF_MOV, R2, 2),
15357 BPF_ALU64_REG(BPF_MOV, R3, BPF_REG_FP),
15358 BPF_STX_MEM(BPF_DW, R3, R1, -8),
15359 BPF_STX_MEM(BPF_DW, R3, R2, -16),
15360 BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -8),
15361 BPF_JMP_REG(BPF_JNE, R0, R1, 3),
15362 BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -16),
15363 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
15364 BPF_ALU64_IMM(BPF_MOV, R0, 0),
15365 BPF_EXIT_INSN(),
15366 },
15367 .result = 0,
15368 .stack_depth = 32,
15369 },
15370 {
15371 "Tail call load/store",
15372 .insns = {
15373 BPF_ALU64_IMM(BPF_MOV, R0, 3),
15374 BPF_STX_MEM(BPF_DW, BPF_REG_FP, R0, -8),
15375 TAIL_CALL(-1),
15376 BPF_ALU64_IMM(BPF_MOV, R0, -1),
15377 BPF_EXIT_INSN(),
15378 },
15379 .result = 0,
15380 .stack_depth = 16,
15381 .has_tail_call = true,
15382 },
15383 {
15384 "Tail call error path, max count reached",
15385 .insns = {
15386 BPF_LDX_MEM(BPF_W, R2, R1, 0),
15387 BPF_ALU64_IMM(BPF_ADD, R2, 1),
15388 BPF_STX_MEM(BPF_W, R1, R2, 0),
15389 TAIL_CALL(0),
15390 BPF_EXIT_INSN(),
15391 },
15392 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15393 .result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
15394 .has_tail_call = true,
15395 },
15396 {
15397 "Tail call count preserved across function calls",
15398 .insns = {
15399 BPF_LDX_MEM(BPF_W, R2, R1, 0),
15400 BPF_ALU64_IMM(BPF_ADD, R2, 1),
15401 BPF_STX_MEM(BPF_W, R1, R2, 0),
15402 BPF_STX_MEM(BPF_DW, R10, R1, -8),
15403 BPF_CALL_REL(BPF_FUNC_get_numa_node_id),
15404 BPF_CALL_REL(BPF_FUNC_ktime_get_ns),
15405 BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns),
15406 BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns),
15407 BPF_CALL_REL(BPF_FUNC_jiffies64),
15408 BPF_CALL_REL(BPF_FUNC_test_func),
15409 BPF_LDX_MEM(BPF_DW, R1, R10, -8),
15410 BPF_ALU32_REG(BPF_MOV, R0, R1),
15411 TAIL_CALL(0),
15412 BPF_EXIT_INSN(),
15413 },
15414 .stack_depth = 8,
15415 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15416 .result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS,
15417 .has_tail_call = true,
15418 },
15419 {
15420 "Tail call error path, NULL target",
15421 .insns = {
15422 BPF_LDX_MEM(BPF_W, R2, R1, 0),
15423 BPF_ALU64_IMM(BPF_ADD, R2, 1),
15424 BPF_STX_MEM(BPF_W, R1, R2, 0),
15425 TAIL_CALL(TAIL_CALL_NULL),
15426 BPF_EXIT_INSN(),
15427 },
15428 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15429 .result = MAX_TESTRUNS,
15430 .has_tail_call = true,
15431 },
15432 {
15433 "Tail call error path, index out of range",
15434 .insns = {
15435 BPF_LDX_MEM(BPF_W, R2, R1, 0),
15436 BPF_ALU64_IMM(BPF_ADD, R2, 1),
15437 BPF_STX_MEM(BPF_W, R1, R2, 0),
15438 TAIL_CALL(TAIL_CALL_INVALID),
15439 BPF_EXIT_INSN(),
15440 },
15441 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
15442 .result = MAX_TESTRUNS,
15443 .has_tail_call = true,
15444 },
15445 };
15446
15447 static void __init destroy_tail_call_tests(struct bpf_array *progs)
15448 {
15449 int i;
15450
15451 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
15452 if (progs->ptrs[i])
15453 bpf_prog_free(progs->ptrs[i]);
15454 kfree(progs);
15455 }
15456
15457 static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
15458 {
15459 int ntests = ARRAY_SIZE(tail_call_tests);
15460 struct bpf_array *progs;
15461 int which, err;
15462
15463 /* Allocate the table of programs to be used for tail calls */
15464 progs = kzalloc(struct_size(progs, ptrs, ntests + 1), GFP_KERNEL);
15465 if (!progs)
15466 goto out_nomem;
15467
15468 /* Create all eBPF programs and populate the table */
15469 for (which = 0; which < ntests; which++) {
15470 struct tail_call_test *test = &tail_call_tests[which];
15471 struct bpf_prog *fp;
15472 int len, i;
15473
15474 /* Compute the number of program instructions */
15475 for (len = 0; len < MAX_INSNS; len++) {
15476 struct bpf_insn *insn = &test->insns[len];
15477
15478 if (len < MAX_INSNS - 1 &&
15479 insn->code == (BPF_LD | BPF_DW | BPF_IMM))
15480 len++;
15481 if (insn->code == 0)
15482 break;
15483 }
15484
15485 /* Allocate and initialize the program */
15486 fp = bpf_prog_alloc(bpf_prog_size(len), 0);
15487 if (!fp)
15488 goto out_nomem;
15489
15490 fp->len = len;
15491 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
15492 fp->aux->stack_depth = test->stack_depth;
15493 fp->aux->tail_call_reachable = test->has_tail_call;
15494 memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
15495
15496 /* Relocate runtime tail call offsets and addresses */
15497 for (i = 0; i < len; i++) {
15498 struct bpf_insn *insn = &fp->insnsi[i];
15499 long addr = 0;
15500
15501 switch (insn->code) {
15502 case BPF_LD | BPF_DW | BPF_IMM:
15503 if (insn->imm != TAIL_CALL_MARKER)
15504 break;
15505 insn[0].imm = (u32)(long)progs;
15506 insn[1].imm = ((u64)(long)progs) >> 32;
15507 break;
15508
15509 case BPF_ALU | BPF_MOV | BPF_K:
15510 if (insn->imm != TAIL_CALL_MARKER)
15511 break;
15512 if (insn->off == TAIL_CALL_NULL)
15513 insn->imm = ntests;
15514 else if (insn->off == TAIL_CALL_INVALID)
15515 insn->imm = ntests + 1;
15516 else
15517 insn->imm = which + insn->off;
15518 insn->off = 0;
15519 break;
15520
15521 case BPF_JMP | BPF_CALL:
15522 if (insn->src_reg != BPF_PSEUDO_CALL)
15523 break;
15524 switch (insn->imm) {
15525 case BPF_FUNC_get_numa_node_id:
15526 addr = (long)&numa_node_id;
15527 break;
15528 case BPF_FUNC_ktime_get_ns:
15529 addr = (long)&ktime_get_ns;
15530 break;
15531 case BPF_FUNC_ktime_get_boot_ns:
15532 addr = (long)&ktime_get_boot_fast_ns;
15533 break;
15534 case BPF_FUNC_ktime_get_coarse_ns:
15535 addr = (long)&ktime_get_coarse_ns;
15536 break;
15537 case BPF_FUNC_jiffies64:
15538 addr = (long)&get_jiffies_64;
15539 break;
15540 case BPF_FUNC_test_func:
15541 addr = (long)&bpf_test_func;
15542 break;
15543 default:
15544 err = -EFAULT;
15545 goto out_err;
15546 }
15547 *insn = BPF_EMIT_CALL(addr);
15548 if ((long)__bpf_call_base + insn->imm != addr)
15549 *insn = BPF_JMP_A(0); /* Skip: NOP */
15550 break;
15551 }
15552 }
15553
15554 fp = bpf_prog_select_runtime(fp, &err);
15555 if (err)
15556 goto out_err;
15557
15558 progs->ptrs[which] = fp;
15559 }
15560
15561 /* The last entry contains a NULL program pointer */
15562 progs->map.max_entries = ntests + 1;
15563 *pprogs = progs;
15564 return 0;
15565
15566 out_nomem:
15567 err = -ENOMEM;
15568
15569 out_err:
15570 if (progs)
15571 destroy_tail_call_tests(progs);
15572 return err;
15573 }
15574
15575 static __init int test_tail_calls(struct bpf_array *progs)
15576 {
15577 int i, err_cnt = 0, pass_cnt = 0;
15578 int jit_cnt = 0, run_cnt = 0;
15579
15580 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
15581 struct tail_call_test *test = &tail_call_tests[i];
15582 struct bpf_prog *fp = progs->ptrs[i];
15583 int *data = NULL;
15584 int state = 0;
15585 u64 duration;
15586 int ret;
15587
15588 cond_resched();
15589 if (exclude_test(i))
15590 continue;
15591
15592 pr_info("#%d %s ", i, test->descr);
15593 if (!fp) {
15594 err_cnt++;
15595 continue;
15596 }
15597 pr_cont("jited:%u ", fp->jited);
15598
15599 run_cnt++;
15600 if (fp->jited)
15601 jit_cnt++;
15602
15603 if (test->flags & FLAG_NEED_STATE)
15604 data = &state;
15605 ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
15606 if (test->flags & FLAG_RESULT_IN_STATE)
15607 ret = state;
15608 if (ret == test->result) {
15609 pr_cont("%lld PASS", duration);
15610 pass_cnt++;
15611 } else {
15612 pr_cont("ret %d != %d FAIL", ret, test->result);
15613 err_cnt++;
15614 }
15615 }
15616
15617 pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
15618 __func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
15619
15620 return err_cnt ? -EINVAL : 0;
15621 }
15622
15623 static char test_suite[32];
15624 module_param_string(test_suite, test_suite, sizeof(test_suite), 0);
15625
15626 static __init int find_test_index(const char *test_name)
15627 {
15628 int i;
15629
15630 if (!strcmp(test_suite, "test_bpf")) {
15631 for (i = 0; i < ARRAY_SIZE(tests); i++) {
15632 if (!strcmp(tests[i].descr, test_name))
15633 return i;
15634 }
15635 }
15636
15637 if (!strcmp(test_suite, "test_tail_calls")) {
15638 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
15639 if (!strcmp(tail_call_tests[i].descr, test_name))
15640 return i;
15641 }
15642 }
15643
15644 if (!strcmp(test_suite, "test_skb_segment")) {
15645 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
15646 if (!strcmp(skb_segment_tests[i].descr, test_name))
15647 return i;
15648 }
15649 }
15650
15651 return -1;
15652 }
15653
15654 static __init int prepare_test_range(void)
15655 {
15656 int valid_range;
15657
15658 if (!strcmp(test_suite, "test_bpf"))
15659 valid_range = ARRAY_SIZE(tests);
15660 else if (!strcmp(test_suite, "test_tail_calls"))
15661 valid_range = ARRAY_SIZE(tail_call_tests);
15662 else if (!strcmp(test_suite, "test_skb_segment"))
15663 valid_range = ARRAY_SIZE(skb_segment_tests);
15664 else
15665 return 0;
15666
15667 if (test_id >= 0) {
15668 /*
15669 * if a test_id was specified, use test_range to
15670 * cover only that test.
15671 */
15672 if (test_id >= valid_range) {
15673 pr_err("test_bpf: invalid test_id specified for '%s' suite.\n",
15674 test_suite);
15675 return -EINVAL;
15676 }
15677
15678 test_range[0] = test_id;
15679 test_range[1] = test_id;
15680 } else if (*test_name) {
15681 /*
15682 * if a test_name was specified, find it and setup
15683 * test_range to cover only that test.
15684 */
15685 int idx = find_test_index(test_name);
15686
15687 if (idx < 0) {
15688 pr_err("test_bpf: no test named '%s' found for '%s' suite.\n",
15689 test_name, test_suite);
15690 return -EINVAL;
15691 }
15692 test_range[0] = idx;
15693 test_range[1] = idx;
15694 } else if (test_range[0] != 0 || test_range[1] != INT_MAX) {
15695 /*
15696 * check that the supplied test_range is valid.
15697 */
15698 if (test_range[0] < 0 || test_range[1] >= valid_range) {
15699 pr_err("test_bpf: test_range is out of bound for '%s' suite.\n",
15700 test_suite);
15701 return -EINVAL;
15702 }
15703
15704 if (test_range[1] < test_range[0]) {
15705 pr_err("test_bpf: test_range is ending before it starts.\n");
15706 return -EINVAL;
15707 }
15708 }
15709
15710 return 0;
15711 }
15712
15713 static int __init test_bpf_init(void)
15714 {
15715 struct bpf_array *progs = NULL;
15716 int ret;
15717
15718 if (strlen(test_suite) &&
15719 strcmp(test_suite, "test_bpf") &&
15720 strcmp(test_suite, "test_tail_calls") &&
15721 strcmp(test_suite, "test_skb_segment")) {
15722 pr_err("test_bpf: invalid test_suite '%s' specified.\n", test_suite);
15723 return -EINVAL;
15724 }
15725
15726 /*
15727 * if test_suite is not specified, but test_id, test_name or test_range
15728 * is specified, set 'test_bpf' as the default test suite.
15729 */
15730 if (!strlen(test_suite) &&
15731 (test_id != -1 || strlen(test_name) ||
15732 (test_range[0] != 0 || test_range[1] != INT_MAX))) {
15733 pr_info("test_bpf: set 'test_bpf' as the default test_suite.\n");
15734 strscpy(test_suite, "test_bpf", sizeof(test_suite));
15735 }
15736
15737 ret = prepare_test_range();
15738 if (ret < 0)
15739 return ret;
15740
15741 if (!strlen(test_suite) || !strcmp(test_suite, "test_bpf")) {
15742 ret = test_bpf();
15743 if (ret)
15744 return ret;
15745 }
15746
15747 if (!strlen(test_suite) || !strcmp(test_suite, "test_tail_calls")) {
15748 ret = prepare_tail_call_tests(&progs);
15749 if (ret)
15750 return ret;
15751 ret = test_tail_calls(progs);
15752 destroy_tail_call_tests(progs);
15753 if (ret)
15754 return ret;
15755 }
15756
15757 if (!strlen(test_suite) || !strcmp(test_suite, "test_skb_segment"))
15758 return test_skb_segment();
15759
15760 return 0;
15761 }
15762
15763 static void __exit test_bpf_exit(void)
15764 {
15765 }
15766
15767 module_init(test_bpf_init);
15768 module_exit(test_bpf_exit);
15769
15770 MODULE_DESCRIPTION("Testsuite for BPF interpreter and BPF JIT compiler");
15771 MODULE_LICENSE("GPL");
A mirror of Linus' kernel repository