212 lines
6.5 KiB
C++
212 lines
6.5 KiB
C++
/*
|
|
* Simulator of microcontrollers (sim.src/uccl.h)
|
|
*
|
|
* Copyright (C) 1999,99 Drotos Daniel, Talker Bt.
|
|
*
|
|
* To contact author send email to drdani@mazsola.iit.uni-miskolc.hu
|
|
*
|
|
*/
|
|
|
|
/* This file is part of microcontroller simulator: ucsim.
|
|
|
|
UCSIM 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 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
UCSIM 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 UCSIM; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
02111-1307, USA. */
|
|
/*@1@*/
|
|
|
|
#ifndef SIM_UCCL_HEADER
|
|
#define SIM_UCCL_HEADER
|
|
|
|
// prj
|
|
#include "stypes.h"
|
|
#include "pobjcl.h"
|
|
|
|
// sim
|
|
#include "hwcl.h"
|
|
#include "memcl.h"
|
|
#include "brkcl.h"
|
|
|
|
|
|
/* Counter to count clock ticks */
|
|
|
|
#define TICK_RUN 0x01
|
|
#define TICK_INISR 0x02
|
|
#define TICK_IDLE 0x03
|
|
|
|
class cl_ticker: public cl_base
|
|
{
|
|
public:
|
|
unsigned long ticks;
|
|
int options; // see TICK_XXX above
|
|
int dir;
|
|
char *name;
|
|
|
|
cl_ticker(int adir, int in_isr, char *aname);
|
|
~cl_ticker(void);
|
|
|
|
virtual int tick(int nr);
|
|
virtual double get_rtime(double xtal);
|
|
virtual void dump(int nr, double xtal, class cl_console *con);
|
|
};
|
|
|
|
|
|
/* Abstract microcontroller */
|
|
|
|
class cl_uc: public cl_base
|
|
{
|
|
public:
|
|
int type; // CPU family
|
|
int technology; // CMOS, HMOS
|
|
int state; // GO, IDLE, PD
|
|
class cl_list *options;
|
|
|
|
t_addr PC; // Program Counter
|
|
class cl_ticker *ticks; // Nr of XTAL clocks
|
|
class cl_ticker *isr_ticks; // Time in ISRs
|
|
class cl_ticker *idle_ticks; // Time in idle mode
|
|
class cl_list *counters; // User definable timers (tickers)
|
|
double xtal; // Clock speed
|
|
|
|
int brk_counter; // Number of breakpoints
|
|
class brk_coll *fbrk; // Collection of FETCH break-points
|
|
class brk_coll *ebrk; // Collection of EVENT breakpoints
|
|
class cl_sim *sim;
|
|
class cl_list *mems;
|
|
class cl_hws *hws;
|
|
|
|
class cl_list *it_sources; // Sources of interrupts
|
|
class cl_list *it_levels; // Follow interrupt services
|
|
class cl_list *st_ops; // Track stack operations
|
|
|
|
t_addr sp_max;
|
|
t_addr sp_avg;
|
|
|
|
public:
|
|
cl_uc(class cl_sim *asim);
|
|
~cl_uc(void);
|
|
virtual int init(void);
|
|
virtual char *id_string(void);
|
|
virtual void reset(void);
|
|
|
|
// making objects
|
|
virtual class cl_mem *mk_mem(enum mem_class type, char *class_name);
|
|
virtual t_addr get_mem_size(enum mem_class type);
|
|
virtual int get_mem_width(enum mem_class type);
|
|
virtual void mk_hw_elements(void);
|
|
virtual void build_cmdset(class cl_cmdset *cmdset);
|
|
|
|
// manipulating memories
|
|
virtual ulong read_mem(enum mem_class type, t_addr addr);
|
|
virtual ulong get_mem(enum mem_class type, t_addr addr);
|
|
virtual void write_mem(enum mem_class type, t_addr addr, t_mem val);
|
|
virtual void set_mem(enum mem_class type, t_addr addr, t_mem val);
|
|
virtual class cl_mem *mem(enum mem_class type);
|
|
virtual class cl_mem *mem(char *class_name);
|
|
//virtual TYPE_UBYTE *MEM(enum mem_class type);
|
|
|
|
// file handling
|
|
virtual long read_hex_file(const char *name);
|
|
|
|
// instructions, code analyzer
|
|
virtual void analyze(t_addr addr) {}
|
|
virtual bool inst_at(t_addr addr);
|
|
virtual void set_inst_at(t_addr addr);
|
|
virtual void del_inst_at(t_addr addr);
|
|
virtual bool there_is_inst(void);
|
|
|
|
// manipulating hw elements
|
|
virtual void register_hw_read(enum mem_class, t_addr addr, class cl_hw *hw);
|
|
virtual void register_hw_write(enum mem_class, t_addr addr, class cl_hw *hw);
|
|
virtual class cl_hw *get_hw(enum hw_cath cath, int *idx);
|
|
virtual class cl_hw *get_hw(char *id_string, int *idx);
|
|
virtual class cl_hw *get_hw(enum hw_cath cath, int hwid, int *idx);
|
|
virtual class cl_hw *get_hw(char *id_string, int hwid, int *idx);
|
|
|
|
// "virtual" timers
|
|
virtual int tick(int cycles);
|
|
virtual class cl_ticker *get_counter(int nr);
|
|
virtual class cl_ticker *get_counter(char *name);
|
|
virtual void add_counter(class cl_ticker *ticker, int nr);
|
|
virtual void add_counter(class cl_ticker *ticker, char *name);
|
|
virtual void del_counter(int nr);
|
|
virtual void del_counter(char *name);
|
|
virtual double get_rtime(void);
|
|
virtual int clock_per_cycle(void);
|
|
|
|
// execution
|
|
virtual t_mem fetch(void);
|
|
virtual bool fetch(t_mem *code);
|
|
virtual int do_inst(int step);
|
|
virtual void pre_inst(void);
|
|
virtual int exec_inst(void);
|
|
virtual void post_inst(void);
|
|
|
|
virtual int it_priority(uchar ie_mask) {return(0);}
|
|
|
|
// stack tracking
|
|
virtual void st_push(class cl_stack_op *op);
|
|
virtual void st_call(class cl_stack_op *op);
|
|
virtual int st_pop(class cl_stack_op *op);
|
|
virtual int st_ret(class cl_stack_op *op);
|
|
|
|
// breakpoints
|
|
virtual class cl_fetch_brk *fbrk_at(t_addr addr);
|
|
virtual class cl_ev_brk *ebrk_at(t_addr addr, char *id);
|
|
//virtual void rm_fbrk(long addr);
|
|
virtual class cl_brk *brk_by_nr(int nr);
|
|
virtual class cl_brk *brk_by_nr(class brk_coll *bpcoll, int nr);
|
|
virtual void rm_ebrk(t_addr addr, char *id);
|
|
virtual void rm_brk(int nr);
|
|
virtual void put_breaks(void);
|
|
virtual void remove_all_breaks(void);
|
|
virtual int make_new_brknr(void);
|
|
virtual class cl_ev_brk *mk_ebrk(enum brk_perm perm, class cl_mem *mem,
|
|
char op, t_addr addr, int hit);
|
|
|
|
// disassembling and symbol recognition
|
|
virtual char *disass(t_addr addr, char *sep);
|
|
virtual struct dis_entry *dis_tbl(void);
|
|
virtual struct name_entry *sfr_tbl(void);
|
|
virtual struct name_entry *bit_tbl(void);
|
|
virtual void print_disass(t_addr addr, class cl_console *con);
|
|
virtual void print_regs(class cl_console *con);
|
|
virtual int inst_length(t_mem code);
|
|
virtual int longest_inst(void);
|
|
virtual bool get_name(t_addr addr, struct name_entry tab[], char *buf);
|
|
virtual bool extract_bit_address(t_addr bit_address,
|
|
class cl_mem **mem,
|
|
t_addr *mem_addr,
|
|
t_mem *bit_mask) {return(DD_FALSE);}
|
|
virtual char *symbolic_bit_name(t_addr bit_address,
|
|
class cl_mem *mem,
|
|
t_addr mem_addr,
|
|
t_mem bit_mask);
|
|
|
|
/* Following fields and virtual methods defined in uc51 I don't have
|
|
energy to redesign them:-( */
|
|
public:
|
|
uchar port_pins[4]; // Port pins
|
|
public:
|
|
virtual void proc_write(uchar *addr) {}
|
|
virtual void set_p_flag(void) {}
|
|
virtual uchar *get_bit(uchar bitaddr) { return(0); }
|
|
virtual void eram2xram(void) {} // Dirty hack for 51R
|
|
virtual void xram2eram(void) {}
|
|
};
|
|
|
|
|
|
#endif
|
|
|
|
/* End of uccl.h */
|