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