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