home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / arch / i386 / math-emu / fpu_entry.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-27  |  19.7 KB  |  691 lines
  1. /*---------------------------------------------------------------------------+
  2.  |  fpu_entry.c                                                              |
  3.  |                                                                           |
  4.  | The entry function for wm-FPU-emu                                         |
  5.  |                                                                           |
  6.  | Copyright (C) 1992,1993,1994                                              |
  7.  |                       W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
  8.  |                       Australia.  E-mail   billm@vaxc.cc.monash.edu.au    |
  9.  |                                                                           |
  10.  | See the files "README" and "COPYING" for further copyright and warranty   |
  11.  | information.                                                              |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------*/
  14.  
  15. /*---------------------------------------------------------------------------+
  16.  | Note:                                                                     |
  17.  |    The file contains code which accesses user memory.                     |
  18.  |    Emulator static data may change when user memory is accessed, due to   |
  19.  |    other processes using the emulator while swapping is in progress.      |
  20.  +---------------------------------------------------------------------------*/
  21.  
  22. /*---------------------------------------------------------------------------+
  23.  | math_emulate() is the sole entry point for wm-FPU-emu                     |
  24.  +---------------------------------------------------------------------------*/
  25.  
  26. #include <linux/signal.h>
  27.  
  28. #include <asm/segment.h>
  29.  
  30. #include "fpu_system.h"
  31. #include "fpu_emu.h"
  32. #include "exception.h"
  33. #include "control_w.h"
  34. #include "status_w.h"
  35.  
  36. #define __BAD__ FPU_illegal   /* Illegal on an 80486, causes SIGILL */
  37.  
  38. #ifndef NO_UNDOC_CODE    /* Un-documented FPU op-codes supported by default. */
  39.  
  40. /* WARNING: These codes are not documented by Intel in their 80486 manual
  41.    and may not work on FPU clones or later Intel FPUs. */
  42.  
  43. /* Changes to support the un-doc codes provided by Linus Torvalds. */
  44.  
  45. #define _d9_d8_ fstp_i    /* unofficial code (19) */
  46. #define _dc_d0_ fcom_st   /* unofficial code (14) */
  47. #define _dc_d8_ fcompst   /* unofficial code (1c) */
  48. #define _dd_c8_ fxch_i    /* unofficial code (0d) */
  49. #define _de_d0_ fcompst   /* unofficial code (16) */
  50. #define _df_c0_ ffreep    /* unofficial code (07) ffree + pop */
  51. #define _df_c8_ fxch_i    /* unofficial code (0f) */
  52. #define _df_d0_ fstp_i    /* unofficial code (17) */
  53. #define _df_d8_ fstp_i    /* unofficial code (1f) */
  54.  
  55. static FUNC const st_instr_table[64] = {
  56.   fadd__,   fld_i_,  __BAD__, __BAD__, fadd_i,  ffree_,  faddp_,  _df_c0_,
  57.   fmul__,   fxch_i,  __BAD__, __BAD__, fmul_i,  _dd_c8_, fmulp_,  _df_c8_,
  58.   fcom_st,  fp_nop,  __BAD__, __BAD__, _dc_d0_, fst_i_,  _de_d0_, _df_d0_,
  59.   fcompst,  _d9_d8_, __BAD__, __BAD__, _dc_d8_, fstp_i,  fcompp,  _df_d8_,
  60.   fsub__,   fp_etc,  __BAD__, finit_,  fsubri,  fucom_,  fsubrp,  fstsw_,
  61.   fsubr_,   fconst,  fucompp, __BAD__, fsub_i,  fucomp,  fsubp_,  __BAD__,
  62.   fdiv__,   trig_a,  __BAD__, __BAD__, fdivri,  __BAD__, fdivrp,  __BAD__,
  63.   fdivr_,   trig_b,  __BAD__, __BAD__, fdiv_i,  __BAD__, fdivp_,  __BAD__,
  64. };
  65.  
  66. #else     /* Support only documented FPU op-codes */
  67.  
  68. static FUNC const st_instr_table[64] = {
  69.   fadd__,   fld_i_,  __BAD__, __BAD__, fadd_i,  ffree_,  faddp_,  __BAD__,
  70.   fmul__,   fxch_i,  __BAD__, __BAD__, fmul_i,  __BAD__, fmulp_,  __BAD__,
  71.   fcom_st,  fp_nop,  __BAD__, __BAD__, __BAD__, fst_i_,  __BAD__, __BAD__,
  72.   fcompst,  __BAD__, __BAD__, __BAD__, __BAD__, fstp_i,  fcompp,  __BAD__,
  73.   fsub__,   fp_etc,  __BAD__, finit_,  fsubri,  fucom_,  fsubrp,  fstsw_,
  74.   fsubr_,   fconst,  fucompp, __BAD__, fsub_i,  fucomp,  fsubp_,  __BAD__,
  75.   fdiv__,   trig_a,  __BAD__, __BAD__, fdivri,  __BAD__, fdivrp,  __BAD__,
  76.   fdivr_,   trig_b,  __BAD__, __BAD__, fdiv_i,  __BAD__, fdivp_,  __BAD__,
  77. };
  78.  
  79. #endif NO_UNDOC_CODE
  80.  
  81.  
  82. #define _NONE_ 0   /* Take no special action */
  83. #define _REG0_ 1   /* Need to check for not empty st(0) */
  84. #define _REGI_ 2   /* Need to check for not empty st(0) and st(rm) */
  85. #define _REGi_ 0   /* Uses st(rm) */
  86. #define _PUSH_ 3   /* Need to check for space to push onto stack */
  87. #define _null_ 4   /* Function illegal or not implemented */
  88. #define _REGIi 5   /* Uses st(0) and st(rm), result to st(rm) */
  89. #define _REGIp 6   /* Uses st(0) and st(rm), result to st(rm) then pop */
  90. #define _REGIc 0   /* Compare st(0) and st(rm) */
  91. #define _REGIn 0   /* Uses st(0) and st(rm), but handle checks later */
  92.  
  93. #ifndef NO_UNDOC_CODE
  94.  
  95. /* Un-documented FPU op-codes supported by default. (see above) */
  96.  
  97. static unsigned char const type_table[64] = {
  98.   _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _REGi_,
  99.   _REGI_, _REGIn, _null_, _null_, _REGIi, _REGI_, _REGIp, _REGI_,
  100.   _REGIc, _NONE_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
  101.   _REGIc, _REG0_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
  102.   _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
  103.   _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
  104.   _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
  105.   _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
  106. };
  107.  
  108. #else     /* Support only documented FPU op-codes */
  109.  
  110. static unsigned char const type_table[64] = {
  111.   _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _null_,
  112.   _REGI_, _REGIn, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
  113.   _REGIc, _NONE_, _null_, _null_, _null_, _REG0_, _null_, _null_,
  114.   _REGIc, _null_, _null_, _null_, _null_, _REG0_, _REGIc, _null_,
  115.   _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
  116.   _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
  117.   _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
  118.   _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
  119. };
  120.  
  121. #endif NO_UNDOC_CODE
  122.  
  123.  
  124. #ifdef RE_ENTRANT_CHECKING
  125. char emulating=0;
  126. #endif RE_ENTRANT_CHECKING
  127.  
  128. static int valid_prefix(unsigned char *Byte, unsigned char **fpu_eip,
  129.             overrides *override);
  130.  
  131. asmlinkage void math_emulate(long arg)
  132. {
  133.   unsigned char  FPU_modrm, byte1;
  134.   unsigned short code;
  135.   fpu_addr_modes addr_modes;
  136.   int unmasked;
  137.   FPU_REG loaded_data;
  138.   void *data_address;
  139.   struct address data_sel_off;
  140.   struct address entry_sel_off;
  141.   unsigned long code_base = 0;
  142.   unsigned long code_limit = 0;  /* Initialized to stop compiler warnings */
  143.   char           st0_tag;
  144.   FPU_REG      *st0_ptr;
  145.   struct desc_struct code_descriptor;
  146.  
  147. #ifdef RE_ENTRANT_CHECKING
  148.   if ( emulating )
  149.     {
  150.       printk("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
  151.     }
  152.   RE_ENTRANT_CHECK_ON;
  153. #endif RE_ENTRANT_CHECKING
  154.  
  155.   if (!current->used_math)
  156.     {
  157.       int i;
  158.       for ( i = 0; i < 8; i++ )
  159.     {
  160.       /* Make sure that the registers are compatible
  161.          with the assumptions of the emulator. */
  162.       regs[i].exp = 0;
  163.       regs[i].sigh = 0x80000000;
  164.     }
  165.       finit();
  166.       current->used_math = 1;
  167.     }
  168.  
  169.   SETUP_DATA_AREA(arg);
  170.  
  171.   FPU_ORIG_EIP = FPU_EIP;
  172.  
  173.   if ( (FPU_EFLAGS & 0x00020000) != 0 )
  174.     {
  175.       /* Virtual 8086 mode */
  176.       addr_modes.default_mode = VM86;
  177.       FPU_EIP += code_base = FPU_CS << 4;
  178.       code_limit = code_base + 0xffff;  /* Assumes code_base <= 0xffff0000 */
  179.     }
  180.   else if ( FPU_CS == USER_CS && FPU_DS == USER_DS )
  181.     {
  182.       addr_modes.default_mode = 0;
  183.     }
  184.   else if ( FPU_CS == KERNEL_CS )
  185.     {
  186.       printk("math_emulate: %04x:%08lx\n",FPU_CS,FPU_EIP);
  187.       panic("Math emulation needed in kernel");
  188.     }
  189.   else
  190.     {
  191.  
  192.       if ( (FPU_CS & 4) != 4 )   /* Must be in the LDT */
  193.     {
  194.       /* Can only handle segmented addressing via the LDT
  195.          for now, and it must be 16 bit */
  196.       printk("FPU emulator: Unsupported addressing mode\n");
  197.       math_abort(FPU_info, SIGILL);
  198.     }
  199.  
  200.       if ( SEG_D_SIZE(code_descriptor = LDT_DESCRIPTOR(FPU_CS)) )
  201.     {
  202.       /* The above test may be wrong, the book is not clear */
  203.       /* Segmented 32 bit protected mode */
  204.       addr_modes.default_mode = SEG32;
  205.     }
  206.       else
  207.     {
  208.       /* 16 bit protected mode */
  209.       addr_modes.default_mode = PM16;
  210.     }
  211.       FPU_EIP += code_base = SEG_BASE_ADDR(code_descriptor);
  212.       code_limit = code_base
  213.     + (SEG_LIMIT(code_descriptor)+1) * SEG_GRANULARITY(code_descriptor)
  214.       - 1;
  215.       if ( code_limit < code_base ) code_limit = 0xffffffff;
  216.     }
  217.  
  218.   FPU_lookahead = 1;
  219.   if (current->flags & PF_PTRACED)
  220.     FPU_lookahead = 0;
  221.  
  222.   if ( !valid_prefix(&byte1, (unsigned char **)&FPU_EIP,
  223.              &addr_modes.override) )
  224.     {
  225.       RE_ENTRANT_CHECK_OFF;
  226.       printk("FPU emulator: Unknown prefix byte 0x%02x, probably due to\n"
  227.          "FPU emulator: self-modifying code! (emulation impossible)\n",
  228.          byte1);
  229.       RE_ENTRANT_CHECK_ON;
  230.       EXCEPTION(EX_INTERNAL|0x126);
  231.       math_abort(FPU_info,SIGILL);
  232.     }
  233.  
  234. do_another_FPU_instruction:
  235.  
  236.   no_ip_update = 0;
  237.  
  238.   FPU_EIP++;  /* We have fetched the prefix and first code bytes. */
  239.  
  240.   if ( addr_modes.default_mode )
  241.     {
  242.       /* This checks for the minimum instruction bytes.
  243.      We also need to check any extra (address mode) code access. */
  244.       if ( FPU_EIP > code_limit )
  245.     math_abort(FPU_info,SIGSEGV);
  246.     }
  247.  
  248.   if ( (byte1 & 0xf8) != 0xd8 )
  249.     {
  250.       if ( byte1 == FWAIT_OPCODE )
  251.     {
  252.       if (partial_status & SW_Summary)
  253.         goto do_the_FPU_interrupt;
  254.       else
  255.         goto FPU_fwait_done;
  256.     }
  257. #ifdef PARANOID
  258.       EXCEPTION(EX_INTERNAL|0x128);
  259.       math_abort(FPU_info,SIGILL);
  260. #endif PARANOID
  261.     }
  262.  
  263.   RE_ENTRANT_CHECK_OFF;
  264.   FPU_code_verify_area(1);
  265.   FPU_modrm = get_fs_byte((unsigned char *) FPU_EIP);
  266.   RE_ENTRANT_CHECK_ON;
  267.   FPU_EIP++;
  268.  
  269.   if (partial_status & SW_Summary)
  270.     {
  271.       /* Ignore the error for now if the current instruction is a no-wait
  272.      control instruction */
  273.       /* The 80486 manual contradicts itself on this topic,
  274.      but a real 80486 uses the following instructions:
  275.      fninit, fnstenv, fnsave, fnstsw, fnstenv, fnclex.
  276.        */
  277.       code = (FPU_modrm << 8) | byte1;
  278.       if ( ! ( (((code & 0xf803) == 0xe003) ||    /* fnclex, fninit, fnstsw */
  279.         (((code & 0x3003) == 0x3001) &&   /* fnsave, fnstcw, fnstenv,
  280.                              fnstsw */
  281.          ((code & 0xc000) != 0xc000))) ) )
  282.     {
  283.       /*
  284.        *  We need to simulate the action of the kernel to FPU
  285.        *  interrupts here.
  286.        *  Currently, the "real FPU" part of the kernel (0.99.10)
  287.        *  clears the exception flags, sets the registers to empty,
  288.        *  and passes information back to the interrupted process
  289.        *  via the cs selector and operand selector, so we do the same.
  290.        */
  291.     do_the_FPU_interrupt:
  292.       instruction_address.selector = status_word();
  293.             operand_address.selector = tag_word();
  294.       partial_status = 0;
  295.       top = 0;
  296.       {
  297.         int r;
  298.         for (r = 0; r < 8; r++)
  299.           {
  300.         regs[r].tag = TW_Empty;
  301.           }
  302.       }
  303.  
  304.       FPU_EIP = FPU_ORIG_EIP;    /* Point to current FPU instruction. */
  305.  
  306.       RE_ENTRANT_CHECK_OFF;
  307.       current->tss.trap_no = 16;
  308.       current->tss.error_code = 0;
  309.       send_sig(SIGFPE, current, 1);
  310.       return;
  311.     }
  312.     }
  313.  
  314.   entry_sel_off.offset = FPU_ORIG_EIP;
  315.   entry_sel_off.selector = FPU_CS;
  316.   entry_sel_off.opcode = (byte1 << 8) | FPU_modrm;
  317.  
  318.   FPU_rm = FPU_modrm & 7;
  319.  
  320.   if ( FPU_modrm < 0300 )
  321.     {
  322.       /* All of these instructions use the mod/rm byte to get a data address */
  323.  
  324.       if ( (addr_modes.default_mode & SIXTEEN)
  325.       ^ (addr_modes.override.address_size == ADDR_SIZE_PREFIX) )
  326.     data_address = get_address_16(FPU_modrm, &FPU_EIP, &data_sel_off,
  327.                       addr_modes);
  328.       else
  329.     data_address = get_address(FPU_modrm, &FPU_EIP, &data_sel_off,
  330.                    addr_modes);
  331.  
  332.       if ( addr_modes.default_mode )
  333.     {
  334.       if ( FPU_EIP-1 > code_limit )
  335.         math_abort(FPU_info,SIGSEGV);
  336.     }
  337.  
  338.       if ( !(byte1 & 1) )
  339.     {
  340.       unsigned short status1 = partial_status;
  341.  
  342.       st0_ptr = &st(0);
  343.       st0_tag = st0_ptr->tag;
  344.  
  345.       /* Stack underflow has priority */
  346.       if ( NOT_EMPTY_ST0 )
  347.         {
  348.           if ( addr_modes.default_mode & PROTECTED )
  349.         {
  350.           /* This table works for 16 and 32 bit protected mode */
  351.           if ( access_limit < data_sizes_16[(byte1 >> 1) & 3] )
  352.             math_abort(FPU_info,SIGSEGV);
  353.         }
  354.  
  355.           unmasked = 0;  /* Do this here to stop compiler warnings. */
  356.           switch ( (byte1 >> 1) & 3 )
  357.         {
  358.         case 0:
  359.           unmasked = reg_load_single((float *)data_address,
  360.                          &loaded_data);
  361.           break;
  362.         case 1:
  363.           reg_load_int32((long *)data_address, &loaded_data);
  364.           break;
  365.         case 2:
  366.           unmasked = reg_load_double((double *)data_address,
  367.                          &loaded_data);
  368.           break;
  369.         case 3:
  370.           reg_load_int16((short *)data_address, &loaded_data);
  371.           break;
  372.         }
  373.           
  374.           /* No more access to user memory, it is safe
  375.          to use static data now */
  376.  
  377.           /* NaN operands have the next priority. */
  378.           /* We have to delay looking at st(0) until after
  379.          loading the data, because that data might contain an SNaN */
  380.           if ( (st0_tag == TW_NaN) ||
  381.           (loaded_data.tag == TW_NaN) )
  382.         {
  383.           /* Restore the status word; we might have loaded a
  384.              denormal. */
  385.           partial_status = status1;
  386.           if ( (FPU_modrm & 0x30) == 0x10 )
  387.             {
  388.               /* fcom or fcomp */
  389.               EXCEPTION(EX_Invalid);
  390.               setcc(SW_C3 | SW_C2 | SW_C0);
  391.               if ( (FPU_modrm & 0x08) && (control_word & CW_Invalid) )
  392.             pop();             /* fcomp, masked, so we pop. */
  393.             }
  394.           else
  395.             {
  396. #ifdef PECULIAR_486
  397.               /* This is not really needed, but gives behaviour
  398.              identical to an 80486 */
  399.               if ( (FPU_modrm & 0x28) == 0x20 )
  400.             /* fdiv or fsub */
  401.             real_2op_NaN(&loaded_data, st0_ptr,
  402.                      st0_ptr);
  403.               else
  404. #endif PECULIAR_486
  405.             /* fadd, fdivr, fmul, or fsubr */
  406.             real_2op_NaN(st0_ptr, &loaded_data,
  407.                      st0_ptr);
  408.             }
  409.           goto reg_mem_instr_done;
  410.         }
  411.  
  412.           if ( unmasked && !((FPU_modrm & 0x30) == 0x10) )
  413.         {
  414.           /* Is not a comparison instruction. */
  415.           if ( (FPU_modrm & 0x38) == 0x38 )
  416.             {
  417.               /* fdivr */
  418.               if ( (st0_tag == TW_Zero) &&
  419.               (loaded_data.tag == TW_Valid) )
  420.             {
  421.               if ( divide_by_zero(loaded_data.sign,
  422.                           st0_ptr) )
  423.                 {
  424.                   /* We use the fact here that the unmasked
  425.                  exception in the loaded data was for a
  426.                  denormal operand */
  427.                   /* Restore the state of the denormal op bit */
  428.                   partial_status &= ~SW_Denorm_Op;
  429.                   partial_status |= status1 & SW_Denorm_Op;
  430.                 }
  431.             }
  432.             }
  433.           goto reg_mem_instr_done;
  434.         }
  435.  
  436.           switch ( (FPU_modrm >> 3) & 7 )
  437.         {
  438.         case 0:         /* fadd */
  439.           clear_C1();
  440.           reg_add(st0_ptr, &loaded_data, st0_ptr,
  441.               control_word);
  442.           break;
  443.         case 1:         /* fmul */
  444.           clear_C1();
  445.           reg_mul(st0_ptr, &loaded_data, st0_ptr,
  446.               control_word);
  447.           break;
  448.         case 2:         /* fcom */
  449.           compare_st_data(&loaded_data);
  450.           break;
  451.         case 3:         /* fcomp */
  452.           if ( !compare_st_data(&loaded_data) && !unmasked )
  453.             pop();
  454.           break;
  455.         case 4:         /* fsub */
  456.           clear_C1();
  457.           reg_sub(st0_ptr, &loaded_data, st0_ptr,
  458.               control_word);
  459.           break;
  460.         case 5:         /* fsubr */
  461.           clear_C1();
  462.           reg_sub(&loaded_data, st0_ptr, st0_ptr,
  463.               control_word);
  464.           break;
  465.         case 6:         /* fdiv */
  466.           clear_C1();
  467.           reg_div(st0_ptr, &loaded_data, st0_ptr,
  468.               control_word);
  469.           break;
  470.         case 7:         /* fdivr */
  471.           clear_C1();
  472.           if ( st0_tag == TW_Zero )
  473.             partial_status = status1;  /* Undo any denorm tag,
  474.                            zero-divide has priority. */
  475.           reg_div(&loaded_data, st0_ptr, st0_ptr,
  476.               control_word);
  477.           break;
  478.         }
  479.         }
  480.       else
  481.         {
  482.           if ( (FPU_modrm & 0x30) == 0x10 )
  483.         {
  484.           /* The instruction is fcom or fcomp */
  485.           EXCEPTION(EX_StackUnder);
  486.           setcc(SW_C3 | SW_C2 | SW_C0);
  487.           if ( (FPU_modrm & 0x08) && (control_word & CW_Invalid) )
  488.             pop();             /* fcomp */
  489.         }
  490.           else
  491.         stack_underflow();
  492.         }
  493.     reg_mem_instr_done:
  494.       operand_address = data_sel_off;
  495.     }
  496.       else
  497.     {
  498.       if ( !(no_ip_update =
  499.          load_store_instr(((FPU_modrm & 0x38) | (byte1 & 6)) >> 1,
  500.                   addr_modes, data_address)) )
  501.         {
  502.           operand_address = data_sel_off;
  503.         }
  504.     }
  505.  
  506.     }
  507.   else
  508.     {
  509.       /* None of these instructions access user memory */
  510.       unsigned char instr_index = (FPU_modrm & 0x38) | (byte1 & 7);
  511.  
  512. #ifdef PECULIAR_486
  513.       /* This is supposed to be undefined, but a real 80486 seems
  514.      to do this: */
  515.       operand_address.offset = 0;
  516.       operand_address.selector = FPU_DS;
  517. #endif PECULIAR_486
  518.  
  519.       st0_ptr = &st(0);
  520.       st0_tag = st0_ptr->tag;
  521.       switch ( type_table[(int) instr_index] )
  522.     {
  523.     case _NONE_:   /* also _REGIc: _REGIn */
  524.       break;
  525.     case _REG0_:
  526.       if ( !NOT_EMPTY_ST0 )
  527.         {
  528.           stack_underflow();
  529.           goto FPU_instruction_done;
  530.         }
  531.       break;
  532.     case _REGIi:
  533.       if ( !NOT_EMPTY_ST0 || !NOT_EMPTY(FPU_rm) )
  534.         {
  535.           stack_underflow_i(FPU_rm);
  536.           goto FPU_instruction_done;
  537.         }
  538.       break;
  539.     case _REGIp:
  540.       if ( !NOT_EMPTY_ST0 || !NOT_EMPTY(FPU_rm) )
  541.         {
  542.           stack_underflow_pop(FPU_rm);
  543.           goto FPU_instruction_done;
  544.         }
  545.       break;
  546.     case _REGI_:
  547.       if ( !NOT_EMPTY_ST0 || !NOT_EMPTY(FPU_rm) )
  548.         {
  549.           stack_underflow();
  550.           goto FPU_instruction_done;
  551.         }
  552.       break;
  553.     case _PUSH_:     /* Only used by the fld st(i) instruction */
  554.       break;
  555.     case _null_:
  556.       FPU_illegal();
  557.       goto FPU_instruction_done;
  558.     default:
  559.       EXCEPTION(EX_INTERNAL|0x111);
  560.       goto FPU_instruction_done;
  561.     }
  562.       (*st_instr_table[(int) instr_index])();
  563.  
  564. FPU_instruction_done:
  565.       ;
  566.     }
  567.  
  568.   if ( ! no_ip_update )
  569.     instruction_address = entry_sel_off;
  570.  
  571. FPU_fwait_done:
  572.  
  573. #ifdef DEBUG
  574.   RE_ENTRANT_CHECK_OFF;
  575.   emu_printall();
  576.   RE_ENTRANT_CHECK_ON;
  577. #endif DEBUG
  578.  
  579.   if (FPU_lookahead && !need_resched)
  580.     {
  581.       FPU_ORIG_EIP = FPU_EIP - code_base;
  582.       if ( valid_prefix(&byte1, (unsigned char **)&FPU_EIP,
  583.             &addr_modes.override) )
  584.     goto do_another_FPU_instruction;
  585.     }
  586.  
  587.   if ( addr_modes.default_mode )
  588.     FPU_EIP -= code_base;
  589.  
  590.   RE_ENTRANT_CHECK_OFF;
  591. }
  592.  
  593.  
  594. /* Support for prefix bytes is not yet complete. To properly handle
  595.    all prefix bytes, further changes are needed in the emulator code
  596.    which accesses user address space. Access to separate segments is
  597.    important for msdos emulation. */
  598. static int valid_prefix(unsigned char *Byte, unsigned char **fpu_eip,
  599.             overrides *override)
  600. {
  601.   unsigned char byte;
  602.   unsigned char *ip = *fpu_eip;
  603.  
  604.   *override = (overrides) { 0, 0, PREFIX_DEFAULT };       /* defaults */
  605.  
  606.   RE_ENTRANT_CHECK_OFF;
  607.   FPU_code_verify_area(1);
  608.   byte = get_fs_byte(ip);
  609.   RE_ENTRANT_CHECK_ON;
  610.  
  611.   while ( 1 )
  612.     {
  613.       switch ( byte )
  614.     {
  615.     case ADDR_SIZE_PREFIX:
  616.       override->address_size = ADDR_SIZE_PREFIX;
  617.       goto do_next_byte;
  618.  
  619.     case OP_SIZE_PREFIX:
  620.       override->operand_size = OP_SIZE_PREFIX;
  621.       goto do_next_byte;
  622.  
  623.     case PREFIX_CS:
  624.       override->segment = PREFIX_CS_;
  625.       goto do_next_byte;
  626.     case PREFIX_ES:
  627.       override->segment = PREFIX_ES_;
  628.       goto do_next_byte;
  629.     case PREFIX_SS:
  630.       override->segment = PREFIX_SS_;
  631.       goto do_next_byte;
  632.     case PREFIX_FS:
  633.       override->segment = PREFIX_FS_;
  634.       goto do_next_byte;
  635.     case PREFIX_GS:
  636.       override->segment = PREFIX_GS_;
  637.       goto do_next_byte;
  638.     case PREFIX_DS:
  639.       override->segment = PREFIX_DS_;
  640.       goto do_next_byte;
  641.  
  642. /* lock is not a valid prefix for FPU instructions,
  643.    let the cpu handle it to generate a SIGILL. */
  644. /*    case PREFIX_LOCK: */
  645.  
  646.       /* rep.. prefixes have no meaning for FPU instructions */
  647.     case PREFIX_REPE:
  648.     case PREFIX_REPNE:
  649.  
  650.     do_next_byte:
  651.       ip++;
  652.       RE_ENTRANT_CHECK_OFF;
  653.       FPU_code_verify_area(1);
  654.       byte = get_fs_byte(ip);
  655.       RE_ENTRANT_CHECK_ON;
  656.       break;
  657.     case FWAIT_OPCODE:
  658.       *Byte = byte;
  659.       return 1;
  660.     default:
  661.       if ( (byte & 0xf8) == 0xd8 )
  662.         {
  663.           *Byte = byte;
  664.           *fpu_eip = ip;
  665.           return 1;
  666.         }
  667.       else
  668.         {
  669.           /* Not a valid sequence of prefix bytes followed by
  670.          an FPU instruction. */
  671.           *Byte = byte;  /* Needed for error message. */
  672.           return 0;
  673.         }
  674.     }
  675.     }
  676. }
  677.  
  678.  
  679. void math_abort(struct info * info, unsigned int signal)
  680. {
  681.     FPU_EIP = FPU_ORIG_EIP;
  682.     current->tss.trap_no = 16;
  683.     current->tss.error_code = 0;
  684.     send_sig(signal,current,1);
  685.     RE_ENTRANT_CHECK_OFF;
  686.     __asm__("movl %0,%%esp ; ret": :"g" (((long) info)-4));
  687. #ifdef PARANOID
  688.       printk("ERROR: wm-FPU-emu math_abort failed!\n");
  689. #endif PARANOID
  690. }
  691.