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