| /* Simulator for Atmel's AVR core. |
| Copyright (C) 2009-2012 Free Software Foundation, Inc. |
| Written by Tristan Gingold, AdaCore. |
| |
| 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/>. */ |
| |
| #include "config.h" |
| |
| #ifdef HAVE_STRING_H |
| #include <string.h> |
| #endif |
| #include "bfd.h" |
| #include "gdb/callback.h" |
| #include "gdb/signals.h" |
| #include "libiberty.h" |
| #include "gdb/remote-sim.h" |
| #include "dis-asm.h" |
| #include "sim-utils.h" |
| |
| /* As AVR is a 8/16 bits processor, define handy types. */ |
| typedef unsigned short int word; |
| typedef signed short int sword; |
| typedef unsigned char byte; |
| typedef signed char sbyte; |
| |
| /* Debug flag to display instructions and registers. */ |
| static int tracing = 0; |
| static int lock_step = 0; |
| static int verbose; |
| |
| /* The only real register. */ |
| static unsigned int pc; |
| |
| /* We update a cycle counter. */ |
| static unsigned int cycles = 0; |
| |
| /* If true, the pc needs more than 2 bytes. */ |
| static int avr_pc22; |
| |
| static struct bfd *cur_bfd; |
| |
| static enum sim_stop cpu_exception; |
| static int cpu_signal; |
| |
| static SIM_OPEN_KIND sim_kind; |
| static char *myname; |
| static host_callback *callback; |
| |
| /* Max size of I space (which is always flash on avr). */ |
| #define MAX_AVR_FLASH (128 * 1024) |
| #define PC_MASK (MAX_AVR_FLASH - 1) |
| |
| /* Mac size of D space. */ |
| #define MAX_AVR_SRAM (64 * 1024) |
| #define SRAM_MASK (MAX_AVR_SRAM - 1) |
| |
| /* D space offset in ELF file. */ |
| #define SRAM_VADDR 0x800000 |
| |
| /* Simulator specific ports. */ |
| #define STDIO_PORT 0x52 |
| #define EXIT_PORT 0x4F |
| #define ABORT_PORT 0x49 |
| |
| /* GDB defined register numbers. */ |
| #define AVR_SREG_REGNUM 32 |
| #define AVR_SP_REGNUM 33 |
| #define AVR_PC_REGNUM 34 |
| |
| /* Memory mapped registers. */ |
| #define SREG 0x5F |
| #define REG_SP 0x5D |
| #define EIND 0x5C |
| #define RAMPZ 0x5B |
| |
| #define REGX 0x1a |
| #define REGY 0x1c |
| #define REGZ 0x1e |
| #define REGZ_LO 0x1e |
| #define REGZ_HI 0x1f |
| |
| /* Sreg (status) bits. */ |
| #define SREG_I 0x80 |
| #define SREG_T 0x40 |
| #define SREG_H 0x20 |
| #define SREG_S 0x10 |
| #define SREG_V 0x08 |
| #define SREG_N 0x04 |
| #define SREG_Z 0x02 |
| #define SREG_C 0x01 |
| |
| /* In order to speed up emulation we use a simple approach: |
| a code is associated with each instruction. The pre-decoding occurs |
| usually once when the instruction is first seen. |
| This works well because I&D spaces are separated. |
| |
| Missing opcodes: sleep, spm, wdr (as they are mmcu dependent). |
| */ |
| enum avr_opcode |
| { |
| /* Opcode not yet decoded. */ |
| OP_unknown, |
| OP_bad, |
| |
| OP_nop, |
| |
| OP_rjmp, |
| OP_rcall, |
| OP_ret, |
| OP_reti, |
| |
| OP_break, |
| |
| OP_brbs, |
| OP_brbc, |
| |
| OP_bset, |
| OP_bclr, |
| |
| OP_bld, |
| OP_bst, |
| |
| OP_sbrc, |
| OP_sbrs, |
| |
| OP_eor, |
| OP_and, |
| OP_andi, |
| OP_or, |
| OP_ori, |
| OP_com, |
| OP_swap, |
| OP_neg, |
| |
| OP_out, |
| OP_in, |
| OP_cbi, |
| OP_sbi, |
| |
| OP_sbic, |
| OP_sbis, |
| |
| OP_ldi, |
| OP_cpse, |
| OP_cp, |
| OP_cpi, |
| OP_cpc, |
| OP_sub, |
| OP_sbc, |
| OP_sbiw, |
| OP_adiw, |
| OP_add, |
| OP_adc, |
| OP_subi, |
| OP_sbci, |
| OP_inc, |
| OP_dec, |
| OP_lsr, |
| OP_ror, |
| OP_asr, |
| |
| OP_mul, |
| OP_muls, |
| OP_mulsu, |
| OP_fmul, |
| OP_fmuls, |
| OP_fmulsu, |
| |
| OP_mov, |
| OP_movw, |
| |
| OP_push, |
| OP_pop, |
| |
| OP_st_X, |
| OP_st_dec_X, |
| OP_st_X_inc, |
| OP_st_Y_inc, |
| OP_st_dec_Y, |
| OP_st_Z_inc, |
| OP_st_dec_Z, |
| OP_std_Y, |
| OP_std_Z, |
| OP_ldd_Y, |
| OP_ldd_Z, |
| OP_ld_Z_inc, |
| OP_ld_dec_Z, |
| OP_ld_Y_inc, |
| OP_ld_dec_Y, |
| OP_ld_X, |
| OP_ld_X_inc, |
| OP_ld_dec_X, |
| |
| OP_lpm, |
| OP_lpm_Z, |
| OP_lpm_inc_Z, |
| OP_elpm, |
| OP_elpm_Z, |
| OP_elpm_inc_Z, |
| |
| OP_ijmp, |
| OP_icall, |
| |
| OP_eijmp, |
| OP_eicall, |
| |
| /* 2 words opcodes. */ |
| #define OP_2words OP_jmp |
| OP_jmp, |
| OP_call, |
| OP_sts, |
| OP_lds |
| }; |
| |
| struct avr_insn_cell |
| { |
| /* The insn (16 bits). */ |
| word op; |
| |
| /* Pre-decoding code. */ |
| enum avr_opcode code : 8; |
| /* One byte of additional information. */ |
| byte r; |
| }; |
| |
| /* I&D memories. */ |
| static struct avr_insn_cell flash[MAX_AVR_FLASH]; |
| static byte sram[MAX_AVR_SRAM]; |
| |
| void |
| sim_size (int s) |
| { |
| } |
| |
| /* Sign extend a value. */ |
| static int sign_ext (word val, int nb_bits) |
| { |
| if (val & (1 << (nb_bits - 1))) |
| return val | (-1 << nb_bits); |
| return val; |
| } |
| |
| /* Insn field extractors. */ |
| |
| /* Extract xxxx_xxxRx_xxxx_RRRR. */ |
| static inline byte get_r (word op) |
| { |
| return (op & 0xf) | ((op >> 5) & 0x10); |
| } |
| |
| /* Extract xxxx_xxxxx_xxxx_RRRR. */ |
| static inline byte get_r16 (word op) |
| { |
| return 16 + (op & 0xf); |
| } |
| |
| /* Extract xxxx_xxxxx_xxxx_xRRR. */ |
| static inline byte get_r16_23 (word op) |
| { |
| return 16 + (op & 0x7); |
| } |
| |
| /* Extract xxxx_xxxD_DDDD_xxxx. */ |
| static inline byte get_d (word op) |
| { |
| return (op >> 4) & 0x1f; |
| } |
| |
| /* Extract xxxx_xxxx_DDDD_xxxx. */ |
| static inline byte get_d16 (word op) |
| { |
| return 16 + ((op >> 4) & 0x0f); |
| } |
| |
| /* Extract xxxx_xxxx_xDDD_xxxx. */ |
| static inline byte get_d16_23 (word op) |
| { |
| return 16 + ((op >> 4) & 0x07); |
| } |
| |
| /* Extract xxxx_xAAx_xxxx_AAAA. */ |
| static inline byte get_A (word op) |
| { |
| return (op & 0x0f) | ((op & 0x600) >> 5); |
| } |
| |
| /* Extract xxxx_xxxx_AAAA_Axxx. */ |
| static inline byte get_biA (word op) |
| { |
| return (op >> 3) & 0x1f; |
| } |
| |
| /* Extract xxxx_KKKK_xxxx_KKKK. */ |
| static inline byte get_K (word op) |
| { |
| return (op & 0xf) | ((op & 0xf00) >> 4); |
| } |
| |
| /* Extract xxxx_xxKK_KKKK_Kxxx. */ |
| static inline int get_k (word op) |
| { |
| return sign_ext ((op & 0x3f8) >> 3, 7); |
| } |
| |
| /* Extract xxxx_xxxx_xxDD_xxxx. */ |
| static inline byte get_d24 (word op) |
| { |
| return 24 + ((op >> 3) & 6); |
| } |
| |
| /* Extract xxxx_xxxx_KKxx_KKKK. */ |
| static inline byte get_k6 (word op) |
| { |
| return (op & 0xf) | ((op >> 2) & 0x30); |
| } |
| |
| /* Extract xxQx_QQxx_xxxx_xQQQ. */ |
| static inline byte get_q (word op) |
| { |
| return (op & 7) | ((op >> 7) & 0x18)| ((op >> 8) & 0x20); |
| } |
| |
| /* Extract xxxx_xxxx_xxxx_xBBB. */ |
| static inline byte get_b (word op) |
| { |
| return (op & 7); |
| } |
| |
| /* AVR is little endian. */ |
| static inline word |
| read_word (unsigned int addr) |
| { |
| return sram[addr] | (sram[addr + 1] << 8); |
| } |
| |
| static inline void |
| write_word (unsigned int addr, word w) |
| { |
| sram[addr] = w; |
| sram[addr + 1] = w >> 8; |
| } |
| |
| static inline word |
| read_word_post_inc (unsigned int addr) |
| { |
| word v = read_word (addr); |
| write_word (addr, v + 1); |
| return v; |
| } |
| |
| static inline word |
| read_word_pre_dec (unsigned int addr) |
| { |
| word v = read_word (addr) - 1; |
| write_word (addr, v); |
| return v; |
| } |
| |
| static void |
| update_flags_logic (byte res) |
| { |
| sram[SREG] &= ~(SREG_S | SREG_V | SREG_N | SREG_Z); |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| if (res & 0x80) |
| sram[SREG] |= SREG_N | SREG_S; |
| } |
| |
| static void |
| update_flags_add (byte r, byte a, byte b) |
| { |
| byte carry; |
| |
| sram[SREG] &= ~(SREG_H | SREG_S | SREG_V | SREG_N | SREG_Z | SREG_C); |
| if (r & 0x80) |
| sram[SREG] |= SREG_N; |
| carry = (a & b) | (a & ~r) | (b & ~r); |
| if (carry & 0x08) |
| sram[SREG] |= SREG_H; |
| if (carry & 0x80) |
| sram[SREG] |= SREG_C; |
| if (((a & b & ~r) | (~a & ~b & r)) & 0x80) |
| sram[SREG] |= SREG_V; |
| if (!(sram[SREG] & SREG_N) ^ !(sram[SREG] & SREG_V)) |
| sram[SREG] |= SREG_S; |
| if (r == 0) |
| sram[SREG] |= SREG_Z; |
| } |
| |
| static void update_flags_sub (byte r, byte a, byte b) |
| { |
| byte carry; |
| |
| sram[SREG] &= ~(SREG_H | SREG_S | SREG_V | SREG_N | SREG_Z | SREG_C); |
| if (r & 0x80) |
| sram[SREG] |= SREG_N; |
| carry = (~a & b) | (b & r) | (r & ~a); |
| if (carry & 0x08) |
| sram[SREG] |= SREG_H; |
| if (carry & 0x80) |
| sram[SREG] |= SREG_C; |
| if (((a & ~b & ~r) | (~a & b & r)) & 0x80) |
| sram[SREG] |= SREG_V; |
| if (!(sram[SREG] & SREG_N) ^ !(sram[SREG] & SREG_V)) |
| sram[SREG] |= SREG_S; |
| /* Note: Z is not set. */ |
| } |
| |
| static enum avr_opcode |
| decode (unsigned int pc) |
| { |
| word op1 = flash[pc].op; |
| |
| switch ((op1 >> 12) & 0x0f) |
| { |
| case 0x0: |
| switch ((op1 >> 10) & 0x3) |
| { |
| case 0x0: |
| switch ((op1 >> 8) & 0x3) |
| { |
| case 0x0: |
| if (op1 == 0) |
| return OP_nop; |
| break; |
| case 0x1: |
| return OP_movw; |
| case 0x2: |
| return OP_muls; |
| case 0x3: |
| if (op1 & 0x80) |
| { |
| if (op1 & 0x08) |
| return OP_fmulsu; |
| else |
| return OP_fmuls; |
| } |
| else |
| { |
| if (op1 & 0x08) |
| return OP_fmul; |
| else |
| return OP_mulsu; |
| } |
| } |
| break; |
| case 0x1: |
| return OP_cpc; |
| case 0x2: |
| flash[pc].r = SREG_C; |
| return OP_sbc; |
| case 0x3: |
| flash[pc].r = 0; |
| return OP_add; |
| } |
| break; |
| case 0x1: |
| switch ((op1 >> 10) & 0x3) |
| { |
| case 0x0: |
| return OP_cpse; |
| case 0x1: |
| return OP_cp; |
| case 0x2: |
| flash[pc].r = 0; |
| return OP_sub; |
| case 0x3: |
| flash[pc].r = SREG_C; |
| return OP_adc; |
| } |
| break; |
| case 0x2: |
| switch ((op1 >> 10) & 0x3) |
| { |
| case 0x0: |
| return OP_and; |
| case 0x1: |
| return OP_eor; |
| case 0x2: |
| return OP_or; |
| case 0x3: |
| return OP_mov; |
| } |
| break; |
| case 0x3: |
| return OP_cpi; |
| case 0x4: |
| return OP_sbci; |
| case 0x5: |
| return OP_subi; |
| case 0x6: |
| return OP_ori; |
| case 0x7: |
| return OP_andi; |
| case 0x8: |
| case 0xa: |
| if (op1 & 0x0200) |
| { |
| if (op1 & 0x0008) |
| { |
| flash[pc].r = get_q (op1); |
| return OP_std_Y; |
| } |
| else |
| { |
| flash[pc].r = get_q (op1); |
| return OP_std_Z; |
| } |
| } |
| else |
| { |
| if (op1 & 0x0008) |
| { |
| flash[pc].r = get_q (op1); |
| return OP_ldd_Y; |
| } |
| else |
| { |
| flash[pc].r = get_q (op1); |
| return OP_ldd_Z; |
| } |
| } |
| break; |
| case 0x9: /* 9xxx */ |
| switch ((op1 >> 8) & 0xf) |
| { |
| case 0x0: |
| case 0x1: |
| switch ((op1 >> 0) & 0xf) |
| { |
| case 0x0: |
| return OP_lds; |
| case 0x1: |
| return OP_ld_Z_inc; |
| case 0x2: |
| return OP_ld_dec_Z; |
| case 0x4: |
| return OP_lpm_Z; |
| case 0x5: |
| return OP_lpm_inc_Z; |
| case 0x6: |
| return OP_elpm_Z; |
| case 0x7: |
| return OP_elpm_inc_Z; |
| case 0x9: |
| return OP_ld_Y_inc; |
| case 0xa: |
| return OP_ld_dec_Y; |
| case 0xc: |
| return OP_ld_X; |
| case 0xd: |
| return OP_ld_X_inc; |
| case 0xe: |
| return OP_ld_dec_X; |
| case 0xf: |
| return OP_pop; |
| } |
| break; |
| case 0x2: |
| case 0x3: |
| switch ((op1 >> 0) & 0xf) |
| { |
| case 0x0: |
| return OP_sts; |
| case 0x1: |
| return OP_st_Z_inc; |
| case 0x2: |
| return OP_st_dec_Z; |
| case 0x9: |
| return OP_st_Y_inc; |
| case 0xa: |
| return OP_st_dec_Y; |
| case 0xc: |
| return OP_st_X; |
| case 0xd: |
| return OP_st_X_inc; |
| case 0xe: |
| return OP_st_dec_X; |
| case 0xf: |
| return OP_push; |
| } |
| break; |
| case 0x4: |
| case 0x5: |
| switch (op1 & 0xf) |
| { |
| case 0x0: |
| return OP_com; |
| case 0x1: |
| return OP_neg; |
| case 0x2: |
| return OP_swap; |
| case 0x3: |
| return OP_inc; |
| case 0x5: |
| flash[pc].r = 0x80; |
| return OP_asr; |
| case 0x6: |
| flash[pc].r = 0; |
| return OP_lsr; |
| case 0x7: |
| return OP_ror; |
| case 0x8: /* 9[45]x8 */ |
| switch ((op1 >> 4) & 0x1f) |
| { |
| case 0x00: |
| case 0x01: |
| case 0x02: |
| case 0x03: |
| case 0x04: |
| case 0x05: |
| case 0x06: |
| case 0x07: |
| return OP_bset; |
| case 0x08: |
| case 0x09: |
| case 0x0a: |
| case 0x0b: |
| case 0x0c: |
| case 0x0d: |
| case 0x0e: |
| case 0x0f: |
| return OP_bclr; |
| case 0x10: |
| return OP_ret; |
| case 0x11: |
| return OP_reti; |
| case 0x19: |
| return OP_break; |
| case 0x1c: |
| return OP_lpm; |
| case 0x1d: |
| return OP_elpm; |
| default: |
| break; |
| } |
| break; |
| case 0x9: /* 9[45]x9 */ |
| switch ((op1 >> 4) & 0x1f) |
| { |
| case 0x00: |
| return OP_ijmp; |
| case 0x01: |
| return OP_eijmp; |
| case 0x10: |
| return OP_icall; |
| case 0x11: |
| return OP_eicall; |
| default: |
| break; |
| } |
| break; |
| case 0xa: |
| return OP_dec; |
| case 0xc: |
| case 0xd: |
| flash[pc].r = ((op1 & 0x1f0) >> 3) | (op1 & 1); |
| return OP_jmp; |
| case 0xe: |
| case 0xf: |
| flash[pc].r = ((op1 & 0x1f0) >> 3) | (op1 & 1); |
| return OP_call; |
| } |
| break; |
| case 0x6: |
| return OP_adiw; |
| case 0x7: |
| return OP_sbiw; |
| case 0x8: |
| return OP_cbi; |
| case 0x9: |
| return OP_sbic; |
| case 0xa: |
| return OP_sbi; |
| case 0xb: |
| return OP_sbis; |
| case 0xc: |
| case 0xd: |
| case 0xe: |
| case 0xf: |
| return OP_mul; |
| } |
| break; |
| case 0xb: |
| flash[pc].r = get_A (op1); |
| if (((op1 >> 11) & 1) == 0) |
| return OP_in; |
| else |
| return OP_out; |
| case 0xc: |
| return OP_rjmp; |
| case 0xd: |
| return OP_rcall; |
| case 0xe: |
| return OP_ldi; |
| case 0xf: |
| switch ((op1 >> 9) & 7) |
| { |
| case 0: |
| case 1: |
| flash[pc].r = 1 << (op1 & 7); |
| return OP_brbs; |
| case 2: |
| case 3: |
| flash[pc].r = 1 << (op1 & 7); |
| return OP_brbc; |
| case 4: |
| if ((op1 & 8) == 0) |
| { |
| flash[pc].r = 1 << (op1 & 7); |
| return OP_bld; |
| } |
| break; |
| case 5: |
| if ((op1 & 8) == 0) |
| { |
| flash[pc].r = 1 << (op1 & 7); |
| return OP_bst; |
| } |
| break; |
| case 6: |
| if ((op1 & 8) == 0) |
| { |
| flash[pc].r = 1 << (op1 & 7); |
| return OP_sbrc; |
| } |
| break; |
| case 7: |
| if ((op1 & 8) == 0) |
| { |
| flash[pc].r = 1 << (op1 & 7); |
| return OP_sbrs; |
| } |
| break; |
| } |
| } |
| sim_cb_eprintf (callback, |
| "Unhandled instruction at pc=0x%x, op=%04x\n", pc * 2, op1); |
| return OP_bad; |
| } |
| |
| /* Disassemble an instruction. */ |
| |
| static int |
| disasm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int length, |
| struct disassemble_info *info) |
| { |
| int res; |
| |
| res = sim_read (NULL, memaddr, myaddr, length); |
| if (res != length) |
| return -1; |
| return 0; |
| } |
| |
| /* Memory error support for an opcodes disassembler. */ |
| |
| static void |
| disasm_perror_memory (int status, bfd_vma memaddr, |
| struct disassemble_info *info) |
| { |
| if (status != -1) |
| /* Can't happen. */ |
| info->fprintf_func (info->stream, "Unknown error %d.", status); |
| else |
| /* Actually, address between memaddr and memaddr + len was |
| out of bounds. */ |
| info->fprintf_func (info->stream, |
| "Address 0x%x is out of bounds.", |
| (int) memaddr); |
| } |
| |
| static void |
| disassemble_insn (SIM_DESC sd, SIM_ADDR pc) |
| { |
| struct disassemble_info disasm_info; |
| int len; |
| int i; |
| |
| INIT_DISASSEMBLE_INFO (disasm_info, callback, sim_cb_eprintf); |
| |
| disasm_info.arch = bfd_get_arch (cur_bfd); |
| disasm_info.mach = bfd_get_mach (cur_bfd); |
| disasm_info.endian = BFD_ENDIAN_LITTLE; |
| disasm_info.read_memory_func = disasm_read_memory; |
| disasm_info.memory_error_func = disasm_perror_memory; |
| |
| len = print_insn_avr (pc << 1, &disasm_info); |
| len = len / 2; |
| for (i = 0; i < len; i++) |
| sim_cb_eprintf (callback, " %04x", flash[pc + i].op); |
| } |
| |
| static void |
| do_call (unsigned int npc) |
| { |
| unsigned int sp = read_word (REG_SP); |
| |
| /* Big endian! */ |
| sram[sp--] = pc; |
| sram[sp--] = pc >> 8; |
| if (avr_pc22) |
| { |
| sram[sp--] = pc >> 16; |
| cycles++; |
| } |
| write_word (REG_SP, sp); |
| pc = npc & PC_MASK; |
| cycles += 3; |
| } |
| |
| static int |
| get_insn_length (unsigned int p) |
| { |
| if (flash[p].code == OP_unknown) |
| flash[p].code = decode(p); |
| if (flash[p].code >= OP_2words) |
| return 2; |
| else |
| return 1; |
| } |
| |
| static unsigned int |
| get_z (void) |
| { |
| return (sram[RAMPZ] << 16) | (sram[REGZ_HI] << 8) | sram[REGZ_LO]; |
| } |
| |
| static unsigned char |
| get_lpm (unsigned int addr) |
| { |
| word w; |
| |
| w = flash[(addr >> 1) & PC_MASK].op; |
| if (addr & 1) |
| w >>= 8; |
| return w; |
| } |
| |
| static void |
| gen_mul (unsigned int res) |
| { |
| write_word (0, res); |
| sram[SREG] &= ~(SREG_Z | SREG_C); |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| if (res & 0x8000) |
| sram[SREG] |= SREG_C; |
| cycles++; |
| } |
| |
| void |
| sim_resume (SIM_DESC sd, int step, int signal) |
| { |
| unsigned int ipc; |
| |
| if (step) |
| { |
| cpu_exception = sim_stopped; |
| cpu_signal = GDB_SIGNAL_TRAP; |
| } |
| else |
| cpu_exception = sim_running; |
| |
| do |
| { |
| int code; |
| word op; |
| byte res; |
| byte r, d, vd; |
| |
| again: |
| code = flash[pc].code; |
| op = flash[pc].op; |
| |
| |
| if ((tracing || lock_step) && code != OP_unknown) |
| { |
| if (verbose > 0) { |
| int flags; |
| int i; |
| |
| sim_cb_eprintf (callback, "R00-07:"); |
| for (i = 0; i < 8; i++) |
| sim_cb_eprintf (callback, " %02x", sram[i]); |
| sim_cb_eprintf (callback, " -"); |
| for (i = 8; i < 16; i++) |
| sim_cb_eprintf (callback, " %02x", sram[i]); |
| sim_cb_eprintf (callback, " SP: %02x %02x", |
| sram[REG_SP + 1], sram[REG_SP]); |
| sim_cb_eprintf (callback, "\n"); |
| sim_cb_eprintf (callback, "R16-31:"); |
| for (i = 16; i < 24; i++) |
| sim_cb_eprintf (callback, " %02x", sram[i]); |
| sim_cb_eprintf (callback, " -"); |
| for (i = 24; i < 32; i++) |
| sim_cb_eprintf (callback, " %02x", sram[i]); |
| sim_cb_eprintf (callback, " "); |
| flags = sram[SREG]; |
| for (i = 0; i < 8; i++) |
| sim_cb_eprintf (callback, "%c", |
| flags & (0x80 >> i) ? "ITHSVNZC"[i] : '-'); |
| sim_cb_eprintf (callback, "\n"); |
| } |
| |
| if (lock_step && !tracing) |
| sim_cb_eprintf (callback, "%06x: %04x\n", 2 * pc, flash[pc].op); |
| else |
| { |
| sim_cb_eprintf (callback, "pc=0x%06x insn=0x%04x code=%d r=%d\n", |
| 2 * pc, flash[pc].op, code, flash[pc].r); |
| disassemble_insn (sd, pc); |
| sim_cb_eprintf (callback, "\n"); |
| } |
| } |
| |
| ipc = pc; |
| pc = (pc + 1) & PC_MASK; |
| cycles++; |
| |
| switch (code) |
| { |
| case OP_unknown: |
| flash[ipc].code = decode(ipc); |
| pc = ipc; |
| cycles--; |
| goto again; |
| break; |
| |
| case OP_nop: |
| break; |
| |
| case OP_jmp: |
| /* 2 words instruction, but we don't care about the pc. */ |
| pc = ((flash[ipc].r << 16) | flash[ipc + 1].op) & PC_MASK; |
| cycles += 2; |
| break; |
| |
| case OP_eijmp: |
| pc = ((sram[EIND] << 16) | read_word (REGZ)) & PC_MASK; |
| cycles += 2; |
| break; |
| |
| case OP_ijmp: |
| pc = read_word (REGZ) & PC_MASK; |
| cycles += 1; |
| break; |
| |
| case OP_call: |
| /* 2 words instruction. */ |
| pc++; |
| do_call ((flash[ipc].r << 16) | flash[ipc + 1].op); |
| break; |
| |
| case OP_eicall: |
| do_call ((sram[EIND] << 16) | read_word (REGZ)); |
| break; |
| |
| case OP_icall: |
| do_call (read_word (REGZ)); |
| break; |
| |
| case OP_rcall: |
| do_call (pc + sign_ext (op & 0xfff, 12)); |
| break; |
| |
| case OP_reti: |
| sram[SREG] |= SREG_I; |
| /* Fall through */ |
| case OP_ret: |
| { |
| unsigned int sp = read_word (REG_SP); |
| if (avr_pc22) |
| { |
| pc = sram[++sp] << 16; |
| cycles++; |
| } |
| else |
| pc = 0; |
| pc |= sram[++sp] << 8; |
| pc |= sram[++sp]; |
| write_word (REG_SP, sp); |
| } |
| cycles += 3; |
| break; |
| |
| case OP_break: |
| /* Stop on this address. */ |
| cpu_exception = sim_stopped; |
| cpu_signal = GDB_SIGNAL_TRAP; |
| pc = ipc; |
| break; |
| |
| case OP_bld: |
| d = get_d (op); |
| r = flash[ipc].r; |
| if (sram[SREG] & SREG_T) |
| sram[d] |= r; |
| else |
| sram[d] &= ~r; |
| break; |
| |
| case OP_bst: |
| if (sram[get_d (op)] & flash[ipc].r) |
| sram[SREG] |= SREG_T; |
| else |
| sram[SREG] &= ~SREG_T; |
| break; |
| |
| case OP_sbrc: |
| case OP_sbrs: |
| if (((sram[get_d (op)] & flash[ipc].r) == 0) ^ ((op & 0x0200) != 0)) |
| { |
| int l = get_insn_length(pc); |
| pc += l; |
| cycles += l; |
| } |
| break; |
| |
| case OP_push: |
| { |
| unsigned int sp = read_word (REG_SP); |
| sram[sp--] = sram[get_d (op)]; |
| write_word (REG_SP, sp); |
| } |
| cycles++; |
| break; |
| |
| case OP_pop: |
| { |
| unsigned int sp = read_word (REG_SP); |
| sram[get_d (op)] = sram[++sp]; |
| write_word (REG_SP, sp); |
| } |
| cycles++; |
| break; |
| |
| case OP_bclr: |
| sram[SREG] &= ~(1 << ((op >> 4) & 0x7)); |
| break; |
| |
| case OP_bset: |
| sram[SREG] |= 1 << ((op >> 4) & 0x7); |
| break; |
| |
| case OP_rjmp: |
| pc = (pc + sign_ext (op & 0xfff, 12)) & PC_MASK; |
| cycles++; |
| break; |
| |
| case OP_eor: |
| d = get_d (op); |
| res = sram[d] ^ sram[get_r (op)]; |
| sram[d] = res; |
| update_flags_logic (res); |
| break; |
| |
| case OP_and: |
| d = get_d (op); |
| res = sram[d] & sram[get_r (op)]; |
| sram[d] = res; |
| update_flags_logic (res); |
| break; |
| |
| case OP_andi: |
| d = get_d16 (op); |
| res = sram[d] & get_K (op); |
| sram[d] = res; |
| update_flags_logic (res); |
| break; |
| |
| case OP_or: |
| d = get_d (op); |
| res = sram[d] | sram[get_r (op)]; |
| sram[d] = res; |
| update_flags_logic (res); |
| break; |
| |
| case OP_ori: |
| d = get_d16 (op); |
| res = sram[d] | get_K (op); |
| sram[d] = res; |
| update_flags_logic (res); |
| break; |
| |
| case OP_com: |
| d = get_d (op); |
| res = ~sram[d]; |
| sram[d] = res; |
| update_flags_logic (res); |
| sram[SREG] |= SREG_C; |
| break; |
| |
| case OP_swap: |
| d = get_d (op); |
| vd = sram[d]; |
| sram[d] = (vd >> 4) | (vd << 4); |
| break; |
| |
| case OP_neg: |
| d = get_d (op); |
| vd = sram[d]; |
| res = -vd; |
| sram[d] = res; |
| sram[SREG] &= ~(SREG_H | SREG_S | SREG_V | SREG_N | SREG_Z | SREG_C); |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| else |
| sram[SREG] |= SREG_C; |
| if (res == 0x80) |
| sram[SREG] |= SREG_V | SREG_N; |
| else if (res & 0x80) |
| sram[SREG] |= SREG_N | SREG_S; |
| if ((res | vd) & 0x08) |
| sram[SREG] |= SREG_H; |
| break; |
| |
| case OP_inc: |
| d = get_d (op); |
| res = sram[d] + 1; |
| sram[d] = res; |
| sram[SREG] &= ~(SREG_S | SREG_V | SREG_N | SREG_Z); |
| if (res == 0x80) |
| sram[SREG] |= SREG_V | SREG_N; |
| else if (res & 0x80) |
| sram[SREG] |= SREG_N | SREG_S; |
| else if (res == 0) |
| sram[SREG] |= SREG_Z; |
| break; |
| |
| case OP_dec: |
| d = get_d (op); |
| res = sram[d] - 1; |
| sram[d] = res; |
| sram[SREG] &= ~(SREG_S | SREG_V | SREG_N | SREG_Z); |
| if (res == 0x7f) |
| sram[SREG] |= SREG_V | SREG_S; |
| else if (res & 0x80) |
| sram[SREG] |= SREG_N | SREG_S; |
| else if (res == 0) |
| sram[SREG] |= SREG_Z; |
| break; |
| |
| case OP_lsr: |
| case OP_asr: |
| d = get_d (op); |
| vd = sram[d]; |
| res = (vd >> 1) | (vd & flash[ipc].r); |
| sram[d] = res; |
| sram[SREG] &= ~(SREG_S | SREG_V | SREG_N | SREG_Z | SREG_C); |
| if (vd & 1) |
| sram[SREG] |= SREG_C | SREG_S; |
| if (res & 0x80) |
| sram[SREG] |= SREG_N; |
| if (!(sram[SREG] & SREG_N) ^ !(sram[SREG] & SREG_C)) |
| sram[SREG] |= SREG_V; |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| break; |
| |
| case OP_ror: |
| d = get_d (op); |
| vd = sram[d]; |
| res = vd >> 1 | (sram[SREG] << 7); |
| sram[d] = res; |
| sram[SREG] &= ~(SREG_S | SREG_V | SREG_N | SREG_Z | SREG_C); |
| if (vd & 1) |
| sram[SREG] |= SREG_C | SREG_S; |
| if (res & 0x80) |
| sram[SREG] |= SREG_N; |
| if (!(sram[SREG] & SREG_N) ^ !(sram[SREG] & SREG_C)) |
| sram[SREG] |= SREG_V; |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| break; |
| |
| case OP_mul: |
| gen_mul ((word)sram[get_r (op)] * (word)sram[get_d (op)]); |
| break; |
| |
| case OP_muls: |
| gen_mul((sword)(sbyte)sram[get_r16 (op)] |
| * (sword)(sbyte)sram[get_d16 (op)]); |
| break; |
| |
| case OP_mulsu: |
| gen_mul ((sword)(word)sram[get_r16_23 (op)] |
| * (sword)(sbyte)sram[get_d16_23 (op)]); |
| break; |
| |
| case OP_fmul: |
| gen_mul(((word)sram[get_r16_23 (op)] |
| * (word)sram[get_d16_23 (op)]) << 1); |
| break; |
| |
| case OP_fmuls: |
| gen_mul(((sword)(sbyte)sram[get_r16_23 (op)] |
| * (sword)(sbyte)sram[get_d16_23 (op)]) << 1); |
| break; |
| |
| case OP_fmulsu: |
| gen_mul(((sword)(word)sram[get_r16_23 (op)] |
| * (sword)(sbyte)sram[get_d16_23 (op)]) << 1); |
| break; |
| |
| case OP_adc: |
| case OP_add: |
| r = sram[get_r (op)]; |
| d = get_d (op); |
| vd = sram[d]; |
| res = r + vd + (sram[SREG] & flash[ipc].r); |
| sram[d] = res; |
| update_flags_add (res, vd, r); |
| break; |
| |
| case OP_sub: |
| d = get_d (op); |
| vd = sram[d]; |
| r = sram[get_r (op)]; |
| res = vd - r; |
| sram[d] = res; |
| update_flags_sub (res, vd, r); |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| break; |
| |
| case OP_sbc: |
| { |
| byte old = sram[SREG]; |
| d = get_d (op); |
| vd = sram[d]; |
| r = sram[get_r (op)]; |
| res = vd - r - (old & SREG_C); |
| sram[d] = res; |
| update_flags_sub (res, vd, r); |
| if (res == 0 && (old & SREG_Z)) |
| sram[SREG] |= SREG_Z; |
| } |
| break; |
| |
| case OP_subi: |
| d = get_d16 (op); |
| vd = sram[d]; |
| r = get_K (op); |
| res = vd - r; |
| sram[d] = res; |
| update_flags_sub (res, vd, r); |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| break; |
| |
| case OP_sbci: |
| { |
| byte old = sram[SREG]; |
| |
| d = get_d16 (op); |
| vd = sram[d]; |
| r = get_K (op); |
| res = vd - r - (old & SREG_C); |
| sram[d] = res; |
| update_flags_sub (res, vd, r); |
| if (res == 0 && (old & SREG_Z)) |
| sram[SREG] |= SREG_Z; |
| } |
| break; |
| |
| case OP_mov: |
| sram[get_d (op)] = sram[get_r (op)]; |
| break; |
| |
| case OP_movw: |
| d = (op & 0xf0) >> 3; |
| r = (op & 0x0f) << 1; |
| sram[d] = sram[r]; |
| sram[d + 1] = sram[r + 1]; |
| break; |
| |
| case OP_out: |
| d = get_A (op) + 0x20; |
| res = sram[get_d (op)]; |
| sram[d] = res; |
| if (d == STDIO_PORT) |
| putchar (res); |
| else if (d == EXIT_PORT) |
| { |
| cpu_exception = sim_exited; |
| cpu_signal = 0; |
| return; |
| } |
| else if (d == ABORT_PORT) |
| { |
| cpu_exception = sim_exited; |
| cpu_signal = 1; |
| return; |
| } |
| break; |
| |
| case OP_in: |
| d = get_A (op) + 0x20; |
| sram[get_d (op)] = sram[d]; |
| break; |
| |
| case OP_cbi: |
| d = get_biA (op) + 0x20; |
| sram[d] &= ~(1 << get_b(op)); |
| break; |
| |
| case OP_sbi: |
| d = get_biA (op) + 0x20; |
| sram[d] |= 1 << get_b(op); |
| break; |
| |
| case OP_sbic: |
| if (!(sram[get_biA (op) + 0x20] & 1 << get_b(op))) |
| { |
| int l = get_insn_length(pc); |
| pc += l; |
| cycles += l; |
| } |
| break; |
| |
| case OP_sbis: |
| if (sram[get_biA (op) + 0x20] & 1 << get_b(op)) |
| { |
| int l = get_insn_length(pc); |
| pc += l; |
| cycles += l; |
| } |
| break; |
| |
| case OP_ldi: |
| res = get_K (op); |
| d = get_d16 (op); |
| sram[d] = res; |
| break; |
| |
| case OP_lds: |
| sram[get_d (op)] = sram[flash[pc].op]; |
| pc++; |
| cycles++; |
| break; |
| |
| case OP_sts: |
| sram[flash[pc].op] = sram[get_d (op)]; |
| pc++; |
| cycles++; |
| break; |
| |
| case OP_cpse: |
| if (sram[get_r (op)] == sram[get_d (op)]) |
| { |
| int l = get_insn_length(pc); |
| pc += l; |
| cycles += l; |
| } |
| break; |
| |
| case OP_cp: |
| r = sram[get_r (op)]; |
| d = sram[get_d (op)]; |
| res = d - r; |
| update_flags_sub (res, d, r); |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| break; |
| |
| case OP_cpi: |
| r = get_K (op); |
| d = sram[get_d16 (op)]; |
| res = d - r; |
| update_flags_sub (res, d, r); |
| if (res == 0) |
| sram[SREG] |= SREG_Z; |
| break; |
| |
| case OP_cpc: |
| { |
| byte old = sram[SREG]; |
| d = sram[get_d (op)]; |
| r = sram[get_r (op)]; |
| res = d - r - (old & SREG_C); |
| update_flags_sub (res, d, r); |
| if (res == 0 && (old & SREG_Z)) |
| sram[SREG] |= SREG_Z; |
| } |
| break; |
| |
| case OP_brbc: |
| if (!(sram[SREG] & flash[ipc].r)) |
| { |
| pc = (pc + get_k (op)) & PC_MASK; |
| cycles++; |
| } |
| break; |
| |
| case OP_brbs: |
| if (sram[SREG] & flash[ipc].r) |
| { |
| pc = (pc + get_k (op)) & PC_MASK; |
| cycles++; |
| } |
| break; |
| |
| case OP_lpm: |
| sram[0] = get_lpm (read_word (REGZ)); |
| cycles += 2; |
| break; |
| |
| case OP_lpm_Z: |
| sram[get_d (op)] = get_lpm (read_word (REGZ)); |
| cycles += 2; |
| break; |
| |
| case OP_lpm_inc_Z: |
| sram[get_d (op)] = get_lpm (read_word_post_inc (REGZ)); |
| cycles += 2; |
| break; |
| |
| case OP_elpm: |
| sram[0] = get_lpm (get_z ()); |
| cycles += 2; |
| break; |
| |
| case OP_elpm_Z: |
| sram[get_d (op)] = get_lpm (get_z ()); |
| cycles += 2; |
| break; |
| |
| case OP_elpm_inc_Z: |
| { |
| unsigned int z = get_z (); |
| |
| sram[get_d (op)] = get_lpm (z); |
| z++; |
| sram[REGZ_LO] = z; |
| sram[REGZ_HI] = z >> 8; |
| sram[RAMPZ] = z >> 16; |
| } |
| cycles += 2; |
| break; |
| |
| case OP_ld_Z_inc: |
| sram[get_d (op)] = sram[read_word_post_inc (REGZ) & SRAM_MASK]; |
| cycles++; |
| break; |
| |
| case OP_ld_dec_Z: |
| sram[get_d (op)] = sram[read_word_pre_dec (REGZ) & SRAM_MASK]; |
| cycles++; |
| break; |
| |
| case OP_ld_X_inc: |
| sram[get_d (op)] = sram[read_word_post_inc (REGX) & SRAM_MASK]; |
| cycles++; |
| break; |
| |
| case OP_ld_dec_X: |
| sram[get_d (op)] = sram[read_word_pre_dec (REGX) & SRAM_MASK]; |
| cycles++; |
| break; |
| |
| case OP_ld_Y_inc: |
| sram[get_d (op)] = sram[read_word_post_inc (REGY) & SRAM_MASK]; |
| cycles++; |
| break; |
| |
| case OP_ld_dec_Y: |
| sram[get_d (op)] = sram[read_word_pre_dec (REGY) & SRAM_MASK]; |
| cycles++; |
| break; |
| |
| case OP_st_X: |
| sram[read_word (REGX) & SRAM_MASK] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_st_X_inc: |
| sram[read_word_post_inc (REGX) & SRAM_MASK] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_st_dec_X: |
| sram[read_word_pre_dec (REGX) & SRAM_MASK] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_st_Z_inc: |
| sram[read_word_post_inc (REGZ) & SRAM_MASK] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_st_dec_Z: |
| sram[read_word_pre_dec (REGZ) & SRAM_MASK] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_st_Y_inc: |
| sram[read_word_post_inc (REGY) & SRAM_MASK] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_st_dec_Y: |
| sram[read_word_pre_dec (REGY) & SRAM_MASK] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_std_Y: |
| sram[read_word (REGY) + flash[ipc].r] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_std_Z: |
| sram[read_word (REGZ) + flash[ipc].r] = sram[get_d (op)]; |
| cycles++; |
| break; |
| |
| case OP_ldd_Z: |
| sram[get_d (op)] = sram[read_word (REGZ) + flash[ipc].r]; |
| cycles++; |
| break; |
| |
| case OP_ldd_Y: |
| sram[get_d (op)] = sram[read_word (REGY) + flash[ipc].r]; |
| cycles++; |
| break; |
| |
| case OP_ld_X: |
| sram[get_d (op)] = sram[read_word (REGX) & SRAM_MASK]; |
| cycles++; |
| break; |
| |
| case OP_sbiw: |
| { |
| word wk = get_k6 (op); |
| word wres; |
| word wr; |
| |
| d = get_d24 (op); |
| wr = read_word (d); |
| wres = wr - wk; |
| |
| sram[SREG] &= ~(SREG_S | SREG_V | SREG_N | SREG_Z | SREG_C); |
| if (wres == 0) |
| sram[SREG] |= SREG_Z; |
| if (wres & 0x8000) |
| sram[SREG] |= SREG_N; |
| if (wres & ~wr & 0x8000) |
| sram[SREG] |= SREG_C; |
| if (~wres & wr & 0x8000) |
| sram[SREG] |= SREG_V; |
| if (((~wres & wr) ^ wres) & 0x8000) |
| sram[SREG] |= SREG_S; |
| write_word (d, wres); |
| } |
| cycles++; |
| break; |
| |
| case OP_adiw: |
| { |
| word wk = get_k6 (op); |
| word wres; |
| word wr; |
| |
| d = get_d24 (op); |
| wr = read_word (d); |
| wres = wr + wk; |
| |
| sram[SREG] &= ~(SREG_S | SREG_V | SREG_N | SREG_Z | SREG_C); |
| if (wres == 0) |
| sram[SREG] |= SREG_Z; |
| if (wres & 0x8000) |
| sram[SREG] |= SREG_N; |
| if (~wres & wr & 0x8000) |
| sram[SREG] |= SREG_C; |
| if (wres & ~wr & 0x8000) |
| sram[SREG] |= SREG_V; |
| if (((wres & ~wr) ^ wres) & 0x8000) |
| sram[SREG] |= SREG_S; |
| write_word (d, wres); |
| } |
| cycles++; |
| break; |
| |
| case OP_bad: |
| sim_cb_eprintf (callback, "Bad instruction at pc=0x%x\n", ipc * 2); |
| return; |
| |
| default: |
| sim_cb_eprintf (callback, |
| "Unhandled instruction at pc=0x%x, code=%d\n", |
| 2 * ipc, code); |
| return; |
| } |
| } |
| while (cpu_exception == sim_running); |
| } |
| |
| |
| int |
| sim_trace (SIM_DESC sd) |
| { |
| tracing = 1; |
| |
| sim_resume (sd, 0, 0); |
| |
| tracing = 0; |
| |
| return 1; |
| } |
| |
| int |
| sim_write (SIM_DESC sd, SIM_ADDR addr, const unsigned char *buffer, int size) |
| { |
| int osize = size; |
| |
| if (addr >= 0 && addr < SRAM_VADDR) |
| { |
| while (size > 0 && addr < (MAX_AVR_FLASH << 1)) |
| { |
| word val = flash[addr >> 1].op; |
| |
| if (addr & 1) |
| val = (val & 0xff) | (buffer[0] << 8); |
| else |
| val = (val & 0xff00) | buffer[0]; |
| |
| flash[addr >> 1].op = val; |
| flash[addr >> 1].code = OP_unknown; |
| addr++; |
| buffer++; |
| size--; |
| } |
| return osize - size; |
| } |
| else if (addr >= SRAM_VADDR && addr < SRAM_VADDR + MAX_AVR_SRAM) |
| { |
| addr -= SRAM_VADDR; |
| if (addr + size > MAX_AVR_SRAM) |
| size = MAX_AVR_SRAM - addr; |
| memcpy (sram + addr, buffer, size); |
| return size; |
| } |
| else |
| return 0; |
| } |
| |
| int |
| sim_read (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size) |
| { |
| int osize = size; |
| |
| if (addr >= 0 && addr < SRAM_VADDR) |
| { |
| while (size > 0 && addr < (MAX_AVR_FLASH << 1)) |
| { |
| word val = flash[addr >> 1].op; |
| |
| if (addr & 1) |
| val >>= 8; |
| |
| *buffer++ = val; |
| addr++; |
| size--; |
| } |
| return osize - size; |
| } |
| else if (addr >= SRAM_VADDR && addr < SRAM_VADDR + MAX_AVR_SRAM) |
| { |
| addr -= SRAM_VADDR; |
| if (addr + size > MAX_AVR_SRAM) |
| size = MAX_AVR_SRAM - addr; |
| memcpy (buffer, sram + addr, size); |
| return size; |
| } |
| else |
| { |
| /* Avoid errors. */ |
| memset (buffer, 0, size); |
| return size; |
| } |
| } |
| |
| int |
| sim_store_register (SIM_DESC sd, int rn, unsigned char *memory, int length) |
| { |
| if (rn < 32 && length == 1) |
| { |
| sram[rn] = *memory; |
| return 1; |
| } |
| if (rn == AVR_SREG_REGNUM && length == 1) |
| { |
| sram[SREG] = *memory; |
| return 1; |
| } |
| if (rn == AVR_SP_REGNUM && length == 2) |
| { |
| sram[REG_SP] = memory[0]; |
| sram[REG_SP + 1] = memory[1]; |
| return 2; |
| } |
| if (rn == AVR_PC_REGNUM && length == 4) |
| { |
| pc = (memory[0] >> 1) | (memory[1] << 7) |
| | (memory[2] << 15) | (memory[3] << 23); |
| pc &= PC_MASK; |
| return 4; |
| } |
| return 0; |
| } |
| |
| int |
| sim_fetch_register (SIM_DESC sd, int rn, unsigned char *memory, int length) |
| { |
| if (rn < 32 && length == 1) |
| { |
| *memory = sram[rn]; |
| return 1; |
| } |
| if (rn == AVR_SREG_REGNUM && length == 1) |
| { |
| *memory = sram[SREG]; |
| return 1; |
| } |
| if (rn == AVR_SP_REGNUM && length == 2) |
| { |
| memory[0] = sram[REG_SP]; |
| memory[1] = sram[REG_SP + 1]; |
| return 2; |
| } |
| if (rn == AVR_PC_REGNUM && length == 4) |
| { |
| memory[0] = pc << 1; |
| memory[1] = pc >> 7; |
| memory[2] = pc >> 15; |
| memory[3] = pc >> 23; |
| return 4; |
| } |
| return 0; |
| } |
| |
| void |
| sim_stop_reason (SIM_DESC sd, enum sim_stop * reason, int *sigrc) |
| { |
| *reason = cpu_exception; |
| *sigrc = cpu_signal; |
| } |
| |
| int |
| sim_stop (SIM_DESC sd) |
| { |
| cpu_exception = sim_stopped; |
| cpu_signal = GDB_SIGNAL_INT; |
| return 1; |
| } |
| |
| void |
| sim_info (SIM_DESC sd, int verbose) |
| { |
| callback->printf_filtered |
| (callback, "\n\n# cycles %10u\n", cycles); |
| } |
| |
| SIM_DESC |
| sim_open (SIM_OPEN_KIND kind, host_callback *cb, struct bfd *abfd, char **argv) |
| { |
| myname = argv[0]; |
| callback = cb; |
| |
| cur_bfd = abfd; |
| |
| /* Fudge our descriptor for now. */ |
| return (SIM_DESC) 1; |
| } |
| |
| void |
| sim_close (SIM_DESC sd, int quitting) |
| { |
| /* nothing to do */ |
| } |
| |
| SIM_RC |
| sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty) |
| { |
| bfd *prog_bfd; |
| |
| /* Clear all the memory. */ |
| memset (sram, 0, sizeof (sram)); |
| memset (flash, 0, sizeof (flash)); |
| |
| prog_bfd = sim_load_file (sd, myname, callback, prog, abfd, |
| sim_kind == SIM_OPEN_DEBUG, |
| 0, sim_write); |
| if (prog_bfd == NULL) |
| return SIM_RC_FAIL; |
| |
| avr_pc22 = (bfd_get_mach (prog_bfd) >= bfd_mach_avr6); |
| |
| if (abfd != NULL) |
| cur_bfd = abfd; |
| |
| return SIM_RC_OK; |
| } |
| |
| SIM_RC |
| sim_create_inferior (SIM_DESC sd, struct bfd *prog_bfd, char **argv, char **env) |
| { |
| /* Set the initial register set. */ |
| pc = 0; |
| |
| return SIM_RC_OK; |
| } |
| |
| void |
| sim_kill (SIM_DESC sd) |
| { |
| /* nothing to do */ |
| } |
| |
| void |
| sim_do_command (SIM_DESC sd, char *cmd) |
| { |
| /* Nothing there yet; it's all an error. */ |
| |
| if (cmd == NULL) |
| return; |
| |
| if (strcmp (cmd, "verbose") == 0) |
| verbose = 2; |
| else if (strcmp (cmd, "trace") == 0) |
| tracing = 1; |
| else |
| sim_cb_eprintf (callback, |
| "Error: \"%s\" is not a valid avr simulator command.\n", |
| cmd); |
| } |
| |
| void |
| sim_set_callbacks (host_callback *ptr) |
| { |
| callback = ptr; |
| } |
| |
| char ** |
| sim_complete_command (SIM_DESC sd, char *text, char *word) |
| { |
| return NULL; |
| } |
