Retro/pcjs
Watch
1
0
Fork
You've already forked pcjs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Halt (for now) on any 80386 GP fault, and prevent SPACE from scrolling the page

Browse source
This commit is contained in:
Jeff Parsons 2015-08-07 00:15:29 -07:00
commit c2d9d6b25f
3 changed files with 37 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

36
modules/pcjs/lib/memory.js
View file

@ -528,14 +528,18 @@ Memory.prototype = {
if (cpu) this.cpu = cpu;
this.setReadAccess(Memory.afnChecked, false);
}
if (DEBUG && this.dbg) this.dbg.println("read breakpoint added to memory block " + str.toHex(this.addr));
if (DEBUG && this.dbg && this.dbg.messageEnabled(Messages.MEM)) {
this.dbg.printMessage("read breakpoint added to memory block " + str.toHex(this.addr), true);
}
}
else {
if (this.cWriteBreakpoints++ === 0) {
if (cpu) this.cpu = cpu;
this.setWriteAccess(Memory.afnChecked, false);
}
if (DEBUG && this.dbg) this.dbg.println("write breakpoint added to memory block " + str.toHex(this.addr));
if (DEBUG && this.dbg && this.dbg.messageEnabled(Messages.MEM)) {
this.dbg.printMessage("write breakpoint added to memory block " + str.toHex(this.addr), true);
}
}
},
/**
@ -558,14 +562,18 @@ Memory.prototype = {
if (!fWrite) {
if (--this.cReadBreakpoints === 0) {
this.resetReadAccess();
if (DEBUG && this.dbg) this.dbg.println("all read breakpoints removed from memory block " + str.toHex(this.addr));
if (DEBUG && this.dbg && this.dbg.messageEnabled(Messages.MEM)) {
this.dbg.printMessage("all read breakpoints removed from memory block " + str.toHex(this.addr), true);
}
}
Component.assert(this.cReadBreakpoints >= 0);
}
else {
if (--this.cWriteBreakpoints === 0) {
this.resetWriteAccess();
if (DEBUG && this.dbg) this.dbg.println("all write breakpoints removed from memory block " + str.toHex(this.addr));
if (DEBUG && this.dbg && this.dbg.messageEnabled(Messages.MEM)) {
this.dbg.printMessage("all write breakpoints removed from memory block " + str.toHex(this.addr), true);
}
}
Component.assert(this.cWriteBreakpoints >= 0);
}
@ -1105,9 +1113,8 @@ Memory.prototype = {
readShortLittleEndian: function readShortLittleEndian(off, addr) {
// DEBUG: Component.assert(off >= 0 && off < this.size - 1);
/*
* TODO: It remains to be seen if there's any advantage to checking the offset
* for an aligned read vs. always reading the bytes separately; it seems a safe bet
* for longs, but it's less clear for shorts.
* TODO: It remains to be seen if there's any advantage to checking the offset for an aligned read
* vs. always reading the bytes separately; it seems a safe bet for longs, but it's less clear for shorts.
*/
return (off & 0x1)? (this.ab[off] | (this.ab[off+1] << 8)) : this.aw[off >> 1];
},
@ -1134,9 +1141,8 @@ Memory.prototype = {
readLongLittleEndian: function readLongLittleEndian(off, addr) {
// DEBUG: Component.assert(off >= 0 && off < this.size - 3);
/*
* TODO: It remains to be seen if there's any advantage to checking the offset
* for an aligned read vs. always reading the bytes separately; it seems a safe bet
* for longs, but it's less clear for shorts.
* TODO: It remains to be seen if there's any advantage to checking the offset for an aligned read
* vs. always reading the bytes separately; it seems a safe bet for longs, but it's less clear for shorts.
*/
return (off & 0x3)? (this.ab[off] | (this.ab[off+1] << 8) | (this.ab[off+2] << 16) | (this.ab[off+3] << 24)) : this.adw[off >> 2];
},
@ -1190,9 +1196,8 @@ Memory.prototype = {
writeShortLittleEndian: function writeShortLittleEndian(off, w, addr) {
// DEBUG: Component.assert(off >= 0 && off < this.size - 1);
/*
* TODO: It remains to be seen if there's any advantage to checking the offset
* for an aligned write vs. always writing the bytes separately; it seems a safe bet
* for longs, but it's less clear for shorts.
* TODO: It remains to be seen if there's any advantage to checking the offset for an aligned write
* vs. always writing the bytes separately; it seems a safe bet for longs, but it's less clear for shorts.
*/
if (off & 0x1) {
this.ab[off] = w;
@ -1226,9 +1231,8 @@ Memory.prototype = {
writeLongLittleEndian: function writeLongLittleEndian(off, l, addr) {
// DEBUG: Component.assert(off >= 0 && off < this.size - 3);
/*
* TODO: It remains to be seen if there's any advantage to checking the offset
* for an aligned write vs. always writing the bytes separately; it seems a safe bet
* for longs, but it's less clear for shorts.
* TODO: It remains to be seen if there's any advantage to checking the offset for an aligned write
* vs. always writing the bytes separately; it seems a safe bet for longs, but it's less clear for shorts.
*/
if (off & 0x3) {
this.ab[off] = l;

11
modules/pcjs/lib/serialport.js
View file

@ -336,23 +336,32 @@ SerialPort.prototype.setBinding = function(sHTMLType, sBinding, control)
control.onkeydown = function onKeyDownSerial(event) {
/*
* This is required in addition to onkeypress, because it's the only way to prevent
* BACKSPACE from being interpreted by the browser as a "Back" operation.
* BACKSPACE (keyCode 8) from being interpreted by the browser as a "Back" operation;
* moreover, not all browsers generate an onkeypress notification for BACKSPACE.
*/
event = event || window.event;
var keyCode = event.keyCode;
if (keyCode === 8) {
if (event.preventDefault) event.preventDefault();
serial.sendRBR([keyCode]);
return true;
}
};
control.onkeypress = function onKeyPressSerial(event) {
/*
* Browser-independent keyCode extraction (refer to keyPress() and the other key
* event handlers in keyboard.js).
*
* The additional check for SPACE (keyCode 32) and subsequent preventDefault() call
* prevents SPACE from bubbling up to the document event handlers, where its default
* behavior is typically to scroll the entire page -- a real nuisance.
*/
event = event || window.event;
var keyCode = event.which || event.keyCode;
serial.sendRBR([keyCode]);
if (keyCode == 32) {
if (event.preventDefault) event.preventDefault();
}
};
return true;

14
modules/pcjs/lib/x86func.js
View file

@ -3831,14 +3831,14 @@ X86.fnFaultMessage = function(nFault, nError, fHalt)
/*
* There are a number of V86-mode exceptions we don't need to know about. For starters, Windows 3.00
* (and other versions of enhanced-mode Windows) use an ARPL in V86-mode to switch out of V86-mode, so
* we can ignore those UD_FAULTs.
* (and other versions of enhanced-mode Windows) use an ARPL to switch out of V86-mode, so we can ignore
* those UD_FAULTs.
*
* Ditto for software interrupts, which will generate a GP_FAULT when the interrupt number (eg, 0x6D)
* exceeds the protected-mode IDT's limit (eg, a limit of 0x2FF yields a maximum interrupt number of 0x5F).
* Windows doesn't really care if its IDT is too small, because no matter what, it has to simulate all
* software interrupts in V86-mode (they will also generate a GP_FAULT if IOPL < 3, and even if IOPL == 3,
* only the protected-mode IDT handler gets to run).
* exceeds the protected-mode IDT's limit (eg, a limit of 0x2FF corresponds to a maximum interrupt number
* of 0x5F). Windows doesn't really care if its IDT is too small, because it has to simulate all software
* interrupts in V86-mode regardless (they generate a GP_FAULT if IOPL < 3, and even when IOPL == 3, only
* the protected-mode IDT handler gets to run).
*/
if ((this.regPS & X86.PS.VM)) {
if (nFault == X86.EXCEPTION.UD_FAULT && bOpcode == X86.OPCODE.ARPL ||
@ -3846,7 +3846,7 @@ X86.fnFaultMessage = function(nFault, nError, fHalt)
fHalt = false;
}
} else {
if (MAXDEBUG && nFault == X86.EXCEPTION.NP_FAULT && bOpcode == 0x8E) {
if (nFault == X86.EXCEPTION.GP_FAULT && this.model == X86.MODEL_80386 /* || nFault == X86.EXCEPTION.NP_FAULT && bOpcode == 0x8E */) {
fHalt = true;
}
}