lib/librte_bpf/bpf_jit_x86.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include <stdarg.h>
   6 #include <errno.h>
   7 #include <stdint.h>
   8 #include <inttypes.h>
   9
  10 #include <rte_common.h>
  11 #include <rte_log.h>
  12 #include <rte_debug.h>
  13 #include <rte_memory.h>
  14 #include <rte_eal.h>
  15 #include <rte_byteorder.h>
  16
  17 #include "bpf_impl.h"
  18
  19 #define GET_BPF_OP(op)  (BPF_OP(op) >> 4)
  20
  21 enum {
  22         RAX = 0,  /* scratch, return value */
  23         RCX = 1,  /* scratch, 4th arg */
  24         RDX = 2,  /* scratch, 3rd arg */
  25         RBX = 3,  /* callee saved */
  26         RSP = 4,  /* stack pointer */
  27         RBP = 5,  /* frame pointer, callee saved */
  28         RSI = 6,  /* scratch, 2nd arg */
  29         RDI = 7,  /* scratch, 1st arg */
  30         R8  = 8,  /* scratch, 5th arg */
  31         R9  = 9,  /* scratch, 6th arg */
  32         R10 = 10, /* scratch */
  33         R11 = 11, /* scratch */
  34         R12 = 12, /* callee saved */
  35         R13 = 13, /* callee saved */
  36         R14 = 14, /* callee saved */
  37         R15 = 15, /* callee saved */
  38 };
  39
  40 #define IS_EXT_REG(r)   ((r) >= R8)
  41
  42 enum {
  43         REX_PREFIX = 0x40, /* fixed value 0100 */
  44         REX_W = 0x8,       /* 64bit operand size */
  45         REX_R = 0x4,       /* extension of the ModRM.reg field */
  46         REX_X = 0x2,       /* extension of the SIB.index field */
  47         REX_B = 0x1,       /* extension of the ModRM.rm field */
  48 };
  49
  50 enum {
  51         MOD_INDIRECT = 0,
  52         MOD_IDISP8 = 1,
  53         MOD_IDISP32 = 2,
  54         MOD_DIRECT = 3,
  55 };
  56
  57 enum {
  58         SIB_SCALE_1 = 0,
  59         SIB_SCALE_2 = 1,
  60         SIB_SCALE_4 = 2,
  61         SIB_SCALE_8 = 3,
  62 };
  63
  64 /*
  65  * eBPF to x86_64 register mappings.
  66  */
  67 static const uint32_t ebpf2x86[] = {
  68         [EBPF_REG_0] = RAX,
  69         [EBPF_REG_1] = RDI,
  70         [EBPF_REG_2] = RSI,
  71         [EBPF_REG_3] = RDX,
  72         [EBPF_REG_4] = RCX,
  73         [EBPF_REG_5] = R8,
  74         [EBPF_REG_6] = RBX,
  75         [EBPF_REG_7] = R13,
  76         [EBPF_REG_8] = R14,
  77         [EBPF_REG_9] = R15,
  78         [EBPF_REG_10] = RBP,
  79 };
  80
  81 /*
  82  * r10 and r11 are used as a scratch temporary registers.
  83  */
  84 enum {
  85         REG_DIV_IMM = R9,
  86         REG_TMP0 = R11,
  87         REG_TMP1 = R10,
  88 };
  89
  90 /*
  91  * callee saved registers list.
  92  * keep RBP as the last one.
  93  */
  94 static const uint32_t save_regs[] = {RBX, R12, R13, R14, R15, RBP};
  95
  96 struct bpf_jit_state {
  97         uint32_t idx;
  98         size_t sz;
  99         struct {
 100                 uint32_t num;
 101                 int32_t off;
 102         } exit;
 103         uint32_t reguse;
 104         int32_t *off;
 105         uint8_t *ins;
 106 };
 107
 108 #define INUSE(v, r)     (((v) >> (r)) & 1)
 109 #define USED(v, r)      ((v) |= 1 << (r))
 110
 111 union bpf_jit_imm {
 112         uint32_t u32;
 113         uint8_t u8[4];
 114 };
 115
 116 static size_t
 117 bpf_size(uint32_t bpf_op_sz)
 118 {
 119         if (bpf_op_sz == BPF_B)
 120                 return sizeof(uint8_t);
 121         else if (bpf_op_sz == BPF_H)
 122                 return sizeof(uint16_t);
 123         else if (bpf_op_sz == BPF_W)
 124                 return sizeof(uint32_t);
 125         else if (bpf_op_sz == EBPF_DW)
 126                 return sizeof(uint64_t);
 127         return 0;
 128 }
 129
 130 /*
 131  * In many cases for imm8 we can produce shorter code.
 132  */
 133 static size_t
 134 imm_size(int32_t v)
 135 {
 136         if (v == (int8_t)v)
 137                 return sizeof(int8_t);
 138         return sizeof(int32_t);
 139 }
 140
 141 static void
 142 emit_bytes(struct bpf_jit_state *st, const uint8_t ins[], uint32_t sz)
 143 {
 144         uint32_t i;
 145
 146         if (st->ins != NULL) {
 147                 for (i = 0; i != sz; i++)
 148                         st->ins[st->sz + i] = ins[i];
 149         }
 150         st->sz += sz;
 151 }
 152
 153 static void
 154 emit_imm(struct bpf_jit_state *st, const uint32_t imm, uint32_t sz)
 155 {
 156         union bpf_jit_imm v;
 157
 158         v.u32 = imm;
 159         emit_bytes(st, v.u8, sz);
 160 }
 161
 162 /*
 163  * emit REX byte
 164  */
 165 static void
 166 emit_rex(struct bpf_jit_state *st, uint32_t op, uint32_t reg, uint32_t rm)
 167 {
 168         uint8_t rex;
 169
 170         /* mark operand registers as used*/
 171         USED(st->reguse, reg);
 172         USED(st->reguse, rm);
 173
 174         rex = 0;
 175         if (BPF_CLASS(op) == EBPF_ALU64 ||
 176                         op == (BPF_ST | BPF_MEM | EBPF_DW) ||
 177                         op == (BPF_STX | BPF_MEM | EBPF_DW) ||
 178                         op == (BPF_STX | EBPF_XADD | EBPF_DW) ||
 179                         op == (BPF_LD | BPF_IMM | EBPF_DW) ||
 180                         (BPF_CLASS(op) == BPF_LDX &&
 181                         BPF_MODE(op) == BPF_MEM &&
 182                         BPF_SIZE(op) != BPF_W))
 183                 rex |= REX_W;
 184
 185         if (IS_EXT_REG(reg))
 186                 rex |= REX_R;
 187
 188         if (IS_EXT_REG(rm))
 189                 rex |= REX_B;
 190
 191         /* store using SIL, DIL */
 192         if (op == (BPF_STX | BPF_MEM | BPF_B) && (reg == RDI || reg == RSI))
 193                 rex |= REX_PREFIX;
 194
 195         if (rex != 0) {
 196                 rex |= REX_PREFIX;
 197                 emit_bytes(st, &rex, sizeof(rex));
 198         }
 199 }
 200
 201 /*
 202  * emit MODRegRM byte
 203  */
 204 static void
 205 emit_modregrm(struct bpf_jit_state *st, uint32_t mod, uint32_t reg, uint32_t rm)
 206 {
 207         uint8_t v;
 208
 209         v = mod << 6 | (reg & 7) << 3 | (rm & 7);
 210         emit_bytes(st, &v, sizeof(v));
 211 }
 212
 213 /*
 214  * emit SIB byte
 215  */
 216 static void
 217 emit_sib(struct bpf_jit_state *st, uint32_t scale, uint32_t idx, uint32_t base)
 218 {
 219         uint8_t v;
 220
 221         v = scale << 6 | (idx & 7) << 3 | (base & 7);
 222         emit_bytes(st, &v, sizeof(v));
 223 }
 224
 225 /*
 226  * emit xchg %<sreg>, %<dreg>
 227  */
 228 static void
 229 emit_xchg_reg(struct bpf_jit_state *st, uint32_t sreg, uint32_t dreg)
 230 {
 231         const uint8_t ops = 0x87;
 232
 233         emit_rex(st, EBPF_ALU64, sreg, dreg);
 234         emit_bytes(st, &ops, sizeof(ops));
 235         emit_modregrm(st, MOD_DIRECT, sreg, dreg);
 236 }
 237
 238 /*
 239  * emit neg %<dreg>
 240  */
 241 static void
 242 emit_neg(struct bpf_jit_state *st, uint32_t op, uint32_t dreg)
 243 {
 244         const uint8_t ops = 0xF7;
 245         const uint8_t mods = 3;
 246
 247         emit_rex(st, op, 0, dreg);
 248         emit_bytes(st, &ops, sizeof(ops));
 249         emit_modregrm(st, MOD_DIRECT, mods, dreg);
 250 }
 251
 252 /*
 253  * emit mov %<sreg>, %<dreg>
 254  */
 255 static void
 256 emit_mov_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 257         uint32_t dreg)
 258 {
 259         const uint8_t ops = 0x89;
 260
 261         /* if operands are 32-bit, then it can be used to clear upper 32-bit */
 262         if (sreg != dreg || BPF_CLASS(op) == BPF_ALU) {
 263                 emit_rex(st, op, sreg, dreg);
 264                 emit_bytes(st, &ops, sizeof(ops));
 265                 emit_modregrm(st, MOD_DIRECT, sreg, dreg);
 266         }
 267 }
 268
 269 /*
 270  * emit movzwl %<sreg>, %<dreg>
 271  */
 272 static void
 273 emit_movzwl(struct bpf_jit_state *st, uint32_t sreg, uint32_t dreg)
 274 {
 275         static const uint8_t ops[] = {0x0F, 0xB7};
 276
 277         emit_rex(st, BPF_ALU, sreg, dreg);
 278         emit_bytes(st, ops, sizeof(ops));
 279         emit_modregrm(st, MOD_DIRECT, sreg, dreg);
 280 }
 281
 282 /*
 283  * emit ror <imm8>, %<dreg>
 284  */
 285 static void
 286 emit_ror_imm(struct bpf_jit_state *st, uint32_t dreg, uint32_t imm)
 287 {
 288         const uint8_t prfx = 0x66;
 289         const uint8_t ops = 0xC1;
 290         const uint8_t mods = 1;
 291
 292         emit_bytes(st, &prfx, sizeof(prfx));
 293         emit_rex(st, BPF_ALU, 0, dreg);
 294         emit_bytes(st, &ops, sizeof(ops));
 295         emit_modregrm(st, MOD_DIRECT, mods, dreg);
 296         emit_imm(st, imm, imm_size(imm));
 297 }
 298
 299 /*
 300  * emit bswap %<dreg>
 301  */
 302 static void
 303 emit_be2le_48(struct bpf_jit_state *st, uint32_t dreg, uint32_t imm)
 304 {
 305         uint32_t rop;
 306
 307         const uint8_t ops = 0x0F;
 308         const uint8_t mods = 1;
 309
 310         rop = (imm == 64) ? EBPF_ALU64 : BPF_ALU;
 311         emit_rex(st, rop, 0, dreg);
 312         emit_bytes(st, &ops, sizeof(ops));
 313         emit_modregrm(st, MOD_DIRECT, mods, dreg);
 314 }
 315
 316 static void
 317 emit_be2le(struct bpf_jit_state *st, uint32_t dreg, uint32_t imm)
 318 {
 319         if (imm == 16) {
 320                 emit_ror_imm(st, dreg, 8);
 321                 emit_movzwl(st, dreg, dreg);
 322         } else
 323                 emit_be2le_48(st, dreg, imm);
 324 }
 325
 326 /*
 327  * In general it is NOP for x86.
 328  * Just clear the upper bits.
 329  */
 330 static void
 331 emit_le2be(struct bpf_jit_state *st, uint32_t dreg, uint32_t imm)
 332 {
 333         if (imm == 16)
 334                 emit_movzwl(st, dreg, dreg);
 335         else if (imm == 32)
 336                 emit_mov_reg(st, BPF_ALU | EBPF_MOV | BPF_X, dreg, dreg);
 337 }
 338
 339 /*
 340  * emit one of:
 341  *   add <imm>, %<dreg>
 342  *   and <imm>, %<dreg>
 343  *   or  <imm>, %<dreg>
 344  *   sub <imm>, %<dreg>
 345  *   xor <imm>, %<dreg>
 346  */
 347 static void
 348 emit_alu_imm(struct bpf_jit_state *st, uint32_t op, uint32_t dreg, uint32_t imm)
 349 {
 350         uint8_t mod, opcode;
 351         uint32_t bop, imsz;
 352
 353         const uint8_t op8 = 0x83;
 354         const uint8_t op32 = 0x81;
 355         static const uint8_t mods[] = {
 356                 [GET_BPF_OP(BPF_ADD)] = 0,
 357                 [GET_BPF_OP(BPF_AND)] = 4,
 358                 [GET_BPF_OP(BPF_OR)] =  1,
 359                 [GET_BPF_OP(BPF_SUB)] = 5,
 360                 [GET_BPF_OP(BPF_XOR)] = 6,
 361         };
 362
 363         bop = GET_BPF_OP(op);
 364         mod = mods[bop];
 365
 366         imsz = imm_size(imm);
 367         opcode = (imsz == 1) ? op8 : op32;
 368
 369         emit_rex(st, op, 0, dreg);
 370         emit_bytes(st, &opcode, sizeof(opcode));
 371         emit_modregrm(st, MOD_DIRECT, mod, dreg);
 372         emit_imm(st, imm, imsz);
 373 }
 374
 375 /*
 376  * emit one of:
 377  *   add %<sreg>, %<dreg>
 378  *   and %<sreg>, %<dreg>
 379  *   or  %<sreg>, %<dreg>
 380  *   sub %<sreg>, %<dreg>
 381  *   xor %<sreg>, %<dreg>
 382  */
 383 static void
 384 emit_alu_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 385         uint32_t dreg)
 386 {
 387         uint32_t bop;
 388
 389         static const uint8_t ops[] = {
 390                 [GET_BPF_OP(BPF_ADD)] = 0x01,
 391                 [GET_BPF_OP(BPF_AND)] = 0x21,
 392                 [GET_BPF_OP(BPF_OR)] =  0x09,
 393                 [GET_BPF_OP(BPF_SUB)] = 0x29,
 394                 [GET_BPF_OP(BPF_XOR)] = 0x31,
 395         };
 396
 397         bop = GET_BPF_OP(op);
 398
 399         emit_rex(st, op, sreg, dreg);
 400         emit_bytes(st, &ops[bop], sizeof(ops[bop]));
 401         emit_modregrm(st, MOD_DIRECT, sreg, dreg);
 402 }
 403
 404 static void
 405 emit_shift(struct bpf_jit_state *st, uint32_t op, uint32_t dreg)
 406 {
 407         uint8_t mod;
 408         uint32_t bop, opx;
 409
 410         static const uint8_t ops[] = {0xC1, 0xD3};
 411         static const uint8_t mods[] = {
 412                 [GET_BPF_OP(BPF_LSH)] = 4,
 413                 [GET_BPF_OP(BPF_RSH)] = 5,
 414                 [GET_BPF_OP(EBPF_ARSH)] = 7,
 415         };
 416
 417         bop = GET_BPF_OP(op);
 418         mod = mods[bop];
 419         opx = (BPF_SRC(op) == BPF_X);
 420
 421         emit_rex(st, op, 0, dreg);
 422         emit_bytes(st, &ops[opx], sizeof(ops[opx]));
 423         emit_modregrm(st, MOD_DIRECT, mod, dreg);
 424 }
 425
 426 /*
 427  * emit one of:
 428  *   shl <imm>, %<dreg>
 429  *   shr <imm>, %<dreg>
 430  *   sar <imm>, %<dreg>
 431  */
 432 static void
 433 emit_shift_imm(struct bpf_jit_state *st, uint32_t op, uint32_t dreg,
 434         uint32_t imm)
 435 {
 436         emit_shift(st, op, dreg);
 437         emit_imm(st, imm, imm_size(imm));
 438 }
 439
 440 /*
 441  * emit one of:
 442  *   shl %<dreg>
 443  *   shr %<dreg>
 444  *   sar %<dreg>
 445  * note that rcx is implicitly used as a source register, so few extra
 446  * instructions for register spillage might be necessary.
 447  */
 448 static void
 449 emit_shift_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 450         uint32_t dreg)
 451 {
 452         if (sreg != RCX)
 453                 emit_xchg_reg(st, RCX, sreg);
 454
 455         emit_shift(st, op, (dreg == RCX) ? sreg : dreg);
 456
 457         if (sreg != RCX)
 458                 emit_xchg_reg(st, RCX, sreg);
 459 }
 460
 461 /*
 462  * emit mov <imm>, %<dreg>
 463  */
 464 static void
 465 emit_mov_imm(struct bpf_jit_state *st, uint32_t op, uint32_t dreg, uint32_t imm)
 466 {
 467         const uint8_t ops = 0xC7;
 468
 469         if (imm == 0) {
 470                 /* replace 'mov 0, %<dst>' with 'xor %<dst>, %<dst>' */
 471                 op = BPF_CLASS(op) | BPF_XOR | BPF_X;
 472                 emit_alu_reg(st, op, dreg, dreg);
 473                 return;
 474         }
 475
 476         emit_rex(st, op, 0, dreg);
 477         emit_bytes(st, &ops, sizeof(ops));
 478         emit_modregrm(st, MOD_DIRECT, 0, dreg);
 479         emit_imm(st, imm, sizeof(imm));
 480 }
 481
 482 /*
 483  * emit mov <imm64>, %<dreg>
 484  */
 485 static void
 486 emit_ld_imm64(struct bpf_jit_state *st, uint32_t dreg, uint32_t imm0,
 487         uint32_t imm1)
 488 {
 489         const uint8_t ops = 0xB8;
 490
 491         if (imm1 == 0) {
 492                 emit_mov_imm(st, EBPF_ALU64 | EBPF_MOV | BPF_K, dreg, imm0);
 493                 return;
 494         }
 495
 496         emit_rex(st, EBPF_ALU64, 0, dreg);
 497         emit_bytes(st, &ops, sizeof(ops));
 498         emit_modregrm(st, MOD_DIRECT, 0, dreg);
 499
 500         emit_imm(st, imm0, sizeof(imm0));
 501         emit_imm(st, imm1, sizeof(imm1));
 502 }
 503
 504 /*
 505  * note that rax:rdx are implicitly used as source/destination registers,
 506  * so some reg spillage is necessary.
 507  * emit:
 508  * mov %rax, %r11
 509  * mov %rdx, %r10
 510  * mov %<dreg>, %rax
 511  * either:
 512  *   mov %<sreg>, %rdx
 513  * OR
 514  *   mov <imm>, %rdx
 515  * mul %rdx
 516  * mov %r10, %rdx
 517  * mov %rax, %<dreg>
 518  * mov %r11, %rax
 519  */
 520 static void
 521 emit_mul(struct bpf_jit_state *st, uint32_t op, uint32_t sreg, uint32_t dreg,
 522         uint32_t imm)
 523 {
 524         const uint8_t ops = 0xF7;
 525         const uint8_t mods = 4;
 526
 527         /* save rax & rdx */
 528         emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, RAX, REG_TMP0);
 529         emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, RDX, REG_TMP1);
 530
 531         /* rax = dreg */
 532         emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, dreg, RAX);
 533
 534         if (BPF_SRC(op) == BPF_X)
 535                 /* rdx = sreg */
 536                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X,
 537                         sreg == RAX ? REG_TMP0 : sreg, RDX);
 538         else
 539                 /* rdx = imm */
 540                 emit_mov_imm(st, EBPF_ALU64 | EBPF_MOV | BPF_K, RDX, imm);
 541
 542         emit_rex(st, op, RAX, RDX);
 543         emit_bytes(st, &ops, sizeof(ops));
 544         emit_modregrm(st, MOD_DIRECT, mods, RDX);
 545
 546         if (dreg != RDX)
 547                 /* restore rdx */
 548                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, REG_TMP1, RDX);
 549
 550         if (dreg != RAX) {
 551                 /* dreg = rax */
 552                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, RAX, dreg);
 553                 /* restore rax */
 554                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, REG_TMP0, RAX);
 555         }
 556 }
 557
 558 /*
 559  * emit mov <ofs>(%<sreg>), %<dreg>
 560  * note that for non 64-bit ops, higher bits have to be cleared.
 561  */
 562 static void
 563 emit_ld_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg, uint32_t dreg,
 564         int32_t ofs)
 565 {
 566         uint32_t mods, opsz;
 567         const uint8_t op32 = 0x8B;
 568         const uint8_t op16[] = {0x0F, 0xB7};
 569         const uint8_t op8[] = {0x0F, 0xB6};
 570
 571         emit_rex(st, op, dreg, sreg);
 572
 573         opsz = BPF_SIZE(op);
 574         if (opsz == BPF_B)
 575                 emit_bytes(st, op8, sizeof(op8));
 576         else if (opsz == BPF_H)
 577                 emit_bytes(st, op16, sizeof(op16));
 578         else
 579                 emit_bytes(st, &op32, sizeof(op32));
 580
 581         mods = (imm_size(ofs) == 1) ? MOD_IDISP8 : MOD_IDISP32;
 582
 583         emit_modregrm(st, mods, dreg, sreg);
 584         if (sreg == RSP || sreg == R12)
 585                 emit_sib(st, SIB_SCALE_1, sreg, sreg);
 586         emit_imm(st, ofs, imm_size(ofs));
 587 }
 588
 589 /*
 590  * emit one of:
 591  *   mov %<sreg>, <ofs>(%<dreg>)
 592  *   mov <imm>, <ofs>(%<dreg>)
 593  */
 594 static void
 595 emit_st_common(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 596         uint32_t dreg, uint32_t imm, int32_t ofs)
 597 {
 598         uint32_t mods, imsz, opsz, opx;
 599         const uint8_t prfx16 = 0x66;
 600
 601         /* 8 bit instruction opcodes */
 602         static const uint8_t op8[] = {0xC6, 0x88};
 603
 604         /* 16/32/64 bit instruction opcodes */
 605         static const uint8_t ops[] = {0xC7, 0x89};
 606
 607         /* is the instruction has immediate value or src reg? */
 608         opx = (BPF_CLASS(op) == BPF_STX);
 609
 610         opsz = BPF_SIZE(op);
 611         if (opsz == BPF_H)
 612                 emit_bytes(st, &prfx16, sizeof(prfx16));
 613
 614         emit_rex(st, op, sreg, dreg);
 615
 616         if (opsz == BPF_B)
 617                 emit_bytes(st, &op8[opx], sizeof(op8[opx]));
 618         else
 619                 emit_bytes(st, &ops[opx], sizeof(ops[opx]));
 620
 621         imsz = imm_size(ofs);
 622         mods = (imsz == 1) ? MOD_IDISP8 : MOD_IDISP32;
 623
 624         emit_modregrm(st, mods, sreg, dreg);
 625
 626         if (dreg == RSP || dreg == R12)
 627                 emit_sib(st, SIB_SCALE_1, dreg, dreg);
 628
 629         emit_imm(st, ofs, imsz);
 630
 631         if (opx == 0) {
 632                 imsz = RTE_MIN(bpf_size(opsz), sizeof(imm));
 633                 emit_imm(st, imm, imsz);
 634         }
 635 }
 636
 637 static void
 638 emit_st_imm(struct bpf_jit_state *st, uint32_t op, uint32_t dreg, uint32_t imm,
 639         int32_t ofs)
 640 {
 641         emit_st_common(st, op, 0, dreg, imm, ofs);
 642 }
 643
 644 static void
 645 emit_st_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg, uint32_t dreg,
 646         int32_t ofs)
 647 {
 648         emit_st_common(st, op, sreg, dreg, 0, ofs);
 649 }
 650
 651 /*
 652  * emit lock add %<sreg>, <ofs>(%<dreg>)
 653  */
 654 static void
 655 emit_st_xadd(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 656         uint32_t dreg, int32_t ofs)
 657 {
 658         uint32_t imsz, mods;
 659
 660         const uint8_t lck = 0xF0; /* lock prefix */
 661         const uint8_t ops = 0x01; /* add opcode */
 662
 663         imsz = imm_size(ofs);
 664         mods = (imsz == 1) ? MOD_IDISP8 : MOD_IDISP32;
 665
 666         emit_bytes(st, &lck, sizeof(lck));
 667         emit_rex(st, op, sreg, dreg);
 668         emit_bytes(st, &ops, sizeof(ops));
 669         emit_modregrm(st, mods, sreg, dreg);
 670         emit_imm(st, ofs, imsz);
 671 }
 672
 673 /*
 674  * emit:
 675  *    mov <imm64>, (%rax)
 676  *    call *%rax
 677  */
 678 static void
 679 emit_call(struct bpf_jit_state *st, uintptr_t trg)
 680 {
 681         const uint8_t ops = 0xFF;
 682         const uint8_t mods = 2;
 683
 684         emit_ld_imm64(st, RAX, trg, trg >> 32);
 685         emit_bytes(st, &ops, sizeof(ops));
 686         emit_modregrm(st, MOD_DIRECT, mods, RAX);
 687 }
 688
 689 /*
 690  * emit jmp <ofs>
 691  * where 'ofs' is the target offset for the native code.
 692  */
 693 static void
 694 emit_abs_jmp(struct bpf_jit_state *st, int32_t ofs)
 695 {
 696         int32_t joff;
 697         uint32_t imsz;
 698
 699         const uint8_t op8 = 0xEB;
 700         const uint8_t op32 = 0xE9;
 701
 702         const int32_t sz8 = sizeof(op8) + sizeof(uint8_t);
 703         const int32_t sz32 = sizeof(op32) + sizeof(uint32_t);
 704
 705         /* max possible jmp instruction size */
 706         const int32_t iszm = RTE_MAX(sz8, sz32);
 707
 708         joff = ofs - st->sz;
 709         imsz = RTE_MAX(imm_size(joff), imm_size(joff + iszm));
 710
 711         if (imsz == 1) {
 712                 emit_bytes(st, &op8, sizeof(op8));
 713                 joff -= sz8;
 714         } else {
 715                 emit_bytes(st, &op32, sizeof(op32));
 716                 joff -= sz32;
 717         }
 718
 719         emit_imm(st, joff, imsz);
 720 }
 721
 722 /*
 723  * emit jmp <ofs>
 724  * where 'ofs' is the target offset for the BPF bytecode.
 725  */
 726 static void
 727 emit_jmp(struct bpf_jit_state *st, int32_t ofs)
 728 {
 729         emit_abs_jmp(st, st->off[st->idx + ofs]);
 730 }
 731
 732 /*
 733  * emit one of:
 734  *    cmovz %<sreg>, <%dreg>
 735  *    cmovne %<sreg>, <%dreg>
 736  *    cmova %<sreg>, <%dreg>
 737  *    cmovb %<sreg>, <%dreg>
 738  *    cmovae %<sreg>, <%dreg>
 739  *    cmovbe %<sreg>, <%dreg>
 740  *    cmovg %<sreg>, <%dreg>
 741  *    cmovl %<sreg>, <%dreg>
 742  *    cmovge %<sreg>, <%dreg>
 743  *    cmovle %<sreg>, <%dreg>
 744  */
 745 static void
 746 emit_movcc_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 747         uint32_t dreg)
 748 {
 749         uint32_t bop;
 750
 751         static const uint8_t ops[][2] = {
 752                 [GET_BPF_OP(BPF_JEQ)] = {0x0F, 0x44},  /* CMOVZ */
 753                 [GET_BPF_OP(EBPF_JNE)] = {0x0F, 0x45},  /* CMOVNE */
 754                 [GET_BPF_OP(BPF_JGT)] = {0x0F, 0x47},  /* CMOVA */
 755                 [GET_BPF_OP(EBPF_JLT)] = {0x0F, 0x42},  /* CMOVB */
 756                 [GET_BPF_OP(BPF_JGE)] = {0x0F, 0x43},  /* CMOVAE */
 757                 [GET_BPF_OP(EBPF_JLE)] = {0x0F, 0x46},  /* CMOVBE */
 758                 [GET_BPF_OP(EBPF_JSGT)] = {0x0F, 0x4F}, /* CMOVG */
 759                 [GET_BPF_OP(EBPF_JSLT)] = {0x0F, 0x4C}, /* CMOVL */
 760                 [GET_BPF_OP(EBPF_JSGE)] = {0x0F, 0x4D}, /* CMOVGE */
 761                 [GET_BPF_OP(EBPF_JSLE)] = {0x0F, 0x4E}, /* CMOVLE */
 762                 [GET_BPF_OP(BPF_JSET)] = {0x0F, 0x45}, /* CMOVNE */
 763         };
 764
 765         bop = GET_BPF_OP(op);
 766
 767         emit_rex(st, op, dreg, sreg);
 768         emit_bytes(st, ops[bop], sizeof(ops[bop]));
 769         emit_modregrm(st, MOD_DIRECT, dreg, sreg);
 770 }
 771
 772 /*
 773  * emit one of:
 774  * je <ofs>
 775  * jne <ofs>
 776  * ja <ofs>
 777  * jb <ofs>
 778  * jae <ofs>
 779  * jbe <ofs>
 780  * jg <ofs>
 781  * jl <ofs>
 782  * jge <ofs>
 783  * jle <ofs>
 784  * where 'ofs' is the target offset for the native code.
 785  */
 786 static void
 787 emit_abs_jcc(struct bpf_jit_state *st, uint32_t op, int32_t ofs)
 788 {
 789         uint32_t bop, imsz;
 790         int32_t joff;
 791
 792         static const uint8_t op8[] = {
 793                 [GET_BPF_OP(BPF_JEQ)] = 0x74,  /* JE */
 794                 [GET_BPF_OP(EBPF_JNE)] = 0x75,  /* JNE */
 795                 [GET_BPF_OP(BPF_JGT)] = 0x77,  /* JA */
 796                 [GET_BPF_OP(EBPF_JLT)] = 0x72,  /* JB */
 797                 [GET_BPF_OP(BPF_JGE)] = 0x73,  /* JAE */
 798                 [GET_BPF_OP(EBPF_JLE)] = 0x76,  /* JBE */
 799                 [GET_BPF_OP(EBPF_JSGT)] = 0x7F, /* JG */
 800                 [GET_BPF_OP(EBPF_JSLT)] = 0x7C, /* JL */
 801                 [GET_BPF_OP(EBPF_JSGE)] = 0x7D, /*JGE */
 802                 [GET_BPF_OP(EBPF_JSLE)] = 0x7E, /* JLE */
 803                 [GET_BPF_OP(BPF_JSET)] = 0x75, /*JNE */
 804         };
 805
 806         static const uint8_t op32[][2] = {
 807                 [GET_BPF_OP(BPF_JEQ)] = {0x0F, 0x84},  /* JE */
 808                 [GET_BPF_OP(EBPF_JNE)] = {0x0F, 0x85},  /* JNE */
 809                 [GET_BPF_OP(BPF_JGT)] = {0x0F, 0x87},  /* JA */
 810                 [GET_BPF_OP(EBPF_JLT)] = {0x0F, 0x82},  /* JB */
 811                 [GET_BPF_OP(BPF_JGE)] = {0x0F, 0x83},  /* JAE */
 812                 [GET_BPF_OP(EBPF_JLE)] = {0x0F, 0x86},  /* JBE */
 813                 [GET_BPF_OP(EBPF_JSGT)] = {0x0F, 0x8F}, /* JG */
 814                 [GET_BPF_OP(EBPF_JSLT)] = {0x0F, 0x8C}, /* JL */
 815                 [GET_BPF_OP(EBPF_JSGE)] = {0x0F, 0x8D}, /*JGE */
 816                 [GET_BPF_OP(EBPF_JSLE)] = {0x0F, 0x8E}, /* JLE */
 817                 [GET_BPF_OP(BPF_JSET)] = {0x0F, 0x85}, /*JNE */
 818         };
 819
 820         const int32_t sz8 = sizeof(op8[0]) + sizeof(uint8_t);
 821         const int32_t sz32 = sizeof(op32[0]) + sizeof(uint32_t);
 822
 823         /* max possible jcc instruction size */
 824         const int32_t iszm = RTE_MAX(sz8, sz32);
 825
 826         joff = ofs - st->sz;
 827         imsz = RTE_MAX(imm_size(joff), imm_size(joff + iszm));
 828
 829         bop = GET_BPF_OP(op);
 830
 831         if (imsz == 1) {
 832                 emit_bytes(st, &op8[bop], sizeof(op8[bop]));
 833                 joff -= sz8;
 834         } else {
 835                 emit_bytes(st, op32[bop], sizeof(op32[bop]));
 836                 joff -= sz32;
 837         }
 838
 839         emit_imm(st, joff, imsz);
 840 }
 841
 842 /*
 843  * emit one of:
 844  * je <ofs>
 845  * jne <ofs>
 846  * ja <ofs>
 847  * jb <ofs>
 848  * jae <ofs>
 849  * jbe <ofs>
 850  * jg <ofs>
 851  * jl <ofs>
 852  * jge <ofs>
 853  * jle <ofs>
 854  * where 'ofs' is the target offset for the BPF bytecode.
 855  */
 856 static void
 857 emit_jcc(struct bpf_jit_state *st, uint32_t op, int32_t ofs)
 858 {
 859         emit_abs_jcc(st, op, st->off[st->idx + ofs]);
 860 }
 861
 862
 863 /*
 864  * emit cmp <imm>, %<dreg>
 865  */
 866 static void
 867 emit_cmp_imm(struct bpf_jit_state *st, uint32_t op, uint32_t dreg, uint32_t imm)
 868 {
 869         uint8_t ops;
 870         uint32_t imsz;
 871
 872         const uint8_t op8 = 0x83;
 873         const uint8_t op32 = 0x81;
 874         const uint8_t mods = 7;
 875
 876         imsz = imm_size(imm);
 877         ops = (imsz == 1) ? op8 : op32;
 878
 879         emit_rex(st, op, 0, dreg);
 880         emit_bytes(st, &ops, sizeof(ops));
 881         emit_modregrm(st, MOD_DIRECT, mods, dreg);
 882         emit_imm(st, imm, imsz);
 883 }
 884
 885 /*
 886  * emit test <imm>, %<dreg>
 887  */
 888 static void
 889 emit_tst_imm(struct bpf_jit_state *st, uint32_t op, uint32_t dreg, uint32_t imm)
 890 {
 891         const uint8_t ops = 0xF7;
 892         const uint8_t mods = 0;
 893
 894         emit_rex(st, op, 0, dreg);
 895         emit_bytes(st, &ops, sizeof(ops));
 896         emit_modregrm(st, MOD_DIRECT, mods, dreg);
 897         emit_imm(st, imm, imm_size(imm));
 898 }
 899
 900 static void
 901 emit_jcc_imm(struct bpf_jit_state *st, uint32_t op, uint32_t dreg,
 902         uint32_t imm, int32_t ofs)
 903 {
 904         if (BPF_OP(op) == BPF_JSET)
 905                 emit_tst_imm(st, EBPF_ALU64, dreg, imm);
 906         else
 907                 emit_cmp_imm(st, EBPF_ALU64, dreg, imm);
 908
 909         emit_jcc(st, op, ofs);
 910 }
 911
 912 /*
 913  * emit test %<sreg>, %<dreg>
 914  */
 915 static void
 916 emit_tst_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 917         uint32_t dreg)
 918 {
 919         const uint8_t ops = 0x85;
 920
 921         emit_rex(st, op, sreg, dreg);
 922         emit_bytes(st, &ops, sizeof(ops));
 923         emit_modregrm(st, MOD_DIRECT, sreg, dreg);
 924 }
 925
 926 /*
 927  * emit cmp %<sreg>, %<dreg>
 928  */
 929 static void
 930 emit_cmp_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 931         uint32_t dreg)
 932 {
 933         const uint8_t ops = 0x39;
 934
 935         emit_rex(st, op, sreg, dreg);
 936         emit_bytes(st, &ops, sizeof(ops));
 937         emit_modregrm(st, MOD_DIRECT, sreg, dreg);
 938
 939 }
 940
 941 static void
 942 emit_jcc_reg(struct bpf_jit_state *st, uint32_t op, uint32_t sreg,
 943         uint32_t dreg, int32_t ofs)
 944 {
 945         if (BPF_OP(op) == BPF_JSET)
 946                 emit_tst_reg(st, EBPF_ALU64, sreg, dreg);
 947         else
 948                 emit_cmp_reg(st, EBPF_ALU64, sreg, dreg);
 949
 950         emit_jcc(st, op, ofs);
 951 }
 952
 953 /*
 954  * note that rax:rdx are implicitly used as source/destination registers,
 955  * so some reg spillage is necessary.
 956  * emit:
 957  * mov %rax, %r11
 958  * mov %rdx, %r10
 959  * mov %<dreg>, %rax
 960  * xor %rdx, %rdx
 961  * for divisor as immediate value:
 962  *   mov <imm>, %r9
 963  * div %<divisor_reg>
 964  * mov %r10, %rdx
 965  * mov %rax, %<dreg>
 966  * mov %r11, %rax
 967  * either:
 968  *   mov %rax, %<dreg>
 969  * OR
 970  *   mov %rdx, %<dreg>
 971  * mov %r11, %rax
 972  * mov %r10, %rdx
 973  */
 974 static void
 975 emit_div(struct bpf_jit_state *st, uint32_t op, uint32_t sreg, uint32_t dreg,
 976         uint32_t imm)
 977 {
 978         uint32_t sr;
 979
 980         const uint8_t ops = 0xF7;
 981         const uint8_t mods = 6;
 982
 983         if (BPF_SRC(op) == BPF_X) {
 984
 985                 /* check that src divisor is not zero */
 986                 emit_tst_reg(st, BPF_CLASS(op), sreg, sreg);
 987
 988                 /* exit with return value zero */
 989                 emit_movcc_reg(st, BPF_CLASS(op) | BPF_JEQ | BPF_X, sreg, RAX);
 990                 emit_abs_jcc(st, BPF_JMP | BPF_JEQ | BPF_K, st->exit.off);
 991         }
 992
 993         /* save rax & rdx */
 994         if (dreg != RAX)
 995                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, RAX, REG_TMP0);
 996         if (dreg != RDX)
 997                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, RDX, REG_TMP1);
 998
 999         /* fill rax & rdx */
