FILE
test_bpf.c
File preview with syntax highlighting.
linux-6.19.14/lib/test_bpf.c
1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Testsuite for BPF interpreter and BPF JIT compiler 4 * 5 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com 6 */ 7 8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10#include <linux/init.h> 11#include <linux/module.h> 12#include <linux/filter.h> 13#include <linux/bpf.h> 14#include <linux/skbuff.h> 15#include <linux/netdevice.h> 16#include <linux/if_vlan.h> 17#include <linux/prandom.h> 18#include <linux/highmem.h> 19#include <linux/sched.h> 20 21/* General test specific settings */ 22#define MAX_SUBTESTS 3 23#define MAX_TESTRUNS 1000 24#define MAX_DATA 128 25#define MAX_INSNS 512 26#define MAX_K 0xffffFFFF 27 28/* Few constants used to init test 'skb' */ 29#define SKB_TYPE 3 30#define SKB_MARK 0x1234aaaa 31#define SKB_HASH 0x1234aaab 32#define SKB_QUEUE_MAP 123 33#define SKB_VLAN_TCI 0xffff 34#define SKB_VLAN_PRESENT 1 35#define SKB_DEV_IFINDEX 577 36#define SKB_DEV_TYPE 588 37 38/* Redefine REGs to make tests less verbose */ 39#define R0 BPF_REG_0 40#define R1 BPF_REG_1 41#define R2 BPF_REG_2 42#define R3 BPF_REG_3 43#define R4 BPF_REG_4 44#define R5 BPF_REG_5 45#define R6 BPF_REG_6 46#define R7 BPF_REG_7 47#define R8 BPF_REG_8 48#define R9 BPF_REG_9 49#define R10 BPF_REG_10 50 51/* Flags that can be passed to test cases */ 52#define FLAG_NO_DATA BIT(0) 53#define FLAG_EXPECTED_FAIL BIT(1) 54#define FLAG_SKB_FRAG BIT(2) 55#define FLAG_VERIFIER_ZEXT BIT(3) 56#define FLAG_LARGE_MEM BIT(4) 57 58enum { 59 CLASSIC = BIT(6), /* Old BPF instructions only. */ 60 INTERNAL = BIT(7), /* Extended instruction set. */ 61}; 62 63#define TEST_TYPE_MASK (CLASSIC | INTERNAL) 64 65struct bpf_test { 66 const char *descr; 67 union { 68 struct sock_filter insns[MAX_INSNS]; 69 struct bpf_insn insns_int[MAX_INSNS]; 70 struct { 71 void *insns; 72 unsigned int len; 73 } ptr; 74 } u; 75 __u8 aux; 76 __u8 data[MAX_DATA]; 77 struct { 78 int data_size; 79 __u32 result; 80 } test[MAX_SUBTESTS]; 81 int (*fill_helper)(struct bpf_test *self); 82 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */ 83 __u8 frag_data[MAX_DATA]; 84 int stack_depth; /* for eBPF only, since tests don't call verifier */ 85 int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */ 86}; 87 88/* Large test cases need separate allocation and fill handler. */ 89 90static int bpf_fill_maxinsns1(struct bpf_test *self) 91{ 92 unsigned int len = BPF_MAXINSNS; 93 struct sock_filter *insn; 94 __u32 k = ~0; 95 int i; 96 97 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 98 if (!insn) 99 return -ENOMEM; 100 101 for (i = 0; i < len; i++, k--) 102 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k); 103 104 self->u.ptr.insns = insn; 105 self->u.ptr.len = len; 106 107 return 0; 108} 109 110static int bpf_fill_maxinsns2(struct bpf_test *self) 111{ 112 unsigned int len = BPF_MAXINSNS; 113 struct sock_filter *insn; 114 int i; 115 116 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 117 if (!insn) 118 return -ENOMEM; 119 120 for (i = 0; i < len; i++) 121 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 122 123 self->u.ptr.insns = insn; 124 self->u.ptr.len = len; 125 126 return 0; 127} 128 129static int bpf_fill_maxinsns3(struct bpf_test *self) 130{ 131 unsigned int len = BPF_MAXINSNS; 132 struct sock_filter *insn; 133 struct rnd_state rnd; 134 int i; 135 136 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 137 if (!insn) 138 return -ENOMEM; 139 140 prandom_seed_state(&rnd, 3141592653589793238ULL); 141 142 for (i = 0; i < len - 1; i++) { 143 __u32 k = prandom_u32_state(&rnd); 144 145 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k); 146 } 147 148 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 149 150 self->u.ptr.insns = insn; 151 self->u.ptr.len = len; 152 153 return 0; 154} 155 156static int bpf_fill_maxinsns4(struct bpf_test *self) 157{ 158 unsigned int len = BPF_MAXINSNS + 1; 159 struct sock_filter *insn; 160 int i; 161 162 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 163 if (!insn) 164 return -ENOMEM; 165 166 for (i = 0; i < len; i++) 167 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 168 169 self->u.ptr.insns = insn; 170 self->u.ptr.len = len; 171 172 return 0; 173} 174 175static int bpf_fill_maxinsns5(struct bpf_test *self) 176{ 177 unsigned int len = BPF_MAXINSNS; 178 struct sock_filter *insn; 179 int i; 180 181 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 182 if (!insn) 183 return -ENOMEM; 184 185 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0); 186 187 for (i = 1; i < len - 1; i++) 188 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 189 190 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab); 191 192 self->u.ptr.insns = insn; 193 self->u.ptr.len = len; 194 195 return 0; 196} 197 198static int bpf_fill_maxinsns6(struct bpf_test *self) 199{ 200 unsigned int len = BPF_MAXINSNS; 201 struct sock_filter *insn; 202 int i; 203 204 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 205 if (!insn) 206 return -ENOMEM; 207 208 for (i = 0; i < len - 1; i++) 209 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 210 SKF_AD_VLAN_TAG_PRESENT); 211 212 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 213 214 self->u.ptr.insns = insn; 215 self->u.ptr.len = len; 216 217 return 0; 218} 219 220static int bpf_fill_maxinsns7(struct bpf_test *self) 221{ 222 unsigned int len = BPF_MAXINSNS; 223 struct sock_filter *insn; 224 int i; 225 226 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 227 if (!insn) 228 return -ENOMEM; 229 230 for (i = 0; i < len - 4; i++) 231 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 232 SKF_AD_CPU); 233 234 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0); 235 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 236 SKF_AD_CPU); 237 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0); 238 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 239 240 self->u.ptr.insns = insn; 241 self->u.ptr.len = len; 242 243 return 0; 244} 245 246static int bpf_fill_maxinsns8(struct bpf_test *self) 247{ 248 unsigned int len = BPF_MAXINSNS; 249 struct sock_filter *insn; 250 int i, jmp_off = len - 3; 251 252 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 253 if (!insn) 254 return -ENOMEM; 255 256 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff); 257 258 for (i = 1; i < len - 1; i++) 259 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0); 260 261 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 262 263 self->u.ptr.insns = insn; 264 self->u.ptr.len = len; 265 266 return 0; 267} 268 269static int bpf_fill_maxinsns9(struct bpf_test *self) 270{ 271 unsigned int len = BPF_MAXINSNS; 272 struct bpf_insn *insn; 273 int i; 274 275 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 276 if (!insn) 277 return -ENOMEM; 278 279 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2); 280 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab); 281 insn[2] = BPF_EXIT_INSN(); 282 283 for (i = 3; i < len - 2; i++) 284 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe); 285 286 insn[len - 2] = BPF_EXIT_INSN(); 287 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1)); 288 289 self->u.ptr.insns = insn; 290 self->u.ptr.len = len; 291 292 return 0; 293} 294 295static int bpf_fill_maxinsns10(struct bpf_test *self) 296{ 297 unsigned int len = BPF_MAXINSNS, hlen = len - 2; 298 struct bpf_insn *insn; 299 int i; 300 301 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 302 if (!insn) 303 return -ENOMEM; 304 305 for (i = 0; i < hlen / 2; i++) 306 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i); 307 for (i = hlen - 1; i > hlen / 2; i--) 308 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i); 309 310 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1); 311 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac); 312 insn[hlen + 1] = BPF_EXIT_INSN(); 313 314 self->u.ptr.insns = insn; 315 self->u.ptr.len = len; 316 317 return 0; 318} 319 320static int __bpf_fill_ja(struct bpf_test *self, unsigned int len, 321 unsigned int plen) 322{ 323 struct sock_filter *insn; 324 unsigned int rlen; 325 int i, j; 326 327 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 328 if (!insn) 329 return -ENOMEM; 330 331 rlen = (len % plen) - 1; 332 333 for (i = 0; i + plen < len; i += plen) 334 for (j = 0; j < plen; j++) 335 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, 336 plen - 1 - j, 0, 0); 337 for (j = 0; j < rlen; j++) 338 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j, 339 0, 0); 340 341 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac); 342 343 self->u.ptr.insns = insn; 344 self->u.ptr.len = len; 345 346 return 0; 347} 348 349static int bpf_fill_maxinsns11(struct bpf_test *self) 350{ 351 /* Hits 70 passes on x86_64 and triggers NOPs padding. */ 352 return __bpf_fill_ja(self, BPF_MAXINSNS, 68); 353} 354 355static int bpf_fill_maxinsns12(struct bpf_test *self) 356{ 357 unsigned int len = BPF_MAXINSNS; 358 struct sock_filter *insn; 359 int i = 0; 360 361 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 362 if (!insn) 363 return -ENOMEM; 364 365 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0); 366 367 for (i = 1; i < len - 1; i++) 368 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0); 369 370 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab); 371 372 self->u.ptr.insns = insn; 373 self->u.ptr.len = len; 374 375 return 0; 376} 377 378static int bpf_fill_maxinsns13(struct bpf_test *self) 379{ 380 unsigned int len = BPF_MAXINSNS; 381 struct sock_filter *insn; 382 int i = 0; 383 384 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 385 if (!insn) 386 return -ENOMEM; 387 388 for (i = 0; i < len - 3; i++) 389 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0); 390 391 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab); 392 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0); 393 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 394 395 self->u.ptr.insns = insn; 396 self->u.ptr.len = len; 397 398 return 0; 399} 400 401static int bpf_fill_ja(struct bpf_test *self) 402{ 403 /* Hits exactly 11 passes on x86_64 JIT. */ 404 return __bpf_fill_ja(self, 12, 9); 405} 406 407static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self) 408{ 409 unsigned int len = BPF_MAXINSNS; 410 struct sock_filter *insn; 411 int i; 412 413 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 414 if (!insn) 415 return -ENOMEM; 416 417 for (i = 0; i < len - 1; i += 2) { 418 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0); 419 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 420 SKF_AD_OFF + SKF_AD_CPU); 421 } 422 423 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee); 424 425 self->u.ptr.insns = insn; 426 self->u.ptr.len = len; 427 428 return 0; 429} 430 431static int __bpf_fill_stxdw(struct bpf_test *self, int size) 432{ 433 unsigned int len = BPF_MAXINSNS; 434 struct bpf_insn *insn; 435 int i; 436 437 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 438 if (!insn) 439 return -ENOMEM; 440 441 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1); 442 insn[1] = BPF_ST_MEM(size, R10, -40, 42); 443 444 for (i = 2; i < len - 2; i++) 445 insn[i] = BPF_STX_XADD(size, R10, R0, -40); 446 447 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40); 448 insn[len - 1] = BPF_EXIT_INSN(); 449 450 self->u.ptr.insns = insn; 451 self->u.ptr.len = len; 452 self->stack_depth = 40; 453 454 return 0; 455} 456 457static int bpf_fill_stxw(struct bpf_test *self) 458{ 459 return __bpf_fill_stxdw(self, BPF_W); 460} 461 462static int bpf_fill_stxdw(struct bpf_test *self) 463{ 464 return __bpf_fill_stxdw(self, BPF_DW); 465} 466 467static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64) 468{ 469 struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)}; 470 471 memcpy(insns, tmp, sizeof(tmp)); 472 return 2; 473} 474 475/* 476 * Branch conversion tests. Complex operations can expand to a lot 477 * of instructions when JITed. This in turn may cause jump offsets 478 * to overflow the field size of the native instruction, triggering 479 * a branch conversion mechanism in some JITs. 480 */ 481static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm, bool alu32) 482{ 483 struct bpf_insn *insns; 484 int len = S16_MAX + 5; 485 int i; 486 487 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 488 if (!insns) 489 return -ENOMEM; 490 491 i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL); 492 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 493 insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX); 494 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2); 495 insns[i++] = BPF_EXIT_INSN(); 496 497 while (i < len - 1) { 498 static const int ops[] = { 499 BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD, 500 BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD, 501 }; 502 int op = ops[(i >> 1) % ARRAY_SIZE(ops)]; 503 504 if ((i & 1) || alu32) 505 insns[i++] = BPF_ALU32_REG(op, R0, R1); 506 else 507 insns[i++] = BPF_ALU64_REG(op, R0, R1); 508 } 509 510 insns[i++] = BPF_EXIT_INSN(); 511 self->u.ptr.insns = insns; 512 self->u.ptr.len = len; 513 BUG_ON(i != len); 514 515 return 0; 516} 517 518/* Branch taken by runtime decision */ 519static int bpf_fill_max_jmp_taken_32(struct bpf_test *self) 520{ 521 return __bpf_fill_max_jmp(self, BPF_JEQ, 1, true); 522} 523 524static int bpf_fill_max_jmp_taken(struct bpf_test *self) 525{ 526 return __bpf_fill_max_jmp(self, BPF_JEQ, 1, false); 527} 528 529/* Branch not taken by runtime decision */ 530static int bpf_fill_max_jmp_not_taken_32(struct bpf_test *self) 531{ 532 return __bpf_fill_max_jmp(self, BPF_JEQ, 0, true); 533} 534 535static int bpf_fill_max_jmp_not_taken(struct bpf_test *self) 536{ 537 return __bpf_fill_max_jmp(self, BPF_JEQ, 0, false); 538} 539 540/* Branch always taken, known at JIT time */ 541static int bpf_fill_max_jmp_always_taken_32(struct bpf_test *self) 542{ 543 return __bpf_fill_max_jmp(self, BPF_JGE, 0, true); 544} 545 546static int bpf_fill_max_jmp_always_taken(struct bpf_test *self) 547{ 548 return __bpf_fill_max_jmp(self, BPF_JGE, 0, false); 549} 550 551/* Branch never taken, known at JIT time */ 552static int bpf_fill_max_jmp_never_taken_32(struct bpf_test *self) 553{ 554 return __bpf_fill_max_jmp(self, BPF_JLT, 0, true); 555} 556 557static int bpf_fill_max_jmp_never_taken(struct bpf_test *self) 558{ 559 return __bpf_fill_max_jmp(self, BPF_JLT, 0, false); 560} 561 562/* ALU result computation used in tests */ 563static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op) 564{ 565 *res = 0; 566 switch (op) { 567 case BPF_MOV: 568 *res = v2; 569 break; 570 case BPF_AND: 571 *res = v1 & v2; 572 break; 573 case BPF_OR: 574 *res = v1 | v2; 575 break; 576 case BPF_XOR: 577 *res = v1 ^ v2; 578 break; 579 case BPF_LSH: 580 *res = v1 << v2; 581 break; 582 case BPF_RSH: 583 *res = v1 >> v2; 584 break; 585 case BPF_ARSH: 586 *res = v1 >> v2; 587 if (v2 > 0 && v1 > S64_MAX) 588 *res |= ~0ULL << (64 - v2); 589 break; 590 case BPF_ADD: 591 *res = v1 + v2; 592 break; 593 case BPF_SUB: 594 *res = v1 - v2; 595 break; 596 case BPF_MUL: 597 *res = v1 * v2; 598 break; 599 case BPF_DIV: 600 if (v2 == 0) 601 return false; 602 *res = div64_u64(v1, v2); 603 break; 604 case BPF_MOD: 605 if (v2 == 0) 606 return false; 607 div64_u64_rem(v1, v2, res); 608 break; 609 } 610 return true; 611} 612 613/* Test an ALU shift operation for all valid shift values */ 614static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op, 615 u8 mode, bool alu32) 616{ 617 static const s64 regs[] = { 618 0x0123456789abcdefLL, /* dword > 0, word < 0 */ 619 0xfedcba9876543210LL, /* dword < 0, word > 0 */ 620 0xfedcba0198765432LL, /* dword < 0, word < 0 */ 621 0x0123458967abcdefLL, /* dword > 0, word > 0 */ 622 }; 623 int bits = alu32 ? 32 : 64; 624 int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3; 625 struct bpf_insn *insn; 626 int imm, k; 627 int i = 0; 628 629 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 630 if (!insn) 631 return -ENOMEM; 632 633 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 634 635 for (k = 0; k < ARRAY_SIZE(regs); k++) { 636 s64 reg = regs[k]; 637 638 i += __bpf_ld_imm64(&insn[i], R3, reg); 639 640 for (imm = 0; imm < bits; imm++) { 641 u64 val; 642 643 /* Perform operation */ 644 insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3); 645 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm); 646 if (alu32) { 647 if (mode == BPF_K) 648 insn[i++] = BPF_ALU32_IMM(op, R1, imm); 649 else 650 insn[i++] = BPF_ALU32_REG(op, R1, R2); 651 652 if (op == BPF_ARSH) 653 reg = (s32)reg; 654 else 655 reg = (u32)reg; 656 __bpf_alu_result(&val, reg, imm, op); 657 val = (u32)val; 658 } else { 659 if (mode == BPF_K) 660 insn[i++] = BPF_ALU64_IMM(op, R1, imm); 661 else 662 insn[i++] = BPF_ALU64_REG(op, R1, R2); 663 __bpf_alu_result(&val, reg, imm, op); 664 } 665 666 /* 667 * When debugging a JIT that fails this test, one 668 * can write the immediate value to R0 here to find 669 * out which operand values that fail. 670 */ 671 672 /* Load reference and check the result */ 673 i += __bpf_ld_imm64(&insn[i], R4, val); 674 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1); 675 insn[i++] = BPF_EXIT_INSN(); 676 } 677 } 678 679 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 680 insn[i++] = BPF_EXIT_INSN(); 681 682 self->u.ptr.insns = insn; 683 self->u.ptr.len = len; 684 BUG_ON(i != len); 685 686 return 0; 687} 688 689static int bpf_fill_alu64_lsh_imm(struct bpf_test *self) 690{ 691 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false); 692} 693 694static int bpf_fill_alu64_rsh_imm(struct bpf_test *self) 695{ 696 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false); 697} 698 699static int bpf_fill_alu64_arsh_imm(struct bpf_test *self) 700{ 701 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false); 702} 703 704static int bpf_fill_alu64_lsh_reg(struct bpf_test *self) 705{ 706 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false); 707} 708 709static int bpf_fill_alu64_rsh_reg(struct bpf_test *self) 710{ 711 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false); 712} 713 714static int bpf_fill_alu64_arsh_reg(struct bpf_test *self) 715{ 716 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false); 717} 718 719static int bpf_fill_alu32_lsh_imm(struct bpf_test *self) 720{ 721 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true); 722} 723 724static int bpf_fill_alu32_rsh_imm(struct bpf_test *self) 725{ 726 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true); 727} 728 729static int bpf_fill_alu32_arsh_imm(struct bpf_test *self) 730{ 731 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true); 732} 733 734static int bpf_fill_alu32_lsh_reg(struct bpf_test *self) 735{ 736 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true); 737} 738 739static int bpf_fill_alu32_rsh_reg(struct bpf_test *self) 740{ 741 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true); 742} 743 744static int bpf_fill_alu32_arsh_reg(struct bpf_test *self) 745{ 746 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true); 747} 748 749/* 750 * Test an ALU register shift operation for all valid shift values 751 * for the case when the source and destination are the same. 752 */ 753static int __bpf_fill_alu_shift_same_reg(struct bpf_test *self, u8 op, 754 bool alu32) 755{ 756 int bits = alu32 ? 32 : 64; 757 int len = 3 + 6 * bits; 758 struct bpf_insn *insn; 759 int i = 0; 760 u64 val; 761 762 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 763 if (!insn) 764 return -ENOMEM; 765 766 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 767 768 for (val = 0; val < bits; val++) { 769 u64 res; 770 771 /* Perform operation */ 772 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R1, val); 773 if (alu32) 774 insn[i++] = BPF_ALU32_REG(op, R1, R1); 775 else 776 insn[i++] = BPF_ALU64_REG(op, R1, R1); 777 778 /* Compute the reference result */ 779 __bpf_alu_result(&res, val, val, op); 780 if (alu32) 781 res = (u32)res; 782 i += __bpf_ld_imm64(&insn[i], R2, res); 783 784 /* Check the actual result */ 785 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1); 786 insn[i++] = BPF_EXIT_INSN(); 787 } 788 789 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 790 insn[i++] = BPF_EXIT_INSN(); 791 792 self->u.ptr.insns = insn; 793 self->u.ptr.len = len; 794 BUG_ON(i != len); 795 796 return 0; 797} 798 799static int bpf_fill_alu64_lsh_same_reg(struct bpf_test *self) 800{ 801 return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, false); 802} 803 804static int bpf_fill_alu64_rsh_same_reg(struct bpf_test *self) 805{ 806 return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, false); 807} 808 809static int bpf_fill_alu64_arsh_same_reg(struct bpf_test *self) 810{ 811 return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, false); 812} 813 814static int bpf_fill_alu32_lsh_same_reg(struct bpf_test *self) 815{ 816 return __bpf_fill_alu_shift_same_reg(self, BPF_LSH, true); 817} 818 819static int bpf_fill_alu32_rsh_same_reg(struct bpf_test *self) 820{ 821 return __bpf_fill_alu_shift_same_reg(self, BPF_RSH, true); 822} 823 824static int bpf_fill_alu32_arsh_same_reg(struct bpf_test *self) 825{ 826 return __bpf_fill_alu_shift_same_reg(self, BPF_ARSH, true); 827} 828 829/* 830 * Common operand pattern generator for exhaustive power-of-two magnitudes 831 * tests. The block size parameters can be adjusted to increase/reduce the 832 * number of combinatons tested and thereby execution speed and memory 833 * footprint. 834 */ 835 836static inline s64 value(int msb, int delta, int sign) 837{ 838 return sign * (1LL << msb) + delta; 839} 840 841static int __bpf_fill_pattern(struct bpf_test *self, void *arg, 842 int dbits, int sbits, int block1, int block2, 843 int (*emit)(struct bpf_test*, void*, 844 struct bpf_insn*, s64, s64)) 845{ 846 static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}}; 847 struct bpf_insn *insns; 848 int di, si, bt, db, sb; 849 int count, len, k; 850 int extra = 1 + 2; 851 int i = 0; 852 853 /* Total number of iterations for the two pattern */ 854 count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn); 855 count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn); 856 857 /* Compute the maximum number of insns and allocate the buffer */ 858 len = extra + count * (*emit)(self, arg, NULL, 0, 0); 859 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 860 if (!insns) 861 return -ENOMEM; 862 863 /* Add head instruction(s) */ 864 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 865 866 /* 867 * Pattern 1: all combinations of power-of-two magnitudes and sign, 868 * and with a block of contiguous values around each magnitude. 869 */ 870 for (di = 0; di < dbits - 1; di++) /* Dst magnitudes */ 871 for (si = 0; si < sbits - 1; si++) /* Src magnitudes */ 872 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */ 873 for (db = -(block1 / 2); 874 db < (block1 + 1) / 2; db++) 875 for (sb = -(block1 / 2); 876 sb < (block1 + 1) / 2; sb++) { 877 s64 dst, src; 878 879 dst = value(di, db, sgn[k][0]); 880 src = value(si, sb, sgn[k][1]); 881 i += (*emit)(self, arg, 882 &insns[i], 883 dst, src); 884 } 885 /* 886 * Pattern 2: all combinations for a larger block of values 887 * for each power-of-two magnitude and sign, where the magnitude is 888 * the same for both operands. 889 */ 890 for (bt = 0; bt < max(dbits, sbits) - 1; bt++) /* Magnitude */ 891 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */ 892 for (db = -(block2 / 2); db < (block2 + 1) / 2; db++) 893 for (sb = -(block2 / 2); 894 sb < (block2 + 1) / 2; sb++) { 895 s64 dst, src; 896 897 dst = value(bt % dbits, db, sgn[k][0]); 898 src = value(bt % sbits, sb, sgn[k][1]); 899 i += (*emit)(self, arg, &insns[i], 900 dst, src); 901 } 902 903 /* Append tail instructions */ 904 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 905 insns[i++] = BPF_EXIT_INSN(); 906 BUG_ON(i > len); 907 908 self->u.ptr.insns = insns; 909 self->u.ptr.len = i; 910 911 return 0; 912} 913 914/* 915 * Block size parameters used in pattern tests below. une as needed to 916 * increase/reduce the number combinations tested, see following examples. 917 * block values per operand MSB 918 * ---------------------------------------- 919 * 0 none 920 * 1 (1 << MSB) 921 * 2 (1 << MSB) + [-1, 0] 922 * 3 (1 << MSB) + [-1, 0, 1] 923 */ 924#define PATTERN_BLOCK1 1 925#define PATTERN_BLOCK2 5 926 927/* Number of test runs for a pattern test */ 928#define NR_PATTERN_RUNS 1 929 930/* 931 * Exhaustive tests of ALU operations for all combinations of power-of-two 932 * magnitudes of the operands, both for positive and negative values. The 933 * test is designed to verify e.g. the ALU and ALU64 operations for JITs that 934 * emit different code depending on the magnitude of the immediate value. 935 */ 936static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg, 937 struct bpf_insn *insns, s64 dst, s64 imm) 938{ 939 int op = *(int *)arg; 940 int i = 0; 941 u64 res; 942 943 if (!insns) 944 return 7; 945 946 if (__bpf_alu_result(&res, dst, (s32)imm, op)) { 947 i += __bpf_ld_imm64(&insns[i], R1, dst); 948 i += __bpf_ld_imm64(&insns[i], R3, res); 949 insns[i++] = BPF_ALU64_IMM(op, R1, imm); 950 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 951 insns[i++] = BPF_EXIT_INSN(); 952 } 953 954 return i; 955} 956 957static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg, 958 struct bpf_insn *insns, s64 dst, s64 imm) 959{ 960 int op = *(int *)arg; 961 int i = 0; 962 u64 res; 963 964 if (!insns) 965 return 7; 966 967 if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) { 968 i += __bpf_ld_imm64(&insns[i], R1, dst); 969 i += __bpf_ld_imm64(&insns[i], R3, (u32)res); 970 insns[i++] = BPF_ALU32_IMM(op, R1, imm); 971 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 972 insns[i++] = BPF_EXIT_INSN(); 973 } 974 975 return i; 976} 977 978static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg, 979 struct bpf_insn *insns, s64 dst, s64 src) 980{ 981 int op = *(int *)arg; 982 int i = 0; 983 u64 res; 984 985 if (!insns) 986 return 9; 987 988 if (__bpf_alu_result(&res, dst, src, op)) { 989 i += __bpf_ld_imm64(&insns[i], R1, dst); 990 i += __bpf_ld_imm64(&insns[i], R2, src); 991 i += __bpf_ld_imm64(&insns[i], R3, res); 992 insns[i++] = BPF_ALU64_REG(op, R1, R2); 993 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 994 insns[i++] = BPF_EXIT_INSN(); 995 } 996 997 return i; 998} 999 1000static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg, 1001 struct bpf_insn *insns, s64 dst, s64 src) 1002{ 1003 int op = *(int *)arg; 1004 int i = 0; 1005 u64 res; 1006 1007 if (!insns) 1008 return 9; 1009 1010 if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) { 1011 i += __bpf_ld_imm64(&insns[i], R1, dst); 1012 i += __bpf_ld_imm64(&insns[i], R2, src); 1013 i += __bpf_ld_imm64(&insns[i], R3, (u32)res); 1014 insns[i++] = BPF_ALU32_REG(op, R1, R2); 1015 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 1016 insns[i++] = BPF_EXIT_INSN(); 1017 } 1018 1019 return i; 1020} 1021 1022static int __bpf_fill_alu64_imm(struct bpf_test *self, int op) 1023{ 1024 return __bpf_fill_pattern(self, &op, 64, 32, 1025 PATTERN_BLOCK1, PATTERN_BLOCK2, 1026 &__bpf_emit_alu64_imm); 1027} 1028 1029static int __bpf_fill_alu32_imm(struct bpf_test *self, int op) 1030{ 1031 return __bpf_fill_pattern(self, &op, 64, 32, 1032 PATTERN_BLOCK1, PATTERN_BLOCK2, 1033 &__bpf_emit_alu32_imm); 1034} 1035 1036static int __bpf_fill_alu64_reg(struct bpf_test *self, int op) 1037{ 1038 return __bpf_fill_pattern(self, &op, 64, 64, 1039 PATTERN_BLOCK1, PATTERN_BLOCK2, 1040 &__bpf_emit_alu64_reg); 1041} 1042 1043static int __bpf_fill_alu32_reg(struct bpf_test *self, int op) 1044{ 1045 return __bpf_fill_pattern(self, &op, 64, 64, 1046 PATTERN_BLOCK1, PATTERN_BLOCK2, 1047 &__bpf_emit_alu32_reg); 1048} 1049 1050/* ALU64 immediate operations */ 1051static int bpf_fill_alu64_mov_imm(struct bpf_test *self) 1052{ 1053 return __bpf_fill_alu64_imm(self, BPF_MOV); 1054} 1055 1056static int bpf_fill_alu64_and_imm(struct bpf_test *self) 1057{ 1058 return __bpf_fill_alu64_imm(self, BPF_AND); 1059} 1060 1061static int bpf_fill_alu64_or_imm(struct bpf_test *self) 1062{ 1063 return __bpf_fill_alu64_imm(self, BPF_OR); 1064} 1065 1066static int bpf_fill_alu64_xor_imm(struct bpf_test *self) 1067{ 1068 return __bpf_fill_alu64_imm(self, BPF_XOR); 1069} 1070 1071static int bpf_fill_alu64_add_imm(struct bpf_test *self) 1072{ 1073 return __bpf_fill_alu64_imm(self, BPF_ADD); 1074} 1075 1076static int bpf_fill_alu64_sub_imm(struct bpf_test *self) 1077{ 1078 return __bpf_fill_alu64_imm(self, BPF_SUB); 1079} 1080 1081static int bpf_fill_alu64_mul_imm(struct bpf_test *self) 1082{ 1083 return __bpf_fill_alu64_imm(self, BPF_MUL); 1084} 1085 1086static int bpf_fill_alu64_div_imm(struct bpf_test *self) 1087{ 1088 return __bpf_fill_alu64_imm(self, BPF_DIV); 1089} 1090 1091static int bpf_fill_alu64_mod_imm(struct bpf_test *self) 1092{ 1093 return __bpf_fill_alu64_imm(self, BPF_MOD); 1094} 1095 1096/* ALU32 immediate operations */ 1097static int bpf_fill_alu32_mov_imm(struct bpf_test *self) 1098{ 1099 return __bpf_fill_alu32_imm(self, BPF_MOV); 1100} 1101 1102static int bpf_fill_alu32_and_imm(struct bpf_test *self) 1103{ 1104 return __bpf_fill_alu32_imm(self, BPF_AND); 1105} 1106 1107static int bpf_fill_alu32_or_imm(struct bpf_test *self) 1108{ 1109 return __bpf_fill_alu32_imm(self, BPF_OR); 1110} 1111 1112static int bpf_fill_alu32_xor_imm(struct bpf_test *self) 1113{ 1114 return __bpf_fill_alu32_imm(self, BPF_XOR); 1115} 1116 1117static int bpf_fill_alu32_add_imm(struct bpf_test *self) 1118{ 1119 return __bpf_fill_alu32_imm(self, BPF_ADD); 1120} 1121 1122static int bpf_fill_alu32_sub_imm(struct bpf_test *self) 1123{ 1124 return __bpf_fill_alu32_imm(self, BPF_SUB); 1125} 1126 1127static int bpf_fill_alu32_mul_imm(struct bpf_test *self) 1128{ 1129 return __bpf_fill_alu32_imm(self, BPF_MUL); 1130} 1131 1132static int bpf_fill_alu32_div_imm(struct bpf_test *self) 1133{ 1134 return __bpf_fill_alu32_imm(self, BPF_DIV); 1135} 1136 1137static int bpf_fill_alu32_mod_imm(struct bpf_test *self) 1138{ 1139 return __bpf_fill_alu32_imm(self, BPF_MOD); 1140} 1141 1142/* ALU64 register operations */ 1143static int bpf_fill_alu64_mov_reg(struct bpf_test *self) 1144{ 1145 return __bpf_fill_alu64_reg(self, BPF_MOV); 1146} 1147 1148static int bpf_fill_alu64_and_reg(struct bpf_test *self) 1149{ 1150 return __bpf_fill_alu64_reg(self, BPF_AND); 1151} 1152 1153static int bpf_fill_alu64_or_reg(struct bpf_test *self) 1154{ 1155 return __bpf_fill_alu64_reg(self, BPF_OR); 1156} 1157 1158static int bpf_fill_alu64_xor_reg(struct bpf_test *self) 1159{ 1160 return __bpf_fill_alu64_reg(self, BPF_XOR); 1161} 1162 1163static int bpf_fill_alu64_add_reg(struct bpf_test *self) 1164{ 1165 return __bpf_fill_alu64_reg(self, BPF_ADD); 1166} 1167 1168static int bpf_fill_alu64_sub_reg(struct bpf_test *self) 1169{ 1170 return __bpf_fill_alu64_reg(self, BPF_SUB); 1171} 1172 1173static int bpf_fill_alu64_mul_reg(struct bpf_test *self) 1174{ 1175 return __bpf_fill_alu64_reg(self, BPF_MUL); 1176} 1177 1178static int bpf_fill_alu64_div_reg(struct bpf_test *self) 1179{ 1180 return __bpf_fill_alu64_reg(self, BPF_DIV); 1181} 1182 1183static int bpf_fill_alu64_mod_reg(struct bpf_test *self) 1184{ 1185 return __bpf_fill_alu64_reg(self, BPF_MOD); 1186} 1187 1188/* ALU32 register operations */ 1189static int bpf_fill_alu32_mov_reg(struct bpf_test *self) 1190{ 1191 return __bpf_fill_alu32_reg(self, BPF_MOV); 1192} 1193 1194static int bpf_fill_alu32_and_reg(struct bpf_test *self) 1195{ 1196 return __bpf_fill_alu32_reg(self, BPF_AND); 1197} 1198 1199static int bpf_fill_alu32_or_reg(struct bpf_test *self) 1200{ 1201 return __bpf_fill_alu32_reg(self, BPF_OR); 1202} 1203 1204static int bpf_fill_alu32_xor_reg(struct bpf_test *self) 1205{ 1206 return __bpf_fill_alu32_reg(self, BPF_XOR); 1207} 1208 1209static int bpf_fill_alu32_add_reg(struct bpf_test *self) 1210{ 1211 return __bpf_fill_alu32_reg(self, BPF_ADD); 1212} 1213 1214static int bpf_fill_alu32_sub_reg(struct bpf_test *self) 1215{ 1216 return __bpf_fill_alu32_reg(self, BPF_SUB); 1217} 1218 1219static int bpf_fill_alu32_mul_reg(struct bpf_test *self) 1220{ 1221 return __bpf_fill_alu32_reg(self, BPF_MUL); 1222} 1223 1224static int bpf_fill_alu32_div_reg(struct bpf_test *self) 1225{ 1226 return __bpf_fill_alu32_reg(self, BPF_DIV); 1227} 1228 1229static int bpf_fill_alu32_mod_reg(struct bpf_test *self) 1230{ 1231 return __bpf_fill_alu32_reg(self, BPF_MOD); 1232} 1233 1234/* 1235 * Test JITs that implement complex ALU operations as function 1236 * calls, and must re-arrange operands for argument passing. 1237 */ 1238static int __bpf_fill_alu_imm_regs(struct bpf_test *self, u8 op, bool alu32) 1239{ 1240 int len = 2 + 10 * 10; 1241 struct bpf_insn *insns; 1242 u64 dst, res; 1243 int i = 0; 1244 u32 imm; 1245 int rd; 1246 1247 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 1248 if (!insns) 1249 return -ENOMEM; 1250 1251 /* Operand and result values according to operation */ 1252 if (alu32) 1253 dst = 0x76543210U; 1254 else 1255 dst = 0x7edcba9876543210ULL; 1256 imm = 0x01234567U; 1257 1258 if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH) 1259 imm &= 31; 1260 1261 __bpf_alu_result(&res, dst, imm, op); 1262 1263 if (alu32) 1264 res = (u32)res; 1265 1266 /* Check all operand registers */ 1267 for (rd = R0; rd <= R9; rd++) { 1268 i += __bpf_ld_imm64(&insns[i], rd, dst); 1269 1270 if (alu32) 1271 insns[i++] = BPF_ALU32_IMM(op, rd, imm); 1272 else 1273 insns[i++] = BPF_ALU64_IMM(op, rd, imm); 1274 1275 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res, 2); 1276 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1277 insns[i++] = BPF_EXIT_INSN(); 1278 1279 insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32); 1280 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, res >> 32, 2); 1281 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1282 insns[i++] = BPF_EXIT_INSN(); 1283 } 1284 1285 insns[i++] = BPF_MOV64_IMM(R0, 1); 1286 insns[i++] = BPF_EXIT_INSN(); 1287 1288 self->u.ptr.insns = insns; 1289 self->u.ptr.len = len; 1290 BUG_ON(i != len); 1291 1292 return 0; 1293} 1294 1295/* ALU64 K registers */ 1296static int bpf_fill_alu64_mov_imm_regs(struct bpf_test *self) 1297{ 1298 return __bpf_fill_alu_imm_regs(self, BPF_MOV, false); 1299} 1300 1301static int bpf_fill_alu64_and_imm_regs(struct bpf_test *self) 1302{ 1303 return __bpf_fill_alu_imm_regs(self, BPF_AND, false); 1304} 1305 1306static int bpf_fill_alu64_or_imm_regs(struct bpf_test *self) 1307{ 1308 return __bpf_fill_alu_imm_regs(self, BPF_OR, false); 1309} 1310 1311static int bpf_fill_alu64_xor_imm_regs(struct bpf_test *self) 1312{ 1313 return __bpf_fill_alu_imm_regs(self, BPF_XOR, false); 1314} 1315 1316static int bpf_fill_alu64_lsh_imm_regs(struct bpf_test *self) 1317{ 1318 return __bpf_fill_alu_imm_regs(self, BPF_LSH, false); 1319} 1320 1321static int bpf_fill_alu64_rsh_imm_regs(struct bpf_test *self) 1322{ 1323 return __bpf_fill_alu_imm_regs(self, BPF_RSH, false); 1324} 1325 1326static int bpf_fill_alu64_arsh_imm_regs(struct bpf_test *self) 1327{ 1328 return __bpf_fill_alu_imm_regs(self, BPF_ARSH, false); 1329} 1330 1331static int bpf_fill_alu64_add_imm_regs(struct bpf_test *self) 1332{ 1333 return __bpf_fill_alu_imm_regs(self, BPF_ADD, false); 1334} 1335 1336static int bpf_fill_alu64_sub_imm_regs(struct bpf_test *self) 1337{ 1338 return __bpf_fill_alu_imm_regs(self, BPF_SUB, false); 1339} 1340 1341static int bpf_fill_alu64_mul_imm_regs(struct bpf_test *self) 1342{ 1343 return __bpf_fill_alu_imm_regs(self, BPF_MUL, false); 1344} 1345 1346static int bpf_fill_alu64_div_imm_regs(struct bpf_test *self) 1347{ 1348 return __bpf_fill_alu_imm_regs(self, BPF_DIV, false); 1349} 1350 1351static int bpf_fill_alu64_mod_imm_regs(struct bpf_test *self) 1352{ 1353 return __bpf_fill_alu_imm_regs(self, BPF_MOD, false); 1354} 1355 1356/* ALU32 K registers */ 1357static int bpf_fill_alu32_mov_imm_regs(struct bpf_test *self) 1358{ 1359 return __bpf_fill_alu_imm_regs(self, BPF_MOV, true); 1360} 1361 1362static int bpf_fill_alu32_and_imm_regs(struct bpf_test *self) 1363{ 1364 return __bpf_fill_alu_imm_regs(self, BPF_AND, true); 1365} 1366 1367static int bpf_fill_alu32_or_imm_regs(struct bpf_test *self) 1368{ 1369 return __bpf_fill_alu_imm_regs(self, BPF_OR, true); 1370} 1371 1372static int bpf_fill_alu32_xor_imm_regs(struct bpf_test *self) 1373{ 1374 return __bpf_fill_alu_imm_regs(self, BPF_XOR, true); 1375} 1376 1377static int bpf_fill_alu32_lsh_imm_regs(struct bpf_test *self) 1378{ 1379 return __bpf_fill_alu_imm_regs(self, BPF_LSH, true); 1380} 1381 1382static int bpf_fill_alu32_rsh_imm_regs(struct bpf_test *self) 1383{ 1384 return __bpf_fill_alu_imm_regs(self, BPF_RSH, true); 1385} 1386 1387static int bpf_fill_alu32_arsh_imm_regs(struct bpf_test *self) 1388{ 1389 return __bpf_fill_alu_imm_regs(self, BPF_ARSH, true); 1390} 1391 1392static int bpf_fill_alu32_add_imm_regs(struct bpf_test *self) 1393{ 1394 return __bpf_fill_alu_imm_regs(self, BPF_ADD, true); 1395} 1396 1397static int bpf_fill_alu32_sub_imm_regs(struct bpf_test *self) 1398{ 1399 return __bpf_fill_alu_imm_regs(self, BPF_SUB, true); 1400} 1401 1402static int bpf_fill_alu32_mul_imm_regs(struct bpf_test *self) 1403{ 1404 return __bpf_fill_alu_imm_regs(self, BPF_MUL, true); 1405} 1406 1407static int bpf_fill_alu32_div_imm_regs(struct bpf_test *self) 1408{ 1409 return __bpf_fill_alu_imm_regs(self, BPF_DIV, true); 1410} 1411 1412static int bpf_fill_alu32_mod_imm_regs(struct bpf_test *self) 1413{ 1414 return __bpf_fill_alu_imm_regs(self, BPF_MOD, true); 1415} 1416 1417/* 1418 * Test JITs that implement complex ALU operations as function 1419 * calls, and must re-arrange operands for argument passing. 1420 */ 1421static int __bpf_fill_alu_reg_pairs(struct bpf_test *self, u8 op, bool alu32) 1422{ 1423 int len = 2 + 10 * 10 * 12; 1424 u64 dst, src, res, same; 1425 struct bpf_insn *insns; 1426 int rd, rs; 1427 int i = 0; 1428 1429 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 1430 if (!insns) 1431 return -ENOMEM; 1432 1433 /* Operand and result values according to operation */ 1434 if (alu32) { 1435 dst = 0x76543210U; 1436 src = 0x01234567U; 1437 } else { 1438 dst = 0x7edcba9876543210ULL; 1439 src = 0x0123456789abcdefULL; 1440 } 1441 1442 if (op == BPF_LSH || op == BPF_RSH || op == BPF_ARSH) 1443 src &= 31; 1444 1445 __bpf_alu_result(&res, dst, src, op); 1446 __bpf_alu_result(&same, src, src, op); 1447 1448 if (alu32) { 1449 res = (u32)res; 1450 same = (u32)same; 1451 } 1452 1453 /* Check all combinations of operand registers */ 1454 for (rd = R0; rd <= R9; rd++) { 1455 for (rs = R0; rs <= R9; rs++) { 1456 u64 val = rd == rs ? same : res; 1457 1458 i += __bpf_ld_imm64(&insns[i], rd, dst); 1459 i += __bpf_ld_imm64(&insns[i], rs, src); 1460 1461 if (alu32) 1462 insns[i++] = BPF_ALU32_REG(op, rd, rs); 1463 else 1464 insns[i++] = BPF_ALU64_REG(op, rd, rs); 1465 1466 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val, 2); 1467 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1468 insns[i++] = BPF_EXIT_INSN(); 1469 1470 insns[i++] = BPF_ALU64_IMM(BPF_RSH, rd, 32); 1471 insns[i++] = BPF_JMP32_IMM(BPF_JEQ, rd, val >> 32, 2); 1472 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1473 insns[i++] = BPF_EXIT_INSN(); 1474 } 1475 } 1476 1477 insns[i++] = BPF_MOV64_IMM(R0, 1); 1478 insns[i++] = BPF_EXIT_INSN(); 1479 1480 self->u.ptr.insns = insns; 1481 self->u.ptr.len = len; 1482 BUG_ON(i != len); 1483 1484 return 0; 1485} 1486 1487/* ALU64 X register combinations */ 1488static int bpf_fill_alu64_mov_reg_pairs(struct bpf_test *self) 1489{ 1490 return __bpf_fill_alu_reg_pairs(self, BPF_MOV, false); 1491} 1492 1493static int bpf_fill_alu64_and_reg_pairs(struct bpf_test *self) 1494{ 1495 return __bpf_fill_alu_reg_pairs(self, BPF_AND, false); 1496} 1497 1498static int bpf_fill_alu64_or_reg_pairs(struct bpf_test *self) 1499{ 1500 return __bpf_fill_alu_reg_pairs(self, BPF_OR, false); 1501} 1502 1503static int bpf_fill_alu64_xor_reg_pairs(struct bpf_test *self) 1504{ 1505 return __bpf_fill_alu_reg_pairs(self, BPF_XOR, false); 1506} 1507 1508static int bpf_fill_alu64_lsh_reg_pairs(struct bpf_test *self) 1509{ 1510 return __bpf_fill_alu_reg_pairs(self, BPF_LSH, false); 1511} 1512 1513static int bpf_fill_alu64_rsh_reg_pairs(struct bpf_test *self) 1514{ 1515 return __bpf_fill_alu_reg_pairs(self, BPF_RSH, false); 1516} 1517 1518static int bpf_fill_alu64_arsh_reg_pairs(struct bpf_test *self) 1519{ 1520 return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, false); 1521} 1522 1523static int bpf_fill_alu64_add_reg_pairs(struct bpf_test *self) 1524{ 1525 return __bpf_fill_alu_reg_pairs(self, BPF_ADD, false); 1526} 1527 1528static int bpf_fill_alu64_sub_reg_pairs(struct bpf_test *self) 1529{ 1530 return __bpf_fill_alu_reg_pairs(self, BPF_SUB, false); 1531} 1532 1533static int bpf_fill_alu64_mul_reg_pairs(struct bpf_test *self) 1534{ 1535 return __bpf_fill_alu_reg_pairs(self, BPF_MUL, false); 1536} 1537 1538static int bpf_fill_alu64_div_reg_pairs(struct bpf_test *self) 1539{ 1540 return __bpf_fill_alu_reg_pairs(self, BPF_DIV, false); 1541} 1542 1543static int bpf_fill_alu64_mod_reg_pairs(struct bpf_test *self) 1544{ 1545 return __bpf_fill_alu_reg_pairs(self, BPF_MOD, false); 1546} 1547 1548/* ALU32 X register combinations */ 1549static int bpf_fill_alu32_mov_reg_pairs(struct bpf_test *self) 1550{ 1551 return __bpf_fill_alu_reg_pairs(self, BPF_MOV, true); 1552} 1553 1554static int bpf_fill_alu32_and_reg_pairs(struct bpf_test *self) 1555{ 1556 return __bpf_fill_alu_reg_pairs(self, BPF_AND, true); 1557} 1558 1559static int bpf_fill_alu32_or_reg_pairs(struct bpf_test *self) 1560{ 1561 return __bpf_fill_alu_reg_pairs(self, BPF_OR, true); 1562} 1563 1564static int bpf_fill_alu32_xor_reg_pairs(struct bpf_test *self) 1565{ 1566 return __bpf_fill_alu_reg_pairs(self, BPF_XOR, true); 1567} 1568 1569static int bpf_fill_alu32_lsh_reg_pairs(struct bpf_test *self) 1570{ 1571 return __bpf_fill_alu_reg_pairs(self, BPF_LSH, true); 1572} 1573 1574static int bpf_fill_alu32_rsh_reg_pairs(struct bpf_test *self) 1575{ 1576 return __bpf_fill_alu_reg_pairs(self, BPF_RSH, true); 1577} 1578 1579static int bpf_fill_alu32_arsh_reg_pairs(struct bpf_test *self) 1580{ 1581 return __bpf_fill_alu_reg_pairs(self, BPF_ARSH, true); 1582} 1583 1584static int bpf_fill_alu32_add_reg_pairs(struct bpf_test *self) 1585{ 1586 return __bpf_fill_alu_reg_pairs(self, BPF_ADD, true); 1587} 1588 1589static int bpf_fill_alu32_sub_reg_pairs(struct bpf_test *self) 1590{ 1591 return __bpf_fill_alu_reg_pairs(self, BPF_SUB, true); 1592} 1593 1594static int bpf_fill_alu32_mul_reg_pairs(struct bpf_test *self) 1595{ 1596 return __bpf_fill_alu_reg_pairs(self, BPF_MUL, true); 1597} 1598 1599static int bpf_fill_alu32_div_reg_pairs(struct bpf_test *self) 1600{ 1601 return __bpf_fill_alu_reg_pairs(self, BPF_DIV, true); 1602} 1603 1604static int bpf_fill_alu32_mod_reg_pairs(struct bpf_test *self) 1605{ 1606 return __bpf_fill_alu_reg_pairs(self, BPF_MOD, true); 1607} 1608 1609/* 1610 * Exhaustive tests of atomic operations for all power-of-two operand 1611 * magnitudes, both for positive and negative values. 1612 */ 1613 1614static int __bpf_emit_atomic64(struct bpf_test *self, void *arg, 1615 struct bpf_insn *insns, s64 dst, s64 src) 1616{ 1617 int op = *(int *)arg; 1618 u64 keep, fetch, res; 1619 int i = 0; 1620 1621 if (!insns) 1622 return 21; 1623 1624 switch (op) { 1625 case BPF_XCHG: 1626 res = src; 1627 break; 1628 default: 1629 __bpf_alu_result(&res, dst, src, BPF_OP(op)); 1630 } 1631 1632 keep = 0x0123456789abcdefULL; 1633 if (op & BPF_FETCH) 1634 fetch = dst; 1635 else 1636 fetch = src; 1637 1638 i += __bpf_ld_imm64(&insns[i], R0, keep); 1639 i += __bpf_ld_imm64(&insns[i], R1, dst); 1640 i += __bpf_ld_imm64(&insns[i], R2, src); 1641 i += __bpf_ld_imm64(&insns[i], R3, res); 1642 i += __bpf_ld_imm64(&insns[i], R4, fetch); 1643 i += __bpf_ld_imm64(&insns[i], R5, keep); 1644 1645 insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8); 1646 insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8); 1647 insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8); 1648 1649 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 1650 insns[i++] = BPF_EXIT_INSN(); 1651 1652 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1); 1653 insns[i++] = BPF_EXIT_INSN(); 1654 1655 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1); 1656 insns[i++] = BPF_EXIT_INSN(); 1657 1658 return i; 1659} 1660 1661static int __bpf_emit_atomic32(struct bpf_test *self, void *arg, 1662 struct bpf_insn *insns, s64 dst, s64 src) 1663{ 1664 int op = *(int *)arg; 1665 u64 keep, fetch, res; 1666 int i = 0; 1667 1668 if (!insns) 1669 return 21; 1670 1671 switch (op) { 1672 case BPF_XCHG: 1673 res = src; 1674 break; 1675 default: 1676 __bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op)); 1677 } 1678 1679 keep = 0x0123456789abcdefULL; 1680 if (op & BPF_FETCH) 1681 fetch = (u32)dst; 1682 else 1683 fetch = src; 1684 1685 i += __bpf_ld_imm64(&insns[i], R0, keep); 1686 i += __bpf_ld_imm64(&insns[i], R1, (u32)dst); 1687 i += __bpf_ld_imm64(&insns[i], R2, src); 1688 i += __bpf_ld_imm64(&insns[i], R3, (u32)res); 1689 i += __bpf_ld_imm64(&insns[i], R4, fetch); 1690 i += __bpf_ld_imm64(&insns[i], R5, keep); 1691 1692 insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4); 1693 insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4); 1694 insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4); 1695 1696 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 1697 insns[i++] = BPF_EXIT_INSN(); 1698 1699 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1); 1700 insns[i++] = BPF_EXIT_INSN(); 1701 1702 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1); 1703 insns[i++] = BPF_EXIT_INSN(); 1704 1705 return i; 1706} 1707 1708static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg, 1709 struct bpf_insn *insns, s64 dst, s64 src) 1710{ 1711 int i = 0; 1712 1713 if (!insns) 1714 return 23; 1715 1716 i += __bpf_ld_imm64(&insns[i], R0, ~dst); 1717 i += __bpf_ld_imm64(&insns[i], R1, dst); 1718 i += __bpf_ld_imm64(&insns[i], R2, src); 1719 1720 /* Result unsuccessful */ 1721 insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8); 1722 insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8); 1723 insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8); 1724 1725 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2); 1726 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1727 insns[i++] = BPF_EXIT_INSN(); 1728 1729 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2); 1730 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1731 insns[i++] = BPF_EXIT_INSN(); 1732 1733 /* Result successful */ 1734 insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8); 1735 insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8); 1736 1737 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2); 1738 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1739 insns[i++] = BPF_EXIT_INSN(); 1740 1741 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2); 1742 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1743 insns[i++] = BPF_EXIT_INSN(); 1744 1745 return i; 1746} 1747 1748static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg, 1749 struct bpf_insn *insns, s64 dst, s64 src) 1750{ 1751 int i = 0; 1752 1753 if (!insns) 1754 return 27; 1755 1756 i += __bpf_ld_imm64(&insns[i], R0, ~dst); 1757 i += __bpf_ld_imm64(&insns[i], R1, (u32)dst); 1758 i += __bpf_ld_imm64(&insns[i], R2, src); 1759 1760 /* Result unsuccessful */ 1761 insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4); 1762 insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4); 1763 insns[i++] = BPF_ZEXT_REG(R0); /* Zext always inserted by verifier */ 1764 insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4); 1765 1766 insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2); 1767 insns[i++] = BPF_MOV32_IMM(R0, __LINE__); 1768 insns[i++] = BPF_EXIT_INSN(); 1769 1770 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2); 1771 insns[i++] = BPF_MOV32_IMM(R0, __LINE__); 1772 insns[i++] = BPF_EXIT_INSN(); 1773 1774 /* Result successful */ 1775 i += __bpf_ld_imm64(&insns[i], R0, dst); 1776 insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4); 1777 insns[i++] = BPF_ZEXT_REG(R0); /* Zext always inserted by verifier */ 1778 insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4); 1779 1780 insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2); 1781 insns[i++] = BPF_MOV32_IMM(R0, __LINE__); 1782 insns[i++] = BPF_EXIT_INSN(); 1783 1784 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2); 1785 insns[i++] = BPF_MOV32_IMM(R0, __LINE__); 1786 insns[i++] = BPF_EXIT_INSN(); 1787 1788 return i; 1789} 1790 1791static int __bpf_fill_atomic64(struct bpf_test *self, int op) 1792{ 1793 return __bpf_fill_pattern(self, &op, 64, 64, 1794 0, PATTERN_BLOCK2, 1795 &__bpf_emit_atomic64); 1796} 1797 1798static int __bpf_fill_atomic32(struct bpf_test *self, int op) 1799{ 1800 return __bpf_fill_pattern(self, &op, 64, 64, 1801 0, PATTERN_BLOCK2, 1802 &__bpf_emit_atomic32); 1803} 1804 1805/* 64-bit atomic operations */ 1806static int bpf_fill_atomic64_add(struct bpf_test *self) 1807{ 1808 return __bpf_fill_atomic64(self, BPF_ADD); 1809} 1810 1811static int bpf_fill_atomic64_and(struct bpf_test *self) 1812{ 1813 return __bpf_fill_atomic64(self, BPF_AND); 1814} 1815 1816static int bpf_fill_atomic64_or(struct bpf_test *self) 1817{ 1818 return __bpf_fill_atomic64(self, BPF_OR); 1819} 1820 1821static int bpf_fill_atomic64_xor(struct bpf_test *self) 1822{ 1823 return __bpf_fill_atomic64(self, BPF_XOR); 1824} 1825 1826static int bpf_fill_atomic64_add_fetch(struct bpf_test *self) 1827{ 1828 return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH); 1829} 1830 1831static int bpf_fill_atomic64_and_fetch(struct bpf_test *self) 1832{ 1833 return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH); 1834} 1835 1836static int bpf_fill_atomic64_or_fetch(struct bpf_test *self) 1837{ 1838 return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH); 1839} 1840 1841static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self) 1842{ 1843 return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH); 1844} 1845 1846static int bpf_fill_atomic64_xchg(struct bpf_test *self) 1847{ 1848 return __bpf_fill_atomic64(self, BPF_XCHG); 1849} 1850 1851static int bpf_fill_cmpxchg64(struct bpf_test *self) 1852{ 1853 return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2, 1854 &__bpf_emit_cmpxchg64); 1855} 1856 1857/* 32-bit atomic operations */ 1858static int bpf_fill_atomic32_add(struct bpf_test *self) 1859{ 1860 return __bpf_fill_atomic32(self, BPF_ADD); 1861} 1862 1863static int bpf_fill_atomic32_and(struct bpf_test *self) 1864{ 1865 return __bpf_fill_atomic32(self, BPF_AND); 1866} 1867 1868static int bpf_fill_atomic32_or(struct bpf_test *self) 1869{ 1870 return __bpf_fill_atomic32(self, BPF_OR); 1871} 1872 1873static int bpf_fill_atomic32_xor(struct bpf_test *self) 1874{ 1875 return __bpf_fill_atomic32(self, BPF_XOR); 1876} 1877 1878static int bpf_fill_atomic32_add_fetch(struct bpf_test *self) 1879{ 1880 return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH); 1881} 1882 1883static int bpf_fill_atomic32_and_fetch(struct bpf_test *self) 1884{ 1885 return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH); 1886} 1887 1888static int bpf_fill_atomic32_or_fetch(struct bpf_test *self) 1889{ 1890 return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH); 1891} 1892 1893static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self) 1894{ 1895 return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH); 1896} 1897 1898static int bpf_fill_atomic32_xchg(struct bpf_test *self) 1899{ 1900 return __bpf_fill_atomic32(self, BPF_XCHG); 1901} 1902 1903static int bpf_fill_cmpxchg32(struct bpf_test *self) 1904{ 1905 return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2, 1906 &__bpf_emit_cmpxchg32); 1907} 1908 1909/* 1910 * Test JITs that implement ATOMIC operations as function calls or 1911 * other primitives, and must re-arrange operands for argument passing. 1912 */ 1913static int __bpf_fill_atomic_reg_pairs(struct bpf_test *self, u8 width, u8 op) 1914{ 1915 struct bpf_insn *insn; 1916 int len = 2 + 34 * 10 * 10; 1917 u64 mem, upd, res; 1918 int rd, rs, i = 0; 1919 1920 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 1921 if (!insn) 1922 return -ENOMEM; 1923 1924 /* Operand and memory values */ 1925 if (width == BPF_DW) { 1926 mem = 0x0123456789abcdefULL; 1927 upd = 0xfedcba9876543210ULL; 1928 } else { /* BPF_W */ 1929 mem = 0x01234567U; 1930 upd = 0x76543210U; 1931 } 1932 1933 /* Memory updated according to operation */ 1934 switch (op) { 1935 case BPF_XCHG: 1936 res = upd; 1937 break; 1938 case BPF_CMPXCHG: 1939 res = mem; 1940 break; 1941 default: 1942 __bpf_alu_result(&res, mem, upd, BPF_OP(op)); 1943 } 1944 1945 /* Test all operand registers */ 1946 for (rd = R0; rd <= R9; rd++) { 1947 for (rs = R0; rs <= R9; rs++) { 1948 u64 cmp, src; 1949 1950 /* Initialize value in memory */ 1951 i += __bpf_ld_imm64(&insn[i], R0, mem); 1952 insn[i++] = BPF_STX_MEM(width, R10, R0, -8); 1953 1954 /* Initialize registers in order */ 1955 i += __bpf_ld_imm64(&insn[i], R0, ~mem); 1956 i += __bpf_ld_imm64(&insn[i], rs, upd); 1957 insn[i++] = BPF_MOV64_REG(rd, R10); 1958 1959 /* Perform atomic operation */ 1960 insn[i++] = BPF_ATOMIC_OP(width, op, rd, rs, -8); 1961 if (op == BPF_CMPXCHG && width == BPF_W) 1962 insn[i++] = BPF_ZEXT_REG(R0); 1963 1964 /* Check R0 register value */ 1965 if (op == BPF_CMPXCHG) 1966 cmp = mem; /* Expect value from memory */ 1967 else if (R0 == rd || R0 == rs) 1968 cmp = 0; /* Aliased, checked below */ 1969 else 1970 cmp = ~mem; /* Expect value to be preserved */ 1971 if (cmp) { 1972 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0, 1973 (u32)cmp, 2); 1974 insn[i++] = BPF_MOV32_IMM(R0, __LINE__); 1975 insn[i++] = BPF_EXIT_INSN(); 1976 insn[i++] = BPF_ALU64_IMM(BPF_RSH, R0, 32); 1977 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, R0, 1978 cmp >> 32, 2); 1979 insn[i++] = BPF_MOV32_IMM(R0, __LINE__); 1980 insn[i++] = BPF_EXIT_INSN(); 1981 } 1982 1983 /* Check source register value */ 1984 if (rs == R0 && op == BPF_CMPXCHG) 1985 src = 0; /* Aliased with R0, checked above */ 1986 else if (rs == rd && (op == BPF_CMPXCHG || 1987 !(op & BPF_FETCH))) 1988 src = 0; /* Aliased with rd, checked below */ 1989 else if (op == BPF_CMPXCHG) 1990 src = upd; /* Expect value to be preserved */ 1991 else if (op & BPF_FETCH) 1992 src = mem; /* Expect fetched value from mem */ 1993 else /* no fetch */ 1994 src = upd; /* Expect value to be preserved */ 1995 if (src) { 1996 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs, 1997 (u32)src, 2); 1998 insn[i++] = BPF_MOV32_IMM(R0, __LINE__); 1999 insn[i++] = BPF_EXIT_INSN(); 2000 insn[i++] = BPF_ALU64_IMM(BPF_RSH, rs, 32); 2001 insn[i++] = BPF_JMP32_IMM(BPF_JEQ, rs, 2002 src >> 32, 2); 2003 insn[i++] = BPF_MOV32_IMM(R0, __LINE__); 2004 insn[i++] = BPF_EXIT_INSN(); 2005 } 2006 2007 /* Check destination register value */ 2008 if (!(rd == R0 && op == BPF_CMPXCHG) && 2009 !(rd == rs && (op & BPF_FETCH))) { 2010 insn[i++] = BPF_JMP_REG(BPF_JEQ, rd, R10, 2); 2011 insn[i++] = BPF_MOV32_IMM(R0, __LINE__); 2012 insn[i++] = BPF_EXIT_INSN(); 2013 } 2014 2015 /* Check value in memory */ 2016 if (rs != rd) { /* No aliasing */ 2017 i += __bpf_ld_imm64(&insn[i], R1, res); 2018 } else if (op == BPF_XCHG) { /* Aliased, XCHG */ 2019 insn[i++] = BPF_MOV64_REG(R1, R10); 2020 } else if (op == BPF_CMPXCHG) { /* Aliased, CMPXCHG */ 2021 i += __bpf_ld_imm64(&insn[i], R1, mem); 2022 } else { /* Aliased, ALU oper */ 2023 i += __bpf_ld_imm64(&insn[i], R1, mem); 2024 insn[i++] = BPF_ALU64_REG(BPF_OP(op), R1, R10); 2025 } 2026 2027 insn[i++] = BPF_LDX_MEM(width, R0, R10, -8); 2028 if (width == BPF_DW) 2029 insn[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2); 2030 else /* width == BPF_W */ 2031 insn[i++] = BPF_JMP32_REG(BPF_JEQ, R0, R1, 2); 2032 insn[i++] = BPF_MOV32_IMM(R0, __LINE__); 2033 insn[i++] = BPF_EXIT_INSN(); 2034 } 2035 } 2036 2037 insn[i++] = BPF_MOV64_IMM(R0, 1); 2038 insn[i++] = BPF_EXIT_INSN(); 2039 2040 self->u.ptr.insns = insn; 2041 self->u.ptr.len = i; 2042 BUG_ON(i > len); 2043 2044 return 0; 2045} 2046 2047/* 64-bit atomic register tests */ 2048static int bpf_fill_atomic64_add_reg_pairs(struct bpf_test *self) 2049{ 2050 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD); 2051} 2052 2053static int bpf_fill_atomic64_and_reg_pairs(struct bpf_test *self) 2054{ 2055 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND); 2056} 2057 2058static int bpf_fill_atomic64_or_reg_pairs(struct bpf_test *self) 2059{ 2060 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR); 2061} 2062 2063static int bpf_fill_atomic64_xor_reg_pairs(struct bpf_test *self) 2064{ 2065 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR); 2066} 2067 2068static int bpf_fill_atomic64_add_fetch_reg_pairs(struct bpf_test *self) 2069{ 2070 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_ADD | BPF_FETCH); 2071} 2072 2073static int bpf_fill_atomic64_and_fetch_reg_pairs(struct bpf_test *self) 2074{ 2075 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_AND | BPF_FETCH); 2076} 2077 2078static int bpf_fill_atomic64_or_fetch_reg_pairs(struct bpf_test *self) 2079{ 2080 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_OR | BPF_FETCH); 2081} 2082 2083static int bpf_fill_atomic64_xor_fetch_reg_pairs(struct bpf_test *self) 2084{ 2085 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XOR | BPF_FETCH); 2086} 2087 2088static int bpf_fill_atomic64_xchg_reg_pairs(struct bpf_test *self) 2089{ 2090 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_XCHG); 2091} 2092 2093static int bpf_fill_atomic64_cmpxchg_reg_pairs(struct bpf_test *self) 2094{ 2095 return __bpf_fill_atomic_reg_pairs(self, BPF_DW, BPF_CMPXCHG); 2096} 2097 2098/* 32-bit atomic register tests */ 2099static int bpf_fill_atomic32_add_reg_pairs(struct bpf_test *self) 2100{ 2101 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD); 2102} 2103 2104static int bpf_fill_atomic32_and_reg_pairs(struct bpf_test *self) 2105{ 2106 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND); 2107} 2108 2109static int bpf_fill_atomic32_or_reg_pairs(struct bpf_test *self) 2110{ 2111 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR); 2112} 2113 2114static int bpf_fill_atomic32_xor_reg_pairs(struct bpf_test *self) 2115{ 2116 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR); 2117} 2118 2119static int bpf_fill_atomic32_add_fetch_reg_pairs(struct bpf_test *self) 2120{ 2121 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_ADD | BPF_FETCH); 2122} 2123 2124static int bpf_fill_atomic32_and_fetch_reg_pairs(struct bpf_test *self) 2125{ 2126 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_AND | BPF_FETCH); 2127} 2128 2129static int bpf_fill_atomic32_or_fetch_reg_pairs(struct bpf_test *self) 2130{ 2131 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_OR | BPF_FETCH); 2132} 2133 2134static int bpf_fill_atomic32_xor_fetch_reg_pairs(struct bpf_test *self) 2135{ 2136 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XOR | BPF_FETCH); 2137} 2138 2139static int bpf_fill_atomic32_xchg_reg_pairs(struct bpf_test *self) 2140{ 2141 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_XCHG); 2142} 2143 2144static int bpf_fill_atomic32_cmpxchg_reg_pairs(struct bpf_test *self) 2145{ 2146 return __bpf_fill_atomic_reg_pairs(self, BPF_W, BPF_CMPXCHG); 2147} 2148 2149/* 2150 * Test the two-instruction 64-bit immediate load operation for all 2151 * power-of-two magnitudes of the immediate operand. For each MSB, a block 2152 * of immediate values centered around the power-of-two MSB are tested, 2153 * both for positive and negative values. The test is designed to verify 2154 * the operation for JITs that emit different code depending on the magnitude 2155 * of the immediate value. This is often the case if the native instruction 2156 * immediate field width is narrower than 32 bits. 2157 */ 2158static int bpf_fill_ld_imm64_magn(struct bpf_test *self) 2159{ 2160 int block = 64; /* Increase for more tests per MSB position */ 2161 int len = 3 + 8 * 63 * block * 2; 2162 struct bpf_insn *insn; 2163 int bit, adj, sign; 2164 int i = 0; 2165 2166 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 2167 if (!insn) 2168 return -ENOMEM; 2169 2170 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 2171 2172 for (bit = 0; bit <= 62; bit++) { 2173 for (adj = -block / 2; adj < block / 2; adj++) { 2174 for (sign = -1; sign <= 1; sign += 2) { 2175 s64 imm = sign * ((1LL << bit) + adj); 2176 2177 /* Perform operation */ 2178 i += __bpf_ld_imm64(&insn[i], R1, imm); 2179 2180 /* Load reference */ 2181 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm); 2182 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, 2183 (u32)(imm >> 32)); 2184 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32); 2185 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3); 2186 2187 /* Check result */ 2188 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1); 2189 insn[i++] = BPF_EXIT_INSN(); 2190 } 2191 } 2192 } 2193 2194 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 2195 insn[i++] = BPF_EXIT_INSN(); 2196 2197 self->u.ptr.insns = insn; 2198 self->u.ptr.len = len; 2199 BUG_ON(i != len); 2200 2201 return 0; 2202} 2203 2204/* 2205 * Test the two-instruction 64-bit immediate load operation for different 2206 * combinations of bytes. Each byte in the 64-bit word is constructed as 2207 * (base & mask) | (rand() & ~mask), where rand() is a deterministic LCG. 2208 * All patterns (base1, mask1) and (base2, mask2) bytes are tested. 2209 */ 2210static int __bpf_fill_ld_imm64_bytes(struct bpf_test *self, 2211 u8 base1, u8 mask1, 2212 u8 base2, u8 mask2) 2213{ 2214 struct bpf_insn *insn; 2215 int len = 3 + 8 * BIT(8); 2216 int pattern, index; 2217 u32 rand = 1; 2218 int i = 0; 2219 2220 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 2221 if (!insn) 2222 return -ENOMEM; 2223 2224 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 2225 2226 for (pattern = 0; pattern < BIT(8); pattern++) { 2227 u64 imm = 0; 2228 2229 for (index = 0; index < 8; index++) { 2230 int byte; 2231 2232 if (pattern & BIT(index)) 2233 byte = (base1 & mask1) | (rand & ~mask1); 2234 else 2235 byte = (base2 & mask2) | (rand & ~mask2); 2236 imm = (imm << 8) | byte; 2237 } 2238 2239 /* Update our LCG */ 2240 rand = rand * 1664525 + 1013904223; 2241 2242 /* Perform operation */ 2243 i += __bpf_ld_imm64(&insn[i], R1, imm); 2244 2245 /* Load reference */ 2246 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm); 2247 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, (u32)(imm >> 32)); 2248 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32); 2249 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3); 2250 2251 /* Check result */ 2252 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1); 2253 insn[i++] = BPF_EXIT_INSN(); 2254 } 2255 2256 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 2257 insn[i++] = BPF_EXIT_INSN(); 2258 2259 self->u.ptr.insns = insn; 2260 self->u.ptr.len = len; 2261 BUG_ON(i != len); 2262 2263 return 0; 2264} 2265 2266static int bpf_fill_ld_imm64_checker(struct bpf_test *self) 2267{ 2268 return __bpf_fill_ld_imm64_bytes(self, 0, 0xff, 0xff, 0xff); 2269} 2270 2271static int bpf_fill_ld_imm64_pos_neg(struct bpf_test *self) 2272{ 2273 return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0x80, 0x80); 2274} 2275 2276static int bpf_fill_ld_imm64_pos_zero(struct bpf_test *self) 2277{ 2278 return __bpf_fill_ld_imm64_bytes(self, 1, 0x81, 0, 0xff); 2279} 2280 2281static int bpf_fill_ld_imm64_neg_zero(struct bpf_test *self) 2282{ 2283 return __bpf_fill_ld_imm64_bytes(self, 0x80, 0x80, 0, 0xff); 2284} 2285 2286/* 2287 * Exhaustive tests of JMP operations for all combinations of power-of-two 2288 * magnitudes of the operands, both for positive and negative values. The 2289 * test is designed to verify e.g. the JMP and JMP32 operations for JITs that 2290 * emit different code depending on the magnitude of the immediate value. 2291 */ 2292 2293static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op) 2294{ 2295 switch (op) { 2296 case BPF_JSET: 2297 return !!(v1 & v2); 2298 case BPF_JEQ: 2299 return v1 == v2; 2300 case BPF_JNE: 2301 return v1 != v2; 2302 case BPF_JGT: 2303 return (u64)v1 > (u64)v2; 2304 case BPF_JGE: 2305 return (u64)v1 >= (u64)v2; 2306 case BPF_JLT: 2307 return (u64)v1 < (u64)v2; 2308 case BPF_JLE: 2309 return (u64)v1 <= (u64)v2; 2310 case BPF_JSGT: 2311 return v1 > v2; 2312 case BPF_JSGE: 2313 return v1 >= v2; 2314 case BPF_JSLT: 2315 return v1 < v2; 2316 case BPF_JSLE: 2317 return v1 <= v2; 2318 } 2319 return false; 2320} 2321 2322static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg, 2323 struct bpf_insn *insns, s64 dst, s64 imm) 2324{ 2325 int op = *(int *)arg; 2326 2327 if (insns) { 2328 bool match = __bpf_match_jmp_cond(dst, (s32)imm, op); 2329 int i = 0; 2330 2331 insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match); 2332 2333 i += __bpf_ld_imm64(&insns[i], R1, dst); 2334 insns[i++] = BPF_JMP_IMM(op, R1, imm, 1); 2335 if (!match) 2336 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1); 2337 insns[i++] = BPF_EXIT_INSN(); 2338 2339 return i; 2340 } 2341 2342 return 5 + 1; 2343} 2344 2345static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg, 2346 struct bpf_insn *insns, s64 dst, s64 imm) 2347{ 2348 int op = *(int *)arg; 2349 2350 if (insns) { 2351 bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op); 2352 int i = 0; 2353 2354 i += __bpf_ld_imm64(&insns[i], R1, dst); 2355 insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1); 2356 if (!match) 2357 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1); 2358 insns[i++] = BPF_EXIT_INSN(); 2359 2360 return i; 2361 } 2362 2363 return 5; 2364} 2365 2366static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg, 2367 struct bpf_insn *insns, s64 dst, s64 src) 2368{ 2369 int op = *(int *)arg; 2370 2371 if (insns) { 2372 bool match = __bpf_match_jmp_cond(dst, src, op); 2373 int i = 0; 2374 2375 i += __bpf_ld_imm64(&insns[i], R1, dst); 2376 i += __bpf_ld_imm64(&insns[i], R2, src); 2377 insns[i++] = BPF_JMP_REG(op, R1, R2, 1); 2378 if (!match) 2379 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1); 2380 insns[i++] = BPF_EXIT_INSN(); 2381 2382 return i; 2383 } 2384 2385 return 7; 2386} 2387 2388static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg, 2389 struct bpf_insn *insns, s64 dst, s64 src) 2390{ 2391 int op = *(int *)arg; 2392 2393 if (insns) { 2394 bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op); 2395 int i = 0; 2396 2397 i += __bpf_ld_imm64(&insns[i], R1, dst); 2398 i += __bpf_ld_imm64(&insns[i], R2, src); 2399 insns[i++] = BPF_JMP32_REG(op, R1, R2, 1); 2400 if (!match) 2401 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1); 2402 insns[i++] = BPF_EXIT_INSN(); 2403 2404 return i; 2405 } 2406 2407 return 7; 2408} 2409 2410static int __bpf_fill_jmp_imm(struct bpf_test *self, int op) 2411{ 2412 return __bpf_fill_pattern(self, &op, 64, 32, 2413 PATTERN_BLOCK1, PATTERN_BLOCK2, 2414 &__bpf_emit_jmp_imm); 2415} 2416 2417static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op) 2418{ 2419 return __bpf_fill_pattern(self, &op, 64, 32, 2420 PATTERN_BLOCK1, PATTERN_BLOCK2, 2421 &__bpf_emit_jmp32_imm); 2422} 2423 2424static int __bpf_fill_jmp_reg(struct bpf_test *self, int op) 2425{ 2426 return __bpf_fill_pattern(self, &op, 64, 64, 2427 PATTERN_BLOCK1, PATTERN_BLOCK2, 2428 &__bpf_emit_jmp_reg); 2429} 2430 2431static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op) 2432{ 2433 return __bpf_fill_pattern(self, &op, 64, 64, 2434 PATTERN_BLOCK1, PATTERN_BLOCK2, 2435 &__bpf_emit_jmp32_reg); 2436} 2437 2438/* JMP immediate tests */ 2439static int bpf_fill_jmp_jset_imm(struct bpf_test *self) 2440{ 2441 return __bpf_fill_jmp_imm(self, BPF_JSET); 2442} 2443 2444static int bpf_fill_jmp_jeq_imm(struct bpf_test *self) 2445{ 2446 return __bpf_fill_jmp_imm(self, BPF_JEQ); 2447} 2448 2449static int bpf_fill_jmp_jne_imm(struct bpf_test *self) 2450{ 2451 return __bpf_fill_jmp_imm(self, BPF_JNE); 2452} 2453 2454static int bpf_fill_jmp_jgt_imm(struct bpf_test *self) 2455{ 2456 return __bpf_fill_jmp_imm(self, BPF_JGT); 2457} 2458 2459static int bpf_fill_jmp_jge_imm(struct bpf_test *self) 2460{ 2461 return __bpf_fill_jmp_imm(self, BPF_JGE); 2462} 2463 2464static int bpf_fill_jmp_jlt_imm(struct bpf_test *self) 2465{ 2466 return __bpf_fill_jmp_imm(self, BPF_JLT); 2467} 2468 2469static int bpf_fill_jmp_jle_imm(struct bpf_test *self) 2470{ 2471 return __bpf_fill_jmp_imm(self, BPF_JLE); 2472} 2473 2474static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self) 2475{ 2476 return __bpf_fill_jmp_imm(self, BPF_JSGT); 2477} 2478 2479static int bpf_fill_jmp_jsge_imm(struct bpf_test *self) 2480{ 2481 return __bpf_fill_jmp_imm(self, BPF_JSGE); 2482} 2483 2484static int bpf_fill_jmp_jslt_imm(struct bpf_test *self) 2485{ 2486 return __bpf_fill_jmp_imm(self, BPF_JSLT); 2487} 2488 2489static int bpf_fill_jmp_jsle_imm(struct bpf_test *self) 2490{ 2491 return __bpf_fill_jmp_imm(self, BPF_JSLE); 2492} 2493 2494/* JMP32 immediate tests */ 2495static int bpf_fill_jmp32_jset_imm(struct bpf_test *self) 2496{ 2497 return __bpf_fill_jmp32_imm(self, BPF_JSET); 2498} 2499 2500static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self) 2501{ 2502 return __bpf_fill_jmp32_imm(self, BPF_JEQ); 2503} 2504 2505static int bpf_fill_jmp32_jne_imm(struct bpf_test *self) 2506{ 2507 return __bpf_fill_jmp32_imm(self, BPF_JNE); 2508} 2509 2510static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self) 2511{ 2512 return __bpf_fill_jmp32_imm(self, BPF_JGT); 2513} 2514 2515static int bpf_fill_jmp32_jge_imm(struct bpf_test *self) 2516{ 2517 return __bpf_fill_jmp32_imm(self, BPF_JGE); 2518} 2519 2520static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self) 2521{ 2522 return __bpf_fill_jmp32_imm(self, BPF_JLT); 2523} 2524 2525static int bpf_fill_jmp32_jle_imm(struct bpf_test *self) 2526{ 2527 return __bpf_fill_jmp32_imm(self, BPF_JLE); 2528} 2529 2530static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self) 2531{ 2532 return __bpf_fill_jmp32_imm(self, BPF_JSGT); 2533} 2534 2535static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self) 2536{ 2537 return __bpf_fill_jmp32_imm(self, BPF_JSGE); 2538} 2539 2540static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self) 2541{ 2542 return __bpf_fill_jmp32_imm(self, BPF_JSLT); 2543} 2544 2545static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self) 2546{ 2547 return __bpf_fill_jmp32_imm(self, BPF_JSLE); 2548} 2549 2550/* JMP register tests */ 2551static int bpf_fill_jmp_jset_reg(struct bpf_test *self) 2552{ 2553 return __bpf_fill_jmp_reg(self, BPF_JSET); 2554} 2555 2556static int bpf_fill_jmp_jeq_reg(struct bpf_test *self) 2557{ 2558 return __bpf_fill_jmp_reg(self, BPF_JEQ); 2559} 2560 2561static int bpf_fill_jmp_jne_reg(struct bpf_test *self) 2562{ 2563 return __bpf_fill_jmp_reg(self, BPF_JNE); 2564} 2565 2566static int bpf_fill_jmp_jgt_reg(struct bpf_test *self) 2567{ 2568 return __bpf_fill_jmp_reg(self, BPF_JGT); 2569} 2570 2571static int bpf_fill_jmp_jge_reg(struct bpf_test *self) 2572{ 2573 return __bpf_fill_jmp_reg(self, BPF_JGE); 2574} 2575 2576static int bpf_fill_jmp_jlt_reg(struct bpf_test *self) 2577{ 2578 return __bpf_fill_jmp_reg(self, BPF_JLT); 2579} 2580 2581static int bpf_fill_jmp_jle_reg(struct bpf_test *self) 2582{ 2583 return __bpf_fill_jmp_reg(self, BPF_JLE); 2584} 2585 2586static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self) 2587{ 2588 return __bpf_fill_jmp_reg(self, BPF_JSGT); 2589} 2590 2591static int bpf_fill_jmp_jsge_reg(struct bpf_test *self) 2592{ 2593 return __bpf_fill_jmp_reg(self, BPF_JSGE); 2594} 2595 2596static int bpf_fill_jmp_jslt_reg(struct bpf_test *self) 2597{ 2598 return __bpf_fill_jmp_reg(self, BPF_JSLT); 2599} 2600 2601static int bpf_fill_jmp_jsle_reg(struct bpf_test *self) 2602{ 2603 return __bpf_fill_jmp_reg(self, BPF_JSLE); 2604} 2605 2606/* JMP32 register tests */ 2607static int bpf_fill_jmp32_jset_reg(struct bpf_test *self) 2608{ 2609 return __bpf_fill_jmp32_reg(self, BPF_JSET); 2610} 2611 2612static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self) 2613{ 2614 return __bpf_fill_jmp32_reg(self, BPF_JEQ); 2615} 2616 2617static int bpf_fill_jmp32_jne_reg(struct bpf_test *self) 2618{ 2619 return __bpf_fill_jmp32_reg(self, BPF_JNE); 2620} 2621 2622static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self) 2623{ 2624 return __bpf_fill_jmp32_reg(self, BPF_JGT); 2625} 2626 2627static int bpf_fill_jmp32_jge_reg(struct bpf_test *self) 2628{ 2629 return __bpf_fill_jmp32_reg(self, BPF_JGE); 2630} 2631 2632static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self) 2633{ 2634 return __bpf_fill_jmp32_reg(self, BPF_JLT); 2635} 2636 2637static int bpf_fill_jmp32_jle_reg(struct bpf_test *self) 2638{ 2639 return __bpf_fill_jmp32_reg(self, BPF_JLE); 2640} 2641 2642static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self) 2643{ 2644 return __bpf_fill_jmp32_reg(self, BPF_JSGT); 2645} 2646 2647static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self) 2648{ 2649 return __bpf_fill_jmp32_reg(self, BPF_JSGE); 2650} 2651 2652static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self) 2653{ 2654 return __bpf_fill_jmp32_reg(self, BPF_JSLT); 2655} 2656 2657static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self) 2658{ 2659 return __bpf_fill_jmp32_reg(self, BPF_JSLE); 2660} 2661 2662/* 2663 * Set up a sequence of staggered jumps, forwards and backwards with 2664 * increasing offset. This tests the conversion of relative jumps to 2665 * JITed native jumps. On some architectures, for example MIPS, a large 2666 * PC-relative jump offset may overflow the immediate field of the native 2667 * conditional branch instruction, triggering a conversion to use an 2668 * absolute jump instead. Since this changes the jump offsets, another 2669 * offset computation pass is necessary, and that may in turn trigger 2670 * another branch conversion. This jump sequence is particularly nasty 2671 * in that regard. 2672 * 2673 * The sequence generation is parameterized by size and jump type. 2674 * The size must be even, and the expected result is always size + 1. 2675 * Below is an example with size=8 and result=9. 2676 * 2677 * ________________________Start 2678 * R0 = 0 2679 * R1 = r1 2680 * R2 = r2 2681 * ,------- JMP +4 * 3______________Preamble: 4 insns 2682 * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------. 2683 * | | R0 = 8 | 2684 * | | JMP +7 * 3 ------------------------. 2685 * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------. | | 2686 * | | | R0 = 6 | | | 2687 * | | | JMP +5 * 3 ------------------. | | 2688 * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------. | | | | 2689 * | | | | R0 = 4 | | | | | 2690 * | | | | JMP +3 * 3 ------------. | | | | 2691 * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--. | | | | | | 2692 * | | | | | R0 = 2 | | | | | | | 2693 * | | | | | JMP +1 * 3 ------. | | | | | | 2694 * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1 1 2 3 4 5 6 7 8 loc 2695 * | | | | | R0 = 1 -1 +2 -3 +4 -5 +6 -7 +8 off 2696 * | | | | | JMP -2 * 3 ---' | | | | | | | 2697 * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----' | | | | | | 2698 * | | | | | | R0 = 3 | | | | | | 2699 * | | | | | | JMP -4 * 3 ---------' | | | | | 2700 * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------' | | | | 2701 * | | | | | | | R0 = 5 | | | | 2702 * | | | | | | | JMP -6 * 3 ---------------' | | | 2703 * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------' | | 2704 * | | | | | | | | R0 = 7 | | 2705 * | | Error | | | JMP -8 * 3 ---------------------' | 2706 * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------' 2707 * | | | | | | | | | R0 = 9__________________Sequence: 3 * size - 1 insns 2708 * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn 2709 * 2710 */ 2711 2712/* The maximum size parameter */ 2713#define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1) 2714 2715/* We use a reduced number of iterations to get a reasonable execution time */ 2716#define NR_STAGGERED_JMP_RUNS 10 2717 2718static int __bpf_fill_staggered_jumps(struct bpf_test *self, 2719 const struct bpf_insn *jmp, 2720 u64 r1, u64 r2) 2721{ 2722 int size = self->test[0].result - 1; 2723 int len = 4 + 3 * (size + 1); 2724 struct bpf_insn *insns; 2725 int off, ind; 2726 2727 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 2728 if (!insns) 2729 return -ENOMEM; 2730 2731 /* Preamble */ 2732 insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 2733 insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1); 2734 insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2); 2735 insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2); 2736 2737 /* Sequence */ 2738 for (ind = 0, off = size; ind <= size; ind++, off -= 2) { 2739 struct bpf_insn *ins = &insns[4 + 3 * ind]; 2740 int loc; 2741 2742 if (off == 0) 2743 off--; 2744 2745 loc = abs(off); 2746 ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1, 2747 3 * (size - ind) + 1); 2748 ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc); 2749 ins[2] = *jmp; 2750 ins[2].off = 3 * (off - 1); 2751 } 2752 2753 /* Return */ 2754 insns[len - 1] = BPF_EXIT_INSN(); 2755 2756 self->u.ptr.insns = insns; 2757 self->u.ptr.len = len; 2758 2759 return 0; 2760} 2761 2762/* 64-bit unconditional jump */ 2763static int bpf_fill_staggered_ja(struct bpf_test *self) 2764{ 2765 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0); 2766 2767 return __bpf_fill_staggered_jumps(self, &jmp, 0, 0); 2768} 2769 2770/* 64-bit immediate jumps */ 2771static int bpf_fill_staggered_jeq_imm(struct bpf_test *self) 2772{ 2773 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0); 2774 2775 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2776} 2777 2778static int bpf_fill_staggered_jne_imm(struct bpf_test *self) 2779{ 2780 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0); 2781 2782 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0); 2783} 2784 2785static int bpf_fill_staggered_jset_imm(struct bpf_test *self) 2786{ 2787 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0); 2788 2789 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0); 2790} 2791 2792static int bpf_fill_staggered_jgt_imm(struct bpf_test *self) 2793{ 2794 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0); 2795 2796 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0); 2797} 2798 2799static int bpf_fill_staggered_jge_imm(struct bpf_test *self) 2800{ 2801 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0); 2802 2803 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2804} 2805 2806static int bpf_fill_staggered_jlt_imm(struct bpf_test *self) 2807{ 2808 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0); 2809 2810 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2811} 2812 2813static int bpf_fill_staggered_jle_imm(struct bpf_test *self) 2814{ 2815 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0); 2816 2817 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2818} 2819 2820static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self) 2821{ 2822 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0); 2823 2824 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0); 2825} 2826 2827static int bpf_fill_staggered_jsge_imm(struct bpf_test *self) 2828{ 2829 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0); 2830 2831 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0); 2832} 2833 2834static int bpf_fill_staggered_jslt_imm(struct bpf_test *self) 2835{ 2836 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0); 2837 2838 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0); 2839} 2840 2841static int bpf_fill_staggered_jsle_imm(struct bpf_test *self) 2842{ 2843 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0); 2844 2845 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0); 2846} 2847 2848/* 64-bit register jumps */ 2849static int bpf_fill_staggered_jeq_reg(struct bpf_test *self) 2850{ 2851 struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0); 2852 2853 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2854} 2855 2856static int bpf_fill_staggered_jne_reg(struct bpf_test *self) 2857{ 2858 struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0); 2859 2860 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234); 2861} 2862 2863static int bpf_fill_staggered_jset_reg(struct bpf_test *self) 2864{ 2865 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0); 2866 2867 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82); 2868} 2869 2870static int bpf_fill_staggered_jgt_reg(struct bpf_test *self) 2871{ 2872 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0); 2873 2874 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234); 2875} 2876 2877static int bpf_fill_staggered_jge_reg(struct bpf_test *self) 2878{ 2879 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0); 2880 2881 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2882} 2883 2884static int bpf_fill_staggered_jlt_reg(struct bpf_test *self) 2885{ 2886 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0); 2887 2888 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000); 2889} 2890 2891static int bpf_fill_staggered_jle_reg(struct bpf_test *self) 2892{ 2893 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0); 2894 2895 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2896} 2897 2898static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self) 2899{ 2900 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0); 2901 2902 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2); 2903} 2904 2905static int bpf_fill_staggered_jsge_reg(struct bpf_test *self) 2906{ 2907 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0); 2908 2909 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2); 2910} 2911 2912static int bpf_fill_staggered_jslt_reg(struct bpf_test *self) 2913{ 2914 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0); 2915 2916 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1); 2917} 2918 2919static int bpf_fill_staggered_jsle_reg(struct bpf_test *self) 2920{ 2921 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0); 2922 2923 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1); 2924} 2925 2926/* 32-bit immediate jumps */ 2927static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self) 2928{ 2929 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0); 2930 2931 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2932} 2933 2934static int bpf_fill_staggered_jne32_imm(struct bpf_test *self) 2935{ 2936 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0); 2937 2938 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0); 2939} 2940 2941static int bpf_fill_staggered_jset32_imm(struct bpf_test *self) 2942{ 2943 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0); 2944 2945 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0); 2946} 2947 2948static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self) 2949{ 2950 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0); 2951 2952 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0); 2953} 2954 2955static int bpf_fill_staggered_jge32_imm(struct bpf_test *self) 2956{ 2957 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0); 2958 2959 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2960} 2961 2962static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self) 2963{ 2964 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0); 2965 2966 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2967} 2968 2969static int bpf_fill_staggered_jle32_imm(struct bpf_test *self) 2970{ 2971 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0); 2972 2973 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2974} 2975 2976static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self) 2977{ 2978 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0); 2979 2980 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0); 2981} 2982 2983static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self) 2984{ 2985 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0); 2986 2987 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0); 2988} 2989 2990static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self) 2991{ 2992 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0); 2993 2994 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0); 2995} 2996 2997static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self) 2998{ 2999 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0); 3000 3001 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0); 3002} 3003 3004/* 32-bit register jumps */ 3005static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self) 3006{ 3007 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0); 3008 3009 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 3010} 3011 3012static int bpf_fill_staggered_jne32_reg(struct bpf_test *self) 3013{ 3014 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0); 3015 3016 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234); 3017} 3018 3019static int bpf_fill_staggered_jset32_reg(struct bpf_test *self) 3020{ 3021 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0); 3022 3023 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82); 3024} 3025 3026static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self) 3027{ 3028 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0); 3029 3030 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234); 3031} 3032 3033static int bpf_fill_staggered_jge32_reg(struct bpf_test *self) 3034{ 3035 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0); 3036 3037 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 3038} 3039 3040static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self) 3041{ 3042 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0); 3043 3044 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000); 3045} 3046 3047static int bpf_fill_staggered_jle32_reg(struct bpf_test *self) 3048{ 3049 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0); 3050 3051 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 3052} 3053 3054static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self) 3055{ 3056 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0); 3057 3058 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2); 3059} 3060 3061static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self) 3062{ 3063 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0); 3064 3065 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2); 3066} 3067 3068static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self) 3069{ 3070 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0); 3071 3072 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1); 3073} 3074 3075static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self) 3076{ 3077 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0); 3078 3079 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1); 3080} 3081 3082 3083static struct bpf_test tests[] = { 3084 { 3085 "TAX", 3086 .u.insns = { 3087 BPF_STMT(BPF_LD | BPF_IMM, 1), 3088 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3089 BPF_STMT(BPF_LD | BPF_IMM, 2), 3090 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3091 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */ 3092 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3093 BPF_STMT(BPF_LD | BPF_LEN, 0), 3094 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3095 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */ 3096 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1), 3097 BPF_STMT(BPF_RET | BPF_A, 0) 3098 }, 3099 CLASSIC, 3100 { 10, 20, 30, 40, 50 }, 3101 { { 2, 10 }, { 3, 20 }, { 4, 30 } }, 3102 }, 3103 { 3104 "TXA", 3105 .u.insns = { 3106 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3107 BPF_STMT(BPF_MISC | BPF_TXA, 0), 3108 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3109 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */ 3110 }, 3111 CLASSIC, 3112 { 10, 20, 30, 40, 50 }, 3113 { { 1, 2 }, { 3, 6 }, { 4, 8 } }, 3114 }, 3115 { 3116 "ADD_SUB_MUL_K", 3117 .u.insns = { 3118 BPF_STMT(BPF_LD | BPF_IMM, 1), 3119 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2), 3120 BPF_STMT(BPF_LDX | BPF_IMM, 3), 3121 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 3122 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff), 3123 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3), 3124 BPF_STMT(BPF_RET | BPF_A, 0) 3125 }, 3126 CLASSIC | FLAG_NO_DATA, 3127 { }, 3128 { { 0, 0xfffffffd } } 3129 }, 3130 { 3131 "DIV_MOD_KX", 3132 .u.insns = { 3133 BPF_STMT(BPF_LD | BPF_IMM, 8), 3134 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2), 3135 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3136 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 3137 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 3138 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3139 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 3140 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000), 3141 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3142 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 3143 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0), 3144 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3145 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 3146 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000), 3147 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3148 BPF_STMT(BPF_RET | BPF_A, 0) 3149 }, 3150 CLASSIC | FLAG_NO_DATA, 3151 { }, 3152 { { 0, 0x20000000 } } 3153 }, 3154 { 3155 "AND_OR_LSH_K", 3156 .u.insns = { 3157 BPF_STMT(BPF_LD | BPF_IMM, 0xff), 3158 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 3159 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27), 3160 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3161 BPF_STMT(BPF_LD | BPF_IMM, 0xf), 3162 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0), 3163 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3164 BPF_STMT(BPF_RET | BPF_A, 0) 3165 }, 3166 CLASSIC | FLAG_NO_DATA, 3167 { }, 3168 { { 0, 0x800000ff }, { 1, 0x800000ff } }, 3169 }, 3170 { 3171 "LD_IMM_0", 3172 .u.insns = { 3173 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */ 3174 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0), 3175 BPF_STMT(BPF_RET | BPF_K, 0), 3176 BPF_STMT(BPF_RET | BPF_K, 1), 3177 }, 3178 CLASSIC, 3179 { }, 3180 { { 1, 1 } }, 3181 }, 3182 { 3183 "LD_IND", 3184 .u.insns = { 3185 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3186 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K), 3187 BPF_STMT(BPF_RET | BPF_K, 1) 3188 }, 3189 CLASSIC, 3190 { }, 3191 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 3192 }, 3193 { 3194 "LD_ABS", 3195 .u.insns = { 3196 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000), 3197 BPF_STMT(BPF_RET | BPF_K, 1) 3198 }, 3199 CLASSIC, 3200 { }, 3201 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 3202 }, 3203 { 3204 "LD_ABS_LL", 3205 .u.insns = { 3206 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF), 3207 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3208 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1), 3209 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3210 BPF_STMT(BPF_RET | BPF_A, 0) 3211 }, 3212 CLASSIC, 3213 { 1, 2, 3 }, 3214 { { 1, 0 }, { 2, 3 } }, 3215 }, 3216 { 3217 "LD_IND_LL", 3218 .u.insns = { 3219 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1), 3220 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3221 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3222 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3223 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 3224 BPF_STMT(BPF_RET | BPF_A, 0) 3225 }, 3226 CLASSIC, 3227 { 1, 2, 3, 0xff }, 3228 { { 1, 1 }, { 3, 3 }, { 4, 0xff } }, 3229 }, 3230 { 3231 "LD_ABS_NET", 3232 .u.insns = { 3233 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF), 3234 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3235 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1), 3236 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3237 BPF_STMT(BPF_RET | BPF_A, 0) 3238 }, 3239 CLASSIC, 3240 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 3241 { { 15, 0 }, { 16, 3 } }, 3242 }, 3243 { 3244 "LD_IND_NET", 3245 .u.insns = { 3246 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15), 3247 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3248 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3249 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3250 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 3251 BPF_STMT(BPF_RET | BPF_A, 0) 3252 }, 3253 CLASSIC, 3254 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 3255 { { 14, 0 }, { 15, 1 }, { 17, 3 } }, 3256 }, 3257 { 3258 "LD_PKTTYPE", 3259 .u.insns = { 3260 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3261 SKF_AD_OFF + SKF_AD_PKTTYPE), 3262 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 3263 BPF_STMT(BPF_RET | BPF_K, 1), 3264 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3265 SKF_AD_OFF + SKF_AD_PKTTYPE), 3266 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 3267 BPF_STMT(BPF_RET | BPF_K, 1), 3268 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3269 SKF_AD_OFF + SKF_AD_PKTTYPE), 3270 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 3271 BPF_STMT(BPF_RET | BPF_K, 1), 3272 BPF_STMT(BPF_RET | BPF_A, 0) 3273 }, 3274 CLASSIC, 3275 { }, 3276 { { 1, 3 }, { 10, 3 } }, 3277 }, 3278 { 3279 "LD_MARK", 3280 .u.insns = { 3281 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3282 SKF_AD_OFF + SKF_AD_MARK), 3283 BPF_STMT(BPF_RET | BPF_A, 0) 3284 }, 3285 CLASSIC, 3286 { }, 3287 { { 1, SKB_MARK}, { 10, SKB_MARK} }, 3288 }, 3289 { 3290 "LD_RXHASH", 3291 .u.insns = { 3292 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3293 SKF_AD_OFF + SKF_AD_RXHASH), 3294 BPF_STMT(BPF_RET | BPF_A, 0) 3295 }, 3296 CLASSIC, 3297 { }, 3298 { { 1, SKB_HASH}, { 10, SKB_HASH} }, 3299 }, 3300 { 3301 "LD_QUEUE", 3302 .u.insns = { 3303 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3304 SKF_AD_OFF + SKF_AD_QUEUE), 3305 BPF_STMT(BPF_RET | BPF_A, 0) 3306 }, 3307 CLASSIC, 3308 { }, 3309 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } }, 3310 }, 3311 { 3312 "LD_PROTOCOL", 3313 .u.insns = { 3314 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1), 3315 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0), 3316 BPF_STMT(BPF_RET | BPF_K, 0), 3317 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3318 SKF_AD_OFF + SKF_AD_PROTOCOL), 3319 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3320 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 3321 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0), 3322 BPF_STMT(BPF_RET | BPF_K, 0), 3323 BPF_STMT(BPF_MISC | BPF_TXA, 0), 3324 BPF_STMT(BPF_RET | BPF_A, 0) 3325 }, 3326 CLASSIC, 3327 { 10, 20, 30 }, 3328 { { 10, ETH_P_IP }, { 100, ETH_P_IP } }, 3329 }, 3330 { 3331 "LD_VLAN_TAG", 3332 .u.insns = { 3333 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3334 SKF_AD_OFF + SKF_AD_VLAN_TAG), 3335 BPF_STMT(BPF_RET | BPF_A, 0) 3336 }, 3337 CLASSIC, 3338 { }, 3339 { 3340 { 1, SKB_VLAN_TCI }, 3341 { 10, SKB_VLAN_TCI } 3342 }, 3343 }, 3344 { 3345 "LD_VLAN_TAG_PRESENT", 3346 .u.insns = { 3347 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3348 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), 3349 BPF_STMT(BPF_RET | BPF_A, 0) 3350 }, 3351 CLASSIC, 3352 { }, 3353 { 3354 { 1, SKB_VLAN_PRESENT }, 3355 { 10, SKB_VLAN_PRESENT } 3356 }, 3357 }, 3358 { 3359 "LD_IFINDEX", 3360 .u.insns = { 3361 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3362 SKF_AD_OFF + SKF_AD_IFINDEX), 3363 BPF_STMT(BPF_RET | BPF_A, 0) 3364 }, 3365 CLASSIC, 3366 { }, 3367 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } }, 3368 }, 3369 { 3370 "LD_HATYPE", 3371 .u.insns = { 3372 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3373 SKF_AD_OFF + SKF_AD_HATYPE), 3374 BPF_STMT(BPF_RET | BPF_A, 0) 3375 }, 3376 CLASSIC, 3377 { }, 3378 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } }, 3379 }, 3380 { 3381 "LD_CPU", 3382 .u.insns = { 3383 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3384 SKF_AD_OFF + SKF_AD_CPU), 3385 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3386 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3387 SKF_AD_OFF + SKF_AD_CPU), 3388 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 3389 BPF_STMT(BPF_RET | BPF_A, 0) 3390 }, 3391 CLASSIC, 3392 { }, 3393 { { 1, 0 }, { 10, 0 } }, 3394 }, 3395 { 3396 "LD_NLATTR", 3397 .u.insns = { 3398 BPF_STMT(BPF_LDX | BPF_IMM, 2), 3399 BPF_STMT(BPF_MISC | BPF_TXA, 0), 3400 BPF_STMT(BPF_LDX | BPF_IMM, 3), 3401 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3402 SKF_AD_OFF + SKF_AD_NLATTR), 3403 BPF_STMT(BPF_RET | BPF_A, 0) 3404 }, 3405 CLASSIC, 3406#ifdef __BIG_ENDIAN 3407 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 }, 3408#else 3409 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 }, 3410#endif 3411 { { 4, 0 }, { 20, 6 } }, 3412 }, 3413 { 3414 "LD_NLATTR_NEST", 3415 .u.insns = { 3416 BPF_STMT(BPF_LD | BPF_IMM, 2), 3417 BPF_STMT(BPF_LDX | BPF_IMM, 3), 3418 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3419 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 3420 BPF_STMT(BPF_LD | BPF_IMM, 2), 3421 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3422 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 3423 BPF_STMT(BPF_LD | BPF_IMM, 2), 3424 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3425 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 3426 BPF_STMT(BPF_LD | BPF_IMM, 2), 3427 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3428 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 3429 BPF_STMT(BPF_LD | BPF_IMM, 2), 3430 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3431 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 3432 BPF_STMT(BPF_LD | BPF_IMM, 2), 3433 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3434 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 3435 BPF_STMT(BPF_LD | BPF_IMM, 2), 3436 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3437 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 3438 BPF_STMT(BPF_LD | BPF_IMM, 2), 3439 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3440 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 3441 BPF_STMT(BPF_RET | BPF_A, 0) 3442 }, 3443 CLASSIC, 3444#ifdef __BIG_ENDIAN 3445 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 }, 3446#else 3447 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 }, 3448#endif 3449 { { 4, 0 }, { 20, 10 } }, 3450 }, 3451 { 3452 "LD_PAYLOAD_OFF", 3453 .u.insns = { 3454 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3455 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 3456 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3457 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 3458 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3459 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 3460 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3461 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 3462 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3463 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 3464 BPF_STMT(BPF_RET | BPF_A, 0) 3465 }, 3466 CLASSIC, 3467 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800), 3468 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request, 3469 * id 9737, seq 1, length 64 3470 */ 3471 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3472 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3473 0x08, 0x00, 3474 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40, 3475 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 }, 3476 { { 30, 0 }, { 100, 42 } }, 3477 }, 3478 { 3479 "LD_ANC_XOR", 3480 .u.insns = { 3481 BPF_STMT(BPF_LD | BPF_IMM, 10), 3482 BPF_STMT(BPF_LDX | BPF_IMM, 300), 3483 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3484 SKF_AD_OFF + SKF_AD_ALU_XOR_X), 3485 BPF_STMT(BPF_RET | BPF_A, 0) 3486 }, 3487 CLASSIC, 3488 { }, 3489 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } }, 3490 }, 3491 { 3492 "SPILL_FILL", 3493 .u.insns = { 3494 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3495 BPF_STMT(BPF_LD | BPF_IMM, 2), 3496 BPF_STMT(BPF_ALU | BPF_RSH, 1), 3497 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 3498 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */ 3499 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000), 3500 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */ 3501 BPF_STMT(BPF_STX, 15), /* M3 = len */ 3502 BPF_STMT(BPF_LDX | BPF_MEM, 1), 3503 BPF_STMT(BPF_LD | BPF_MEM, 2), 3504 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 3505 BPF_STMT(BPF_LDX | BPF_MEM, 15), 3506 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 3507 BPF_STMT(BPF_RET | BPF_A, 0) 3508 }, 3509 CLASSIC, 3510 { }, 3511 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } } 3512 }, 3513 { 3514 "JEQ", 3515 .u.insns = { 3516 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3517 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 3518 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1), 3519 BPF_STMT(BPF_RET | BPF_K, 1), 3520 BPF_STMT(BPF_RET | BPF_K, MAX_K) 3521 }, 3522 CLASSIC, 3523 { 3, 3, 3, 3, 3 }, 3524 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } }, 3525 }, 3526 { 3527 "JGT", 3528 .u.insns = { 3529 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3530 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 3531 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1), 3532 BPF_STMT(BPF_RET | BPF_K, 1), 3533 BPF_STMT(BPF_RET | BPF_K, MAX_K) 3534 }, 3535 CLASSIC, 3536 { 4, 4, 4, 3, 3 }, 3537 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } }, 3538 }, 3539 { 3540 "JGE (jt 0), test 1", 3541 .u.insns = { 3542 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3543 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 3544 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1), 3545 BPF_STMT(BPF_RET | BPF_K, 1), 3546 BPF_STMT(BPF_RET | BPF_K, MAX_K) 3547 }, 3548 CLASSIC, 3549 { 4, 4, 4, 3, 3 }, 3550 { { 2, 0 }, { 3, 1 }, { 4, 1 } }, 3551 }, 3552 { 3553 "JGE (jt 0), test 2", 3554 .u.insns = { 3555 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3556 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 3557 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1), 3558 BPF_STMT(BPF_RET | BPF_K, 1), 3559 BPF_STMT(BPF_RET | BPF_K, MAX_K) 3560 }, 3561 CLASSIC, 3562 { 4, 4, 5, 3, 3 }, 3563 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } }, 3564 }, 3565 { 3566 "JGE", 3567 .u.insns = { 3568 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3569 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K), 3570 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0), 3571 BPF_STMT(BPF_RET | BPF_K, 10), 3572 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0), 3573 BPF_STMT(BPF_RET | BPF_K, 20), 3574 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0), 3575 BPF_STMT(BPF_RET | BPF_K, 30), 3576 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0), 3577 BPF_STMT(BPF_RET | BPF_K, 40), 3578 BPF_STMT(BPF_RET | BPF_K, MAX_K) 3579 }, 3580 CLASSIC, 3581 { 1, 2, 3, 4, 5 }, 3582 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } }, 3583 }, 3584 { 3585 "JSET", 3586 .u.insns = { 3587 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 3588 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1), 3589 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 3590 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 3591 BPF_STMT(BPF_LDX | BPF_LEN, 0), 3592 BPF_STMT(BPF_MISC | BPF_TXA, 0), 3593 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4), 3594 BPF_STMT(BPF_MISC | BPF_TAX, 0), 3595 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0), 3596 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1), 3597 BPF_STMT(BPF_RET | BPF_K, 10), 3598 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1), 3599 BPF_STMT(BPF_RET | BPF_K, 20), 3600 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 3601 BPF_STMT(BPF_RET | BPF_K, 30), 3602 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 3603 BPF_STMT(BPF_RET | BPF_K, 30), 3604 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 3605 BPF_STMT(BPF_RET | BPF_K, 30), 3606 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 3607 BPF_STMT(BPF_RET | BPF_K, 30), 3608 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 3609 BPF_STMT(BPF_RET | BPF_K, 30), 3610 BPF_STMT(BPF_RET | BPF_K, MAX_K) 3611 }, 3612 CLASSIC, 3613 { 0, 0xAA, 0x55, 1 }, 3614 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } }, 3615 }, 3616 { 3617 "tcpdump port 22", 3618 .u.insns = { 3619 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 3620 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */ 3621 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20), 3622 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 3623 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 3624 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17), 3625 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54), 3626 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0), 3627 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56), 3628 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13), 3629 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */ 3630 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 3631 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 3632 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 3633 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8), 3634 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 3635 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0), 3636 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 3637 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 3638 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 3639 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 3640 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1), 3641 BPF_STMT(BPF_RET | BPF_K, 0xffff), 3642 BPF_STMT(BPF_RET | BPF_K, 0), 3643 }, 3644 CLASSIC, 3645 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800) 3646 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.], 3647 * seq 1305692979:1305693027, ack 3650467037, win 65535, 3648 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48 3649 */ 3650 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 3651 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 3652 0x08, 0x00, 3653 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 3654 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 3655 0x0a, 0x01, 0x01, 0x95, /* ip src */ 3656 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 3657 0xc2, 0x24, 3658 0x00, 0x16 /* dst port */ }, 3659 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 3660 }, 3661 { 3662 "tcpdump complex", 3663 .u.insns = { 3664 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] - 3665 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and 3666 * (len > 115 or len < 30000000000)' -d 3667 */ 3668 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 3669 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0), 3670 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29), 3671 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 3672 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27), 3673 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 3674 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0), 3675 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 3676 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 3677 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 3678 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 3679 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20), 3680 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16), 3681 BPF_STMT(BPF_ST, 1), 3682 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14), 3683 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf), 3684 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2), 3685 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */ 3686 BPF_STMT(BPF_LD | BPF_MEM, 1), 3687 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 3688 BPF_STMT(BPF_ST, 5), 3689 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 3690 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26), 3691 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 3692 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2), 3693 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */ 3694 BPF_STMT(BPF_LD | BPF_MEM, 5), 3695 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0), 3696 BPF_STMT(BPF_LD | BPF_LEN, 0), 3697 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0), 3698 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0), 3699 BPF_STMT(BPF_RET | BPF_K, 0xffff), 3700 BPF_STMT(BPF_RET | BPF_K, 0), 3701 }, 3702 CLASSIC, 3703 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 3704 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 3705 0x08, 0x00, 3706 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 3707 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 3708 0x0a, 0x01, 0x01, 0x95, /* ip src */ 3709 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 3710 0xc2, 0x24, 3711 0x00, 0x16 /* dst port */ }, 3712 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 3713 }, 3714 { 3715 "RET_A", 3716 .u.insns = { 3717 /* check that uninitialized X and A contain zeros */ 3718 BPF_STMT(BPF_MISC | BPF_TXA, 0), 3719 BPF_STMT(BPF_RET | BPF_A, 0) 3720 }, 3721 CLASSIC, 3722 { }, 3723 { {1, 0}, {2, 0} }, 3724 }, 3725 { 3726 "INT: ADD trivial", 3727 .u.insns_int = { 3728 BPF_ALU64_IMM(BPF_MOV, R1, 1), 3729 BPF_ALU64_IMM(BPF_ADD, R1, 2), 3730 BPF_ALU64_IMM(BPF_MOV, R2, 3), 3731 BPF_ALU64_REG(BPF_SUB, R1, R2), 3732 BPF_ALU64_IMM(BPF_ADD, R1, -1), 3733 BPF_ALU64_IMM(BPF_MUL, R1, 3), 3734 BPF_ALU64_REG(BPF_MOV, R0, R1), 3735 BPF_EXIT_INSN(), 3736 }, 3737 INTERNAL, 3738 { }, 3739 { { 0, 0xfffffffd } } 3740 }, 3741 { 3742 "INT: MUL_X", 3743 .u.insns_int = { 3744 BPF_ALU64_IMM(BPF_MOV, R0, -1), 3745 BPF_ALU64_IMM(BPF_MOV, R1, -1), 3746 BPF_ALU64_IMM(BPF_MOV, R2, 3), 3747 BPF_ALU64_REG(BPF_MUL, R1, R2), 3748 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1), 3749 BPF_EXIT_INSN(), 3750 BPF_ALU64_IMM(BPF_MOV, R0, 1), 3751 BPF_EXIT_INSN(), 3752 }, 3753 INTERNAL, 3754 { }, 3755 { { 0, 1 } } 3756 }, 3757 { 3758 "INT: MUL_X2", 3759 .u.insns_int = { 3760 BPF_ALU32_IMM(BPF_MOV, R0, -1), 3761 BPF_ALU32_IMM(BPF_MOV, R1, -1), 3762 BPF_ALU32_IMM(BPF_MOV, R2, 3), 3763 BPF_ALU64_REG(BPF_MUL, R1, R2), 3764 BPF_ALU64_IMM(BPF_RSH, R1, 8), 3765 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1), 3766 BPF_EXIT_INSN(), 3767 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3768 BPF_EXIT_INSN(), 3769 }, 3770 INTERNAL, 3771 { }, 3772 { { 0, 1 } } 3773 }, 3774 { 3775 "INT: MUL32_X", 3776 .u.insns_int = { 3777 BPF_ALU32_IMM(BPF_MOV, R0, -1), 3778 BPF_ALU64_IMM(BPF_MOV, R1, -1), 3779 BPF_ALU32_IMM(BPF_MOV, R2, 3), 3780 BPF_ALU32_REG(BPF_MUL, R1, R2), 3781 BPF_ALU64_IMM(BPF_RSH, R1, 8), 3782 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1), 3783 BPF_EXIT_INSN(), 3784 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3785 BPF_EXIT_INSN(), 3786 }, 3787 INTERNAL, 3788 { }, 3789 { { 0, 1 } } 3790 }, 3791 { 3792 /* Have to test all register combinations, since 3793 * JITing of different registers will produce 3794 * different asm code. 3795 */ 3796 "INT: ADD 64-bit", 3797 .u.insns_int = { 3798 BPF_ALU64_IMM(BPF_MOV, R0, 0), 3799 BPF_ALU64_IMM(BPF_MOV, R1, 1), 3800 BPF_ALU64_IMM(BPF_MOV, R2, 2), 3801 BPF_ALU64_IMM(BPF_MOV, R3, 3), 3802 BPF_ALU64_IMM(BPF_MOV, R4, 4), 3803 BPF_ALU64_IMM(BPF_MOV, R5, 5), 3804 BPF_ALU64_IMM(BPF_MOV, R6, 6), 3805 BPF_ALU64_IMM(BPF_MOV, R7, 7), 3806 BPF_ALU64_IMM(BPF_MOV, R8, 8), 3807 BPF_ALU64_IMM(BPF_MOV, R9, 9), 3808 BPF_ALU64_IMM(BPF_ADD, R0, 20), 3809 BPF_ALU64_IMM(BPF_ADD, R1, 20), 3810 BPF_ALU64_IMM(BPF_ADD, R2, 20), 3811 BPF_ALU64_IMM(BPF_ADD, R3, 20), 3812 BPF_ALU64_IMM(BPF_ADD, R4, 20), 3813 BPF_ALU64_IMM(BPF_ADD, R5, 20), 3814 BPF_ALU64_IMM(BPF_ADD, R6, 20), 3815 BPF_ALU64_IMM(BPF_ADD, R7, 20), 3816 BPF_ALU64_IMM(BPF_ADD, R8, 20), 3817 BPF_ALU64_IMM(BPF_ADD, R9, 20), 3818 BPF_ALU64_IMM(BPF_SUB, R0, 10), 3819 BPF_ALU64_IMM(BPF_SUB, R1, 10), 3820 BPF_ALU64_IMM(BPF_SUB, R2, 10), 3821 BPF_ALU64_IMM(BPF_SUB, R3, 10), 3822 BPF_ALU64_IMM(BPF_SUB, R4, 10), 3823 BPF_ALU64_IMM(BPF_SUB, R5, 10), 3824 BPF_ALU64_IMM(BPF_SUB, R6, 10), 3825 BPF_ALU64_IMM(BPF_SUB, R7, 10), 3826 BPF_ALU64_IMM(BPF_SUB, R8, 10), 3827 BPF_ALU64_IMM(BPF_SUB, R9, 10), 3828 BPF_ALU64_REG(BPF_ADD, R0, R0), 3829 BPF_ALU64_REG(BPF_ADD, R0, R1), 3830 BPF_ALU64_REG(BPF_ADD, R0, R2), 3831 BPF_ALU64_REG(BPF_ADD, R0, R3), 3832 BPF_ALU64_REG(BPF_ADD, R0, R4), 3833 BPF_ALU64_REG(BPF_ADD, R0, R5), 3834 BPF_ALU64_REG(BPF_ADD, R0, R6), 3835 BPF_ALU64_REG(BPF_ADD, R0, R7), 3836 BPF_ALU64_REG(BPF_ADD, R0, R8), 3837 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 3838 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 3839 BPF_EXIT_INSN(), 3840 BPF_ALU64_REG(BPF_ADD, R1, R0), 3841 BPF_ALU64_REG(BPF_ADD, R1, R1), 3842 BPF_ALU64_REG(BPF_ADD, R1, R2), 3843 BPF_ALU64_REG(BPF_ADD, R1, R3), 3844 BPF_ALU64_REG(BPF_ADD, R1, R4), 3845 BPF_ALU64_REG(BPF_ADD, R1, R5), 3846 BPF_ALU64_REG(BPF_ADD, R1, R6), 3847 BPF_ALU64_REG(BPF_ADD, R1, R7), 3848 BPF_ALU64_REG(BPF_ADD, R1, R8), 3849 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 3850 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 3851 BPF_EXIT_INSN(), 3852 BPF_ALU64_REG(BPF_ADD, R2, R0), 3853 BPF_ALU64_REG(BPF_ADD, R2, R1), 3854 BPF_ALU64_REG(BPF_ADD, R2, R2), 3855 BPF_ALU64_REG(BPF_ADD, R2, R3), 3856 BPF_ALU64_REG(BPF_ADD, R2, R4), 3857 BPF_ALU64_REG(BPF_ADD, R2, R5), 3858 BPF_ALU64_REG(BPF_ADD, R2, R6), 3859 BPF_ALU64_REG(BPF_ADD, R2, R7), 3860 BPF_ALU64_REG(BPF_ADD, R2, R8), 3861 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 3862 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 3863 BPF_EXIT_INSN(), 3864 BPF_ALU64_REG(BPF_ADD, R3, R0), 3865 BPF_ALU64_REG(BPF_ADD, R3, R1), 3866 BPF_ALU64_REG(BPF_ADD, R3, R2), 3867 BPF_ALU64_REG(BPF_ADD, R3, R3), 3868 BPF_ALU64_REG(BPF_ADD, R3, R4), 3869 BPF_ALU64_REG(BPF_ADD, R3, R5), 3870 BPF_ALU64_REG(BPF_ADD, R3, R6), 3871 BPF_ALU64_REG(BPF_ADD, R3, R7), 3872 BPF_ALU64_REG(BPF_ADD, R3, R8), 3873 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 3874 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 3875 BPF_EXIT_INSN(), 3876 BPF_ALU64_REG(BPF_ADD, R4, R0), 3877 BPF_ALU64_REG(BPF_ADD, R4, R1), 3878 BPF_ALU64_REG(BPF_ADD, R4, R2), 3879 BPF_ALU64_REG(BPF_ADD, R4, R3), 3880 BPF_ALU64_REG(BPF_ADD, R4, R4), 3881 BPF_ALU64_REG(BPF_ADD, R4, R5), 3882 BPF_ALU64_REG(BPF_ADD, R4, R6), 3883 BPF_ALU64_REG(BPF_ADD, R4, R7), 3884 BPF_ALU64_REG(BPF_ADD, R4, R8), 3885 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 3886 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 3887 BPF_EXIT_INSN(), 3888 BPF_ALU64_REG(BPF_ADD, R5, R0), 3889 BPF_ALU64_REG(BPF_ADD, R5, R1), 3890 BPF_ALU64_REG(BPF_ADD, R5, R2), 3891 BPF_ALU64_REG(BPF_ADD, R5, R3), 3892 BPF_ALU64_REG(BPF_ADD, R5, R4), 3893 BPF_ALU64_REG(BPF_ADD, R5, R5), 3894 BPF_ALU64_REG(BPF_ADD, R5, R6), 3895 BPF_ALU64_REG(BPF_ADD, R5, R7), 3896 BPF_ALU64_REG(BPF_ADD, R5, R8), 3897 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 3898 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 3899 BPF_EXIT_INSN(), 3900 BPF_ALU64_REG(BPF_ADD, R6, R0), 3901 BPF_ALU64_REG(BPF_ADD, R6, R1), 3902 BPF_ALU64_REG(BPF_ADD, R6, R2), 3903 BPF_ALU64_REG(BPF_ADD, R6, R3), 3904 BPF_ALU64_REG(BPF_ADD, R6, R4), 3905 BPF_ALU64_REG(BPF_ADD, R6, R5), 3906 BPF_ALU64_REG(BPF_ADD, R6, R6), 3907 BPF_ALU64_REG(BPF_ADD, R6, R7), 3908 BPF_ALU64_REG(BPF_ADD, R6, R8), 3909 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 3910 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 3911 BPF_EXIT_INSN(), 3912 BPF_ALU64_REG(BPF_ADD, R7, R0), 3913 BPF_ALU64_REG(BPF_ADD, R7, R1), 3914 BPF_ALU64_REG(BPF_ADD, R7, R2), 3915 BPF_ALU64_REG(BPF_ADD, R7, R3), 3916 BPF_ALU64_REG(BPF_ADD, R7, R4), 3917 BPF_ALU64_REG(BPF_ADD, R7, R5), 3918 BPF_ALU64_REG(BPF_ADD, R7, R6), 3919 BPF_ALU64_REG(BPF_ADD, R7, R7), 3920 BPF_ALU64_REG(BPF_ADD, R7, R8), 3921 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 3922 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 3923 BPF_EXIT_INSN(), 3924 BPF_ALU64_REG(BPF_ADD, R8, R0), 3925 BPF_ALU64_REG(BPF_ADD, R8, R1), 3926 BPF_ALU64_REG(BPF_ADD, R8, R2), 3927 BPF_ALU64_REG(BPF_ADD, R8, R3), 3928 BPF_ALU64_REG(BPF_ADD, R8, R4), 3929 BPF_ALU64_REG(BPF_ADD, R8, R5), 3930 BPF_ALU64_REG(BPF_ADD, R8, R6), 3931 BPF_ALU64_REG(BPF_ADD, R8, R7), 3932 BPF_ALU64_REG(BPF_ADD, R8, R8), 3933 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 3934 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 3935 BPF_EXIT_INSN(), 3936 BPF_ALU64_REG(BPF_ADD, R9, R0), 3937 BPF_ALU64_REG(BPF_ADD, R9, R1), 3938 BPF_ALU64_REG(BPF_ADD, R9, R2), 3939 BPF_ALU64_REG(BPF_ADD, R9, R3), 3940 BPF_ALU64_REG(BPF_ADD, R9, R4), 3941 BPF_ALU64_REG(BPF_ADD, R9, R5), 3942 BPF_ALU64_REG(BPF_ADD, R9, R6), 3943 BPF_ALU64_REG(BPF_ADD, R9, R7), 3944 BPF_ALU64_REG(BPF_ADD, R9, R8), 3945 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 3946 BPF_ALU64_REG(BPF_MOV, R0, R9), 3947 BPF_EXIT_INSN(), 3948 }, 3949 INTERNAL, 3950 { }, 3951 { { 0, 2957380 } } 3952 }, 3953 { 3954 "INT: ADD 32-bit", 3955 .u.insns_int = { 3956 BPF_ALU32_IMM(BPF_MOV, R0, 20), 3957 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3958 BPF_ALU32_IMM(BPF_MOV, R2, 2), 3959 BPF_ALU32_IMM(BPF_MOV, R3, 3), 3960 BPF_ALU32_IMM(BPF_MOV, R4, 4), 3961 BPF_ALU32_IMM(BPF_MOV, R5, 5), 3962 BPF_ALU32_IMM(BPF_MOV, R6, 6), 3963 BPF_ALU32_IMM(BPF_MOV, R7, 7), 3964 BPF_ALU32_IMM(BPF_MOV, R8, 8), 3965 BPF_ALU32_IMM(BPF_MOV, R9, 9), 3966 BPF_ALU64_IMM(BPF_ADD, R1, 10), 3967 BPF_ALU64_IMM(BPF_ADD, R2, 10), 3968 BPF_ALU64_IMM(BPF_ADD, R3, 10), 3969 BPF_ALU64_IMM(BPF_ADD, R4, 10), 3970 BPF_ALU64_IMM(BPF_ADD, R5, 10), 3971 BPF_ALU64_IMM(BPF_ADD, R6, 10), 3972 BPF_ALU64_IMM(BPF_ADD, R7, 10), 3973 BPF_ALU64_IMM(BPF_ADD, R8, 10), 3974 BPF_ALU64_IMM(BPF_ADD, R9, 10), 3975 BPF_ALU32_REG(BPF_ADD, R0, R1), 3976 BPF_ALU32_REG(BPF_ADD, R0, R2), 3977 BPF_ALU32_REG(BPF_ADD, R0, R3), 3978 BPF_ALU32_REG(BPF_ADD, R0, R4), 3979 BPF_ALU32_REG(BPF_ADD, R0, R5), 3980 BPF_ALU32_REG(BPF_ADD, R0, R6), 3981 BPF_ALU32_REG(BPF_ADD, R0, R7), 3982 BPF_ALU32_REG(BPF_ADD, R0, R8), 3983 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 3984 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 3985 BPF_EXIT_INSN(), 3986 BPF_ALU32_REG(BPF_ADD, R1, R0), 3987 BPF_ALU32_REG(BPF_ADD, R1, R1), 3988 BPF_ALU32_REG(BPF_ADD, R1, R2), 3989 BPF_ALU32_REG(BPF_ADD, R1, R3), 3990 BPF_ALU32_REG(BPF_ADD, R1, R4), 3991 BPF_ALU32_REG(BPF_ADD, R1, R5), 3992 BPF_ALU32_REG(BPF_ADD, R1, R6), 3993 BPF_ALU32_REG(BPF_ADD, R1, R7), 3994 BPF_ALU32_REG(BPF_ADD, R1, R8), 3995 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 3996 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 3997 BPF_EXIT_INSN(), 3998 BPF_ALU32_REG(BPF_ADD, R2, R0), 3999 BPF_ALU32_REG(BPF_ADD, R2, R1), 4000 BPF_ALU32_REG(BPF_ADD, R2, R2), 4001 BPF_ALU32_REG(BPF_ADD, R2, R3), 4002 BPF_ALU32_REG(BPF_ADD, R2, R4), 4003 BPF_ALU32_REG(BPF_ADD, R2, R5), 4004 BPF_ALU32_REG(BPF_ADD, R2, R6), 4005 BPF_ALU32_REG(BPF_ADD, R2, R7), 4006 BPF_ALU32_REG(BPF_ADD, R2, R8), 4007 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 4008 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 4009 BPF_EXIT_INSN(), 4010 BPF_ALU32_REG(BPF_ADD, R3, R0), 4011 BPF_ALU32_REG(BPF_ADD, R3, R1), 4012 BPF_ALU32_REG(BPF_ADD, R3, R2), 4013 BPF_ALU32_REG(BPF_ADD, R3, R3), 4014 BPF_ALU32_REG(BPF_ADD, R3, R4), 4015 BPF_ALU32_REG(BPF_ADD, R3, R5), 4016 BPF_ALU32_REG(BPF_ADD, R3, R6), 4017 BPF_ALU32_REG(BPF_ADD, R3, R7), 4018 BPF_ALU32_REG(BPF_ADD, R3, R8), 4019 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 4020 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 4021 BPF_EXIT_INSN(), 4022 BPF_ALU32_REG(BPF_ADD, R4, R0), 4023 BPF_ALU32_REG(BPF_ADD, R4, R1), 4024 BPF_ALU32_REG(BPF_ADD, R4, R2), 4025 BPF_ALU32_REG(BPF_ADD, R4, R3), 4026 BPF_ALU32_REG(BPF_ADD, R4, R4), 4027 BPF_ALU32_REG(BPF_ADD, R4, R5), 4028 BPF_ALU32_REG(BPF_ADD, R4, R6), 4029 BPF_ALU32_REG(BPF_ADD, R4, R7), 4030 BPF_ALU32_REG(BPF_ADD, R4, R8), 4031 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 4032 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 4033 BPF_EXIT_INSN(), 4034 BPF_ALU32_REG(BPF_ADD, R5, R0), 4035 BPF_ALU32_REG(BPF_ADD, R5, R1), 4036 BPF_ALU32_REG(BPF_ADD, R5, R2), 4037 BPF_ALU32_REG(BPF_ADD, R5, R3), 4038 BPF_ALU32_REG(BPF_ADD, R5, R4), 4039 BPF_ALU32_REG(BPF_ADD, R5, R5), 4040 BPF_ALU32_REG(BPF_ADD, R5, R6), 4041 BPF_ALU32_REG(BPF_ADD, R5, R7), 4042 BPF_ALU32_REG(BPF_ADD, R5, R8), 4043 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 4044 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 4045 BPF_EXIT_INSN(), 4046 BPF_ALU32_REG(BPF_ADD, R6, R0), 4047 BPF_ALU32_REG(BPF_ADD, R6, R1), 4048 BPF_ALU32_REG(BPF_ADD, R6, R2), 4049 BPF_ALU32_REG(BPF_ADD, R6, R3), 4050 BPF_ALU32_REG(BPF_ADD, R6, R4), 4051 BPF_ALU32_REG(BPF_ADD, R6, R5), 4052 BPF_ALU32_REG(BPF_ADD, R6, R6), 4053 BPF_ALU32_REG(BPF_ADD, R6, R7), 4054 BPF_ALU32_REG(BPF_ADD, R6, R8), 4055 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 4056 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 4057 BPF_EXIT_INSN(), 4058 BPF_ALU32_REG(BPF_ADD, R7, R0), 4059 BPF_ALU32_REG(BPF_ADD, R7, R1), 4060 BPF_ALU32_REG(BPF_ADD, R7, R2), 4061 BPF_ALU32_REG(BPF_ADD, R7, R3), 4062 BPF_ALU32_REG(BPF_ADD, R7, R4), 4063 BPF_ALU32_REG(BPF_ADD, R7, R5), 4064 BPF_ALU32_REG(BPF_ADD, R7, R6), 4065 BPF_ALU32_REG(BPF_ADD, R7, R7), 4066 BPF_ALU32_REG(BPF_ADD, R7, R8), 4067 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 4068 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 4069 BPF_EXIT_INSN(), 4070 BPF_ALU32_REG(BPF_ADD, R8, R0), 4071 BPF_ALU32_REG(BPF_ADD, R8, R1), 4072 BPF_ALU32_REG(BPF_ADD, R8, R2), 4073 BPF_ALU32_REG(BPF_ADD, R8, R3), 4074 BPF_ALU32_REG(BPF_ADD, R8, R4), 4075 BPF_ALU32_REG(BPF_ADD, R8, R5), 4076 BPF_ALU32_REG(BPF_ADD, R8, R6), 4077 BPF_ALU32_REG(BPF_ADD, R8, R7), 4078 BPF_ALU32_REG(BPF_ADD, R8, R8), 4079 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 4080 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 4081 BPF_EXIT_INSN(), 4082 BPF_ALU32_REG(BPF_ADD, R9, R0), 4083 BPF_ALU32_REG(BPF_ADD, R9, R1), 4084 BPF_ALU32_REG(BPF_ADD, R9, R2), 4085 BPF_ALU32_REG(BPF_ADD, R9, R3), 4086 BPF_ALU32_REG(BPF_ADD, R9, R4), 4087 BPF_ALU32_REG(BPF_ADD, R9, R5), 4088 BPF_ALU32_REG(BPF_ADD, R9, R6), 4089 BPF_ALU32_REG(BPF_ADD, R9, R7), 4090 BPF_ALU32_REG(BPF_ADD, R9, R8), 4091 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 4092 BPF_ALU32_REG(BPF_MOV, R0, R9), 4093 BPF_EXIT_INSN(), 4094 }, 4095 INTERNAL, 4096 { }, 4097 { { 0, 2957380 } } 4098 }, 4099 { /* Mainly checking JIT here. */ 4100 "INT: SUB", 4101 .u.insns_int = { 4102 BPF_ALU64_IMM(BPF_MOV, R0, 0), 4103 BPF_ALU64_IMM(BPF_MOV, R1, 1), 4104 BPF_ALU64_IMM(BPF_MOV, R2, 2), 4105 BPF_ALU64_IMM(BPF_MOV, R3, 3), 4106 BPF_ALU64_IMM(BPF_MOV, R4, 4), 4107 BPF_ALU64_IMM(BPF_MOV, R5, 5), 4108 BPF_ALU64_IMM(BPF_MOV, R6, 6), 4109 BPF_ALU64_IMM(BPF_MOV, R7, 7), 4110 BPF_ALU64_IMM(BPF_MOV, R8, 8), 4111 BPF_ALU64_IMM(BPF_MOV, R9, 9), 4112 BPF_ALU64_REG(BPF_SUB, R0, R0), 4113 BPF_ALU64_REG(BPF_SUB, R0, R1), 4114 BPF_ALU64_REG(BPF_SUB, R0, R2), 4115 BPF_ALU64_REG(BPF_SUB, R0, R3), 4116 BPF_ALU64_REG(BPF_SUB, R0, R4), 4117 BPF_ALU64_REG(BPF_SUB, R0, R5), 4118 BPF_ALU64_REG(BPF_SUB, R0, R6), 4119 BPF_ALU64_REG(BPF_SUB, R0, R7), 4120 BPF_ALU64_REG(BPF_SUB, R0, R8), 4121 BPF_ALU64_REG(BPF_SUB, R0, R9), 4122 BPF_ALU64_IMM(BPF_SUB, R0, 10), 4123 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1), 4124 BPF_EXIT_INSN(), 4125 BPF_ALU64_REG(BPF_SUB, R1, R0), 4126 BPF_ALU64_REG(BPF_SUB, R1, R2), 4127 BPF_ALU64_REG(BPF_SUB, R1, R3), 4128 BPF_ALU64_REG(BPF_SUB, R1, R4), 4129 BPF_ALU64_REG(BPF_SUB, R1, R5), 4130 BPF_ALU64_REG(BPF_SUB, R1, R6), 4131 BPF_ALU64_REG(BPF_SUB, R1, R7), 4132 BPF_ALU64_REG(BPF_SUB, R1, R8), 4133 BPF_ALU64_REG(BPF_SUB, R1, R9), 4134 BPF_ALU64_IMM(BPF_SUB, R1, 10), 4135 BPF_ALU64_REG(BPF_SUB, R2, R0), 4136 BPF_ALU64_REG(BPF_SUB, R2, R1), 4137 BPF_ALU64_REG(BPF_SUB, R2, R3), 4138 BPF_ALU64_REG(BPF_SUB, R2, R4), 4139 BPF_ALU64_REG(BPF_SUB, R2, R5), 4140 BPF_ALU64_REG(BPF_SUB, R2, R6), 4141 BPF_ALU64_REG(BPF_SUB, R2, R7), 4142 BPF_ALU64_REG(BPF_SUB, R2, R8), 4143 BPF_ALU64_REG(BPF_SUB, R2, R9), 4144 BPF_ALU64_IMM(BPF_SUB, R2, 10), 4145 BPF_ALU64_REG(BPF_SUB, R3, R0), 4146 BPF_ALU64_REG(BPF_SUB, R3, R1), 4147 BPF_ALU64_REG(BPF_SUB, R3, R2), 4148 BPF_ALU64_REG(BPF_SUB, R3, R4), 4149 BPF_ALU64_REG(BPF_SUB, R3, R5), 4150 BPF_ALU64_REG(BPF_SUB, R3, R6), 4151 BPF_ALU64_REG(BPF_SUB, R3, R7), 4152 BPF_ALU64_REG(BPF_SUB, R3, R8), 4153 BPF_ALU64_REG(BPF_SUB, R3, R9), 4154 BPF_ALU64_IMM(BPF_SUB, R3, 10), 4155 BPF_ALU64_REG(BPF_SUB, R4, R0), 4156 BPF_ALU64_REG(BPF_SUB, R4, R1), 4157 BPF_ALU64_REG(BPF_SUB, R4, R2), 4158 BPF_ALU64_REG(BPF_SUB, R4, R3), 4159 BPF_ALU64_REG(BPF_SUB, R4, R5), 4160 BPF_ALU64_REG(BPF_SUB, R4, R6), 4161 BPF_ALU64_REG(BPF_SUB, R4, R7), 4162 BPF_ALU64_REG(BPF_SUB, R4, R8), 4163 BPF_ALU64_REG(BPF_SUB, R4, R9), 4164 BPF_ALU64_IMM(BPF_SUB, R4, 10), 4165 BPF_ALU64_REG(BPF_SUB, R5, R0), 4166 BPF_ALU64_REG(BPF_SUB, R5, R1), 4167 BPF_ALU64_REG(BPF_SUB, R5, R2), 4168 BPF_ALU64_REG(BPF_SUB, R5, R3), 4169 BPF_ALU64_REG(BPF_SUB, R5, R4), 4170 BPF_ALU64_REG(BPF_SUB, R5, R6), 4171 BPF_ALU64_REG(BPF_SUB, R5, R7), 4172 BPF_ALU64_REG(BPF_SUB, R5, R8), 4173 BPF_ALU64_REG(BPF_SUB, R5, R9), 4174 BPF_ALU64_IMM(BPF_SUB, R5, 10), 4175 BPF_ALU64_REG(BPF_SUB, R6, R0), 4176 BPF_ALU64_REG(BPF_SUB, R6, R1), 4177 BPF_ALU64_REG(BPF_SUB, R6, R2), 4178 BPF_ALU64_REG(BPF_SUB, R6, R3), 4179 BPF_ALU64_REG(BPF_SUB, R6, R4), 4180 BPF_ALU64_REG(BPF_SUB, R6, R5), 4181 BPF_ALU64_REG(BPF_SUB, R6, R7), 4182 BPF_ALU64_REG(BPF_SUB, R6, R8), 4183 BPF_ALU64_REG(BPF_SUB, R6, R9), 4184 BPF_ALU64_IMM(BPF_SUB, R6, 10), 4185 BPF_ALU64_REG(BPF_SUB, R7, R0), 4186 BPF_ALU64_REG(BPF_SUB, R7, R1), 4187 BPF_ALU64_REG(BPF_SUB, R7, R2), 4188 BPF_ALU64_REG(BPF_SUB, R7, R3), 4189 BPF_ALU64_REG(BPF_SUB, R7, R4), 4190 BPF_ALU64_REG(BPF_SUB, R7, R5), 4191 BPF_ALU64_REG(BPF_SUB, R7, R6), 4192 BPF_ALU64_REG(BPF_SUB, R7, R8), 4193 BPF_ALU64_REG(BPF_SUB, R7, R9), 4194 BPF_ALU64_IMM(BPF_SUB, R7, 10), 4195 BPF_ALU64_REG(BPF_SUB, R8, R0), 4196 BPF_ALU64_REG(BPF_SUB, R8, R1), 4197 BPF_ALU64_REG(BPF_SUB, R8, R2), 4198 BPF_ALU64_REG(BPF_SUB, R8, R3), 4199 BPF_ALU64_REG(BPF_SUB, R8, R4), 4200 BPF_ALU64_REG(BPF_SUB, R8, R5), 4201 BPF_ALU64_REG(BPF_SUB, R8, R6), 4202 BPF_ALU64_REG(BPF_SUB, R8, R7), 4203 BPF_ALU64_REG(BPF_SUB, R8, R9), 4204 BPF_ALU64_IMM(BPF_SUB, R8, 10), 4205 BPF_ALU64_REG(BPF_SUB, R9, R0), 4206 BPF_ALU64_REG(BPF_SUB, R9, R1), 4207 BPF_ALU64_REG(BPF_SUB, R9, R2), 4208 BPF_ALU64_REG(BPF_SUB, R9, R3), 4209 BPF_ALU64_REG(BPF_SUB, R9, R4), 4210 BPF_ALU64_REG(BPF_SUB, R9, R5), 4211 BPF_ALU64_REG(BPF_SUB, R9, R6), 4212 BPF_ALU64_REG(BPF_SUB, R9, R7), 4213 BPF_ALU64_REG(BPF_SUB, R9, R8), 4214 BPF_ALU64_IMM(BPF_SUB, R9, 10), 4215 BPF_ALU64_IMM(BPF_SUB, R0, 10), 4216 BPF_ALU64_IMM(BPF_NEG, R0, 0), 4217 BPF_ALU64_REG(BPF_SUB, R0, R1), 4218 BPF_ALU64_REG(BPF_SUB, R0, R2), 4219 BPF_ALU64_REG(BPF_SUB, R0, R3), 4220 BPF_ALU64_REG(BPF_SUB, R0, R4), 4221 BPF_ALU64_REG(BPF_SUB, R0, R5), 4222 BPF_ALU64_REG(BPF_SUB, R0, R6), 4223 BPF_ALU64_REG(BPF_SUB, R0, R7), 4224 BPF_ALU64_REG(BPF_SUB, R0, R8), 4225 BPF_ALU64_REG(BPF_SUB, R0, R9), 4226 BPF_EXIT_INSN(), 4227 }, 4228 INTERNAL, 4229 { }, 4230 { { 0, 11 } } 4231 }, 4232 { /* Mainly checking JIT here. */ 4233 "INT: XOR", 4234 .u.insns_int = { 4235 BPF_ALU64_REG(BPF_SUB, R0, R0), 4236 BPF_ALU64_REG(BPF_XOR, R1, R1), 4237 BPF_JMP_REG(BPF_JEQ, R0, R1, 1), 4238 BPF_EXIT_INSN(), 4239 BPF_ALU64_IMM(BPF_MOV, R0, 10), 4240 BPF_ALU64_IMM(BPF_MOV, R1, -1), 4241 BPF_ALU64_REG(BPF_SUB, R1, R1), 4242 BPF_ALU64_REG(BPF_XOR, R2, R2), 4243 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 4244 BPF_EXIT_INSN(), 4245 BPF_ALU64_REG(BPF_SUB, R2, R2), 4246 BPF_ALU64_REG(BPF_XOR, R3, R3), 4247 BPF_ALU64_IMM(BPF_MOV, R0, 10), 4248 BPF_ALU64_IMM(BPF_MOV, R1, -1), 4249 BPF_JMP_REG(BPF_JEQ, R2, R3, 1), 4250 BPF_EXIT_INSN(), 4251 BPF_ALU64_REG(BPF_SUB, R3, R3), 4252 BPF_ALU64_REG(BPF_XOR, R4, R4), 4253 BPF_ALU64_IMM(BPF_MOV, R2, 1), 4254 BPF_ALU64_IMM(BPF_MOV, R5, -1), 4255 BPF_JMP_REG(BPF_JEQ, R3, R4, 1), 4256 BPF_EXIT_INSN(), 4257 BPF_ALU64_REG(BPF_SUB, R4, R4), 4258 BPF_ALU64_REG(BPF_XOR, R5, R5), 4259 BPF_ALU64_IMM(BPF_MOV, R3, 1), 4260 BPF_ALU64_IMM(BPF_MOV, R7, -1), 4261 BPF_JMP_REG(BPF_JEQ, R5, R4, 1), 4262 BPF_EXIT_INSN(), 4263 BPF_ALU64_IMM(BPF_MOV, R5, 1), 4264 BPF_ALU64_REG(BPF_SUB, R5, R5), 4265 BPF_ALU64_REG(BPF_XOR, R6, R6), 4266 BPF_ALU64_IMM(BPF_MOV, R1, 1), 4267 BPF_ALU64_IMM(BPF_MOV, R8, -1), 4268 BPF_JMP_REG(BPF_JEQ, R5, R6, 1), 4269 BPF_EXIT_INSN(), 4270 BPF_ALU64_REG(BPF_SUB, R6, R6), 4271 BPF_ALU64_REG(BPF_XOR, R7, R7), 4272 BPF_JMP_REG(BPF_JEQ, R7, R6, 1), 4273 BPF_EXIT_INSN(), 4274 BPF_ALU64_REG(BPF_SUB, R7, R7), 4275 BPF_ALU64_REG(BPF_XOR, R8, R8), 4276 BPF_JMP_REG(BPF_JEQ, R7, R8, 1), 4277 BPF_EXIT_INSN(), 4278 BPF_ALU64_REG(BPF_SUB, R8, R8), 4279 BPF_ALU64_REG(BPF_XOR, R9, R9), 4280 BPF_JMP_REG(BPF_JEQ, R9, R8, 1), 4281 BPF_EXIT_INSN(), 4282 BPF_ALU64_REG(BPF_SUB, R9, R9), 4283 BPF_ALU64_REG(BPF_XOR, R0, R0), 4284 BPF_JMP_REG(BPF_JEQ, R9, R0, 1), 4285 BPF_EXIT_INSN(), 4286 BPF_ALU64_REG(BPF_SUB, R1, R1), 4287 BPF_ALU64_REG(BPF_XOR, R0, R0), 4288 BPF_JMP_REG(BPF_JEQ, R9, R0, 2), 4289 BPF_ALU64_IMM(BPF_MOV, R0, 0), 4290 BPF_EXIT_INSN(), 4291 BPF_ALU64_IMM(BPF_MOV, R0, 1), 4292 BPF_EXIT_INSN(), 4293 }, 4294 INTERNAL, 4295 { }, 4296 { { 0, 1 } } 4297 }, 4298 { /* Mainly checking JIT here. */ 4299 "INT: MUL", 4300 .u.insns_int = { 4301 BPF_ALU64_IMM(BPF_MOV, R0, 11), 4302 BPF_ALU64_IMM(BPF_MOV, R1, 1), 4303 BPF_ALU64_IMM(BPF_MOV, R2, 2), 4304 BPF_ALU64_IMM(BPF_MOV, R3, 3), 4305 BPF_ALU64_IMM(BPF_MOV, R4, 4), 4306 BPF_ALU64_IMM(BPF_MOV, R5, 5), 4307 BPF_ALU64_IMM(BPF_MOV, R6, 6), 4308 BPF_ALU64_IMM(BPF_MOV, R7, 7), 4309 BPF_ALU64_IMM(BPF_MOV, R8, 8), 4310 BPF_ALU64_IMM(BPF_MOV, R9, 9), 4311 BPF_ALU64_REG(BPF_MUL, R0, R0), 4312 BPF_ALU64_REG(BPF_MUL, R0, R1), 4313 BPF_ALU64_REG(BPF_MUL, R0, R2), 4314 BPF_ALU64_REG(BPF_MUL, R0, R3), 4315 BPF_ALU64_REG(BPF_MUL, R0, R4), 4316 BPF_ALU64_REG(BPF_MUL, R0, R5), 4317 BPF_ALU64_REG(BPF_MUL, R0, R6), 4318 BPF_ALU64_REG(BPF_MUL, R0, R7), 4319 BPF_ALU64_REG(BPF_MUL, R0, R8), 4320 BPF_ALU64_REG(BPF_MUL, R0, R9), 4321 BPF_ALU64_IMM(BPF_MUL, R0, 10), 4322 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1), 4323 BPF_EXIT_INSN(), 4324 BPF_ALU64_REG(BPF_MUL, R1, R0), 4325 BPF_ALU64_REG(BPF_MUL, R1, R2), 4326 BPF_ALU64_REG(BPF_MUL, R1, R3), 4327 BPF_ALU64_REG(BPF_MUL, R1, R4), 4328 BPF_ALU64_REG(BPF_MUL, R1, R5), 4329 BPF_ALU64_REG(BPF_MUL, R1, R6), 4330 BPF_ALU64_REG(BPF_MUL, R1, R7), 4331 BPF_ALU64_REG(BPF_MUL, R1, R8), 4332 BPF_ALU64_REG(BPF_MUL, R1, R9), 4333 BPF_ALU64_IMM(BPF_MUL, R1, 10), 4334 BPF_ALU64_REG(BPF_MOV, R2, R1), 4335 BPF_ALU64_IMM(BPF_RSH, R2, 32), 4336 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1), 4337 BPF_EXIT_INSN(), 4338 BPF_ALU64_IMM(BPF_LSH, R1, 32), 4339 BPF_ALU64_IMM(BPF_ARSH, R1, 32), 4340 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1), 4341 BPF_EXIT_INSN(), 4342 BPF_ALU64_REG(BPF_MUL, R2, R0), 4343 BPF_ALU64_REG(BPF_MUL, R2, R1), 4344 BPF_ALU64_REG(BPF_MUL, R2, R3), 4345 BPF_ALU64_REG(BPF_MUL, R2, R4), 4346 BPF_ALU64_REG(BPF_MUL, R2, R5), 4347 BPF_ALU64_REG(BPF_MUL, R2, R6), 4348 BPF_ALU64_REG(BPF_MUL, R2, R7), 4349 BPF_ALU64_REG(BPF_MUL, R2, R8), 4350 BPF_ALU64_REG(BPF_MUL, R2, R9), 4351 BPF_ALU64_IMM(BPF_MUL, R2, 10), 4352 BPF_ALU64_IMM(BPF_RSH, R2, 32), 4353 BPF_ALU64_REG(BPF_MOV, R0, R2), 4354 BPF_EXIT_INSN(), 4355 }, 4356 INTERNAL, 4357 { }, 4358 { { 0, 0x35d97ef2 } } 4359 }, 4360 { /* Mainly checking JIT here. */ 4361 "MOV REG64", 4362 .u.insns_int = { 4363 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 4364 BPF_MOV64_REG(R1, R0), 4365 BPF_MOV64_REG(R2, R1), 4366 BPF_MOV64_REG(R3, R2), 4367 BPF_MOV64_REG(R4, R3), 4368 BPF_MOV64_REG(R5, R4), 4369 BPF_MOV64_REG(R6, R5), 4370 BPF_MOV64_REG(R7, R6), 4371 BPF_MOV64_REG(R8, R7), 4372 BPF_MOV64_REG(R9, R8), 4373 BPF_ALU64_IMM(BPF_MOV, R0, 0), 4374 BPF_ALU64_IMM(BPF_MOV, R1, 0), 4375 BPF_ALU64_IMM(BPF_MOV, R2, 0), 4376 BPF_ALU64_IMM(BPF_MOV, R3, 0), 4377 BPF_ALU64_IMM(BPF_MOV, R4, 0), 4378 BPF_ALU64_IMM(BPF_MOV, R5, 0), 4379 BPF_ALU64_IMM(BPF_MOV, R6, 0), 4380 BPF_ALU64_IMM(BPF_MOV, R7, 0), 4381 BPF_ALU64_IMM(BPF_MOV, R8, 0), 4382 BPF_ALU64_IMM(BPF_MOV, R9, 0), 4383 BPF_ALU64_REG(BPF_ADD, R0, R0), 4384 BPF_ALU64_REG(BPF_ADD, R0, R1), 4385 BPF_ALU64_REG(BPF_ADD, R0, R2), 4386 BPF_ALU64_REG(BPF_ADD, R0, R3), 4387 BPF_ALU64_REG(BPF_ADD, R0, R4), 4388 BPF_ALU64_REG(BPF_ADD, R0, R5), 4389 BPF_ALU64_REG(BPF_ADD, R0, R6), 4390 BPF_ALU64_REG(BPF_ADD, R0, R7), 4391 BPF_ALU64_REG(BPF_ADD, R0, R8), 4392 BPF_ALU64_REG(BPF_ADD, R0, R9), 4393 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 4394 BPF_EXIT_INSN(), 4395 }, 4396 INTERNAL, 4397 { }, 4398 { { 0, 0xfefe } } 4399 }, 4400 { /* Mainly checking JIT here. */ 4401 "MOV REG32", 4402 .u.insns_int = { 4403 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 4404 BPF_MOV64_REG(R1, R0), 4405 BPF_MOV64_REG(R2, R1), 4406 BPF_MOV64_REG(R3, R2), 4407 BPF_MOV64_REG(R4, R3), 4408 BPF_MOV64_REG(R5, R4), 4409 BPF_MOV64_REG(R6, R5), 4410 BPF_MOV64_REG(R7, R6), 4411 BPF_MOV64_REG(R8, R7), 4412 BPF_MOV64_REG(R9, R8), 4413 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4414 BPF_ALU32_IMM(BPF_MOV, R1, 0), 4415 BPF_ALU32_IMM(BPF_MOV, R2, 0), 4416 BPF_ALU32_IMM(BPF_MOV, R3, 0), 4417 BPF_ALU32_IMM(BPF_MOV, R4, 0), 4418 BPF_ALU32_IMM(BPF_MOV, R5, 0), 4419 BPF_ALU32_IMM(BPF_MOV, R6, 0), 4420 BPF_ALU32_IMM(BPF_MOV, R7, 0), 4421 BPF_ALU32_IMM(BPF_MOV, R8, 0), 4422 BPF_ALU32_IMM(BPF_MOV, R9, 0), 4423 BPF_ALU64_REG(BPF_ADD, R0, R0), 4424 BPF_ALU64_REG(BPF_ADD, R0, R1), 4425 BPF_ALU64_REG(BPF_ADD, R0, R2), 4426 BPF_ALU64_REG(BPF_ADD, R0, R3), 4427 BPF_ALU64_REG(BPF_ADD, R0, R4), 4428 BPF_ALU64_REG(BPF_ADD, R0, R5), 4429 BPF_ALU64_REG(BPF_ADD, R0, R6), 4430 BPF_ALU64_REG(BPF_ADD, R0, R7), 4431 BPF_ALU64_REG(BPF_ADD, R0, R8), 4432 BPF_ALU64_REG(BPF_ADD, R0, R9), 4433 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 4434 BPF_EXIT_INSN(), 4435 }, 4436 INTERNAL, 4437 { }, 4438 { { 0, 0xfefe } } 4439 }, 4440 { /* Mainly checking JIT here. */ 4441 "LD IMM64", 4442 .u.insns_int = { 4443 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 4444 BPF_MOV64_REG(R1, R0), 4445 BPF_MOV64_REG(R2, R1), 4446 BPF_MOV64_REG(R3, R2), 4447 BPF_MOV64_REG(R4, R3), 4448 BPF_MOV64_REG(R5, R4), 4449 BPF_MOV64_REG(R6, R5), 4450 BPF_MOV64_REG(R7, R6), 4451 BPF_MOV64_REG(R8, R7), 4452 BPF_MOV64_REG(R9, R8), 4453 BPF_LD_IMM64(R0, 0x0LL), 4454 BPF_LD_IMM64(R1, 0x0LL), 4455 BPF_LD_IMM64(R2, 0x0LL), 4456 BPF_LD_IMM64(R3, 0x0LL), 4457 BPF_LD_IMM64(R4, 0x0LL), 4458 BPF_LD_IMM64(R5, 0x0LL), 4459 BPF_LD_IMM64(R6, 0x0LL), 4460 BPF_LD_IMM64(R7, 0x0LL), 4461 BPF_LD_IMM64(R8, 0x0LL), 4462 BPF_LD_IMM64(R9, 0x0LL), 4463 BPF_ALU64_REG(BPF_ADD, R0, R0), 4464 BPF_ALU64_REG(BPF_ADD, R0, R1), 4465 BPF_ALU64_REG(BPF_ADD, R0, R2), 4466 BPF_ALU64_REG(BPF_ADD, R0, R3), 4467 BPF_ALU64_REG(BPF_ADD, R0, R4), 4468 BPF_ALU64_REG(BPF_ADD, R0, R5), 4469 BPF_ALU64_REG(BPF_ADD, R0, R6), 4470 BPF_ALU64_REG(BPF_ADD, R0, R7), 4471 BPF_ALU64_REG(BPF_ADD, R0, R8), 4472 BPF_ALU64_REG(BPF_ADD, R0, R9), 4473 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 4474 BPF_EXIT_INSN(), 4475 }, 4476 INTERNAL, 4477 { }, 4478 { { 0, 0xfefe } } 4479 }, 4480 { 4481 "INT: ALU MIX", 4482 .u.insns_int = { 4483 BPF_ALU64_IMM(BPF_MOV, R0, 11), 4484 BPF_ALU64_IMM(BPF_ADD, R0, -1), 4485 BPF_ALU64_IMM(BPF_MOV, R2, 2), 4486 BPF_ALU64_IMM(BPF_XOR, R2, 3), 4487 BPF_ALU64_REG(BPF_DIV, R0, R2), 4488 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1), 4489 BPF_EXIT_INSN(), 4490 BPF_ALU64_IMM(BPF_MOD, R0, 3), 4491 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1), 4492 BPF_EXIT_INSN(), 4493 BPF_ALU64_IMM(BPF_MOV, R0, -1), 4494 BPF_EXIT_INSN(), 4495 }, 4496 INTERNAL, 4497 { }, 4498 { { 0, -1 } } 4499 }, 4500 { 4501 "INT: shifts by register", 4502 .u.insns_int = { 4503 BPF_MOV64_IMM(R0, -1234), 4504 BPF_MOV64_IMM(R1, 1), 4505 BPF_ALU32_REG(BPF_RSH, R0, R1), 4506 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1), 4507 BPF_EXIT_INSN(), 4508 BPF_MOV64_IMM(R2, 1), 4509 BPF_ALU64_REG(BPF_LSH, R0, R2), 4510 BPF_MOV32_IMM(R4, -1234), 4511 BPF_JMP_REG(BPF_JEQ, R0, R4, 1), 4512 BPF_EXIT_INSN(), 4513 BPF_ALU64_IMM(BPF_AND, R4, 63), 4514 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */ 4515 BPF_MOV64_IMM(R3, 47), 4516 BPF_ALU64_REG(BPF_ARSH, R0, R3), 4517 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1), 4518 BPF_EXIT_INSN(), 4519 BPF_MOV64_IMM(R2, 1), 4520 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */ 4521 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1), 4522 BPF_EXIT_INSN(), 4523 BPF_MOV64_IMM(R4, 4), 4524 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */ 4525 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1), 4526 BPF_EXIT_INSN(), 4527 BPF_MOV64_IMM(R4, 5), 4528 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */ 4529 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1), 4530 BPF_EXIT_INSN(), 4531 BPF_MOV64_IMM(R0, -1), 4532 BPF_EXIT_INSN(), 4533 }, 4534 INTERNAL, 4535 { }, 4536 { { 0, -1 } } 4537 }, 4538#ifdef CONFIG_32BIT 4539 { 4540 "INT: 32-bit context pointer word order and zero-extension", 4541 .u.insns_int = { 4542 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4543 BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3), 4544 BPF_ALU64_IMM(BPF_RSH, R1, 32), 4545 BPF_JMP32_IMM(BPF_JNE, R1, 0, 1), 4546 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4547 BPF_EXIT_INSN(), 4548 }, 4549 INTERNAL, 4550 { }, 4551 { { 0, 1 } } 4552 }, 4553#endif 4554 { 4555 "check: missing ret", 4556 .u.insns = { 4557 BPF_STMT(BPF_LD | BPF_IMM, 1), 4558 }, 4559 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4560 { }, 4561 { }, 4562 .fill_helper = NULL, 4563 .expected_errcode = -EINVAL, 4564 }, 4565 { 4566 "check: div_k_0", 4567 .u.insns = { 4568 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0), 4569 BPF_STMT(BPF_RET | BPF_K, 0) 4570 }, 4571 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4572 { }, 4573 { }, 4574 .fill_helper = NULL, 4575 .expected_errcode = -EINVAL, 4576 }, 4577 { 4578 "check: unknown insn", 4579 .u.insns = { 4580 /* seccomp insn, rejected in socket filter */ 4581 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0), 4582 BPF_STMT(BPF_RET | BPF_K, 0) 4583 }, 4584 CLASSIC | FLAG_EXPECTED_FAIL, 4585 { }, 4586 { }, 4587 .fill_helper = NULL, 4588 .expected_errcode = -EINVAL, 4589 }, 4590 { 4591 "check: out of range spill/fill", 4592 .u.insns = { 4593 BPF_STMT(BPF_STX, 16), 4594 BPF_STMT(BPF_RET | BPF_K, 0) 4595 }, 4596 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4597 { }, 4598 { }, 4599 .fill_helper = NULL, 4600 .expected_errcode = -EINVAL, 4601 }, 4602 { 4603 "JUMPS + HOLES", 4604 .u.insns = { 4605 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4606 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15), 4607 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4608 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4609 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4610 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4611 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4612 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4613 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4614 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4615 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4616 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4617 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4618 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4619 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4620 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4), 4621 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4622 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2), 4623 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4624 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 4625 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 4626 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4627 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4628 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4629 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4630 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4631 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4632 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4633 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4634 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4635 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4636 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4637 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4638 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4639 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3), 4640 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2), 4641 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4642 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 4643 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 4644 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4645 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4646 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4647 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4648 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4649 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4650 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4651 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4652 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4653 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4654 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4655 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4656 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4657 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3), 4658 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2), 4659 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4660 BPF_STMT(BPF_RET | BPF_A, 0), 4661 BPF_STMT(BPF_RET | BPF_A, 0), 4662 }, 4663 CLASSIC, 4664 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8, 4665 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4, 4666 0x08, 0x00, 4667 0x45, 0x00, 0x00, 0x28, 0x00, 0x00, 4668 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */ 4669 0xc0, 0xa8, 0x33, 0x01, 4670 0xc0, 0xa8, 0x33, 0x02, 4671 0xbb, 0xb6, 4672 0xa9, 0xfa, 4673 0x00, 0x14, 0x00, 0x00, 4674 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4675 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4676 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4677 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4678 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4679 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4680 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4681 0xcc, 0xcc, 0xcc, 0xcc }, 4682 { { 88, 0x001b } } 4683 }, 4684 { 4685 "check: RET X", 4686 .u.insns = { 4687 BPF_STMT(BPF_RET | BPF_X, 0), 4688 }, 4689 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4690 { }, 4691 { }, 4692 .fill_helper = NULL, 4693 .expected_errcode = -EINVAL, 4694 }, 4695 { 4696 "check: LDX + RET X", 4697 .u.insns = { 4698 BPF_STMT(BPF_LDX | BPF_IMM, 42), 4699 BPF_STMT(BPF_RET | BPF_X, 0), 4700 }, 4701 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4702 { }, 4703 { }, 4704 .fill_helper = NULL, 4705 .expected_errcode = -EINVAL, 4706 }, 4707 { /* Mainly checking JIT here. */ 4708 "M[]: alt STX + LDX", 4709 .u.insns = { 4710 BPF_STMT(BPF_LDX | BPF_IMM, 100), 4711 BPF_STMT(BPF_STX, 0), 4712 BPF_STMT(BPF_LDX | BPF_MEM, 0), 4713 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4714 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4715 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4716 BPF_STMT(BPF_STX, 1), 4717 BPF_STMT(BPF_LDX | BPF_MEM, 1), 4718 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4719 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4720 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4721 BPF_STMT(BPF_STX, 2), 4722 BPF_STMT(BPF_LDX | BPF_MEM, 2), 4723 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4724 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4725 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4726 BPF_STMT(BPF_STX, 3), 4727 BPF_STMT(BPF_LDX | BPF_MEM, 3), 4728 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4729 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4730 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4731 BPF_STMT(BPF_STX, 4), 4732 BPF_STMT(BPF_LDX | BPF_MEM, 4), 4733 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4734 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4735 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4736 BPF_STMT(BPF_STX, 5), 4737 BPF_STMT(BPF_LDX | BPF_MEM, 5), 4738 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4739 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4740 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4741 BPF_STMT(BPF_STX, 6), 4742 BPF_STMT(BPF_LDX | BPF_MEM, 6), 4743 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4744 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4745 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4746 BPF_STMT(BPF_STX, 7), 4747 BPF_STMT(BPF_LDX | BPF_MEM, 7), 4748 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4749 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4750 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4751 BPF_STMT(BPF_STX, 8), 4752 BPF_STMT(BPF_LDX | BPF_MEM, 8), 4753 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4754 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4755 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4756 BPF_STMT(BPF_STX, 9), 4757 BPF_STMT(BPF_LDX | BPF_MEM, 9), 4758 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4759 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4760 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4761 BPF_STMT(BPF_STX, 10), 4762 BPF_STMT(BPF_LDX | BPF_MEM, 10), 4763 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4764 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4765 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4766 BPF_STMT(BPF_STX, 11), 4767 BPF_STMT(BPF_LDX | BPF_MEM, 11), 4768 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4769 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4770 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4771 BPF_STMT(BPF_STX, 12), 4772 BPF_STMT(BPF_LDX | BPF_MEM, 12), 4773 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4774 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4775 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4776 BPF_STMT(BPF_STX, 13), 4777 BPF_STMT(BPF_LDX | BPF_MEM, 13), 4778 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4779 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4780 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4781 BPF_STMT(BPF_STX, 14), 4782 BPF_STMT(BPF_LDX | BPF_MEM, 14), 4783 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4784 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4785 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4786 BPF_STMT(BPF_STX, 15), 4787 BPF_STMT(BPF_LDX | BPF_MEM, 15), 4788 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4789 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4790 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4791 BPF_STMT(BPF_RET | BPF_A, 0), 4792 }, 4793 CLASSIC | FLAG_NO_DATA, 4794 { }, 4795 { { 0, 116 } }, 4796 }, 4797 { /* Mainly checking JIT here. */ 4798 "M[]: full STX + full LDX", 4799 .u.insns = { 4800 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb), 4801 BPF_STMT(BPF_STX, 0), 4802 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae), 4803 BPF_STMT(BPF_STX, 1), 4804 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf), 4805 BPF_STMT(BPF_STX, 2), 4806 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc), 4807 BPF_STMT(BPF_STX, 3), 4808 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb), 4809 BPF_STMT(BPF_STX, 4), 4810 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda), 4811 BPF_STMT(BPF_STX, 5), 4812 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb), 4813 BPF_STMT(BPF_STX, 6), 4814 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade), 4815 BPF_STMT(BPF_STX, 7), 4816 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec), 4817 BPF_STMT(BPF_STX, 8), 4818 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc), 4819 BPF_STMT(BPF_STX, 9), 4820 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac), 4821 BPF_STMT(BPF_STX, 10), 4822 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea), 4823 BPF_STMT(BPF_STX, 11), 4824 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb), 4825 BPF_STMT(BPF_STX, 12), 4826 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf), 4827 BPF_STMT(BPF_STX, 13), 4828 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde), 4829 BPF_STMT(BPF_STX, 14), 4830 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad), 4831 BPF_STMT(BPF_STX, 15), 4832 BPF_STMT(BPF_LDX | BPF_MEM, 0), 4833 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4834 BPF_STMT(BPF_LDX | BPF_MEM, 1), 4835 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4836 BPF_STMT(BPF_LDX | BPF_MEM, 2), 4837 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4838 BPF_STMT(BPF_LDX | BPF_MEM, 3), 4839 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4840 BPF_STMT(BPF_LDX | BPF_MEM, 4), 4841 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4842 BPF_STMT(BPF_LDX | BPF_MEM, 5), 4843 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4844 BPF_STMT(BPF_LDX | BPF_MEM, 6), 4845 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4846 BPF_STMT(BPF_LDX | BPF_MEM, 7), 4847 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4848 BPF_STMT(BPF_LDX | BPF_MEM, 8), 4849 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4850 BPF_STMT(BPF_LDX | BPF_MEM, 9), 4851 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4852 BPF_STMT(BPF_LDX | BPF_MEM, 10), 4853 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4854 BPF_STMT(BPF_LDX | BPF_MEM, 11), 4855 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4856 BPF_STMT(BPF_LDX | BPF_MEM, 12), 4857 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4858 BPF_STMT(BPF_LDX | BPF_MEM, 13), 4859 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4860 BPF_STMT(BPF_LDX | BPF_MEM, 14), 4861 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4862 BPF_STMT(BPF_LDX | BPF_MEM, 15), 4863 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4864 BPF_STMT(BPF_RET | BPF_A, 0), 4865 }, 4866 CLASSIC | FLAG_NO_DATA, 4867 { }, 4868 { { 0, 0x2a5a5e5 } }, 4869 }, 4870 { 4871 "check: SKF_AD_MAX", 4872 .u.insns = { 4873 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 4874 SKF_AD_OFF + SKF_AD_MAX), 4875 BPF_STMT(BPF_RET | BPF_A, 0), 4876 }, 4877 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4878 { }, 4879 { }, 4880 .fill_helper = NULL, 4881 .expected_errcode = -EINVAL, 4882 }, 4883 { /* Passes checker but fails during runtime. */ 4884 "LD [SKF_AD_OFF-1]", 4885 .u.insns = { 4886 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 4887 SKF_AD_OFF - 1), 4888 BPF_STMT(BPF_RET | BPF_K, 1), 4889 }, 4890 CLASSIC, 4891 { }, 4892 { { 1, 0 } }, 4893 }, 4894 { 4895 "load 64-bit immediate", 4896 .u.insns_int = { 4897 BPF_LD_IMM64(R1, 0x567800001234LL), 4898 BPF_MOV64_REG(R2, R1), 4899 BPF_MOV64_REG(R3, R2), 4900 BPF_ALU64_IMM(BPF_RSH, R2, 32), 4901 BPF_ALU64_IMM(BPF_LSH, R3, 32), 4902 BPF_ALU64_IMM(BPF_RSH, R3, 32), 4903 BPF_ALU64_IMM(BPF_MOV, R0, 0), 4904 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1), 4905 BPF_EXIT_INSN(), 4906 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1), 4907 BPF_EXIT_INSN(), 4908 BPF_LD_IMM64(R0, 0x1ffffffffLL), 4909 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */ 4910 BPF_EXIT_INSN(), 4911 }, 4912 INTERNAL, 4913 { }, 4914 { { 0, 1 } } 4915 }, 4916 /* BPF_ALU | BPF_MOV | BPF_X */ 4917 { 4918 "ALU_MOV_X: dst = 2", 4919 .u.insns_int = { 4920 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4921 BPF_ALU32_REG(BPF_MOV, R0, R1), 4922 BPF_EXIT_INSN(), 4923 }, 4924 INTERNAL, 4925 { }, 4926 { { 0, 2 } }, 4927 }, 4928 { 4929 "ALU_MOV_X: dst = 4294967295", 4930 .u.insns_int = { 4931 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 4932 BPF_ALU32_REG(BPF_MOV, R0, R1), 4933 BPF_EXIT_INSN(), 4934 }, 4935 INTERNAL, 4936 { }, 4937 { { 0, 4294967295U } }, 4938 }, 4939 { 4940 "ALU64_MOV_X: dst = 2", 4941 .u.insns_int = { 4942 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4943 BPF_ALU64_REG(BPF_MOV, R0, R1), 4944 BPF_EXIT_INSN(), 4945 }, 4946 INTERNAL, 4947 { }, 4948 { { 0, 2 } }, 4949 }, 4950 { 4951 "ALU64_MOV_X: dst = 4294967295", 4952 .u.insns_int = { 4953 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 4954 BPF_ALU64_REG(BPF_MOV, R0, R1), 4955 BPF_EXIT_INSN(), 4956 }, 4957 INTERNAL, 4958 { }, 4959 { { 0, 4294967295U } }, 4960 }, 4961 /* BPF_ALU | BPF_MOV | BPF_K */ 4962 { 4963 "ALU_MOV_K: dst = 2", 4964 .u.insns_int = { 4965 BPF_ALU32_IMM(BPF_MOV, R0, 2), 4966 BPF_EXIT_INSN(), 4967 }, 4968 INTERNAL, 4969 { }, 4970 { { 0, 2 } }, 4971 }, 4972 { 4973 "ALU_MOV_K: dst = 4294967295", 4974 .u.insns_int = { 4975 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U), 4976 BPF_EXIT_INSN(), 4977 }, 4978 INTERNAL, 4979 { }, 4980 { { 0, 4294967295U } }, 4981 }, 4982 { 4983 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff", 4984 .u.insns_int = { 4985 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4986 BPF_LD_IMM64(R3, 0x00000000ffffffffLL), 4987 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff), 4988 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4989 BPF_MOV32_IMM(R0, 2), 4990 BPF_EXIT_INSN(), 4991 BPF_MOV32_IMM(R0, 1), 4992 BPF_EXIT_INSN(), 4993 }, 4994 INTERNAL, 4995 { }, 4996 { { 0, 0x1 } }, 4997 }, 4998 { 4999 "ALU_MOV_K: small negative", 5000 .u.insns_int = { 5001 BPF_ALU32_IMM(BPF_MOV, R0, -123), 5002 BPF_EXIT_INSN(), 5003 }, 5004 INTERNAL, 5005 { }, 5006 { { 0, -123 } } 5007 }, 5008 { 5009 "ALU_MOV_K: small negative zero extension", 5010 .u.insns_int = { 5011 BPF_ALU32_IMM(BPF_MOV, R0, -123), 5012 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5013 BPF_EXIT_INSN(), 5014 }, 5015 INTERNAL, 5016 { }, 5017 { { 0, 0 } } 5018 }, 5019 { 5020 "ALU_MOV_K: large negative", 5021 .u.insns_int = { 5022 BPF_ALU32_IMM(BPF_MOV, R0, -123456789), 5023 BPF_EXIT_INSN(), 5024 }, 5025 INTERNAL, 5026 { }, 5027 { { 0, -123456789 } } 5028 }, 5029 { 5030 "ALU_MOV_K: large negative zero extension", 5031 .u.insns_int = { 5032 BPF_ALU32_IMM(BPF_MOV, R0, -123456789), 5033 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5034 BPF_EXIT_INSN(), 5035 }, 5036 INTERNAL, 5037 { }, 5038 { { 0, 0 } } 5039 }, 5040 { 5041 "ALU64_MOV_K: dst = 2", 5042 .u.insns_int = { 5043 BPF_ALU64_IMM(BPF_MOV, R0, 2), 5044 BPF_EXIT_INSN(), 5045 }, 5046 INTERNAL, 5047 { }, 5048 { { 0, 2 } }, 5049 }, 5050 { 5051 "ALU64_MOV_K: dst = 2147483647", 5052 .u.insns_int = { 5053 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647), 5054 BPF_EXIT_INSN(), 5055 }, 5056 INTERNAL, 5057 { }, 5058 { { 0, 2147483647 } }, 5059 }, 5060 { 5061 "ALU64_OR_K: dst = 0x0", 5062 .u.insns_int = { 5063 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 5064 BPF_LD_IMM64(R3, 0x0), 5065 BPF_ALU64_IMM(BPF_MOV, R2, 0x0), 5066 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5067 BPF_MOV32_IMM(R0, 2), 5068 BPF_EXIT_INSN(), 5069 BPF_MOV32_IMM(R0, 1), 5070 BPF_EXIT_INSN(), 5071 }, 5072 INTERNAL, 5073 { }, 5074 { { 0, 0x1 } }, 5075 }, 5076 { 5077 "ALU64_MOV_K: dst = -1", 5078 .u.insns_int = { 5079 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 5080 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 5081 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff), 5082 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5083 BPF_MOV32_IMM(R0, 2), 5084 BPF_EXIT_INSN(), 5085 BPF_MOV32_IMM(R0, 1), 5086 BPF_EXIT_INSN(), 5087 }, 5088 INTERNAL, 5089 { }, 5090 { { 0, 0x1 } }, 5091 }, 5092 { 5093 "ALU64_MOV_K: small negative", 5094 .u.insns_int = { 5095 BPF_ALU64_IMM(BPF_MOV, R0, -123), 5096 BPF_EXIT_INSN(), 5097 }, 5098 INTERNAL, 5099 { }, 5100 { { 0, -123 } } 5101 }, 5102 { 5103 "ALU64_MOV_K: small negative sign extension", 5104 .u.insns_int = { 5105 BPF_ALU64_IMM(BPF_MOV, R0, -123), 5106 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5107 BPF_EXIT_INSN(), 5108 }, 5109 INTERNAL, 5110 { }, 5111 { { 0, 0xffffffff } } 5112 }, 5113 { 5114 "ALU64_MOV_K: large negative", 5115 .u.insns_int = { 5116 BPF_ALU64_IMM(BPF_MOV, R0, -123456789), 5117 BPF_EXIT_INSN(), 5118 }, 5119 INTERNAL, 5120 { }, 5121 { { 0, -123456789 } } 5122 }, 5123 { 5124 "ALU64_MOV_K: large negative sign extension", 5125 .u.insns_int = { 5126 BPF_ALU64_IMM(BPF_MOV, R0, -123456789), 5127 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5128 BPF_EXIT_INSN(), 5129 }, 5130 INTERNAL, 5131 { }, 5132 { { 0, 0xffffffff } } 5133 }, 5134 /* MOVSX32 */ 5135 { 5136 "ALU_MOVSX | BPF_B", 5137 .u.insns_int = { 5138 BPF_LD_IMM64(R2, 0x00000000ffffffefLL), 5139 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL), 5140 BPF_MOVSX32_REG(R1, R3, 8), 5141 BPF_JMP_REG(BPF_JEQ, R2, R1, 2), 5142 BPF_MOV32_IMM(R0, 2), 5143 BPF_EXIT_INSN(), 5144 BPF_MOV32_IMM(R0, 1), 5145 BPF_EXIT_INSN(), 5146 }, 5147 INTERNAL, 5148 { }, 5149 { { 0, 0x1 } }, 5150 }, 5151 { 5152 "ALU_MOVSX | BPF_H", 5153 .u.insns_int = { 5154 BPF_LD_IMM64(R2, 0x00000000ffffbeefLL), 5155 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL), 5156 BPF_MOVSX32_REG(R1, R3, 16), 5157 BPF_JMP_REG(BPF_JEQ, R2, R1, 2), 5158 BPF_MOV32_IMM(R0, 2), 5159 BPF_EXIT_INSN(), 5160 BPF_MOV32_IMM(R0, 1), 5161 BPF_EXIT_INSN(), 5162 }, 5163 INTERNAL, 5164 { }, 5165 { { 0, 0x1 } }, 5166 }, 5167 /* MOVSX64 REG */ 5168 { 5169 "ALU64_MOVSX | BPF_B", 5170 .u.insns_int = { 5171 BPF_LD_IMM64(R2, 0xffffffffffffffefLL), 5172 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL), 5173 BPF_MOVSX64_REG(R1, R3, 8), 5174 BPF_JMP_REG(BPF_JEQ, R2, R1, 2), 5175 BPF_MOV32_IMM(R0, 2), 5176 BPF_EXIT_INSN(), 5177 BPF_MOV32_IMM(R0, 1), 5178 BPF_EXIT_INSN(), 5179 }, 5180 INTERNAL, 5181 { }, 5182 { { 0, 0x1 } }, 5183 }, 5184 { 5185 "ALU64_MOVSX | BPF_H", 5186 .u.insns_int = { 5187 BPF_LD_IMM64(R2, 0xffffffffffffbeefLL), 5188 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL), 5189 BPF_MOVSX64_REG(R1, R3, 16), 5190 BPF_JMP_REG(BPF_JEQ, R2, R1, 2), 5191 BPF_MOV32_IMM(R0, 2), 5192 BPF_EXIT_INSN(), 5193 BPF_MOV32_IMM(R0, 1), 5194 BPF_EXIT_INSN(), 5195 }, 5196 INTERNAL, 5197 { }, 5198 { { 0, 0x1 } }, 5199 }, 5200 { 5201 "ALU64_MOVSX | BPF_W", 5202 .u.insns_int = { 5203 BPF_LD_IMM64(R2, 0xffffffffdeadbeefLL), 5204 BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL), 5205 BPF_MOVSX64_REG(R1, R3, 32), 5206 BPF_JMP_REG(BPF_JEQ, R2, R1, 2), 5207 BPF_MOV32_IMM(R0, 2), 5208 BPF_EXIT_INSN(), 5209 BPF_MOV32_IMM(R0, 1), 5210 BPF_EXIT_INSN(), 5211 }, 5212 INTERNAL, 5213 { }, 5214 { { 0, 0x1 } }, 5215 }, 5216 /* BPF_ALU | BPF_ADD | BPF_X */ 5217 { 5218 "ALU_ADD_X: 1 + 2 = 3", 5219 .u.insns_int = { 5220 BPF_LD_IMM64(R0, 1), 5221 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5222 BPF_ALU32_REG(BPF_ADD, R0, R1), 5223 BPF_EXIT_INSN(), 5224 }, 5225 INTERNAL, 5226 { }, 5227 { { 0, 3 } }, 5228 }, 5229 { 5230 "ALU_ADD_X: 1 + 4294967294 = 4294967295", 5231 .u.insns_int = { 5232 BPF_LD_IMM64(R0, 1), 5233 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 5234 BPF_ALU32_REG(BPF_ADD, R0, R1), 5235 BPF_EXIT_INSN(), 5236 }, 5237 INTERNAL, 5238 { }, 5239 { { 0, 4294967295U } }, 5240 }, 5241 { 5242 "ALU_ADD_X: 2 + 4294967294 = 0", 5243 .u.insns_int = { 5244 BPF_LD_IMM64(R0, 2), 5245 BPF_LD_IMM64(R1, 4294967294U), 5246 BPF_ALU32_REG(BPF_ADD, R0, R1), 5247 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2), 5248 BPF_ALU32_IMM(BPF_MOV, R0, 0), 5249 BPF_EXIT_INSN(), 5250 BPF_ALU32_IMM(BPF_MOV, R0, 1), 5251 BPF_EXIT_INSN(), 5252 }, 5253 INTERNAL, 5254 { }, 5255 { { 0, 1 } }, 5256 }, 5257 { 5258 "ALU64_ADD_X: 1 + 2 = 3", 5259 .u.insns_int = { 5260 BPF_LD_IMM64(R0, 1), 5261 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5262 BPF_ALU64_REG(BPF_ADD, R0, R1), 5263 BPF_EXIT_INSN(), 5264 }, 5265 INTERNAL, 5266 { }, 5267 { { 0, 3 } }, 5268 }, 5269 { 5270 "ALU64_ADD_X: 1 + 4294967294 = 4294967295", 5271 .u.insns_int = { 5272 BPF_LD_IMM64(R0, 1), 5273 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 5274 BPF_ALU64_REG(BPF_ADD, R0, R1), 5275 BPF_EXIT_INSN(), 5276 }, 5277 INTERNAL, 5278 { }, 5279 { { 0, 4294967295U } }, 5280 }, 5281 { 5282 "ALU64_ADD_X: 2 + 4294967294 = 4294967296", 5283 .u.insns_int = { 5284 BPF_LD_IMM64(R0, 2), 5285 BPF_LD_IMM64(R1, 4294967294U), 5286 BPF_LD_IMM64(R2, 4294967296ULL), 5287 BPF_ALU64_REG(BPF_ADD, R0, R1), 5288 BPF_JMP_REG(BPF_JEQ, R0, R2, 2), 5289 BPF_MOV32_IMM(R0, 0), 5290 BPF_EXIT_INSN(), 5291 BPF_MOV32_IMM(R0, 1), 5292 BPF_EXIT_INSN(), 5293 }, 5294 INTERNAL, 5295 { }, 5296 { { 0, 1 } }, 5297 }, 5298 /* BPF_ALU | BPF_ADD | BPF_K */ 5299 { 5300 "ALU_ADD_K: 1 + 2 = 3", 5301 .u.insns_int = { 5302 BPF_LD_IMM64(R0, 1), 5303 BPF_ALU32_IMM(BPF_ADD, R0, 2), 5304 BPF_EXIT_INSN(), 5305 }, 5306 INTERNAL, 5307 { }, 5308 { { 0, 3 } }, 5309 }, 5310 { 5311 "ALU_ADD_K: 3 + 0 = 3", 5312 .u.insns_int = { 5313 BPF_LD_IMM64(R0, 3), 5314 BPF_ALU32_IMM(BPF_ADD, R0, 0), 5315 BPF_EXIT_INSN(), 5316 }, 5317 INTERNAL, 5318 { }, 5319 { { 0, 3 } }, 5320 }, 5321 { 5322 "ALU_ADD_K: 1 + 4294967294 = 4294967295", 5323 .u.insns_int = { 5324 BPF_LD_IMM64(R0, 1), 5325 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U), 5326 BPF_EXIT_INSN(), 5327 }, 5328 INTERNAL, 5329 { }, 5330 { { 0, 4294967295U } }, 5331 }, 5332 { 5333 "ALU_ADD_K: 4294967294 + 2 = 0", 5334 .u.insns_int = { 5335 BPF_LD_IMM64(R0, 4294967294U), 5336 BPF_ALU32_IMM(BPF_ADD, R0, 2), 5337 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2), 5338 BPF_ALU32_IMM(BPF_MOV, R0, 0), 5339 BPF_EXIT_INSN(), 5340 BPF_ALU32_IMM(BPF_MOV, R0, 1), 5341 BPF_EXIT_INSN(), 5342 }, 5343 INTERNAL, 5344 { }, 5345 { { 0, 1 } }, 5346 }, 5347 { 5348 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff", 5349 .u.insns_int = { 5350 BPF_LD_IMM64(R2, 0x0), 5351 BPF_LD_IMM64(R3, 0x00000000ffffffff), 5352 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff), 5353 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5354 BPF_MOV32_IMM(R0, 2), 5355 BPF_EXIT_INSN(), 5356 BPF_MOV32_IMM(R0, 1), 5357 BPF_EXIT_INSN(), 5358 }, 5359 INTERNAL, 5360 { }, 5361 { { 0, 0x1 } }, 5362 }, 5363 { 5364 "ALU_ADD_K: 0 + 0xffff = 0xffff", 5365 .u.insns_int = { 5366 BPF_LD_IMM64(R2, 0x0), 5367 BPF_LD_IMM64(R3, 0xffff), 5368 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff), 5369 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5370 BPF_MOV32_IMM(R0, 2), 5371 BPF_EXIT_INSN(), 5372 BPF_MOV32_IMM(R0, 1), 5373 BPF_EXIT_INSN(), 5374 }, 5375 INTERNAL, 5376 { }, 5377 { { 0, 0x1 } }, 5378 }, 5379 { 5380 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff", 5381 .u.insns_int = { 5382 BPF_LD_IMM64(R2, 0x0), 5383 BPF_LD_IMM64(R3, 0x7fffffff), 5384 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff), 5385 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5386 BPF_MOV32_IMM(R0, 2), 5387 BPF_EXIT_INSN(), 5388 BPF_MOV32_IMM(R0, 1), 5389 BPF_EXIT_INSN(), 5390 }, 5391 INTERNAL, 5392 { }, 5393 { { 0, 0x1 } }, 5394 }, 5395 { 5396 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000", 5397 .u.insns_int = { 5398 BPF_LD_IMM64(R2, 0x0), 5399 BPF_LD_IMM64(R3, 0x80000000), 5400 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000), 5401 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5402 BPF_MOV32_IMM(R0, 2), 5403 BPF_EXIT_INSN(), 5404 BPF_MOV32_IMM(R0, 1), 5405 BPF_EXIT_INSN(), 5406 }, 5407 INTERNAL, 5408 { }, 5409 { { 0, 0x1 } }, 5410 }, 5411 { 5412 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000", 5413 .u.insns_int = { 5414 BPF_LD_IMM64(R2, 0x0), 5415 BPF_LD_IMM64(R3, 0x80008000), 5416 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000), 5417 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5418 BPF_MOV32_IMM(R0, 2), 5419 BPF_EXIT_INSN(), 5420 BPF_MOV32_IMM(R0, 1), 5421 BPF_EXIT_INSN(), 5422 }, 5423 INTERNAL, 5424 { }, 5425 { { 0, 0x1 } }, 5426 }, 5427 { 5428 "ALU64_ADD_K: 1 + 2 = 3", 5429 .u.insns_int = { 5430 BPF_LD_IMM64(R0, 1), 5431 BPF_ALU64_IMM(BPF_ADD, R0, 2), 5432 BPF_EXIT_INSN(), 5433 }, 5434 INTERNAL, 5435 { }, 5436 { { 0, 3 } }, 5437 }, 5438 { 5439 "ALU64_ADD_K: 3 + 0 = 3", 5440 .u.insns_int = { 5441 BPF_LD_IMM64(R0, 3), 5442 BPF_ALU64_IMM(BPF_ADD, R0, 0), 5443 BPF_EXIT_INSN(), 5444 }, 5445 INTERNAL, 5446 { }, 5447 { { 0, 3 } }, 5448 }, 5449 { 5450 "ALU64_ADD_K: 1 + 2147483646 = 2147483647", 5451 .u.insns_int = { 5452 BPF_LD_IMM64(R0, 1), 5453 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646), 5454 BPF_EXIT_INSN(), 5455 }, 5456 INTERNAL, 5457 { }, 5458 { { 0, 2147483647 } }, 5459 }, 5460 { 5461 "ALU64_ADD_K: 4294967294 + 2 = 4294967296", 5462 .u.insns_int = { 5463 BPF_LD_IMM64(R0, 4294967294U), 5464 BPF_LD_IMM64(R1, 4294967296ULL), 5465 BPF_ALU64_IMM(BPF_ADD, R0, 2), 5466 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 5467 BPF_ALU32_IMM(BPF_MOV, R0, 0), 5468 BPF_EXIT_INSN(), 5469 BPF_ALU32_IMM(BPF_MOV, R0, 1), 5470 BPF_EXIT_INSN(), 5471 }, 5472 INTERNAL, 5473 { }, 5474 { { 0, 1 } }, 5475 }, 5476 { 5477 "ALU64_ADD_K: 2147483646 + -2147483647 = -1", 5478 .u.insns_int = { 5479 BPF_LD_IMM64(R0, 2147483646), 5480 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647), 5481 BPF_EXIT_INSN(), 5482 }, 5483 INTERNAL, 5484 { }, 5485 { { 0, -1 } }, 5486 }, 5487 { 5488 "ALU64_ADD_K: 1 + 0 = 1", 5489 .u.insns_int = { 5490 BPF_LD_IMM64(R2, 0x1), 5491 BPF_LD_IMM64(R3, 0x1), 5492 BPF_ALU64_IMM(BPF_ADD, R2, 0x0), 5493 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5494 BPF_MOV32_IMM(R0, 2), 5495 BPF_EXIT_INSN(), 5496 BPF_MOV32_IMM(R0, 1), 5497 BPF_EXIT_INSN(), 5498 }, 5499 INTERNAL, 5500 { }, 5501 { { 0, 0x1 } }, 5502 }, 5503 { 5504 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff", 5505 .u.insns_int = { 5506 BPF_LD_IMM64(R2, 0x0), 5507 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 5508 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff), 5509 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5510 BPF_MOV32_IMM(R0, 2), 5511 BPF_EXIT_INSN(), 5512 BPF_MOV32_IMM(R0, 1), 5513 BPF_EXIT_INSN(), 5514 }, 5515 INTERNAL, 5516 { }, 5517 { { 0, 0x1 } }, 5518 }, 5519 { 5520 "ALU64_ADD_K: 0 + 0xffff = 0xffff", 5521 .u.insns_int = { 5522 BPF_LD_IMM64(R2, 0x0), 5523 BPF_LD_IMM64(R3, 0xffff), 5524 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff), 5525 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5526 BPF_MOV32_IMM(R0, 2), 5527 BPF_EXIT_INSN(), 5528 BPF_MOV32_IMM(R0, 1), 5529 BPF_EXIT_INSN(), 5530 }, 5531 INTERNAL, 5532 { }, 5533 { { 0, 0x1 } }, 5534 }, 5535 { 5536 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff", 5537 .u.insns_int = { 5538 BPF_LD_IMM64(R2, 0x0), 5539 BPF_LD_IMM64(R3, 0x7fffffff), 5540 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff), 5541 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5542 BPF_MOV32_IMM(R0, 2), 5543 BPF_EXIT_INSN(), 5544 BPF_MOV32_IMM(R0, 1), 5545 BPF_EXIT_INSN(), 5546 }, 5547 INTERNAL, 5548 { }, 5549 { { 0, 0x1 } }, 5550 }, 5551 { 5552 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000", 5553 .u.insns_int = { 5554 BPF_LD_IMM64(R2, 0x0), 5555 BPF_LD_IMM64(R3, 0xffffffff80000000LL), 5556 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000), 5557 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5558 BPF_MOV32_IMM(R0, 2), 5559 BPF_EXIT_INSN(), 5560 BPF_MOV32_IMM(R0, 1), 5561 BPF_EXIT_INSN(), 5562 }, 5563 INTERNAL, 5564 { }, 5565 { { 0, 0x1 } }, 5566 }, 5567 { 5568 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000", 5569 .u.insns_int = { 5570 BPF_LD_IMM64(R2, 0x0), 5571 BPF_LD_IMM64(R3, 0xffffffff80008000LL), 5572 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000), 5573 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5574 BPF_MOV32_IMM(R0, 2), 5575 BPF_EXIT_INSN(), 5576 BPF_MOV32_IMM(R0, 1), 5577 BPF_EXIT_INSN(), 5578 }, 5579 INTERNAL, 5580 { }, 5581 { { 0, 0x1 } }, 5582 }, 5583 /* BPF_ALU | BPF_SUB | BPF_X */ 5584 { 5585 "ALU_SUB_X: 3 - 1 = 2", 5586 .u.insns_int = { 5587 BPF_LD_IMM64(R0, 3), 5588 BPF_ALU32_IMM(BPF_MOV, R1, 1), 5589 BPF_ALU32_REG(BPF_SUB, R0, R1), 5590 BPF_EXIT_INSN(), 5591 }, 5592 INTERNAL, 5593 { }, 5594 { { 0, 2 } }, 5595 }, 5596 { 5597 "ALU_SUB_X: 4294967295 - 4294967294 = 1", 5598 .u.insns_int = { 5599 BPF_LD_IMM64(R0, 4294967295U), 5600 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 5601 BPF_ALU32_REG(BPF_SUB, R0, R1), 5602 BPF_EXIT_INSN(), 5603 }, 5604 INTERNAL, 5605 { }, 5606 { { 0, 1 } }, 5607 }, 5608 { 5609 "ALU64_SUB_X: 3 - 1 = 2", 5610 .u.insns_int = { 5611 BPF_LD_IMM64(R0, 3), 5612 BPF_ALU32_IMM(BPF_MOV, R1, 1), 5613 BPF_ALU64_REG(BPF_SUB, R0, R1), 5614 BPF_EXIT_INSN(), 5615 }, 5616 INTERNAL, 5617 { }, 5618 { { 0, 2 } }, 5619 }, 5620 { 5621 "ALU64_SUB_X: 4294967295 - 4294967294 = 1", 5622 .u.insns_int = { 5623 BPF_LD_IMM64(R0, 4294967295U), 5624 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 5625 BPF_ALU64_REG(BPF_SUB, R0, R1), 5626 BPF_EXIT_INSN(), 5627 }, 5628 INTERNAL, 5629 { }, 5630 { { 0, 1 } }, 5631 }, 5632 /* BPF_ALU | BPF_SUB | BPF_K */ 5633 { 5634 "ALU_SUB_K: 3 - 1 = 2", 5635 .u.insns_int = { 5636 BPF_LD_IMM64(R0, 3), 5637 BPF_ALU32_IMM(BPF_SUB, R0, 1), 5638 BPF_EXIT_INSN(), 5639 }, 5640 INTERNAL, 5641 { }, 5642 { { 0, 2 } }, 5643 }, 5644 { 5645 "ALU_SUB_K: 3 - 0 = 3", 5646 .u.insns_int = { 5647 BPF_LD_IMM64(R0, 3), 5648 BPF_ALU32_IMM(BPF_SUB, R0, 0), 5649 BPF_EXIT_INSN(), 5650 }, 5651 INTERNAL, 5652 { }, 5653 { { 0, 3 } }, 5654 }, 5655 { 5656 "ALU_SUB_K: 4294967295 - 4294967294 = 1", 5657 .u.insns_int = { 5658 BPF_LD_IMM64(R0, 4294967295U), 5659 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U), 5660 BPF_EXIT_INSN(), 5661 }, 5662 INTERNAL, 5663 { }, 5664 { { 0, 1 } }, 5665 }, 5666 { 5667 "ALU64_SUB_K: 3 - 1 = 2", 5668 .u.insns_int = { 5669 BPF_LD_IMM64(R0, 3), 5670 BPF_ALU64_IMM(BPF_SUB, R0, 1), 5671 BPF_EXIT_INSN(), 5672 }, 5673 INTERNAL, 5674 { }, 5675 { { 0, 2 } }, 5676 }, 5677 { 5678 "ALU64_SUB_K: 3 - 0 = 3", 5679 .u.insns_int = { 5680 BPF_LD_IMM64(R0, 3), 5681 BPF_ALU64_IMM(BPF_SUB, R0, 0), 5682 BPF_EXIT_INSN(), 5683 }, 5684 INTERNAL, 5685 { }, 5686 { { 0, 3 } }, 5687 }, 5688 { 5689 "ALU64_SUB_K: 4294967294 - 4294967295 = -1", 5690 .u.insns_int = { 5691 BPF_LD_IMM64(R0, 4294967294U), 5692 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U), 5693 BPF_EXIT_INSN(), 5694 }, 5695 INTERNAL, 5696 { }, 5697 { { 0, -1 } }, 5698 }, 5699 { 5700 "ALU64_ADD_K: 2147483646 - 2147483647 = -1", 5701 .u.insns_int = { 5702 BPF_LD_IMM64(R0, 2147483646), 5703 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647), 5704 BPF_EXIT_INSN(), 5705 }, 5706 INTERNAL, 5707 { }, 5708 { { 0, -1 } }, 5709 }, 5710 /* BPF_ALU | BPF_MUL | BPF_X */ 5711 { 5712 "ALU_MUL_X: 2 * 3 = 6", 5713 .u.insns_int = { 5714 BPF_LD_IMM64(R0, 2), 5715 BPF_ALU32_IMM(BPF_MOV, R1, 3), 5716 BPF_ALU32_REG(BPF_MUL, R0, R1), 5717 BPF_EXIT_INSN(), 5718 }, 5719 INTERNAL, 5720 { }, 5721 { { 0, 6 } }, 5722 }, 5723 { 5724 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0", 5725 .u.insns_int = { 5726 BPF_LD_IMM64(R0, 2), 5727 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8), 5728 BPF_ALU32_REG(BPF_MUL, R0, R1), 5729 BPF_EXIT_INSN(), 5730 }, 5731 INTERNAL, 5732 { }, 5733 { { 0, 0xFFFFFFF0 } }, 5734 }, 5735 { 5736 "ALU_MUL_X: -1 * -1 = 1", 5737 .u.insns_int = { 5738 BPF_LD_IMM64(R0, -1), 5739 BPF_ALU32_IMM(BPF_MOV, R1, -1), 5740 BPF_ALU32_REG(BPF_MUL, R0, R1), 5741 BPF_EXIT_INSN(), 5742 }, 5743 INTERNAL, 5744 { }, 5745 { { 0, 1 } }, 5746 }, 5747 { 5748 "ALU64_MUL_X: 2 * 3 = 6", 5749 .u.insns_int = { 5750 BPF_LD_IMM64(R0, 2), 5751 BPF_ALU32_IMM(BPF_MOV, R1, 3), 5752 BPF_ALU64_REG(BPF_MUL, R0, R1), 5753 BPF_EXIT_INSN(), 5754 }, 5755 INTERNAL, 5756 { }, 5757 { { 0, 6 } }, 5758 }, 5759 { 5760 "ALU64_MUL_X: 1 * 2147483647 = 2147483647", 5761 .u.insns_int = { 5762 BPF_LD_IMM64(R0, 1), 5763 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647), 5764 BPF_ALU64_REG(BPF_MUL, R0, R1), 5765 BPF_EXIT_INSN(), 5766 }, 5767 INTERNAL, 5768 { }, 5769 { { 0, 2147483647 } }, 5770 }, 5771 { 5772 "ALU64_MUL_X: 64x64 multiply, low word", 5773 .u.insns_int = { 5774 BPF_LD_IMM64(R0, 0x0fedcba987654321LL), 5775 BPF_LD_IMM64(R1, 0x123456789abcdef0LL), 5776 BPF_ALU64_REG(BPF_MUL, R0, R1), 5777 BPF_EXIT_INSN(), 5778 }, 5779 INTERNAL, 5780 { }, 5781 { { 0, 0xe5618cf0 } } 5782 }, 5783 { 5784 "ALU64_MUL_X: 64x64 multiply, high word", 5785 .u.insns_int = { 5786 BPF_LD_IMM64(R0, 0x0fedcba987654321LL), 5787 BPF_LD_IMM64(R1, 0x123456789abcdef0LL), 5788 BPF_ALU64_REG(BPF_MUL, R0, R1), 5789 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5790 BPF_EXIT_INSN(), 5791 }, 5792 INTERNAL, 5793 { }, 5794 { { 0, 0x2236d88f } } 5795 }, 5796 /* BPF_ALU | BPF_MUL | BPF_K */ 5797 { 5798 "ALU_MUL_K: 2 * 3 = 6", 5799 .u.insns_int = { 5800 BPF_LD_IMM64(R0, 2), 5801 BPF_ALU32_IMM(BPF_MUL, R0, 3), 5802 BPF_EXIT_INSN(), 5803 }, 5804 INTERNAL, 5805 { }, 5806 { { 0, 6 } }, 5807 }, 5808 { 5809 "ALU_MUL_K: 3 * 1 = 3", 5810 .u.insns_int = { 5811 BPF_LD_IMM64(R0, 3), 5812 BPF_ALU32_IMM(BPF_MUL, R0, 1), 5813 BPF_EXIT_INSN(), 5814 }, 5815 INTERNAL, 5816 { }, 5817 { { 0, 3 } }, 5818 }, 5819 { 5820 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0", 5821 .u.insns_int = { 5822 BPF_LD_IMM64(R0, 2), 5823 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8), 5824 BPF_EXIT_INSN(), 5825 }, 5826 INTERNAL, 5827 { }, 5828 { { 0, 0xFFFFFFF0 } }, 5829 }, 5830 { 5831 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff", 5832 .u.insns_int = { 5833 BPF_LD_IMM64(R2, 0x1), 5834 BPF_LD_IMM64(R3, 0x00000000ffffffff), 5835 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff), 5836 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5837 BPF_MOV32_IMM(R0, 2), 5838 BPF_EXIT_INSN(), 5839 BPF_MOV32_IMM(R0, 1), 5840 BPF_EXIT_INSN(), 5841 }, 5842 INTERNAL, 5843 { }, 5844 { { 0, 0x1 } }, 5845 }, 5846 { 5847 "ALU64_MUL_K: 2 * 3 = 6", 5848 .u.insns_int = { 5849 BPF_LD_IMM64(R0, 2), 5850 BPF_ALU64_IMM(BPF_MUL, R0, 3), 5851 BPF_EXIT_INSN(), 5852 }, 5853 INTERNAL, 5854 { }, 5855 { { 0, 6 } }, 5856 }, 5857 { 5858 "ALU64_MUL_K: 3 * 1 = 3", 5859 .u.insns_int = { 5860 BPF_LD_IMM64(R0, 3), 5861 BPF_ALU64_IMM(BPF_MUL, R0, 1), 5862 BPF_EXIT_INSN(), 5863 }, 5864 INTERNAL, 5865 { }, 5866 { { 0, 3 } }, 5867 }, 5868 { 5869 "ALU64_MUL_K: 1 * 2147483647 = 2147483647", 5870 .u.insns_int = { 5871 BPF_LD_IMM64(R0, 1), 5872 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647), 5873 BPF_EXIT_INSN(), 5874 }, 5875 INTERNAL, 5876 { }, 5877 { { 0, 2147483647 } }, 5878 }, 5879 { 5880 "ALU64_MUL_K: 1 * -2147483647 = -2147483647", 5881 .u.insns_int = { 5882 BPF_LD_IMM64(R0, 1), 5883 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647), 5884 BPF_EXIT_INSN(), 5885 }, 5886 INTERNAL, 5887 { }, 5888 { { 0, -2147483647 } }, 5889 }, 5890 { 5891 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff", 5892 .u.insns_int = { 5893 BPF_LD_IMM64(R2, 0x1), 5894 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 5895 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff), 5896 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5897 BPF_MOV32_IMM(R0, 2), 5898 BPF_EXIT_INSN(), 5899 BPF_MOV32_IMM(R0, 1), 5900 BPF_EXIT_INSN(), 5901 }, 5902 INTERNAL, 5903 { }, 5904 { { 0, 0x1 } }, 5905 }, 5906 { 5907 "ALU64_MUL_K: 64x32 multiply, low word", 5908 .u.insns_int = { 5909 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5910 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678), 5911 BPF_EXIT_INSN(), 5912 }, 5913 INTERNAL, 5914 { }, 5915 { { 0, 0xe242d208 } } 5916 }, 5917 { 5918 "ALU64_MUL_K: 64x32 multiply, high word", 5919 .u.insns_int = { 5920 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5921 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678), 5922 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5923 BPF_EXIT_INSN(), 5924 }, 5925 INTERNAL, 5926 { }, 5927 { { 0, 0xc28f5c28 } } 5928 }, 5929 /* BPF_ALU | BPF_DIV | BPF_X */ 5930 { 5931 "ALU_DIV_X: 6 / 2 = 3", 5932 .u.insns_int = { 5933 BPF_LD_IMM64(R0, 6), 5934 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5935 BPF_ALU32_REG(BPF_DIV, R0, R1), 5936 BPF_EXIT_INSN(), 5937 }, 5938 INTERNAL, 5939 { }, 5940 { { 0, 3 } }, 5941 }, 5942 { 5943 "ALU_DIV_X: 4294967295 / 4294967295 = 1", 5944 .u.insns_int = { 5945 BPF_LD_IMM64(R0, 4294967295U), 5946 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 5947 BPF_ALU32_REG(BPF_DIV, R0, R1), 5948 BPF_EXIT_INSN(), 5949 }, 5950 INTERNAL, 5951 { }, 5952 { { 0, 1 } }, 5953 }, 5954 { 5955 "ALU64_DIV_X: 6 / 2 = 3", 5956 .u.insns_int = { 5957 BPF_LD_IMM64(R0, 6), 5958 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5959 BPF_ALU64_REG(BPF_DIV, R0, R1), 5960 BPF_EXIT_INSN(), 5961 }, 5962 INTERNAL, 5963 { }, 5964 { { 0, 3 } }, 5965 }, 5966 { 5967 "ALU64_DIV_X: 2147483647 / 2147483647 = 1", 5968 .u.insns_int = { 5969 BPF_LD_IMM64(R0, 2147483647), 5970 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647), 5971 BPF_ALU64_REG(BPF_DIV, R0, R1), 5972 BPF_EXIT_INSN(), 5973 }, 5974 INTERNAL, 5975 { }, 5976 { { 0, 1 } }, 5977 }, 5978 { 5979 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001", 5980 .u.insns_int = { 5981 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 5982 BPF_LD_IMM64(R4, 0xffffffffffffffffLL), 5983 BPF_LD_IMM64(R3, 0x0000000000000001LL), 5984 BPF_ALU64_REG(BPF_DIV, R2, R4), 5985 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5986 BPF_MOV32_IMM(R0, 2), 5987 BPF_EXIT_INSN(), 5988 BPF_MOV32_IMM(R0, 1), 5989 BPF_EXIT_INSN(), 5990 }, 5991 INTERNAL, 5992 { }, 5993 { { 0, 0x1 } }, 5994 }, 5995 /* BPF_ALU | BPF_DIV | BPF_K */ 5996 { 5997 "ALU_DIV_K: 6 / 2 = 3", 5998 .u.insns_int = { 5999 BPF_LD_IMM64(R0, 6), 6000 BPF_ALU32_IMM(BPF_DIV, R0, 2), 6001 BPF_EXIT_INSN(), 6002 }, 6003 INTERNAL, 6004 { }, 6005 { { 0, 3 } }, 6006 }, 6007 { 6008 "ALU_DIV_K: 3 / 1 = 3", 6009 .u.insns_int = { 6010 BPF_LD_IMM64(R0, 3), 6011 BPF_ALU32_IMM(BPF_DIV, R0, 1), 6012 BPF_EXIT_INSN(), 6013 }, 6014 INTERNAL, 6015 { }, 6016 { { 0, 3 } }, 6017 }, 6018 { 6019 "ALU_DIV_K: 4294967295 / 4294967295 = 1", 6020 .u.insns_int = { 6021 BPF_LD_IMM64(R0, 4294967295U), 6022 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U), 6023 BPF_EXIT_INSN(), 6024 }, 6025 INTERNAL, 6026 { }, 6027 { { 0, 1 } }, 6028 }, 6029 { 6030 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1", 6031 .u.insns_int = { 6032 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 6033 BPF_LD_IMM64(R3, 0x1UL), 6034 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff), 6035 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6036 BPF_MOV32_IMM(R0, 2), 6037 BPF_EXIT_INSN(), 6038 BPF_MOV32_IMM(R0, 1), 6039 BPF_EXIT_INSN(), 6040 }, 6041 INTERNAL, 6042 { }, 6043 { { 0, 0x1 } }, 6044 }, 6045 { 6046 "ALU64_DIV_K: 6 / 2 = 3", 6047 .u.insns_int = { 6048 BPF_LD_IMM64(R0, 6), 6049 BPF_ALU64_IMM(BPF_DIV, R0, 2), 6050 BPF_EXIT_INSN(), 6051 }, 6052 INTERNAL, 6053 { }, 6054 { { 0, 3 } }, 6055 }, 6056 { 6057 "ALU64_DIV_K: 3 / 1 = 3", 6058 .u.insns_int = { 6059 BPF_LD_IMM64(R0, 3), 6060 BPF_ALU64_IMM(BPF_DIV, R0, 1), 6061 BPF_EXIT_INSN(), 6062 }, 6063 INTERNAL, 6064 { }, 6065 { { 0, 3 } }, 6066 }, 6067 { 6068 "ALU64_DIV_K: 2147483647 / 2147483647 = 1", 6069 .u.insns_int = { 6070 BPF_LD_IMM64(R0, 2147483647), 6071 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647), 6072 BPF_EXIT_INSN(), 6073 }, 6074 INTERNAL, 6075 { }, 6076 { { 0, 1 } }, 6077 }, 6078 { 6079 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001", 6080 .u.insns_int = { 6081 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 6082 BPF_LD_IMM64(R3, 0x0000000000000001LL), 6083 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff), 6084 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6085 BPF_MOV32_IMM(R0, 2), 6086 BPF_EXIT_INSN(), 6087 BPF_MOV32_IMM(R0, 1), 6088 BPF_EXIT_INSN(), 6089 }, 6090 INTERNAL, 6091 { }, 6092 { { 0, 0x1 } }, 6093 }, 6094 /* BPF_ALU | BPF_MOD | BPF_X */ 6095 { 6096 "ALU_MOD_X: 3 % 2 = 1", 6097 .u.insns_int = { 6098 BPF_LD_IMM64(R0, 3), 6099 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6100 BPF_ALU32_REG(BPF_MOD, R0, R1), 6101 BPF_EXIT_INSN(), 6102 }, 6103 INTERNAL, 6104 { }, 6105 { { 0, 1 } }, 6106 }, 6107 { 6108 "ALU_MOD_X: 4294967295 % 4294967293 = 2", 6109 .u.insns_int = { 6110 BPF_LD_IMM64(R0, 4294967295U), 6111 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U), 6112 BPF_ALU32_REG(BPF_MOD, R0, R1), 6113 BPF_EXIT_INSN(), 6114 }, 6115 INTERNAL, 6116 { }, 6117 { { 0, 2 } }, 6118 }, 6119 { 6120 "ALU64_MOD_X: 3 % 2 = 1", 6121 .u.insns_int = { 6122 BPF_LD_IMM64(R0, 3), 6123 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6124 BPF_ALU64_REG(BPF_MOD, R0, R1), 6125 BPF_EXIT_INSN(), 6126 }, 6127 INTERNAL, 6128 { }, 6129 { { 0, 1 } }, 6130 }, 6131 { 6132 "ALU64_MOD_X: 2147483647 % 2147483645 = 2", 6133 .u.insns_int = { 6134 BPF_LD_IMM64(R0, 2147483647), 6135 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645), 6136 BPF_ALU64_REG(BPF_MOD, R0, R1), 6137 BPF_EXIT_INSN(), 6138 }, 6139 INTERNAL, 6140 { }, 6141 { { 0, 2 } }, 6142 }, 6143 /* BPF_ALU | BPF_MOD | BPF_K */ 6144 { 6145 "ALU_MOD_K: 3 % 2 = 1", 6146 .u.insns_int = { 6147 BPF_LD_IMM64(R0, 3), 6148 BPF_ALU32_IMM(BPF_MOD, R0, 2), 6149 BPF_EXIT_INSN(), 6150 }, 6151 INTERNAL, 6152 { }, 6153 { { 0, 1 } }, 6154 }, 6155 { 6156 "ALU_MOD_K: 3 % 1 = 0", 6157 .u.insns_int = { 6158 BPF_LD_IMM64(R0, 3), 6159 BPF_ALU32_IMM(BPF_MOD, R0, 1), 6160 BPF_EXIT_INSN(), 6161 }, 6162 INTERNAL, 6163 { }, 6164 { { 0, 0 } }, 6165 }, 6166 { 6167 "ALU_MOD_K: 4294967295 % 4294967293 = 2", 6168 .u.insns_int = { 6169 BPF_LD_IMM64(R0, 4294967295U), 6170 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U), 6171 BPF_EXIT_INSN(), 6172 }, 6173 INTERNAL, 6174 { }, 6175 { { 0, 2 } }, 6176 }, 6177 { 6178 "ALU64_MOD_K: 3 % 2 = 1", 6179 .u.insns_int = { 6180 BPF_LD_IMM64(R0, 3), 6181 BPF_ALU64_IMM(BPF_MOD, R0, 2), 6182 BPF_EXIT_INSN(), 6183 }, 6184 INTERNAL, 6185 { }, 6186 { { 0, 1 } }, 6187 }, 6188 { 6189 "ALU64_MOD_K: 3 % 1 = 0", 6190 .u.insns_int = { 6191 BPF_LD_IMM64(R0, 3), 6192 BPF_ALU64_IMM(BPF_MOD, R0, 1), 6193 BPF_EXIT_INSN(), 6194 }, 6195 INTERNAL, 6196 { }, 6197 { { 0, 0 } }, 6198 }, 6199 { 6200 "ALU64_MOD_K: 2147483647 % 2147483645 = 2", 6201 .u.insns_int = { 6202 BPF_LD_IMM64(R0, 2147483647), 6203 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645), 6204 BPF_EXIT_INSN(), 6205 }, 6206 INTERNAL, 6207 { }, 6208 { { 0, 2 } }, 6209 }, 6210 /* BPF_ALU | BPF_DIV | BPF_X off=1 (SDIV) */ 6211 { 6212 "ALU_SDIV_X: -6 / 2 = -3", 6213 .u.insns_int = { 6214 BPF_LD_IMM64(R0, -6), 6215 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6216 BPF_ALU32_REG_OFF(BPF_DIV, R0, R1, 1), 6217 BPF_EXIT_INSN(), 6218 }, 6219 INTERNAL, 6220 { }, 6221 { { 0, -3 } }, 6222 }, 6223 /* BPF_ALU | BPF_DIV | BPF_K off=1 (SDIV) */ 6224 { 6225 "ALU_SDIV_K: -6 / 2 = -3", 6226 .u.insns_int = { 6227 BPF_LD_IMM64(R0, -6), 6228 BPF_ALU32_IMM_OFF(BPF_DIV, R0, 2, 1), 6229 BPF_EXIT_INSN(), 6230 }, 6231 INTERNAL, 6232 { }, 6233 { { 0, -3 } }, 6234 }, 6235 /* BPF_ALU64 | BPF_DIV | BPF_X off=1 (SDIV64) */ 6236 { 6237 "ALU64_SDIV_X: -6 / 2 = -3", 6238 .u.insns_int = { 6239 BPF_LD_IMM64(R0, -6), 6240 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6241 BPF_ALU64_REG_OFF(BPF_DIV, R0, R1, 1), 6242 BPF_EXIT_INSN(), 6243 }, 6244 INTERNAL, 6245 { }, 6246 { { 0, -3 } }, 6247 }, 6248 /* BPF_ALU64 | BPF_DIV | BPF_K off=1 (SDIV64) */ 6249 { 6250 "ALU64_SDIV_K: -6 / 2 = -3", 6251 .u.insns_int = { 6252 BPF_LD_IMM64(R0, -6), 6253 BPF_ALU64_IMM_OFF(BPF_DIV, R0, 2, 1), 6254 BPF_EXIT_INSN(), 6255 }, 6256 INTERNAL, 6257 { }, 6258 { { 0, -3 } }, 6259 }, 6260 /* BPF_ALU | BPF_MOD | BPF_X off=1 (SMOD) */ 6261 { 6262 "ALU_SMOD_X: -7 % 2 = -1", 6263 .u.insns_int = { 6264 BPF_LD_IMM64(R0, -7), 6265 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6266 BPF_ALU32_REG_OFF(BPF_MOD, R0, R1, 1), 6267 BPF_EXIT_INSN(), 6268 }, 6269 INTERNAL, 6270 { }, 6271 { { 0, -1 } }, 6272 }, 6273 /* BPF_ALU | BPF_MOD | BPF_K off=1 (SMOD) */ 6274 { 6275 "ALU_SMOD_K: -7 % 2 = -1", 6276 .u.insns_int = { 6277 BPF_LD_IMM64(R0, -7), 6278 BPF_ALU32_IMM_OFF(BPF_MOD, R0, 2, 1), 6279 BPF_EXIT_INSN(), 6280 }, 6281 INTERNAL, 6282 { }, 6283 { { 0, -1 } }, 6284 }, 6285 /* BPF_ALU64 | BPF_MOD | BPF_X off=1 (SMOD64) */ 6286 { 6287 "ALU64_SMOD_X: -7 % 2 = -1", 6288 .u.insns_int = { 6289 BPF_LD_IMM64(R0, -7), 6290 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6291 BPF_ALU64_REG_OFF(BPF_MOD, R0, R1, 1), 6292 BPF_EXIT_INSN(), 6293 }, 6294 INTERNAL, 6295 { }, 6296 { { 0, -1 } }, 6297 }, 6298 /* BPF_ALU64 | BPF_MOD | BPF_K off=1 (SMOD64) */ 6299 { 6300 "ALU64_SMOD_K: -7 % 2 = -1", 6301 .u.insns_int = { 6302 BPF_LD_IMM64(R0, -7), 6303 BPF_ALU64_IMM_OFF(BPF_MOD, R0, 2, 1), 6304 BPF_EXIT_INSN(), 6305 }, 6306 INTERNAL, 6307 { }, 6308 { { 0, -1 } }, 6309 }, 6310 /* BPF_ALU | BPF_AND | BPF_X */ 6311 { 6312 "ALU_AND_X: 3 & 2 = 2", 6313 .u.insns_int = { 6314 BPF_LD_IMM64(R0, 3), 6315 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6316 BPF_ALU32_REG(BPF_AND, R0, R1), 6317 BPF_EXIT_INSN(), 6318 }, 6319 INTERNAL, 6320 { }, 6321 { { 0, 2 } }, 6322 }, 6323 { 6324 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff", 6325 .u.insns_int = { 6326 BPF_LD_IMM64(R0, 0xffffffff), 6327 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6328 BPF_ALU32_REG(BPF_AND, R0, R1), 6329 BPF_EXIT_INSN(), 6330 }, 6331 INTERNAL, 6332 { }, 6333 { { 0, 0xffffffff } }, 6334 }, 6335 { 6336 "ALU64_AND_X: 3 & 2 = 2", 6337 .u.insns_int = { 6338 BPF_LD_IMM64(R0, 3), 6339 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6340 BPF_ALU64_REG(BPF_AND, R0, R1), 6341 BPF_EXIT_INSN(), 6342 }, 6343 INTERNAL, 6344 { }, 6345 { { 0, 2 } }, 6346 }, 6347 { 6348 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff", 6349 .u.insns_int = { 6350 BPF_LD_IMM64(R0, 0xffffffff), 6351 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6352 BPF_ALU64_REG(BPF_AND, R0, R1), 6353 BPF_EXIT_INSN(), 6354 }, 6355 INTERNAL, 6356 { }, 6357 { { 0, 0xffffffff } }, 6358 }, 6359 /* BPF_ALU | BPF_AND | BPF_K */ 6360 { 6361 "ALU_AND_K: 3 & 2 = 2", 6362 .u.insns_int = { 6363 BPF_LD_IMM64(R0, 3), 6364 BPF_ALU32_IMM(BPF_AND, R0, 2), 6365 BPF_EXIT_INSN(), 6366 }, 6367 INTERNAL, 6368 { }, 6369 { { 0, 2 } }, 6370 }, 6371 { 6372 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff", 6373 .u.insns_int = { 6374 BPF_LD_IMM64(R0, 0xffffffff), 6375 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff), 6376 BPF_EXIT_INSN(), 6377 }, 6378 INTERNAL, 6379 { }, 6380 { { 0, 0xffffffff } }, 6381 }, 6382 { 6383 "ALU_AND_K: Small immediate", 6384 .u.insns_int = { 6385 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 6386 BPF_ALU32_IMM(BPF_AND, R0, 15), 6387 BPF_EXIT_INSN(), 6388 }, 6389 INTERNAL, 6390 { }, 6391 { { 0, 4 } } 6392 }, 6393 { 6394 "ALU_AND_K: Large immediate", 6395 .u.insns_int = { 6396 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4), 6397 BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf), 6398 BPF_EXIT_INSN(), 6399 }, 6400 INTERNAL, 6401 { }, 6402 { { 0, 0xa1b2c3d4 } } 6403 }, 6404 { 6405 "ALU_AND_K: Zero extension", 6406 .u.insns_int = { 6407 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6408 BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL), 6409 BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0), 6410 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6411 BPF_MOV32_IMM(R0, 2), 6412 BPF_EXIT_INSN(), 6413 BPF_MOV32_IMM(R0, 1), 6414 BPF_EXIT_INSN(), 6415 }, 6416 INTERNAL, 6417 { }, 6418 { { 0, 1 } } 6419 }, 6420 { 6421 "ALU64_AND_K: 3 & 2 = 2", 6422 .u.insns_int = { 6423 BPF_LD_IMM64(R0, 3), 6424 BPF_ALU64_IMM(BPF_AND, R0, 2), 6425 BPF_EXIT_INSN(), 6426 }, 6427 INTERNAL, 6428 { }, 6429 { { 0, 2 } }, 6430 }, 6431 { 6432 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff", 6433 .u.insns_int = { 6434 BPF_LD_IMM64(R0, 0xffffffff), 6435 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff), 6436 BPF_EXIT_INSN(), 6437 }, 6438 INTERNAL, 6439 { }, 6440 { { 0, 0xffffffff } }, 6441 }, 6442 { 6443 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000", 6444 .u.insns_int = { 6445 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 6446 BPF_LD_IMM64(R3, 0x0000000000000000LL), 6447 BPF_ALU64_IMM(BPF_AND, R2, 0x0), 6448 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6449 BPF_MOV32_IMM(R0, 2), 6450 BPF_EXIT_INSN(), 6451 BPF_MOV32_IMM(R0, 1), 6452 BPF_EXIT_INSN(), 6453 }, 6454 INTERNAL, 6455 { }, 6456 { { 0, 0x1 } }, 6457 }, 6458 { 6459 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000", 6460 .u.insns_int = { 6461 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 6462 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 6463 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff), 6464 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6465 BPF_MOV32_IMM(R0, 2), 6466 BPF_EXIT_INSN(), 6467 BPF_MOV32_IMM(R0, 1), 6468 BPF_EXIT_INSN(), 6469 }, 6470 INTERNAL, 6471 { }, 6472 { { 0, 0x1 } }, 6473 }, 6474 { 6475 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff", 6476 .u.insns_int = { 6477 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 6478 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 6479 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff), 6480 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6481 BPF_MOV32_IMM(R0, 2), 6482 BPF_EXIT_INSN(), 6483 BPF_MOV32_IMM(R0, 1), 6484 BPF_EXIT_INSN(), 6485 }, 6486 INTERNAL, 6487 { }, 6488 { { 0, 0x1 } }, 6489 }, 6490 { 6491 "ALU64_AND_K: Sign extension 1", 6492 .u.insns_int = { 6493 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6494 BPF_LD_IMM64(R1, 0x00000000090b0d0fLL), 6495 BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f), 6496 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6497 BPF_MOV32_IMM(R0, 2), 6498 BPF_EXIT_INSN(), 6499 BPF_MOV32_IMM(R0, 1), 6500 BPF_EXIT_INSN(), 6501 }, 6502 INTERNAL, 6503 { }, 6504 { { 0, 1 } } 6505 }, 6506 { 6507 "ALU64_AND_K: Sign extension 2", 6508 .u.insns_int = { 6509 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6510 BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL), 6511 BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0), 6512 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6513 BPF_MOV32_IMM(R0, 2), 6514 BPF_EXIT_INSN(), 6515 BPF_MOV32_IMM(R0, 1), 6516 BPF_EXIT_INSN(), 6517 }, 6518 INTERNAL, 6519 { }, 6520 { { 0, 1 } } 6521 }, 6522 /* BPF_ALU | BPF_OR | BPF_X */ 6523 { 6524 "ALU_OR_X: 1 | 2 = 3", 6525 .u.insns_int = { 6526 BPF_LD_IMM64(R0, 1), 6527 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6528 BPF_ALU32_REG(BPF_OR, R0, R1), 6529 BPF_EXIT_INSN(), 6530 }, 6531 INTERNAL, 6532 { }, 6533 { { 0, 3 } }, 6534 }, 6535 { 6536 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff", 6537 .u.insns_int = { 6538 BPF_LD_IMM64(R0, 0), 6539 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6540 BPF_ALU32_REG(BPF_OR, R0, R1), 6541 BPF_EXIT_INSN(), 6542 }, 6543 INTERNAL, 6544 { }, 6545 { { 0, 0xffffffff } }, 6546 }, 6547 { 6548 "ALU64_OR_X: 1 | 2 = 3", 6549 .u.insns_int = { 6550 BPF_LD_IMM64(R0, 1), 6551 BPF_ALU32_IMM(BPF_MOV, R1, 2), 6552 BPF_ALU64_REG(BPF_OR, R0, R1), 6553 BPF_EXIT_INSN(), 6554 }, 6555 INTERNAL, 6556 { }, 6557 { { 0, 3 } }, 6558 }, 6559 { 6560 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff", 6561 .u.insns_int = { 6562 BPF_LD_IMM64(R0, 0), 6563 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6564 BPF_ALU64_REG(BPF_OR, R0, R1), 6565 BPF_EXIT_INSN(), 6566 }, 6567 INTERNAL, 6568 { }, 6569 { { 0, 0xffffffff } }, 6570 }, 6571 /* BPF_ALU | BPF_OR | BPF_K */ 6572 { 6573 "ALU_OR_K: 1 | 2 = 3", 6574 .u.insns_int = { 6575 BPF_LD_IMM64(R0, 1), 6576 BPF_ALU32_IMM(BPF_OR, R0, 2), 6577 BPF_EXIT_INSN(), 6578 }, 6579 INTERNAL, 6580 { }, 6581 { { 0, 3 } }, 6582 }, 6583 { 6584 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff", 6585 .u.insns_int = { 6586 BPF_LD_IMM64(R0, 0), 6587 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff), 6588 BPF_EXIT_INSN(), 6589 }, 6590 INTERNAL, 6591 { }, 6592 { { 0, 0xffffffff } }, 6593 }, 6594 { 6595 "ALU_OR_K: Small immediate", 6596 .u.insns_int = { 6597 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 6598 BPF_ALU32_IMM(BPF_OR, R0, 1), 6599 BPF_EXIT_INSN(), 6600 }, 6601 INTERNAL, 6602 { }, 6603 { { 0, 0x01020305 } } 6604 }, 6605 { 6606 "ALU_OR_K: Large immediate", 6607 .u.insns_int = { 6608 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 6609 BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0), 6610 BPF_EXIT_INSN(), 6611 }, 6612 INTERNAL, 6613 { }, 6614 { { 0, 0xa1b2c3d4 } } 6615 }, 6616 { 6617 "ALU_OR_K: Zero extension", 6618 .u.insns_int = { 6619 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6620 BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL), 6621 BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0), 6622 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6623 BPF_MOV32_IMM(R0, 2), 6624 BPF_EXIT_INSN(), 6625 BPF_MOV32_IMM(R0, 1), 6626 BPF_EXIT_INSN(), 6627 }, 6628 INTERNAL, 6629 { }, 6630 { { 0, 1 } } 6631 }, 6632 { 6633 "ALU64_OR_K: 1 | 2 = 3", 6634 .u.insns_int = { 6635 BPF_LD_IMM64(R0, 1), 6636 BPF_ALU64_IMM(BPF_OR, R0, 2), 6637 BPF_EXIT_INSN(), 6638 }, 6639 INTERNAL, 6640 { }, 6641 { { 0, 3 } }, 6642 }, 6643 { 6644 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff", 6645 .u.insns_int = { 6646 BPF_LD_IMM64(R0, 0), 6647 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff), 6648 BPF_EXIT_INSN(), 6649 }, 6650 INTERNAL, 6651 { }, 6652 { { 0, 0xffffffff } }, 6653 }, 6654 { 6655 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000", 6656 .u.insns_int = { 6657 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 6658 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 6659 BPF_ALU64_IMM(BPF_OR, R2, 0x0), 6660 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6661 BPF_MOV32_IMM(R0, 2), 6662 BPF_EXIT_INSN(), 6663 BPF_MOV32_IMM(R0, 1), 6664 BPF_EXIT_INSN(), 6665 }, 6666 INTERNAL, 6667 { }, 6668 { { 0, 0x1 } }, 6669 }, 6670 { 6671 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff", 6672 .u.insns_int = { 6673 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 6674 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 6675 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff), 6676 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6677 BPF_MOV32_IMM(R0, 2), 6678 BPF_EXIT_INSN(), 6679 BPF_MOV32_IMM(R0, 1), 6680 BPF_EXIT_INSN(), 6681 }, 6682 INTERNAL, 6683 { }, 6684 { { 0, 0x1 } }, 6685 }, 6686 { 6687 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff", 6688 .u.insns_int = { 6689 BPF_LD_IMM64(R2, 0x0000000000000000LL), 6690 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 6691 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff), 6692 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6693 BPF_MOV32_IMM(R0, 2), 6694 BPF_EXIT_INSN(), 6695 BPF_MOV32_IMM(R0, 1), 6696 BPF_EXIT_INSN(), 6697 }, 6698 INTERNAL, 6699 { }, 6700 { { 0, 0x1 } }, 6701 }, 6702 { 6703 "ALU64_OR_K: Sign extension 1", 6704 .u.insns_int = { 6705 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6706 BPF_LD_IMM64(R1, 0x012345678fafcfefLL), 6707 BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f), 6708 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6709 BPF_MOV32_IMM(R0, 2), 6710 BPF_EXIT_INSN(), 6711 BPF_MOV32_IMM(R0, 1), 6712 BPF_EXIT_INSN(), 6713 }, 6714 INTERNAL, 6715 { }, 6716 { { 0, 1 } } 6717 }, 6718 { 6719 "ALU64_OR_K: Sign extension 2", 6720 .u.insns_int = { 6721 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6722 BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL), 6723 BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0), 6724 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6725 BPF_MOV32_IMM(R0, 2), 6726 BPF_EXIT_INSN(), 6727 BPF_MOV32_IMM(R0, 1), 6728 BPF_EXIT_INSN(), 6729 }, 6730 INTERNAL, 6731 { }, 6732 { { 0, 1 } } 6733 }, 6734 /* BPF_ALU | BPF_XOR | BPF_X */ 6735 { 6736 "ALU_XOR_X: 5 ^ 6 = 3", 6737 .u.insns_int = { 6738 BPF_LD_IMM64(R0, 5), 6739 BPF_ALU32_IMM(BPF_MOV, R1, 6), 6740 BPF_ALU32_REG(BPF_XOR, R0, R1), 6741 BPF_EXIT_INSN(), 6742 }, 6743 INTERNAL, 6744 { }, 6745 { { 0, 3 } }, 6746 }, 6747 { 6748 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe", 6749 .u.insns_int = { 6750 BPF_LD_IMM64(R0, 1), 6751 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6752 BPF_ALU32_REG(BPF_XOR, R0, R1), 6753 BPF_EXIT_INSN(), 6754 }, 6755 INTERNAL, 6756 { }, 6757 { { 0, 0xfffffffe } }, 6758 }, 6759 { 6760 "ALU64_XOR_X: 5 ^ 6 = 3", 6761 .u.insns_int = { 6762 BPF_LD_IMM64(R0, 5), 6763 BPF_ALU32_IMM(BPF_MOV, R1, 6), 6764 BPF_ALU64_REG(BPF_XOR, R0, R1), 6765 BPF_EXIT_INSN(), 6766 }, 6767 INTERNAL, 6768 { }, 6769 { { 0, 3 } }, 6770 }, 6771 { 6772 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe", 6773 .u.insns_int = { 6774 BPF_LD_IMM64(R0, 1), 6775 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6776 BPF_ALU64_REG(BPF_XOR, R0, R1), 6777 BPF_EXIT_INSN(), 6778 }, 6779 INTERNAL, 6780 { }, 6781 { { 0, 0xfffffffe } }, 6782 }, 6783 /* BPF_ALU | BPF_XOR | BPF_K */ 6784 { 6785 "ALU_XOR_K: 5 ^ 6 = 3", 6786 .u.insns_int = { 6787 BPF_LD_IMM64(R0, 5), 6788 BPF_ALU32_IMM(BPF_XOR, R0, 6), 6789 BPF_EXIT_INSN(), 6790 }, 6791 INTERNAL, 6792 { }, 6793 { { 0, 3 } }, 6794 }, 6795 { 6796 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe", 6797 .u.insns_int = { 6798 BPF_LD_IMM64(R0, 1), 6799 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff), 6800 BPF_EXIT_INSN(), 6801 }, 6802 INTERNAL, 6803 { }, 6804 { { 0, 0xfffffffe } }, 6805 }, 6806 { 6807 "ALU_XOR_K: Small immediate", 6808 .u.insns_int = { 6809 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 6810 BPF_ALU32_IMM(BPF_XOR, R0, 15), 6811 BPF_EXIT_INSN(), 6812 }, 6813 INTERNAL, 6814 { }, 6815 { { 0, 0x0102030b } } 6816 }, 6817 { 6818 "ALU_XOR_K: Large immediate", 6819 .u.insns_int = { 6820 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4), 6821 BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf), 6822 BPF_EXIT_INSN(), 6823 }, 6824 INTERNAL, 6825 { }, 6826 { { 0, 0x5e4d3c2b } } 6827 }, 6828 { 6829 "ALU_XOR_K: Zero extension", 6830 .u.insns_int = { 6831 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6832 BPF_LD_IMM64(R1, 0x00000000795b3d1fLL), 6833 BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0), 6834 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6835 BPF_MOV32_IMM(R0, 2), 6836 BPF_EXIT_INSN(), 6837 BPF_MOV32_IMM(R0, 1), 6838 BPF_EXIT_INSN(), 6839 }, 6840 INTERNAL, 6841 { }, 6842 { { 0, 1 } } 6843 }, 6844 { 6845 "ALU64_XOR_K: 5 ^ 6 = 3", 6846 .u.insns_int = { 6847 BPF_LD_IMM64(R0, 5), 6848 BPF_ALU64_IMM(BPF_XOR, R0, 6), 6849 BPF_EXIT_INSN(), 6850 }, 6851 INTERNAL, 6852 { }, 6853 { { 0, 3 } }, 6854 }, 6855 { 6856 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe", 6857 .u.insns_int = { 6858 BPF_LD_IMM64(R0, 1), 6859 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff), 6860 BPF_EXIT_INSN(), 6861 }, 6862 INTERNAL, 6863 { }, 6864 { { 0, 0xfffffffe } }, 6865 }, 6866 { 6867 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000", 6868 .u.insns_int = { 6869 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 6870 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 6871 BPF_ALU64_IMM(BPF_XOR, R2, 0x0), 6872 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6873 BPF_MOV32_IMM(R0, 2), 6874 BPF_EXIT_INSN(), 6875 BPF_MOV32_IMM(R0, 1), 6876 BPF_EXIT_INSN(), 6877 }, 6878 INTERNAL, 6879 { }, 6880 { { 0, 0x1 } }, 6881 }, 6882 { 6883 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff", 6884 .u.insns_int = { 6885 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 6886 BPF_LD_IMM64(R3, 0xffff00000000ffffLL), 6887 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff), 6888 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6889 BPF_MOV32_IMM(R0, 2), 6890 BPF_EXIT_INSN(), 6891 BPF_MOV32_IMM(R0, 1), 6892 BPF_EXIT_INSN(), 6893 }, 6894 INTERNAL, 6895 { }, 6896 { { 0, 0x1 } }, 6897 }, 6898 { 6899 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff", 6900 .u.insns_int = { 6901 BPF_LD_IMM64(R2, 0x0000000000000000LL), 6902 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 6903 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff), 6904 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6905 BPF_MOV32_IMM(R0, 2), 6906 BPF_EXIT_INSN(), 6907 BPF_MOV32_IMM(R0, 1), 6908 BPF_EXIT_INSN(), 6909 }, 6910 INTERNAL, 6911 { }, 6912 { { 0, 0x1 } }, 6913 }, 6914 { 6915 "ALU64_XOR_K: Sign extension 1", 6916 .u.insns_int = { 6917 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6918 BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL), 6919 BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f), 6920 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6921 BPF_MOV32_IMM(R0, 2), 6922 BPF_EXIT_INSN(), 6923 BPF_MOV32_IMM(R0, 1), 6924 BPF_EXIT_INSN(), 6925 }, 6926 INTERNAL, 6927 { }, 6928 { { 0, 1 } } 6929 }, 6930 { 6931 "ALU64_XOR_K: Sign extension 2", 6932 .u.insns_int = { 6933 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6934 BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL), 6935 BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0), 6936 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6937 BPF_MOV32_IMM(R0, 2), 6938 BPF_EXIT_INSN(), 6939 BPF_MOV32_IMM(R0, 1), 6940 BPF_EXIT_INSN(), 6941 }, 6942 INTERNAL, 6943 { }, 6944 { { 0, 1 } } 6945 }, 6946 /* BPF_ALU | BPF_LSH | BPF_X */ 6947 { 6948 "ALU_LSH_X: 1 << 1 = 2", 6949 .u.insns_int = { 6950 BPF_LD_IMM64(R0, 1), 6951 BPF_ALU32_IMM(BPF_MOV, R1, 1), 6952 BPF_ALU32_REG(BPF_LSH, R0, R1), 6953 BPF_EXIT_INSN(), 6954 }, 6955 INTERNAL, 6956 { }, 6957 { { 0, 2 } }, 6958 }, 6959 { 6960 "ALU_LSH_X: 1 << 31 = 0x80000000", 6961 .u.insns_int = { 6962 BPF_LD_IMM64(R0, 1), 6963 BPF_ALU32_IMM(BPF_MOV, R1, 31), 6964 BPF_ALU32_REG(BPF_LSH, R0, R1), 6965 BPF_EXIT_INSN(), 6966 }, 6967 INTERNAL, 6968 { }, 6969 { { 0, 0x80000000 } }, 6970 }, 6971 { 6972 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000", 6973 .u.insns_int = { 6974 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 6975 BPF_ALU32_IMM(BPF_MOV, R1, 12), 6976 BPF_ALU32_REG(BPF_LSH, R0, R1), 6977 BPF_EXIT_INSN(), 6978 }, 6979 INTERNAL, 6980 { }, 6981 { { 0, 0x45678000 } } 6982 }, 6983 { 6984 "ALU64_LSH_X: 1 << 1 = 2", 6985 .u.insns_int = { 6986 BPF_LD_IMM64(R0, 1), 6987 BPF_ALU32_IMM(BPF_MOV, R1, 1), 6988 BPF_ALU64_REG(BPF_LSH, R0, R1), 6989 BPF_EXIT_INSN(), 6990 }, 6991 INTERNAL, 6992 { }, 6993 { { 0, 2 } }, 6994 }, 6995 { 6996 "ALU64_LSH_X: 1 << 31 = 0x80000000", 6997 .u.insns_int = { 6998 BPF_LD_IMM64(R0, 1), 6999 BPF_ALU32_IMM(BPF_MOV, R1, 31), 7000 BPF_ALU64_REG(BPF_LSH, R0, R1), 7001 BPF_EXIT_INSN(), 7002 }, 7003 INTERNAL, 7004 { }, 7005 { { 0, 0x80000000 } }, 7006 }, 7007 { 7008 "ALU64_LSH_X: Shift < 32, low word", 7009 .u.insns_int = { 7010 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7011 BPF_ALU32_IMM(BPF_MOV, R1, 12), 7012 BPF_ALU64_REG(BPF_LSH, R0, R1), 7013 BPF_EXIT_INSN(), 7014 }, 7015 INTERNAL, 7016 { }, 7017 { { 0, 0xbcdef000 } } 7018 }, 7019 { 7020 "ALU64_LSH_X: Shift < 32, high word", 7021 .u.insns_int = { 7022 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7023 BPF_ALU32_IMM(BPF_MOV, R1, 12), 7024 BPF_ALU64_REG(BPF_LSH, R0, R1), 7025 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7026 BPF_EXIT_INSN(), 7027 }, 7028 INTERNAL, 7029 { }, 7030 { { 0, 0x3456789a } } 7031 }, 7032 { 7033 "ALU64_LSH_X: Shift > 32, low word", 7034 .u.insns_int = { 7035 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7036 BPF_ALU32_IMM(BPF_MOV, R1, 36), 7037 BPF_ALU64_REG(BPF_LSH, R0, R1), 7038 BPF_EXIT_INSN(), 7039 }, 7040 INTERNAL, 7041 { }, 7042 { { 0, 0 } } 7043 }, 7044 { 7045 "ALU64_LSH_X: Shift > 32, high word", 7046 .u.insns_int = { 7047 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7048 BPF_ALU32_IMM(BPF_MOV, R1, 36), 7049 BPF_ALU64_REG(BPF_LSH, R0, R1), 7050 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7051 BPF_EXIT_INSN(), 7052 }, 7053 INTERNAL, 7054 { }, 7055 { { 0, 0x9abcdef0 } } 7056 }, 7057 { 7058 "ALU64_LSH_X: Shift == 32, low word", 7059 .u.insns_int = { 7060 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7061 BPF_ALU32_IMM(BPF_MOV, R1, 32), 7062 BPF_ALU64_REG(BPF_LSH, R0, R1), 7063 BPF_EXIT_INSN(), 7064 }, 7065 INTERNAL, 7066 { }, 7067 { { 0, 0 } } 7068 }, 7069 { 7070 "ALU64_LSH_X: Shift == 32, high word", 7071 .u.insns_int = { 7072 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7073 BPF_ALU32_IMM(BPF_MOV, R1, 32), 7074 BPF_ALU64_REG(BPF_LSH, R0, R1), 7075 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7076 BPF_EXIT_INSN(), 7077 }, 7078 INTERNAL, 7079 { }, 7080 { { 0, 0x89abcdef } } 7081 }, 7082 { 7083 "ALU64_LSH_X: Zero shift, low word", 7084 .u.insns_int = { 7085 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7086 BPF_ALU32_IMM(BPF_MOV, R1, 0), 7087 BPF_ALU64_REG(BPF_LSH, R0, R1), 7088 BPF_EXIT_INSN(), 7089 }, 7090 INTERNAL, 7091 { }, 7092 { { 0, 0x89abcdef } } 7093 }, 7094 { 7095 "ALU64_LSH_X: Zero shift, high word", 7096 .u.insns_int = { 7097 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7098 BPF_ALU32_IMM(BPF_MOV, R1, 0), 7099 BPF_ALU64_REG(BPF_LSH, R0, R1), 7100 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7101 BPF_EXIT_INSN(), 7102 }, 7103 INTERNAL, 7104 { }, 7105 { { 0, 0x01234567 } } 7106 }, 7107 /* BPF_ALU | BPF_LSH | BPF_K */ 7108 { 7109 "ALU_LSH_K: 1 << 1 = 2", 7110 .u.insns_int = { 7111 BPF_LD_IMM64(R0, 1), 7112 BPF_ALU32_IMM(BPF_LSH, R0, 1), 7113 BPF_EXIT_INSN(), 7114 }, 7115 INTERNAL, 7116 { }, 7117 { { 0, 2 } }, 7118 }, 7119 { 7120 "ALU_LSH_K: 1 << 31 = 0x80000000", 7121 .u.insns_int = { 7122 BPF_LD_IMM64(R0, 1), 7123 BPF_ALU32_IMM(BPF_LSH, R0, 31), 7124 BPF_EXIT_INSN(), 7125 }, 7126 INTERNAL, 7127 { }, 7128 { { 0, 0x80000000 } }, 7129 }, 7130 { 7131 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000", 7132 .u.insns_int = { 7133 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 7134 BPF_ALU32_IMM(BPF_LSH, R0, 12), 7135 BPF_EXIT_INSN(), 7136 }, 7137 INTERNAL, 7138 { }, 7139 { { 0, 0x45678000 } } 7140 }, 7141 { 7142 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678", 7143 .u.insns_int = { 7144 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 7145 BPF_ALU32_IMM(BPF_LSH, R0, 0), 7146 BPF_EXIT_INSN(), 7147 }, 7148 INTERNAL, 7149 { }, 7150 { { 0, 0x12345678 } } 7151 }, 7152 { 7153 "ALU64_LSH_K: 1 << 1 = 2", 7154 .u.insns_int = { 7155 BPF_LD_IMM64(R0, 1), 7156 BPF_ALU64_IMM(BPF_LSH, R0, 1), 7157 BPF_EXIT_INSN(), 7158 }, 7159 INTERNAL, 7160 { }, 7161 { { 0, 2 } }, 7162 }, 7163 { 7164 "ALU64_LSH_K: 1 << 31 = 0x80000000", 7165 .u.insns_int = { 7166 BPF_LD_IMM64(R0, 1), 7167 BPF_ALU64_IMM(BPF_LSH, R0, 31), 7168 BPF_EXIT_INSN(), 7169 }, 7170 INTERNAL, 7171 { }, 7172 { { 0, 0x80000000 } }, 7173 }, 7174 { 7175 "ALU64_LSH_K: Shift < 32, low word", 7176 .u.insns_int = { 7177 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7178 BPF_ALU64_IMM(BPF_LSH, R0, 12), 7179 BPF_EXIT_INSN(), 7180 }, 7181 INTERNAL, 7182 { }, 7183 { { 0, 0xbcdef000 } } 7184 }, 7185 { 7186 "ALU64_LSH_K: Shift < 32, high word", 7187 .u.insns_int = { 7188 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7189 BPF_ALU64_IMM(BPF_LSH, R0, 12), 7190 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7191 BPF_EXIT_INSN(), 7192 }, 7193 INTERNAL, 7194 { }, 7195 { { 0, 0x3456789a } } 7196 }, 7197 { 7198 "ALU64_LSH_K: Shift > 32, low word", 7199 .u.insns_int = { 7200 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7201 BPF_ALU64_IMM(BPF_LSH, R0, 36), 7202 BPF_EXIT_INSN(), 7203 }, 7204 INTERNAL, 7205 { }, 7206 { { 0, 0 } } 7207 }, 7208 { 7209 "ALU64_LSH_K: Shift > 32, high word", 7210 .u.insns_int = { 7211 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7212 BPF_ALU64_IMM(BPF_LSH, R0, 36), 7213 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7214 BPF_EXIT_INSN(), 7215 }, 7216 INTERNAL, 7217 { }, 7218 { { 0, 0x9abcdef0 } } 7219 }, 7220 { 7221 "ALU64_LSH_K: Shift == 32, low word", 7222 .u.insns_int = { 7223 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7224 BPF_ALU64_IMM(BPF_LSH, R0, 32), 7225 BPF_EXIT_INSN(), 7226 }, 7227 INTERNAL, 7228 { }, 7229 { { 0, 0 } } 7230 }, 7231 { 7232 "ALU64_LSH_K: Shift == 32, high word", 7233 .u.insns_int = { 7234 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7235 BPF_ALU64_IMM(BPF_LSH, R0, 32), 7236 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7237 BPF_EXIT_INSN(), 7238 }, 7239 INTERNAL, 7240 { }, 7241 { { 0, 0x89abcdef } } 7242 }, 7243 { 7244 "ALU64_LSH_K: Zero shift", 7245 .u.insns_int = { 7246 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7247 BPF_ALU64_IMM(BPF_LSH, R0, 0), 7248 BPF_EXIT_INSN(), 7249 }, 7250 INTERNAL, 7251 { }, 7252 { { 0, 0x89abcdef } } 7253 }, 7254 /* BPF_ALU | BPF_RSH | BPF_X */ 7255 { 7256 "ALU_RSH_X: 2 >> 1 = 1", 7257 .u.insns_int = { 7258 BPF_LD_IMM64(R0, 2), 7259 BPF_ALU32_IMM(BPF_MOV, R1, 1), 7260 BPF_ALU32_REG(BPF_RSH, R0, R1), 7261 BPF_EXIT_INSN(), 7262 }, 7263 INTERNAL, 7264 { }, 7265 { { 0, 1 } }, 7266 }, 7267 { 7268 "ALU_RSH_X: 0x80000000 >> 31 = 1", 7269 .u.insns_int = { 7270 BPF_LD_IMM64(R0, 0x80000000), 7271 BPF_ALU32_IMM(BPF_MOV, R1, 31), 7272 BPF_ALU32_REG(BPF_RSH, R0, R1), 7273 BPF_EXIT_INSN(), 7274 }, 7275 INTERNAL, 7276 { }, 7277 { { 0, 1 } }, 7278 }, 7279 { 7280 "ALU_RSH_X: 0x12345678 >> 20 = 0x123", 7281 .u.insns_int = { 7282 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 7283 BPF_ALU32_IMM(BPF_MOV, R1, 20), 7284 BPF_ALU32_REG(BPF_RSH, R0, R1), 7285 BPF_EXIT_INSN(), 7286 }, 7287 INTERNAL, 7288 { }, 7289 { { 0, 0x123 } } 7290 }, 7291 { 7292 "ALU64_RSH_X: 2 >> 1 = 1", 7293 .u.insns_int = { 7294 BPF_LD_IMM64(R0, 2), 7295 BPF_ALU32_IMM(BPF_MOV, R1, 1), 7296 BPF_ALU64_REG(BPF_RSH, R0, R1), 7297 BPF_EXIT_INSN(), 7298 }, 7299 INTERNAL, 7300 { }, 7301 { { 0, 1 } }, 7302 }, 7303 { 7304 "ALU64_RSH_X: 0x80000000 >> 31 = 1", 7305 .u.insns_int = { 7306 BPF_LD_IMM64(R0, 0x80000000), 7307 BPF_ALU32_IMM(BPF_MOV, R1, 31), 7308 BPF_ALU64_REG(BPF_RSH, R0, R1), 7309 BPF_EXIT_INSN(), 7310 }, 7311 INTERNAL, 7312 { }, 7313 { { 0, 1 } }, 7314 }, 7315 { 7316 "ALU64_RSH_X: Shift < 32, low word", 7317 .u.insns_int = { 7318 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7319 BPF_ALU32_IMM(BPF_MOV, R1, 12), 7320 BPF_ALU64_REG(BPF_RSH, R0, R1), 7321 BPF_EXIT_INSN(), 7322 }, 7323 INTERNAL, 7324 { }, 7325 { { 0, 0x56789abc } } 7326 }, 7327 { 7328 "ALU64_RSH_X: Shift < 32, high word", 7329 .u.insns_int = { 7330 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7331 BPF_ALU32_IMM(BPF_MOV, R1, 12), 7332 BPF_ALU64_REG(BPF_RSH, R0, R1), 7333 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7334 BPF_EXIT_INSN(), 7335 }, 7336 INTERNAL, 7337 { }, 7338 { { 0, 0x00081234 } } 7339 }, 7340 { 7341 "ALU64_RSH_X: Shift > 32, low word", 7342 .u.insns_int = { 7343 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7344 BPF_ALU32_IMM(BPF_MOV, R1, 36), 7345 BPF_ALU64_REG(BPF_RSH, R0, R1), 7346 BPF_EXIT_INSN(), 7347 }, 7348 INTERNAL, 7349 { }, 7350 { { 0, 0x08123456 } } 7351 }, 7352 { 7353 "ALU64_RSH_X: Shift > 32, high word", 7354 .u.insns_int = { 7355 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7356 BPF_ALU32_IMM(BPF_MOV, R1, 36), 7357 BPF_ALU64_REG(BPF_RSH, R0, R1), 7358 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7359 BPF_EXIT_INSN(), 7360 }, 7361 INTERNAL, 7362 { }, 7363 { { 0, 0 } } 7364 }, 7365 { 7366 "ALU64_RSH_X: Shift == 32, low word", 7367 .u.insns_int = { 7368 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7369 BPF_ALU32_IMM(BPF_MOV, R1, 32), 7370 BPF_ALU64_REG(BPF_RSH, R0, R1), 7371 BPF_EXIT_INSN(), 7372 }, 7373 INTERNAL, 7374 { }, 7375 { { 0, 0x81234567 } } 7376 }, 7377 { 7378 "ALU64_RSH_X: Shift == 32, high word", 7379 .u.insns_int = { 7380 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7381 BPF_ALU32_IMM(BPF_MOV, R1, 32), 7382 BPF_ALU64_REG(BPF_RSH, R0, R1), 7383 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7384 BPF_EXIT_INSN(), 7385 }, 7386 INTERNAL, 7387 { }, 7388 { { 0, 0 } } 7389 }, 7390 { 7391 "ALU64_RSH_X: Zero shift, low word", 7392 .u.insns_int = { 7393 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7394 BPF_ALU32_IMM(BPF_MOV, R1, 0), 7395 BPF_ALU64_REG(BPF_RSH, R0, R1), 7396 BPF_EXIT_INSN(), 7397 }, 7398 INTERNAL, 7399 { }, 7400 { { 0, 0x89abcdef } } 7401 }, 7402 { 7403 "ALU64_RSH_X: Zero shift, high word", 7404 .u.insns_int = { 7405 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7406 BPF_ALU32_IMM(BPF_MOV, R1, 0), 7407 BPF_ALU64_REG(BPF_RSH, R0, R1), 7408 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7409 BPF_EXIT_INSN(), 7410 }, 7411 INTERNAL, 7412 { }, 7413 { { 0, 0x81234567 } } 7414 }, 7415 /* BPF_ALU | BPF_RSH | BPF_K */ 7416 { 7417 "ALU_RSH_K: 2 >> 1 = 1", 7418 .u.insns_int = { 7419 BPF_LD_IMM64(R0, 2), 7420 BPF_ALU32_IMM(BPF_RSH, R0, 1), 7421 BPF_EXIT_INSN(), 7422 }, 7423 INTERNAL, 7424 { }, 7425 { { 0, 1 } }, 7426 }, 7427 { 7428 "ALU_RSH_K: 0x80000000 >> 31 = 1", 7429 .u.insns_int = { 7430 BPF_LD_IMM64(R0, 0x80000000), 7431 BPF_ALU32_IMM(BPF_RSH, R0, 31), 7432 BPF_EXIT_INSN(), 7433 }, 7434 INTERNAL, 7435 { }, 7436 { { 0, 1 } }, 7437 }, 7438 { 7439 "ALU_RSH_K: 0x12345678 >> 20 = 0x123", 7440 .u.insns_int = { 7441 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 7442 BPF_ALU32_IMM(BPF_RSH, R0, 20), 7443 BPF_EXIT_INSN(), 7444 }, 7445 INTERNAL, 7446 { }, 7447 { { 0, 0x123 } } 7448 }, 7449 { 7450 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678", 7451 .u.insns_int = { 7452 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 7453 BPF_ALU32_IMM(BPF_RSH, R0, 0), 7454 BPF_EXIT_INSN(), 7455 }, 7456 INTERNAL, 7457 { }, 7458 { { 0, 0x12345678 } } 7459 }, 7460 { 7461 "ALU64_RSH_K: 2 >> 1 = 1", 7462 .u.insns_int = { 7463 BPF_LD_IMM64(R0, 2), 7464 BPF_ALU64_IMM(BPF_RSH, R0, 1), 7465 BPF_EXIT_INSN(), 7466 }, 7467 INTERNAL, 7468 { }, 7469 { { 0, 1 } }, 7470 }, 7471 { 7472 "ALU64_RSH_K: 0x80000000 >> 31 = 1", 7473 .u.insns_int = { 7474 BPF_LD_IMM64(R0, 0x80000000), 7475 BPF_ALU64_IMM(BPF_RSH, R0, 31), 7476 BPF_EXIT_INSN(), 7477 }, 7478 INTERNAL, 7479 { }, 7480 { { 0, 1 } }, 7481 }, 7482 { 7483 "ALU64_RSH_K: Shift < 32, low word", 7484 .u.insns_int = { 7485 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7486 BPF_ALU64_IMM(BPF_RSH, R0, 12), 7487 BPF_EXIT_INSN(), 7488 }, 7489 INTERNAL, 7490 { }, 7491 { { 0, 0x56789abc } } 7492 }, 7493 { 7494 "ALU64_RSH_K: Shift < 32, high word", 7495 .u.insns_int = { 7496 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7497 BPF_ALU64_IMM(BPF_RSH, R0, 12), 7498 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7499 BPF_EXIT_INSN(), 7500 }, 7501 INTERNAL, 7502 { }, 7503 { { 0, 0x00081234 } } 7504 }, 7505 { 7506 "ALU64_RSH_K: Shift > 32, low word", 7507 .u.insns_int = { 7508 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7509 BPF_ALU64_IMM(BPF_RSH, R0, 36), 7510 BPF_EXIT_INSN(), 7511 }, 7512 INTERNAL, 7513 { }, 7514 { { 0, 0x08123456 } } 7515 }, 7516 { 7517 "ALU64_RSH_K: Shift > 32, high word", 7518 .u.insns_int = { 7519 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7520 BPF_ALU64_IMM(BPF_RSH, R0, 36), 7521 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7522 BPF_EXIT_INSN(), 7523 }, 7524 INTERNAL, 7525 { }, 7526 { { 0, 0 } } 7527 }, 7528 { 7529 "ALU64_RSH_K: Shift == 32, low word", 7530 .u.insns_int = { 7531 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7532 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7533 BPF_EXIT_INSN(), 7534 }, 7535 INTERNAL, 7536 { }, 7537 { { 0, 0x81234567 } } 7538 }, 7539 { 7540 "ALU64_RSH_K: Shift == 32, high word", 7541 .u.insns_int = { 7542 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7543 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7544 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7545 BPF_EXIT_INSN(), 7546 }, 7547 INTERNAL, 7548 { }, 7549 { { 0, 0 } } 7550 }, 7551 { 7552 "ALU64_RSH_K: Zero shift", 7553 .u.insns_int = { 7554 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7555 BPF_ALU64_IMM(BPF_RSH, R0, 0), 7556 BPF_EXIT_INSN(), 7557 }, 7558 INTERNAL, 7559 { }, 7560 { { 0, 0x89abcdef } } 7561 }, 7562 /* BPF_ALU | BPF_ARSH | BPF_X */ 7563 { 7564 "ALU32_ARSH_X: -1234 >> 7 = -10", 7565 .u.insns_int = { 7566 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 7567 BPF_ALU32_IMM(BPF_MOV, R1, 7), 7568 BPF_ALU32_REG(BPF_ARSH, R0, R1), 7569 BPF_EXIT_INSN(), 7570 }, 7571 INTERNAL, 7572 { }, 7573 { { 0, -10 } } 7574 }, 7575 { 7576 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff", 7577 .u.insns_int = { 7578 BPF_LD_IMM64(R0, 0xff00ff0000000000LL), 7579 BPF_ALU32_IMM(BPF_MOV, R1, 40), 7580 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7581 BPF_EXIT_INSN(), 7582 }, 7583 INTERNAL, 7584 { }, 7585 { { 0, 0xffff00ff } }, 7586 }, 7587 { 7588 "ALU64_ARSH_X: Shift < 32, low word", 7589 .u.insns_int = { 7590 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7591 BPF_ALU32_IMM(BPF_MOV, R1, 12), 7592 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7593 BPF_EXIT_INSN(), 7594 }, 7595 INTERNAL, 7596 { }, 7597 { { 0, 0x56789abc } } 7598 }, 7599 { 7600 "ALU64_ARSH_X: Shift < 32, high word", 7601 .u.insns_int = { 7602 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7603 BPF_ALU32_IMM(BPF_MOV, R1, 12), 7604 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7605 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7606 BPF_EXIT_INSN(), 7607 }, 7608 INTERNAL, 7609 { }, 7610 { { 0, 0xfff81234 } } 7611 }, 7612 { 7613 "ALU64_ARSH_X: Shift > 32, low word", 7614 .u.insns_int = { 7615 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7616 BPF_ALU32_IMM(BPF_MOV, R1, 36), 7617 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7618 BPF_EXIT_INSN(), 7619 }, 7620 INTERNAL, 7621 { }, 7622 { { 0, 0xf8123456 } } 7623 }, 7624 { 7625 "ALU64_ARSH_X: Shift > 32, high word", 7626 .u.insns_int = { 7627 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7628 BPF_ALU32_IMM(BPF_MOV, R1, 36), 7629 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7630 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7631 BPF_EXIT_INSN(), 7632 }, 7633 INTERNAL, 7634 { }, 7635 { { 0, -1 } } 7636 }, 7637 { 7638 "ALU64_ARSH_X: Shift == 32, low word", 7639 .u.insns_int = { 7640 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7641 BPF_ALU32_IMM(BPF_MOV, R1, 32), 7642 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7643 BPF_EXIT_INSN(), 7644 }, 7645 INTERNAL, 7646 { }, 7647 { { 0, 0x81234567 } } 7648 }, 7649 { 7650 "ALU64_ARSH_X: Shift == 32, high word", 7651 .u.insns_int = { 7652 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7653 BPF_ALU32_IMM(BPF_MOV, R1, 32), 7654 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7655 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7656 BPF_EXIT_INSN(), 7657 }, 7658 INTERNAL, 7659 { }, 7660 { { 0, -1 } } 7661 }, 7662 { 7663 "ALU64_ARSH_X: Zero shift, low word", 7664 .u.insns_int = { 7665 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7666 BPF_ALU32_IMM(BPF_MOV, R1, 0), 7667 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7668 BPF_EXIT_INSN(), 7669 }, 7670 INTERNAL, 7671 { }, 7672 { { 0, 0x89abcdef } } 7673 }, 7674 { 7675 "ALU64_ARSH_X: Zero shift, high word", 7676 .u.insns_int = { 7677 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7678 BPF_ALU32_IMM(BPF_MOV, R1, 0), 7679 BPF_ALU64_REG(BPF_ARSH, R0, R1), 7680 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7681 BPF_EXIT_INSN(), 7682 }, 7683 INTERNAL, 7684 { }, 7685 { { 0, 0x81234567 } } 7686 }, 7687 /* BPF_ALU | BPF_ARSH | BPF_K */ 7688 { 7689 "ALU32_ARSH_K: -1234 >> 7 = -10", 7690 .u.insns_int = { 7691 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 7692 BPF_ALU32_IMM(BPF_ARSH, R0, 7), 7693 BPF_EXIT_INSN(), 7694 }, 7695 INTERNAL, 7696 { }, 7697 { { 0, -10 } } 7698 }, 7699 { 7700 "ALU32_ARSH_K: -1234 >> 0 = -1234", 7701 .u.insns_int = { 7702 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 7703 BPF_ALU32_IMM(BPF_ARSH, R0, 0), 7704 BPF_EXIT_INSN(), 7705 }, 7706 INTERNAL, 7707 { }, 7708 { { 0, -1234 } } 7709 }, 7710 { 7711 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff", 7712 .u.insns_int = { 7713 BPF_LD_IMM64(R0, 0xff00ff0000000000LL), 7714 BPF_ALU64_IMM(BPF_ARSH, R0, 40), 7715 BPF_EXIT_INSN(), 7716 }, 7717 INTERNAL, 7718 { }, 7719 { { 0, 0xffff00ff } }, 7720 }, 7721 { 7722 "ALU64_ARSH_K: Shift < 32, low word", 7723 .u.insns_int = { 7724 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7725 BPF_ALU64_IMM(BPF_RSH, R0, 12), 7726 BPF_EXIT_INSN(), 7727 }, 7728 INTERNAL, 7729 { }, 7730 { { 0, 0x56789abc } } 7731 }, 7732 { 7733 "ALU64_ARSH_K: Shift < 32, high word", 7734 .u.insns_int = { 7735 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7736 BPF_ALU64_IMM(BPF_ARSH, R0, 12), 7737 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7738 BPF_EXIT_INSN(), 7739 }, 7740 INTERNAL, 7741 { }, 7742 { { 0, 0xfff81234 } } 7743 }, 7744 { 7745 "ALU64_ARSH_K: Shift > 32, low word", 7746 .u.insns_int = { 7747 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7748 BPF_ALU64_IMM(BPF_ARSH, R0, 36), 7749 BPF_EXIT_INSN(), 7750 }, 7751 INTERNAL, 7752 { }, 7753 { { 0, 0xf8123456 } } 7754 }, 7755 { 7756 "ALU64_ARSH_K: Shift > 32, high word", 7757 .u.insns_int = { 7758 BPF_LD_IMM64(R0, 0xf123456789abcdefLL), 7759 BPF_ALU64_IMM(BPF_ARSH, R0, 36), 7760 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7761 BPF_EXIT_INSN(), 7762 }, 7763 INTERNAL, 7764 { }, 7765 { { 0, -1 } } 7766 }, 7767 { 7768 "ALU64_ARSH_K: Shift == 32, low word", 7769 .u.insns_int = { 7770 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7771 BPF_ALU64_IMM(BPF_ARSH, R0, 32), 7772 BPF_EXIT_INSN(), 7773 }, 7774 INTERNAL, 7775 { }, 7776 { { 0, 0x81234567 } } 7777 }, 7778 { 7779 "ALU64_ARSH_K: Shift == 32, high word", 7780 .u.insns_int = { 7781 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7782 BPF_ALU64_IMM(BPF_ARSH, R0, 32), 7783 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7784 BPF_EXIT_INSN(), 7785 }, 7786 INTERNAL, 7787 { }, 7788 { { 0, -1 } } 7789 }, 7790 { 7791 "ALU64_ARSH_K: Zero shift", 7792 .u.insns_int = { 7793 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 7794 BPF_ALU64_IMM(BPF_ARSH, R0, 0), 7795 BPF_EXIT_INSN(), 7796 }, 7797 INTERNAL, 7798 { }, 7799 { { 0, 0x89abcdef } } 7800 }, 7801 /* BPF_ALU | BPF_NEG */ 7802 { 7803 "ALU_NEG: -(3) = -3", 7804 .u.insns_int = { 7805 BPF_ALU32_IMM(BPF_MOV, R0, 3), 7806 BPF_ALU32_IMM(BPF_NEG, R0, 0), 7807 BPF_EXIT_INSN(), 7808 }, 7809 INTERNAL, 7810 { }, 7811 { { 0, -3 } }, 7812 }, 7813 { 7814 "ALU_NEG: -(-3) = 3", 7815 .u.insns_int = { 7816 BPF_ALU32_IMM(BPF_MOV, R0, -3), 7817 BPF_ALU32_IMM(BPF_NEG, R0, 0), 7818 BPF_EXIT_INSN(), 7819 }, 7820 INTERNAL, 7821 { }, 7822 { { 0, 3 } }, 7823 }, 7824 { 7825 "ALU64_NEG: -(3) = -3", 7826 .u.insns_int = { 7827 BPF_LD_IMM64(R0, 3), 7828 BPF_ALU64_IMM(BPF_NEG, R0, 0), 7829 BPF_EXIT_INSN(), 7830 }, 7831 INTERNAL, 7832 { }, 7833 { { 0, -3 } }, 7834 }, 7835 { 7836 "ALU64_NEG: -(-3) = 3", 7837 .u.insns_int = { 7838 BPF_LD_IMM64(R0, -3), 7839 BPF_ALU64_IMM(BPF_NEG, R0, 0), 7840 BPF_EXIT_INSN(), 7841 }, 7842 INTERNAL, 7843 { }, 7844 { { 0, 3 } }, 7845 }, 7846 /* BPF_ALU | BPF_END | BPF_FROM_BE */ 7847 { 7848 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef", 7849 .u.insns_int = { 7850 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7851 BPF_ENDIAN(BPF_FROM_BE, R0, 16), 7852 BPF_EXIT_INSN(), 7853 }, 7854 INTERNAL, 7855 { }, 7856 { { 0, cpu_to_be16(0xcdef) } }, 7857 }, 7858 { 7859 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef", 7860 .u.insns_int = { 7861 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7862 BPF_ENDIAN(BPF_FROM_BE, R0, 32), 7863 BPF_ALU64_REG(BPF_MOV, R1, R0), 7864 BPF_ALU64_IMM(BPF_RSH, R1, 32), 7865 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 7866 BPF_EXIT_INSN(), 7867 }, 7868 INTERNAL, 7869 { }, 7870 { { 0, cpu_to_be32(0x89abcdef) } }, 7871 }, 7872 { 7873 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef", 7874 .u.insns_int = { 7875 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7876 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 7877 BPF_EXIT_INSN(), 7878 }, 7879 INTERNAL, 7880 { }, 7881 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } }, 7882 }, 7883 { 7884 "ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567", 7885 .u.insns_int = { 7886 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7887 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 7888 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7889 BPF_EXIT_INSN(), 7890 }, 7891 INTERNAL, 7892 { }, 7893 { { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } }, 7894 }, 7895 /* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */ 7896 { 7897 "ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210", 7898 .u.insns_int = { 7899 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7900 BPF_ENDIAN(BPF_FROM_BE, R0, 16), 7901 BPF_EXIT_INSN(), 7902 }, 7903 INTERNAL, 7904 { }, 7905 { { 0, cpu_to_be16(0x3210) } }, 7906 }, 7907 { 7908 "ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210", 7909 .u.insns_int = { 7910 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7911 BPF_ENDIAN(BPF_FROM_BE, R0, 32), 7912 BPF_ALU64_REG(BPF_MOV, R1, R0), 7913 BPF_ALU64_IMM(BPF_RSH, R1, 32), 7914 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 7915 BPF_EXIT_INSN(), 7916 }, 7917 INTERNAL, 7918 { }, 7919 { { 0, cpu_to_be32(0x76543210) } }, 7920 }, 7921 { 7922 "ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210", 7923 .u.insns_int = { 7924 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7925 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 7926 BPF_EXIT_INSN(), 7927 }, 7928 INTERNAL, 7929 { }, 7930 { { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } }, 7931 }, 7932 { 7933 "ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98", 7934 .u.insns_int = { 7935 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7936 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 7937 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7938 BPF_EXIT_INSN(), 7939 }, 7940 INTERNAL, 7941 { }, 7942 { { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } }, 7943 }, 7944 /* BPF_ALU | BPF_END | BPF_FROM_LE */ 7945 { 7946 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd", 7947 .u.insns_int = { 7948 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7949 BPF_ENDIAN(BPF_FROM_LE, R0, 16), 7950 BPF_EXIT_INSN(), 7951 }, 7952 INTERNAL, 7953 { }, 7954 { { 0, cpu_to_le16(0xcdef) } }, 7955 }, 7956 { 7957 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89", 7958 .u.insns_int = { 7959 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7960 BPF_ENDIAN(BPF_FROM_LE, R0, 32), 7961 BPF_ALU64_REG(BPF_MOV, R1, R0), 7962 BPF_ALU64_IMM(BPF_RSH, R1, 32), 7963 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 7964 BPF_EXIT_INSN(), 7965 }, 7966 INTERNAL, 7967 { }, 7968 { { 0, cpu_to_le32(0x89abcdef) } }, 7969 }, 7970 { 7971 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301", 7972 .u.insns_int = { 7973 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7974 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 7975 BPF_EXIT_INSN(), 7976 }, 7977 INTERNAL, 7978 { }, 7979 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } }, 7980 }, 7981 { 7982 "ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89", 7983 .u.insns_int = { 7984 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7985 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 7986 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7987 BPF_EXIT_INSN(), 7988 }, 7989 INTERNAL, 7990 { }, 7991 { { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } }, 7992 }, 7993 /* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */ 7994 { 7995 "ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032", 7996 .u.insns_int = { 7997 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7998 BPF_ENDIAN(BPF_FROM_LE, R0, 16), 7999 BPF_EXIT_INSN(), 8000 }, 8001 INTERNAL, 8002 { }, 8003 { { 0, cpu_to_le16(0x3210) } }, 8004 }, 8005 { 8006 "ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476", 8007 .u.insns_int = { 8008 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 8009 BPF_ENDIAN(BPF_FROM_LE, R0, 32), 8010 BPF_ALU64_REG(BPF_MOV, R1, R0), 8011 BPF_ALU64_IMM(BPF_RSH, R1, 32), 8012 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 8013 BPF_EXIT_INSN(), 8014 }, 8015 INTERNAL, 8016 { }, 8017 { { 0, cpu_to_le32(0x76543210) } }, 8018 }, 8019 { 8020 "ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476", 8021 .u.insns_int = { 8022 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 8023 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 8024 BPF_EXIT_INSN(), 8025 }, 8026 INTERNAL, 8027 { }, 8028 { { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } }, 8029 }, 8030 { 8031 "ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe", 8032 .u.insns_int = { 8033 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 8034 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 8035 BPF_ALU64_IMM(BPF_RSH, R0, 32), 8036 BPF_EXIT_INSN(), 8037 }, 8038 INTERNAL, 8039 { }, 8040 { { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } }, 8041 }, 8042 /* BSWAP */ 8043 { 8044 "BSWAP 16: 0x0123456789abcdef -> 0xefcd", 8045 .u.insns_int = { 8046 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 8047 BPF_BSWAP(R0, 16), 8048 BPF_EXIT_INSN(), 8049 }, 8050 INTERNAL, 8051 { }, 8052 { { 0, 0xefcd } }, 8053 }, 8054 { 8055 "BSWAP 32: 0x0123456789abcdef -> 0xefcdab89", 8056 .u.insns_int = { 8057 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 8058 BPF_BSWAP(R0, 32), 8059 BPF_ALU64_REG(BPF_MOV, R1, R0), 8060 BPF_ALU64_IMM(BPF_RSH, R1, 32), 8061 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 8062 BPF_EXIT_INSN(), 8063 }, 8064 INTERNAL, 8065 { }, 8066 { { 0, 0xefcdab89 } }, 8067 }, 8068 { 8069 "BSWAP 64: 0x0123456789abcdef -> 0x67452301", 8070 .u.insns_int = { 8071 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 8072 BPF_BSWAP(R0, 64), 8073 BPF_EXIT_INSN(), 8074 }, 8075 INTERNAL, 8076 { }, 8077 { { 0, 0x67452301 } }, 8078 }, 8079 { 8080 "BSWAP 64: 0x0123456789abcdef >> 32 -> 0xefcdab89", 8081 .u.insns_int = { 8082 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 8083 BPF_BSWAP(R0, 64), 8084 BPF_ALU64_IMM(BPF_RSH, R0, 32), 8085 BPF_EXIT_INSN(), 8086 }, 8087 INTERNAL, 8088 { }, 8089 { { 0, 0xefcdab89 } }, 8090 }, 8091 /* BSWAP, reversed */ 8092 { 8093 "BSWAP 16: 0xfedcba9876543210 -> 0x1032", 8094 .u.insns_int = { 8095 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 8096 BPF_BSWAP(R0, 16), 8097 BPF_EXIT_INSN(), 8098 }, 8099 INTERNAL, 8100 { }, 8101 { { 0, 0x1032 } }, 8102 }, 8103 { 8104 "BSWAP 32: 0xfedcba9876543210 -> 0x10325476", 8105 .u.insns_int = { 8106 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 8107 BPF_BSWAP(R0, 32), 8108 BPF_ALU64_REG(BPF_MOV, R1, R0), 8109 BPF_ALU64_IMM(BPF_RSH, R1, 32), 8110 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 8111 BPF_EXIT_INSN(), 8112 }, 8113 INTERNAL, 8114 { }, 8115 { { 0, 0x10325476 } }, 8116 }, 8117 { 8118 "BSWAP 64: 0xfedcba9876543210 -> 0x98badcfe", 8119 .u.insns_int = { 8120 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 8121 BPF_BSWAP(R0, 64), 8122 BPF_EXIT_INSN(), 8123 }, 8124 INTERNAL, 8125 { }, 8126 { { 0, 0x98badcfe } }, 8127 }, 8128 { 8129 "BSWAP 64: 0xfedcba9876543210 >> 32 -> 0x10325476", 8130 .u.insns_int = { 8131 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 8132 BPF_BSWAP(R0, 64), 8133 BPF_ALU64_IMM(BPF_RSH, R0, 32), 8134 BPF_EXIT_INSN(), 8135 }, 8136 INTERNAL, 8137 { }, 8138 { { 0, 0x10325476 } }, 8139 }, 8140 /* BPF_LDX_MEM B/H/W/DW */ 8141 { 8142 "BPF_LDX_MEM | BPF_B, base", 8143 .u.insns_int = { 8144 BPF_LD_IMM64(R1, 0x0102030405060708ULL), 8145 BPF_LD_IMM64(R2, 0x0000000000000008ULL), 8146 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8147#ifdef __BIG_ENDIAN 8148 BPF_LDX_MEM(BPF_B, R0, R10, -1), 8149#else 8150 BPF_LDX_MEM(BPF_B, R0, R10, -8), 8151#endif 8152 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8153 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8154 BPF_EXIT_INSN(), 8155 }, 8156 INTERNAL, 8157 { }, 8158 { { 0, 0 } }, 8159 .stack_depth = 8, 8160 }, 8161 { 8162 "BPF_LDX_MEM | BPF_B, MSB set", 8163 .u.insns_int = { 8164 BPF_LD_IMM64(R1, 0x8182838485868788ULL), 8165 BPF_LD_IMM64(R2, 0x0000000000000088ULL), 8166 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8167#ifdef __BIG_ENDIAN 8168 BPF_LDX_MEM(BPF_B, R0, R10, -1), 8169#else 8170 BPF_LDX_MEM(BPF_B, R0, R10, -8), 8171#endif 8172 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8173 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8174 BPF_EXIT_INSN(), 8175 }, 8176 INTERNAL, 8177 { }, 8178 { { 0, 0 } }, 8179 .stack_depth = 8, 8180 }, 8181 { 8182 "BPF_LDX_MEM | BPF_B, negative offset", 8183 .u.insns_int = { 8184 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8185 BPF_LD_IMM64(R3, 0x0000000000000088ULL), 8186 BPF_ALU64_IMM(BPF_ADD, R1, 512), 8187 BPF_STX_MEM(BPF_B, R1, R2, -256), 8188 BPF_LDX_MEM(BPF_B, R0, R1, -256), 8189 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8190 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8191 BPF_EXIT_INSN(), 8192 }, 8193 INTERNAL | FLAG_LARGE_MEM, 8194 { }, 8195 { { 512, 0 } }, 8196 .stack_depth = 0, 8197 }, 8198 { 8199 "BPF_LDX_MEM | BPF_B, small positive offset", 8200 .u.insns_int = { 8201 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8202 BPF_LD_IMM64(R3, 0x0000000000000088ULL), 8203 BPF_STX_MEM(BPF_B, R1, R2, 256), 8204 BPF_LDX_MEM(BPF_B, R0, R1, 256), 8205 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8206 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8207 BPF_EXIT_INSN(), 8208 }, 8209 INTERNAL | FLAG_LARGE_MEM, 8210 { }, 8211 { { 512, 0 } }, 8212 .stack_depth = 0, 8213 }, 8214 { 8215 "BPF_LDX_MEM | BPF_B, large positive offset", 8216 .u.insns_int = { 8217 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8218 BPF_LD_IMM64(R3, 0x0000000000000088ULL), 8219 BPF_STX_MEM(BPF_B, R1, R2, 4096), 8220 BPF_LDX_MEM(BPF_B, R0, R1, 4096), 8221 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8222 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8223 BPF_EXIT_INSN(), 8224 }, 8225 INTERNAL | FLAG_LARGE_MEM, 8226 { }, 8227 { { 4096 + 16, 0 } }, 8228 .stack_depth = 0, 8229 }, 8230 { 8231 "BPF_LDX_MEM | BPF_H, base", 8232 .u.insns_int = { 8233 BPF_LD_IMM64(R1, 0x0102030405060708ULL), 8234 BPF_LD_IMM64(R2, 0x0000000000000708ULL), 8235 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8236#ifdef __BIG_ENDIAN 8237 BPF_LDX_MEM(BPF_H, R0, R10, -2), 8238#else 8239 BPF_LDX_MEM(BPF_H, R0, R10, -8), 8240#endif 8241 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8242 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8243 BPF_EXIT_INSN(), 8244 }, 8245 INTERNAL, 8246 { }, 8247 { { 0, 0 } }, 8248 .stack_depth = 8, 8249 }, 8250 { 8251 "BPF_LDX_MEM | BPF_H, MSB set", 8252 .u.insns_int = { 8253 BPF_LD_IMM64(R1, 0x8182838485868788ULL), 8254 BPF_LD_IMM64(R2, 0x0000000000008788ULL), 8255 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8256#ifdef __BIG_ENDIAN 8257 BPF_LDX_MEM(BPF_H, R0, R10, -2), 8258#else 8259 BPF_LDX_MEM(BPF_H, R0, R10, -8), 8260#endif 8261 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8262 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8263 BPF_EXIT_INSN(), 8264 }, 8265 INTERNAL, 8266 { }, 8267 { { 0, 0 } }, 8268 .stack_depth = 8, 8269 }, 8270 { 8271 "BPF_LDX_MEM | BPF_H, negative offset", 8272 .u.insns_int = { 8273 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8274 BPF_LD_IMM64(R3, 0x0000000000008788ULL), 8275 BPF_ALU64_IMM(BPF_ADD, R1, 512), 8276 BPF_STX_MEM(BPF_H, R1, R2, -256), 8277 BPF_LDX_MEM(BPF_H, R0, R1, -256), 8278 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8279 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8280 BPF_EXIT_INSN(), 8281 }, 8282 INTERNAL | FLAG_LARGE_MEM, 8283 { }, 8284 { { 512, 0 } }, 8285 .stack_depth = 0, 8286 }, 8287 { 8288 "BPF_LDX_MEM | BPF_H, small positive offset", 8289 .u.insns_int = { 8290 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8291 BPF_LD_IMM64(R3, 0x0000000000008788ULL), 8292 BPF_STX_MEM(BPF_H, R1, R2, 256), 8293 BPF_LDX_MEM(BPF_H, R0, R1, 256), 8294 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8295 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8296 BPF_EXIT_INSN(), 8297 }, 8298 INTERNAL | FLAG_LARGE_MEM, 8299 { }, 8300 { { 512, 0 } }, 8301 .stack_depth = 0, 8302 }, 8303 { 8304 "BPF_LDX_MEM | BPF_H, large positive offset", 8305 .u.insns_int = { 8306 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8307 BPF_LD_IMM64(R3, 0x0000000000008788ULL), 8308 BPF_STX_MEM(BPF_H, R1, R2, 8192), 8309 BPF_LDX_MEM(BPF_H, R0, R1, 8192), 8310 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8311 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8312 BPF_EXIT_INSN(), 8313 }, 8314 INTERNAL | FLAG_LARGE_MEM, 8315 { }, 8316 { { 8192 + 16, 0 } }, 8317 .stack_depth = 0, 8318 }, 8319 { 8320 "BPF_LDX_MEM | BPF_H, unaligned positive offset", 8321 .u.insns_int = { 8322 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8323 BPF_LD_IMM64(R3, 0x0000000000008788ULL), 8324 BPF_STX_MEM(BPF_H, R1, R2, 13), 8325 BPF_LDX_MEM(BPF_H, R0, R1, 13), 8326 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8327 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8328 BPF_EXIT_INSN(), 8329 }, 8330 INTERNAL | FLAG_LARGE_MEM, 8331 { }, 8332 { { 32, 0 } }, 8333 .stack_depth = 0, 8334 }, 8335 { 8336 "BPF_LDX_MEM | BPF_W, base", 8337 .u.insns_int = { 8338 BPF_LD_IMM64(R1, 0x0102030405060708ULL), 8339 BPF_LD_IMM64(R2, 0x0000000005060708ULL), 8340 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8341#ifdef __BIG_ENDIAN 8342 BPF_LDX_MEM(BPF_W, R0, R10, -4), 8343#else 8344 BPF_LDX_MEM(BPF_W, R0, R10, -8), 8345#endif 8346 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8347 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8348 BPF_EXIT_INSN(), 8349 }, 8350 INTERNAL, 8351 { }, 8352 { { 0, 0 } }, 8353 .stack_depth = 8, 8354 }, 8355 { 8356 "BPF_LDX_MEM | BPF_W, MSB set", 8357 .u.insns_int = { 8358 BPF_LD_IMM64(R1, 0x8182838485868788ULL), 8359 BPF_LD_IMM64(R2, 0x0000000085868788ULL), 8360 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8361#ifdef __BIG_ENDIAN 8362 BPF_LDX_MEM(BPF_W, R0, R10, -4), 8363#else 8364 BPF_LDX_MEM(BPF_W, R0, R10, -8), 8365#endif 8366 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8367 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8368 BPF_EXIT_INSN(), 8369 }, 8370 INTERNAL, 8371 { }, 8372 { { 0, 0 } }, 8373 .stack_depth = 8, 8374 }, 8375 { 8376 "BPF_LDX_MEM | BPF_W, negative offset", 8377 .u.insns_int = { 8378 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8379 BPF_LD_IMM64(R3, 0x0000000085868788ULL), 8380 BPF_ALU64_IMM(BPF_ADD, R1, 512), 8381 BPF_STX_MEM(BPF_W, R1, R2, -256), 8382 BPF_LDX_MEM(BPF_W, R0, R1, -256), 8383 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8384 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8385 BPF_EXIT_INSN(), 8386 }, 8387 INTERNAL | FLAG_LARGE_MEM, 8388 { }, 8389 { { 512, 0 } }, 8390 .stack_depth = 0, 8391 }, 8392 { 8393 "BPF_LDX_MEM | BPF_W, small positive offset", 8394 .u.insns_int = { 8395 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8396 BPF_LD_IMM64(R3, 0x0000000085868788ULL), 8397 BPF_STX_MEM(BPF_W, R1, R2, 256), 8398 BPF_LDX_MEM(BPF_W, R0, R1, 256), 8399 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8400 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8401 BPF_EXIT_INSN(), 8402 }, 8403 INTERNAL | FLAG_LARGE_MEM, 8404 { }, 8405 { { 512, 0 } }, 8406 .stack_depth = 0, 8407 }, 8408 { 8409 "BPF_LDX_MEM | BPF_W, large positive offset", 8410 .u.insns_int = { 8411 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8412 BPF_LD_IMM64(R3, 0x0000000085868788ULL), 8413 BPF_STX_MEM(BPF_W, R1, R2, 16384), 8414 BPF_LDX_MEM(BPF_W, R0, R1, 16384), 8415 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8416 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8417 BPF_EXIT_INSN(), 8418 }, 8419 INTERNAL | FLAG_LARGE_MEM, 8420 { }, 8421 { { 16384 + 16, 0 } }, 8422 .stack_depth = 0, 8423 }, 8424 { 8425 "BPF_LDX_MEM | BPF_W, unaligned positive offset", 8426 .u.insns_int = { 8427 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8428 BPF_LD_IMM64(R3, 0x0000000085868788ULL), 8429 BPF_STX_MEM(BPF_W, R1, R2, 13), 8430 BPF_LDX_MEM(BPF_W, R0, R1, 13), 8431 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8432 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8433 BPF_EXIT_INSN(), 8434 }, 8435 INTERNAL | FLAG_LARGE_MEM, 8436 { }, 8437 { { 32, 0 } }, 8438 .stack_depth = 0, 8439 }, 8440 { 8441 "BPF_LDX_MEM | BPF_DW, base", 8442 .u.insns_int = { 8443 BPF_LD_IMM64(R1, 0x0102030405060708ULL), 8444 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8445 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 8446 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 8447 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8448 BPF_EXIT_INSN(), 8449 }, 8450 INTERNAL, 8451 { }, 8452 { { 0, 0 } }, 8453 .stack_depth = 8, 8454 }, 8455 { 8456 "BPF_LDX_MEM | BPF_DW, MSB set", 8457 .u.insns_int = { 8458 BPF_LD_IMM64(R1, 0x8182838485868788ULL), 8459 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8460 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 8461 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 8462 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8463 BPF_EXIT_INSN(), 8464 }, 8465 INTERNAL, 8466 { }, 8467 { { 0, 0 } }, 8468 .stack_depth = 8, 8469 }, 8470 { 8471 "BPF_LDX_MEM | BPF_DW, negative offset", 8472 .u.insns_int = { 8473 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8474 BPF_ALU64_IMM(BPF_ADD, R1, 512), 8475 BPF_STX_MEM(BPF_DW, R1, R2, -256), 8476 BPF_LDX_MEM(BPF_DW, R0, R1, -256), 8477 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8478 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8479 BPF_EXIT_INSN(), 8480 }, 8481 INTERNAL | FLAG_LARGE_MEM, 8482 { }, 8483 { { 512, 0 } }, 8484 .stack_depth = 0, 8485 }, 8486 { 8487 "BPF_LDX_MEM | BPF_DW, small positive offset", 8488 .u.insns_int = { 8489 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8490 BPF_STX_MEM(BPF_DW, R1, R2, 256), 8491 BPF_LDX_MEM(BPF_DW, R0, R1, 256), 8492 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8493 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8494 BPF_EXIT_INSN(), 8495 }, 8496 INTERNAL | FLAG_LARGE_MEM, 8497 { }, 8498 { { 512, 0 } }, 8499 .stack_depth = 8, 8500 }, 8501 { 8502 "BPF_LDX_MEM | BPF_DW, large positive offset", 8503 .u.insns_int = { 8504 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8505 BPF_STX_MEM(BPF_DW, R1, R2, 32760), 8506 BPF_LDX_MEM(BPF_DW, R0, R1, 32760), 8507 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8508 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8509 BPF_EXIT_INSN(), 8510 }, 8511 INTERNAL | FLAG_LARGE_MEM, 8512 { }, 8513 { { 32768, 0 } }, 8514 .stack_depth = 0, 8515 }, 8516 { 8517 "BPF_LDX_MEM | BPF_DW, unaligned positive offset", 8518 .u.insns_int = { 8519 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8520 BPF_STX_MEM(BPF_DW, R1, R2, 13), 8521 BPF_LDX_MEM(BPF_DW, R0, R1, 13), 8522 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8523 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8524 BPF_EXIT_INSN(), 8525 }, 8526 INTERNAL | FLAG_LARGE_MEM, 8527 { }, 8528 { { 32, 0 } }, 8529 .stack_depth = 0, 8530 }, 8531 /* BPF_LDX_MEMSX B/H/W */ 8532 { 8533 "BPF_LDX_MEMSX | BPF_B", 8534 .u.insns_int = { 8535 BPF_LD_IMM64(R1, 0xdead0000000000f0ULL), 8536 BPF_LD_IMM64(R2, 0xfffffffffffffff0ULL), 8537 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8538#ifdef __BIG_ENDIAN 8539 BPF_LDX_MEMSX(BPF_B, R0, R10, -1), 8540#else 8541 BPF_LDX_MEMSX(BPF_B, R0, R10, -8), 8542#endif 8543 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8544 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8545 BPF_EXIT_INSN(), 8546 }, 8547 INTERNAL, 8548 { }, 8549 { { 0, 0 } }, 8550 .stack_depth = 8, 8551 }, 8552 { 8553 "BPF_LDX_MEMSX | BPF_H", 8554 .u.insns_int = { 8555 BPF_LD_IMM64(R1, 0xdead00000000f123ULL), 8556 BPF_LD_IMM64(R2, 0xfffffffffffff123ULL), 8557 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8558#ifdef __BIG_ENDIAN 8559 BPF_LDX_MEMSX(BPF_H, R0, R10, -2), 8560#else 8561 BPF_LDX_MEMSX(BPF_H, R0, R10, -8), 8562#endif 8563 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8564 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8565 BPF_EXIT_INSN(), 8566 }, 8567 INTERNAL, 8568 { }, 8569 { { 0, 0 } }, 8570 .stack_depth = 8, 8571 }, 8572 { 8573 "BPF_LDX_MEMSX | BPF_W", 8574 .u.insns_int = { 8575 BPF_LD_IMM64(R1, 0x00000000deadbeefULL), 8576 BPF_LD_IMM64(R2, 0xffffffffdeadbeefULL), 8577 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8578#ifdef __BIG_ENDIAN 8579 BPF_LDX_MEMSX(BPF_W, R0, R10, -4), 8580#else 8581 BPF_LDX_MEMSX(BPF_W, R0, R10, -8), 8582#endif 8583 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8584 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8585 BPF_EXIT_INSN(), 8586 }, 8587 INTERNAL, 8588 { }, 8589 { { 0, 0 } }, 8590 .stack_depth = 8, 8591 }, 8592 /* BPF_STX_MEM B/H/W/DW */ 8593 { 8594 "BPF_STX_MEM | BPF_B", 8595 .u.insns_int = { 8596 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 8597 BPF_LD_IMM64(R2, 0x0102030405060708ULL), 8598 BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL), 8599 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8600#ifdef __BIG_ENDIAN 8601 BPF_STX_MEM(BPF_B, R10, R2, -1), 8602#else 8603 BPF_STX_MEM(BPF_B, R10, R2, -8), 8604#endif 8605 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 8606 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8607 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8608 BPF_EXIT_INSN(), 8609 }, 8610 INTERNAL, 8611 { }, 8612 { { 0, 0 } }, 8613 .stack_depth = 8, 8614 }, 8615 { 8616 "BPF_STX_MEM | BPF_B, MSB set", 8617 .u.insns_int = { 8618 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 8619 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8620 BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL), 8621 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8622#ifdef __BIG_ENDIAN 8623 BPF_STX_MEM(BPF_B, R10, R2, -1), 8624#else 8625 BPF_STX_MEM(BPF_B, R10, R2, -8), 8626#endif 8627 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 8628 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8629 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8630 BPF_EXIT_INSN(), 8631 }, 8632 INTERNAL, 8633 { }, 8634 { { 0, 0 } }, 8635 .stack_depth = 8, 8636 }, 8637 { 8638 "BPF_STX_MEM | BPF_H", 8639 .u.insns_int = { 8640 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 8641 BPF_LD_IMM64(R2, 0x0102030405060708ULL), 8642 BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL), 8643 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8644#ifdef __BIG_ENDIAN 8645 BPF_STX_MEM(BPF_H, R10, R2, -2), 8646#else 8647 BPF_STX_MEM(BPF_H, R10, R2, -8), 8648#endif 8649 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 8650 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8651 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8652 BPF_EXIT_INSN(), 8653 }, 8654 INTERNAL, 8655 { }, 8656 { { 0, 0 } }, 8657 .stack_depth = 8, 8658 }, 8659 { 8660 "BPF_STX_MEM | BPF_H, MSB set", 8661 .u.insns_int = { 8662 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 8663 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8664 BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL), 8665 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8666#ifdef __BIG_ENDIAN 8667 BPF_STX_MEM(BPF_H, R10, R2, -2), 8668#else 8669 BPF_STX_MEM(BPF_H, R10, R2, -8), 8670#endif 8671 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 8672 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8673 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8674 BPF_EXIT_INSN(), 8675 }, 8676 INTERNAL, 8677 { }, 8678 { { 0, 0 } }, 8679 .stack_depth = 8, 8680 }, 8681 { 8682 "BPF_STX_MEM | BPF_W", 8683 .u.insns_int = { 8684 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 8685 BPF_LD_IMM64(R2, 0x0102030405060708ULL), 8686 BPF_LD_IMM64(R3, 0x8090a0b005060708ULL), 8687 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8688#ifdef __BIG_ENDIAN 8689 BPF_STX_MEM(BPF_W, R10, R2, -4), 8690#else 8691 BPF_STX_MEM(BPF_W, R10, R2, -8), 8692#endif 8693 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 8694 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8695 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8696 BPF_EXIT_INSN(), 8697 }, 8698 INTERNAL, 8699 { }, 8700 { { 0, 0 } }, 8701 .stack_depth = 8, 8702 }, 8703 { 8704 "BPF_STX_MEM | BPF_W, MSB set", 8705 .u.insns_int = { 8706 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 8707 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 8708 BPF_LD_IMM64(R3, 0x8090a0b085868788ULL), 8709 BPF_STX_MEM(BPF_DW, R10, R1, -8), 8710#ifdef __BIG_ENDIAN 8711 BPF_STX_MEM(BPF_W, R10, R2, -4), 8712#else 8713 BPF_STX_MEM(BPF_W, R10, R2, -8), 8714#endif 8715 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 8716 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 8717 BPF_ALU64_IMM(BPF_MOV, R0, 0), 8718 BPF_EXIT_INSN(), 8719 }, 8720 INTERNAL, 8721 { }, 8722 { { 0, 0 } }, 8723 .stack_depth = 8, 8724 }, 8725 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */ 8726 { 8727 "ST_MEM_B: Store/Load byte: max negative", 8728 .u.insns_int = { 8729 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8730 BPF_ST_MEM(BPF_B, R10, -40, 0xff), 8731 BPF_LDX_MEM(BPF_B, R0, R10, -40), 8732 BPF_EXIT_INSN(), 8733 }, 8734 INTERNAL, 8735 { }, 8736 { { 0, 0xff } }, 8737 .stack_depth = 40, 8738 }, 8739 { 8740 "ST_MEM_B: Store/Load byte: max positive", 8741 .u.insns_int = { 8742 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8743 BPF_ST_MEM(BPF_H, R10, -40, 0x7f), 8744 BPF_LDX_MEM(BPF_H, R0, R10, -40), 8745 BPF_EXIT_INSN(), 8746 }, 8747 INTERNAL, 8748 { }, 8749 { { 0, 0x7f } }, 8750 .stack_depth = 40, 8751 }, 8752 { 8753 "STX_MEM_B: Store/Load byte: max negative", 8754 .u.insns_int = { 8755 BPF_LD_IMM64(R0, 0), 8756 BPF_LD_IMM64(R1, 0xffLL), 8757 BPF_STX_MEM(BPF_B, R10, R1, -40), 8758 BPF_LDX_MEM(BPF_B, R0, R10, -40), 8759 BPF_EXIT_INSN(), 8760 }, 8761 INTERNAL, 8762 { }, 8763 { { 0, 0xff } }, 8764 .stack_depth = 40, 8765 }, 8766 { 8767 "ST_MEM_H: Store/Load half word: max negative", 8768 .u.insns_int = { 8769 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8770 BPF_ST_MEM(BPF_H, R10, -40, 0xffff), 8771 BPF_LDX_MEM(BPF_H, R0, R10, -40), 8772 BPF_EXIT_INSN(), 8773 }, 8774 INTERNAL, 8775 { }, 8776 { { 0, 0xffff } }, 8777 .stack_depth = 40, 8778 }, 8779 { 8780 "ST_MEM_H: Store/Load half word: max positive", 8781 .u.insns_int = { 8782 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8783 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff), 8784 BPF_LDX_MEM(BPF_H, R0, R10, -40), 8785 BPF_EXIT_INSN(), 8786 }, 8787 INTERNAL, 8788 { }, 8789 { { 0, 0x7fff } }, 8790 .stack_depth = 40, 8791 }, 8792 { 8793 "STX_MEM_H: Store/Load half word: max negative", 8794 .u.insns_int = { 8795 BPF_LD_IMM64(R0, 0), 8796 BPF_LD_IMM64(R1, 0xffffLL), 8797 BPF_STX_MEM(BPF_H, R10, R1, -40), 8798 BPF_LDX_MEM(BPF_H, R0, R10, -40), 8799 BPF_EXIT_INSN(), 8800 }, 8801 INTERNAL, 8802 { }, 8803 { { 0, 0xffff } }, 8804 .stack_depth = 40, 8805 }, 8806 { 8807 "ST_MEM_W: Store/Load word: max negative", 8808 .u.insns_int = { 8809 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8810 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff), 8811 BPF_LDX_MEM(BPF_W, R0, R10, -40), 8812 BPF_EXIT_INSN(), 8813 }, 8814 INTERNAL, 8815 { }, 8816 { { 0, 0xffffffff } }, 8817 .stack_depth = 40, 8818 }, 8819 { 8820 "ST_MEM_W: Store/Load word: max positive", 8821 .u.insns_int = { 8822 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8823 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff), 8824 BPF_LDX_MEM(BPF_W, R0, R10, -40), 8825 BPF_EXIT_INSN(), 8826 }, 8827 INTERNAL, 8828 { }, 8829 { { 0, 0x7fffffff } }, 8830 .stack_depth = 40, 8831 }, 8832 { 8833 "STX_MEM_W: Store/Load word: max negative", 8834 .u.insns_int = { 8835 BPF_LD_IMM64(R0, 0), 8836 BPF_LD_IMM64(R1, 0xffffffffLL), 8837 BPF_STX_MEM(BPF_W, R10, R1, -40), 8838 BPF_LDX_MEM(BPF_W, R0, R10, -40), 8839 BPF_EXIT_INSN(), 8840 }, 8841 INTERNAL, 8842 { }, 8843 { { 0, 0xffffffff } }, 8844 .stack_depth = 40, 8845 }, 8846 { 8847 "ST_MEM_DW: Store/Load double word: max negative", 8848 .u.insns_int = { 8849 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8850 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff), 8851 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 8852 BPF_EXIT_INSN(), 8853 }, 8854 INTERNAL, 8855 { }, 8856 { { 0, 0xffffffff } }, 8857 .stack_depth = 40, 8858 }, 8859 { 8860 "ST_MEM_DW: Store/Load double word: max negative 2", 8861 .u.insns_int = { 8862 BPF_LD_IMM64(R2, 0xffff00000000ffffLL), 8863 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 8864 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff), 8865 BPF_LDX_MEM(BPF_DW, R2, R10, -40), 8866 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 8867 BPF_MOV32_IMM(R0, 2), 8868 BPF_EXIT_INSN(), 8869 BPF_MOV32_IMM(R0, 1), 8870 BPF_EXIT_INSN(), 8871 }, 8872 INTERNAL, 8873 { }, 8874 { { 0, 0x1 } }, 8875 .stack_depth = 40, 8876 }, 8877 { 8878 "ST_MEM_DW: Store/Load double word: max positive", 8879 .u.insns_int = { 8880 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8881 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff), 8882 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 8883 BPF_EXIT_INSN(), 8884 }, 8885 INTERNAL, 8886 { }, 8887 { { 0, 0x7fffffff } }, 8888 .stack_depth = 40, 8889 }, 8890 { 8891 "STX_MEM_DW: Store/Load double word: max negative", 8892 .u.insns_int = { 8893 BPF_LD_IMM64(R0, 0), 8894 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 8895 BPF_STX_MEM(BPF_DW, R10, R1, -40), 8896 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 8897 BPF_EXIT_INSN(), 8898 }, 8899 INTERNAL, 8900 { }, 8901 { { 0, 0xffffffff } }, 8902 .stack_depth = 40, 8903 }, 8904 { 8905 "STX_MEM_DW: Store double word: first word in memory", 8906 .u.insns_int = { 8907 BPF_LD_IMM64(R0, 0), 8908 BPF_LD_IMM64(R1, 0x0123456789abcdefLL), 8909 BPF_STX_MEM(BPF_DW, R10, R1, -40), 8910 BPF_LDX_MEM(BPF_W, R0, R10, -40), 8911 BPF_EXIT_INSN(), 8912 }, 8913 INTERNAL, 8914 { }, 8915#ifdef __BIG_ENDIAN 8916 { { 0, 0x01234567 } }, 8917#else 8918 { { 0, 0x89abcdef } }, 8919#endif 8920 .stack_depth = 40, 8921 }, 8922 { 8923 "STX_MEM_DW: Store double word: second word in memory", 8924 .u.insns_int = { 8925 BPF_LD_IMM64(R0, 0), 8926 BPF_LD_IMM64(R1, 0x0123456789abcdefLL), 8927 BPF_STX_MEM(BPF_DW, R10, R1, -40), 8928 BPF_LDX_MEM(BPF_W, R0, R10, -36), 8929 BPF_EXIT_INSN(), 8930 }, 8931 INTERNAL, 8932 { }, 8933#ifdef __BIG_ENDIAN 8934 { { 0, 0x89abcdef } }, 8935#else 8936 { { 0, 0x01234567 } }, 8937#endif 8938 .stack_depth = 40, 8939 }, 8940 /* BPF_STX | BPF_ATOMIC | BPF_W/DW */ 8941 { 8942 "STX_XADD_W: X + 1 + 1 + 1 + ...", 8943 { }, 8944 INTERNAL, 8945 { }, 8946 { { 0, 4134 } }, 8947 .fill_helper = bpf_fill_stxw, 8948 }, 8949 { 8950 "STX_XADD_DW: X + 1 + 1 + 1 + ...", 8951 { }, 8952 INTERNAL, 8953 { }, 8954 { { 0, 4134 } }, 8955 .fill_helper = bpf_fill_stxdw, 8956 }, 8957 /* 8958 * Exhaustive tests of atomic operation variants. 8959 * Individual tests are expanded from template macros for all 8960 * combinations of ALU operation, word size and fetching. 8961 */ 8962#define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0) 8963 8964#define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result) \ 8965{ \ 8966 "BPF_ATOMIC | " #width ", " #op ": Test: " \ 8967 #old " " #logic " " #update " = " #result, \ 8968 .u.insns_int = { \ 8969 BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)), \ 8970 BPF_ST_MEM(width, R10, -40, old), \ 8971 BPF_ATOMIC_OP(width, op, R10, R5, -40), \ 8972 BPF_LDX_MEM(width, R0, R10, -40), \ 8973 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 8974 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 8975 BPF_ALU64_REG(BPF_OR, R0, R1), \ 8976 BPF_EXIT_INSN(), \ 8977 }, \ 8978 INTERNAL, \ 8979 { }, \ 8980 { { 0, result } }, \ 8981 .stack_depth = 40, \ 8982} 8983#define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result) \ 8984{ \ 8985 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: " \ 8986 #old " " #logic " " #update " = " #result, \ 8987 .u.insns_int = { \ 8988 BPF_ALU64_REG(BPF_MOV, R1, R10), \ 8989 BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)), \ 8990 BPF_ST_MEM(BPF_W, R10, -40, old), \ 8991 BPF_ATOMIC_OP(width, op, R10, R0, -40), \ 8992 BPF_ALU64_REG(BPF_MOV, R0, R10), \ 8993 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 8994 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 8995 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 8996 BPF_ALU64_REG(BPF_OR, R0, R1), \ 8997 BPF_EXIT_INSN(), \ 8998 }, \ 8999 INTERNAL, \ 9000 { }, \ 9001 { { 0, 0 } }, \ 9002 .stack_depth = 40, \ 9003} 9004#define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result) \ 9005{ \ 9006 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: " \ 9007 #old " " #logic " " #update " = " #result, \ 9008 .u.insns_int = { \ 9009 BPF_ALU64_REG(BPF_MOV, R0, R10), \ 9010 BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)), \ 9011 BPF_ST_MEM(width, R10, -40, old), \ 9012 BPF_ATOMIC_OP(width, op, R10, R1, -40), \ 9013 BPF_ALU64_REG(BPF_SUB, R0, R10), \ 9014 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 9015 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 9016 BPF_ALU64_REG(BPF_OR, R0, R1), \ 9017 BPF_EXIT_INSN(), \ 9018 }, \ 9019 INTERNAL, \ 9020 { }, \ 9021 { { 0, 0 } }, \ 9022 .stack_depth = 40, \ 9023} 9024#define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result) \ 9025{ \ 9026 "BPF_ATOMIC | " #width ", " #op ": Test fetch: " \ 9027 #old " " #logic " " #update " = " #result, \ 9028 .u.insns_int = { \ 9029 BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)), \ 9030 BPF_ST_MEM(width, R10, -40, old), \ 9031 BPF_ATOMIC_OP(width, op, R10, R3, -40), \ 9032 BPF_ALU32_REG(BPF_MOV, R0, R3), \ 9033 BPF_EXIT_INSN(), \ 9034 }, \ 9035 INTERNAL, \ 9036 { }, \ 9037 { { 0, (op) & BPF_FETCH ? old : update } }, \ 9038 .stack_depth = 40, \ 9039} 9040 /* BPF_ATOMIC | BPF_W: BPF_ADD */ 9041 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 9042 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 9043 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 9044 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 9045 /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */ 9046 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 9047 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 9048 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 9049 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 9050 /* BPF_ATOMIC | BPF_DW: BPF_ADD */ 9051 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 9052 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 9053 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 9054 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 9055 /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */ 9056 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 9057 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 9058 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 9059 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 9060 /* BPF_ATOMIC | BPF_W: BPF_AND */ 9061 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 9062 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 9063 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 9064 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 9065 /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */ 9066 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 9067 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 9068 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 9069 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 9070 /* BPF_ATOMIC | BPF_DW: BPF_AND */ 9071 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 9072 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 9073 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 9074 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 9075 /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */ 9076 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 9077 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 9078 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 9079 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 9080 /* BPF_ATOMIC | BPF_W: BPF_OR */ 9081 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 9082 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 9083 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 9084 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 9085 /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */ 9086 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 9087 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 9088 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 9089 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 9090 /* BPF_ATOMIC | BPF_DW: BPF_OR */ 9091 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 9092 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 9093 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 9094 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 9095 /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */ 9096 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 9097 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 9098 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 9099 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 9100 /* BPF_ATOMIC | BPF_W: BPF_XOR */ 9101 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 9102 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 9103 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 9104 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 9105 /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */ 9106 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 9107 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 9108 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 9109 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 9110 /* BPF_ATOMIC | BPF_DW: BPF_XOR */ 9111 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 9112 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 9113 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 9114 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 9115 /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */ 9116 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 9117 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 9118 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 9119 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 9120 /* BPF_ATOMIC | BPF_W: BPF_XCHG */ 9121 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 9122 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 9123 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 9124 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 9125 /* BPF_ATOMIC | BPF_DW: BPF_XCHG */ 9126 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 9127 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 9128 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 9129 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 9130#undef BPF_ATOMIC_POISON 9131#undef BPF_ATOMIC_OP_TEST1 9132#undef BPF_ATOMIC_OP_TEST2 9133#undef BPF_ATOMIC_OP_TEST3 9134#undef BPF_ATOMIC_OP_TEST4 9135 /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */ 9136 { 9137 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return", 9138 .u.insns_int = { 9139 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 9140 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 9141 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 9142 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 9143 BPF_EXIT_INSN(), 9144 }, 9145 INTERNAL, 9146 { }, 9147 { { 0, 0x01234567 } }, 9148 .stack_depth = 40, 9149 }, 9150 { 9151 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store", 9152 .u.insns_int = { 9153 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 9154 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 9155 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 9156 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 9157 BPF_LDX_MEM(BPF_W, R0, R10, -40), 9158 BPF_EXIT_INSN(), 9159 }, 9160 INTERNAL, 9161 { }, 9162 { { 0, 0x89abcdef } }, 9163 .stack_depth = 40, 9164 }, 9165 { 9166 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return", 9167 .u.insns_int = { 9168 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 9169 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210), 9170 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 9171 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 9172 BPF_EXIT_INSN(), 9173 }, 9174 INTERNAL, 9175 { }, 9176 { { 0, 0x01234567 } }, 9177 .stack_depth = 40, 9178 }, 9179 { 9180 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store", 9181 .u.insns_int = { 9182 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 9183 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210), 9184 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 9185 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 9186 BPF_LDX_MEM(BPF_W, R0, R10, -40), 9187 BPF_EXIT_INSN(), 9188 }, 9189 INTERNAL, 9190 { }, 9191 { { 0, 0x01234567 } }, 9192 .stack_depth = 40, 9193 }, 9194 { 9195 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects", 9196 .u.insns_int = { 9197 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 9198 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 9199 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 9200 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 9201 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 9202 BPF_ALU32_REG(BPF_MOV, R0, R3), 9203 BPF_EXIT_INSN(), 9204 }, 9205 INTERNAL, 9206 { }, 9207 { { 0, 0x89abcdef } }, 9208 .stack_depth = 40, 9209 }, 9210 /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */ 9211 { 9212 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return", 9213 .u.insns_int = { 9214 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 9215 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL), 9216 BPF_ALU64_REG(BPF_MOV, R0, R1), 9217 BPF_STX_MEM(BPF_DW, R10, R1, -40), 9218 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 9219 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 9220 BPF_ALU64_REG(BPF_SUB, R0, R1), 9221 BPF_EXIT_INSN(), 9222 }, 9223 INTERNAL, 9224 { }, 9225 { { 0, 0 } }, 9226 .stack_depth = 40, 9227 }, 9228 { 9229 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store", 9230 .u.insns_int = { 9231 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 9232 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL), 9233 BPF_ALU64_REG(BPF_MOV, R0, R1), 9234 BPF_STX_MEM(BPF_DW, R10, R0, -40), 9235 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 9236 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 9237 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 9238 BPF_ALU64_REG(BPF_SUB, R0, R2), 9239 BPF_EXIT_INSN(), 9240 }, 9241 INTERNAL, 9242 { }, 9243 { { 0, 0 } }, 9244 .stack_depth = 40, 9245 }, 9246 { 9247 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return", 9248 .u.insns_int = { 9249 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 9250 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL), 9251 BPF_ALU64_REG(BPF_MOV, R0, R1), 9252 BPF_ALU64_IMM(BPF_ADD, R0, 1), 9253 BPF_STX_MEM(BPF_DW, R10, R1, -40), 9254 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 9255 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 9256 BPF_ALU64_REG(BPF_SUB, R0, R1), 9257 BPF_EXIT_INSN(), 9258 }, 9259 INTERNAL, 9260 { }, 9261 { { 0, 0 } }, 9262 .stack_depth = 40, 9263 }, 9264 { 9265 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store", 9266 .u.insns_int = { 9267 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 9268 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL), 9269 BPF_ALU64_REG(BPF_MOV, R0, R1), 9270 BPF_ALU64_IMM(BPF_ADD, R0, 1), 9271 BPF_STX_MEM(BPF_DW, R10, R1, -40), 9272 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 9273 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 9274 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 9275 BPF_ALU64_REG(BPF_SUB, R0, R1), 9276 BPF_EXIT_INSN(), 9277 }, 9278 INTERNAL, 9279 { }, 9280 { { 0, 0 } }, 9281 .stack_depth = 40, 9282 }, 9283 { 9284 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects", 9285 .u.insns_int = { 9286 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 9287 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL), 9288 BPF_ALU64_REG(BPF_MOV, R0, R1), 9289 BPF_STX_MEM(BPF_DW, R10, R1, -40), 9290 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 9291 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 9292 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 9293 BPF_ALU64_REG(BPF_SUB, R0, R2), 9294 BPF_EXIT_INSN(), 9295 }, 9296 INTERNAL, 9297 { }, 9298 { { 0, 0 } }, 9299 .stack_depth = 40, 9300 }, 9301 /* BPF_JMP32 | BPF_JEQ | BPF_K */ 9302 { 9303 "JMP32_JEQ_K: Small immediate", 9304 .u.insns_int = { 9305 BPF_ALU32_IMM(BPF_MOV, R0, 123), 9306 BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1), 9307 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1), 9308 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9309 BPF_EXIT_INSN(), 9310 }, 9311 INTERNAL, 9312 { }, 9313 { { 0, 123 } } 9314 }, 9315 { 9316 "JMP32_JEQ_K: Large immediate", 9317 .u.insns_int = { 9318 BPF_ALU32_IMM(BPF_MOV, R0, 12345678), 9319 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1), 9320 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1), 9321 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9322 BPF_EXIT_INSN(), 9323 }, 9324 INTERNAL, 9325 { }, 9326 { { 0, 12345678 } } 9327 }, 9328 { 9329 "JMP32_JEQ_K: negative immediate", 9330 .u.insns_int = { 9331 BPF_ALU32_IMM(BPF_MOV, R0, -123), 9332 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1), 9333 BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1), 9334 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9335 BPF_EXIT_INSN(), 9336 }, 9337 INTERNAL, 9338 { }, 9339 { { 0, -123 } } 9340 }, 9341 /* BPF_JMP32 | BPF_JEQ | BPF_X */ 9342 { 9343 "JMP32_JEQ_X", 9344 .u.insns_int = { 9345 BPF_ALU32_IMM(BPF_MOV, R0, 1234), 9346 BPF_ALU32_IMM(BPF_MOV, R1, 4321), 9347 BPF_JMP32_REG(BPF_JEQ, R0, R1, 2), 9348 BPF_ALU32_IMM(BPF_MOV, R1, 1234), 9349 BPF_JMP32_REG(BPF_JEQ, R0, R1, 1), 9350 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9351 BPF_EXIT_INSN(), 9352 }, 9353 INTERNAL, 9354 { }, 9355 { { 0, 1234 } } 9356 }, 9357 /* BPF_JMP32 | BPF_JNE | BPF_K */ 9358 { 9359 "JMP32_JNE_K: Small immediate", 9360 .u.insns_int = { 9361 BPF_ALU32_IMM(BPF_MOV, R0, 123), 9362 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1), 9363 BPF_JMP32_IMM(BPF_JNE, R0, 321, 1), 9364 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9365 BPF_EXIT_INSN(), 9366 }, 9367 INTERNAL, 9368 { }, 9369 { { 0, 123 } } 9370 }, 9371 { 9372 "JMP32_JNE_K: Large immediate", 9373 .u.insns_int = { 9374 BPF_ALU32_IMM(BPF_MOV, R0, 12345678), 9375 BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1), 9376 BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1), 9377 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9378 BPF_EXIT_INSN(), 9379 }, 9380 INTERNAL, 9381 { }, 9382 { { 0, 12345678 } } 9383 }, 9384 { 9385 "JMP32_JNE_K: negative immediate", 9386 .u.insns_int = { 9387 BPF_ALU32_IMM(BPF_MOV, R0, -123), 9388 BPF_JMP32_IMM(BPF_JNE, R0, -123, 1), 9389 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1), 9390 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9391 BPF_EXIT_INSN(), 9392 }, 9393 INTERNAL, 9394 { }, 9395 { { 0, -123 } } 9396 }, 9397 /* BPF_JMP32 | BPF_JNE | BPF_X */ 9398 { 9399 "JMP32_JNE_X", 9400 .u.insns_int = { 9401 BPF_ALU32_IMM(BPF_MOV, R0, 1234), 9402 BPF_ALU32_IMM(BPF_MOV, R1, 1234), 9403 BPF_JMP32_REG(BPF_JNE, R0, R1, 2), 9404 BPF_ALU32_IMM(BPF_MOV, R1, 4321), 9405 BPF_JMP32_REG(BPF_JNE, R0, R1, 1), 9406 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9407 BPF_EXIT_INSN(), 9408 }, 9409 INTERNAL, 9410 { }, 9411 { { 0, 1234 } } 9412 }, 9413 /* BPF_JMP32 | BPF_JSET | BPF_K */ 9414 { 9415 "JMP32_JSET_K: Small immediate", 9416 .u.insns_int = { 9417 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9418 BPF_JMP32_IMM(BPF_JSET, R0, 2, 1), 9419 BPF_JMP32_IMM(BPF_JSET, R0, 3, 1), 9420 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9421 BPF_EXIT_INSN(), 9422 }, 9423 INTERNAL, 9424 { }, 9425 { { 0, 1 } } 9426 }, 9427 { 9428 "JMP32_JSET_K: Large immediate", 9429 .u.insns_int = { 9430 BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000), 9431 BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1), 9432 BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1), 9433 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9434 BPF_EXIT_INSN(), 9435 }, 9436 INTERNAL, 9437 { }, 9438 { { 0, 0x40000000 } } 9439 }, 9440 { 9441 "JMP32_JSET_K: negative immediate", 9442 .u.insns_int = { 9443 BPF_ALU32_IMM(BPF_MOV, R0, -123), 9444 BPF_JMP32_IMM(BPF_JSET, R0, -1, 1), 9445 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9446 BPF_EXIT_INSN(), 9447 }, 9448 INTERNAL, 9449 { }, 9450 { { 0, -123 } } 9451 }, 9452 /* BPF_JMP32 | BPF_JSET | BPF_X */ 9453 { 9454 "JMP32_JSET_X", 9455 .u.insns_int = { 9456 BPF_ALU32_IMM(BPF_MOV, R0, 8), 9457 BPF_ALU32_IMM(BPF_MOV, R1, 7), 9458 BPF_JMP32_REG(BPF_JSET, R0, R1, 2), 9459 BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2), 9460 BPF_JMP32_REG(BPF_JNE, R0, R1, 1), 9461 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9462 BPF_EXIT_INSN(), 9463 }, 9464 INTERNAL, 9465 { }, 9466 { { 0, 8 } } 9467 }, 9468 /* BPF_JMP32 | BPF_JGT | BPF_K */ 9469 { 9470 "JMP32_JGT_K: Small immediate", 9471 .u.insns_int = { 9472 BPF_ALU32_IMM(BPF_MOV, R0, 123), 9473 BPF_JMP32_IMM(BPF_JGT, R0, 123, 1), 9474 BPF_JMP32_IMM(BPF_JGT, R0, 122, 1), 9475 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9476 BPF_EXIT_INSN(), 9477 }, 9478 INTERNAL, 9479 { }, 9480 { { 0, 123 } } 9481 }, 9482 { 9483 "JMP32_JGT_K: Large immediate", 9484 .u.insns_int = { 9485 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 9486 BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1), 9487 BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1), 9488 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9489 BPF_EXIT_INSN(), 9490 }, 9491 INTERNAL, 9492 { }, 9493 { { 0, 0xfffffffe } } 9494 }, 9495 /* BPF_JMP32 | BPF_JGT | BPF_X */ 9496 { 9497 "JMP32_JGT_X", 9498 .u.insns_int = { 9499 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 9500 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 9501 BPF_JMP32_REG(BPF_JGT, R0, R1, 2), 9502 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 9503 BPF_JMP32_REG(BPF_JGT, R0, R1, 1), 9504 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9505 BPF_EXIT_INSN(), 9506 }, 9507 INTERNAL, 9508 { }, 9509 { { 0, 0xfffffffe } } 9510 }, 9511 /* BPF_JMP32 | BPF_JGE | BPF_K */ 9512 { 9513 "JMP32_JGE_K: Small immediate", 9514 .u.insns_int = { 9515 BPF_ALU32_IMM(BPF_MOV, R0, 123), 9516 BPF_JMP32_IMM(BPF_JGE, R0, 124, 1), 9517 BPF_JMP32_IMM(BPF_JGE, R0, 123, 1), 9518 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9519 BPF_EXIT_INSN(), 9520 }, 9521 INTERNAL, 9522 { }, 9523 { { 0, 123 } } 9524 }, 9525 { 9526 "JMP32_JGE_K: Large immediate", 9527 .u.insns_int = { 9528 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 9529 BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1), 9530 BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1), 9531 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9532 BPF_EXIT_INSN(), 9533 }, 9534 INTERNAL, 9535 { }, 9536 { { 0, 0xfffffffe } } 9537 }, 9538 /* BPF_JMP32 | BPF_JGE | BPF_X */ 9539 { 9540 "JMP32_JGE_X", 9541 .u.insns_int = { 9542 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 9543 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 9544 BPF_JMP32_REG(BPF_JGE, R0, R1, 2), 9545 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe), 9546 BPF_JMP32_REG(BPF_JGE, R0, R1, 1), 9547 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9548 BPF_EXIT_INSN(), 9549 }, 9550 INTERNAL, 9551 { }, 9552 { { 0, 0xfffffffe } } 9553 }, 9554 /* BPF_JMP32 | BPF_JLT | BPF_K */ 9555 { 9556 "JMP32_JLT_K: Small immediate", 9557 .u.insns_int = { 9558 BPF_ALU32_IMM(BPF_MOV, R0, 123), 9559 BPF_JMP32_IMM(BPF_JLT, R0, 123, 1), 9560 BPF_JMP32_IMM(BPF_JLT, R0, 124, 1), 9561 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9562 BPF_EXIT_INSN(), 9563 }, 9564 INTERNAL, 9565 { }, 9566 { { 0, 123 } } 9567 }, 9568 { 9569 "JMP32_JLT_K: Large immediate", 9570 .u.insns_int = { 9571 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 9572 BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1), 9573 BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1), 9574 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9575 BPF_EXIT_INSN(), 9576 }, 9577 INTERNAL, 9578 { }, 9579 { { 0, 0xfffffffe } } 9580 }, 9581 /* BPF_JMP32 | BPF_JLT | BPF_X */ 9582 { 9583 "JMP32_JLT_X", 9584 .u.insns_int = { 9585 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 9586 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 9587 BPF_JMP32_REG(BPF_JLT, R0, R1, 2), 9588 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 9589 BPF_JMP32_REG(BPF_JLT, R0, R1, 1), 9590 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9591 BPF_EXIT_INSN(), 9592 }, 9593 INTERNAL, 9594 { }, 9595 { { 0, 0xfffffffe } } 9596 }, 9597 /* BPF_JMP32 | BPF_JLE | BPF_K */ 9598 { 9599 "JMP32_JLE_K: Small immediate", 9600 .u.insns_int = { 9601 BPF_ALU32_IMM(BPF_MOV, R0, 123), 9602 BPF_JMP32_IMM(BPF_JLE, R0, 122, 1), 9603 BPF_JMP32_IMM(BPF_JLE, R0, 123, 1), 9604 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9605 BPF_EXIT_INSN(), 9606 }, 9607 INTERNAL, 9608 { }, 9609 { { 0, 123 } } 9610 }, 9611 { 9612 "JMP32_JLE_K: Large immediate", 9613 .u.insns_int = { 9614 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 9615 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1), 9616 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1), 9617 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9618 BPF_EXIT_INSN(), 9619 }, 9620 INTERNAL, 9621 { }, 9622 { { 0, 0xfffffffe } } 9623 }, 9624 /* BPF_JMP32 | BPF_JLE | BPF_X */ 9625 { 9626 "JMP32_JLE_X", 9627 .u.insns_int = { 9628 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 9629 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 9630 BPF_JMP32_REG(BPF_JLE, R0, R1, 2), 9631 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe), 9632 BPF_JMP32_REG(BPF_JLE, R0, R1, 1), 9633 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9634 BPF_EXIT_INSN(), 9635 }, 9636 INTERNAL, 9637 { }, 9638 { { 0, 0xfffffffe } } 9639 }, 9640 /* BPF_JMP32 | BPF_JSGT | BPF_K */ 9641 { 9642 "JMP32_JSGT_K: Small immediate", 9643 .u.insns_int = { 9644 BPF_ALU32_IMM(BPF_MOV, R0, -123), 9645 BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1), 9646 BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1), 9647 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9648 BPF_EXIT_INSN(), 9649 }, 9650 INTERNAL, 9651 { }, 9652 { { 0, -123 } } 9653 }, 9654 { 9655 "JMP32_JSGT_K: Large immediate", 9656 .u.insns_int = { 9657 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 9658 BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1), 9659 BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1), 9660 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9661 BPF_EXIT_INSN(), 9662 }, 9663 INTERNAL, 9664 { }, 9665 { { 0, -12345678 } } 9666 }, 9667 /* BPF_JMP32 | BPF_JSGT | BPF_X */ 9668 { 9669 "JMP32_JSGT_X", 9670 .u.insns_int = { 9671 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 9672 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 9673 BPF_JMP32_REG(BPF_JSGT, R0, R1, 2), 9674 BPF_ALU32_IMM(BPF_MOV, R1, -12345679), 9675 BPF_JMP32_REG(BPF_JSGT, R0, R1, 1), 9676 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9677 BPF_EXIT_INSN(), 9678 }, 9679 INTERNAL, 9680 { }, 9681 { { 0, -12345678 } } 9682 }, 9683 /* BPF_JMP32 | BPF_JSGE | BPF_K */ 9684 { 9685 "JMP32_JSGE_K: Small immediate", 9686 .u.insns_int = { 9687 BPF_ALU32_IMM(BPF_MOV, R0, -123), 9688 BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1), 9689 BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1), 9690 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9691 BPF_EXIT_INSN(), 9692 }, 9693 INTERNAL, 9694 { }, 9695 { { 0, -123 } } 9696 }, 9697 { 9698 "JMP32_JSGE_K: Large immediate", 9699 .u.insns_int = { 9700 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 9701 BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1), 9702 BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1), 9703 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9704 BPF_EXIT_INSN(), 9705 }, 9706 INTERNAL, 9707 { }, 9708 { { 0, -12345678 } } 9709 }, 9710 /* BPF_JMP32 | BPF_JSGE | BPF_X */ 9711 { 9712 "JMP32_JSGE_X", 9713 .u.insns_int = { 9714 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 9715 BPF_ALU32_IMM(BPF_MOV, R1, -12345677), 9716 BPF_JMP32_REG(BPF_JSGE, R0, R1, 2), 9717 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 9718 BPF_JMP32_REG(BPF_JSGE, R0, R1, 1), 9719 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9720 BPF_EXIT_INSN(), 9721 }, 9722 INTERNAL, 9723 { }, 9724 { { 0, -12345678 } } 9725 }, 9726 /* BPF_JMP32 | BPF_JSLT | BPF_K */ 9727 { 9728 "JMP32_JSLT_K: Small immediate", 9729 .u.insns_int = { 9730 BPF_ALU32_IMM(BPF_MOV, R0, -123), 9731 BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1), 9732 BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1), 9733 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9734 BPF_EXIT_INSN(), 9735 }, 9736 INTERNAL, 9737 { }, 9738 { { 0, -123 } } 9739 }, 9740 { 9741 "JMP32_JSLT_K: Large immediate", 9742 .u.insns_int = { 9743 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 9744 BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1), 9745 BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1), 9746 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9747 BPF_EXIT_INSN(), 9748 }, 9749 INTERNAL, 9750 { }, 9751 { { 0, -12345678 } } 9752 }, 9753 /* BPF_JMP32 | BPF_JSLT | BPF_X */ 9754 { 9755 "JMP32_JSLT_X", 9756 .u.insns_int = { 9757 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 9758 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 9759 BPF_JMP32_REG(BPF_JSLT, R0, R1, 2), 9760 BPF_ALU32_IMM(BPF_MOV, R1, -12345677), 9761 BPF_JMP32_REG(BPF_JSLT, R0, R1, 1), 9762 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9763 BPF_EXIT_INSN(), 9764 }, 9765 INTERNAL, 9766 { }, 9767 { { 0, -12345678 } } 9768 }, 9769 /* BPF_JMP32 | BPF_JSLE | BPF_K */ 9770 { 9771 "JMP32_JSLE_K: Small immediate", 9772 .u.insns_int = { 9773 BPF_ALU32_IMM(BPF_MOV, R0, -123), 9774 BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1), 9775 BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1), 9776 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9777 BPF_EXIT_INSN(), 9778 }, 9779 INTERNAL, 9780 { }, 9781 { { 0, -123 } } 9782 }, 9783 { 9784 "JMP32_JSLE_K: Large immediate", 9785 .u.insns_int = { 9786 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 9787 BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1), 9788 BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1), 9789 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9790 BPF_EXIT_INSN(), 9791 }, 9792 INTERNAL, 9793 { }, 9794 { { 0, -12345678 } } 9795 }, 9796 /* BPF_JMP32 | BPF_JSLE | BPF_K */ 9797 { 9798 "JMP32_JSLE_X", 9799 .u.insns_int = { 9800 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 9801 BPF_ALU32_IMM(BPF_MOV, R1, -12345679), 9802 BPF_JMP32_REG(BPF_JSLE, R0, R1, 2), 9803 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 9804 BPF_JMP32_REG(BPF_JSLE, R0, R1, 1), 9805 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9806 BPF_EXIT_INSN(), 9807 }, 9808 INTERNAL, 9809 { }, 9810 { { 0, -12345678 } } 9811 }, 9812 /* BPF_JMP | BPF_EXIT */ 9813 { 9814 "JMP_EXIT", 9815 .u.insns_int = { 9816 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711), 9817 BPF_EXIT_INSN(), 9818 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712), 9819 }, 9820 INTERNAL, 9821 { }, 9822 { { 0, 0x4711 } }, 9823 }, 9824 /* BPF_JMP | BPF_JA */ 9825 { 9826 "JMP_JA: Unconditional jump: if (true) return 1", 9827 .u.insns_int = { 9828 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9829 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 9830 BPF_EXIT_INSN(), 9831 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9832 BPF_EXIT_INSN(), 9833 }, 9834 INTERNAL, 9835 { }, 9836 { { 0, 1 } }, 9837 }, 9838 /* BPF_JMP32 | BPF_JA */ 9839 { 9840 "JMP32_JA: Unconditional jump: if (true) return 1", 9841 .u.insns_int = { 9842 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9843 BPF_JMP32_IMM(BPF_JA, 0, 1, 0), 9844 BPF_EXIT_INSN(), 9845 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9846 BPF_EXIT_INSN(), 9847 }, 9848 INTERNAL, 9849 { }, 9850 { { 0, 1 } }, 9851 }, 9852 /* BPF_JMP | BPF_JSLT | BPF_K */ 9853 { 9854 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1", 9855 .u.insns_int = { 9856 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9857 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL), 9858 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1), 9859 BPF_EXIT_INSN(), 9860 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9861 BPF_EXIT_INSN(), 9862 }, 9863 INTERNAL, 9864 { }, 9865 { { 0, 1 } }, 9866 }, 9867 { 9868 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0", 9869 .u.insns_int = { 9870 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9871 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 9872 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1), 9873 BPF_EXIT_INSN(), 9874 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9875 BPF_EXIT_INSN(), 9876 }, 9877 INTERNAL, 9878 { }, 9879 { { 0, 1 } }, 9880 }, 9881 /* BPF_JMP | BPF_JSGT | BPF_K */ 9882 { 9883 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1", 9884 .u.insns_int = { 9885 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9886 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 9887 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1), 9888 BPF_EXIT_INSN(), 9889 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9890 BPF_EXIT_INSN(), 9891 }, 9892 INTERNAL, 9893 { }, 9894 { { 0, 1 } }, 9895 }, 9896 { 9897 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0", 9898 .u.insns_int = { 9899 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9900 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 9901 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1), 9902 BPF_EXIT_INSN(), 9903 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9904 BPF_EXIT_INSN(), 9905 }, 9906 INTERNAL, 9907 { }, 9908 { { 0, 1 } }, 9909 }, 9910 /* BPF_JMP | BPF_JSLE | BPF_K */ 9911 { 9912 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1", 9913 .u.insns_int = { 9914 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9915 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL), 9916 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1), 9917 BPF_EXIT_INSN(), 9918 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9919 BPF_EXIT_INSN(), 9920 }, 9921 INTERNAL, 9922 { }, 9923 { { 0, 1 } }, 9924 }, 9925 { 9926 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1", 9927 .u.insns_int = { 9928 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9929 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 9930 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1), 9931 BPF_EXIT_INSN(), 9932 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9933 BPF_EXIT_INSN(), 9934 }, 9935 INTERNAL, 9936 { }, 9937 { { 0, 1 } }, 9938 }, 9939 { 9940 "JMP_JSLE_K: Signed jump: value walk 1", 9941 .u.insns_int = { 9942 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9943 BPF_LD_IMM64(R1, 3), 9944 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6), 9945 BPF_ALU64_IMM(BPF_SUB, R1, 1), 9946 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4), 9947 BPF_ALU64_IMM(BPF_SUB, R1, 1), 9948 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2), 9949 BPF_ALU64_IMM(BPF_SUB, R1, 1), 9950 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1), 9951 BPF_EXIT_INSN(), /* bad exit */ 9952 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 9953 BPF_EXIT_INSN(), 9954 }, 9955 INTERNAL, 9956 { }, 9957 { { 0, 1 } }, 9958 }, 9959 { 9960 "JMP_JSLE_K: Signed jump: value walk 2", 9961 .u.insns_int = { 9962 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9963 BPF_LD_IMM64(R1, 3), 9964 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4), 9965 BPF_ALU64_IMM(BPF_SUB, R1, 2), 9966 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2), 9967 BPF_ALU64_IMM(BPF_SUB, R1, 2), 9968 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1), 9969 BPF_EXIT_INSN(), /* bad exit */ 9970 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 9971 BPF_EXIT_INSN(), 9972 }, 9973 INTERNAL, 9974 { }, 9975 { { 0, 1 } }, 9976 }, 9977 /* BPF_JMP | BPF_JSGE | BPF_K */ 9978 { 9979 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1", 9980 .u.insns_int = { 9981 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9982 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 9983 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1), 9984 BPF_EXIT_INSN(), 9985 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9986 BPF_EXIT_INSN(), 9987 }, 9988 INTERNAL, 9989 { }, 9990 { { 0, 1 } }, 9991 }, 9992 { 9993 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1", 9994 .u.insns_int = { 9995 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9996 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 9997 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1), 9998 BPF_EXIT_INSN(), 9999 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10000 BPF_EXIT_INSN(), 10001 }, 10002 INTERNAL, 10003 { }, 10004 { { 0, 1 } }, 10005 }, 10006 { 10007 "JMP_JSGE_K: Signed jump: value walk 1", 10008 .u.insns_int = { 10009 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10010 BPF_LD_IMM64(R1, -3), 10011 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6), 10012 BPF_ALU64_IMM(BPF_ADD, R1, 1), 10013 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4), 10014 BPF_ALU64_IMM(BPF_ADD, R1, 1), 10015 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2), 10016 BPF_ALU64_IMM(BPF_ADD, R1, 1), 10017 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1), 10018 BPF_EXIT_INSN(), /* bad exit */ 10019 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 10020 BPF_EXIT_INSN(), 10021 }, 10022 INTERNAL, 10023 { }, 10024 { { 0, 1 } }, 10025 }, 10026 { 10027 "JMP_JSGE_K: Signed jump: value walk 2", 10028 .u.insns_int = { 10029 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10030 BPF_LD_IMM64(R1, -3), 10031 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4), 10032 BPF_ALU64_IMM(BPF_ADD, R1, 2), 10033 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2), 10034 BPF_ALU64_IMM(BPF_ADD, R1, 2), 10035 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1), 10036 BPF_EXIT_INSN(), /* bad exit */ 10037 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 10038 BPF_EXIT_INSN(), 10039 }, 10040 INTERNAL, 10041 { }, 10042 { { 0, 1 } }, 10043 }, 10044 /* BPF_JMP | BPF_JGT | BPF_K */ 10045 { 10046 "JMP_JGT_K: if (3 > 2) return 1", 10047 .u.insns_int = { 10048 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10049 BPF_LD_IMM64(R1, 3), 10050 BPF_JMP_IMM(BPF_JGT, R1, 2, 1), 10051 BPF_EXIT_INSN(), 10052 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10053 BPF_EXIT_INSN(), 10054 }, 10055 INTERNAL, 10056 { }, 10057 { { 0, 1 } }, 10058 }, 10059 { 10060 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1", 10061 .u.insns_int = { 10062 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10063 BPF_LD_IMM64(R1, -1), 10064 BPF_JMP_IMM(BPF_JGT, R1, 1, 1), 10065 BPF_EXIT_INSN(), 10066 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10067 BPF_EXIT_INSN(), 10068 }, 10069 INTERNAL, 10070 { }, 10071 { { 0, 1 } }, 10072 }, 10073 /* BPF_JMP | BPF_JLT | BPF_K */ 10074 { 10075 "JMP_JLT_K: if (2 < 3) return 1", 10076 .u.insns_int = { 10077 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10078 BPF_LD_IMM64(R1, 2), 10079 BPF_JMP_IMM(BPF_JLT, R1, 3, 1), 10080 BPF_EXIT_INSN(), 10081 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10082 BPF_EXIT_INSN(), 10083 }, 10084 INTERNAL, 10085 { }, 10086 { { 0, 1 } }, 10087 }, 10088 { 10089 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1", 10090 .u.insns_int = { 10091 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10092 BPF_LD_IMM64(R1, 1), 10093 BPF_JMP_IMM(BPF_JLT, R1, -1, 1), 10094 BPF_EXIT_INSN(), 10095 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10096 BPF_EXIT_INSN(), 10097 }, 10098 INTERNAL, 10099 { }, 10100 { { 0, 1 } }, 10101 }, 10102 /* BPF_JMP | BPF_JGE | BPF_K */ 10103 { 10104 "JMP_JGE_K: if (3 >= 2) return 1", 10105 .u.insns_int = { 10106 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10107 BPF_LD_IMM64(R1, 3), 10108 BPF_JMP_IMM(BPF_JGE, R1, 2, 1), 10109 BPF_EXIT_INSN(), 10110 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10111 BPF_EXIT_INSN(), 10112 }, 10113 INTERNAL, 10114 { }, 10115 { { 0, 1 } }, 10116 }, 10117 /* BPF_JMP | BPF_JLE | BPF_K */ 10118 { 10119 "JMP_JLE_K: if (2 <= 3) return 1", 10120 .u.insns_int = { 10121 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10122 BPF_LD_IMM64(R1, 2), 10123 BPF_JMP_IMM(BPF_JLE, R1, 3, 1), 10124 BPF_EXIT_INSN(), 10125 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10126 BPF_EXIT_INSN(), 10127 }, 10128 INTERNAL, 10129 { }, 10130 { { 0, 1 } }, 10131 }, 10132 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */ 10133 { 10134 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)", 10135 .u.insns_int = { 10136 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */ 10137 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */ 10138 BPF_EXIT_INSN(), 10139 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */ 10140 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */ 10141 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */ 10142 BPF_EXIT_INSN(), 10143 }, 10144 INTERNAL, 10145 { }, 10146 { { 0, 1 } }, 10147 }, 10148 { 10149 "JMP_JGE_K: if (3 >= 3) return 1", 10150 .u.insns_int = { 10151 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10152 BPF_LD_IMM64(R1, 3), 10153 BPF_JMP_IMM(BPF_JGE, R1, 3, 1), 10154 BPF_EXIT_INSN(), 10155 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10156 BPF_EXIT_INSN(), 10157 }, 10158 INTERNAL, 10159 { }, 10160 { { 0, 1 } }, 10161 }, 10162 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */ 10163 { 10164 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)", 10165 .u.insns_int = { 10166 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */ 10167 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */ 10168 BPF_EXIT_INSN(), 10169 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */ 10170 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */ 10171 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */ 10172 BPF_EXIT_INSN(), 10173 }, 10174 INTERNAL, 10175 { }, 10176 { { 0, 1 } }, 10177 }, 10178 { 10179 "JMP_JLE_K: if (3 <= 3) return 1", 10180 .u.insns_int = { 10181 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10182 BPF_LD_IMM64(R1, 3), 10183 BPF_JMP_IMM(BPF_JLE, R1, 3, 1), 10184 BPF_EXIT_INSN(), 10185 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10186 BPF_EXIT_INSN(), 10187 }, 10188 INTERNAL, 10189 { }, 10190 { { 0, 1 } }, 10191 }, 10192 /* BPF_JMP | BPF_JNE | BPF_K */ 10193 { 10194 "JMP_JNE_K: if (3 != 2) return 1", 10195 .u.insns_int = { 10196 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10197 BPF_LD_IMM64(R1, 3), 10198 BPF_JMP_IMM(BPF_JNE, R1, 2, 1), 10199 BPF_EXIT_INSN(), 10200 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10201 BPF_EXIT_INSN(), 10202 }, 10203 INTERNAL, 10204 { }, 10205 { { 0, 1 } }, 10206 }, 10207 /* BPF_JMP | BPF_JEQ | BPF_K */ 10208 { 10209 "JMP_JEQ_K: if (3 == 3) return 1", 10210 .u.insns_int = { 10211 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10212 BPF_LD_IMM64(R1, 3), 10213 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1), 10214 BPF_EXIT_INSN(), 10215 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10216 BPF_EXIT_INSN(), 10217 }, 10218 INTERNAL, 10219 { }, 10220 { { 0, 1 } }, 10221 }, 10222 /* BPF_JMP | BPF_JSET | BPF_K */ 10223 { 10224 "JMP_JSET_K: if (0x3 & 0x2) return 1", 10225 .u.insns_int = { 10226 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10227 BPF_LD_IMM64(R1, 3), 10228 BPF_JMP_IMM(BPF_JSET, R1, 2, 1), 10229 BPF_EXIT_INSN(), 10230 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10231 BPF_EXIT_INSN(), 10232 }, 10233 INTERNAL, 10234 { }, 10235 { { 0, 1 } }, 10236 }, 10237 { 10238 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1", 10239 .u.insns_int = { 10240 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10241 BPF_LD_IMM64(R1, 3), 10242 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1), 10243 BPF_EXIT_INSN(), 10244 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10245 BPF_EXIT_INSN(), 10246 }, 10247 INTERNAL, 10248 { }, 10249 { { 0, 1 } }, 10250 }, 10251 /* BPF_JMP | BPF_JSGT | BPF_X */ 10252 { 10253 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1", 10254 .u.insns_int = { 10255 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10256 BPF_LD_IMM64(R1, -1), 10257 BPF_LD_IMM64(R2, -2), 10258 BPF_JMP_REG(BPF_JSGT, R1, R2, 1), 10259 BPF_EXIT_INSN(), 10260 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10261 BPF_EXIT_INSN(), 10262 }, 10263 INTERNAL, 10264 { }, 10265 { { 0, 1 } }, 10266 }, 10267 { 10268 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0", 10269 .u.insns_int = { 10270 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10271 BPF_LD_IMM64(R1, -1), 10272 BPF_LD_IMM64(R2, -1), 10273 BPF_JMP_REG(BPF_JSGT, R1, R2, 1), 10274 BPF_EXIT_INSN(), 10275 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10276 BPF_EXIT_INSN(), 10277 }, 10278 INTERNAL, 10279 { }, 10280 { { 0, 1 } }, 10281 }, 10282 /* BPF_JMP | BPF_JSLT | BPF_X */ 10283 { 10284 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1", 10285 .u.insns_int = { 10286 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10287 BPF_LD_IMM64(R1, -1), 10288 BPF_LD_IMM64(R2, -2), 10289 BPF_JMP_REG(BPF_JSLT, R2, R1, 1), 10290 BPF_EXIT_INSN(), 10291 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10292 BPF_EXIT_INSN(), 10293 }, 10294 INTERNAL, 10295 { }, 10296 { { 0, 1 } }, 10297 }, 10298 { 10299 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0", 10300 .u.insns_int = { 10301 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10302 BPF_LD_IMM64(R1, -1), 10303 BPF_LD_IMM64(R2, -1), 10304 BPF_JMP_REG(BPF_JSLT, R1, R2, 1), 10305 BPF_EXIT_INSN(), 10306 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10307 BPF_EXIT_INSN(), 10308 }, 10309 INTERNAL, 10310 { }, 10311 { { 0, 1 } }, 10312 }, 10313 /* BPF_JMP | BPF_JSGE | BPF_X */ 10314 { 10315 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1", 10316 .u.insns_int = { 10317 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10318 BPF_LD_IMM64(R1, -1), 10319 BPF_LD_IMM64(R2, -2), 10320 BPF_JMP_REG(BPF_JSGE, R1, R2, 1), 10321 BPF_EXIT_INSN(), 10322 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10323 BPF_EXIT_INSN(), 10324 }, 10325 INTERNAL, 10326 { }, 10327 { { 0, 1 } }, 10328 }, 10329 { 10330 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1", 10331 .u.insns_int = { 10332 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10333 BPF_LD_IMM64(R1, -1), 10334 BPF_LD_IMM64(R2, -1), 10335 BPF_JMP_REG(BPF_JSGE, R1, R2, 1), 10336 BPF_EXIT_INSN(), 10337 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10338 BPF_EXIT_INSN(), 10339 }, 10340 INTERNAL, 10341 { }, 10342 { { 0, 1 } }, 10343 }, 10344 /* BPF_JMP | BPF_JSLE | BPF_X */ 10345 { 10346 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1", 10347 .u.insns_int = { 10348 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10349 BPF_LD_IMM64(R1, -1), 10350 BPF_LD_IMM64(R2, -2), 10351 BPF_JMP_REG(BPF_JSLE, R2, R1, 1), 10352 BPF_EXIT_INSN(), 10353 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10354 BPF_EXIT_INSN(), 10355 }, 10356 INTERNAL, 10357 { }, 10358 { { 0, 1 } }, 10359 }, 10360 { 10361 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1", 10362 .u.insns_int = { 10363 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10364 BPF_LD_IMM64(R1, -1), 10365 BPF_LD_IMM64(R2, -1), 10366 BPF_JMP_REG(BPF_JSLE, R1, R2, 1), 10367 BPF_EXIT_INSN(), 10368 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10369 BPF_EXIT_INSN(), 10370 }, 10371 INTERNAL, 10372 { }, 10373 { { 0, 1 } }, 10374 }, 10375 /* BPF_JMP | BPF_JGT | BPF_X */ 10376 { 10377 "JMP_JGT_X: if (3 > 2) return 1", 10378 .u.insns_int = { 10379 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10380 BPF_LD_IMM64(R1, 3), 10381 BPF_LD_IMM64(R2, 2), 10382 BPF_JMP_REG(BPF_JGT, R1, R2, 1), 10383 BPF_EXIT_INSN(), 10384 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10385 BPF_EXIT_INSN(), 10386 }, 10387 INTERNAL, 10388 { }, 10389 { { 0, 1 } }, 10390 }, 10391 { 10392 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1", 10393 .u.insns_int = { 10394 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10395 BPF_LD_IMM64(R1, -1), 10396 BPF_LD_IMM64(R2, 1), 10397 BPF_JMP_REG(BPF_JGT, R1, R2, 1), 10398 BPF_EXIT_INSN(), 10399 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10400 BPF_EXIT_INSN(), 10401 }, 10402 INTERNAL, 10403 { }, 10404 { { 0, 1 } }, 10405 }, 10406 /* BPF_JMP | BPF_JLT | BPF_X */ 10407 { 10408 "JMP_JLT_X: if (2 < 3) return 1", 10409 .u.insns_int = { 10410 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10411 BPF_LD_IMM64(R1, 3), 10412 BPF_LD_IMM64(R2, 2), 10413 BPF_JMP_REG(BPF_JLT, R2, R1, 1), 10414 BPF_EXIT_INSN(), 10415 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10416 BPF_EXIT_INSN(), 10417 }, 10418 INTERNAL, 10419 { }, 10420 { { 0, 1 } }, 10421 }, 10422 { 10423 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1", 10424 .u.insns_int = { 10425 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10426 BPF_LD_IMM64(R1, -1), 10427 BPF_LD_IMM64(R2, 1), 10428 BPF_JMP_REG(BPF_JLT, R2, R1, 1), 10429 BPF_EXIT_INSN(), 10430 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10431 BPF_EXIT_INSN(), 10432 }, 10433 INTERNAL, 10434 { }, 10435 { { 0, 1 } }, 10436 }, 10437 /* BPF_JMP | BPF_JGE | BPF_X */ 10438 { 10439 "JMP_JGE_X: if (3 >= 2) return 1", 10440 .u.insns_int = { 10441 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10442 BPF_LD_IMM64(R1, 3), 10443 BPF_LD_IMM64(R2, 2), 10444 BPF_JMP_REG(BPF_JGE, R1, R2, 1), 10445 BPF_EXIT_INSN(), 10446 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10447 BPF_EXIT_INSN(), 10448 }, 10449 INTERNAL, 10450 { }, 10451 { { 0, 1 } }, 10452 }, 10453 { 10454 "JMP_JGE_X: if (3 >= 3) return 1", 10455 .u.insns_int = { 10456 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10457 BPF_LD_IMM64(R1, 3), 10458 BPF_LD_IMM64(R2, 3), 10459 BPF_JMP_REG(BPF_JGE, R1, R2, 1), 10460 BPF_EXIT_INSN(), 10461 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10462 BPF_EXIT_INSN(), 10463 }, 10464 INTERNAL, 10465 { }, 10466 { { 0, 1 } }, 10467 }, 10468 /* BPF_JMP | BPF_JLE | BPF_X */ 10469 { 10470 "JMP_JLE_X: if (2 <= 3) return 1", 10471 .u.insns_int = { 10472 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10473 BPF_LD_IMM64(R1, 3), 10474 BPF_LD_IMM64(R2, 2), 10475 BPF_JMP_REG(BPF_JLE, R2, R1, 1), 10476 BPF_EXIT_INSN(), 10477 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10478 BPF_EXIT_INSN(), 10479 }, 10480 INTERNAL, 10481 { }, 10482 { { 0, 1 } }, 10483 }, 10484 { 10485 "JMP_JLE_X: if (3 <= 3) return 1", 10486 .u.insns_int = { 10487 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10488 BPF_LD_IMM64(R1, 3), 10489 BPF_LD_IMM64(R2, 3), 10490 BPF_JMP_REG(BPF_JLE, R1, R2, 1), 10491 BPF_EXIT_INSN(), 10492 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10493 BPF_EXIT_INSN(), 10494 }, 10495 INTERNAL, 10496 { }, 10497 { { 0, 1 } }, 10498 }, 10499 { 10500 /* Mainly testing JIT + imm64 here. */ 10501 "JMP_JGE_X: ldimm64 test 1", 10502 .u.insns_int = { 10503 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10504 BPF_LD_IMM64(R1, 3), 10505 BPF_LD_IMM64(R2, 2), 10506 BPF_JMP_REG(BPF_JGE, R1, R2, 2), 10507 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 10508 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 10509 BPF_EXIT_INSN(), 10510 }, 10511 INTERNAL, 10512 { }, 10513 { { 0, 0xeeeeeeeeU } }, 10514 }, 10515 { 10516 "JMP_JGE_X: ldimm64 test 2", 10517 .u.insns_int = { 10518 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10519 BPF_LD_IMM64(R1, 3), 10520 BPF_LD_IMM64(R2, 2), 10521 BPF_JMP_REG(BPF_JGE, R1, R2, 0), 10522 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 10523 BPF_EXIT_INSN(), 10524 }, 10525 INTERNAL, 10526 { }, 10527 { { 0, 0xffffffffU } }, 10528 }, 10529 { 10530 "JMP_JGE_X: ldimm64 test 3", 10531 .u.insns_int = { 10532 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10533 BPF_LD_IMM64(R1, 3), 10534 BPF_LD_IMM64(R2, 2), 10535 BPF_JMP_REG(BPF_JGE, R1, R2, 4), 10536 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 10537 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 10538 BPF_EXIT_INSN(), 10539 }, 10540 INTERNAL, 10541 { }, 10542 { { 0, 1 } }, 10543 }, 10544 { 10545 "JMP_JLE_X: ldimm64 test 1", 10546 .u.insns_int = { 10547 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10548 BPF_LD_IMM64(R1, 3), 10549 BPF_LD_IMM64(R2, 2), 10550 BPF_JMP_REG(BPF_JLE, R2, R1, 2), 10551 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 10552 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 10553 BPF_EXIT_INSN(), 10554 }, 10555 INTERNAL, 10556 { }, 10557 { { 0, 0xeeeeeeeeU } }, 10558 }, 10559 { 10560 "JMP_JLE_X: ldimm64 test 2", 10561 .u.insns_int = { 10562 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10563 BPF_LD_IMM64(R1, 3), 10564 BPF_LD_IMM64(R2, 2), 10565 BPF_JMP_REG(BPF_JLE, R2, R1, 0), 10566 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 10567 BPF_EXIT_INSN(), 10568 }, 10569 INTERNAL, 10570 { }, 10571 { { 0, 0xffffffffU } }, 10572 }, 10573 { 10574 "JMP_JLE_X: ldimm64 test 3", 10575 .u.insns_int = { 10576 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10577 BPF_LD_IMM64(R1, 3), 10578 BPF_LD_IMM64(R2, 2), 10579 BPF_JMP_REG(BPF_JLE, R2, R1, 4), 10580 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 10581 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 10582 BPF_EXIT_INSN(), 10583 }, 10584 INTERNAL, 10585 { }, 10586 { { 0, 1 } }, 10587 }, 10588 /* BPF_JMP | BPF_JNE | BPF_X */ 10589 { 10590 "JMP_JNE_X: if (3 != 2) return 1", 10591 .u.insns_int = { 10592 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10593 BPF_LD_IMM64(R1, 3), 10594 BPF_LD_IMM64(R2, 2), 10595 BPF_JMP_REG(BPF_JNE, R1, R2, 1), 10596 BPF_EXIT_INSN(), 10597 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10598 BPF_EXIT_INSN(), 10599 }, 10600 INTERNAL, 10601 { }, 10602 { { 0, 1 } }, 10603 }, 10604 /* BPF_JMP | BPF_JEQ | BPF_X */ 10605 { 10606 "JMP_JEQ_X: if (3 == 3) return 1", 10607 .u.insns_int = { 10608 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10609 BPF_LD_IMM64(R1, 3), 10610 BPF_LD_IMM64(R2, 3), 10611 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 10612 BPF_EXIT_INSN(), 10613 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10614 BPF_EXIT_INSN(), 10615 }, 10616 INTERNAL, 10617 { }, 10618 { { 0, 1 } }, 10619 }, 10620 /* BPF_JMP | BPF_JSET | BPF_X */ 10621 { 10622 "JMP_JSET_X: if (0x3 & 0x2) return 1", 10623 .u.insns_int = { 10624 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10625 BPF_LD_IMM64(R1, 3), 10626 BPF_LD_IMM64(R2, 2), 10627 BPF_JMP_REG(BPF_JSET, R1, R2, 1), 10628 BPF_EXIT_INSN(), 10629 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10630 BPF_EXIT_INSN(), 10631 }, 10632 INTERNAL, 10633 { }, 10634 { { 0, 1 } }, 10635 }, 10636 { 10637 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1", 10638 .u.insns_int = { 10639 BPF_ALU32_IMM(BPF_MOV, R0, 0), 10640 BPF_LD_IMM64(R1, 3), 10641 BPF_LD_IMM64(R2, 0xffffffff), 10642 BPF_JMP_REG(BPF_JSET, R1, R2, 1), 10643 BPF_EXIT_INSN(), 10644 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10645 BPF_EXIT_INSN(), 10646 }, 10647 INTERNAL, 10648 { }, 10649 { { 0, 1 } }, 10650 }, 10651 { 10652 "JMP_JA: Jump, gap, jump, ...", 10653 { }, 10654 CLASSIC | FLAG_NO_DATA, 10655 { }, 10656 { { 0, 0xababcbac } }, 10657 .fill_helper = bpf_fill_ja, 10658 }, 10659 { /* Mainly checking JIT here. */ 10660 "BPF_MAXINSNS: Maximum possible literals", 10661 { }, 10662 CLASSIC | FLAG_NO_DATA, 10663 { }, 10664 { { 0, 0xffffffff } }, 10665 .fill_helper = bpf_fill_maxinsns1, 10666 }, 10667 { /* Mainly checking JIT here. */ 10668 "BPF_MAXINSNS: Single literal", 10669 { }, 10670 CLASSIC | FLAG_NO_DATA, 10671 { }, 10672 { { 0, 0xfefefefe } }, 10673 .fill_helper = bpf_fill_maxinsns2, 10674 }, 10675 { /* Mainly checking JIT here. */ 10676 "BPF_MAXINSNS: Run/add until end", 10677 { }, 10678 CLASSIC | FLAG_NO_DATA, 10679 { }, 10680 { { 0, 0x947bf368 } }, 10681 .fill_helper = bpf_fill_maxinsns3, 10682 }, 10683 { 10684 "BPF_MAXINSNS: Too many instructions", 10685 { }, 10686 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 10687 { }, 10688 { }, 10689 .fill_helper = bpf_fill_maxinsns4, 10690 .expected_errcode = -EINVAL, 10691 }, 10692 { /* Mainly checking JIT here. */ 10693 "BPF_MAXINSNS: Very long jump", 10694 { }, 10695 CLASSIC | FLAG_NO_DATA, 10696 { }, 10697 { { 0, 0xabababab } }, 10698 .fill_helper = bpf_fill_maxinsns5, 10699 }, 10700 { /* Mainly checking JIT here. */ 10701 "BPF_MAXINSNS: Ctx heavy transformations", 10702 { }, 10703 CLASSIC, 10704 { }, 10705 { 10706 { 1, SKB_VLAN_PRESENT }, 10707 { 10, SKB_VLAN_PRESENT } 10708 }, 10709 .fill_helper = bpf_fill_maxinsns6, 10710 }, 10711 { /* Mainly checking JIT here. */ 10712 "BPF_MAXINSNS: Call heavy transformations", 10713 { }, 10714 CLASSIC | FLAG_NO_DATA, 10715 { }, 10716 { { 1, 0 }, { 10, 0 } }, 10717 .fill_helper = bpf_fill_maxinsns7, 10718 }, 10719 { /* Mainly checking JIT here. */ 10720 "BPF_MAXINSNS: Jump heavy test", 10721 { }, 10722 CLASSIC | FLAG_NO_DATA, 10723 { }, 10724 { { 0, 0xffffffff } }, 10725 .fill_helper = bpf_fill_maxinsns8, 10726 }, 10727 { /* Mainly checking JIT here. */ 10728 "BPF_MAXINSNS: Very long jump backwards", 10729 { }, 10730 INTERNAL | FLAG_NO_DATA, 10731 { }, 10732 { { 0, 0xcbababab } }, 10733 .fill_helper = bpf_fill_maxinsns9, 10734 }, 10735 { /* Mainly checking JIT here. */ 10736 "BPF_MAXINSNS: Edge hopping nuthouse", 10737 { }, 10738 INTERNAL | FLAG_NO_DATA, 10739 { }, 10740 { { 0, 0xabababac } }, 10741 .fill_helper = bpf_fill_maxinsns10, 10742 }, 10743 { 10744 "BPF_MAXINSNS: Jump, gap, jump, ...", 10745 { }, 10746 CLASSIC | FLAG_NO_DATA, 10747 { }, 10748 { { 0, 0xababcbac } }, 10749 .fill_helper = bpf_fill_maxinsns11, 10750 }, 10751 { 10752 "BPF_MAXINSNS: jump over MSH", 10753 { }, 10754 CLASSIC | FLAG_EXPECTED_FAIL, 10755 { 0xfa, 0xfb, 0xfc, 0xfd, }, 10756 { { 4, 0xabababab } }, 10757 .fill_helper = bpf_fill_maxinsns12, 10758 .expected_errcode = -EINVAL, 10759 }, 10760 { 10761 "BPF_MAXINSNS: exec all MSH", 10762 { }, 10763 CLASSIC, 10764 { 0xfa, 0xfb, 0xfc, 0xfd, }, 10765 { { 4, 0xababab83 } }, 10766 .fill_helper = bpf_fill_maxinsns13, 10767 }, 10768 { 10769 "BPF_MAXINSNS: ld_abs+get_processor_id", 10770 { }, 10771 CLASSIC, 10772 { }, 10773 { { 1, 0xbee } }, 10774 .fill_helper = bpf_fill_ld_abs_get_processor_id, 10775 }, 10776 /* 10777 * LD_IND / LD_ABS on fragmented SKBs 10778 */ 10779 { 10780 "LD_IND byte frag", 10781 .u.insns = { 10782 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 10783 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0), 10784 BPF_STMT(BPF_RET | BPF_A, 0x0), 10785 }, 10786 CLASSIC | FLAG_SKB_FRAG, 10787 { }, 10788 { {0x40, 0x42} }, 10789 .frag_data = { 10790 0x42, 0x00, 0x00, 0x00, 10791 0x43, 0x44, 0x00, 0x00, 10792 0x21, 0x07, 0x19, 0x83, 10793 }, 10794 }, 10795 { 10796 "LD_IND halfword frag", 10797 .u.insns = { 10798 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 10799 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4), 10800 BPF_STMT(BPF_RET | BPF_A, 0x0), 10801 }, 10802 CLASSIC | FLAG_SKB_FRAG, 10803 { }, 10804 { {0x40, 0x4344} }, 10805 .frag_data = { 10806 0x42, 0x00, 0x00, 0x00, 10807 0x43, 0x44, 0x00, 0x00, 10808 0x21, 0x07, 0x19, 0x83, 10809 }, 10810 }, 10811 { 10812 "LD_IND word frag", 10813 .u.insns = { 10814 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 10815 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8), 10816 BPF_STMT(BPF_RET | BPF_A, 0x0), 10817 }, 10818 CLASSIC | FLAG_SKB_FRAG, 10819 { }, 10820 { {0x40, 0x21071983} }, 10821 .frag_data = { 10822 0x42, 0x00, 0x00, 0x00, 10823 0x43, 0x44, 0x00, 0x00, 10824 0x21, 0x07, 0x19, 0x83, 10825 }, 10826 }, 10827 { 10828 "LD_IND halfword mixed head/frag", 10829 .u.insns = { 10830 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 10831 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1), 10832 BPF_STMT(BPF_RET | BPF_A, 0x0), 10833 }, 10834 CLASSIC | FLAG_SKB_FRAG, 10835 { [0x3e] = 0x25, [0x3f] = 0x05, }, 10836 { {0x40, 0x0519} }, 10837 .frag_data = { 0x19, 0x82 }, 10838 }, 10839 { 10840 "LD_IND word mixed head/frag", 10841 .u.insns = { 10842 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 10843 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2), 10844 BPF_STMT(BPF_RET | BPF_A, 0x0), 10845 }, 10846 CLASSIC | FLAG_SKB_FRAG, 10847 { [0x3e] = 0x25, [0x3f] = 0x05, }, 10848 { {0x40, 0x25051982} }, 10849 .frag_data = { 0x19, 0x82 }, 10850 }, 10851 { 10852 "LD_ABS byte frag", 10853 .u.insns = { 10854 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40), 10855 BPF_STMT(BPF_RET | BPF_A, 0x0), 10856 }, 10857 CLASSIC | FLAG_SKB_FRAG, 10858 { }, 10859 { {0x40, 0x42} }, 10860 .frag_data = { 10861 0x42, 0x00, 0x00, 0x00, 10862 0x43, 0x44, 0x00, 0x00, 10863 0x21, 0x07, 0x19, 0x83, 10864 }, 10865 }, 10866 { 10867 "LD_ABS halfword frag", 10868 .u.insns = { 10869 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44), 10870 BPF_STMT(BPF_RET | BPF_A, 0x0), 10871 }, 10872 CLASSIC | FLAG_SKB_FRAG, 10873 { }, 10874 { {0x40, 0x4344} }, 10875 .frag_data = { 10876 0x42, 0x00, 0x00, 0x00, 10877 0x43, 0x44, 0x00, 0x00, 10878 0x21, 0x07, 0x19, 0x83, 10879 }, 10880 }, 10881 { 10882 "LD_ABS word frag", 10883 .u.insns = { 10884 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48), 10885 BPF_STMT(BPF_RET | BPF_A, 0x0), 10886 }, 10887 CLASSIC | FLAG_SKB_FRAG, 10888 { }, 10889 { {0x40, 0x21071983} }, 10890 .frag_data = { 10891 0x42, 0x00, 0x00, 0x00, 10892 0x43, 0x44, 0x00, 0x00, 10893 0x21, 0x07, 0x19, 0x83, 10894 }, 10895 }, 10896 { 10897 "LD_ABS halfword mixed head/frag", 10898 .u.insns = { 10899 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f), 10900 BPF_STMT(BPF_RET | BPF_A, 0x0), 10901 }, 10902 CLASSIC | FLAG_SKB_FRAG, 10903 { [0x3e] = 0x25, [0x3f] = 0x05, }, 10904 { {0x40, 0x0519} }, 10905 .frag_data = { 0x19, 0x82 }, 10906 }, 10907 { 10908 "LD_ABS word mixed head/frag", 10909 .u.insns = { 10910 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e), 10911 BPF_STMT(BPF_RET | BPF_A, 0x0), 10912 }, 10913 CLASSIC | FLAG_SKB_FRAG, 10914 { [0x3e] = 0x25, [0x3f] = 0x05, }, 10915 { {0x40, 0x25051982} }, 10916 .frag_data = { 0x19, 0x82 }, 10917 }, 10918 /* 10919 * LD_IND / LD_ABS on non fragmented SKBs 10920 */ 10921 { 10922 /* 10923 * this tests that the JIT/interpreter correctly resets X 10924 * before using it in an LD_IND instruction. 10925 */ 10926 "LD_IND byte default X", 10927 .u.insns = { 10928 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 10929 BPF_STMT(BPF_RET | BPF_A, 0x0), 10930 }, 10931 CLASSIC, 10932 { [0x1] = 0x42 }, 10933 { {0x40, 0x42 } }, 10934 }, 10935 { 10936 "LD_IND byte positive offset", 10937 .u.insns = { 10938 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 10939 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 10940 BPF_STMT(BPF_RET | BPF_A, 0x0), 10941 }, 10942 CLASSIC, 10943 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10944 { {0x40, 0x82 } }, 10945 }, 10946 { 10947 "LD_IND byte negative offset", 10948 .u.insns = { 10949 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 10950 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1), 10951 BPF_STMT(BPF_RET | BPF_A, 0x0), 10952 }, 10953 CLASSIC, 10954 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10955 { {0x40, 0x05 } }, 10956 }, 10957 { 10958 "LD_IND byte positive offset, all ff", 10959 .u.insns = { 10960 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 10961 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 10962 BPF_STMT(BPF_RET | BPF_A, 0x0), 10963 }, 10964 CLASSIC, 10965 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 10966 { {0x40, 0xff } }, 10967 }, 10968 { 10969 "LD_IND byte positive offset, out of bounds", 10970 .u.insns = { 10971 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 10972 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 10973 BPF_STMT(BPF_RET | BPF_A, 0x0), 10974 }, 10975 CLASSIC, 10976 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10977 { {0x3f, 0 }, }, 10978 }, 10979 { 10980 "LD_IND byte negative offset, out of bounds", 10981 .u.insns = { 10982 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 10983 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f), 10984 BPF_STMT(BPF_RET | BPF_A, 0x0), 10985 }, 10986 CLASSIC, 10987 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10988 { {0x3f, 0 } }, 10989 }, 10990 { 10991 "LD_IND byte negative offset, multiple calls", 10992 .u.insns = { 10993 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b), 10994 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1), 10995 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2), 10996 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3), 10997 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4), 10998 BPF_STMT(BPF_RET | BPF_A, 0x0), 10999 }, 11000 CLASSIC, 11001 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11002 { {0x40, 0x82 }, }, 11003 }, 11004 { 11005 "LD_IND halfword positive offset", 11006 .u.insns = { 11007 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 11008 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2), 11009 BPF_STMT(BPF_RET | BPF_A, 0x0), 11010 }, 11011 CLASSIC, 11012 { 11013 [0x1c] = 0xaa, [0x1d] = 0x55, 11014 [0x1e] = 0xbb, [0x1f] = 0x66, 11015 [0x20] = 0xcc, [0x21] = 0x77, 11016 [0x22] = 0xdd, [0x23] = 0x88, 11017 }, 11018 { {0x40, 0xdd88 } }, 11019 }, 11020 { 11021 "LD_IND halfword negative offset", 11022 .u.insns = { 11023 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 11024 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2), 11025 BPF_STMT(BPF_RET | BPF_A, 0x0), 11026 }, 11027 CLASSIC, 11028 { 11029 [0x1c] = 0xaa, [0x1d] = 0x55, 11030 [0x1e] = 0xbb, [0x1f] = 0x66, 11031 [0x20] = 0xcc, [0x21] = 0x77, 11032 [0x22] = 0xdd, [0x23] = 0x88, 11033 }, 11034 { {0x40, 0xbb66 } }, 11035 }, 11036 { 11037 "LD_IND halfword unaligned", 11038 .u.insns = { 11039 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 11040 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1), 11041 BPF_STMT(BPF_RET | BPF_A, 0x0), 11042 }, 11043 CLASSIC, 11044 { 11045 [0x1c] = 0xaa, [0x1d] = 0x55, 11046 [0x1e] = 0xbb, [0x1f] = 0x66, 11047 [0x20] = 0xcc, [0x21] = 0x77, 11048 [0x22] = 0xdd, [0x23] = 0x88, 11049 }, 11050 { {0x40, 0x66cc } }, 11051 }, 11052 { 11053 "LD_IND halfword positive offset, all ff", 11054 .u.insns = { 11055 BPF_STMT(BPF_LDX | BPF_IMM, 0x3d), 11056 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1), 11057 BPF_STMT(BPF_RET | BPF_A, 0x0), 11058 }, 11059 CLASSIC, 11060 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 11061 { {0x40, 0xffff } }, 11062 }, 11063 { 11064 "LD_IND halfword positive offset, out of bounds", 11065 .u.insns = { 11066 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 11067 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1), 11068 BPF_STMT(BPF_RET | BPF_A, 0x0), 11069 }, 11070 CLASSIC, 11071 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11072 { {0x3f, 0 }, }, 11073 }, 11074 { 11075 "LD_IND halfword negative offset, out of bounds", 11076 .u.insns = { 11077 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 11078 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f), 11079 BPF_STMT(BPF_RET | BPF_A, 0x0), 11080 }, 11081 CLASSIC, 11082 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11083 { {0x3f, 0 } }, 11084 }, 11085 { 11086 "LD_IND word positive offset", 11087 .u.insns = { 11088 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 11089 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4), 11090 BPF_STMT(BPF_RET | BPF_A, 0x0), 11091 }, 11092 CLASSIC, 11093 { 11094 [0x1c] = 0xaa, [0x1d] = 0x55, 11095 [0x1e] = 0xbb, [0x1f] = 0x66, 11096 [0x20] = 0xcc, [0x21] = 0x77, 11097 [0x22] = 0xdd, [0x23] = 0x88, 11098 [0x24] = 0xee, [0x25] = 0x99, 11099 [0x26] = 0xff, [0x27] = 0xaa, 11100 }, 11101 { {0x40, 0xee99ffaa } }, 11102 }, 11103 { 11104 "LD_IND word negative offset", 11105 .u.insns = { 11106 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 11107 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4), 11108 BPF_STMT(BPF_RET | BPF_A, 0x0), 11109 }, 11110 CLASSIC, 11111 { 11112 [0x1c] = 0xaa, [0x1d] = 0x55, 11113 [0x1e] = 0xbb, [0x1f] = 0x66, 11114 [0x20] = 0xcc, [0x21] = 0x77, 11115 [0x22] = 0xdd, [0x23] = 0x88, 11116 [0x24] = 0xee, [0x25] = 0x99, 11117 [0x26] = 0xff, [0x27] = 0xaa, 11118 }, 11119 { {0x40, 0xaa55bb66 } }, 11120 }, 11121 { 11122 "LD_IND word unaligned (addr & 3 == 2)", 11123 .u.insns = { 11124 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 11125 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2), 11126 BPF_STMT(BPF_RET | BPF_A, 0x0), 11127 }, 11128 CLASSIC, 11129 { 11130 [0x1c] = 0xaa, [0x1d] = 0x55, 11131 [0x1e] = 0xbb, [0x1f] = 0x66, 11132 [0x20] = 0xcc, [0x21] = 0x77, 11133 [0x22] = 0xdd, [0x23] = 0x88, 11134 [0x24] = 0xee, [0x25] = 0x99, 11135 [0x26] = 0xff, [0x27] = 0xaa, 11136 }, 11137 { {0x40, 0xbb66cc77 } }, 11138 }, 11139 { 11140 "LD_IND word unaligned (addr & 3 == 1)", 11141 .u.insns = { 11142 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 11143 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3), 11144 BPF_STMT(BPF_RET | BPF_A, 0x0), 11145 }, 11146 CLASSIC, 11147 { 11148 [0x1c] = 0xaa, [0x1d] = 0x55, 11149 [0x1e] = 0xbb, [0x1f] = 0x66, 11150 [0x20] = 0xcc, [0x21] = 0x77, 11151 [0x22] = 0xdd, [0x23] = 0x88, 11152 [0x24] = 0xee, [0x25] = 0x99, 11153 [0x26] = 0xff, [0x27] = 0xaa, 11154 }, 11155 { {0x40, 0x55bb66cc } }, 11156 }, 11157 { 11158 "LD_IND word unaligned (addr & 3 == 3)", 11159 .u.insns = { 11160 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 11161 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1), 11162 BPF_STMT(BPF_RET | BPF_A, 0x0), 11163 }, 11164 CLASSIC, 11165 { 11166 [0x1c] = 0xaa, [0x1d] = 0x55, 11167 [0x1e] = 0xbb, [0x1f] = 0x66, 11168 [0x20] = 0xcc, [0x21] = 0x77, 11169 [0x22] = 0xdd, [0x23] = 0x88, 11170 [0x24] = 0xee, [0x25] = 0x99, 11171 [0x26] = 0xff, [0x27] = 0xaa, 11172 }, 11173 { {0x40, 0x66cc77dd } }, 11174 }, 11175 { 11176 "LD_IND word positive offset, all ff", 11177 .u.insns = { 11178 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b), 11179 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1), 11180 BPF_STMT(BPF_RET | BPF_A, 0x0), 11181 }, 11182 CLASSIC, 11183 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 11184 { {0x40, 0xffffffff } }, 11185 }, 11186 { 11187 "LD_IND word positive offset, out of bounds", 11188 .u.insns = { 11189 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 11190 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1), 11191 BPF_STMT(BPF_RET | BPF_A, 0x0), 11192 }, 11193 CLASSIC, 11194 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11195 { {0x3f, 0 }, }, 11196 }, 11197 { 11198 "LD_IND word negative offset, out of bounds", 11199 .u.insns = { 11200 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 11201 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f), 11202 BPF_STMT(BPF_RET | BPF_A, 0x0), 11203 }, 11204 CLASSIC, 11205 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11206 { {0x3f, 0 } }, 11207 }, 11208 { 11209 "LD_ABS byte", 11210 .u.insns = { 11211 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20), 11212 BPF_STMT(BPF_RET | BPF_A, 0x0), 11213 }, 11214 CLASSIC, 11215 { 11216 [0x1c] = 0xaa, [0x1d] = 0x55, 11217 [0x1e] = 0xbb, [0x1f] = 0x66, 11218 [0x20] = 0xcc, [0x21] = 0x77, 11219 [0x22] = 0xdd, [0x23] = 0x88, 11220 [0x24] = 0xee, [0x25] = 0x99, 11221 [0x26] = 0xff, [0x27] = 0xaa, 11222 }, 11223 { {0x40, 0xcc } }, 11224 }, 11225 { 11226 "LD_ABS byte positive offset, all ff", 11227 .u.insns = { 11228 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f), 11229 BPF_STMT(BPF_RET | BPF_A, 0x0), 11230 }, 11231 CLASSIC, 11232 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 11233 { {0x40, 0xff } }, 11234 }, 11235 { 11236 "LD_ABS byte positive offset, out of bounds", 11237 .u.insns = { 11238 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f), 11239 BPF_STMT(BPF_RET | BPF_A, 0x0), 11240 }, 11241 CLASSIC, 11242 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11243 { {0x3f, 0 }, }, 11244 }, 11245 { 11246 "LD_ABS byte negative offset, out of bounds load", 11247 .u.insns = { 11248 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1), 11249 BPF_STMT(BPF_RET | BPF_A, 0x0), 11250 }, 11251 CLASSIC | FLAG_EXPECTED_FAIL, 11252 .expected_errcode = -EINVAL, 11253 }, 11254 { 11255 "LD_ABS byte negative offset, in bounds", 11256 .u.insns = { 11257 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 11258 BPF_STMT(BPF_RET | BPF_A, 0x0), 11259 }, 11260 CLASSIC, 11261 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11262 { {0x40, 0x82 }, }, 11263 }, 11264 { 11265 "LD_ABS byte negative offset, out of bounds", 11266 .u.insns = { 11267 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 11268 BPF_STMT(BPF_RET | BPF_A, 0x0), 11269 }, 11270 CLASSIC, 11271 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11272 { {0x3f, 0 }, }, 11273 }, 11274 { 11275 "LD_ABS byte negative offset, multiple calls", 11276 .u.insns = { 11277 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c), 11278 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d), 11279 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e), 11280 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 11281 BPF_STMT(BPF_RET | BPF_A, 0x0), 11282 }, 11283 CLASSIC, 11284 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11285 { {0x40, 0x82 }, }, 11286 }, 11287 { 11288 "LD_ABS halfword", 11289 .u.insns = { 11290 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22), 11291 BPF_STMT(BPF_RET | BPF_A, 0x0), 11292 }, 11293 CLASSIC, 11294 { 11295 [0x1c] = 0xaa, [0x1d] = 0x55, 11296 [0x1e] = 0xbb, [0x1f] = 0x66, 11297 [0x20] = 0xcc, [0x21] = 0x77, 11298 [0x22] = 0xdd, [0x23] = 0x88, 11299 [0x24] = 0xee, [0x25] = 0x99, 11300 [0x26] = 0xff, [0x27] = 0xaa, 11301 }, 11302 { {0x40, 0xdd88 } }, 11303 }, 11304 { 11305 "LD_ABS halfword unaligned", 11306 .u.insns = { 11307 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25), 11308 BPF_STMT(BPF_RET | BPF_A, 0x0), 11309 }, 11310 CLASSIC, 11311 { 11312 [0x1c] = 0xaa, [0x1d] = 0x55, 11313 [0x1e] = 0xbb, [0x1f] = 0x66, 11314 [0x20] = 0xcc, [0x21] = 0x77, 11315 [0x22] = 0xdd, [0x23] = 0x88, 11316 [0x24] = 0xee, [0x25] = 0x99, 11317 [0x26] = 0xff, [0x27] = 0xaa, 11318 }, 11319 { {0x40, 0x99ff } }, 11320 }, 11321 { 11322 "LD_ABS halfword positive offset, all ff", 11323 .u.insns = { 11324 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e), 11325 BPF_STMT(BPF_RET | BPF_A, 0x0), 11326 }, 11327 CLASSIC, 11328 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 11329 { {0x40, 0xffff } }, 11330 }, 11331 { 11332 "LD_ABS halfword positive offset, out of bounds", 11333 .u.insns = { 11334 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f), 11335 BPF_STMT(BPF_RET | BPF_A, 0x0), 11336 }, 11337 CLASSIC, 11338 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11339 { {0x3f, 0 }, }, 11340 }, 11341 { 11342 "LD_ABS halfword negative offset, out of bounds load", 11343 .u.insns = { 11344 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1), 11345 BPF_STMT(BPF_RET | BPF_A, 0x0), 11346 }, 11347 CLASSIC | FLAG_EXPECTED_FAIL, 11348 .expected_errcode = -EINVAL, 11349 }, 11350 { 11351 "LD_ABS halfword negative offset, in bounds", 11352 .u.insns = { 11353 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e), 11354 BPF_STMT(BPF_RET | BPF_A, 0x0), 11355 }, 11356 CLASSIC, 11357 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11358 { {0x40, 0x1982 }, }, 11359 }, 11360 { 11361 "LD_ABS halfword negative offset, out of bounds", 11362 .u.insns = { 11363 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e), 11364 BPF_STMT(BPF_RET | BPF_A, 0x0), 11365 }, 11366 CLASSIC, 11367 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11368 { {0x3f, 0 }, }, 11369 }, 11370 { 11371 "LD_ABS word", 11372 .u.insns = { 11373 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c), 11374 BPF_STMT(BPF_RET | BPF_A, 0x0), 11375 }, 11376 CLASSIC, 11377 { 11378 [0x1c] = 0xaa, [0x1d] = 0x55, 11379 [0x1e] = 0xbb, [0x1f] = 0x66, 11380 [0x20] = 0xcc, [0x21] = 0x77, 11381 [0x22] = 0xdd, [0x23] = 0x88, 11382 [0x24] = 0xee, [0x25] = 0x99, 11383 [0x26] = 0xff, [0x27] = 0xaa, 11384 }, 11385 { {0x40, 0xaa55bb66 } }, 11386 }, 11387 { 11388 "LD_ABS word unaligned (addr & 3 == 2)", 11389 .u.insns = { 11390 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22), 11391 BPF_STMT(BPF_RET | BPF_A, 0x0), 11392 }, 11393 CLASSIC, 11394 { 11395 [0x1c] = 0xaa, [0x1d] = 0x55, 11396 [0x1e] = 0xbb, [0x1f] = 0x66, 11397 [0x20] = 0xcc, [0x21] = 0x77, 11398 [0x22] = 0xdd, [0x23] = 0x88, 11399 [0x24] = 0xee, [0x25] = 0x99, 11400 [0x26] = 0xff, [0x27] = 0xaa, 11401 }, 11402 { {0x40, 0xdd88ee99 } }, 11403 }, 11404 { 11405 "LD_ABS word unaligned (addr & 3 == 1)", 11406 .u.insns = { 11407 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21), 11408 BPF_STMT(BPF_RET | BPF_A, 0x0), 11409 }, 11410 CLASSIC, 11411 { 11412 [0x1c] = 0xaa, [0x1d] = 0x55, 11413 [0x1e] = 0xbb, [0x1f] = 0x66, 11414 [0x20] = 0xcc, [0x21] = 0x77, 11415 [0x22] = 0xdd, [0x23] = 0x88, 11416 [0x24] = 0xee, [0x25] = 0x99, 11417 [0x26] = 0xff, [0x27] = 0xaa, 11418 }, 11419 { {0x40, 0x77dd88ee } }, 11420 }, 11421 { 11422 "LD_ABS word unaligned (addr & 3 == 3)", 11423 .u.insns = { 11424 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23), 11425 BPF_STMT(BPF_RET | BPF_A, 0x0), 11426 }, 11427 CLASSIC, 11428 { 11429 [0x1c] = 0xaa, [0x1d] = 0x55, 11430 [0x1e] = 0xbb, [0x1f] = 0x66, 11431 [0x20] = 0xcc, [0x21] = 0x77, 11432 [0x22] = 0xdd, [0x23] = 0x88, 11433 [0x24] = 0xee, [0x25] = 0x99, 11434 [0x26] = 0xff, [0x27] = 0xaa, 11435 }, 11436 { {0x40, 0x88ee99ff } }, 11437 }, 11438 { 11439 "LD_ABS word positive offset, all ff", 11440 .u.insns = { 11441 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c), 11442 BPF_STMT(BPF_RET | BPF_A, 0x0), 11443 }, 11444 CLASSIC, 11445 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 11446 { {0x40, 0xffffffff } }, 11447 }, 11448 { 11449 "LD_ABS word positive offset, out of bounds", 11450 .u.insns = { 11451 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f), 11452 BPF_STMT(BPF_RET | BPF_A, 0x0), 11453 }, 11454 CLASSIC, 11455 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11456 { {0x3f, 0 }, }, 11457 }, 11458 { 11459 "LD_ABS word negative offset, out of bounds load", 11460 .u.insns = { 11461 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1), 11462 BPF_STMT(BPF_RET | BPF_A, 0x0), 11463 }, 11464 CLASSIC | FLAG_EXPECTED_FAIL, 11465 .expected_errcode = -EINVAL, 11466 }, 11467 { 11468 "LD_ABS word negative offset, in bounds", 11469 .u.insns = { 11470 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c), 11471 BPF_STMT(BPF_RET | BPF_A, 0x0), 11472 }, 11473 CLASSIC, 11474 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11475 { {0x40, 0x25051982 }, }, 11476 }, 11477 { 11478 "LD_ABS word negative offset, out of bounds", 11479 .u.insns = { 11480 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c), 11481 BPF_STMT(BPF_RET | BPF_A, 0x0), 11482 }, 11483 CLASSIC, 11484 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11485 { {0x3f, 0 }, }, 11486 }, 11487 { 11488 "LDX_MSH standalone, preserved A", 11489 .u.insns = { 11490 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 11491 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 11492 BPF_STMT(BPF_RET | BPF_A, 0x0), 11493 }, 11494 CLASSIC, 11495 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11496 { {0x40, 0xffeebbaa }, }, 11497 }, 11498 { 11499 "LDX_MSH standalone, preserved A 2", 11500 .u.insns = { 11501 BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63), 11502 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 11503 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d), 11504 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e), 11505 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f), 11506 BPF_STMT(BPF_RET | BPF_A, 0x0), 11507 }, 11508 CLASSIC, 11509 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11510 { {0x40, 0x175e9d63 }, }, 11511 }, 11512 { 11513 "LDX_MSH standalone, test result 1", 11514 .u.insns = { 11515 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 11516 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 11517 BPF_STMT(BPF_MISC | BPF_TXA, 0), 11518 BPF_STMT(BPF_RET | BPF_A, 0x0), 11519 }, 11520 CLASSIC, 11521 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11522 { {0x40, 0x14 }, }, 11523 }, 11524 { 11525 "LDX_MSH standalone, test result 2", 11526 .u.insns = { 11527 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 11528 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e), 11529 BPF_STMT(BPF_MISC | BPF_TXA, 0), 11530 BPF_STMT(BPF_RET | BPF_A, 0x0), 11531 }, 11532 CLASSIC, 11533 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11534 { {0x40, 0x24 }, }, 11535 }, 11536 { 11537 "LDX_MSH standalone, negative offset", 11538 .u.insns = { 11539 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 11540 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1), 11541 BPF_STMT(BPF_MISC | BPF_TXA, 0), 11542 BPF_STMT(BPF_RET | BPF_A, 0x0), 11543 }, 11544 CLASSIC, 11545 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11546 { {0x40, 0 }, }, 11547 }, 11548 { 11549 "LDX_MSH standalone, negative offset 2", 11550 .u.insns = { 11551 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 11552 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e), 11553 BPF_STMT(BPF_MISC | BPF_TXA, 0), 11554 BPF_STMT(BPF_RET | BPF_A, 0x0), 11555 }, 11556 CLASSIC, 11557 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11558 { {0x40, 0x24 }, }, 11559 }, 11560 { 11561 "LDX_MSH standalone, out of bounds", 11562 .u.insns = { 11563 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 11564 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40), 11565 BPF_STMT(BPF_MISC | BPF_TXA, 0), 11566 BPF_STMT(BPF_RET | BPF_A, 0x0), 11567 }, 11568 CLASSIC, 11569 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 11570 { {0x40, 0 }, }, 11571 }, 11572 /* 11573 * verify that the interpreter or JIT correctly sets A and X 11574 * to 0. 11575 */ 11576 { 11577 "ADD default X", 11578 .u.insns = { 11579 /* 11580 * A = 0x42 11581 * A = A + X 11582 * ret A 11583 */ 11584 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 11585 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 11586 BPF_STMT(BPF_RET | BPF_A, 0x0), 11587 }, 11588 CLASSIC | FLAG_NO_DATA, 11589 {}, 11590 { {0x1, 0x42 } }, 11591 }, 11592 { 11593 "ADD default A", 11594 .u.insns = { 11595 /* 11596 * A = A + 0x42 11597 * ret A 11598 */ 11599 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42), 11600 BPF_STMT(BPF_RET | BPF_A, 0x0), 11601 }, 11602 CLASSIC | FLAG_NO_DATA, 11603 {}, 11604 { {0x1, 0x42 } }, 11605 }, 11606 { 11607 "SUB default X", 11608 .u.insns = { 11609 /* 11610 * A = 0x66 11611 * A = A - X 11612 * ret A 11613 */ 11614 BPF_STMT(BPF_LD | BPF_IMM, 0x66), 11615 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 11616 BPF_STMT(BPF_RET | BPF_A, 0x0), 11617 }, 11618 CLASSIC | FLAG_NO_DATA, 11619 {}, 11620 { {0x1, 0x66 } }, 11621 }, 11622 { 11623 "SUB default A", 11624 .u.insns = { 11625 /* 11626 * A = A - -0x66 11627 * ret A 11628 */ 11629 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66), 11630 BPF_STMT(BPF_RET | BPF_A, 0x0), 11631 }, 11632 CLASSIC | FLAG_NO_DATA, 11633 {}, 11634 { {0x1, 0x66 } }, 11635 }, 11636 { 11637 "MUL default X", 11638 .u.insns = { 11639 /* 11640 * A = 0x42 11641 * A = A * X 11642 * ret A 11643 */ 11644 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 11645 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0), 11646 BPF_STMT(BPF_RET | BPF_A, 0x0), 11647 }, 11648 CLASSIC | FLAG_NO_DATA, 11649 {}, 11650 { {0x1, 0x0 } }, 11651 }, 11652 { 11653 "MUL default A", 11654 .u.insns = { 11655 /* 11656 * A = A * 0x66 11657 * ret A 11658 */ 11659 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66), 11660 BPF_STMT(BPF_RET | BPF_A, 0x0), 11661 }, 11662 CLASSIC | FLAG_NO_DATA, 11663 {}, 11664 { {0x1, 0x0 } }, 11665 }, 11666 { 11667 "DIV default X", 11668 .u.insns = { 11669 /* 11670 * A = 0x42 11671 * A = A / X ; this halt the filter execution if X is 0 11672 * ret 0x42 11673 */ 11674 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 11675 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 11676 BPF_STMT(BPF_RET | BPF_K, 0x42), 11677 }, 11678 CLASSIC | FLAG_NO_DATA, 11679 {}, 11680 { {0x1, 0x0 } }, 11681 }, 11682 { 11683 "DIV default A", 11684 .u.insns = { 11685 /* 11686 * A = A / 1 11687 * ret A 11688 */ 11689 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1), 11690 BPF_STMT(BPF_RET | BPF_A, 0x0), 11691 }, 11692 CLASSIC | FLAG_NO_DATA, 11693 {}, 11694 { {0x1, 0x0 } }, 11695 }, 11696 { 11697 "MOD default X", 11698 .u.insns = { 11699 /* 11700 * A = 0x42 11701 * A = A mod X ; this halt the filter execution if X is 0 11702 * ret 0x42 11703 */ 11704 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 11705 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0), 11706 BPF_STMT(BPF_RET | BPF_K, 0x42), 11707 }, 11708 CLASSIC | FLAG_NO_DATA, 11709 {}, 11710 { {0x1, 0x0 } }, 11711 }, 11712 { 11713 "MOD default A", 11714 .u.insns = { 11715 /* 11716 * A = A mod 1 11717 * ret A 11718 */ 11719 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1), 11720 BPF_STMT(BPF_RET | BPF_A, 0x0), 11721 }, 11722 CLASSIC | FLAG_NO_DATA, 11723 {}, 11724 { {0x1, 0x0 } }, 11725 }, 11726 { 11727 "JMP EQ default A", 11728 .u.insns = { 11729 /* 11730 * cmp A, 0x0, 0, 1 11731 * ret 0x42 11732 * ret 0x66 11733 */ 11734 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1), 11735 BPF_STMT(BPF_RET | BPF_K, 0x42), 11736 BPF_STMT(BPF_RET | BPF_K, 0x66), 11737 }, 11738 CLASSIC | FLAG_NO_DATA, 11739 {}, 11740 { {0x1, 0x42 } }, 11741 }, 11742 { 11743 "JMP EQ default X", 11744 .u.insns = { 11745 /* 11746 * A = 0x0 11747 * cmp A, X, 0, 1 11748 * ret 0x42 11749 * ret 0x66 11750 */ 11751 BPF_STMT(BPF_LD | BPF_IMM, 0x0), 11752 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1), 11753 BPF_STMT(BPF_RET | BPF_K, 0x42), 11754 BPF_STMT(BPF_RET | BPF_K, 0x66), 11755 }, 11756 CLASSIC | FLAG_NO_DATA, 11757 {}, 11758 { {0x1, 0x42 } }, 11759 }, 11760 /* Checking interpreter vs JIT wrt signed extended imms. */ 11761 { 11762 "JNE signed compare, test 1", 11763 .u.insns_int = { 11764 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 11765 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 11766 BPF_MOV64_REG(R2, R1), 11767 BPF_ALU64_REG(BPF_AND, R2, R3), 11768 BPF_ALU32_IMM(BPF_MOV, R0, 1), 11769 BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1), 11770 BPF_ALU32_IMM(BPF_MOV, R0, 2), 11771 BPF_EXIT_INSN(), 11772 }, 11773 INTERNAL, 11774 { }, 11775 { { 0, 1 } }, 11776 }, 11777 { 11778 "JNE signed compare, test 2", 11779 .u.insns_int = { 11780 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 11781 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 11782 BPF_MOV64_REG(R2, R1), 11783 BPF_ALU64_REG(BPF_AND, R2, R3), 11784 BPF_ALU32_IMM(BPF_MOV, R0, 1), 11785 BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1), 11786 BPF_ALU32_IMM(BPF_MOV, R0, 2), 11787 BPF_EXIT_INSN(), 11788 }, 11789 INTERNAL, 11790 { }, 11791 { { 0, 1 } }, 11792 }, 11793 { 11794 "JNE signed compare, test 3", 11795 .u.insns_int = { 11796 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 11797 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 11798 BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000), 11799 BPF_MOV64_REG(R2, R1), 11800 BPF_ALU64_REG(BPF_AND, R2, R3), 11801 BPF_ALU32_IMM(BPF_MOV, R0, 1), 11802 BPF_JMP_REG(BPF_JNE, R2, R4, 1), 11803 BPF_ALU32_IMM(BPF_MOV, R0, 2), 11804 BPF_EXIT_INSN(), 11805 }, 11806 INTERNAL, 11807 { }, 11808 { { 0, 2 } }, 11809 }, 11810 { 11811 "JNE signed compare, test 4", 11812 .u.insns_int = { 11813 BPF_LD_IMM64(R1, -17104896), 11814 BPF_ALU32_IMM(BPF_MOV, R0, 1), 11815 BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1), 11816 BPF_ALU32_IMM(BPF_MOV, R0, 2), 11817 BPF_EXIT_INSN(), 11818 }, 11819 INTERNAL, 11820 { }, 11821 { { 0, 2 } }, 11822 }, 11823 { 11824 "JNE signed compare, test 5", 11825 .u.insns_int = { 11826 BPF_LD_IMM64(R1, 0xfefb0000), 11827 BPF_ALU32_IMM(BPF_MOV, R0, 1), 11828 BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1), 11829 BPF_ALU32_IMM(BPF_MOV, R0, 2), 11830 BPF_EXIT_INSN(), 11831 }, 11832 INTERNAL, 11833 { }, 11834 { { 0, 1 } }, 11835 }, 11836 { 11837 "JNE signed compare, test 6", 11838 .u.insns_int = { 11839 BPF_LD_IMM64(R1, 0x7efb0000), 11840 BPF_ALU32_IMM(BPF_MOV, R0, 1), 11841 BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1), 11842 BPF_ALU32_IMM(BPF_MOV, R0, 2), 11843 BPF_EXIT_INSN(), 11844 }, 11845 INTERNAL, 11846 { }, 11847 { { 0, 2 } }, 11848 }, 11849 { 11850 "JNE signed compare, test 7", 11851 .u.insns = { 11852 BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000), 11853 BPF_STMT(BPF_MISC | BPF_TAX, 0), 11854 BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12), 11855 BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0), 11856 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0), 11857 BPF_STMT(BPF_RET | BPF_K, 1), 11858 BPF_STMT(BPF_RET | BPF_K, 2), 11859 }, 11860 CLASSIC | FLAG_NO_DATA, 11861 {}, 11862 { { 0, 2 } }, 11863 }, 11864 /* BPF_LDX_MEM with operand aliasing */ 11865 { 11866 "LDX_MEM_B: operand register aliasing", 11867 .u.insns_int = { 11868 BPF_ST_MEM(BPF_B, R10, -8, 123), 11869 BPF_MOV64_REG(R0, R10), 11870 BPF_LDX_MEM(BPF_B, R0, R0, -8), 11871 BPF_EXIT_INSN(), 11872 }, 11873 INTERNAL, 11874 { }, 11875 { { 0, 123 } }, 11876 .stack_depth = 8, 11877 }, 11878 { 11879 "LDX_MEM_H: operand register aliasing", 11880 .u.insns_int = { 11881 BPF_ST_MEM(BPF_H, R10, -8, 12345), 11882 BPF_MOV64_REG(R0, R10), 11883 BPF_LDX_MEM(BPF_H, R0, R0, -8), 11884 BPF_EXIT_INSN(), 11885 }, 11886 INTERNAL, 11887 { }, 11888 { { 0, 12345 } }, 11889 .stack_depth = 8, 11890 }, 11891 { 11892 "LDX_MEM_W: operand register aliasing", 11893 .u.insns_int = { 11894 BPF_ST_MEM(BPF_W, R10, -8, 123456789), 11895 BPF_MOV64_REG(R0, R10), 11896 BPF_LDX_MEM(BPF_W, R0, R0, -8), 11897 BPF_EXIT_INSN(), 11898 }, 11899 INTERNAL, 11900 { }, 11901 { { 0, 123456789 } }, 11902 .stack_depth = 8, 11903 }, 11904 { 11905 "LDX_MEM_DW: operand register aliasing", 11906 .u.insns_int = { 11907 BPF_LD_IMM64(R1, 0x123456789abcdefULL), 11908 BPF_STX_MEM(BPF_DW, R10, R1, -8), 11909 BPF_MOV64_REG(R0, R10), 11910 BPF_LDX_MEM(BPF_DW, R0, R0, -8), 11911 BPF_ALU64_REG(BPF_SUB, R0, R1), 11912 BPF_MOV64_REG(R1, R0), 11913 BPF_ALU64_IMM(BPF_RSH, R1, 32), 11914 BPF_ALU64_REG(BPF_OR, R0, R1), 11915 BPF_EXIT_INSN(), 11916 }, 11917 INTERNAL, 11918 { }, 11919 { { 0, 0 } }, 11920 .stack_depth = 8, 11921 }, 11922 /* 11923 * Register (non-)clobbering tests for the case where a JIT implements 11924 * complex ALU or ATOMIC operations via function calls. If so, the 11925 * function call must be transparent to the eBPF registers. The JIT 11926 * must therefore save and restore relevant registers across the call. 11927 * The following tests check that the eBPF registers retain their 11928 * values after such an operation. Mainly intended for complex ALU 11929 * and atomic operation, but we run it for all. You never know... 11930 * 11931 * Note that each operations should be tested twice with different 11932 * destinations, to check preservation for all registers. 11933 */ 11934#define BPF_TEST_CLOBBER_ALU(alu, op, dst, src) \ 11935 { \ 11936 #alu "_" #op " to " #dst ": no clobbering", \ 11937 .u.insns_int = { \ 11938 BPF_ALU64_IMM(BPF_MOV, R0, R0), \ 11939 BPF_ALU64_IMM(BPF_MOV, R1, R1), \ 11940 BPF_ALU64_IMM(BPF_MOV, R2, R2), \ 11941 BPF_ALU64_IMM(BPF_MOV, R3, R3), \ 11942 BPF_ALU64_IMM(BPF_MOV, R4, R4), \ 11943 BPF_ALU64_IMM(BPF_MOV, R5, R5), \ 11944 BPF_ALU64_IMM(BPF_MOV, R6, R6), \ 11945 BPF_ALU64_IMM(BPF_MOV, R7, R7), \ 11946 BPF_ALU64_IMM(BPF_MOV, R8, R8), \ 11947 BPF_ALU64_IMM(BPF_MOV, R9, R9), \ 11948 BPF_##alu(BPF_ ##op, dst, src), \ 11949 BPF_ALU32_IMM(BPF_MOV, dst, dst), \ 11950 BPF_JMP_IMM(BPF_JNE, R0, R0, 10), \ 11951 BPF_JMP_IMM(BPF_JNE, R1, R1, 9), \ 11952 BPF_JMP_IMM(BPF_JNE, R2, R2, 8), \ 11953 BPF_JMP_IMM(BPF_JNE, R3, R3, 7), \ 11954 BPF_JMP_IMM(BPF_JNE, R4, R4, 6), \ 11955 BPF_JMP_IMM(BPF_JNE, R5, R5, 5), \ 11956 BPF_JMP_IMM(BPF_JNE, R6, R6, 4), \ 11957 BPF_JMP_IMM(BPF_JNE, R7, R7, 3), \ 11958 BPF_JMP_IMM(BPF_JNE, R8, R8, 2), \ 11959 BPF_JMP_IMM(BPF_JNE, R9, R9, 1), \ 11960 BPF_ALU64_IMM(BPF_MOV, R0, 1), \ 11961 BPF_EXIT_INSN(), \ 11962 }, \ 11963 INTERNAL, \ 11964 { }, \ 11965 { { 0, 1 } } \ 11966 } 11967 /* ALU64 operations, register clobbering */ 11968 BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R8, 123456789), 11969 BPF_TEST_CLOBBER_ALU(ALU64_IMM, AND, R9, 123456789), 11970 BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R8, 123456789), 11971 BPF_TEST_CLOBBER_ALU(ALU64_IMM, OR, R9, 123456789), 11972 BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R8, 123456789), 11973 BPF_TEST_CLOBBER_ALU(ALU64_IMM, XOR, R9, 123456789), 11974 BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R8, 12), 11975 BPF_TEST_CLOBBER_ALU(ALU64_IMM, LSH, R9, 12), 11976 BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R8, 12), 11977 BPF_TEST_CLOBBER_ALU(ALU64_IMM, RSH, R9, 12), 11978 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R8, 12), 11979 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ARSH, R9, 12), 11980 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R8, 123456789), 11981 BPF_TEST_CLOBBER_ALU(ALU64_IMM, ADD, R9, 123456789), 11982 BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R8, 123456789), 11983 BPF_TEST_CLOBBER_ALU(ALU64_IMM, SUB, R9, 123456789), 11984 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R8, 123456789), 11985 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MUL, R9, 123456789), 11986 BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R8, 123456789), 11987 BPF_TEST_CLOBBER_ALU(ALU64_IMM, DIV, R9, 123456789), 11988 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R8, 123456789), 11989 BPF_TEST_CLOBBER_ALU(ALU64_IMM, MOD, R9, 123456789), 11990 /* ALU32 immediate operations, register clobbering */ 11991 BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R8, 123456789), 11992 BPF_TEST_CLOBBER_ALU(ALU32_IMM, AND, R9, 123456789), 11993 BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R8, 123456789), 11994 BPF_TEST_CLOBBER_ALU(ALU32_IMM, OR, R9, 123456789), 11995 BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R8, 123456789), 11996 BPF_TEST_CLOBBER_ALU(ALU32_IMM, XOR, R9, 123456789), 11997 BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R8, 12), 11998 BPF_TEST_CLOBBER_ALU(ALU32_IMM, LSH, R9, 12), 11999 BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R8, 12), 12000 BPF_TEST_CLOBBER_ALU(ALU32_IMM, RSH, R9, 12), 12001 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R8, 12), 12002 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ARSH, R9, 12), 12003 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R8, 123456789), 12004 BPF_TEST_CLOBBER_ALU(ALU32_IMM, ADD, R9, 123456789), 12005 BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R8, 123456789), 12006 BPF_TEST_CLOBBER_ALU(ALU32_IMM, SUB, R9, 123456789), 12007 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R8, 123456789), 12008 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MUL, R9, 123456789), 12009 BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R8, 123456789), 12010 BPF_TEST_CLOBBER_ALU(ALU32_IMM, DIV, R9, 123456789), 12011 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R8, 123456789), 12012 BPF_TEST_CLOBBER_ALU(ALU32_IMM, MOD, R9, 123456789), 12013 /* ALU64 register operations, register clobbering */ 12014 BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R8, R1), 12015 BPF_TEST_CLOBBER_ALU(ALU64_REG, AND, R9, R1), 12016 BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R8, R1), 12017 BPF_TEST_CLOBBER_ALU(ALU64_REG, OR, R9, R1), 12018 BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R8, R1), 12019 BPF_TEST_CLOBBER_ALU(ALU64_REG, XOR, R9, R1), 12020 BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R8, R1), 12021 BPF_TEST_CLOBBER_ALU(ALU64_REG, LSH, R9, R1), 12022 BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R8, R1), 12023 BPF_TEST_CLOBBER_ALU(ALU64_REG, RSH, R9, R1), 12024 BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R8, R1), 12025 BPF_TEST_CLOBBER_ALU(ALU64_REG, ARSH, R9, R1), 12026 BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R8, R1), 12027 BPF_TEST_CLOBBER_ALU(ALU64_REG, ADD, R9, R1), 12028 BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R8, R1), 12029 BPF_TEST_CLOBBER_ALU(ALU64_REG, SUB, R9, R1), 12030 BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R8, R1), 12031 BPF_TEST_CLOBBER_ALU(ALU64_REG, MUL, R9, R1), 12032 BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R8, R1), 12033 BPF_TEST_CLOBBER_ALU(ALU64_REG, DIV, R9, R1), 12034 BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R8, R1), 12035 BPF_TEST_CLOBBER_ALU(ALU64_REG, MOD, R9, R1), 12036 /* ALU32 register operations, register clobbering */ 12037 BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R8, R1), 12038 BPF_TEST_CLOBBER_ALU(ALU32_REG, AND, R9, R1), 12039 BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R8, R1), 12040 BPF_TEST_CLOBBER_ALU(ALU32_REG, OR, R9, R1), 12041 BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R8, R1), 12042 BPF_TEST_CLOBBER_ALU(ALU32_REG, XOR, R9, R1), 12043 BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R8, R1), 12044 BPF_TEST_CLOBBER_ALU(ALU32_REG, LSH, R9, R1), 12045 BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R8, R1), 12046 BPF_TEST_CLOBBER_ALU(ALU32_REG, RSH, R9, R1), 12047 BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R8, R1), 12048 BPF_TEST_CLOBBER_ALU(ALU32_REG, ARSH, R9, R1), 12049 BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R8, R1), 12050 BPF_TEST_CLOBBER_ALU(ALU32_REG, ADD, R9, R1), 12051 BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R8, R1), 12052 BPF_TEST_CLOBBER_ALU(ALU32_REG, SUB, R9, R1), 12053 BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R8, R1), 12054 BPF_TEST_CLOBBER_ALU(ALU32_REG, MUL, R9, R1), 12055 BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R8, R1), 12056 BPF_TEST_CLOBBER_ALU(ALU32_REG, DIV, R9, R1), 12057 BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R8, R1), 12058 BPF_TEST_CLOBBER_ALU(ALU32_REG, MOD, R9, R1), 12059#undef BPF_TEST_CLOBBER_ALU 12060#define BPF_TEST_CLOBBER_ATOMIC(width, op) \ 12061 { \ 12062 "Atomic_" #width " " #op ": no clobbering", \ 12063 .u.insns_int = { \ 12064 BPF_ALU64_IMM(BPF_MOV, R0, 0), \ 12065 BPF_ALU64_IMM(BPF_MOV, R1, 1), \ 12066 BPF_ALU64_IMM(BPF_MOV, R2, 2), \ 12067 BPF_ALU64_IMM(BPF_MOV, R3, 3), \ 12068 BPF_ALU64_IMM(BPF_MOV, R4, 4), \ 12069 BPF_ALU64_IMM(BPF_MOV, R5, 5), \ 12070 BPF_ALU64_IMM(BPF_MOV, R6, 6), \ 12071 BPF_ALU64_IMM(BPF_MOV, R7, 7), \ 12072 BPF_ALU64_IMM(BPF_MOV, R8, 8), \ 12073 BPF_ALU64_IMM(BPF_MOV, R9, 9), \ 12074 BPF_ST_MEM(width, R10, -8, \ 12075 (op) == BPF_CMPXCHG ? 0 : \ 12076 (op) & BPF_FETCH ? 1 : 0), \ 12077 BPF_ATOMIC_OP(width, op, R10, R1, -8), \ 12078 BPF_JMP_IMM(BPF_JNE, R0, 0, 10), \ 12079 BPF_JMP_IMM(BPF_JNE, R1, 1, 9), \ 12080 BPF_JMP_IMM(BPF_JNE, R2, 2, 8), \ 12081 BPF_JMP_IMM(BPF_JNE, R3, 3, 7), \ 12082 BPF_JMP_IMM(BPF_JNE, R4, 4, 6), \ 12083 BPF_JMP_IMM(BPF_JNE, R5, 5, 5), \ 12084 BPF_JMP_IMM(BPF_JNE, R6, 6, 4), \ 12085 BPF_JMP_IMM(BPF_JNE, R7, 7, 3), \ 12086 BPF_JMP_IMM(BPF_JNE, R8, 8, 2), \ 12087 BPF_JMP_IMM(BPF_JNE, R9, 9, 1), \ 12088 BPF_ALU64_IMM(BPF_MOV, R0, 1), \ 12089 BPF_EXIT_INSN(), \ 12090 }, \ 12091 INTERNAL, \ 12092 { }, \ 12093 { { 0, 1 } }, \ 12094 .stack_depth = 8, \ 12095 } 12096 /* 64-bit atomic operations, register clobbering */ 12097 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD), 12098 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND), 12099 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR), 12100 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR), 12101 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_ADD | BPF_FETCH), 12102 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_AND | BPF_FETCH), 12103 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_OR | BPF_FETCH), 12104 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XOR | BPF_FETCH), 12105 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_XCHG), 12106 BPF_TEST_CLOBBER_ATOMIC(BPF_DW, BPF_CMPXCHG), 12107 /* 32-bit atomic operations, register clobbering */ 12108 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD), 12109 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND), 12110 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR), 12111 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR), 12112 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_ADD | BPF_FETCH), 12113 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_AND | BPF_FETCH), 12114 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_OR | BPF_FETCH), 12115 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XOR | BPF_FETCH), 12116 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_XCHG), 12117 BPF_TEST_CLOBBER_ATOMIC(BPF_W, BPF_CMPXCHG), 12118#undef BPF_TEST_CLOBBER_ATOMIC 12119 /* Checking that ALU32 src is not zero extended in place */ 12120#define BPF_ALU32_SRC_ZEXT(op) \ 12121 { \ 12122 "ALU32_" #op "_X: src preserved in zext", \ 12123 .u.insns_int = { \ 12124 BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\ 12125 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\ 12126 BPF_ALU64_REG(BPF_MOV, R0, R1), \ 12127 BPF_ALU32_REG(BPF_##op, R2, R1), \ 12128 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 12129 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 12130 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 12131 BPF_ALU64_REG(BPF_OR, R0, R1), \ 12132 BPF_EXIT_INSN(), \ 12133 }, \ 12134 INTERNAL, \ 12135 { }, \ 12136 { { 0, 0 } }, \ 12137 } 12138 BPF_ALU32_SRC_ZEXT(MOV), 12139 BPF_ALU32_SRC_ZEXT(AND), 12140 BPF_ALU32_SRC_ZEXT(OR), 12141 BPF_ALU32_SRC_ZEXT(XOR), 12142 BPF_ALU32_SRC_ZEXT(ADD), 12143 BPF_ALU32_SRC_ZEXT(SUB), 12144 BPF_ALU32_SRC_ZEXT(MUL), 12145 BPF_ALU32_SRC_ZEXT(DIV), 12146 BPF_ALU32_SRC_ZEXT(MOD), 12147#undef BPF_ALU32_SRC_ZEXT 12148 /* Checking that ATOMIC32 src is not zero extended in place */ 12149#define BPF_ATOMIC32_SRC_ZEXT(op) \ 12150 { \ 12151 "ATOMIC_W_" #op ": src preserved in zext", \ 12152 .u.insns_int = { \ 12153 BPF_LD_IMM64(R0, 0x0123456789acbdefULL), \ 12154 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 12155 BPF_ST_MEM(BPF_W, R10, -4, 0), \ 12156 BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4), \ 12157 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 12158 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 12159 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 12160 BPF_ALU64_REG(BPF_OR, R0, R1), \ 12161 BPF_EXIT_INSN(), \ 12162 }, \ 12163 INTERNAL, \ 12164 { }, \ 12165 { { 0, 0 } }, \ 12166 .stack_depth = 8, \ 12167 } 12168 BPF_ATOMIC32_SRC_ZEXT(ADD), 12169 BPF_ATOMIC32_SRC_ZEXT(AND), 12170 BPF_ATOMIC32_SRC_ZEXT(OR), 12171 BPF_ATOMIC32_SRC_ZEXT(XOR), 12172#undef BPF_ATOMIC32_SRC_ZEXT 12173 /* Checking that CMPXCHG32 src is not zero extended in place */ 12174 { 12175 "ATOMIC_W_CMPXCHG: src preserved in zext", 12176 .u.insns_int = { 12177 BPF_LD_IMM64(R1, 0x0123456789acbdefULL), 12178 BPF_ALU64_REG(BPF_MOV, R2, R1), 12179 BPF_ALU64_REG(BPF_MOV, R0, 0), 12180 BPF_ST_MEM(BPF_W, R10, -4, 0), 12181 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4), 12182 BPF_ALU64_REG(BPF_SUB, R1, R2), 12183 BPF_ALU64_REG(BPF_MOV, R2, R1), 12184 BPF_ALU64_IMM(BPF_RSH, R2, 32), 12185 BPF_ALU64_REG(BPF_OR, R1, R2), 12186 BPF_ALU64_REG(BPF_MOV, R0, R1), 12187 BPF_EXIT_INSN(), 12188 }, 12189 INTERNAL, 12190 { }, 12191 { { 0, 0 } }, 12192 .stack_depth = 8, 12193 }, 12194 /* Checking that JMP32 immediate src is not zero extended in place */ 12195#define BPF_JMP32_IMM_ZEXT(op) \ 12196 { \ 12197 "JMP32_" #op "_K: operand preserved in zext", \ 12198 .u.insns_int = { \ 12199 BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\ 12200 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 12201 BPF_JMP32_IMM(BPF_##op, R0, 1234, 1), \ 12202 BPF_JMP_A(0), /* Nop */ \ 12203 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 12204 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 12205 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 12206 BPF_ALU64_REG(BPF_OR, R0, R1), \ 12207 BPF_EXIT_INSN(), \ 12208 }, \ 12209 INTERNAL, \ 12210 { }, \ 12211 { { 0, 0 } }, \ 12212 } 12213 BPF_JMP32_IMM_ZEXT(JEQ), 12214 BPF_JMP32_IMM_ZEXT(JNE), 12215 BPF_JMP32_IMM_ZEXT(JSET), 12216 BPF_JMP32_IMM_ZEXT(JGT), 12217 BPF_JMP32_IMM_ZEXT(JGE), 12218 BPF_JMP32_IMM_ZEXT(JLT), 12219 BPF_JMP32_IMM_ZEXT(JLE), 12220 BPF_JMP32_IMM_ZEXT(JSGT), 12221 BPF_JMP32_IMM_ZEXT(JSGE), 12222 BPF_JMP32_IMM_ZEXT(JSLT), 12223 BPF_JMP32_IMM_ZEXT(JSLE), 12224#undef BPF_JMP2_IMM_ZEXT 12225 /* Checking that JMP32 dst & src are not zero extended in place */ 12226#define BPF_JMP32_REG_ZEXT(op) \ 12227 { \ 12228 "JMP32_" #op "_X: operands preserved in zext", \ 12229 .u.insns_int = { \ 12230 BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\ 12231 BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\ 12232 BPF_ALU64_REG(BPF_MOV, R2, R0), \ 12233 BPF_ALU64_REG(BPF_MOV, R3, R1), \ 12234 BPF_JMP32_IMM(BPF_##op, R0, R1, 1), \ 12235 BPF_JMP_A(0), /* Nop */ \ 12236 BPF_ALU64_REG(BPF_SUB, R0, R2), \ 12237 BPF_ALU64_REG(BPF_SUB, R1, R3), \ 12238 BPF_ALU64_REG(BPF_OR, R0, R1), \ 12239 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 12240 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 12241 BPF_ALU64_REG(BPF_OR, R0, R1), \ 12242 BPF_EXIT_INSN(), \ 12243 }, \ 12244 INTERNAL, \ 12245 { }, \ 12246 { { 0, 0 } }, \ 12247 } 12248 BPF_JMP32_REG_ZEXT(JEQ), 12249 BPF_JMP32_REG_ZEXT(JNE), 12250 BPF_JMP32_REG_ZEXT(JSET), 12251 BPF_JMP32_REG_ZEXT(JGT), 12252 BPF_JMP32_REG_ZEXT(JGE), 12253 BPF_JMP32_REG_ZEXT(JLT), 12254 BPF_JMP32_REG_ZEXT(JLE), 12255 BPF_JMP32_REG_ZEXT(JSGT), 12256 BPF_JMP32_REG_ZEXT(JSGE), 12257 BPF_JMP32_REG_ZEXT(JSLT), 12258 BPF_JMP32_REG_ZEXT(JSLE), 12259#undef BPF_JMP2_REG_ZEXT 12260 /* ALU64 K register combinations */ 12261 { 12262 "ALU64_MOV_K: registers", 12263 { }, 12264 INTERNAL, 12265 { }, 12266 { { 0, 1 } }, 12267 .fill_helper = bpf_fill_alu64_mov_imm_regs, 12268 }, 12269 { 12270 "ALU64_AND_K: registers", 12271 { }, 12272 INTERNAL, 12273 { }, 12274 { { 0, 1 } }, 12275 .fill_helper = bpf_fill_alu64_and_imm_regs, 12276 }, 12277 { 12278 "ALU64_OR_K: registers", 12279 { }, 12280 INTERNAL, 12281 { }, 12282 { { 0, 1 } }, 12283 .fill_helper = bpf_fill_alu64_or_imm_regs, 12284 }, 12285 { 12286 "ALU64_XOR_K: registers", 12287 { }, 12288 INTERNAL, 12289 { }, 12290 { { 0, 1 } }, 12291 .fill_helper = bpf_fill_alu64_xor_imm_regs, 12292 }, 12293 { 12294 "ALU64_LSH_K: registers", 12295 { }, 12296 INTERNAL, 12297 { }, 12298 { { 0, 1 } }, 12299 .fill_helper = bpf_fill_alu64_lsh_imm_regs, 12300 }, 12301 { 12302 "ALU64_RSH_K: registers", 12303 { }, 12304 INTERNAL, 12305 { }, 12306 { { 0, 1 } }, 12307 .fill_helper = bpf_fill_alu64_rsh_imm_regs, 12308 }, 12309 { 12310 "ALU64_ARSH_K: registers", 12311 { }, 12312 INTERNAL, 12313 { }, 12314 { { 0, 1 } }, 12315 .fill_helper = bpf_fill_alu64_arsh_imm_regs, 12316 }, 12317 { 12318 "ALU64_ADD_K: registers", 12319 { }, 12320 INTERNAL, 12321 { }, 12322 { { 0, 1 } }, 12323 .fill_helper = bpf_fill_alu64_add_imm_regs, 12324 }, 12325 { 12326 "ALU64_SUB_K: registers", 12327 { }, 12328 INTERNAL, 12329 { }, 12330 { { 0, 1 } }, 12331 .fill_helper = bpf_fill_alu64_sub_imm_regs, 12332 }, 12333 { 12334 "ALU64_MUL_K: registers", 12335 { }, 12336 INTERNAL, 12337 { }, 12338 { { 0, 1 } }, 12339 .fill_helper = bpf_fill_alu64_mul_imm_regs, 12340 }, 12341 { 12342 "ALU64_DIV_K: registers", 12343 { }, 12344 INTERNAL, 12345 { }, 12346 { { 0, 1 } }, 12347 .fill_helper = bpf_fill_alu64_div_imm_regs, 12348 }, 12349 { 12350 "ALU64_MOD_K: registers", 12351 { }, 12352 INTERNAL, 12353 { }, 12354 { { 0, 1 } }, 12355 .fill_helper = bpf_fill_alu64_mod_imm_regs, 12356 }, 12357 /* ALU32 K registers */ 12358 { 12359 "ALU32_MOV_K: registers", 12360 { }, 12361 INTERNAL, 12362 { }, 12363 { { 0, 1 } }, 12364 .fill_helper = bpf_fill_alu32_mov_imm_regs, 12365 }, 12366 { 12367 "ALU32_AND_K: registers", 12368 { }, 12369 INTERNAL, 12370 { }, 12371 { { 0, 1 } }, 12372 .fill_helper = bpf_fill_alu32_and_imm_regs, 12373 }, 12374 { 12375 "ALU32_OR_K: registers", 12376 { }, 12377 INTERNAL, 12378 { }, 12379 { { 0, 1 } }, 12380 .fill_helper = bpf_fill_alu32_or_imm_regs, 12381 }, 12382 { 12383 "ALU32_XOR_K: registers", 12384 { }, 12385 INTERNAL, 12386 { }, 12387 { { 0, 1 } }, 12388 .fill_helper = bpf_fill_alu32_xor_imm_regs, 12389 }, 12390 { 12391 "ALU32_LSH_K: registers", 12392 { }, 12393 INTERNAL, 12394 { }, 12395 { { 0, 1 } }, 12396 .fill_helper = bpf_fill_alu32_lsh_imm_regs, 12397 }, 12398 { 12399 "ALU32_RSH_K: registers", 12400 { }, 12401 INTERNAL, 12402 { }, 12403 { { 0, 1 } }, 12404 .fill_helper = bpf_fill_alu32_rsh_imm_regs, 12405 }, 12406 { 12407 "ALU32_ARSH_K: registers", 12408 { }, 12409 INTERNAL, 12410 { }, 12411 { { 0, 1 } }, 12412 .fill_helper = bpf_fill_alu32_arsh_imm_regs, 12413 }, 12414 { 12415 "ALU32_ADD_K: registers", 12416 { }, 12417 INTERNAL, 12418 { }, 12419 { { 0, 1 } }, 12420 .fill_helper = bpf_fill_alu32_add_imm_regs, 12421 }, 12422 { 12423 "ALU32_SUB_K: registers", 12424 { }, 12425 INTERNAL, 12426 { }, 12427 { { 0, 1 } }, 12428 .fill_helper = bpf_fill_alu32_sub_imm_regs, 12429 }, 12430 { 12431 "ALU32_MUL_K: registers", 12432 { }, 12433 INTERNAL, 12434 { }, 12435 { { 0, 1 } }, 12436 .fill_helper = bpf_fill_alu32_mul_imm_regs, 12437 }, 12438 { 12439 "ALU32_DIV_K: registers", 12440 { }, 12441 INTERNAL, 12442 { }, 12443 { { 0, 1 } }, 12444 .fill_helper = bpf_fill_alu32_div_imm_regs, 12445 }, 12446 { 12447 "ALU32_MOD_K: registers", 12448 { }, 12449 INTERNAL, 12450 { }, 12451 { { 0, 1 } }, 12452 .fill_helper = bpf_fill_alu32_mod_imm_regs, 12453 }, 12454 /* ALU64 X register combinations */ 12455 { 12456 "ALU64_MOV_X: register combinations", 12457 { }, 12458 INTERNAL, 12459 { }, 12460 { { 0, 1 } }, 12461 .fill_helper = bpf_fill_alu64_mov_reg_pairs, 12462 }, 12463 { 12464 "ALU64_AND_X: register combinations", 12465 { }, 12466 INTERNAL, 12467 { }, 12468 { { 0, 1 } }, 12469 .fill_helper = bpf_fill_alu64_and_reg_pairs, 12470 }, 12471 { 12472 "ALU64_OR_X: register combinations", 12473 { }, 12474 INTERNAL, 12475 { }, 12476 { { 0, 1 } }, 12477 .fill_helper = bpf_fill_alu64_or_reg_pairs, 12478 }, 12479 { 12480 "ALU64_XOR_X: register combinations", 12481 { }, 12482 INTERNAL, 12483 { }, 12484 { { 0, 1 } }, 12485 .fill_helper = bpf_fill_alu64_xor_reg_pairs, 12486 }, 12487 { 12488 "ALU64_LSH_X: register combinations", 12489 { }, 12490 INTERNAL, 12491 { }, 12492 { { 0, 1 } }, 12493 .fill_helper = bpf_fill_alu64_lsh_reg_pairs, 12494 }, 12495 { 12496 "ALU64_RSH_X: register combinations", 12497 { }, 12498 INTERNAL, 12499 { }, 12500 { { 0, 1 } }, 12501 .fill_helper = bpf_fill_alu64_rsh_reg_pairs, 12502 }, 12503 { 12504 "ALU64_ARSH_X: register combinations", 12505 { }, 12506 INTERNAL, 12507 { }, 12508 { { 0, 1 } }, 12509 .fill_helper = bpf_fill_alu64_arsh_reg_pairs, 12510 }, 12511 { 12512 "ALU64_ADD_X: register combinations", 12513 { }, 12514 INTERNAL, 12515 { }, 12516 { { 0, 1 } }, 12517 .fill_helper = bpf_fill_alu64_add_reg_pairs, 12518 }, 12519 { 12520 "ALU64_SUB_X: register combinations", 12521 { }, 12522 INTERNAL, 12523 { }, 12524 { { 0, 1 } }, 12525 .fill_helper = bpf_fill_alu64_sub_reg_pairs, 12526 }, 12527 { 12528 "ALU64_MUL_X: register combinations", 12529 { }, 12530 INTERNAL, 12531 { }, 12532 { { 0, 1 } }, 12533 .fill_helper = bpf_fill_alu64_mul_reg_pairs, 12534 }, 12535 { 12536 "ALU64_DIV_X: register combinations", 12537 { }, 12538 INTERNAL, 12539 { }, 12540 { { 0, 1 } }, 12541 .fill_helper = bpf_fill_alu64_div_reg_pairs, 12542 }, 12543 { 12544 "ALU64_MOD_X: register combinations", 12545 { }, 12546 INTERNAL, 12547 { }, 12548 { { 0, 1 } }, 12549 .fill_helper = bpf_fill_alu64_mod_reg_pairs, 12550 }, 12551 /* ALU32 X register combinations */ 12552 { 12553 "ALU32_MOV_X: register combinations", 12554 { }, 12555 INTERNAL, 12556 { }, 12557 { { 0, 1 } }, 12558 .fill_helper = bpf_fill_alu32_mov_reg_pairs, 12559 }, 12560 { 12561 "ALU32_AND_X: register combinations", 12562 { }, 12563 INTERNAL, 12564 { }, 12565 { { 0, 1 } }, 12566 .fill_helper = bpf_fill_alu32_and_reg_pairs, 12567 }, 12568 { 12569 "ALU32_OR_X: register combinations", 12570 { }, 12571 INTERNAL, 12572 { }, 12573 { { 0, 1 } }, 12574 .fill_helper = bpf_fill_alu32_or_reg_pairs, 12575 }, 12576 { 12577 "ALU32_XOR_X: register combinations", 12578 { }, 12579 INTERNAL, 12580 { }, 12581 { { 0, 1 } }, 12582 .fill_helper = bpf_fill_alu32_xor_reg_pairs, 12583 }, 12584 { 12585 "ALU32_LSH_X: register combinations", 12586 { }, 12587 INTERNAL, 12588 { }, 12589 { { 0, 1 } }, 12590 .fill_helper = bpf_fill_alu32_lsh_reg_pairs, 12591 }, 12592 { 12593 "ALU32_RSH_X: register combinations", 12594 { }, 12595 INTERNAL, 12596 { }, 12597 { { 0, 1 } }, 12598 .fill_helper = bpf_fill_alu32_rsh_reg_pairs, 12599 }, 12600 { 12601 "ALU32_ARSH_X: register combinations", 12602 { }, 12603 INTERNAL, 12604 { }, 12605 { { 0, 1 } }, 12606 .fill_helper = bpf_fill_alu32_arsh_reg_pairs, 12607 }, 12608 { 12609 "ALU32_ADD_X: register combinations", 12610 { }, 12611 INTERNAL, 12612 { }, 12613 { { 0, 1 } }, 12614 .fill_helper = bpf_fill_alu32_add_reg_pairs, 12615 }, 12616 { 12617 "ALU32_SUB_X: register combinations", 12618 { }, 12619 INTERNAL, 12620 { }, 12621 { { 0, 1 } }, 12622 .fill_helper = bpf_fill_alu32_sub_reg_pairs, 12623 }, 12624 { 12625 "ALU32_MUL_X: register combinations", 12626 { }, 12627 INTERNAL, 12628 { }, 12629 { { 0, 1 } }, 12630 .fill_helper = bpf_fill_alu32_mul_reg_pairs, 12631 }, 12632 { 12633 "ALU32_DIV_X: register combinations", 12634 { }, 12635 INTERNAL, 12636 { }, 12637 { { 0, 1 } }, 12638 .fill_helper = bpf_fill_alu32_div_reg_pairs, 12639 }, 12640 { 12641 "ALU32_MOD_X register combinations", 12642 { }, 12643 INTERNAL, 12644 { }, 12645 { { 0, 1 } }, 12646 .fill_helper = bpf_fill_alu32_mod_reg_pairs, 12647 }, 12648 /* Exhaustive test of ALU64 shift operations */ 12649 { 12650 "ALU64_LSH_K: all shift values", 12651 { }, 12652 INTERNAL | FLAG_NO_DATA, 12653 { }, 12654 { { 0, 1 } }, 12655 .fill_helper = bpf_fill_alu64_lsh_imm, 12656 }, 12657 { 12658 "ALU64_RSH_K: all shift values", 12659 { }, 12660 INTERNAL | FLAG_NO_DATA, 12661 { }, 12662 { { 0, 1 } }, 12663 .fill_helper = bpf_fill_alu64_rsh_imm, 12664 }, 12665 { 12666 "ALU64_ARSH_K: all shift values", 12667 { }, 12668 INTERNAL | FLAG_NO_DATA, 12669 { }, 12670 { { 0, 1 } }, 12671 .fill_helper = bpf_fill_alu64_arsh_imm, 12672 }, 12673 { 12674 "ALU64_LSH_X: all shift values", 12675 { }, 12676 INTERNAL | FLAG_NO_DATA, 12677 { }, 12678 { { 0, 1 } }, 12679 .fill_helper = bpf_fill_alu64_lsh_reg, 12680 }, 12681 { 12682 "ALU64_RSH_X: all shift values", 12683 { }, 12684 INTERNAL | FLAG_NO_DATA, 12685 { }, 12686 { { 0, 1 } }, 12687 .fill_helper = bpf_fill_alu64_rsh_reg, 12688 }, 12689 { 12690 "ALU64_ARSH_X: all shift values", 12691 { }, 12692 INTERNAL | FLAG_NO_DATA, 12693 { }, 12694 { { 0, 1 } }, 12695 .fill_helper = bpf_fill_alu64_arsh_reg, 12696 }, 12697 /* Exhaustive test of ALU32 shift operations */ 12698 { 12699 "ALU32_LSH_K: all shift values", 12700 { }, 12701 INTERNAL | FLAG_NO_DATA, 12702 { }, 12703 { { 0, 1 } }, 12704 .fill_helper = bpf_fill_alu32_lsh_imm, 12705 }, 12706 { 12707 "ALU32_RSH_K: all shift values", 12708 { }, 12709 INTERNAL | FLAG_NO_DATA, 12710 { }, 12711 { { 0, 1 } }, 12712 .fill_helper = bpf_fill_alu32_rsh_imm, 12713 }, 12714 { 12715 "ALU32_ARSH_K: all shift values", 12716 { }, 12717 INTERNAL | FLAG_NO_DATA, 12718 { }, 12719 { { 0, 1 } }, 12720 .fill_helper = bpf_fill_alu32_arsh_imm, 12721 }, 12722 { 12723 "ALU32_LSH_X: all shift values", 12724 { }, 12725 INTERNAL | FLAG_NO_DATA, 12726 { }, 12727 { { 0, 1 } }, 12728 .fill_helper = bpf_fill_alu32_lsh_reg, 12729 }, 12730 { 12731 "ALU32_RSH_X: all shift values", 12732 { }, 12733 INTERNAL | FLAG_NO_DATA, 12734 { }, 12735 { { 0, 1 } }, 12736 .fill_helper = bpf_fill_alu32_rsh_reg, 12737 }, 12738 { 12739 "ALU32_ARSH_X: all shift values", 12740 { }, 12741 INTERNAL | FLAG_NO_DATA, 12742 { }, 12743 { { 0, 1 } }, 12744 .fill_helper = bpf_fill_alu32_arsh_reg, 12745 }, 12746 /* 12747 * Exhaustive test of ALU64 shift operations when 12748 * source and destination register are the same. 12749 */ 12750 { 12751 "ALU64_LSH_X: all shift values with the same register", 12752 { }, 12753 INTERNAL | FLAG_NO_DATA, 12754 { }, 12755 { { 0, 1 } }, 12756 .fill_helper = bpf_fill_alu64_lsh_same_reg, 12757 }, 12758 { 12759 "ALU64_RSH_X: all shift values with the same register", 12760 { }, 12761 INTERNAL | FLAG_NO_DATA, 12762 { }, 12763 { { 0, 1 } }, 12764 .fill_helper = bpf_fill_alu64_rsh_same_reg, 12765 }, 12766 { 12767 "ALU64_ARSH_X: all shift values with the same register", 12768 { }, 12769 INTERNAL | FLAG_NO_DATA, 12770 { }, 12771 { { 0, 1 } }, 12772 .fill_helper = bpf_fill_alu64_arsh_same_reg, 12773 }, 12774 /* 12775 * Exhaustive test of ALU32 shift operations when 12776 * source and destination register are the same. 12777 */ 12778 { 12779 "ALU32_LSH_X: all shift values with the same register", 12780 { }, 12781 INTERNAL | FLAG_NO_DATA, 12782 { }, 12783 { { 0, 1 } }, 12784 .fill_helper = bpf_fill_alu32_lsh_same_reg, 12785 }, 12786 { 12787 "ALU32_RSH_X: all shift values with the same register", 12788 { }, 12789 INTERNAL | FLAG_NO_DATA, 12790 { }, 12791 { { 0, 1 } }, 12792 .fill_helper = bpf_fill_alu32_rsh_same_reg, 12793 }, 12794 { 12795 "ALU32_ARSH_X: all shift values with the same register", 12796 { }, 12797 INTERNAL | FLAG_NO_DATA, 12798 { }, 12799 { { 0, 1 } }, 12800 .fill_helper = bpf_fill_alu32_arsh_same_reg, 12801 }, 12802 /* ALU64 immediate magnitudes */ 12803 { 12804 "ALU64_MOV_K: all immediate value magnitudes", 12805 { }, 12806 INTERNAL | FLAG_NO_DATA, 12807 { }, 12808 { { 0, 1 } }, 12809 .fill_helper = bpf_fill_alu64_mov_imm, 12810 .nr_testruns = NR_PATTERN_RUNS, 12811 }, 12812 { 12813 "ALU64_AND_K: all immediate value magnitudes", 12814 { }, 12815 INTERNAL | FLAG_NO_DATA, 12816 { }, 12817 { { 0, 1 } }, 12818 .fill_helper = bpf_fill_alu64_and_imm, 12819 .nr_testruns = NR_PATTERN_RUNS, 12820 }, 12821 { 12822 "ALU64_OR_K: all immediate value magnitudes", 12823 { }, 12824 INTERNAL | FLAG_NO_DATA, 12825 { }, 12826 { { 0, 1 } }, 12827 .fill_helper = bpf_fill_alu64_or_imm, 12828 .nr_testruns = NR_PATTERN_RUNS, 12829 }, 12830 { 12831 "ALU64_XOR_K: all immediate value magnitudes", 12832 { }, 12833 INTERNAL | FLAG_NO_DATA, 12834 { }, 12835 { { 0, 1 } }, 12836 .fill_helper = bpf_fill_alu64_xor_imm, 12837 .nr_testruns = NR_PATTERN_RUNS, 12838 }, 12839 { 12840 "ALU64_ADD_K: all immediate value magnitudes", 12841 { }, 12842 INTERNAL | FLAG_NO_DATA, 12843 { }, 12844 { { 0, 1 } }, 12845 .fill_helper = bpf_fill_alu64_add_imm, 12846 .nr_testruns = NR_PATTERN_RUNS, 12847 }, 12848 { 12849 "ALU64_SUB_K: all immediate value magnitudes", 12850 { }, 12851 INTERNAL | FLAG_NO_DATA, 12852 { }, 12853 { { 0, 1 } }, 12854 .fill_helper = bpf_fill_alu64_sub_imm, 12855 .nr_testruns = NR_PATTERN_RUNS, 12856 }, 12857 { 12858 "ALU64_MUL_K: all immediate value magnitudes", 12859 { }, 12860 INTERNAL | FLAG_NO_DATA, 12861 { }, 12862 { { 0, 1 } }, 12863 .fill_helper = bpf_fill_alu64_mul_imm, 12864 .nr_testruns = NR_PATTERN_RUNS, 12865 }, 12866 { 12867 "ALU64_DIV_K: all immediate value magnitudes", 12868 { }, 12869 INTERNAL | FLAG_NO_DATA, 12870 { }, 12871 { { 0, 1 } }, 12872 .fill_helper = bpf_fill_alu64_div_imm, 12873 .nr_testruns = NR_PATTERN_RUNS, 12874 }, 12875 { 12876 "ALU64_MOD_K: all immediate value magnitudes", 12877 { }, 12878 INTERNAL | FLAG_NO_DATA, 12879 { }, 12880 { { 0, 1 } }, 12881 .fill_helper = bpf_fill_alu64_mod_imm, 12882 .nr_testruns = NR_PATTERN_RUNS, 12883 }, 12884 /* ALU32 immediate magnitudes */ 12885 { 12886 "ALU32_MOV_K: all immediate value magnitudes", 12887 { }, 12888 INTERNAL | FLAG_NO_DATA, 12889 { }, 12890 { { 0, 1 } }, 12891 .fill_helper = bpf_fill_alu32_mov_imm, 12892 .nr_testruns = NR_PATTERN_RUNS, 12893 }, 12894 { 12895 "ALU32_AND_K: all immediate value magnitudes", 12896 { }, 12897 INTERNAL | FLAG_NO_DATA, 12898 { }, 12899 { { 0, 1 } }, 12900 .fill_helper = bpf_fill_alu32_and_imm, 12901 .nr_testruns = NR_PATTERN_RUNS, 12902 }, 12903 { 12904 "ALU32_OR_K: all immediate value magnitudes", 12905 { }, 12906 INTERNAL | FLAG_NO_DATA, 12907 { }, 12908 { { 0, 1 } }, 12909 .fill_helper = bpf_fill_alu32_or_imm, 12910 .nr_testruns = NR_PATTERN_RUNS, 12911 }, 12912 { 12913 "ALU32_XOR_K: all immediate value magnitudes", 12914 { }, 12915 INTERNAL | FLAG_NO_DATA, 12916 { }, 12917 { { 0, 1 } }, 12918 .fill_helper = bpf_fill_alu32_xor_imm, 12919 .nr_testruns = NR_PATTERN_RUNS, 12920 }, 12921 { 12922 "ALU32_ADD_K: all immediate value magnitudes", 12923 { }, 12924 INTERNAL | FLAG_NO_DATA, 12925 { }, 12926 { { 0, 1 } }, 12927 .fill_helper = bpf_fill_alu32_add_imm, 12928 .nr_testruns = NR_PATTERN_RUNS, 12929 }, 12930 { 12931 "ALU32_SUB_K: all immediate value magnitudes", 12932 { }, 12933 INTERNAL | FLAG_NO_DATA, 12934 { }, 12935 { { 0, 1 } }, 12936 .fill_helper = bpf_fill_alu32_sub_imm, 12937 .nr_testruns = NR_PATTERN_RUNS, 12938 }, 12939 { 12940 "ALU32_MUL_K: all immediate value magnitudes", 12941 { }, 12942 INTERNAL | FLAG_NO_DATA, 12943 { }, 12944 { { 0, 1 } }, 12945 .fill_helper = bpf_fill_alu32_mul_imm, 12946 .nr_testruns = NR_PATTERN_RUNS, 12947 }, 12948 { 12949 "ALU32_DIV_K: all immediate value magnitudes", 12950 { }, 12951 INTERNAL | FLAG_NO_DATA, 12952 { }, 12953 { { 0, 1 } }, 12954 .fill_helper = bpf_fill_alu32_div_imm, 12955 .nr_testruns = NR_PATTERN_RUNS, 12956 }, 12957 { 12958 "ALU32_MOD_K: all immediate value magnitudes", 12959 { }, 12960 INTERNAL | FLAG_NO_DATA, 12961 { }, 12962 { { 0, 1 } }, 12963 .fill_helper = bpf_fill_alu32_mod_imm, 12964 .nr_testruns = NR_PATTERN_RUNS, 12965 }, 12966 /* ALU64 register magnitudes */ 12967 { 12968 "ALU64_MOV_X: all register value magnitudes", 12969 { }, 12970 INTERNAL | FLAG_NO_DATA, 12971 { }, 12972 { { 0, 1 } }, 12973 .fill_helper = bpf_fill_alu64_mov_reg, 12974 .nr_testruns = NR_PATTERN_RUNS, 12975 }, 12976 { 12977 "ALU64_AND_X: all register value magnitudes", 12978 { }, 12979 INTERNAL | FLAG_NO_DATA, 12980 { }, 12981 { { 0, 1 } }, 12982 .fill_helper = bpf_fill_alu64_and_reg, 12983 .nr_testruns = NR_PATTERN_RUNS, 12984 }, 12985 { 12986 "ALU64_OR_X: all register value magnitudes", 12987 { }, 12988 INTERNAL | FLAG_NO_DATA, 12989 { }, 12990 { { 0, 1 } }, 12991 .fill_helper = bpf_fill_alu64_or_reg, 12992 .nr_testruns = NR_PATTERN_RUNS, 12993 }, 12994 { 12995 "ALU64_XOR_X: all register value magnitudes", 12996 { }, 12997 INTERNAL | FLAG_NO_DATA, 12998 { }, 12999 { { 0, 1 } }, 13000 .fill_helper = bpf_fill_alu64_xor_reg, 13001 .nr_testruns = NR_PATTERN_RUNS, 13002 }, 13003 { 13004 "ALU64_ADD_X: all register value magnitudes", 13005 { }, 13006 INTERNAL | FLAG_NO_DATA, 13007 { }, 13008 { { 0, 1 } }, 13009 .fill_helper = bpf_fill_alu64_add_reg, 13010 .nr_testruns = NR_PATTERN_RUNS, 13011 }, 13012 { 13013 "ALU64_SUB_X: all register value magnitudes", 13014 { }, 13015 INTERNAL | FLAG_NO_DATA, 13016 { }, 13017 { { 0, 1 } }, 13018 .fill_helper = bpf_fill_alu64_sub_reg, 13019 .nr_testruns = NR_PATTERN_RUNS, 13020 }, 13021 { 13022 "ALU64_MUL_X: all register value magnitudes", 13023 { }, 13024 INTERNAL | FLAG_NO_DATA, 13025 { }, 13026 { { 0, 1 } }, 13027 .fill_helper = bpf_fill_alu64_mul_reg, 13028 .nr_testruns = NR_PATTERN_RUNS, 13029 }, 13030 { 13031 "ALU64_DIV_X: all register value magnitudes", 13032 { }, 13033 INTERNAL | FLAG_NO_DATA, 13034 { }, 13035 { { 0, 1 } }, 13036 .fill_helper = bpf_fill_alu64_div_reg, 13037 .nr_testruns = NR_PATTERN_RUNS, 13038 }, 13039 { 13040 "ALU64_MOD_X: all register value magnitudes", 13041 { }, 13042 INTERNAL | FLAG_NO_DATA, 13043 { }, 13044 { { 0, 1 } }, 13045 .fill_helper = bpf_fill_alu64_mod_reg, 13046 .nr_testruns = NR_PATTERN_RUNS, 13047 }, 13048 /* ALU32 register magnitudes */ 13049 { 13050 "ALU32_MOV_X: all register value magnitudes", 13051 { }, 13052 INTERNAL | FLAG_NO_DATA, 13053 { }, 13054 { { 0, 1 } }, 13055 .fill_helper = bpf_fill_alu32_mov_reg, 13056 .nr_testruns = NR_PATTERN_RUNS, 13057 }, 13058 { 13059 "ALU32_AND_X: all register value magnitudes", 13060 { }, 13061 INTERNAL | FLAG_NO_DATA, 13062 { }, 13063 { { 0, 1 } }, 13064 .fill_helper = bpf_fill_alu32_and_reg, 13065 .nr_testruns = NR_PATTERN_RUNS, 13066 }, 13067 { 13068 "ALU32_OR_X: all register value magnitudes", 13069 { }, 13070 INTERNAL | FLAG_NO_DATA, 13071 { }, 13072 { { 0, 1 } }, 13073 .fill_helper = bpf_fill_alu32_or_reg, 13074 .nr_testruns = NR_PATTERN_RUNS, 13075 }, 13076 { 13077 "ALU32_XOR_X: all register value magnitudes", 13078 { }, 13079 INTERNAL | FLAG_NO_DATA, 13080 { }, 13081 { { 0, 1 } }, 13082 .fill_helper = bpf_fill_alu32_xor_reg, 13083 .nr_testruns = NR_PATTERN_RUNS, 13084 }, 13085 { 13086 "ALU32_ADD_X: all register value magnitudes", 13087 { }, 13088 INTERNAL | FLAG_NO_DATA, 13089 { }, 13090 { { 0, 1 } }, 13091 .fill_helper = bpf_fill_alu32_add_reg, 13092 .nr_testruns = NR_PATTERN_RUNS, 13093 }, 13094 { 13095 "ALU32_SUB_X: all register value magnitudes", 13096 { }, 13097 INTERNAL | FLAG_NO_DATA, 13098 { }, 13099 { { 0, 1 } }, 13100 .fill_helper = bpf_fill_alu32_sub_reg, 13101 .nr_testruns = NR_PATTERN_RUNS, 13102 }, 13103 { 13104 "ALU32_MUL_X: all register value magnitudes", 13105 { }, 13106 INTERNAL | FLAG_NO_DATA, 13107 { }, 13108 { { 0, 1 } }, 13109 .fill_helper = bpf_fill_alu32_mul_reg, 13110 .nr_testruns = NR_PATTERN_RUNS, 13111 }, 13112 { 13113 "ALU32_DIV_X: all register value magnitudes", 13114 { }, 13115 INTERNAL | FLAG_NO_DATA, 13116 { }, 13117 { { 0, 1 } }, 13118 .fill_helper = bpf_fill_alu32_div_reg, 13119 .nr_testruns = NR_PATTERN_RUNS, 13120 }, 13121 { 13122 "ALU32_MOD_X: all register value magnitudes", 13123 { }, 13124 INTERNAL | FLAG_NO_DATA, 13125 { }, 13126 { { 0, 1 } }, 13127 .fill_helper = bpf_fill_alu32_mod_reg, 13128 .nr_testruns = NR_PATTERN_RUNS, 13129 }, 13130 /* LD_IMM64 immediate magnitudes and byte patterns */ 13131 { 13132 "LD_IMM64: all immediate value magnitudes", 13133 { }, 13134 INTERNAL | FLAG_NO_DATA, 13135 { }, 13136 { { 0, 1 } }, 13137 .fill_helper = bpf_fill_ld_imm64_magn, 13138 }, 13139 { 13140 "LD_IMM64: checker byte patterns", 13141 { }, 13142 INTERNAL | FLAG_NO_DATA, 13143 { }, 13144 { { 0, 1 } }, 13145 .fill_helper = bpf_fill_ld_imm64_checker, 13146 }, 13147 { 13148 "LD_IMM64: random positive and zero byte patterns", 13149 { }, 13150 INTERNAL | FLAG_NO_DATA, 13151 { }, 13152 { { 0, 1 } }, 13153 .fill_helper = bpf_fill_ld_imm64_pos_zero, 13154 }, 13155 { 13156 "LD_IMM64: random negative and zero byte patterns", 13157 { }, 13158 INTERNAL | FLAG_NO_DATA, 13159 { }, 13160 { { 0, 1 } }, 13161 .fill_helper = bpf_fill_ld_imm64_neg_zero, 13162 }, 13163 { 13164 "LD_IMM64: random positive and negative byte patterns", 13165 { }, 13166 INTERNAL | FLAG_NO_DATA, 13167 { }, 13168 { { 0, 1 } }, 13169 .fill_helper = bpf_fill_ld_imm64_pos_neg, 13170 }, 13171 /* 64-bit ATOMIC register combinations */ 13172 { 13173 "ATOMIC_DW_ADD: register combinations", 13174 { }, 13175 INTERNAL, 13176 { }, 13177 { { 0, 1 } }, 13178 .fill_helper = bpf_fill_atomic64_add_reg_pairs, 13179 .stack_depth = 8, 13180 }, 13181 { 13182 "ATOMIC_DW_AND: register combinations", 13183 { }, 13184 INTERNAL, 13185 { }, 13186 { { 0, 1 } }, 13187 .fill_helper = bpf_fill_atomic64_and_reg_pairs, 13188 .stack_depth = 8, 13189 }, 13190 { 13191 "ATOMIC_DW_OR: register combinations", 13192 { }, 13193 INTERNAL, 13194 { }, 13195 { { 0, 1 } }, 13196 .fill_helper = bpf_fill_atomic64_or_reg_pairs, 13197 .stack_depth = 8, 13198 }, 13199 { 13200 "ATOMIC_DW_XOR: register combinations", 13201 { }, 13202 INTERNAL, 13203 { }, 13204 { { 0, 1 } }, 13205 .fill_helper = bpf_fill_atomic64_xor_reg_pairs, 13206 .stack_depth = 8, 13207 }, 13208 { 13209 "ATOMIC_DW_ADD_FETCH: register combinations", 13210 { }, 13211 INTERNAL, 13212 { }, 13213 { { 0, 1 } }, 13214 .fill_helper = bpf_fill_atomic64_add_fetch_reg_pairs, 13215 .stack_depth = 8, 13216 }, 13217 { 13218 "ATOMIC_DW_AND_FETCH: register combinations", 13219 { }, 13220 INTERNAL, 13221 { }, 13222 { { 0, 1 } }, 13223 .fill_helper = bpf_fill_atomic64_and_fetch_reg_pairs, 13224 .stack_depth = 8, 13225 }, 13226 { 13227 "ATOMIC_DW_OR_FETCH: register combinations", 13228 { }, 13229 INTERNAL, 13230 { }, 13231 { { 0, 1 } }, 13232 .fill_helper = bpf_fill_atomic64_or_fetch_reg_pairs, 13233 .stack_depth = 8, 13234 }, 13235 { 13236 "ATOMIC_DW_XOR_FETCH: register combinations", 13237 { }, 13238 INTERNAL, 13239 { }, 13240 { { 0, 1 } }, 13241 .fill_helper = bpf_fill_atomic64_xor_fetch_reg_pairs, 13242 .stack_depth = 8, 13243 }, 13244 { 13245 "ATOMIC_DW_XCHG: register combinations", 13246 { }, 13247 INTERNAL, 13248 { }, 13249 { { 0, 1 } }, 13250 .fill_helper = bpf_fill_atomic64_xchg_reg_pairs, 13251 .stack_depth = 8, 13252 }, 13253 { 13254 "ATOMIC_DW_CMPXCHG: register combinations", 13255 { }, 13256 INTERNAL, 13257 { }, 13258 { { 0, 1 } }, 13259 .fill_helper = bpf_fill_atomic64_cmpxchg_reg_pairs, 13260 .stack_depth = 8, 13261 }, 13262 /* 32-bit ATOMIC register combinations */ 13263 { 13264 "ATOMIC_W_ADD: register combinations", 13265 { }, 13266 INTERNAL, 13267 { }, 13268 { { 0, 1 } }, 13269 .fill_helper = bpf_fill_atomic32_add_reg_pairs, 13270 .stack_depth = 8, 13271 }, 13272 { 13273 "ATOMIC_W_AND: register combinations", 13274 { }, 13275 INTERNAL, 13276 { }, 13277 { { 0, 1 } }, 13278 .fill_helper = bpf_fill_atomic32_and_reg_pairs, 13279 .stack_depth = 8, 13280 }, 13281 { 13282 "ATOMIC_W_OR: register combinations", 13283 { }, 13284 INTERNAL, 13285 { }, 13286 { { 0, 1 } }, 13287 .fill_helper = bpf_fill_atomic32_or_reg_pairs, 13288 .stack_depth = 8, 13289 }, 13290 { 13291 "ATOMIC_W_XOR: register combinations", 13292 { }, 13293 INTERNAL, 13294 { }, 13295 { { 0, 1 } }, 13296 .fill_helper = bpf_fill_atomic32_xor_reg_pairs, 13297 .stack_depth = 8, 13298 }, 13299 { 13300 "ATOMIC_W_ADD_FETCH: register combinations", 13301 { }, 13302 INTERNAL, 13303 { }, 13304 { { 0, 1 } }, 13305 .fill_helper = bpf_fill_atomic32_add_fetch_reg_pairs, 13306 .stack_depth = 8, 13307 }, 13308 { 13309 "ATOMIC_W_AND_FETCH: register combinations", 13310 { }, 13311 INTERNAL, 13312 { }, 13313 { { 0, 1 } }, 13314 .fill_helper = bpf_fill_atomic32_and_fetch_reg_pairs, 13315 .stack_depth = 8, 13316 }, 13317 { 13318 "ATOMIC_W_OR_FETCH: register combinations", 13319 { }, 13320 INTERNAL, 13321 { }, 13322 { { 0, 1 } }, 13323 .fill_helper = bpf_fill_atomic32_or_fetch_reg_pairs, 13324 .stack_depth = 8, 13325 }, 13326 { 13327 "ATOMIC_W_XOR_FETCH: register combinations", 13328 { }, 13329 INTERNAL, 13330 { }, 13331 { { 0, 1 } }, 13332 .fill_helper = bpf_fill_atomic32_xor_fetch_reg_pairs, 13333 .stack_depth = 8, 13334 }, 13335 { 13336 "ATOMIC_W_XCHG: register combinations", 13337 { }, 13338 INTERNAL, 13339 { }, 13340 { { 0, 1 } }, 13341 .fill_helper = bpf_fill_atomic32_xchg_reg_pairs, 13342 .stack_depth = 8, 13343 }, 13344 { 13345 "ATOMIC_W_CMPXCHG: register combinations", 13346 { }, 13347 INTERNAL, 13348 { }, 13349 { { 0, 1 } }, 13350 .fill_helper = bpf_fill_atomic32_cmpxchg_reg_pairs, 13351 .stack_depth = 8, 13352 }, 13353 /* 64-bit ATOMIC magnitudes */ 13354 { 13355 "ATOMIC_DW_ADD: all operand magnitudes", 13356 { }, 13357 INTERNAL | FLAG_NO_DATA, 13358 { }, 13359 { { 0, 1 } }, 13360 .fill_helper = bpf_fill_atomic64_add, 13361 .stack_depth = 8, 13362 .nr_testruns = NR_PATTERN_RUNS, 13363 }, 13364 { 13365 "ATOMIC_DW_AND: all operand magnitudes", 13366 { }, 13367 INTERNAL | FLAG_NO_DATA, 13368 { }, 13369 { { 0, 1 } }, 13370 .fill_helper = bpf_fill_atomic64_and, 13371 .stack_depth = 8, 13372 .nr_testruns = NR_PATTERN_RUNS, 13373 }, 13374 { 13375 "ATOMIC_DW_OR: all operand magnitudes", 13376 { }, 13377 INTERNAL | FLAG_NO_DATA, 13378 { }, 13379 { { 0, 1 } }, 13380 .fill_helper = bpf_fill_atomic64_or, 13381 .stack_depth = 8, 13382 .nr_testruns = NR_PATTERN_RUNS, 13383 }, 13384 { 13385 "ATOMIC_DW_XOR: all operand magnitudes", 13386 { }, 13387 INTERNAL | FLAG_NO_DATA, 13388 { }, 13389 { { 0, 1 } }, 13390 .fill_helper = bpf_fill_atomic64_xor, 13391 .stack_depth = 8, 13392 .nr_testruns = NR_PATTERN_RUNS, 13393 }, 13394 { 13395 "ATOMIC_DW_ADD_FETCH: all operand magnitudes", 13396 { }, 13397 INTERNAL | FLAG_NO_DATA, 13398 { }, 13399 { { 0, 1 } }, 13400 .fill_helper = bpf_fill_atomic64_add_fetch, 13401 .stack_depth = 8, 13402 .nr_testruns = NR_PATTERN_RUNS, 13403 }, 13404 { 13405 "ATOMIC_DW_AND_FETCH: all operand magnitudes", 13406 { }, 13407 INTERNAL | FLAG_NO_DATA, 13408 { }, 13409 { { 0, 1 } }, 13410 .fill_helper = bpf_fill_atomic64_and_fetch, 13411 .stack_depth = 8, 13412 .nr_testruns = NR_PATTERN_RUNS, 13413 }, 13414 { 13415 "ATOMIC_DW_OR_FETCH: all operand magnitudes", 13416 { }, 13417 INTERNAL | FLAG_NO_DATA, 13418 { }, 13419 { { 0, 1 } }, 13420 .fill_helper = bpf_fill_atomic64_or_fetch, 13421 .stack_depth = 8, 13422 .nr_testruns = NR_PATTERN_RUNS, 13423 }, 13424 { 13425 "ATOMIC_DW_XOR_FETCH: all operand magnitudes", 13426 { }, 13427 INTERNAL | FLAG_NO_DATA, 13428 { }, 13429 { { 0, 1 } }, 13430 .fill_helper = bpf_fill_atomic64_xor_fetch, 13431 .stack_depth = 8, 13432 .nr_testruns = NR_PATTERN_RUNS, 13433 }, 13434 { 13435 "ATOMIC_DW_XCHG: all operand magnitudes", 13436 { }, 13437 INTERNAL | FLAG_NO_DATA, 13438 { }, 13439 { { 0, 1 } }, 13440 .fill_helper = bpf_fill_atomic64_xchg, 13441 .stack_depth = 8, 13442 .nr_testruns = NR_PATTERN_RUNS, 13443 }, 13444 { 13445 "ATOMIC_DW_CMPXCHG: all operand magnitudes", 13446 { }, 13447 INTERNAL | FLAG_NO_DATA, 13448 { }, 13449 { { 0, 1 } }, 13450 .fill_helper = bpf_fill_cmpxchg64, 13451 .stack_depth = 8, 13452 .nr_testruns = NR_PATTERN_RUNS, 13453 }, 13454 /* 32-bit atomic magnitudes */ 13455 { 13456 "ATOMIC_W_ADD: all operand magnitudes", 13457 { }, 13458 INTERNAL | FLAG_NO_DATA, 13459 { }, 13460 { { 0, 1 } }, 13461 .fill_helper = bpf_fill_atomic32_add, 13462 .stack_depth = 8, 13463 .nr_testruns = NR_PATTERN_RUNS, 13464 }, 13465 { 13466 "ATOMIC_W_AND: all operand magnitudes", 13467 { }, 13468 INTERNAL | FLAG_NO_DATA, 13469 { }, 13470 { { 0, 1 } }, 13471 .fill_helper = bpf_fill_atomic32_and, 13472 .stack_depth = 8, 13473 .nr_testruns = NR_PATTERN_RUNS, 13474 }, 13475 { 13476 "ATOMIC_W_OR: all operand magnitudes", 13477 { }, 13478 INTERNAL | FLAG_NO_DATA, 13479 { }, 13480 { { 0, 1 } }, 13481 .fill_helper = bpf_fill_atomic32_or, 13482 .stack_depth = 8, 13483 .nr_testruns = NR_PATTERN_RUNS, 13484 }, 13485 { 13486 "ATOMIC_W_XOR: all operand magnitudes", 13487 { }, 13488 INTERNAL | FLAG_NO_DATA, 13489 { }, 13490 { { 0, 1 } }, 13491 .fill_helper = bpf_fill_atomic32_xor, 13492 .stack_depth = 8, 13493 .nr_testruns = NR_PATTERN_RUNS, 13494 }, 13495 { 13496 "ATOMIC_W_ADD_FETCH: all operand magnitudes", 13497 { }, 13498 INTERNAL | FLAG_NO_DATA, 13499 { }, 13500 { { 0, 1 } }, 13501 .fill_helper = bpf_fill_atomic32_add_fetch, 13502 .stack_depth = 8, 13503 .nr_testruns = NR_PATTERN_RUNS, 13504 }, 13505 { 13506 "ATOMIC_W_AND_FETCH: all operand magnitudes", 13507 { }, 13508 INTERNAL | FLAG_NO_DATA, 13509 { }, 13510 { { 0, 1 } }, 13511 .fill_helper = bpf_fill_atomic32_and_fetch, 13512 .stack_depth = 8, 13513 .nr_testruns = NR_PATTERN_RUNS, 13514 }, 13515 { 13516 "ATOMIC_W_OR_FETCH: all operand magnitudes", 13517 { }, 13518 INTERNAL | FLAG_NO_DATA, 13519 { }, 13520 { { 0, 1 } }, 13521 .fill_helper = bpf_fill_atomic32_or_fetch, 13522 .stack_depth = 8, 13523 .nr_testruns = NR_PATTERN_RUNS, 13524 }, 13525 { 13526 "ATOMIC_W_XOR_FETCH: all operand magnitudes", 13527 { }, 13528 INTERNAL | FLAG_NO_DATA, 13529 { }, 13530 { { 0, 1 } }, 13531 .fill_helper = bpf_fill_atomic32_xor_fetch, 13532 .stack_depth = 8, 13533 .nr_testruns = NR_PATTERN_RUNS, 13534 }, 13535 { 13536 "ATOMIC_W_XCHG: all operand magnitudes", 13537 { }, 13538 INTERNAL | FLAG_NO_DATA, 13539 { }, 13540 { { 0, 1 } }, 13541 .fill_helper = bpf_fill_atomic32_xchg, 13542 .stack_depth = 8, 13543 .nr_testruns = NR_PATTERN_RUNS, 13544 }, 13545 { 13546 "ATOMIC_W_CMPXCHG: all operand magnitudes", 13547 { }, 13548 INTERNAL | FLAG_NO_DATA, 13549 { }, 13550 { { 0, 1 } }, 13551 .fill_helper = bpf_fill_cmpxchg32, 13552 .stack_depth = 8, 13553 .nr_testruns = NR_PATTERN_RUNS, 13554 }, 13555 /* JMP immediate magnitudes */ 13556 { 13557 "JMP_JSET_K: all immediate value magnitudes", 13558 { }, 13559 INTERNAL | FLAG_NO_DATA, 13560 { }, 13561 { { 0, 1 } }, 13562 .fill_helper = bpf_fill_jmp_jset_imm, 13563 .nr_testruns = NR_PATTERN_RUNS, 13564 }, 13565 { 13566 "JMP_JEQ_K: all immediate value magnitudes", 13567 { }, 13568 INTERNAL | FLAG_NO_DATA, 13569 { }, 13570 { { 0, 1 } }, 13571 .fill_helper = bpf_fill_jmp_jeq_imm, 13572 .nr_testruns = NR_PATTERN_RUNS, 13573 }, 13574 { 13575 "JMP_JNE_K: all immediate value magnitudes", 13576 { }, 13577 INTERNAL | FLAG_NO_DATA, 13578 { }, 13579 { { 0, 1 } }, 13580 .fill_helper = bpf_fill_jmp_jne_imm, 13581 .nr_testruns = NR_PATTERN_RUNS, 13582 }, 13583 { 13584 "JMP_JGT_K: all immediate value magnitudes", 13585 { }, 13586 INTERNAL | FLAG_NO_DATA, 13587 { }, 13588 { { 0, 1 } }, 13589 .fill_helper = bpf_fill_jmp_jgt_imm, 13590 .nr_testruns = NR_PATTERN_RUNS, 13591 }, 13592 { 13593 "JMP_JGE_K: all immediate value magnitudes", 13594 { }, 13595 INTERNAL | FLAG_NO_DATA, 13596 { }, 13597 { { 0, 1 } }, 13598 .fill_helper = bpf_fill_jmp_jge_imm, 13599 .nr_testruns = NR_PATTERN_RUNS, 13600 }, 13601 { 13602 "JMP_JLT_K: all immediate value magnitudes", 13603 { }, 13604 INTERNAL | FLAG_NO_DATA, 13605 { }, 13606 { { 0, 1 } }, 13607 .fill_helper = bpf_fill_jmp_jlt_imm, 13608 .nr_testruns = NR_PATTERN_RUNS, 13609 }, 13610 { 13611 "JMP_JLE_K: all immediate value magnitudes", 13612 { }, 13613 INTERNAL | FLAG_NO_DATA, 13614 { }, 13615 { { 0, 1 } }, 13616 .fill_helper = bpf_fill_jmp_jle_imm, 13617 .nr_testruns = NR_PATTERN_RUNS, 13618 }, 13619 { 13620 "JMP_JSGT_K: all immediate value magnitudes", 13621 { }, 13622 INTERNAL | FLAG_NO_DATA, 13623 { }, 13624 { { 0, 1 } }, 13625 .fill_helper = bpf_fill_jmp_jsgt_imm, 13626 .nr_testruns = NR_PATTERN_RUNS, 13627 }, 13628 { 13629 "JMP_JSGE_K: all immediate value magnitudes", 13630 { }, 13631 INTERNAL | FLAG_NO_DATA, 13632 { }, 13633 { { 0, 1 } }, 13634 .fill_helper = bpf_fill_jmp_jsge_imm, 13635 .nr_testruns = NR_PATTERN_RUNS, 13636 }, 13637 { 13638 "JMP_JSLT_K: all immediate value magnitudes", 13639 { }, 13640 INTERNAL | FLAG_NO_DATA, 13641 { }, 13642 { { 0, 1 } }, 13643 .fill_helper = bpf_fill_jmp_jslt_imm, 13644 .nr_testruns = NR_PATTERN_RUNS, 13645 }, 13646 { 13647 "JMP_JSLE_K: all immediate value magnitudes", 13648 { }, 13649 INTERNAL | FLAG_NO_DATA, 13650 { }, 13651 { { 0, 1 } }, 13652 .fill_helper = bpf_fill_jmp_jsle_imm, 13653 .nr_testruns = NR_PATTERN_RUNS, 13654 }, 13655 /* JMP register magnitudes */ 13656 { 13657 "JMP_JSET_X: all register value magnitudes", 13658 { }, 13659 INTERNAL | FLAG_NO_DATA, 13660 { }, 13661 { { 0, 1 } }, 13662 .fill_helper = bpf_fill_jmp_jset_reg, 13663 .nr_testruns = NR_PATTERN_RUNS, 13664 }, 13665 { 13666 "JMP_JEQ_X: all register value magnitudes", 13667 { }, 13668 INTERNAL | FLAG_NO_DATA, 13669 { }, 13670 { { 0, 1 } }, 13671 .fill_helper = bpf_fill_jmp_jeq_reg, 13672 .nr_testruns = NR_PATTERN_RUNS, 13673 }, 13674 { 13675 "JMP_JNE_X: all register value magnitudes", 13676 { }, 13677 INTERNAL | FLAG_NO_DATA, 13678 { }, 13679 { { 0, 1 } }, 13680 .fill_helper = bpf_fill_jmp_jne_reg, 13681 .nr_testruns = NR_PATTERN_RUNS, 13682 }, 13683 { 13684 "JMP_JGT_X: all register value magnitudes", 13685 { }, 13686 INTERNAL | FLAG_NO_DATA, 13687 { }, 13688 { { 0, 1 } }, 13689 .fill_helper = bpf_fill_jmp_jgt_reg, 13690 .nr_testruns = NR_PATTERN_RUNS, 13691 }, 13692 { 13693 "JMP_JGE_X: all register value magnitudes", 13694 { }, 13695 INTERNAL | FLAG_NO_DATA, 13696 { }, 13697 { { 0, 1 } }, 13698 .fill_helper = bpf_fill_jmp_jge_reg, 13699 .nr_testruns = NR_PATTERN_RUNS, 13700 }, 13701 { 13702 "JMP_JLT_X: all register value magnitudes", 13703 { }, 13704 INTERNAL | FLAG_NO_DATA, 13705 { }, 13706 { { 0, 1 } }, 13707 .fill_helper = bpf_fill_jmp_jlt_reg, 13708 .nr_testruns = NR_PATTERN_RUNS, 13709 }, 13710 { 13711 "JMP_JLE_X: all register value magnitudes", 13712 { }, 13713 INTERNAL | FLAG_NO_DATA, 13714 { }, 13715 { { 0, 1 } }, 13716 .fill_helper = bpf_fill_jmp_jle_reg, 13717 .nr_testruns = NR_PATTERN_RUNS, 13718 }, 13719 { 13720 "JMP_JSGT_X: all register value magnitudes", 13721 { }, 13722 INTERNAL | FLAG_NO_DATA, 13723 { }, 13724 { { 0, 1 } }, 13725 .fill_helper = bpf_fill_jmp_jsgt_reg, 13726 .nr_testruns = NR_PATTERN_RUNS, 13727 }, 13728 { 13729 "JMP_JSGE_X: all register value magnitudes", 13730 { }, 13731 INTERNAL | FLAG_NO_DATA, 13732 { }, 13733 { { 0, 1 } }, 13734 .fill_helper = bpf_fill_jmp_jsge_reg, 13735 .nr_testruns = NR_PATTERN_RUNS, 13736 }, 13737 { 13738 "JMP_JSLT_X: all register value magnitudes", 13739 { }, 13740 INTERNAL | FLAG_NO_DATA, 13741 { }, 13742 { { 0, 1 } }, 13743 .fill_helper = bpf_fill_jmp_jslt_reg, 13744 .nr_testruns = NR_PATTERN_RUNS, 13745 }, 13746 { 13747 "JMP_JSLE_X: all register value magnitudes", 13748 { }, 13749 INTERNAL | FLAG_NO_DATA, 13750 { }, 13751 { { 0, 1 } }, 13752 .fill_helper = bpf_fill_jmp_jsle_reg, 13753 .nr_testruns = NR_PATTERN_RUNS, 13754 }, 13755 /* JMP32 immediate magnitudes */ 13756 { 13757 "JMP32_JSET_K: all immediate value magnitudes", 13758 { }, 13759 INTERNAL | FLAG_NO_DATA, 13760 { }, 13761 { { 0, 1 } }, 13762 .fill_helper = bpf_fill_jmp32_jset_imm, 13763 .nr_testruns = NR_PATTERN_RUNS, 13764 }, 13765 { 13766 "JMP32_JEQ_K: all immediate value magnitudes", 13767 { }, 13768 INTERNAL | FLAG_NO_DATA, 13769 { }, 13770 { { 0, 1 } }, 13771 .fill_helper = bpf_fill_jmp32_jeq_imm, 13772 .nr_testruns = NR_PATTERN_RUNS, 13773 }, 13774 { 13775 "JMP32_JNE_K: all immediate value magnitudes", 13776 { }, 13777 INTERNAL | FLAG_NO_DATA, 13778 { }, 13779 { { 0, 1 } }, 13780 .fill_helper = bpf_fill_jmp32_jne_imm, 13781 .nr_testruns = NR_PATTERN_RUNS, 13782 }, 13783 { 13784 "JMP32_JGT_K: all immediate value magnitudes", 13785 { }, 13786 INTERNAL | FLAG_NO_DATA, 13787 { }, 13788 { { 0, 1 } }, 13789 .fill_helper = bpf_fill_jmp32_jgt_imm, 13790 .nr_testruns = NR_PATTERN_RUNS, 13791 }, 13792 { 13793 "JMP32_JGE_K: all immediate value magnitudes", 13794 { }, 13795 INTERNAL | FLAG_NO_DATA, 13796 { }, 13797 { { 0, 1 } }, 13798 .fill_helper = bpf_fill_jmp32_jge_imm, 13799 .nr_testruns = NR_PATTERN_RUNS, 13800 }, 13801 { 13802 "JMP32_JLT_K: all immediate value magnitudes", 13803 { }, 13804 INTERNAL | FLAG_NO_DATA, 13805 { }, 13806 { { 0, 1 } }, 13807 .fill_helper = bpf_fill_jmp32_jlt_imm, 13808 .nr_testruns = NR_PATTERN_RUNS, 13809 }, 13810 { 13811 "JMP32_JLE_K: all immediate value magnitudes", 13812 { }, 13813 INTERNAL | FLAG_NO_DATA, 13814 { }, 13815 { { 0, 1 } }, 13816 .fill_helper = bpf_fill_jmp32_jle_imm, 13817 .nr_testruns = NR_PATTERN_RUNS, 13818 }, 13819 { 13820 "JMP32_JSGT_K: all immediate value magnitudes", 13821 { }, 13822 INTERNAL | FLAG_NO_DATA, 13823 { }, 13824 { { 0, 1 } }, 13825 .fill_helper = bpf_fill_jmp32_jsgt_imm, 13826 .nr_testruns = NR_PATTERN_RUNS, 13827 }, 13828 { 13829 "JMP32_JSGE_K: all immediate value magnitudes", 13830 { }, 13831 INTERNAL | FLAG_NO_DATA, 13832 { }, 13833 { { 0, 1 } }, 13834 .fill_helper = bpf_fill_jmp32_jsge_imm, 13835 .nr_testruns = NR_PATTERN_RUNS, 13836 }, 13837 { 13838 "JMP32_JSLT_K: all immediate value magnitudes", 13839 { }, 13840 INTERNAL | FLAG_NO_DATA, 13841 { }, 13842 { { 0, 1 } }, 13843 .fill_helper = bpf_fill_jmp32_jslt_imm, 13844 .nr_testruns = NR_PATTERN_RUNS, 13845 }, 13846 { 13847 "JMP32_JSLE_K: all immediate value magnitudes", 13848 { }, 13849 INTERNAL | FLAG_NO_DATA, 13850 { }, 13851 { { 0, 1 } }, 13852 .fill_helper = bpf_fill_jmp32_jsle_imm, 13853 .nr_testruns = NR_PATTERN_RUNS, 13854 }, 13855 /* JMP32 register magnitudes */ 13856 { 13857 "JMP32_JSET_X: all register value magnitudes", 13858 { }, 13859 INTERNAL | FLAG_NO_DATA, 13860 { }, 13861 { { 0, 1 } }, 13862 .fill_helper = bpf_fill_jmp32_jset_reg, 13863 .nr_testruns = NR_PATTERN_RUNS, 13864 }, 13865 { 13866 "JMP32_JEQ_X: all register value magnitudes", 13867 { }, 13868 INTERNAL | FLAG_NO_DATA, 13869 { }, 13870 { { 0, 1 } }, 13871 .fill_helper = bpf_fill_jmp32_jeq_reg, 13872 .nr_testruns = NR_PATTERN_RUNS, 13873 }, 13874 { 13875 "JMP32_JNE_X: all register value magnitudes", 13876 { }, 13877 INTERNAL | FLAG_NO_DATA, 13878 { }, 13879 { { 0, 1 } }, 13880 .fill_helper = bpf_fill_jmp32_jne_reg, 13881 .nr_testruns = NR_PATTERN_RUNS, 13882 }, 13883 { 13884 "JMP32_JGT_X: all register value magnitudes", 13885 { }, 13886 INTERNAL | FLAG_NO_DATA, 13887 { }, 13888 { { 0, 1 } }, 13889 .fill_helper = bpf_fill_jmp32_jgt_reg, 13890 .nr_testruns = NR_PATTERN_RUNS, 13891 }, 13892 { 13893 "JMP32_JGE_X: all register value magnitudes", 13894 { }, 13895 INTERNAL | FLAG_NO_DATA, 13896 { }, 13897 { { 0, 1 } }, 13898 .fill_helper = bpf_fill_jmp32_jge_reg, 13899 .nr_testruns = NR_PATTERN_RUNS, 13900 }, 13901 { 13902 "JMP32_JLT_X: all register value magnitudes", 13903 { }, 13904 INTERNAL | FLAG_NO_DATA, 13905 { }, 13906 { { 0, 1 } }, 13907 .fill_helper = bpf_fill_jmp32_jlt_reg, 13908 .nr_testruns = NR_PATTERN_RUNS, 13909 }, 13910 { 13911 "JMP32_JLE_X: all register value magnitudes", 13912 { }, 13913 INTERNAL | FLAG_NO_DATA, 13914 { }, 13915 { { 0, 1 } }, 13916 .fill_helper = bpf_fill_jmp32_jle_reg, 13917 .nr_testruns = NR_PATTERN_RUNS, 13918 }, 13919 { 13920 "JMP32_JSGT_X: all register value magnitudes", 13921 { }, 13922 INTERNAL | FLAG_NO_DATA, 13923 { }, 13924 { { 0, 1 } }, 13925 .fill_helper = bpf_fill_jmp32_jsgt_reg, 13926 .nr_testruns = NR_PATTERN_RUNS, 13927 }, 13928 { 13929 "JMP32_JSGE_X: all register value magnitudes", 13930 { }, 13931 INTERNAL | FLAG_NO_DATA, 13932 { }, 13933 { { 0, 1 } }, 13934 .fill_helper = bpf_fill_jmp32_jsge_reg, 13935 .nr_testruns = NR_PATTERN_RUNS, 13936 }, 13937 { 13938 "JMP32_JSLT_X: all register value magnitudes", 13939 { }, 13940 INTERNAL | FLAG_NO_DATA, 13941 { }, 13942 { { 0, 1 } }, 13943 .fill_helper = bpf_fill_jmp32_jslt_reg, 13944 .nr_testruns = NR_PATTERN_RUNS, 13945 }, 13946 { 13947 "JMP32_JSLE_X: all register value magnitudes", 13948 { }, 13949 INTERNAL | FLAG_NO_DATA, 13950 { }, 13951 { { 0, 1 } }, 13952 .fill_helper = bpf_fill_jmp32_jsle_reg, 13953 .nr_testruns = NR_PATTERN_RUNS, 13954 }, 13955 /* Conditional jumps with constant decision */ 13956 { 13957 "JMP_JSET_K: imm = 0 -> never taken", 13958 .u.insns_int = { 13959 BPF_ALU64_IMM(BPF_MOV, R0, 1), 13960 BPF_JMP_IMM(BPF_JSET, R1, 0, 1), 13961 BPF_ALU64_IMM(BPF_MOV, R0, 0), 13962 BPF_EXIT_INSN(), 13963 }, 13964 INTERNAL | FLAG_NO_DATA, 13965 { }, 13966 { { 0, 0 } }, 13967 }, 13968 { 13969 "JMP_JLT_K: imm = 0 -> never taken", 13970 .u.insns_int = { 13971 BPF_ALU64_IMM(BPF_MOV, R0, 1), 13972 BPF_JMP_IMM(BPF_JLT, R1, 0, 1), 13973 BPF_ALU64_IMM(BPF_MOV, R0, 0), 13974 BPF_EXIT_INSN(), 13975 }, 13976 INTERNAL | FLAG_NO_DATA, 13977 { }, 13978 { { 0, 0 } }, 13979 }, 13980 { 13981 "JMP_JGE_K: imm = 0 -> always taken", 13982 .u.insns_int = { 13983 BPF_ALU64_IMM(BPF_MOV, R0, 1), 13984 BPF_JMP_IMM(BPF_JGE, R1, 0, 1), 13985 BPF_ALU64_IMM(BPF_MOV, R0, 0), 13986 BPF_EXIT_INSN(), 13987 }, 13988 INTERNAL | FLAG_NO_DATA, 13989 { }, 13990 { { 0, 1 } }, 13991 }, 13992 { 13993 "JMP_JGT_K: imm = 0xffffffff -> never taken", 13994 .u.insns_int = { 13995 BPF_ALU64_IMM(BPF_MOV, R0, 1), 13996 BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1), 13997 BPF_ALU64_IMM(BPF_MOV, R0, 0), 13998 BPF_EXIT_INSN(), 13999 }, 14000 INTERNAL | FLAG_NO_DATA, 14001 { }, 14002 { { 0, 0 } }, 14003 }, 14004 { 14005 "JMP_JLE_K: imm = 0xffffffff -> always taken", 14006 .u.insns_int = { 14007 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14008 BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1), 14009 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14010 BPF_EXIT_INSN(), 14011 }, 14012 INTERNAL | FLAG_NO_DATA, 14013 { }, 14014 { { 0, 1 } }, 14015 }, 14016 { 14017 "JMP32_JSGT_K: imm = 0x7fffffff -> never taken", 14018 .u.insns_int = { 14019 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14020 BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1), 14021 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14022 BPF_EXIT_INSN(), 14023 }, 14024 INTERNAL | FLAG_NO_DATA, 14025 { }, 14026 { { 0, 0 } }, 14027 }, 14028 { 14029 "JMP32_JSGE_K: imm = -0x80000000 -> always taken", 14030 .u.insns_int = { 14031 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14032 BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1), 14033 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14034 BPF_EXIT_INSN(), 14035 }, 14036 INTERNAL | FLAG_NO_DATA, 14037 { }, 14038 { { 0, 1 } }, 14039 }, 14040 { 14041 "JMP32_JSLT_K: imm = -0x80000000 -> never taken", 14042 .u.insns_int = { 14043 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14044 BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1), 14045 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14046 BPF_EXIT_INSN(), 14047 }, 14048 INTERNAL | FLAG_NO_DATA, 14049 { }, 14050 { { 0, 0 } }, 14051 }, 14052 { 14053 "JMP32_JSLE_K: imm = 0x7fffffff -> always taken", 14054 .u.insns_int = { 14055 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14056 BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1), 14057 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14058 BPF_EXIT_INSN(), 14059 }, 14060 INTERNAL | FLAG_NO_DATA, 14061 { }, 14062 { { 0, 1 } }, 14063 }, 14064 { 14065 "JMP_JEQ_X: dst = src -> always taken", 14066 .u.insns_int = { 14067 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14068 BPF_JMP_REG(BPF_JEQ, R1, R1, 1), 14069 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14070 BPF_EXIT_INSN(), 14071 }, 14072 INTERNAL | FLAG_NO_DATA, 14073 { }, 14074 { { 0, 1 } }, 14075 }, 14076 { 14077 "JMP_JGE_X: dst = src -> always taken", 14078 .u.insns_int = { 14079 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14080 BPF_JMP_REG(BPF_JGE, R1, R1, 1), 14081 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14082 BPF_EXIT_INSN(), 14083 }, 14084 INTERNAL | FLAG_NO_DATA, 14085 { }, 14086 { { 0, 1 } }, 14087 }, 14088 { 14089 "JMP_JLE_X: dst = src -> always taken", 14090 .u.insns_int = { 14091 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14092 BPF_JMP_REG(BPF_JLE, R1, R1, 1), 14093 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14094 BPF_EXIT_INSN(), 14095 }, 14096 INTERNAL | FLAG_NO_DATA, 14097 { }, 14098 { { 0, 1 } }, 14099 }, 14100 { 14101 "JMP_JSGE_X: dst = src -> always taken", 14102 .u.insns_int = { 14103 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14104 BPF_JMP_REG(BPF_JSGE, R1, R1, 1), 14105 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14106 BPF_EXIT_INSN(), 14107 }, 14108 INTERNAL | FLAG_NO_DATA, 14109 { }, 14110 { { 0, 1 } }, 14111 }, 14112 { 14113 "JMP_JSLE_X: dst = src -> always taken", 14114 .u.insns_int = { 14115 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14116 BPF_JMP_REG(BPF_JSLE, R1, R1, 1), 14117 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14118 BPF_EXIT_INSN(), 14119 }, 14120 INTERNAL | FLAG_NO_DATA, 14121 { }, 14122 { { 0, 1 } }, 14123 }, 14124 { 14125 "JMP_JNE_X: dst = src -> never taken", 14126 .u.insns_int = { 14127 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14128 BPF_JMP_REG(BPF_JNE, R1, R1, 1), 14129 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14130 BPF_EXIT_INSN(), 14131 }, 14132 INTERNAL | FLAG_NO_DATA, 14133 { }, 14134 { { 0, 0 } }, 14135 }, 14136 { 14137 "JMP_JGT_X: dst = src -> never taken", 14138 .u.insns_int = { 14139 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14140 BPF_JMP_REG(BPF_JGT, R1, R1, 1), 14141 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14142 BPF_EXIT_INSN(), 14143 }, 14144 INTERNAL | FLAG_NO_DATA, 14145 { }, 14146 { { 0, 0 } }, 14147 }, 14148 { 14149 "JMP_JLT_X: dst = src -> never taken", 14150 .u.insns_int = { 14151 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14152 BPF_JMP_REG(BPF_JLT, R1, R1, 1), 14153 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14154 BPF_EXIT_INSN(), 14155 }, 14156 INTERNAL | FLAG_NO_DATA, 14157 { }, 14158 { { 0, 0 } }, 14159 }, 14160 { 14161 "JMP_JSGT_X: dst = src -> never taken", 14162 .u.insns_int = { 14163 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14164 BPF_JMP_REG(BPF_JSGT, R1, R1, 1), 14165 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14166 BPF_EXIT_INSN(), 14167 }, 14168 INTERNAL | FLAG_NO_DATA, 14169 { }, 14170 { { 0, 0 } }, 14171 }, 14172 { 14173 "JMP_JSLT_X: dst = src -> never taken", 14174 .u.insns_int = { 14175 BPF_ALU64_IMM(BPF_MOV, R0, 1), 14176 BPF_JMP_REG(BPF_JSLT, R1, R1, 1), 14177 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14178 BPF_EXIT_INSN(), 14179 }, 14180 INTERNAL | FLAG_NO_DATA, 14181 { }, 14182 { { 0, 0 } }, 14183 }, 14184 /* Short relative jumps */ 14185 { 14186 "Short relative jump: offset=0", 14187 .u.insns_int = { 14188 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14189 BPF_JMP_IMM(BPF_JEQ, R0, 0, 0), 14190 BPF_EXIT_INSN(), 14191 BPF_ALU32_IMM(BPF_MOV, R0, -1), 14192 }, 14193 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 14194 { }, 14195 { { 0, 0 } }, 14196 }, 14197 { 14198 "Short relative jump: offset=1", 14199 .u.insns_int = { 14200 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14201 BPF_JMP_IMM(BPF_JEQ, R0, 0, 1), 14202 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14203 BPF_EXIT_INSN(), 14204 BPF_ALU32_IMM(BPF_MOV, R0, -1), 14205 }, 14206 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 14207 { }, 14208 { { 0, 0 } }, 14209 }, 14210 { 14211 "Short relative jump: offset=2", 14212 .u.insns_int = { 14213 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14214 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2), 14215 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14216 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14217 BPF_EXIT_INSN(), 14218 BPF_ALU32_IMM(BPF_MOV, R0, -1), 14219 }, 14220 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 14221 { }, 14222 { { 0, 0 } }, 14223 }, 14224 { 14225 "Short relative jump: offset=3", 14226 .u.insns_int = { 14227 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14228 BPF_JMP_IMM(BPF_JEQ, R0, 0, 3), 14229 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14230 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14231 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14232 BPF_EXIT_INSN(), 14233 BPF_ALU32_IMM(BPF_MOV, R0, -1), 14234 }, 14235 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 14236 { }, 14237 { { 0, 0 } }, 14238 }, 14239 { 14240 "Short relative jump: offset=4", 14241 .u.insns_int = { 14242 BPF_ALU64_IMM(BPF_MOV, R0, 0), 14243 BPF_JMP_IMM(BPF_JEQ, R0, 0, 4), 14244 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14245 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14246 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14247 BPF_ALU32_IMM(BPF_ADD, R0, 1), 14248 BPF_EXIT_INSN(), 14249 BPF_ALU32_IMM(BPF_MOV, R0, -1), 14250 }, 14251 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 14252 { }, 14253 { { 0, 0 } }, 14254 }, 14255 /* Conditional branch conversions */ 14256 { 14257 "Long conditional jump: taken at runtime (32 bits)", 14258 { }, 14259 INTERNAL | FLAG_NO_DATA, 14260 { }, 14261 { { 0, 1 } }, 14262 .fill_helper = bpf_fill_max_jmp_taken_32, 14263 }, 14264 { 14265 "Long conditional jump: not taken at runtime (32 bits)", 14266 { }, 14267 INTERNAL | FLAG_NO_DATA, 14268 { }, 14269 { { 0, 2 } }, 14270 .fill_helper = bpf_fill_max_jmp_not_taken_32, 14271 }, 14272 { 14273 "Long conditional jump: always taken, known at JIT time (32 bits)", 14274 { }, 14275 INTERNAL | FLAG_NO_DATA, 14276 { }, 14277 { { 0, 1 } }, 14278 .fill_helper = bpf_fill_max_jmp_always_taken_32, 14279 }, 14280 { 14281 "Long conditional jump: never taken, known at JIT time (32 bits)", 14282 { }, 14283 INTERNAL | FLAG_NO_DATA, 14284 { }, 14285 { { 0, 2 } }, 14286 .fill_helper = bpf_fill_max_jmp_never_taken_32, 14287 }, 14288 { 14289 "Long conditional jump: taken at runtime", 14290 { }, 14291 INTERNAL | FLAG_NO_DATA, 14292 { }, 14293 { { 0, 1 } }, 14294 .fill_helper = bpf_fill_max_jmp_taken, 14295 }, 14296 { 14297 "Long conditional jump: not taken at runtime", 14298 { }, 14299 INTERNAL | FLAG_NO_DATA, 14300 { }, 14301 { { 0, 2 } }, 14302 .fill_helper = bpf_fill_max_jmp_not_taken, 14303 }, 14304 { 14305 "Long conditional jump: always taken, known at JIT time", 14306 { }, 14307 INTERNAL | FLAG_NO_DATA, 14308 { }, 14309 { { 0, 1 } }, 14310 .fill_helper = bpf_fill_max_jmp_always_taken, 14311 }, 14312 { 14313 "Long conditional jump: never taken, known at JIT time", 14314 { }, 14315 INTERNAL | FLAG_NO_DATA, 14316 { }, 14317 { { 0, 2 } }, 14318 .fill_helper = bpf_fill_max_jmp_never_taken, 14319 }, 14320 /* Staggered jump sequences, immediate */ 14321 { 14322 "Staggered jumps: JMP_JA", 14323 { }, 14324 INTERNAL | FLAG_NO_DATA, 14325 { }, 14326 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14327 .fill_helper = bpf_fill_staggered_ja, 14328 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14329 }, 14330 { 14331 "Staggered jumps: JMP_JEQ_K", 14332 { }, 14333 INTERNAL | FLAG_NO_DATA, 14334 { }, 14335 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14336 .fill_helper = bpf_fill_staggered_jeq_imm, 14337 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14338 }, 14339 { 14340 "Staggered jumps: JMP_JNE_K", 14341 { }, 14342 INTERNAL | FLAG_NO_DATA, 14343 { }, 14344 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14345 .fill_helper = bpf_fill_staggered_jne_imm, 14346 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14347 }, 14348 { 14349 "Staggered jumps: JMP_JSET_K", 14350 { }, 14351 INTERNAL | FLAG_NO_DATA, 14352 { }, 14353 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14354 .fill_helper = bpf_fill_staggered_jset_imm, 14355 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14356 }, 14357 { 14358 "Staggered jumps: JMP_JGT_K", 14359 { }, 14360 INTERNAL | FLAG_NO_DATA, 14361 { }, 14362 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14363 .fill_helper = bpf_fill_staggered_jgt_imm, 14364 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14365 }, 14366 { 14367 "Staggered jumps: JMP_JGE_K", 14368 { }, 14369 INTERNAL | FLAG_NO_DATA, 14370 { }, 14371 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14372 .fill_helper = bpf_fill_staggered_jge_imm, 14373 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14374 }, 14375 { 14376 "Staggered jumps: JMP_JLT_K", 14377 { }, 14378 INTERNAL | FLAG_NO_DATA, 14379 { }, 14380 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14381 .fill_helper = bpf_fill_staggered_jlt_imm, 14382 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14383 }, 14384 { 14385 "Staggered jumps: JMP_JLE_K", 14386 { }, 14387 INTERNAL | FLAG_NO_DATA, 14388 { }, 14389 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14390 .fill_helper = bpf_fill_staggered_jle_imm, 14391 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14392 }, 14393 { 14394 "Staggered jumps: JMP_JSGT_K", 14395 { }, 14396 INTERNAL | FLAG_NO_DATA, 14397 { }, 14398 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14399 .fill_helper = bpf_fill_staggered_jsgt_imm, 14400 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14401 }, 14402 { 14403 "Staggered jumps: JMP_JSGE_K", 14404 { }, 14405 INTERNAL | FLAG_NO_DATA, 14406 { }, 14407 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14408 .fill_helper = bpf_fill_staggered_jsge_imm, 14409 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14410 }, 14411 { 14412 "Staggered jumps: JMP_JSLT_K", 14413 { }, 14414 INTERNAL | FLAG_NO_DATA, 14415 { }, 14416 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14417 .fill_helper = bpf_fill_staggered_jslt_imm, 14418 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14419 }, 14420 { 14421 "Staggered jumps: JMP_JSLE_K", 14422 { }, 14423 INTERNAL | FLAG_NO_DATA, 14424 { }, 14425 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14426 .fill_helper = bpf_fill_staggered_jsle_imm, 14427 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14428 }, 14429 /* Staggered jump sequences, register */ 14430 { 14431 "Staggered jumps: JMP_JEQ_X", 14432 { }, 14433 INTERNAL | FLAG_NO_DATA, 14434 { }, 14435 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14436 .fill_helper = bpf_fill_staggered_jeq_reg, 14437 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14438 }, 14439 { 14440 "Staggered jumps: JMP_JNE_X", 14441 { }, 14442 INTERNAL | FLAG_NO_DATA, 14443 { }, 14444 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14445 .fill_helper = bpf_fill_staggered_jne_reg, 14446 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14447 }, 14448 { 14449 "Staggered jumps: JMP_JSET_X", 14450 { }, 14451 INTERNAL | FLAG_NO_DATA, 14452 { }, 14453 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14454 .fill_helper = bpf_fill_staggered_jset_reg, 14455 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14456 }, 14457 { 14458 "Staggered jumps: JMP_JGT_X", 14459 { }, 14460 INTERNAL | FLAG_NO_DATA, 14461 { }, 14462 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14463 .fill_helper = bpf_fill_staggered_jgt_reg, 14464 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14465 }, 14466 { 14467 "Staggered jumps: JMP_JGE_X", 14468 { }, 14469 INTERNAL | FLAG_NO_DATA, 14470 { }, 14471 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14472 .fill_helper = bpf_fill_staggered_jge_reg, 14473 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14474 }, 14475 { 14476 "Staggered jumps: JMP_JLT_X", 14477 { }, 14478 INTERNAL | FLAG_NO_DATA, 14479 { }, 14480 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14481 .fill_helper = bpf_fill_staggered_jlt_reg, 14482 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14483 }, 14484 { 14485 "Staggered jumps: JMP_JLE_X", 14486 { }, 14487 INTERNAL | FLAG_NO_DATA, 14488 { }, 14489 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14490 .fill_helper = bpf_fill_staggered_jle_reg, 14491 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14492 }, 14493 { 14494 "Staggered jumps: JMP_JSGT_X", 14495 { }, 14496 INTERNAL | FLAG_NO_DATA, 14497 { }, 14498 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14499 .fill_helper = bpf_fill_staggered_jsgt_reg, 14500 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14501 }, 14502 { 14503 "Staggered jumps: JMP_JSGE_X", 14504 { }, 14505 INTERNAL | FLAG_NO_DATA, 14506 { }, 14507 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14508 .fill_helper = bpf_fill_staggered_jsge_reg, 14509 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14510 }, 14511 { 14512 "Staggered jumps: JMP_JSLT_X", 14513 { }, 14514 INTERNAL | FLAG_NO_DATA, 14515 { }, 14516 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14517 .fill_helper = bpf_fill_staggered_jslt_reg, 14518 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14519 }, 14520 { 14521 "Staggered jumps: JMP_JSLE_X", 14522 { }, 14523 INTERNAL | FLAG_NO_DATA, 14524 { }, 14525 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14526 .fill_helper = bpf_fill_staggered_jsle_reg, 14527 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14528 }, 14529 /* Staggered jump sequences, JMP32 immediate */ 14530 { 14531 "Staggered jumps: JMP32_JEQ_K", 14532 { }, 14533 INTERNAL | FLAG_NO_DATA, 14534 { }, 14535 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14536 .fill_helper = bpf_fill_staggered_jeq32_imm, 14537 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14538 }, 14539 { 14540 "Staggered jumps: JMP32_JNE_K", 14541 { }, 14542 INTERNAL | FLAG_NO_DATA, 14543 { }, 14544 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14545 .fill_helper = bpf_fill_staggered_jne32_imm, 14546 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14547 }, 14548 { 14549 "Staggered jumps: JMP32_JSET_K", 14550 { }, 14551 INTERNAL | FLAG_NO_DATA, 14552 { }, 14553 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14554 .fill_helper = bpf_fill_staggered_jset32_imm, 14555 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14556 }, 14557 { 14558 "Staggered jumps: JMP32_JGT_K", 14559 { }, 14560 INTERNAL | FLAG_NO_DATA, 14561 { }, 14562 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14563 .fill_helper = bpf_fill_staggered_jgt32_imm, 14564 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14565 }, 14566 { 14567 "Staggered jumps: JMP32_JGE_K", 14568 { }, 14569 INTERNAL | FLAG_NO_DATA, 14570 { }, 14571 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14572 .fill_helper = bpf_fill_staggered_jge32_imm, 14573 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14574 }, 14575 { 14576 "Staggered jumps: JMP32_JLT_K", 14577 { }, 14578 INTERNAL | FLAG_NO_DATA, 14579 { }, 14580 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14581 .fill_helper = bpf_fill_staggered_jlt32_imm, 14582 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14583 }, 14584 { 14585 "Staggered jumps: JMP32_JLE_K", 14586 { }, 14587 INTERNAL | FLAG_NO_DATA, 14588 { }, 14589 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14590 .fill_helper = bpf_fill_staggered_jle32_imm, 14591 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14592 }, 14593 { 14594 "Staggered jumps: JMP32_JSGT_K", 14595 { }, 14596 INTERNAL | FLAG_NO_DATA, 14597 { }, 14598 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14599 .fill_helper = bpf_fill_staggered_jsgt32_imm, 14600 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14601 }, 14602 { 14603 "Staggered jumps: JMP32_JSGE_K", 14604 { }, 14605 INTERNAL | FLAG_NO_DATA, 14606 { }, 14607 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14608 .fill_helper = bpf_fill_staggered_jsge32_imm, 14609 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14610 }, 14611 { 14612 "Staggered jumps: JMP32_JSLT_K", 14613 { }, 14614 INTERNAL | FLAG_NO_DATA, 14615 { }, 14616 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14617 .fill_helper = bpf_fill_staggered_jslt32_imm, 14618 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14619 }, 14620 { 14621 "Staggered jumps: JMP32_JSLE_K", 14622 { }, 14623 INTERNAL | FLAG_NO_DATA, 14624 { }, 14625 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14626 .fill_helper = bpf_fill_staggered_jsle32_imm, 14627 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14628 }, 14629 /* Staggered jump sequences, JMP32 register */ 14630 { 14631 "Staggered jumps: JMP32_JEQ_X", 14632 { }, 14633 INTERNAL | FLAG_NO_DATA, 14634 { }, 14635 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14636 .fill_helper = bpf_fill_staggered_jeq32_reg, 14637 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14638 }, 14639 { 14640 "Staggered jumps: JMP32_JNE_X", 14641 { }, 14642 INTERNAL | FLAG_NO_DATA, 14643 { }, 14644 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14645 .fill_helper = bpf_fill_staggered_jne32_reg, 14646 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14647 }, 14648 { 14649 "Staggered jumps: JMP32_JSET_X", 14650 { }, 14651 INTERNAL | FLAG_NO_DATA, 14652 { }, 14653 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14654 .fill_helper = bpf_fill_staggered_jset32_reg, 14655 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14656 }, 14657 { 14658 "Staggered jumps: JMP32_JGT_X", 14659 { }, 14660 INTERNAL | FLAG_NO_DATA, 14661 { }, 14662 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14663 .fill_helper = bpf_fill_staggered_jgt32_reg, 14664 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14665 }, 14666 { 14667 "Staggered jumps: JMP32_JGE_X", 14668 { }, 14669 INTERNAL | FLAG_NO_DATA, 14670 { }, 14671 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14672 .fill_helper = bpf_fill_staggered_jge32_reg, 14673 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14674 }, 14675 { 14676 "Staggered jumps: JMP32_JLT_X", 14677 { }, 14678 INTERNAL | FLAG_NO_DATA, 14679 { }, 14680 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14681 .fill_helper = bpf_fill_staggered_jlt32_reg, 14682 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14683 }, 14684 { 14685 "Staggered jumps: JMP32_JLE_X", 14686 { }, 14687 INTERNAL | FLAG_NO_DATA, 14688 { }, 14689 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14690 .fill_helper = bpf_fill_staggered_jle32_reg, 14691 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14692 }, 14693 { 14694 "Staggered jumps: JMP32_JSGT_X", 14695 { }, 14696 INTERNAL | FLAG_NO_DATA, 14697 { }, 14698 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14699 .fill_helper = bpf_fill_staggered_jsgt32_reg, 14700 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14701 }, 14702 { 14703 "Staggered jumps: JMP32_JSGE_X", 14704 { }, 14705 INTERNAL | FLAG_NO_DATA, 14706 { }, 14707 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14708 .fill_helper = bpf_fill_staggered_jsge32_reg, 14709 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14710 }, 14711 { 14712 "Staggered jumps: JMP32_JSLT_X", 14713 { }, 14714 INTERNAL | FLAG_NO_DATA, 14715 { }, 14716 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14717 .fill_helper = bpf_fill_staggered_jslt32_reg, 14718 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14719 }, 14720 { 14721 "Staggered jumps: JMP32_JSLE_X", 14722 { }, 14723 INTERNAL | FLAG_NO_DATA, 14724 { }, 14725 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 14726 .fill_helper = bpf_fill_staggered_jsle32_reg, 14727 .nr_testruns = NR_STAGGERED_JMP_RUNS, 14728 }, 14729}; 14730 14731static struct net_device dev; 14732 14733static struct sk_buff *populate_skb(char *buf, int size) 14734{ 14735 struct sk_buff *skb; 14736 14737 if (size >= MAX_DATA) 14738 return NULL; 14739 14740 skb = alloc_skb(MAX_DATA, GFP_KERNEL); 14741 if (!skb) 14742 return NULL; 14743 14744 __skb_put_data(skb, buf, size); 14745 14746 /* Initialize a fake skb with test pattern. */ 14747 skb_reset_mac_header(skb); 14748 skb->protocol = htons(ETH_P_IP); 14749 skb->pkt_type = SKB_TYPE; 14750 skb->mark = SKB_MARK; 14751 skb->hash = SKB_HASH; 14752 skb->queue_mapping = SKB_QUEUE_MAP; 14753 skb->vlan_tci = SKB_VLAN_TCI; 14754 skb->vlan_proto = htons(ETH_P_IP); 14755 dev_net_set(&dev, &init_net); 14756 skb->dev = &dev; 14757 skb->dev->ifindex = SKB_DEV_IFINDEX; 14758 skb->dev->type = SKB_DEV_TYPE; 14759 skb_set_network_header(skb, min(size, ETH_HLEN)); 14760 14761 return skb; 14762} 14763 14764static void *generate_test_data(struct bpf_test *test, int sub) 14765{ 14766 struct sk_buff *skb; 14767 struct page *page; 14768 14769 if (test->aux & FLAG_NO_DATA) 14770 return NULL; 14771 14772 if (test->aux & FLAG_LARGE_MEM) 14773 return kmalloc(test->test[sub].data_size, GFP_KERNEL); 14774 14775 /* Test case expects an skb, so populate one. Various 14776 * subtests generate skbs of different sizes based on 14777 * the same data. 14778 */ 14779 skb = populate_skb(test->data, test->test[sub].data_size); 14780 if (!skb) 14781 return NULL; 14782 14783 if (test->aux & FLAG_SKB_FRAG) { 14784 /* 14785 * when the test requires a fragmented skb, add a 14786 * single fragment to the skb, filled with 14787 * test->frag_data. 14788 */ 14789 page = alloc_page(GFP_KERNEL); 14790 if (!page) 14791 goto err_kfree_skb; 14792 14793 memcpy(page_address(page), test->frag_data, MAX_DATA); 14794 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA); 14795 } 14796 14797 return skb; 14798err_kfree_skb: 14799 kfree_skb(skb); 14800 return NULL; 14801} 14802 14803static void release_test_data(const struct bpf_test *test, void *data) 14804{ 14805 if (test->aux & FLAG_NO_DATA) 14806 return; 14807 14808 if (test->aux & FLAG_LARGE_MEM) 14809 kfree(data); 14810 else 14811 kfree_skb(data); 14812} 14813 14814static int filter_length(int which) 14815{ 14816 struct sock_filter *fp; 14817 int len; 14818 14819 if (tests[which].fill_helper) 14820 return tests[which].u.ptr.len; 14821 14822 fp = tests[which].u.insns; 14823 for (len = MAX_INSNS - 1; len > 0; --len) 14824 if (fp[len].code != 0 || fp[len].k != 0) 14825 break; 14826 14827 return len + 1; 14828} 14829 14830static void *filter_pointer(int which) 14831{ 14832 if (tests[which].fill_helper) 14833 return tests[which].u.ptr.insns; 14834 else 14835 return tests[which].u.insns; 14836} 14837 14838static struct bpf_prog *generate_filter(int which, int *err) 14839{ 14840 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 14841 unsigned int flen = filter_length(which); 14842 void *fptr = filter_pointer(which); 14843 struct sock_fprog_kern fprog; 14844 struct bpf_prog *fp; 14845 14846 switch (test_type) { 14847 case CLASSIC: 14848 fprog.filter = fptr; 14849 fprog.len = flen; 14850 14851 *err = bpf_prog_create(&fp, &fprog); 14852 if (tests[which].aux & FLAG_EXPECTED_FAIL) { 14853 if (*err == tests[which].expected_errcode) { 14854 pr_cont("PASS\n"); 14855 /* Verifier rejected filter as expected. */ 14856 *err = 0; 14857 return NULL; 14858 } else { 14859 pr_cont("UNEXPECTED_PASS\n"); 14860 /* Verifier didn't reject the test that's 14861 * bad enough, just return! 14862 */ 14863 *err = -EINVAL; 14864 return NULL; 14865 } 14866 } 14867 if (*err) { 14868 pr_cont("FAIL to prog_create err=%d len=%d\n", 14869 *err, fprog.len); 14870 return NULL; 14871 } 14872 break; 14873 14874 case INTERNAL: 14875 fp = bpf_prog_alloc(bpf_prog_size(flen), 0); 14876 if (fp == NULL) { 14877 pr_cont("UNEXPECTED_FAIL no memory left\n"); 14878 *err = -ENOMEM; 14879 return NULL; 14880 } 14881 14882 fp->len = flen; 14883 /* Type doesn't really matter here as long as it's not unspec. */ 14884 fp->type = BPF_PROG_TYPE_SOCKET_FILTER; 14885 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn)); 14886 fp->aux->stack_depth = tests[which].stack_depth; 14887 fp->aux->verifier_zext = !!(tests[which].aux & 14888 FLAG_VERIFIER_ZEXT); 14889 14890 /* We cannot error here as we don't need type compatibility 14891 * checks. 14892 */ 14893 fp = bpf_prog_select_runtime(fp, err); 14894 if (*err) { 14895 pr_cont("FAIL to select_runtime err=%d\n", *err); 14896 return NULL; 14897 } 14898 break; 14899 } 14900 14901 *err = 0; 14902 return fp; 14903} 14904 14905static void release_filter(struct bpf_prog *fp, int which) 14906{ 14907 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 14908 14909 switch (test_type) { 14910 case CLASSIC: 14911 bpf_prog_destroy(fp); 14912 break; 14913 case INTERNAL: 14914 bpf_prog_free(fp); 14915 break; 14916 } 14917} 14918 14919static int __run_one(const struct bpf_prog *fp, const void *data, 14920 int runs, u64 *duration) 14921{ 14922 u64 start, finish; 14923 int ret = 0, i; 14924 14925 migrate_disable(); 14926 start = ktime_get_ns(); 14927 14928 for (i = 0; i < runs; i++) 14929 ret = bpf_prog_run(fp, data); 14930 14931 finish = ktime_get_ns(); 14932 migrate_enable(); 14933 14934 *duration = finish - start; 14935 do_div(*duration, runs); 14936 14937 return ret; 14938} 14939 14940static int run_one(const struct bpf_prog *fp, struct bpf_test *test) 14941{ 14942 int err_cnt = 0, i, runs = MAX_TESTRUNS; 14943 14944 if (test->nr_testruns) 14945 runs = min(test->nr_testruns, MAX_TESTRUNS); 14946 14947 for (i = 0; i < MAX_SUBTESTS; i++) { 14948 void *data; 14949 u64 duration; 14950 u32 ret; 14951 14952 /* 14953 * NOTE: Several sub-tests may be present, in which case 14954 * a zero {data_size, result} tuple indicates the end of 14955 * the sub-test array. The first test is always run, 14956 * even if both data_size and result happen to be zero. 14957 */ 14958 if (i > 0 && 14959 test->test[i].data_size == 0 && 14960 test->test[i].result == 0) 14961 break; 14962 14963 data = generate_test_data(test, i); 14964 if (!data && !(test->aux & FLAG_NO_DATA)) { 14965 pr_cont("data generation failed "); 14966 err_cnt++; 14967 break; 14968 } 14969 ret = __run_one(fp, data, runs, &duration); 14970 release_test_data(test, data); 14971 14972 if (ret == test->test[i].result) { 14973 pr_cont("%lld ", duration); 14974 } else { 14975 s32 res = test->test[i].result; 14976 14977 pr_cont("ret %d != %d (%#x != %#x)", 14978 ret, res, ret, res); 14979 err_cnt++; 14980 } 14981 } 14982 14983 return err_cnt; 14984} 14985 14986static char test_name[64]; 14987module_param_string(test_name, test_name, sizeof(test_name), 0); 14988 14989static int test_id = -1; 14990module_param(test_id, int, 0); 14991 14992static int test_range[2] = { 0, INT_MAX }; 14993module_param_array(test_range, int, NULL, 0); 14994 14995static bool exclude_test(int test_id) 14996{ 14997 return test_id < test_range[0] || test_id > test_range[1]; 14998} 14999 15000static __init struct sk_buff *build_test_skb(void) 15001{ 15002 u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN; 15003 struct sk_buff *skb[2]; 15004 struct page *page[2]; 15005 int i, data_size = 8; 15006 15007 for (i = 0; i < 2; i++) { 15008 page[i] = alloc_page(GFP_KERNEL); 15009 if (!page[i]) { 15010 if (i == 0) 15011 goto err_page0; 15012 else 15013 goto err_page1; 15014 } 15015 15016 /* this will set skb[i]->head_frag */ 15017 skb[i] = dev_alloc_skb(headroom + data_size); 15018 if (!skb[i]) { 15019 if (i == 0) 15020 goto err_skb0; 15021 else 15022 goto err_skb1; 15023 } 15024 15025 skb_reserve(skb[i], headroom); 15026 skb_put(skb[i], data_size); 15027 skb[i]->protocol = htons(ETH_P_IP); 15028 skb_reset_network_header(skb[i]); 15029 skb_set_mac_header(skb[i], -ETH_HLEN); 15030 15031 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64); 15032 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1 15033 } 15034 15035 /* setup shinfo */ 15036 skb_shinfo(skb[0])->gso_size = 1448; 15037 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4; 15038 skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY; 15039 skb_shinfo(skb[0])->gso_segs = 0; 15040 skb_shinfo(skb[0])->frag_list = skb[1]; 15041 skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000; 15042 15043 /* adjust skb[0]'s len */ 15044 skb[0]->len += skb[1]->len; 15045 skb[0]->data_len += skb[1]->data_len; 15046 skb[0]->truesize += skb[1]->truesize; 15047 15048 return skb[0]; 15049 15050err_skb1: 15051 __free_page(page[1]); 15052err_page1: 15053 kfree_skb(skb[0]); 15054err_skb0: 15055 __free_page(page[0]); 15056err_page0: 15057 return NULL; 15058} 15059 15060static __init struct sk_buff *build_test_skb_linear_no_head_frag(void) 15061{ 15062 unsigned int alloc_size = 2000; 15063 unsigned int headroom = 102, doffset = 72, data_size = 1308; 15064 struct sk_buff *skb[2]; 15065 int i; 15066 15067 /* skbs linked in a frag_list, both with linear data, with head_frag=0 15068 * (data allocated by kmalloc), both have tcp data of 1308 bytes 15069 * (total payload is 2616 bytes). 15070 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom. 15071 */ 15072 for (i = 0; i < 2; i++) { 15073 skb[i] = alloc_skb(alloc_size, GFP_KERNEL); 15074 if (!skb[i]) { 15075 if (i == 0) 15076 goto err_skb0; 15077 else 15078 goto err_skb1; 15079 } 15080 15081 skb[i]->protocol = htons(ETH_P_IPV6); 15082 skb_reserve(skb[i], headroom); 15083 skb_put(skb[i], doffset + data_size); 15084 skb_reset_network_header(skb[i]); 15085 if (i == 0) 15086 skb_reset_mac_header(skb[i]); 15087 else 15088 skb_set_mac_header(skb[i], -ETH_HLEN); 15089 __skb_pull(skb[i], doffset); 15090 } 15091 15092 /* setup shinfo. 15093 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a 15094 * reduced gso_size. 15095 */ 15096 skb_shinfo(skb[0])->gso_size = 1288; 15097 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY; 15098 skb_shinfo(skb[0])->gso_segs = 0; 15099 skb_shinfo(skb[0])->frag_list = skb[1]; 15100 15101 /* adjust skb[0]'s len */ 15102 skb[0]->len += skb[1]->len; 15103 skb[0]->data_len += skb[1]->len; 15104 skb[0]->truesize += skb[1]->truesize; 15105 15106 return skb[0]; 15107 15108err_skb1: 15109 kfree_skb(skb[0]); 15110err_skb0: 15111 return NULL; 15112} 15113 15114struct skb_segment_test { 15115 const char *descr; 15116 struct sk_buff *(*build_skb)(void); 15117 netdev_features_t features; 15118}; 15119 15120static struct skb_segment_test skb_segment_tests[] __initconst = { 15121 { 15122 .descr = "gso_with_rx_frags", 15123 .build_skb = build_test_skb, 15124 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM | 15125 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM 15126 }, 15127 { 15128 .descr = "gso_linear_no_head_frag", 15129 .build_skb = build_test_skb_linear_no_head_frag, 15130 .features = NETIF_F_SG | NETIF_F_FRAGLIST | 15131 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO | 15132 NETIF_F_GRO | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM | 15133 NETIF_F_HW_VLAN_STAG_TX 15134 } 15135}; 15136 15137static __init int test_skb_segment_single(const struct skb_segment_test *test) 15138{ 15139 struct sk_buff *skb, *segs; 15140 int ret = -1; 15141 15142 skb = test->build_skb(); 15143 if (!skb) { 15144 pr_info("%s: failed to build_test_skb", __func__); 15145 goto done; 15146 } 15147 15148 segs = skb_segment(skb, test->features); 15149 if (!IS_ERR(segs)) { 15150 kfree_skb_list(segs); 15151 ret = 0; 15152 } 15153 kfree_skb(skb); 15154done: 15155 return ret; 15156} 15157 15158static __init int test_skb_segment(void) 15159{ 15160 int i, err_cnt = 0, pass_cnt = 0; 15161 15162 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) { 15163 const struct skb_segment_test *test = &skb_segment_tests[i]; 15164 15165 cond_resched(); 15166 if (exclude_test(i)) 15167 continue; 15168 15169 pr_info("#%d %s ", i, test->descr); 15170 15171 if (test_skb_segment_single(test)) { 15172 pr_cont("FAIL\n"); 15173 err_cnt++; 15174 } else { 15175 pr_cont("PASS\n"); 15176 pass_cnt++; 15177 } 15178 } 15179 15180 pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__, 15181 pass_cnt, err_cnt); 15182 return err_cnt ? -EINVAL : 0; 15183} 15184 15185static __init int test_bpf(void) 15186{ 15187 int i, err_cnt = 0, pass_cnt = 0; 15188 int jit_cnt = 0, run_cnt = 0; 15189 15190 for (i = 0; i < ARRAY_SIZE(tests); i++) { 15191 struct bpf_prog *fp; 15192 int err; 15193 15194 cond_resched(); 15195 if (exclude_test(i)) 15196 continue; 15197 15198 pr_info("#%d %s ", i, tests[i].descr); 15199 15200 if (tests[i].fill_helper && 15201 tests[i].fill_helper(&tests[i]) < 0) { 15202 pr_cont("FAIL to prog_fill\n"); 15203 continue; 15204 } 15205 15206 fp = generate_filter(i, &err); 15207 15208 if (tests[i].fill_helper) { 15209 kfree(tests[i].u.ptr.insns); 15210 tests[i].u.ptr.insns = NULL; 15211 } 15212 15213 if (fp == NULL) { 15214 if (err == 0) { 15215 pass_cnt++; 15216 continue; 15217 } 15218 err_cnt++; 15219 continue; 15220 } 15221 15222 pr_cont("jited:%u ", fp->jited); 15223 15224 run_cnt++; 15225 if (fp->jited) 15226 jit_cnt++; 15227 15228 err = run_one(fp, &tests[i]); 15229 release_filter(fp, i); 15230 15231 if (err) { 15232 pr_cont("FAIL (%d times)\n", err); 15233 err_cnt++; 15234 } else { 15235 pr_cont("PASS\n"); 15236 pass_cnt++; 15237 } 15238 } 15239 15240 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n", 15241 pass_cnt, err_cnt, jit_cnt, run_cnt); 15242 15243 return err_cnt ? -EINVAL : 0; 15244} 15245 15246struct tail_call_test { 15247 const char *descr; 15248 struct bpf_insn insns[MAX_INSNS]; 15249 int flags; 15250 int result; 15251 int stack_depth; 15252 bool has_tail_call; 15253}; 15254 15255/* Flags that can be passed to tail call test cases */ 15256#define FLAG_NEED_STATE BIT(0) 15257#define FLAG_RESULT_IN_STATE BIT(1) 15258 15259/* 15260 * Magic marker used in test snippets for tail calls below. 15261 * BPF_LD/MOV to R2 and R2 with this immediate value is replaced 15262 * with the proper values by the test runner. 15263 */ 15264#define TAIL_CALL_MARKER 0x7a11ca11 15265 15266/* Special offset to indicate a NULL call target */ 15267#define TAIL_CALL_NULL 0x7fff 15268 15269/* Special offset to indicate an out-of-range index */ 15270#define TAIL_CALL_INVALID 0x7ffe 15271 15272#define TAIL_CALL(offset) \ 15273 BPF_LD_IMM64(R2, TAIL_CALL_MARKER), \ 15274 BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \ 15275 offset, TAIL_CALL_MARKER), \ 15276 BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0) 15277 15278/* 15279 * A test function to be called from a BPF program, clobbering a lot of 15280 * CPU registers in the process. A JITed BPF program calling this function 15281 * must save and restore any caller-saved registers it uses for internal 15282 * state, for example the current tail call count. 15283 */ 15284BPF_CALL_1(bpf_test_func, u64, arg) 15285{ 15286 char buf[64]; 15287 long a = 0; 15288 long b = 1; 15289 long c = 2; 15290 long d = 3; 15291 long e = 4; 15292 long f = 5; 15293 long g = 6; 15294 long h = 7; 15295 15296 return snprintf(buf, sizeof(buf), 15297 "%ld %lu %lx %ld %lu %lx %ld %lu %x", 15298 a, b, c, d, e, f, g, h, (int)arg); 15299} 15300#define BPF_FUNC_test_func __BPF_FUNC_MAX_ID 15301 15302/* 15303 * Tail call tests. Each test case may call any other test in the table, 15304 * including itself, specified as a relative index offset from the calling 15305 * test. The index TAIL_CALL_NULL can be used to specify a NULL target 15306 * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID 15307 * results in a target index that is out of range. 15308 */ 15309static struct tail_call_test tail_call_tests[] = { 15310 { 15311 "Tail call leaf", 15312 .insns = { 15313 BPF_ALU64_REG(BPF_MOV, R0, R1), 15314 BPF_ALU64_IMM(BPF_ADD, R0, 1), 15315 BPF_EXIT_INSN(), 15316 }, 15317 .result = 1, 15318 }, 15319 { 15320 "Tail call 2", 15321 .insns = { 15322 BPF_ALU64_IMM(BPF_ADD, R1, 2), 15323 TAIL_CALL(-1), 15324 BPF_ALU64_IMM(BPF_MOV, R0, -1), 15325 BPF_EXIT_INSN(), 15326 }, 15327 .result = 3, 15328 .has_tail_call = true, 15329 }, 15330 { 15331 "Tail call 3", 15332 .insns = { 15333 BPF_ALU64_IMM(BPF_ADD, R1, 3), 15334 TAIL_CALL(-1), 15335 BPF_ALU64_IMM(BPF_MOV, R0, -1), 15336 BPF_EXIT_INSN(), 15337 }, 15338 .result = 6, 15339 .has_tail_call = true, 15340 }, 15341 { 15342 "Tail call 4", 15343 .insns = { 15344 BPF_ALU64_IMM(BPF_ADD, R1, 4), 15345 TAIL_CALL(-1), 15346 BPF_ALU64_IMM(BPF_MOV, R0, -1), 15347 BPF_EXIT_INSN(), 15348 }, 15349 .result = 10, 15350 .has_tail_call = true, 15351 }, 15352 { 15353 "Tail call load/store leaf", 15354 .insns = { 15355 BPF_ALU64_IMM(BPF_MOV, R1, 1), 15356 BPF_ALU64_IMM(BPF_MOV, R2, 2), 15357 BPF_ALU64_REG(BPF_MOV, R3, BPF_REG_FP), 15358 BPF_STX_MEM(BPF_DW, R3, R1, -8), 15359 BPF_STX_MEM(BPF_DW, R3, R2, -16), 15360 BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -8), 15361 BPF_JMP_REG(BPF_JNE, R0, R1, 3), 15362 BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -16), 15363 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 15364 BPF_ALU64_IMM(BPF_MOV, R0, 0), 15365 BPF_EXIT_INSN(), 15366 }, 15367 .result = 0, 15368 .stack_depth = 32, 15369 }, 15370 { 15371 "Tail call load/store", 15372 .insns = { 15373 BPF_ALU64_IMM(BPF_MOV, R0, 3), 15374 BPF_STX_MEM(BPF_DW, BPF_REG_FP, R0, -8), 15375 TAIL_CALL(-1), 15376 BPF_ALU64_IMM(BPF_MOV, R0, -1), 15377 BPF_EXIT_INSN(), 15378 }, 15379 .result = 0, 15380 .stack_depth = 16, 15381 .has_tail_call = true, 15382 }, 15383 { 15384 "Tail call error path, max count reached", 15385 .insns = { 15386 BPF_LDX_MEM(BPF_W, R2, R1, 0), 15387 BPF_ALU64_IMM(BPF_ADD, R2, 1), 15388 BPF_STX_MEM(BPF_W, R1, R2, 0), 15389 TAIL_CALL(0), 15390 BPF_EXIT_INSN(), 15391 }, 15392 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE, 15393 .result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS, 15394 .has_tail_call = true, 15395 }, 15396 { 15397 "Tail call count preserved across function calls", 15398 .insns = { 15399 BPF_LDX_MEM(BPF_W, R2, R1, 0), 15400 BPF_ALU64_IMM(BPF_ADD, R2, 1), 15401 BPF_STX_MEM(BPF_W, R1, R2, 0), 15402 BPF_STX_MEM(BPF_DW, R10, R1, -8), 15403 BPF_CALL_REL(BPF_FUNC_get_numa_node_id), 15404 BPF_CALL_REL(BPF_FUNC_ktime_get_ns), 15405 BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns), 15406 BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns), 15407 BPF_CALL_REL(BPF_FUNC_jiffies64), 15408 BPF_CALL_REL(BPF_FUNC_test_func), 15409 BPF_LDX_MEM(BPF_DW, R1, R10, -8), 15410 BPF_ALU32_REG(BPF_MOV, R0, R1), 15411 TAIL_CALL(0), 15412 BPF_EXIT_INSN(), 15413 }, 15414 .stack_depth = 8, 15415 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE, 15416 .result = (MAX_TAIL_CALL_CNT + 1) * MAX_TESTRUNS, 15417 .has_tail_call = true, 15418 }, 15419 { 15420 "Tail call error path, NULL target", 15421 .insns = { 15422 BPF_LDX_MEM(BPF_W, R2, R1, 0), 15423 BPF_ALU64_IMM(BPF_ADD, R2, 1), 15424 BPF_STX_MEM(BPF_W, R1, R2, 0), 15425 TAIL_CALL(TAIL_CALL_NULL), 15426 BPF_EXIT_INSN(), 15427 }, 15428 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE, 15429 .result = MAX_TESTRUNS, 15430 .has_tail_call = true, 15431 }, 15432 { 15433 "Tail call error path, index out of range", 15434 .insns = { 15435 BPF_LDX_MEM(BPF_W, R2, R1, 0), 15436 BPF_ALU64_IMM(BPF_ADD, R2, 1), 15437 BPF_STX_MEM(BPF_W, R1, R2, 0), 15438 TAIL_CALL(TAIL_CALL_INVALID), 15439 BPF_EXIT_INSN(), 15440 }, 15441 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE, 15442 .result = MAX_TESTRUNS, 15443 .has_tail_call = true, 15444 }, 15445}; 15446 15447static void __init destroy_tail_call_tests(struct bpf_array *progs) 15448{ 15449 int i; 15450 15451 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) 15452 if (progs->ptrs[i]) 15453 bpf_prog_free(progs->ptrs[i]); 15454 kfree(progs); 15455} 15456 15457static __init int prepare_tail_call_tests(struct bpf_array **pprogs) 15458{ 15459 int ntests = ARRAY_SIZE(tail_call_tests); 15460 struct bpf_array *progs; 15461 int which, err; 15462 15463 /* Allocate the table of programs to be used for tail calls */ 15464 progs = kzalloc(struct_size(progs, ptrs, ntests + 1), GFP_KERNEL); 15465 if (!progs) 15466 goto out_nomem; 15467 15468 /* Create all eBPF programs and populate the table */ 15469 for (which = 0; which < ntests; which++) { 15470 struct tail_call_test *test = &tail_call_tests[which]; 15471 struct bpf_prog *fp; 15472 int len, i; 15473 15474 /* Compute the number of program instructions */ 15475 for (len = 0; len < MAX_INSNS; len++) { 15476 struct bpf_insn *insn = &test->insns[len]; 15477 15478 if (len < MAX_INSNS - 1 && 15479 insn->code == (BPF_LD | BPF_DW | BPF_IMM)) 15480 len++; 15481 if (insn->code == 0) 15482 break; 15483 } 15484 15485 /* Allocate and initialize the program */ 15486 fp = bpf_prog_alloc(bpf_prog_size(len), 0); 15487 if (!fp) 15488 goto out_nomem; 15489 15490 fp->len = len; 15491 fp->type = BPF_PROG_TYPE_SOCKET_FILTER; 15492 fp->aux->stack_depth = test->stack_depth; 15493 fp->aux->tail_call_reachable = test->has_tail_call; 15494 memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn)); 15495 15496 /* Relocate runtime tail call offsets and addresses */ 15497 for (i = 0; i < len; i++) { 15498 struct bpf_insn *insn = &fp->insnsi[i]; 15499 long addr = 0; 15500 15501 switch (insn->code) { 15502 case BPF_LD | BPF_DW | BPF_IMM: 15503 if (insn->imm != TAIL_CALL_MARKER) 15504 break; 15505 insn[0].imm = (u32)(long)progs; 15506 insn[1].imm = ((u64)(long)progs) >> 32; 15507 break; 15508 15509 case BPF_ALU | BPF_MOV | BPF_K: 15510 if (insn->imm != TAIL_CALL_MARKER) 15511 break; 15512 if (insn->off == TAIL_CALL_NULL) 15513 insn->imm = ntests; 15514 else if (insn->off == TAIL_CALL_INVALID) 15515 insn->imm = ntests + 1; 15516 else 15517 insn->imm = which + insn->off; 15518 insn->off = 0; 15519 break; 15520 15521 case BPF_JMP | BPF_CALL: 15522 if (insn->src_reg != BPF_PSEUDO_CALL) 15523 break; 15524 switch (insn->imm) { 15525 case BPF_FUNC_get_numa_node_id: 15526 addr = (long)&numa_node_id; 15527 break; 15528 case BPF_FUNC_ktime_get_ns: 15529 addr = (long)&ktime_get_ns; 15530 break; 15531 case BPF_FUNC_ktime_get_boot_ns: 15532 addr = (long)&ktime_get_boot_fast_ns; 15533 break; 15534 case BPF_FUNC_ktime_get_coarse_ns: 15535 addr = (long)&ktime_get_coarse_ns; 15536 break; 15537 case BPF_FUNC_jiffies64: 15538 addr = (long)&get_jiffies_64; 15539 break; 15540 case BPF_FUNC_test_func: 15541 addr = (long)&bpf_test_func; 15542 break; 15543 default: 15544 err = -EFAULT; 15545 goto out_err; 15546 } 15547 *insn = BPF_EMIT_CALL(addr); 15548 if ((long)__bpf_call_base + insn->imm != addr) 15549 *insn = BPF_JMP_A(0); /* Skip: NOP */ 15550 break; 15551 } 15552 } 15553 15554 fp = bpf_prog_select_runtime(fp, &err); 15555 if (err) 15556 goto out_err; 15557 15558 progs->ptrs[which] = fp; 15559 } 15560 15561 /* The last entry contains a NULL program pointer */ 15562 progs->map.max_entries = ntests + 1; 15563 *pprogs = progs; 15564 return 0; 15565 15566out_nomem: 15567 err = -ENOMEM; 15568 15569out_err: 15570 if (progs) 15571 destroy_tail_call_tests(progs); 15572 return err; 15573} 15574 15575static __init int test_tail_calls(struct bpf_array *progs) 15576{ 15577 int i, err_cnt = 0, pass_cnt = 0; 15578 int jit_cnt = 0, run_cnt = 0; 15579 15580 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) { 15581 struct tail_call_test *test = &tail_call_tests[i]; 15582 struct bpf_prog *fp = progs->ptrs[i]; 15583 int *data = NULL; 15584 int state = 0; 15585 u64 duration; 15586 int ret; 15587 15588 cond_resched(); 15589 if (exclude_test(i)) 15590 continue; 15591 15592 pr_info("#%d %s ", i, test->descr); 15593 if (!fp) { 15594 err_cnt++; 15595 continue; 15596 } 15597 pr_cont("jited:%u ", fp->jited); 15598 15599 run_cnt++; 15600 if (fp->jited) 15601 jit_cnt++; 15602 15603 if (test->flags & FLAG_NEED_STATE) 15604 data = &state; 15605 ret = __run_one(fp, data, MAX_TESTRUNS, &duration); 15606 if (test->flags & FLAG_RESULT_IN_STATE) 15607 ret = state; 15608 if (ret == test->result) { 15609 pr_cont("%lld PASS", duration); 15610 pass_cnt++; 15611 } else { 15612 pr_cont("ret %d != %d FAIL", ret, test->result); 15613 err_cnt++; 15614 } 15615 } 15616 15617 pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n", 15618 __func__, pass_cnt, err_cnt, jit_cnt, run_cnt); 15619 15620 return err_cnt ? -EINVAL : 0; 15621} 15622 15623static char test_suite[32]; 15624module_param_string(test_suite, test_suite, sizeof(test_suite), 0); 15625 15626static __init int find_test_index(const char *test_name) 15627{ 15628 int i; 15629 15630 if (!strcmp(test_suite, "test_bpf")) { 15631 for (i = 0; i < ARRAY_SIZE(tests); i++) { 15632 if (!strcmp(tests[i].descr, test_name)) 15633 return i; 15634 } 15635 } 15636 15637 if (!strcmp(test_suite, "test_tail_calls")) { 15638 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) { 15639 if (!strcmp(tail_call_tests[i].descr, test_name)) 15640 return i; 15641 } 15642 } 15643 15644 if (!strcmp(test_suite, "test_skb_segment")) { 15645 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) { 15646 if (!strcmp(skb_segment_tests[i].descr, test_name)) 15647 return i; 15648 } 15649 } 15650 15651 return -1; 15652} 15653 15654static __init int prepare_test_range(void) 15655{ 15656 int valid_range; 15657 15658 if (!strcmp(test_suite, "test_bpf")) 15659 valid_range = ARRAY_SIZE(tests); 15660 else if (!strcmp(test_suite, "test_tail_calls")) 15661 valid_range = ARRAY_SIZE(tail_call_tests); 15662 else if (!strcmp(test_suite, "test_skb_segment")) 15663 valid_range = ARRAY_SIZE(skb_segment_tests); 15664 else 15665 return 0; 15666 15667 if (test_id >= 0) { 15668 /* 15669 * if a test_id was specified, use test_range to 15670 * cover only that test. 15671 */ 15672 if (test_id >= valid_range) { 15673 pr_err("test_bpf: invalid test_id specified for '%s' suite.\n", 15674 test_suite); 15675 return -EINVAL; 15676 } 15677 15678 test_range[0] = test_id; 15679 test_range[1] = test_id; 15680 } else if (*test_name) { 15681 /* 15682 * if a test_name was specified, find it and setup 15683 * test_range to cover only that test. 15684 */ 15685 int idx = find_test_index(test_name); 15686 15687 if (idx < 0) { 15688 pr_err("test_bpf: no test named '%s' found for '%s' suite.\n", 15689 test_name, test_suite); 15690 return -EINVAL; 15691 } 15692 test_range[0] = idx; 15693 test_range[1] = idx; 15694 } else if (test_range[0] != 0 || test_range[1] != INT_MAX) { 15695 /* 15696 * check that the supplied test_range is valid. 15697 */ 15698 if (test_range[0] < 0 || test_range[1] >= valid_range) { 15699 pr_err("test_bpf: test_range is out of bound for '%s' suite.\n", 15700 test_suite); 15701 return -EINVAL; 15702 } 15703 15704 if (test_range[1] < test_range[0]) { 15705 pr_err("test_bpf: test_range is ending before it starts.\n"); 15706 return -EINVAL; 15707 } 15708 } 15709 15710 return 0; 15711} 15712 15713static int __init test_bpf_init(void) 15714{ 15715 struct bpf_array *progs = NULL; 15716 int ret; 15717 15718 if (strlen(test_suite) && 15719 strcmp(test_suite, "test_bpf") && 15720 strcmp(test_suite, "test_tail_calls") && 15721 strcmp(test_suite, "test_skb_segment")) { 15722 pr_err("test_bpf: invalid test_suite '%s' specified.\n", test_suite); 15723 return -EINVAL; 15724 } 15725 15726 /* 15727 * if test_suite is not specified, but test_id, test_name or test_range 15728 * is specified, set 'test_bpf' as the default test suite. 15729 */ 15730 if (!strlen(test_suite) && 15731 (test_id != -1 || strlen(test_name) || 15732 (test_range[0] != 0 || test_range[1] != INT_MAX))) { 15733 pr_info("test_bpf: set 'test_bpf' as the default test_suite.\n"); 15734 strscpy(test_suite, "test_bpf", sizeof(test_suite)); 15735 } 15736 15737 ret = prepare_test_range(); 15738 if (ret < 0) 15739 return ret; 15740 15741 if (!strlen(test_suite) || !strcmp(test_suite, "test_bpf")) { 15742 ret = test_bpf(); 15743 if (ret) 15744 return ret; 15745 } 15746 15747 if (!strlen(test_suite) || !strcmp(test_suite, "test_tail_calls")) { 15748 ret = prepare_tail_call_tests(&progs); 15749 if (ret) 15750 return ret; 15751 ret = test_tail_calls(progs); 15752 destroy_tail_call_tests(progs); 15753 if (ret) 15754 return ret; 15755 } 15756 15757 if (!strlen(test_suite) || !strcmp(test_suite, "test_skb_segment")) 15758 return test_skb_segment(); 15759 15760 return 0; 15761} 15762 15763static void __exit test_bpf_exit(void) 15764{ 15765} 15766 15767module_init(test_bpf_init); 15768module_exit(test_bpf_exit); 15769 15770MODULE_DESCRIPTION("Testsuite for BPF interpreter and BPF JIT compiler"); 15771MODULE_LICENSE("GPL");
~/
Read-only file preview.