public override void AssembleNew(Assembler aAssembler, object aMethodInfo) { // IDT is already initialized but just for base hooks, and asm only. // ie Int 1, 3 and GPF // This routine updates the IDT now that we have C# running to allow C# hooks to handle // the other INTs // We are updating the IDT, disable interrupts XS.ClearInterruptFlag(); for (int i = 0; i < 256; i++) { // These are already mapped, don't remap them. // Maybe in the future we can look at ones that are present // and skip them, but some we may want to overwrite anyways. if (i == 1 || i == 3) { continue; } XS.Set(EAX, "__ISR_Handler_" + i.ToString("X2")); XS.Set("_NATIVE_IDT_Contents", AL, destinationDisplacement: (i * 8) + 0); XS.Set("_NATIVE_IDT_Contents", AH, destinationDisplacement: (i * 8) + 1); XS.Set("_NATIVE_IDT_Contents", 0x8, destinationDisplacement: (i * 8) + 2, size: RegisterSize.Byte8); XS.Set("_NATIVE_IDT_Contents", 0x8E, destinationDisplacement: (i * 8) + 5, size: RegisterSize.Byte8); XS.ShiftRight(EAX, 16); XS.Set("_NATIVE_IDT_Contents", AL, destinationDisplacement: (i * 8) + 6); XS.Set("_NATIVE_IDT_Contents", AH, destinationDisplacement: (i * 8) + 7); } XS.Jump("__AFTER__ALL__ISR__HANDLER__STUBS__"); var xInterruptsWithParam = new[] { 8, 10, 11, 12, 13, 14 }; for (int j = 0; j < 256; j++) { XS.Label("__ISR_Handler_" + j.ToString("X2")); XS.Call("__INTERRUPT_OCCURRED__"); if (Array.IndexOf(xInterruptsWithParam, j) == -1) { XS.Push(0); } XS.Push((uint)j); if (j != 0x20) { XS.PushAllRegisters(); XS.Sub(ESP, 4); XS.Set(EAX, ESP); // preserve old stack address for passing to interrupt handler // store floating point data XS.And(ESP, 0xfffffff0); // fxsave needs to be 16-byte alligned XS.Sub(ESP, 512); // fxsave needs 512 bytes XS.SSE.FXSave(ESP, isIndirect: true); // save the registers XS.Set(EAX, ESP, destinationIsIndirect: true); XS.Push(EAX); // XS.Push(EAX); // pass old stack address (pointer to InterruptContext struct) to the interrupt handler XS.JumpToSegment(8, "__ISR_Handler_" + j.ToString("X2") + "_SetCS"); XS.Label("__ISR_Handler_" + j.ToString("X2") + "_SetCS"); MethodBase xHandler = GetInterruptHandler((byte)j); if (xHandler == null) { xHandler = GetMethodDef(typeof(Cosmos.Core.INTs).Assembly, typeof(Cosmos.Core.INTs).FullName, "HandleInterrupt_Default", true); } XS.Call(LabelName.Get(xHandler)); XS.Pop(EAX); XS.SSE.FXRestore(ESP, isIndirect: true); XS.Set(ESP, EAX); // this restores the stack for the FX stuff, except the pointer to the FX data XS.Add(ESP, 4); // "pop" the pointer XS.PopAllRegisters(); } else { new LiteralAssemblerCode("pushad"); new LiteralAssemblerCode("mov eax, ds"); new LiteralAssemblerCode("push eax"); new LiteralAssemblerCode("mov eax, es"); new LiteralAssemblerCode("push eax"); new LiteralAssemblerCode("mov eax, fs"); new LiteralAssemblerCode("push eax"); new LiteralAssemblerCode("mov eax, gs"); new LiteralAssemblerCode("push eax"); new LiteralAssemblerCode("mov ax, 0x10"); new LiteralAssemblerCode("mov ds, ax"); new LiteralAssemblerCode("mov es, ax"); new LiteralAssemblerCode("mov fs, ax"); new LiteralAssemblerCode("mov gs, ax"); new LiteralAssemblerCode("mov eax, esp"); XS.Set("static_field__Cosmos_Core_INTs_mStackContext", EAX, destinationIsIndirect: true); XS.Call(LabelName.Get(GetMethodDef(typeof(Cosmos.Core.Processing.ProcessorScheduler).Assembly, typeof(Cosmos.Core.Processing.ProcessorScheduler).FullName, "SwitchTask", true))); XS.Set(EAX, "static_field__Cosmos_Core_INTs_mStackContext", sourceIsIndirect: true); new LiteralAssemblerCode("mov esp, eax"); new LiteralAssemblerCode("pop eax"); new LiteralAssemblerCode("mov gs, eax"); new LiteralAssemblerCode("pop eax"); new LiteralAssemblerCode("mov fs, eax"); new LiteralAssemblerCode("pop eax"); new LiteralAssemblerCode("mov es, eax"); new LiteralAssemblerCode("pop eax"); new LiteralAssemblerCode("mov ds, eax"); new LiteralAssemblerCode("popad"); } XS.Add(ESP, 8); XS.Label("__ISR_Handler_" + j.ToString("X2") + "_END"); XS.InterruptReturn(); } XS.Label("__INTERRUPT_OCCURRED__"); XS.Return(); XS.Label("__AFTER__ALL__ISR__HANDLER__STUBS__"); XS.Noop(); XS.Set(EAX, EBP, sourceDisplacement: 8); XS.Compare(EAX, 0); XS.Jump(ConditionalTestEnum.Zero, ".__AFTER_ENABLE_INTERRUPTS"); // reload interrupt list XS.Set(EAX, "_NATIVE_IDT_Pointer"); XS.Set(AsmMarker.Labels[AsmMarker.Type.Processor_IntsEnabled], 1, destinationIsIndirect: true, size: RegisterSize.Byte8); XS.LoadIdt(EAX, isIndirect: true); // Reenable interrupts XS.EnableInterrupts(); XS.Label(".__AFTER_ENABLE_INTERRUPTS"); }
public override void AssembleNew(Assembler aAssembler, object aMethodInfo) { var xAssembler = aAssembler; var xMethodInfo = (_MethodInfo)aMethodInfo; var xMethodBaseAsInfo = xMethodInfo.MethodBase as global::System.Reflection.MethodInfo; if (xMethodBaseAsInfo.ReturnType != typeof(void)) { throw new Exception("Events with return type not yet supported!"); } /* * EAX contains the GetInvocationList() array at the index at which it was last used * EDX contains the index at which the EAX is * EBX contains the number of items in the array * ECX contains the argument size */ XS.ClearInterruptFlag(); XS.Comment("Get Invoke list count"); var xGetInvocationListMethod = typeof(MulticastDelegate).GetMethod("GetInvocationList"); Ldarg.DoExecute(aAssembler, xMethodInfo, 0); XS.Call(LabelName.Get(xGetInvocationListMethod)); XS.Add(XSRegisters.ESP, 4); XS.Pop(XSRegisters.EAX); XS.Add(XSRegisters.EAX, 8); XS.Set(XSRegisters.EBX, XSRegisters.EAX, sourceIsIndirect: true); XS.Comment("Get invoke method"); XS.Add(XSRegisters.EAX, 8); XS.Set(XSRegisters.EDI, XSRegisters.EAX, sourceIsIndirect: true, sourceDisplacement: 4); XS.Comment("Get ArgSize"); int xArgSizeOffset = Ldfld.GetFieldOffset(typeof(global::System.Delegate), "$$ArgSize$$"); Ldarg.DoExecute(aAssembler, xMethodInfo, 0); XS.Add(XSRegisters.ESP, 4); XS.Pop(XSRegisters.ECX); XS.Add(XSRegisters.ECX, (uint)xArgSizeOffset); XS.Set(XSRegisters.ECX, XSRegisters.ECX, sourceIsIndirect: true); XS.Comment("Set current invoke list index"); XS.Set(XSRegisters.EDX, 0); XS.Label(".BEGIN_OF_LOOP"); { XS.Compare(XSRegisters.EDX, XSRegisters.EBX); XS.Jump(x86.ConditionalTestEnum.GreaterThanOrEqualTo, ".END_OF_INVOKE"); XS.PushAllRegisters(); XS.Comment("Check if delegate has $this"); XS.Set(XSRegisters.EDI, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0)); XS.Add(XSRegisters.EDI, 4); XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.Object System.Delegate._target")); XS.Compare(XSRegisters.EDI, 0); XS.Jump(x86.ConditionalTestEnum.Zero, ".NO_THIS"); XS.Label(".HAS_THIS"); XS.Push(XSRegisters.EDI); XS.Push(0); XS.Label(".NO_THIS"); XS.Set(XSRegisters.EDI, XSRegisters.EAX, sourceIsIndirect: true, sourceDisplacement: 4); XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.IntPtr System.Delegate._methodPtr")); XS.Comment("Check if delegate has args"); XS.Compare(XSRegisters.ECX, 0); XS.Jump(x86.ConditionalTestEnum.Zero, ".NO_ARGS"); XS.Label(".HAS_ARGS"); XS.Sub(XSRegisters.ESP, XSRegisters.ECX); XS.Push(XSRegisters.EDI); XS.Set(XSRegisters.EDI, XSRegisters.ESP); XS.Add(XSRegisters.EDI, 4); XS.Set(XSRegisters.ESI, XSRegisters.EBP); XS.Add(XSRegisters.ESI, 8); new x86.Movs { Size = 8, Prefixes = x86.InstructionPrefixes.Repeat }; XS.Pop(XSRegisters.EDI); XS.Label(".NO_ARGS"); XS.Call(XSRegisters.EDI); XS.PopAllRegisters(); XS.Increment(XSRegisters.EDX); XS.Jump(".BEGIN_OF_LOOP"); } XS.Label(".END_OF_INVOKE"); XS.Set(XSRegisters.EDX, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0)); XS.Set(XSRegisters.EDX, XSRegisters.EDX, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "$$ReturnsValue$$")); XS.Compare(XSRegisters.EDX, 0); XS.Jump(x86.ConditionalTestEnum.Equal, ".NO_RETURN"); XS.Label(".HAS_RETURN"); XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationDisplacement: 8); XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationDisplacement: 4); XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationIsIndirect: true); XS.Push(XSRegisters.EDX); XS.Set(XSRegisters.ESP, XSRegisters.EDI, destinationDisplacement: 12); XS.Label(".NO_RETURN"); XS.EnableInterrupts(); }
public override void AssembleNew(Assembler aAssembler, object aMethodInfo) { int start = 0; for (int i = start; i < 256; i++) { if (i == 1 || i == 3) { //continue; // was used for debugging } XS.Set(XSRegisters.EAX, "_isr" + i.ToString("X2")); XS.Set("_NATIVE_IDT_Contents", XSRegisters.AL, destinationDisplacement: (i * 8) + 0); XS.Set("_NATIVE_IDT_Contents", XSRegisters.AH, destinationDisplacement: (i * 8) + 1); XS.Set("_NATIVE_IDT_Contents", 0x08, destinationDisplacement: (i * 8) + 2, size: XSRegisters.RegisterSize.Byte8); XS.Set("_NATIVE_IDT_Contents", 0x00, destinationDisplacement: (i * 8) + 4, size: XSRegisters.RegisterSize.Byte8); XS.Set("_NATIVE_IDT_Contents", 0x8E, destinationDisplacement: (i * 8) + 5, size: XSRegisters.RegisterSize.Byte8); XS.ShiftRight(XSRegisters.EAX, 16); XS.Set("_NATIVE_IDT_Contents", XSRegisters.AL, destinationDisplacement: (i * 8) + 6); XS.Set("_NATIVE_IDT_Contents", XSRegisters.AH, destinationDisplacement: (i * 8) + 7); } XS.Jump("skip_isrhandlers"); var xInterruptsWithParam = new[] { 8, 10, 11, 12, 13, 14 }; for (int j = start; j < 256; j++) { XS.Label("_isr" + j.ToString("X2")); XS.ClearInterruptFlag(); XS.Call("__INTERRUPT_OCCURRED__"); if (global::System.Array.IndexOf(xInterruptsWithParam, j) == -1) { XS.Push(0); } XS.Push((uint)j); XS.Jump("CommonISRBase"); } XS.Label("CommonISRBase"); XS.PushAllRegisters(); XS.Set(XSRegisters.EAX, XSRegisters.ESP); XS.Set("static_field__Kernel_System_Core_ISR_old_esp", XSRegisters.EAX, destinationIsIndirect: true); XS.Sub(XSRegisters.ESP, 4); XS.Set(XSRegisters.EAX, XSRegisters.ESP); XS.And(XSRegisters.ESP, 0xfffffff0); XS.Sub(XSRegisters.ESP, 512); XS.SSE.FXSave(XSRegisters.ESP, isIndirect: true); XS.Set(XSRegisters.EAX, XSRegisters.ESP, destinationIsIndirect: true); XS.Push(XSRegisters.EAX); XS.Push(XSRegisters.EAX); XS.Set("static_field__Kernel_System_Core_ISR_Registers", XSRegisters.EAX, destinationIsIndirect: true); MethodBase xHandler = GetMethodDef(typeof(ISR).Assembly, typeof(ISR).FullName, "CommonISRHandler", true); XS.Call(LabelName.Get(xHandler)); XS.Pop(XSRegisters.EAX); XS.SSE.FXRestore(XSRegisters.ESP, isIndirect: true); XS.Set(XSRegisters.ESP, XSRegisters.EAX); XS.Add(XSRegisters.ESP, 4); XS.Set(XSRegisters.EAX, "static_field__Kernel_System_Core_ISR_old_esp", sourceIsIndirect: true); XS.Set(XSRegisters.ESP, XSRegisters.EAX); XS.PopAllRegisters(); XS.Add(XSRegisters.ESP, 8); XS.InterruptReturn(); XS.Label("skip_isrhandlers"); }
public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object aMethodInfo) { XS.ClearInterruptFlag(); }
public void Initialize() { uint xSig = 0x1BADB002; DataMembers.Add(new DataIfNotDefined("ELF_COMPILATION")); DataMembers.Add(new DataMember("MultibootSignature", new uint[] { xSig })); uint xFlags = 0x10003; DataMembers.Add(new DataMember("MultibootFlags", xFlags)); DataMembers.Add(new DataMember("MultibootChecksum", (int)(0 - (xFlags + xSig)))); DataMembers.Add(new DataMember("MultibootHeaderAddr", ElementReference.New("MultibootSignature"))); DataMembers.Add(new DataMember("MultibootLoadAddr", ElementReference.New("MultibootSignature"))); DataMembers.Add(new DataMember("MultibootLoadEndAddr", ElementReference.New("_end_code"))); DataMembers.Add(new DataMember("MultibootBSSEndAddr", ElementReference.New("_end_code"))); DataMembers.Add(new DataMember("MultibootEntryAddr", ElementReference.New("Kernel_Start"))); DataMembers.Add(new DataEndIfDefined()); DataMembers.Add(new DataIfDefined("ELF_COMPILATION")); xFlags = 0x00003; DataMembers.Add(new DataMember("MultibootSignature", new uint[] { xSig })); DataMembers.Add(new DataMember("MultibootFlags", xFlags)); DataMembers.Add(new DataMember("MultibootChecksum", (int)(0 - (xFlags + xSig)))); DataMembers.Add(new DataEndIfDefined()); // graphics info fields DataMembers.Add(new DataMember("MultibootGraphicsRuntime_VbeModeInfoAddr", Int32.MaxValue)); DataMembers.Add(new DataMember("MultibootGraphicsRuntime_VbeControlInfoAddr", Int32.MaxValue)); DataMembers.Add(new DataMember("MultibootGraphicsRuntime_VbeMode", Int32.MaxValue)); // memory DataMembers.Add(new DataMember("MultiBootInfo_Memory_High", 0)); DataMembers.Add(new DataMember("MultiBootInfo_Memory_Low", 0)); DataMembers.Add(new DataMember("Before_Kernel_Stack", new byte[0x50000])); DataMembers.Add(new DataMember("Kernel_Stack", new byte[0])); DataMembers.Add(new DataMember("MultiBootInfo_Structure", new uint[1])); if (mComPort > 0) { new Define("DEBUGSTUB"); } // This is our first entry point. Multiboot uses this as Cosmos entry point. new Label("Kernel_Start", isGlobal: true); XS.Set(XSRegisters.ESP, "Kernel_Stack"); // Displays "Cosmos" in top left. Used to make sure Cosmos is booted in case of hang. // ie bootloader debugging. This must be the FIRST code, even before setup so we know // we are being called properly by the bootloader and that if there are problems its // somwhere in our code, not the bootloader. WriteDebugVideo("Cosmos pre boot"); // For when using Bochs, causes a break ASAP on entry after initial Cosmos display. new LiteralAssemblerCode("xchg bx, bx"); // CLI ASAP WriteDebugVideo("Clearing interrupts."); XS.ClearInterruptFlag(); WriteDebugVideo("Begin multiboot info."); new LiteralAssemblerCode("%ifndef EXCLUDE_MULTIBOOT_MAGIC"); new Comment(this, "MultiBoot compliant loader provides info in registers: "); new Comment(this, "EBX=multiboot_info "); new Comment(this, "EAX=0x2BADB002 - check if it's really Multiboot-compliant loader "); new Comment(this, " ;- copy mb info - some stuff for you "); new Comment(this, "BEGIN - Multiboot Info"); new Mov { DestinationRef = ElementReference.New("MultiBootInfo_Structure"), DestinationIsIndirect = true, SourceReg = RegistersEnum.EBX }; XS.Add(XSRegisters.EBX, 4); XS.Set(XSRegisters.EAX, XSRegisters.EBX, sourceIsIndirect: true); new Mov { DestinationRef = ElementReference.New("MultiBootInfo_Memory_Low"), DestinationIsIndirect = true, SourceReg = RegistersEnum.EAX }; XS.Add(XSRegisters.EBX, 4); XS.Set(XSRegisters.EAX, XSRegisters.EBX, sourceIsIndirect: true); new Mov { DestinationRef = ElementReference.New("MultiBootInfo_Memory_High"), DestinationIsIndirect = true, SourceReg = RegistersEnum.EAX }; new Comment(this, "END - Multiboot Info"); new LiteralAssemblerCode("%endif"); WriteDebugVideo("Creating GDT."); CreateGDT(); WriteDebugVideo("Configuring PIC"); ConfigurePIC(); WriteDebugVideo("Creating IDT."); CreateIDT(); #if LFB_1024_8 new Comment("Set graphics fields"); XS.Mov(XSRegisters.EBX, Cosmos.Assembler.ElementReference.New("MultiBootInfo_Structure"), sourceIsIndirect: true); XS.Mov(XSRegisters.EAX, XSRegisters.EBX, sourceDisplacement: 72); new Move { DestinationRef = Cosmos.Assembler.ElementReference.New("MultibootGraphicsRuntime_VbeControlInfoAddr"), DestinationIsIndirect = true, SourceReg = Registers.EAX }; XS.Mov(XSRegisters.EAX, XSRegisters.EBX, sourceDisplacement: 76); new Move { DestinationRef = Cosmos.Assembler.ElementReference.New("MultibootGraphicsRuntime_VbeModeInfoAddr"), DestinationIsIndirect = true, SourceReg = Registers.EAX }; XS.Mov(XSRegisters.EAX, XSRegisters.EBX, sourceDisplacement: 80); new Move { DestinationRef = Cosmos.Assembler.ElementReference.New("MultibootGraphicsRuntime_VbeMode"), DestinationIsIndirect = true, SourceReg = Registers.EAX }; #endif //WriteDebugVideo("Initializing SSE."); //new Comment(this, "BEGIN - SSE Init"); //// CR4[bit 9]=1, CR4[bit 10]=1, CR0[bit 2]=0, CR0[bit 1]=1 //XS.Mov(XSRegisters.EAX, XSRegisters.Registers.CR4); //XS.Or(XSRegisters.EAX, 0x100); //XS.Mov(XSRegisters.CR4, XSRegisters.Registers.EAX); //XS.Mov(XSRegisters.EAX, XSRegisters.Registers.CR4); //XS.Or(XSRegisters.EAX, 0x200); //XS.Mov(XSRegisters.CR4, XSRegisters.Registers.EAX); //XS.Mov(XSRegisters.EAX, XSRegisters.Registers.CR0); //XS.And(XSRegisters.EAX, 0xfffffffd); //XS.Mov(XSRegisters.CR0, XSRegisters.Registers.EAX); //XS.Mov(XSRegisters.EAX, XSRegisters.Registers.CR0); //XS.And(XSRegisters.EAX, 1); //XS.Mov(XSRegisters.CR0, XSRegisters.Registers.EAX); //new Comment(this, "END - SSE Init"); if (mComPort > 0) { WriteDebugVideo("Initializing DebugStub."); XS.Call("DebugStub_Init"); } // Jump to Kernel entry point WriteDebugVideo("Jumping to kernel."); XS.Call(EntryPointName); new Comment(this, "Kernel done - loop till next IRQ"); XS.Label(".loop"); XS.ClearInterruptFlag(); XS.Halt(); XS.Jump(".loop"); if (mComPort > 0) { var xGen = new AsmGenerator(); var xGenerateAssembler = new Action <object>(i => { if (i is StreamReader) { var xAsm = xGen.Generate((StreamReader)i); CurrentInstance.Instructions.AddRange(xAsm.Instructions); CurrentInstance.DataMembers.AddRange(xAsm.DataMembers); } else if (i is string) { var xAsm = xGen.Generate((string)i); CurrentInstance.Instructions.AddRange(xAsm.Instructions); CurrentInstance.DataMembers.AddRange(xAsm.DataMembers); } else { throw new Exception("Object type '" + i.ToString() + "' not supported!"); } }); if (ReadDebugStubFromDisk) { foreach (var xFile in Directory.GetFiles(CosmosPaths.DebugStubSrc, "*.xs")) { xGenerateAssembler(xFile); } } else { foreach (var xManifestName in typeof(ReferenceHelper).Assembly.GetManifestResourceNames()) { if (!xManifestName.EndsWith(".xs", StringComparison.OrdinalIgnoreCase)) { continue; } using (var xStream = typeof(ReferenceHelper).Assembly.GetManifestResourceStream(xManifestName)) { using (var xReader = new StreamReader(xStream)) { xGenerateAssembler(xReader); } } } } OnAfterEmitDebugStub(); } else { XS.Label("DebugStub_Step"); XS.Return(); } // Start emitting assembly labels CurrentInstance.EmitAsmLabels = true; }
public override void AssembleNew(Assembler aAssembler, object aMethodInfo) { var xMethodInfo = (Il2cpuMethodInfo)aMethodInfo; /* * EAX contains the GetInvocationList() array at the index at which it was last used * EBX contains the number of items in the array * ECX contains the argument size * EDX contains the current index in the array * ESI contains the size of the return value * EDI contains the function pointer */ XS.ClearInterruptFlag(); XS.Comment("Get Invoke list count"); var xGetInvocationListMethod = typeof(MulticastDelegate).GetMethod("GetInvocationList"); Ldarg.DoExecute(aAssembler, xMethodInfo, 0); XS.Call(LabelName.Get(xGetInvocationListMethod)); XS.Add(ESP, 4); XS.Pop(EAX); XS.Add(EAX, 8); XS.Set(EBX, EAX, sourceIsIndirect: true); XS.Comment("Get invoke method"); XS.Add(EAX, 8); XS.Set(EDI, EAX, sourceIsIndirect: true, sourceDisplacement: 4); // this line can propably can be removed XS.Comment("Get ArgSize"); int xArgSizeOffset = Ldfld.GetFieldOffset(typeof(Delegate), "$$ArgSize$$"); Ldarg.DoExecute(aAssembler, xMethodInfo, 0); XS.Add(ESP, 4); XS.Pop(ECX); XS.Add(ECX, (uint)xArgSizeOffset); XS.Set(ECX, ECX, sourceIsIndirect: true); XS.Comment("Set current invoke list index"); XS.Set(EDX, 0); XS.Comment("Make space for return value"); int returnSizeOffset = Ldfld.GetFieldOffset(typeof(Delegate), "$$ReturnSize$$"); Ldarg.DoExecute(aAssembler, xMethodInfo, 0); XS.Add(ESP, 4); XS.Pop(ESI); XS.Add(ESI, (uint)returnSizeOffset); XS.Set(ESI, ESI, sourceIsIndirect: true); XS.Sub(ESP, ESI); XS.Label(".BEGIN_OF_LOOP"); { XS.Compare(EDX, EBX); XS.Jump(x86.ConditionalTestEnum.GreaterThanOrEqualTo, ".END_OF_INVOKE"); XS.PushAllRegisters(); XS.Comment("Check if delegate has $this"); XS.Set(EDI, EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0)); XS.Add(EDI, 4); XS.Set(EDI, EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.Object System.Delegate._target")); XS.Set(EDX, ECX); // edx contains the size of the arguments including $this XS.Compare(EDI, 0); XS.Jump(x86.ConditionalTestEnum.Zero, ".NO_THIS"); XS.Label(".HAS_THIS"); XS.Push(EDI); XS.Set(EDI, EDI, sourceIsIndirect: true); // get type of target object XS.Add(EDX, 4); // we have at least one int of $this //TODO: In future we might be able to replace the following call with a check //if the object is boxed and in that case assume its a struct // safe info from registers which get trashed XS.Push(EAX); XS.Push(EBX); XS.Push(ECX); XS.Push(EDX); XS.Push(EDI); XS.Call(LabelName.Get(VTablesImplRefs.IsStructRef)); XS.Pop(EDI); // restore values XS.Pop(EDX); XS.Pop(ECX); XS.Pop(EBX); XS.Pop(EAX); // now check if target turned out to be struct XS.Compare(EDI, 1); XS.Jump(x86.ConditionalTestEnum.Equal, ".Struct"); //structs are just the pointer so we are already done XS.Push(0); XS.Add(EDX, 4); XS.Jump(".NO_THIS"); XS.Label(".Struct"); XS.Add(ESP, ObjectUtils.FieldDataOffset, destinationIsIndirect: true); XS.Label(".NO_THIS"); XS.Set(EDI, EAX, sourceIsIndirect: true, sourceDisplacement: 4); XS.Set(EDI, EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.IntPtr System.Delegate._methodPtr")); XS.Set(EBX, 0); // initialise required extra space to 0 XS.Compare(ESI, EDX); XS.Jump(x86.ConditionalTestEnum.LessThanOrEqualTo, ".NO_RETURN_VALUE_SPACE"); XS.Set(EBX, ESI); XS.Sub(EBX, ECX); XS.Label(".NO_RETURN_VALUE_SPACE"); XS.Comment("Check if delegate has args"); XS.Compare(ECX, 0); XS.Jump(x86.ConditionalTestEnum.Zero, ".NO_ARGS"); XS.Label(".HAS_ARGS"); XS.Sub(ESP, ECX); XS.Push(EDI); XS.Set(EDI, ESP); XS.Add(EDI, 4); XS.Set(ESI, EBP); XS.Compare(EBX, 0); XS.Jump(x86.ConditionalTestEnum.Equal, ".NO_RETURN_EXTRA"); XS.Add(ESI, EBX); // to skip the extra space reserved for the return value XS.Jump(".AFTER_ADJUST_ESI"); XS.Label(".NO_RETURN_EXTRA"); XS.Add(ESI, 8); XS.Label(".AFTER_ADJUST_ESI"); new x86.Movs { Size = 8, Prefixes = x86.InstructionPrefixes.Repeat }; XS.Pop(EDI); XS.Label(".NO_ARGS"); XS.Sub(ESP, EBX); // make extra space for the return value XS.Call(EDI); XS.Comment("If there is a return value copy it to holding place now"); Ldarg.DoExecute(aAssembler, xMethodInfo, 0); XS.Add(ESP, 4); XS.Pop(EAX); XS.Add(EAX, (uint)returnSizeOffset); XS.Set(EAX, EAX, sourceIsIndirect: true); // got size of return value XS.Set(EDI, EBP); XS.Sub(EDI, EAX); XS.Label(".RETURN_VALUE_LOOP_START"); XS.Compare(EAX, 0); XS.Jump(x86.ConditionalTestEnum.LessThanOrEqualTo, ".RETURN_VALUE_LOOP_END"); XS.Pop(EBX); XS.Set(EDI, EBX, destinationIsIndirect: true); XS.Add(EDI, 4); XS.Sub(EAX, 4); XS.Jump(".RETURN_VALUE_LOOP_START"); XS.Label(".RETURN_VALUE_LOOP_END"); XS.PopAllRegisters(); XS.Increment(EDX); XS.Jump(".BEGIN_OF_LOOP"); } XS.Label(".END_OF_INVOKE"); XS.EnableInterrupts(); }
public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object aMethodInfo) { var xAssembler = (Cosmos.Assembler.Assembler)aAssembler; var xMethodInfo = (Cosmos.IL2CPU.MethodInfo)aMethodInfo; var xMethodBaseAsInfo = xMethodInfo.MethodBase as global::System.Reflection.MethodInfo; if (xMethodBaseAsInfo.ReturnType != typeof(void)) { throw new Exception("Events with return type not yet supported!"); } XS.Comment("XXXXXXX"); XS.Exchange(XSRegisters.BX, XSRegisters.BX); /* * EAX contains the GetInvocationList() array at the index at which it was last used * EDX contains the index at which the EAX is * EBX contains the number of items in the array * ECX contains the argument size */ XS.ClearInterruptFlag(); XS.Label(".DEBUG"); //XS.Label("____DEBUG_FOR_MULTICAST___"); XS.Comment("move address of delegate to eax"); XS.Set(XSRegisters.EAX, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0)); var xGetInvocationListMethod = typeof(MulticastDelegate).GetMethod("GetInvocationList"); XS.Comment("push address of delgate to stack"); XS.Push(XSRegisters.EAX);//addrof this XS.Call(LabelName.Get(xGetInvocationListMethod)); XS.Comment("get address from return value -> eax"); XS.Pop(XSRegisters.EAX); ;//list XS.Comment("eax+=8 is where the offset where an array's count is"); XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true); XS.Add(XSRegisters.EAX, 8); //addrof list.Length XS.Comment("store count in ebx"); XS.Set(XSRegisters.EBX, XSRegisters.EAX, sourceIsIndirect: true); //list.count XS.Comment("eax+=8 is where the offset where an array's items start"); XS.Add(XSRegisters.EAX, 8); // Put pointer at the first item in the list. XS.Set(XSRegisters.EDI, 0); XS.Comment("ecx = ptr to delegate object"); XS.Set(XSRegisters.ECX, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0));//addrof the delegate XS.Comment("ecx points to the size of the delegated methods arguments"); XS.Set(XSRegisters.ECX, XSRegisters.ECX, sourceIsIndirect: true); XS.Set(XSRegisters.ECX, XSRegisters.ECX, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "$$ArgSize$$")); //the size of the arguments to the method? + 12??? -- 12 is the size of the current call stack.. i think XS.Xor(XSRegisters.EDX, XSRegisters.EDX); ; //make sure edx is 0 XS.Label(".BEGIN_OF_LOOP"); { XS.Compare(XSRegisters.EDX, XSRegisters.EBX); //are we at the end of this list XS.Jump(CPUx86.ConditionalTestEnum.GreaterThanOrEqualTo, ".END_OF_INVOKE_"); //then we better stop XS.PushAllRegisters(); XS.Comment("esi points to where we will copy the methods argumetns from"); XS.Set(XSRegisters.ESI, XSRegisters.ESP); XS.Comment("edi = ptr to delegate object"); XS.Set(XSRegisters.EDI, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0)); XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceIsIndirect: true); // dereference handle XS.Comment("edi = ptr to delegate object should be a pointer to the delgates context ie (this) for the methods "); XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.Object System.Delegate._target")); XS.Compare(XSRegisters.EDI, 0); XS.Jump(CPUx86.ConditionalTestEnum.Zero, ".NO_THIS"); XS.Push(XSRegisters.EDI); XS.Label(".NO_THIS"); XS.Comment("make space for us to copy the arguments too"); XS.Sub(XSRegisters.ESP, XSRegisters.ECX); XS.Comment("move the current delegate to edi"); XS.Set(XSRegisters.EDI, XSRegisters.EAX, sourceIsIndirect: true); XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceIsIndirect: true); // dereference XS.Comment("move the methodptr from that delegate to edi "); XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.IntPtr System.Delegate._methodPtr")); // XS.Comment("save methodptr on the stack"); XS.Push(XSRegisters.EDI); XS.Comment("move location to copy args to"); XS.Set(XSRegisters.EDI, XSRegisters.ESP); XS.Add(XSRegisters.EDI, 4); //new CPU.Comment("get above the saved methodptr"); //XS.Sub(XSRegisters.ESP, 4); //we allocated the argsize on the stack once, and it we need to get above the original args XS.Comment("we allocated argsize on the stack once"); XS.Comment("add 32 for the Pushad + 16 for the current stack + 4 for the return value"); //uint xToAdd = 32; // skip pushad data //xToAdd += 4; // method pointer XS.Set(XSRegisters.ESI, XSRegisters.EBP); XS.Add(XSRegisters.ESI, 8); // ebp+8 is first argument new CPUx86.Movs { Size = 8, Prefixes = CPUx86.InstructionPrefixes.Repeat }; XS.Pop(XSRegisters.EDI); XS.Label(".BeforeCall"); XS.Call(XSRegisters.EDI); XS.Comment("store return -- return stored into edi after popad"); XS.Comment("edi = ptr to delegate object"); XS.Set(XSRegisters.EDI, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0)); XS.Comment("edi = ptr to delegate object should be a pointer to the delgates context ie (this) for the methods "); XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceIsIndirect: true); // dereference handle XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.Object System.Delegate._target")); //i really dont get the +12, MtW: that's for the object header XS.Label(".noTHIStoPop"); XS.PopAllRegisters(); XS.Increment(XSRegisters.EDX); XS.Add(XSRegisters.EAX, 4); XS.Jump(".BEGIN_OF_LOOP"); } XS.Label(".END_OF_INVOKE_"); XS.Comment("get the return value"); XS.Set(XSRegisters.EDX, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0)); //addrof the delegate XS.Set(XSRegisters.EDX, XSRegisters.EDX, sourceIsIndirect: true); // dereference handle XS.Set(XSRegisters.EDX, XSRegisters.EDX, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "$$ReturnsValue$$")); XS.Compare(XSRegisters.EDX, 0); XS.Jump(CPUx86.ConditionalTestEnum.Equal, ".noReturn"); //may have to expand the return... idk XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationDisplacement: 8); XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationDisplacement: 4); XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationIsIndirect: true); XS.Push(XSRegisters.EDX);//ebp XS.Set(XSRegisters.ESP, XSRegisters.EDI, destinationDisplacement: 12); XS.Label(".noReturn"); XS.EnableInterrupts(); }
public void Initialize(bool enableVBE, string VBEResolution) { uint xSig = 0xe85250d6; //Multiboot header DataMembers.Add(new DataMember("align", "8", true)); DataMembers.Add(new DataMember("MultibootHeader", Array.Empty <byte>())); DataMembers.Add(new DataMember("MultibootSignature", new uint[] { xSig })); DataMembers.Add(new DataMember("MultibootArchitecture", 0)); DataMembers.Add(new DataMember("MultibootLenght", "MultibootHeaderEnd - MultibootHeader", typeof(uint))); DataMembers.Add(new DataMember("MultibootChecksum", "0x100000000 - (0xe85250d6 + 0 + (MultibootHeaderEnd - MultibootHeader))", typeof(uint))); if (enableVBE) { try { string[] res = VBEResolution.Split('x'); //Framebuffer Tag DataMembers.Add(new DataMember("align", "8", true)); DataMembers.Add(new DataMember("MultibootFramebufferTag", Array.Empty <byte>())); DataMembers.Add(new DataMember("MultibootFramebufferType", (ushort)5)); DataMembers.Add(new DataMember("MultibootFramebufferOptional", (ushort)1)); DataMembers.Add(new DataMember("MultibootFramebufferLenght", "MultibootFramebufferTagEnd - MultibootFramebufferTag", typeof(uint))); DataMembers.Add(new DataMember("", int.Parse(res[0]))); DataMembers.Add(new DataMember("", int.Parse(res[1]))); DataMembers.Add(new DataMember("", int.Parse(res[2]))); DataMembers.Add(new DataMember("MultibootFramebufferTagEnd", Array.Empty <byte>())); } catch { Console.WriteLine("VBE Resolution must be this format: 1920x1080x32"); } } // memory DataMembers.Add(new DataMember("align", "8", true)); DataMembers.Add(new DataMember("MultibootMemoryTag", Array.Empty <byte>())); DataMembers.Add(new DataMember("MultibootMemoryTagType", (ushort)2)); DataMembers.Add(new DataMember("MultibootMemoryTagOptional", (ushort)1)); DataMembers.Add(new DataMember("MultibootMemoryTagLenght", "MultibootMemoryTagEnd - MultibootMemoryTag", typeof(uint))); DataMembers.Add(new DataMember("MultibootHeaderAddr", ElementReference.New("MultibootSignature"))); DataMembers.Add(new DataMember("MultibootLoadAddr", ElementReference.New("MultibootSignature"))); DataMembers.Add(new DataMember("MultibootLoadEndAddr", ElementReference.New("_end_code"))); DataMembers.Add(new DataMember("MultibootBSSEndAddr", ElementReference.New("_end_code"))); DataMembers.Add(new DataMember("MultibootMemoryTagEnd", Array.Empty <byte>())); //Entry Address DataMembers.Add(new DataMember("align", "8", true)); DataMembers.Add(new DataMember("MultibootEntryTag", Array.Empty <byte>())); DataMembers.Add(new DataMember("MultibootEntryTagType", (ushort)3)); DataMembers.Add(new DataMember("MultibootEntryTagOptional", (ushort)1)); DataMembers.Add(new DataMember("MultibootEntryTagLenght", "MultibootEntryTagEnd - MultibootEntryTag", typeof(uint))); DataMembers.Add(new DataMember("MultibootEntryAddr", ElementReference.New("Kernel_Start"))); DataMembers.Add(new DataMember("MultibootEntryTagEnd", Array.Empty <byte>())); //End Tag DataMembers.Add(new DataMember("align", "8", true)); DataMembers.Add(new DataMember("MultibootEndTag", Array.Empty <byte>())); DataMembers.Add(new DataMember("MultibootEndTagType", (ushort)0)); DataMembers.Add(new DataMember("MultibootEndTagOptional", (ushort)0)); DataMembers.Add(new DataMember("MultibootEndTagEnd", Array.Empty <byte>())); DataMembers.Add(new DataMember("MultibootHeaderEnd", Array.Empty <byte>())); //memory DataMembers.Add(new DataMember("align", "16", true)); DataMembers.Add(new DataMember("Before_Kernel_Stack", new byte[0x50000])); DataMembers.Add(new DataMember("align", "16", true)); DataMembers.Add(new DataMember("Kernel_Stack", Array.Empty <byte>())); DataMembers.Add(new DataMember("MultiBootInfo_Structure", new uint[1])); // constants DataMembers.Add(new DataMember("align", "16", true)); DataMembers.Add(new DataMember(@"__uint2double_const", new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x41 })); DataMembers.Add(new DataMember("align", "16", true)); DataMembers.Add(new DataMember(@"__ulong2double_const", 0x5F800000)); DataMembers.Add(new DataMember("align", "16", true)); DataMembers.Add(new DataMember(@"__doublesignbit", 0x8000000000000000)); DataMembers.Add(new DataMember("align", "16", true)); DataMembers.Add(new DataMember(@"__floatsignbit", 0x80000000)); if (mComPort > 0) { new Define("DEBUGSTUB"); } // This is our first entry point. Multiboot uses this as Cosmos entry point. new Label("Kernel_Start", isGlobal: true); XS.Set(ESP, "Kernel_Stack"); // Displays "Cosmos" in top left. Used to make sure Cosmos is booted in case of hang. // ie bootloader debugging. This must be the FIRST code, even before setup so we know // we are being called properly by the bootloader and that if there are problems its // somwhere in our code, not the bootloader. WriteDebugVideo("Cosmos pre boot"); // For when using Bochs, causes a break ASAP on entry after initial Cosmos display. //new LiteralAssemblerCode("xchg bx, bx"); // CLI ASAP WriteDebugVideo("Clearing interrupts."); XS.ClearInterruptFlag(); WriteDebugVideo("Begin multiboot info."); new LiteralAssemblerCode("%ifndef EXCLUDE_MULTIBOOT_MAGIC"); new Comment(this, "MultiBoot compliant loader provides info in registers: "); new Comment(this, "EBX=multiboot_info "); new Comment(this, "EAX=0x36d76289 - check if it's really Multiboot2-compliant loader "); new Comment(this, " ;- copy mb info - some stuff for you "); new Comment(this, "BEGIN - Multiboot Info"); new Mov { DestinationRef = ElementReference.New("MultiBootInfo_Structure"), DestinationIsIndirect = true, SourceReg = RegistersEnum.EBX }; XS.Call("SystemVoidCosmosCoreMultiboot2Init"); new Comment(this, "END - Multiboot Info"); new LiteralAssemblerCode("%endif"); WriteDebugVideo("Creating GDT."); CreateGDT(); WriteDebugVideo("Configuring PIC"); ConfigurePIC(); WriteDebugVideo("Creating IDT."); CreateIDT(); //WriteDebugVideo("Initializing SSE."); //new Comment(this, "BEGIN - SSE Init"); //// CR4[bit 9]=1, CR4[bit 10]=1, CR0[bit 2]=0, CR0[bit 1]=1 //XS.Mov(XSRegisters.EAX, XSRegisters.Registers.CR4); //XS.Or(XSRegisters.EAX, 0x100); //XS.Mov(XSRegisters.CR4, XSRegisters.Registers.EAX); //XS.Mov(XSRegisters.EAX, XSRegisters.Registers.CR4); //XS.Or(XSRegisters.EAX, 0x200); //XS.Mov(XSRegisters.CR4, XSRegisters.Registers.EAX); //XS.Mov(XSRegisters.EAX, XSRegisters.Registers.CR0); //XS.And(XSRegisters.EAX, 0xfffffffd); //XS.Mov(XSRegisters.CR0, XSRegisters.Registers.EAX); //XS.Mov(XSRegisters.EAX, XSRegisters.Registers.CR0); //XS.And(XSRegisters.EAX, 1); //XS.Mov(XSRegisters.CR0, XSRegisters.Registers.EAX); //new Comment(this, "END - SSE Init"); if (mComPort > 0) { WriteDebugVideo("Initializing DebugStub."); XS.Call(AsmMarker.Labels[AsmMarker.Type.DebugStub_Init]); } //Initiate Memory WriteDebugVideo("Initiating Memory"); XS.Call(LabelName.Get(GCImplementationRefs.InitRef)); // Jump to Kernel entry point WriteDebugVideo("Jumping to kernel."); XS.Call(EntryPointName); new Comment(this, "Kernel done - loop till next IRQ"); XS.Label(".loop"); XS.ClearInterruptFlag(); XS.Halt(); XS.Jump(".loop"); if (mComPort > 0) { var xGen = new AsmGenerator(); void GenerateAssembler(Assembler assembler) { CurrentInstance.Instructions.AddRange(assembler.Instructions); CurrentInstance.DataMembers.AddRange(assembler.DataMembers); } if (ReadDebugStubFromDisk) { foreach (var xFile in Directory.GetFiles(CosmosPaths.DebugStubSrc, "*.xs")) { GenerateAssembler(xGen.Generate(xFile)); } } else { foreach (var xManifestName in typeof(ReferenceHelper).Assembly.GetManifestResourceNames()) { if (!xManifestName.EndsWith(".xs", StringComparison.OrdinalIgnoreCase)) { continue; } using (var xStream = typeof(ReferenceHelper).Assembly.GetManifestResourceStream(xManifestName)) { using (var xReader = new StreamReader(xStream)) { GenerateAssembler(xGen.Generate(xReader)); } } } } OnAfterEmitDebugStub(); } else { XS.Label(AsmMarker.Labels[AsmMarker.Type.DebugStub_Step]); XS.Return(); } // Start emitting assembly labels CurrentInstance.EmitAsmLabels = true; }