]> Git Repo - linux.git/blame - lib/test_bpf.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bpf/tests: Add exhaustive test of LD_IMM64 immediate magnitudes
[linux.git] / lib / test_bpf.c
CommitLineData
5b497af4 1// SPDX-License-Identifier: GPL-2.0-only
64a8946b
AS		 2/*
3 * Testsuite for BPF interpreter and BPF JIT compiler
4 *
5 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
64a8946b
AS		 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>
4d9c5c53 13#include <linux/bpf.h>
64a8946b
AS		 14#include <linux/skbuff.h>
15#include <linux/netdevice.h>
16#include <linux/if_vlan.h>
a4afd37b 17#include <linux/random.h>
bac142ac 18#include <linux/highmem.h>
d40bc962 19#include <linux/sched.h>
64a8946b 20
10f18e0b 21/* General test specific settings */
64a8946b 22#define MAX_SUBTESTS 3
9960d766 23#define MAX_TESTRUNS 1000
64a8946b
AS		 24#define MAX_DATA 128
25#define MAX_INSNS 512
26#define MAX_K 0xffffFFFF
27
10f18e0b 28/* Few constants used to init test 'skb' */
64a8946b
AS		 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
0c4b2d37 34#define SKB_VLAN_PRESENT 1
64a8946b
AS		 35#define SKB_DEV_IFINDEX 577
36#define SKB_DEV_TYPE 588
37
10f18e0b
DB		 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)
bac142ac 54#define FLAG_SKB_FRAG BIT(2)
10f18e0b
DB		 55
56enum {
57 CLASSIC = BIT(6), /* Old BPF instructions only. */
58 INTERNAL = BIT(7), /* Extended instruction set. */
59};
60
61#define TEST_TYPE_MASK (CLASSIC | INTERNAL)
64a8946b
AS		 62
63struct bpf_test {
64 const char *descr;
65 union {
66 struct sock_filter insns[MAX_INSNS];
2695fb55 67 struct bpf_insn insns_int[MAX_INSNS];
a4afd37b
DB		 68 struct {
69 void *insns;
70 unsigned int len;
71 } ptr;
ece80490 72 } u;
10f18e0b 73 __u8 aux;
64a8946b
AS		 74 __u8 data[MAX_DATA];
75 struct {
76 int data_size;
77 __u32 result;
78 } test[MAX_SUBTESTS];
a4afd37b 79 int (*fill_helper)(struct bpf_test *self);
09584b40 80 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
bac142ac 81 __u8 frag_data[MAX_DATA];
105c0361 82 int stack_depth; /* for eBPF only, since tests don't call verifier */
c2a228d6 83 int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
64a8946b
AS		 84};
85
a4afd37b
DB		 86/* Large test cases need separate allocation and fill handler. */
87
88static int bpf_fill_maxinsns1(struct bpf_test *self)
89{
90 unsigned int len = BPF_MAXINSNS;
91 struct sock_filter *insn;
92 __u32 k = ~0;
93 int i;
94
95 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
96 if (!insn)
97 return -ENOMEM;
98
99 for (i = 0; i < len; i++, k--)
100 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
101
102 self->u.ptr.insns = insn;
103 self->u.ptr.len = len;
104
105 return 0;
106}
107
108static int bpf_fill_maxinsns2(struct bpf_test *self)
109{
110 unsigned int len = BPF_MAXINSNS;
111 struct sock_filter *insn;
112 int i;
113
114 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
115 if (!insn)
116 return -ENOMEM;
117
118 for (i = 0; i < len; i++)
119 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
120
121 self->u.ptr.insns = insn;
122 self->u.ptr.len = len;
123
124 return 0;
125}
126
127static int bpf_fill_maxinsns3(struct bpf_test *self)
128{
129 unsigned int len = BPF_MAXINSNS;
130 struct sock_filter *insn;
131 struct rnd_state rnd;
132 int i;
133
134 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
135 if (!insn)
136 return -ENOMEM;
137
138 prandom_seed_state(&rnd, 3141592653589793238ULL);
139
140 for (i = 0; i < len - 1; i++) {
141 __u32 k = prandom_u32_state(&rnd);
142
143 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
144 }
145
146 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
147
148 self->u.ptr.insns = insn;
149 self->u.ptr.len = len;
150
151 return 0;
152}
153
154static int bpf_fill_maxinsns4(struct bpf_test *self)
155{
156 unsigned int len = BPF_MAXINSNS + 1;
157 struct sock_filter *insn;
158 int i;
159
160 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
161 if (!insn)
162 return -ENOMEM;
163
164 for (i = 0; i < len; i++)
165 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
166
167 self->u.ptr.insns = insn;
168 self->u.ptr.len = len;
169
170 return 0;
171}
172
173static int bpf_fill_maxinsns5(struct bpf_test *self)
174{
175 unsigned int len = BPF_MAXINSNS;
176 struct sock_filter *insn;
177 int i;
178
179 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
180 if (!insn)
181 return -ENOMEM;
182
183 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
184
185 for (i = 1; i < len - 1; i++)
186 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
187
188 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
189
190 self->u.ptr.insns = insn;
191 self->u.ptr.len = len;
192
193 return 0;
194}
195
196static int bpf_fill_maxinsns6(struct bpf_test *self)
197{
198 unsigned int len = BPF_MAXINSNS;
199 struct sock_filter *insn;
200 int i;
201
202 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
203 if (!insn)
204 return -ENOMEM;
205
206 for (i = 0; i < len - 1; i++)
207 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
208 SKF_AD_VLAN_TAG_PRESENT);
209
210 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
211
212 self->u.ptr.insns = insn;
213 self->u.ptr.len = len;
214
215 return 0;
216}
217
218static int bpf_fill_maxinsns7(struct bpf_test *self)
219{
220 unsigned int len = BPF_MAXINSNS;
221 struct sock_filter *insn;
222 int i;
223
224 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
225 if (!insn)
226 return -ENOMEM;
227
228 for (i = 0; i < len - 4; i++)
229 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
230 SKF_AD_CPU);
231
232 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
233 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
234 SKF_AD_CPU);
235 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
236 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
237
238 self->u.ptr.insns = insn;
239 self->u.ptr.len = len;
240
241 return 0;
242}
243
244static int bpf_fill_maxinsns8(struct bpf_test *self)
245{
246 unsigned int len = BPF_MAXINSNS;
247 struct sock_filter *insn;
248 int i, jmp_off = len - 3;
249
250 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
251 if (!insn)
252 return -ENOMEM;
253
254 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
255
256 for (i = 1; i < len - 1; i++)
257 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
258
259 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
260
261 self->u.ptr.insns = insn;
262 self->u.ptr.len = len;
263
264 return 0;
265}
266
3b529602
DB		 267static int bpf_fill_maxinsns9(struct bpf_test *self)
268{
269 unsigned int len = BPF_MAXINSNS;
270 struct bpf_insn *insn;
271 int i;
272
273 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
274 if (!insn)
275 return -ENOMEM;
276
277 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
278 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
279 insn[2] = BPF_EXIT_INSN();
280
281 for (i = 3; i < len - 2; i++)
282 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
283
284 insn[len - 2] = BPF_EXIT_INSN();
285 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
286
287 self->u.ptr.insns = insn;
288 self->u.ptr.len = len;
289
290 return 0;
291}
292
293static int bpf_fill_maxinsns10(struct bpf_test *self)
294{
295 unsigned int len = BPF_MAXINSNS, hlen = len - 2;
296 struct bpf_insn *insn;
297 int i;
298
299 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
300 if (!insn)
301 return -ENOMEM;
302
303 for (i = 0; i < hlen / 2; i++)
304 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
305 for (i = hlen - 1; i > hlen / 2; i--)
306 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
307
308 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
309 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
310 insn[hlen + 1] = BPF_EXIT_INSN();
311
312 self->u.ptr.insns = insn;
313 self->u.ptr.len = len;
314
315 return 0;
316}
317
bde28bc6
DB		 318static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
319 unsigned int plen)
320{
321 struct sock_filter *insn;
322 unsigned int rlen;
323 int i, j;
324
325 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
326 if (!insn)
327 return -ENOMEM;
328
329 rlen = (len % plen) - 1;
330
331 for (i = 0; i + plen < len; i += plen)
332 for (j = 0; j < plen; j++)
333 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
334 plen - 1 - j, 0, 0);
335 for (j = 0; j < rlen; j++)
336 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
337 0, 0);
338
339 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
340
341 self->u.ptr.insns = insn;
342 self->u.ptr.len = len;
343
344 return 0;
345}
346
347static int bpf_fill_maxinsns11(struct bpf_test *self)
348{
16a660ef 349 /* Hits 70 passes on x86_64 and triggers NOPs padding. */
bde28bc6
DB		 350 return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
351}
352
be08815c
DB		 353static int bpf_fill_maxinsns12(struct bpf_test *self)
354{
355 unsigned int len = BPF_MAXINSNS;
356 struct sock_filter *insn;
357 int i = 0;
358
359 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
360 if (!insn)
361 return -ENOMEM;
362
363 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
364
365 for (i = 1; i < len - 1; i++)
366 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
367
368 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
369
370 self->u.ptr.insns = insn;
371 self->u.ptr.len = len;
372
373 return 0;
374}
375
376static int bpf_fill_maxinsns13(struct bpf_test *self)
377{
378 unsigned int len = BPF_MAXINSNS;
379 struct sock_filter *insn;
380 int i = 0;
381
382 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
383 if (!insn)
384 return -ENOMEM;
385
386 for (i = 0; i < len - 3; i++)
387 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
388
389 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
390 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
391 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
392
393 self->u.ptr.insns = insn;
394 self->u.ptr.len = len;
395
396 return 0;
397}
398
bde28bc6
DB		 399static int bpf_fill_ja(struct bpf_test *self)
400{
401 /* Hits exactly 11 passes on x86_64 JIT. */
402 return __bpf_fill_ja(self, 12, 9);
403}
404
4d9c5c53
AS		 405static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
406{
407 unsigned int len = BPF_MAXINSNS;
408 struct sock_filter *insn;
409 int i;
410
411 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
412 if (!insn)
413 return -ENOMEM;
414
415 for (i = 0; i < len - 1; i += 2) {
416 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
417 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
418 SKF_AD_OFF + SKF_AD_CPU);
419 }
420
421 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
422
423 self->u.ptr.insns = insn;
424 self->u.ptr.len = len;
425
426 return 0;
427}
428
85f68fe8
DB		 429static int __bpf_fill_stxdw(struct bpf_test *self, int size)
430{
431 unsigned int len = BPF_MAXINSNS;
432 struct bpf_insn *insn;
433 int i;
434
435 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
436 if (!insn)
437 return -ENOMEM;
438
439 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
440 insn[1] = BPF_ST_MEM(size, R10, -40, 42);
441
442 for (i = 2; i < len - 2; i++)
443 insn[i] = BPF_STX_XADD(size, R10, R0, -40);
444
445 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
446 insn[len - 1] = BPF_EXIT_INSN();
447
448 self->u.ptr.insns = insn;
449 self->u.ptr.len = len;
105c0361 450 self->stack_depth = 40;
85f68fe8
DB		 451
452 return 0;
453}
454
455static int bpf_fill_stxw(struct bpf_test *self)
456{
457 return __bpf_fill_stxdw(self, BPF_W);
458}
459
460static int bpf_fill_stxdw(struct bpf_test *self)
461{
462 return __bpf_fill_stxdw(self, BPF_DW);
463}
464
66e5eb84
JA		 465static int bpf_fill_long_jmp(struct bpf_test *self)
466{
467 unsigned int len = BPF_MAXINSNS;
468 struct bpf_insn *insn;
469 int i;
470
471 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
472 if (!insn)
473 return -ENOMEM;
474
475 insn[0] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
476 insn[1] = BPF_JMP_IMM(BPF_JEQ, R0, 1, len - 2 - 1);
477
478 /*
479 * Fill with a complex 64-bit operation that expands to a lot of
480 * instructions on 32-bit JITs. The large jump offset can then
481 * overflow the conditional branch field size, triggering a branch
482 * conversion mechanism in some JITs.
483 *
484 * Note: BPF_MAXINSNS of ALU64 MUL is enough to trigger such branch
485 * conversion on the 32-bit MIPS JIT. For other JITs, the instruction
486 * count and/or operation may need to be modified to trigger the
487 * branch conversion.
488 */
489 for (i = 2; i < len - 1; i++)
490 insn[i] = BPF_ALU64_IMM(BPF_MUL, R0, (i << 16) + i);
491
492 insn[len - 1] = BPF_EXIT_INSN();
493
494 self->u.ptr.insns = insn;
495 self->u.ptr.len = len;
496
497 return 0;
498}
499
68c956fe
JA		 500static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
501{
502 struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
503
504 memcpy(insns, tmp, sizeof(tmp));
505 return 2;
506}
507
508/* Test an ALU shift operation for all valid shift values */
509static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
510 u8 mode, bool alu32)
511{
512 static const s64 regs[] = {
513 0x0123456789abcdefLL, /* dword > 0, word < 0 */
514 0xfedcba9876543210LL, /* dowrd < 0, word > 0 */
515 0xfedcba0198765432LL, /* dowrd < 0, word < 0 */
516 0x0123458967abcdefLL, /* dword > 0, word > 0 */
517 };
518 int bits = alu32 ? 32 : 64;
519 int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
520 struct bpf_insn *insn;
521 int imm, k;
522 int i = 0;
523
524 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
525 if (!insn)
526 return -ENOMEM;
527
528 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
529
530 for (k = 0; k < ARRAY_SIZE(regs); k++) {
531 s64 reg = regs[k];
532
533 i += __bpf_ld_imm64(&insn[i], R3, reg);
534
535 for (imm = 0; imm < bits; imm++) {
536 u64 val;
537
538 /* Perform operation */
539 insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
540 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
541 if (alu32) {
542 if (mode == BPF_K)
543 insn[i++] = BPF_ALU32_IMM(op, R1, imm);
544 else
545 insn[i++] = BPF_ALU32_REG(op, R1, R2);
546 switch (op) {
547 case BPF_LSH:
548 val = (u32)reg << imm;
549 break;
550 case BPF_RSH:
551 val = (u32)reg >> imm;
552 break;
553 case BPF_ARSH:
554 val = (u32)reg >> imm;
555 if (imm > 0 && (reg & 0x80000000))
556 val |= ~(u32)0 << (32 - imm);
557 break;
558 }
559 } else {
560 if (mode == BPF_K)
561 insn[i++] = BPF_ALU64_IMM(op, R1, imm);
562 else
563 insn[i++] = BPF_ALU64_REG(op, R1, R2);
564 switch (op) {
565 case BPF_LSH:
566 val = (u64)reg << imm;
567 break;
568 case BPF_RSH:
569 val = (u64)reg >> imm;
570 break;
571 case BPF_ARSH:
572 val = (u64)reg >> imm;
573 if (imm > 0 && reg < 0)
574 val |= ~(u64)0 << (64 - imm);
575 break;
576 }
577 }
578
579 /*
580 * When debugging a JIT that fails this test, one
581 * can write the immediate value to R0 here to find
582 * out which operand values that fail.
583 */
584
585 /* Load reference and check the result */
586 i += __bpf_ld_imm64(&insn[i], R4, val);
587 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
588 insn[i++] = BPF_EXIT_INSN();
589 }
590 }
591
592 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
593 insn[i++] = BPF_EXIT_INSN();
594
595 self->u.ptr.insns = insn;
596 self->u.ptr.len = len;
597 BUG_ON(i > len);
598
599 return 0;
600}
601
602static int bpf_fill_alu_lsh_imm(struct bpf_test *self)
603{
604 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false);
605}
606
607static int bpf_fill_alu_rsh_imm(struct bpf_test *self)
608{
609 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false);
610}
611
612static int bpf_fill_alu_arsh_imm(struct bpf_test *self)
613{
614 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false);
615}
616
617static int bpf_fill_alu_lsh_reg(struct bpf_test *self)
618{
619 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false);
620}
621
622static int bpf_fill_alu_rsh_reg(struct bpf_test *self)
623{
624 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false);
625}
626
627static int bpf_fill_alu_arsh_reg(struct bpf_test *self)
628{
629 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false);
630}
631
632static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
633{
634 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true);
635}
636
637static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
638{
639 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true);
640}
641
642static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
643{
644 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true);
645}
646
647static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
648{
649 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true);
650}
651
652static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
653{
654 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true);
655}
656
657static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
658{
659 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true);
660}
661
9298e63e
JA		 662/*
663 * Common operand pattern generator for exhaustive power-of-two magnitudes
664 * tests. The block size parameters can be adjusted to increase/reduce the
665 * number of combinatons tested and thereby execution speed and memory
666 * footprint.
667 */
668
669static inline s64 value(int msb, int delta, int sign)
670{
671 return sign * (1LL << msb) + delta;
672}
673
674static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
675 int dbits, int sbits, int block1, int block2,
676 int (*emit)(struct bpf_test*, void*,
677 struct bpf_insn*, s64, s64))
678{
679 static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
680 struct bpf_insn *insns;
681 int di, si, bt, db, sb;
682 int count, len, k;
683 int extra = 1 + 2;
684 int i = 0;
685
686 /* Total number of iterations for the two pattern */
687 count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
688 count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
689
690 /* Compute the maximum number of insns and allocate the buffer */
691 len = extra + count * (*emit)(self, arg, NULL, 0, 0);
692 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
693 if (!insns)
694 return -ENOMEM;
695
696 /* Add head instruction(s) */
697 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
698
699 /*
700 * Pattern 1: all combinations of power-of-two magnitudes and sign,
701 * and with a block of contiguous values around each magnitude.
702 */
703 for (di = 0; di < dbits - 1; di++) /* Dst magnitudes */
704 for (si = 0; si < sbits - 1; si++) /* Src magnitudes */
705 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
706 for (db = -(block1 / 2);
707 db < (block1 + 1) / 2; db++)
708 for (sb = -(block1 / 2);
709 sb < (block1 + 1) / 2; sb++) {
710 s64 dst, src;
711
712 dst = value(di, db, sgn[k][0]);
713 src = value(si, sb, sgn[k][1]);
714 i += (*emit)(self, arg,
715 &insns[i],
716 dst, src);
717 }
718 /*
719 * Pattern 2: all combinations for a larger block of values
720 * for each power-of-two magnitude and sign, where the magnitude is
721 * the same for both operands.
722 */
723 for (bt = 0; bt < max(dbits, sbits) - 1; bt++) /* Magnitude */
724 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
725 for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
726 for (sb = -(block2 / 2);
727 sb < (block2 + 1) / 2; sb++) {
728 s64 dst, src;
729
730 dst = value(bt % dbits, db, sgn[k][0]);
731 src = value(bt % sbits, sb, sgn[k][1]);
732 i += (*emit)(self, arg, &insns[i],
733 dst, src);
734 }
735
736 /* Append tail instructions */
737 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
738 insns[i++] = BPF_EXIT_INSN();
739 BUG_ON(i > len);
740
741 self->u.ptr.insns = insns;
742 self->u.ptr.len = i;
743
744 return 0;
745}
746
747/*
748 * Block size parameters used in pattern tests below. une as needed to
749 * increase/reduce the number combinations tested, see following examples.
750 * block values per operand MSB
751 * ----------------------------------------
752 * 0 none
753 * 1 (1 << MSB)
754 * 2 (1 << MSB) + [-1, 0]
755 * 3 (1 << MSB) + [-1, 0, 1]
756 */
757#define PATTERN_BLOCK1 1
758#define PATTERN_BLOCK2 5
759
760/* Number of test runs for a pattern test */
761#define NR_PATTERN_RUNS 1
762
763/*
764 * Exhaustive tests of ALU operations for all combinations of power-of-two
765 * magnitudes of the operands, both for positive and negative values. The
766 * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
767 * emit different code depending on the magnitude of the immediate value.
768 */
769
770static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op)
771{
772 *res = 0;
773 switch (op) {
774 case BPF_MOV:
775 *res = v2;
776 break;
777 case BPF_AND:
778 *res = v1 & v2;
779 break;
780 case BPF_OR:
781 *res = v1 | v2;
782 break;
783 case BPF_XOR:
784 *res = v1 ^ v2;
785 break;
786 case BPF_ADD:
787 *res = v1 + v2;
788 break;
789 case BPF_SUB:
790 *res = v1 - v2;
791 break;
792 case BPF_MUL:
793 *res = v1 * v2;
794 break;
795 case BPF_DIV:
796 if (v2 == 0)
797 return false;
798 *res = div64_u64(v1, v2);
799 break;
800 case BPF_MOD:
801 if (v2 == 0)
802 return false;
803 div64_u64_rem(v1, v2, res);
804 break;
805 }
806 return true;
807}
808
809static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
810 struct bpf_insn *insns, s64 dst, s64 imm)
811{
812 int op = *(int *)arg;
813 int i = 0;
814 u64 res;
815
816 if (!insns)
817 return 7;
818
819 if (__bpf_alu_result(&res, dst, (s32)imm, op)) {
820 i += __bpf_ld_imm64(&insns[i], R1, dst);
821 i += __bpf_ld_imm64(&insns[i], R3, res);
822 insns[i++] = BPF_ALU64_IMM(op, R1, imm);
823 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
824 insns[i++] = BPF_EXIT_INSN();
825 }
826
827 return i;
828}
829
830static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
831 struct bpf_insn *insns, s64 dst, s64 imm)
832{
833 int op = *(int *)arg;
834 int i = 0;
835 u64 res;
836
837 if (!insns)
838 return 7;
839
840 if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {
841 i += __bpf_ld_imm64(&insns[i], R1, dst);
842 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
843 insns[i++] = BPF_ALU32_IMM(op, R1, imm);
844 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
845 insns[i++] = BPF_EXIT_INSN();
846 }
847
848 return i;
849}
850
851static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
852 struct bpf_insn *insns, s64 dst, s64 src)
853{
854 int op = *(int *)arg;
855 int i = 0;
856 u64 res;
857
858 if (!insns)
859 return 9;
860
861 if (__bpf_alu_result(&res, dst, src, op)) {
862 i += __bpf_ld_imm64(&insns[i], R1, dst);
863 i += __bpf_ld_imm64(&insns[i], R2, src);
864 i += __bpf_ld_imm64(&insns[i], R3, res);
865 insns[i++] = BPF_ALU64_REG(op, R1, R2);
866 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
867 insns[i++] = BPF_EXIT_INSN();
868 }
869
870 return i;
871}
872
873static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
874 struct bpf_insn *insns, s64 dst, s64 src)
875{
876 int op = *(int *)arg;
877 int i = 0;
878 u64 res;
879
880 if (!insns)
881 return 9;
882
883 if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {
884 i += __bpf_ld_imm64(&insns[i], R1, dst);
885 i += __bpf_ld_imm64(&insns[i], R2, src);
886 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
887 insns[i++] = BPF_ALU32_REG(op, R1, R2);
888 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
889 insns[i++] = BPF_EXIT_INSN();
890 }
891
892 return i;
893}
894
895static int __bpf_fill_alu64_imm(struct bpf_test *self, int op)
896{
897 return __bpf_fill_pattern(self, &op, 64, 32,
898 PATTERN_BLOCK1, PATTERN_BLOCK2,
899 &__bpf_emit_alu64_imm);
900}
901
902static int __bpf_fill_alu32_imm(struct bpf_test *self, int op)
903{
904 return __bpf_fill_pattern(self, &op, 64, 32,
905 PATTERN_BLOCK1, PATTERN_BLOCK2,
906 &__bpf_emit_alu32_imm);
907}
908
909static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
910{
911 return __bpf_fill_pattern(self, &op, 64, 64,
912 PATTERN_BLOCK1, PATTERN_BLOCK2,
913 &__bpf_emit_alu64_reg);
914}
915
916static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
917{
918 return __bpf_fill_pattern(self, &op, 64, 64,
919 PATTERN_BLOCK1, PATTERN_BLOCK2,
920 &__bpf_emit_alu32_reg);
921}
922
923/* ALU64 immediate operations */
924static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
925{
926 return __bpf_fill_alu64_imm(self, BPF_MOV);
927}
928
929static int bpf_fill_alu64_and_imm(struct bpf_test *self)
930{
931 return __bpf_fill_alu64_imm(self, BPF_AND);
932}
933
934static int bpf_fill_alu64_or_imm(struct bpf_test *self)
935{
936 return __bpf_fill_alu64_imm(self, BPF_OR);
937}
938
939static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
940{
941 return __bpf_fill_alu64_imm(self, BPF_XOR);
942}
943
944static int bpf_fill_alu64_add_imm(struct bpf_test *self)
945{
946 return __bpf_fill_alu64_imm(self, BPF_ADD);
947}
948
949static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
950{
951 return __bpf_fill_alu64_imm(self, BPF_SUB);
952}
953
954static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
955{
956 return __bpf_fill_alu64_imm(self, BPF_MUL);
957}
958
959static int bpf_fill_alu64_div_imm(struct bpf_test *self)
960{
961 return __bpf_fill_alu64_imm(self, BPF_DIV);
962}
963
964static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
965{
966 return __bpf_fill_alu64_imm(self, BPF_MOD);
967}
968
969/* ALU32 immediate operations */
970static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
971{
972 return __bpf_fill_alu32_imm(self, BPF_MOV);
973}
974
975static int bpf_fill_alu32_and_imm(struct bpf_test *self)
976{
977 return __bpf_fill_alu32_imm(self, BPF_AND);
978}
979
980static int bpf_fill_alu32_or_imm(struct bpf_test *self)
981{
982 return __bpf_fill_alu32_imm(self, BPF_OR);
983}
984
985static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
986{
987 return __bpf_fill_alu32_imm(self, BPF_XOR);
988}
989
990static int bpf_fill_alu32_add_imm(struct bpf_test *self)
991{
992 return __bpf_fill_alu32_imm(self, BPF_ADD);
993}
994
995static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
996{
997 return __bpf_fill_alu32_imm(self, BPF_SUB);
998}
999
1000static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1001{
1002 return __bpf_fill_alu32_imm(self, BPF_MUL);
1003}
1004
1005static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1006{
1007 return __bpf_fill_alu32_imm(self, BPF_DIV);
1008}
1009
1010static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1011{
1012 return __bpf_fill_alu32_imm(self, BPF_MOD);
1013}
1014
1015/* ALU64 register operations */
1016static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1017{
1018 return __bpf_fill_alu64_reg(self, BPF_MOV);
1019}
1020
1021static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1022{
1023 return __bpf_fill_alu64_reg(self, BPF_AND);
1024}
1025
1026static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1027{
1028 return __bpf_fill_alu64_reg(self, BPF_OR);
1029}
1030
1031static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1032{
1033 return __bpf_fill_alu64_reg(self, BPF_XOR);
1034}
1035
1036static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1037{
1038 return __bpf_fill_alu64_reg(self, BPF_ADD);
1039}
1040
1041static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1042{
1043 return __bpf_fill_alu64_reg(self, BPF_SUB);
1044}
1045
1046static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1047{
1048 return __bpf_fill_alu64_reg(self, BPF_MUL);
1049}
1050
1051static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1052{
1053 return __bpf_fill_alu64_reg(self, BPF_DIV);
1054}
1055
1056static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1057{
1058 return __bpf_fill_alu64_reg(self, BPF_MOD);
1059}
1060
1061/* ALU32 register operations */
1062static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1063{
1064 return __bpf_fill_alu32_reg(self, BPF_MOV);
1065}
1066
1067static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1068{
1069 return __bpf_fill_alu32_reg(self, BPF_AND);
1070}
1071
1072static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1073{
1074 return __bpf_fill_alu32_reg(self, BPF_OR);
1075}
1076
1077static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1078{
1079 return __bpf_fill_alu32_reg(self, BPF_XOR);
1080}
1081
1082static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1083{
1084 return __bpf_fill_alu32_reg(self, BPF_ADD);
1085}
1086
1087static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1088{
1089 return __bpf_fill_alu32_reg(self, BPF_SUB);
1090}
1091
1092static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1093{
1094 return __bpf_fill_alu32_reg(self, BPF_MUL);
1095}
1096
1097static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1098{
1099 return __bpf_fill_alu32_reg(self, BPF_DIV);
1100}
1101
1102static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1103{
1104 return __bpf_fill_alu32_reg(self, BPF_MOD);
1105}
1106
2e807611
JA		 1107/*
1108 * Test the two-instruction 64-bit immediate load operation for all
1109 * power-of-two magnitudes of the immediate operand. For each MSB, a block
1110 * of immediate values centered around the power-of-two MSB are tested,
1111 * both for positive and negative values. The test is designed to verify
1112 * the operation for JITs that emit different code depending on the magnitude
1113 * of the immediate value. This is often the case if the native instruction
1114 * immediate field width is narrower than 32 bits.
1115 */
1116static int bpf_fill_ld_imm64(struct bpf_test *self)
1117{
1118 int block = 64; /* Increase for more tests per MSB position */
1119 int len = 3 + 8 * 63 * block * 2;
1120 struct bpf_insn *insn;
1121 int bit, adj, sign;
1122 int i = 0;
1123
1124 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
1125 if (!insn)
1126 return -ENOMEM;
1127
1128 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
1129
1130 for (bit = 0; bit <= 62; bit++) {
1131 for (adj = -block / 2; adj < block / 2; adj++) {
1132 for (sign = -1; sign <= 1; sign += 2) {
1133 s64 imm = sign * ((1LL << bit) + adj);
1134
1135 /* Perform operation */
1136 i += __bpf_ld_imm64(&insn[i], R1, imm);
1137
1138 /* Load reference */
1139 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
1140 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
1141 (u32)(imm >> 32));
1142 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
1143 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
1144
1145 /* Check result */
1146 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
1147 insn[i++] = BPF_EXIT_INSN();
1148 }
1149 }
1150 }
1151
1152 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
1153 insn[i++] = BPF_EXIT_INSN();
1154
1155 self->u.ptr.insns = insn;
1156 self->u.ptr.len = len;
1157 BUG_ON(i != len);
1158
1159 return 0;
1160}
a5a36544
JA		 1161
1162/*
1163 * Exhaustive tests of JMP operations for all combinations of power-of-two
1164 * magnitudes of the operands, both for positive and negative values. The
1165 * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
1166 * emit different code depending on the magnitude of the immediate value.
1167 */
1168
1169static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
1170{
1171 switch (op) {
1172 case BPF_JSET:
1173 return !!(v1 & v2);
1174 case BPF_JEQ:
1175 return v1 == v2;
1176 case BPF_JNE:
1177 return v1 != v2;
1178 case BPF_JGT:
1179 return (u64)v1 > (u64)v2;
1180 case BPF_JGE:
1181 return (u64)v1 >= (u64)v2;
1182 case BPF_JLT:
1183 return (u64)v1 < (u64)v2;
1184 case BPF_JLE:
1185 return (u64)v1 <= (u64)v2;
1186 case BPF_JSGT:
1187 return v1 > v2;
1188 case BPF_JSGE:
1189 return v1 >= v2;
1190 case BPF_JSLT:
1191 return v1 < v2;
1192 case BPF_JSLE:
1193 return v1 <= v2;
1194 }
1195 return false;
1196}
1197
1198static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
1199 struct bpf_insn *insns, s64 dst, s64 imm)
1200{
1201 int op = *(int *)arg;
1202
1203 if (insns) {
1204 bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
1205 int i = 0;
1206
1207 insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
1208
1209 i += __bpf_ld_imm64(&insns[i], R1, dst);
1210 insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
1211 if (!match)
1212 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1213 insns[i++] = BPF_EXIT_INSN();
1214
1215 return i;
1216 }
1217
1218 return 5 + 1;
1219}
1220
1221static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
1222 struct bpf_insn *insns, s64 dst, s64 imm)
1223{
1224 int op = *(int *)arg;
1225
1226 if (insns) {
1227 bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
1228 int i = 0;
1229
1230 i += __bpf_ld_imm64(&insns[i], R1, dst);
1231 insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
1232 if (!match)
1233 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1234 insns[i++] = BPF_EXIT_INSN();
1235
1236 return i;
1237 }
1238
1239 return 5;
1240}
1241
1242static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
1243 struct bpf_insn *insns, s64 dst, s64 src)
1244{
1245 int op = *(int *)arg;
1246
1247 if (insns) {
1248 bool match = __bpf_match_jmp_cond(dst, src, op);
1249 int i = 0;
1250
1251 i += __bpf_ld_imm64(&insns[i], R1, dst);
1252 i += __bpf_ld_imm64(&insns[i], R2, src);
1253 insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
1254 if (!match)
1255 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1256 insns[i++] = BPF_EXIT_INSN();
1257
1258 return i;
1259 }
1260
1261 return 7;
1262}
1263
1264static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
1265 struct bpf_insn *insns, s64 dst, s64 src)
1266{
1267 int op = *(int *)arg;
1268
1269 if (insns) {
1270 bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
1271 int i = 0;
1272
1273 i += __bpf_ld_imm64(&insns[i], R1, dst);
1274 i += __bpf_ld_imm64(&insns[i], R2, src);
1275 insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
1276 if (!match)
1277 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1278 insns[i++] = BPF_EXIT_INSN();
1279
1280 return i;
1281 }
1282
1283 return 7;
1284}
1285
1286static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
1287{
1288 return __bpf_fill_pattern(self, &op, 64, 32,
1289 PATTERN_BLOCK1, PATTERN_BLOCK2,
1290 &__bpf_emit_jmp_imm);
1291}
1292
1293static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
1294{
1295 return __bpf_fill_pattern(self, &op, 64, 32,
1296 PATTERN_BLOCK1, PATTERN_BLOCK2,
1297 &__bpf_emit_jmp32_imm);
1298}
1299
1300static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
1301{
1302 return __bpf_fill_pattern(self, &op, 64, 64,
1303 PATTERN_BLOCK1, PATTERN_BLOCK2,
1304 &__bpf_emit_jmp_reg);
1305}
1306
1307static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
1308{
1309 return __bpf_fill_pattern(self, &op, 64, 64,
1310 PATTERN_BLOCK1, PATTERN_BLOCK2,
1311 &__bpf_emit_jmp32_reg);
1312}
1313
1314/* JMP immediate tests */
1315static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
1316{
1317 return __bpf_fill_jmp_imm(self, BPF_JSET);
1318}
1319
1320static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
1321{
1322 return __bpf_fill_jmp_imm(self, BPF_JEQ);
1323}
1324
1325static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
1326{
1327 return __bpf_fill_jmp_imm(self, BPF_JNE);
1328}
1329
1330static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
1331{
1332 return __bpf_fill_jmp_imm(self, BPF_JGT);
1333}
1334
1335static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
1336{
1337 return __bpf_fill_jmp_imm(self, BPF_JGE);
1338}
1339
1340static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
1341{
1342 return __bpf_fill_jmp_imm(self, BPF_JLT);
1343}
1344
1345static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
1346{
1347 return __bpf_fill_jmp_imm(self, BPF_JLE);
1348}
1349
1350static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
1351{
1352 return __bpf_fill_jmp_imm(self, BPF_JSGT);
1353}
1354
1355static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
1356{
1357 return __bpf_fill_jmp_imm(self, BPF_JSGE);
1358}
1359
1360static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
1361{
1362 return __bpf_fill_jmp_imm(self, BPF_JSLT);
1363}
1364
1365static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
1366{
1367 return __bpf_fill_jmp_imm(self, BPF_JSLE);
1368}
1369
1370/* JMP32 immediate tests */
1371static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
1372{
1373 return __bpf_fill_jmp32_imm(self, BPF_JSET);
1374}
1375
1376static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
1377{
1378 return __bpf_fill_jmp32_imm(self, BPF_JEQ);
1379}
1380
1381static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
1382{
1383 return __bpf_fill_jmp32_imm(self, BPF_JNE);
1384}
1385
1386static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
1387{
1388 return __bpf_fill_jmp32_imm(self, BPF_JGT);
1389}
1390
1391static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
1392{
1393 return __bpf_fill_jmp32_imm(self, BPF_JGE);
1394}
1395
1396static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
1397{
1398 return __bpf_fill_jmp32_imm(self, BPF_JLT);
1399}
1400
1401static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
1402{
1403 return __bpf_fill_jmp32_imm(self, BPF_JLE);
1404}
1405
1406static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
1407{
1408 return __bpf_fill_jmp32_imm(self, BPF_JSGT);
1409}
1410
1411static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
1412{
1413 return __bpf_fill_jmp32_imm(self, BPF_JSGE);
1414}
1415
1416static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
1417{
1418 return __bpf_fill_jmp32_imm(self, BPF_JSLT);
1419}
1420
1421static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
1422{
1423 return __bpf_fill_jmp32_imm(self, BPF_JSLE);
1424}
1425
1426/* JMP register tests */
1427static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
1428{
1429 return __bpf_fill_jmp_reg(self, BPF_JSET);
1430}
1431
1432static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
1433{
1434 return __bpf_fill_jmp_reg(self, BPF_JEQ);
1435}
1436
1437static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
1438{
1439 return __bpf_fill_jmp_reg(self, BPF_JNE);
1440}
1441
1442static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
1443{
1444 return __bpf_fill_jmp_reg(self, BPF_JGT);
1445}
1446
1447static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
1448{
1449 return __bpf_fill_jmp_reg(self, BPF_JGE);
1450}
1451
1452static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
1453{
1454 return __bpf_fill_jmp_reg(self, BPF_JLT);
1455}
1456
1457static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
1458{
1459 return __bpf_fill_jmp_reg(self, BPF_JLE);
1460}
1461
1462static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
1463{
1464 return __bpf_fill_jmp_reg(self, BPF_JSGT);
1465}
1466
1467static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
1468{
1469 return __bpf_fill_jmp_reg(self, BPF_JSGE);
1470}
1471
1472static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
1473{
1474 return __bpf_fill_jmp_reg(self, BPF_JSLT);
1475}
1476
1477static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
1478{
1479 return __bpf_fill_jmp_reg(self, BPF_JSLE);
1480}
1481
1482/* JMP32 register tests */
1483static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
1484{
1485 return __bpf_fill_jmp32_reg(self, BPF_JSET);
1486}
1487
1488static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
1489{
1490 return __bpf_fill_jmp32_reg(self, BPF_JEQ);
1491}
1492
1493static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
1494{
1495 return __bpf_fill_jmp32_reg(self, BPF_JNE);
1496}
1497
1498static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
1499{
1500 return __bpf_fill_jmp32_reg(self, BPF_JGT);
1501}
1502
1503static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
1504{
1505 return __bpf_fill_jmp32_reg(self, BPF_JGE);
1506}
1507
1508static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
1509{
1510 return __bpf_fill_jmp32_reg(self, BPF_JLT);
1511}
1512
1513static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
1514{
1515 return __bpf_fill_jmp32_reg(self, BPF_JLE);
1516}
1517
1518static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
1519{
1520 return __bpf_fill_jmp32_reg(self, BPF_JSGT);
1521}
1522
1523static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
1524{
1525 return __bpf_fill_jmp32_reg(self, BPF_JSGE);
1526}
1527
1528static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
1529{
1530 return __bpf_fill_jmp32_reg(self, BPF_JSLT);
1531}
1532
1533static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
1534{
1535 return __bpf_fill_jmp32_reg(self, BPF_JSLE);
1536}
1537
a7d2e752
JA		 1538/*
1539 * Set up a sequence of staggered jumps, forwards and backwards with
1540 * increasing offset. This tests the conversion of relative jumps to
1541 * JITed native jumps. On some architectures, for example MIPS, a large
1542 * PC-relative jump offset may overflow the immediate field of the native
1543 * conditional branch instruction, triggering a conversion to use an
1544 * absolute jump instead. Since this changes the jump offsets, another
1545 * offset computation pass is necessary, and that may in turn trigger
1546 * another branch conversion. This jump sequence is particularly nasty
1547 * in that regard.
1548 *
1549 * The sequence generation is parameterized by size and jump type.
1550 * The size must be even, and the expected result is always size + 1.
1551 * Below is an example with size=8 and result=9.
1552 *
1553 * ________________________Start
1554 * R0 = 0
1555 * R1 = r1
1556 * R2 = r2
1557 * ,------- JMP +4 * 3______________Preamble: 4 insns
1558 * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
1559 * | | R0 = 8 |
1560 * | | JMP +7 * 3 ------------------------.
1561 * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------. | |
1562 * | | | R0 = 6 | | |
1563 * | | | JMP +5 * 3 ------------------. | |
1564 * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------. | | | |
1565 * | | | | R0 = 4 | | | | |
1566 * | | | | JMP +3 * 3 ------------. | | | |
1567 * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--. | | | | | |
1568 * | | | | | R0 = 2 | | | | | | |
1569 * | | | | | JMP +1 * 3 ------. | | | | | |
1570 * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1 1 2 3 4 5 6 7 8 loc
1571 * | | | | | R0 = 1 -1 +2 -3 +4 -5 +6 -7 +8 off
1572 * | | | | | JMP -2 * 3 ---' | | | | | | |
1573 * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----' | | | | | |
1574 * | | | | | | R0 = 3 | | | | | |
1575 * | | | | | | JMP -4 * 3 ---------' | | | | |
1576 * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------' | | | |
1577 * | | | | | | | R0 = 5 | | | |
1578 * | | | | | | | JMP -6 * 3 ---------------' | | |
1579 * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------' | |
1580 * | | | | | | | | R0 = 7 | |
1581 * | | Error | | | JMP -8 * 3 ---------------------' |
1582 * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
1583 * | | | | | | | | | R0 = 9__________________Sequence: 3 * size - 1 insns
1584 * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
1585 *
1586 */
1587
1588/* The maximum size parameter */
1589#define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
1590
1591/* We use a reduced number of iterations to get a reasonable execution time */
1592#define NR_STAGGERED_JMP_RUNS 10
1593
1594static int __bpf_fill_staggered_jumps(struct bpf_test *self,
1595 const struct bpf_insn *jmp,
1596 u64 r1, u64 r2)
1597{
1598 int size = self->test[0].result - 1;
1599 int len = 4 + 3 * (size + 1);
1600 struct bpf_insn *insns;
1601 int off, ind;
1602
1603 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1604 if (!insns)
1605 return -ENOMEM;
1606
1607 /* Preamble */
1608 insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
1609 insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
1610 insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
1611 insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
1612
1613 /* Sequence */
1614 for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
1615 struct bpf_insn *ins = &insns[4 + 3 * ind];
1616 int loc;
1617
1618 if (off == 0)
1619 off--;
1620
1621 loc = abs(off);
1622 ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
1623 3 * (size - ind) + 1);
1624 ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
1625 ins[2] = *jmp;
1626 ins[2].off = 3 * (off - 1);
1627 }
1628
1629 /* Return */
1630 insns[len - 1] = BPF_EXIT_INSN();
1631
1632 self->u.ptr.insns = insns;
1633 self->u.ptr.len = len;
1634
1635 return 0;
1636}
1637
1638/* 64-bit unconditional jump */
1639static int bpf_fill_staggered_ja(struct bpf_test *self)
1640{
1641 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
1642
1643 return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
1644}
1645
1646/* 64-bit immediate jumps */
1647static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
1648{
1649 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
1650
1651 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1652}
1653
1654static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
1655{
1656 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
1657
1658 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
1659}
1660
1661static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
1662{
1663 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
1664
1665 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
1666}
1667
1668static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
1669{
1670 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
1671
1672 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
1673}
1674
1675static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
1676{
1677 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
1678
1679 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1680}
1681
1682static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
1683{
1684 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
1685
1686 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1687}
1688
1689static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
1690{
1691 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
1692
1693 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1694}
1695
1696static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
1697{
1698 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
1699
1700 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
1701}
1702
1703static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
1704{
1705 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
1706
1707 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
1708}
1709
1710static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
1711{
1712 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
1713
1714 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
1715}
1716
1717static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
1718{
1719 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
1720
1721 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
1722}
1723
1724/* 64-bit register jumps */
1725static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
1726{
1727 struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
1728
1729 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
1730}
1731
1732static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
1733{
1734 struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
1735
1736 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
1737}
1738
1739static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
1740{
1741 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
1742
1743 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
1744}
1745
1746static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
1747{
1748 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
1749
1750 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
1751}
1752
1753static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
1754{
1755 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
1756
1757 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
1758}
1759
1760static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
1761{
1762 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
1763
1764 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
1765}
1766
1767static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
1768{
1769 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
1770
1771 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
1772}
1773
1774static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
1775{
1776 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
1777
1778 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
1779}
1780
1781static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
1782{
1783 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
1784
1785 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
1786}
1787
1788static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
1789{
1790 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
1791
1792 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
1793}
1794
1795static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
1796{
1797 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
1798
1799 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
1800}
1801
1802/* 32-bit immediate jumps */
1803static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
1804{
1805 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
1806
1807 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1808}
1809
1810static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
1811{
1812 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
1813
1814 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
1815}
1816
1817static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
1818{
1819 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
1820
1821 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
1822}
1823
1824static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
1825{
1826 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
1827
1828 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
1829}
1830
1831static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
1832{
1833 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
1834
1835 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1836}
1837
1838static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
1839{
1840 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
1841
1842 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1843}
1844
1845static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
1846{
1847 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
1848
1849 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1850}
1851
1852static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
1853{
1854 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
1855
1856 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
1857}
1858
1859static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
1860{
1861 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
1862
1863 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
1864}
1865
1866static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
1867{
1868 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
1869
1870 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
1871}
1872
1873static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
1874{
1875 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
1876
1877 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
1878}
1879
1880/* 32-bit register jumps */
1881static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
1882{
1883 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
1884
1885 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
1886}
1887
1888static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
1889{
1890 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
1891
1892 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
1893}
1894
1895static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
1896{
1897 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
1898
1899 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
1900}
1901
1902static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
1903{
1904 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
1905
1906 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
1907}
1908
1909static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
1910{
1911 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
1912
1913 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
1914}
1915
1916static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
1917{
1918 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
1919
1920 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
1921}
1922
1923static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
1924{
1925 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
1926
1927 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
1928}
1929
1930static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
1931{
1932 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
1933
1934 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
1935}
1936
1937static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
1938{
1939 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
1940
1941 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
1942}
1943
1944static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
1945{
1946 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
1947
1948 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
1949}
1950
1951static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
1952{
1953 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
1954
1955 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
1956}
1957
a5a36544 1958
64a8946b
AS		 1959static struct bpf_test tests[] = {
1960 {
1961 "TAX",
ece80490 1962 .u.insns = {
64a8946b
AS		 1963 BPF_STMT(BPF_LD | BPF_IMM, 1),
1964 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1965 BPF_STMT(BPF_LD | BPF_IMM, 2),
1966 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
1967 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
1968 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1969 BPF_STMT(BPF_LD | BPF_LEN, 0),
1970 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
1971 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
1972 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
1973 BPF_STMT(BPF_RET | BPF_A, 0)
1974 },
10f18e0b 1975 CLASSIC,
64a8946b
AS		 1976 { 10, 20, 30, 40, 50 },
1977 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
1978 },
9def624a
AS		 1979 {
1980 "TXA",
ece80490 1981 .u.insns = {
9def624a
AS		 1982 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1983 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1984 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
1985 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
1986 },
10f18e0b 1987 CLASSIC,
9def624a
AS		 1988 { 10, 20, 30, 40, 50 },
1989 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
1990 },
1991 {
1992 "ADD_SUB_MUL_K",
ece80490 1993 .u.insns = {
9def624a
AS		 1994 BPF_STMT(BPF_LD | BPF_IMM, 1),
1995 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
1996 BPF_STMT(BPF_LDX | BPF_IMM, 3),
1997 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
1998 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
1999 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
2000 BPF_STMT(BPF_RET | BPF_A, 0)
2001 },
10f18e0b 2002 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 2003 { },
2004 { { 0, 0xfffffffd } }
2005 },
2006 {
6867b17b 2007 "DIV_MOD_KX",
ece80490 2008 .u.insns = {
9def624a
AS		 2009 BPF_STMT(BPF_LD | BPF_IMM, 8),
2010 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
2011 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2012 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2013 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
2014 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2015 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2016 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
6867b17b
DK		 2017 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2018 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2019 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
2020 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2021 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2022 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
9def624a
AS		 2023 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2024 BPF_STMT(BPF_RET | BPF_A, 0)
2025 },
10f18e0b 2026 CLASSIC | FLAG_NO_DATA,
9def624a 2027 { },
6867b17b 2028 { { 0, 0x20000000 } }
9def624a
AS		 2029 },
2030 {
2031 "AND_OR_LSH_K",
ece80490 2032 .u.insns = {
9def624a
AS		 2033 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
2034 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
2035 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
2036 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2037 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
2038 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
2039 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2040 BPF_STMT(BPF_RET | BPF_A, 0)
2041 },
10f18e0b 2042 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 2043 { },
2044 { { 0, 0x800000ff }, { 1, 0x800000ff } },
2045 },
e9d94504
CG		 2046 {
2047 "LD_IMM_0",
2048 .u.insns = {
2049 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
2050 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
2051 BPF_STMT(BPF_RET | BPF_K, 0),
2052 BPF_STMT(BPF_RET | BPF_K, 1),
2053 },
2054 CLASSIC,
2055 { },
2056 { { 1, 1 } },
2057 },
9def624a
AS		 2058 {
2059 "LD_IND",
ece80490 2060 .u.insns = {
9def624a
AS		 2061 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2062 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
2063 BPF_STMT(BPF_RET | BPF_K, 1)
2064 },
10f18e0b 2065 CLASSIC,
9def624a
AS		 2066 { },
2067 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
2068 },
2069 {
2070 "LD_ABS",
ece80490 2071 .u.insns = {
9def624a
AS		 2072 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
2073 BPF_STMT(BPF_RET | BPF_K, 1)
2074 },
10f18e0b 2075 CLASSIC,
9def624a
AS		 2076 { },
2077 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
2078 },
2079 {
2080 "LD_ABS_LL",
ece80490 2081 .u.insns = {
9def624a
AS		 2082 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
2083 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2084 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
2085 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2086 BPF_STMT(BPF_RET | BPF_A, 0)
2087 },
10f18e0b 2088 CLASSIC,
9def624a
AS		 2089 { 1, 2, 3 },
2090 { { 1, 0 }, { 2, 3 } },
2091 },
2092 {
2093 "LD_IND_LL",
ece80490 2094 .u.insns = {
9def624a
AS		 2095 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
2096 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2097 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2098 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2099 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
2100 BPF_STMT(BPF_RET | BPF_A, 0)
2101 },
10f18e0b 2102 CLASSIC,
9def624a
AS		 2103 { 1, 2, 3, 0xff },
2104 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
2105 },
2106 {
2107 "LD_ABS_NET",
ece80490 2108 .u.insns = {
9def624a
AS		 2109 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
2110 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2111 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
2112 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2113 BPF_STMT(BPF_RET | BPF_A, 0)
2114 },
10f18e0b 2115 CLASSIC,
9def624a
AS		 2116 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
2117 { { 15, 0 }, { 16, 3 } },
2118 },
2119 {
2120 "LD_IND_NET",
ece80490 2121 .u.insns = {
9def624a
AS		 2122 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
2123 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2124 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2125 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2126 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
2127 BPF_STMT(BPF_RET | BPF_A, 0)
2128 },
10f18e0b 2129 CLASSIC,
9def624a
AS		 2130 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
2131 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
2132 },
2133 {
2134 "LD_PKTTYPE",
ece80490 2135 .u.insns = {
9def624a
AS		 2136 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2137 SKF_AD_OFF + SKF_AD_PKTTYPE),
2138 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2139 BPF_STMT(BPF_RET | BPF_K, 1),
2140 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2141 SKF_AD_OFF + SKF_AD_PKTTYPE),
2142 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2143 BPF_STMT(BPF_RET | BPF_K, 1),
2144 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2145 SKF_AD_OFF + SKF_AD_PKTTYPE),
2146 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2147 BPF_STMT(BPF_RET | BPF_K, 1),
2148 BPF_STMT(BPF_RET | BPF_A, 0)
2149 },
10f18e0b 2150 CLASSIC,
9def624a
AS		 2151 { },
2152 { { 1, 3 }, { 10, 3 } },
2153 },
2154 {
2155 "LD_MARK",
ece80490 2156 .u.insns = {
9def624a
AS		 2157 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2158 SKF_AD_OFF + SKF_AD_MARK),
2159 BPF_STMT(BPF_RET | BPF_A, 0)
2160 },
10f18e0b 2161 CLASSIC,
9def624a
AS		 2162 { },
2163 { { 1, SKB_MARK}, { 10, SKB_MARK} },
2164 },
2165 {
2166 "LD_RXHASH",
ece80490 2167 .u.insns = {
9def624a
AS		 2168 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2169 SKF_AD_OFF + SKF_AD_RXHASH),
2170 BPF_STMT(BPF_RET | BPF_A, 0)
2171 },
10f18e0b 2172 CLASSIC,
9def624a
AS		 2173 { },
2174 { { 1, SKB_HASH}, { 10, SKB_HASH} },
2175 },
2176 {
2177 "LD_QUEUE",
ece80490 2178 .u.insns = {
9def624a
AS		 2179 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2180 SKF_AD_OFF + SKF_AD_QUEUE),
2181 BPF_STMT(BPF_RET | BPF_A, 0)
2182 },
10f18e0b 2183 CLASSIC,
9def624a
AS		 2184 { },
2185 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
2186 },
2187 {
2188 "LD_PROTOCOL",
ece80490 2189 .u.insns = {
9def624a
AS		 2190 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
2191 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
2192 BPF_STMT(BPF_RET | BPF_K, 0),
2193 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2194 SKF_AD_OFF + SKF_AD_PROTOCOL),
2195 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2196 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2197 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
2198 BPF_STMT(BPF_RET | BPF_K, 0),
2199 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2200 BPF_STMT(BPF_RET | BPF_A, 0)
2201 },
10f18e0b 2202 CLASSIC,
9def624a
AS		 2203 { 10, 20, 30 },
2204 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
2205 },
2206 {
2207 "LD_VLAN_TAG",
ece80490 2208 .u.insns = {
9def624a
AS		 2209 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2210 SKF_AD_OFF + SKF_AD_VLAN_TAG),
2211 BPF_STMT(BPF_RET | BPF_A, 0)
2212 },
10f18e0b 2213 CLASSIC,
9def624a
AS		 2214 { },
2215 {
0c4b2d37
MM		 2216 { 1, SKB_VLAN_TCI },
2217 { 10, SKB_VLAN_TCI }
9def624a
AS		 2218 },
2219 },
2220 {
2221 "LD_VLAN_TAG_PRESENT",
ece80490 2222 .u.insns = {
9def624a
AS		 2223 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2224 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
2225 BPF_STMT(BPF_RET | BPF_A, 0)
2226 },
10f18e0b 2227 CLASSIC,
9def624a
AS		 2228 { },
2229 {
0c4b2d37
MM		 2230 { 1, SKB_VLAN_PRESENT },
2231 { 10, SKB_VLAN_PRESENT }
9def624a
AS		 2232 },
2233 },
2234 {
2235 "LD_IFINDEX",
ece80490 2236 .u.insns = {
9def624a
AS		 2237 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2238 SKF_AD_OFF + SKF_AD_IFINDEX),
2239 BPF_STMT(BPF_RET | BPF_A, 0)
2240 },
10f18e0b 2241 CLASSIC,
9def624a
AS		 2242 { },
2243 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
2244 },
2245 {
2246 "LD_HATYPE",
ece80490 2247 .u.insns = {
9def624a
AS		 2248 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2249 SKF_AD_OFF + SKF_AD_HATYPE),
2250 BPF_STMT(BPF_RET | BPF_A, 0)
2251 },
10f18e0b 2252 CLASSIC,
9def624a
AS		 2253 { },
2254 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
2255 },
2256 {
2257 "LD_CPU",
ece80490 2258 .u.insns = {
9def624a
AS		 2259 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2260 SKF_AD_OFF + SKF_AD_CPU),
2261 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2262 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2263 SKF_AD_OFF + SKF_AD_CPU),
2264 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
2265 BPF_STMT(BPF_RET | BPF_A, 0)
2266 },
10f18e0b 2267 CLASSIC,
9def624a
AS		 2268 { },
2269 { { 1, 0 }, { 10, 0 } },
2270 },
2271 {
2272 "LD_NLATTR",
ece80490 2273 .u.insns = {
df6d0f98 2274 BPF_STMT(BPF_LDX | BPF_IMM, 2),
9def624a
AS		 2275 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2276 BPF_STMT(BPF_LDX | BPF_IMM, 3),
2277 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2278 SKF_AD_OFF + SKF_AD_NLATTR),
2279 BPF_STMT(BPF_RET | BPF_A, 0)
2280 },
10f18e0b 2281 CLASSIC,
df6d0f98
AS		 2282#ifdef __BIG_ENDIAN
2283 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
2284#else
2285 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
2286#endif
2287 { { 4, 0 }, { 20, 6 } },
9def624a
AS		 2288 },
2289 {
2290 "LD_NLATTR_NEST",
ece80490 2291 .u.insns = {
df6d0f98 2292 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2293 BPF_STMT(BPF_LDX | BPF_IMM, 3),
2294 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2295 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2296 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2297 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2298 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2299 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2300 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2301 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2302 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2303 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2304 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2305 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2306 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2307 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2308 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2309 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2310 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2311 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2312 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2313 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2314 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2315 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2316 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2317 BPF_STMT(BPF_RET | BPF_A, 0)
2318 },
10f18e0b 2319 CLASSIC,
df6d0f98
AS		 2320#ifdef __BIG_ENDIAN
2321 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
2322#else
2323 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
2324#endif
2325 { { 4, 0 }, { 20, 10 } },
9def624a
AS		 2326 },
2327 {
2328 "LD_PAYLOAD_OFF",
ece80490 2329 .u.insns = {
9def624a
AS		 2330 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2331 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2332 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2333 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2334 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2335 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2336 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2337 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2338 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2339 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2340 BPF_STMT(BPF_RET | BPF_A, 0)
2341 },
10f18e0b 2342 CLASSIC,
9def624a
AS		 2343 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
2344 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
2345 * id 9737, seq 1, length 64
2346 */
2347 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2348 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2349 0x08, 0x00,
2350 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
2351 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
2352 { { 30, 0 }, { 100, 42 } },
2353 },
2354 {
2355 "LD_ANC_XOR",
ece80490 2356 .u.insns = {
9def624a
AS		 2357 BPF_STMT(BPF_LD | BPF_IMM, 10),
2358 BPF_STMT(BPF_LDX | BPF_IMM, 300),
2359 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2360 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
2361 BPF_STMT(BPF_RET | BPF_A, 0)
2362 },
10f18e0b 2363 CLASSIC,
9def624a 2364 { },
09845436 2365 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
9def624a
AS		 2366 },
2367 {
2368 "SPILL_FILL",
ece80490 2369 .u.insns = {
9def624a
AS		 2370 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2371 BPF_STMT(BPF_LD | BPF_IMM, 2),
2372 BPF_STMT(BPF_ALU | BPF_RSH, 1),
2373 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2374 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
2375 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
2376 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
2377 BPF_STMT(BPF_STX, 15), /* M3 = len */
2378 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2379 BPF_STMT(BPF_LD | BPF_MEM, 2),
2380 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2381 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2382 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2383 BPF_STMT(BPF_RET | BPF_A, 0)
2384 },
10f18e0b 2385 CLASSIC,
9def624a
AS		 2386 { },
2387 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
2388 },
2389 {
2390 "JEQ",
ece80490 2391 .u.insns = {
9def624a
AS		 2392 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2393 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2394 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
2395 BPF_STMT(BPF_RET | BPF_K, 1),
2396 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2397 },
10f18e0b 2398 CLASSIC,
9def624a
AS		 2399 { 3, 3, 3, 3, 3 },
2400 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
2401 },
2402 {
2403 "JGT",
ece80490 2404 .u.insns = {
9def624a
AS		 2405 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2406 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2407 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
2408 BPF_STMT(BPF_RET | BPF_K, 1),
2409 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2410 },
10f18e0b 2411 CLASSIC,
9def624a
AS		 2412 { 4, 4, 4, 3, 3 },
2413 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
2414 },
92b31a9a
DB		 2415 {
2416 "JGE (jt 0), test 1",
2417 .u.insns = {
2418 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2419 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2420 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
2421 BPF_STMT(BPF_RET | BPF_K, 1),
2422 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2423 },
2424 CLASSIC,
2425 { 4, 4, 4, 3, 3 },
2426 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
2427 },
2428 {
2429 "JGE (jt 0), test 2",
2430 .u.insns = {
2431 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2432 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2433 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
2434 BPF_STMT(BPF_RET | BPF_K, 1),
2435 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2436 },
2437 CLASSIC,
2438 { 4, 4, 5, 3, 3 },
2439 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
2440 },
9def624a
AS		 2441 {
2442 "JGE",
ece80490 2443 .u.insns = {
9def624a
AS		 2444 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2445 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
2446 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
2447 BPF_STMT(BPF_RET | BPF_K, 10),
2448 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
2449 BPF_STMT(BPF_RET | BPF_K, 20),
2450 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
2451 BPF_STMT(BPF_RET | BPF_K, 30),
2452 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
2453 BPF_STMT(BPF_RET | BPF_K, 40),
2454 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2455 },
10f18e0b 2456 CLASSIC,
9def624a
AS		 2457 { 1, 2, 3, 4, 5 },
2458 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
2459 },
2460 {
2461 "JSET",
ece80490 2462 .u.insns = {
9def624a
AS		 2463 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2464 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
2465 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2466 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2467 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2468 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2469 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
2470 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2471 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
2472 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
2473 BPF_STMT(BPF_RET | BPF_K, 10),
2474 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
2475 BPF_STMT(BPF_RET | BPF_K, 20),
2476 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2477 BPF_STMT(BPF_RET | BPF_K, 30),
2478 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2479 BPF_STMT(BPF_RET | BPF_K, 30),
2480 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2481 BPF_STMT(BPF_RET | BPF_K, 30),
2482 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2483 BPF_STMT(BPF_RET | BPF_K, 30),
2484 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2485 BPF_STMT(BPF_RET | BPF_K, 30),
2486 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2487 },
10f18e0b 2488 CLASSIC,
9def624a
AS		 2489 { 0, 0xAA, 0x55, 1 },
2490 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
2491 },
64a8946b
AS		 2492 {
2493 "tcpdump port 22",
ece80490 2494 .u.insns = {
ce25b68b
DB		 2495 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
2496 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
2497 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
2498 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
2499 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
2500 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
2501 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
2502 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
2503 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
2504 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
2505 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
2506 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
2507 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
2508 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
2509 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
2510 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
2511 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
2512 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2513 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
2514 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
2515 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
2516 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
2517 BPF_STMT(BPF_RET | BPF_K, 0xffff),
2518 BPF_STMT(BPF_RET | BPF_K, 0),
64a8946b 2519 },
10f18e0b 2520 CLASSIC,
64a8946b
AS		 2521 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
2522 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
2523 * seq 1305692979:1305693027, ack 3650467037, win 65535,
2524 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
2525 */
2526 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
2527 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
2528 0x08, 0x00,
2529 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
2530 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
2531 0x0a, 0x01, 0x01, 0x95, /* ip src */
2532 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
2533 0xc2, 0x24,
2534 0x00, 0x16 /* dst port */ },
2535 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
2536 },
9def624a
AS		 2537 {
2538 "tcpdump complex",
ece80490 2539 .u.insns = {
9def624a
AS		 2540 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
2541 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
2542 * (len > 115 or len < 30000000000)' -d
2543 */
ce25b68b
DB		 2544 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
2545 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
2546 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
2547 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
2548 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
2549 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
2550 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
2551 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2552 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
2553 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
2554 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
2555 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
2556 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
2557 BPF_STMT(BPF_ST, 1),
2558 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
2559 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
2560 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
2561 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
2562 BPF_STMT(BPF_LD | BPF_MEM, 1),
2563 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
2564 BPF_STMT(BPF_ST, 5),
2565 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2566 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
2567 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
2568 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
2569 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
2570 BPF_STMT(BPF_LD | BPF_MEM, 5),
2571 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
2572 BPF_STMT(BPF_LD | BPF_LEN, 0),
2573 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
2574 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
2575 BPF_STMT(BPF_RET | BPF_K, 0xffff),
2576 BPF_STMT(BPF_RET | BPF_K, 0),
9def624a 2577 },
10f18e0b 2578 CLASSIC,
9def624a
AS		 2579 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
2580 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
2581 0x08, 0x00,
2582 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
2583 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
2584 0x0a, 0x01, 0x01, 0x95, /* ip src */
2585 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
2586 0xc2, 0x24,
2587 0x00, 0x16 /* dst port */ },
2588 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
2589 },
2590 {
2591 "RET_A",
ece80490 2592 .u.insns = {
53b0fe36 2593 /* check that uninitialized X and A contain zeros */
9def624a
AS		 2594 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2595 BPF_STMT(BPF_RET | BPF_A, 0)
2596 },
10f18e0b
DB		 2597 CLASSIC,
2598 { },
9def624a
AS		 2599 { {1, 0}, {2, 0} },
2600 },
2601 {
2602 "INT: ADD trivial",
ece80490 2603 .u.insns_int = {
9def624a
AS		 2604 BPF_ALU64_IMM(BPF_MOV, R1, 1),
2605 BPF_ALU64_IMM(BPF_ADD, R1, 2),
2606 BPF_ALU64_IMM(BPF_MOV, R2, 3),
2607 BPF_ALU64_REG(BPF_SUB, R1, R2),
2608 BPF_ALU64_IMM(BPF_ADD, R1, -1),
2609 BPF_ALU64_IMM(BPF_MUL, R1, 3),
2610 BPF_ALU64_REG(BPF_MOV, R0, R1),
2611 BPF_EXIT_INSN(),
2612 },
10f18e0b 2613 INTERNAL,
9def624a
AS		 2614 { },
2615 { { 0, 0xfffffffd } }
2616 },
2617 {
2618 "INT: MUL_X",
ece80490 2619 .u.insns_int = {
9def624a
AS		 2620 BPF_ALU64_IMM(BPF_MOV, R0, -1),
2621 BPF_ALU64_IMM(BPF_MOV, R1, -1),
2622 BPF_ALU64_IMM(BPF_MOV, R2, 3),
2623 BPF_ALU64_REG(BPF_MUL, R1, R2),
2624 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
2625 BPF_EXIT_INSN(),
2626 BPF_ALU64_IMM(BPF_MOV, R0, 1),
2627 BPF_EXIT_INSN(),
2628 },
10f18e0b 2629 INTERNAL,
9def624a
AS		 2630 { },
2631 { { 0, 1 } }
2632 },
2633 {
2634 "INT: MUL_X2",
ece80490 2635 .u.insns_int = {
9def624a
AS		 2636 BPF_ALU32_IMM(BPF_MOV, R0, -1),
2637 BPF_ALU32_IMM(BPF_MOV, R1, -1),
2638 BPF_ALU32_IMM(BPF_MOV, R2, 3),
2639 BPF_ALU64_REG(BPF_MUL, R1, R2),
2640 BPF_ALU64_IMM(BPF_RSH, R1, 8),
2641 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
2642 BPF_EXIT_INSN(),
2643 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2644 BPF_EXIT_INSN(),
2645 },
10f18e0b 2646 INTERNAL,
9def624a
AS		 2647 { },
2648 { { 0, 1 } }
2649 },
2650 {
2651 "INT: MUL32_X",
ece80490 2652 .u.insns_int = {
9def624a
AS		 2653 BPF_ALU32_IMM(BPF_MOV, R0, -1),
2654 BPF_ALU64_IMM(BPF_MOV, R1, -1),
2655 BPF_ALU32_IMM(BPF_MOV, R2, 3),
2656 BPF_ALU32_REG(BPF_MUL, R1, R2),
2657 BPF_ALU64_IMM(BPF_RSH, R1, 8),
2658 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
2659 BPF_EXIT_INSN(),
2660 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2661 BPF_EXIT_INSN(),
2662 },
10f18e0b 2663 INTERNAL,
9def624a
AS		 2664 { },
2665 { { 0, 1 } }
2666 },
2667 {
2668 /* Have to test all register combinations, since
2669 * JITing of different registers will produce
2670 * different asm code.
2671 */
2672 "INT: ADD 64-bit",
ece80490 2673 .u.insns_int = {
9def624a
AS		 2674 BPF_ALU64_IMM(BPF_MOV, R0, 0),
2675 BPF_ALU64_IMM(BPF_MOV, R1, 1),
2676 BPF_ALU64_IMM(BPF_MOV, R2, 2),
2677 BPF_ALU64_IMM(BPF_MOV, R3, 3),
2678 BPF_ALU64_IMM(BPF_MOV, R4, 4),
2679 BPF_ALU64_IMM(BPF_MOV, R5, 5),
2680 BPF_ALU64_IMM(BPF_MOV, R6, 6),
2681 BPF_ALU64_IMM(BPF_MOV, R7, 7),
2682 BPF_ALU64_IMM(BPF_MOV, R8, 8),
2683 BPF_ALU64_IMM(BPF_MOV, R9, 9),
2684 BPF_ALU64_IMM(BPF_ADD, R0, 20),
2685 BPF_ALU64_IMM(BPF_ADD, R1, 20),
2686 BPF_ALU64_IMM(BPF_ADD, R2, 20),
2687 BPF_ALU64_IMM(BPF_ADD, R3, 20),
2688 BPF_ALU64_IMM(BPF_ADD, R4, 20),
2689 BPF_ALU64_IMM(BPF_ADD, R5, 20),
2690 BPF_ALU64_IMM(BPF_ADD, R6, 20),
2691 BPF_ALU64_IMM(BPF_ADD, R7, 20),
2692 BPF_ALU64_IMM(BPF_ADD, R8, 20),
2693 BPF_ALU64_IMM(BPF_ADD, R9, 20),
2694 BPF_ALU64_IMM(BPF_SUB, R0, 10),
2695 BPF_ALU64_IMM(BPF_SUB, R1, 10),
2696 BPF_ALU64_IMM(BPF_SUB, R2, 10),
2697 BPF_ALU64_IMM(BPF_SUB, R3, 10),
2698 BPF_ALU64_IMM(BPF_SUB, R4, 10),
2699 BPF_ALU64_IMM(BPF_SUB, R5, 10),
2700 BPF_ALU64_IMM(BPF_SUB, R6, 10),
2701 BPF_ALU64_IMM(BPF_SUB, R7, 10),
2702 BPF_ALU64_IMM(BPF_SUB, R8, 10),
2703 BPF_ALU64_IMM(BPF_SUB, R9, 10),
2704 BPF_ALU64_REG(BPF_ADD, R0, R0),
2705 BPF_ALU64_REG(BPF_ADD, R0, R1),
2706 BPF_ALU64_REG(BPF_ADD, R0, R2),
2707 BPF_ALU64_REG(BPF_ADD, R0, R3),
2708 BPF_ALU64_REG(BPF_ADD, R0, R4),
2709 BPF_ALU64_REG(BPF_ADD, R0, R5),
2710 BPF_ALU64_REG(BPF_ADD, R0, R6),
2711 BPF_ALU64_REG(BPF_ADD, R0, R7),
2712 BPF_ALU64_REG(BPF_ADD, R0, R8),
2713 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
2714 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
2715 BPF_EXIT_INSN(),
2716 BPF_ALU64_REG(BPF_ADD, R1, R0),
2717 BPF_ALU64_REG(BPF_ADD, R1, R1),
2718 BPF_ALU64_REG(BPF_ADD, R1, R2),
2719 BPF_ALU64_REG(BPF_ADD, R1, R3),
2720 BPF_ALU64_REG(BPF_ADD, R1, R4),
2721 BPF_ALU64_REG(BPF_ADD, R1, R5),
2722 BPF_ALU64_REG(BPF_ADD, R1, R6),
2723 BPF_ALU64_REG(BPF_ADD, R1, R7),
2724 BPF_ALU64_REG(BPF_ADD, R1, R8),
2725 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
2726 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
2727 BPF_EXIT_INSN(),
2728 BPF_ALU64_REG(BPF_ADD, R2, R0),
2729 BPF_ALU64_REG(BPF_ADD, R2, R1),
2730 BPF_ALU64_REG(BPF_ADD, R2, R2),
2731 BPF_ALU64_REG(BPF_ADD, R2, R3),
2732 BPF_ALU64_REG(BPF_ADD, R2, R4),
2733 BPF_ALU64_REG(BPF_ADD, R2, R5),
2734 BPF_ALU64_REG(BPF_ADD, R2, R6),
2735 BPF_ALU64_REG(BPF_ADD, R2, R7),
2736 BPF_ALU64_REG(BPF_ADD, R2, R8),
2737 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
2738 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
2739 BPF_EXIT_INSN(),
2740 BPF_ALU64_REG(BPF_ADD, R3, R0),
2741 BPF_ALU64_REG(BPF_ADD, R3, R1),
2742 BPF_ALU64_REG(BPF_ADD, R3, R2),
2743 BPF_ALU64_REG(BPF_ADD, R3, R3),
2744 BPF_ALU64_REG(BPF_ADD, R3, R4),
2745 BPF_ALU64_REG(BPF_ADD, R3, R5),
2746 BPF_ALU64_REG(BPF_ADD, R3, R6),
2747 BPF_ALU64_REG(BPF_ADD, R3, R7),
2748 BPF_ALU64_REG(BPF_ADD, R3, R8),
2749 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
2750 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
2751 BPF_EXIT_INSN(),
2752 BPF_ALU64_REG(BPF_ADD, R4, R0),
2753 BPF_ALU64_REG(BPF_ADD, R4, R1),
2754 BPF_ALU64_REG(BPF_ADD, R4, R2),
2755 BPF_ALU64_REG(BPF_ADD, R4, R3),
2756 BPF_ALU64_REG(BPF_ADD, R4, R4),
2757 BPF_ALU64_REG(BPF_ADD, R4, R5),
2758 BPF_ALU64_REG(BPF_ADD, R4, R6),
2759 BPF_ALU64_REG(BPF_ADD, R4, R7),
2760 BPF_ALU64_REG(BPF_ADD, R4, R8),
2761 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
2762 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
2763 BPF_EXIT_INSN(),
2764 BPF_ALU64_REG(BPF_ADD, R5, R0),
2765 BPF_ALU64_REG(BPF_ADD, R5, R1),
2766 BPF_ALU64_REG(BPF_ADD, R5, R2),
2767 BPF_ALU64_REG(BPF_ADD, R5, R3),
2768 BPF_ALU64_REG(BPF_ADD, R5, R4),
2769 BPF_ALU64_REG(BPF_ADD, R5, R5),
2770 BPF_ALU64_REG(BPF_ADD, R5, R6),
2771 BPF_ALU64_REG(BPF_ADD, R5, R7),
2772 BPF_ALU64_REG(BPF_ADD, R5, R8),
2773 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
2774 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
2775 BPF_EXIT_INSN(),
2776 BPF_ALU64_REG(BPF_ADD, R6, R0),
2777 BPF_ALU64_REG(BPF_ADD, R6, R1),
2778 BPF_ALU64_REG(BPF_ADD, R6, R2),
2779 BPF_ALU64_REG(BPF_ADD, R6, R3),
2780 BPF_ALU64_REG(BPF_ADD, R6, R4),
2781 BPF_ALU64_REG(BPF_ADD, R6, R5),
2782 BPF_ALU64_REG(BPF_ADD, R6, R6),
2783 BPF_ALU64_REG(BPF_ADD, R6, R7),
2784 BPF_ALU64_REG(BPF_ADD, R6, R8),
2785 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
2786 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
2787 BPF_EXIT_INSN(),
2788 BPF_ALU64_REG(BPF_ADD, R7, R0),
2789 BPF_ALU64_REG(BPF_ADD, R7, R1),
2790 BPF_ALU64_REG(BPF_ADD, R7, R2),
2791 BPF_ALU64_REG(BPF_ADD, R7, R3),
2792 BPF_ALU64_REG(BPF_ADD, R7, R4),
2793 BPF_ALU64_REG(BPF_ADD, R7, R5),
2794 BPF_ALU64_REG(BPF_ADD, R7, R6),
2795 BPF_ALU64_REG(BPF_ADD, R7, R7),
2796 BPF_ALU64_REG(BPF_ADD, R7, R8),
2797 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
2798 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
2799 BPF_EXIT_INSN(),
2800 BPF_ALU64_REG(BPF_ADD, R8, R0),
2801 BPF_ALU64_REG(BPF_ADD, R8, R1),
2802 BPF_ALU64_REG(BPF_ADD, R8, R2),
2803 BPF_ALU64_REG(BPF_ADD, R8, R3),
2804 BPF_ALU64_REG(BPF_ADD, R8, R4),
2805 BPF_ALU64_REG(BPF_ADD, R8, R5),
2806 BPF_ALU64_REG(BPF_ADD, R8, R6),
2807 BPF_ALU64_REG(BPF_ADD, R8, R7),
2808 BPF_ALU64_REG(BPF_ADD, R8, R8),
2809 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
2810 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
2811 BPF_EXIT_INSN(),
2812 BPF_ALU64_REG(BPF_ADD, R9, R0),
2813 BPF_ALU64_REG(BPF_ADD, R9, R1),
2814 BPF_ALU64_REG(BPF_ADD, R9, R2),
2815 BPF_ALU64_REG(BPF_ADD, R9, R3),
2816 BPF_ALU64_REG(BPF_ADD, R9, R4),
2817 BPF_ALU64_REG(BPF_ADD, R9, R5),
2818 BPF_ALU64_REG(BPF_ADD, R9, R6),
2819 BPF_ALU64_REG(BPF_ADD, R9, R7),
2820 BPF_ALU64_REG(BPF_ADD, R9, R8),
2821 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
2822 BPF_ALU64_REG(BPF_MOV, R0, R9),
2823 BPF_EXIT_INSN(),
2824 },
10f18e0b 2825 INTERNAL,
9def624a
AS		 2826 { },
2827 { { 0, 2957380 } }
2828 },
2829 {
2830 "INT: ADD 32-bit",
ece80490 2831 .u.insns_int = {
9def624a
AS		 2832 BPF_ALU32_IMM(BPF_MOV, R0, 20),
2833 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2834 BPF_ALU32_IMM(BPF_MOV, R2, 2),
2835 BPF_ALU32_IMM(BPF_MOV, R3, 3),
2836 BPF_ALU32_IMM(BPF_MOV, R4, 4),
2837 BPF_ALU32_IMM(BPF_MOV, R5, 5),
2838 BPF_ALU32_IMM(BPF_MOV, R6, 6),
2839 BPF_ALU32_IMM(BPF_MOV, R7, 7),
2840 BPF_ALU32_IMM(BPF_MOV, R8, 8),
2841 BPF_ALU32_IMM(BPF_MOV, R9, 9),
2842 BPF_ALU64_IMM(BPF_ADD, R1, 10),
2843 BPF_ALU64_IMM(BPF_ADD, R2, 10),
2844 BPF_ALU64_IMM(BPF_ADD, R3, 10),
2845 BPF_ALU64_IMM(BPF_ADD, R4, 10),
2846 BPF_ALU64_IMM(BPF_ADD, R5, 10),
2847 BPF_ALU64_IMM(BPF_ADD, R6, 10),
2848 BPF_ALU64_IMM(BPF_ADD, R7, 10),
2849 BPF_ALU64_IMM(BPF_ADD, R8, 10),
2850 BPF_ALU64_IMM(BPF_ADD, R9, 10),
2851 BPF_ALU32_REG(BPF_ADD, R0, R1),
2852 BPF_ALU32_REG(BPF_ADD, R0, R2),
2853 BPF_ALU32_REG(BPF_ADD, R0, R3),
2854 BPF_ALU32_REG(BPF_ADD, R0, R4),
2855 BPF_ALU32_REG(BPF_ADD, R0, R5),
2856 BPF_ALU32_REG(BPF_ADD, R0, R6),
2857 BPF_ALU32_REG(BPF_ADD, R0, R7),
2858 BPF_ALU32_REG(BPF_ADD, R0, R8),
2859 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
2860 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
2861 BPF_EXIT_INSN(),
2862 BPF_ALU32_REG(BPF_ADD, R1, R0),
2863 BPF_ALU32_REG(BPF_ADD, R1, R1),
2864 BPF_ALU32_REG(BPF_ADD, R1, R2),
2865 BPF_ALU32_REG(BPF_ADD, R1, R3),
2866 BPF_ALU32_REG(BPF_ADD, R1, R4),
2867 BPF_ALU32_REG(BPF_ADD, R1, R5),
2868 BPF_ALU32_REG(BPF_ADD, R1, R6),
2869 BPF_ALU32_REG(BPF_ADD, R1, R7),
2870 BPF_ALU32_REG(BPF_ADD, R1, R8),
2871 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
2872 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
2873 BPF_EXIT_INSN(),
2874 BPF_ALU32_REG(BPF_ADD, R2, R0),
2875 BPF_ALU32_REG(BPF_ADD, R2, R1),
2876 BPF_ALU32_REG(BPF_ADD, R2, R2),
2877 BPF_ALU32_REG(BPF_ADD, R2, R3),
2878 BPF_ALU32_REG(BPF_ADD, R2, R4),
2879 BPF_ALU32_REG(BPF_ADD, R2, R5),
2880 BPF_ALU32_REG(BPF_ADD, R2, R6),
2881 BPF_ALU32_REG(BPF_ADD, R2, R7),
2882 BPF_ALU32_REG(BPF_ADD, R2, R8),
2883 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
2884 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
2885 BPF_EXIT_INSN(),
2886 BPF_ALU32_REG(BPF_ADD, R3, R0),
2887 BPF_ALU32_REG(BPF_ADD, R3, R1),
2888 BPF_ALU32_REG(BPF_ADD, R3, R2),
2889 BPF_ALU32_REG(BPF_ADD, R3, R3),
2890 BPF_ALU32_REG(BPF_ADD, R3, R4),
2891 BPF_ALU32_REG(BPF_ADD, R3, R5),
2892 BPF_ALU32_REG(BPF_ADD, R3, R6),
2893 BPF_ALU32_REG(BPF_ADD, R3, R7),
2894 BPF_ALU32_REG(BPF_ADD, R3, R8),
2895 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
2896 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
2897 BPF_EXIT_INSN(),
2898 BPF_ALU32_REG(BPF_ADD, R4, R0),
2899 BPF_ALU32_REG(BPF_ADD, R4, R1),
2900 BPF_ALU32_REG(BPF_ADD, R4, R2),
2901 BPF_ALU32_REG(BPF_ADD, R4, R3),
2902 BPF_ALU32_REG(BPF_ADD, R4, R4),
2903 BPF_ALU32_REG(BPF_ADD, R4, R5),
2904 BPF_ALU32_REG(BPF_ADD, R4, R6),
2905 BPF_ALU32_REG(BPF_ADD, R4, R7),
2906 BPF_ALU32_REG(BPF_ADD, R4, R8),
2907 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
2908 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
2909 BPF_EXIT_INSN(),
2910 BPF_ALU32_REG(BPF_ADD, R5, R0),
2911 BPF_ALU32_REG(BPF_ADD, R5, R1),
2912 BPF_ALU32_REG(BPF_ADD, R5, R2),
2913 BPF_ALU32_REG(BPF_ADD, R5, R3),
2914 BPF_ALU32_REG(BPF_ADD, R5, R4),
2915 BPF_ALU32_REG(BPF_ADD, R5, R5),
2916 BPF_ALU32_REG(BPF_ADD, R5, R6),
2917 BPF_ALU32_REG(BPF_ADD, R5, R7),
2918 BPF_ALU32_REG(BPF_ADD, R5, R8),
2919 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
2920 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
2921 BPF_EXIT_INSN(),
2922 BPF_ALU32_REG(BPF_ADD, R6, R0),
2923 BPF_ALU32_REG(BPF_ADD, R6, R1),
2924 BPF_ALU32_REG(BPF_ADD, R6, R2),
2925 BPF_ALU32_REG(BPF_ADD, R6, R3),
2926 BPF_ALU32_REG(BPF_ADD, R6, R4),
2927 BPF_ALU32_REG(BPF_ADD, R6, R5),
2928 BPF_ALU32_REG(BPF_ADD, R6, R6),
2929 BPF_ALU32_REG(BPF_ADD, R6, R7),
2930 BPF_ALU32_REG(BPF_ADD, R6, R8),
2931 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
2932 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
2933 BPF_EXIT_INSN(),
2934 BPF_ALU32_REG(BPF_ADD, R7, R0),
2935 BPF_ALU32_REG(BPF_ADD, R7, R1),
2936 BPF_ALU32_REG(BPF_ADD, R7, R2),
2937 BPF_ALU32_REG(BPF_ADD, R7, R3),
2938 BPF_ALU32_REG(BPF_ADD, R7, R4),
2939 BPF_ALU32_REG(BPF_ADD, R7, R5),
2940 BPF_ALU32_REG(BPF_ADD, R7, R6),
2941 BPF_ALU32_REG(BPF_ADD, R7, R7),
2942 BPF_ALU32_REG(BPF_ADD, R7, R8),
2943 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
2944 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
2945 BPF_EXIT_INSN(),
2946 BPF_ALU32_REG(BPF_ADD, R8, R0),
2947 BPF_ALU32_REG(BPF_ADD, R8, R1),
2948 BPF_ALU32_REG(BPF_ADD, R8, R2),
2949 BPF_ALU32_REG(BPF_ADD, R8, R3),
2950 BPF_ALU32_REG(BPF_ADD, R8, R4),
2951 BPF_ALU32_REG(BPF_ADD, R8, R5),
2952 BPF_ALU32_REG(BPF_ADD, R8, R6),
2953 BPF_ALU32_REG(BPF_ADD, R8, R7),
2954 BPF_ALU32_REG(BPF_ADD, R8, R8),
2955 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
2956 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
2957 BPF_EXIT_INSN(),
2958 BPF_ALU32_REG(BPF_ADD, R9, R0),
2959 BPF_ALU32_REG(BPF_ADD, R9, R1),
2960 BPF_ALU32_REG(BPF_ADD, R9, R2),
2961 BPF_ALU32_REG(BPF_ADD, R9, R3),
2962 BPF_ALU32_REG(BPF_ADD, R9, R4),
2963 BPF_ALU32_REG(BPF_ADD, R9, R5),
2964 BPF_ALU32_REG(BPF_ADD, R9, R6),
2965 BPF_ALU32_REG(BPF_ADD, R9, R7),
2966 BPF_ALU32_REG(BPF_ADD, R9, R8),
2967 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
2968 BPF_ALU32_REG(BPF_MOV, R0, R9),
2969 BPF_EXIT_INSN(),
2970 },
10f18e0b 2971 INTERNAL,
9def624a
AS		 2972 { },
2973 { { 0, 2957380 } }
2974 },
2975 { /* Mainly checking JIT here. */
2976 "INT: SUB",
ece80490 2977 .u.insns_int = {
9def624a
AS		 2978 BPF_ALU64_IMM(BPF_MOV, R0, 0),
2979 BPF_ALU64_IMM(BPF_MOV, R1, 1),
2980 BPF_ALU64_IMM(BPF_MOV, R2, 2),
2981 BPF_ALU64_IMM(BPF_MOV, R3, 3),
2982 BPF_ALU64_IMM(BPF_MOV, R4, 4),
2983 BPF_ALU64_IMM(BPF_MOV, R5, 5),
2984 BPF_ALU64_IMM(BPF_MOV, R6, 6),
2985 BPF_ALU64_IMM(BPF_MOV, R7, 7),
2986 BPF_ALU64_IMM(BPF_MOV, R8, 8),
2987 BPF_ALU64_IMM(BPF_MOV, R9, 9),
2988 BPF_ALU64_REG(BPF_SUB, R0, R0),
2989 BPF_ALU64_REG(BPF_SUB, R0, R1),
2990 BPF_ALU64_REG(BPF_SUB, R0, R2),
2991 BPF_ALU64_REG(BPF_SUB, R0, R3),
2992 BPF_ALU64_REG(BPF_SUB, R0, R4),
2993 BPF_ALU64_REG(BPF_SUB, R0, R5),
2994 BPF_ALU64_REG(BPF_SUB, R0, R6),
2995 BPF_ALU64_REG(BPF_SUB, R0, R7),
2996 BPF_ALU64_REG(BPF_SUB, R0, R8),
2997 BPF_ALU64_REG(BPF_SUB, R0, R9),
2998 BPF_ALU64_IMM(BPF_SUB, R0, 10),
2999 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
3000 BPF_EXIT_INSN(),
3001 BPF_ALU64_REG(BPF_SUB, R1, R0),
3002 BPF_ALU64_REG(BPF_SUB, R1, R2),
3003 BPF_ALU64_REG(BPF_SUB, R1, R3),
3004 BPF_ALU64_REG(BPF_SUB, R1, R4),
3005 BPF_ALU64_REG(BPF_SUB, R1, R5),
3006 BPF_ALU64_REG(BPF_SUB, R1, R6),
3007 BPF_ALU64_REG(BPF_SUB, R1, R7),
3008 BPF_ALU64_REG(BPF_SUB, R1, R8),
3009 BPF_ALU64_REG(BPF_SUB, R1, R9),
3010 BPF_ALU64_IMM(BPF_SUB, R1, 10),
3011 BPF_ALU64_REG(BPF_SUB, R2, R0),
3012 BPF_ALU64_REG(BPF_SUB, R2, R1),
3013 BPF_ALU64_REG(BPF_SUB, R2, R3),
3014 BPF_ALU64_REG(BPF_SUB, R2, R4),
3015 BPF_ALU64_REG(BPF_SUB, R2, R5),
3016 BPF_ALU64_REG(BPF_SUB, R2, R6),
3017 BPF_ALU64_REG(BPF_SUB, R2, R7),
3018 BPF_ALU64_REG(BPF_SUB, R2, R8),
3019 BPF_ALU64_REG(BPF_SUB, R2, R9),
3020 BPF_ALU64_IMM(BPF_SUB, R2, 10),
3021 BPF_ALU64_REG(BPF_SUB, R3, R0),
3022 BPF_ALU64_REG(BPF_SUB, R3, R1),
3023 BPF_ALU64_REG(BPF_SUB, R3, R2),
3024 BPF_ALU64_REG(BPF_SUB, R3, R4),
3025 BPF_ALU64_REG(BPF_SUB, R3, R5),
3026 BPF_ALU64_REG(BPF_SUB, R3, R6),
3027 BPF_ALU64_REG(BPF_SUB, R3, R7),
3028 BPF_ALU64_REG(BPF_SUB, R3, R8),
3029 BPF_ALU64_REG(BPF_SUB, R3, R9),
3030 BPF_ALU64_IMM(BPF_SUB, R3, 10),
3031 BPF_ALU64_REG(BPF_SUB, R4, R0),
3032 BPF_ALU64_REG(BPF_SUB, R4, R1),
3033 BPF_ALU64_REG(BPF_SUB, R4, R2),
3034 BPF_ALU64_REG(BPF_SUB, R4, R3),
3035 BPF_ALU64_REG(BPF_SUB, R4, R5),
3036 BPF_ALU64_REG(BPF_SUB, R4, R6),
3037 BPF_ALU64_REG(BPF_SUB, R4, R7),
3038 BPF_ALU64_REG(BPF_SUB, R4, R8),
3039 BPF_ALU64_REG(BPF_SUB, R4, R9),
3040 BPF_ALU64_IMM(BPF_SUB, R4, 10),
3041 BPF_ALU64_REG(BPF_SUB, R5, R0),
3042 BPF_ALU64_REG(BPF_SUB, R5, R1),
3043 BPF_ALU64_REG(BPF_SUB, R5, R2),
3044 BPF_ALU64_REG(BPF_SUB, R5, R3),
3045 BPF_ALU64_REG(BPF_SUB, R5, R4),
3046 BPF_ALU64_REG(BPF_SUB, R5, R6),
3047 BPF_ALU64_REG(BPF_SUB, R5, R7),
3048 BPF_ALU64_REG(BPF_SUB, R5, R8),
3049 BPF_ALU64_REG(BPF_SUB, R5, R9),
3050 BPF_ALU64_IMM(BPF_SUB, R5, 10),
3051 BPF_ALU64_REG(BPF_SUB, R6, R0),
3052 BPF_ALU64_REG(BPF_SUB, R6, R1),
3053 BPF_ALU64_REG(BPF_SUB, R6, R2),
3054 BPF_ALU64_REG(BPF_SUB, R6, R3),
3055 BPF_ALU64_REG(BPF_SUB, R6, R4),
3056 BPF_ALU64_REG(BPF_SUB, R6, R5),
3057 BPF_ALU64_REG(BPF_SUB, R6, R7),
3058 BPF_ALU64_REG(BPF_SUB, R6, R8),
3059 BPF_ALU64_REG(BPF_SUB, R6, R9),
3060 BPF_ALU64_IMM(BPF_SUB, R6, 10),
3061 BPF_ALU64_REG(BPF_SUB, R7, R0),
3062 BPF_ALU64_REG(BPF_SUB, R7, R1),
3063 BPF_ALU64_REG(BPF_SUB, R7, R2),
3064 BPF_ALU64_REG(BPF_SUB, R7, R3),
3065 BPF_ALU64_REG(BPF_SUB, R7, R4),
3066 BPF_ALU64_REG(BPF_SUB, R7, R5),
3067 BPF_ALU64_REG(BPF_SUB, R7, R6),
3068 BPF_ALU64_REG(BPF_SUB, R7, R8),
3069 BPF_ALU64_REG(BPF_SUB, R7, R9),
3070 BPF_ALU64_IMM(BPF_SUB, R7, 10),
3071 BPF_ALU64_REG(BPF_SUB, R8, R0),
3072 BPF_ALU64_REG(BPF_SUB, R8, R1),
3073 BPF_ALU64_REG(BPF_SUB, R8, R2),
3074 BPF_ALU64_REG(BPF_SUB, R8, R3),
3075 BPF_ALU64_REG(BPF_SUB, R8, R4),
3076 BPF_ALU64_REG(BPF_SUB, R8, R5),
3077 BPF_ALU64_REG(BPF_SUB, R8, R6),
3078 BPF_ALU64_REG(BPF_SUB, R8, R7),
3079 BPF_ALU64_REG(BPF_SUB, R8, R9),
3080 BPF_ALU64_IMM(BPF_SUB, R8, 10),
3081 BPF_ALU64_REG(BPF_SUB, R9, R0),
3082 BPF_ALU64_REG(BPF_SUB, R9, R1),
3083 BPF_ALU64_REG(BPF_SUB, R9, R2),
3084 BPF_ALU64_REG(BPF_SUB, R9, R3),
3085 BPF_ALU64_REG(BPF_SUB, R9, R4),
3086 BPF_ALU64_REG(BPF_SUB, R9, R5),
3087 BPF_ALU64_REG(BPF_SUB, R9, R6),
3088 BPF_ALU64_REG(BPF_SUB, R9, R7),
3089 BPF_ALU64_REG(BPF_SUB, R9, R8),
3090 BPF_ALU64_IMM(BPF_SUB, R9, 10),
3091 BPF_ALU64_IMM(BPF_SUB, R0, 10),
3092 BPF_ALU64_IMM(BPF_NEG, R0, 0),
3093 BPF_ALU64_REG(BPF_SUB, R0, R1),
3094 BPF_ALU64_REG(BPF_SUB, R0, R2),
3095 BPF_ALU64_REG(BPF_SUB, R0, R3),
3096 BPF_ALU64_REG(BPF_SUB, R0, R4),
3097 BPF_ALU64_REG(BPF_SUB, R0, R5),
3098 BPF_ALU64_REG(BPF_SUB, R0, R6),
3099 BPF_ALU64_REG(BPF_SUB, R0, R7),
3100 BPF_ALU64_REG(BPF_SUB, R0, R8),
3101 BPF_ALU64_REG(BPF_SUB, R0, R9),
3102 BPF_EXIT_INSN(),
3103 },
10f18e0b 3104 INTERNAL,
9def624a
AS		 3105 { },
3106 { { 0, 11 } }
3107 },
3108 { /* Mainly checking JIT here. */
3109 "INT: XOR",
ece80490 3110 .u.insns_int = {
9def624a
AS		 3111 BPF_ALU64_REG(BPF_SUB, R0, R0),
3112 BPF_ALU64_REG(BPF_XOR, R1, R1),
3113 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
3114 BPF_EXIT_INSN(),
3115 BPF_ALU64_IMM(BPF_MOV, R0, 10),
3116 BPF_ALU64_IMM(BPF_MOV, R1, -1),
3117 BPF_ALU64_REG(BPF_SUB, R1, R1),
3118 BPF_ALU64_REG(BPF_XOR, R2, R2),
3119 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
3120 BPF_EXIT_INSN(),
3121 BPF_ALU64_REG(BPF_SUB, R2, R2),
3122 BPF_ALU64_REG(BPF_XOR, R3, R3),
3123 BPF_ALU64_IMM(BPF_MOV, R0, 10),
3124 BPF_ALU64_IMM(BPF_MOV, R1, -1),
3125 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
3126 BPF_EXIT_INSN(),
3127 BPF_ALU64_REG(BPF_SUB, R3, R3),
3128 BPF_ALU64_REG(BPF_XOR, R4, R4),
3129 BPF_ALU64_IMM(BPF_MOV, R2, 1),
3130 BPF_ALU64_IMM(BPF_MOV, R5, -1),
3131 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
3132 BPF_EXIT_INSN(),
3133 BPF_ALU64_REG(BPF_SUB, R4, R4),
3134 BPF_ALU64_REG(BPF_XOR, R5, R5),
3135 BPF_ALU64_IMM(BPF_MOV, R3, 1),
3136 BPF_ALU64_IMM(BPF_MOV, R7, -1),
3137 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
3138 BPF_EXIT_INSN(),
3139 BPF_ALU64_IMM(BPF_MOV, R5, 1),
3140 BPF_ALU64_REG(BPF_SUB, R5, R5),
3141 BPF_ALU64_REG(BPF_XOR, R6, R6),
3142 BPF_ALU64_IMM(BPF_MOV, R1, 1),
3143 BPF_ALU64_IMM(BPF_MOV, R8, -1),
3144 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
3145 BPF_EXIT_INSN(),
3146 BPF_ALU64_REG(BPF_SUB, R6, R6),
3147 BPF_ALU64_REG(BPF_XOR, R7, R7),
3148 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
3149 BPF_EXIT_INSN(),
3150 BPF_ALU64_REG(BPF_SUB, R7, R7),
3151 BPF_ALU64_REG(BPF_XOR, R8, R8),
3152 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
3153 BPF_EXIT_INSN(),
3154 BPF_ALU64_REG(BPF_SUB, R8, R8),
3155 BPF_ALU64_REG(BPF_XOR, R9, R9),
3156 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
3157 BPF_EXIT_INSN(),
3158 BPF_ALU64_REG(BPF_SUB, R9, R9),
3159 BPF_ALU64_REG(BPF_XOR, R0, R0),
3160 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
3161 BPF_EXIT_INSN(),
3162 BPF_ALU64_REG(BPF_SUB, R1, R1),
3163 BPF_ALU64_REG(BPF_XOR, R0, R0),
3164 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
3165 BPF_ALU64_IMM(BPF_MOV, R0, 0),
3166 BPF_EXIT_INSN(),
3167 BPF_ALU64_IMM(BPF_MOV, R0, 1),
3168 BPF_EXIT_INSN(),
3169 },
10f18e0b 3170 INTERNAL,
9def624a
AS		 3171 { },
3172 { { 0, 1 } }
3173 },
3174 { /* Mainly checking JIT here. */
3175 "INT: MUL",
ece80490 3176 .u.insns_int = {
9def624a
AS		 3177 BPF_ALU64_IMM(BPF_MOV, R0, 11),
3178 BPF_ALU64_IMM(BPF_MOV, R1, 1),
3179 BPF_ALU64_IMM(BPF_MOV, R2, 2),
3180 BPF_ALU64_IMM(BPF_MOV, R3, 3),
3181 BPF_ALU64_IMM(BPF_MOV, R4, 4),
3182 BPF_ALU64_IMM(BPF_MOV, R5, 5),
3183 BPF_ALU64_IMM(BPF_MOV, R6, 6),
3184 BPF_ALU64_IMM(BPF_MOV, R7, 7),
3185 BPF_ALU64_IMM(BPF_MOV, R8, 8),
3186 BPF_ALU64_IMM(BPF_MOV, R9, 9),
3187 BPF_ALU64_REG(BPF_MUL, R0, R0),
3188 BPF_ALU64_REG(BPF_MUL, R0, R1),
3189 BPF_ALU64_REG(BPF_MUL, R0, R2),
3190 BPF_ALU64_REG(BPF_MUL, R0, R3),
3191 BPF_ALU64_REG(BPF_MUL, R0, R4),
3192 BPF_ALU64_REG(BPF_MUL, R0, R5),
3193 BPF_ALU64_REG(BPF_MUL, R0, R6),
3194 BPF_ALU64_REG(BPF_MUL, R0, R7),
3195 BPF_ALU64_REG(BPF_MUL, R0, R8),
3196 BPF_ALU64_REG(BPF_MUL, R0, R9),
3197 BPF_ALU64_IMM(BPF_MUL, R0, 10),
3198 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
3199 BPF_EXIT_INSN(),
3200 BPF_ALU64_REG(BPF_MUL, R1, R0),
3201 BPF_ALU64_REG(BPF_MUL, R1, R2),
3202 BPF_ALU64_REG(BPF_MUL, R1, R3),
3203 BPF_ALU64_REG(BPF_MUL, R1, R4),
3204 BPF_ALU64_REG(BPF_MUL, R1, R5),
3205 BPF_ALU64_REG(BPF_MUL, R1, R6),
3206 BPF_ALU64_REG(BPF_MUL, R1, R7),
3207 BPF_ALU64_REG(BPF_MUL, R1, R8),
3208 BPF_ALU64_REG(BPF_MUL, R1, R9),
3209 BPF_ALU64_IMM(BPF_MUL, R1, 10),
3210 BPF_ALU64_REG(BPF_MOV, R2, R1),
3211 BPF_ALU64_IMM(BPF_RSH, R2, 32),
3212 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
3213 BPF_EXIT_INSN(),
3214 BPF_ALU64_IMM(BPF_LSH, R1, 32),
3215 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
3216 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
3217 BPF_EXIT_INSN(),
3218 BPF_ALU64_REG(BPF_MUL, R2, R0),
3219 BPF_ALU64_REG(BPF_MUL, R2, R1),
3220 BPF_ALU64_REG(BPF_MUL, R2, R3),
3221 BPF_ALU64_REG(BPF_MUL, R2, R4),
3222 BPF_ALU64_REG(BPF_MUL, R2, R5),
3223 BPF_ALU64_REG(BPF_MUL, R2, R6),
3224 BPF_ALU64_REG(BPF_MUL, R2, R7),
3225 BPF_ALU64_REG(BPF_MUL, R2, R8),
3226 BPF_ALU64_REG(BPF_MUL, R2, R9),
3227 BPF_ALU64_IMM(BPF_MUL, R2, 10),
3228 BPF_ALU64_IMM(BPF_RSH, R2, 32),
3229 BPF_ALU64_REG(BPF_MOV, R0, R2),
3230 BPF_EXIT_INSN(),
3231 },
10f18e0b 3232 INTERNAL,
9def624a
AS		 3233 { },
3234 { { 0, 0x35d97ef2 } }
3235 },
9dd2af83
DB		 3236 { /* Mainly checking JIT here. */
3237 "MOV REG64",
3238 .u.insns_int = {
3239 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3240 BPF_MOV64_REG(R1, R0),
3241 BPF_MOV64_REG(R2, R1),
3242 BPF_MOV64_REG(R3, R2),
3243 BPF_MOV64_REG(R4, R3),
3244 BPF_MOV64_REG(R5, R4),
3245 BPF_MOV64_REG(R6, R5),
3246 BPF_MOV64_REG(R7, R6),
3247 BPF_MOV64_REG(R8, R7),
3248 BPF_MOV64_REG(R9, R8),
3249 BPF_ALU64_IMM(BPF_MOV, R0, 0),
3250 BPF_ALU64_IMM(BPF_MOV, R1, 0),
3251 BPF_ALU64_IMM(BPF_MOV, R2, 0),
3252 BPF_ALU64_IMM(BPF_MOV, R3, 0),
3253 BPF_ALU64_IMM(BPF_MOV, R4, 0),
3254 BPF_ALU64_IMM(BPF_MOV, R5, 0),
3255 BPF_ALU64_IMM(BPF_MOV, R6, 0),
3256 BPF_ALU64_IMM(BPF_MOV, R7, 0),
3257 BPF_ALU64_IMM(BPF_MOV, R8, 0),
3258 BPF_ALU64_IMM(BPF_MOV, R9, 0),
3259 BPF_ALU64_REG(BPF_ADD, R0, R0),
3260 BPF_ALU64_REG(BPF_ADD, R0, R1),
3261 BPF_ALU64_REG(BPF_ADD, R0, R2),
3262 BPF_ALU64_REG(BPF_ADD, R0, R3),
3263 BPF_ALU64_REG(BPF_ADD, R0, R4),
3264 BPF_ALU64_REG(BPF_ADD, R0, R5),
3265 BPF_ALU64_REG(BPF_ADD, R0, R6),
3266 BPF_ALU64_REG(BPF_ADD, R0, R7),
3267 BPF_ALU64_REG(BPF_ADD, R0, R8),
3268 BPF_ALU64_REG(BPF_ADD, R0, R9),
3269 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3270 BPF_EXIT_INSN(),
3271 },
3272 INTERNAL,
3273 { },
3274 { { 0, 0xfefe } }
3275 },
3276 { /* Mainly checking JIT here. */
3277 "MOV REG32",
3278 .u.insns_int = {
3279 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3280 BPF_MOV64_REG(R1, R0),
3281 BPF_MOV64_REG(R2, R1),
3282 BPF_MOV64_REG(R3, R2),
3283 BPF_MOV64_REG(R4, R3),
3284 BPF_MOV64_REG(R5, R4),
3285 BPF_MOV64_REG(R6, R5),
3286 BPF_MOV64_REG(R7, R6),
3287 BPF_MOV64_REG(R8, R7),
3288 BPF_MOV64_REG(R9, R8),
3289 BPF_ALU32_IMM(BPF_MOV, R0, 0),
3290 BPF_ALU32_IMM(BPF_MOV, R1, 0),
3291 BPF_ALU32_IMM(BPF_MOV, R2, 0),
3292 BPF_ALU32_IMM(BPF_MOV, R3, 0),
3293 BPF_ALU32_IMM(BPF_MOV, R4, 0),
3294 BPF_ALU32_IMM(BPF_MOV, R5, 0),
3295 BPF_ALU32_IMM(BPF_MOV, R6, 0),
3296 BPF_ALU32_IMM(BPF_MOV, R7, 0),
3297 BPF_ALU32_IMM(BPF_MOV, R8, 0),
3298 BPF_ALU32_IMM(BPF_MOV, R9, 0),
3299 BPF_ALU64_REG(BPF_ADD, R0, R0),
3300 BPF_ALU64_REG(BPF_ADD, R0, R1),
3301 BPF_ALU64_REG(BPF_ADD, R0, R2),
3302 BPF_ALU64_REG(BPF_ADD, R0, R3),
3303 BPF_ALU64_REG(BPF_ADD, R0, R4),
3304 BPF_ALU64_REG(BPF_ADD, R0, R5),
3305 BPF_ALU64_REG(BPF_ADD, R0, R6),
3306 BPF_ALU64_REG(BPF_ADD, R0, R7),
3307 BPF_ALU64_REG(BPF_ADD, R0, R8),
3308 BPF_ALU64_REG(BPF_ADD, R0, R9),
3309 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3310 BPF_EXIT_INSN(),
3311 },
3312 INTERNAL,
3313 { },
3314 { { 0, 0xfefe } }
3315 },
3316 { /* Mainly checking JIT here. */
3317 "LD IMM64",
3318 .u.insns_int = {
3319 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3320 BPF_MOV64_REG(R1, R0),
3321 BPF_MOV64_REG(R2, R1),
3322 BPF_MOV64_REG(R3, R2),
3323 BPF_MOV64_REG(R4, R3),
3324 BPF_MOV64_REG(R5, R4),
3325 BPF_MOV64_REG(R6, R5),
3326 BPF_MOV64_REG(R7, R6),
3327 BPF_MOV64_REG(R8, R7),
3328 BPF_MOV64_REG(R9, R8),
3329 BPF_LD_IMM64(R0, 0x0LL),
3330 BPF_LD_IMM64(R1, 0x0LL),
3331 BPF_LD_IMM64(R2, 0x0LL),
3332 BPF_LD_IMM64(R3, 0x0LL),
3333 BPF_LD_IMM64(R4, 0x0LL),
3334 BPF_LD_IMM64(R5, 0x0LL),
3335 BPF_LD_IMM64(R6, 0x0LL),
3336 BPF_LD_IMM64(R7, 0x0LL),
3337 BPF_LD_IMM64(R8, 0x0LL),
3338 BPF_LD_IMM64(R9, 0x0LL),
3339 BPF_ALU64_REG(BPF_ADD, R0, R0),
3340 BPF_ALU64_REG(BPF_ADD, R0, R1),
3341 BPF_ALU64_REG(BPF_ADD, R0, R2),
3342 BPF_ALU64_REG(BPF_ADD, R0, R3),
3343 BPF_ALU64_REG(BPF_ADD, R0, R4),
3344 BPF_ALU64_REG(BPF_ADD, R0, R5),
3345 BPF_ALU64_REG(BPF_ADD, R0, R6),
3346 BPF_ALU64_REG(BPF_ADD, R0, R7),
3347 BPF_ALU64_REG(BPF_ADD, R0, R8),
3348 BPF_ALU64_REG(BPF_ADD, R0, R9),
3349 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3350 BPF_EXIT_INSN(),
3351 },
3352 INTERNAL,
3353 { },
3354 { { 0, 0xfefe } }
3355 },
9def624a
AS		 3356 {
3357 "INT: ALU MIX",
ece80490 3358 .u.insns_int = {
9def624a
AS		 3359 BPF_ALU64_IMM(BPF_MOV, R0, 11),
3360 BPF_ALU64_IMM(BPF_ADD, R0, -1),
3361 BPF_ALU64_IMM(BPF_MOV, R2, 2),
3362 BPF_ALU64_IMM(BPF_XOR, R2, 3),
3363 BPF_ALU64_REG(BPF_DIV, R0, R2),
3364 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
3365 BPF_EXIT_INSN(),
3366 BPF_ALU64_IMM(BPF_MOD, R0, 3),
3367 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
3368 BPF_EXIT_INSN(),
3369 BPF_ALU64_IMM(BPF_MOV, R0, -1),
72b603ee
AS		 3370 BPF_EXIT_INSN(),
3371 },
3372 INTERNAL,
3373 { },
3374 { { 0, -1 } }
3375 },
3376 {
3377 "INT: shifts by register",
3378 .u.insns_int = {
3379 BPF_MOV64_IMM(R0, -1234),
3380 BPF_MOV64_IMM(R1, 1),
3381 BPF_ALU32_REG(BPF_RSH, R0, R1),
3382 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
3383 BPF_EXIT_INSN(),
3384 BPF_MOV64_IMM(R2, 1),
3385 BPF_ALU64_REG(BPF_LSH, R0, R2),
3386 BPF_MOV32_IMM(R4, -1234),
3387 BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
3388 BPF_EXIT_INSN(),
3389 BPF_ALU64_IMM(BPF_AND, R4, 63),
3390 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
3391 BPF_MOV64_IMM(R3, 47),
3392 BPF_ALU64_REG(BPF_ARSH, R0, R3),
3393 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
3394 BPF_EXIT_INSN(),
3395 BPF_MOV64_IMM(R2, 1),
3396 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
3397 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
3398 BPF_EXIT_INSN(),
3399 BPF_MOV64_IMM(R4, 4),
3400 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
3401 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
3402 BPF_EXIT_INSN(),
3403 BPF_MOV64_IMM(R4, 5),
3404 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
3405 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
3406 BPF_EXIT_INSN(),
3407 BPF_MOV64_IMM(R0, -1),
9def624a
AS		 3408 BPF_EXIT_INSN(),
3409 },
10f18e0b 3410 INTERNAL,
9def624a
AS		 3411 { },
3412 { { 0, -1 } }
3413 },
84024a4e
JA		 3414 {
3415 /*
3416 * Register (non-)clobbering test, in the case where a 32-bit
3417 * JIT implements complex ALU64 operations via function calls.
3418 * If so, the function call must be invisible in the eBPF
3419 * registers. The JIT must then save and restore relevant
3420 * registers during the call. The following tests check that
3421 * the eBPF registers retain their values after such a call.
3422 */
3423 "INT: Register clobbering, R1 updated",
3424 .u.insns_int = {
3425 BPF_ALU32_IMM(BPF_MOV, R0, 0),
3426 BPF_ALU32_IMM(BPF_MOV, R1, 123456789),
3427 BPF_ALU32_IMM(BPF_MOV, R2, 2),
3428 BPF_ALU32_IMM(BPF_MOV, R3, 3),
3429 BPF_ALU32_IMM(BPF_MOV, R4, 4),
3430 BPF_ALU32_IMM(BPF_MOV, R5, 5),
3431 BPF_ALU32_IMM(BPF_MOV, R6, 6),
3432 BPF_ALU32_IMM(BPF_MOV, R7, 7),
3433 BPF_ALU32_IMM(BPF_MOV, R8, 8),
3434 BPF_ALU32_IMM(BPF_MOV, R9, 9),
3435 BPF_ALU64_IMM(BPF_DIV, R1, 123456789),
3436 BPF_JMP_IMM(BPF_JNE, R0, 0, 10),
3437 BPF_JMP_IMM(BPF_JNE, R1, 1, 9),
3438 BPF_JMP_IMM(BPF_JNE, R2, 2, 8),
3439 BPF_JMP_IMM(BPF_JNE, R3, 3, 7),
3440 BPF_JMP_IMM(BPF_JNE, R4, 4, 6),
3441 BPF_JMP_IMM(BPF_JNE, R5, 5, 5),
3442 BPF_JMP_IMM(BPF_JNE, R6, 6, 4),
3443 BPF_JMP_IMM(BPF_JNE, R7, 7, 3),
3444 BPF_JMP_IMM(BPF_JNE, R8, 8, 2),
3445 BPF_JMP_IMM(BPF_JNE, R9, 9, 1),
3446 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3447 BPF_EXIT_INSN(),
3448 },
3449 INTERNAL,
3450 { },
3451 { { 0, 1 } }
3452 },
3453 {
3454 "INT: Register clobbering, R2 updated",
3455 .u.insns_int = {
3456 BPF_ALU32_IMM(BPF_MOV, R0, 0),
3457 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3458 BPF_ALU32_IMM(BPF_MOV, R2, 2 * 123456789),
3459 BPF_ALU32_IMM(BPF_MOV, R3, 3),
3460 BPF_ALU32_IMM(BPF_MOV, R4, 4),
3461 BPF_ALU32_IMM(BPF_MOV, R5, 5),
3462 BPF_ALU32_IMM(BPF_MOV, R6, 6),
3463 BPF_ALU32_IMM(BPF_MOV, R7, 7),
3464 BPF_ALU32_IMM(BPF_MOV, R8, 8),
3465 BPF_ALU32_IMM(BPF_MOV, R9, 9),
3466 BPF_ALU64_IMM(BPF_DIV, R2, 123456789),
3467 BPF_JMP_IMM(BPF_JNE, R0, 0, 10),
3468 BPF_JMP_IMM(BPF_JNE, R1, 1, 9),
3469 BPF_JMP_IMM(BPF_JNE, R2, 2, 8),
3470 BPF_JMP_IMM(BPF_JNE, R3, 3, 7),
3471 BPF_JMP_IMM(BPF_JNE, R4, 4, 6),
3472 BPF_JMP_IMM(BPF_JNE, R5, 5, 5),
3473 BPF_JMP_IMM(BPF_JNE, R6, 6, 4),
3474 BPF_JMP_IMM(BPF_JNE, R7, 7, 3),
3475 BPF_JMP_IMM(BPF_JNE, R8, 8, 2),
3476 BPF_JMP_IMM(BPF_JNE, R9, 9, 1),
3477 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3478 BPF_EXIT_INSN(),
3479 },
3480 INTERNAL,
3481 { },
3482 { { 0, 1 } }
3483 },
3484 {
3485 /*
3486 * Test 32-bit JITs that implement complex ALU64 operations as
3487 * function calls R0 = f(R1, R2), and must re-arrange operands.
3488 */
3489#define NUMER 0xfedcba9876543210ULL
3490#define DENOM 0x0123456789abcdefULL
3491 "ALU64_DIV X: Operand register permutations",
3492 .u.insns_int = {
3493 /* R0 / R2 */
3494 BPF_LD_IMM64(R0, NUMER),
3495 BPF_LD_IMM64(R2, DENOM),
3496 BPF_ALU64_REG(BPF_DIV, R0, R2),
3497 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
3498 BPF_EXIT_INSN(),
3499 /* R1 / R0 */
3500 BPF_LD_IMM64(R1, NUMER),
3501 BPF_LD_IMM64(R0, DENOM),
3502 BPF_ALU64_REG(BPF_DIV, R1, R0),
3503 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
3504 BPF_EXIT_INSN(),
3505 /* R0 / R1 */
3506 BPF_LD_IMM64(R0, NUMER),
3507 BPF_LD_IMM64(R1, DENOM),
3508 BPF_ALU64_REG(BPF_DIV, R0, R1),
3509 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
3510 BPF_EXIT_INSN(),
3511 /* R2 / R0 */
3512 BPF_LD_IMM64(R2, NUMER),
3513 BPF_LD_IMM64(R0, DENOM),
3514 BPF_ALU64_REG(BPF_DIV, R2, R0),
3515 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
3516 BPF_EXIT_INSN(),
3517 /* R2 / R1 */
3518 BPF_LD_IMM64(R2, NUMER),
3519 BPF_LD_IMM64(R1, DENOM),
3520 BPF_ALU64_REG(BPF_DIV, R2, R1),
3521 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
3522 BPF_EXIT_INSN(),
3523 /* R1 / R2 */
3524 BPF_LD_IMM64(R1, NUMER),
3525 BPF_LD_IMM64(R2, DENOM),
3526 BPF_ALU64_REG(BPF_DIV, R1, R2),
3527 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
3528 BPF_EXIT_INSN(),
3529 /* R1 / R1 */
3530 BPF_LD_IMM64(R1, NUMER),
3531 BPF_ALU64_REG(BPF_DIV, R1, R1),
3532 BPF_JMP_IMM(BPF_JEQ, R1, 1, 1),
3533 BPF_EXIT_INSN(),
3534 /* R2 / R2 */
3535 BPF_LD_IMM64(R2, DENOM),
3536 BPF_ALU64_REG(BPF_DIV, R2, R2),
3537 BPF_JMP_IMM(BPF_JEQ, R2, 1, 1),
3538 BPF_EXIT_INSN(),
3539 /* R3 / R4 */
3540 BPF_LD_IMM64(R3, NUMER),
3541 BPF_LD_IMM64(R4, DENOM),
3542 BPF_ALU64_REG(BPF_DIV, R3, R4),
3543 BPF_JMP_IMM(BPF_JEQ, R3, NUMER / DENOM, 1),
3544 BPF_EXIT_INSN(),
3545 /* Successful return */
3546 BPF_LD_IMM64(R0, 1),
3547 BPF_EXIT_INSN(),
3548 },
3549 INTERNAL,
3550 { },
3551 { { 0, 1 } },
3552#undef NUMER
3553#undef DENOM
3554 },
53e33f99
JA		 3555#ifdef CONFIG_32BIT
3556 {
3557 "INT: 32-bit context pointer word order and zero-extension",
3558 .u.insns_int = {
3559 BPF_ALU32_IMM(BPF_MOV, R0, 0),
3560 BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
3561 BPF_ALU64_IMM(BPF_RSH, R1, 32),
3562 BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
3563 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3564 BPF_EXIT_INSN(),
3565 },
3566 INTERNAL,
3567 { },
3568 { { 0, 1 } }
3569 },
3570#endif
64a8946b
AS		 3571 {
3572 "check: missing ret",
ece80490 3573 .u.insns = {
64a8946b
AS		 3574 BPF_STMT(BPF_LD | BPF_IMM, 1),
3575 },
10f18e0b 3576 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
64a8946b 3577 { },
09584b40
YS		 3578 { },
3579 .fill_helper = NULL,
3580 .expected_errcode = -EINVAL,
64a8946b 3581 },
9def624a
AS		 3582 {
3583 "check: div_k_0",
ece80490 3584 .u.insns = {
9def624a
AS		 3585 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
3586 BPF_STMT(BPF_RET | BPF_K, 0)
3587 },
10f18e0b 3588 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a 3589 { },
09584b40
YS		 3590 { },
3591 .fill_helper = NULL,
3592 .expected_errcode = -EINVAL,
9def624a
AS		 3593 },
3594 {
3595 "check: unknown insn",
ece80490 3596 .u.insns = {
9def624a
AS		 3597 /* seccomp insn, rejected in socket filter */
3598 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
3599 BPF_STMT(BPF_RET | BPF_K, 0)
3600 },
10f18e0b 3601 CLASSIC | FLAG_EXPECTED_FAIL,
9def624a 3602 { },
09584b40
YS		 3603 { },
3604 .fill_helper = NULL,
3605 .expected_errcode = -EINVAL,
9def624a
AS		 3606 },
3607 {
3608 "check: out of range spill/fill",
ece80490 3609 .u.insns = {
9def624a
AS		 3610 BPF_STMT(BPF_STX, 16),
3611 BPF_STMT(BPF_RET | BPF_K, 0)
3612 },
10f18e0b 3613 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a 3614 { },
09584b40
YS		 3615 { },
3616 .fill_helper = NULL,
3617 .expected_errcode = -EINVAL,
9def624a 3618 },
2e8a83c5
DB		 3619 {
3620 "JUMPS + HOLES",
3621 .u.insns = {
3622 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3623 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
3624 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3625 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3626 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3627 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3628 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3629 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3630 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3631 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3632 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3633 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3634 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3635 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3636 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3637 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
3638 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3639 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
3640 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3641 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
3642 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
3643 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3644 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3645 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3646 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3647 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3648 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3649 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3650 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3651 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3652 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3653 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3654 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3655 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3656 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
3657 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
3658 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3659 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
3660 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
3661 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3662 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3663 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3664 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3665 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3666 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3667 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3668 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3669 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3670 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3671 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3672 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3673 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3674 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
3675 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
3676 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3677 BPF_STMT(BPF_RET | BPF_A, 0),
3678 BPF_STMT(BPF_RET | BPF_A, 0),
3679 },
3680 CLASSIC,
ce25b68b
DB		 3681 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
3682 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
3683 0x08, 0x00,
3684 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
3685 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
3686 0xc0, 0xa8, 0x33, 0x01,
3687 0xc0, 0xa8, 0x33, 0x02,
3688 0xbb, 0xb6,
3689 0xa9, 0xfa,
3690 0x00, 0x14, 0x00, 0x00,
3691 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3692 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3693 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3694 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3695 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3696 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3697 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3698 0xcc, 0xcc, 0xcc, 0xcc },
2e8a83c5
DB		 3699 { { 88, 0x001b } }
3700 },
3701 {
3702 "check: RET X",
3703 .u.insns = {
3704 BPF_STMT(BPF_RET | BPF_X, 0),
3705 },
3706 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
3707 { },
3708 { },
09584b40
YS		 3709 .fill_helper = NULL,
3710 .expected_errcode = -EINVAL,
2e8a83c5
DB		 3711 },
3712 {
3713 "check: LDX + RET X",
3714 .u.insns = {
3715 BPF_STMT(BPF_LDX | BPF_IMM, 42),
3716 BPF_STMT(BPF_RET | BPF_X, 0),
3717 },
3718 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
3719 { },
3720 { },
09584b40
YS		 3721 .fill_helper = NULL,
3722 .expected_errcode = -EINVAL,
2e8a83c5 3723 },
108cc22a 3724 { /* Mainly checking JIT here. */
9fe13baa 3725 "M[]: alt STX + LDX",
108cc22a
DB		 3726 .u.insns = {
3727 BPF_STMT(BPF_LDX | BPF_IMM, 100),
3728 BPF_STMT(BPF_STX, 0),
3729 BPF_STMT(BPF_LDX | BPF_MEM, 0),
3730 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3731 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3732 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3733 BPF_STMT(BPF_STX, 1),
3734 BPF_STMT(BPF_LDX | BPF_MEM, 1),
3735 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3736 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3737 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3738 BPF_STMT(BPF_STX, 2),
3739 BPF_STMT(BPF_LDX | BPF_MEM, 2),
3740 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3741 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3742 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3743 BPF_STMT(BPF_STX, 3),
3744 BPF_STMT(BPF_LDX | BPF_MEM, 3),
3745 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3746 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3747 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3748 BPF_STMT(BPF_STX, 4),
3749 BPF_STMT(BPF_LDX | BPF_MEM, 4),
3750 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3751 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3752 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3753 BPF_STMT(BPF_STX, 5),
3754 BPF_STMT(BPF_LDX | BPF_MEM, 5),
3755 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3756 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3757 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3758 BPF_STMT(BPF_STX, 6),
3759 BPF_STMT(BPF_LDX | BPF_MEM, 6),
3760 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3761 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3762 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3763 BPF_STMT(BPF_STX, 7),
3764 BPF_STMT(BPF_LDX | BPF_MEM, 7),
3765 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3766 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3767 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3768 BPF_STMT(BPF_STX, 8),
3769 BPF_STMT(BPF_LDX | BPF_MEM, 8),
3770 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3771 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3772 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3773 BPF_STMT(BPF_STX, 9),
3774 BPF_STMT(BPF_LDX | BPF_MEM, 9),
3775 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3776 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3777 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3778 BPF_STMT(BPF_STX, 10),
3779 BPF_STMT(BPF_LDX | BPF_MEM, 10),
3780 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3781 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3782 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3783 BPF_STMT(BPF_STX, 11),
3784 BPF_STMT(BPF_LDX | BPF_MEM, 11),
3785 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3786 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3787 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3788 BPF_STMT(BPF_STX, 12),
3789 BPF_STMT(BPF_LDX | BPF_MEM, 12),
3790 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3791 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3792 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3793 BPF_STMT(BPF_STX, 13),
3794 BPF_STMT(BPF_LDX | BPF_MEM, 13),
3795 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3796 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3797 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3798 BPF_STMT(BPF_STX, 14),
3799 BPF_STMT(BPF_LDX | BPF_MEM, 14),
3800 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3801 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3802 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3803 BPF_STMT(BPF_STX, 15),
3804 BPF_STMT(BPF_LDX | BPF_MEM, 15),
3805 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3806 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3807 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3808 BPF_STMT(BPF_RET | BPF_A, 0),
3809 },
3810 CLASSIC | FLAG_NO_DATA,
3811 { },
3812 { { 0, 116 } },
3813 },
9fe13baa
DB		 3814 { /* Mainly checking JIT here. */
3815 "M[]: full STX + full LDX",
3816 .u.insns = {
3817 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
3818 BPF_STMT(BPF_STX, 0),
3819 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
3820 BPF_STMT(BPF_STX, 1),
3821 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
3822 BPF_STMT(BPF_STX, 2),
3823 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
3824 BPF_STMT(BPF_STX, 3),
3825 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
3826 BPF_STMT(BPF_STX, 4),
3827 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
3828 BPF_STMT(BPF_STX, 5),
3829 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
3830 BPF_STMT(BPF_STX, 6),
3831 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
3832 BPF_STMT(BPF_STX, 7),
3833 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
3834 BPF_STMT(BPF_STX, 8),
3835 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
3836 BPF_STMT(BPF_STX, 9),
3837 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
3838 BPF_STMT(BPF_STX, 10),
3839 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
3840 BPF_STMT(BPF_STX, 11),
3841 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
3842 BPF_STMT(BPF_STX, 12),
3843 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
3844 BPF_STMT(BPF_STX, 13),
3845 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
3846 BPF_STMT(BPF_STX, 14),
3847 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
3848 BPF_STMT(BPF_STX, 15),
3849 BPF_STMT(BPF_LDX | BPF_MEM, 0),
3850 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3851 BPF_STMT(BPF_LDX | BPF_MEM, 1),
3852 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3853 BPF_STMT(BPF_LDX | BPF_MEM, 2),
3854 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3855 BPF_STMT(BPF_LDX | BPF_MEM, 3),
3856 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3857 BPF_STMT(BPF_LDX | BPF_MEM, 4),
3858 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3859 BPF_STMT(BPF_LDX | BPF_MEM, 5),
3860 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3861 BPF_STMT(BPF_LDX | BPF_MEM, 6),
3862 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3863 BPF_STMT(BPF_LDX | BPF_MEM, 7),
3864 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3865 BPF_STMT(BPF_LDX | BPF_MEM, 8),
3866 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3867 BPF_STMT(BPF_LDX | BPF_MEM, 9),
3868 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3869 BPF_STMT(BPF_LDX | BPF_MEM, 10),
3870 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3871 BPF_STMT(BPF_LDX | BPF_MEM, 11),
3872 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3873 BPF_STMT(BPF_LDX | BPF_MEM, 12),
3874 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3875 BPF_STMT(BPF_LDX | BPF_MEM, 13),
3876 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3877 BPF_STMT(BPF_LDX | BPF_MEM, 14),
3878 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3879 BPF_STMT(BPF_LDX | BPF_MEM, 15),
3880 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
3881 BPF_STMT(BPF_RET | BPF_A, 0),
3882 },
3883 CLASSIC | FLAG_NO_DATA,
3884 { },
3885 { { 0, 0x2a5a5e5 } },
3886 },
d50bc157
DB		 3887 {
3888 "check: SKF_AD_MAX",
3889 .u.insns = {
3890 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3891 SKF_AD_OFF + SKF_AD_MAX),
3892 BPF_STMT(BPF_RET | BPF_A, 0),
3893 },
3894 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
3895 { },
3896 { },
09584b40
YS		 3897 .fill_helper = NULL,
3898 .expected_errcode = -EINVAL,
d50bc157
DB		 3899 },
3900 { /* Passes checker but fails during runtime. */
3901 "LD [SKF_AD_OFF-1]",
3902 .u.insns = {
3903 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
3904 SKF_AD_OFF - 1),
3905 BPF_STMT(BPF_RET | BPF_K, 1),
3906 },
3907 CLASSIC,
3908 { },
3909 { { 1, 0 } },
3910 },
02ab695b
AS		 3911 {
3912 "load 64-bit immediate",
3913 .u.insns_int = {
25ee7327 3914 BPF_LD_IMM64(R1, 0x567800001234LL),
02ab695b
AS		 3915 BPF_MOV64_REG(R2, R1),
3916 BPF_MOV64_REG(R3, R2),
3917 BPF_ALU64_IMM(BPF_RSH, R2, 32),
3918 BPF_ALU64_IMM(BPF_LSH, R3, 32),
3919 BPF_ALU64_IMM(BPF_RSH, R3, 32),
3920 BPF_ALU64_IMM(BPF_MOV, R0, 0),
3921 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
3922 BPF_EXIT_INSN(),
3923 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
3924 BPF_EXIT_INSN(),
986ccfdb
XW		 3925 BPF_LD_IMM64(R0, 0x1ffffffffLL),
3926 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
02ab695b
AS		 3927 BPF_EXIT_INSN(),
3928 },
3929 INTERNAL,
3930 { },
3931 { { 0, 1 } }
3932 },
cffc642d
MH		 3933 /* BPF_ALU | BPF_MOV | BPF_X */
3934 {
3935 "ALU_MOV_X: dst = 2",
3936 .u.insns_int = {
3937 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3938 BPF_ALU32_REG(BPF_MOV, R0, R1),
3939 BPF_EXIT_INSN(),
3940 },
3941 INTERNAL,
3942 { },
3943 { { 0, 2 } },
3944 },
3945 {
3946 "ALU_MOV_X: dst = 4294967295",
3947 .u.insns_int = {
56cbaa45 3948 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 3949 BPF_ALU32_REG(BPF_MOV, R0, R1),
3950 BPF_EXIT_INSN(),
3951 },
3952 INTERNAL,
3953 { },
56cbaa45 3954 { { 0, 4294967295U } },
cffc642d
MH		 3955 },
3956 {
3957 "ALU64_MOV_X: dst = 2",
3958 .u.insns_int = {
3959 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3960 BPF_ALU64_REG(BPF_MOV, R0, R1),
3961 BPF_EXIT_INSN(),
3962 },
3963 INTERNAL,
3964 { },
3965 { { 0, 2 } },
3966 },
3967 {
3968 "ALU64_MOV_X: dst = 4294967295",
3969 .u.insns_int = {
56cbaa45 3970 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 3971 BPF_ALU64_REG(BPF_MOV, R0, R1),
3972 BPF_EXIT_INSN(),
3973 },
3974 INTERNAL,
3975 { },
56cbaa45 3976 { { 0, 4294967295U } },
cffc642d
MH		 3977 },
3978 /* BPF_ALU | BPF_MOV | BPF_K */
3979 {
3980 "ALU_MOV_K: dst = 2",
3981 .u.insns_int = {
3982 BPF_ALU32_IMM(BPF_MOV, R0, 2),
3983 BPF_EXIT_INSN(),
3984 },
3985 INTERNAL,
3986 { },
3987 { { 0, 2 } },
3988 },
3989 {
3990 "ALU_MOV_K: dst = 4294967295",
3991 .u.insns_int = {
56cbaa45 3992 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
cffc642d
MH		 3993 BPF_EXIT_INSN(),
3994 },
3995 INTERNAL,
3996 { },
56cbaa45 3997 { { 0, 4294967295U } },
cffc642d
MH		 3998 },
3999 {
4000 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4001 .u.insns_int = {
56cbaa45
MH		 4002 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4003 BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
cffc642d
MH		 4004 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4005 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4006 BPF_MOV32_IMM(R0, 2),
4007 BPF_EXIT_INSN(),
4008 BPF_MOV32_IMM(R0, 1),
4009 BPF_EXIT_INSN(),
4010 },
4011 INTERNAL,
4012 { },
4013 { { 0, 0x1 } },
4014 },
565731ac
JA		 4015 {
4016 "ALU_MOV_K: small negative",
4017 .u.insns_int = {
4018 BPF_ALU32_IMM(BPF_MOV, R0, -123),
4019 BPF_EXIT_INSN(),
4020 },
4021 INTERNAL,
4022 { },
4023 { { 0, -123 } }
4024 },
4025 {
4026 "ALU_MOV_K: small negative zero extension",
4027 .u.insns_int = {
4028 BPF_ALU32_IMM(BPF_MOV, R0, -123),
4029 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4030 BPF_EXIT_INSN(),
4031 },
4032 INTERNAL,
4033 { },
4034 { { 0, 0 } }
4035 },
4036 {
4037 "ALU_MOV_K: large negative",
4038 .u.insns_int = {
4039 BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
4040 BPF_EXIT_INSN(),
4041 },
4042 INTERNAL,
4043 { },
4044 { { 0, -123456789 } }
4045 },
4046 {
4047 "ALU_MOV_K: large negative zero extension",
4048 .u.insns_int = {
4049 BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
4050 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4051 BPF_EXIT_INSN(),
4052 },
4053 INTERNAL,
4054 { },
4055 { { 0, 0 } }
4056 },
cffc642d
MH		 4057 {
4058 "ALU64_MOV_K: dst = 2",
4059 .u.insns_int = {
4060 BPF_ALU64_IMM(BPF_MOV, R0, 2),
4061 BPF_EXIT_INSN(),
4062 },
4063 INTERNAL,
4064 { },
4065 { { 0, 2 } },
4066 },
4067 {
4068 "ALU64_MOV_K: dst = 2147483647",
4069 .u.insns_int = {
4070 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
4071 BPF_EXIT_INSN(),
4072 },
4073 INTERNAL,
4074 { },
4075 { { 0, 2147483647 } },
4076 },
4077 {
4078 "ALU64_OR_K: dst = 0x0",
4079 .u.insns_int = {
56cbaa45 4080 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
cffc642d
MH		 4081 BPF_LD_IMM64(R3, 0x0),
4082 BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
4083 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4084 BPF_MOV32_IMM(R0, 2),
4085 BPF_EXIT_INSN(),
4086 BPF_MOV32_IMM(R0, 1),
4087 BPF_EXIT_INSN(),
4088 },
4089 INTERNAL,
4090 { },
4091 { { 0, 0x1 } },
4092 },
4093 {
4094 "ALU64_MOV_K: dst = -1",
4095 .u.insns_int = {
56cbaa45
MH		 4096 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4097 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 4098 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
4099 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4100 BPF_MOV32_IMM(R0, 2),
4101 BPF_EXIT_INSN(),
4102 BPF_MOV32_IMM(R0, 1),
4103 BPF_EXIT_INSN(),
4104 },
4105 INTERNAL,
4106 { },
4107 { { 0, 0x1 } },
4108 },
565731ac
JA		 4109 {
4110 "ALU64_MOV_K: small negative",
4111 .u.insns_int = {
4112 BPF_ALU64_IMM(BPF_MOV, R0, -123),
4113 BPF_EXIT_INSN(),
4114 },
4115 INTERNAL,
4116 { },
4117 { { 0, -123 } }
4118 },
4119 {
4120 "ALU64_MOV_K: small negative sign extension",
4121 .u.insns_int = {
4122 BPF_ALU64_IMM(BPF_MOV, R0, -123),
4123 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4124 BPF_EXIT_INSN(),
4125 },
4126 INTERNAL,
4127 { },
4128 { { 0, 0xffffffff } }
4129 },
4130 {
4131 "ALU64_MOV_K: large negative",
4132 .u.insns_int = {
4133 BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
4134 BPF_EXIT_INSN(),
4135 },
4136 INTERNAL,
4137 { },
4138 { { 0, -123456789 } }
4139 },
4140 {
4141 "ALU64_MOV_K: large negative sign extension",
4142 .u.insns_int = {
4143 BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
4144 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4145 BPF_EXIT_INSN(),
4146 },
4147 INTERNAL,
4148 { },
4149 { { 0, 0xffffffff } }
4150 },
cffc642d
MH		 4151 /* BPF_ALU | BPF_ADD | BPF_X */
4152 {
4153 "ALU_ADD_X: 1 + 2 = 3",
4154 .u.insns_int = {
4155 BPF_LD_IMM64(R0, 1),
4156 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4157 BPF_ALU32_REG(BPF_ADD, R0, R1),
4158 BPF_EXIT_INSN(),
4159 },
4160 INTERNAL,
4161 { },
4162 { { 0, 3 } },
4163 },
4164 {
4165 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
4166 .u.insns_int = {
4167 BPF_LD_IMM64(R0, 1),
56cbaa45 4168 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 4169 BPF_ALU32_REG(BPF_ADD, R0, R1),
4170 BPF_EXIT_INSN(),
4171 },
4172 INTERNAL,
4173 { },
56cbaa45 4174 { { 0, 4294967295U } },
cffc642d 4175 },
b64b50ea
NR		 4176 {
4177 "ALU_ADD_X: 2 + 4294967294 = 0",
4178 .u.insns_int = {
4179 BPF_LD_IMM64(R0, 2),
4180 BPF_LD_IMM64(R1, 4294967294U),
4181 BPF_ALU32_REG(BPF_ADD, R0, R1),
4182 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
4183 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4184 BPF_EXIT_INSN(),
4185 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4186 BPF_EXIT_INSN(),
4187 },
4188 INTERNAL,
4189 { },
4190 { { 0, 1 } },
4191 },
cffc642d
MH		 4192 {
4193 "ALU64_ADD_X: 1 + 2 = 3",
4194 .u.insns_int = {
4195 BPF_LD_IMM64(R0, 1),
4196 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4197 BPF_ALU64_REG(BPF_ADD, R0, R1),
4198 BPF_EXIT_INSN(),
4199 },
4200 INTERNAL,
4201 { },
4202 { { 0, 3 } },
4203 },
4204 {
4205 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
4206 .u.insns_int = {
4207 BPF_LD_IMM64(R0, 1),
56cbaa45 4208 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 4209 BPF_ALU64_REG(BPF_ADD, R0, R1),
4210 BPF_EXIT_INSN(),
4211 },
4212 INTERNAL,
4213 { },
56cbaa45 4214 { { 0, 4294967295U } },
cffc642d 4215 },
b64b50ea
NR		 4216 {
4217 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
4218 .u.insns_int = {
4219 BPF_LD_IMM64(R0, 2),
4220 BPF_LD_IMM64(R1, 4294967294U),
4221 BPF_LD_IMM64(R2, 4294967296ULL),
4222 BPF_ALU64_REG(BPF_ADD, R0, R1),
4223 BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
4224 BPF_MOV32_IMM(R0, 0),
4225 BPF_EXIT_INSN(),
4226 BPF_MOV32_IMM(R0, 1),
4227 BPF_EXIT_INSN(),
4228 },
4229 INTERNAL,
4230 { },
4231 { { 0, 1 } },
4232 },
cffc642d
MH		 4233 /* BPF_ALU | BPF_ADD | BPF_K */
4234 {
4235 "ALU_ADD_K: 1 + 2 = 3",
4236 .u.insns_int = {
4237 BPF_LD_IMM64(R0, 1),
4238 BPF_ALU32_IMM(BPF_ADD, R0, 2),
4239 BPF_EXIT_INSN(),
4240 },
4241 INTERNAL,
4242 { },
4243 { { 0, 3 } },
4244 },
4245 {
4246 "ALU_ADD_K: 3 + 0 = 3",
4247 .u.insns_int = {
4248 BPF_LD_IMM64(R0, 3),
4249 BPF_ALU32_IMM(BPF_ADD, R0, 0),
4250 BPF_EXIT_INSN(),
4251 },
4252 INTERNAL,
4253 { },
4254 { { 0, 3 } },
4255 },
4256 {
4257 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
4258 .u.insns_int = {
4259 BPF_LD_IMM64(R0, 1),
56cbaa45 4260 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
cffc642d
MH		 4261 BPF_EXIT_INSN(),
4262 },
4263 INTERNAL,
4264 { },
56cbaa45 4265 { { 0, 4294967295U } },
cffc642d 4266 },
b64b50ea
NR		 4267 {
4268 "ALU_ADD_K: 4294967294 + 2 = 0",
4269 .u.insns_int = {
4270 BPF_LD_IMM64(R0, 4294967294U),
4271 BPF_ALU32_IMM(BPF_ADD, R0, 2),
4272 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
4273 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4274 BPF_EXIT_INSN(),
4275 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4276 BPF_EXIT_INSN(),
4277 },
4278 INTERNAL,
4279 { },
4280 { { 0, 1 } },
4281 },
cffc642d
MH		 4282 {
4283 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
4284 .u.insns_int = {
4285 BPF_LD_IMM64(R2, 0x0),
4286 BPF_LD_IMM64(R3, 0x00000000ffffffff),
4287 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
4288 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4289 BPF_MOV32_IMM(R0, 2),
4290 BPF_EXIT_INSN(),
4291 BPF_MOV32_IMM(R0, 1),
4292 BPF_EXIT_INSN(),
4293 },
4294 INTERNAL,
4295 { },
4296 { { 0, 0x1 } },
4297 },
9c94f6c8
NR		 4298 {
4299 "ALU_ADD_K: 0 + 0xffff = 0xffff",
4300 .u.insns_int = {
4301 BPF_LD_IMM64(R2, 0x0),
4302 BPF_LD_IMM64(R3, 0xffff),
4303 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
4304 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4305 BPF_MOV32_IMM(R0, 2),
4306 BPF_EXIT_INSN(),
4307 BPF_MOV32_IMM(R0, 1),
4308 BPF_EXIT_INSN(),
4309 },
4310 INTERNAL,
4311 { },
4312 { { 0, 0x1 } },
4313 },
4314 {
4315 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
4316 .u.insns_int = {
4317 BPF_LD_IMM64(R2, 0x0),
4318 BPF_LD_IMM64(R3, 0x7fffffff),
4319 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
4320 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4321 BPF_MOV32_IMM(R0, 2),
4322 BPF_EXIT_INSN(),
4323 BPF_MOV32_IMM(R0, 1),
4324 BPF_EXIT_INSN(),
4325 },
4326 INTERNAL,
4327 { },
4328 { { 0, 0x1 } },
4329 },
4330 {
4331 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
4332 .u.insns_int = {
4333 BPF_LD_IMM64(R2, 0x0),
4334 BPF_LD_IMM64(R3, 0x80000000),
4335 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
4336 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4337 BPF_MOV32_IMM(R0, 2),
4338 BPF_EXIT_INSN(),
4339 BPF_MOV32_IMM(R0, 1),
4340 BPF_EXIT_INSN(),
4341 },
4342 INTERNAL,
4343 { },
4344 { { 0, 0x1 } },
4345 },
4346 {
4347 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
4348 .u.insns_int = {
4349 BPF_LD_IMM64(R2, 0x0),
4350 BPF_LD_IMM64(R3, 0x80008000),
4351 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
4352 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4353 BPF_MOV32_IMM(R0, 2),
4354 BPF_EXIT_INSN(),
4355 BPF_MOV32_IMM(R0, 1),
4356 BPF_EXIT_INSN(),
4357 },
4358 INTERNAL,
4359 { },
4360 { { 0, 0x1 } },
4361 },
cffc642d
MH		 4362 {
4363 "ALU64_ADD_K: 1 + 2 = 3",
4364 .u.insns_int = {
4365 BPF_LD_IMM64(R0, 1),
4366 BPF_ALU64_IMM(BPF_ADD, R0, 2),
4367 BPF_EXIT_INSN(),
4368 },
4369 INTERNAL,
4370 { },
4371 { { 0, 3 } },
4372 },
4373 {
4374 "ALU64_ADD_K: 3 + 0 = 3",
4375 .u.insns_int = {
4376 BPF_LD_IMM64(R0, 3),
4377 BPF_ALU64_IMM(BPF_ADD, R0, 0),
4378 BPF_EXIT_INSN(),
4379 },
4380 INTERNAL,
4381 { },
4382 { { 0, 3 } },
4383 },
4384 {
4385 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
4386 .u.insns_int = {
4387 BPF_LD_IMM64(R0, 1),
4388 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
4389 BPF_EXIT_INSN(),
4390 },
4391 INTERNAL,
4392 { },
4393 { { 0, 2147483647 } },
4394 },
b64b50ea
NR		 4395 {
4396 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
4397 .u.insns_int = {
4398 BPF_LD_IMM64(R0, 4294967294U),
4399 BPF_LD_IMM64(R1, 4294967296ULL),
4400 BPF_ALU64_IMM(BPF_ADD, R0, 2),
4401 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4402 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4403 BPF_EXIT_INSN(),
4404 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4405 BPF_EXIT_INSN(),
4406 },
4407 INTERNAL,
4408 { },
4409 { { 0, 1 } },
4410 },
cffc642d
MH		 4411 {
4412 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
4413 .u.insns_int = {
4414 BPF_LD_IMM64(R0, 2147483646),
4415 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
4416 BPF_EXIT_INSN(),
4417 },
4418 INTERNAL,
4419 { },
4420 { { 0, -1 } },
4421 },
4422 {
4423 "ALU64_ADD_K: 1 + 0 = 1",
4424 .u.insns_int = {
4425 BPF_LD_IMM64(R2, 0x1),
4426 BPF_LD_IMM64(R3, 0x1),
4427 BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
4428 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4429 BPF_MOV32_IMM(R0, 2),
4430 BPF_EXIT_INSN(),
4431 BPF_MOV32_IMM(R0, 1),
4432 BPF_EXIT_INSN(),
4433 },
4434 INTERNAL,
4435 { },
4436 { { 0, 0x1 } },
4437 },
4438 {
4439 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
4440 .u.insns_int = {
4441 BPF_LD_IMM64(R2, 0x0),
56cbaa45 4442 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 4443 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
4444 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4445 BPF_MOV32_IMM(R0, 2),
4446 BPF_EXIT_INSN(),
4447 BPF_MOV32_IMM(R0, 1),
4448 BPF_EXIT_INSN(),
4449 },
4450 INTERNAL,
4451 { },
4452 { { 0, 0x1 } },
4453 },
9c94f6c8
NR		 4454 {
4455 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
4456 .u.insns_int = {
4457 BPF_LD_IMM64(R2, 0x0),
4458 BPF_LD_IMM64(R3, 0xffff),
4459 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
4460 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4461 BPF_MOV32_IMM(R0, 2),
4462 BPF_EXIT_INSN(),
4463 BPF_MOV32_IMM(R0, 1),
4464 BPF_EXIT_INSN(),
4465 },
4466 INTERNAL,
4467 { },
4468 { { 0, 0x1 } },
4469 },
4470 {
4471 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
4472 .u.insns_int = {
4473 BPF_LD_IMM64(R2, 0x0),
4474 BPF_LD_IMM64(R3, 0x7fffffff),
4475 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
4476 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4477 BPF_MOV32_IMM(R0, 2),
4478 BPF_EXIT_INSN(),
4479 BPF_MOV32_IMM(R0, 1),
4480 BPF_EXIT_INSN(),
4481 },
4482 INTERNAL,
4483 { },
4484 { { 0, 0x1 } },
4485 },
4486 {
4487 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
4488 .u.insns_int = {
4489 BPF_LD_IMM64(R2, 0x0),
4490 BPF_LD_IMM64(R3, 0xffffffff80000000LL),
4491 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
4492 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4493 BPF_MOV32_IMM(R0, 2),
4494 BPF_EXIT_INSN(),
4495 BPF_MOV32_IMM(R0, 1),
4496 BPF_EXIT_INSN(),
4497 },
4498 INTERNAL,
4499 { },
4500 { { 0, 0x1 } },
4501 },
4502 {
4503 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
4504 .u.insns_int = {
4505 BPF_LD_IMM64(R2, 0x0),
4506 BPF_LD_IMM64(R3, 0xffffffff80008000LL),
4507 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
4508 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4509 BPF_MOV32_IMM(R0, 2),
4510 BPF_EXIT_INSN(),
4511 BPF_MOV32_IMM(R0, 1),
4512 BPF_EXIT_INSN(),
4513 },
4514 INTERNAL,
4515 { },
4516 { { 0, 0x1 } },
4517 },
cffc642d
MH		 4518 /* BPF_ALU | BPF_SUB | BPF_X */
4519 {
4520 "ALU_SUB_X: 3 - 1 = 2",
4521 .u.insns_int = {
4522 BPF_LD_IMM64(R0, 3),
4523 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4524 BPF_ALU32_REG(BPF_SUB, R0, R1),
4525 BPF_EXIT_INSN(),
4526 },
4527 INTERNAL,
4528 { },
4529 { { 0, 2 } },
4530 },
4531 {
4532 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
4533 .u.insns_int = {
56cbaa45
MH		 4534 BPF_LD_IMM64(R0, 4294967295U),
4535 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 4536 BPF_ALU32_REG(BPF_SUB, R0, R1),
4537 BPF_EXIT_INSN(),
4538 },
4539 INTERNAL,
4540 { },
4541 { { 0, 1 } },
4542 },
4543 {
4544 "ALU64_SUB_X: 3 - 1 = 2",
4545 .u.insns_int = {
4546 BPF_LD_IMM64(R0, 3),
4547 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4548 BPF_ALU64_REG(BPF_SUB, R0, R1),
4549 BPF_EXIT_INSN(),
4550 },
4551 INTERNAL,
4552 { },
4553 { { 0, 2 } },
4554 },
4555 {
4556 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
4557 .u.insns_int = {
56cbaa45
MH		 4558 BPF_LD_IMM64(R0, 4294967295U),
4559 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 4560 BPF_ALU64_REG(BPF_SUB, R0, R1),
4561 BPF_EXIT_INSN(),
4562 },
4563 INTERNAL,
4564 { },
4565 { { 0, 1 } },
4566 },
4567 /* BPF_ALU | BPF_SUB | BPF_K */
4568 {
4569 "ALU_SUB_K: 3 - 1 = 2",
4570 .u.insns_int = {
4571 BPF_LD_IMM64(R0, 3),
4572 BPF_ALU32_IMM(BPF_SUB, R0, 1),
4573 BPF_EXIT_INSN(),
4574 },
4575 INTERNAL,
4576 { },
4577 { { 0, 2 } },
4578 },
4579 {
4580 "ALU_SUB_K: 3 - 0 = 3",
4581 .u.insns_int = {
4582 BPF_LD_IMM64(R0, 3),
4583 BPF_ALU32_IMM(BPF_SUB, R0, 0),
4584 BPF_EXIT_INSN(),
4585 },
4586 INTERNAL,
4587 { },
4588 { { 0, 3 } },
4589 },
4590 {
4591 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
4592 .u.insns_int = {
56cbaa45
MH		 4593 BPF_LD_IMM64(R0, 4294967295U),
4594 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
cffc642d
MH		 4595 BPF_EXIT_INSN(),
4596 },
4597 INTERNAL,
4598 { },
4599 { { 0, 1 } },
4600 },
4601 {
4602 "ALU64_SUB_K: 3 - 1 = 2",
4603 .u.insns_int = {
4604 BPF_LD_IMM64(R0, 3),
4605 BPF_ALU64_IMM(BPF_SUB, R0, 1),
4606 BPF_EXIT_INSN(),
4607 },
4608 INTERNAL,
4609 { },
4610 { { 0, 2 } },
4611 },
4612 {
4613 "ALU64_SUB_K: 3 - 0 = 3",
4614 .u.insns_int = {
4615 BPF_LD_IMM64(R0, 3),
4616 BPF_ALU64_IMM(BPF_SUB, R0, 0),
4617 BPF_EXIT_INSN(),
4618 },
4619 INTERNAL,
4620 { },
4621 { { 0, 3 } },
4622 },
4623 {
4624 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
4625 .u.insns_int = {
56cbaa45
MH		 4626 BPF_LD_IMM64(R0, 4294967294U),
4627 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
cffc642d
MH		 4628 BPF_EXIT_INSN(),
4629 },
4630 INTERNAL,
4631 { },
4632 { { 0, -1 } },
4633 },
4634 {
4635 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
4636 .u.insns_int = {
4637 BPF_LD_IMM64(R0, 2147483646),
4638 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
4639 BPF_EXIT_INSN(),
4640 },
4641 INTERNAL,
4642 { },
4643 { { 0, -1 } },
4644 },
4645 /* BPF_ALU | BPF_MUL | BPF_X */
4646 {
4647 "ALU_MUL_X: 2 * 3 = 6",
4648 .u.insns_int = {
4649 BPF_LD_IMM64(R0, 2),
4650 BPF_ALU32_IMM(BPF_MOV, R1, 3),
4651 BPF_ALU32_REG(BPF_MUL, R0, R1),
4652 BPF_EXIT_INSN(),
4653 },
4654 INTERNAL,
4655 { },
4656 { { 0, 6 } },
4657 },
4658 {
4659 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
4660 .u.insns_int = {
4661 BPF_LD_IMM64(R0, 2),
4662 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
4663 BPF_ALU32_REG(BPF_MUL, R0, R1),
4664 BPF_EXIT_INSN(),
4665 },
4666 INTERNAL,
4667 { },
4668 { { 0, 0xFFFFFFF0 } },
4669 },
4670 {
4671 "ALU_MUL_X: -1 * -1 = 1",
4672 .u.insns_int = {
4673 BPF_LD_IMM64(R0, -1),
4674 BPF_ALU32_IMM(BPF_MOV, R1, -1),
4675 BPF_ALU32_REG(BPF_MUL, R0, R1),
4676 BPF_EXIT_INSN(),
4677 },
4678 INTERNAL,
4679 { },
4680 { { 0, 1 } },
4681 },
4682 {
4683 "ALU64_MUL_X: 2 * 3 = 6",
4684 .u.insns_int = {
4685 BPF_LD_IMM64(R0, 2),
4686 BPF_ALU32_IMM(BPF_MOV, R1, 3),
4687 BPF_ALU64_REG(BPF_MUL, R0, R1),
4688 BPF_EXIT_INSN(),
4689 },
4690 INTERNAL,
4691 { },
4692 { { 0, 6 } },
4693 },
4694 {
4695 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
4696 .u.insns_int = {
4697 BPF_LD_IMM64(R0, 1),
4698 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
4699 BPF_ALU64_REG(BPF_MUL, R0, R1),
4700 BPF_EXIT_INSN(),
4701 },
4702 INTERNAL,
4703 { },
4704 { { 0, 2147483647 } },
4705 },
faa57625
JA		 4706 {
4707 "ALU64_MUL_X: 64x64 multiply, low word",
4708 .u.insns_int = {
4709 BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
4710 BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
4711 BPF_ALU64_REG(BPF_MUL, R0, R1),
4712 BPF_EXIT_INSN(),
4713 },
4714 INTERNAL,
4715 { },
4716 { { 0, 0xe5618cf0 } }
4717 },
4718 {
4719 "ALU64_MUL_X: 64x64 multiply, high word",
4720 .u.insns_int = {
4721 BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
4722 BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
4723 BPF_ALU64_REG(BPF_MUL, R0, R1),
4724 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4725 BPF_EXIT_INSN(),
4726 },
4727 INTERNAL,
4728 { },
4729 { { 0, 0x2236d88f } }
4730 },
cffc642d
MH		 4731 /* BPF_ALU | BPF_MUL | BPF_K */
4732 {
4733 "ALU_MUL_K: 2 * 3 = 6",
4734 .u.insns_int = {
4735 BPF_LD_IMM64(R0, 2),
4736 BPF_ALU32_IMM(BPF_MUL, R0, 3),
4737 BPF_EXIT_INSN(),
4738 },
4739 INTERNAL,
4740 { },
4741 { { 0, 6 } },
4742 },
4743 {
4744 "ALU_MUL_K: 3 * 1 = 3",
4745 .u.insns_int = {
4746 BPF_LD_IMM64(R0, 3),
4747 BPF_ALU32_IMM(BPF_MUL, R0, 1),
4748 BPF_EXIT_INSN(),
4749 },
4750 INTERNAL,
4751 { },
4752 { { 0, 3 } },
4753 },
4754 {
4755 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
4756 .u.insns_int = {
4757 BPF_LD_IMM64(R0, 2),
4758 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
4759 BPF_EXIT_INSN(),
4760 },
4761 INTERNAL,
4762 { },
4763 { { 0, 0xFFFFFFF0 } },
4764 },
4765 {
4766 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
4767 .u.insns_int = {
4768 BPF_LD_IMM64(R2, 0x1),
4769 BPF_LD_IMM64(R3, 0x00000000ffffffff),
4770 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
4771 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4772 BPF_MOV32_IMM(R0, 2),
4773 BPF_EXIT_INSN(),
4774 BPF_MOV32_IMM(R0, 1),
4775 BPF_EXIT_INSN(),
4776 },
4777 INTERNAL,
4778 { },
4779 { { 0, 0x1 } },
4780 },
4781 {
4782 "ALU64_MUL_K: 2 * 3 = 6",
4783 .u.insns_int = {
4784 BPF_LD_IMM64(R0, 2),
4785 BPF_ALU64_IMM(BPF_MUL, R0, 3),
4786 BPF_EXIT_INSN(),
4787 },
4788 INTERNAL,
4789 { },
4790 { { 0, 6 } },
4791 },
4792 {
4793 "ALU64_MUL_K: 3 * 1 = 3",
4794 .u.insns_int = {
4795 BPF_LD_IMM64(R0, 3),
4796 BPF_ALU64_IMM(BPF_MUL, R0, 1),
4797 BPF_EXIT_INSN(),
4798 },
4799 INTERNAL,
4800 { },
4801 { { 0, 3 } },
4802 },
4803 {
4804 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
4805 .u.insns_int = {
4806 BPF_LD_IMM64(R0, 1),
4807 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
4808 BPF_EXIT_INSN(),
4809 },
4810 INTERNAL,
4811 { },
4812 { { 0, 2147483647 } },
4813 },
4814 {
4815 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
4816 .u.insns_int = {
4817 BPF_LD_IMM64(R0, 1),
4818 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
4819 BPF_EXIT_INSN(),
4820 },
4821 INTERNAL,
4822 { },
4823 { { 0, -2147483647 } },
4824 },
4825 {
4826 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
4827 .u.insns_int = {
4828 BPF_LD_IMM64(R2, 0x1),
56cbaa45 4829 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 4830 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
4831 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4832 BPF_MOV32_IMM(R0, 2),
4833 BPF_EXIT_INSN(),
4834 BPF_MOV32_IMM(R0, 1),
4835 BPF_EXIT_INSN(),
4836 },
4837 INTERNAL,
4838 { },
4839 { { 0, 0x1 } },
4840 },
faa57625
JA		 4841 {
4842 "ALU64_MUL_K: 64x32 multiply, low word",
4843 .u.insns_int = {
4844 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4845 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
4846 BPF_EXIT_INSN(),
4847 },
4848 INTERNAL,
4849 { },
4850 { { 0, 0xe242d208 } }
4851 },
4852 {
4853 "ALU64_MUL_K: 64x32 multiply, high word",
4854 .u.insns_int = {
4855 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4856 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
4857 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4858 BPF_EXIT_INSN(),
4859 },
4860 INTERNAL,
4861 { },
4862 { { 0, 0xc28f5c28 } }
4863 },
cffc642d
MH		 4864 /* BPF_ALU | BPF_DIV | BPF_X */
4865 {
4866 "ALU_DIV_X: 6 / 2 = 3",
4867 .u.insns_int = {
4868 BPF_LD_IMM64(R0, 6),
4869 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4870 BPF_ALU32_REG(BPF_DIV, R0, R1),
4871 BPF_EXIT_INSN(),
4872 },
4873 INTERNAL,
4874 { },
4875 { { 0, 3 } },
4876 },
4877 {
4878 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
4879 .u.insns_int = {
56cbaa45
MH		 4880 BPF_LD_IMM64(R0, 4294967295U),
4881 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 4882 BPF_ALU32_REG(BPF_DIV, R0, R1),
4883 BPF_EXIT_INSN(),
4884 },
4885 INTERNAL,
4886 { },
4887 { { 0, 1 } },
4888 },
4889 {
4890 "ALU64_DIV_X: 6 / 2 = 3",
4891 .u.insns_int = {
4892 BPF_LD_IMM64(R0, 6),
4893 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4894 BPF_ALU64_REG(BPF_DIV, R0, R1),
4895 BPF_EXIT_INSN(),
4896 },
4897 INTERNAL,
4898 { },
4899 { { 0, 3 } },
4900 },
4901 {
4902 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
4903 .u.insns_int = {
4904 BPF_LD_IMM64(R0, 2147483647),
4905 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
4906 BPF_ALU64_REG(BPF_DIV, R0, R1),
4907 BPF_EXIT_INSN(),
4908 },
4909 INTERNAL,
4910 { },
4911 { { 0, 1 } },
4912 },
4913 {
4914 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
4915 .u.insns_int = {
56cbaa45
MH		 4916 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
4917 BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
4918 BPF_LD_IMM64(R3, 0x0000000000000001LL),
cffc642d
MH		 4919 BPF_ALU64_REG(BPF_DIV, R2, R4),
4920 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4921 BPF_MOV32_IMM(R0, 2),
4922 BPF_EXIT_INSN(),
4923 BPF_MOV32_IMM(R0, 1),
4924 BPF_EXIT_INSN(),
4925 },
4926 INTERNAL,
4927 { },
4928 { { 0, 0x1 } },
4929 },
4930 /* BPF_ALU | BPF_DIV | BPF_K */
4931 {
4932 "ALU_DIV_K: 6 / 2 = 3",
4933 .u.insns_int = {
4934 BPF_LD_IMM64(R0, 6),
4935 BPF_ALU32_IMM(BPF_DIV, R0, 2),
4936 BPF_EXIT_INSN(),
4937 },
4938 INTERNAL,
4939 { },
4940 { { 0, 3 } },
4941 },
4942 {
4943 "ALU_DIV_K: 3 / 1 = 3",
4944 .u.insns_int = {
4945 BPF_LD_IMM64(R0, 3),
4946 BPF_ALU32_IMM(BPF_DIV, R0, 1),
4947 BPF_EXIT_INSN(),
4948 },
4949 INTERNAL,
4950 { },
4951 { { 0, 3 } },
4952 },
4953 {
4954 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
4955 .u.insns_int = {
56cbaa45
MH		 4956 BPF_LD_IMM64(R0, 4294967295U),
4957 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
cffc642d
MH		 4958 BPF_EXIT_INSN(),
4959 },
4960 INTERNAL,
4961 { },
4962 { { 0, 1 } },
4963 },
4964 {
4965 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
4966 .u.insns_int = {
56cbaa45 4967 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
cffc642d
MH		 4968 BPF_LD_IMM64(R3, 0x1UL),
4969 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
4970 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4971 BPF_MOV32_IMM(R0, 2),
4972 BPF_EXIT_INSN(),
4973 BPF_MOV32_IMM(R0, 1),
4974 BPF_EXIT_INSN(),
4975 },
4976 INTERNAL,
4977 { },
4978 { { 0, 0x1 } },
4979 },
4980 {
4981 "ALU64_DIV_K: 6 / 2 = 3",
4982 .u.insns_int = {
4983 BPF_LD_IMM64(R0, 6),
4984 BPF_ALU64_IMM(BPF_DIV, R0, 2),
4985 BPF_EXIT_INSN(),
4986 },
4987 INTERNAL,
4988 { },
4989 { { 0, 3 } },
4990 },
4991 {
4992 "ALU64_DIV_K: 3 / 1 = 3",
4993 .u.insns_int = {
4994 BPF_LD_IMM64(R0, 3),
4995 BPF_ALU64_IMM(BPF_DIV, R0, 1),
4996 BPF_EXIT_INSN(),
4997 },
4998 INTERNAL,
4999 { },
5000 { { 0, 3 } },
5001 },
5002 {
5003 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
5004 .u.insns_int = {
5005 BPF_LD_IMM64(R0, 2147483647),
5006 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
5007 BPF_EXIT_INSN(),
5008 },
5009 INTERNAL,
5010 { },
5011 { { 0, 1 } },
5012 },
5013 {
5014 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5015 .u.insns_int = {
56cbaa45
MH		 5016 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5017 BPF_LD_IMM64(R3, 0x0000000000000001LL),
cffc642d
MH		 5018 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
5019 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5020 BPF_MOV32_IMM(R0, 2),
5021 BPF_EXIT_INSN(),
5022 BPF_MOV32_IMM(R0, 1),
5023 BPF_EXIT_INSN(),
5024 },
5025 INTERNAL,
5026 { },
5027 { { 0, 0x1 } },
5028 },
5029 /* BPF_ALU | BPF_MOD | BPF_X */
5030 {
5031 "ALU_MOD_X: 3 % 2 = 1",
5032 .u.insns_int = {
5033 BPF_LD_IMM64(R0, 3),
5034 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5035 BPF_ALU32_REG(BPF_MOD, R0, R1),
5036 BPF_EXIT_INSN(),
5037 },
5038 INTERNAL,
5039 { },
5040 { { 0, 1 } },
5041 },
5042 {
5043 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
5044 .u.insns_int = {
56cbaa45
MH		 5045 BPF_LD_IMM64(R0, 4294967295U),
5046 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
cffc642d
MH		 5047 BPF_ALU32_REG(BPF_MOD, R0, R1),
5048 BPF_EXIT_INSN(),
5049 },
5050 INTERNAL,
5051 { },
5052 { { 0, 2 } },
5053 },
5054 {
5055 "ALU64_MOD_X: 3 % 2 = 1",
5056 .u.insns_int = {
5057 BPF_LD_IMM64(R0, 3),
5058 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5059 BPF_ALU64_REG(BPF_MOD, R0, R1),
5060 BPF_EXIT_INSN(),
5061 },
5062 INTERNAL,
5063 { },
5064 { { 0, 1 } },
5065 },
5066 {
5067 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
5068 .u.insns_int = {
5069 BPF_LD_IMM64(R0, 2147483647),
5070 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
5071 BPF_ALU64_REG(BPF_MOD, R0, R1),
5072 BPF_EXIT_INSN(),
5073 },
5074 INTERNAL,
5075 { },
5076 { { 0, 2 } },
5077 },
5078 /* BPF_ALU | BPF_MOD | BPF_K */
5079 {
5080 "ALU_MOD_K: 3 % 2 = 1",
5081 .u.insns_int = {
5082 BPF_LD_IMM64(R0, 3),
5083 BPF_ALU32_IMM(BPF_MOD, R0, 2),
5084 BPF_EXIT_INSN(),
5085 },
5086 INTERNAL,
5087 { },
5088 { { 0, 1 } },
5089 },
5090 {
5091 "ALU_MOD_K: 3 % 1 = 0",
5092 .u.insns_int = {
5093 BPF_LD_IMM64(R0, 3),
5094 BPF_ALU32_IMM(BPF_MOD, R0, 1),
5095 BPF_EXIT_INSN(),
5096 },
5097 INTERNAL,
5098 { },
5099 { { 0, 0 } },
5100 },
5101 {
5102 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
5103 .u.insns_int = {
56cbaa45
MH		 5104 BPF_LD_IMM64(R0, 4294967295U),
5105 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
cffc642d
MH		 5106 BPF_EXIT_INSN(),
5107 },
5108 INTERNAL,
5109 { },
5110 { { 0, 2 } },
5111 },
5112 {
5113 "ALU64_MOD_K: 3 % 2 = 1",
5114 .u.insns_int = {
5115 BPF_LD_IMM64(R0, 3),
5116 BPF_ALU64_IMM(BPF_MOD, R0, 2),
5117 BPF_EXIT_INSN(),
5118 },
5119 INTERNAL,
5120 { },
5121 { { 0, 1 } },
5122 },
5123 {
5124 "ALU64_MOD_K: 3 % 1 = 0",
5125 .u.insns_int = {
5126 BPF_LD_IMM64(R0, 3),
5127 BPF_ALU64_IMM(BPF_MOD, R0, 1),
5128 BPF_EXIT_INSN(),
5129 },
5130 INTERNAL,
5131 { },
5132 { { 0, 0 } },
5133 },
5134 {
5135 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
5136 .u.insns_int = {
5137 BPF_LD_IMM64(R0, 2147483647),
5138 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
5139 BPF_EXIT_INSN(),
5140 },
5141 INTERNAL,
5142 { },
5143 { { 0, 2 } },
5144 },
5145 /* BPF_ALU | BPF_AND | BPF_X */
5146 {
5147 "ALU_AND_X: 3 & 2 = 2",
5148 .u.insns_int = {
5149 BPF_LD_IMM64(R0, 3),
5150 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5151 BPF_ALU32_REG(BPF_AND, R0, R1),
5152 BPF_EXIT_INSN(),
5153 },
5154 INTERNAL,
5155 { },
5156 { { 0, 2 } },
5157 },
5158 {
5159 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
5160 .u.insns_int = {
5161 BPF_LD_IMM64(R0, 0xffffffff),
5162 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5163 BPF_ALU32_REG(BPF_AND, R0, R1),
5164 BPF_EXIT_INSN(),
5165 },
5166 INTERNAL,
5167 { },
5168 { { 0, 0xffffffff } },
5169 },
5170 {
5171 "ALU64_AND_X: 3 & 2 = 2",
5172 .u.insns_int = {
5173 BPF_LD_IMM64(R0, 3),
5174 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5175 BPF_ALU64_REG(BPF_AND, R0, R1),
5176 BPF_EXIT_INSN(),
5177 },
5178 INTERNAL,
5179 { },
5180 { { 0, 2 } },
5181 },
5182 {
5183 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
5184 .u.insns_int = {
5185 BPF_LD_IMM64(R0, 0xffffffff),
5186 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5187 BPF_ALU64_REG(BPF_AND, R0, R1),
5188 BPF_EXIT_INSN(),
5189 },
5190 INTERNAL,
5191 { },
5192 { { 0, 0xffffffff } },
5193 },
5194 /* BPF_ALU | BPF_AND | BPF_K */
5195 {
5196 "ALU_AND_K: 3 & 2 = 2",
5197 .u.insns_int = {
5198 BPF_LD_IMM64(R0, 3),
5199 BPF_ALU32_IMM(BPF_AND, R0, 2),
5200 BPF_EXIT_INSN(),
5201 },
5202 INTERNAL,
5203 { },
5204 { { 0, 2 } },
5205 },
5206 {
5207 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
5208 .u.insns_int = {
5209 BPF_LD_IMM64(R0, 0xffffffff),
5210 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
5211 BPF_EXIT_INSN(),
5212 },
5213 INTERNAL,
5214 { },
5215 { { 0, 0xffffffff } },
5216 },
ba89bcf7
JA		 5217 {
5218 "ALU_AND_K: Small immediate",
5219 .u.insns_int = {
5220 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5221 BPF_ALU32_IMM(BPF_AND, R0, 15),
5222 BPF_EXIT_INSN(),
5223 },
5224 INTERNAL,
5225 { },
5226 { { 0, 4 } }
5227 },
5228 {
5229 "ALU_AND_K: Large immediate",
5230 .u.insns_int = {
5231 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
5232 BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
5233 BPF_EXIT_INSN(),
5234 },
5235 INTERNAL,
5236 { },
5237 { { 0, 0xa1b2c3d4 } }
5238 },
5239 {
5240 "ALU_AND_K: Zero extension",
5241 .u.insns_int = {
5242 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5243 BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
5244 BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
5245 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5246 BPF_MOV32_IMM(R0, 2),
5247 BPF_EXIT_INSN(),
5248 BPF_MOV32_IMM(R0, 1),
5249 BPF_EXIT_INSN(),
5250 },
5251 INTERNAL,
5252 { },
5253 { { 0, 1 } }
5254 },
cffc642d
MH		 5255 {
5256 "ALU64_AND_K: 3 & 2 = 2",
5257 .u.insns_int = {
5258 BPF_LD_IMM64(R0, 3),
5259 BPF_ALU64_IMM(BPF_AND, R0, 2),
5260 BPF_EXIT_INSN(),
5261 },
5262 INTERNAL,
5263 { },
5264 { { 0, 2 } },
5265 },
5266 {
5267 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
5268 .u.insns_int = {
5269 BPF_LD_IMM64(R0, 0xffffffff),
5270 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
5271 BPF_EXIT_INSN(),
5272 },
5273 INTERNAL,
5274 { },
5275 { { 0, 0xffffffff } },
5276 },
5277 {
e92c813b 5278 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
cffc642d 5279 .u.insns_int = {
56cbaa45
MH		 5280 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5281 BPF_LD_IMM64(R3, 0x0000000000000000LL),
cffc642d
MH		 5282 BPF_ALU64_IMM(BPF_AND, R2, 0x0),
5283 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5284 BPF_MOV32_IMM(R0, 2),
5285 BPF_EXIT_INSN(),
5286 BPF_MOV32_IMM(R0, 1),
5287 BPF_EXIT_INSN(),
5288 },
5289 INTERNAL,
5290 { },
5291 { { 0, 0x1 } },
5292 },
5293 {
e92c813b 5294 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
cffc642d 5295 .u.insns_int = {
56cbaa45
MH		 5296 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5297 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 5298 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
5299 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5300 BPF_MOV32_IMM(R0, 2),
5301 BPF_EXIT_INSN(),
5302 BPF_MOV32_IMM(R0, 1),
5303 BPF_EXIT_INSN(),
5304 },
5305 INTERNAL,
5306 { },
5307 { { 0, 0x1 } },
5308 },
5309 {
5310 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
5311 .u.insns_int = {
56cbaa45
MH		 5312 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5313 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5314 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
5315 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5316 BPF_MOV32_IMM(R0, 2),
5317 BPF_EXIT_INSN(),
5318 BPF_MOV32_IMM(R0, 1),
5319 BPF_EXIT_INSN(),
5320 },
5321 INTERNAL,
5322 { },
5323 { { 0, 0x1 } },
5324 },
ba89bcf7
JA		 5325 {
5326 "ALU64_AND_K: Sign extension 1",
5327 .u.insns_int = {
5328 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5329 BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
5330 BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
5331 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5332 BPF_MOV32_IMM(R0, 2),
5333 BPF_EXIT_INSN(),
5334 BPF_MOV32_IMM(R0, 1),
5335 BPF_EXIT_INSN(),
5336 },
5337 INTERNAL,
5338 { },
5339 { { 0, 1 } }
5340 },
5341 {
5342 "ALU64_AND_K: Sign extension 2",
5343 .u.insns_int = {
5344 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5345 BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
5346 BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
5347 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5348 BPF_MOV32_IMM(R0, 2),
5349 BPF_EXIT_INSN(),
5350 BPF_MOV32_IMM(R0, 1),
5351 BPF_EXIT_INSN(),
5352 },
5353 INTERNAL,
5354 { },
5355 { { 0, 1 } }
5356 },
cffc642d
MH		 5357 /* BPF_ALU | BPF_OR | BPF_X */
5358 {
5359 "ALU_OR_X: 1 | 2 = 3",
5360 .u.insns_int = {
5361 BPF_LD_IMM64(R0, 1),
5362 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5363 BPF_ALU32_REG(BPF_OR, R0, R1),
5364 BPF_EXIT_INSN(),
5365 },
5366 INTERNAL,
5367 { },
5368 { { 0, 3 } },
5369 },
5370 {
5371 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
5372 .u.insns_int = {
5373 BPF_LD_IMM64(R0, 0),
5374 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5375 BPF_ALU32_REG(BPF_OR, R0, R1),
5376 BPF_EXIT_INSN(),
5377 },
5378 INTERNAL,
5379 { },
5380 { { 0, 0xffffffff } },
5381 },
5382 {
5383 "ALU64_OR_X: 1 | 2 = 3",
5384 .u.insns_int = {
5385 BPF_LD_IMM64(R0, 1),
5386 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5387 BPF_ALU64_REG(BPF_OR, R0, R1),
5388 BPF_EXIT_INSN(),
5389 },
5390 INTERNAL,
5391 { },
5392 { { 0, 3 } },
5393 },
5394 {
5395 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
5396 .u.insns_int = {
5397 BPF_LD_IMM64(R0, 0),
5398 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5399 BPF_ALU64_REG(BPF_OR, R0, R1),
5400 BPF_EXIT_INSN(),
5401 },
5402 INTERNAL,
5403 { },
5404 { { 0, 0xffffffff } },
5405 },
5406 /* BPF_ALU | BPF_OR | BPF_K */
5407 {
5408 "ALU_OR_K: 1 | 2 = 3",
5409 .u.insns_int = {
5410 BPF_LD_IMM64(R0, 1),
5411 BPF_ALU32_IMM(BPF_OR, R0, 2),
5412 BPF_EXIT_INSN(),
5413 },
5414 INTERNAL,
5415 { },
5416 { { 0, 3 } },
5417 },
5418 {
5419 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
5420 .u.insns_int = {
5421 BPF_LD_IMM64(R0, 0),
5422 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
5423 BPF_EXIT_INSN(),
5424 },
5425 INTERNAL,
5426 { },
5427 { { 0, 0xffffffff } },
5428 },
ba89bcf7
JA		 5429 {
5430 "ALU_OR_K: Small immediate",
5431 .u.insns_int = {
5432 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5433 BPF_ALU32_IMM(BPF_OR, R0, 1),
5434 BPF_EXIT_INSN(),
5435 },
5436 INTERNAL,
5437 { },
5438 { { 0, 0x01020305 } }
5439 },
5440 {
5441 "ALU_OR_K: Large immediate",
5442 .u.insns_int = {
5443 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5444 BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
5445 BPF_EXIT_INSN(),
5446 },
5447 INTERNAL,
5448 { },
5449 { { 0, 0xa1b2c3d4 } }
5450 },
5451 {
5452 "ALU_OR_K: Zero extension",
5453 .u.insns_int = {
5454 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5455 BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
5456 BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
5457 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5458 BPF_MOV32_IMM(R0, 2),
5459 BPF_EXIT_INSN(),
5460 BPF_MOV32_IMM(R0, 1),
5461 BPF_EXIT_INSN(),
5462 },
5463 INTERNAL,
5464 { },
5465 { { 0, 1 } }
5466 },
cffc642d
MH		 5467 {
5468 "ALU64_OR_K: 1 | 2 = 3",
5469 .u.insns_int = {
5470 BPF_LD_IMM64(R0, 1),
5471 BPF_ALU64_IMM(BPF_OR, R0, 2),
5472 BPF_EXIT_INSN(),
5473 },
5474 INTERNAL,
5475 { },
5476 { { 0, 3 } },
5477 },
5478 {
5479 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
5480 .u.insns_int = {
5481 BPF_LD_IMM64(R0, 0),
5482 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
5483 BPF_EXIT_INSN(),
5484 },
5485 INTERNAL,
5486 { },
5487 { { 0, 0xffffffff } },
5488 },
5489 {
e92c813b 5490 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
cffc642d 5491 .u.insns_int = {
56cbaa45
MH		 5492 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5493 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 5494 BPF_ALU64_IMM(BPF_OR, R2, 0x0),
5495 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5496 BPF_MOV32_IMM(R0, 2),
5497 BPF_EXIT_INSN(),
5498 BPF_MOV32_IMM(R0, 1),
5499 BPF_EXIT_INSN(),
5500 },
5501 INTERNAL,
5502 { },
5503 { { 0, 0x1 } },
5504 },
5505 {
5506 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
5507 .u.insns_int = {
56cbaa45
MH		 5508 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5509 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5510 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
5511 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5512 BPF_MOV32_IMM(R0, 2),
5513 BPF_EXIT_INSN(),
5514 BPF_MOV32_IMM(R0, 1),
5515 BPF_EXIT_INSN(),
5516 },
5517 INTERNAL,
5518 { },
5519 { { 0, 0x1 } },
5520 },
5521 {
5522 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
5523 .u.insns_int = {
56cbaa45
MH		 5524 BPF_LD_IMM64(R2, 0x0000000000000000LL),
5525 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5526 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
5527 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5528 BPF_MOV32_IMM(R0, 2),
5529 BPF_EXIT_INSN(),
5530 BPF_MOV32_IMM(R0, 1),
5531 BPF_EXIT_INSN(),
5532 },
5533 INTERNAL,
5534 { },
5535 { { 0, 0x1 } },
5536 },
ba89bcf7
JA		 5537 {
5538 "ALU64_OR_K: Sign extension 1",
5539 .u.insns_int = {
5540 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5541 BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
5542 BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
5543 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5544 BPF_MOV32_IMM(R0, 2),
5545 BPF_EXIT_INSN(),
5546 BPF_MOV32_IMM(R0, 1),
5547 BPF_EXIT_INSN(),
5548 },
5549 INTERNAL,
5550 { },
5551 { { 0, 1 } }
5552 },
5553 {
5554 "ALU64_OR_K: Sign extension 2",
5555 .u.insns_int = {
5556 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5557 BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
5558 BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
5559 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5560 BPF_MOV32_IMM(R0, 2),
5561 BPF_EXIT_INSN(),
5562 BPF_MOV32_IMM(R0, 1),
5563 BPF_EXIT_INSN(),
5564 },
5565 INTERNAL,
5566 { },
5567 { { 0, 1 } }
5568 },
cffc642d
MH		 5569 /* BPF_ALU | BPF_XOR | BPF_X */
5570 {
5571 "ALU_XOR_X: 5 ^ 6 = 3",
5572 .u.insns_int = {
5573 BPF_LD_IMM64(R0, 5),
5574 BPF_ALU32_IMM(BPF_MOV, R1, 6),
5575 BPF_ALU32_REG(BPF_XOR, R0, R1),
5576 BPF_EXIT_INSN(),
5577 },
5578 INTERNAL,
5579 { },
5580 { { 0, 3 } },
5581 },
5582 {
5583 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
5584 .u.insns_int = {
5585 BPF_LD_IMM64(R0, 1),
5586 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5587 BPF_ALU32_REG(BPF_XOR, R0, R1),
5588 BPF_EXIT_INSN(),
5589 },
5590 INTERNAL,
5591 { },
5592 { { 0, 0xfffffffe } },
5593 },
5594 {
5595 "ALU64_XOR_X: 5 ^ 6 = 3",
5596 .u.insns_int = {
5597 BPF_LD_IMM64(R0, 5),
5598 BPF_ALU32_IMM(BPF_MOV, R1, 6),
5599 BPF_ALU64_REG(BPF_XOR, R0, R1),
5600 BPF_EXIT_INSN(),
5601 },
5602 INTERNAL,
5603 { },
5604 { { 0, 3 } },
5605 },
5606 {
5607 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
5608 .u.insns_int = {
5609 BPF_LD_IMM64(R0, 1),
5610 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5611 BPF_ALU64_REG(BPF_XOR, R0, R1),
5612 BPF_EXIT_INSN(),
5613 },
5614 INTERNAL,
5615 { },
5616 { { 0, 0xfffffffe } },
5617 },
5618 /* BPF_ALU | BPF_XOR | BPF_K */
5619 {
5620 "ALU_XOR_K: 5 ^ 6 = 3",
5621 .u.insns_int = {
5622 BPF_LD_IMM64(R0, 5),
5623 BPF_ALU32_IMM(BPF_XOR, R0, 6),
5624 BPF_EXIT_INSN(),
5625 },
5626 INTERNAL,
5627 { },
5628 { { 0, 3 } },
5629 },
5630 {
5631 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
5632 .u.insns_int = {
5633 BPF_LD_IMM64(R0, 1),
5634 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
5635 BPF_EXIT_INSN(),
5636 },
5637 INTERNAL,
5638 { },
5639 { { 0, 0xfffffffe } },
5640 },
ba89bcf7
JA		 5641 {
5642 "ALU_XOR_K: Small immediate",
5643 .u.insns_int = {
5644 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5645 BPF_ALU32_IMM(BPF_XOR, R0, 15),
5646 BPF_EXIT_INSN(),
5647 },
5648 INTERNAL,
5649 { },
5650 { { 0, 0x0102030b } }
5651 },
5652 {
5653 "ALU_XOR_K: Large immediate",
5654 .u.insns_int = {
5655 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
5656 BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
5657 BPF_EXIT_INSN(),
5658 },
5659 INTERNAL,
5660 { },
5661 { { 0, 0x5e4d3c2b } }
5662 },
5663 {
5664 "ALU_XOR_K: Zero extension",
5665 .u.insns_int = {
5666 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5667 BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
5668 BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
5669 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5670 BPF_MOV32_IMM(R0, 2),
5671 BPF_EXIT_INSN(),
5672 BPF_MOV32_IMM(R0, 1),
5673 BPF_EXIT_INSN(),
5674 },
5675 INTERNAL,
5676 { },
5677 { { 0, 1 } }
5678 },
cffc642d
MH		 5679 {
5680 "ALU64_XOR_K: 5 ^ 6 = 3",
5681 .u.insns_int = {
5682 BPF_LD_IMM64(R0, 5),
5683 BPF_ALU64_IMM(BPF_XOR, R0, 6),
5684 BPF_EXIT_INSN(),
5685 },
5686 INTERNAL,
5687 { },
5688 { { 0, 3 } },
5689 },
5690 {
e92c813b 5691 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
cffc642d
MH		 5692 .u.insns_int = {
5693 BPF_LD_IMM64(R0, 1),
5694 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
5695 BPF_EXIT_INSN(),
5696 },
5697 INTERNAL,
5698 { },
5699 { { 0, 0xfffffffe } },
5700 },
5701 {
5702 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
5703 .u.insns_int = {
56cbaa45
MH		 5704 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5705 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 5706 BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
5707 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5708 BPF_MOV32_IMM(R0, 2),
5709 BPF_EXIT_INSN(),
5710 BPF_MOV32_IMM(R0, 1),
5711 BPF_EXIT_INSN(),
5712 },
5713 INTERNAL,
5714 { },
5715 { { 0, 0x1 } },
5716 },
5717 {
5718 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
5719 .u.insns_int = {
56cbaa45
MH		 5720 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5721 BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
cffc642d
MH		 5722 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
5723 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5724 BPF_MOV32_IMM(R0, 2),
5725 BPF_EXIT_INSN(),
5726 BPF_MOV32_IMM(R0, 1),
5727 BPF_EXIT_INSN(),
5728 },
5729 INTERNAL,
5730 { },
5731 { { 0, 0x1 } },
5732 },
5733 {
5734 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
5735 .u.insns_int = {
56cbaa45
MH		 5736 BPF_LD_IMM64(R2, 0x0000000000000000LL),
5737 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5738 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
5739 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5740 BPF_MOV32_IMM(R0, 2),
5741 BPF_EXIT_INSN(),
5742 BPF_MOV32_IMM(R0, 1),
5743 BPF_EXIT_INSN(),
5744 },
5745 INTERNAL,
5746 { },
5747 { { 0, 0x1 } },
5748 },
ba89bcf7
JA		 5749 {
5750 "ALU64_XOR_K: Sign extension 1",
5751 .u.insns_int = {
5752 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5753 BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
5754 BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
5755 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5756 BPF_MOV32_IMM(R0, 2),
5757 BPF_EXIT_INSN(),
5758 BPF_MOV32_IMM(R0, 1),
5759 BPF_EXIT_INSN(),
5760 },
5761 INTERNAL,
5762 { },
5763 { { 0, 1 } }
5764 },
5765 {
5766 "ALU64_XOR_K: Sign extension 2",
5767 .u.insns_int = {
5768 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5769 BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
5770 BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
5771 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5772 BPF_MOV32_IMM(R0, 2),
5773 BPF_EXIT_INSN(),
5774 BPF_MOV32_IMM(R0, 1),
5775 BPF_EXIT_INSN(),
5776 },
5777 INTERNAL,
5778 { },
5779 { { 0, 1 } }
5780 },
cffc642d
MH		 5781 /* BPF_ALU | BPF_LSH | BPF_X */
5782 {
5783 "ALU_LSH_X: 1 << 1 = 2",
5784 .u.insns_int = {
5785 BPF_LD_IMM64(R0, 1),
5786 BPF_ALU32_IMM(BPF_MOV, R1, 1),
5787 BPF_ALU32_REG(BPF_LSH, R0, R1),
5788 BPF_EXIT_INSN(),
5789 },
5790 INTERNAL,
5791 { },
5792 { { 0, 2 } },
5793 },
5794 {
5795 "ALU_LSH_X: 1 << 31 = 0x80000000",
5796 .u.insns_int = {
5797 BPF_LD_IMM64(R0, 1),
5798 BPF_ALU32_IMM(BPF_MOV, R1, 31),
5799 BPF_ALU32_REG(BPF_LSH, R0, R1),
5800 BPF_EXIT_INSN(),
5801 },
5802 INTERNAL,
5803 { },
5804 { { 0, 0x80000000 } },
5805 },
0f2fca1a
JA		 5806 {
5807 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
5808 .u.insns_int = {
5809 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
5810 BPF_ALU32_IMM(BPF_MOV, R1, 12),
5811 BPF_ALU32_REG(BPF_LSH, R0, R1),
5812 BPF_EXIT_INSN(),
5813 },
5814 INTERNAL,
5815 { },
5816 { { 0, 0x45678000 } }
5817 },
cffc642d
MH		 5818 {
5819 "ALU64_LSH_X: 1 << 1 = 2",
5820 .u.insns_int = {
5821 BPF_LD_IMM64(R0, 1),
5822 BPF_ALU32_IMM(BPF_MOV, R1, 1),
5823 BPF_ALU64_REG(BPF_LSH, R0, R1),
5824 BPF_EXIT_INSN(),
5825 },
5826 INTERNAL,
5827 { },
5828 { { 0, 2 } },
5829 },
5830 {
5831 "ALU64_LSH_X: 1 << 31 = 0x80000000",
5832 .u.insns_int = {
5833 BPF_LD_IMM64(R0, 1),
5834 BPF_ALU32_IMM(BPF_MOV, R1, 31),
5835 BPF_ALU64_REG(BPF_LSH, R0, R1),
5836 BPF_EXIT_INSN(),
5837 },
5838 INTERNAL,
5839 { },
5840 { { 0, 0x80000000 } },
5841 },
3b9890ef
JA		 5842 {
5843 "ALU64_LSH_X: Shift < 32, low word",
5844 .u.insns_int = {
5845 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5846 BPF_ALU32_IMM(BPF_MOV, R1, 12),
5847 BPF_ALU64_REG(BPF_LSH, R0, R1),
5848 BPF_EXIT_INSN(),
5849 },
5850 INTERNAL,
5851 { },
5852 { { 0, 0xbcdef000 } }
5853 },
5854 {
5855 "ALU64_LSH_X: Shift < 32, high word",
5856 .u.insns_int = {
5857 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5858 BPF_ALU32_IMM(BPF_MOV, R1, 12),
5859 BPF_ALU64_REG(BPF_LSH, R0, R1),
5860 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5861 BPF_EXIT_INSN(),
5862 },
5863 INTERNAL,
5864 { },
5865 { { 0, 0x3456789a } }
5866 },
5867 {
5868 "ALU64_LSH_X: Shift > 32, low word",
5869 .u.insns_int = {
5870 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5871 BPF_ALU32_IMM(BPF_MOV, R1, 36),
5872 BPF_ALU64_REG(BPF_LSH, R0, R1),
5873 BPF_EXIT_INSN(),
5874 },
5875 INTERNAL,
5876 { },
5877 { { 0, 0 } }
5878 },
5879 {
5880 "ALU64_LSH_X: Shift > 32, high word",
5881 .u.insns_int = {
5882 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5883 BPF_ALU32_IMM(BPF_MOV, R1, 36),
5884 BPF_ALU64_REG(BPF_LSH, R0, R1),
5885 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5886 BPF_EXIT_INSN(),
5887 },
5888 INTERNAL,
5889 { },
5890 { { 0, 0x9abcdef0 } }
5891 },
5892 {
5893 "ALU64_LSH_X: Shift == 32, low word",
5894 .u.insns_int = {
5895 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5896 BPF_ALU32_IMM(BPF_MOV, R1, 32),
5897 BPF_ALU64_REG(BPF_LSH, R0, R1),
5898 BPF_EXIT_INSN(),
5899 },
5900 INTERNAL,
5901 { },
5902 { { 0, 0 } }
5903 },
5904 {
5905 "ALU64_LSH_X: Shift == 32, high word",
5906 .u.insns_int = {
5907 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5908 BPF_ALU32_IMM(BPF_MOV, R1, 32),
5909 BPF_ALU64_REG(BPF_LSH, R0, R1),
5910 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5911 BPF_EXIT_INSN(),
5912 },
5913 INTERNAL,
5914 { },
5915 { { 0, 0x89abcdef } }
5916 },
5917 {
5918 "ALU64_LSH_X: Zero shift, low word",
5919 .u.insns_int = {
5920 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5921 BPF_ALU32_IMM(BPF_MOV, R1, 0),
5922 BPF_ALU64_REG(BPF_LSH, R0, R1),
5923 BPF_EXIT_INSN(),
5924 },
5925 INTERNAL,
5926 { },
5927 { { 0, 0x89abcdef } }
5928 },
5929 {
5930 "ALU64_LSH_X: Zero shift, high word",
5931 .u.insns_int = {
5932 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5933 BPF_ALU32_IMM(BPF_MOV, R1, 0),
5934 BPF_ALU64_REG(BPF_LSH, R0, R1),
5935 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5936 BPF_EXIT_INSN(),
5937 },
5938 INTERNAL,
5939 { },
5940 { { 0, 0x01234567 } }
5941 },
cffc642d
MH		 5942 /* BPF_ALU | BPF_LSH | BPF_K */
5943 {
5944 "ALU_LSH_K: 1 << 1 = 2",
5945 .u.insns_int = {
5946 BPF_LD_IMM64(R0, 1),
5947 BPF_ALU32_IMM(BPF_LSH, R0, 1),
5948 BPF_EXIT_INSN(),
5949 },
5950 INTERNAL,
5951 { },
5952 { { 0, 2 } },
5953 },
5954 {
5955 "ALU_LSH_K: 1 << 31 = 0x80000000",
5956 .u.insns_int = {
5957 BPF_LD_IMM64(R0, 1),
5958 BPF_ALU32_IMM(BPF_LSH, R0, 31),
5959 BPF_EXIT_INSN(),
5960 },
5961 INTERNAL,
5962 { },
5963 { { 0, 0x80000000 } },
5964 },
0f2fca1a
JA		 5965 {
5966 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
5967 .u.insns_int = {
5968 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
5969 BPF_ALU32_IMM(BPF_LSH, R0, 12),
5970 BPF_EXIT_INSN(),
5971 },
5972 INTERNAL,
5973 { },
5974 { { 0, 0x45678000 } }
5975 },
5976 {
5977 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
5978 .u.insns_int = {
5979 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
5980 BPF_ALU32_IMM(BPF_LSH, R0, 0),
5981 BPF_EXIT_INSN(),
5982 },
5983 INTERNAL,
5984 { },
5985 { { 0, 0x12345678 } }
5986 },
cffc642d
MH		 5987 {
5988 "ALU64_LSH_K: 1 << 1 = 2",
5989 .u.insns_int = {
5990 BPF_LD_IMM64(R0, 1),
5991 BPF_ALU64_IMM(BPF_LSH, R0, 1),
5992 BPF_EXIT_INSN(),
5993 },
5994 INTERNAL,
5995 { },
5996 { { 0, 2 } },
5997 },
5998 {
5999 "ALU64_LSH_K: 1 << 31 = 0x80000000",
6000 .u.insns_int = {
6001 BPF_LD_IMM64(R0, 1),
6002 BPF_ALU64_IMM(BPF_LSH, R0, 31),
6003 BPF_EXIT_INSN(),
6004 },
6005 INTERNAL,
6006 { },
6007 { { 0, 0x80000000 } },
6008 },
3b9890ef
JA		 6009 {
6010 "ALU64_LSH_K: Shift < 32, low word",
6011 .u.insns_int = {
6012 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6013 BPF_ALU64_IMM(BPF_LSH, R0, 12),
6014 BPF_EXIT_INSN(),
6015 },
6016 INTERNAL,
6017 { },
6018 { { 0, 0xbcdef000 } }
6019 },
6020 {
6021 "ALU64_LSH_K: Shift < 32, high word",
6022 .u.insns_int = {
6023 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6024 BPF_ALU64_IMM(BPF_LSH, R0, 12),
6025 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6026 BPF_EXIT_INSN(),
6027 },
6028 INTERNAL,
6029 { },
6030 { { 0, 0x3456789a } }
6031 },
6032 {
6033 "ALU64_LSH_K: Shift > 32, low word",
6034 .u.insns_int = {
6035 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6036 BPF_ALU64_IMM(BPF_LSH, R0, 36),
6037 BPF_EXIT_INSN(),
6038 },
6039 INTERNAL,
6040 { },
6041 { { 0, 0 } }
6042 },
6043 {
6044 "ALU64_LSH_K: Shift > 32, high word",
6045 .u.insns_int = {
6046 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6047 BPF_ALU64_IMM(BPF_LSH, R0, 36),
6048 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6049 BPF_EXIT_INSN(),
6050 },
6051 INTERNAL,
6052 { },
6053 { { 0, 0x9abcdef0 } }
6054 },
6055 {
6056 "ALU64_LSH_K: Shift == 32, low word",
6057 .u.insns_int = {
6058 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6059 BPF_ALU64_IMM(BPF_LSH, R0, 32),
6060 BPF_EXIT_INSN(),
6061 },
6062 INTERNAL,
6063 { },
6064 { { 0, 0 } }
6065 },
6066 {
6067 "ALU64_LSH_K: Shift == 32, high word",
6068 .u.insns_int = {
6069 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6070 BPF_ALU64_IMM(BPF_LSH, R0, 32),
6071 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6072 BPF_EXIT_INSN(),
6073 },
6074 INTERNAL,
6075 { },
6076 { { 0, 0x89abcdef } }
6077 },
6078 {
6079 "ALU64_LSH_K: Zero shift",
6080 .u.insns_int = {
6081 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6082 BPF_ALU64_IMM(BPF_LSH, R0, 0),
6083 BPF_EXIT_INSN(),
6084 },
6085 INTERNAL,
6086 { },
6087 { { 0, 0x89abcdef } }
6088 },
cffc642d
MH		 6089 /* BPF_ALU | BPF_RSH | BPF_X */
6090 {
6091 "ALU_RSH_X: 2 >> 1 = 1",
6092 .u.insns_int = {
6093 BPF_LD_IMM64(R0, 2),
6094 BPF_ALU32_IMM(BPF_MOV, R1, 1),
6095 BPF_ALU32_REG(BPF_RSH, R0, R1),
6096 BPF_EXIT_INSN(),
6097 },
6098 INTERNAL,
6099 { },
6100 { { 0, 1 } },
6101 },
6102 {
6103 "ALU_RSH_X: 0x80000000 >> 31 = 1",
6104 .u.insns_int = {
6105 BPF_LD_IMM64(R0, 0x80000000),
6106 BPF_ALU32_IMM(BPF_MOV, R1, 31),
6107 BPF_ALU32_REG(BPF_RSH, R0, R1),
6108 BPF_EXIT_INSN(),
6109 },
6110 INTERNAL,
6111 { },
6112 { { 0, 1 } },
6113 },
0f2fca1a
JA		 6114 {
6115 "ALU_RSH_X: 0x12345678 >> 20 = 0x123",
6116 .u.insns_int = {
6117 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6118 BPF_ALU32_IMM(BPF_MOV, R1, 20),
6119 BPF_ALU32_REG(BPF_RSH, R0, R1),
6120 BPF_EXIT_INSN(),
6121 },
6122 INTERNAL,
6123 { },
6124 { { 0, 0x123 } }
6125 },
cffc642d
MH		 6126 {
6127 "ALU64_RSH_X: 2 >> 1 = 1",
6128 .u.insns_int = {
6129 BPF_LD_IMM64(R0, 2),
6130 BPF_ALU32_IMM(BPF_MOV, R1, 1),
6131 BPF_ALU64_REG(BPF_RSH, R0, R1),
6132 BPF_EXIT_INSN(),
6133 },
6134 INTERNAL,
6135 { },
6136 { { 0, 1 } },
6137 },
6138 {
6139 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
6140 .u.insns_int = {
6141 BPF_LD_IMM64(R0, 0x80000000),
6142 BPF_ALU32_IMM(BPF_MOV, R1, 31),
6143 BPF_ALU64_REG(BPF_RSH, R0, R1),
6144 BPF_EXIT_INSN(),
6145 },
6146 INTERNAL,
6147 { },
6148 { { 0, 1 } },
6149 },
3b9890ef
JA		 6150 {
6151 "ALU64_RSH_X: Shift < 32, low word",
6152 .u.insns_int = {
6153 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6154 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6155 BPF_ALU64_REG(BPF_RSH, R0, R1),
6156 BPF_EXIT_INSN(),
6157 },
6158 INTERNAL,
6159 { },
6160 { { 0, 0x56789abc } }
6161 },
6162 {
6163 "ALU64_RSH_X: Shift < 32, high word",
6164 .u.insns_int = {
6165 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6166 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6167 BPF_ALU64_REG(BPF_RSH, R0, R1),
6168 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6169 BPF_EXIT_INSN(),
6170 },
6171 INTERNAL,
6172 { },
6173 { { 0, 0x00081234 } }
6174 },
6175 {
6176 "ALU64_RSH_X: Shift > 32, low word",
6177 .u.insns_int = {
6178 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6179 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6180 BPF_ALU64_REG(BPF_RSH, R0, R1),
6181 BPF_EXIT_INSN(),
6182 },
6183 INTERNAL,
6184 { },
6185 { { 0, 0x08123456 } }
6186 },
6187 {
6188 "ALU64_RSH_X: Shift > 32, high word",
6189 .u.insns_int = {
6190 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6191 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6192 BPF_ALU64_REG(BPF_RSH, R0, R1),
6193 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6194 BPF_EXIT_INSN(),
6195 },
6196 INTERNAL,
6197 { },
6198 { { 0, 0 } }
6199 },
6200 {
6201 "ALU64_RSH_X: Shift == 32, low word",
6202 .u.insns_int = {
6203 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6204 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6205 BPF_ALU64_REG(BPF_RSH, R0, R1),
6206 BPF_EXIT_INSN(),
6207 },
6208 INTERNAL,
6209 { },
6210 { { 0, 0x81234567 } }
6211 },
6212 {
6213 "ALU64_RSH_X: Shift == 32, high word",
6214 .u.insns_int = {
6215 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6216 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6217 BPF_ALU64_REG(BPF_RSH, R0, R1),
6218 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6219 BPF_EXIT_INSN(),
6220 },
6221 INTERNAL,
6222 { },
6223 { { 0, 0 } }
6224 },
6225 {
6226 "ALU64_RSH_X: Zero shift, low word",
6227 .u.insns_int = {
6228 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6229 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6230 BPF_ALU64_REG(BPF_RSH, R0, R1),
6231 BPF_EXIT_INSN(),
6232 },
6233 INTERNAL,
6234 { },
6235 { { 0, 0x89abcdef } }
6236 },
6237 {
6238 "ALU64_RSH_X: Zero shift, high word",
6239 .u.insns_int = {
6240 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6241 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6242 BPF_ALU64_REG(BPF_RSH, R0, R1),
6243 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6244 BPF_EXIT_INSN(),
6245 },
6246 INTERNAL,
6247 { },
6248 { { 0, 0x81234567 } }
6249 },
cffc642d
MH		 6250 /* BPF_ALU | BPF_RSH | BPF_K */
6251 {
6252 "ALU_RSH_K: 2 >> 1 = 1",
6253 .u.insns_int = {
6254 BPF_LD_IMM64(R0, 2),
6255 BPF_ALU32_IMM(BPF_RSH, R0, 1),
6256 BPF_EXIT_INSN(),
6257 },
6258 INTERNAL,
6259 { },
6260 { { 0, 1 } },
6261 },
6262 {
6263 "ALU_RSH_K: 0x80000000 >> 31 = 1",
6264 .u.insns_int = {
6265 BPF_LD_IMM64(R0, 0x80000000),
6266 BPF_ALU32_IMM(BPF_RSH, R0, 31),
6267 BPF_EXIT_INSN(),
6268 },
6269 INTERNAL,
6270 { },
6271 { { 0, 1 } },
6272 },
0f2fca1a
JA		 6273 {
6274 "ALU_RSH_K: 0x12345678 >> 20 = 0x123",
6275 .u.insns_int = {
6276 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6277 BPF_ALU32_IMM(BPF_RSH, R0, 20),
6278 BPF_EXIT_INSN(),
6279 },
6280 INTERNAL,
6281 { },
6282 { { 0, 0x123 } }
6283 },
6284 {
6285 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
6286 .u.insns_int = {
6287 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6288 BPF_ALU32_IMM(BPF_RSH, R0, 0),
6289 BPF_EXIT_INSN(),
6290 },
6291 INTERNAL,
6292 { },
6293 { { 0, 0x12345678 } }
6294 },
cffc642d
MH		 6295 {
6296 "ALU64_RSH_K: 2 >> 1 = 1",
6297 .u.insns_int = {
6298 BPF_LD_IMM64(R0, 2),
6299 BPF_ALU64_IMM(BPF_RSH, R0, 1),
6300 BPF_EXIT_INSN(),
6301 },
6302 INTERNAL,
6303 { },
6304 { { 0, 1 } },
6305 },
6306 {
6307 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
6308 .u.insns_int = {
6309 BPF_LD_IMM64(R0, 0x80000000),
6310 BPF_ALU64_IMM(BPF_RSH, R0, 31),
6311 BPF_EXIT_INSN(),
6312 },
6313 INTERNAL,
6314 { },
6315 { { 0, 1 } },
6316 },
3b9890ef
JA		 6317 {
6318 "ALU64_RSH_K: Shift < 32, low word",
6319 .u.insns_int = {
6320 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6321 BPF_ALU64_IMM(BPF_RSH, R0, 12),
6322 BPF_EXIT_INSN(),
6323 },
6324 INTERNAL,
6325 { },
6326 { { 0, 0x56789abc } }
6327 },
6328 {
6329 "ALU64_RSH_K: Shift < 32, high word",
6330 .u.insns_int = {
6331 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6332 BPF_ALU64_IMM(BPF_RSH, R0, 12),
6333 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6334 BPF_EXIT_INSN(),
6335 },
6336 INTERNAL,
6337 { },
6338 { { 0, 0x00081234 } }
6339 },
6340 {
6341 "ALU64_RSH_K: Shift > 32, low word",
6342 .u.insns_int = {
6343 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6344 BPF_ALU64_IMM(BPF_RSH, R0, 36),
6345 BPF_EXIT_INSN(),
6346 },
6347 INTERNAL,
6348 { },
6349 { { 0, 0x08123456 } }
6350 },
6351 {
6352 "ALU64_RSH_K: Shift > 32, high word",
6353 .u.insns_int = {
6354 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6355 BPF_ALU64_IMM(BPF_RSH, R0, 36),
6356 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6357 BPF_EXIT_INSN(),
6358 },
6359 INTERNAL,
6360 { },
6361 { { 0, 0 } }
6362 },
6363 {
6364 "ALU64_RSH_K: Shift == 32, low word",
6365 .u.insns_int = {
6366 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6367 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6368 BPF_EXIT_INSN(),
6369 },
6370 INTERNAL,
6371 { },
6372 { { 0, 0x81234567 } }
6373 },
6374 {
6375 "ALU64_RSH_K: Shift == 32, high word",
6376 .u.insns_int = {
6377 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6378 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6379 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6380 BPF_EXIT_INSN(),
6381 },
6382 INTERNAL,
6383 { },
6384 { { 0, 0 } }
6385 },
6386 {
6387 "ALU64_RSH_K: Zero shift",
6388 .u.insns_int = {
6389 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6390 BPF_ALU64_IMM(BPF_RSH, R0, 0),
6391 BPF_EXIT_INSN(),
6392 },
6393 INTERNAL,
6394 { },
6395 { { 0, 0x89abcdef } }
6396 },
cffc642d 6397 /* BPF_ALU | BPF_ARSH | BPF_X */
0f2fca1a
JA		 6398 {
6399 "ALU32_ARSH_X: -1234 >> 7 = -10",
6400 .u.insns_int = {
6401 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6402 BPF_ALU32_IMM(BPF_MOV, R1, 7),
6403 BPF_ALU32_REG(BPF_ARSH, R0, R1),
6404 BPF_EXIT_INSN(),
6405 },
6406 INTERNAL,
6407 { },
6408 { { 0, -10 } }
6409 },
cffc642d 6410 {
3b9890ef 6411 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
cffc642d
MH		 6412 .u.insns_int = {
6413 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
6414 BPF_ALU32_IMM(BPF_MOV, R1, 40),
6415 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6416 BPF_EXIT_INSN(),
6417 },
6418 INTERNAL,
6419 { },
6420 { { 0, 0xffff00ff } },
6421 },
3b9890ef
JA		 6422 {
6423 "ALU64_ARSH_X: Shift < 32, low word",
6424 .u.insns_int = {
6425 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6426 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6427 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6428 BPF_EXIT_INSN(),
6429 },
6430 INTERNAL,
6431 { },
6432 { { 0, 0x56789abc } }
6433 },
6434 {
6435 "ALU64_ARSH_X: Shift < 32, high word",
6436 .u.insns_int = {
6437 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6438 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6439 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6440 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6441 BPF_EXIT_INSN(),
6442 },
6443 INTERNAL,
6444 { },
6445 { { 0, 0xfff81234 } }
6446 },
6447 {
6448 "ALU64_ARSH_X: Shift > 32, low word",
6449 .u.insns_int = {
6450 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6451 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6452 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6453 BPF_EXIT_INSN(),
6454 },
6455 INTERNAL,
6456 { },
6457 { { 0, 0xf8123456 } }
6458 },
6459 {
6460 "ALU64_ARSH_X: Shift > 32, high word",
6461 .u.insns_int = {
6462 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6463 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6464 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6465 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6466 BPF_EXIT_INSN(),
6467 },
6468 INTERNAL,
6469 { },
6470 { { 0, -1 } }
6471 },
6472 {
6473 "ALU64_ARSH_X: Shift == 32, low word",
6474 .u.insns_int = {
6475 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6476 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6477 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6478 BPF_EXIT_INSN(),
6479 },
6480 INTERNAL,
6481 { },
6482 { { 0, 0x81234567 } }
6483 },
6484 {
6485 "ALU64_ARSH_X: Shift == 32, high word",
6486 .u.insns_int = {
6487 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6488 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6489 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6490 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6491 BPF_EXIT_INSN(),
6492 },
6493 INTERNAL,
6494 { },
6495 { { 0, -1 } }
6496 },
6497 {
6498 "ALU64_ARSH_X: Zero shift, low word",
6499 .u.insns_int = {
6500 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6501 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6502 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6503 BPF_EXIT_INSN(),
6504 },
6505 INTERNAL,
6506 { },
6507 { { 0, 0x89abcdef } }
6508 },
6509 {
6510 "ALU64_ARSH_X: Zero shift, high word",
6511 .u.insns_int = {
6512 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6513 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6514 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6515 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6516 BPF_EXIT_INSN(),
6517 },
6518 INTERNAL,
6519 { },
6520 { { 0, 0x81234567 } }
6521 },
cffc642d 6522 /* BPF_ALU | BPF_ARSH | BPF_K */
0f2fca1a
JA		 6523 {
6524 "ALU32_ARSH_K: -1234 >> 7 = -10",
6525 .u.insns_int = {
6526 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6527 BPF_ALU32_IMM(BPF_ARSH, R0, 7),
6528 BPF_EXIT_INSN(),
6529 },
6530 INTERNAL,
6531 { },
6532 { { 0, -10 } }
6533 },
6534 {
6535 "ALU32_ARSH_K: -1234 >> 0 = -1234",
6536 .u.insns_int = {
6537 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6538 BPF_ALU32_IMM(BPF_ARSH, R0, 0),
6539 BPF_EXIT_INSN(),
6540 },
6541 INTERNAL,
6542 { },
6543 { { 0, -1234 } }
6544 },
cffc642d 6545 {
3b9890ef 6546 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
cffc642d
MH		 6547 .u.insns_int = {
6548 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
6549 BPF_ALU64_IMM(BPF_ARSH, R0, 40),
6550 BPF_EXIT_INSN(),
6551 },
6552 INTERNAL,
6553 { },
6554 { { 0, 0xffff00ff } },
6555 },
3b9890ef
JA		 6556 {
6557 "ALU64_ARSH_K: Shift < 32, low word",
6558 .u.insns_int = {
6559 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6560 BPF_ALU64_IMM(BPF_RSH, R0, 12),
6561 BPF_EXIT_INSN(),
6562 },
6563 INTERNAL,
6564 { },
6565 { { 0, 0x56789abc } }
6566 },
6567 {
6568 "ALU64_ARSH_K: Shift < 32, high word",
6569 .u.insns_int = {
6570 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6571 BPF_ALU64_IMM(BPF_ARSH, R0, 12),
6572 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6573 BPF_EXIT_INSN(),
6574 },
6575 INTERNAL,
6576 { },
6577 { { 0, 0xfff81234 } }
6578 },
6579 {
6580 "ALU64_ARSH_K: Shift > 32, low word",
6581 .u.insns_int = {
6582 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6583 BPF_ALU64_IMM(BPF_ARSH, R0, 36),
6584 BPF_EXIT_INSN(),
6585 },
6586 INTERNAL,
6587 { },
6588 { { 0, 0xf8123456 } }
6589 },
6590 {
6591 "ALU64_ARSH_K: Shift > 32, high word",
6592 .u.insns_int = {
6593 BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
6594 BPF_ALU64_IMM(BPF_ARSH, R0, 36),
6595 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6596 BPF_EXIT_INSN(),
6597 },
6598 INTERNAL,
6599 { },
6600 { { 0, -1 } }
6601 },
6602 {
6603 "ALU64_ARSH_K: Shift == 32, low word",
6604 .u.insns_int = {
6605 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6606 BPF_ALU64_IMM(BPF_ARSH, R0, 32),
6607 BPF_EXIT_INSN(),
6608 },
6609 INTERNAL,
6610 { },
6611 { { 0, 0x81234567 } }
6612 },
6613 {
6614 "ALU64_ARSH_K: Shift == 32, high word",
6615 .u.insns_int = {
6616 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6617 BPF_ALU64_IMM(BPF_ARSH, R0, 32),
6618 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6619 BPF_EXIT_INSN(),
6620 },
6621 INTERNAL,
6622 { },
6623 { { 0, -1 } }
6624 },
6625 {
1bda52f8 6626 "ALU64_ARSH_K: Zero shift",
3b9890ef
JA		 6627 .u.insns_int = {
6628 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6629 BPF_ALU64_IMM(BPF_ARSH, R0, 0),
6630 BPF_EXIT_INSN(),
6631 },
6632 INTERNAL,
6633 { },
6634 { { 0, 0x89abcdef } }
6635 },
cffc642d
MH		 6636 /* BPF_ALU | BPF_NEG */
6637 {
6638 "ALU_NEG: -(3) = -3",
6639 .u.insns_int = {
6640 BPF_ALU32_IMM(BPF_MOV, R0, 3),
6641 BPF_ALU32_IMM(BPF_NEG, R0, 0),
6642 BPF_EXIT_INSN(),
6643 },
6644 INTERNAL,
6645 { },
6646 { { 0, -3 } },
6647 },
6648 {
6649 "ALU_NEG: -(-3) = 3",
6650 .u.insns_int = {
6651 BPF_ALU32_IMM(BPF_MOV, R0, -3),
6652 BPF_ALU32_IMM(BPF_NEG, R0, 0),
6653 BPF_EXIT_INSN(),
6654 },
6655 INTERNAL,
6656 { },
6657 { { 0, 3 } },
6658 },
6659 {
6660 "ALU64_NEG: -(3) = -3",
6661 .u.insns_int = {
6662 BPF_LD_IMM64(R0, 3),
6663 BPF_ALU64_IMM(BPF_NEG, R0, 0),
6664 BPF_EXIT_INSN(),
6665 },
6666 INTERNAL,
6667 { },
6668 { { 0, -3 } },
6669 },
6670 {
6671 "ALU64_NEG: -(-3) = 3",
6672 .u.insns_int = {
6673 BPF_LD_IMM64(R0, -3),
6674 BPF_ALU64_IMM(BPF_NEG, R0, 0),
6675 BPF_EXIT_INSN(),
6676 },
6677 INTERNAL,
6678 { },
6679 { { 0, 3 } },
6680 },
6681 /* BPF_ALU | BPF_END | BPF_FROM_BE */
6682 {
6683 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
6684 .u.insns_int = {
6685 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6686 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
6687 BPF_EXIT_INSN(),
6688 },
6689 INTERNAL,
6690 { },
6691 { { 0, cpu_to_be16(0xcdef) } },
6692 },
6693 {
6694 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
6695 .u.insns_int = {
6696 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6697 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
ba29becd
XW		 6698 BPF_ALU64_REG(BPF_MOV, R1, R0),
6699 BPF_ALU64_IMM(BPF_RSH, R1, 32),
6700 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
cffc642d
MH		 6701 BPF_EXIT_INSN(),
6702 },
6703 INTERNAL,
6704 { },
6705 { { 0, cpu_to_be32(0x89abcdef) } },
6706 },
6707 {
6708 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
6709 .u.insns_int = {
6710 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6711 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
6712 BPF_EXIT_INSN(),
6713 },
6714 INTERNAL,
6715 { },
6716 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
6717 },
6718 /* BPF_ALU | BPF_END | BPF_FROM_LE */
6719 {
6720 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
6721 .u.insns_int = {
6722 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6723 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
6724 BPF_EXIT_INSN(),
6725 },
6726 INTERNAL,
6727 { },
6728 { { 0, cpu_to_le16(0xcdef) } },
6729 },
6730 {
6731 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
6732 .u.insns_int = {
6733 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6734 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
ba29becd
XW		 6735 BPF_ALU64_REG(BPF_MOV, R1, R0),
6736 BPF_ALU64_IMM(BPF_RSH, R1, 32),
6737 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
cffc642d
MH		 6738 BPF_EXIT_INSN(),
6739 },
6740 INTERNAL,
6741 { },
6742 { { 0, cpu_to_le32(0x89abcdef) } },
6743 },
6744 {
6745 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
6746 .u.insns_int = {
6747 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6748 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
6749 BPF_EXIT_INSN(),
6750 },
6751 INTERNAL,
6752 { },
6753 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
6754 },
6755 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
6756 {
6757 "ST_MEM_B: Store/Load byte: max negative",
6758 .u.insns_int = {
6759 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6760 BPF_ST_MEM(BPF_B, R10, -40, 0xff),
6761 BPF_LDX_MEM(BPF_B, R0, R10, -40),
6762 BPF_EXIT_INSN(),
6763 },
6764 INTERNAL,
6765 { },
6766 { { 0, 0xff } },
105c0361 6767 .stack_depth = 40,
cffc642d
MH		 6768 },
6769 {
6770 "ST_MEM_B: Store/Load byte: max positive",
6771 .u.insns_int = {
6772 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6773 BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
6774 BPF_LDX_MEM(BPF_H, R0, R10, -40),
6775 BPF_EXIT_INSN(),
6776 },
6777 INTERNAL,
6778 { },
6779 { { 0, 0x7f } },
105c0361 6780 .stack_depth = 40,
cffc642d
MH		 6781 },
6782 {
6783 "STX_MEM_B: Store/Load byte: max negative",
6784 .u.insns_int = {
6785 BPF_LD_IMM64(R0, 0),
6786 BPF_LD_IMM64(R1, 0xffLL),
6787 BPF_STX_MEM(BPF_B, R10, R1, -40),
6788 BPF_LDX_MEM(BPF_B, R0, R10, -40),
6789 BPF_EXIT_INSN(),
6790 },
6791 INTERNAL,
6792 { },
6793 { { 0, 0xff } },
105c0361 6794 .stack_depth = 40,
cffc642d
MH		 6795 },
6796 {
6797 "ST_MEM_H: Store/Load half word: max negative",
6798 .u.insns_int = {
6799 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6800 BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
6801 BPF_LDX_MEM(BPF_H, R0, R10, -40),
6802 BPF_EXIT_INSN(),
6803 },
6804 INTERNAL,
6805 { },
6806 { { 0, 0xffff } },
105c0361 6807 .stack_depth = 40,
cffc642d
MH		 6808 },
6809 {
6810 "ST_MEM_H: Store/Load half word: max positive",
6811 .u.insns_int = {
6812 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6813 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
6814 BPF_LDX_MEM(BPF_H, R0, R10, -40),
6815 BPF_EXIT_INSN(),
6816 },
6817 INTERNAL,
6818 { },
6819 { { 0, 0x7fff } },
105c0361 6820 .stack_depth = 40,
cffc642d
MH		 6821 },
6822 {
6823 "STX_MEM_H: Store/Load half word: max negative",
6824 .u.insns_int = {
6825 BPF_LD_IMM64(R0, 0),
6826 BPF_LD_IMM64(R1, 0xffffLL),
6827 BPF_STX_MEM(BPF_H, R10, R1, -40),
6828 BPF_LDX_MEM(BPF_H, R0, R10, -40),
6829 BPF_EXIT_INSN(),
6830 },
6831 INTERNAL,
6832 { },
6833 { { 0, 0xffff } },
105c0361 6834 .stack_depth = 40,
cffc642d
MH		 6835 },
6836 {
6837 "ST_MEM_W: Store/Load word: max negative",
6838 .u.insns_int = {
6839 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6840 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
6841 BPF_LDX_MEM(BPF_W, R0, R10, -40),
6842 BPF_EXIT_INSN(),
6843 },
6844 INTERNAL,
6845 { },
6846 { { 0, 0xffffffff } },
105c0361 6847 .stack_depth = 40,
cffc642d
MH		 6848 },
6849 {
6850 "ST_MEM_W: Store/Load word: max positive",
6851 .u.insns_int = {
6852 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6853 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
6854 BPF_LDX_MEM(BPF_W, R0, R10, -40),
6855 BPF_EXIT_INSN(),
6856 },
6857 INTERNAL,
6858 { },
6859 { { 0, 0x7fffffff } },
105c0361 6860 .stack_depth = 40,
cffc642d
MH		 6861 },
6862 {
6863 "STX_MEM_W: Store/Load word: max negative",
6864 .u.insns_int = {
6865 BPF_LD_IMM64(R0, 0),
6866 BPF_LD_IMM64(R1, 0xffffffffLL),
6867 BPF_STX_MEM(BPF_W, R10, R1, -40),
6868 BPF_LDX_MEM(BPF_W, R0, R10, -40),
6869 BPF_EXIT_INSN(),
6870 },
6871 INTERNAL,
6872 { },
6873 { { 0, 0xffffffff } },
105c0361 6874 .stack_depth = 40,
cffc642d
MH		 6875 },
6876 {
6877 "ST_MEM_DW: Store/Load double word: max negative",
6878 .u.insns_int = {
6879 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6880 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
6881 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
6882 BPF_EXIT_INSN(),
6883 },
6884 INTERNAL,
6885 { },
6886 { { 0, 0xffffffff } },
105c0361 6887 .stack_depth = 40,
cffc642d
MH		 6888 },
6889 {
6890 "ST_MEM_DW: Store/Load double word: max negative 2",
6891 .u.insns_int = {
56cbaa45
MH		 6892 BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
6893 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 6894 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
6895 BPF_LDX_MEM(BPF_DW, R2, R10, -40),
6896 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
6897 BPF_MOV32_IMM(R0, 2),
6898 BPF_EXIT_INSN(),
6899 BPF_MOV32_IMM(R0, 1),
6900 BPF_EXIT_INSN(),
6901 },
6902 INTERNAL,
6903 { },
6904 { { 0, 0x1 } },
105c0361 6905 .stack_depth = 40,
cffc642d
MH		 6906 },
6907 {
6908 "ST_MEM_DW: Store/Load double word: max positive",
6909 .u.insns_int = {
6910 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6911 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
6912 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
6913 BPF_EXIT_INSN(),
6914 },
6915 INTERNAL,
6916 { },
6917 { { 0, 0x7fffffff } },
105c0361 6918 .stack_depth = 40,
cffc642d
MH		 6919 },
6920 {
6921 "STX_MEM_DW: Store/Load double word: max negative",
6922 .u.insns_int = {
6923 BPF_LD_IMM64(R0, 0),
6924 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
ae7f4704
JA		 6925 BPF_STX_MEM(BPF_DW, R10, R1, -40),
6926 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
cffc642d
MH		 6927 BPF_EXIT_INSN(),
6928 },
6929 INTERNAL,
6930 { },
6931 { { 0, 0xffffffff } },
105c0361 6932 .stack_depth = 40,
cffc642d 6933 },
e5009b46
JA		 6934 {
6935 "STX_MEM_DW: Store double word: first word in memory",
6936 .u.insns_int = {
6937 BPF_LD_IMM64(R0, 0),
6938 BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
6939 BPF_STX_MEM(BPF_DW, R10, R1, -40),
6940 BPF_LDX_MEM(BPF_W, R0, R10, -40),
6941 BPF_EXIT_INSN(),
6942 },
6943 INTERNAL,
6944 { },
6945#ifdef __BIG_ENDIAN
6946 { { 0, 0x01234567 } },
6947#else
6948 { { 0, 0x89abcdef } },
6949#endif
6950 .stack_depth = 40,
6951 },
6952 {
6953 "STX_MEM_DW: Store double word: second word in memory",
6954 .u.insns_int = {
6955 BPF_LD_IMM64(R0, 0),
6956 BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
6957 BPF_STX_MEM(BPF_DW, R10, R1, -40),
6958 BPF_LDX_MEM(BPF_W, R0, R10, -36),
6959 BPF_EXIT_INSN(),
6960 },
6961 INTERNAL,
6962 { },
6963#ifdef __BIG_ENDIAN
6964 { { 0, 0x89abcdef } },
6965#else
6966 { { 0, 0x01234567 } },
6967#endif
6968 .stack_depth = 40,
6969 },
91c960b0 6970 /* BPF_STX | BPF_ATOMIC | BPF_W/DW */
85f68fe8
DB		 6971 {
6972 "STX_XADD_W: X + 1 + 1 + 1 + ...",
6973 { },
6974 INTERNAL,
6975 { },
6976 { { 0, 4134 } },
6977 .fill_helper = bpf_fill_stxw,
6978 },
85f68fe8
DB		 6979 {
6980 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
6981 { },
6982 INTERNAL,
6983 { },
6984 { { 0, 4134 } },
6985 .fill_helper = bpf_fill_stxdw,
6986 },
e4517b36
JA		 6987 /*
6988 * Exhaustive tests of atomic operation variants.
6989 * Individual tests are expanded from template macros for all
6990 * combinations of ALU operation, word size and fetching.
6991 */
6992#define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result) \
6993{ \
6994 "BPF_ATOMIC | " #width ", " #op ": Test: " \
6995 #old " " #logic " " #update " = " #result, \
6996 .u.insns_int = { \
6997 BPF_ALU32_IMM(BPF_MOV, R5, update), \
6998 BPF_ST_MEM(width, R10, -40, old), \
6999 BPF_ATOMIC_OP(width, op, R10, R5, -40), \
7000 BPF_LDX_MEM(width, R0, R10, -40), \
7001 BPF_EXIT_INSN(), \
7002 }, \
7003 INTERNAL, \
7004 { }, \
7005 { { 0, result } }, \
7006 .stack_depth = 40, \
7007}
7008#define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result) \
7009{ \
7010 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: " \
7011 #old " " #logic " " #update " = " #result, \
7012 .u.insns_int = { \
7013 BPF_ALU64_REG(BPF_MOV, R1, R10), \
7014 BPF_ALU32_IMM(BPF_MOV, R0, update), \
7015 BPF_ST_MEM(BPF_W, R10, -40, old), \
7016 BPF_ATOMIC_OP(width, op, R10, R0, -40), \
7017 BPF_ALU64_REG(BPF_MOV, R0, R10), \
7018 BPF_ALU64_REG(BPF_SUB, R0, R1), \
7019 BPF_EXIT_INSN(), \
7020 }, \
7021 INTERNAL, \
7022 { }, \
7023 { { 0, 0 } }, \
7024 .stack_depth = 40, \
7025}
7026#define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result) \
7027{ \
7028 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: " \
7029 #old " " #logic " " #update " = " #result, \
7030 .u.insns_int = { \
7031 BPF_ALU64_REG(BPF_MOV, R0, R10), \
7032 BPF_ALU32_IMM(BPF_MOV, R1, update), \
7033 BPF_ST_MEM(width, R10, -40, old), \
7034 BPF_ATOMIC_OP(width, op, R10, R1, -40), \
7035 BPF_ALU64_REG(BPF_SUB, R0, R10), \
7036 BPF_EXIT_INSN(), \
7037 }, \
7038 INTERNAL, \
7039 { }, \
7040 { { 0, 0 } }, \
7041 .stack_depth = 40, \
7042}
7043#define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result) \
7044{ \
7045 "BPF_ATOMIC | " #width ", " #op ": Test fetch: " \
7046 #old " " #logic " " #update " = " #result, \
7047 .u.insns_int = { \
7048 BPF_ALU32_IMM(BPF_MOV, R3, update), \
7049 BPF_ST_MEM(width, R10, -40, old), \
7050 BPF_ATOMIC_OP(width, op, R10, R3, -40), \
7051 BPF_ALU64_REG(BPF_MOV, R0, R3), \
7052 BPF_EXIT_INSN(), \
7053 }, \
7054 INTERNAL, \
7055 { }, \
7056 { { 0, (op) & BPF_FETCH ? old : update } }, \
7057 .stack_depth = 40, \
7058}
7059 /* BPF_ATOMIC | BPF_W: BPF_ADD */
7060 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7061 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7062 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7063 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7064 /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
7065 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7066 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7067 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7068 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7069 /* BPF_ATOMIC | BPF_DW: BPF_ADD */
7070 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7071 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7072 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7073 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7074 /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
7075 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7076 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7077 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7078 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7079 /* BPF_ATOMIC | BPF_W: BPF_AND */
7080 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7081 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7082 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7083 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7084 /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
7085 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7086 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7087 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7088 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7089 /* BPF_ATOMIC | BPF_DW: BPF_AND */
7090 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7091 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7092 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7093 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7094 /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
7095 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7096 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7097 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7098 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7099 /* BPF_ATOMIC | BPF_W: BPF_OR */
7100 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7101 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7102 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7103 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7104 /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
7105 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7106 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7107 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7108 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7109 /* BPF_ATOMIC | BPF_DW: BPF_OR */
7110 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7111 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7112 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7113 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7114 /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
7115 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7116 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7117 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7118 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7119 /* BPF_ATOMIC | BPF_W: BPF_XOR */
7120 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7121 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7122 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7123 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7124 /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
7125 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7126 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7127 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7128 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7129 /* BPF_ATOMIC | BPF_DW: BPF_XOR */
7130 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7131 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7132 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7133 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7134 /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
7135 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7136 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7137 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7138 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7139 /* BPF_ATOMIC | BPF_W: BPF_XCHG */
7140 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7141 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7142 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7143 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7144 /* BPF_ATOMIC | BPF_DW: BPF_XCHG */
7145 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7146 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7147 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7148 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7149#undef BPF_ATOMIC_OP_TEST1
7150#undef BPF_ATOMIC_OP_TEST2
7151#undef BPF_ATOMIC_OP_TEST3
7152#undef BPF_ATOMIC_OP_TEST4
6a3b24ca
JA		 7153 /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
7154 {
7155 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
7156 .u.insns_int = {
7157 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7158 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7159 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7160 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7161 BPF_EXIT_INSN(),
7162 },
7163 INTERNAL,
7164 { },
7165 { { 0, 0x01234567 } },
7166 .stack_depth = 40,
7167 },
7168 {
7169 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
7170 .u.insns_int = {
7171 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7172 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7173 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7174 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7175 BPF_LDX_MEM(BPF_W, R0, R10, -40),
7176 BPF_EXIT_INSN(),
7177 },
7178 INTERNAL,
7179 { },
7180 { { 0, 0x89abcdef } },
7181 .stack_depth = 40,
7182 },
7183 {
7184 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
7185 .u.insns_int = {
7186 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7187 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
7188 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7189 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7190 BPF_EXIT_INSN(),
7191 },
7192 INTERNAL,
7193 { },
7194 { { 0, 0x01234567 } },
7195 .stack_depth = 40,
7196 },
7197 {
7198 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
7199 .u.insns_int = {
7200 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7201 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
7202 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7203 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7204 BPF_LDX_MEM(BPF_W, R0, R10, -40),
7205 BPF_EXIT_INSN(),
7206 },
7207 INTERNAL,
7208 { },
7209 { { 0, 0x01234567 } },
7210 .stack_depth = 40,
7211 },
7212 {
7213 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
7214 .u.insns_int = {
7215 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7216 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7217 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7218 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7219 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7220 BPF_ALU32_REG(BPF_MOV, R0, R3),
7221 BPF_EXIT_INSN(),
7222 },
7223 INTERNAL,
7224 { },
7225 { { 0, 0x89abcdef } },
7226 .stack_depth = 40,
7227 },
7228 /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
7229 {
7230 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
7231 .u.insns_int = {
7232 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
7233 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
7234 BPF_ALU64_REG(BPF_MOV, R0, R1),
7235 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7236 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7237 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
7238 BPF_ALU64_REG(BPF_SUB, R0, R1),
7239 BPF_EXIT_INSN(),
7240 },
7241 INTERNAL,
7242 { },
7243 { { 0, 0 } },
7244 .stack_depth = 40,
7245 },
7246 {
7247 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
7248 .u.insns_int = {
7249 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
7250 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
7251 BPF_ALU64_REG(BPF_MOV, R0, R1),
7252 BPF_STX_MEM(BPF_DW, R10, R0, -40),
7253 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7254 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7255 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7256 BPF_ALU64_REG(BPF_SUB, R0, R2),
7257 BPF_EXIT_INSN(),
7258 },
7259 INTERNAL,
7260 { },
7261 { { 0, 0 } },
7262 .stack_depth = 40,
7263 },
7264 {
7265 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
7266 .u.insns_int = {
7267 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
7268 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
7269 BPF_ALU64_REG(BPF_MOV, R0, R1),
7270 BPF_ALU64_IMM(BPF_ADD, R0, 1),
7271 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7272 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7273 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
7274 BPF_ALU64_REG(BPF_SUB, R0, R1),
7275 BPF_EXIT_INSN(),
7276 },
7277 INTERNAL,
7278 { },
7279 { { 0, 0 } },
7280 .stack_depth = 40,
7281 },
7282 {
7283 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
7284 .u.insns_int = {
7285 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
7286 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
7287 BPF_ALU64_REG(BPF_MOV, R0, R1),
7288 BPF_ALU64_IMM(BPF_ADD, R0, 1),
7289 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7290 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7291 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7292 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
7293 BPF_ALU64_REG(BPF_SUB, R0, R1),
7294 BPF_EXIT_INSN(),
7295 },
7296 INTERNAL,
7297 { },
7298 { { 0, 0 } },
7299 .stack_depth = 40,
7300 },
7301 {
7302 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
7303 .u.insns_int = {
7304 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
7305 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
7306 BPF_ALU64_REG(BPF_MOV, R0, R1),
7307 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7308 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7309 BPF_LD_IMM64(R0, 0xfecdba9876543210ULL),
7310 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7311 BPF_ALU64_REG(BPF_SUB, R0, R2),
7312 BPF_EXIT_INSN(),
7313 },
7314 INTERNAL,
7315 { },
7316 { { 0, 0 } },
7317 .stack_depth = 40,
7318 },
b55dfa85
JA		 7319 /* BPF_JMP32 | BPF_JEQ | BPF_K */
7320 {
7321 "JMP32_JEQ_K: Small immediate",
7322 .u.insns_int = {
7323 BPF_ALU32_IMM(BPF_MOV, R0, 123),
7324 BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
7325 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
7326 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7327 BPF_EXIT_INSN(),
7328 },
7329 INTERNAL,
7330 { },
7331 { { 0, 123 } }
7332 },
7333 {
7334 "JMP32_JEQ_K: Large immediate",
7335 .u.insns_int = {
7336 BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
7337 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
7338 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
7339 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7340 BPF_EXIT_INSN(),
7341 },
7342 INTERNAL,
7343 { },
7344 { { 0, 12345678 } }
7345 },
7346 {
7347 "JMP32_JEQ_K: negative immediate",
7348 .u.insns_int = {
7349 BPF_ALU32_IMM(BPF_MOV, R0, -123),
7350 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
7351 BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
7352 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7353 BPF_EXIT_INSN(),
7354 },
7355 INTERNAL,
7356 { },
7357 { { 0, -123 } }
7358 },
7359 /* BPF_JMP32 | BPF_JEQ | BPF_X */
7360 {
7361 "JMP32_JEQ_X",
7362 .u.insns_int = {
7363 BPF_ALU32_IMM(BPF_MOV, R0, 1234),
7364 BPF_ALU32_IMM(BPF_MOV, R1, 4321),
7365 BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
7366 BPF_ALU32_IMM(BPF_MOV, R1, 1234),
7367 BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
7368 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7369 BPF_EXIT_INSN(),
7370 },
7371 INTERNAL,
7372 { },
7373 { { 0, 1234 } }
7374 },
7375 /* BPF_JMP32 | BPF_JNE | BPF_K */
7376 {
7377 "JMP32_JNE_K: Small immediate",
7378 .u.insns_int = {
7379 BPF_ALU32_IMM(BPF_MOV, R0, 123),
7380 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
7381 BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
7382 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7383 BPF_EXIT_INSN(),
7384 },
7385 INTERNAL,
7386 { },
7387 { { 0, 123 } }
7388 },
7389 {
7390 "JMP32_JNE_K: Large immediate",
7391 .u.insns_int = {
7392 BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
7393 BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
7394 BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
7395 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7396 BPF_EXIT_INSN(),
7397 },
7398 INTERNAL,
7399 { },
7400 { { 0, 12345678 } }
7401 },
7402 {
7403 "JMP32_JNE_K: negative immediate",
7404 .u.insns_int = {
7405 BPF_ALU32_IMM(BPF_MOV, R0, -123),
7406 BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
7407 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
7408 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7409 BPF_EXIT_INSN(),
7410 },
7411 INTERNAL,
7412 { },
7413 { { 0, -123 } }
7414 },
7415 /* BPF_JMP32 | BPF_JNE | BPF_X */
7416 {
7417 "JMP32_JNE_X",
7418 .u.insns_int = {
7419 BPF_ALU32_IMM(BPF_MOV, R0, 1234),
7420 BPF_ALU32_IMM(BPF_MOV, R1, 1234),
7421 BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
7422 BPF_ALU32_IMM(BPF_MOV, R1, 4321),
7423 BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
7424 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7425 BPF_EXIT_INSN(),
7426 },
7427 INTERNAL,
7428 { },
7429 { { 0, 1234 } }
7430 },
7431 /* BPF_JMP32 | BPF_JSET | BPF_K */
7432 {
7433 "JMP32_JSET_K: Small immediate",
7434 .u.insns_int = {
7435 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7436 BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
7437 BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
7438 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7439 BPF_EXIT_INSN(),
7440 },
7441 INTERNAL,
7442 { },
7443 { { 0, 1 } }
7444 },
7445 {
7446 "JMP32_JSET_K: Large immediate",
7447 .u.insns_int = {
7448 BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
7449 BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
7450 BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
7451 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7452 BPF_EXIT_INSN(),
7453 },
7454 INTERNAL,
7455 { },
7456 { { 0, 0x40000000 } }
7457 },
7458 {
7459 "JMP32_JSET_K: negative immediate",
7460 .u.insns_int = {
7461 BPF_ALU32_IMM(BPF_MOV, R0, -123),
7462 BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
7463 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7464 BPF_EXIT_INSN(),
7465 },
7466 INTERNAL,
7467 { },
7468 { { 0, -123 } }
7469 },
7470 /* BPF_JMP32 | BPF_JSET | BPF_X */
7471 {
7472 "JMP32_JSET_X",
7473 .u.insns_int = {
7474 BPF_ALU32_IMM(BPF_MOV, R0, 8),
7475 BPF_ALU32_IMM(BPF_MOV, R1, 7),
7476 BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
7477 BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
7478 BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
7479 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7480 BPF_EXIT_INSN(),
7481 },
7482 INTERNAL,
7483 { },
7484 { { 0, 8 } }
7485 },
7486 /* BPF_JMP32 | BPF_JGT | BPF_K */
7487 {
7488 "JMP32_JGT_K: Small immediate",
7489 .u.insns_int = {
7490 BPF_ALU32_IMM(BPF_MOV, R0, 123),
7491 BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
7492 BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
7493 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7494 BPF_EXIT_INSN(),
7495 },
7496 INTERNAL,
7497 { },
7498 { { 0, 123 } }
7499 },
7500 {
7501 "JMP32_JGT_K: Large immediate",
7502 .u.insns_int = {
7503 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
7504 BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
7505 BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
7506 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7507 BPF_EXIT_INSN(),
7508 },
7509 INTERNAL,
7510 { },
7511 { { 0, 0xfffffffe } }
7512 },
7513 /* BPF_JMP32 | BPF_JGT | BPF_X */
7514 {
7515 "JMP32_JGT_X",
7516 .u.insns_int = {
7517 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
7518 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
7519 BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
7520 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
7521 BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
7522 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7523 BPF_EXIT_INSN(),
7524 },
7525 INTERNAL,
7526 { },
7527 { { 0, 0xfffffffe } }
7528 },
7529 /* BPF_JMP32 | BPF_JGE | BPF_K */
7530 {
7531 "JMP32_JGE_K: Small immediate",
7532 .u.insns_int = {
7533 BPF_ALU32_IMM(BPF_MOV, R0, 123),
7534 BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
7535 BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
7536 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7537 BPF_EXIT_INSN(),
7538 },
7539 INTERNAL,
7540 { },
7541 { { 0, 123 } }
7542 },
7543 {
7544 "JMP32_JGE_K: Large immediate",
7545 .u.insns_int = {
7546 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
7547 BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
7548 BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
7549 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7550 BPF_EXIT_INSN(),
7551 },
7552 INTERNAL,
7553 { },
7554 { { 0, 0xfffffffe } }
7555 },
7556 /* BPF_JMP32 | BPF_JGE | BPF_X */
7557 {
7558 "JMP32_JGE_X",
7559 .u.insns_int = {
7560 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
7561 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
7562 BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
7563 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
7564 BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
7565 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7566 BPF_EXIT_INSN(),
7567 },
7568 INTERNAL,
7569 { },
7570 { { 0, 0xfffffffe } }
7571 },
7572 /* BPF_JMP32 | BPF_JLT | BPF_K */
7573 {
7574 "JMP32_JLT_K: Small immediate",
7575 .u.insns_int = {
7576 BPF_ALU32_IMM(BPF_MOV, R0, 123),
7577 BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
7578 BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
7579 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7580 BPF_EXIT_INSN(),
7581 },
7582 INTERNAL,
7583 { },
7584 { { 0, 123 } }
7585 },
7586 {
7587 "JMP32_JLT_K: Large immediate",
7588 .u.insns_int = {
7589 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
7590 BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
7591 BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
7592 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7593 BPF_EXIT_INSN(),
7594 },
7595 INTERNAL,
7596 { },
7597 { { 0, 0xfffffffe } }
7598 },
7599 /* BPF_JMP32 | BPF_JLT | BPF_X */
7600 {
7601 "JMP32_JLT_X",
7602 .u.insns_int = {
7603 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
7604 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
7605 BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
7606 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
7607 BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
7608 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7609 BPF_EXIT_INSN(),
7610 },
7611 INTERNAL,
7612 { },
7613 { { 0, 0xfffffffe } }
7614 },
7615 /* BPF_JMP32 | BPF_JLE | BPF_K */
7616 {
7617 "JMP32_JLE_K: Small immediate",
7618 .u.insns_int = {
7619 BPF_ALU32_IMM(BPF_MOV, R0, 123),
7620 BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
7621 BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
7622 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7623 BPF_EXIT_INSN(),
7624 },
7625 INTERNAL,
7626 { },
7627 { { 0, 123 } }
7628 },
7629 {
7630 "JMP32_JLE_K: Large immediate",
7631 .u.insns_int = {
7632 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
7633 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
7634 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
7635 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7636 BPF_EXIT_INSN(),
7637 },
7638 INTERNAL,
7639 { },
7640 { { 0, 0xfffffffe } }
7641 },
7642 /* BPF_JMP32 | BPF_JLE | BPF_X */
7643 {
7644 "JMP32_JLE_X",
7645 .u.insns_int = {
7646 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
7647 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
7648 BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
7649 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
7650 BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
7651 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7652 BPF_EXIT_INSN(),
7653 },
7654 INTERNAL,
7655 { },
7656 { { 0, 0xfffffffe } }
7657 },
7658 /* BPF_JMP32 | BPF_JSGT | BPF_K */
7659 {
7660 "JMP32_JSGT_K: Small immediate",
7661 .u.insns_int = {
7662 BPF_ALU32_IMM(BPF_MOV, R0, -123),
7663 BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
7664 BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
7665 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7666 BPF_EXIT_INSN(),
7667 },
7668 INTERNAL,
7669 { },
7670 { { 0, -123 } }
7671 },
7672 {
7673 "JMP32_JSGT_K: Large immediate",
7674 .u.insns_int = {
7675 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
7676 BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
7677 BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
7678 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7679 BPF_EXIT_INSN(),
7680 },
7681 INTERNAL,
7682 { },
7683 { { 0, -12345678 } }
7684 },
7685 /* BPF_JMP32 | BPF_JSGT | BPF_X */
7686 {
7687 "JMP32_JSGT_X",
7688 .u.insns_int = {
7689 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
7690 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
7691 BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
7692 BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
7693 BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
7694 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7695 BPF_EXIT_INSN(),
7696 },
7697 INTERNAL,
7698 { },
7699 { { 0, -12345678 } }
7700 },
7701 /* BPF_JMP32 | BPF_JSGE | BPF_K */
7702 {
7703 "JMP32_JSGE_K: Small immediate",
7704 .u.insns_int = {
7705 BPF_ALU32_IMM(BPF_MOV, R0, -123),
7706 BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
7707 BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
7708 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7709 BPF_EXIT_INSN(),
7710 },
7711 INTERNAL,
7712 { },
7713 { { 0, -123 } }
7714 },
7715 {
7716 "JMP32_JSGE_K: Large immediate",
7717 .u.insns_int = {
7718 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
7719 BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
7720 BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
7721 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7722 BPF_EXIT_INSN(),
7723 },
7724 INTERNAL,
7725 { },
7726 { { 0, -12345678 } }
7727 },
7728 /* BPF_JMP32 | BPF_JSGE | BPF_X */
7729 {
7730 "JMP32_JSGE_X",
7731 .u.insns_int = {
7732 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
7733 BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
7734 BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
7735 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
7736 BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
7737 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7738 BPF_EXIT_INSN(),
7739 },
7740 INTERNAL,
7741 { },
7742 { { 0, -12345678 } }
7743 },
7744 /* BPF_JMP32 | BPF_JSLT | BPF_K */
7745 {
7746 "JMP32_JSLT_K: Small immediate",
7747 .u.insns_int = {
7748 BPF_ALU32_IMM(BPF_MOV, R0, -123),
7749 BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
7750 BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
7751 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7752 BPF_EXIT_INSN(),
7753 },
7754 INTERNAL,
7755 { },
7756 { { 0, -123 } }
7757 },
7758 {
7759 "JMP32_JSLT_K: Large immediate",
7760 .u.insns_int = {
7761 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
7762 BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
7763 BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
7764 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7765 BPF_EXIT_INSN(),
7766 },
7767 INTERNAL,
7768 { },
7769 { { 0, -12345678 } }
7770 },
7771 /* BPF_JMP32 | BPF_JSLT | BPF_X */
7772 {
7773 "JMP32_JSLT_X",
7774 .u.insns_int = {
7775 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
7776 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
7777 BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
7778 BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
7779 BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
7780 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7781 BPF_EXIT_INSN(),
7782 },
7783 INTERNAL,
7784 { },
7785 { { 0, -12345678 } }
7786 },
7787 /* BPF_JMP32 | BPF_JSLE | BPF_K */
7788 {
7789 "JMP32_JSLE_K: Small immediate",
7790 .u.insns_int = {
7791 BPF_ALU32_IMM(BPF_MOV, R0, -123),
7792 BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
7793 BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
7794 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7795 BPF_EXIT_INSN(),
7796 },
7797 INTERNAL,
7798 { },
7799 { { 0, -123 } }
7800 },
7801 {
7802 "JMP32_JSLE_K: Large immediate",
7803 .u.insns_int = {
7804 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
7805 BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
7806 BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
7807 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7808 BPF_EXIT_INSN(),
7809 },
7810 INTERNAL,
7811 { },
7812 { { 0, -12345678 } }
7813 },
7814 /* BPF_JMP32 | BPF_JSLE | BPF_K */
7815 {
7816 "JMP32_JSLE_X",
7817 .u.insns_int = {
7818 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
7819 BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
7820 BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
7821 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
7822 BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
7823 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7824 BPF_EXIT_INSN(),
7825 },
7826 INTERNAL,
7827 { },
7828 { { 0, -12345678 } }
7829 },
cffc642d
MH		 7830 /* BPF_JMP | BPF_EXIT */
7831 {
7832 "JMP_EXIT",
7833 .u.insns_int = {
7834 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
7835 BPF_EXIT_INSN(),
7836 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
7837 },
7838 INTERNAL,
7839 { },
7840 { { 0, 0x4711 } },
7841 },
7842 /* BPF_JMP | BPF_JA */
7843 {
7844 "JMP_JA: Unconditional jump: if (true) return 1",
7845 .u.insns_int = {
7846 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7847 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
7848 BPF_EXIT_INSN(),
7849 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7850 BPF_EXIT_INSN(),
7851 },
7852 INTERNAL,
7853 { },
7854 { { 0, 1 } },
7855 },
92b31a9a
DB		 7856 /* BPF_JMP | BPF_JSLT | BPF_K */
7857 {
7858 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
7859 .u.insns_int = {
7860 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7861 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
7862 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
7863 BPF_EXIT_INSN(),
7864 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7865 BPF_EXIT_INSN(),
7866 },
7867 INTERNAL,
7868 { },
7869 { { 0, 1 } },
7870 },
7871 {
7872 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
7873 .u.insns_int = {
7874 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7875 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
7876 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
7877 BPF_EXIT_INSN(),
7878 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7879 BPF_EXIT_INSN(),
7880 },
7881 INTERNAL,
7882 { },
7883 { { 0, 1 } },
7884 },
cffc642d
MH		 7885 /* BPF_JMP | BPF_JSGT | BPF_K */
7886 {
7887 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
7888 .u.insns_int = {
7889 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7890 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
7891 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
7892 BPF_EXIT_INSN(),
7893 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7894 BPF_EXIT_INSN(),
7895 },
7896 INTERNAL,
7897 { },
7898 { { 0, 1 } },
7899 },
7900 {
7901 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
7902 .u.insns_int = {
7903 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7904 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
7905 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
7906 BPF_EXIT_INSN(),
7907 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7908 BPF_EXIT_INSN(),
7909 },
7910 INTERNAL,
7911 { },
7912 { { 0, 1 } },
7913 },
92b31a9a
DB		 7914 /* BPF_JMP | BPF_JSLE | BPF_K */
7915 {
7916 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
7917 .u.insns_int = {
7918 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7919 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
7920 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
7921 BPF_EXIT_INSN(),
7922 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7923 BPF_EXIT_INSN(),
7924 },
7925 INTERNAL,
7926 { },
7927 { { 0, 1 } },
7928 },
7929 {
7930 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
7931 .u.insns_int = {
7932 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7933 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
7934 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
7935 BPF_EXIT_INSN(),
7936 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7937 BPF_EXIT_INSN(),
7938 },
7939 INTERNAL,
7940 { },
7941 { { 0, 1 } },
7942 },
7943 {
7944 "JMP_JSLE_K: Signed jump: value walk 1",
7945 .u.insns_int = {
7946 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7947 BPF_LD_IMM64(R1, 3),
7948 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
7949 BPF_ALU64_IMM(BPF_SUB, R1, 1),
7950 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
7951 BPF_ALU64_IMM(BPF_SUB, R1, 1),
7952 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
7953 BPF_ALU64_IMM(BPF_SUB, R1, 1),
7954 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
7955 BPF_EXIT_INSN(), /* bad exit */
7956 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
7957 BPF_EXIT_INSN(),
7958 },
7959 INTERNAL,
7960 { },
7961 { { 0, 1 } },
7962 },
7963 {
7964 "JMP_JSLE_K: Signed jump: value walk 2",
7965 .u.insns_int = {
7966 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7967 BPF_LD_IMM64(R1, 3),
7968 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
7969 BPF_ALU64_IMM(BPF_SUB, R1, 2),
7970 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
7971 BPF_ALU64_IMM(BPF_SUB, R1, 2),
7972 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
7973 BPF_EXIT_INSN(), /* bad exit */
7974 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
7975 BPF_EXIT_INSN(),
7976 },
7977 INTERNAL,
7978 { },
7979 { { 0, 1 } },
7980 },
cffc642d
MH		 7981 /* BPF_JMP | BPF_JSGE | BPF_K */
7982 {
7983 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
7984 .u.insns_int = {
7985 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7986 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
7987 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
7988 BPF_EXIT_INSN(),
7989 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7990 BPF_EXIT_INSN(),
7991 },
7992 INTERNAL,
7993 { },
7994 { { 0, 1 } },
7995 },
7996 {
7997 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
7998 .u.insns_int = {
7999 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8000 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8001 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
8002 BPF_EXIT_INSN(),
8003 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8004 BPF_EXIT_INSN(),
8005 },
8006 INTERNAL,
8007 { },
8008 { { 0, 1 } },
8009 },
791caeb0
DD		 8010 {
8011 "JMP_JSGE_K: Signed jump: value walk 1",
8012 .u.insns_int = {
8013 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8014 BPF_LD_IMM64(R1, -3),
8015 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
8016 BPF_ALU64_IMM(BPF_ADD, R1, 1),
8017 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
8018 BPF_ALU64_IMM(BPF_ADD, R1, 1),
8019 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
8020 BPF_ALU64_IMM(BPF_ADD, R1, 1),
8021 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
8022 BPF_EXIT_INSN(), /* bad exit */
8023 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
8024 BPF_EXIT_INSN(),
8025 },
8026 INTERNAL,
8027 { },
8028 { { 0, 1 } },
8029 },
8030 {
8031 "JMP_JSGE_K: Signed jump: value walk 2",
8032 .u.insns_int = {
8033 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8034 BPF_LD_IMM64(R1, -3),
8035 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
8036 BPF_ALU64_IMM(BPF_ADD, R1, 2),
8037 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
8038 BPF_ALU64_IMM(BPF_ADD, R1, 2),
8039 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
8040 BPF_EXIT_INSN(), /* bad exit */
8041 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
8042 BPF_EXIT_INSN(),
8043 },
8044 INTERNAL,
8045 { },
8046 { { 0, 1 } },
8047 },
cffc642d
MH		 8048 /* BPF_JMP | BPF_JGT | BPF_K */
8049 {
8050 "JMP_JGT_K: if (3 > 2) return 1",
8051 .u.insns_int = {
8052 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8053 BPF_LD_IMM64(R1, 3),
8054 BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
8055 BPF_EXIT_INSN(),
8056 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8057 BPF_EXIT_INSN(),
8058 },
8059 INTERNAL,
8060 { },
8061 { { 0, 1 } },
8062 },
c7395d6b
NR		 8063 {
8064 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
8065 .u.insns_int = {
8066 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8067 BPF_LD_IMM64(R1, -1),
8068 BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
8069 BPF_EXIT_INSN(),
8070 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8071 BPF_EXIT_INSN(),
8072 },
8073 INTERNAL,
8074 { },
8075 { { 0, 1 } },
8076 },
92b31a9a
DB		 8077 /* BPF_JMP | BPF_JLT | BPF_K */
8078 {
8079 "JMP_JLT_K: if (2 < 3) return 1",
8080 .u.insns_int = {
8081 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8082 BPF_LD_IMM64(R1, 2),
8083 BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
8084 BPF_EXIT_INSN(),
8085 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8086 BPF_EXIT_INSN(),
8087 },
8088 INTERNAL,
8089 { },
8090 { { 0, 1 } },
8091 },
8092 {
8093 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
8094 .u.insns_int = {
8095 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8096 BPF_LD_IMM64(R1, 1),
8097 BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
8098 BPF_EXIT_INSN(),
8099 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8100 BPF_EXIT_INSN(),
8101 },
8102 INTERNAL,
8103 { },
8104 { { 0, 1 } },
8105 },
cffc642d
MH		 8106 /* BPF_JMP | BPF_JGE | BPF_K */
8107 {
8108 "JMP_JGE_K: if (3 >= 2) return 1",
8109 .u.insns_int = {
8110 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8111 BPF_LD_IMM64(R1, 3),
8112 BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
8113 BPF_EXIT_INSN(),
8114 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8115 BPF_EXIT_INSN(),
8116 },
8117 INTERNAL,
8118 { },
8119 { { 0, 1 } },
8120 },
92b31a9a
DB		 8121 /* BPF_JMP | BPF_JLE | BPF_K */
8122 {
8123 "JMP_JLE_K: if (2 <= 3) return 1",
8124 .u.insns_int = {
8125 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8126 BPF_LD_IMM64(R1, 2),
8127 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
8128 BPF_EXIT_INSN(),
8129 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8130 BPF_EXIT_INSN(),
8131 },
8132 INTERNAL,
8133 { },
8134 { { 0, 1 } },
8135 },
fe593844
MH		 8136 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
8137 {
8138 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
8139 .u.insns_int = {
8140 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
8141 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
8142 BPF_EXIT_INSN(),
8143 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
8144 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
8145 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
8146 BPF_EXIT_INSN(),
8147 },
8148 INTERNAL,
8149 { },
8150 { { 0, 1 } },
8151 },
cffc642d
MH		 8152 {
8153 "JMP_JGE_K: if (3 >= 3) return 1",
8154 .u.insns_int = {
8155 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8156 BPF_LD_IMM64(R1, 3),
8157 BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
8158 BPF_EXIT_INSN(),
8159 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8160 BPF_EXIT_INSN(),
8161 },
8162 INTERNAL,
8163 { },
8164 { { 0, 1 } },
8165 },
92b31a9a
DB		 8166 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
8167 {
8168 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
8169 .u.insns_int = {
8170 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
8171 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
8172 BPF_EXIT_INSN(),
8173 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
8174 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
8175 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
8176 BPF_EXIT_INSN(),
8177 },
8178 INTERNAL,
8179 { },
8180 { { 0, 1 } },
8181 },
8182 {
8183 "JMP_JLE_K: if (3 <= 3) return 1",
8184 .u.insns_int = {
8185 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8186 BPF_LD_IMM64(R1, 3),
8187 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
8188 BPF_EXIT_INSN(),
8189 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8190 BPF_EXIT_INSN(),
8191 },
8192 INTERNAL,
8193 { },
8194 { { 0, 1 } },
8195 },
cffc642d
MH		 8196 /* BPF_JMP | BPF_JNE | BPF_K */
8197 {
8198 "JMP_JNE_K: if (3 != 2) return 1",
8199 .u.insns_int = {
8200 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8201 BPF_LD_IMM64(R1, 3),
8202 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
8203 BPF_EXIT_INSN(),
8204 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8205 BPF_EXIT_INSN(),
8206 },
8207 INTERNAL,
8208 { },
8209 { { 0, 1 } },
8210 },
8211 /* BPF_JMP | BPF_JEQ | BPF_K */
8212 {
8213 "JMP_JEQ_K: if (3 == 3) return 1",
8214 .u.insns_int = {
8215 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8216 BPF_LD_IMM64(R1, 3),
8217 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
8218 BPF_EXIT_INSN(),
8219 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8220 BPF_EXIT_INSN(),
8221 },
8222 INTERNAL,
8223 { },
8224 { { 0, 1 } },
8225 },
8226 /* BPF_JMP | BPF_JSET | BPF_K */
8227 {
8228 "JMP_JSET_K: if (0x3 & 0x2) return 1",
8229 .u.insns_int = {
8230 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8231 BPF_LD_IMM64(R1, 3),
9f134c34 8232 BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
cffc642d
MH		 8233 BPF_EXIT_INSN(),
8234 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8235 BPF_EXIT_INSN(),
8236 },
8237 INTERNAL,
8238 { },
8239 { { 0, 1 } },
8240 },
8241 {
8242 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
8243 .u.insns_int = {
8244 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8245 BPF_LD_IMM64(R1, 3),
9f134c34 8246 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
cffc642d
MH		 8247 BPF_EXIT_INSN(),
8248 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8249 BPF_EXIT_INSN(),
8250 },
8251 INTERNAL,
8252 { },
8253 { { 0, 1 } },
8254 },
8255 /* BPF_JMP | BPF_JSGT | BPF_X */
8256 {
8257 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
8258 .u.insns_int = {
8259 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8260 BPF_LD_IMM64(R1, -1),
8261 BPF_LD_IMM64(R2, -2),
8262 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
8263 BPF_EXIT_INSN(),
8264 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8265 BPF_EXIT_INSN(),
8266 },
8267 INTERNAL,
8268 { },
8269 { { 0, 1 } },
8270 },
8271 {
8272 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
8273 .u.insns_int = {
8274 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8275 BPF_LD_IMM64(R1, -1),
8276 BPF_LD_IMM64(R2, -1),
8277 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
8278 BPF_EXIT_INSN(),
8279 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8280 BPF_EXIT_INSN(),
8281 },
8282 INTERNAL,
8283 { },
8284 { { 0, 1 } },
8285 },
92b31a9a
DB		 8286 /* BPF_JMP | BPF_JSLT | BPF_X */
8287 {
8288 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
8289 .u.insns_int = {
8290 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8291 BPF_LD_IMM64(R1, -1),
8292 BPF_LD_IMM64(R2, -2),
8293 BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
8294 BPF_EXIT_INSN(),
8295 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8296 BPF_EXIT_INSN(),
8297 },
8298 INTERNAL,
8299 { },
8300 { { 0, 1 } },
8301 },
8302 {
8303 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
8304 .u.insns_int = {
8305 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8306 BPF_LD_IMM64(R1, -1),
8307 BPF_LD_IMM64(R2, -1),
8308 BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
8309 BPF_EXIT_INSN(),
8310 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8311 BPF_EXIT_INSN(),
8312 },
8313 INTERNAL,
8314 { },
8315 { { 0, 1 } },
8316 },
cffc642d
MH		 8317 /* BPF_JMP | BPF_JSGE | BPF_X */
8318 {
8319 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
8320 .u.insns_int = {
8321 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8322 BPF_LD_IMM64(R1, -1),
8323 BPF_LD_IMM64(R2, -2),
8324 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
8325 BPF_EXIT_INSN(),
8326 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8327 BPF_EXIT_INSN(),
8328 },
8329 INTERNAL,
8330 { },
8331 { { 0, 1 } },
8332 },
8333 {
8334 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
8335 .u.insns_int = {
8336 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8337 BPF_LD_IMM64(R1, -1),
8338 BPF_LD_IMM64(R2, -1),
8339 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
8340 BPF_EXIT_INSN(),
8341 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8342 BPF_EXIT_INSN(),
8343 },
8344 INTERNAL,
8345 { },
8346 { { 0, 1 } },
8347 },
92b31a9a
DB		 8348 /* BPF_JMP | BPF_JSLE | BPF_X */
8349 {
8350 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
8351 .u.insns_int = {
8352 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8353 BPF_LD_IMM64(R1, -1),
8354 BPF_LD_IMM64(R2, -2),
8355 BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
8356 BPF_EXIT_INSN(),
8357 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8358 BPF_EXIT_INSN(),
8359 },
8360 INTERNAL,
8361 { },
8362 { { 0, 1 } },
8363 },
8364 {
8365 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
8366 .u.insns_int = {
8367 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8368 BPF_LD_IMM64(R1, -1),
8369 BPF_LD_IMM64(R2, -1),
8370 BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
8371 BPF_EXIT_INSN(),
8372 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8373 BPF_EXIT_INSN(),
8374 },
8375 INTERNAL,
8376 { },
8377 { { 0, 1 } },
8378 },
cffc642d
MH		 8379 /* BPF_JMP | BPF_JGT | BPF_X */
8380 {
8381 "JMP_JGT_X: if (3 > 2) return 1",
8382 .u.insns_int = {
8383 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8384 BPF_LD_IMM64(R1, 3),
8385 BPF_LD_IMM64(R2, 2),
8386 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
8387 BPF_EXIT_INSN(),
8388 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8389 BPF_EXIT_INSN(),
8390 },
8391 INTERNAL,
8392 { },
8393 { { 0, 1 } },
8394 },
c7395d6b
NR		 8395 {
8396 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
8397 .u.insns_int = {
8398 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8399 BPF_LD_IMM64(R1, -1),
8400 BPF_LD_IMM64(R2, 1),
8401 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
8402 BPF_EXIT_INSN(),
8403 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8404 BPF_EXIT_INSN(),
8405 },
8406 INTERNAL,
8407 { },
8408 { { 0, 1 } },
8409 },
92b31a9a
DB		 8410 /* BPF_JMP | BPF_JLT | BPF_X */
8411 {
8412 "JMP_JLT_X: if (2 < 3) return 1",
8413 .u.insns_int = {
8414 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8415 BPF_LD_IMM64(R1, 3),
8416 BPF_LD_IMM64(R2, 2),
8417 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
8418 BPF_EXIT_INSN(),
8419 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8420 BPF_EXIT_INSN(),
8421 },
8422 INTERNAL,
8423 { },
8424 { { 0, 1 } },
8425 },
8426 {
8427 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
8428 .u.insns_int = {
8429 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8430 BPF_LD_IMM64(R1, -1),
8431 BPF_LD_IMM64(R2, 1),
8432 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
8433 BPF_EXIT_INSN(),
8434 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8435 BPF_EXIT_INSN(),
8436 },
8437 INTERNAL,
8438 { },
8439 { { 0, 1 } },
8440 },
cffc642d
MH		 8441 /* BPF_JMP | BPF_JGE | BPF_X */
8442 {
8443 "JMP_JGE_X: if (3 >= 2) return 1",
8444 .u.insns_int = {
8445 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8446 BPF_LD_IMM64(R1, 3),
8447 BPF_LD_IMM64(R2, 2),
8448 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
8449 BPF_EXIT_INSN(),
8450 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8451 BPF_EXIT_INSN(),
8452 },
8453 INTERNAL,
8454 { },
8455 { { 0, 1 } },
8456 },
8457 {
8458 "JMP_JGE_X: if (3 >= 3) return 1",
8459 .u.insns_int = {
8460 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8461 BPF_LD_IMM64(R1, 3),
8462 BPF_LD_IMM64(R2, 3),
8463 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
8464 BPF_EXIT_INSN(),
8465 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8466 BPF_EXIT_INSN(),
8467 },
8468 INTERNAL,
8469 { },
8470 { { 0, 1 } },
8471 },
92b31a9a
DB		 8472 /* BPF_JMP | BPF_JLE | BPF_X */
8473 {
8474 "JMP_JLE_X: if (2 <= 3) return 1",
8475 .u.insns_int = {
8476 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8477 BPF_LD_IMM64(R1, 3),
8478 BPF_LD_IMM64(R2, 2),
8479 BPF_JMP_REG(BPF_JLE, R2, R1, 1),
8480 BPF_EXIT_INSN(),
8481 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8482 BPF_EXIT_INSN(),
8483 },
8484 INTERNAL,
8485 { },
8486 { { 0, 1 } },
8487 },
8488 {
8489 "JMP_JLE_X: if (3 <= 3) return 1",
8490 .u.insns_int = {
8491 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8492 BPF_LD_IMM64(R1, 3),
8493 BPF_LD_IMM64(R2, 3),
8494 BPF_JMP_REG(BPF_JLE, R1, R2, 1),
8495 BPF_EXIT_INSN(),
8496 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8497 BPF_EXIT_INSN(),
8498 },
8499 INTERNAL,
8500 { },
8501 { { 0, 1 } },
8502 },
ddc665a4
DB		 8503 {
8504 /* Mainly testing JIT + imm64 here. */
8505 "JMP_JGE_X: ldimm64 test 1",
8506 .u.insns_int = {
8507 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8508 BPF_LD_IMM64(R1, 3),
8509 BPF_LD_IMM64(R2, 2),
8510 BPF_JMP_REG(BPF_JGE, R1, R2, 2),
86f8e247
GU		 8511 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
8512 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
ddc665a4
DB		 8513 BPF_EXIT_INSN(),
8514 },
8515 INTERNAL,
8516 { },
8517 { { 0, 0xeeeeeeeeU } },
8518 },
8519 {
8520 "JMP_JGE_X: ldimm64 test 2",
8521 .u.insns_int = {
8522 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8523 BPF_LD_IMM64(R1, 3),
8524 BPF_LD_IMM64(R2, 2),
8525 BPF_JMP_REG(BPF_JGE, R1, R2, 0),
86f8e247 8526 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
ddc665a4
DB		 8527 BPF_EXIT_INSN(),
8528 },
8529 INTERNAL,
8530 { },
8531 { { 0, 0xffffffffU } },
8532 },
8533 {
8534 "JMP_JGE_X: ldimm64 test 3",
8535 .u.insns_int = {
8536 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8537 BPF_LD_IMM64(R1, 3),
8538 BPF_LD_IMM64(R2, 2),
8539 BPF_JMP_REG(BPF_JGE, R1, R2, 4),
86f8e247
GU		 8540 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
8541 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
ddc665a4
DB		 8542 BPF_EXIT_INSN(),
8543 },
8544 INTERNAL,
8545 { },
8546 { { 0, 1 } },
8547 },
92b31a9a
DB		 8548 {
8549 "JMP_JLE_X: ldimm64 test 1",
8550 .u.insns_int = {
8551 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8552 BPF_LD_IMM64(R1, 3),
8553 BPF_LD_IMM64(R2, 2),
8554 BPF_JMP_REG(BPF_JLE, R2, R1, 2),
8555 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
8556 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
8557 BPF_EXIT_INSN(),
8558 },
8559 INTERNAL,
8560 { },
8561 { { 0, 0xeeeeeeeeU } },
8562 },
8563 {
8564 "JMP_JLE_X: ldimm64 test 2",
8565 .u.insns_int = {
8566 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8567 BPF_LD_IMM64(R1, 3),
8568 BPF_LD_IMM64(R2, 2),
8569 BPF_JMP_REG(BPF_JLE, R2, R1, 0),
8570 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
8571 BPF_EXIT_INSN(),
8572 },
8573 INTERNAL,
8574 { },
8575 { { 0, 0xffffffffU } },
8576 },
8577 {
8578 "JMP_JLE_X: ldimm64 test 3",
8579 .u.insns_int = {
8580 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8581 BPF_LD_IMM64(R1, 3),
8582 BPF_LD_IMM64(R2, 2),
8583 BPF_JMP_REG(BPF_JLE, R2, R1, 4),
8584 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
8585 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
8586 BPF_EXIT_INSN(),
8587 },
8588 INTERNAL,
8589 { },
8590 { { 0, 1 } },
8591 },
cffc642d
MH		 8592 /* BPF_JMP | BPF_JNE | BPF_X */
8593 {
8594 "JMP_JNE_X: if (3 != 2) return 1",
8595 .u.insns_int = {
8596 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8597 BPF_LD_IMM64(R1, 3),
8598 BPF_LD_IMM64(R2, 2),
8599 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
8600 BPF_EXIT_INSN(),
8601 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8602 BPF_EXIT_INSN(),
8603 },
8604 INTERNAL,
8605 { },
8606 { { 0, 1 } },
8607 },
8608 /* BPF_JMP | BPF_JEQ | BPF_X */
8609 {
8610 "JMP_JEQ_X: if (3 == 3) return 1",
8611 .u.insns_int = {
8612 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8613 BPF_LD_IMM64(R1, 3),
8614 BPF_LD_IMM64(R2, 3),
8615 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
8616 BPF_EXIT_INSN(),
8617 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8618 BPF_EXIT_INSN(),
8619 },
8620 INTERNAL,
8621 { },
8622 { { 0, 1 } },
8623 },
8624 /* BPF_JMP | BPF_JSET | BPF_X */
8625 {
8626 "JMP_JSET_X: if (0x3 & 0x2) return 1",
8627 .u.insns_int = {
8628 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8629 BPF_LD_IMM64(R1, 3),
8630 BPF_LD_IMM64(R2, 2),
9f134c34 8631 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
cffc642d
MH		 8632 BPF_EXIT_INSN(),
8633 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8634 BPF_EXIT_INSN(),
8635 },
8636 INTERNAL,
8637 { },
8638 { { 0, 1 } },
8639 },
8640 {
8641 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
8642 .u.insns_int = {
8643 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8644 BPF_LD_IMM64(R1, 3),
8645 BPF_LD_IMM64(R2, 0xffffffff),
9f134c34 8646 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
cffc642d
MH		 8647 BPF_EXIT_INSN(),
8648 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8649 BPF_EXIT_INSN(),
8650 },
8651 INTERNAL,
8652 { },
8653 { { 0, 1 } },
8654 },
66e5eb84
JA		 8655 { /* Mainly checking JIT here. */
8656 "BPF_MAXINSNS: Very long conditional jump",
8657 { },
8658 INTERNAL | FLAG_NO_DATA,
8659 { },
8660 { { 0, 1 } },
8661 .fill_helper = bpf_fill_long_jmp,
8662 },
bde28bc6
DB		 8663 {
8664 "JMP_JA: Jump, gap, jump, ...",
8665 { },
8666 CLASSIC | FLAG_NO_DATA,
8667 { },
8668 { { 0, 0xababcbac } },
8669 .fill_helper = bpf_fill_ja,
8670 },
a4afd37b
DB		 8671 { /* Mainly checking JIT here. */
8672 "BPF_MAXINSNS: Maximum possible literals",
8673 { },
8674 CLASSIC | FLAG_NO_DATA,
8675 { },
8676 { { 0, 0xffffffff } },
8677 .fill_helper = bpf_fill_maxinsns1,
8678 },
8679 { /* Mainly checking JIT here. */
8680 "BPF_MAXINSNS: Single literal",
8681 { },
8682 CLASSIC | FLAG_NO_DATA,
8683 { },
8684 { { 0, 0xfefefefe } },
8685 .fill_helper = bpf_fill_maxinsns2,
8686 },
8687 { /* Mainly checking JIT here. */
8688 "BPF_MAXINSNS: Run/add until end",
8689 { },
8690 CLASSIC | FLAG_NO_DATA,
8691 { },
8692 { { 0, 0x947bf368 } },
8693 .fill_helper = bpf_fill_maxinsns3,
8694 },
8695 {
8696 "BPF_MAXINSNS: Too many instructions",
8697 { },
8698 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
8699 { },
8700 { },
8701 .fill_helper = bpf_fill_maxinsns4,
09584b40 8702 .expected_errcode = -EINVAL,
a4afd37b
DB		 8703 },
8704 { /* Mainly checking JIT here. */
8705 "BPF_MAXINSNS: Very long jump",
8706 { },
8707 CLASSIC | FLAG_NO_DATA,
8708 { },
8709 { { 0, 0xabababab } },
8710 .fill_helper = bpf_fill_maxinsns5,
8711 },
8712 { /* Mainly checking JIT here. */
8713 "BPF_MAXINSNS: Ctx heavy transformations",
8714 { },
8715 CLASSIC,
8716 { },
8717 {
0c4b2d37
MM		 8718 { 1, SKB_VLAN_PRESENT },
8719 { 10, SKB_VLAN_PRESENT }
a4afd37b
DB		 8720 },
8721 .fill_helper = bpf_fill_maxinsns6,
8722 },
8723 { /* Mainly checking JIT here. */
8724 "BPF_MAXINSNS: Call heavy transformations",
8725 { },
8726 CLASSIC | FLAG_NO_DATA,
8727 { },
8728 { { 1, 0 }, { 10, 0 } },
8729 .fill_helper = bpf_fill_maxinsns7,
8730 },
8731 { /* Mainly checking JIT here. */
8732 "BPF_MAXINSNS: Jump heavy test",
8733 { },
8734 CLASSIC | FLAG_NO_DATA,
8735 { },
8736 { { 0, 0xffffffff } },
8737 .fill_helper = bpf_fill_maxinsns8,
8738 },
3b529602
DB		 8739 { /* Mainly checking JIT here. */
8740 "BPF_MAXINSNS: Very long jump backwards",
8741 { },
8742 INTERNAL | FLAG_NO_DATA,
8743 { },
8744 { { 0, 0xcbababab } },
8745 .fill_helper = bpf_fill_maxinsns9,
8746 },
8747 { /* Mainly checking JIT here. */
8748 "BPF_MAXINSNS: Edge hopping nuthouse",
8749 { },
8750 INTERNAL | FLAG_NO_DATA,
8751 { },
8752 { { 0, 0xabababac } },
8753 .fill_helper = bpf_fill_maxinsns10,
8754 },
bde28bc6
DB		 8755 {
8756 "BPF_MAXINSNS: Jump, gap, jump, ...",
8757 { },
8758 CLASSIC | FLAG_NO_DATA,
8759 { },
8760 { { 0, 0xababcbac } },
8761 .fill_helper = bpf_fill_maxinsns11,
8762 },
be08815c
DB		 8763 {
8764 "BPF_MAXINSNS: jump over MSH",
8765 { },
8766 CLASSIC | FLAG_EXPECTED_FAIL,
8767 { 0xfa, 0xfb, 0xfc, 0xfd, },
8768 { { 4, 0xabababab } },
8769 .fill_helper = bpf_fill_maxinsns12,
8770 .expected_errcode = -EINVAL,
8771 },
8772 {
8773 "BPF_MAXINSNS: exec all MSH",
8774 { },
8775 CLASSIC,
8776 { 0xfa, 0xfb, 0xfc, 0xfd, },
8777 { { 4, 0xababab83 } },
8778 .fill_helper = bpf_fill_maxinsns13,
8779 },
4d9c5c53
AS		 8780 {
8781 "BPF_MAXINSNS: ld_abs+get_processor_id",
8782 { },
8783 CLASSIC,
8784 { },
8785 { { 1, 0xbee } },
8786 .fill_helper = bpf_fill_ld_abs_get_processor_id,
8787 },
2cf1ad75
NS		 8788 /*
8789 * LD_IND / LD_ABS on fragmented SKBs
8790 */
8791 {
8792 "LD_IND byte frag",
8793 .u.insns = {
8794 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
8795 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
8796 BPF_STMT(BPF_RET | BPF_A, 0x0),
8797 },
8798 CLASSIC | FLAG_SKB_FRAG,
8799 { },
8800 { {0x40, 0x42} },
8801 .frag_data = {
8802 0x42, 0x00, 0x00, 0x00,
8803 0x43, 0x44, 0x00, 0x00,
8804 0x21, 0x07, 0x19, 0x83,
8805 },
8806 },
8807 {
8808 "LD_IND halfword frag",
8809 .u.insns = {
8810 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
8811 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
8812 BPF_STMT(BPF_RET | BPF_A, 0x0),
8813 },
8814 CLASSIC | FLAG_SKB_FRAG,
8815 { },
8816 { {0x40, 0x4344} },
8817 .frag_data = {
8818 0x42, 0x00, 0x00, 0x00,
8819 0x43, 0x44, 0x00, 0x00,
8820 0x21, 0x07, 0x19, 0x83,
8821 },
8822 },
8823 {
8824 "LD_IND word frag",
8825 .u.insns = {
8826 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
8827 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
8828 BPF_STMT(BPF_RET | BPF_A, 0x0),
8829 },
8830 CLASSIC | FLAG_SKB_FRAG,
8831 { },
8832 { {0x40, 0x21071983} },
8833 .frag_data = {
8834 0x42, 0x00, 0x00, 0x00,
8835 0x43, 0x44, 0x00, 0x00,
8836 0x21, 0x07, 0x19, 0x83,
8837 },
8838 },
8839 {
8840 "LD_IND halfword mixed head/frag",
8841 .u.insns = {
8842 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
8843 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
8844 BPF_STMT(BPF_RET | BPF_A, 0x0),
8845 },
8846 CLASSIC | FLAG_SKB_FRAG,
8847 { [0x3e] = 0x25, [0x3f] = 0x05, },
8848 { {0x40, 0x0519} },
8849 .frag_data = { 0x19, 0x82 },
8850 },
8851 {
8852 "LD_IND word mixed head/frag",
8853 .u.insns = {
8854 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
8855 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
8856 BPF_STMT(BPF_RET | BPF_A, 0x0),
8857 },
8858 CLASSIC | FLAG_SKB_FRAG,
8859 { [0x3e] = 0x25, [0x3f] = 0x05, },
8860 { {0x40, 0x25051982} },
8861 .frag_data = { 0x19, 0x82 },
8862 },
8863 {
8864 "LD_ABS byte frag",
8865 .u.insns = {
8866 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
8867 BPF_STMT(BPF_RET | BPF_A, 0x0),
8868 },
8869 CLASSIC | FLAG_SKB_FRAG,
8870 { },
8871 { {0x40, 0x42} },
8872 .frag_data = {
8873 0x42, 0x00, 0x00, 0x00,
8874 0x43, 0x44, 0x00, 0x00,
8875 0x21, 0x07, 0x19, 0x83,
8876 },
8877 },
8878 {
8879 "LD_ABS halfword frag",
8880 .u.insns = {
8881 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
8882 BPF_STMT(BPF_RET | BPF_A, 0x0),
8883 },
8884 CLASSIC | FLAG_SKB_FRAG,
8885 { },
8886 { {0x40, 0x4344} },
8887 .frag_data = {
8888 0x42, 0x00, 0x00, 0x00,
8889 0x43, 0x44, 0x00, 0x00,
8890 0x21, 0x07, 0x19, 0x83,
8891 },
8892 },
8893 {
8894 "LD_ABS word frag",
8895 .u.insns = {
8896 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
8897 BPF_STMT(BPF_RET | BPF_A, 0x0),
8898 },
8899 CLASSIC | FLAG_SKB_FRAG,
8900 { },
8901 { {0x40, 0x21071983} },
8902 .frag_data = {
8903 0x42, 0x00, 0x00, 0x00,
8904 0x43, 0x44, 0x00, 0x00,
8905 0x21, 0x07, 0x19, 0x83,
8906 },
8907 },
8908 {
8909 "LD_ABS halfword mixed head/frag",
8910 .u.insns = {
8911 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
8912 BPF_STMT(BPF_RET | BPF_A, 0x0),
8913 },
8914 CLASSIC | FLAG_SKB_FRAG,
8915 { [0x3e] = 0x25, [0x3f] = 0x05, },
8916 { {0x40, 0x0519} },
8917 .frag_data = { 0x19, 0x82 },
8918 },
8919 {
8920 "LD_ABS word mixed head/frag",
8921 .u.insns = {
8922 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
8923 BPF_STMT(BPF_RET | BPF_A, 0x0),
8924 },
8925 CLASSIC | FLAG_SKB_FRAG,
8926 { [0x3e] = 0x25, [0x3f] = 0x05, },
8927 { {0x40, 0x25051982} },
8928 .frag_data = { 0x19, 0x82 },
8929 },
08fcb08f
NS		 8930 /*
8931 * LD_IND / LD_ABS on non fragmented SKBs
8932 */
8933 {
8934 /*
8935 * this tests that the JIT/interpreter correctly resets X
8936 * before using it in an LD_IND instruction.
8937 */
8938 "LD_IND byte default X",
8939 .u.insns = {
8940 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
8941 BPF_STMT(BPF_RET | BPF_A, 0x0),
8942 },
8943 CLASSIC,
8944 { [0x1] = 0x42 },
8945 { {0x40, 0x42 } },
8946 },
8947 {
8948 "LD_IND byte positive offset",
8949 .u.insns = {
8950 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
8951 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
8952 BPF_STMT(BPF_RET | BPF_A, 0x0),
8953 },
8954 CLASSIC,
8955 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
8956 { {0x40, 0x82 } },
8957 },
8958 {
8959 "LD_IND byte negative offset",
8960 .u.insns = {
8961 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
8962 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
8963 BPF_STMT(BPF_RET | BPF_A, 0x0),
8964 },
8965 CLASSIC,
8966 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
8967 { {0x40, 0x05 } },
8968 },
93731ef0
DB		 8969 {
8970 "LD_IND byte positive offset, all ff",
8971 .u.insns = {
8972 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
8973 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
8974 BPF_STMT(BPF_RET | BPF_A, 0x0),
8975 },
8976 CLASSIC,
8977 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
8978 { {0x40, 0xff } },
8979 },
8980 {
8981 "LD_IND byte positive offset, out of bounds",
8982 .u.insns = {
8983 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
8984 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
8985 BPF_STMT(BPF_RET | BPF_A, 0x0),
8986 },
8987 CLASSIC,
8988 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
8989 { {0x3f, 0 }, },
8990 },
8991 {
8992 "LD_IND byte negative offset, out of bounds",
8993 .u.insns = {
8994 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
8995 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
8996 BPF_STMT(BPF_RET | BPF_A, 0x0),
8997 },
8998 CLASSIC,
8999 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9000 { {0x3f, 0 } },
9001 },
9002 {
9003 "LD_IND byte negative offset, multiple calls",
9004 .u.insns = {
9005 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
9006 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
9007 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
9008 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
9009 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
9010 BPF_STMT(BPF_RET | BPF_A, 0x0),
9011 },
9012 CLASSIC,
9013 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9014 { {0x40, 0x82 }, },
9015 },
08fcb08f
NS		 9016 {
9017 "LD_IND halfword positive offset",
9018 .u.insns = {
9019 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9020 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
9021 BPF_STMT(BPF_RET | BPF_A, 0x0),
9022 },
9023 CLASSIC,
9024 {
9025 [0x1c] = 0xaa, [0x1d] = 0x55,
9026 [0x1e] = 0xbb, [0x1f] = 0x66,
9027 [0x20] = 0xcc, [0x21] = 0x77,
9028 [0x22] = 0xdd, [0x23] = 0x88,
9029 },
9030 { {0x40, 0xdd88 } },
9031 },
9032 {
9033 "LD_IND halfword negative offset",
9034 .u.insns = {
9035 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9036 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
9037 BPF_STMT(BPF_RET | BPF_A, 0x0),
9038 },
9039 CLASSIC,
9040 {
9041 [0x1c] = 0xaa, [0x1d] = 0x55,
9042 [0x1e] = 0xbb, [0x1f] = 0x66,
9043 [0x20] = 0xcc, [0x21] = 0x77,
9044 [0x22] = 0xdd, [0x23] = 0x88,
9045 },
9046 { {0x40, 0xbb66 } },
9047 },
9048 {
9049 "LD_IND halfword unaligned",
9050 .u.insns = {
9051 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9052 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
9053 BPF_STMT(BPF_RET | BPF_A, 0x0),
9054 },
9055 CLASSIC,
9056 {
9057 [0x1c] = 0xaa, [0x1d] = 0x55,
9058 [0x1e] = 0xbb, [0x1f] = 0x66,
9059 [0x20] = 0xcc, [0x21] = 0x77,
9060 [0x22] = 0xdd, [0x23] = 0x88,
9061 },
9062 { {0x40, 0x66cc } },
9063 },
93731ef0
DB		 9064 {
9065 "LD_IND halfword positive offset, all ff",
9066 .u.insns = {
9067 BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
9068 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
9069 BPF_STMT(BPF_RET | BPF_A, 0x0),
9070 },
9071 CLASSIC,
9072 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9073 { {0x40, 0xffff } },
9074 },
9075 {
9076 "LD_IND halfword positive offset, out of bounds",
9077 .u.insns = {
9078 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9079 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
9080 BPF_STMT(BPF_RET | BPF_A, 0x0),
9081 },
9082 CLASSIC,
9083 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9084 { {0x3f, 0 }, },
9085 },
9086 {
9087 "LD_IND halfword negative offset, out of bounds",
9088 .u.insns = {
9089 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9090 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
9091 BPF_STMT(BPF_RET | BPF_A, 0x0),
9092 },
9093 CLASSIC,
9094 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9095 { {0x3f, 0 } },
9096 },
08fcb08f
NS		 9097 {
9098 "LD_IND word positive offset",
9099 .u.insns = {
9100 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9101 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
9102 BPF_STMT(BPF_RET | BPF_A, 0x0),
9103 },
9104 CLASSIC,
9105 {
9106 [0x1c] = 0xaa, [0x1d] = 0x55,
9107 [0x1e] = 0xbb, [0x1f] = 0x66,
9108 [0x20] = 0xcc, [0x21] = 0x77,
9109 [0x22] = 0xdd, [0x23] = 0x88,
9110 [0x24] = 0xee, [0x25] = 0x99,
9111 [0x26] = 0xff, [0x27] = 0xaa,
9112 },
9113 { {0x40, 0xee99ffaa } },
9114 },
9115 {
9116 "LD_IND word negative offset",
9117 .u.insns = {
9118 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9119 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
9120 BPF_STMT(BPF_RET | BPF_A, 0x0),
9121 },
9122 CLASSIC,
9123 {
9124 [0x1c] = 0xaa, [0x1d] = 0x55,
9125 [0x1e] = 0xbb, [0x1f] = 0x66,
9126 [0x20] = 0xcc, [0x21] = 0x77,
9127 [0x22] = 0xdd, [0x23] = 0x88,
9128 [0x24] = 0xee, [0x25] = 0x99,
9129 [0x26] = 0xff, [0x27] = 0xaa,
9130 },
9131 { {0x40, 0xaa55bb66 } },
9132 },
9133 {
9134 "LD_IND word unaligned (addr & 3 == 2)",
9135 .u.insns = {
9136 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9137 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
9138 BPF_STMT(BPF_RET | BPF_A, 0x0),
9139 },
9140 CLASSIC,
9141 {
9142 [0x1c] = 0xaa, [0x1d] = 0x55,
9143 [0x1e] = 0xbb, [0x1f] = 0x66,
9144 [0x20] = 0xcc, [0x21] = 0x77,
9145 [0x22] = 0xdd, [0x23] = 0x88,
9146 [0x24] = 0xee, [0x25] = 0x99,
9147 [0x26] = 0xff, [0x27] = 0xaa,
9148 },
9149 { {0x40, 0xbb66cc77 } },
9150 },
9151 {
9152 "LD_IND word unaligned (addr & 3 == 1)",
9153 .u.insns = {
9154 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9155 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
9156 BPF_STMT(BPF_RET | BPF_A, 0x0),
9157 },
9158 CLASSIC,
9159 {
9160 [0x1c] = 0xaa, [0x1d] = 0x55,
9161 [0x1e] = 0xbb, [0x1f] = 0x66,
9162 [0x20] = 0xcc, [0x21] = 0x77,
9163 [0x22] = 0xdd, [0x23] = 0x88,
9164 [0x24] = 0xee, [0x25] = 0x99,
9165 [0x26] = 0xff, [0x27] = 0xaa,
9166 },
9167 { {0x40, 0x55bb66cc } },
9168 },
9169 {
9170 "LD_IND word unaligned (addr & 3 == 3)",
9171 .u.insns = {
9172 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9173 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
9174 BPF_STMT(BPF_RET | BPF_A, 0x0),
9175 },
9176 CLASSIC,
9177 {
9178 [0x1c] = 0xaa, [0x1d] = 0x55,
9179 [0x1e] = 0xbb, [0x1f] = 0x66,
9180 [0x20] = 0xcc, [0x21] = 0x77,
9181 [0x22] = 0xdd, [0x23] = 0x88,
9182 [0x24] = 0xee, [0x25] = 0x99,
9183 [0x26] = 0xff, [0x27] = 0xaa,
9184 },
9185 { {0x40, 0x66cc77dd } },
9186 },
93731ef0
DB		 9187 {
9188 "LD_IND word positive offset, all ff",
9189 .u.insns = {
9190 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
9191 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
9192 BPF_STMT(BPF_RET | BPF_A, 0x0),
9193 },
9194 CLASSIC,
9195 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9196 { {0x40, 0xffffffff } },
9197 },
9198 {
9199 "LD_IND word positive offset, out of bounds",
9200 .u.insns = {
9201 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9202 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
9203 BPF_STMT(BPF_RET | BPF_A, 0x0),
9204 },
9205 CLASSIC,
9206 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9207 { {0x3f, 0 }, },
9208 },
9209 {
9210 "LD_IND word negative offset, out of bounds",
9211 .u.insns = {
9212 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9213 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
9214 BPF_STMT(BPF_RET | BPF_A, 0x0),
9215 },
9216 CLASSIC,
9217 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9218 { {0x3f, 0 } },
9219 },
08fcb08f
NS		 9220 {
9221 "LD_ABS byte",
9222 .u.insns = {
9223 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
9224 BPF_STMT(BPF_RET | BPF_A, 0x0),
9225 },
9226 CLASSIC,
9227 {
9228 [0x1c] = 0xaa, [0x1d] = 0x55,
9229 [0x1e] = 0xbb, [0x1f] = 0x66,
9230 [0x20] = 0xcc, [0x21] = 0x77,
9231 [0x22] = 0xdd, [0x23] = 0x88,
9232 [0x24] = 0xee, [0x25] = 0x99,
9233 [0x26] = 0xff, [0x27] = 0xaa,
9234 },
9235 { {0x40, 0xcc } },
9236 },
93731ef0
DB		 9237 {
9238 "LD_ABS byte positive offset, all ff",
9239 .u.insns = {
9240 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
9241 BPF_STMT(BPF_RET | BPF_A, 0x0),
9242 },
9243 CLASSIC,
9244 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9245 { {0x40, 0xff } },
9246 },
9247 {
9248 "LD_ABS byte positive offset, out of bounds",
9249 .u.insns = {
9250 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
9251 BPF_STMT(BPF_RET | BPF_A, 0x0),
9252 },
9253 CLASSIC,
9254 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9255 { {0x3f, 0 }, },
9256 },
9257 {
9258 "LD_ABS byte negative offset, out of bounds load",
9259 .u.insns = {
9260 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
9261 BPF_STMT(BPF_RET | BPF_A, 0x0),
9262 },
9263 CLASSIC | FLAG_EXPECTED_FAIL,
9264 .expected_errcode = -EINVAL,
9265 },
9266 {
9267 "LD_ABS byte negative offset, in bounds",
9268 .u.insns = {
9269 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
9270 BPF_STMT(BPF_RET | BPF_A, 0x0),
9271 },
9272 CLASSIC,
9273 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9274 { {0x40, 0x82 }, },
9275 },
9276 {
9277 "LD_ABS byte negative offset, out of bounds",
9278 .u.insns = {
9279 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
9280 BPF_STMT(BPF_RET | BPF_A, 0x0),
9281 },
9282 CLASSIC,
9283 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9284 { {0x3f, 0 }, },
9285 },
9286 {
9287 "LD_ABS byte negative offset, multiple calls",
9288 .u.insns = {
9289 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
9290 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
9291 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
9292 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
9293 BPF_STMT(BPF_RET | BPF_A, 0x0),
9294 },
9295 CLASSIC,
9296 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9297 { {0x40, 0x82 }, },
9298 },
08fcb08f
NS		 9299 {
9300 "LD_ABS halfword",
9301 .u.insns = {
9302 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
9303 BPF_STMT(BPF_RET | BPF_A, 0x0),
9304 },
9305 CLASSIC,
9306 {
9307 [0x1c] = 0xaa, [0x1d] = 0x55,
9308 [0x1e] = 0xbb, [0x1f] = 0x66,
9309 [0x20] = 0xcc, [0x21] = 0x77,
9310 [0x22] = 0xdd, [0x23] = 0x88,
9311 [0x24] = 0xee, [0x25] = 0x99,
9312 [0x26] = 0xff, [0x27] = 0xaa,
9313 },
9314 { {0x40, 0xdd88 } },
9315 },
9316 {
9317 "LD_ABS halfword unaligned",
9318 .u.insns = {
9319 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
9320 BPF_STMT(BPF_RET | BPF_A, 0x0),
9321 },
9322 CLASSIC,
9323 {
9324 [0x1c] = 0xaa, [0x1d] = 0x55,
9325 [0x1e] = 0xbb, [0x1f] = 0x66,
9326 [0x20] = 0xcc, [0x21] = 0x77,
9327 [0x22] = 0xdd, [0x23] = 0x88,
9328 [0x24] = 0xee, [0x25] = 0x99,
9329 [0x26] = 0xff, [0x27] = 0xaa,
9330 },
9331 { {0x40, 0x99ff } },
9332 },
93731ef0
DB		 9333 {
9334 "LD_ABS halfword positive offset, all ff",
9335 .u.insns = {
9336 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
9337 BPF_STMT(BPF_RET | BPF_A, 0x0),
9338 },
9339 CLASSIC,
9340 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9341 { {0x40, 0xffff } },
9342 },
9343 {
9344 "LD_ABS halfword positive offset, out of bounds",
9345 .u.insns = {
9346 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
9347 BPF_STMT(BPF_RET | BPF_A, 0x0),
9348 },
9349 CLASSIC,
9350 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9351 { {0x3f, 0 }, },
9352 },
9353 {
9354 "LD_ABS halfword negative offset, out of bounds load",
9355 .u.insns = {
9356 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
9357 BPF_STMT(BPF_RET | BPF_A, 0x0),
9358 },
9359 CLASSIC | FLAG_EXPECTED_FAIL,
9360 .expected_errcode = -EINVAL,
9361 },
9362 {
9363 "LD_ABS halfword negative offset, in bounds",
9364 .u.insns = {
9365 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
9366 BPF_STMT(BPF_RET | BPF_A, 0x0),
9367 },
9368 CLASSIC,
9369 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9370 { {0x40, 0x1982 }, },
9371 },
9372 {
9373 "LD_ABS halfword negative offset, out of bounds",
9374 .u.insns = {
9375 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
9376 BPF_STMT(BPF_RET | BPF_A, 0x0),
9377 },
9378 CLASSIC,
9379 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9380 { {0x3f, 0 }, },
9381 },
08fcb08f
NS		 9382 {
9383 "LD_ABS word",
9384 .u.insns = {
9385 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
9386 BPF_STMT(BPF_RET | BPF_A, 0x0),
9387 },
9388 CLASSIC,
9389 {
9390 [0x1c] = 0xaa, [0x1d] = 0x55,
9391 [0x1e] = 0xbb, [0x1f] = 0x66,
9392 [0x20] = 0xcc, [0x21] = 0x77,
9393 [0x22] = 0xdd, [0x23] = 0x88,
9394 [0x24] = 0xee, [0x25] = 0x99,
9395 [0x26] = 0xff, [0x27] = 0xaa,
9396 },
9397 { {0x40, 0xaa55bb66 } },
9398 },
9399 {
9400 "LD_ABS word unaligned (addr & 3 == 2)",
9401 .u.insns = {
9402 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
9403 BPF_STMT(BPF_RET | BPF_A, 0x0),
9404 },
9405 CLASSIC,
9406 {
9407 [0x1c] = 0xaa, [0x1d] = 0x55,
9408 [0x1e] = 0xbb, [0x1f] = 0x66,
9409 [0x20] = 0xcc, [0x21] = 0x77,
9410 [0x22] = 0xdd, [0x23] = 0x88,
9411 [0x24] = 0xee, [0x25] = 0x99,
9412 [0x26] = 0xff, [0x27] = 0xaa,
9413 },
9414 { {0x40, 0xdd88ee99 } },
9415 },
9416 {
9417 "LD_ABS word unaligned (addr & 3 == 1)",
9418 .u.insns = {
9419 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
9420 BPF_STMT(BPF_RET | BPF_A, 0x0),
9421 },
9422 CLASSIC,
9423 {
9424 [0x1c] = 0xaa, [0x1d] = 0x55,
9425 [0x1e] = 0xbb, [0x1f] = 0x66,
9426 [0x20] = 0xcc, [0x21] = 0x77,
9427 [0x22] = 0xdd, [0x23] = 0x88,
9428 [0x24] = 0xee, [0x25] = 0x99,
9429 [0x26] = 0xff, [0x27] = 0xaa,
9430 },
9431 { {0x40, 0x77dd88ee } },
9432 },
9433 {
9434 "LD_ABS word unaligned (addr & 3 == 3)",
9435 .u.insns = {
9436 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
9437 BPF_STMT(BPF_RET | BPF_A, 0x0),
9438 },
9439 CLASSIC,
9440 {
9441 [0x1c] = 0xaa, [0x1d] = 0x55,
9442 [0x1e] = 0xbb, [0x1f] = 0x66,
9443 [0x20] = 0xcc, [0x21] = 0x77,
9444 [0x22] = 0xdd, [0x23] = 0x88,
9445 [0x24] = 0xee, [0x25] = 0x99,
9446 [0x26] = 0xff, [0x27] = 0xaa,
9447 },
9448 { {0x40, 0x88ee99ff } },
9449 },
93731ef0
DB		 9450 {
9451 "LD_ABS word positive offset, all ff",
9452 .u.insns = {
9453 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
9454 BPF_STMT(BPF_RET | BPF_A, 0x0),
9455 },
9456 CLASSIC,
9457 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9458 { {0x40, 0xffffffff } },
9459 },
9460 {
9461 "LD_ABS word positive offset, out of bounds",
9462 .u.insns = {
9463 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
9464 BPF_STMT(BPF_RET | BPF_A, 0x0),
9465 },
9466 CLASSIC,
9467 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9468 { {0x3f, 0 }, },
9469 },
9470 {
9471 "LD_ABS word negative offset, out of bounds load",
9472 .u.insns = {
9473 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
9474 BPF_STMT(BPF_RET | BPF_A, 0x0),
9475 },
9476 CLASSIC | FLAG_EXPECTED_FAIL,
9477 .expected_errcode = -EINVAL,
9478 },
9479 {
9480 "LD_ABS word negative offset, in bounds",
9481 .u.insns = {
9482 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
9483 BPF_STMT(BPF_RET | BPF_A, 0x0),
9484 },
9485 CLASSIC,
9486 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9487 { {0x40, 0x25051982 }, },
9488 },
9489 {
9490 "LD_ABS word negative offset, out of bounds",
9491 .u.insns = {
9492 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
9493 BPF_STMT(BPF_RET | BPF_A, 0x0),
9494 },
9495 CLASSIC,
9496 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9497 { {0x3f, 0 }, },
9498 },
9499 {
9500 "LDX_MSH standalone, preserved A",
9501 .u.insns = {
9502 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
9503 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
9504 BPF_STMT(BPF_RET | BPF_A, 0x0),
9505 },
9506 CLASSIC,
9507 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9508 { {0x40, 0xffeebbaa }, },
9509 },
9510 {
9511 "LDX_MSH standalone, preserved A 2",
9512 .u.insns = {
9513 BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
9514 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
9515 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
9516 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
9517 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
9518 BPF_STMT(BPF_RET | BPF_A, 0x0),
9519 },
9520 CLASSIC,
9521 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9522 { {0x40, 0x175e9d63 }, },
9523 },
9524 {
9525 "LDX_MSH standalone, test result 1",
9526 .u.insns = {
9527 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
9528 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
9529 BPF_STMT(BPF_MISC | BPF_TXA, 0),
9530 BPF_STMT(BPF_RET | BPF_A, 0x0),
9531 },
9532 CLASSIC,
9533 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9534 { {0x40, 0x14 }, },
9535 },
9536 {
9537 "LDX_MSH standalone, test result 2",
9538 .u.insns = {
9539 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
9540 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
9541 BPF_STMT(BPF_MISC | BPF_TXA, 0),
9542 BPF_STMT(BPF_RET | BPF_A, 0x0),
9543 },
9544 CLASSIC,
9545 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9546 { {0x40, 0x24 }, },
9547 },
9548 {
9549 "LDX_MSH standalone, negative offset",
9550 .u.insns = {
9551 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
9552 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
9553 BPF_STMT(BPF_MISC | BPF_TXA, 0),
9554 BPF_STMT(BPF_RET | BPF_A, 0x0),
9555 },
9556 CLASSIC,
9557 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9558 { {0x40, 0 }, },
9559 },
9560 {
9561 "LDX_MSH standalone, negative offset 2",
9562 .u.insns = {
9563 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
9564 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
9565 BPF_STMT(BPF_MISC | BPF_TXA, 0),
9566 BPF_STMT(BPF_RET | BPF_A, 0x0),
9567 },
9568 CLASSIC,
9569 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9570 { {0x40, 0x24 }, },
9571 },
9572 {
9573 "LDX_MSH standalone, out of bounds",
9574 .u.insns = {
9575 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
9576 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
9577 BPF_STMT(BPF_MISC | BPF_TXA, 0),
9578 BPF_STMT(BPF_RET | BPF_A, 0x0),
9579 },
9580 CLASSIC,
9581 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9582 { {0x40, 0 }, },
9583 },
86bf1721
NS		 9584 /*
9585 * verify that the interpreter or JIT correctly sets A and X
9586 * to 0.
9587 */
9588 {
9589 "ADD default X",
9590 .u.insns = {
9591 /*
9592 * A = 0x42
9593 * A = A + X
9594 * ret A
9595 */
9596 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
9597 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
9598 BPF_STMT(BPF_RET | BPF_A, 0x0),
9599 },
9600 CLASSIC | FLAG_NO_DATA,
9601 {},
9602 { {0x1, 0x42 } },
9603 },
9604 {
9605 "ADD default A",
9606 .u.insns = {
9607 /*
9608 * A = A + 0x42
9609 * ret A
9610 */
9611 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
9612 BPF_STMT(BPF_RET | BPF_A, 0x0),
9613 },
9614 CLASSIC | FLAG_NO_DATA,
9615 {},
9616 { {0x1, 0x42 } },
9617 },
9618 {
9619 "SUB default X",
9620 .u.insns = {
9621 /*
9622 * A = 0x66
9623 * A = A - X
9624 * ret A
9625 */
9626 BPF_STMT(BPF_LD | BPF_IMM, 0x66),
9627 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
9628 BPF_STMT(BPF_RET | BPF_A, 0x0),
9629 },
9630 CLASSIC | FLAG_NO_DATA,
9631 {},
9632 { {0x1, 0x66 } },
9633 },
9634 {
9635 "SUB default A",
9636 .u.insns = {
9637 /*
9638 * A = A - -0x66
9639 * ret A
9640 */
9641 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
9642 BPF_STMT(BPF_RET | BPF_A, 0x0),
9643 },
9644 CLASSIC | FLAG_NO_DATA,
9645 {},
9646 { {0x1, 0x66 } },
9647 },
9648 {
9649 "MUL default X",
9650 .u.insns = {
9651 /*
9652 * A = 0x42
9653 * A = A * X
9654 * ret A
9655 */
9656 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
9657 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
9658 BPF_STMT(BPF_RET | BPF_A, 0x0),
9659 },
9660 CLASSIC | FLAG_NO_DATA,
9661 {},
9662 { {0x1, 0x0 } },
9663 },
9664 {
9665 "MUL default A",
9666 .u.insns = {
9667 /*
9668 * A = A * 0x66
9669 * ret A
9670 */
9671 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
9672 BPF_STMT(BPF_RET | BPF_A, 0x0),
9673 },
9674 CLASSIC | FLAG_NO_DATA,
9675 {},
9676 { {0x1, 0x0 } },
9677 },
9678 {
9679 "DIV default X",
9680 .u.insns = {
9681 /*
9682 * A = 0x42
9683 * A = A / X ; this halt the filter execution if X is 0
9684 * ret 0x42
9685 */
9686 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
9687 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
9688 BPF_STMT(BPF_RET | BPF_K, 0x42),
9689 },
9690 CLASSIC | FLAG_NO_DATA,
9691 {},
9692 { {0x1, 0x0 } },
9693 },
9694 {
9695 "DIV default A",
9696 .u.insns = {
9697 /*
9698 * A = A / 1
9699 * ret A
9700 */
9701 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
9702 BPF_STMT(BPF_RET | BPF_A, 0x0),
9703 },
9704 CLASSIC | FLAG_NO_DATA,
9705 {},
9706 { {0x1, 0x0 } },
9707 },
d4e4bc16
YS		 9708 {
9709 "MOD default X",
9710 .u.insns = {
9711 /*
9712 * A = 0x42
9713 * A = A mod X ; this halt the filter execution if X is 0
9714 * ret 0x42
9715 */
9716 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
9717 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
9718 BPF_STMT(BPF_RET | BPF_K, 0x42),
9719 },
9720 CLASSIC | FLAG_NO_DATA,
9721 {},
9722 { {0x1, 0x0 } },
9723 },
9724 {
9725 "MOD default A",
9726 .u.insns = {
9727 /*
9728 * A = A mod 1
9729 * ret A
9730 */
9731 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
9732 BPF_STMT(BPF_RET | BPF_A, 0x0),
9733 },
9734 CLASSIC | FLAG_NO_DATA,
9735 {},
9736 { {0x1, 0x0 } },
9737 },
86bf1721
NS		 9738 {
9739 "JMP EQ default A",
9740 .u.insns = {
9741 /*
9742 * cmp A, 0x0, 0, 1
9743 * ret 0x42
9744 * ret 0x66
9745 */
9746 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
9747 BPF_STMT(BPF_RET | BPF_K, 0x42),
9748 BPF_STMT(BPF_RET | BPF_K, 0x66),
9749 },
9750 CLASSIC | FLAG_NO_DATA,
9751 {},
9752 { {0x1, 0x42 } },
9753 },
9754 {
9755 "JMP EQ default X",
9756 .u.insns = {
9757 /*
9758 * A = 0x0
9759 * cmp A, X, 0, 1
9760 * ret 0x42
9761 * ret 0x66
9762 */
9763 BPF_STMT(BPF_LD | BPF_IMM, 0x0),
9764 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
9765 BPF_STMT(BPF_RET | BPF_K, 0x42),
9766 BPF_STMT(BPF_RET | BPF_K, 0x66),
9767 },
9768 CLASSIC | FLAG_NO_DATA,
9769 {},
9770 { {0x1, 0x42 } },
9771 },
fcd1c917
DB		 9772 /* Checking interpreter vs JIT wrt signed extended imms. */
9773 {
9774 "JNE signed compare, test 1",
9775 .u.insns_int = {
9776 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
9777 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
9778 BPF_MOV64_REG(R2, R1),
9779 BPF_ALU64_REG(BPF_AND, R2, R3),
9780 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9781 BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
9782 BPF_ALU32_IMM(BPF_MOV, R0, 2),
9783 BPF_EXIT_INSN(),
9784 },
9785 INTERNAL,
9786 { },
9787 { { 0, 1 } },
9788 },
9789 {
9790 "JNE signed compare, test 2",
9791 .u.insns_int = {
9792 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
9793 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
9794 BPF_MOV64_REG(R2, R1),
9795 BPF_ALU64_REG(BPF_AND, R2, R3),
9796 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9797 BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
9798 BPF_ALU32_IMM(BPF_MOV, R0, 2),
9799 BPF_EXIT_INSN(),
9800 },
9801 INTERNAL,
9802 { },
9803 { { 0, 1 } },
9804 },
9805 {
9806 "JNE signed compare, test 3",
9807 .u.insns_int = {
9808 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
9809 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
9810 BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
9811 BPF_MOV64_REG(R2, R1),
9812 BPF_ALU64_REG(BPF_AND, R2, R3),
9813 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9814 BPF_JMP_REG(BPF_JNE, R2, R4, 1),
9815 BPF_ALU32_IMM(BPF_MOV, R0, 2),
9816 BPF_EXIT_INSN(),
9817 },
9818 INTERNAL,
9819 { },
9820 { { 0, 2 } },
9821 },
9822 {
9823 "JNE signed compare, test 4",
9824 .u.insns_int = {
9825 BPF_LD_IMM64(R1, -17104896),
9826 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9827 BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
9828 BPF_ALU32_IMM(BPF_MOV, R0, 2),
9829 BPF_EXIT_INSN(),
9830 },
9831 INTERNAL,
9832 { },
9833 { { 0, 2 } },
9834 },
9835 {
9836 "JNE signed compare, test 5",
9837 .u.insns_int = {
9838 BPF_LD_IMM64(R1, 0xfefb0000),
9839 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9840 BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
9841 BPF_ALU32_IMM(BPF_MOV, R0, 2),
9842 BPF_EXIT_INSN(),
9843 },
9844 INTERNAL,
9845 { },
9846 { { 0, 1 } },
9847 },
9848 {
9849 "JNE signed compare, test 6",
9850 .u.insns_int = {
9851 BPF_LD_IMM64(R1, 0x7efb0000),
9852 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9853 BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
9854 BPF_ALU32_IMM(BPF_MOV, R0, 2),
9855 BPF_EXIT_INSN(),
9856 },
9857 INTERNAL,
9858 { },
9859 { { 0, 2 } },
9860 },
9861 {
9862 "JNE signed compare, test 7",
9863 .u.insns = {
9864 BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
9865 BPF_STMT(BPF_MISC | BPF_TAX, 0),
9866 BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
9867 BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
9868 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
9869 BPF_STMT(BPF_RET | BPF_K, 1),
9870 BPF_STMT(BPF_RET | BPF_K, 2),
9871 },
9872 CLASSIC | FLAG_NO_DATA,
9873 {},
9874 { { 0, 2 } },
9875 },
68c956fe
JA		 9876 /* Exhaustive test of ALU64 shift operations */
9877 {
9878 "ALU64_LSH_K: all shift values",
9879 { },
9880 INTERNAL | FLAG_NO_DATA,
9881 { },
9882 { { 0, 1 } },
9883 .fill_helper = bpf_fill_alu_lsh_imm,
9884 },
9885 {
9886 "ALU64_RSH_K: all shift values",
9887 { },
9888 INTERNAL | FLAG_NO_DATA,
9889 { },
9890 { { 0, 1 } },
9891 .fill_helper = bpf_fill_alu_rsh_imm,
9892 },
9893 {
9894 "ALU64_ARSH_K: all shift values",
9895 { },
9896 INTERNAL | FLAG_NO_DATA,
9897 { },
9898 { { 0, 1 } },
9899 .fill_helper = bpf_fill_alu_arsh_imm,
9900 },
9901 {
9902 "ALU64_LSH_X: all shift values",
9903 { },
9904 INTERNAL | FLAG_NO_DATA,
9905 { },
9906 { { 0, 1 } },
9907 .fill_helper = bpf_fill_alu_lsh_reg,
9908 },
9909 {
9910 "ALU64_RSH_X: all shift values",
9911 { },
9912 INTERNAL | FLAG_NO_DATA,
9913 { },
9914 { { 0, 1 } },
9915 .fill_helper = bpf_fill_alu_rsh_reg,
9916 },
9917 {
9918 "ALU64_ARSH_X: all shift values",
9919 { },
9920 INTERNAL | FLAG_NO_DATA,
9921 { },
9922 { { 0, 1 } },
9923 .fill_helper = bpf_fill_alu_arsh_reg,
9924 },
9925 /* Exhaustive test of ALU32 shift operations */
9926 {
9927 "ALU32_LSH_K: all shift values",
9928 { },
9929 INTERNAL | FLAG_NO_DATA,
9930 { },
9931 { { 0, 1 } },
9932 .fill_helper = bpf_fill_alu32_lsh_imm,
9933 },
9934 {
9935 "ALU32_RSH_K: all shift values",
9936 { },
9937 INTERNAL | FLAG_NO_DATA,
9938 { },
9939 { { 0, 1 } },
9940 .fill_helper = bpf_fill_alu32_rsh_imm,
9941 },
9942 {
9943 "ALU32_ARSH_K: all shift values",
9944 { },
9945 INTERNAL | FLAG_NO_DATA,
9946 { },
9947 { { 0, 1 } },
9948 .fill_helper = bpf_fill_alu32_arsh_imm,
9949 },
9950 {
9951 "ALU32_LSH_X: all shift values",
9952 { },
9953 INTERNAL | FLAG_NO_DATA,
9954 { },
9955 { { 0, 1 } },
9956 .fill_helper = bpf_fill_alu32_lsh_reg,
9957 },
9958 {
9959 "ALU32_RSH_X: all shift values",
9960 { },
9961 INTERNAL | FLAG_NO_DATA,
9962 { },
9963 { { 0, 1 } },
9964 .fill_helper = bpf_fill_alu32_rsh_reg,
9965 },
9966 {
9967 "ALU32_ARSH_X: all shift values",
9968 { },
9969 INTERNAL | FLAG_NO_DATA,
9970 { },
9971 { { 0, 1 } },
9972 .fill_helper = bpf_fill_alu32_arsh_reg,
9973 },
9298e63e
JA		 9974 /* ALU64 immediate magnitudes */
9975 {
9976 "ALU64_MOV_K: all immediate value magnitudes",
9977 { },
9978 INTERNAL | FLAG_NO_DATA,
9979 { },
9980 { { 0, 1 } },
9981 .fill_helper = bpf_fill_alu64_mov_imm,
9982 .nr_testruns = NR_PATTERN_RUNS,
9983 },
9984 {
9985 "ALU64_AND_K: all immediate value magnitudes",
9986 { },
9987 INTERNAL | FLAG_NO_DATA,
9988 { },
9989 { { 0, 1 } },
9990 .fill_helper = bpf_fill_alu64_and_imm,
9991 .nr_testruns = NR_PATTERN_RUNS,
9992 },
9993 {
9994 "ALU64_OR_K: all immediate value magnitudes",
9995 { },
9996 INTERNAL | FLAG_NO_DATA,
9997 { },
9998 { { 0, 1 } },
9999 .fill_helper = bpf_fill_alu64_or_imm,
10000 .nr_testruns = NR_PATTERN_RUNS,
10001 },
10002 {
10003 "ALU64_XOR_K: all immediate value magnitudes",
10004 { },
10005 INTERNAL | FLAG_NO_DATA,
10006 { },
10007 { { 0, 1 } },
10008 .fill_helper = bpf_fill_alu64_xor_imm,
10009 .nr_testruns = NR_PATTERN_RUNS,
10010 },
10011 {
10012 "ALU64_ADD_K: all immediate value magnitudes",
10013 { },
10014 INTERNAL | FLAG_NO_DATA,
10015 { },
10016 { { 0, 1 } },
10017 .fill_helper = bpf_fill_alu64_add_imm,
10018 .nr_testruns = NR_PATTERN_RUNS,
10019 },
10020 {
10021 "ALU64_SUB_K: all immediate value magnitudes",
10022 { },
10023 INTERNAL | FLAG_NO_DATA,
10024 { },
10025 { { 0, 1 } },
10026 .fill_helper = bpf_fill_alu64_sub_imm,
10027 .nr_testruns = NR_PATTERN_RUNS,
10028 },
10029 {
10030 "ALU64_MUL_K: all immediate value magnitudes",
10031 { },
10032 INTERNAL | FLAG_NO_DATA,
10033 { },
10034 { { 0, 1 } },
10035 .fill_helper = bpf_fill_alu64_mul_imm,
10036 .nr_testruns = NR_PATTERN_RUNS,
10037 },
10038 {
10039 "ALU64_DIV_K: all immediate value magnitudes",
10040 { },
10041 INTERNAL | FLAG_NO_DATA,
10042 { },
10043 { { 0, 1 } },
10044 .fill_helper = bpf_fill_alu64_div_imm,
10045 .nr_testruns = NR_PATTERN_RUNS,
10046 },
10047 {
10048 "ALU64_MOD_K: all immediate value magnitudes",
10049 { },
10050 INTERNAL | FLAG_NO_DATA,
10051 { },
10052 { { 0, 1 } },
10053 .fill_helper = bpf_fill_alu64_mod_imm,
10054 .nr_testruns = NR_PATTERN_RUNS,
10055 },
10056 /* ALU32 immediate magnitudes */
10057 {
10058 "ALU32_MOV_K: all immediate value magnitudes",
10059 { },
10060 INTERNAL | FLAG_NO_DATA,
10061 { },
10062 { { 0, 1 } },
10063 .fill_helper = bpf_fill_alu32_mov_imm,
10064 .nr_testruns = NR_PATTERN_RUNS,
10065 },
10066 {
10067 "ALU32_AND_K: all immediate value magnitudes",
10068 { },
10069 INTERNAL | FLAG_NO_DATA,
10070 { },
10071 { { 0, 1 } },
10072 .fill_helper = bpf_fill_alu32_and_imm,
10073 .nr_testruns = NR_PATTERN_RUNS,
10074 },
10075 {
10076 "ALU32_OR_K: all immediate value magnitudes",
10077 { },
10078 INTERNAL | FLAG_NO_DATA,
10079 { },
10080 { { 0, 1 } },
10081 .fill_helper = bpf_fill_alu32_or_imm,
10082 .nr_testruns = NR_PATTERN_RUNS,
10083 },
10084 {
10085 "ALU32_XOR_K: all immediate value magnitudes",
10086 { },
10087 INTERNAL | FLAG_NO_DATA,
10088 { },
10089 { { 0, 1 } },
10090 .fill_helper = bpf_fill_alu32_xor_imm,
10091 .nr_testruns = NR_PATTERN_RUNS,
10092 },
10093 {
10094 "ALU32_ADD_K: all immediate value magnitudes",
10095 { },
10096 INTERNAL | FLAG_NO_DATA,
10097 { },
10098 { { 0, 1 } },
10099 .fill_helper = bpf_fill_alu32_add_imm,
10100 .nr_testruns = NR_PATTERN_RUNS,
10101 },
10102 {
10103 "ALU32_SUB_K: all immediate value magnitudes",
10104 { },
10105 INTERNAL | FLAG_NO_DATA,
10106 { },
10107 { { 0, 1 } },
10108 .fill_helper = bpf_fill_alu32_sub_imm,
10109 .nr_testruns = NR_PATTERN_RUNS,
10110 },
10111 {
10112 "ALU32_MUL_K: all immediate value magnitudes",
10113 { },
10114 INTERNAL | FLAG_NO_DATA,
10115 { },
10116 { { 0, 1 } },
10117 .fill_helper = bpf_fill_alu32_mul_imm,
10118 .nr_testruns = NR_PATTERN_RUNS,
10119 },
10120 {
10121 "ALU32_DIV_K: all immediate value magnitudes",
10122 { },
10123 INTERNAL | FLAG_NO_DATA,
10124 { },
10125 { { 0, 1 } },
10126 .fill_helper = bpf_fill_alu32_div_imm,
10127 .nr_testruns = NR_PATTERN_RUNS,
10128 },
10129 {
10130 "ALU32_MOD_K: all immediate value magnitudes",
10131 { },
10132 INTERNAL | FLAG_NO_DATA,
10133 { },
10134 { { 0, 1 } },
10135 .fill_helper = bpf_fill_alu32_mod_imm,
a5a36544 10136 .nr_testruns = NR_PATTERN_RUNS,
9298e63e
JA		 10137 },
10138 /* ALU64 register magnitudes */
10139 {
10140 "ALU64_MOV_X: all register value magnitudes",
10141 { },
10142 INTERNAL | FLAG_NO_DATA,
10143 { },
10144 { { 0, 1 } },
10145 .fill_helper = bpf_fill_alu64_mov_reg,
10146 .nr_testruns = NR_PATTERN_RUNS,
10147 },
10148 {
10149 "ALU64_AND_X: all register value magnitudes",
10150 { },
10151 INTERNAL | FLAG_NO_DATA,
10152 { },
10153 { { 0, 1 } },
10154 .fill_helper = bpf_fill_alu64_and_reg,
10155 .nr_testruns = NR_PATTERN_RUNS,
10156 },
10157 {
10158 "ALU64_OR_X: all register value magnitudes",
10159 { },
10160 INTERNAL | FLAG_NO_DATA,
10161 { },
10162 { { 0, 1 } },
10163 .fill_helper = bpf_fill_alu64_or_reg,
10164 .nr_testruns = NR_PATTERN_RUNS,
10165 },
10166 {
10167 "ALU64_XOR_X: all register value magnitudes",
10168 { },
10169 INTERNAL | FLAG_NO_DATA,
10170 { },
10171 { { 0, 1 } },
10172 .fill_helper = bpf_fill_alu64_xor_reg,
10173 .nr_testruns = NR_PATTERN_RUNS,
10174 },
10175 {
10176 "ALU64_ADD_X: all register value magnitudes",
10177 { },
10178 INTERNAL | FLAG_NO_DATA,
10179 { },
10180 { { 0, 1 } },
10181 .fill_helper = bpf_fill_alu64_add_reg,
10182 .nr_testruns = NR_PATTERN_RUNS,
10183 },
10184 {
10185 "ALU64_SUB_X: all register value magnitudes",
10186 { },
10187 INTERNAL | FLAG_NO_DATA,
10188 { },
10189 { { 0, 1 } },
10190 .fill_helper = bpf_fill_alu64_sub_reg,
10191 .nr_testruns = NR_PATTERN_RUNS,
10192 },
10193 {
10194 "ALU64_MUL_X: all register value magnitudes",
10195 { },
10196 INTERNAL | FLAG_NO_DATA,
10197 { },
10198 { { 0, 1 } },
10199 .fill_helper = bpf_fill_alu64_mul_reg,
10200 .nr_testruns = NR_PATTERN_RUNS,
10201 },
10202 {
10203 "ALU64_DIV_X: all register value magnitudes",
10204 { },
10205 INTERNAL | FLAG_NO_DATA,
10206 { },
10207 { { 0, 1 } },
10208 .fill_helper = bpf_fill_alu64_div_reg,
10209 .nr_testruns = NR_PATTERN_RUNS,
10210 },
10211 {
10212 "ALU64_MOD_X: all register value magnitudes",
10213 { },
10214 INTERNAL | FLAG_NO_DATA,
10215 { },
10216 { { 0, 1 } },
10217 .fill_helper = bpf_fill_alu64_mod_reg,
10218 .nr_testruns = NR_PATTERN_RUNS,
10219 },
10220 /* ALU32 register magnitudes */
10221 {
10222 "ALU32_MOV_X: all register value magnitudes",
10223 { },
10224 INTERNAL | FLAG_NO_DATA,
10225 { },
10226 { { 0, 1 } },
10227 .fill_helper = bpf_fill_alu32_mov_reg,
10228 .nr_testruns = NR_PATTERN_RUNS,
10229 },
10230 {
10231 "ALU32_AND_X: all register value magnitudes",
10232 { },
10233 INTERNAL | FLAG_NO_DATA,
10234 { },
10235 { { 0, 1 } },
10236 .fill_helper = bpf_fill_alu32_and_reg,
10237 .nr_testruns = NR_PATTERN_RUNS,
10238 },
10239 {
10240 "ALU32_OR_X: all register value magnitudes",
10241 { },
10242 INTERNAL | FLAG_NO_DATA,
10243 { },
10244 { { 0, 1 } },
10245 .fill_helper = bpf_fill_alu32_or_reg,
10246 .nr_testruns = NR_PATTERN_RUNS,
10247 },
10248 {
10249 "ALU32_XOR_X: all register value magnitudes",
10250 { },
10251 INTERNAL | FLAG_NO_DATA,
10252 { },
10253 { { 0, 1 } },
10254 .fill_helper = bpf_fill_alu32_xor_reg,
10255 .nr_testruns = NR_PATTERN_RUNS,
10256 },
10257 {
10258 "ALU32_ADD_X: all register value magnitudes",
10259 { },
10260 INTERNAL | FLAG_NO_DATA,
10261 { },
10262 { { 0, 1 } },
10263 .fill_helper = bpf_fill_alu32_add_reg,
10264 .nr_testruns = NR_PATTERN_RUNS,
10265 },
10266 {
10267 "ALU32_SUB_X: all register value magnitudes",
10268 { },
10269 INTERNAL | FLAG_NO_DATA,
10270 { },
10271 { { 0, 1 } },
10272 .fill_helper = bpf_fill_alu32_sub_reg,
10273 .nr_testruns = NR_PATTERN_RUNS,
10274 },
10275 {
10276 "ALU32_MUL_X: all register value magnitudes",
10277 { },
10278 INTERNAL | FLAG_NO_DATA,
10279 { },
10280 { { 0, 1 } },
10281 .fill_helper = bpf_fill_alu32_mul_reg,
10282 .nr_testruns = NR_PATTERN_RUNS,
10283 },
10284 {
10285 "ALU32_DIV_X: all register value magnitudes",
10286 { },
10287 INTERNAL | FLAG_NO_DATA,
10288 { },
10289 { { 0, 1 } },
10290 .fill_helper = bpf_fill_alu32_div_reg,
10291 .nr_testruns = NR_PATTERN_RUNS,
10292 },
10293 {
10294 "ALU32_MOD_X: all register value magnitudes",
10295 { },
10296 INTERNAL | FLAG_NO_DATA,
10297 { },
10298 { { 0, 1 } },
10299 .fill_helper = bpf_fill_alu32_mod_reg,
10300 .nr_testruns = NR_PATTERN_RUNS,
10301 },
2e807611
JA		 10302 /* LD_IMM64 immediate magnitudes */
10303 {
10304 "LD_IMM64: all immediate value magnitudes",
10305 { },
10306 INTERNAL | FLAG_NO_DATA,
10307 { },
10308 { { 0, 1 } },
10309 .fill_helper = bpf_fill_ld_imm64,
10310 },
a5a36544
JA		 10311 /* JMP immediate magnitudes */
10312 {
10313 "JMP_JSET_K: all immediate value magnitudes",
10314 { },
10315 INTERNAL | FLAG_NO_DATA,
10316 { },
10317 { { 0, 1 } },
10318 .fill_helper = bpf_fill_jmp_jset_imm,
10319 .nr_testruns = NR_PATTERN_RUNS,
10320 },
10321 {
10322 "JMP_JEQ_K: all immediate value magnitudes",
10323 { },
10324 INTERNAL | FLAG_NO_DATA,
10325 { },
10326 { { 0, 1 } },
10327 .fill_helper = bpf_fill_jmp_jeq_imm,
10328 .nr_testruns = NR_PATTERN_RUNS,
10329 },
10330 {
10331 "JMP_JNE_K: all immediate value magnitudes",
10332 { },
10333 INTERNAL | FLAG_NO_DATA,
10334 { },
10335 { { 0, 1 } },
10336 .fill_helper = bpf_fill_jmp_jne_imm,
10337 .nr_testruns = NR_PATTERN_RUNS,
10338 },
10339 {
10340 "JMP_JGT_K: all immediate value magnitudes",
10341 { },
10342 INTERNAL | FLAG_NO_DATA,
10343 { },
10344 { { 0, 1 } },
10345 .fill_helper = bpf_fill_jmp_jgt_imm,
10346 .nr_testruns = NR_PATTERN_RUNS,
10347 },
10348 {
10349 "JMP_JGE_K: all immediate value magnitudes",
10350 { },
10351 INTERNAL | FLAG_NO_DATA,
10352 { },
10353 { { 0, 1 } },
10354 .fill_helper = bpf_fill_jmp_jge_imm,
10355 .nr_testruns = NR_PATTERN_RUNS,
10356 },
10357 {
10358 "JMP_JLT_K: all immediate value magnitudes",
10359 { },
10360 INTERNAL | FLAG_NO_DATA,
10361 { },
10362 { { 0, 1 } },
10363 .fill_helper = bpf_fill_jmp_jlt_imm,
10364 .nr_testruns = NR_PATTERN_RUNS,
10365 },
10366 {
10367 "JMP_JLE_K: all immediate value magnitudes",
10368 { },
10369 INTERNAL | FLAG_NO_DATA,
10370 { },
10371 { { 0, 1 } },
10372 .fill_helper = bpf_fill_jmp_jle_imm,
10373 .nr_testruns = NR_PATTERN_RUNS,
10374 },
10375 {
10376 "JMP_JSGT_K: all immediate value magnitudes",
10377 { },
10378 INTERNAL | FLAG_NO_DATA,
10379 { },
10380 { { 0, 1 } },
10381 .fill_helper = bpf_fill_jmp_jsgt_imm,
10382 .nr_testruns = NR_PATTERN_RUNS,
10383 },
10384 {
10385 "JMP_JSGE_K: all immediate value magnitudes",
10386 { },
10387 INTERNAL | FLAG_NO_DATA,
10388 { },
10389 { { 0, 1 } },
10390 .fill_helper = bpf_fill_jmp_jsge_imm,
10391 .nr_testruns = NR_PATTERN_RUNS,
10392 },
10393 {
10394 "JMP_JSLT_K: all immediate value magnitudes",
10395 { },
10396 INTERNAL | FLAG_NO_DATA,
10397 { },
10398 { { 0, 1 } },
10399 .fill_helper = bpf_fill_jmp_jslt_imm,
10400 .nr_testruns = NR_PATTERN_RUNS,
10401 },
10402 {
10403 "JMP_JSLE_K: all immediate value magnitudes",
10404 { },
10405 INTERNAL | FLAG_NO_DATA,
10406 { },
10407 { { 0, 1 } },
10408 .fill_helper = bpf_fill_jmp_jsle_imm,
10409 .nr_testruns = NR_PATTERN_RUNS,
10410 },
10411 /* JMP register magnitudes */
10412 {
10413 "JMP_JSET_X: all register value magnitudes",
10414 { },
10415 INTERNAL | FLAG_NO_DATA,
10416 { },
10417 { { 0, 1 } },
10418 .fill_helper = bpf_fill_jmp_jset_reg,
10419 .nr_testruns = NR_PATTERN_RUNS,
10420 },
10421 {
10422 "JMP_JEQ_X: all register value magnitudes",
10423 { },
10424 INTERNAL | FLAG_NO_DATA,
10425 { },
10426 { { 0, 1 } },
10427 .fill_helper = bpf_fill_jmp_jeq_reg,
10428 .nr_testruns = NR_PATTERN_RUNS,
10429 },
10430 {
10431 "JMP_JNE_X: all register value magnitudes",
10432 { },
10433 INTERNAL | FLAG_NO_DATA,
10434 { },
10435 { { 0, 1 } },
10436 .fill_helper = bpf_fill_jmp_jne_reg,
10437 .nr_testruns = NR_PATTERN_RUNS,
10438 },
10439 {
10440 "JMP_JGT_X: all register value magnitudes",
10441 { },
10442 INTERNAL | FLAG_NO_DATA,
10443 { },
10444 { { 0, 1 } },
10445 .fill_helper = bpf_fill_jmp_jgt_reg,
10446 .nr_testruns = NR_PATTERN_RUNS,
10447 },
10448 {
10449 "JMP_JGE_X: all register value magnitudes",
10450 { },
10451 INTERNAL | FLAG_NO_DATA,
10452 { },
10453 { { 0, 1 } },
10454 .fill_helper = bpf_fill_jmp_jge_reg,
10455 .nr_testruns = NR_PATTERN_RUNS,
10456 },
10457 {
10458 "JMP_JLT_X: all register value magnitudes",
10459 { },
10460 INTERNAL | FLAG_NO_DATA,
10461 { },
10462 { { 0, 1 } },
10463 .fill_helper = bpf_fill_jmp_jlt_reg,
10464 .nr_testruns = NR_PATTERN_RUNS,
10465 },
10466 {
10467 "JMP_JLE_X: all register value magnitudes",
10468 { },
10469 INTERNAL | FLAG_NO_DATA,
10470 { },
10471 { { 0, 1 } },
10472 .fill_helper = bpf_fill_jmp_jle_reg,
10473 .nr_testruns = NR_PATTERN_RUNS,
10474 },
10475 {
10476 "JMP_JSGT_X: all register value magnitudes",
10477 { },
10478 INTERNAL | FLAG_NO_DATA,
10479 { },
10480 { { 0, 1 } },
10481 .fill_helper = bpf_fill_jmp_jsgt_reg,
10482 .nr_testruns = NR_PATTERN_RUNS,
10483 },
10484 {
10485 "JMP_JSGE_X: all register value magnitudes",
10486 { },
10487 INTERNAL | FLAG_NO_DATA,
10488 { },
10489 { { 0, 1 } },
10490 .fill_helper = bpf_fill_jmp_jsge_reg,
10491 .nr_testruns = NR_PATTERN_RUNS,
10492 },
10493 {
10494 "JMP_JSLT_X: all register value magnitudes",
10495 { },
10496 INTERNAL | FLAG_NO_DATA,
10497 { },
10498 { { 0, 1 } },
10499 .fill_helper = bpf_fill_jmp_jslt_reg,
10500 .nr_testruns = NR_PATTERN_RUNS,
10501 },
10502 {
10503 "JMP_JSLE_X: all register value magnitudes",
10504 { },
10505 INTERNAL | FLAG_NO_DATA,
10506 { },
10507 { { 0, 1 } },
10508 .fill_helper = bpf_fill_jmp_jsle_reg,
10509 .nr_testruns = NR_PATTERN_RUNS,
10510 },
10511 /* JMP32 immediate magnitudes */
10512 {
10513 "JMP32_JSET_K: all immediate value magnitudes",
10514 { },
10515 INTERNAL | FLAG_NO_DATA,
10516 { },
10517 { { 0, 1 } },
10518 .fill_helper = bpf_fill_jmp32_jset_imm,
10519 .nr_testruns = NR_PATTERN_RUNS,
10520 },
10521 {
10522 "JMP32_JEQ_K: all immediate value magnitudes",
10523 { },
10524 INTERNAL | FLAG_NO_DATA,
10525 { },
10526 { { 0, 1 } },
10527 .fill_helper = bpf_fill_jmp32_jeq_imm,
10528 .nr_testruns = NR_PATTERN_RUNS,
10529 },
10530 {
10531 "JMP32_JNE_K: all immediate value magnitudes",
10532 { },
10533 INTERNAL | FLAG_NO_DATA,
10534 { },
10535 { { 0, 1 } },
10536 .fill_helper = bpf_fill_jmp32_jne_imm,
10537 .nr_testruns = NR_PATTERN_RUNS,
10538 },
10539 {
10540 "JMP32_JGT_K: all immediate value magnitudes",
10541 { },
10542 INTERNAL | FLAG_NO_DATA,
10543 { },
10544 { { 0, 1 } },
10545 .fill_helper = bpf_fill_jmp32_jgt_imm,
10546 .nr_testruns = NR_PATTERN_RUNS,
10547 },
10548 {
10549 "JMP32_JGE_K: all immediate value magnitudes",
10550 { },
10551 INTERNAL | FLAG_NO_DATA,
10552 { },
10553 { { 0, 1 } },
10554 .fill_helper = bpf_fill_jmp32_jge_imm,
10555 .nr_testruns = NR_PATTERN_RUNS,
10556 },
10557 {
10558 "JMP32_JLT_K: all immediate value magnitudes",
10559 { },
10560 INTERNAL | FLAG_NO_DATA,
10561 { },
10562 { { 0, 1 } },
10563 .fill_helper = bpf_fill_jmp32_jlt_imm,
10564 .nr_testruns = NR_PATTERN_RUNS,
10565 },
10566 {
10567 "JMP32_JLE_K: all immediate value magnitudes",
10568 { },
10569 INTERNAL | FLAG_NO_DATA,
10570 { },
10571 { { 0, 1 } },
10572 .fill_helper = bpf_fill_jmp32_jle_imm,
10573 .nr_testruns = NR_PATTERN_RUNS,
10574 },
10575 {
10576 "JMP32_JSGT_K: all immediate value magnitudes",
10577 { },
10578 INTERNAL | FLAG_NO_DATA,
10579 { },
10580 { { 0, 1 } },
10581 .fill_helper = bpf_fill_jmp32_jsgt_imm,
10582 .nr_testruns = NR_PATTERN_RUNS,
10583 },
10584 {
10585 "JMP32_JSGE_K: all immediate value magnitudes",
10586 { },
10587 INTERNAL | FLAG_NO_DATA,
10588 { },
10589 { { 0, 1 } },
10590 .fill_helper = bpf_fill_jmp32_jsge_imm,
10591 .nr_testruns = NR_PATTERN_RUNS,
10592 },
10593 {
10594 "JMP32_JSLT_K: all immediate value magnitudes",
10595 { },
10596 INTERNAL | FLAG_NO_DATA,
10597 { },
10598 { { 0, 1 } },
10599 .fill_helper = bpf_fill_jmp32_jslt_imm,
10600 .nr_testruns = NR_PATTERN_RUNS,
10601 },
10602 {
10603 "JMP32_JSLE_K: all immediate value magnitudes",
10604 { },
10605 INTERNAL | FLAG_NO_DATA,
10606 { },
10607 { { 0, 1 } },
10608 .fill_helper = bpf_fill_jmp32_jsle_imm,
10609 .nr_testruns = NR_PATTERN_RUNS,
10610 },
10611 /* JMP32 register magnitudes */
10612 {
10613 "JMP32_JSET_X: all register value magnitudes",
10614 { },
10615 INTERNAL | FLAG_NO_DATA,
10616 { },
10617 { { 0, 1 } },
10618 .fill_helper = bpf_fill_jmp32_jset_reg,
10619 .nr_testruns = NR_PATTERN_RUNS,
10620 },
10621 {
10622 "JMP32_JEQ_X: all register value magnitudes",
10623 { },
10624 INTERNAL | FLAG_NO_DATA,
10625 { },
10626 { { 0, 1 } },
10627 .fill_helper = bpf_fill_jmp32_jeq_reg,
10628 .nr_testruns = NR_PATTERN_RUNS,
10629 },
10630 {
10631 "JMP32_JNE_X: all register value magnitudes",
10632 { },
10633 INTERNAL | FLAG_NO_DATA,
10634 { },
10635 { { 0, 1 } },
10636 .fill_helper = bpf_fill_jmp32_jne_reg,
10637 .nr_testruns = NR_PATTERN_RUNS,
10638 },
10639 {
10640 "JMP32_JGT_X: all register value magnitudes",
10641 { },
10642 INTERNAL | FLAG_NO_DATA,
10643 { },
10644 { { 0, 1 } },
10645 .fill_helper = bpf_fill_jmp32_jgt_reg,
10646 .nr_testruns = NR_PATTERN_RUNS,
10647 },
10648 {
10649 "JMP32_JGE_X: all register value magnitudes",
10650 { },
10651 INTERNAL | FLAG_NO_DATA,
10652 { },
10653 { { 0, 1 } },
10654 .fill_helper = bpf_fill_jmp32_jge_reg,
10655 .nr_testruns = NR_PATTERN_RUNS,
10656 },
10657 {
10658 "JMP32_JLT_X: all register value magnitudes",
10659 { },
10660 INTERNAL | FLAG_NO_DATA,
10661 { },
10662 { { 0, 1 } },
10663 .fill_helper = bpf_fill_jmp32_jlt_reg,
10664 .nr_testruns = NR_PATTERN_RUNS,
10665 },
10666 {
10667 "JMP32_JLE_X: all register value magnitudes",
10668 { },
10669 INTERNAL | FLAG_NO_DATA,
10670 { },
10671 { { 0, 1 } },
10672 .fill_helper = bpf_fill_jmp32_jle_reg,
10673 .nr_testruns = NR_PATTERN_RUNS,
10674 },
10675 {
10676 "JMP32_JSGT_X: all register value magnitudes",
10677 { },
10678 INTERNAL | FLAG_NO_DATA,
10679 { },
10680 { { 0, 1 } },
10681 .fill_helper = bpf_fill_jmp32_jsgt_reg,
10682 .nr_testruns = NR_PATTERN_RUNS,
10683 },
10684 {
10685 "JMP32_JSGE_X: all register value magnitudes",
10686 { },
10687 INTERNAL | FLAG_NO_DATA,
10688 { },
10689 { { 0, 1 } },
10690 .fill_helper = bpf_fill_jmp32_jsge_reg,
10691 .nr_testruns = NR_PATTERN_RUNS,
10692 },
10693 {
10694 "JMP32_JSLT_X: all register value magnitudes",
10695 { },
10696 INTERNAL | FLAG_NO_DATA,
10697 { },
10698 { { 0, 1 } },
10699 .fill_helper = bpf_fill_jmp32_jslt_reg,
10700 .nr_testruns = NR_PATTERN_RUNS,
10701 },
10702 {
10703 "JMP32_JSLE_X: all register value magnitudes",
10704 { },
10705 INTERNAL | FLAG_NO_DATA,
10706 { },
10707 { { 0, 1 } },
10708 .fill_helper = bpf_fill_jmp32_jsle_reg,
10709 .nr_testruns = NR_PATTERN_RUNS,
10710 },
a7d2e752
JA		 10711 /* Staggered jump sequences, immediate */
10712 {
10713 "Staggered jumps: JMP_JA",
10714 { },
10715 INTERNAL | FLAG_NO_DATA,
10716 { },
10717 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10718 .fill_helper = bpf_fill_staggered_ja,
10719 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10720 },
10721 {
10722 "Staggered jumps: JMP_JEQ_K",
10723 { },
10724 INTERNAL | FLAG_NO_DATA,
10725 { },
10726 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10727 .fill_helper = bpf_fill_staggered_jeq_imm,
10728 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10729 },
10730 {
10731 "Staggered jumps: JMP_JNE_K",
10732 { },
10733 INTERNAL | FLAG_NO_DATA,
10734 { },
10735 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10736 .fill_helper = bpf_fill_staggered_jne_imm,
10737 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10738 },
10739 {
10740 "Staggered jumps: JMP_JSET_K",
10741 { },
10742 INTERNAL | FLAG_NO_DATA,
10743 { },
10744 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10745 .fill_helper = bpf_fill_staggered_jset_imm,
10746 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10747 },
10748 {
10749 "Staggered jumps: JMP_JGT_K",
10750 { },
10751 INTERNAL | FLAG_NO_DATA,
10752 { },
10753 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10754 .fill_helper = bpf_fill_staggered_jgt_imm,
10755 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10756 },
10757 {
10758 "Staggered jumps: JMP_JGE_K",
10759 { },
10760 INTERNAL | FLAG_NO_DATA,
10761 { },
10762 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10763 .fill_helper = bpf_fill_staggered_jge_imm,
10764 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10765 },
10766 {
10767 "Staggered jumps: JMP_JLT_K",
10768 { },
10769 INTERNAL | FLAG_NO_DATA,
10770 { },
10771 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10772 .fill_helper = bpf_fill_staggered_jlt_imm,
10773 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10774 },
10775 {
10776 "Staggered jumps: JMP_JLE_K",
10777 { },
10778 INTERNAL | FLAG_NO_DATA,
10779 { },
10780 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10781 .fill_helper = bpf_fill_staggered_jle_imm,
10782 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10783 },
10784 {
10785 "Staggered jumps: JMP_JSGT_K",
10786 { },
10787 INTERNAL | FLAG_NO_DATA,
10788 { },
10789 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10790 .fill_helper = bpf_fill_staggered_jsgt_imm,
10791 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10792 },
10793 {
10794 "Staggered jumps: JMP_JSGE_K",
10795 { },
10796 INTERNAL | FLAG_NO_DATA,
10797 { },
10798 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10799 .fill_helper = bpf_fill_staggered_jsge_imm,
10800 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10801 },
10802 {
10803 "Staggered jumps: JMP_JSLT_K",
10804 { },
10805 INTERNAL | FLAG_NO_DATA,
10806 { },
10807 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10808 .fill_helper = bpf_fill_staggered_jslt_imm,
10809 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10810 },
10811 {
10812 "Staggered jumps: JMP_JSLE_K",
10813 { },
10814 INTERNAL | FLAG_NO_DATA,
10815 { },
10816 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10817 .fill_helper = bpf_fill_staggered_jsle_imm,
10818 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10819 },
10820 /* Staggered jump sequences, register */
10821 {
10822 "Staggered jumps: JMP_JEQ_X",
10823 { },
10824 INTERNAL | FLAG_NO_DATA,
10825 { },
10826 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10827 .fill_helper = bpf_fill_staggered_jeq_reg,
10828 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10829 },
10830 {
10831 "Staggered jumps: JMP_JNE_X",
10832 { },
10833 INTERNAL | FLAG_NO_DATA,
10834 { },
10835 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10836 .fill_helper = bpf_fill_staggered_jne_reg,
10837 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10838 },
10839 {
10840 "Staggered jumps: JMP_JSET_X",
10841 { },
10842 INTERNAL | FLAG_NO_DATA,
10843 { },
10844 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10845 .fill_helper = bpf_fill_staggered_jset_reg,
10846 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10847 },
10848 {
10849 "Staggered jumps: JMP_JGT_X",
10850 { },
10851 INTERNAL | FLAG_NO_DATA,
10852 { },
10853 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10854 .fill_helper = bpf_fill_staggered_jgt_reg,
10855 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10856 },
10857 {
10858 "Staggered jumps: JMP_JGE_X",
10859 { },
10860 INTERNAL | FLAG_NO_DATA,
10861 { },
10862 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10863 .fill_helper = bpf_fill_staggered_jge_reg,
10864 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10865 },
10866 {
10867 "Staggered jumps: JMP_JLT_X",
10868 { },
10869 INTERNAL | FLAG_NO_DATA,
10870 { },
10871 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10872 .fill_helper = bpf_fill_staggered_jlt_reg,
10873 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10874 },
10875 {
10876 "Staggered jumps: JMP_JLE_X",
10877 { },
10878 INTERNAL | FLAG_NO_DATA,
10879 { },
10880 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10881 .fill_helper = bpf_fill_staggered_jle_reg,
10882 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10883 },
10884 {
10885 "Staggered jumps: JMP_JSGT_X",
10886 { },
10887 INTERNAL | FLAG_NO_DATA,
10888 { },
10889 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10890 .fill_helper = bpf_fill_staggered_jsgt_reg,
10891 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10892 },
10893 {
10894 "Staggered jumps: JMP_JSGE_X",
10895 { },
10896 INTERNAL | FLAG_NO_DATA,
10897 { },
10898 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10899 .fill_helper = bpf_fill_staggered_jsge_reg,
10900 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10901 },
10902 {
10903 "Staggered jumps: JMP_JSLT_X",
10904 { },
10905 INTERNAL | FLAG_NO_DATA,
10906 { },
10907 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10908 .fill_helper = bpf_fill_staggered_jslt_reg,
10909 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10910 },
10911 {
10912 "Staggered jumps: JMP_JSLE_X",
10913 { },
10914 INTERNAL | FLAG_NO_DATA,
10915 { },
10916 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10917 .fill_helper = bpf_fill_staggered_jsle_reg,
10918 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10919 },
10920 /* Staggered jump sequences, JMP32 immediate */
10921 {
10922 "Staggered jumps: JMP32_JEQ_K",
10923 { },
10924 INTERNAL | FLAG_NO_DATA,
10925 { },
10926 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10927 .fill_helper = bpf_fill_staggered_jeq32_imm,
10928 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10929 },
10930 {
10931 "Staggered jumps: JMP32_JNE_K",
10932 { },
10933 INTERNAL | FLAG_NO_DATA,
10934 { },
10935 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10936 .fill_helper = bpf_fill_staggered_jne32_imm,
10937 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10938 },
10939 {
10940 "Staggered jumps: JMP32_JSET_K",
10941 { },
10942 INTERNAL | FLAG_NO_DATA,
10943 { },
10944 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10945 .fill_helper = bpf_fill_staggered_jset32_imm,
10946 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10947 },
10948 {
10949 "Staggered jumps: JMP32_JGT_K",
10950 { },
10951 INTERNAL | FLAG_NO_DATA,
10952 { },
10953 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10954 .fill_helper = bpf_fill_staggered_jgt32_imm,
10955 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10956 },
10957 {
10958 "Staggered jumps: JMP32_JGE_K",
10959 { },
10960 INTERNAL | FLAG_NO_DATA,
10961 { },
10962 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10963 .fill_helper = bpf_fill_staggered_jge32_imm,
10964 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10965 },
10966 {
10967 "Staggered jumps: JMP32_JLT_K",
10968 { },
10969 INTERNAL | FLAG_NO_DATA,
10970 { },
10971 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10972 .fill_helper = bpf_fill_staggered_jlt32_imm,
10973 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10974 },
10975 {
10976 "Staggered jumps: JMP32_JLE_K",
10977 { },
10978 INTERNAL | FLAG_NO_DATA,
10979 { },
10980 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10981 .fill_helper = bpf_fill_staggered_jle32_imm,
10982 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10983 },
10984 {
10985 "Staggered jumps: JMP32_JSGT_K",
10986 { },
10987 INTERNAL | FLAG_NO_DATA,
10988 { },
10989 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10990 .fill_helper = bpf_fill_staggered_jsgt32_imm,
10991 .nr_testruns = NR_STAGGERED_JMP_RUNS,
10992 },
10993 {
10994 "Staggered jumps: JMP32_JSGE_K",
10995 { },
10996 INTERNAL | FLAG_NO_DATA,
10997 { },
10998 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
10999 .fill_helper = bpf_fill_staggered_jsge32_imm,
11000 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11001 },
11002 {
11003 "Staggered jumps: JMP32_JSLT_K",
11004 { },
11005 INTERNAL | FLAG_NO_DATA,
11006 { },
11007 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11008 .fill_helper = bpf_fill_staggered_jslt32_imm,
11009 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11010 },
11011 {
11012 "Staggered jumps: JMP32_JSLE_K",
11013 { },
11014 INTERNAL | FLAG_NO_DATA,
11015 { },
11016 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11017 .fill_helper = bpf_fill_staggered_jsle32_imm,
11018 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11019 },
11020 /* Staggered jump sequences, JMP32 register */
11021 {
11022 "Staggered jumps: JMP32_JEQ_X",
11023 { },
11024 INTERNAL | FLAG_NO_DATA,
11025 { },
11026 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11027 .fill_helper = bpf_fill_staggered_jeq32_reg,
11028 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11029 },
11030 {
11031 "Staggered jumps: JMP32_JNE_X",
11032 { },
11033 INTERNAL | FLAG_NO_DATA,
11034 { },
11035 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11036 .fill_helper = bpf_fill_staggered_jne32_reg,
11037 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11038 },
11039 {
11040 "Staggered jumps: JMP32_JSET_X",
11041 { },
11042 INTERNAL | FLAG_NO_DATA,
11043 { },
11044 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11045 .fill_helper = bpf_fill_staggered_jset32_reg,
11046 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11047 },
11048 {
11049 "Staggered jumps: JMP32_JGT_X",
11050 { },
11051 INTERNAL | FLAG_NO_DATA,
11052 { },
11053 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11054 .fill_helper = bpf_fill_staggered_jgt32_reg,
11055 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11056 },
11057 {
11058 "Staggered jumps: JMP32_JGE_X",
11059 { },
11060 INTERNAL | FLAG_NO_DATA,
11061 { },
11062 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11063 .fill_helper = bpf_fill_staggered_jge32_reg,
11064 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11065 },
11066 {
11067 "Staggered jumps: JMP32_JLT_X",
11068 { },
11069 INTERNAL | FLAG_NO_DATA,
11070 { },
11071 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11072 .fill_helper = bpf_fill_staggered_jlt32_reg,
11073 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11074 },
11075 {
11076 "Staggered jumps: JMP32_JLE_X",
11077 { },
11078 INTERNAL | FLAG_NO_DATA,
11079 { },
11080 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11081 .fill_helper = bpf_fill_staggered_jle32_reg,
11082 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11083 },
11084 {
11085 "Staggered jumps: JMP32_JSGT_X",
11086 { },
11087 INTERNAL | FLAG_NO_DATA,
11088 { },
11089 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11090 .fill_helper = bpf_fill_staggered_jsgt32_reg,
11091 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11092 },
11093 {
11094 "Staggered jumps: JMP32_JSGE_X",
11095 { },
11096 INTERNAL | FLAG_NO_DATA,
11097 { },
11098 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11099 .fill_helper = bpf_fill_staggered_jsge32_reg,
11100 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11101 },
11102 {
11103 "Staggered jumps: JMP32_JSLT_X",
11104 { },
11105 INTERNAL | FLAG_NO_DATA,
11106 { },
11107 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11108 .fill_helper = bpf_fill_staggered_jslt32_reg,
11109 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11110 },
11111 {
11112 "Staggered jumps: JMP32_JSLE_X",
11113 { },
11114 INTERNAL | FLAG_NO_DATA,
11115 { },
11116 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
11117 .fill_helper = bpf_fill_staggered_jsle32_reg,
11118 .nr_testruns = NR_STAGGERED_JMP_RUNS,
11119 },
64a8946b
AS		 11120};
11121
10f18e0b 11122static struct net_device dev;
64a8946b 11123
10f18e0b 11124static struct sk_buff *populate_skb(char *buf, int size)
64a8946b
AS		 11125{
11126 struct sk_buff *skb;
11127
11128 if (size >= MAX_DATA)
11129 return NULL;
11130
11131 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
11132 if (!skb)
11133 return NULL;
11134
de77b966 11135 __skb_put_data(skb, buf, size);
10f18e0b
DB		 11136
11137 /* Initialize a fake skb with test pattern. */
64a8946b
AS		 11138 skb_reset_mac_header(skb);
11139 skb->protocol = htons(ETH_P_IP);
11140 skb->pkt_type = SKB_TYPE;
11141 skb->mark = SKB_MARK;
11142 skb->hash = SKB_HASH;
11143 skb->queue_mapping = SKB_QUEUE_MAP;
11144 skb->vlan_tci = SKB_VLAN_TCI;
0c4b2d37 11145 skb->vlan_present = SKB_VLAN_PRESENT;
5c0ca3f5 11146 skb->vlan_proto = htons(ETH_P_IP);
10081193 11147 dev_net_set(&dev, &init_net);
64a8946b
AS		 11148 skb->dev = &dev;
11149 skb->dev->ifindex = SKB_DEV_IFINDEX;
11150 skb->dev->type = SKB_DEV_TYPE;
11151 skb_set_network_header(skb, min(size, ETH_HLEN));
11152
11153 return skb;
11154}
11155
10f18e0b 11156static void *generate_test_data(struct bpf_test *test, int sub)
64a8946b 11157{
bac142ac
NS		 11158 struct sk_buff *skb;
11159 struct page *page;
11160
10f18e0b
DB		 11161 if (test->aux & FLAG_NO_DATA)
11162 return NULL;
64a8946b 11163
10f18e0b
DB		 11164 /* Test case expects an skb, so populate one. Various
11165 * subtests generate skbs of different sizes based on
11166 * the same data.
11167 */
bac142ac
NS		 11168 skb = populate_skb(test->data, test->test[sub].data_size);
11169 if (!skb)
11170 return NULL;
11171
11172 if (test->aux & FLAG_SKB_FRAG) {
11173 /*
11174 * when the test requires a fragmented skb, add a
11175 * single fragment to the skb, filled with
11176 * test->frag_data.
11177 */
11178 void *ptr;
11179
11180 page = alloc_page(GFP_KERNEL);
11181
11182 if (!page)
11183 goto err_kfree_skb;
11184
11185 ptr = kmap(page);
11186 if (!ptr)
11187 goto err_free_page;
11188 memcpy(ptr, test->frag_data, MAX_DATA);
11189 kunmap(page);
11190 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
11191 }
11192
11193 return skb;
11194
11195err_free_page:
11196 __free_page(page);
11197err_kfree_skb:
11198 kfree_skb(skb);
11199 return NULL;
10f18e0b
DB		 11200}
11201
11202static void release_test_data(const struct bpf_test *test, void *data)
11203{
11204 if (test->aux & FLAG_NO_DATA)
11205 return;
11206
11207 kfree_skb(data);
11208}
11209
a4afd37b 11210static int filter_length(int which)
10f18e0b 11211{
a4afd37b
DB		 11212 struct sock_filter *fp;
11213 int len;
10f18e0b 11214
a4afd37b
DB		 11215 if (tests[which].fill_helper)
11216 return tests[which].u.ptr.len;
11217
11218 fp = tests[which].u.insns;
e9d94504
CG		 11219 for (len = MAX_INSNS - 1; len > 0; --len)
11220 if (fp[len].code != 0 || fp[len].k != 0)
11221 break;
10f18e0b 11222
e9d94504 11223 return len + 1;
10f18e0b
DB		 11224}
11225
a4afd37b
DB		 11226static void *filter_pointer(int which)
11227{
11228 if (tests[which].fill_helper)
11229 return tests[which].u.ptr.insns;
11230 else
11231 return tests[which].u.insns;
11232}
11233
7ae457c1 11234static struct bpf_prog *generate_filter(int which, int *err)
10f18e0b 11235{
10f18e0b 11236 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
a4afd37b
DB		 11237 unsigned int flen = filter_length(which);
11238 void *fptr = filter_pointer(which);
11239 struct sock_fprog_kern fprog;
11240 struct bpf_prog *fp;
10f18e0b
DB		 11241
11242 switch (test_type) {
11243 case CLASSIC:
a4afd37b 11244 fprog.filter = fptr;
10f18e0b
DB		 11245 fprog.len = flen;
11246
7ae457c1 11247 *err = bpf_prog_create(&fp, &fprog);
10f18e0b 11248 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
09584b40 11249 if (*err == tests[which].expected_errcode) {
10f18e0b
DB		 11250 pr_cont("PASS\n");
11251 /* Verifier rejected filter as expected. */
11252 *err = 0;
11253 return NULL;
11254 } else {
11255 pr_cont("UNEXPECTED_PASS\n");
11256 /* Verifier didn't reject the test that's
11257 * bad enough, just return!
11258 */
11259 *err = -EINVAL;
11260 return NULL;
11261 }
11262 }
10f18e0b 11263 if (*err) {
290af866 11264 pr_cont("FAIL to prog_create err=%d len=%d\n",
10f18e0b
DB		 11265 *err, fprog.len);
11266 return NULL;
11267 }
11268 break;
11269
11270 case INTERNAL:
60a3b225 11271 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
10f18e0b
DB		 11272 if (fp == NULL) {
11273 pr_cont("UNEXPECTED_FAIL no memory left\n");
11274 *err = -ENOMEM;
11275 return NULL;
64a8946b
AS		 11276 }
11277
10f18e0b 11278 fp->len = flen;
4962fa10
DB		 11279 /* Type doesn't really matter here as long as it's not unspec. */
11280 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
a4afd37b 11281 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
105c0361 11282 fp->aux->stack_depth = tests[which].stack_depth;
64a8946b 11283
d1c55ab5
DB		 11284 /* We cannot error here as we don't need type compatibility
11285 * checks.
11286 */
11287 fp = bpf_prog_select_runtime(fp, err);
290af866
AS		 11288 if (*err) {
11289 pr_cont("FAIL to select_runtime err=%d\n", *err);
11290 return NULL;
11291 }
10f18e0b
DB		 11292 break;
11293 }
64a8946b 11294
10f18e0b
DB		 11295 *err = 0;
11296 return fp;
11297}
64a8946b 11298
7ae457c1 11299static void release_filter(struct bpf_prog *fp, int which)
10f18e0b
DB		 11300{
11301 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
64a8946b 11302
10f18e0b
DB		 11303 switch (test_type) {
11304 case CLASSIC:
7ae457c1 11305 bpf_prog_destroy(fp);
10f18e0b
DB		 11306 break;
11307 case INTERNAL:
7ae457c1 11308 bpf_prog_free(fp);
10f18e0b
DB		 11309 break;
11310 }
11311}
11312
7ae457c1 11313static int __run_one(const struct bpf_prog *fp, const void *data,
10f18e0b
DB		 11314 int runs, u64 *duration)
11315{
11316 u64 start, finish;
25ee7327 11317 int ret = 0, i;
10f18e0b 11318
6eac7795 11319 migrate_disable();
4d9c5c53 11320 start = ktime_get_ns();
10f18e0b
DB		 11321
11322 for (i = 0; i < runs; i++)
fb7dd8bc 11323 ret = bpf_prog_run(fp, data);
10f18e0b 11324
4d9c5c53 11325 finish = ktime_get_ns();
6eac7795 11326 migrate_enable();
10f18e0b 11327
4d9c5c53 11328 *duration = finish - start;
10f18e0b
DB		 11329 do_div(*duration, runs);
11330
11331 return ret;
11332}
11333
7ae457c1 11334static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
10f18e0b
DB		 11335{
11336 int err_cnt = 0, i, runs = MAX_TESTRUNS;
11337
c2a228d6
JA		 11338 if (test->nr_testruns)
11339 runs = min(test->nr_testruns, MAX_TESTRUNS);
11340
10f18e0b
DB		 11341 for (i = 0; i < MAX_SUBTESTS; i++) {
11342 void *data;
11343 u64 duration;
11344 u32 ret;
11345
2b7e9f25
JA		 11346 /*
11347 * NOTE: Several sub-tests may be present, in which case
11348 * a zero {data_size, result} tuple indicates the end of
11349 * the sub-test array. The first test is always run,
11350 * even if both data_size and result happen to be zero.
11351 */
11352 if (i > 0 &&
11353 test->test[i].data_size == 0 &&
10f18e0b
DB		 11354 test->test[i].result == 0)
11355 break;
11356
11357 data = generate_test_data(test, i);
e34684f8
NS		 11358 if (!data && !(test->aux & FLAG_NO_DATA)) {
11359 pr_cont("data generation failed ");
11360 err_cnt++;
11361 break;
11362 }
10f18e0b
DB		 11363 ret = __run_one(fp, data, runs, &duration);
11364 release_test_data(test, data);
11365
11366 if (ret == test->test[i].result) {
11367 pr_cont("%lld ", duration);
11368 } else {
11369 pr_cont("ret %d != %d ", ret,
11370 test->test[i].result);
64a8946b
AS		 11371 err_cnt++;
11372 }
11373 }
11374
11375 return err_cnt;
11376}
11377
d2648d4e
NS		 11378static char test_name[64];
11379module_param_string(test_name, test_name, sizeof(test_name), 0);
11380
11381static int test_id = -1;
11382module_param(test_id, int, 0);
11383
11384static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
11385module_param_array(test_range, int, NULL, 0);
11386
11387static __init int find_test_index(const char *test_name)
11388{
11389 int i;
11390
11391 for (i = 0; i < ARRAY_SIZE(tests); i++) {
11392 if (!strcmp(tests[i].descr, test_name))
11393 return i;
11394 }
11395 return -1;
11396}
11397
a4afd37b
DB		 11398static __init int prepare_bpf_tests(void)
11399{
d2648d4e
NS		 11400 if (test_id >= 0) {
11401 /*
11402 * if a test_id was specified, use test_range to
11403 * cover only that test.
11404 */
11405 if (test_id >= ARRAY_SIZE(tests)) {
11406 pr_err("test_bpf: invalid test_id specified.\n");
11407 return -EINVAL;
11408 }
11409
11410 test_range[0] = test_id;
11411 test_range[1] = test_id;
11412 } else if (*test_name) {
11413 /*
11414 * if a test_name was specified, find it and setup
11415 * test_range to cover only that test.
11416 */
11417 int idx = find_test_index(test_name);
11418
11419 if (idx < 0) {
11420 pr_err("test_bpf: no test named '%s' found.\n",
11421 test_name);
11422 return -EINVAL;
11423 }
11424 test_range[0] = idx;
11425 test_range[1] = idx;
11426 } else {
11427 /*
11428 * check that the supplied test_range is valid.
11429 */
11430 if (test_range[0] >= ARRAY_SIZE(tests) ||
11431 test_range[1] >= ARRAY_SIZE(tests) ||
11432 test_range[0] < 0 || test_range[1] < 0) {
11433 pr_err("test_bpf: test_range is out of bound.\n");
11434 return -EINVAL;
11435 }
11436
11437 if (test_range[1] < test_range[0]) {
11438 pr_err("test_bpf: test_range is ending before it starts.\n");
11439 return -EINVAL;
11440 }
11441 }
11442
a4afd37b
DB		 11443 return 0;
11444}
11445
11446static __init void destroy_bpf_tests(void)
11447{
a4afd37b
DB		 11448}
11449
d2648d4e
NS		 11450static bool exclude_test(int test_id)
11451{
11452 return test_id < test_range[0] || test_id > test_range[1];
11453}
11454
76db8087
YS		 11455static __init struct sk_buff *build_test_skb(void)
11456{
11457 u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
11458 struct sk_buff *skb[2];
11459 struct page *page[2];
11460 int i, data_size = 8;
11461
11462 for (i = 0; i < 2; i++) {
11463 page[i] = alloc_page(GFP_KERNEL);
11464 if (!page[i]) {
11465 if (i == 0)
11466 goto err_page0;
11467 else
11468 goto err_page1;
11469 }
11470
11471 /* this will set skb[i]->head_frag */
11472 skb[i] = dev_alloc_skb(headroom + data_size);
11473 if (!skb[i]) {
11474 if (i == 0)
11475 goto err_skb0;
11476 else
11477 goto err_skb1;
11478 }
11479
11480 skb_reserve(skb[i], headroom);
11481 skb_put(skb[i], data_size);
11482 skb[i]->protocol = htons(ETH_P_IP);
11483 skb_reset_network_header(skb[i]);
11484 skb_set_mac_header(skb[i], -ETH_HLEN);
11485
11486 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
11487 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
11488 }
11489
11490 /* setup shinfo */
11491 skb_shinfo(skb[0])->gso_size = 1448;
11492 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
11493 skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
11494 skb_shinfo(skb[0])->gso_segs = 0;
11495 skb_shinfo(skb[0])->frag_list = skb[1];
3384c7c7 11496 skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
76db8087
YS		 11497
11498 /* adjust skb[0]'s len */
11499 skb[0]->len += skb[1]->len;
11500 skb[0]->data_len += skb[1]->data_len;
11501 skb[0]->truesize += skb[1]->truesize;
11502
11503 return skb[0];
11504
11505err_skb1:
11506 __free_page(page[1]);
11507err_page1:
11508 kfree_skb(skb[0]);
11509err_skb0:
11510 __free_page(page[0]);
11511err_page0:
11512 return NULL;
11513}
11514
cf204a71
SL		 11515static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
11516{
11517 unsigned int alloc_size = 2000;
11518 unsigned int headroom = 102, doffset = 72, data_size = 1308;
11519 struct sk_buff *skb[2];
11520 int i;
11521
11522 /* skbs linked in a frag_list, both with linear data, with head_frag=0
11523 * (data allocated by kmalloc), both have tcp data of 1308 bytes
11524 * (total payload is 2616 bytes).
11525 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
11526 */
11527 for (i = 0; i < 2; i++) {
11528 skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
11529 if (!skb[i]) {
11530 if (i == 0)
11531 goto err_skb0;
11532 else
11533 goto err_skb1;
11534 }
11535
11536 skb[i]->protocol = htons(ETH_P_IPV6);
11537 skb_reserve(skb[i], headroom);
11538 skb_put(skb[i], doffset + data_size);
11539 skb_reset_network_header(skb[i]);
11540 if (i == 0)
11541 skb_reset_mac_header(skb[i]);
11542 else
11543 skb_set_mac_header(skb[i], -ETH_HLEN);
11544 __skb_pull(skb[i], doffset);
11545 }
11546
11547 /* setup shinfo.
11548 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
11549 * reduced gso_size.
11550 */
11551 skb_shinfo(skb[0])->gso_size = 1288;
11552 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
11553 skb_shinfo(skb[0])->gso_segs = 0;
11554 skb_shinfo(skb[0])->frag_list = skb[1];
11555
11556 /* adjust skb[0]'s len */
11557 skb[0]->len += skb[1]->len;
11558 skb[0]->data_len += skb[1]->len;
11559 skb[0]->truesize += skb[1]->truesize;
11560
11561 return skb[0];
11562
11563err_skb1:
11564 kfree_skb(skb[0]);
11565err_skb0:
11566 return NULL;
11567}
11568
af21c717
SL		 11569struct skb_segment_test {
11570 const char *descr;
11571 struct sk_buff *(*build_skb)(void);
76db8087 11572 netdev_features_t features;
af21c717
SL		 11573};
11574
11575static struct skb_segment_test skb_segment_tests[] __initconst = {
11576 {
11577 .descr = "gso_with_rx_frags",
11578 .build_skb = build_test_skb,
11579 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
11580 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
cf204a71
SL		 11581 },
11582 {
11583 .descr = "gso_linear_no_head_frag",
11584 .build_skb = build_test_skb_linear_no_head_frag,
11585 .features = NETIF_F_SG | NETIF_F_FRAGLIST |
11586 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
11587 NETIF_F_LLTX_BIT | NETIF_F_GRO |
11588 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
11589 NETIF_F_HW_VLAN_STAG_TX_BIT
af21c717
SL		 11590 }
11591};
11592
11593static __init int test_skb_segment_single(const struct skb_segment_test *test)
11594{
76db8087
YS		 11595 struct sk_buff *skb, *segs;
11596 int ret = -1;
11597
af21c717 11598 skb = test->build_skb();
76db8087
YS		 11599 if (!skb) {
11600 pr_info("%s: failed to build_test_skb", __func__);
11601 goto done;
11602 }
11603
af21c717 11604 segs = skb_segment(skb, test->features);
99fe29d3 11605 if (!IS_ERR(segs)) {
76db8087
YS		 11606 kfree_skb_list(segs);
11607 ret = 0;
76db8087
YS		 11608 }
11609 kfree_skb(skb);
11610done:
11611 return ret;
11612}
11613
af21c717
SL		 11614static __init int test_skb_segment(void)
11615{
11616 int i, err_cnt = 0, pass_cnt = 0;
11617
11618 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
11619 const struct skb_segment_test *test = &skb_segment_tests[i];
11620
11621 pr_info("#%d %s ", i, test->descr);
11622
11623 if (test_skb_segment_single(test)) {
11624 pr_cont("FAIL\n");
11625 err_cnt++;
11626 } else {
11627 pr_cont("PASS\n");
11628 pass_cnt++;
11629 }
11630 }
11631
11632 pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
11633 pass_cnt, err_cnt);
11634 return err_cnt ? -EINVAL : 0;
11635}
11636
64a8946b
AS		 11637static __init int test_bpf(void)
11638{
10f18e0b 11639 int i, err_cnt = 0, pass_cnt = 0;
327941f8 11640 int jit_cnt = 0, run_cnt = 0;
64a8946b
AS		 11641
11642 for (i = 0; i < ARRAY_SIZE(tests); i++) {
7ae457c1 11643 struct bpf_prog *fp;
10f18e0b 11644 int err;
64a8946b 11645
d40bc962 11646 cond_resched();
d2648d4e
NS		 11647 if (exclude_test(i))
11648 continue;
11649
10f18e0b 11650 pr_info("#%d %s ", i, tests[i].descr);
64a8946b 11651
4bc35413
JA		 11652 if (tests[i].fill_helper &&
11653 tests[i].fill_helper(&tests[i]) < 0) {
11654 pr_cont("FAIL to prog_fill\n");
11655 continue;
11656 }
11657
10f18e0b 11658 fp = generate_filter(i, &err);
4bc35413
JA		 11659
11660 if (tests[i].fill_helper) {
11661 kfree(tests[i].u.ptr.insns);
11662 tests[i].u.ptr.insns = NULL;
11663 }
11664
10f18e0b
DB		 11665 if (fp == NULL) {
11666 if (err == 0) {
11667 pass_cnt++;
11668 continue;
64a8946b 11669 }
290af866
AS		 11670 err_cnt++;
11671 continue;
10f18e0b 11672 }
327941f8
DB		 11673
11674 pr_cont("jited:%u ", fp->jited);
11675
11676 run_cnt++;
11677 if (fp->jited)
11678 jit_cnt++;
11679
64a8946b 11680 err = run_one(fp, &tests[i]);
10f18e0b 11681 release_filter(fp, i);
64a8946b
AS		 11682
11683 if (err) {
10f18e0b 11684 pr_cont("FAIL (%d times)\n", err);
64a8946b
AS		 11685 err_cnt++;
11686 } else {
11687 pr_cont("PASS\n");
10f18e0b 11688 pass_cnt++;
64a8946b
AS		 11689 }
11690 }
11691
327941f8
DB		 11692 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
11693 pass_cnt, err_cnt, jit_cnt, run_cnt);
11694
10f18e0b 11695 return err_cnt ? -EINVAL : 0;
64a8946b
AS		 11696}
11697
874be05f
JA		 11698struct tail_call_test {
11699 const char *descr;
11700 struct bpf_insn insns[MAX_INSNS];
11701 int result;
11702 int stack_depth;
11703};
11704
11705/*
11706 * Magic marker used in test snippets for tail calls below.
11707 * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
11708 * with the proper values by the test runner.
11709 */
11710#define TAIL_CALL_MARKER 0x7a11ca11
11711
11712/* Special offset to indicate a NULL call target */
11713#define TAIL_CALL_NULL 0x7fff
11714
11715/* Special offset to indicate an out-of-range index */
11716#define TAIL_CALL_INVALID 0x7ffe
11717
11718#define TAIL_CALL(offset) \
11719 BPF_LD_IMM64(R2, TAIL_CALL_MARKER), \
11720 BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
11721 offset, TAIL_CALL_MARKER), \
11722 BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
11723
11724/*
11725 * Tail call tests. Each test case may call any other test in the table,
11726 * including itself, specified as a relative index offset from the calling
11727 * test. The index TAIL_CALL_NULL can be used to specify a NULL target
11728 * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
11729 * results in a target index that is out of range.
11730 */
11731static struct tail_call_test tail_call_tests[] = {
11732 {
11733 "Tail call leaf",
11734 .insns = {
11735 BPF_ALU64_REG(BPF_MOV, R0, R1),
11736 BPF_ALU64_IMM(BPF_ADD, R0, 1),
11737 BPF_EXIT_INSN(),
11738 },
11739 .result = 1,
11740 },
11741 {
11742 "Tail call 2",
11743 .insns = {
11744 BPF_ALU64_IMM(BPF_ADD, R1, 2),
11745 TAIL_CALL(-1),
11746 BPF_ALU64_IMM(BPF_MOV, R0, -1),
11747 BPF_EXIT_INSN(),
11748 },
11749 .result = 3,
11750 },
11751 {
11752 "Tail call 3",
11753 .insns = {
11754 BPF_ALU64_IMM(BPF_ADD, R1, 3),
11755 TAIL_CALL(-1),
11756 BPF_ALU64_IMM(BPF_MOV, R0, -1),
11757 BPF_EXIT_INSN(),
11758 },
11759 .result = 6,
11760 },
11761 {
11762 "Tail call 4",
11763 .insns = {
11764 BPF_ALU64_IMM(BPF_ADD, R1, 4),
11765 TAIL_CALL(-1),
11766 BPF_ALU64_IMM(BPF_MOV, R0, -1),
11767 BPF_EXIT_INSN(),
11768 },
11769 .result = 10,
11770 },
11771 {
11772 "Tail call error path, max count reached",
11773 .insns = {
11774 BPF_ALU64_IMM(BPF_ADD, R1, 1),
11775 BPF_ALU64_REG(BPF_MOV, R0, R1),
11776 TAIL_CALL(0),
11777 BPF_EXIT_INSN(),
11778 },
11779 .result = MAX_TAIL_CALL_CNT + 1,
11780 },
11781 {
11782 "Tail call error path, NULL target",
11783 .insns = {
11784 BPF_ALU64_IMM(BPF_MOV, R0, -1),
11785 TAIL_CALL(TAIL_CALL_NULL),
11786 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11787 BPF_EXIT_INSN(),
11788 },
11789 .result = 1,
11790 },
11791 {
11792 "Tail call error path, index out of range",
11793 .insns = {
11794 BPF_ALU64_IMM(BPF_MOV, R0, -1),
11795 TAIL_CALL(TAIL_CALL_INVALID),
11796 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11797 BPF_EXIT_INSN(),
11798 },
11799 .result = 1,
11800 },
11801};
11802
11803static void __init destroy_tail_call_tests(struct bpf_array *progs)
11804{
11805 int i;
11806
11807 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
11808 if (progs->ptrs[i])
11809 bpf_prog_free(progs->ptrs[i]);
11810 kfree(progs);
11811}
11812
11813static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
11814{
11815 int ntests = ARRAY_SIZE(tail_call_tests);
11816 struct bpf_array *progs;
11817 int which, err;
11818
11819 /* Allocate the table of programs to be used for tall calls */
11820 progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]),
11821 GFP_KERNEL);
11822 if (!progs)
11823 goto out_nomem;
11824
11825 /* Create all eBPF programs and populate the table */
11826 for (which = 0; which < ntests; which++) {
11827 struct tail_call_test *test = &tail_call_tests[which];
11828 struct bpf_prog *fp;
11829 int len, i;
11830
11831 /* Compute the number of program instructions */
11832 for (len = 0; len < MAX_INSNS; len++) {
11833 struct bpf_insn *insn = &test->insns[len];
11834
11835 if (len < MAX_INSNS - 1 &&
11836 insn->code == (BPF_LD | BPF_DW | BPF_IMM))
11837 len++;
11838 if (insn->code == 0)
11839 break;
11840 }
11841
11842 /* Allocate and initialize the program */
11843 fp = bpf_prog_alloc(bpf_prog_size(len), 0);
11844 if (!fp)
11845 goto out_nomem;
11846
11847 fp->len = len;
11848 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
11849 fp->aux->stack_depth = test->stack_depth;
11850 memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
11851
11852 /* Relocate runtime tail call offsets and addresses */
11853 for (i = 0; i < len; i++) {
11854 struct bpf_insn *insn = &fp->insnsi[i];
11855
11856 if (insn->imm != TAIL_CALL_MARKER)
11857 continue;
11858
11859 switch (insn->code) {
11860 case BPF_LD | BPF_DW | BPF_IMM:
11861 insn[0].imm = (u32)(long)progs;
11862 insn[1].imm = ((u64)(long)progs) >> 32;
11863 break;
11864
11865 case BPF_ALU | BPF_MOV | BPF_K:
11866 if (insn->off == TAIL_CALL_NULL)
11867 insn->imm = ntests;
11868 else if (insn->off == TAIL_CALL_INVALID)
11869 insn->imm = ntests + 1;
11870 else
11871 insn->imm = which + insn->off;
11872 insn->off = 0;
11873 }
11874 }
11875
11876 fp = bpf_prog_select_runtime(fp, &err);
11877 if (err)
11878 goto out_err;
11879
11880 progs->ptrs[which] = fp;
11881 }
11882
11883 /* The last entry contains a NULL program pointer */
11884 progs->map.max_entries = ntests + 1;
11885 *pprogs = progs;
11886 return 0;
11887
11888out_nomem:
11889 err = -ENOMEM;
11890
11891out_err:
11892 if (progs)
11893 destroy_tail_call_tests(progs);
11894 return err;
11895}
11896
11897static __init int test_tail_calls(struct bpf_array *progs)
11898{
11899 int i, err_cnt = 0, pass_cnt = 0;
11900 int jit_cnt = 0, run_cnt = 0;
11901
11902 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
11903 struct tail_call_test *test = &tail_call_tests[i];
11904 struct bpf_prog *fp = progs->ptrs[i];
11905 u64 duration;
11906 int ret;
11907
11908 cond_resched();
11909
11910 pr_info("#%d %s ", i, test->descr);
11911 if (!fp) {
11912 err_cnt++;
11913 continue;
11914 }
11915 pr_cont("jited:%u ", fp->jited);
11916
11917 run_cnt++;
11918 if (fp->jited)
11919 jit_cnt++;
11920
11921 ret = __run_one(fp, NULL, MAX_TESTRUNS, &duration);
11922 if (ret == test->result) {
11923 pr_cont("%lld PASS", duration);
11924 pass_cnt++;
11925 } else {
11926 pr_cont("ret %d != %d FAIL", ret, test->result);
11927 err_cnt++;
11928 }
11929 }
11930
11931 pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
11932 __func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
11933
11934 return err_cnt ? -EINVAL : 0;
11935}
11936
64a8946b
AS		 11937static int __init test_bpf_init(void)
11938{
874be05f 11939 struct bpf_array *progs = NULL;
a4afd37b
DB		 11940 int ret;
11941
11942 ret = prepare_bpf_tests();
11943 if (ret < 0)
11944 return ret;
11945
11946 ret = test_bpf();
a4afd37b 11947 destroy_bpf_tests();
76db8087
YS		 11948 if (ret)
11949 return ret;
11950
874be05f
JA		 11951 ret = prepare_tail_call_tests(&progs);
11952 if (ret)
11953 return ret;
11954 ret = test_tail_calls(progs);
11955 destroy_tail_call_tests(progs);
11956 if (ret)
11957 return ret;
11958
76db8087 11959 return test_skb_segment();
64a8946b
AS		 11960}
11961
11962static void __exit test_bpf_exit(void)
11963{
11964}
11965
11966module_init(test_bpf_init);
11967module_exit(test_bpf_exit);
10f18e0b 11968
64a8946b 11969MODULE_LICENSE("GPL");
Empty description
This page took 1.792561 seconds and 4 git commands to generate.