mirror of
https://github.com/danbulant/Cosmos
synced 2026-05-20 12:58:39 +00:00
132 lines
5 KiB
C#
132 lines
5 KiB
C#
using System;
|
|
using System.Linq;
|
|
using Cosmos.Assembler;
|
|
using Cosmos.Assembler.x86;
|
|
|
|
namespace Cosmos.Debug.DebugStub {
|
|
public class TracerEntry : Cosmos.Assembler.Code {
|
|
|
|
public TracerEntry(Assembler.Assembler aAssembler) : base(aAssembler) {}
|
|
|
|
public override void Assemble() {
|
|
new LiteralAssemblerCode("; We need to make sure Int3 can never run more than one instance at a time.");
|
|
|
|
new LiteralAssemblerCode("; We are not threaded yet, when we are we have to change stuff to thread vars and a lot of other stuff.");
|
|
|
|
new LiteralAssemblerCode("; Two Int3 calls currently can never happen at the same time normally, but IRQs can happen while the DebugStub is");
|
|
|
|
new LiteralAssemblerCode("; running. We also need to make sure IRQs are allowed to run during DebugStub as DebugStub can wait for");
|
|
|
|
new LiteralAssemblerCode("; a long time on commands.");
|
|
|
|
new LiteralAssemblerCode("; So we need to disable interrupts immediately and set a flag, then reenable interrupts if they were enabled");
|
|
|
|
new LiteralAssemblerCode("; when we disabled them. Later this can be replaced by some kind of critical section / lock around this code.");
|
|
|
|
new LiteralAssemblerCode("; Currently IRQs are disabled - we need to fix DS before we can reenable them and add support for critical sections / locks here.");
|
|
|
|
new LiteralAssemblerCode("; -http://www.codemaestro.com/reviews/8");
|
|
|
|
new LiteralAssemblerCode("; -http://en.wikipedia.org/wiki/Spinlock - Uses a register which is a problem for us");
|
|
|
|
new LiteralAssemblerCode("; -http://wiki.osdev.org/Spinlock");
|
|
|
|
new LiteralAssemblerCode("; -Looks good and also allows testing intead of waiting");
|
|
|
|
new LiteralAssemblerCode("; -Wont require us to disable / enable IRQs");
|
|
|
|
new Comment("X#: Group DebugStub");
|
|
|
|
new Comment("X#: InterruptHandler TracerEntry {");
|
|
new LiteralAssemblerCode("DebugStub_TracerEntry:");
|
|
|
|
new LiteralAssemblerCode("; This code is temporarily disabled as IRQs are not enabled right now.");
|
|
|
|
new LiteralAssemblerCode("; LockOrExit");
|
|
|
|
new LiteralAssemblerCode("; EBP is restored by PopAll, but SendFrame uses it. Could");
|
|
|
|
new LiteralAssemblerCode("; get it from the PushAll data, but this is easier.");
|
|
|
|
new Comment("X#: .CallerEBP = EBP");
|
|
new LiteralAssemblerCode("Mov [DebugStub_CallerEBP], EBP");
|
|
|
|
new LiteralAssemblerCode("; Could get ESP from PushAll but this is easier.");
|
|
|
|
new LiteralAssemblerCode("; Also allows us to use the stack before PushAll if we ever need it.");
|
|
|
|
new LiteralAssemblerCode("; We cant modify any registers since we havent done PushAll yet");
|
|
|
|
new LiteralAssemblerCode("; Maybe we could do a sub(4) on memory direct..");
|
|
|
|
new LiteralAssemblerCode("; But for now we remove from ESP which the Int3 produces,");
|
|
|
|
new LiteralAssemblerCode("; store ESP, then restore ESP so we don't cause stack corruption.");
|
|
|
|
new LiteralAssemblerCode("; 12 bytes for EFLAGS, CS, EIP");
|
|
|
|
new Comment("X#: ESP + 12");
|
|
new LiteralAssemblerCode("Add ESP, 12");
|
|
|
|
new Comment("X#: .CallerESP = ESP");
|
|
new LiteralAssemblerCode("Mov [DebugStub_CallerESP], ESP");
|
|
|
|
new Comment("X#: ESP - 12");
|
|
new LiteralAssemblerCode("Sub ESP, 12");
|
|
|
|
new Comment("X#: PushAll");
|
|
new LiteralAssemblerCode("Pushad");
|
|
|
|
new LiteralAssemblerCode("; Save current ESP so we can look at the results of PushAll later");
|
|
|
|
new Comment("X#: .PushAllPtr = ESP");
|
|
new LiteralAssemblerCode("Mov [DebugStub_PushAllPtr], ESP");
|
|
|
|
new LiteralAssemblerCode("; Get current ESP and add 32. This will skip over the PushAll and point");
|
|
|
|
new LiteralAssemblerCode("; us at the call data from Int3.");
|
|
|
|
new Comment("X#: EBP = ESP");
|
|
new LiteralAssemblerCode("Mov EBP, ESP");
|
|
|
|
new Comment("X#: EBP + 32");
|
|
new LiteralAssemblerCode("Add EBP, 32");
|
|
|
|
new LiteralAssemblerCode("; Caller EIP");
|
|
|
|
new Comment("X#: EAX = EBP[0]");
|
|
new LiteralAssemblerCode("Mov EAX, [EBP + 0]");
|
|
|
|
new LiteralAssemblerCode("; EIP is pointer to op after our call. Int3 is 1 byte so we subtract 1.");
|
|
|
|
new LiteralAssemblerCode("; Note - when we used call it was 5 (size of our call + address)");
|
|
|
|
new LiteralAssemblerCode("; so we get the EIP as IL2CPU records it. Its also useful for when we");
|
|
|
|
new LiteralAssemblerCode("; wil be changing ops that call this stub.");
|
|
|
|
new Comment("X#: EAX--");
|
|
new LiteralAssemblerCode("Dec EAX");
|
|
|
|
new LiteralAssemblerCode("; Store it for later use.");
|
|
|
|
new Comment("X#: .CallerEIP = EAX");
|
|
new LiteralAssemblerCode("Mov [DebugStub_CallerEIP], EAX");
|
|
|
|
new Comment("X#: Executing()");
|
|
new LiteralAssemblerCode("Call DebugStub_Executing");
|
|
|
|
new Comment("X#: PopAll");
|
|
new LiteralAssemblerCode("Popad");
|
|
|
|
new LiteralAssemblerCode("; Temp disabled, see comment on LockOrExit above");
|
|
|
|
new LiteralAssemblerCode("; Unlock");
|
|
|
|
new Comment("X#: }");
|
|
new LiteralAssemblerCode("DebugStub_TracerEntry_Exit:");
|
|
new LiteralAssemblerCode("IRet");
|
|
|
|
}
|
|
}
|
|
}
|