bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc JITs
Subsystems (2)
v2 cover bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc JITs
The parisc BPF JITs emit unsigned divide and remainder for signed BPF_DIV and BPF_MOD (off == 1), so neither implements signed BPF_SDIV and BPF_SMOD. Negative operands therefore produce unsigned results.
Patch 1 adds signed support to the parisc64 JIT and shared signed 64-bit helpers. Patch 2 adds support to the parisc32 JIT, using those helpers for ALU64 and the signed millicode routines for ALU32.
The original series was tested with test_bpf under QEMU on both JITs:
the signed division and remainder cases fail before and pass after. Helge has also tested the series on physical machines and QEMU. For this rebase, both JITs and test_bpf.o build with W=1. The source changes are unchanged from v1; no new runtime run is claimed for v2.
Changes in v2:
- Rebase on current bpf-next; no code changes.
- Add Helge's Acked-by and Tested-by to both patches.
v1: https://lore.kernel.org/bpf/[email protected]/
Nicholas Dudar (2):
bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc64 JIT bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc32 JIT
arch/parisc/net/bpf_jit.h | 2 ++ arch/parisc/net/bpf_jit_comp32.c | 29 +++++++++++++++++--------- arch/parisc/net/bpf_jit_comp64.c | 35 ++++++++++++++++++++++++-------- arch/parisc/net/bpf_jit_core.c | 14 +++++++++++++ 4 files changed, 61 insertions(+), 19 deletions(-)
base-commit: 5ef40d69b38a93bc9951dadb1a15c85c597e1a40
PATCH v2 1/2 bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc64 JIT
emit_call_libgcc_ll() zero-extends the ALU32 operands and calls the unsigned hppa_div64()/hppa_div64_rem() helpers regardless of the BPF instruction's signedness, so the parisc64 JIT does not implement signed BPF_SDIV and BPF_SMOD (off == 1). Signed ALU32 and ALU64 div/mod get an unsigned quotient and remainder rather than the verifier's and the interpreter's signed result for negative operands.
Add hppa_sdiv64()/hppa_sdiv64_rem() wrapping div64_s64(), thread is_signed = (insn->off == 1) through the div/mod emit sites, and on the signed path sign-extend the ALU32 operands (and the immediate divisor) instead of zero-extending them before calling the signed helpers. bpf_do_misc_fixups() rewrites the zero-divisor and INT_MIN/-1 cases out of the instruction stream before the JIT runs.
--- arch/parisc/net/bpf_jit.h | 2 ++ arch/parisc/net/bpf_jit_comp64.c | 35 ++++++++++++++++++++++++-------- arch/parisc/net/bpf_jit_core.c | 14 +++++++++++++ 3 files changed, 42 insertions(+), 9 deletions(-)
arch/parisc/net/bpf_jit.h +2 -0
@@ -467,6 +467,8 @@ static inline u32 hppa_t21_insn(u8 opcode, u8 r2, u8 r1, u8 ext8, u8 t)u64 hppa_div64 (u64 div,u64 divisor);u64 hppa_div64_rem (u64 div,u64 divisor); +u64 hppa_sdiv64 (u64 div,u64 divisor); +u64 hppa_sdiv64_rem (u64 div,u64 divisor);/* Helper functions that emit HPPA instructions when possible. */
arch/parisc/net/bpf_jit_comp64.c +26 -9
@@ -502,14 +502,19 @@ static void emit_call(u64 addr, bool fixed, struct hppa_jit_context *ctx)emit_hppa_copy (HPPA_REG_RET0 , regmap[BPF_REG_0 ], ctx); } -static void emit_call_libgcc_ll (void *func,const s8 arg0, -const s8 arg1,u8 opcode,struct hppa_jit_context *ctx) +static void emit_call_libgcc_ll (void *func,const s8 arg0,const s8 arg1, +u8 opcode,bool is_signed,struct hppa_jit_context *ctx) {u64 func_addr;if (BPF_CLASS (opcode) ==BPF_ALU ) { -emit_hppa64_zext32 (arg0,HPPA_REG_ARG0 , ctx); -emit_hppa64_zext32 (arg1,HPPA_REG_ARG1 , ctx); +if (is_signed) { +emit_hppa64_sext32 (arg0,HPPA_REG_ARG0 , ctx); +emit_hppa64_sext32 (arg1,HPPA_REG_ARG1 , ctx); + }else { +emit_hppa64_zext32 (arg0,HPPA_REG_ARG0 , ctx); +emit_hppa64_zext32 (arg1,HPPA_REG_ARG1 , ctx); + } }else {emit_hppa_copy (arg0,HPPA_REG_ARG0 , ctx);emit_hppa_copy (arg1,HPPA_REG_ARG1 , ctx);
@@ -600,6 +605,8 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct hppa_jit_context *ctx,u8 rd =-1 , rs =-1 , code = insn->code;s16 off = insn->off;s32 imm = insn->imm; +bool is_signed; +void *func;init_regs (&rd, &rs, insn, ctx);
@@ -656,29 +663,39 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct hppa_jit_context *ctx, fallthrough;case BPF_ALU |BPF_MUL |BPF_X :case BPF_ALU64 |BPF_MUL |BPF_X : -emit_call_libgcc_ll (__muldi3, rd, rs, code, ctx); +emit_call_libgcc_ll (__muldi3, rd, rs, code, false, ctx);if (!is64 && !aux->verifier_zext)emit_zext_32 (rd, ctx);break ;case BPF_ALU |BPF_DIV |BPF_K :case BPF_ALU64 |BPF_DIV |BPF_K : -emit_imm (HPPA_REG_T1 , is64 ? (s64 )(s32 )imm : (u32 )imm,HPPA_REG_T2 , ctx); + is_signed = (off ==1 ); +emit_imm (HPPA_REG_T1 , + is64 || is_signed ? (s64 )(s32 )imm : (u32 )imm, +HPPA_REG_T2 , ctx); rs =HPPA_REG_T1 ; fallthrough;case BPF_ALU |BPF_DIV |BPF_X :case BPF_ALU64 |BPF_DIV |BPF_X : -emit_call_libgcc_ll (&hppa_div64, rd, rs, code, ctx); + is_signed = (off ==1 ); + func = is_signed ? &hppa_sdiv64 : &hppa_div64; +emit_call_libgcc_ll (func, rd, rs, code, is_signed, ctx);if (!is64 && !aux->verifier_zext)emit_zext_32 (rd, ctx);break ;case BPF_ALU |BPF_MOD |BPF_K :case BPF_ALU64 |BPF_MOD |BPF_K : -emit_imm (HPPA_REG_T1 , is64 ? (s64 )(s32 )imm : (u32 )imm,HPPA_REG_T2 , ctx); + is_signed = (off ==1 ); +emit_imm (HPPA_REG_T1 , + is64 || is_signed ? (s64 )(s32 )imm : (u32 )imm, +HPPA_REG_T2 , ctx); rs =HPPA_REG_T1 ; fallthrough;case BPF_ALU |BPF_MOD |BPF_X :case BPF_ALU64 |BPF_MOD |BPF_X : -emit_call_libgcc_ll (&hppa_div64_rem, rd, rs, code, ctx); + is_signed = (off ==1 ); + func = is_signed ? &hppa_sdiv64_rem : &hppa_div64_rem; +emit_call_libgcc_ll (func, rd, rs, code, is_signed, ctx);if (!is64 && !aux->verifier_zext)emit_zext_32 (rd, ctx);break ;
arch/parisc/net/bpf_jit_core.c +14 -0
@@ -190,3 +190,17 @@ u64 hppa_div64_rem(u64 div, u64 divisor)div64_u64_rem (div, divisor, &rem);return rem; } + +u64 hppa_sdiv64 (u64 div,u64 divisor) +{ +s64 sdiv =div64_s64 ((s64 )div, (s64 )divisor); + +return (u64 )sdiv; +} + +u64 hppa_sdiv64_rem (u64 div,u64 divisor) +{ +s64 sdiv =div64_s64 ((s64 )div, (s64 )divisor); + +return (u64)((s64 )div - sdiv * (s64 )divisor); +}
PATCH v2 2/2 bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc32 JIT
In reply to Nicholas Dudaremit_alu_r32() and emit_alu_r64() call the unsigned millicode ($$divU/$$remU) and libgcc-style (hppa_div64()/hppa_div64_rem()) divide/remainder helpers for BPF_DIV and BPF_MOD regardless of the BPF instruction's signedness, so the parisc32 JIT does not implement signed BPF_SDIV and BPF_SMOD (off == 1). Signed ALU32 and ALU64 div/mod get an unsigned quotient and remainder rather than the verifier's and the interpreter's signed result for negative operands.
Thread is_signed = (insn->off == 1) through emit_alu_r32()/ emit_alu_r64(), and on the signed path use the $$divI/$$remI signed millicode routines (32-bit) or the hppa_sdiv64()/hppa_sdiv64_rem() helpers added in patch 1 (64-bit) instead of their unsigned counterparts. $$divI and $$remI are extern-declared and exported next to $$divU/$$remU in arch/parisc/kernel/parisc_ksyms.c. bpf_do_misc_fixups() rewrites the zero-divisor and INT_MIN/-1 cases out of the instruction stream before the JIT runs.
--- arch/parisc/net/bpf_jit_comp32.c | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-)
arch/parisc/net/bpf_jit_comp32.c +19 -10
@@ -321,6 +321,8 @@ static void bpf_put_reg32(const s8 *reg, const s8 *src,extern void $$mulI (void );extern void $$divU (void );extern void $$remU (void ); +extern void $$divI (void ); +extern void $$remI (void );static void emit_call_millicode (void *func,const s8 arg0,const s8 arg1,u8 opcode,struct hppa_jit_context *ctx)
@@ -562,12 +564,14 @@ static void emit_alu_i32(const s8 *dst, s32 imm, }static void emit_alu_r64 (const s8 *dst,const s8 *src, -struct hppa_jit_context *ctx,const u8 op) +struct hppa_jit_context *ctx,const u8 op, +bool is_signed) {const s8 *tmp1 = regmap[TMP_REG_1 ];const s8 *tmp2 = regmap[TMP_REG_2 ];const s8 *rd;const s8 *rs =bpf_get_reg64 (src, tmp2, ctx); +void *func;if (op ==BPF_MOV ) rd =bpf_get_reg64_ref (dst, tmp1, false, ctx);
@@ -604,10 +608,12 @@ static void emit_alu_r64(const s8 *dst, const s8 *src,emit_call_libgcc_ll (__muldi3, rd, rs, op, ctx);break ;case BPF_DIV : -emit_call_libgcc_ll (&hppa_div64, rd, rs, op, ctx); + func = is_signed ? &hppa_sdiv64 : &hppa_div64; +emit_call_libgcc_ll (func, rd, rs, op, ctx);break ;case BPF_MOD : -emit_call_libgcc_ll (&hppa_div64_rem, rd, rs, op, ctx); + func = is_signed ? &hppa_sdiv64_rem : &hppa_div64_rem; +emit_call_libgcc_ll (func, rd, rs, op, ctx);break ;case BPF_LSH :emit_call_libgcc_ll (__ashldi3, rd, rs, op, ctx);
@@ -630,7 +636,8 @@ static void emit_alu_r64(const s8 *dst, const s8 *src, }static void emit_alu_r32 (const s8 *dst,const s8 *src, -struct hppa_jit_context *ctx,const u8 op) +struct hppa_jit_context *ctx,const u8 op, +bool is_signed) {const s8 *tmp1 = regmap[TMP_REG_1 ];const s8 *tmp2 = regmap[TMP_REG_2 ];
@@ -666,10 +673,12 @@ static void emit_alu_r32(const s8 *dst, const s8 *src,emit_call_millicode ($$mulI,lo (rd),lo (rs), op, ctx);break ;case BPF_DIV : -emit_call_millicode ($$divU,lo (rd),lo (rs), op, ctx); +emit_call_millicode (is_signed ? $$divI : $$divU, +lo (rd),lo (rs), op, ctx);break ;case BPF_MOD : -emit_call_millicode ($$remU,lo (rd),lo (rs), op, ctx); +emit_call_millicode (is_signed ? $$remI : $$remU, +lo (rd),lo (rs), op, ctx);break ;case BPF_LSH :emit (hppa_subi (0x1f ,lo (rs),HPPA_REG_T0 ), ctx);
@@ -1163,12 +1172,12 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct hppa_jit_context *ctx,emit_imm32 (tmp2, imm, ctx); src = tmp2; } -emit_alu_r64 (dst, src, ctx,BPF_OP (code)); +emit_alu_r64 (dst, src, ctx,BPF_OP (code), off ==1 );break ;/* dst = -dst */ case BPF_ALU64 |BPF_NEG : -emit_alu_r64 (dst, tmp2, ctx,BPF_OP (code)); +emit_alu_r64 (dst, tmp2, ctx,BPF_OP (code), false);break ;case BPF_ALU64 |BPF_MOV |BPF_K :
@@ -1211,7 +1220,7 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct hppa_jit_context *ctx,emit_imm32 (tmp2, imm, ctx); src = tmp2; } -emit_alu_r32 (dst, src, ctx,BPF_OP (code)); +emit_alu_r32 (dst, src, ctx,BPF_OP (code), off ==1 );break ;/* dst = dst OP imm */
@@ -1236,7 +1245,7 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct hppa_jit_context *ctx,* src is ignored---choose tmp2 as a dummy register since it * is not on the stack. */ -emit_alu_r32 (dst, tmp2, ctx,BPF_OP (code)); +emit_alu_r32 (dst, tmp2, ctx,BPF_OP (code), false);break ;/* dst = BSWAP##imm(dst) */
[email protected]
AI reviewRe: [PATCH bpf-next v2 2/2] bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc32 JIT
This looks like a bug fix for the parisc32 JIT's handling of signed division and modulo operations. Should this include a Fixes: tag?
Quoted 22 lines
commit
78e60eb41cf96a6559947f9582f1a6e1e10551af
Author: Nicholas Dudar <[email protected]>bpf, parisc: Add support for
BPF_SDIVandBPF_SMODin the parisc32 JIT
emit_alu_r32()andemit_alu_r64()call the unsigned millicode ($$divU/$$remU) and libgcc-style (hppa_div64()/hppa_div64_rem()) divide/remainder helpers forBPF_DIVandBPF_MODregardless of the BPF instruction's signedness, so the parisc32 JIT does not implement signedBPF_SDIVandBPF_SMOD(off == 1). Signed ALU32 and ALU64 div/mod get an unsigned quotient and remainder rather than the verifier's and the interpreter's signed result for negative operands.Thread
is_signed= (insn->off== 1) through emit_alu_r32()/emit_alu_r64(), and on the signed path use the $$divI/$$remI signed millicode routines (32-bit) or the hppa_sdiv64()/hppa_sdiv64_rem() helpers added in patch 1 (64-bit) instead of their unsigned counterparts. $$divI and $$remI are extern-declared and exported next to $$divU/$$remU inarch/parisc/kernel/parisc_ksyms.c.bpf_do_misc_fixups()rewrites the zero-divisor and INT_MIN/-1 cases out of the instruction stream before the JIT runs.
Quoted 4 lines
Acked-by Helge Deller <[email protected]>Tested-by Helge Deller <[email protected]>Assisted-by Claude:claude-opus-4-8Signed-off-by Nicholas Dudar <[email protected]>
This looks like a bug fix for the parisc32 JIT's handling of signed division and modulo operations. Should this include a Fixes: tag?
This isn't a bug, but would it be worth naming the sibling commit (or saying "the previous patch") instead of "patch 1" here, so the reference still makes sense once the series is applied?
Quoted 1 line
helpers added in patch 1 (64-bit) instead of their unsigned
The "patch 1" reference is only resolvable while the series is on the list. Once the commits land, git history has no "patch 1" for later readers or anyone doing archaeology on this code.
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/34922459599
Re: [PATCH bpf-next v2 2/2] bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc32 JIT
Quoted 4 lines · On Tue, Sep 15, 2026, [email protected] wrote:
This looks like a bug fix for the parisc32 JIT's handling of signed division and modulo operations. Should this include a Fixes: tag?
Fixes 847b98421362 ("adding ci files")
847b98421362 only adds CI files, not parisc JIT changes.
I submitted this as missing instruction support to bpf-next without Fixes, following the RV32/i386 guidance [1,2], as explained on parisc v1 [3]. The current unsigned results for signed operations are still incorrect.
Quoted 3 lines
This isn't a bug, but would it be worth naming the sibling commit (or saying "the previous patch") instead of "patch 1" here, so the reference still makes sense once the series is applied?
Agreed. Please replace "helpers added in patch 1 (64-bit)" with "signed 64-bit helpers" when applying. The preceding text already names hppa_sdiv64() and hppa_sdiv64_rem().
BPF maintainers: please consider both patches for stable after mainline inclusion, patch 2 needs patch 1's helpers. Per the BPF guide, I'm requesting this here rather than adding a Cc: stable trailer.
Thank you,
Nicholas
[1] https://lore.kernel.org/bpf/[email protected]/
[2] https://lore.kernel.org/bpf/[email protected]/
[3] https://lore.kernel.org/bpf/CAJZwKkgG2Ct3KipN4cRgg4v=QQwj9LhA8pveqQvT_gQ_GpzJ3w@mail.gmail.com/
This series was applied to bpf/bpf-next.git (master) by Daniel Borkmann <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Daniel Borkmann <[email protected]>:
Quoted 9 lines · On Mon, 14 Sep 2026 22:29:03 -0400 you wrote:
The parisc BPF JITs emit unsigned divide and remainder for signed
BPF_DIVandBPF_MOD(off == 1), so neither implements signedBPF_SDIVandBPF_SMOD. Negative operands therefore produce unsigned results.Patch 1 adds signed support to the parisc64 JIT and shared signed 64-bit helpers. Patch 2 adds support to the parisc32 JIT, using those helpers for ALU64 and the signed millicode routines for ALU32.
[...]
Here is the summary with links:
- [bpf-next,v2,1/2] bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc64 JIT
https://git.kernel.org/bpf/bpf-next/c/32a7b17bc8e7 - [bpf-next,v2,2/2] bpf, parisc: Add support for BPF_SDIV and BPF_SMOD in the parisc32 JIT https://git.kernel.org/bpf/bpf-next/c/dbda00ac6f0a
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html