X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=sim%2Fucsim%2Fsim.src%2Fmemcl.h;h=d2044fb3bfae5a58219e4a5d12dc7573a28a00c2;hb=0e1bba0730e55b3d40c1c644d94befc99c87270d;hp=85f9462d81aca3f354af47eef782b536a51d3eb9;hpb=6ba6105dc5975c3b0cc0d1ce53f47a1ddf4be9cf;p=fw%2Fsdcc

diff --git a/sim/ucsim/sim.src/memcl.h b/sim/ucsim/sim.src/memcl.h
index 85f9462d..d2044fb3 100644
--- a/sim/ucsim/sim.src/memcl.h
+++ b/sim/ucsim/sim.src/memcl.h
@@ -28,17 +28,111 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #ifndef SIM_MEMCL_HEADER
 #define SIM_MEMCL_HEADER
 
+
+// prj
+#include "ddconfig.h"
 #include "stypes.h"
 #include "pobjcl.h"
 
+// gui.src
 #include "guiobjcl.h"
 
 
 class cl_mem;
+class cl_event_handler;
+
+
+// Cell types
+#define CELL_NORMAL	0x00	/* Nothing special */
+#define CELL_HW_READ	0x01	/* Hw handles read */
+#define CELL_HW_WRITE	0x02	/* Hw catches write */
+#define CELL_INST	0x04	/* Marked as instruction */
+#define CELL_FETCH_BRK	0x08	/* Fetch breakpoint */
+#define CELL_READ_BRK	0x10	/* Read event breakpoint */
+#define CELL_WRITE_BRK	0x20	/* Write event breakpoint */
+
+#define CELL_GENERAL	(CELL_NORMAL|CELL_INST|CELL_FETCH_BRK)
+
+
+class cl_cell: public cl_base
+{
+#ifdef STATISTIC
+public:
+  unsigned long nuof_writes, nuof_reads;
+#endif
+public:
+  cl_cell(void);
+public:
+  virtual TYPE_UBYTE get_type(void)= 0;
+  virtual void set_type(TYPE_UBYTE what)= 0;
+  virtual t_mem get_mask(void)= 0;
+
+  virtual t_mem read(void)=0 ;
+  virtual t_mem read(enum hw_cath /*skip*/)=0;
+  virtual t_mem get(void)=0;
+  virtual t_mem write(t_mem val)=0;
+  virtual t_mem set(t_mem val)=0;
+  virtual t_mem add(long what)=0;
+  virtual t_mem wadd(long what)=0;
+
+  virtual void set_bit1(t_mem bits)=0;
+  virtual void set_bit0(t_mem bits)=0;
+
+  virtual class cl_cell *add_hw(class cl_hw */*hw*/, int */*ith*/)=0;
+  virtual class cl_hw *get_hw(int ith)=0;
+  virtual class cl_event_handler *get_event_handler(void)=0;
+};
+
+class cl_normal_cell: public cl_cell
+{
+public:
+  t_mem data;
+  TYPE_UBYTE type;	// See CELL_XXXX
+  //protected:
+  t_mem mask;
+  uchar width;
+
+public:
+  cl_normal_cell(uchar awidth);
+  //virtual void destroy(void) {}
+
+  virtual TYPE_UBYTE get_type(void) { return(type); }
+  virtual void set_type(TYPE_UBYTE what) { type= what; }
+  virtual t_mem get_mask(void) { return(mask); }
+
+  virtual t_mem read(void) {
+#ifdef STATISTIC
+    nuof_reads++;
+#endif
+    return(data);
+  }
+  virtual t_mem read(enum hw_cath /*skip*/) { return(data); }
+  virtual t_mem get(void)  { return(data); }
+  virtual t_mem write(t_mem val) {
+    data= val & mask;
+#ifdef STATISTIC
+    nuof_writes++;
+#endif
+    return(data);
+  }
+  virtual t_mem set(t_mem val) { return(data= val & mask); }
+  virtual t_mem add(long what);
+  virtual t_mem wadd(long what);
+
+  virtual void set_bit1(t_mem bits);
+  virtual void set_bit0(t_mem bits);
+
+  virtual class cl_cell *add_hw(class cl_hw */*hw*/, int */*ith*/)
+  { return(0); }
+  virtual class cl_hw *get_hw(int ith) { return(0); }
+  //virtual class cl_brk *get_brk(void) { return(0); }
+  virtual class cl_event_handler *get_event_handler(void) { return(0); }
+};
+
 
 /* Memory location handled specially by a hw element */
 
-class cl_memloc: public cl_base
+/*class cl_memloc: public cl_base
 {
 public:
   t_addr address;
@@ -46,13 +140,13 @@ public:
 
 public:
   cl_memloc(t_addr addr);
-  ~cl_memloc(void);
+  virtual ~cl_memloc(void);
 
   virtual ulong read(class cl_mem *mem);
   virtual void write(class cl_mem *mem, t_addr addr, t_mem *val);
-};
+};*/
 
