2 * Simulator of microcontrollers (uc.cc)
4 * Copyright (C) 1999,99 Drotos Daniel, Talker Bt.
6 * To contact author send email to drdani@mazsola.iit.uni-miskolc.hu
10 /* This file is part of microcontroller simulator: ucsim.
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.
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.
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
61 cl_ticker::cl_ticker(int adir, int in_isr, char *aname)
68 name= aname?strdup(aname):0;
71 cl_ticker::~cl_ticker(void)
78 cl_ticker::tick(int nr)
86 cl_ticker::get_rtime(double xtal)
90 d= (double)ticks/xtal;
95 cl_ticker::dump(int nr, double xtal, class cl_console *con)
97 con->dd_printf("timer #%d(\"%s\") %s%s: %g sec (%lu clks)\n",
98 nr, name?name:"unnamed",
99 (options&TICK_RUN)?"ON":"OFF",
100 (options&TICK_INISR)?",ISR":"",
101 get_rtime(xtal), ticks);
106 * Abstract microcontroller
107 ******************************************************************************
110 cl_uc::cl_uc(class cl_sim *asim):
115 mems= new cl_list(MEM_TYPES, 1);
117 options= new cl_list(2, 2);
118 for (i= MEM_ROM; i < MEM_TYPES; i++)
120 ticks= new cl_ticker(+1, 0, "time");
121 isr_ticks= new cl_ticker(+1, TICK_INISR, "isr");
122 idle_ticks= new cl_ticker(+1, TICK_IDLE, "idle");
123 counters= new cl_list(2, 2);
124 it_levels= new cl_list(2, 2);
125 it_sources= new cl_list(2, 2);
126 class it_level *il= new it_level(-1, 0, 0, 0);
128 st_ops= new cl_list(2, 2);
157 if (!(sim->app->args->arg_avail('X')) ||
158 sim->app->args->get_farg('X', 0) == 0)
161 xtal= sim->app->args->get_farg('X', 0);
162 for (mc= MEM_ROM; mc < MEM_TYPES; mc++)
164 class cl_mem *m= mk_mem((enum mem_class)mc,
165 get_id_string(mem_classes, mc));
168 ebrk= new brk_coll(2, 2, (class cl_rom *)mem(MEM_ROM));
169 fbrk= new brk_coll(2, 2, (class cl_rom *)mem(MEM_ROM));
170 fbrk->Duplicates= DD_FALSE;
174 class cl_cmdset *cs= sim->app->get_commander()->cmdset;
177 for (i= 0; i < sim->app->in_files->count; i++)
179 char *fname= (char *)(sim->app->in_files->at(i));
181 if ((l= read_hex_file(fname)) >= 0)
183 sim->app->get_commander()->all_printf("%ld words read from %s\n",
191 cl_uc::id_string(void)
193 return("unknown microcontroller");
205 idle_ticks->ticks= 0;
206 /*FIXME should we clear user counters?*/
207 il= (class it_level *)(it_levels->top());
211 il= (class it_level *)(it_levels->pop());
213 il= (class it_level *)(it_levels->top());
224 cl_uc::mk_mem(enum mem_class type, char *class_name)
228 if (get_mem_size(type) <= 0)
231 m= new cl_rom(get_mem_size(type), get_mem_width(type));
233 m= new cl_mem(type, get_id_string(mem_classes, type),
234 get_mem_size(type), get_mem_width(type));
240 cl_uc::get_mem_size(enum mem_class type)
244 case MEM_ROM: return(0x10000);
245 case MEM_XRAM: return(0x10000);
246 case MEM_IRAM: return(0x100);
247 case MEM_SFR: return(0x100);
255 cl_uc::get_mem_width(enum mem_class type)
261 cl_uc::mk_hw_elements(void)
266 cl_uc::build_cmdset(class cl_cmdset *cmdset)
269 class cl_cmdset *cset;
271 cmdset->add(cmd= new cl_state_cmd("state", 0,
272 "state State of microcontroller",
273 "long help of state"));
276 cmdset->add(cmd= new cl_file_cmd("file", 0,
277 "file \"FILE\" Load FILE into ROM",
278 "long help of file"));
280 cmd->add_name("load");
282 cmdset->add(cmd= new cl_dl_cmd("download", 0,
283 "download,dl Load (intel.hex) data",
284 "long help of download"));
288 cmdset->add(cmd= new cl_pc_cmd("pc", 0,
289 "pc [addr] Set/get PC",
293 cmdset->add(cmd= new cl_reset_cmd("reset", 0,
295 "long help of reset"));
298 cmdset->add(cmd= new cl_dump_cmd("dump", 0,
299 "dump memory_type [start [stop [bytes_per_line]]]\n"
300 " Dump memory of specified type\n"
301 "dump bit... Dump bits",
302 "long help of dump"));
305 cmdset->add(cmd= new cl_di_cmd("di", 0,
306 "di [start [stop]] Dump Internal RAM",
310 cmdset->add(cmd= new cl_dx_cmd("dx", 0,
311 "dx [start [stop]] Dump External RAM",
315 cmdset->add(cmd= new cl_ds_cmd("ds", 0,
316 "ds [start [stop]] Dump SFR",
320 cmdset->add(cmd= new cl_dch_cmd("dch", 0,
321 "dch [start [stop]] Dump code in hex form",
322 "long help of dch"));
325 cmdset->add(cmd= new cl_dc_cmd("dc", 0,
326 "dc [start [stop]] Dump code in disass form",
330 cmdset->add(cmd= new cl_disassemble_cmd("disassemble", 0,
331 "disassemble [start [offset [lines]]]\n"
333 "long help of disassemble"));
336 cmdset->add(cmd= new cl_fill_cmd("fill", 0,
337 "fill memory_type start end data\n"
338 " Fill memory region with data",
339 "long help of fill"));
342 cmdset->add(cmd= new cl_where_cmd("where", 0,
343 "where memory_type data...\n"
344 " Case unsensitive search for data",
345 "long help of where"));
348 cmdset->add(cmd= new cl_Where_cmd("Where", 0,
349 "Where memory_type data...\n"
350 " Case sensitive search for data",
351 "long help of Where"));
354 cmdset->add(cmd= new cl_break_cmd("break", 0,
355 "break addr [hit] Set fix breakpoint\n"
356 "break mem_type r|w addr [hit]\n"
357 " Set fix event breakpoint",
358 "long help of break"));
361 cmdset->add(cmd= new cl_tbreak_cmd("tbreak", 0,
362 "tbreak addr [hit] Set temporary breakpoint\n"
363 "tbreak mem_type r|w addr [hit]\n"
364 " Set temporary event breakpoint",
365 "long help of tbreak"));
368 cmdset->add(cmd= new cl_clear_cmd("clear", 0,
369 "clear [addr...] Clear fix breakpoint",
370 "long help of clear"));
373 cmdset->add(cmd= new cl_delete_cmd("delete", 0,
374 "delete [nr...] Delete breakpoint(s)",
375 "long help of clear"));
379 cset= new cl_cmdset();
381 cset->add(cmd= new cl_get_sfr_cmd("sfr", 0,
382 "get sfr address...\n"
383 " Get value of addressed SFRs",
384 "long help of get sfr"));
386 cset->add(cmd= new cl_get_option_cmd("option", 0,
388 " Get value of an option",
389 "long help of get option"));
392 cmdset->add(cmd= new cl_super_cmd("get", 0,
393 "get subcommand Get, see `get' command for more help",
394 "long help of get", cset));
398 cset= new cl_cmdset();
400 cset->add(cmd= new cl_set_mem_cmd("memory", 0,
401 "set memory memory_type address data...\n"
402 " Place list of data into memory",
403 "long help of set memory"));
405 cset->add(cmd= new cl_set_bit_cmd("bit", 0,
406 "set bit addr 0|1 Set specified bit to 0 or 1",
407 "long help of set bit"));
409 cset->add(cmd= new cl_set_port_cmd("port", 0,
410 "set port hw data Set data connected to port",
411 "long help of set port"));
413 cset->add(cmd= new cl_set_option_cmd("option", 0,
414 "set option name value\n"
415 " Set value of an option",
416 "long help of set option"));
419 cmdset->add(cmd= new cl_super_cmd("set", 0,
420 "set subcommand Set, see `set' command for more help",
421 "long help of set", cset));
425 cset= new cl_cmdset();
427 cset->add(cmd= new cl_info_bp_cmd("breakpoints", 0,
428 "info breakpoints Status of user-settable breakpoints",
429 "long help of info breakpoints"));
432 cset->add(cmd= new cl_info_reg_cmd("registers", 0,
433 "info registers List of integer registers and their contents",
434 "long help of info registers"));
436 cset->add(cmd= new cl_info_hw_cmd("hardware", 0,
437 "info hardware cathegory\n"
438 " Status of hardware elements of the CPU",
439 "long help of info hardware"));
440 cmd->add_name("h w");
443 cmdset->add(cmd= new cl_super_cmd("info", 0,
444 "info subcommand Information, see `info' command for more help",
445 "long help of info", cset));
448 cmdset->add(cmd= new cl_timer_cmd("timer", 0,
449 "timer a|d|g|r|s|v id [direction|value]\n"
450 " Timer add|del|get|run|stop|value",
451 "timer add|create|make id [direction] -- create a new timer\n"
452 "timer del id -- delete a timer\n"
453 "timer get id -- list timers\n"
454 "timer run id -- turn a timer ON\n"
455 "timer stop id -- turn a timer OFF\n"
456 "timer value id val -- set value of a timer to `val'"));
462 * Read/write simulated memory
466 cl_uc::read_mem(enum mem_class type, t_mem addr)
470 if ((m= (class cl_mem*)mems->at(type)))
471 return(m->read(addr));
473 fprintf(stderr, "cl_uc::read_mem(type= %d, 0x%06lx) TROUBLE\n", type, addr);
478 cl_uc::get_mem(enum mem_class type, t_addr addr)
482 if ((m= (class cl_mem*)mems->at(type)))
483 return(m->get(addr));
485 printf("cl_uc::get_mem(type= %d, 0x%06lx) TROUBLE\n", type, addr);
490 cl_uc::write_mem(enum mem_class type, t_addr addr, t_mem val)
494 if ((m= (class cl_mem*)mems->at(type)))
496 m->write(addr, &val);
500 else printf("cl_uc::write_mem(type= %d, 0x%06lx, 0x%lx) TROUBLE\n", type, addr, val);
504 cl_uc::set_mem(enum mem_class type, t_addr addr, t_mem val)
508 if ((m= (class cl_mem*)mems->at(type)))
511 else printf("cl_uc::set_mem(type= %d, 0x%06lx, 0x%lx) TROUBLE\n", type, addr, val);
515 cl_uc::mem(enum mem_class type)
517 if (mems->count < type)
519 {printf("TROUBLE\n"); return(0);
521 return((class cl_mem *)(mems->at(type)));
525 cl_uc::mem(char *class_name)
532 s= n= strdup(class_name);
541 for (i= 0; !found && i < mems->count; i++)
543 cl_mem *m= (cl_mem *)(mems->at(i));
548 s= mcn= strdup(m->class_name);
554 if (strstr(/*m->class_name*/mcn,/*class_name*/n) == /*m->class_name*/mcn)
568 cl_uc::MEM(enum mem_class type)
572 if ((m= mem(type)) == 0)
574 {printf("TROUBLE\n"); return(0);
576 return((TYPE_UBYTE *)(m->mem));
580 /* Local function for `read_hex_file' method to read some bytes */
583 ReadInt(FILE *f, bool *ok, int bytes)
591 if (fscanf(f, "%2c", &s2[0]) == EOF)
594 l= l*256 + strtol(s2, NULL, 16);
603 * Reading intel hexa file into EROM
604 *____________________________________________________________________________
606 * If parameter is a NULL pointer, this function reads data from `cmd_in'
611 cl_uc::read_hex_file(const char *name)
615 long written= 0, recnum= 0;
617 uchar dnum; // data number
618 uchar rtyp=0; // record type
619 uint addr= 0; // address
620 uchar rec[300]; // data record
621 uchar sum ; // checksum
629 sim->app->get_commander()->
630 dd_printf("cl_uc::read_hex_file File name not specified\n");
634 if ((f= fopen(name, "r")) == NULL)
636 fprintf(stderr, "Can't open `%s': %s\n", name, strerror(errno));
640 //memset(inst_map, '\0', sizeof(inst_map));
645 while (((c= getc(f)) != ':') &&
648 {fprintf(stderr, ": not found\n");break;}
650 dnum= ReadInt(f, &ok, 1);//printf("dnum=%02x",dnum);
652 addr= ReadInt(f, &ok, 2);//printf("addr=%04x",addr);
654 chk+= ((addr >> 8) & 0xff);
655 rtyp= ReadInt(f, &ok, 1);//printf("rtyp=%02x ",rtyp);
657 for (i= 0; ok && (i < dnum); i++)
659 rec[i]= ReadInt(f, &ok, 1);//printf("%02x",rec[i]);
664 sum= ReadInt(f, &ok, 1);//printf(" sum=%02x\n",sum);
667 if (((sum + chk) & 0xff) == 0)
671 if (get_mem_width(MEM_ROM) > 8)
673 for (i= 0; i < dnum; i++)
675 if (get_mem_width(MEM_ROM) <= 8)
677 set_mem(MEM_ROM, addr, rec[i]);
681 else if (get_mem_width(MEM_ROM) <= 16)
691 set_mem(MEM_ROM, addr, (high*256)+low);
700 if (sim->app->args->get_iarg('V', 0) &&
702 sim->app->get_commander()->
703 dd_printf("Unknown record type %d(0x%x)\n",
707 if (sim->app->args->get_iarg('V', 0))
708 sim->app->get_commander()->
709 dd_printf("Checksum error (%x instead of %x) in "
710 "record %ld.\n", chk, sum, recnum);
713 if (sim->app->args->get_iarg('V', 0))
714 sim->app->get_commander()->
715 dd_printf("Read error in record %ld.\n", recnum);
718 if (get_mem_width(MEM_ROM) > 8 &&
720 set_mem(MEM_ROM, addr, low);
724 if (sim->app->args->get_iarg('V', 0))
725 sim->app->get_commander()->dd_printf("%ld records have been read\n",
733 * Handling instruction map
735 * `inst_at' is checking if the specified address is in instruction
736 * map and `set_inst_at' marks the address in the map and
737 * `del_inst_at' deletes the mark. `there_is_inst' cheks if there is
738 * any mark in the map
742 cl_uc::inst_at(t_addr addr)
744 class cl_rom *rom= (class cl_rom *)mem(MEM_ROM);
748 return(rom->inst_map->get(addr));
752 cl_uc::set_inst_at(t_addr addr)
754 class cl_rom *rom= (class cl_rom *)mem(MEM_ROM);
757 rom->inst_map->set(addr);
761 cl_uc::del_inst_at(t_addr addr)
763 class cl_rom *rom= (class cl_rom *)mem(MEM_ROM);
766 rom->inst_map->clear(addr);
770 cl_uc::there_is_inst(void)
772 class cl_rom *rom= (class cl_rom *)mem(MEM_ROM);
776 return(!(rom->inst_map->empty()));
781 * Manipulating HW elements of the CPU
782 *****************************************************************************
785 /* Register callback hw objects for mem read/write */
788 cl_uc::register_hw_read(enum mem_class type, t_addr addr, class cl_hw *hw)
793 if ((m= (class cl_mem*)mems->at(type)))
795 if ((l= m->read_locs->get_loc(addr)) == 0)
797 l= new cl_memloc(addr);
799 m->read_locs->add(l);
804 printf("cl_uc::register_hw_read TROUBLE\n");
808 cl_uc::register_hw_write(enum mem_class type, t_addr addr, class cl_hw *hw)
812 /* Looking for a specific HW element */
815 cl_uc::get_hw(enum hw_cath cath, int *idx)
822 for (; i < hws->count; i++)
824 hw= (class cl_hw *)(hws->at(i));
825 if (hw->cathegory == cath)
836 cl_uc::get_hw(char *id_string, int *idx)
843 for (; i < hws->count; i++)
845 hw= (class cl_hw *)(hws->at(i));
846 if (strstr(hw->id_string, id_string) == hw->id_string)
857 cl_uc::get_hw(enum hw_cath cath, int hwid, int *idx)
864 hw= get_hw(cath, &i);
869 hw= get_hw(cath, &i);
878 cl_uc::get_hw(char *id_string, int hwid, int *idx)
885 hw= get_hw(id_string, &i);
890 hw= get_hw(id_string, &i);
900 * Help of the command interpreter
906 static struct dis_entry empty= { 0, 0, 0, 0, NULL };
913 static struct name_entry empty= { 0, 0 };
920 static struct name_entry empty= { 0, 0 };
925 cl_uc::disass(t_addr addr, char *sep)
929 buf= (char*)malloc(100);
930 strcpy(buf, "uc::do_disass unimplemented\n");
935 cl_uc::print_disass(t_addr addr, class cl_console *con)
940 class cl_mem *rom= mem(MEM_ROM);
941 t_mem code= get_mem(MEM_ROM, addr);
946 dis= disass(addr, NULL);
948 con->dd_printf("%c", (b->perm == brkFIX)?'F':'D');
951 con->dd_printf("%c ", inst_at(addr)?' ':'?');
952 con->dd_printf(rom->addr_format, addr); con->dd_printf(" ");
953 con->dd_printf(rom->data_format, code);
954 for (i= 1; i < inst_length(code); i++)
957 con->dd_printf(rom->data_format, get_mem(MEM_ROM, addr+i));
959 int li= longest_inst();
963 j= rom->width/4 + ((rom->width%4)?1:0) + 1;
965 con->dd_printf(" "), j--;
968 con->dd_printf(" %s\n", dis);
973 cl_uc::print_regs(class cl_console *con)
975 con->dd_printf("No registers\n");
979 cl_uc::inst_length(t_mem code)
981 struct dis_entry *tabl= dis_tbl();
984 for (i= 0; tabl[i].mnemonic && (code & tabl[i].mask) != tabl[i].code; i++) ;
985 return(tabl[i].mnemonic?tabl[i].length:1);
989 cl_uc::longest_inst(void)
991 struct dis_entry *de= dis_tbl();
997 if (de->length > max)
1005 cl_uc::get_name(t_addr addr, struct name_entry tab[], char *buf)
1010 while (tab[i].name &&
1011 (!(tab[i].cpu_type & type) ||
1012 (tab[i].addr != addr)))
1015 strcpy(buf, tab[i].name);
1016 return(tab[i].name != NULL);
1020 cl_uc::symbolic_bit_name(t_addr bit_address,
1029 while (bit_tbl()[i].name &&
1030 (bit_tbl()[i].addr != bit_address))
1032 if (bit_tbl()[i].name)
1034 sym_name= strdup(bit_tbl()[i].name);
1040 strstr(mem->class_name, "sfr") == mem->class_name)
1043 while (sfr_tbl()[i].name &&
1044 (sfr_tbl()[i].addr != mem_addr))
1046 if (sfr_tbl()[i].name)
1047 sym_name= strdup(sfr_tbl()[i].name);
1053 sym_name= (char *)malloc(16);
1054 sprintf(sym_name, mem?(mem->addr_format):"0x%06x", mem_addr);
1056 sym_name= (char *)realloc(sym_name, strlen(sym_name)+2);
1057 strcat(sym_name, ".");
1059 while (bit_mask > 1)
1065 sprintf(bitnumstr, "%1d", i);
1066 strcat(sym_name, bitnumstr);
1076 cl_uc::tick(int cycles)
1079 int i, cpc= clock_per_cycle();
1082 ticks->tick(cycles * cpc);
1083 class it_level *il= (class it_level *)(it_levels->top());
1085 isr_ticks->tick(cycles * cpc);
1086 if (state == stIDLE)
1087 idle_ticks->tick(cycles * cpc);
1088 for (i= 0; i < counters->count; i++)
1090 class cl_ticker *t= (class cl_ticker *)(counters->at(i));
1093 if ((t->options&TICK_INISR) ||
1095 t->tick(cycles * cpc);
1100 for (i= 0; i < hws->count; i++)
1102 hw= (class cl_hw *)(hws->at(i));
1103 if (hw->flags & HWF_INSIDE)
1110 cl_uc::get_counter(int nr)
1112 if (nr >= counters->count)
1114 return((class cl_ticker *)(counters->at(nr)));
1118 cl_uc::get_counter(char *name)
1124 for (i= 0; i < counters->count; i++)
1126 class cl_ticker *t= (class cl_ticker *)(counters->at(i));
1129 strcmp(t->name, name) == 0)
1136 cl_uc::add_counter(class cl_ticker *ticker, int nr)
1138 while (counters->count <= nr)
1140 counters->put_at(nr, ticker);
1144 cl_uc::add_counter(class cl_ticker *ticker, char */*name*/)
1148 if (counters->count < 1)
1150 for (i= 1; i < counters->count; i++)
1152 class cl_ticker *t= (class cl_ticker *)(counters->at(i));
1155 counters->put_at(i, ticker);
1159 counters->add(ticker);
1163 cl_uc::del_counter(int nr)
1167 if (nr >= counters->count)
1169 if ((t= (class cl_ticker *)(counters->at(0))) != 0)
1171 counters->put_at(nr, 0);
1175 cl_uc::del_counter(char *name)
1181 for (i= 0; i < counters->count; i++)
1183 class cl_ticker *t= (class cl_ticker *)(counters->at(i));
1186 strcmp(t->name, name) == 0)
1189 counters->put_at(i, 0);
1196 * Fetch without checking for breakpoint hit
1204 code= read_mem(MEM_ROM, PC);
1206 if (PC >= get_mem_size(MEM_ROM))
1212 * Fetch but checking for breakpoint hit first
1216 cl_uc::fetch(t_mem *code)
1223 if (sim->state & SIM_GO)
1225 if ((brk= fbrk->get_bp(PC, &idx)) &&
1228 if (brk->perm == brkDYNAMIC)
1238 cl_uc::do_inst(int step)
1257 cl_uc::pre_inst(void)
1261 cl_uc::exec_inst(void)
1267 cl_uc::post_inst(void)
1272 * Time related functions
1276 cl_uc::get_rtime(void)
1280 d= (double)ticks/xtal;
1282 return(ticks->get_rtime(xtal));
1286 cl_uc::clock_per_cycle(void)
1293 * Stack tracking system
1297 cl_uc::st_push(class cl_stack_op *op)
1303 cl_uc::st_call(class cl_stack_op *op)
1309 cl_uc::st_pop(class cl_stack_op *op)
1311 class cl_stack_op *sop= (class cl_stack_op *)(st_ops->pop());
1319 cl_uc::st_ret(class cl_stack_op *op)
1321 class cl_stack_op *sop= (class cl_stack_op *)(st_ops->pop());
1330 * Breakpoint handling
1333 class cl_fetch_brk *
1334 cl_uc::fbrk_at(t_addr addr)
1338 return((class cl_fetch_brk *)(fbrk->get_bp(addr, &idx)));
1342 cl_uc::ebrk_at(t_addr addr, char *id)
1345 class cl_ev_brk *eb;
1347 for (i= 0; i < ebrk->count; i++)
1349 eb= (class cl_ev_brk *)(ebrk->at(i));
1350 if (eb->addr == addr &&
1351 !strcmp(eb->id, id))
1358 cl_uc::rm_fbrk(long addr)
1363 /* Get a breakpoint specified by its number */
1366 cl_uc::brk_by_nr(int nr)
1370 if ((bp= fbrk->get_bp(nr)))
1372 if ((bp= ebrk->get_bp(nr)))
1377 /* Get a breakpoint from the specified collection by its number */
1380 cl_uc::brk_by_nr(class brk_coll *bpcoll, int nr)
1384 if ((bp= bpcoll->get_bp(nr)))
1389 /* Remove an event breakpoint specified by its address and id */
1392 cl_uc::rm_ebrk(t_addr addr, char *id)
1395 class cl_ev_brk *eb;
1397 for (i= 0; i < ebrk->count; i++)
1399 eb= (class cl_ev_brk *)(ebrk->at(i));
1400 if (eb->addr == addr &&
1401 !strcmp(eb->id, id))
1406 /* Remove a breakpoint specified by its number */
1409 cl_uc::rm_brk(int nr)
1413 if ((bp= brk_by_nr(fbrk, nr)))
1414 fbrk->del_bp(bp->addr);
1415 else if ((bp= brk_by_nr(ebrk, nr)))
1416 ebrk->free_at(ebrk->index_of(bp));
1420 cl_uc::put_breaks(void)
1423 /* Remove all fetch and event breakpoints */
1426 cl_uc::remove_all_breaks(void)
1430 class cl_brk *brk= (class cl_brk *)(fbrk->at(0));
1431 fbrk->del_bp(brk->addr);
1434 ebrk->free_at(ebrk->count-1);
1438 cl_uc::make_new_brknr(void)
1440 if (brk_counter == 0)
1441 return(brk_counter= 1);
1442 if (fbrk->count == 0 &&
1444 return(brk_counter= 1);
1445 return(++brk_counter);
1449 cl_uc::mk_ebrk(enum brk_perm perm, class cl_mem *mem,
1450 char op, t_addr addr, int hit)
1459 b= new cl_rc_brk(make_new_brknr(), addr, perm, hit);
1465 b= new cl_ri_brk(make_new_brknr(), addr, perm, hit);
1467 b= new cl_wi_brk(make_new_brknr(), addr, perm, hit);
1473 b= new cl_rx_brk(make_new_brknr(), addr, perm, hit);
1475 b= new cl_wx_brk(make_new_brknr(), addr, perm, hit);
1481 b= new cl_rs_brk(make_new_brknr(), addr, perm, hit);
1483 b= new cl_ws_brk(make_new_brknr(), addr, perm, hit);