git.gag.com Git - fw/sdcc/blob - sim/ucsim/sim.src/uccl.h

   1 /*
   2  * Simulator of microcontrollers (sim.src/uccl.h)
   3  *
   4  * Copyright (C) 1999,99 Drotos Daniel, Talker Bt.
   5  *
   6  * To contact author send email to drdani@mazsola.iit.uni-miskolc.hu
   7  *
   8  */
   9
  10 /* This file is part of microcontroller simulator: ucsim.
  11
  12 UCSIM is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2 of the License, or
  15 (at your option) any later version.
  16
  17 UCSIM is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with UCSIM; see the file COPYING.  If not, write to the Free
  24 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25 02111-1307, USA. */
  26 /*@1@*/
  27
  28 #ifndef SIM_UCCL_HEADER
  29 #define SIM_UCCL_HEADER
  30
  31 // prj
  32 #include "stypes.h"
  33 #include "pobjcl.h"
  34
  35 // sim
  36 #include "hwcl.h"
  37 #include "memcl.h"
  38 #include "brkcl.h"
  39
  40
  41 /* Counter to count clock ticks */
  42
  43 #define TICK_RUN        0x01
  44 #define TICK_INISR      0x02
  45 #define TICK_IDLE       0x03
  46
  47 class cl_ticker: public cl_base
  48 {
  49 public:
  50   unsigned long ticks;
  51   int options; // see TICK_XXX above
  52   int dir;
  53   char *name;
  54
  55   cl_ticker(int adir, int in_isr, char *aname);
  56   virtual ~cl_ticker(void);
  57
  58   virtual int tick(int nr);
  59   virtual double get_rtime(double xtal);
  60   virtual void dump(int nr, double xtal, class cl_console *con);
  61 };
  62
  63
  64 /* Abstract microcontroller */
  65
  66 class cl_uc: public cl_base
  67 {
  68 public:
  69   int type;                     // CPU family
  70   int technology;               // CMOS, HMOS
  71   int state;                    // GO, IDLE, PD
  72   class cl_list *options;
  73
  74   t_addr PC, instPC;            // Program Counter
  75   bool inst_exec;               // Instruction is executed
  76   class cl_ticker *ticks;       // Nr of XTAL clocks
  77   class cl_ticker *isr_ticks;   // Time in ISRs
  78   class cl_ticker *idle_ticks;  // Time in idle mode
  79   class cl_list *counters;      // User definable timers (tickers)
  80   int inst_ticks;               // ticks of an instruction
  81   double xtal;                  // Clock speed
  82
  83   int brk_counter;              // Number of breakpoints
  84   class brk_coll *fbrk;         // Collection of FETCH break-points
  85   class brk_coll *ebrk;         // Collection of EVENT breakpoints
  86   class cl_sim *sim;
  87   class cl_list *mems;
  88   class cl_hws *hws;
  89
  90   class cl_irqs *it_sources;    // Sources of interrupts
  91   class cl_list *it_levels;     // Follow interrupt services
  92   class cl_list *st_ops;        // Track stack operations
  93
  94   class cl_list *errors;        // Errors of instruction execution
  95   class cl_list *events;        // Events happened during inst exec
  96
  97   t_addr sp_max;
  98   t_addr sp_avg;
  99
 100 public:
 101   cl_uc(class cl_sim *asim);
 102   virtual ~cl_uc(void);
 103   virtual int init(void);
 104   virtual char *id_string(void);
 105   virtual void reset(void);
 106
 107   // making objects
 108   virtual class cl_mem *mk_mem(enum mem_class type, char *class_name);
 109   virtual t_addr get_mem_size(enum mem_class type);
 110   virtual int get_mem_width(enum mem_class type);
 111   virtual void mk_hw_elements(void);
 112   virtual void build_cmdset(class cl_cmdset *cmdset);
 113
 114   // manipulating memories
 115   virtual t_mem read_mem(enum mem_class type, t_addr addr);
 116   virtual t_mem get_mem(enum mem_class type, t_addr addr);
 117   virtual void write_mem(enum mem_class type, t_addr addr, t_mem val);
 118   virtual void set_mem(enum mem_class type, t_addr addr, t_mem val);
 119   virtual class cl_mem *mem(enum mem_class type);
 120   virtual class cl_mem *mem(char *class_name);
 121
 122   // file handling
 123   virtual long read_hex_file(const char *name);
 124
 125   // instructions, code analyzer
 126   virtual void analyze(t_addr addr) {}
 127   virtual bool inst_at(t_addr addr);
 128   virtual void set_inst_at(t_addr addr);
 129   virtual void del_inst_at(t_addr addr);
 130   virtual bool there_is_inst(void);
 131
 132   // manipulating hw elements
 133   virtual class cl_hw *get_hw(enum hw_cath cath, int *idx);
 134   virtual class cl_hw *get_hw(char *id_string, int *idx);
 135   virtual class cl_hw *get_hw(enum hw_cath cath, int hwid, int *idx);
 136   virtual class cl_hw *get_hw(char *id_string, int hwid, int *idx);
 137
 138   // "virtual" timers
 139   virtual int tick_hw(int cycles);
 140   virtual void do_extra_hw(int cycles);
 141   virtual int tick(int cycles);
 142   virtual class cl_ticker *get_counter(int nr);
 143   virtual class cl_ticker *get_counter(char *name);
 144   virtual void add_counter(class cl_ticker *ticker, int nr);
 145   virtual void add_counter(class cl_ticker *ticker, char *name);
 146   virtual void del_counter(int nr);
 147   virtual void del_counter(char *name);
 148   virtual double get_rtime(void);
 149   virtual int clock_per_cycle(void);
 150
 151   // execution
 152   virtual t_mem fetch(void);
 153   virtual bool fetch(t_mem *code);
 154   virtual int do_inst(int step);
 155   virtual void pre_inst(void);
 156   virtual int exec_inst(void);
 157   virtual void post_inst(void);
 158
 159   virtual int it_priority(uchar ie_mask) {return(0);}
 160
 161   // stack tracking
 162   virtual void st_push(class cl_stack_op *op);
 163   virtual void st_call(class cl_stack_op *op);
 164   virtual int st_pop(class cl_stack_op *op);
 165   virtual int st_ret(class cl_stack_op *op);
 166
 167   // breakpoints
 168   virtual class cl_fetch_brk *fbrk_at(t_addr addr);
 169   virtual class cl_ev_brk *ebrk_at(t_addr addr, char *id);
 170   virtual class cl_brk *brk_by_nr(int nr);
 171   virtual class cl_brk *brk_by_nr(class brk_coll *bpcoll, int nr);
 172   virtual void rm_ebrk(t_addr addr, char *id);
 173   virtual bool rm_brk(int nr);
 174   virtual void put_breaks(void);
 175   virtual void remove_all_breaks(void);
 176   virtual int make_new_brknr(void);
 177   virtual class cl_ev_brk *mk_ebrk(enum brk_perm perm, class cl_mem *mem,
 178                                    char op, t_addr addr, int hit);
 179   virtual void check_events(void);
 180
 181   // disassembling and symbol recognition
 182   virtual char *disass(t_addr addr, char *sep);
 183   virtual struct dis_entry *dis_tbl(void);
 184   virtual struct name_entry *sfr_tbl(void);
 185   virtual struct name_entry *bit_tbl(void);
 186   virtual void print_disass(t_addr addr, class cl_console *con);
 187   virtual void print_regs(class cl_console *con);
 188   virtual int inst_length(t_addr addr);
 189   virtual int inst_branch(t_addr addr);
 190   virtual int longest_inst(void);
 191   virtual bool get_name(t_addr addr, struct name_entry tab[], char *buf);
 192   virtual char *symbolic_bit_name(t_addr bit_address,
 193                                   class cl_mem *mem,
 194                                   t_addr mem_addr,
 195                                   t_mem bit_mask);
 196
 197   /* Converting abstract address spaces into real ones */
 198   virtual class cl_mem *bit2mem(t_addr bitaddr,
 199                                 t_addr *memaddr, t_mem *bitmask);
 200
 201   // messages from app to handle and broadcast
 202   virtual void mem_cell_changed(class cl_mem *mem, t_addr addr);
 203
 204   // Error handling
 205   virtual void error(class cl_error *error);
 206   virtual void check_errors(void);
 207
 208   /* Following fields and virtual methods defined in uc51 I don't have
 209      energy to redesign them:-( */
 210 public:
 211   virtual void eram2xram(void) {} // Dirty hack for 51R
 212   virtual void xram2eram(void) {}
 213 };
 214
 215
 216 #endif
 217
 218 /* End of uccl.h */