subsystems/ntvdm/registers.c

   1 /*
   2  * COPYRIGHT:       GPL - See COPYING in the top level directory
   3  * PROJECT:         ReactOS Virtual DOS Machine
   4  * FILE:            registers.c
   5  * PURPOSE:         Exported functions for manipulating registers
   6  * PROGRAMMERS:     Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #define NDEBUG
  12
  13 #include "emulator.h"
  14
  15 // TODO: Should be moved to fast486.h
  16 enum
  17 {
  18     EMULATOR_REG_EAX,
  19     EMULATOR_REG_ECX,
  20     EMULATOR_REG_EDX,
  21     EMULATOR_REG_EBX,
  22     EMULATOR_REG_ESP,
  23     EMULATOR_REG_EBP,
  24     EMULATOR_REG_ESI,
  25     EMULATOR_REG_EDI,
  26
  27     EMULATOR_REG_ES,
  28     EMULATOR_REG_CS,
  29     EMULATOR_REG_SS,
  30     EMULATOR_REG_DS,
  31     EMULATOR_REG_FS,
  32     EMULATOR_REG_GS
  33 };
  34
  35 /* PUBLIC FUNCTIONS ***********************************************************/
  36
  37 ULONG EmulatorGetRegister(ULONG Register)
  38 {
  39     if (Register < EMULATOR_REG_ES)
  40     {
  41         return EmulatorContext.GeneralRegs[Register].Long;
  42     }
  43     else
  44     {
  45         return EmulatorContext.SegmentRegs[Register - EMULATOR_REG_ES].Selector;
  46     }
  47 }
  48
  49 VOID EmulatorSetRegister(ULONG Register, ULONG Value)
  50 {
  51     if (Register < EMULATOR_REG_ES)
  52     {
  53         EmulatorContext.GeneralRegs[Register].Long = Value;
  54     }
  55     else
  56     {
  57         Fast486SetSegment(&EmulatorContext, Register - EMULATOR_REG_ES, (USHORT)Value);
  58     }
  59 }
  60
  61 BOOLEAN EmulatorGetFlag(ULONG Flag)
  62 {
  63     return (EmulatorContext.Flags.Long & Flag) ? TRUE : FALSE;
  64 }
  65
  66 VOID EmulatorSetFlag(ULONG Flag)
  67 {
  68     EmulatorContext.Flags.Long |= Flag;
  69 }
  70
  71 VOID EmulatorClearFlag(ULONG Flag)
  72 {
  73     EmulatorContext.Flags.Long &= ~Flag;
  74 }
  75
  76 VOID EmulatorSetStack(WORD Segment, DWORD Offset)
  77 {
  78     Fast486SetStack(&EmulatorContext, Segment, Offset);
  79 }
  80
  81
  82
  83 ULONG
  84 CDECL
  85 getEAX(VOID)
  86 {
  87     return EmulatorContext.GeneralRegs[EMULATOR_REG_EAX].Long;
  88 }
  89
  90 VOID
  91 CDECL
  92 setEAX(ULONG Value)
  93 {
  94     EmulatorContext.GeneralRegs[EMULATOR_REG_EAX].Long = Value;
  95 }
  96
  97 USHORT
  98 CDECL
  99 getAX(VOID)
 100 {
 101     return EmulatorContext.GeneralRegs[EMULATOR_REG_EAX].LowWord;
 102 }
 103
 104 VOID
 105 CDECL
 106 setAX(USHORT Value)
 107 {
 108     EmulatorContext.GeneralRegs[EMULATOR_REG_EAX].LowWord = Value;
 109 }
 110
 111 UCHAR
 112 CDECL
 113 getAH(VOID)
 114 {
 115     return EmulatorContext.GeneralRegs[EMULATOR_REG_EAX].HighByte;
 116 }
 117
 118 VOID
 119 CDECL
 120 setAH(UCHAR Value)
 121 {
 122     EmulatorContext.GeneralRegs[EMULATOR_REG_EAX].HighByte = Value;
 123 }
 124
 125 UCHAR
 126 CDECL
 127 getAL(VOID)
 128 {
 129     return EmulatorContext.GeneralRegs[EMULATOR_REG_EAX].LowByte;
 130 }
 131
 132 VOID
 133 CDECL
 134 setAL(UCHAR Value)
 135 {
 136     EmulatorContext.GeneralRegs[EMULATOR_REG_EAX].LowByte = Value;
 137 }
 138
 139 ULONG
 140 CDECL
 141 getEBX(VOID)
 142 {
 143     return EmulatorContext.GeneralRegs[EMULATOR_REG_EBX].Long;
 144 }
 145
 146 VOID
 147 CDECL
 148 setEBX(ULONG Value)
 149 {
 150     EmulatorContext.GeneralRegs[EMULATOR_REG_EBX].Long = Value;
 151 }
 152
 153 USHORT
 154 CDECL
 155 getBX(VOID)
 156 {
 157     return EmulatorContext.GeneralRegs[EMULATOR_REG_EBX].LowWord;
 158 }
 159
 160 VOID
 161 CDECL
 162 setBX(USHORT Value)
 163 {
 164     EmulatorContext.GeneralRegs[EMULATOR_REG_EBX].LowWord = Value;
 165 }
 166
 167 UCHAR
 168 CDECL
 169 getBH(VOID)
 170 {
 171     return EmulatorContext.GeneralRegs[EMULATOR_REG_EBX].HighByte;
 172 }
 173
 174 VOID
 175 CDECL
 176 setBH(UCHAR Value)
 177 {
 178     EmulatorContext.GeneralRegs[EMULATOR_REG_EBX].HighByte = Value;
 179 }
 180
 181 UCHAR
 182 CDECL
 183 getBL(VOID)
 184 {
 185     return EmulatorContext.GeneralRegs[EMULATOR_REG_EBX].LowByte;
 186 }
 187
 188 VOID
 189 CDECL
 190 setBL(UCHAR Value)
 191 {
 192     EmulatorContext.GeneralRegs[EMULATOR_REG_EBX].LowByte = Value;
 193 }
 194
 195
 196
 197 ULONG
 198 CDECL
 199 getECX(VOID)
 200 {
 201     return EmulatorContext.GeneralRegs[EMULATOR_REG_ECX].Long;
 202 }
 203
 204 VOID
 205 CDECL
 206 setECX(ULONG Value)
 207 {
 208     EmulatorContext.GeneralRegs[EMULATOR_REG_ECX].Long = Value;
 209 }
 210
 211 USHORT
 212 CDECL
 213 getCX(VOID)
 214 {
 215     return EmulatorContext.GeneralRegs[EMULATOR_REG_ECX].LowWord;
 216 }
 217
 218 VOID
 219 CDECL
 220 setCX(USHORT Value)
 221 {
 222     EmulatorContext.GeneralRegs[EMULATOR_REG_ECX].LowWord = Value;
 223 }
 224
 225 UCHAR
 226 CDECL
 227 getCH(VOID)
 228 {
 229     return EmulatorContext.GeneralRegs[EMULATOR_REG_ECX].HighByte;
 230 }
 231
 232 VOID
 233 CDECL
 234 setCH(UCHAR Value)
 235 {
 236     EmulatorContext.GeneralRegs[EMULATOR_REG_ECX].HighByte = Value;
 237 }
 238
 239 UCHAR
 240 CDECL
 241 getCL(VOID)
 242 {
 243     return EmulatorContext.GeneralRegs[EMULATOR_REG_ECX].LowByte;
 244 }
 245
 246 VOID
 247 CDECL
 248 setCL(UCHAR Value)
 249 {
 250     EmulatorContext.GeneralRegs[EMULATOR_REG_ECX].LowByte = Value;
 251 }
 252
 253
 254
 255 ULONG
 256 CDECL
 257 getEDX(VOID)
 258 {
 259     return EmulatorContext.GeneralRegs[EMULATOR_REG_EDX].Long;
 260 }
 261
 262 VOID
 263 CDECL
 264 setEDX(ULONG Value)
 265 {
 266     EmulatorContext.GeneralRegs[EMULATOR_REG_EDX].Long = Value;
 267 }
 268
 269 USHORT
 270 CDECL
 271 getDX(VOID)
 272 {
 273     return EmulatorContext.GeneralRegs[EMULATOR_REG_EDX].LowWord;
 274 }
 275
 276 VOID
 277 CDECL
 278 setDX(USHORT Value)
 279 {
 280     EmulatorContext.GeneralRegs[EMULATOR_REG_EDX].LowWord = Value;
 281 }
 282
 283 UCHAR
 284 CDECL
 285 getDH(VOID)
 286 {
 287     return EmulatorContext.GeneralRegs[EMULATOR_REG_EDX].HighByte;
 288 }
 289
 290 VOID
 291 CDECL
 292 setDH(UCHAR Value)
 293 {
 294     EmulatorContext.GeneralRegs[EMULATOR_REG_EDX].HighByte = Value;
 295 }
 296
 297 UCHAR
 298 CDECL
 299 getDL(VOID)
 300 {
 301     return EmulatorContext.GeneralRegs[EMULATOR_REG_EDX].LowByte;
 302 }
 303
 304 VOID
 305 CDECL
 306 setDL(UCHAR Value)
 307 {
 308     EmulatorContext.GeneralRegs[EMULATOR_REG_EDX].LowByte = Value;
 309 }
 310
 311
 312
 313 ULONG
 314 CDECL
 315 getESP(VOID)
 316 {
 317     return EmulatorGetRegister(EMULATOR_REG_ESP);
 318 }
 319
 320 VOID
 321 CDECL
 322 setESP(ULONG Value)
 323 {
 324     EmulatorSetStack(EmulatorGetRegister(EMULATOR_REG_SS), Value);
 325 }
 326
 327 USHORT
 328 CDECL
 329 getSP(VOID)
 330 {
 331     return LOWORD(EmulatorGetRegister(EMULATOR_REG_ESP));
 332 }
 333
 334 VOID
 335 CDECL
 336 setSP(USHORT Value)
 337 {
 338     EmulatorSetStack(EmulatorGetRegister(EMULATOR_REG_SS), Value);
 339 }
 340
 341
 342
 343 ULONG
 344 CDECL
 345 getEBP(VOID)
 346 {
 347     return EmulatorContext.GeneralRegs[EMULATOR_REG_EBP].Long;
 348 }
 349
 350 VOID
 351 CDECL
 352 setEBP(ULONG Value)
 353 {
 354     EmulatorContext.GeneralRegs[EMULATOR_REG_EBP].Long = Value;
 355 }
 356
 357 USHORT
 358 CDECL
 359 getBP(VOID)
 360 {
 361     return EmulatorContext.GeneralRegs[EMULATOR_REG_EBP].LowWord;
 362 }
 363
 364 VOID
 365 CDECL
 366 setBP(USHORT Value)
 367 {
 368     EmulatorContext.GeneralRegs[EMULATOR_REG_EBP].LowWord = Value;
 369 }
 370
 371
 372
 373 ULONG
 374 CDECL
 375 getESI(VOID)
 376 {
 377     return EmulatorContext.GeneralRegs[EMULATOR_REG_ESI].Long;
 378 }
 379
 380 VOID
 381 CDECL
 382 setESI(ULONG Value)
 383 {
 384     EmulatorContext.GeneralRegs[EMULATOR_REG_ESI].Long = Value;
 385 }
 386
 387 USHORT
 388 CDECL
 389 getSI(VOID)
 390 {
 391     return EmulatorContext.GeneralRegs[EMULATOR_REG_ESI].LowWord;
 392 }
 393
 394 VOID
 395 CDECL
 396 setSI(USHORT Value)
 397 {
 398     EmulatorContext.GeneralRegs[EMULATOR_REG_ESI].LowWord = Value;
 399 }
 400
 401
 402
 403 ULONG
 404 CDECL
 405 getEDI(VOID)
 406 {
 407     return EmulatorContext.GeneralRegs[EMULATOR_REG_EDI].Long;
 408 }
 409
 410 VOID
 411 CDECL
 412 setEDI(ULONG Value)
 413 {
 414     EmulatorContext.GeneralRegs[EMULATOR_REG_EDI].Long = Value;
 415 }
 416
 417 USHORT
 418 CDECL
 419 getDI(VOID)
 420 {
 421     return EmulatorContext.GeneralRegs[EMULATOR_REG_EDI].LowWord;
 422 }
 423
 424 VOID
 425 CDECL
 426 setDI(USHORT Value)
 427 {
 428     EmulatorContext.GeneralRegs[EMULATOR_REG_EDI].LowWord = Value;
 429 }
 430
 431
 432
 433 ULONG
 434 CDECL
 435 getEIP(VOID)
 436 {
 437     return EmulatorContext.InstPtr.Long;
 438 }
 439
 440 VOID
 441 CDECL
 442 setEIP(ULONG Value)
 443 {
 444     EmulatorExecute(EmulatorGetRegister(EMULATOR_REG_CS), Value);
 445 }
 446
 447 USHORT
 448 CDECL
 449 getIP(VOID)
 450 {
 451     return EmulatorContext.InstPtr.LowWord;
 452 }
 453
 454 VOID
 455 CDECL
 456 setIP(USHORT Value)
 457 {
 458     EmulatorExecute(EmulatorGetRegister(EMULATOR_REG_CS), Value);
 459 }
 460
 461
 462
 463 USHORT
 464 CDECL
 465 getCS(VOID)
 466 {
 467     return EmulatorGetRegister(EMULATOR_REG_CS);
 468 }
 469
 470 VOID
 471 CDECL
 472 setCS(USHORT Value)
 473 {
 474     EmulatorSetRegister(EMULATOR_REG_CS, Value);
 475 }
 476
 477 USHORT
 478 CDECL
 479 getSS(VOID)
 480 {
 481     return EmulatorGetRegister(EMULATOR_REG_SS);
 482 }
 483
 484 VOID
 485 CDECL
 486 setSS(USHORT Value)
 487 {
 488     EmulatorSetRegister(EMULATOR_REG_SS, Value);
 489 }
 490
 491 USHORT
 492 CDECL
 493 getDS(VOID)
 494 {
 495     return EmulatorGetRegister(EMULATOR_REG_DS);
 496 }
 497
 498 VOID
 499 CDECL
 500 setDS(USHORT Value)
 501 {
 502     EmulatorSetRegister(EMULATOR_REG_DS, Value);
 503 }
 504
 505 USHORT
 506 CDECL
 507 getES(VOID)
 508 {
 509     return EmulatorGetRegister(EMULATOR_REG_ES);
 510 }
 511
 512 VOID
 513 CDECL
 514 setES(USHORT Value)
 515 {
 516     EmulatorSetRegister(EMULATOR_REG_ES, Value);
 517 }
 518
 519 USHORT
 520 CDECL
 521 getFS(VOID)
 522 {
 523     return EmulatorGetRegister(EMULATOR_REG_FS);
 524 }
 525
 526 VOID
 527 CDECL
 528 setFS(USHORT Value)
 529 {
 530     EmulatorSetRegister(EMULATOR_REG_FS, Value);
 531 }
 532
 533 USHORT
 534 CDECL
 535 getGS(VOID)
 536 {
 537     return EmulatorGetRegister(EMULATOR_REG_GS);
 538 }
 539
 540 VOID
 541 CDECL
 542 setGS(USHORT Value)
 543 {
 544     EmulatorSetRegister(EMULATOR_REG_GS, Value);
 545 }
 546
 547
 548
 549 ULONG
 550 CDECL
 551 getCF(VOID)
 552 {
 553     return EmulatorGetFlag(EMULATOR_FLAG_CF);
 554 }
 555
 556 VOID
 557 CDECL
 558 setCF(ULONG Flag)
 559 {
 560     if (Flag & 1)
 561         EmulatorSetFlag(EMULATOR_FLAG_CF);
 562     else
 563         EmulatorClearFlag(EMULATOR_FLAG_CF);
 564 }
 565
 566 ULONG
 567 CDECL
 568 getPF(VOID)
 569 {
 570     return EmulatorGetFlag(EMULATOR_FLAG_PF);
 571 }
 572
 573 VOID
 574 CDECL
 575 setPF(ULONG Flag)
 576 {
 577     if (Flag & 1)
 578         EmulatorSetFlag(EMULATOR_FLAG_PF);
 579     else
 580         EmulatorClearFlag(EMULATOR_FLAG_PF);
 581 }
 582
 583 ULONG
 584 CDECL
 585 getAF(VOID)
 586 {
 587     return EmulatorGetFlag(EMULATOR_FLAG_AF);
 588 }
 589
 590 VOID
 591 CDECL
 592 setAF(ULONG Flag)
 593 {
 594     if (Flag & 1)
 595         EmulatorSetFlag(EMULATOR_FLAG_AF);
 596     else
 597         EmulatorClearFlag(EMULATOR_FLAG_AF);
 598 }
 599
 600 ULONG
 601 CDECL
 602 getZF(VOID)
 603 {
 604     return EmulatorGetFlag(EMULATOR_FLAG_ZF);
 605 }
 606
 607 VOID
 608 CDECL
 609 setZF(ULONG Flag)
 610 {
 611     if (Flag & 1)
 612         EmulatorSetFlag(EMULATOR_FLAG_ZF);
 613     else
 614         EmulatorClearFlag(EMULATOR_FLAG_ZF);
 615 }
 616
 617 ULONG
 618 CDECL
 619 getSF(VOID)
 620 {
 621     return EmulatorGetFlag(EMULATOR_FLAG_SF);
 622 }
 623
 624 VOID
 625 CDECL
 626 setSF(ULONG Flag)
 627 {
 628     if (Flag & 1)
 629         EmulatorSetFlag(EMULATOR_FLAG_SF);
 630     else
 631         EmulatorClearFlag(EMULATOR_FLAG_SF);
 632 }
 633
 634 ULONG
 635 CDECL
 636 getIF(VOID)
 637 {
 638     return EmulatorGetFlag(EMULATOR_FLAG_IF);
 639 }
 640
 641 VOID
 642 CDECL
 643 setIF(ULONG Flag)
 644 {
 645     if (Flag & 1)
 646         EmulatorSetFlag(EMULATOR_FLAG_IF);
 647     else
 648         EmulatorClearFlag(EMULATOR_FLAG_IF);
 649 }
 650
 651 ULONG
 652 CDECL
 653 getDF(VOID)
 654 {
 655     return EmulatorGetFlag(EMULATOR_FLAG_DF);
 656 }
 657
 658 VOID
 659 CDECL
 660 setDF(ULONG Flag)
 661 {
 662     if (Flag & 1)
 663         EmulatorSetFlag(EMULATOR_FLAG_DF);
 664     else
 665         EmulatorClearFlag(EMULATOR_FLAG_DF);
 666 }
 667
 668 ULONG
 669 CDECL
 670 getOF(VOID)
 671 {
 672     return EmulatorGetFlag(EMULATOR_FLAG_OF);
 673 }
 674
 675 VOID
 676 CDECL
 677 setOF(ULONG Flag)
 678 {
 679     if (Flag & 1)
 680         EmulatorSetFlag(EMULATOR_FLAG_OF);
 681     else
 682         EmulatorClearFlag(EMULATOR_FLAG_OF);
 683 }
 684
 685
 686
 687 ULONG
 688 CDECL
 689 getEFLAGS(VOID)
 690 {
 691     return EmulatorContext.Flags.Long;
 692 }
 693
 694 VOID
 695 CDECL
 696 setEFLAGS(ULONG Flags)
 697 {
 698     EmulatorContext.Flags.Long = Flags;
 699 }
 700
 701
 702
 703 USHORT
 704 CDECL
 705 getMSW(VOID)
 706 {
 707     return 0; // UNIMPLEMENTED
 708 }
 709
 710 VOID
 711 CDECL
 712 setMSW(USHORT Value)
 713 {
 714     // UNIMPLEMENTED
 715 }
 716
 717 /* EOF */