11.1 Coprocessing

• ET bit of control register zero (CR0)
• The EM, and MP bits of CR0
• The ESC instructions
• The WAIT instruction
• The TS bit of CR0
• Exceptions

11.1.1 Coprocessor Identification

11.1.2 ESC and WAIT Instructions

• Tests the emulation mode (EM) flag to determine whether coprocessor functions are being emulated by software.
• Tests the TS flag to determine whether there has been a context change since the last ESC instruction.
• For some ESC instructions, tests the ERROR# pin to determine whether the coprocessor detected an error in the previous ESC instruction.

• Waits until the coprocessor no longer asserts the BUSY# pin.
• Tests the ERROR# pin (after BUSY# goes inactive). If ERROR# is active, the 80386 signals exception 16, which indicates that the coprocessor encountered an error in the previous ESC instruction.
• WAIT can therefore be used to cause exception 16 if an error is pending from a previous ESC instruction. Note that, if no coprocessor is present, the ERROR# and BUSY# pins should be tied inactive to prevent WAIT from waiting forever or causing spurious exceptions.

11.1.3 EM and MP Flags

The EM bit indicates whether coprocessor functions are to be emulated. If the processor finds EM set when executing an ESC instruction, it signals exception 7, giving the exception handler an opportunity to emulate the ESC instruction.

The MP (monitor coprocessor) bit indicates whether a coprocessor is actually attached. The MP flag controls the function of the WAIT instruction. If, when executing a WAIT instruction, the CPU finds MP set, then it tests the TS flag; it does not otherwise test TS during a WAIT instruction. If it finds TS set under these conditions, the CPU signals exception 7.

The EM and MP flags can be changed with the aid of a MOV instruction using CR0 as the destination operand and read with the aid of a MOV instruction with CR0 as the source operand. These forms of the MOV instruction can be executed only at privilege level zero.

11.1.4 The Task-Switched Flag

The CLTS instruction (legal only at privilege level zero) resets the TS flag.

11.1.5 Coprocessor Exceptions

11.1.5.1 Interrupt 7 -- Coprocessor Not Available

1. The CPU encounters an ESC instruction and EM is set. In this case, the exception handler should emulate the instruction that caused the exception. TS may also be set.
2. The CPU encounters either the WAIT instruction or an ESC instruction when both MP and TS are set. In this case, the exception handler should update the state of the coprocessor, if necessary.

11.1.5.2 Interrupt 9 -- Coprocessor Segment Overrun

This exception occurs in protected mode under the following conditions:
• An operand of a coprocessor instruction wraps around an addressing limit (0FFFFH for small segments, 0FFFFFFFFH for big segments, zero for expand-down segments). An operand may wrap around an addressing limit when the segment limit is near an addressing limit and the operand is near the largest valid address in the segment. Because of the wrap-around, the beginning and ending addresses of such an operand will be near opposite ends of the segment.
• Both the first byte and the last byte of the operand (considering wrap-around) are at addresses located in the segment and in present and accessible pages.
• The operand spans inaccessible addresses. There are two ways that such an operand may also span inaccessible addresses:
  1. The segment limit is not equal to the addressing limit (e.g., addressing limit is FFFFH and segment limit is FFFDH); therefore, the operand will span addresses that are not within the segment (e.g., an 8-byte operand that starts at valid offset FFFC will span addresses FFFC-FFFF and 0000-0003; however, addresses FFFE and FFFF are not valid, because they exceed the limit);
  2. The operand begins and ends in present and accessible pages but intermediate bytes of the operand fall either in a not-present page or in a page to which the current procedure does not have access rights.

Case 2 can be avoided by either aligning all segments on page boundaries or by not starting them within 108 bytes of the start or end of a page. (The maximum size of a coprocessor operand is 108 bytes.) Case 1 can be avoided by making sure that the gap between the last valid offset and the first valid offset of a segment is either no less than 108 bytes or is zero (i.e., the segment is of full size). If neither software system design constraint is acceptable, the exception handler should execute FNINIT and should probably terminate the task.

11.1.5.3 Interrupt 16 -- Coprocessor Error

up: Chapter 11 -- Coprocessing and Multiprocessing
prev: Chapter 11 -- Coprocessing and Multiprocessing
next: 11.2 General Multiprocessing