sys/i386/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  *
  60  */
  61
  62 /*---------------------------------------------------------------------------+
  63  | Note:                                                                     |
  64  |    The file contains code which accesses user memory.                     |
  65  |    Emulator static data may change when user memory is accessed, due to   |
  66  |    other processes using the emulator while swapping is in progress.      |
  67  +---------------------------------------------------------------------------*/
  68
  69 /*---------------------------------------------------------------------------+
  70  | math_emulate() is the sole entry point for wm-FPU-emu                     |
  71  +---------------------------------------------------------------------------*/
  72
  73
  74 #include <sys/param.h>
  75 #include <sys/systm.h>
  76 #include <sys/proc.h>
  77 #include <sys/kernel.h>
  78
  79 #include <machine/cpu.h>
  80 #include <machine/pcb.h>
  81
  82 #include <gnu/i386/fpemul/fpu_emu.h>
  83 #include <gnu/i386/fpemul/fpu_system.h>
  84 #include <gnu/i386/fpemul/exception.h>
  85 #include <gnu/i386/fpemul/status_w.h>
  86
  87
  88 #define __BAD__ Un_impl         /* Not implemented */
  89
  90 #define FPU_LOOKAHEAD   1       /* For performance boost */
  91
  92 #if FPU_LOOKAHEAD != 0          /* I think thet we have to limit the */
  93 #define LOOKAHEAD_LIMIT 7       /* Max number of lookahead instructions*/
  94 #endif                          /* Or else a prog consisting of a million */
  95                                 /* fnops will spend all its time in kernel*/
  96
  97 #ifndef NO_UNDOC_CODE           /* Un-documented FPU op-codes supported by
  98                                  * default. */
  99
 100 /* WARNING: These codes are not documented by Intel in their 80486 manual
 101    and may not work on FPU clones or later Intel FPUs. */
 102
 103 /* Changes to support the un-doc codes provided by Linus Torvalds. */
 104
 105 #define _d9_d8_ fstp_i          /* unofficial code (19) */
 106 #define _dc_d0_ fcom_st         /* unofficial code (14) */
 107 #define _dc_d8_ fcompst         /* unofficial code (1c) */
 108 #define _dd_c8_ fxch_i          /* unofficial code (0d) */
 109 #define _de_d0_ fcompst         /* unofficial code (16) */
 110 #define _df_c0_ ffreep          /* unofficial code (07) ffree + pop */
 111 #define _df_c8_ fxch_i          /* unofficial code (0f) */
 112 #define _df_d0_ fstp_i          /* unofficial code (17) */
 113 #define _df_d8_ fstp_i          /* unofficial code (1f) */
 114
 115 static FUNC st_instr_table[64] = {
 116         fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, _df_c0_,
 117         fmul__, fxch_i, __BAD__, __BAD__, fmul_i, _dd_c8_, fmulp_, _df_c8_,
 118         fcom_st, fp_nop, __BAD__, __BAD__, _dc_d0_, fst_i_, _de_d0_, _df_d0_,
 119         fcompst, _d9_d8_, __BAD__, __BAD__, _dc_d8_, fstp_i, fcompp, _df_d8_,
 120         fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
 121         fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
 122         fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
 123         fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
 124 };
 125 #else                           /* Support only documented FPU op-codes */
 126
 127 static FUNC st_instr_table[64] = {
 128         fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, __BAD__,
 129         fmul__, fxch_i, __BAD__, __BAD__, fmul_i, __BAD__, fmulp_, __BAD__,
 130         fcom_st, fp_nop, __BAD__, __BAD__, __BAD__, fst_i_, __BAD__, __BAD__,
 131         fcompst, __BAD__, __BAD__, __BAD__, __BAD__, fstp_i, fcompp, __BAD__,
 132         fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
 133         fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
 134         fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
 135         fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
 136 };
 137 #endif                          /* NO_UNDOC_CODE */
 138
 139
 140 #define _NONE_ 0                /* Take no special action */
 141 #define _REG0_ 1                /* Need to check for not empty st(0) */
 142 #define _REGI_ 2                /* Need to check for not empty st(0) and
 143                                  * st(rm) */
 144 #define _REGi_ 0                /* Uses st(rm) */
 145 #define _PUSH_ 3                /* Need to check for space to push onto stack */
 146 #define _null_ 4                /* Function illegal or not implemented */
 147 #define _REGIi 5                /* Uses st(0) and st(rm), result to st(rm) */
 148 #define _REGIp 6                /* Uses st(0) and st(rm), result to st(rm)
 149                                  * then pop */
 150 #define _REGIc 0                /* Compare st(0) and st(rm) */
 151 #define _REGIn 0                /* Uses st(0) and st(rm), but handle checks
 152                                  * later */
 153
 154 #ifndef NO_UNDOC_CODE
 155
 156 /* Un-documented FPU op-codes supported by default. (see above) */
 157
 158 static unsigned char type_table[64] = {
 159         _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _REGi_,
 160         _REGI_, _REGIn, _null_, _null_, _REGIi, _REGI_, _REGIp, _REGI_,
 161         _REGIc, _NONE_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
 162         _REGIc, _REG0_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
 163         _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
 164         _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
 165         _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
 166         _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
 167 };
 168 #else                           /* Support only documented FPU op-codes */
 169
 170 static unsigned char type_table[64] = {
 171         _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _null_,
 172         _REGI_, _REGIn, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
 173         _REGIc, _NONE_, _null_, _null_, _null_, _REG0_, _null_, _null_,
 174         _REGIc, _null_, _null_, _null_, _null_, _REG0_, _REGIc, _null_,
 175         _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
 176         _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
 177         _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
 178         _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
 179 };
 180 #endif                          /* NO_UNDOC_CODE */
 181
 182 /* Be careful when using any of these global variables...
 183    they might change if swapping is triggered */
 184 unsigned char FPU_rm;
 185 char    FPU_st0_tag;
 186 FPU_REG *FPU_st0_ptr;
 187
 188 #ifdef PARANOID
 189 char    emulating = 0;
 190 #endif                          /* PARANOID */
 191
 192 #define bswapw(x) __asm__("xchgb %%al,%%ah":"=a" (x):"0" ((short)x))
 193 #define math_abort(signo) \
 194     FPU_EIP = FPU_ORIG_EIP;REENTRANT_CHECK(OFF);return(signo);
 195
 196 static int
 197 math_emulate(struct trapframe * tframe)
 198 {
 199
 200         unsigned char FPU_modrm;
 201         unsigned short code;
 202 #ifdef LOOKAHEAD_LIMIT
 203         int lookahead_limit = LOOKAHEAD_LIMIT;
 204 #endif
 205 #ifdef PARANOID
 206         if (emulating) {
 207                 printf("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
 208         }
 209         REENTRANT_CHECK(ON);
 210 #endif                          /* PARANOID */
 211
 212         if ((((struct pcb *) curproc->p_addr)->pcb_flags & FP_SOFTFP) == 0) {
 213                 finit();
 214                 control_word = __INITIAL_NPXCW__;
 215                 ((struct pcb *) curproc->p_addr)->pcb_flags |= FP_SOFTFP;
 216         }
 217         FPU_info = tframe;
 218         FPU_ORIG_EIP = FPU_EIP; /* --pink-- */
 219
 220         if (FPU_CS != 0x001f) {
 221                 printf("math_emulate: %x : %x\n", FPU_CS, FPU_EIP);
 222                 panic("FPU emulation in kernel");
 223         }
 224 #ifdef notyet
 225         /* We cannot handle emulation in v86-mode */
 226         if (FPU_EFLAGS & 0x00020000) {
 227                 FPU_ORIG_EIP = FPU_EIP;
 228                 math_abort(FPU_info, SIGILL);
 229         }
 230 #endif
 231
 232         FPU_lookahead = FPU_LOOKAHEAD;
 233         if (curproc->p_flag & P_TRACED)
 234                 FPU_lookahead = 0;
 235
 236 do_another_FPU_instruction:
 237
 238         REENTRANT_CHECK(OFF);
 239         code = fuword((u_int *) FPU_EIP);
 240         REENTRANT_CHECK(ON);
 241         if ((code & 0xff) == 0x9b) {    /* fwait */
 242                 if (status_word & SW_Summary)
 243                         goto do_the_FPU_interrupt;
 244                 else {
 245                         FPU_EIP++;
 246                         goto FPU_instruction_done;
 247                 }
 248         }
 249         if (status_word & SW_Summary) {
 250                 /* Ignore the error for now if the current instruction is a
 251                  * no-wait control instruction */
 252                 /* The 80486 manual contradicts itself on this topic, so I use
 253                  * the following list of such instructions until I can check
 254                  * on a real 80486: fninit, fnstenv, fnsave, fnstsw, fnstenv,
 255                  * fnclex. */
 256                 if (!((((code & 0xf803) == 0xe003) ||   /* fnclex, fninit,
 257                                                          * fnstsw */
 258                             (((code & 0x3003) == 0x3001) &&     /* fnsave, fnstcw,
 259                                                                  * fnstenv, fnstsw */
 260                                 ((code & 0xc000) != 0xc000))))) {
 261                         /* This is a guess about what a real FPU might do to
 262                          * this bit: */
 263 /*        status_word &= ~SW_Summary; ****/
 264
 265                         /* We need to simulate the action of the kernel to FPU
 266                          * interrupts here. Currently, the "real FPU" part of
 267                          * the kernel (0.99.10) clears the exception flags,
 268                          * sets the registers to empty, and passes information
 269                          * back to the interrupted process via the cs selector
 270                          * and operand selector, so we do the same. */
 271         do_the_FPU_interrupt:
 272                         cs_selector &= 0xffff0000;
 273                         cs_selector |= (status_word & ~SW_Top) | ((top & 7) << SW_Top_Shift);
 274                         operand_selector = tag_word();
 275                         status_word = 0;
 276                         top = 0;
 277                         {
 278                                 int     r;
 279                                 for (r = 0; r < 8; r++) {
 280                                         regs[r].tag = TW_Empty;
 281                                 }
 282                         }
 283                         REENTRANT_CHECK(OFF);
 284                         math_abort(SIGFPE);
 285                 }
 286         }
 287         FPU_entry_eip = FPU_ORIG_EIP = FPU_EIP;
 288
 289         if ((code & 0xff) == 0x66) {    /* size prefix */
 290                 FPU_EIP++;
 291                 REENTRANT_CHECK(OFF);
 292                 code = fuword((u_int *) FPU_EIP);
 293                 REENTRANT_CHECK(ON);
 294         }
 295         FPU_EIP += 2;
 296
 297         FPU_modrm = code >> 8;
 298         FPU_rm = FPU_modrm & 7;
 299
 300         if (FPU_modrm < 0300) {
 301                 /* All of these instructions use the mod/rm byte to get a data
 302                  * address */
 303                 get_address(FPU_modrm);
 304                 if (!(code & 1)) {
 305                         unsigned short status1 = status_word;
 306                         FPU_st0_ptr = &st(0);
 307                         FPU_st0_tag = FPU_st0_ptr->tag;
 308
 309                         /* Stack underflow has priority */
 310                         if (NOT_EMPTY_0) {
 311                                 switch ((code >> 1) & 3) {
 312                                 case 0:
 313                                         reg_load_single();
 314                                         break;
 315                                 case 1:
 316                                         reg_load_int32();
 317                                         break;
 318                                 case 2:
 319                                         reg_load_double();
 320                                         break;
 321                                 case 3:
 322                                         reg_load_int16();
 323                                         break;
 324                                 }
 325
 326                                 /* No more access to user memory, it is safe
 327                                  * to use static data now */
 328                                 FPU_st0_ptr = &st(0);
 329                                 FPU_st0_tag = FPU_st0_ptr->tag;
 330
 331                                 /* NaN operands have the next priority. */
 332                                 /* We have to delay looking at st(0) until
 333                                  * after loading the data, because that data
 334                                  * might contain an SNaN */
 335                                 if ((FPU_st0_tag == TW_NaN) ||
 336                                     (FPU_loaded_data.tag == TW_NaN)) {
 337                                         /* Restore the status word; we might
 338                                          * have loaded a denormal. */
 339                                         status_word = status1;
 340                                         if ((FPU_modrm & 0x30) == 0x10) {
 341                                                 /* fcom or fcomp */
 342                                                 EXCEPTION(EX_Invalid);
 343                                                 setcc(SW_C3 | SW_C2 | SW_C0);
 344                                                 if (FPU_modrm & 0x08)
 345                                                         pop();  /* fcomp, so we pop. */
 346                                         } else
 347                                                 real_2op_NaN(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr);
 348                                         goto reg_mem_instr_done;
 349                                 }
 350                                 switch ((FPU_modrm >> 3) & 7) {
 351                                 case 0: /* fadd */
 352                                         reg_add(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
 353                                         break;
 354                                 case 1: /* fmul */
 355                                         reg_mul(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
 356                                         break;
 357                                 case 2: /* fcom */
 358                                         compare_st_data();
 359                                         break;
 360                                 case 3: /* fcomp */
 361                                         compare_st_data();
 362                                         pop();
 363                                         break;
 364                                 case 4: /* fsub */
 365                                         reg_sub(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
 366                                         break;
 367                                 case 5: /* fsubr */
 368                                         reg_sub(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr, control_word);
 369                                         break;
 370                                 case 6: /* fdiv */
 371                                         reg_div(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
 372                                         break;
 373                                 case 7: /* fdivr */
 374                                         if (FPU_st0_tag == TW_Zero)
 375                                                 status_word = status1;  /* Undo any denorm tag,
 376                                                                          * zero-divide has
 377                                                                          * priority. */
 378                                         reg_div(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr, control_word);
 379                                         break;
 380                                 }
 381                         } else {
 382                                 if ((FPU_modrm & 0x30) == 0x10) {
 383                                         /* The instruction is fcom or fcomp */
 384                                         EXCEPTION(EX_StackUnder);
 385                                         setcc(SW_C3 | SW_C2 | SW_C0);
 386                                         if (FPU_modrm & 0x08)
 387                                                 pop();  /* fcomp, Empty or not,
 388                                                          * we pop. */
 389                                 } else
 390                                         stack_underflow();
 391                         }
 392                 } else {
 393                         load_store_instr(((FPU_modrm & 0x38) | (code & 6)) >> 1);
 394                 }
 395
 396 reg_mem_instr_done:
 397
 398                 data_operand_offset = (intptr_t) (void *) FPU_data_address;
 399         } else {
 400                 /* None of these instructions access user memory */
 401                 unsigned char instr_index = (FPU_modrm & 0x38) | (code & 7);
 402
 403                 FPU_st0_ptr = &st(0);
 404                 FPU_st0_tag = FPU_st0_ptr->tag;
 405                 switch (type_table[(int) instr_index]) {
 406                 case _NONE_:    /* also _REGIc: _REGIn */
 407                         break;
 408                 case _REG0_:
 409                         if (!NOT_EMPTY_0) {
 410                                 stack_underflow();
 411                                 goto FPU_instruction_done;
 412                         }
 413                         break;
 414                 case _REGIi:
 415                         if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
 416                                 stack_underflow_i(FPU_rm);
 417                                 goto FPU_instruction_done;
 418                         }
 419                         break;
 420                 case _REGIp:
 421                         if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
 422                                 stack_underflow_i(FPU_rm);
 423                                 pop();
 424                                 goto FPU_instruction_done;
 425                         }
 426                         break;
 427                 case _REGI_:
 428                         if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
 429                                 stack_underflow();
 430                                 goto FPU_instruction_done;
 431                         }
 432                         break;
 433                 case _PUSH_:    /* Only used by the fld st(i) instruction */
 434                         break;
 435                 case _null_:
 436                         Un_impl();
 437                         goto FPU_instruction_done;
 438                 default:
 439                         EXCEPTION(EX_INTERNAL | 0x111);
 440                         goto FPU_instruction_done;
 441                 }
 442                 (*st_instr_table[(int) instr_index]) ();
 443         }
 444
 445 FPU_instruction_done:
 446
 447         ip_offset = FPU_entry_eip;
 448         bswapw(code);
 449         *(1 + (unsigned short *) &cs_selector) = code & 0x7ff;
 450
 451 #ifdef DEBUG
 452         REENTRANT_CHECK(OFF);
 453         emu_printall();
 454         REENTRANT_CHECK(ON);
 455 #endif                          /* DEBUG */
 456 #ifdef LOOKAHEAD_LIMIT
 457 if (--lookahead_limit)
 458 #endif
 459         if (FPU_lookahead) {
 460                 unsigned char next;
 461
 462                 /* (This test should generate no machine code) */
 463                 while (1) {
 464                         REENTRANT_CHECK(OFF);
 465                         next = fubyte((u_char *) FPU_EIP);
 466                         REENTRANT_CHECK(ON);
 467                         if (((next & 0xf8) == 0xd8) || (next == 0x9b)) {        /* fwait */
 468                                 goto do_another_FPU_instruction;
 469                         } else
 470                                 if (next == 0x66) {     /* size prefix */
 471                                         REENTRANT_CHECK(OFF);
 472                                         next = fubyte((u_char *) (FPU_EIP + 1));
 473                                         REENTRANT_CHECK(ON);
 474                                         if ((next & 0xf8) == 0xd8) {
 475                                                 FPU_EIP++;
 476                                                 goto do_another_FPU_instruction;
 477                                         }
 478                                 }
 479                         break;
 480                 }
 481         }
 482         REENTRANT_CHECK(OFF);
 483         return (0);             /* --pink-- */
 484 }
 485
 486 static int
 487 gnufpu_modevent(module_t mod, int type, void *unused)
 488 {
 489         switch (type) {
 490         case MOD_LOAD:
 491                 if (pmath_emulate) {
 492                         printf("Another Math emulator already present\n");
 493                         return EACCES;
 494                 }
 495                 pmath_emulate = math_emulate;
 496                 if (bootverbose)
 497                         printf("GPL Math emulator present\n");
 498                 break;
 499         case MOD_UNLOAD:
 500                 if (pmath_emulate != math_emulate) {
 501                         printf("Cannot unload another math emulator\n");
 502                         return EACCES;
 503                 }
 504                 pmath_emulate = 0;
 505                 if (bootverbose)
 506                         printf("GPL Math emulator unloaded\n");
 507                 break;
 508         default:
 509                 break;
 510         }
 511         return 0;
 512
 513 }
 514 static moduledata_t gnufpumod = {
 515         "gnufpu",
 516         gnufpu_modevent,
 517         0
 518 };
 519 DECLARE_MODULE(gnufpu, gnufpumod, SI_SUB_DRIVERS, SI_ORDER_ANY);