reactos/lib/fast486/fast486.c

   1 /*
   2  * Fast486 386/486 CPU Emulation Library
   3  * fast486.c
   4  *
   5  * Copyright (C) 2014 Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  */
  21
  22 /* INCLUDES *******************************************************************/
  23
  24 #include <windef.h>
  25
  26 // #define NDEBUG
  27 #include <debug.h>
  28
  29 #include <fast486.h>
  30 #include "common.h"
  31 #include "opcodes.h"
  32 #include "fpu.h"
  33
  34 /* DEFINES ********************************************************************/
  35
  36 typedef enum
  37 {
  38     FAST486_STEP_INTO,
  39     FAST486_STEP_OVER,
  40     FAST486_STEP_OUT,
  41     FAST486_CONTINUE
  42 } FAST486_EXEC_CMD;
  43
  44 /* PRIVATE FUNCTIONS **********************************************************/
  45
  46 VOID
  47 NTAPI
  48 Fast486ExecutionControl(PFAST486_STATE State, FAST486_EXEC_CMD Command)
  49 {
  50     UCHAR Opcode;
  51     FAST486_OPCODE_HANDLER_PROC CurrentHandler;
  52     INT ProcedureCallCount = 0;
  53
  54     /* Main execution loop */
  55     do
  56     {
  57 NextInst:
  58         /* Check if this is a new instruction */
  59         if (State->PrefixFlags == 0) State->SavedInstPtr = State->InstPtr;
  60
  61         /* Perform an instruction fetch */
  62         if (!Fast486FetchByte(State, &Opcode))
  63         {
  64             /* Exception occurred */
  65             State->PrefixFlags = 0;
  66             continue;
  67         }
  68
  69         // TODO: Check for CALL/RET to update ProcedureCallCount.
  70
  71         /* Call the opcode handler */
  72         CurrentHandler = Fast486OpcodeHandlers[Opcode];
  73         CurrentHandler(State, Opcode);
  74
  75         /* If this is a prefix, go to the next instruction immediately */
  76         if (CurrentHandler == Fast486OpcodePrefix) goto NextInst;
  77
  78         /* A non-prefix opcode has been executed, reset the prefix flags */
  79         State->PrefixFlags = 0;
  80
  81         /*
  82          * Check if there is an interrupt to execute, or a hardware interrupt signal
  83          * while interrupts are enabled.
  84          */
  85         if (State->IntStatus == FAST486_INT_EXECUTE)
  86         {
  87             /* Perform the interrupt */
  88             Fast486PerformInterrupt(State, State->PendingIntNum);
  89
  90             /* Clear the interrupt status */
  91             State->IntStatus = FAST486_INT_NONE;
  92         }
  93         else if (State->Flags.If && (State->IntStatus == FAST486_INT_SIGNAL)
  94                                  && (State->IntAckCallback != NULL))
  95         {
  96             /* Acknowledge the interrupt to get the number */
  97             State->PendingIntNum = State->IntAckCallback(State);
  98
  99             /* Set the interrupt status to execute on the next instruction */
 100             State->IntStatus = FAST486_INT_EXECUTE;
 101         }
 102         else if (State->IntStatus == FAST486_INT_DELAYED)
 103         {
 104             /* Restore the old state */
 105             State->IntStatus = FAST486_INT_EXECUTE;
 106         }
 107     }
 108     while ((Command == FAST486_CONTINUE) ||
 109            (Command == FAST486_STEP_OVER && ProcedureCallCount > 0) ||
 110            (Command == FAST486_STEP_OUT && ProcedureCallCount >= 0));
 111 }
 112
 113 /* DEFAULT CALLBACKS **********************************************************/
 114
 115 static VOID
 116 NTAPI
 117 Fast486MemReadCallback(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
 118 {
 119     UNREFERENCED_PARAMETER(State);
 120     RtlMoveMemory(Buffer, (PVOID)Address, Size);
 121 }
 122
 123 static VOID
 124 NTAPI
 125 Fast486MemWriteCallback(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
 126 {
 127     UNREFERENCED_PARAMETER(State);
 128     RtlMoveMemory((PVOID)Address, Buffer, Size);
 129 }
 130
 131 static VOID
 132 NTAPI
 133 Fast486IoReadCallback(PFAST486_STATE State, ULONG Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
 134 {
 135     UNREFERENCED_PARAMETER(State);
 136     UNREFERENCED_PARAMETER(Port);
 137     UNREFERENCED_PARAMETER(Buffer);
 138     UNREFERENCED_PARAMETER(DataCount);
 139     UNREFERENCED_PARAMETER(DataSize);
 140 }
 141
 142 static VOID
 143 NTAPI
 144 Fast486IoWriteCallback(PFAST486_STATE State, ULONG Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
 145 {
 146     UNREFERENCED_PARAMETER(State);
 147     UNREFERENCED_PARAMETER(Port);
 148     UNREFERENCED_PARAMETER(Buffer);
 149     UNREFERENCED_PARAMETER(DataCount);
 150     UNREFERENCED_PARAMETER(DataSize);
 151 }
 152
 153 static VOID
 154 NTAPI
 155 Fast486IdleCallback(PFAST486_STATE State)
 156 {
 157     UNREFERENCED_PARAMETER(State);
 158 }
 159
 160 static VOID
 161 NTAPI
 162 Fast486BopCallback(PFAST486_STATE State, UCHAR BopCode)
 163 {
 164     UNREFERENCED_PARAMETER(State);
 165     UNREFERENCED_PARAMETER(BopCode);
 166 }
 167
 168 static UCHAR
 169 NTAPI
 170 Fast486IntAckCallback(PFAST486_STATE State)
 171 {
 172     UNREFERENCED_PARAMETER(State);
 173
 174     /* Return something... */
 175     return 0;
 176 }
 177
 178 /* PUBLIC FUNCTIONS ***********************************************************/
 179
 180 VOID
 181 NTAPI
 182 Fast486Initialize(PFAST486_STATE         State,
 183                   FAST486_MEM_READ_PROC  MemReadCallback,
 184                   FAST486_MEM_WRITE_PROC MemWriteCallback,
 185                   FAST486_IO_READ_PROC   IoReadCallback,
 186                   FAST486_IO_WRITE_PROC  IoWriteCallback,
 187                   FAST486_IDLE_PROC      IdleCallback,
 188                   FAST486_BOP_PROC       BopCallback,
 189                   FAST486_INT_ACK_PROC   IntAckCallback,
 190                   PULONG                 Tlb)
 191 {
 192     /* Set the callbacks (or use default ones if some are NULL) */
 193     State->MemReadCallback  = (MemReadCallback  ? MemReadCallback  : Fast486MemReadCallback );
 194     State->MemWriteCallback = (MemWriteCallback ? MemWriteCallback : Fast486MemWriteCallback);
 195     State->IoReadCallback   = (IoReadCallback   ? IoReadCallback   : Fast486IoReadCallback  );
 196     State->IoWriteCallback  = (IoWriteCallback  ? IoWriteCallback  : Fast486IoWriteCallback );
 197     State->IdleCallback     = (IdleCallback     ? IdleCallback     : Fast486IdleCallback    );
 198     State->BopCallback      = (BopCallback      ? BopCallback      : Fast486BopCallback     );
 199     State->IntAckCallback   = (IntAckCallback   ? IntAckCallback   : Fast486IntAckCallback  );
 200
 201     /* Set the TLB (if given) */
 202     State->Tlb = Tlb;
 203
 204     /* Reset the CPU */
 205     Fast486Reset(State);
 206 }
 207
 208 VOID
 209 NTAPI
 210 Fast486Reset(PFAST486_STATE State)
 211 {
 212     FAST486_SEG_REGS i;
 213
 214     FAST486_MEM_READ_PROC  MemReadCallback  = State->MemReadCallback;
 215     FAST486_MEM_WRITE_PROC MemWriteCallback = State->MemWriteCallback;
 216     FAST486_IO_READ_PROC   IoReadCallback   = State->IoReadCallback;
 217     FAST486_IO_WRITE_PROC  IoWriteCallback  = State->IoWriteCallback;
 218     FAST486_IDLE_PROC      IdleCallback     = State->IdleCallback;
 219     FAST486_BOP_PROC       BopCallback      = State->BopCallback;
 220     FAST486_INT_ACK_PROC   IntAckCallback   = State->IntAckCallback;
 221     PULONG                 Tlb              = State->Tlb;
 222
 223     /* Clear the entire structure */
 224     RtlZeroMemory(State, sizeof(*State));
 225
 226     /* Initialize the registers */
 227     State->Flags.AlwaysSet = 1;
 228     State->InstPtr.LowWord = 0xFFF0;
 229
 230     /* Set the CPL to 0 */
 231     State->Cpl = 0;
 232
 233     /* Initialize segments */
 234     for (i = 0; i < FAST486_NUM_SEG_REGS; i++)
 235     {
 236         State->SegmentRegs[i].Selector = 0;
 237         State->SegmentRegs[i].Base = 0;
 238         State->SegmentRegs[i].Limit = 0xFFFF;
 239         State->SegmentRegs[i].Present = TRUE;
 240         State->SegmentRegs[i].ReadWrite = TRUE;
 241         State->SegmentRegs[i].Executable = FALSE;
 242         State->SegmentRegs[i].DirConf = FALSE;
 243         State->SegmentRegs[i].SystemType = 1; // Segment descriptor
 244         State->SegmentRegs[i].Dpl = 0;
 245         State->SegmentRegs[i].Size = FALSE; // 16-bit
 246     }
 247
 248     /* Initialize the code segment */
 249     State->SegmentRegs[FAST486_REG_CS].Executable = TRUE;
 250     State->SegmentRegs[FAST486_REG_CS].Selector = 0xF000;
 251     State->SegmentRegs[FAST486_REG_CS].Base = 0xFFFF0000;
 252
 253     /* Initialize the IDT */
 254     State->Idtr.Size = 0x3FF;
 255     State->Idtr.Address = 0;
 256
 257 #ifndef FAST486_NO_FPU
 258     /* Initialize CR0 */
 259     State->ControlRegisters[FAST486_REG_CR0] |= FAST486_CR0_ET;
 260
 261     /* Initialize the FPU control and tag registers */
 262     State->FpuControl.Value = FAST486_FPU_DEFAULT_CONTROL;
 263     State->FpuStatus.Value = 0;
 264     State->FpuTag = 0xFFFF;
 265 #endif
 266
 267     /* Restore the callbacks and TLB */
 268     State->MemReadCallback  = MemReadCallback;
 269     State->MemWriteCallback = MemWriteCallback;
 270     State->IoReadCallback   = IoReadCallback;
 271     State->IoWriteCallback  = IoWriteCallback;
 272     State->IdleCallback     = IdleCallback;
 273     State->BopCallback      = BopCallback;
 274     State->IntAckCallback   = IntAckCallback;
 275     State->Tlb              = Tlb;
 276 }
 277
 278 VOID
 279 NTAPI
 280 Fast486Interrupt(PFAST486_STATE State, UCHAR Number)
 281 {
 282     /* Set the interrupt status and the number */
 283     State->IntStatus = FAST486_INT_EXECUTE;
 284     State->PendingIntNum = Number;
 285 }
 286
 287 VOID
 288 NTAPI
 289 Fast486InterruptSignal(PFAST486_STATE State)
 290 {
 291     /* Set the interrupt status */
 292     State->IntStatus = FAST486_INT_SIGNAL;
 293 }
 294
 295 VOID
 296 NTAPI
 297 Fast486ExecuteAt(PFAST486_STATE State, USHORT Segment, ULONG Offset)
 298 {
 299     /* Load the new CS */
 300     if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment))
 301     {
 302         /* An exception occurred, let the handler execute instead */
 303         return;
 304     }
 305
 306     /* Set the new IP */
 307     State->InstPtr.Long = Offset;
 308 }
 309
 310 VOID
 311 NTAPI
 312 Fast486SetStack(PFAST486_STATE State, USHORT Segment, ULONG Offset)
 313 {
 314     /* Load the new SS */
 315     if (!Fast486LoadSegment(State, FAST486_REG_SS, Segment))
 316     {
 317         /* An exception occurred, let the handler execute instead */
 318         return;
 319     }
 320
 321     /* Set the new SP */
 322     State->GeneralRegs[FAST486_REG_ESP].Long = Offset;
 323 }
 324
 325 VOID
 326 NTAPI
 327 Fast486SetSegment(PFAST486_STATE State,
 328                   FAST486_SEG_REGS Segment,
 329                   USHORT Selector)
 330 {
 331     /* Call the internal function */
 332     Fast486LoadSegment(State, Segment, Selector);
 333 }
 334
 335 /* EOF */