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
 121     RtlMoveMemory(Buffer, (PVOID)Address, Size);
 122 }
 123
 124 static VOID
 125 NTAPI
 126 Fast486MemWriteCallback(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
 127 {
 128     UNREFERENCED_PARAMETER(State);
 129
 130     RtlMoveMemory((PVOID)Address, Buffer, Size);
 131 }
 132
 133 static VOID
 134 NTAPI
 135 Fast486IoReadCallback(PFAST486_STATE State, ULONG Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
 136 {
 137     UNREFERENCED_PARAMETER(State);
 138     UNREFERENCED_PARAMETER(Port);
 139     UNREFERENCED_PARAMETER(Buffer);
 140     UNREFERENCED_PARAMETER(DataCount);
 141     UNREFERENCED_PARAMETER(DataSize);
 142 }
 143
 144 static VOID
 145 NTAPI
 146 Fast486IoWriteCallback(PFAST486_STATE State, ULONG Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
 147 {
 148     UNREFERENCED_PARAMETER(State);
 149     UNREFERENCED_PARAMETER(Port);
 150     UNREFERENCED_PARAMETER(Buffer);
 151     UNREFERENCED_PARAMETER(DataCount);
 152     UNREFERENCED_PARAMETER(DataSize);
 153 }
 154
 155 static VOID
 156 NTAPI
 157 Fast486IdleCallback(PFAST486_STATE State)
 158 {
 159     UNREFERENCED_PARAMETER(State);
 160 }
 161
 162 static VOID
 163 NTAPI
 164 Fast486BopCallback(PFAST486_STATE State, UCHAR BopCode)
 165 {
 166     UNREFERENCED_PARAMETER(State);
 167     UNREFERENCED_PARAMETER(BopCode);
 168 }
 169
 170 static UCHAR
 171 NTAPI
 172 Fast486IntAckCallback(PFAST486_STATE State)
 173 {
 174     UNREFERENCED_PARAMETER(State);
 175
 176     /* Return something... */
 177     return 0;
 178 }
 179
 180 /* PUBLIC FUNCTIONS ***********************************************************/
 181
 182 VOID
 183 NTAPI
 184 Fast486Initialize(PFAST486_STATE         State,
 185                   FAST486_MEM_READ_PROC  MemReadCallback,
 186                   FAST486_MEM_WRITE_PROC MemWriteCallback,
 187                   FAST486_IO_READ_PROC   IoReadCallback,
 188                   FAST486_IO_WRITE_PROC  IoWriteCallback,
 189                   FAST486_IDLE_PROC      IdleCallback,
 190                   FAST486_BOP_PROC       BopCallback,
 191                   FAST486_INT_ACK_PROC   IntAckCallback,
 192                   PULONG                 Tlb)
 193 {
 194     /* Set the callbacks (or use default ones if some are NULL) */
 195     State->MemReadCallback  = (MemReadCallback  ? MemReadCallback  : Fast486MemReadCallback );
 196     State->MemWriteCallback = (MemWriteCallback ? MemWriteCallback : Fast486MemWriteCallback);
 197     State->IoReadCallback   = (IoReadCallback   ? IoReadCallback   : Fast486IoReadCallback  );
 198     State->IoWriteCallback  = (IoWriteCallback  ? IoWriteCallback  : Fast486IoWriteCallback );
 199     State->IdleCallback     = (IdleCallback     ? IdleCallback     : Fast486IdleCallback    );
 200     State->BopCallback      = (BopCallback      ? BopCallback      : Fast486BopCallback     );
 201     State->IntAckCallback   = (IntAckCallback   ? IntAckCallback   : Fast486IntAckCallback  );
 202
 203     /* Set the TLB (if given) */
 204     State->Tlb = Tlb;
 205
 206     /* Reset the CPU */
 207     Fast486Reset(State);
 208 }
 209
 210 VOID
 211 NTAPI
 212 Fast486Reset(PFAST486_STATE State)
 213 {
 214     FAST486_SEG_REGS i;
 215
 216     FAST486_MEM_READ_PROC  MemReadCallback  = State->MemReadCallback;
 217     FAST486_MEM_WRITE_PROC MemWriteCallback = State->MemWriteCallback;
 218     FAST486_IO_READ_PROC   IoReadCallback   = State->IoReadCallback;
 219     FAST486_IO_WRITE_PROC  IoWriteCallback  = State->IoWriteCallback;
 220     FAST486_IDLE_PROC      IdleCallback     = State->IdleCallback;
 221     FAST486_BOP_PROC       BopCallback      = State->BopCallback;
 222     FAST486_INT_ACK_PROC   IntAckCallback   = State->IntAckCallback;
 223     PULONG                 Tlb              = State->Tlb;
 224
 225     /* Clear the entire structure */
 226     RtlZeroMemory(State, sizeof(*State));
 227
 228     /* Initialize the registers */
 229     State->Flags.AlwaysSet = 1;
 230     State->InstPtr.LowWord = 0xFFF0;
 231
 232     /* Set the CPL to 0 */
 233     State->Cpl = 0;
 234
 235     /* Initialize segments */
 236     for (i = 0; i < FAST486_NUM_SEG_REGS; i++)
 237     {
 238         State->SegmentRegs[i].Selector = 0;
 239         State->SegmentRegs[i].Base = 0;
 240         State->SegmentRegs[i].Limit = 0xFFFF;
 241         State->SegmentRegs[i].Present = TRUE;
 242         State->SegmentRegs[i].ReadWrite = TRUE;
 243         State->SegmentRegs[i].Executable = FALSE;
 244         State->SegmentRegs[i].DirConf = FALSE;
 245         State->SegmentRegs[i].SystemType = 1; // Segment descriptor
 246         State->SegmentRegs[i].Dpl = 0;
 247         State->SegmentRegs[i].Size = FALSE; // 16-bit
 248     }
 249
 250     /* Initialize the code segment */
 251     State->SegmentRegs[FAST486_REG_CS].Executable = TRUE;
 252     State->SegmentRegs[FAST486_REG_CS].Selector = 0xF000;
 253     State->SegmentRegs[FAST486_REG_CS].Base = 0xFFFF0000;
 254
 255     /* Initialize the IDT */
 256     State->Idtr.Size = 0x3FF;
 257     State->Idtr.Address = 0;
 258
 259 #ifndef FAST486_NO_FPU
 260     /* Initialize CR0 */
 261     State->ControlRegisters[FAST486_REG_CR0] |= FAST486_CR0_ET;
 262
 263     /* Initialize the FPU control and tag registers */
 264     State->FpuControl.Value = FAST486_FPU_DEFAULT_CONTROL;
 265     State->FpuStatus.Value = 0;
 266     State->FpuTag = 0xFFFF;
 267 #endif
 268
 269     /* Restore the callbacks and TLB */
 270     State->MemReadCallback  = MemReadCallback;
 271     State->MemWriteCallback = MemWriteCallback;
 272     State->IoReadCallback   = IoReadCallback;
 273     State->IoWriteCallback  = IoWriteCallback;
 274     State->IdleCallback     = IdleCallback;
 275     State->BopCallback      = BopCallback;
 276     State->IntAckCallback   = IntAckCallback;
 277     State->Tlb              = Tlb;
 278 }
 279
 280 VOID
 281 NTAPI
 282 Fast486Interrupt(PFAST486_STATE State, UCHAR Number)
 283 {
 284     /* Set the interrupt status and the number */
 285     State->IntStatus = FAST486_INT_EXECUTE;
 286     State->PendingIntNum = Number;
 287 }
 288
 289 VOID
 290 NTAPI
 291 Fast486InterruptSignal(PFAST486_STATE State)
 292 {
 293     /* Set the interrupt status */
 294     State->IntStatus = FAST486_INT_SIGNAL;
 295 }
 296
 297 VOID
 298 NTAPI
 299 Fast486ExecuteAt(PFAST486_STATE State, USHORT Segment, ULONG Offset)
 300 {
 301     /* Load the new CS */
 302     if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment))
 303     {
 304         /* An exception occurred, let the handler execute instead */
 305         return;
 306     }
 307
 308     /* Set the new IP */
 309     State->InstPtr.Long = Offset;
 310 }
 311
 312 VOID
 313 NTAPI
 314 Fast486SetStack(PFAST486_STATE State, USHORT Segment, ULONG Offset)
 315 {
 316     /* Load the new SS */
 317     if (!Fast486LoadSegment(State, FAST486_REG_SS, Segment))
 318     {
 319         /* An exception occurred, let the handler execute instead */
 320         return;
 321     }
 322
 323     /* Set the new SP */
 324     State->GeneralRegs[FAST486_REG_ESP].Long = Offset;
 325 }
 326
 327 VOID
 328 NTAPI
 329 Fast486SetSegment(PFAST486_STATE State,
 330                   FAST486_SEG_REGS Segment,
 331                   USHORT Selector)
 332 {
 333     /* Call the internal function */
 334     Fast486LoadSegment(State, Segment, Selector);
 335 }
 336
 337 /* EOF */