Lines Matching defs:opcode
1803 u8 opcode = BPF_OP(insn->code);
1822 if (opcode == BPF_MOV) {
1910 if (opcode == BPF_CALL) {
1924 } else if (opcode == BPF_EXIT) {
5701 static bool sanitize_needed(u8 opcode)
5703 return opcode == BPF_ADD || opcode == BPF_SUB;
5739 u8 opcode = BPF_OP(insn->code);
5762 info->mask_to_left = (opcode == BPF_ADD && off_is_neg) || (opcode == BPF_SUB && !off_is_neg);
5954 u8 opcode = BPF_OP(insn->code);
5970 if (opcode == BPF_SUB && env->allow_ptr_leaks) {
5988 if (known && smin_val == 0 && opcode == BPF_ADD) {
6020 if (sanitize_needed(opcode)) {
6027 switch (opcode) {
6136 verbose(env, "R%d bitwise operator %s on pointer prohibited\n", dst, bpf_alu_string[opcode >> 0x4]);
6140 verbose(env, "R%d pointer arithmetic with %s operator prohibited\n", dst, bpf_alu_string[opcode >> 0x4]);
6153 if (sanitize_needed(opcode)) {
6716 u8 opcode = BPF_OP(insn->code);
6758 if (!src_known && opcode != BPF_ADD && opcode != BPF_SUB && opcode != BPF_AND) {
6763 if (sanitize_needed(opcode)) {
6784 switch (opcode) {
6880 u8 opcode = BPF_OP(insn->code);
6901 if (opcode == BPF_SUB && env->allow_ptr_leaks) {
6906 bpf_alu_string[opcode >> VERIFIER_FOUR]);
6957 u8 opcode = BPF_OP(insn->code);
6960 if (opcode == BPF_END || opcode == BPF_NEG) {
6961 if (opcode == BPF_NEG) {
6991 } else if (opcode == BPF_MOV) {
7067 } else if (opcode > BPF_END) {
7068 verbose(env, "invalid BPF_ALU opcode %x\n", opcode);
7094 if ((opcode == BPF_MOD || opcode == BPF_DIV) && BPF_SRC(insn->code) == BPF_K && insn->imm == 0) {
7099 if ((opcode == BPF_LSH || opcode == BPF_RSH || opcode == BPF_ARSH) && BPF_SRC(insn->code) == BPF_K) {
7217 static int is_branch32_taken(struct bpf_reg_state *reg, u32 val, u8 opcode)
7222 switch (opcode) {
7302 static int is_branch64_taken(struct bpf_reg_state *reg, u64 val, u8 opcode)
7306 switch (opcode) {
7386 /* compute branch direction of the expression "if (reg opcode val) goto target;"
7393 static int is_branch_taken(struct bpf_reg_state *reg, u64 val, u8 opcode, bool is_jmp32)
7407 switch (opcode) {
7418 return is_branch32_taken(reg, val, opcode);
7420 return is_branch64_taken(reg, val, opcode);
7429 u8 opcode, bool is_jmp32)
7448 switch (opcode) {
7492 u32 false_umax = opcode == BPF_JGT ? val32 : val32 - 1;
7493 u32 true_umin = opcode == BPF_JGT ? val32 + 1 : val32;
7498 u64 false_umax = opcode == BPF_JGT ? val : val - 1;
7499 u64 true_umin = opcode == BPF_JGT ? val + 1 : val;
7509 s32 false_smax = opcode == BPF_JSGT ? sval32 : sval32 - 1;
7510 s32 true_smin = opcode == BPF_JSGT ? sval32 + 1 : sval32;
7515 s64 false_smax = opcode == BPF_JSGT ? sval : sval - 1;
7516 s64 true_smin = opcode == BPF_JSGT ? sval + 1 : sval;
7526 u32 false_umin = opcode == BPF_JLT ? val32 : val32 + 1;
7527 u32 true_umax = opcode == BPF_JLT ? val32 - 1 : val32;
7532 u64 false_umin = opcode == BPF_JLT ? val : val + 1;
7533 u64 true_umax = opcode == BPF_JLT ? val - 1 : val;
7543 s32 false_smin = opcode == BPF_JSLT ? sval32 : sval32 + 1;
7544 s32 true_smax = opcode == BPF_JSLT ? sval32 - 1 : sval32;
7549 s64 false_smin = opcode == BPF_JSLT ? sval : sval + 1;
7550 s64 true_smax = opcode == BPF_JSLT ? sval - 1 : sval;
7578 u8 opcode, bool is_jmp32)
7594 opcode = opcode_flip[opcode >> VERIFIER_FOUR];
7595 /* This uses zero as "not present in table"; luckily the zero opcode,
7598 if (opcode) {
7599 reg_set_min_max(true_reg, false_reg, val, val32, opcode, is_jmp32);
7617 struct bpf_reg_state *false_src, struct bpf_reg_state *false_dst, u8 opcode)
7619 switch (opcode) {
7828 u8 opcode = BPF_OP(insn->code);
7834 if (opcode == BPF_JA || opcode > BPF_JSLE) {
7835 verbose(env, "invalid BPF_JMP/JMP32 opcode %x\n", opcode);
7873 pred = is_branch_taken(dst_reg, insn->imm, opcode, is_jmp32);
7875 pred = is_branch_taken(dst_reg, tnum_subreg(src_reg->var_off).value, opcode, is_jmp32);
7877 pred = is_branch_taken(dst_reg, src_reg->var_off.value, opcode, is_jmp32);
7935 tnum_subreg(src_reg_in->var_off).value, opcode, is_jmp32);
7938 tnum_subreg(dst_reg->var_off).value, opcode, is_jmp32);
7939 } else if (!is_jmp32 && (opcode == BPF_JEQ || opcode == BPF_JNE)) {
7942 dst_reg, opcode);
7950 reg_set_min_max(&other_branch_regs[insn->dst_reg], dst_reg, insn->imm, (u32)insn->imm, opcode, is_jmp32);
7963 if (!is_jmp32 && BPF_SRC(insn->code) == BPF_K && insn->imm == 0 && (opcode == BPF_JEQ || opcode == BPF_JNE) &&
7968 mark_ptr_or_null_regs(this_branch, insn->dst_reg, opcode == BPF_JNE);
7969 mark_ptr_or_null_regs(other_branch, insn->dst_reg, opcode == BPF_JEQ);
8430 u8 opcode = BPF_OP(insns[t].code);
8431 if (opcode == BPF_EXIT) {
8433 } else if (opcode == BPF_CALL) {
8452 } else if (opcode == BPF_JA) {
9852 u8 opcode = BPF_OP(insn->code);
9854 if (opcode == BPF_CALL) {
9875 } else if (opcode == BPF_JA) {
9883 } else if (opcode == BPF_EXIT) {
10295 verbose(env, "unknown opcode %02x\n", insn->code);
11374 /* mark bpf_tail_call as different opcode to avoid