![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to op.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / target-alpha|
Return to op.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-alpha |
1.1 root 1: /*
2: * Alpha emulation cpu micro-operations for qemu.
3: *
4: * Copyright (c) 2007 Jocelyn Mayer
5: *
6: * This library is free software; you can redistribute it and/or
7: * modify it under the terms of the GNU Lesser General Public
8: * License as published by the Free Software Foundation; either
9: * version 2 of the License, or (at your option) any later version.
10: *
11: * This library is distributed in the hope that it will be useful,
12: * but WITHOUT ANY WARRANTY; without even the implied warranty of
13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: * Lesser General Public License for more details.
15: *
16: * You should have received a copy of the GNU Lesser General Public
17: * License along with this library; if not, write to the Free Software
18: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19: */
20:
21: #define DEBUG_OP
22:
23: #include "config.h"
24: #include "exec.h"
25: #include "host-utils.h"
26:
27: #include "op_helper.h"
28:
29: #define REG 0
30: #include "op_template.h"
31:
32: #define REG 1
33: #include "op_template.h"
34:
35: #define REG 2
36: #include "op_template.h"
37:
38: #define REG 3
39: #include "op_template.h"
40:
41: #define REG 4
42: #include "op_template.h"
43:
44: #define REG 5
45: #include "op_template.h"
46:
47: #define REG 6
48: #include "op_template.h"
49:
50: #define REG 7
51: #include "op_template.h"
52:
53: #define REG 8
54: #include "op_template.h"
55:
56: #define REG 9
57: #include "op_template.h"
58:
59: #define REG 10
60: #include "op_template.h"
61:
62: #define REG 11
63: #include "op_template.h"
64:
65: #define REG 12
66: #include "op_template.h"
67:
68: #define REG 13
69: #include "op_template.h"
70:
71: #define REG 14
72: #include "op_template.h"
73:
74: #define REG 15
75: #include "op_template.h"
76:
77: #define REG 16
78: #include "op_template.h"
79:
80: #define REG 17
81: #include "op_template.h"
82:
83: #define REG 18
84: #include "op_template.h"
85:
86: #define REG 19
87: #include "op_template.h"
88:
89: #define REG 20
90: #include "op_template.h"
91:
92: #define REG 21
93: #include "op_template.h"
94:
95: #define REG 22
96: #include "op_template.h"
97:
98: #define REG 23
99: #include "op_template.h"
100:
101: #define REG 24
102: #include "op_template.h"
103:
104: #define REG 25
105: #include "op_template.h"
106:
107: #define REG 26
108: #include "op_template.h"
109:
110: #define REG 27
111: #include "op_template.h"
112:
113: #define REG 28
114: #include "op_template.h"
115:
116: #define REG 29
117: #include "op_template.h"
118:
119: #define REG 30
120: #include "op_template.h"
121:
122: #define REG 31
123: #include "op_template.h"
124:
125: /* Debug stuff */
126: void OPPROTO op_no_op (void)
127: {
128: #if !defined (DEBUG_OP)
129: __asm__ __volatile__("nop" : : : "memory");
130: #endif
131: RETURN();
132: }
133:
134: void OPPROTO op_tb_flush (void)
135: {
136: helper_tb_flush();
137: RETURN();
138: }
139:
140: /* Load and stores */
141: #define MEMSUFFIX _raw
142: #include "op_mem.h"
143: #if !defined(CONFIG_USER_ONLY)
144: #define MEMSUFFIX _kernel
145: #include "op_mem.h"
146: #define MEMSUFFIX _executive
147: #include "op_mem.h"
148: #define MEMSUFFIX _supervisor
149: #include "op_mem.h"
150: #define MEMSUFFIX _user
151: #include "op_mem.h"
152: /* This is used for pal modes */
153: #define MEMSUFFIX _data
154: #include "op_mem.h"
155: #endif
156:
157: /* Special operation for load and store */
158: void OPPROTO op_n7 (void)
159: {
160: T0 &= ~(uint64_t)0x7;
161: RETURN();
162: }
163:
164: /* Misc */
165: void OPPROTO op_excp (void)
166: {
167: helper_excp(PARAM(1), PARAM(2));
168: RETURN();
169: }
170:
171: void OPPROTO op_load_amask (void)
172: {
173: helper_amask();
174: RETURN();
175: }
176:
177: void OPPROTO op_load_pcc (void)
178: {
179: helper_load_pcc();
180: RETURN();
181: }
182:
183: void OPPROTO op_load_implver (void)
184: {
185: helper_load_implver();
186: RETURN();
187: }
188:
189: void OPPROTO op_load_fpcr (void)
190: {
191: helper_load_fpcr();
192: RETURN();
193: }
194:
195: void OPPROTO op_store_fpcr (void)
196: {
197: helper_store_fpcr();
198: RETURN();
199: }
200:
201: void OPPROTO op_load_irf (void)
202: {
203: helper_load_irf();
204: RETURN();
205: }
206:
207: void OPPROTO op_set_irf (void)
208: {
209: helper_set_irf();
210: RETURN();
211: }
212:
213: void OPPROTO op_clear_irf (void)
214: {
215: helper_clear_irf();
216: RETURN();
217: }
218:
219: void OPPROTO op_exit_tb (void)
220: {
221: EXIT_TB();
222: }
223:
224: /* Arithmetic */
225: void OPPROTO op_addq (void)
226: {
227: T0 += T1;
228: RETURN();
229: }
230:
231: void OPPROTO op_addqv (void)
232: {
233: helper_addqv();
234: RETURN();
235: }
236:
237: void OPPROTO op_addl (void)
238: {
239: T0 = (int64_t)((int32_t)(T0 + T1));
240: RETURN();
241: }
242:
243: void OPPROTO op_addlv (void)
244: {
245: helper_addlv();
246: RETURN();
247: }
248:
249: void OPPROTO op_subq (void)
250: {
251: T0 -= T1;
252: RETURN();
253: }
254:
255: void OPPROTO op_subqv (void)
256: {
257: helper_subqv();
258: RETURN();
259: }
260:
261: void OPPROTO op_subl (void)
262: {
263: T0 = (int64_t)((int32_t)(T0 - T1));
264: RETURN();
265: }
266:
267: void OPPROTO op_sublv (void)
268: {
269: helper_sublv();
270: RETURN();
271: }
272:
273: void OPPROTO op_s4 (void)
274: {
275: T0 <<= 2;
276: RETURN();
277: }
278:
279: void OPPROTO op_s8 (void)
280: {
281: T0 <<= 3;
282: RETURN();
283: }
284:
285: void OPPROTO op_mull (void)
286: {
287: T0 = (int64_t)((int32_t)T0 * (int32_t)T1);
288: RETURN();
289: }
290:
291: void OPPROTO op_mullv (void)
292: {
293: helper_mullv();
294: RETURN();
295: }
296:
297: void OPPROTO op_mulq (void)
298: {
299: T0 = (int64_t)T0 * (int64_t)T1;
300: RETURN();
301: }
302:
303: void OPPROTO op_mulqv (void)
304: {
305: helper_mulqv();
306: RETURN();
307: }
308:
309: void OPPROTO op_umulh (void)
310: {
311: uint64_t tl, th;
312:
313: mulu64(&tl, &th, T0, T1);
314: T0 = th;
315: RETURN();
316: }
317:
318: /* Logical */
319: void OPPROTO op_and (void)
320: {
321: T0 &= T1;
322: RETURN();
323: }
324:
325: void OPPROTO op_bic (void)
326: {
327: T0 &= ~T1;
328: RETURN();
329: }
330:
331: void OPPROTO op_bis (void)
332: {
333: T0 |= T1;
334: RETURN();
335: }
336:
337: void OPPROTO op_eqv (void)
338: {
339: T0 ^= ~T1;
340: RETURN();
341: }
342:
343: void OPPROTO op_ornot (void)
344: {
345: T0 |= ~T1;
346: RETURN();
347: }
348:
349: void OPPROTO op_xor (void)
350: {
351: T0 ^= T1;
352: RETURN();
353: }
354:
355: void OPPROTO op_sll (void)
356: {
357: T0 <<= T1;
358: RETURN();
359: }
360:
361: void OPPROTO op_srl (void)
362: {
363: T0 >>= T1;
364: RETURN();
365: }
366:
367: void OPPROTO op_sra (void)
368: {
369: T0 = (int64_t)T0 >> T1;
370: RETURN();
371: }
372:
373: void OPPROTO op_sextb (void)
374: {
375: T0 = (int64_t)((int8_t)T0);
376: RETURN();
377: }
378:
379: void OPPROTO op_sextw (void)
380: {
381: T0 = (int64_t)((int16_t)T0);
382: RETURN();
383:
384: }
385:
386: void OPPROTO op_ctpop (void)
387: {
388: helper_ctpop();
389: RETURN();
390: }
391:
392: void OPPROTO op_ctlz (void)
393: {
394: helper_ctlz();
395: RETURN();
396: }
397:
398: void OPPROTO op_cttz (void)
399: {
400: helper_cttz();
401: RETURN();
402: }
403:
404: void OPPROTO op_mskbl (void)
405: {
406: helper_mskbl();
407: RETURN();
408: }
409:
410: void OPPROTO op_extbl (void)
411: {
412: helper_extbl();
413: RETURN();
414: }
415:
416: void OPPROTO op_insbl (void)
417: {
418: helper_insbl();
419: RETURN();
420: }
421:
422: void OPPROTO op_mskwl (void)
423: {
424: helper_mskwl();
425: RETURN();
426: }
427:
428: void OPPROTO op_extwl (void)
429: {
430: helper_extwl();
431: RETURN();
432: }
433:
434: void OPPROTO op_inswl (void)
435: {
436: helper_inswl();
437: RETURN();
438: }
439:
440: void OPPROTO op_mskll (void)
441: {
442: helper_mskll();
443: RETURN();
444: }
445:
446: void OPPROTO op_extll (void)
447: {
448: helper_extll();
449: RETURN();
450: }
451:
452: void OPPROTO op_insll (void)
453: {
454: helper_insll();
455: RETURN();
456: }
457:
458: void OPPROTO op_zap (void)
459: {
460: helper_zap();
461: RETURN();
462: }
463:
464: void OPPROTO op_zapnot (void)
465: {
466: helper_zapnot();
467: RETURN();
468: }
469:
470: void OPPROTO op_mskql (void)
471: {
472: helper_mskql();
473: RETURN();
474: }
475:
476: void OPPROTO op_extql (void)
477: {
478: helper_extql();
479: RETURN();
480: }
481:
482: void OPPROTO op_insql (void)
483: {
484: helper_insql();
485: RETURN();
486: }
487:
488: void OPPROTO op_mskwh (void)
489: {
490: helper_mskwh();
491: RETURN();
492: }
493:
494: void OPPROTO op_inswh (void)
495: {
496: helper_inswh();
497: RETURN();
498: }
499:
500: void OPPROTO op_extwh (void)
501: {
502: helper_extwh();
503: RETURN();
504: }
505:
506: void OPPROTO op_msklh (void)
507: {
508: helper_msklh();
509: RETURN();
510: }
511:
512: void OPPROTO op_inslh (void)
513: {
514: helper_inslh();
515: RETURN();
516: }
517:
518: void OPPROTO op_extlh (void)
519: {
520: helper_extlh();
521: RETURN();
522: }
523:
524: void OPPROTO op_mskqh (void)
525: {
526: helper_mskqh();
527: RETURN();
528: }
529:
530: void OPPROTO op_insqh (void)
531: {
532: helper_insqh();
533: RETURN();
534: }
535:
536: void OPPROTO op_extqh (void)
537: {
538: helper_extqh();
539: RETURN();
540: }
541:
542: /* Tests */
543: void OPPROTO op_cmpult (void)
544: {
545: if (T0 < T1)
546: T0 = 1;
547: else
548: T0 = 0;
549: RETURN();
550: }
551:
552: void OPPROTO op_cmpule (void)
553: {
554: if (T0 <= T1)
555: T0 = 1;
556: else
557: T0 = 0;
558: RETURN();
559: }
560:
561: void OPPROTO op_cmpeq (void)
562: {
563: if (T0 == T1)
564: T0 = 1;
565: else
566: T0 = 0;
567: RETURN();
568: }
569:
570: void OPPROTO op_cmplt (void)
571: {
572: if ((int64_t)T0 < (int64_t)T1)
573: T0 = 1;
574: else
575: T0 = 0;
576: RETURN();
577: }
578:
579: void OPPROTO op_cmple (void)
580: {
581: if ((int64_t)T0 <= (int64_t)T1)
582: T0 = 1;
583: else
584: T0 = 0;
585: RETURN();
586: }
587:
588: void OPPROTO op_cmpbge (void)
589: {
590: helper_cmpbge();
591: RETURN();
592: }
593:
594: void OPPROTO op_cmpeqz (void)
595: {
596: if (T0 == 0)
597: T0 = 1;
598: else
599: T0 = 0;
600: RETURN();
601: }
602:
603: void OPPROTO op_cmpnez (void)
604: {
605: if (T0 != 0)
606: T0 = 1;
607: else
608: T0 = 0;
609: RETURN();
610: }
611:
612: void OPPROTO op_cmpltz (void)
613: {
614: if ((int64_t)T0 < 0)
615: T0 = 1;
616: else
617: T0 = 0;
618: RETURN();
619: }
620:
621: void OPPROTO op_cmplez (void)
622: {
623: if ((int64_t)T0 <= 0)
624: T0 = 1;
625: else
626: T0 = 0;
627: RETURN();
628: }
629:
630: void OPPROTO op_cmpgtz (void)
631: {
632: if ((int64_t)T0 > 0)
633: T0 = 1;
634: else
635: T0 = 0;
636: RETURN();
637: }
638:
639: void OPPROTO op_cmpgez (void)
640: {
641: if ((int64_t)T0 >= 0)
642: T0 = 1;
643: else
644: T0 = 0;
645: RETURN();
646: }
647:
648: void OPPROTO op_cmplbs (void)
649: {
650: T0 &= 1;
651: RETURN();
652: }
653:
654: void OPPROTO op_cmplbc (void)
655: {
656: T0 = (~T0) & 1;
657: RETURN();
658: }
659:
660: /* Branches */
661: void OPPROTO op_branch (void)
662: {
663: env->pc = T0 & ~3;
664: RETURN();
665: }
666:
667: void OPPROTO op_addq1 (void)
668: {
669: T1 += T0;
670: RETURN();
671: }
672:
673: #if 0 // Qemu does not know how to do this...
674: void OPPROTO op_bcond (void)
675: {
676: if (T0)
677: env->pc = T1 & ~3;
678: else
679: env->pc = PARAM(1);
680: RETURN();
681: }
682: #else
683: void OPPROTO op_bcond (void)
684: {
685: if (T0)
686: env->pc = T1 & ~3;
687: else
688: env->pc = ((uint64_t)PARAM(1) << 32) | (uint64_t)PARAM(2);
689: RETURN();
690: }
691: #endif
692:
693: #if 0 // Qemu does not know how to do this...
694: void OPPROTO op_update_pc (void)
695: {
696: env->pc = PARAM(1);
697: RETURN();
698: }
699: #else
700: void OPPROTO op_update_pc (void)
701: {
702: env->pc = ((uint64_t)PARAM(1) << 32) | (uint64_t)PARAM(2);
703: RETURN();
704: }
705: #endif
706:
707: /* Optimization for 32 bits hosts architectures */
708: void OPPROTO op_update_pc32 (void)
709: {
710: env->pc = (uint64_t)PARAM(1);
711: RETURN();
712: }
713:
714: /* IEEE floating point arithmetic */
715: /* S floating (single) */
716: void OPPROTO op_adds (void)
717: {
718: FT0 = float32_add(FT0, FT1, &FP_STATUS);
719: RETURN();
720: }
721:
722: void OPPROTO op_subs (void)
723: {
724: FT0 = float32_sub(FT0, FT1, &FP_STATUS);
725: RETURN();
726: }
727:
728: void OPPROTO op_muls (void)
729: {
730: FT0 = float32_mul(FT0, FT1, &FP_STATUS);
731: RETURN();
732: }
733:
734: void OPPROTO op_divs (void)
735: {
736: FT0 = float32_div(FT0, FT1, &FP_STATUS);
737: RETURN();
738: }
739:
740: void OPPROTO op_sqrts (void)
741: {
742: helper_sqrts();
743: RETURN();
744: }
745:
746: void OPPROTO op_cpys (void)
747: {
748: helper_cpys();
749: RETURN();
750: }
751:
752: void OPPROTO op_cpysn (void)
753: {
754: helper_cpysn();
755: RETURN();
756: }
757:
758: void OPPROTO op_cpyse (void)
759: {
760: helper_cpyse();
761: RETURN();
762: }
763:
764: void OPPROTO op_itofs (void)
765: {
766: helper_itofs();
767: RETURN();
768: }
769:
770: void OPPROTO op_ftois (void)
771: {
772: helper_ftois();
773: RETURN();
774: }
775:
776: /* T floating (double) */
777: void OPPROTO op_addt (void)
778: {
779: FT0 = float64_add(FT0, FT1, &FP_STATUS);
780: RETURN();
781: }
782:
783: void OPPROTO op_subt (void)
784: {
785: FT0 = float64_sub(FT0, FT1, &FP_STATUS);
786: RETURN();
787: }
788:
789: void OPPROTO op_mult (void)
790: {
791: FT0 = float64_mul(FT0, FT1, &FP_STATUS);
792: RETURN();
793: }
794:
795: void OPPROTO op_divt (void)
796: {
797: FT0 = float64_div(FT0, FT1, &FP_STATUS);
798: RETURN();
799: }
800:
801: void OPPROTO op_sqrtt (void)
802: {
803: helper_sqrtt();
804: RETURN();
805: }
806:
807: void OPPROTO op_cmptun (void)
808: {
809: helper_cmptun();
810: RETURN();
811: }
812:
813: void OPPROTO op_cmpteq (void)
814: {
815: helper_cmpteq();
816: RETURN();
817: }
818:
819: void OPPROTO op_cmptle (void)
820: {
821: helper_cmptle();
822: RETURN();
823: }
824:
825: void OPPROTO op_cmptlt (void)
826: {
827: helper_cmptlt();
828: RETURN();
829: }
830:
831: void OPPROTO op_itoft (void)
832: {
833: helper_itoft();
834: RETURN();
835: }
836:
837: void OPPROTO op_ftoit (void)
838: {
839: helper_ftoit();
840: RETURN();
841: }
842:
843: /* VAX floating point arithmetic */
844: /* F floating */
845: void OPPROTO op_addf (void)
846: {
847: helper_addf();
848: RETURN();
849: }
850:
851: void OPPROTO op_subf (void)
852: {
853: helper_subf();
854: RETURN();
855: }
856:
857: void OPPROTO op_mulf (void)
858: {
859: helper_mulf();
860: RETURN();
861: }
862:
863: void OPPROTO op_divf (void)
864: {
865: helper_divf();
866: RETURN();
867: }
868:
869: void OPPROTO op_sqrtf (void)
870: {
871: helper_sqrtf();
872: RETURN();
873: }
874:
875: void OPPROTO op_cmpfeq (void)
876: {
877: helper_cmpfeq();
878: RETURN();
879: }
880:
881: void OPPROTO op_cmpfne (void)
882: {
883: helper_cmpfne();
884: RETURN();
885: }
886:
887: void OPPROTO op_cmpflt (void)
888: {
889: helper_cmpflt();
890: RETURN();
891: }
892:
893: void OPPROTO op_cmpfle (void)
894: {
895: helper_cmpfle();
896: RETURN();
897: }
898:
899: void OPPROTO op_cmpfgt (void)
900: {
901: helper_cmpfgt();
902: RETURN();
903: }
904:
905: void OPPROTO op_cmpfge (void)
906: {
907: helper_cmpfge();
908: RETURN();
909: }
910:
911: void OPPROTO op_itoff (void)
912: {
913: helper_itoff();
914: RETURN();
915: }
916:
917: /* G floating */
918: void OPPROTO op_addg (void)
919: {
920: helper_addg();
921: RETURN();
922: }
923:
924: void OPPROTO op_subg (void)
925: {
926: helper_subg();
927: RETURN();
928: }
929:
930: void OPPROTO op_mulg (void)
931: {
932: helper_mulg();
933: RETURN();
934: }
935:
936: void OPPROTO op_divg (void)
937: {
938: helper_divg();
939: RETURN();
940: }
941:
942: void OPPROTO op_sqrtg (void)
943: {
944: helper_sqrtg();
945: RETURN();
946: }
947:
948: void OPPROTO op_cmpgeq (void)
949: {
950: helper_cmpgeq();
951: RETURN();
952: }
953:
954: void OPPROTO op_cmpglt (void)
955: {
956: helper_cmpglt();
957: RETURN();
958: }
959:
960: void OPPROTO op_cmpgle (void)
961: {
962: helper_cmpgle();
963: RETURN();
964: }
965:
966: /* Floating point format conversion */
967: void OPPROTO op_cvtst (void)
968: {
969: FT0 = (float)FT0;
970: RETURN();
971: }
972:
973: void OPPROTO op_cvtqs (void)
974: {
975: helper_cvtqs();
976: RETURN();
977: }
978:
979: void OPPROTO op_cvtts (void)
980: {
981: FT0 = (float)FT0;
982: RETURN();
983: }
984:
985: void OPPROTO op_cvttq (void)
986: {
987: helper_cvttq();
988: RETURN();
989: }
990:
991: void OPPROTO op_cvtqt (void)
992: {
993: helper_cvtqt();
994: RETURN();
995: }
996:
997: void OPPROTO op_cvtqf (void)
998: {
999: helper_cvtqf();
1000: RETURN();
1001: }
1002:
1003: void OPPROTO op_cvtgf (void)
1004: {
1005: helper_cvtgf();
1006: RETURN();
1007: }
1008:
1009: void OPPROTO op_cvtgd (void)
1010: {
1011: helper_cvtgd();
1012: RETURN();
1013: }
1014:
1015: void OPPROTO op_cvtgq (void)
1016: {
1017: helper_cvtgq();
1018: RETURN();
1019: }
1020:
1021: void OPPROTO op_cvtqg (void)
1022: {
1023: helper_cvtqg();
1024: RETURN();
1025: }
1026:
1027: void OPPROTO op_cvtdg (void)
1028: {
1029: helper_cvtdg();
1030: RETURN();
1031: }
1032:
1033: void OPPROTO op_cvtlq (void)
1034: {
1035: helper_cvtlq();
1036: RETURN();
1037: }
1038:
1039: void OPPROTO op_cvtql (void)
1040: {
1041: helper_cvtql();
1042: RETURN();
1043: }
1044:
1045: void OPPROTO op_cvtqlv (void)
1046: {
1047: helper_cvtqlv();
1048: RETURN();
1049: }
1050:
1051: void OPPROTO op_cvtqlsv (void)
1052: {
1053: helper_cvtqlsv();
1054: RETURN();
1055: }
1056:
1057: /* PALcode support special instructions */
1058: #if !defined (CONFIG_USER_ONLY)
1059: void OPPROTO op_hw_rei (void)
1060: {
1061: env->pc = env->ipr[IPR_EXC_ADDR] & ~3;
1062: env->ipr[IPR_EXC_ADDR] = env->ipr[IPR_EXC_ADDR] & 1;
1063: /* XXX: re-enable interrupts and memory mapping */
1064: RETURN();
1065: }
1066:
1067: void OPPROTO op_hw_ret (void)
1068: {
1069: env->pc = T0 & ~3;
1070: env->ipr[IPR_EXC_ADDR] = T0 & 1;
1071: /* XXX: re-enable interrupts and memory mapping */
1072: RETURN();
1073: }
1074:
1075: void OPPROTO op_mfpr (void)
1076: {
1077: helper_mfpr(PARAM(1));
1078: RETURN();
1079: }
1080:
1081: void OPPROTO op_mtpr (void)
1082: {
1083: helper_mtpr(PARAM(1));
1084: RETURN();
1085: }
1086:
1087: void OPPROTO op_set_alt_mode (void)
1088: {
1089: env->saved_mode = env->ps & 0xC;
1090: env->ps = (env->ps & ~0xC) | (env->ipr[IPR_ALT_MODE] & 0xC);
1091: RETURN();
1092: }
1093:
1094: void OPPROTO op_restore_mode (void)
1095: {
1096: env->ps = (env->ps & ~0xC) | env->saved_mode;
1097: RETURN();
1098: }
1099:
1100: void OPPROTO op_ld_phys_to_virt (void)
1101: {
1102: helper_ld_phys_to_virt();
1103: RETURN();
1104: }
1105:
1106: void OPPROTO op_st_phys_to_virt (void)
1107: {
1108: helper_st_phys_to_virt();
1109: RETURN();
1110: }
1111: #endif /* !defined (CONFIG_USER_ONLY) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.