Mark the following stuff as depricated:
[dragonfly.git] / sys / platform / pc32 / gnu / fpemul / fpu_entry.c
1 /*
2  *  fpu_entry.c
3  *
4  * The entry function for wm-FPU-emu
5  *
6  *
7  * Copyright (C) 1992,1993,1994
8  *                       W. Metzenthen, 22 Parker St, Ormond, Vic 3163,
9  *                       Australia.  E-mail   billm@vaxc.cc.monash.edu.au
10  * All rights reserved.
11  *
12  * This copyright notice covers the redistribution and use of the
13  * FPU emulator developed by W. Metzenthen. It covers only its use
14  * in the 386BSD, FreeBSD and NetBSD operating systems. Any other
15  * use is not permitted under this copyright.
16  *
17  * Redistribution and use in source and binary forms, with or without
18  * modification, are permitted provided that the following conditions
19  * are met:
20  * 1. Redistributions of source code must retain the above copyright
21  *    notice, this list of conditions and the following disclaimer.
22  * 2. Redistributions in binary form must include information specifying
23  *    that source code for the emulator is freely available and include
24  *    either:
25  *      a) an offer to provide the source code for a nominal distribution
26  *         fee, or
27  *      b) list at least two alternative methods whereby the source
28  *         can be obtained, e.g. a publically accessible bulletin board
29  *         and an anonymous ftp site from which the software can be
30  *         downloaded.
31  * 3. All advertising materials specifically mentioning features or use of
32  *    this emulator must acknowledge that it was developed by W. Metzenthen.
33  * 4. The name of W. Metzenthen may not be used to endorse or promote
34  *    products derived from this software without specific prior written
35  *    permission.
36  *
37  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
38  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
39  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
40  * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
41  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
42  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
43  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
44  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
45  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
46  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
47  *
48  *
49  * The purpose of this copyright, based upon the Berkeley copyright, is to
50  * ensure that the covered software remains freely available to everyone.
51  *
52  * The software (with necessary differences) is also available, but under
53  * the terms of the GNU copyleft, for the Linux operating system and for
54  * the djgpp ms-dos extender.
55  *
56  * W. Metzenthen   June 1994.
57  *
58  * $FreeBSD: src/sys/gnu/i386/fpemul/fpu_entry.c,v 1.23 1999/10/12 02:23:14 msmith Exp $
59  * $DragonFly: src/sys/platform/pc32/gnu/fpemul/Attic/fpu_entry.c,v 1.5 2004/12/08 20:36:39 joerg Exp $
60  *
61  */
62
63 /*---------------------------------------------------------------------------+
64  | Note:                                                                     |
65  |    The file contains code which accesses user memory.                     |
66  |    Emulator static data may change when user memory is accessed, due to   |
67  |    other processes using the emulator while swapping is in progress.      |
68  +---------------------------------------------------------------------------*/
69
70 /*---------------------------------------------------------------------------+
71  | math_emulate() is the sole entry point for wm-FPU-emu                     |
72  +---------------------------------------------------------------------------*/
73
74 #include "opt_depricated.h"
75 #ifndef I_WANT_DEPRICATED_STUFF
76 #error "Add options I_WANT_DEPRICATED_STUFF to your kernel config and send a mail to kernel@"
77 #endif
78
79 #include <sys/param.h>
80 #include <sys/systm.h>
81 #include <sys/proc.h>
82 #include <sys/kernel.h>
83
84 #include <machine/cpu.h>
85 #include <machine/pcb.h>
86
87 #include "fpu_emu.h"
88 #include "fpu_system.h"
89 #include "exception.h"
90 #include "status_w.h"
91
92
93 #define __BAD__ Un_impl         /* Not implemented */
94
95 #define FPU_LOOKAHEAD   1       /* For performance boost */
96
97 #if FPU_LOOKAHEAD != 0          /* I think thet we have to limit the */
98 #define LOOKAHEAD_LIMIT 7       /* Max number of lookahead instructions*/
99 #endif                          /* Or else a prog consisting of a million */
100                                 /* fnops will spend all its time in kernel*/
101
102 #ifndef NO_UNDOC_CODE           /* Un-documented FPU op-codes supported by
103                                  * default. */
104
105 /* WARNING: These codes are not documented by Intel in their 80486 manual
106    and may not work on FPU clones or later Intel FPUs. */
107
108 /* Changes to support the un-doc codes provided by Linus Torvalds. */
109
110 #define _d9_d8_ fstp_i          /* unofficial code (19) */
111 #define _dc_d0_ fcom_st         /* unofficial code (14) */
112 #define _dc_d8_ fcompst         /* unofficial code (1c) */
113 #define _dd_c8_ fxch_i          /* unofficial code (0d) */
114 #define _de_d0_ fcompst         /* unofficial code (16) */
115 #define _df_c0_ ffreep          /* unofficial code (07) ffree + pop */
116 #define _df_c8_ fxch_i          /* unofficial code (0f) */
117 #define _df_d0_ fstp_i          /* unofficial code (17) */
118 #define _df_d8_ fstp_i          /* unofficial code (1f) */
119
120 static FUNC st_instr_table[64] = {
121         fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, _df_c0_,
122         fmul__, fxch_i, __BAD__, __BAD__, fmul_i, _dd_c8_, fmulp_, _df_c8_,
123         fcom_st, fp_nop, __BAD__, __BAD__, _dc_d0_, fst_i_, _de_d0_, _df_d0_,
124         fcompst, _d9_d8_, __BAD__, __BAD__, _dc_d8_, fstp_i, fcompp, _df_d8_,
125         fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
126         fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
127         fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
128         fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
129 };
130 #else                           /* Support only documented FPU op-codes */
131
132 static FUNC st_instr_table[64] = {
133         fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, __BAD__,
134         fmul__, fxch_i, __BAD__, __BAD__, fmul_i, __BAD__, fmulp_, __BAD__,
135         fcom_st, fp_nop, __BAD__, __BAD__, __BAD__, fst_i_, __BAD__, __BAD__,
136         fcompst, __BAD__, __BAD__, __BAD__, __BAD__, fstp_i, fcompp, __BAD__,
137         fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
138         fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
139         fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
140         fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
141 };
142 #endif                          /* NO_UNDOC_CODE */
143
144
145 #define _NONE_ 0                /* Take no special action */
146 #define _REG0_ 1                /* Need to check for not empty st(0) */
147 #define _REGI_ 2                /* Need to check for not empty st(0) and
148                                  * st(rm) */
149 #define _REGi_ 0                /* Uses st(rm) */
150 #define _PUSH_ 3                /* Need to check for space to push onto stack */
151 #define _null_ 4                /* Function illegal or not implemented */
152 #define _REGIi 5                /* Uses st(0) and st(rm), result to st(rm) */
153 #define _REGIp 6                /* Uses st(0) and st(rm), result to st(rm)
154                                  * then pop */
155 #define _REGIc 0                /* Compare st(0) and st(rm) */
156 #define _REGIn 0                /* Uses st(0) and st(rm), but handle checks
157                                  * later */
158
159 #ifndef NO_UNDOC_CODE
160
161 /* Un-documented FPU op-codes supported by default. (see above) */
162
163 static unsigned char type_table[64] = {
164         _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _REGi_,
165         _REGI_, _REGIn, _null_, _null_, _REGIi, _REGI_, _REGIp, _REGI_,
166         _REGIc, _NONE_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
167         _REGIc, _REG0_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
168         _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
169         _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
170         _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
171         _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
172 };
173 #else                           /* Support only documented FPU op-codes */
174
175 static unsigned char type_table[64] = {
176         _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _null_,
177         _REGI_, _REGIn, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
178         _REGIc, _NONE_, _null_, _null_, _null_, _REG0_, _null_, _null_,
179         _REGIc, _null_, _null_, _null_, _null_, _REG0_, _REGIc, _null_,
180         _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
181         _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
182         _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
183         _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
184 };
185 #endif                          /* NO_UNDOC_CODE */
186
187 /* Be careful when using any of these global variables...
188    they might change if swapping is triggered */
189 unsigned char FPU_rm;
190 char    FPU_st0_tag;
191 FPU_REG *FPU_st0_ptr;
192
193 #ifdef PARANOID
194 char    emulating = 0;
195 #endif                          /* PARANOID */
196
197 #define bswapw(x) __asm__("xchgb %%al,%%ah":"=a" (x):"0" ((short)x))
198 #define math_abort(signo) \
199     FPU_EIP = FPU_ORIG_EIP;REENTRANT_CHECK(OFF);return(signo);
200
201 static int
202 math_emulate(struct trapframe * tframe)
203 {
204
205         unsigned char FPU_modrm;
206         unsigned short code;
207 #ifdef LOOKAHEAD_LIMIT
208         int lookahead_limit = LOOKAHEAD_LIMIT;
209 #endif
210 #ifdef PARANOID
211         if (emulating) {
212                 printf("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
213         }
214         REENTRANT_CHECK(ON);
215 #endif                          /* PARANOID */
216
217         KKASSERT(curproc);
218         if ((((struct pcb *) curproc->p_addr)->pcb_flags & FP_SOFTFP) == 0) {
219                 finit();
220                 control_word = __INITIAL_NPXCW__;
221                 ((struct pcb *) curproc->p_addr)->pcb_flags |= FP_SOFTFP;
222         }
223         FPU_info = tframe;
224         FPU_ORIG_EIP = FPU_EIP; /* --pink-- */
225
226         if (FPU_CS != 0x001f) {
227                 printf("math_emulate: %x : %x\n", FPU_CS, FPU_EIP);
228                 panic("FPU emulation in kernel");
229         }
230 #ifdef notyet
231         /* We cannot handle emulation in v86-mode */
232         if (FPU_EFLAGS & 0x00020000) {
233                 FPU_ORIG_EIP = FPU_EIP;
234                 math_abort(FPU_info, SIGILL);
235         }
236 #endif
237
238         FPU_lookahead = FPU_LOOKAHEAD;
239         if (curproc->p_flag & P_TRACED)
240                 FPU_lookahead = 0;
241
242 do_another_FPU_instruction:
243
244         REENTRANT_CHECK(OFF);
245         code = fuword((u_int *) FPU_EIP);
246         REENTRANT_CHECK(ON);
247         if ((code & 0xff) == 0x9b) {    /* fwait */
248                 if (status_word & SW_Summary)
249                         goto do_the_FPU_interrupt;
250                 else {
251                         FPU_EIP++;
252                         goto FPU_instruction_done;
253                 }
254         }
255         if (status_word & SW_Summary) {
256                 /* Ignore the error for now if the current instruction is a
257                  * no-wait control instruction */
258                 /* The 80486 manual contradicts itself on this topic, so I use
259                  * the following list of such instructions until I can check
260                  * on a real 80486: fninit, fnstenv, fnsave, fnstsw, fnstenv,
261                  * fnclex. */
262                 if (!((((code & 0xf803) == 0xe003) ||   /* fnclex, fninit,
263                                                          * fnstsw */
264                             (((code & 0x3003) == 0x3001) &&     /* fnsave, fnstcw,
265                                                                  * fnstenv, fnstsw */
266                                 ((code & 0xc000) != 0xc000))))) {
267                         /* This is a guess about what a real FPU might do to
268                          * this bit: */
269 /*        status_word &= ~SW_Summary; ****/
270
271                         /* We need to simulate the action of the kernel to FPU
272                          * interrupts here. Currently, the "real FPU" part of
273                          * the kernel (0.99.10) clears the exception flags,
274                          * sets the registers to empty, and passes information
275                          * back to the interrupted process via the cs selector
276                          * and operand selector, so we do the same. */
277         do_the_FPU_interrupt:
278                         cs_selector &= 0xffff0000;
279                         cs_selector |= (status_word & ~SW_Top) | ((top & 7) << SW_Top_Shift);
280                         operand_selector = tag_word();
281                         status_word = 0;
282                         top = 0;
283                         {
284                                 int     r;
285                                 for (r = 0; r < 8; r++) {
286                                         regs[r].tag = TW_Empty;
287                                 }
288                         }
289                         REENTRANT_CHECK(OFF);
290                         math_abort(SIGFPE);
291                 }
292         }
293         FPU_entry_eip = FPU_ORIG_EIP = FPU_EIP;
294
295         if ((code & 0xff) == 0x66) {    /* size prefix */
296                 FPU_EIP++;
297                 REENTRANT_CHECK(OFF);
298                 code = fuword((u_int *) FPU_EIP);
299                 REENTRANT_CHECK(ON);
300         }
301         FPU_EIP += 2;
302
303         FPU_modrm = code >> 8;
304         FPU_rm = FPU_modrm & 7;
305
306         if (FPU_modrm < 0300) {
307                 /* All of these instructions use the mod/rm byte to get a data
308                  * address */
309                 get_address(FPU_modrm);
310                 if (!(code & 1)) {
311                         unsigned short status1 = status_word;
312                         FPU_st0_ptr = &st(0);
313                         FPU_st0_tag = FPU_st0_ptr->tag;
314
315                         /* Stack underflow has priority */
316                         if (NOT_EMPTY_0) {
317                                 switch ((code >> 1) & 3) {
318                                 case 0:
319                                         reg_load_single();
320                                         break;
321                                 case 1:
322                                         reg_load_int32();
323                                         break;
324                                 case 2:
325                                         reg_load_double();
326                                         break;
327                                 case 3:
328                                         reg_load_int16();
329                                         break;
330                                 }
331
332                                 /* No more access to user memory, it is safe
333                                  * to use static data now */
334                                 FPU_st0_ptr = &st(0);
335                                 FPU_st0_tag = FPU_st0_ptr->tag;
336
337                                 /* NaN operands have the next priority. */
338                                 /* We have to delay looking at st(0) until
339                                  * after loading the data, because that data
340                                  * might contain an SNaN */
341                                 if ((FPU_st0_tag == TW_NaN) ||
342                                     (FPU_loaded_data.tag == TW_NaN)) {
343                                         /* Restore the status word; we might
344                                          * have loaded a denormal. */
345                                         status_word = status1;
346                                         if ((FPU_modrm & 0x30) == 0x10) {
347                                                 /* fcom or fcomp */
348                                                 EXCEPTION(EX_Invalid);
349                                                 setcc(SW_C3 | SW_C2 | SW_C0);
350                                                 if (FPU_modrm & 0x08)
351                                                         pop();  /* fcomp, so we pop. */
352                                         } else
353                                                 real_2op_NaN(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr);
354                                         goto reg_mem_instr_done;
355                                 }
356                                 switch ((FPU_modrm >> 3) & 7) {
357                                 case 0: /* fadd */
358                                         reg_add(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
359                                         break;
360                                 case 1: /* fmul */
361                                         reg_mul(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
362                                         break;
363                                 case 2: /* fcom */
364                                         compare_st_data();
365                                         break;
366                                 case 3: /* fcomp */
367                                         compare_st_data();
368                                         pop();
369                                         break;
370                                 case 4: /* fsub */
371                                         reg_sub(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
372                                         break;
373                                 case 5: /* fsubr */
374                                         reg_sub(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr, control_word);
375                                         break;
376                                 case 6: /* fdiv */
377                                         reg_div(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
378                                         break;
379                                 case 7: /* fdivr */
380                                         if (FPU_st0_tag == TW_Zero)
381                                                 status_word = status1;  /* Undo any denorm tag,
382                                                                          * zero-divide has
383                                                                          * priority. */
384                                         reg_div(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr, control_word);
385                                         break;
386                                 }
387                         } else {
388                                 if ((FPU_modrm & 0x30) == 0x10) {
389                                         /* The instruction is fcom or fcomp */
390                                         EXCEPTION(EX_StackUnder);
391                                         setcc(SW_C3 | SW_C2 | SW_C0);
392                                         if (FPU_modrm & 0x08)
393                                                 pop();  /* fcomp, Empty or not,
394                                                          * we pop. */
395                                 } else
396                                         stack_underflow();
397                         }
398                 } else {
399                         load_store_instr(((FPU_modrm & 0x38) | (code & 6)) >> 1);
400                 }
401
402 reg_mem_instr_done:
403
404                 data_operand_offset = (intptr_t) (void *) FPU_data_address;
405         } else {
406                 /* None of these instructions access user memory */
407                 unsigned char instr_index = (FPU_modrm & 0x38) | (code & 7);
408
409                 FPU_st0_ptr = &st(0);
410                 FPU_st0_tag = FPU_st0_ptr->tag;
411                 switch (type_table[(int) instr_index]) {
412                 case _NONE_:    /* also _REGIc: _REGIn */
413                         break;
414                 case _REG0_:
415                         if (!NOT_EMPTY_0) {
416                                 stack_underflow();
417                                 goto FPU_instruction_done;
418                         }
419                         break;
420                 case _REGIi:
421                         if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
422                                 stack_underflow_i(FPU_rm);
423                                 goto FPU_instruction_done;
424                         }
425                         break;
426                 case _REGIp:
427                         if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
428                                 stack_underflow_i(FPU_rm);
429                                 pop();
430                                 goto FPU_instruction_done;
431                         }
432                         break;
433                 case _REGI_:
434                         if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
435                                 stack_underflow();
436                                 goto FPU_instruction_done;
437                         }
438                         break;
439                 case _PUSH_:    /* Only used by the fld st(i) instruction */
440                         break;
441                 case _null_:
442                         Un_impl();
443                         goto FPU_instruction_done;
444                 default:
445                         EXCEPTION(EX_INTERNAL | 0x111);
446                         goto FPU_instruction_done;
447                 }
448                 (*st_instr_table[(int) instr_index]) ();
449         }
450
451 FPU_instruction_done:
452
453         ip_offset = FPU_entry_eip;
454         bswapw(code);
455         *(1 + (unsigned short *) &cs_selector) = code & 0x7ff;
456
457 #ifdef DEBUG
458         REENTRANT_CHECK(OFF);
459         emu_printall();
460         REENTRANT_CHECK(ON);
461 #endif                          /* DEBUG */
462 #ifdef LOOKAHEAD_LIMIT
463 if (--lookahead_limit)
464 #endif
465         if (FPU_lookahead) {
466                 unsigned char next;
467
468                 /* (This test should generate no machine code) */
469                 while (1) {
470                         REENTRANT_CHECK(OFF);
471                         next = fubyte((u_char *) FPU_EIP);
472                         REENTRANT_CHECK(ON);
473                         if (((next & 0xf8) == 0xd8) || (next == 0x9b)) {        /* fwait */
474                                 goto do_another_FPU_instruction;
475                         } else
476                                 if (next == 0x66) {     /* size prefix */
477                                         REENTRANT_CHECK(OFF);
478                                         next = fubyte((u_char *) (FPU_EIP + 1));
479                                         REENTRANT_CHECK(ON);
480                                         if ((next & 0xf8) == 0xd8) {
481                                                 FPU_EIP++;
482                                                 goto do_another_FPU_instruction;
483                                         }
484                                 }
485                         break;
486                 }
487         }
488         REENTRANT_CHECK(OFF);
489         return (0);             /* --pink-- */
490 }
491
492 static int
493 gnufpu_modevent(module_t mod, int type, void *unused) 
494 {
495         switch (type) {
496         case MOD_LOAD:
497                 if (pmath_emulate) {
498                         printf("Another Math emulator already present\n");
499                         return EACCES;
500                 }
501                 pmath_emulate = math_emulate;
502                 if (bootverbose)
503                         printf("GPL Math emulator present\n");
504                 break;
505         case MOD_UNLOAD:
506                 if (pmath_emulate != math_emulate) {
507                         printf("Cannot unload another math emulator\n");
508                         return EACCES;
509                 }
510                 pmath_emulate = 0;
511                 if (bootverbose)
512                         printf("GPL Math emulator unloaded\n");
513                 break;
514         default:
515                 break;
516         }
517         return 0;
518                 
519 }
520 static moduledata_t gnufpumod = {
521         "gnufpu",
522         gnufpu_modevent,
523         0
524 };
525 DECLARE_MODULE(gnufpu, gnufpumod, SI_SUB_DRIVERS, SI_ORDER_ANY);