projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bpf/tests: Minor restructuring of ALU tests
[linux-block.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)
27cc6dac 55#define FLAG_VERIFIER_ZEXT BIT(3)
10f18e0b
DB		 56
57enum {
58 CLASSIC = BIT(6), /* Old BPF instructions only. */
59 INTERNAL = BIT(7), /* Extended instruction set. */
60};
61
62#define TEST_TYPE_MASK (CLASSIC | INTERNAL)
64a8946b
AS		 63
64struct bpf_test {
65 const char *descr;
66 union {
67 struct sock_filter insns[MAX_INSNS];
2695fb55 68 struct bpf_insn insns_int[MAX_INSNS];
a4afd37b
DB		 69 struct {
70 void *insns;
71 unsigned int len;
72 } ptr;
ece80490 73 } u;
10f18e0b 74 __u8 aux;
64a8946b
AS		 75 __u8 data[MAX_DATA];
76 struct {
77 int data_size;
78 __u32 result;
79 } test[MAX_SUBTESTS];
a4afd37b 80 int (*fill_helper)(struct bpf_test *self);
09584b40 81 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
bac142ac 82 __u8 frag_data[MAX_DATA];
105c0361 83 int stack_depth; /* for eBPF only, since tests don't call verifier */
c2a228d6 84 int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */
64a8946b
AS		 85};
86
a4afd37b
DB		 87/* Large test cases need separate allocation and fill handler. */
88
89static int bpf_fill_maxinsns1(struct bpf_test *self)
90{
91 unsigned int len = BPF_MAXINSNS;
92 struct sock_filter *insn;
93 __u32 k = ~0;
94 int i;
95
96 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
97 if (!insn)
98 return -ENOMEM;
99
100 for (i = 0; i < len; i++, k--)
101 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
102
103 self->u.ptr.insns = insn;
104 self->u.ptr.len = len;
105
106 return 0;
107}
108
109static int bpf_fill_maxinsns2(struct bpf_test *self)
110{
111 unsigned int len = BPF_MAXINSNS;
112 struct sock_filter *insn;
113 int i;
114
115 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
116 if (!insn)
117 return -ENOMEM;
118
119 for (i = 0; i < len; i++)
120 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
121
122 self->u.ptr.insns = insn;
123 self->u.ptr.len = len;
124
125 return 0;
126}
127
128static int bpf_fill_maxinsns3(struct bpf_test *self)
129{
130 unsigned int len = BPF_MAXINSNS;
131 struct sock_filter *insn;
132 struct rnd_state rnd;
133 int i;
134
135 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
136 if (!insn)
137 return -ENOMEM;
138
139 prandom_seed_state(&rnd, 3141592653589793238ULL);
140
141 for (i = 0; i < len - 1; i++) {
142 __u32 k = prandom_u32_state(&rnd);
143
144 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
145 }
146
147 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
148
149 self->u.ptr.insns = insn;
150 self->u.ptr.len = len;
151
152 return 0;
153}
154
155static int bpf_fill_maxinsns4(struct bpf_test *self)
156{
157 unsigned int len = BPF_MAXINSNS + 1;
158 struct sock_filter *insn;
159 int i;
160
161 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
162 if (!insn)
163 return -ENOMEM;
164
165 for (i = 0; i < len; i++)
166 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
167
168 self->u.ptr.insns = insn;
169 self->u.ptr.len = len;
170
171 return 0;
172}
173
174static int bpf_fill_maxinsns5(struct bpf_test *self)
175{
176 unsigned int len = BPF_MAXINSNS;
177 struct sock_filter *insn;
178 int i;
179
180 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
181 if (!insn)
182 return -ENOMEM;
183
184 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
185
186 for (i = 1; i < len - 1; i++)
187 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
188
189 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
190
191 self->u.ptr.insns = insn;
192 self->u.ptr.len = len;
193
194 return 0;
195}
196
197static int bpf_fill_maxinsns6(struct bpf_test *self)
198{
199 unsigned int len = BPF_MAXINSNS;
200 struct sock_filter *insn;
201 int i;
202
203 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
204 if (!insn)
205 return -ENOMEM;
206
207 for (i = 0; i < len - 1; i++)
208 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
209 SKF_AD_VLAN_TAG_PRESENT);
210
211 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
212
213 self->u.ptr.insns = insn;
214 self->u.ptr.len = len;
215
216 return 0;
217}
218
219static int bpf_fill_maxinsns7(struct bpf_test *self)
220{
221 unsigned int len = BPF_MAXINSNS;
222 struct sock_filter *insn;
223 int i;
224
225 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
226 if (!insn)
227 return -ENOMEM;
228
229 for (i = 0; i < len - 4; i++)
230 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
231 SKF_AD_CPU);
232
233 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
234 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
235 SKF_AD_CPU);
236 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
237 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
238
239 self->u.ptr.insns = insn;
240 self->u.ptr.len = len;
241
242 return 0;
243}
244
245static int bpf_fill_maxinsns8(struct bpf_test *self)
246{
247 unsigned int len = BPF_MAXINSNS;
248 struct sock_filter *insn;
249 int i, jmp_off = len - 3;
250
251 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
252 if (!insn)
253 return -ENOMEM;
254
255 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
256
257 for (i = 1; i < len - 1; i++)
258 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
259
260 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
261
262 self->u.ptr.insns = insn;
263 self->u.ptr.len = len;
264
265 return 0;
266}
267
3b529602
DB		 268static int bpf_fill_maxinsns9(struct bpf_test *self)
269{
270 unsigned int len = BPF_MAXINSNS;
271 struct bpf_insn *insn;
272 int i;
273
274 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
275 if (!insn)
276 return -ENOMEM;
277
278 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
279 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
280 insn[2] = BPF_EXIT_INSN();
281
282 for (i = 3; i < len - 2; i++)
283 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
284
285 insn[len - 2] = BPF_EXIT_INSN();
286 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
287
288 self->u.ptr.insns = insn;
289 self->u.ptr.len = len;
290
291 return 0;
292}
293
294static int bpf_fill_maxinsns10(struct bpf_test *self)
295{
296 unsigned int len = BPF_MAXINSNS, hlen = len - 2;
297 struct bpf_insn *insn;
298 int i;
299
300 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
301 if (!insn)
302 return -ENOMEM;
303
304 for (i = 0; i < hlen / 2; i++)
305 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
306 for (i = hlen - 1; i > hlen / 2; i--)
307 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
308
309 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
310 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
311 insn[hlen + 1] = BPF_EXIT_INSN();
312
313 self->u.ptr.insns = insn;
314 self->u.ptr.len = len;
315
316 return 0;
317}
318
bde28bc6
DB		 319static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
320 unsigned int plen)
321{
322 struct sock_filter *insn;
323 unsigned int rlen;
324 int i, j;
325
326 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
327 if (!insn)
328 return -ENOMEM;
329
330 rlen = (len % plen) - 1;
331
332 for (i = 0; i + plen < len; i += plen)
333 for (j = 0; j < plen; j++)
334 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
335 plen - 1 - j, 0, 0);
336 for (j = 0; j < rlen; j++)
337 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
338 0, 0);
339
340 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
341
342 self->u.ptr.insns = insn;
343 self->u.ptr.len = len;
344
345 return 0;
346}
347
348static int bpf_fill_maxinsns11(struct bpf_test *self)
349{
16a660ef 350 /* Hits 70 passes on x86_64 and triggers NOPs padding. */
bde28bc6
DB		 351 return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
352}
353
be08815c
DB		 354static int bpf_fill_maxinsns12(struct bpf_test *self)
355{
356 unsigned int len = BPF_MAXINSNS;
357 struct sock_filter *insn;
358 int i = 0;
359
360 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
361 if (!insn)
362 return -ENOMEM;
363
364 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
365
366 for (i = 1; i < len - 1; i++)
367 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
368
369 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
370
371 self->u.ptr.insns = insn;
372 self->u.ptr.len = len;
373
374 return 0;
375}
376
377static int bpf_fill_maxinsns13(struct bpf_test *self)
378{
379 unsigned int len = BPF_MAXINSNS;
380 struct sock_filter *insn;
381 int i = 0;
382
383 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
384 if (!insn)
385 return -ENOMEM;
386
387 for (i = 0; i < len - 3; i++)
388 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
389
390 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
391 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
392 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
393
394 self->u.ptr.insns = insn;
395 self->u.ptr.len = len;
396
397 return 0;
398}
399
bde28bc6
DB		 400static int bpf_fill_ja(struct bpf_test *self)
401{
402 /* Hits exactly 11 passes on x86_64 JIT. */
403 return __bpf_fill_ja(self, 12, 9);
404}
405
4d9c5c53
AS		 406static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
407{
408 unsigned int len = BPF_MAXINSNS;
409 struct sock_filter *insn;
410 int i;
411
412 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
413 if (!insn)
414 return -ENOMEM;
415
416 for (i = 0; i < len - 1; i += 2) {
417 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
418 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
419 SKF_AD_OFF + SKF_AD_CPU);
420 }
421
422 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
423
424 self->u.ptr.insns = insn;
425 self->u.ptr.len = len;
426
427 return 0;
428}
429
85f68fe8
DB		 430static int __bpf_fill_stxdw(struct bpf_test *self, int size)
431{
432 unsigned int len = BPF_MAXINSNS;
433 struct bpf_insn *insn;
434 int i;
435
436 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
437 if (!insn)
438 return -ENOMEM;
439
440 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
441 insn[1] = BPF_ST_MEM(size, R10, -40, 42);
442
443 for (i = 2; i < len - 2; i++)
444 insn[i] = BPF_STX_XADD(size, R10, R0, -40);
445
446 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
447 insn[len - 1] = BPF_EXIT_INSN();
448
449 self->u.ptr.insns = insn;
450 self->u.ptr.len = len;
105c0361 451 self->stack_depth = 40;
85f68fe8
DB		 452
453 return 0;
454}
455
456static int bpf_fill_stxw(struct bpf_test *self)
457{
458 return __bpf_fill_stxdw(self, BPF_W);
459}
460
461static int bpf_fill_stxdw(struct bpf_test *self)
462{
463 return __bpf_fill_stxdw(self, BPF_DW);
464}
465
f1517eb7 466static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64)
66e5eb84 467{
f1517eb7
JA		 468 struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)};
469
470 memcpy(insns, tmp, sizeof(tmp));
471 return 2;
472}
473
474/*
475 * Branch conversion tests. Complex operations can expand to a lot
476 * of instructions when JITed. This in turn may cause jump offsets
477 * to overflow the field size of the native instruction, triggering
478 * a branch conversion mechanism in some JITs.
479 */
480static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm)
481{
482 struct bpf_insn *insns;
483 int len = S16_MAX + 5;
66e5eb84
JA		 484 int i;
485
f1517eb7
JA		 486 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
487 if (!insns)
66e5eb84
JA		 488 return -ENOMEM;
489
f1517eb7
JA		 490 i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL);
491 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
492 insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX);
493 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2);
494 insns[i++] = BPF_EXIT_INSN();
66e5eb84 495
f1517eb7
JA		 496 while (i < len - 1) {
497 static const int ops[] = {
498 BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD,
499 BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD,
500 };
501 int op = ops[(i >> 1) % ARRAY_SIZE(ops)];
502
503 if (i & 1)
504 insns[i++] = BPF_ALU32_REG(op, R0, R1);
505 else
506 insns[i++] = BPF_ALU64_REG(op, R0, R1);
507 }
66e5eb84 508
f1517eb7
JA		 509 insns[i++] = BPF_EXIT_INSN();
510 self->u.ptr.insns = insns;
66e5eb84 511 self->u.ptr.len = len;
f1517eb7 512 BUG_ON(i != len);
66e5eb84
JA		 513
514 return 0;
515}
516
f1517eb7
JA		 517/* Branch taken by runtime decision */
518static int bpf_fill_max_jmp_taken(struct bpf_test *self)
68c956fe 519{
f1517eb7
JA		 520 return __bpf_fill_max_jmp(self, BPF_JEQ, 1);
521}
68c956fe 522
f1517eb7
JA		 523/* Branch not taken by runtime decision */
524static int bpf_fill_max_jmp_not_taken(struct bpf_test *self)
525{
526 return __bpf_fill_max_jmp(self, BPF_JEQ, 0);
527}
528
529/* Branch always taken, known at JIT time */
530static int bpf_fill_max_jmp_always_taken(struct bpf_test *self)
531{
532 return __bpf_fill_max_jmp(self, BPF_JGE, 0);
533}
534
535/* Branch never taken, known at JIT time */
536static int bpf_fill_max_jmp_never_taken(struct bpf_test *self)
537{
538 return __bpf_fill_max_jmp(self, BPF_JLT, 0);
68c956fe
JA		 539}
540
e42fc3c2
JA		 541/* ALU result computation used in tests */
542static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op)
543{
544 *res = 0;
545 switch (op) {
546 case BPF_MOV:
547 *res = v2;
548 break;
549 case BPF_AND:
550 *res = v1 & v2;
551 break;
552 case BPF_OR:
553 *res = v1 | v2;
554 break;
555 case BPF_XOR:
556 *res = v1 ^ v2;
557 break;
558 case BPF_LSH:
559 *res = v1 << v2;
560 break;
561 case BPF_RSH:
562 *res = v1 >> v2;
563 break;
564 case BPF_ARSH:
565 *res = v1 >> v2;
566 if (v2 > 0 && v1 > S64_MAX)
567 *res |= ~0ULL << (64 - v2);
568 break;
569 case BPF_ADD:
570 *res = v1 + v2;
571 break;
572 case BPF_SUB:
573 *res = v1 - v2;
574 break;
575 case BPF_MUL:
576 *res = v1 * v2;
577 break;
578 case BPF_DIV:
579 if (v2 == 0)
580 return false;
581 *res = div64_u64(v1, v2);
582 break;
583 case BPF_MOD:
584 if (v2 == 0)
585 return false;
586 div64_u64_rem(v1, v2, res);
587 break;
588 }
589 return true;
590}
591
68c956fe
JA		 592/* Test an ALU shift operation for all valid shift values */
593static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op,
594 u8 mode, bool alu32)
595{
596 static const s64 regs[] = {
597 0x0123456789abcdefLL, /* dword > 0, word < 0 */
598 0xfedcba9876543210LL, /* dowrd < 0, word > 0 */
599 0xfedcba0198765432LL, /* dowrd < 0, word < 0 */
600 0x0123458967abcdefLL, /* dword > 0, word > 0 */
601 };
602 int bits = alu32 ? 32 : 64;
603 int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3;
604 struct bpf_insn *insn;
605 int imm, k;
606 int i = 0;
607
608 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
609 if (!insn)
610 return -ENOMEM;
611
612 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
613
614 for (k = 0; k < ARRAY_SIZE(regs); k++) {
615 s64 reg = regs[k];
616
617 i += __bpf_ld_imm64(&insn[i], R3, reg);
618
619 for (imm = 0; imm < bits; imm++) {
620 u64 val;
621
622 /* Perform operation */
623 insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
624 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm);
625 if (alu32) {
626 if (mode == BPF_K)
627 insn[i++] = BPF_ALU32_IMM(op, R1, imm);
628 else
629 insn[i++] = BPF_ALU32_REG(op, R1, R2);
e42fc3c2
JA		 630
631 if (op == BPF_ARSH)
632 reg = (s32)reg;
633 else
634 reg = (u32)reg;
635 __bpf_alu_result(&val, reg, imm, op);
636 val = (u32)val;
68c956fe
JA		 637 } else {
638 if (mode == BPF_K)
639 insn[i++] = BPF_ALU64_IMM(op, R1, imm);
640 else
641 insn[i++] = BPF_ALU64_REG(op, R1, R2);
e42fc3c2 642 __bpf_alu_result(&val, reg, imm, op);
68c956fe
JA		 643 }
644
645 /*
646 * When debugging a JIT that fails this test, one
647 * can write the immediate value to R0 here to find
648 * out which operand values that fail.
649 */
650
651 /* Load reference and check the result */
652 i += __bpf_ld_imm64(&insn[i], R4, val);
653 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1);
654 insn[i++] = BPF_EXIT_INSN();
655 }
656 }
657
658 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
659 insn[i++] = BPF_EXIT_INSN();
660
661 self->u.ptr.insns = insn;
662 self->u.ptr.len = len;
663 BUG_ON(i > len);
664
665 return 0;
666}
667
668static int bpf_fill_alu_lsh_imm(struct bpf_test *self)
669{
670 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false);
671}
672
673static int bpf_fill_alu_rsh_imm(struct bpf_test *self)
674{
675 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false);
676}
677
678static int bpf_fill_alu_arsh_imm(struct bpf_test *self)
679{
680 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false);
681}
682
683static int bpf_fill_alu_lsh_reg(struct bpf_test *self)
684{
685 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false);
686}
687
688static int bpf_fill_alu_rsh_reg(struct bpf_test *self)
689{
690 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false);
691}
692
693static int bpf_fill_alu_arsh_reg(struct bpf_test *self)
694{
695 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false);
696}
697
698static int bpf_fill_alu32_lsh_imm(struct bpf_test *self)
699{
700 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true);
701}
702
703static int bpf_fill_alu32_rsh_imm(struct bpf_test *self)
704{
705 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true);
706}
707
708static int bpf_fill_alu32_arsh_imm(struct bpf_test *self)
709{
710 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true);
711}
712
713static int bpf_fill_alu32_lsh_reg(struct bpf_test *self)
714{
715 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true);
716}
717
718static int bpf_fill_alu32_rsh_reg(struct bpf_test *self)
719{
720 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true);
721}
722
723static int bpf_fill_alu32_arsh_reg(struct bpf_test *self)
724{
725 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true);
726}
727
9298e63e
JA		 728/*
729 * Common operand pattern generator for exhaustive power-of-two magnitudes
730 * tests. The block size parameters can be adjusted to increase/reduce the
731 * number of combinatons tested and thereby execution speed and memory
732 * footprint.
733 */
734
735static inline s64 value(int msb, int delta, int sign)
736{
737 return sign * (1LL << msb) + delta;
738}
739
740static int __bpf_fill_pattern(struct bpf_test *self, void *arg,
741 int dbits, int sbits, int block1, int block2,
742 int (*emit)(struct bpf_test*, void*,
743 struct bpf_insn*, s64, s64))
744{
745 static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
746 struct bpf_insn *insns;
747 int di, si, bt, db, sb;
748 int count, len, k;
749 int extra = 1 + 2;
750 int i = 0;
751
752 /* Total number of iterations for the two pattern */
753 count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn);
754 count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn);
755
756 /* Compute the maximum number of insns and allocate the buffer */
757 len = extra + count * (*emit)(self, arg, NULL, 0, 0);
758 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
759 if (!insns)
760 return -ENOMEM;
761
762 /* Add head instruction(s) */
763 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
764
765 /*
766 * Pattern 1: all combinations of power-of-two magnitudes and sign,
767 * and with a block of contiguous values around each magnitude.
768 */
769 for (di = 0; di < dbits - 1; di++) /* Dst magnitudes */
770 for (si = 0; si < sbits - 1; si++) /* Src magnitudes */
771 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
772 for (db = -(block1 / 2);
773 db < (block1 + 1) / 2; db++)
774 for (sb = -(block1 / 2);
775 sb < (block1 + 1) / 2; sb++) {
776 s64 dst, src;
777
778 dst = value(di, db, sgn[k][0]);
779 src = value(si, sb, sgn[k][1]);
780 i += (*emit)(self, arg,
781 &insns[i],
782 dst, src);
783 }
784 /*
785 * Pattern 2: all combinations for a larger block of values
786 * for each power-of-two magnitude and sign, where the magnitude is
787 * the same for both operands.
788 */
789 for (bt = 0; bt < max(dbits, sbits) - 1; bt++) /* Magnitude */
790 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */
791 for (db = -(block2 / 2); db < (block2 + 1) / 2; db++)
792 for (sb = -(block2 / 2);
793 sb < (block2 + 1) / 2; sb++) {
794 s64 dst, src;
795
796 dst = value(bt % dbits, db, sgn[k][0]);
797 src = value(bt % sbits, sb, sgn[k][1]);
798 i += (*emit)(self, arg, &insns[i],
799 dst, src);
800 }
801
802 /* Append tail instructions */
803 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
804 insns[i++] = BPF_EXIT_INSN();
805 BUG_ON(i > len);
806
807 self->u.ptr.insns = insns;
808 self->u.ptr.len = i;
809
810 return 0;
811}
812
813/*
814 * Block size parameters used in pattern tests below. une as needed to
815 * increase/reduce the number combinations tested, see following examples.
816 * block values per operand MSB
817 * ----------------------------------------
818 * 0 none
819 * 1 (1 << MSB)
820 * 2 (1 << MSB) + [-1, 0]
821 * 3 (1 << MSB) + [-1, 0, 1]
822 */
823#define PATTERN_BLOCK1 1
824#define PATTERN_BLOCK2 5
825
826/* Number of test runs for a pattern test */
827#define NR_PATTERN_RUNS 1
828
829/*
830 * Exhaustive tests of ALU operations for all combinations of power-of-two
831 * magnitudes of the operands, both for positive and negative values. The
f68e8efd 832 * test is designed to verify e.g. the ALU and ALU64 operations for JITs that
9298e63e
JA		 833 * emit different code depending on the magnitude of the immediate value.
834 */
9298e63e
JA		 835static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg,
836 struct bpf_insn *insns, s64 dst, s64 imm)
837{
838 int op = *(int *)arg;
839 int i = 0;
840 u64 res;
841
842 if (!insns)
843 return 7;
844
845 if (__bpf_alu_result(&res, dst, (s32)imm, op)) {
846 i += __bpf_ld_imm64(&insns[i], R1, dst);
847 i += __bpf_ld_imm64(&insns[i], R3, res);
848 insns[i++] = BPF_ALU64_IMM(op, R1, imm);
849 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
850 insns[i++] = BPF_EXIT_INSN();
851 }
852
853 return i;
854}
855
856static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg,
857 struct bpf_insn *insns, s64 dst, s64 imm)
858{
859 int op = *(int *)arg;
860 int i = 0;
861 u64 res;
862
863 if (!insns)
864 return 7;
865
866 if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {
867 i += __bpf_ld_imm64(&insns[i], R1, dst);
868 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
869 insns[i++] = BPF_ALU32_IMM(op, R1, imm);
870 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
871 insns[i++] = BPF_EXIT_INSN();
872 }
873
874 return i;
875}
876
877static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg,
878 struct bpf_insn *insns, s64 dst, s64 src)
879{
880 int op = *(int *)arg;
881 int i = 0;
882 u64 res;
883
884 if (!insns)
885 return 9;
886
887 if (__bpf_alu_result(&res, dst, src, op)) {
888 i += __bpf_ld_imm64(&insns[i], R1, dst);
889 i += __bpf_ld_imm64(&insns[i], R2, src);
890 i += __bpf_ld_imm64(&insns[i], R3, res);
891 insns[i++] = BPF_ALU64_REG(op, R1, R2);
892 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
893 insns[i++] = BPF_EXIT_INSN();
894 }
895
896 return i;
897}
898
899static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg,
900 struct bpf_insn *insns, s64 dst, s64 src)
901{
902 int op = *(int *)arg;
903 int i = 0;
904 u64 res;
905
906 if (!insns)
907 return 9;
908
909 if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {
910 i += __bpf_ld_imm64(&insns[i], R1, dst);
911 i += __bpf_ld_imm64(&insns[i], R2, src);
912 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
913 insns[i++] = BPF_ALU32_REG(op, R1, R2);
914 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
915 insns[i++] = BPF_EXIT_INSN();
916 }
917
918 return i;
919}
920
921static int __bpf_fill_alu64_imm(struct bpf_test *self, int op)
922{
923 return __bpf_fill_pattern(self, &op, 64, 32,
924 PATTERN_BLOCK1, PATTERN_BLOCK2,
925 &__bpf_emit_alu64_imm);
926}
927
928static int __bpf_fill_alu32_imm(struct bpf_test *self, int op)
929{
930 return __bpf_fill_pattern(self, &op, 64, 32,
931 PATTERN_BLOCK1, PATTERN_BLOCK2,
932 &__bpf_emit_alu32_imm);
933}
934
935static int __bpf_fill_alu64_reg(struct bpf_test *self, int op)
936{
937 return __bpf_fill_pattern(self, &op, 64, 64,
938 PATTERN_BLOCK1, PATTERN_BLOCK2,
939 &__bpf_emit_alu64_reg);
940}
941
942static int __bpf_fill_alu32_reg(struct bpf_test *self, int op)
943{
944 return __bpf_fill_pattern(self, &op, 64, 64,
945 PATTERN_BLOCK1, PATTERN_BLOCK2,
946 &__bpf_emit_alu32_reg);
947}
948
949/* ALU64 immediate operations */
950static int bpf_fill_alu64_mov_imm(struct bpf_test *self)
951{
952 return __bpf_fill_alu64_imm(self, BPF_MOV);
953}
954
955static int bpf_fill_alu64_and_imm(struct bpf_test *self)
956{
957 return __bpf_fill_alu64_imm(self, BPF_AND);
958}
959
960static int bpf_fill_alu64_or_imm(struct bpf_test *self)
961{
962 return __bpf_fill_alu64_imm(self, BPF_OR);
963}
964
965static int bpf_fill_alu64_xor_imm(struct bpf_test *self)
966{
967 return __bpf_fill_alu64_imm(self, BPF_XOR);
968}
969
970static int bpf_fill_alu64_add_imm(struct bpf_test *self)
971{
972 return __bpf_fill_alu64_imm(self, BPF_ADD);
973}
974
975static int bpf_fill_alu64_sub_imm(struct bpf_test *self)
976{
977 return __bpf_fill_alu64_imm(self, BPF_SUB);
978}
979
980static int bpf_fill_alu64_mul_imm(struct bpf_test *self)
981{
982 return __bpf_fill_alu64_imm(self, BPF_MUL);
983}
984
985static int bpf_fill_alu64_div_imm(struct bpf_test *self)
986{
987 return __bpf_fill_alu64_imm(self, BPF_DIV);
988}
989
990static int bpf_fill_alu64_mod_imm(struct bpf_test *self)
991{
992 return __bpf_fill_alu64_imm(self, BPF_MOD);
993}
994
995/* ALU32 immediate operations */
996static int bpf_fill_alu32_mov_imm(struct bpf_test *self)
997{
998 return __bpf_fill_alu32_imm(self, BPF_MOV);
999}
1000
1001static int bpf_fill_alu32_and_imm(struct bpf_test *self)
1002{
1003 return __bpf_fill_alu32_imm(self, BPF_AND);
1004}
1005
1006static int bpf_fill_alu32_or_imm(struct bpf_test *self)
1007{
1008 return __bpf_fill_alu32_imm(self, BPF_OR);
1009}
1010
1011static int bpf_fill_alu32_xor_imm(struct bpf_test *self)
1012{
1013 return __bpf_fill_alu32_imm(self, BPF_XOR);
1014}
1015
1016static int bpf_fill_alu32_add_imm(struct bpf_test *self)
1017{
1018 return __bpf_fill_alu32_imm(self, BPF_ADD);
1019}
1020
1021static int bpf_fill_alu32_sub_imm(struct bpf_test *self)
1022{
1023 return __bpf_fill_alu32_imm(self, BPF_SUB);
1024}
1025
1026static int bpf_fill_alu32_mul_imm(struct bpf_test *self)
1027{
1028 return __bpf_fill_alu32_imm(self, BPF_MUL);
1029}
1030
1031static int bpf_fill_alu32_div_imm(struct bpf_test *self)
1032{
1033 return __bpf_fill_alu32_imm(self, BPF_DIV);
1034}
1035
1036static int bpf_fill_alu32_mod_imm(struct bpf_test *self)
1037{
1038 return __bpf_fill_alu32_imm(self, BPF_MOD);
1039}
1040
1041/* ALU64 register operations */
1042static int bpf_fill_alu64_mov_reg(struct bpf_test *self)
1043{
1044 return __bpf_fill_alu64_reg(self, BPF_MOV);
1045}
1046
1047static int bpf_fill_alu64_and_reg(struct bpf_test *self)
1048{
1049 return __bpf_fill_alu64_reg(self, BPF_AND);
1050}
1051
1052static int bpf_fill_alu64_or_reg(struct bpf_test *self)
1053{
1054 return __bpf_fill_alu64_reg(self, BPF_OR);
1055}
1056
1057static int bpf_fill_alu64_xor_reg(struct bpf_test *self)
1058{
1059 return __bpf_fill_alu64_reg(self, BPF_XOR);
1060}
1061
1062static int bpf_fill_alu64_add_reg(struct bpf_test *self)
1063{
1064 return __bpf_fill_alu64_reg(self, BPF_ADD);
1065}
1066
1067static int bpf_fill_alu64_sub_reg(struct bpf_test *self)
1068{
1069 return __bpf_fill_alu64_reg(self, BPF_SUB);
1070}
1071
1072static int bpf_fill_alu64_mul_reg(struct bpf_test *self)
1073{
1074 return __bpf_fill_alu64_reg(self, BPF_MUL);
1075}
1076
1077static int bpf_fill_alu64_div_reg(struct bpf_test *self)
1078{
1079 return __bpf_fill_alu64_reg(self, BPF_DIV);
1080}
1081
1082static int bpf_fill_alu64_mod_reg(struct bpf_test *self)
1083{
1084 return __bpf_fill_alu64_reg(self, BPF_MOD);
1085}
1086
1087/* ALU32 register operations */
1088static int bpf_fill_alu32_mov_reg(struct bpf_test *self)
1089{
1090 return __bpf_fill_alu32_reg(self, BPF_MOV);
1091}
1092
1093static int bpf_fill_alu32_and_reg(struct bpf_test *self)
1094{
1095 return __bpf_fill_alu32_reg(self, BPF_AND);
1096}
1097
1098static int bpf_fill_alu32_or_reg(struct bpf_test *self)
1099{
1100 return __bpf_fill_alu32_reg(self, BPF_OR);
1101}
1102
1103static int bpf_fill_alu32_xor_reg(struct bpf_test *self)
1104{
1105 return __bpf_fill_alu32_reg(self, BPF_XOR);
1106}
1107
1108static int bpf_fill_alu32_add_reg(struct bpf_test *self)
1109{
1110 return __bpf_fill_alu32_reg(self, BPF_ADD);
1111}
1112
1113static int bpf_fill_alu32_sub_reg(struct bpf_test *self)
1114{
1115 return __bpf_fill_alu32_reg(self, BPF_SUB);
1116}
1117
1118static int bpf_fill_alu32_mul_reg(struct bpf_test *self)
1119{
1120 return __bpf_fill_alu32_reg(self, BPF_MUL);
1121}
1122
1123static int bpf_fill_alu32_div_reg(struct bpf_test *self)
1124{
1125 return __bpf_fill_alu32_reg(self, BPF_DIV);
1126}
1127
1128static int bpf_fill_alu32_mod_reg(struct bpf_test *self)
1129{
1130 return __bpf_fill_alu32_reg(self, BPF_MOD);
1131}
1132
f68e8efd
JA		 1133/*
1134 * Exhaustive tests of atomic operations for all power-of-two operand
1135 * magnitudes, both for positive and negative values.
1136 */
1137
1138static int __bpf_emit_atomic64(struct bpf_test *self, void *arg,
1139 struct bpf_insn *insns, s64 dst, s64 src)
1140{
1141 int op = *(int *)arg;
1142 u64 keep, fetch, res;
1143 int i = 0;
1144
1145 if (!insns)
1146 return 21;
1147
1148 switch (op) {
1149 case BPF_XCHG:
1150 res = src;
1151 break;
1152 default:
1153 __bpf_alu_result(&res, dst, src, BPF_OP(op));
1154 }
1155
1156 keep = 0x0123456789abcdefULL;
1157 if (op & BPF_FETCH)
1158 fetch = dst;
1159 else
1160 fetch = src;
1161
1162 i += __bpf_ld_imm64(&insns[i], R0, keep);
1163 i += __bpf_ld_imm64(&insns[i], R1, dst);
1164 i += __bpf_ld_imm64(&insns[i], R2, src);
1165 i += __bpf_ld_imm64(&insns[i], R3, res);
1166 i += __bpf_ld_imm64(&insns[i], R4, fetch);
1167 i += __bpf_ld_imm64(&insns[i], R5, keep);
1168
1169 insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1170 insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8);
1171 insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8);
1172
1173 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1174 insns[i++] = BPF_EXIT_INSN();
1175
1176 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1177 insns[i++] = BPF_EXIT_INSN();
1178
1179 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1180 insns[i++] = BPF_EXIT_INSN();
1181
1182 return i;
1183}
1184
1185static int __bpf_emit_atomic32(struct bpf_test *self, void *arg,
1186 struct bpf_insn *insns, s64 dst, s64 src)
1187{
1188 int op = *(int *)arg;
1189 u64 keep, fetch, res;
1190 int i = 0;
1191
1192 if (!insns)
1193 return 21;
1194
1195 switch (op) {
1196 case BPF_XCHG:
1197 res = src;
1198 break;
1199 default:
1200 __bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op));
1201 }
1202
1203 keep = 0x0123456789abcdefULL;
1204 if (op & BPF_FETCH)
1205 fetch = (u32)dst;
1206 else
1207 fetch = src;
1208
1209 i += __bpf_ld_imm64(&insns[i], R0, keep);
1210 i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1211 i += __bpf_ld_imm64(&insns[i], R2, src);
1212 i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
1213 i += __bpf_ld_imm64(&insns[i], R4, fetch);
1214 i += __bpf_ld_imm64(&insns[i], R5, keep);
1215
1216 insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1217 insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4);
1218 insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4);
1219
1220 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
1221 insns[i++] = BPF_EXIT_INSN();
1222
1223 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1);
1224 insns[i++] = BPF_EXIT_INSN();
1225
1226 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1);
1227 insns[i++] = BPF_EXIT_INSN();
1228
1229 return i;
1230}
1231
1232static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg,
1233 struct bpf_insn *insns, s64 dst, s64 src)
1234{
1235 int i = 0;
1236
1237 if (!insns)
1238 return 23;
1239
1240 i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1241 i += __bpf_ld_imm64(&insns[i], R1, dst);
1242 i += __bpf_ld_imm64(&insns[i], R2, src);
1243
1244 /* Result unsuccessful */
1245 insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8);
1246 insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1247 insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1248
1249 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
1250 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1251 insns[i++] = BPF_EXIT_INSN();
1252
1253 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1254 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1255 insns[i++] = BPF_EXIT_INSN();
1256
1257 /* Result successful */
1258 insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8);
1259 insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
1260
1261 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
1262 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1263 insns[i++] = BPF_EXIT_INSN();
1264
1265 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1266 insns[i++] = BPF_MOV64_IMM(R0, __LINE__);
1267 insns[i++] = BPF_EXIT_INSN();
1268
1269 return i;
1270}
1271
1272static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg,
1273 struct bpf_insn *insns, s64 dst, s64 src)
1274{
1275 int i = 0;
1276
1277 if (!insns)
1278 return 27;
1279
1280 i += __bpf_ld_imm64(&insns[i], R0, ~dst);
1281 i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);
1282 i += __bpf_ld_imm64(&insns[i], R2, src);
1283
1284 /* Result unsuccessful */
1285 insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4);
1286 insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1287 insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1288 insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1289
1290 insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
1291 insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1292 insns[i++] = BPF_EXIT_INSN();
1293
1294 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
1295 insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1296 insns[i++] = BPF_EXIT_INSN();
1297
1298 /* Result successful */
1299 i += __bpf_ld_imm64(&insns[i], R0, dst);
1300 insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4);
1301 insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */
1302 insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
1303
1304 insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
1305 insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1306 insns[i++] = BPF_EXIT_INSN();
1307
1308 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2);
1309 insns[i++] = BPF_MOV32_IMM(R0, __LINE__);
1310 insns[i++] = BPF_EXIT_INSN();
1311
1312 return i;
1313}
1314
1315static int __bpf_fill_atomic64(struct bpf_test *self, int op)
1316{
1317 return __bpf_fill_pattern(self, &op, 64, 64,
1318 0, PATTERN_BLOCK2,
1319 &__bpf_emit_atomic64);
1320}
1321
1322static int __bpf_fill_atomic32(struct bpf_test *self, int op)
1323{
1324 return __bpf_fill_pattern(self, &op, 64, 64,
1325 0, PATTERN_BLOCK2,
1326 &__bpf_emit_atomic32);
1327}
1328
1329/* 64-bit atomic operations */
1330static int bpf_fill_atomic64_add(struct bpf_test *self)
1331{
1332 return __bpf_fill_atomic64(self, BPF_ADD);
1333}
1334
1335static int bpf_fill_atomic64_and(struct bpf_test *self)
1336{
1337 return __bpf_fill_atomic64(self, BPF_AND);
1338}
1339
1340static int bpf_fill_atomic64_or(struct bpf_test *self)
1341{
1342 return __bpf_fill_atomic64(self, BPF_OR);
1343}
1344
1345static int bpf_fill_atomic64_xor(struct bpf_test *self)
1346{
1347 return __bpf_fill_atomic64(self, BPF_XOR);
1348}
1349
1350static int bpf_fill_atomic64_add_fetch(struct bpf_test *self)
1351{
1352 return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH);
1353}
1354
1355static int bpf_fill_atomic64_and_fetch(struct bpf_test *self)
1356{
1357 return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH);
1358}
1359
1360static int bpf_fill_atomic64_or_fetch(struct bpf_test *self)
1361{
1362 return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH);
1363}
1364
1365static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self)
1366{
1367 return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH);
1368}
1369
1370static int bpf_fill_atomic64_xchg(struct bpf_test *self)
1371{
1372 return __bpf_fill_atomic64(self, BPF_XCHG);
1373}
1374
1375static int bpf_fill_cmpxchg64(struct bpf_test *self)
1376{
1377 return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1378 &__bpf_emit_cmpxchg64);
1379}
1380
1381/* 32-bit atomic operations */
1382static int bpf_fill_atomic32_add(struct bpf_test *self)
1383{
1384 return __bpf_fill_atomic32(self, BPF_ADD);
1385}
1386
1387static int bpf_fill_atomic32_and(struct bpf_test *self)
1388{
1389 return __bpf_fill_atomic32(self, BPF_AND);
1390}
1391
1392static int bpf_fill_atomic32_or(struct bpf_test *self)
1393{
1394 return __bpf_fill_atomic32(self, BPF_OR);
1395}
1396
1397static int bpf_fill_atomic32_xor(struct bpf_test *self)
1398{
1399 return __bpf_fill_atomic32(self, BPF_XOR);
1400}
1401
1402static int bpf_fill_atomic32_add_fetch(struct bpf_test *self)
1403{
1404 return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH);
1405}
1406
1407static int bpf_fill_atomic32_and_fetch(struct bpf_test *self)
1408{
1409 return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH);
1410}
1411
1412static int bpf_fill_atomic32_or_fetch(struct bpf_test *self)
1413{
1414 return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH);
1415}
1416
1417static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self)
1418{
1419 return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH);
1420}
1421
1422static int bpf_fill_atomic32_xchg(struct bpf_test *self)
1423{
1424 return __bpf_fill_atomic32(self, BPF_XCHG);
1425}
1426
1427static int bpf_fill_cmpxchg32(struct bpf_test *self)
1428{
1429 return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2,
1430 &__bpf_emit_cmpxchg32);
1431}
1432
2e807611
JA		 1433/*
1434 * Test the two-instruction 64-bit immediate load operation for all
1435 * power-of-two magnitudes of the immediate operand. For each MSB, a block
1436 * of immediate values centered around the power-of-two MSB are tested,
1437 * both for positive and negative values. The test is designed to verify
1438 * the operation for JITs that emit different code depending on the magnitude
1439 * of the immediate value. This is often the case if the native instruction
1440 * immediate field width is narrower than 32 bits.
1441 */
1442static int bpf_fill_ld_imm64(struct bpf_test *self)
1443{
1444 int block = 64; /* Increase for more tests per MSB position */
1445 int len = 3 + 8 * 63 * block * 2;
1446 struct bpf_insn *insn;
1447 int bit, adj, sign;
1448 int i = 0;
1449
1450 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
1451 if (!insn)
1452 return -ENOMEM;
1453
1454 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
1455
1456 for (bit = 0; bit <= 62; bit++) {
1457 for (adj = -block / 2; adj < block / 2; adj++) {
1458 for (sign = -1; sign <= 1; sign += 2) {
1459 s64 imm = sign * ((1LL << bit) + adj);
1460
1461 /* Perform operation */
1462 i += __bpf_ld_imm64(&insn[i], R1, imm);
1463
1464 /* Load reference */
1465 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm);
1466 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
1467 (u32)(imm >> 32));
1468 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
1469 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
1470
1471 /* Check result */
1472 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1);
1473 insn[i++] = BPF_EXIT_INSN();
1474 }
1475 }
1476 }
1477
1478 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
1479 insn[i++] = BPF_EXIT_INSN();
1480
1481 self->u.ptr.insns = insn;
1482 self->u.ptr.len = len;
1483 BUG_ON(i != len);
1484
1485 return 0;
1486}
a5a36544
JA		 1487
1488/*
1489 * Exhaustive tests of JMP operations for all combinations of power-of-two
1490 * magnitudes of the operands, both for positive and negative values. The
1491 * test is designed to verify e.g. the JMP and JMP32 operations for JITs that
1492 * emit different code depending on the magnitude of the immediate value.
1493 */
1494
1495static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)
1496{
1497 switch (op) {
1498 case BPF_JSET:
1499 return !!(v1 & v2);
1500 case BPF_JEQ:
1501 return v1 == v2;
1502 case BPF_JNE:
1503 return v1 != v2;
1504 case BPF_JGT:
1505 return (u64)v1 > (u64)v2;
1506 case BPF_JGE:
1507 return (u64)v1 >= (u64)v2;
1508 case BPF_JLT:
1509 return (u64)v1 < (u64)v2;
1510 case BPF_JLE:
1511 return (u64)v1 <= (u64)v2;
1512 case BPF_JSGT:
1513 return v1 > v2;
1514 case BPF_JSGE:
1515 return v1 >= v2;
1516 case BPF_JSLT:
1517 return v1 < v2;
1518 case BPF_JSLE:
1519 return v1 <= v2;
1520 }
1521 return false;
1522}
1523
1524static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,
1525 struct bpf_insn *insns, s64 dst, s64 imm)
1526{
1527 int op = *(int *)arg;
1528
1529 if (insns) {
1530 bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);
1531 int i = 0;
1532
1533 insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);
1534
1535 i += __bpf_ld_imm64(&insns[i], R1, dst);
1536 insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);
1537 if (!match)
1538 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1539 insns[i++] = BPF_EXIT_INSN();
1540
1541 return i;
1542 }
1543
1544 return 5 + 1;
1545}
1546
1547static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,
1548 struct bpf_insn *insns, s64 dst, s64 imm)
1549{
1550 int op = *(int *)arg;
1551
1552 if (insns) {
1553 bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);
1554 int i = 0;
1555
1556 i += __bpf_ld_imm64(&insns[i], R1, dst);
1557 insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);
1558 if (!match)
1559 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1560 insns[i++] = BPF_EXIT_INSN();
1561
1562 return i;
1563 }
1564
1565 return 5;
1566}
1567
1568static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,
1569 struct bpf_insn *insns, s64 dst, s64 src)
1570{
1571 int op = *(int *)arg;
1572
1573 if (insns) {
1574 bool match = __bpf_match_jmp_cond(dst, src, op);
1575 int i = 0;
1576
1577 i += __bpf_ld_imm64(&insns[i], R1, dst);
1578 i += __bpf_ld_imm64(&insns[i], R2, src);
1579 insns[i++] = BPF_JMP_REG(op, R1, R2, 1);
1580 if (!match)
1581 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1582 insns[i++] = BPF_EXIT_INSN();
1583
1584 return i;
1585 }
1586
1587 return 7;
1588}
1589
1590static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,
1591 struct bpf_insn *insns, s64 dst, s64 src)
1592{
1593 int op = *(int *)arg;
1594
1595 if (insns) {
1596 bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);
1597 int i = 0;
1598
1599 i += __bpf_ld_imm64(&insns[i], R1, dst);
1600 i += __bpf_ld_imm64(&insns[i], R2, src);
1601 insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);
1602 if (!match)
1603 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
1604 insns[i++] = BPF_EXIT_INSN();
1605
1606 return i;
1607 }
1608
1609 return 7;
1610}
1611
1612static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)
1613{
1614 return __bpf_fill_pattern(self, &op, 64, 32,
1615 PATTERN_BLOCK1, PATTERN_BLOCK2,
1616 &__bpf_emit_jmp_imm);
1617}
1618
1619static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)
1620{
1621 return __bpf_fill_pattern(self, &op, 64, 32,
1622 PATTERN_BLOCK1, PATTERN_BLOCK2,
1623 &__bpf_emit_jmp32_imm);
1624}
1625
1626static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)
1627{
1628 return __bpf_fill_pattern(self, &op, 64, 64,
1629 PATTERN_BLOCK1, PATTERN_BLOCK2,
1630 &__bpf_emit_jmp_reg);
1631}
1632
1633static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)
1634{
1635 return __bpf_fill_pattern(self, &op, 64, 64,
1636 PATTERN_BLOCK1, PATTERN_BLOCK2,
1637 &__bpf_emit_jmp32_reg);
1638}
1639
1640/* JMP immediate tests */
1641static int bpf_fill_jmp_jset_imm(struct bpf_test *self)
1642{
1643 return __bpf_fill_jmp_imm(self, BPF_JSET);
1644}
1645
1646static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)
1647{
1648 return __bpf_fill_jmp_imm(self, BPF_JEQ);
1649}
1650
1651static int bpf_fill_jmp_jne_imm(struct bpf_test *self)
1652{
1653 return __bpf_fill_jmp_imm(self, BPF_JNE);
1654}
1655
1656static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)
1657{
1658 return __bpf_fill_jmp_imm(self, BPF_JGT);
1659}
1660
1661static int bpf_fill_jmp_jge_imm(struct bpf_test *self)
1662{
1663 return __bpf_fill_jmp_imm(self, BPF_JGE);
1664}
1665
1666static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)
1667{
1668 return __bpf_fill_jmp_imm(self, BPF_JLT);
1669}
1670
1671static int bpf_fill_jmp_jle_imm(struct bpf_test *self)
1672{
1673 return __bpf_fill_jmp_imm(self, BPF_JLE);
1674}
1675
1676static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)
1677{
1678 return __bpf_fill_jmp_imm(self, BPF_JSGT);
1679}
1680
1681static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)
1682{
1683 return __bpf_fill_jmp_imm(self, BPF_JSGE);
1684}
1685
1686static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)
1687{
1688 return __bpf_fill_jmp_imm(self, BPF_JSLT);
1689}
1690
1691static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)
1692{
1693 return __bpf_fill_jmp_imm(self, BPF_JSLE);
1694}
1695
1696/* JMP32 immediate tests */
1697static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)
1698{
1699 return __bpf_fill_jmp32_imm(self, BPF_JSET);
1700}
1701
1702static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)
1703{
1704 return __bpf_fill_jmp32_imm(self, BPF_JEQ);
1705}
1706
1707static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)
1708{
1709 return __bpf_fill_jmp32_imm(self, BPF_JNE);
1710}
1711
1712static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)
1713{
1714 return __bpf_fill_jmp32_imm(self, BPF_JGT);
1715}
1716
1717static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)
1718{
1719 return __bpf_fill_jmp32_imm(self, BPF_JGE);
1720}
1721
1722static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)
1723{
1724 return __bpf_fill_jmp32_imm(self, BPF_JLT);
1725}
1726
1727static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)
1728{
1729 return __bpf_fill_jmp32_imm(self, BPF_JLE);
1730}
1731
1732static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)
1733{
1734 return __bpf_fill_jmp32_imm(self, BPF_JSGT);
1735}
1736
1737static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)
1738{
1739 return __bpf_fill_jmp32_imm(self, BPF_JSGE);
1740}
1741
1742static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)
1743{
1744 return __bpf_fill_jmp32_imm(self, BPF_JSLT);
1745}
1746
1747static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)
1748{
1749 return __bpf_fill_jmp32_imm(self, BPF_JSLE);
1750}
1751
1752/* JMP register tests */
1753static int bpf_fill_jmp_jset_reg(struct bpf_test *self)
1754{
1755 return __bpf_fill_jmp_reg(self, BPF_JSET);
1756}
1757
1758static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)
1759{
1760 return __bpf_fill_jmp_reg(self, BPF_JEQ);
1761}
1762
1763static int bpf_fill_jmp_jne_reg(struct bpf_test *self)
1764{
1765 return __bpf_fill_jmp_reg(self, BPF_JNE);
1766}
1767
1768static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)
1769{
1770 return __bpf_fill_jmp_reg(self, BPF_JGT);
1771}
1772
1773static int bpf_fill_jmp_jge_reg(struct bpf_test *self)
1774{
1775 return __bpf_fill_jmp_reg(self, BPF_JGE);
1776}
1777
1778static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)
1779{
1780 return __bpf_fill_jmp_reg(self, BPF_JLT);
1781}
1782
1783static int bpf_fill_jmp_jle_reg(struct bpf_test *self)
1784{
1785 return __bpf_fill_jmp_reg(self, BPF_JLE);
1786}
1787
1788static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)
1789{
1790 return __bpf_fill_jmp_reg(self, BPF_JSGT);
1791}
1792
1793static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)
1794{
1795 return __bpf_fill_jmp_reg(self, BPF_JSGE);
1796}
1797
1798static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)
1799{
1800 return __bpf_fill_jmp_reg(self, BPF_JSLT);
1801}
1802
1803static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)
1804{
1805 return __bpf_fill_jmp_reg(self, BPF_JSLE);
1806}
1807
1808/* JMP32 register tests */
1809static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)
1810{
1811 return __bpf_fill_jmp32_reg(self, BPF_JSET);
1812}
1813
1814static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)
1815{
1816 return __bpf_fill_jmp32_reg(self, BPF_JEQ);
1817}
1818
1819static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)
1820{
1821 return __bpf_fill_jmp32_reg(self, BPF_JNE);
1822}
1823
1824static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)
1825{
1826 return __bpf_fill_jmp32_reg(self, BPF_JGT);
1827}
1828
1829static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)
1830{
1831 return __bpf_fill_jmp32_reg(self, BPF_JGE);
1832}
1833
1834static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)
1835{
1836 return __bpf_fill_jmp32_reg(self, BPF_JLT);
1837}
1838
1839static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)
1840{
1841 return __bpf_fill_jmp32_reg(self, BPF_JLE);
1842}
1843
1844static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)
1845{
1846 return __bpf_fill_jmp32_reg(self, BPF_JSGT);
1847}
1848
1849static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)
1850{
1851 return __bpf_fill_jmp32_reg(self, BPF_JSGE);
1852}
1853
1854static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)
1855{
1856 return __bpf_fill_jmp32_reg(self, BPF_JSLT);
1857}
1858
1859static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
1860{
1861 return __bpf_fill_jmp32_reg(self, BPF_JSLE);
1862}
1863
a7d2e752
JA		 1864/*
1865 * Set up a sequence of staggered jumps, forwards and backwards with
1866 * increasing offset. This tests the conversion of relative jumps to
1867 * JITed native jumps. On some architectures, for example MIPS, a large
1868 * PC-relative jump offset may overflow the immediate field of the native
1869 * conditional branch instruction, triggering a conversion to use an
1870 * absolute jump instead. Since this changes the jump offsets, another
1871 * offset computation pass is necessary, and that may in turn trigger
1872 * another branch conversion. This jump sequence is particularly nasty
1873 * in that regard.
1874 *
1875 * The sequence generation is parameterized by size and jump type.
1876 * The size must be even, and the expected result is always size + 1.
1877 * Below is an example with size=8 and result=9.
1878 *
1879 * ________________________Start
1880 * R0 = 0
1881 * R1 = r1
1882 * R2 = r2
1883 * ,------- JMP +4 * 3______________Preamble: 4 insns
1884 * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
1885 * | | R0 = 8 |
1886 * | | JMP +7 * 3 ------------------------.
1887 * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------. | |
1888 * | | | R0 = 6 | | |
1889 * | | | JMP +5 * 3 ------------------. | |
1890 * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------. | | | |
1891 * | | | | R0 = 4 | | | | |
1892 * | | | | JMP +3 * 3 ------------. | | | |
1893 * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--. | | | | | |
1894 * | | | | | R0 = 2 | | | | | | |
1895 * | | | | | JMP +1 * 3 ------. | | | | | |
1896 * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1 1 2 3 4 5 6 7 8 loc
1897 * | | | | | R0 = 1 -1 +2 -3 +4 -5 +6 -7 +8 off
1898 * | | | | | JMP -2 * 3 ---' | | | | | | |
1899 * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----' | | | | | |
1900 * | | | | | | R0 = 3 | | | | | |
1901 * | | | | | | JMP -4 * 3 ---------' | | | | |
1902 * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------' | | | |
1903 * | | | | | | | R0 = 5 | | | |
1904 * | | | | | | | JMP -6 * 3 ---------------' | | |
1905 * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------' | |
1906 * | | | | | | | | R0 = 7 | |
1907 * | | Error | | | JMP -8 * 3 ---------------------' |
1908 * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
1909 * | | | | | | | | | R0 = 9__________________Sequence: 3 * size - 1 insns
1910 * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
1911 *
1912 */
1913
1914/* The maximum size parameter */
1915#define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
1916
1917/* We use a reduced number of iterations to get a reasonable execution time */
1918#define NR_STAGGERED_JMP_RUNS 10
1919
1920static int __bpf_fill_staggered_jumps(struct bpf_test *self,
1921 const struct bpf_insn *jmp,
1922 u64 r1, u64 r2)
1923{
1924 int size = self->test[0].result - 1;
1925 int len = 4 + 3 * (size + 1);
1926 struct bpf_insn *insns;
1927 int off, ind;
1928
1929 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
1930 if (!insns)
1931 return -ENOMEM;
1932
1933 /* Preamble */
1934 insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
1935 insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
1936 insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
1937 insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
1938
1939 /* Sequence */
1940 for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
1941 struct bpf_insn *ins = &insns[4 + 3 * ind];
1942 int loc;
1943
1944 if (off == 0)
1945 off--;
1946
1947 loc = abs(off);
1948 ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
1949 3 * (size - ind) + 1);
1950 ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
1951 ins[2] = *jmp;
1952 ins[2].off = 3 * (off - 1);
1953 }
1954
1955 /* Return */
1956 insns[len - 1] = BPF_EXIT_INSN();
1957
1958 self->u.ptr.insns = insns;
1959 self->u.ptr.len = len;
1960
1961 return 0;
1962}
1963
1964/* 64-bit unconditional jump */
1965static int bpf_fill_staggered_ja(struct bpf_test *self)
1966{
1967 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
1968
1969 return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
1970}
1971
1972/* 64-bit immediate jumps */
1973static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
1974{
1975 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
1976
1977 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
1978}
1979
1980static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
1981{
1982 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
1983
1984 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
1985}
1986
1987static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
1988{
1989 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
1990
1991 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
1992}
1993
1994static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
1995{
1996 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
1997
1998 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
1999}
2000
2001static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
2002{
2003 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
2004
2005 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2006}
2007
2008static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
2009{
2010 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
2011
2012 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2013}
2014
2015static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
2016{
2017 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
2018
2019 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2020}
2021
2022static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
2023{
2024 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
2025
2026 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2027}
2028
2029static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
2030{
2031 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
2032
2033 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2034}
2035
2036static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
2037{
2038 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
2039
2040 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2041}
2042
2043static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
2044{
2045 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
2046
2047 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2048}
2049
2050/* 64-bit register jumps */
2051static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
2052{
2053 struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
2054
2055 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2056}
2057
2058static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
2059{
2060 struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
2061
2062 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2063}
2064
2065static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
2066{
2067 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
2068
2069 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2070}
2071
2072static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
2073{
2074 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
2075
2076 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2077}
2078
2079static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
2080{
2081 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
2082
2083 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2084}
2085
2086static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
2087{
2088 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
2089
2090 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2091}
2092
2093static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
2094{
2095 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
2096
2097 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2098}
2099
2100static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
2101{
2102 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
2103
2104 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2105}
2106
2107static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
2108{
2109 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
2110
2111 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2112}
2113
2114static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
2115{
2116 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
2117
2118 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2119}
2120
2121static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
2122{
2123 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
2124
2125 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2126}
2127
2128/* 32-bit immediate jumps */
2129static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
2130{
2131 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
2132
2133 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2134}
2135
2136static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
2137{
2138 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
2139
2140 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
2141}
2142
2143static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
2144{
2145 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
2146
2147 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
2148}
2149
2150static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
2151{
2152 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
2153
2154 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
2155}
2156
2157static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
2158{
2159 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
2160
2161 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2162}
2163
2164static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
2165{
2166 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
2167
2168 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2169}
2170
2171static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
2172{
2173 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
2174
2175 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
2176}
2177
2178static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
2179{
2180 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
2181
2182 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2183}
2184
2185static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
2186{
2187 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
2188
2189 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2190}
2191
2192static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
2193{
2194 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
2195
2196 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
2197}
2198
2199static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
2200{
2201 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
2202
2203 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
2204}
2205
2206/* 32-bit register jumps */
2207static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
2208{
2209 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
2210
2211 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2212}
2213
2214static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
2215{
2216 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
2217
2218 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
2219}
2220
2221static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
2222{
2223 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
2224
2225 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
2226}
2227
2228static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
2229{
2230 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
2231
2232 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
2233}
2234
2235static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
2236{
2237 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
2238
2239 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2240}
2241
2242static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
2243{
2244 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
2245
2246 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
2247}
2248
2249static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
2250{
2251 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
2252
2253 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
2254}
2255
2256static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
2257{
2258 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
2259
2260 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
2261}
2262
2263static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
2264{
2265 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
2266
2267 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
2268}
2269
2270static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
2271{
2272 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
2273
2274 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
2275}
2276
2277static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
2278{
2279 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
2280
2281 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
2282}
2283
a5a36544 2284
64a8946b
AS		 2285static struct bpf_test tests[] = {
2286 {
2287 "TAX",
ece80490 2288 .u.insns = {
64a8946b
AS		 2289 BPF_STMT(BPF_LD | BPF_IMM, 1),
2290 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2291 BPF_STMT(BPF_LD | BPF_IMM, 2),
2292 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2293 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
2294 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2295 BPF_STMT(BPF_LD | BPF_LEN, 0),
2296 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2297 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
2298 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
2299 BPF_STMT(BPF_RET | BPF_A, 0)
2300 },
10f18e0b 2301 CLASSIC,
64a8946b
AS		 2302 { 10, 20, 30, 40, 50 },
2303 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
2304 },
9def624a
AS		 2305 {
2306 "TXA",
ece80490 2307 .u.insns = {
9def624a
AS		 2308 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2309 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2310 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2311 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
2312 },
10f18e0b 2313 CLASSIC,
9def624a
AS		 2314 { 10, 20, 30, 40, 50 },
2315 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
2316 },
2317 {
2318 "ADD_SUB_MUL_K",
ece80490 2319 .u.insns = {
9def624a
AS		 2320 BPF_STMT(BPF_LD | BPF_IMM, 1),
2321 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
2322 BPF_STMT(BPF_LDX | BPF_IMM, 3),
2323 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
2324 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
2325 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
2326 BPF_STMT(BPF_RET | BPF_A, 0)
2327 },
10f18e0b 2328 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 2329 { },
2330 { { 0, 0xfffffffd } }
2331 },
2332 {
6867b17b 2333 "DIV_MOD_KX",
ece80490 2334 .u.insns = {
9def624a
AS		 2335 BPF_STMT(BPF_LD | BPF_IMM, 8),
2336 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
2337 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2338 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2339 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
2340 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2341 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2342 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
6867b17b
DK		 2343 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2344 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2345 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
2346 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2347 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
2348 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
9def624a
AS		 2349 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2350 BPF_STMT(BPF_RET | BPF_A, 0)
2351 },
10f18e0b 2352 CLASSIC | FLAG_NO_DATA,
9def624a 2353 { },
6867b17b 2354 { { 0, 0x20000000 } }
9def624a
AS		 2355 },
2356 {
2357 "AND_OR_LSH_K",
ece80490 2358 .u.insns = {
9def624a
AS		 2359 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
2360 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
2361 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
2362 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2363 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
2364 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
2365 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2366 BPF_STMT(BPF_RET | BPF_A, 0)
2367 },
10f18e0b 2368 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 2369 { },
2370 { { 0, 0x800000ff }, { 1, 0x800000ff } },
2371 },
e9d94504
CG		 2372 {
2373 "LD_IMM_0",
2374 .u.insns = {
2375 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
2376 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
2377 BPF_STMT(BPF_RET | BPF_K, 0),
2378 BPF_STMT(BPF_RET | BPF_K, 1),
2379 },
2380 CLASSIC,
2381 { },
2382 { { 1, 1 } },
2383 },
9def624a
AS		 2384 {
2385 "LD_IND",
ece80490 2386 .u.insns = {
9def624a
AS		 2387 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2388 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
2389 BPF_STMT(BPF_RET | BPF_K, 1)
2390 },
10f18e0b 2391 CLASSIC,
9def624a
AS		 2392 { },
2393 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
2394 },
2395 {
2396 "LD_ABS",
ece80490 2397 .u.insns = {
9def624a
AS		 2398 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
2399 BPF_STMT(BPF_RET | BPF_K, 1)
2400 },
10f18e0b 2401 CLASSIC,
9def624a
AS		 2402 { },
2403 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
2404 },
2405 {
2406 "LD_ABS_LL",
ece80490 2407 .u.insns = {
9def624a
AS		 2408 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
2409 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2410 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
2411 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2412 BPF_STMT(BPF_RET | BPF_A, 0)
2413 },
10f18e0b 2414 CLASSIC,
9def624a
AS		 2415 { 1, 2, 3 },
2416 { { 1, 0 }, { 2, 3 } },
2417 },
2418 {
2419 "LD_IND_LL",
ece80490 2420 .u.insns = {
9def624a
AS		 2421 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
2422 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2423 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2424 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2425 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
2426 BPF_STMT(BPF_RET | BPF_A, 0)
2427 },
10f18e0b 2428 CLASSIC,
9def624a
AS		 2429 { 1, 2, 3, 0xff },
2430 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
2431 },
2432 {
2433 "LD_ABS_NET",
ece80490 2434 .u.insns = {
9def624a
AS		 2435 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
2436 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2437 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
2438 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2439 BPF_STMT(BPF_RET | BPF_A, 0)
2440 },
10f18e0b 2441 CLASSIC,
9def624a
AS		 2442 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
2443 { { 15, 0 }, { 16, 3 } },
2444 },
2445 {
2446 "LD_IND_NET",
ece80490 2447 .u.insns = {
9def624a
AS		 2448 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
2449 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2450 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2451 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2452 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
2453 BPF_STMT(BPF_RET | BPF_A, 0)
2454 },
10f18e0b 2455 CLASSIC,
9def624a
AS		 2456 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
2457 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
2458 },
2459 {
2460 "LD_PKTTYPE",
ece80490 2461 .u.insns = {
9def624a
AS		 2462 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2463 SKF_AD_OFF + SKF_AD_PKTTYPE),
2464 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2465 BPF_STMT(BPF_RET | BPF_K, 1),
2466 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2467 SKF_AD_OFF + SKF_AD_PKTTYPE),
2468 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2469 BPF_STMT(BPF_RET | BPF_K, 1),
2470 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2471 SKF_AD_OFF + SKF_AD_PKTTYPE),
2472 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
2473 BPF_STMT(BPF_RET | BPF_K, 1),
2474 BPF_STMT(BPF_RET | BPF_A, 0)
2475 },
10f18e0b 2476 CLASSIC,
9def624a
AS		 2477 { },
2478 { { 1, 3 }, { 10, 3 } },
2479 },
2480 {
2481 "LD_MARK",
ece80490 2482 .u.insns = {
9def624a
AS		 2483 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2484 SKF_AD_OFF + SKF_AD_MARK),
2485 BPF_STMT(BPF_RET | BPF_A, 0)
2486 },
10f18e0b 2487 CLASSIC,
9def624a
AS		 2488 { },
2489 { { 1, SKB_MARK}, { 10, SKB_MARK} },
2490 },
2491 {
2492 "LD_RXHASH",
ece80490 2493 .u.insns = {
9def624a
AS		 2494 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2495 SKF_AD_OFF + SKF_AD_RXHASH),
2496 BPF_STMT(BPF_RET | BPF_A, 0)
2497 },
10f18e0b 2498 CLASSIC,
9def624a
AS		 2499 { },
2500 { { 1, SKB_HASH}, { 10, SKB_HASH} },
2501 },
2502 {
2503 "LD_QUEUE",
ece80490 2504 .u.insns = {
9def624a
AS		 2505 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2506 SKF_AD_OFF + SKF_AD_QUEUE),
2507 BPF_STMT(BPF_RET | BPF_A, 0)
2508 },
10f18e0b 2509 CLASSIC,
9def624a
AS		 2510 { },
2511 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
2512 },
2513 {
2514 "LD_PROTOCOL",
ece80490 2515 .u.insns = {
9def624a
AS		 2516 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
2517 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
2518 BPF_STMT(BPF_RET | BPF_K, 0),
2519 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2520 SKF_AD_OFF + SKF_AD_PROTOCOL),
2521 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2522 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2523 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
2524 BPF_STMT(BPF_RET | BPF_K, 0),
2525 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2526 BPF_STMT(BPF_RET | BPF_A, 0)
2527 },
10f18e0b 2528 CLASSIC,
9def624a
AS		 2529 { 10, 20, 30 },
2530 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
2531 },
2532 {
2533 "LD_VLAN_TAG",
ece80490 2534 .u.insns = {
9def624a
AS		 2535 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2536 SKF_AD_OFF + SKF_AD_VLAN_TAG),
2537 BPF_STMT(BPF_RET | BPF_A, 0)
2538 },
10f18e0b 2539 CLASSIC,
9def624a
AS		 2540 { },
2541 {
0c4b2d37
MM		 2542 { 1, SKB_VLAN_TCI },
2543 { 10, SKB_VLAN_TCI }
9def624a
AS		 2544 },
2545 },
2546 {
2547 "LD_VLAN_TAG_PRESENT",
ece80490 2548 .u.insns = {
9def624a
AS		 2549 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2550 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
2551 BPF_STMT(BPF_RET | BPF_A, 0)
2552 },
10f18e0b 2553 CLASSIC,
9def624a
AS		 2554 { },
2555 {
0c4b2d37
MM		 2556 { 1, SKB_VLAN_PRESENT },
2557 { 10, SKB_VLAN_PRESENT }
9def624a
AS		 2558 },
2559 },
2560 {
2561 "LD_IFINDEX",
ece80490 2562 .u.insns = {
9def624a
AS		 2563 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2564 SKF_AD_OFF + SKF_AD_IFINDEX),
2565 BPF_STMT(BPF_RET | BPF_A, 0)
2566 },
10f18e0b 2567 CLASSIC,
9def624a
AS		 2568 { },
2569 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
2570 },
2571 {
2572 "LD_HATYPE",
ece80490 2573 .u.insns = {
9def624a
AS		 2574 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2575 SKF_AD_OFF + SKF_AD_HATYPE),
2576 BPF_STMT(BPF_RET | BPF_A, 0)
2577 },
10f18e0b 2578 CLASSIC,
9def624a
AS		 2579 { },
2580 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
2581 },
2582 {
2583 "LD_CPU",
ece80490 2584 .u.insns = {
9def624a
AS		 2585 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2586 SKF_AD_OFF + SKF_AD_CPU),
2587 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2588 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2589 SKF_AD_OFF + SKF_AD_CPU),
2590 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
2591 BPF_STMT(BPF_RET | BPF_A, 0)
2592 },
10f18e0b 2593 CLASSIC,
9def624a
AS		 2594 { },
2595 { { 1, 0 }, { 10, 0 } },
2596 },
2597 {
2598 "LD_NLATTR",
ece80490 2599 .u.insns = {
df6d0f98 2600 BPF_STMT(BPF_LDX | BPF_IMM, 2),
9def624a
AS		 2601 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2602 BPF_STMT(BPF_LDX | BPF_IMM, 3),
2603 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2604 SKF_AD_OFF + SKF_AD_NLATTR),
2605 BPF_STMT(BPF_RET | BPF_A, 0)
2606 },
10f18e0b 2607 CLASSIC,
df6d0f98
AS		 2608#ifdef __BIG_ENDIAN
2609 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
2610#else
2611 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
2612#endif
2613 { { 4, 0 }, { 20, 6 } },
9def624a
AS		 2614 },
2615 {
2616 "LD_NLATTR_NEST",
ece80490 2617 .u.insns = {
df6d0f98 2618 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2619 BPF_STMT(BPF_LDX | BPF_IMM, 3),
2620 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2621 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2622 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2623 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2624 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2625 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2626 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2627 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2628 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2629 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2630 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2631 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2632 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2633 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2634 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2635 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2636 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2637 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2638 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2639 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 2640 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 2641 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2642 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
2643 BPF_STMT(BPF_RET | BPF_A, 0)
2644 },
10f18e0b 2645 CLASSIC,
df6d0f98
AS		 2646#ifdef __BIG_ENDIAN
2647 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
2648#else
2649 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
2650#endif
2651 { { 4, 0 }, { 20, 10 } },
9def624a
AS		 2652 },
2653 {
2654 "LD_PAYLOAD_OFF",
ece80490 2655 .u.insns = {
9def624a
AS		 2656 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2657 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2658 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2659 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2660 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2661 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2662 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2663 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2664 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2665 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
2666 BPF_STMT(BPF_RET | BPF_A, 0)
2667 },
10f18e0b 2668 CLASSIC,
9def624a
AS		 2669 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
2670 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
2671 * id 9737, seq 1, length 64
2672 */
2673 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2674 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2675 0x08, 0x00,
2676 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
2677 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
2678 { { 30, 0 }, { 100, 42 } },
2679 },
2680 {
2681 "LD_ANC_XOR",
ece80490 2682 .u.insns = {
9def624a
AS		 2683 BPF_STMT(BPF_LD | BPF_IMM, 10),
2684 BPF_STMT(BPF_LDX | BPF_IMM, 300),
2685 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2686 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
2687 BPF_STMT(BPF_RET | BPF_A, 0)
2688 },
10f18e0b 2689 CLASSIC,
9def624a 2690 { },
09845436 2691 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
9def624a
AS		 2692 },
2693 {
2694 "SPILL_FILL",
ece80490 2695 .u.insns = {
9def624a
AS		 2696 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2697 BPF_STMT(BPF_LD | BPF_IMM, 2),
2698 BPF_STMT(BPF_ALU | BPF_RSH, 1),
2699 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2700 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
2701 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
2702 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
2703 BPF_STMT(BPF_STX, 15), /* M3 = len */
2704 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2705 BPF_STMT(BPF_LD | BPF_MEM, 2),
2706 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2707 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2708 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
2709 BPF_STMT(BPF_RET | BPF_A, 0)
2710 },
10f18e0b 2711 CLASSIC,
9def624a
AS		 2712 { },
2713 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
2714 },
2715 {
2716 "JEQ",
ece80490 2717 .u.insns = {
9def624a
AS		 2718 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2719 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2720 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
2721 BPF_STMT(BPF_RET | BPF_K, 1),
2722 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2723 },
10f18e0b 2724 CLASSIC,
9def624a
AS		 2725 { 3, 3, 3, 3, 3 },
2726 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
2727 },
2728 {
2729 "JGT",
ece80490 2730 .u.insns = {
9def624a
AS		 2731 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2732 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2733 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
2734 BPF_STMT(BPF_RET | BPF_K, 1),
2735 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2736 },
10f18e0b 2737 CLASSIC,
9def624a
AS		 2738 { 4, 4, 4, 3, 3 },
2739 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
2740 },
92b31a9a
DB		 2741 {
2742 "JGE (jt 0), test 1",
2743 .u.insns = {
2744 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2745 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2746 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
2747 BPF_STMT(BPF_RET | BPF_K, 1),
2748 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2749 },
2750 CLASSIC,
2751 { 4, 4, 4, 3, 3 },
2752 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
2753 },
2754 {
2755 "JGE (jt 0), test 2",
2756 .u.insns = {
2757 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2758 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
2759 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
2760 BPF_STMT(BPF_RET | BPF_K, 1),
2761 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2762 },
2763 CLASSIC,
2764 { 4, 4, 5, 3, 3 },
2765 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
2766 },
9def624a
AS		 2767 {
2768 "JGE",
ece80490 2769 .u.insns = {
9def624a
AS		 2770 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2771 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
2772 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
2773 BPF_STMT(BPF_RET | BPF_K, 10),
2774 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
2775 BPF_STMT(BPF_RET | BPF_K, 20),
2776 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
2777 BPF_STMT(BPF_RET | BPF_K, 30),
2778 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
2779 BPF_STMT(BPF_RET | BPF_K, 40),
2780 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2781 },
10f18e0b 2782 CLASSIC,
9def624a
AS		 2783 { 1, 2, 3, 4, 5 },
2784 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
2785 },
2786 {
2787 "JSET",
ece80490 2788 .u.insns = {
9def624a
AS		 2789 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2790 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
2791 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2792 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
2793 BPF_STMT(BPF_LDX | BPF_LEN, 0),
2794 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2795 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
2796 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2797 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
2798 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
2799 BPF_STMT(BPF_RET | BPF_K, 10),
2800 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
2801 BPF_STMT(BPF_RET | BPF_K, 20),
2802 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2803 BPF_STMT(BPF_RET | BPF_K, 30),
2804 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2805 BPF_STMT(BPF_RET | BPF_K, 30),
2806 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2807 BPF_STMT(BPF_RET | BPF_K, 30),
2808 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2809 BPF_STMT(BPF_RET | BPF_K, 30),
2810 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
2811 BPF_STMT(BPF_RET | BPF_K, 30),
2812 BPF_STMT(BPF_RET | BPF_K, MAX_K)
2813 },
10f18e0b 2814 CLASSIC,
9def624a
AS		 2815 { 0, 0xAA, 0x55, 1 },
2816 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
2817 },
64a8946b
AS		 2818 {
2819 "tcpdump port 22",
ece80490 2820 .u.insns = {
ce25b68b
DB		 2821 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
2822 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
2823 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
2824 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
2825 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
2826 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
2827 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
2828 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
2829 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
2830 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
2831 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
2832 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
2833 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
2834 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
2835 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
2836 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
2837 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
2838 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2839 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
2840 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
2841 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
2842 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
2843 BPF_STMT(BPF_RET | BPF_K, 0xffff),
2844 BPF_STMT(BPF_RET | BPF_K, 0),
64a8946b 2845 },
10f18e0b 2846 CLASSIC,
64a8946b
AS		 2847 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
2848 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
2849 * seq 1305692979:1305693027, ack 3650467037, win 65535,
2850 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
2851 */
2852 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
2853 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
2854 0x08, 0x00,
2855 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
2856 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
2857 0x0a, 0x01, 0x01, 0x95, /* ip src */
2858 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
2859 0xc2, 0x24,
2860 0x00, 0x16 /* dst port */ },
2861 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
2862 },
9def624a
AS		 2863 {
2864 "tcpdump complex",
ece80490 2865 .u.insns = {
9def624a
AS		 2866 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
2867 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
2868 * (len > 115 or len < 30000000000)' -d
2869 */
ce25b68b
DB		 2870 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
2871 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
2872 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
2873 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
2874 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
2875 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
2876 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
2877 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2878 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
2879 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
2880 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
2881 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
2882 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
2883 BPF_STMT(BPF_ST, 1),
2884 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
2885 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
2886 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
2887 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
2888 BPF_STMT(BPF_LD | BPF_MEM, 1),
2889 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
2890 BPF_STMT(BPF_ST, 5),
2891 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
2892 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
2893 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
2894 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
2895 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
2896 BPF_STMT(BPF_LD | BPF_MEM, 5),
2897 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
2898 BPF_STMT(BPF_LD | BPF_LEN, 0),
2899 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
2900 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
2901 BPF_STMT(BPF_RET | BPF_K, 0xffff),
2902 BPF_STMT(BPF_RET | BPF_K, 0),
9def624a 2903 },
10f18e0b 2904 CLASSIC,
9def624a
AS		 2905 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
2906 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
2907 0x08, 0x00,
2908 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
2909 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
2910 0x0a, 0x01, 0x01, 0x95, /* ip src */
2911 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
2912 0xc2, 0x24,
2913 0x00, 0x16 /* dst port */ },
2914 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
2915 },
2916 {
2917 "RET_A",
ece80490 2918 .u.insns = {
53b0fe36 2919 /* check that uninitialized X and A contain zeros */
9def624a
AS		 2920 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2921 BPF_STMT(BPF_RET | BPF_A, 0)
2922 },
10f18e0b
DB		 2923 CLASSIC,
2924 { },
9def624a
AS		 2925 { {1, 0}, {2, 0} },
2926 },
2927 {
2928 "INT: ADD trivial",
ece80490 2929 .u.insns_int = {
9def624a
AS		 2930 BPF_ALU64_IMM(BPF_MOV, R1, 1),
2931 BPF_ALU64_IMM(BPF_ADD, R1, 2),
2932 BPF_ALU64_IMM(BPF_MOV, R2, 3),
2933 BPF_ALU64_REG(BPF_SUB, R1, R2),
2934 BPF_ALU64_IMM(BPF_ADD, R1, -1),
2935 BPF_ALU64_IMM(BPF_MUL, R1, 3),
2936 BPF_ALU64_REG(BPF_MOV, R0, R1),
2937 BPF_EXIT_INSN(),
2938 },
10f18e0b 2939 INTERNAL,
9def624a
AS		 2940 { },
2941 { { 0, 0xfffffffd } }
2942 },
2943 {
2944 "INT: MUL_X",
ece80490 2945 .u.insns_int = {
9def624a
AS		 2946 BPF_ALU64_IMM(BPF_MOV, R0, -1),
2947 BPF_ALU64_IMM(BPF_MOV, R1, -1),
2948 BPF_ALU64_IMM(BPF_MOV, R2, 3),
2949 BPF_ALU64_REG(BPF_MUL, R1, R2),
2950 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
2951 BPF_EXIT_INSN(),
2952 BPF_ALU64_IMM(BPF_MOV, R0, 1),
2953 BPF_EXIT_INSN(),
2954 },
10f18e0b 2955 INTERNAL,
9def624a
AS		 2956 { },
2957 { { 0, 1 } }
2958 },
2959 {
2960 "INT: MUL_X2",
ece80490 2961 .u.insns_int = {
9def624a
AS		 2962 BPF_ALU32_IMM(BPF_MOV, R0, -1),
2963 BPF_ALU32_IMM(BPF_MOV, R1, -1),
2964 BPF_ALU32_IMM(BPF_MOV, R2, 3),
2965 BPF_ALU64_REG(BPF_MUL, R1, R2),
2966 BPF_ALU64_IMM(BPF_RSH, R1, 8),
2967 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
2968 BPF_EXIT_INSN(),
2969 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2970 BPF_EXIT_INSN(),
2971 },
10f18e0b 2972 INTERNAL,
9def624a
AS		 2973 { },
2974 { { 0, 1 } }
2975 },
2976 {
2977 "INT: MUL32_X",
ece80490 2978 .u.insns_int = {
9def624a
AS		 2979 BPF_ALU32_IMM(BPF_MOV, R0, -1),
2980 BPF_ALU64_IMM(BPF_MOV, R1, -1),
2981 BPF_ALU32_IMM(BPF_MOV, R2, 3),
2982 BPF_ALU32_REG(BPF_MUL, R1, R2),
2983 BPF_ALU64_IMM(BPF_RSH, R1, 8),
2984 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
2985 BPF_EXIT_INSN(),
2986 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2987 BPF_EXIT_INSN(),
2988 },
10f18e0b 2989 INTERNAL,
9def624a
AS		 2990 { },
2991 { { 0, 1 } }
2992 },
2993 {
2994 /* Have to test all register combinations, since
2995 * JITing of different registers will produce
2996 * different asm code.
2997 */
2998 "INT: ADD 64-bit",
ece80490 2999 .u.insns_int = {
9def624a
AS		 3000 BPF_ALU64_IMM(BPF_MOV, R0, 0),
3001 BPF_ALU64_IMM(BPF_MOV, R1, 1),
3002 BPF_ALU64_IMM(BPF_MOV, R2, 2),
3003 BPF_ALU64_IMM(BPF_MOV, R3, 3),
3004 BPF_ALU64_IMM(BPF_MOV, R4, 4),
3005 BPF_ALU64_IMM(BPF_MOV, R5, 5),
3006 BPF_ALU64_IMM(BPF_MOV, R6, 6),
3007 BPF_ALU64_IMM(BPF_MOV, R7, 7),
3008 BPF_ALU64_IMM(BPF_MOV, R8, 8),
3009 BPF_ALU64_IMM(BPF_MOV, R9, 9),
3010 BPF_ALU64_IMM(BPF_ADD, R0, 20),
3011 BPF_ALU64_IMM(BPF_ADD, R1, 20),
3012 BPF_ALU64_IMM(BPF_ADD, R2, 20),
3013 BPF_ALU64_IMM(BPF_ADD, R3, 20),
3014 BPF_ALU64_IMM(BPF_ADD, R4, 20),
3015 BPF_ALU64_IMM(BPF_ADD, R5, 20),
3016 BPF_ALU64_IMM(BPF_ADD, R6, 20),
3017 BPF_ALU64_IMM(BPF_ADD, R7, 20),
3018 BPF_ALU64_IMM(BPF_ADD, R8, 20),
3019 BPF_ALU64_IMM(BPF_ADD, R9, 20),
3020 BPF_ALU64_IMM(BPF_SUB, R0, 10),
3021 BPF_ALU64_IMM(BPF_SUB, R1, 10),
3022 BPF_ALU64_IMM(BPF_SUB, R2, 10),
3023 BPF_ALU64_IMM(BPF_SUB, R3, 10),
3024 BPF_ALU64_IMM(BPF_SUB, R4, 10),
3025 BPF_ALU64_IMM(BPF_SUB, R5, 10),
3026 BPF_ALU64_IMM(BPF_SUB, R6, 10),
3027 BPF_ALU64_IMM(BPF_SUB, R7, 10),
3028 BPF_ALU64_IMM(BPF_SUB, R8, 10),
3029 BPF_ALU64_IMM(BPF_SUB, R9, 10),
3030 BPF_ALU64_REG(BPF_ADD, R0, R0),
3031 BPF_ALU64_REG(BPF_ADD, R0, R1),
3032 BPF_ALU64_REG(BPF_ADD, R0, R2),
3033 BPF_ALU64_REG(BPF_ADD, R0, R3),
3034 BPF_ALU64_REG(BPF_ADD, R0, R4),
3035 BPF_ALU64_REG(BPF_ADD, R0, R5),
3036 BPF_ALU64_REG(BPF_ADD, R0, R6),
3037 BPF_ALU64_REG(BPF_ADD, R0, R7),
3038 BPF_ALU64_REG(BPF_ADD, R0, R8),
3039 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3040 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3041 BPF_EXIT_INSN(),
3042 BPF_ALU64_REG(BPF_ADD, R1, R0),
3043 BPF_ALU64_REG(BPF_ADD, R1, R1),
3044 BPF_ALU64_REG(BPF_ADD, R1, R2),
3045 BPF_ALU64_REG(BPF_ADD, R1, R3),
3046 BPF_ALU64_REG(BPF_ADD, R1, R4),
3047 BPF_ALU64_REG(BPF_ADD, R1, R5),
3048 BPF_ALU64_REG(BPF_ADD, R1, R6),
3049 BPF_ALU64_REG(BPF_ADD, R1, R7),
3050 BPF_ALU64_REG(BPF_ADD, R1, R8),
3051 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3052 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3053 BPF_EXIT_INSN(),
3054 BPF_ALU64_REG(BPF_ADD, R2, R0),
3055 BPF_ALU64_REG(BPF_ADD, R2, R1),
3056 BPF_ALU64_REG(BPF_ADD, R2, R2),
3057 BPF_ALU64_REG(BPF_ADD, R2, R3),
3058 BPF_ALU64_REG(BPF_ADD, R2, R4),
3059 BPF_ALU64_REG(BPF_ADD, R2, R5),
3060 BPF_ALU64_REG(BPF_ADD, R2, R6),
3061 BPF_ALU64_REG(BPF_ADD, R2, R7),
3062 BPF_ALU64_REG(BPF_ADD, R2, R8),
3063 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3064 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3065 BPF_EXIT_INSN(),
3066 BPF_ALU64_REG(BPF_ADD, R3, R0),
3067 BPF_ALU64_REG(BPF_ADD, R3, R1),
3068 BPF_ALU64_REG(BPF_ADD, R3, R2),
3069 BPF_ALU64_REG(BPF_ADD, R3, R3),
3070 BPF_ALU64_REG(BPF_ADD, R3, R4),
3071 BPF_ALU64_REG(BPF_ADD, R3, R5),
3072 BPF_ALU64_REG(BPF_ADD, R3, R6),
3073 BPF_ALU64_REG(BPF_ADD, R3, R7),
3074 BPF_ALU64_REG(BPF_ADD, R3, R8),
3075 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3076 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3077 BPF_EXIT_INSN(),
3078 BPF_ALU64_REG(BPF_ADD, R4, R0),
3079 BPF_ALU64_REG(BPF_ADD, R4, R1),
3080 BPF_ALU64_REG(BPF_ADD, R4, R2),
3081 BPF_ALU64_REG(BPF_ADD, R4, R3),
3082 BPF_ALU64_REG(BPF_ADD, R4, R4),
3083 BPF_ALU64_REG(BPF_ADD, R4, R5),
3084 BPF_ALU64_REG(BPF_ADD, R4, R6),
3085 BPF_ALU64_REG(BPF_ADD, R4, R7),
3086 BPF_ALU64_REG(BPF_ADD, R4, R8),
3087 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3088 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3089 BPF_EXIT_INSN(),
3090 BPF_ALU64_REG(BPF_ADD, R5, R0),
3091 BPF_ALU64_REG(BPF_ADD, R5, R1),
3092 BPF_ALU64_REG(BPF_ADD, R5, R2),
3093 BPF_ALU64_REG(BPF_ADD, R5, R3),
3094 BPF_ALU64_REG(BPF_ADD, R5, R4),
3095 BPF_ALU64_REG(BPF_ADD, R5, R5),
3096 BPF_ALU64_REG(BPF_ADD, R5, R6),
3097 BPF_ALU64_REG(BPF_ADD, R5, R7),
3098 BPF_ALU64_REG(BPF_ADD, R5, R8),
3099 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3100 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3101 BPF_EXIT_INSN(),
3102 BPF_ALU64_REG(BPF_ADD, R6, R0),
3103 BPF_ALU64_REG(BPF_ADD, R6, R1),
3104 BPF_ALU64_REG(BPF_ADD, R6, R2),
3105 BPF_ALU64_REG(BPF_ADD, R6, R3),
3106 BPF_ALU64_REG(BPF_ADD, R6, R4),
3107 BPF_ALU64_REG(BPF_ADD, R6, R5),
3108 BPF_ALU64_REG(BPF_ADD, R6, R6),
3109 BPF_ALU64_REG(BPF_ADD, R6, R7),
3110 BPF_ALU64_REG(BPF_ADD, R6, R8),
3111 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3112 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3113 BPF_EXIT_INSN(),
3114 BPF_ALU64_REG(BPF_ADD, R7, R0),
3115 BPF_ALU64_REG(BPF_ADD, R7, R1),
3116 BPF_ALU64_REG(BPF_ADD, R7, R2),
3117 BPF_ALU64_REG(BPF_ADD, R7, R3),
3118 BPF_ALU64_REG(BPF_ADD, R7, R4),
3119 BPF_ALU64_REG(BPF_ADD, R7, R5),
3120 BPF_ALU64_REG(BPF_ADD, R7, R6),
3121 BPF_ALU64_REG(BPF_ADD, R7, R7),
3122 BPF_ALU64_REG(BPF_ADD, R7, R8),
3123 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3124 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3125 BPF_EXIT_INSN(),
3126 BPF_ALU64_REG(BPF_ADD, R8, R0),
3127 BPF_ALU64_REG(BPF_ADD, R8, R1),
3128 BPF_ALU64_REG(BPF_ADD, R8, R2),
3129 BPF_ALU64_REG(BPF_ADD, R8, R3),
3130 BPF_ALU64_REG(BPF_ADD, R8, R4),
3131 BPF_ALU64_REG(BPF_ADD, R8, R5),
3132 BPF_ALU64_REG(BPF_ADD, R8, R6),
3133 BPF_ALU64_REG(BPF_ADD, R8, R7),
3134 BPF_ALU64_REG(BPF_ADD, R8, R8),
3135 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3136 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3137 BPF_EXIT_INSN(),
3138 BPF_ALU64_REG(BPF_ADD, R9, R0),
3139 BPF_ALU64_REG(BPF_ADD, R9, R1),
3140 BPF_ALU64_REG(BPF_ADD, R9, R2),
3141 BPF_ALU64_REG(BPF_ADD, R9, R3),
3142 BPF_ALU64_REG(BPF_ADD, R9, R4),
3143 BPF_ALU64_REG(BPF_ADD, R9, R5),
3144 BPF_ALU64_REG(BPF_ADD, R9, R6),
3145 BPF_ALU64_REG(BPF_ADD, R9, R7),
3146 BPF_ALU64_REG(BPF_ADD, R9, R8),
3147 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3148 BPF_ALU64_REG(BPF_MOV, R0, R9),
3149 BPF_EXIT_INSN(),
3150 },
10f18e0b 3151 INTERNAL,
9def624a
AS		 3152 { },
3153 { { 0, 2957380 } }
3154 },
3155 {
3156 "INT: ADD 32-bit",
ece80490 3157 .u.insns_int = {
9def624a
AS		 3158 BPF_ALU32_IMM(BPF_MOV, R0, 20),
3159 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3160 BPF_ALU32_IMM(BPF_MOV, R2, 2),
3161 BPF_ALU32_IMM(BPF_MOV, R3, 3),
3162 BPF_ALU32_IMM(BPF_MOV, R4, 4),
3163 BPF_ALU32_IMM(BPF_MOV, R5, 5),
3164 BPF_ALU32_IMM(BPF_MOV, R6, 6),
3165 BPF_ALU32_IMM(BPF_MOV, R7, 7),
3166 BPF_ALU32_IMM(BPF_MOV, R8, 8),
3167 BPF_ALU32_IMM(BPF_MOV, R9, 9),
3168 BPF_ALU64_IMM(BPF_ADD, R1, 10),
3169 BPF_ALU64_IMM(BPF_ADD, R2, 10),
3170 BPF_ALU64_IMM(BPF_ADD, R3, 10),
3171 BPF_ALU64_IMM(BPF_ADD, R4, 10),
3172 BPF_ALU64_IMM(BPF_ADD, R5, 10),
3173 BPF_ALU64_IMM(BPF_ADD, R6, 10),
3174 BPF_ALU64_IMM(BPF_ADD, R7, 10),
3175 BPF_ALU64_IMM(BPF_ADD, R8, 10),
3176 BPF_ALU64_IMM(BPF_ADD, R9, 10),
3177 BPF_ALU32_REG(BPF_ADD, R0, R1),
3178 BPF_ALU32_REG(BPF_ADD, R0, R2),
3179 BPF_ALU32_REG(BPF_ADD, R0, R3),
3180 BPF_ALU32_REG(BPF_ADD, R0, R4),
3181 BPF_ALU32_REG(BPF_ADD, R0, R5),
3182 BPF_ALU32_REG(BPF_ADD, R0, R6),
3183 BPF_ALU32_REG(BPF_ADD, R0, R7),
3184 BPF_ALU32_REG(BPF_ADD, R0, R8),
3185 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
3186 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
3187 BPF_EXIT_INSN(),
3188 BPF_ALU32_REG(BPF_ADD, R1, R0),
3189 BPF_ALU32_REG(BPF_ADD, R1, R1),
3190 BPF_ALU32_REG(BPF_ADD, R1, R2),
3191 BPF_ALU32_REG(BPF_ADD, R1, R3),
3192 BPF_ALU32_REG(BPF_ADD, R1, R4),
3193 BPF_ALU32_REG(BPF_ADD, R1, R5),
3194 BPF_ALU32_REG(BPF_ADD, R1, R6),
3195 BPF_ALU32_REG(BPF_ADD, R1, R7),
3196 BPF_ALU32_REG(BPF_ADD, R1, R8),
3197 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
3198 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
3199 BPF_EXIT_INSN(),
3200 BPF_ALU32_REG(BPF_ADD, R2, R0),
3201 BPF_ALU32_REG(BPF_ADD, R2, R1),
3202 BPF_ALU32_REG(BPF_ADD, R2, R2),
3203 BPF_ALU32_REG(BPF_ADD, R2, R3),
3204 BPF_ALU32_REG(BPF_ADD, R2, R4),
3205 BPF_ALU32_REG(BPF_ADD, R2, R5),
3206 BPF_ALU32_REG(BPF_ADD, R2, R6),
3207 BPF_ALU32_REG(BPF_ADD, R2, R7),
3208 BPF_ALU32_REG(BPF_ADD, R2, R8),
3209 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
3210 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
3211 BPF_EXIT_INSN(),
3212 BPF_ALU32_REG(BPF_ADD, R3, R0),
3213 BPF_ALU32_REG(BPF_ADD, R3, R1),
3214 BPF_ALU32_REG(BPF_ADD, R3, R2),
3215 BPF_ALU32_REG(BPF_ADD, R3, R3),
3216 BPF_ALU32_REG(BPF_ADD, R3, R4),
3217 BPF_ALU32_REG(BPF_ADD, R3, R5),
3218 BPF_ALU32_REG(BPF_ADD, R3, R6),
3219 BPF_ALU32_REG(BPF_ADD, R3, R7),
3220 BPF_ALU32_REG(BPF_ADD, R3, R8),
3221 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
3222 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
3223 BPF_EXIT_INSN(),
3224 BPF_ALU32_REG(BPF_ADD, R4, R0),
3225 BPF_ALU32_REG(BPF_ADD, R4, R1),
3226 BPF_ALU32_REG(BPF_ADD, R4, R2),
3227 BPF_ALU32_REG(BPF_ADD, R4, R3),
3228 BPF_ALU32_REG(BPF_ADD, R4, R4),
3229 BPF_ALU32_REG(BPF_ADD, R4, R5),
3230 BPF_ALU32_REG(BPF_ADD, R4, R6),
3231 BPF_ALU32_REG(BPF_ADD, R4, R7),
3232 BPF_ALU32_REG(BPF_ADD, R4, R8),
3233 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
3234 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
3235 BPF_EXIT_INSN(),
3236 BPF_ALU32_REG(BPF_ADD, R5, R0),
3237 BPF_ALU32_REG(BPF_ADD, R5, R1),
3238 BPF_ALU32_REG(BPF_ADD, R5, R2),
3239 BPF_ALU32_REG(BPF_ADD, R5, R3),
3240 BPF_ALU32_REG(BPF_ADD, R5, R4),
3241 BPF_ALU32_REG(BPF_ADD, R5, R5),
3242 BPF_ALU32_REG(BPF_ADD, R5, R6),
3243 BPF_ALU32_REG(BPF_ADD, R5, R7),
3244 BPF_ALU32_REG(BPF_ADD, R5, R8),
3245 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
3246 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
3247 BPF_EXIT_INSN(),
3248 BPF_ALU32_REG(BPF_ADD, R6, R0),
3249 BPF_ALU32_REG(BPF_ADD, R6, R1),
3250 BPF_ALU32_REG(BPF_ADD, R6, R2),
3251 BPF_ALU32_REG(BPF_ADD, R6, R3),
3252 BPF_ALU32_REG(BPF_ADD, R6, R4),
3253 BPF_ALU32_REG(BPF_ADD, R6, R5),
3254 BPF_ALU32_REG(BPF_ADD, R6, R6),
3255 BPF_ALU32_REG(BPF_ADD, R6, R7),
3256 BPF_ALU32_REG(BPF_ADD, R6, R8),
3257 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
3258 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
3259 BPF_EXIT_INSN(),
3260 BPF_ALU32_REG(BPF_ADD, R7, R0),
3261 BPF_ALU32_REG(BPF_ADD, R7, R1),
3262 BPF_ALU32_REG(BPF_ADD, R7, R2),
3263 BPF_ALU32_REG(BPF_ADD, R7, R3),
3264 BPF_ALU32_REG(BPF_ADD, R7, R4),
3265 BPF_ALU32_REG(BPF_ADD, R7, R5),
3266 BPF_ALU32_REG(BPF_ADD, R7, R6),
3267 BPF_ALU32_REG(BPF_ADD, R7, R7),
3268 BPF_ALU32_REG(BPF_ADD, R7, R8),
3269 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
3270 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
3271 BPF_EXIT_INSN(),
3272 BPF_ALU32_REG(BPF_ADD, R8, R0),
3273 BPF_ALU32_REG(BPF_ADD, R8, R1),
3274 BPF_ALU32_REG(BPF_ADD, R8, R2),
3275 BPF_ALU32_REG(BPF_ADD, R8, R3),
3276 BPF_ALU32_REG(BPF_ADD, R8, R4),
3277 BPF_ALU32_REG(BPF_ADD, R8, R5),
3278 BPF_ALU32_REG(BPF_ADD, R8, R6),
3279 BPF_ALU32_REG(BPF_ADD, R8, R7),
3280 BPF_ALU32_REG(BPF_ADD, R8, R8),
3281 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
3282 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
3283 BPF_EXIT_INSN(),
3284 BPF_ALU32_REG(BPF_ADD, R9, R0),
3285 BPF_ALU32_REG(BPF_ADD, R9, R1),
3286 BPF_ALU32_REG(BPF_ADD, R9, R2),
3287 BPF_ALU32_REG(BPF_ADD, R9, R3),
3288 BPF_ALU32_REG(BPF_ADD, R9, R4),
3289 BPF_ALU32_REG(BPF_ADD, R9, R5),
3290 BPF_ALU32_REG(BPF_ADD, R9, R6),
3291 BPF_ALU32_REG(BPF_ADD, R9, R7),
3292 BPF_ALU32_REG(BPF_ADD, R9, R8),
3293 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
3294 BPF_ALU32_REG(BPF_MOV, R0, R9),
3295 BPF_EXIT_INSN(),
3296 },
10f18e0b 3297 INTERNAL,
9def624a
AS		 3298 { },
3299 { { 0, 2957380 } }
3300 },
3301 { /* Mainly checking JIT here. */
3302 "INT: SUB",
ece80490 3303 .u.insns_int = {
9def624a
AS		 3304 BPF_ALU64_IMM(BPF_MOV, R0, 0),
3305 BPF_ALU64_IMM(BPF_MOV, R1, 1),
3306 BPF_ALU64_IMM(BPF_MOV, R2, 2),
3307 BPF_ALU64_IMM(BPF_MOV, R3, 3),
3308 BPF_ALU64_IMM(BPF_MOV, R4, 4),
3309 BPF_ALU64_IMM(BPF_MOV, R5, 5),
3310 BPF_ALU64_IMM(BPF_MOV, R6, 6),
3311 BPF_ALU64_IMM(BPF_MOV, R7, 7),
3312 BPF_ALU64_IMM(BPF_MOV, R8, 8),
3313 BPF_ALU64_IMM(BPF_MOV, R9, 9),
3314 BPF_ALU64_REG(BPF_SUB, R0, R0),
3315 BPF_ALU64_REG(BPF_SUB, R0, R1),
3316 BPF_ALU64_REG(BPF_SUB, R0, R2),
3317 BPF_ALU64_REG(BPF_SUB, R0, R3),
3318 BPF_ALU64_REG(BPF_SUB, R0, R4),
3319 BPF_ALU64_REG(BPF_SUB, R0, R5),
3320 BPF_ALU64_REG(BPF_SUB, R0, R6),
3321 BPF_ALU64_REG(BPF_SUB, R0, R7),
3322 BPF_ALU64_REG(BPF_SUB, R0, R8),
3323 BPF_ALU64_REG(BPF_SUB, R0, R9),
3324 BPF_ALU64_IMM(BPF_SUB, R0, 10),
3325 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
3326 BPF_EXIT_INSN(),
3327 BPF_ALU64_REG(BPF_SUB, R1, R0),
3328 BPF_ALU64_REG(BPF_SUB, R1, R2),
3329 BPF_ALU64_REG(BPF_SUB, R1, R3),
3330 BPF_ALU64_REG(BPF_SUB, R1, R4),
3331 BPF_ALU64_REG(BPF_SUB, R1, R5),
3332 BPF_ALU64_REG(BPF_SUB, R1, R6),
3333 BPF_ALU64_REG(BPF_SUB, R1, R7),
3334 BPF_ALU64_REG(BPF_SUB, R1, R8),
3335 BPF_ALU64_REG(BPF_SUB, R1, R9),
3336 BPF_ALU64_IMM(BPF_SUB, R1, 10),
3337 BPF_ALU64_REG(BPF_SUB, R2, R0),
3338 BPF_ALU64_REG(BPF_SUB, R2, R1),
3339 BPF_ALU64_REG(BPF_SUB, R2, R3),
3340 BPF_ALU64_REG(BPF_SUB, R2, R4),
3341 BPF_ALU64_REG(BPF_SUB, R2, R5),
3342 BPF_ALU64_REG(BPF_SUB, R2, R6),
3343 BPF_ALU64_REG(BPF_SUB, R2, R7),
3344 BPF_ALU64_REG(BPF_SUB, R2, R8),
3345 BPF_ALU64_REG(BPF_SUB, R2, R9),
3346 BPF_ALU64_IMM(BPF_SUB, R2, 10),
3347 BPF_ALU64_REG(BPF_SUB, R3, R0),
3348 BPF_ALU64_REG(BPF_SUB, R3, R1),
3349 BPF_ALU64_REG(BPF_SUB, R3, R2),
3350 BPF_ALU64_REG(BPF_SUB, R3, R4),
3351 BPF_ALU64_REG(BPF_SUB, R3, R5),
3352 BPF_ALU64_REG(BPF_SUB, R3, R6),
3353 BPF_ALU64_REG(BPF_SUB, R3, R7),
3354 BPF_ALU64_REG(BPF_SUB, R3, R8),
3355 BPF_ALU64_REG(BPF_SUB, R3, R9),
3356 BPF_ALU64_IMM(BPF_SUB, R3, 10),
3357 BPF_ALU64_REG(BPF_SUB, R4, R0),
3358 BPF_ALU64_REG(BPF_SUB, R4, R1),
3359 BPF_ALU64_REG(BPF_SUB, R4, R2),
3360 BPF_ALU64_REG(BPF_SUB, R4, R3),
3361 BPF_ALU64_REG(BPF_SUB, R4, R5),
3362 BPF_ALU64_REG(BPF_SUB, R4, R6),
3363 BPF_ALU64_REG(BPF_SUB, R4, R7),
3364 BPF_ALU64_REG(BPF_SUB, R4, R8),
3365 BPF_ALU64_REG(BPF_SUB, R4, R9),
3366 BPF_ALU64_IMM(BPF_SUB, R4, 10),
3367 BPF_ALU64_REG(BPF_SUB, R5, R0),
3368 BPF_ALU64_REG(BPF_SUB, R5, R1),
3369 BPF_ALU64_REG(BPF_SUB, R5, R2),
3370 BPF_ALU64_REG(BPF_SUB, R5, R3),
3371 BPF_ALU64_REG(BPF_SUB, R5, R4),
3372 BPF_ALU64_REG(BPF_SUB, R5, R6),
3373 BPF_ALU64_REG(BPF_SUB, R5, R7),
3374 BPF_ALU64_REG(BPF_SUB, R5, R8),
3375 BPF_ALU64_REG(BPF_SUB, R5, R9),
3376 BPF_ALU64_IMM(BPF_SUB, R5, 10),
3377 BPF_ALU64_REG(BPF_SUB, R6, R0),
3378 BPF_ALU64_REG(BPF_SUB, R6, R1),
3379 BPF_ALU64_REG(BPF_SUB, R6, R2),
3380 BPF_ALU64_REG(BPF_SUB, R6, R3),
3381 BPF_ALU64_REG(BPF_SUB, R6, R4),
3382 BPF_ALU64_REG(BPF_SUB, R6, R5),
3383 BPF_ALU64_REG(BPF_SUB, R6, R7),
3384 BPF_ALU64_REG(BPF_SUB, R6, R8),
3385 BPF_ALU64_REG(BPF_SUB, R6, R9),
3386 BPF_ALU64_IMM(BPF_SUB, R6, 10),
3387 BPF_ALU64_REG(BPF_SUB, R7, R0),
3388 BPF_ALU64_REG(BPF_SUB, R7, R1),
3389 BPF_ALU64_REG(BPF_SUB, R7, R2),
3390 BPF_ALU64_REG(BPF_SUB, R7, R3),
3391 BPF_ALU64_REG(BPF_SUB, R7, R4),
3392 BPF_ALU64_REG(BPF_SUB, R7, R5),
3393 BPF_ALU64_REG(BPF_SUB, R7, R6),
3394 BPF_ALU64_REG(BPF_SUB, R7, R8),
3395 BPF_ALU64_REG(BPF_SUB, R7, R9),
3396 BPF_ALU64_IMM(BPF_SUB, R7, 10),
3397 BPF_ALU64_REG(BPF_SUB, R8, R0),
3398 BPF_ALU64_REG(BPF_SUB, R8, R1),
3399 BPF_ALU64_REG(BPF_SUB, R8, R2),
3400 BPF_ALU64_REG(BPF_SUB, R8, R3),
3401 BPF_ALU64_REG(BPF_SUB, R8, R4),
3402 BPF_ALU64_REG(BPF_SUB, R8, R5),
3403 BPF_ALU64_REG(BPF_SUB, R8, R6),
3404 BPF_ALU64_REG(BPF_SUB, R8, R7),
3405 BPF_ALU64_REG(BPF_SUB, R8, R9),
3406 BPF_ALU64_IMM(BPF_SUB, R8, 10),
3407 BPF_ALU64_REG(BPF_SUB, R9, R0),
3408 BPF_ALU64_REG(BPF_SUB, R9, R1),
3409 BPF_ALU64_REG(BPF_SUB, R9, R2),
3410 BPF_ALU64_REG(BPF_SUB, R9, R3),
3411 BPF_ALU64_REG(BPF_SUB, R9, R4),
3412 BPF_ALU64_REG(BPF_SUB, R9, R5),
3413 BPF_ALU64_REG(BPF_SUB, R9, R6),
3414 BPF_ALU64_REG(BPF_SUB, R9, R7),
3415 BPF_ALU64_REG(BPF_SUB, R9, R8),
3416 BPF_ALU64_IMM(BPF_SUB, R9, 10),
3417 BPF_ALU64_IMM(BPF_SUB, R0, 10),
3418 BPF_ALU64_IMM(BPF_NEG, R0, 0),
3419 BPF_ALU64_REG(BPF_SUB, R0, R1),
3420 BPF_ALU64_REG(BPF_SUB, R0, R2),
3421 BPF_ALU64_REG(BPF_SUB, R0, R3),
3422 BPF_ALU64_REG(BPF_SUB, R0, R4),
3423 BPF_ALU64_REG(BPF_SUB, R0, R5),
3424 BPF_ALU64_REG(BPF_SUB, R0, R6),
3425 BPF_ALU64_REG(BPF_SUB, R0, R7),
3426 BPF_ALU64_REG(BPF_SUB, R0, R8),
3427 BPF_ALU64_REG(BPF_SUB, R0, R9),
3428 BPF_EXIT_INSN(),
3429 },
10f18e0b 3430 INTERNAL,
9def624a
AS		 3431 { },
3432 { { 0, 11 } }
3433 },
3434 { /* Mainly checking JIT here. */
3435 "INT: XOR",
ece80490 3436 .u.insns_int = {
9def624a
AS		 3437 BPF_ALU64_REG(BPF_SUB, R0, R0),
3438 BPF_ALU64_REG(BPF_XOR, R1, R1),
3439 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
3440 BPF_EXIT_INSN(),
3441 BPF_ALU64_IMM(BPF_MOV, R0, 10),
3442 BPF_ALU64_IMM(BPF_MOV, R1, -1),
3443 BPF_ALU64_REG(BPF_SUB, R1, R1),
3444 BPF_ALU64_REG(BPF_XOR, R2, R2),
3445 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
3446 BPF_EXIT_INSN(),
3447 BPF_ALU64_REG(BPF_SUB, R2, R2),
3448 BPF_ALU64_REG(BPF_XOR, R3, R3),
3449 BPF_ALU64_IMM(BPF_MOV, R0, 10),
3450 BPF_ALU64_IMM(BPF_MOV, R1, -1),
3451 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
3452 BPF_EXIT_INSN(),
3453 BPF_ALU64_REG(BPF_SUB, R3, R3),
3454 BPF_ALU64_REG(BPF_XOR, R4, R4),
3455 BPF_ALU64_IMM(BPF_MOV, R2, 1),
3456 BPF_ALU64_IMM(BPF_MOV, R5, -1),
3457 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
3458 BPF_EXIT_INSN(),
3459 BPF_ALU64_REG(BPF_SUB, R4, R4),
3460 BPF_ALU64_REG(BPF_XOR, R5, R5),
3461 BPF_ALU64_IMM(BPF_MOV, R3, 1),
3462 BPF_ALU64_IMM(BPF_MOV, R7, -1),
3463 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
3464 BPF_EXIT_INSN(),
3465 BPF_ALU64_IMM(BPF_MOV, R5, 1),
3466 BPF_ALU64_REG(BPF_SUB, R5, R5),
3467 BPF_ALU64_REG(BPF_XOR, R6, R6),
3468 BPF_ALU64_IMM(BPF_MOV, R1, 1),
3469 BPF_ALU64_IMM(BPF_MOV, R8, -1),
3470 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
3471 BPF_EXIT_INSN(),
3472 BPF_ALU64_REG(BPF_SUB, R6, R6),
3473 BPF_ALU64_REG(BPF_XOR, R7, R7),
3474 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
3475 BPF_EXIT_INSN(),
3476 BPF_ALU64_REG(BPF_SUB, R7, R7),
3477 BPF_ALU64_REG(BPF_XOR, R8, R8),
3478 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
3479 BPF_EXIT_INSN(),
3480 BPF_ALU64_REG(BPF_SUB, R8, R8),
3481 BPF_ALU64_REG(BPF_XOR, R9, R9),
3482 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
3483 BPF_EXIT_INSN(),
3484 BPF_ALU64_REG(BPF_SUB, R9, R9),
3485 BPF_ALU64_REG(BPF_XOR, R0, R0),
3486 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
3487 BPF_EXIT_INSN(),
3488 BPF_ALU64_REG(BPF_SUB, R1, R1),
3489 BPF_ALU64_REG(BPF_XOR, R0, R0),
3490 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
3491 BPF_ALU64_IMM(BPF_MOV, R0, 0),
3492 BPF_EXIT_INSN(),
3493 BPF_ALU64_IMM(BPF_MOV, R0, 1),
3494 BPF_EXIT_INSN(),
3495 },
10f18e0b 3496 INTERNAL,
9def624a
AS		 3497 { },
3498 { { 0, 1 } }
3499 },
3500 { /* Mainly checking JIT here. */
3501 "INT: MUL",
ece80490 3502 .u.insns_int = {
9def624a
AS		 3503 BPF_ALU64_IMM(BPF_MOV, R0, 11),
3504 BPF_ALU64_IMM(BPF_MOV, R1, 1),
3505 BPF_ALU64_IMM(BPF_MOV, R2, 2),
3506 BPF_ALU64_IMM(BPF_MOV, R3, 3),
3507 BPF_ALU64_IMM(BPF_MOV, R4, 4),
3508 BPF_ALU64_IMM(BPF_MOV, R5, 5),
3509 BPF_ALU64_IMM(BPF_MOV, R6, 6),
3510 BPF_ALU64_IMM(BPF_MOV, R7, 7),
3511 BPF_ALU64_IMM(BPF_MOV, R8, 8),
3512 BPF_ALU64_IMM(BPF_MOV, R9, 9),
3513 BPF_ALU64_REG(BPF_MUL, R0, R0),
3514 BPF_ALU64_REG(BPF_MUL, R0, R1),
3515 BPF_ALU64_REG(BPF_MUL, R0, R2),
3516 BPF_ALU64_REG(BPF_MUL, R0, R3),
3517 BPF_ALU64_REG(BPF_MUL, R0, R4),
3518 BPF_ALU64_REG(BPF_MUL, R0, R5),
3519 BPF_ALU64_REG(BPF_MUL, R0, R6),
3520 BPF_ALU64_REG(BPF_MUL, R0, R7),
3521 BPF_ALU64_REG(BPF_MUL, R0, R8),
3522 BPF_ALU64_REG(BPF_MUL, R0, R9),
3523 BPF_ALU64_IMM(BPF_MUL, R0, 10),
3524 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
3525 BPF_EXIT_INSN(),
3526 BPF_ALU64_REG(BPF_MUL, R1, R0),
3527 BPF_ALU64_REG(BPF_MUL, R1, R2),
3528 BPF_ALU64_REG(BPF_MUL, R1, R3),
3529 BPF_ALU64_REG(BPF_MUL, R1, R4),
3530 BPF_ALU64_REG(BPF_MUL, R1, R5),
3531 BPF_ALU64_REG(BPF_MUL, R1, R6),
3532 BPF_ALU64_REG(BPF_MUL, R1, R7),
3533 BPF_ALU64_REG(BPF_MUL, R1, R8),
3534 BPF_ALU64_REG(BPF_MUL, R1, R9),
3535 BPF_ALU64_IMM(BPF_MUL, R1, 10),
3536 BPF_ALU64_REG(BPF_MOV, R2, R1),
3537 BPF_ALU64_IMM(BPF_RSH, R2, 32),
3538 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
3539 BPF_EXIT_INSN(),
3540 BPF_ALU64_IMM(BPF_LSH, R1, 32),
3541 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
3542 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
3543 BPF_EXIT_INSN(),
3544 BPF_ALU64_REG(BPF_MUL, R2, R0),
3545 BPF_ALU64_REG(BPF_MUL, R2, R1),
3546 BPF_ALU64_REG(BPF_MUL, R2, R3),
3547 BPF_ALU64_REG(BPF_MUL, R2, R4),
3548 BPF_ALU64_REG(BPF_MUL, R2, R5),
3549 BPF_ALU64_REG(BPF_MUL, R2, R6),
3550 BPF_ALU64_REG(BPF_MUL, R2, R7),
3551 BPF_ALU64_REG(BPF_MUL, R2, R8),
3552 BPF_ALU64_REG(BPF_MUL, R2, R9),
3553 BPF_ALU64_IMM(BPF_MUL, R2, 10),
3554 BPF_ALU64_IMM(BPF_RSH, R2, 32),
3555 BPF_ALU64_REG(BPF_MOV, R0, R2),
3556 BPF_EXIT_INSN(),
3557 },
10f18e0b 3558 INTERNAL,
9def624a
AS		 3559 { },
3560 { { 0, 0x35d97ef2 } }
3561 },
9dd2af83
DB		 3562 { /* Mainly checking JIT here. */
3563 "MOV REG64",
3564 .u.insns_int = {
3565 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3566 BPF_MOV64_REG(R1, R0),
3567 BPF_MOV64_REG(R2, R1),
3568 BPF_MOV64_REG(R3, R2),
3569 BPF_MOV64_REG(R4, R3),
3570 BPF_MOV64_REG(R5, R4),
3571 BPF_MOV64_REG(R6, R5),
3572 BPF_MOV64_REG(R7, R6),
3573 BPF_MOV64_REG(R8, R7),
3574 BPF_MOV64_REG(R9, R8),
3575 BPF_ALU64_IMM(BPF_MOV, R0, 0),
3576 BPF_ALU64_IMM(BPF_MOV, R1, 0),
3577 BPF_ALU64_IMM(BPF_MOV, R2, 0),
3578 BPF_ALU64_IMM(BPF_MOV, R3, 0),
3579 BPF_ALU64_IMM(BPF_MOV, R4, 0),
3580 BPF_ALU64_IMM(BPF_MOV, R5, 0),
3581 BPF_ALU64_IMM(BPF_MOV, R6, 0),
3582 BPF_ALU64_IMM(BPF_MOV, R7, 0),
3583 BPF_ALU64_IMM(BPF_MOV, R8, 0),
3584 BPF_ALU64_IMM(BPF_MOV, R9, 0),
3585 BPF_ALU64_REG(BPF_ADD, R0, R0),
3586 BPF_ALU64_REG(BPF_ADD, R0, R1),
3587 BPF_ALU64_REG(BPF_ADD, R0, R2),
3588 BPF_ALU64_REG(BPF_ADD, R0, R3),
3589 BPF_ALU64_REG(BPF_ADD, R0, R4),
3590 BPF_ALU64_REG(BPF_ADD, R0, R5),
3591 BPF_ALU64_REG(BPF_ADD, R0, R6),
3592 BPF_ALU64_REG(BPF_ADD, R0, R7),
3593 BPF_ALU64_REG(BPF_ADD, R0, R8),
3594 BPF_ALU64_REG(BPF_ADD, R0, R9),
3595 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3596 BPF_EXIT_INSN(),
3597 },
3598 INTERNAL,
3599 { },
3600 { { 0, 0xfefe } }
3601 },
3602 { /* Mainly checking JIT here. */
3603 "MOV REG32",
3604 .u.insns_int = {
3605 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3606 BPF_MOV64_REG(R1, R0),
3607 BPF_MOV64_REG(R2, R1),
3608 BPF_MOV64_REG(R3, R2),
3609 BPF_MOV64_REG(R4, R3),
3610 BPF_MOV64_REG(R5, R4),
3611 BPF_MOV64_REG(R6, R5),
3612 BPF_MOV64_REG(R7, R6),
3613 BPF_MOV64_REG(R8, R7),
3614 BPF_MOV64_REG(R9, R8),
3615 BPF_ALU32_IMM(BPF_MOV, R0, 0),
3616 BPF_ALU32_IMM(BPF_MOV, R1, 0),
3617 BPF_ALU32_IMM(BPF_MOV, R2, 0),
3618 BPF_ALU32_IMM(BPF_MOV, R3, 0),
3619 BPF_ALU32_IMM(BPF_MOV, R4, 0),
3620 BPF_ALU32_IMM(BPF_MOV, R5, 0),
3621 BPF_ALU32_IMM(BPF_MOV, R6, 0),
3622 BPF_ALU32_IMM(BPF_MOV, R7, 0),
3623 BPF_ALU32_IMM(BPF_MOV, R8, 0),
3624 BPF_ALU32_IMM(BPF_MOV, R9, 0),
3625 BPF_ALU64_REG(BPF_ADD, R0, R0),
3626 BPF_ALU64_REG(BPF_ADD, R0, R1),
3627 BPF_ALU64_REG(BPF_ADD, R0, R2),
3628 BPF_ALU64_REG(BPF_ADD, R0, R3),
3629 BPF_ALU64_REG(BPF_ADD, R0, R4),
3630 BPF_ALU64_REG(BPF_ADD, R0, R5),
3631 BPF_ALU64_REG(BPF_ADD, R0, R6),
3632 BPF_ALU64_REG(BPF_ADD, R0, R7),
3633 BPF_ALU64_REG(BPF_ADD, R0, R8),
3634 BPF_ALU64_REG(BPF_ADD, R0, R9),
3635 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3636 BPF_EXIT_INSN(),
3637 },
3638 INTERNAL,
3639 { },
3640 { { 0, 0xfefe } }
3641 },
3642 { /* Mainly checking JIT here. */
3643 "LD IMM64",
3644 .u.insns_int = {
3645 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
3646 BPF_MOV64_REG(R1, R0),
3647 BPF_MOV64_REG(R2, R1),
3648 BPF_MOV64_REG(R3, R2),
3649 BPF_MOV64_REG(R4, R3),
3650 BPF_MOV64_REG(R5, R4),
3651 BPF_MOV64_REG(R6, R5),
3652 BPF_MOV64_REG(R7, R6),
3653 BPF_MOV64_REG(R8, R7),
3654 BPF_MOV64_REG(R9, R8),
3655 BPF_LD_IMM64(R0, 0x0LL),
3656 BPF_LD_IMM64(R1, 0x0LL),
3657 BPF_LD_IMM64(R2, 0x0LL),
3658 BPF_LD_IMM64(R3, 0x0LL),
3659 BPF_LD_IMM64(R4, 0x0LL),
3660 BPF_LD_IMM64(R5, 0x0LL),
3661 BPF_LD_IMM64(R6, 0x0LL),
3662 BPF_LD_IMM64(R7, 0x0LL),
3663 BPF_LD_IMM64(R8, 0x0LL),
3664 BPF_LD_IMM64(R9, 0x0LL),
3665 BPF_ALU64_REG(BPF_ADD, R0, R0),
3666 BPF_ALU64_REG(BPF_ADD, R0, R1),
3667 BPF_ALU64_REG(BPF_ADD, R0, R2),
3668 BPF_ALU64_REG(BPF_ADD, R0, R3),
3669 BPF_ALU64_REG(BPF_ADD, R0, R4),
3670 BPF_ALU64_REG(BPF_ADD, R0, R5),
3671 BPF_ALU64_REG(BPF_ADD, R0, R6),
3672 BPF_ALU64_REG(BPF_ADD, R0, R7),
3673 BPF_ALU64_REG(BPF_ADD, R0, R8),
3674 BPF_ALU64_REG(BPF_ADD, R0, R9),
3675 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
3676 BPF_EXIT_INSN(),
3677 },
3678 INTERNAL,
3679 { },
3680 { { 0, 0xfefe } }
3681 },
9def624a
AS		 3682 {
3683 "INT: ALU MIX",
ece80490 3684 .u.insns_int = {
9def624a
AS		 3685 BPF_ALU64_IMM(BPF_MOV, R0, 11),
3686 BPF_ALU64_IMM(BPF_ADD, R0, -1),
3687 BPF_ALU64_IMM(BPF_MOV, R2, 2),
3688 BPF_ALU64_IMM(BPF_XOR, R2, 3),
3689 BPF_ALU64_REG(BPF_DIV, R0, R2),
3690 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
3691 BPF_EXIT_INSN(),
3692 BPF_ALU64_IMM(BPF_MOD, R0, 3),
3693 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
3694 BPF_EXIT_INSN(),
3695 BPF_ALU64_IMM(BPF_MOV, R0, -1),
72b603ee
AS		 3696 BPF_EXIT_INSN(),
3697 },
3698 INTERNAL,
3699 { },
3700 { { 0, -1 } }
3701 },
3702 {
3703 "INT: shifts by register",
3704 .u.insns_int = {
3705 BPF_MOV64_IMM(R0, -1234),
3706 BPF_MOV64_IMM(R1, 1),
3707 BPF_ALU32_REG(BPF_RSH, R0, R1),
3708 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
3709 BPF_EXIT_INSN(),
3710 BPF_MOV64_IMM(R2, 1),
3711 BPF_ALU64_REG(BPF_LSH, R0, R2),
3712 BPF_MOV32_IMM(R4, -1234),
3713 BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
3714 BPF_EXIT_INSN(),
3715 BPF_ALU64_IMM(BPF_AND, R4, 63),
3716 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
3717 BPF_MOV64_IMM(R3, 47),
3718 BPF_ALU64_REG(BPF_ARSH, R0, R3),
3719 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
3720 BPF_EXIT_INSN(),
3721 BPF_MOV64_IMM(R2, 1),
3722 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
3723 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
3724 BPF_EXIT_INSN(),
3725 BPF_MOV64_IMM(R4, 4),
3726 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
3727 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
3728 BPF_EXIT_INSN(),
3729 BPF_MOV64_IMM(R4, 5),
3730 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
3731 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
3732 BPF_EXIT_INSN(),
3733 BPF_MOV64_IMM(R0, -1),
9def624a
AS		 3734 BPF_EXIT_INSN(),
3735 },
10f18e0b 3736 INTERNAL,
9def624a
AS		 3737 { },
3738 { { 0, -1 } }
3739 },
84024a4e
JA		 3740 {
3741 /*
3742 * Test 32-bit JITs that implement complex ALU64 operations as
3743 * function calls R0 = f(R1, R2), and must re-arrange operands.
3744 */
3745#define NUMER 0xfedcba9876543210ULL
3746#define DENOM 0x0123456789abcdefULL
3747 "ALU64_DIV X: Operand register permutations",
3748 .u.insns_int = {
3749 /* R0 / R2 */
3750 BPF_LD_IMM64(R0, NUMER),
3751 BPF_LD_IMM64(R2, DENOM),
3752 BPF_ALU64_REG(BPF_DIV, R0, R2),
3753 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
3754 BPF_EXIT_INSN(),
3755 /* R1 / R0 */
3756 BPF_LD_IMM64(R1, NUMER),
3757 BPF_LD_IMM64(R0, DENOM),
3758 BPF_ALU64_REG(BPF_DIV, R1, R0),
3759 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
3760 BPF_EXIT_INSN(),
3761 /* R0 / R1 */
3762 BPF_LD_IMM64(R0, NUMER),
3763 BPF_LD_IMM64(R1, DENOM),
3764 BPF_ALU64_REG(BPF_DIV, R0, R1),
3765 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
3766 BPF_EXIT_INSN(),
3767 /* R2 / R0 */
3768 BPF_LD_IMM64(R2, NUMER),
3769 BPF_LD_IMM64(R0, DENOM),
3770 BPF_ALU64_REG(BPF_DIV, R2, R0),
3771 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
3772 BPF_EXIT_INSN(),
3773 /* R2 / R1 */
3774 BPF_LD_IMM64(R2, NUMER),
3775 BPF_LD_IMM64(R1, DENOM),
3776 BPF_ALU64_REG(BPF_DIV, R2, R1),
3777 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
3778 BPF_EXIT_INSN(),
3779 /* R1 / R2 */
3780 BPF_LD_IMM64(R1, NUMER),
3781 BPF_LD_IMM64(R2, DENOM),
3782 BPF_ALU64_REG(BPF_DIV, R1, R2),
3783 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
3784 BPF_EXIT_INSN(),
3785 /* R1 / R1 */
3786 BPF_LD_IMM64(R1, NUMER),
3787 BPF_ALU64_REG(BPF_DIV, R1, R1),
3788 BPF_JMP_IMM(BPF_JEQ, R1, 1, 1),
3789 BPF_EXIT_INSN(),
3790 /* R2 / R2 */
3791 BPF_LD_IMM64(R2, DENOM),
3792 BPF_ALU64_REG(BPF_DIV, R2, R2),
3793 BPF_JMP_IMM(BPF_JEQ, R2, 1, 1),
3794 BPF_EXIT_INSN(),
3795 /* R3 / R4 */
3796 BPF_LD_IMM64(R3, NUMER),
3797 BPF_LD_IMM64(R4, DENOM),
3798 BPF_ALU64_REG(BPF_DIV, R3, R4),
3799 BPF_JMP_IMM(BPF_JEQ, R3, NUMER / DENOM, 1),
3800 BPF_EXIT_INSN(),
3801 /* Successful return */
3802 BPF_LD_IMM64(R0, 1),
3803 BPF_EXIT_INSN(),
3804 },
3805 INTERNAL,
3806 { },
3807 { { 0, 1 } },
3808#undef NUMER
3809#undef DENOM
3810 },
53e33f99
JA		 3811#ifdef CONFIG_32BIT
3812 {
3813 "INT: 32-bit context pointer word order and zero-extension",
3814 .u.insns_int = {
3815 BPF_ALU32_IMM(BPF_MOV, R0, 0),
3816 BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
3817 BPF_ALU64_IMM(BPF_RSH, R1, 32),
3818 BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
3819 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3820 BPF_EXIT_INSN(),
3821 },
3822 INTERNAL,
3823 { },
3824 { { 0, 1 } }
3825 },
3826#endif
64a8946b
AS		 3827 {
3828 "check: missing ret",
ece80490 3829 .u.insns = {
64a8946b
AS		 3830 BPF_STMT(BPF_LD | BPF_IMM, 1),
3831 },
10f18e0b 3832 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
64a8946b 3833 { },
09584b40
YS		 3834 { },
3835 .fill_helper = NULL,
3836 .expected_errcode = -EINVAL,
64a8946b 3837 },
9def624a
AS		 3838 {
3839 "check: div_k_0",
ece80490 3840 .u.insns = {
9def624a
AS		 3841 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
3842 BPF_STMT(BPF_RET | BPF_K, 0)
3843 },
10f18e0b 3844 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a 3845 { },
09584b40
YS		 3846 { },
3847 .fill_helper = NULL,
3848 .expected_errcode = -EINVAL,
9def624a
AS		 3849 },
3850 {
3851 "check: unknown insn",
ece80490 3852 .u.insns = {
9def624a
AS		 3853 /* seccomp insn, rejected in socket filter */
3854 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
3855 BPF_STMT(BPF_RET | BPF_K, 0)
3856 },
10f18e0b 3857 CLASSIC | FLAG_EXPECTED_FAIL,
9def624a 3858 { },
09584b40
YS		 3859 { },
3860 .fill_helper = NULL,
3861 .expected_errcode = -EINVAL,
9def624a
AS		 3862 },
3863 {
3864 "check: out of range spill/fill",
ece80490 3865 .u.insns = {
9def624a
AS		 3866 BPF_STMT(BPF_STX, 16),
3867 BPF_STMT(BPF_RET | BPF_K, 0)
3868 },
10f18e0b 3869 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a 3870 { },
09584b40
YS		 3871 { },
3872 .fill_helper = NULL,
3873 .expected_errcode = -EINVAL,
9def624a 3874 },
2e8a83c5
DB		 3875 {
3876 "JUMPS + HOLES",
3877 .u.insns = {
3878 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3879 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
3880 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3881 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3882 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3883 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3884 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3885 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3886 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3887 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3888 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3889 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3890 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3891 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3892 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3893 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
3894 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3895 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
3896 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3897 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
3898 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
3899 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3900 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3901 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3902 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3903 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3904 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3905 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3906 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3907 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3908 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3909 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3910 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3911 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3912 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
3913 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
3914 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3915 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
3916 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
3917 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3918 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3919 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3920 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3921 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3922 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3923 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3924 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3925 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3926 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3927 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3928 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3929 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3930 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
3931 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
3932 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
3933 BPF_STMT(BPF_RET | BPF_A, 0),
3934 BPF_STMT(BPF_RET | BPF_A, 0),
3935 },
3936 CLASSIC,
ce25b68b
DB		 3937 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
3938 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
3939 0x08, 0x00,
3940 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
3941 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
3942 0xc0, 0xa8, 0x33, 0x01,
3943 0xc0, 0xa8, 0x33, 0x02,
3944 0xbb, 0xb6,
3945 0xa9, 0xfa,
3946 0x00, 0x14, 0x00, 0x00,
3947 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3948 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3949 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3950 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3951 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3952 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3953 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
3954 0xcc, 0xcc, 0xcc, 0xcc },
2e8a83c5
DB		 3955 { { 88, 0x001b } }
3956 },
3957 {
3958 "check: RET X",
3959 .u.insns = {
3960 BPF_STMT(BPF_RET | BPF_X, 0),
3961 },
3962 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
3963 { },
3964 { },
09584b40
YS		 3965 .fill_helper = NULL,
3966 .expected_errcode = -EINVAL,
2e8a83c5
DB		 3967 },
3968 {
3969 "check: LDX + RET X",
3970 .u.insns = {
3971 BPF_STMT(BPF_LDX | BPF_IMM, 42),
3972 BPF_STMT(BPF_RET | BPF_X, 0),
3973 },
3974 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
3975 { },
3976 { },
09584b40
YS		 3977 .fill_helper = NULL,
3978 .expected_errcode = -EINVAL,
2e8a83c5 3979 },
108cc22a 3980 { /* Mainly checking JIT here. */
9fe13baa 3981 "M[]: alt STX + LDX",
108cc22a
DB		 3982 .u.insns = {
3983 BPF_STMT(BPF_LDX | BPF_IMM, 100),
3984 BPF_STMT(BPF_STX, 0),
3985 BPF_STMT(BPF_LDX | BPF_MEM, 0),
3986 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3987 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3988 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3989 BPF_STMT(BPF_STX, 1),
3990 BPF_STMT(BPF_LDX | BPF_MEM, 1),
3991 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3992 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3993 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3994 BPF_STMT(BPF_STX, 2),
3995 BPF_STMT(BPF_LDX | BPF_MEM, 2),
3996 BPF_STMT(BPF_MISC | BPF_TXA, 0),
3997 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
3998 BPF_STMT(BPF_MISC | BPF_TAX, 0),
3999 BPF_STMT(BPF_STX, 3),
4000 BPF_STMT(BPF_LDX | BPF_MEM, 3),
4001 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4002 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4003 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4004 BPF_STMT(BPF_STX, 4),
4005 BPF_STMT(BPF_LDX | BPF_MEM, 4),
4006 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4007 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4008 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4009 BPF_STMT(BPF_STX, 5),
4010 BPF_STMT(BPF_LDX | BPF_MEM, 5),
4011 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4012 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4013 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4014 BPF_STMT(BPF_STX, 6),
4015 BPF_STMT(BPF_LDX | BPF_MEM, 6),
4016 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4017 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4018 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4019 BPF_STMT(BPF_STX, 7),
4020 BPF_STMT(BPF_LDX | BPF_MEM, 7),
4021 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4022 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4023 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4024 BPF_STMT(BPF_STX, 8),
4025 BPF_STMT(BPF_LDX | BPF_MEM, 8),
4026 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4027 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4028 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4029 BPF_STMT(BPF_STX, 9),
4030 BPF_STMT(BPF_LDX | BPF_MEM, 9),
4031 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4032 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4033 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4034 BPF_STMT(BPF_STX, 10),
4035 BPF_STMT(BPF_LDX | BPF_MEM, 10),
4036 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4037 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4038 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4039 BPF_STMT(BPF_STX, 11),
4040 BPF_STMT(BPF_LDX | BPF_MEM, 11),
4041 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4042 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4043 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4044 BPF_STMT(BPF_STX, 12),
4045 BPF_STMT(BPF_LDX | BPF_MEM, 12),
4046 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4047 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4048 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4049 BPF_STMT(BPF_STX, 13),
4050 BPF_STMT(BPF_LDX | BPF_MEM, 13),
4051 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4052 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4053 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4054 BPF_STMT(BPF_STX, 14),
4055 BPF_STMT(BPF_LDX | BPF_MEM, 14),
4056 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4057 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4058 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4059 BPF_STMT(BPF_STX, 15),
4060 BPF_STMT(BPF_LDX | BPF_MEM, 15),
4061 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4062 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
4063 BPF_STMT(BPF_MISC | BPF_TAX, 0),
4064 BPF_STMT(BPF_RET | BPF_A, 0),
4065 },
4066 CLASSIC | FLAG_NO_DATA,
4067 { },
4068 { { 0, 116 } },
4069 },
9fe13baa
DB		 4070 { /* Mainly checking JIT here. */
4071 "M[]: full STX + full LDX",
4072 .u.insns = {
4073 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
4074 BPF_STMT(BPF_STX, 0),
4075 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
4076 BPF_STMT(BPF_STX, 1),
4077 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
4078 BPF_STMT(BPF_STX, 2),
4079 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
4080 BPF_STMT(BPF_STX, 3),
4081 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
4082 BPF_STMT(BPF_STX, 4),
4083 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
4084 BPF_STMT(BPF_STX, 5),
4085 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
4086 BPF_STMT(BPF_STX, 6),
4087 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
4088 BPF_STMT(BPF_STX, 7),
4089 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
4090 BPF_STMT(BPF_STX, 8),
4091 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
4092 BPF_STMT(BPF_STX, 9),
4093 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
4094 BPF_STMT(BPF_STX, 10),
4095 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
4096 BPF_STMT(BPF_STX, 11),
4097 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
4098 BPF_STMT(BPF_STX, 12),
4099 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
4100 BPF_STMT(BPF_STX, 13),
4101 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
4102 BPF_STMT(BPF_STX, 14),
4103 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
4104 BPF_STMT(BPF_STX, 15),
4105 BPF_STMT(BPF_LDX | BPF_MEM, 0),
4106 BPF_STMT(BPF_MISC | BPF_TXA, 0),
4107 BPF_STMT(BPF_LDX | BPF_MEM, 1),
4108 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4109 BPF_STMT(BPF_LDX | BPF_MEM, 2),
4110 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4111 BPF_STMT(BPF_LDX | BPF_MEM, 3),
4112 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4113 BPF_STMT(BPF_LDX | BPF_MEM, 4),
4114 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4115 BPF_STMT(BPF_LDX | BPF_MEM, 5),
4116 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4117 BPF_STMT(BPF_LDX | BPF_MEM, 6),
4118 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4119 BPF_STMT(BPF_LDX | BPF_MEM, 7),
4120 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4121 BPF_STMT(BPF_LDX | BPF_MEM, 8),
4122 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4123 BPF_STMT(BPF_LDX | BPF_MEM, 9),
4124 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4125 BPF_STMT(BPF_LDX | BPF_MEM, 10),
4126 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4127 BPF_STMT(BPF_LDX | BPF_MEM, 11),
4128 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4129 BPF_STMT(BPF_LDX | BPF_MEM, 12),
4130 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4131 BPF_STMT(BPF_LDX | BPF_MEM, 13),
4132 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4133 BPF_STMT(BPF_LDX | BPF_MEM, 14),
4134 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4135 BPF_STMT(BPF_LDX | BPF_MEM, 15),
4136 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
4137 BPF_STMT(BPF_RET | BPF_A, 0),
4138 },
4139 CLASSIC | FLAG_NO_DATA,
4140 { },
4141 { { 0, 0x2a5a5e5 } },
4142 },
d50bc157
DB		 4143 {
4144 "check: SKF_AD_MAX",
4145 .u.insns = {
4146 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4147 SKF_AD_OFF + SKF_AD_MAX),
4148 BPF_STMT(BPF_RET | BPF_A, 0),
4149 },
4150 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4151 { },
4152 { },
09584b40
YS		 4153 .fill_helper = NULL,
4154 .expected_errcode = -EINVAL,
d50bc157
DB		 4155 },
4156 { /* Passes checker but fails during runtime. */
4157 "LD [SKF_AD_OFF-1]",
4158 .u.insns = {
4159 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
4160 SKF_AD_OFF - 1),
4161 BPF_STMT(BPF_RET | BPF_K, 1),
4162 },
4163 CLASSIC,
4164 { },
4165 { { 1, 0 } },
4166 },
02ab695b
AS		 4167 {
4168 "load 64-bit immediate",
4169 .u.insns_int = {
25ee7327 4170 BPF_LD_IMM64(R1, 0x567800001234LL),
02ab695b
AS		 4171 BPF_MOV64_REG(R2, R1),
4172 BPF_MOV64_REG(R3, R2),
4173 BPF_ALU64_IMM(BPF_RSH, R2, 32),
4174 BPF_ALU64_IMM(BPF_LSH, R3, 32),
4175 BPF_ALU64_IMM(BPF_RSH, R3, 32),
4176 BPF_ALU64_IMM(BPF_MOV, R0, 0),
4177 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
4178 BPF_EXIT_INSN(),
4179 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
4180 BPF_EXIT_INSN(),
986ccfdb
XW		 4181 BPF_LD_IMM64(R0, 0x1ffffffffLL),
4182 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
02ab695b
AS		 4183 BPF_EXIT_INSN(),
4184 },
4185 INTERNAL,
4186 { },
4187 { { 0, 1 } }
4188 },
cffc642d
MH		 4189 /* BPF_ALU | BPF_MOV | BPF_X */
4190 {
4191 "ALU_MOV_X: dst = 2",
4192 .u.insns_int = {
4193 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4194 BPF_ALU32_REG(BPF_MOV, R0, R1),
4195 BPF_EXIT_INSN(),
4196 },
4197 INTERNAL,
4198 { },
4199 { { 0, 2 } },
4200 },
4201 {
4202 "ALU_MOV_X: dst = 4294967295",
4203 .u.insns_int = {
56cbaa45 4204 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 4205 BPF_ALU32_REG(BPF_MOV, R0, R1),
4206 BPF_EXIT_INSN(),
4207 },
4208 INTERNAL,
4209 { },
56cbaa45 4210 { { 0, 4294967295U } },
cffc642d
MH		 4211 },
4212 {
4213 "ALU64_MOV_X: dst = 2",
4214 .u.insns_int = {
4215 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4216 BPF_ALU64_REG(BPF_MOV, R0, R1),
4217 BPF_EXIT_INSN(),
4218 },
4219 INTERNAL,
4220 { },
4221 { { 0, 2 } },
4222 },
4223 {
4224 "ALU64_MOV_X: dst = 4294967295",
4225 .u.insns_int = {
56cbaa45 4226 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 4227 BPF_ALU64_REG(BPF_MOV, R0, R1),
4228 BPF_EXIT_INSN(),
4229 },
4230 INTERNAL,
4231 { },
56cbaa45 4232 { { 0, 4294967295U } },
cffc642d
MH		 4233 },
4234 /* BPF_ALU | BPF_MOV | BPF_K */
4235 {
4236 "ALU_MOV_K: dst = 2",
4237 .u.insns_int = {
4238 BPF_ALU32_IMM(BPF_MOV, R0, 2),
4239 BPF_EXIT_INSN(),
4240 },
4241 INTERNAL,
4242 { },
4243 { { 0, 2 } },
4244 },
4245 {
4246 "ALU_MOV_K: dst = 4294967295",
4247 .u.insns_int = {
56cbaa45 4248 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
cffc642d
MH		 4249 BPF_EXIT_INSN(),
4250 },
4251 INTERNAL,
4252 { },
56cbaa45 4253 { { 0, 4294967295U } },
cffc642d
MH		 4254 },
4255 {
4256 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
4257 .u.insns_int = {
56cbaa45
MH		 4258 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4259 BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
cffc642d
MH		 4260 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
4261 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4262 BPF_MOV32_IMM(R0, 2),
4263 BPF_EXIT_INSN(),
4264 BPF_MOV32_IMM(R0, 1),
4265 BPF_EXIT_INSN(),
4266 },
4267 INTERNAL,
4268 { },
4269 { { 0, 0x1 } },
4270 },
565731ac
JA		 4271 {
4272 "ALU_MOV_K: small negative",
4273 .u.insns_int = {
4274 BPF_ALU32_IMM(BPF_MOV, R0, -123),
4275 BPF_EXIT_INSN(),
4276 },
4277 INTERNAL,
4278 { },
4279 { { 0, -123 } }
4280 },
4281 {
4282 "ALU_MOV_K: small negative zero extension",
4283 .u.insns_int = {
4284 BPF_ALU32_IMM(BPF_MOV, R0, -123),
4285 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4286 BPF_EXIT_INSN(),
4287 },
4288 INTERNAL,
4289 { },
4290 { { 0, 0 } }
4291 },
4292 {
4293 "ALU_MOV_K: large negative",
4294 .u.insns_int = {
4295 BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
4296 BPF_EXIT_INSN(),
4297 },
4298 INTERNAL,
4299 { },
4300 { { 0, -123456789 } }
4301 },
4302 {
4303 "ALU_MOV_K: large negative zero extension",
4304 .u.insns_int = {
4305 BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
4306 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4307 BPF_EXIT_INSN(),
4308 },
4309 INTERNAL,
4310 { },
4311 { { 0, 0 } }
4312 },
cffc642d
MH		 4313 {
4314 "ALU64_MOV_K: dst = 2",
4315 .u.insns_int = {
4316 BPF_ALU64_IMM(BPF_MOV, R0, 2),
4317 BPF_EXIT_INSN(),
4318 },
4319 INTERNAL,
4320 { },
4321 { { 0, 2 } },
4322 },
4323 {
4324 "ALU64_MOV_K: dst = 2147483647",
4325 .u.insns_int = {
4326 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
4327 BPF_EXIT_INSN(),
4328 },
4329 INTERNAL,
4330 { },
4331 { { 0, 2147483647 } },
4332 },
4333 {
4334 "ALU64_OR_K: dst = 0x0",
4335 .u.insns_int = {
56cbaa45 4336 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
cffc642d
MH		 4337 BPF_LD_IMM64(R3, 0x0),
4338 BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
4339 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4340 BPF_MOV32_IMM(R0, 2),
4341 BPF_EXIT_INSN(),
4342 BPF_MOV32_IMM(R0, 1),
4343 BPF_EXIT_INSN(),
4344 },
4345 INTERNAL,
4346 { },
4347 { { 0, 0x1 } },
4348 },
4349 {
4350 "ALU64_MOV_K: dst = -1",
4351 .u.insns_int = {
56cbaa45
MH		 4352 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4353 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 4354 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
4355 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4356 BPF_MOV32_IMM(R0, 2),
4357 BPF_EXIT_INSN(),
4358 BPF_MOV32_IMM(R0, 1),
4359 BPF_EXIT_INSN(),
4360 },
4361 INTERNAL,
4362 { },
4363 { { 0, 0x1 } },
4364 },
565731ac
JA		 4365 {
4366 "ALU64_MOV_K: small negative",
4367 .u.insns_int = {
4368 BPF_ALU64_IMM(BPF_MOV, R0, -123),
4369 BPF_EXIT_INSN(),
4370 },
4371 INTERNAL,
4372 { },
4373 { { 0, -123 } }
4374 },
4375 {
4376 "ALU64_MOV_K: small negative sign extension",
4377 .u.insns_int = {
4378 BPF_ALU64_IMM(BPF_MOV, R0, -123),
4379 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4380 BPF_EXIT_INSN(),
4381 },
4382 INTERNAL,
4383 { },
4384 { { 0, 0xffffffff } }
4385 },
4386 {
4387 "ALU64_MOV_K: large negative",
4388 .u.insns_int = {
4389 BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
4390 BPF_EXIT_INSN(),
4391 },
4392 INTERNAL,
4393 { },
4394 { { 0, -123456789 } }
4395 },
4396 {
4397 "ALU64_MOV_K: large negative sign extension",
4398 .u.insns_int = {
4399 BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
4400 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4401 BPF_EXIT_INSN(),
4402 },
4403 INTERNAL,
4404 { },
4405 { { 0, 0xffffffff } }
4406 },
cffc642d
MH		 4407 /* BPF_ALU | BPF_ADD | BPF_X */
4408 {
4409 "ALU_ADD_X: 1 + 2 = 3",
4410 .u.insns_int = {
4411 BPF_LD_IMM64(R0, 1),
4412 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4413 BPF_ALU32_REG(BPF_ADD, R0, R1),
4414 BPF_EXIT_INSN(),
4415 },
4416 INTERNAL,
4417 { },
4418 { { 0, 3 } },
4419 },
4420 {
4421 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
4422 .u.insns_int = {
4423 BPF_LD_IMM64(R0, 1),
56cbaa45 4424 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 4425 BPF_ALU32_REG(BPF_ADD, R0, R1),
4426 BPF_EXIT_INSN(),
4427 },
4428 INTERNAL,
4429 { },
56cbaa45 4430 { { 0, 4294967295U } },
cffc642d 4431 },
b64b50ea
NR		 4432 {
4433 "ALU_ADD_X: 2 + 4294967294 = 0",
4434 .u.insns_int = {
4435 BPF_LD_IMM64(R0, 2),
4436 BPF_LD_IMM64(R1, 4294967294U),
4437 BPF_ALU32_REG(BPF_ADD, R0, R1),
4438 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
4439 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4440 BPF_EXIT_INSN(),
4441 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4442 BPF_EXIT_INSN(),
4443 },
4444 INTERNAL,
4445 { },
4446 { { 0, 1 } },
4447 },
cffc642d
MH		 4448 {
4449 "ALU64_ADD_X: 1 + 2 = 3",
4450 .u.insns_int = {
4451 BPF_LD_IMM64(R0, 1),
4452 BPF_ALU32_IMM(BPF_MOV, R1, 2),
4453 BPF_ALU64_REG(BPF_ADD, R0, R1),
4454 BPF_EXIT_INSN(),
4455 },
4456 INTERNAL,
4457 { },
4458 { { 0, 3 } },
4459 },
4460 {
4461 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
4462 .u.insns_int = {
4463 BPF_LD_IMM64(R0, 1),
56cbaa45 4464 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 4465 BPF_ALU64_REG(BPF_ADD, R0, R1),
4466 BPF_EXIT_INSN(),
4467 },
4468 INTERNAL,
4469 { },
56cbaa45 4470 { { 0, 4294967295U } },
cffc642d 4471 },
b64b50ea
NR		 4472 {
4473 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
4474 .u.insns_int = {
4475 BPF_LD_IMM64(R0, 2),
4476 BPF_LD_IMM64(R1, 4294967294U),
4477 BPF_LD_IMM64(R2, 4294967296ULL),
4478 BPF_ALU64_REG(BPF_ADD, R0, R1),
4479 BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
4480 BPF_MOV32_IMM(R0, 0),
4481 BPF_EXIT_INSN(),
4482 BPF_MOV32_IMM(R0, 1),
4483 BPF_EXIT_INSN(),
4484 },
4485 INTERNAL,
4486 { },
4487 { { 0, 1 } },
4488 },
cffc642d
MH		 4489 /* BPF_ALU | BPF_ADD | BPF_K */
4490 {
4491 "ALU_ADD_K: 1 + 2 = 3",
4492 .u.insns_int = {
4493 BPF_LD_IMM64(R0, 1),
4494 BPF_ALU32_IMM(BPF_ADD, R0, 2),
4495 BPF_EXIT_INSN(),
4496 },
4497 INTERNAL,
4498 { },
4499 { { 0, 3 } },
4500 },
4501 {
4502 "ALU_ADD_K: 3 + 0 = 3",
4503 .u.insns_int = {
4504 BPF_LD_IMM64(R0, 3),
4505 BPF_ALU32_IMM(BPF_ADD, R0, 0),
4506 BPF_EXIT_INSN(),
4507 },
4508 INTERNAL,
4509 { },
4510 { { 0, 3 } },
4511 },
4512 {
4513 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
4514 .u.insns_int = {
4515 BPF_LD_IMM64(R0, 1),
56cbaa45 4516 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
cffc642d
MH		 4517 BPF_EXIT_INSN(),
4518 },
4519 INTERNAL,
4520 { },
56cbaa45 4521 { { 0, 4294967295U } },
cffc642d 4522 },
b64b50ea
NR		 4523 {
4524 "ALU_ADD_K: 4294967294 + 2 = 0",
4525 .u.insns_int = {
4526 BPF_LD_IMM64(R0, 4294967294U),
4527 BPF_ALU32_IMM(BPF_ADD, R0, 2),
4528 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
4529 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4530 BPF_EXIT_INSN(),
4531 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4532 BPF_EXIT_INSN(),
4533 },
4534 INTERNAL,
4535 { },
4536 { { 0, 1 } },
4537 },
cffc642d
MH		 4538 {
4539 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
4540 .u.insns_int = {
4541 BPF_LD_IMM64(R2, 0x0),
4542 BPF_LD_IMM64(R3, 0x00000000ffffffff),
4543 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
4544 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4545 BPF_MOV32_IMM(R0, 2),
4546 BPF_EXIT_INSN(),
4547 BPF_MOV32_IMM(R0, 1),
4548 BPF_EXIT_INSN(),
4549 },
4550 INTERNAL,
4551 { },
4552 { { 0, 0x1 } },
4553 },
9c94f6c8
NR		 4554 {
4555 "ALU_ADD_K: 0 + 0xffff = 0xffff",
4556 .u.insns_int = {
4557 BPF_LD_IMM64(R2, 0x0),
4558 BPF_LD_IMM64(R3, 0xffff),
4559 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
4560 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4561 BPF_MOV32_IMM(R0, 2),
4562 BPF_EXIT_INSN(),
4563 BPF_MOV32_IMM(R0, 1),
4564 BPF_EXIT_INSN(),
4565 },
4566 INTERNAL,
4567 { },
4568 { { 0, 0x1 } },
4569 },
4570 {
4571 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
4572 .u.insns_int = {
4573 BPF_LD_IMM64(R2, 0x0),
4574 BPF_LD_IMM64(R3, 0x7fffffff),
4575 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
4576 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4577 BPF_MOV32_IMM(R0, 2),
4578 BPF_EXIT_INSN(),
4579 BPF_MOV32_IMM(R0, 1),
4580 BPF_EXIT_INSN(),
4581 },
4582 INTERNAL,
4583 { },
4584 { { 0, 0x1 } },
4585 },
4586 {
4587 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
4588 .u.insns_int = {
4589 BPF_LD_IMM64(R2, 0x0),
4590 BPF_LD_IMM64(R3, 0x80000000),
4591 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
4592 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4593 BPF_MOV32_IMM(R0, 2),
4594 BPF_EXIT_INSN(),
4595 BPF_MOV32_IMM(R0, 1),
4596 BPF_EXIT_INSN(),
4597 },
4598 INTERNAL,
4599 { },
4600 { { 0, 0x1 } },
4601 },
4602 {
4603 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
4604 .u.insns_int = {
4605 BPF_LD_IMM64(R2, 0x0),
4606 BPF_LD_IMM64(R3, 0x80008000),
4607 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
4608 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4609 BPF_MOV32_IMM(R0, 2),
4610 BPF_EXIT_INSN(),
4611 BPF_MOV32_IMM(R0, 1),
4612 BPF_EXIT_INSN(),
4613 },
4614 INTERNAL,
4615 { },
4616 { { 0, 0x1 } },
4617 },
cffc642d
MH		 4618 {
4619 "ALU64_ADD_K: 1 + 2 = 3",
4620 .u.insns_int = {
4621 BPF_LD_IMM64(R0, 1),
4622 BPF_ALU64_IMM(BPF_ADD, R0, 2),
4623 BPF_EXIT_INSN(),
4624 },
4625 INTERNAL,
4626 { },
4627 { { 0, 3 } },
4628 },
4629 {
4630 "ALU64_ADD_K: 3 + 0 = 3",
4631 .u.insns_int = {
4632 BPF_LD_IMM64(R0, 3),
4633 BPF_ALU64_IMM(BPF_ADD, R0, 0),
4634 BPF_EXIT_INSN(),
4635 },
4636 INTERNAL,
4637 { },
4638 { { 0, 3 } },
4639 },
4640 {
4641 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
4642 .u.insns_int = {
4643 BPF_LD_IMM64(R0, 1),
4644 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
4645 BPF_EXIT_INSN(),
4646 },
4647 INTERNAL,
4648 { },
4649 { { 0, 2147483647 } },
4650 },
b64b50ea
NR		 4651 {
4652 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
4653 .u.insns_int = {
4654 BPF_LD_IMM64(R0, 4294967294U),
4655 BPF_LD_IMM64(R1, 4294967296ULL),
4656 BPF_ALU64_IMM(BPF_ADD, R0, 2),
4657 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4658 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4659 BPF_EXIT_INSN(),
4660 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4661 BPF_EXIT_INSN(),
4662 },
4663 INTERNAL,
4664 { },
4665 { { 0, 1 } },
4666 },
cffc642d
MH		 4667 {
4668 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
4669 .u.insns_int = {
4670 BPF_LD_IMM64(R0, 2147483646),
4671 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
4672 BPF_EXIT_INSN(),
4673 },
4674 INTERNAL,
4675 { },
4676 { { 0, -1 } },
4677 },
4678 {
4679 "ALU64_ADD_K: 1 + 0 = 1",
4680 .u.insns_int = {
4681 BPF_LD_IMM64(R2, 0x1),
4682 BPF_LD_IMM64(R3, 0x1),
4683 BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
4684 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4685 BPF_MOV32_IMM(R0, 2),
4686 BPF_EXIT_INSN(),
4687 BPF_MOV32_IMM(R0, 1),
4688 BPF_EXIT_INSN(),
4689 },
4690 INTERNAL,
4691 { },
4692 { { 0, 0x1 } },
4693 },
4694 {
4695 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
4696 .u.insns_int = {
4697 BPF_LD_IMM64(R2, 0x0),
56cbaa45 4698 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 4699 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
4700 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4701 BPF_MOV32_IMM(R0, 2),
4702 BPF_EXIT_INSN(),
4703 BPF_MOV32_IMM(R0, 1),
4704 BPF_EXIT_INSN(),
4705 },
4706 INTERNAL,
4707 { },
4708 { { 0, 0x1 } },
4709 },
9c94f6c8
NR		 4710 {
4711 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
4712 .u.insns_int = {
4713 BPF_LD_IMM64(R2, 0x0),
4714 BPF_LD_IMM64(R3, 0xffff),
4715 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
4716 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4717 BPF_MOV32_IMM(R0, 2),
4718 BPF_EXIT_INSN(),
4719 BPF_MOV32_IMM(R0, 1),
4720 BPF_EXIT_INSN(),
4721 },
4722 INTERNAL,
4723 { },
4724 { { 0, 0x1 } },
4725 },
4726 {
4727 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
4728 .u.insns_int = {
4729 BPF_LD_IMM64(R2, 0x0),
4730 BPF_LD_IMM64(R3, 0x7fffffff),
4731 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
4732 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4733 BPF_MOV32_IMM(R0, 2),
4734 BPF_EXIT_INSN(),
4735 BPF_MOV32_IMM(R0, 1),
4736 BPF_EXIT_INSN(),
4737 },
4738 INTERNAL,
4739 { },
4740 { { 0, 0x1 } },
4741 },
4742 {
4743 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
4744 .u.insns_int = {
4745 BPF_LD_IMM64(R2, 0x0),
4746 BPF_LD_IMM64(R3, 0xffffffff80000000LL),
4747 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
4748 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4749 BPF_MOV32_IMM(R0, 2),
4750 BPF_EXIT_INSN(),
4751 BPF_MOV32_IMM(R0, 1),
4752 BPF_EXIT_INSN(),
4753 },
4754 INTERNAL,
4755 { },
4756 { { 0, 0x1 } },
4757 },
4758 {
4759 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
4760 .u.insns_int = {
4761 BPF_LD_IMM64(R2, 0x0),
4762 BPF_LD_IMM64(R3, 0xffffffff80008000LL),
4763 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
4764 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4765 BPF_MOV32_IMM(R0, 2),
4766 BPF_EXIT_INSN(),
4767 BPF_MOV32_IMM(R0, 1),
4768 BPF_EXIT_INSN(),
4769 },
4770 INTERNAL,
4771 { },
4772 { { 0, 0x1 } },
4773 },
cffc642d
MH		 4774 /* BPF_ALU | BPF_SUB | BPF_X */
4775 {
4776 "ALU_SUB_X: 3 - 1 = 2",
4777 .u.insns_int = {
4778 BPF_LD_IMM64(R0, 3),
4779 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4780 BPF_ALU32_REG(BPF_SUB, R0, R1),
4781 BPF_EXIT_INSN(),
4782 },
4783 INTERNAL,
4784 { },
4785 { { 0, 2 } },
4786 },
4787 {
4788 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
4789 .u.insns_int = {
56cbaa45
MH		 4790 BPF_LD_IMM64(R0, 4294967295U),
4791 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 4792 BPF_ALU32_REG(BPF_SUB, R0, R1),
4793 BPF_EXIT_INSN(),
4794 },
4795 INTERNAL,
4796 { },
4797 { { 0, 1 } },
4798 },
4799 {
4800 "ALU64_SUB_X: 3 - 1 = 2",
4801 .u.insns_int = {
4802 BPF_LD_IMM64(R0, 3),
4803 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4804 BPF_ALU64_REG(BPF_SUB, R0, R1),
4805 BPF_EXIT_INSN(),
4806 },
4807 INTERNAL,
4808 { },
4809 { { 0, 2 } },
4810 },
4811 {
4812 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
4813 .u.insns_int = {
56cbaa45
MH		 4814 BPF_LD_IMM64(R0, 4294967295U),
4815 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 4816 BPF_ALU64_REG(BPF_SUB, R0, R1),
4817 BPF_EXIT_INSN(),
4818 },
4819 INTERNAL,
4820 { },
4821 { { 0, 1 } },
4822 },
4823 /* BPF_ALU | BPF_SUB | BPF_K */
4824 {
4825 "ALU_SUB_K: 3 - 1 = 2",
4826 .u.insns_int = {
4827 BPF_LD_IMM64(R0, 3),
4828 BPF_ALU32_IMM(BPF_SUB, R0, 1),
4829 BPF_EXIT_INSN(),
4830 },
4831 INTERNAL,
4832 { },
4833 { { 0, 2 } },
4834 },
4835 {
4836 "ALU_SUB_K: 3 - 0 = 3",
4837 .u.insns_int = {
4838 BPF_LD_IMM64(R0, 3),
4839 BPF_ALU32_IMM(BPF_SUB, R0, 0),
4840 BPF_EXIT_INSN(),
4841 },
4842 INTERNAL,
4843 { },
4844 { { 0, 3 } },
4845 },
4846 {
4847 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
4848 .u.insns_int = {
56cbaa45
MH		 4849 BPF_LD_IMM64(R0, 4294967295U),
4850 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
cffc642d
MH		 4851 BPF_EXIT_INSN(),
4852 },
4853 INTERNAL,
4854 { },
4855 { { 0, 1 } },
4856 },
4857 {
4858 "ALU64_SUB_K: 3 - 1 = 2",
4859 .u.insns_int = {
4860 BPF_LD_IMM64(R0, 3),
4861 BPF_ALU64_IMM(BPF_SUB, R0, 1),
4862 BPF_EXIT_INSN(),
4863 },
4864 INTERNAL,
4865 { },
4866 { { 0, 2 } },
4867 },
4868 {
4869 "ALU64_SUB_K: 3 - 0 = 3",
4870 .u.insns_int = {
4871 BPF_LD_IMM64(R0, 3),
4872 BPF_ALU64_IMM(BPF_SUB, R0, 0),
4873 BPF_EXIT_INSN(),
4874 },
4875 INTERNAL,
4876 { },
4877 { { 0, 3 } },
4878 },
4879 {
4880 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
4881 .u.insns_int = {
56cbaa45
MH		 4882 BPF_LD_IMM64(R0, 4294967294U),
4883 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
cffc642d
MH		 4884 BPF_EXIT_INSN(),
4885 },
4886 INTERNAL,
4887 { },
4888 { { 0, -1 } },
4889 },
4890 {
4891 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
4892 .u.insns_int = {
4893 BPF_LD_IMM64(R0, 2147483646),
4894 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
4895 BPF_EXIT_INSN(),
4896 },
4897 INTERNAL,
4898 { },
4899 { { 0, -1 } },
4900 },
4901 /* BPF_ALU | BPF_MUL | BPF_X */
4902 {
4903 "ALU_MUL_X: 2 * 3 = 6",
4904 .u.insns_int = {
4905 BPF_LD_IMM64(R0, 2),
4906 BPF_ALU32_IMM(BPF_MOV, R1, 3),
4907 BPF_ALU32_REG(BPF_MUL, R0, R1),
4908 BPF_EXIT_INSN(),
4909 },
4910 INTERNAL,
4911 { },
4912 { { 0, 6 } },
4913 },
4914 {
4915 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
4916 .u.insns_int = {
4917 BPF_LD_IMM64(R0, 2),
4918 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
4919 BPF_ALU32_REG(BPF_MUL, R0, R1),
4920 BPF_EXIT_INSN(),
4921 },
4922 INTERNAL,
4923 { },
4924 { { 0, 0xFFFFFFF0 } },
4925 },
4926 {
4927 "ALU_MUL_X: -1 * -1 = 1",
4928 .u.insns_int = {
4929 BPF_LD_IMM64(R0, -1),
4930 BPF_ALU32_IMM(BPF_MOV, R1, -1),
4931 BPF_ALU32_REG(BPF_MUL, R0, R1),
4932 BPF_EXIT_INSN(),
4933 },
4934 INTERNAL,
4935 { },
4936 { { 0, 1 } },
4937 },
4938 {
4939 "ALU64_MUL_X: 2 * 3 = 6",
4940 .u.insns_int = {
4941 BPF_LD_IMM64(R0, 2),
4942 BPF_ALU32_IMM(BPF_MOV, R1, 3),
4943 BPF_ALU64_REG(BPF_MUL, R0, R1),
4944 BPF_EXIT_INSN(),
4945 },
4946 INTERNAL,
4947 { },
4948 { { 0, 6 } },
4949 },
4950 {
4951 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
4952 .u.insns_int = {
4953 BPF_LD_IMM64(R0, 1),
4954 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
4955 BPF_ALU64_REG(BPF_MUL, R0, R1),
4956 BPF_EXIT_INSN(),
4957 },
4958 INTERNAL,
4959 { },
4960 { { 0, 2147483647 } },
4961 },
faa57625
JA		 4962 {
4963 "ALU64_MUL_X: 64x64 multiply, low word",
4964 .u.insns_int = {
4965 BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
4966 BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
4967 BPF_ALU64_REG(BPF_MUL, R0, R1),
4968 BPF_EXIT_INSN(),
4969 },
4970 INTERNAL,
4971 { },
4972 { { 0, 0xe5618cf0 } }
4973 },
4974 {
4975 "ALU64_MUL_X: 64x64 multiply, high word",
4976 .u.insns_int = {
4977 BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
4978 BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
4979 BPF_ALU64_REG(BPF_MUL, R0, R1),
4980 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4981 BPF_EXIT_INSN(),
4982 },
4983 INTERNAL,
4984 { },
4985 { { 0, 0x2236d88f } }
4986 },
cffc642d
MH		 4987 /* BPF_ALU | BPF_MUL | BPF_K */
4988 {
4989 "ALU_MUL_K: 2 * 3 = 6",
4990 .u.insns_int = {
4991 BPF_LD_IMM64(R0, 2),
4992 BPF_ALU32_IMM(BPF_MUL, R0, 3),
4993 BPF_EXIT_INSN(),
4994 },
4995 INTERNAL,
4996 { },
4997 { { 0, 6 } },
4998 },
4999 {
5000 "ALU_MUL_K: 3 * 1 = 3",
5001 .u.insns_int = {
5002 BPF_LD_IMM64(R0, 3),
5003 BPF_ALU32_IMM(BPF_MUL, R0, 1),
5004 BPF_EXIT_INSN(),
5005 },
5006 INTERNAL,
5007 { },
5008 { { 0, 3 } },
5009 },
5010 {
5011 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
5012 .u.insns_int = {
5013 BPF_LD_IMM64(R0, 2),
5014 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
5015 BPF_EXIT_INSN(),
5016 },
5017 INTERNAL,
5018 { },
5019 { { 0, 0xFFFFFFF0 } },
5020 },
5021 {
5022 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
5023 .u.insns_int = {
5024 BPF_LD_IMM64(R2, 0x1),
5025 BPF_LD_IMM64(R3, 0x00000000ffffffff),
5026 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
5027 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5028 BPF_MOV32_IMM(R0, 2),
5029 BPF_EXIT_INSN(),
5030 BPF_MOV32_IMM(R0, 1),
5031 BPF_EXIT_INSN(),
5032 },
5033 INTERNAL,
5034 { },
5035 { { 0, 0x1 } },
5036 },
5037 {
5038 "ALU64_MUL_K: 2 * 3 = 6",
5039 .u.insns_int = {
5040 BPF_LD_IMM64(R0, 2),
5041 BPF_ALU64_IMM(BPF_MUL, R0, 3),
5042 BPF_EXIT_INSN(),
5043 },
5044 INTERNAL,
5045 { },
5046 { { 0, 6 } },
5047 },
5048 {
5049 "ALU64_MUL_K: 3 * 1 = 3",
5050 .u.insns_int = {
5051 BPF_LD_IMM64(R0, 3),
5052 BPF_ALU64_IMM(BPF_MUL, R0, 1),
5053 BPF_EXIT_INSN(),
5054 },
5055 INTERNAL,
5056 { },
5057 { { 0, 3 } },
5058 },
5059 {
5060 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
5061 .u.insns_int = {
5062 BPF_LD_IMM64(R0, 1),
5063 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
5064 BPF_EXIT_INSN(),
5065 },
5066 INTERNAL,
5067 { },
5068 { { 0, 2147483647 } },
5069 },
5070 {
5071 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
5072 .u.insns_int = {
5073 BPF_LD_IMM64(R0, 1),
5074 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
5075 BPF_EXIT_INSN(),
5076 },
5077 INTERNAL,
5078 { },
5079 { { 0, -2147483647 } },
5080 },
5081 {
5082 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
5083 .u.insns_int = {
5084 BPF_LD_IMM64(R2, 0x1),
56cbaa45 5085 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5086 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
5087 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5088 BPF_MOV32_IMM(R0, 2),
5089 BPF_EXIT_INSN(),
5090 BPF_MOV32_IMM(R0, 1),
5091 BPF_EXIT_INSN(),
5092 },
5093 INTERNAL,
5094 { },
5095 { { 0, 0x1 } },
5096 },
faa57625
JA		 5097 {
5098 "ALU64_MUL_K: 64x32 multiply, low word",
5099 .u.insns_int = {
5100 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5101 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5102 BPF_EXIT_INSN(),
5103 },
5104 INTERNAL,
5105 { },
5106 { { 0, 0xe242d208 } }
5107 },
5108 {
5109 "ALU64_MUL_K: 64x32 multiply, high word",
5110 .u.insns_int = {
5111 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5112 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
5113 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5114 BPF_EXIT_INSN(),
5115 },
5116 INTERNAL,
5117 { },
5118 { { 0, 0xc28f5c28 } }
5119 },
cffc642d
MH		 5120 /* BPF_ALU | BPF_DIV | BPF_X */
5121 {
5122 "ALU_DIV_X: 6 / 2 = 3",
5123 .u.insns_int = {
5124 BPF_LD_IMM64(R0, 6),
5125 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5126 BPF_ALU32_REG(BPF_DIV, R0, R1),
5127 BPF_EXIT_INSN(),
5128 },
5129 INTERNAL,
5130 { },
5131 { { 0, 3 } },
5132 },
5133 {
5134 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
5135 .u.insns_int = {
56cbaa45
MH		 5136 BPF_LD_IMM64(R0, 4294967295U),
5137 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 5138 BPF_ALU32_REG(BPF_DIV, R0, R1),
5139 BPF_EXIT_INSN(),
5140 },
5141 INTERNAL,
5142 { },
5143 { { 0, 1 } },
5144 },
5145 {
5146 "ALU64_DIV_X: 6 / 2 = 3",
5147 .u.insns_int = {
5148 BPF_LD_IMM64(R0, 6),
5149 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5150 BPF_ALU64_REG(BPF_DIV, R0, R1),
5151 BPF_EXIT_INSN(),
5152 },
5153 INTERNAL,
5154 { },
5155 { { 0, 3 } },
5156 },
5157 {
5158 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
5159 .u.insns_int = {
5160 BPF_LD_IMM64(R0, 2147483647),
5161 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
5162 BPF_ALU64_REG(BPF_DIV, R0, R1),
5163 BPF_EXIT_INSN(),
5164 },
5165 INTERNAL,
5166 { },
5167 { { 0, 1 } },
5168 },
5169 {
5170 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5171 .u.insns_int = {
56cbaa45
MH		 5172 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5173 BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
5174 BPF_LD_IMM64(R3, 0x0000000000000001LL),
cffc642d
MH		 5175 BPF_ALU64_REG(BPF_DIV, R2, R4),
5176 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5177 BPF_MOV32_IMM(R0, 2),
5178 BPF_EXIT_INSN(),
5179 BPF_MOV32_IMM(R0, 1),
5180 BPF_EXIT_INSN(),
5181 },
5182 INTERNAL,
5183 { },
5184 { { 0, 0x1 } },
5185 },
5186 /* BPF_ALU | BPF_DIV | BPF_K */
5187 {
5188 "ALU_DIV_K: 6 / 2 = 3",
5189 .u.insns_int = {
5190 BPF_LD_IMM64(R0, 6),
5191 BPF_ALU32_IMM(BPF_DIV, R0, 2),
5192 BPF_EXIT_INSN(),
5193 },
5194 INTERNAL,
5195 { },
5196 { { 0, 3 } },
5197 },
5198 {
5199 "ALU_DIV_K: 3 / 1 = 3",
5200 .u.insns_int = {
5201 BPF_LD_IMM64(R0, 3),
5202 BPF_ALU32_IMM(BPF_DIV, R0, 1),
5203 BPF_EXIT_INSN(),
5204 },
5205 INTERNAL,
5206 { },
5207 { { 0, 3 } },
5208 },
5209 {
5210 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
5211 .u.insns_int = {
56cbaa45
MH		 5212 BPF_LD_IMM64(R0, 4294967295U),
5213 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
cffc642d
MH		 5214 BPF_EXIT_INSN(),
5215 },
5216 INTERNAL,
5217 { },
5218 { { 0, 1 } },
5219 },
5220 {
5221 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
5222 .u.insns_int = {
56cbaa45 5223 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
cffc642d
MH		 5224 BPF_LD_IMM64(R3, 0x1UL),
5225 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
5226 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5227 BPF_MOV32_IMM(R0, 2),
5228 BPF_EXIT_INSN(),
5229 BPF_MOV32_IMM(R0, 1),
5230 BPF_EXIT_INSN(),
5231 },
5232 INTERNAL,
5233 { },
5234 { { 0, 0x1 } },
5235 },
5236 {
5237 "ALU64_DIV_K: 6 / 2 = 3",
5238 .u.insns_int = {
5239 BPF_LD_IMM64(R0, 6),
5240 BPF_ALU64_IMM(BPF_DIV, R0, 2),
5241 BPF_EXIT_INSN(),
5242 },
5243 INTERNAL,
5244 { },
5245 { { 0, 3 } },
5246 },
5247 {
5248 "ALU64_DIV_K: 3 / 1 = 3",
5249 .u.insns_int = {
5250 BPF_LD_IMM64(R0, 3),
5251 BPF_ALU64_IMM(BPF_DIV, R0, 1),
5252 BPF_EXIT_INSN(),
5253 },
5254 INTERNAL,
5255 { },
5256 { { 0, 3 } },
5257 },
5258 {
5259 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
5260 .u.insns_int = {
5261 BPF_LD_IMM64(R0, 2147483647),
5262 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
5263 BPF_EXIT_INSN(),
5264 },
5265 INTERNAL,
5266 { },
5267 { { 0, 1 } },
5268 },
5269 {
5270 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
5271 .u.insns_int = {
56cbaa45
MH		 5272 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5273 BPF_LD_IMM64(R3, 0x0000000000000001LL),
cffc642d
MH		 5274 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
5275 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5276 BPF_MOV32_IMM(R0, 2),
5277 BPF_EXIT_INSN(),
5278 BPF_MOV32_IMM(R0, 1),
5279 BPF_EXIT_INSN(),
5280 },
5281 INTERNAL,
5282 { },
5283 { { 0, 0x1 } },
5284 },
5285 /* BPF_ALU | BPF_MOD | BPF_X */
5286 {
5287 "ALU_MOD_X: 3 % 2 = 1",
5288 .u.insns_int = {
5289 BPF_LD_IMM64(R0, 3),
5290 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5291 BPF_ALU32_REG(BPF_MOD, R0, R1),
5292 BPF_EXIT_INSN(),
5293 },
5294 INTERNAL,
5295 { },
5296 { { 0, 1 } },
5297 },
5298 {
5299 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
5300 .u.insns_int = {
56cbaa45
MH		 5301 BPF_LD_IMM64(R0, 4294967295U),
5302 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
cffc642d
MH		 5303 BPF_ALU32_REG(BPF_MOD, R0, R1),
5304 BPF_EXIT_INSN(),
5305 },
5306 INTERNAL,
5307 { },
5308 { { 0, 2 } },
5309 },
5310 {
5311 "ALU64_MOD_X: 3 % 2 = 1",
5312 .u.insns_int = {
5313 BPF_LD_IMM64(R0, 3),
5314 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5315 BPF_ALU64_REG(BPF_MOD, R0, R1),
5316 BPF_EXIT_INSN(),
5317 },
5318 INTERNAL,
5319 { },
5320 { { 0, 1 } },
5321 },
5322 {
5323 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
5324 .u.insns_int = {
5325 BPF_LD_IMM64(R0, 2147483647),
5326 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
5327 BPF_ALU64_REG(BPF_MOD, R0, R1),
5328 BPF_EXIT_INSN(),
5329 },
5330 INTERNAL,
5331 { },
5332 { { 0, 2 } },
5333 },
5334 /* BPF_ALU | BPF_MOD | BPF_K */
5335 {
5336 "ALU_MOD_K: 3 % 2 = 1",
5337 .u.insns_int = {
5338 BPF_LD_IMM64(R0, 3),
5339 BPF_ALU32_IMM(BPF_MOD, R0, 2),
5340 BPF_EXIT_INSN(),
5341 },
5342 INTERNAL,
5343 { },
5344 { { 0, 1 } },
5345 },
5346 {
5347 "ALU_MOD_K: 3 % 1 = 0",
5348 .u.insns_int = {
5349 BPF_LD_IMM64(R0, 3),
5350 BPF_ALU32_IMM(BPF_MOD, R0, 1),
5351 BPF_EXIT_INSN(),
5352 },
5353 INTERNAL,
5354 { },
5355 { { 0, 0 } },
5356 },
5357 {
5358 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
5359 .u.insns_int = {
56cbaa45
MH		 5360 BPF_LD_IMM64(R0, 4294967295U),
5361 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
cffc642d
MH		 5362 BPF_EXIT_INSN(),
5363 },
5364 INTERNAL,
5365 { },
5366 { { 0, 2 } },
5367 },
5368 {
5369 "ALU64_MOD_K: 3 % 2 = 1",
5370 .u.insns_int = {
5371 BPF_LD_IMM64(R0, 3),
5372 BPF_ALU64_IMM(BPF_MOD, R0, 2),
5373 BPF_EXIT_INSN(),
5374 },
5375 INTERNAL,
5376 { },
5377 { { 0, 1 } },
5378 },
5379 {
5380 "ALU64_MOD_K: 3 % 1 = 0",
5381 .u.insns_int = {
5382 BPF_LD_IMM64(R0, 3),
5383 BPF_ALU64_IMM(BPF_MOD, R0, 1),
5384 BPF_EXIT_INSN(),
5385 },
5386 INTERNAL,
5387 { },
5388 { { 0, 0 } },
5389 },
5390 {
5391 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
5392 .u.insns_int = {
5393 BPF_LD_IMM64(R0, 2147483647),
5394 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
5395 BPF_EXIT_INSN(),
5396 },
5397 INTERNAL,
5398 { },
5399 { { 0, 2 } },
5400 },
5401 /* BPF_ALU | BPF_AND | BPF_X */
5402 {
5403 "ALU_AND_X: 3 & 2 = 2",
5404 .u.insns_int = {
5405 BPF_LD_IMM64(R0, 3),
5406 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5407 BPF_ALU32_REG(BPF_AND, R0, R1),
5408 BPF_EXIT_INSN(),
5409 },
5410 INTERNAL,
5411 { },
5412 { { 0, 2 } },
5413 },
5414 {
5415 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
5416 .u.insns_int = {
5417 BPF_LD_IMM64(R0, 0xffffffff),
5418 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5419 BPF_ALU32_REG(BPF_AND, R0, R1),
5420 BPF_EXIT_INSN(),
5421 },
5422 INTERNAL,
5423 { },
5424 { { 0, 0xffffffff } },
5425 },
5426 {
5427 "ALU64_AND_X: 3 & 2 = 2",
5428 .u.insns_int = {
5429 BPF_LD_IMM64(R0, 3),
5430 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5431 BPF_ALU64_REG(BPF_AND, R0, R1),
5432 BPF_EXIT_INSN(),
5433 },
5434 INTERNAL,
5435 { },
5436 { { 0, 2 } },
5437 },
5438 {
5439 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
5440 .u.insns_int = {
5441 BPF_LD_IMM64(R0, 0xffffffff),
5442 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5443 BPF_ALU64_REG(BPF_AND, R0, R1),
5444 BPF_EXIT_INSN(),
5445 },
5446 INTERNAL,
5447 { },
5448 { { 0, 0xffffffff } },
5449 },
5450 /* BPF_ALU | BPF_AND | BPF_K */
5451 {
5452 "ALU_AND_K: 3 & 2 = 2",
5453 .u.insns_int = {
5454 BPF_LD_IMM64(R0, 3),
5455 BPF_ALU32_IMM(BPF_AND, R0, 2),
5456 BPF_EXIT_INSN(),
5457 },
5458 INTERNAL,
5459 { },
5460 { { 0, 2 } },
5461 },
5462 {
5463 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
5464 .u.insns_int = {
5465 BPF_LD_IMM64(R0, 0xffffffff),
5466 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
5467 BPF_EXIT_INSN(),
5468 },
5469 INTERNAL,
5470 { },
5471 { { 0, 0xffffffff } },
5472 },
ba89bcf7
JA		 5473 {
5474 "ALU_AND_K: Small immediate",
5475 .u.insns_int = {
5476 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5477 BPF_ALU32_IMM(BPF_AND, R0, 15),
5478 BPF_EXIT_INSN(),
5479 },
5480 INTERNAL,
5481 { },
5482 { { 0, 4 } }
5483 },
5484 {
5485 "ALU_AND_K: Large immediate",
5486 .u.insns_int = {
5487 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
5488 BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
5489 BPF_EXIT_INSN(),
5490 },
5491 INTERNAL,
5492 { },
5493 { { 0, 0xa1b2c3d4 } }
5494 },
5495 {
5496 "ALU_AND_K: Zero extension",
5497 .u.insns_int = {
5498 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5499 BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
5500 BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
5501 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5502 BPF_MOV32_IMM(R0, 2),
5503 BPF_EXIT_INSN(),
5504 BPF_MOV32_IMM(R0, 1),
5505 BPF_EXIT_INSN(),
5506 },
5507 INTERNAL,
5508 { },
5509 { { 0, 1 } }
5510 },
cffc642d
MH		 5511 {
5512 "ALU64_AND_K: 3 & 2 = 2",
5513 .u.insns_int = {
5514 BPF_LD_IMM64(R0, 3),
5515 BPF_ALU64_IMM(BPF_AND, R0, 2),
5516 BPF_EXIT_INSN(),
5517 },
5518 INTERNAL,
5519 { },
5520 { { 0, 2 } },
5521 },
5522 {
5523 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
5524 .u.insns_int = {
5525 BPF_LD_IMM64(R0, 0xffffffff),
5526 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
5527 BPF_EXIT_INSN(),
5528 },
5529 INTERNAL,
5530 { },
5531 { { 0, 0xffffffff } },
5532 },
5533 {
e92c813b 5534 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
cffc642d 5535 .u.insns_int = {
56cbaa45
MH		 5536 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5537 BPF_LD_IMM64(R3, 0x0000000000000000LL),
cffc642d
MH		 5538 BPF_ALU64_IMM(BPF_AND, R2, 0x0),
5539 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5540 BPF_MOV32_IMM(R0, 2),
5541 BPF_EXIT_INSN(),
5542 BPF_MOV32_IMM(R0, 1),
5543 BPF_EXIT_INSN(),
5544 },
5545 INTERNAL,
5546 { },
5547 { { 0, 0x1 } },
5548 },
5549 {
e92c813b 5550 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
cffc642d 5551 .u.insns_int = {
56cbaa45
MH		 5552 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5553 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 5554 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
5555 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5556 BPF_MOV32_IMM(R0, 2),
5557 BPF_EXIT_INSN(),
5558 BPF_MOV32_IMM(R0, 1),
5559 BPF_EXIT_INSN(),
5560 },
5561 INTERNAL,
5562 { },
5563 { { 0, 0x1 } },
5564 },
5565 {
5566 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
5567 .u.insns_int = {
56cbaa45
MH		 5568 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
5569 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5570 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
5571 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5572 BPF_MOV32_IMM(R0, 2),
5573 BPF_EXIT_INSN(),
5574 BPF_MOV32_IMM(R0, 1),
5575 BPF_EXIT_INSN(),
5576 },
5577 INTERNAL,
5578 { },
5579 { { 0, 0x1 } },
5580 },
ba89bcf7
JA		 5581 {
5582 "ALU64_AND_K: Sign extension 1",
5583 .u.insns_int = {
5584 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5585 BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
5586 BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
5587 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5588 BPF_MOV32_IMM(R0, 2),
5589 BPF_EXIT_INSN(),
5590 BPF_MOV32_IMM(R0, 1),
5591 BPF_EXIT_INSN(),
5592 },
5593 INTERNAL,
5594 { },
5595 { { 0, 1 } }
5596 },
5597 {
5598 "ALU64_AND_K: Sign extension 2",
5599 .u.insns_int = {
5600 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5601 BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
5602 BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
5603 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5604 BPF_MOV32_IMM(R0, 2),
5605 BPF_EXIT_INSN(),
5606 BPF_MOV32_IMM(R0, 1),
5607 BPF_EXIT_INSN(),
5608 },
5609 INTERNAL,
5610 { },
5611 { { 0, 1 } }
5612 },
cffc642d
MH		 5613 /* BPF_ALU | BPF_OR | BPF_X */
5614 {
5615 "ALU_OR_X: 1 | 2 = 3",
5616 .u.insns_int = {
5617 BPF_LD_IMM64(R0, 1),
5618 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5619 BPF_ALU32_REG(BPF_OR, R0, R1),
5620 BPF_EXIT_INSN(),
5621 },
5622 INTERNAL,
5623 { },
5624 { { 0, 3 } },
5625 },
5626 {
5627 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
5628 .u.insns_int = {
5629 BPF_LD_IMM64(R0, 0),
5630 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5631 BPF_ALU32_REG(BPF_OR, R0, R1),
5632 BPF_EXIT_INSN(),
5633 },
5634 INTERNAL,
5635 { },
5636 { { 0, 0xffffffff } },
5637 },
5638 {
5639 "ALU64_OR_X: 1 | 2 = 3",
5640 .u.insns_int = {
5641 BPF_LD_IMM64(R0, 1),
5642 BPF_ALU32_IMM(BPF_MOV, R1, 2),
5643 BPF_ALU64_REG(BPF_OR, R0, R1),
5644 BPF_EXIT_INSN(),
5645 },
5646 INTERNAL,
5647 { },
5648 { { 0, 3 } },
5649 },
5650 {
5651 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
5652 .u.insns_int = {
5653 BPF_LD_IMM64(R0, 0),
5654 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5655 BPF_ALU64_REG(BPF_OR, R0, R1),
5656 BPF_EXIT_INSN(),
5657 },
5658 INTERNAL,
5659 { },
5660 { { 0, 0xffffffff } },
5661 },
5662 /* BPF_ALU | BPF_OR | BPF_K */
5663 {
5664 "ALU_OR_K: 1 | 2 = 3",
5665 .u.insns_int = {
5666 BPF_LD_IMM64(R0, 1),
5667 BPF_ALU32_IMM(BPF_OR, R0, 2),
5668 BPF_EXIT_INSN(),
5669 },
5670 INTERNAL,
5671 { },
5672 { { 0, 3 } },
5673 },
5674 {
5675 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
5676 .u.insns_int = {
5677 BPF_LD_IMM64(R0, 0),
5678 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
5679 BPF_EXIT_INSN(),
5680 },
5681 INTERNAL,
5682 { },
5683 { { 0, 0xffffffff } },
5684 },
ba89bcf7
JA		 5685 {
5686 "ALU_OR_K: Small immediate",
5687 .u.insns_int = {
5688 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5689 BPF_ALU32_IMM(BPF_OR, R0, 1),
5690 BPF_EXIT_INSN(),
5691 },
5692 INTERNAL,
5693 { },
5694 { { 0, 0x01020305 } }
5695 },
5696 {
5697 "ALU_OR_K: Large immediate",
5698 .u.insns_int = {
5699 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5700 BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
5701 BPF_EXIT_INSN(),
5702 },
5703 INTERNAL,
5704 { },
5705 { { 0, 0xa1b2c3d4 } }
5706 },
5707 {
5708 "ALU_OR_K: Zero extension",
5709 .u.insns_int = {
5710 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5711 BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
5712 BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
5713 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5714 BPF_MOV32_IMM(R0, 2),
5715 BPF_EXIT_INSN(),
5716 BPF_MOV32_IMM(R0, 1),
5717 BPF_EXIT_INSN(),
5718 },
5719 INTERNAL,
5720 { },
5721 { { 0, 1 } }
5722 },
cffc642d
MH		 5723 {
5724 "ALU64_OR_K: 1 | 2 = 3",
5725 .u.insns_int = {
5726 BPF_LD_IMM64(R0, 1),
5727 BPF_ALU64_IMM(BPF_OR, R0, 2),
5728 BPF_EXIT_INSN(),
5729 },
5730 INTERNAL,
5731 { },
5732 { { 0, 3 } },
5733 },
5734 {
5735 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
5736 .u.insns_int = {
5737 BPF_LD_IMM64(R0, 0),
5738 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
5739 BPF_EXIT_INSN(),
5740 },
5741 INTERNAL,
5742 { },
5743 { { 0, 0xffffffff } },
5744 },
5745 {
e92c813b 5746 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
cffc642d 5747 .u.insns_int = {
56cbaa45
MH		 5748 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5749 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 5750 BPF_ALU64_IMM(BPF_OR, R2, 0x0),
5751 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5752 BPF_MOV32_IMM(R0, 2),
5753 BPF_EXIT_INSN(),
5754 BPF_MOV32_IMM(R0, 1),
5755 BPF_EXIT_INSN(),
5756 },
5757 INTERNAL,
5758 { },
5759 { { 0, 0x1 } },
5760 },
5761 {
5762 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
5763 .u.insns_int = {
56cbaa45
MH		 5764 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5765 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5766 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
5767 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5768 BPF_MOV32_IMM(R0, 2),
5769 BPF_EXIT_INSN(),
5770 BPF_MOV32_IMM(R0, 1),
5771 BPF_EXIT_INSN(),
5772 },
5773 INTERNAL,
5774 { },
5775 { { 0, 0x1 } },
5776 },
5777 {
5778 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
5779 .u.insns_int = {
56cbaa45
MH		 5780 BPF_LD_IMM64(R2, 0x0000000000000000LL),
5781 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5782 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
5783 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5784 BPF_MOV32_IMM(R0, 2),
5785 BPF_EXIT_INSN(),
5786 BPF_MOV32_IMM(R0, 1),
5787 BPF_EXIT_INSN(),
5788 },
5789 INTERNAL,
5790 { },
5791 { { 0, 0x1 } },
5792 },
ba89bcf7
JA		 5793 {
5794 "ALU64_OR_K: Sign extension 1",
5795 .u.insns_int = {
5796 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5797 BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
5798 BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
5799 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5800 BPF_MOV32_IMM(R0, 2),
5801 BPF_EXIT_INSN(),
5802 BPF_MOV32_IMM(R0, 1),
5803 BPF_EXIT_INSN(),
5804 },
5805 INTERNAL,
5806 { },
5807 { { 0, 1 } }
5808 },
5809 {
5810 "ALU64_OR_K: Sign extension 2",
5811 .u.insns_int = {
5812 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5813 BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
5814 BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
5815 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5816 BPF_MOV32_IMM(R0, 2),
5817 BPF_EXIT_INSN(),
5818 BPF_MOV32_IMM(R0, 1),
5819 BPF_EXIT_INSN(),
5820 },
5821 INTERNAL,
5822 { },
5823 { { 0, 1 } }
5824 },
cffc642d
MH		 5825 /* BPF_ALU | BPF_XOR | BPF_X */
5826 {
5827 "ALU_XOR_X: 5 ^ 6 = 3",
5828 .u.insns_int = {
5829 BPF_LD_IMM64(R0, 5),
5830 BPF_ALU32_IMM(BPF_MOV, R1, 6),
5831 BPF_ALU32_REG(BPF_XOR, R0, R1),
5832 BPF_EXIT_INSN(),
5833 },
5834 INTERNAL,
5835 { },
5836 { { 0, 3 } },
5837 },
5838 {
5839 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
5840 .u.insns_int = {
5841 BPF_LD_IMM64(R0, 1),
5842 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5843 BPF_ALU32_REG(BPF_XOR, R0, R1),
5844 BPF_EXIT_INSN(),
5845 },
5846 INTERNAL,
5847 { },
5848 { { 0, 0xfffffffe } },
5849 },
5850 {
5851 "ALU64_XOR_X: 5 ^ 6 = 3",
5852 .u.insns_int = {
5853 BPF_LD_IMM64(R0, 5),
5854 BPF_ALU32_IMM(BPF_MOV, R1, 6),
5855 BPF_ALU64_REG(BPF_XOR, R0, R1),
5856 BPF_EXIT_INSN(),
5857 },
5858 INTERNAL,
5859 { },
5860 { { 0, 3 } },
5861 },
5862 {
5863 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
5864 .u.insns_int = {
5865 BPF_LD_IMM64(R0, 1),
5866 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5867 BPF_ALU64_REG(BPF_XOR, R0, R1),
5868 BPF_EXIT_INSN(),
5869 },
5870 INTERNAL,
5871 { },
5872 { { 0, 0xfffffffe } },
5873 },
5874 /* BPF_ALU | BPF_XOR | BPF_K */
5875 {
5876 "ALU_XOR_K: 5 ^ 6 = 3",
5877 .u.insns_int = {
5878 BPF_LD_IMM64(R0, 5),
5879 BPF_ALU32_IMM(BPF_XOR, R0, 6),
5880 BPF_EXIT_INSN(),
5881 },
5882 INTERNAL,
5883 { },
5884 { { 0, 3 } },
5885 },
5886 {
5887 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
5888 .u.insns_int = {
5889 BPF_LD_IMM64(R0, 1),
5890 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
5891 BPF_EXIT_INSN(),
5892 },
5893 INTERNAL,
5894 { },
5895 { { 0, 0xfffffffe } },
5896 },
ba89bcf7
JA		 5897 {
5898 "ALU_XOR_K: Small immediate",
5899 .u.insns_int = {
5900 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
5901 BPF_ALU32_IMM(BPF_XOR, R0, 15),
5902 BPF_EXIT_INSN(),
5903 },
5904 INTERNAL,
5905 { },
5906 { { 0, 0x0102030b } }
5907 },
5908 {
5909 "ALU_XOR_K: Large immediate",
5910 .u.insns_int = {
5911 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
5912 BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
5913 BPF_EXIT_INSN(),
5914 },
5915 INTERNAL,
5916 { },
5917 { { 0, 0x5e4d3c2b } }
5918 },
5919 {
5920 "ALU_XOR_K: Zero extension",
5921 .u.insns_int = {
5922 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5923 BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
5924 BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
5925 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
5926 BPF_MOV32_IMM(R0, 2),
5927 BPF_EXIT_INSN(),
5928 BPF_MOV32_IMM(R0, 1),
5929 BPF_EXIT_INSN(),
5930 },
5931 INTERNAL,
5932 { },
5933 { { 0, 1 } }
5934 },
cffc642d
MH		 5935 {
5936 "ALU64_XOR_K: 5 ^ 6 = 3",
5937 .u.insns_int = {
5938 BPF_LD_IMM64(R0, 5),
5939 BPF_ALU64_IMM(BPF_XOR, R0, 6),
5940 BPF_EXIT_INSN(),
5941 },
5942 INTERNAL,
5943 { },
5944 { { 0, 3 } },
5945 },
5946 {
e92c813b 5947 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
cffc642d
MH		 5948 .u.insns_int = {
5949 BPF_LD_IMM64(R0, 1),
5950 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
5951 BPF_EXIT_INSN(),
5952 },
5953 INTERNAL,
5954 { },
5955 { { 0, 0xfffffffe } },
5956 },
5957 {
5958 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
5959 .u.insns_int = {
56cbaa45
MH		 5960 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5961 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 5962 BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
5963 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5964 BPF_MOV32_IMM(R0, 2),
5965 BPF_EXIT_INSN(),
5966 BPF_MOV32_IMM(R0, 1),
5967 BPF_EXIT_INSN(),
5968 },
5969 INTERNAL,
5970 { },
5971 { { 0, 0x1 } },
5972 },
5973 {
5974 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
5975 .u.insns_int = {
56cbaa45
MH		 5976 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
5977 BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
cffc642d
MH		 5978 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
5979 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5980 BPF_MOV32_IMM(R0, 2),
5981 BPF_EXIT_INSN(),
5982 BPF_MOV32_IMM(R0, 1),
5983 BPF_EXIT_INSN(),
5984 },
5985 INTERNAL,
5986 { },
5987 { { 0, 0x1 } },
5988 },
5989 {
5990 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
5991 .u.insns_int = {
56cbaa45
MH		 5992 BPF_LD_IMM64(R2, 0x0000000000000000LL),
5993 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 5994 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
5995 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5996 BPF_MOV32_IMM(R0, 2),
5997 BPF_EXIT_INSN(),
5998 BPF_MOV32_IMM(R0, 1),
5999 BPF_EXIT_INSN(),
6000 },
6001 INTERNAL,
6002 { },
6003 { { 0, 0x1 } },
6004 },
ba89bcf7
JA		 6005 {
6006 "ALU64_XOR_K: Sign extension 1",
6007 .u.insns_int = {
6008 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6009 BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
6010 BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
6011 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6012 BPF_MOV32_IMM(R0, 2),
6013 BPF_EXIT_INSN(),
6014 BPF_MOV32_IMM(R0, 1),
6015 BPF_EXIT_INSN(),
6016 },
6017 INTERNAL,
6018 { },
6019 { { 0, 1 } }
6020 },
6021 {
6022 "ALU64_XOR_K: Sign extension 2",
6023 .u.insns_int = {
6024 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6025 BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
6026 BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
6027 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
6028 BPF_MOV32_IMM(R0, 2),
6029 BPF_EXIT_INSN(),
6030 BPF_MOV32_IMM(R0, 1),
6031 BPF_EXIT_INSN(),
6032 },
6033 INTERNAL,
6034 { },
6035 { { 0, 1 } }
6036 },
cffc642d
MH		 6037 /* BPF_ALU | BPF_LSH | BPF_X */
6038 {
6039 "ALU_LSH_X: 1 << 1 = 2",
6040 .u.insns_int = {
6041 BPF_LD_IMM64(R0, 1),
6042 BPF_ALU32_IMM(BPF_MOV, R1, 1),
6043 BPF_ALU32_REG(BPF_LSH, R0, R1),
6044 BPF_EXIT_INSN(),
6045 },
6046 INTERNAL,
6047 { },
6048 { { 0, 2 } },
6049 },
6050 {
6051 "ALU_LSH_X: 1 << 31 = 0x80000000",
6052 .u.insns_int = {
6053 BPF_LD_IMM64(R0, 1),
6054 BPF_ALU32_IMM(BPF_MOV, R1, 31),
6055 BPF_ALU32_REG(BPF_LSH, R0, R1),
6056 BPF_EXIT_INSN(),
6057 },
6058 INTERNAL,
6059 { },
6060 { { 0, 0x80000000 } },
6061 },
0f2fca1a
JA		 6062 {
6063 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
6064 .u.insns_int = {
6065 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6066 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6067 BPF_ALU32_REG(BPF_LSH, R0, R1),
6068 BPF_EXIT_INSN(),
6069 },
6070 INTERNAL,
6071 { },
6072 { { 0, 0x45678000 } }
6073 },
cffc642d
MH		 6074 {
6075 "ALU64_LSH_X: 1 << 1 = 2",
6076 .u.insns_int = {
6077 BPF_LD_IMM64(R0, 1),
6078 BPF_ALU32_IMM(BPF_MOV, R1, 1),
6079 BPF_ALU64_REG(BPF_LSH, R0, R1),
6080 BPF_EXIT_INSN(),
6081 },
6082 INTERNAL,
6083 { },
6084 { { 0, 2 } },
6085 },
6086 {
6087 "ALU64_LSH_X: 1 << 31 = 0x80000000",
6088 .u.insns_int = {
6089 BPF_LD_IMM64(R0, 1),
6090 BPF_ALU32_IMM(BPF_MOV, R1, 31),
6091 BPF_ALU64_REG(BPF_LSH, R0, R1),
6092 BPF_EXIT_INSN(),
6093 },
6094 INTERNAL,
6095 { },
6096 { { 0, 0x80000000 } },
6097 },
3b9890ef
JA		 6098 {
6099 "ALU64_LSH_X: Shift < 32, low word",
6100 .u.insns_int = {
6101 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6102 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6103 BPF_ALU64_REG(BPF_LSH, R0, R1),
6104 BPF_EXIT_INSN(),
6105 },
6106 INTERNAL,
6107 { },
6108 { { 0, 0xbcdef000 } }
6109 },
6110 {
6111 "ALU64_LSH_X: Shift < 32, high word",
6112 .u.insns_int = {
6113 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6114 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6115 BPF_ALU64_REG(BPF_LSH, R0, R1),
6116 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6117 BPF_EXIT_INSN(),
6118 },
6119 INTERNAL,
6120 { },
6121 { { 0, 0x3456789a } }
6122 },
6123 {
6124 "ALU64_LSH_X: Shift > 32, low word",
6125 .u.insns_int = {
6126 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6127 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6128 BPF_ALU64_REG(BPF_LSH, R0, R1),
6129 BPF_EXIT_INSN(),
6130 },
6131 INTERNAL,
6132 { },
6133 { { 0, 0 } }
6134 },
6135 {
6136 "ALU64_LSH_X: Shift > 32, high word",
6137 .u.insns_int = {
6138 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6139 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6140 BPF_ALU64_REG(BPF_LSH, R0, R1),
6141 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6142 BPF_EXIT_INSN(),
6143 },
6144 INTERNAL,
6145 { },
6146 { { 0, 0x9abcdef0 } }
6147 },
6148 {
6149 "ALU64_LSH_X: Shift == 32, low word",
6150 .u.insns_int = {
6151 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6152 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6153 BPF_ALU64_REG(BPF_LSH, R0, R1),
6154 BPF_EXIT_INSN(),
6155 },
6156 INTERNAL,
6157 { },
6158 { { 0, 0 } }
6159 },
6160 {
6161 "ALU64_LSH_X: Shift == 32, high word",
6162 .u.insns_int = {
6163 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6164 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6165 BPF_ALU64_REG(BPF_LSH, R0, R1),
6166 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6167 BPF_EXIT_INSN(),
6168 },
6169 INTERNAL,
6170 { },
6171 { { 0, 0x89abcdef } }
6172 },
6173 {
6174 "ALU64_LSH_X: Zero shift, low word",
6175 .u.insns_int = {
6176 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6177 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6178 BPF_ALU64_REG(BPF_LSH, R0, R1),
6179 BPF_EXIT_INSN(),
6180 },
6181 INTERNAL,
6182 { },
6183 { { 0, 0x89abcdef } }
6184 },
6185 {
6186 "ALU64_LSH_X: Zero shift, high word",
6187 .u.insns_int = {
6188 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6189 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6190 BPF_ALU64_REG(BPF_LSH, R0, R1),
6191 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6192 BPF_EXIT_INSN(),
6193 },
6194 INTERNAL,
6195 { },
6196 { { 0, 0x01234567 } }
6197 },
cffc642d
MH		 6198 /* BPF_ALU | BPF_LSH | BPF_K */
6199 {
6200 "ALU_LSH_K: 1 << 1 = 2",
6201 .u.insns_int = {
6202 BPF_LD_IMM64(R0, 1),
6203 BPF_ALU32_IMM(BPF_LSH, R0, 1),
6204 BPF_EXIT_INSN(),
6205 },
6206 INTERNAL,
6207 { },
6208 { { 0, 2 } },
6209 },
6210 {
6211 "ALU_LSH_K: 1 << 31 = 0x80000000",
6212 .u.insns_int = {
6213 BPF_LD_IMM64(R0, 1),
6214 BPF_ALU32_IMM(BPF_LSH, R0, 31),
6215 BPF_EXIT_INSN(),
6216 },
6217 INTERNAL,
6218 { },
6219 { { 0, 0x80000000 } },
6220 },
0f2fca1a
JA		 6221 {
6222 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
6223 .u.insns_int = {
6224 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6225 BPF_ALU32_IMM(BPF_LSH, R0, 12),
6226 BPF_EXIT_INSN(),
6227 },
6228 INTERNAL,
6229 { },
6230 { { 0, 0x45678000 } }
6231 },
6232 {
6233 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
6234 .u.insns_int = {
6235 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6236 BPF_ALU32_IMM(BPF_LSH, R0, 0),
6237 BPF_EXIT_INSN(),
6238 },
6239 INTERNAL,
6240 { },
6241 { { 0, 0x12345678 } }
6242 },
cffc642d
MH		 6243 {
6244 "ALU64_LSH_K: 1 << 1 = 2",
6245 .u.insns_int = {
6246 BPF_LD_IMM64(R0, 1),
6247 BPF_ALU64_IMM(BPF_LSH, R0, 1),
6248 BPF_EXIT_INSN(),
6249 },
6250 INTERNAL,
6251 { },
6252 { { 0, 2 } },
6253 },
6254 {
6255 "ALU64_LSH_K: 1 << 31 = 0x80000000",
6256 .u.insns_int = {
6257 BPF_LD_IMM64(R0, 1),
6258 BPF_ALU64_IMM(BPF_LSH, R0, 31),
6259 BPF_EXIT_INSN(),
6260 },
6261 INTERNAL,
6262 { },
6263 { { 0, 0x80000000 } },
6264 },
3b9890ef
JA		 6265 {
6266 "ALU64_LSH_K: Shift < 32, low word",
6267 .u.insns_int = {
6268 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6269 BPF_ALU64_IMM(BPF_LSH, R0, 12),
6270 BPF_EXIT_INSN(),
6271 },
6272 INTERNAL,
6273 { },
6274 { { 0, 0xbcdef000 } }
6275 },
6276 {
6277 "ALU64_LSH_K: Shift < 32, high word",
6278 .u.insns_int = {
6279 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6280 BPF_ALU64_IMM(BPF_LSH, R0, 12),
6281 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6282 BPF_EXIT_INSN(),
6283 },
6284 INTERNAL,
6285 { },
6286 { { 0, 0x3456789a } }
6287 },
6288 {
6289 "ALU64_LSH_K: Shift > 32, low word",
6290 .u.insns_int = {
6291 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6292 BPF_ALU64_IMM(BPF_LSH, R0, 36),
6293 BPF_EXIT_INSN(),
6294 },
6295 INTERNAL,
6296 { },
6297 { { 0, 0 } }
6298 },
6299 {
6300 "ALU64_LSH_K: Shift > 32, high word",
6301 .u.insns_int = {
6302 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6303 BPF_ALU64_IMM(BPF_LSH, R0, 36),
6304 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6305 BPF_EXIT_INSN(),
6306 },
6307 INTERNAL,
6308 { },
6309 { { 0, 0x9abcdef0 } }
6310 },
6311 {
6312 "ALU64_LSH_K: Shift == 32, low word",
6313 .u.insns_int = {
6314 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6315 BPF_ALU64_IMM(BPF_LSH, R0, 32),
6316 BPF_EXIT_INSN(),
6317 },
6318 INTERNAL,
6319 { },
6320 { { 0, 0 } }
6321 },
6322 {
6323 "ALU64_LSH_K: Shift == 32, high word",
6324 .u.insns_int = {
6325 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6326 BPF_ALU64_IMM(BPF_LSH, R0, 32),
6327 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6328 BPF_EXIT_INSN(),
6329 },
6330 INTERNAL,
6331 { },
6332 { { 0, 0x89abcdef } }
6333 },
6334 {
6335 "ALU64_LSH_K: Zero shift",
6336 .u.insns_int = {
6337 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6338 BPF_ALU64_IMM(BPF_LSH, R0, 0),
6339 BPF_EXIT_INSN(),
6340 },
6341 INTERNAL,
6342 { },
6343 { { 0, 0x89abcdef } }
6344 },
cffc642d
MH		 6345 /* BPF_ALU | BPF_RSH | BPF_X */
6346 {
6347 "ALU_RSH_X: 2 >> 1 = 1",
6348 .u.insns_int = {
6349 BPF_LD_IMM64(R0, 2),
6350 BPF_ALU32_IMM(BPF_MOV, R1, 1),
6351 BPF_ALU32_REG(BPF_RSH, R0, R1),
6352 BPF_EXIT_INSN(),
6353 },
6354 INTERNAL,
6355 { },
6356 { { 0, 1 } },
6357 },
6358 {
6359 "ALU_RSH_X: 0x80000000 >> 31 = 1",
6360 .u.insns_int = {
6361 BPF_LD_IMM64(R0, 0x80000000),
6362 BPF_ALU32_IMM(BPF_MOV, R1, 31),
6363 BPF_ALU32_REG(BPF_RSH, R0, R1),
6364 BPF_EXIT_INSN(),
6365 },
6366 INTERNAL,
6367 { },
6368 { { 0, 1 } },
6369 },
0f2fca1a
JA		 6370 {
6371 "ALU_RSH_X: 0x12345678 >> 20 = 0x123",
6372 .u.insns_int = {
6373 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6374 BPF_ALU32_IMM(BPF_MOV, R1, 20),
6375 BPF_ALU32_REG(BPF_RSH, R0, R1),
6376 BPF_EXIT_INSN(),
6377 },
6378 INTERNAL,
6379 { },
6380 { { 0, 0x123 } }
6381 },
cffc642d
MH		 6382 {
6383 "ALU64_RSH_X: 2 >> 1 = 1",
6384 .u.insns_int = {
6385 BPF_LD_IMM64(R0, 2),
6386 BPF_ALU32_IMM(BPF_MOV, R1, 1),
6387 BPF_ALU64_REG(BPF_RSH, R0, R1),
6388 BPF_EXIT_INSN(),
6389 },
6390 INTERNAL,
6391 { },
6392 { { 0, 1 } },
6393 },
6394 {
6395 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
6396 .u.insns_int = {
6397 BPF_LD_IMM64(R0, 0x80000000),
6398 BPF_ALU32_IMM(BPF_MOV, R1, 31),
6399 BPF_ALU64_REG(BPF_RSH, R0, R1),
6400 BPF_EXIT_INSN(),
6401 },
6402 INTERNAL,
6403 { },
6404 { { 0, 1 } },
6405 },
3b9890ef
JA		 6406 {
6407 "ALU64_RSH_X: Shift < 32, low word",
6408 .u.insns_int = {
6409 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6410 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6411 BPF_ALU64_REG(BPF_RSH, R0, R1),
6412 BPF_EXIT_INSN(),
6413 },
6414 INTERNAL,
6415 { },
6416 { { 0, 0x56789abc } }
6417 },
6418 {
6419 "ALU64_RSH_X: Shift < 32, high word",
6420 .u.insns_int = {
6421 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6422 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6423 BPF_ALU64_REG(BPF_RSH, R0, R1),
6424 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6425 BPF_EXIT_INSN(),
6426 },
6427 INTERNAL,
6428 { },
6429 { { 0, 0x00081234 } }
6430 },
6431 {
6432 "ALU64_RSH_X: Shift > 32, low word",
6433 .u.insns_int = {
6434 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6435 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6436 BPF_ALU64_REG(BPF_RSH, R0, R1),
6437 BPF_EXIT_INSN(),
6438 },
6439 INTERNAL,
6440 { },
6441 { { 0, 0x08123456 } }
6442 },
6443 {
6444 "ALU64_RSH_X: Shift > 32, high word",
6445 .u.insns_int = {
6446 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6447 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6448 BPF_ALU64_REG(BPF_RSH, R0, R1),
6449 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6450 BPF_EXIT_INSN(),
6451 },
6452 INTERNAL,
6453 { },
6454 { { 0, 0 } }
6455 },
6456 {
6457 "ALU64_RSH_X: Shift == 32, low word",
6458 .u.insns_int = {
6459 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6460 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6461 BPF_ALU64_REG(BPF_RSH, R0, R1),
6462 BPF_EXIT_INSN(),
6463 },
6464 INTERNAL,
6465 { },
6466 { { 0, 0x81234567 } }
6467 },
6468 {
6469 "ALU64_RSH_X: Shift == 32, high word",
6470 .u.insns_int = {
6471 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6472 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6473 BPF_ALU64_REG(BPF_RSH, R0, R1),
6474 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6475 BPF_EXIT_INSN(),
6476 },
6477 INTERNAL,
6478 { },
6479 { { 0, 0 } }
6480 },
6481 {
6482 "ALU64_RSH_X: Zero shift, low word",
6483 .u.insns_int = {
6484 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6485 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6486 BPF_ALU64_REG(BPF_RSH, R0, R1),
6487 BPF_EXIT_INSN(),
6488 },
6489 INTERNAL,
6490 { },
6491 { { 0, 0x89abcdef } }
6492 },
6493 {
6494 "ALU64_RSH_X: Zero shift, high word",
6495 .u.insns_int = {
6496 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6497 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6498 BPF_ALU64_REG(BPF_RSH, R0, R1),
6499 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6500 BPF_EXIT_INSN(),
6501 },
6502 INTERNAL,
6503 { },
6504 { { 0, 0x81234567 } }
6505 },
cffc642d
MH		 6506 /* BPF_ALU | BPF_RSH | BPF_K */
6507 {
6508 "ALU_RSH_K: 2 >> 1 = 1",
6509 .u.insns_int = {
6510 BPF_LD_IMM64(R0, 2),
6511 BPF_ALU32_IMM(BPF_RSH, R0, 1),
6512 BPF_EXIT_INSN(),
6513 },
6514 INTERNAL,
6515 { },
6516 { { 0, 1 } },
6517 },
6518 {
6519 "ALU_RSH_K: 0x80000000 >> 31 = 1",
6520 .u.insns_int = {
6521 BPF_LD_IMM64(R0, 0x80000000),
6522 BPF_ALU32_IMM(BPF_RSH, R0, 31),
6523 BPF_EXIT_INSN(),
6524 },
6525 INTERNAL,
6526 { },
6527 { { 0, 1 } },
6528 },
0f2fca1a
JA		 6529 {
6530 "ALU_RSH_K: 0x12345678 >> 20 = 0x123",
6531 .u.insns_int = {
6532 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6533 BPF_ALU32_IMM(BPF_RSH, R0, 20),
6534 BPF_EXIT_INSN(),
6535 },
6536 INTERNAL,
6537 { },
6538 { { 0, 0x123 } }
6539 },
6540 {
6541 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
6542 .u.insns_int = {
6543 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
6544 BPF_ALU32_IMM(BPF_RSH, R0, 0),
6545 BPF_EXIT_INSN(),
6546 },
6547 INTERNAL,
6548 { },
6549 { { 0, 0x12345678 } }
6550 },
cffc642d
MH		 6551 {
6552 "ALU64_RSH_K: 2 >> 1 = 1",
6553 .u.insns_int = {
6554 BPF_LD_IMM64(R0, 2),
6555 BPF_ALU64_IMM(BPF_RSH, R0, 1),
6556 BPF_EXIT_INSN(),
6557 },
6558 INTERNAL,
6559 { },
6560 { { 0, 1 } },
6561 },
6562 {
6563 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
6564 .u.insns_int = {
6565 BPF_LD_IMM64(R0, 0x80000000),
6566 BPF_ALU64_IMM(BPF_RSH, R0, 31),
6567 BPF_EXIT_INSN(),
6568 },
6569 INTERNAL,
6570 { },
6571 { { 0, 1 } },
6572 },
3b9890ef
JA		 6573 {
6574 "ALU64_RSH_K: Shift < 32, low word",
6575 .u.insns_int = {
6576 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6577 BPF_ALU64_IMM(BPF_RSH, R0, 12),
6578 BPF_EXIT_INSN(),
6579 },
6580 INTERNAL,
6581 { },
6582 { { 0, 0x56789abc } }
6583 },
6584 {
6585 "ALU64_RSH_K: Shift < 32, high word",
6586 .u.insns_int = {
6587 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6588 BPF_ALU64_IMM(BPF_RSH, R0, 12),
6589 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6590 BPF_EXIT_INSN(),
6591 },
6592 INTERNAL,
6593 { },
6594 { { 0, 0x00081234 } }
6595 },
6596 {
6597 "ALU64_RSH_K: Shift > 32, low word",
6598 .u.insns_int = {
6599 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6600 BPF_ALU64_IMM(BPF_RSH, R0, 36),
6601 BPF_EXIT_INSN(),
6602 },
6603 INTERNAL,
6604 { },
6605 { { 0, 0x08123456 } }
6606 },
6607 {
6608 "ALU64_RSH_K: Shift > 32, high word",
6609 .u.insns_int = {
6610 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6611 BPF_ALU64_IMM(BPF_RSH, R0, 36),
6612 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6613 BPF_EXIT_INSN(),
6614 },
6615 INTERNAL,
6616 { },
6617 { { 0, 0 } }
6618 },
6619 {
6620 "ALU64_RSH_K: Shift == 32, low word",
6621 .u.insns_int = {
6622 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6623 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6624 BPF_EXIT_INSN(),
6625 },
6626 INTERNAL,
6627 { },
6628 { { 0, 0x81234567 } }
6629 },
6630 {
6631 "ALU64_RSH_K: Shift == 32, high word",
6632 .u.insns_int = {
6633 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6634 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6635 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6636 BPF_EXIT_INSN(),
6637 },
6638 INTERNAL,
6639 { },
6640 { { 0, 0 } }
6641 },
6642 {
6643 "ALU64_RSH_K: Zero shift",
6644 .u.insns_int = {
6645 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6646 BPF_ALU64_IMM(BPF_RSH, R0, 0),
6647 BPF_EXIT_INSN(),
6648 },
6649 INTERNAL,
6650 { },
6651 { { 0, 0x89abcdef } }
6652 },
cffc642d 6653 /* BPF_ALU | BPF_ARSH | BPF_X */
0f2fca1a
JA		 6654 {
6655 "ALU32_ARSH_X: -1234 >> 7 = -10",
6656 .u.insns_int = {
6657 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6658 BPF_ALU32_IMM(BPF_MOV, R1, 7),
6659 BPF_ALU32_REG(BPF_ARSH, R0, R1),
6660 BPF_EXIT_INSN(),
6661 },
6662 INTERNAL,
6663 { },
6664 { { 0, -10 } }
6665 },
cffc642d 6666 {
3b9890ef 6667 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
cffc642d
MH		 6668 .u.insns_int = {
6669 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
6670 BPF_ALU32_IMM(BPF_MOV, R1, 40),
6671 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6672 BPF_EXIT_INSN(),
6673 },
6674 INTERNAL,
6675 { },
6676 { { 0, 0xffff00ff } },
6677 },
3b9890ef
JA		 6678 {
6679 "ALU64_ARSH_X: Shift < 32, low word",
6680 .u.insns_int = {
6681 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6682 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6683 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6684 BPF_EXIT_INSN(),
6685 },
6686 INTERNAL,
6687 { },
6688 { { 0, 0x56789abc } }
6689 },
6690 {
6691 "ALU64_ARSH_X: Shift < 32, high word",
6692 .u.insns_int = {
6693 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6694 BPF_ALU32_IMM(BPF_MOV, R1, 12),
6695 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6696 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6697 BPF_EXIT_INSN(),
6698 },
6699 INTERNAL,
6700 { },
6701 { { 0, 0xfff81234 } }
6702 },
6703 {
6704 "ALU64_ARSH_X: Shift > 32, low word",
6705 .u.insns_int = {
6706 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6707 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6708 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6709 BPF_EXIT_INSN(),
6710 },
6711 INTERNAL,
6712 { },
6713 { { 0, 0xf8123456 } }
6714 },
6715 {
6716 "ALU64_ARSH_X: Shift > 32, high word",
6717 .u.insns_int = {
6718 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6719 BPF_ALU32_IMM(BPF_MOV, R1, 36),
6720 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6721 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6722 BPF_EXIT_INSN(),
6723 },
6724 INTERNAL,
6725 { },
6726 { { 0, -1 } }
6727 },
6728 {
6729 "ALU64_ARSH_X: Shift == 32, low word",
6730 .u.insns_int = {
6731 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6732 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6733 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6734 BPF_EXIT_INSN(),
6735 },
6736 INTERNAL,
6737 { },
6738 { { 0, 0x81234567 } }
6739 },
6740 {
6741 "ALU64_ARSH_X: Shift == 32, high word",
6742 .u.insns_int = {
6743 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6744 BPF_ALU32_IMM(BPF_MOV, R1, 32),
6745 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6746 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6747 BPF_EXIT_INSN(),
6748 },
6749 INTERNAL,
6750 { },
6751 { { 0, -1 } }
6752 },
6753 {
6754 "ALU64_ARSH_X: Zero shift, low word",
6755 .u.insns_int = {
6756 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6757 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6758 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6759 BPF_EXIT_INSN(),
6760 },
6761 INTERNAL,
6762 { },
6763 { { 0, 0x89abcdef } }
6764 },
6765 {
6766 "ALU64_ARSH_X: Zero shift, high word",
6767 .u.insns_int = {
6768 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6769 BPF_ALU32_IMM(BPF_MOV, R1, 0),
6770 BPF_ALU64_REG(BPF_ARSH, R0, R1),
6771 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6772 BPF_EXIT_INSN(),
6773 },
6774 INTERNAL,
6775 { },
6776 { { 0, 0x81234567 } }
6777 },
cffc642d 6778 /* BPF_ALU | BPF_ARSH | BPF_K */
0f2fca1a
JA		 6779 {
6780 "ALU32_ARSH_K: -1234 >> 7 = -10",
6781 .u.insns_int = {
6782 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6783 BPF_ALU32_IMM(BPF_ARSH, R0, 7),
6784 BPF_EXIT_INSN(),
6785 },
6786 INTERNAL,
6787 { },
6788 { { 0, -10 } }
6789 },
6790 {
6791 "ALU32_ARSH_K: -1234 >> 0 = -1234",
6792 .u.insns_int = {
6793 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
6794 BPF_ALU32_IMM(BPF_ARSH, R0, 0),
6795 BPF_EXIT_INSN(),
6796 },
6797 INTERNAL,
6798 { },
6799 { { 0, -1234 } }
6800 },
cffc642d 6801 {
3b9890ef 6802 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
cffc642d
MH		 6803 .u.insns_int = {
6804 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
6805 BPF_ALU64_IMM(BPF_ARSH, R0, 40),
6806 BPF_EXIT_INSN(),
6807 },
6808 INTERNAL,
6809 { },
6810 { { 0, 0xffff00ff } },
6811 },
3b9890ef
JA		 6812 {
6813 "ALU64_ARSH_K: Shift < 32, low word",
6814 .u.insns_int = {
6815 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6816 BPF_ALU64_IMM(BPF_RSH, R0, 12),
6817 BPF_EXIT_INSN(),
6818 },
6819 INTERNAL,
6820 { },
6821 { { 0, 0x56789abc } }
6822 },
6823 {
6824 "ALU64_ARSH_K: Shift < 32, high word",
6825 .u.insns_int = {
6826 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6827 BPF_ALU64_IMM(BPF_ARSH, R0, 12),
6828 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6829 BPF_EXIT_INSN(),
6830 },
6831 INTERNAL,
6832 { },
6833 { { 0, 0xfff81234 } }
6834 },
6835 {
6836 "ALU64_ARSH_K: Shift > 32, low word",
6837 .u.insns_int = {
6838 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6839 BPF_ALU64_IMM(BPF_ARSH, R0, 36),
6840 BPF_EXIT_INSN(),
6841 },
6842 INTERNAL,
6843 { },
6844 { { 0, 0xf8123456 } }
6845 },
6846 {
6847 "ALU64_ARSH_K: Shift > 32, high word",
6848 .u.insns_int = {
6849 BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
6850 BPF_ALU64_IMM(BPF_ARSH, R0, 36),
6851 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6852 BPF_EXIT_INSN(),
6853 },
6854 INTERNAL,
6855 { },
6856 { { 0, -1 } }
6857 },
6858 {
6859 "ALU64_ARSH_K: Shift == 32, low word",
6860 .u.insns_int = {
6861 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6862 BPF_ALU64_IMM(BPF_ARSH, R0, 32),
6863 BPF_EXIT_INSN(),
6864 },
6865 INTERNAL,
6866 { },
6867 { { 0, 0x81234567 } }
6868 },
6869 {
6870 "ALU64_ARSH_K: Shift == 32, high word",
6871 .u.insns_int = {
6872 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6873 BPF_ALU64_IMM(BPF_ARSH, R0, 32),
6874 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6875 BPF_EXIT_INSN(),
6876 },
6877 INTERNAL,
6878 { },
6879 { { 0, -1 } }
6880 },
6881 {
1bda52f8 6882 "ALU64_ARSH_K: Zero shift",
3b9890ef
JA		 6883 .u.insns_int = {
6884 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
6885 BPF_ALU64_IMM(BPF_ARSH, R0, 0),
6886 BPF_EXIT_INSN(),
6887 },
6888 INTERNAL,
6889 { },
6890 { { 0, 0x89abcdef } }
6891 },
cffc642d
MH		 6892 /* BPF_ALU | BPF_NEG */
6893 {
6894 "ALU_NEG: -(3) = -3",
6895 .u.insns_int = {
6896 BPF_ALU32_IMM(BPF_MOV, R0, 3),
6897 BPF_ALU32_IMM(BPF_NEG, R0, 0),
6898 BPF_EXIT_INSN(),
6899 },
6900 INTERNAL,
6901 { },
6902 { { 0, -3 } },
6903 },
6904 {
6905 "ALU_NEG: -(-3) = 3",
6906 .u.insns_int = {
6907 BPF_ALU32_IMM(BPF_MOV, R0, -3),
6908 BPF_ALU32_IMM(BPF_NEG, R0, 0),
6909 BPF_EXIT_INSN(),
6910 },
6911 INTERNAL,
6912 { },
6913 { { 0, 3 } },
6914 },
6915 {
6916 "ALU64_NEG: -(3) = -3",
6917 .u.insns_int = {
6918 BPF_LD_IMM64(R0, 3),
6919 BPF_ALU64_IMM(BPF_NEG, R0, 0),
6920 BPF_EXIT_INSN(),
6921 },
6922 INTERNAL,
6923 { },
6924 { { 0, -3 } },
6925 },
6926 {
6927 "ALU64_NEG: -(-3) = 3",
6928 .u.insns_int = {
6929 BPF_LD_IMM64(R0, -3),
6930 BPF_ALU64_IMM(BPF_NEG, R0, 0),
6931 BPF_EXIT_INSN(),
6932 },
6933 INTERNAL,
6934 { },
6935 { { 0, 3 } },
6936 },
6937 /* BPF_ALU | BPF_END | BPF_FROM_BE */
6938 {
6939 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
6940 .u.insns_int = {
6941 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6942 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
6943 BPF_EXIT_INSN(),
6944 },
6945 INTERNAL,
6946 { },
6947 { { 0, cpu_to_be16(0xcdef) } },
6948 },
6949 {
6950 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
6951 .u.insns_int = {
6952 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6953 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
ba29becd
XW		 6954 BPF_ALU64_REG(BPF_MOV, R1, R0),
6955 BPF_ALU64_IMM(BPF_RSH, R1, 32),
6956 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
cffc642d
MH		 6957 BPF_EXIT_INSN(),
6958 },
6959 INTERNAL,
6960 { },
6961 { { 0, cpu_to_be32(0x89abcdef) } },
6962 },
6963 {
6964 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
6965 .u.insns_int = {
6966 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6967 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
6968 BPF_EXIT_INSN(),
6969 },
6970 INTERNAL,
6971 { },
6972 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
6973 },
f536a7c8
JA		 6974 {
6975 "ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
6976 .u.insns_int = {
6977 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
6978 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
6979 BPF_ALU64_IMM(BPF_RSH, R0, 32),
6980 BPF_EXIT_INSN(),
6981 },
6982 INTERNAL,
6983 { },
6984 { { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
6985 },
6986 /* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
6987 {
6988 "ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
6989 .u.insns_int = {
6990 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
6991 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
6992 BPF_EXIT_INSN(),
6993 },
6994 INTERNAL,
6995 { },
6996 { { 0, cpu_to_be16(0x3210) } },
6997 },
6998 {
6999 "ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
7000 .u.insns_int = {
7001 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7002 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
7003 BPF_ALU64_REG(BPF_MOV, R1, R0),
7004 BPF_ALU64_IMM(BPF_RSH, R1, 32),
7005 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7006 BPF_EXIT_INSN(),
7007 },
7008 INTERNAL,
7009 { },
7010 { { 0, cpu_to_be32(0x76543210) } },
7011 },
7012 {
7013 "ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
7014 .u.insns_int = {
7015 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7016 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7017 BPF_EXIT_INSN(),
7018 },
7019 INTERNAL,
7020 { },
7021 { { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
7022 },
7023 {
7024 "ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
7025 .u.insns_int = {
7026 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7027 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
7028 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7029 BPF_EXIT_INSN(),
7030 },
7031 INTERNAL,
7032 { },
7033 { { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
7034 },
cffc642d
MH		 7035 /* BPF_ALU | BPF_END | BPF_FROM_LE */
7036 {
7037 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
7038 .u.insns_int = {
7039 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7040 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7041 BPF_EXIT_INSN(),
7042 },
7043 INTERNAL,
7044 { },
7045 { { 0, cpu_to_le16(0xcdef) } },
7046 },
7047 {
7048 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
7049 .u.insns_int = {
7050 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7051 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
ba29becd
XW		 7052 BPF_ALU64_REG(BPF_MOV, R1, R0),
7053 BPF_ALU64_IMM(BPF_RSH, R1, 32),
7054 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
cffc642d
MH		 7055 BPF_EXIT_INSN(),
7056 },
7057 INTERNAL,
7058 { },
7059 { { 0, cpu_to_le32(0x89abcdef) } },
7060 },
7061 {
7062 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
7063 .u.insns_int = {
7064 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7065 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7066 BPF_EXIT_INSN(),
7067 },
7068 INTERNAL,
7069 { },
7070 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
7071 },
f536a7c8
JA		 7072 {
7073 "ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
7074 .u.insns_int = {
7075 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
7076 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7077 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7078 BPF_EXIT_INSN(),
7079 },
7080 INTERNAL,
7081 { },
7082 { { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
7083 },
7084 /* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
7085 {
7086 "ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
7087 .u.insns_int = {
7088 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7089 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
7090 BPF_EXIT_INSN(),
7091 },
7092 INTERNAL,
7093 { },
7094 { { 0, cpu_to_le16(0x3210) } },
7095 },
7096 {
7097 "ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
7098 .u.insns_int = {
7099 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7100 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
7101 BPF_ALU64_REG(BPF_MOV, R1, R0),
7102 BPF_ALU64_IMM(BPF_RSH, R1, 32),
7103 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
7104 BPF_EXIT_INSN(),
7105 },
7106 INTERNAL,
7107 { },
7108 { { 0, cpu_to_le32(0x76543210) } },
7109 },
7110 {
7111 "ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
7112 .u.insns_int = {
7113 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7114 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7115 BPF_EXIT_INSN(),
7116 },
7117 INTERNAL,
7118 { },
7119 { { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
7120 },
7121 {
7122 "ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
7123 .u.insns_int = {
7124 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
7125 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
7126 BPF_ALU64_IMM(BPF_RSH, R0, 32),
7127 BPF_EXIT_INSN(),
7128 },
7129 INTERNAL,
7130 { },
7131 { { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
7132 },
caaaa166
JA		 7133 /* BPF_LDX_MEM B/H/W/DW */
7134 {
7135 "BPF_LDX_MEM | BPF_B",
7136 .u.insns_int = {
7137 BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7138 BPF_LD_IMM64(R2, 0x0000000000000008ULL),
7139 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7140#ifdef __BIG_ENDIAN
7141 BPF_LDX_MEM(BPF_B, R0, R10, -1),
7142#else
7143 BPF_LDX_MEM(BPF_B, R0, R10, -8),
7144#endif
7145 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7146 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7147 BPF_EXIT_INSN(),
7148 },
7149 INTERNAL,
7150 { },
7151 { { 0, 0 } },
7152 .stack_depth = 8,
7153 },
7154 {
7155 "BPF_LDX_MEM | BPF_B, MSB set",
7156 .u.insns_int = {
7157 BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7158 BPF_LD_IMM64(R2, 0x0000000000000088ULL),
7159 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7160#ifdef __BIG_ENDIAN
7161 BPF_LDX_MEM(BPF_B, R0, R10, -1),
7162#else
7163 BPF_LDX_MEM(BPF_B, R0, R10, -8),
7164#endif
7165 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7166 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7167 BPF_EXIT_INSN(),
7168 },
7169 INTERNAL,
7170 { },
7171 { { 0, 0 } },
7172 .stack_depth = 8,
7173 },
7174 {
7175 "BPF_LDX_MEM | BPF_H",
7176 .u.insns_int = {
7177 BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7178 BPF_LD_IMM64(R2, 0x0000000000000708ULL),
7179 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7180#ifdef __BIG_ENDIAN
7181 BPF_LDX_MEM(BPF_H, R0, R10, -2),
7182#else
7183 BPF_LDX_MEM(BPF_H, R0, R10, -8),
7184#endif
7185 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7186 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7187 BPF_EXIT_INSN(),
7188 },
7189 INTERNAL,
7190 { },
7191 { { 0, 0 } },
7192 .stack_depth = 8,
7193 },
7194 {
7195 "BPF_LDX_MEM | BPF_H, MSB set",
7196 .u.insns_int = {
7197 BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7198 BPF_LD_IMM64(R2, 0x0000000000008788ULL),
7199 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7200#ifdef __BIG_ENDIAN
7201 BPF_LDX_MEM(BPF_H, R0, R10, -2),
7202#else
7203 BPF_LDX_MEM(BPF_H, R0, R10, -8),
7204#endif
7205 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7206 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7207 BPF_EXIT_INSN(),
7208 },
7209 INTERNAL,
7210 { },
7211 { { 0, 0 } },
7212 .stack_depth = 8,
7213 },
7214 {
7215 "BPF_LDX_MEM | BPF_W",
7216 .u.insns_int = {
7217 BPF_LD_IMM64(R1, 0x0102030405060708ULL),
7218 BPF_LD_IMM64(R2, 0x0000000005060708ULL),
7219 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7220#ifdef __BIG_ENDIAN
7221 BPF_LDX_MEM(BPF_W, R0, R10, -4),
7222#else
7223 BPF_LDX_MEM(BPF_W, R0, R10, -8),
7224#endif
7225 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7226 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7227 BPF_EXIT_INSN(),
7228 },
7229 INTERNAL,
7230 { },
7231 { { 0, 0 } },
7232 .stack_depth = 8,
7233 },
7234 {
7235 "BPF_LDX_MEM | BPF_W, MSB set",
7236 .u.insns_int = {
7237 BPF_LD_IMM64(R1, 0x8182838485868788ULL),
7238 BPF_LD_IMM64(R2, 0x0000000085868788ULL),
7239 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7240#ifdef __BIG_ENDIAN
7241 BPF_LDX_MEM(BPF_W, R0, R10, -4),
7242#else
7243 BPF_LDX_MEM(BPF_W, R0, R10, -8),
7244#endif
7245 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7246 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7247 BPF_EXIT_INSN(),
7248 },
7249 INTERNAL,
7250 { },
7251 { { 0, 0 } },
7252 .stack_depth = 8,
7253 },
7254 /* BPF_STX_MEM B/H/W/DW */
7255 {
7256 "BPF_STX_MEM | BPF_B",
7257 .u.insns_int = {
7258 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7259 BPF_LD_IMM64(R2, 0x0102030405060708ULL),
7260 BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
7261 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7262#ifdef __BIG_ENDIAN
7263 BPF_STX_MEM(BPF_B, R10, R2, -1),
7264#else
7265 BPF_STX_MEM(BPF_B, R10, R2, -8),
7266#endif
7267 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7268 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7269 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7270 BPF_EXIT_INSN(),
7271 },
7272 INTERNAL,
7273 { },
7274 { { 0, 0 } },
7275 .stack_depth = 8,
7276 },
7277 {
7278 "BPF_STX_MEM | BPF_B, MSB set",
7279 .u.insns_int = {
7280 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7281 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7282 BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
7283 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7284#ifdef __BIG_ENDIAN
7285 BPF_STX_MEM(BPF_B, R10, R2, -1),
7286#else
7287 BPF_STX_MEM(BPF_B, R10, R2, -8),
7288#endif
7289 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7290 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7291 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7292 BPF_EXIT_INSN(),
7293 },
7294 INTERNAL,
7295 { },
7296 { { 0, 0 } },
7297 .stack_depth = 8,
7298 },
7299 {
7300 "BPF_STX_MEM | BPF_H",
7301 .u.insns_int = {
7302 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7303 BPF_LD_IMM64(R2, 0x0102030405060708ULL),
7304 BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
7305 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7306#ifdef __BIG_ENDIAN
7307 BPF_STX_MEM(BPF_H, R10, R2, -2),
7308#else
7309 BPF_STX_MEM(BPF_H, R10, R2, -8),
7310#endif
7311 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7312 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7313 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7314 BPF_EXIT_INSN(),
7315 },
7316 INTERNAL,
7317 { },
7318 { { 0, 0 } },
7319 .stack_depth = 8,
7320 },
7321 {
7322 "BPF_STX_MEM | BPF_H, MSB set",
7323 .u.insns_int = {
7324 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7325 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7326 BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
7327 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7328#ifdef __BIG_ENDIAN
7329 BPF_STX_MEM(BPF_H, R10, R2, -2),
7330#else
7331 BPF_STX_MEM(BPF_H, R10, R2, -8),
7332#endif
7333 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7334 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7335 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7336 BPF_EXIT_INSN(),
7337 },
7338 INTERNAL,
7339 { },
7340 { { 0, 0 } },
7341 .stack_depth = 8,
7342 },
7343 {
7344 "BPF_STX_MEM | BPF_W",
7345 .u.insns_int = {
7346 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7347 BPF_LD_IMM64(R2, 0x0102030405060708ULL),
7348 BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
7349 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7350#ifdef __BIG_ENDIAN
7351 BPF_STX_MEM(BPF_W, R10, R2, -4),
7352#else
7353 BPF_STX_MEM(BPF_W, R10, R2, -8),
7354#endif
7355 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7356 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7357 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7358 BPF_EXIT_INSN(),
7359 },
7360 INTERNAL,
7361 { },
7362 { { 0, 0 } },
7363 .stack_depth = 8,
7364 },
7365 {
7366 "BPF_STX_MEM | BPF_W, MSB set",
7367 .u.insns_int = {
7368 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),
7369 BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7370 BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
7371 BPF_STX_MEM(BPF_DW, R10, R1, -8),
7372#ifdef __BIG_ENDIAN
7373 BPF_STX_MEM(BPF_W, R10, R2, -4),
7374#else
7375 BPF_STX_MEM(BPF_W, R10, R2, -8),
7376#endif
7377 BPF_LDX_MEM(BPF_DW, R0, R10, -8),
7378 BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7379 BPF_ALU64_IMM(BPF_MOV, R0, 0),
7380 BPF_EXIT_INSN(),
7381 },
7382 INTERNAL,
7383 { },
7384 { { 0, 0 } },
7385 .stack_depth = 8,
7386 },
cffc642d
MH		 7387 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
7388 {
7389 "ST_MEM_B: Store/Load byte: max negative",
7390 .u.insns_int = {
7391 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7392 BPF_ST_MEM(BPF_B, R10, -40, 0xff),
7393 BPF_LDX_MEM(BPF_B, R0, R10, -40),
7394 BPF_EXIT_INSN(),
7395 },
7396 INTERNAL,
7397 { },
7398 { { 0, 0xff } },
105c0361 7399 .stack_depth = 40,
cffc642d
MH		 7400 },
7401 {
7402 "ST_MEM_B: Store/Load byte: max positive",
7403 .u.insns_int = {
7404 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7405 BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
7406 BPF_LDX_MEM(BPF_H, R0, R10, -40),
7407 BPF_EXIT_INSN(),
7408 },
7409 INTERNAL,
7410 { },
7411 { { 0, 0x7f } },
105c0361 7412 .stack_depth = 40,
cffc642d
MH		 7413 },
7414 {
7415 "STX_MEM_B: Store/Load byte: max negative",
7416 .u.insns_int = {
7417 BPF_LD_IMM64(R0, 0),
7418 BPF_LD_IMM64(R1, 0xffLL),
7419 BPF_STX_MEM(BPF_B, R10, R1, -40),
7420 BPF_LDX_MEM(BPF_B, R0, R10, -40),
7421 BPF_EXIT_INSN(),
7422 },
7423 INTERNAL,
7424 { },
7425 { { 0, 0xff } },
105c0361 7426 .stack_depth = 40,
cffc642d
MH		 7427 },
7428 {
7429 "ST_MEM_H: Store/Load half word: max negative",
7430 .u.insns_int = {
7431 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7432 BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
7433 BPF_LDX_MEM(BPF_H, R0, R10, -40),
7434 BPF_EXIT_INSN(),
7435 },
7436 INTERNAL,
7437 { },
7438 { { 0, 0xffff } },
105c0361 7439 .stack_depth = 40,
cffc642d
MH		 7440 },
7441 {
7442 "ST_MEM_H: Store/Load half word: max positive",
7443 .u.insns_int = {
7444 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7445 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
7446 BPF_LDX_MEM(BPF_H, R0, R10, -40),
7447 BPF_EXIT_INSN(),
7448 },
7449 INTERNAL,
7450 { },
7451 { { 0, 0x7fff } },
105c0361 7452 .stack_depth = 40,
cffc642d
MH		 7453 },
7454 {
7455 "STX_MEM_H: Store/Load half word: max negative",
7456 .u.insns_int = {
7457 BPF_LD_IMM64(R0, 0),
7458 BPF_LD_IMM64(R1, 0xffffLL),
7459 BPF_STX_MEM(BPF_H, R10, R1, -40),
7460 BPF_LDX_MEM(BPF_H, R0, R10, -40),
7461 BPF_EXIT_INSN(),
7462 },
7463 INTERNAL,
7464 { },
7465 { { 0, 0xffff } },
105c0361 7466 .stack_depth = 40,
cffc642d
MH		 7467 },
7468 {
7469 "ST_MEM_W: Store/Load word: max negative",
7470 .u.insns_int = {
7471 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7472 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
7473 BPF_LDX_MEM(BPF_W, R0, R10, -40),
7474 BPF_EXIT_INSN(),
7475 },
7476 INTERNAL,
7477 { },
7478 { { 0, 0xffffffff } },
105c0361 7479 .stack_depth = 40,
cffc642d
MH		 7480 },
7481 {
7482 "ST_MEM_W: Store/Load word: max positive",
7483 .u.insns_int = {
7484 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7485 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
7486 BPF_LDX_MEM(BPF_W, R0, R10, -40),
7487 BPF_EXIT_INSN(),
7488 },
7489 INTERNAL,
7490 { },
7491 { { 0, 0x7fffffff } },
105c0361 7492 .stack_depth = 40,
cffc642d
MH		 7493 },
7494 {
7495 "STX_MEM_W: Store/Load word: max negative",
7496 .u.insns_int = {
7497 BPF_LD_IMM64(R0, 0),
7498 BPF_LD_IMM64(R1, 0xffffffffLL),
7499 BPF_STX_MEM(BPF_W, R10, R1, -40),
7500 BPF_LDX_MEM(BPF_W, R0, R10, -40),
7501 BPF_EXIT_INSN(),
7502 },
7503 INTERNAL,
7504 { },
7505 { { 0, 0xffffffff } },
105c0361 7506 .stack_depth = 40,
cffc642d
MH		 7507 },
7508 {
7509 "ST_MEM_DW: Store/Load double word: max negative",
7510 .u.insns_int = {
7511 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7512 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
7513 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7514 BPF_EXIT_INSN(),
7515 },
7516 INTERNAL,
7517 { },
7518 { { 0, 0xffffffff } },
105c0361 7519 .stack_depth = 40,
cffc642d
MH		 7520 },
7521 {
7522 "ST_MEM_DW: Store/Load double word: max negative 2",
7523 .u.insns_int = {
56cbaa45
MH		 7524 BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
7525 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 7526 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
7527 BPF_LDX_MEM(BPF_DW, R2, R10, -40),
7528 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
7529 BPF_MOV32_IMM(R0, 2),
7530 BPF_EXIT_INSN(),
7531 BPF_MOV32_IMM(R0, 1),
7532 BPF_EXIT_INSN(),
7533 },
7534 INTERNAL,
7535 { },
7536 { { 0, 0x1 } },
105c0361 7537 .stack_depth = 40,
cffc642d
MH		 7538 },
7539 {
7540 "ST_MEM_DW: Store/Load double word: max positive",
7541 .u.insns_int = {
7542 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7543 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
7544 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7545 BPF_EXIT_INSN(),
7546 },
7547 INTERNAL,
7548 { },
7549 { { 0, 0x7fffffff } },
105c0361 7550 .stack_depth = 40,
cffc642d
MH		 7551 },
7552 {
7553 "STX_MEM_DW: Store/Load double word: max negative",
7554 .u.insns_int = {
7555 BPF_LD_IMM64(R0, 0),
7556 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
ae7f4704
JA		 7557 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7558 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
cffc642d
MH		 7559 BPF_EXIT_INSN(),
7560 },
7561 INTERNAL,
7562 { },
7563 { { 0, 0xffffffff } },
105c0361 7564 .stack_depth = 40,
cffc642d 7565 },
e5009b46
JA		 7566 {
7567 "STX_MEM_DW: Store double word: first word in memory",
7568 .u.insns_int = {
7569 BPF_LD_IMM64(R0, 0),
7570 BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
7571 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7572 BPF_LDX_MEM(BPF_W, R0, R10, -40),
7573 BPF_EXIT_INSN(),
7574 },
7575 INTERNAL,
7576 { },
7577#ifdef __BIG_ENDIAN
7578 { { 0, 0x01234567 } },
7579#else
7580 { { 0, 0x89abcdef } },
7581#endif
7582 .stack_depth = 40,
7583 },
7584 {
7585 "STX_MEM_DW: Store double word: second word in memory",
7586 .u.insns_int = {
7587 BPF_LD_IMM64(R0, 0),
7588 BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
7589 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7590 BPF_LDX_MEM(BPF_W, R0, R10, -36),
7591 BPF_EXIT_INSN(),
7592 },
7593 INTERNAL,
7594 { },
7595#ifdef __BIG_ENDIAN
7596 { { 0, 0x89abcdef } },
7597#else
7598 { { 0, 0x01234567 } },
7599#endif
7600 .stack_depth = 40,
7601 },
91c960b0 7602 /* BPF_STX | BPF_ATOMIC | BPF_W/DW */
85f68fe8
DB		 7603 {
7604 "STX_XADD_W: X + 1 + 1 + 1 + ...",
7605 { },
7606 INTERNAL,
7607 { },
7608 { { 0, 4134 } },
7609 .fill_helper = bpf_fill_stxw,
7610 },
85f68fe8
DB		 7611 {
7612 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
7613 { },
7614 INTERNAL,
7615 { },
7616 { { 0, 4134 } },
7617 .fill_helper = bpf_fill_stxdw,
7618 },
e4517b36
JA		 7619 /*
7620 * Exhaustive tests of atomic operation variants.
7621 * Individual tests are expanded from template macros for all
7622 * combinations of ALU operation, word size and fetching.
7623 */
89b63462
JA		 7624#define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0)
7625
e4517b36
JA		 7626#define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result) \
7627{ \
7628 "BPF_ATOMIC | " #width ", " #op ": Test: " \
7629 #old " " #logic " " #update " = " #result, \
7630 .u.insns_int = { \
89b63462 7631 BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)), \
e4517b36
JA		 7632 BPF_ST_MEM(width, R10, -40, old), \
7633 BPF_ATOMIC_OP(width, op, R10, R5, -40), \
7634 BPF_LDX_MEM(width, R0, R10, -40), \
89b63462
JA		 7635 BPF_ALU64_REG(BPF_MOV, R1, R0), \
7636 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
7637 BPF_ALU64_REG(BPF_OR, R0, R1), \
e4517b36
JA		 7638 BPF_EXIT_INSN(), \
7639 }, \
7640 INTERNAL, \
7641 { }, \
7642 { { 0, result } }, \
7643 .stack_depth = 40, \
7644}
7645#define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result) \
7646{ \
7647 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: " \
7648 #old " " #logic " " #update " = " #result, \
7649 .u.insns_int = { \
7650 BPF_ALU64_REG(BPF_MOV, R1, R10), \
89b63462 7651 BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)), \
e4517b36
JA		 7652 BPF_ST_MEM(BPF_W, R10, -40, old), \
7653 BPF_ATOMIC_OP(width, op, R10, R0, -40), \
7654 BPF_ALU64_REG(BPF_MOV, R0, R10), \
7655 BPF_ALU64_REG(BPF_SUB, R0, R1), \
89b63462
JA		 7656 BPF_ALU64_REG(BPF_MOV, R1, R0), \
7657 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
7658 BPF_ALU64_REG(BPF_OR, R0, R1), \
e4517b36
JA		 7659 BPF_EXIT_INSN(), \
7660 }, \
7661 INTERNAL, \
7662 { }, \
7663 { { 0, 0 } }, \
7664 .stack_depth = 40, \
7665}
7666#define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result) \
7667{ \
7668 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: " \
7669 #old " " #logic " " #update " = " #result, \
7670 .u.insns_int = { \
7671 BPF_ALU64_REG(BPF_MOV, R0, R10), \
89b63462 7672 BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)), \
e4517b36
JA		 7673 BPF_ST_MEM(width, R10, -40, old), \
7674 BPF_ATOMIC_OP(width, op, R10, R1, -40), \
7675 BPF_ALU64_REG(BPF_SUB, R0, R10), \
89b63462
JA		 7676 BPF_ALU64_REG(BPF_MOV, R1, R0), \
7677 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
7678 BPF_ALU64_REG(BPF_OR, R0, R1), \
e4517b36
JA		 7679 BPF_EXIT_INSN(), \
7680 }, \
7681 INTERNAL, \
7682 { }, \
7683 { { 0, 0 } }, \
7684 .stack_depth = 40, \
7685}
7686#define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result) \
7687{ \
7688 "BPF_ATOMIC | " #width ", " #op ": Test fetch: " \
7689 #old " " #logic " " #update " = " #result, \
7690 .u.insns_int = { \
89b63462 7691 BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)), \
e4517b36
JA		 7692 BPF_ST_MEM(width, R10, -40, old), \
7693 BPF_ATOMIC_OP(width, op, R10, R3, -40), \
89b63462 7694 BPF_ALU32_REG(BPF_MOV, R0, R3), \
e4517b36
JA		 7695 BPF_EXIT_INSN(), \
7696 }, \
7697 INTERNAL, \
7698 { }, \
7699 { { 0, (op) & BPF_FETCH ? old : update } }, \
7700 .stack_depth = 40, \
7701}
7702 /* BPF_ATOMIC | BPF_W: BPF_ADD */
7703 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7704 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7705 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7706 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
7707 /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
7708 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7709 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7710 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7711 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7712 /* BPF_ATOMIC | BPF_DW: BPF_ADD */
7713 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7714 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7715 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7716 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
7717 /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
7718 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7719 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7720 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7721 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
7722 /* BPF_ATOMIC | BPF_W: BPF_AND */
7723 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7724 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7725 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7726 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
7727 /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
7728 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7729 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7730 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7731 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7732 /* BPF_ATOMIC | BPF_DW: BPF_AND */
7733 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7734 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7735 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7736 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
7737 /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
7738 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7739 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7740 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7741 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
7742 /* BPF_ATOMIC | BPF_W: BPF_OR */
7743 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7744 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7745 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7746 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
7747 /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
7748 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7749 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7750 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7751 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7752 /* BPF_ATOMIC | BPF_DW: BPF_OR */
7753 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7754 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7755 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7756 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
7757 /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
7758 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7759 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7760 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7761 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
7762 /* BPF_ATOMIC | BPF_W: BPF_XOR */
7763 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7764 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7765 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7766 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7767 /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
7768 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7769 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7770 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7771 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7772 /* BPF_ATOMIC | BPF_DW: BPF_XOR */
7773 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7774 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7775 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7776 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
7777 /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
7778 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7779 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7780 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7781 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
7782 /* BPF_ATOMIC | BPF_W: BPF_XCHG */
7783 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7784 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7785 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7786 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7787 /* BPF_ATOMIC | BPF_DW: BPF_XCHG */
7788 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7789 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7790 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
7791 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
89b63462 7792#undef BPF_ATOMIC_POISON
e4517b36
JA		 7793#undef BPF_ATOMIC_OP_TEST1
7794#undef BPF_ATOMIC_OP_TEST2
7795#undef BPF_ATOMIC_OP_TEST3
7796#undef BPF_ATOMIC_OP_TEST4
6a3b24ca
JA		 7797 /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
7798 {
7799 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
7800 .u.insns_int = {
7801 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7802 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7803 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7804 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7805 BPF_EXIT_INSN(),
7806 },
7807 INTERNAL,
7808 { },
7809 { { 0, 0x01234567 } },
7810 .stack_depth = 40,
7811 },
7812 {
7813 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
7814 .u.insns_int = {
7815 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7816 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7817 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7818 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7819 BPF_LDX_MEM(BPF_W, R0, R10, -40),
7820 BPF_EXIT_INSN(),
7821 },
7822 INTERNAL,
7823 { },
7824 { { 0, 0x89abcdef } },
7825 .stack_depth = 40,
7826 },
7827 {
7828 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
7829 .u.insns_int = {
7830 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7831 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
7832 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7833 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7834 BPF_EXIT_INSN(),
7835 },
7836 INTERNAL,
7837 { },
7838 { { 0, 0x01234567 } },
7839 .stack_depth = 40,
7840 },
7841 {
7842 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
7843 .u.insns_int = {
7844 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7845 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
7846 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7847 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7848 BPF_LDX_MEM(BPF_W, R0, R10, -40),
7849 BPF_EXIT_INSN(),
7850 },
7851 INTERNAL,
7852 { },
7853 { { 0, 0x01234567 } },
7854 .stack_depth = 40,
7855 },
7856 {
7857 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
7858 .u.insns_int = {
7859 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
7860 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
7861 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
7862 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7863 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
7864 BPF_ALU32_REG(BPF_MOV, R0, R3),
7865 BPF_EXIT_INSN(),
7866 },
7867 INTERNAL,
7868 { },
7869 { { 0, 0x89abcdef } },
7870 .stack_depth = 40,
7871 },
7872 /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
7873 {
7874 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
7875 .u.insns_int = {
7876 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
e42fc3c2 7877 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
6a3b24ca
JA		 7878 BPF_ALU64_REG(BPF_MOV, R0, R1),
7879 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7880 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7881 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
7882 BPF_ALU64_REG(BPF_SUB, R0, R1),
7883 BPF_EXIT_INSN(),
7884 },
7885 INTERNAL,
7886 { },
7887 { { 0, 0 } },
7888 .stack_depth = 40,
7889 },
7890 {
7891 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
7892 .u.insns_int = {
7893 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
e42fc3c2 7894 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
6a3b24ca
JA		 7895 BPF_ALU64_REG(BPF_MOV, R0, R1),
7896 BPF_STX_MEM(BPF_DW, R10, R0, -40),
7897 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7898 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7899 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7900 BPF_ALU64_REG(BPF_SUB, R0, R2),
7901 BPF_EXIT_INSN(),
7902 },
7903 INTERNAL,
7904 { },
7905 { { 0, 0 } },
7906 .stack_depth = 40,
7907 },
7908 {
7909 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
7910 .u.insns_int = {
7911 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
e42fc3c2 7912 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
6a3b24ca
JA		 7913 BPF_ALU64_REG(BPF_MOV, R0, R1),
7914 BPF_ALU64_IMM(BPF_ADD, R0, 1),
7915 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7916 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7917 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
7918 BPF_ALU64_REG(BPF_SUB, R0, R1),
7919 BPF_EXIT_INSN(),
7920 },
7921 INTERNAL,
7922 { },
7923 { { 0, 0 } },
7924 .stack_depth = 40,
7925 },
7926 {
7927 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
7928 .u.insns_int = {
7929 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
e42fc3c2 7930 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
6a3b24ca
JA		 7931 BPF_ALU64_REG(BPF_MOV, R0, R1),
7932 BPF_ALU64_IMM(BPF_ADD, R0, 1),
7933 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7934 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
7935 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
7936 BPF_JMP_REG(BPF_JNE, R0, R1, 1),
7937 BPF_ALU64_REG(BPF_SUB, R0, R1),
7938 BPF_EXIT_INSN(),
7939 },
7940 INTERNAL,
7941 { },
7942 { { 0, 0 } },
7943 .stack_depth = 40,
7944 },
7945 {
7946 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
7947 .u.insns_int = {
7948 BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
e42fc3c2 7949 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),
6a3b24ca
JA		 7950 BPF_ALU64_REG(BPF_MOV, R0, R1),
7951 BPF_STX_MEM(BPF_DW, R10, R1, -40),
7952 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
e42fc3c2 7953 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
6a3b24ca
JA		 7954 BPF_JMP_REG(BPF_JNE, R0, R2, 1),
7955 BPF_ALU64_REG(BPF_SUB, R0, R2),
7956 BPF_EXIT_INSN(),
7957 },
7958 INTERNAL,
7959 { },
7960 { { 0, 0 } },
7961 .stack_depth = 40,
7962 },
b55dfa85
JA		 7963 /* BPF_JMP32 | BPF_JEQ | BPF_K */
7964 {
7965 "JMP32_JEQ_K: Small immediate",
7966 .u.insns_int = {
7967 BPF_ALU32_IMM(BPF_MOV, R0, 123),
7968 BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
7969 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
7970 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7971 BPF_EXIT_INSN(),
7972 },
7973 INTERNAL,
7974 { },
7975 { { 0, 123 } }
7976 },
7977 {
7978 "JMP32_JEQ_K: Large immediate",
7979 .u.insns_int = {
7980 BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
7981 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
7982 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
7983 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7984 BPF_EXIT_INSN(),
7985 },
7986 INTERNAL,
7987 { },
7988 { { 0, 12345678 } }
7989 },
7990 {
7991 "JMP32_JEQ_K: negative immediate",
7992 .u.insns_int = {
7993 BPF_ALU32_IMM(BPF_MOV, R0, -123),
7994 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
7995 BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
7996 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7997 BPF_EXIT_INSN(),
7998 },
7999 INTERNAL,
8000 { },
8001 { { 0, -123 } }
8002 },
8003 /* BPF_JMP32 | BPF_JEQ | BPF_X */
8004 {
8005 "JMP32_JEQ_X",
8006 .u.insns_int = {
8007 BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8008 BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8009 BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
8010 BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8011 BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
8012 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8013 BPF_EXIT_INSN(),
8014 },
8015 INTERNAL,
8016 { },
8017 { { 0, 1234 } }
8018 },
8019 /* BPF_JMP32 | BPF_JNE | BPF_K */
8020 {
8021 "JMP32_JNE_K: Small immediate",
8022 .u.insns_int = {
8023 BPF_ALU32_IMM(BPF_MOV, R0, 123),
8024 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
8025 BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
8026 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8027 BPF_EXIT_INSN(),
8028 },
8029 INTERNAL,
8030 { },
8031 { { 0, 123 } }
8032 },
8033 {
8034 "JMP32_JNE_K: Large immediate",
8035 .u.insns_int = {
8036 BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
8037 BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
8038 BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
8039 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8040 BPF_EXIT_INSN(),
8041 },
8042 INTERNAL,
8043 { },
8044 { { 0, 12345678 } }
8045 },
8046 {
8047 "JMP32_JNE_K: negative immediate",
8048 .u.insns_int = {
8049 BPF_ALU32_IMM(BPF_MOV, R0, -123),
8050 BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
8051 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
8052 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8053 BPF_EXIT_INSN(),
8054 },
8055 INTERNAL,
8056 { },
8057 { { 0, -123 } }
8058 },
8059 /* BPF_JMP32 | BPF_JNE | BPF_X */
8060 {
8061 "JMP32_JNE_X",
8062 .u.insns_int = {
8063 BPF_ALU32_IMM(BPF_MOV, R0, 1234),
8064 BPF_ALU32_IMM(BPF_MOV, R1, 1234),
8065 BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
8066 BPF_ALU32_IMM(BPF_MOV, R1, 4321),
8067 BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
8068 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8069 BPF_EXIT_INSN(),
8070 },
8071 INTERNAL,
8072 { },
8073 { { 0, 1234 } }
8074 },
8075 /* BPF_JMP32 | BPF_JSET | BPF_K */
8076 {
8077 "JMP32_JSET_K: Small immediate",
8078 .u.insns_int = {
8079 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8080 BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
8081 BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
8082 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8083 BPF_EXIT_INSN(),
8084 },
8085 INTERNAL,
8086 { },
8087 { { 0, 1 } }
8088 },
8089 {
8090 "JMP32_JSET_K: Large immediate",
8091 .u.insns_int = {
8092 BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
8093 BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
8094 BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
8095 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8096 BPF_EXIT_INSN(),
8097 },
8098 INTERNAL,
8099 { },
8100 { { 0, 0x40000000 } }
8101 },
8102 {
8103 "JMP32_JSET_K: negative immediate",
8104 .u.insns_int = {
8105 BPF_ALU32_IMM(BPF_MOV, R0, -123),
8106 BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
8107 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8108 BPF_EXIT_INSN(),
8109 },
8110 INTERNAL,
8111 { },
8112 { { 0, -123 } }
8113 },
8114 /* BPF_JMP32 | BPF_JSET | BPF_X */
8115 {
8116 "JMP32_JSET_X",
8117 .u.insns_int = {
8118 BPF_ALU32_IMM(BPF_MOV, R0, 8),
8119 BPF_ALU32_IMM(BPF_MOV, R1, 7),
8120 BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
8121 BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
8122 BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
8123 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8124 BPF_EXIT_INSN(),
8125 },
8126 INTERNAL,
8127 { },
8128 { { 0, 8 } }
8129 },
8130 /* BPF_JMP32 | BPF_JGT | BPF_K */
8131 {
8132 "JMP32_JGT_K: Small immediate",
8133 .u.insns_int = {
8134 BPF_ALU32_IMM(BPF_MOV, R0, 123),
8135 BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
8136 BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
8137 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8138 BPF_EXIT_INSN(),
8139 },
8140 INTERNAL,
8141 { },
8142 { { 0, 123 } }
8143 },
8144 {
8145 "JMP32_JGT_K: Large immediate",
8146 .u.insns_int = {
8147 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8148 BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
8149 BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
8150 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8151 BPF_EXIT_INSN(),
8152 },
8153 INTERNAL,
8154 { },
8155 { { 0, 0xfffffffe } }
8156 },
8157 /* BPF_JMP32 | BPF_JGT | BPF_X */
8158 {
8159 "JMP32_JGT_X",
8160 .u.insns_int = {
8161 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8162 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8163 BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
8164 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8165 BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
8166 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8167 BPF_EXIT_INSN(),
8168 },
8169 INTERNAL,
8170 { },
8171 { { 0, 0xfffffffe } }
8172 },
8173 /* BPF_JMP32 | BPF_JGE | BPF_K */
8174 {
8175 "JMP32_JGE_K: Small immediate",
8176 .u.insns_int = {
8177 BPF_ALU32_IMM(BPF_MOV, R0, 123),
8178 BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
8179 BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
8180 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8181 BPF_EXIT_INSN(),
8182 },
8183 INTERNAL,
8184 { },
8185 { { 0, 123 } }
8186 },
8187 {
8188 "JMP32_JGE_K: Large immediate",
8189 .u.insns_int = {
8190 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8191 BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
8192 BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
8193 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8194 BPF_EXIT_INSN(),
8195 },
8196 INTERNAL,
8197 { },
8198 { { 0, 0xfffffffe } }
8199 },
8200 /* BPF_JMP32 | BPF_JGE | BPF_X */
8201 {
8202 "JMP32_JGE_X",
8203 .u.insns_int = {
8204 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8205 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8206 BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
8207 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
8208 BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
8209 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8210 BPF_EXIT_INSN(),
8211 },
8212 INTERNAL,
8213 { },
8214 { { 0, 0xfffffffe } }
8215 },
8216 /* BPF_JMP32 | BPF_JLT | BPF_K */
8217 {
8218 "JMP32_JLT_K: Small immediate",
8219 .u.insns_int = {
8220 BPF_ALU32_IMM(BPF_MOV, R0, 123),
8221 BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
8222 BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
8223 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8224 BPF_EXIT_INSN(),
8225 },
8226 INTERNAL,
8227 { },
8228 { { 0, 123 } }
8229 },
8230 {
8231 "JMP32_JLT_K: Large immediate",
8232 .u.insns_int = {
8233 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8234 BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
8235 BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
8236 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8237 BPF_EXIT_INSN(),
8238 },
8239 INTERNAL,
8240 { },
8241 { { 0, 0xfffffffe } }
8242 },
8243 /* BPF_JMP32 | BPF_JLT | BPF_X */
8244 {
8245 "JMP32_JLT_X",
8246 .u.insns_int = {
8247 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8248 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8249 BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
8250 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
8251 BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
8252 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8253 BPF_EXIT_INSN(),
8254 },
8255 INTERNAL,
8256 { },
8257 { { 0, 0xfffffffe } }
8258 },
8259 /* BPF_JMP32 | BPF_JLE | BPF_K */
8260 {
8261 "JMP32_JLE_K: Small immediate",
8262 .u.insns_int = {
8263 BPF_ALU32_IMM(BPF_MOV, R0, 123),
8264 BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
8265 BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
8266 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8267 BPF_EXIT_INSN(),
8268 },
8269 INTERNAL,
8270 { },
8271 { { 0, 123 } }
8272 },
8273 {
8274 "JMP32_JLE_K: Large immediate",
8275 .u.insns_int = {
8276 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8277 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
8278 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
8279 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8280 BPF_EXIT_INSN(),
8281 },
8282 INTERNAL,
8283 { },
8284 { { 0, 0xfffffffe } }
8285 },
8286 /* BPF_JMP32 | BPF_JLE | BPF_X */
8287 {
8288 "JMP32_JLE_X",
8289 .u.insns_int = {
8290 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
8291 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
8292 BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
8293 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
8294 BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
8295 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8296 BPF_EXIT_INSN(),
8297 },
8298 INTERNAL,
8299 { },
8300 { { 0, 0xfffffffe } }
8301 },
8302 /* BPF_JMP32 | BPF_JSGT | BPF_K */
8303 {
8304 "JMP32_JSGT_K: Small immediate",
8305 .u.insns_int = {
8306 BPF_ALU32_IMM(BPF_MOV, R0, -123),
8307 BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
8308 BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
8309 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8310 BPF_EXIT_INSN(),
8311 },
8312 INTERNAL,
8313 { },
8314 { { 0, -123 } }
8315 },
8316 {
8317 "JMP32_JSGT_K: Large immediate",
8318 .u.insns_int = {
8319 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8320 BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
8321 BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
8322 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8323 BPF_EXIT_INSN(),
8324 },
8325 INTERNAL,
8326 { },
8327 { { 0, -12345678 } }
8328 },
8329 /* BPF_JMP32 | BPF_JSGT | BPF_X */
8330 {
8331 "JMP32_JSGT_X",
8332 .u.insns_int = {
8333 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8334 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
8335 BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
8336 BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
8337 BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
8338 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8339 BPF_EXIT_INSN(),
8340 },
8341 INTERNAL,
8342 { },
8343 { { 0, -12345678 } }
8344 },
8345 /* BPF_JMP32 | BPF_JSGE | BPF_K */
8346 {
8347 "JMP32_JSGE_K: Small immediate",
8348 .u.insns_int = {
8349 BPF_ALU32_IMM(BPF_MOV, R0, -123),
8350 BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
8351 BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
8352 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8353 BPF_EXIT_INSN(),
8354 },
8355 INTERNAL,
8356 { },
8357 { { 0, -123 } }
8358 },
8359 {
8360 "JMP32_JSGE_K: Large immediate",
8361 .u.insns_int = {
8362 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8363 BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
8364 BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
8365 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8366 BPF_EXIT_INSN(),
8367 },
8368 INTERNAL,
8369 { },
8370 { { 0, -12345678 } }
8371 },
8372 /* BPF_JMP32 | BPF_JSGE | BPF_X */
8373 {
8374 "JMP32_JSGE_X",
8375 .u.insns_int = {
8376 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8377 BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
8378 BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
8379 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
8380 BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
8381 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8382 BPF_EXIT_INSN(),
8383 },
8384 INTERNAL,
8385 { },
8386 { { 0, -12345678 } }
8387 },
8388 /* BPF_JMP32 | BPF_JSLT | BPF_K */
8389 {
8390 "JMP32_JSLT_K: Small immediate",
8391 .u.insns_int = {
8392 BPF_ALU32_IMM(BPF_MOV, R0, -123),
8393 BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
8394 BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
8395 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8396 BPF_EXIT_INSN(),
8397 },
8398 INTERNAL,
8399 { },
8400 { { 0, -123 } }
8401 },
8402 {
8403 "JMP32_JSLT_K: Large immediate",
8404 .u.insns_int = {
8405 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8406 BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
8407 BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
8408 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8409 BPF_EXIT_INSN(),
8410 },
8411 INTERNAL,
8412 { },
8413 { { 0, -12345678 } }
8414 },
8415 /* BPF_JMP32 | BPF_JSLT | BPF_X */
8416 {
8417 "JMP32_JSLT_X",
8418 .u.insns_int = {
8419 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8420 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
8421 BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
8422 BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
8423 BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
8424 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8425 BPF_EXIT_INSN(),
8426 },
8427 INTERNAL,
8428 { },
8429 { { 0, -12345678 } }
8430 },
8431 /* BPF_JMP32 | BPF_JSLE | BPF_K */
8432 {
8433 "JMP32_JSLE_K: Small immediate",
8434 .u.insns_int = {
8435 BPF_ALU32_IMM(BPF_MOV, R0, -123),
8436 BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
8437 BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
8438 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8439 BPF_EXIT_INSN(),
8440 },
8441 INTERNAL,
8442 { },
8443 { { 0, -123 } }
8444 },
8445 {
8446 "JMP32_JSLE_K: Large immediate",
8447 .u.insns_int = {
8448 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8449 BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
8450 BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
8451 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8452 BPF_EXIT_INSN(),
8453 },
8454 INTERNAL,
8455 { },
8456 { { 0, -12345678 } }
8457 },
8458 /* BPF_JMP32 | BPF_JSLE | BPF_K */
8459 {
8460 "JMP32_JSLE_X",
8461 .u.insns_int = {
8462 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
8463 BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
8464 BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
8465 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
8466 BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
8467 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8468 BPF_EXIT_INSN(),
8469 },
8470 INTERNAL,
8471 { },
8472 { { 0, -12345678 } }
8473 },
cffc642d
MH		 8474 /* BPF_JMP | BPF_EXIT */
8475 {
8476 "JMP_EXIT",
8477 .u.insns_int = {
8478 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
8479 BPF_EXIT_INSN(),
8480 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
8481 },
8482 INTERNAL,
8483 { },
8484 { { 0, 0x4711 } },
8485 },
8486 /* BPF_JMP | BPF_JA */
8487 {
8488 "JMP_JA: Unconditional jump: if (true) return 1",
8489 .u.insns_int = {
8490 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8491 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
8492 BPF_EXIT_INSN(),
8493 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8494 BPF_EXIT_INSN(),
8495 },
8496 INTERNAL,
8497 { },
8498 { { 0, 1 } },
8499 },
92b31a9a
DB		 8500 /* BPF_JMP | BPF_JSLT | BPF_K */
8501 {
8502 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
8503 .u.insns_int = {
8504 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8505 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
8506 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
8507 BPF_EXIT_INSN(),
8508 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8509 BPF_EXIT_INSN(),
8510 },
8511 INTERNAL,
8512 { },
8513 { { 0, 1 } },
8514 },
8515 {
8516 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
8517 .u.insns_int = {
8518 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8519 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8520 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
8521 BPF_EXIT_INSN(),
8522 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8523 BPF_EXIT_INSN(),
8524 },
8525 INTERNAL,
8526 { },
8527 { { 0, 1 } },
8528 },
cffc642d
MH		 8529 /* BPF_JMP | BPF_JSGT | BPF_K */
8530 {
8531 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
8532 .u.insns_int = {
8533 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8534 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8535 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
8536 BPF_EXIT_INSN(),
8537 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8538 BPF_EXIT_INSN(),
8539 },
8540 INTERNAL,
8541 { },
8542 { { 0, 1 } },
8543 },
8544 {
8545 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
8546 .u.insns_int = {
8547 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8548 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8549 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
8550 BPF_EXIT_INSN(),
8551 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8552 BPF_EXIT_INSN(),
8553 },
8554 INTERNAL,
8555 { },
8556 { { 0, 1 } },
8557 },
92b31a9a
DB		 8558 /* BPF_JMP | BPF_JSLE | BPF_K */
8559 {
8560 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
8561 .u.insns_int = {
8562 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8563 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
8564 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
8565 BPF_EXIT_INSN(),
8566 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8567 BPF_EXIT_INSN(),
8568 },
8569 INTERNAL,
8570 { },
8571 { { 0, 1 } },
8572 },
8573 {
8574 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
8575 .u.insns_int = {
8576 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8577 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8578 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
8579 BPF_EXIT_INSN(),
8580 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8581 BPF_EXIT_INSN(),
8582 },
8583 INTERNAL,
8584 { },
8585 { { 0, 1 } },
8586 },
8587 {
8588 "JMP_JSLE_K: Signed jump: value walk 1",
8589 .u.insns_int = {
8590 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8591 BPF_LD_IMM64(R1, 3),
8592 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
8593 BPF_ALU64_IMM(BPF_SUB, R1, 1),
8594 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
8595 BPF_ALU64_IMM(BPF_SUB, R1, 1),
8596 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
8597 BPF_ALU64_IMM(BPF_SUB, R1, 1),
8598 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
8599 BPF_EXIT_INSN(), /* bad exit */
8600 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
8601 BPF_EXIT_INSN(),
8602 },
8603 INTERNAL,
8604 { },
8605 { { 0, 1 } },
8606 },
8607 {
8608 "JMP_JSLE_K: Signed jump: value walk 2",
8609 .u.insns_int = {
8610 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8611 BPF_LD_IMM64(R1, 3),
8612 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
8613 BPF_ALU64_IMM(BPF_SUB, R1, 2),
8614 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
8615 BPF_ALU64_IMM(BPF_SUB, R1, 2),
8616 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
8617 BPF_EXIT_INSN(), /* bad exit */
8618 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
8619 BPF_EXIT_INSN(),
8620 },
8621 INTERNAL,
8622 { },
8623 { { 0, 1 } },
8624 },
cffc642d
MH		 8625 /* BPF_JMP | BPF_JSGE | BPF_K */
8626 {
8627 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
8628 .u.insns_int = {
8629 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8630 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8631 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
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_JSGE_K: Signed jump: if (-1 >= -1) return 1",
8642 .u.insns_int = {
8643 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8644 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
8645 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
8646 BPF_EXIT_INSN(),
8647 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8648 BPF_EXIT_INSN(),
8649 },
8650 INTERNAL,
8651 { },
8652 { { 0, 1 } },
8653 },
791caeb0
DD		 8654 {
8655 "JMP_JSGE_K: Signed jump: value walk 1",
8656 .u.insns_int = {
8657 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8658 BPF_LD_IMM64(R1, -3),
8659 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
8660 BPF_ALU64_IMM(BPF_ADD, R1, 1),
8661 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
8662 BPF_ALU64_IMM(BPF_ADD, R1, 1),
8663 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
8664 BPF_ALU64_IMM(BPF_ADD, R1, 1),
8665 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
8666 BPF_EXIT_INSN(), /* bad exit */
8667 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
8668 BPF_EXIT_INSN(),
8669 },
8670 INTERNAL,
8671 { },
8672 { { 0, 1 } },
8673 },
8674 {
8675 "JMP_JSGE_K: Signed jump: value walk 2",
8676 .u.insns_int = {
8677 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8678 BPF_LD_IMM64(R1, -3),
8679 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
8680 BPF_ALU64_IMM(BPF_ADD, R1, 2),
8681 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
8682 BPF_ALU64_IMM(BPF_ADD, R1, 2),
8683 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
8684 BPF_EXIT_INSN(), /* bad exit */
8685 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
8686 BPF_EXIT_INSN(),
8687 },
8688 INTERNAL,
8689 { },
8690 { { 0, 1 } },
8691 },
cffc642d
MH		 8692 /* BPF_JMP | BPF_JGT | BPF_K */
8693 {
8694 "JMP_JGT_K: if (3 > 2) return 1",
8695 .u.insns_int = {
8696 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8697 BPF_LD_IMM64(R1, 3),
8698 BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
8699 BPF_EXIT_INSN(),
8700 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8701 BPF_EXIT_INSN(),
8702 },
8703 INTERNAL,
8704 { },
8705 { { 0, 1 } },
8706 },
c7395d6b
NR		 8707 {
8708 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
8709 .u.insns_int = {
8710 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8711 BPF_LD_IMM64(R1, -1),
8712 BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
8713 BPF_EXIT_INSN(),
8714 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8715 BPF_EXIT_INSN(),
8716 },
8717 INTERNAL,
8718 { },
8719 { { 0, 1 } },
8720 },
92b31a9a
DB		 8721 /* BPF_JMP | BPF_JLT | BPF_K */
8722 {
8723 "JMP_JLT_K: if (2 < 3) return 1",
8724 .u.insns_int = {
8725 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8726 BPF_LD_IMM64(R1, 2),
8727 BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
8728 BPF_EXIT_INSN(),
8729 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8730 BPF_EXIT_INSN(),
8731 },
8732 INTERNAL,
8733 { },
8734 { { 0, 1 } },
8735 },
8736 {
8737 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
8738 .u.insns_int = {
8739 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8740 BPF_LD_IMM64(R1, 1),
8741 BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
8742 BPF_EXIT_INSN(),
8743 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8744 BPF_EXIT_INSN(),
8745 },
8746 INTERNAL,
8747 { },
8748 { { 0, 1 } },
8749 },
cffc642d
MH		 8750 /* BPF_JMP | BPF_JGE | BPF_K */
8751 {
8752 "JMP_JGE_K: if (3 >= 2) return 1",
8753 .u.insns_int = {
8754 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8755 BPF_LD_IMM64(R1, 3),
8756 BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
8757 BPF_EXIT_INSN(),
8758 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8759 BPF_EXIT_INSN(),
8760 },
8761 INTERNAL,
8762 { },
8763 { { 0, 1 } },
8764 },
92b31a9a
DB		 8765 /* BPF_JMP | BPF_JLE | BPF_K */
8766 {
8767 "JMP_JLE_K: if (2 <= 3) return 1",
8768 .u.insns_int = {
8769 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8770 BPF_LD_IMM64(R1, 2),
8771 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
8772 BPF_EXIT_INSN(),
8773 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8774 BPF_EXIT_INSN(),
8775 },
8776 INTERNAL,
8777 { },
8778 { { 0, 1 } },
8779 },
fe593844
MH		 8780 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
8781 {
8782 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
8783 .u.insns_int = {
8784 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
8785 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
8786 BPF_EXIT_INSN(),
8787 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
8788 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
8789 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
8790 BPF_EXIT_INSN(),
8791 },
8792 INTERNAL,
8793 { },
8794 { { 0, 1 } },
8795 },
cffc642d
MH		 8796 {
8797 "JMP_JGE_K: if (3 >= 3) return 1",
8798 .u.insns_int = {
8799 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8800 BPF_LD_IMM64(R1, 3),
8801 BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
8802 BPF_EXIT_INSN(),
8803 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8804 BPF_EXIT_INSN(),
8805 },
8806 INTERNAL,
8807 { },
8808 { { 0, 1 } },
8809 },
92b31a9a
DB		 8810 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
8811 {
8812 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
8813 .u.insns_int = {
8814 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
8815 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
8816 BPF_EXIT_INSN(),
8817 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
8818 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
8819 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
8820 BPF_EXIT_INSN(),
8821 },
8822 INTERNAL,
8823 { },
8824 { { 0, 1 } },
8825 },
8826 {
8827 "JMP_JLE_K: if (3 <= 3) return 1",
8828 .u.insns_int = {
8829 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8830 BPF_LD_IMM64(R1, 3),
8831 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
8832 BPF_EXIT_INSN(),
8833 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8834 BPF_EXIT_INSN(),
8835 },
8836 INTERNAL,
8837 { },
8838 { { 0, 1 } },
8839 },
cffc642d
MH		 8840 /* BPF_JMP | BPF_JNE | BPF_K */
8841 {
8842 "JMP_JNE_K: if (3 != 2) return 1",
8843 .u.insns_int = {
8844 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8845 BPF_LD_IMM64(R1, 3),
8846 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
8847 BPF_EXIT_INSN(),
8848 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8849 BPF_EXIT_INSN(),
8850 },
8851 INTERNAL,
8852 { },
8853 { { 0, 1 } },
8854 },
8855 /* BPF_JMP | BPF_JEQ | BPF_K */
8856 {
8857 "JMP_JEQ_K: if (3 == 3) return 1",
8858 .u.insns_int = {
8859 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8860 BPF_LD_IMM64(R1, 3),
8861 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
8862 BPF_EXIT_INSN(),
8863 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8864 BPF_EXIT_INSN(),
8865 },
8866 INTERNAL,
8867 { },
8868 { { 0, 1 } },
8869 },
8870 /* BPF_JMP | BPF_JSET | BPF_K */
8871 {
8872 "JMP_JSET_K: if (0x3 & 0x2) return 1",
8873 .u.insns_int = {
8874 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8875 BPF_LD_IMM64(R1, 3),
9f134c34 8876 BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
cffc642d
MH		 8877 BPF_EXIT_INSN(),
8878 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8879 BPF_EXIT_INSN(),
8880 },
8881 INTERNAL,
8882 { },
8883 { { 0, 1 } },
8884 },
8885 {
8886 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
8887 .u.insns_int = {
8888 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8889 BPF_LD_IMM64(R1, 3),
9f134c34 8890 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
cffc642d
MH		 8891 BPF_EXIT_INSN(),
8892 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8893 BPF_EXIT_INSN(),
8894 },
8895 INTERNAL,
8896 { },
8897 { { 0, 1 } },
8898 },
8899 /* BPF_JMP | BPF_JSGT | BPF_X */
8900 {
8901 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
8902 .u.insns_int = {
8903 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8904 BPF_LD_IMM64(R1, -1),
8905 BPF_LD_IMM64(R2, -2),
8906 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
8907 BPF_EXIT_INSN(),
8908 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8909 BPF_EXIT_INSN(),
8910 },
8911 INTERNAL,
8912 { },
8913 { { 0, 1 } },
8914 },
8915 {
8916 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
8917 .u.insns_int = {
8918 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8919 BPF_LD_IMM64(R1, -1),
8920 BPF_LD_IMM64(R2, -1),
8921 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
8922 BPF_EXIT_INSN(),
8923 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8924 BPF_EXIT_INSN(),
8925 },
8926 INTERNAL,
8927 { },
8928 { { 0, 1 } },
8929 },
92b31a9a
DB		 8930 /* BPF_JMP | BPF_JSLT | BPF_X */
8931 {
8932 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
8933 .u.insns_int = {
8934 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8935 BPF_LD_IMM64(R1, -1),
8936 BPF_LD_IMM64(R2, -2),
8937 BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
8938 BPF_EXIT_INSN(),
8939 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8940 BPF_EXIT_INSN(),
8941 },
8942 INTERNAL,
8943 { },
8944 { { 0, 1 } },
8945 },
8946 {
8947 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
8948 .u.insns_int = {
8949 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8950 BPF_LD_IMM64(R1, -1),
8951 BPF_LD_IMM64(R2, -1),
8952 BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
8953 BPF_EXIT_INSN(),
8954 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8955 BPF_EXIT_INSN(),
8956 },
8957 INTERNAL,
8958 { },
8959 { { 0, 1 } },
8960 },
cffc642d
MH		 8961 /* BPF_JMP | BPF_JSGE | BPF_X */
8962 {
8963 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
8964 .u.insns_int = {
8965 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8966 BPF_LD_IMM64(R1, -1),
8967 BPF_LD_IMM64(R2, -2),
8968 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
8969 BPF_EXIT_INSN(),
8970 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8971 BPF_EXIT_INSN(),
8972 },
8973 INTERNAL,
8974 { },
8975 { { 0, 1 } },
8976 },
8977 {
8978 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
8979 .u.insns_int = {
8980 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8981 BPF_LD_IMM64(R1, -1),
8982 BPF_LD_IMM64(R2, -1),
8983 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
8984 BPF_EXIT_INSN(),
8985 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8986 BPF_EXIT_INSN(),
8987 },
8988 INTERNAL,
8989 { },
8990 { { 0, 1 } },
8991 },
92b31a9a
DB		 8992 /* BPF_JMP | BPF_JSLE | BPF_X */
8993 {
8994 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
8995 .u.insns_int = {
8996 BPF_ALU32_IMM(BPF_MOV, R0, 0),
8997 BPF_LD_IMM64(R1, -1),
8998 BPF_LD_IMM64(R2, -2),
8999 BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
9000 BPF_EXIT_INSN(),
9001 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9002 BPF_EXIT_INSN(),
9003 },
9004 INTERNAL,
9005 { },
9006 { { 0, 1 } },
9007 },
9008 {
9009 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
9010 .u.insns_int = {
9011 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9012 BPF_LD_IMM64(R1, -1),
9013 BPF_LD_IMM64(R2, -1),
9014 BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
9015 BPF_EXIT_INSN(),
9016 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9017 BPF_EXIT_INSN(),
9018 },
9019 INTERNAL,
9020 { },
9021 { { 0, 1 } },
9022 },
cffc642d
MH		 9023 /* BPF_JMP | BPF_JGT | BPF_X */
9024 {
9025 "JMP_JGT_X: if (3 > 2) return 1",
9026 .u.insns_int = {
9027 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9028 BPF_LD_IMM64(R1, 3),
9029 BPF_LD_IMM64(R2, 2),
9030 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
9031 BPF_EXIT_INSN(),
9032 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9033 BPF_EXIT_INSN(),
9034 },
9035 INTERNAL,
9036 { },
9037 { { 0, 1 } },
9038 },
c7395d6b
NR		 9039 {
9040 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
9041 .u.insns_int = {
9042 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9043 BPF_LD_IMM64(R1, -1),
9044 BPF_LD_IMM64(R2, 1),
9045 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
9046 BPF_EXIT_INSN(),
9047 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9048 BPF_EXIT_INSN(),
9049 },
9050 INTERNAL,
9051 { },
9052 { { 0, 1 } },
9053 },
92b31a9a
DB		 9054 /* BPF_JMP | BPF_JLT | BPF_X */
9055 {
9056 "JMP_JLT_X: if (2 < 3) return 1",
9057 .u.insns_int = {
9058 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9059 BPF_LD_IMM64(R1, 3),
9060 BPF_LD_IMM64(R2, 2),
9061 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
9062 BPF_EXIT_INSN(),
9063 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9064 BPF_EXIT_INSN(),
9065 },
9066 INTERNAL,
9067 { },
9068 { { 0, 1 } },
9069 },
9070 {
9071 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
9072 .u.insns_int = {
9073 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9074 BPF_LD_IMM64(R1, -1),
9075 BPF_LD_IMM64(R2, 1),
9076 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
9077 BPF_EXIT_INSN(),
9078 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9079 BPF_EXIT_INSN(),
9080 },
9081 INTERNAL,
9082 { },
9083 { { 0, 1 } },
9084 },
cffc642d
MH		 9085 /* BPF_JMP | BPF_JGE | BPF_X */
9086 {
9087 "JMP_JGE_X: if (3 >= 2) return 1",
9088 .u.insns_int = {
9089 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9090 BPF_LD_IMM64(R1, 3),
9091 BPF_LD_IMM64(R2, 2),
9092 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
9093 BPF_EXIT_INSN(),
9094 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9095 BPF_EXIT_INSN(),
9096 },
9097 INTERNAL,
9098 { },
9099 { { 0, 1 } },
9100 },
9101 {
9102 "JMP_JGE_X: if (3 >= 3) return 1",
9103 .u.insns_int = {
9104 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9105 BPF_LD_IMM64(R1, 3),
9106 BPF_LD_IMM64(R2, 3),
9107 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
9108 BPF_EXIT_INSN(),
9109 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9110 BPF_EXIT_INSN(),
9111 },
9112 INTERNAL,
9113 { },
9114 { { 0, 1 } },
9115 },
92b31a9a
DB		 9116 /* BPF_JMP | BPF_JLE | BPF_X */
9117 {
9118 "JMP_JLE_X: if (2 <= 3) return 1",
9119 .u.insns_int = {
9120 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9121 BPF_LD_IMM64(R1, 3),
9122 BPF_LD_IMM64(R2, 2),
9123 BPF_JMP_REG(BPF_JLE, R2, R1, 1),
9124 BPF_EXIT_INSN(),
9125 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9126 BPF_EXIT_INSN(),
9127 },
9128 INTERNAL,
9129 { },
9130 { { 0, 1 } },
9131 },
9132 {
9133 "JMP_JLE_X: if (3 <= 3) return 1",
9134 .u.insns_int = {
9135 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9136 BPF_LD_IMM64(R1, 3),
9137 BPF_LD_IMM64(R2, 3),
9138 BPF_JMP_REG(BPF_JLE, R1, R2, 1),
9139 BPF_EXIT_INSN(),
9140 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9141 BPF_EXIT_INSN(),
9142 },
9143 INTERNAL,
9144 { },
9145 { { 0, 1 } },
9146 },
ddc665a4
DB		 9147 {
9148 /* Mainly testing JIT + imm64 here. */
9149 "JMP_JGE_X: ldimm64 test 1",
9150 .u.insns_int = {
9151 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9152 BPF_LD_IMM64(R1, 3),
9153 BPF_LD_IMM64(R2, 2),
9154 BPF_JMP_REG(BPF_JGE, R1, R2, 2),
86f8e247
GU		 9155 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9156 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
ddc665a4
DB		 9157 BPF_EXIT_INSN(),
9158 },
9159 INTERNAL,
9160 { },
9161 { { 0, 0xeeeeeeeeU } },
9162 },
9163 {
9164 "JMP_JGE_X: ldimm64 test 2",
9165 .u.insns_int = {
9166 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9167 BPF_LD_IMM64(R1, 3),
9168 BPF_LD_IMM64(R2, 2),
9169 BPF_JMP_REG(BPF_JGE, R1, R2, 0),
86f8e247 9170 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
ddc665a4
DB		 9171 BPF_EXIT_INSN(),
9172 },
9173 INTERNAL,
9174 { },
9175 { { 0, 0xffffffffU } },
9176 },
9177 {
9178 "JMP_JGE_X: ldimm64 test 3",
9179 .u.insns_int = {
9180 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9181 BPF_LD_IMM64(R1, 3),
9182 BPF_LD_IMM64(R2, 2),
9183 BPF_JMP_REG(BPF_JGE, R1, R2, 4),
86f8e247
GU		 9184 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9185 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
ddc665a4
DB		 9186 BPF_EXIT_INSN(),
9187 },
9188 INTERNAL,
9189 { },
9190 { { 0, 1 } },
9191 },
92b31a9a
DB		 9192 {
9193 "JMP_JLE_X: ldimm64 test 1",
9194 .u.insns_int = {
9195 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9196 BPF_LD_IMM64(R1, 3),
9197 BPF_LD_IMM64(R2, 2),
9198 BPF_JMP_REG(BPF_JLE, R2, R1, 2),
9199 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9200 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9201 BPF_EXIT_INSN(),
9202 },
9203 INTERNAL,
9204 { },
9205 { { 0, 0xeeeeeeeeU } },
9206 },
9207 {
9208 "JMP_JLE_X: ldimm64 test 2",
9209 .u.insns_int = {
9210 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9211 BPF_LD_IMM64(R1, 3),
9212 BPF_LD_IMM64(R2, 2),
9213 BPF_JMP_REG(BPF_JLE, R2, R1, 0),
9214 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9215 BPF_EXIT_INSN(),
9216 },
9217 INTERNAL,
9218 { },
9219 { { 0, 0xffffffffU } },
9220 },
9221 {
9222 "JMP_JLE_X: ldimm64 test 3",
9223 .u.insns_int = {
9224 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9225 BPF_LD_IMM64(R1, 3),
9226 BPF_LD_IMM64(R2, 2),
9227 BPF_JMP_REG(BPF_JLE, R2, R1, 4),
9228 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
9229 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
9230 BPF_EXIT_INSN(),
9231 },
9232 INTERNAL,
9233 { },
9234 { { 0, 1 } },
9235 },
cffc642d
MH		 9236 /* BPF_JMP | BPF_JNE | BPF_X */
9237 {
9238 "JMP_JNE_X: if (3 != 2) return 1",
9239 .u.insns_int = {
9240 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9241 BPF_LD_IMM64(R1, 3),
9242 BPF_LD_IMM64(R2, 2),
9243 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
9244 BPF_EXIT_INSN(),
9245 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9246 BPF_EXIT_INSN(),
9247 },
9248 INTERNAL,
9249 { },
9250 { { 0, 1 } },
9251 },
9252 /* BPF_JMP | BPF_JEQ | BPF_X */
9253 {
9254 "JMP_JEQ_X: if (3 == 3) return 1",
9255 .u.insns_int = {
9256 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9257 BPF_LD_IMM64(R1, 3),
9258 BPF_LD_IMM64(R2, 3),
9259 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
9260 BPF_EXIT_INSN(),
9261 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9262 BPF_EXIT_INSN(),
9263 },
9264 INTERNAL,
9265 { },
9266 { { 0, 1 } },
9267 },
9268 /* BPF_JMP | BPF_JSET | BPF_X */
9269 {
9270 "JMP_JSET_X: if (0x3 & 0x2) return 1",
9271 .u.insns_int = {
9272 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9273 BPF_LD_IMM64(R1, 3),
9274 BPF_LD_IMM64(R2, 2),
9f134c34 9275 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
cffc642d
MH		 9276 BPF_EXIT_INSN(),
9277 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9278 BPF_EXIT_INSN(),
9279 },
9280 INTERNAL,
9281 { },
9282 { { 0, 1 } },
9283 },
9284 {
9285 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
9286 .u.insns_int = {
9287 BPF_ALU32_IMM(BPF_MOV, R0, 0),
9288 BPF_LD_IMM64(R1, 3),
9289 BPF_LD_IMM64(R2, 0xffffffff),
9f134c34 9290 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
cffc642d
MH		 9291 BPF_EXIT_INSN(),
9292 BPF_ALU32_IMM(BPF_MOV, R0, 1),
9293 BPF_EXIT_INSN(),
9294 },
9295 INTERNAL,
9296 { },
9297 { { 0, 1 } },
9298 },
bde28bc6
DB		 9299 {
9300 "JMP_JA: Jump, gap, jump, ...",
9301 { },
9302 CLASSIC | FLAG_NO_DATA,
9303 { },
9304 { { 0, 0xababcbac } },
9305 .fill_helper = bpf_fill_ja,
9306 },
a4afd37b
DB		 9307 { /* Mainly checking JIT here. */
9308 "BPF_MAXINSNS: Maximum possible literals",
9309 { },
9310 CLASSIC | FLAG_NO_DATA,
9311 { },
9312 { { 0, 0xffffffff } },
9313 .fill_helper = bpf_fill_maxinsns1,
9314 },
9315 { /* Mainly checking JIT here. */
9316 "BPF_MAXINSNS: Single literal",
9317 { },
9318 CLASSIC | FLAG_NO_DATA,
9319 { },
9320 { { 0, 0xfefefefe } },
9321 .fill_helper = bpf_fill_maxinsns2,
9322 },
9323 { /* Mainly checking JIT here. */
9324 "BPF_MAXINSNS: Run/add until end",
9325 { },
9326 CLASSIC | FLAG_NO_DATA,
9327 { },
9328 { { 0, 0x947bf368 } },
9329 .fill_helper = bpf_fill_maxinsns3,
9330 },
9331 {
9332 "BPF_MAXINSNS: Too many instructions",
9333 { },
9334 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9335 { },
9336 { },
9337 .fill_helper = bpf_fill_maxinsns4,
09584b40 9338 .expected_errcode = -EINVAL,
a4afd37b
DB		 9339 },
9340 { /* Mainly checking JIT here. */
9341 "BPF_MAXINSNS: Very long jump",
9342 { },
9343 CLASSIC | FLAG_NO_DATA,
9344 { },
9345 { { 0, 0xabababab } },
9346 .fill_helper = bpf_fill_maxinsns5,
9347 },
9348 { /* Mainly checking JIT here. */
9349 "BPF_MAXINSNS: Ctx heavy transformations",
9350 { },
9351 CLASSIC,
9352 { },
9353 {
0c4b2d37
MM		 9354 { 1, SKB_VLAN_PRESENT },
9355 { 10, SKB_VLAN_PRESENT }
a4afd37b
DB		 9356 },
9357 .fill_helper = bpf_fill_maxinsns6,
9358 },
9359 { /* Mainly checking JIT here. */
9360 "BPF_MAXINSNS: Call heavy transformations",
9361 { },
9362 CLASSIC | FLAG_NO_DATA,
9363 { },
9364 { { 1, 0 }, { 10, 0 } },
9365 .fill_helper = bpf_fill_maxinsns7,
9366 },
9367 { /* Mainly checking JIT here. */
9368 "BPF_MAXINSNS: Jump heavy test",
9369 { },
9370 CLASSIC | FLAG_NO_DATA,
9371 { },
9372 { { 0, 0xffffffff } },
9373 .fill_helper = bpf_fill_maxinsns8,
9374 },
3b529602
DB		 9375 { /* Mainly checking JIT here. */
9376 "BPF_MAXINSNS: Very long jump backwards",
9377 { },
9378 INTERNAL | FLAG_NO_DATA,
9379 { },
9380 { { 0, 0xcbababab } },
9381 .fill_helper = bpf_fill_maxinsns9,
9382 },
9383 { /* Mainly checking JIT here. */
9384 "BPF_MAXINSNS: Edge hopping nuthouse",
9385 { },
9386 INTERNAL | FLAG_NO_DATA,
9387 { },
9388 { { 0, 0xabababac } },
9389 .fill_helper = bpf_fill_maxinsns10,
9390 },
bde28bc6
DB		 9391 {
9392 "BPF_MAXINSNS: Jump, gap, jump, ...",
9393 { },
9394 CLASSIC | FLAG_NO_DATA,
9395 { },
9396 { { 0, 0xababcbac } },
9397 .fill_helper = bpf_fill_maxinsns11,
9398 },
be08815c
DB		 9399 {
9400 "BPF_MAXINSNS: jump over MSH",
9401 { },
9402 CLASSIC | FLAG_EXPECTED_FAIL,
9403 { 0xfa, 0xfb, 0xfc, 0xfd, },
9404 { { 4, 0xabababab } },
9405 .fill_helper = bpf_fill_maxinsns12,
9406 .expected_errcode = -EINVAL,
9407 },
9408 {
9409 "BPF_MAXINSNS: exec all MSH",
9410 { },
9411 CLASSIC,
9412 { 0xfa, 0xfb, 0xfc, 0xfd, },
9413 { { 4, 0xababab83 } },
9414 .fill_helper = bpf_fill_maxinsns13,
9415 },
4d9c5c53
AS		 9416 {
9417 "BPF_MAXINSNS: ld_abs+get_processor_id",
9418 { },
9419 CLASSIC,
9420 { },
9421 { { 1, 0xbee } },
9422 .fill_helper = bpf_fill_ld_abs_get_processor_id,
9423 },
2cf1ad75
NS		 9424 /*
9425 * LD_IND / LD_ABS on fragmented SKBs
9426 */
9427 {
9428 "LD_IND byte frag",
9429 .u.insns = {
9430 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9431 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
9432 BPF_STMT(BPF_RET | BPF_A, 0x0),
9433 },
9434 CLASSIC | FLAG_SKB_FRAG,
9435 { },
9436 { {0x40, 0x42} },
9437 .frag_data = {
9438 0x42, 0x00, 0x00, 0x00,
9439 0x43, 0x44, 0x00, 0x00,
9440 0x21, 0x07, 0x19, 0x83,
9441 },
9442 },
9443 {
9444 "LD_IND halfword frag",
9445 .u.insns = {
9446 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9447 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
9448 BPF_STMT(BPF_RET | BPF_A, 0x0),
9449 },
9450 CLASSIC | FLAG_SKB_FRAG,
9451 { },
9452 { {0x40, 0x4344} },
9453 .frag_data = {
9454 0x42, 0x00, 0x00, 0x00,
9455 0x43, 0x44, 0x00, 0x00,
9456 0x21, 0x07, 0x19, 0x83,
9457 },
9458 },
9459 {
9460 "LD_IND word frag",
9461 .u.insns = {
9462 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9463 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
9464 BPF_STMT(BPF_RET | BPF_A, 0x0),
9465 },
9466 CLASSIC | FLAG_SKB_FRAG,
9467 { },
9468 { {0x40, 0x21071983} },
9469 .frag_data = {
9470 0x42, 0x00, 0x00, 0x00,
9471 0x43, 0x44, 0x00, 0x00,
9472 0x21, 0x07, 0x19, 0x83,
9473 },
9474 },
9475 {
9476 "LD_IND halfword mixed head/frag",
9477 .u.insns = {
9478 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9479 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
9480 BPF_STMT(BPF_RET | BPF_A, 0x0),
9481 },
9482 CLASSIC | FLAG_SKB_FRAG,
9483 { [0x3e] = 0x25, [0x3f] = 0x05, },
9484 { {0x40, 0x0519} },
9485 .frag_data = { 0x19, 0x82 },
9486 },
9487 {
9488 "LD_IND word mixed head/frag",
9489 .u.insns = {
9490 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
9491 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
9492 BPF_STMT(BPF_RET | BPF_A, 0x0),
9493 },
9494 CLASSIC | FLAG_SKB_FRAG,
9495 { [0x3e] = 0x25, [0x3f] = 0x05, },
9496 { {0x40, 0x25051982} },
9497 .frag_data = { 0x19, 0x82 },
9498 },
9499 {
9500 "LD_ABS byte frag",
9501 .u.insns = {
9502 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
9503 BPF_STMT(BPF_RET | BPF_A, 0x0),
9504 },
9505 CLASSIC | FLAG_SKB_FRAG,
9506 { },
9507 { {0x40, 0x42} },
9508 .frag_data = {
9509 0x42, 0x00, 0x00, 0x00,
9510 0x43, 0x44, 0x00, 0x00,
9511 0x21, 0x07, 0x19, 0x83,
9512 },
9513 },
9514 {
9515 "LD_ABS halfword frag",
9516 .u.insns = {
9517 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
9518 BPF_STMT(BPF_RET | BPF_A, 0x0),
9519 },
9520 CLASSIC | FLAG_SKB_FRAG,
9521 { },
9522 { {0x40, 0x4344} },
9523 .frag_data = {
9524 0x42, 0x00, 0x00, 0x00,
9525 0x43, 0x44, 0x00, 0x00,
9526 0x21, 0x07, 0x19, 0x83,
9527 },
9528 },
9529 {
9530 "LD_ABS word frag",
9531 .u.insns = {
9532 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
9533 BPF_STMT(BPF_RET | BPF_A, 0x0),
9534 },
9535 CLASSIC | FLAG_SKB_FRAG,
9536 { },
9537 { {0x40, 0x21071983} },
9538 .frag_data = {
9539 0x42, 0x00, 0x00, 0x00,
9540 0x43, 0x44, 0x00, 0x00,
9541 0x21, 0x07, 0x19, 0x83,
9542 },
9543 },
9544 {
9545 "LD_ABS halfword mixed head/frag",
9546 .u.insns = {
9547 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
9548 BPF_STMT(BPF_RET | BPF_A, 0x0),
9549 },
9550 CLASSIC | FLAG_SKB_FRAG,
9551 { [0x3e] = 0x25, [0x3f] = 0x05, },
9552 { {0x40, 0x0519} },
9553 .frag_data = { 0x19, 0x82 },
9554 },
9555 {
9556 "LD_ABS word mixed head/frag",
9557 .u.insns = {
9558 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
9559 BPF_STMT(BPF_RET | BPF_A, 0x0),
9560 },
9561 CLASSIC | FLAG_SKB_FRAG,
9562 { [0x3e] = 0x25, [0x3f] = 0x05, },
9563 { {0x40, 0x25051982} },
9564 .frag_data = { 0x19, 0x82 },
9565 },
08fcb08f
NS		 9566 /*
9567 * LD_IND / LD_ABS on non fragmented SKBs
9568 */
9569 {
9570 /*
9571 * this tests that the JIT/interpreter correctly resets X
9572 * before using it in an LD_IND instruction.
9573 */
9574 "LD_IND byte default X",
9575 .u.insns = {
9576 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
9577 BPF_STMT(BPF_RET | BPF_A, 0x0),
9578 },
9579 CLASSIC,
9580 { [0x1] = 0x42 },
9581 { {0x40, 0x42 } },
9582 },
9583 {
9584 "LD_IND byte positive offset",
9585 .u.insns = {
9586 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9587 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
9588 BPF_STMT(BPF_RET | BPF_A, 0x0),
9589 },
9590 CLASSIC,
9591 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9592 { {0x40, 0x82 } },
9593 },
9594 {
9595 "LD_IND byte negative offset",
9596 .u.insns = {
9597 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9598 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
9599 BPF_STMT(BPF_RET | BPF_A, 0x0),
9600 },
9601 CLASSIC,
9602 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9603 { {0x40, 0x05 } },
9604 },
93731ef0
DB		 9605 {
9606 "LD_IND byte positive offset, all ff",
9607 .u.insns = {
9608 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9609 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
9610 BPF_STMT(BPF_RET | BPF_A, 0x0),
9611 },
9612 CLASSIC,
9613 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9614 { {0x40, 0xff } },
9615 },
9616 {
9617 "LD_IND byte positive offset, out of bounds",
9618 .u.insns = {
9619 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9620 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
9621 BPF_STMT(BPF_RET | BPF_A, 0x0),
9622 },
9623 CLASSIC,
9624 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9625 { {0x3f, 0 }, },
9626 },
9627 {
9628 "LD_IND byte negative offset, out of bounds",
9629 .u.insns = {
9630 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9631 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
9632 BPF_STMT(BPF_RET | BPF_A, 0x0),
9633 },
9634 CLASSIC,
9635 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9636 { {0x3f, 0 } },
9637 },
9638 {
9639 "LD_IND byte negative offset, multiple calls",
9640 .u.insns = {
9641 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
9642 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
9643 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
9644 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
9645 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
9646 BPF_STMT(BPF_RET | BPF_A, 0x0),
9647 },
9648 CLASSIC,
9649 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9650 { {0x40, 0x82 }, },
9651 },
08fcb08f
NS		 9652 {
9653 "LD_IND halfword positive offset",
9654 .u.insns = {
9655 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9656 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
9657 BPF_STMT(BPF_RET | BPF_A, 0x0),
9658 },
9659 CLASSIC,
9660 {
9661 [0x1c] = 0xaa, [0x1d] = 0x55,
9662 [0x1e] = 0xbb, [0x1f] = 0x66,
9663 [0x20] = 0xcc, [0x21] = 0x77,
9664 [0x22] = 0xdd, [0x23] = 0x88,
9665 },
9666 { {0x40, 0xdd88 } },
9667 },
9668 {
9669 "LD_IND halfword negative offset",
9670 .u.insns = {
9671 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9672 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
9673 BPF_STMT(BPF_RET | BPF_A, 0x0),
9674 },
9675 CLASSIC,
9676 {
9677 [0x1c] = 0xaa, [0x1d] = 0x55,
9678 [0x1e] = 0xbb, [0x1f] = 0x66,
9679 [0x20] = 0xcc, [0x21] = 0x77,
9680 [0x22] = 0xdd, [0x23] = 0x88,
9681 },
9682 { {0x40, 0xbb66 } },
9683 },
9684 {
9685 "LD_IND halfword unaligned",
9686 .u.insns = {
9687 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9688 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
9689 BPF_STMT(BPF_RET | BPF_A, 0x0),
9690 },
9691 CLASSIC,
9692 {
9693 [0x1c] = 0xaa, [0x1d] = 0x55,
9694 [0x1e] = 0xbb, [0x1f] = 0x66,
9695 [0x20] = 0xcc, [0x21] = 0x77,
9696 [0x22] = 0xdd, [0x23] = 0x88,
9697 },
9698 { {0x40, 0x66cc } },
9699 },
93731ef0
DB		 9700 {
9701 "LD_IND halfword positive offset, all ff",
9702 .u.insns = {
9703 BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
9704 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
9705 BPF_STMT(BPF_RET | BPF_A, 0x0),
9706 },
9707 CLASSIC,
9708 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9709 { {0x40, 0xffff } },
9710 },
9711 {
9712 "LD_IND halfword positive offset, out of bounds",
9713 .u.insns = {
9714 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9715 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
9716 BPF_STMT(BPF_RET | BPF_A, 0x0),
9717 },
9718 CLASSIC,
9719 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9720 { {0x3f, 0 }, },
9721 },
9722 {
9723 "LD_IND halfword negative offset, out of bounds",
9724 .u.insns = {
9725 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9726 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
9727 BPF_STMT(BPF_RET | BPF_A, 0x0),
9728 },
9729 CLASSIC,
9730 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9731 { {0x3f, 0 } },
9732 },
08fcb08f
NS		 9733 {
9734 "LD_IND word positive offset",
9735 .u.insns = {
9736 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9737 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
9738 BPF_STMT(BPF_RET | BPF_A, 0x0),
9739 },
9740 CLASSIC,
9741 {
9742 [0x1c] = 0xaa, [0x1d] = 0x55,
9743 [0x1e] = 0xbb, [0x1f] = 0x66,
9744 [0x20] = 0xcc, [0x21] = 0x77,
9745 [0x22] = 0xdd, [0x23] = 0x88,
9746 [0x24] = 0xee, [0x25] = 0x99,
9747 [0x26] = 0xff, [0x27] = 0xaa,
9748 },
9749 { {0x40, 0xee99ffaa } },
9750 },
9751 {
9752 "LD_IND word negative offset",
9753 .u.insns = {
9754 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9755 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
9756 BPF_STMT(BPF_RET | BPF_A, 0x0),
9757 },
9758 CLASSIC,
9759 {
9760 [0x1c] = 0xaa, [0x1d] = 0x55,
9761 [0x1e] = 0xbb, [0x1f] = 0x66,
9762 [0x20] = 0xcc, [0x21] = 0x77,
9763 [0x22] = 0xdd, [0x23] = 0x88,
9764 [0x24] = 0xee, [0x25] = 0x99,
9765 [0x26] = 0xff, [0x27] = 0xaa,
9766 },
9767 { {0x40, 0xaa55bb66 } },
9768 },
9769 {
9770 "LD_IND word unaligned (addr & 3 == 2)",
9771 .u.insns = {
9772 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9773 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
9774 BPF_STMT(BPF_RET | BPF_A, 0x0),
9775 },
9776 CLASSIC,
9777 {
9778 [0x1c] = 0xaa, [0x1d] = 0x55,
9779 [0x1e] = 0xbb, [0x1f] = 0x66,
9780 [0x20] = 0xcc, [0x21] = 0x77,
9781 [0x22] = 0xdd, [0x23] = 0x88,
9782 [0x24] = 0xee, [0x25] = 0x99,
9783 [0x26] = 0xff, [0x27] = 0xaa,
9784 },
9785 { {0x40, 0xbb66cc77 } },
9786 },
9787 {
9788 "LD_IND word unaligned (addr & 3 == 1)",
9789 .u.insns = {
9790 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9791 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
9792 BPF_STMT(BPF_RET | BPF_A, 0x0),
9793 },
9794 CLASSIC,
9795 {
9796 [0x1c] = 0xaa, [0x1d] = 0x55,
9797 [0x1e] = 0xbb, [0x1f] = 0x66,
9798 [0x20] = 0xcc, [0x21] = 0x77,
9799 [0x22] = 0xdd, [0x23] = 0x88,
9800 [0x24] = 0xee, [0x25] = 0x99,
9801 [0x26] = 0xff, [0x27] = 0xaa,
9802 },
9803 { {0x40, 0x55bb66cc } },
9804 },
9805 {
9806 "LD_IND word unaligned (addr & 3 == 3)",
9807 .u.insns = {
9808 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
9809 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
9810 BPF_STMT(BPF_RET | BPF_A, 0x0),
9811 },
9812 CLASSIC,
9813 {
9814 [0x1c] = 0xaa, [0x1d] = 0x55,
9815 [0x1e] = 0xbb, [0x1f] = 0x66,
9816 [0x20] = 0xcc, [0x21] = 0x77,
9817 [0x22] = 0xdd, [0x23] = 0x88,
9818 [0x24] = 0xee, [0x25] = 0x99,
9819 [0x26] = 0xff, [0x27] = 0xaa,
9820 },
9821 { {0x40, 0x66cc77dd } },
9822 },
93731ef0
DB		 9823 {
9824 "LD_IND word positive offset, all ff",
9825 .u.insns = {
9826 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
9827 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
9828 BPF_STMT(BPF_RET | BPF_A, 0x0),
9829 },
9830 CLASSIC,
9831 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9832 { {0x40, 0xffffffff } },
9833 },
9834 {
9835 "LD_IND word positive offset, out of bounds",
9836 .u.insns = {
9837 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9838 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
9839 BPF_STMT(BPF_RET | BPF_A, 0x0),
9840 },
9841 CLASSIC,
9842 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9843 { {0x3f, 0 }, },
9844 },
9845 {
9846 "LD_IND word negative offset, out of bounds",
9847 .u.insns = {
9848 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
9849 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
9850 BPF_STMT(BPF_RET | BPF_A, 0x0),
9851 },
9852 CLASSIC,
9853 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9854 { {0x3f, 0 } },
9855 },
08fcb08f
NS		 9856 {
9857 "LD_ABS byte",
9858 .u.insns = {
9859 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
9860 BPF_STMT(BPF_RET | BPF_A, 0x0),
9861 },
9862 CLASSIC,
9863 {
9864 [0x1c] = 0xaa, [0x1d] = 0x55,
9865 [0x1e] = 0xbb, [0x1f] = 0x66,
9866 [0x20] = 0xcc, [0x21] = 0x77,
9867 [0x22] = 0xdd, [0x23] = 0x88,
9868 [0x24] = 0xee, [0x25] = 0x99,
9869 [0x26] = 0xff, [0x27] = 0xaa,
9870 },
9871 { {0x40, 0xcc } },
9872 },
93731ef0
DB		 9873 {
9874 "LD_ABS byte positive offset, all ff",
9875 .u.insns = {
9876 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
9877 BPF_STMT(BPF_RET | BPF_A, 0x0),
9878 },
9879 CLASSIC,
9880 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9881 { {0x40, 0xff } },
9882 },
9883 {
9884 "LD_ABS byte positive offset, out of bounds",
9885 .u.insns = {
9886 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
9887 BPF_STMT(BPF_RET | BPF_A, 0x0),
9888 },
9889 CLASSIC,
9890 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9891 { {0x3f, 0 }, },
9892 },
9893 {
9894 "LD_ABS byte negative offset, out of bounds load",
9895 .u.insns = {
9896 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
9897 BPF_STMT(BPF_RET | BPF_A, 0x0),
9898 },
9899 CLASSIC | FLAG_EXPECTED_FAIL,
9900 .expected_errcode = -EINVAL,
9901 },
9902 {
9903 "LD_ABS byte negative offset, in bounds",
9904 .u.insns = {
9905 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
9906 BPF_STMT(BPF_RET | BPF_A, 0x0),
9907 },
9908 CLASSIC,
9909 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9910 { {0x40, 0x82 }, },
9911 },
9912 {
9913 "LD_ABS byte negative offset, out of bounds",
9914 .u.insns = {
9915 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
9916 BPF_STMT(BPF_RET | BPF_A, 0x0),
9917 },
9918 CLASSIC,
9919 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9920 { {0x3f, 0 }, },
9921 },
9922 {
9923 "LD_ABS byte negative offset, multiple calls",
9924 .u.insns = {
9925 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
9926 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
9927 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
9928 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
9929 BPF_STMT(BPF_RET | BPF_A, 0x0),
9930 },
9931 CLASSIC,
9932 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9933 { {0x40, 0x82 }, },
9934 },
08fcb08f
NS		 9935 {
9936 "LD_ABS halfword",
9937 .u.insns = {
9938 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
9939 BPF_STMT(BPF_RET | BPF_A, 0x0),
9940 },
9941 CLASSIC,
9942 {
9943 [0x1c] = 0xaa, [0x1d] = 0x55,
9944 [0x1e] = 0xbb, [0x1f] = 0x66,
9945 [0x20] = 0xcc, [0x21] = 0x77,
9946 [0x22] = 0xdd, [0x23] = 0x88,
9947 [0x24] = 0xee, [0x25] = 0x99,
9948 [0x26] = 0xff, [0x27] = 0xaa,
9949 },
9950 { {0x40, 0xdd88 } },
9951 },
9952 {
9953 "LD_ABS halfword unaligned",
9954 .u.insns = {
9955 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
9956 BPF_STMT(BPF_RET | BPF_A, 0x0),
9957 },
9958 CLASSIC,
9959 {
9960 [0x1c] = 0xaa, [0x1d] = 0x55,
9961 [0x1e] = 0xbb, [0x1f] = 0x66,
9962 [0x20] = 0xcc, [0x21] = 0x77,
9963 [0x22] = 0xdd, [0x23] = 0x88,
9964 [0x24] = 0xee, [0x25] = 0x99,
9965 [0x26] = 0xff, [0x27] = 0xaa,
9966 },
9967 { {0x40, 0x99ff } },
9968 },
93731ef0
DB		 9969 {
9970 "LD_ABS halfword positive offset, all ff",
9971 .u.insns = {
9972 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
9973 BPF_STMT(BPF_RET | BPF_A, 0x0),
9974 },
9975 CLASSIC,
9976 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
9977 { {0x40, 0xffff } },
9978 },
9979 {
9980 "LD_ABS halfword positive offset, out of bounds",
9981 .u.insns = {
9982 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
9983 BPF_STMT(BPF_RET | BPF_A, 0x0),
9984 },
9985 CLASSIC,
9986 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
9987 { {0x3f, 0 }, },
9988 },
9989 {
9990 "LD_ABS halfword negative offset, out of bounds load",
9991 .u.insns = {
9992 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
9993 BPF_STMT(BPF_RET | BPF_A, 0x0),
9994 },
9995 CLASSIC | FLAG_EXPECTED_FAIL,
9996 .expected_errcode = -EINVAL,
9997 },
9998 {
9999 "LD_ABS halfword negative offset, in bounds",
10000 .u.insns = {
10001 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10002 BPF_STMT(BPF_RET | BPF_A, 0x0),
10003 },
10004 CLASSIC,
10005 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10006 { {0x40, 0x1982 }, },
10007 },
10008 {
10009 "LD_ABS halfword negative offset, out of bounds",
10010 .u.insns = {
10011 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
10012 BPF_STMT(BPF_RET | BPF_A, 0x0),
10013 },
10014 CLASSIC,
10015 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10016 { {0x3f, 0 }, },
10017 },
08fcb08f
NS		 10018 {
10019 "LD_ABS word",
10020 .u.insns = {
10021 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
10022 BPF_STMT(BPF_RET | BPF_A, 0x0),
10023 },
10024 CLASSIC,
10025 {
10026 [0x1c] = 0xaa, [0x1d] = 0x55,
10027 [0x1e] = 0xbb, [0x1f] = 0x66,
10028 [0x20] = 0xcc, [0x21] = 0x77,
10029 [0x22] = 0xdd, [0x23] = 0x88,
10030 [0x24] = 0xee, [0x25] = 0x99,
10031 [0x26] = 0xff, [0x27] = 0xaa,
10032 },
10033 { {0x40, 0xaa55bb66 } },
10034 },
10035 {
10036 "LD_ABS word unaligned (addr & 3 == 2)",
10037 .u.insns = {
10038 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
10039 BPF_STMT(BPF_RET | BPF_A, 0x0),
10040 },
10041 CLASSIC,
10042 {
10043 [0x1c] = 0xaa, [0x1d] = 0x55,
10044 [0x1e] = 0xbb, [0x1f] = 0x66,
10045 [0x20] = 0xcc, [0x21] = 0x77,
10046 [0x22] = 0xdd, [0x23] = 0x88,
10047 [0x24] = 0xee, [0x25] = 0x99,
10048 [0x26] = 0xff, [0x27] = 0xaa,
10049 },
10050 { {0x40, 0xdd88ee99 } },
10051 },
10052 {
10053 "LD_ABS word unaligned (addr & 3 == 1)",
10054 .u.insns = {
10055 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
10056 BPF_STMT(BPF_RET | BPF_A, 0x0),
10057 },
10058 CLASSIC,
10059 {
10060 [0x1c] = 0xaa, [0x1d] = 0x55,
10061 [0x1e] = 0xbb, [0x1f] = 0x66,
10062 [0x20] = 0xcc, [0x21] = 0x77,
10063 [0x22] = 0xdd, [0x23] = 0x88,
10064 [0x24] = 0xee, [0x25] = 0x99,
10065 [0x26] = 0xff, [0x27] = 0xaa,
10066 },
10067 { {0x40, 0x77dd88ee } },
10068 },
10069 {
10070 "LD_ABS word unaligned (addr & 3 == 3)",
10071 .u.insns = {
10072 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
10073 BPF_STMT(BPF_RET | BPF_A, 0x0),
10074 },
10075 CLASSIC,
10076 {
10077 [0x1c] = 0xaa, [0x1d] = 0x55,
10078 [0x1e] = 0xbb, [0x1f] = 0x66,
10079 [0x20] = 0xcc, [0x21] = 0x77,
10080 [0x22] = 0xdd, [0x23] = 0x88,
10081 [0x24] = 0xee, [0x25] = 0x99,
10082 [0x26] = 0xff, [0x27] = 0xaa,
10083 },
10084 { {0x40, 0x88ee99ff } },
10085 },
93731ef0
DB		 10086 {
10087 "LD_ABS word positive offset, all ff",
10088 .u.insns = {
10089 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
10090 BPF_STMT(BPF_RET | BPF_A, 0x0),
10091 },
10092 CLASSIC,
10093 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
10094 { {0x40, 0xffffffff } },
10095 },
10096 {
10097 "LD_ABS word positive offset, out of bounds",
10098 .u.insns = {
10099 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
10100 BPF_STMT(BPF_RET | BPF_A, 0x0),
10101 },
10102 CLASSIC,
10103 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10104 { {0x3f, 0 }, },
10105 },
10106 {
10107 "LD_ABS word negative offset, out of bounds load",
10108 .u.insns = {
10109 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
10110 BPF_STMT(BPF_RET | BPF_A, 0x0),
10111 },
10112 CLASSIC | FLAG_EXPECTED_FAIL,
10113 .expected_errcode = -EINVAL,
10114 },
10115 {
10116 "LD_ABS word negative offset, in bounds",
10117 .u.insns = {
10118 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
10119 BPF_STMT(BPF_RET | BPF_A, 0x0),
10120 },
10121 CLASSIC,
10122 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10123 { {0x40, 0x25051982 }, },
10124 },
10125 {
10126 "LD_ABS word negative offset, out of bounds",
10127 .u.insns = {
10128 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
10129 BPF_STMT(BPF_RET | BPF_A, 0x0),
10130 },
10131 CLASSIC,
10132 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10133 { {0x3f, 0 }, },
10134 },
10135 {
10136 "LDX_MSH standalone, preserved A",
10137 .u.insns = {
10138 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10139 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10140 BPF_STMT(BPF_RET | BPF_A, 0x0),
10141 },
10142 CLASSIC,
10143 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10144 { {0x40, 0xffeebbaa }, },
10145 },
10146 {
10147 "LDX_MSH standalone, preserved A 2",
10148 .u.insns = {
10149 BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
10150 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10151 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
10152 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
10153 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
10154 BPF_STMT(BPF_RET | BPF_A, 0x0),
10155 },
10156 CLASSIC,
10157 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10158 { {0x40, 0x175e9d63 }, },
10159 },
10160 {
10161 "LDX_MSH standalone, test result 1",
10162 .u.insns = {
10163 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10164 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
10165 BPF_STMT(BPF_MISC | BPF_TXA, 0),
10166 BPF_STMT(BPF_RET | BPF_A, 0x0),
10167 },
10168 CLASSIC,
10169 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10170 { {0x40, 0x14 }, },
10171 },
10172 {
10173 "LDX_MSH standalone, test result 2",
10174 .u.insns = {
10175 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10176 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
10177 BPF_STMT(BPF_MISC | BPF_TXA, 0),
10178 BPF_STMT(BPF_RET | BPF_A, 0x0),
10179 },
10180 CLASSIC,
10181 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10182 { {0x40, 0x24 }, },
10183 },
10184 {
10185 "LDX_MSH standalone, negative offset",
10186 .u.insns = {
10187 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10188 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
10189 BPF_STMT(BPF_MISC | BPF_TXA, 0),
10190 BPF_STMT(BPF_RET | BPF_A, 0x0),
10191 },
10192 CLASSIC,
10193 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10194 { {0x40, 0 }, },
10195 },
10196 {
10197 "LDX_MSH standalone, negative offset 2",
10198 .u.insns = {
10199 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10200 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
10201 BPF_STMT(BPF_MISC | BPF_TXA, 0),
10202 BPF_STMT(BPF_RET | BPF_A, 0x0),
10203 },
10204 CLASSIC,
10205 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10206 { {0x40, 0x24 }, },
10207 },
10208 {
10209 "LDX_MSH standalone, out of bounds",
10210 .u.insns = {
10211 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
10212 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
10213 BPF_STMT(BPF_MISC | BPF_TXA, 0),
10214 BPF_STMT(BPF_RET | BPF_A, 0x0),
10215 },
10216 CLASSIC,
10217 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
10218 { {0x40, 0 }, },
10219 },
86bf1721
NS		 10220 /*
10221 * verify that the interpreter or JIT correctly sets A and X
10222 * to 0.
10223 */
10224 {
10225 "ADD default X",
10226 .u.insns = {
10227 /*
10228 * A = 0x42
10229 * A = A + X
10230 * ret A
10231 */
10232 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10233 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
10234 BPF_STMT(BPF_RET | BPF_A, 0x0),
10235 },
10236 CLASSIC | FLAG_NO_DATA,
10237 {},
10238 { {0x1, 0x42 } },
10239 },
10240 {
10241 "ADD default A",
10242 .u.insns = {
10243 /*
10244 * A = A + 0x42
10245 * ret A
10246 */
10247 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
10248 BPF_STMT(BPF_RET | BPF_A, 0x0),
10249 },
10250 CLASSIC | FLAG_NO_DATA,
10251 {},
10252 { {0x1, 0x42 } },
10253 },
10254 {
10255 "SUB default X",
10256 .u.insns = {
10257 /*
10258 * A = 0x66
10259 * A = A - X
10260 * ret A
10261 */
10262 BPF_STMT(BPF_LD | BPF_IMM, 0x66),
10263 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
10264 BPF_STMT(BPF_RET | BPF_A, 0x0),
10265 },
10266 CLASSIC | FLAG_NO_DATA,
10267 {},
10268 { {0x1, 0x66 } },
10269 },
10270 {
10271 "SUB default A",
10272 .u.insns = {
10273 /*
10274 * A = A - -0x66
10275 * ret A
10276 */
10277 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
10278 BPF_STMT(BPF_RET | BPF_A, 0x0),
10279 },
10280 CLASSIC | FLAG_NO_DATA,
10281 {},
10282 { {0x1, 0x66 } },
10283 },
10284 {
10285 "MUL default X",
10286 .u.insns = {
10287 /*
10288 * A = 0x42
10289 * A = A * X
10290 * ret A
10291 */
10292 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10293 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
10294 BPF_STMT(BPF_RET | BPF_A, 0x0),
10295 },
10296 CLASSIC | FLAG_NO_DATA,
10297 {},
10298 { {0x1, 0x0 } },
10299 },
10300 {
10301 "MUL default A",
10302 .u.insns = {
10303 /*
10304 * A = A * 0x66
10305 * ret A
10306 */
10307 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
10308 BPF_STMT(BPF_RET | BPF_A, 0x0),
10309 },
10310 CLASSIC | FLAG_NO_DATA,
10311 {},
10312 { {0x1, 0x0 } },
10313 },
10314 {
10315 "DIV default X",
10316 .u.insns = {
10317 /*
10318 * A = 0x42
10319 * A = A / X ; this halt the filter execution if X is 0
10320 * ret 0x42
10321 */
10322 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10323 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
10324 BPF_STMT(BPF_RET | BPF_K, 0x42),
10325 },
10326 CLASSIC | FLAG_NO_DATA,
10327 {},
10328 { {0x1, 0x0 } },
10329 },
10330 {
10331 "DIV default A",
10332 .u.insns = {
10333 /*
10334 * A = A / 1
10335 * ret A
10336 */
10337 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
10338 BPF_STMT(BPF_RET | BPF_A, 0x0),
10339 },
10340 CLASSIC | FLAG_NO_DATA,
10341 {},
10342 { {0x1, 0x0 } },
10343 },
d4e4bc16
YS		 10344 {
10345 "MOD default X",
10346 .u.insns = {
10347 /*
10348 * A = 0x42
10349 * A = A mod X ; this halt the filter execution if X is 0
10350 * ret 0x42
10351 */
10352 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
10353 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
10354 BPF_STMT(BPF_RET | BPF_K, 0x42),
10355 },
10356 CLASSIC | FLAG_NO_DATA,
10357 {},
10358 { {0x1, 0x0 } },
10359 },
10360 {
10361 "MOD default A",
10362 .u.insns = {
10363 /*
10364 * A = A mod 1
10365 * ret A
10366 */
10367 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
10368 BPF_STMT(BPF_RET | BPF_A, 0x0),
10369 },
10370 CLASSIC | FLAG_NO_DATA,
10371 {},
10372 { {0x1, 0x0 } },
10373 },
86bf1721
NS		 10374 {
10375 "JMP EQ default A",
10376 .u.insns = {
10377 /*
10378 * cmp A, 0x0, 0, 1
10379 * ret 0x42
10380 * ret 0x66
10381 */
10382 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
10383 BPF_STMT(BPF_RET | BPF_K, 0x42),
10384 BPF_STMT(BPF_RET | BPF_K, 0x66),
10385 },
10386 CLASSIC | FLAG_NO_DATA,
10387 {},
10388 { {0x1, 0x42 } },
10389 },
10390 {
10391 "JMP EQ default X",
10392 .u.insns = {
10393 /*
10394 * A = 0x0
10395 * cmp A, X, 0, 1
10396 * ret 0x42
10397 * ret 0x66
10398 */
10399 BPF_STMT(BPF_LD | BPF_IMM, 0x0),
10400 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
10401 BPF_STMT(BPF_RET | BPF_K, 0x42),
10402 BPF_STMT(BPF_RET | BPF_K, 0x66),
10403 },
10404 CLASSIC | FLAG_NO_DATA,
10405 {},
10406 { {0x1, 0x42 } },
10407 },
fcd1c917
DB		 10408 /* Checking interpreter vs JIT wrt signed extended imms. */
10409 {
10410 "JNE signed compare, test 1",
10411 .u.insns_int = {
10412 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
10413 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
10414 BPF_MOV64_REG(R2, R1),
10415 BPF_ALU64_REG(BPF_AND, R2, R3),
10416 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10417 BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
10418 BPF_ALU32_IMM(BPF_MOV, R0, 2),
10419 BPF_EXIT_INSN(),
10420 },
10421 INTERNAL,
10422 { },
10423 { { 0, 1 } },
10424 },
10425 {
10426 "JNE signed compare, test 2",
10427 .u.insns_int = {
10428 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
10429 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
10430 BPF_MOV64_REG(R2, R1),
10431 BPF_ALU64_REG(BPF_AND, R2, R3),
10432 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10433 BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
10434 BPF_ALU32_IMM(BPF_MOV, R0, 2),
10435 BPF_EXIT_INSN(),
10436 },
10437 INTERNAL,
10438 { },
10439 { { 0, 1 } },
10440 },
10441 {
10442 "JNE signed compare, test 3",
10443 .u.insns_int = {
10444 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
10445 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
10446 BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
10447 BPF_MOV64_REG(R2, R1),
10448 BPF_ALU64_REG(BPF_AND, R2, R3),
10449 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10450 BPF_JMP_REG(BPF_JNE, R2, R4, 1),
10451 BPF_ALU32_IMM(BPF_MOV, R0, 2),
10452 BPF_EXIT_INSN(),
10453 },
10454 INTERNAL,
10455 { },
10456 { { 0, 2 } },
10457 },
10458 {
10459 "JNE signed compare, test 4",
10460 .u.insns_int = {
10461 BPF_LD_IMM64(R1, -17104896),
10462 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10463 BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
10464 BPF_ALU32_IMM(BPF_MOV, R0, 2),
10465 BPF_EXIT_INSN(),
10466 },
10467 INTERNAL,
10468 { },
10469 { { 0, 2 } },
10470 },
10471 {
10472 "JNE signed compare, test 5",
10473 .u.insns_int = {
10474 BPF_LD_IMM64(R1, 0xfefb0000),
10475 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10476 BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
10477 BPF_ALU32_IMM(BPF_MOV, R0, 2),
10478 BPF_EXIT_INSN(),
10479 },
10480 INTERNAL,
10481 { },
10482 { { 0, 1 } },
10483 },
10484 {
10485 "JNE signed compare, test 6",
10486 .u.insns_int = {
10487 BPF_LD_IMM64(R1, 0x7efb0000),
10488 BPF_ALU32_IMM(BPF_MOV, R0, 1),
10489 BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
10490 BPF_ALU32_IMM(BPF_MOV, R0, 2),
10491 BPF_EXIT_INSN(),
10492 },
10493 INTERNAL,
10494 { },
10495 { { 0, 2 } },
10496 },
10497 {
10498 "JNE signed compare, test 7",
10499 .u.insns = {
10500 BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
10501 BPF_STMT(BPF_MISC | BPF_TAX, 0),
10502 BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
10503 BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
10504 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
10505 BPF_STMT(BPF_RET | BPF_K, 1),
10506 BPF_STMT(BPF_RET | BPF_K, 2),
10507 },
10508 CLASSIC | FLAG_NO_DATA,
10509 {},
10510 { { 0, 2 } },
10511 },
e2f9797b
JA		 10512 /*
10513 * Register (non-)clobbering tests for the case where a JIT implements
10514 * complex ALU or ATOMIC operations via function calls. If so, the
10515 * function call must be transparent to the eBPF registers. The JIT
10516 * must therefore save and restore relevant registers across the call.
10517 * The following tests check that the eBPF registers retain their
10518 * values after such an operation. Mainly intended for complex ALU
10519 * and atomic operation, but we run it for all. You never know...
10520 *
10521 * Note that each operations should be tested twice with different
10522 * destinations, to check preservation for all registers.
10523 */
10524#define BPF_TEST_CLOBBER_ALU(alu, op, dst, src) \
10525 { \
10526 #alu "_" #op " to " #dst ": no clobbering", \
10527 .u.insns_int = { \
10528 BPF_ALU64_IMM(BPF_MOV, R0, R0), \
10529 BPF_ALU64_IMM(BPF_MOV, R1, R1), \
10530 BPF_ALU64_IMM(BPF_MOV, R2, R2), \
10531 BPF_ALU64_IMM(BPF_MOV, R3, R3), \
10532 BPF_ALU64_IMM(BPF_MOV, R4, R4), \
10533 BPF_ALU64_IMM(BPF_MOV, R5, R5), \
10534 BPF_ALU64_IMM(BPF_MOV, R6, R6), \
10535 BPF_ALU64_IMM(BPF_MOV, R7, R7), \
10536 BPF_ALU64_IMM(BPF_MOV, R8, R8), \
10537 BPF_ALU64_IMM(BPF_MOV, R9, R9), \
10538 BPF_##alu(BPF_ ##op, dst, src), \
10539 BPF_ALU32_IMM(BPF_MOV, dst, dst), \
10540 BPF_JMP_IMM(BPF_JNE, R0, R0, 10), \
10541 BPF_JMP_IMM(BPF_JNE, R1, R1, 9), \
10542 BPF_JMP_IMM(BPF_JNE, R2, R2, 8), \
10543 BPF_JMP_IMM(BPF_JNE, R3, R3, 7), \
10544 BPF_JMP_IMM(BPF_JNE, R4, R4, 6), \
10545 BPF_JMP_IMM(BPF_JNE, R5, R5, 5), \
10546 BPF_JMP_IMM(BPF_JNE, R6, R6, 4), \
10547 BPF_JMP_IMM(BPF_JNE, R7, R7, 3), \
10548 BPF_JMP_IMM(BPF_JNE, R8, R8, 2), \
10549 BPF_JMP_IMM(BPF_JNE, R9, R9, 1), \
10550 BPF_ALU64_IMM(BPF_MOV, R0, 1), \
10551 BPF_EXIT_INSN(), \
10552 }, \
10553 INTERNAL, \
10554 { }, \
10555 { { 0, 1 } } \
10556 }
10557 /* ALU64 operations, register clobbering */
10558 BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R8, 123456789),
10559 BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R9, 123456789),
10560 BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R8, 123456789),
10561 BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R9, 123456789),
10562 BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R8, 123456789),
10563 BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R9, 123456789),
10564 BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R8, 12),
10565 BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R9, 12),
10566 BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R8, 12),
10567 BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R9, 12),
10568 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R8, 12),
10569 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R9, 12),
10570 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R8, 123456789),
10571 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R9, 123456789),
10572 BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R8, 123456789),
10573 BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R9, 123456789),
10574 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R8, 123456789),
10575 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R9, 123456789),
10576 BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R8, 123456789),
10577 BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R9, 123456789),
10578 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R8, 123456789),
10579 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R9, 123456789),
10580 /* ALU32 immediate operations, register clobbering */
10581 BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R8, 123456789),
10582 BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R9, 123456789),
10583 BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R8, 123456789),
10584 BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R9, 123456789),
10585 BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R8, 123456789),
10586 BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R9, 123456789),
10587 BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R8, 12),
10588 BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R9, 12),
10589 BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R8, 12),
10590 BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R9, 12),
10591 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R8, 12),
10592 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R9, 12),
10593 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R8, 123456789),
10594 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R9, 123456789),
10595 BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R8, 123456789),
10596 BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R9, 123456789),
10597 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R8, 123456789),
10598 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R9, 123456789),
10599 BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R8, 123456789),
10600 BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R9, 123456789),
10601 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R8, 123456789),
10602 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R9, 123456789),
10603 /* ALU64 register operations, register clobbering */
10604 BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R8, R1),
10605 BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R9, R1),
10606 BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R8, R1),
10607 BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R9, R1),
10608 BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R8, R1),
10609 BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R9, R1),
10610 BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R8, R1),
10611 BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R9, R1),
10612 BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R8, R1),
10613 BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R9, R1),
10614 BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R8, R1),
10615 BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R9, R1),
10616 BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R8, R1),
10617 BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R9, R1),
10618 BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R8, R1),
10619 BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R9, R1),
10620 BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R8, R1),
10621 BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R9, R1),
10622 BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R8, R1),
10623 BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R9, R1),
10624 BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R8, R1),
10625 BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R9, R1),
10626 /* ALU32 register operations, register clobbering */
10627 BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R8, R1),
10628 BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R9, R1),
10629 BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R8, R1),
10630 BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R9, R1),
10631 BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R8, R1),
10632 BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R9, R1),
10633 BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R8, R1),
10634 BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R9, R1),
10635 BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R8, R1),
10636 BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R9, R1),
10637 BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R8, R1),
10638 BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R9, R1),
10639 BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R8, R1),
10640 BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R9, R1),
10641 BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R8, R1),
10642 BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R9, R1),
10643 BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R8, R1),
10644 BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R9, R1),
10645 BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R8, R1),
10646 BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R9, R1),
10647 BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R8, R1),
10648 BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R9, R1),
10649#undef BPF_TEST_CLOBBER_ALU
10650#define BPF_TEST_CLOBBER_ATOMIC(width, op) \
10651 { \
10652 "Atomic_" #width " " #op ": no clobbering", \
10653 .u.insns_int = { \
10654 BPF_ALU64_IMM(BPF_MOV, R0, 0), \
10655 BPF_ALU64_IMM(BPF_MOV, R1, 1), \
10656 BPF_ALU64_IMM(BPF_MOV, R2, 2), \
10657 BPF_ALU64_IMM(BPF_MOV, R3, 3), \
10658 BPF_ALU64_IMM(BPF_MOV, R4, 4), \
10659 BPF_ALU64_IMM(BPF_MOV, R5, 5), \
10660 BPF_ALU64_IMM(BPF_MOV, R6, 6), \
10661 BPF_ALU64_IMM(BPF_MOV, R7, 7), \
10662 BPF_ALU64_IMM(BPF_MOV, R8, 8), \
10663 BPF_ALU64_IMM(BPF_MOV, R9, 9), \
10664 BPF_ST_MEM(width, R10, -8, \
10665 (op) == BPF_CMPXCHG ? 0 : \
10666 (op) & BPF_FETCH ? 1 : 0), \
10667 BPF_ATOMIC_OP(width, op, R10, R1, -8), \
10668 BPF_JMP_IMM(BPF_JNE, R0, 0, 10), \
10669 BPF_JMP_IMM(BPF_JNE, R1, 1, 9), \
10670 BPF_JMP_IMM(BPF_JNE, R2, 2, 8), \
10671 BPF_JMP_IMM(BPF_JNE, R3, 3, 7), \
10672 BPF_JMP_IMM(BPF_JNE, R4, 4, 6), \
10673 BPF_JMP_IMM(BPF_JNE, R5, 5, 5), \
10674 BPF_JMP_IMM(BPF_JNE, R6, 6, 4), \
10675 BPF_JMP_IMM(BPF_JNE, R7, 7, 3), \
10676 BPF_JMP_IMM(BPF_JNE, R8, 8, 2), \
10677 BPF_JMP_IMM(BPF_JNE, R9, 9, 1), \
10678 BPF_ALU64_IMM(BPF_MOV, R0, 1), \
10679 BPF_EXIT_INSN(), \
10680 }, \
10681 INTERNAL, \
10682 { }, \
10683 { { 0, 1 } }, \
10684 .stack_depth = 8, \
10685 }
10686 /* 64-bit atomic operations, register clobbering */
10687 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD),
10688 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND),
10689 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR),
10690 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR),
10691 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD | BPF_FETCH),
10692 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND | BPF_FETCH),
10693 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR | BPF_FETCH),
10694 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR | BPF_FETCH),
10695 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XCHG),
10696 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_CMPXCHG),
10697 /* 32-bit atomic operations, register clobbering */
10698 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD),
10699 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND),
10700 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR),
10701 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR),
10702 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD | BPF_FETCH),
10703 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND | BPF_FETCH),
10704 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR | BPF_FETCH),
10705 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR | BPF_FETCH),
10706 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XCHG),
10707 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_CMPXCHG),
10708#undef BPF_TEST_CLOBBER_ATOMIC
0bbaa02b
JA		 10709 /* Checking that ALU32 src is not zero extended in place */
10710#define BPF_ALU32_SRC_ZEXT(op) \
10711 { \
10712 "ALU32_" #op "_X: src preserved in zext", \
10713 .u.insns_int = { \
10714 BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\
10715 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\
10716 BPF_ALU64_REG(BPF_MOV, R0, R1), \
10717 BPF_ALU32_REG(BPF_##op, R2, R1), \
10718 BPF_ALU64_REG(BPF_SUB, R0, R1), \
10719 BPF_ALU64_REG(BPF_MOV, R1, R0), \
10720 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
10721 BPF_ALU64_REG(BPF_OR, R0, R1), \
10722 BPF_EXIT_INSN(), \
10723 }, \
10724 INTERNAL, \
10725 { }, \
10726 { { 0, 0 } }, \
10727 }
10728 BPF_ALU32_SRC_ZEXT(MOV),
10729 BPF_ALU32_SRC_ZEXT(AND),
10730 BPF_ALU32_SRC_ZEXT(OR),
10731 BPF_ALU32_SRC_ZEXT(XOR),
10732 BPF_ALU32_SRC_ZEXT(ADD),
10733 BPF_ALU32_SRC_ZEXT(SUB),
10734 BPF_ALU32_SRC_ZEXT(MUL),
10735 BPF_ALU32_SRC_ZEXT(DIV),
10736 BPF_ALU32_SRC_ZEXT(MOD),
10737#undef BPF_ALU32_SRC_ZEXT
10738 /* Checking that ATOMIC32 src is not zero extended in place */
10739#define BPF_ATOMIC32_SRC_ZEXT(op) \
10740 { \
10741 "ATOMIC_W_" #op ": src preserved in zext", \
10742 .u.insns_int = { \
10743 BPF_LD_IMM64(R0, 0x0123456789acbdefULL), \
10744 BPF_ALU64_REG(BPF_MOV, R1, R0), \
10745 BPF_ST_MEM(BPF_W, R10, -4, 0), \
10746 BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4), \
10747 BPF_ALU64_REG(BPF_SUB, R0, R1), \
10748 BPF_ALU64_REG(BPF_MOV, R1, R0), \
10749 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
10750 BPF_ALU64_REG(BPF_OR, R0, R1), \
10751 BPF_EXIT_INSN(), \
10752 }, \
10753 INTERNAL, \
10754 { }, \
10755 { { 0, 0 } }, \
10756 .stack_depth = 8, \
10757 }
10758 BPF_ATOMIC32_SRC_ZEXT(ADD),
10759 BPF_ATOMIC32_SRC_ZEXT(AND),
10760 BPF_ATOMIC32_SRC_ZEXT(OR),
10761 BPF_ATOMIC32_SRC_ZEXT(XOR),
10762#undef BPF_ATOMIC32_SRC_ZEXT
10763 /* Checking that CMPXCHG32 src is not zero extended in place */
10764 {
10765 "ATOMIC_W_CMPXCHG: src preserved in zext",
10766 .u.insns_int = {
10767 BPF_LD_IMM64(R1, 0x0123456789acbdefULL),
10768 BPF_ALU64_REG(BPF_MOV, R2, R1),
10769 BPF_ALU64_REG(BPF_MOV, R0, 0),
10770 BPF_ST_MEM(BPF_W, R10, -4, 0),
10771 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4),
10772 BPF_ALU64_REG(BPF_SUB, R1, R2),
10773 BPF_ALU64_REG(BPF_MOV, R2, R1),
10774 BPF_ALU64_IMM(BPF_RSH, R2, 32),
10775 BPF_ALU64_REG(BPF_OR, R1, R2),
10776 BPF_ALU64_REG(BPF_MOV, R0, R1),
10777 BPF_EXIT_INSN(),
10778 },
10779 INTERNAL,
10780 { },
10781 { { 0, 0 } },
10782 .stack_depth = 8,
10783 },
10784 /* Checking that JMP32 immediate src is not zero extended in place */
10785#define BPF_JMP32_IMM_ZEXT(op) \
10786 { \
10787 "JMP32_" #op "_K: operand preserved in zext", \
10788 .u.insns_int = { \
10789 BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
10790 BPF_ALU64_REG(BPF_MOV, R1, R0), \
10791 BPF_JMP32_IMM(BPF_##op, R0, 1234, 1), \
10792 BPF_JMP_A(0), /* Nop */ \
10793 BPF_ALU64_REG(BPF_SUB, R0, R1), \
10794 BPF_ALU64_REG(BPF_MOV, R1, R0), \
10795 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
10796 BPF_ALU64_REG(BPF_OR, R0, R1), \
10797 BPF_EXIT_INSN(), \
10798 }, \
10799 INTERNAL, \
10800 { }, \
10801 { { 0, 0 } }, \
10802 }
10803 BPF_JMP32_IMM_ZEXT(JEQ),
10804 BPF_JMP32_IMM_ZEXT(JNE),
10805 BPF_JMP32_IMM_ZEXT(JSET),
10806 BPF_JMP32_IMM_ZEXT(JGT),
10807 BPF_JMP32_IMM_ZEXT(JGE),
10808 BPF_JMP32_IMM_ZEXT(JLT),
10809 BPF_JMP32_IMM_ZEXT(JLE),
10810 BPF_JMP32_IMM_ZEXT(JSGT),
10811 BPF_JMP32_IMM_ZEXT(JSGE),
10812 BPF_JMP32_IMM_ZEXT(JSGT),
10813 BPF_JMP32_IMM_ZEXT(JSLT),
10814 BPF_JMP32_IMM_ZEXT(JSLE),
10815#undef BPF_JMP2_IMM_ZEXT
10816 /* Checking that JMP32 dst & src are not zero extended in place */
10817#define BPF_JMP32_REG_ZEXT(op) \
10818 { \
10819 "JMP32_" #op "_X: operands preserved in zext", \
10820 .u.insns_int = { \
10821 BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\
10822 BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\
10823 BPF_ALU64_REG(BPF_MOV, R2, R0), \
10824 BPF_ALU64_REG(BPF_MOV, R3, R1), \
10825 BPF_JMP32_IMM(BPF_##op, R0, R1, 1), \
10826 BPF_JMP_A(0), /* Nop */ \
10827 BPF_ALU64_REG(BPF_SUB, R0, R2), \
10828 BPF_ALU64_REG(BPF_SUB, R1, R3), \
10829 BPF_ALU64_REG(BPF_OR, R0, R1), \
10830 BPF_ALU64_REG(BPF_MOV, R1, R0), \
10831 BPF_ALU64_IMM(BPF_RSH, R1, 32), \
10832 BPF_ALU64_REG(BPF_OR, R0, R1), \
10833 BPF_EXIT_INSN(), \
10834 }, \
10835 INTERNAL, \
10836 { }, \
10837 { { 0, 0 } }, \
10838 }
10839 BPF_JMP32_REG_ZEXT(JEQ),
10840 BPF_JMP32_REG_ZEXT(JNE),
10841 BPF_JMP32_REG_ZEXT(JSET),
10842 BPF_JMP32_REG_ZEXT(JGT),
10843 BPF_JMP32_REG_ZEXT(JGE),
10844 BPF_JMP32_REG_ZEXT(JLT),
10845 BPF_JMP32_REG_ZEXT(JLE),
10846 BPF_JMP32_REG_ZEXT(JSGT),
10847 BPF_JMP32_REG_ZEXT(JSGE),
10848 BPF_JMP32_REG_ZEXT(JSGT),
10849 BPF_JMP32_REG_ZEXT(JSLT),
10850 BPF_JMP32_REG_ZEXT(JSLE),
10851#undef BPF_JMP2_REG_ZEXT
68c956fe
JA		 10852 /* Exhaustive test of ALU64 shift operations */
10853 {
10854 "ALU64_LSH_K: all shift values",
10855 { },
10856 INTERNAL | FLAG_NO_DATA,
10857 { },
10858 { { 0, 1 } },
10859 .fill_helper = bpf_fill_alu_lsh_imm,
10860 },
10861 {
10862 "ALU64_RSH_K: all shift values",
10863 { },
10864 INTERNAL | FLAG_NO_DATA,
10865 { },
10866 { { 0, 1 } },
10867 .fill_helper = bpf_fill_alu_rsh_imm,
10868 },
10869 {
10870 "ALU64_ARSH_K: all shift values",
10871 { },
10872 INTERNAL | FLAG_NO_DATA,
10873 { },
10874 { { 0, 1 } },
10875 .fill_helper = bpf_fill_alu_arsh_imm,
10876 },
10877 {
10878 "ALU64_LSH_X: all shift values",
10879 { },
10880 INTERNAL | FLAG_NO_DATA,
10881 { },
10882 { { 0, 1 } },
10883 .fill_helper = bpf_fill_alu_lsh_reg,
10884 },
10885 {
10886 "ALU64_RSH_X: all shift values",
10887 { },
10888 INTERNAL | FLAG_NO_DATA,
10889 { },
10890 { { 0, 1 } },
10891 .fill_helper = bpf_fill_alu_rsh_reg,
10892 },
10893 {
10894 "ALU64_ARSH_X: all shift values",
10895 { },
10896 INTERNAL | FLAG_NO_DATA,
10897 { },
10898 { { 0, 1 } },
10899 .fill_helper = bpf_fill_alu_arsh_reg,
10900 },
10901 /* Exhaustive test of ALU32 shift operations */
10902 {
10903 "ALU32_LSH_K: all shift values",
10904 { },
10905 INTERNAL | FLAG_NO_DATA,
10906 { },
10907 { { 0, 1 } },
10908 .fill_helper = bpf_fill_alu32_lsh_imm,
10909 },
10910 {
10911 "ALU32_RSH_K: all shift values",
10912 { },
10913 INTERNAL | FLAG_NO_DATA,
10914 { },
10915 { { 0, 1 } },
10916 .fill_helper = bpf_fill_alu32_rsh_imm,
10917 },
10918 {
10919 "ALU32_ARSH_K: all shift values",
10920 { },
10921 INTERNAL | FLAG_NO_DATA,
10922 { },
10923 { { 0, 1 } },
10924 .fill_helper = bpf_fill_alu32_arsh_imm,
10925 },
10926 {
10927 "ALU32_LSH_X: all shift values",
10928 { },
10929 INTERNAL | FLAG_NO_DATA,
10930 { },
10931 { { 0, 1 } },
10932 .fill_helper = bpf_fill_alu32_lsh_reg,
10933 },
10934 {
10935 "ALU32_RSH_X: all shift values",
10936 { },
10937 INTERNAL | FLAG_NO_DATA,
10938 { },
10939 { { 0, 1 } },
10940 .fill_helper = bpf_fill_alu32_rsh_reg,
10941 },
10942 {
10943 "ALU32_ARSH_X: all shift values",
10944 { },
10945 INTERNAL | FLAG_NO_DATA,
10946 { },
10947 { { 0, 1 } },
10948 .fill_helper = bpf_fill_alu32_arsh_reg,
10949 },
9298e63e
JA		 10950 /* ALU64 immediate magnitudes */
10951 {
10952 "ALU64_MOV_K: all immediate value magnitudes",
10953 { },
10954 INTERNAL | FLAG_NO_DATA,
10955 { },
10956 { { 0, 1 } },
10957 .fill_helper = bpf_fill_alu64_mov_imm,
10958 .nr_testruns = NR_PATTERN_RUNS,
10959 },
10960 {
10961 "ALU64_AND_K: all immediate value magnitudes",
10962 { },
10963 INTERNAL | FLAG_NO_DATA,
10964 { },
10965 { { 0, 1 } },
10966 .fill_helper = bpf_fill_alu64_and_imm,
10967 .nr_testruns = NR_PATTERN_RUNS,
10968 },
10969 {
10970 "ALU64_OR_K: all immediate value magnitudes",
10971 { },
10972 INTERNAL | FLAG_NO_DATA,
10973 { },
10974 { { 0, 1 } },
10975 .fill_helper = bpf_fill_alu64_or_imm,
10976 .nr_testruns = NR_PATTERN_RUNS,
10977 },
10978 {
10979 "ALU64_XOR_K: all immediate value magnitudes",
10980 { },
10981 INTERNAL | FLAG_NO_DATA,
10982 { },
10983 { { 0, 1 } },
10984 .fill_helper = bpf_fill_alu64_xor_imm,
10985 .nr_testruns = NR_PATTERN_RUNS,
10986 },
10987 {
10988 "ALU64_ADD_K: all immediate value magnitudes",
10989 { },
10990 INTERNAL | FLAG_NO_DATA,
10991 { },
10992 { { 0, 1 } },
10993 .fill_helper = bpf_fill_alu64_add_imm,
10994 .nr_testruns = NR_PATTERN_RUNS,
10995 },
10996 {
10997 "ALU64_SUB_K: all immediate value magnitudes",
10998 { },
10999 INTERNAL | FLAG_NO_DATA,
11000 { },
11001 { { 0, 1 } },
11002 .fill_helper = bpf_fill_alu64_sub_imm,
11003 .nr_testruns = NR_PATTERN_RUNS,
11004 },
11005 {
11006 "ALU64_MUL_K: all immediate value magnitudes",
11007 { },
11008 INTERNAL | FLAG_NO_DATA,
11009 { },
11010 { { 0, 1 } },
11011 .fill_helper = bpf_fill_alu64_mul_imm,
11012 .nr_testruns = NR_PATTERN_RUNS,
11013 },
11014 {
11015 "ALU64_DIV_K: all immediate value magnitudes",
11016 { },
11017 INTERNAL | FLAG_NO_DATA,
11018 { },
11019 { { 0, 1 } },
11020 .fill_helper = bpf_fill_alu64_div_imm,
11021 .nr_testruns = NR_PATTERN_RUNS,
11022 },
11023 {
11024 "ALU64_MOD_K: all immediate value magnitudes",
11025 { },
11026 INTERNAL | FLAG_NO_DATA,
11027 { },
11028 { { 0, 1 } },
11029 .fill_helper = bpf_fill_alu64_mod_imm,
11030 .nr_testruns = NR_PATTERN_RUNS,
11031 },
11032 /* ALU32 immediate magnitudes */
11033 {
11034 "ALU32_MOV_K: all immediate value magnitudes",
11035 { },
11036 INTERNAL | FLAG_NO_DATA,
11037 { },
11038 { { 0, 1 } },
11039 .fill_helper = bpf_fill_alu32_mov_imm,
11040 .nr_testruns = NR_PATTERN_RUNS,
11041 },
11042 {
11043 "ALU32_AND_K: all immediate value magnitudes",
11044 { },
11045 INTERNAL | FLAG_NO_DATA,
11046 { },
11047 { { 0, 1 } },
11048 .fill_helper = bpf_fill_alu32_and_imm,
11049 .nr_testruns = NR_PATTERN_RUNS,
11050 },
11051 {
11052 "ALU32_OR_K: all immediate value magnitudes",
11053 { },
11054 INTERNAL | FLAG_NO_DATA,
11055 { },
11056 { { 0, 1 } },
11057 .fill_helper = bpf_fill_alu32_or_imm,
11058 .nr_testruns = NR_PATTERN_RUNS,
11059 },
11060 {
11061 "ALU32_XOR_K: all immediate value magnitudes",
11062 { },
11063 INTERNAL | FLAG_NO_DATA,
11064 { },
11065 { { 0, 1 } },
11066 .fill_helper = bpf_fill_alu32_xor_imm,
11067 .nr_testruns = NR_PATTERN_RUNS,
11068 },
11069 {
11070 "ALU32_ADD_K: all immediate value magnitudes",
11071 { },
11072 INTERNAL | FLAG_NO_DATA,
11073 { },
11074 { { 0, 1 } },
11075 .fill_helper = bpf_fill_alu32_add_imm,
11076 .nr_testruns = NR_PATTERN_RUNS,
11077 },
11078 {
11079 "ALU32_SUB_K: all immediate value magnitudes",
11080 { },
11081 INTERNAL | FLAG_NO_DATA,
11082 { },
11083 { { 0, 1 } },
11084 .fill_helper = bpf_fill_alu32_sub_imm,
11085 .nr_testruns = NR_PATTERN_RUNS,
11086 },
11087 {
11088 "ALU32_MUL_K: all immediate value magnitudes",
11089 { },
11090 INTERNAL | FLAG_NO_DATA,
11091 { },
11092 { { 0, 1 } },
11093 .fill_helper = bpf_fill_alu32_mul_imm,
11094 .nr_testruns = NR_PATTERN_RUNS,
11095 },
11096 {
11097 "ALU32_DIV_K: all immediate value magnitudes",
11098 { },
11099 INTERNAL | FLAG_NO_DATA,
11100 { },
11101 { { 0, 1 } },
11102 .fill_helper = bpf_fill_alu32_div_imm,
11103 .nr_testruns = NR_PATTERN_RUNS,
11104 },
11105 {
11106 "ALU32_MOD_K: all immediate value magnitudes",
11107 { },
11108 INTERNAL | FLAG_NO_DATA,
11109 { },
11110 { { 0, 1 } },
11111 .fill_helper = bpf_fill_alu32_mod_imm,
a5a36544 11112 .nr_testruns = NR_PATTERN_RUNS,
9298e63e
JA		 11113 },
11114 /* ALU64 register magnitudes */
11115 {
11116 "ALU64_MOV_X: all register value magnitudes",
11117 { },
11118 INTERNAL | FLAG_NO_DATA,
11119 { },
11120 { { 0, 1 } },
11121 .fill_helper = bpf_fill_alu64_mov_reg,
11122 .nr_testruns = NR_PATTERN_RUNS,
11123 },
11124 {
11125 "ALU64_AND_X: all register value magnitudes",
11126 { },
11127 INTERNAL | FLAG_NO_DATA,
11128 { },
11129 { { 0, 1 } },
11130 .fill_helper = bpf_fill_alu64_and_reg,
11131 .nr_testruns = NR_PATTERN_RUNS,
11132 },
11133 {
11134 "ALU64_OR_X: all register value magnitudes",
11135 { },
11136 INTERNAL | FLAG_NO_DATA,
11137 { },
11138 { { 0, 1 } },
11139 .fill_helper = bpf_fill_alu64_or_reg,
11140 .nr_testruns = NR_PATTERN_RUNS,
11141 },
11142 {
11143 "ALU64_XOR_X: all register value magnitudes",
11144 { },
11145 INTERNAL | FLAG_NO_DATA,
11146 { },
11147 { { 0, 1 } },
11148 .fill_helper = bpf_fill_alu64_xor_reg,
11149 .nr_testruns = NR_PATTERN_RUNS,
11150 },
11151 {
11152 "ALU64_ADD_X: all register value magnitudes",
11153 { },
11154 INTERNAL | FLAG_NO_DATA,
11155 { },
11156 { { 0, 1 } },
11157 .fill_helper = bpf_fill_alu64_add_reg,
11158 .nr_testruns = NR_PATTERN_RUNS,
11159 },
11160 {
11161 "ALU64_SUB_X: all register value magnitudes",
11162 { },
11163 INTERNAL | FLAG_NO_DATA,
11164 { },
11165 { { 0, 1 } },
11166 .fill_helper = bpf_fill_alu64_sub_reg,
11167 .nr_testruns = NR_PATTERN_RUNS,
11168 },
11169 {
11170 "ALU64_MUL_X: all register value magnitudes",
11171 { },
11172 INTERNAL | FLAG_NO_DATA,
11173 { },
11174 { { 0, 1 } },
11175 .fill_helper = bpf_fill_alu64_mul_reg,
11176 .nr_testruns = NR_PATTERN_RUNS,
11177 },
11178 {
11179 "ALU64_DIV_X: all register value magnitudes",
11180 { },
11181 INTERNAL | FLAG_NO_DATA,
11182 { },
11183 { { 0, 1 } },
11184 .fill_helper = bpf_fill_alu64_div_reg,
11185 .nr_testruns = NR_PATTERN_RUNS,
11186 },
11187 {
11188 "ALU64_MOD_X: all register value magnitudes",
11189 { },
11190 INTERNAL | FLAG_NO_DATA,
11191 { },
11192 { { 0, 1 } },
11193 .fill_helper = bpf_fill_alu64_mod_reg,
11194 .nr_testruns = NR_PATTERN_RUNS,
11195 },
11196 /* ALU32 register magnitudes */
11197 {
11198 "ALU32_MOV_X: all register value magnitudes",
11199 { },
11200 INTERNAL | FLAG_NO_DATA,
11201 { },
11202 { { 0, 1 } },
11203 .fill_helper = bpf_fill_alu32_mov_reg,
11204 .nr_testruns = NR_PATTERN_RUNS,
11205 },
11206 {
11207 "ALU32_AND_X: all register value magnitudes",
11208 { },
11209 INTERNAL | FLAG_NO_DATA,
11210 { },
11211 { { 0, 1 } },
11212 .fill_helper = bpf_fill_alu32_and_reg,
11213 .nr_testruns = NR_PATTERN_RUNS,
11214 },
11215 {
11216 "ALU32_OR_X: all register value magnitudes",
11217 { },
11218 INTERNAL | FLAG_NO_DATA,
11219 { },
11220 { { 0, 1 } },
11221 .fill_helper = bpf_fill_alu32_or_reg,
11222 .nr_testruns = NR_PATTERN_RUNS,
11223 },
11224 {
11225 "ALU32_XOR_X: all register value magnitudes",
11226 { },
11227 INTERNAL | FLAG_NO_DATA,
11228 { },
11229 { { 0, 1 } },
11230 .fill_helper = bpf_fill_alu32_xor_reg,
11231 .nr_testruns = NR_PATTERN_RUNS,
11232 },
11233 {
11234 "ALU32_ADD_X: all register value magnitudes",
11235 { },
11236 INTERNAL | FLAG_NO_DATA,
11237 { },
11238 { { 0, 1 } },
11239 .fill_helper = bpf_fill_alu32_add_reg,
11240 .nr_testruns = NR_PATTERN_RUNS,
11241 },
11242 {
11243 "ALU32_SUB_X: all register value magnitudes",
11244 { },
11245 INTERNAL | FLAG_NO_DATA,
11246 { },
11247 { { 0, 1 } },
11248 .fill_helper = bpf_fill_alu32_sub_reg,
11249 .nr_testruns = NR_PATTERN_RUNS,
11250 },
11251 {
11252 "ALU32_MUL_X: all register value magnitudes",
11253 { },
11254 INTERNAL | FLAG_NO_DATA,
11255 { },
11256 { { 0, 1 } },
11257 .fill_helper = bpf_fill_alu32_mul_reg,
11258 .nr_testruns = NR_PATTERN_RUNS,
11259 },
11260 {
11261 "ALU32_DIV_X: all register value magnitudes",
11262 { },
11263 INTERNAL | FLAG_NO_DATA,
11264 { },
11265 { { 0, 1 } },
11266 .fill_helper = bpf_fill_alu32_div_reg,
11267 .nr_testruns = NR_PATTERN_RUNS,
11268 },
11269 {
11270 "ALU32_MOD_X: all register value magnitudes",
11271 { },
11272 INTERNAL | FLAG_NO_DATA,
11273 { },
11274 { { 0, 1 } },
11275 .fill_helper = bpf_fill_alu32_mod_reg,
11276 .nr_testruns = NR_PATTERN_RUNS,
11277 },
2e807611
JA		 11278 /* LD_IMM64 immediate magnitudes */
11279 {
11280 "LD_IMM64: all immediate value magnitudes",
11281 { },
11282 INTERNAL | FLAG_NO_DATA,
11283 { },
11284 { { 0, 1 } },
11285 .fill_helper = bpf_fill_ld_imm64,
11286 },
f68e8efd
JA		 11287 /* 64-bit ATOMIC magnitudes */
11288 {
11289 "ATOMIC_DW_ADD: all operand magnitudes",
11290 { },
11291 INTERNAL | FLAG_NO_DATA,
11292 { },
11293 { { 0, 1 } },
11294 .fill_helper = bpf_fill_atomic64_add,
11295 .stack_depth = 8,
11296 .nr_testruns = NR_PATTERN_RUNS,
11297 },
11298 {
11299 "ATOMIC_DW_AND: all operand magnitudes",
11300 { },
11301 INTERNAL | FLAG_NO_DATA,
11302 { },
11303 { { 0, 1 } },
11304 .fill_helper = bpf_fill_atomic64_and,
11305 .stack_depth = 8,
11306 .nr_testruns = NR_PATTERN_RUNS,
11307 },
11308 {
11309 "ATOMIC_DW_OR: all operand magnitudes",
11310 { },
11311 INTERNAL | FLAG_NO_DATA,
11312 { },
11313 { { 0, 1 } },
11314 .fill_helper = bpf_fill_atomic64_or,
11315 .stack_depth = 8,
11316 .nr_testruns = NR_PATTERN_RUNS,
11317 },
11318 {
11319 "ATOMIC_DW_XOR: all operand magnitudes",
11320 { },
11321 INTERNAL | FLAG_NO_DATA,
11322 { },
11323 { { 0, 1 } },
11324 .fill_helper = bpf_fill_atomic64_xor,
11325 .stack_depth = 8,
11326 .nr_testruns = NR_PATTERN_RUNS,
11327 },
11328 {
11329 "ATOMIC_DW_ADD_FETCH: all operand magnitudes",
11330 { },
11331 INTERNAL | FLAG_NO_DATA,
11332 { },
11333 { { 0, 1 } },
11334 .fill_helper = bpf_fill_atomic64_add_fetch,
11335 .stack_depth = 8,
11336 .nr_testruns = NR_PATTERN_RUNS,
11337 },
11338 {
11339 "ATOMIC_DW_AND_FETCH: all operand magnitudes",
11340 { },
11341 INTERNAL | FLAG_NO_DATA,
11342 { },
11343 { { 0, 1 } },
11344 .fill_helper = bpf_fill_atomic64_and_fetch,
11345 .stack_depth = 8,
11346 .nr_testruns = NR_PATTERN_RUNS,
11347 },
11348 {
11349 "ATOMIC_DW_OR_FETCH: all operand magnitudes",
11350 { },
11351 INTERNAL | FLAG_NO_DATA,
11352 { },
11353 { { 0, 1 } },
11354 .fill_helper = bpf_fill_atomic64_or_fetch,
11355 .stack_depth = 8,
11356 .nr_testruns = NR_PATTERN_RUNS,
11357 },
11358 {
11359 "ATOMIC_DW_XOR_FETCH: all operand magnitudes",
11360 { },
11361 INTERNAL | FLAG_NO_DATA,
11362 { },
11363 { { 0, 1 } },
11364 .fill_helper = bpf_fill_atomic64_xor_fetch,
11365 .stack_depth = 8,
11366 .nr_testruns = NR_PATTERN_RUNS,
11367 },
11368 {
11369 "ATOMIC_DW_XCHG: all operand magnitudes",
11370 { },
11371 INTERNAL | FLAG_NO_DATA,
11372 { },
11373 { { 0, 1 } },
11374 .fill_helper = bpf_fill_atomic64_xchg,
11375 .stack_depth = 8,
11376 .nr_testruns = NR_PATTERN_RUNS,
11377 },
11378 {
11379 "ATOMIC_DW_CMPXCHG: all operand magnitudes",
11380 { },
11381 INTERNAL | FLAG_NO_DATA,
11382 { },
11383 { { 0, 1 } },
11384 .fill_helper = bpf_fill_cmpxchg64,
11385 .stack_depth = 8,
11386 .nr_testruns = NR_PATTERN_RUNS,
11387 },
11388 /* 64-bit atomic magnitudes */
11389 {
11390 "ATOMIC_W_ADD: all operand magnitudes",
11391 { },
11392 INTERNAL | FLAG_NO_DATA,
11393 { },
11394 { { 0, 1 } },
11395 .fill_helper = bpf_fill_atomic32_add,
11396 .stack_depth = 8,
11397 .nr_testruns = NR_PATTERN_RUNS,
11398 },
11399 {
11400 "ATOMIC_W_AND: all operand magnitudes",
11401 { },
11402 INTERNAL | FLAG_NO_DATA,
11403 { },
11404 { { 0, 1 } },
11405 .fill_helper = bpf_fill_atomic32_and,
11406 .stack_depth = 8,
11407 .nr_testruns = NR_PATTERN_RUNS,
11408 },
11409 {
11410 "ATOMIC_W_OR: all operand magnitudes",
11411 { },
11412 INTERNAL | FLAG_NO_DATA,
11413 { },
11414 { { 0, 1 } },
11415 .fill_helper = bpf_fill_atomic32_or,
11416 .stack_depth = 8,
11417 .nr_testruns = NR_PATTERN_RUNS,
11418 },
11419 {
11420 "ATOMIC_W_XOR: all operand magnitudes",
11421 { },
11422 INTERNAL | FLAG_NO_DATA,
11423 { },
11424 { { 0, 1 } },
11425 .fill_helper = bpf_fill_atomic32_xor,
11426 .stack_depth = 8,
11427 .nr_testruns = NR_PATTERN_RUNS,
11428 },
11429 {
11430 "ATOMIC_W_ADD_FETCH: all operand magnitudes",
11431 { },
11432 INTERNAL | FLAG_NO_DATA,
11433 { },
11434 { { 0, 1 } },
11435 .fill_helper = bpf_fill_atomic32_add_fetch,
11436 .stack_depth = 8,
11437 .nr_testruns = NR_PATTERN_RUNS,
11438 },
11439 {
11440 "ATOMIC_W_AND_FETCH: all operand magnitudes",
11441 { },
11442 INTERNAL | FLAG_NO_DATA,
11443 { },
11444 { { 0, 1 } },
11445 .fill_helper = bpf_fill_atomic32_and_fetch,
11446 .stack_depth = 8,
11447 .nr_testruns = NR_PATTERN_RUNS,
11448 },
11449 {
11450 "ATOMIC_W_OR_FETCH: all operand magnitudes",
11451 { },
11452 INTERNAL | FLAG_NO_DATA,
11453 { },
11454 { { 0, 1 } },
11455 .fill_helper = bpf_fill_atomic32_or_fetch,
11456 .stack_depth = 8,
11457 .nr_testruns = NR_PATTERN_RUNS,
11458 },
11459 {
11460 "ATOMIC_W_XOR_FETCH: all operand magnitudes",
11461 { },
11462 INTERNAL | FLAG_NO_DATA,
11463 { },
11464 { { 0, 1 } },
11465 .fill_helper = bpf_fill_atomic32_xor_fetch,
11466 .stack_depth = 8,
11467 .nr_testruns = NR_PATTERN_RUNS,
11468 },
11469 {
11470 "ATOMIC_W_XCHG: all operand magnitudes",
11471 { },
11472 INTERNAL | FLAG_NO_DATA,
11473 { },
11474 { { 0, 1 } },
11475 .fill_helper = bpf_fill_atomic32_xchg,
11476 .stack_depth = 8,
11477 .nr_testruns = NR_PATTERN_RUNS,
11478 },
11479 {
11480 "ATOMIC_W_CMPXCHG: all operand magnitudes",
11481 { },
11482 INTERNAL | FLAG_NO_DATA,
11483 { },
11484 { { 0, 1 } },
11485 .fill_helper = bpf_fill_cmpxchg32,
11486 .stack_depth = 8,
11487 .nr_testruns = NR_PATTERN_RUNS,
11488 },
a5a36544
JA		 11489 /* JMP immediate magnitudes */
11490 {
11491 "JMP_JSET_K: all immediate value magnitudes",
11492 { },
11493 INTERNAL | FLAG_NO_DATA,
11494 { },
11495 { { 0, 1 } },
11496 .fill_helper = bpf_fill_jmp_jset_imm,
11497 .nr_testruns = NR_PATTERN_RUNS,
11498 },
11499 {
11500 "JMP_JEQ_K: all immediate value magnitudes",
11501 { },
11502 INTERNAL | FLAG_NO_DATA,
11503 { },
11504 { { 0, 1 } },
11505 .fill_helper = bpf_fill_jmp_jeq_imm,
11506 .nr_testruns = NR_PATTERN_RUNS,
11507 },
11508 {
11509 "JMP_JNE_K: all immediate value magnitudes",
11510 { },
11511 INTERNAL | FLAG_NO_DATA,
11512 { },
11513 { { 0, 1 } },
11514 .fill_helper = bpf_fill_jmp_jne_imm,
11515 .nr_testruns = NR_PATTERN_RUNS,
11516 },
11517 {
11518 "JMP_JGT_K: all immediate value magnitudes",
11519 { },
11520 INTERNAL | FLAG_NO_DATA,
11521 { },
11522 { { 0, 1 } },
11523 .fill_helper = bpf_fill_jmp_jgt_imm,
11524 .nr_testruns = NR_PATTERN_RUNS,
11525 },
11526 {
11527 "JMP_JGE_K: all immediate value magnitudes",
11528 { },
11529 INTERNAL | FLAG_NO_DATA,
11530 { },
11531 { { 0, 1 } },
11532 .fill_helper = bpf_fill_jmp_jge_imm,
11533 .nr_testruns = NR_PATTERN_RUNS,
11534 },
11535 {
11536 "JMP_JLT_K: all immediate value magnitudes",
11537 { },
11538 INTERNAL | FLAG_NO_DATA,
11539 { },
11540 { { 0, 1 } },
11541 .fill_helper = bpf_fill_jmp_jlt_imm,
11542 .nr_testruns = NR_PATTERN_RUNS,
11543 },
11544 {
11545 "JMP_JLE_K: all immediate value magnitudes",
11546 { },
11547 INTERNAL | FLAG_NO_DATA,
11548 { },
11549 { { 0, 1 } },
11550 .fill_helper = bpf_fill_jmp_jle_imm,
11551 .nr_testruns = NR_PATTERN_RUNS,
11552 },
11553 {
11554 "JMP_JSGT_K: all immediate value magnitudes",
11555 { },
11556 INTERNAL | FLAG_NO_DATA,
11557 { },
11558 { { 0, 1 } },
11559 .fill_helper = bpf_fill_jmp_jsgt_imm,
11560 .nr_testruns = NR_PATTERN_RUNS,
11561 },
11562 {
11563 "JMP_JSGE_K: all immediate value magnitudes",
11564 { },
11565 INTERNAL | FLAG_NO_DATA,
11566 { },
11567 { { 0, 1 } },
11568 .fill_helper = bpf_fill_jmp_jsge_imm,
11569 .nr_testruns = NR_PATTERN_RUNS,
11570 },
11571 {
11572 "JMP_JSLT_K: all immediate value magnitudes",
11573 { },
11574 INTERNAL | FLAG_NO_DATA,
11575 { },
11576 { { 0, 1 } },
11577 .fill_helper = bpf_fill_jmp_jslt_imm,
11578 .nr_testruns = NR_PATTERN_RUNS,
11579 },
11580 {
11581 "JMP_JSLE_K: all immediate value magnitudes",
11582 { },
11583 INTERNAL | FLAG_NO_DATA,
11584 { },
11585 { { 0, 1 } },
11586 .fill_helper = bpf_fill_jmp_jsle_imm,
11587 .nr_testruns = NR_PATTERN_RUNS,
11588 },
11589 /* JMP register magnitudes */
11590 {
11591 "JMP_JSET_X: all register value magnitudes",
11592 { },
11593 INTERNAL | FLAG_NO_DATA,
11594 { },
11595 { { 0, 1 } },
11596 .fill_helper = bpf_fill_jmp_jset_reg,
11597 .nr_testruns = NR_PATTERN_RUNS,
11598 },
11599 {
11600 "JMP_JEQ_X: all register value magnitudes",
11601 { },
11602 INTERNAL | FLAG_NO_DATA,
11603 { },
11604 { { 0, 1 } },
11605 .fill_helper = bpf_fill_jmp_jeq_reg,
11606 .nr_testruns = NR_PATTERN_RUNS,
11607 },
11608 {
11609 "JMP_JNE_X: all register value magnitudes",
11610 { },
11611 INTERNAL | FLAG_NO_DATA,
11612 { },
11613 { { 0, 1 } },
11614 .fill_helper = bpf_fill_jmp_jne_reg,
11615 .nr_testruns = NR_PATTERN_RUNS,
11616 },
11617 {
11618 "JMP_JGT_X: all register value magnitudes",
11619 { },
11620 INTERNAL | FLAG_NO_DATA,
11621 { },
11622 { { 0, 1 } },
11623 .fill_helper = bpf_fill_jmp_jgt_reg,
11624 .nr_testruns = NR_PATTERN_RUNS,
11625 },
11626 {
11627 "JMP_JGE_X: all register value magnitudes",
11628 { },
11629 INTERNAL | FLAG_NO_DATA,
11630 { },
11631 { { 0, 1 } },
11632 .fill_helper = bpf_fill_jmp_jge_reg,
11633 .nr_testruns = NR_PATTERN_RUNS,
11634 },
11635 {
11636 "JMP_JLT_X: all register value magnitudes",
11637 { },
11638 INTERNAL | FLAG_NO_DATA,
11639 { },
11640 { { 0, 1 } },
11641 .fill_helper = bpf_fill_jmp_jlt_reg,
11642 .nr_testruns = NR_PATTERN_RUNS,
11643 },
11644 {
11645 "JMP_JLE_X: all register value magnitudes",
11646 { },
11647 INTERNAL | FLAG_NO_DATA,
11648 { },
11649 { { 0, 1 } },
11650 .fill_helper = bpf_fill_jmp_jle_reg,
11651 .nr_testruns = NR_PATTERN_RUNS,
11652 },
11653 {
11654 "JMP_JSGT_X: all register value magnitudes",
11655 { },
11656 INTERNAL | FLAG_NO_DATA,
11657 { },
11658 { { 0, 1 } },
11659 .fill_helper = bpf_fill_jmp_jsgt_reg,
11660 .nr_testruns = NR_PATTERN_RUNS,
11661 },
11662 {
11663 "JMP_JSGE_X: all register value magnitudes",
11664 { },
11665 INTERNAL | FLAG_NO_DATA,
11666 { },
11667 { { 0, 1 } },
11668 .fill_helper = bpf_fill_jmp_jsge_reg,
11669 .nr_testruns = NR_PATTERN_RUNS,
11670 },
11671 {
11672 "JMP_JSLT_X: all register value magnitudes",
11673 { },
11674 INTERNAL | FLAG_NO_DATA,
11675 { },
11676 { { 0, 1 } },
11677 .fill_helper = bpf_fill_jmp_jslt_reg,
11678 .nr_testruns = NR_PATTERN_RUNS,
11679 },
11680 {
11681 "JMP_JSLE_X: all register value magnitudes",
11682 { },
11683 INTERNAL | FLAG_NO_DATA,
11684 { },
11685 { { 0, 1 } },
11686 .fill_helper = bpf_fill_jmp_jsle_reg,
11687 .nr_testruns = NR_PATTERN_RUNS,
11688 },
11689 /* JMP32 immediate magnitudes */
11690 {
11691 "JMP32_JSET_K: all immediate value magnitudes",
11692 { },
11693 INTERNAL | FLAG_NO_DATA,
11694 { },
11695 { { 0, 1 } },
11696 .fill_helper = bpf_fill_jmp32_jset_imm,
11697 .nr_testruns = NR_PATTERN_RUNS,
11698 },
11699 {
11700 "JMP32_JEQ_K: all immediate value magnitudes",
11701 { },
11702 INTERNAL | FLAG_NO_DATA,
11703 { },
11704 { { 0, 1 } },
11705 .fill_helper = bpf_fill_jmp32_jeq_imm,
11706 .nr_testruns = NR_PATTERN_RUNS,
11707 },
11708 {
11709 "JMP32_JNE_K: all immediate value magnitudes",
11710 { },
11711 INTERNAL | FLAG_NO_DATA,
11712 { },
11713 { { 0, 1 } },
11714 .fill_helper = bpf_fill_jmp32_jne_imm,
11715 .nr_testruns = NR_PATTERN_RUNS,
11716 },
11717 {
11718 "JMP32_JGT_K: all immediate value magnitudes",
11719 { },
11720 INTERNAL | FLAG_NO_DATA,
11721 { },
11722 { { 0, 1 } },
11723 .fill_helper = bpf_fill_jmp32_jgt_imm,
11724 .nr_testruns = NR_PATTERN_RUNS,
11725 },
11726 {
11727 "JMP32_JGE_K: all immediate value magnitudes",
11728 { },
11729 INTERNAL | FLAG_NO_DATA,
11730 { },
11731 { { 0, 1 } },
11732 .fill_helper = bpf_fill_jmp32_jge_imm,
11733 .nr_testruns = NR_PATTERN_RUNS,
11734 },
11735 {
11736 "JMP32_JLT_K: all immediate value magnitudes",
11737 { },
11738 INTERNAL | FLAG_NO_DATA,
11739 { },
11740 { { 0, 1 } },
11741 .fill_helper = bpf_fill_jmp32_jlt_imm,
11742 .nr_testruns = NR_PATTERN_RUNS,
11743 },
11744 {
11745 "JMP32_JLE_K: all immediate value magnitudes",
11746 { },
11747 INTERNAL | FLAG_NO_DATA,
11748 { },
11749 { { 0, 1 } },
11750 .fill_helper = bpf_fill_jmp32_jle_imm,
11751 .nr_testruns = NR_PATTERN_RUNS,
11752 },
11753 {
11754 "JMP32_JSGT_K: all immediate value magnitudes",
11755 { },
11756 INTERNAL | FLAG_NO_DATA,
11757 { },
11758 { { 0, 1 } },
11759 .fill_helper = bpf_fill_jmp32_jsgt_imm,
11760 .nr_testruns = NR_PATTERN_RUNS,
11761 },
11762 {
11763 "JMP32_JSGE_K: all immediate value magnitudes",
11764 { },
11765 INTERNAL | FLAG_NO_DATA,
11766 { },
11767 { { 0, 1 } },
11768 .fill_helper = bpf_fill_jmp32_jsge_imm,
11769 .nr_testruns = NR_PATTERN_RUNS,
11770 },
11771 {
11772 "JMP32_JSLT_K: all immediate value magnitudes",
11773 { },
11774 INTERNAL | FLAG_NO_DATA,
11775 { },
11776 { { 0, 1 } },
11777 .fill_helper = bpf_fill_jmp32_jslt_imm,
11778 .nr_testruns = NR_PATTERN_RUNS,
11779 },
11780 {
11781 "JMP32_JSLE_K: all immediate value magnitudes",
11782 { },
11783 INTERNAL | FLAG_NO_DATA,
11784 { },
11785 { { 0, 1 } },
11786 .fill_helper = bpf_fill_jmp32_jsle_imm,
11787 .nr_testruns = NR_PATTERN_RUNS,
11788 },
11789 /* JMP32 register magnitudes */
11790 {
11791 "JMP32_JSET_X: all register value magnitudes",
11792 { },
11793 INTERNAL | FLAG_NO_DATA,
11794 { },
11795 { { 0, 1 } },
11796 .fill_helper = bpf_fill_jmp32_jset_reg,
11797 .nr_testruns = NR_PATTERN_RUNS,
11798 },
11799 {
11800 "JMP32_JEQ_X: all register value magnitudes",
11801 { },
11802 INTERNAL | FLAG_NO_DATA,
11803 { },
11804 { { 0, 1 } },
11805 .fill_helper = bpf_fill_jmp32_jeq_reg,
11806 .nr_testruns = NR_PATTERN_RUNS,
11807 },
11808 {
11809 "JMP32_JNE_X: all register value magnitudes",
11810 { },
11811 INTERNAL | FLAG_NO_DATA,
11812 { },
11813 { { 0, 1 } },
11814 .fill_helper = bpf_fill_jmp32_jne_reg,
11815 .nr_testruns = NR_PATTERN_RUNS,
11816 },
11817 {
11818 "JMP32_JGT_X: all register value magnitudes",
11819 { },
11820 INTERNAL | FLAG_NO_DATA,
11821 { },
11822 { { 0, 1 } },
11823 .fill_helper = bpf_fill_jmp32_jgt_reg,
11824 .nr_testruns = NR_PATTERN_RUNS,
11825 },
11826 {
11827 "JMP32_JGE_X: all register value magnitudes",
11828 { },
11829 INTERNAL | FLAG_NO_DATA,
11830 { },
11831 { { 0, 1 } },
11832 .fill_helper = bpf_fill_jmp32_jge_reg,
11833 .nr_testruns = NR_PATTERN_RUNS,
11834 },
11835 {
11836 "JMP32_JLT_X: all register value magnitudes",
11837 { },
11838 INTERNAL | FLAG_NO_DATA,
11839 { },
11840 { { 0, 1 } },
11841 .fill_helper = bpf_fill_jmp32_jlt_reg,
11842 .nr_testruns = NR_PATTERN_RUNS,
11843 },
11844 {
11845 "JMP32_JLE_X: all register value magnitudes",
11846 { },
11847 INTERNAL | FLAG_NO_DATA,
11848 { },
11849 { { 0, 1 } },
11850 .fill_helper = bpf_fill_jmp32_jle_reg,
11851 .nr_testruns = NR_PATTERN_RUNS,
11852 },
11853 {
11854 "JMP32_JSGT_X: all register value magnitudes",
11855 { },
11856 INTERNAL | FLAG_NO_DATA,
11857 { },
11858 { { 0, 1 } },
11859 .fill_helper = bpf_fill_jmp32_jsgt_reg,
11860 .nr_testruns = NR_PATTERN_RUNS,
11861 },
11862 {
11863 "JMP32_JSGE_X: all register value magnitudes",
11864 { },
11865 INTERNAL | FLAG_NO_DATA,
11866 { },
11867 { { 0, 1 } },
11868 .fill_helper = bpf_fill_jmp32_jsge_reg,
11869 .nr_testruns = NR_PATTERN_RUNS,
11870 },
11871 {
11872 "JMP32_JSLT_X: all register value magnitudes",
11873 { },
11874 INTERNAL | FLAG_NO_DATA,
11875 { },
11876 { { 0, 1 } },
11877 .fill_helper = bpf_fill_jmp32_jslt_reg,
11878 .nr_testruns = NR_PATTERN_RUNS,
11879 },
11880 {
11881 "JMP32_JSLE_X: all register value magnitudes",
11882 { },
11883 INTERNAL | FLAG_NO_DATA,
11884 { },
11885 { { 0, 1 } },
11886 .fill_helper = bpf_fill_jmp32_jsle_reg,
11887 .nr_testruns = NR_PATTERN_RUNS,
11888 },
c4df4559
JA		 11889 /* Conditional jumps with constant decision */
11890 {
11891 "JMP_JSET_K: imm = 0 -> never taken",
11892 .u.insns_int = {
11893 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11894 BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
11895 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11896 BPF_EXIT_INSN(),
11897 },
11898 INTERNAL | FLAG_NO_DATA,
11899 { },
11900 { { 0, 0 } },
11901 },
11902 {
11903 "JMP_JLT_K: imm = 0 -> never taken",
11904 .u.insns_int = {
11905 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11906 BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
11907 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11908 BPF_EXIT_INSN(),
11909 },
11910 INTERNAL | FLAG_NO_DATA,
11911 { },
11912 { { 0, 0 } },
11913 },
11914 {
11915 "JMP_JGE_K: imm = 0 -> always taken",
11916 .u.insns_int = {
11917 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11918 BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
11919 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11920 BPF_EXIT_INSN(),
11921 },
11922 INTERNAL | FLAG_NO_DATA,
11923 { },
11924 { { 0, 1 } },
11925 },
11926 {
11927 "JMP_JGT_K: imm = 0xffffffff -> never taken",
11928 .u.insns_int = {
11929 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11930 BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
11931 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11932 BPF_EXIT_INSN(),
11933 },
11934 INTERNAL | FLAG_NO_DATA,
11935 { },
11936 { { 0, 0 } },
11937 },
11938 {
11939 "JMP_JLE_K: imm = 0xffffffff -> always taken",
11940 .u.insns_int = {
11941 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11942 BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
11943 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11944 BPF_EXIT_INSN(),
11945 },
11946 INTERNAL | FLAG_NO_DATA,
11947 { },
11948 { { 0, 1 } },
11949 },
11950 {
11951 "JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
11952 .u.insns_int = {
11953 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11954 BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
11955 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11956 BPF_EXIT_INSN(),
11957 },
11958 INTERNAL | FLAG_NO_DATA,
11959 { },
11960 { { 0, 0 } },
11961 },
11962 {
11963 "JMP32_JSGE_K: imm = -0x80000000 -> always taken",
11964 .u.insns_int = {
11965 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11966 BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
11967 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11968 BPF_EXIT_INSN(),
11969 },
11970 INTERNAL | FLAG_NO_DATA,
11971 { },
11972 { { 0, 1 } },
11973 },
11974 {
11975 "JMP32_JSLT_K: imm = -0x80000000 -> never taken",
11976 .u.insns_int = {
11977 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11978 BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
11979 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11980 BPF_EXIT_INSN(),
11981 },
11982 INTERNAL | FLAG_NO_DATA,
11983 { },
11984 { { 0, 0 } },
11985 },
11986 {
11987 "JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
11988 .u.insns_int = {
11989 BPF_ALU64_IMM(BPF_MOV, R0, 1),
11990 BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
11991 BPF_ALU64_IMM(BPF_MOV, R0, 0),
11992 BPF_EXIT_INSN(),
11993 },
11994 INTERNAL | FLAG_NO_DATA,
11995 { },
11996 { { 0, 1 } },
11997 },
11998 {
11999 "JMP_JEQ_X: dst = src -> always taken",
12000 .u.insns_int = {
12001 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12002 BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
12003 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12004 BPF_EXIT_INSN(),
12005 },
12006 INTERNAL | FLAG_NO_DATA,
12007 { },
12008 { { 0, 1 } },
12009 },
12010 {
12011 "JMP_JGE_X: dst = src -> always taken",
12012 .u.insns_int = {
12013 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12014 BPF_JMP_REG(BPF_JGE, R1, R1, 1),
12015 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12016 BPF_EXIT_INSN(),
12017 },
12018 INTERNAL | FLAG_NO_DATA,
12019 { },
12020 { { 0, 1 } },
12021 },
12022 {
12023 "JMP_JLE_X: dst = src -> always taken",
12024 .u.insns_int = {
12025 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12026 BPF_JMP_REG(BPF_JLE, R1, R1, 1),
12027 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12028 BPF_EXIT_INSN(),
12029 },
12030 INTERNAL | FLAG_NO_DATA,
12031 { },
12032 { { 0, 1 } },
12033 },
12034 {
12035 "JMP_JSGE_X: dst = src -> always taken",
12036 .u.insns_int = {
12037 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12038 BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
12039 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12040 BPF_EXIT_INSN(),
12041 },
12042 INTERNAL | FLAG_NO_DATA,
12043 { },
12044 { { 0, 1 } },
12045 },
12046 {
12047 "JMP_JSLE_X: dst = src -> always taken",
12048 .u.insns_int = {
12049 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12050 BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
12051 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12052 BPF_EXIT_INSN(),
12053 },
12054 INTERNAL | FLAG_NO_DATA,
12055 { },
12056 { { 0, 1 } },
12057 },
12058 {
12059 "JMP_JNE_X: dst = src -> never taken",
12060 .u.insns_int = {
12061 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12062 BPF_JMP_REG(BPF_JNE, R1, R1, 1),
12063 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12064 BPF_EXIT_INSN(),
12065 },
12066 INTERNAL | FLAG_NO_DATA,
12067 { },
12068 { { 0, 0 } },
12069 },
12070 {
12071 "JMP_JGT_X: dst = src -> never taken",
12072 .u.insns_int = {
12073 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12074 BPF_JMP_REG(BPF_JGT, R1, R1, 1),
12075 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12076 BPF_EXIT_INSN(),
12077 },
12078 INTERNAL | FLAG_NO_DATA,
12079 { },
12080 { { 0, 0 } },
12081 },
12082 {
12083 "JMP_JLT_X: dst = src -> never taken",
12084 .u.insns_int = {
12085 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12086 BPF_JMP_REG(BPF_JLT, R1, R1, 1),
12087 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12088 BPF_EXIT_INSN(),
12089 },
12090 INTERNAL | FLAG_NO_DATA,
12091 { },
12092 { { 0, 0 } },
12093 },
12094 {
12095 "JMP_JSGT_X: dst = src -> never taken",
12096 .u.insns_int = {
12097 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12098 BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
12099 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12100 BPF_EXIT_INSN(),
12101 },
12102 INTERNAL | FLAG_NO_DATA,
12103 { },
12104 { { 0, 0 } },
12105 },
12106 {
12107 "JMP_JSLT_X: dst = src -> never taken",
12108 .u.insns_int = {
12109 BPF_ALU64_IMM(BPF_MOV, R0, 1),
12110 BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
12111 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12112 BPF_EXIT_INSN(),
12113 },
12114 INTERNAL | FLAG_NO_DATA,
12115 { },
12116 { { 0, 0 } },
12117 },
d4ff9ee2
JA		 12118 /* Short relative jumps */
12119 {
12120 "Short relative jump: offset=0",
12121 .u.insns_int = {
12122 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12123 BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
12124 BPF_EXIT_INSN(),
12125 BPF_ALU32_IMM(BPF_MOV, R0, -1),
12126 },
12127 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12128 { },
12129 { { 0, 0 } },
12130 },
12131 {
12132 "Short relative jump: offset=1",
12133 .u.insns_int = {
12134 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12135 BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
12136 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12137 BPF_EXIT_INSN(),
12138 BPF_ALU32_IMM(BPF_MOV, R0, -1),
12139 },
12140 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12141 { },
12142 { { 0, 0 } },
12143 },
12144 {
12145 "Short relative jump: offset=2",
12146 .u.insns_int = {
12147 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12148 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
12149 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12150 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12151 BPF_EXIT_INSN(),
12152 BPF_ALU32_IMM(BPF_MOV, R0, -1),
12153 },
12154 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12155 { },
12156 { { 0, 0 } },
12157 },
12158 {
12159 "Short relative jump: offset=3",
12160 .u.insns_int = {
12161 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12162 BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
12163 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12164 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12165 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12166 BPF_EXIT_INSN(),
12167 BPF_ALU32_IMM(BPF_MOV, R0, -1),
12168 },
12169 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12170 { },
12171 { { 0, 0 } },
12172 },
12173 {
12174 "Short relative jump: offset=4",
12175 .u.insns_int = {
12176 BPF_ALU64_IMM(BPF_MOV, R0, 0),
12177 BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
12178 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12179 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12180 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12181 BPF_ALU32_IMM(BPF_ADD, R0, 1),
12182 BPF_EXIT_INSN(),
12183 BPF_ALU32_IMM(BPF_MOV, R0, -1),
12184 },
12185 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
12186 { },
12187 { { 0, 0 } },
12188 },
f1517eb7
JA		 12189 /* Conditional branch conversions */
12190 {
12191 "Long conditional jump: taken at runtime",
12192 { },
12193 INTERNAL | FLAG_NO_DATA,
12194 { },
12195 { { 0, 1 } },
12196 .fill_helper = bpf_fill_max_jmp_taken,
12197 },
12198 {
12199 "Long conditional jump: not taken at runtime",
12200 { },
12201 INTERNAL | FLAG_NO_DATA,
12202 { },
12203 { { 0, 2 } },
12204 .fill_helper = bpf_fill_max_jmp_not_taken,
12205 },
12206 {
12207 "Long conditional jump: always taken, known at JIT time",
12208 { },
12209 INTERNAL | FLAG_NO_DATA,
12210 { },
12211 { { 0, 1 } },
12212 .fill_helper = bpf_fill_max_jmp_always_taken,
12213 },
12214 {
12215 "Long conditional jump: never taken, known at JIT time",
12216 { },
12217 INTERNAL | FLAG_NO_DATA,
12218 { },
12219 { { 0, 2 } },
12220 .fill_helper = bpf_fill_max_jmp_never_taken,
12221 },
a7d2e752
JA		 12222 /* Staggered jump sequences, immediate */
12223 {
12224 "Staggered jumps: JMP_JA",
12225 { },
12226 INTERNAL | FLAG_NO_DATA,
12227 { },
12228 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12229 .fill_helper = bpf_fill_staggered_ja,
12230 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12231 },
12232 {
12233 "Staggered jumps: JMP_JEQ_K",
12234 { },
12235 INTERNAL | FLAG_NO_DATA,
12236 { },
12237 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12238 .fill_helper = bpf_fill_staggered_jeq_imm,
12239 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12240 },
12241 {
12242 "Staggered jumps: JMP_JNE_K",
12243 { },
12244 INTERNAL | FLAG_NO_DATA,
12245 { },
12246 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12247 .fill_helper = bpf_fill_staggered_jne_imm,
12248 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12249 },
12250 {
12251 "Staggered jumps: JMP_JSET_K",
12252 { },
12253 INTERNAL | FLAG_NO_DATA,
12254 { },
12255 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12256 .fill_helper = bpf_fill_staggered_jset_imm,
12257 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12258 },
12259 {
12260 "Staggered jumps: JMP_JGT_K",
12261 { },
12262 INTERNAL | FLAG_NO_DATA,
12263 { },
12264 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12265 .fill_helper = bpf_fill_staggered_jgt_imm,
12266 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12267 },
12268 {
12269 "Staggered jumps: JMP_JGE_K",
12270 { },
12271 INTERNAL | FLAG_NO_DATA,
12272 { },
12273 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12274 .fill_helper = bpf_fill_staggered_jge_imm,
12275 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12276 },
12277 {
12278 "Staggered jumps: JMP_JLT_K",
12279 { },
12280 INTERNAL | FLAG_NO_DATA,
12281 { },
12282 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12283 .fill_helper = bpf_fill_staggered_jlt_imm,
12284 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12285 },
12286 {
12287 "Staggered jumps: JMP_JLE_K",
12288 { },
12289 INTERNAL | FLAG_NO_DATA,
12290 { },
12291 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12292 .fill_helper = bpf_fill_staggered_jle_imm,
12293 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12294 },
12295 {
12296 "Staggered jumps: JMP_JSGT_K",
12297 { },
12298 INTERNAL | FLAG_NO_DATA,
12299 { },
12300 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12301 .fill_helper = bpf_fill_staggered_jsgt_imm,
12302 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12303 },
12304 {
12305 "Staggered jumps: JMP_JSGE_K",
12306 { },
12307 INTERNAL | FLAG_NO_DATA,
12308 { },
12309 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12310 .fill_helper = bpf_fill_staggered_jsge_imm,
12311 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12312 },
12313 {
12314 "Staggered jumps: JMP_JSLT_K",
12315 { },
12316 INTERNAL | FLAG_NO_DATA,
12317 { },
12318 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12319 .fill_helper = bpf_fill_staggered_jslt_imm,
12320 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12321 },
12322 {
12323 "Staggered jumps: JMP_JSLE_K",
12324 { },
12325 INTERNAL | FLAG_NO_DATA,
12326 { },
12327 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12328 .fill_helper = bpf_fill_staggered_jsle_imm,
12329 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12330 },
12331 /* Staggered jump sequences, register */
12332 {
12333 "Staggered jumps: JMP_JEQ_X",
12334 { },
12335 INTERNAL | FLAG_NO_DATA,
12336 { },
12337 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12338 .fill_helper = bpf_fill_staggered_jeq_reg,
12339 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12340 },
12341 {
12342 "Staggered jumps: JMP_JNE_X",
12343 { },
12344 INTERNAL | FLAG_NO_DATA,
12345 { },
12346 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12347 .fill_helper = bpf_fill_staggered_jne_reg,
12348 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12349 },
12350 {
12351 "Staggered jumps: JMP_JSET_X",
12352 { },
12353 INTERNAL | FLAG_NO_DATA,
12354 { },
12355 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12356 .fill_helper = bpf_fill_staggered_jset_reg,
12357 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12358 },
12359 {
12360 "Staggered jumps: JMP_JGT_X",
12361 { },
12362 INTERNAL | FLAG_NO_DATA,
12363 { },
12364 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12365 .fill_helper = bpf_fill_staggered_jgt_reg,
12366 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12367 },
12368 {
12369 "Staggered jumps: JMP_JGE_X",
12370 { },
12371 INTERNAL | FLAG_NO_DATA,
12372 { },
12373 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12374 .fill_helper = bpf_fill_staggered_jge_reg,
12375 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12376 },
12377 {
12378 "Staggered jumps: JMP_JLT_X",
12379 { },
12380 INTERNAL | FLAG_NO_DATA,
12381 { },
12382 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12383 .fill_helper = bpf_fill_staggered_jlt_reg,
12384 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12385 },
12386 {
12387 "Staggered jumps: JMP_JLE_X",
12388 { },
12389 INTERNAL | FLAG_NO_DATA,
12390 { },
12391 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12392 .fill_helper = bpf_fill_staggered_jle_reg,
12393 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12394 },
12395 {
12396 "Staggered jumps: JMP_JSGT_X",
12397 { },
12398 INTERNAL | FLAG_NO_DATA,
12399 { },
12400 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12401 .fill_helper = bpf_fill_staggered_jsgt_reg,
12402 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12403 },
12404 {
12405 "Staggered jumps: JMP_JSGE_X",
12406 { },
12407 INTERNAL | FLAG_NO_DATA,
12408 { },
12409 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12410 .fill_helper = bpf_fill_staggered_jsge_reg,
12411 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12412 },
12413 {
12414 "Staggered jumps: JMP_JSLT_X",
12415 { },
12416 INTERNAL | FLAG_NO_DATA,
12417 { },
12418 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12419 .fill_helper = bpf_fill_staggered_jslt_reg,
12420 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12421 },
12422 {
12423 "Staggered jumps: JMP_JSLE_X",
12424 { },
12425 INTERNAL | FLAG_NO_DATA,
12426 { },
12427 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12428 .fill_helper = bpf_fill_staggered_jsle_reg,
12429 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12430 },
12431 /* Staggered jump sequences, JMP32 immediate */
12432 {
12433 "Staggered jumps: JMP32_JEQ_K",
12434 { },
12435 INTERNAL | FLAG_NO_DATA,
12436 { },
12437 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12438 .fill_helper = bpf_fill_staggered_jeq32_imm,
12439 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12440 },
12441 {
12442 "Staggered jumps: JMP32_JNE_K",
12443 { },
12444 INTERNAL | FLAG_NO_DATA,
12445 { },
12446 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12447 .fill_helper = bpf_fill_staggered_jne32_imm,
12448 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12449 },
12450 {
12451 "Staggered jumps: JMP32_JSET_K",
12452 { },
12453 INTERNAL | FLAG_NO_DATA,
12454 { },
12455 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12456 .fill_helper = bpf_fill_staggered_jset32_imm,
12457 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12458 },
12459 {
12460 "Staggered jumps: JMP32_JGT_K",
12461 { },
12462 INTERNAL | FLAG_NO_DATA,
12463 { },
12464 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12465 .fill_helper = bpf_fill_staggered_jgt32_imm,
12466 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12467 },
12468 {
12469 "Staggered jumps: JMP32_JGE_K",
12470 { },
12471 INTERNAL | FLAG_NO_DATA,
12472 { },
12473 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12474 .fill_helper = bpf_fill_staggered_jge32_imm,
12475 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12476 },
12477 {
12478 "Staggered jumps: JMP32_JLT_K",
12479 { },
12480 INTERNAL | FLAG_NO_DATA,
12481 { },
12482 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12483 .fill_helper = bpf_fill_staggered_jlt32_imm,
12484 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12485 },
12486 {
12487 "Staggered jumps: JMP32_JLE_K",
12488 { },
12489 INTERNAL | FLAG_NO_DATA,
12490 { },
12491 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12492 .fill_helper = bpf_fill_staggered_jle32_imm,
12493 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12494 },
12495 {
12496 "Staggered jumps: JMP32_JSGT_K",
12497 { },
12498 INTERNAL | FLAG_NO_DATA,
12499 { },
12500 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12501 .fill_helper = bpf_fill_staggered_jsgt32_imm,
12502 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12503 },
12504 {
12505 "Staggered jumps: JMP32_JSGE_K",
12506 { },
12507 INTERNAL | FLAG_NO_DATA,
12508 { },
12509 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12510 .fill_helper = bpf_fill_staggered_jsge32_imm,
12511 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12512 },
12513 {
12514 "Staggered jumps: JMP32_JSLT_K",
12515 { },
12516 INTERNAL | FLAG_NO_DATA,
12517 { },
12518 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12519 .fill_helper = bpf_fill_staggered_jslt32_imm,
12520 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12521 },
12522 {
12523 "Staggered jumps: JMP32_JSLE_K",
12524 { },
12525 INTERNAL | FLAG_NO_DATA,
12526 { },
12527 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12528 .fill_helper = bpf_fill_staggered_jsle32_imm,
12529 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12530 },
12531 /* Staggered jump sequences, JMP32 register */
12532 {
12533 "Staggered jumps: JMP32_JEQ_X",
12534 { },
12535 INTERNAL | FLAG_NO_DATA,
12536 { },
12537 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12538 .fill_helper = bpf_fill_staggered_jeq32_reg,
12539 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12540 },
12541 {
12542 "Staggered jumps: JMP32_JNE_X",
12543 { },
12544 INTERNAL | FLAG_NO_DATA,
12545 { },
12546 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12547 .fill_helper = bpf_fill_staggered_jne32_reg,
12548 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12549 },
12550 {
12551 "Staggered jumps: JMP32_JSET_X",
12552 { },
12553 INTERNAL | FLAG_NO_DATA,
12554 { },
12555 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12556 .fill_helper = bpf_fill_staggered_jset32_reg,
12557 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12558 },
12559 {
12560 "Staggered jumps: JMP32_JGT_X",
12561 { },
12562 INTERNAL | FLAG_NO_DATA,
12563 { },
12564 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12565 .fill_helper = bpf_fill_staggered_jgt32_reg,
12566 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12567 },
12568 {
12569 "Staggered jumps: JMP32_JGE_X",
12570 { },
12571 INTERNAL | FLAG_NO_DATA,
12572 { },
12573 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12574 .fill_helper = bpf_fill_staggered_jge32_reg,
12575 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12576 },
12577 {
12578 "Staggered jumps: JMP32_JLT_X",
12579 { },
12580 INTERNAL | FLAG_NO_DATA,
12581 { },
12582 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12583 .fill_helper = bpf_fill_staggered_jlt32_reg,
12584 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12585 },
12586 {
12587 "Staggered jumps: JMP32_JLE_X",
12588 { },
12589 INTERNAL | FLAG_NO_DATA,
12590 { },
12591 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12592 .fill_helper = bpf_fill_staggered_jle32_reg,
12593 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12594 },
12595 {
12596 "Staggered jumps: JMP32_JSGT_X",
12597 { },
12598 INTERNAL | FLAG_NO_DATA,
12599 { },
12600 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12601 .fill_helper = bpf_fill_staggered_jsgt32_reg,
12602 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12603 },
12604 {
12605 "Staggered jumps: JMP32_JSGE_X",
12606 { },
12607 INTERNAL | FLAG_NO_DATA,
12608 { },
12609 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12610 .fill_helper = bpf_fill_staggered_jsge32_reg,
12611 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12612 },
12613 {
12614 "Staggered jumps: JMP32_JSLT_X",
12615 { },
12616 INTERNAL | FLAG_NO_DATA,
12617 { },
12618 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12619 .fill_helper = bpf_fill_staggered_jslt32_reg,
12620 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12621 },
12622 {
12623 "Staggered jumps: JMP32_JSLE_X",
12624 { },
12625 INTERNAL | FLAG_NO_DATA,
12626 { },
12627 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
12628 .fill_helper = bpf_fill_staggered_jsle32_reg,
12629 .nr_testruns = NR_STAGGERED_JMP_RUNS,
12630 },
64a8946b
AS		 12631};
12632
10f18e0b 12633static struct net_device dev;
64a8946b 12634
10f18e0b 12635static struct sk_buff *populate_skb(char *buf, int size)
64a8946b
AS		 12636{
12637 struct sk_buff *skb;
12638
12639 if (size >= MAX_DATA)
12640 return NULL;
12641
12642 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
12643 if (!skb)
12644 return NULL;
12645
de77b966 12646 __skb_put_data(skb, buf, size);
10f18e0b
DB		 12647
12648 /* Initialize a fake skb with test pattern. */
64a8946b
AS		 12649 skb_reset_mac_header(skb);
12650 skb->protocol = htons(ETH_P_IP);
12651 skb->pkt_type = SKB_TYPE;
12652 skb->mark = SKB_MARK;
12653 skb->hash = SKB_HASH;
12654 skb->queue_mapping = SKB_QUEUE_MAP;
12655 skb->vlan_tci = SKB_VLAN_TCI;
0c4b2d37 12656 skb->vlan_present = SKB_VLAN_PRESENT;
5c0ca3f5 12657 skb->vlan_proto = htons(ETH_P_IP);
10081193 12658 dev_net_set(&dev, &init_net);
64a8946b
AS		 12659 skb->dev = &dev;
12660 skb->dev->ifindex = SKB_DEV_IFINDEX;
12661 skb->dev->type = SKB_DEV_TYPE;
12662 skb_set_network_header(skb, min(size, ETH_HLEN));
12663
12664 return skb;
12665}
12666
10f18e0b 12667static void *generate_test_data(struct bpf_test *test, int sub)
64a8946b 12668{
bac142ac
NS		 12669 struct sk_buff *skb;
12670 struct page *page;
12671
10f18e0b
DB		 12672 if (test->aux & FLAG_NO_DATA)
12673 return NULL;
64a8946b 12674
10f18e0b
DB		 12675 /* Test case expects an skb, so populate one. Various
12676 * subtests generate skbs of different sizes based on
12677 * the same data.
12678 */
bac142ac
NS		 12679 skb = populate_skb(test->data, test->test[sub].data_size);
12680 if (!skb)
12681 return NULL;
12682
12683 if (test->aux & FLAG_SKB_FRAG) {
12684 /*
12685 * when the test requires a fragmented skb, add a
12686 * single fragment to the skb, filled with
12687 * test->frag_data.
12688 */
12689 void *ptr;
12690
12691 page = alloc_page(GFP_KERNEL);
12692
12693 if (!page)
12694 goto err_kfree_skb;
12695
12696 ptr = kmap(page);
12697 if (!ptr)
12698 goto err_free_page;
12699 memcpy(ptr, test->frag_data, MAX_DATA);
12700 kunmap(page);
12701 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
12702 }
12703
12704 return skb;
12705
12706err_free_page:
12707 __free_page(page);
12708err_kfree_skb:
12709 kfree_skb(skb);
12710 return NULL;
10f18e0b
DB		 12711}
12712
12713static void release_test_data(const struct bpf_test *test, void *data)
12714{
12715 if (test->aux & FLAG_NO_DATA)
12716 return;
12717
12718 kfree_skb(data);
12719}
12720
a4afd37b 12721static int filter_length(int which)
10f18e0b 12722{
a4afd37b
DB		 12723 struct sock_filter *fp;
12724 int len;
10f18e0b 12725
a4afd37b
DB		 12726 if (tests[which].fill_helper)
12727 return tests[which].u.ptr.len;
12728
12729 fp = tests[which].u.insns;
e9d94504
CG		 12730 for (len = MAX_INSNS - 1; len > 0; --len)
12731 if (fp[len].code != 0 || fp[len].k != 0)
12732 break;
10f18e0b 12733
e9d94504 12734 return len + 1;
10f18e0b
DB		 12735}
12736
a4afd37b
DB		 12737static void *filter_pointer(int which)
12738{
12739 if (tests[which].fill_helper)
12740 return tests[which].u.ptr.insns;
12741 else
12742 return tests[which].u.insns;
12743}
12744
7ae457c1 12745static struct bpf_prog *generate_filter(int which, int *err)
10f18e0b 12746{
10f18e0b 12747 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
a4afd37b
DB		 12748 unsigned int flen = filter_length(which);
12749 void *fptr = filter_pointer(which);
12750 struct sock_fprog_kern fprog;
12751 struct bpf_prog *fp;
10f18e0b
DB		 12752
12753 switch (test_type) {
12754 case CLASSIC:
a4afd37b 12755 fprog.filter = fptr;
10f18e0b
DB		 12756 fprog.len = flen;
12757
7ae457c1 12758 *err = bpf_prog_create(&fp, &fprog);
10f18e0b 12759 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
09584b40 12760 if (*err == tests[which].expected_errcode) {
10f18e0b
DB		 12761 pr_cont("PASS\n");
12762 /* Verifier rejected filter as expected. */
12763 *err = 0;
12764 return NULL;
12765 } else {
12766 pr_cont("UNEXPECTED_PASS\n");
12767 /* Verifier didn't reject the test that's
12768 * bad enough, just return!
12769 */
12770 *err = -EINVAL;
12771 return NULL;
12772 }
12773 }
10f18e0b 12774 if (*err) {
290af866 12775 pr_cont("FAIL to prog_create err=%d len=%d\n",
10f18e0b
DB		 12776 *err, fprog.len);
12777 return NULL;
12778 }
12779 break;
12780
12781 case INTERNAL:
60a3b225 12782 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
10f18e0b
DB		 12783 if (fp == NULL) {
12784 pr_cont("UNEXPECTED_FAIL no memory left\n");
12785 *err = -ENOMEM;
12786 return NULL;
64a8946b
AS		 12787 }
12788
10f18e0b 12789 fp->len = flen;
4962fa10
DB		 12790 /* Type doesn't really matter here as long as it's not unspec. */
12791 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
a4afd37b 12792 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
105c0361 12793 fp->aux->stack_depth = tests[which].stack_depth;
27cc6dac
JA		 12794 fp->aux->verifier_zext = !!(tests[which].aux &
12795 FLAG_VERIFIER_ZEXT);
64a8946b 12796
d1c55ab5
DB		 12797 /* We cannot error here as we don't need type compatibility
12798 * checks.
12799 */
12800 fp = bpf_prog_select_runtime(fp, err);
290af866
AS		 12801 if (*err) {
12802 pr_cont("FAIL to select_runtime err=%d\n", *err);
12803 return NULL;
12804 }
10f18e0b
DB		 12805 break;
12806 }
64a8946b 12807
10f18e0b
DB		 12808 *err = 0;
12809 return fp;
12810}
64a8946b 12811
7ae457c1 12812static void release_filter(struct bpf_prog *fp, int which)
10f18e0b
DB		 12813{
12814 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
64a8946b 12815
10f18e0b
DB		 12816 switch (test_type) {
12817 case CLASSIC:
7ae457c1 12818 bpf_prog_destroy(fp);
10f18e0b
DB		 12819 break;
12820 case INTERNAL:
7ae457c1 12821 bpf_prog_free(fp);
10f18e0b
DB		 12822 break;
12823 }
12824}
12825
7ae457c1 12826static int __run_one(const struct bpf_prog *fp, const void *data,
10f18e0b
DB		 12827 int runs, u64 *duration)
12828{
12829 u64 start, finish;
25ee7327 12830 int ret = 0, i;
10f18e0b 12831
6eac7795 12832 migrate_disable();
4d9c5c53 12833 start = ktime_get_ns();
10f18e0b
DB		 12834
12835 for (i = 0; i < runs; i++)
fb7dd8bc 12836 ret = bpf_prog_run(fp, data);
10f18e0b 12837
4d9c5c53 12838 finish = ktime_get_ns();
6eac7795 12839 migrate_enable();
10f18e0b 12840
4d9c5c53 12841 *duration = finish - start;
10f18e0b
DB		 12842 do_div(*duration, runs);
12843
12844 return ret;
12845}
12846
7ae457c1 12847static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
10f18e0b
DB		 12848{
12849 int err_cnt = 0, i, runs = MAX_TESTRUNS;
12850
c2a228d6
JA		 12851 if (test->nr_testruns)
12852 runs = min(test->nr_testruns, MAX_TESTRUNS);
12853
10f18e0b
DB		 12854 for (i = 0; i < MAX_SUBTESTS; i++) {
12855 void *data;
12856 u64 duration;
12857 u32 ret;
12858
2b7e9f25
JA		 12859 /*
12860 * NOTE: Several sub-tests may be present, in which case
12861 * a zero {data_size, result} tuple indicates the end of
12862 * the sub-test array. The first test is always run,
12863 * even if both data_size and result happen to be zero.
12864 */
12865 if (i > 0 &&
12866 test->test[i].data_size == 0 &&
10f18e0b
DB		 12867 test->test[i].result == 0)
12868 break;
12869
12870 data = generate_test_data(test, i);
e34684f8
NS		 12871 if (!data && !(test->aux & FLAG_NO_DATA)) {
12872 pr_cont("data generation failed ");
12873 err_cnt++;
12874 break;
12875 }
10f18e0b
DB		 12876 ret = __run_one(fp, data, runs, &duration);
12877 release_test_data(test, data);
12878
12879 if (ret == test->test[i].result) {
12880 pr_cont("%lld ", duration);
12881 } else {
12882 pr_cont("ret %d != %d ", ret,
12883 test->test[i].result);
64a8946b
AS		 12884 err_cnt++;
12885 }
12886 }
12887
12888 return err_cnt;
12889}
12890
d2648d4e
NS		 12891static char test_name[64];
12892module_param_string(test_name, test_name, sizeof(test_name), 0);
12893
12894static int test_id = -1;
12895module_param(test_id, int, 0);
12896
12897static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
12898module_param_array(test_range, int, NULL, 0);
12899
12900static __init int find_test_index(const char *test_name)
12901{
12902 int i;
12903
12904 for (i = 0; i < ARRAY_SIZE(tests); i++) {
12905 if (!strcmp(tests[i].descr, test_name))
12906 return i;
12907 }
12908 return -1;
12909}
12910
a4afd37b
DB		 12911static __init int prepare_bpf_tests(void)
12912{
d2648d4e
NS		 12913 if (test_id >= 0) {
12914 /*
12915 * if a test_id was specified, use test_range to
12916 * cover only that test.
12917 */
12918 if (test_id >= ARRAY_SIZE(tests)) {
12919 pr_err("test_bpf: invalid test_id specified.\n");
12920 return -EINVAL;
12921 }
12922
12923 test_range[0] = test_id;
12924 test_range[1] = test_id;
12925 } else if (*test_name) {
12926 /*
12927 * if a test_name was specified, find it and setup
12928 * test_range to cover only that test.
12929 */
12930 int idx = find_test_index(test_name);
12931
12932 if (idx < 0) {
12933 pr_err("test_bpf: no test named '%s' found.\n",
12934 test_name);
12935 return -EINVAL;
12936 }
12937 test_range[0] = idx;
12938 test_range[1] = idx;
12939 } else {
12940 /*
12941 * check that the supplied test_range is valid.
12942 */
12943 if (test_range[0] >= ARRAY_SIZE(tests) ||
12944 test_range[1] >= ARRAY_SIZE(tests) ||
12945 test_range[0] < 0 || test_range[1] < 0) {
12946 pr_err("test_bpf: test_range is out of bound.\n");
12947 return -EINVAL;
12948 }
12949
12950 if (test_range[1] < test_range[0]) {
12951 pr_err("test_bpf: test_range is ending before it starts.\n");
12952 return -EINVAL;
12953 }
12954 }
12955
a4afd37b
DB		 12956 return 0;
12957}
12958
12959static __init void destroy_bpf_tests(void)
12960{
a4afd37b
DB		 12961}
12962
d2648d4e
NS		 12963static bool exclude_test(int test_id)
12964{
12965 return test_id < test_range[0] || test_id > test_range[1];
12966}
12967
76db8087
YS		 12968static __init struct sk_buff *build_test_skb(void)
12969{
12970 u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
12971 struct sk_buff *skb[2];
12972 struct page *page[2];
12973 int i, data_size = 8;
12974
12975 for (i = 0; i < 2; i++) {
12976 page[i] = alloc_page(GFP_KERNEL);
12977 if (!page[i]) {
12978 if (i == 0)
12979 goto err_page0;
12980 else
12981 goto err_page1;
12982 }
12983
12984 /* this will set skb[i]->head_frag */
12985 skb[i] = dev_alloc_skb(headroom + data_size);
12986 if (!skb[i]) {
12987 if (i == 0)
12988 goto err_skb0;
12989 else
12990 goto err_skb1;
12991 }
12992
12993 skb_reserve(skb[i], headroom);
12994 skb_put(skb[i], data_size);
12995 skb[i]->protocol = htons(ETH_P_IP);
12996 skb_reset_network_header(skb[i]);
12997 skb_set_mac_header(skb[i], -ETH_HLEN);
12998
12999 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
13000 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
13001 }
13002
13003 /* setup shinfo */
13004 skb_shinfo(skb[0])->gso_size = 1448;
13005 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
13006 skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
13007 skb_shinfo(skb[0])->gso_segs = 0;
13008 skb_shinfo(skb[0])->frag_list = skb[1];
3384c7c7 13009 skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000;
76db8087
YS		 13010
13011 /* adjust skb[0]'s len */
13012 skb[0]->len += skb[1]->len;
13013 skb[0]->data_len += skb[1]->data_len;
13014 skb[0]->truesize += skb[1]->truesize;
13015
13016 return skb[0];
13017
13018err_skb1:
13019 __free_page(page[1]);
13020err_page1:
13021 kfree_skb(skb[0]);
13022err_skb0:
13023 __free_page(page[0]);
13024err_page0:
13025 return NULL;
13026}
13027
cf204a71
SL		 13028static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
13029{
13030 unsigned int alloc_size = 2000;
13031 unsigned int headroom = 102, doffset = 72, data_size = 1308;
13032 struct sk_buff *skb[2];
13033 int i;
13034
13035 /* skbs linked in a frag_list, both with linear data, with head_frag=0
13036 * (data allocated by kmalloc), both have tcp data of 1308 bytes
13037 * (total payload is 2616 bytes).
13038 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
13039 */
13040 for (i = 0; i < 2; i++) {
13041 skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
13042 if (!skb[i]) {
13043 if (i == 0)
13044 goto err_skb0;
13045 else
13046 goto err_skb1;
13047 }
13048
13049 skb[i]->protocol = htons(ETH_P_IPV6);
13050 skb_reserve(skb[i], headroom);
13051 skb_put(skb[i], doffset + data_size);
13052 skb_reset_network_header(skb[i]);
13053 if (i == 0)
13054 skb_reset_mac_header(skb[i]);
13055 else
13056 skb_set_mac_header(skb[i], -ETH_HLEN);
13057 __skb_pull(skb[i], doffset);
13058 }
13059
13060 /* setup shinfo.
13061 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
13062 * reduced gso_size.
13063 */
13064 skb_shinfo(skb[0])->gso_size = 1288;
13065 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
13066 skb_shinfo(skb[0])->gso_segs = 0;
13067 skb_shinfo(skb[0])->frag_list = skb[1];
13068
13069 /* adjust skb[0]'s len */
13070 skb[0]->len += skb[1]->len;
13071 skb[0]->data_len += skb[1]->len;
13072 skb[0]->truesize += skb[1]->truesize;
13073
13074 return skb[0];
13075
13076err_skb1:
13077 kfree_skb(skb[0]);
13078err_skb0:
13079 return NULL;
13080}
13081
af21c717
SL		 13082struct skb_segment_test {
13083 const char *descr;
13084 struct sk_buff *(*build_skb)(void);
76db8087 13085 netdev_features_t features;
af21c717
SL		 13086};
13087
13088static struct skb_segment_test skb_segment_tests[] __initconst = {
13089 {
13090 .descr = "gso_with_rx_frags",
13091 .build_skb = build_test_skb,
13092 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
13093 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
cf204a71
SL		 13094 },
13095 {
13096 .descr = "gso_linear_no_head_frag",
13097 .build_skb = build_test_skb_linear_no_head_frag,
13098 .features = NETIF_F_SG | NETIF_F_FRAGLIST |
13099 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
13100 NETIF_F_LLTX_BIT | NETIF_F_GRO |
13101 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
13102 NETIF_F_HW_VLAN_STAG_TX_BIT
af21c717
SL		 13103 }
13104};
13105
13106static __init int test_skb_segment_single(const struct skb_segment_test *test)
13107{
76db8087
YS		 13108 struct sk_buff *skb, *segs;
13109 int ret = -1;
13110
af21c717 13111 skb = test->build_skb();
76db8087
YS		 13112 if (!skb) {
13113 pr_info("%s: failed to build_test_skb", __func__);
13114 goto done;
13115 }
13116
af21c717 13117 segs = skb_segment(skb, test->features);
99fe29d3 13118 if (!IS_ERR(segs)) {
76db8087
YS		 13119 kfree_skb_list(segs);
13120 ret = 0;
76db8087
YS		 13121 }
13122 kfree_skb(skb);
13123done:
13124 return ret;
13125}
13126
af21c717
SL		 13127static __init int test_skb_segment(void)
13128{
13129 int i, err_cnt = 0, pass_cnt = 0;
13130
13131 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
13132 const struct skb_segment_test *test = &skb_segment_tests[i];
13133
13134 pr_info("#%d %s ", i, test->descr);
13135
13136 if (test_skb_segment_single(test)) {
13137 pr_cont("FAIL\n");
13138 err_cnt++;
13139 } else {
13140 pr_cont("PASS\n");
13141 pass_cnt++;
13142 }
13143 }
13144
13145 pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
13146 pass_cnt, err_cnt);
13147 return err_cnt ? -EINVAL : 0;
13148}
13149
64a8946b
AS		 13150static __init int test_bpf(void)
13151{
10f18e0b 13152 int i, err_cnt = 0, pass_cnt = 0;
327941f8 13153 int jit_cnt = 0, run_cnt = 0;
64a8946b
AS		 13154
13155 for (i = 0; i < ARRAY_SIZE(tests); i++) {
7ae457c1 13156 struct bpf_prog *fp;
10f18e0b 13157 int err;
64a8946b 13158
d40bc962 13159 cond_resched();
d2648d4e
NS		 13160 if (exclude_test(i))
13161 continue;
13162
10f18e0b 13163 pr_info("#%d %s ", i, tests[i].descr);
64a8946b 13164
4bc35413
JA		 13165 if (tests[i].fill_helper &&
13166 tests[i].fill_helper(&tests[i]) < 0) {
13167 pr_cont("FAIL to prog_fill\n");
13168 continue;
13169 }
13170
10f18e0b 13171 fp = generate_filter(i, &err);
4bc35413
JA		 13172
13173 if (tests[i].fill_helper) {
13174 kfree(tests[i].u.ptr.insns);
13175 tests[i].u.ptr.insns = NULL;
13176 }
13177
10f18e0b
DB		 13178 if (fp == NULL) {
13179 if (err == 0) {
13180 pass_cnt++;
13181 continue;
64a8946b 13182 }
290af866
AS		 13183 err_cnt++;
13184 continue;
10f18e0b 13185 }
327941f8
DB		 13186
13187 pr_cont("jited:%u ", fp->jited);
13188
13189 run_cnt++;
13190 if (fp->jited)
13191 jit_cnt++;
13192
64a8946b 13193 err = run_one(fp, &tests[i]);
10f18e0b 13194 release_filter(fp, i);
64a8946b
AS		 13195
13196 if (err) {
10f18e0b 13197 pr_cont("FAIL (%d times)\n", err);
64a8946b
AS		 13198 err_cnt++;
13199 } else {
13200 pr_cont("PASS\n");
10f18e0b 13201 pass_cnt++;
64a8946b
AS		 13202 }
13203 }
13204
327941f8
DB		 13205 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
13206 pass_cnt, err_cnt, jit_cnt, run_cnt);
13207
10f18e0b 13208 return err_cnt ? -EINVAL : 0;
64a8946b
AS		 13209}
13210
874be05f
JA		 13211struct tail_call_test {
13212 const char *descr;
13213 struct bpf_insn insns[MAX_INSNS];
18935a72 13214 int flags;
874be05f
JA		 13215 int result;
13216 int stack_depth;
13217};
13218
18935a72
JA		 13219/* Flags that can be passed to tail call test cases */
13220#define FLAG_NEED_STATE BIT(0)
13221#define FLAG_RESULT_IN_STATE BIT(1)
13222
874be05f
JA		 13223/*
13224 * Magic marker used in test snippets for tail calls below.
13225 * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
13226 * with the proper values by the test runner.
13227 */
13228#define TAIL_CALL_MARKER 0x7a11ca11
13229
13230/* Special offset to indicate a NULL call target */
13231#define TAIL_CALL_NULL 0x7fff
13232
13233/* Special offset to indicate an out-of-range index */
13234#define TAIL_CALL_INVALID 0x7ffe
13235
13236#define TAIL_CALL(offset) \
13237 BPF_LD_IMM64(R2, TAIL_CALL_MARKER), \
13238 BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
13239 offset, TAIL_CALL_MARKER), \
13240 BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
13241
29eef85b
JA		 13242/*
13243 * A test function to be called from a BPF program, clobbering a lot of
13244 * CPU registers in the process. A JITed BPF program calling this function
13245 * must save and restore any caller-saved registers it uses for internal
13246 * state, for example the current tail call count.
13247 */
13248BPF_CALL_1(bpf_test_func, u64, arg)
13249{
13250 char buf[64];
13251 long a = 0;
13252 long b = 1;
13253 long c = 2;
13254 long d = 3;
13255 long e = 4;
13256 long f = 5;
13257 long g = 6;
13258 long h = 7;
13259
13260 return snprintf(buf, sizeof(buf),
13261 "%ld %lu %lx %ld %lu %lx %ld %lu %x",
13262 a, b, c, d, e, f, g, h, (int)arg);
13263}
13264#define BPF_FUNC_test_func __BPF_FUNC_MAX_ID
13265
874be05f
JA		 13266/*
13267 * Tail call tests. Each test case may call any other test in the table,
13268 * including itself, specified as a relative index offset from the calling
13269 * test. The index TAIL_CALL_NULL can be used to specify a NULL target
13270 * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
13271 * results in a target index that is out of range.
13272 */
13273static struct tail_call_test tail_call_tests[] = {
13274 {
13275 "Tail call leaf",
13276 .insns = {
13277 BPF_ALU64_REG(BPF_MOV, R0, R1),
13278 BPF_ALU64_IMM(BPF_ADD, R0, 1),
13279 BPF_EXIT_INSN(),
13280 },
13281 .result = 1,
13282 },
13283 {
13284 "Tail call 2",
13285 .insns = {
13286 BPF_ALU64_IMM(BPF_ADD, R1, 2),
13287 TAIL_CALL(-1),
13288 BPF_ALU64_IMM(BPF_MOV, R0, -1),
13289 BPF_EXIT_INSN(),
13290 },
13291 .result = 3,
13292 },
13293 {
13294 "Tail call 3",
13295 .insns = {
13296 BPF_ALU64_IMM(BPF_ADD, R1, 3),
13297 TAIL_CALL(-1),
13298 BPF_ALU64_IMM(BPF_MOV, R0, -1),
13299 BPF_EXIT_INSN(),
13300 },
13301 .result = 6,
13302 },
13303 {
13304 "Tail call 4",
13305 .insns = {
13306 BPF_ALU64_IMM(BPF_ADD, R1, 4),
13307 TAIL_CALL(-1),
13308 BPF_ALU64_IMM(BPF_MOV, R0, -1),
13309 BPF_EXIT_INSN(),
13310 },
13311 .result = 10,
13312 },
13313 {
13314 "Tail call error path, max count reached",
13315 .insns = {
18935a72
JA		 13316 BPF_LDX_MEM(BPF_W, R2, R1, 0),
13317 BPF_ALU64_IMM(BPF_ADD, R2, 1),
13318 BPF_STX_MEM(BPF_W, R1, R2, 0),
874be05f
JA		 13319 TAIL_CALL(0),
13320 BPF_EXIT_INSN(),
13321 },
18935a72
JA		 13322 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
13323 .result = (MAX_TAIL_CALL_CNT + 1 + 1) * MAX_TESTRUNS,
874be05f 13324 },
29eef85b
JA		 13325 {
13326 "Tail call count preserved across function calls",
13327 .insns = {
13328 BPF_LDX_MEM(BPF_W, R2, R1, 0),
13329 BPF_ALU64_IMM(BPF_ADD, R2, 1),
13330 BPF_STX_MEM(BPF_W, R1, R2, 0),
13331 BPF_STX_MEM(BPF_DW, R10, R1, -8),
13332 BPF_CALL_REL(BPF_FUNC_get_numa_node_id),
13333 BPF_CALL_REL(BPF_FUNC_ktime_get_ns),
13334 BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns),
13335 BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns),
13336 BPF_CALL_REL(BPF_FUNC_jiffies64),
13337 BPF_CALL_REL(BPF_FUNC_test_func),
13338 BPF_LDX_MEM(BPF_DW, R1, R10, -8),
13339 BPF_ALU32_REG(BPF_MOV, R0, R1),
13340 TAIL_CALL(0),
13341 BPF_EXIT_INSN(),
13342 },
13343 .stack_depth = 8,
13344 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
13345 .result = (MAX_TAIL_CALL_CNT + 1 + 1) * MAX_TESTRUNS,
13346 },
874be05f
JA		 13347 {
13348 "Tail call error path, NULL target",
13349 .insns = {
18935a72
JA		 13350 BPF_LDX_MEM(BPF_W, R2, R1, 0),
13351 BPF_ALU64_IMM(BPF_ADD, R2, 1),
13352 BPF_STX_MEM(BPF_W, R1, R2, 0),
874be05f 13353 TAIL_CALL(TAIL_CALL_NULL),
874be05f
JA		 13354 BPF_EXIT_INSN(),
13355 },
18935a72
JA		 13356 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
13357 .result = MAX_TESTRUNS,
874be05f
JA		 13358 },
13359 {
13360 "Tail call error path, index out of range",
13361 .insns = {
18935a72
JA		 13362 BPF_LDX_MEM(BPF_W, R2, R1, 0),
13363 BPF_ALU64_IMM(BPF_ADD, R2, 1),
13364 BPF_STX_MEM(BPF_W, R1, R2, 0),
874be05f 13365 TAIL_CALL(TAIL_CALL_INVALID),
874be05f
JA		 13366 BPF_EXIT_INSN(),
13367 },
18935a72
JA		 13368 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
13369 .result = MAX_TESTRUNS,
874be05f
JA		 13370 },
13371};
13372
13373static void __init destroy_tail_call_tests(struct bpf_array *progs)
13374{
13375 int i;
13376
13377 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
13378 if (progs->ptrs[i])
13379 bpf_prog_free(progs->ptrs[i]);
13380 kfree(progs);
13381}
13382
13383static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
13384{
13385 int ntests = ARRAY_SIZE(tail_call_tests);
13386 struct bpf_array *progs;
13387 int which, err;
13388
13389 /* Allocate the table of programs to be used for tall calls */
13390 progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]),
13391 GFP_KERNEL);
13392 if (!progs)
13393 goto out_nomem;
13394
13395 /* Create all eBPF programs and populate the table */
13396 for (which = 0; which < ntests; which++) {
13397 struct tail_call_test *test = &tail_call_tests[which];
13398 struct bpf_prog *fp;
13399 int len, i;
13400
13401 /* Compute the number of program instructions */
13402 for (len = 0; len < MAX_INSNS; len++) {
13403 struct bpf_insn *insn = &test->insns[len];
13404
13405 if (len < MAX_INSNS - 1 &&
13406 insn->code == (BPF_LD | BPF_DW | BPF_IMM))
13407 len++;
13408 if (insn->code == 0)
13409 break;
13410 }
13411
13412 /* Allocate and initialize the program */
13413 fp = bpf_prog_alloc(bpf_prog_size(len), 0);
13414 if (!fp)
13415 goto out_nomem;
13416
13417 fp->len = len;
13418 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
13419 fp->aux->stack_depth = test->stack_depth;
13420 memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
13421
13422 /* Relocate runtime tail call offsets and addresses */
13423 for (i = 0; i < len; i++) {
13424 struct bpf_insn *insn = &fp->insnsi[i];
29eef85b 13425 long addr = 0;
874be05f
JA		 13426
13427 switch (insn->code) {
13428 case BPF_LD | BPF_DW | BPF_IMM:
29eef85b
JA		 13429 if (insn->imm != TAIL_CALL_MARKER)
13430 break;
874be05f
JA		 13431 insn[0].imm = (u32)(long)progs;
13432 insn[1].imm = ((u64)(long)progs) >> 32;
13433 break;
13434
13435 case BPF_ALU | BPF_MOV | BPF_K:
29eef85b
JA		 13436 if (insn->imm != TAIL_CALL_MARKER)
13437 break;
874be05f
JA		 13438 if (insn->off == TAIL_CALL_NULL)
13439 insn->imm = ntests;
13440 else if (insn->off == TAIL_CALL_INVALID)
13441 insn->imm = ntests + 1;
13442 else
13443 insn->imm = which + insn->off;
13444 insn->off = 0;
29eef85b
JA		 13445 break;
13446
13447 case BPF_JMP | BPF_CALL:
13448 if (insn->src_reg != BPF_PSEUDO_CALL)
13449 break;
13450 switch (insn->imm) {
13451 case BPF_FUNC_get_numa_node_id:
13452 addr = (long)&numa_node_id;
13453 break;
13454 case BPF_FUNC_ktime_get_ns:
13455 addr = (long)&ktime_get_ns;
13456 break;
13457 case BPF_FUNC_ktime_get_boot_ns:
13458 addr = (long)&ktime_get_boot_fast_ns;
13459 break;
13460 case BPF_FUNC_ktime_get_coarse_ns:
13461 addr = (long)&ktime_get_coarse_ns;
13462 break;
13463 case BPF_FUNC_jiffies64:
13464 addr = (long)&get_jiffies_64;
13465 break;
13466 case BPF_FUNC_test_func:
13467 addr = (long)&bpf_test_func;
13468 break;
13469 default:
13470 err = -EFAULT;
13471 goto out_err;
13472 }
3d717fad 13473 *insn = BPF_EMIT_CALL(addr);
29eef85b
JA		 13474 if ((long)__bpf_call_base + insn->imm != addr)
13475 *insn = BPF_JMP_A(0); /* Skip: NOP */
13476 break;
874be05f
JA		 13477 }
13478 }
13479
13480 fp = bpf_prog_select_runtime(fp, &err);
13481 if (err)
13482 goto out_err;
13483
13484 progs->ptrs[which] = fp;
13485 }
13486
13487 /* The last entry contains a NULL program pointer */
13488 progs->map.max_entries = ntests + 1;
13489 *pprogs = progs;
13490 return 0;
13491
13492out_nomem:
13493 err = -ENOMEM;
13494
13495out_err:
13496 if (progs)
13497 destroy_tail_call_tests(progs);
13498 return err;
13499}
13500
13501static __init int test_tail_calls(struct bpf_array *progs)
13502{
13503 int i, err_cnt = 0, pass_cnt = 0;
13504 int jit_cnt = 0, run_cnt = 0;
13505
13506 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
13507 struct tail_call_test *test = &tail_call_tests[i];
13508 struct bpf_prog *fp = progs->ptrs[i];
18935a72
JA		 13509 int *data = NULL;
13510 int state = 0;
874be05f
JA		 13511 u64 duration;
13512 int ret;
13513
13514 cond_resched();
13515
13516 pr_info("#%d %s ", i, test->descr);
13517 if (!fp) {
13518 err_cnt++;
13519 continue;
13520 }
13521 pr_cont("jited:%u ", fp->jited);
13522
13523 run_cnt++;
13524 if (fp->jited)
13525 jit_cnt++;
13526
18935a72
JA		 13527 if (test->flags & FLAG_NEED_STATE)
13528 data = &state;
13529 ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
13530 if (test->flags & FLAG_RESULT_IN_STATE)
13531 ret = state;
874be05f
JA		 13532 if (ret == test->result) {
13533 pr_cont("%lld PASS", duration);
13534 pass_cnt++;
13535 } else {
13536 pr_cont("ret %d != %d FAIL", ret, test->result);
13537 err_cnt++;
13538 }
13539 }
13540
13541 pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
13542 __func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
13543
13544 return err_cnt ? -EINVAL : 0;
13545}
13546
64a8946b
AS		 13547static int __init test_bpf_init(void)
13548{
874be05f 13549 struct bpf_array *progs = NULL;
a4afd37b
DB		 13550 int ret;
13551
13552 ret = prepare_bpf_tests();
13553 if (ret < 0)
13554 return ret;
13555
13556 ret = test_bpf();
a4afd37b 13557 destroy_bpf_tests();
76db8087
YS		 13558 if (ret)
13559 return ret;
13560
874be05f
JA		 13561 ret = prepare_tail_call_tests(&progs);
13562 if (ret)
13563 return ret;
13564 ret = test_tail_calls(progs);
13565 destroy_tail_call_tests(progs);
13566 if (ret)
13567 return ret;
13568
76db8087 13569 return test_skb_segment();
64a8946b
AS		 13570}
13571
13572static void __exit test_bpf_exit(void)
13573{
13574}
13575
13576module_init(test_bpf_init);
13577module_exit(test_bpf_exit);
10f18e0b 13578
64a8946b 13579MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)