type casting of rbpf

[shenghaoyuan]

Hello, It looks like there are some inconsistency when Solana rbpf deals with the type-casting using i32 and u32. e.g.

• ebpf::ADD32_IMM considers dst and imm as i32 firstly, then as u64, while
• ebpf::OR32_IMM considers dst and imm as u32 first, then as u64

  // BPF_ALU class
  ebpf::ADD32_IMM  => self.reg[dst] = (self.reg[dst] as i32).wrapping_add(insn.imm as i32)      as u64,
  ebpf::ADD32_REG  => self.reg[dst] = (self.reg[dst] as i32).wrapping_add(self.reg[src] as i32) as u64,
  ebpf::SUB32_IMM  => if self.executable.get_sbpf_version().swap_sub_reg_imm_operands() {
                      self.reg[dst] = (insn.imm as i32).wrapping_sub(self.reg[dst] as i32)      as u64
  } else {
                      self.reg[dst] = (self.reg[dst] as i32).wrapping_sub(insn.imm as i32)      as u64
  },
  ebpf::SUB32_REG  => self.reg[dst] = (self.reg[dst] as i32).wrapping_sub(self.reg[src] as i32) as u64,
  ...
  ebpf::OR32_IMM   => self.reg[dst] = (self.reg[dst] as u32             | insn.imm as u32)      as u64,

  Does Solana rbpf perform some specific operations on e.g. eBPF ADD ...? As self.reg[dst] = (self.reg[dst] as i32).wrapping_add(insn.imm as i32) as u64 and self.reg[dst] = (self.reg[dst] as u32).wrapping_add(insn.imm as u32) as u64 may have different results.

When Linux eBPF performs type-casting, it always follows a consistent way

#define ALU(OPCODE, OP)                 \
    ALU64_##OPCODE##_X:             \
        DST = DST OP SRC;           \
        CONT;                   \
    ALU_##OPCODE##_X:               \
        DST = (u32) DST OP (u32) SRC;       \
        CONT;                   \
    ALU64_##OPCODE##_K:             \
        DST = DST OP IMM;           \
        CONT;                   \
    ALU_##OPCODE##_K:               \
        DST = (u32) DST OP (u32) IMM;       \

[Lichtso]

Known issue: https://github.com/solana-labs/rbpf/pull/548 https://github.com/solana-labs/solana/issues/32924

The inconsistency looks like it comes from the input side:

let a = (x as i32).wrapping_add(y as i32) as u64;
let b = (x as u32).wrapping_add(y as u32) as u64;

But it actually happens on the output side:

let c = (x as u32).wrapping_add(y as u32) as i32 as u64;
let d = (x as u32).wrapping_add(y as u32) as u32 as u64;