git.sur5r.net Git - cc65/blob - src/sim65/paravirt.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                paravirt.c                                 */
   4 /*                                                                           */
   5 /*                Paravirtualization for the sim65 6502 simulator            */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2013-2013 Ullrich von Bassewitz                                       */
  10 /*               Römerstrasse 52                                             */
  11 /*               D-70794 Filderstadt                                         */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <string.h>
  37 #include <stdlib.h>
  38 #include <fcntl.h>
  39 #if defined(_WIN32)
  40 #  define O_INITIAL O_BINARY
  41 #else
  42 #  define O_INITIAL 0
  43 #endif
  44 #if defined(_MSC_VER)
  45 /* Microsoft compiler */
  46 #  include <io.h>
  47 #else
  48 /* Anyone else */
  49 #  include <unistd.h>
  50 #endif
  51
  52 /* common */
  53 #include "cmdline.h"
  54 #include "print.h"
  55 #include "xmalloc.h"
  56
  57 /* sim65 */
  58 #include "6502.h"
  59 #include "memory.h"
  60 #include "paravirt.h"
  61
  62
  63
  64 /*****************************************************************************/
  65 /*                                   Data                                    */
  66 /*****************************************************************************/
  67
  68
  69
  70 typedef void (*PVFunc) (CPURegs* Regs);
  71
  72 static unsigned ArgStart;
  73
  74
  75
  76 /*****************************************************************************/
  77 /*                                   Code                                    */
  78 /*****************************************************************************/
  79
  80
  81
  82 static unsigned GetAX (CPURegs* Regs)
  83 {
  84     return Regs->AC + (Regs->XR << 8);
  85 }
  86
  87
  88
  89 static void SetAX (CPURegs* Regs, unsigned Val)
  90 {
  91     Regs->AC = Val & 0xFF;
  92     Val >>= 8;
  93     Regs->XR = Val;
  94 }
  95
  96
  97
  98 static void MemWriteWord (unsigned Addr, unsigned Val)
  99 {
 100     MemWriteByte (Addr, Val);
 101     Val >>= 8;
 102     MemWriteByte (Addr + 1, Val);
 103 }
 104
 105
 106
 107 static unsigned char Pop (CPURegs* Regs)
 108 {
 109     return MemReadByte (0x0100 + ++Regs->SP);
 110 }
 111
 112
 113
 114 static unsigned PopParam (unsigned char Incr)
 115 {
 116     unsigned SP = MemReadZPWord (0x00);
 117     unsigned Val = MemReadWord (SP);
 118     MemWriteWord (0x0000, SP + Incr);
 119     return Val;
 120 }
 121
 122
 123
 124 static void PVArgs (CPURegs* Regs)
 125 {
 126     unsigned ArgC = ArgCount - ArgStart;
 127     unsigned ArgV = GetAX (Regs);
 128     unsigned SP   = MemReadZPWord (0x00);
 129     unsigned Args = SP - (ArgC + 1) * 2;
 130
 131     Print (stderr, 2, "PVArgs ($%04X)\n", ArgV);
 132
 133     MemWriteWord (ArgV, Args);
 134
 135     SP = Args;
 136     while (ArgStart < ArgCount) {
 137         unsigned I = 0;
 138         const char* Arg = ArgVec[ArgStart++];
 139         SP -= strlen (Arg) + 1;
 140         do {
 141             MemWriteByte (SP + I, Arg[I]);
 142         }
 143         while (Arg[I++]);
 144
 145         MemWriteWord (Args, SP);
 146         Args += 2;
 147     }
 148     MemWriteWord (Args, 0x0000);
 149
 150     MemWriteWord (0x0000, SP);
 151     SetAX (Regs, ArgC);
 152 }
 153
 154
 155
 156 static void PVExit (CPURegs* Regs)
 157 {
 158     Print (stderr, 1, "PVExit ($%02X)\n", Regs->AC);
 159
 160     exit (Regs->AC);
 161 }
 162
 163
 164
 165 static void PVOpen (CPURegs* Regs)
 166 {
 167     char Path[1024];
 168     int OFlag = O_INITIAL;
 169     unsigned RetVal, I = 0;
 170
 171     unsigned Mode  = PopParam (Regs->YR - 4);
 172     unsigned Flags = PopParam (2);
 173     unsigned Name  = PopParam (2);
 174
 175     do {
 176         Path[I] = MemReadByte (Name++);
 177     }
 178     while (Path[I++]);
 179
 180     Print (stderr, 2, "PVOpen (\"%s\", $%04X)\n", Path, Flags);
 181
 182     switch (Flags & 0x03) {
 183         case 0x01:
 184             OFlag |= O_RDONLY;
 185             break;
 186         case 0x02:
 187             OFlag |= O_WRONLY;
 188             break;
 189         case 0x03:
 190             OFlag |= O_RDWR;
 191             break;
 192     }
 193     if (Flags & 0x10) {
 194         OFlag |= O_CREAT;
 195     }
 196     if (Flags & 0x20) {
 197         OFlag |= O_TRUNC;
 198     }
 199     if (Flags & 0x40) {
 200         OFlag |= O_APPEND;
 201     }
 202     if (Flags & 0x80) {
 203         OFlag |= O_EXCL;
 204     }
 205
 206     /* Avoid gcc warning */
 207     (void) Mode;
 208
 209     RetVal = open (Path, OFlag);
 210
 211     SetAX (Regs, RetVal);
 212 }
 213
 214
 215
 216 static void PVClose (CPURegs* Regs)
 217 {
 218     unsigned RetVal;
 219
 220     unsigned FD = GetAX (Regs);
 221
 222     Print (stderr, 2, "PVClose ($%04X)\n", FD);
 223
 224     RetVal = close (FD);
 225
 226     SetAX (Regs, RetVal);
 227 }
 228
 229
 230
 231 static void PVRead (CPURegs* Regs)
 232 {
 233     unsigned char* Data;
 234     unsigned RetVal, I = 0;
 235
 236     unsigned Count = GetAX (Regs);
 237     unsigned Buf   = PopParam (2);
 238     unsigned FD    = PopParam (2);
 239
 240     Print (stderr, 2, "PVRead ($%04X, $%04X, $%04X)\n", FD, Buf, Count);
 241
 242     Data = xmalloc (Count);
 243
 244     RetVal = read (FD, Data, Count);
 245
 246     if (RetVal != (unsigned) -1) {
 247         while (I < RetVal) {
 248             MemWriteByte (Buf++, Data[I++]);
 249         }
 250     }
 251     xfree (Data);
 252
 253     SetAX (Regs, RetVal);
 254 }
 255
 256
 257
 258 static void PVWrite (CPURegs* Regs)
 259 {
 260     unsigned char* Data;
 261     unsigned RetVal, I = 0;
 262
 263     unsigned Count = GetAX (Regs);
 264     unsigned Buf   = PopParam (2);
 265     unsigned FD    = PopParam (2);
 266
 267     Print (stderr, 2, "PVWrite ($%04X, $%04X, $%04X)\n", FD, Buf, Count);
 268
 269     Data = xmalloc (Count);
 270     while (I < Count) {
 271         Data[I++] = MemReadByte (Buf++);
 272     }
 273
 274     RetVal = write (FD, Data, Count);
 275
 276     xfree (Data);
 277
 278     SetAX (Regs, RetVal);
 279 }
 280
 281
 282
 283 static const PVFunc Hooks[] = {
 284     PVArgs,
 285     PVExit,
 286     PVOpen,
 287     PVClose,
 288     PVRead,
 289     PVWrite,
 290 };
 291
 292
 293
 294 void ParaVirtInit (unsigned aArgStart)
 295 /* Initialize the paravirtualization subsystem */
 296 {
 297     ArgStart = aArgStart;
 298 };
 299
 300
 301
 302 void ParaVirtHooks (CPURegs* Regs)
 303 /* Potentially execute paravirtualization hooks */
 304 {
 305     /* Check for paravirtualization address range */
 306     if (Regs->PC <  0xFFF0 ||
 307         Regs->PC >= 0xFFF0 + sizeof (Hooks) / sizeof (Hooks[0])) {
 308         return;
 309     }
 310
 311     /* Call paravirtualization hook */
 312     Hooks[Regs->PC - 0xFFF0] (Regs);
 313
 314     /* Simulate RTS */
 315     Regs->PC = Pop(Regs) + (Pop(Regs) << 8) + 1;
 316 }