#ifndef SIM_MEMCL_HEADER
#define SIM_MEMCL_HEADER
+#include "ddconfig.h"
// prj
-#include "ddconfig.h"
#include "stypes.h"
#include "pobjcl.h"
#include "guiobjcl.h"
-class cl_mem;
class cl_event_handler;
#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_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); }
+// Cell flags
+enum cell_flag {
+ CELL_NONE = 0x00,
+ CELL_INST = 0x04, /* Marked as instruction */
+ CELL_FETCH_BRK = 0x08, /* Fetch breakpoint */
+ CELL_NON_DECODED = 0x40 /* Cell is not decoded (yet) */
};
+#define CELL_GENERAL (CELL_NORMAL|CELL_INST|CELL_FETCH_BRK)
-/* Memory location handled specially by a hw element */
-/*class cl_memloc: public cl_base
-{
-public:
- t_addr address;
- class cl_list *hws;
-
-public:
- cl_memloc(t_addr addr);
- virtual ~cl_memloc(void);
-
- virtual ulong read(class cl_mem *mem);
- virtual void write(class cl_mem *mem, t_addr addr, t_mem *val);
-};*/
+/*
+ * 3rd version of memory system
+ */
-/*class cl_memloc_coll: public cl_sorted_list
+class cl_memory: public cl_base
{
public:
- cl_memloc_coll(void);
-
- virtual void *key_of(void *item);
- virtual int compare(void *key1, void *key2);
-
- class cl_memloc *get_loc(t_addr address);
-};*/
-
-/* Memory */
-
-class cl_mem: public cl_guiobj
-{
+ t_addr start_address;
+protected:
+ class cl_uc *uc;
+ t_addr size;
public:
- enum mem_class type;
- char *class_name;
char *addr_format, *data_format;
- t_addr size;
- ulong mask;
int width; // in bits
- union {
- void *mem;
- uchar *umem8;
- };
- //class cl_memloc_coll *read_locs, *write_locs;
- class cl_uc *uc;
- t_addr dump_finished;
+ t_mem data_mask;
+ //char *class_name; // used by cl_m!!
+protected:
+ t_addr dump_finished;
public:
- cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
- class cl_uc *auc);
- virtual ~cl_mem(void);
+ cl_memory(char *id, t_addr asize, int awidth);
+ virtual ~cl_memory(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 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)); }
+ t_addr get_start_address(void) { return(start_address); }
+ t_addr get_size(void) { return(size); }
+ virtual void set_uc(class cl_uc *auc) { uc= auc; }
+ virtual bool valid_address(t_addr addr);
+ virtual t_addr inc_address(t_addr addr, int val);
+ virtual t_addr inc_address(t_addr addr);
+ virtual t_addr validate_address(t_addr addr);
+
+ virtual bool is_chip(void) { return(DD_FALSE); }
+ virtual bool is_address_space(void) { return(DD_FALSE); }
+
+ virtual void err_inv_addr(t_addr addr);
+ virtual void err_non_decoded(t_addr addr);
+
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 */
+ virtual t_addr lowest_valid_address(void) { return(start_address); }
+ virtual t_addr highest_valid_address(void) { return(start_address+size-1); }
-/*class cl_bitmap: public cl_base
-{
-public:
- uchar *map;
- int size;
-public:
- cl_bitmap(t_addr asize);
- virtual ~cl_bitmap(void);
- virtual void set(t_addr pos);
- virtual void clear(t_addr pos);
- virtual bool get(t_addr pos);
- virtual bool empty(void);
+
+ virtual t_mem read(t_addr addr)=0;
+ virtual t_mem read(t_addr addr, enum hw_cath skip)=0;
+ virtual t_mem get(t_addr addr)=0;
+ virtual t_mem write(t_addr addr, t_mem val)=0;
+ virtual void set(t_addr addr, t_mem val)=0;
+ virtual void set_bit1(t_addr addr, t_mem bits)=0;
+ virtual void set_bit0(t_addr addr, t_mem bits)=0;
};
-class cl_rom: public cl_mem
-{
-public:
- class cl_bitmap *bp_map;
- class cl_bitmap *inst_map;
-public:
- cl_rom(t_addr asize, int awidth, class cl_uc *auc);
- virtual ~cl_rom(void);
-};*/
/*
- * New type of memory simulation
+ * Operators for memory cells
*/
-class cl_registered_cell: public cl_normal_cell
+class cl_memory_operator: public cl_base
{
+protected:
+ t_addr address;
+ t_mem *data;
+ t_mem mask;
+ class cl_memory_operator *next_operator;
+ class cl_memory_cell *cell;
public:
- //class cl_list *hws;
- class cl_hw **hardwares;
- int nuof_hws;
+ cl_memory_operator(class cl_memory_cell *acell, t_addr addr);
+ cl_memory_operator(class cl_memory_cell *acell, t_addr addr,
+ t_mem *data_place, t_mem the_mask);
+
+ virtual void set_data(t_mem *data_place, t_mem the_mask);
+ virtual class cl_memory_operator *get_next(void) { return(next_operator); }
+ virtual void set_next(class cl_memory_operator *next) { next_operator= next;}
+
+ virtual bool match(class cl_hw *the_hw) { return(DD_FALSE); }
+ virtual bool match(class cl_brk *brk) { return(DD_FALSE); }
+
+ virtual t_mem read(void);
+ virtual t_mem read(enum hw_cath skip) { return(read()); }
+ virtual t_mem write(t_mem val);
+};
+
+class cl_hw_operator: public cl_memory_operator
+{
+protected:
+ class cl_hw *hw;
public:
- cl_registered_cell(uchar awidth);
- virtual ~cl_registered_cell(void);
- //virtual void destroy(void);
+ cl_hw_operator(class cl_memory_cell *acell, t_addr addr,
+ t_mem *data_place, t_mem the_mask, class cl_hw *ahw);
+
+ virtual bool match(class cl_hw *the_hw) { return(hw == the_hw); }
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
+class cl_event_break_operator: public cl_memory_operator
{
-public:
- class cl_list *read_bps, *write_bps;
+protected:
class cl_uc *uc;
+ class cl_brk *bp;
public:
- cl_event_handler(class cl_uc *auc);
- virtual ~cl_event_handler(void);
-
- virtual void write(void);
- virtual void read(void);
+ cl_event_break_operator(class cl_memory_cell *acell, t_addr addr,
+ t_mem *data_place, t_mem the_mask,
+ class cl_uc *auc, class cl_brk *the_bp):
+ cl_memory_operator(acell, addr, data_place, the_mask)
+ {
+ uc= auc;
+ bp= the_bp;
+ }
- 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);
+ virtual bool match(class cl_brk *brk) { return(bp == brk); }
};
-class cl_event_cell: public cl_normal_cell
+class cl_write_operator: public cl_event_break_operator
{
-protected:
- class cl_event_handler *eh;
public:
- cl_event_cell(uchar awidth, class cl_uc *auc);
- virtual ~cl_event_cell(void);
+ cl_write_operator(class cl_memory_cell *acell, t_addr addr,
+ t_mem *data_place, t_mem the_mask,
+ class cl_uc *auc, class cl_brk *the_bp);
- 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
+class cl_read_operator: public cl_event_break_operator
{
-protected:
- class cl_event_handler *eh;
public:
- cl_ev_reg_cell(uchar awidth, class cl_uc *auc);
- virtual ~cl_ev_reg_cell(void);
-
+ cl_read_operator(class cl_memory_cell *acell, t_addr addr,
+ t_mem *data_place, t_mem the_mask,
+ class cl_uc *auc, class cl_brk *the_bp);
+
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_mapped_cell: public cl_cell
+
+/*
+ * version 3 of cell
+ */
+
+class cl_memory_cell: public cl_base
{
+#ifdef STATISTIC
+public:
+ unsigned long nuof_writes, nuof_reads;
+#endif
protected:
- class cl_cell *real_cell;
+ t_mem *data;
+ t_mem mask;
+ uchar width;
+ TYPE_UBYTE flags;
+ class cl_memory_operator *operators;
public:
- cl_mapped_cell(class cl_cell *realcell);
- virtual ~cl_mapped_cell(void);
+ cl_memory_cell(void);
+ virtual ~cl_memory_cell(void);
+ virtual int init(void);
+
+ virtual t_mem *get_data(void) { return(data); }
+ virtual t_mem get_mask(void) { return(mask); }
+ virtual TYPE_UBYTE get_flags(void);
+ virtual bool get_flag(enum cell_flag flag);
+ virtual void set_flags(TYPE_UBYTE what);
+ virtual void set_flag(enum cell_flag flag, bool val);
+
+ virtual void un_decode(void);
+ virtual void decode(class cl_memory_chip *chip, t_addr addr);
virtual t_mem read(void);
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 void append_operator(class cl_memory_operator *op);
+ virtual void prepend_operator(class cl_memory_operator *op);
+ virtual void del_operator(class cl_brk *brk);
+
+ virtual class cl_memory_cell *add_hw(class cl_hw *hw, int *ith, t_addr addr);
+ //virtual class cl_hw *get_hw(int ith);
virtual class cl_event_handler *get_event_handler(void);
};
-class cl_m: public cl_mem
+class cl_dummy_cell: public cl_memory_cell
{
-protected:
- class cl_cell **array;
- class cl_cell *dummy;
- t_addr bus_mask;
public:
- //t_addr size;
- //int width;
+ cl_dummy_cell(void): cl_memory_cell() {}
+ virtual t_mem write(t_mem val);
+ virtual t_mem set(t_mem val);
+};
+
+
+/*
+ * Address space
+ */
+
+class cl_memory_chip;
+
+class cl_address_space: public cl_memory
+{
+protected:
+ class cl_memory_cell **cells, *dummy;
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);
- 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);
+ class cl_decoder_list *decoders;
+public:
+ cl_address_space(char *id, t_addr astart, t_addr asize, int awidth);
+ virtual ~cl_address_space(void);
+
+ virtual bool is_address_space(void) { return(DD_TRUE); }
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 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 t_mem wadd(t_addr addr, long what);
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 class cl_memory_cell *get_cell(t_addr addr);
+ virtual int get_cell_flag(t_addr addr);
+ virtual bool get_cell_flag(t_addr addr, enum cell_flag flag);
+ virtual void set_cell_flag(t_addr addr, bool set_to, enum cell_flag flag);
+
+ virtual bool decode_cell(t_addr addr,
+ class cl_memory_chip *chip, t_addr chipaddr);
+ virtual void undecode_cell(t_addr addr);
+ virtual void undecode_area(class cl_address_decoder *skip,
+ t_addr begin, t_addr end, class cl_console *con);
+
+ virtual class cl_memory_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);
+ 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
};
+class cl_address_space_list: public cl_list
+{
+protected:
+ class cl_uc *uc;
+public:
+ cl_address_space_list(class cl_uc *the_uc);
+ virtual t_index add(class cl_address_space *mem);
+};
+
+
+/*
+ * Memory chip (storage)
+ */
+
+class cl_memory_chip: public cl_memory
+{
+protected:
+ t_mem *array;
+ int init_value;
+public:
+ cl_memory_chip(char *id, int asize, int awidth, int initial= -1);
+ virtual ~cl_memory_chip(void);
+ virtual int init(void);
+
+ virtual bool is_chip(void) { return(DD_TRUE); }
+
+ virtual t_mem *get_slot(t_addr addr);
+
+ virtual t_mem read(t_addr addr) { return(get(addr)); }
+ virtual t_mem read(t_addr addr, enum hw_cath skip) { return(get(addr)); }
+ virtual t_mem get(t_addr addr);
+ virtual t_mem write(t_addr addr, t_mem val) { set(addr, val); return(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);
+};
+
+
+/*
+ * Address decoder
+ */
+
+class cl_address_decoder: public cl_base
+{
+public:
+ class cl_address_space *address_space;
+ class cl_memory_chip *memchip;
+ t_addr as_begin, as_end;
+ t_addr chip_begin;
+ bool activated;
+public:
+ cl_address_decoder(class cl_memory *as, class cl_memory *chip,
+ t_addr asb, t_addr ase, t_addr cb);
+ virtual ~cl_address_decoder(void);
+ virtual int init(void);
+
+ virtual bool activate(class cl_console *con);
+
+ virtual bool fully_covered_by(t_addr begin, t_addr end);
+ virtual bool is_in(t_addr begin, t_addr end);
+ virtual bool covers(t_addr begin, t_addr end);
+
+ virtual bool shrink_out_of(t_addr begin, t_addr end);
+ virtual class cl_address_decoder *split(t_addr begin, t_addr end);
+};
+
+/* List of address decoders */
+
+class cl_decoder_list: public cl_sorted_list
+{
+protected:
+ bool by_chip;
+public:
+ cl_decoder_list(t_index alimit, t_index adelta, bool bychip);
+
+ virtual void *key_of(void *item);
+ virtual int compare(void *key1, void *key2);
+};
+
+
+/*
+ * Messages
+ */
+
+#include "eventcl.h"
+
+class cl_event_address_space_added: public cl_event
+{
+public:
+ class cl_address_space *as;
+ cl_event_address_space_added(class cl_address_space *the_as):
+ cl_event(ev_address_space_added)
+ { as= the_as; }
+};
-#include "errorcl.h"
/*
* Errors in memory handling
*/
-class cl_err_inv_addr: public cl_error
+#include "errorcl.h"
+
+ERROR_CLASS_DECL(mem): public cl_error
{
protected:
- class cl_mem *mem;
+ class cl_memory *mem;
t_addr addr;
public:
- cl_err_inv_addr(class cl_mem *amem, t_addr aaddr);
+ cl_error_mem(class cl_memory *amem, t_addr aaddr);
+};
+
+ERROR_CLASS_DECL(mem_invalid_address): public cl_error_mem
+{
+public:
+ cl_error_mem_invalid_address(class cl_memory *amem, t_addr aaddr);
+
+ virtual void print(class cl_commander *c);
+};
+
+ERROR_CLASS_DECL(mem_non_decoded): public cl_error_mem
+{
+public:
+ cl_error_mem_non_decoded(class cl_memory *amem, t_addr aaddr);
+
virtual void print(class cl_commander *c);
};
projects / fw / sdcc / blobdiff