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 #include "stypes.h"
  32 #include "pobjcl.h"
  33
  34 #include "guiobjcl.h"
  35
  36
  37 class cl_mem;
  38
  39 /* Memory location handled specially by a hw element */
  40
  41 class cl_memloc: public cl_base
  42 {
  43 public:
  44   t_addr address;
  45   class cl_list *hws;
  46
  47 public:
  48   cl_memloc(t_addr addr);
  49   ~cl_memloc(void);
  50
  51   virtual ulong read(class cl_mem *mem);
  52   virtual void write(class cl_mem *mem, t_addr addr, t_mem *val);
  53 };
  54
  55 class cl_memloc_coll: public cl_sorted_list
  56 {
  57 public:
  58   cl_memloc_coll(void);
  59
  60   virtual void *key_of(void *item);
  61   virtual int compare(void *key1, void *key2);
  62
  63   class cl_memloc *get_loc(t_addr address);
  64 };
  65
  66 /* Memory */
  67
  68 class cl_mem: public cl_guiobj
  69 {
  70 public:
  71   enum mem_class type;
  72   char *class_name;
  73   char *addr_format, *data_format;
  74   t_addr size;
  75   ulong mask;
  76   int width; // in bits
  77   union {
  78     void *mem;
  79     uchar *umem8;
  80   };
  81   class cl_memloc_coll *read_locs, *write_locs;
  82   t_addr dump_finished;
  83
  84 public:
  85   cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth);
  86   ~cl_mem(void);
  87   virtual int init(void);
  88   virtual char *id_string(void);
  89
  90   virtual t_mem read(t_addr addr);
  91   virtual t_mem get(t_addr addr);
  92   virtual void write(t_addr addr, t_mem *val);
  93   virtual void set(t_addr addr, t_mem val);
  94   virtual void set_bit1(t_addr addr, t_mem bits);
  95   virtual void set_bit0(t_addr addr, t_mem bits);
  96   virtual t_mem add(t_addr addr, long what);
  97   virtual t_addr dump(t_addr start, t_addr stop, int bpl,
  98                       class cl_console *con);
  99   virtual t_addr dump(class cl_console *con);
 100   virtual bool search_next(bool case_sensitive,
 101                            t_mem *array, int len, t_addr *addr);
 102 };
 103
 104 /* Spec for CODE */
 105
 106 class cl_bitmap: public cl_base
 107 {
 108 public:
 109   uchar *map;
 110   int size;
 111 public:
 112   cl_bitmap(t_addr asize);
 113   ~cl_bitmap(void);
 114   virtual void set(t_addr pos);
 115   virtual void clear(t_addr pos);
 116   virtual bool get(t_addr pos);
 117   virtual bool empty(void);
 118 };
 119
 120 class cl_rom: public cl_mem
 121 {
 122 public:
 123   class cl_bitmap *bp_map;
 124   class cl_bitmap *inst_map;
 125 public:
 126   cl_rom(t_addr asize, int awidth);
 127   ~cl_rom(void);
 128 };
 129
 130 /* New type */
 131
 132 class cl_cell: public cl_base
 133 {
 134 public:
 135   t_mem data;
 136 protected:
 137   t_mem mask;
 138
 139 public:
 140   cl_cell(int awidth);
 141   virtual t_mem read(void) { return(data); }
 142   virtual t_mem get(void)  { return(data); }
 143   virtual void write(t_mem *val) { data= *val= (*val & mask); }
 144   virtual void set(t_mem val)    { data= val & mask; }
 145 };
 146
 147 class cl_registered_cell: public cl_cell
 148 {
 149 protected:
 150   class cl_list *hws;
 151   class cl_hw *hardwares;
 152   int nuof_hws;
 153 public:
 154   cl_registered_cell(int awidth);
 155   ~cl_registered_cell(void);
 156   virtual t_mem read(void);
 157   virtual void write(t_mem *val);
 158 };
 159
 160 class cl_m: public cl_mem
 161 {
 162 protected:
 163   class cl_cell **array;
 164 public:
 165   t_addr size;
 166   int width;
 167
 168 public:
 169   cl_m(t_addr asize, int awidth);
 170   ~cl_m(void);
 171   virtual t_mem read(t_addr addr);
 172   virtual t_mem get(t_addr addr);
 173   virtual void write(t_addr addr, t_mem *val);
 174   virtual void set(t_addr addr, t_mem val);
 175 };
 176
 177
 178 #endif
 179
 180 /* End of memcl.h */