tools/testing/selftests/bpf/verifier/jmp32.c

   1 {
   2         "jset32: BPF_K",
   3         .insns = {
   4         BPF_DIRECT_PKT_R2,
   5         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
   6         /* reg, high bits shouldn't be tested */
   7         BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, -2, 1),
   8         BPF_JMP_IMM(BPF_JA, 0, 0, 1),
   9         BPF_EXIT_INSN(),
  10
  11         BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 1, 1),
  12         BPF_EXIT_INSN(),
  13         BPF_MOV64_IMM(BPF_REG_0, 2),
  14         BPF_EXIT_INSN(),
  15         },
  16         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
  17         .result = ACCEPT,
  18         .runs = 3,
  19         .retvals = {
  20                 { .retval = 0,
  21                   .data64 = { 1ULL << 63, }
  22                 },
  23                 { .retval = 2,
  24                   .data64 = { 1, }
  25                 },
  26                 { .retval = 2,
  27                   .data64 = { 1ULL << 63 | 1, }
  28                 },
  29         },
  30         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
  31 },
  32 {
  33         "jset32: BPF_X",
  34         .insns = {
  35         BPF_DIRECT_PKT_R2,
  36         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
  37         BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
  38         BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
  39         BPF_JMP_IMM(BPF_JA, 0, 0, 1),
  40         BPF_EXIT_INSN(),
  41
  42         BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
  43         BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
  44         BPF_EXIT_INSN(),
  45         BPF_MOV64_IMM(BPF_REG_0, 2),
  46         BPF_EXIT_INSN(),
  47         },
  48         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
  49         .result = ACCEPT,
  50         .runs = 3,
  51         .retvals = {
  52                 { .retval = 0,
  53                   .data64 = { 1ULL << 63, }
  54                 },
  55                 { .retval = 2,
  56                   .data64 = { 1, }
  57                 },
  58                 { .retval = 2,
  59                   .data64 = { 1ULL << 63 | 1, }
  60                 },
  61         },
  62         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
  63 },
  64 {
  65         "jset32: min/max deduction",
  66         .insns = {
  67         BPF_RAND_UEXT_R7,
  68         BPF_MOV64_IMM(BPF_REG_0, 0),
  69         BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 0x10, 1),
  70         BPF_EXIT_INSN(),
  71         BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x10, 1),
  72         BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
  73         BPF_EXIT_INSN(),
  74         },
  75         .result = ACCEPT,
  76 },
  77 {
  78         "jeq32: BPF_K",
  79         .insns = {
  80         BPF_DIRECT_PKT_R2,
  81         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
  82         BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, -1, 1),
  83         BPF_EXIT_INSN(),
  84         BPF_MOV64_IMM(BPF_REG_0, 2),
  85         BPF_EXIT_INSN(),
  86         },
  87         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
  88         .result = ACCEPT,
  89         .runs = 2,
  90         .retvals = {
  91                 { .retval = 0,
  92                   .data64 = { -2, }
  93                 },
  94                 { .retval = 2,
  95                   .data64 = { -1, }
  96                 },
  97         },
  98         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
  99 },
 100 {
 101         "jeq32: BPF_X",
 102         .insns = {
 103         BPF_DIRECT_PKT_R2,
 104         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 105         BPF_LD_IMM64(BPF_REG_8, 0x7000000000000001),
 106         BPF_JMP32_REG(BPF_JEQ, BPF_REG_7, BPF_REG_8, 1),
 107         BPF_EXIT_INSN(),
 108         BPF_MOV64_IMM(BPF_REG_0, 2),
 109         BPF_EXIT_INSN(),
 110         },
 111         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 112         .result = ACCEPT,
 113         .runs = 3,
 114         .retvals = {
 115                 { .retval = 0,
 116                   .data64 = { 2, }
 117                 },
 118                 { .retval = 2,
 119                   .data64 = { 1, }
 120                 },
 121                 { .retval = 2,
 122                   .data64 = { 1ULL << 63 | 1, }
 123                 },
 124         },
 125         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 126 },
 127 {
 128         "jeq32: min/max deduction",
 129         .insns = {
 130         BPF_RAND_UEXT_R7,
 131         BPF_MOV64_IMM(BPF_REG_0, 0),
 132         BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, 0x10, 1),
 133         BPF_EXIT_INSN(),
 134         BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, 0xf, 1),
 135         BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
 136         BPF_EXIT_INSN(),
 137         },
 138         .result = ACCEPT,
 139 },
 140 {
 141         "jne32: BPF_K",
 142         .insns = {
 143         BPF_DIRECT_PKT_R2,
 144         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 145         BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, -1, 1),
 146         BPF_EXIT_INSN(),
 147         BPF_MOV64_IMM(BPF_REG_0, 2),
 148         BPF_EXIT_INSN(),
 149         },
 150         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 151         .result = ACCEPT,
 152         .runs = 2,
 153         .retvals = {
 154                 { .retval = 2,
 155                   .data64 = { 1, }
 156                 },
 157                 { .retval = 0,
 158                   .data64 = { -1, }
 159                 },
 160         },
 161         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 162 },
 163 {
 164         "jne32: BPF_X",
 165         .insns = {
 166         BPF_DIRECT_PKT_R2,
 167         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 168         BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
 169         BPF_JMP32_REG(BPF_JNE, BPF_REG_7, BPF_REG_8, 1),
 170         BPF_EXIT_INSN(),
 171         BPF_MOV64_IMM(BPF_REG_0, 2),
 172         BPF_EXIT_INSN(),
 173         },
 174         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 175         .result = ACCEPT,
 176         .runs = 3,
 177         .retvals = {
 178                 { .retval = 0,
 179                   .data64 = { 1, }
 180                 },
 181                 { .retval = 2,
 182                   .data64 = { 2, }
 183                 },
 184                 { .retval = 2,
 185                   .data64 = { 1ULL << 63 | 2, }
 186                 },
 187         },
 188         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 189 },
 190 {
 191         "jne32: min/max deduction",
 192         .insns = {
 193         BPF_RAND_UEXT_R7,
 194         BPF_MOV64_IMM(BPF_REG_0, 0),
 195         BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
 196         BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
 197         BPF_EXIT_INSN(),
 198         BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
 199         BPF_EXIT_INSN(),
 200         },
 201         .result = ACCEPT,
 202 },
 203 {
 204         "jge32: BPF_K",
 205         .insns = {
 206         BPF_DIRECT_PKT_R2,
 207         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 208         BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, UINT_MAX - 1, 1),
 209         BPF_EXIT_INSN(),
 210         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 211         BPF_EXIT_INSN(),
 212         },
 213         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 214         .result = ACCEPT,
 215         .runs = 3,
 216         .retvals = {
 217                 { .retval = 2,
 218                   .data64 = { UINT_MAX, }
 219                 },
 220                 { .retval = 2,
 221                   .data64 = { UINT_MAX - 1, }
 222                 },
 223                 { .retval = 0,
 224                   .data64 = { 0, }
 225                 },
 226         },
 227         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 228 },
 229 {
 230         "jge32: BPF_X",
 231         .insns = {
 232         BPF_DIRECT_PKT_R2,
 233         BPF_LD_IMM64(BPF_REG_8, UINT_MAX | 1ULL << 32),
 234         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 235         BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
 236         BPF_EXIT_INSN(),
 237         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 238         BPF_EXIT_INSN(),
 239         },
 240         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 241         .result = ACCEPT,
 242         .runs = 3,
 243         .retvals = {
 244                 { .retval = 2,
 245                   .data64 = { UINT_MAX, }
 246                 },
 247                 { .retval = 0,
 248                   .data64 = { INT_MAX, }
 249                 },
 250                 { .retval = 0,
 251                   .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
 252                 },
 253         },
 254         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 255 },
 256 {
 257         "jge32: min/max deduction",
 258         .insns = {
 259         BPF_RAND_UEXT_R7,
 260         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 261         BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
 262         BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
 263         BPF_EXIT_INSN(),
 264         BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x7ffffff0, 1),
 265         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
 266         BPF_EXIT_INSN(),
 267         },
 268         .result = ACCEPT,
 269         .retval = 2,
 270 },
 271 {
 272         "jgt32: BPF_K",
 273         .insns = {
 274         BPF_DIRECT_PKT_R2,
 275         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 276         BPF_JMP32_IMM(BPF_JGT, BPF_REG_7, UINT_MAX - 1, 1),
 277         BPF_EXIT_INSN(),
 278         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 279         BPF_EXIT_INSN(),
 280         },
 281         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 282         .result = ACCEPT,
 283         .runs = 3,
 284         .retvals = {
 285                 { .retval = 2,
 286                   .data64 = { UINT_MAX, }
 287                 },
 288                 { .retval = 0,
 289                   .data64 = { UINT_MAX - 1, }
 290                 },
 291                 { .retval = 0,
 292                   .data64 = { 0, }
 293                 },
 294         },
 295         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 296 },
 297 {
 298         "jgt32: BPF_X",
 299         .insns = {
 300         BPF_DIRECT_PKT_R2,
 301         BPF_LD_IMM64(BPF_REG_8, (UINT_MAX - 1) | 1ULL << 32),
 302         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 303         BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
 304         BPF_EXIT_INSN(),
 305         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 306         BPF_EXIT_INSN(),
 307         },
 308         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 309         .result = ACCEPT,
 310         .runs = 3,
 311         .retvals = {
 312                 { .retval = 2,
 313                   .data64 = { UINT_MAX, }
 314                 },
 315                 { .retval = 0,
 316                   .data64 = { UINT_MAX - 1, }
 317                 },
 318                 { .retval = 0,
 319                   .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
 320                 },
 321         },
 322         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 323 },
 324 {
 325         "jgt32: min/max deduction",
 326         .insns = {
 327         BPF_RAND_UEXT_R7,
 328         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 329         BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
 330         BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
 331         BPF_EXIT_INSN(),
 332         BPF_JMP_IMM(BPF_JGT, BPF_REG_7, 0x7ffffff0, 1),
 333         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
 334         BPF_EXIT_INSN(),
 335         },
 336         .result = ACCEPT,
 337         .retval = 2,
 338 },
 339 {
 340         "jle32: BPF_K",
 341         .insns = {
 342         BPF_DIRECT_PKT_R2,
 343         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 344         BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, INT_MAX, 1),
 345         BPF_EXIT_INSN(),
 346         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 347         BPF_EXIT_INSN(),
 348         },
 349         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 350         .result = ACCEPT,
 351         .runs = 3,
 352         .retvals = {
 353                 { .retval = 2,
 354                   .data64 = { INT_MAX - 1, }
 355                 },
 356                 { .retval = 0,
 357                   .data64 = { UINT_MAX, }
 358                 },
 359                 { .retval = 2,
 360                   .data64 = { INT_MAX, }
 361                 },
 362         },
 363         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 364 },
 365 {
 366         "jle32: BPF_X",
 367         .insns = {
 368         BPF_DIRECT_PKT_R2,
 369         BPF_LD_IMM64(BPF_REG_8, (INT_MAX - 1) | 2ULL << 32),
 370         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 371         BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
 372         BPF_EXIT_INSN(),
 373         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 374         BPF_EXIT_INSN(),
 375         },
 376         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 377         .result = ACCEPT,
 378         .runs = 3,
 379         .retvals = {
 380                 { .retval = 0,
 381                   .data64 = { INT_MAX | 1ULL << 32, }
 382                 },
 383                 { .retval = 2,
 384                   .data64 = { INT_MAX - 2, }
 385                 },
 386                 { .retval = 0,
 387                   .data64 = { UINT_MAX, }
 388                 },
 389         },
 390         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 391 },
 392 {
 393         "jle32: min/max deduction",
 394         .insns = {
 395         BPF_RAND_UEXT_R7,
 396         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 397         BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
 398         BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
 399         BPF_EXIT_INSN(),
 400         BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, 0x7ffffff0, 1),
 401         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
 402         BPF_EXIT_INSN(),
 403         },
 404         .result = ACCEPT,
 405         .retval = 2,
 406 },
 407 {
 408         "jlt32: BPF_K",
 409         .insns = {
 410         BPF_DIRECT_PKT_R2,
 411         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 412         BPF_JMP32_IMM(BPF_JLT, BPF_REG_7, INT_MAX, 1),
 413         BPF_EXIT_INSN(),
 414         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 415         BPF_EXIT_INSN(),
 416         },
 417         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 418         .result = ACCEPT,
 419         .runs = 3,
 420         .retvals = {
 421                 { .retval = 0,
 422                   .data64 = { INT_MAX, }
 423                 },
 424                 { .retval = 0,
 425                   .data64 = { UINT_MAX, }
 426                 },
 427                 { .retval = 2,
 428                   .data64 = { INT_MAX - 1, }
 429                 },
 430         },
 431         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 432 },
 433 {
 434         "jlt32: BPF_X",
 435         .insns = {
 436         BPF_DIRECT_PKT_R2,
 437         BPF_LD_IMM64(BPF_REG_8, INT_MAX | 2ULL << 32),
 438         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 439         BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
 440         BPF_EXIT_INSN(),
 441         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 442         BPF_EXIT_INSN(),
 443         },
 444         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 445         .result = ACCEPT,
 446         .runs = 3,
 447         .retvals = {
 448                 { .retval = 0,
 449                   .data64 = { INT_MAX | 1ULL << 32, }
 450                 },
 451                 { .retval = 0,
 452                   .data64 = { UINT_MAX, }
 453                 },
 454                 { .retval = 2,
 455                   .data64 = { (INT_MAX - 1) | 3ULL << 32, }
 456                 },
 457         },
 458         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 459 },
 460 {
 461         "jlt32: min/max deduction",
 462         .insns = {
 463         BPF_RAND_UEXT_R7,
 464         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 465         BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
 466         BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
 467         BPF_EXIT_INSN(),
 468         BPF_JMP_IMM(BPF_JSLT, BPF_REG_7, 0x7ffffff0, 1),
 469         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
 470         BPF_EXIT_INSN(),
 471         },
 472         .result = ACCEPT,
 473         .retval = 2,
 474 },
 475 {
 476         "jsge32: BPF_K",
 477         .insns = {
 478         BPF_DIRECT_PKT_R2,
 479         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 480         BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, -1, 1),
 481         BPF_EXIT_INSN(),
 482         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 483         BPF_EXIT_INSN(),
 484         },
 485         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 486         .result = ACCEPT,
 487         .runs = 3,
 488         .retvals = {
 489                 { .retval = 2,
 490                   .data64 = { 0, }
 491                 },
 492                 { .retval = 2,
 493                   .data64 = { -1, }
 494                 },
 495                 { .retval = 0,
 496                   .data64 = { -2, }
 497                 },
 498         },
 499         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 500 },
 501 {
 502         "jsge32: BPF_X",
 503         .insns = {
 504         BPF_DIRECT_PKT_R2,
 505         BPF_LD_IMM64(BPF_REG_8, (__u32)-1 | 2ULL << 32),
 506         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 507         BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
 508         BPF_EXIT_INSN(),
 509         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 510         BPF_EXIT_INSN(),
 511         },
 512         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 513         .result = ACCEPT,
 514         .runs = 3,
 515         .retvals = {
 516                 { .retval = 2,
 517                   .data64 = { -1, }
 518                 },
 519                 { .retval = 2,
 520                   .data64 = { 0x7fffffff | 1ULL << 32, }
 521                 },
 522                 { .retval = 0,
 523                   .data64 = { -2, }
 524                 },
 525         },
 526         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 527 },
 528 {
 529         "jsge32: min/max deduction",
 530         .insns = {
 531         BPF_RAND_UEXT_R7,
 532         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 533         BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
 534         BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
 535         BPF_EXIT_INSN(),
 536         BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0x7ffffff0, 1),
 537         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
 538         BPF_EXIT_INSN(),
 539         },
 540         .result = ACCEPT,
 541         .retval = 2,
 542 },
 543 {
 544         "jsgt32: BPF_K",
 545         .insns = {
 546         BPF_DIRECT_PKT_R2,
 547         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 548         BPF_JMP32_IMM(BPF_JSGT, BPF_REG_7, -1, 1),
 549         BPF_EXIT_INSN(),
 550         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 551         BPF_EXIT_INSN(),
 552         },
 553         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 554         .result = ACCEPT,
 555         .runs = 3,
 556         .retvals = {
 557                 { .retval = 0,
 558                   .data64 = { (__u32)-2, }
 559                 },
 560                 { .retval = 0,
 561                   .data64 = { -1, }
 562                 },
 563                 { .retval = 2,
 564                   .data64 = { 1, }
 565                 },
 566         },
 567         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 568 },
 569 {
 570         "jsgt32: BPF_X",
 571         .insns = {
 572         BPF_DIRECT_PKT_R2,
 573         BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
 574         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 575         BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
 576         BPF_EXIT_INSN(),
 577         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 578         BPF_EXIT_INSN(),
 579         },
 580         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 581         .result = ACCEPT,
 582         .runs = 3,
 583         .retvals = {
 584                 { .retval = 0,
 585                   .data64 = { 0x7ffffffe, }
 586                 },
 587                 { .retval = 0,
 588                   .data64 = { 0x1ffffffffULL, }
 589                 },
 590                 { .retval = 2,
 591                   .data64 = { 0x7fffffff, }
 592                 },
 593         },
 594         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 595 },
 596 {
 597         "jsgt32: min/max deduction",
 598         .insns = {
 599         BPF_RAND_SEXT_R7,
 600         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 601         BPF_LD_IMM64(BPF_REG_8, (__u32)(-2) | 1ULL << 32),
 602         BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
 603         BPF_EXIT_INSN(),
 604         BPF_JMP_IMM(BPF_JSGT, BPF_REG_7, -2, 1),
 605         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
 606         BPF_EXIT_INSN(),
 607         },
 608         .result = ACCEPT,
 609         .retval = 2,
 610 },
 611 {
 612         "jsle32: BPF_K",
 613         .insns = {
 614         BPF_DIRECT_PKT_R2,
 615         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 616         BPF_JMP32_IMM(BPF_JSLE, BPF_REG_7, -1, 1),
 617         BPF_EXIT_INSN(),
 618         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 619         BPF_EXIT_INSN(),
 620         },
 621         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 622         .result = ACCEPT,
 623         .runs = 3,
 624         .retvals = {
 625                 { .retval = 2,
 626                   .data64 = { (__u32)-2, }
 627                 },
 628                 { .retval = 2,
 629                   .data64 = { -1, }
 630                 },
 631                 { .retval = 0,
 632                   .data64 = { 1, }
 633                 },
 634         },
 635         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 636 },
 637 {
 638         "jsle32: BPF_X",
 639         .insns = {
 640         BPF_DIRECT_PKT_R2,
 641         BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
 642         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 643         BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
 644         BPF_EXIT_INSN(),
 645         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 646         BPF_EXIT_INSN(),
 647         },
 648         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 649         .result = ACCEPT,
 650         .runs = 3,
 651         .retvals = {
 652                 { .retval = 2,
 653                   .data64 = { 0x7ffffffe, }
 654                 },
 655                 { .retval = 2,
 656                   .data64 = { (__u32)-1, }
 657                 },
 658                 { .retval = 0,
 659                   .data64 = { 0x7fffffff | 2ULL << 32, }
 660                 },
 661         },
 662         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 663 },
 664 {
 665         "jsle32: min/max deduction",
 666         .insns = {
 667         BPF_RAND_UEXT_R7,
 668         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 669         BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
 670         BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
 671         BPF_EXIT_INSN(),
 672         BPF_JMP_IMM(BPF_JSLE, BPF_REG_7, 0x7ffffff0, 1),
 673         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
 674         BPF_EXIT_INSN(),
 675         },
 676         .result = ACCEPT,
 677         .retval = 2,
 678 },
 679 {
 680         "jslt32: BPF_K",
 681         .insns = {
 682         BPF_DIRECT_PKT_R2,
 683         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 684         BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
 685         BPF_EXIT_INSN(),
 686         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 687         BPF_EXIT_INSN(),
 688         },
 689         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 690         .result = ACCEPT,
 691         .runs = 3,
 692         .retvals = {
 693                 { .retval = 2,
 694                   .data64 = { (__u32)-2, }
 695                 },
 696                 { .retval = 0,
 697                   .data64 = { -1, }
 698                 },
 699                 { .retval = 0,
 700                   .data64 = { 1, }
 701                 },
 702         },
 703         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 704 },
 705 {
 706         "jslt32: BPF_X",
 707         .insns = {
 708         BPF_DIRECT_PKT_R2,
 709         BPF_LD_IMM64(BPF_REG_8, 0x7fffffff | 1ULL << 32),
 710         BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 711         BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
 712         BPF_EXIT_INSN(),
 713         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 714         BPF_EXIT_INSN(),
 715         },
 716         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 717         .result = ACCEPT,
 718         .runs = 3,
 719         .retvals = {
 720                 { .retval = 2,
 721                   .data64 = { 0x7ffffffe, }
 722                 },
 723                 { .retval = 2,
 724                   .data64 = { 0xffffffff, }
 725                 },
 726                 { .retval = 0,
 727                   .data64 = { 0x7fffffff | 2ULL << 32, }
 728                 },
 729         },
 730         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 731 },
 732 {
 733         "jslt32: min/max deduction",
 734         .insns = {
 735         BPF_RAND_SEXT_R7,
 736         BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
 737         BPF_LD_IMM64(BPF_REG_8, (__u32)(-1) | 1ULL << 32),
 738         BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
 739         BPF_EXIT_INSN(),
 740         BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
 741         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
 742         BPF_EXIT_INSN(),
 743         },
 744         .result = ACCEPT,
 745         .retval = 2,
 746 },