]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - lib/test_bpf.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
test_rhashtable: add test case for rhltable with duplicate objects
[mirror_ubuntu-bionic-kernel.git] / lib / test_bpf.c
CommitLineData
64a8946b
AS		 1/*
2 * Testsuite for BPF interpreter and BPF JIT compiler
3 *
4 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 */
15
16#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18#include <linux/init.h>
19#include <linux/module.h>
20#include <linux/filter.h>
4d9c5c53 21#include <linux/bpf.h>
64a8946b
AS		 22#include <linux/skbuff.h>
23#include <linux/netdevice.h>
24#include <linux/if_vlan.h>
a4afd37b 25#include <linux/random.h>
bac142ac 26#include <linux/highmem.h>
64a8946b 27
10f18e0b 28/* General test specific settings */
64a8946b 29#define MAX_SUBTESTS 3
10f18e0b 30#define MAX_TESTRUNS 10000
64a8946b
AS		 31#define MAX_DATA 128
32#define MAX_INSNS 512
33#define MAX_K 0xffffFFFF
34
10f18e0b 35/* Few constants used to init test 'skb' */
64a8946b
AS		 36#define SKB_TYPE 3
37#define SKB_MARK 0x1234aaaa
38#define SKB_HASH 0x1234aaab
39#define SKB_QUEUE_MAP 123
40#define SKB_VLAN_TCI 0xffff
41#define SKB_DEV_IFINDEX 577
42#define SKB_DEV_TYPE 588
43
10f18e0b
DB		 44/* Redefine REGs to make tests less verbose */
45#define R0 BPF_REG_0
46#define R1 BPF_REG_1
47#define R2 BPF_REG_2
48#define R3 BPF_REG_3
49#define R4 BPF_REG_4
50#define R5 BPF_REG_5
51#define R6 BPF_REG_6
52#define R7 BPF_REG_7
53#define R8 BPF_REG_8
54#define R9 BPF_REG_9
55#define R10 BPF_REG_10
56
57/* Flags that can be passed to test cases */
58#define FLAG_NO_DATA BIT(0)
59#define FLAG_EXPECTED_FAIL BIT(1)
bac142ac 60#define FLAG_SKB_FRAG BIT(2)
10f18e0b
DB		 61
62enum {
63 CLASSIC = BIT(6), /* Old BPF instructions only. */
64 INTERNAL = BIT(7), /* Extended instruction set. */
65};
66
67#define TEST_TYPE_MASK (CLASSIC | INTERNAL)
64a8946b
AS		 68
69struct bpf_test {
70 const char *descr;
71 union {
72 struct sock_filter insns[MAX_INSNS];
2695fb55 73 struct bpf_insn insns_int[MAX_INSNS];
a4afd37b
DB		 74 struct {
75 void *insns;
76 unsigned int len;
77 } ptr;
ece80490 78 } u;
10f18e0b 79 __u8 aux;
64a8946b
AS		 80 __u8 data[MAX_DATA];
81 struct {
82 int data_size;
83 __u32 result;
84 } test[MAX_SUBTESTS];
a4afd37b 85 int (*fill_helper)(struct bpf_test *self);
f735fecf 86 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
bac142ac 87 __u8 frag_data[MAX_DATA];
105c0361 88 int stack_depth; /* for eBPF only, since tests don't call verifier */
64a8946b
AS		 89};
90
a4afd37b
DB		 91/* Large test cases need separate allocation and fill handler. */
92
93static int bpf_fill_maxinsns1(struct bpf_test *self)
94{
95 unsigned int len = BPF_MAXINSNS;
96 struct sock_filter *insn;
97 __u32 k = ~0;
98 int i;
99
100 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
101 if (!insn)
102 return -ENOMEM;
103
104 for (i = 0; i < len; i++, k--)
105 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
106
107 self->u.ptr.insns = insn;
108 self->u.ptr.len = len;
109
110 return 0;
111}
112
113static int bpf_fill_maxinsns2(struct bpf_test *self)
114{
115 unsigned int len = BPF_MAXINSNS;
116 struct sock_filter *insn;
117 int i;
118
119 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
120 if (!insn)
121 return -ENOMEM;
122
123 for (i = 0; i < len; i++)
124 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
125
126 self->u.ptr.insns = insn;
127 self->u.ptr.len = len;
128
129 return 0;
130}
131
132static int bpf_fill_maxinsns3(struct bpf_test *self)
133{
134 unsigned int len = BPF_MAXINSNS;
135 struct sock_filter *insn;
136 struct rnd_state rnd;
137 int i;
138
139 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
140 if (!insn)
141 return -ENOMEM;
142
143 prandom_seed_state(&rnd, 3141592653589793238ULL);
144
145 for (i = 0; i < len - 1; i++) {
146 __u32 k = prandom_u32_state(&rnd);
147
148 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
149 }
150
151 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
152
153 self->u.ptr.insns = insn;
154 self->u.ptr.len = len;
155
156 return 0;
157}
158
159static int bpf_fill_maxinsns4(struct bpf_test *self)
160{
161 unsigned int len = BPF_MAXINSNS + 1;
162 struct sock_filter *insn;
163 int i;
164
165 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
166 if (!insn)
167 return -ENOMEM;
168
169 for (i = 0; i < len; i++)
170 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
171
172 self->u.ptr.insns = insn;
173 self->u.ptr.len = len;
174
175 return 0;
176}
177
178static int bpf_fill_maxinsns5(struct bpf_test *self)
179{
180 unsigned int len = BPF_MAXINSNS;
181 struct sock_filter *insn;
182 int i;
183
184 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
185 if (!insn)
186 return -ENOMEM;
187
188 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
189
190 for (i = 1; i < len - 1; i++)
191 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
192
193 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
194
195 self->u.ptr.insns = insn;
196 self->u.ptr.len = len;
197
198 return 0;
199}
200
201static int bpf_fill_maxinsns6(struct bpf_test *self)
202{
203 unsigned int len = BPF_MAXINSNS;
204 struct sock_filter *insn;
205 int i;
206
207 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
208 if (!insn)
209 return -ENOMEM;
210
211 for (i = 0; i < len - 1; i++)
212 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
213 SKF_AD_VLAN_TAG_PRESENT);
214
215 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
216
217 self->u.ptr.insns = insn;
218 self->u.ptr.len = len;
219
220 return 0;
221}
222
223static int bpf_fill_maxinsns7(struct bpf_test *self)
224{
225 unsigned int len = BPF_MAXINSNS;
226 struct sock_filter *insn;
227 int i;
228
229 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
230 if (!insn)
231 return -ENOMEM;
232
233 for (i = 0; i < len - 4; i++)
234 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
235 SKF_AD_CPU);
236
237 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
238 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
239 SKF_AD_CPU);
240 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
241 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
242
243 self->u.ptr.insns = insn;
244 self->u.ptr.len = len;
245
246 return 0;
247}
248
249static int bpf_fill_maxinsns8(struct bpf_test *self)
250{
251 unsigned int len = BPF_MAXINSNS;
252 struct sock_filter *insn;
253 int i, jmp_off = len - 3;
254
255 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
256 if (!insn)
257 return -ENOMEM;
258
259 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
260
261 for (i = 1; i < len - 1; i++)
262 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
263
264 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
265
266 self->u.ptr.insns = insn;
267 self->u.ptr.len = len;
268
269 return 0;
270}
271
3b529602
DB		 272static int bpf_fill_maxinsns9(struct bpf_test *self)
273{
274 unsigned int len = BPF_MAXINSNS;
275 struct bpf_insn *insn;
276 int i;
277
278 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
279 if (!insn)
280 return -ENOMEM;
281
282 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
283 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
284 insn[2] = BPF_EXIT_INSN();
285
286 for (i = 3; i < len - 2; i++)
287 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
288
289 insn[len - 2] = BPF_EXIT_INSN();
290 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
291
292 self->u.ptr.insns = insn;
293 self->u.ptr.len = len;
294
295 return 0;
296}
297
298static int bpf_fill_maxinsns10(struct bpf_test *self)
299{
300 unsigned int len = BPF_MAXINSNS, hlen = len - 2;
301 struct bpf_insn *insn;
302 int i;
303
304 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
305 if (!insn)
306 return -ENOMEM;
307
308 for (i = 0; i < hlen / 2; i++)
309 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
310 for (i = hlen - 1; i > hlen / 2; i--)
311 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
312
313 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
314 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
315 insn[hlen + 1] = BPF_EXIT_INSN();
316
317 self->u.ptr.insns = insn;
318 self->u.ptr.len = len;
319
320 return 0;
321}
322
bde28bc6
DB		 323static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
324 unsigned int plen)
325{
326 struct sock_filter *insn;
327 unsigned int rlen;
328 int i, j;
329
330 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
331 if (!insn)
332 return -ENOMEM;
333
334 rlen = (len % plen) - 1;
335
336 for (i = 0; i + plen < len; i += plen)
337 for (j = 0; j < plen; j++)
338 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
339 plen - 1 - j, 0, 0);
340 for (j = 0; j < rlen; j++)
341 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
342 0, 0);
343
344 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
345
346 self->u.ptr.insns = insn;
347 self->u.ptr.len = len;
348
349 return 0;
350}
351
352static int bpf_fill_maxinsns11(struct bpf_test *self)
353{
354 /* Hits 70 passes on x86_64, so cannot get JITed there. */
355 return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
356}
357
358static int bpf_fill_ja(struct bpf_test *self)
359{
360 /* Hits exactly 11 passes on x86_64 JIT. */
361 return __bpf_fill_ja(self, 12, 9);
362}
363
4d9c5c53
AS		 364static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
365{
366 unsigned int len = BPF_MAXINSNS;
367 struct sock_filter *insn;
368 int i;
369
370 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
371 if (!insn)
372 return -ENOMEM;
373
374 for (i = 0; i < len - 1; i += 2) {
375 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
376 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
377 SKF_AD_OFF + SKF_AD_CPU);
378 }
379
380 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
381
382 self->u.ptr.insns = insn;
383 self->u.ptr.len = len;
384
385 return 0;
386}
387
388#define PUSH_CNT 68
389/* test: {skb->data[0], vlan_push} x 68 + {skb->data[0], vlan_pop} x 68 */
390static int bpf_fill_ld_abs_vlan_push_pop(struct bpf_test *self)
391{
392 unsigned int len = BPF_MAXINSNS;
393 struct bpf_insn *insn;
394 int i = 0, j, k = 0;
395
396 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
397 if (!insn)
398 return -ENOMEM;
399
400 insn[i++] = BPF_MOV64_REG(R6, R1);
401loop:
402 for (j = 0; j < PUSH_CNT; j++) {
403 insn[i++] = BPF_LD_ABS(BPF_B, 0);
404 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
405 i++;
406 insn[i++] = BPF_MOV64_REG(R1, R6);
407 insn[i++] = BPF_MOV64_IMM(R2, 1);
408 insn[i++] = BPF_MOV64_IMM(R3, 2);
409 insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
410 bpf_skb_vlan_push_proto.func - __bpf_call_base);
411 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
412 i++;
413 }
414
415 for (j = 0; j < PUSH_CNT; j++) {
416 insn[i++] = BPF_LD_ABS(BPF_B, 0);
417 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
418 i++;
419 insn[i++] = BPF_MOV64_REG(R1, R6);
420 insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
421 bpf_skb_vlan_pop_proto.func - __bpf_call_base);
422 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
423 i++;
424 }
425 if (++k < 5)
426 goto loop;
427
428 for (; i < len - 1; i++)
429 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xbef);
430
431 insn[len - 1] = BPF_EXIT_INSN();
432
433 self->u.ptr.insns = insn;
434 self->u.ptr.len = len;
435
436 return 0;
437}
438
87ab8194
DB		 439static int bpf_fill_ld_abs_vlan_push_pop2(struct bpf_test *self)
440{
441 struct bpf_insn *insn;
442
443 insn = kmalloc_array(16, sizeof(*insn), GFP_KERNEL);
444 if (!insn)
445 return -ENOMEM;
446
447 /* Due to func address being non-const, we need to
448 * assemble this here.
449 */
450 insn[0] = BPF_MOV64_REG(R6, R1);
451 insn[1] = BPF_LD_ABS(BPF_B, 0);
452 insn[2] = BPF_LD_ABS(BPF_H, 0);
453 insn[3] = BPF_LD_ABS(BPF_W, 0);
454 insn[4] = BPF_MOV64_REG(R7, R6);
455 insn[5] = BPF_MOV64_IMM(R6, 0);
456 insn[6] = BPF_MOV64_REG(R1, R7);
457 insn[7] = BPF_MOV64_IMM(R2, 1);
458 insn[8] = BPF_MOV64_IMM(R3, 2);
459 insn[9] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
460 bpf_skb_vlan_push_proto.func - __bpf_call_base);
461 insn[10] = BPF_MOV64_REG(R6, R7);
462 insn[11] = BPF_LD_ABS(BPF_B, 0);
463 insn[12] = BPF_LD_ABS(BPF_H, 0);
464 insn[13] = BPF_LD_ABS(BPF_W, 0);
465 insn[14] = BPF_MOV64_IMM(R0, 42);
466 insn[15] = BPF_EXIT_INSN();
467
468 self->u.ptr.insns = insn;
469 self->u.ptr.len = 16;
470
471 return 0;
472}
473
b7127cfe
DD		 474static int bpf_fill_jump_around_ld_abs(struct bpf_test *self)
475{
476 unsigned int len = BPF_MAXINSNS;
477 struct bpf_insn *insn;
478 int i = 0;
479
480 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
481 if (!insn)
482 return -ENOMEM;
483
484 insn[i++] = BPF_MOV64_REG(R6, R1);
485 insn[i++] = BPF_LD_ABS(BPF_B, 0);
486 insn[i] = BPF_JMP_IMM(BPF_JEQ, R0, 10, len - i - 2);
487 i++;
488 while (i < len - 1)
489 insn[i++] = BPF_LD_ABS(BPF_B, 1);
490 insn[i] = BPF_EXIT_INSN();
491
492 self->u.ptr.insns = insn;
493 self->u.ptr.len = len;
494
495 return 0;
496}
497
85f68fe8
DB		 498static int __bpf_fill_stxdw(struct bpf_test *self, int size)
499{
500 unsigned int len = BPF_MAXINSNS;
501 struct bpf_insn *insn;
502 int i;
503
504 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
505 if (!insn)
506 return -ENOMEM;
507
508 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
509 insn[1] = BPF_ST_MEM(size, R10, -40, 42);
510
511 for (i = 2; i < len - 2; i++)
512 insn[i] = BPF_STX_XADD(size, R10, R0, -40);
513
514 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
515 insn[len - 1] = BPF_EXIT_INSN();
516
517 self->u.ptr.insns = insn;
518 self->u.ptr.len = len;
105c0361 519 self->stack_depth = 40;
85f68fe8
DB		 520
521 return 0;
522}
523
524static int bpf_fill_stxw(struct bpf_test *self)
525{
526 return __bpf_fill_stxdw(self, BPF_W);
527}
528
529static int bpf_fill_stxdw(struct bpf_test *self)
530{
531 return __bpf_fill_stxdw(self, BPF_DW);
532}
533
64a8946b
AS		 534static struct bpf_test tests[] = {
535 {
536 "TAX",
ece80490 537 .u.insns = {
64a8946b
AS		 538 BPF_STMT(BPF_LD | BPF_IMM, 1),
539 BPF_STMT(BPF_MISC | BPF_TAX, 0),
540 BPF_STMT(BPF_LD | BPF_IMM, 2),
541 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
542 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
543 BPF_STMT(BPF_MISC | BPF_TAX, 0),
544 BPF_STMT(BPF_LD | BPF_LEN, 0),
545 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
546 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
547 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
548 BPF_STMT(BPF_RET | BPF_A, 0)
549 },
10f18e0b 550 CLASSIC,
64a8946b
AS		 551 { 10, 20, 30, 40, 50 },
552 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
553 },
9def624a
AS		 554 {
555 "TXA",
ece80490 556 .u.insns = {
9def624a
AS		 557 BPF_STMT(BPF_LDX | BPF_LEN, 0),
558 BPF_STMT(BPF_MISC | BPF_TXA, 0),
559 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
560 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
561 },
10f18e0b 562 CLASSIC,
9def624a
AS		 563 { 10, 20, 30, 40, 50 },
564 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
565 },
566 {
567 "ADD_SUB_MUL_K",
ece80490 568 .u.insns = {
9def624a
AS		 569 BPF_STMT(BPF_LD | BPF_IMM, 1),
570 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
571 BPF_STMT(BPF_LDX | BPF_IMM, 3),
572 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
573 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
574 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
575 BPF_STMT(BPF_RET | BPF_A, 0)
576 },
10f18e0b 577 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 578 { },
579 { { 0, 0xfffffffd } }
580 },
581 {
6867b17b 582 "DIV_MOD_KX",
ece80490 583 .u.insns = {
9def624a
AS		 584 BPF_STMT(BPF_LD | BPF_IMM, 8),
585 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
586 BPF_STMT(BPF_MISC | BPF_TAX, 0),
587 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
588 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
589 BPF_STMT(BPF_MISC | BPF_TAX, 0),
590 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
591 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
6867b17b
DK		 592 BPF_STMT(BPF_MISC | BPF_TAX, 0),
593 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
594 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
595 BPF_STMT(BPF_MISC | BPF_TAX, 0),
596 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
597 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
9def624a
AS		 598 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
599 BPF_STMT(BPF_RET | BPF_A, 0)
600 },
10f18e0b 601 CLASSIC | FLAG_NO_DATA,
9def624a 602 { },
6867b17b 603 { { 0, 0x20000000 } }
9def624a
AS		 604 },
605 {
606 "AND_OR_LSH_K",
ece80490 607 .u.insns = {
9def624a
AS		 608 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
609 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
610 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
611 BPF_STMT(BPF_MISC | BPF_TAX, 0),
612 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
613 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
614 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
615 BPF_STMT(BPF_RET | BPF_A, 0)
616 },
10f18e0b 617 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 618 { },
619 { { 0, 0x800000ff }, { 1, 0x800000ff } },
620 },
e9d94504
CG		 621 {
622 "LD_IMM_0",
623 .u.insns = {
624 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
625 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
626 BPF_STMT(BPF_RET | BPF_K, 0),
627 BPF_STMT(BPF_RET | BPF_K, 1),
628 },
629 CLASSIC,
630 { },
631 { { 1, 1 } },
632 },
9def624a
AS		 633 {
634 "LD_IND",
ece80490 635 .u.insns = {
9def624a
AS		 636 BPF_STMT(BPF_LDX | BPF_LEN, 0),
637 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
638 BPF_STMT(BPF_RET | BPF_K, 1)
639 },
10f18e0b 640 CLASSIC,
9def624a
AS		 641 { },
642 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
643 },
644 {
645 "LD_ABS",
ece80490 646 .u.insns = {
9def624a
AS		 647 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
648 BPF_STMT(BPF_RET | BPF_K, 1)
649 },
10f18e0b 650 CLASSIC,
9def624a
AS		 651 { },
652 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
653 },
654 {
655 "LD_ABS_LL",
ece80490 656 .u.insns = {
9def624a
AS		 657 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
658 BPF_STMT(BPF_MISC | BPF_TAX, 0),
659 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
660 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
661 BPF_STMT(BPF_RET | BPF_A, 0)
662 },
10f18e0b 663 CLASSIC,
9def624a
AS		 664 { 1, 2, 3 },
665 { { 1, 0 }, { 2, 3 } },
666 },
667 {
668 "LD_IND_LL",
ece80490 669 .u.insns = {
9def624a
AS		 670 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
671 BPF_STMT(BPF_LDX | BPF_LEN, 0),
672 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
673 BPF_STMT(BPF_MISC | BPF_TAX, 0),
674 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
675 BPF_STMT(BPF_RET | BPF_A, 0)
676 },
10f18e0b 677 CLASSIC,
9def624a
AS		 678 { 1, 2, 3, 0xff },
679 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
680 },
681 {
682 "LD_ABS_NET",
ece80490 683 .u.insns = {
9def624a
AS		 684 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
685 BPF_STMT(BPF_MISC | BPF_TAX, 0),
686 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
687 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
688 BPF_STMT(BPF_RET | BPF_A, 0)
689 },
10f18e0b 690 CLASSIC,
9def624a
AS		 691 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
692 { { 15, 0 }, { 16, 3 } },
693 },
694 {
695 "LD_IND_NET",
ece80490 696 .u.insns = {
9def624a
AS		 697 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
698 BPF_STMT(BPF_LDX | BPF_LEN, 0),
699 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
700 BPF_STMT(BPF_MISC | BPF_TAX, 0),
701 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
702 BPF_STMT(BPF_RET | BPF_A, 0)
703 },
10f18e0b 704 CLASSIC,
9def624a
AS		 705 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
706 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
707 },
708 {
709 "LD_PKTTYPE",
ece80490 710 .u.insns = {
9def624a
AS		 711 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
712 SKF_AD_OFF + SKF_AD_PKTTYPE),
713 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
714 BPF_STMT(BPF_RET | BPF_K, 1),
715 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
716 SKF_AD_OFF + SKF_AD_PKTTYPE),
717 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
718 BPF_STMT(BPF_RET | BPF_K, 1),
719 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
720 SKF_AD_OFF + SKF_AD_PKTTYPE),
721 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
722 BPF_STMT(BPF_RET | BPF_K, 1),
723 BPF_STMT(BPF_RET | BPF_A, 0)
724 },
10f18e0b 725 CLASSIC,
9def624a
AS		 726 { },
727 { { 1, 3 }, { 10, 3 } },
728 },
729 {
730 "LD_MARK",
ece80490 731 .u.insns = {
9def624a
AS		 732 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
733 SKF_AD_OFF + SKF_AD_MARK),
734 BPF_STMT(BPF_RET | BPF_A, 0)
735 },
10f18e0b 736 CLASSIC,
9def624a
AS		 737 { },
738 { { 1, SKB_MARK}, { 10, SKB_MARK} },
739 },
740 {
741 "LD_RXHASH",
ece80490 742 .u.insns = {
9def624a
AS		 743 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
744 SKF_AD_OFF + SKF_AD_RXHASH),
745 BPF_STMT(BPF_RET | BPF_A, 0)
746 },
10f18e0b 747 CLASSIC,
9def624a
AS		 748 { },
749 { { 1, SKB_HASH}, { 10, SKB_HASH} },
750 },
751 {
752 "LD_QUEUE",
ece80490 753 .u.insns = {
9def624a
AS		 754 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
755 SKF_AD_OFF + SKF_AD_QUEUE),
756 BPF_STMT(BPF_RET | BPF_A, 0)
757 },
10f18e0b 758 CLASSIC,
9def624a
AS		 759 { },
760 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
761 },
762 {
763 "LD_PROTOCOL",
ece80490 764 .u.insns = {
9def624a
AS		 765 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
766 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
767 BPF_STMT(BPF_RET | BPF_K, 0),
768 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
769 SKF_AD_OFF + SKF_AD_PROTOCOL),
770 BPF_STMT(BPF_MISC | BPF_TAX, 0),
771 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
772 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
773 BPF_STMT(BPF_RET | BPF_K, 0),
774 BPF_STMT(BPF_MISC | BPF_TXA, 0),
775 BPF_STMT(BPF_RET | BPF_A, 0)
776 },
10f18e0b 777 CLASSIC,
9def624a
AS		 778 { 10, 20, 30 },
779 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
780 },
781 {
782 "LD_VLAN_TAG",
ece80490 783 .u.insns = {
9def624a
AS		 784 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
785 SKF_AD_OFF + SKF_AD_VLAN_TAG),
786 BPF_STMT(BPF_RET | BPF_A, 0)
787 },
10f18e0b 788 CLASSIC,
9def624a
AS		 789 { },
790 {
791 { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT },
792 { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }
793 },
794 },
795 {
796 "LD_VLAN_TAG_PRESENT",
ece80490 797 .u.insns = {
9def624a
AS		 798 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
799 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
800 BPF_STMT(BPF_RET | BPF_A, 0)
801 },
10f18e0b 802 CLASSIC,
9def624a
AS		 803 { },
804 {
805 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
806 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
807 },
808 },
809 {
810 "LD_IFINDEX",
ece80490 811 .u.insns = {
9def624a
AS		 812 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
813 SKF_AD_OFF + SKF_AD_IFINDEX),
814 BPF_STMT(BPF_RET | BPF_A, 0)
815 },
10f18e0b 816 CLASSIC,
9def624a
AS		 817 { },
818 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
819 },
820 {
821 "LD_HATYPE",
ece80490 822 .u.insns = {
9def624a
AS		 823 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
824 SKF_AD_OFF + SKF_AD_HATYPE),
825 BPF_STMT(BPF_RET | BPF_A, 0)
826 },
10f18e0b 827 CLASSIC,
9def624a
AS		 828 { },
829 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
830 },
831 {
832 "LD_CPU",
ece80490 833 .u.insns = {
9def624a
AS		 834 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
835 SKF_AD_OFF + SKF_AD_CPU),
836 BPF_STMT(BPF_MISC | BPF_TAX, 0),
837 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
838 SKF_AD_OFF + SKF_AD_CPU),
839 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
840 BPF_STMT(BPF_RET | BPF_A, 0)
841 },
10f18e0b 842 CLASSIC,
9def624a
AS		 843 { },
844 { { 1, 0 }, { 10, 0 } },
845 },
846 {
847 "LD_NLATTR",
ece80490 848 .u.insns = {
df6d0f98 849 BPF_STMT(BPF_LDX | BPF_IMM, 2),
9def624a
AS		 850 BPF_STMT(BPF_MISC | BPF_TXA, 0),
851 BPF_STMT(BPF_LDX | BPF_IMM, 3),
852 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
853 SKF_AD_OFF + SKF_AD_NLATTR),
854 BPF_STMT(BPF_RET | BPF_A, 0)
855 },
10f18e0b 856 CLASSIC,
df6d0f98
AS		 857#ifdef __BIG_ENDIAN
858 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
859#else
860 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
861#endif
862 { { 4, 0 }, { 20, 6 } },
9def624a
AS		 863 },
864 {
865 "LD_NLATTR_NEST",
ece80490 866 .u.insns = {
df6d0f98 867 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 868 BPF_STMT(BPF_LDX | BPF_IMM, 3),
869 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
870 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 871 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 872 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
873 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 874 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 875 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
876 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 877 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 878 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
879 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 880 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 881 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
882 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 883 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 884 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
885 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 886 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 887 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
888 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 889 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 890 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
891 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
892 BPF_STMT(BPF_RET | BPF_A, 0)
893 },
10f18e0b 894 CLASSIC,
df6d0f98
AS		 895#ifdef __BIG_ENDIAN
896 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
897#else
898 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
899#endif
900 { { 4, 0 }, { 20, 10 } },
9def624a
AS		 901 },
902 {
903 "LD_PAYLOAD_OFF",
ece80490 904 .u.insns = {
9def624a
AS		 905 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
906 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
907 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
908 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
909 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
910 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
911 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
912 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
913 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
914 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
915 BPF_STMT(BPF_RET | BPF_A, 0)
916 },
10f18e0b 917 CLASSIC,
9def624a
AS		 918 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
919 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
920 * id 9737, seq 1, length 64
921 */
922 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
923 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
924 0x08, 0x00,
925 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
926 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
927 { { 30, 0 }, { 100, 42 } },
928 },
929 {
930 "LD_ANC_XOR",
ece80490 931 .u.insns = {
9def624a
AS		 932 BPF_STMT(BPF_LD | BPF_IMM, 10),
933 BPF_STMT(BPF_LDX | BPF_IMM, 300),
934 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
935 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
936 BPF_STMT(BPF_RET | BPF_A, 0)
937 },
10f18e0b 938 CLASSIC,
9def624a
AS		 939 { },
940 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } },
941 },
942 {
943 "SPILL_FILL",
ece80490 944 .u.insns = {
9def624a
AS		 945 BPF_STMT(BPF_LDX | BPF_LEN, 0),
946 BPF_STMT(BPF_LD | BPF_IMM, 2),
947 BPF_STMT(BPF_ALU | BPF_RSH, 1),
948 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
949 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
950 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
951 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
952 BPF_STMT(BPF_STX, 15), /* M3 = len */
953 BPF_STMT(BPF_LDX | BPF_MEM, 1),
954 BPF_STMT(BPF_LD | BPF_MEM, 2),
955 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
956 BPF_STMT(BPF_LDX | BPF_MEM, 15),
957 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
958 BPF_STMT(BPF_RET | BPF_A, 0)
959 },
10f18e0b 960 CLASSIC,
9def624a
AS		 961 { },
962 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
963 },
964 {
965 "JEQ",
ece80490 966 .u.insns = {
9def624a
AS		 967 BPF_STMT(BPF_LDX | BPF_LEN, 0),
968 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
969 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
970 BPF_STMT(BPF_RET | BPF_K, 1),
971 BPF_STMT(BPF_RET | BPF_K, MAX_K)
972 },
10f18e0b 973 CLASSIC,
9def624a
AS		 974 { 3, 3, 3, 3, 3 },
975 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
976 },
977 {
978 "JGT",
ece80490 979 .u.insns = {
9def624a
AS		 980 BPF_STMT(BPF_LDX | BPF_LEN, 0),
981 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
982 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
983 BPF_STMT(BPF_RET | BPF_K, 1),
984 BPF_STMT(BPF_RET | BPF_K, MAX_K)
985 },
10f18e0b 986 CLASSIC,
9def624a
AS		 987 { 4, 4, 4, 3, 3 },
988 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
989 },
92b31a9a
DB		 990 {
991 "JGE (jt 0), test 1",
992 .u.insns = {
993 BPF_STMT(BPF_LDX | BPF_LEN, 0),
994 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
995 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
996 BPF_STMT(BPF_RET | BPF_K, 1),
997 BPF_STMT(BPF_RET | BPF_K, MAX_K)
998 },
999 CLASSIC,
1000 { 4, 4, 4, 3, 3 },
1001 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
1002 },
1003 {
1004 "JGE (jt 0), test 2",
1005 .u.insns = {
1006 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1007 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
1008 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
1009 BPF_STMT(BPF_RET | BPF_K, 1),
1010 BPF_STMT(BPF_RET | BPF_K, MAX_K)
1011 },
1012 CLASSIC,
1013 { 4, 4, 5, 3, 3 },
1014 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
1015 },
9def624a
AS		 1016 {
1017 "JGE",
ece80490 1018 .u.insns = {
9def624a
AS		 1019 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1020 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
1021 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
1022 BPF_STMT(BPF_RET | BPF_K, 10),
1023 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
1024 BPF_STMT(BPF_RET | BPF_K, 20),
1025 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
1026 BPF_STMT(BPF_RET | BPF_K, 30),
1027 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
1028 BPF_STMT(BPF_RET | BPF_K, 40),
1029 BPF_STMT(BPF_RET | BPF_K, MAX_K)
1030 },
10f18e0b 1031 CLASSIC,
9def624a
AS		 1032 { 1, 2, 3, 4, 5 },
1033 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
1034 },
1035 {
1036 "JSET",
ece80490 1037 .u.insns = {
9def624a
AS		 1038 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1039 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
1040 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1041 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1042 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1043 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1044 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
1045 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1046 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
1047 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
1048 BPF_STMT(BPF_RET | BPF_K, 10),
1049 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
1050 BPF_STMT(BPF_RET | BPF_K, 20),
1051 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1052 BPF_STMT(BPF_RET | BPF_K, 30),
1053 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1054 BPF_STMT(BPF_RET | BPF_K, 30),
1055 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1056 BPF_STMT(BPF_RET | BPF_K, 30),
1057 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1058 BPF_STMT(BPF_RET | BPF_K, 30),
1059 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1060 BPF_STMT(BPF_RET | BPF_K, 30),
1061 BPF_STMT(BPF_RET | BPF_K, MAX_K)
1062 },
10f18e0b 1063 CLASSIC,
9def624a
AS		 1064 { 0, 0xAA, 0x55, 1 },
1065 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
1066 },
64a8946b
AS		 1067 {
1068 "tcpdump port 22",
ece80490 1069 .u.insns = {
ce25b68b
DB		 1070 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
1071 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
1072 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
1073 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
1074 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
1075 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
1076 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
1077 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
1078 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
1079 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
1080 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
1081 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1082 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
1083 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
1084 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
1085 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1086 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
1087 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1088 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1089 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1090 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1091 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
1092 BPF_STMT(BPF_RET | BPF_K, 0xffff),
1093 BPF_STMT(BPF_RET | BPF_K, 0),
64a8946b 1094 },
10f18e0b 1095 CLASSIC,
64a8946b
AS		 1096 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
1097 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
1098 * seq 1305692979:1305693027, ack 3650467037, win 65535,
1099 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
1100 */
1101 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1102 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1103 0x08, 0x00,
1104 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1105 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1106 0x0a, 0x01, 0x01, 0x95, /* ip src */
1107 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1108 0xc2, 0x24,
1109 0x00, 0x16 /* dst port */ },
1110 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1111 },
9def624a
AS		 1112 {
1113 "tcpdump complex",
ece80490 1114 .u.insns = {
9def624a
AS		 1115 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
1116 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
1117 * (len > 115 or len < 30000000000)' -d
1118 */
ce25b68b
DB		 1119 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
1120 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
1121 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
1122 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1123 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
1124 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1125 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
1126 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1127 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1128 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1129 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1130 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
1131 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
1132 BPF_STMT(BPF_ST, 1),
1133 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
1134 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
1135 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
1136 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
1137 BPF_STMT(BPF_LD | BPF_MEM, 1),
1138 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
1139 BPF_STMT(BPF_ST, 5),
1140 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1141 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
1142 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
1143 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
1144 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
1145 BPF_STMT(BPF_LD | BPF_MEM, 5),
1146 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
1147 BPF_STMT(BPF_LD | BPF_LEN, 0),
1148 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
1149 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
1150 BPF_STMT(BPF_RET | BPF_K, 0xffff),
1151 BPF_STMT(BPF_RET | BPF_K, 0),
9def624a 1152 },
10f18e0b 1153 CLASSIC,
9def624a
AS		 1154 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1155 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1156 0x08, 0x00,
1157 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1158 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1159 0x0a, 0x01, 0x01, 0x95, /* ip src */
1160 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1161 0xc2, 0x24,
1162 0x00, 0x16 /* dst port */ },
1163 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1164 },
1165 {
1166 "RET_A",
ece80490 1167 .u.insns = {
9def624a
AS		 1168 /* check that unitialized X and A contain zeros */
1169 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1170 BPF_STMT(BPF_RET | BPF_A, 0)
1171 },
10f18e0b
DB		 1172 CLASSIC,
1173 { },
9def624a
AS		 1174 { {1, 0}, {2, 0} },
1175 },
1176 {
1177 "INT: ADD trivial",
ece80490 1178 .u.insns_int = {
9def624a
AS		 1179 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1180 BPF_ALU64_IMM(BPF_ADD, R1, 2),
1181 BPF_ALU64_IMM(BPF_MOV, R2, 3),
1182 BPF_ALU64_REG(BPF_SUB, R1, R2),
1183 BPF_ALU64_IMM(BPF_ADD, R1, -1),
1184 BPF_ALU64_IMM(BPF_MUL, R1, 3),
1185 BPF_ALU64_REG(BPF_MOV, R0, R1),
1186 BPF_EXIT_INSN(),
1187 },
10f18e0b 1188 INTERNAL,
9def624a
AS		 1189 { },
1190 { { 0, 0xfffffffd } }
1191 },
1192 {
1193 "INT: MUL_X",
ece80490 1194 .u.insns_int = {
9def624a
AS		 1195 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1196 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1197 BPF_ALU64_IMM(BPF_MOV, R2, 3),
1198 BPF_ALU64_REG(BPF_MUL, R1, R2),
1199 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
1200 BPF_EXIT_INSN(),
1201 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1202 BPF_EXIT_INSN(),
1203 },
10f18e0b 1204 INTERNAL,
9def624a
AS		 1205 { },
1206 { { 0, 1 } }
1207 },
1208 {
1209 "INT: MUL_X2",
ece80490 1210 .u.insns_int = {
9def624a
AS		 1211 BPF_ALU32_IMM(BPF_MOV, R0, -1),
1212 BPF_ALU32_IMM(BPF_MOV, R1, -1),
1213 BPF_ALU32_IMM(BPF_MOV, R2, 3),
1214 BPF_ALU64_REG(BPF_MUL, R1, R2),
1215 BPF_ALU64_IMM(BPF_RSH, R1, 8),
1216 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
1217 BPF_EXIT_INSN(),
1218 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1219 BPF_EXIT_INSN(),
1220 },
10f18e0b 1221 INTERNAL,
9def624a
AS		 1222 { },
1223 { { 0, 1 } }
1224 },
1225 {
1226 "INT: MUL32_X",
ece80490 1227 .u.insns_int = {
9def624a
AS		 1228 BPF_ALU32_IMM(BPF_MOV, R0, -1),
1229 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1230 BPF_ALU32_IMM(BPF_MOV, R2, 3),
1231 BPF_ALU32_REG(BPF_MUL, R1, R2),
1232 BPF_ALU64_IMM(BPF_RSH, R1, 8),
1233 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
1234 BPF_EXIT_INSN(),
1235 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1236 BPF_EXIT_INSN(),
1237 },
10f18e0b 1238 INTERNAL,
9def624a
AS		 1239 { },
1240 { { 0, 1 } }
1241 },
1242 {
1243 /* Have to test all register combinations, since
1244 * JITing of different registers will produce
1245 * different asm code.
1246 */
1247 "INT: ADD 64-bit",
ece80490 1248 .u.insns_int = {
9def624a
AS		 1249 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1250 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1251 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1252 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1253 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1254 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1255 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1256 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1257 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1258 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1259 BPF_ALU64_IMM(BPF_ADD, R0, 20),
1260 BPF_ALU64_IMM(BPF_ADD, R1, 20),
1261 BPF_ALU64_IMM(BPF_ADD, R2, 20),
1262 BPF_ALU64_IMM(BPF_ADD, R3, 20),
1263 BPF_ALU64_IMM(BPF_ADD, R4, 20),
1264 BPF_ALU64_IMM(BPF_ADD, R5, 20),
1265 BPF_ALU64_IMM(BPF_ADD, R6, 20),
1266 BPF_ALU64_IMM(BPF_ADD, R7, 20),
1267 BPF_ALU64_IMM(BPF_ADD, R8, 20),
1268 BPF_ALU64_IMM(BPF_ADD, R9, 20),
1269 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1270 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1271 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1272 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1273 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1274 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1275 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1276 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1277 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1278 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1279 BPF_ALU64_REG(BPF_ADD, R0, R0),
1280 BPF_ALU64_REG(BPF_ADD, R0, R1),
1281 BPF_ALU64_REG(BPF_ADD, R0, R2),
1282 BPF_ALU64_REG(BPF_ADD, R0, R3),
1283 BPF_ALU64_REG(BPF_ADD, R0, R4),
1284 BPF_ALU64_REG(BPF_ADD, R0, R5),
1285 BPF_ALU64_REG(BPF_ADD, R0, R6),
1286 BPF_ALU64_REG(BPF_ADD, R0, R7),
1287 BPF_ALU64_REG(BPF_ADD, R0, R8),
1288 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1289 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1290 BPF_EXIT_INSN(),
1291 BPF_ALU64_REG(BPF_ADD, R1, R0),
1292 BPF_ALU64_REG(BPF_ADD, R1, R1),
1293 BPF_ALU64_REG(BPF_ADD, R1, R2),
1294 BPF_ALU64_REG(BPF_ADD, R1, R3),
1295 BPF_ALU64_REG(BPF_ADD, R1, R4),
1296 BPF_ALU64_REG(BPF_ADD, R1, R5),
1297 BPF_ALU64_REG(BPF_ADD, R1, R6),
1298 BPF_ALU64_REG(BPF_ADD, R1, R7),
1299 BPF_ALU64_REG(BPF_ADD, R1, R8),
1300 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1301 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1302 BPF_EXIT_INSN(),
1303 BPF_ALU64_REG(BPF_ADD, R2, R0),
1304 BPF_ALU64_REG(BPF_ADD, R2, R1),
1305 BPF_ALU64_REG(BPF_ADD, R2, R2),
1306 BPF_ALU64_REG(BPF_ADD, R2, R3),
1307 BPF_ALU64_REG(BPF_ADD, R2, R4),
1308 BPF_ALU64_REG(BPF_ADD, R2, R5),
1309 BPF_ALU64_REG(BPF_ADD, R2, R6),
1310 BPF_ALU64_REG(BPF_ADD, R2, R7),
1311 BPF_ALU64_REG(BPF_ADD, R2, R8),
1312 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1313 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1314 BPF_EXIT_INSN(),
1315 BPF_ALU64_REG(BPF_ADD, R3, R0),
1316 BPF_ALU64_REG(BPF_ADD, R3, R1),
1317 BPF_ALU64_REG(BPF_ADD, R3, R2),
1318 BPF_ALU64_REG(BPF_ADD, R3, R3),
1319 BPF_ALU64_REG(BPF_ADD, R3, R4),
1320 BPF_ALU64_REG(BPF_ADD, R3, R5),
1321 BPF_ALU64_REG(BPF_ADD, R3, R6),
1322 BPF_ALU64_REG(BPF_ADD, R3, R7),
1323 BPF_ALU64_REG(BPF_ADD, R3, R8),
1324 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1325 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1326 BPF_EXIT_INSN(),
1327 BPF_ALU64_REG(BPF_ADD, R4, R0),
1328 BPF_ALU64_REG(BPF_ADD, R4, R1),
1329 BPF_ALU64_REG(BPF_ADD, R4, R2),
1330 BPF_ALU64_REG(BPF_ADD, R4, R3),
1331 BPF_ALU64_REG(BPF_ADD, R4, R4),
1332 BPF_ALU64_REG(BPF_ADD, R4, R5),
1333 BPF_ALU64_REG(BPF_ADD, R4, R6),
1334 BPF_ALU64_REG(BPF_ADD, R4, R7),
1335 BPF_ALU64_REG(BPF_ADD, R4, R8),
1336 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1337 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1338 BPF_EXIT_INSN(),
1339 BPF_ALU64_REG(BPF_ADD, R5, R0),
1340 BPF_ALU64_REG(BPF_ADD, R5, R1),
1341 BPF_ALU64_REG(BPF_ADD, R5, R2),
1342 BPF_ALU64_REG(BPF_ADD, R5, R3),
1343 BPF_ALU64_REG(BPF_ADD, R5, R4),
1344 BPF_ALU64_REG(BPF_ADD, R5, R5),
1345 BPF_ALU64_REG(BPF_ADD, R5, R6),
1346 BPF_ALU64_REG(BPF_ADD, R5, R7),
1347 BPF_ALU64_REG(BPF_ADD, R5, R8),
1348 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1349 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1350 BPF_EXIT_INSN(),
1351 BPF_ALU64_REG(BPF_ADD, R6, R0),
1352 BPF_ALU64_REG(BPF_ADD, R6, R1),
1353 BPF_ALU64_REG(BPF_ADD, R6, R2),
1354 BPF_ALU64_REG(BPF_ADD, R6, R3),
1355 BPF_ALU64_REG(BPF_ADD, R6, R4),
1356 BPF_ALU64_REG(BPF_ADD, R6, R5),
1357 BPF_ALU64_REG(BPF_ADD, R6, R6),
1358 BPF_ALU64_REG(BPF_ADD, R6, R7),
1359 BPF_ALU64_REG(BPF_ADD, R6, R8),
1360 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1361 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1362 BPF_EXIT_INSN(),
1363 BPF_ALU64_REG(BPF_ADD, R7, R0),
1364 BPF_ALU64_REG(BPF_ADD, R7, R1),
1365 BPF_ALU64_REG(BPF_ADD, R7, R2),
1366 BPF_ALU64_REG(BPF_ADD, R7, R3),
1367 BPF_ALU64_REG(BPF_ADD, R7, R4),
1368 BPF_ALU64_REG(BPF_ADD, R7, R5),
1369 BPF_ALU64_REG(BPF_ADD, R7, R6),
1370 BPF_ALU64_REG(BPF_ADD, R7, R7),
1371 BPF_ALU64_REG(BPF_ADD, R7, R8),
1372 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1373 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1374 BPF_EXIT_INSN(),
1375 BPF_ALU64_REG(BPF_ADD, R8, R0),
1376 BPF_ALU64_REG(BPF_ADD, R8, R1),
1377 BPF_ALU64_REG(BPF_ADD, R8, R2),
1378 BPF_ALU64_REG(BPF_ADD, R8, R3),
1379 BPF_ALU64_REG(BPF_ADD, R8, R4),
1380 BPF_ALU64_REG(BPF_ADD, R8, R5),
1381 BPF_ALU64_REG(BPF_ADD, R8, R6),
1382 BPF_ALU64_REG(BPF_ADD, R8, R7),
1383 BPF_ALU64_REG(BPF_ADD, R8, R8),
1384 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1385 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1386 BPF_EXIT_INSN(),
1387 BPF_ALU64_REG(BPF_ADD, R9, R0),
1388 BPF_ALU64_REG(BPF_ADD, R9, R1),
1389 BPF_ALU64_REG(BPF_ADD, R9, R2),
1390 BPF_ALU64_REG(BPF_ADD, R9, R3),
1391 BPF_ALU64_REG(BPF_ADD, R9, R4),
1392 BPF_ALU64_REG(BPF_ADD, R9, R5),
1393 BPF_ALU64_REG(BPF_ADD, R9, R6),
1394 BPF_ALU64_REG(BPF_ADD, R9, R7),
1395 BPF_ALU64_REG(BPF_ADD, R9, R8),
1396 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1397 BPF_ALU64_REG(BPF_MOV, R0, R9),
1398 BPF_EXIT_INSN(),
1399 },
10f18e0b 1400 INTERNAL,
9def624a
AS		 1401 { },
1402 { { 0, 2957380 } }
1403 },
1404 {
1405 "INT: ADD 32-bit",
ece80490 1406 .u.insns_int = {
9def624a
AS		 1407 BPF_ALU32_IMM(BPF_MOV, R0, 20),
1408 BPF_ALU32_IMM(BPF_MOV, R1, 1),
1409 BPF_ALU32_IMM(BPF_MOV, R2, 2),
1410 BPF_ALU32_IMM(BPF_MOV, R3, 3),
1411 BPF_ALU32_IMM(BPF_MOV, R4, 4),
1412 BPF_ALU32_IMM(BPF_MOV, R5, 5),
1413 BPF_ALU32_IMM(BPF_MOV, R6, 6),
1414 BPF_ALU32_IMM(BPF_MOV, R7, 7),
1415 BPF_ALU32_IMM(BPF_MOV, R8, 8),
1416 BPF_ALU32_IMM(BPF_MOV, R9, 9),
1417 BPF_ALU64_IMM(BPF_ADD, R1, 10),
1418 BPF_ALU64_IMM(BPF_ADD, R2, 10),
1419 BPF_ALU64_IMM(BPF_ADD, R3, 10),
1420 BPF_ALU64_IMM(BPF_ADD, R4, 10),
1421 BPF_ALU64_IMM(BPF_ADD, R5, 10),
1422 BPF_ALU64_IMM(BPF_ADD, R6, 10),
1423 BPF_ALU64_IMM(BPF_ADD, R7, 10),
1424 BPF_ALU64_IMM(BPF_ADD, R8, 10),
1425 BPF_ALU64_IMM(BPF_ADD, R9, 10),
1426 BPF_ALU32_REG(BPF_ADD, R0, R1),
1427 BPF_ALU32_REG(BPF_ADD, R0, R2),
1428 BPF_ALU32_REG(BPF_ADD, R0, R3),
1429 BPF_ALU32_REG(BPF_ADD, R0, R4),
1430 BPF_ALU32_REG(BPF_ADD, R0, R5),
1431 BPF_ALU32_REG(BPF_ADD, R0, R6),
1432 BPF_ALU32_REG(BPF_ADD, R0, R7),
1433 BPF_ALU32_REG(BPF_ADD, R0, R8),
1434 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1435 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1436 BPF_EXIT_INSN(),
1437 BPF_ALU32_REG(BPF_ADD, R1, R0),
1438 BPF_ALU32_REG(BPF_ADD, R1, R1),
1439 BPF_ALU32_REG(BPF_ADD, R1, R2),
1440 BPF_ALU32_REG(BPF_ADD, R1, R3),
1441 BPF_ALU32_REG(BPF_ADD, R1, R4),
1442 BPF_ALU32_REG(BPF_ADD, R1, R5),
1443 BPF_ALU32_REG(BPF_ADD, R1, R6),
1444 BPF_ALU32_REG(BPF_ADD, R1, R7),
1445 BPF_ALU32_REG(BPF_ADD, R1, R8),
1446 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1447 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1448 BPF_EXIT_INSN(),
1449 BPF_ALU32_REG(BPF_ADD, R2, R0),
1450 BPF_ALU32_REG(BPF_ADD, R2, R1),
1451 BPF_ALU32_REG(BPF_ADD, R2, R2),
1452 BPF_ALU32_REG(BPF_ADD, R2, R3),
1453 BPF_ALU32_REG(BPF_ADD, R2, R4),
1454 BPF_ALU32_REG(BPF_ADD, R2, R5),
1455 BPF_ALU32_REG(BPF_ADD, R2, R6),
1456 BPF_ALU32_REG(BPF_ADD, R2, R7),
1457 BPF_ALU32_REG(BPF_ADD, R2, R8),
1458 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1459 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1460 BPF_EXIT_INSN(),
1461 BPF_ALU32_REG(BPF_ADD, R3, R0),
1462 BPF_ALU32_REG(BPF_ADD, R3, R1),
1463 BPF_ALU32_REG(BPF_ADD, R3, R2),
1464 BPF_ALU32_REG(BPF_ADD, R3, R3),
1465 BPF_ALU32_REG(BPF_ADD, R3, R4),
1466 BPF_ALU32_REG(BPF_ADD, R3, R5),
1467 BPF_ALU32_REG(BPF_ADD, R3, R6),
1468 BPF_ALU32_REG(BPF_ADD, R3, R7),
1469 BPF_ALU32_REG(BPF_ADD, R3, R8),
1470 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1471 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1472 BPF_EXIT_INSN(),
1473 BPF_ALU32_REG(BPF_ADD, R4, R0),
1474 BPF_ALU32_REG(BPF_ADD, R4, R1),
1475 BPF_ALU32_REG(BPF_ADD, R4, R2),
1476 BPF_ALU32_REG(BPF_ADD, R4, R3),
1477 BPF_ALU32_REG(BPF_ADD, R4, R4),
1478 BPF_ALU32_REG(BPF_ADD, R4, R5),
1479 BPF_ALU32_REG(BPF_ADD, R4, R6),
1480 BPF_ALU32_REG(BPF_ADD, R4, R7),
1481 BPF_ALU32_REG(BPF_ADD, R4, R8),
1482 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1483 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1484 BPF_EXIT_INSN(),
1485 BPF_ALU32_REG(BPF_ADD, R5, R0),
1486 BPF_ALU32_REG(BPF_ADD, R5, R1),
1487 BPF_ALU32_REG(BPF_ADD, R5, R2),
1488 BPF_ALU32_REG(BPF_ADD, R5, R3),
1489 BPF_ALU32_REG(BPF_ADD, R5, R4),
1490 BPF_ALU32_REG(BPF_ADD, R5, R5),
1491 BPF_ALU32_REG(BPF_ADD, R5, R6),
1492 BPF_ALU32_REG(BPF_ADD, R5, R7),
1493 BPF_ALU32_REG(BPF_ADD, R5, R8),
1494 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1495 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1496 BPF_EXIT_INSN(),
1497 BPF_ALU32_REG(BPF_ADD, R6, R0),
1498 BPF_ALU32_REG(BPF_ADD, R6, R1),
1499 BPF_ALU32_REG(BPF_ADD, R6, R2),
1500 BPF_ALU32_REG(BPF_ADD, R6, R3),
1501 BPF_ALU32_REG(BPF_ADD, R6, R4),
1502 BPF_ALU32_REG(BPF_ADD, R6, R5),
1503 BPF_ALU32_REG(BPF_ADD, R6, R6),
1504 BPF_ALU32_REG(BPF_ADD, R6, R7),
1505 BPF_ALU32_REG(BPF_ADD, R6, R8),
1506 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1507 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1508 BPF_EXIT_INSN(),
1509 BPF_ALU32_REG(BPF_ADD, R7, R0),
1510 BPF_ALU32_REG(BPF_ADD, R7, R1),
1511 BPF_ALU32_REG(BPF_ADD, R7, R2),
1512 BPF_ALU32_REG(BPF_ADD, R7, R3),
1513 BPF_ALU32_REG(BPF_ADD, R7, R4),
1514 BPF_ALU32_REG(BPF_ADD, R7, R5),
1515 BPF_ALU32_REG(BPF_ADD, R7, R6),
1516 BPF_ALU32_REG(BPF_ADD, R7, R7),
1517 BPF_ALU32_REG(BPF_ADD, R7, R8),
1518 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1519 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1520 BPF_EXIT_INSN(),
1521 BPF_ALU32_REG(BPF_ADD, R8, R0),
1522 BPF_ALU32_REG(BPF_ADD, R8, R1),
1523 BPF_ALU32_REG(BPF_ADD, R8, R2),
1524 BPF_ALU32_REG(BPF_ADD, R8, R3),
1525 BPF_ALU32_REG(BPF_ADD, R8, R4),
1526 BPF_ALU32_REG(BPF_ADD, R8, R5),
1527 BPF_ALU32_REG(BPF_ADD, R8, R6),
1528 BPF_ALU32_REG(BPF_ADD, R8, R7),
1529 BPF_ALU32_REG(BPF_ADD, R8, R8),
1530 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1531 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1532 BPF_EXIT_INSN(),
1533 BPF_ALU32_REG(BPF_ADD, R9, R0),
1534 BPF_ALU32_REG(BPF_ADD, R9, R1),
1535 BPF_ALU32_REG(BPF_ADD, R9, R2),
1536 BPF_ALU32_REG(BPF_ADD, R9, R3),
1537 BPF_ALU32_REG(BPF_ADD, R9, R4),
1538 BPF_ALU32_REG(BPF_ADD, R9, R5),
1539 BPF_ALU32_REG(BPF_ADD, R9, R6),
1540 BPF_ALU32_REG(BPF_ADD, R9, R7),
1541 BPF_ALU32_REG(BPF_ADD, R9, R8),
1542 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1543 BPF_ALU32_REG(BPF_MOV, R0, R9),
1544 BPF_EXIT_INSN(),
1545 },
10f18e0b 1546 INTERNAL,
9def624a
AS		 1547 { },
1548 { { 0, 2957380 } }
1549 },
1550 { /* Mainly checking JIT here. */
1551 "INT: SUB",
ece80490 1552 .u.insns_int = {
9def624a
AS		 1553 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1554 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1555 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1556 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1557 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1558 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1559 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1560 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1561 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1562 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1563 BPF_ALU64_REG(BPF_SUB, R0, R0),
1564 BPF_ALU64_REG(BPF_SUB, R0, R1),
1565 BPF_ALU64_REG(BPF_SUB, R0, R2),
1566 BPF_ALU64_REG(BPF_SUB, R0, R3),
1567 BPF_ALU64_REG(BPF_SUB, R0, R4),
1568 BPF_ALU64_REG(BPF_SUB, R0, R5),
1569 BPF_ALU64_REG(BPF_SUB, R0, R6),
1570 BPF_ALU64_REG(BPF_SUB, R0, R7),
1571 BPF_ALU64_REG(BPF_SUB, R0, R8),
1572 BPF_ALU64_REG(BPF_SUB, R0, R9),
1573 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1574 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
1575 BPF_EXIT_INSN(),
1576 BPF_ALU64_REG(BPF_SUB, R1, R0),
1577 BPF_ALU64_REG(BPF_SUB, R1, R2),
1578 BPF_ALU64_REG(BPF_SUB, R1, R3),
1579 BPF_ALU64_REG(BPF_SUB, R1, R4),
1580 BPF_ALU64_REG(BPF_SUB, R1, R5),
1581 BPF_ALU64_REG(BPF_SUB, R1, R6),
1582 BPF_ALU64_REG(BPF_SUB, R1, R7),
1583 BPF_ALU64_REG(BPF_SUB, R1, R8),
1584 BPF_ALU64_REG(BPF_SUB, R1, R9),
1585 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1586 BPF_ALU64_REG(BPF_SUB, R2, R0),
1587 BPF_ALU64_REG(BPF_SUB, R2, R1),
1588 BPF_ALU64_REG(BPF_SUB, R2, R3),
1589 BPF_ALU64_REG(BPF_SUB, R2, R4),
1590 BPF_ALU64_REG(BPF_SUB, R2, R5),
1591 BPF_ALU64_REG(BPF_SUB, R2, R6),
1592 BPF_ALU64_REG(BPF_SUB, R2, R7),
1593 BPF_ALU64_REG(BPF_SUB, R2, R8),
1594 BPF_ALU64_REG(BPF_SUB, R2, R9),
1595 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1596 BPF_ALU64_REG(BPF_SUB, R3, R0),
1597 BPF_ALU64_REG(BPF_SUB, R3, R1),
1598 BPF_ALU64_REG(BPF_SUB, R3, R2),
1599 BPF_ALU64_REG(BPF_SUB, R3, R4),
1600 BPF_ALU64_REG(BPF_SUB, R3, R5),
1601 BPF_ALU64_REG(BPF_SUB, R3, R6),
1602 BPF_ALU64_REG(BPF_SUB, R3, R7),
1603 BPF_ALU64_REG(BPF_SUB, R3, R8),
1604 BPF_ALU64_REG(BPF_SUB, R3, R9),
1605 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1606 BPF_ALU64_REG(BPF_SUB, R4, R0),
1607 BPF_ALU64_REG(BPF_SUB, R4, R1),
1608 BPF_ALU64_REG(BPF_SUB, R4, R2),
1609 BPF_ALU64_REG(BPF_SUB, R4, R3),
1610 BPF_ALU64_REG(BPF_SUB, R4, R5),
1611 BPF_ALU64_REG(BPF_SUB, R4, R6),
1612 BPF_ALU64_REG(BPF_SUB, R4, R7),
1613 BPF_ALU64_REG(BPF_SUB, R4, R8),
1614 BPF_ALU64_REG(BPF_SUB, R4, R9),
1615 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1616 BPF_ALU64_REG(BPF_SUB, R5, R0),
1617 BPF_ALU64_REG(BPF_SUB, R5, R1),
1618 BPF_ALU64_REG(BPF_SUB, R5, R2),
1619 BPF_ALU64_REG(BPF_SUB, R5, R3),
1620 BPF_ALU64_REG(BPF_SUB, R5, R4),
1621 BPF_ALU64_REG(BPF_SUB, R5, R6),
1622 BPF_ALU64_REG(BPF_SUB, R5, R7),
1623 BPF_ALU64_REG(BPF_SUB, R5, R8),
1624 BPF_ALU64_REG(BPF_SUB, R5, R9),
1625 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1626 BPF_ALU64_REG(BPF_SUB, R6, R0),
1627 BPF_ALU64_REG(BPF_SUB, R6, R1),
1628 BPF_ALU64_REG(BPF_SUB, R6, R2),
1629 BPF_ALU64_REG(BPF_SUB, R6, R3),
1630 BPF_ALU64_REG(BPF_SUB, R6, R4),
1631 BPF_ALU64_REG(BPF_SUB, R6, R5),
1632 BPF_ALU64_REG(BPF_SUB, R6, R7),
1633 BPF_ALU64_REG(BPF_SUB, R6, R8),
1634 BPF_ALU64_REG(BPF_SUB, R6, R9),
1635 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1636 BPF_ALU64_REG(BPF_SUB, R7, R0),
1637 BPF_ALU64_REG(BPF_SUB, R7, R1),
1638 BPF_ALU64_REG(BPF_SUB, R7, R2),
1639 BPF_ALU64_REG(BPF_SUB, R7, R3),
1640 BPF_ALU64_REG(BPF_SUB, R7, R4),
1641 BPF_ALU64_REG(BPF_SUB, R7, R5),
1642 BPF_ALU64_REG(BPF_SUB, R7, R6),
1643 BPF_ALU64_REG(BPF_SUB, R7, R8),
1644 BPF_ALU64_REG(BPF_SUB, R7, R9),
1645 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1646 BPF_ALU64_REG(BPF_SUB, R8, R0),
1647 BPF_ALU64_REG(BPF_SUB, R8, R1),
1648 BPF_ALU64_REG(BPF_SUB, R8, R2),
1649 BPF_ALU64_REG(BPF_SUB, R8, R3),
1650 BPF_ALU64_REG(BPF_SUB, R8, R4),
1651 BPF_ALU64_REG(BPF_SUB, R8, R5),
1652 BPF_ALU64_REG(BPF_SUB, R8, R6),
1653 BPF_ALU64_REG(BPF_SUB, R8, R7),
1654 BPF_ALU64_REG(BPF_SUB, R8, R9),
1655 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1656 BPF_ALU64_REG(BPF_SUB, R9, R0),
1657 BPF_ALU64_REG(BPF_SUB, R9, R1),
1658 BPF_ALU64_REG(BPF_SUB, R9, R2),
1659 BPF_ALU64_REG(BPF_SUB, R9, R3),
1660 BPF_ALU64_REG(BPF_SUB, R9, R4),
1661 BPF_ALU64_REG(BPF_SUB, R9, R5),
1662 BPF_ALU64_REG(BPF_SUB, R9, R6),
1663 BPF_ALU64_REG(BPF_SUB, R9, R7),
1664 BPF_ALU64_REG(BPF_SUB, R9, R8),
1665 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1666 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1667 BPF_ALU64_IMM(BPF_NEG, R0, 0),
1668 BPF_ALU64_REG(BPF_SUB, R0, R1),
1669 BPF_ALU64_REG(BPF_SUB, R0, R2),
1670 BPF_ALU64_REG(BPF_SUB, R0, R3),
1671 BPF_ALU64_REG(BPF_SUB, R0, R4),
1672 BPF_ALU64_REG(BPF_SUB, R0, R5),
1673 BPF_ALU64_REG(BPF_SUB, R0, R6),
1674 BPF_ALU64_REG(BPF_SUB, R0, R7),
1675 BPF_ALU64_REG(BPF_SUB, R0, R8),
1676 BPF_ALU64_REG(BPF_SUB, R0, R9),
1677 BPF_EXIT_INSN(),
1678 },
10f18e0b 1679 INTERNAL,
9def624a
AS		 1680 { },
1681 { { 0, 11 } }
1682 },
1683 { /* Mainly checking JIT here. */
1684 "INT: XOR",
ece80490 1685 .u.insns_int = {
9def624a
AS		 1686 BPF_ALU64_REG(BPF_SUB, R0, R0),
1687 BPF_ALU64_REG(BPF_XOR, R1, R1),
1688 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
1689 BPF_EXIT_INSN(),
1690 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1691 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1692 BPF_ALU64_REG(BPF_SUB, R1, R1),
1693 BPF_ALU64_REG(BPF_XOR, R2, R2),
1694 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
1695 BPF_EXIT_INSN(),
1696 BPF_ALU64_REG(BPF_SUB, R2, R2),
1697 BPF_ALU64_REG(BPF_XOR, R3, R3),
1698 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1699 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1700 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
1701 BPF_EXIT_INSN(),
1702 BPF_ALU64_REG(BPF_SUB, R3, R3),
1703 BPF_ALU64_REG(BPF_XOR, R4, R4),
1704 BPF_ALU64_IMM(BPF_MOV, R2, 1),
1705 BPF_ALU64_IMM(BPF_MOV, R5, -1),
1706 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
1707 BPF_EXIT_INSN(),
1708 BPF_ALU64_REG(BPF_SUB, R4, R4),
1709 BPF_ALU64_REG(BPF_XOR, R5, R5),
1710 BPF_ALU64_IMM(BPF_MOV, R3, 1),
1711 BPF_ALU64_IMM(BPF_MOV, R7, -1),
1712 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
1713 BPF_EXIT_INSN(),
1714 BPF_ALU64_IMM(BPF_MOV, R5, 1),
1715 BPF_ALU64_REG(BPF_SUB, R5, R5),
1716 BPF_ALU64_REG(BPF_XOR, R6, R6),
1717 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1718 BPF_ALU64_IMM(BPF_MOV, R8, -1),
1719 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
1720 BPF_EXIT_INSN(),
1721 BPF_ALU64_REG(BPF_SUB, R6, R6),
1722 BPF_ALU64_REG(BPF_XOR, R7, R7),
1723 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
1724 BPF_EXIT_INSN(),
1725 BPF_ALU64_REG(BPF_SUB, R7, R7),
1726 BPF_ALU64_REG(BPF_XOR, R8, R8),
1727 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
1728 BPF_EXIT_INSN(),
1729 BPF_ALU64_REG(BPF_SUB, R8, R8),
1730 BPF_ALU64_REG(BPF_XOR, R9, R9),
1731 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
1732 BPF_EXIT_INSN(),
1733 BPF_ALU64_REG(BPF_SUB, R9, R9),
1734 BPF_ALU64_REG(BPF_XOR, R0, R0),
1735 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
1736 BPF_EXIT_INSN(),
1737 BPF_ALU64_REG(BPF_SUB, R1, R1),
1738 BPF_ALU64_REG(BPF_XOR, R0, R0),
1739 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
1740 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1741 BPF_EXIT_INSN(),
1742 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1743 BPF_EXIT_INSN(),
1744 },
10f18e0b 1745 INTERNAL,
9def624a
AS		 1746 { },
1747 { { 0, 1 } }
1748 },
1749 { /* Mainly checking JIT here. */
1750 "INT: MUL",
ece80490 1751 .u.insns_int = {
9def624a
AS		 1752 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1753 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1754 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1755 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1756 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1757 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1758 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1759 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1760 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1761 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1762 BPF_ALU64_REG(BPF_MUL, R0, R0),
1763 BPF_ALU64_REG(BPF_MUL, R0, R1),
1764 BPF_ALU64_REG(BPF_MUL, R0, R2),
1765 BPF_ALU64_REG(BPF_MUL, R0, R3),
1766 BPF_ALU64_REG(BPF_MUL, R0, R4),
1767 BPF_ALU64_REG(BPF_MUL, R0, R5),
1768 BPF_ALU64_REG(BPF_MUL, R0, R6),
1769 BPF_ALU64_REG(BPF_MUL, R0, R7),
1770 BPF_ALU64_REG(BPF_MUL, R0, R8),
1771 BPF_ALU64_REG(BPF_MUL, R0, R9),
1772 BPF_ALU64_IMM(BPF_MUL, R0, 10),
1773 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
1774 BPF_EXIT_INSN(),
1775 BPF_ALU64_REG(BPF_MUL, R1, R0),
1776 BPF_ALU64_REG(BPF_MUL, R1, R2),
1777 BPF_ALU64_REG(BPF_MUL, R1, R3),
1778 BPF_ALU64_REG(BPF_MUL, R1, R4),
1779 BPF_ALU64_REG(BPF_MUL, R1, R5),
1780 BPF_ALU64_REG(BPF_MUL, R1, R6),
1781 BPF_ALU64_REG(BPF_MUL, R1, R7),
1782 BPF_ALU64_REG(BPF_MUL, R1, R8),
1783 BPF_ALU64_REG(BPF_MUL, R1, R9),
1784 BPF_ALU64_IMM(BPF_MUL, R1, 10),
1785 BPF_ALU64_REG(BPF_MOV, R2, R1),
1786 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1787 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
1788 BPF_EXIT_INSN(),
1789 BPF_ALU64_IMM(BPF_LSH, R1, 32),
1790 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
1791 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
1792 BPF_EXIT_INSN(),
1793 BPF_ALU64_REG(BPF_MUL, R2, R0),
1794 BPF_ALU64_REG(BPF_MUL, R2, R1),
1795 BPF_ALU64_REG(BPF_MUL, R2, R3),
1796 BPF_ALU64_REG(BPF_MUL, R2, R4),
1797 BPF_ALU64_REG(BPF_MUL, R2, R5),
1798 BPF_ALU64_REG(BPF_MUL, R2, R6),
1799 BPF_ALU64_REG(BPF_MUL, R2, R7),
1800 BPF_ALU64_REG(BPF_MUL, R2, R8),
1801 BPF_ALU64_REG(BPF_MUL, R2, R9),
1802 BPF_ALU64_IMM(BPF_MUL, R2, 10),
1803 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1804 BPF_ALU64_REG(BPF_MOV, R0, R2),
1805 BPF_EXIT_INSN(),
1806 },
10f18e0b 1807 INTERNAL,
9def624a
AS		 1808 { },
1809 { { 0, 0x35d97ef2 } }
1810 },
9dd2af83
DB		 1811 { /* Mainly checking JIT here. */
1812 "MOV REG64",
1813 .u.insns_int = {
1814 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1815 BPF_MOV64_REG(R1, R0),
1816 BPF_MOV64_REG(R2, R1),
1817 BPF_MOV64_REG(R3, R2),
1818 BPF_MOV64_REG(R4, R3),
1819 BPF_MOV64_REG(R5, R4),
1820 BPF_MOV64_REG(R6, R5),
1821 BPF_MOV64_REG(R7, R6),
1822 BPF_MOV64_REG(R8, R7),
1823 BPF_MOV64_REG(R9, R8),
1824 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1825 BPF_ALU64_IMM(BPF_MOV, R1, 0),
1826 BPF_ALU64_IMM(BPF_MOV, R2, 0),
1827 BPF_ALU64_IMM(BPF_MOV, R3, 0),
1828 BPF_ALU64_IMM(BPF_MOV, R4, 0),
1829 BPF_ALU64_IMM(BPF_MOV, R5, 0),
1830 BPF_ALU64_IMM(BPF_MOV, R6, 0),
1831 BPF_ALU64_IMM(BPF_MOV, R7, 0),
1832 BPF_ALU64_IMM(BPF_MOV, R8, 0),
1833 BPF_ALU64_IMM(BPF_MOV, R9, 0),
1834 BPF_ALU64_REG(BPF_ADD, R0, R0),
1835 BPF_ALU64_REG(BPF_ADD, R0, R1),
1836 BPF_ALU64_REG(BPF_ADD, R0, R2),
1837 BPF_ALU64_REG(BPF_ADD, R0, R3),
1838 BPF_ALU64_REG(BPF_ADD, R0, R4),
1839 BPF_ALU64_REG(BPF_ADD, R0, R5),
1840 BPF_ALU64_REG(BPF_ADD, R0, R6),
1841 BPF_ALU64_REG(BPF_ADD, R0, R7),
1842 BPF_ALU64_REG(BPF_ADD, R0, R8),
1843 BPF_ALU64_REG(BPF_ADD, R0, R9),
1844 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1845 BPF_EXIT_INSN(),
1846 },
1847 INTERNAL,
1848 { },
1849 { { 0, 0xfefe } }
1850 },
1851 { /* Mainly checking JIT here. */
1852 "MOV REG32",
1853 .u.insns_int = {
1854 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1855 BPF_MOV64_REG(R1, R0),
1856 BPF_MOV64_REG(R2, R1),
1857 BPF_MOV64_REG(R3, R2),
1858 BPF_MOV64_REG(R4, R3),
1859 BPF_MOV64_REG(R5, R4),
1860 BPF_MOV64_REG(R6, R5),
1861 BPF_MOV64_REG(R7, R6),
1862 BPF_MOV64_REG(R8, R7),
1863 BPF_MOV64_REG(R9, R8),
1864 BPF_ALU32_IMM(BPF_MOV, R0, 0),
1865 BPF_ALU32_IMM(BPF_MOV, R1, 0),
1866 BPF_ALU32_IMM(BPF_MOV, R2, 0),
1867 BPF_ALU32_IMM(BPF_MOV, R3, 0),
1868 BPF_ALU32_IMM(BPF_MOV, R4, 0),
1869 BPF_ALU32_IMM(BPF_MOV, R5, 0),
1870 BPF_ALU32_IMM(BPF_MOV, R6, 0),
1871 BPF_ALU32_IMM(BPF_MOV, R7, 0),
1872 BPF_ALU32_IMM(BPF_MOV, R8, 0),
1873 BPF_ALU32_IMM(BPF_MOV, R9, 0),
1874 BPF_ALU64_REG(BPF_ADD, R0, R0),
1875 BPF_ALU64_REG(BPF_ADD, R0, R1),
1876 BPF_ALU64_REG(BPF_ADD, R0, R2),
1877 BPF_ALU64_REG(BPF_ADD, R0, R3),
1878 BPF_ALU64_REG(BPF_ADD, R0, R4),
1879 BPF_ALU64_REG(BPF_ADD, R0, R5),
1880 BPF_ALU64_REG(BPF_ADD, R0, R6),
1881 BPF_ALU64_REG(BPF_ADD, R0, R7),
1882 BPF_ALU64_REG(BPF_ADD, R0, R8),
1883 BPF_ALU64_REG(BPF_ADD, R0, R9),
1884 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1885 BPF_EXIT_INSN(),
1886 },
1887 INTERNAL,
1888 { },
1889 { { 0, 0xfefe } }
1890 },
1891 { /* Mainly checking JIT here. */
1892 "LD IMM64",
1893 .u.insns_int = {
1894 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1895 BPF_MOV64_REG(R1, R0),
1896 BPF_MOV64_REG(R2, R1),
1897 BPF_MOV64_REG(R3, R2),
1898 BPF_MOV64_REG(R4, R3),
1899 BPF_MOV64_REG(R5, R4),
1900 BPF_MOV64_REG(R6, R5),
1901 BPF_MOV64_REG(R7, R6),
1902 BPF_MOV64_REG(R8, R7),
1903 BPF_MOV64_REG(R9, R8),
1904 BPF_LD_IMM64(R0, 0x0LL),
1905 BPF_LD_IMM64(R1, 0x0LL),
1906 BPF_LD_IMM64(R2, 0x0LL),
1907 BPF_LD_IMM64(R3, 0x0LL),
1908 BPF_LD_IMM64(R4, 0x0LL),
1909 BPF_LD_IMM64(R5, 0x0LL),
1910 BPF_LD_IMM64(R6, 0x0LL),
1911 BPF_LD_IMM64(R7, 0x0LL),
1912 BPF_LD_IMM64(R8, 0x0LL),
1913 BPF_LD_IMM64(R9, 0x0LL),
1914 BPF_ALU64_REG(BPF_ADD, R0, R0),
1915 BPF_ALU64_REG(BPF_ADD, R0, R1),
1916 BPF_ALU64_REG(BPF_ADD, R0, R2),
1917 BPF_ALU64_REG(BPF_ADD, R0, R3),
1918 BPF_ALU64_REG(BPF_ADD, R0, R4),
1919 BPF_ALU64_REG(BPF_ADD, R0, R5),
1920 BPF_ALU64_REG(BPF_ADD, R0, R6),
1921 BPF_ALU64_REG(BPF_ADD, R0, R7),
1922 BPF_ALU64_REG(BPF_ADD, R0, R8),
1923 BPF_ALU64_REG(BPF_ADD, R0, R9),
1924 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1925 BPF_EXIT_INSN(),
1926 },
1927 INTERNAL,
1928 { },
1929 { { 0, 0xfefe } }
1930 },
9def624a
AS		 1931 {
1932 "INT: ALU MIX",
ece80490 1933 .u.insns_int = {
9def624a
AS		 1934 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1935 BPF_ALU64_IMM(BPF_ADD, R0, -1),
1936 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1937 BPF_ALU64_IMM(BPF_XOR, R2, 3),
1938 BPF_ALU64_REG(BPF_DIV, R0, R2),
1939 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1940 BPF_EXIT_INSN(),
1941 BPF_ALU64_IMM(BPF_MOD, R0, 3),
1942 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1943 BPF_EXIT_INSN(),
1944 BPF_ALU64_IMM(BPF_MOV, R0, -1),
72b603ee
AS		 1945 BPF_EXIT_INSN(),
1946 },
1947 INTERNAL,
1948 { },
1949 { { 0, -1 } }
1950 },
1951 {
1952 "INT: shifts by register",
1953 .u.insns_int = {
1954 BPF_MOV64_IMM(R0, -1234),
1955 BPF_MOV64_IMM(R1, 1),
1956 BPF_ALU32_REG(BPF_RSH, R0, R1),
1957 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
1958 BPF_EXIT_INSN(),
1959 BPF_MOV64_IMM(R2, 1),
1960 BPF_ALU64_REG(BPF_LSH, R0, R2),
1961 BPF_MOV32_IMM(R4, -1234),
1962 BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
1963 BPF_EXIT_INSN(),
1964 BPF_ALU64_IMM(BPF_AND, R4, 63),
1965 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
1966 BPF_MOV64_IMM(R3, 47),
1967 BPF_ALU64_REG(BPF_ARSH, R0, R3),
1968 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
1969 BPF_EXIT_INSN(),
1970 BPF_MOV64_IMM(R2, 1),
1971 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
1972 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
1973 BPF_EXIT_INSN(),
1974 BPF_MOV64_IMM(R4, 4),
1975 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
1976 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
1977 BPF_EXIT_INSN(),
1978 BPF_MOV64_IMM(R4, 5),
1979 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
1980 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
1981 BPF_EXIT_INSN(),
1982 BPF_MOV64_IMM(R0, -1),
9def624a
AS		 1983 BPF_EXIT_INSN(),
1984 },
10f18e0b 1985 INTERNAL,
9def624a
AS		 1986 { },
1987 { { 0, -1 } }
1988 },
64a8946b
AS		 1989 {
1990 "INT: DIV + ABS",
ece80490 1991 .u.insns_int = {
64a8946b
AS		 1992 BPF_ALU64_REG(BPF_MOV, R6, R1),
1993 BPF_LD_ABS(BPF_B, 3),
1994 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1995 BPF_ALU32_REG(BPF_DIV, R0, R2),
1996 BPF_ALU64_REG(BPF_MOV, R8, R0),
1997 BPF_LD_ABS(BPF_B, 4),
1998 BPF_ALU64_REG(BPF_ADD, R8, R0),
1999 BPF_LD_IND(BPF_B, R8, -70),
2000 BPF_EXIT_INSN(),
2001 },
10f18e0b 2002 INTERNAL,
64a8946b
AS		 2003 { 10, 20, 30, 40, 50 },
2004 { { 4, 0 }, { 5, 10 } }
2005 },
9def624a
AS		 2006 {
2007 "INT: DIV by zero",
ece80490 2008 .u.insns_int = {
9def624a
AS		 2009 BPF_ALU64_REG(BPF_MOV, R6, R1),
2010 BPF_ALU64_IMM(BPF_MOV, R7, 0),
2011 BPF_LD_ABS(BPF_B, 3),
2012 BPF_ALU32_REG(BPF_DIV, R0, R7),
2013 BPF_EXIT_INSN(),
2014 },
10f18e0b 2015 INTERNAL,
9def624a
AS		 2016 { 10, 20, 30, 40, 50 },
2017 { { 3, 0 }, { 4, 0 } }
2018 },
64a8946b
AS		 2019 {
2020 "check: missing ret",
ece80490 2021 .u.insns = {
64a8946b
AS		 2022 BPF_STMT(BPF_LD | BPF_IMM, 1),
2023 },
10f18e0b 2024 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
64a8946b 2025 { },
f735fecf
YS		 2026 { },
2027 .fill_helper = NULL,
2028 .expected_errcode = -EINVAL,
64a8946b 2029 },
9def624a
AS		 2030 {
2031 "check: div_k_0",
ece80490 2032 .u.insns = {
9def624a
AS		 2033 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
2034 BPF_STMT(BPF_RET | BPF_K, 0)
2035 },
10f18e0b 2036 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a 2037 { },
f735fecf
YS		 2038 { },
2039 .fill_helper = NULL,
2040 .expected_errcode = -EINVAL,
9def624a
AS		 2041 },
2042 {
2043 "check: unknown insn",
ece80490 2044 .u.insns = {
9def624a
AS		 2045 /* seccomp insn, rejected in socket filter */
2046 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
2047 BPF_STMT(BPF_RET | BPF_K, 0)
2048 },
10f18e0b 2049 CLASSIC | FLAG_EXPECTED_FAIL,
9def624a 2050 { },
f735fecf
YS		 2051 { },
2052 .fill_helper = NULL,
2053 .expected_errcode = -EINVAL,
9def624a
AS		 2054 },
2055 {
2056 "check: out of range spill/fill",
ece80490 2057 .u.insns = {
9def624a
AS		 2058 BPF_STMT(BPF_STX, 16),
2059 BPF_STMT(BPF_RET | BPF_K, 0)
2060 },
10f18e0b 2061 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a 2062 { },
f735fecf
YS		 2063 { },
2064 .fill_helper = NULL,
2065 .expected_errcode = -EINVAL,
9def624a 2066 },
2e8a83c5
DB		 2067 {
2068 "JUMPS + HOLES",
2069 .u.insns = {
2070 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2071 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
2072 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2073 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2074 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2075 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2076 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2077 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2078 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2079 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2080 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2081 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2082 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2083 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2084 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2085 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
2086 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2087 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
2088 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2089 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2090 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2091 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2092 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2093 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2094 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2095 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2096 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2097 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2098 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2099 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2100 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2101 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2102 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2103 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2104 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
2105 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
2106 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2107 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2108 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2109 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2110 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2111 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2112 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2113 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2114 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2115 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2116 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2117 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2118 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2119 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2120 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2121 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2122 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
2123 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
2124 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2125 BPF_STMT(BPF_RET | BPF_A, 0),
2126 BPF_STMT(BPF_RET | BPF_A, 0),
2127 },
2128 CLASSIC,
ce25b68b
DB		 2129 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
2130 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
2131 0x08, 0x00,
2132 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
2133 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
2134 0xc0, 0xa8, 0x33, 0x01,
2135 0xc0, 0xa8, 0x33, 0x02,
2136 0xbb, 0xb6,
2137 0xa9, 0xfa,
2138 0x00, 0x14, 0x00, 0x00,
2139 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2140 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2141 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2142 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2143 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2144 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2145 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2146 0xcc, 0xcc, 0xcc, 0xcc },
2e8a83c5
DB		 2147 { { 88, 0x001b } }
2148 },
2149 {
2150 "check: RET X",
2151 .u.insns = {
2152 BPF_STMT(BPF_RET | BPF_X, 0),
2153 },
2154 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2155 { },
2156 { },
f735fecf
YS		 2157 .fill_helper = NULL,
2158 .expected_errcode = -EINVAL,
2e8a83c5
DB		 2159 },
2160 {
2161 "check: LDX + RET X",
2162 .u.insns = {
2163 BPF_STMT(BPF_LDX | BPF_IMM, 42),
2164 BPF_STMT(BPF_RET | BPF_X, 0),
2165 },
2166 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2167 { },
2168 { },
f735fecf
YS		 2169 .fill_helper = NULL,
2170 .expected_errcode = -EINVAL,
2e8a83c5 2171 },
108cc22a 2172 { /* Mainly checking JIT here. */
9fe13baa 2173 "M[]: alt STX + LDX",
108cc22a
DB		 2174 .u.insns = {
2175 BPF_STMT(BPF_LDX | BPF_IMM, 100),
2176 BPF_STMT(BPF_STX, 0),
2177 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2178 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2179 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2180 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2181 BPF_STMT(BPF_STX, 1),
2182 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2183 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2184 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2185 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2186 BPF_STMT(BPF_STX, 2),
2187 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2188 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2189 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2190 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2191 BPF_STMT(BPF_STX, 3),
2192 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2193 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2194 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2195 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2196 BPF_STMT(BPF_STX, 4),
2197 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2198 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2199 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2200 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2201 BPF_STMT(BPF_STX, 5),
2202 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2203 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2204 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2205 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2206 BPF_STMT(BPF_STX, 6),
2207 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2208 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2209 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2210 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2211 BPF_STMT(BPF_STX, 7),
2212 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2213 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2214 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2215 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2216 BPF_STMT(BPF_STX, 8),
2217 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2218 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2219 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2220 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2221 BPF_STMT(BPF_STX, 9),
2222 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2223 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2224 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2225 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2226 BPF_STMT(BPF_STX, 10),
2227 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2228 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2229 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2230 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2231 BPF_STMT(BPF_STX, 11),
2232 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2233 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2234 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2235 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2236 BPF_STMT(BPF_STX, 12),
2237 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2238 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2239 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2240 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2241 BPF_STMT(BPF_STX, 13),
2242 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2243 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2244 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2245 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2246 BPF_STMT(BPF_STX, 14),
2247 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2248 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2249 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2250 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2251 BPF_STMT(BPF_STX, 15),
2252 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2253 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2254 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2255 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2256 BPF_STMT(BPF_RET | BPF_A, 0),
2257 },
2258 CLASSIC | FLAG_NO_DATA,
2259 { },
2260 { { 0, 116 } },
2261 },
9fe13baa
DB		 2262 { /* Mainly checking JIT here. */
2263 "M[]: full STX + full LDX",
2264 .u.insns = {
2265 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
2266 BPF_STMT(BPF_STX, 0),
2267 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
2268 BPF_STMT(BPF_STX, 1),
2269 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
2270 BPF_STMT(BPF_STX, 2),
2271 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
2272 BPF_STMT(BPF_STX, 3),
2273 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
2274 BPF_STMT(BPF_STX, 4),
2275 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
2276 BPF_STMT(BPF_STX, 5),
2277 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
2278 BPF_STMT(BPF_STX, 6),
2279 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
2280 BPF_STMT(BPF_STX, 7),
2281 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
2282 BPF_STMT(BPF_STX, 8),
2283 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
2284 BPF_STMT(BPF_STX, 9),
2285 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
2286 BPF_STMT(BPF_STX, 10),
2287 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
2288 BPF_STMT(BPF_STX, 11),
2289 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
2290 BPF_STMT(BPF_STX, 12),
2291 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
2292 BPF_STMT(BPF_STX, 13),
2293 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
2294 BPF_STMT(BPF_STX, 14),
2295 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
2296 BPF_STMT(BPF_STX, 15),
2297 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2298 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2299 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2300 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2301 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2302 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2303 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2304 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2305 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2306 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2307 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2308 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2309 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2310 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2311 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2312 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2313 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2314 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2315 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2316 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2317 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2318 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2319 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2320 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2321 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2322 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2323 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2324 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2325 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2326 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2327 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2328 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2329 BPF_STMT(BPF_RET | BPF_A, 0),
2330 },
2331 CLASSIC | FLAG_NO_DATA,
2332 { },
2333 { { 0, 0x2a5a5e5 } },
2334 },
d50bc157
DB		 2335 {
2336 "check: SKF_AD_MAX",
2337 .u.insns = {
2338 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2339 SKF_AD_OFF + SKF_AD_MAX),
2340 BPF_STMT(BPF_RET | BPF_A, 0),
2341 },
2342 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2343 { },
2344 { },
f735fecf
YS		 2345 .fill_helper = NULL,
2346 .expected_errcode = -EINVAL,
d50bc157
DB		 2347 },
2348 { /* Passes checker but fails during runtime. */
2349 "LD [SKF_AD_OFF-1]",
2350 .u.insns = {
2351 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2352 SKF_AD_OFF - 1),
2353 BPF_STMT(BPF_RET | BPF_K, 1),
2354 },
2355 CLASSIC,
2356 { },
2357 { { 1, 0 } },
2358 },
02ab695b
AS		 2359 {
2360 "load 64-bit immediate",
2361 .u.insns_int = {
25ee7327 2362 BPF_LD_IMM64(R1, 0x567800001234LL),
02ab695b
AS		 2363 BPF_MOV64_REG(R2, R1),
2364 BPF_MOV64_REG(R3, R2),
2365 BPF_ALU64_IMM(BPF_RSH, R2, 32),
2366 BPF_ALU64_IMM(BPF_LSH, R3, 32),
2367 BPF_ALU64_IMM(BPF_RSH, R3, 32),
2368 BPF_ALU64_IMM(BPF_MOV, R0, 0),
2369 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
2370 BPF_EXIT_INSN(),
2371 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2372 BPF_EXIT_INSN(),
986ccfdb
XW		 2373 BPF_LD_IMM64(R0, 0x1ffffffffLL),
2374 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
02ab695b
AS		 2375 BPF_EXIT_INSN(),
2376 },
2377 INTERNAL,
2378 { },
2379 { { 0, 1 } }
2380 },
e21ab36a
AS		 2381 {
2382 "nmap reduced",
2383 .u.insns_int = {
2384 BPF_MOV64_REG(R6, R1),
2385 BPF_LD_ABS(BPF_H, 12),
2386 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 28),
2387 BPF_LD_ABS(BPF_H, 12),
2388 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 26),
2389 BPF_MOV32_IMM(R0, 18),
2390 BPF_STX_MEM(BPF_W, R10, R0, -64),
2391 BPF_LDX_MEM(BPF_W, R7, R10, -64),
2392 BPF_LD_IND(BPF_W, R7, 14),
2393 BPF_STX_MEM(BPF_W, R10, R0, -60),
2394 BPF_MOV32_IMM(R0, 280971478),
2395 BPF_STX_MEM(BPF_W, R10, R0, -56),
2396 BPF_LDX_MEM(BPF_W, R7, R10, -56),
2397 BPF_LDX_MEM(BPF_W, R0, R10, -60),
2398 BPF_ALU32_REG(BPF_SUB, R0, R7),
2399 BPF_JMP_IMM(BPF_JNE, R0, 0, 15),
2400 BPF_LD_ABS(BPF_H, 12),
2401 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 13),
2402 BPF_MOV32_IMM(R0, 22),
2403 BPF_STX_MEM(BPF_W, R10, R0, -56),
2404 BPF_LDX_MEM(BPF_W, R7, R10, -56),
2405 BPF_LD_IND(BPF_H, R7, 14),
2406 BPF_STX_MEM(BPF_W, R10, R0, -52),
2407 BPF_MOV32_IMM(R0, 17366),
2408 BPF_STX_MEM(BPF_W, R10, R0, -48),
2409 BPF_LDX_MEM(BPF_W, R7, R10, -48),
2410 BPF_LDX_MEM(BPF_W, R0, R10, -52),
2411 BPF_ALU32_REG(BPF_SUB, R0, R7),
2412 BPF_JMP_IMM(BPF_JNE, R0, 0, 2),
2413 BPF_MOV32_IMM(R0, 256),
2414 BPF_EXIT_INSN(),
2415 BPF_MOV32_IMM(R0, 0),
2416 BPF_EXIT_INSN(),
2417 },
2418 INTERNAL,
2419 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x06, 0, 0,
2420 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2421 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6},
105c0361
AS		 2422 { { 38, 256 } },
2423 .stack_depth = 64,
e21ab36a 2424 },
cffc642d
MH		 2425 /* BPF_ALU | BPF_MOV | BPF_X */
2426 {
2427 "ALU_MOV_X: dst = 2",
2428 .u.insns_int = {
2429 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2430 BPF_ALU32_REG(BPF_MOV, R0, R1),
2431 BPF_EXIT_INSN(),
2432 },
2433 INTERNAL,
2434 { },
2435 { { 0, 2 } },
2436 },
2437 {
2438 "ALU_MOV_X: dst = 4294967295",
2439 .u.insns_int = {
56cbaa45 2440 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 2441 BPF_ALU32_REG(BPF_MOV, R0, R1),
2442 BPF_EXIT_INSN(),
2443 },
2444 INTERNAL,
2445 { },
56cbaa45 2446 { { 0, 4294967295U } },
cffc642d
MH		 2447 },
2448 {
2449 "ALU64_MOV_X: dst = 2",
2450 .u.insns_int = {
2451 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2452 BPF_ALU64_REG(BPF_MOV, R0, R1),
2453 BPF_EXIT_INSN(),
2454 },
2455 INTERNAL,
2456 { },
2457 { { 0, 2 } },
2458 },
2459 {
2460 "ALU64_MOV_X: dst = 4294967295",
2461 .u.insns_int = {
56cbaa45 2462 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 2463 BPF_ALU64_REG(BPF_MOV, R0, R1),
2464 BPF_EXIT_INSN(),
2465 },
2466 INTERNAL,
2467 { },
56cbaa45 2468 { { 0, 4294967295U } },
cffc642d
MH		 2469 },
2470 /* BPF_ALU | BPF_MOV | BPF_K */
2471 {
2472 "ALU_MOV_K: dst = 2",
2473 .u.insns_int = {
2474 BPF_ALU32_IMM(BPF_MOV, R0, 2),
2475 BPF_EXIT_INSN(),
2476 },
2477 INTERNAL,
2478 { },
2479 { { 0, 2 } },
2480 },
2481 {
2482 "ALU_MOV_K: dst = 4294967295",
2483 .u.insns_int = {
56cbaa45 2484 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
cffc642d
MH		 2485 BPF_EXIT_INSN(),
2486 },
2487 INTERNAL,
2488 { },
56cbaa45 2489 { { 0, 4294967295U } },
cffc642d
MH		 2490 },
2491 {
2492 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2493 .u.insns_int = {
56cbaa45
MH		 2494 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2495 BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
cffc642d
MH		 2496 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
2497 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2498 BPF_MOV32_IMM(R0, 2),
2499 BPF_EXIT_INSN(),
2500 BPF_MOV32_IMM(R0, 1),
2501 BPF_EXIT_INSN(),
2502 },
2503 INTERNAL,
2504 { },
2505 { { 0, 0x1 } },
2506 },
2507 {
2508 "ALU64_MOV_K: dst = 2",
2509 .u.insns_int = {
2510 BPF_ALU64_IMM(BPF_MOV, R0, 2),
2511 BPF_EXIT_INSN(),
2512 },
2513 INTERNAL,
2514 { },
2515 { { 0, 2 } },
2516 },
2517 {
2518 "ALU64_MOV_K: dst = 2147483647",
2519 .u.insns_int = {
2520 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2521 BPF_EXIT_INSN(),
2522 },
2523 INTERNAL,
2524 { },
2525 { { 0, 2147483647 } },
2526 },
2527 {
2528 "ALU64_OR_K: dst = 0x0",
2529 .u.insns_int = {
56cbaa45 2530 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
cffc642d
MH		 2531 BPF_LD_IMM64(R3, 0x0),
2532 BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
2533 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2534 BPF_MOV32_IMM(R0, 2),
2535 BPF_EXIT_INSN(),
2536 BPF_MOV32_IMM(R0, 1),
2537 BPF_EXIT_INSN(),
2538 },
2539 INTERNAL,
2540 { },
2541 { { 0, 0x1 } },
2542 },
2543 {
2544 "ALU64_MOV_K: dst = -1",
2545 .u.insns_int = {
56cbaa45
MH		 2546 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2547 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 2548 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
2549 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2550 BPF_MOV32_IMM(R0, 2),
2551 BPF_EXIT_INSN(),
2552 BPF_MOV32_IMM(R0, 1),
2553 BPF_EXIT_INSN(),
2554 },
2555 INTERNAL,
2556 { },
2557 { { 0, 0x1 } },
2558 },
2559 /* BPF_ALU | BPF_ADD | BPF_X */
2560 {
2561 "ALU_ADD_X: 1 + 2 = 3",
2562 .u.insns_int = {
2563 BPF_LD_IMM64(R0, 1),
2564 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2565 BPF_ALU32_REG(BPF_ADD, R0, R1),
2566 BPF_EXIT_INSN(),
2567 },
2568 INTERNAL,
2569 { },
2570 { { 0, 3 } },
2571 },
2572 {
2573 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2574 .u.insns_int = {
2575 BPF_LD_IMM64(R0, 1),
56cbaa45 2576 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 2577 BPF_ALU32_REG(BPF_ADD, R0, R1),
2578 BPF_EXIT_INSN(),
2579 },
2580 INTERNAL,
2581 { },
56cbaa45 2582 { { 0, 4294967295U } },
cffc642d 2583 },
b64b50ea
NR		 2584 {
2585 "ALU_ADD_X: 2 + 4294967294 = 0",
2586 .u.insns_int = {
2587 BPF_LD_IMM64(R0, 2),
2588 BPF_LD_IMM64(R1, 4294967294U),
2589 BPF_ALU32_REG(BPF_ADD, R0, R1),
2590 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2591 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2592 BPF_EXIT_INSN(),
2593 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2594 BPF_EXIT_INSN(),
2595 },
2596 INTERNAL,
2597 { },
2598 { { 0, 1 } },
2599 },
cffc642d
MH		 2600 {
2601 "ALU64_ADD_X: 1 + 2 = 3",
2602 .u.insns_int = {
2603 BPF_LD_IMM64(R0, 1),
2604 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2605 BPF_ALU64_REG(BPF_ADD, R0, R1),
2606 BPF_EXIT_INSN(),
2607 },
2608 INTERNAL,
2609 { },
2610 { { 0, 3 } },
2611 },
2612 {
2613 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2614 .u.insns_int = {
2615 BPF_LD_IMM64(R0, 1),
56cbaa45 2616 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 2617 BPF_ALU64_REG(BPF_ADD, R0, R1),
2618 BPF_EXIT_INSN(),
2619 },
2620 INTERNAL,
2621 { },
56cbaa45 2622 { { 0, 4294967295U } },
cffc642d 2623 },
b64b50ea
NR		 2624 {
2625 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
2626 .u.insns_int = {
2627 BPF_LD_IMM64(R0, 2),
2628 BPF_LD_IMM64(R1, 4294967294U),
2629 BPF_LD_IMM64(R2, 4294967296ULL),
2630 BPF_ALU64_REG(BPF_ADD, R0, R1),
2631 BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
2632 BPF_MOV32_IMM(R0, 0),
2633 BPF_EXIT_INSN(),
2634 BPF_MOV32_IMM(R0, 1),
2635 BPF_EXIT_INSN(),
2636 },
2637 INTERNAL,
2638 { },
2639 { { 0, 1 } },
2640 },
cffc642d
MH		 2641 /* BPF_ALU | BPF_ADD | BPF_K */
2642 {
2643 "ALU_ADD_K: 1 + 2 = 3",
2644 .u.insns_int = {
2645 BPF_LD_IMM64(R0, 1),
2646 BPF_ALU32_IMM(BPF_ADD, R0, 2),
2647 BPF_EXIT_INSN(),
2648 },
2649 INTERNAL,
2650 { },
2651 { { 0, 3 } },
2652 },
2653 {
2654 "ALU_ADD_K: 3 + 0 = 3",
2655 .u.insns_int = {
2656 BPF_LD_IMM64(R0, 3),
2657 BPF_ALU32_IMM(BPF_ADD, R0, 0),
2658 BPF_EXIT_INSN(),
2659 },
2660 INTERNAL,
2661 { },
2662 { { 0, 3 } },
2663 },
2664 {
2665 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2666 .u.insns_int = {
2667 BPF_LD_IMM64(R0, 1),
56cbaa45 2668 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
cffc642d
MH		 2669 BPF_EXIT_INSN(),
2670 },
2671 INTERNAL,
2672 { },
56cbaa45 2673 { { 0, 4294967295U } },
cffc642d 2674 },
b64b50ea
NR		 2675 {
2676 "ALU_ADD_K: 4294967294 + 2 = 0",
2677 .u.insns_int = {
2678 BPF_LD_IMM64(R0, 4294967294U),
2679 BPF_ALU32_IMM(BPF_ADD, R0, 2),
2680 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2681 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2682 BPF_EXIT_INSN(),
2683 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2684 BPF_EXIT_INSN(),
2685 },
2686 INTERNAL,
2687 { },
2688 { { 0, 1 } },
2689 },
cffc642d
MH		 2690 {
2691 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2692 .u.insns_int = {
2693 BPF_LD_IMM64(R2, 0x0),
2694 BPF_LD_IMM64(R3, 0x00000000ffffffff),
2695 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
2696 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2697 BPF_MOV32_IMM(R0, 2),
2698 BPF_EXIT_INSN(),
2699 BPF_MOV32_IMM(R0, 1),
2700 BPF_EXIT_INSN(),
2701 },
2702 INTERNAL,
2703 { },
2704 { { 0, 0x1 } },
2705 },
9c94f6c8
NR		 2706 {
2707 "ALU_ADD_K: 0 + 0xffff = 0xffff",
2708 .u.insns_int = {
2709 BPF_LD_IMM64(R2, 0x0),
2710 BPF_LD_IMM64(R3, 0xffff),
2711 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
2712 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2713 BPF_MOV32_IMM(R0, 2),
2714 BPF_EXIT_INSN(),
2715 BPF_MOV32_IMM(R0, 1),
2716 BPF_EXIT_INSN(),
2717 },
2718 INTERNAL,
2719 { },
2720 { { 0, 0x1 } },
2721 },
2722 {
2723 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2724 .u.insns_int = {
2725 BPF_LD_IMM64(R2, 0x0),
2726 BPF_LD_IMM64(R3, 0x7fffffff),
2727 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
2728 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2729 BPF_MOV32_IMM(R0, 2),
2730 BPF_EXIT_INSN(),
2731 BPF_MOV32_IMM(R0, 1),
2732 BPF_EXIT_INSN(),
2733 },
2734 INTERNAL,
2735 { },
2736 { { 0, 0x1 } },
2737 },
2738 {
2739 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
2740 .u.insns_int = {
2741 BPF_LD_IMM64(R2, 0x0),
2742 BPF_LD_IMM64(R3, 0x80000000),
2743 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
2744 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2745 BPF_MOV32_IMM(R0, 2),
2746 BPF_EXIT_INSN(),
2747 BPF_MOV32_IMM(R0, 1),
2748 BPF_EXIT_INSN(),
2749 },
2750 INTERNAL,
2751 { },
2752 { { 0, 0x1 } },
2753 },
2754 {
2755 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
2756 .u.insns_int = {
2757 BPF_LD_IMM64(R2, 0x0),
2758 BPF_LD_IMM64(R3, 0x80008000),
2759 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
2760 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2761 BPF_MOV32_IMM(R0, 2),
2762 BPF_EXIT_INSN(),
2763 BPF_MOV32_IMM(R0, 1),
2764 BPF_EXIT_INSN(),
2765 },
2766 INTERNAL,
2767 { },
2768 { { 0, 0x1 } },
2769 },
cffc642d
MH		 2770 {
2771 "ALU64_ADD_K: 1 + 2 = 3",
2772 .u.insns_int = {
2773 BPF_LD_IMM64(R0, 1),
2774 BPF_ALU64_IMM(BPF_ADD, R0, 2),
2775 BPF_EXIT_INSN(),
2776 },
2777 INTERNAL,
2778 { },
2779 { { 0, 3 } },
2780 },
2781 {
2782 "ALU64_ADD_K: 3 + 0 = 3",
2783 .u.insns_int = {
2784 BPF_LD_IMM64(R0, 3),
2785 BPF_ALU64_IMM(BPF_ADD, R0, 0),
2786 BPF_EXIT_INSN(),
2787 },
2788 INTERNAL,
2789 { },
2790 { { 0, 3 } },
2791 },
2792 {
2793 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2794 .u.insns_int = {
2795 BPF_LD_IMM64(R0, 1),
2796 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2797 BPF_EXIT_INSN(),
2798 },
2799 INTERNAL,
2800 { },
2801 { { 0, 2147483647 } },
2802 },
b64b50ea
NR		 2803 {
2804 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
2805 .u.insns_int = {
2806 BPF_LD_IMM64(R0, 4294967294U),
2807 BPF_LD_IMM64(R1, 4294967296ULL),
2808 BPF_ALU64_IMM(BPF_ADD, R0, 2),
2809 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
2810 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2811 BPF_EXIT_INSN(),
2812 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2813 BPF_EXIT_INSN(),
2814 },
2815 INTERNAL,
2816 { },
2817 { { 0, 1 } },
2818 },
cffc642d
MH		 2819 {
2820 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2821 .u.insns_int = {
2822 BPF_LD_IMM64(R0, 2147483646),
2823 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2824 BPF_EXIT_INSN(),
2825 },
2826 INTERNAL,
2827 { },
2828 { { 0, -1 } },
2829 },
2830 {
2831 "ALU64_ADD_K: 1 + 0 = 1",
2832 .u.insns_int = {
2833 BPF_LD_IMM64(R2, 0x1),
2834 BPF_LD_IMM64(R3, 0x1),
2835 BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
2836 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2837 BPF_MOV32_IMM(R0, 2),
2838 BPF_EXIT_INSN(),
2839 BPF_MOV32_IMM(R0, 1),
2840 BPF_EXIT_INSN(),
2841 },
2842 INTERNAL,
2843 { },
2844 { { 0, 0x1 } },
2845 },
2846 {
2847 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2848 .u.insns_int = {
2849 BPF_LD_IMM64(R2, 0x0),
56cbaa45 2850 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 2851 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
2852 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2853 BPF_MOV32_IMM(R0, 2),
2854 BPF_EXIT_INSN(),
2855 BPF_MOV32_IMM(R0, 1),
2856 BPF_EXIT_INSN(),
2857 },
2858 INTERNAL,
2859 { },
2860 { { 0, 0x1 } },
2861 },
9c94f6c8
NR		 2862 {
2863 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
2864 .u.insns_int = {
2865 BPF_LD_IMM64(R2, 0x0),
2866 BPF_LD_IMM64(R3, 0xffff),
2867 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
2868 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2869 BPF_MOV32_IMM(R0, 2),
2870 BPF_EXIT_INSN(),
2871 BPF_MOV32_IMM(R0, 1),
2872 BPF_EXIT_INSN(),
2873 },
2874 INTERNAL,
2875 { },
2876 { { 0, 0x1 } },
2877 },
2878 {
2879 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2880 .u.insns_int = {
2881 BPF_LD_IMM64(R2, 0x0),
2882 BPF_LD_IMM64(R3, 0x7fffffff),
2883 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
2884 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2885 BPF_MOV32_IMM(R0, 2),
2886 BPF_EXIT_INSN(),
2887 BPF_MOV32_IMM(R0, 1),
2888 BPF_EXIT_INSN(),
2889 },
2890 INTERNAL,
2891 { },
2892 { { 0, 0x1 } },
2893 },
2894 {
2895 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
2896 .u.insns_int = {
2897 BPF_LD_IMM64(R2, 0x0),
2898 BPF_LD_IMM64(R3, 0xffffffff80000000LL),
2899 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
2900 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2901 BPF_MOV32_IMM(R0, 2),
2902 BPF_EXIT_INSN(),
2903 BPF_MOV32_IMM(R0, 1),
2904 BPF_EXIT_INSN(),
2905 },
2906 INTERNAL,
2907 { },
2908 { { 0, 0x1 } },
2909 },
2910 {
2911 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
2912 .u.insns_int = {
2913 BPF_LD_IMM64(R2, 0x0),
2914 BPF_LD_IMM64(R3, 0xffffffff80008000LL),
2915 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
2916 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2917 BPF_MOV32_IMM(R0, 2),
2918 BPF_EXIT_INSN(),
2919 BPF_MOV32_IMM(R0, 1),
2920 BPF_EXIT_INSN(),
2921 },
2922 INTERNAL,
2923 { },
2924 { { 0, 0x1 } },
2925 },
cffc642d
MH		 2926 /* BPF_ALU | BPF_SUB | BPF_X */
2927 {
2928 "ALU_SUB_X: 3 - 1 = 2",
2929 .u.insns_int = {
2930 BPF_LD_IMM64(R0, 3),
2931 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2932 BPF_ALU32_REG(BPF_SUB, R0, R1),
2933 BPF_EXIT_INSN(),
2934 },
2935 INTERNAL,
2936 { },
2937 { { 0, 2 } },
2938 },
2939 {
2940 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
2941 .u.insns_int = {
56cbaa45
MH		 2942 BPF_LD_IMM64(R0, 4294967295U),
2943 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 2944 BPF_ALU32_REG(BPF_SUB, R0, R1),
2945 BPF_EXIT_INSN(),
2946 },
2947 INTERNAL,
2948 { },
2949 { { 0, 1 } },
2950 },
2951 {
2952 "ALU64_SUB_X: 3 - 1 = 2",
2953 .u.insns_int = {
2954 BPF_LD_IMM64(R0, 3),
2955 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2956 BPF_ALU64_REG(BPF_SUB, R0, R1),
2957 BPF_EXIT_INSN(),
2958 },
2959 INTERNAL,
2960 { },
2961 { { 0, 2 } },
2962 },
2963 {
2964 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
2965 .u.insns_int = {
56cbaa45
MH		 2966 BPF_LD_IMM64(R0, 4294967295U),
2967 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 2968 BPF_ALU64_REG(BPF_SUB, R0, R1),
2969 BPF_EXIT_INSN(),
2970 },
2971 INTERNAL,
2972 { },
2973 { { 0, 1 } },
2974 },
2975 /* BPF_ALU | BPF_SUB | BPF_K */
2976 {
2977 "ALU_SUB_K: 3 - 1 = 2",
2978 .u.insns_int = {
2979 BPF_LD_IMM64(R0, 3),
2980 BPF_ALU32_IMM(BPF_SUB, R0, 1),
2981 BPF_EXIT_INSN(),
2982 },
2983 INTERNAL,
2984 { },
2985 { { 0, 2 } },
2986 },
2987 {
2988 "ALU_SUB_K: 3 - 0 = 3",
2989 .u.insns_int = {
2990 BPF_LD_IMM64(R0, 3),
2991 BPF_ALU32_IMM(BPF_SUB, R0, 0),
2992 BPF_EXIT_INSN(),
2993 },
2994 INTERNAL,
2995 { },
2996 { { 0, 3 } },
2997 },
2998 {
2999 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
3000 .u.insns_int = {
56cbaa45
MH		 3001 BPF_LD_IMM64(R0, 4294967295U),
3002 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
cffc642d
MH		 3003 BPF_EXIT_INSN(),
3004 },
3005 INTERNAL,
3006 { },
3007 { { 0, 1 } },
3008 },
3009 {
3010 "ALU64_SUB_K: 3 - 1 = 2",
3011 .u.insns_int = {
3012 BPF_LD_IMM64(R0, 3),
3013 BPF_ALU64_IMM(BPF_SUB, R0, 1),
3014 BPF_EXIT_INSN(),
3015 },
3016 INTERNAL,
3017 { },
3018 { { 0, 2 } },
3019 },
3020 {
3021 "ALU64_SUB_K: 3 - 0 = 3",
3022 .u.insns_int = {
3023 BPF_LD_IMM64(R0, 3),
3024 BPF_ALU64_IMM(BPF_SUB, R0, 0),
3025 BPF_EXIT_INSN(),
3026 },
3027 INTERNAL,
3028 { },
3029 { { 0, 3 } },
3030 },
3031 {
3032 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
3033 .u.insns_int = {
56cbaa45
MH		 3034 BPF_LD_IMM64(R0, 4294967294U),
3035 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
cffc642d
MH		 3036 BPF_EXIT_INSN(),
3037 },
3038 INTERNAL,
3039 { },
3040 { { 0, -1 } },
3041 },
3042 {
3043 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
3044 .u.insns_int = {
3045 BPF_LD_IMM64(R0, 2147483646),
3046 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
3047 BPF_EXIT_INSN(),
3048 },
3049 INTERNAL,
3050 { },
3051 { { 0, -1 } },
3052 },
3053 /* BPF_ALU | BPF_MUL | BPF_X */
3054 {
3055 "ALU_MUL_X: 2 * 3 = 6",
3056 .u.insns_int = {
3057 BPF_LD_IMM64(R0, 2),
3058 BPF_ALU32_IMM(BPF_MOV, R1, 3),
3059 BPF_ALU32_REG(BPF_MUL, R0, R1),
3060 BPF_EXIT_INSN(),
3061 },
3062 INTERNAL,
3063 { },
3064 { { 0, 6 } },
3065 },
3066 {
3067 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3068 .u.insns_int = {
3069 BPF_LD_IMM64(R0, 2),
3070 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
3071 BPF_ALU32_REG(BPF_MUL, R0, R1),
3072 BPF_EXIT_INSN(),
3073 },
3074 INTERNAL,
3075 { },
3076 { { 0, 0xFFFFFFF0 } },
3077 },
3078 {
3079 "ALU_MUL_X: -1 * -1 = 1",
3080 .u.insns_int = {
3081 BPF_LD_IMM64(R0, -1),
3082 BPF_ALU32_IMM(BPF_MOV, R1, -1),
3083 BPF_ALU32_REG(BPF_MUL, R0, R1),
3084 BPF_EXIT_INSN(),
3085 },
3086 INTERNAL,
3087 { },
3088 { { 0, 1 } },
3089 },
3090 {
3091 "ALU64_MUL_X: 2 * 3 = 6",
3092 .u.insns_int = {
3093 BPF_LD_IMM64(R0, 2),
3094 BPF_ALU32_IMM(BPF_MOV, R1, 3),
3095 BPF_ALU64_REG(BPF_MUL, R0, R1),
3096 BPF_EXIT_INSN(),
3097 },
3098 INTERNAL,
3099 { },
3100 { { 0, 6 } },
3101 },
3102 {
3103 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
3104 .u.insns_int = {
3105 BPF_LD_IMM64(R0, 1),
3106 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3107 BPF_ALU64_REG(BPF_MUL, R0, R1),
3108 BPF_EXIT_INSN(),
3109 },
3110 INTERNAL,
3111 { },
3112 { { 0, 2147483647 } },
3113 },
3114 /* BPF_ALU | BPF_MUL | BPF_K */
3115 {
3116 "ALU_MUL_K: 2 * 3 = 6",
3117 .u.insns_int = {
3118 BPF_LD_IMM64(R0, 2),
3119 BPF_ALU32_IMM(BPF_MUL, R0, 3),
3120 BPF_EXIT_INSN(),
3121 },
3122 INTERNAL,
3123 { },
3124 { { 0, 6 } },
3125 },
3126 {
3127 "ALU_MUL_K: 3 * 1 = 3",
3128 .u.insns_int = {
3129 BPF_LD_IMM64(R0, 3),
3130 BPF_ALU32_IMM(BPF_MUL, R0, 1),
3131 BPF_EXIT_INSN(),
3132 },
3133 INTERNAL,
3134 { },
3135 { { 0, 3 } },
3136 },
3137 {
3138 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3139 .u.insns_int = {
3140 BPF_LD_IMM64(R0, 2),
3141 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
3142 BPF_EXIT_INSN(),
3143 },
3144 INTERNAL,
3145 { },
3146 { { 0, 0xFFFFFFF0 } },
3147 },
3148 {
3149 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
3150 .u.insns_int = {
3151 BPF_LD_IMM64(R2, 0x1),
3152 BPF_LD_IMM64(R3, 0x00000000ffffffff),
3153 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
3154 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3155 BPF_MOV32_IMM(R0, 2),
3156 BPF_EXIT_INSN(),
3157 BPF_MOV32_IMM(R0, 1),
3158 BPF_EXIT_INSN(),
3159 },
3160 INTERNAL,
3161 { },
3162 { { 0, 0x1 } },
3163 },
3164 {
3165 "ALU64_MUL_K: 2 * 3 = 6",
3166 .u.insns_int = {
3167 BPF_LD_IMM64(R0, 2),
3168 BPF_ALU64_IMM(BPF_MUL, R0, 3),
3169 BPF_EXIT_INSN(),
3170 },
3171 INTERNAL,
3172 { },
3173 { { 0, 6 } },
3174 },
3175 {
3176 "ALU64_MUL_K: 3 * 1 = 3",
3177 .u.insns_int = {
3178 BPF_LD_IMM64(R0, 3),
3179 BPF_ALU64_IMM(BPF_MUL, R0, 1),
3180 BPF_EXIT_INSN(),
3181 },
3182 INTERNAL,
3183 { },
3184 { { 0, 3 } },
3185 },
3186 {
3187 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
3188 .u.insns_int = {
3189 BPF_LD_IMM64(R0, 1),
3190 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
3191 BPF_EXIT_INSN(),
3192 },
3193 INTERNAL,
3194 { },
3195 { { 0, 2147483647 } },
3196 },
3197 {
3198 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
3199 .u.insns_int = {
3200 BPF_LD_IMM64(R0, 1),
3201 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
3202 BPF_EXIT_INSN(),
3203 },
3204 INTERNAL,
3205 { },
3206 { { 0, -2147483647 } },
3207 },
3208 {
3209 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
3210 .u.insns_int = {
3211 BPF_LD_IMM64(R2, 0x1),
56cbaa45 3212 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3213 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
3214 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3215 BPF_MOV32_IMM(R0, 2),
3216 BPF_EXIT_INSN(),
3217 BPF_MOV32_IMM(R0, 1),
3218 BPF_EXIT_INSN(),
3219 },
3220 INTERNAL,
3221 { },
3222 { { 0, 0x1 } },
3223 },
3224 /* BPF_ALU | BPF_DIV | BPF_X */
3225 {
3226 "ALU_DIV_X: 6 / 2 = 3",
3227 .u.insns_int = {
3228 BPF_LD_IMM64(R0, 6),
3229 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3230 BPF_ALU32_REG(BPF_DIV, R0, R1),
3231 BPF_EXIT_INSN(),
3232 },
3233 INTERNAL,
3234 { },
3235 { { 0, 3 } },
3236 },
3237 {
3238 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
3239 .u.insns_int = {
56cbaa45
MH		 3240 BPF_LD_IMM64(R0, 4294967295U),
3241 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 3242 BPF_ALU32_REG(BPF_DIV, R0, R1),
3243 BPF_EXIT_INSN(),
3244 },
3245 INTERNAL,
3246 { },
3247 { { 0, 1 } },
3248 },
3249 {
3250 "ALU64_DIV_X: 6 / 2 = 3",
3251 .u.insns_int = {
3252 BPF_LD_IMM64(R0, 6),
3253 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3254 BPF_ALU64_REG(BPF_DIV, R0, R1),
3255 BPF_EXIT_INSN(),
3256 },
3257 INTERNAL,
3258 { },
3259 { { 0, 3 } },
3260 },
3261 {
3262 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
3263 .u.insns_int = {
3264 BPF_LD_IMM64(R0, 2147483647),
3265 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3266 BPF_ALU64_REG(BPF_DIV, R0, R1),
3267 BPF_EXIT_INSN(),
3268 },
3269 INTERNAL,
3270 { },
3271 { { 0, 1 } },
3272 },
3273 {
3274 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3275 .u.insns_int = {
56cbaa45
MH		 3276 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3277 BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
3278 BPF_LD_IMM64(R3, 0x0000000000000001LL),
cffc642d
MH		 3279 BPF_ALU64_REG(BPF_DIV, R2, R4),
3280 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3281 BPF_MOV32_IMM(R0, 2),
3282 BPF_EXIT_INSN(),
3283 BPF_MOV32_IMM(R0, 1),
3284 BPF_EXIT_INSN(),
3285 },
3286 INTERNAL,
3287 { },
3288 { { 0, 0x1 } },
3289 },
3290 /* BPF_ALU | BPF_DIV | BPF_K */
3291 {
3292 "ALU_DIV_K: 6 / 2 = 3",
3293 .u.insns_int = {
3294 BPF_LD_IMM64(R0, 6),
3295 BPF_ALU32_IMM(BPF_DIV, R0, 2),
3296 BPF_EXIT_INSN(),
3297 },
3298 INTERNAL,
3299 { },
3300 { { 0, 3 } },
3301 },
3302 {
3303 "ALU_DIV_K: 3 / 1 = 3",
3304 .u.insns_int = {
3305 BPF_LD_IMM64(R0, 3),
3306 BPF_ALU32_IMM(BPF_DIV, R0, 1),
3307 BPF_EXIT_INSN(),
3308 },
3309 INTERNAL,
3310 { },
3311 { { 0, 3 } },
3312 },
3313 {
3314 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
3315 .u.insns_int = {
56cbaa45
MH		 3316 BPF_LD_IMM64(R0, 4294967295U),
3317 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
cffc642d
MH		 3318 BPF_EXIT_INSN(),
3319 },
3320 INTERNAL,
3321 { },
3322 { { 0, 1 } },
3323 },
3324 {
3325 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
3326 .u.insns_int = {
56cbaa45 3327 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
cffc642d
MH		 3328 BPF_LD_IMM64(R3, 0x1UL),
3329 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
3330 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3331 BPF_MOV32_IMM(R0, 2),
3332 BPF_EXIT_INSN(),
3333 BPF_MOV32_IMM(R0, 1),
3334 BPF_EXIT_INSN(),
3335 },
3336 INTERNAL,
3337 { },
3338 { { 0, 0x1 } },
3339 },
3340 {
3341 "ALU64_DIV_K: 6 / 2 = 3",
3342 .u.insns_int = {
3343 BPF_LD_IMM64(R0, 6),
3344 BPF_ALU64_IMM(BPF_DIV, R0, 2),
3345 BPF_EXIT_INSN(),
3346 },
3347 INTERNAL,
3348 { },
3349 { { 0, 3 } },
3350 },
3351 {
3352 "ALU64_DIV_K: 3 / 1 = 3",
3353 .u.insns_int = {
3354 BPF_LD_IMM64(R0, 3),
3355 BPF_ALU64_IMM(BPF_DIV, R0, 1),
3356 BPF_EXIT_INSN(),
3357 },
3358 INTERNAL,
3359 { },
3360 { { 0, 3 } },
3361 },
3362 {
3363 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3364 .u.insns_int = {
3365 BPF_LD_IMM64(R0, 2147483647),
3366 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
3367 BPF_EXIT_INSN(),
3368 },
3369 INTERNAL,
3370 { },
3371 { { 0, 1 } },
3372 },
3373 {
3374 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3375 .u.insns_int = {
56cbaa45
MH		 3376 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3377 BPF_LD_IMM64(R3, 0x0000000000000001LL),
cffc642d
MH		 3378 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
3379 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3380 BPF_MOV32_IMM(R0, 2),
3381 BPF_EXIT_INSN(),
3382 BPF_MOV32_IMM(R0, 1),
3383 BPF_EXIT_INSN(),
3384 },
3385 INTERNAL,
3386 { },
3387 { { 0, 0x1 } },
3388 },
3389 /* BPF_ALU | BPF_MOD | BPF_X */
3390 {
3391 "ALU_MOD_X: 3 % 2 = 1",
3392 .u.insns_int = {
3393 BPF_LD_IMM64(R0, 3),
3394 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3395 BPF_ALU32_REG(BPF_MOD, R0, R1),
3396 BPF_EXIT_INSN(),
3397 },
3398 INTERNAL,
3399 { },
3400 { { 0, 1 } },
3401 },
3402 {
3403 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
3404 .u.insns_int = {
56cbaa45
MH		 3405 BPF_LD_IMM64(R0, 4294967295U),
3406 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
cffc642d
MH		 3407 BPF_ALU32_REG(BPF_MOD, R0, R1),
3408 BPF_EXIT_INSN(),
3409 },
3410 INTERNAL,
3411 { },
3412 { { 0, 2 } },
3413 },
3414 {
3415 "ALU64_MOD_X: 3 % 2 = 1",
3416 .u.insns_int = {
3417 BPF_LD_IMM64(R0, 3),
3418 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3419 BPF_ALU64_REG(BPF_MOD, R0, R1),
3420 BPF_EXIT_INSN(),
3421 },
3422 INTERNAL,
3423 { },
3424 { { 0, 1 } },
3425 },
3426 {
3427 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3428 .u.insns_int = {
3429 BPF_LD_IMM64(R0, 2147483647),
3430 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
3431 BPF_ALU64_REG(BPF_MOD, R0, R1),
3432 BPF_EXIT_INSN(),
3433 },
3434 INTERNAL,
3435 { },
3436 { { 0, 2 } },
3437 },
3438 /* BPF_ALU | BPF_MOD | BPF_K */
3439 {
3440 "ALU_MOD_K: 3 % 2 = 1",
3441 .u.insns_int = {
3442 BPF_LD_IMM64(R0, 3),
3443 BPF_ALU32_IMM(BPF_MOD, R0, 2),
3444 BPF_EXIT_INSN(),
3445 },
3446 INTERNAL,
3447 { },
3448 { { 0, 1 } },
3449 },
3450 {
3451 "ALU_MOD_K: 3 % 1 = 0",
3452 .u.insns_int = {
3453 BPF_LD_IMM64(R0, 3),
3454 BPF_ALU32_IMM(BPF_MOD, R0, 1),
3455 BPF_EXIT_INSN(),
3456 },
3457 INTERNAL,
3458 { },
3459 { { 0, 0 } },
3460 },
3461 {
3462 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3463 .u.insns_int = {
56cbaa45
MH		 3464 BPF_LD_IMM64(R0, 4294967295U),
3465 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
cffc642d
MH		 3466 BPF_EXIT_INSN(),
3467 },
3468 INTERNAL,
3469 { },
3470 { { 0, 2 } },
3471 },
3472 {
3473 "ALU64_MOD_K: 3 % 2 = 1",
3474 .u.insns_int = {
3475 BPF_LD_IMM64(R0, 3),
3476 BPF_ALU64_IMM(BPF_MOD, R0, 2),
3477 BPF_EXIT_INSN(),
3478 },
3479 INTERNAL,
3480 { },
3481 { { 0, 1 } },
3482 },
3483 {
3484 "ALU64_MOD_K: 3 % 1 = 0",
3485 .u.insns_int = {
3486 BPF_LD_IMM64(R0, 3),
3487 BPF_ALU64_IMM(BPF_MOD, R0, 1),
3488 BPF_EXIT_INSN(),
3489 },
3490 INTERNAL,
3491 { },
3492 { { 0, 0 } },
3493 },
3494 {
3495 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3496 .u.insns_int = {
3497 BPF_LD_IMM64(R0, 2147483647),
3498 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3499 BPF_EXIT_INSN(),
3500 },
3501 INTERNAL,
3502 { },
3503 { { 0, 2 } },
3504 },
3505 /* BPF_ALU | BPF_AND | BPF_X */
3506 {
3507 "ALU_AND_X: 3 & 2 = 2",
3508 .u.insns_int = {
3509 BPF_LD_IMM64(R0, 3),
3510 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3511 BPF_ALU32_REG(BPF_AND, R0, R1),
3512 BPF_EXIT_INSN(),
3513 },
3514 INTERNAL,
3515 { },
3516 { { 0, 2 } },
3517 },
3518 {
3519 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3520 .u.insns_int = {
3521 BPF_LD_IMM64(R0, 0xffffffff),
3522 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3523 BPF_ALU32_REG(BPF_AND, R0, R1),
3524 BPF_EXIT_INSN(),
3525 },
3526 INTERNAL,
3527 { },
3528 { { 0, 0xffffffff } },
3529 },
3530 {
3531 "ALU64_AND_X: 3 & 2 = 2",
3532 .u.insns_int = {
3533 BPF_LD_IMM64(R0, 3),
3534 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3535 BPF_ALU64_REG(BPF_AND, R0, R1),
3536 BPF_EXIT_INSN(),
3537 },
3538 INTERNAL,
3539 { },
3540 { { 0, 2 } },
3541 },
3542 {
3543 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3544 .u.insns_int = {
3545 BPF_LD_IMM64(R0, 0xffffffff),
3546 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3547 BPF_ALU64_REG(BPF_AND, R0, R1),
3548 BPF_EXIT_INSN(),
3549 },
3550 INTERNAL,
3551 { },
3552 { { 0, 0xffffffff } },
3553 },
3554 /* BPF_ALU | BPF_AND | BPF_K */
3555 {
3556 "ALU_AND_K: 3 & 2 = 2",
3557 .u.insns_int = {
3558 BPF_LD_IMM64(R0, 3),
3559 BPF_ALU32_IMM(BPF_AND, R0, 2),
3560 BPF_EXIT_INSN(),
3561 },
3562 INTERNAL,
3563 { },
3564 { { 0, 2 } },
3565 },
3566 {
3567 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3568 .u.insns_int = {
3569 BPF_LD_IMM64(R0, 0xffffffff),
3570 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3571 BPF_EXIT_INSN(),
3572 },
3573 INTERNAL,
3574 { },
3575 { { 0, 0xffffffff } },
3576 },
3577 {
3578 "ALU64_AND_K: 3 & 2 = 2",
3579 .u.insns_int = {
3580 BPF_LD_IMM64(R0, 3),
3581 BPF_ALU64_IMM(BPF_AND, R0, 2),
3582 BPF_EXIT_INSN(),
3583 },
3584 INTERNAL,
3585 { },
3586 { { 0, 2 } },
3587 },
3588 {
3589 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3590 .u.insns_int = {
3591 BPF_LD_IMM64(R0, 0xffffffff),
3592 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3593 BPF_EXIT_INSN(),
3594 },
3595 INTERNAL,
3596 { },
3597 { { 0, 0xffffffff } },
3598 },
3599 {
3600 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000ffff00000000",
3601 .u.insns_int = {
56cbaa45
MH		 3602 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3603 BPF_LD_IMM64(R3, 0x0000000000000000LL),
cffc642d
MH		 3604 BPF_ALU64_IMM(BPF_AND, R2, 0x0),
3605 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3606 BPF_MOV32_IMM(R0, 2),
3607 BPF_EXIT_INSN(),
3608 BPF_MOV32_IMM(R0, 1),
3609 BPF_EXIT_INSN(),
3610 },
3611 INTERNAL,
3612 { },
3613 { { 0, 0x1 } },
3614 },
3615 {
3616 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffffffff",
3617 .u.insns_int = {
56cbaa45
MH		 3618 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3619 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 3620 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3621 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3622 BPF_MOV32_IMM(R0, 2),
3623 BPF_EXIT_INSN(),
3624 BPF_MOV32_IMM(R0, 1),
3625 BPF_EXIT_INSN(),
3626 },
3627 INTERNAL,
3628 { },
3629 { { 0, 0x1 } },
3630 },
3631 {
3632 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3633 .u.insns_int = {
56cbaa45
MH		 3634 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3635 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3636 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3637 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3638 BPF_MOV32_IMM(R0, 2),
3639 BPF_EXIT_INSN(),
3640 BPF_MOV32_IMM(R0, 1),
3641 BPF_EXIT_INSN(),
3642 },
3643 INTERNAL,
3644 { },
3645 { { 0, 0x1 } },
3646 },
3647 /* BPF_ALU | BPF_OR | BPF_X */
3648 {
3649 "ALU_OR_X: 1 | 2 = 3",
3650 .u.insns_int = {
3651 BPF_LD_IMM64(R0, 1),
3652 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3653 BPF_ALU32_REG(BPF_OR, R0, R1),
3654 BPF_EXIT_INSN(),
3655 },
3656 INTERNAL,
3657 { },
3658 { { 0, 3 } },
3659 },
3660 {
3661 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3662 .u.insns_int = {
3663 BPF_LD_IMM64(R0, 0),
3664 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3665 BPF_ALU32_REG(BPF_OR, R0, R1),
3666 BPF_EXIT_INSN(),
3667 },
3668 INTERNAL,
3669 { },
3670 { { 0, 0xffffffff } },
3671 },
3672 {
3673 "ALU64_OR_X: 1 | 2 = 3",
3674 .u.insns_int = {
3675 BPF_LD_IMM64(R0, 1),
3676 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3677 BPF_ALU64_REG(BPF_OR, R0, R1),
3678 BPF_EXIT_INSN(),
3679 },
3680 INTERNAL,
3681 { },
3682 { { 0, 3 } },
3683 },
3684 {
3685 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3686 .u.insns_int = {
3687 BPF_LD_IMM64(R0, 0),
3688 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3689 BPF_ALU64_REG(BPF_OR, R0, R1),
3690 BPF_EXIT_INSN(),
3691 },
3692 INTERNAL,
3693 { },
3694 { { 0, 0xffffffff } },
3695 },
3696 /* BPF_ALU | BPF_OR | BPF_K */
3697 {
3698 "ALU_OR_K: 1 | 2 = 3",
3699 .u.insns_int = {
3700 BPF_LD_IMM64(R0, 1),
3701 BPF_ALU32_IMM(BPF_OR, R0, 2),
3702 BPF_EXIT_INSN(),
3703 },
3704 INTERNAL,
3705 { },
3706 { { 0, 3 } },
3707 },
3708 {
3709 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3710 .u.insns_int = {
3711 BPF_LD_IMM64(R0, 0),
3712 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3713 BPF_EXIT_INSN(),
3714 },
3715 INTERNAL,
3716 { },
3717 { { 0, 0xffffffff } },
3718 },
3719 {
3720 "ALU64_OR_K: 1 | 2 = 3",
3721 .u.insns_int = {
3722 BPF_LD_IMM64(R0, 1),
3723 BPF_ALU64_IMM(BPF_OR, R0, 2),
3724 BPF_EXIT_INSN(),
3725 },
3726 INTERNAL,
3727 { },
3728 { { 0, 3 } },
3729 },
3730 {
3731 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
3732 .u.insns_int = {
3733 BPF_LD_IMM64(R0, 0),
3734 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
3735 BPF_EXIT_INSN(),
3736 },
3737 INTERNAL,
3738 { },
3739 { { 0, 0xffffffff } },
3740 },
3741 {
3742 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffff00000000",
3743 .u.insns_int = {
56cbaa45
MH		 3744 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3745 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 3746 BPF_ALU64_IMM(BPF_OR, R2, 0x0),
3747 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3748 BPF_MOV32_IMM(R0, 2),
3749 BPF_EXIT_INSN(),
3750 BPF_MOV32_IMM(R0, 1),
3751 BPF_EXIT_INSN(),
3752 },
3753 INTERNAL,
3754 { },
3755 { { 0, 0x1 } },
3756 },
3757 {
3758 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
3759 .u.insns_int = {
56cbaa45
MH		 3760 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3761 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3762 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3763 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3764 BPF_MOV32_IMM(R0, 2),
3765 BPF_EXIT_INSN(),
3766 BPF_MOV32_IMM(R0, 1),
3767 BPF_EXIT_INSN(),
3768 },
3769 INTERNAL,
3770 { },
3771 { { 0, 0x1 } },
3772 },
3773 {
3774 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
3775 .u.insns_int = {
56cbaa45
MH		 3776 BPF_LD_IMM64(R2, 0x0000000000000000LL),
3777 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3778 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3779 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3780 BPF_MOV32_IMM(R0, 2),
3781 BPF_EXIT_INSN(),
3782 BPF_MOV32_IMM(R0, 1),
3783 BPF_EXIT_INSN(),
3784 },
3785 INTERNAL,
3786 { },
3787 { { 0, 0x1 } },
3788 },
3789 /* BPF_ALU | BPF_XOR | BPF_X */
3790 {
3791 "ALU_XOR_X: 5 ^ 6 = 3",
3792 .u.insns_int = {
3793 BPF_LD_IMM64(R0, 5),
3794 BPF_ALU32_IMM(BPF_MOV, R1, 6),
3795 BPF_ALU32_REG(BPF_XOR, R0, R1),
3796 BPF_EXIT_INSN(),
3797 },
3798 INTERNAL,
3799 { },
3800 { { 0, 3 } },
3801 },
3802 {
3803 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
3804 .u.insns_int = {
3805 BPF_LD_IMM64(R0, 1),
3806 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3807 BPF_ALU32_REG(BPF_XOR, R0, R1),
3808 BPF_EXIT_INSN(),
3809 },
3810 INTERNAL,
3811 { },
3812 { { 0, 0xfffffffe } },
3813 },
3814 {
3815 "ALU64_XOR_X: 5 ^ 6 = 3",
3816 .u.insns_int = {
3817 BPF_LD_IMM64(R0, 5),
3818 BPF_ALU32_IMM(BPF_MOV, R1, 6),
3819 BPF_ALU64_REG(BPF_XOR, R0, R1),
3820 BPF_EXIT_INSN(),
3821 },
3822 INTERNAL,
3823 { },
3824 { { 0, 3 } },
3825 },
3826 {
3827 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
3828 .u.insns_int = {
3829 BPF_LD_IMM64(R0, 1),
3830 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3831 BPF_ALU64_REG(BPF_XOR, R0, R1),
3832 BPF_EXIT_INSN(),
3833 },
3834 INTERNAL,
3835 { },
3836 { { 0, 0xfffffffe } },
3837 },
3838 /* BPF_ALU | BPF_XOR | BPF_K */
3839 {
3840 "ALU_XOR_K: 5 ^ 6 = 3",
3841 .u.insns_int = {
3842 BPF_LD_IMM64(R0, 5),
3843 BPF_ALU32_IMM(BPF_XOR, R0, 6),
3844 BPF_EXIT_INSN(),
3845 },
3846 INTERNAL,
3847 { },
3848 { { 0, 3 } },
3849 },
3850 {
3851 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
3852 .u.insns_int = {
3853 BPF_LD_IMM64(R0, 1),
3854 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
3855 BPF_EXIT_INSN(),
3856 },
3857 INTERNAL,
3858 { },
3859 { { 0, 0xfffffffe } },
3860 },
3861 {
3862 "ALU64_XOR_K: 5 ^ 6 = 3",
3863 .u.insns_int = {
3864 BPF_LD_IMM64(R0, 5),
3865 BPF_ALU64_IMM(BPF_XOR, R0, 6),
3866 BPF_EXIT_INSN(),
3867 },
3868 INTERNAL,
3869 { },
3870 { { 0, 3 } },
3871 },
3872 {
3873 "ALU64_XOR_K: 1 & 0xffffffff = 0xfffffffe",
3874 .u.insns_int = {
3875 BPF_LD_IMM64(R0, 1),
3876 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
3877 BPF_EXIT_INSN(),
3878 },
3879 INTERNAL,
3880 { },
3881 { { 0, 0xfffffffe } },
3882 },
3883 {
3884 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
3885 .u.insns_int = {
56cbaa45
MH		 3886 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3887 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 3888 BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
3889 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3890 BPF_MOV32_IMM(R0, 2),
3891 BPF_EXIT_INSN(),
3892 BPF_MOV32_IMM(R0, 1),
3893 BPF_EXIT_INSN(),
3894 },
3895 INTERNAL,
3896 { },
3897 { { 0, 0x1 } },
3898 },
3899 {
3900 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
3901 .u.insns_int = {
56cbaa45
MH		 3902 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3903 BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
cffc642d
MH		 3904 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3905 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3906 BPF_MOV32_IMM(R0, 2),
3907 BPF_EXIT_INSN(),
3908 BPF_MOV32_IMM(R0, 1),
3909 BPF_EXIT_INSN(),
3910 },
3911 INTERNAL,
3912 { },
3913 { { 0, 0x1 } },
3914 },
3915 {
3916 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
3917 .u.insns_int = {
56cbaa45
MH		 3918 BPF_LD_IMM64(R2, 0x0000000000000000LL),
3919 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3920 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3921 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3922 BPF_MOV32_IMM(R0, 2),
3923 BPF_EXIT_INSN(),
3924 BPF_MOV32_IMM(R0, 1),
3925 BPF_EXIT_INSN(),
3926 },
3927 INTERNAL,
3928 { },
3929 { { 0, 0x1 } },
3930 },
3931 /* BPF_ALU | BPF_LSH | BPF_X */
3932 {
3933 "ALU_LSH_X: 1 << 1 = 2",
3934 .u.insns_int = {
3935 BPF_LD_IMM64(R0, 1),
3936 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3937 BPF_ALU32_REG(BPF_LSH, R0, R1),
3938 BPF_EXIT_INSN(),
3939 },
3940 INTERNAL,
3941 { },
3942 { { 0, 2 } },
3943 },
3944 {
3945 "ALU_LSH_X: 1 << 31 = 0x80000000",
3946 .u.insns_int = {
3947 BPF_LD_IMM64(R0, 1),
3948 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3949 BPF_ALU32_REG(BPF_LSH, R0, R1),
3950 BPF_EXIT_INSN(),
3951 },
3952 INTERNAL,
3953 { },
3954 { { 0, 0x80000000 } },
3955 },
3956 {
3957 "ALU64_LSH_X: 1 << 1 = 2",
3958 .u.insns_int = {
3959 BPF_LD_IMM64(R0, 1),
3960 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3961 BPF_ALU64_REG(BPF_LSH, R0, R1),
3962 BPF_EXIT_INSN(),
3963 },
3964 INTERNAL,
3965 { },
3966 { { 0, 2 } },
3967 },
3968 {
3969 "ALU64_LSH_X: 1 << 31 = 0x80000000",
3970 .u.insns_int = {
3971 BPF_LD_IMM64(R0, 1),
3972 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3973 BPF_ALU64_REG(BPF_LSH, R0, R1),
3974 BPF_EXIT_INSN(),
3975 },
3976 INTERNAL,
3977 { },
3978 { { 0, 0x80000000 } },
3979 },
3980 /* BPF_ALU | BPF_LSH | BPF_K */
3981 {
3982 "ALU_LSH_K: 1 << 1 = 2",
3983 .u.insns_int = {
3984 BPF_LD_IMM64(R0, 1),
3985 BPF_ALU32_IMM(BPF_LSH, R0, 1),
3986 BPF_EXIT_INSN(),
3987 },
3988 INTERNAL,
3989 { },
3990 { { 0, 2 } },
3991 },
3992 {
3993 "ALU_LSH_K: 1 << 31 = 0x80000000",
3994 .u.insns_int = {
3995 BPF_LD_IMM64(R0, 1),
3996 BPF_ALU32_IMM(BPF_LSH, R0, 31),
3997 BPF_EXIT_INSN(),
3998 },
3999 INTERNAL,
4000 { },
4001 { { 0, 0x80000000 } },
4002 },
4003 {
4004 "ALU64_LSH_K: 1 << 1 = 2",
4005 .u.insns_int = {
4006 BPF_LD_IMM64(R0, 1),
4007 BPF_ALU64_IMM(BPF_LSH, R0, 1),
4008 BPF_EXIT_INSN(),
4009 },
4010 INTERNAL,
4011 { },
4012 { { 0, 2 } },
4013 },
4014 {
4015 "ALU64_LSH_K: 1 << 31 = 0x80000000",
4016 .u.insns_int = {
4017 BPF_LD_IMM64(R0, 1),
4018 BPF_ALU64_IMM(BPF_LSH, R0, 31),
4019 BPF_EXIT_INSN(),
4020 },
4021 INTERNAL,
4022 { },
4023 { { 0, 0x80000000 } },
4024 },
4025 /* BPF_ALU | BPF_RSH | BPF_X */
4026 {
4027 "ALU_RSH_X: 2 >> 1 = 1",
4028 .u.insns_int = {
4029 BPF_LD_IMM64(R0, 2),
4030 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4031 BPF_ALU32_REG(BPF_RSH, R0, R1),
4032 BPF_EXIT_INSN(),
4033 },
4034 INTERNAL,
4035 { },
4036 { { 0, 1 } },
4037 },
4038 {
4039 "ALU_RSH_X: 0x80000000 >> 31 = 1",
4040 .u.insns_int = {
4041 BPF_LD_IMM64(R0, 0x80000000),
4042 BPF_ALU32_IMM(BPF_MOV, R1, 31),
4043 BPF_ALU32_REG(BPF_RSH, R0, R1),
4044 BPF_EXIT_INSN(),
4045 },
4046 INTERNAL,
4047 { },
4048 { { 0, 1 } },
4049 },
4050 {
4051 "ALU64_RSH_X: 2 >> 1 = 1",
4052 .u.insns_int = {
4053 BPF_LD_IMM64(R0, 2),
4054 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4055 BPF_ALU64_REG(BPF_RSH, R0, R1),
4056 BPF_EXIT_INSN(),
4057 },
4058 INTERNAL,
4059 { },
4060 { { 0, 1 } },
4061 },
4062 {
4063 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
4064 .u.insns_int = {
4065 BPF_LD_IMM64(R0, 0x80000000),
4066 BPF_ALU32_IMM(BPF_MOV, R1, 31),
4067 BPF_ALU64_REG(BPF_RSH, R0, R1),
4068 BPF_EXIT_INSN(),
4069 },
4070 INTERNAL,
4071 { },
4072 { { 0, 1 } },
4073 },
4074 /* BPF_ALU | BPF_RSH | BPF_K */
4075 {
4076 "ALU_RSH_K: 2 >> 1 = 1",
4077 .u.insns_int = {
4078 BPF_LD_IMM64(R0, 2),
4079 BPF_ALU32_IMM(BPF_RSH, R0, 1),
4080 BPF_EXIT_INSN(),
4081 },
4082 INTERNAL,
4083 { },
4084 { { 0, 1 } },
4085 },
4086 {
4087 "ALU_RSH_K: 0x80000000 >> 31 = 1",
4088 .u.insns_int = {
4089 BPF_LD_IMM64(R0, 0x80000000),
4090 BPF_ALU32_IMM(BPF_RSH, R0, 31),
4091 BPF_EXIT_INSN(),
4092 },
4093 INTERNAL,
4094 { },
4095 { { 0, 1 } },
4096 },
4097 {
4098 "ALU64_RSH_K: 2 >> 1 = 1",
4099 .u.insns_int = {
4100 BPF_LD_IMM64(R0, 2),
4101 BPF_ALU64_IMM(BPF_RSH, R0, 1),
4102 BPF_EXIT_INSN(),
4103 },
4104 INTERNAL,
4105 { },
4106 { { 0, 1 } },
4107 },
4108 {
4109 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
4110 .u.insns_int = {
4111 BPF_LD_IMM64(R0, 0x80000000),
4112 BPF_ALU64_IMM(BPF_RSH, R0, 31),
4113 BPF_EXIT_INSN(),
4114 },
4115 INTERNAL,
4116 { },
4117 { { 0, 1 } },
4118 },
4119 /* BPF_ALU | BPF_ARSH | BPF_X */
4120 {
4121 "ALU_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4122 .u.insns_int = {
4123 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4124 BPF_ALU32_IMM(BPF_MOV, R1, 40),
4125 BPF_ALU64_REG(BPF_ARSH, R0, R1),
4126 BPF_EXIT_INSN(),
4127 },
4128 INTERNAL,
4129 { },
4130 { { 0, 0xffff00ff } },
4131 },
4132 /* BPF_ALU | BPF_ARSH | BPF_K */
4133 {
4134 "ALU_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4135 .u.insns_int = {
4136 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4137 BPF_ALU64_IMM(BPF_ARSH, R0, 40),
4138 BPF_EXIT_INSN(),
4139 },
4140 INTERNAL,
4141 { },
4142 { { 0, 0xffff00ff } },
4143 },
4144 /* BPF_ALU | BPF_NEG */
4145 {
4146 "ALU_NEG: -(3) = -3",
4147 .u.insns_int = {
4148 BPF_ALU32_IMM(BPF_MOV, R0, 3),
4149 BPF_ALU32_IMM(BPF_NEG, R0, 0),
4150 BPF_EXIT_INSN(),
4151 },
4152 INTERNAL,
4153 { },
4154 { { 0, -3 } },
4155 },
4156 {
4157 "ALU_NEG: -(-3) = 3",
4158 .u.insns_int = {
4159 BPF_ALU32_IMM(BPF_MOV, R0, -3),
4160 BPF_ALU32_IMM(BPF_NEG, R0, 0),
4161 BPF_EXIT_INSN(),
4162 },
4163 INTERNAL,
4164 { },
4165 { { 0, 3 } },
4166 },
4167 {
4168 "ALU64_NEG: -(3) = -3",
4169 .u.insns_int = {
4170 BPF_LD_IMM64(R0, 3),
4171 BPF_ALU64_IMM(BPF_NEG, R0, 0),
4172 BPF_EXIT_INSN(),
4173 },
4174 INTERNAL,
4175 { },
4176 { { 0, -3 } },
4177 },
4178 {
4179 "ALU64_NEG: -(-3) = 3",
4180 .u.insns_int = {
4181 BPF_LD_IMM64(R0, -3),
4182 BPF_ALU64_IMM(BPF_NEG, R0, 0),
4183 BPF_EXIT_INSN(),
4184 },
4185 INTERNAL,
4186 { },
4187 { { 0, 3 } },
4188 },
4189 /* BPF_ALU | BPF_END | BPF_FROM_BE */
4190 {
4191 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
4192 .u.insns_int = {
4193 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4194 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
4195 BPF_EXIT_INSN(),
4196 },
4197 INTERNAL,
4198 { },
4199 { { 0, cpu_to_be16(0xcdef) } },
4200 },
4201 {
4202 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
4203 .u.insns_int = {
4204 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4205 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
ba29becd
XW		 4206 BPF_ALU64_REG(BPF_MOV, R1, R0),
4207 BPF_ALU64_IMM(BPF_RSH, R1, 32),
4208 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
cffc642d
MH		 4209 BPF_EXIT_INSN(),
4210 },
4211 INTERNAL,
4212 { },
4213 { { 0, cpu_to_be32(0x89abcdef) } },
4214 },
4215 {
4216 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
4217 .u.insns_int = {
4218 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4219 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
4220 BPF_EXIT_INSN(),
4221 },
4222 INTERNAL,
4223 { },
4224 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
4225 },
4226 /* BPF_ALU | BPF_END | BPF_FROM_LE */
4227 {
4228 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
4229 .u.insns_int = {
4230 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4231 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
4232 BPF_EXIT_INSN(),
4233 },
4234 INTERNAL,
4235 { },
4236 { { 0, cpu_to_le16(0xcdef) } },
4237 },
4238 {
4239 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
4240 .u.insns_int = {
4241 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4242 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
ba29becd
XW		 4243 BPF_ALU64_REG(BPF_MOV, R1, R0),
4244 BPF_ALU64_IMM(BPF_RSH, R1, 32),
4245 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
cffc642d
MH		 4246 BPF_EXIT_INSN(),
4247 },
4248 INTERNAL,
4249 { },
4250 { { 0, cpu_to_le32(0x89abcdef) } },
4251 },
4252 {
4253 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
4254 .u.insns_int = {
4255 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4256 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
4257 BPF_EXIT_INSN(),
4258 },
4259 INTERNAL,
4260 { },
4261 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
4262 },
4263 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
4264 {
4265 "ST_MEM_B: Store/Load byte: max negative",
4266 .u.insns_int = {
4267 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4268 BPF_ST_MEM(BPF_B, R10, -40, 0xff),
4269 BPF_LDX_MEM(BPF_B, R0, R10, -40),
4270 BPF_EXIT_INSN(),
4271 },
4272 INTERNAL,
4273 { },
4274 { { 0, 0xff } },
105c0361 4275 .stack_depth = 40,
cffc642d
MH		 4276 },
4277 {
4278 "ST_MEM_B: Store/Load byte: max positive",
4279 .u.insns_int = {
4280 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4281 BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
4282 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4283 BPF_EXIT_INSN(),
4284 },
4285 INTERNAL,
4286 { },
4287 { { 0, 0x7f } },
105c0361 4288 .stack_depth = 40,
cffc642d
MH		 4289 },
4290 {
4291 "STX_MEM_B: Store/Load byte: max negative",
4292 .u.insns_int = {
4293 BPF_LD_IMM64(R0, 0),
4294 BPF_LD_IMM64(R1, 0xffLL),
4295 BPF_STX_MEM(BPF_B, R10, R1, -40),
4296 BPF_LDX_MEM(BPF_B, R0, R10, -40),
4297 BPF_EXIT_INSN(),
4298 },
4299 INTERNAL,
4300 { },
4301 { { 0, 0xff } },
105c0361 4302 .stack_depth = 40,
cffc642d
MH		 4303 },
4304 {
4305 "ST_MEM_H: Store/Load half word: max negative",
4306 .u.insns_int = {
4307 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4308 BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
4309 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4310 BPF_EXIT_INSN(),
4311 },
4312 INTERNAL,
4313 { },
4314 { { 0, 0xffff } },
105c0361 4315 .stack_depth = 40,
cffc642d
MH		 4316 },
4317 {
4318 "ST_MEM_H: Store/Load half word: max positive",
4319 .u.insns_int = {
4320 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4321 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
4322 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4323 BPF_EXIT_INSN(),
4324 },
4325 INTERNAL,
4326 { },
4327 { { 0, 0x7fff } },
105c0361 4328 .stack_depth = 40,
cffc642d
MH		 4329 },
4330 {
4331 "STX_MEM_H: Store/Load half word: max negative",
4332 .u.insns_int = {
4333 BPF_LD_IMM64(R0, 0),
4334 BPF_LD_IMM64(R1, 0xffffLL),
4335 BPF_STX_MEM(BPF_H, R10, R1, -40),
4336 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4337 BPF_EXIT_INSN(),
4338 },
4339 INTERNAL,
4340 { },
4341 { { 0, 0xffff } },
105c0361 4342 .stack_depth = 40,
cffc642d
MH		 4343 },
4344 {
4345 "ST_MEM_W: Store/Load word: max negative",
4346 .u.insns_int = {
4347 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4348 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
4349 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4350 BPF_EXIT_INSN(),
4351 },
4352 INTERNAL,
4353 { },
4354 { { 0, 0xffffffff } },
105c0361 4355 .stack_depth = 40,
cffc642d
MH		 4356 },
4357 {
4358 "ST_MEM_W: Store/Load word: max positive",
4359 .u.insns_int = {
4360 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4361 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
4362 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4363 BPF_EXIT_INSN(),
4364 },
4365 INTERNAL,
4366 { },
4367 { { 0, 0x7fffffff } },
105c0361 4368 .stack_depth = 40,
cffc642d
MH		 4369 },
4370 {
4371 "STX_MEM_W: Store/Load word: max negative",
4372 .u.insns_int = {
4373 BPF_LD_IMM64(R0, 0),
4374 BPF_LD_IMM64(R1, 0xffffffffLL),
4375 BPF_STX_MEM(BPF_W, R10, R1, -40),
4376 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4377 BPF_EXIT_INSN(),
4378 },
4379 INTERNAL,
4380 { },
4381 { { 0, 0xffffffff } },
105c0361 4382 .stack_depth = 40,
cffc642d
MH		 4383 },
4384 {
4385 "ST_MEM_DW: Store/Load double word: max negative",
4386 .u.insns_int = {
4387 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4388 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
4389 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4390 BPF_EXIT_INSN(),
4391 },
4392 INTERNAL,
4393 { },
4394 { { 0, 0xffffffff } },
105c0361 4395 .stack_depth = 40,
cffc642d
MH		 4396 },
4397 {
4398 "ST_MEM_DW: Store/Load double word: max negative 2",
4399 .u.insns_int = {
56cbaa45
MH		 4400 BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
4401 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 4402 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
4403 BPF_LDX_MEM(BPF_DW, R2, R10, -40),
4404 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4405 BPF_MOV32_IMM(R0, 2),
4406 BPF_EXIT_INSN(),
4407 BPF_MOV32_IMM(R0, 1),
4408 BPF_EXIT_INSN(),
4409 },
4410 INTERNAL,
4411 { },
4412 { { 0, 0x1 } },
105c0361 4413 .stack_depth = 40,
cffc642d
MH		 4414 },
4415 {
4416 "ST_MEM_DW: Store/Load double word: max positive",
4417 .u.insns_int = {
4418 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4419 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
4420 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4421 BPF_EXIT_INSN(),
4422 },
4423 INTERNAL,
4424 { },
4425 { { 0, 0x7fffffff } },
105c0361 4426 .stack_depth = 40,
cffc642d
MH		 4427 },
4428 {
4429 "STX_MEM_DW: Store/Load double word: max negative",
4430 .u.insns_int = {
4431 BPF_LD_IMM64(R0, 0),
4432 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4433 BPF_STX_MEM(BPF_W, R10, R1, -40),
4434 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4435 BPF_EXIT_INSN(),
4436 },
4437 INTERNAL,
4438 { },
4439 { { 0, 0xffffffff } },
105c0361 4440 .stack_depth = 40,
cffc642d
MH		 4441 },
4442 /* BPF_STX | BPF_XADD | BPF_W/DW */
4443 {
4444 "STX_XADD_W: Test: 0x12 + 0x10 = 0x22",
4445 .u.insns_int = {
4446 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4447 BPF_ST_MEM(BPF_W, R10, -40, 0x10),
4448 BPF_STX_XADD(BPF_W, R10, R0, -40),
4449 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4450 BPF_EXIT_INSN(),
4451 },
4452 INTERNAL,
4453 { },
4454 { { 0, 0x22 } },
105c0361 4455 .stack_depth = 40,
cffc642d 4456 },
85f68fe8
DB		 4457 {
4458 "STX_XADD_W: Test side-effects, r10: 0x12 + 0x10 = 0x22",
4459 .u.insns_int = {
4460 BPF_ALU64_REG(BPF_MOV, R1, R10),
4461 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4462 BPF_ST_MEM(BPF_W, R10, -40, 0x10),
4463 BPF_STX_XADD(BPF_W, R10, R0, -40),
4464 BPF_ALU64_REG(BPF_MOV, R0, R10),
4465 BPF_ALU64_REG(BPF_SUB, R0, R1),
4466 BPF_EXIT_INSN(),
4467 },
4468 INTERNAL,
4469 { },
4470 { { 0, 0 } },
105c0361 4471 .stack_depth = 40,
85f68fe8
DB		 4472 },
4473 {
4474 "STX_XADD_W: Test side-effects, r0: 0x12 + 0x10 = 0x22",
4475 .u.insns_int = {
4476 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4477 BPF_ST_MEM(BPF_W, R10, -40, 0x10),
4478 BPF_STX_XADD(BPF_W, R10, R0, -40),
4479 BPF_EXIT_INSN(),
4480 },
4481 INTERNAL,
4482 { },
4483 { { 0, 0x12 } },
105c0361 4484 .stack_depth = 40,
85f68fe8
DB		 4485 },
4486 {
4487 "STX_XADD_W: X + 1 + 1 + 1 + ...",
4488 { },
4489 INTERNAL,
4490 { },
4491 { { 0, 4134 } },
4492 .fill_helper = bpf_fill_stxw,
4493 },
cffc642d
MH		 4494 {
4495 "STX_XADD_DW: Test: 0x12 + 0x10 = 0x22",
4496 .u.insns_int = {
4497 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4498 BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
4499 BPF_STX_XADD(BPF_DW, R10, R0, -40),
4500 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4501 BPF_EXIT_INSN(),
4502 },
4503 INTERNAL,
4504 { },
4505 { { 0, 0x22 } },
105c0361 4506 .stack_depth = 40,
cffc642d 4507 },
85f68fe8
DB		 4508 {
4509 "STX_XADD_DW: Test side-effects, r10: 0x12 + 0x10 = 0x22",
4510 .u.insns_int = {
4511 BPF_ALU64_REG(BPF_MOV, R1, R10),
4512 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4513 BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
4514 BPF_STX_XADD(BPF_DW, R10, R0, -40),
4515 BPF_ALU64_REG(BPF_MOV, R0, R10),
4516 BPF_ALU64_REG(BPF_SUB, R0, R1),
4517 BPF_EXIT_INSN(),
4518 },
4519 INTERNAL,
4520 { },
4521 { { 0, 0 } },
105c0361 4522 .stack_depth = 40,
85f68fe8
DB		 4523 },
4524 {
4525 "STX_XADD_DW: Test side-effects, r0: 0x12 + 0x10 = 0x22",
4526 .u.insns_int = {
4527 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4528 BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
4529 BPF_STX_XADD(BPF_DW, R10, R0, -40),
4530 BPF_EXIT_INSN(),
4531 },
4532 INTERNAL,
4533 { },
4534 { { 0, 0x12 } },
105c0361 4535 .stack_depth = 40,
85f68fe8
DB		 4536 },
4537 {
4538 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
4539 { },
4540 INTERNAL,
4541 { },
4542 { { 0, 4134 } },
4543 .fill_helper = bpf_fill_stxdw,
4544 },
cffc642d
MH		 4545 /* BPF_JMP | BPF_EXIT */
4546 {
4547 "JMP_EXIT",
4548 .u.insns_int = {
4549 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
4550 BPF_EXIT_INSN(),
4551 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
4552 },
4553 INTERNAL,
4554 { },
4555 { { 0, 0x4711 } },
4556 },
4557 /* BPF_JMP | BPF_JA */
4558 {
4559 "JMP_JA: Unconditional jump: if (true) return 1",
4560 .u.insns_int = {
4561 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4562 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
4563 BPF_EXIT_INSN(),
4564 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4565 BPF_EXIT_INSN(),
4566 },
4567 INTERNAL,
4568 { },
4569 { { 0, 1 } },
4570 },
92b31a9a
DB		 4571 /* BPF_JMP | BPF_JSLT | BPF_K */
4572 {
4573 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
4574 .u.insns_int = {
4575 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4576 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
4577 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
4578 BPF_EXIT_INSN(),
4579 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4580 BPF_EXIT_INSN(),
4581 },
4582 INTERNAL,
4583 { },
4584 { { 0, 1 } },
4585 },
4586 {
4587 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
4588 .u.insns_int = {
4589 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4590 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4591 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
4592 BPF_EXIT_INSN(),
4593 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4594 BPF_EXIT_INSN(),
4595 },
4596 INTERNAL,
4597 { },
4598 { { 0, 1 } },
4599 },
cffc642d
MH		 4600 /* BPF_JMP | BPF_JSGT | BPF_K */
4601 {
4602 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
4603 .u.insns_int = {
4604 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4605 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4606 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
4607 BPF_EXIT_INSN(),
4608 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4609 BPF_EXIT_INSN(),
4610 },
4611 INTERNAL,
4612 { },
4613 { { 0, 1 } },
4614 },
4615 {
4616 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
4617 .u.insns_int = {
4618 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4619 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4620 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
4621 BPF_EXIT_INSN(),
4622 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4623 BPF_EXIT_INSN(),
4624 },
4625 INTERNAL,
4626 { },
4627 { { 0, 1 } },
4628 },
92b31a9a
DB		 4629 /* BPF_JMP | BPF_JSLE | BPF_K */
4630 {
4631 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
4632 .u.insns_int = {
4633 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4634 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
4635 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
4636 BPF_EXIT_INSN(),
4637 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4638 BPF_EXIT_INSN(),
4639 },
4640 INTERNAL,
4641 { },
4642 { { 0, 1 } },
4643 },
4644 {
4645 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
4646 .u.insns_int = {
4647 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4648 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4649 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
4650 BPF_EXIT_INSN(),
4651 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4652 BPF_EXIT_INSN(),
4653 },
4654 INTERNAL,
4655 { },
4656 { { 0, 1 } },
4657 },
4658 {
4659 "JMP_JSLE_K: Signed jump: value walk 1",
4660 .u.insns_int = {
4661 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4662 BPF_LD_IMM64(R1, 3),
4663 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
4664 BPF_ALU64_IMM(BPF_SUB, R1, 1),
4665 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
4666 BPF_ALU64_IMM(BPF_SUB, R1, 1),
4667 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
4668 BPF_ALU64_IMM(BPF_SUB, R1, 1),
4669 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
4670 BPF_EXIT_INSN(), /* bad exit */
4671 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
4672 BPF_EXIT_INSN(),
4673 },
4674 INTERNAL,
4675 { },
4676 { { 0, 1 } },
4677 },
4678 {
4679 "JMP_JSLE_K: Signed jump: value walk 2",
4680 .u.insns_int = {
4681 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4682 BPF_LD_IMM64(R1, 3),
4683 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
4684 BPF_ALU64_IMM(BPF_SUB, R1, 2),
4685 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
4686 BPF_ALU64_IMM(BPF_SUB, R1, 2),
4687 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
4688 BPF_EXIT_INSN(), /* bad exit */
4689 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
4690 BPF_EXIT_INSN(),
4691 },
4692 INTERNAL,
4693 { },
4694 { { 0, 1 } },
4695 },
cffc642d
MH		 4696 /* BPF_JMP | BPF_JSGE | BPF_K */
4697 {
4698 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
4699 .u.insns_int = {
4700 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4701 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4702 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
4703 BPF_EXIT_INSN(),
4704 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4705 BPF_EXIT_INSN(),
4706 },
4707 INTERNAL,
4708 { },
4709 { { 0, 1 } },
4710 },
4711 {
4712 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
4713 .u.insns_int = {
4714 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4715 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4716 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
4717 BPF_EXIT_INSN(),
4718 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4719 BPF_EXIT_INSN(),
4720 },
4721 INTERNAL,
4722 { },
4723 { { 0, 1 } },
4724 },
791caeb0
DD		 4725 {
4726 "JMP_JSGE_K: Signed jump: value walk 1",
4727 .u.insns_int = {
4728 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4729 BPF_LD_IMM64(R1, -3),
4730 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
4731 BPF_ALU64_IMM(BPF_ADD, R1, 1),
4732 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
4733 BPF_ALU64_IMM(BPF_ADD, R1, 1),
4734 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
4735 BPF_ALU64_IMM(BPF_ADD, R1, 1),
4736 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
4737 BPF_EXIT_INSN(), /* bad exit */
4738 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
4739 BPF_EXIT_INSN(),
4740 },
4741 INTERNAL,
4742 { },
4743 { { 0, 1 } },
4744 },
4745 {
4746 "JMP_JSGE_K: Signed jump: value walk 2",
4747 .u.insns_int = {
4748 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4749 BPF_LD_IMM64(R1, -3),
4750 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
4751 BPF_ALU64_IMM(BPF_ADD, R1, 2),
4752 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
4753 BPF_ALU64_IMM(BPF_ADD, R1, 2),
4754 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
4755 BPF_EXIT_INSN(), /* bad exit */
4756 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
4757 BPF_EXIT_INSN(),
4758 },
4759 INTERNAL,
4760 { },
4761 { { 0, 1 } },
4762 },
cffc642d
MH		 4763 /* BPF_JMP | BPF_JGT | BPF_K */
4764 {
4765 "JMP_JGT_K: if (3 > 2) return 1",
4766 .u.insns_int = {
4767 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4768 BPF_LD_IMM64(R1, 3),
4769 BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
4770 BPF_EXIT_INSN(),
4771 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4772 BPF_EXIT_INSN(),
4773 },
4774 INTERNAL,
4775 { },
4776 { { 0, 1 } },
4777 },
c7395d6b
NR		 4778 {
4779 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
4780 .u.insns_int = {
4781 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4782 BPF_LD_IMM64(R1, -1),
4783 BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
4784 BPF_EXIT_INSN(),
4785 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4786 BPF_EXIT_INSN(),
4787 },
4788 INTERNAL,
4789 { },
4790 { { 0, 1 } },
4791 },
92b31a9a
DB		 4792 /* BPF_JMP | BPF_JLT | BPF_K */
4793 {
4794 "JMP_JLT_K: if (2 < 3) return 1",
4795 .u.insns_int = {
4796 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4797 BPF_LD_IMM64(R1, 2),
4798 BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
4799 BPF_EXIT_INSN(),
4800 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4801 BPF_EXIT_INSN(),
4802 },
4803 INTERNAL,
4804 { },
4805 { { 0, 1 } },
4806 },
4807 {
4808 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
4809 .u.insns_int = {
4810 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4811 BPF_LD_IMM64(R1, 1),
4812 BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
4813 BPF_EXIT_INSN(),
4814 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4815 BPF_EXIT_INSN(),
4816 },
4817 INTERNAL,
4818 { },
4819 { { 0, 1 } },
4820 },
cffc642d
MH		 4821 /* BPF_JMP | BPF_JGE | BPF_K */
4822 {
4823 "JMP_JGE_K: if (3 >= 2) return 1",
4824 .u.insns_int = {
4825 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4826 BPF_LD_IMM64(R1, 3),
4827 BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
4828 BPF_EXIT_INSN(),
4829 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4830 BPF_EXIT_INSN(),
4831 },
4832 INTERNAL,
4833 { },
4834 { { 0, 1 } },
4835 },
92b31a9a
DB		 4836 /* BPF_JMP | BPF_JLE | BPF_K */
4837 {
4838 "JMP_JLE_K: if (2 <= 3) return 1",
4839 .u.insns_int = {
4840 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4841 BPF_LD_IMM64(R1, 2),
4842 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
4843 BPF_EXIT_INSN(),
4844 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4845 BPF_EXIT_INSN(),
4846 },
4847 INTERNAL,
4848 { },
4849 { { 0, 1 } },
4850 },
fe593844
MH		 4851 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
4852 {
4853 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
4854 .u.insns_int = {
4855 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
4856 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
4857 BPF_EXIT_INSN(),
4858 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
4859 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
4860 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
4861 BPF_EXIT_INSN(),
4862 },
4863 INTERNAL,
4864 { },
4865 { { 0, 1 } },
4866 },
cffc642d
MH		 4867 {
4868 "JMP_JGE_K: if (3 >= 3) return 1",
4869 .u.insns_int = {
4870 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4871 BPF_LD_IMM64(R1, 3),
4872 BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
4873 BPF_EXIT_INSN(),
4874 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4875 BPF_EXIT_INSN(),
4876 },
4877 INTERNAL,
4878 { },
4879 { { 0, 1 } },
4880 },
92b31a9a
DB		 4881 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
4882 {
4883 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
4884 .u.insns_int = {
4885 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
4886 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
4887 BPF_EXIT_INSN(),
4888 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
4889 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
4890 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
4891 BPF_EXIT_INSN(),
4892 },
4893 INTERNAL,
4894 { },
4895 { { 0, 1 } },
4896 },
4897 {
4898 "JMP_JLE_K: if (3 <= 3) return 1",
4899 .u.insns_int = {
4900 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4901 BPF_LD_IMM64(R1, 3),
4902 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
4903 BPF_EXIT_INSN(),
4904 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4905 BPF_EXIT_INSN(),
4906 },
4907 INTERNAL,
4908 { },
4909 { { 0, 1 } },
4910 },
cffc642d
MH		 4911 /* BPF_JMP | BPF_JNE | BPF_K */
4912 {
4913 "JMP_JNE_K: if (3 != 2) return 1",
4914 .u.insns_int = {
4915 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4916 BPF_LD_IMM64(R1, 3),
4917 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
4918 BPF_EXIT_INSN(),
4919 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4920 BPF_EXIT_INSN(),
4921 },
4922 INTERNAL,
4923 { },
4924 { { 0, 1 } },
4925 },
4926 /* BPF_JMP | BPF_JEQ | BPF_K */
4927 {
4928 "JMP_JEQ_K: if (3 == 3) return 1",
4929 .u.insns_int = {
4930 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4931 BPF_LD_IMM64(R1, 3),
4932 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
4933 BPF_EXIT_INSN(),
4934 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4935 BPF_EXIT_INSN(),
4936 },
4937 INTERNAL,
4938 { },
4939 { { 0, 1 } },
4940 },
4941 /* BPF_JMP | BPF_JSET | BPF_K */
4942 {
4943 "JMP_JSET_K: if (0x3 & 0x2) return 1",
4944 .u.insns_int = {
4945 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4946 BPF_LD_IMM64(R1, 3),
9f134c34 4947 BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
cffc642d
MH		 4948 BPF_EXIT_INSN(),
4949 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4950 BPF_EXIT_INSN(),
4951 },
4952 INTERNAL,
4953 { },
4954 { { 0, 1 } },
4955 },
4956 {
4957 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
4958 .u.insns_int = {
4959 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4960 BPF_LD_IMM64(R1, 3),
9f134c34 4961 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
cffc642d
MH		 4962 BPF_EXIT_INSN(),
4963 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4964 BPF_EXIT_INSN(),
4965 },
4966 INTERNAL,
4967 { },
4968 { { 0, 1 } },
4969 },
4970 /* BPF_JMP | BPF_JSGT | BPF_X */
4971 {
4972 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
4973 .u.insns_int = {
4974 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4975 BPF_LD_IMM64(R1, -1),
4976 BPF_LD_IMM64(R2, -2),
4977 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4978 BPF_EXIT_INSN(),
4979 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4980 BPF_EXIT_INSN(),
4981 },
4982 INTERNAL,
4983 { },
4984 { { 0, 1 } },
4985 },
4986 {
4987 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
4988 .u.insns_int = {
4989 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4990 BPF_LD_IMM64(R1, -1),
4991 BPF_LD_IMM64(R2, -1),
4992 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4993 BPF_EXIT_INSN(),
4994 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4995 BPF_EXIT_INSN(),
4996 },
4997 INTERNAL,
4998 { },
4999 { { 0, 1 } },
5000 },
92b31a9a
DB		 5001 /* BPF_JMP | BPF_JSLT | BPF_X */
5002 {
5003 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
5004 .u.insns_int = {
5005 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5006 BPF_LD_IMM64(R1, -1),
5007 BPF_LD_IMM64(R2, -2),
5008 BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
5009 BPF_EXIT_INSN(),
5010 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5011 BPF_EXIT_INSN(),
5012 },
5013 INTERNAL,
5014 { },
5015 { { 0, 1 } },
5016 },
5017 {
5018 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
5019 .u.insns_int = {
5020 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5021 BPF_LD_IMM64(R1, -1),
5022 BPF_LD_IMM64(R2, -1),
5023 BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
5024 BPF_EXIT_INSN(),
5025 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5026 BPF_EXIT_INSN(),
5027 },
5028 INTERNAL,
5029 { },
5030 { { 0, 1 } },
5031 },
cffc642d
MH		 5032 /* BPF_JMP | BPF_JSGE | BPF_X */
5033 {
5034 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
5035 .u.insns_int = {
5036 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5037 BPF_LD_IMM64(R1, -1),
5038 BPF_LD_IMM64(R2, -2),
5039 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
5040 BPF_EXIT_INSN(),
5041 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5042 BPF_EXIT_INSN(),
5043 },
5044 INTERNAL,
5045 { },
5046 { { 0, 1 } },
5047 },
5048 {
5049 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
5050 .u.insns_int = {
5051 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5052 BPF_LD_IMM64(R1, -1),
5053 BPF_LD_IMM64(R2, -1),
5054 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
5055 BPF_EXIT_INSN(),
5056 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5057 BPF_EXIT_INSN(),
5058 },
5059 INTERNAL,
5060 { },
5061 { { 0, 1 } },
5062 },
92b31a9a
DB		 5063 /* BPF_JMP | BPF_JSLE | BPF_X */
5064 {
5065 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
5066 .u.insns_int = {
5067 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5068 BPF_LD_IMM64(R1, -1),
5069 BPF_LD_IMM64(R2, -2),
5070 BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
5071 BPF_EXIT_INSN(),
5072 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5073 BPF_EXIT_INSN(),
5074 },
5075 INTERNAL,
5076 { },
5077 { { 0, 1 } },
5078 },
5079 {
5080 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
5081 .u.insns_int = {
5082 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5083 BPF_LD_IMM64(R1, -1),
5084 BPF_LD_IMM64(R2, -1),
5085 BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
5086 BPF_EXIT_INSN(),
5087 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5088 BPF_EXIT_INSN(),
5089 },
5090 INTERNAL,
5091 { },
5092 { { 0, 1 } },
5093 },
cffc642d
MH		 5094 /* BPF_JMP | BPF_JGT | BPF_X */
5095 {
5096 "JMP_JGT_X: if (3 > 2) return 1",
5097 .u.insns_int = {
5098 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5099 BPF_LD_IMM64(R1, 3),
5100 BPF_LD_IMM64(R2, 2),
5101 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
5102 BPF_EXIT_INSN(),
5103 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5104 BPF_EXIT_INSN(),
5105 },
5106 INTERNAL,
5107 { },
5108 { { 0, 1 } },
5109 },
c7395d6b
NR		 5110 {
5111 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
5112 .u.insns_int = {
5113 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5114 BPF_LD_IMM64(R1, -1),
5115 BPF_LD_IMM64(R2, 1),
5116 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
5117 BPF_EXIT_INSN(),
5118 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5119 BPF_EXIT_INSN(),
5120 },
5121 INTERNAL,
5122 { },
5123 { { 0, 1 } },
5124 },
92b31a9a
DB		 5125 /* BPF_JMP | BPF_JLT | BPF_X */
5126 {
5127 "JMP_JLT_X: if (2 < 3) return 1",
5128 .u.insns_int = {
5129 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5130 BPF_LD_IMM64(R1, 3),
5131 BPF_LD_IMM64(R2, 2),
5132 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
5133 BPF_EXIT_INSN(),
5134 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5135 BPF_EXIT_INSN(),
5136 },
5137 INTERNAL,
5138 { },
5139 { { 0, 1 } },
5140 },
5141 {
5142 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
5143 .u.insns_int = {
5144 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5145 BPF_LD_IMM64(R1, -1),
5146 BPF_LD_IMM64(R2, 1),
5147 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
5148 BPF_EXIT_INSN(),
5149 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5150 BPF_EXIT_INSN(),
5151 },
5152 INTERNAL,
5153 { },
5154 { { 0, 1 } },
5155 },
cffc642d
MH		 5156 /* BPF_JMP | BPF_JGE | BPF_X */
5157 {
5158 "JMP_JGE_X: if (3 >= 2) return 1",
5159 .u.insns_int = {
5160 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5161 BPF_LD_IMM64(R1, 3),
5162 BPF_LD_IMM64(R2, 2),
5163 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
5164 BPF_EXIT_INSN(),
5165 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5166 BPF_EXIT_INSN(),
5167 },
5168 INTERNAL,
5169 { },
5170 { { 0, 1 } },
5171 },
5172 {
5173 "JMP_JGE_X: if (3 >= 3) return 1",
5174 .u.insns_int = {
5175 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5176 BPF_LD_IMM64(R1, 3),
5177 BPF_LD_IMM64(R2, 3),
5178 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
5179 BPF_EXIT_INSN(),
5180 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5181 BPF_EXIT_INSN(),
5182 },
5183 INTERNAL,
5184 { },
5185 { { 0, 1 } },
5186 },
92b31a9a
DB		 5187 /* BPF_JMP | BPF_JLE | BPF_X */
5188 {
5189 "JMP_JLE_X: if (2 <= 3) return 1",
5190 .u.insns_int = {
5191 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5192 BPF_LD_IMM64(R1, 3),
5193 BPF_LD_IMM64(R2, 2),
5194 BPF_JMP_REG(BPF_JLE, R2, R1, 1),
5195 BPF_EXIT_INSN(),
5196 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5197 BPF_EXIT_INSN(),
5198 },
5199 INTERNAL,
5200 { },
5201 { { 0, 1 } },
5202 },
5203 {
5204 "JMP_JLE_X: if (3 <= 3) return 1",
5205 .u.insns_int = {
5206 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5207 BPF_LD_IMM64(R1, 3),
5208 BPF_LD_IMM64(R2, 3),
5209 BPF_JMP_REG(BPF_JLE, R1, R2, 1),
5210 BPF_EXIT_INSN(),
5211 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5212 BPF_EXIT_INSN(),
5213 },
5214 INTERNAL,
5215 { },
5216 { { 0, 1 } },
5217 },
ddc665a4
DB		 5218 {
5219 /* Mainly testing JIT + imm64 here. */
5220 "JMP_JGE_X: ldimm64 test 1",
5221 .u.insns_int = {
5222 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5223 BPF_LD_IMM64(R1, 3),
5224 BPF_LD_IMM64(R2, 2),
5225 BPF_JMP_REG(BPF_JGE, R1, R2, 2),
86f8e247
GU		 5226 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5227 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
ddc665a4
DB		 5228 BPF_EXIT_INSN(),
5229 },
5230 INTERNAL,
5231 { },
5232 { { 0, 0xeeeeeeeeU } },
5233 },
5234 {
5235 "JMP_JGE_X: ldimm64 test 2",
5236 .u.insns_int = {
5237 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5238 BPF_LD_IMM64(R1, 3),
5239 BPF_LD_IMM64(R2, 2),
5240 BPF_JMP_REG(BPF_JGE, R1, R2, 0),
86f8e247 5241 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
ddc665a4
DB		 5242 BPF_EXIT_INSN(),
5243 },
5244 INTERNAL,
5245 { },
5246 { { 0, 0xffffffffU } },
5247 },
5248 {
5249 "JMP_JGE_X: ldimm64 test 3",
5250 .u.insns_int = {
5251 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5252 BPF_LD_IMM64(R1, 3),
5253 BPF_LD_IMM64(R2, 2),
5254 BPF_JMP_REG(BPF_JGE, R1, R2, 4),
86f8e247
GU		 5255 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5256 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
ddc665a4
DB		 5257 BPF_EXIT_INSN(),
5258 },
5259 INTERNAL,
5260 { },
5261 { { 0, 1 } },
5262 },
92b31a9a
DB		 5263 {
5264 "JMP_JLE_X: ldimm64 test 1",
5265 .u.insns_int = {
5266 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5267 BPF_LD_IMM64(R1, 3),
5268 BPF_LD_IMM64(R2, 2),
5269 BPF_JMP_REG(BPF_JLE, R2, R1, 2),
5270 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5271 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
5272 BPF_EXIT_INSN(),
5273 },
5274 INTERNAL,
5275 { },
5276 { { 0, 0xeeeeeeeeU } },
5277 },
5278 {
5279 "JMP_JLE_X: ldimm64 test 2",
5280 .u.insns_int = {
5281 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5282 BPF_LD_IMM64(R1, 3),
5283 BPF_LD_IMM64(R2, 2),
5284 BPF_JMP_REG(BPF_JLE, R2, R1, 0),
5285 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5286 BPF_EXIT_INSN(),
5287 },
5288 INTERNAL,
5289 { },
5290 { { 0, 0xffffffffU } },
5291 },
5292 {
5293 "JMP_JLE_X: ldimm64 test 3",
5294 .u.insns_int = {
5295 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5296 BPF_LD_IMM64(R1, 3),
5297 BPF_LD_IMM64(R2, 2),
5298 BPF_JMP_REG(BPF_JLE, R2, R1, 4),
5299 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5300 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
5301 BPF_EXIT_INSN(),
5302 },
5303 INTERNAL,
5304 { },
5305 { { 0, 1 } },
5306 },
cffc642d
MH		 5307 /* BPF_JMP | BPF_JNE | BPF_X */
5308 {
5309 "JMP_JNE_X: if (3 != 2) return 1",
5310 .u.insns_int = {
5311 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5312 BPF_LD_IMM64(R1, 3),
5313 BPF_LD_IMM64(R2, 2),
5314 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
5315 BPF_EXIT_INSN(),
5316 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5317 BPF_EXIT_INSN(),
5318 },
5319 INTERNAL,
5320 { },
5321 { { 0, 1 } },
5322 },
5323 /* BPF_JMP | BPF_JEQ | BPF_X */
5324 {
5325 "JMP_JEQ_X: if (3 == 3) return 1",
5326 .u.insns_int = {
5327 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5328 BPF_LD_IMM64(R1, 3),
5329 BPF_LD_IMM64(R2, 3),
5330 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
5331 BPF_EXIT_INSN(),
5332 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5333 BPF_EXIT_INSN(),
5334 },
5335 INTERNAL,
5336 { },
5337 { { 0, 1 } },
5338 },
5339 /* BPF_JMP | BPF_JSET | BPF_X */
5340 {
5341 "JMP_JSET_X: if (0x3 & 0x2) return 1",
5342 .u.insns_int = {
5343 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5344 BPF_LD_IMM64(R1, 3),
5345 BPF_LD_IMM64(R2, 2),
9f134c34 5346 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
cffc642d
MH		 5347 BPF_EXIT_INSN(),
5348 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5349 BPF_EXIT_INSN(),
5350 },
5351 INTERNAL,
5352 { },
5353 { { 0, 1 } },
5354 },
5355 {
5356 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
5357 .u.insns_int = {
5358 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5359 BPF_LD_IMM64(R1, 3),
5360 BPF_LD_IMM64(R2, 0xffffffff),
9f134c34 5361 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
cffc642d
MH		 5362 BPF_EXIT_INSN(),
5363 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5364 BPF_EXIT_INSN(),
5365 },
5366 INTERNAL,
5367 { },
5368 { { 0, 1 } },
5369 },
bde28bc6
DB		 5370 {
5371 "JMP_JA: Jump, gap, jump, ...",
5372 { },
5373 CLASSIC | FLAG_NO_DATA,
5374 { },
5375 { { 0, 0xababcbac } },
5376 .fill_helper = bpf_fill_ja,
5377 },
a4afd37b
DB		 5378 { /* Mainly checking JIT here. */
5379 "BPF_MAXINSNS: Maximum possible literals",
5380 { },
5381 CLASSIC | FLAG_NO_DATA,
5382 { },
5383 { { 0, 0xffffffff } },
5384 .fill_helper = bpf_fill_maxinsns1,
5385 },
5386 { /* Mainly checking JIT here. */
5387 "BPF_MAXINSNS: Single literal",
5388 { },
5389 CLASSIC | FLAG_NO_DATA,
5390 { },
5391 { { 0, 0xfefefefe } },
5392 .fill_helper = bpf_fill_maxinsns2,
5393 },
5394 { /* Mainly checking JIT here. */
5395 "BPF_MAXINSNS: Run/add until end",
5396 { },
5397 CLASSIC | FLAG_NO_DATA,
5398 { },
5399 { { 0, 0x947bf368 } },
5400 .fill_helper = bpf_fill_maxinsns3,
5401 },
5402 {
5403 "BPF_MAXINSNS: Too many instructions",
5404 { },
5405 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
5406 { },
5407 { },
5408 .fill_helper = bpf_fill_maxinsns4,
f735fecf 5409 .expected_errcode = -EINVAL,
a4afd37b
DB		 5410 },
5411 { /* Mainly checking JIT here. */
5412 "BPF_MAXINSNS: Very long jump",
5413 { },
5414 CLASSIC | FLAG_NO_DATA,
5415 { },
5416 { { 0, 0xabababab } },
5417 .fill_helper = bpf_fill_maxinsns5,
5418 },
5419 { /* Mainly checking JIT here. */
5420 "BPF_MAXINSNS: Ctx heavy transformations",
5421 { },
5422 CLASSIC,
5423 { },
5424 {
5425 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
5426 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
5427 },
5428 .fill_helper = bpf_fill_maxinsns6,
5429 },
5430 { /* Mainly checking JIT here. */
5431 "BPF_MAXINSNS: Call heavy transformations",
5432 { },
5433 CLASSIC | FLAG_NO_DATA,
5434 { },
5435 { { 1, 0 }, { 10, 0 } },
5436 .fill_helper = bpf_fill_maxinsns7,
5437 },
5438 { /* Mainly checking JIT here. */
5439 "BPF_MAXINSNS: Jump heavy test",
5440 { },
5441 CLASSIC | FLAG_NO_DATA,
5442 { },
5443 { { 0, 0xffffffff } },
5444 .fill_helper = bpf_fill_maxinsns8,
5445 },
3b529602
DB		 5446 { /* Mainly checking JIT here. */
5447 "BPF_MAXINSNS: Very long jump backwards",
5448 { },
5449 INTERNAL | FLAG_NO_DATA,
5450 { },
5451 { { 0, 0xcbababab } },
5452 .fill_helper = bpf_fill_maxinsns9,
5453 },
5454 { /* Mainly checking JIT here. */
5455 "BPF_MAXINSNS: Edge hopping nuthouse",
5456 { },
5457 INTERNAL | FLAG_NO_DATA,
5458 { },
5459 { { 0, 0xabababac } },
5460 .fill_helper = bpf_fill_maxinsns10,
5461 },
bde28bc6
DB		 5462 {
5463 "BPF_MAXINSNS: Jump, gap, jump, ...",
5464 { },
32625984 5465#if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_X86)
f735fecf
YS		 5466 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
5467#else
bde28bc6 5468 CLASSIC | FLAG_NO_DATA,
f735fecf 5469#endif
bde28bc6
DB		 5470 { },
5471 { { 0, 0xababcbac } },
5472 .fill_helper = bpf_fill_maxinsns11,
f735fecf 5473 .expected_errcode = -ENOTSUPP,
bde28bc6 5474 },
4d9c5c53
AS		 5475 {
5476 "BPF_MAXINSNS: ld_abs+get_processor_id",
5477 { },
5478 CLASSIC,
5479 { },
5480 { { 1, 0xbee } },
5481 .fill_helper = bpf_fill_ld_abs_get_processor_id,
5482 },
5483 {
5484 "BPF_MAXINSNS: ld_abs+vlan_push/pop",
5485 { },
5486 INTERNAL,
5487 { 0x34 },
0d906b1e 5488 { { ETH_HLEN, 0xbef } },
4d9c5c53
AS		 5489 .fill_helper = bpf_fill_ld_abs_vlan_push_pop,
5490 },
b7127cfe
DD		 5491 {
5492 "BPF_MAXINSNS: jump around ld_abs",
5493 { },
5494 INTERNAL,
5495 { 10, 11 },
5496 { { 2, 10 } },
5497 .fill_helper = bpf_fill_jump_around_ld_abs,
5498 },
2cf1ad75
NS		 5499 /*
5500 * LD_IND / LD_ABS on fragmented SKBs
5501 */
5502 {
5503 "LD_IND byte frag",
5504 .u.insns = {
5505 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5506 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
5507 BPF_STMT(BPF_RET | BPF_A, 0x0),
5508 },
5509 CLASSIC | FLAG_SKB_FRAG,
5510 { },
5511 { {0x40, 0x42} },
5512 .frag_data = {
5513 0x42, 0x00, 0x00, 0x00,
5514 0x43, 0x44, 0x00, 0x00,
5515 0x21, 0x07, 0x19, 0x83,
5516 },
5517 },
5518 {
5519 "LD_IND halfword frag",
5520 .u.insns = {
5521 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5522 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
5523 BPF_STMT(BPF_RET | BPF_A, 0x0),
5524 },
5525 CLASSIC | FLAG_SKB_FRAG,
5526 { },
5527 { {0x40, 0x4344} },
5528 .frag_data = {
5529 0x42, 0x00, 0x00, 0x00,
5530 0x43, 0x44, 0x00, 0x00,
5531 0x21, 0x07, 0x19, 0x83,
5532 },
5533 },
5534 {
5535 "LD_IND word frag",
5536 .u.insns = {
5537 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5538 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
5539 BPF_STMT(BPF_RET | BPF_A, 0x0),
5540 },
5541 CLASSIC | FLAG_SKB_FRAG,
5542 { },
5543 { {0x40, 0x21071983} },
5544 .frag_data = {
5545 0x42, 0x00, 0x00, 0x00,
5546 0x43, 0x44, 0x00, 0x00,
5547 0x21, 0x07, 0x19, 0x83,
5548 },
5549 },
5550 {
5551 "LD_IND halfword mixed head/frag",
5552 .u.insns = {
5553 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5554 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
5555 BPF_STMT(BPF_RET | BPF_A, 0x0),
5556 },
5557 CLASSIC | FLAG_SKB_FRAG,
5558 { [0x3e] = 0x25, [0x3f] = 0x05, },
5559 { {0x40, 0x0519} },
5560 .frag_data = { 0x19, 0x82 },
5561 },
5562 {
5563 "LD_IND word mixed head/frag",
5564 .u.insns = {
5565 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5566 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
5567 BPF_STMT(BPF_RET | BPF_A, 0x0),
5568 },
5569 CLASSIC | FLAG_SKB_FRAG,
5570 { [0x3e] = 0x25, [0x3f] = 0x05, },
5571 { {0x40, 0x25051982} },
5572 .frag_data = { 0x19, 0x82 },
5573 },
5574 {
5575 "LD_ABS byte frag",
5576 .u.insns = {
5577 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
5578 BPF_STMT(BPF_RET | BPF_A, 0x0),
5579 },
5580 CLASSIC | FLAG_SKB_FRAG,
5581 { },
5582 { {0x40, 0x42} },
5583 .frag_data = {
5584 0x42, 0x00, 0x00, 0x00,
5585 0x43, 0x44, 0x00, 0x00,
5586 0x21, 0x07, 0x19, 0x83,
5587 },
5588 },
5589 {
5590 "LD_ABS halfword frag",
5591 .u.insns = {
5592 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
5593 BPF_STMT(BPF_RET | BPF_A, 0x0),
5594 },
5595 CLASSIC | FLAG_SKB_FRAG,
5596 { },
5597 { {0x40, 0x4344} },
5598 .frag_data = {
5599 0x42, 0x00, 0x00, 0x00,
5600 0x43, 0x44, 0x00, 0x00,
5601 0x21, 0x07, 0x19, 0x83,
5602 },
5603 },
5604 {
5605 "LD_ABS word frag",
5606 .u.insns = {
5607 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
5608 BPF_STMT(BPF_RET | BPF_A, 0x0),
5609 },
5610 CLASSIC | FLAG_SKB_FRAG,
5611 { },
5612 { {0x40, 0x21071983} },
5613 .frag_data = {
5614 0x42, 0x00, 0x00, 0x00,
5615 0x43, 0x44, 0x00, 0x00,
5616 0x21, 0x07, 0x19, 0x83,
5617 },
5618 },
5619 {
5620 "LD_ABS halfword mixed head/frag",
5621 .u.insns = {
5622 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
5623 BPF_STMT(BPF_RET | BPF_A, 0x0),
5624 },
5625 CLASSIC | FLAG_SKB_FRAG,
5626 { [0x3e] = 0x25, [0x3f] = 0x05, },
5627 { {0x40, 0x0519} },
5628 .frag_data = { 0x19, 0x82 },
5629 },
5630 {
5631 "LD_ABS word mixed head/frag",
5632 .u.insns = {
5633 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
5634 BPF_STMT(BPF_RET | BPF_A, 0x0),
5635 },
5636 CLASSIC | FLAG_SKB_FRAG,
5637 { [0x3e] = 0x25, [0x3f] = 0x05, },
5638 { {0x40, 0x25051982} },
5639 .frag_data = { 0x19, 0x82 },
5640 },
08fcb08f
NS		 5641 /*
5642 * LD_IND / LD_ABS on non fragmented SKBs
5643 */
5644 {
5645 /*
5646 * this tests that the JIT/interpreter correctly resets X
5647 * before using it in an LD_IND instruction.
5648 */
5649 "LD_IND byte default X",
5650 .u.insns = {
5651 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
5652 BPF_STMT(BPF_RET | BPF_A, 0x0),
5653 },
5654 CLASSIC,
5655 { [0x1] = 0x42 },
5656 { {0x40, 0x42 } },
5657 },
5658 {
5659 "LD_IND byte positive offset",
5660 .u.insns = {
5661 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
5662 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
5663 BPF_STMT(BPF_RET | BPF_A, 0x0),
5664 },
5665 CLASSIC,
5666 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5667 { {0x40, 0x82 } },
5668 },
5669 {
5670 "LD_IND byte negative offset",
5671 .u.insns = {
5672 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
5673 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
5674 BPF_STMT(BPF_RET | BPF_A, 0x0),
5675 },
5676 CLASSIC,
5677 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5678 { {0x40, 0x05 } },
5679 },
5680 {
5681 "LD_IND halfword positive offset",
5682 .u.insns = {
5683 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5684 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
5685 BPF_STMT(BPF_RET | BPF_A, 0x0),
5686 },
5687 CLASSIC,
5688 {
5689 [0x1c] = 0xaa, [0x1d] = 0x55,
5690 [0x1e] = 0xbb, [0x1f] = 0x66,
5691 [0x20] = 0xcc, [0x21] = 0x77,
5692 [0x22] = 0xdd, [0x23] = 0x88,
5693 },
5694 { {0x40, 0xdd88 } },
5695 },
5696 {
5697 "LD_IND halfword negative offset",
5698 .u.insns = {
5699 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5700 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
5701 BPF_STMT(BPF_RET | BPF_A, 0x0),
5702 },
5703 CLASSIC,
5704 {
5705 [0x1c] = 0xaa, [0x1d] = 0x55,
5706 [0x1e] = 0xbb, [0x1f] = 0x66,
5707 [0x20] = 0xcc, [0x21] = 0x77,
5708 [0x22] = 0xdd, [0x23] = 0x88,
5709 },
5710 { {0x40, 0xbb66 } },
5711 },
5712 {
5713 "LD_IND halfword unaligned",
5714 .u.insns = {
5715 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5716 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
5717 BPF_STMT(BPF_RET | BPF_A, 0x0),
5718 },
5719 CLASSIC,
5720 {
5721 [0x1c] = 0xaa, [0x1d] = 0x55,
5722 [0x1e] = 0xbb, [0x1f] = 0x66,
5723 [0x20] = 0xcc, [0x21] = 0x77,
5724 [0x22] = 0xdd, [0x23] = 0x88,
5725 },
5726 { {0x40, 0x66cc } },
5727 },
5728 {
5729 "LD_IND word positive offset",
5730 .u.insns = {
5731 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5732 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
5733 BPF_STMT(BPF_RET | BPF_A, 0x0),
5734 },
5735 CLASSIC,
5736 {
5737 [0x1c] = 0xaa, [0x1d] = 0x55,
5738 [0x1e] = 0xbb, [0x1f] = 0x66,
5739 [0x20] = 0xcc, [0x21] = 0x77,
5740 [0x22] = 0xdd, [0x23] = 0x88,
5741 [0x24] = 0xee, [0x25] = 0x99,
5742 [0x26] = 0xff, [0x27] = 0xaa,
5743 },
5744 { {0x40, 0xee99ffaa } },
5745 },
5746 {
5747 "LD_IND word negative offset",
5748 .u.insns = {
5749 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5750 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
5751 BPF_STMT(BPF_RET | BPF_A, 0x0),
5752 },
5753 CLASSIC,
5754 {
5755 [0x1c] = 0xaa, [0x1d] = 0x55,
5756 [0x1e] = 0xbb, [0x1f] = 0x66,
5757 [0x20] = 0xcc, [0x21] = 0x77,
5758 [0x22] = 0xdd, [0x23] = 0x88,
5759 [0x24] = 0xee, [0x25] = 0x99,
5760 [0x26] = 0xff, [0x27] = 0xaa,
5761 },
5762 { {0x40, 0xaa55bb66 } },
5763 },
5764 {
5765 "LD_IND word unaligned (addr & 3 == 2)",
5766 .u.insns = {
5767 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5768 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
5769 BPF_STMT(BPF_RET | BPF_A, 0x0),
5770 },
5771 CLASSIC,
5772 {
5773 [0x1c] = 0xaa, [0x1d] = 0x55,
5774 [0x1e] = 0xbb, [0x1f] = 0x66,
5775 [0x20] = 0xcc, [0x21] = 0x77,
5776 [0x22] = 0xdd, [0x23] = 0x88,
5777 [0x24] = 0xee, [0x25] = 0x99,
5778 [0x26] = 0xff, [0x27] = 0xaa,
5779 },
5780 { {0x40, 0xbb66cc77 } },
5781 },
5782 {
5783 "LD_IND word unaligned (addr & 3 == 1)",
5784 .u.insns = {
5785 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5786 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
5787 BPF_STMT(BPF_RET | BPF_A, 0x0),
5788 },
5789 CLASSIC,
5790 {
5791 [0x1c] = 0xaa, [0x1d] = 0x55,
5792 [0x1e] = 0xbb, [0x1f] = 0x66,
5793 [0x20] = 0xcc, [0x21] = 0x77,
5794 [0x22] = 0xdd, [0x23] = 0x88,
5795 [0x24] = 0xee, [0x25] = 0x99,
5796 [0x26] = 0xff, [0x27] = 0xaa,
5797 },
5798 { {0x40, 0x55bb66cc } },
5799 },
5800 {
5801 "LD_IND word unaligned (addr & 3 == 3)",
5802 .u.insns = {
5803 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5804 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
5805 BPF_STMT(BPF_RET | BPF_A, 0x0),
5806 },
5807 CLASSIC,
5808 {
5809 [0x1c] = 0xaa, [0x1d] = 0x55,
5810 [0x1e] = 0xbb, [0x1f] = 0x66,
5811 [0x20] = 0xcc, [0x21] = 0x77,
5812 [0x22] = 0xdd, [0x23] = 0x88,
5813 [0x24] = 0xee, [0x25] = 0x99,
5814 [0x26] = 0xff, [0x27] = 0xaa,
5815 },
5816 { {0x40, 0x66cc77dd } },
5817 },
5818 {
5819 "LD_ABS byte",
5820 .u.insns = {
5821 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
5822 BPF_STMT(BPF_RET | BPF_A, 0x0),
5823 },
5824 CLASSIC,
5825 {
5826 [0x1c] = 0xaa, [0x1d] = 0x55,
5827 [0x1e] = 0xbb, [0x1f] = 0x66,
5828 [0x20] = 0xcc, [0x21] = 0x77,
5829 [0x22] = 0xdd, [0x23] = 0x88,
5830 [0x24] = 0xee, [0x25] = 0x99,
5831 [0x26] = 0xff, [0x27] = 0xaa,
5832 },
5833 { {0x40, 0xcc } },
5834 },
5835 {
5836 "LD_ABS halfword",
5837 .u.insns = {
5838 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
5839 BPF_STMT(BPF_RET | BPF_A, 0x0),
5840 },
5841 CLASSIC,
5842 {
5843 [0x1c] = 0xaa, [0x1d] = 0x55,
5844 [0x1e] = 0xbb, [0x1f] = 0x66,
5845 [0x20] = 0xcc, [0x21] = 0x77,
5846 [0x22] = 0xdd, [0x23] = 0x88,
5847 [0x24] = 0xee, [0x25] = 0x99,
5848 [0x26] = 0xff, [0x27] = 0xaa,
5849 },
5850 { {0x40, 0xdd88 } },
5851 },
5852 {
5853 "LD_ABS halfword unaligned",
5854 .u.insns = {
5855 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
5856 BPF_STMT(BPF_RET | BPF_A, 0x0),
5857 },
5858 CLASSIC,
5859 {
5860 [0x1c] = 0xaa, [0x1d] = 0x55,
5861 [0x1e] = 0xbb, [0x1f] = 0x66,
5862 [0x20] = 0xcc, [0x21] = 0x77,
5863 [0x22] = 0xdd, [0x23] = 0x88,
5864 [0x24] = 0xee, [0x25] = 0x99,
5865 [0x26] = 0xff, [0x27] = 0xaa,
5866 },
5867 { {0x40, 0x99ff } },
5868 },
5869 {
5870 "LD_ABS word",
5871 .u.insns = {
5872 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
5873 BPF_STMT(BPF_RET | BPF_A, 0x0),
5874 },
5875 CLASSIC,
5876 {
5877 [0x1c] = 0xaa, [0x1d] = 0x55,
5878 [0x1e] = 0xbb, [0x1f] = 0x66,
5879 [0x20] = 0xcc, [0x21] = 0x77,
5880 [0x22] = 0xdd, [0x23] = 0x88,
5881 [0x24] = 0xee, [0x25] = 0x99,
5882 [0x26] = 0xff, [0x27] = 0xaa,
5883 },
5884 { {0x40, 0xaa55bb66 } },
5885 },
5886 {
5887 "LD_ABS word unaligned (addr & 3 == 2)",
5888 .u.insns = {
5889 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
5890 BPF_STMT(BPF_RET | BPF_A, 0x0),
5891 },
5892 CLASSIC,
5893 {
5894 [0x1c] = 0xaa, [0x1d] = 0x55,
5895 [0x1e] = 0xbb, [0x1f] = 0x66,
5896 [0x20] = 0xcc, [0x21] = 0x77,
5897 [0x22] = 0xdd, [0x23] = 0x88,
5898 [0x24] = 0xee, [0x25] = 0x99,
5899 [0x26] = 0xff, [0x27] = 0xaa,
5900 },
5901 { {0x40, 0xdd88ee99 } },
5902 },
5903 {
5904 "LD_ABS word unaligned (addr & 3 == 1)",
5905 .u.insns = {
5906 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
5907 BPF_STMT(BPF_RET | BPF_A, 0x0),
5908 },
5909 CLASSIC,
5910 {
5911 [0x1c] = 0xaa, [0x1d] = 0x55,
5912 [0x1e] = 0xbb, [0x1f] = 0x66,
5913 [0x20] = 0xcc, [0x21] = 0x77,
5914 [0x22] = 0xdd, [0x23] = 0x88,
5915 [0x24] = 0xee, [0x25] = 0x99,
5916 [0x26] = 0xff, [0x27] = 0xaa,
5917 },
5918 { {0x40, 0x77dd88ee } },
5919 },
5920 {
5921 "LD_ABS word unaligned (addr & 3 == 3)",
5922 .u.insns = {
5923 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
5924 BPF_STMT(BPF_RET | BPF_A, 0x0),
5925 },
5926 CLASSIC,
5927 {
5928 [0x1c] = 0xaa, [0x1d] = 0x55,
5929 [0x1e] = 0xbb, [0x1f] = 0x66,
5930 [0x20] = 0xcc, [0x21] = 0x77,
5931 [0x22] = 0xdd, [0x23] = 0x88,
5932 [0x24] = 0xee, [0x25] = 0x99,
5933 [0x26] = 0xff, [0x27] = 0xaa,
5934 },
5935 { {0x40, 0x88ee99ff } },
5936 },
86bf1721
NS		 5937 /*
5938 * verify that the interpreter or JIT correctly sets A and X
5939 * to 0.
5940 */
5941 {
5942 "ADD default X",
5943 .u.insns = {
5944 /*
5945 * A = 0x42
5946 * A = A + X
5947 * ret A
5948 */
5949 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5950 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
5951 BPF_STMT(BPF_RET | BPF_A, 0x0),
5952 },
5953 CLASSIC | FLAG_NO_DATA,
5954 {},
5955 { {0x1, 0x42 } },
5956 },
5957 {
5958 "ADD default A",
5959 .u.insns = {
5960 /*
5961 * A = A + 0x42
5962 * ret A
5963 */
5964 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
5965 BPF_STMT(BPF_RET | BPF_A, 0x0),
5966 },
5967 CLASSIC | FLAG_NO_DATA,
5968 {},
5969 { {0x1, 0x42 } },
5970 },
5971 {
5972 "SUB default X",
5973 .u.insns = {
5974 /*
5975 * A = 0x66
5976 * A = A - X
5977 * ret A
5978 */
5979 BPF_STMT(BPF_LD | BPF_IMM, 0x66),
5980 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
5981 BPF_STMT(BPF_RET | BPF_A, 0x0),
5982 },
5983 CLASSIC | FLAG_NO_DATA,
5984 {},
5985 { {0x1, 0x66 } },
5986 },
5987 {
5988 "SUB default A",
5989 .u.insns = {
5990 /*
5991 * A = A - -0x66
5992 * ret A
5993 */
5994 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
5995 BPF_STMT(BPF_RET | BPF_A, 0x0),
5996 },
5997 CLASSIC | FLAG_NO_DATA,
5998 {},
5999 { {0x1, 0x66 } },
6000 },
6001 {
6002 "MUL default X",
6003 .u.insns = {
6004 /*
6005 * A = 0x42
6006 * A = A * X
6007 * ret A
6008 */
6009 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
6010 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
6011 BPF_STMT(BPF_RET | BPF_A, 0x0),
6012 },
6013 CLASSIC | FLAG_NO_DATA,
6014 {},
6015 { {0x1, 0x0 } },
6016 },
6017 {
6018 "MUL default A",
6019 .u.insns = {
6020 /*
6021 * A = A * 0x66
6022 * ret A
6023 */
6024 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
6025 BPF_STMT(BPF_RET | BPF_A, 0x0),
6026 },
6027 CLASSIC | FLAG_NO_DATA,
6028 {},
6029 { {0x1, 0x0 } },
6030 },
6031 {
6032 "DIV default X",
6033 .u.insns = {
6034 /*
6035 * A = 0x42
6036 * A = A / X ; this halt the filter execution if X is 0
6037 * ret 0x42
6038 */
6039 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
6040 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
6041 BPF_STMT(BPF_RET | BPF_K, 0x42),
6042 },
6043 CLASSIC | FLAG_NO_DATA,
6044 {},
6045 { {0x1, 0x0 } },
6046 },
6047 {
6048 "DIV default A",
6049 .u.insns = {
6050 /*
6051 * A = A / 1
6052 * ret A
6053 */
6054 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
6055 BPF_STMT(BPF_RET | BPF_A, 0x0),
6056 },
6057 CLASSIC | FLAG_NO_DATA,
6058 {},
6059 { {0x1, 0x0 } },
6060 },
d4e4bc16
YS		 6061 {
6062 "MOD default X",
6063 .u.insns = {
6064 /*
6065 * A = 0x42
6066 * A = A mod X ; this halt the filter execution if X is 0
6067 * ret 0x42
6068 */
6069 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
6070 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
6071 BPF_STMT(BPF_RET | BPF_K, 0x42),
6072 },
6073 CLASSIC | FLAG_NO_DATA,
6074 {},
6075 { {0x1, 0x0 } },
6076 },
6077 {
6078 "MOD default A",
6079 .u.insns = {
6080 /*
6081 * A = A mod 1
6082 * ret A
6083 */
6084 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
6085 BPF_STMT(BPF_RET | BPF_A, 0x0),
6086 },
6087 CLASSIC | FLAG_NO_DATA,
6088 {},
6089 { {0x1, 0x0 } },
6090 },
86bf1721
NS		 6091 {
6092 "JMP EQ default A",
6093 .u.insns = {
6094 /*
6095 * cmp A, 0x0, 0, 1
6096 * ret 0x42
6097 * ret 0x66
6098 */
6099 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
6100 BPF_STMT(BPF_RET | BPF_K, 0x42),
6101 BPF_STMT(BPF_RET | BPF_K, 0x66),
6102 },
6103 CLASSIC | FLAG_NO_DATA,
6104 {},
6105 { {0x1, 0x42 } },
6106 },
6107 {
6108 "JMP EQ default X",
6109 .u.insns = {
6110 /*
6111 * A = 0x0
6112 * cmp A, X, 0, 1
6113 * ret 0x42
6114 * ret 0x66
6115 */
6116 BPF_STMT(BPF_LD | BPF_IMM, 0x0),
6117 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
6118 BPF_STMT(BPF_RET | BPF_K, 0x42),
6119 BPF_STMT(BPF_RET | BPF_K, 0x66),
6120 },
6121 CLASSIC | FLAG_NO_DATA,
6122 {},
6123 { {0x1, 0x42 } },
6124 },
87ab8194
DB		 6125 {
6126 "LD_ABS with helper changing skb data",
6127 { },
6128 INTERNAL,
6129 { 0x34 },
6130 { { ETH_HLEN, 42 } },
6131 .fill_helper = bpf_fill_ld_abs_vlan_push_pop2,
6132 },
64a8946b
AS		 6133};
6134
10f18e0b 6135static struct net_device dev;
64a8946b 6136
10f18e0b 6137static struct sk_buff *populate_skb(char *buf, int size)
64a8946b
AS		 6138{
6139 struct sk_buff *skb;
6140
6141 if (size >= MAX_DATA)
6142 return NULL;
6143
6144 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
6145 if (!skb)
6146 return NULL;
6147
de77b966 6148 __skb_put_data(skb, buf, size);
10f18e0b
DB		 6149
6150 /* Initialize a fake skb with test pattern. */
64a8946b
AS		 6151 skb_reset_mac_header(skb);
6152 skb->protocol = htons(ETH_P_IP);
6153 skb->pkt_type = SKB_TYPE;
6154 skb->mark = SKB_MARK;
6155 skb->hash = SKB_HASH;
6156 skb->queue_mapping = SKB_QUEUE_MAP;
6157 skb->vlan_tci = SKB_VLAN_TCI;
5c0ca3f5 6158 skb->vlan_proto = htons(ETH_P_IP);
64a8946b
AS		 6159 skb->dev = &dev;
6160 skb->dev->ifindex = SKB_DEV_IFINDEX;
6161 skb->dev->type = SKB_DEV_TYPE;
6162 skb_set_network_header(skb, min(size, ETH_HLEN));
6163
6164 return skb;
6165}
6166
10f18e0b 6167static void *generate_test_data(struct bpf_test *test, int sub)
64a8946b 6168{
bac142ac
NS		 6169 struct sk_buff *skb;
6170 struct page *page;
6171
10f18e0b
DB		 6172 if (test->aux & FLAG_NO_DATA)
6173 return NULL;
64a8946b 6174
10f18e0b
DB		 6175 /* Test case expects an skb, so populate one. Various
6176 * subtests generate skbs of different sizes based on
6177 * the same data.
6178 */
bac142ac
NS		 6179 skb = populate_skb(test->data, test->test[sub].data_size);
6180 if (!skb)
6181 return NULL;
6182
6183 if (test->aux & FLAG_SKB_FRAG) {
6184 /*
6185 * when the test requires a fragmented skb, add a
6186 * single fragment to the skb, filled with
6187 * test->frag_data.
6188 */
6189 void *ptr;
6190
6191 page = alloc_page(GFP_KERNEL);
6192
6193 if (!page)
6194 goto err_kfree_skb;
6195
6196 ptr = kmap(page);
6197 if (!ptr)
6198 goto err_free_page;
6199 memcpy(ptr, test->frag_data, MAX_DATA);
6200 kunmap(page);
6201 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
6202 }
6203
6204 return skb;
6205
6206err_free_page:
6207 __free_page(page);
6208err_kfree_skb:
6209 kfree_skb(skb);
6210 return NULL;
10f18e0b
DB		 6211}
6212
6213static void release_test_data(const struct bpf_test *test, void *data)
6214{
6215 if (test->aux & FLAG_NO_DATA)
6216 return;
6217
6218 kfree_skb(data);
6219}
6220
a4afd37b 6221static int filter_length(int which)
10f18e0b 6222{
a4afd37b
DB		 6223 struct sock_filter *fp;
6224 int len;
10f18e0b 6225
a4afd37b
DB		 6226 if (tests[which].fill_helper)
6227 return tests[which].u.ptr.len;
6228
6229 fp = tests[which].u.insns;
e9d94504
CG		 6230 for (len = MAX_INSNS - 1; len > 0; --len)
6231 if (fp[len].code != 0 || fp[len].k != 0)
6232 break;
10f18e0b 6233
e9d94504 6234 return len + 1;
10f18e0b
DB		 6235}
6236
a4afd37b
DB		 6237static void *filter_pointer(int which)
6238{
6239 if (tests[which].fill_helper)
6240 return tests[which].u.ptr.insns;
6241 else
6242 return tests[which].u.insns;
6243}
6244
7ae457c1 6245static struct bpf_prog *generate_filter(int which, int *err)
10f18e0b 6246{
10f18e0b 6247 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
a4afd37b
DB		 6248 unsigned int flen = filter_length(which);
6249 void *fptr = filter_pointer(which);
6250 struct sock_fprog_kern fprog;
6251 struct bpf_prog *fp;
10f18e0b
DB		 6252
6253 switch (test_type) {
6254 case CLASSIC:
a4afd37b 6255 fprog.filter = fptr;
10f18e0b
DB		 6256 fprog.len = flen;
6257
7ae457c1 6258 *err = bpf_prog_create(&fp, &fprog);
10f18e0b 6259 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
f735fecf 6260 if (*err == tests[which].expected_errcode) {
10f18e0b
DB		 6261 pr_cont("PASS\n");
6262 /* Verifier rejected filter as expected. */
6263 *err = 0;
6264 return NULL;
6265 } else {
6266 pr_cont("UNEXPECTED_PASS\n");
6267 /* Verifier didn't reject the test that's
6268 * bad enough, just return!
6269 */
6270 *err = -EINVAL;
6271 return NULL;
6272 }
6273 }
10f18e0b 6274 if (*err) {
290af866 6275 pr_cont("FAIL to prog_create err=%d len=%d\n",
10f18e0b
DB		 6276 *err, fprog.len);
6277 return NULL;
6278 }
6279 break;
6280
6281 case INTERNAL:
60a3b225 6282 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
10f18e0b
DB		 6283 if (fp == NULL) {
6284 pr_cont("UNEXPECTED_FAIL no memory left\n");
6285 *err = -ENOMEM;
6286 return NULL;
64a8946b
AS		 6287 }
6288
10f18e0b 6289 fp->len = flen;
4962fa10
DB		 6290 /* Type doesn't really matter here as long as it's not unspec. */
6291 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
a4afd37b 6292 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
105c0361 6293 fp->aux->stack_depth = tests[which].stack_depth;
64a8946b 6294
d1c55ab5
DB		 6295 /* We cannot error here as we don't need type compatibility
6296 * checks.
6297 */
6298 fp = bpf_prog_select_runtime(fp, err);
290af866
AS		 6299 if (*err) {
6300 pr_cont("FAIL to select_runtime err=%d\n", *err);
6301 return NULL;
6302 }
10f18e0b
DB		 6303 break;
6304 }
64a8946b 6305
10f18e0b
DB		 6306 *err = 0;
6307 return fp;
6308}
64a8946b 6309
7ae457c1 6310static void release_filter(struct bpf_prog *fp, int which)
10f18e0b
DB		 6311{
6312 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
64a8946b 6313
10f18e0b
DB		 6314 switch (test_type) {
6315 case CLASSIC:
7ae457c1 6316 bpf_prog_destroy(fp);
10f18e0b
DB		 6317 break;
6318 case INTERNAL:
7ae457c1 6319 bpf_prog_free(fp);
10f18e0b
DB		 6320 break;
6321 }
6322}
6323
7ae457c1 6324static int __run_one(const struct bpf_prog *fp, const void *data,
10f18e0b
DB		 6325 int runs, u64 *duration)
6326{
6327 u64 start, finish;
25ee7327 6328 int ret = 0, i;
10f18e0b 6329
4d9c5c53 6330 start = ktime_get_ns();
10f18e0b
DB		 6331
6332 for (i = 0; i < runs; i++)
7ae457c1 6333 ret = BPF_PROG_RUN(fp, data);
10f18e0b 6334
4d9c5c53 6335 finish = ktime_get_ns();
10f18e0b 6336
4d9c5c53 6337 *duration = finish - start;
10f18e0b
DB		 6338 do_div(*duration, runs);
6339
6340 return ret;
6341}
6342
7ae457c1 6343static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
10f18e0b
DB		 6344{
6345 int err_cnt = 0, i, runs = MAX_TESTRUNS;
6346
6347 for (i = 0; i < MAX_SUBTESTS; i++) {
6348 void *data;
6349 u64 duration;
6350 u32 ret;
6351
6352 if (test->test[i].data_size == 0 &&
6353 test->test[i].result == 0)
6354 break;
6355
6356 data = generate_test_data(test, i);
e34684f8
NS		 6357 if (!data && !(test->aux & FLAG_NO_DATA)) {
6358 pr_cont("data generation failed ");
6359 err_cnt++;
6360 break;
6361 }
10f18e0b
DB		 6362 ret = __run_one(fp, data, runs, &duration);
6363 release_test_data(test, data);
6364
6365 if (ret == test->test[i].result) {
6366 pr_cont("%lld ", duration);
6367 } else {
6368 pr_cont("ret %d != %d ", ret,
6369 test->test[i].result);
64a8946b
AS		 6370 err_cnt++;
6371 }
6372 }
6373
6374 return err_cnt;
6375}
6376
d2648d4e
NS		 6377static char test_name[64];
6378module_param_string(test_name, test_name, sizeof(test_name), 0);
6379
6380static int test_id = -1;
6381module_param(test_id, int, 0);
6382
6383static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
6384module_param_array(test_range, int, NULL, 0);
6385
6386static __init int find_test_index(const char *test_name)
6387{
6388 int i;
6389
6390 for (i = 0; i < ARRAY_SIZE(tests); i++) {
6391 if (!strcmp(tests[i].descr, test_name))
6392 return i;
6393 }
6394 return -1;
6395}
6396
a4afd37b
DB		 6397static __init int prepare_bpf_tests(void)
6398{
6399 int i;
6400
d2648d4e
NS		 6401 if (test_id >= 0) {
6402 /*
6403 * if a test_id was specified, use test_range to
6404 * cover only that test.
6405 */
6406 if (test_id >= ARRAY_SIZE(tests)) {
6407 pr_err("test_bpf: invalid test_id specified.\n");
6408 return -EINVAL;
6409 }
6410
6411 test_range[0] = test_id;
6412 test_range[1] = test_id;
6413 } else if (*test_name) {
6414 /*
6415 * if a test_name was specified, find it and setup
6416 * test_range to cover only that test.
6417 */
6418 int idx = find_test_index(test_name);
6419
6420 if (idx < 0) {
6421 pr_err("test_bpf: no test named '%s' found.\n",
6422 test_name);
6423 return -EINVAL;
6424 }
6425 test_range[0] = idx;
6426 test_range[1] = idx;
6427 } else {
6428 /*
6429 * check that the supplied test_range is valid.
6430 */
6431 if (test_range[0] >= ARRAY_SIZE(tests) ||
6432 test_range[1] >= ARRAY_SIZE(tests) ||
6433 test_range[0] < 0 || test_range[1] < 0) {
6434 pr_err("test_bpf: test_range is out of bound.\n");
6435 return -EINVAL;
6436 }
6437
6438 if (test_range[1] < test_range[0]) {
6439 pr_err("test_bpf: test_range is ending before it starts.\n");
6440 return -EINVAL;
6441 }
6442 }
6443
a4afd37b
DB		 6444 for (i = 0; i < ARRAY_SIZE(tests); i++) {
6445 if (tests[i].fill_helper &&
6446 tests[i].fill_helper(&tests[i]) < 0)
6447 return -ENOMEM;
6448 }
6449
6450 return 0;
6451}
6452
6453static __init void destroy_bpf_tests(void)
6454{
6455 int i;
6456
6457 for (i = 0; i < ARRAY_SIZE(tests); i++) {
6458 if (tests[i].fill_helper)
6459 kfree(tests[i].u.ptr.insns);
6460 }
6461}
6462
d2648d4e
NS		 6463static bool exclude_test(int test_id)
6464{
6465 return test_id < test_range[0] || test_id > test_range[1];
6466}
6467
64a8946b
AS		 6468static __init int test_bpf(void)
6469{
10f18e0b 6470 int i, err_cnt = 0, pass_cnt = 0;
327941f8 6471 int jit_cnt = 0, run_cnt = 0;
64a8946b
AS		 6472
6473 for (i = 0; i < ARRAY_SIZE(tests); i++) {
7ae457c1 6474 struct bpf_prog *fp;
10f18e0b 6475 int err;
64a8946b 6476
d2648d4e
NS		 6477 if (exclude_test(i))
6478 continue;
6479
10f18e0b 6480 pr_info("#%d %s ", i, tests[i].descr);
64a8946b 6481
10f18e0b
DB		 6482 fp = generate_filter(i, &err);
6483 if (fp == NULL) {
6484 if (err == 0) {
6485 pass_cnt++;
6486 continue;
64a8946b 6487 }
290af866
AS		 6488 err_cnt++;
6489 continue;
10f18e0b 6490 }
327941f8
DB		 6491
6492 pr_cont("jited:%u ", fp->jited);
6493
6494 run_cnt++;
6495 if (fp->jited)
6496 jit_cnt++;
6497
64a8946b 6498 err = run_one(fp, &tests[i]);
10f18e0b 6499 release_filter(fp, i);
64a8946b
AS		 6500
6501 if (err) {
10f18e0b 6502 pr_cont("FAIL (%d times)\n", err);
64a8946b
AS		 6503 err_cnt++;
6504 } else {
6505 pr_cont("PASS\n");
10f18e0b 6506 pass_cnt++;
64a8946b
AS		 6507 }
6508 }
6509
327941f8
DB		 6510 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
6511 pass_cnt, err_cnt, jit_cnt, run_cnt);
6512
10f18e0b 6513 return err_cnt ? -EINVAL : 0;
64a8946b
AS		 6514}
6515
6516static int __init test_bpf_init(void)
6517{
a4afd37b
DB		 6518 int ret;
6519
6520 ret = prepare_bpf_tests();
6521 if (ret < 0)
6522 return ret;
6523
6524 ret = test_bpf();
6525
6526 destroy_bpf_tests();
6527 return ret;
64a8946b
AS		 6528}
6529
6530static void __exit test_bpf_exit(void)
6531{
6532}
6533
6534module_init(test_bpf_init);
6535module_exit(test_bpf_exit);
10f18e0b 6536
64a8946b 6537MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror