Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1081 lines
16 KiB

  1. /*++
  2. Copyright (c) 1991 Microsoft Corporation
  3. Copyright (c) 1992 Digital Equipment Corporation
  4. Module Name:
  5. getsetrg.c
  6. Abstract:
  7. This module implement the code necessary to get and set register values.
  8. These routines are used during the emulation of unaligned data references
  9. and floating point exceptions.
  10. Author:
  11. David N. Cutler (davec) 17-Jun-1991
  12. Environment:
  13. Kernel mode only.
  14. Revision History:
  15. Thomas Van Baak (tvb) 14-Jul-1992
  16. Adapted for NT/Alpha
  17. --*/
  18. #include "ki.h"
  19. ULONGLONG
  20. KiGetRegisterValue (
  21. IN ULONG Register,
  22. IN PKEXCEPTION_FRAME ExceptionFrame,
  23. IN PKTRAP_FRAME TrapFrame
  24. )
  25. /*++
  26. Routine Description:
  27. This function is called to get the value of a register from the specified
  28. exception or trap frame.
  29. Arguments:
  30. Register - Supplies the number of the register whose value is to be
  31. returned. Integer registers are specified as 0 - 31 and floating
  32. registers are specified as 32 - 63.
  33. ExceptionFrame - Supplies a pointer to an exception frame.
  34. TrapFrame - Supplies a pointer to a trap frame.
  35. Return Value:
  36. The value of the specified register is returned as the function value.
  37. --*/
  38. {
  39. //
  40. // Dispatch on the register number.
  41. //
  42. switch (Register) {
  43. //
  44. // Integer register V0.
  45. //
  46. case 0:
  47. return TrapFrame->IntV0;
  48. //
  49. // Integer register T0.
  50. //
  51. case 1:
  52. return TrapFrame->IntT0;
  53. //
  54. // Integer register T1.
  55. //
  56. case 2:
  57. return TrapFrame->IntT1;
  58. //
  59. // Integer register T2.
  60. //
  61. case 3:
  62. return TrapFrame->IntT2;
  63. //
  64. // Integer register T3.
  65. //
  66. case 4:
  67. return TrapFrame->IntT3;
  68. //
  69. // Integer register T4.
  70. //
  71. case 5:
  72. return TrapFrame->IntT4;
  73. //
  74. // Integer register T5.
  75. //
  76. case 6:
  77. return TrapFrame->IntT5;
  78. //
  79. // Integer register T6.
  80. //
  81. case 7:
  82. return TrapFrame->IntT6;
  83. //
  84. // Integer register T7.
  85. //
  86. case 8:
  87. return TrapFrame->IntT7;
  88. //
  89. // Integer register S0.
  90. //
  91. case 9:
  92. return ExceptionFrame->IntS0;
  93. //
  94. // Integer register S1.
  95. //
  96. case 10:
  97. return ExceptionFrame->IntS1;
  98. //
  99. // Integer register S2.
  100. //
  101. case 11:
  102. return ExceptionFrame->IntS2;
  103. //
  104. // Integer register S3.
  105. //
  106. case 12:
  107. return ExceptionFrame->IntS3;
  108. //
  109. // Integer register S4.
  110. //
  111. case 13:
  112. return ExceptionFrame->IntS4;
  113. //
  114. // Integer register S5.
  115. //
  116. case 14:
  117. return ExceptionFrame->IntS5;
  118. //
  119. // Integer register S6/Fp.
  120. //
  121. // N.B. Unlike the other S registers, S6 is obtained from the trap
  122. // frame instead of the exception frame since it is used by the kernel
  123. // as a trap frame pointer.
  124. //
  125. case 15:
  126. return TrapFrame->IntFp;
  127. //
  128. // Integer register A0.
  129. //
  130. case 16:
  131. return TrapFrame->IntA0;
  132. //
  133. // Integer register A1.
  134. //
  135. case 17:
  136. return TrapFrame->IntA1;
  137. //
  138. // Integer register A2
  139. //
  140. case 18:
  141. return TrapFrame->IntA2;
  142. //
  143. // Integer register A3.
  144. //
  145. case 19:
  146. return TrapFrame->IntA3;
  147. //
  148. // Integer register A4.
  149. //
  150. case 20:
  151. return TrapFrame->IntA4;
  152. //
  153. // Integer register A5.
  154. //
  155. case 21:
  156. return TrapFrame->IntA5;
  157. //
  158. // Integer register T8.
  159. //
  160. case 22:
  161. return TrapFrame->IntT8;
  162. //
  163. // Integer register T9.
  164. //
  165. case 23:
  166. return TrapFrame->IntT9;
  167. //
  168. // Integer register T10.
  169. //
  170. case 24:
  171. return TrapFrame->IntT10;
  172. //
  173. // Integer register T11.
  174. //
  175. case 25:
  176. return TrapFrame->IntT11;
  177. //
  178. // Integer register Ra.
  179. //
  180. case 26:
  181. return TrapFrame->IntRa;
  182. //
  183. // Integer register T12.
  184. //
  185. case 27:
  186. return TrapFrame->IntT12;
  187. //
  188. // Integer register At.
  189. //
  190. case 28:
  191. return TrapFrame->IntAt;
  192. //
  193. // Integer register Gp.
  194. //
  195. case 29:
  196. return TrapFrame->IntGp;
  197. //
  198. // Integer register Sp.
  199. //
  200. case 30:
  201. return TrapFrame->IntSp;
  202. //
  203. // Integer register Zero.
  204. //
  205. case 31:
  206. return 0;
  207. //
  208. // Floating register F0.
  209. //
  210. case 32:
  211. return TrapFrame->FltF0;
  212. //
  213. // Floating register F1.
  214. //
  215. case 33:
  216. return TrapFrame->FltF1;
  217. //
  218. // Floating register F2.
  219. //
  220. case 34:
  221. return ExceptionFrame->FltF2;
  222. //
  223. // Floating register F3.
  224. //
  225. case 35:
  226. return ExceptionFrame->FltF3;
  227. //
  228. // Floating register F4.
  229. //
  230. case 36:
  231. return ExceptionFrame->FltF4;
  232. //
  233. // Floating register F5.
  234. //
  235. case 37:
  236. return ExceptionFrame->FltF5;
  237. //
  238. // Floating register F6.
  239. //
  240. case 38:
  241. return ExceptionFrame->FltF6;
  242. //
  243. // Floating register F7.
  244. //
  245. case 39:
  246. return ExceptionFrame->FltF7;
  247. //
  248. // Floating register F8.
  249. //
  250. case 40:
  251. return ExceptionFrame->FltF8;
  252. //
  253. // Floating register F9.
  254. //
  255. case 41:
  256. return ExceptionFrame->FltF9;
  257. //
  258. // Floating register F10.
  259. //
  260. case 42:
  261. return TrapFrame->FltF10;
  262. //
  263. // Floating register F11.
  264. //
  265. case 43:
  266. return TrapFrame->FltF11;
  267. //
  268. // Floating register F12.
  269. //
  270. case 44:
  271. return TrapFrame->FltF12;
  272. //
  273. // Floating register F13.
  274. //
  275. case 45:
  276. return TrapFrame->FltF13;
  277. //
  278. // Floating register F14.
  279. //
  280. case 46:
  281. return TrapFrame->FltF14;
  282. //
  283. // Floating register F15.
  284. //
  285. case 47:
  286. return TrapFrame->FltF15;
  287. //
  288. // Floating register F16.
  289. //
  290. case 48:
  291. return TrapFrame->FltF16;
  292. //
  293. // Floating register F17.
  294. //
  295. case 49:
  296. return TrapFrame->FltF17;
  297. //
  298. // Floating register F18.
  299. //
  300. case 50:
  301. return TrapFrame->FltF18;
  302. //
  303. // Floating register F19.
  304. //
  305. case 51:
  306. return TrapFrame->FltF19;
  307. //
  308. // Floating register F20.
  309. //
  310. case 52:
  311. return TrapFrame->FltF20;
  312. //
  313. // Floating register F21.
  314. //
  315. case 53:
  316. return TrapFrame->FltF21;
  317. //
  318. // Floating register F22.
  319. //
  320. case 54:
  321. return TrapFrame->FltF22;
  322. //
  323. // Floating register F23.
  324. //
  325. case 55:
  326. return TrapFrame->FltF23;
  327. //
  328. // Floating register F24.
  329. //
  330. case 56:
  331. return TrapFrame->FltF24;
  332. //
  333. // Floating register F25.
  334. //
  335. case 57:
  336. return TrapFrame->FltF25;
  337. //
  338. // Floating register F26.
  339. //
  340. case 58:
  341. return TrapFrame->FltF26;
  342. //
  343. // Floating register F27.
  344. //
  345. case 59:
  346. return TrapFrame->FltF27;
  347. //
  348. // Floating register F28.
  349. //
  350. case 60:
  351. return TrapFrame->FltF28;
  352. //
  353. // Floating register F29.
  354. //
  355. case 61:
  356. return TrapFrame->FltF29;
  357. //
  358. // Floating register F30.
  359. //
  360. case 62:
  361. return TrapFrame->FltF30;
  362. //
  363. // Floating register F31 (Zero).
  364. //
  365. case 63:
  366. return 0;
  367. }
  368. }
  369. VOID
  370. KiSetRegisterValue (
  371. IN ULONG Register,
  372. IN ULONGLONG Value,
  373. OUT PKEXCEPTION_FRAME ExceptionFrame,
  374. OUT PKTRAP_FRAME TrapFrame
  375. )
  376. /*++
  377. Routine Description:
  378. This function is called to set the value of a register in the specified
  379. exception or trap frame.
  380. Arguments:
  381. Register - Supplies the number of the register whose value is to be
  382. stored. Integer registers are specified as 0 - 31 and floating
  383. registers are specified as 32 - 63.
  384. Value - Supplies the value to be stored in the specified register.
  385. ExceptionFrame - Supplies a pointer to an exception frame.
  386. TrapFrame - Supplies a pointer to a trap frame.
  387. Return Value:
  388. None.
  389. --*/
  390. {
  391. //
  392. // Dispatch on the register number.
  393. //
  394. switch (Register) {
  395. //
  396. // Integer register V0.
  397. //
  398. case 0:
  399. TrapFrame->IntV0 = Value;
  400. return;
  401. //
  402. // Integer register T0.
  403. //
  404. case 1:
  405. TrapFrame->IntT0 = Value;
  406. return;
  407. //
  408. // Integer register T1.
  409. //
  410. case 2:
  411. TrapFrame->IntT1 = Value;
  412. return;
  413. //
  414. // Integer register T2.
  415. //
  416. case 3:
  417. TrapFrame->IntT2 = Value;
  418. return;
  419. //
  420. // Integer register T3.
  421. //
  422. case 4:
  423. TrapFrame->IntT3 = Value;
  424. return;
  425. //
  426. // Integer register T4.
  427. //
  428. case 5:
  429. TrapFrame->IntT4 = Value;
  430. return;
  431. //
  432. // Integer register T5.
  433. //
  434. case 6:
  435. TrapFrame->IntT5 = Value;
  436. return;
  437. //
  438. // Integer register T6.
  439. //
  440. case 7:
  441. TrapFrame->IntT6 = Value;
  442. return;
  443. //
  444. // Integer register T7.
  445. //
  446. case 8:
  447. TrapFrame->IntT7 = Value;
  448. return;
  449. //
  450. // Integer register S0.
  451. //
  452. case 9:
  453. ExceptionFrame->IntS0 = Value;
  454. return;
  455. //
  456. // Integer register S1.
  457. //
  458. case 10:
  459. ExceptionFrame->IntS1 = Value;
  460. return;
  461. //
  462. // Integer register S2.
  463. //
  464. case 11:
  465. ExceptionFrame->IntS2 = Value;
  466. return;
  467. //
  468. // Integer register S3.
  469. //
  470. case 12:
  471. ExceptionFrame->IntS3 = Value;
  472. return;
  473. //
  474. // Integer register S4.
  475. //
  476. case 13:
  477. ExceptionFrame->IntS4 = Value;
  478. return;
  479. //
  480. // Integer register S5.
  481. //
  482. case 14:
  483. ExceptionFrame->IntS5 = Value;
  484. return;
  485. //
  486. // Integer register S6/Fp.
  487. //
  488. // N.B. Unlike the other S registers, S6 is stored back in the trap
  489. // frame instead of the exception frame since it is used by the kernel
  490. // as a trap frame pointer.
  491. //
  492. case 15:
  493. TrapFrame->IntFp = Value;
  494. return;
  495. //
  496. // Integer register A0.
  497. //
  498. case 16:
  499. TrapFrame->IntA0 = Value;
  500. return;
  501. //
  502. // Integer register A1.
  503. //
  504. case 17:
  505. TrapFrame->IntA1 = Value;
  506. return;
  507. //
  508. // Integer register A2.
  509. //
  510. case 18:
  511. TrapFrame->IntA2 = Value;
  512. return;
  513. //
  514. // Integer register A3.
  515. //
  516. case 19:
  517. TrapFrame->IntA3 = Value;
  518. return;
  519. //
  520. // Integer register A4.
  521. //
  522. case 20:
  523. TrapFrame->IntA4 = Value;
  524. return;
  525. //
  526. // Integer register A5.
  527. //
  528. case 21:
  529. TrapFrame->IntA5 = Value;
  530. return;
  531. //
  532. // Integer register T8.
  533. //
  534. case 22:
  535. TrapFrame->IntT8 = Value;
  536. return;
  537. //
  538. // Integer register T9.
  539. //
  540. case 23:
  541. TrapFrame->IntT9 = Value;
  542. return;
  543. //
  544. // Integer register T10.
  545. //
  546. case 24:
  547. TrapFrame->IntT10 = Value;
  548. return;
  549. //
  550. // Integer register T11.
  551. //
  552. case 25:
  553. TrapFrame->IntT11 = Value;
  554. return;
  555. //
  556. // Integer register Ra.
  557. //
  558. case 26:
  559. TrapFrame->IntRa = Value;
  560. return;
  561. //
  562. // Integer register T12.
  563. //
  564. case 27:
  565. TrapFrame->IntT12 = Value;
  566. return;
  567. //
  568. // Integer register At.
  569. //
  570. case 28:
  571. TrapFrame->IntAt = Value;
  572. return;
  573. //
  574. // Integer register Gp.
  575. //
  576. case 29:
  577. TrapFrame->IntGp = Value;
  578. return;
  579. //
  580. // Integer register Sp.
  581. //
  582. case 30:
  583. TrapFrame->IntSp = Value;
  584. return;
  585. //
  586. // Integer register Zero.
  587. //
  588. case 31:
  589. return;
  590. //
  591. // Floating register F0.
  592. //
  593. case 32:
  594. TrapFrame->FltF0 = Value;
  595. return;
  596. //
  597. // Floating register F1.
  598. //
  599. case 33:
  600. TrapFrame->FltF1 = Value;
  601. return;
  602. //
  603. // Floating register F2.
  604. //
  605. case 34:
  606. ExceptionFrame->FltF2 = Value;
  607. return;
  608. //
  609. // Floating register F3.
  610. //
  611. case 35:
  612. ExceptionFrame->FltF3 = Value;
  613. return;
  614. //
  615. // Floating register F4.
  616. //
  617. case 36:
  618. ExceptionFrame->FltF4 = Value;
  619. return;
  620. //
  621. // Floating register F5.
  622. //
  623. case 37:
  624. ExceptionFrame->FltF5 = Value;
  625. return;
  626. //
  627. // Floating register F6.
  628. //
  629. case 38:
  630. ExceptionFrame->FltF6 = Value;
  631. return;
  632. //
  633. // Floating register F7.
  634. //
  635. case 39:
  636. ExceptionFrame->FltF7 = Value;
  637. return;
  638. //
  639. // Floating register F8.
  640. //
  641. case 40:
  642. ExceptionFrame->FltF8 = Value;
  643. return;
  644. //
  645. // Floating register F9.
  646. //
  647. case 41:
  648. ExceptionFrame->FltF9 = Value;
  649. return;
  650. //
  651. // Floating register F10.
  652. //
  653. case 42:
  654. TrapFrame->FltF10 = Value;
  655. return;
  656. //
  657. // Floating register F11.
  658. //
  659. case 43:
  660. TrapFrame->FltF11 = Value;
  661. return;
  662. //
  663. // Floating register F12.
  664. //
  665. case 44:
  666. TrapFrame->FltF12 = Value;
  667. return;
  668. //
  669. // Floating register F13.
  670. //
  671. case 45:
  672. TrapFrame->FltF13 = Value;
  673. return;
  674. //
  675. // Floating register F14.
  676. //
  677. case 46:
  678. TrapFrame->FltF14 = Value;
  679. return;
  680. //
  681. // Floating register F15.
  682. //
  683. case 47:
  684. TrapFrame->FltF15 = Value;
  685. return;
  686. //
  687. // Floating register F16.
  688. //
  689. case 48:
  690. TrapFrame->FltF16 = Value;
  691. return;
  692. //
  693. // Floating register F17.
  694. //
  695. case 49:
  696. TrapFrame->FltF17 = Value;
  697. return;
  698. //
  699. // Floating register F18.
  700. //
  701. case 50:
  702. TrapFrame->FltF18 = Value;
  703. return;
  704. //
  705. // Floating register F19.
  706. //
  707. case 51:
  708. TrapFrame->FltF19 = Value;
  709. return;
  710. //
  711. // Floating register F20.
  712. //
  713. case 52:
  714. TrapFrame->FltF20 = Value;
  715. return;
  716. //
  717. // Floating register F21.
  718. //
  719. case 53:
  720. TrapFrame->FltF21 = Value;
  721. return;
  722. //
  723. // Floating register F22.
  724. //
  725. case 54:
  726. TrapFrame->FltF22 = Value;
  727. return;
  728. //
  729. // Floating register F23.
  730. //
  731. case 55:
  732. TrapFrame->FltF23 = Value;
  733. return;
  734. //
  735. // Floating register F24.
  736. //
  737. case 56:
  738. TrapFrame->FltF24 = Value;
  739. return;
  740. //
  741. // Floating register F25.
  742. //
  743. case 57:
  744. TrapFrame->FltF25 = Value;
  745. return;
  746. //
  747. // Floating register F26.
  748. //
  749. case 58:
  750. TrapFrame->FltF26 = Value;
  751. return;
  752. //
  753. // Floating register F27.
  754. //
  755. case 59:
  756. TrapFrame->FltF27 = Value;
  757. return;
  758. //
  759. // Floating register F28.
  760. //
  761. case 60:
  762. TrapFrame->FltF28 = Value;
  763. return;
  764. //
  765. // Floating register F29.
  766. //
  767. case 61:
  768. TrapFrame->FltF29 = Value;
  769. return;
  770. //
  771. // Floating register F30.
  772. //
  773. case 62:
  774. TrapFrame->FltF30 = Value;
  775. return;
  776. //
  777. // Floating register F31 (Zero).
  778. //
  779. case 63:
  780. return;
  781. }
  782. }