public void TestSetAndReadBytes() //MOV AL, BH { byte[] test; RegistersController registry = new SegmentRegisters(); registry.SetBytesToRegistry("CS", 0, 1); test = registry.GetRegistry("CS"); Assert.AreEqual(BitConverter.ToUInt16(test), 256); registry.SetBytesToRegistry("SS", 0, 255); test = registry.GetRegistry("SS"); Assert.AreEqual(BitConverter.ToUInt16(test), 65280); registry.SetBytesToRegistry("DS", 1, 0, 1, 0, 1, 0); test = registry.GetRegistry("DS"); Assert.AreEqual(BitConverter.ToUInt16(test), 1); registry.SetBytesToRegistry("ES", 255); test = registry.GetRegistry("ES"); Assert.AreEqual(BitConverter.ToUInt16(test), 255); registry.SetBytesToRegistry("ES"); test = registry.GetRegistry("ES"); Assert.AreEqual(BitConverter.ToUInt16(test), 255); }
public void TestPOP() { MemoryModel.SetAddressBusLength = 20; MemoryModel memory = MemoryModel.GetInstance(); GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters(); SegmentRegisters segmentRegistersMock = new SegmentRegisters(); PointerRegisters pointerRegistersMock = new PointerRegisters(); LoggerMock loggerMock = new LoggerMock(); RegistryCommander registryCommand = new RegistryCommander(loggerMock); POP pop = new POP(generalRegistersMock, pointerRegistersMock, segmentRegistersMock); PUSH push = new PUSH(generalRegistersMock, pointerRegistersMock, segmentRegistersMock); XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock); MOV mov = new MOV(generalRegistersMock, segmentRegistersMock); AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, pointerRegistersMock, segmentRegistersMock); registryCommand.AddHandler(pop); registryCommand.AddHandler(push); registryCommand.AddHandler(xchg); registryCommand.AddHandler(mov); registryCommand.AddHandler(assignTo); byte[] word; registryCommand.InputCommand("ax 1122"); registryCommand.InputCommand("push ax"); registryCommand.InputCommand("pop cx"); word = generalRegistersMock.GetRegistry("CX"); Assert.AreEqual(34, word[0]); Assert.AreEqual(17, word[1]); Assert.AreEqual("Value 1122h from physical address 0h popped from stack to registry CX.\r\n", loggerMock.outputResult); word = pointerRegistersMock.GetRegistry("SP"); Assert.AreEqual(0, word[0]); registryCommand.InputCommand("ax FFEE"); registryCommand.InputCommand("bx AA99"); registryCommand.InputCommand("SS FF"); registryCommand.InputCommand("push ax"); registryCommand.InputCommand("push bx"); registryCommand.InputCommand("pop dx"); word = generalRegistersMock.GetRegistry("DX"); Assert.AreEqual(153, word[0]); Assert.AreEqual(170, word[1]); Assert.AreEqual("Value AA99h from physical address FF2h popped from stack to registry DX.\r\n", loggerMock.outputResult); word = pointerRegistersMock.GetRegistry("SP"); Assert.AreEqual(2, word[0]); }
public void TestMOVInvalidCommands() { MemoryModel.SetAddressBusLength = 20; GeneralPurposeRegisters registersMock = new GeneralPurposeRegisters(); SegmentRegisters segmentsMock = new SegmentRegisters(); PointerRegisters pointersMock = new PointerRegisters(); LoggerMock loggerMock = new LoggerMock(); RegistryCommander registryCommand = new RegistryCommander(loggerMock); MOV mov = new MOV(registersMock, pointersMock, segmentsMock); AssignToRegistry assign = new AssignToRegistry(registersMock, pointersMock, segmentsMock); registryCommand.AddHandler(mov); registryCommand.AddHandler(assign); registryCommand.InputCommand("mov ak, bh"); Assert.AreEqual(loggerMock.outputResult, "AK is unsupported registry name."); registryCommand.InputCommand("mov ah, bk"); Assert.AreEqual(loggerMock.outputResult, "BK is unsupported registry name."); registryCommand.InputCommand("mov ah bk"); Assert.AreEqual(loggerMock.outputResult, "MOV arguments must be separated by comma."); registryCommand.InputCommand("mov ch,"); Assert.AreEqual(loggerMock.outputResult, "Too few arguments to function MOV."); registryCommand.InputCommand("mov ax, [0"); Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket."); registryCommand.InputCommand("mov [0, ax"); Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket."); registryCommand.InputCommand("mov [0, ch"); Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket."); registryCommand.InputCommand("BP ffff"); registryCommand.InputCommand("DS ffff"); registryCommand.InputCommand("mov [BP], CX"); Assert.AreEqual("Converting arguments into effective address FFFFh.\r\nPhysical address 10FFEFh is out of range memory.\nAborting operation MOV.\r\n", loggerMock.outputResult); registryCommand.InputCommand("mov CX, [BP]"); Assert.AreEqual("Converting arguments into effective address FFFFh.\r\nPhysical address 10FFEFh is out of range memory.\nAborting operation MOV.\r\n", loggerMock.outputResult); MemoryModel.SetAddressBusLength = 0; }
public void TestPUSH() { MemoryModel.SetAddressBusLength = 20; MemoryModel memory = MemoryModel.GetInstance(); GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters(); SegmentRegisters segmentRegistersMock = new SegmentRegisters(); PointerRegisters pointerRegistersMock = new PointerRegisters(); LoggerMock loggerMock = new LoggerMock(); RegistryCommander registryCommand = new RegistryCommander(loggerMock); PUSH push = new PUSH(generalRegistersMock, pointerRegistersMock, segmentRegistersMock); XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock); MOV mov = new MOV(generalRegistersMock, segmentRegistersMock); AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, pointerRegistersMock, segmentRegistersMock); registryCommand.AddHandler(push); registryCommand.AddHandler(xchg); registryCommand.AddHandler(mov); registryCommand.AddHandler(assignTo); byte[] word; registryCommand.InputCommand("ax 1122"); registryCommand.InputCommand("push ax"); word = memory.GetMemoryWord(0); Assert.AreEqual(word[0], 34); Assert.AreEqual(word[1], 17); Assert.AreEqual("Value 1122h from registry AX pushed on stack with physical address 0h.\r\n", loggerMock.outputResult); word = pointerRegistersMock.GetRegistry("SP"); Assert.AreEqual(word[0], 2); registryCommand.InputCommand("ax FFEE"); registryCommand.InputCommand("bx AA99"); registryCommand.InputCommand("SS FF"); registryCommand.InputCommand("push ax"); registryCommand.InputCommand("push bx"); word = memory.GetMemoryWord(4083); Assert.AreEqual(word[0], 255); Assert.AreEqual(word[1], 153); Assert.AreEqual("Value AA99h from registry BX pushed on stack with physical address FF4h.\r\n", loggerMock.outputResult); word = pointerRegistersMock.GetRegistry("SP"); Assert.AreEqual(word[0], 6); }
public void TestXCHGMemoryRegistry() { MemoryModel.SetAddressBusLength = 20; MemoryModel memory = MemoryModel.GetInstance(); GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters(); SegmentRegisters segmentRegistersMock = new SegmentRegisters(); LoggerMock loggerMock = new LoggerMock(); RegistryCommander registryCommand = new RegistryCommander(loggerMock); XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock); MOV mov = new MOV(generalRegistersMock, segmentRegistersMock); AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, segmentRegistersMock); registryCommand.AddHandler(xchg); registryCommand.AddHandler(mov); registryCommand.AddHandler(assignTo); registryCommand.InputCommand("MoV AL, FFh"); registryCommand.InputCommand("MoV [SI + 0], AL"); registryCommand.InputCommand("MoV AL, 1"); registryCommand.InputCommand("XCHG [0], AL"); byte bytetmp = memory.GetMemoryCell(0); Assert.AreEqual(bytetmp, 1); Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as decimal.\r\nConverting arguments into effective address 0h.\r\nValue 1h from registry AL exchanged with FF at physical address 0h.\r\n"); bytetmp = generalRegistersMock.GetRegistry("AL")[0]; Assert.AreEqual(bytetmp, 255); segmentRegistersMock.SetBytesToRegistry("DS", 255); registryCommand.InputCommand("MoV CX, FF11h"); registryCommand.InputCommand("MoV [SI + BP + FFh], CX"); registryCommand.InputCommand("MoV CX, 2233h"); registryCommand.InputCommand("XCHG CX, [100h]"); byte[] word = generalRegistersMock.GetRegistry("CX"); Assert.AreEqual(word[0], 255); Assert.AreEqual(word[1], 0); Assert.AreEqual(loggerMock.outputResult, "Parsing value \"100\" as hexadecimal.\r\nConverting arguments into effective address 100h.\r\nValue 2233h from registry CX exchanged with FF at physical address 10F0h.\r\n"); word = memory.GetMemoryWord(4336); Assert.AreEqual(word[0], 51); Assert.AreEqual(word[1], 34); MemoryModel.SetAddressBusLength = 0; }
public MainWindow() { InitializeComponent(); MemoryModel.SetAddressBusLength = 20; MemoryModel.GetInstance().AddObserver(this); memoryView = new MemoryView(); Go_Click(null, null); generalPurposeRegisters = new GeneralPurposeRegisters(); indexRegisters = new IndexRegisters(); pointerRegisters = new PointerRegisters(); segmentRegisters = new SegmentRegisters(); commandInterpreter = InitDefaultRegistryCommander(); generalPurposeRegistersView = new GeneralPurposeRegistersView(new HexParser()); indexRegistersView = new IndexRegistersView(new HexParser()); pointerRegistersView = new PointerRegistersView(new HexParser()); segmentRegistersView = new SegmentRegistersView(new HexParser()); if (generalPurposeRegisters is Observable observableGeneralPurposeReg) { observableGeneralPurposeReg.AddObserver(generalPurposeRegistersView); } if (indexRegisters is Observable observableIndexReg) { observableIndexReg.AddObserver(indexRegistersView); } if (pointerRegisters is Observable observablePointersReg) { observablePointersReg.AddObserver(pointerRegistersView); } if (segmentRegisters is Observable observableSegmentsReg) { observableSegmentsReg.AddObserver(segmentRegistersView); } SetBlockDataContext(); }
/// <summary> /// Gets the linear address of a specified segment. /// </summary> /// <param name="segment">The segment to get.</param> /// <param name="context">The context.</param> /// <returns>A <see cref="IntPtr" /> pointer corresponding to the linear address of the segment.</returns> /// <exception cref="InvalidEnumArgumentException">segment</exception> public IntPtr GetRealSegmentAddress(SegmentRegisters segment, ref ThreadContext32 context) { // Get a selector entry for the segment LdtEntry entry; switch (segment) { case SegmentRegisters.Cs: entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegCs); break; case SegmentRegisters.Ds: entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegDs); break; case SegmentRegisters.Es: entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegEs); break; case SegmentRegisters.Fs: entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegFs); break; case SegmentRegisters.Gs: entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegGs); break; case SegmentRegisters.Ss: entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegSs); break; default: throw new InvalidEnumArgumentException(nameof(segment), (int)segment, typeof(SegmentRegisters)); } // Compute the linear address return(new IntPtr(entry.BaseLow | (entry.BaseMid << 16) | (entry.BaseHi << 24))); }
public void TestFromToRegistryMemory() { MemoryModel.SetAddressBusLength = 20; MemoryModel memory = MemoryModel.GetInstance(); GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters(); SegmentRegisters segmentRegistersMock = new SegmentRegisters(); LoggerMock loggerMock = new LoggerMock(); RegistryCommander registryCommand = new RegistryCommander(loggerMock); XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock); MOV mov = new MOV(generalRegistersMock, segmentRegistersMock); AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, segmentRegistersMock); registryCommand.AddHandler(xchg); registryCommand.AddHandler(mov); registryCommand.AddHandler(assignTo); registryCommand.InputCommand("MoV AL, 255"); registryCommand.InputCommand("MoV [0], AL"); byte bytetmp = memory.GetMemoryCell(0); Assert.AreEqual(bytetmp, 255); Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as decimal.\r\nConverting arguments into effective address 0h.\r\nValue FFh from registry AL assigned to physical address 0h.\r\n"); segmentRegistersMock.SetBytesToRegistry("DS", 255); registryCommand.InputCommand("MoV AH, AAh"); registryCommand.InputCommand("MoV [FFh], AH"); bytetmp = memory.GetMemoryCell(4335); Assert.AreEqual(bytetmp, 170); Assert.AreEqual(loggerMock.outputResult, "Parsing value \"FF\" as hexadecimal.\r\nConverting arguments into effective address FFh.\r\nValue AAh from registry AH assigned to physical address 10EFh.\r\n"); segmentRegistersMock.SetBytesToRegistry("DS", 15); registryCommand.InputCommand("MoV [0h], AX"); byte[] word = memory.GetMemoryWord(240); Assert.AreEqual(word[0], 255); Assert.AreEqual(word[1], 170); Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue AAFFh from registry AX assigned to physical address F0h.\r\n"); segmentRegistersMock.SetBytesToRegistry("DS", 0); registryCommand.InputCommand("MoV AX, [0h]"); word = generalRegistersMock.GetRegistry("AX"); Assert.AreEqual(word[0], 255); Assert.AreEqual(word[1], 0); Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue FFh assigned to registry AX from physical address 0h.\r\n"); segmentRegistersMock.SetBytesToRegistry("DS", 255); registryCommand.InputCommand("MoV AX, [FEh]"); word = generalRegistersMock.GetRegistry("AX"); Assert.AreEqual(word[0], 0); Assert.AreEqual(word[1], 170); Assert.AreEqual(loggerMock.outputResult, "Parsing value \"FE\" as hexadecimal.\r\nConverting arguments into effective address FEh.\r\nValue AA00h assigned to registry AX from physical address 10EEh.\r\n"); segmentRegistersMock.SetBytesToRegistry("DS", 15); registryCommand.InputCommand("MoV AX, [0h]"); word = generalRegistersMock.GetRegistry("AX"); Assert.AreEqual(word[0], 255); Assert.AreEqual(word[1], 170); Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue AAFFh assigned to registry AX from physical address F0h.\r\n"); MemoryModel.SetAddressBusLength = 0; }