![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to PCemulateREAL.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / i386 / pc_support|
Return to PCemulateREAL.c CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / i386 / pc_support |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* ! 26: * Copyright (c) 1993 NeXT Computer, Inc. ! 27: * ! 28: * PC support Real mode emulation. ! 29: * ! 30: * HISTORY ! 31: * ! 32: * 23 Mar 1993 ? at NeXT ! 33: * Created. ! 34: */ ! 35: ! 36: #import <mach/mach_types.h> ! 37: ! 38: #import <architecture/i386/sel.h> ! 39: #import <machdep/i386/trap.h> ! 40: #import <machdep/i386/err_inline.h> ! 41: ! 42: #import "PCprivate.h" ! 43: #import "PCmiscInline.h" ! 44: #import "PCtaskInline.h" ! 45: ! 46: struct inst_prefix { ! 47: unsigned int opnd :1, ! 48: addr :1; ! 49: }; ! 50: ! 51: static __inline__ ! 52: vm_offset_t ! 53: segment_base( ! 54: sel_t sel ! 55: ) ! 56: { ! 57: return ((*(unsigned short *)&sel) << 4); ! 58: } ! 59: ! 60: static __inline__ ! 61: fetch_segment_byte( ! 62: thread_t thread, ! 63: sel_t sel, ! 64: unsigned short offset, ! 65: unsigned char *data ! 66: ) ! 67: { ! 68: vm_offset_t base = segment_base(sel); ! 69: ! 70: return (fetchByte(thread, base + offset, data)); ! 71: } ! 72: ! 73: static __inline__ ! 74: fetch_segment_2byte( ! 75: thread_t thread, ! 76: sel_t sel, ! 77: unsigned short offset, ! 78: unsigned short *data ! 79: ) ! 80: { ! 81: vm_offset_t base = segment_base(sel); ! 82: ! 83: return (fetch2Byte(thread, base + offset, data)); ! 84: } ! 85: ! 86: static __inline__ ! 87: store_segment_2byte( ! 88: thread_t thread, ! 89: sel_t sel, ! 90: unsigned short offset, ! 91: unsigned short data ! 92: ) ! 93: { ! 94: vm_offset_t base = segment_base(sel); ! 95: ! 96: return (store2Byte(thread, base + offset, data)); ! 97: } ! 98: ! 99: static __inline__ ! 100: fetch_segment_4byte( ! 101: thread_t thread, ! 102: sel_t sel, ! 103: unsigned short offset, ! 104: unsigned int *data ! 105: ) ! 106: { ! 107: vm_offset_t base = segment_base(sel); ! 108: ! 109: return (fetch4Byte(thread, base + offset, data)); ! 110: } ! 111: ! 112: static __inline__ ! 113: store_segment_4byte( ! 114: thread_t thread, ! 115: sel_t sel, ! 116: unsigned short offset, ! 117: unsigned int data ! 118: ) ! 119: { ! 120: vm_offset_t base = segment_base(sel); ! 121: ! 122: return (store4Byte(thread, base + offset, data)); ! 123: } ! 124: ! 125: static __inline__ ! 126: boolean_t ! 127: fetch_segment( ! 128: thread_t thread, ! 129: sel_t sel, ! 130: unsigned short offset, ! 131: void *data, ! 132: unsigned int length ! 133: ) ! 134: { ! 135: #define sdata ((unsigned short *)data) ! 136: vm_offset_t base = segment_base(sel); ! 137: ! 138: thread->recover = (vm_offset_t)&&fault; ! 139: ! 140: while (length > 0) { ! 141: asm volatile( ! 142: "movw %%fs:%1,%0" ! 143: : "=q" (*sdata) ! 144: : "m" (*(unsigned short *)(base + offset))); ! 145: ! 146: sdata++; offset += sizeof (*sdata); length -= sizeof (*sdata); ! 147: } ! 148: ! 149: thread->recover = 0; ! 150: return (TRUE); ! 151: ! 152: fault: ! 153: thread->recover = 0; ! 154: return (FALSE); ! 155: #undef sdata ! 156: } ! 157: ! 158: static __inline__ ! 159: boolean_t ! 160: store_segment( ! 161: thread_t thread, ! 162: sel_t sel, ! 163: unsigned short offset, ! 164: void *data, ! 165: unsigned int length ! 166: ) ! 167: { ! 168: #define sdata ((unsigned short *)data) ! 169: vm_offset_t base = segment_base(sel); ! 170: ! 171: thread->recover = (vm_offset_t)&&fault; ! 172: ! 173: while (length > 0) { ! 174: asm volatile( ! 175: "movw %0,%%fs:%1" ! 176: : ! 177: : "r" (*sdata), "m" (*(unsigned short *)(base + offset))); ! 178: ! 179: sdata++; offset += sizeof (*sdata); length -= sizeof (*sdata); ! 180: } ! 181: ! 182: thread->recover = 0; ! 183: return (TRUE); ! 184: ! 185: fault: ! 186: thread->recover = 0; ! 187: return (FALSE); ! 188: #undef sdata ! 189: } ! 190: ! 191: static ! 192: boolean_t ! 193: handle_bop( ! 194: thread_t thread, ! 195: thread_saved_state_t *state ! 196: ) ! 197: { ! 198: PCcontext_t context = threadPCContext(thread); ! 199: unsigned int inst; ! 200: unsigned char bbyte; ! 201: ! 202: if (!fetch_segment_4byte( ! 203: thread, ! 204: state->frame.cs, state->frame.eip, ! 205: &inst)) ! 206: return (FALSE); ! 207: ! 208: if (*(unsigned short *)&inst != 0xC4C4) ! 209: return (FALSE); ! 210: ! 211: bbyte = *((unsigned char *)&inst + 2); ! 212: ! 213: if (bbyte == 0xFE) { ! 214: PCcancelTimers(context); ! 215: ! 216: context->callHandler = PC_HANDLE_EXIT; ! 217: ! 218: PCcallMonitor(thread, state); ! 219: /* NOTREACHED */ ! 220: } ! 221: else if (bbyte == 0xFA) { ! 222: PCbopFA_t args; ! 223: ! 224: if (!fetch_segment( ! 225: thread, ! 226: state->frame.ss, state->frame.esp, ! 227: &args, sizeof (args))) ! 228: return (FALSE); ! 229: ! 230: return (PCbopFA(thread, state, &args)); ! 231: /* NOTREACHED */ ! 232: } ! 233: else if (bbyte == 0xFC) { ! 234: PCbopFC_t args; ! 235: ! 236: if (!fetch_segment( ! 237: thread, ! 238: state->frame.ss, state->frame.esp, ! 239: &args, sizeof (args))) ! 240: return (FALSE); ! 241: ! 242: return (PCbopFC(thread, state, &args)); ! 243: /* NOTREACHED */ ! 244: } ! 245: else if (bbyte == 0xFD) { ! 246: PCbopFD_t args; ! 247: ! 248: if (!fetch_segment( ! 249: thread, ! 250: state->frame.ss, state->frame.esp, ! 251: &args, sizeof (args))) ! 252: return (FALSE); ! 253: ! 254: PCbopFD(thread, state, &args); ! 255: /* NOTREACHED */ ! 256: } ! 257: else { ! 258: context->trapNum = bbyte; ! 259: context->callHandler = PC_HANDLE_BOP; ! 260: ! 261: PCcallMonitor(thread, state); ! 262: /* NOTREACHED */ ! 263: } ! 264: } ! 265: ! 266: static __inline__ ! 267: boolean_t ! 268: fetch_inst( ! 269: thread_t thread, ! 270: thread_saved_state_t *state, ! 271: int *offset, ! 272: unsigned char *inst, ! 273: struct inst_prefix *prefix ! 274: ) ! 275: { ! 276: sel_t cs; ! 277: unsigned short ip; ! 278: unsigned char ibyte; ! 279: int n; ! 280: ! 281: cs = state->frame.cs; ! 282: ip = state->frame.eip; ! 283: ! 284: for (n = 0; n < 15; n++) { // a reasonable limit ! 285: if (!fetch_segment_byte(thread, cs, ip + n, &ibyte)) ! 286: break; ! 287: ! 288: switch (ibyte) { ! 289: ! 290: case 0x66: // Operand-size prefix ! 291: prefix->opnd = TRUE; ! 292: break; ! 293: ! 294: case 0xf0: // LOCK prefix ! 295: break; ! 296: ! 297: default: ! 298: *offset = (ip + n) - ip; ! 299: *inst = ibyte - 0x90; ! 300: ! 301: return (TRUE); ! 302: } ! 303: } ! 304: ! 305: return (FALSE); ! 306: } ! 307: ! 308: static ! 309: boolean_t ! 310: emulate_CLI( ! 311: thread_t thread, ! 312: thread_saved_state_t *state, ! 313: int offset, ! 314: struct inst_prefix prefix ! 315: ) ! 316: { ! 317: PCcontext_t context = threadPCContext(thread); ! 318: ! 319: (unsigned short)state->frame.eip += (offset + 1); ! 320: ! 321: context->IF_flag = FALSE; ! 322: ! 323: return (TRUE); ! 324: } ! 325: ! 326: static ! 327: boolean_t ! 328: emulate_STI( ! 329: thread_t thread, ! 330: thread_saved_state_t *state, ! 331: int offset, ! 332: struct inst_prefix prefix ! 333: ) ! 334: { ! 335: PCcontext_t context = threadPCContext(thread); ! 336: ! 337: (unsigned short)state->frame.eip += (offset + 1); ! 338: ! 339: if (!context->IF_flag) { ! 340: context->IF_flag = TRUE; ! 341: ! 342: context->pendingCallbacks |= (context->runOptions & PC_RUN_IF_SET); ! 343: } ! 344: ! 345: return (TRUE); ! 346: } ! 347: ! 348: static boolean_t emulate_PUSHFD( ! 349: thread_t thread, ! 350: thread_saved_state_t *state, ! 351: int offset, ! 352: struct inst_prefix prefix); ! 353: ! 354: static ! 355: boolean_t ! 356: emulate_PUSHF( ! 357: thread_t thread, ! 358: thread_saved_state_t *state, ! 359: int offset, ! 360: struct inst_prefix prefix ! 361: ) ! 362: { ! 363: PCcontext_t context; ! 364: struct { ! 365: unsigned short flags; ! 366: } frame; ! 367: ! 368: if (prefix.opnd) ! 369: return (emulate_PUSHFD(thread, state, offset, prefix)); ! 370: ! 371: context = threadPCContext(thread); ! 372: ! 373: frame.flags = state->frame.eflags; ! 374: if (context->IF_flag) ! 375: frame.flags |= EFL_IF; ! 376: else ! 377: frame.flags &= ~EFL_IF; ! 378: ! 379: frame.flags |= (context->X_flags & (EFL_NT | EFL_IOPL)); ! 380: ! 381: if (!store_segment_2byte( ! 382: thread, ! 383: state->frame.ss, state->frame.esp - sizeof (frame), ! 384: frame.flags)) ! 385: return (FALSE); ! 386: ! 387: (unsigned short)state->frame.eip += (offset + 1); ! 388: ! 389: (unsigned short)state->frame.esp -= sizeof (frame); ! 390: ! 391: return (TRUE); ! 392: } ! 393: ! 394: static ! 395: boolean_t ! 396: emulate_PUSHFD( ! 397: thread_t thread, ! 398: thread_saved_state_t *state, ! 399: int offset, ! 400: struct inst_prefix prefix ! 401: ) ! 402: { ! 403: PCcontext_t context; ! 404: struct { ! 405: unsigned int eflags; ! 406: } frame; ! 407: ! 408: context = threadPCContext(thread); ! 409: ! 410: frame.eflags = state->frame.eflags; ! 411: if (context->IF_flag) ! 412: frame.eflags |= EFL_IF; ! 413: else ! 414: frame.eflags &= ~EFL_IF; ! 415: ! 416: frame.eflags |= (context->X_flags & (EFL_NT | EFL_IOPL)); ! 417: ! 418: if (!store_segment_4byte( ! 419: thread, ! 420: state->frame.ss, state->frame.esp - sizeof (frame), ! 421: frame.eflags)) ! 422: return (FALSE); ! 423: ! 424: (unsigned short)state->frame.eip += (offset + 1); ! 425: ! 426: (unsigned short)state->frame.esp -= sizeof (frame); ! 427: ! 428: return (TRUE); ! 429: } ! 430: ! 431: static boolean_t emulate_POPFD( ! 432: thread_t thread, ! 433: thread_saved_state_t *state, ! 434: int offset, ! 435: struct inst_prefix prefix); ! 436: ! 437: static ! 438: boolean_t ! 439: emulate_POPF( ! 440: thread_t thread, ! 441: thread_saved_state_t *state, ! 442: int offset, ! 443: struct inst_prefix prefix ! 444: ) ! 445: { ! 446: PCcontext_t context; ! 447: struct { ! 448: unsigned short flags; ! 449: } frame; ! 450: ! 451: if (prefix.opnd) ! 452: return (emulate_POPFD(thread, state, offset, prefix)); ! 453: ! 454: context = threadPCContext(thread); ! 455: ! 456: if (!fetch_segment_2byte( ! 457: thread, ! 458: state->frame.ss, state->frame.esp, ! 459: &frame.flags)) ! 460: return (FALSE); ! 461: ! 462: if ((context->debugOptions & PC_DEBUG_PRESERVE_TRACE) != 0) ! 463: frame.flags |= (state->frame.eflags & EFL_TF); ! 464: (unsigned short)state->frame.eflags = frame.flags; ! 465: state->frame.eflags &= ~( EFL_NT | EFL_IOPL | EFL_CLR ); ! 466: state->frame.eflags |= ( EFL_VM | EFL_IF | EFL_SET ); ! 467: ! 468: (unsigned short)state->frame.eip += (offset + 1); ! 469: (unsigned short)state->frame.esp += sizeof (frame); ! 470: ! 471: context->X_flags = (frame.flags & (EFL_NT | EFL_IOPL)); ! 472: ! 473: if (frame.flags & EFL_IF) { ! 474: if (!context->IF_flag) ! 475: context->pendingCallbacks |= (context->runOptions & PC_RUN_IF_SET); ! 476: ! 477: context->IF_flag = TRUE; ! 478: } ! 479: else ! 480: context->IF_flag = FALSE; ! 481: ! 482: return (TRUE); ! 483: } ! 484: ! 485: static ! 486: boolean_t ! 487: emulate_POPFD( ! 488: thread_t thread, ! 489: thread_saved_state_t *state, ! 490: int offset, ! 491: struct inst_prefix prefix ! 492: ) ! 493: { ! 494: PCcontext_t context; ! 495: struct { ! 496: unsigned long eflags; ! 497: } frame; ! 498: ! 499: context = threadPCContext(thread); ! 500: ! 501: if (!fetch_segment_4byte( ! 502: thread, ! 503: state->frame.ss, state->frame.esp, ! 504: &frame.eflags)) ! 505: return (FALSE); ! 506: ! 507: if ((context->debugOptions & PC_DEBUG_PRESERVE_TRACE) != 0) ! 508: frame.eflags |= (state->frame.eflags & EFL_TF); ! 509: state->frame.eflags = frame.eflags; ! 510: state->frame.eflags &= ~( EFL_NT | EFL_IOPL | EFL_CLR ); ! 511: state->frame.eflags |= ( EFL_VM | EFL_IF | EFL_SET ); ! 512: ! 513: (unsigned short)state->frame.eip += (offset + 1); ! 514: (unsigned short)state->frame.esp += sizeof (frame); ! 515: ! 516: context->X_flags = (frame.eflags & (EFL_NT | EFL_IOPL)); ! 517: ! 518: if (frame.eflags & EFL_IF) { ! 519: if (!context->IF_flag) ! 520: context->pendingCallbacks |= (context->runOptions & PC_RUN_IF_SET); ! 521: ! 522: context->IF_flag = TRUE; ! 523: } ! 524: else ! 525: context->IF_flag = FALSE; ! 526: ! 527: return (TRUE); ! 528: } ! 529: ! 530: static boolean_t emulate_IRETD( ! 531: thread_t thread, ! 532: thread_saved_state_t *state, ! 533: int offset, ! 534: struct inst_prefix prefix); ! 535: ! 536: static ! 537: boolean_t ! 538: emulate_IRET( ! 539: thread_t thread, ! 540: thread_saved_state_t *state, ! 541: int offset, ! 542: struct inst_prefix prefix ! 543: ) ! 544: { ! 545: PCcontext_t context; ! 546: struct { ! 547: unsigned short ip; ! 548: sel_t cs; ! 549: unsigned short flags; ! 550: } frame; ! 551: ! 552: if (prefix.opnd) ! 553: return (emulate_IRETD(thread, state, offset, prefix)); ! 554: ! 555: context = threadPCContext(thread); ! 556: ! 557: if (!fetch_segment( ! 558: thread, ! 559: state->frame.ss, state->frame.esp, ! 560: &frame, sizeof (frame))) ! 561: return (FALSE); ! 562: ! 563: (unsigned short)state->frame.eip = frame.ip; ! 564: state->frame.cs = frame.cs; ! 565: ! 566: if ((context->debugOptions & PC_DEBUG_PRESERVE_TRACE) != 0) ! 567: frame.flags |= (state->frame.eflags & EFL_TF); ! 568: (unsigned short)state->frame.eflags = frame.flags; ! 569: state->frame.eflags &= ~( EFL_NT | EFL_IOPL | EFL_CLR ); ! 570: state->frame.eflags |= ( EFL_VM | EFL_IF | EFL_SET ); ! 571: ! 572: (unsigned short)state->frame.esp += sizeof (frame); ! 573: ! 574: context->X_flags = (frame.flags & (EFL_NT | EFL_IOPL)); ! 575: ! 576: if (frame.flags & EFL_IF) { ! 577: if (!context->IF_flag) ! 578: context->pendingCallbacks |= (context->runOptions & PC_RUN_IF_SET); ! 579: ! 580: context->IF_flag = TRUE; ! 581: } ! 582: else ! 583: context->IF_flag = FALSE; ! 584: ! 585: return (TRUE); ! 586: } ! 587: ! 588: static ! 589: boolean_t ! 590: emulate_IRETD( ! 591: thread_t thread, ! 592: thread_saved_state_t *state, ! 593: int offset, ! 594: struct inst_prefix prefix ! 595: ) ! 596: { ! 597: PCcontext_t context; ! 598: struct { ! 599: unsigned long eip; ! 600: sel_t cs; ! 601: unsigned long eflags; ! 602: } frame; ! 603: ! 604: context = threadPCContext(thread); ! 605: ! 606: if (!fetch_segment( ! 607: thread, ! 608: state->frame.ss, state->frame.esp, ! 609: &frame, sizeof (frame))) ! 610: return (FALSE); ! 611: ! 612: state->frame.eip = frame.eip; ! 613: state->frame.cs = frame.cs; ! 614: ! 615: if ((context->debugOptions & PC_DEBUG_PRESERVE_TRACE) != 0) ! 616: frame.eflags |= (state->frame.eflags & EFL_TF); ! 617: state->frame.eflags = frame.eflags; ! 618: state->frame.eflags &= ~( EFL_NT | EFL_IOPL | EFL_CLR ); ! 619: state->frame.eflags |= ( EFL_VM | EFL_IF | EFL_SET ); ! 620: ! 621: (unsigned short)state->frame.esp += sizeof (frame); ! 622: ! 623: context->X_flags = (frame.eflags & (EFL_NT | EFL_IOPL)); ! 624: ! 625: if (frame.eflags & EFL_IF) { ! 626: if (!context->IF_flag) ! 627: context->pendingCallbacks |= (context->runOptions & PC_RUN_IF_SET); ! 628: ! 629: context->IF_flag = TRUE; ! 630: } ! 631: else ! 632: context->IF_flag = FALSE; ! 633: ! 634: return (TRUE); ! 635: } ! 636: ! 637: static ! 638: boolean_t ! 639: emulate_exception( ! 640: thread_t thread, ! 641: thread_saved_state_t *state, ! 642: int trapno ! 643: ) ! 644: { ! 645: PCcontext_t context; ! 646: struct { ! 647: unsigned short ip; ! 648: sel_t cs; ! 649: unsigned short flags; ! 650: } frame; ! 651: struct { ! 652: unsigned short ip; ! 653: sel_t cs; ! 654: } vector; ! 655: ! 656: context = threadPCContext(thread); ! 657: ! 658: frame.ip = state->frame.eip; ! 659: frame.cs = state->frame.cs; ! 660: ! 661: frame.flags = state->frame.eflags; ! 662: if (context->IF_flag) ! 663: frame.flags |= EFL_IF; ! 664: else ! 665: frame.flags &= ~EFL_IF; ! 666: ! 667: frame.flags |= (context->X_flags & (EFL_NT | EFL_IOPL)); ! 668: ! 669: if (!store_segment( ! 670: thread, ! 671: state->frame.ss, state->frame.esp - sizeof (frame), ! 672: &frame, sizeof (frame))) ! 673: return (FALSE); ! 674: ! 675: if (!fetch4Byte(thread, (trapno << 2), (unsigned long *)&vector)) ! 676: return (FALSE); ! 677: ! 678: (unsigned short)state->frame.esp -= sizeof (frame); ! 679: ! 680: state->frame.eip = vector.ip; ! 681: state->frame.cs = vector.cs; ! 682: ! 683: context->IF_flag = FALSE; ! 684: ! 685: if ((context->debugOptions & PC_DEBUG_PRESERVE_TRACE) == 0) ! 686: state->frame.eflags &= ~EFL_TF; ! 687: ! 688: return (TRUE); ! 689: } ! 690: ! 691: static ! 692: boolean_t ! 693: emulate_INTn( ! 694: thread_t thread, ! 695: thread_saved_state_t *state, ! 696: int offset, ! 697: struct inst_prefix prefix ! 698: ) ! 699: { ! 700: PCshared_t shared; ! 701: PCcontext_t context; ! 702: unsigned char trapno; ! 703: ! 704: shared = threadPCShared(thread); ! 705: context = currentContext(shared); ! 706: ! 707: if (!fetch_segment_byte( ! 708: thread, ! 709: state->frame.cs, state->frame.eip + offset + 1, ! 710: &trapno)) ! 711: return (FALSE); ! 712: ! 713: if (maskIsSet(&shared->intNMask, trapno)) { ! 714: context->trapNum = trapno; ! 715: context->errCode = 0; ! 716: if (trapno <= 7) ! 717: context->callHandler = PC_HANDLE_FAULT; ! 718: else ! 719: context->callHandler = PC_HANDLE_INTN; ! 720: ! 721: PCcallMonitor(thread, state); ! 722: /* NOTREACHED */ ! 723: } ! 724: ! 725: (unsigned short)state->frame.eip += (offset + 2); ! 726: ! 727: if (!emulate_exception(thread, state, trapno)) { ! 728: (unsigned short)state->frame.eip -= (offset + 2); ! 729: return (FALSE); ! 730: } ! 731: ! 732: return (TRUE); ! 733: } ! 734: ! 735: static ! 736: boolean_t ! 737: handle_exception( ! 738: thread_t thread, ! 739: thread_saved_state_t *state ! 740: ) ! 741: { ! 742: PCshared_t shared; ! 743: PCcontext_t context; ! 744: ! 745: shared = threadPCShared(thread); ! 746: context = currentContext(shared); ! 747: ! 748: if (maskIsSet(&shared->faultMask, state->trapno)) { ! 749: context->trapNum = state->trapno; ! 750: context->errCode = err_to_error_code(state->frame.err); ! 751: context->callHandler = PC_HANDLE_FAULT; ! 752: ! 753: PCcallMonitor(thread, state); ! 754: /* NOTREACHED */ ! 755: } ! 756: ! 757: if (!emulate_exception(thread, state, state->trapno)) ! 758: return (FALSE); ! 759: ! 760: return (TRUE); ! 761: } ! 762: ! 763: #define none 0 ! 764: #define STI emulate_STI ! 765: #define CLI emulate_CLI ! 766: #define PUSHF emulate_PUSHF ! 767: #define POPF emulate_POPF ! 768: #define IRET emulate_IRET ! 769: #define INTn emulate_INTn ! 770: ! 771: static ! 772: boolean_t (*inst_table[256])() = ! 773: { ! 774: /* 90 */ none, /* 91 */ none, /* 92 */ none, /* 93 */ none, ! 775: /* 94 */ none, /* 95 */ none, /* 96 */ none, /* 97 */ none, ! 776: /* 98 */ none, /* 99 */ none, /* 9A */ none, /* 9B */ none, ! 777: /* 9C */PUSHF, /* 9D */ POPF, /* 9E */ none, /* 9F */ none, ! 778: /* A0 */ none, /* A1 */ none, /* A2 */ none, /* A3 */ none, ! 779: /* A4 */ none, /* A5 */ none, /* A6 */ none, /* A7 */ none, ! 780: /* A8 */ none, /* A9 */ none, /* AA */ none, /* AB */ none, ! 781: /* AC */ none, /* AD */ none, /* AE */ none, /* AF */ none, ! 782: /* B0 */ none, /* B1 */ none, /* B2 */ none, /* B3 */ none, ! 783: /* B4 */ none, /* B5 */ none, /* B6 */ none, /* B7 */ none, ! 784: /* B8 */ none, /* B9 */ none, /* BA */ none, /* BB */ none, ! 785: /* BC */ none, /* BD */ none, /* BE */ none, /* BF */ none, ! 786: /* C0 */ none, /* C1 */ none, /* C2 */ none, /* C3 */ none, ! 787: /* C4 */ none, /* C5 */ none, /* C6 */ none, /* C7 */ none, ! 788: /* C8 */ none, /* C9 */ none, /* CA */ none, /* CB */ none, ! 789: /* CC */ none, /* CD */ INTn, /* CE */ none, /* CF */ IRET, ! 790: /* D0 */ none, /* D1 */ none, /* D2 */ none, /* D3 */ none, ! 791: /* D4 */ none, /* D5 */ none, /* D6 */ none, /* D7 */ none, ! 792: /* D8 */ none, /* D9 */ none, /* DA */ none, /* DB */ none, ! 793: /* DC */ none, /* DD */ none, /* DE */ none, /* DF */ none, ! 794: /* E0 */ none, /* E1 */ none, /* E2 */ none, /* E3 */ none, ! 795: /* E4 */ none, /* E5 */ none, /* E6 */ none, /* E7 */ none, ! 796: /* E8 */ none, /* E9 */ none, /* EA */ none, /* EB */ none, ! 797: /* EC */ none, /* ED */ none, /* EE */ none, /* EF */ none, ! 798: /* F0 */ none, /* F1 */ none, /* F2 */ none, /* F3 */ none, ! 799: /* F4 */ none, /* F5 */ none, /* F6 */ none, /* F7 */ none, ! 800: /* F8 */ none, /* F9 */ none, /* FA */ CLI, /* FB */ STI, ! 801: /* FC */ none, /* FD */ none, /* FE */ none, /* FF */ none, ! 802: }; ! 803: ! 804: static ! 805: boolean_t ! 806: emulate_instruction( ! 807: thread_t thread, ! 808: thread_saved_state_t *state ! 809: ) ! 810: { ! 811: int offset; ! 812: unsigned char inst; ! 813: struct inst_prefix prefix = { 0 }; ! 814: boolean_t (*emul)(); ! 815: ! 816: return ( ! 817: fetch_inst(thread, state, &offset, &inst, &prefix) && ! 818: (emul = inst_table[inst]) != 0 && ! 819: (*emul)(thread, state, offset, prefix)); ! 820: } ! 821: ! 822: boolean_t ! 823: PCemulateREAL( ! 824: thread_t thread, ! 825: thread_saved_state_t *state ! 826: ) ! 827: { ! 828: if (state->trapno == T_GENERAL_PROTECTION) { ! 829: if (!emulate_instruction(thread,state)) ! 830: return handle_exception(thread, state); ! 831: else ! 832: return TRUE; ! 833: } ! 834: else ! 835: if (state->trapno == T_INVALID_OPCODE) { ! 836: if (!handle_bop(thread, state)) ! 837: return handle_exception(thread, state); ! 838: else ! 839: return TRUE; ! 840: } ! 841: else ! 842: return handle_exception(thread, state); ! 843: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.