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

   1 /*
   2  * Simulator of microcontrollers (sim.src/memcl.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_MEMCL_HEADER
  29 #define SIM_MEMCL_HEADER
  30
  31
  32 // prj
  33 #include "stypes.h"
  34 #include "pobjcl.h"
  35
  36 // gui.src
  37 #include "guiobjcl.h"
  38
  39
  40 class cl_mem;
  41 class cl_event_handler;
  42
  43
  44 // Cell types
  45 #define CELL_NORMAL     0x00    /* Nothing special */
  46 #define CELL_HW_READ    0x01    /* Hw handles read */
  47 #define CELL_HW_WRITE   0x02    /* Hw catches write */
  48 #define CELL_INST       0x04    /* Marked as instruction */
  49 #define CELL_FETCH_BRK  0x08    /* Fetch breakpoint */
  50 #define CELL_READ_BRK   0x10    /* Read event breakpoint */
  51 #define CELL_WRITE_BRK  0x20    /* Write event breakpoint */
  52
  53 #define CELL_GENERAL    (CELL_NORMAL|CELL_INST|CELL_FETCH_BRK)
  54
  55
  56 class cl_cell: public cl_base
  57 {
  58 public:
  59   cl_cell(void): cl_base() {}
  60 public:
  61   virtual TYPE_UBYTE get_type(void)= 0;
  62   virtual void set_type(TYPE_UBYTE what)= 0;
  63   virtual t_mem get_mask(void)= 0;
  64
  65   virtual t_mem read(void)=0 ;
  66   virtual t_mem read(enum hw_cath /*skip*/)=0;
  67   virtual t_mem get(void)=0;
  68   virtual t_mem write(t_mem val)=0;
  69   virtual t_mem set(t_mem val)=0;
  70   virtual t_mem add(long what)=0;
  71   virtual t_mem wadd(long what)=0;
  72
  73   virtual void set_bit1(t_mem bits)=0;
  74   virtual void set_bit0(t_mem bits)=0;
  75
  76   virtual class cl_cell *add_hw(class cl_hw */*hw*/, int */*ith*/)=0;
  77   virtual class cl_hw *get_hw(int ith)=0;
  78   virtual class cl_event_handler *get_event_handler(void)=0;
  79 };
  80
  81 class cl_normal_cell: public cl_cell
  82 {
  83 public:
  84   t_mem data;
  85   TYPE_UBYTE type;      // See CELL_XXXX
  86   //protected:
  87   t_mem mask;
  88   uchar width;
  89
  90 public:
  91   cl_normal_cell(uchar awidth);
  92   //virtual void destroy(void) {}
  93
  94   virtual TYPE_UBYTE get_type(void) { return(type); }
  95   virtual void set_type(TYPE_UBYTE what) { type= what; }
  96   virtual t_mem get_mask(void) { return(mask); }
  97
  98   virtual t_mem read(void) { return(data); }
  99   virtual t_mem read(enum hw_cath /*skip*/) { return(data); }
 100   virtual t_mem get(void)  { return(data); }
 101   virtual t_mem write(t_mem val) { data= val & mask; return(data); }
 102   virtual t_mem set(t_mem val) { return(data= val & mask); }
 103   virtual t_mem add(long what);
 104   virtual t_mem wadd(long what);
 105
 106   virtual void set_bit1(t_mem bits);
 107   virtual void set_bit0(t_mem bits);
 108
 109   virtual class cl_cell *add_hw(class cl_hw */*hw*/, int */*ith*/)
 110   { return(0); }
 111   virtual class cl_hw *get_hw(int ith) { return(0); }
 112   //virtual class cl_brk *get_brk(void) { return(0); }
 113   virtual class cl_event_handler *get_event_handler(void) { return(0); }
 114 };
 115
 116
 117 /* Memory location handled specially by a hw element */
 118
 119 /*class cl_memloc: public cl_base
 120 {
 121 public:
 122   t_addr address;
 123   class cl_list *hws;
 124
 125 public:
 126   cl_memloc(t_addr addr);
 127   virtual ~cl_memloc(void);
 128
 129   virtual ulong read(class cl_mem *mem);
 130   virtual void write(class cl_mem *mem, t_addr addr, t_mem *val);
 131 };*/
 132
 133 /*class cl_memloc_coll: public cl_sorted_list
 134 {
 135 public:
 136   cl_memloc_coll(void);
 137
 138   virtual void *key_of(void *item);
 139   virtual int compare(void *key1, void *key2);
 140
 141   class cl_memloc *get_loc(t_addr address);
 142 };*/
 143
 144 /* Memory */
 145
 146 class cl_mem: public cl_guiobj
 147 {
 148 public:
 149   enum mem_class type;
 150   char *class_name;
 151   char *addr_format, *data_format;
 152   t_addr size;
 153   ulong mask;
 154   int width; // in bits
 155   union {
 156     void *mem;
 157     uchar *umem8;
 158   };
 159   //class cl_memloc_coll *read_locs, *write_locs;
 160   class cl_uc *uc;
 161   t_addr dump_finished;
 162
 163 public:
 164   cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
 165          class cl_uc *auc);
 166   virtual ~cl_mem(void);
 167   virtual int init(void);
 168   virtual char *id_string(void);
 169   virtual int get_cell_flag(t_addr /*addr*/) { return(CELL_NORMAL); }
 170   virtual bool get_cell_flag(t_addr /*addr*/, int /*flag*/)
 171   { return(DD_FALSE); }
 172   virtual void set_cell_flag(t_addr addr, bool set_to, int flag) {}
 173
 174   virtual t_mem read(t_addr addr);
 175   virtual t_mem read(t_addr addr, enum hw_cath /*skip*/) {return(read(addr));}
 176   virtual t_mem get(t_addr addr);
 177   virtual t_mem write(t_addr addr, t_mem val);
 178   virtual void set(t_addr addr, t_mem val);
 179   virtual void set_bit1(t_addr addr, t_mem bits);
 180   virtual void set_bit0(t_addr addr, t_mem bits);
 181   virtual void write_bit1(t_addr addr, t_mem bits) { set_bit1(addr, bits); }
 182   virtual void write_bit0(t_addr addr, t_mem bits) { set_bit0(addr, bits); }
 183   virtual t_mem add(t_addr addr, long what);
 184   virtual t_mem wadd(t_addr addr, long what) { return(add(addr, what)); }
 185   virtual t_addr dump(t_addr start, t_addr stop, int bpl,
 186                       class cl_console *con);
 187   virtual t_addr dump(class cl_console *con);
 188   virtual bool search_next(bool case_sensitive,
 189                            t_mem *array, int len, t_addr *addr);
 190
 191   virtual class cl_cell *get_cell(t_addr addr) {return(0);}
 192   virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
 193                                      bool announce)
 194   { return(0); }
 195   virtual void set_brk(t_addr /*addr*/, class cl_brk */*brk*/) {}
 196   virtual void del_brk(t_addr addr, class cl_brk *brk) {}
 197 };
 198
 199 /* Spec for CODE */
 200
 201 /*class cl_bitmap: public cl_base
 202 {
 203 public:
 204   uchar *map;
 205   int size;
 206 public:
 207   cl_bitmap(t_addr asize);
 208   virtual ~cl_bitmap(void);
 209   virtual void set(t_addr pos);
 210   virtual void clear(t_addr pos);
 211   virtual bool get(t_addr pos);
 212   virtual bool empty(void);
 213 };
 214
 215 class cl_rom: public cl_mem
 216 {
 217 public:
 218   class cl_bitmap *bp_map;
 219   class cl_bitmap *inst_map;
 220 public:
 221   cl_rom(t_addr asize, int awidth, class cl_uc *auc);
 222   virtual ~cl_rom(void);
 223 };*/
 224
 225 /*
 226  * New type of memory simulation
 227  */
 228
 229 class cl_registered_cell: public cl_normal_cell
 230 {
 231 public:
 232   //class cl_list *hws;
 233   class cl_hw **hardwares;
 234   int nuof_hws;
 235 public:
 236   cl_registered_cell(uchar awidth);
 237   virtual ~cl_registered_cell(void);
 238   //virtual void destroy(void);
 239
 240   virtual t_mem read(void);
 241   virtual t_mem read(enum hw_cath skip);
 242   virtual t_mem write(t_mem val);
 243
 244   virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
 245   virtual class cl_hw *get_hw(int ith);
 246 };
 247
 248 class cl_event_handler: public cl_base
 249 {
 250 public:
 251   class cl_list *read_bps, *write_bps;
 252   class cl_uc *uc;
 253 public:
 254   cl_event_handler(class cl_uc *auc);
 255   virtual ~cl_event_handler(void);
 256
 257   virtual void write(void);
 258   virtual void read(void);
 259
 260   virtual int add_bp(class cl_brk *bp);
 261   virtual int copy_from(class cl_event_handler *eh);
 262   virtual bool del_bp(class cl_brk *bp);
 263 };
 264
 265 class cl_event_cell: public cl_normal_cell
 266 {
 267 protected:
 268   class cl_event_handler *eh;
 269 public:
 270   cl_event_cell(uchar awidth, class cl_uc *auc);
 271   virtual ~cl_event_cell(void);
 272
 273   virtual t_mem read(void);
 274   virtual t_mem write(t_mem val);
 275   //virtual void event(void);
 276
 277   //virtual class cl_brk *get_brk(void) { return(brk); }
 278   virtual class cl_event_handler *get_event_handler(void) { return(eh); }
 279 };
 280
 281 class cl_ev_reg_cell: public cl_registered_cell
 282 {
 283 protected:
 284   class cl_event_handler *eh;
 285 public:
 286   cl_ev_reg_cell(uchar awidth, class cl_uc *auc);
 287   virtual ~cl_ev_reg_cell(void);
 288
 289   virtual t_mem read(void);
 290   virtual t_mem write(t_mem val);
 291   //virtual void event(void);
 292
 293   //virtual class cl_brk *get_brk(void) { return(brk); }
 294   virtual class cl_event_handler *get_event_handler(void) { return(eh); }
 295 };
 296
 297 class cl_mapped_cell: public cl_cell
 298 {
 299 protected:
 300   class cl_cell *real_cell;
 301 public:
 302   cl_mapped_cell(class cl_cell *realcell);
 303   virtual ~cl_mapped_cell(void);
 304
 305   virtual t_mem read(void);
 306   virtual t_mem read(enum hw_cath skip);
 307   virtual t_mem get(void);
 308   virtual t_mem write(t_mem val);
 309   virtual t_mem set(t_mem val);
 310   virtual t_mem add(long what);
 311   virtual t_mem wadd(long what);
 312
 313   virtual void set_bit1(t_mem bits);
 314   virtual void set_bit0(t_mem bits);
 315
 316   virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
 317   virtual class cl_hw *get_hw(int ith);
 318   virtual class cl_event_handler *get_event_handler(void);
 319 };
 320
 321 class cl_m: public cl_mem
 322 {
 323 protected:
 324   class cl_cell **array;
 325   class cl_cell *dummy;
 326   t_addr bus_mask;
 327 public:
 328   //t_addr size;
 329   //int width;
 330
 331 public:
 332   cl_m(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
 333        class cl_uc *auc);
 334   cl_m(t_addr asize, int awidth);
 335   virtual ~cl_m(void);
 336   virtual void err_inv_addr(t_addr addr);
 337   virtual int get_cell_flag(t_addr addr);
 338   virtual bool get_cell_flag(t_addr addr, int flag);
 339   virtual void set_cell_flag(t_addr addr, bool set_to, int flag);
 340
 341   virtual t_mem read(t_addr addr);
 342   virtual t_mem read(t_addr addr, enum hw_cath skip);
 343   virtual t_mem get(t_addr addr);
 344   virtual t_mem write(t_addr addr, t_mem val);
 345   virtual void set(t_addr addr, t_mem val);
 346   virtual class cl_cell *get_cell(t_addr addr);
 347
 348   virtual void set_bit1(t_addr addr, t_mem bits);
 349   virtual void set_bit0(t_addr addr, t_mem bits);
 350   virtual void write_bit1(t_addr addr, t_mem bits);
 351   virtual void write_bit0(t_addr addr, t_mem bits);
 352   virtual t_mem add(t_addr addr, long what);
 353   virtual t_mem wadd(t_addr addr, long what);
 354
 355   virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
 356                                      bool announce);
 357   virtual void set_brk(t_addr addr, class cl_brk *brk);
 358   virtual void del_brk(t_addr addr, class cl_brk *brk);
 359 };
 360
 361
 362 #include "errorcl.h"
 363
 364 /*
 365  * Errors in memory handling
 366  */
 367
 368 class cl_err_inv_addr: public cl_error
 369 {
 370 protected:
 371   class cl_mem *mem;
 372   t_addr addr;
 373 public:
 374   cl_err_inv_addr(class cl_mem *amem, t_addr aaddr);
 375   virtual void print(class cl_commander *c);
 376 };
 377
 378
 379 #endif
 380
 381 /* End of memcl.h */