BPF_REG_FP - Linux

arch/arc/net/bpf_jit_arcv2.c

1307

if (rd != BPF_REG_FP)

arch/arc/net/bpf_jit_arcv2.c

1365

if (rs != BPF_REG_FP)

arch/arc/net/bpf_jit_arcv2.c

1382

if (reg != BPF_REG_FP) {

arch/arc/net/bpf_jit_arcv2.c

1527

if (reg != BPF_REG_FP)

arch/arc/net/bpf_jit_arcv2.c

1532

if (reg != BPF_REG_FP)

arch/arc/net/bpf_jit_arcv2.c

2378

} else if (bpf_reg == BPF_REG_FP) {

arch/arc/net/bpf_jit_arcv2.c

2379

usage |= BIT(REG_LO(BPF_REG_FP));

arch/arc/net/bpf_jit_arcv2.c

81

[BPF_REG_FP] = {ARC_R_FP, },

arch/arm/net/bpf_jit_32.c

1529

const s8 *bpf_fp = bpf2a32[BPF_REG_FP];

arch/arm/net/bpf_jit_32.c

167

[BPF_REG_FP] = {STACK_OFFSET(BPF_FP_HI), STACK_OFFSET(BPF_FP_LO)},

arch/arm64/net/bpf_jit_comp.c

1262

const u8 fp = bpf2a64[BPF_REG_FP];

arch/arm64/net/bpf_jit_comp.c

394

if (insn->dst_reg == BPF_REG_FP || insn->src_reg == BPF_REG_FP) {

arch/arm64/net/bpf_jit_comp.c

414

ctx->used_callee_reg[i++] = bpf2a64[BPF_REG_FP];

arch/arm64/net/bpf_jit_comp.c

517

const u8 fp = bpf2a64[BPF_REG_FP];

arch/arm64/net/bpf_jit_comp.c

63

[BPF_REG_FP] = A64_R(25),

arch/loongarch/net/bpf_jit.c

207

emit_insn(ctx, addid, regmap[BPF_REG_FP], LOONGARCH_GPR_SP, bpf_stack_adjust);

arch/loongarch/net/bpf_jit.c

45

[BPF_REG_FP] = LOONGARCH_GPR_S4,

arch/mips/net/bpf_jit_comp32.c

133

[BPF_REG_FP] = {MIPS_R_FP, MIPS_R_ZERO},

arch/mips/net/bpf_jit_comp32.c

135

[BPF_REG_FP] = {MIPS_R_ZERO, MIPS_R_FP},

arch/mips/net/bpf_jit_comp32.c

1376

const u8 *fp = bpf2mips32[BPF_REG_FP];

arch/mips/net/bpf_jit_comp32.c

1410

if (ctx->accessed & BIT(BPF_REG_FP))

arch/mips/net/bpf_jit_comp32.c

1436

if (ctx->accessed & BIT(BPF_REG_FP))

arch/mips/net/bpf_jit_comp64.c

548

u8 fp = bpf2mips64[BPF_REG_FP];

arch/mips/net/bpf_jit_comp64.c

575

if (ctx->accessed & BIT(BPF_REG_FP))

arch/mips/net/bpf_jit_comp64.c

605

if (ctx->accessed & BIT(BPF_REG_FP))

arch/mips/net/bpf_jit_comp64.c

79

[BPF_REG_FP] = MIPS_R_FP,

arch/parisc/net/bpf_jit_comp32.c

1598

dst = regmap[BPF_REG_FP];

arch/parisc/net/bpf_jit_comp32.c

94

[BPF_REG_FP] = {STACK_OFFSET(BPF_FP_HI), STACK_OFFSET(BPF_FP_LO)},

arch/parisc/net/bpf_jit_comp64.c

1195

reg = regmap[BPF_REG_FP]; /* -> HPPA_REG_FP */

arch/parisc/net/bpf_jit_comp64.c

31

[BPF_REG_FP] = HPPA_R(14),

arch/powerpc/net/bpf_jit_comp32.c

201

if (bpf_is_seen_register(ctx, bpf_to_ppc(BPF_REG_FP))) {

arch/powerpc/net/bpf_jit_comp32.c

202

EMIT(PPC_RAW_LI(bpf_to_ppc(BPF_REG_FP) - 1, 0));

arch/powerpc/net/bpf_jit_comp32.c

203

EMIT(PPC_RAW_ADDI(bpf_to_ppc(BPF_REG_FP), _R1,

arch/powerpc/net/bpf_jit_comp32.c

62

ctx->b2p[BPF_REG_FP] = _R18;

arch/powerpc/net/bpf_jit_comp32.c

93

bpf_is_seen_register(ctx, bpf_to_ppc(BPF_REG_FP));

arch/powerpc/net/bpf_jit_comp64.c

118

bpf_is_seen_register(ctx, bpf_to_ppc(BPF_REG_FP)) ||

arch/powerpc/net/bpf_jit_comp64.c

213

PPC_LI64(bpf_to_ppc(BPF_REG_FP), (__force long)ctx->priv_sp);

arch/powerpc/net/bpf_jit_comp64.c

222

EMIT(PPC_RAW_ADD(bpf_to_ppc(BPF_REG_FP),

arch/powerpc/net/bpf_jit_comp64.c

223

bpf_to_ppc(TMP_REG_1), bpf_to_ppc(BPF_REG_FP)));

arch/powerpc/net/bpf_jit_comp64.c

225

EMIT(PPC_RAW_ADDI(bpf_to_ppc(BPF_REG_FP), bpf_to_ppc(BPF_REG_FP),

arch/powerpc/net/bpf_jit_comp64.c

353

if (bpf_is_seen_register(ctx, bpf_to_ppc(BPF_REG_FP))) {

arch/powerpc/net/bpf_jit_comp64.c

359

EMIT(PPC_RAW_ADDI(bpf_to_ppc(BPF_REG_FP), _R1,

arch/powerpc/net/bpf_jit_comp64.c

92

ctx->b2p[BPF_REG_FP] = _R31;

arch/riscv/net/bpf_jit_comp32.c

1305

const s8 *fp = bpf2rv32[BPF_REG_FP];

arch/riscv/net/bpf_jit_comp32.c

89

[BPF_REG_FP] = {RV_REG_S6, RV_REG_S5},

arch/riscv/net/bpf_jit_comp64.c

40

[BPF_REG_FP] = RV_REG_S5,

arch/s390/net/bpf_jit_comp.c

100

[BPF_REG_FP] = 13,

arch/s390/net/bpf_jit_comp.c

653

EMIT4_DISP(0x41000000, BPF_REG_FP, REG_15,

arch/sparc/net/bpf_jit_comp_64.c

1302

if (insn->dst_reg == BPF_REG_FP)

arch/sparc/net/bpf_jit_comp_64.c

1343

if (insn->dst_reg == BPF_REG_FP)

arch/sparc/net/bpf_jit_comp_64.c

1384

if (insn->dst_reg == BPF_REG_FP)

arch/sparc/net/bpf_jit_comp_64.c

1412

if (insn->dst_reg == BPF_REG_FP)

arch/sparc/net/bpf_jit_comp_64.c

226

[BPF_REG_FP] = L6,

arch/sparc/net/bpf_jit_comp_64.c

824

const u8 vfp = bpf2sparc[BPF_REG_FP];

arch/sparc/net/bpf_jit_comp_64.c

904

if (insn->src_reg == BPF_REG_FP)

arch/x86/net/bpf_jit_comp.c

1330

emit_stx(pprog, BPF_DW, BPF_REG_FP, reg, stack_off);

arch/x86/net/bpf_jit_comp.c

1823

if (src_reg == BPF_REG_FP)

arch/x86/net/bpf_jit_comp.c

1826

if (dst_reg == BPF_REG_FP)

arch/x86/net/bpf_jit_comp.c

193

[BPF_REG_FP] = 5, /* RBP readonly */

arch/x86/net/bpf_jit_comp.c

2245

dst_reg = BPF_REG_FP;

arch/x86/net/bpf_jit_comp.c

2268

dst_reg = BPF_REG_FP;

arch/x86/net/bpf_jit_comp.c

2375

src_reg = BPF_REG_FP;

arch/x86/net/bpf_jit_comp.c

240

BIT(BPF_REG_FP));

arch/x86/net/bpf_jit_comp.c

3040

emit_ldx(prog, BPF_DW, BPF_REG_0, BPF_REG_FP,

arch/x86/net/bpf_jit_comp.c

3042

emit_stx(prog, BPF_DW, BPF_REG_FP, BPF_REG_0,

arch/x86/net/bpf_jit_comp.c

3062

emit_stx(prog, BPF_DW, BPF_REG_FP,

arch/x86/net/bpf_jit_comp.c

3092

BPF_REG_FP,

arch/x86/net/bpf_jit_comp.c

3127

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_1, -run_ctx_off + ctx_cookie_off);

arch/x86/net/bpf_jit_comp.c

3173

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8);

arch/x86/net/bpf_jit_comp.c

3256

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8);

arch/x86/net/bpf_jit_comp.c

3498

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_6, -rbx_off);

arch/x86/net/bpf_jit_comp.c

3561

emit_ldx(&prog, BPF_DW, BPF_REG_6, BPF_REG_FP, 8);

arch/x86/net/bpf_jit_comp.c

3571

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8);

arch/x86/net/bpf_jit_comp.c

3629

emit_ldx(&prog, BPF_DW, BPF_REG_0, BPF_REG_FP, -8);

arch/x86/net/bpf_jit_comp.c

3631

emit_ldx(&prog, BPF_DW, BPF_REG_6, BPF_REG_FP, -rbx_off);

arch/x86/net/bpf_jit_comp32.c

1205

const u8 fplo = bpf2ia32[BPF_REG_FP][0];

arch/x86/net/bpf_jit_comp32.c

1206

const u8 fphi = bpf2ia32[BPF_REG_FP][1];

arch/x86/net/bpf_jit_comp32.c

158

[BPF_REG_FP] = {STACK_OFFSET(80), STACK_OFFSET(84)},

kernel/bpf/backtrack.c

311

if (sreg != BPF_REG_FP)

kernel/bpf/backtrack.c

328

if (sreg != BPF_REG_FP)

kernel/bpf/backtrack.c

677

for (j = 0; j < BPF_REG_FP; j++) {

kernel/bpf/core.c

64

#define FP regs[BPF_REG_FP]

kernel/bpf/fixups.c

2378

insn_buf[cnt++] = BPF_ST_MEM(BPF_DW, BPF_REG_FP, -stack_depth,

kernel/bpf/fixups.c

2380

insn_buf[cnt++] = BPF_ST_MEM(BPF_DW, BPF_REG_FP, -stack_depth + 8, 0);

kernel/bpf/fixups.c

2383

insn_buf[cnt++] = BPF_ST_MEM(BPF_DW, BPF_REG_FP, -stack_depth,

kernel/bpf/fixups.c

713

insn_buf[cnt++] = BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_1,

kernel/bpf/liveness.c

1011

if (reg == BPF_REG_FP) {

kernel/bpf/liveness.c

1085

return regno == BPF_REG_FP || at->frame == depth ||

kernel/bpf/liveness.c

1661

at_in[0][BPF_REG_FP] = arg_single(depth, 0);

kernel/bpf/liveness.c

911

if (reg == BPF_REG_FP) {

kernel/bpf/liveness.c

947

if (reg == BPF_REG_FP) {

kernel/bpf/states.c

1034

for (i = 0; i < BPF_REG_FP; i++, state_reg++) {

kernel/bpf/states.c

1221

for (j = 0; j < BPF_REG_FP; j++) {

kernel/bpf/states.c

404

for (i = 0; i < BPF_REG_FP; i++) {

kernel/bpf/verifier.c

15868

for (j = 0; j < BPF_REG_FP; j++) {

kernel/bpf/verifier.c

2244

regs[BPF_REG_FP].type = PTR_TO_STACK;

kernel/bpf/verifier.c

2245

mark_reg_known_zero(env, regs, BPF_REG_FP);

kernel/bpf/verifier.c

2246

regs[BPF_REG_FP].frameno = state->frameno;

kernel/bpf/verifier.c

3114

if (regno == BPF_REG_FP)

kernel/bpf/verifier.c

3123

if (regno == BPF_REG_FP) {

lib/test_bpf.c

15520

BPF_ALU64_REG(BPF_MOV, R3, BPF_REG_FP),

lib/test_bpf.c

15523

BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -8),

lib/test_bpf.c

15525

BPF_LDX_MEM(BPF_DW, R0, BPF_REG_FP, -16),

lib/test_bpf.c

15537

BPF_STX_MEM(BPF_DW, BPF_REG_FP, R0, -8),

net/core/filter.c

591

BUILD_BUG_ON(BPF_REG_FP + 1 != MAX_BPF_REG);

net/core/filter.c

837

*insn = BPF_STX_MEM(BPF_W, BPF_REG_FP, BPF_CLASS(fp->code) ==

net/core/filter.c

853

BPF_REG_A : BPF_REG_X, BPF_REG_FP,

net/sched/bpf_qdisc.c

179

*insn++ = BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_FP, ctx_stack_off);

tools/testing/selftests/bpf/progs/verifier_spill_fill.c

497

__imm_insn(fp1_u8_st_zero, BPF_ST_MEM(BPF_B, BPF_REG_FP, -1, 0)),

tools/testing/selftests/bpf/progs/verifier_spill_fill.c

498

__imm_insn(fp10_u16_st_zero, BPF_ST_MEM(BPF_H, BPF_REG_FP, -10, 0)),

tools/testing/selftests/bpf/progs/verifier_spill_fill.c

499

__imm_insn(fp18_u16_st_zero, BPF_ST_MEM(BPF_H, BPF_REG_FP, -18, 0))

tools/testing/selftests/bpf/progs/verifier_spill_fill.c

592

__imm_insn(fp8_st_zero, BPF_ST_MEM(BPF_DW, BPF_REG_FP, -8, 0))

tools/testing/selftests/bpf/progs/verifier_spill_fill.c

633

__imm_insn(fp4_st_zero, BPF_ST_MEM(BPF_W, BPF_REG_FP, -4, 0))

tools/testing/selftests/bpf/progs/verifier_spill_fill.c

712

__imm_insn(fp8_st_one, BPF_ST_MEM(BPF_DW, BPF_REG_FP, -8, 1))

tools/testing/selftests/bpf/progs/verifier_spill_fill.c

789

__imm_insn(fp8_st_one, BPF_ST_MEM(BPF_W, BPF_REG_FP, -8, 1)) /* 32-bit spill */

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1696

*insn++ = BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_FP, ctx_stack_off);

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1759

*insn++ = BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_FP, ctx_stack_off);

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

2393

BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_0, -24),

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

2400

BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_0, -32),

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

2404

BPF_MOV64_REG(BPF_REG_1, BPF_REG_FP),