-class cl_memloc_coll: public cl_sorted_list
+/*class cl_memloc_coll: public cl_sorted_list
 {
 public:
   cl_memloc_coll(void);
@@ -61,7 +155,7 @@ public:
   virtual int compare(void *key1, void *key2);
 
   class cl_memloc *get_loc(t_addr address);
-};
+};*/
 
 /* Memory */
 
@@ -78,39 +172,62 @@ public:
     void *mem;
     uchar *umem8;
   };
-  class cl_memloc_coll *read_locs, *write_locs;
+  //class cl_memloc_coll *read_locs, *write_locs;
+  class cl_uc *uc;
   t_addr dump_finished;
 
 public:
-  cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth);
-  ~cl_mem(void);
+  cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
+	 class cl_uc *auc);
+  virtual ~cl_mem(void);
   virtual int init(void);
   virtual char *id_string(void);
+  virtual int get_cell_flag(t_addr /*addr*/) { return(CELL_NORMAL); }
+  virtual bool get_cell_flag(t_addr /*addr*/, int /*flag*/)
+  { return(DD_FALSE); }
+  virtual void set_cell_flag(t_addr addr, bool set_to, int flag) {}
 
   virtual t_mem read(t_addr addr);
+  virtual t_mem read(t_addr addr, enum hw_cath /*skip*/) {return(read(addr));}
   virtual t_mem get(t_addr addr);
-  virtual void write(t_addr addr, t_mem *val);
+  virtual t_mem write(t_addr addr, t_mem val);
   virtual void set(t_addr addr, t_mem val);
   virtual void set_bit1(t_addr addr, t_mem bits);
   virtual void set_bit0(t_addr addr, t_mem bits);
+  virtual void write_bit1(t_addr addr, t_mem bits) { set_bit1(addr, bits); }
+  virtual void write_bit0(t_addr addr, t_mem bits) { set_bit0(addr, bits); }
   virtual t_mem add(t_addr addr, long what);
+  virtual t_mem wadd(t_addr addr, long what) { return(add(addr, what)); }
   virtual t_addr dump(t_addr start, t_addr stop, int bpl,
 		      class cl_console *con);
   virtual t_addr dump(class cl_console *con);
   virtual bool search_next(bool case_sensitive,
 			   t_mem *array, int len, t_addr *addr);
+
+  virtual class cl_cell *get_cell(t_addr addr) {return(0);}
+  virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
+				     bool announce)
+  { return(0); }
+  virtual void set_brk(t_addr /*addr*/, class cl_brk */*brk*/) {}
+  virtual void del_brk(t_addr addr, class cl_brk *brk) {}
+#ifdef STATISTIC
+  virtual unsigned long get_nuof_reads(void) {return(0);}
+  virtual unsigned long get_nuof_writes(void) {return(0);}
+  virtual void set_nuof_reads(unsigned long value) {}
+  virtual void set_nuof_writes(unsigned long value) {}
+#endif
 };
 
 /* Spec for CODE */
 
-class cl_bitmap: public cl_base
+/*class cl_bitmap: public cl_base
 {
 public:
   uchar *map;
   int size;
 public:
   cl_bitmap(t_addr asize);
-  ~cl_bitmap(void);
+  virtual ~cl_bitmap(void);
   virtual void set(t_addr pos);
   virtual void clear(t_addr pos);
   virtual bool get(t_addr pos);
@@ -123,55 +240,168 @@ public:
   class cl_bitmap *bp_map;
   class cl_bitmap *inst_map;
 public:
-  cl_rom(t_addr asize, int awidth);
-  ~cl_rom(void);
-};
+  cl_rom(t_addr asize, int awidth, class cl_uc *auc);
+  virtual ~cl_rom(void);
+};*/
 
-/* New type */
+/*
+ * New type of memory simulation
+ */
 
-class cl_cell: public cl_base
+class cl_registered_cell: public cl_normal_cell
 {
 public:
-  t_mem data;
+  //class cl_list *hws;
+  class cl_hw **hardwares;
+  int nuof_hws;
+public:
+  cl_registered_cell(uchar awidth);
+  virtual ~cl_registered_cell(void);
+  //virtual void destroy(void);
+
+  virtual t_mem read(void);
+  virtual t_mem read(enum hw_cath skip);
+  virtual t_mem write(t_mem val);
+
+  virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
+  virtual class cl_hw *get_hw(int ith);
+};
+
+class cl_event_handler: public cl_base
+{
+public:
+  class cl_list *read_bps, *write_bps;
+  class cl_uc *uc;
+public:
+  cl_event_handler(class cl_uc *auc);
+  virtual ~cl_event_handler(void);
+
+  virtual void write(void);
+  virtual void read(void);
+
+  virtual int add_bp(class cl_brk *bp);
+  virtual int copy_from(class cl_event_handler *eh);
+  virtual bool del_bp(class cl_brk *bp);
+};
+
+class cl_event_cell: public cl_normal_cell
+{
 protected:
-  t_mem mask;
+  class cl_event_handler *eh;
+public:
+  cl_event_cell(uchar awidth, class cl_uc *auc);
+  virtual ~cl_event_cell(void);
+
+  virtual t_mem read(void);
+  virtual t_mem write(t_mem val);
+  //virtual void event(void);
+
+  //virtual class cl_brk *get_brk(void) { return(brk); }
+  virtual class cl_event_handler *get_event_handler(void) { return(eh); }
+};
 
