lists.openwall.net   lists  /  announce  owl-users  owl-dev  john-users  john-dev  passwdqc-users  yescrypt  popa3d-users  /  oss-security  kernel-hardening  musl  sabotage  tlsify  passwords  /  crypt-dev  xvendor  /  Bugtraq  Full-Disclosure  linux-kernel  linux-netdev  linux-ext4  linux-hardening  linux-cve-announce  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [day] [month] [year] [list]
Message-ID: <202312031333.ESYgytOb-lkp@intel.com>
Date:   Sun, 3 Dec 2023 14:32:10 +0800
From:   kernel test robot <lkp@...el.com>
To:     Johan Almbladh <johan.almbladh@...finetworks.com>
Cc:     oe-kbuild-all@...ts.linux.dev, linux-kernel@...r.kernel.org,
        Daniel Borkmann <daniel@...earbox.net>
Subject: lib/test_bpf.c:6896:30: sparse: sparse: cast truncates bits from
 constant value (1032547698badcfe becomes 98badcfe)

tree:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
head:   968f35f4ab1c0966ceb39af3c89f2e24afedf878
commit: f536a7c80675e4875e50df9182881d7678e27651 bpf/tests: Add more BPF_END byte order conversion tests
date:   2 years, 2 months ago
config: mips-randconfig-r123-20231130 (https://download.01.org/0day-ci/archive/20231203/202312031333.ESYgytOb-lkp@intel.com/config)
compiler: clang version 17.0.0 (https://github.com/llvm/llvm-project.git 4a5ac14ee968ff0ad5d2cc1ffa0299048db4c88a)
reproduce: (https://download.01.org/0day-ci/archive/20231203/202312031333.ESYgytOb-lkp@intel.com/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@...el.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202312031333.ESYgytOb-lkp@intel.com/

sparse warnings: (new ones prefixed by >>)
   lib/test_bpf.c:3958:25: sparse: sparse: cast truncates bits from constant value (1ffffffff becomes ffffffff)
   lib/test_bpf.c:4035:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:4113:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:4129:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:4254:25: sparse: sparse: cast truncates bits from constant value (100000000 becomes 0)
   lib/test_bpf.c:4432:25: sparse: sparse: cast truncates bits from constant value (100000000 becomes 0)
   lib/test_bpf.c:4742:25: sparse: sparse: cast truncates bits from constant value (fedcba987654321 becomes 87654321)
   lib/test_bpf.c:4743:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef0 becomes 9abcdef0)
   lib/test_bpf.c:4754:25: sparse: sparse: cast truncates bits from constant value (fedcba987654321 becomes 87654321)
   lib/test_bpf.c:4755:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef0 becomes 9abcdef0)
   lib/test_bpf.c:4877:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:4888:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5275:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5313:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5329:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5330:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5361:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5377:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5378:25: sparse: sparse: cast truncates bits from constant value (123456780a0c0e0 becomes 80a0c0e0)
   lib/test_bpf.c:5487:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5525:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5526:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5541:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5573:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5574:25: sparse: sparse: cast truncates bits from constant value (12345678fafcfef becomes 8fafcfef)
   lib/test_bpf.c:5589:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5699:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5737:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5738:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5753:25: sparse: sparse: cast truncates bits from constant value (ffffffff0000 becomes ffff0000)
   lib/test_bpf.c:5754:25: sparse: sparse: cast truncates bits from constant value (ffff00000000ffff becomes ffff)
   lib/test_bpf.c:5785:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5786:25: sparse: sparse: cast truncates bits from constant value (123456786a4c2e0 becomes 86a4c2e0)
   lib/test_bpf.c:5801:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5802:25: sparse: sparse: cast truncates bits from constant value (fedcba98795b3d1f becomes 795b3d1f)
   lib/test_bpf.c:5878:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5890:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5903:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5915:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5928:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5940:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5953:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:5965:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6045:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6056:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6068:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6079:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6091:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6102:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6114:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6186:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6198:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6211:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6223:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6236:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6248:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6261:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6273:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6353:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6364:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6376:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6387:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6399:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6410:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6422:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6446:25: sparse: sparse: cast truncates bits from constant value (ff00ff0000000000 becomes 0)
   lib/test_bpf.c:6458:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6470:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6483:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6495:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6508:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6520:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6533:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6545:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6581:25: sparse: sparse: cast truncates bits from constant value (ff00ff0000000000 becomes 0)
   lib/test_bpf.c:6592:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6603:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6615:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6626:25: sparse: sparse: cast truncates bits from constant value (f123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6638:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6649:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6661:25: sparse: sparse: cast truncates bits from constant value (8123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6718:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6729:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6743:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6749:30: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6754:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6767:25: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
   lib/test_bpf.c:6778:25: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
   lib/test_bpf.c:6792:25: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
   lib/test_bpf.c:6798:30: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
   lib/test_bpf.c:6803:25: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
   lib/test_bpf.c:6816:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6827:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6841:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6847:30: sparse: sparse: cast truncates bits from constant value (efcdab8967452301 becomes 67452301)
   lib/test_bpf.c:6852:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:6865:25: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
   lib/test_bpf.c:6876:25: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
   lib/test_bpf.c:6890:25: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
>> lib/test_bpf.c:6896:30: sparse: sparse: cast truncates bits from constant value (1032547698badcfe becomes 98badcfe)
   lib/test_bpf.c:6901:25: sparse: sparse: cast truncates bits from constant value (fedcba9876543210 becomes 76543210)
   lib/test_bpf.c:7047:25: sparse: sparse: cast truncates bits from constant value (ffff00000000ffff becomes ffff)
   lib/test_bpf.c:7093:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:7111:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:7387:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:7388:25: sparse: sparse: cast truncates bits from constant value (fecdba9876543210 becomes 76543210)
   lib/test_bpf.c:7404:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:7405:25: sparse: sparse: cast truncates bits from constant value (fecdba9876543210 becomes 76543210)
   lib/test_bpf.c:7422:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:7423:25: sparse: sparse: cast truncates bits from constant value (fecdba9876543210 becomes 76543210)
   lib/test_bpf.c:7440:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:7441:25: sparse: sparse: cast truncates bits from constant value (fecdba9876543210 becomes 76543210)
   lib/test_bpf.c:7459:25: sparse: sparse: cast truncates bits from constant value (123456789abcdef becomes 89abcdef)
   lib/test_bpf.c:7460:25: sparse: sparse: cast truncates bits from constant value (fecdba9876543210 becomes 76543210)
   lib/test_bpf.c:7464:25: sparse: sparse: cast truncates bits from constant value (fecdba9876543210 becomes 76543210)
   lib/test_bpf.c:8667:25: sparse: sparse: cast truncates bits from constant value (eeeeeeeeeeeeeeee becomes eeeeeeee)
   lib/test_bpf.c:8696:25: sparse: sparse: cast truncates bits from constant value (eeeeeeeeeeeeeeee becomes eeeeeeee)
   lib/test_bpf.c:8711:25: sparse: sparse: cast truncates bits from constant value (eeeeeeeeeeeeeeee becomes eeeeeeee)
   lib/test_bpf.c:8740:25: sparse: sparse: cast truncates bits from constant value (eeeeeeeeeeeeeeee becomes eeeeeeee)

vim +6896 lib/test_bpf.c

  1990	
  1991	
  1992	static struct bpf_test tests[] = {
  1993		{
  1994			"TAX",
  1995			.u.insns = {
  1996				BPF_STMT(BPF_LD | BPF_IMM, 1),
  1997				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  1998				BPF_STMT(BPF_LD | BPF_IMM, 2),
  1999				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2000				BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
  2001				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2002				BPF_STMT(BPF_LD | BPF_LEN, 0),
  2003				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2004				BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
  2005				BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
  2006				BPF_STMT(BPF_RET | BPF_A, 0)
  2007			},
  2008			CLASSIC,
  2009			{ 10, 20, 30, 40, 50 },
  2010			{ { 2, 10 }, { 3, 20 }, { 4, 30 } },
  2011		},
  2012		{
  2013			"TXA",
  2014			.u.insns = {
  2015				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2016				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  2017				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2018				BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
  2019			},
  2020			CLASSIC,
  2021			{ 10, 20, 30, 40, 50 },
  2022			{ { 1, 2 }, { 3, 6 }, { 4, 8 } },
  2023		},
  2024		{
  2025			"ADD_SUB_MUL_K",
  2026			.u.insns = {
  2027				BPF_STMT(BPF_LD | BPF_IMM, 1),
  2028				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
  2029				BPF_STMT(BPF_LDX | BPF_IMM, 3),
  2030				BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
  2031				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
  2032				BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
  2033				BPF_STMT(BPF_RET | BPF_A, 0)
  2034			},
  2035			CLASSIC | FLAG_NO_DATA,
  2036			{ },
  2037			{ { 0, 0xfffffffd } }
  2038		},
  2039		{
  2040			"DIV_MOD_KX",
  2041			.u.insns = {
  2042				BPF_STMT(BPF_LD | BPF_IMM, 8),
  2043				BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
  2044				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2045				BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
  2046				BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
  2047				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2048				BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
  2049				BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
  2050				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2051				BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
  2052				BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
  2053				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2054				BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
  2055				BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
  2056				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2057				BPF_STMT(BPF_RET | BPF_A, 0)
  2058			},
  2059			CLASSIC | FLAG_NO_DATA,
  2060			{ },
  2061			{ { 0, 0x20000000 } }
  2062		},
  2063		{
  2064			"AND_OR_LSH_K",
  2065			.u.insns = {
  2066				BPF_STMT(BPF_LD | BPF_IMM, 0xff),
  2067				BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
  2068				BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
  2069				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2070				BPF_STMT(BPF_LD | BPF_IMM, 0xf),
  2071				BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
  2072				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2073				BPF_STMT(BPF_RET | BPF_A, 0)
  2074			},
  2075			CLASSIC | FLAG_NO_DATA,
  2076			{ },
  2077			{ { 0, 0x800000ff }, { 1, 0x800000ff } },
  2078		},
  2079		{
  2080			"LD_IMM_0",
  2081			.u.insns = {
  2082				BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
  2083				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
  2084				BPF_STMT(BPF_RET | BPF_K, 0),
  2085				BPF_STMT(BPF_RET | BPF_K, 1),
  2086			},
  2087			CLASSIC,
  2088			{ },
  2089			{ { 1, 1 } },
  2090		},
  2091		{
  2092			"LD_IND",
  2093			.u.insns = {
  2094				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2095				BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
  2096				BPF_STMT(BPF_RET | BPF_K, 1)
  2097			},
  2098			CLASSIC,
  2099			{ },
  2100			{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
  2101		},
  2102		{
  2103			"LD_ABS",
  2104			.u.insns = {
  2105				BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
  2106				BPF_STMT(BPF_RET | BPF_K, 1)
  2107			},
  2108			CLASSIC,
  2109			{ },
  2110			{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
  2111		},
  2112		{
  2113			"LD_ABS_LL",
  2114			.u.insns = {
  2115				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
  2116				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2117				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
  2118				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2119				BPF_STMT(BPF_RET | BPF_A, 0)
  2120			},
  2121			CLASSIC,
  2122			{ 1, 2, 3 },
  2123			{ { 1, 0 }, { 2, 3 } },
  2124		},
  2125		{
  2126			"LD_IND_LL",
  2127			.u.insns = {
  2128				BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
  2129				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2130				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2131				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2132				BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
  2133				BPF_STMT(BPF_RET | BPF_A, 0)
  2134			},
  2135			CLASSIC,
  2136			{ 1, 2, 3, 0xff },
  2137			{ { 1, 1 }, { 3, 3 }, { 4, 0xff } },
  2138		},
  2139		{
  2140			"LD_ABS_NET",
  2141			.u.insns = {
  2142				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
  2143				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2144				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
  2145				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2146				BPF_STMT(BPF_RET | BPF_A, 0)
  2147			},
  2148			CLASSIC,
  2149			{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
  2150			{ { 15, 0 }, { 16, 3 } },
  2151		},
  2152		{
  2153			"LD_IND_NET",
  2154			.u.insns = {
  2155				BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
  2156				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2157				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  2158				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2159				BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
  2160				BPF_STMT(BPF_RET | BPF_A, 0)
  2161			},
  2162			CLASSIC,
  2163			{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
  2164			{ { 14, 0 }, { 15, 1 }, { 17, 3 } },
  2165		},
  2166		{
  2167			"LD_PKTTYPE",
  2168			.u.insns = {
  2169				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2170					 SKF_AD_OFF + SKF_AD_PKTTYPE),
  2171				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
  2172				BPF_STMT(BPF_RET | BPF_K, 1),
  2173				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2174					 SKF_AD_OFF + SKF_AD_PKTTYPE),
  2175				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
  2176				BPF_STMT(BPF_RET | BPF_K, 1),
  2177				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2178					 SKF_AD_OFF + SKF_AD_PKTTYPE),
  2179				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
  2180				BPF_STMT(BPF_RET | BPF_K, 1),
  2181				BPF_STMT(BPF_RET | BPF_A, 0)
  2182			},
  2183			CLASSIC,
  2184			{ },
  2185			{ { 1, 3 }, { 10, 3 } },
  2186		},
  2187		{
  2188			"LD_MARK",
  2189			.u.insns = {
  2190				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2191					 SKF_AD_OFF + SKF_AD_MARK),
  2192				BPF_STMT(BPF_RET | BPF_A, 0)
  2193			},
  2194			CLASSIC,
  2195			{ },
  2196			{ { 1, SKB_MARK}, { 10, SKB_MARK} },
  2197		},
  2198		{
  2199			"LD_RXHASH",
  2200			.u.insns = {
  2201				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2202					 SKF_AD_OFF + SKF_AD_RXHASH),
  2203				BPF_STMT(BPF_RET | BPF_A, 0)
  2204			},
  2205			CLASSIC,
  2206			{ },
  2207			{ { 1, SKB_HASH}, { 10, SKB_HASH} },
  2208		},
  2209		{
  2210			"LD_QUEUE",
  2211			.u.insns = {
  2212				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2213					 SKF_AD_OFF + SKF_AD_QUEUE),
  2214				BPF_STMT(BPF_RET | BPF_A, 0)
  2215			},
  2216			CLASSIC,
  2217			{ },
  2218			{ { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
  2219		},
  2220		{
  2221			"LD_PROTOCOL",
  2222			.u.insns = {
  2223				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
  2224				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
  2225				BPF_STMT(BPF_RET | BPF_K, 0),
  2226				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2227					 SKF_AD_OFF + SKF_AD_PROTOCOL),
  2228				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2229				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
  2230				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
  2231				BPF_STMT(BPF_RET | BPF_K, 0),
  2232				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  2233				BPF_STMT(BPF_RET | BPF_A, 0)
  2234			},
  2235			CLASSIC,
  2236			{ 10, 20, 30 },
  2237			{ { 10, ETH_P_IP }, { 100, ETH_P_IP } },
  2238		},
  2239		{
  2240			"LD_VLAN_TAG",
  2241			.u.insns = {
  2242				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2243					 SKF_AD_OFF + SKF_AD_VLAN_TAG),
  2244				BPF_STMT(BPF_RET | BPF_A, 0)
  2245			},
  2246			CLASSIC,
  2247			{ },
  2248			{
  2249				{ 1, SKB_VLAN_TCI },
  2250				{ 10, SKB_VLAN_TCI }
  2251			},
  2252		},
  2253		{
  2254			"LD_VLAN_TAG_PRESENT",
  2255			.u.insns = {
  2256				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2257					 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
  2258				BPF_STMT(BPF_RET | BPF_A, 0)
  2259			},
  2260			CLASSIC,
  2261			{ },
  2262			{
  2263				{ 1, SKB_VLAN_PRESENT },
  2264				{ 10, SKB_VLAN_PRESENT }
  2265			},
  2266		},
  2267		{
  2268			"LD_IFINDEX",
  2269			.u.insns = {
  2270				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2271					 SKF_AD_OFF + SKF_AD_IFINDEX),
  2272				BPF_STMT(BPF_RET | BPF_A, 0)
  2273			},
  2274			CLASSIC,
  2275			{ },
  2276			{ { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
  2277		},
  2278		{
  2279			"LD_HATYPE",
  2280			.u.insns = {
  2281				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2282					 SKF_AD_OFF + SKF_AD_HATYPE),
  2283				BPF_STMT(BPF_RET | BPF_A, 0)
  2284			},
  2285			CLASSIC,
  2286			{ },
  2287			{ { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
  2288		},
  2289		{
  2290			"LD_CPU",
  2291			.u.insns = {
  2292				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2293					 SKF_AD_OFF + SKF_AD_CPU),
  2294				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2295				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2296					 SKF_AD_OFF + SKF_AD_CPU),
  2297				BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
  2298				BPF_STMT(BPF_RET | BPF_A, 0)
  2299			},
  2300			CLASSIC,
  2301			{ },
  2302			{ { 1, 0 }, { 10, 0 } },
  2303		},
  2304		{
  2305			"LD_NLATTR",
  2306			.u.insns = {
  2307				BPF_STMT(BPF_LDX | BPF_IMM, 2),
  2308				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  2309				BPF_STMT(BPF_LDX | BPF_IMM, 3),
  2310				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2311					 SKF_AD_OFF + SKF_AD_NLATTR),
  2312				BPF_STMT(BPF_RET | BPF_A, 0)
  2313			},
  2314			CLASSIC,
  2315	#ifdef __BIG_ENDIAN
  2316			{ 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
  2317	#else
  2318			{ 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
  2319	#endif
  2320			{ { 4, 0 }, { 20, 6 } },
  2321		},
  2322		{
  2323			"LD_NLATTR_NEST",
  2324			.u.insns = {
  2325				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2326				BPF_STMT(BPF_LDX | BPF_IMM, 3),
  2327				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2328					 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
  2329				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2330				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2331					 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
  2332				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2333				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2334					 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
  2335				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2336				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2337					 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
  2338				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2339				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2340					 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
  2341				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2342				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2343					 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
  2344				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2345				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2346					 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
  2347				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2348				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2349					 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
  2350				BPF_STMT(BPF_RET | BPF_A, 0)
  2351			},
  2352			CLASSIC,
  2353	#ifdef __BIG_ENDIAN
  2354			{ 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
  2355	#else
  2356			{ 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
  2357	#endif
  2358			{ { 4, 0 }, { 20, 10 } },
  2359		},
  2360		{
  2361			"LD_PAYLOAD_OFF",
  2362			.u.insns = {
  2363				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2364					 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
  2365				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2366					 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
  2367				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2368					 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
  2369				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2370					 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
  2371				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2372					 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
  2373				BPF_STMT(BPF_RET | BPF_A, 0)
  2374			},
  2375			CLASSIC,
  2376			/* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
  2377			 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
  2378			 * id 9737, seq 1, length 64
  2379			 */
  2380			{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  2381			  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  2382			  0x08, 0x00,
  2383			  0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
  2384			  0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
  2385			{ { 30, 0 }, { 100, 42 } },
  2386		},
  2387		{
  2388			"LD_ANC_XOR",
  2389			.u.insns = {
  2390				BPF_STMT(BPF_LD | BPF_IMM, 10),
  2391				BPF_STMT(BPF_LDX | BPF_IMM, 300),
  2392				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  2393					 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
  2394				BPF_STMT(BPF_RET | BPF_A, 0)
  2395			},
  2396			CLASSIC,
  2397			{ },
  2398			{ { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
  2399		},
  2400		{
  2401			"SPILL_FILL",
  2402			.u.insns = {
  2403				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2404				BPF_STMT(BPF_LD | BPF_IMM, 2),
  2405				BPF_STMT(BPF_ALU | BPF_RSH, 1),
  2406				BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
  2407				BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
  2408				BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
  2409				BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
  2410				BPF_STMT(BPF_STX, 15), /* M3 = len */
  2411				BPF_STMT(BPF_LDX | BPF_MEM, 1),
  2412				BPF_STMT(BPF_LD | BPF_MEM, 2),
  2413				BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
  2414				BPF_STMT(BPF_LDX | BPF_MEM, 15),
  2415				BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
  2416				BPF_STMT(BPF_RET | BPF_A, 0)
  2417			},
  2418			CLASSIC,
  2419			{ },
  2420			{ { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
  2421		},
  2422		{
  2423			"JEQ",
  2424			.u.insns = {
  2425				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2426				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
  2427				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
  2428				BPF_STMT(BPF_RET | BPF_K, 1),
  2429				BPF_STMT(BPF_RET | BPF_K, MAX_K)
  2430			},
  2431			CLASSIC,
  2432			{ 3, 3, 3, 3, 3 },
  2433			{ { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
  2434		},
  2435		{
  2436			"JGT",
  2437			.u.insns = {
  2438				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2439				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
  2440				BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
  2441				BPF_STMT(BPF_RET | BPF_K, 1),
  2442				BPF_STMT(BPF_RET | BPF_K, MAX_K)
  2443			},
  2444			CLASSIC,
  2445			{ 4, 4, 4, 3, 3 },
  2446			{ { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
  2447		},
  2448		{
  2449			"JGE (jt 0), test 1",
  2450			.u.insns = {
  2451				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2452				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
  2453				BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
  2454				BPF_STMT(BPF_RET | BPF_K, 1),
  2455				BPF_STMT(BPF_RET | BPF_K, MAX_K)
  2456			},
  2457			CLASSIC,
  2458			{ 4, 4, 4, 3, 3 },
  2459			{ { 2, 0 }, { 3, 1 }, { 4, 1 } },
  2460		},
  2461		{
  2462			"JGE (jt 0), test 2",
  2463			.u.insns = {
  2464				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2465				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
  2466				BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
  2467				BPF_STMT(BPF_RET | BPF_K, 1),
  2468				BPF_STMT(BPF_RET | BPF_K, MAX_K)
  2469			},
  2470			CLASSIC,
  2471			{ 4, 4, 5, 3, 3 },
  2472			{ { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
  2473		},
  2474		{
  2475			"JGE",
  2476			.u.insns = {
  2477				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2478				BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
  2479				BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
  2480				BPF_STMT(BPF_RET | BPF_K, 10),
  2481				BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
  2482				BPF_STMT(BPF_RET | BPF_K, 20),
  2483				BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
  2484				BPF_STMT(BPF_RET | BPF_K, 30),
  2485				BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
  2486				BPF_STMT(BPF_RET | BPF_K, 40),
  2487				BPF_STMT(BPF_RET | BPF_K, MAX_K)
  2488			},
  2489			CLASSIC,
  2490			{ 1, 2, 3, 4, 5 },
  2491			{ { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
  2492		},
  2493		{
  2494			"JSET",
  2495			.u.insns = {
  2496				BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
  2497				BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
  2498				BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
  2499				BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
  2500				BPF_STMT(BPF_LDX | BPF_LEN, 0),
  2501				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  2502				BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
  2503				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  2504				BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
  2505				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
  2506				BPF_STMT(BPF_RET | BPF_K, 10),
  2507				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
  2508				BPF_STMT(BPF_RET | BPF_K, 20),
  2509				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
  2510				BPF_STMT(BPF_RET | BPF_K, 30),
  2511				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
  2512				BPF_STMT(BPF_RET | BPF_K, 30),
  2513				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
  2514				BPF_STMT(BPF_RET | BPF_K, 30),
  2515				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
  2516				BPF_STMT(BPF_RET | BPF_K, 30),
  2517				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
  2518				BPF_STMT(BPF_RET | BPF_K, 30),
  2519				BPF_STMT(BPF_RET | BPF_K, MAX_K)
  2520			},
  2521			CLASSIC,
  2522			{ 0, 0xAA, 0x55, 1 },
  2523			{ { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
  2524		},
  2525		{
  2526			"tcpdump port 22",
  2527			.u.insns = {
  2528				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
  2529				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
  2530				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
  2531				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
  2532				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
  2533				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
  2534				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
  2535				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
  2536				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
  2537				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
  2538				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
  2539				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
  2540				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
  2541				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
  2542				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
  2543				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
  2544				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
  2545				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
  2546				BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
  2547				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
  2548				BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
  2549				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
  2550				BPF_STMT(BPF_RET | BPF_K, 0xffff),
  2551				BPF_STMT(BPF_RET | BPF_K, 0),
  2552			},
  2553			CLASSIC,
  2554			/* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
  2555			 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
  2556			 * seq 1305692979:1305693027, ack 3650467037, win 65535,
  2557			 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
  2558			 */
  2559			{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
  2560			  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
  2561			  0x08, 0x00,
  2562			  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
  2563			  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
  2564			  0x0a, 0x01, 0x01, 0x95, /* ip src */
  2565			  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
  2566			  0xc2, 0x24,
  2567			  0x00, 0x16 /* dst port */ },
  2568			{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
  2569		},
  2570		{
  2571			"tcpdump complex",
  2572			.u.insns = {
  2573				/* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
  2574				 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
  2575				 * (len > 115 or len < 30000000000)' -d
  2576				 */
  2577				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
  2578				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
  2579				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
  2580				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
  2581				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
  2582				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
  2583				BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
  2584				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
  2585				BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
  2586				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
  2587				BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
  2588				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
  2589				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
  2590				BPF_STMT(BPF_ST, 1),
  2591				BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
  2592				BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
  2593				BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
  2594				BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
  2595				BPF_STMT(BPF_LD | BPF_MEM, 1),
  2596				BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
  2597				BPF_STMT(BPF_ST, 5),
  2598				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
  2599				BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
  2600				BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
  2601				BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
  2602				BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
  2603				BPF_STMT(BPF_LD | BPF_MEM, 5),
  2604				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
  2605				BPF_STMT(BPF_LD | BPF_LEN, 0),
  2606				BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
  2607				BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
  2608				BPF_STMT(BPF_RET | BPF_K, 0xffff),
  2609				BPF_STMT(BPF_RET | BPF_K, 0),
  2610			},
  2611			CLASSIC,
  2612			{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
  2613			  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
  2614			  0x08, 0x00,
  2615			  0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
  2616			  0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
  2617			  0x0a, 0x01, 0x01, 0x95, /* ip src */
  2618			  0x0a, 0x01, 0x02, 0x0a, /* ip dst */
  2619			  0xc2, 0x24,
  2620			  0x00, 0x16 /* dst port */ },
  2621			{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
  2622		},
  2623		{
  2624			"RET_A",
  2625			.u.insns = {
  2626				/* check that uninitialized X and A contain zeros */
  2627				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  2628				BPF_STMT(BPF_RET | BPF_A, 0)
  2629			},
  2630			CLASSIC,
  2631			{ },
  2632			{ {1, 0}, {2, 0} },
  2633		},
  2634		{
  2635			"INT: ADD trivial",
  2636			.u.insns_int = {
  2637				BPF_ALU64_IMM(BPF_MOV, R1, 1),
  2638				BPF_ALU64_IMM(BPF_ADD, R1, 2),
  2639				BPF_ALU64_IMM(BPF_MOV, R2, 3),
  2640				BPF_ALU64_REG(BPF_SUB, R1, R2),
  2641				BPF_ALU64_IMM(BPF_ADD, R1, -1),
  2642				BPF_ALU64_IMM(BPF_MUL, R1, 3),
  2643				BPF_ALU64_REG(BPF_MOV, R0, R1),
  2644				BPF_EXIT_INSN(),
  2645			},
  2646			INTERNAL,
  2647			{ },
  2648			{ { 0, 0xfffffffd } }
  2649		},
  2650		{
  2651			"INT: MUL_X",
  2652			.u.insns_int = {
  2653				BPF_ALU64_IMM(BPF_MOV, R0, -1),
  2654				BPF_ALU64_IMM(BPF_MOV, R1, -1),
  2655				BPF_ALU64_IMM(BPF_MOV, R2, 3),
  2656				BPF_ALU64_REG(BPF_MUL, R1, R2),
  2657				BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
  2658				BPF_EXIT_INSN(),
  2659				BPF_ALU64_IMM(BPF_MOV, R0, 1),
  2660				BPF_EXIT_INSN(),
  2661			},
  2662			INTERNAL,
  2663			{ },
  2664			{ { 0, 1 } }
  2665		},
  2666		{
  2667			"INT: MUL_X2",
  2668			.u.insns_int = {
  2669				BPF_ALU32_IMM(BPF_MOV, R0, -1),
  2670				BPF_ALU32_IMM(BPF_MOV, R1, -1),
  2671				BPF_ALU32_IMM(BPF_MOV, R2, 3),
  2672				BPF_ALU64_REG(BPF_MUL, R1, R2),
  2673				BPF_ALU64_IMM(BPF_RSH, R1, 8),
  2674				BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
  2675				BPF_EXIT_INSN(),
  2676				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  2677				BPF_EXIT_INSN(),
  2678			},
  2679			INTERNAL,
  2680			{ },
  2681			{ { 0, 1 } }
  2682		},
  2683		{
  2684			"INT: MUL32_X",
  2685			.u.insns_int = {
  2686				BPF_ALU32_IMM(BPF_MOV, R0, -1),
  2687				BPF_ALU64_IMM(BPF_MOV, R1, -1),
  2688				BPF_ALU32_IMM(BPF_MOV, R2, 3),
  2689				BPF_ALU32_REG(BPF_MUL, R1, R2),
  2690				BPF_ALU64_IMM(BPF_RSH, R1, 8),
  2691				BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
  2692				BPF_EXIT_INSN(),
  2693				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  2694				BPF_EXIT_INSN(),
  2695			},
  2696			INTERNAL,
  2697			{ },
  2698			{ { 0, 1 } }
  2699		},
  2700		{
  2701			/* Have to test all register combinations, since
  2702			 * JITing of different registers will produce
  2703			 * different asm code.
  2704			 */
  2705			"INT: ADD 64-bit",
  2706			.u.insns_int = {
  2707				BPF_ALU64_IMM(BPF_MOV, R0, 0),
  2708				BPF_ALU64_IMM(BPF_MOV, R1, 1),
  2709				BPF_ALU64_IMM(BPF_MOV, R2, 2),
  2710				BPF_ALU64_IMM(BPF_MOV, R3, 3),
  2711				BPF_ALU64_IMM(BPF_MOV, R4, 4),
  2712				BPF_ALU64_IMM(BPF_MOV, R5, 5),
  2713				BPF_ALU64_IMM(BPF_MOV, R6, 6),
  2714				BPF_ALU64_IMM(BPF_MOV, R7, 7),
  2715				BPF_ALU64_IMM(BPF_MOV, R8, 8),
  2716				BPF_ALU64_IMM(BPF_MOV, R9, 9),
  2717				BPF_ALU64_IMM(BPF_ADD, R0, 20),
  2718				BPF_ALU64_IMM(BPF_ADD, R1, 20),
  2719				BPF_ALU64_IMM(BPF_ADD, R2, 20),
  2720				BPF_ALU64_IMM(BPF_ADD, R3, 20),
  2721				BPF_ALU64_IMM(BPF_ADD, R4, 20),
  2722				BPF_ALU64_IMM(BPF_ADD, R5, 20),
  2723				BPF_ALU64_IMM(BPF_ADD, R6, 20),
  2724				BPF_ALU64_IMM(BPF_ADD, R7, 20),
  2725				BPF_ALU64_IMM(BPF_ADD, R8, 20),
  2726				BPF_ALU64_IMM(BPF_ADD, R9, 20),
  2727				BPF_ALU64_IMM(BPF_SUB, R0, 10),
  2728				BPF_ALU64_IMM(BPF_SUB, R1, 10),
  2729				BPF_ALU64_IMM(BPF_SUB, R2, 10),
  2730				BPF_ALU64_IMM(BPF_SUB, R3, 10),
  2731				BPF_ALU64_IMM(BPF_SUB, R4, 10),
  2732				BPF_ALU64_IMM(BPF_SUB, R5, 10),
  2733				BPF_ALU64_IMM(BPF_SUB, R6, 10),
  2734				BPF_ALU64_IMM(BPF_SUB, R7, 10),
  2735				BPF_ALU64_IMM(BPF_SUB, R8, 10),
  2736				BPF_ALU64_IMM(BPF_SUB, R9, 10),
  2737				BPF_ALU64_REG(BPF_ADD, R0, R0),
  2738				BPF_ALU64_REG(BPF_ADD, R0, R1),
  2739				BPF_ALU64_REG(BPF_ADD, R0, R2),
  2740				BPF_ALU64_REG(BPF_ADD, R0, R3),
  2741				BPF_ALU64_REG(BPF_ADD, R0, R4),
  2742				BPF_ALU64_REG(BPF_ADD, R0, R5),
  2743				BPF_ALU64_REG(BPF_ADD, R0, R6),
  2744				BPF_ALU64_REG(BPF_ADD, R0, R7),
  2745				BPF_ALU64_REG(BPF_ADD, R0, R8),
  2746				BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
  2747				BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
  2748				BPF_EXIT_INSN(),
  2749				BPF_ALU64_REG(BPF_ADD, R1, R0),
  2750				BPF_ALU64_REG(BPF_ADD, R1, R1),
  2751				BPF_ALU64_REG(BPF_ADD, R1, R2),
  2752				BPF_ALU64_REG(BPF_ADD, R1, R3),
  2753				BPF_ALU64_REG(BPF_ADD, R1, R4),
  2754				BPF_ALU64_REG(BPF_ADD, R1, R5),
  2755				BPF_ALU64_REG(BPF_ADD, R1, R6),
  2756				BPF_ALU64_REG(BPF_ADD, R1, R7),
  2757				BPF_ALU64_REG(BPF_ADD, R1, R8),
  2758				BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
  2759				BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
  2760				BPF_EXIT_INSN(),
  2761				BPF_ALU64_REG(BPF_ADD, R2, R0),
  2762				BPF_ALU64_REG(BPF_ADD, R2, R1),
  2763				BPF_ALU64_REG(BPF_ADD, R2, R2),
  2764				BPF_ALU64_REG(BPF_ADD, R2, R3),
  2765				BPF_ALU64_REG(BPF_ADD, R2, R4),
  2766				BPF_ALU64_REG(BPF_ADD, R2, R5),
  2767				BPF_ALU64_REG(BPF_ADD, R2, R6),
  2768				BPF_ALU64_REG(BPF_ADD, R2, R7),
  2769				BPF_ALU64_REG(BPF_ADD, R2, R8),
  2770				BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
  2771				BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
  2772				BPF_EXIT_INSN(),
  2773				BPF_ALU64_REG(BPF_ADD, R3, R0),
  2774				BPF_ALU64_REG(BPF_ADD, R3, R1),
  2775				BPF_ALU64_REG(BPF_ADD, R3, R2),
  2776				BPF_ALU64_REG(BPF_ADD, R3, R3),
  2777				BPF_ALU64_REG(BPF_ADD, R3, R4),
  2778				BPF_ALU64_REG(BPF_ADD, R3, R5),
  2779				BPF_ALU64_REG(BPF_ADD, R3, R6),
  2780				BPF_ALU64_REG(BPF_ADD, R3, R7),
  2781				BPF_ALU64_REG(BPF_ADD, R3, R8),
  2782				BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
  2783				BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
  2784				BPF_EXIT_INSN(),
  2785				BPF_ALU64_REG(BPF_ADD, R4, R0),
  2786				BPF_ALU64_REG(BPF_ADD, R4, R1),
  2787				BPF_ALU64_REG(BPF_ADD, R4, R2),
  2788				BPF_ALU64_REG(BPF_ADD, R4, R3),
  2789				BPF_ALU64_REG(BPF_ADD, R4, R4),
  2790				BPF_ALU64_REG(BPF_ADD, R4, R5),
  2791				BPF_ALU64_REG(BPF_ADD, R4, R6),
  2792				BPF_ALU64_REG(BPF_ADD, R4, R7),
  2793				BPF_ALU64_REG(BPF_ADD, R4, R8),
  2794				BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
  2795				BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
  2796				BPF_EXIT_INSN(),
  2797				BPF_ALU64_REG(BPF_ADD, R5, R0),
  2798				BPF_ALU64_REG(BPF_ADD, R5, R1),
  2799				BPF_ALU64_REG(BPF_ADD, R5, R2),
  2800				BPF_ALU64_REG(BPF_ADD, R5, R3),
  2801				BPF_ALU64_REG(BPF_ADD, R5, R4),
  2802				BPF_ALU64_REG(BPF_ADD, R5, R5),
  2803				BPF_ALU64_REG(BPF_ADD, R5, R6),
  2804				BPF_ALU64_REG(BPF_ADD, R5, R7),
  2805				BPF_ALU64_REG(BPF_ADD, R5, R8),
  2806				BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
  2807				BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
  2808				BPF_EXIT_INSN(),
  2809				BPF_ALU64_REG(BPF_ADD, R6, R0),
  2810				BPF_ALU64_REG(BPF_ADD, R6, R1),
  2811				BPF_ALU64_REG(BPF_ADD, R6, R2),
  2812				BPF_ALU64_REG(BPF_ADD, R6, R3),
  2813				BPF_ALU64_REG(BPF_ADD, R6, R4),
  2814				BPF_ALU64_REG(BPF_ADD, R6, R5),
  2815				BPF_ALU64_REG(BPF_ADD, R6, R6),
  2816				BPF_ALU64_REG(BPF_ADD, R6, R7),
  2817				BPF_ALU64_REG(BPF_ADD, R6, R8),
  2818				BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
  2819				BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
  2820				BPF_EXIT_INSN(),
  2821				BPF_ALU64_REG(BPF_ADD, R7, R0),
  2822				BPF_ALU64_REG(BPF_ADD, R7, R1),
  2823				BPF_ALU64_REG(BPF_ADD, R7, R2),
  2824				BPF_ALU64_REG(BPF_ADD, R7, R3),
  2825				BPF_ALU64_REG(BPF_ADD, R7, R4),
  2826				BPF_ALU64_REG(BPF_ADD, R7, R5),
  2827				BPF_ALU64_REG(BPF_ADD, R7, R6),
  2828				BPF_ALU64_REG(BPF_ADD, R7, R7),
  2829				BPF_ALU64_REG(BPF_ADD, R7, R8),
  2830				BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
  2831				BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
  2832				BPF_EXIT_INSN(),
  2833				BPF_ALU64_REG(BPF_ADD, R8, R0),
  2834				BPF_ALU64_REG(BPF_ADD, R8, R1),
  2835				BPF_ALU64_REG(BPF_ADD, R8, R2),
  2836				BPF_ALU64_REG(BPF_ADD, R8, R3),
  2837				BPF_ALU64_REG(BPF_ADD, R8, R4),
  2838				BPF_ALU64_REG(BPF_ADD, R8, R5),
  2839				BPF_ALU64_REG(BPF_ADD, R8, R6),
  2840				BPF_ALU64_REG(BPF_ADD, R8, R7),
  2841				BPF_ALU64_REG(BPF_ADD, R8, R8),
  2842				BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
  2843				BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
  2844				BPF_EXIT_INSN(),
  2845				BPF_ALU64_REG(BPF_ADD, R9, R0),
  2846				BPF_ALU64_REG(BPF_ADD, R9, R1),
  2847				BPF_ALU64_REG(BPF_ADD, R9, R2),
  2848				BPF_ALU64_REG(BPF_ADD, R9, R3),
  2849				BPF_ALU64_REG(BPF_ADD, R9, R4),
  2850				BPF_ALU64_REG(BPF_ADD, R9, R5),
  2851				BPF_ALU64_REG(BPF_ADD, R9, R6),
  2852				BPF_ALU64_REG(BPF_ADD, R9, R7),
  2853				BPF_ALU64_REG(BPF_ADD, R9, R8),
  2854				BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
  2855				BPF_ALU64_REG(BPF_MOV, R0, R9),
  2856				BPF_EXIT_INSN(),
  2857			},
  2858			INTERNAL,
  2859			{ },
  2860			{ { 0, 2957380 } }
  2861		},
  2862		{
  2863			"INT: ADD 32-bit",
  2864			.u.insns_int = {
  2865				BPF_ALU32_IMM(BPF_MOV, R0, 20),
  2866				BPF_ALU32_IMM(BPF_MOV, R1, 1),
  2867				BPF_ALU32_IMM(BPF_MOV, R2, 2),
  2868				BPF_ALU32_IMM(BPF_MOV, R3, 3),
  2869				BPF_ALU32_IMM(BPF_MOV, R4, 4),
  2870				BPF_ALU32_IMM(BPF_MOV, R5, 5),
  2871				BPF_ALU32_IMM(BPF_MOV, R6, 6),
  2872				BPF_ALU32_IMM(BPF_MOV, R7, 7),
  2873				BPF_ALU32_IMM(BPF_MOV, R8, 8),
  2874				BPF_ALU32_IMM(BPF_MOV, R9, 9),
  2875				BPF_ALU64_IMM(BPF_ADD, R1, 10),
  2876				BPF_ALU64_IMM(BPF_ADD, R2, 10),
  2877				BPF_ALU64_IMM(BPF_ADD, R3, 10),
  2878				BPF_ALU64_IMM(BPF_ADD, R4, 10),
  2879				BPF_ALU64_IMM(BPF_ADD, R5, 10),
  2880				BPF_ALU64_IMM(BPF_ADD, R6, 10),
  2881				BPF_ALU64_IMM(BPF_ADD, R7, 10),
  2882				BPF_ALU64_IMM(BPF_ADD, R8, 10),
  2883				BPF_ALU64_IMM(BPF_ADD, R9, 10),
  2884				BPF_ALU32_REG(BPF_ADD, R0, R1),
  2885				BPF_ALU32_REG(BPF_ADD, R0, R2),
  2886				BPF_ALU32_REG(BPF_ADD, R0, R3),
  2887				BPF_ALU32_REG(BPF_ADD, R0, R4),
  2888				BPF_ALU32_REG(BPF_ADD, R0, R5),
  2889				BPF_ALU32_REG(BPF_ADD, R0, R6),
  2890				BPF_ALU32_REG(BPF_ADD, R0, R7),
  2891				BPF_ALU32_REG(BPF_ADD, R0, R8),
  2892				BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
  2893				BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
  2894				BPF_EXIT_INSN(),
  2895				BPF_ALU32_REG(BPF_ADD, R1, R0),
  2896				BPF_ALU32_REG(BPF_ADD, R1, R1),
  2897				BPF_ALU32_REG(BPF_ADD, R1, R2),
  2898				BPF_ALU32_REG(BPF_ADD, R1, R3),
  2899				BPF_ALU32_REG(BPF_ADD, R1, R4),
  2900				BPF_ALU32_REG(BPF_ADD, R1, R5),
  2901				BPF_ALU32_REG(BPF_ADD, R1, R6),
  2902				BPF_ALU32_REG(BPF_ADD, R1, R7),
  2903				BPF_ALU32_REG(BPF_ADD, R1, R8),
  2904				BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
  2905				BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
  2906				BPF_EXIT_INSN(),
  2907				BPF_ALU32_REG(BPF_ADD, R2, R0),
  2908				BPF_ALU32_REG(BPF_ADD, R2, R1),
  2909				BPF_ALU32_REG(BPF_ADD, R2, R2),
  2910				BPF_ALU32_REG(BPF_ADD, R2, R3),
  2911				BPF_ALU32_REG(BPF_ADD, R2, R4),
  2912				BPF_ALU32_REG(BPF_ADD, R2, R5),
  2913				BPF_ALU32_REG(BPF_ADD, R2, R6),
  2914				BPF_ALU32_REG(BPF_ADD, R2, R7),
  2915				BPF_ALU32_REG(BPF_ADD, R2, R8),
  2916				BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
  2917				BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
  2918				BPF_EXIT_INSN(),
  2919				BPF_ALU32_REG(BPF_ADD, R3, R0),
  2920				BPF_ALU32_REG(BPF_ADD, R3, R1),
  2921				BPF_ALU32_REG(BPF_ADD, R3, R2),
  2922				BPF_ALU32_REG(BPF_ADD, R3, R3),
  2923				BPF_ALU32_REG(BPF_ADD, R3, R4),
  2924				BPF_ALU32_REG(BPF_ADD, R3, R5),
  2925				BPF_ALU32_REG(BPF_ADD, R3, R6),
  2926				BPF_ALU32_REG(BPF_ADD, R3, R7),
  2927				BPF_ALU32_REG(BPF_ADD, R3, R8),
  2928				BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
  2929				BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
  2930				BPF_EXIT_INSN(),
  2931				BPF_ALU32_REG(BPF_ADD, R4, R0),
  2932				BPF_ALU32_REG(BPF_ADD, R4, R1),
  2933				BPF_ALU32_REG(BPF_ADD, R4, R2),
  2934				BPF_ALU32_REG(BPF_ADD, R4, R3),
  2935				BPF_ALU32_REG(BPF_ADD, R4, R4),
  2936				BPF_ALU32_REG(BPF_ADD, R4, R5),
  2937				BPF_ALU32_REG(BPF_ADD, R4, R6),
  2938				BPF_ALU32_REG(BPF_ADD, R4, R7),
  2939				BPF_ALU32_REG(BPF_ADD, R4, R8),
  2940				BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
  2941				BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
  2942				BPF_EXIT_INSN(),
  2943				BPF_ALU32_REG(BPF_ADD, R5, R0),
  2944				BPF_ALU32_REG(BPF_ADD, R5, R1),
  2945				BPF_ALU32_REG(BPF_ADD, R5, R2),
  2946				BPF_ALU32_REG(BPF_ADD, R5, R3),
  2947				BPF_ALU32_REG(BPF_ADD, R5, R4),
  2948				BPF_ALU32_REG(BPF_ADD, R5, R5),
  2949				BPF_ALU32_REG(BPF_ADD, R5, R6),
  2950				BPF_ALU32_REG(BPF_ADD, R5, R7),
  2951				BPF_ALU32_REG(BPF_ADD, R5, R8),
  2952				BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
  2953				BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
  2954				BPF_EXIT_INSN(),
  2955				BPF_ALU32_REG(BPF_ADD, R6, R0),
  2956				BPF_ALU32_REG(BPF_ADD, R6, R1),
  2957				BPF_ALU32_REG(BPF_ADD, R6, R2),
  2958				BPF_ALU32_REG(BPF_ADD, R6, R3),
  2959				BPF_ALU32_REG(BPF_ADD, R6, R4),
  2960				BPF_ALU32_REG(BPF_ADD, R6, R5),
  2961				BPF_ALU32_REG(BPF_ADD, R6, R6),
  2962				BPF_ALU32_REG(BPF_ADD, R6, R7),
  2963				BPF_ALU32_REG(BPF_ADD, R6, R8),
  2964				BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
  2965				BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
  2966				BPF_EXIT_INSN(),
  2967				BPF_ALU32_REG(BPF_ADD, R7, R0),
  2968				BPF_ALU32_REG(BPF_ADD, R7, R1),
  2969				BPF_ALU32_REG(BPF_ADD, R7, R2),
  2970				BPF_ALU32_REG(BPF_ADD, R7, R3),
  2971				BPF_ALU32_REG(BPF_ADD, R7, R4),
  2972				BPF_ALU32_REG(BPF_ADD, R7, R5),
  2973				BPF_ALU32_REG(BPF_ADD, R7, R6),
  2974				BPF_ALU32_REG(BPF_ADD, R7, R7),
  2975				BPF_ALU32_REG(BPF_ADD, R7, R8),
  2976				BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
  2977				BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
  2978				BPF_EXIT_INSN(),
  2979				BPF_ALU32_REG(BPF_ADD, R8, R0),
  2980				BPF_ALU32_REG(BPF_ADD, R8, R1),
  2981				BPF_ALU32_REG(BPF_ADD, R8, R2),
  2982				BPF_ALU32_REG(BPF_ADD, R8, R3),
  2983				BPF_ALU32_REG(BPF_ADD, R8, R4),
  2984				BPF_ALU32_REG(BPF_ADD, R8, R5),
  2985				BPF_ALU32_REG(BPF_ADD, R8, R6),
  2986				BPF_ALU32_REG(BPF_ADD, R8, R7),
  2987				BPF_ALU32_REG(BPF_ADD, R8, R8),
  2988				BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
  2989				BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
  2990				BPF_EXIT_INSN(),
  2991				BPF_ALU32_REG(BPF_ADD, R9, R0),
  2992				BPF_ALU32_REG(BPF_ADD, R9, R1),
  2993				BPF_ALU32_REG(BPF_ADD, R9, R2),
  2994				BPF_ALU32_REG(BPF_ADD, R9, R3),
  2995				BPF_ALU32_REG(BPF_ADD, R9, R4),
  2996				BPF_ALU32_REG(BPF_ADD, R9, R5),
  2997				BPF_ALU32_REG(BPF_ADD, R9, R6),
  2998				BPF_ALU32_REG(BPF_ADD, R9, R7),
  2999				BPF_ALU32_REG(BPF_ADD, R9, R8),
  3000				BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
  3001				BPF_ALU32_REG(BPF_MOV, R0, R9),
  3002				BPF_EXIT_INSN(),
  3003			},
  3004			INTERNAL,
  3005			{ },
  3006			{ { 0, 2957380 } }
  3007		},
  3008		{	/* Mainly checking JIT here. */
  3009			"INT: SUB",
  3010			.u.insns_int = {
  3011				BPF_ALU64_IMM(BPF_MOV, R0, 0),
  3012				BPF_ALU64_IMM(BPF_MOV, R1, 1),
  3013				BPF_ALU64_IMM(BPF_MOV, R2, 2),
  3014				BPF_ALU64_IMM(BPF_MOV, R3, 3),
  3015				BPF_ALU64_IMM(BPF_MOV, R4, 4),
  3016				BPF_ALU64_IMM(BPF_MOV, R5, 5),
  3017				BPF_ALU64_IMM(BPF_MOV, R6, 6),
  3018				BPF_ALU64_IMM(BPF_MOV, R7, 7),
  3019				BPF_ALU64_IMM(BPF_MOV, R8, 8),
  3020				BPF_ALU64_IMM(BPF_MOV, R9, 9),
  3021				BPF_ALU64_REG(BPF_SUB, R0, R0),
  3022				BPF_ALU64_REG(BPF_SUB, R0, R1),
  3023				BPF_ALU64_REG(BPF_SUB, R0, R2),
  3024				BPF_ALU64_REG(BPF_SUB, R0, R3),
  3025				BPF_ALU64_REG(BPF_SUB, R0, R4),
  3026				BPF_ALU64_REG(BPF_SUB, R0, R5),
  3027				BPF_ALU64_REG(BPF_SUB, R0, R6),
  3028				BPF_ALU64_REG(BPF_SUB, R0, R7),
  3029				BPF_ALU64_REG(BPF_SUB, R0, R8),
  3030				BPF_ALU64_REG(BPF_SUB, R0, R9),
  3031				BPF_ALU64_IMM(BPF_SUB, R0, 10),
  3032				BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
  3033				BPF_EXIT_INSN(),
  3034				BPF_ALU64_REG(BPF_SUB, R1, R0),
  3035				BPF_ALU64_REG(BPF_SUB, R1, R2),
  3036				BPF_ALU64_REG(BPF_SUB, R1, R3),
  3037				BPF_ALU64_REG(BPF_SUB, R1, R4),
  3038				BPF_ALU64_REG(BPF_SUB, R1, R5),
  3039				BPF_ALU64_REG(BPF_SUB, R1, R6),
  3040				BPF_ALU64_REG(BPF_SUB, R1, R7),
  3041				BPF_ALU64_REG(BPF_SUB, R1, R8),
  3042				BPF_ALU64_REG(BPF_SUB, R1, R9),
  3043				BPF_ALU64_IMM(BPF_SUB, R1, 10),
  3044				BPF_ALU64_REG(BPF_SUB, R2, R0),
  3045				BPF_ALU64_REG(BPF_SUB, R2, R1),
  3046				BPF_ALU64_REG(BPF_SUB, R2, R3),
  3047				BPF_ALU64_REG(BPF_SUB, R2, R4),
  3048				BPF_ALU64_REG(BPF_SUB, R2, R5),
  3049				BPF_ALU64_REG(BPF_SUB, R2, R6),
  3050				BPF_ALU64_REG(BPF_SUB, R2, R7),
  3051				BPF_ALU64_REG(BPF_SUB, R2, R8),
  3052				BPF_ALU64_REG(BPF_SUB, R2, R9),
  3053				BPF_ALU64_IMM(BPF_SUB, R2, 10),
  3054				BPF_ALU64_REG(BPF_SUB, R3, R0),
  3055				BPF_ALU64_REG(BPF_SUB, R3, R1),
  3056				BPF_ALU64_REG(BPF_SUB, R3, R2),
  3057				BPF_ALU64_REG(BPF_SUB, R3, R4),
  3058				BPF_ALU64_REG(BPF_SUB, R3, R5),
  3059				BPF_ALU64_REG(BPF_SUB, R3, R6),
  3060				BPF_ALU64_REG(BPF_SUB, R3, R7),
  3061				BPF_ALU64_REG(BPF_SUB, R3, R8),
  3062				BPF_ALU64_REG(BPF_SUB, R3, R9),
  3063				BPF_ALU64_IMM(BPF_SUB, R3, 10),
  3064				BPF_ALU64_REG(BPF_SUB, R4, R0),
  3065				BPF_ALU64_REG(BPF_SUB, R4, R1),
  3066				BPF_ALU64_REG(BPF_SUB, R4, R2),
  3067				BPF_ALU64_REG(BPF_SUB, R4, R3),
  3068				BPF_ALU64_REG(BPF_SUB, R4, R5),
  3069				BPF_ALU64_REG(BPF_SUB, R4, R6),
  3070				BPF_ALU64_REG(BPF_SUB, R4, R7),
  3071				BPF_ALU64_REG(BPF_SUB, R4, R8),
  3072				BPF_ALU64_REG(BPF_SUB, R4, R9),
  3073				BPF_ALU64_IMM(BPF_SUB, R4, 10),
  3074				BPF_ALU64_REG(BPF_SUB, R5, R0),
  3075				BPF_ALU64_REG(BPF_SUB, R5, R1),
  3076				BPF_ALU64_REG(BPF_SUB, R5, R2),
  3077				BPF_ALU64_REG(BPF_SUB, R5, R3),
  3078				BPF_ALU64_REG(BPF_SUB, R5, R4),
  3079				BPF_ALU64_REG(BPF_SUB, R5, R6),
  3080				BPF_ALU64_REG(BPF_SUB, R5, R7),
  3081				BPF_ALU64_REG(BPF_SUB, R5, R8),
  3082				BPF_ALU64_REG(BPF_SUB, R5, R9),
  3083				BPF_ALU64_IMM(BPF_SUB, R5, 10),
  3084				BPF_ALU64_REG(BPF_SUB, R6, R0),
  3085				BPF_ALU64_REG(BPF_SUB, R6, R1),
  3086				BPF_ALU64_REG(BPF_SUB, R6, R2),
  3087				BPF_ALU64_REG(BPF_SUB, R6, R3),
  3088				BPF_ALU64_REG(BPF_SUB, R6, R4),
  3089				BPF_ALU64_REG(BPF_SUB, R6, R5),
  3090				BPF_ALU64_REG(BPF_SUB, R6, R7),
  3091				BPF_ALU64_REG(BPF_SUB, R6, R8),
  3092				BPF_ALU64_REG(BPF_SUB, R6, R9),
  3093				BPF_ALU64_IMM(BPF_SUB, R6, 10),
  3094				BPF_ALU64_REG(BPF_SUB, R7, R0),
  3095				BPF_ALU64_REG(BPF_SUB, R7, R1),
  3096				BPF_ALU64_REG(BPF_SUB, R7, R2),
  3097				BPF_ALU64_REG(BPF_SUB, R7, R3),
  3098				BPF_ALU64_REG(BPF_SUB, R7, R4),
  3099				BPF_ALU64_REG(BPF_SUB, R7, R5),
  3100				BPF_ALU64_REG(BPF_SUB, R7, R6),
  3101				BPF_ALU64_REG(BPF_SUB, R7, R8),
  3102				BPF_ALU64_REG(BPF_SUB, R7, R9),
  3103				BPF_ALU64_IMM(BPF_SUB, R7, 10),
  3104				BPF_ALU64_REG(BPF_SUB, R8, R0),
  3105				BPF_ALU64_REG(BPF_SUB, R8, R1),
  3106				BPF_ALU64_REG(BPF_SUB, R8, R2),
  3107				BPF_ALU64_REG(BPF_SUB, R8, R3),
  3108				BPF_ALU64_REG(BPF_SUB, R8, R4),
  3109				BPF_ALU64_REG(BPF_SUB, R8, R5),
  3110				BPF_ALU64_REG(BPF_SUB, R8, R6),
  3111				BPF_ALU64_REG(BPF_SUB, R8, R7),
  3112				BPF_ALU64_REG(BPF_SUB, R8, R9),
  3113				BPF_ALU64_IMM(BPF_SUB, R8, 10),
  3114				BPF_ALU64_REG(BPF_SUB, R9, R0),
  3115				BPF_ALU64_REG(BPF_SUB, R9, R1),
  3116				BPF_ALU64_REG(BPF_SUB, R9, R2),
  3117				BPF_ALU64_REG(BPF_SUB, R9, R3),
  3118				BPF_ALU64_REG(BPF_SUB, R9, R4),
  3119				BPF_ALU64_REG(BPF_SUB, R9, R5),
  3120				BPF_ALU64_REG(BPF_SUB, R9, R6),
  3121				BPF_ALU64_REG(BPF_SUB, R9, R7),
  3122				BPF_ALU64_REG(BPF_SUB, R9, R8),
  3123				BPF_ALU64_IMM(BPF_SUB, R9, 10),
  3124				BPF_ALU64_IMM(BPF_SUB, R0, 10),
  3125				BPF_ALU64_IMM(BPF_NEG, R0, 0),
  3126				BPF_ALU64_REG(BPF_SUB, R0, R1),
  3127				BPF_ALU64_REG(BPF_SUB, R0, R2),
  3128				BPF_ALU64_REG(BPF_SUB, R0, R3),
  3129				BPF_ALU64_REG(BPF_SUB, R0, R4),
  3130				BPF_ALU64_REG(BPF_SUB, R0, R5),
  3131				BPF_ALU64_REG(BPF_SUB, R0, R6),
  3132				BPF_ALU64_REG(BPF_SUB, R0, R7),
  3133				BPF_ALU64_REG(BPF_SUB, R0, R8),
  3134				BPF_ALU64_REG(BPF_SUB, R0, R9),
  3135				BPF_EXIT_INSN(),
  3136			},
  3137			INTERNAL,
  3138			{ },
  3139			{ { 0, 11 } }
  3140		},
  3141		{	/* Mainly checking JIT here. */
  3142			"INT: XOR",
  3143			.u.insns_int = {
  3144				BPF_ALU64_REG(BPF_SUB, R0, R0),
  3145				BPF_ALU64_REG(BPF_XOR, R1, R1),
  3146				BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
  3147				BPF_EXIT_INSN(),
  3148				BPF_ALU64_IMM(BPF_MOV, R0, 10),
  3149				BPF_ALU64_IMM(BPF_MOV, R1, -1),
  3150				BPF_ALU64_REG(BPF_SUB, R1, R1),
  3151				BPF_ALU64_REG(BPF_XOR, R2, R2),
  3152				BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
  3153				BPF_EXIT_INSN(),
  3154				BPF_ALU64_REG(BPF_SUB, R2, R2),
  3155				BPF_ALU64_REG(BPF_XOR, R3, R3),
  3156				BPF_ALU64_IMM(BPF_MOV, R0, 10),
  3157				BPF_ALU64_IMM(BPF_MOV, R1, -1),
  3158				BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
  3159				BPF_EXIT_INSN(),
  3160				BPF_ALU64_REG(BPF_SUB, R3, R3),
  3161				BPF_ALU64_REG(BPF_XOR, R4, R4),
  3162				BPF_ALU64_IMM(BPF_MOV, R2, 1),
  3163				BPF_ALU64_IMM(BPF_MOV, R5, -1),
  3164				BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
  3165				BPF_EXIT_INSN(),
  3166				BPF_ALU64_REG(BPF_SUB, R4, R4),
  3167				BPF_ALU64_REG(BPF_XOR, R5, R5),
  3168				BPF_ALU64_IMM(BPF_MOV, R3, 1),
  3169				BPF_ALU64_IMM(BPF_MOV, R7, -1),
  3170				BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
  3171				BPF_EXIT_INSN(),
  3172				BPF_ALU64_IMM(BPF_MOV, R5, 1),
  3173				BPF_ALU64_REG(BPF_SUB, R5, R5),
  3174				BPF_ALU64_REG(BPF_XOR, R6, R6),
  3175				BPF_ALU64_IMM(BPF_MOV, R1, 1),
  3176				BPF_ALU64_IMM(BPF_MOV, R8, -1),
  3177				BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
  3178				BPF_EXIT_INSN(),
  3179				BPF_ALU64_REG(BPF_SUB, R6, R6),
  3180				BPF_ALU64_REG(BPF_XOR, R7, R7),
  3181				BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
  3182				BPF_EXIT_INSN(),
  3183				BPF_ALU64_REG(BPF_SUB, R7, R7),
  3184				BPF_ALU64_REG(BPF_XOR, R8, R8),
  3185				BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
  3186				BPF_EXIT_INSN(),
  3187				BPF_ALU64_REG(BPF_SUB, R8, R8),
  3188				BPF_ALU64_REG(BPF_XOR, R9, R9),
  3189				BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
  3190				BPF_EXIT_INSN(),
  3191				BPF_ALU64_REG(BPF_SUB, R9, R9),
  3192				BPF_ALU64_REG(BPF_XOR, R0, R0),
  3193				BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
  3194				BPF_EXIT_INSN(),
  3195				BPF_ALU64_REG(BPF_SUB, R1, R1),
  3196				BPF_ALU64_REG(BPF_XOR, R0, R0),
  3197				BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
  3198				BPF_ALU64_IMM(BPF_MOV, R0, 0),
  3199				BPF_EXIT_INSN(),
  3200				BPF_ALU64_IMM(BPF_MOV, R0, 1),
  3201				BPF_EXIT_INSN(),
  3202			},
  3203			INTERNAL,
  3204			{ },
  3205			{ { 0, 1 } }
  3206		},
  3207		{	/* Mainly checking JIT here. */
  3208			"INT: MUL",
  3209			.u.insns_int = {
  3210				BPF_ALU64_IMM(BPF_MOV, R0, 11),
  3211				BPF_ALU64_IMM(BPF_MOV, R1, 1),
  3212				BPF_ALU64_IMM(BPF_MOV, R2, 2),
  3213				BPF_ALU64_IMM(BPF_MOV, R3, 3),
  3214				BPF_ALU64_IMM(BPF_MOV, R4, 4),
  3215				BPF_ALU64_IMM(BPF_MOV, R5, 5),
  3216				BPF_ALU64_IMM(BPF_MOV, R6, 6),
  3217				BPF_ALU64_IMM(BPF_MOV, R7, 7),
  3218				BPF_ALU64_IMM(BPF_MOV, R8, 8),
  3219				BPF_ALU64_IMM(BPF_MOV, R9, 9),
  3220				BPF_ALU64_REG(BPF_MUL, R0, R0),
  3221				BPF_ALU64_REG(BPF_MUL, R0, R1),
  3222				BPF_ALU64_REG(BPF_MUL, R0, R2),
  3223				BPF_ALU64_REG(BPF_MUL, R0, R3),
  3224				BPF_ALU64_REG(BPF_MUL, R0, R4),
  3225				BPF_ALU64_REG(BPF_MUL, R0, R5),
  3226				BPF_ALU64_REG(BPF_MUL, R0, R6),
  3227				BPF_ALU64_REG(BPF_MUL, R0, R7),
  3228				BPF_ALU64_REG(BPF_MUL, R0, R8),
  3229				BPF_ALU64_REG(BPF_MUL, R0, R9),
  3230				BPF_ALU64_IMM(BPF_MUL, R0, 10),
  3231				BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
  3232				BPF_EXIT_INSN(),
  3233				BPF_ALU64_REG(BPF_MUL, R1, R0),
  3234				BPF_ALU64_REG(BPF_MUL, R1, R2),
  3235				BPF_ALU64_REG(BPF_MUL, R1, R3),
  3236				BPF_ALU64_REG(BPF_MUL, R1, R4),
  3237				BPF_ALU64_REG(BPF_MUL, R1, R5),
  3238				BPF_ALU64_REG(BPF_MUL, R1, R6),
  3239				BPF_ALU64_REG(BPF_MUL, R1, R7),
  3240				BPF_ALU64_REG(BPF_MUL, R1, R8),
  3241				BPF_ALU64_REG(BPF_MUL, R1, R9),
  3242				BPF_ALU64_IMM(BPF_MUL, R1, 10),
  3243				BPF_ALU64_REG(BPF_MOV, R2, R1),
  3244				BPF_ALU64_IMM(BPF_RSH, R2, 32),
  3245				BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
  3246				BPF_EXIT_INSN(),
  3247				BPF_ALU64_IMM(BPF_LSH, R1, 32),
  3248				BPF_ALU64_IMM(BPF_ARSH, R1, 32),
  3249				BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
  3250				BPF_EXIT_INSN(),
  3251				BPF_ALU64_REG(BPF_MUL, R2, R0),
  3252				BPF_ALU64_REG(BPF_MUL, R2, R1),
  3253				BPF_ALU64_REG(BPF_MUL, R2, R3),
  3254				BPF_ALU64_REG(BPF_MUL, R2, R4),
  3255				BPF_ALU64_REG(BPF_MUL, R2, R5),
  3256				BPF_ALU64_REG(BPF_MUL, R2, R6),
  3257				BPF_ALU64_REG(BPF_MUL, R2, R7),
  3258				BPF_ALU64_REG(BPF_MUL, R2, R8),
  3259				BPF_ALU64_REG(BPF_MUL, R2, R9),
  3260				BPF_ALU64_IMM(BPF_MUL, R2, 10),
  3261				BPF_ALU64_IMM(BPF_RSH, R2, 32),
  3262				BPF_ALU64_REG(BPF_MOV, R0, R2),
  3263				BPF_EXIT_INSN(),
  3264			},
  3265			INTERNAL,
  3266			{ },
  3267			{ { 0, 0x35d97ef2 } }
  3268		},
  3269		{	/* Mainly checking JIT here. */
  3270			"MOV REG64",
  3271			.u.insns_int = {
  3272				BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
  3273				BPF_MOV64_REG(R1, R0),
  3274				BPF_MOV64_REG(R2, R1),
  3275				BPF_MOV64_REG(R3, R2),
  3276				BPF_MOV64_REG(R4, R3),
  3277				BPF_MOV64_REG(R5, R4),
  3278				BPF_MOV64_REG(R6, R5),
  3279				BPF_MOV64_REG(R7, R6),
  3280				BPF_MOV64_REG(R8, R7),
  3281				BPF_MOV64_REG(R9, R8),
  3282				BPF_ALU64_IMM(BPF_MOV, R0, 0),
  3283				BPF_ALU64_IMM(BPF_MOV, R1, 0),
  3284				BPF_ALU64_IMM(BPF_MOV, R2, 0),
  3285				BPF_ALU64_IMM(BPF_MOV, R3, 0),
  3286				BPF_ALU64_IMM(BPF_MOV, R4, 0),
  3287				BPF_ALU64_IMM(BPF_MOV, R5, 0),
  3288				BPF_ALU64_IMM(BPF_MOV, R6, 0),
  3289				BPF_ALU64_IMM(BPF_MOV, R7, 0),
  3290				BPF_ALU64_IMM(BPF_MOV, R8, 0),
  3291				BPF_ALU64_IMM(BPF_MOV, R9, 0),
  3292				BPF_ALU64_REG(BPF_ADD, R0, R0),
  3293				BPF_ALU64_REG(BPF_ADD, R0, R1),
  3294				BPF_ALU64_REG(BPF_ADD, R0, R2),
  3295				BPF_ALU64_REG(BPF_ADD, R0, R3),
  3296				BPF_ALU64_REG(BPF_ADD, R0, R4),
  3297				BPF_ALU64_REG(BPF_ADD, R0, R5),
  3298				BPF_ALU64_REG(BPF_ADD, R0, R6),
  3299				BPF_ALU64_REG(BPF_ADD, R0, R7),
  3300				BPF_ALU64_REG(BPF_ADD, R0, R8),
  3301				BPF_ALU64_REG(BPF_ADD, R0, R9),
  3302				BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
  3303				BPF_EXIT_INSN(),
  3304			},
  3305			INTERNAL,
  3306			{ },
  3307			{ { 0, 0xfefe } }
  3308		},
  3309		{	/* Mainly checking JIT here. */
  3310			"MOV REG32",
  3311			.u.insns_int = {
  3312				BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
  3313				BPF_MOV64_REG(R1, R0),
  3314				BPF_MOV64_REG(R2, R1),
  3315				BPF_MOV64_REG(R3, R2),
  3316				BPF_MOV64_REG(R4, R3),
  3317				BPF_MOV64_REG(R5, R4),
  3318				BPF_MOV64_REG(R6, R5),
  3319				BPF_MOV64_REG(R7, R6),
  3320				BPF_MOV64_REG(R8, R7),
  3321				BPF_MOV64_REG(R9, R8),
  3322				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  3323				BPF_ALU32_IMM(BPF_MOV, R1, 0),
  3324				BPF_ALU32_IMM(BPF_MOV, R2, 0),
  3325				BPF_ALU32_IMM(BPF_MOV, R3, 0),
  3326				BPF_ALU32_IMM(BPF_MOV, R4, 0),
  3327				BPF_ALU32_IMM(BPF_MOV, R5, 0),
  3328				BPF_ALU32_IMM(BPF_MOV, R6, 0),
  3329				BPF_ALU32_IMM(BPF_MOV, R7, 0),
  3330				BPF_ALU32_IMM(BPF_MOV, R8, 0),
  3331				BPF_ALU32_IMM(BPF_MOV, R9, 0),
  3332				BPF_ALU64_REG(BPF_ADD, R0, R0),
  3333				BPF_ALU64_REG(BPF_ADD, R0, R1),
  3334				BPF_ALU64_REG(BPF_ADD, R0, R2),
  3335				BPF_ALU64_REG(BPF_ADD, R0, R3),
  3336				BPF_ALU64_REG(BPF_ADD, R0, R4),
  3337				BPF_ALU64_REG(BPF_ADD, R0, R5),
  3338				BPF_ALU64_REG(BPF_ADD, R0, R6),
  3339				BPF_ALU64_REG(BPF_ADD, R0, R7),
  3340				BPF_ALU64_REG(BPF_ADD, R0, R8),
  3341				BPF_ALU64_REG(BPF_ADD, R0, R9),
  3342				BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
  3343				BPF_EXIT_INSN(),
  3344			},
  3345			INTERNAL,
  3346			{ },
  3347			{ { 0, 0xfefe } }
  3348		},
  3349		{	/* Mainly checking JIT here. */
  3350			"LD IMM64",
  3351			.u.insns_int = {
  3352				BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
  3353				BPF_MOV64_REG(R1, R0),
  3354				BPF_MOV64_REG(R2, R1),
  3355				BPF_MOV64_REG(R3, R2),
  3356				BPF_MOV64_REG(R4, R3),
  3357				BPF_MOV64_REG(R5, R4),
  3358				BPF_MOV64_REG(R6, R5),
  3359				BPF_MOV64_REG(R7, R6),
  3360				BPF_MOV64_REG(R8, R7),
  3361				BPF_MOV64_REG(R9, R8),
  3362				BPF_LD_IMM64(R0, 0x0LL),
  3363				BPF_LD_IMM64(R1, 0x0LL),
  3364				BPF_LD_IMM64(R2, 0x0LL),
  3365				BPF_LD_IMM64(R3, 0x0LL),
  3366				BPF_LD_IMM64(R4, 0x0LL),
  3367				BPF_LD_IMM64(R5, 0x0LL),
  3368				BPF_LD_IMM64(R6, 0x0LL),
  3369				BPF_LD_IMM64(R7, 0x0LL),
  3370				BPF_LD_IMM64(R8, 0x0LL),
  3371				BPF_LD_IMM64(R9, 0x0LL),
  3372				BPF_ALU64_REG(BPF_ADD, R0, R0),
  3373				BPF_ALU64_REG(BPF_ADD, R0, R1),
  3374				BPF_ALU64_REG(BPF_ADD, R0, R2),
  3375				BPF_ALU64_REG(BPF_ADD, R0, R3),
  3376				BPF_ALU64_REG(BPF_ADD, R0, R4),
  3377				BPF_ALU64_REG(BPF_ADD, R0, R5),
  3378				BPF_ALU64_REG(BPF_ADD, R0, R6),
  3379				BPF_ALU64_REG(BPF_ADD, R0, R7),
  3380				BPF_ALU64_REG(BPF_ADD, R0, R8),
  3381				BPF_ALU64_REG(BPF_ADD, R0, R9),
  3382				BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
  3383				BPF_EXIT_INSN(),
  3384			},
  3385			INTERNAL,
  3386			{ },
  3387			{ { 0, 0xfefe } }
  3388		},
  3389		{
  3390			"INT: ALU MIX",
  3391			.u.insns_int = {
  3392				BPF_ALU64_IMM(BPF_MOV, R0, 11),
  3393				BPF_ALU64_IMM(BPF_ADD, R0, -1),
  3394				BPF_ALU64_IMM(BPF_MOV, R2, 2),
  3395				BPF_ALU64_IMM(BPF_XOR, R2, 3),
  3396				BPF_ALU64_REG(BPF_DIV, R0, R2),
  3397				BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
  3398				BPF_EXIT_INSN(),
  3399				BPF_ALU64_IMM(BPF_MOD, R0, 3),
  3400				BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
  3401				BPF_EXIT_INSN(),
  3402				BPF_ALU64_IMM(BPF_MOV, R0, -1),
  3403				BPF_EXIT_INSN(),
  3404			},
  3405			INTERNAL,
  3406			{ },
  3407			{ { 0, -1 } }
  3408		},
  3409		{
  3410			"INT: shifts by register",
  3411			.u.insns_int = {
  3412				BPF_MOV64_IMM(R0, -1234),
  3413				BPF_MOV64_IMM(R1, 1),
  3414				BPF_ALU32_REG(BPF_RSH, R0, R1),
  3415				BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
  3416				BPF_EXIT_INSN(),
  3417				BPF_MOV64_IMM(R2, 1),
  3418				BPF_ALU64_REG(BPF_LSH, R0, R2),
  3419				BPF_MOV32_IMM(R4, -1234),
  3420				BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
  3421				BPF_EXIT_INSN(),
  3422				BPF_ALU64_IMM(BPF_AND, R4, 63),
  3423				BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
  3424				BPF_MOV64_IMM(R3, 47),
  3425				BPF_ALU64_REG(BPF_ARSH, R0, R3),
  3426				BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
  3427				BPF_EXIT_INSN(),
  3428				BPF_MOV64_IMM(R2, 1),
  3429				BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
  3430				BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
  3431				BPF_EXIT_INSN(),
  3432				BPF_MOV64_IMM(R4, 4),
  3433				BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
  3434				BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
  3435				BPF_EXIT_INSN(),
  3436				BPF_MOV64_IMM(R4, 5),
  3437				BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
  3438				BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
  3439				BPF_EXIT_INSN(),
  3440				BPF_MOV64_IMM(R0, -1),
  3441				BPF_EXIT_INSN(),
  3442			},
  3443			INTERNAL,
  3444			{ },
  3445			{ { 0, -1 } }
  3446		},
  3447		{
  3448			/*
  3449			 * Register (non-)clobbering test, in the case where a 32-bit
  3450			 * JIT implements complex ALU64 operations via function calls.
  3451			 * If so, the function call must be invisible in the eBPF
  3452			 * registers. The JIT must then save and restore relevant
  3453			 * registers during the call. The following tests check that
  3454			 * the eBPF registers retain their values after such a call.
  3455			 */
  3456			"INT: Register clobbering, R1 updated",
  3457			.u.insns_int = {
  3458				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  3459				BPF_ALU32_IMM(BPF_MOV, R1, 123456789),
  3460				BPF_ALU32_IMM(BPF_MOV, R2, 2),
  3461				BPF_ALU32_IMM(BPF_MOV, R3, 3),
  3462				BPF_ALU32_IMM(BPF_MOV, R4, 4),
  3463				BPF_ALU32_IMM(BPF_MOV, R5, 5),
  3464				BPF_ALU32_IMM(BPF_MOV, R6, 6),
  3465				BPF_ALU32_IMM(BPF_MOV, R7, 7),
  3466				BPF_ALU32_IMM(BPF_MOV, R8, 8),
  3467				BPF_ALU32_IMM(BPF_MOV, R9, 9),
  3468				BPF_ALU64_IMM(BPF_DIV, R1, 123456789),
  3469				BPF_JMP_IMM(BPF_JNE, R0, 0, 10),
  3470				BPF_JMP_IMM(BPF_JNE, R1, 1, 9),
  3471				BPF_JMP_IMM(BPF_JNE, R2, 2, 8),
  3472				BPF_JMP_IMM(BPF_JNE, R3, 3, 7),
  3473				BPF_JMP_IMM(BPF_JNE, R4, 4, 6),
  3474				BPF_JMP_IMM(BPF_JNE, R5, 5, 5),
  3475				BPF_JMP_IMM(BPF_JNE, R6, 6, 4),
  3476				BPF_JMP_IMM(BPF_JNE, R7, 7, 3),
  3477				BPF_JMP_IMM(BPF_JNE, R8, 8, 2),
  3478				BPF_JMP_IMM(BPF_JNE, R9, 9, 1),
  3479				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  3480				BPF_EXIT_INSN(),
  3481			},
  3482			INTERNAL,
  3483			{ },
  3484			{ { 0, 1 } }
  3485		},
  3486		{
  3487			"INT: Register clobbering, R2 updated",
  3488			.u.insns_int = {
  3489				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  3490				BPF_ALU32_IMM(BPF_MOV, R1, 1),
  3491				BPF_ALU32_IMM(BPF_MOV, R2, 2 * 123456789),
  3492				BPF_ALU32_IMM(BPF_MOV, R3, 3),
  3493				BPF_ALU32_IMM(BPF_MOV, R4, 4),
  3494				BPF_ALU32_IMM(BPF_MOV, R5, 5),
  3495				BPF_ALU32_IMM(BPF_MOV, R6, 6),
  3496				BPF_ALU32_IMM(BPF_MOV, R7, 7),
  3497				BPF_ALU32_IMM(BPF_MOV, R8, 8),
  3498				BPF_ALU32_IMM(BPF_MOV, R9, 9),
  3499				BPF_ALU64_IMM(BPF_DIV, R2, 123456789),
  3500				BPF_JMP_IMM(BPF_JNE, R0, 0, 10),
  3501				BPF_JMP_IMM(BPF_JNE, R1, 1, 9),
  3502				BPF_JMP_IMM(BPF_JNE, R2, 2, 8),
  3503				BPF_JMP_IMM(BPF_JNE, R3, 3, 7),
  3504				BPF_JMP_IMM(BPF_JNE, R4, 4, 6),
  3505				BPF_JMP_IMM(BPF_JNE, R5, 5, 5),
  3506				BPF_JMP_IMM(BPF_JNE, R6, 6, 4),
  3507				BPF_JMP_IMM(BPF_JNE, R7, 7, 3),
  3508				BPF_JMP_IMM(BPF_JNE, R8, 8, 2),
  3509				BPF_JMP_IMM(BPF_JNE, R9, 9, 1),
  3510				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  3511				BPF_EXIT_INSN(),
  3512			},
  3513			INTERNAL,
  3514			{ },
  3515			{ { 0, 1 } }
  3516		},
  3517		{
  3518			/*
  3519			 * Test 32-bit JITs that implement complex ALU64 operations as
  3520			 * function calls R0 = f(R1, R2), and must re-arrange operands.
  3521			 */
  3522	#define NUMER 0xfedcba9876543210ULL
  3523	#define DENOM 0x0123456789abcdefULL
  3524			"ALU64_DIV X: Operand register permutations",
  3525			.u.insns_int = {
  3526				/* R0 / R2 */
  3527				BPF_LD_IMM64(R0, NUMER),
  3528				BPF_LD_IMM64(R2, DENOM),
  3529				BPF_ALU64_REG(BPF_DIV, R0, R2),
  3530				BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
  3531				BPF_EXIT_INSN(),
  3532				/* R1 / R0 */
  3533				BPF_LD_IMM64(R1, NUMER),
  3534				BPF_LD_IMM64(R0, DENOM),
  3535				BPF_ALU64_REG(BPF_DIV, R1, R0),
  3536				BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
  3537				BPF_EXIT_INSN(),
  3538				/* R0 / R1 */
  3539				BPF_LD_IMM64(R0, NUMER),
  3540				BPF_LD_IMM64(R1, DENOM),
  3541				BPF_ALU64_REG(BPF_DIV, R0, R1),
  3542				BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
  3543				BPF_EXIT_INSN(),
  3544				/* R2 / R0 */
  3545				BPF_LD_IMM64(R2, NUMER),
  3546				BPF_LD_IMM64(R0, DENOM),
  3547				BPF_ALU64_REG(BPF_DIV, R2, R0),
  3548				BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
  3549				BPF_EXIT_INSN(),
  3550				/* R2 / R1 */
  3551				BPF_LD_IMM64(R2, NUMER),
  3552				BPF_LD_IMM64(R1, DENOM),
  3553				BPF_ALU64_REG(BPF_DIV, R2, R1),
  3554				BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
  3555				BPF_EXIT_INSN(),
  3556				/* R1 / R2 */
  3557				BPF_LD_IMM64(R1, NUMER),
  3558				BPF_LD_IMM64(R2, DENOM),
  3559				BPF_ALU64_REG(BPF_DIV, R1, R2),
  3560				BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
  3561				BPF_EXIT_INSN(),
  3562				/* R1 / R1 */
  3563				BPF_LD_IMM64(R1, NUMER),
  3564				BPF_ALU64_REG(BPF_DIV, R1, R1),
  3565				BPF_JMP_IMM(BPF_JEQ, R1, 1, 1),
  3566				BPF_EXIT_INSN(),
  3567				/* R2 / R2 */
  3568				BPF_LD_IMM64(R2, DENOM),
  3569				BPF_ALU64_REG(BPF_DIV, R2, R2),
  3570				BPF_JMP_IMM(BPF_JEQ, R2, 1, 1),
  3571				BPF_EXIT_INSN(),
  3572				/* R3 / R4 */
  3573				BPF_LD_IMM64(R3, NUMER),
  3574				BPF_LD_IMM64(R4, DENOM),
  3575				BPF_ALU64_REG(BPF_DIV, R3, R4),
  3576				BPF_JMP_IMM(BPF_JEQ, R3, NUMER / DENOM, 1),
  3577				BPF_EXIT_INSN(),
  3578				/* Successful return */
  3579				BPF_LD_IMM64(R0, 1),
  3580				BPF_EXIT_INSN(),
  3581			},
  3582			INTERNAL,
  3583			{ },
  3584			{ { 0, 1 } },
  3585	#undef NUMER
  3586	#undef DENOM
  3587		},
  3588	#ifdef CONFIG_32BIT
  3589		{
  3590			"INT: 32-bit context pointer word order and zero-extension",
  3591			.u.insns_int = {
  3592				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  3593				BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
  3594				BPF_ALU64_IMM(BPF_RSH, R1, 32),
  3595				BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
  3596				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  3597				BPF_EXIT_INSN(),
  3598			},
  3599			INTERNAL,
  3600			{ },
  3601			{ { 0, 1 } }
  3602		},
  3603	#endif
  3604		{
  3605			"check: missing ret",
  3606			.u.insns = {
  3607				BPF_STMT(BPF_LD | BPF_IMM, 1),
  3608			},
  3609			CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
  3610			{ },
  3611			{ },
  3612			.fill_helper = NULL,
  3613			.expected_errcode = -EINVAL,
  3614		},
  3615		{
  3616			"check: div_k_0",
  3617			.u.insns = {
  3618				BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
  3619				BPF_STMT(BPF_RET | BPF_K, 0)
  3620			},
  3621			CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
  3622			{ },
  3623			{ },
  3624			.fill_helper = NULL,
  3625			.expected_errcode = -EINVAL,
  3626		},
  3627		{
  3628			"check: unknown insn",
  3629			.u.insns = {
  3630				/* seccomp insn, rejected in socket filter */
  3631				BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
  3632				BPF_STMT(BPF_RET | BPF_K, 0)
  3633			},
  3634			CLASSIC | FLAG_EXPECTED_FAIL,
  3635			{ },
  3636			{ },
  3637			.fill_helper = NULL,
  3638			.expected_errcode = -EINVAL,
  3639		},
  3640		{
  3641			"check: out of range spill/fill",
  3642			.u.insns = {
  3643				BPF_STMT(BPF_STX, 16),
  3644				BPF_STMT(BPF_RET | BPF_K, 0)
  3645			},
  3646			CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
  3647			{ },
  3648			{ },
  3649			.fill_helper = NULL,
  3650			.expected_errcode = -EINVAL,
  3651		},
  3652		{
  3653			"JUMPS + HOLES",
  3654			.u.insns = {
  3655				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3656				BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
  3657				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3658				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3659				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3660				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3661				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3662				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3663				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3664				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3665				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3666				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3667				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3668				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3669				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3670				BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
  3671				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3672				BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
  3673				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3674				BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
  3675				BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
  3676				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3677				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3678				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3679				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3680				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3681				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3682				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3683				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3684				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3685				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3686				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3687				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3688				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3689				BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
  3690				BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
  3691				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3692				BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
  3693				BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
  3694				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3695				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3696				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3697				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3698				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3699				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3700				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3701				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3702				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3703				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3704				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3705				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3706				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3707				BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
  3708				BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
  3709				BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
  3710				BPF_STMT(BPF_RET | BPF_A, 0),
  3711				BPF_STMT(BPF_RET | BPF_A, 0),
  3712			},
  3713			CLASSIC,
  3714			{ 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
  3715			  0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
  3716			  0x08, 0x00,
  3717			  0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
  3718			  0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
  3719			  0xc0, 0xa8, 0x33, 0x01,
  3720			  0xc0, 0xa8, 0x33, 0x02,
  3721			  0xbb, 0xb6,
  3722			  0xa9, 0xfa,
  3723			  0x00, 0x14, 0x00, 0x00,
  3724			  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
  3725			  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
  3726			  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
  3727			  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
  3728			  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
  3729			  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
  3730			  0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
  3731			  0xcc, 0xcc, 0xcc, 0xcc },
  3732			{ { 88, 0x001b } }
  3733		},
  3734		{
  3735			"check: RET X",
  3736			.u.insns = {
  3737				BPF_STMT(BPF_RET | BPF_X, 0),
  3738			},
  3739			CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
  3740			{ },
  3741			{ },
  3742			.fill_helper = NULL,
  3743			.expected_errcode = -EINVAL,
  3744		},
  3745		{
  3746			"check: LDX + RET X",
  3747			.u.insns = {
  3748				BPF_STMT(BPF_LDX | BPF_IMM, 42),
  3749				BPF_STMT(BPF_RET | BPF_X, 0),
  3750			},
  3751			CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
  3752			{ },
  3753			{ },
  3754			.fill_helper = NULL,
  3755			.expected_errcode = -EINVAL,
  3756		},
  3757		{	/* Mainly checking JIT here. */
  3758			"M[]: alt STX + LDX",
  3759			.u.insns = {
  3760				BPF_STMT(BPF_LDX | BPF_IMM, 100),
  3761				BPF_STMT(BPF_STX, 0),
  3762				BPF_STMT(BPF_LDX | BPF_MEM, 0),
  3763				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3764				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3765				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3766				BPF_STMT(BPF_STX, 1),
  3767				BPF_STMT(BPF_LDX | BPF_MEM, 1),
  3768				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3769				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3770				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3771				BPF_STMT(BPF_STX, 2),
  3772				BPF_STMT(BPF_LDX | BPF_MEM, 2),
  3773				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3774				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3775				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3776				BPF_STMT(BPF_STX, 3),
  3777				BPF_STMT(BPF_LDX | BPF_MEM, 3),
  3778				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3779				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3780				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3781				BPF_STMT(BPF_STX, 4),
  3782				BPF_STMT(BPF_LDX | BPF_MEM, 4),
  3783				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3784				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3785				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3786				BPF_STMT(BPF_STX, 5),
  3787				BPF_STMT(BPF_LDX | BPF_MEM, 5),
  3788				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3789				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3790				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3791				BPF_STMT(BPF_STX, 6),
  3792				BPF_STMT(BPF_LDX | BPF_MEM, 6),
  3793				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3794				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3795				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3796				BPF_STMT(BPF_STX, 7),
  3797				BPF_STMT(BPF_LDX | BPF_MEM, 7),
  3798				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3799				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3800				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3801				BPF_STMT(BPF_STX, 8),
  3802				BPF_STMT(BPF_LDX | BPF_MEM, 8),
  3803				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3804				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3805				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3806				BPF_STMT(BPF_STX, 9),
  3807				BPF_STMT(BPF_LDX | BPF_MEM, 9),
  3808				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3809				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3810				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3811				BPF_STMT(BPF_STX, 10),
  3812				BPF_STMT(BPF_LDX | BPF_MEM, 10),
  3813				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3814				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3815				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3816				BPF_STMT(BPF_STX, 11),
  3817				BPF_STMT(BPF_LDX | BPF_MEM, 11),
  3818				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3819				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3820				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3821				BPF_STMT(BPF_STX, 12),
  3822				BPF_STMT(BPF_LDX | BPF_MEM, 12),
  3823				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3824				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3825				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3826				BPF_STMT(BPF_STX, 13),
  3827				BPF_STMT(BPF_LDX | BPF_MEM, 13),
  3828				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3829				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3830				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3831				BPF_STMT(BPF_STX, 14),
  3832				BPF_STMT(BPF_LDX | BPF_MEM, 14),
  3833				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3834				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3835				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3836				BPF_STMT(BPF_STX, 15),
  3837				BPF_STMT(BPF_LDX | BPF_MEM, 15),
  3838				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3839				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
  3840				BPF_STMT(BPF_MISC | BPF_TAX, 0),
  3841				BPF_STMT(BPF_RET | BPF_A, 0),
  3842			},
  3843			CLASSIC | FLAG_NO_DATA,
  3844			{ },
  3845			{ { 0, 116 } },
  3846		},
  3847		{	/* Mainly checking JIT here. */
  3848			"M[]: full STX + full LDX",
  3849			.u.insns = {
  3850				BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
  3851				BPF_STMT(BPF_STX, 0),
  3852				BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
  3853				BPF_STMT(BPF_STX, 1),
  3854				BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
  3855				BPF_STMT(BPF_STX, 2),
  3856				BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
  3857				BPF_STMT(BPF_STX, 3),
  3858				BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
  3859				BPF_STMT(BPF_STX, 4),
  3860				BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
  3861				BPF_STMT(BPF_STX, 5),
  3862				BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
  3863				BPF_STMT(BPF_STX, 6),
  3864				BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
  3865				BPF_STMT(BPF_STX, 7),
  3866				BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
  3867				BPF_STMT(BPF_STX, 8),
  3868				BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
  3869				BPF_STMT(BPF_STX, 9),
  3870				BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
  3871				BPF_STMT(BPF_STX, 10),
  3872				BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
  3873				BPF_STMT(BPF_STX, 11),
  3874				BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
  3875				BPF_STMT(BPF_STX, 12),
  3876				BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
  3877				BPF_STMT(BPF_STX, 13),
  3878				BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
  3879				BPF_STMT(BPF_STX, 14),
  3880				BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
  3881				BPF_STMT(BPF_STX, 15),
  3882				BPF_STMT(BPF_LDX | BPF_MEM, 0),
  3883				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  3884				BPF_STMT(BPF_LDX | BPF_MEM, 1),
  3885				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3886				BPF_STMT(BPF_LDX | BPF_MEM, 2),
  3887				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3888				BPF_STMT(BPF_LDX | BPF_MEM, 3),
  3889				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3890				BPF_STMT(BPF_LDX | BPF_MEM, 4),
  3891				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3892				BPF_STMT(BPF_LDX | BPF_MEM, 5),
  3893				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3894				BPF_STMT(BPF_LDX | BPF_MEM, 6),
  3895				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3896				BPF_STMT(BPF_LDX | BPF_MEM, 7),
  3897				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3898				BPF_STMT(BPF_LDX | BPF_MEM, 8),
  3899				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3900				BPF_STMT(BPF_LDX | BPF_MEM, 9),
  3901				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3902				BPF_STMT(BPF_LDX | BPF_MEM, 10),
  3903				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3904				BPF_STMT(BPF_LDX | BPF_MEM, 11),
  3905				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3906				BPF_STMT(BPF_LDX | BPF_MEM, 12),
  3907				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3908				BPF_STMT(BPF_LDX | BPF_MEM, 13),
  3909				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3910				BPF_STMT(BPF_LDX | BPF_MEM, 14),
  3911				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3912				BPF_STMT(BPF_LDX | BPF_MEM, 15),
  3913				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  3914				BPF_STMT(BPF_RET | BPF_A, 0),
  3915			},
  3916			CLASSIC | FLAG_NO_DATA,
  3917			{ },
  3918			{ { 0, 0x2a5a5e5 } },
  3919		},
  3920		{
  3921			"check: SKF_AD_MAX",
  3922			.u.insns = {
  3923				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  3924					 SKF_AD_OFF + SKF_AD_MAX),
  3925				BPF_STMT(BPF_RET | BPF_A, 0),
  3926			},
  3927			CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
  3928			{ },
  3929			{ },
  3930			.fill_helper = NULL,
  3931			.expected_errcode = -EINVAL,
  3932		},
  3933		{	/* Passes checker but fails during runtime. */
  3934			"LD [SKF_AD_OFF-1]",
  3935			.u.insns = {
  3936				BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
  3937					 SKF_AD_OFF - 1),
  3938				BPF_STMT(BPF_RET | BPF_K, 1),
  3939			},
  3940			CLASSIC,
  3941			{ },
  3942			{ { 1, 0 } },
  3943		},
  3944		{
  3945			"load 64-bit immediate",
  3946			.u.insns_int = {
  3947				BPF_LD_IMM64(R1, 0x567800001234LL),
  3948				BPF_MOV64_REG(R2, R1),
  3949				BPF_MOV64_REG(R3, R2),
  3950				BPF_ALU64_IMM(BPF_RSH, R2, 32),
  3951				BPF_ALU64_IMM(BPF_LSH, R3, 32),
  3952				BPF_ALU64_IMM(BPF_RSH, R3, 32),
  3953				BPF_ALU64_IMM(BPF_MOV, R0, 0),
  3954				BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
  3955				BPF_EXIT_INSN(),
  3956				BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
  3957				BPF_EXIT_INSN(),
  3958				BPF_LD_IMM64(R0, 0x1ffffffffLL),
  3959				BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
  3960				BPF_EXIT_INSN(),
  3961			},
  3962			INTERNAL,
  3963			{ },
  3964			{ { 0, 1 } }
  3965		},
  3966		/* BPF_ALU | BPF_MOV | BPF_X */
  3967		{
  3968			"ALU_MOV_X: dst = 2",
  3969			.u.insns_int = {
  3970				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  3971				BPF_ALU32_REG(BPF_MOV, R0, R1),
  3972				BPF_EXIT_INSN(),
  3973			},
  3974			INTERNAL,
  3975			{ },
  3976			{ { 0, 2 } },
  3977		},
  3978		{
  3979			"ALU_MOV_X: dst = 4294967295",
  3980			.u.insns_int = {
  3981				BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
  3982				BPF_ALU32_REG(BPF_MOV, R0, R1),
  3983				BPF_EXIT_INSN(),
  3984			},
  3985			INTERNAL,
  3986			{ },
  3987			{ { 0, 4294967295U } },
  3988		},
  3989		{
  3990			"ALU64_MOV_X: dst = 2",
  3991			.u.insns_int = {
  3992				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  3993				BPF_ALU64_REG(BPF_MOV, R0, R1),
  3994				BPF_EXIT_INSN(),
  3995			},
  3996			INTERNAL,
  3997			{ },
  3998			{ { 0, 2 } },
  3999		},
  4000		{
  4001			"ALU64_MOV_X: dst = 4294967295",
  4002			.u.insns_int = {
  4003				BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
  4004				BPF_ALU64_REG(BPF_MOV, R0, R1),
  4005				BPF_EXIT_INSN(),
  4006			},
  4007			INTERNAL,
  4008			{ },
  4009			{ { 0, 4294967295U } },
  4010		},
  4011		/* BPF_ALU | BPF_MOV | BPF_K */
  4012		{
  4013			"ALU_MOV_K: dst = 2",
  4014			.u.insns_int = {
  4015				BPF_ALU32_IMM(BPF_MOV, R0, 2),
  4016				BPF_EXIT_INSN(),
  4017			},
  4018			INTERNAL,
  4019			{ },
  4020			{ { 0, 2 } },
  4021		},
  4022		{
  4023			"ALU_MOV_K: dst = 4294967295",
  4024			.u.insns_int = {
  4025				BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
  4026				BPF_EXIT_INSN(),
  4027			},
  4028			INTERNAL,
  4029			{ },
  4030			{ { 0, 4294967295U } },
  4031		},
  4032		{
  4033			"ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
  4034			.u.insns_int = {
  4035				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  4036				BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
  4037				BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
  4038				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4039				BPF_MOV32_IMM(R0, 2),
  4040				BPF_EXIT_INSN(),
  4041				BPF_MOV32_IMM(R0, 1),
  4042				BPF_EXIT_INSN(),
  4043			},
  4044			INTERNAL,
  4045			{ },
  4046			{ { 0, 0x1 } },
  4047		},
  4048		{
  4049			"ALU_MOV_K: small negative",
  4050			.u.insns_int = {
  4051				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  4052				BPF_EXIT_INSN(),
  4053			},
  4054			INTERNAL,
  4055			{ },
  4056			{ { 0, -123 } }
  4057		},
  4058		{
  4059			"ALU_MOV_K: small negative zero extension",
  4060			.u.insns_int = {
  4061				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  4062				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  4063				BPF_EXIT_INSN(),
  4064			},
  4065			INTERNAL,
  4066			{ },
  4067			{ { 0, 0 } }
  4068		},
  4069		{
  4070			"ALU_MOV_K: large negative",
  4071			.u.insns_int = {
  4072				BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
  4073				BPF_EXIT_INSN(),
  4074			},
  4075			INTERNAL,
  4076			{ },
  4077			{ { 0, -123456789 } }
  4078		},
  4079		{
  4080			"ALU_MOV_K: large negative zero extension",
  4081			.u.insns_int = {
  4082				BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
  4083				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  4084				BPF_EXIT_INSN(),
  4085			},
  4086			INTERNAL,
  4087			{ },
  4088			{ { 0, 0 } }
  4089		},
  4090		{
  4091			"ALU64_MOV_K: dst = 2",
  4092			.u.insns_int = {
  4093				BPF_ALU64_IMM(BPF_MOV, R0, 2),
  4094				BPF_EXIT_INSN(),
  4095			},
  4096			INTERNAL,
  4097			{ },
  4098			{ { 0, 2 } },
  4099		},
  4100		{
  4101			"ALU64_MOV_K: dst = 2147483647",
  4102			.u.insns_int = {
  4103				BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
  4104				BPF_EXIT_INSN(),
  4105			},
  4106			INTERNAL,
  4107			{ },
  4108			{ { 0, 2147483647 } },
  4109		},
  4110		{
  4111			"ALU64_OR_K: dst = 0x0",
  4112			.u.insns_int = {
  4113				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  4114				BPF_LD_IMM64(R3, 0x0),
  4115				BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
  4116				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4117				BPF_MOV32_IMM(R0, 2),
  4118				BPF_EXIT_INSN(),
  4119				BPF_MOV32_IMM(R0, 1),
  4120				BPF_EXIT_INSN(),
  4121			},
  4122			INTERNAL,
  4123			{ },
  4124			{ { 0, 0x1 } },
  4125		},
  4126		{
  4127			"ALU64_MOV_K: dst = -1",
  4128			.u.insns_int = {
  4129				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  4130				BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
  4131				BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
  4132				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4133				BPF_MOV32_IMM(R0, 2),
  4134				BPF_EXIT_INSN(),
  4135				BPF_MOV32_IMM(R0, 1),
  4136				BPF_EXIT_INSN(),
  4137			},
  4138			INTERNAL,
  4139			{ },
  4140			{ { 0, 0x1 } },
  4141		},
  4142		{
  4143			"ALU64_MOV_K: small negative",
  4144			.u.insns_int = {
  4145				BPF_ALU64_IMM(BPF_MOV, R0, -123),
  4146				BPF_EXIT_INSN(),
  4147			},
  4148			INTERNAL,
  4149			{ },
  4150			{ { 0, -123 } }
  4151		},
  4152		{
  4153			"ALU64_MOV_K: small negative sign extension",
  4154			.u.insns_int = {
  4155				BPF_ALU64_IMM(BPF_MOV, R0, -123),
  4156				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  4157				BPF_EXIT_INSN(),
  4158			},
  4159			INTERNAL,
  4160			{ },
  4161			{ { 0, 0xffffffff } }
  4162		},
  4163		{
  4164			"ALU64_MOV_K: large negative",
  4165			.u.insns_int = {
  4166				BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
  4167				BPF_EXIT_INSN(),
  4168			},
  4169			INTERNAL,
  4170			{ },
  4171			{ { 0, -123456789 } }
  4172		},
  4173		{
  4174			"ALU64_MOV_K: large negative sign extension",
  4175			.u.insns_int = {
  4176				BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
  4177				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  4178				BPF_EXIT_INSN(),
  4179			},
  4180			INTERNAL,
  4181			{ },
  4182			{ { 0, 0xffffffff } }
  4183		},
  4184		/* BPF_ALU | BPF_ADD | BPF_X */
  4185		{
  4186			"ALU_ADD_X: 1 + 2 = 3",
  4187			.u.insns_int = {
  4188				BPF_LD_IMM64(R0, 1),
  4189				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  4190				BPF_ALU32_REG(BPF_ADD, R0, R1),
  4191				BPF_EXIT_INSN(),
  4192			},
  4193			INTERNAL,
  4194			{ },
  4195			{ { 0, 3 } },
  4196		},
  4197		{
  4198			"ALU_ADD_X: 1 + 4294967294 = 4294967295",
  4199			.u.insns_int = {
  4200				BPF_LD_IMM64(R0, 1),
  4201				BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
  4202				BPF_ALU32_REG(BPF_ADD, R0, R1),
  4203				BPF_EXIT_INSN(),
  4204			},
  4205			INTERNAL,
  4206			{ },
  4207			{ { 0, 4294967295U } },
  4208		},
  4209		{
  4210			"ALU_ADD_X: 2 + 4294967294 = 0",
  4211			.u.insns_int = {
  4212				BPF_LD_IMM64(R0, 2),
  4213				BPF_LD_IMM64(R1, 4294967294U),
  4214				BPF_ALU32_REG(BPF_ADD, R0, R1),
  4215				BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
  4216				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  4217				BPF_EXIT_INSN(),
  4218				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  4219				BPF_EXIT_INSN(),
  4220			},
  4221			INTERNAL,
  4222			{ },
  4223			{ { 0, 1 } },
  4224		},
  4225		{
  4226			"ALU64_ADD_X: 1 + 2 = 3",
  4227			.u.insns_int = {
  4228				BPF_LD_IMM64(R0, 1),
  4229				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  4230				BPF_ALU64_REG(BPF_ADD, R0, R1),
  4231				BPF_EXIT_INSN(),
  4232			},
  4233			INTERNAL,
  4234			{ },
  4235			{ { 0, 3 } },
  4236		},
  4237		{
  4238			"ALU64_ADD_X: 1 + 4294967294 = 4294967295",
  4239			.u.insns_int = {
  4240				BPF_LD_IMM64(R0, 1),
  4241				BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
  4242				BPF_ALU64_REG(BPF_ADD, R0, R1),
  4243				BPF_EXIT_INSN(),
  4244			},
  4245			INTERNAL,
  4246			{ },
  4247			{ { 0, 4294967295U } },
  4248		},
  4249		{
  4250			"ALU64_ADD_X: 2 + 4294967294 = 4294967296",
  4251			.u.insns_int = {
  4252				BPF_LD_IMM64(R0, 2),
  4253				BPF_LD_IMM64(R1, 4294967294U),
  4254				BPF_LD_IMM64(R2, 4294967296ULL),
  4255				BPF_ALU64_REG(BPF_ADD, R0, R1),
  4256				BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
  4257				BPF_MOV32_IMM(R0, 0),
  4258				BPF_EXIT_INSN(),
  4259				BPF_MOV32_IMM(R0, 1),
  4260				BPF_EXIT_INSN(),
  4261			},
  4262			INTERNAL,
  4263			{ },
  4264			{ { 0, 1 } },
  4265		},
  4266		/* BPF_ALU | BPF_ADD | BPF_K */
  4267		{
  4268			"ALU_ADD_K: 1 + 2 = 3",
  4269			.u.insns_int = {
  4270				BPF_LD_IMM64(R0, 1),
  4271				BPF_ALU32_IMM(BPF_ADD, R0, 2),
  4272				BPF_EXIT_INSN(),
  4273			},
  4274			INTERNAL,
  4275			{ },
  4276			{ { 0, 3 } },
  4277		},
  4278		{
  4279			"ALU_ADD_K: 3 + 0 = 3",
  4280			.u.insns_int = {
  4281				BPF_LD_IMM64(R0, 3),
  4282				BPF_ALU32_IMM(BPF_ADD, R0, 0),
  4283				BPF_EXIT_INSN(),
  4284			},
  4285			INTERNAL,
  4286			{ },
  4287			{ { 0, 3 } },
  4288		},
  4289		{
  4290			"ALU_ADD_K: 1 + 4294967294 = 4294967295",
  4291			.u.insns_int = {
  4292				BPF_LD_IMM64(R0, 1),
  4293				BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
  4294				BPF_EXIT_INSN(),
  4295			},
  4296			INTERNAL,
  4297			{ },
  4298			{ { 0, 4294967295U } },
  4299		},
  4300		{
  4301			"ALU_ADD_K: 4294967294 + 2 = 0",
  4302			.u.insns_int = {
  4303				BPF_LD_IMM64(R0, 4294967294U),
  4304				BPF_ALU32_IMM(BPF_ADD, R0, 2),
  4305				BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
  4306				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  4307				BPF_EXIT_INSN(),
  4308				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  4309				BPF_EXIT_INSN(),
  4310			},
  4311			INTERNAL,
  4312			{ },
  4313			{ { 0, 1 } },
  4314		},
  4315		{
  4316			"ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
  4317			.u.insns_int = {
  4318				BPF_LD_IMM64(R2, 0x0),
  4319				BPF_LD_IMM64(R3, 0x00000000ffffffff),
  4320				BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
  4321				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4322				BPF_MOV32_IMM(R0, 2),
  4323				BPF_EXIT_INSN(),
  4324				BPF_MOV32_IMM(R0, 1),
  4325				BPF_EXIT_INSN(),
  4326			},
  4327			INTERNAL,
  4328			{ },
  4329			{ { 0, 0x1 } },
  4330		},
  4331		{
  4332			"ALU_ADD_K: 0 + 0xffff = 0xffff",
  4333			.u.insns_int = {
  4334				BPF_LD_IMM64(R2, 0x0),
  4335				BPF_LD_IMM64(R3, 0xffff),
  4336				BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
  4337				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4338				BPF_MOV32_IMM(R0, 2),
  4339				BPF_EXIT_INSN(),
  4340				BPF_MOV32_IMM(R0, 1),
  4341				BPF_EXIT_INSN(),
  4342			},
  4343			INTERNAL,
  4344			{ },
  4345			{ { 0, 0x1 } },
  4346		},
  4347		{
  4348			"ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
  4349			.u.insns_int = {
  4350				BPF_LD_IMM64(R2, 0x0),
  4351				BPF_LD_IMM64(R3, 0x7fffffff),
  4352				BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
  4353				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4354				BPF_MOV32_IMM(R0, 2),
  4355				BPF_EXIT_INSN(),
  4356				BPF_MOV32_IMM(R0, 1),
  4357				BPF_EXIT_INSN(),
  4358			},
  4359			INTERNAL,
  4360			{ },
  4361			{ { 0, 0x1 } },
  4362		},
  4363		{
  4364			"ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
  4365			.u.insns_int = {
  4366				BPF_LD_IMM64(R2, 0x0),
  4367				BPF_LD_IMM64(R3, 0x80000000),
  4368				BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
  4369				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4370				BPF_MOV32_IMM(R0, 2),
  4371				BPF_EXIT_INSN(),
  4372				BPF_MOV32_IMM(R0, 1),
  4373				BPF_EXIT_INSN(),
  4374			},
  4375			INTERNAL,
  4376			{ },
  4377			{ { 0, 0x1 } },
  4378		},
  4379		{
  4380			"ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
  4381			.u.insns_int = {
  4382				BPF_LD_IMM64(R2, 0x0),
  4383				BPF_LD_IMM64(R3, 0x80008000),
  4384				BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
  4385				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4386				BPF_MOV32_IMM(R0, 2),
  4387				BPF_EXIT_INSN(),
  4388				BPF_MOV32_IMM(R0, 1),
  4389				BPF_EXIT_INSN(),
  4390			},
  4391			INTERNAL,
  4392			{ },
  4393			{ { 0, 0x1 } },
  4394		},
  4395		{
  4396			"ALU64_ADD_K: 1 + 2 = 3",
  4397			.u.insns_int = {
  4398				BPF_LD_IMM64(R0, 1),
  4399				BPF_ALU64_IMM(BPF_ADD, R0, 2),
  4400				BPF_EXIT_INSN(),
  4401			},
  4402			INTERNAL,
  4403			{ },
  4404			{ { 0, 3 } },
  4405		},
  4406		{
  4407			"ALU64_ADD_K: 3 + 0 = 3",
  4408			.u.insns_int = {
  4409				BPF_LD_IMM64(R0, 3),
  4410				BPF_ALU64_IMM(BPF_ADD, R0, 0),
  4411				BPF_EXIT_INSN(),
  4412			},
  4413			INTERNAL,
  4414			{ },
  4415			{ { 0, 3 } },
  4416		},
  4417		{
  4418			"ALU64_ADD_K: 1 + 2147483646 = 2147483647",
  4419			.u.insns_int = {
  4420				BPF_LD_IMM64(R0, 1),
  4421				BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
  4422				BPF_EXIT_INSN(),
  4423			},
  4424			INTERNAL,
  4425			{ },
  4426			{ { 0, 2147483647 } },
  4427		},
  4428		{
  4429			"ALU64_ADD_K: 4294967294 + 2 = 4294967296",
  4430			.u.insns_int = {
  4431				BPF_LD_IMM64(R0, 4294967294U),
  4432				BPF_LD_IMM64(R1, 4294967296ULL),
  4433				BPF_ALU64_IMM(BPF_ADD, R0, 2),
  4434				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  4435				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  4436				BPF_EXIT_INSN(),
  4437				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  4438				BPF_EXIT_INSN(),
  4439			},
  4440			INTERNAL,
  4441			{ },
  4442			{ { 0, 1 } },
  4443		},
  4444		{
  4445			"ALU64_ADD_K: 2147483646 + -2147483647 = -1",
  4446			.u.insns_int = {
  4447				BPF_LD_IMM64(R0, 2147483646),
  4448				BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
  4449				BPF_EXIT_INSN(),
  4450			},
  4451			INTERNAL,
  4452			{ },
  4453			{ { 0, -1 } },
  4454		},
  4455		{
  4456			"ALU64_ADD_K: 1 + 0 = 1",
  4457			.u.insns_int = {
  4458				BPF_LD_IMM64(R2, 0x1),
  4459				BPF_LD_IMM64(R3, 0x1),
  4460				BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
  4461				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4462				BPF_MOV32_IMM(R0, 2),
  4463				BPF_EXIT_INSN(),
  4464				BPF_MOV32_IMM(R0, 1),
  4465				BPF_EXIT_INSN(),
  4466			},
  4467			INTERNAL,
  4468			{ },
  4469			{ { 0, 0x1 } },
  4470		},
  4471		{
  4472			"ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
  4473			.u.insns_int = {
  4474				BPF_LD_IMM64(R2, 0x0),
  4475				BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
  4476				BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
  4477				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4478				BPF_MOV32_IMM(R0, 2),
  4479				BPF_EXIT_INSN(),
  4480				BPF_MOV32_IMM(R0, 1),
  4481				BPF_EXIT_INSN(),
  4482			},
  4483			INTERNAL,
  4484			{ },
  4485			{ { 0, 0x1 } },
  4486		},
  4487		{
  4488			"ALU64_ADD_K: 0 + 0xffff = 0xffff",
  4489			.u.insns_int = {
  4490				BPF_LD_IMM64(R2, 0x0),
  4491				BPF_LD_IMM64(R3, 0xffff),
  4492				BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
  4493				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4494				BPF_MOV32_IMM(R0, 2),
  4495				BPF_EXIT_INSN(),
  4496				BPF_MOV32_IMM(R0, 1),
  4497				BPF_EXIT_INSN(),
  4498			},
  4499			INTERNAL,
  4500			{ },
  4501			{ { 0, 0x1 } },
  4502		},
  4503		{
  4504			"ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
  4505			.u.insns_int = {
  4506				BPF_LD_IMM64(R2, 0x0),
  4507				BPF_LD_IMM64(R3, 0x7fffffff),
  4508				BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
  4509				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4510				BPF_MOV32_IMM(R0, 2),
  4511				BPF_EXIT_INSN(),
  4512				BPF_MOV32_IMM(R0, 1),
  4513				BPF_EXIT_INSN(),
  4514			},
  4515			INTERNAL,
  4516			{ },
  4517			{ { 0, 0x1 } },
  4518		},
  4519		{
  4520			"ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
  4521			.u.insns_int = {
  4522				BPF_LD_IMM64(R2, 0x0),
  4523				BPF_LD_IMM64(R3, 0xffffffff80000000LL),
  4524				BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
  4525				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4526				BPF_MOV32_IMM(R0, 2),
  4527				BPF_EXIT_INSN(),
  4528				BPF_MOV32_IMM(R0, 1),
  4529				BPF_EXIT_INSN(),
  4530			},
  4531			INTERNAL,
  4532			{ },
  4533			{ { 0, 0x1 } },
  4534		},
  4535		{
  4536			"ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
  4537			.u.insns_int = {
  4538				BPF_LD_IMM64(R2, 0x0),
  4539				BPF_LD_IMM64(R3, 0xffffffff80008000LL),
  4540				BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
  4541				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4542				BPF_MOV32_IMM(R0, 2),
  4543				BPF_EXIT_INSN(),
  4544				BPF_MOV32_IMM(R0, 1),
  4545				BPF_EXIT_INSN(),
  4546			},
  4547			INTERNAL,
  4548			{ },
  4549			{ { 0, 0x1 } },
  4550		},
  4551		/* BPF_ALU | BPF_SUB | BPF_X */
  4552		{
  4553			"ALU_SUB_X: 3 - 1 = 2",
  4554			.u.insns_int = {
  4555				BPF_LD_IMM64(R0, 3),
  4556				BPF_ALU32_IMM(BPF_MOV, R1, 1),
  4557				BPF_ALU32_REG(BPF_SUB, R0, R1),
  4558				BPF_EXIT_INSN(),
  4559			},
  4560			INTERNAL,
  4561			{ },
  4562			{ { 0, 2 } },
  4563		},
  4564		{
  4565			"ALU_SUB_X: 4294967295 - 4294967294 = 1",
  4566			.u.insns_int = {
  4567				BPF_LD_IMM64(R0, 4294967295U),
  4568				BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
  4569				BPF_ALU32_REG(BPF_SUB, R0, R1),
  4570				BPF_EXIT_INSN(),
  4571			},
  4572			INTERNAL,
  4573			{ },
  4574			{ { 0, 1 } },
  4575		},
  4576		{
  4577			"ALU64_SUB_X: 3 - 1 = 2",
  4578			.u.insns_int = {
  4579				BPF_LD_IMM64(R0, 3),
  4580				BPF_ALU32_IMM(BPF_MOV, R1, 1),
  4581				BPF_ALU64_REG(BPF_SUB, R0, R1),
  4582				BPF_EXIT_INSN(),
  4583			},
  4584			INTERNAL,
  4585			{ },
  4586			{ { 0, 2 } },
  4587		},
  4588		{
  4589			"ALU64_SUB_X: 4294967295 - 4294967294 = 1",
  4590			.u.insns_int = {
  4591				BPF_LD_IMM64(R0, 4294967295U),
  4592				BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
  4593				BPF_ALU64_REG(BPF_SUB, R0, R1),
  4594				BPF_EXIT_INSN(),
  4595			},
  4596			INTERNAL,
  4597			{ },
  4598			{ { 0, 1 } },
  4599		},
  4600		/* BPF_ALU | BPF_SUB | BPF_K */
  4601		{
  4602			"ALU_SUB_K: 3 - 1 = 2",
  4603			.u.insns_int = {
  4604				BPF_LD_IMM64(R0, 3),
  4605				BPF_ALU32_IMM(BPF_SUB, R0, 1),
  4606				BPF_EXIT_INSN(),
  4607			},
  4608			INTERNAL,
  4609			{ },
  4610			{ { 0, 2 } },
  4611		},
  4612		{
  4613			"ALU_SUB_K: 3 - 0 = 3",
  4614			.u.insns_int = {
  4615				BPF_LD_IMM64(R0, 3),
  4616				BPF_ALU32_IMM(BPF_SUB, R0, 0),
  4617				BPF_EXIT_INSN(),
  4618			},
  4619			INTERNAL,
  4620			{ },
  4621			{ { 0, 3 } },
  4622		},
  4623		{
  4624			"ALU_SUB_K: 4294967295 - 4294967294 = 1",
  4625			.u.insns_int = {
  4626				BPF_LD_IMM64(R0, 4294967295U),
  4627				BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
  4628				BPF_EXIT_INSN(),
  4629			},
  4630			INTERNAL,
  4631			{ },
  4632			{ { 0, 1 } },
  4633		},
  4634		{
  4635			"ALU64_SUB_K: 3 - 1 = 2",
  4636			.u.insns_int = {
  4637				BPF_LD_IMM64(R0, 3),
  4638				BPF_ALU64_IMM(BPF_SUB, R0, 1),
  4639				BPF_EXIT_INSN(),
  4640			},
  4641			INTERNAL,
  4642			{ },
  4643			{ { 0, 2 } },
  4644		},
  4645		{
  4646			"ALU64_SUB_K: 3 - 0 = 3",
  4647			.u.insns_int = {
  4648				BPF_LD_IMM64(R0, 3),
  4649				BPF_ALU64_IMM(BPF_SUB, R0, 0),
  4650				BPF_EXIT_INSN(),
  4651			},
  4652			INTERNAL,
  4653			{ },
  4654			{ { 0, 3 } },
  4655		},
  4656		{
  4657			"ALU64_SUB_K: 4294967294 - 4294967295 = -1",
  4658			.u.insns_int = {
  4659				BPF_LD_IMM64(R0, 4294967294U),
  4660				BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
  4661				BPF_EXIT_INSN(),
  4662			},
  4663			INTERNAL,
  4664			{ },
  4665			{ { 0, -1 } },
  4666		},
  4667		{
  4668			"ALU64_ADD_K: 2147483646 - 2147483647 = -1",
  4669			.u.insns_int = {
  4670				BPF_LD_IMM64(R0, 2147483646),
  4671				BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
  4672				BPF_EXIT_INSN(),
  4673			},
  4674			INTERNAL,
  4675			{ },
  4676			{ { 0, -1 } },
  4677		},
  4678		/* BPF_ALU | BPF_MUL | BPF_X */
  4679		{
  4680			"ALU_MUL_X: 2 * 3 = 6",
  4681			.u.insns_int = {
  4682				BPF_LD_IMM64(R0, 2),
  4683				BPF_ALU32_IMM(BPF_MOV, R1, 3),
  4684				BPF_ALU32_REG(BPF_MUL, R0, R1),
  4685				BPF_EXIT_INSN(),
  4686			},
  4687			INTERNAL,
  4688			{ },
  4689			{ { 0, 6 } },
  4690		},
  4691		{
  4692			"ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
  4693			.u.insns_int = {
  4694				BPF_LD_IMM64(R0, 2),
  4695				BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
  4696				BPF_ALU32_REG(BPF_MUL, R0, R1),
  4697				BPF_EXIT_INSN(),
  4698			},
  4699			INTERNAL,
  4700			{ },
  4701			{ { 0, 0xFFFFFFF0 } },
  4702		},
  4703		{
  4704			"ALU_MUL_X: -1 * -1 = 1",
  4705			.u.insns_int = {
  4706				BPF_LD_IMM64(R0, -1),
  4707				BPF_ALU32_IMM(BPF_MOV, R1, -1),
  4708				BPF_ALU32_REG(BPF_MUL, R0, R1),
  4709				BPF_EXIT_INSN(),
  4710			},
  4711			INTERNAL,
  4712			{ },
  4713			{ { 0, 1 } },
  4714		},
  4715		{
  4716			"ALU64_MUL_X: 2 * 3 = 6",
  4717			.u.insns_int = {
  4718				BPF_LD_IMM64(R0, 2),
  4719				BPF_ALU32_IMM(BPF_MOV, R1, 3),
  4720				BPF_ALU64_REG(BPF_MUL, R0, R1),
  4721				BPF_EXIT_INSN(),
  4722			},
  4723			INTERNAL,
  4724			{ },
  4725			{ { 0, 6 } },
  4726		},
  4727		{
  4728			"ALU64_MUL_X: 1 * 2147483647 = 2147483647",
  4729			.u.insns_int = {
  4730				BPF_LD_IMM64(R0, 1),
  4731				BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
  4732				BPF_ALU64_REG(BPF_MUL, R0, R1),
  4733				BPF_EXIT_INSN(),
  4734			},
  4735			INTERNAL,
  4736			{ },
  4737			{ { 0, 2147483647 } },
  4738		},
  4739		{
  4740			"ALU64_MUL_X: 64x64 multiply, low word",
  4741			.u.insns_int = {
  4742				BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
  4743				BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
  4744				BPF_ALU64_REG(BPF_MUL, R0, R1),
  4745				BPF_EXIT_INSN(),
  4746			},
  4747			INTERNAL,
  4748			{ },
  4749			{ { 0, 0xe5618cf0 } }
  4750		},
  4751		{
  4752			"ALU64_MUL_X: 64x64 multiply, high word",
  4753			.u.insns_int = {
  4754				BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
  4755				BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
  4756				BPF_ALU64_REG(BPF_MUL, R0, R1),
  4757				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  4758				BPF_EXIT_INSN(),
  4759			},
  4760			INTERNAL,
  4761			{ },
  4762			{ { 0, 0x2236d88f } }
  4763		},
  4764		/* BPF_ALU | BPF_MUL | BPF_K */
  4765		{
  4766			"ALU_MUL_K: 2 * 3 = 6",
  4767			.u.insns_int = {
  4768				BPF_LD_IMM64(R0, 2),
  4769				BPF_ALU32_IMM(BPF_MUL, R0, 3),
  4770				BPF_EXIT_INSN(),
  4771			},
  4772			INTERNAL,
  4773			{ },
  4774			{ { 0, 6 } },
  4775		},
  4776		{
  4777			"ALU_MUL_K: 3 * 1 = 3",
  4778			.u.insns_int = {
  4779				BPF_LD_IMM64(R0, 3),
  4780				BPF_ALU32_IMM(BPF_MUL, R0, 1),
  4781				BPF_EXIT_INSN(),
  4782			},
  4783			INTERNAL,
  4784			{ },
  4785			{ { 0, 3 } },
  4786		},
  4787		{
  4788			"ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
  4789			.u.insns_int = {
  4790				BPF_LD_IMM64(R0, 2),
  4791				BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
  4792				BPF_EXIT_INSN(),
  4793			},
  4794			INTERNAL,
  4795			{ },
  4796			{ { 0, 0xFFFFFFF0 } },
  4797		},
  4798		{
  4799			"ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
  4800			.u.insns_int = {
  4801				BPF_LD_IMM64(R2, 0x1),
  4802				BPF_LD_IMM64(R3, 0x00000000ffffffff),
  4803				BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
  4804				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4805				BPF_MOV32_IMM(R0, 2),
  4806				BPF_EXIT_INSN(),
  4807				BPF_MOV32_IMM(R0, 1),
  4808				BPF_EXIT_INSN(),
  4809			},
  4810			INTERNAL,
  4811			{ },
  4812			{ { 0, 0x1 } },
  4813		},
  4814		{
  4815			"ALU64_MUL_K: 2 * 3 = 6",
  4816			.u.insns_int = {
  4817				BPF_LD_IMM64(R0, 2),
  4818				BPF_ALU64_IMM(BPF_MUL, R0, 3),
  4819				BPF_EXIT_INSN(),
  4820			},
  4821			INTERNAL,
  4822			{ },
  4823			{ { 0, 6 } },
  4824		},
  4825		{
  4826			"ALU64_MUL_K: 3 * 1 = 3",
  4827			.u.insns_int = {
  4828				BPF_LD_IMM64(R0, 3),
  4829				BPF_ALU64_IMM(BPF_MUL, R0, 1),
  4830				BPF_EXIT_INSN(),
  4831			},
  4832			INTERNAL,
  4833			{ },
  4834			{ { 0, 3 } },
  4835		},
  4836		{
  4837			"ALU64_MUL_K: 1 * 2147483647 = 2147483647",
  4838			.u.insns_int = {
  4839				BPF_LD_IMM64(R0, 1),
  4840				BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
  4841				BPF_EXIT_INSN(),
  4842			},
  4843			INTERNAL,
  4844			{ },
  4845			{ { 0, 2147483647 } },
  4846		},
  4847		{
  4848			"ALU64_MUL_K: 1 * -2147483647 = -2147483647",
  4849			.u.insns_int = {
  4850				BPF_LD_IMM64(R0, 1),
  4851				BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
  4852				BPF_EXIT_INSN(),
  4853			},
  4854			INTERNAL,
  4855			{ },
  4856			{ { 0, -2147483647 } },
  4857		},
  4858		{
  4859			"ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
  4860			.u.insns_int = {
  4861				BPF_LD_IMM64(R2, 0x1),
  4862				BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
  4863				BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
  4864				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4865				BPF_MOV32_IMM(R0, 2),
  4866				BPF_EXIT_INSN(),
  4867				BPF_MOV32_IMM(R0, 1),
  4868				BPF_EXIT_INSN(),
  4869			},
  4870			INTERNAL,
  4871			{ },
  4872			{ { 0, 0x1 } },
  4873		},
  4874		{
  4875			"ALU64_MUL_K: 64x32 multiply, low word",
  4876			.u.insns_int = {
  4877				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  4878				BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
  4879				BPF_EXIT_INSN(),
  4880			},
  4881			INTERNAL,
  4882			{ },
  4883			{ { 0, 0xe242d208 } }
  4884		},
  4885		{
  4886			"ALU64_MUL_K: 64x32 multiply, high word",
  4887			.u.insns_int = {
  4888				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  4889				BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
  4890				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  4891				BPF_EXIT_INSN(),
  4892			},
  4893			INTERNAL,
  4894			{ },
  4895			{ { 0, 0xc28f5c28 } }
  4896		},
  4897		/* BPF_ALU | BPF_DIV | BPF_X */
  4898		{
  4899			"ALU_DIV_X: 6 / 2 = 3",
  4900			.u.insns_int = {
  4901				BPF_LD_IMM64(R0, 6),
  4902				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  4903				BPF_ALU32_REG(BPF_DIV, R0, R1),
  4904				BPF_EXIT_INSN(),
  4905			},
  4906			INTERNAL,
  4907			{ },
  4908			{ { 0, 3 } },
  4909		},
  4910		{
  4911			"ALU_DIV_X: 4294967295 / 4294967295 = 1",
  4912			.u.insns_int = {
  4913				BPF_LD_IMM64(R0, 4294967295U),
  4914				BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
  4915				BPF_ALU32_REG(BPF_DIV, R0, R1),
  4916				BPF_EXIT_INSN(),
  4917			},
  4918			INTERNAL,
  4919			{ },
  4920			{ { 0, 1 } },
  4921		},
  4922		{
  4923			"ALU64_DIV_X: 6 / 2 = 3",
  4924			.u.insns_int = {
  4925				BPF_LD_IMM64(R0, 6),
  4926				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  4927				BPF_ALU64_REG(BPF_DIV, R0, R1),
  4928				BPF_EXIT_INSN(),
  4929			},
  4930			INTERNAL,
  4931			{ },
  4932			{ { 0, 3 } },
  4933		},
  4934		{
  4935			"ALU64_DIV_X: 2147483647 / 2147483647 = 1",
  4936			.u.insns_int = {
  4937				BPF_LD_IMM64(R0, 2147483647),
  4938				BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
  4939				BPF_ALU64_REG(BPF_DIV, R0, R1),
  4940				BPF_EXIT_INSN(),
  4941			},
  4942			INTERNAL,
  4943			{ },
  4944			{ { 0, 1 } },
  4945		},
  4946		{
  4947			"ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
  4948			.u.insns_int = {
  4949				BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
  4950				BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
  4951				BPF_LD_IMM64(R3, 0x0000000000000001LL),
  4952				BPF_ALU64_REG(BPF_DIV, R2, R4),
  4953				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  4954				BPF_MOV32_IMM(R0, 2),
  4955				BPF_EXIT_INSN(),
  4956				BPF_MOV32_IMM(R0, 1),
  4957				BPF_EXIT_INSN(),
  4958			},
  4959			INTERNAL,
  4960			{ },
  4961			{ { 0, 0x1 } },
  4962		},
  4963		/* BPF_ALU | BPF_DIV | BPF_K */
  4964		{
  4965			"ALU_DIV_K: 6 / 2 = 3",
  4966			.u.insns_int = {
  4967				BPF_LD_IMM64(R0, 6),
  4968				BPF_ALU32_IMM(BPF_DIV, R0, 2),
  4969				BPF_EXIT_INSN(),
  4970			},
  4971			INTERNAL,
  4972			{ },
  4973			{ { 0, 3 } },
  4974		},
  4975		{
  4976			"ALU_DIV_K: 3 / 1 = 3",
  4977			.u.insns_int = {
  4978				BPF_LD_IMM64(R0, 3),
  4979				BPF_ALU32_IMM(BPF_DIV, R0, 1),
  4980				BPF_EXIT_INSN(),
  4981			},
  4982			INTERNAL,
  4983			{ },
  4984			{ { 0, 3 } },
  4985		},
  4986		{
  4987			"ALU_DIV_K: 4294967295 / 4294967295 = 1",
  4988			.u.insns_int = {
  4989				BPF_LD_IMM64(R0, 4294967295U),
  4990				BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
  4991				BPF_EXIT_INSN(),
  4992			},
  4993			INTERNAL,
  4994			{ },
  4995			{ { 0, 1 } },
  4996		},
  4997		{
  4998			"ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
  4999			.u.insns_int = {
  5000				BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
  5001				BPF_LD_IMM64(R3, 0x1UL),
  5002				BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
  5003				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5004				BPF_MOV32_IMM(R0, 2),
  5005				BPF_EXIT_INSN(),
  5006				BPF_MOV32_IMM(R0, 1),
  5007				BPF_EXIT_INSN(),
  5008			},
  5009			INTERNAL,
  5010			{ },
  5011			{ { 0, 0x1 } },
  5012		},
  5013		{
  5014			"ALU64_DIV_K: 6 / 2 = 3",
  5015			.u.insns_int = {
  5016				BPF_LD_IMM64(R0, 6),
  5017				BPF_ALU64_IMM(BPF_DIV, R0, 2),
  5018				BPF_EXIT_INSN(),
  5019			},
  5020			INTERNAL,
  5021			{ },
  5022			{ { 0, 3 } },
  5023		},
  5024		{
  5025			"ALU64_DIV_K: 3 / 1 = 3",
  5026			.u.insns_int = {
  5027				BPF_LD_IMM64(R0, 3),
  5028				BPF_ALU64_IMM(BPF_DIV, R0, 1),
  5029				BPF_EXIT_INSN(),
  5030			},
  5031			INTERNAL,
  5032			{ },
  5033			{ { 0, 3 } },
  5034		},
  5035		{
  5036			"ALU64_DIV_K: 2147483647 / 2147483647 = 1",
  5037			.u.insns_int = {
  5038				BPF_LD_IMM64(R0, 2147483647),
  5039				BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
  5040				BPF_EXIT_INSN(),
  5041			},
  5042			INTERNAL,
  5043			{ },
  5044			{ { 0, 1 } },
  5045		},
  5046		{
  5047			"ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
  5048			.u.insns_int = {
  5049				BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
  5050				BPF_LD_IMM64(R3, 0x0000000000000001LL),
  5051				BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
  5052				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5053				BPF_MOV32_IMM(R0, 2),
  5054				BPF_EXIT_INSN(),
  5055				BPF_MOV32_IMM(R0, 1),
  5056				BPF_EXIT_INSN(),
  5057			},
  5058			INTERNAL,
  5059			{ },
  5060			{ { 0, 0x1 } },
  5061		},
  5062		/* BPF_ALU | BPF_MOD | BPF_X */
  5063		{
  5064			"ALU_MOD_X: 3 % 2 = 1",
  5065			.u.insns_int = {
  5066				BPF_LD_IMM64(R0, 3),
  5067				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  5068				BPF_ALU32_REG(BPF_MOD, R0, R1),
  5069				BPF_EXIT_INSN(),
  5070			},
  5071			INTERNAL,
  5072			{ },
  5073			{ { 0, 1 } },
  5074		},
  5075		{
  5076			"ALU_MOD_X: 4294967295 % 4294967293 = 2",
  5077			.u.insns_int = {
  5078				BPF_LD_IMM64(R0, 4294967295U),
  5079				BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
  5080				BPF_ALU32_REG(BPF_MOD, R0, R1),
  5081				BPF_EXIT_INSN(),
  5082			},
  5083			INTERNAL,
  5084			{ },
  5085			{ { 0, 2 } },
  5086		},
  5087		{
  5088			"ALU64_MOD_X: 3 % 2 = 1",
  5089			.u.insns_int = {
  5090				BPF_LD_IMM64(R0, 3),
  5091				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  5092				BPF_ALU64_REG(BPF_MOD, R0, R1),
  5093				BPF_EXIT_INSN(),
  5094			},
  5095			INTERNAL,
  5096			{ },
  5097			{ { 0, 1 } },
  5098		},
  5099		{
  5100			"ALU64_MOD_X: 2147483647 % 2147483645 = 2",
  5101			.u.insns_int = {
  5102				BPF_LD_IMM64(R0, 2147483647),
  5103				BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
  5104				BPF_ALU64_REG(BPF_MOD, R0, R1),
  5105				BPF_EXIT_INSN(),
  5106			},
  5107			INTERNAL,
  5108			{ },
  5109			{ { 0, 2 } },
  5110		},
  5111		/* BPF_ALU | BPF_MOD | BPF_K */
  5112		{
  5113			"ALU_MOD_K: 3 % 2 = 1",
  5114			.u.insns_int = {
  5115				BPF_LD_IMM64(R0, 3),
  5116				BPF_ALU32_IMM(BPF_MOD, R0, 2),
  5117				BPF_EXIT_INSN(),
  5118			},
  5119			INTERNAL,
  5120			{ },
  5121			{ { 0, 1 } },
  5122		},
  5123		{
  5124			"ALU_MOD_K: 3 % 1 = 0",
  5125			.u.insns_int = {
  5126				BPF_LD_IMM64(R0, 3),
  5127				BPF_ALU32_IMM(BPF_MOD, R0, 1),
  5128				BPF_EXIT_INSN(),
  5129			},
  5130			INTERNAL,
  5131			{ },
  5132			{ { 0, 0 } },
  5133		},
  5134		{
  5135			"ALU_MOD_K: 4294967295 % 4294967293 = 2",
  5136			.u.insns_int = {
  5137				BPF_LD_IMM64(R0, 4294967295U),
  5138				BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
  5139				BPF_EXIT_INSN(),
  5140			},
  5141			INTERNAL,
  5142			{ },
  5143			{ { 0, 2 } },
  5144		},
  5145		{
  5146			"ALU64_MOD_K: 3 % 2 = 1",
  5147			.u.insns_int = {
  5148				BPF_LD_IMM64(R0, 3),
  5149				BPF_ALU64_IMM(BPF_MOD, R0, 2),
  5150				BPF_EXIT_INSN(),
  5151			},
  5152			INTERNAL,
  5153			{ },
  5154			{ { 0, 1 } },
  5155		},
  5156		{
  5157			"ALU64_MOD_K: 3 % 1 = 0",
  5158			.u.insns_int = {
  5159				BPF_LD_IMM64(R0, 3),
  5160				BPF_ALU64_IMM(BPF_MOD, R0, 1),
  5161				BPF_EXIT_INSN(),
  5162			},
  5163			INTERNAL,
  5164			{ },
  5165			{ { 0, 0 } },
  5166		},
  5167		{
  5168			"ALU64_MOD_K: 2147483647 % 2147483645 = 2",
  5169			.u.insns_int = {
  5170				BPF_LD_IMM64(R0, 2147483647),
  5171				BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
  5172				BPF_EXIT_INSN(),
  5173			},
  5174			INTERNAL,
  5175			{ },
  5176			{ { 0, 2 } },
  5177		},
  5178		/* BPF_ALU | BPF_AND | BPF_X */
  5179		{
  5180			"ALU_AND_X: 3 & 2 = 2",
  5181			.u.insns_int = {
  5182				BPF_LD_IMM64(R0, 3),
  5183				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  5184				BPF_ALU32_REG(BPF_AND, R0, R1),
  5185				BPF_EXIT_INSN(),
  5186			},
  5187			INTERNAL,
  5188			{ },
  5189			{ { 0, 2 } },
  5190		},
  5191		{
  5192			"ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
  5193			.u.insns_int = {
  5194				BPF_LD_IMM64(R0, 0xffffffff),
  5195				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  5196				BPF_ALU32_REG(BPF_AND, R0, R1),
  5197				BPF_EXIT_INSN(),
  5198			},
  5199			INTERNAL,
  5200			{ },
  5201			{ { 0, 0xffffffff } },
  5202		},
  5203		{
  5204			"ALU64_AND_X: 3 & 2 = 2",
  5205			.u.insns_int = {
  5206				BPF_LD_IMM64(R0, 3),
  5207				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  5208				BPF_ALU64_REG(BPF_AND, R0, R1),
  5209				BPF_EXIT_INSN(),
  5210			},
  5211			INTERNAL,
  5212			{ },
  5213			{ { 0, 2 } },
  5214		},
  5215		{
  5216			"ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
  5217			.u.insns_int = {
  5218				BPF_LD_IMM64(R0, 0xffffffff),
  5219				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  5220				BPF_ALU64_REG(BPF_AND, R0, R1),
  5221				BPF_EXIT_INSN(),
  5222			},
  5223			INTERNAL,
  5224			{ },
  5225			{ { 0, 0xffffffff } },
  5226		},
  5227		/* BPF_ALU | BPF_AND | BPF_K */
  5228		{
  5229			"ALU_AND_K: 3 & 2 = 2",
  5230			.u.insns_int = {
  5231				BPF_LD_IMM64(R0, 3),
  5232				BPF_ALU32_IMM(BPF_AND, R0, 2),
  5233				BPF_EXIT_INSN(),
  5234			},
  5235			INTERNAL,
  5236			{ },
  5237			{ { 0, 2 } },
  5238		},
  5239		{
  5240			"ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
  5241			.u.insns_int = {
  5242				BPF_LD_IMM64(R0, 0xffffffff),
  5243				BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
  5244				BPF_EXIT_INSN(),
  5245			},
  5246			INTERNAL,
  5247			{ },
  5248			{ { 0, 0xffffffff } },
  5249		},
  5250		{
  5251			"ALU_AND_K: Small immediate",
  5252			.u.insns_int = {
  5253				BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
  5254				BPF_ALU32_IMM(BPF_AND, R0, 15),
  5255				BPF_EXIT_INSN(),
  5256			},
  5257			INTERNAL,
  5258			{ },
  5259			{ { 0, 4 } }
  5260		},
  5261		{
  5262			"ALU_AND_K: Large immediate",
  5263			.u.insns_int = {
  5264				BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
  5265				BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
  5266				BPF_EXIT_INSN(),
  5267			},
  5268			INTERNAL,
  5269			{ },
  5270			{ { 0, 0xa1b2c3d4 } }
  5271		},
  5272		{
  5273			"ALU_AND_K: Zero extension",
  5274			.u.insns_int = {
  5275				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5276				BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
  5277				BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
  5278				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5279				BPF_MOV32_IMM(R0, 2),
  5280				BPF_EXIT_INSN(),
  5281				BPF_MOV32_IMM(R0, 1),
  5282				BPF_EXIT_INSN(),
  5283			},
  5284			INTERNAL,
  5285			{ },
  5286			{ { 0, 1 } }
  5287		},
  5288		{
  5289			"ALU64_AND_K: 3 & 2 = 2",
  5290			.u.insns_int = {
  5291				BPF_LD_IMM64(R0, 3),
  5292				BPF_ALU64_IMM(BPF_AND, R0, 2),
  5293				BPF_EXIT_INSN(),
  5294			},
  5295			INTERNAL,
  5296			{ },
  5297			{ { 0, 2 } },
  5298		},
  5299		{
  5300			"ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
  5301			.u.insns_int = {
  5302				BPF_LD_IMM64(R0, 0xffffffff),
  5303				BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
  5304				BPF_EXIT_INSN(),
  5305			},
  5306			INTERNAL,
  5307			{ },
  5308			{ { 0, 0xffffffff } },
  5309		},
  5310		{
  5311			"ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
  5312			.u.insns_int = {
  5313				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  5314				BPF_LD_IMM64(R3, 0x0000000000000000LL),
  5315				BPF_ALU64_IMM(BPF_AND, R2, 0x0),
  5316				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5317				BPF_MOV32_IMM(R0, 2),
  5318				BPF_EXIT_INSN(),
  5319				BPF_MOV32_IMM(R0, 1),
  5320				BPF_EXIT_INSN(),
  5321			},
  5322			INTERNAL,
  5323			{ },
  5324			{ { 0, 0x1 } },
  5325		},
  5326		{
  5327			"ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
  5328			.u.insns_int = {
  5329				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  5330				BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
  5331				BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
  5332				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5333				BPF_MOV32_IMM(R0, 2),
  5334				BPF_EXIT_INSN(),
  5335				BPF_MOV32_IMM(R0, 1),
  5336				BPF_EXIT_INSN(),
  5337			},
  5338			INTERNAL,
  5339			{ },
  5340			{ { 0, 0x1 } },
  5341		},
  5342		{
  5343			"ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
  5344			.u.insns_int = {
  5345				BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
  5346				BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
  5347				BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
  5348				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5349				BPF_MOV32_IMM(R0, 2),
  5350				BPF_EXIT_INSN(),
  5351				BPF_MOV32_IMM(R0, 1),
  5352				BPF_EXIT_INSN(),
  5353			},
  5354			INTERNAL,
  5355			{ },
  5356			{ { 0, 0x1 } },
  5357		},
  5358		{
  5359			"ALU64_AND_K: Sign extension 1",
  5360			.u.insns_int = {
  5361				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5362				BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
  5363				BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
  5364				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5365				BPF_MOV32_IMM(R0, 2),
  5366				BPF_EXIT_INSN(),
  5367				BPF_MOV32_IMM(R0, 1),
  5368				BPF_EXIT_INSN(),
  5369			},
  5370			INTERNAL,
  5371			{ },
  5372			{ { 0, 1 } }
  5373		},
  5374		{
  5375			"ALU64_AND_K: Sign extension 2",
  5376			.u.insns_int = {
  5377				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5378				BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
  5379				BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
  5380				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5381				BPF_MOV32_IMM(R0, 2),
  5382				BPF_EXIT_INSN(),
  5383				BPF_MOV32_IMM(R0, 1),
  5384				BPF_EXIT_INSN(),
  5385			},
  5386			INTERNAL,
  5387			{ },
  5388			{ { 0, 1 } }
  5389		},
  5390		/* BPF_ALU | BPF_OR | BPF_X */
  5391		{
  5392			"ALU_OR_X: 1 | 2 = 3",
  5393			.u.insns_int = {
  5394				BPF_LD_IMM64(R0, 1),
  5395				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  5396				BPF_ALU32_REG(BPF_OR, R0, R1),
  5397				BPF_EXIT_INSN(),
  5398			},
  5399			INTERNAL,
  5400			{ },
  5401			{ { 0, 3 } },
  5402		},
  5403		{
  5404			"ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
  5405			.u.insns_int = {
  5406				BPF_LD_IMM64(R0, 0),
  5407				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  5408				BPF_ALU32_REG(BPF_OR, R0, R1),
  5409				BPF_EXIT_INSN(),
  5410			},
  5411			INTERNAL,
  5412			{ },
  5413			{ { 0, 0xffffffff } },
  5414		},
  5415		{
  5416			"ALU64_OR_X: 1 | 2 = 3",
  5417			.u.insns_int = {
  5418				BPF_LD_IMM64(R0, 1),
  5419				BPF_ALU32_IMM(BPF_MOV, R1, 2),
  5420				BPF_ALU64_REG(BPF_OR, R0, R1),
  5421				BPF_EXIT_INSN(),
  5422			},
  5423			INTERNAL,
  5424			{ },
  5425			{ { 0, 3 } },
  5426		},
  5427		{
  5428			"ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
  5429			.u.insns_int = {
  5430				BPF_LD_IMM64(R0, 0),
  5431				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  5432				BPF_ALU64_REG(BPF_OR, R0, R1),
  5433				BPF_EXIT_INSN(),
  5434			},
  5435			INTERNAL,
  5436			{ },
  5437			{ { 0, 0xffffffff } },
  5438		},
  5439		/* BPF_ALU | BPF_OR | BPF_K */
  5440		{
  5441			"ALU_OR_K: 1 | 2 = 3",
  5442			.u.insns_int = {
  5443				BPF_LD_IMM64(R0, 1),
  5444				BPF_ALU32_IMM(BPF_OR, R0, 2),
  5445				BPF_EXIT_INSN(),
  5446			},
  5447			INTERNAL,
  5448			{ },
  5449			{ { 0, 3 } },
  5450		},
  5451		{
  5452			"ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
  5453			.u.insns_int = {
  5454				BPF_LD_IMM64(R0, 0),
  5455				BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
  5456				BPF_EXIT_INSN(),
  5457			},
  5458			INTERNAL,
  5459			{ },
  5460			{ { 0, 0xffffffff } },
  5461		},
  5462		{
  5463			"ALU_OR_K: Small immediate",
  5464			.u.insns_int = {
  5465				BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
  5466				BPF_ALU32_IMM(BPF_OR, R0, 1),
  5467				BPF_EXIT_INSN(),
  5468			},
  5469			INTERNAL,
  5470			{ },
  5471			{ { 0, 0x01020305 } }
  5472		},
  5473		{
  5474			"ALU_OR_K: Large immediate",
  5475			.u.insns_int = {
  5476				BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
  5477				BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
  5478				BPF_EXIT_INSN(),
  5479			},
  5480			INTERNAL,
  5481			{ },
  5482			{ { 0, 0xa1b2c3d4 } }
  5483		},
  5484		{
  5485			"ALU_OR_K: Zero extension",
  5486			.u.insns_int = {
  5487				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5488				BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
  5489				BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
  5490				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5491				BPF_MOV32_IMM(R0, 2),
  5492				BPF_EXIT_INSN(),
  5493				BPF_MOV32_IMM(R0, 1),
  5494				BPF_EXIT_INSN(),
  5495			},
  5496			INTERNAL,
  5497			{ },
  5498			{ { 0, 1 } }
  5499		},
  5500		{
  5501			"ALU64_OR_K: 1 | 2 = 3",
  5502			.u.insns_int = {
  5503				BPF_LD_IMM64(R0, 1),
  5504				BPF_ALU64_IMM(BPF_OR, R0, 2),
  5505				BPF_EXIT_INSN(),
  5506			},
  5507			INTERNAL,
  5508			{ },
  5509			{ { 0, 3 } },
  5510		},
  5511		{
  5512			"ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
  5513			.u.insns_int = {
  5514				BPF_LD_IMM64(R0, 0),
  5515				BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
  5516				BPF_EXIT_INSN(),
  5517			},
  5518			INTERNAL,
  5519			{ },
  5520			{ { 0, 0xffffffff } },
  5521		},
  5522		{
  5523			"ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
  5524			.u.insns_int = {
  5525				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  5526				BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
  5527				BPF_ALU64_IMM(BPF_OR, R2, 0x0),
  5528				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5529				BPF_MOV32_IMM(R0, 2),
  5530				BPF_EXIT_INSN(),
  5531				BPF_MOV32_IMM(R0, 1),
  5532				BPF_EXIT_INSN(),
  5533			},
  5534			INTERNAL,
  5535			{ },
  5536			{ { 0, 0x1 } },
  5537		},
  5538		{
  5539			"ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
  5540			.u.insns_int = {
  5541				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  5542				BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
  5543				BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
  5544				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5545				BPF_MOV32_IMM(R0, 2),
  5546				BPF_EXIT_INSN(),
  5547				BPF_MOV32_IMM(R0, 1),
  5548				BPF_EXIT_INSN(),
  5549			},
  5550			INTERNAL,
  5551			{ },
  5552			{ { 0, 0x1 } },
  5553		},
  5554		{
  5555			"ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
  5556			.u.insns_int = {
  5557				BPF_LD_IMM64(R2, 0x0000000000000000LL),
  5558				BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
  5559				BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
  5560				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5561				BPF_MOV32_IMM(R0, 2),
  5562				BPF_EXIT_INSN(),
  5563				BPF_MOV32_IMM(R0, 1),
  5564				BPF_EXIT_INSN(),
  5565			},
  5566			INTERNAL,
  5567			{ },
  5568			{ { 0, 0x1 } },
  5569		},
  5570		{
  5571			"ALU64_OR_K: Sign extension 1",
  5572			.u.insns_int = {
  5573				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5574				BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
  5575				BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
  5576				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5577				BPF_MOV32_IMM(R0, 2),
  5578				BPF_EXIT_INSN(),
  5579				BPF_MOV32_IMM(R0, 1),
  5580				BPF_EXIT_INSN(),
  5581			},
  5582			INTERNAL,
  5583			{ },
  5584			{ { 0, 1 } }
  5585		},
  5586		{
  5587			"ALU64_OR_K: Sign extension 2",
  5588			.u.insns_int = {
  5589				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5590				BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
  5591				BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
  5592				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5593				BPF_MOV32_IMM(R0, 2),
  5594				BPF_EXIT_INSN(),
  5595				BPF_MOV32_IMM(R0, 1),
  5596				BPF_EXIT_INSN(),
  5597			},
  5598			INTERNAL,
  5599			{ },
  5600			{ { 0, 1 } }
  5601		},
  5602		/* BPF_ALU | BPF_XOR | BPF_X */
  5603		{
  5604			"ALU_XOR_X: 5 ^ 6 = 3",
  5605			.u.insns_int = {
  5606				BPF_LD_IMM64(R0, 5),
  5607				BPF_ALU32_IMM(BPF_MOV, R1, 6),
  5608				BPF_ALU32_REG(BPF_XOR, R0, R1),
  5609				BPF_EXIT_INSN(),
  5610			},
  5611			INTERNAL,
  5612			{ },
  5613			{ { 0, 3 } },
  5614		},
  5615		{
  5616			"ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
  5617			.u.insns_int = {
  5618				BPF_LD_IMM64(R0, 1),
  5619				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  5620				BPF_ALU32_REG(BPF_XOR, R0, R1),
  5621				BPF_EXIT_INSN(),
  5622			},
  5623			INTERNAL,
  5624			{ },
  5625			{ { 0, 0xfffffffe } },
  5626		},
  5627		{
  5628			"ALU64_XOR_X: 5 ^ 6 = 3",
  5629			.u.insns_int = {
  5630				BPF_LD_IMM64(R0, 5),
  5631				BPF_ALU32_IMM(BPF_MOV, R1, 6),
  5632				BPF_ALU64_REG(BPF_XOR, R0, R1),
  5633				BPF_EXIT_INSN(),
  5634			},
  5635			INTERNAL,
  5636			{ },
  5637			{ { 0, 3 } },
  5638		},
  5639		{
  5640			"ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
  5641			.u.insns_int = {
  5642				BPF_LD_IMM64(R0, 1),
  5643				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  5644				BPF_ALU64_REG(BPF_XOR, R0, R1),
  5645				BPF_EXIT_INSN(),
  5646			},
  5647			INTERNAL,
  5648			{ },
  5649			{ { 0, 0xfffffffe } },
  5650		},
  5651		/* BPF_ALU | BPF_XOR | BPF_K */
  5652		{
  5653			"ALU_XOR_K: 5 ^ 6 = 3",
  5654			.u.insns_int = {
  5655				BPF_LD_IMM64(R0, 5),
  5656				BPF_ALU32_IMM(BPF_XOR, R0, 6),
  5657				BPF_EXIT_INSN(),
  5658			},
  5659			INTERNAL,
  5660			{ },
  5661			{ { 0, 3 } },
  5662		},
  5663		{
  5664			"ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
  5665			.u.insns_int = {
  5666				BPF_LD_IMM64(R0, 1),
  5667				BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
  5668				BPF_EXIT_INSN(),
  5669			},
  5670			INTERNAL,
  5671			{ },
  5672			{ { 0, 0xfffffffe } },
  5673		},
  5674		{
  5675			"ALU_XOR_K: Small immediate",
  5676			.u.insns_int = {
  5677				BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
  5678				BPF_ALU32_IMM(BPF_XOR, R0, 15),
  5679				BPF_EXIT_INSN(),
  5680			},
  5681			INTERNAL,
  5682			{ },
  5683			{ { 0, 0x0102030b } }
  5684		},
  5685		{
  5686			"ALU_XOR_K: Large immediate",
  5687			.u.insns_int = {
  5688				BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
  5689				BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
  5690				BPF_EXIT_INSN(),
  5691			},
  5692			INTERNAL,
  5693			{ },
  5694			{ { 0, 0x5e4d3c2b } }
  5695		},
  5696		{
  5697			"ALU_XOR_K: Zero extension",
  5698			.u.insns_int = {
  5699				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5700				BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
  5701				BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
  5702				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5703				BPF_MOV32_IMM(R0, 2),
  5704				BPF_EXIT_INSN(),
  5705				BPF_MOV32_IMM(R0, 1),
  5706				BPF_EXIT_INSN(),
  5707			},
  5708			INTERNAL,
  5709			{ },
  5710			{ { 0, 1 } }
  5711		},
  5712		{
  5713			"ALU64_XOR_K: 5 ^ 6 = 3",
  5714			.u.insns_int = {
  5715				BPF_LD_IMM64(R0, 5),
  5716				BPF_ALU64_IMM(BPF_XOR, R0, 6),
  5717				BPF_EXIT_INSN(),
  5718			},
  5719			INTERNAL,
  5720			{ },
  5721			{ { 0, 3 } },
  5722		},
  5723		{
  5724			"ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
  5725			.u.insns_int = {
  5726				BPF_LD_IMM64(R0, 1),
  5727				BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
  5728				BPF_EXIT_INSN(),
  5729			},
  5730			INTERNAL,
  5731			{ },
  5732			{ { 0, 0xfffffffe } },
  5733		},
  5734		{
  5735			"ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
  5736			.u.insns_int = {
  5737				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  5738				BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
  5739				BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
  5740				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5741				BPF_MOV32_IMM(R0, 2),
  5742				BPF_EXIT_INSN(),
  5743				BPF_MOV32_IMM(R0, 1),
  5744				BPF_EXIT_INSN(),
  5745			},
  5746			INTERNAL,
  5747			{ },
  5748			{ { 0, 0x1 } },
  5749		},
  5750		{
  5751			"ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
  5752			.u.insns_int = {
  5753				BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
  5754				BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
  5755				BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
  5756				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5757				BPF_MOV32_IMM(R0, 2),
  5758				BPF_EXIT_INSN(),
  5759				BPF_MOV32_IMM(R0, 1),
  5760				BPF_EXIT_INSN(),
  5761			},
  5762			INTERNAL,
  5763			{ },
  5764			{ { 0, 0x1 } },
  5765		},
  5766		{
  5767			"ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
  5768			.u.insns_int = {
  5769				BPF_LD_IMM64(R2, 0x0000000000000000LL),
  5770				BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
  5771				BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
  5772				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  5773				BPF_MOV32_IMM(R0, 2),
  5774				BPF_EXIT_INSN(),
  5775				BPF_MOV32_IMM(R0, 1),
  5776				BPF_EXIT_INSN(),
  5777			},
  5778			INTERNAL,
  5779			{ },
  5780			{ { 0, 0x1 } },
  5781		},
  5782		{
  5783			"ALU64_XOR_K: Sign extension 1",
  5784			.u.insns_int = {
  5785				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5786				BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
  5787				BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
  5788				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5789				BPF_MOV32_IMM(R0, 2),
  5790				BPF_EXIT_INSN(),
  5791				BPF_MOV32_IMM(R0, 1),
  5792				BPF_EXIT_INSN(),
  5793			},
  5794			INTERNAL,
  5795			{ },
  5796			{ { 0, 1 } }
  5797		},
  5798		{
  5799			"ALU64_XOR_K: Sign extension 2",
  5800			.u.insns_int = {
  5801				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5802				BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
  5803				BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
  5804				BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
  5805				BPF_MOV32_IMM(R0, 2),
  5806				BPF_EXIT_INSN(),
  5807				BPF_MOV32_IMM(R0, 1),
  5808				BPF_EXIT_INSN(),
  5809			},
  5810			INTERNAL,
  5811			{ },
  5812			{ { 0, 1 } }
  5813		},
  5814		/* BPF_ALU | BPF_LSH | BPF_X */
  5815		{
  5816			"ALU_LSH_X: 1 << 1 = 2",
  5817			.u.insns_int = {
  5818				BPF_LD_IMM64(R0, 1),
  5819				BPF_ALU32_IMM(BPF_MOV, R1, 1),
  5820				BPF_ALU32_REG(BPF_LSH, R0, R1),
  5821				BPF_EXIT_INSN(),
  5822			},
  5823			INTERNAL,
  5824			{ },
  5825			{ { 0, 2 } },
  5826		},
  5827		{
  5828			"ALU_LSH_X: 1 << 31 = 0x80000000",
  5829			.u.insns_int = {
  5830				BPF_LD_IMM64(R0, 1),
  5831				BPF_ALU32_IMM(BPF_MOV, R1, 31),
  5832				BPF_ALU32_REG(BPF_LSH, R0, R1),
  5833				BPF_EXIT_INSN(),
  5834			},
  5835			INTERNAL,
  5836			{ },
  5837			{ { 0, 0x80000000 } },
  5838		},
  5839		{
  5840			"ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
  5841			.u.insns_int = {
  5842				BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
  5843				BPF_ALU32_IMM(BPF_MOV, R1, 12),
  5844				BPF_ALU32_REG(BPF_LSH, R0, R1),
  5845				BPF_EXIT_INSN(),
  5846			},
  5847			INTERNAL,
  5848			{ },
  5849			{ { 0, 0x45678000 } }
  5850		},
  5851		{
  5852			"ALU64_LSH_X: 1 << 1 = 2",
  5853			.u.insns_int = {
  5854				BPF_LD_IMM64(R0, 1),
  5855				BPF_ALU32_IMM(BPF_MOV, R1, 1),
  5856				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5857				BPF_EXIT_INSN(),
  5858			},
  5859			INTERNAL,
  5860			{ },
  5861			{ { 0, 2 } },
  5862		},
  5863		{
  5864			"ALU64_LSH_X: 1 << 31 = 0x80000000",
  5865			.u.insns_int = {
  5866				BPF_LD_IMM64(R0, 1),
  5867				BPF_ALU32_IMM(BPF_MOV, R1, 31),
  5868				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5869				BPF_EXIT_INSN(),
  5870			},
  5871			INTERNAL,
  5872			{ },
  5873			{ { 0, 0x80000000 } },
  5874		},
  5875		{
  5876			"ALU64_LSH_X: Shift < 32, low word",
  5877			.u.insns_int = {
  5878				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5879				BPF_ALU32_IMM(BPF_MOV, R1, 12),
  5880				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5881				BPF_EXIT_INSN(),
  5882			},
  5883			INTERNAL,
  5884			{ },
  5885			{ { 0, 0xbcdef000 } }
  5886		},
  5887		{
  5888			"ALU64_LSH_X: Shift < 32, high word",
  5889			.u.insns_int = {
  5890				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5891				BPF_ALU32_IMM(BPF_MOV, R1, 12),
  5892				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5893				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  5894				BPF_EXIT_INSN(),
  5895			},
  5896			INTERNAL,
  5897			{ },
  5898			{ { 0, 0x3456789a } }
  5899		},
  5900		{
  5901			"ALU64_LSH_X: Shift > 32, low word",
  5902			.u.insns_int = {
  5903				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5904				BPF_ALU32_IMM(BPF_MOV, R1, 36),
  5905				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5906				BPF_EXIT_INSN(),
  5907			},
  5908			INTERNAL,
  5909			{ },
  5910			{ { 0, 0 } }
  5911		},
  5912		{
  5913			"ALU64_LSH_X: Shift > 32, high word",
  5914			.u.insns_int = {
  5915				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5916				BPF_ALU32_IMM(BPF_MOV, R1, 36),
  5917				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5918				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  5919				BPF_EXIT_INSN(),
  5920			},
  5921			INTERNAL,
  5922			{ },
  5923			{ { 0, 0x9abcdef0 } }
  5924		},
  5925		{
  5926			"ALU64_LSH_X: Shift == 32, low word",
  5927			.u.insns_int = {
  5928				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5929				BPF_ALU32_IMM(BPF_MOV, R1, 32),
  5930				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5931				BPF_EXIT_INSN(),
  5932			},
  5933			INTERNAL,
  5934			{ },
  5935			{ { 0, 0 } }
  5936		},
  5937		{
  5938			"ALU64_LSH_X: Shift == 32, high word",
  5939			.u.insns_int = {
  5940				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5941				BPF_ALU32_IMM(BPF_MOV, R1, 32),
  5942				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5943				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  5944				BPF_EXIT_INSN(),
  5945			},
  5946			INTERNAL,
  5947			{ },
  5948			{ { 0, 0x89abcdef } }
  5949		},
  5950		{
  5951			"ALU64_LSH_X: Zero shift, low word",
  5952			.u.insns_int = {
  5953				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5954				BPF_ALU32_IMM(BPF_MOV, R1, 0),
  5955				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5956				BPF_EXIT_INSN(),
  5957			},
  5958			INTERNAL,
  5959			{ },
  5960			{ { 0, 0x89abcdef } }
  5961		},
  5962		{
  5963			"ALU64_LSH_X: Zero shift, high word",
  5964			.u.insns_int = {
  5965				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  5966				BPF_ALU32_IMM(BPF_MOV, R1, 0),
  5967				BPF_ALU64_REG(BPF_LSH, R0, R1),
  5968				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  5969				BPF_EXIT_INSN(),
  5970			},
  5971			INTERNAL,
  5972			{ },
  5973			{ { 0, 0x01234567 } }
  5974		},
  5975		/* BPF_ALU | BPF_LSH | BPF_K */
  5976		{
  5977			"ALU_LSH_K: 1 << 1 = 2",
  5978			.u.insns_int = {
  5979				BPF_LD_IMM64(R0, 1),
  5980				BPF_ALU32_IMM(BPF_LSH, R0, 1),
  5981				BPF_EXIT_INSN(),
  5982			},
  5983			INTERNAL,
  5984			{ },
  5985			{ { 0, 2 } },
  5986		},
  5987		{
  5988			"ALU_LSH_K: 1 << 31 = 0x80000000",
  5989			.u.insns_int = {
  5990				BPF_LD_IMM64(R0, 1),
  5991				BPF_ALU32_IMM(BPF_LSH, R0, 31),
  5992				BPF_EXIT_INSN(),
  5993			},
  5994			INTERNAL,
  5995			{ },
  5996			{ { 0, 0x80000000 } },
  5997		},
  5998		{
  5999			"ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
  6000			.u.insns_int = {
  6001				BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
  6002				BPF_ALU32_IMM(BPF_LSH, R0, 12),
  6003				BPF_EXIT_INSN(),
  6004			},
  6005			INTERNAL,
  6006			{ },
  6007			{ { 0, 0x45678000 } }
  6008		},
  6009		{
  6010			"ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
  6011			.u.insns_int = {
  6012				BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
  6013				BPF_ALU32_IMM(BPF_LSH, R0, 0),
  6014				BPF_EXIT_INSN(),
  6015			},
  6016			INTERNAL,
  6017			{ },
  6018			{ { 0, 0x12345678 } }
  6019		},
  6020		{
  6021			"ALU64_LSH_K: 1 << 1 = 2",
  6022			.u.insns_int = {
  6023				BPF_LD_IMM64(R0, 1),
  6024				BPF_ALU64_IMM(BPF_LSH, R0, 1),
  6025				BPF_EXIT_INSN(),
  6026			},
  6027			INTERNAL,
  6028			{ },
  6029			{ { 0, 2 } },
  6030		},
  6031		{
  6032			"ALU64_LSH_K: 1 << 31 = 0x80000000",
  6033			.u.insns_int = {
  6034				BPF_LD_IMM64(R0, 1),
  6035				BPF_ALU64_IMM(BPF_LSH, R0, 31),
  6036				BPF_EXIT_INSN(),
  6037			},
  6038			INTERNAL,
  6039			{ },
  6040			{ { 0, 0x80000000 } },
  6041		},
  6042		{
  6043			"ALU64_LSH_K: Shift < 32, low word",
  6044			.u.insns_int = {
  6045				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6046				BPF_ALU64_IMM(BPF_LSH, R0, 12),
  6047				BPF_EXIT_INSN(),
  6048			},
  6049			INTERNAL,
  6050			{ },
  6051			{ { 0, 0xbcdef000 } }
  6052		},
  6053		{
  6054			"ALU64_LSH_K: Shift < 32, high word",
  6055			.u.insns_int = {
  6056				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6057				BPF_ALU64_IMM(BPF_LSH, R0, 12),
  6058				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6059				BPF_EXIT_INSN(),
  6060			},
  6061			INTERNAL,
  6062			{ },
  6063			{ { 0, 0x3456789a } }
  6064		},
  6065		{
  6066			"ALU64_LSH_K: Shift > 32, low word",
  6067			.u.insns_int = {
  6068				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6069				BPF_ALU64_IMM(BPF_LSH, R0, 36),
  6070				BPF_EXIT_INSN(),
  6071			},
  6072			INTERNAL,
  6073			{ },
  6074			{ { 0, 0 } }
  6075		},
  6076		{
  6077			"ALU64_LSH_K: Shift > 32, high word",
  6078			.u.insns_int = {
  6079				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6080				BPF_ALU64_IMM(BPF_LSH, R0, 36),
  6081				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6082				BPF_EXIT_INSN(),
  6083			},
  6084			INTERNAL,
  6085			{ },
  6086			{ { 0, 0x9abcdef0 } }
  6087		},
  6088		{
  6089			"ALU64_LSH_K: Shift == 32, low word",
  6090			.u.insns_int = {
  6091				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6092				BPF_ALU64_IMM(BPF_LSH, R0, 32),
  6093				BPF_EXIT_INSN(),
  6094			},
  6095			INTERNAL,
  6096			{ },
  6097			{ { 0, 0 } }
  6098		},
  6099		{
  6100			"ALU64_LSH_K: Shift == 32, high word",
  6101			.u.insns_int = {
  6102				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6103				BPF_ALU64_IMM(BPF_LSH, R0, 32),
  6104				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6105				BPF_EXIT_INSN(),
  6106			},
  6107			INTERNAL,
  6108			{ },
  6109			{ { 0, 0x89abcdef } }
  6110		},
  6111		{
  6112			"ALU64_LSH_K: Zero shift",
  6113			.u.insns_int = {
  6114				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6115				BPF_ALU64_IMM(BPF_LSH, R0, 0),
  6116				BPF_EXIT_INSN(),
  6117			},
  6118			INTERNAL,
  6119			{ },
  6120			{ { 0, 0x89abcdef } }
  6121		},
  6122		/* BPF_ALU | BPF_RSH | BPF_X */
  6123		{
  6124			"ALU_RSH_X: 2 >> 1 = 1",
  6125			.u.insns_int = {
  6126				BPF_LD_IMM64(R0, 2),
  6127				BPF_ALU32_IMM(BPF_MOV, R1, 1),
  6128				BPF_ALU32_REG(BPF_RSH, R0, R1),
  6129				BPF_EXIT_INSN(),
  6130			},
  6131			INTERNAL,
  6132			{ },
  6133			{ { 0, 1 } },
  6134		},
  6135		{
  6136			"ALU_RSH_X: 0x80000000 >> 31 = 1",
  6137			.u.insns_int = {
  6138				BPF_LD_IMM64(R0, 0x80000000),
  6139				BPF_ALU32_IMM(BPF_MOV, R1, 31),
  6140				BPF_ALU32_REG(BPF_RSH, R0, R1),
  6141				BPF_EXIT_INSN(),
  6142			},
  6143			INTERNAL,
  6144			{ },
  6145			{ { 0, 1 } },
  6146		},
  6147		{
  6148			"ALU_RSH_X: 0x12345678 >> 20 = 0x123",
  6149			.u.insns_int = {
  6150				BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
  6151				BPF_ALU32_IMM(BPF_MOV, R1, 20),
  6152				BPF_ALU32_REG(BPF_RSH, R0, R1),
  6153				BPF_EXIT_INSN(),
  6154			},
  6155			INTERNAL,
  6156			{ },
  6157			{ { 0, 0x123 } }
  6158		},
  6159		{
  6160			"ALU64_RSH_X: 2 >> 1 = 1",
  6161			.u.insns_int = {
  6162				BPF_LD_IMM64(R0, 2),
  6163				BPF_ALU32_IMM(BPF_MOV, R1, 1),
  6164				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6165				BPF_EXIT_INSN(),
  6166			},
  6167			INTERNAL,
  6168			{ },
  6169			{ { 0, 1 } },
  6170		},
  6171		{
  6172			"ALU64_RSH_X: 0x80000000 >> 31 = 1",
  6173			.u.insns_int = {
  6174				BPF_LD_IMM64(R0, 0x80000000),
  6175				BPF_ALU32_IMM(BPF_MOV, R1, 31),
  6176				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6177				BPF_EXIT_INSN(),
  6178			},
  6179			INTERNAL,
  6180			{ },
  6181			{ { 0, 1 } },
  6182		},
  6183		{
  6184			"ALU64_RSH_X: Shift < 32, low word",
  6185			.u.insns_int = {
  6186				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6187				BPF_ALU32_IMM(BPF_MOV, R1, 12),
  6188				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6189				BPF_EXIT_INSN(),
  6190			},
  6191			INTERNAL,
  6192			{ },
  6193			{ { 0, 0x56789abc } }
  6194		},
  6195		{
  6196			"ALU64_RSH_X: Shift < 32, high word",
  6197			.u.insns_int = {
  6198				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6199				BPF_ALU32_IMM(BPF_MOV, R1, 12),
  6200				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6201				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6202				BPF_EXIT_INSN(),
  6203			},
  6204			INTERNAL,
  6205			{ },
  6206			{ { 0, 0x00081234 } }
  6207		},
  6208		{
  6209			"ALU64_RSH_X: Shift > 32, low word",
  6210			.u.insns_int = {
  6211				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6212				BPF_ALU32_IMM(BPF_MOV, R1, 36),
  6213				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6214				BPF_EXIT_INSN(),
  6215			},
  6216			INTERNAL,
  6217			{ },
  6218			{ { 0, 0x08123456 } }
  6219		},
  6220		{
  6221			"ALU64_RSH_X: Shift > 32, high word",
  6222			.u.insns_int = {
  6223				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6224				BPF_ALU32_IMM(BPF_MOV, R1, 36),
  6225				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6226				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6227				BPF_EXIT_INSN(),
  6228			},
  6229			INTERNAL,
  6230			{ },
  6231			{ { 0, 0 } }
  6232		},
  6233		{
  6234			"ALU64_RSH_X: Shift == 32, low word",
  6235			.u.insns_int = {
  6236				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6237				BPF_ALU32_IMM(BPF_MOV, R1, 32),
  6238				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6239				BPF_EXIT_INSN(),
  6240			},
  6241			INTERNAL,
  6242			{ },
  6243			{ { 0, 0x81234567 } }
  6244		},
  6245		{
  6246			"ALU64_RSH_X: Shift == 32, high word",
  6247			.u.insns_int = {
  6248				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6249				BPF_ALU32_IMM(BPF_MOV, R1, 32),
  6250				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6251				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6252				BPF_EXIT_INSN(),
  6253			},
  6254			INTERNAL,
  6255			{ },
  6256			{ { 0, 0 } }
  6257		},
  6258		{
  6259			"ALU64_RSH_X: Zero shift, low word",
  6260			.u.insns_int = {
  6261				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6262				BPF_ALU32_IMM(BPF_MOV, R1, 0),
  6263				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6264				BPF_EXIT_INSN(),
  6265			},
  6266			INTERNAL,
  6267			{ },
  6268			{ { 0, 0x89abcdef } }
  6269		},
  6270		{
  6271			"ALU64_RSH_X: Zero shift, high word",
  6272			.u.insns_int = {
  6273				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6274				BPF_ALU32_IMM(BPF_MOV, R1, 0),
  6275				BPF_ALU64_REG(BPF_RSH, R0, R1),
  6276				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6277				BPF_EXIT_INSN(),
  6278			},
  6279			INTERNAL,
  6280			{ },
  6281			{ { 0, 0x81234567 } }
  6282		},
  6283		/* BPF_ALU | BPF_RSH | BPF_K */
  6284		{
  6285			"ALU_RSH_K: 2 >> 1 = 1",
  6286			.u.insns_int = {
  6287				BPF_LD_IMM64(R0, 2),
  6288				BPF_ALU32_IMM(BPF_RSH, R0, 1),
  6289				BPF_EXIT_INSN(),
  6290			},
  6291			INTERNAL,
  6292			{ },
  6293			{ { 0, 1 } },
  6294		},
  6295		{
  6296			"ALU_RSH_K: 0x80000000 >> 31 = 1",
  6297			.u.insns_int = {
  6298				BPF_LD_IMM64(R0, 0x80000000),
  6299				BPF_ALU32_IMM(BPF_RSH, R0, 31),
  6300				BPF_EXIT_INSN(),
  6301			},
  6302			INTERNAL,
  6303			{ },
  6304			{ { 0, 1 } },
  6305		},
  6306		{
  6307			"ALU_RSH_K: 0x12345678 >> 20 = 0x123",
  6308			.u.insns_int = {
  6309				BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
  6310				BPF_ALU32_IMM(BPF_RSH, R0, 20),
  6311				BPF_EXIT_INSN(),
  6312			},
  6313			INTERNAL,
  6314			{ },
  6315			{ { 0, 0x123 } }
  6316		},
  6317		{
  6318			"ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
  6319			.u.insns_int = {
  6320				BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
  6321				BPF_ALU32_IMM(BPF_RSH, R0, 0),
  6322				BPF_EXIT_INSN(),
  6323			},
  6324			INTERNAL,
  6325			{ },
  6326			{ { 0, 0x12345678 } }
  6327		},
  6328		{
  6329			"ALU64_RSH_K: 2 >> 1 = 1",
  6330			.u.insns_int = {
  6331				BPF_LD_IMM64(R0, 2),
  6332				BPF_ALU64_IMM(BPF_RSH, R0, 1),
  6333				BPF_EXIT_INSN(),
  6334			},
  6335			INTERNAL,
  6336			{ },
  6337			{ { 0, 1 } },
  6338		},
  6339		{
  6340			"ALU64_RSH_K: 0x80000000 >> 31 = 1",
  6341			.u.insns_int = {
  6342				BPF_LD_IMM64(R0, 0x80000000),
  6343				BPF_ALU64_IMM(BPF_RSH, R0, 31),
  6344				BPF_EXIT_INSN(),
  6345			},
  6346			INTERNAL,
  6347			{ },
  6348			{ { 0, 1 } },
  6349		},
  6350		{
  6351			"ALU64_RSH_K: Shift < 32, low word",
  6352			.u.insns_int = {
  6353				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6354				BPF_ALU64_IMM(BPF_RSH, R0, 12),
  6355				BPF_EXIT_INSN(),
  6356			},
  6357			INTERNAL,
  6358			{ },
  6359			{ { 0, 0x56789abc } }
  6360		},
  6361		{
  6362			"ALU64_RSH_K: Shift < 32, high word",
  6363			.u.insns_int = {
  6364				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6365				BPF_ALU64_IMM(BPF_RSH, R0, 12),
  6366				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6367				BPF_EXIT_INSN(),
  6368			},
  6369			INTERNAL,
  6370			{ },
  6371			{ { 0, 0x00081234 } }
  6372		},
  6373		{
  6374			"ALU64_RSH_K: Shift > 32, low word",
  6375			.u.insns_int = {
  6376				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6377				BPF_ALU64_IMM(BPF_RSH, R0, 36),
  6378				BPF_EXIT_INSN(),
  6379			},
  6380			INTERNAL,
  6381			{ },
  6382			{ { 0, 0x08123456 } }
  6383		},
  6384		{
  6385			"ALU64_RSH_K: Shift > 32, high word",
  6386			.u.insns_int = {
  6387				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6388				BPF_ALU64_IMM(BPF_RSH, R0, 36),
  6389				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6390				BPF_EXIT_INSN(),
  6391			},
  6392			INTERNAL,
  6393			{ },
  6394			{ { 0, 0 } }
  6395		},
  6396		{
  6397			"ALU64_RSH_K: Shift == 32, low word",
  6398			.u.insns_int = {
  6399				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6400				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6401				BPF_EXIT_INSN(),
  6402			},
  6403			INTERNAL,
  6404			{ },
  6405			{ { 0, 0x81234567 } }
  6406		},
  6407		{
  6408			"ALU64_RSH_K: Shift == 32, high word",
  6409			.u.insns_int = {
  6410				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6411				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6412				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6413				BPF_EXIT_INSN(),
  6414			},
  6415			INTERNAL,
  6416			{ },
  6417			{ { 0, 0 } }
  6418		},
  6419		{
  6420			"ALU64_RSH_K: Zero shift",
  6421			.u.insns_int = {
  6422				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6423				BPF_ALU64_IMM(BPF_RSH, R0, 0),
  6424				BPF_EXIT_INSN(),
  6425			},
  6426			INTERNAL,
  6427			{ },
  6428			{ { 0, 0x89abcdef } }
  6429		},
  6430		/* BPF_ALU | BPF_ARSH | BPF_X */
  6431		{
  6432			"ALU32_ARSH_X: -1234 >> 7 = -10",
  6433			.u.insns_int = {
  6434				BPF_ALU32_IMM(BPF_MOV, R0, -1234),
  6435				BPF_ALU32_IMM(BPF_MOV, R1, 7),
  6436				BPF_ALU32_REG(BPF_ARSH, R0, R1),
  6437				BPF_EXIT_INSN(),
  6438			},
  6439			INTERNAL,
  6440			{ },
  6441			{ { 0, -10 } }
  6442		},
  6443		{
  6444			"ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
  6445			.u.insns_int = {
  6446				BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
  6447				BPF_ALU32_IMM(BPF_MOV, R1, 40),
  6448				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6449				BPF_EXIT_INSN(),
  6450			},
  6451			INTERNAL,
  6452			{ },
  6453			{ { 0, 0xffff00ff } },
  6454		},
  6455		{
  6456			"ALU64_ARSH_X: Shift < 32, low word",
  6457			.u.insns_int = {
  6458				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6459				BPF_ALU32_IMM(BPF_MOV, R1, 12),
  6460				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6461				BPF_EXIT_INSN(),
  6462			},
  6463			INTERNAL,
  6464			{ },
  6465			{ { 0, 0x56789abc } }
  6466		},
  6467		{
  6468			"ALU64_ARSH_X: Shift < 32, high word",
  6469			.u.insns_int = {
  6470				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6471				BPF_ALU32_IMM(BPF_MOV, R1, 12),
  6472				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6473				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6474				BPF_EXIT_INSN(),
  6475			},
  6476			INTERNAL,
  6477			{ },
  6478			{ { 0, 0xfff81234 } }
  6479		},
  6480		{
  6481			"ALU64_ARSH_X: Shift > 32, low word",
  6482			.u.insns_int = {
  6483				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6484				BPF_ALU32_IMM(BPF_MOV, R1, 36),
  6485				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6486				BPF_EXIT_INSN(),
  6487			},
  6488			INTERNAL,
  6489			{ },
  6490			{ { 0, 0xf8123456 } }
  6491		},
  6492		{
  6493			"ALU64_ARSH_X: Shift > 32, high word",
  6494			.u.insns_int = {
  6495				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6496				BPF_ALU32_IMM(BPF_MOV, R1, 36),
  6497				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6498				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6499				BPF_EXIT_INSN(),
  6500			},
  6501			INTERNAL,
  6502			{ },
  6503			{ { 0, -1 } }
  6504		},
  6505		{
  6506			"ALU64_ARSH_X: Shift == 32, low word",
  6507			.u.insns_int = {
  6508				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6509				BPF_ALU32_IMM(BPF_MOV, R1, 32),
  6510				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6511				BPF_EXIT_INSN(),
  6512			},
  6513			INTERNAL,
  6514			{ },
  6515			{ { 0, 0x81234567 } }
  6516		},
  6517		{
  6518			"ALU64_ARSH_X: Shift == 32, high word",
  6519			.u.insns_int = {
  6520				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6521				BPF_ALU32_IMM(BPF_MOV, R1, 32),
  6522				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6523				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6524				BPF_EXIT_INSN(),
  6525			},
  6526			INTERNAL,
  6527			{ },
  6528			{ { 0, -1 } }
  6529		},
  6530		{
  6531			"ALU64_ARSH_X: Zero shift, low word",
  6532			.u.insns_int = {
  6533				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6534				BPF_ALU32_IMM(BPF_MOV, R1, 0),
  6535				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6536				BPF_EXIT_INSN(),
  6537			},
  6538			INTERNAL,
  6539			{ },
  6540			{ { 0, 0x89abcdef } }
  6541		},
  6542		{
  6543			"ALU64_ARSH_X: Zero shift, high word",
  6544			.u.insns_int = {
  6545				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6546				BPF_ALU32_IMM(BPF_MOV, R1, 0),
  6547				BPF_ALU64_REG(BPF_ARSH, R0, R1),
  6548				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6549				BPF_EXIT_INSN(),
  6550			},
  6551			INTERNAL,
  6552			{ },
  6553			{ { 0, 0x81234567 } }
  6554		},
  6555		/* BPF_ALU | BPF_ARSH | BPF_K */
  6556		{
  6557			"ALU32_ARSH_K: -1234 >> 7 = -10",
  6558			.u.insns_int = {
  6559				BPF_ALU32_IMM(BPF_MOV, R0, -1234),
  6560				BPF_ALU32_IMM(BPF_ARSH, R0, 7),
  6561				BPF_EXIT_INSN(),
  6562			},
  6563			INTERNAL,
  6564			{ },
  6565			{ { 0, -10 } }
  6566		},
  6567		{
  6568			"ALU32_ARSH_K: -1234 >> 0 = -1234",
  6569			.u.insns_int = {
  6570				BPF_ALU32_IMM(BPF_MOV, R0, -1234),
  6571				BPF_ALU32_IMM(BPF_ARSH, R0, 0),
  6572				BPF_EXIT_INSN(),
  6573			},
  6574			INTERNAL,
  6575			{ },
  6576			{ { 0, -1234 } }
  6577		},
  6578		{
  6579			"ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
  6580			.u.insns_int = {
  6581				BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
  6582				BPF_ALU64_IMM(BPF_ARSH, R0, 40),
  6583				BPF_EXIT_INSN(),
  6584			},
  6585			INTERNAL,
  6586			{ },
  6587			{ { 0, 0xffff00ff } },
  6588		},
  6589		{
  6590			"ALU64_ARSH_K: Shift < 32, low word",
  6591			.u.insns_int = {
  6592				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6593				BPF_ALU64_IMM(BPF_RSH, R0, 12),
  6594				BPF_EXIT_INSN(),
  6595			},
  6596			INTERNAL,
  6597			{ },
  6598			{ { 0, 0x56789abc } }
  6599		},
  6600		{
  6601			"ALU64_ARSH_K: Shift < 32, high word",
  6602			.u.insns_int = {
  6603				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6604				BPF_ALU64_IMM(BPF_ARSH, R0, 12),
  6605				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6606				BPF_EXIT_INSN(),
  6607			},
  6608			INTERNAL,
  6609			{ },
  6610			{ { 0, 0xfff81234 } }
  6611		},
  6612		{
  6613			"ALU64_ARSH_K: Shift > 32, low word",
  6614			.u.insns_int = {
  6615				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6616				BPF_ALU64_IMM(BPF_ARSH, R0, 36),
  6617				BPF_EXIT_INSN(),
  6618			},
  6619			INTERNAL,
  6620			{ },
  6621			{ { 0, 0xf8123456 } }
  6622		},
  6623		{
  6624			"ALU64_ARSH_K: Shift > 32, high word",
  6625			.u.insns_int = {
  6626				BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
  6627				BPF_ALU64_IMM(BPF_ARSH, R0, 36),
  6628				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6629				BPF_EXIT_INSN(),
  6630			},
  6631			INTERNAL,
  6632			{ },
  6633			{ { 0, -1 } }
  6634		},
  6635		{
  6636			"ALU64_ARSH_K: Shift == 32, low word",
  6637			.u.insns_int = {
  6638				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6639				BPF_ALU64_IMM(BPF_ARSH, R0, 32),
  6640				BPF_EXIT_INSN(),
  6641			},
  6642			INTERNAL,
  6643			{ },
  6644			{ { 0, 0x81234567 } }
  6645		},
  6646		{
  6647			"ALU64_ARSH_K: Shift == 32, high word",
  6648			.u.insns_int = {
  6649				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6650				BPF_ALU64_IMM(BPF_ARSH, R0, 32),
  6651				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6652				BPF_EXIT_INSN(),
  6653			},
  6654			INTERNAL,
  6655			{ },
  6656			{ { 0, -1 } }
  6657		},
  6658		{
  6659			"ALU64_ARSH_K: Zero shift",
  6660			.u.insns_int = {
  6661				BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
  6662				BPF_ALU64_IMM(BPF_ARSH, R0, 0),
  6663				BPF_EXIT_INSN(),
  6664			},
  6665			INTERNAL,
  6666			{ },
  6667			{ { 0, 0x89abcdef } }
  6668		},
  6669		/* BPF_ALU | BPF_NEG */
  6670		{
  6671			"ALU_NEG: -(3) = -3",
  6672			.u.insns_int = {
  6673				BPF_ALU32_IMM(BPF_MOV, R0, 3),
  6674				BPF_ALU32_IMM(BPF_NEG, R0, 0),
  6675				BPF_EXIT_INSN(),
  6676			},
  6677			INTERNAL,
  6678			{ },
  6679			{ { 0, -3 } },
  6680		},
  6681		{
  6682			"ALU_NEG: -(-3) = 3",
  6683			.u.insns_int = {
  6684				BPF_ALU32_IMM(BPF_MOV, R0, -3),
  6685				BPF_ALU32_IMM(BPF_NEG, R0, 0),
  6686				BPF_EXIT_INSN(),
  6687			},
  6688			INTERNAL,
  6689			{ },
  6690			{ { 0, 3 } },
  6691		},
  6692		{
  6693			"ALU64_NEG: -(3) = -3",
  6694			.u.insns_int = {
  6695				BPF_LD_IMM64(R0, 3),
  6696				BPF_ALU64_IMM(BPF_NEG, R0, 0),
  6697				BPF_EXIT_INSN(),
  6698			},
  6699			INTERNAL,
  6700			{ },
  6701			{ { 0, -3 } },
  6702		},
  6703		{
  6704			"ALU64_NEG: -(-3) = 3",
  6705			.u.insns_int = {
  6706				BPF_LD_IMM64(R0, -3),
  6707				BPF_ALU64_IMM(BPF_NEG, R0, 0),
  6708				BPF_EXIT_INSN(),
  6709			},
  6710			INTERNAL,
  6711			{ },
  6712			{ { 0, 3 } },
  6713		},
  6714		/* BPF_ALU | BPF_END | BPF_FROM_BE */
  6715		{
  6716			"ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
  6717			.u.insns_int = {
  6718				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6719				BPF_ENDIAN(BPF_FROM_BE, R0, 16),
  6720				BPF_EXIT_INSN(),
  6721			},
  6722			INTERNAL,
  6723			{ },
  6724			{ { 0,  cpu_to_be16(0xcdef) } },
  6725		},
  6726		{
  6727			"ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
  6728			.u.insns_int = {
  6729				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6730				BPF_ENDIAN(BPF_FROM_BE, R0, 32),
  6731				BPF_ALU64_REG(BPF_MOV, R1, R0),
  6732				BPF_ALU64_IMM(BPF_RSH, R1, 32),
  6733				BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
  6734				BPF_EXIT_INSN(),
  6735			},
  6736			INTERNAL,
  6737			{ },
  6738			{ { 0, cpu_to_be32(0x89abcdef) } },
  6739		},
  6740		{
  6741			"ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
  6742			.u.insns_int = {
  6743				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6744				BPF_ENDIAN(BPF_FROM_BE, R0, 64),
  6745				BPF_EXIT_INSN(),
  6746			},
  6747			INTERNAL,
  6748			{ },
  6749			{ { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
  6750		},
  6751		{
  6752			"ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
  6753			.u.insns_int = {
  6754				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6755				BPF_ENDIAN(BPF_FROM_BE, R0, 64),
  6756				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6757				BPF_EXIT_INSN(),
  6758			},
  6759			INTERNAL,
  6760			{ },
  6761			{ { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
  6762		},
  6763		/* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
  6764		{
  6765			"ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
  6766			.u.insns_int = {
  6767				BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
  6768				BPF_ENDIAN(BPF_FROM_BE, R0, 16),
  6769				BPF_EXIT_INSN(),
  6770			},
  6771			INTERNAL,
  6772			{ },
  6773			{ { 0,  cpu_to_be16(0x3210) } },
  6774		},
  6775		{
  6776			"ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
  6777			.u.insns_int = {
  6778				BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
  6779				BPF_ENDIAN(BPF_FROM_BE, R0, 32),
  6780				BPF_ALU64_REG(BPF_MOV, R1, R0),
  6781				BPF_ALU64_IMM(BPF_RSH, R1, 32),
  6782				BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
  6783				BPF_EXIT_INSN(),
  6784			},
  6785			INTERNAL,
  6786			{ },
  6787			{ { 0, cpu_to_be32(0x76543210) } },
  6788		},
  6789		{
  6790			"ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
  6791			.u.insns_int = {
  6792				BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
  6793				BPF_ENDIAN(BPF_FROM_BE, R0, 64),
  6794				BPF_EXIT_INSN(),
  6795			},
  6796			INTERNAL,
  6797			{ },
  6798			{ { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
  6799		},
  6800		{
  6801			"ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
  6802			.u.insns_int = {
  6803				BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
  6804				BPF_ENDIAN(BPF_FROM_BE, R0, 64),
  6805				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6806				BPF_EXIT_INSN(),
  6807			},
  6808			INTERNAL,
  6809			{ },
  6810			{ { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
  6811		},
  6812		/* BPF_ALU | BPF_END | BPF_FROM_LE */
  6813		{
  6814			"ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
  6815			.u.insns_int = {
  6816				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6817				BPF_ENDIAN(BPF_FROM_LE, R0, 16),
  6818				BPF_EXIT_INSN(),
  6819			},
  6820			INTERNAL,
  6821			{ },
  6822			{ { 0, cpu_to_le16(0xcdef) } },
  6823		},
  6824		{
  6825			"ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
  6826			.u.insns_int = {
  6827				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6828				BPF_ENDIAN(BPF_FROM_LE, R0, 32),
  6829				BPF_ALU64_REG(BPF_MOV, R1, R0),
  6830				BPF_ALU64_IMM(BPF_RSH, R1, 32),
  6831				BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
  6832				BPF_EXIT_INSN(),
  6833			},
  6834			INTERNAL,
  6835			{ },
  6836			{ { 0, cpu_to_le32(0x89abcdef) } },
  6837		},
  6838		{
  6839			"ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
  6840			.u.insns_int = {
  6841				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6842				BPF_ENDIAN(BPF_FROM_LE, R0, 64),
  6843				BPF_EXIT_INSN(),
  6844			},
  6845			INTERNAL,
  6846			{ },
  6847			{ { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
  6848		},
  6849		{
  6850			"ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
  6851			.u.insns_int = {
  6852				BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
  6853				BPF_ENDIAN(BPF_FROM_LE, R0, 64),
  6854				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6855				BPF_EXIT_INSN(),
  6856			},
  6857			INTERNAL,
  6858			{ },
  6859			{ { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
  6860		},
  6861		/* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
  6862		{
  6863			"ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
  6864			.u.insns_int = {
  6865				BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
  6866				BPF_ENDIAN(BPF_FROM_LE, R0, 16),
  6867				BPF_EXIT_INSN(),
  6868			},
  6869			INTERNAL,
  6870			{ },
  6871			{ { 0,  cpu_to_le16(0x3210) } },
  6872		},
  6873		{
  6874			"ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
  6875			.u.insns_int = {
  6876				BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
  6877				BPF_ENDIAN(BPF_FROM_LE, R0, 32),
  6878				BPF_ALU64_REG(BPF_MOV, R1, R0),
  6879				BPF_ALU64_IMM(BPF_RSH, R1, 32),
  6880				BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
  6881				BPF_EXIT_INSN(),
  6882			},
  6883			INTERNAL,
  6884			{ },
  6885			{ { 0, cpu_to_le32(0x76543210) } },
  6886		},
  6887		{
  6888			"ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
  6889			.u.insns_int = {
  6890				BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
  6891				BPF_ENDIAN(BPF_FROM_LE, R0, 64),
  6892				BPF_EXIT_INSN(),
  6893			},
  6894			INTERNAL,
  6895			{ },
> 6896			{ { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
  6897		},
  6898		{
  6899			"ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
  6900			.u.insns_int = {
  6901				BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
  6902				BPF_ENDIAN(BPF_FROM_LE, R0, 64),
  6903				BPF_ALU64_IMM(BPF_RSH, R0, 32),
  6904				BPF_EXIT_INSN(),
  6905			},
  6906			INTERNAL,
  6907			{ },
  6908			{ { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
  6909		},
  6910		/* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
  6911		{
  6912			"ST_MEM_B: Store/Load byte: max negative",
  6913			.u.insns_int = {
  6914				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  6915				BPF_ST_MEM(BPF_B, R10, -40, 0xff),
  6916				BPF_LDX_MEM(BPF_B, R0, R10, -40),
  6917				BPF_EXIT_INSN(),
  6918			},
  6919			INTERNAL,
  6920			{ },
  6921			{ { 0, 0xff } },
  6922			.stack_depth = 40,
  6923		},
  6924		{
  6925			"ST_MEM_B: Store/Load byte: max positive",
  6926			.u.insns_int = {
  6927				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  6928				BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
  6929				BPF_LDX_MEM(BPF_H, R0, R10, -40),
  6930				BPF_EXIT_INSN(),
  6931			},
  6932			INTERNAL,
  6933			{ },
  6934			{ { 0, 0x7f } },
  6935			.stack_depth = 40,
  6936		},
  6937		{
  6938			"STX_MEM_B: Store/Load byte: max negative",
  6939			.u.insns_int = {
  6940				BPF_LD_IMM64(R0, 0),
  6941				BPF_LD_IMM64(R1, 0xffLL),
  6942				BPF_STX_MEM(BPF_B, R10, R1, -40),
  6943				BPF_LDX_MEM(BPF_B, R0, R10, -40),
  6944				BPF_EXIT_INSN(),
  6945			},
  6946			INTERNAL,
  6947			{ },
  6948			{ { 0, 0xff } },
  6949			.stack_depth = 40,
  6950		},
  6951		{
  6952			"ST_MEM_H: Store/Load half word: max negative",
  6953			.u.insns_int = {
  6954				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  6955				BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
  6956				BPF_LDX_MEM(BPF_H, R0, R10, -40),
  6957				BPF_EXIT_INSN(),
  6958			},
  6959			INTERNAL,
  6960			{ },
  6961			{ { 0, 0xffff } },
  6962			.stack_depth = 40,
  6963		},
  6964		{
  6965			"ST_MEM_H: Store/Load half word: max positive",
  6966			.u.insns_int = {
  6967				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  6968				BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
  6969				BPF_LDX_MEM(BPF_H, R0, R10, -40),
  6970				BPF_EXIT_INSN(),
  6971			},
  6972			INTERNAL,
  6973			{ },
  6974			{ { 0, 0x7fff } },
  6975			.stack_depth = 40,
  6976		},
  6977		{
  6978			"STX_MEM_H: Store/Load half word: max negative",
  6979			.u.insns_int = {
  6980				BPF_LD_IMM64(R0, 0),
  6981				BPF_LD_IMM64(R1, 0xffffLL),
  6982				BPF_STX_MEM(BPF_H, R10, R1, -40),
  6983				BPF_LDX_MEM(BPF_H, R0, R10, -40),
  6984				BPF_EXIT_INSN(),
  6985			},
  6986			INTERNAL,
  6987			{ },
  6988			{ { 0, 0xffff } },
  6989			.stack_depth = 40,
  6990		},
  6991		{
  6992			"ST_MEM_W: Store/Load word: max negative",
  6993			.u.insns_int = {
  6994				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  6995				BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
  6996				BPF_LDX_MEM(BPF_W, R0, R10, -40),
  6997				BPF_EXIT_INSN(),
  6998			},
  6999			INTERNAL,
  7000			{ },
  7001			{ { 0, 0xffffffff } },
  7002			.stack_depth = 40,
  7003		},
  7004		{
  7005			"ST_MEM_W: Store/Load word: max positive",
  7006			.u.insns_int = {
  7007				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  7008				BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
  7009				BPF_LDX_MEM(BPF_W, R0, R10, -40),
  7010				BPF_EXIT_INSN(),
  7011			},
  7012			INTERNAL,
  7013			{ },
  7014			{ { 0, 0x7fffffff } },
  7015			.stack_depth = 40,
  7016		},
  7017		{
  7018			"STX_MEM_W: Store/Load word: max negative",
  7019			.u.insns_int = {
  7020				BPF_LD_IMM64(R0, 0),
  7021				BPF_LD_IMM64(R1, 0xffffffffLL),
  7022				BPF_STX_MEM(BPF_W, R10, R1, -40),
  7023				BPF_LDX_MEM(BPF_W, R0, R10, -40),
  7024				BPF_EXIT_INSN(),
  7025			},
  7026			INTERNAL,
  7027			{ },
  7028			{ { 0, 0xffffffff } },
  7029			.stack_depth = 40,
  7030		},
  7031		{
  7032			"ST_MEM_DW: Store/Load double word: max negative",
  7033			.u.insns_int = {
  7034				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  7035				BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
  7036				BPF_LDX_MEM(BPF_DW, R0, R10, -40),
  7037				BPF_EXIT_INSN(),
  7038			},
  7039			INTERNAL,
  7040			{ },
  7041			{ { 0, 0xffffffff } },
  7042			.stack_depth = 40,
  7043		},
  7044		{
  7045			"ST_MEM_DW: Store/Load double word: max negative 2",
  7046			.u.insns_int = {
  7047				BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
  7048				BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
  7049				BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
  7050				BPF_LDX_MEM(BPF_DW, R2, R10, -40),
  7051				BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
  7052				BPF_MOV32_IMM(R0, 2),
  7053				BPF_EXIT_INSN(),
  7054				BPF_MOV32_IMM(R0, 1),
  7055				BPF_EXIT_INSN(),
  7056			},
  7057			INTERNAL,
  7058			{ },
  7059			{ { 0, 0x1 } },
  7060			.stack_depth = 40,
  7061		},
  7062		{
  7063			"ST_MEM_DW: Store/Load double word: max positive",
  7064			.u.insns_int = {
  7065				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  7066				BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
  7067				BPF_LDX_MEM(BPF_DW, R0, R10, -40),
  7068				BPF_EXIT_INSN(),
  7069			},
  7070			INTERNAL,
  7071			{ },
  7072			{ { 0, 0x7fffffff } },
  7073			.stack_depth = 40,
  7074		},
  7075		{
  7076			"STX_MEM_DW: Store/Load double word: max negative",
  7077			.u.insns_int = {
  7078				BPF_LD_IMM64(R0, 0),
  7079				BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
  7080				BPF_STX_MEM(BPF_DW, R10, R1, -40),
  7081				BPF_LDX_MEM(BPF_DW, R0, R10, -40),
  7082				BPF_EXIT_INSN(),
  7083			},
  7084			INTERNAL,
  7085			{ },
  7086			{ { 0, 0xffffffff } },
  7087			.stack_depth = 40,
  7088		},
  7089		{
  7090			"STX_MEM_DW: Store double word: first word in memory",
  7091			.u.insns_int = {
  7092				BPF_LD_IMM64(R0, 0),
  7093				BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
  7094				BPF_STX_MEM(BPF_DW, R10, R1, -40),
  7095				BPF_LDX_MEM(BPF_W, R0, R10, -40),
  7096				BPF_EXIT_INSN(),
  7097			},
  7098			INTERNAL,
  7099			{ },
  7100	#ifdef __BIG_ENDIAN
  7101			{ { 0, 0x01234567 } },
  7102	#else
  7103			{ { 0, 0x89abcdef } },
  7104	#endif
  7105			.stack_depth = 40,
  7106		},
  7107		{
  7108			"STX_MEM_DW: Store double word: second word in memory",
  7109			.u.insns_int = {
  7110				BPF_LD_IMM64(R0, 0),
  7111				BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
  7112				BPF_STX_MEM(BPF_DW, R10, R1, -40),
  7113				BPF_LDX_MEM(BPF_W, R0, R10, -36),
  7114				BPF_EXIT_INSN(),
  7115			},
  7116			INTERNAL,
  7117			{ },
  7118	#ifdef __BIG_ENDIAN
  7119			{ { 0, 0x89abcdef } },
  7120	#else
  7121			{ { 0, 0x01234567 } },
  7122	#endif
  7123			.stack_depth = 40,
  7124		},
  7125		/* BPF_STX | BPF_ATOMIC | BPF_W/DW */
  7126		{
  7127			"STX_XADD_W: X + 1 + 1 + 1 + ...",
  7128			{ },
  7129			INTERNAL,
  7130			{ },
  7131			{ { 0, 4134 } },
  7132			.fill_helper = bpf_fill_stxw,
  7133		},
  7134		{
  7135			"STX_XADD_DW: X + 1 + 1 + 1 + ...",
  7136			{ },
  7137			INTERNAL,
  7138			{ },
  7139			{ { 0, 4134 } },
  7140			.fill_helper = bpf_fill_stxdw,
  7141		},
  7142		/*
  7143		 * Exhaustive tests of atomic operation variants.
  7144		 * Individual tests are expanded from template macros for all
  7145		 * combinations of ALU operation, word size and fetching.
  7146		 */
  7147	#define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)	\
  7148	{									\
  7149		"BPF_ATOMIC | " #width ", " #op ": Test: "			\
  7150			#old " " #logic " " #update " = " #result,		\
  7151		.u.insns_int = {						\
  7152			BPF_ALU32_IMM(BPF_MOV, R5, update),			\
  7153			BPF_ST_MEM(width, R10, -40, old),			\
  7154			BPF_ATOMIC_OP(width, op, R10, R5, -40),			\
  7155			BPF_LDX_MEM(width, R0, R10, -40),			\
  7156			BPF_EXIT_INSN(),					\
  7157		},								\
  7158		INTERNAL,							\
  7159		{ },								\
  7160		{ { 0, result } },						\
  7161		.stack_depth = 40,						\
  7162	}
  7163	#define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)	\
  7164	{									\
  7165		"BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "	\
  7166			#old " " #logic " " #update " = " #result,		\
  7167		.u.insns_int = {						\
  7168			BPF_ALU64_REG(BPF_MOV, R1, R10),			\
  7169			BPF_ALU32_IMM(BPF_MOV, R0, update),			\
  7170			BPF_ST_MEM(BPF_W, R10, -40, old),			\
  7171			BPF_ATOMIC_OP(width, op, R10, R0, -40),			\
  7172			BPF_ALU64_REG(BPF_MOV, R0, R10),			\
  7173			BPF_ALU64_REG(BPF_SUB, R0, R1),				\
  7174			BPF_EXIT_INSN(),					\
  7175		},								\
  7176		INTERNAL,							\
  7177		{ },								\
  7178		{ { 0, 0 } },							\
  7179		.stack_depth = 40,						\
  7180	}
  7181	#define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)	\
  7182	{									\
  7183		"BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "	\
  7184			#old " " #logic " " #update " = " #result,		\
  7185		.u.insns_int = {						\
  7186			BPF_ALU64_REG(BPF_MOV, R0, R10),			\
  7187			BPF_ALU32_IMM(BPF_MOV, R1, update),			\
  7188			BPF_ST_MEM(width, R10, -40, old),			\
  7189			BPF_ATOMIC_OP(width, op, R10, R1, -40),			\
  7190			BPF_ALU64_REG(BPF_SUB, R0, R10),			\
  7191			BPF_EXIT_INSN(),					\
  7192		},								\
  7193		INTERNAL,                                                       \
  7194		{ },                                                            \
  7195		{ { 0, 0 } },                                                   \
  7196		.stack_depth = 40,                                              \
  7197	}
  7198	#define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)	\
  7199	{									\
  7200		"BPF_ATOMIC | " #width ", " #op ": Test fetch: "		\
  7201			#old " " #logic " " #update " = " #result,		\
  7202		.u.insns_int = {						\
  7203			BPF_ALU32_IMM(BPF_MOV, R3, update),			\
  7204			BPF_ST_MEM(width, R10, -40, old),			\
  7205			BPF_ATOMIC_OP(width, op, R10, R3, -40),			\
  7206			BPF_ALU64_REG(BPF_MOV, R0, R3),                         \
  7207			BPF_EXIT_INSN(),					\
  7208		},								\
  7209		INTERNAL,                                                       \
  7210		{ },                                                            \
  7211		{ { 0, (op) & BPF_FETCH ? old : update } },			\
  7212		.stack_depth = 40,                                              \
  7213	}
  7214		/* BPF_ATOMIC | BPF_W: BPF_ADD */
  7215		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
  7216		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
  7217		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
  7218		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
  7219		/* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
  7220		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
  7221		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
  7222		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
  7223		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
  7224		/* BPF_ATOMIC | BPF_DW: BPF_ADD */
  7225		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
  7226		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
  7227		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
  7228		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
  7229		/* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
  7230		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
  7231		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
  7232		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
  7233		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
  7234		/* BPF_ATOMIC | BPF_W: BPF_AND */
  7235		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
  7236		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
  7237		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
  7238		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
  7239		/* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
  7240		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
  7241		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
  7242		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
  7243		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
  7244		/* BPF_ATOMIC | BPF_DW: BPF_AND */
  7245		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
  7246		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
  7247		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
  7248		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
  7249		/* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
  7250		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
  7251		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
  7252		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
  7253		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
  7254		/* BPF_ATOMIC | BPF_W: BPF_OR */
  7255		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
  7256		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
  7257		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
  7258		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
  7259		/* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
  7260		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
  7261		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
  7262		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
  7263		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
  7264		/* BPF_ATOMIC | BPF_DW: BPF_OR */
  7265		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
  7266		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
  7267		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
  7268		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
  7269		/* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
  7270		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
  7271		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
  7272		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
  7273		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
  7274		/* BPF_ATOMIC | BPF_W: BPF_XOR */
  7275		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
  7276		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
  7277		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
  7278		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
  7279		/* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
  7280		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
  7281		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
  7282		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
  7283		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
  7284		/* BPF_ATOMIC | BPF_DW: BPF_XOR */
  7285		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
  7286		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
  7287		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
  7288		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
  7289		/* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
  7290		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
  7291		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
  7292		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
  7293		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
  7294		/* BPF_ATOMIC | BPF_W: BPF_XCHG */
  7295		BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
  7296		BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
  7297		BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
  7298		BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
  7299		/* BPF_ATOMIC | BPF_DW: BPF_XCHG */
  7300		BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
  7301		BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
  7302		BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
  7303		BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
  7304	#undef BPF_ATOMIC_OP_TEST1
  7305	#undef BPF_ATOMIC_OP_TEST2
  7306	#undef BPF_ATOMIC_OP_TEST3
  7307	#undef BPF_ATOMIC_OP_TEST4
  7308		/* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
  7309		{
  7310			"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
  7311			.u.insns_int = {
  7312				BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
  7313				BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
  7314				BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
  7315				BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
  7316				BPF_EXIT_INSN(),
  7317			},
  7318			INTERNAL,
  7319			{ },
  7320			{ { 0, 0x01234567 } },
  7321			.stack_depth = 40,
  7322		},
  7323		{
  7324			"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
  7325			.u.insns_int = {
  7326				BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
  7327				BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
  7328				BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
  7329				BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
  7330				BPF_LDX_MEM(BPF_W, R0, R10, -40),
  7331				BPF_EXIT_INSN(),
  7332			},
  7333			INTERNAL,
  7334			{ },
  7335			{ { 0, 0x89abcdef } },
  7336			.stack_depth = 40,
  7337		},
  7338		{
  7339			"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
  7340			.u.insns_int = {
  7341				BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
  7342				BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
  7343				BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
  7344				BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
  7345				BPF_EXIT_INSN(),
  7346			},
  7347			INTERNAL,
  7348			{ },
  7349			{ { 0, 0x01234567 } },
  7350			.stack_depth = 40,
  7351		},
  7352		{
  7353			"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
  7354			.u.insns_int = {
  7355				BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
  7356				BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
  7357				BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
  7358				BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
  7359				BPF_LDX_MEM(BPF_W, R0, R10, -40),
  7360				BPF_EXIT_INSN(),
  7361			},
  7362			INTERNAL,
  7363			{ },
  7364			{ { 0, 0x01234567 } },
  7365			.stack_depth = 40,
  7366		},
  7367		{
  7368			"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
  7369			.u.insns_int = {
  7370				BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
  7371				BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
  7372				BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
  7373				BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
  7374				BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
  7375				BPF_ALU32_REG(BPF_MOV, R0, R3),
  7376				BPF_EXIT_INSN(),
  7377			},
  7378			INTERNAL,
  7379			{ },
  7380			{ { 0, 0x89abcdef } },
  7381			.stack_depth = 40,
  7382		},
  7383		/* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
  7384		{
  7385			"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
  7386			.u.insns_int = {
  7387				BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
  7388				BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
  7389				BPF_ALU64_REG(BPF_MOV, R0, R1),
  7390				BPF_STX_MEM(BPF_DW, R10, R1, -40),
  7391				BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
  7392				BPF_JMP_REG(BPF_JNE, R0, R1, 1),
  7393				BPF_ALU64_REG(BPF_SUB, R0, R1),
  7394				BPF_EXIT_INSN(),
  7395			},
  7396			INTERNAL,
  7397			{ },
  7398			{ { 0, 0 } },
  7399			.stack_depth = 40,
  7400		},
  7401		{
  7402			"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
  7403			.u.insns_int = {
  7404				BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
  7405				BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
  7406				BPF_ALU64_REG(BPF_MOV, R0, R1),
  7407				BPF_STX_MEM(BPF_DW, R10, R0, -40),
  7408				BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
  7409				BPF_LDX_MEM(BPF_DW, R0, R10, -40),
  7410				BPF_JMP_REG(BPF_JNE, R0, R2, 1),
  7411				BPF_ALU64_REG(BPF_SUB, R0, R2),
  7412				BPF_EXIT_INSN(),
  7413			},
  7414			INTERNAL,
  7415			{ },
  7416			{ { 0, 0 } },
  7417			.stack_depth = 40,
  7418		},
  7419		{
  7420			"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
  7421			.u.insns_int = {
  7422				BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
  7423				BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
  7424				BPF_ALU64_REG(BPF_MOV, R0, R1),
  7425				BPF_ALU64_IMM(BPF_ADD, R0, 1),
  7426				BPF_STX_MEM(BPF_DW, R10, R1, -40),
  7427				BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
  7428				BPF_JMP_REG(BPF_JNE, R0, R1, 1),
  7429				BPF_ALU64_REG(BPF_SUB, R0, R1),
  7430				BPF_EXIT_INSN(),
  7431			},
  7432			INTERNAL,
  7433			{ },
  7434			{ { 0, 0 } },
  7435			.stack_depth = 40,
  7436		},
  7437		{
  7438			"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
  7439			.u.insns_int = {
  7440				BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
  7441				BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
  7442				BPF_ALU64_REG(BPF_MOV, R0, R1),
  7443				BPF_ALU64_IMM(BPF_ADD, R0, 1),
  7444				BPF_STX_MEM(BPF_DW, R10, R1, -40),
  7445				BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
  7446				BPF_LDX_MEM(BPF_DW, R0, R10, -40),
  7447				BPF_JMP_REG(BPF_JNE, R0, R1, 1),
  7448				BPF_ALU64_REG(BPF_SUB, R0, R1),
  7449				BPF_EXIT_INSN(),
  7450			},
  7451			INTERNAL,
  7452			{ },
  7453			{ { 0, 0 } },
  7454			.stack_depth = 40,
  7455		},
  7456		{
  7457			"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
  7458			.u.insns_int = {
  7459				BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
  7460				BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
  7461				BPF_ALU64_REG(BPF_MOV, R0, R1),
  7462				BPF_STX_MEM(BPF_DW, R10, R1, -40),
  7463				BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
  7464				BPF_LD_IMM64(R0, 0xfecdba9876543210ULL),
  7465				BPF_JMP_REG(BPF_JNE, R0, R2, 1),
  7466				BPF_ALU64_REG(BPF_SUB, R0, R2),
  7467				BPF_EXIT_INSN(),
  7468			},
  7469			INTERNAL,
  7470			{ },
  7471			{ { 0, 0 } },
  7472			.stack_depth = 40,
  7473		},
  7474		/* BPF_JMP32 | BPF_JEQ | BPF_K */
  7475		{
  7476			"JMP32_JEQ_K: Small immediate",
  7477			.u.insns_int = {
  7478				BPF_ALU32_IMM(BPF_MOV, R0, 123),
  7479				BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
  7480				BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
  7481				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7482				BPF_EXIT_INSN(),
  7483			},
  7484			INTERNAL,
  7485			{ },
  7486			{ { 0, 123 } }
  7487		},
  7488		{
  7489			"JMP32_JEQ_K: Large immediate",
  7490			.u.insns_int = {
  7491				BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
  7492				BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
  7493				BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
  7494				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7495				BPF_EXIT_INSN(),
  7496			},
  7497			INTERNAL,
  7498			{ },
  7499			{ { 0, 12345678 } }
  7500		},
  7501		{
  7502			"JMP32_JEQ_K: negative immediate",
  7503			.u.insns_int = {
  7504				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  7505				BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
  7506				BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
  7507				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7508				BPF_EXIT_INSN(),
  7509			},
  7510			INTERNAL,
  7511			{ },
  7512			{ { 0, -123 } }
  7513		},
  7514		/* BPF_JMP32 | BPF_JEQ | BPF_X */
  7515		{
  7516			"JMP32_JEQ_X",
  7517			.u.insns_int = {
  7518				BPF_ALU32_IMM(BPF_MOV, R0, 1234),
  7519				BPF_ALU32_IMM(BPF_MOV, R1, 4321),
  7520				BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
  7521				BPF_ALU32_IMM(BPF_MOV, R1, 1234),
  7522				BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
  7523				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7524				BPF_EXIT_INSN(),
  7525			},
  7526			INTERNAL,
  7527			{ },
  7528			{ { 0, 1234 } }
  7529		},
  7530		/* BPF_JMP32 | BPF_JNE | BPF_K */
  7531		{
  7532			"JMP32_JNE_K: Small immediate",
  7533			.u.insns_int = {
  7534				BPF_ALU32_IMM(BPF_MOV, R0, 123),
  7535				BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
  7536				BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
  7537				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7538				BPF_EXIT_INSN(),
  7539			},
  7540			INTERNAL,
  7541			{ },
  7542			{ { 0, 123 } }
  7543		},
  7544		{
  7545			"JMP32_JNE_K: Large immediate",
  7546			.u.insns_int = {
  7547				BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
  7548				BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
  7549				BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
  7550				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7551				BPF_EXIT_INSN(),
  7552			},
  7553			INTERNAL,
  7554			{ },
  7555			{ { 0, 12345678 } }
  7556		},
  7557		{
  7558			"JMP32_JNE_K: negative immediate",
  7559			.u.insns_int = {
  7560				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  7561				BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
  7562				BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
  7563				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7564				BPF_EXIT_INSN(),
  7565			},
  7566			INTERNAL,
  7567			{ },
  7568			{ { 0, -123 } }
  7569		},
  7570		/* BPF_JMP32 | BPF_JNE | BPF_X */
  7571		{
  7572			"JMP32_JNE_X",
  7573			.u.insns_int = {
  7574				BPF_ALU32_IMM(BPF_MOV, R0, 1234),
  7575				BPF_ALU32_IMM(BPF_MOV, R1, 1234),
  7576				BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
  7577				BPF_ALU32_IMM(BPF_MOV, R1, 4321),
  7578				BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
  7579				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7580				BPF_EXIT_INSN(),
  7581			},
  7582			INTERNAL,
  7583			{ },
  7584			{ { 0, 1234 } }
  7585		},
  7586		/* BPF_JMP32 | BPF_JSET | BPF_K */
  7587		{
  7588			"JMP32_JSET_K: Small immediate",
  7589			.u.insns_int = {
  7590				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  7591				BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
  7592				BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
  7593				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7594				BPF_EXIT_INSN(),
  7595			},
  7596			INTERNAL,
  7597			{ },
  7598			{ { 0, 1 } }
  7599		},
  7600		{
  7601			"JMP32_JSET_K: Large immediate",
  7602			.u.insns_int = {
  7603				BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
  7604				BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
  7605				BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
  7606				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7607				BPF_EXIT_INSN(),
  7608			},
  7609			INTERNAL,
  7610			{ },
  7611			{ { 0, 0x40000000 } }
  7612		},
  7613		{
  7614			"JMP32_JSET_K: negative immediate",
  7615			.u.insns_int = {
  7616				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  7617				BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
  7618				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7619				BPF_EXIT_INSN(),
  7620			},
  7621			INTERNAL,
  7622			{ },
  7623			{ { 0, -123 } }
  7624		},
  7625		/* BPF_JMP32 | BPF_JSET | BPF_X */
  7626		{
  7627			"JMP32_JSET_X",
  7628			.u.insns_int = {
  7629				BPF_ALU32_IMM(BPF_MOV, R0, 8),
  7630				BPF_ALU32_IMM(BPF_MOV, R1, 7),
  7631				BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
  7632				BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
  7633				BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
  7634				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7635				BPF_EXIT_INSN(),
  7636			},
  7637			INTERNAL,
  7638			{ },
  7639			{ { 0, 8 } }
  7640		},
  7641		/* BPF_JMP32 | BPF_JGT | BPF_K */
  7642		{
  7643			"JMP32_JGT_K: Small immediate",
  7644			.u.insns_int = {
  7645				BPF_ALU32_IMM(BPF_MOV, R0, 123),
  7646				BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
  7647				BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
  7648				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7649				BPF_EXIT_INSN(),
  7650			},
  7651			INTERNAL,
  7652			{ },
  7653			{ { 0, 123 } }
  7654		},
  7655		{
  7656			"JMP32_JGT_K: Large immediate",
  7657			.u.insns_int = {
  7658				BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
  7659				BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
  7660				BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
  7661				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7662				BPF_EXIT_INSN(),
  7663			},
  7664			INTERNAL,
  7665			{ },
  7666			{ { 0, 0xfffffffe } }
  7667		},
  7668		/* BPF_JMP32 | BPF_JGT | BPF_X */
  7669		{
  7670			"JMP32_JGT_X",
  7671			.u.insns_int = {
  7672				BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
  7673				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  7674				BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
  7675				BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
  7676				BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
  7677				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7678				BPF_EXIT_INSN(),
  7679			},
  7680			INTERNAL,
  7681			{ },
  7682			{ { 0, 0xfffffffe } }
  7683		},
  7684		/* BPF_JMP32 | BPF_JGE | BPF_K */
  7685		{
  7686			"JMP32_JGE_K: Small immediate",
  7687			.u.insns_int = {
  7688				BPF_ALU32_IMM(BPF_MOV, R0, 123),
  7689				BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
  7690				BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
  7691				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7692				BPF_EXIT_INSN(),
  7693			},
  7694			INTERNAL,
  7695			{ },
  7696			{ { 0, 123 } }
  7697		},
  7698		{
  7699			"JMP32_JGE_K: Large immediate",
  7700			.u.insns_int = {
  7701				BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
  7702				BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
  7703				BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
  7704				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7705				BPF_EXIT_INSN(),
  7706			},
  7707			INTERNAL,
  7708			{ },
  7709			{ { 0, 0xfffffffe } }
  7710		},
  7711		/* BPF_JMP32 | BPF_JGE | BPF_X */
  7712		{
  7713			"JMP32_JGE_X",
  7714			.u.insns_int = {
  7715				BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
  7716				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  7717				BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
  7718				BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
  7719				BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
  7720				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7721				BPF_EXIT_INSN(),
  7722			},
  7723			INTERNAL,
  7724			{ },
  7725			{ { 0, 0xfffffffe } }
  7726		},
  7727		/* BPF_JMP32 | BPF_JLT | BPF_K */
  7728		{
  7729			"JMP32_JLT_K: Small immediate",
  7730			.u.insns_int = {
  7731				BPF_ALU32_IMM(BPF_MOV, R0, 123),
  7732				BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
  7733				BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
  7734				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7735				BPF_EXIT_INSN(),
  7736			},
  7737			INTERNAL,
  7738			{ },
  7739			{ { 0, 123 } }
  7740		},
  7741		{
  7742			"JMP32_JLT_K: Large immediate",
  7743			.u.insns_int = {
  7744				BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
  7745				BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
  7746				BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
  7747				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7748				BPF_EXIT_INSN(),
  7749			},
  7750			INTERNAL,
  7751			{ },
  7752			{ { 0, 0xfffffffe } }
  7753		},
  7754		/* BPF_JMP32 | BPF_JLT | BPF_X */
  7755		{
  7756			"JMP32_JLT_X",
  7757			.u.insns_int = {
  7758				BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
  7759				BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
  7760				BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
  7761				BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
  7762				BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
  7763				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7764				BPF_EXIT_INSN(),
  7765			},
  7766			INTERNAL,
  7767			{ },
  7768			{ { 0, 0xfffffffe } }
  7769		},
  7770		/* BPF_JMP32 | BPF_JLE | BPF_K */
  7771		{
  7772			"JMP32_JLE_K: Small immediate",
  7773			.u.insns_int = {
  7774				BPF_ALU32_IMM(BPF_MOV, R0, 123),
  7775				BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
  7776				BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
  7777				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7778				BPF_EXIT_INSN(),
  7779			},
  7780			INTERNAL,
  7781			{ },
  7782			{ { 0, 123 } }
  7783		},
  7784		{
  7785			"JMP32_JLE_K: Large immediate",
  7786			.u.insns_int = {
  7787				BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
  7788				BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
  7789				BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
  7790				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7791				BPF_EXIT_INSN(),
  7792			},
  7793			INTERNAL,
  7794			{ },
  7795			{ { 0, 0xfffffffe } }
  7796		},
  7797		/* BPF_JMP32 | BPF_JLE | BPF_X */
  7798		{
  7799			"JMP32_JLE_X",
  7800			.u.insns_int = {
  7801				BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
  7802				BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
  7803				BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
  7804				BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
  7805				BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
  7806				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7807				BPF_EXIT_INSN(),
  7808			},
  7809			INTERNAL,
  7810			{ },
  7811			{ { 0, 0xfffffffe } }
  7812		},
  7813		/* BPF_JMP32 | BPF_JSGT | BPF_K */
  7814		{
  7815			"JMP32_JSGT_K: Small immediate",
  7816			.u.insns_int = {
  7817				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  7818				BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
  7819				BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
  7820				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7821				BPF_EXIT_INSN(),
  7822			},
  7823			INTERNAL,
  7824			{ },
  7825			{ { 0, -123 } }
  7826		},
  7827		{
  7828			"JMP32_JSGT_K: Large immediate",
  7829			.u.insns_int = {
  7830				BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
  7831				BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
  7832				BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
  7833				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7834				BPF_EXIT_INSN(),
  7835			},
  7836			INTERNAL,
  7837			{ },
  7838			{ { 0, -12345678 } }
  7839		},
  7840		/* BPF_JMP32 | BPF_JSGT | BPF_X */
  7841		{
  7842			"JMP32_JSGT_X",
  7843			.u.insns_int = {
  7844				BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
  7845				BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
  7846				BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
  7847				BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
  7848				BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
  7849				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7850				BPF_EXIT_INSN(),
  7851			},
  7852			INTERNAL,
  7853			{ },
  7854			{ { 0, -12345678 } }
  7855		},
  7856		/* BPF_JMP32 | BPF_JSGE | BPF_K */
  7857		{
  7858			"JMP32_JSGE_K: Small immediate",
  7859			.u.insns_int = {
  7860				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  7861				BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
  7862				BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
  7863				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7864				BPF_EXIT_INSN(),
  7865			},
  7866			INTERNAL,
  7867			{ },
  7868			{ { 0, -123 } }
  7869		},
  7870		{
  7871			"JMP32_JSGE_K: Large immediate",
  7872			.u.insns_int = {
  7873				BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
  7874				BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
  7875				BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
  7876				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7877				BPF_EXIT_INSN(),
  7878			},
  7879			INTERNAL,
  7880			{ },
  7881			{ { 0, -12345678 } }
  7882		},
  7883		/* BPF_JMP32 | BPF_JSGE | BPF_X */
  7884		{
  7885			"JMP32_JSGE_X",
  7886			.u.insns_int = {
  7887				BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
  7888				BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
  7889				BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
  7890				BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
  7891				BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
  7892				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7893				BPF_EXIT_INSN(),
  7894			},
  7895			INTERNAL,
  7896			{ },
  7897			{ { 0, -12345678 } }
  7898		},
  7899		/* BPF_JMP32 | BPF_JSLT | BPF_K */
  7900		{
  7901			"JMP32_JSLT_K: Small immediate",
  7902			.u.insns_int = {
  7903				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  7904				BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
  7905				BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
  7906				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7907				BPF_EXIT_INSN(),
  7908			},
  7909			INTERNAL,
  7910			{ },
  7911			{ { 0, -123 } }
  7912		},
  7913		{
  7914			"JMP32_JSLT_K: Large immediate",
  7915			.u.insns_int = {
  7916				BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
  7917				BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
  7918				BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
  7919				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7920				BPF_EXIT_INSN(),
  7921			},
  7922			INTERNAL,
  7923			{ },
  7924			{ { 0, -12345678 } }
  7925		},
  7926		/* BPF_JMP32 | BPF_JSLT | BPF_X */
  7927		{
  7928			"JMP32_JSLT_X",
  7929			.u.insns_int = {
  7930				BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
  7931				BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
  7932				BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
  7933				BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
  7934				BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
  7935				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7936				BPF_EXIT_INSN(),
  7937			},
  7938			INTERNAL,
  7939			{ },
  7940			{ { 0, -12345678 } }
  7941		},
  7942		/* BPF_JMP32 | BPF_JSLE | BPF_K */
  7943		{
  7944			"JMP32_JSLE_K: Small immediate",
  7945			.u.insns_int = {
  7946				BPF_ALU32_IMM(BPF_MOV, R0, -123),
  7947				BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
  7948				BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
  7949				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7950				BPF_EXIT_INSN(),
  7951			},
  7952			INTERNAL,
  7953			{ },
  7954			{ { 0, -123 } }
  7955		},
  7956		{
  7957			"JMP32_JSLE_K: Large immediate",
  7958			.u.insns_int = {
  7959				BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
  7960				BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
  7961				BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
  7962				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7963				BPF_EXIT_INSN(),
  7964			},
  7965			INTERNAL,
  7966			{ },
  7967			{ { 0, -12345678 } }
  7968		},
  7969		/* BPF_JMP32 | BPF_JSLE | BPF_K */
  7970		{
  7971			"JMP32_JSLE_X",
  7972			.u.insns_int = {
  7973				BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
  7974				BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
  7975				BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
  7976				BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
  7977				BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
  7978				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  7979				BPF_EXIT_INSN(),
  7980			},
  7981			INTERNAL,
  7982			{ },
  7983			{ { 0, -12345678 } }
  7984		},
  7985		/* BPF_JMP | BPF_EXIT */
  7986		{
  7987			"JMP_EXIT",
  7988			.u.insns_int = {
  7989				BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
  7990				BPF_EXIT_INSN(),
  7991				BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
  7992			},
  7993			INTERNAL,
  7994			{ },
  7995			{ { 0, 0x4711 } },
  7996		},
  7997		/* BPF_JMP | BPF_JA */
  7998		{
  7999			"JMP_JA: Unconditional jump: if (true) return 1",
  8000			.u.insns_int = {
  8001				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8002				BPF_JMP_IMM(BPF_JA, 0, 0, 1),
  8003				BPF_EXIT_INSN(),
  8004				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8005				BPF_EXIT_INSN(),
  8006			},
  8007			INTERNAL,
  8008			{ },
  8009			{ { 0, 1 } },
  8010		},
  8011		/* BPF_JMP | BPF_JSLT | BPF_K */
  8012		{
  8013			"JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
  8014			.u.insns_int = {
  8015				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8016				BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
  8017				BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
  8018				BPF_EXIT_INSN(),
  8019				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8020				BPF_EXIT_INSN(),
  8021			},
  8022			INTERNAL,
  8023			{ },
  8024			{ { 0, 1 } },
  8025		},
  8026		{
  8027			"JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
  8028			.u.insns_int = {
  8029				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8030				BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
  8031				BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
  8032				BPF_EXIT_INSN(),
  8033				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8034				BPF_EXIT_INSN(),
  8035			},
  8036			INTERNAL,
  8037			{ },
  8038			{ { 0, 1 } },
  8039		},
  8040		/* BPF_JMP | BPF_JSGT | BPF_K */
  8041		{
  8042			"JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
  8043			.u.insns_int = {
  8044				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8045				BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
  8046				BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
  8047				BPF_EXIT_INSN(),
  8048				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8049				BPF_EXIT_INSN(),
  8050			},
  8051			INTERNAL,
  8052			{ },
  8053			{ { 0, 1 } },
  8054		},
  8055		{
  8056			"JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
  8057			.u.insns_int = {
  8058				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8059				BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
  8060				BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
  8061				BPF_EXIT_INSN(),
  8062				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8063				BPF_EXIT_INSN(),
  8064			},
  8065			INTERNAL,
  8066			{ },
  8067			{ { 0, 1 } },
  8068		},
  8069		/* BPF_JMP | BPF_JSLE | BPF_K */
  8070		{
  8071			"JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
  8072			.u.insns_int = {
  8073				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8074				BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
  8075				BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
  8076				BPF_EXIT_INSN(),
  8077				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8078				BPF_EXIT_INSN(),
  8079			},
  8080			INTERNAL,
  8081			{ },
  8082			{ { 0, 1 } },
  8083		},
  8084		{
  8085			"JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
  8086			.u.insns_int = {
  8087				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8088				BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
  8089				BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
  8090				BPF_EXIT_INSN(),
  8091				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8092				BPF_EXIT_INSN(),
  8093			},
  8094			INTERNAL,
  8095			{ },
  8096			{ { 0, 1 } },
  8097		},
  8098		{
  8099			"JMP_JSLE_K: Signed jump: value walk 1",
  8100			.u.insns_int = {
  8101				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8102				BPF_LD_IMM64(R1, 3),
  8103				BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
  8104				BPF_ALU64_IMM(BPF_SUB, R1, 1),
  8105				BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
  8106				BPF_ALU64_IMM(BPF_SUB, R1, 1),
  8107				BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
  8108				BPF_ALU64_IMM(BPF_SUB, R1, 1),
  8109				BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
  8110				BPF_EXIT_INSN(),		/* bad exit */
  8111				BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
  8112				BPF_EXIT_INSN(),
  8113			},
  8114			INTERNAL,
  8115			{ },
  8116			{ { 0, 1 } },
  8117		},
  8118		{
  8119			"JMP_JSLE_K: Signed jump: value walk 2",
  8120			.u.insns_int = {
  8121				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8122				BPF_LD_IMM64(R1, 3),
  8123				BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
  8124				BPF_ALU64_IMM(BPF_SUB, R1, 2),
  8125				BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
  8126				BPF_ALU64_IMM(BPF_SUB, R1, 2),
  8127				BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
  8128				BPF_EXIT_INSN(),		/* bad exit */
  8129				BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
  8130				BPF_EXIT_INSN(),
  8131			},
  8132			INTERNAL,
  8133			{ },
  8134			{ { 0, 1 } },
  8135		},
  8136		/* BPF_JMP | BPF_JSGE | BPF_K */
  8137		{
  8138			"JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
  8139			.u.insns_int = {
  8140				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8141				BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
  8142				BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
  8143				BPF_EXIT_INSN(),
  8144				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8145				BPF_EXIT_INSN(),
  8146			},
  8147			INTERNAL,
  8148			{ },
  8149			{ { 0, 1 } },
  8150		},
  8151		{
  8152			"JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
  8153			.u.insns_int = {
  8154				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8155				BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
  8156				BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
  8157				BPF_EXIT_INSN(),
  8158				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8159				BPF_EXIT_INSN(),
  8160			},
  8161			INTERNAL,
  8162			{ },
  8163			{ { 0, 1 } },
  8164		},
  8165		{
  8166			"JMP_JSGE_K: Signed jump: value walk 1",
  8167			.u.insns_int = {
  8168				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8169				BPF_LD_IMM64(R1, -3),
  8170				BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
  8171				BPF_ALU64_IMM(BPF_ADD, R1, 1),
  8172				BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
  8173				BPF_ALU64_IMM(BPF_ADD, R1, 1),
  8174				BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
  8175				BPF_ALU64_IMM(BPF_ADD, R1, 1),
  8176				BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
  8177				BPF_EXIT_INSN(),		/* bad exit */
  8178				BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
  8179				BPF_EXIT_INSN(),
  8180			},
  8181			INTERNAL,
  8182			{ },
  8183			{ { 0, 1 } },
  8184		},
  8185		{
  8186			"JMP_JSGE_K: Signed jump: value walk 2",
  8187			.u.insns_int = {
  8188				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8189				BPF_LD_IMM64(R1, -3),
  8190				BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
  8191				BPF_ALU64_IMM(BPF_ADD, R1, 2),
  8192				BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
  8193				BPF_ALU64_IMM(BPF_ADD, R1, 2),
  8194				BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
  8195				BPF_EXIT_INSN(),		/* bad exit */
  8196				BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
  8197				BPF_EXIT_INSN(),
  8198			},
  8199			INTERNAL,
  8200			{ },
  8201			{ { 0, 1 } },
  8202		},
  8203		/* BPF_JMP | BPF_JGT | BPF_K */
  8204		{
  8205			"JMP_JGT_K: if (3 > 2) return 1",
  8206			.u.insns_int = {
  8207				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8208				BPF_LD_IMM64(R1, 3),
  8209				BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
  8210				BPF_EXIT_INSN(),
  8211				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8212				BPF_EXIT_INSN(),
  8213			},
  8214			INTERNAL,
  8215			{ },
  8216			{ { 0, 1 } },
  8217		},
  8218		{
  8219			"JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
  8220			.u.insns_int = {
  8221				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8222				BPF_LD_IMM64(R1, -1),
  8223				BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
  8224				BPF_EXIT_INSN(),
  8225				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8226				BPF_EXIT_INSN(),
  8227			},
  8228			INTERNAL,
  8229			{ },
  8230			{ { 0, 1 } },
  8231		},
  8232		/* BPF_JMP | BPF_JLT | BPF_K */
  8233		{
  8234			"JMP_JLT_K: if (2 < 3) return 1",
  8235			.u.insns_int = {
  8236				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8237				BPF_LD_IMM64(R1, 2),
  8238				BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
  8239				BPF_EXIT_INSN(),
  8240				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8241				BPF_EXIT_INSN(),
  8242			},
  8243			INTERNAL,
  8244			{ },
  8245			{ { 0, 1 } },
  8246		},
  8247		{
  8248			"JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
  8249			.u.insns_int = {
  8250				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8251				BPF_LD_IMM64(R1, 1),
  8252				BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
  8253				BPF_EXIT_INSN(),
  8254				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8255				BPF_EXIT_INSN(),
  8256			},
  8257			INTERNAL,
  8258			{ },
  8259			{ { 0, 1 } },
  8260		},
  8261		/* BPF_JMP | BPF_JGE | BPF_K */
  8262		{
  8263			"JMP_JGE_K: if (3 >= 2) return 1",
  8264			.u.insns_int = {
  8265				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8266				BPF_LD_IMM64(R1, 3),
  8267				BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
  8268				BPF_EXIT_INSN(),
  8269				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8270				BPF_EXIT_INSN(),
  8271			},
  8272			INTERNAL,
  8273			{ },
  8274			{ { 0, 1 } },
  8275		},
  8276		/* BPF_JMP | BPF_JLE | BPF_K */
  8277		{
  8278			"JMP_JLE_K: if (2 <= 3) return 1",
  8279			.u.insns_int = {
  8280				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8281				BPF_LD_IMM64(R1, 2),
  8282				BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
  8283				BPF_EXIT_INSN(),
  8284				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8285				BPF_EXIT_INSN(),
  8286			},
  8287			INTERNAL,
  8288			{ },
  8289			{ { 0, 1 } },
  8290		},
  8291		/* BPF_JMP | BPF_JGT | BPF_K jump backwards */
  8292		{
  8293			"JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
  8294			.u.insns_int = {
  8295				BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
  8296				BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
  8297				BPF_EXIT_INSN(),
  8298				BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
  8299				BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
  8300				BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
  8301				BPF_EXIT_INSN(),
  8302			},
  8303			INTERNAL,
  8304			{ },
  8305			{ { 0, 1 } },
  8306		},
  8307		{
  8308			"JMP_JGE_K: if (3 >= 3) return 1",
  8309			.u.insns_int = {
  8310				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8311				BPF_LD_IMM64(R1, 3),
  8312				BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
  8313				BPF_EXIT_INSN(),
  8314				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8315				BPF_EXIT_INSN(),
  8316			},
  8317			INTERNAL,
  8318			{ },
  8319			{ { 0, 1 } },
  8320		},
  8321		/* BPF_JMP | BPF_JLT | BPF_K jump backwards */
  8322		{
  8323			"JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
  8324			.u.insns_int = {
  8325				BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
  8326				BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
  8327				BPF_EXIT_INSN(),
  8328				BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
  8329				BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
  8330				BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
  8331				BPF_EXIT_INSN(),
  8332			},
  8333			INTERNAL,
  8334			{ },
  8335			{ { 0, 1 } },
  8336		},
  8337		{
  8338			"JMP_JLE_K: if (3 <= 3) return 1",
  8339			.u.insns_int = {
  8340				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8341				BPF_LD_IMM64(R1, 3),
  8342				BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
  8343				BPF_EXIT_INSN(),
  8344				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8345				BPF_EXIT_INSN(),
  8346			},
  8347			INTERNAL,
  8348			{ },
  8349			{ { 0, 1 } },
  8350		},
  8351		/* BPF_JMP | BPF_JNE | BPF_K */
  8352		{
  8353			"JMP_JNE_K: if (3 != 2) return 1",
  8354			.u.insns_int = {
  8355				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8356				BPF_LD_IMM64(R1, 3),
  8357				BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
  8358				BPF_EXIT_INSN(),
  8359				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8360				BPF_EXIT_INSN(),
  8361			},
  8362			INTERNAL,
  8363			{ },
  8364			{ { 0, 1 } },
  8365		},
  8366		/* BPF_JMP | BPF_JEQ | BPF_K */
  8367		{
  8368			"JMP_JEQ_K: if (3 == 3) return 1",
  8369			.u.insns_int = {
  8370				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8371				BPF_LD_IMM64(R1, 3),
  8372				BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
  8373				BPF_EXIT_INSN(),
  8374				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8375				BPF_EXIT_INSN(),
  8376			},
  8377			INTERNAL,
  8378			{ },
  8379			{ { 0, 1 } },
  8380		},
  8381		/* BPF_JMP | BPF_JSET | BPF_K */
  8382		{
  8383			"JMP_JSET_K: if (0x3 & 0x2) return 1",
  8384			.u.insns_int = {
  8385				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8386				BPF_LD_IMM64(R1, 3),
  8387				BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
  8388				BPF_EXIT_INSN(),
  8389				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8390				BPF_EXIT_INSN(),
  8391			},
  8392			INTERNAL,
  8393			{ },
  8394			{ { 0, 1 } },
  8395		},
  8396		{
  8397			"JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
  8398			.u.insns_int = {
  8399				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8400				BPF_LD_IMM64(R1, 3),
  8401				BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
  8402				BPF_EXIT_INSN(),
  8403				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8404				BPF_EXIT_INSN(),
  8405			},
  8406			INTERNAL,
  8407			{ },
  8408			{ { 0, 1 } },
  8409		},
  8410		/* BPF_JMP | BPF_JSGT | BPF_X */
  8411		{
  8412			"JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
  8413			.u.insns_int = {
  8414				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8415				BPF_LD_IMM64(R1, -1),
  8416				BPF_LD_IMM64(R2, -2),
  8417				BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
  8418				BPF_EXIT_INSN(),
  8419				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8420				BPF_EXIT_INSN(),
  8421			},
  8422			INTERNAL,
  8423			{ },
  8424			{ { 0, 1 } },
  8425		},
  8426		{
  8427			"JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
  8428			.u.insns_int = {
  8429				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8430				BPF_LD_IMM64(R1, -1),
  8431				BPF_LD_IMM64(R2, -1),
  8432				BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
  8433				BPF_EXIT_INSN(),
  8434				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8435				BPF_EXIT_INSN(),
  8436			},
  8437			INTERNAL,
  8438			{ },
  8439			{ { 0, 1 } },
  8440		},
  8441		/* BPF_JMP | BPF_JSLT | BPF_X */
  8442		{
  8443			"JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
  8444			.u.insns_int = {
  8445				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8446				BPF_LD_IMM64(R1, -1),
  8447				BPF_LD_IMM64(R2, -2),
  8448				BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
  8449				BPF_EXIT_INSN(),
  8450				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8451				BPF_EXIT_INSN(),
  8452			},
  8453			INTERNAL,
  8454			{ },
  8455			{ { 0, 1 } },
  8456		},
  8457		{
  8458			"JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
  8459			.u.insns_int = {
  8460				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8461				BPF_LD_IMM64(R1, -1),
  8462				BPF_LD_IMM64(R2, -1),
  8463				BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
  8464				BPF_EXIT_INSN(),
  8465				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8466				BPF_EXIT_INSN(),
  8467			},
  8468			INTERNAL,
  8469			{ },
  8470			{ { 0, 1 } },
  8471		},
  8472		/* BPF_JMP | BPF_JSGE | BPF_X */
  8473		{
  8474			"JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
  8475			.u.insns_int = {
  8476				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8477				BPF_LD_IMM64(R1, -1),
  8478				BPF_LD_IMM64(R2, -2),
  8479				BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
  8480				BPF_EXIT_INSN(),
  8481				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8482				BPF_EXIT_INSN(),
  8483			},
  8484			INTERNAL,
  8485			{ },
  8486			{ { 0, 1 } },
  8487		},
  8488		{
  8489			"JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
  8490			.u.insns_int = {
  8491				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8492				BPF_LD_IMM64(R1, -1),
  8493				BPF_LD_IMM64(R2, -1),
  8494				BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
  8495				BPF_EXIT_INSN(),
  8496				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8497				BPF_EXIT_INSN(),
  8498			},
  8499			INTERNAL,
  8500			{ },
  8501			{ { 0, 1 } },
  8502		},
  8503		/* BPF_JMP | BPF_JSLE | BPF_X */
  8504		{
  8505			"JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
  8506			.u.insns_int = {
  8507				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8508				BPF_LD_IMM64(R1, -1),
  8509				BPF_LD_IMM64(R2, -2),
  8510				BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
  8511				BPF_EXIT_INSN(),
  8512				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8513				BPF_EXIT_INSN(),
  8514			},
  8515			INTERNAL,
  8516			{ },
  8517			{ { 0, 1 } },
  8518		},
  8519		{
  8520			"JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
  8521			.u.insns_int = {
  8522				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8523				BPF_LD_IMM64(R1, -1),
  8524				BPF_LD_IMM64(R2, -1),
  8525				BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
  8526				BPF_EXIT_INSN(),
  8527				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8528				BPF_EXIT_INSN(),
  8529			},
  8530			INTERNAL,
  8531			{ },
  8532			{ { 0, 1 } },
  8533		},
  8534		/* BPF_JMP | BPF_JGT | BPF_X */
  8535		{
  8536			"JMP_JGT_X: if (3 > 2) return 1",
  8537			.u.insns_int = {
  8538				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8539				BPF_LD_IMM64(R1, 3),
  8540				BPF_LD_IMM64(R2, 2),
  8541				BPF_JMP_REG(BPF_JGT, R1, R2, 1),
  8542				BPF_EXIT_INSN(),
  8543				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8544				BPF_EXIT_INSN(),
  8545			},
  8546			INTERNAL,
  8547			{ },
  8548			{ { 0, 1 } },
  8549		},
  8550		{
  8551			"JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
  8552			.u.insns_int = {
  8553				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8554				BPF_LD_IMM64(R1, -1),
  8555				BPF_LD_IMM64(R2, 1),
  8556				BPF_JMP_REG(BPF_JGT, R1, R2, 1),
  8557				BPF_EXIT_INSN(),
  8558				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8559				BPF_EXIT_INSN(),
  8560			},
  8561			INTERNAL,
  8562			{ },
  8563			{ { 0, 1 } },
  8564		},
  8565		/* BPF_JMP | BPF_JLT | BPF_X */
  8566		{
  8567			"JMP_JLT_X: if (2 < 3) return 1",
  8568			.u.insns_int = {
  8569				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8570				BPF_LD_IMM64(R1, 3),
  8571				BPF_LD_IMM64(R2, 2),
  8572				BPF_JMP_REG(BPF_JLT, R2, R1, 1),
  8573				BPF_EXIT_INSN(),
  8574				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8575				BPF_EXIT_INSN(),
  8576			},
  8577			INTERNAL,
  8578			{ },
  8579			{ { 0, 1 } },
  8580		},
  8581		{
  8582			"JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
  8583			.u.insns_int = {
  8584				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8585				BPF_LD_IMM64(R1, -1),
  8586				BPF_LD_IMM64(R2, 1),
  8587				BPF_JMP_REG(BPF_JLT, R2, R1, 1),
  8588				BPF_EXIT_INSN(),
  8589				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8590				BPF_EXIT_INSN(),
  8591			},
  8592			INTERNAL,
  8593			{ },
  8594			{ { 0, 1 } },
  8595		},
  8596		/* BPF_JMP | BPF_JGE | BPF_X */
  8597		{
  8598			"JMP_JGE_X: if (3 >= 2) return 1",
  8599			.u.insns_int = {
  8600				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8601				BPF_LD_IMM64(R1, 3),
  8602				BPF_LD_IMM64(R2, 2),
  8603				BPF_JMP_REG(BPF_JGE, R1, R2, 1),
  8604				BPF_EXIT_INSN(),
  8605				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8606				BPF_EXIT_INSN(),
  8607			},
  8608			INTERNAL,
  8609			{ },
  8610			{ { 0, 1 } },
  8611		},
  8612		{
  8613			"JMP_JGE_X: if (3 >= 3) return 1",
  8614			.u.insns_int = {
  8615				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8616				BPF_LD_IMM64(R1, 3),
  8617				BPF_LD_IMM64(R2, 3),
  8618				BPF_JMP_REG(BPF_JGE, R1, R2, 1),
  8619				BPF_EXIT_INSN(),
  8620				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8621				BPF_EXIT_INSN(),
  8622			},
  8623			INTERNAL,
  8624			{ },
  8625			{ { 0, 1 } },
  8626		},
  8627		/* BPF_JMP | BPF_JLE | BPF_X */
  8628		{
  8629			"JMP_JLE_X: if (2 <= 3) return 1",
  8630			.u.insns_int = {
  8631				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8632				BPF_LD_IMM64(R1, 3),
  8633				BPF_LD_IMM64(R2, 2),
  8634				BPF_JMP_REG(BPF_JLE, R2, R1, 1),
  8635				BPF_EXIT_INSN(),
  8636				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8637				BPF_EXIT_INSN(),
  8638			},
  8639			INTERNAL,
  8640			{ },
  8641			{ { 0, 1 } },
  8642		},
  8643		{
  8644			"JMP_JLE_X: if (3 <= 3) return 1",
  8645			.u.insns_int = {
  8646				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8647				BPF_LD_IMM64(R1, 3),
  8648				BPF_LD_IMM64(R2, 3),
  8649				BPF_JMP_REG(BPF_JLE, R1, R2, 1),
  8650				BPF_EXIT_INSN(),
  8651				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8652				BPF_EXIT_INSN(),
  8653			},
  8654			INTERNAL,
  8655			{ },
  8656			{ { 0, 1 } },
  8657		},
  8658		{
  8659			/* Mainly testing JIT + imm64 here. */
  8660			"JMP_JGE_X: ldimm64 test 1",
  8661			.u.insns_int = {
  8662				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8663				BPF_LD_IMM64(R1, 3),
  8664				BPF_LD_IMM64(R2, 2),
  8665				BPF_JMP_REG(BPF_JGE, R1, R2, 2),
  8666				BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
  8667				BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
  8668				BPF_EXIT_INSN(),
  8669			},
  8670			INTERNAL,
  8671			{ },
  8672			{ { 0, 0xeeeeeeeeU } },
  8673		},
  8674		{
  8675			"JMP_JGE_X: ldimm64 test 2",
  8676			.u.insns_int = {
  8677				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8678				BPF_LD_IMM64(R1, 3),
  8679				BPF_LD_IMM64(R2, 2),
  8680				BPF_JMP_REG(BPF_JGE, R1, R2, 0),
  8681				BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
  8682				BPF_EXIT_INSN(),
  8683			},
  8684			INTERNAL,
  8685			{ },
  8686			{ { 0, 0xffffffffU } },
  8687		},
  8688		{
  8689			"JMP_JGE_X: ldimm64 test 3",
  8690			.u.insns_int = {
  8691				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8692				BPF_LD_IMM64(R1, 3),
  8693				BPF_LD_IMM64(R2, 2),
  8694				BPF_JMP_REG(BPF_JGE, R1, R2, 4),
  8695				BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
  8696				BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
  8697				BPF_EXIT_INSN(),
  8698			},
  8699			INTERNAL,
  8700			{ },
  8701			{ { 0, 1 } },
  8702		},
  8703		{
  8704			"JMP_JLE_X: ldimm64 test 1",
  8705			.u.insns_int = {
  8706				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8707				BPF_LD_IMM64(R1, 3),
  8708				BPF_LD_IMM64(R2, 2),
  8709				BPF_JMP_REG(BPF_JLE, R2, R1, 2),
  8710				BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
  8711				BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
  8712				BPF_EXIT_INSN(),
  8713			},
  8714			INTERNAL,
  8715			{ },
  8716			{ { 0, 0xeeeeeeeeU } },
  8717		},
  8718		{
  8719			"JMP_JLE_X: ldimm64 test 2",
  8720			.u.insns_int = {
  8721				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8722				BPF_LD_IMM64(R1, 3),
  8723				BPF_LD_IMM64(R2, 2),
  8724				BPF_JMP_REG(BPF_JLE, R2, R1, 0),
  8725				BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
  8726				BPF_EXIT_INSN(),
  8727			},
  8728			INTERNAL,
  8729			{ },
  8730			{ { 0, 0xffffffffU } },
  8731		},
  8732		{
  8733			"JMP_JLE_X: ldimm64 test 3",
  8734			.u.insns_int = {
  8735				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8736				BPF_LD_IMM64(R1, 3),
  8737				BPF_LD_IMM64(R2, 2),
  8738				BPF_JMP_REG(BPF_JLE, R2, R1, 4),
  8739				BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
  8740				BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
  8741				BPF_EXIT_INSN(),
  8742			},
  8743			INTERNAL,
  8744			{ },
  8745			{ { 0, 1 } },
  8746		},
  8747		/* BPF_JMP | BPF_JNE | BPF_X */
  8748		{
  8749			"JMP_JNE_X: if (3 != 2) return 1",
  8750			.u.insns_int = {
  8751				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8752				BPF_LD_IMM64(R1, 3),
  8753				BPF_LD_IMM64(R2, 2),
  8754				BPF_JMP_REG(BPF_JNE, R1, R2, 1),
  8755				BPF_EXIT_INSN(),
  8756				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8757				BPF_EXIT_INSN(),
  8758			},
  8759			INTERNAL,
  8760			{ },
  8761			{ { 0, 1 } },
  8762		},
  8763		/* BPF_JMP | BPF_JEQ | BPF_X */
  8764		{
  8765			"JMP_JEQ_X: if (3 == 3) return 1",
  8766			.u.insns_int = {
  8767				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8768				BPF_LD_IMM64(R1, 3),
  8769				BPF_LD_IMM64(R2, 3),
  8770				BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
  8771				BPF_EXIT_INSN(),
  8772				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8773				BPF_EXIT_INSN(),
  8774			},
  8775			INTERNAL,
  8776			{ },
  8777			{ { 0, 1 } },
  8778		},
  8779		/* BPF_JMP | BPF_JSET | BPF_X */
  8780		{
  8781			"JMP_JSET_X: if (0x3 & 0x2) return 1",
  8782			.u.insns_int = {
  8783				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8784				BPF_LD_IMM64(R1, 3),
  8785				BPF_LD_IMM64(R2, 2),
  8786				BPF_JMP_REG(BPF_JSET, R1, R2, 1),
  8787				BPF_EXIT_INSN(),
  8788				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8789				BPF_EXIT_INSN(),
  8790			},
  8791			INTERNAL,
  8792			{ },
  8793			{ { 0, 1 } },
  8794		},
  8795		{
  8796			"JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
  8797			.u.insns_int = {
  8798				BPF_ALU32_IMM(BPF_MOV, R0, 0),
  8799				BPF_LD_IMM64(R1, 3),
  8800				BPF_LD_IMM64(R2, 0xffffffff),
  8801				BPF_JMP_REG(BPF_JSET, R1, R2, 1),
  8802				BPF_EXIT_INSN(),
  8803				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  8804				BPF_EXIT_INSN(),
  8805			},
  8806			INTERNAL,
  8807			{ },
  8808			{ { 0, 1 } },
  8809		},
  8810		{
  8811			"JMP_JA: Jump, gap, jump, ...",
  8812			{ },
  8813			CLASSIC | FLAG_NO_DATA,
  8814			{ },
  8815			{ { 0, 0xababcbac } },
  8816			.fill_helper = bpf_fill_ja,
  8817		},
  8818		{	/* Mainly checking JIT here. */
  8819			"BPF_MAXINSNS: Maximum possible literals",
  8820			{ },
  8821			CLASSIC | FLAG_NO_DATA,
  8822			{ },
  8823			{ { 0, 0xffffffff } },
  8824			.fill_helper = bpf_fill_maxinsns1,
  8825		},
  8826		{	/* Mainly checking JIT here. */
  8827			"BPF_MAXINSNS: Single literal",
  8828			{ },
  8829			CLASSIC | FLAG_NO_DATA,
  8830			{ },
  8831			{ { 0, 0xfefefefe } },
  8832			.fill_helper = bpf_fill_maxinsns2,
  8833		},
  8834		{	/* Mainly checking JIT here. */
  8835			"BPF_MAXINSNS: Run/add until end",
  8836			{ },
  8837			CLASSIC | FLAG_NO_DATA,
  8838			{ },
  8839			{ { 0, 0x947bf368 } },
  8840			.fill_helper = bpf_fill_maxinsns3,
  8841		},
  8842		{
  8843			"BPF_MAXINSNS: Too many instructions",
  8844			{ },
  8845			CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
  8846			{ },
  8847			{ },
  8848			.fill_helper = bpf_fill_maxinsns4,
  8849			.expected_errcode = -EINVAL,
  8850		},
  8851		{	/* Mainly checking JIT here. */
  8852			"BPF_MAXINSNS: Very long jump",
  8853			{ },
  8854			CLASSIC | FLAG_NO_DATA,
  8855			{ },
  8856			{ { 0, 0xabababab } },
  8857			.fill_helper = bpf_fill_maxinsns5,
  8858		},
  8859		{	/* Mainly checking JIT here. */
  8860			"BPF_MAXINSNS: Ctx heavy transformations",
  8861			{ },
  8862			CLASSIC,
  8863			{ },
  8864			{
  8865				{  1, SKB_VLAN_PRESENT },
  8866				{ 10, SKB_VLAN_PRESENT }
  8867			},
  8868			.fill_helper = bpf_fill_maxinsns6,
  8869		},
  8870		{	/* Mainly checking JIT here. */
  8871			"BPF_MAXINSNS: Call heavy transformations",
  8872			{ },
  8873			CLASSIC | FLAG_NO_DATA,
  8874			{ },
  8875			{ { 1, 0 }, { 10, 0 } },
  8876			.fill_helper = bpf_fill_maxinsns7,
  8877		},
  8878		{	/* Mainly checking JIT here. */
  8879			"BPF_MAXINSNS: Jump heavy test",
  8880			{ },
  8881			CLASSIC | FLAG_NO_DATA,
  8882			{ },
  8883			{ { 0, 0xffffffff } },
  8884			.fill_helper = bpf_fill_maxinsns8,
  8885		},
  8886		{	/* Mainly checking JIT here. */
  8887			"BPF_MAXINSNS: Very long jump backwards",
  8888			{ },
  8889			INTERNAL | FLAG_NO_DATA,
  8890			{ },
  8891			{ { 0, 0xcbababab } },
  8892			.fill_helper = bpf_fill_maxinsns9,
  8893		},
  8894		{	/* Mainly checking JIT here. */
  8895			"BPF_MAXINSNS: Edge hopping nuthouse",
  8896			{ },
  8897			INTERNAL | FLAG_NO_DATA,
  8898			{ },
  8899			{ { 0, 0xabababac } },
  8900			.fill_helper = bpf_fill_maxinsns10,
  8901		},
  8902		{
  8903			"BPF_MAXINSNS: Jump, gap, jump, ...",
  8904			{ },
  8905			CLASSIC | FLAG_NO_DATA,
  8906			{ },
  8907			{ { 0, 0xababcbac } },
  8908			.fill_helper = bpf_fill_maxinsns11,
  8909		},
  8910		{
  8911			"BPF_MAXINSNS: jump over MSH",
  8912			{ },
  8913			CLASSIC | FLAG_EXPECTED_FAIL,
  8914			{ 0xfa, 0xfb, 0xfc, 0xfd, },
  8915			{ { 4, 0xabababab } },
  8916			.fill_helper = bpf_fill_maxinsns12,
  8917			.expected_errcode = -EINVAL,
  8918		},
  8919		{
  8920			"BPF_MAXINSNS: exec all MSH",
  8921			{ },
  8922			CLASSIC,
  8923			{ 0xfa, 0xfb, 0xfc, 0xfd, },
  8924			{ { 4, 0xababab83 } },
  8925			.fill_helper = bpf_fill_maxinsns13,
  8926		},
  8927		{
  8928			"BPF_MAXINSNS: ld_abs+get_processor_id",
  8929			{ },
  8930			CLASSIC,
  8931			{ },
  8932			{ { 1, 0xbee } },
  8933			.fill_helper = bpf_fill_ld_abs_get_processor_id,
  8934		},
  8935		/*
  8936		 * LD_IND / LD_ABS on fragmented SKBs
  8937		 */
  8938		{
  8939			"LD_IND byte frag",
  8940			.u.insns = {
  8941				BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
  8942				BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
  8943				BPF_STMT(BPF_RET | BPF_A, 0x0),
  8944			},
  8945			CLASSIC | FLAG_SKB_FRAG,
  8946			{ },
  8947			{ {0x40, 0x42} },
  8948			.frag_data = {
  8949				0x42, 0x00, 0x00, 0x00,
  8950				0x43, 0x44, 0x00, 0x00,
  8951				0x21, 0x07, 0x19, 0x83,
  8952			},
  8953		},
  8954		{
  8955			"LD_IND halfword frag",
  8956			.u.insns = {
  8957				BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
  8958				BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
  8959				BPF_STMT(BPF_RET | BPF_A, 0x0),
  8960			},
  8961			CLASSIC | FLAG_SKB_FRAG,
  8962			{ },
  8963			{ {0x40, 0x4344} },
  8964			.frag_data = {
  8965				0x42, 0x00, 0x00, 0x00,
  8966				0x43, 0x44, 0x00, 0x00,
  8967				0x21, 0x07, 0x19, 0x83,
  8968			},
  8969		},
  8970		{
  8971			"LD_IND word frag",
  8972			.u.insns = {
  8973				BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
  8974				BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
  8975				BPF_STMT(BPF_RET | BPF_A, 0x0),
  8976			},
  8977			CLASSIC | FLAG_SKB_FRAG,
  8978			{ },
  8979			{ {0x40, 0x21071983} },
  8980			.frag_data = {
  8981				0x42, 0x00, 0x00, 0x00,
  8982				0x43, 0x44, 0x00, 0x00,
  8983				0x21, 0x07, 0x19, 0x83,
  8984			},
  8985		},
  8986		{
  8987			"LD_IND halfword mixed head/frag",
  8988			.u.insns = {
  8989				BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
  8990				BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
  8991				BPF_STMT(BPF_RET | BPF_A, 0x0),
  8992			},
  8993			CLASSIC | FLAG_SKB_FRAG,
  8994			{ [0x3e] = 0x25, [0x3f] = 0x05, },
  8995			{ {0x40, 0x0519} },
  8996			.frag_data = { 0x19, 0x82 },
  8997		},
  8998		{
  8999			"LD_IND word mixed head/frag",
  9000			.u.insns = {
  9001				BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
  9002				BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
  9003				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9004			},
  9005			CLASSIC | FLAG_SKB_FRAG,
  9006			{ [0x3e] = 0x25, [0x3f] = 0x05, },
  9007			{ {0x40, 0x25051982} },
  9008			.frag_data = { 0x19, 0x82 },
  9009		},
  9010		{
  9011			"LD_ABS byte frag",
  9012			.u.insns = {
  9013				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
  9014				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9015			},
  9016			CLASSIC | FLAG_SKB_FRAG,
  9017			{ },
  9018			{ {0x40, 0x42} },
  9019			.frag_data = {
  9020				0x42, 0x00, 0x00, 0x00,
  9021				0x43, 0x44, 0x00, 0x00,
  9022				0x21, 0x07, 0x19, 0x83,
  9023			},
  9024		},
  9025		{
  9026			"LD_ABS halfword frag",
  9027			.u.insns = {
  9028				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
  9029				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9030			},
  9031			CLASSIC | FLAG_SKB_FRAG,
  9032			{ },
  9033			{ {0x40, 0x4344} },
  9034			.frag_data = {
  9035				0x42, 0x00, 0x00, 0x00,
  9036				0x43, 0x44, 0x00, 0x00,
  9037				0x21, 0x07, 0x19, 0x83,
  9038			},
  9039		},
  9040		{
  9041			"LD_ABS word frag",
  9042			.u.insns = {
  9043				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
  9044				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9045			},
  9046			CLASSIC | FLAG_SKB_FRAG,
  9047			{ },
  9048			{ {0x40, 0x21071983} },
  9049			.frag_data = {
  9050				0x42, 0x00, 0x00, 0x00,
  9051				0x43, 0x44, 0x00, 0x00,
  9052				0x21, 0x07, 0x19, 0x83,
  9053			},
  9054		},
  9055		{
  9056			"LD_ABS halfword mixed head/frag",
  9057			.u.insns = {
  9058				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
  9059				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9060			},
  9061			CLASSIC | FLAG_SKB_FRAG,
  9062			{ [0x3e] = 0x25, [0x3f] = 0x05, },
  9063			{ {0x40, 0x0519} },
  9064			.frag_data = { 0x19, 0x82 },
  9065		},
  9066		{
  9067			"LD_ABS word mixed head/frag",
  9068			.u.insns = {
  9069				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
  9070				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9071			},
  9072			CLASSIC | FLAG_SKB_FRAG,
  9073			{ [0x3e] = 0x25, [0x3f] = 0x05, },
  9074			{ {0x40, 0x25051982} },
  9075			.frag_data = { 0x19, 0x82 },
  9076		},
  9077		/*
  9078		 * LD_IND / LD_ABS on non fragmented SKBs
  9079		 */
  9080		{
  9081			/*
  9082			 * this tests that the JIT/interpreter correctly resets X
  9083			 * before using it in an LD_IND instruction.
  9084			 */
  9085			"LD_IND byte default X",
  9086			.u.insns = {
  9087				BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
  9088				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9089			},
  9090			CLASSIC,
  9091			{ [0x1] = 0x42 },
  9092			{ {0x40, 0x42 } },
  9093		},
  9094		{
  9095			"LD_IND byte positive offset",
  9096			.u.insns = {
  9097				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9098				BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
  9099				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9100			},
  9101			CLASSIC,
  9102			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9103			{ {0x40, 0x82 } },
  9104		},
  9105		{
  9106			"LD_IND byte negative offset",
  9107			.u.insns = {
  9108				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9109				BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
  9110				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9111			},
  9112			CLASSIC,
  9113			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9114			{ {0x40, 0x05 } },
  9115		},
  9116		{
  9117			"LD_IND byte positive offset, all ff",
  9118			.u.insns = {
  9119				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9120				BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
  9121				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9122			},
  9123			CLASSIC,
  9124			{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
  9125			{ {0x40, 0xff } },
  9126		},
  9127		{
  9128			"LD_IND byte positive offset, out of bounds",
  9129			.u.insns = {
  9130				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9131				BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
  9132				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9133			},
  9134			CLASSIC,
  9135			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9136			{ {0x3f, 0 }, },
  9137		},
  9138		{
  9139			"LD_IND byte negative offset, out of bounds",
  9140			.u.insns = {
  9141				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9142				BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
  9143				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9144			},
  9145			CLASSIC,
  9146			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9147			{ {0x3f, 0 } },
  9148		},
  9149		{
  9150			"LD_IND byte negative offset, multiple calls",
  9151			.u.insns = {
  9152				BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
  9153				BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
  9154				BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
  9155				BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
  9156				BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
  9157				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9158			},
  9159			CLASSIC,
  9160			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9161			{ {0x40, 0x82 }, },
  9162		},
  9163		{
  9164			"LD_IND halfword positive offset",
  9165			.u.insns = {
  9166				BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
  9167				BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
  9168				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9169			},
  9170			CLASSIC,
  9171			{
  9172				[0x1c] = 0xaa, [0x1d] = 0x55,
  9173				[0x1e] = 0xbb, [0x1f] = 0x66,
  9174				[0x20] = 0xcc, [0x21] = 0x77,
  9175				[0x22] = 0xdd, [0x23] = 0x88,
  9176			},
  9177			{ {0x40, 0xdd88 } },
  9178		},
  9179		{
  9180			"LD_IND halfword negative offset",
  9181			.u.insns = {
  9182				BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
  9183				BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
  9184				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9185			},
  9186			CLASSIC,
  9187			{
  9188				[0x1c] = 0xaa, [0x1d] = 0x55,
  9189				[0x1e] = 0xbb, [0x1f] = 0x66,
  9190				[0x20] = 0xcc, [0x21] = 0x77,
  9191				[0x22] = 0xdd, [0x23] = 0x88,
  9192			},
  9193			{ {0x40, 0xbb66 } },
  9194		},
  9195		{
  9196			"LD_IND halfword unaligned",
  9197			.u.insns = {
  9198				BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
  9199				BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
  9200				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9201			},
  9202			CLASSIC,
  9203			{
  9204				[0x1c] = 0xaa, [0x1d] = 0x55,
  9205				[0x1e] = 0xbb, [0x1f] = 0x66,
  9206				[0x20] = 0xcc, [0x21] = 0x77,
  9207				[0x22] = 0xdd, [0x23] = 0x88,
  9208			},
  9209			{ {0x40, 0x66cc } },
  9210		},
  9211		{
  9212			"LD_IND halfword positive offset, all ff",
  9213			.u.insns = {
  9214				BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
  9215				BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
  9216				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9217			},
  9218			CLASSIC,
  9219			{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
  9220			{ {0x40, 0xffff } },
  9221		},
  9222		{
  9223			"LD_IND halfword positive offset, out of bounds",
  9224			.u.insns = {
  9225				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9226				BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
  9227				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9228			},
  9229			CLASSIC,
  9230			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9231			{ {0x3f, 0 }, },
  9232		},
  9233		{
  9234			"LD_IND halfword negative offset, out of bounds",
  9235			.u.insns = {
  9236				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9237				BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
  9238				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9239			},
  9240			CLASSIC,
  9241			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9242			{ {0x3f, 0 } },
  9243		},
  9244		{
  9245			"LD_IND word positive offset",
  9246			.u.insns = {
  9247				BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
  9248				BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
  9249				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9250			},
  9251			CLASSIC,
  9252			{
  9253				[0x1c] = 0xaa, [0x1d] = 0x55,
  9254				[0x1e] = 0xbb, [0x1f] = 0x66,
  9255				[0x20] = 0xcc, [0x21] = 0x77,
  9256				[0x22] = 0xdd, [0x23] = 0x88,
  9257				[0x24] = 0xee, [0x25] = 0x99,
  9258				[0x26] = 0xff, [0x27] = 0xaa,
  9259			},
  9260			{ {0x40, 0xee99ffaa } },
  9261		},
  9262		{
  9263			"LD_IND word negative offset",
  9264			.u.insns = {
  9265				BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
  9266				BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
  9267				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9268			},
  9269			CLASSIC,
  9270			{
  9271				[0x1c] = 0xaa, [0x1d] = 0x55,
  9272				[0x1e] = 0xbb, [0x1f] = 0x66,
  9273				[0x20] = 0xcc, [0x21] = 0x77,
  9274				[0x22] = 0xdd, [0x23] = 0x88,
  9275				[0x24] = 0xee, [0x25] = 0x99,
  9276				[0x26] = 0xff, [0x27] = 0xaa,
  9277			},
  9278			{ {0x40, 0xaa55bb66 } },
  9279		},
  9280		{
  9281			"LD_IND word unaligned (addr & 3 == 2)",
  9282			.u.insns = {
  9283				BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
  9284				BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
  9285				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9286			},
  9287			CLASSIC,
  9288			{
  9289				[0x1c] = 0xaa, [0x1d] = 0x55,
  9290				[0x1e] = 0xbb, [0x1f] = 0x66,
  9291				[0x20] = 0xcc, [0x21] = 0x77,
  9292				[0x22] = 0xdd, [0x23] = 0x88,
  9293				[0x24] = 0xee, [0x25] = 0x99,
  9294				[0x26] = 0xff, [0x27] = 0xaa,
  9295			},
  9296			{ {0x40, 0xbb66cc77 } },
  9297		},
  9298		{
  9299			"LD_IND word unaligned (addr & 3 == 1)",
  9300			.u.insns = {
  9301				BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
  9302				BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
  9303				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9304			},
  9305			CLASSIC,
  9306			{
  9307				[0x1c] = 0xaa, [0x1d] = 0x55,
  9308				[0x1e] = 0xbb, [0x1f] = 0x66,
  9309				[0x20] = 0xcc, [0x21] = 0x77,
  9310				[0x22] = 0xdd, [0x23] = 0x88,
  9311				[0x24] = 0xee, [0x25] = 0x99,
  9312				[0x26] = 0xff, [0x27] = 0xaa,
  9313			},
  9314			{ {0x40, 0x55bb66cc } },
  9315		},
  9316		{
  9317			"LD_IND word unaligned (addr & 3 == 3)",
  9318			.u.insns = {
  9319				BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
  9320				BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
  9321				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9322			},
  9323			CLASSIC,
  9324			{
  9325				[0x1c] = 0xaa, [0x1d] = 0x55,
  9326				[0x1e] = 0xbb, [0x1f] = 0x66,
  9327				[0x20] = 0xcc, [0x21] = 0x77,
  9328				[0x22] = 0xdd, [0x23] = 0x88,
  9329				[0x24] = 0xee, [0x25] = 0x99,
  9330				[0x26] = 0xff, [0x27] = 0xaa,
  9331			},
  9332			{ {0x40, 0x66cc77dd } },
  9333		},
  9334		{
  9335			"LD_IND word positive offset, all ff",
  9336			.u.insns = {
  9337				BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
  9338				BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
  9339				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9340			},
  9341			CLASSIC,
  9342			{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
  9343			{ {0x40, 0xffffffff } },
  9344		},
  9345		{
  9346			"LD_IND word positive offset, out of bounds",
  9347			.u.insns = {
  9348				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9349				BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
  9350				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9351			},
  9352			CLASSIC,
  9353			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9354			{ {0x3f, 0 }, },
  9355		},
  9356		{
  9357			"LD_IND word negative offset, out of bounds",
  9358			.u.insns = {
  9359				BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
  9360				BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
  9361				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9362			},
  9363			CLASSIC,
  9364			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9365			{ {0x3f, 0 } },
  9366		},
  9367		{
  9368			"LD_ABS byte",
  9369			.u.insns = {
  9370				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
  9371				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9372			},
  9373			CLASSIC,
  9374			{
  9375				[0x1c] = 0xaa, [0x1d] = 0x55,
  9376				[0x1e] = 0xbb, [0x1f] = 0x66,
  9377				[0x20] = 0xcc, [0x21] = 0x77,
  9378				[0x22] = 0xdd, [0x23] = 0x88,
  9379				[0x24] = 0xee, [0x25] = 0x99,
  9380				[0x26] = 0xff, [0x27] = 0xaa,
  9381			},
  9382			{ {0x40, 0xcc } },
  9383		},
  9384		{
  9385			"LD_ABS byte positive offset, all ff",
  9386			.u.insns = {
  9387				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
  9388				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9389			},
  9390			CLASSIC,
  9391			{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
  9392			{ {0x40, 0xff } },
  9393		},
  9394		{
  9395			"LD_ABS byte positive offset, out of bounds",
  9396			.u.insns = {
  9397				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
  9398				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9399			},
  9400			CLASSIC,
  9401			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9402			{ {0x3f, 0 }, },
  9403		},
  9404		{
  9405			"LD_ABS byte negative offset, out of bounds load",
  9406			.u.insns = {
  9407				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
  9408				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9409			},
  9410			CLASSIC | FLAG_EXPECTED_FAIL,
  9411			.expected_errcode = -EINVAL,
  9412		},
  9413		{
  9414			"LD_ABS byte negative offset, in bounds",
  9415			.u.insns = {
  9416				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
  9417				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9418			},
  9419			CLASSIC,
  9420			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9421			{ {0x40, 0x82 }, },
  9422		},
  9423		{
  9424			"LD_ABS byte negative offset, out of bounds",
  9425			.u.insns = {
  9426				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
  9427				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9428			},
  9429			CLASSIC,
  9430			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9431			{ {0x3f, 0 }, },
  9432		},
  9433		{
  9434			"LD_ABS byte negative offset, multiple calls",
  9435			.u.insns = {
  9436				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
  9437				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
  9438				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
  9439				BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
  9440				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9441			},
  9442			CLASSIC,
  9443			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9444			{ {0x40, 0x82 }, },
  9445		},
  9446		{
  9447			"LD_ABS halfword",
  9448			.u.insns = {
  9449				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
  9450				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9451			},
  9452			CLASSIC,
  9453			{
  9454				[0x1c] = 0xaa, [0x1d] = 0x55,
  9455				[0x1e] = 0xbb, [0x1f] = 0x66,
  9456				[0x20] = 0xcc, [0x21] = 0x77,
  9457				[0x22] = 0xdd, [0x23] = 0x88,
  9458				[0x24] = 0xee, [0x25] = 0x99,
  9459				[0x26] = 0xff, [0x27] = 0xaa,
  9460			},
  9461			{ {0x40, 0xdd88 } },
  9462		},
  9463		{
  9464			"LD_ABS halfword unaligned",
  9465			.u.insns = {
  9466				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
  9467				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9468			},
  9469			CLASSIC,
  9470			{
  9471				[0x1c] = 0xaa, [0x1d] = 0x55,
  9472				[0x1e] = 0xbb, [0x1f] = 0x66,
  9473				[0x20] = 0xcc, [0x21] = 0x77,
  9474				[0x22] = 0xdd, [0x23] = 0x88,
  9475				[0x24] = 0xee, [0x25] = 0x99,
  9476				[0x26] = 0xff, [0x27] = 0xaa,
  9477			},
  9478			{ {0x40, 0x99ff } },
  9479		},
  9480		{
  9481			"LD_ABS halfword positive offset, all ff",
  9482			.u.insns = {
  9483				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
  9484				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9485			},
  9486			CLASSIC,
  9487			{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
  9488			{ {0x40, 0xffff } },
  9489		},
  9490		{
  9491			"LD_ABS halfword positive offset, out of bounds",
  9492			.u.insns = {
  9493				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
  9494				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9495			},
  9496			CLASSIC,
  9497			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9498			{ {0x3f, 0 }, },
  9499		},
  9500		{
  9501			"LD_ABS halfword negative offset, out of bounds load",
  9502			.u.insns = {
  9503				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
  9504				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9505			},
  9506			CLASSIC | FLAG_EXPECTED_FAIL,
  9507			.expected_errcode = -EINVAL,
  9508		},
  9509		{
  9510			"LD_ABS halfword negative offset, in bounds",
  9511			.u.insns = {
  9512				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
  9513				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9514			},
  9515			CLASSIC,
  9516			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9517			{ {0x40, 0x1982 }, },
  9518		},
  9519		{
  9520			"LD_ABS halfword negative offset, out of bounds",
  9521			.u.insns = {
  9522				BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
  9523				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9524			},
  9525			CLASSIC,
  9526			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9527			{ {0x3f, 0 }, },
  9528		},
  9529		{
  9530			"LD_ABS word",
  9531			.u.insns = {
  9532				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
  9533				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9534			},
  9535			CLASSIC,
  9536			{
  9537				[0x1c] = 0xaa, [0x1d] = 0x55,
  9538				[0x1e] = 0xbb, [0x1f] = 0x66,
  9539				[0x20] = 0xcc, [0x21] = 0x77,
  9540				[0x22] = 0xdd, [0x23] = 0x88,
  9541				[0x24] = 0xee, [0x25] = 0x99,
  9542				[0x26] = 0xff, [0x27] = 0xaa,
  9543			},
  9544			{ {0x40, 0xaa55bb66 } },
  9545		},
  9546		{
  9547			"LD_ABS word unaligned (addr & 3 == 2)",
  9548			.u.insns = {
  9549				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
  9550				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9551			},
  9552			CLASSIC,
  9553			{
  9554				[0x1c] = 0xaa, [0x1d] = 0x55,
  9555				[0x1e] = 0xbb, [0x1f] = 0x66,
  9556				[0x20] = 0xcc, [0x21] = 0x77,
  9557				[0x22] = 0xdd, [0x23] = 0x88,
  9558				[0x24] = 0xee, [0x25] = 0x99,
  9559				[0x26] = 0xff, [0x27] = 0xaa,
  9560			},
  9561			{ {0x40, 0xdd88ee99 } },
  9562		},
  9563		{
  9564			"LD_ABS word unaligned (addr & 3 == 1)",
  9565			.u.insns = {
  9566				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
  9567				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9568			},
  9569			CLASSIC,
  9570			{
  9571				[0x1c] = 0xaa, [0x1d] = 0x55,
  9572				[0x1e] = 0xbb, [0x1f] = 0x66,
  9573				[0x20] = 0xcc, [0x21] = 0x77,
  9574				[0x22] = 0xdd, [0x23] = 0x88,
  9575				[0x24] = 0xee, [0x25] = 0x99,
  9576				[0x26] = 0xff, [0x27] = 0xaa,
  9577			},
  9578			{ {0x40, 0x77dd88ee } },
  9579		},
  9580		{
  9581			"LD_ABS word unaligned (addr & 3 == 3)",
  9582			.u.insns = {
  9583				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
  9584				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9585			},
  9586			CLASSIC,
  9587			{
  9588				[0x1c] = 0xaa, [0x1d] = 0x55,
  9589				[0x1e] = 0xbb, [0x1f] = 0x66,
  9590				[0x20] = 0xcc, [0x21] = 0x77,
  9591				[0x22] = 0xdd, [0x23] = 0x88,
  9592				[0x24] = 0xee, [0x25] = 0x99,
  9593				[0x26] = 0xff, [0x27] = 0xaa,
  9594			},
  9595			{ {0x40, 0x88ee99ff } },
  9596		},
  9597		{
  9598			"LD_ABS word positive offset, all ff",
  9599			.u.insns = {
  9600				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
  9601				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9602			},
  9603			CLASSIC,
  9604			{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
  9605			{ {0x40, 0xffffffff } },
  9606		},
  9607		{
  9608			"LD_ABS word positive offset, out of bounds",
  9609			.u.insns = {
  9610				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
  9611				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9612			},
  9613			CLASSIC,
  9614			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9615			{ {0x3f, 0 }, },
  9616		},
  9617		{
  9618			"LD_ABS word negative offset, out of bounds load",
  9619			.u.insns = {
  9620				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
  9621				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9622			},
  9623			CLASSIC | FLAG_EXPECTED_FAIL,
  9624			.expected_errcode = -EINVAL,
  9625		},
  9626		{
  9627			"LD_ABS word negative offset, in bounds",
  9628			.u.insns = {
  9629				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
  9630				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9631			},
  9632			CLASSIC,
  9633			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9634			{ {0x40, 0x25051982 }, },
  9635		},
  9636		{
  9637			"LD_ABS word negative offset, out of bounds",
  9638			.u.insns = {
  9639				BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
  9640				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9641			},
  9642			CLASSIC,
  9643			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9644			{ {0x3f, 0 }, },
  9645		},
  9646		{
  9647			"LDX_MSH standalone, preserved A",
  9648			.u.insns = {
  9649				BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
  9650				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
  9651				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9652			},
  9653			CLASSIC,
  9654			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9655			{ {0x40, 0xffeebbaa }, },
  9656		},
  9657		{
  9658			"LDX_MSH standalone, preserved A 2",
  9659			.u.insns = {
  9660				BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
  9661				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
  9662				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
  9663				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
  9664				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
  9665				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9666			},
  9667			CLASSIC,
  9668			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9669			{ {0x40, 0x175e9d63 }, },
  9670		},
  9671		{
  9672			"LDX_MSH standalone, test result 1",
  9673			.u.insns = {
  9674				BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
  9675				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
  9676				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  9677				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9678			},
  9679			CLASSIC,
  9680			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9681			{ {0x40, 0x14 }, },
  9682		},
  9683		{
  9684			"LDX_MSH standalone, test result 2",
  9685			.u.insns = {
  9686				BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
  9687				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
  9688				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  9689				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9690			},
  9691			CLASSIC,
  9692			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9693			{ {0x40, 0x24 }, },
  9694		},
  9695		{
  9696			"LDX_MSH standalone, negative offset",
  9697			.u.insns = {
  9698				BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
  9699				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
  9700				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  9701				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9702			},
  9703			CLASSIC,
  9704			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9705			{ {0x40, 0 }, },
  9706		},
  9707		{
  9708			"LDX_MSH standalone, negative offset 2",
  9709			.u.insns = {
  9710				BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
  9711				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
  9712				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  9713				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9714			},
  9715			CLASSIC,
  9716			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9717			{ {0x40, 0x24 }, },
  9718		},
  9719		{
  9720			"LDX_MSH standalone, out of bounds",
  9721			.u.insns = {
  9722				BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
  9723				BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
  9724				BPF_STMT(BPF_MISC | BPF_TXA, 0),
  9725				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9726			},
  9727			CLASSIC,
  9728			{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
  9729			{ {0x40, 0 }, },
  9730		},
  9731		/*
  9732		 * verify that the interpreter or JIT correctly sets A and X
  9733		 * to 0.
  9734		 */
  9735		{
  9736			"ADD default X",
  9737			.u.insns = {
  9738				/*
  9739				 * A = 0x42
  9740				 * A = A + X
  9741				 * ret A
  9742				 */
  9743				BPF_STMT(BPF_LD | BPF_IMM, 0x42),
  9744				BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
  9745				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9746			},
  9747			CLASSIC | FLAG_NO_DATA,
  9748			{},
  9749			{ {0x1, 0x42 } },
  9750		},
  9751		{
  9752			"ADD default A",
  9753			.u.insns = {
  9754				/*
  9755				 * A = A + 0x42
  9756				 * ret A
  9757				 */
  9758				BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
  9759				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9760			},
  9761			CLASSIC | FLAG_NO_DATA,
  9762			{},
  9763			{ {0x1, 0x42 } },
  9764		},
  9765		{
  9766			"SUB default X",
  9767			.u.insns = {
  9768				/*
  9769				 * A = 0x66
  9770				 * A = A - X
  9771				 * ret A
  9772				 */
  9773				BPF_STMT(BPF_LD | BPF_IMM, 0x66),
  9774				BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
  9775				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9776			},
  9777			CLASSIC | FLAG_NO_DATA,
  9778			{},
  9779			{ {0x1, 0x66 } },
  9780		},
  9781		{
  9782			"SUB default A",
  9783			.u.insns = {
  9784				/*
  9785				 * A = A - -0x66
  9786				 * ret A
  9787				 */
  9788				BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
  9789				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9790			},
  9791			CLASSIC | FLAG_NO_DATA,
  9792			{},
  9793			{ {0x1, 0x66 } },
  9794		},
  9795		{
  9796			"MUL default X",
  9797			.u.insns = {
  9798				/*
  9799				 * A = 0x42
  9800				 * A = A * X
  9801				 * ret A
  9802				 */
  9803				BPF_STMT(BPF_LD | BPF_IMM, 0x42),
  9804				BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
  9805				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9806			},
  9807			CLASSIC | FLAG_NO_DATA,
  9808			{},
  9809			{ {0x1, 0x0 } },
  9810		},
  9811		{
  9812			"MUL default A",
  9813			.u.insns = {
  9814				/*
  9815				 * A = A * 0x66
  9816				 * ret A
  9817				 */
  9818				BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
  9819				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9820			},
  9821			CLASSIC | FLAG_NO_DATA,
  9822			{},
  9823			{ {0x1, 0x0 } },
  9824		},
  9825		{
  9826			"DIV default X",
  9827			.u.insns = {
  9828				/*
  9829				 * A = 0x42
  9830				 * A = A / X ; this halt the filter execution if X is 0
  9831				 * ret 0x42
  9832				 */
  9833				BPF_STMT(BPF_LD | BPF_IMM, 0x42),
  9834				BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
  9835				BPF_STMT(BPF_RET | BPF_K, 0x42),
  9836			},
  9837			CLASSIC | FLAG_NO_DATA,
  9838			{},
  9839			{ {0x1, 0x0 } },
  9840		},
  9841		{
  9842			"DIV default A",
  9843			.u.insns = {
  9844				/*
  9845				 * A = A / 1
  9846				 * ret A
  9847				 */
  9848				BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
  9849				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9850			},
  9851			CLASSIC | FLAG_NO_DATA,
  9852			{},
  9853			{ {0x1, 0x0 } },
  9854		},
  9855		{
  9856			"MOD default X",
  9857			.u.insns = {
  9858				/*
  9859				 * A = 0x42
  9860				 * A = A mod X ; this halt the filter execution if X is 0
  9861				 * ret 0x42
  9862				 */
  9863				BPF_STMT(BPF_LD | BPF_IMM, 0x42),
  9864				BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
  9865				BPF_STMT(BPF_RET | BPF_K, 0x42),
  9866			},
  9867			CLASSIC | FLAG_NO_DATA,
  9868			{},
  9869			{ {0x1, 0x0 } },
  9870		},
  9871		{
  9872			"MOD default A",
  9873			.u.insns = {
  9874				/*
  9875				 * A = A mod 1
  9876				 * ret A
  9877				 */
  9878				BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
  9879				BPF_STMT(BPF_RET | BPF_A, 0x0),
  9880			},
  9881			CLASSIC | FLAG_NO_DATA,
  9882			{},
  9883			{ {0x1, 0x0 } },
  9884		},
  9885		{
  9886			"JMP EQ default A",
  9887			.u.insns = {
  9888				/*
  9889				 * cmp A, 0x0, 0, 1
  9890				 * ret 0x42
  9891				 * ret 0x66
  9892				 */
  9893				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
  9894				BPF_STMT(BPF_RET | BPF_K, 0x42),
  9895				BPF_STMT(BPF_RET | BPF_K, 0x66),
  9896			},
  9897			CLASSIC | FLAG_NO_DATA,
  9898			{},
  9899			{ {0x1, 0x42 } },
  9900		},
  9901		{
  9902			"JMP EQ default X",
  9903			.u.insns = {
  9904				/*
  9905				 * A = 0x0
  9906				 * cmp A, X, 0, 1
  9907				 * ret 0x42
  9908				 * ret 0x66
  9909				 */
  9910				BPF_STMT(BPF_LD | BPF_IMM, 0x0),
  9911				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
  9912				BPF_STMT(BPF_RET | BPF_K, 0x42),
  9913				BPF_STMT(BPF_RET | BPF_K, 0x66),
  9914			},
  9915			CLASSIC | FLAG_NO_DATA,
  9916			{},
  9917			{ {0x1, 0x42 } },
  9918		},
  9919		/* Checking interpreter vs JIT wrt signed extended imms. */
  9920		{
  9921			"JNE signed compare, test 1",
  9922			.u.insns_int = {
  9923				BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
  9924				BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
  9925				BPF_MOV64_REG(R2, R1),
  9926				BPF_ALU64_REG(BPF_AND, R2, R3),
  9927				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  9928				BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
  9929				BPF_ALU32_IMM(BPF_MOV, R0, 2),
  9930				BPF_EXIT_INSN(),
  9931			},
  9932			INTERNAL,
  9933			{ },
  9934			{ { 0, 1 } },
  9935		},
  9936		{
  9937			"JNE signed compare, test 2",
  9938			.u.insns_int = {
  9939				BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
  9940				BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
  9941				BPF_MOV64_REG(R2, R1),
  9942				BPF_ALU64_REG(BPF_AND, R2, R3),
  9943				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  9944				BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
  9945				BPF_ALU32_IMM(BPF_MOV, R0, 2),
  9946				BPF_EXIT_INSN(),
  9947			},
  9948			INTERNAL,
  9949			{ },
  9950			{ { 0, 1 } },
  9951		},
  9952		{
  9953			"JNE signed compare, test 3",
  9954			.u.insns_int = {
  9955				BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
  9956				BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
  9957				BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
  9958				BPF_MOV64_REG(R2, R1),
  9959				BPF_ALU64_REG(BPF_AND, R2, R3),
  9960				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  9961				BPF_JMP_REG(BPF_JNE, R2, R4, 1),
  9962				BPF_ALU32_IMM(BPF_MOV, R0, 2),
  9963				BPF_EXIT_INSN(),
  9964			},
  9965			INTERNAL,
  9966			{ },
  9967			{ { 0, 2 } },
  9968		},
  9969		{
  9970			"JNE signed compare, test 4",
  9971			.u.insns_int = {
  9972				BPF_LD_IMM64(R1, -17104896),
  9973				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  9974				BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
  9975				BPF_ALU32_IMM(BPF_MOV, R0, 2),
  9976				BPF_EXIT_INSN(),
  9977			},
  9978			INTERNAL,
  9979			{ },
  9980			{ { 0, 2 } },
  9981		},
  9982		{
  9983			"JNE signed compare, test 5",
  9984			.u.insns_int = {
  9985				BPF_LD_IMM64(R1, 0xfefb0000),
  9986				BPF_ALU32_IMM(BPF_MOV, R0, 1),
  9987				BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
  9988				BPF_ALU32_IMM(BPF_MOV, R0, 2),
  9989				BPF_EXIT_INSN(),
  9990			},
  9991			INTERNAL,
  9992			{ },
  9993			{ { 0, 1 } },
  9994		},
  9995		{
  9996			"JNE signed compare, test 6",
  9997			.u.insns_int = {
  9998				BPF_LD_IMM64(R1, 0x7efb0000),
  9999				BPF_ALU32_IMM(BPF_MOV, R0, 1),
 10000				BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
 10001				BPF_ALU32_IMM(BPF_MOV, R0, 2),
 10002				BPF_EXIT_INSN(),
 10003			},
 10004			INTERNAL,
 10005			{ },
 10006			{ { 0, 2 } },
 10007		},
 10008		{
 10009			"JNE signed compare, test 7",
 10010			.u.insns = {
 10011				BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
 10012				BPF_STMT(BPF_MISC | BPF_TAX, 0),
 10013				BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
 10014				BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
 10015				BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
 10016				BPF_STMT(BPF_RET | BPF_K, 1),
 10017				BPF_STMT(BPF_RET | BPF_K, 2),
 10018			},
 10019			CLASSIC | FLAG_NO_DATA,
 10020			{},
 10021			{ { 0, 2 } },
 10022		},
 10023		/* Exhaustive test of ALU64 shift operations */
 10024		{
 10025			"ALU64_LSH_K: all shift values",
 10026			{ },
 10027			INTERNAL | FLAG_NO_DATA,
 10028			{ },
 10029			{ { 0, 1 } },
 10030			.fill_helper = bpf_fill_alu_lsh_imm,
 10031		},
 10032		{
 10033			"ALU64_RSH_K: all shift values",
 10034			{ },
 10035			INTERNAL | FLAG_NO_DATA,
 10036			{ },
 10037			{ { 0, 1 } },
 10038			.fill_helper = bpf_fill_alu_rsh_imm,
 10039		},
 10040		{
 10041			"ALU64_ARSH_K: all shift values",
 10042			{ },
 10043			INTERNAL | FLAG_NO_DATA,
 10044			{ },
 10045			{ { 0, 1 } },
 10046			.fill_helper = bpf_fill_alu_arsh_imm,
 10047		},
 10048		{
 10049			"ALU64_LSH_X: all shift values",
 10050			{ },
 10051			INTERNAL | FLAG_NO_DATA,
 10052			{ },
 10053			{ { 0, 1 } },
 10054			.fill_helper = bpf_fill_alu_lsh_reg,
 10055		},
 10056		{
 10057			"ALU64_RSH_X: all shift values",
 10058			{ },
 10059			INTERNAL | FLAG_NO_DATA,
 10060			{ },
 10061			{ { 0, 1 } },
 10062			.fill_helper = bpf_fill_alu_rsh_reg,
 10063		},
 10064		{
 10065			"ALU64_ARSH_X: all shift values",
 10066			{ },
 10067			INTERNAL | FLAG_NO_DATA,
 10068			{ },
 10069			{ { 0, 1 } },
 10070			.fill_helper = bpf_fill_alu_arsh_reg,
 10071		},
 10072		/* Exhaustive test of ALU32 shift operations */
 10073		{
 10074			"ALU32_LSH_K: all shift values",
 10075			{ },
 10076			INTERNAL | FLAG_NO_DATA,
 10077			{ },
 10078			{ { 0, 1 } },
 10079			.fill_helper = bpf_fill_alu32_lsh_imm,
 10080		},
 10081		{
 10082			"ALU32_RSH_K: all shift values",
 10083			{ },
 10084			INTERNAL | FLAG_NO_DATA,
 10085			{ },
 10086			{ { 0, 1 } },
 10087			.fill_helper = bpf_fill_alu32_rsh_imm,
 10088		},
 10089		{
 10090			"ALU32_ARSH_K: all shift values",
 10091			{ },
 10092			INTERNAL | FLAG_NO_DATA,
 10093			{ },
 10094			{ { 0, 1 } },
 10095			.fill_helper = bpf_fill_alu32_arsh_imm,
 10096		},
 10097		{
 10098			"ALU32_LSH_X: all shift values",
 10099			{ },
 10100			INTERNAL | FLAG_NO_DATA,
 10101			{ },
 10102			{ { 0, 1 } },
 10103			.fill_helper = bpf_fill_alu32_lsh_reg,
 10104		},
 10105		{
 10106			"ALU32_RSH_X: all shift values",
 10107			{ },
 10108			INTERNAL | FLAG_NO_DATA,
 10109			{ },
 10110			{ { 0, 1 } },
 10111			.fill_helper = bpf_fill_alu32_rsh_reg,
 10112		},
 10113		{
 10114			"ALU32_ARSH_X: all shift values",
 10115			{ },
 10116			INTERNAL | FLAG_NO_DATA,
 10117			{ },
 10118			{ { 0, 1 } },
 10119			.fill_helper = bpf_fill_alu32_arsh_reg,
 10120		},
 10121		/* ALU64 immediate magnitudes */
 10122		{
 10123			"ALU64_MOV_K: all immediate value magnitudes",
 10124			{ },
 10125			INTERNAL | FLAG_NO_DATA,
 10126			{ },
 10127			{ { 0, 1 } },
 10128			.fill_helper = bpf_fill_alu64_mov_imm,
 10129			.nr_testruns = NR_PATTERN_RUNS,
 10130		},
 10131		{
 10132			"ALU64_AND_K: all immediate value magnitudes",
 10133			{ },
 10134			INTERNAL | FLAG_NO_DATA,
 10135			{ },
 10136			{ { 0, 1 } },
 10137			.fill_helper = bpf_fill_alu64_and_imm,
 10138			.nr_testruns = NR_PATTERN_RUNS,
 10139		},
 10140		{
 10141			"ALU64_OR_K: all immediate value magnitudes",
 10142			{ },
 10143			INTERNAL | FLAG_NO_DATA,
 10144			{ },
 10145			{ { 0, 1 } },
 10146			.fill_helper = bpf_fill_alu64_or_imm,
 10147			.nr_testruns = NR_PATTERN_RUNS,
 10148		},
 10149		{
 10150			"ALU64_XOR_K: all immediate value magnitudes",
 10151			{ },
 10152			INTERNAL | FLAG_NO_DATA,
 10153			{ },
 10154			{ { 0, 1 } },
 10155			.fill_helper = bpf_fill_alu64_xor_imm,
 10156			.nr_testruns = NR_PATTERN_RUNS,
 10157		},
 10158		{
 10159			"ALU64_ADD_K: all immediate value magnitudes",
 10160			{ },
 10161			INTERNAL | FLAG_NO_DATA,
 10162			{ },
 10163			{ { 0, 1 } },
 10164			.fill_helper = bpf_fill_alu64_add_imm,
 10165			.nr_testruns = NR_PATTERN_RUNS,
 10166		},
 10167		{
 10168			"ALU64_SUB_K: all immediate value magnitudes",
 10169			{ },
 10170			INTERNAL | FLAG_NO_DATA,
 10171			{ },
 10172			{ { 0, 1 } },
 10173			.fill_helper = bpf_fill_alu64_sub_imm,
 10174			.nr_testruns = NR_PATTERN_RUNS,
 10175		},
 10176		{
 10177			"ALU64_MUL_K: all immediate value magnitudes",
 10178			{ },
 10179			INTERNAL | FLAG_NO_DATA,
 10180			{ },
 10181			{ { 0, 1 } },
 10182			.fill_helper = bpf_fill_alu64_mul_imm,
 10183			.nr_testruns = NR_PATTERN_RUNS,
 10184		},
 10185		{
 10186			"ALU64_DIV_K: all immediate value magnitudes",
 10187			{ },
 10188			INTERNAL | FLAG_NO_DATA,
 10189			{ },
 10190			{ { 0, 1 } },
 10191			.fill_helper = bpf_fill_alu64_div_imm,
 10192			.nr_testruns = NR_PATTERN_RUNS,
 10193		},
 10194		{
 10195			"ALU64_MOD_K: all immediate value magnitudes",
 10196			{ },
 10197			INTERNAL | FLAG_NO_DATA,
 10198			{ },
 10199			{ { 0, 1 } },
 10200			.fill_helper = bpf_fill_alu64_mod_imm,
 10201			.nr_testruns = NR_PATTERN_RUNS,
 10202		},
 10203		/* ALU32 immediate magnitudes */
 10204		{
 10205			"ALU32_MOV_K: all immediate value magnitudes",
 10206			{ },
 10207			INTERNAL | FLAG_NO_DATA,
 10208			{ },
 10209			{ { 0, 1 } },
 10210			.fill_helper = bpf_fill_alu32_mov_imm,
 10211			.nr_testruns = NR_PATTERN_RUNS,
 10212		},
 10213		{
 10214			"ALU32_AND_K: all immediate value magnitudes",
 10215			{ },
 10216			INTERNAL | FLAG_NO_DATA,
 10217			{ },
 10218			{ { 0, 1 } },
 10219			.fill_helper = bpf_fill_alu32_and_imm,
 10220			.nr_testruns = NR_PATTERN_RUNS,
 10221		},
 10222		{
 10223			"ALU32_OR_K: all immediate value magnitudes",
 10224			{ },
 10225			INTERNAL | FLAG_NO_DATA,
 10226			{ },
 10227			{ { 0, 1 } },
 10228			.fill_helper = bpf_fill_alu32_or_imm,
 10229			.nr_testruns = NR_PATTERN_RUNS,
 10230		},
 10231		{
 10232			"ALU32_XOR_K: all immediate value magnitudes",
 10233			{ },
 10234			INTERNAL | FLAG_NO_DATA,
 10235			{ },
 10236			{ { 0, 1 } },
 10237			.fill_helper = bpf_fill_alu32_xor_imm,
 10238			.nr_testruns = NR_PATTERN_RUNS,
 10239		},
 10240		{
 10241			"ALU32_ADD_K: all immediate value magnitudes",
 10242			{ },
 10243			INTERNAL | FLAG_NO_DATA,
 10244			{ },
 10245			{ { 0, 1 } },
 10246			.fill_helper = bpf_fill_alu32_add_imm,
 10247			.nr_testruns = NR_PATTERN_RUNS,
 10248		},
 10249		{
 10250			"ALU32_SUB_K: all immediate value magnitudes",
 10251			{ },
 10252			INTERNAL | FLAG_NO_DATA,
 10253			{ },
 10254			{ { 0, 1 } },
 10255			.fill_helper = bpf_fill_alu32_sub_imm,
 10256			.nr_testruns = NR_PATTERN_RUNS,
 10257		},
 10258		{
 10259			"ALU32_MUL_K: all immediate value magnitudes",
 10260			{ },
 10261			INTERNAL | FLAG_NO_DATA,
 10262			{ },
 10263			{ { 0, 1 } },
 10264			.fill_helper = bpf_fill_alu32_mul_imm,
 10265			.nr_testruns = NR_PATTERN_RUNS,
 10266		},
 10267		{
 10268			"ALU32_DIV_K: all immediate value magnitudes",
 10269			{ },
 10270			INTERNAL | FLAG_NO_DATA,
 10271			{ },
 10272			{ { 0, 1 } },
 10273			.fill_helper = bpf_fill_alu32_div_imm,
 10274			.nr_testruns = NR_PATTERN_RUNS,
 10275		},
 10276		{
 10277			"ALU32_MOD_K: all immediate value magnitudes",
 10278			{ },
 10279			INTERNAL | FLAG_NO_DATA,
 10280			{ },
 10281			{ { 0, 1 } },
 10282			.fill_helper = bpf_fill_alu32_mod_imm,
 10283			.nr_testruns = NR_PATTERN_RUNS,
 10284		},
 10285		/* ALU64 register magnitudes */
 10286		{
 10287			"ALU64_MOV_X: all register value magnitudes",
 10288			{ },
 10289			INTERNAL | FLAG_NO_DATA,
 10290			{ },
 10291			{ { 0, 1 } },
 10292			.fill_helper = bpf_fill_alu64_mov_reg,
 10293			.nr_testruns = NR_PATTERN_RUNS,
 10294		},
 10295		{
 10296			"ALU64_AND_X: all register value magnitudes",
 10297			{ },
 10298			INTERNAL | FLAG_NO_DATA,
 10299			{ },
 10300			{ { 0, 1 } },
 10301			.fill_helper = bpf_fill_alu64_and_reg,
 10302			.nr_testruns = NR_PATTERN_RUNS,
 10303		},
 10304		{
 10305			"ALU64_OR_X: all register value magnitudes",
 10306			{ },
 10307			INTERNAL | FLAG_NO_DATA,
 10308			{ },
 10309			{ { 0, 1 } },
 10310			.fill_helper = bpf_fill_alu64_or_reg,
 10311			.nr_testruns = NR_PATTERN_RUNS,
 10312		},
 10313		{
 10314			"ALU64_XOR_X: all register value magnitudes",
 10315			{ },
 10316			INTERNAL | FLAG_NO_DATA,
 10317			{ },
 10318			{ { 0, 1 } },
 10319			.fill_helper = bpf_fill_alu64_xor_reg,
 10320			.nr_testruns = NR_PATTERN_RUNS,
 10321		},
 10322		{
 10323			"ALU64_ADD_X: all register value magnitudes",
 10324			{ },
 10325			INTERNAL | FLAG_NO_DATA,
 10326			{ },
 10327			{ { 0, 1 } },
 10328			.fill_helper = bpf_fill_alu64_add_reg,
 10329			.nr_testruns = NR_PATTERN_RUNS,
 10330		},
 10331		{
 10332			"ALU64_SUB_X: all register value magnitudes",
 10333			{ },
 10334			INTERNAL | FLAG_NO_DATA,
 10335			{ },
 10336			{ { 0, 1 } },
 10337			.fill_helper = bpf_fill_alu64_sub_reg,
 10338			.nr_testruns = NR_PATTERN_RUNS,
 10339		},
 10340		{
 10341			"ALU64_MUL_X: all register value magnitudes",
 10342			{ },
 10343			INTERNAL | FLAG_NO_DATA,
 10344			{ },
 10345			{ { 0, 1 } },
 10346			.fill_helper = bpf_fill_alu64_mul_reg,
 10347			.nr_testruns = NR_PATTERN_RUNS,
 10348		},
 10349		{
 10350			"ALU64_DIV_X: all register value magnitudes",
 10351			{ },
 10352			INTERNAL | FLAG_NO_DATA,
 10353			{ },
 10354			{ { 0, 1 } },
 10355			.fill_helper = bpf_fill_alu64_div_reg,
 10356			.nr_testruns = NR_PATTERN_RUNS,
 10357		},
 10358		{
 10359			"ALU64_MOD_X: all register value magnitudes",
 10360			{ },
 10361			INTERNAL | FLAG_NO_DATA,
 10362			{ },
 10363			{ { 0, 1 } },
 10364			.fill_helper = bpf_fill_alu64_mod_reg,
 10365			.nr_testruns = NR_PATTERN_RUNS,
 10366		},
 10367		/* ALU32 register magnitudes */
 10368		{
 10369			"ALU32_MOV_X: all register value magnitudes",
 10370			{ },
 10371			INTERNAL | FLAG_NO_DATA,
 10372			{ },
 10373			{ { 0, 1 } },
 10374			.fill_helper = bpf_fill_alu32_mov_reg,
 10375			.nr_testruns = NR_PATTERN_RUNS,
 10376		},
 10377		{
 10378			"ALU32_AND_X: all register value magnitudes",
 10379			{ },
 10380			INTERNAL | FLAG_NO_DATA,
 10381			{ },
 10382			{ { 0, 1 } },
 10383			.fill_helper = bpf_fill_alu32_and_reg,
 10384			.nr_testruns = NR_PATTERN_RUNS,
 10385		},
 10386		{
 10387			"ALU32_OR_X: all register value magnitudes",
 10388			{ },
 10389			INTERNAL | FLAG_NO_DATA,
 10390			{ },
 10391			{ { 0, 1 } },
 10392			.fill_helper = bpf_fill_alu32_or_reg,
 10393			.nr_testruns = NR_PATTERN_RUNS,
 10394		},
 10395		{
 10396			"ALU32_XOR_X: all register value magnitudes",
 10397			{ },
 10398			INTERNAL | FLAG_NO_DATA,
 10399			{ },
 10400			{ { 0, 1 } },
 10401			.fill_helper = bpf_fill_alu32_xor_reg,
 10402			.nr_testruns = NR_PATTERN_RUNS,
 10403		},
 10404		{
 10405			"ALU32_ADD_X: all register value magnitudes",
 10406			{ },
 10407			INTERNAL | FLAG_NO_DATA,
 10408			{ },
 10409			{ { 0, 1 } },
 10410			.fill_helper = bpf_fill_alu32_add_reg,
 10411			.nr_testruns = NR_PATTERN_RUNS,
 10412		},
 10413		{
 10414			"ALU32_SUB_X: all register value magnitudes",
 10415			{ },
 10416			INTERNAL | FLAG_NO_DATA,
 10417			{ },
 10418			{ { 0, 1 } },
 10419			.fill_helper = bpf_fill_alu32_sub_reg,
 10420			.nr_testruns = NR_PATTERN_RUNS,
 10421		},
 10422		{
 10423			"ALU32_MUL_X: all register value magnitudes",
 10424			{ },
 10425			INTERNAL | FLAG_NO_DATA,
 10426			{ },
 10427			{ { 0, 1 } },
 10428			.fill_helper = bpf_fill_alu32_mul_reg,
 10429			.nr_testruns = NR_PATTERN_RUNS,
 10430		},
 10431		{
 10432			"ALU32_DIV_X: all register value magnitudes",
 10433			{ },
 10434			INTERNAL | FLAG_NO_DATA,
 10435			{ },
 10436			{ { 0, 1 } },
 10437			.fill_helper = bpf_fill_alu32_div_reg,
 10438			.nr_testruns = NR_PATTERN_RUNS,
 10439		},
 10440		{
 10441			"ALU32_MOD_X: all register value magnitudes",
 10442			{ },
 10443			INTERNAL | FLAG_NO_DATA,
 10444			{ },
 10445			{ { 0, 1 } },
 10446			.fill_helper = bpf_fill_alu32_mod_reg,
 10447			.nr_testruns = NR_PATTERN_RUNS,
 10448		},
 10449		/* LD_IMM64 immediate magnitudes */
 10450		{
 10451			"LD_IMM64: all immediate value magnitudes",
 10452			{ },
 10453			INTERNAL | FLAG_NO_DATA,
 10454			{ },
 10455			{ { 0, 1 } },
 10456			.fill_helper = bpf_fill_ld_imm64,
 10457		},
 10458		/* JMP immediate magnitudes */
 10459		{
 10460			"JMP_JSET_K: all immediate value magnitudes",
 10461			{ },
 10462			INTERNAL | FLAG_NO_DATA,
 10463			{ },
 10464			{ { 0, 1 } },
 10465			.fill_helper = bpf_fill_jmp_jset_imm,
 10466			.nr_testruns = NR_PATTERN_RUNS,
 10467		},
 10468		{
 10469			"JMP_JEQ_K: all immediate value magnitudes",
 10470			{ },
 10471			INTERNAL | FLAG_NO_DATA,
 10472			{ },
 10473			{ { 0, 1 } },
 10474			.fill_helper = bpf_fill_jmp_jeq_imm,
 10475			.nr_testruns = NR_PATTERN_RUNS,
 10476		},
 10477		{
 10478			"JMP_JNE_K: all immediate value magnitudes",
 10479			{ },
 10480			INTERNAL | FLAG_NO_DATA,
 10481			{ },
 10482			{ { 0, 1 } },
 10483			.fill_helper = bpf_fill_jmp_jne_imm,
 10484			.nr_testruns = NR_PATTERN_RUNS,
 10485		},
 10486		{
 10487			"JMP_JGT_K: all immediate value magnitudes",
 10488			{ },
 10489			INTERNAL | FLAG_NO_DATA,
 10490			{ },
 10491			{ { 0, 1 } },
 10492			.fill_helper = bpf_fill_jmp_jgt_imm,
 10493			.nr_testruns = NR_PATTERN_RUNS,
 10494		},
 10495		{
 10496			"JMP_JGE_K: all immediate value magnitudes",
 10497			{ },
 10498			INTERNAL | FLAG_NO_DATA,
 10499			{ },
 10500			{ { 0, 1 } },
 10501			.fill_helper = bpf_fill_jmp_jge_imm,
 10502			.nr_testruns = NR_PATTERN_RUNS,
 10503		},
 10504		{
 10505			"JMP_JLT_K: all immediate value magnitudes",
 10506			{ },
 10507			INTERNAL | FLAG_NO_DATA,
 10508			{ },
 10509			{ { 0, 1 } },
 10510			.fill_helper = bpf_fill_jmp_jlt_imm,
 10511			.nr_testruns = NR_PATTERN_RUNS,
 10512		},
 10513		{
 10514			"JMP_JLE_K: all immediate value magnitudes",
 10515			{ },
 10516			INTERNAL | FLAG_NO_DATA,
 10517			{ },
 10518			{ { 0, 1 } },
 10519			.fill_helper = bpf_fill_jmp_jle_imm,
 10520			.nr_testruns = NR_PATTERN_RUNS,
 10521		},
 10522		{
 10523			"JMP_JSGT_K: all immediate value magnitudes",
 10524			{ },
 10525			INTERNAL | FLAG_NO_DATA,
 10526			{ },
 10527			{ { 0, 1 } },
 10528			.fill_helper = bpf_fill_jmp_jsgt_imm,
 10529			.nr_testruns = NR_PATTERN_RUNS,
 10530		},
 10531		{
 10532			"JMP_JSGE_K: all immediate value magnitudes",
 10533			{ },
 10534			INTERNAL | FLAG_NO_DATA,
 10535			{ },
 10536			{ { 0, 1 } },
 10537			.fill_helper = bpf_fill_jmp_jsge_imm,
 10538			.nr_testruns = NR_PATTERN_RUNS,
 10539		},
 10540		{
 10541			"JMP_JSLT_K: all immediate value magnitudes",
 10542			{ },
 10543			INTERNAL | FLAG_NO_DATA,
 10544			{ },
 10545			{ { 0, 1 } },
 10546			.fill_helper = bpf_fill_jmp_jslt_imm,
 10547			.nr_testruns = NR_PATTERN_RUNS,
 10548		},
 10549		{
 10550			"JMP_JSLE_K: all immediate value magnitudes",
 10551			{ },
 10552			INTERNAL | FLAG_NO_DATA,
 10553			{ },
 10554			{ { 0, 1 } },
 10555			.fill_helper = bpf_fill_jmp_jsle_imm,
 10556			.nr_testruns = NR_PATTERN_RUNS,
 10557		},
 10558		/* JMP register magnitudes */
 10559		{
 10560			"JMP_JSET_X: all register value magnitudes",
 10561			{ },
 10562			INTERNAL | FLAG_NO_DATA,
 10563			{ },
 10564			{ { 0, 1 } },
 10565			.fill_helper = bpf_fill_jmp_jset_reg,
 10566			.nr_testruns = NR_PATTERN_RUNS,
 10567		},
 10568		{
 10569			"JMP_JEQ_X: all register value magnitudes",
 10570			{ },
 10571			INTERNAL | FLAG_NO_DATA,
 10572			{ },
 10573			{ { 0, 1 } },
 10574			.fill_helper = bpf_fill_jmp_jeq_reg,
 10575			.nr_testruns = NR_PATTERN_RUNS,
 10576		},
 10577		{
 10578			"JMP_JNE_X: all register value magnitudes",
 10579			{ },
 10580			INTERNAL | FLAG_NO_DATA,
 10581			{ },
 10582			{ { 0, 1 } },
 10583			.fill_helper = bpf_fill_jmp_jne_reg,
 10584			.nr_testruns = NR_PATTERN_RUNS,
 10585		},
 10586		{
 10587			"JMP_JGT_X: all register value magnitudes",
 10588			{ },
 10589			INTERNAL | FLAG_NO_DATA,
 10590			{ },
 10591			{ { 0, 1 } },
 10592			.fill_helper = bpf_fill_jmp_jgt_reg,
 10593			.nr_testruns = NR_PATTERN_RUNS,
 10594		},
 10595		{
 10596			"JMP_JGE_X: all register value magnitudes",
 10597			{ },
 10598			INTERNAL | FLAG_NO_DATA,
 10599			{ },
 10600			{ { 0, 1 } },
 10601			.fill_helper = bpf_fill_jmp_jge_reg,
 10602			.nr_testruns = NR_PATTERN_RUNS,
 10603		},
 10604		{
 10605			"JMP_JLT_X: all register value magnitudes",
 10606			{ },
 10607			INTERNAL | FLAG_NO_DATA,
 10608			{ },
 10609			{ { 0, 1 } },
 10610			.fill_helper = bpf_fill_jmp_jlt_reg,
 10611			.nr_testruns = NR_PATTERN_RUNS,
 10612		},
 10613		{
 10614			"JMP_JLE_X: all register value magnitudes",
 10615			{ },
 10616			INTERNAL | FLAG_NO_DATA,
 10617			{ },
 10618			{ { 0, 1 } },
 10619			.fill_helper = bpf_fill_jmp_jle_reg,
 10620			.nr_testruns = NR_PATTERN_RUNS,
 10621		},
 10622		{
 10623			"JMP_JSGT_X: all register value magnitudes",
 10624			{ },
 10625			INTERNAL | FLAG_NO_DATA,
 10626			{ },
 10627			{ { 0, 1 } },
 10628			.fill_helper = bpf_fill_jmp_jsgt_reg,
 10629			.nr_testruns = NR_PATTERN_RUNS,
 10630		},
 10631		{
 10632			"JMP_JSGE_X: all register value magnitudes",
 10633			{ },
 10634			INTERNAL | FLAG_NO_DATA,
 10635			{ },
 10636			{ { 0, 1 } },
 10637			.fill_helper = bpf_fill_jmp_jsge_reg,
 10638			.nr_testruns = NR_PATTERN_RUNS,
 10639		},
 10640		{
 10641			"JMP_JSLT_X: all register value magnitudes",
 10642			{ },
 10643			INTERNAL | FLAG_NO_DATA,
 10644			{ },
 10645			{ { 0, 1 } },
 10646			.fill_helper = bpf_fill_jmp_jslt_reg,
 10647			.nr_testruns = NR_PATTERN_RUNS,
 10648		},
 10649		{
 10650			"JMP_JSLE_X: all register value magnitudes",
 10651			{ },
 10652			INTERNAL | FLAG_NO_DATA,
 10653			{ },
 10654			{ { 0, 1 } },
 10655			.fill_helper = bpf_fill_jmp_jsle_reg,
 10656			.nr_testruns = NR_PATTERN_RUNS,
 10657		},
 10658		/* JMP32 immediate magnitudes */
 10659		{
 10660			"JMP32_JSET_K: all immediate value magnitudes",
 10661			{ },
 10662			INTERNAL | FLAG_NO_DATA,
 10663			{ },
 10664			{ { 0, 1 } },
 10665			.fill_helper = bpf_fill_jmp32_jset_imm,
 10666			.nr_testruns = NR_PATTERN_RUNS,
 10667		},
 10668		{
 10669			"JMP32_JEQ_K: all immediate value magnitudes",
 10670			{ },
 10671			INTERNAL | FLAG_NO_DATA,
 10672			{ },
 10673			{ { 0, 1 } },
 10674			.fill_helper = bpf_fill_jmp32_jeq_imm,
 10675			.nr_testruns = NR_PATTERN_RUNS,
 10676		},
 10677		{
 10678			"JMP32_JNE_K: all immediate value magnitudes",
 10679			{ },
 10680			INTERNAL | FLAG_NO_DATA,
 10681			{ },
 10682			{ { 0, 1 } },
 10683			.fill_helper = bpf_fill_jmp32_jne_imm,
 10684			.nr_testruns = NR_PATTERN_RUNS,
 10685		},
 10686		{
 10687			"JMP32_JGT_K: all immediate value magnitudes",
 10688			{ },
 10689			INTERNAL | FLAG_NO_DATA,
 10690			{ },
 10691			{ { 0, 1 } },
 10692			.fill_helper = bpf_fill_jmp32_jgt_imm,
 10693			.nr_testruns = NR_PATTERN_RUNS,
 10694		},
 10695		{
 10696			"JMP32_JGE_K: all immediate value magnitudes",
 10697			{ },
 10698			INTERNAL | FLAG_NO_DATA,
 10699			{ },
 10700			{ { 0, 1 } },
 10701			.fill_helper = bpf_fill_jmp32_jge_imm,
 10702			.nr_testruns = NR_PATTERN_RUNS,
 10703		},
 10704		{
 10705			"JMP32_JLT_K: all immediate value magnitudes",
 10706			{ },
 10707			INTERNAL | FLAG_NO_DATA,
 10708			{ },
 10709			{ { 0, 1 } },
 10710			.fill_helper = bpf_fill_jmp32_jlt_imm,
 10711			.nr_testruns = NR_PATTERN_RUNS,
 10712		},
 10713		{
 10714			"JMP32_JLE_K: all immediate value magnitudes",
 10715			{ },
 10716			INTERNAL | FLAG_NO_DATA,
 10717			{ },
 10718			{ { 0, 1 } },
 10719			.fill_helper = bpf_fill_jmp32_jle_imm,
 10720			.nr_testruns = NR_PATTERN_RUNS,
 10721		},
 10722		{
 10723			"JMP32_JSGT_K: all immediate value magnitudes",
 10724			{ },
 10725			INTERNAL | FLAG_NO_DATA,
 10726			{ },
 10727			{ { 0, 1 } },
 10728			.fill_helper = bpf_fill_jmp32_jsgt_imm,
 10729			.nr_testruns = NR_PATTERN_RUNS,
 10730		},
 10731		{
 10732			"JMP32_JSGE_K: all immediate value magnitudes",
 10733			{ },
 10734			INTERNAL | FLAG_NO_DATA,
 10735			{ },
 10736			{ { 0, 1 } },
 10737			.fill_helper = bpf_fill_jmp32_jsge_imm,
 10738			.nr_testruns = NR_PATTERN_RUNS,
 10739		},
 10740		{
 10741			"JMP32_JSLT_K: all immediate value magnitudes",
 10742			{ },
 10743			INTERNAL | FLAG_NO_DATA,
 10744			{ },
 10745			{ { 0, 1 } },
 10746			.fill_helper = bpf_fill_jmp32_jslt_imm,
 10747			.nr_testruns = NR_PATTERN_RUNS,
 10748		},
 10749		{
 10750			"JMP32_JSLE_K: all immediate value magnitudes",
 10751			{ },
 10752			INTERNAL | FLAG_NO_DATA,
 10753			{ },
 10754			{ { 0, 1 } },
 10755			.fill_helper = bpf_fill_jmp32_jsle_imm,
 10756			.nr_testruns = NR_PATTERN_RUNS,
 10757		},
 10758		/* JMP32 register magnitudes */
 10759		{
 10760			"JMP32_JSET_X: all register value magnitudes",
 10761			{ },
 10762			INTERNAL | FLAG_NO_DATA,
 10763			{ },
 10764			{ { 0, 1 } },
 10765			.fill_helper = bpf_fill_jmp32_jset_reg,
 10766			.nr_testruns = NR_PATTERN_RUNS,
 10767		},
 10768		{
 10769			"JMP32_JEQ_X: all register value magnitudes",
 10770			{ },
 10771			INTERNAL | FLAG_NO_DATA,
 10772			{ },
 10773			{ { 0, 1 } },
 10774			.fill_helper = bpf_fill_jmp32_jeq_reg,
 10775			.nr_testruns = NR_PATTERN_RUNS,
 10776		},
 10777		{
 10778			"JMP32_JNE_X: all register value magnitudes",
 10779			{ },
 10780			INTERNAL | FLAG_NO_DATA,
 10781			{ },
 10782			{ { 0, 1 } },
 10783			.fill_helper = bpf_fill_jmp32_jne_reg,
 10784			.nr_testruns = NR_PATTERN_RUNS,
 10785		},
 10786		{
 10787			"JMP32_JGT_X: all register value magnitudes",
 10788			{ },
 10789			INTERNAL | FLAG_NO_DATA,
 10790			{ },
 10791			{ { 0, 1 } },
 10792			.fill_helper = bpf_fill_jmp32_jgt_reg,
 10793			.nr_testruns = NR_PATTERN_RUNS,
 10794		},
 10795		{
 10796			"JMP32_JGE_X: all register value magnitudes",
 10797			{ },
 10798			INTERNAL | FLAG_NO_DATA,
 10799			{ },
 10800			{ { 0, 1 } },
 10801			.fill_helper = bpf_fill_jmp32_jge_reg,
 10802			.nr_testruns = NR_PATTERN_RUNS,
 10803		},
 10804		{
 10805			"JMP32_JLT_X: all register value magnitudes",
 10806			{ },
 10807			INTERNAL | FLAG_NO_DATA,
 10808			{ },
 10809			{ { 0, 1 } },
 10810			.fill_helper = bpf_fill_jmp32_jlt_reg,
 10811			.nr_testruns = NR_PATTERN_RUNS,
 10812		},
 10813		{
 10814			"JMP32_JLE_X: all register value magnitudes",
 10815			{ },
 10816			INTERNAL | FLAG_NO_DATA,
 10817			{ },
 10818			{ { 0, 1 } },
 10819			.fill_helper = bpf_fill_jmp32_jle_reg,
 10820			.nr_testruns = NR_PATTERN_RUNS,
 10821		},
 10822		{
 10823			"JMP32_JSGT_X: all register value magnitudes",
 10824			{ },
 10825			INTERNAL | FLAG_NO_DATA,
 10826			{ },
 10827			{ { 0, 1 } },
 10828			.fill_helper = bpf_fill_jmp32_jsgt_reg,
 10829			.nr_testruns = NR_PATTERN_RUNS,
 10830		},
 10831		{
 10832			"JMP32_JSGE_X: all register value magnitudes",
 10833			{ },
 10834			INTERNAL | FLAG_NO_DATA,
 10835			{ },
 10836			{ { 0, 1 } },
 10837			.fill_helper = bpf_fill_jmp32_jsge_reg,
 10838			.nr_testruns = NR_PATTERN_RUNS,
 10839		},
 10840		{
 10841			"JMP32_JSLT_X: all register value magnitudes",
 10842			{ },
 10843			INTERNAL | FLAG_NO_DATA,
 10844			{ },
 10845			{ { 0, 1 } },
 10846			.fill_helper = bpf_fill_jmp32_jslt_reg,
 10847			.nr_testruns = NR_PATTERN_RUNS,
 10848		},
 10849		{
 10850			"JMP32_JSLE_X: all register value magnitudes",
 10851			{ },
 10852			INTERNAL | FLAG_NO_DATA,
 10853			{ },
 10854			{ { 0, 1 } },
 10855			.fill_helper = bpf_fill_jmp32_jsle_reg,
 10856			.nr_testruns = NR_PATTERN_RUNS,
 10857		},
 10858		/* Conditional jumps with constant decision */
 10859		{
 10860			"JMP_JSET_K: imm = 0 -> never taken",
 10861			.u.insns_int = {
 10862				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10863				BPF_JMP_IMM(BPF_JSET, R1, 0, 1),
 10864				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10865				BPF_EXIT_INSN(),
 10866			},
 10867			INTERNAL | FLAG_NO_DATA,
 10868			{ },
 10869			{ { 0, 0 } },
 10870		},
 10871		{
 10872			"JMP_JLT_K: imm = 0 -> never taken",
 10873			.u.insns_int = {
 10874				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10875				BPF_JMP_IMM(BPF_JLT, R1, 0, 1),
 10876				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10877				BPF_EXIT_INSN(),
 10878			},
 10879			INTERNAL | FLAG_NO_DATA,
 10880			{ },
 10881			{ { 0, 0 } },
 10882		},
 10883		{
 10884			"JMP_JGE_K: imm = 0 -> always taken",
 10885			.u.insns_int = {
 10886				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10887				BPF_JMP_IMM(BPF_JGE, R1, 0, 1),
 10888				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10889				BPF_EXIT_INSN(),
 10890			},
 10891			INTERNAL | FLAG_NO_DATA,
 10892			{ },
 10893			{ { 0, 1 } },
 10894		},
 10895		{
 10896			"JMP_JGT_K: imm = 0xffffffff -> never taken",
 10897			.u.insns_int = {
 10898				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10899				BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1),
 10900				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10901				BPF_EXIT_INSN(),
 10902			},
 10903			INTERNAL | FLAG_NO_DATA,
 10904			{ },
 10905			{ { 0, 0 } },
 10906		},
 10907		{
 10908			"JMP_JLE_K: imm = 0xffffffff -> always taken",
 10909			.u.insns_int = {
 10910				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10911				BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1),
 10912				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10913				BPF_EXIT_INSN(),
 10914			},
 10915			INTERNAL | FLAG_NO_DATA,
 10916			{ },
 10917			{ { 0, 1 } },
 10918		},
 10919		{
 10920			"JMP32_JSGT_K: imm = 0x7fffffff -> never taken",
 10921			.u.insns_int = {
 10922				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10923				BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1),
 10924				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10925				BPF_EXIT_INSN(),
 10926			},
 10927			INTERNAL | FLAG_NO_DATA,
 10928			{ },
 10929			{ { 0, 0 } },
 10930		},
 10931		{
 10932			"JMP32_JSGE_K: imm = -0x80000000 -> always taken",
 10933			.u.insns_int = {
 10934				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10935				BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1),
 10936				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10937				BPF_EXIT_INSN(),
 10938			},
 10939			INTERNAL | FLAG_NO_DATA,
 10940			{ },
 10941			{ { 0, 1 } },
 10942		},
 10943		{
 10944			"JMP32_JSLT_K: imm = -0x80000000 -> never taken",
 10945			.u.insns_int = {
 10946				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10947				BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1),
 10948				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10949				BPF_EXIT_INSN(),
 10950			},
 10951			INTERNAL | FLAG_NO_DATA,
 10952			{ },
 10953			{ { 0, 0 } },
 10954		},
 10955		{
 10956			"JMP32_JSLE_K: imm = 0x7fffffff -> always taken",
 10957			.u.insns_int = {
 10958				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10959				BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1),
 10960				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10961				BPF_EXIT_INSN(),
 10962			},
 10963			INTERNAL | FLAG_NO_DATA,
 10964			{ },
 10965			{ { 0, 1 } },
 10966		},
 10967		{
 10968			"JMP_JEQ_X: dst = src -> always taken",
 10969			.u.insns_int = {
 10970				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10971				BPF_JMP_REG(BPF_JEQ, R1, R1, 1),
 10972				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10973				BPF_EXIT_INSN(),
 10974			},
 10975			INTERNAL | FLAG_NO_DATA,
 10976			{ },
 10977			{ { 0, 1 } },
 10978		},
 10979		{
 10980			"JMP_JGE_X: dst = src -> always taken",
 10981			.u.insns_int = {
 10982				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10983				BPF_JMP_REG(BPF_JGE, R1, R1, 1),
 10984				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10985				BPF_EXIT_INSN(),
 10986			},
 10987			INTERNAL | FLAG_NO_DATA,
 10988			{ },
 10989			{ { 0, 1 } },
 10990		},
 10991		{
 10992			"JMP_JLE_X: dst = src -> always taken",
 10993			.u.insns_int = {
 10994				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 10995				BPF_JMP_REG(BPF_JLE, R1, R1, 1),
 10996				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 10997				BPF_EXIT_INSN(),
 10998			},
 10999			INTERNAL | FLAG_NO_DATA,
 11000			{ },
 11001			{ { 0, 1 } },
 11002		},
 11003		{
 11004			"JMP_JSGE_X: dst = src -> always taken",
 11005			.u.insns_int = {
 11006				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 11007				BPF_JMP_REG(BPF_JSGE, R1, R1, 1),
 11008				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11009				BPF_EXIT_INSN(),
 11010			},
 11011			INTERNAL | FLAG_NO_DATA,
 11012			{ },
 11013			{ { 0, 1 } },
 11014		},
 11015		{
 11016			"JMP_JSLE_X: dst = src -> always taken",
 11017			.u.insns_int = {
 11018				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 11019				BPF_JMP_REG(BPF_JSLE, R1, R1, 1),
 11020				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11021				BPF_EXIT_INSN(),
 11022			},
 11023			INTERNAL | FLAG_NO_DATA,
 11024			{ },
 11025			{ { 0, 1 } },
 11026		},
 11027		{
 11028			"JMP_JNE_X: dst = src -> never taken",
 11029			.u.insns_int = {
 11030				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 11031				BPF_JMP_REG(BPF_JNE, R1, R1, 1),
 11032				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11033				BPF_EXIT_INSN(),
 11034			},
 11035			INTERNAL | FLAG_NO_DATA,
 11036			{ },
 11037			{ { 0, 0 } },
 11038		},
 11039		{
 11040			"JMP_JGT_X: dst = src -> never taken",
 11041			.u.insns_int = {
 11042				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 11043				BPF_JMP_REG(BPF_JGT, R1, R1, 1),
 11044				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11045				BPF_EXIT_INSN(),
 11046			},
 11047			INTERNAL | FLAG_NO_DATA,
 11048			{ },
 11049			{ { 0, 0 } },
 11050		},
 11051		{
 11052			"JMP_JLT_X: dst = src -> never taken",
 11053			.u.insns_int = {
 11054				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 11055				BPF_JMP_REG(BPF_JLT, R1, R1, 1),
 11056				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11057				BPF_EXIT_INSN(),
 11058			},
 11059			INTERNAL | FLAG_NO_DATA,
 11060			{ },
 11061			{ { 0, 0 } },
 11062		},
 11063		{
 11064			"JMP_JSGT_X: dst = src -> never taken",
 11065			.u.insns_int = {
 11066				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 11067				BPF_JMP_REG(BPF_JSGT, R1, R1, 1),
 11068				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11069				BPF_EXIT_INSN(),
 11070			},
 11071			INTERNAL | FLAG_NO_DATA,
 11072			{ },
 11073			{ { 0, 0 } },
 11074		},
 11075		{
 11076			"JMP_JSLT_X: dst = src -> never taken",
 11077			.u.insns_int = {
 11078				BPF_ALU64_IMM(BPF_MOV, R0, 1),
 11079				BPF_JMP_REG(BPF_JSLT, R1, R1, 1),
 11080				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11081				BPF_EXIT_INSN(),
 11082			},
 11083			INTERNAL | FLAG_NO_DATA,
 11084			{ },
 11085			{ { 0, 0 } },
 11086		},
 11087		/* Short relative jumps */
 11088		{
 11089			"Short relative jump: offset=0",
 11090			.u.insns_int = {
 11091				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11092				BPF_JMP_IMM(BPF_JEQ, R0, 0, 0),
 11093				BPF_EXIT_INSN(),
 11094				BPF_ALU32_IMM(BPF_MOV, R0, -1),
 11095			},
 11096			INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
 11097			{ },
 11098			{ { 0, 0 } },
 11099		},
 11100		{
 11101			"Short relative jump: offset=1",
 11102			.u.insns_int = {
 11103				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11104				BPF_JMP_IMM(BPF_JEQ, R0, 0, 1),
 11105				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11106				BPF_EXIT_INSN(),
 11107				BPF_ALU32_IMM(BPF_MOV, R0, -1),
 11108			},
 11109			INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
 11110			{ },
 11111			{ { 0, 0 } },
 11112		},
 11113		{
 11114			"Short relative jump: offset=2",
 11115			.u.insns_int = {
 11116				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11117				BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
 11118				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11119				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11120				BPF_EXIT_INSN(),
 11121				BPF_ALU32_IMM(BPF_MOV, R0, -1),
 11122			},
 11123			INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
 11124			{ },
 11125			{ { 0, 0 } },
 11126		},
 11127		{
 11128			"Short relative jump: offset=3",
 11129			.u.insns_int = {
 11130				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11131				BPF_JMP_IMM(BPF_JEQ, R0, 0, 3),
 11132				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11133				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11134				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11135				BPF_EXIT_INSN(),
 11136				BPF_ALU32_IMM(BPF_MOV, R0, -1),
 11137			},
 11138			INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
 11139			{ },
 11140			{ { 0, 0 } },
 11141		},
 11142		{
 11143			"Short relative jump: offset=4",
 11144			.u.insns_int = {
 11145				BPF_ALU64_IMM(BPF_MOV, R0, 0),
 11146				BPF_JMP_IMM(BPF_JEQ, R0, 0, 4),
 11147				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11148				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11149				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11150				BPF_ALU32_IMM(BPF_ADD, R0, 1),
 11151				BPF_EXIT_INSN(),
 11152				BPF_ALU32_IMM(BPF_MOV, R0, -1),
 11153			},
 11154			INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT,
 11155			{ },
 11156			{ { 0, 0 } },
 11157		},
 11158		/* Conditional branch conversions */
 11159		{
 11160			"Long conditional jump: taken at runtime",
 11161			{ },
 11162			INTERNAL | FLAG_NO_DATA,
 11163			{ },
 11164			{ { 0, 1 } },
 11165			.fill_helper = bpf_fill_max_jmp_taken,
 11166		},
 11167		{
 11168			"Long conditional jump: not taken at runtime",
 11169			{ },
 11170			INTERNAL | FLAG_NO_DATA,
 11171			{ },
 11172			{ { 0, 2 } },
 11173			.fill_helper = bpf_fill_max_jmp_not_taken,
 11174		},
 11175		{
 11176			"Long conditional jump: always taken, known at JIT time",
 11177			{ },
 11178			INTERNAL | FLAG_NO_DATA,
 11179			{ },
 11180			{ { 0, 1 } },
 11181			.fill_helper = bpf_fill_max_jmp_always_taken,
 11182		},
 11183		{
 11184			"Long conditional jump: never taken, known at JIT time",
 11185			{ },
 11186			INTERNAL | FLAG_NO_DATA,
 11187			{ },
 11188			{ { 0, 2 } },
 11189			.fill_helper = bpf_fill_max_jmp_never_taken,
 11190		},
 11191		/* Staggered jump sequences, immediate */
 11192		{
 11193			"Staggered jumps: JMP_JA",
 11194			{ },
 11195			INTERNAL | FLAG_NO_DATA,
 11196			{ },
 11197			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11198			.fill_helper = bpf_fill_staggered_ja,
 11199			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11200		},
 11201		{
 11202			"Staggered jumps: JMP_JEQ_K",
 11203			{ },
 11204			INTERNAL | FLAG_NO_DATA,
 11205			{ },
 11206			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11207			.fill_helper = bpf_fill_staggered_jeq_imm,
 11208			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11209		},
 11210		{
 11211			"Staggered jumps: JMP_JNE_K",
 11212			{ },
 11213			INTERNAL | FLAG_NO_DATA,
 11214			{ },
 11215			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11216			.fill_helper = bpf_fill_staggered_jne_imm,
 11217			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11218		},
 11219		{
 11220			"Staggered jumps: JMP_JSET_K",
 11221			{ },
 11222			INTERNAL | FLAG_NO_DATA,
 11223			{ },
 11224			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11225			.fill_helper = bpf_fill_staggered_jset_imm,
 11226			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11227		},
 11228		{
 11229			"Staggered jumps: JMP_JGT_K",
 11230			{ },
 11231			INTERNAL | FLAG_NO_DATA,
 11232			{ },
 11233			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11234			.fill_helper = bpf_fill_staggered_jgt_imm,
 11235			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11236		},
 11237		{
 11238			"Staggered jumps: JMP_JGE_K",
 11239			{ },
 11240			INTERNAL | FLAG_NO_DATA,
 11241			{ },
 11242			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11243			.fill_helper = bpf_fill_staggered_jge_imm,
 11244			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11245		},
 11246		{
 11247			"Staggered jumps: JMP_JLT_K",
 11248			{ },
 11249			INTERNAL | FLAG_NO_DATA,
 11250			{ },
 11251			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11252			.fill_helper = bpf_fill_staggered_jlt_imm,
 11253			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11254		},
 11255		{
 11256			"Staggered jumps: JMP_JLE_K",
 11257			{ },
 11258			INTERNAL | FLAG_NO_DATA,
 11259			{ },
 11260			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11261			.fill_helper = bpf_fill_staggered_jle_imm,
 11262			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11263		},
 11264		{
 11265			"Staggered jumps: JMP_JSGT_K",
 11266			{ },
 11267			INTERNAL | FLAG_NO_DATA,
 11268			{ },
 11269			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11270			.fill_helper = bpf_fill_staggered_jsgt_imm,
 11271			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11272		},
 11273		{
 11274			"Staggered jumps: JMP_JSGE_K",
 11275			{ },
 11276			INTERNAL | FLAG_NO_DATA,
 11277			{ },
 11278			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11279			.fill_helper = bpf_fill_staggered_jsge_imm,
 11280			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11281		},
 11282		{
 11283			"Staggered jumps: JMP_JSLT_K",
 11284			{ },
 11285			INTERNAL | FLAG_NO_DATA,
 11286			{ },
 11287			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11288			.fill_helper = bpf_fill_staggered_jslt_imm,
 11289			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11290		},
 11291		{
 11292			"Staggered jumps: JMP_JSLE_K",
 11293			{ },
 11294			INTERNAL | FLAG_NO_DATA,
 11295			{ },
 11296			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11297			.fill_helper = bpf_fill_staggered_jsle_imm,
 11298			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11299		},
 11300		/* Staggered jump sequences, register */
 11301		{
 11302			"Staggered jumps: JMP_JEQ_X",
 11303			{ },
 11304			INTERNAL | FLAG_NO_DATA,
 11305			{ },
 11306			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11307			.fill_helper = bpf_fill_staggered_jeq_reg,
 11308			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11309		},
 11310		{
 11311			"Staggered jumps: JMP_JNE_X",
 11312			{ },
 11313			INTERNAL | FLAG_NO_DATA,
 11314			{ },
 11315			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11316			.fill_helper = bpf_fill_staggered_jne_reg,
 11317			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11318		},
 11319		{
 11320			"Staggered jumps: JMP_JSET_X",
 11321			{ },
 11322			INTERNAL | FLAG_NO_DATA,
 11323			{ },
 11324			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11325			.fill_helper = bpf_fill_staggered_jset_reg,
 11326			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11327		},
 11328		{
 11329			"Staggered jumps: JMP_JGT_X",
 11330			{ },
 11331			INTERNAL | FLAG_NO_DATA,
 11332			{ },
 11333			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11334			.fill_helper = bpf_fill_staggered_jgt_reg,
 11335			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11336		},
 11337		{
 11338			"Staggered jumps: JMP_JGE_X",
 11339			{ },
 11340			INTERNAL | FLAG_NO_DATA,
 11341			{ },
 11342			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11343			.fill_helper = bpf_fill_staggered_jge_reg,
 11344			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11345		},
 11346		{
 11347			"Staggered jumps: JMP_JLT_X",
 11348			{ },
 11349			INTERNAL | FLAG_NO_DATA,
 11350			{ },
 11351			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11352			.fill_helper = bpf_fill_staggered_jlt_reg,
 11353			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11354		},
 11355		{
 11356			"Staggered jumps: JMP_JLE_X",
 11357			{ },
 11358			INTERNAL | FLAG_NO_DATA,
 11359			{ },
 11360			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11361			.fill_helper = bpf_fill_staggered_jle_reg,
 11362			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11363		},
 11364		{
 11365			"Staggered jumps: JMP_JSGT_X",
 11366			{ },
 11367			INTERNAL | FLAG_NO_DATA,
 11368			{ },
 11369			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11370			.fill_helper = bpf_fill_staggered_jsgt_reg,
 11371			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11372		},
 11373		{
 11374			"Staggered jumps: JMP_JSGE_X",
 11375			{ },
 11376			INTERNAL | FLAG_NO_DATA,
 11377			{ },
 11378			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11379			.fill_helper = bpf_fill_staggered_jsge_reg,
 11380			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11381		},
 11382		{
 11383			"Staggered jumps: JMP_JSLT_X",
 11384			{ },
 11385			INTERNAL | FLAG_NO_DATA,
 11386			{ },
 11387			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11388			.fill_helper = bpf_fill_staggered_jslt_reg,
 11389			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11390		},
 11391		{
 11392			"Staggered jumps: JMP_JSLE_X",
 11393			{ },
 11394			INTERNAL | FLAG_NO_DATA,
 11395			{ },
 11396			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11397			.fill_helper = bpf_fill_staggered_jsle_reg,
 11398			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11399		},
 11400		/* Staggered jump sequences, JMP32 immediate */
 11401		{
 11402			"Staggered jumps: JMP32_JEQ_K",
 11403			{ },
 11404			INTERNAL | FLAG_NO_DATA,
 11405			{ },
 11406			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11407			.fill_helper = bpf_fill_staggered_jeq32_imm,
 11408			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11409		},
 11410		{
 11411			"Staggered jumps: JMP32_JNE_K",
 11412			{ },
 11413			INTERNAL | FLAG_NO_DATA,
 11414			{ },
 11415			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11416			.fill_helper = bpf_fill_staggered_jne32_imm,
 11417			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11418		},
 11419		{
 11420			"Staggered jumps: JMP32_JSET_K",
 11421			{ },
 11422			INTERNAL | FLAG_NO_DATA,
 11423			{ },
 11424			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11425			.fill_helper = bpf_fill_staggered_jset32_imm,
 11426			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11427		},
 11428		{
 11429			"Staggered jumps: JMP32_JGT_K",
 11430			{ },
 11431			INTERNAL | FLAG_NO_DATA,
 11432			{ },
 11433			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11434			.fill_helper = bpf_fill_staggered_jgt32_imm,
 11435			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11436		},
 11437		{
 11438			"Staggered jumps: JMP32_JGE_K",
 11439			{ },
 11440			INTERNAL | FLAG_NO_DATA,
 11441			{ },
 11442			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11443			.fill_helper = bpf_fill_staggered_jge32_imm,
 11444			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11445		},
 11446		{
 11447			"Staggered jumps: JMP32_JLT_K",
 11448			{ },
 11449			INTERNAL | FLAG_NO_DATA,
 11450			{ },
 11451			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11452			.fill_helper = bpf_fill_staggered_jlt32_imm,
 11453			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11454		},
 11455		{
 11456			"Staggered jumps: JMP32_JLE_K",
 11457			{ },
 11458			INTERNAL | FLAG_NO_DATA,
 11459			{ },
 11460			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11461			.fill_helper = bpf_fill_staggered_jle32_imm,
 11462			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11463		},
 11464		{
 11465			"Staggered jumps: JMP32_JSGT_K",
 11466			{ },
 11467			INTERNAL | FLAG_NO_DATA,
 11468			{ },
 11469			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11470			.fill_helper = bpf_fill_staggered_jsgt32_imm,
 11471			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11472		},
 11473		{
 11474			"Staggered jumps: JMP32_JSGE_K",
 11475			{ },
 11476			INTERNAL | FLAG_NO_DATA,
 11477			{ },
 11478			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11479			.fill_helper = bpf_fill_staggered_jsge32_imm,
 11480			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11481		},
 11482		{
 11483			"Staggered jumps: JMP32_JSLT_K",
 11484			{ },
 11485			INTERNAL | FLAG_NO_DATA,
 11486			{ },
 11487			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11488			.fill_helper = bpf_fill_staggered_jslt32_imm,
 11489			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11490		},
 11491		{
 11492			"Staggered jumps: JMP32_JSLE_K",
 11493			{ },
 11494			INTERNAL | FLAG_NO_DATA,
 11495			{ },
 11496			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11497			.fill_helper = bpf_fill_staggered_jsle32_imm,
 11498			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11499		},
 11500		/* Staggered jump sequences, JMP32 register */
 11501		{
 11502			"Staggered jumps: JMP32_JEQ_X",
 11503			{ },
 11504			INTERNAL | FLAG_NO_DATA,
 11505			{ },
 11506			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11507			.fill_helper = bpf_fill_staggered_jeq32_reg,
 11508			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11509		},
 11510		{
 11511			"Staggered jumps: JMP32_JNE_X",
 11512			{ },
 11513			INTERNAL | FLAG_NO_DATA,
 11514			{ },
 11515			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11516			.fill_helper = bpf_fill_staggered_jne32_reg,
 11517			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11518		},
 11519		{
 11520			"Staggered jumps: JMP32_JSET_X",
 11521			{ },
 11522			INTERNAL | FLAG_NO_DATA,
 11523			{ },
 11524			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11525			.fill_helper = bpf_fill_staggered_jset32_reg,
 11526			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11527		},
 11528		{
 11529			"Staggered jumps: JMP32_JGT_X",
 11530			{ },
 11531			INTERNAL | FLAG_NO_DATA,
 11532			{ },
 11533			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11534			.fill_helper = bpf_fill_staggered_jgt32_reg,
 11535			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11536		},
 11537		{
 11538			"Staggered jumps: JMP32_JGE_X",
 11539			{ },
 11540			INTERNAL | FLAG_NO_DATA,
 11541			{ },
 11542			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11543			.fill_helper = bpf_fill_staggered_jge32_reg,
 11544			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11545		},
 11546		{
 11547			"Staggered jumps: JMP32_JLT_X",
 11548			{ },
 11549			INTERNAL | FLAG_NO_DATA,
 11550			{ },
 11551			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11552			.fill_helper = bpf_fill_staggered_jlt32_reg,
 11553			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11554		},
 11555		{
 11556			"Staggered jumps: JMP32_JLE_X",
 11557			{ },
 11558			INTERNAL | FLAG_NO_DATA,
 11559			{ },
 11560			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11561			.fill_helper = bpf_fill_staggered_jle32_reg,
 11562			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11563		},
 11564		{
 11565			"Staggered jumps: JMP32_JSGT_X",
 11566			{ },
 11567			INTERNAL | FLAG_NO_DATA,
 11568			{ },
 11569			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11570			.fill_helper = bpf_fill_staggered_jsgt32_reg,
 11571			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11572		},
 11573		{
 11574			"Staggered jumps: JMP32_JSGE_X",
 11575			{ },
 11576			INTERNAL | FLAG_NO_DATA,
 11577			{ },
 11578			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11579			.fill_helper = bpf_fill_staggered_jsge32_reg,
 11580			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11581		},
 11582		{
 11583			"Staggered jumps: JMP32_JSLT_X",
 11584			{ },
 11585			INTERNAL | FLAG_NO_DATA,
 11586			{ },
 11587			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11588			.fill_helper = bpf_fill_staggered_jslt32_reg,
 11589			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11590		},
 11591		{
 11592			"Staggered jumps: JMP32_JSLE_X",
 11593			{ },
 11594			INTERNAL | FLAG_NO_DATA,
 11595			{ },
 11596			{ { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
 11597			.fill_helper = bpf_fill_staggered_jsle32_reg,
 11598			.nr_testruns = NR_STAGGERED_JMP_RUNS,
 11599		},
 11600	};
 11601	

-- 
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki

Powered by blists - more mailing lists