else	sym_name= 0;    }  if (!sym_name)    {      sym_name= (char *)malloc(16);      sprintf(sym_name, mem?(mem->addr_format):"0x%06x", mem_addr);    }  sym_name= (char *)realloc(sym_name, strlen(sym_name)+2);  strcat(sym_name, ".");  i= 0;  while (bit_mask > 1)    {      bit_mask>>=1;      i++;    }  char bitnumstr[10];  sprintf(bitnumstr, "%1d", i);  strcat(sym_name, bitnumstr);  return(sym_name);}/* * Messages to broadcast */voidcl_uc::mem_cell_changed(class cl_mem *mem, t_addr addr){  if (hws)    hws->mem_cell_changed(mem, addr);  else    printf("JAJ uc\n");//FIXME  if (mems &&      mems->count)    {      int i;      for (i= 0; i < mems->count; i++)	{	}    }}/* * Error handling */voidcl_uc::error(class cl_error *error){  errors->add(error);  if ((error->inst= inst_exec))    error->PC= instPC;}voidcl_uc::check_errors(void){  int i;  class cl_commander *c= sim->app->get_commander();  if (c)    {      for (i= 0; i < errors->count; i++)	{	  class cl_error *error= (class cl_error *)(errors->at(i));	  error->print(c);	  if (error->inst)	    {	      class cl_console *con;	      con= c->actual_console;	      if (!con)		con= c->frozen_console;	      if (con)		print_disass(error->PC, con);	    }	}      errors->free_all();    }  else    fprintf(stderr, "no actual console, %d errors\n", errors->count);}/* * Converting bit address into real memory */class cl_mem *cl_uc::bit2mem(t_addr bitaddr, t_addr *memaddr, t_mem *bitmask){  if (memaddr)    *memaddr= bitaddr;  if (bitmask)    *bitmask= 1 << (bitaddr & 0x7);  return(0); // abstract...}/* * Execution */intcl_uc::tick_hw(int cycles){  class cl_hw *hw;  int i;//, cpc= clock_per_cycle();  // tick hws  for (i= 0; i < hws->count; i++)    {      hw= (class cl_hw *)(hws->at(i));      if (hw->flags & HWF_INSIDE)	hw->tick(cycles);    }  do_extra_hw(cycles);  return(0);}voidcl_uc::do_extra_hw(int cycles){}intcl_uc::tick(int cycles){  //class cl_hw *hw;  int i, cpc= clock_per_cycle();  // increase time  ticks->tick(cycles * cpc);  class it_level *il= (class it_level *)(it_levels->top());  if (il->level >= 0)    isr_ticks->tick(cycles * cpc);  if (state == stIDLE)    idle_ticks->tick(cycles * cpc);  for (i= 0; i < counters->count; i++)    {      class cl_ticker *t= (class cl_ticker *)(counters->at(i));      if (t)	{	  if ((t->options&TICK_INISR) ||	      il->level < 0)	    t->tick(cycles * cpc);	}    }  // tick for hardwares  inst_ticks+= cycles;  return(0);}class cl_ticker *cl_uc::get_counter(int nr){  if (nr >= counters->count)    return(0);  return((class cl_ticker *)(counters->at(nr)));}class cl_ticker *cl_uc::get_counter(char *nam){  int i;  if (!nam)    return(0);  for (i= 0; i < counters->count; i++)    {      class cl_ticker *t= (class cl_ticker *)(counters->at(i));      if (t &&	  t->get_name() &&	  strcmp(t->get_name(), nam) == 0)	return(t);    }  return(0);}voidcl_uc::add_counter(class cl_ticker *ticker, int nr){  while (counters->count <= nr)    counters->add(0);  counters->put_at(nr, ticker);}voidcl_uc::add_counter(class cl_ticker *ticker, char */*nam*/){  int i;  if (counters->count < 1)    counters->add(0);  for (i= 1; i < counters->count; i++)    {      class cl_ticker *t= (class cl_ticker *)(counters->at(i));      if (!t)	{	  counters->put_at(i, ticker);	  return;	}    }  counters->add(ticker);}voidcl_uc::del_counter(int nr){  class cl_ticker *t;  if (nr >= counters->count)    return;  if ((t= (class cl_ticker *)(counters->at(0))) != 0)    delete t;  counters->put_at(nr, 0);}voidcl_uc::del_counter(char *nam){  int i;    if (!nam)    return;  for (i= 0; i < counters->count; i++)    {      class cl_ticker *t= (class cl_ticker *)(counters->at(i));      if (t &&	  t->get_name() &&	  strcmp(t->get_name(), nam) == 0)	{	  delete t;	  counters->put_at(i, 0);	  return;	}    }}/* * Fetch without checking for breakpoint hit */t_memcl_uc::fetch(void){  ulong code;  code= read_mem(MEM_ROM, PC);  PC++;  if (PC >= get_mem_size(MEM_ROM))    PC= 0;  return(code);}/* * Fetch but checking for breakpoint hit first, returns TRUE if * a breakpoint is hit */boolcl_uc::fetch(t_mem *code){  class cl_brk *brk;  int idx;  if (!code)    return(0);  if (sim->state & SIM_GO)    {      if (mem(MEM_ROM)->get_cell_flag(PC, CELL_FETCH_BRK) &&	  (brk= fbrk->get_bp(PC, &idx)) &&	  (brk->do_hit()))	{	  if (brk->perm == brkDYNAMIC)	    fbrk->del_bp(PC);	  return(1);	}    }  *code= fetch();  return(0);}intcl_uc::do_inst(int step){  int res= resGO;  if (step < 0)    step= 1;  while (step-- &&	 res == resGO)    {      pre_inst();      res= exec_inst();      post_inst();    }  if (res != resGO)    sim->stop(res);  return(res);}voidcl_uc::pre_inst(void){  inst_exec= DD_TRUE;  inst_ticks= 0;  events->disconn_all();}intcl_uc::exec_inst(void){  instPC= PC;  return(resGO);}voidcl_uc::post_inst(void){  tick_hw(inst_ticks);  if (errors->count)    check_errors();  if (events->count)    check_events();  inst_exec= DD_FALSE;}/* * Time related functions */doublecl_uc::get_rtime(void){  /*  double d;  d= (double)ticks/xtal;  return(d);*/  return(ticks->get_rtime(xtal));}intcl_uc::clock_per_cycle(void){  return(1);}/* * Stack tracking system */voidcl_uc::st_push(class cl_stack_op *op){  st_ops->push(op);}voidcl_uc::st_call(class cl_stack_op *op){  st_ops->push(op);}intcl_uc::st_pop(class cl_stack_op *op){  class cl_stack_op *sop= (class cl_stack_op *)(st_ops->pop());  if (!sop)    return(1);  return(0);}intcl_uc::st_ret(class cl_stack_op *op){  class cl_stack_op *sop= (class cl_stack_op *)(st_ops->pop());  if (!sop)    return(1);  return(0);}/* * Breakpoint handling */class cl_fetch_brk *cl_uc::fbrk_at(t_addr addr){  int idx;    return((class cl_fetch_brk *)(fbrk->get_bp(addr, &idx)));}class cl_ev_brk *cl_uc::ebrk_at(t_addr addr, char *id){  int i;  class cl_ev_brk *eb;  for (i= 0; i < ebrk->count; i++)    {      eb= (class cl_ev_brk *)(ebrk->at(i));      if (eb->addr == addr &&	  !strcmp(eb->id, id))	return(eb);    }  return(0);}/*voidcl_uc::rm_fbrk(long addr){  fbrk->del_bp(addr);}*//* Get a breakpoint specified by its number */class cl_brk *cl_uc::brk_by_nr(int nr){  class cl_brk *bp;  if ((bp= fbrk->get_bp(nr)))    return(bp);  if ((bp= ebrk->get_bp(nr)))    return(bp);  return(0);}/* Get a breakpoint from the specified collection by its number */class cl_brk *cl_uc::brk_by_nr(class brk_coll *bpcoll, int nr){  class cl_brk *bp;  if ((bp= bpcoll->get_bp(nr)))    return(bp);  return(0);}/* Remove an event breakpoint specified by its address and id */voidcl_uc::rm_ebrk(t_addr addr, char *id){  int i;  class cl_ev_brk *eb;  for (i= 0; i < ebrk->count; i++)    {      eb= (class cl_ev_brk *)(ebrk->at(i));      if (eb->addr == addr &&	  !strcmp(eb->id, id))	ebrk->del_bp(i, 0);    }}/* Remove a breakpoint specified by its number */boolcl_uc::rm_brk(int nr){  class cl_brk *bp;  if ((bp= brk_by_nr(fbrk, nr)))    {      fbrk->del_bp(bp->addr);      return(DD_TRUE);    }  else if ((bp= brk_by_nr(ebrk, nr)))    {      ebrk->del_bp(ebrk->index_of(bp), 0);      return(DD_TRUE);    }  return(DD_FALSE);}voidcl_uc::put_breaks(void){}/* Remove all fetch and event breakpoints */voidcl_uc::remove_all_breaks(void){  while (fbrk->count)    {      class cl_brk *brk= (class cl_brk *)(fbrk->at(0));      fbrk->del_bp(brk->addr);    }  while (ebrk->count)    ebrk->del_bp(ebrk->count-1, 0);}intcl_uc::make_new_brknr(void){  if (brk_counter == 0)    return(brk_counter= 1);  if (fbrk->count == 0 &&      ebrk->count == 0)    return(brk_counter= 1);  return(++brk_counter);}class cl_ev_brk *cl_uc::mk_ebrk(enum brk_perm perm, class cl_mem *mem,	       char op, t_addr addr, int hit){  class cl_ev_brk *b;  op= toupper(op);  b= new cl_ev_brk(mem, make_new_brknr(), addr, perm, hit, op);  b->init();  return(b);}voidcl_uc::check_events(void){  sim->stop(resBREAKPOINT);}/* End of uc.cc */