arch/riscv/net/bpf_jit_comp64.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* BPF JIT compiler for RV64G
   3  *
   4  * Copyright(c) 2019 Björn Töpel <bjorn.topel@gmail.com>
   5  *
   6  */
   7
   8 #include <linux/bitfield.h>
   9 #include <linux/bpf.h>
  10 #include <linux/filter.h>
  11 #include <linux/memory.h>
  12 #include <linux/stop_machine.h>
  13 #include <asm/patch.h>
  14 #include "bpf_jit.h"
  15
  16 #define RV_REG_TCC RV_REG_A6
  17 #define RV_REG_TCC_SAVED RV_REG_S6 /* Store A6 in S6 if program do calls */
  18
  19 static const int regmap[] = {
  20         [BPF_REG_0] =   RV_REG_A5,
  21         [BPF_REG_1] =   RV_REG_A0,
  22         [BPF_REG_2] =   RV_REG_A1,
  23         [BPF_REG_3] =   RV_REG_A2,
  24         [BPF_REG_4] =   RV_REG_A3,
  25         [BPF_REG_5] =   RV_REG_A4,
  26         [BPF_REG_6] =   RV_REG_S1,
  27         [BPF_REG_7] =   RV_REG_S2,
  28         [BPF_REG_8] =   RV_REG_S3,
  29         [BPF_REG_9] =   RV_REG_S4,
  30         [BPF_REG_FP] =  RV_REG_S5,
  31         [BPF_REG_AX] =  RV_REG_T0,
  32 };
  33
  34 static const int pt_regmap[] = {
  35         [RV_REG_A0] = offsetof(struct pt_regs, a0),
  36         [RV_REG_A1] = offsetof(struct pt_regs, a1),
  37         [RV_REG_A2] = offsetof(struct pt_regs, a2),
  38         [RV_REG_A3] = offsetof(struct pt_regs, a3),
  39         [RV_REG_A4] = offsetof(struct pt_regs, a4),
  40         [RV_REG_A5] = offsetof(struct pt_regs, a5),
  41         [RV_REG_S1] = offsetof(struct pt_regs, s1),
  42         [RV_REG_S2] = offsetof(struct pt_regs, s2),
  43         [RV_REG_S3] = offsetof(struct pt_regs, s3),
  44         [RV_REG_S4] = offsetof(struct pt_regs, s4),
  45         [RV_REG_S5] = offsetof(struct pt_regs, s5),
  46         [RV_REG_T0] = offsetof(struct pt_regs, t0),
  47 };
  48
  49 enum {
  50         RV_CTX_F_SEEN_TAIL_CALL =       0,
  51         RV_CTX_F_SEEN_CALL =            RV_REG_RA,
  52         RV_CTX_F_SEEN_S1 =              RV_REG_S1,
  53         RV_CTX_F_SEEN_S2 =              RV_REG_S2,
  54         RV_CTX_F_SEEN_S3 =              RV_REG_S3,
  55         RV_CTX_F_SEEN_S4 =              RV_REG_S4,
  56         RV_CTX_F_SEEN_S5 =              RV_REG_S5,
  57         RV_CTX_F_SEEN_S6 =              RV_REG_S6,
  58 };
  59
  60 static u8 bpf_to_rv_reg(int bpf_reg, struct rv_jit_context *ctx)
  61 {
  62         u8 reg = regmap[bpf_reg];
  63
  64         switch (reg) {
  65         case RV_CTX_F_SEEN_S1:
  66         case RV_CTX_F_SEEN_S2:
  67         case RV_CTX_F_SEEN_S3:
  68         case RV_CTX_F_SEEN_S4:
  69         case RV_CTX_F_SEEN_S5:
  70         case RV_CTX_F_SEEN_S6:
  71                 __set_bit(reg, &ctx->flags);
  72         }
  73         return reg;
  74 };
  75
  76 static bool seen_reg(int reg, struct rv_jit_context *ctx)
  77 {
  78         switch (reg) {
  79         case RV_CTX_F_SEEN_CALL:
  80         case RV_CTX_F_SEEN_S1:
  81         case RV_CTX_F_SEEN_S2:
  82         case RV_CTX_F_SEEN_S3:
  83         case RV_CTX_F_SEEN_S4:
  84         case RV_CTX_F_SEEN_S5:
  85         case RV_CTX_F_SEEN_S6:
  86                 return test_bit(reg, &ctx->flags);
  87         }
  88         return false;
  89 }
  90
  91 static void mark_fp(struct rv_jit_context *ctx)
  92 {
  93         __set_bit(RV_CTX_F_SEEN_S5, &ctx->flags);
  94 }
  95
  96 static void mark_call(struct rv_jit_context *ctx)
  97 {
  98         __set_bit(RV_CTX_F_SEEN_CALL, &ctx->flags);
  99 }
 100
 101 static bool seen_call(struct rv_jit_context *ctx)
 102 {
 103         return test_bit(RV_CTX_F_SEEN_CALL, &ctx->flags);
 104 }
 105
 106 static void mark_tail_call(struct rv_jit_context *ctx)
 107 {
 108         __set_bit(RV_CTX_F_SEEN_TAIL_CALL, &ctx->flags);
 109 }
 110
 111 static bool seen_tail_call(struct rv_jit_context *ctx)
 112 {
 113         return test_bit(RV_CTX_F_SEEN_TAIL_CALL, &ctx->flags);
 114 }
 115
 116 static u8 rv_tail_call_reg(struct rv_jit_context *ctx)
 117 {
 118         mark_tail_call(ctx);
 119
 120         if (seen_call(ctx)) {
 121                 __set_bit(RV_CTX_F_SEEN_S6, &ctx->flags);
 122                 return RV_REG_S6;
 123         }
 124         return RV_REG_A6;
 125 }
 126
 127 static bool is_32b_int(s64 val)
 128 {
 129         return -(1L << 31) <= val && val < (1L << 31);
 130 }
 131
 132 static bool in_auipc_jalr_range(s64 val)
 133 {
 134         /*
 135          * auipc+jalr can reach any signed PC-relative offset in the range
 136          * [-2^31 - 2^11, 2^31 - 2^11).
 137          */
 138         return (-(1L << 31) - (1L << 11)) <= val &&
 139                 val < ((1L << 31) - (1L << 11));
 140 }
 141
 142 /* Emit fixed-length instructions for address */
 143 static int emit_addr(u8 rd, u64 addr, bool extra_pass, struct rv_jit_context *ctx)
 144 {
 145         u64 ip = (u64)(ctx->insns + ctx->ninsns);
 146         s64 off = addr - ip;
 147         s64 upper = (off + (1 << 11)) >> 12;
 148         s64 lower = off & 0xfff;
 149
 150         if (extra_pass && !in_auipc_jalr_range(off)) {
 151                 pr_err("bpf-jit: target offset 0x%llx is out of range\n", off);
 152                 return -ERANGE;
 153         }
 154
 155         emit(rv_auipc(rd, upper), ctx);
 156         emit(rv_addi(rd, rd, lower), ctx);
 157         return 0;
 158 }
 159
 160 /* Emit variable-length instructions for 32-bit and 64-bit imm */
 161 static void emit_imm(u8 rd, s64 val, struct rv_jit_context *ctx)
 162 {
 163         /* Note that the immediate from the add is sign-extended,
 164          * which means that we need to compensate this by adding 2^12,
 165          * when the 12th bit is set. A simpler way of doing this, and
 166          * getting rid of the check, is to just add 2**11 before the
 167          * shift. The "Loading a 32-Bit constant" example from the
 168          * "Computer Organization and Design, RISC-V edition" book by
 169          * Patterson/Hennessy highlights this fact.
 170          *
 171          * This also means that we need to process LSB to MSB.
 172          */
 173         s64 upper = (val + (1 << 11)) >> 12;
 174         /* Sign-extend lower 12 bits to 64 bits since immediates for li, addiw,
 175          * and addi are signed and RVC checks will perform signed comparisons.
 176          */
 177         s64 lower = ((val & 0xfff) << 52) >> 52;
 178         int shift;
 179
 180         if (is_32b_int(val)) {
 181                 if (upper)
 182                         emit_lui(rd, upper, ctx);
 183
 184                 if (!upper) {
 185                         emit_li(rd, lower, ctx);
 186                         return;
 187                 }
 188
 189                 emit_addiw(rd, rd, lower, ctx);
 190                 return;
 191         }
 192
 193         shift = __ffs(upper);
 194         upper >>= shift;
 195         shift += 12;
 196
 197         emit_imm(rd, upper, ctx);
 198
 199         emit_slli(rd, rd, shift, ctx);
 200         if (lower)
 201                 emit_addi(rd, rd, lower, ctx);
 202 }
 203
 204 static void __build_epilogue(bool is_tail_call, struct rv_jit_context *ctx)
 205 {
 206         int stack_adjust = ctx->stack_size, store_offset = stack_adjust - 8;
 207
 208         if (seen_reg(RV_REG_RA, ctx)) {
 209                 emit_ld(RV_REG_RA, store_offset, RV_REG_SP, ctx);
 210                 store_offset -= 8;
 211         }
 212         emit_ld(RV_REG_FP, store_offset, RV_REG_SP, ctx);
 213         store_offset -= 8;
 214         if (seen_reg(RV_REG_S1, ctx)) {
 215                 emit_ld(RV_REG_S1, store_offset, RV_REG_SP, ctx);
 216                 store_offset -= 8;
 217         }
 218         if (seen_reg(RV_REG_S2, ctx)) {
 219                 emit_ld(RV_REG_S2, store_offset, RV_REG_SP, ctx);
 220                 store_offset -= 8;
 221         }
 222         if (seen_reg(RV_REG_S3, ctx)) {
 223                 emit_ld(RV_REG_S3, store_offset, RV_REG_SP, ctx);
 224                 store_offset -= 8;
 225         }
 226         if (seen_reg(RV_REG_S4, ctx)) {
 227                 emit_ld(RV_REG_S4, store_offset, RV_REG_SP, ctx);
 228                 store_offset -= 8;
 229         }
 230         if (seen_reg(RV_REG_S5, ctx)) {
 231                 emit_ld(RV_REG_S5, store_offset, RV_REG_SP, ctx);
 232                 store_offset -= 8;
 233         }
 234         if (seen_reg(RV_REG_S6, ctx)) {
 235                 emit_ld(RV_REG_S6, store_offset, RV_REG_SP, ctx);
 236                 store_offset -= 8;
 237         }
 238
 239         emit_addi(RV_REG_SP, RV_REG_SP, stack_adjust, ctx);
 240         /* Set return value. */
 241         if (!is_tail_call)
 242                 emit_mv(RV_REG_A0, RV_REG_A5, ctx);
 243         emit_jalr(RV_REG_ZERO, is_tail_call ? RV_REG_T3 : RV_REG_RA,
 244                   is_tail_call ? 20 : 0, /* skip reserved nops and TCC init */
 245                   ctx);
 246 }
 247
 248 static void emit_bcc(u8 cond, u8 rd, u8 rs, int rvoff,
 249                      struct rv_jit_context *ctx)
 250 {
 251         switch (cond) {
 252         case BPF_JEQ:
 253                 emit(rv_beq(rd, rs, rvoff >> 1), ctx);
 254                 return;
 255         case BPF_JGT:
 256                 emit(rv_bltu(rs, rd, rvoff >> 1), ctx);
 257                 return;
 258         case BPF_JLT:
 259                 emit(rv_bltu(rd, rs, rvoff >> 1), ctx);
 260                 return;
 261         case BPF_JGE:
 262                 emit(rv_bgeu(rd, rs, rvoff >> 1), ctx);
 263                 return;
 264         case BPF_JLE:
 265                 emit(rv_bgeu(rs, rd, rvoff >> 1), ctx);
 266                 return;
 267         case BPF_JNE:
 268                 emit(rv_bne(rd, rs, rvoff >> 1), ctx);
 269                 return;
 270         case BPF_JSGT:
 271                 emit(rv_blt(rs, rd, rvoff >> 1), ctx);
 272                 return;
 273         case BPF_JSLT:
 274                 emit(rv_blt(rd, rs, rvoff >> 1), ctx);
 275                 return;
 276         case BPF_JSGE:
 277                 emit(rv_bge(rd, rs, rvoff >> 1), ctx);
 278                 return;
 279         case BPF_JSLE:
 280                 emit(rv_bge(rs, rd, rvoff >> 1), ctx);
 281         }
 282 }
 283
 284 static void emit_branch(u8 cond, u8 rd, u8 rs, int rvoff,
 285                         struct rv_jit_context *ctx)
 286 {
 287         s64 upper, lower;
 288
 289         if (is_13b_int(rvoff)) {
 290                 emit_bcc(cond, rd, rs, rvoff, ctx);
 291                 return;
 292         }
 293
 294         /* Adjust for jal */
 295         rvoff -= 4;
 296
 297         /* Transform, e.g.:
 298          *   bne rd,rs,foo
 299          * to
 300          *   beq rd,rs,<.L1>
 301          *   (auipc foo)
 302          *   jal(r) foo
 303          * .L1
 304          */
 305         cond = invert_bpf_cond(cond);
 306         if (is_21b_int(rvoff)) {
 307                 emit_bcc(cond, rd, rs, 8, ctx);
 308                 emit(rv_jal(RV_REG_ZERO, rvoff >> 1), ctx);
 309                 return;
 310         }
 311
 312         /* 32b No need for an additional rvoff adjustment, since we
 313          * get that from the auipc at PC', where PC = PC' + 4.
 314          */
 315         upper = (rvoff + (1 << 11)) >> 12;
 316         lower = rvoff & 0xfff;
 317
 318         emit_bcc(cond, rd, rs, 12, ctx);
 319         emit(rv_auipc(RV_REG_T1, upper), ctx);
 320         emit(rv_jalr(RV_REG_ZERO, RV_REG_T1, lower), ctx);
 321 }
 322
 323 static void emit_zext_32(u8 reg, struct rv_jit_context *ctx)
 324 {
 325         emit_slli(reg, reg, 32, ctx);
 326         emit_srli(reg, reg, 32, ctx);
 327 }
 328
 329 static int emit_bpf_tail_call(int insn, struct rv_jit_context *ctx)
 330 {
 331         int tc_ninsn, off, start_insn = ctx->ninsns;
 332         u8 tcc = rv_tail_call_reg(ctx);
 333
 334         /* a0: &ctx
 335          * a1: &array
 336          * a2: index
 337          *
 338          * if (index >= array->map.max_entries)
 339          *      goto out;
 340          */
 341         tc_ninsn = insn ? ctx->offset[insn] - ctx->offset[insn - 1] :
 342                    ctx->offset[0];
 343         emit_zext_32(RV_REG_A2, ctx);
 344
 345         off = offsetof(struct bpf_array, map.max_entries);
 346         if (is_12b_check(off, insn))
 347                 return -1;
 348         emit(rv_lwu(RV_REG_T1, off, RV_REG_A1), ctx);
 349         off = ninsns_rvoff(tc_ninsn - (ctx->ninsns - start_insn));
 350         emit_branch(BPF_JGE, RV_REG_A2, RV_REG_T1, off, ctx);
 351
 352         /* if (--TCC < 0)
 353          *     goto out;
 354          */
 355         emit_addi(RV_REG_TCC, tcc, -1, ctx);
 356         off = ninsns_rvoff(tc_ninsn - (ctx->ninsns - start_insn));
 357         emit_branch(BPF_JSLT, RV_REG_TCC, RV_REG_ZERO, off, ctx);
 358
 359         /* prog = array->ptrs[index];
 360          * if (!prog)
 361          *     goto out;
 362          */
 363         emit_slli(RV_REG_T2, RV_REG_A2, 3, ctx);
 364         emit_add(RV_REG_T2, RV_REG_T2, RV_REG_A1, ctx);
 365         off = offsetof(struct bpf_array, ptrs);
 366         if (is_12b_check(off, insn))
 367                 return -1;
 368         emit_ld(RV_REG_T2, off, RV_REG_T2, ctx);
 369         off = ninsns_rvoff(tc_ninsn - (ctx->ninsns - start_insn));
 370         emit_branch(BPF_JEQ, RV_REG_T2, RV_REG_ZERO, off, ctx);
 371
 372         /* goto *(prog->bpf_func + 4); */
 373         off = offsetof(struct bpf_prog, bpf_func);
 374         if (is_12b_check(off, insn))
 375                 return -1;
 376         emit_ld(RV_REG_T3, off, RV_REG_T2, ctx);
 377         __build_epilogue(true, ctx);
 378         return 0;
 379 }
 380
 381 static void init_regs(u8 *rd, u8 *rs, const struct bpf_insn *insn,
 382                       struct rv_jit_context *ctx)
 383 {
 384         u8 code = insn->code;
 385
 386         switch (code) {
 387         case BPF_JMP | BPF_JA:
 388         case BPF_JMP | BPF_CALL:
 389         case BPF_JMP | BPF_EXIT:
 390         case BPF_JMP | BPF_TAIL_CALL:
 391                 break;
 392         default:
 393                 *rd = bpf_to_rv_reg(insn->dst_reg, ctx);
 394         }
 395
 396         if (code & (BPF_ALU | BPF_X) || code & (BPF_ALU64 | BPF_X) ||
 397             code & (BPF_JMP | BPF_X) || code & (BPF_JMP32 | BPF_X) ||
 398             code & BPF_LDX || code & BPF_STX)
 399                 *rs = bpf_to_rv_reg(insn->src_reg, ctx);
 400 }
 401
 402 static void emit_zext_32_rd_rs(u8 *rd, u8 *rs, struct rv_jit_context *ctx)
 403 {
 404         emit_mv(RV_REG_T2, *rd, ctx);
 405         emit_zext_32(RV_REG_T2, ctx);
 406         emit_mv(RV_REG_T1, *rs, ctx);
 407         emit_zext_32(RV_REG_T1, ctx);
 408         *rd = RV_REG_T2;
 409         *rs = RV_REG_T1;
 410 }
 411
 412 static void emit_sext_32_rd_rs(u8 *rd, u8 *rs, struct rv_jit_context *ctx)
 413 {
 414         emit_addiw(RV_REG_T2, *rd, 0, ctx);
 415         emit_addiw(RV_REG_T1, *rs, 0, ctx);
 416         *rd = RV_REG_T2;
 417         *rs = RV_REG_T1;
 418 }
 419
 420 static void emit_zext_32_rd_t1(u8 *rd, struct rv_jit_context *ctx)
 421 {
 422         emit_mv(RV_REG_T2, *rd, ctx);
 423         emit_zext_32(RV_REG_T2, ctx);
 424         emit_zext_32(RV_REG_T1, ctx);
 425         *rd = RV_REG_T2;
 426 }
 427
 428 static void emit_sext_32_rd(u8 *rd, struct rv_jit_context *ctx)
 429 {
 430         emit_addiw(RV_REG_T2, *rd, 0, ctx);
 431         *rd = RV_REG_T2;
 432 }
 433
 434 static int emit_jump_and_link(u8 rd, s64 rvoff, bool fixed_addr,
 435                               struct rv_jit_context *ctx)
 436 {
 437         s64 upper, lower;
 438
 439         if (rvoff && fixed_addr && is_21b_int(rvoff)) {
 440                 emit(rv_jal(rd, rvoff >> 1), ctx);
 441                 return 0;
 442         } else if (in_auipc_jalr_range(rvoff)) {
 443                 upper = (rvoff + (1 << 11)) >> 12;
 444                 lower = rvoff & 0xfff;
 445                 emit(rv_auipc(RV_REG_T1, upper), ctx);
 446                 emit(rv_jalr(rd, RV_REG_T1, lower), ctx);
 447                 return 0;
 448         }
 449
 450         pr_err("bpf-jit: target offset 0x%llx is out of range\n", rvoff);
 451         return -ERANGE;
 452 }
 453
 454 static bool is_signed_bpf_cond(u8 cond)
 455 {
 456         return cond == BPF_JSGT || cond == BPF_JSLT ||
 457                 cond == BPF_JSGE || cond == BPF_JSLE;
 458 }
 459
 460 static int emit_call(u64 addr, bool fixed_addr, struct rv_jit_context *ctx)
 461 {
 462         s64 off = 0;
 463         u64 ip;
 464
 465         if (addr && ctx->insns) {
 466                 ip = (u64)(long)(ctx->insns + ctx->ninsns);
 467                 off = addr - ip;
 468         }
 469
 470         return emit_jump_and_link(RV_REG_RA, off, fixed_addr, ctx);
 471 }
 472
 473 static void emit_atomic(u8 rd, u8 rs, s16 off, s32 imm, bool is64,
 474                         struct rv_jit_context *ctx)
 475 {
 476         u8 r0;
 477         int jmp_offset;
 478
 479         if (off) {
 480                 if (is_12b_int(off)) {
 481                         emit_addi(RV_REG_T1, rd, off, ctx);
 482                 } else {
 483                         emit_imm(RV_REG_T1, off, ctx);
 484                         emit_add(RV_REG_T1, RV_REG_T1, rd, ctx);
 485                 }
 486                 rd = RV_REG_T1;
 487         }
 488
 489         switch (imm) {
 490         /* lock *(u32/u64 *)(dst_reg + off16) <op>= src_reg */
 491         case BPF_ADD:
 492                 emit(is64 ? rv_amoadd_d(RV_REG_ZERO, rs, rd, 0, 0) :
 493                      rv_amoadd_w(RV_REG_ZERO, rs, rd, 0, 0), ctx);
 494                 break;
 495         case BPF_AND:
 496                 emit(is64 ? rv_amoand_d(RV_REG_ZERO, rs, rd, 0, 0) :
 497                      rv_amoand_w(RV_REG_ZERO, rs, rd, 0, 0), ctx);
 498                 break;
 499         case BPF_OR:
 500                 emit(is64 ? rv_amoor_d(RV_REG_ZERO, rs, rd, 0, 0) :
 501                      rv_amoor_w(RV_REG_ZERO, rs, rd, 0, 0), ctx);
 502                 break;
 503         case BPF_XOR:
 504                 emit(is64 ? rv_amoxor_d(RV_REG_ZERO, rs, rd, 0, 0) :
 505                      rv_amoxor_w(RV_REG_ZERO, rs, rd, 0, 0), ctx);
 506                 break;
 507         /* src_reg = atomic_fetch_<op>(dst_reg + off16, src_reg) */
 508         case BPF_ADD | BPF_FETCH:
 509                 emit(is64 ? rv_amoadd_d(rs, rs, rd, 0, 0) :
 510                      rv_amoadd_w(rs, rs, rd, 0, 0), ctx);
 511                 if (!is64)
 512                         emit_zext_32(rs, ctx);
 513                 break;
 514         case BPF_AND | BPF_FETCH:
 515                 emit(is64 ? rv_amoand_d(rs, rs, rd, 0, 0) :
 516                      rv_amoand_w(rs, rs, rd, 0, 0), ctx);
 517                 if (!is64)
 518                         emit_zext_32(rs, ctx);
 519                 break;
 520         case BPF_OR | BPF_FETCH:
 521                 emit(is64 ? rv_amoor_d(rs, rs, rd, 0, 0) :
 522                      rv_amoor_w(rs, rs, rd, 0, 0), ctx);
 523                 if (!is64)
 524                         emit_zext_32(rs, ctx);
 525                 break;
 526         case BPF_XOR | BPF_FETCH:
 527                 emit(is64 ? rv_amoxor_d(rs, rs, rd, 0, 0) :
 528                      rv_amoxor_w(rs, rs, rd, 0, 0), ctx);
 529                 if (!is64)
 530                         emit_zext_32(rs, ctx);
 531                 break;
 532         /* src_reg = atomic_xchg(dst_reg + off16, src_reg); */
 533         case BPF_XCHG:
 534                 emit(is64 ? rv_amoswap_d(rs, rs, rd, 0, 0) :
 535                      rv_amoswap_w(rs, rs, rd, 0, 0), ctx);
 536                 if (!is64)
 537                         emit_zext_32(rs, ctx);
 538                 break;
 539         /* r0 = atomic_cmpxchg(dst_reg + off16, r0, src_reg); */
 540         case BPF_CMPXCHG:
 541                 r0 = bpf_to_rv_reg(BPF_REG_0, ctx);
 542                 emit(is64 ? rv_addi(RV_REG_T2, r0, 0) :
 543                      rv_addiw(RV_REG_T2, r0, 0), ctx);
 544                 emit(is64 ? rv_lr_d(r0, 0, rd, 0, 0) :
 545                      rv_lr_w(r0, 0, rd, 0, 0), ctx);
 546                 jmp_offset = ninsns_rvoff(8);
 547                 emit(rv_bne(RV_REG_T2, r0, jmp_offset >> 1), ctx);
 548                 emit(is64 ? rv_sc_d(RV_REG_T3, rs, rd, 0, 0) :
 549                      rv_sc_w(RV_REG_T3, rs, rd, 0, 0), ctx);
 550                 jmp_offset = ninsns_rvoff(-6);
 551                 emit(rv_bne(RV_REG_T3, 0, jmp_offset >> 1), ctx);
 552                 emit(rv_fence(0x3, 0x3), ctx);
 553                 break;
 554         }
 555 }
 556
 557 #define BPF_FIXUP_OFFSET_MASK   GENMASK(26, 0)
 558 #define BPF_FIXUP_REG_MASK      GENMASK(31, 27)
 559
 560 bool ex_handler_bpf(const struct exception_table_entry *ex,
 561                     struct pt_regs *regs)
 562 {
 563         off_t offset = FIELD_GET(BPF_FIXUP_OFFSET_MASK, ex->fixup);
 564         int regs_offset = FIELD_GET(BPF_FIXUP_REG_MASK, ex->fixup);
 565
 566         *(unsigned long *)((void *)regs + pt_regmap[regs_offset]) = 0;
 567         regs->epc = (unsigned long)&ex->fixup - offset;
 568
 569         return true;
 570 }
 571
 572 /* For accesses to BTF pointers, add an entry to the exception table */
 573 static int add_exception_handler(const struct bpf_insn *insn,
 574                                  struct rv_jit_context *ctx,
 575                                  int dst_reg, int insn_len)
 576 {
 577         struct exception_table_entry *ex;
 578         unsigned long pc;
 579         off_t offset;
 580
 581         if (!ctx->insns || !ctx->prog->aux->extable || BPF_MODE(insn->code) != BPF_PROBE_MEM)
 582                 return 0;
 583
 584         if (WARN_ON_ONCE(ctx->nexentries >= ctx->prog->aux->num_exentries))
 585                 return -EINVAL;
 586
 587         if (WARN_ON_ONCE(insn_len > ctx->ninsns))
 588                 return -EINVAL;
 589
 590         if (WARN_ON_ONCE(!rvc_enabled() && insn_len == 1))
 591                 return -EINVAL;
 592
 593         ex = &ctx->prog->aux->extable[ctx->nexentries];
 594         pc = (unsigned long)&ctx->insns[ctx->ninsns - insn_len];
 595
 596         offset = pc - (long)&ex->insn;
 597         if (WARN_ON_ONCE(offset >= 0 || offset < INT_MIN))
 598                 return -ERANGE;
 599         ex->insn = offset;
 600
 601         /*
 602          * Since the extable follows the program, the fixup offset is always
 603          * negative and limited to BPF_JIT_REGION_SIZE. Store a positive value
 604          * to keep things simple, and put the destination register in the upper
 605          * bits. We don't need to worry about buildtime or runtime sort
 606          * modifying the upper bits because the table is already sorted, and
 607          * isn't part of the main exception table.
 608          */
 609         offset = (long)&ex->fixup - (pc + insn_len * sizeof(u16));
 610         if (!FIELD_FIT(BPF_FIXUP_OFFSET_MASK, offset))
 611                 return -ERANGE;
 612
 613         ex->fixup = FIELD_PREP(BPF_FIXUP_OFFSET_MASK, offset) |
 614                 FIELD_PREP(BPF_FIXUP_REG_MASK, dst_reg);
 615         ex->type = EX_TYPE_BPF;
 616
 617         ctx->nexentries++;
 618         return 0;
 619 }
 620
 621 static int gen_call_or_nops(void *target, void *ip, u32 *insns)
 622 {
 623         s64 rvoff;
 624         int i, ret;
 625         struct rv_jit_context ctx;
 626
 627         ctx.ninsns = 0;
 628         ctx.insns = (u16 *)insns;
 629
 630         if (!target) {
 631                 for (i = 0; i < 4; i++)
 632                         emit(rv_nop(), &ctx);
 633                 return 0;
 634         }
 635
 636         rvoff = (s64)(target - (ip + 4));
 637         emit(rv_sd(RV_REG_SP, -8, RV_REG_RA), &ctx);
 638         ret = emit_jump_and_link(RV_REG_RA, rvoff, false, &ctx);
 639         if (ret)
 640                 return ret;
 641         emit(rv_ld(RV_REG_RA, -8, RV_REG_SP), &ctx);
 642
 643         return 0;
 644 }
 645
 646 static int gen_jump_or_nops(void *target, void *ip, u32 *insns)
 647 {
 648         s64 rvoff;
 649         struct rv_jit_context ctx;
 650
 651         ctx.ninsns = 0;
 652         ctx.insns = (u16 *)insns;
 653
 654         if (!target) {
 655                 emit(rv_nop(), &ctx);
 656                 emit(rv_nop(), &ctx);
 657                 return 0;
 658         }
 659
 660         rvoff = (s64)(target - ip);
 661         return emit_jump_and_link(RV_REG_ZERO, rvoff, false, &ctx);
 662 }
 663
 664 int bpf_arch_text_poke(void *ip, enum bpf_text_poke_type poke_type,
 665                        void *old_addr, void *new_addr)
 666 {
 667         u32 old_insns[4], new_insns[4];
 668         bool is_call = poke_type == BPF_MOD_CALL;
 669         int (*gen_insns)(void *target, void *ip, u32 *insns);
 670         int ninsns = is_call ? 4 : 2;
 671         int ret;
 672
 673         if (!is_bpf_text_address((unsigned long)ip))
 674                 return -ENOTSUPP;
 675
 676         gen_insns = is_call ? gen_call_or_nops : gen_jump_or_nops;
 677
 678         ret = gen_insns(old_addr, ip, old_insns);
 679         if (ret)
 680                 return ret;
 681
 682         if (memcmp(ip, old_insns, ninsns * 4))
 683                 return -EFAULT;
 684
 685         ret = gen_insns(new_addr, ip, new_insns);
 686         if (ret)
 687                 return ret;
 688
 689         cpus_read_lock();
 690         mutex_lock(&text_mutex);
 691         if (memcmp(ip, new_insns, ninsns * 4))
 692                 ret = patch_text(ip, new_insns, ninsns);
 693         mutex_unlock(&text_mutex);
 694         cpus_read_unlock();
 695
 696         return ret;
 697 }
 698
 699 static void store_args(int nregs, int args_off, struct rv_jit_context *ctx)
 700 {
 701         int i;
 702
 703         for (i = 0; i < nregs; i++) {
 704                 emit_sd(RV_REG_FP, -args_off, RV_REG_A0 + i, ctx);
 705                 args_off -= 8;
 706         }
 707 }
 708
 709 static void restore_args(int nregs, int args_off, struct rv_jit_context *ctx)
 710 {
 711         int i;
 712
 713         for (i = 0; i < nregs; i++) {
 714                 emit_ld(RV_REG_A0 + i, -args_off, RV_REG_FP, ctx);
 715                 args_off -= 8;
 716         }
 717 }
 718
 719 static int invoke_bpf_prog(struct bpf_tramp_link *l, int args_off, int retval_off,
 720                            int run_ctx_off, bool save_ret, struct rv_jit_context *ctx)
 721 {
 722         int ret, branch_off;
 723         struct bpf_prog *p = l->link.prog;
 724         int cookie_off = offsetof(struct bpf_tramp_run_ctx, bpf_cookie);
 725
 726         if (l->cookie) {
 727                 emit_imm(RV_REG_T1, l->cookie, ctx);
 728                 emit_sd(RV_REG_FP, -run_ctx_off + cookie_off, RV_REG_T1, ctx);
 729         } else {
 730                 emit_sd(RV_REG_FP, -run_ctx_off + cookie_off, RV_REG_ZERO, ctx);
 731         }
 732
 733         /* arg1: prog */
 734         emit_imm(RV_REG_A0, (const s64)p, ctx);
 735         /* arg2: &run_ctx */
 736         emit_addi(RV_REG_A1, RV_REG_FP, -run_ctx_off, ctx);
 737         ret = emit_call((const u64)bpf_trampoline_enter(p), true, ctx);
 738         if (ret)
 739                 return ret;
 740
 741         /* if (__bpf_prog_enter(prog) == 0)
 742          *      goto skip_exec_of_prog;
 743          */
 744         branch_off = ctx->ninsns;
 745         /* nop reserved for conditional jump */
 746         emit(rv_nop(), ctx);
 747
 748         /* store prog start time */
 749         emit_mv(RV_REG_S1, RV_REG_A0, ctx);
 750
 751         /* arg1: &args_off */
 752         emit_addi(RV_REG_A0, RV_REG_FP, -args_off, ctx);
 753         if (!p->jited)
 754                 /* arg2: progs[i]->insnsi for interpreter */
 755                 emit_imm(RV_REG_A1, (const s64)p->insnsi, ctx);
 756         ret = emit_call((const u64)p->bpf_func, true, ctx);
 757         if (ret)
 758                 return ret;
 759
 760         if (save_ret)
 761                 emit_sd(RV_REG_FP, -retval_off, regmap[BPF_REG_0], ctx);
 762
 763         /* update branch with beqz */
 764         if (ctx->insns) {
 765                 int offset = ninsns_rvoff(ctx->ninsns - branch_off);
 766                 u32 insn = rv_beq(RV_REG_A0, RV_REG_ZERO, offset >> 1);
 767                 *(u32 *)(ctx->insns + branch_off) = insn;
 768         }
 769
 770         /* arg1: prog */
 771         emit_imm(RV_REG_A0, (const s64)p, ctx);
 772         /* arg2: prog start time */
 773         emit_mv(RV_REG_A1, RV_REG_S1, ctx);
 774         /* arg3: &run_ctx */
 775         emit_addi(RV_REG_A2, RV_REG_FP, -run_ctx_off, ctx);
 776         ret = emit_call((const u64)bpf_trampoline_exit(p), true, ctx);
 777
 778         return ret;
 779 }
 780
 781 static int __arch_prepare_bpf_trampoline(struct bpf_tramp_image *im,
 782                                          const struct btf_func_model *m,
 783                                          struct bpf_tramp_links *tlinks,
 784                                          void *func_addr, u32 flags,
 785                                          struct rv_jit_context *ctx)
 786 {
 787         int i, ret, offset;
 788         int *branches_off = NULL;
 789         int stack_size = 0, nregs = m->nr_args;
 790         int retaddr_off, fp_off, retval_off, args_off;
 791         int nregs_off, ip_off, run_ctx_off, sreg_off;
 792         struct bpf_tramp_links *fentry = &tlinks[BPF_TRAMP_FENTRY];
 793         struct bpf_tramp_links *fexit = &tlinks[BPF_TRAMP_FEXIT];
 794         struct bpf_tramp_links *fmod_ret = &tlinks[BPF_TRAMP_MODIFY_RETURN];
 795         void *orig_call = func_addr;
 796         bool save_ret;
 797         u32 insn;
 798
 799         /* Generated trampoline stack layout:
 800          *
 801          * FP - 8           [ RA of parent func ] return address of parent
 802          *                                        function
 803          * FP - retaddr_off [ RA of traced func ] return address of traced
 804          *                                        function
 805          * FP - fp_off      [ FP of parent func ]
 806          *
 807          * FP - retval_off  [ return value      ] BPF_TRAMP_F_CALL_ORIG or
 808          *                                        BPF_TRAMP_F_RET_FENTRY_RET
 809          *                  [ argN              ]
 810          *                  [ ...               ]
 811          * FP - args_off    [ arg1              ]
 812          *
 813          * FP - nregs_off   [ regs count        ]
 814          *
 815          * FP - ip_off      [ traced func       ] BPF_TRAMP_F_IP_ARG
 816          *
 817          * FP - run_ctx_off [ bpf_tramp_run_ctx ]
 818          *
 819          * FP - sreg_off    [ callee saved reg  ]
 820          *
 821          *                  [ pads              ] pads for 16 bytes alignment
 822          */
 823
 824         if (flags & (BPF_TRAMP_F_ORIG_STACK | BPF_TRAMP_F_SHARE_IPMODIFY))
 825                 return -ENOTSUPP;
 826
 827         /* extra regiters for struct arguments */
 828         for (i = 0; i < m->nr_args; i++)
 829                 if (m->arg_flags[i] & BTF_FMODEL_STRUCT_ARG)
 830                         nregs += round_up(m->arg_size[i], 8) / 8 - 1;
 831
 832         /* 8 arguments passed by registers */
 833         if (nregs > 8)
 834                 return -ENOTSUPP;
 835
 836         /* room for parent function return address */
 837         stack_size += 8;
 838
 839         stack_size += 8;
 840         retaddr_off = stack_size;
 841
 842         stack_size += 8;
 843         fp_off = stack_size;
 844
 845         save_ret = flags & (BPF_TRAMP_F_CALL_ORIG | BPF_TRAMP_F_RET_FENTRY_RET);
 846         if (save_ret) {
 847                 stack_size += 8;
 848                 retval_off = stack_size;
 849         }
 850
 851         stack_size += nregs * 8;
 852         args_off = stack_size;
 853
 854         stack_size += 8;
 855         nregs_off = stack_size;
 856
 857         if (flags & BPF_TRAMP_F_IP_ARG) {
 858                 stack_size += 8;
 859                 ip_off = stack_size;
 860         }
 861
 862         stack_size += round_up(sizeof(struct bpf_tramp_run_ctx), 8);
 863         run_ctx_off = stack_size;
 864
 865         stack_size += 8;
 866         sreg_off = stack_size;
 867
 868         stack_size = round_up(stack_size, 16);
 869
 870         emit_addi(RV_REG_SP, RV_REG_SP, -stack_size, ctx);
 871
 872         emit_sd(RV_REG_SP, stack_size - retaddr_off, RV_REG_RA, ctx);
 873         emit_sd(RV_REG_SP, stack_size - fp_off, RV_REG_FP, ctx);
 874
 875         emit_addi(RV_REG_FP, RV_REG_SP, stack_size, ctx);
 876
 877         /* callee saved register S1 to pass start time */
 878         emit_sd(RV_REG_FP, -sreg_off, RV_REG_S1, ctx);
 879
 880         /* store ip address of the traced function */
 881         if (flags & BPF_TRAMP_F_IP_ARG) {
 882                 emit_imm(RV_REG_T1, (const s64)func_addr, ctx);
 883                 emit_sd(RV_REG_FP, -ip_off, RV_REG_T1, ctx);
 884         }
 885
 886         emit_li(RV_REG_T1, nregs, ctx);
 887         emit_sd(RV_REG_FP, -nregs_off, RV_REG_T1, ctx);
 888
 889         store_args(nregs, args_off, ctx);
 890
 891         /* skip to actual body of traced function */
 892         if (flags & BPF_TRAMP_F_SKIP_FRAME)
 893                 orig_call += 16;
 894
 895         if (flags & BPF_TRAMP_F_CALL_ORIG) {
 896                 emit_imm(RV_REG_A0, (const s64)im, ctx);
 897                 ret = emit_call((const u64)__bpf_tramp_enter, true, ctx);
 898                 if (ret)
 899                         return ret;
 900         }
 901
 902         for (i = 0; i < fentry->nr_links; i++) {
 903                 ret = invoke_bpf_prog(fentry->links[i], args_off, retval_off, run_ctx_off,
 904                                       flags & BPF_TRAMP_F_RET_FENTRY_RET, ctx);
 905                 if (ret)
 906                         return ret;
 907         }
 908
 909         if (fmod_ret->nr_links) {
 910                 branches_off = kcalloc(fmod_ret->nr_links, sizeof(int), GFP_KERNEL);
 911                 if (!branches_off)
 912                         return -ENOMEM;
 913
 914                 /* cleanup to avoid garbage return value confusion */
 915                 emit_sd(RV_REG_FP, -retval_off, RV_REG_ZERO, ctx);
 916                 for (i = 0; i < fmod_ret->nr_links; i++) {
 917                         ret = invoke_bpf_prog(fmod_ret->links[i], args_off, retval_off,
 918                                               run_ctx_off, true, ctx);
 919                         if (ret)
 920                                 goto out;
 921                         emit_ld(RV_REG_T1, -retval_off, RV_REG_FP, ctx);
 922                         branches_off[i] = ctx->ninsns;
 923                         /* nop reserved for conditional jump */
 924                         emit(rv_nop(), ctx);
 925                 }
 926         }
 927
 928         if (flags & BPF_TRAMP_F_CALL_ORIG) {
 929                 restore_args(nregs, args_off, ctx);
 930                 ret = emit_call((const u64)orig_call, true, ctx);
 931                 if (ret)
 932                         goto out;
 933                 emit_sd(RV_REG_FP, -retval_off, RV_REG_A0, ctx);
 934                 im->ip_after_call = ctx->insns + ctx->ninsns;
 935                 /* 2 nops reserved for auipc+jalr pair */
 936                 emit(rv_nop(), ctx);
 937                 emit(rv_nop(), ctx);
 938         }
 939
 940         /* update branches saved in invoke_bpf_mod_ret with bnez */
 941         for (i = 0; ctx->insns && i < fmod_ret->nr_links; i++) {
 942                 offset = ninsns_rvoff(ctx->ninsns - branches_off[i]);
 943                 insn = rv_bne(RV_REG_T1, RV_REG_ZERO, offset >> 1);
 944                 *(u32 *)(ctx->insns + branches_off[i]) = insn;
 945         }
 946
 947         for (i = 0; i < fexit->nr_links; i++) {
 948                 ret = invoke_bpf_prog(fexit->links[i], args_off, retval_off,
 949                                       run_ctx_off, false, ctx);
 950                 if (ret)
 951                         goto out;
 952         }
 953
 954         if (flags & BPF_TRAMP_F_CALL_ORIG) {
 955                 im->ip_epilogue = ctx->insns + ctx->ninsns;
 956                 emit_imm(RV_REG_A0, (const s64)im, ctx);
 957                 ret = emit_call((const u64)__bpf_tramp_exit, true, ctx);
 958                 if (ret)
 959                         goto out;
 960         }
 961
 962         if (flags & BPF_TRAMP_F_RESTORE_REGS)
 963                 restore_args(nregs, args_off, ctx);
 964
 965         if (save_ret)
 966                 emit_ld(RV_REG_A0, -retval_off, RV_REG_FP, ctx);
 967
 968         emit_ld(RV_REG_S1, -sreg_off, RV_REG_FP, ctx);
 969
 970         if (flags & BPF_TRAMP_F_SKIP_FRAME)
 971                 /* return address of parent function */
 972                 emit_ld(RV_REG_RA, stack_size - 8, RV_REG_SP, ctx);
 973         else
 974                 /* return address of traced function */
 975                 emit_ld(RV_REG_RA, stack_size - retaddr_off, RV_REG_SP, ctx);
 976
 977         emit_ld(RV_REG_FP, stack_size - fp_off, RV_REG_SP, ctx);
 978         emit_addi(RV_REG_SP, RV_REG_SP, stack_size, ctx);
 979
 980         emit_jalr(RV_REG_ZERO, RV_REG_RA, 0, ctx);
 981
 982         ret = ctx->ninsns;
 983 out:
 984         kfree(branches_off);
 985         return ret;
 986 }
 987
 988 int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image,
 989                                 void *image_end, const struct btf_func_model *m,
 990                                 u32 flags, struct bpf_tramp_links *tlinks,
 991                                 void *func_addr)
 992 {
 993         int ret;
 994         struct rv_jit_context ctx;
 995
 996         ctx.ninsns = 0;
 997         ctx.insns = NULL;
 998         ret = __arch_prepare_bpf_trampoline(im, m, tlinks, func_addr, flags, &ctx);
 999         if (ret < 0)
1000                 return ret;
1001
1002         if (ninsns_rvoff(ret) > (long)image_end - (long)image)
1003                 return -EFBIG;
1004
1005         ctx.ninsns = 0;
1006         ctx.insns = image;
1007         ret = __arch_prepare_bpf_trampoline(im, m, tlinks, func_addr, flags, &ctx);
1008         if (ret < 0)
1009                 return ret;
1010
1011         bpf_flush_icache(ctx.insns, ctx.insns + ctx.ninsns);
1012
1013         return ninsns_rvoff(ret);
1014 }
1015
1016 int bpf_jit_emit_insn(const struct bpf_insn *insn, struct rv_jit_context *ctx,
1017                       bool extra_pass)
1018 {
1019         bool is64 = BPF_CLASS(insn->code) == BPF_ALU64 ||
1020                     BPF_CLASS(insn->code) == BPF_JMP;
1021         int s, e, rvoff, ret, i = insn - ctx->prog->insnsi;
1022         struct bpf_prog_aux *aux = ctx->prog->aux;
1023         u8 rd = -1, rs = -1, code = insn->code;
1024         s16 off = insn->off;
1025         s32 imm = insn->imm;
1026
1027         init_regs(&rd, &rs, insn, ctx);
1028
1029         switch (code) {
1030         /* dst = src */
1031         case BPF_ALU | BPF_MOV | BPF_X:
1032         case BPF_ALU64 | BPF_MOV | BPF_X:
1033                 if (imm == 1) {
1034                         /* Special mov32 for zext */
1035                         emit_zext_32(rd, ctx);
1036                         break;
1037                 }
1038                 emit_mv(rd, rs, ctx);
1039                 if (!is64 && !aux->verifier_zext)
1040                         emit_zext_32(rd, ctx);
1041                 break;
1042
1043         /* dst = dst OP src */
1044         case BPF_ALU | BPF_ADD | BPF_X:
1045         case BPF_ALU64 | BPF_ADD | BPF_X:
1046                 emit_add(rd, rd, rs, ctx);
1047                 if (!is64 && !aux->verifier_zext)
1048                         emit_zext_32(rd, ctx);
1049                 break;
1050         case BPF_ALU | BPF_SUB | BPF_X:
1051         case BPF_ALU64 | BPF_SUB | BPF_X:
1052                 if (is64)
1053                         emit_sub(rd, rd, rs, ctx);
1054                 else
1055                         emit_subw(rd, rd, rs, ctx);
1056
1057                 if (!is64 && !aux->verifier_zext)
1058                         emit_zext_32(rd, ctx);
1059                 break;
1060         case BPF_ALU | BPF_AND | BPF_X:
1061         case BPF_ALU64 | BPF_AND | BPF_X:
1062                 emit_and(rd, rd, rs, ctx);
1063                 if (!is64 && !aux->verifier_zext)
1064                         emit_zext_32(rd, ctx);
1065                 break;
1066         case BPF_ALU | BPF_OR | BPF_X:
1067         case BPF_ALU64 | BPF_OR | BPF_X:
1068                 emit_or(rd, rd, rs, ctx);
1069                 if (!is64 && !aux->verifier_zext)
1070                         emit_zext_32(rd, ctx);
1071                 break;
1072         case BPF_ALU | BPF_XOR | BPF_X:
1073         case BPF_ALU64 | BPF_XOR | BPF_X:
1074                 emit_xor(rd, rd, rs, ctx);
1075                 if (!is64 && !aux->verifier_zext)
1076                         emit_zext_32(rd, ctx);
1077                 break;
1078         case BPF_ALU | BPF_MUL | BPF_X:
1079         case BPF_ALU64 | BPF_MUL | BPF_X:
1080                 emit(is64 ? rv_mul(rd, rd, rs) : rv_mulw(rd, rd, rs), ctx);
1081                 if (!is64 && !aux->verifier_zext)
1082                         emit_zext_32(rd, ctx);
1083                 break;
1084         case BPF_ALU | BPF_DIV | BPF_X:
1085         case BPF_ALU64 | BPF_DIV | BPF_X:
1086                 emit(is64 ? rv_divu(rd, rd, rs) : rv_divuw(rd, rd, rs), ctx);
1087                 if (!is64 && !aux->verifier_zext)
1088                         emit_zext_32(rd, ctx);
1089                 break;
1090         case BPF_ALU | BPF_MOD | BPF_X:
1091         case BPF_ALU64 | BPF_MOD | BPF_X:
1092                 emit(is64 ? rv_remu(rd, rd, rs) : rv_remuw(rd, rd, rs), ctx);
1093                 if (!is64 && !aux->verifier_zext)
1094                         emit_zext_32(rd, ctx);
1095                 break;
1096         case BPF_ALU | BPF_LSH | BPF_X:
1097         case BPF_ALU64 | BPF_LSH | BPF_X:
1098                 emit(is64 ? rv_sll(rd, rd, rs) : rv_sllw(rd, rd, rs), ctx);
1099                 if (!is64 && !aux->verifier_zext)
1100                         emit_zext_32(rd, ctx);
1101                 break;
1102         case BPF_ALU | BPF_RSH | BPF_X:
1103         case BPF_ALU64 | BPF_RSH | BPF_X:
1104                 emit(is64 ? rv_srl(rd, rd, rs) : rv_srlw(rd, rd, rs), ctx);
1105                 if (!is64 && !aux->verifier_zext)
1106                         emit_zext_32(rd, ctx);
1107                 break;
1108         case BPF_ALU | BPF_ARSH | BPF_X:
1109         case BPF_ALU64 | BPF_ARSH | BPF_X:
1110                 emit(is64 ? rv_sra(rd, rd, rs) : rv_sraw(rd, rd, rs), ctx);
1111                 if (!is64 && !aux->verifier_zext)
1112                         emit_zext_32(rd, ctx);
1113                 break;
1114
1115         /* dst = -dst */
1116         case BPF_ALU | BPF_NEG:
1117         case BPF_ALU64 | BPF_NEG:
1118                 emit_sub(rd, RV_REG_ZERO, rd, ctx);
1119                 if (!is64 && !aux->verifier_zext)
1120                         emit_zext_32(rd, ctx);
1121                 break;
1122
1123         /* dst = BSWAP##imm(dst) */
1124         case BPF_ALU | BPF_END | BPF_FROM_LE:
1125                 switch (imm) {
1126                 case 16:
1127                         emit_slli(rd, rd, 48, ctx);
1128                         emit_srli(rd, rd, 48, ctx);
1129                         break;
1130                 case 32:
1131                         if (!aux->verifier_zext)
1132                                 emit_zext_32(rd, ctx);
1133                         break;
1134                 case 64:
1135                         /* Do nothing */
1136                         break;
1137                 }
1138                 break;
1139
1140         case BPF_ALU | BPF_END | BPF_FROM_BE:
1141                 emit_li(RV_REG_T2, 0, ctx);
1142
1143                 emit_andi(RV_REG_T1, rd, 0xff, ctx);
1144                 emit_add(RV_REG_T2, RV_REG_T2, RV_REG_T1, ctx);
1145                 emit_slli(RV_REG_T2, RV_REG_T2, 8, ctx);
1146                 emit_srli(rd, rd, 8, ctx);
1147                 if (imm == 16)
1148                         goto out_be;
1149
1150                 emit_andi(RV_REG_T1, rd, 0xff, ctx);
1151                 emit_add(RV_REG_T2, RV_REG_T2, RV_REG_T1, ctx);
1152                 emit_slli(RV_REG_T2, RV_REG_T2, 8, ctx);
1153                 emit_srli(rd, rd, 8, ctx);
1154
1155                 emit_andi(RV_REG_T1, rd, 0xff, ctx);
1156                 emit_add(RV_REG_T2, RV_REG_T2, RV_REG_T1, ctx);
1157                 emit_slli(RV_REG_T2, RV_REG_T2, 8, ctx);
1158                 emit_srli(rd, rd, 8, ctx);
1159                 if (imm == 32)
1160                         goto out_be;
1161
1162                 emit_andi(RV_REG_T1, rd, 0xff, ctx);
1163                 emit_add(RV_REG_T2, RV_REG_T2, RV_REG_T1, ctx);
1164                 emit_slli(RV_REG_T2, RV_REG_T2, 8, ctx);
1165                 emit_srli(rd, rd, 8, ctx);
1166
1167                 emit_andi(RV_REG_T1, rd, 0xff, ctx);
1168                 emit_add(RV_REG_T2, RV_REG_T2, RV_REG_T1, ctx);
1169                 emit_slli(RV_REG_T2, RV_REG_T2, 8, ctx);
1170                 emit_srli(rd, rd, 8, ctx);
1171
1172                 emit_andi(RV_REG_T1, rd, 0xff, ctx);
1173                 emit_add(RV_REG_T2, RV_REG_T2, RV_REG_T1, ctx);
1174                 emit_slli(RV_REG_T2, RV_REG_T2, 8, ctx);
1175                 emit_srli(rd, rd, 8, ctx);
1176
1177                 emit_andi(RV_REG_T1, rd, 0xff, ctx);
1178                 emit_add(RV_REG_T2, RV_REG_T2, RV_REG_T1, ctx);
1179                 emit_slli(RV_REG_T2, RV_REG_T2, 8, ctx);
1180                 emit_srli(rd, rd, 8, ctx);
1181 out_be:
1182                 emit_andi(RV_REG_T1, rd, 0xff, ctx);
1183                 emit_add(RV_REG_T2, RV_REG_T2, RV_REG_T1, ctx);
1184
1185                 emit_mv(rd, RV_REG_T2, ctx);
1186                 break;
1187
1188         /* dst = imm */
1189         case BPF_ALU | BPF_MOV | BPF_K:
1190         case BPF_ALU64 | BPF_MOV | BPF_K:
1191                 emit_imm(rd, imm, ctx);
1192                 if (!is64 && !aux->verifier_zext)
1193                         emit_zext_32(rd, ctx);
1194                 break;
1195
1196         /* dst = dst OP imm */
1197         case BPF_ALU | BPF_ADD | BPF_K:
1198         case BPF_ALU64 | BPF_ADD | BPF_K:
1199                 if (is_12b_int(imm)) {
1200                         emit_addi(rd, rd, imm, ctx);
1201                 } else {
1202                         emit_imm(RV_REG_T1, imm, ctx);
1203                         emit_add(rd, rd, RV_REG_T1, ctx);
1204                 }
1205                 if (!is64 && !aux->verifier_zext)
1206                         emit_zext_32(rd, ctx);
1207                 break;
1208         case BPF_ALU | BPF_SUB | BPF_K:
1209         case BPF_ALU64 | BPF_SUB | BPF_K:
1210                 if (is_12b_int(-imm)) {
1211                         emit_addi(rd, rd, -imm, ctx);
1212                 } else {
1213                         emit_imm(RV_REG_T1, imm, ctx);
1214                         emit_sub(rd, rd, RV_REG_T1, ctx);
1215                 }
1216                 if (!is64 && !aux->verifier_zext)
1217                         emit_zext_32(rd, ctx);
1218                 break;
1219         case BPF_ALU | BPF_AND | BPF_K:
1220         case BPF_ALU64 | BPF_AND | BPF_K:
1221                 if (is_12b_int(imm)) {
1222                         emit_andi(rd, rd, imm, ctx);
1223                 } else {
1224                         emit_imm(RV_REG_T1, imm, ctx);
1225                         emit_and(rd, rd, RV_REG_T1, ctx);
1226                 }
1227                 if (!is64 && !aux->verifier_zext)
1228                         emit_zext_32(rd, ctx);
1229                 break;
1230         case BPF_ALU | BPF_OR | BPF_K:
1231         case BPF_ALU64 | BPF_OR | BPF_K:
1232                 if (is_12b_int(imm)) {
1233                         emit(rv_ori(rd, rd, imm), ctx);
1234                 } else {
1235                         emit_imm(RV_REG_T1, imm, ctx);
1236                         emit_or(rd, rd, RV_REG_T1, ctx);
1237                 }
1238                 if (!is64 && !aux->verifier_zext)
1239                         emit_zext_32(rd, ctx);
1240                 break;
1241         case BPF_ALU | BPF_XOR | BPF_K:
1242         case BPF_ALU64 | BPF_XOR | BPF_K:
1243                 if (is_12b_int(imm)) {
1244                         emit(rv_xori(rd, rd, imm), ctx);
1245                 } else {
1246                         emit_imm(RV_REG_T1, imm, ctx);
1247                         emit_xor(rd, rd, RV_REG_T1, ctx);
1248                 }
1249                 if (!is64 && !aux->verifier_zext)
1250                         emit_zext_32(rd, ctx);
1251                 break;
1252         case BPF_ALU | BPF_MUL | BPF_K:
1253         case BPF_ALU64 | BPF_MUL | BPF_K:
1254                 emit_imm(RV_REG_T1, imm, ctx);
1255                 emit(is64 ? rv_mul(rd, rd, RV_REG_T1) :
1256                      rv_mulw(rd, rd, RV_REG_T1), ctx);
1257                 if (!is64 && !aux->verifier_zext)
1258                         emit_zext_32(rd, ctx);
1259                 break;
1260         case BPF_ALU | BPF_DIV | BPF_K:
1261         case BPF_ALU64 | BPF_DIV | BPF_K:
1262                 emit_imm(RV_REG_T1, imm, ctx);
1263                 emit(is64 ? rv_divu(rd, rd, RV_REG_T1) :
1264                      rv_divuw(rd, rd, RV_REG_T1), ctx);
1265                 if (!is64 && !aux->verifier_zext)
1266                         emit_zext_32(rd, ctx);
1267                 break;
1268         case BPF_ALU | BPF_MOD | BPF_K:
1269         case BPF_ALU64 | BPF_MOD | BPF_K:
1270                 emit_imm(RV_REG_T1, imm, ctx);
1271                 emit(is64 ? rv_remu(rd, rd, RV_REG_T1) :
1272                      rv_remuw(rd, rd, RV_REG_T1), ctx);
1273                 if (!is64 && !aux->verifier_zext)
1274                         emit_zext_32(rd, ctx);
1275                 break;
1276         case BPF_ALU | BPF_LSH | BPF_K:
1277         case BPF_ALU64 | BPF_LSH | BPF_K:
1278                 emit_slli(rd, rd, imm, ctx);
1279
1280                 if (!is64 && !aux->verifier_zext)
1281                         emit_zext_32(rd, ctx);
1282                 break;
1283         case BPF_ALU | BPF_RSH | BPF_K:
1284         case BPF_ALU64 | BPF_RSH | BPF_K:
1285                 if (is64)
1286                         emit_srli(rd, rd, imm, ctx);
1287                 else
1288                         emit(rv_srliw(rd, rd, imm), ctx);
1289
1290                 if (!is64 && !aux->verifier_zext)
1291                         emit_zext_32(rd, ctx);
1292                 break;
1293         case BPF_ALU | BPF_ARSH | BPF_K:
1294         case BPF_ALU64 | BPF_ARSH | BPF_K:
1295                 if (is64)
1296                         emit_srai(rd, rd, imm, ctx);
1297                 else
1298                         emit(rv_sraiw(rd, rd, imm), ctx);
1299
1300                 if (!is64 && !aux->verifier_zext)
1301                         emit_zext_32(rd, ctx);
1302                 break;
1303
1304         /* JUMP off */
1305         case BPF_JMP | BPF_JA:
1306                 rvoff = rv_offset(i, off, ctx);
1307                 ret = emit_jump_and_link(RV_REG_ZERO, rvoff, true, ctx);
1308                 if (ret)
1309                         return ret;
1310                 break;
1311
1312         /* IF (dst COND src) JUMP off */
1313         case BPF_JMP | BPF_JEQ | BPF_X:
1314         case BPF_JMP32 | BPF_JEQ | BPF_X:
1315         case BPF_JMP | BPF_JGT | BPF_X:
1316         case BPF_JMP32 | BPF_JGT | BPF_X:
1317         case BPF_JMP | BPF_JLT | BPF_X:
1318         case BPF_JMP32 | BPF_JLT | BPF_X:
1319         case BPF_JMP | BPF_JGE | BPF_X:
1320         case BPF_JMP32 | BPF_JGE | BPF_X:
1321         case BPF_JMP | BPF_JLE | BPF_X:
1322         case BPF_JMP32 | BPF_JLE | BPF_X:
1323         case BPF_JMP | BPF_JNE | BPF_X:
1324         case BPF_JMP32 | BPF_JNE | BPF_X:
1325         case BPF_JMP | BPF_JSGT | BPF_X:
1326         case BPF_JMP32 | BPF_JSGT | BPF_X:
1327         case BPF_JMP | BPF_JSLT | BPF_X:
1328         case BPF_JMP32 | BPF_JSLT | BPF_X:
1329         case BPF_JMP | BPF_JSGE | BPF_X:
1330         case BPF_JMP32 | BPF_JSGE | BPF_X:
1331         case BPF_JMP | BPF_JSLE | BPF_X:
1332         case BPF_JMP32 | BPF_JSLE | BPF_X:
1333         case BPF_JMP | BPF_JSET | BPF_X:
1334         case BPF_JMP32 | BPF_JSET | BPF_X:
1335                 rvoff = rv_offset(i, off, ctx);
1336                 if (!is64) {
1337                         s = ctx->ninsns;
1338                         if (is_signed_bpf_cond(BPF_OP(code)))
1339                                 emit_sext_32_rd_rs(&rd, &rs, ctx);
1340                         else
1341                                 emit_zext_32_rd_rs(&rd, &rs, ctx);
1342                         e = ctx->ninsns;
1343
1344                         /* Adjust for extra insns */
1345                         rvoff -= ninsns_rvoff(e - s);
1346                 }
1347
1348                 if (BPF_OP(code) == BPF_JSET) {
1349                         /* Adjust for and */
1350                         rvoff -= 4;
1351                         emit_and(RV_REG_T1, rd, rs, ctx);
1352                         emit_branch(BPF_JNE, RV_REG_T1, RV_REG_ZERO, rvoff,
1353                                     ctx);
1354                 } else {
1355                         emit_branch(BPF_OP(code), rd, rs, rvoff, ctx);
1356                 }
1357                 break;
1358
1359         /* IF (dst COND imm) JUMP off */
1360         case BPF_JMP | BPF_JEQ | BPF_K:
1361         case BPF_JMP32 | BPF_JEQ | BPF_K:
1362         case BPF_JMP | BPF_JGT | BPF_K:
1363         case BPF_JMP32 | BPF_JGT | BPF_K:
1364         case BPF_JMP | BPF_JLT | BPF_K:
1365         case BPF_JMP32 | BPF_JLT | BPF_K:
1366         case BPF_JMP | BPF_JGE | BPF_K:
1367         case BPF_JMP32 | BPF_JGE | BPF_K:
1368         case BPF_JMP | BPF_JLE | BPF_K:
1369         case BPF_JMP32 | BPF_JLE | BPF_K:
1370         case BPF_JMP | BPF_JNE | BPF_K:
1371         case BPF_JMP32 | BPF_JNE | BPF_K:
1372         case BPF_JMP | BPF_JSGT | BPF_K:
1373         case BPF_JMP32 | BPF_JSGT | BPF_K:
1374         case BPF_JMP | BPF_JSLT | BPF_K:
1375         case BPF_JMP32 | BPF_JSLT | BPF_K:
1376         case BPF_JMP | BPF_JSGE | BPF_K:
1377         case BPF_JMP32 | BPF_JSGE | BPF_K:
1378         case BPF_JMP | BPF_JSLE | BPF_K:
1379         case BPF_JMP32 | BPF_JSLE | BPF_K:
1380                 rvoff = rv_offset(i, off, ctx);
1381                 s = ctx->ninsns;
1382                 if (imm) {
1383                         emit_imm(RV_REG_T1, imm, ctx);
1384                         rs = RV_REG_T1;
1385                 } else {
1386                         /* If imm is 0, simply use zero register. */
1387                         rs = RV_REG_ZERO;
1388                 }
1389                 if (!is64) {
1390                         if (is_signed_bpf_cond(BPF_OP(code)))
1391                                 emit_sext_32_rd(&rd, ctx);
1392                         else
1393                                 emit_zext_32_rd_t1(&rd, ctx);
1394                 }
1395                 e = ctx->ninsns;
1396
1397                 /* Adjust for extra insns */
1398                 rvoff -= ninsns_rvoff(e - s);
1399                 emit_branch(BPF_OP(code), rd, rs, rvoff, ctx);
1400                 break;
1401
1402         case BPF_JMP | BPF_JSET | BPF_K:
1403         case BPF_JMP32 | BPF_JSET | BPF_K:
1404                 rvoff = rv_offset(i, off, ctx);
1405                 s = ctx->ninsns;
1406                 if (is_12b_int(imm)) {
1407                         emit_andi(RV_REG_T1, rd, imm, ctx);
1408                 } else {
1409                         emit_imm(RV_REG_T1, imm, ctx);
1410                         emit_and(RV_REG_T1, rd, RV_REG_T1, ctx);
1411                 }
1412                 /* For jset32, we should clear the upper 32 bits of t1, but
1413                  * sign-extension is sufficient here and saves one instruction,
1414                  * as t1 is used only in comparison against zero.
1415                  */
1416                 if (!is64 && imm < 0)
1417                         emit_addiw(RV_REG_T1, RV_REG_T1, 0, ctx);
1418                 e = ctx->ninsns;
1419                 rvoff -= ninsns_rvoff(e - s);
1420                 emit_branch(BPF_JNE, RV_REG_T1, RV_REG_ZERO, rvoff, ctx);
1421                 break;
1422
1423         /* function call */
1424         case BPF_JMP | BPF_CALL:
1425         {
1426                 bool fixed_addr;
1427                 u64 addr;
1428
1429                 mark_call(ctx);
1430                 ret = bpf_jit_get_func_addr(ctx->prog, insn, extra_pass,
1431                                             &addr, &fixed_addr);
1432                 if (ret < 0)
1433                         return ret;
1434
1435                 ret = emit_call(addr, fixed_addr, ctx);
1436                 if (ret)
1437                         return ret;
1438
1439                 emit_mv(bpf_to_rv_reg(BPF_REG_0, ctx), RV_REG_A0, ctx);
1440                 break;
1441         }
1442         /* tail call */
1443         case BPF_JMP | BPF_TAIL_CALL:
1444                 if (emit_bpf_tail_call(i, ctx))
1445                         return -1;
1446                 break;
1447
1448         /* function return */
1449         case BPF_JMP | BPF_EXIT:
1450                 if (i == ctx->prog->len - 1)
1451                         break;
1452
1453                 rvoff = epilogue_offset(ctx);
1454                 ret = emit_jump_and_link(RV_REG_ZERO, rvoff, true, ctx);
1455                 if (ret)
1456                         return ret;
1457                 break;
1458
1459         /* dst = imm64 */
1460         case BPF_LD | BPF_IMM | BPF_DW:
1461         {
1462                 struct bpf_insn insn1 = insn[1];
1463                 u64 imm64;
1464
1465                 imm64 = (u64)insn1.imm << 32 | (u32)imm;
1466                 if (bpf_pseudo_func(insn)) {
1467                         /* fixed-length insns for extra jit pass */
1468                         ret = emit_addr(rd, imm64, extra_pass, ctx);
1469                         if (ret)
1470                                 return ret;
1471                 } else {
1472                         emit_imm(rd, imm64, ctx);
1473                 }
1474
1475                 return 1;
1476         }
1477
1478         /* LDX: dst = *(size *)(src + off) */
1479         case BPF_LDX | BPF_MEM | BPF_B:
1480         case BPF_LDX | BPF_MEM | BPF_H:
1481         case BPF_LDX | BPF_MEM | BPF_W:
1482         case BPF_LDX | BPF_MEM | BPF_DW:
1483         case BPF_LDX | BPF_PROBE_MEM | BPF_B:
1484         case BPF_LDX | BPF_PROBE_MEM | BPF_H:
1485         case BPF_LDX | BPF_PROBE_MEM | BPF_W:
1486         case BPF_LDX | BPF_PROBE_MEM | BPF_DW:
1487         {
1488                 int insn_len, insns_start;
1489
1490                 switch (BPF_SIZE(code)) {
1491                 case BPF_B:
1492                         if (is_12b_int(off)) {
1493                                 insns_start = ctx->ninsns;
1494                                 emit(rv_lbu(rd, off, rs), ctx);
1495                                 insn_len = ctx->ninsns - insns_start;
1496                                 break;
1497                         }
1498
1499                         emit_imm(RV_REG_T1, off, ctx);
1500                         emit_add(RV_REG_T1, RV_REG_T1, rs, ctx);
1501                         insns_start = ctx->ninsns;
1502                         emit(rv_lbu(rd, 0, RV_REG_T1), ctx);
1503                         insn_len = ctx->ninsns - insns_start;
1504                         if (insn_is_zext(&insn[1]))
1505                                 return 1;
1506                         break;
1507                 case BPF_H:
1508                         if (is_12b_int(off)) {
1509                                 insns_start = ctx->ninsns;
1510                                 emit(rv_lhu(rd, off, rs), ctx);
1511                                 insn_len = ctx->ninsns - insns_start;
1512                                 break;
1513                         }
1514
1515                         emit_imm(RV_REG_T1, off, ctx);
1516                         emit_add(RV_REG_T1, RV_REG_T1, rs, ctx);
1517                         insns_start = ctx->ninsns;
1518                         emit(rv_lhu(rd, 0, RV_REG_T1), ctx);
1519                         insn_len = ctx->ninsns - insns_start;
1520                         if (insn_is_zext(&insn[1]))
1521                                 return 1;
1522                         break;
1523                 case BPF_W:
1524                         if (is_12b_int(off)) {
1525                                 insns_start = ctx->ninsns;
1526                                 emit(rv_lwu(rd, off, rs), ctx);
1527                                 insn_len = ctx->ninsns - insns_start;
1528                                 break;
1529                         }
1530
1531                         emit_imm(RV_REG_T1, off, ctx);
1532                         emit_add(RV_REG_T1, RV_REG_T1, rs, ctx);
1533                         insns_start = ctx->ninsns;
1534                         emit(rv_lwu(rd, 0, RV_REG_T1), ctx);
1535                         insn_len = ctx->ninsns - insns_start;
1536                         if (insn_is_zext(&insn[1]))
1537                                 return 1;
1538                         break;
1539                 case BPF_DW:
1540                         if (is_12b_int(off)) {
1541                                 insns_start = ctx->ninsns;
1542                                 emit_ld(rd, off, rs, ctx);
1543                                 insn_len = ctx->ninsns - insns_start;
1544                                 break;
1545                         }
1546
1547                         emit_imm(RV_REG_T1, off, ctx);
1548                         emit_add(RV_REG_T1, RV_REG_T1, rs, ctx);
1549                         insns_start = ctx->ninsns;
1550                         emit_ld(rd, 0, RV_REG_T1, ctx);
1551                         insn_len = ctx->ninsns - insns_start;
1552                         break;
1553                 }
1554
1555                 ret = add_exception_handler(insn, ctx, rd, insn_len);
1556                 if (ret)
1557                         return ret;
1558                 break;
1559         }
1560         /* speculation barrier */
1561         case BPF_ST | BPF_NOSPEC:
1562                 break;
1563
1564         /* ST: *(size *)(dst + off) = imm */
1565         case BPF_ST | BPF_MEM | BPF_B:
1566                 emit_imm(RV_REG_T1, imm, ctx);
1567                 if (is_12b_int(off)) {
1568                         emit(rv_sb(rd, off, RV_REG_T1), ctx);
1569                         break;
1570                 }
1571
1572                 emit_imm(RV_REG_T2, off, ctx);
1573                 emit_add(RV_REG_T2, RV_REG_T2, rd, ctx);
1574                 emit(rv_sb(RV_REG_T2, 0, RV_REG_T1), ctx);
1575                 break;
1576
1577         case BPF_ST | BPF_MEM | BPF_H:
1578                 emit_imm(RV_REG_T1, imm, ctx);
1579                 if (is_12b_int(off)) {
1580                         emit(rv_sh(rd, off, RV_REG_T1), ctx);
1581                         break;
1582                 }
1583
1584                 emit_imm(RV_REG_T2, off, ctx);
1585                 emit_add(RV_REG_T2, RV_REG_T2, rd, ctx);
1586                 emit(rv_sh(RV_REG_T2, 0, RV_REG_T1), ctx);
1587                 break;
1588         case BPF_ST | BPF_MEM | BPF_W:
1589                 emit_imm(RV_REG_T1, imm, ctx);
1590                 if (is_12b_int(off)) {
1591                         emit_sw(rd, off, RV_REG_T1, ctx);
1592                         break;
1593                 }
1594
1595                 emit_imm(RV_REG_T2, off, ctx);
1596                 emit_add(RV_REG_T2, RV_REG_T2, rd, ctx);
1597                 emit_sw(RV_REG_T2, 0, RV_REG_T1, ctx);
1598                 break;
1599         case BPF_ST | BPF_MEM | BPF_DW:
1600                 emit_imm(RV_REG_T1, imm, ctx);
1601                 if (is_12b_int(off)) {
1602                         emit_sd(rd, off, RV_REG_T1, ctx);
1603                         break;
1604                 }
1605
1606                 emit_imm(RV_REG_T2, off, ctx);
1607                 emit_add(RV_REG_T2, RV_REG_T2, rd, ctx);
1608                 emit_sd(RV_REG_T2, 0, RV_REG_T1, ctx);
1609                 break;
1610
1611         /* STX: *(size *)(dst + off) = src */
1612         case BPF_STX | BPF_MEM | BPF_B:
1613                 if (is_12b_int(off)) {
1614                         emit(rv_sb(rd, off, rs), ctx);
1615                         break;
1616                 }
1617
1618                 emit_imm(RV_REG_T1, off, ctx);
1619                 emit_add(RV_REG_T1, RV_REG_T1, rd, ctx);
1620                 emit(rv_sb(RV_REG_T1, 0, rs), ctx);
1621                 break;
1622         case BPF_STX | BPF_MEM | BPF_H:
1623                 if (is_12b_int(off)) {
1624                         emit(rv_sh(rd, off, rs), ctx);
1625                         break;
1626                 }
1627
1628                 emit_imm(RV_REG_T1, off, ctx);
1629                 emit_add(RV_REG_T1, RV_REG_T1, rd, ctx);
1630                 emit(rv_sh(RV_REG_T1, 0, rs), ctx);
1631                 break;
1632         case BPF_STX | BPF_MEM | BPF_W:
1633                 if (is_12b_int(off)) {
1634                         emit_sw(rd, off, rs, ctx);
1635                         break;
1636                 }
1637
1638                 emit_imm(RV_REG_T1, off, ctx);
1639                 emit_add(RV_REG_T1, RV_REG_T1, rd, ctx);
1640                 emit_sw(RV_REG_T1, 0, rs, ctx);
1641                 break;
1642         case BPF_STX | BPF_MEM | BPF_DW:
1643                 if (is_12b_int(off)) {
1644                         emit_sd(rd, off, rs, ctx);
1645                         break;
1646                 }
1647
1648                 emit_imm(RV_REG_T1, off, ctx);
1649                 emit_add(RV_REG_T1, RV_REG_T1, rd, ctx);
1650                 emit_sd(RV_REG_T1, 0, rs, ctx);
1651                 break;
1652         case BPF_STX | BPF_ATOMIC | BPF_W:
1653         case BPF_STX | BPF_ATOMIC | BPF_DW:
1654                 emit_atomic(rd, rs, off, imm,
1655                             BPF_SIZE(code) == BPF_DW, ctx);
1656                 break;
1657         default:
1658                 pr_err("bpf-jit: unknown opcode %02x\n", code);
1659                 return -EINVAL;
1660         }
1661
1662         return 0;
1663 }
1664
1665 void bpf_jit_build_prologue(struct rv_jit_context *ctx)
1666 {
1667         int i, stack_adjust = 0, store_offset, bpf_stack_adjust;
1668
1669         bpf_stack_adjust = round_up(ctx->prog->aux->stack_depth, 16);
1670         if (bpf_stack_adjust)
1671                 mark_fp(ctx);
1672
1673         if (seen_reg(RV_REG_RA, ctx))
1674                 stack_adjust += 8;
1675         stack_adjust += 8; /* RV_REG_FP */
1676         if (seen_reg(RV_REG_S1, ctx))
1677                 stack_adjust += 8;
1678         if (seen_reg(RV_REG_S2, ctx))
1679                 stack_adjust += 8;
1680         if (seen_reg(RV_REG_S3, ctx))
1681                 stack_adjust += 8;
1682         if (seen_reg(RV_REG_S4, ctx))
1683                 stack_adjust += 8;
1684         if (seen_reg(RV_REG_S5, ctx))
1685                 stack_adjust += 8;
1686         if (seen_reg(RV_REG_S6, ctx))
1687                 stack_adjust += 8;
1688
1689         stack_adjust = round_up(stack_adjust, 16);
1690         stack_adjust += bpf_stack_adjust;
1691
1692         store_offset = stack_adjust - 8;
1693
1694         /* reserve 4 nop insns */
1695         for (i = 0; i < 4; i++)
1696                 emit(rv_nop(), ctx);
1697
1698         /* First instruction is always setting the tail-call-counter
1699          * (TCC) register. This instruction is skipped for tail calls.
1700          * Force using a 4-byte (non-compressed) instruction.
1701          */
1702         emit(rv_addi(RV_REG_TCC, RV_REG_ZERO, MAX_TAIL_CALL_CNT), ctx);
1703
1704         emit_addi(RV_REG_SP, RV_REG_SP, -stack_adjust, ctx);
1705
1706         if (seen_reg(RV_REG_RA, ctx)) {
1707                 emit_sd(RV_REG_SP, store_offset, RV_REG_RA, ctx);
1708                 store_offset -= 8;
1709         }
1710         emit_sd(RV_REG_SP, store_offset, RV_REG_FP, ctx);
1711         store_offset -= 8;
1712         if (seen_reg(RV_REG_S1, ctx)) {
1713                 emit_sd(RV_REG_SP, store_offset, RV_REG_S1, ctx);
1714                 store_offset -= 8;
1715         }
1716         if (seen_reg(RV_REG_S2, ctx)) {
1717                 emit_sd(RV_REG_SP, store_offset, RV_REG_S2, ctx);
1718                 store_offset -= 8;
1719         }
1720         if (seen_reg(RV_REG_S3, ctx)) {
1721                 emit_sd(RV_REG_SP, store_offset, RV_REG_S3, ctx);
1722                 store_offset -= 8;
1723         }
1724         if (seen_reg(RV_REG_S4, ctx)) {
1725                 emit_sd(RV_REG_SP, store_offset, RV_REG_S4, ctx);
1726                 store_offset -= 8;
1727         }
1728         if (seen_reg(RV_REG_S5, ctx)) {
1729                 emit_sd(RV_REG_SP, store_offset, RV_REG_S5, ctx);
1730                 store_offset -= 8;
1731         }
1732         if (seen_reg(RV_REG_S6, ctx)) {
1733                 emit_sd(RV_REG_SP, store_offset, RV_REG_S6, ctx);
1734                 store_offset -= 8;
1735         }
1736
1737         emit_addi(RV_REG_FP, RV_REG_SP, stack_adjust, ctx);
1738
1739         if (bpf_stack_adjust)
1740                 emit_addi(RV_REG_S5, RV_REG_SP, bpf_stack_adjust, ctx);
1741
1742         /* Program contains calls and tail calls, so RV_REG_TCC need
1743          * to be saved across calls.
1744          */
1745         if (seen_tail_call(ctx) && seen_call(ctx))
1746                 emit_mv(RV_REG_TCC_SAVED, RV_REG_TCC, ctx);
1747
1748         ctx->stack_size = stack_adjust;
1749 }
1750
1751 void bpf_jit_build_epilogue(struct rv_jit_context *ctx)
1752 {
1753         __build_epilogue(false, ctx);
1754 }