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