| /* Simulator for BPF. | |
| Copyright (C) 2020-2026 Free Software Foundation, Inc. | |
| Contributed by Oracle Inc. | |
| This file is part of GDB, the GNU debugger. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 3 of the License, or | |
| (at your option) any later version. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
| /* This must come before any other includes. */ | |
| #include "defs.h" | |
| #include "libiberty.h" | |
| #include "bfd.h" | |
| #include "opcode/bpf.h" | |
| #include "sim/sim.h" | |
| #include "sim-main.h" | |
| #include "sim-core.h" | |
| #include "sim-base.h" | |
| #include "sim-options.h" | |
| #include "sim-signal.h" | |
| #include "bpf-sim.h" | |
| #include <assert.h> | |
| #include <stdlib.h> | |
| /***** Emulated hardware. *****/ | |
| /* Registers are 64-bit long. | |
| 11 general purpose registers, indexed by register number. | |
| 1 program counter. */ | |
| typedef uint64_t bpf_reg; | |
| bpf_reg bpf_pc; | |
| bpf_reg bpf_regs[11]; | |
| #define BPF_R0 0 | |
| #define BPF_R1 1 | |
| #define BPF_R2 2 | |
| #define BPF_R3 3 | |
| #define BPF_R4 4 | |
| #define BPF_R5 5 | |
| #define BPF_R6 6 | |
| #define BPF_R7 7 | |
| #define BPF_R8 8 | |
| #define BPF_R9 9 | |
| #define BPF_R10 10 | |
| #define BPF_FP 10 | |
| /***** Emulated memory accessors. *****/ | |
| static uint8_t | |
| bpf_read_u8 (SIM_CPU *cpu, bfd_vma address) | |
| { | |
| return sim_core_read_unaligned_1 (cpu, 0, read_map, address); | |
| } | |
| static void | |
| bpf_write_u8 (SIM_CPU *cpu, bfd_vma address, uint8_t value) | |
| { | |
| sim_core_write_unaligned_1 (cpu, 0, write_map, address, value); | |
| } | |
| static uint16_t ATTRIBUTE_UNUSED | |
| bpf_read_u16 (SIM_CPU *cpu, bfd_vma address) | |
| { | |
| uint16_t val = sim_core_read_unaligned_2 (cpu, 0, read_map, address); | |
| if (current_target_byte_order == BFD_ENDIAN_LITTLE) | |
| return endian_le2h_2 (val); | |
| else | |
| return endian_le2h_2 (val); | |
| } | |
| static void | |
| bpf_write_u16 (SIM_CPU *cpu, bfd_vma address, uint16_t value) | |
| { | |
| sim_core_write_unaligned_2 (cpu, 0, write_map, address, endian_h2le_2 (value)); | |
| } | |
| static uint32_t ATTRIBUTE_UNUSED | |
| bpf_read_u32 (SIM_CPU *cpu, bfd_vma address) | |
| { | |
| uint32_t val = sim_core_read_unaligned_4 (cpu, 0, read_map, address); | |
| if (current_target_byte_order == BFD_ENDIAN_LITTLE) | |
| return endian_le2h_4 (val); | |
| else | |
| return endian_le2h_4 (val); | |
| } | |
| static void | |
| bpf_write_u32 (SIM_CPU *cpu, bfd_vma address, uint32_t value) | |
| { | |
| sim_core_write_unaligned_4 (cpu, 0, write_map, address, endian_h2le_4 (value)); | |
| } | |
| static uint64_t ATTRIBUTE_UNUSED | |
| bpf_read_u64 (SIM_CPU *cpu, bfd_vma address) | |
| { | |
| uint64_t val = sim_core_read_unaligned_8 (cpu, 0, read_map, address); | |
| if (current_target_byte_order == BFD_ENDIAN_LITTLE) | |
| return endian_le2h_8 (val); | |
| else | |
| return endian_le2h_8 (val); | |
| } | |
| static void | |
| bpf_write_u64 (SIM_CPU *cpu, bfd_vma address, uint64_t value) | |
| { | |
| sim_core_write_unaligned_8 (cpu, 0, write_map, address, endian_h2le_8 (value)); | |
| } | |
| /***** Emulation of the BPF kernel helpers. *****/ | |
| /* BPF programs rely on the existence of several helper functions, | |
| which are provided by the kernel. This simulator provides an | |
| implementation of the helpers, which can be customized by the | |
| user. */ | |
| /* bpf_trace_printk is a printk-like facility for debugging. | |
| In the kernel, it appends a line to the Linux's tracing debugging | |
| interface. | |
| In this simulator, it uses the simulator's tracing interface | |
| instead. | |
| The format tags recognized by this helper are: | |
| %d, %i, %u, %x, %ld, %li, %lu, %lx, %lld, %lli, %llu, %llx, | |
| %p, %s | |
| A maximum of three tags are supported. | |
| This helper returns the number of bytes written, or a negative | |
| value in case of failure. */ | |
| static int | |
| bpf_trace_printk (SIM_CPU *cpu) | |
| { | |
| SIM_DESC sd = CPU_STATE (cpu); | |
| bfd_vma fmt_address; | |
| uint32_t size, tags_processed; | |
| size_t i, bytes_written = 0; | |
| /* The first argument is the format string, which is passed as a | |
| pointer in %r1. */ | |
| fmt_address = bpf_regs[BPF_R1]; | |
| /* The second argument is the length of the format string, as an | |
| unsigned 32-bit number in %r2. */ | |
| size = bpf_regs[BPF_R2]; | |
| /* Read the format string from the memory pointed by %r2, printing | |
| out the stuff as we go. There is a maximum of three format tags | |
| supported, which are read from %r3, %r4 and %r5 respectively. */ | |
| for (i = 0, tags_processed = 0; i < size;) | |
| { | |
| uint64_t value; | |
| uint8_t c = bpf_read_u8 (cpu, fmt_address + i); | |
| switch (c) | |
| { | |
| case '%': | |
| /* Check we are not exceeding the limit of three format | |
| tags. */ | |
| if (tags_processed > 2) | |
| return -1; /* XXX look for kernel error code. */ | |
| /* Depending on the kind of tag, extract the value from the | |
| proper argument. */ | |
| if (i++ >= size) | |
| return -1; /* XXX look for kernel error code. */ | |
| value = bpf_regs[BPF_R3 + tags_processed]; | |
| switch ((bpf_read_u8 (cpu, fmt_address + i))) | |
| { | |
| case 'd': | |
| trace_printf (sd, cpu, "%d", (int) value); | |
| break; | |
| case 'i': | |
| trace_printf (sd, cpu, "%i", (int) value); | |
| break; | |
| case 'u': | |
| trace_printf (sd, cpu, "%u", (unsigned int) value); | |
| break; | |
| case 'x': | |
| trace_printf (sd, cpu, "%x", (unsigned int) value); | |
| break; | |
| case 'l': | |
| { | |
| if (i++ >= size) | |
| return -1; | |
| switch (bpf_read_u8 (cpu, fmt_address + i)) | |
| { | |
| case 'd': | |
| trace_printf (sd, cpu, "%ld", (long) value); | |
| break; | |
| case 'i': | |
| trace_printf (sd, cpu, "%li", (long) value); | |
| break; | |
| case 'u': | |
| trace_printf (sd, cpu, "%lu", (unsigned long) value); | |
| break; | |
| case 'x': | |
| trace_printf (sd, cpu, "%lx", (unsigned long) value); | |
| break; | |
| case 'l': | |
| { | |
| if (i++ >= size) | |
| return -1; | |
| switch (bpf_read_u8 (cpu, fmt_address + i)) | |
| { | |
| case 'd': | |
| trace_printf (sd, cpu, "%lld", (long long) value); | |
| break; | |
| case 'i': | |
| trace_printf (sd, cpu, "%lli", (long long) value); | |
| break; | |
| case 'u': | |
| trace_printf (sd, cpu, "%llu", (unsigned long long) value); | |
| break; | |
| case 'x': | |
| trace_printf (sd, cpu, "%llx", (unsigned long long) value); | |
| break; | |
| default: | |
| assert (0); | |
| break; | |
| } | |
| break; | |
| } | |
| default: | |
| assert (0); | |
| break; | |
| } | |
| break; | |
| } | |
| default: | |
| /* XXX completeme */ | |
| assert (0); | |
| break; | |
| } | |
| tags_processed++; | |
| i++; | |
| break; | |
| case '\0': | |
| i = size; | |
| break; | |
| default: | |
| trace_printf (sd, cpu, "%c", c); | |
| bytes_written++; | |
| i++; | |
| break; | |
| } | |
| } | |
| return bytes_written; | |
| } | |
| /****** Accessors to install in the CPU description. ******/ | |
| static int | |
| bpf_reg_get (SIM_CPU *cpu, int rn, void *buf, int length) | |
| { | |
| bpf_reg val; | |
| unsigned char *memory = buf; | |
| if (length != 8 || rn >= 11) | |
| return 0; | |
| val = bpf_regs[rn]; | |
| if (current_target_byte_order == BFD_ENDIAN_LITTLE) | |
| { | |
| memory[7] = (val >> 56) & 0xff; | |
| memory[6] = (val >> 48) & 0xff; | |
| memory[5] = (val >> 40) & 0xff; | |
| memory[4] = (val >> 32) & 0xff; | |
| memory[3] = (val >> 24) & 0xff; | |
| memory[2] = (val >> 16) & 0xff; | |
| memory[1] = (val >> 8) & 0xff; | |
| memory[0] = val & 0xff; | |
| } | |
| else | |
| { | |
| memory[0] = (val >> 56) & 0xff; | |
| memory[1] = (val >> 48) & 0xff; | |
| memory[2] = (val >> 40) & 0xff; | |
| memory[3] = (val >> 32) & 0xff; | |
| memory[4] = (val >> 24) & 0xff; | |
| memory[5] = (val >> 16) & 0xff; | |
| memory[6] = (val >> 8) & 0xff; | |
| memory[7] = val & 0xff; | |
| } | |
| return 8; | |
| } | |
| static int | |
| bpf_reg_set (SIM_CPU *cpu, int rn, const void *buf, int length) | |
| { | |
| const unsigned char *memory = buf; | |
| if (length != 8 || rn >= 11) | |
| return 0; | |
| if (current_target_byte_order == BFD_ENDIAN_LITTLE) | |
| bpf_regs[rn] = (((uint64_t) memory[7] << 56) | |
| | ((uint64_t) memory[6] << 48) | |
| | ((uint64_t) memory[5] << 40) | |
| | ((uint64_t) memory[4] << 32) | |
| | ((uint64_t) memory[3] << 24) | |
| | ((uint64_t) memory[2] << 16) | |
| | ((uint64_t) memory[1] << 8) | |
| | ((uint64_t) memory[0])); | |
| else | |
| bpf_regs[rn] = (((uint64_t) memory[0] << 56) | |
| | ((uint64_t) memory[1] << 48) | |
| | ((uint64_t) memory[2] << 40) | |
| | ((uint64_t) memory[3] << 32) | |
| | ((uint64_t) memory[4] << 24) | |
| | ((uint64_t) memory[5] << 16) | |
| | ((uint64_t) memory[6] << 8) | |
| | ((uint64_t) memory[7])); | |
| return 8; | |
| } | |
| static sim_cia | |
| bpf_pc_get (sim_cpu *cpu) | |
| { | |
| return bpf_pc; | |
| } | |
| static void | |
| bpf_pc_set (sim_cpu *cpu, sim_cia pc) | |
| { | |
| bpf_pc = pc; | |
| } | |
| /***** Other global state. ******/ | |
| static int64_t skb_data_offset; | |
| /***** Handle BPF-specific command line options. *****/ | |
| static SIM_RC bpf_option_handler (SIM_DESC, sim_cpu *, int, char *, int); | |
| typedef enum | |
| { | |
| OPTION_BPF_SET_PROGRAM = OPTION_START, | |
| OPTION_BPF_LIST_PROGRAMS, | |
| OPTION_BPF_VERIFY_PROGRAM, | |
| OPTION_BPF_SKB_DATA_OFFSET, | |
| } BPF_OPTION; | |
| static const OPTION bpf_options[] = | |
| { | |
| { {"bpf-set-program", required_argument, NULL, OPTION_BPF_SET_PROGRAM}, | |
| '\0', "SECTION_NAME", "Set the entry point", | |
| bpf_option_handler }, | |
| { {"bpf-list-programs", no_argument, NULL, OPTION_BPF_LIST_PROGRAMS}, | |
| '\0', "", "List loaded bpf programs", | |
| bpf_option_handler }, | |
| { {"bpf-verify-program", required_argument, NULL, OPTION_BPF_VERIFY_PROGRAM}, | |
| '\0', "PROGRAM", "Run the verifier on the given BPF program", | |
| bpf_option_handler }, | |
| { {"skb-data-offset", required_argument, NULL, OPTION_BPF_SKB_DATA_OFFSET}, | |
| '\0', "OFFSET", "Configure offsetof(struct sk_buff, data)", | |
| bpf_option_handler }, | |
| { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL } | |
| }; | |
| static SIM_RC | |
| bpf_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt, | |
| char *arg, int is_command ATTRIBUTE_UNUSED) | |
| { | |
| switch ((BPF_OPTION) opt) | |
| { | |
| case OPTION_BPF_VERIFY_PROGRAM: | |
| /* XXX call the verifier. */ | |
| sim_io_printf (sd, "Verifying BPF program %s...\n", arg); | |
| break; | |
| case OPTION_BPF_LIST_PROGRAMS: | |
| /* XXX list programs. */ | |
| sim_io_printf (sd, "BPF programs available:\n"); | |
| break; | |
| case OPTION_BPF_SET_PROGRAM: | |
| /* XXX: check that the section exists and tell the user about a | |
| new start_address. */ | |
| break; | |
| case OPTION_BPF_SKB_DATA_OFFSET: | |
| skb_data_offset = strtoul (arg, NULL, 0); | |
| break; | |
| default: | |
| sim_io_eprintf (sd, "Unknown option `%s'\n", arg); | |
| return SIM_RC_FAIL; | |
| } | |
| return SIM_RC_OK; | |
| } | |
| /***** Instruction decoding. *****/ | |
| /* Decoded BPF instruction. */ | |
| struct bpf_insn | |
| { | |
| enum bpf_insn_id id; | |
| int size; /* Instruction size in bytes. */ | |
| bpf_reg dst; | |
| bpf_reg src; | |
| int16_t offset16; | |
| int32_t imm32; | |
| int64_t imm64; | |
| }; | |
| /* Read an instruction word at the given PC. Note that we need to | |
| return a big-endian word. */ | |
| static bpf_insn_word | |
| bpf_read_insn_word (SIM_CPU *cpu, uint64_t pc) | |
| { | |
| bpf_insn_word word = sim_core_read_unaligned_8 (cpu, 0, read_map, pc); | |
| if (current_target_byte_order == BFD_ENDIAN_LITTLE) | |
| word = endian_le2h_8 (word); | |
| else | |
| word = endian_be2h_8 (word); | |
| return endian_h2be_8 (word); | |
| } | |
| /* Decode and return a BPF instruction at the given PC. Return 0 if | |
| no valid instruction is found, 1 otherwise. */ | |
| static int ATTRIBUTE_UNUSED | |
| decode (SIM_CPU *cpu, uint64_t pc, struct bpf_insn *insn) | |
| { | |
| const struct bpf_opcode *opcode; | |
| bpf_insn_word word; | |
| const char *p; | |
| enum bpf_endian endian | |
| = (current_target_byte_order == BFD_ENDIAN_LITTLE | |
| ? BPF_ENDIAN_LITTLE : BPF_ENDIAN_BIG); | |
| /* Initialize the insn struct. */ | |
| memset (insn, 0, sizeof (struct bpf_insn)); | |
| /* Read a 64-bit instruction word at PC. */ | |
| word = bpf_read_insn_word (cpu, pc); | |
| /* See if it is a valid instruction and get the opcodes. */ | |
| opcode = bpf_match_insn (word, endian, BPF_V4); | |
| if (!opcode) | |
| return 0; | |
| insn->id = opcode->id; | |
| insn->size = 8; | |
| /* Extract operands using the instruction as a guide. */ | |
| for (p = opcode->normal; *p != '\0';) | |
| { | |
| if (*p == '%') | |
| { | |
| if (*(p + 1) == '%') | |
| p += 2; | |
| else if (strncmp (p, "%dr", 3) == 0) | |
| { | |
| insn->dst = bpf_extract_dst (word, endian); | |
| p += 3; | |
| } | |
| else if (strncmp (p, "%sr", 3) == 0) | |
| { | |
| insn->src = bpf_extract_src (word, endian); | |
| p += 3; | |
| } | |
| else if (strncmp (p, "%dw", 3) == 0) | |
| { | |
| insn->dst = bpf_extract_dst (word, endian); | |
| p += 3; | |
| } | |
| else if (strncmp (p, "%sw", 3) == 0) | |
| { | |
| insn->src = bpf_extract_src (word, endian); | |
| p += 3; | |
| } | |
| else if (strncmp (p, "%i32", 4) == 0 | |
| || strncmp (p, "%d32", 4) == 0) | |
| { | |
| insn->imm32 = bpf_extract_imm32 (word, endian); | |
| p += 4; | |
| } | |
| else if (strncmp (p, "%o16", 4) == 0 | |
| || strncmp (p, "%d16", 4) == 0) | |
| { | |
| insn->offset16 = bpf_extract_offset16 (word, endian); | |
| p += 4; | |
| } | |
| else if (strncmp (p, "%i64", 4) == 0) | |
| { | |
| bpf_insn_word word2; | |
| /* XXX PC + 8 */ | |
| word2 = bpf_read_insn_word (cpu, pc + 8); | |
| insn->imm64 = bpf_extract_imm64 (word, word2, endian); | |
| insn->size = 16; | |
| p += 4; | |
| } | |
| else if (strncmp (p, "%w", 2) == 0 | |
| || strncmp (p, "%W", 2) == 0) | |
| { | |
| /* Ignore these templates. */ | |
| p += 2; | |
| } | |
| else | |
| /* Malformed opcode template. */ | |
| /* XXX ignore unknown tags? */ | |
| assert (0); | |
| } | |
| else | |
| p += 1; | |
| } | |
| return 1; | |
| } | |
| /***** Instruction semantics. *****/ | |
| static void | |
| bpf_call (SIM_CPU *cpu, int32_t disp32, uint8_t src) | |
| { | |
| /* eBPF supports two kind of CALL instructions: the so called pseudo | |
| calls ("bpf to bpf") and external calls ("bpf to helper"). | |
| Both kind of calls use the same instruction (CALL). However, | |
| external calls are constructed by passing a constant argument to | |
| the instruction, that identifies the helper, whereas pseudo calls | |
| result from expressions involving symbols. | |
| We distinguish calls from pseudo-calls with the later having a 1 | |
| stored in the SRC field of the instruction. */ | |
| if (src == 1) | |
| { | |
| /* This is a pseudo-call. */ | |
| /* XXX allocate a new stack frame and transfer control. For | |
| that we need to analyze the target function, like the kernel | |
| verifier does. We better populate a cache | |
| (function_start_address -> frame_size) so we avoid | |
| calculating this more than once. But it is easier to just | |
| allocate the maximum stack size per stack frame? */ | |
| /* XXX note that disp32 is PC-relative in number of 64-bit | |
| words, _minus one_. */ | |
| } | |
| else | |
| { | |
| /* This is a call to a helper. | |
| DISP32 contains the helper number. */ | |
| switch (disp32) { | |
| /* case TRACE_PRINTK: */ | |
| case 7: | |
| bpf_trace_printk (cpu); | |
| break; | |
| default:; | |
| } | |
| } | |
| } | |
| static int | |
| execute (SIM_CPU *cpu, struct bpf_insn *insn) | |
| { | |
| uint64_t next_pc = bpf_pc + insn->size; | |
| /* Displacements in instructions are encoded in number of 64-bit | |
| words _minus one_, and not in bytes. */ | |
| #define DISP(OFFSET) (((OFFSET) + 1) * 8) | |
| /* For debugging. */ | |
| #define BPF_TRACE(STR) \ | |
| do \ | |
| { \ | |
| if (0) \ | |
| printf ("%s", (STR)); \ | |
| } \ | |
| while (0) | |
| switch (insn->id) | |
| { | |
| /* Instruction to trap to GDB. */ | |
| case BPF_INSN_BRKPT: | |
| BPF_TRACE ("BPF_INSN_BRKPT\n"); | |
| sim_engine_halt (CPU_STATE (cpu), cpu, | |
| NULL, bpf_pc, sim_stopped, SIM_SIGTRAP); | |
| break; | |
| /* ALU instructions. */ | |
| case BPF_INSN_ADDR: | |
| BPF_TRACE ("BPF_INSN_ADDR\n"); | |
| bpf_regs[insn->dst] += bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_ADDI: | |
| BPF_TRACE ("BPF_INSN_ADDI\n"); | |
| bpf_regs[insn->dst] += insn->imm32; | |
| break; | |
| case BPF_INSN_SUBR: | |
| BPF_TRACE ("BPF_INSN_SUBR\n"); | |
| bpf_regs[insn->dst] -= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_SUBI: | |
| BPF_TRACE ("BPF_INSN_SUBI\n"); | |
| bpf_regs[insn->dst] -= insn->imm32; | |
| break; | |
| case BPF_INSN_MULR: | |
| BPF_TRACE ("BPF_INSN_MULR\n"); | |
| bpf_regs[insn->dst] *= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_MULI: | |
| BPF_TRACE ("BPF_INSN_MULI\n"); | |
| bpf_regs[insn->dst] *= insn->imm32; | |
| break; | |
| case BPF_INSN_DIVR: | |
| BPF_TRACE ("BPF_INSN_DIVR\n"); | |
| if (bpf_regs[insn->src] == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] /= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_DIVI: | |
| BPF_TRACE ("BPF_INSN_DIVI\n"); | |
| if (insn->imm32 == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] /= insn->imm32; | |
| break; | |
| case BPF_INSN_MODR: | |
| BPF_TRACE ("BPF_INSN_MODR\n"); | |
| if (bpf_regs[insn->src] == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] %= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_MODI: | |
| BPF_TRACE ("BPF_INSN_MODI\n"); | |
| if (insn->imm32 == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] %= insn->imm32; | |
| break; | |
| case BPF_INSN_ORR: | |
| BPF_TRACE ("BPF_INSN_ORR\n"); | |
| bpf_regs[insn->dst] |= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_ORI: | |
| BPF_TRACE ("BPF_INSN_ORI\n"); | |
| bpf_regs[insn->dst] |= insn->imm32; | |
| break; | |
| case BPF_INSN_ANDR: | |
| BPF_TRACE ("BPF_INSN_ANDR\n"); | |
| bpf_regs[insn->dst] &= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_ANDI: | |
| BPF_TRACE ("BPF_INSN_ANDI\n"); | |
| bpf_regs[insn->dst] &= insn->imm32; | |
| break; | |
| case BPF_INSN_XORR: | |
| BPF_TRACE ("BPF_INSN_XORR\n"); | |
| bpf_regs[insn->dst] ^= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_XORI: | |
| BPF_TRACE ("BPF_INSN_XORI\n"); | |
| bpf_regs[insn->dst] ^= insn->imm32; | |
| break; | |
| case BPF_INSN_SDIVR: | |
| BPF_TRACE ("BPF_INSN_SDIVR\n"); | |
| if (bpf_regs[insn->src] == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (int64_t) bpf_regs[insn->dst] / (int64_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_SDIVI: | |
| BPF_TRACE ("BPF_INSN_SDIVI\n"); | |
| if (insn->imm32 == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (int64_t) bpf_regs[insn->dst] / (int64_t) insn->imm32; | |
| break; | |
| case BPF_INSN_SMODR: | |
| BPF_TRACE ("BPF_INSN_SMODR\n"); | |
| if (bpf_regs[insn->src] == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (int64_t) bpf_regs[insn->dst] % (int64_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_SMODI: | |
| BPF_TRACE ("BPF_INSN_SMODI\n"); | |
| if (insn->imm32 == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (int64_t) bpf_regs[insn->dst] % (int64_t) insn->imm32; | |
| break; | |
| case BPF_INSN_NEGR: | |
| BPF_TRACE ("BPF_INSN_NEGR\n"); | |
| bpf_regs[insn->dst] = - (int64_t) bpf_regs[insn->dst]; | |
| break; | |
| case BPF_INSN_LSHR: | |
| BPF_TRACE ("BPF_INSN_LSHR\n"); | |
| bpf_regs[insn->dst] <<= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_LSHI: | |
| BPF_TRACE ("BPF_INSN_LSHI\n"); | |
| bpf_regs[insn->dst] <<= insn->imm32; | |
| break; | |
| case BPF_INSN_RSHR: | |
| BPF_TRACE ("BPF_INSN_RSHR\n"); | |
| bpf_regs[insn->dst] >>= bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_RSHI: | |
| BPF_TRACE ("BPF_INSN_RSHI\n"); | |
| bpf_regs[insn->dst] >>= insn->imm32; | |
| break; | |
| case BPF_INSN_ARSHR: | |
| BPF_TRACE ("BPF_INSN_ARSHR\n"); | |
| bpf_regs[insn->dst] = (int64_t) bpf_regs[insn->dst] >> bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_ARSHI: | |
| BPF_TRACE ("BPF_INSN_ARSHI\n"); | |
| bpf_regs[insn->dst] = (int64_t) bpf_regs[insn->dst] >> insn->imm32; | |
| break; | |
| case BPF_INSN_MOVR: | |
| BPF_TRACE ("BPF_INSN_MOVR\n"); | |
| bpf_regs[insn->dst] = bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_MOVI: | |
| BPF_TRACE ("BPF_INSN_MOVI\n"); | |
| bpf_regs[insn->dst] = insn->imm32; | |
| break; | |
| /* ALU32 instructions. */ | |
| case BPF_INSN_ADD32R: | |
| BPF_TRACE ("BPF_INSN_ADD32R\n"); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] + (int32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_ADD32I: | |
| BPF_TRACE ("BPF_INSN_ADD32I\n"); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] + insn->imm32; | |
| break; | |
| case BPF_INSN_SUB32R: | |
| BPF_TRACE ("BPF_INSN_SUB32R\n"); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] - (int32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_SUB32I: | |
| BPF_TRACE ("BPF_INSN_SUB32I\n"); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] - insn->imm32; | |
| break; | |
| case BPF_INSN_MUL32R: | |
| BPF_TRACE ("BPF_INSN_MUL32R\n"); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] * (int32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_MUL32I: | |
| BPF_TRACE ("BPF_INSN_MUL32I\n"); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] * (int32_t) insn->imm32; | |
| break; | |
| case BPF_INSN_DIV32R: | |
| BPF_TRACE ("BPF_INSN_DIV32R\n"); | |
| if (bpf_regs[insn->src] == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] / (uint32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_DIV32I: | |
| BPF_TRACE ("BPF_INSN_DIV32I\n"); | |
| if (insn->imm32 == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] / (uint32_t) insn->imm32; | |
| break; | |
| case BPF_INSN_MOD32R: | |
| BPF_TRACE ("BPF_INSN_MOD32R\n"); | |
| if (bpf_regs[insn->src] == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] % (uint32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_MOD32I: | |
| BPF_TRACE ("BPF_INSN_MOD32I\n"); | |
| if (insn->imm32 == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] % (uint32_t) insn->imm32; | |
| break; | |
| case BPF_INSN_OR32R: | |
| BPF_TRACE ("BPF_INSN_OR32R\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] | (int32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_OR32I: | |
| BPF_TRACE ("BPF_INSN_OR32I\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] | (int32_t) insn->imm32; | |
| break; | |
| case BPF_INSN_AND32R: | |
| BPF_TRACE ("BPF_INSN_AND32R\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] & (int32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_AND32I: | |
| BPF_TRACE ("BPF_INSN_AND32I\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] & (int32_t) insn->imm32; | |
| break; | |
| case BPF_INSN_XOR32R: | |
| BPF_TRACE ("BPF_INSN_XOR32R\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] ^ (int32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_XOR32I: | |
| BPF_TRACE ("BPF_INSN_XOR32I\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] ^ (int32_t) insn->imm32; | |
| break; | |
| case BPF_INSN_SDIV32R: | |
| BPF_TRACE ("BPF_INSN_SDIV32R\n"); | |
| if (bpf_regs[insn->src] == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] / (int32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_SDIV32I: | |
| BPF_TRACE ("BPF_INSN_SDIV32I\n"); | |
| if (insn->imm32 == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] / (int32_t) insn->imm32; | |
| break; | |
| case BPF_INSN_SMOD32R: | |
| BPF_TRACE ("BPF_INSN_SMOD32R\n"); | |
| if (bpf_regs[insn->src] == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] % (int32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_SMOD32I: | |
| BPF_TRACE ("BPF_INSN_SMOD32I\n"); | |
| if (insn->imm32 == 0) | |
| sim_engine_halt (CPU_STATE (cpu), cpu, NULL, bpf_pc, sim_signalled, SIM_SIGFPE); | |
| bpf_regs[insn->dst] = (int32_t) bpf_regs[insn->dst] % (int32_t) insn->imm32; | |
| break; | |
| case BPF_INSN_NEG32R: | |
| BPF_TRACE ("BPF_INSN_NEG32R\n"); | |
| bpf_regs[insn->dst] = (uint32_t) (- (int32_t) bpf_regs[insn->dst]); | |
| break; | |
| case BPF_INSN_LSH32R: | |
| BPF_TRACE ("BPF_INSN_LSH32R\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] << bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_LSH32I: | |
| BPF_TRACE ("BPF_INSN_LSH32I\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] << insn->imm32; | |
| break; | |
| case BPF_INSN_RSH32R: | |
| BPF_TRACE ("BPF_INSN_RSH32R\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] >> bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_RSH32I: | |
| BPF_TRACE ("BPF_INSN_RSH32I\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->dst] >> insn->imm32; | |
| break; | |
| case BPF_INSN_ARSH32R: | |
| BPF_TRACE ("BPF_INSN_ARSH32R\n"); | |
| bpf_regs[insn->dst] = (uint32_t)((int32_t)(uint32_t) bpf_regs[insn->dst] >> bpf_regs[insn->src]); | |
| break; | |
| case BPF_INSN_ARSH32I: | |
| BPF_TRACE ("BPF_INSN_ARSH32I\n"); | |
| bpf_regs[insn->dst] = (uint32_t)((int32_t)(uint32_t) bpf_regs[insn->dst] >> insn->imm32); | |
| break; | |
| case BPF_INSN_MOV32R: | |
| BPF_TRACE ("BPF_INSN_MOV32R\n"); | |
| bpf_regs[insn->dst] = (uint32_t) bpf_regs[insn->src]; | |
| break; | |
| case BPF_INSN_MOV32I: | |
| BPF_TRACE ("BPF_INSN_MOV32I\n"); | |
| bpf_regs[insn->dst] = (uint32_t) insn->imm32; | |
| break; | |
| /* Endianness conversion instructions. */ | |
| case BPF_INSN_ENDLE16: | |
| BPF_TRACE ("BPF_INSN_ENDLE16\n"); | |
| bpf_regs[insn->dst] = endian_h2le_2 (endian_t2h_2 (bpf_regs[insn->dst])); | |
| break; | |
| case BPF_INSN_ENDLE32: | |
| BPF_TRACE ("BPF_INSN_ENDLE32\n"); | |
| bpf_regs[insn->dst] = endian_h2le_4 (endian_t2h_4 (bpf_regs[insn->dst])); | |
| break; | |
| case BPF_INSN_ENDLE64: | |
| BPF_TRACE ("BPF_INSN_ENDLE64\n"); | |
| bpf_regs[insn->dst] = endian_h2le_8 (endian_t2h_8 (bpf_regs[insn->dst])); | |
| break; | |
| case BPF_INSN_ENDBE16: | |
| BPF_TRACE ("BPF_INSN_ENDBE16\n"); | |
| bpf_regs[insn->dst] = endian_h2be_2 (endian_t2h_2 (bpf_regs[insn->dst])); | |
| break; | |
| case BPF_INSN_ENDBE32: | |
| BPF_TRACE ("BPF_INSN_ENDBE32\n"); | |
| bpf_regs[insn->dst] = endian_h2be_4 (endian_t2h_4 (bpf_regs[insn->dst])); | |
| break; | |
| case BPF_INSN_ENDBE64: | |
| BPF_TRACE ("BPF_INSN_ENDBE64\n"); | |
| bpf_regs[insn->dst] = endian_h2be_8 (endian_t2h_8 (bpf_regs[insn->dst])); | |
| break; | |
| /* 64-bit load instruction. */ | |
| case BPF_INSN_LDDW: | |
| BPF_TRACE ("BPF_INSN_LDDW\n"); | |
| bpf_regs[insn->dst] = insn->imm64; | |
| break; | |
| /* Indirect load instructions. */ | |
| case BPF_INSN_LDINDB: | |
| BPF_TRACE ("BPF_INSN_LDINDB\n"); | |
| bpf_regs[BPF_R0] = bpf_read_u8 (cpu, | |
| bpf_read_u64 (cpu, bpf_regs[BPF_R6] + skb_data_offset) | |
| + bpf_regs[insn->src] + insn->imm32); | |
| break; | |
| case BPF_INSN_LDINDH: | |
| BPF_TRACE ("BPF_INSN_LDINDH\n"); | |
| bpf_regs[BPF_R0] = bpf_read_u16 (cpu, | |
| bpf_read_u64 (cpu, bpf_regs[BPF_R6] + skb_data_offset) | |
| + bpf_regs[insn->src] + insn->imm32); | |
| break; | |
| case BPF_INSN_LDINDW: | |
| BPF_TRACE ("BPF_INSN_LDINDW\n"); | |
| bpf_regs[BPF_R0] = bpf_read_u32 (cpu, | |
| bpf_read_u64 (cpu, bpf_regs[BPF_R6] + skb_data_offset) | |
| + bpf_regs[insn->src] + insn->imm32); | |
| break; | |
| case BPF_INSN_LDABSB: | |
| BPF_TRACE ("BPF_INSN_LDABSB\n"); | |
| bpf_regs[BPF_R0] = bpf_read_u8 (cpu, | |
| bpf_read_u64 (cpu, bpf_regs[BPF_R6] + skb_data_offset) | |
| + insn->imm32); | |
| break; | |
| case BPF_INSN_LDABSH: | |
| BPF_TRACE ("BPF_INSN_LDABSH\n"); | |
| bpf_regs[BPF_R0] = bpf_read_u16 (cpu, | |
| bpf_read_u64 (cpu, bpf_regs[BPF_R6] + skb_data_offset) | |
| + insn->imm32); | |
| break; | |
| case BPF_INSN_LDABSW: | |
| BPF_TRACE ("BPF_INSN_LDABSW\n"); | |
| bpf_regs[BPF_R0] = bpf_read_u32 (cpu, | |
| bpf_read_u64 (cpu, bpf_regs[BPF_R6] + skb_data_offset) | |
| + insn->imm32); | |
| break; | |
| /* Generic load instructions (to register.) */ | |
| case BPF_INSN_LDXB: | |
| BPF_TRACE ("BPF_INSN_LDXB\n"); | |
| bpf_regs[insn->dst] = (int8_t) bpf_read_u8 (cpu, | |
| bpf_regs[insn->src] + insn->offset16); | |
| break; | |
| case BPF_INSN_LDXH: | |
| BPF_TRACE ("BPF_INSN_LDXH\n"); | |
| bpf_regs[insn->dst] = (int16_t) bpf_read_u16 (cpu, | |
| bpf_regs[insn->src] + insn->offset16); | |
| break; | |
| case BPF_INSN_LDXW: | |
| BPF_TRACE ("BPF_INSN_LDXW\n"); | |
| bpf_regs[insn->dst] = (int32_t) bpf_read_u32 (cpu, | |
| bpf_regs[insn->src] + insn->offset16); | |
| break; | |
| case BPF_INSN_LDXDW: | |
| BPF_TRACE ("BPF_INSN_LDXDW\n"); | |
| bpf_regs[insn->dst] = bpf_read_u64 (cpu, | |
| bpf_regs[insn->src] + insn->offset16); | |
| break; | |
| /* Generic store instructions (from register.) */ | |
| case BPF_INSN_STXBR: | |
| BPF_TRACE ("BPF_INSN_STXBR\n"); | |
| bpf_write_u8 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| bpf_regs[insn->src]); | |
| break; | |
| case BPF_INSN_STXHR: | |
| BPF_TRACE ("BPF_INSN_STXHR\n"); | |
| bpf_write_u16 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| bpf_regs[insn->src]); | |
| break; | |
| case BPF_INSN_STXWR: | |
| BPF_TRACE ("BPF_INSN_STXWR\n"); | |
| bpf_write_u32 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| bpf_regs[insn->src]); | |
| break; | |
| case BPF_INSN_STXDWR: | |
| BPF_TRACE ("BPF_INSN_STXDWR\n"); | |
| bpf_write_u64 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| bpf_regs[insn->src]); | |
| break; | |
| /* Generic store instructions (from 32-bit immediate.) */ | |
| case BPF_INSN_STXBI: | |
| BPF_TRACE ("BPF_INSN_STXBI\n"); | |
| bpf_write_u8 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| insn->imm32); | |
| break; | |
| case BPF_INSN_STXHI: | |
| BPF_TRACE ("BPF_INSN_STXHI\n"); | |
| bpf_write_u16 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| insn->imm32); | |
| break; | |
| case BPF_INSN_STXWI: | |
| BPF_TRACE ("BPF_INSN_STXWI\n"); | |
| bpf_write_u32 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| insn->imm32); | |
| break; | |
| case BPF_INSN_STXDWI: | |
| BPF_TRACE ("BPF_INSN_STXDWI\n"); | |
| bpf_write_u64 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| insn->imm32); | |
| break; | |
| /* Compare-and-jump instructions (reg OP reg). */ | |
| case BPF_INSN_JAR: | |
| BPF_TRACE ("BPF_INSN_JAR\n"); | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JEQR: | |
| BPF_TRACE ("BPF_INSN_JEQR\n"); | |
| if (bpf_regs[insn->dst] == bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JGTR: | |
| BPF_TRACE ("BPF_INSN_JGTR\n"); | |
| if (bpf_regs[insn->dst] > bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSGTR: | |
| BPF_TRACE ("BPF_INSN_JSGTR\n"); | |
| if ((int64_t) bpf_regs[insn->dst] > (int64_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JGER: | |
| BPF_TRACE ("BPF_INSN_JGER\n"); | |
| if (bpf_regs[insn->dst] >= bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSGER: | |
| BPF_TRACE ("BPF_INSN_JSGER\n"); | |
| if ((int64_t) bpf_regs[insn->dst] >= (int64_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JLTR: | |
| BPF_TRACE ("BPF_INSN_JLTR\n"); | |
| if (bpf_regs[insn->dst] < bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSLTR: | |
| BPF_TRACE ("BPF_INSN_JSLTR\n"); | |
| if ((int64_t) bpf_regs[insn->dst] < (int64_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JLER: | |
| BPF_TRACE ("BPF_INSN_JLER\n"); | |
| if (bpf_regs[insn->dst] <= bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSLER: | |
| BPF_TRACE ("BPF_INSN_JSLER\n"); | |
| if ((int64_t) bpf_regs[insn->dst] <= (int64_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSETR: | |
| BPF_TRACE ("BPF_INSN_JSETR\n"); | |
| if (bpf_regs[insn->dst] & bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JNER: | |
| BPF_TRACE ("BPF_INSN_JNER\n"); | |
| if (bpf_regs[insn->dst] != bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_CALLR: | |
| BPF_TRACE ("BPF_INSN_CALLR\n"); | |
| bpf_call (cpu, DISP (bpf_regs[insn->dst]), insn->src); | |
| break; | |
| case BPF_INSN_CALL: | |
| BPF_TRACE ("BPF_INSN_CALL\n"); | |
| bpf_call (cpu, insn->imm32, insn->src); | |
| break; | |
| case BPF_INSN_EXIT: | |
| BPF_TRACE ("BPF_INSN_EXIT\n"); | |
| { | |
| SIM_DESC sd = CPU_STATE (cpu); | |
| printf ("exit %" PRId64 " (0x%" PRIx64 ")\n", | |
| bpf_regs[BPF_R0], bpf_regs[BPF_R0]); | |
| sim_engine_halt (sd, cpu, NULL, bpf_pc, | |
| sim_exited, 0 /* sigrc */); | |
| break; | |
| } | |
| /* Compare-and-jump instructions (reg OP imm). */ | |
| case BPF_INSN_JEQI: | |
| BPF_TRACE ("BPF_INSN_JEQI\n"); | |
| if (bpf_regs[insn->dst] == insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JGTI: | |
| BPF_TRACE ("BPF_INSN_JGTI\n"); | |
| if (bpf_regs[insn->dst] > insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSGTI: | |
| BPF_TRACE ("BPF_INSN_JSGTI\n"); | |
| if ((int64_t) bpf_regs[insn->dst] > insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JGEI: | |
| BPF_TRACE ("BPF_INSN_JGEI\n"); | |
| if (bpf_regs[insn->dst] >= insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSGEI: | |
| BPF_TRACE ("BPF_INSN_JSGEI\n"); | |
| if ((int64_t) bpf_regs[insn->dst] >= (int64_t) insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JLTI: | |
| BPF_TRACE ("BPF_INSN_JLTI\n"); | |
| if (bpf_regs[insn->dst] < insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSLTI: | |
| BPF_TRACE ("BPF_INSN_JSLTI\n"); | |
| if ((int64_t) bpf_regs[insn->dst] < (int64_t) insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JLEI: | |
| BPF_TRACE ("BPF_INSN_JLEI\n"); | |
| if (bpf_regs[insn->dst] <= insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSLEI: | |
| BPF_TRACE ("BPF_INSN_JSLEI\n"); | |
| if ((int64_t) bpf_regs[insn->dst] <= (int64_t) insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSETI: | |
| BPF_TRACE ("BPF_INSN_JSETI\n"); | |
| if (bpf_regs[insn->dst] & insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JNEI: | |
| BPF_TRACE ("BPF_INSN_JNEI\n"); | |
| if (bpf_regs[insn->dst] != insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| /* 32-bit compare-and-jump instructions (reg OP reg). */ | |
| case BPF_INSN_JEQ32R: | |
| BPF_TRACE ("BPF_INSN_JEQ32R\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] == (uint32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JGT32R: | |
| BPF_TRACE ("BPF_INSN_JGT32R\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] > (uint32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSGT32R: | |
| BPF_TRACE ("BPF_INSN_JSGT32R\n"); | |
| if ((int32_t) bpf_regs[insn->dst] > (int32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JGE32R: | |
| BPF_TRACE ("BPF_INSN_JGE32R\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] >= (uint32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSGE32R: | |
| BPF_TRACE ("BPF_INSN_JSGE32R\n"); | |
| if ((int32_t) bpf_regs[insn->dst] >= (int32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JLT32R: | |
| BPF_TRACE ("BPF_INSN_JLT32R\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] < (uint32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSLT32R: | |
| BPF_TRACE ("BPF_INSN_JSLT32R\n"); | |
| if ((int32_t) bpf_regs[insn->dst] < (int32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JLE32R: | |
| BPF_TRACE ("BPF_INSN_JLE32R\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] <= (uint32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSLE32R: | |
| BPF_TRACE ("BPF_INSN_JSLE32R\n"); | |
| if ((int32_t) bpf_regs[insn->dst] <= (int32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSET32R: | |
| BPF_TRACE ("BPF_INSN_JSET32R\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] & (uint32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JNE32R: | |
| BPF_TRACE ("BPF_INSN_JNE32R\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] != (uint32_t) bpf_regs[insn->src]) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| /* 32-bit compare-and-jump instructions (reg OP imm). */ | |
| case BPF_INSN_JEQ32I: | |
| BPF_TRACE ("BPF_INSN_JEQ32I\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] == insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JGT32I: | |
| BPF_TRACE ("BPF_INSN_JGT32I\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] > insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSGT32I: | |
| BPF_TRACE ("BPF_INSN_JSGT32I\n"); | |
| if ((int32_t) bpf_regs[insn->dst] > insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JGE32I: | |
| BPF_TRACE ("BPF_INSN_JGE32I\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] >= insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSGE32I: | |
| BPF_TRACE ("BPF_INSN_JSGE32I\n"); | |
| if ((int32_t) bpf_regs[insn->dst] >= (int32_t) insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JLT32I: | |
| BPF_TRACE ("BPF_INSN_JLT32I\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] < insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSLT32I: | |
| BPF_TRACE ("BPF_INSN_JSLT32I\n"); | |
| if ((int32_t) bpf_regs[insn->dst] < (int32_t) insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JLE32I: | |
| BPF_TRACE ("BPF_INSN_JLE32I\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] <= insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSLE32I: | |
| BPF_TRACE ("BPF_INSN_JSLE32I\n"); | |
| if ((int32_t) bpf_regs[insn->dst] <= (int32_t) insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JSET32I: | |
| BPF_TRACE ("BPF_INSN_JSET32I\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] & insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| case BPF_INSN_JNE32I: | |
| BPF_TRACE ("BPF_INSN_JNE32I\n"); | |
| if ((uint32_t) bpf_regs[insn->dst] != insn->imm32) | |
| next_pc = bpf_pc + DISP (insn->offset16); | |
| break; | |
| /* Atomic instructions. */ | |
| case BPF_INSN_AADD: | |
| BPF_TRACE ("BPF_INSN_AADD\n"); | |
| bpf_write_u64 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| bpf_read_u64 (cpu, bpf_regs[insn->dst] + insn->offset16) | |
| + bpf_regs[insn->src]); | |
| break; | |
| case BPF_INSN_AADD32: | |
| BPF_TRACE ("BPF_INSN_AADD32\n"); | |
| bpf_write_u32 (cpu, | |
| bpf_regs[insn->dst] + insn->offset16, | |
| (int32_t) bpf_read_u32 (cpu, bpf_regs[insn->dst] + insn->offset16) | |
| + bpf_regs[insn->src]); | |
| break; | |
| /* XXX Atomic instructions with fetching. */ | |
| default: /* XXX */ | |
| case BPF_NOINSN: | |
| BPF_TRACE ("BPF_NOINSN\n"); | |
| return 0; | |
| break; | |
| } | |
| /* Set new PC. */ | |
| bpf_pc = next_pc; | |
| return 1; | |
| } | |
| /* Entry points. */ | |
| SIM_RC | |
| sim_create_inferior (SIM_DESC sd, struct bfd *abfd, | |
| char * const *argv, char * const *env) | |
| { | |
| SIM_CPU *cpu = STATE_CPU (sd, 0); | |
| bfd_vma addr; | |
| /* Determine the start address. | |
| XXX acknowledge bpf_program_section. If it is NULL, emit a | |
| warning explaining that we are using the ELF file start address, | |
| which often is not what is actually wanted. */ | |
| if (abfd != NULL) | |
| addr = bfd_get_start_address (abfd); | |
| else | |
| addr = 0; | |
| sim_pc_set (cpu, addr); | |
| return SIM_RC_OK; | |
| } | |
| /* Like sim_state_free, but free the cpu buffers as well. */ | |
| static void | |
| bpf_free_state (SIM_DESC sd) | |
| { | |
| if (STATE_MODULES (sd) != NULL) | |
| sim_module_uninstall (sd); | |
| sim_cpu_free_all (sd); | |
| sim_state_free (sd); | |
| } | |
| /* Create an instance of the simulator. */ | |
| SIM_DESC | |
| sim_open (SIM_OPEN_KIND kind, host_callback *cb, | |
| struct bfd *abfd, char * const *argv) | |
| { | |
| SIM_DESC sd = sim_state_alloc_extra (kind, cb, sizeof (struct bpf_sim_state)); | |
| SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); | |
| /* Set default options before parsing user options. */ | |
| current_target_byte_order = BFD_ENDIAN_LITTLE; | |
| if (sim_cpu_alloc_all_extra (sd, 0, sizeof (struct bpf_sim_state)) != SIM_RC_OK) | |
| goto error; | |
| if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK) | |
| goto error; | |
| /* Add the BPF-specific option list to the simulator. */ | |
| if (sim_add_option_table (sd, NULL, bpf_options) != SIM_RC_OK) | |
| { | |
| bpf_free_state (sd); | |
| return 0; | |
| } | |
| /* The parser will print an error message for us, so we silently return. */ | |
| if (sim_parse_args (sd, argv) != SIM_RC_OK) | |
| goto error; | |
| /* Check for/establish the a reference program image. */ | |
| if (sim_analyze_program (sd, STATE_PROG_FILE (sd), abfd) != SIM_RC_OK) | |
| goto error; | |
| /* Configure/verify the target byte order and other runtime | |
| configuration options. */ | |
| if (sim_config (sd) != SIM_RC_OK) | |
| goto error; | |
| if (sim_post_argv_init (sd) != SIM_RC_OK) | |
| goto error; | |
| /* Initialize properties of the simulated CPU. */ | |
| assert (MAX_NR_PROCESSORS == 1); | |
| { | |
| SIM_CPU *cpu = STATE_CPU (sd, i); | |
| cpu = STATE_CPU (sd, 0); | |
| CPU_PC_FETCH (cpu) = bpf_pc_get; | |
| CPU_PC_STORE (cpu) = bpf_pc_set; | |
| CPU_REG_FETCH (cpu) = bpf_reg_get; | |
| CPU_REG_STORE (cpu) = bpf_reg_set; | |
| } | |
| return sd; | |
| error: | |
| bpf_free_state (sd); | |
| return NULL; | |
| } | |
| void | |
| sim_engine_run (SIM_DESC sd, | |
| int next_cpu_nr ATTRIBUTE_UNUSED, | |
| int nr_cpus ATTRIBUTE_UNUSED, | |
| int siggnal ATTRIBUTE_UNUSED) | |
| { | |
| SIM_CPU *cpu = STATE_CPU (sd, 0); | |
| struct bpf_insn insn; | |
| while (1) | |
| { | |
| if (!decode (cpu, bpf_pc, &insn)) | |
| { | |
| sim_io_eprintf (sd, "couldn't decode instruction at PC 0x%" PRIx64 "\n", | |
| bpf_pc); | |
| break; | |
| } | |
| if (!execute (cpu, &insn)) | |
| { | |
| sim_io_eprintf (sd, "couldn' execute instruction at PC 0x%" PRIx64 "\n", | |
| bpf_pc); | |
| break; | |
| } | |
| } | |
| } |