![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fpu_entry.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / emulator|
Return to fpu_entry.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / emulator |
1.1 ! root 1: /*---------------------------------------------------------------------------+ ! 2: | fpu_entry.c | ! 3: | | ! 4: | The entry function for wm-FPU-emu | ! 5: | | ! 6: | Copyright (C) 1992 W. Metzenthen, 22 Parker St, Ormond, Vic 3163, | ! 7: | Australia. E-mail [email protected] | ! 8: | | ! 9: | See the files "README" and "COPYING" for further copyright and warranty | ! 10: | information. | ! 11: | | ! 12: +---------------------------------------------------------------------------*/ ! 13: ! 14: /*---------------------------------------------------------------------------+ ! 15: | Note: | ! 16: | The file contains code which accesses user memory. | ! 17: | Emulator static data may change when user memory is accessed, due to | ! 18: | other processes using the emulator while swapping is in progress. | ! 19: +---------------------------------------------------------------------------*/ ! 20: ! 21: /*---------------------------------------------------------------------------+ ! 22: | math_emulate() is the sole entry point for wm-FPU-emu | ! 23: +---------------------------------------------------------------------------*/ ! 24: ! 25: #ifdef KERNEL_MATH_EMULATION ! 26: ! 27: #include <linux/signal.h> ! 28: ! 29: #include "fpu_system.h" ! 30: #include "fpu_emu.h" ! 31: #include "exception.h" ! 32: ! 33: #include <asm/segment.h> ! 34: ! 35: #ifdef COHERENT ! 36: struct _fpstackframe *emCurrent; ! 37: struct _fpemstate *FPU_info; ! 38: #endif ! 39: ! 40: #define __BAD__ Un_impl /* Not implemented */ ! 41: ! 42: static FUNC st_instr_table[64] = { ! 43: fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, __BAD__, ! 44: fmul__, fxch_i, __BAD__, __BAD__, fmul_i, __BAD__, fmulp_, __BAD__, ! 45: fcom_st, fp_nop, __BAD__, __BAD__, __BAD__, fst_i_, __BAD__, __BAD__, ! 46: fcompst, __BAD__, __BAD__, __BAD__, __BAD__, fstp_i, fcompp, __BAD__, ! 47: fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_, ! 48: fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__, ! 49: fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__, ! 50: fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__, ! 51: }; ! 52: ! 53: #define _NONE_ 0 /* Take no special action */ ! 54: #define _REG0_ 1 /* Need to check for not empty st(0) */ ! 55: #define _REGI_ 2 /* Need to check for not empty st(0) and st(rm) */ ! 56: #define _REGi_ 0 /* Uses st(rm) */ ! 57: #define _PUSH_ 3 /* Need to check for space to push onto stack */ ! 58: #define _null_ 4 /* Function illegal or not implemented */ ! 59: ! 60: static unsigned char type_table[64] = { ! 61: _REGI_, _NONE_, _null_, _null_, _REGI_, _REGi_, _REGI_, _null_, ! 62: _REGI_, _REGI_, _null_, _null_, _REGI_, _null_, _REGI_, _null_, ! 63: _REGI_, _NONE_, _null_, _null_, _null_, _REG0_, _null_, _null_, ! 64: _REGI_, _null_, _null_, _null_, _null_, _REG0_, _REGI_, _null_, ! 65: _REGI_, _NONE_, _null_, _NONE_, _REGI_, _REGI_, _REGI_, _NONE_, ! 66: _REGI_, _NONE_, _REGI_, _null_, _REGI_, _REGI_, _REGI_, _null_, ! 67: _REGI_, _NONE_, _null_, _null_, _REGI_, _null_, _REGI_, _null_, ! 68: _REGI_, _NONE_, _null_, _null_, _REGI_, _null_, _REGI_, _null_ ! 69: }; ! 70: ! 71: ! 72: /* Be careful when using any of these global variables... ! 73: they might change if swapping is triggered */ ! 74: unsigned char FPU_rm; ! 75: char FPU_st0_tag; ! 76: FPU_REG *FPU_st0_ptr; ! 77: ! 78: #ifdef PARANOID ! 79: char emulating=0; ! 80: #endif PARANOID ! 81: ! 82: #define bswapw(x) __asm__("xchgb %%al,%%ah":"=a" (x):"0" ((short)x)) ! 83: ! 84: #if COHERENT ! 85: /* Special kernel routines to pack and unpack emulator to normal */ ! 86: void kfsave(struct _fpemstate *fpem, struct _fpstate *fp) ! 87: { ! 88: FPU_info = fpem; ! 89: FPU_data_address = (void *)fp; ! 90: fsave(); ! 91: } ! 92: ! 93: void kfrstor(struct _fpstate *fp, struct _fpemstate *fpem) ! 94: { ! 95: FPU_info = fpem; ! 96: FPU_data_address = (void *)fp; ! 97: frstor(); ! 98: } ! 99: ! 100: void math_emulate(long *saveRegs, struct _fpemstate *fpem, int looker) ! 101: { ! 102: unsigned char FPU_modrm; ! 103: unsigned short code; ! 104: ! 105: emCurrent = (struct _fpstackframe *)(saveRegs - 1); ! 106: FPU_info = fpem; ! 107: ! 108: FPU_lookahead = looker; ! 109: #else ! 110: void math_emulate(long arg) ! 111: { ! 112: unsigned char FPU_modrm; ! 113: unsigned short code; ! 114: ! 115: #ifdef PARANOID ! 116: if ( emulating ) ! 117: { ! 118: printf("ERROR: wm-FPU-emu is not RE-ENTRANT!\r\n"); ! 119: } ! 120: RE_ENTRANT_CHECK_ON ! 121: #endif PARANOID ! 122: ! 123: if (!emCurrent->used_math) ! 124: { ! 125: finit(); ! 126: emCurrent->used_math = 1; ! 127: control_word = 0x037f; ! 128: status_word = 0x0000; ! 129: } ! 130: ! 131: FPU_info = (struct info *) &arg; ! 132: ! 133: /* We cannot handle emulation in v86-mode */ ! 134: if (FPU_EFLAGS & 0x00020000) ! 135: math_abort(FPU_info,SIGILL); ! 136: ! 137: /* 0x000f means user code space */ ! 138: if (FPU_CS != 0x000f) ! 139: { ! 140: printf("math_emulate: %04x:%08x\n\r",FPU_CS,FPU_EIP); ! 141: emPanic("Math emulation needed in kernel"); ! 142: } ! 143: ! 144: FPU_lookahead = 1; ! 145: if (emCurrent->flags & PF_PTRACED) ! 146: FPU_lookahead = 0; ! 147: #endif ! 148: do_another: ! 149: ! 150: FPU_entry_eip = FPU_ORIG_EIP = FPU_EIP; ! 151: ! 152: RE_ENTRANT_CHECK_OFF ! 153: code = get_fs_word((unsigned short *) FPU_EIP); ! 154: RE_ENTRANT_CHECK_ON ! 155: ! 156: if ( (code & 0xff) == 0x66 ) ! 157: { ! 158: FPU_EIP++; ! 159: RE_ENTRANT_CHECK_OFF ! 160: code = get_fs_word((unsigned short *) FPU_EIP); ! 161: RE_ENTRANT_CHECK_ON ! 162: } ! 163: FPU_EIP += 2; ! 164: ! 165: FPU_modrm = code >> 8; ! 166: FPU_rm = FPU_modrm & 7; ! 167: ! 168: if ( FPU_modrm < 0300 ) ! 169: { ! 170: /* All of these instructions use the mod/rm byte to get a data address */ ! 171: get_address(FPU_modrm); ! 172: ! 173: if ( !(code & 1) ) ! 174: { ! 175: switch ( (code >> 1) & 3 ) ! 176: { ! 177: case 0: ! 178: reg_load_single(); ! 179: break; ! 180: case 1: ! 181: reg_load_int32(); ! 182: break; ! 183: case 2: ! 184: reg_load_double(); ! 185: break; ! 186: case 3: ! 187: reg_load_int16(); ! 188: break; ! 189: } ! 190: ! 191: /* No more access to user memory, it is safe ! 192: to use static data now */ ! 193: FPU_st0_ptr = &st(0); ! 194: FPU_st0_tag = FPU_st0_ptr->tag; ! 195: if ( NOT_EMPTY_0 ) ! 196: { ! 197: switch ( (FPU_modrm >> 3) & 7 ) ! 198: { ! 199: case 0: /* fadd */ ! 200: reg_add(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr); ! 201: break; ! 202: case 1: /* fmul */ ! 203: reg_mul(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr); ! 204: break; ! 205: case 2: /* fcom */ ! 206: compare_st_data(); ! 207: break; ! 208: case 3: /* fcomp */ ! 209: compare_st_data(); ! 210: pop(); ! 211: break; ! 212: case 4: /* fsub */ ! 213: reg_sub(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr); ! 214: break; ! 215: case 5: /* fsubr */ ! 216: reg_sub(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr); ! 217: break; ! 218: case 6: /* fdiv */ ! 219: reg_div(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr); ! 220: break; ! 221: case 7: /* fdivr */ ! 222: reg_div(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr); ! 223: break; ! 224: } ! 225: } ! 226: else ! 227: stack_underflow(); ! 228: } ! 229: else ! 230: { ! 231: load_store_instr(((FPU_modrm & 0x38) | (code & 6)) >> 1); ! 232: } ! 233: ! 234: #ifdef COHERENT ! 235: if (data_operand_offset != (unsigned long)FPU_data_address) { ! 236: data_operand_offset = (unsigned long)FPU_data_address; ! 237: operand_selector = FPU_DS; ! 238: } ! 239: #else ! 240: data_operand_offset = (unsigned long)FPU_data_address; ! 241: #endif ! 242: } ! 243: else ! 244: { ! 245: /* None of these instructions access user memory */ ! 246: unsigned char instr_index = (FPU_modrm & 0x38) | (code & 7); ! 247: FPU_st0_ptr = &st(0); ! 248: FPU_st0_tag = FPU_st0_ptr->tag; ! 249: switch ( type_table[(int) instr_index] ) ! 250: { ! 251: case _NONE_: ! 252: break; ! 253: case _REG0_: ! 254: if ( !NOT_EMPTY_0 ) ! 255: { ! 256: stack_underflow(); ! 257: goto instruction_done; ! 258: } ! 259: break; ! 260: case _REGI_: ! 261: if ( !NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm) ) ! 262: { ! 263: stack_underflow(); ! 264: goto instruction_done; ! 265: } ! 266: break; ! 267: case _PUSH_: /* Only used by the fld st(i) instruction */ ! 268: break; ! 269: case _null_: ! 270: Un_impl(); ! 271: goto instruction_done; ! 272: default: ! 273: EXCEPTION(EX_INTERNAL|0x111); ! 274: goto instruction_done; ! 275: } ! 276: (*st_instr_table[(int) instr_index])(); ! 277: } ! 278: ! 279: instruction_done: ! 280: ! 281: #ifdef COHERENT ! 282: if (ip_offset != FPU_entry_eip) { ! 283: ip_offset = FPU_entry_eip; ! 284: bswapw(code); ! 285: cs_selector = ((code & 0x7ff) << 16) | FPU_CS; ! 286: } ! 287: #else ! 288: ip_offset = FPU_entry_eip; ! 289: bswapw(code); ! 290: *(1 + (unsigned short *)&cs_selector) = code & 0x7ff; ! 291: #endif ! 292: ! 293: #ifdef COHERENT ! 294: if (FPU_lookahead) ! 295: #else ! 296: if (FPU_lookahead && !need_resched) ! 297: #endif ! 298: { ! 299: unsigned char next; ! 300: skip_fwait: ! 301: RE_ENTRANT_CHECK_OFF ! 302: next = get_fs_byte((unsigned char *) FPU_EIP); ! 303: RE_ENTRANT_CHECK_ON ! 304: test_for_fp: ! 305: if ( (next & 0xf8) == 0xd8 ) ! 306: { ! 307: goto do_another; ! 308: } ! 309: if ( next == 0x9b ) /* fwait */ ! 310: { FPU_EIP++; goto skip_fwait; } ! 311: if ( next == 0x66 ) /* size prefix */ ! 312: { ! 313: RE_ENTRANT_CHECK_OFF ! 314: next = get_fs_byte((unsigned char *) (FPU_EIP+1)); ! 315: RE_ENTRANT_CHECK_ON ! 316: if ( (next & 0xf8) == 0xd8 ) ! 317: goto test_for_fp; ! 318: } ! 319: } ! 320: ! 321: RE_ENTRANT_CHECK_OFF ! 322: } ! 323: ! 324: #ifndef COHERENT ! 325: void __math_abort(struct info * info, unsigned int signal) ! 326: { ! 327: FPU_EIP = FPU_ORIG_EIP; ! 328: emSendsig(signal,emCurrent,1); ! 329: __asm__("movl %0,%%esp ; ret"::"g" (((long) info)-4)); ! 330: } ! 331: #endif ! 332: #else /* no math emulation */ ! 333: ! 334: #include <linux/signal.h> ! 335: #include <linux/sched.h> ! 336: ! 337: void math_emulate(long arg) ! 338: { ! 339: emSendsig(SIGFPE,emCurrent,1); ! 340: schedule(); ! 341: } ! 342: ! 343: #endif /* KERNEL_MATH_EMULATION */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.