Document Title

((dlite_check || dlite_active)                                  \
   ? __check_break((NPC), (ACCESS), (ADDR), (ICNT), (CYCLE))            \
   : FALSE)

01820 {
01821   struct dlite_break_t *bp;
01822 
01823   if (dlite_active)
01824     {
01825       /* single-stepping, break always */
01826       break_access = /* single step */0;
01827       return TRUE;
01828     }
01829   /* else, check for a breakpoint */
01830 
01831   for (bp=dlite_bps; bp != NULL; bp=bp->next)
01832     {
01833       switch (bp->range.start.ptype)
01834         {
01835         case pt_addr:
01836           if ((bp->class & ACCESS_EXEC)
01837               && !range_cmp_range(&bp->range, next_PC))
01838             {
01839               /* hit a code breakpoint */
01840               myfprintf(stdout,
01841                         "Stopping at code breakpoint #%d @ 0x%08p...\n",
01842                         bp->id, next_PC);
01843               break_access = ACCESS_EXEC;
01844               return TRUE;
01845             }
01846           if ((bp->class & ACCESS_READ)
01847               && ((access & ACCESS_READ)
01848                   && !range_cmp_range(&bp->range, addr)))
01849             {
01850               /* hit a read breakpoint */
01851               myfprintf(stdout,
01852                         "Stopping at read breakpoint #%d @ 0x%08p...\n",
01853                         bp->id, addr);
01854               break_access = ACCESS_READ;
01855               return TRUE;
01856             }
01857           if ((bp->class & ACCESS_WRITE)
01858               && ((access & ACCESS_WRITE)
01859                   && !range_cmp_range(&bp->range, addr)))
01860             {
01861               /* hit a write breakpoint */
01862               myfprintf(stdout,
01863                         "Stopping at write breakpoint #%d @ 0x%08p...\n",
01864                         bp->id, addr);
01865               break_access = ACCESS_WRITE;
01866               return TRUE;
01867             }
01868           break;
01869 
01870         case pt_inst:
01871           if (!range_cmp_range(&bp->range, icount))
01872             {
01873               /* hit a code breakpoint */
01874               fprintf(stdout,
01875                       "Stopping at inst count breakpoint #%d @ %.0f...\n",
01876                       bp->id, (double)icount);
01877               break_access = ACCESS_EXEC;
01878               return TRUE;
01879             }
01880           break;
01881 
01882         case pt_cycle:
01883           if (!range_cmp_range(&bp->range, cycle))
01884             {
01885               /* hit a code breakpoint */
01886               fprintf(stdout,
01887                       "Stopping at cycle count breakpoint #%d @ %.0f...\n",
01888                       bp->id, (double)cycle);
01889               break_access = ACCESS_EXEC;
01890               return TRUE;
01891             }
01892           break;
01893 
01894         default:
01895           panic("bogus range type");
01896         }
01897 
01898 
01899     }
01900 
01901   /* no matching breakpoint found */
01902   break_access = /* no break */0;
01903   return FALSE;
01904 }

02198 {
02199   /* architected state accessors */
02200   f_dlite_reg_obj = reg_obj;
02201   f_dlite_mem_obj = mem_obj;
02202   f_dlite_mstate_obj = mstate_obj;
02203 
02204   /* instantiate the expression evaluator */
02205   dlite_evaluator = eval_new(ident_evaluator, NULL);
02206 }

02260 {
02261   char buf[512], *err_str;
02262   int dbreak = (break_access & (ACCESS_READ|ACCESS_WRITE)) != 0;
02263   static char cmd[512] = "";
02264 
02265   dlite_active = TRUE;
02266   dlite_return = FALSE;
02267   dlite_status(regs_PC, next_PC, cycle, dbreak, regs, mem);
02268 
02269   while (dlite_active && !dlite_return)
02270     {
02271       fprintf(stdout, DLITE_PROMPT);
02272       fflush(stdout);
02273       fgets(buf, 512, stdin);
02274 
02275       /* chop */
02276       if (buf[strlen(buf)-1] == '\n')
02277         buf[strlen(buf)-1] = '\0';
02278 
02279       if (buf[0] != '\0')
02280         {
02281           /* use this command */
02282           strcpy(cmd, buf);
02283         }
02284       /* else, use last command */
02285 
02286       err_str = dlite_exec(cmd, regs, mem);
02287       if (err_str)
02288         fprintf(stdout, "Dlite: error: %s\n", err_str);
02289     }
02290 }

00892 {
00893   enum mem_cmd cmd;
00894 
00895   if (!is_write)
00896     cmd = Read;
00897   else
00898     cmd = Write;
00899 
00900 #if 0
00901   char *errstr;
00902   errstr = mem_valid(cmd, addr, nbytes, /* !declare */FALSE);
00903   if (errstr)
00904     return errstr;
00905 #endif
00906 
00907   /* else, no error, access memory */
00908   mem_access(mem, cmd, addr, p, nbytes);
00909 
00910   /* no error */
00911   return NULL;
00912 }

00920 {
00921   /* nada */
00922   fprintf(stream, "No machine state.\n");
00923 
00924   /* no error */
00925   return NULL;
00926 }

dlite.h File Reference

Defines

Typedefs

Functions

Variables

Define Documentation

Typedef Documentation

Function Documentation

Variable Documentation


	Department of Computer Science School of Engineering, University of Virginia 151 Engineer's Way, P.O. Box 400740 Charlottesville, Virginia 22904-4740 (434) 982-2200 Fax: (434) 982-2214