+cl_memory_cell::cl_memory_cell(void):
+ cl_base()
+{
+ data= (t_mem *)malloc(sizeof(t_mem));
+ flags= CELL_NON_DECODED;
+ width= 8;
+ *data= 0;
+ operators= NULL;
+
+#ifdef STATISTIC
+ nuof_writes= nuof_reads= 0;
+#endif
+
+ mask= 1;
+ int w= width;
+ for (--w; w; w--)
+ {
+ mask<<= 1;
+ mask|= 1;
+ }
+}
+
+cl_memory_cell::~cl_memory_cell(void)
+{
+ if ((flags & CELL_NON_DECODED) &&
+ data)
+ free(data);
+}
+
+int
+cl_memory_cell::init(void)
+{
+ cl_base::init();
+ set(0/*rand()*/);
+ return(0);
+}
+
+
+TYPE_UBYTE
+cl_memory_cell::get_flags(void)
+{
+ return(flags);
+}
+
+bool
+cl_memory_cell::get_flag(enum cell_flag flag)
+{
+ return(flags & flag);
+}
+
+void
+cl_memory_cell::set_flags(TYPE_UBYTE what)
+{
+ flags= what;
+}
+
+void
+cl_memory_cell::set_flag(enum cell_flag flag, bool val)
+{
+ if (val)
+ flags|= flag;
+ else
+ flags&= ~(flag);
+}
+
+
+void
+cl_memory_cell::un_decode(void)
+{
+ if ((flags & CELL_NON_DECODED) == 0)
+ {
+ data= (t_mem *)malloc(sizeof(t_mem));
+ flags|= CELL_NON_DECODED;
+ }
+}
+
+void
+cl_memory_cell::decode(class cl_memory_chip *chip, t_addr addr)
+{
+ if (flags & CELL_NON_DECODED)
+ free(data);
+ data= chip->get_slot(addr);
+ if (!data)
+ {
+ data= (t_mem *)malloc(sizeof(t_mem));
+ flags|= CELL_NON_DECODED;
+ }
+ else
+ flags&= ~(CELL_NON_DECODED);
+}
+
+
+t_mem
+cl_memory_cell::read(void)
+{
+#ifdef STATISTIC
+ nuof_reads++;
+#endif
+ if (operators)
+ return(operators->read());
+ return(*data);
+}
+
+t_mem
+cl_memory_cell::read(enum hw_cath skip)
+{
+#ifdef STATISTIC
+ nuof_reads++;
+#endif
+ if (operators)
+ return(operators->read(skip));
+ return(*data);
+}
+
+t_mem
+cl_memory_cell::get(void)
+{
+ return(*data);
+}
+
+t_mem
+cl_memory_cell::write(t_mem val)
+{
+#ifdef STATISTIC
+ nuof_writes++;
+#endif
+ if (operators)
+ return(operators->write(val));
+ *data= val & mask;
+ return(*data);
+}
+
+t_mem
+cl_memory_cell::set(t_mem val)
+{
+ *data= val & mask;
+ return(*data);
+}
+
+
+
+t_mem
+cl_memory_cell::add(long what)
+{
+ *data= (*data + what) & mask;
+ return(*data);
+}
+
+t_mem
+cl_memory_cell::wadd(long what)
+{
+ t_mem d= (*data + what) & mask;
+ return(write(d));
+}
+
+void
+cl_memory_cell::set_bit1(t_mem bits)
+{
+ bits&= mask;
+ (*data)|= bits;
+}
+
+void
+cl_memory_cell::set_bit0(t_mem bits)
+{
+ bits&= mask;
+ (*data)&= ~bits;
+}
+
+
+void
+cl_memory_cell::append_operator(class cl_memory_operator *op)
+{
+ if (!operators)
+ operators= op;
+ else
+ {
+ class cl_memory_operator *o= operators, *n;
+ n= o->get_next();
+ while (n)
+ {
+ o= n;
+ n= o->get_next();
+ }
+ o->set_next(op);
+ }
+}
+
+void
+cl_memory_cell::prepend_operator(class cl_memory_operator *op)
+{
+ if (op)
+ {
+ op->set_next(operators);
+ operators= op;
+ }
+}
+
+void
+cl_memory_cell::del_operator(class cl_brk *brk)
+{
+ if (!operators)
+ return;
+ class cl_memory_operator *op= operators;
+ if (operators->match(brk))
+ {
+ operators= op->get_next();
+ delete op;
+ }
+ else
+ {
+ while (op->get_next() &&
+ !op->get_next()->match(brk))
+ op= op->get_next();
+ if (op->get_next())
+ {
+ class cl_memory_operator *m= op->get_next();
+ op->set_next(m->get_next());;
+ delete m;
+ }
+ }
+}
+
+
+class cl_memory_cell *
+cl_memory_cell::add_hw(class cl_hw *hw, int *ith, t_addr addr)
+{
+ class cl_hw_operator *o= new cl_hw_operator(this, addr, data, mask, hw);
+ append_operator(o);
+ return(this);
+}
+
+/*class cl_hw *
+cl_memory_cell::get_hw(int ith)
+{
+ return(0);
+}*/
+
+class cl_event_handler *
+cl_memory_cell::get_event_handler(void)
+{
+ return(0);
+}
+
+
+/*
+ * Dummy cell for non-existent addresses
+ */
+
+t_mem
+cl_dummy_cell::write(t_mem val)
+{
+#ifdef STATISTIC
+ nuof_writes++;
+#endif
+ *data= rand() & mask;
+ return(*data);
+}
+
+t_mem
+cl_dummy_cell::set(t_mem val)
+{
+ *data= rand() & mask;
+ return(*data);
+}
+
+
+/*
+ * Address space
+ */
+
+cl_address_space::cl_address_space(char *id,
+ t_addr astart, t_addr asize, int awidth):
+ cl_memory(id, asize, awidth)
+{
+ start_address= astart;
+ decoders= new cl_decoder_list(2, 2, DD_FALSE);
+ cells= (class cl_memory_cell **)malloc(size * sizeof(class cl_memory_cell*));
+ int i;
+ for (i= 0; i < size; i++)
+ {
+ cells[i]= new cl_memory_cell();
+ cells[i]->init();
+ }
+ dummy= new cl_dummy_cell();
+}
+
+cl_address_space::~cl_address_space(void)
+{
+ delete decoders;
+ int i;
+ for (i= 0; i < size; i++)
+ if (cells[i])
+ delete cells[i];
+ delete dummy;
+}
+
+
+t_mem
+cl_address_space::read(t_addr addr)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ err_inv_addr(addr);
+ return(dummy->read());
+ }
+ return(cells[idx]->read());
+}
+
+t_mem
+cl_address_space::read(t_addr addr, enum hw_cath skip)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ err_inv_addr(addr);
+ return(dummy->read());
+ }
+ return(cells[idx]->read(skip));
+}
+
+t_mem
+cl_address_space::get(t_addr addr)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ err_inv_addr(addr);
+ return(dummy->get());
+ }
+ return(cells[idx]->get());
+}
+
+t_mem
+cl_address_space::write(t_addr addr, t_mem val)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ err_inv_addr(addr);
+ return(dummy->write(val));
+ }
+ return(cells[idx]->write(val));
+}
+
+void
+cl_address_space::set(t_addr addr, t_mem val)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ err_inv_addr(addr);
+ dummy->set(val);
+ return;
+ }
+ cells[idx]->set(val);
+}
+
+t_mem
+cl_address_space::wadd(t_addr addr, long what)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ err_inv_addr(addr);
+ }
+ return(cells[idx]->wadd(what));
+}
+
+/* Set or clear bits, without callbacks */
+
+void
+cl_address_space::set_bit1(t_addr addr, t_mem bits)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ return;
+ class cl_memory_cell *cell= cells[idx];
+ cell->set_bit1(bits);
+}
+
+void
+cl_address_space::set_bit0(t_addr addr, t_mem bits)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ return;
+ class cl_memory_cell *cell= cells[idx];
+ cell->set_bit0(bits);
+}
+
+
+class cl_memory_cell *
+cl_address_space::get_cell(t_addr addr)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ err_inv_addr(addr);
+ return(dummy);
+ }
+ return(cells[idx]);
+}
+
+
+int
+cl_address_space::get_cell_flag(t_addr addr)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ return(dummy->get_flags());
+ }
+ return(cells[addr]->get_flags());
+}
+
+bool
+cl_address_space::get_cell_flag(t_addr addr, enum cell_flag flag)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ {
+ return(dummy->get_flag(flag));
+ }
+ return(cells[addr]->get_flag(flag));
+}
+
+void
+cl_address_space::set_cell_flag(t_addr addr, bool set_to, enum cell_flag flag)
+{
+ t_addr idx= addr-start_address;
+ class cl_memory_cell *cell;
+
+ if (idx >= size ||
+ addr < start_address)
+ {
+ cell= dummy;
+ }
+ else
+ cell= cells[addr];
+ cell->set_flag(flag, set_to);
+}
+
+
+bool
+cl_address_space::decode_cell(t_addr addr,
+ class cl_memory_chip *chip, t_addr chipaddr)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ return(DD_FALSE);
+ class cl_memory_cell *cell= cells[idx];
+
+ if (!cell->get_flag(CELL_NON_DECODED))
+ {
+ // un-decode first!
+ cell->un_decode();
+ }
+ cell->decode(chip, chipaddr);
+
+ return(!cell->get_flag(CELL_NON_DECODED));
+}
+
+void
+cl_address_space::undecode_cell(t_addr addr)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ return;
+ class cl_memory_cell *cell= cells[idx];
+
+ cell->un_decode();
+}
+
+void
+cl_address_space::undecode_area(class cl_address_decoder *skip,
+ t_addr begin, t_addr end,class cl_console *con)
+{
+#define D if (con) con->debug
+ D("Undecoding area 0x%x-0x%x of %s\n", begin, end, get_name());
+ int i;
+ for (i= 0; i < decoders->count; i++)
+ {
+ class cl_address_decoder *d=
+ dynamic_cast<class cl_address_decoder *>(decoders->object_at(i));
+ if (!d ||
+ d == skip)
+ continue;
+ D(" Checking decoder 0x%x-0x%x -> %s[0x%x]\n",
+ d->as_begin, d->as_end, d->memchip->get_name(), d->chip_begin);
+ if (d->fully_covered_by(begin, end))
+ {
+ // decoder can be removed
+ D(" Can be removed\n");
+ decoders->disconn(d);
+ i--;
+ delete d;
+ if (decoders->count == 0)
+ break;
+ }
+ else if (d->covers(begin, end))
+ {
+ // decoder must be split
+ D(" Must be split\n");
+ class cl_address_decoder *nd= d->split(begin, end);
+ D(" After split:\n");
+ D(" 0x%x-0x%x -> %s[0x%x]\n",
+ d->as_begin, d->as_end, d->memchip->get_name(), d->chip_begin);
+ if (nd)
+ {
+ decoders->add(nd);
+ D(" 0x%x-0x%x -> %s[0x%x]\n",
+ nd->as_begin, nd->as_end, nd->memchip->get_name(), nd->chip_begin);
+ nd->activate(con);
+ }
+ }
+ else if (d->is_in(begin, end))
+ {
+ // decoder sould shrink
+ D(" Sould shrink\n");
+ if (d->shrink_out_of(begin, end))
+ {
+ D(" Can be removed after shrink\n");
+ decoders->disconn(d);
+ i--;
+ delete d;
+ if (decoders->count == 0)
+ break;
+ }
+ else
+ {
+ D(" Shrinked to 0x%x-0x%x -> %s[0x%x]\n",
+ d->as_begin, d->as_end, d->memchip->get_name(), d->chip_begin);
+ }
+ }
+ }
+#undef D
+}
+
+
+class cl_memory_cell *
+cl_address_space::register_hw(t_addr addr, class cl_hw *hw,
+ int *ith,
+ bool announce)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ return(0);
+ class cl_memory_cell *cell= cells[idx];
+ cell->add_hw(hw, ith, addr);
+ //printf("adding hw %s to cell 0x%x(%d) of %s\n", hw->id_string, addr, idx, get_name("as"));
+ if (announce)
+ ;//uc->sim->/*app->*/mem_cell_changed(this, addr);//FIXME
+ return(cell);
+}
+
+
+void
+cl_address_space::set_brk(t_addr addr, class cl_brk *brk)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ return;
+ class cl_memory_cell *cell= cells[idx];
+ class cl_memory_operator *op;
+
+ switch (brk->get_event())
+ {
+ case brkWRITE: case brkWXRAM: case brkWIRAM: case brkWSFR:
+ //e= 'W';
+ op= new cl_write_operator(cell, addr, cell->get_data(), cell->get_mask(),
+ uc, brk);
+ break;
+ case brkREAD: case brkRXRAM: case brkRCODE: case brkRIRAM: case brkRSFR:
+ //e= 'R';
+ op= new cl_read_operator(cell, addr, cell->get_data(), cell->get_mask(),
+ uc, brk);
+ break;
+ case brkNONE:
+ set_cell_flag(addr, DD_TRUE, CELL_FETCH_BRK);
+ return;
+ break;
+ default:
+ //e= '.';
+ op= 0;
+ break;
+ }
+ if (op)
+ cell->append_operator(op);
+}
+
+void
+cl_address_space::del_brk(t_addr addr, class cl_brk *brk)
+{
+ t_addr idx= addr-start_address;
+ if (idx >= size ||
+ addr < start_address)
+ return;
+ class cl_memory_cell *cell= cells[idx];
+
+ switch (brk->get_event())
+ {
+ case brkWRITE: case brkWXRAM: case brkWIRAM: case brkWSFR:
+ case brkREAD: case brkRXRAM: case brkRCODE: case brkRIRAM: case brkRSFR:
+ cell->del_operator(brk);
+ break;
+ case brkNONE:
+ set_cell_flag(addr, DD_FALSE, CELL_FETCH_BRK);
+ return;
+ break;
+ default:
+ break;
+ }
+}
+
+
+/*
+ * List of address spaces
+ */
+
+cl_address_space_list::cl_address_space_list(class cl_uc *the_uc):
+ cl_list(2, 2, "address spaces")
+{
+ uc= the_uc;
+}
+
+t_index
+cl_address_space_list::add(class cl_address_space *mem)
+{
+ mem->set_uc(uc);
+ t_index ret= cl_list::add(mem);
+ if (uc)
+ {
+ class cl_event_address_space_added e(mem);
+ uc->handle_event(e);
+ }
+ return(ret);
+}
+
+
+/*
+ * Memory chip
+ */
+
+cl_memory_chip::cl_memory_chip(char *id, int asize, int awidth, int initial):
+ cl_memory(id, asize, awidth)
+{
+ array= (t_mem *)malloc(size * sizeof(t_mem));
+ init_value= initial;
+}
+
+cl_memory_chip::~cl_memory_chip(void)
+{
+ if (array)
+ free(array);
+}
+
+int
+cl_memory_chip::init(void)
+{
+ cl_memory::init();
+ int i;
+ for (i= 0; i < size; i++)
+ set(i,
+ (init_value<0)?rand():(init_value));
+ return(0);
+}
+
+
+t_mem *
+cl_memory_chip::get_slot(t_addr addr)
+{
+ if (!array ||
+ size <= addr)
+ return(0);
+ return(&array[addr]);
+}
+
+
+t_mem
+cl_memory_chip::get(t_addr addr)
+{
+ if (!array ||
+ size <= addr)
+ return(0);
+ return(array[addr]);
+}
+
+void
+cl_memory_chip::set(t_addr addr, t_mem val)
+{
+ if (!array ||
+ size <= addr)
+ return;
+ array[addr]= val & data_mask;
+}
+
+void
+cl_memory_chip::set_bit1(t_addr addr, t_mem bits)
+{
+ if (!array ||
+ size <= addr)
+ return;
+ array[addr]|= (bits & data_mask);
+}
+
+void
+cl_memory_chip::set_bit0(t_addr addr, t_mem bits)
+{
+ if (!array ||
+ size <= addr)
+ return;
+ array[addr]&= ((~bits) & data_mask);
+}
+
+
+/*
+ * Address decoder
+ */
+
+cl_address_decoder::cl_address_decoder(class cl_memory *as,
+ class cl_memory *chip,
+ t_addr asb, t_addr ase, t_addr cb)
+{
+ if (as->is_address_space())
+ address_space= (class cl_address_space *)as;
+ else
+ address_space= 0;
+ if (chip->is_chip())
+ memchip= (class cl_memory_chip *)chip;
+ else
+ memchip= 0;
+ as_begin= asb;
+ as_end= ase;
+ chip_begin= cb;
+ activated= DD_FALSE;
+}
+
+cl_address_decoder::~cl_address_decoder(void)
+{
+ t_addr a;
+ if (address_space)
+ for (a= as_begin; a <= as_end; a++)
+ address_space->undecode_cell(a);
+}
+
+int
+cl_address_decoder::init(void)
+{
+ return(0);
+}
+
+
+bool
+cl_address_decoder::activate(class cl_console *con)
+{
+#define D if (con) con->debug
+ D("Activation of an address decoder\n");
+ if (activated)
+ {
+ D("Already activated\n");
+ return(DD_FALSE);
+ }
+ if (!address_space ||
+ !address_space->is_address_space())
+ {
+ D("No or non address space\n");
+ return(DD_FALSE);
+ }
+ if (!memchip ||
+ !memchip->is_chip())
+ {
+ D("No or non memory chip\n");
+ return(DD_FALSE);
+ }
+ if (as_begin > as_end)
+ {
+ D("Wrong address area specification\n");
+ return(DD_FALSE);
+ }
+ if (chip_begin >= memchip->get_size())
+ {
+ D("Wrong chip area specification\n");
+ return(DD_FALSE);
+ }
+ if (as_begin < address_space->start_address ||
+ as_end >= address_space->start_address + address_space->get_size())
+ {
+ D("Specified area is out of address space\n");
+ return(DD_FALSE);
+ }
+ if (as_end-as_begin > memchip->get_size()-chip_begin)
+ {
+ D("Specified area is out of chip size\n");
+ return(DD_FALSE);
+ }
+
+ address_space->undecode_area(this, as_begin, as_end, con);
+
+ t_addr asa, ca;
+ for (asa= as_begin, ca= chip_begin;
+ asa <= as_end;
+ asa++, ca++)
+ {
+ if (!address_space->decode_cell(asa, memchip, ca))
+ {
+ D("Decoding 0x%06x->0x%06x failed\n", asa, ca);
+ }
+ }
+ activated= DD_TRUE;
+
+#undef D
+ return(activated);
+}
+
+
+bool
+cl_address_decoder::fully_covered_by(t_addr begin, t_addr end)
+{
+ if (begin <= as_begin &&
+ end >= as_end)
+ return(DD_TRUE);
+ return(DD_FALSE);
+}
+
+bool
+cl_address_decoder::is_in(t_addr begin, t_addr end)
+{
+ if (begin >= as_begin &&
+ begin <= as_end)
+ return(DD_TRUE);
+ if (end >= as_begin &&
+ end <= as_end)
+ return(DD_TRUE);
+ return(DD_FALSE);
+}
+
+bool
+cl_address_decoder::covers(t_addr begin, t_addr end)
+{
+ if (begin > as_begin &&
+ end < as_end)
+ return(DD_TRUE);
+ return(DD_FALSE);
+}
+
+
+/* Returns TRUE if shrunken decoder is unnecessary */
+
+bool
+cl_address_decoder::shrink_out_of(t_addr begin, t_addr end)
+{
+ t_addr a= as_begin;
+
+ if (!address_space)
+ return(DD_TRUE);
+ if (begin > a)
+ a= begin;
+ while (a <= end &&
+ a <= as_end)
+ {
+ address_space->undecode_cell(a);
+ a++;
+ }
+ if (begin > as_begin)
+ as_end= begin-1;
+ if (as_end > end)
+ {
+ chip_begin+= (end-as_begin+1);
+ as_begin= end+1;
+ }
+ if (as_end < as_begin)
+ return(DD_TRUE);
+ return(DD_FALSE);
+}
+
+class cl_address_decoder *
+cl_address_decoder::split(t_addr begin, t_addr end)
+{
+ class cl_address_decoder *nd= 0;
+ if (begin > as_begin)
+ {
+ if (as_end > end)
+ nd= new cl_address_decoder(address_space, memchip,
+ end+1, as_end, chip_begin+(end-as_begin)+1);
+ shrink_out_of(begin, as_end);
+ }
+ else if (end < as_end)
+ {
+ if (as_begin < begin)
+ nd= new cl_address_decoder(address_space, memchip,
+ as_begin, begin-1, chip_begin);
+ shrink_out_of(end+1, as_end);
+ }
+ if (nd)
+ nd->init();
+ return(nd);
+}
+
+
+/*
+ * List of address decoders
+ */
+
+cl_decoder_list::cl_decoder_list(t_index alimit, t_index adelta, bool bychip):
+ cl_sorted_list(alimit, adelta, "decoder list")
+{
+ Duplicates= DD_TRUE;
+ by_chip= bychip;
+}
+
+void *
+cl_decoder_list::key_of(void *item)
+{
+ class cl_address_decoder *d= (class cl_address_decoder *)item;
+ if (by_chip)
+ return(&(d->chip_begin));
+ else
+ return(&(d->as_begin));
+}
+
+int
+cl_decoder_list::compare(void *key1, void *key2)
+{
+ t_addr k1= *((t_addr*)key1), k2= *((t_addr*)key2);
+ if (k1 == k2)
+ return(0);
+ else if (k1 > k2)
+ return(1);
+ return(-1);
+}
+
+
+/*
+ * Errors in memory handling
+ */
+
+/* All of memory errors */
+
+cl_error_mem::cl_error_mem(class cl_memory *amem, t_addr aaddr)
+{
+ mem= amem;
+ addr= aaddr;
+ classification= mem_error_registry.find("memory");
+}
+
+/* Invalid address in memory access */
+
+cl_error_mem_invalid_address::
+cl_error_mem_invalid_address(class cl_memory *amem, t_addr aaddr):
+ cl_error_mem(amem, aaddr)
+{
+ classification= mem_error_registry.find("invalid_address");
+}
+
+void
+cl_error_mem_invalid_address::print(class cl_commander *c)
+{
+ FILE *f= c->get_out();
+ cmd_fprintf(f, "%s: invalid address ", get_type_name());
+ cmd_fprintf(f, mem->addr_format, addr);
+ cmd_fprintf(f, " in memory %s.\n", mem->get_name());
+}
+
+/* Non-decoded address space access */
+
+cl_error_mem_non_decoded::
+cl_error_mem_non_decoded(class cl_memory *amem, t_addr aaddr):
+ cl_error_mem(amem, aaddr)
+{
+ classification= mem_error_registry.find("non_decoded");
+}
+
+void
+cl_error_mem_non_decoded::print(class cl_commander *c)