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 <<<<<<< memcl.h
 222   cl_rom(t_addr asize, int awidth);
 223   ~cl_rom(void);
 224 };
 225
 226 /* New type */
 227 =======
 228   cl_rom(t_addr asize, int awidth, class cl_uc *auc);
 229   virtual ~cl_rom(void);
 230 };*/
 231
 232 /*
 233  * New type of memory simulation
 234  */
 235 >>>>>>> 1.4.2.2
 236
 237 <<<<<<< memcl.h
 238 class cl_cell: public cl_base
 239 {
 240 public:
 241   t_mem data;
 242 =======
 243 class cl_registered_cell: public cl_normal_cell
 244 {
 245 public:
 246   //class cl_list *hws;
 247   class cl_hw **hardwares;
 248   int nuof_hws;
 249 public:
 250   cl_registered_cell(uchar awidth);
 251   virtual ~cl_registered_cell(void);
 252   //virtual void destroy(void);
 253
 254   virtual t_mem read(void);
 255   virtual t_mem read(enum hw_cath skip);
 256   virtual t_mem write(t_mem val);
 257
 258   virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
 259   virtual class cl_hw *get_hw(int ith);
 260 };
 261
 262 class cl_event_handler: public cl_base
 263 {
 264 public:
 265   class cl_list *read_bps, *write_bps;
 266   class cl_uc *uc;
 267 public:
 268   cl_event_handler(class cl_uc *auc);
 269   virtual ~cl_event_handler(void);
 270
 271   virtual void write(void);
 272   virtual void read(void);
 273
 274   virtual int add_bp(class cl_brk *bp);
 275   virtual int copy_from(class cl_event_handler *eh);
 276   virtual bool del_bp(class cl_brk *bp);
 277 };
 278
 279 class cl_event_cell: public cl_normal_cell
 280 {
 281 >>>>>>> 1.4.2.2
 282 protected:
 283   class cl_event_handler *eh;
 284 public:
 285   cl_event_cell(uchar awidth, class cl_uc *auc);
 286   virtual ~cl_event_cell(void);
 287
 288   virtual t_mem read(void);
 289   virtual t_mem write(t_mem val);
 290   //virtual void event(void);
 291
 292   //virtual class cl_brk *get_brk(void) { return(brk); }
 293   virtual class cl_event_handler *get_event_handler(void) { return(eh); }
 294 };
 295
 296 class cl_ev_reg_cell: public cl_registered_cell
 297 {
 298 protected:
 299   class cl_event_handler *eh;
 300 public:
 301   cl_ev_reg_cell(uchar awidth, class cl_uc *auc);
 302   virtual ~cl_ev_reg_cell(void);
 303
 304   virtual t_mem read(void);
 305   virtual t_mem write(t_mem val);
 306   //virtual void event(void);
 307
 308   //virtual class cl_brk *get_brk(void) { return(brk); }
 309   virtual class cl_event_handler *get_event_handler(void) { return(eh); }
 310 };
 311
 312 class cl_mapped_cell: public cl_cell
 313 {
 314 protected:
 315   class cl_cell *real_cell;
 316 public:
 317   cl_mapped_cell(class cl_cell *realcell);
 318   virtual ~cl_mapped_cell(void);
 319
 320   virtual t_mem read(void);
 321   virtual t_mem read(enum hw_cath skip);
 322   virtual t_mem get(void);
 323   virtual t_mem write(t_mem val);
 324   virtual t_mem set(t_mem val);
 325   virtual t_mem add(long what);
 326   virtual t_mem wadd(long what);
 327
 328   virtual void set_bit1(t_mem bits);
 329   virtual void set_bit0(t_mem bits);
 330
 331   virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
 332   virtual class cl_hw *get_hw(int ith);
 333   virtual class cl_event_handler *get_event_handler(void);
 334 };
 335
 336 class cl_m: public cl_mem
 337 {
 338 protected:
 339   class cl_cell **array;
 340   class cl_cell *dummy;
 341   t_addr bus_mask;
 342 public:
 343   //t_addr size;
 344   //int width;
 345
 346 public:
 347   cl_m(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
 348        class cl_uc *auc);
 349   cl_m(t_addr asize, int awidth);
 350   virtual ~cl_m(void);
 351   virtual void err_inv_addr(t_addr addr);
 352   virtual int get_cell_flag(t_addr addr);
 353   virtual bool get_cell_flag(t_addr addr, int flag);
 354   virtual void set_cell_flag(t_addr addr, bool set_to, int flag);
 355
 356   virtual t_mem read(t_addr addr);
 357   virtual t_mem read(t_addr addr, enum hw_cath skip);
 358   virtual t_mem get(t_addr addr);
 359   virtual t_mem write(t_addr addr, t_mem val);
 360   virtual void set(t_addr addr, t_mem val);
 361   virtual class cl_cell *get_cell(t_addr addr);
 362
 363   virtual void set_bit1(t_addr addr, t_mem bits);
 364   virtual void set_bit0(t_addr addr, t_mem bits);
 365   virtual void write_bit1(t_addr addr, t_mem bits);
 366   virtual void write_bit0(t_addr addr, t_mem bits);
 367   virtual t_mem add(t_addr addr, long what);
 368   virtual t_mem wadd(t_addr addr, long what);
 369
 370   virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
 371                                      bool announce);
 372   virtual void set_brk(t_addr addr, class cl_brk *brk);
 373   virtual void del_brk(t_addr addr, class cl_brk *brk);
 374 };
 375
 376
 377 #include "errorcl.h"
 378
 379 /*
 380  * Errors in memory handling
 381  */
 382
 383 class cl_err_inv_addr: public cl_error
 384 {
 385 protected:
 386   class cl_mem *mem;
 387   t_addr addr;
 388 public:
 389   cl_err_inv_addr(class cl_mem *amem, t_addr aaddr);
 390   virtual void print(class cl_commander *c);
 391 };
 392
 393
 394 #endif
 395
 396 /* End of memcl.h */