1000         emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, dreg, RAX);
1001         emit_mov_imm(st, EBPF_ALU64 | EBPF_MOV | BPF_K, RDX, 0);
1002
1003         if (BPF_SRC(op) == BPF_X) {
1004                 sr = sreg;
1005                 if (sr == RAX)
1006                         sr = REG_TMP0;
1007                 else if (sr == RDX)
1008                         sr = REG_TMP1;
1009         } else {
1010                 sr = REG_DIV_IMM;
1011                 emit_mov_imm(st, EBPF_ALU64 | EBPF_MOV | BPF_K, sr, imm);
1012         }
1013
1014         emit_rex(st, op, 0, sr);
1015         emit_bytes(st, &ops, sizeof(ops));
1016         emit_modregrm(st, MOD_DIRECT, mods, sr);
1017
1018         if (BPF_OP(op) == BPF_DIV)
1019                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, RAX, dreg);
1020         else
1021                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, RDX, dreg);
1022
1023         if (dreg != RAX)
1024                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, REG_TMP0, RAX);
1025         if (dreg != RDX)
1026                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, REG_TMP1, RDX);
1027 }
1028
1029 static void
1030 emit_prolog(struct bpf_jit_state *st, int32_t stack_size)
1031 {
1032         uint32_t i;
1033         int32_t spil, ofs;
1034
1035         spil = 0;
1036         for (i = 0; i != RTE_DIM(save_regs); i++)
1037                 spil += INUSE(st->reguse, save_regs[i]);
1038
1039         /* we can avoid touching the stack at all */
1040         if (spil == 0)
1041                 return;
1042
1043
1044         emit_alu_imm(st, EBPF_ALU64 | BPF_SUB | BPF_K, RSP,
1045                 spil * sizeof(uint64_t));
1046
1047         ofs = 0;
1048         for (i = 0; i != RTE_DIM(save_regs); i++) {
1049                 if (INUSE(st->reguse, save_regs[i]) != 0) {
1050                         emit_st_reg(st, BPF_STX | BPF_MEM | EBPF_DW,
1051                                 save_regs[i], RSP, ofs);
1052                         ofs += sizeof(uint64_t);
1053                 }
1054         }
1055
1056         if (INUSE(st->reguse, RBP) != 0) {
1057                 emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X, RSP, RBP);
1058                 emit_alu_imm(st, EBPF_ALU64 | BPF_SUB | BPF_K, RSP, stack_size);
1059         }
1060 }
1061
1062 /*
1063  * emit ret
1064  */
1065 static void
1066 emit_ret(struct bpf_jit_state *st)
1067 {
1068         const uint8_t ops = 0xC3;
1069
1070         emit_bytes(st, &ops, sizeof(ops));
1071 }
1072
1073 static void
1074 emit_epilog(struct bpf_jit_state *st)
1075 {
1076         uint32_t i;
1077         int32_t spil, ofs;
1078
1079         /* if we allready have an epilog generate a jump to it */
1080         if (st->exit.num++ != 0) {
1081                 emit_abs_jmp(st, st->exit.off);
1082                 return;
1083         }
1084
1085         /* store offset of epilog block */
1086         st->exit.off = st->sz;
1087
1088         spil = 0;
1089         for (i = 0; i != RTE_DIM(save_regs); i++)
1090                 spil += INUSE(st->reguse, save_regs[i]);
1091
1092         if (spil != 0) {
1093
1094                 if (INUSE(st->reguse, RBP) != 0)
1095                         emit_mov_reg(st, EBPF_ALU64 | EBPF_MOV | BPF_X,
1096                                 RBP, RSP);
1097
1098                 ofs = 0;
1099                 for (i = 0; i != RTE_DIM(save_regs); i++) {
1100                         if (INUSE(st->reguse, save_regs[i]) != 0) {
1101                                 emit_ld_reg(st, BPF_LDX | BPF_MEM | EBPF_DW,
1102                                         RSP, save_regs[i], ofs);
1103                                 ofs += sizeof(uint64_t);
1104                         }
1105                 }
1106
1107                 emit_alu_imm(st, EBPF_ALU64 | BPF_ADD | BPF_K, RSP,
1108                         spil * sizeof(uint64_t));
1109         }
1110
1111         emit_ret(st);
1112 }
1113
1114 /*
1115  * walk through bpf code and translate them x86_64 one.
1116  */
1117 static int
1118 emit(struct bpf_jit_state *st, const struct rte_bpf *bpf)
1119 {
1120         uint32_t i, dr, op, sr;
1121         const struct ebpf_insn *ins;
1122
1123         /* reset state fields */
1124         st->sz = 0;
1125         st->exit.num = 0;
1126
1127         emit_prolog(st, bpf->stack_sz);
1128
1129         for (i = 0; i != bpf->prm.nb_ins; i++) {
1130
1131                 st->idx = i;
1132                 st->off[i] = st->sz;
1133
1134                 ins = bpf->prm.ins + i;
1135
1136                 dr = ebpf2x86[ins->dst_reg];
1137                 sr = ebpf2x86[ins->src_reg];
1138                 op = ins->code;
1139
1140                 switch (op) {
1141                 /* 32 bit ALU IMM operations */
1142                 case (BPF_ALU | BPF_ADD | BPF_K):
1143                 case (BPF_ALU | BPF_SUB | BPF_K):
1144                 case (BPF_ALU | BPF_AND | BPF_K):
1145                 case (BPF_ALU | BPF_OR | BPF_K):
1146                 case (BPF_ALU | BPF_XOR | BPF_K):
1147                         emit_alu_imm(st, op, dr, ins->imm);
1148                         break;
1149                 case (BPF_ALU | BPF_LSH | BPF_K):
1150                 case (BPF_ALU | BPF_RSH | BPF_K):
1151                         emit_shift_imm(st, op, dr, ins->imm);
1152                         break;
1153                 case (BPF_ALU | EBPF_MOV | BPF_K):
1154                         emit_mov_imm(st, op, dr, ins->imm);
1155                         break;
1156                 /* 32 bit ALU REG operations */
1157                 case (BPF_ALU | BPF_ADD | BPF_X):
1158                 case (BPF_ALU | BPF_SUB | BPF_X):
1159                 case (BPF_ALU | BPF_AND | BPF_X):
1160                 case (BPF_ALU | BPF_OR | BPF_X):
1161                 case (BPF_ALU | BPF_XOR | BPF_X):
1162                         emit_alu_reg(st, op, sr, dr);
1163                         break;
1164                 case (BPF_ALU | BPF_LSH | BPF_X):
1165                 case (BPF_ALU | BPF_RSH | BPF_X):
1166                         emit_shift_reg(st, op, sr, dr);
1167                         break;
1168                 case (BPF_ALU | EBPF_MOV | BPF_X):
1169                         emit_mov_reg(st, op, sr, dr);
1170                         break;
1171                 case (BPF_ALU | BPF_NEG):
1172                         emit_neg(st, op, dr);
1173                         break;
1174                 case (BPF_ALU | EBPF_END | EBPF_TO_BE):
1175                         emit_be2le(st, dr, ins->imm);
1176                         break;
1177                 case (BPF_ALU | EBPF_END | EBPF_TO_LE):
1178                         emit_le2be(st, dr, ins->imm);
1179                         break;
1180                 /* 64 bit ALU IMM operations */
1181                 case (EBPF_ALU64 | BPF_ADD | BPF_K):
1182                 case (EBPF_ALU64 | BPF_SUB | BPF_K):
1183                 case (EBPF_ALU64 | BPF_AND | BPF_K):
1184                 case (EBPF_ALU64 | BPF_OR | BPF_K):
1185                 case (EBPF_ALU64 | BPF_XOR | BPF_K):
1186                         emit_alu_imm(st, op, dr, ins->imm);
1187                         break;
1188                 case (EBPF_ALU64 | BPF_LSH | BPF_K):
1189                 case (EBPF_ALU64 | BPF_RSH | BPF_K):
1190                 case (EBPF_ALU64 | EBPF_ARSH | BPF_K):
1191                         emit_shift_imm(st, op, dr, ins->imm);
1192                         break;
1193                 case (EBPF_ALU64 | EBPF_MOV | BPF_K):
1194                         emit_mov_imm(st, op, dr, ins->imm);
1195                         break;
1196                 /* 64 bit ALU REG operations */
1197                 case (EBPF_ALU64 | BPF_ADD | BPF_X):
1198                 case (EBPF_ALU64 | BPF_SUB | BPF_X):
1199                 case (EBPF_ALU64 | BPF_AND | BPF_X):
1200                 case (EBPF_ALU64 | BPF_OR | BPF_X):
1201                 case (EBPF_ALU64 | BPF_XOR | BPF_X):
1202                         emit_alu_reg(st, op, sr, dr);
1203                         break;
1204                 case (EBPF_ALU64 | BPF_LSH | BPF_X):
1205                 case (EBPF_ALU64 | BPF_RSH | BPF_X):
1206                 case (EBPF_ALU64 | EBPF_ARSH | BPF_X):
1207                         emit_shift_reg(st, op, sr, dr);
1208                         break;
1209                 case (EBPF_ALU64 | EBPF_MOV | BPF_X):
1210                         emit_mov_reg(st, op, sr, dr);
1211                         break;
1212                 case (EBPF_ALU64 | BPF_NEG):
1213                         emit_neg(st, op, dr);
1214                         break;
1215                 /* multiply instructions */
1216                 case (BPF_ALU | BPF_MUL | BPF_K):
1217                 case (BPF_ALU | BPF_MUL | BPF_X):
1218                 case (EBPF_ALU64 | BPF_MUL | BPF_K):
1219                 case (EBPF_ALU64 | BPF_MUL | BPF_X):
1220                         emit_mul(st, op, sr, dr, ins->imm);
1221                         break;
1222                 /* divide instructions */
1223                 case (BPF_ALU | BPF_DIV | BPF_K):
1224                 case (BPF_ALU | BPF_MOD | BPF_K):
1225                 case (BPF_ALU | BPF_DIV | BPF_X):
1226                 case (BPF_ALU | BPF_MOD | BPF_X):
1227                 case (EBPF_ALU64 | BPF_DIV | BPF_K):
1228                 case (EBPF_ALU64 | BPF_MOD | BPF_K):
1229                 case (EBPF_ALU64 | BPF_DIV | BPF_X):
1230                 case (EBPF_ALU64 | BPF_MOD | BPF_X):
1231                         emit_div(st, op, sr, dr, ins->imm);
1232                         break;
1233                 /* load instructions */
1234                 case (BPF_LDX | BPF_MEM | BPF_B):
1235                 case (BPF_LDX | BPF_MEM | BPF_H):
1236                 case (BPF_LDX | BPF_MEM | BPF_W):
1237                 case (BPF_LDX | BPF_MEM | EBPF_DW):
1238                         emit_ld_reg(st, op, sr, dr, ins->off);
1239                         break;
1240                 /* load 64 bit immediate value */
1241                 case (BPF_LD | BPF_IMM | EBPF_DW):
1242                         emit_ld_imm64(st, dr, ins[0].imm, ins[1].imm);
1243                         i++;
1244                         break;
1245                 /* store instructions */
1246                 case (BPF_STX | BPF_MEM | BPF_B):
1247                 case (BPF_STX | BPF_MEM | BPF_H):
1248                 case (BPF_STX | BPF_MEM | BPF_W):
1249                 case (BPF_STX | BPF_MEM | EBPF_DW):
1250                         emit_st_reg(st, op, sr, dr, ins->off);
1251                         break;
1252                 case (BPF_ST | BPF_MEM | BPF_B):
1253                 case (BPF_ST | BPF_MEM | BPF_H):
1254                 case (BPF_ST | BPF_MEM | BPF_W):
1255                 case (BPF_ST | BPF_MEM | EBPF_DW):
1256                         emit_st_imm(st, op, dr, ins->imm, ins->off);
1257                         break;
1258                 /* atomic add instructions */
1259                 case (BPF_STX | EBPF_XADD | BPF_W):
1260                 case (BPF_STX | EBPF_XADD | EBPF_DW):
1261                         emit_st_xadd(st, op, sr, dr, ins->off);
1262                         break;
1263                 /* jump instructions */
1264                 case (BPF_JMP | BPF_JA):
1265                         emit_jmp(st, ins->off + 1);
1266                         break;
1267                 /* jump IMM instructions */
1268                 case (BPF_JMP | BPF_JEQ | BPF_K):
1269                 case (BPF_JMP | EBPF_JNE | BPF_K):
1270                 case (BPF_JMP | BPF_JGT | BPF_K):
1271                 case (BPF_JMP | EBPF_JLT | BPF_K):
1272                 case (BPF_JMP | BPF_JGE | BPF_K):
1273                 case (BPF_JMP | EBPF_JLE | BPF_K):
1274                 case (BPF_JMP | EBPF_JSGT | BPF_K):
1275                 case (BPF_JMP | EBPF_JSLT | BPF_K):
1276                 case (BPF_JMP | EBPF_JSGE | BPF_K):
1277                 case (BPF_JMP | EBPF_JSLE | BPF_K):
1278                 case (BPF_JMP | BPF_JSET | BPF_K):
1279                         emit_jcc_imm(st, op, dr, ins->imm, ins->off + 1);
1280                         break;
1281                 /* jump REG instructions */
1282                 case (BPF_JMP | BPF_JEQ | BPF_X):
1283                 case (BPF_JMP | EBPF_JNE | BPF_X):
1284                 case (BPF_JMP | BPF_JGT | BPF_X):
1285                 case (BPF_JMP | EBPF_JLT | BPF_X):
1286                 case (BPF_JMP | BPF_JGE | BPF_X):
1287                 case (BPF_JMP | EBPF_JLE | BPF_X):
1288                 case (BPF_JMP | EBPF_JSGT | BPF_X):
1289                 case (BPF_JMP | EBPF_JSLT | BPF_X):
1290                 case (BPF_JMP | EBPF_JSGE | BPF_X):
1291                 case (BPF_JMP | EBPF_JSLE | BPF_X):
1292                 case (BPF_JMP | BPF_JSET | BPF_X):
1293                         emit_jcc_reg(st, op, sr, dr, ins->off + 1);
1294                         break;
1295                 /* call instructions */
1296                 case (BPF_JMP | EBPF_CALL):
1297                         emit_call(st, (uintptr_t)bpf->prm.xsym[ins->imm].func);
1298                         break;
1299                 /* return instruction */
1300                 case (BPF_JMP | EBPF_EXIT):
1301                         emit_epilog(st);
1302                         break;
1303                 default:
1304                         RTE_BPF_LOG(ERR,
1305                                 "%s(%p): invalid opcode %#x at pc: %u;\n",
1306                                 __func__, bpf, ins->code, i);
1307                         return -EINVAL;
1308                 }
1309         }
1310
1311         return 0;
1312 }
1313
1314 /*
1315  * produce a native ISA version of the given BPF code.
1316  */
1317 int
1318 bpf_jit_x86(struct rte_bpf *bpf)
1319 {
1320         int32_t rc;
1321         uint32_t i;
1322         size_t sz;
1323         struct bpf_jit_state st;
1324
1325         /* init state */
1326         memset(&st, 0, sizeof(st));
1327         st.off = malloc(bpf->prm.nb_ins * sizeof(st.off[0]));
1328         if (st.off == NULL)
1329                 return -ENOMEM;
1330
1331         /* fill with fake offsets */
1332         st.exit.off = INT32_MAX;
1333         for (i = 0; i != bpf->prm.nb_ins; i++)
1334                 st.off[i] = INT32_MAX;
1335
1336         /*
1337          * dry runs, used to calculate total code size and valid jump offsets.
1338          * stop when we get minimal possible size
1339          */
1340         do {
1341                 sz = st.sz;
1342                 rc = emit(&st, bpf);
1343         } while (rc == 0 && sz != st.sz);
1344
1345         if (rc == 0) {
1346
1347                 /* allocate memory needed */
1348                 st.ins = mmap(NULL, st.sz, PROT_READ | PROT_WRITE,
1349                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
1350                 if (st.ins == MAP_FAILED)
1351                         rc = -ENOMEM;
1352                 else
1353                         /* generate code */
1354                         rc = emit(&st, bpf);
1355         }
1356
1357         if (rc == 0 && mprotect(st.ins, st.sz, PROT_READ | PROT_EXEC) != 0)
1358                 rc = -ENOMEM;
1359
1360         if (rc != 0)
1361                 munmap(st.ins, st.sz);
1362         else {
1363                 bpf->jit.func = (void *)st.ins;
1364                 bpf->jit.sz = st.sz;
1365         }
1366
1367         free(st.off);
1368         return rc;
1369 }