+class cl_ev_reg_cell: public cl_registered_cell
+{
+protected:
+  class cl_event_handler *eh;
 public:
-  cl_cell(int awidth);
-  virtual t_mem read(void) { return(data); }
-  virtual t_mem get(void)  { return(data); }
-  virtual void write(t_mem *val) { data= *val= (*val & mask); }
-  virtual void set(t_mem val)    { data= val & mask; }
+  cl_ev_reg_cell(uchar awidth, class cl_uc *auc);
+  virtual ~cl_ev_reg_cell(void);
+ 
+  virtual t_mem read(void);
+  virtual t_mem write(t_mem val);
+  //virtual void event(void);
+  
+  //virtual class cl_brk *get_brk(void) { return(brk); }
+  virtual class cl_event_handler *get_event_handler(void) { return(eh); }
 };
 
-class cl_registered_cell: public cl_cell
+class cl_mapped_cell: public cl_cell
 {
 protected:
-  class cl_list *hws;
-  class cl_hw *hardwares;
-  int nuof_hws;
+  class cl_cell *real_cell;
 public:
-  cl_registered_cell(int awidth);
-  ~cl_registered_cell(void);
+  cl_mapped_cell(class cl_cell *realcell);
+  virtual ~cl_mapped_cell(void);
+
   virtual t_mem read(void);
-  virtual void write(t_mem *val);
+  virtual t_mem read(enum hw_cath skip);
+  virtual t_mem get(void);
+  virtual t_mem write(t_mem val);
+  virtual t_mem set(t_mem val);
+  virtual t_mem add(long what);
+  virtual t_mem wadd(long what);
+
+  virtual void set_bit1(t_mem bits);
+  virtual void set_bit0(t_mem bits);
+
+  virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
+  virtual class cl_hw *get_hw(int ith);
+  virtual class cl_event_handler *get_event_handler(void);
 };
 
 class cl_m: public cl_mem
 {
 protected:
   class cl_cell **array;
+  class cl_cell *dummy;
+  t_addr bus_mask;
 public:
-  t_addr size;
-  int width;
+  //t_addr size;
+  //int width;
 
 public:
+  cl_m(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
+       class cl_uc *auc);
   cl_m(t_addr asize, int awidth);
-  ~cl_m(void);
+  virtual ~cl_m(void);
+  virtual void err_inv_addr(t_addr addr);
+  virtual int get_cell_flag(t_addr addr);
+  virtual bool get_cell_flag(t_addr addr, int flag);
+  virtual void set_cell_flag(t_addr addr, bool set_to, int flag);
+
   virtual t_mem read(t_addr addr);
+  virtual t_mem read(t_addr addr, enum hw_cath skip);
   virtual t_mem get(t_addr addr);
-  virtual void write(t_addr addr, t_mem *val);
+  virtual t_mem write(t_addr addr, t_mem val);
   virtual void set(t_addr addr, t_mem val);
+  virtual class cl_cell *get_cell(t_addr addr);
+
+  virtual void set_bit1(t_addr addr, t_mem bits);
+  virtual void set_bit0(t_addr addr, t_mem bits);
+  virtual void write_bit1(t_addr addr, t_mem bits);
+  virtual void write_bit0(t_addr addr, t_mem bits);
+  virtual t_mem add(t_addr addr, long what);
+  virtual t_mem wadd(t_addr addr, long what);
+
+  virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
+				     bool announce);
+  virtual void set_brk(t_addr addr, class cl_brk *brk);
+  virtual void del_brk(t_addr addr, class cl_brk *brk);
+
+#ifdef STATISTIC
+  virtual unsigned long get_nuof_reads(void);
+  virtual unsigned long get_nuof_writes(void);
+  virtual void set_nuof_reads(unsigned long value);
+  virtual void set_nuof_writes(unsigned long value);
+#endif
+};
+
+
+#include "errorcl.h"
+
+/*
+ * Errors in memory handling
+ */
+
+class cl_err_inv_addr: public cl_error
+{
+protected:
+  class cl_mem *mem;
+  t_addr addr;
+public:
+  cl_err_inv_addr(class cl_mem *amem, t_addr aaddr);
+  virtual void print(class cl_commander *c);
 };