mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

enhances to gui debugger and integrated debugger

Browse Source
This commit is contained in:
Stanislav Shwartsman 2009-08-07 08:26:41 +00:00
parent b19da50414
commit e912b328c2
8 changed files with 1997 additions and 1964 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
bochs/bx_debug/dbg_main.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: dbg_main.cc,v 1.199 2009-07-07 04:56:07 sshwarts Exp $
// $Id: dbg_main.cc,v 1.200 2009-08-07 08:26:41 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -737,6 +737,23 @@ void bx_dbg_info_flags(void)
BX_CPU(dbg_cpu)->get_CF() ? "CF" : "cf");
}
void bx_dbg_info_debug_regs_command(void)
{
bx_address dr0 = SIM->get_param_num("DR0", dbg_cpu_list)->get();
bx_address dr1 = SIM->get_param_num("DR1", dbg_cpu_list)->get();
bx_address dr2 = SIM->get_param_num("DR1", dbg_cpu_list)->get();
bx_address dr3 = SIM->get_param_num("DR1", dbg_cpu_list)->get();
Bit32u dr6 = SIM->get_param_num("DR6", dbg_cpu_list)->get();
Bit32u dr7 = SIM->get_param_num("DR7", dbg_cpu_list)->get();
dbg_printf("DR0=0x" FMT_ADDRX "\n", dr0);
dbg_printf("DR1=0x" FMT_ADDRX "\n", dr1);
dbg_printf("DR2=0x" FMT_ADDRX "\n", dr2);
dbg_printf("DR3=0x" FMT_ADDRX "\n", dr3);
dbg_printf("DR6=0x08x\n", dr6);
dbg_printf("DR7=0x08x\n", dr7);
}
void bx_dbg_info_control_regs_command(void)
{
Bit32u cr0 = SIM->get_param_num("CR0", dbg_cpu_list)->get();
@ -1131,7 +1148,7 @@ void bx_dbg_modebp_command()
BX_CPU(dbg_cpu)->mode_break ? "enabled" : "disabled");
}
static bx_bool bx_dbg_read_linear(unsigned which_cpu, bx_address laddr, unsigned len, Bit8u *buf)
bx_bool bx_dbg_read_linear(unsigned which_cpu, bx_address laddr, unsigned len, Bit8u *buf)
{
unsigned remainsInPage;
bx_phy_address paddr;
@ -2771,15 +2788,15 @@ void bx_dbg_print_descriptor(unsigned char desc[8])
// either a code or a data segment. bit 11 (type file MSB) then says
// 0=data segment, 1=code seg
if (type&8) {
dbg_printf("Code segment, laddr=%08x, limit=%05x %s, %s%s%s, %d-bit\n",
base, limit, g ? "* 4Kbytes" : "bytes",
dbg_printf("Code segment, laddr=0x%08x, limit=0x%08x, %s%s%s, %d-bit\n",
base, g ? (limit * 4096 + 4095) : limit,
(type&2)? "Execute/Read" : "Execute-Only",
(type&4)? ", Conforming" : "",
(type&1)? ", Accessed" : "",
d_b ? 32 : 16);
} else {
dbg_printf("Data segment, laddr=%08x, limit=%05x %s, %s%s%s\n",
base, limit, g ? "* 4Kbytes" : "bytes",
dbg_printf("Data segment, laddr=0x%08x, limit=0x%08x, %s%s%s\n",
base, g ? (limit * 4096 + 4095) : limit,
(type&2)? "Read/Write" : "Read-Only",
(type&4)? ", Expand-down" : "",
(type&1)? ", Accessed" : "");

4
bochs/bx_debug/debug.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: debug.h,v 1.54 2009-05-03 19:29:19 sshwarts Exp $
// $Id: debug.h,v 1.55 2009-08-07 08:26:41 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -205,6 +205,7 @@ extern void bxerror(char *s);
#define EMPTY_ARG (-1)
bx_bool bx_dbg_read_linear(unsigned which_cpu, bx_address laddr, unsigned len, Bit8u *buf);
Bit16u bx_dbg_get_selector_value(unsigned int seg_no);
Bit16u bx_dbg_get_ip (void);
Bit32u bx_dbg_get_eip(void);
@ -272,6 +273,7 @@ void bx_dbg_info_idt_command(unsigned from, unsigned to);
void bx_dbg_info_gdt_command(unsigned from, unsigned to);
void bx_dbg_info_ldt_command(unsigned from, unsigned to);
void bx_dbg_info_tss_command(void);
void bx_dbg_info_debug_regs_command(void);
void bx_dbg_info_control_regs_command(void);
void bx_dbg_info_segment_regs_command(void);
void bx_dbg_info_flags(void);

1203
bochs/bx_debug/lexer.c
View File

File diff suppressed because it is too large Load Diff

10
bochs/bx_debug/lexer.l
View File

@ -1,6 +1,6 @@
%{
/////////////////////////////////////////////////////////////////////////
// $Id: lexer.l,v 1.29 2009-04-07 16:12:19 sshwarts Exp $
// $Id: lexer.l,v 1.30 2009-08-07 08:26:41 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
#include <stdlib.h>
@ -71,10 +71,10 @@ b|pb |
pbreak { bxlval.sval = strdup(bxtext); return(BX_TOKEN_PBREAKPOINT); }
info { bxlval.sval = strdup(bxtext); return(BX_TOKEN_INFO); }
cr |
creg |
cregs { bxlval.sval = strdup(bxtext); return(BX_TOKEN_CONTROL_REGS); }
sreg |
sregs { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SEGMENT_REGS); }
creg { bxlval.sval = strdup(bxtext); return(BX_TOKEN_CONTROL_REGS); }
dr |
dreg { bxlval.sval = strdup(bxtext); return(BX_TOKEN_DEBUG_REGS); }
sreg { bxlval.sval = strdup(bxtext); return(BX_TOKEN_SEGMENT_REGS); }
r { bxlval.sval = strdup(bxtext); return(BX_TOKEN_R); }
reg|regs |
registers { bxlval.sval = strdup(bxtext); return(BX_TOKEN_REGS); }

2413
bochs/bx_debug/parser.c
View File

File diff suppressed because it is too large Load Diff

240
bochs/bx_debug/parser.h
View File

@ -82,65 +82,66 @@
BX_TOKEN_TAB = 298,
BX_TOKEN_DIRTY = 299,
BX_TOKEN_LINUX = 300,
BX_TOKEN_CONTROL_REGS = 301,
BX_TOKEN_SEGMENT_REGS = 302,
BX_TOKEN_EXAMINE = 303,
BX_TOKEN_XFORMAT = 304,
BX_TOKEN_DISFORMAT = 305,
BX_TOKEN_RESTORE = 306,
BX_TOKEN_SETPMEM = 307,
BX_TOKEN_SYMBOLNAME = 308,
BX_TOKEN_QUERY = 309,
BX_TOKEN_PENDING = 310,
BX_TOKEN_TAKE = 311,
BX_TOKEN_DMA = 312,
BX_TOKEN_IRQ = 313,
BX_TOKEN_DISASSEMBLE = 314,
BX_TOKEN_INSTRUMENT = 315,
BX_TOKEN_STRING = 316,
BX_TOKEN_STOP = 317,
BX_TOKEN_DOIT = 318,
BX_TOKEN_CRC = 319,
BX_TOKEN_TRACE = 320,
BX_TOKEN_TRACEREG = 321,
BX_TOKEN_TRACEMEM = 322,
BX_TOKEN_SWITCH_MODE = 323,
BX_TOKEN_SIZE = 324,
BX_TOKEN_PTIME = 325,
BX_TOKEN_TIMEBP_ABSOLUTE = 326,
BX_TOKEN_TIMEBP = 327,
BX_TOKEN_RECORD = 328,
BX_TOKEN_PLAYBACK = 329,
BX_TOKEN_MODEBP = 330,
BX_TOKEN_PRINT_STACK = 331,
BX_TOKEN_WATCH = 332,
BX_TOKEN_UNWATCH = 333,
BX_TOKEN_READ = 334,
BX_TOKEN_WRITE = 335,
BX_TOKEN_SHOW = 336,
BX_TOKEN_LOAD_SYMBOLS = 337,
BX_TOKEN_SYMBOLS = 338,
BX_TOKEN_LIST_SYMBOLS = 339,
BX_TOKEN_GLOBAL = 340,
BX_TOKEN_WHERE = 341,
BX_TOKEN_PRINT_STRING = 342,
BX_TOKEN_NUMERIC = 343,
BX_TOKEN_NE2000 = 344,
BX_TOKEN_PIC = 345,
BX_TOKEN_PAGE = 346,
BX_TOKEN_HELP = 347,
BX_TOKEN_CALC = 348,
BX_TOKEN_VGA = 349,
BX_TOKEN_PCI = 350,
BX_TOKEN_COMMAND = 351,
BX_TOKEN_GENERIC = 352,
BX_TOKEN_RSHIFT = 353,
BX_TOKEN_LSHIFT = 354,
BX_TOKEN_REG_IP = 355,
BX_TOKEN_REG_EIP = 356,
BX_TOKEN_REG_RIP = 357,
NEG = 358,
NOT = 359
BX_TOKEN_DEBUG_REGS = 301,
BX_TOKEN_CONTROL_REGS = 302,
BX_TOKEN_SEGMENT_REGS = 303,
BX_TOKEN_EXAMINE = 304,
BX_TOKEN_XFORMAT = 305,
BX_TOKEN_DISFORMAT = 306,
BX_TOKEN_RESTORE = 307,
BX_TOKEN_SETPMEM = 308,
BX_TOKEN_SYMBOLNAME = 309,
BX_TOKEN_QUERY = 310,
BX_TOKEN_PENDING = 311,
BX_TOKEN_TAKE = 312,
BX_TOKEN_DMA = 313,
BX_TOKEN_IRQ = 314,
BX_TOKEN_DISASSEMBLE = 315,
BX_TOKEN_INSTRUMENT = 316,
BX_TOKEN_STRING = 317,
BX_TOKEN_STOP = 318,
BX_TOKEN_DOIT = 319,
BX_TOKEN_CRC = 320,
BX_TOKEN_TRACE = 321,
BX_TOKEN_TRACEREG = 322,
BX_TOKEN_TRACEMEM = 323,
BX_TOKEN_SWITCH_MODE = 324,
BX_TOKEN_SIZE = 325,
BX_TOKEN_PTIME = 326,
BX_TOKEN_TIMEBP_ABSOLUTE = 327,
BX_TOKEN_TIMEBP = 328,
BX_TOKEN_RECORD = 329,
BX_TOKEN_PLAYBACK = 330,
BX_TOKEN_MODEBP = 331,
BX_TOKEN_PRINT_STACK = 332,
BX_TOKEN_WATCH = 333,
BX_TOKEN_UNWATCH = 334,
BX_TOKEN_READ = 335,
BX_TOKEN_WRITE = 336,
BX_TOKEN_SHOW = 337,
BX_TOKEN_LOAD_SYMBOLS = 338,
BX_TOKEN_SYMBOLS = 339,
BX_TOKEN_LIST_SYMBOLS = 340,
BX_TOKEN_GLOBAL = 341,
BX_TOKEN_WHERE = 342,
BX_TOKEN_PRINT_STRING = 343,
BX_TOKEN_NUMERIC = 344,
BX_TOKEN_NE2000 = 345,
BX_TOKEN_PIC = 346,
BX_TOKEN_PAGE = 347,
BX_TOKEN_HELP = 348,
BX_TOKEN_CALC = 349,
BX_TOKEN_VGA = 350,
BX_TOKEN_PCI = 351,
BX_TOKEN_COMMAND = 352,
BX_TOKEN_GENERIC = 353,
BX_TOKEN_RSHIFT = 354,
BX_TOKEN_LSHIFT = 355,
BX_TOKEN_REG_IP = 356,
BX_TOKEN_REG_EIP = 357,
BX_TOKEN_REG_RIP = 358,
NEG = 359,
NOT = 360
};
#endif
/* Tokens. */
@ -187,65 +188,66 @@
#define BX_TOKEN_TAB 298
#define BX_TOKEN_DIRTY 299
#define BX_TOKEN_LINUX 300
#define BX_TOKEN_CONTROL_REGS 301
#define BX_TOKEN_SEGMENT_REGS 302
#define BX_TOKEN_EXAMINE 303
#define BX_TOKEN_XFORMAT 304
#define BX_TOKEN_DISFORMAT 305
#define BX_TOKEN_RESTORE 306
#define BX_TOKEN_SETPMEM 307
#define BX_TOKEN_SYMBOLNAME 308
#define BX_TOKEN_QUERY 309
#define BX_TOKEN_PENDING 310
#define BX_TOKEN_TAKE 311
#define BX_TOKEN_DMA 312
#define BX_TOKEN_IRQ 313
#define BX_TOKEN_DISASSEMBLE 314
#define BX_TOKEN_INSTRUMENT 315
#define BX_TOKEN_STRING 316
#define BX_TOKEN_STOP 317
#define BX_TOKEN_DOIT 318
#define BX_TOKEN_CRC 319
#define BX_TOKEN_TRACE 320
#define BX_TOKEN_TRACEREG 321
#define BX_TOKEN_TRACEMEM 322
#define BX_TOKEN_SWITCH_MODE 323
#define BX_TOKEN_SIZE 324
#define BX_TOKEN_PTIME 325
#define BX_TOKEN_TIMEBP_ABSOLUTE 326
#define BX_TOKEN_TIMEBP 327
#define BX_TOKEN_RECORD 328
#define BX_TOKEN_PLAYBACK 329
#define BX_TOKEN_MODEBP 330
#define BX_TOKEN_PRINT_STACK 331
#define BX_TOKEN_WATCH 332
#define BX_TOKEN_UNWATCH 333
#define BX_TOKEN_READ 334
#define BX_TOKEN_WRITE 335
#define BX_TOKEN_SHOW 336
#define BX_TOKEN_LOAD_SYMBOLS 337
#define BX_TOKEN_SYMBOLS 338
#define BX_TOKEN_LIST_SYMBOLS 339
#define BX_TOKEN_GLOBAL 340
#define BX_TOKEN_WHERE 341
#define BX_TOKEN_PRINT_STRING 342
#define BX_TOKEN_NUMERIC 343
#define BX_TOKEN_NE2000 344
#define BX_TOKEN_PIC 345
#define BX_TOKEN_PAGE 346
#define BX_TOKEN_HELP 347
#define BX_TOKEN_CALC 348
#define BX_TOKEN_VGA 349
#define BX_TOKEN_PCI 350
#define BX_TOKEN_COMMAND 351
#define BX_TOKEN_GENERIC 352
#define BX_TOKEN_RSHIFT 353
#define BX_TOKEN_LSHIFT 354
#define BX_TOKEN_REG_IP 355
#define BX_TOKEN_REG_EIP 356
#define BX_TOKEN_REG_RIP 357
#define NEG 358
#define NOT 359
#define BX_TOKEN_DEBUG_REGS 301
#define BX_TOKEN_CONTROL_REGS 302
#define BX_TOKEN_SEGMENT_REGS 303
#define BX_TOKEN_EXAMINE 304
#define BX_TOKEN_XFORMAT 305
#define BX_TOKEN_DISFORMAT 306
#define BX_TOKEN_RESTORE 307
#define BX_TOKEN_SETPMEM 308
#define BX_TOKEN_SYMBOLNAME 309
#define BX_TOKEN_QUERY 310
#define BX_TOKEN_PENDING 311
#define BX_TOKEN_TAKE 312
#define BX_TOKEN_DMA 313
#define BX_TOKEN_IRQ 314
#define BX_TOKEN_DISASSEMBLE 315
#define BX_TOKEN_INSTRUMENT 316
#define BX_TOKEN_STRING 317
#define BX_TOKEN_STOP 318
#define BX_TOKEN_DOIT 319
#define BX_TOKEN_CRC 320
#define BX_TOKEN_TRACE 321
#define BX_TOKEN_TRACEREG 322
#define BX_TOKEN_TRACEMEM 323
#define BX_TOKEN_SWITCH_MODE 324
#define BX_TOKEN_SIZE 325
#define BX_TOKEN_PTIME 326
#define BX_TOKEN_TIMEBP_ABSOLUTE 327
#define BX_TOKEN_TIMEBP 328
#define BX_TOKEN_RECORD 329
#define BX_TOKEN_PLAYBACK 330
#define BX_TOKEN_MODEBP 331
#define BX_TOKEN_PRINT_STACK 332
#define BX_TOKEN_WATCH 333
#define BX_TOKEN_UNWATCH 334
#define BX_TOKEN_READ 335
#define BX_TOKEN_WRITE 336
#define BX_TOKEN_SHOW 337
#define BX_TOKEN_LOAD_SYMBOLS 338
#define BX_TOKEN_SYMBOLS 339
#define BX_TOKEN_LIST_SYMBOLS 340
#define BX_TOKEN_GLOBAL 341
#define BX_TOKEN_WHERE 342
#define BX_TOKEN_PRINT_STRING 343
#define BX_TOKEN_NUMERIC 344
#define BX_TOKEN_NE2000 345
#define BX_TOKEN_PIC 346
#define BX_TOKEN_PAGE 347
#define BX_TOKEN_HELP 348
#define BX_TOKEN_CALC 349
#define BX_TOKEN_VGA 350
#define BX_TOKEN_PCI 351
#define BX_TOKEN_COMMAND 352
#define BX_TOKEN_GENERIC 353
#define BX_TOKEN_RSHIFT 354
#define BX_TOKEN_LSHIFT 355
#define BX_TOKEN_REG_IP 356
#define BX_TOKEN_REG_EIP 357
#define BX_TOKEN_REG_RIP 358
#define NEG 359
#define NOT 360
@ -259,7 +261,7 @@ typedef union YYSTYPE
bx_bool bval;
}
/* Line 1489 of yacc.c. */
#line 263 "y.tab.h"
#line 265 "y.tab.h"
YYSTYPE;
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1

12
bochs/bx_debug/parser.y
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: parser.y,v 1.34 2009-04-03 17:36:24 sshwarts Exp $
// $Id: parser.y,v 1.35 2009-08-07 08:26:41 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
%{
@ -65,6 +65,7 @@
%token <sval> BX_TOKEN_TAB
%token <sval> BX_TOKEN_DIRTY
%token <sval> BX_TOKEN_LINUX
%token <sval> BX_TOKEN_DEBUG_REGS
%token <sval> BX_TOKEN_CONTROL_REGS
%token <sval> BX_TOKEN_SEGMENT_REGS
%token <sval> BX_TOKEN_EXAMINE
@ -150,6 +151,7 @@ command:
| mmx_regs_command
| sse_regs_command
| segment_regs_command
| debug_regs_command
| control_regs_command
| blist_command
| slist_command
@ -679,6 +681,14 @@ control_regs_command:
}
;
debug_regs_command:
BX_TOKEN_DEBUG_REGS '\n'
{
bx_dbg_info_debug_regs_command();
free($1);
}
;
delete_command:
BX_TOKEN_DEL_BREAKPOINT BX_TOKEN_NUMERIC '\n'
{

50
bochs/gui/enh_dbg.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: enh_dbg.cc,v 1.15 2009-04-12 05:52:38 sshwarts Exp $
// $Id: enh_dbg.cc,v 1.16 2009-08-07 08:26:41 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// BOCHS ENHANCED DEBUGGER Ver 1.2
@ -497,27 +497,7 @@ void UpdateStatus()
// Note: laddr + len must not cross a 4K boundary -- otherwise, there are no limits
bx_bool ReadBxLMem(Bit64u laddr, unsigned len, Bit8u *buf)
{
bx_phy_address paddr;
bx_bool retval = TRUE;
// on same physical page as the last access?
if (laddr < ladrmin || laddr > ladrmax)
{
// No -- create a new translation offset for the new page.
if (laddr > (Bit64u) 0xffffffff && In64Mode == FALSE)
return FALSE;
bx_address la_4K = (bx_address) laddr & (~0xfff);
ladrmin = la_4K;
ladrmax = la_4K + 0xfff;
retval = BX_CPU(CurrentCPU)->dbg_xlate_linear2phy(la_4K, &paddr);
if (retval == FALSE)
return FALSE;
l_p_offset = la_4K - paddr;
}
paddr = (bx_phy_address)(laddr - l_p_offset);
if (len != 0)
retval = bx_mem.dbg_fetch_mem(BX_CPU(CurrentCPU), paddr, len, buf);
return retval;
return bx_dbg_read_linear(CurrentCPU, laddr, len, buf);
}
// binary conversion (and validity testing) on hex/decimal char string inputs
@ -944,7 +924,7 @@ void FillAsm(Bit64u LAddr, int MaxLines)
*(s++)= *(p++);
// load buffer, up to the next 4k boundary
len = 4096 - (((int) ReadAddr) & 0xfff); // calculate read amount
Go = ReadBxLMem (ReadAddr, len, (Bit8u *) s);
Go = ReadBxLMem(ReadAddr, len, (Bit8u *) s);
BufLen += len;
ReadAddr += len;
if (Go == FALSE)
@ -982,8 +962,8 @@ void FillAsm(Bit64u LAddr, int MaxLines)
while (len-- > 0)
{
i = (unsigned char) *(p++);
*(s++) = AsciiHex[ 2* i ];
*(s++) = AsciiHex[ 1+ 2*i ];
*(s++) = AsciiHex[2*i];
*(s++) = AsciiHex[2*i+1];
}
*s = 0; // zero terminate the "bytes" string
@ -1528,8 +1508,8 @@ void FillIDT()
k = 256;
for(i = 0 ; i < k ; i++)
{
idttxt[1] = AsciiHex[ 2* i ];
idttxt[2] = AsciiHex[ 1+ 2*i ];
idttxt[1] = AsciiHex[2*i];
idttxt[2] = AsciiHex[2*i+1];
idttxt[3] = 0;
if (ReadBxLMem(laddr, entrysize, idtbuf) == FALSE) // abort the current IDT dump on a memory error
{
@ -1713,7 +1693,7 @@ void FillStack()
{
unsigned int ReadSize = 0x1000 - i;
// read up to the 4K boundary, then try to read the last chunk
if (ReadBxLMem (StackLA, ReadSize, (Bit8u *) cp) == FALSE)
if (ReadBxLMem(StackLA, ReadSize, (Bit8u *) cp) == FALSE)
{
// no data to show -- just one error message
sprintf (cols[17],"illegal address");
@ -1722,12 +1702,12 @@ void FillStack()
EndListUpdate(DUMP_WND);
return;
}
LglAddy = ReadBxLMem (StackLA + ReadSize, len + i - 0x1000, (Bit8u *) cp + ReadSize);
LglAddy = ReadBxLMem(StackLA + ReadSize, len + i - 0x1000, (Bit8u *) cp + ReadSize);
if (LglAddy == FALSE)
len = ReadSize;
}
else
ReadBxLMem (StackLA, len, (Bit8u *) cp);
ReadBxLMem(StackLA, len, (Bit8u *) cp);
UpdateDisp = CpuModeChange; // calculate which stack entries have changed
cp = CurStack;
@ -1995,8 +1975,8 @@ void FillDataX(char* t, char C, bx_bool doHex)
if (doHex != FALSE)
{
*d = AsciiHex[ 2* (unsigned char)C ];
d[1] = AsciiHex[ 1+ 2* (unsigned char)C ];
*d = AsciiHex[2* (unsigned char)C];
d[1] = AsciiHex[2* (unsigned char)C + 1];
d[2] = 0;
if (isLittleEndian != FALSE) // little endian => reverse hex digits
{
@ -2320,9 +2300,9 @@ bx_bool InitDataDump(bx_bool isLinear, Bit64u newDS)
unsigned int len = (int) newDS & 0xfff;
unsigned int i = 4096 - len;
Bit64u h = newDS + i;
retval = ReadBxLMem (newDS,i,(Bit8u *)DataDump);
retval = ReadBxLMem(newDS,i,(Bit8u *)DataDump);
if (retval != FALSE && len != 0)
retval = ReadBxLMem (h,len,(Bit8u *)DataDump + i);
retval = ReadBxLMem(h,len,(Bit8u *)DataDump + i);
}
else
retval = (bx_bool) bx_mem.dbg_fetch_mem( BX_CPU(CurrentCPU),
@ -2756,7 +2736,7 @@ void SetMemLine(int L)
if (LinearDump != FALSE) // is h is a LINEAR address? Convert to physical!
{
// use the ReadBx function to calculate the lin->phys offset
if (ReadBxLMem (h,0,(Bit8u *)addrstr) == FALSE) // "read" 0 bytes
if (ReadBxLMem(h,0,(Bit8u *)addrstr) == FALSE) // "read" 0 bytes
err = 2;
else
h -= l_p_offset; // convert h to a physmem address