![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_support.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / i386|
Return to fp_support.c CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / i386 |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1992, 1993 NeXT Computer, Inc.
27: *
28: * Floating point support.
29: *
30: * HISTORY
31: *
32: * 21 June 1993 ? at NeXT
33: * Major rewrite to add special support for SoftPC.
34: * 10 September 1992 ? at NeXT
35: * Created.
36: */
37:
38: #import <mach/mach_types.h>
39: #import <mach/exception.h>
40:
41: #import <machdep/i386/cpu_inline.h>
42: #import <machdep/i386/fp_inline.h>
43: #import <machdep/i386/fp_exported.h>
44: #import <machdep/i386/configure.h>
45:
46: #import <fp_emul.h>
47: #if FP_EMUL
48: #import <machdep/i386/table_inline.h>
49: #import <machdep/i386/desc_inline.h>
50: #endif
51:
52: #import <pc_support.h>
53: #if PC_SUPPORT
54: #import <machdep/i386/pc_support/PCprivate.h>
55: #endif
56:
57: static thread_t fp_thread;
58:
59: static
60: inline void fp_init(fp_state_t *fpstate),
61: fp_init_default(fp_state_t *fpstate),
62: fp_unowned(void),
63: fp_save(void),
64: fp_restore(void);
65:
66: static void fp_switch(void);
67:
68: #import <bsd/i386/reboot.h>
69: extern int boothowto;
70:
71: /*
72: * Determine whether this machine
73: * contains a hardware FPU and configure
74: * the CPU accordingly.
75: */
76:
77: void
78: fp_configure(void)
79: {
80: cr0_t _cr0 = cr0();
81: volatile
82: unsigned short status_word;
83:
84: /*
85: * Make sure that floating
86: * point operations do not
87: * cause a trap.
88: */
89: _cr0.em = _cr0.ts = 0;
90: set_cr0(_cr0);
91:
92: /*
93: * Machines with a hardware
94: * FPU will return a status
95: * word of zero after an finit,
96: * Machines without an FPU will
97: * not modify the destination
98: * operand.
99: */
100: status_word = 0x5a5a;
101:
102: asm volatile(
103: "fninit;
104: fnstsw %0"
105: : "=m" (status_word));
106:
107: if (status_word != 0 || (boothowto&RB_NOFP) != 0) {
108: /*
109: * Either this machine
110: * does not have an FPU,
111: * or we want to test the
112: * floating point emulator.
113: * Turn on the EM bit in CR0
114: * so that all floating point
115: * opcodes cause a trap.
116: */
117: _cr0.em = 1; // cause floating point instructions to trap INT7
118: _cr0.mp = 0; // cause WAIT instructions to trap INT7
119: set_cr0(_cr0);
120: #if FP_EMUL
121: cpu_config.fpu_type = FPU_EMUL;
122: #endif
123: }
124: else {
125: _cr0.ne = 1; // cause unmasked floating point exceptions to trap INT16
126: _cr0.mp = 1;
127: set_cr0(_cr0);
128: cpu_config.fpu_type = FPU_HDW;
129: }
130: }
131:
132: /*
133: * Called on occurance of INT7 from
134: * user mode.
135: */
136:
137: void
138: fp_noextension(
139: thread_saved_state_t *state
140: )
141: {
142: if (cpu_config.fpu_type == FPU_NONE) {
143: /*
144: * If we are not providing
145: * floating point support,
146: * just send an exception.
147: */
148: exception(EXC_EMULATION, EXC_I386_NOEXTENSION, 0);
149: /* NOTREACHED */
150: }
151:
152: /*
153: * Switch the fpu context
154: * if necessary.
155: */
156: fp_switch();
157:
158: #if FP_EMUL
159: if (cpu_config.fpu_type == FPU_EMUL) {
160: /*
161: * If we are using the
162: * kernel floating point
163: * emulator, call it.
164: */
165: e80387(state);
166: }
167: #endif
168: }
169:
170: /*
171: * Called on occurance of INT16 from
172: * user mode.
173: */
174:
175: void
176: fp_extension_fault(
177: thread_saved_state_t *state
178: )
179: {
180: thread_t exception_thread = fp_thread;
181:
182: /*
183: * Stop the floating point unit
184: * dead in its tracks. We do not
185: * want another exception to occur.
186: */
187: fp_save(); // sets fp_thread = THREAD_NULL
188:
189: if (exception_thread == current_thread()) {
190: exception(EXC_ARITHMETIC, EXC_I386_EXTENSION_FAULT, 0);
191: /* NOTREACHED */
192: }
193: else
194: thread_ast_set(exception_thread, AST_FP_EXTEN);
195: }
196:
197: /*
198: * Called on occurance of INT16 from
199: * kernel mode.
200: */
201: void
202: fp_kernel_extension_fault(
203: thread_saved_state_t *state
204: )
205: {
206: thread_t exception_thread = fp_thread;
207:
208: /*
209: * Stop the floating point unit.
210: */
211: fp_save(); // sets fp_thread = THREAD_NULL
212:
213: thread_ast_set(exception_thread, AST_FP_EXTEN);
214: if (exception_thread == current_thread())
215: ast_propagate(exception_thread, cpu_number());
216: }
217:
218: void
219: fp_ast(
220: thread_t thread
221: )
222: {
223: thread_ast_clear(thread, AST_FP_EXTEN);
224:
225: exception(EXC_ARITHMETIC, EXC_I386_EXTENSION_FAULT, 0);
226: /* NOTREACHED */
227: }
228:
229: /*
230: * Initialize a saved floating point
231: * context as if an FINIT was performed.
232: * Used to initialize a context for the
233: * software emulator, as well as to
234: * initialize an unused context so that
235: * thread_get_state() returns something
236: * sensible for a thread that has not
237: * performed any floating point operations.
238: */
239:
240: /*
241: * Initialize the floating point
242: * state to the hardware default.
243: */
244: static inline
245: void
246: fp_init_default(
247: fp_state_t *fpstate
248: )
249: {
250: *(unsigned short *)&fpstate->environ.control = 0x037F;
251: *(unsigned short *)&fpstate->environ.status = 0x0000;
252: *(unsigned short *)&fpstate->environ.tag = 0xFFFF;
253:
254: fpstate->environ.ip = 0x00000000;
255: fpstate->environ.opcode = 0x0000;
256: fpstate->environ.cs = NULL_SEL;
257: fpstate->environ.dp = 0x00000000;
258: fpstate->environ.ds = NULL_SEL;
259: }
260:
261: /*
262: * Initialize the floating point
263: * state to that needed by the
264: * NEXTSTEP floating point model:
265: * double precision, round to
266: * nearest or even.
267: */
268: static inline
269: void
270: fp_init(
271: fp_state_t *fpstate
272: )
273: {
274: *(unsigned short *)&fpstate->environ.control = 0x027F;
275: *(unsigned short *)&fpstate->environ.status = 0x0000;
276: *(unsigned short *)&fpstate->environ.tag = 0xFFFF;
277:
278: fpstate->environ.ip = 0x00000000;
279: fpstate->environ.opcode = 0x0000;
280: fpstate->environ.cs = NULL_SEL;
281: fpstate->environ.dp = 0x00000000;
282: fpstate->environ.ds = NULL_SEL;
283: }
284:
285: /*
286: * Save the floating point context
287: * for the thread which owns the FPU
288: * and mark it unowned. N.B. This might
289: * not be the current thread.
290: */
291:
292: static inline
293: void
294: fp_save(void)
295: {
296: thread_t thread = fp_thread;
297:
298: if (thread) {
299: #if PC_SUPPORT
300: PCshared_t shared = threadPCShared(thread);
301:
302: if (shared && shared->fpuOwned) {
303: if (cpu_config.fpu_type == FPU_HDW)
304: fnsave(&shared->fpuState); // clears TS flag
305:
306: shared->fpuStateValid = TRUE;
307: }
308: else {
309: #endif
310: if (cpu_config.fpu_type == FPU_HDW)
311: fnsave(&thread->pcb->fpstate); // clears TS flag
312:
313: thread->pcb->fpvalid = TRUE;
314: #if PC_SUPPORT
315: }
316: #endif
317:
318: fp_unowned();
319: }
320: }
321:
322: /*
323: * Restore the floating point context of the
324: * current thread. The main assumption here
325: * is that the FPU is currently NOT owned by
326: * any thread.
327: */
328:
329: static inline
330: void
331: fp_restore(void)
332: {
333: thread_t thread = current_thread();
334: #if PC_SUPPORT
335: PCshared_t shared = threadPCShared(thread);
336:
337: if (shared) {
338: PCcontext_t context = currentContext(shared);
339:
340: if (context->running) {
341: if (shared->fpuStateValid) {
342: if (cpu_config.fpu_type == FPU_HDW)
343: frstor(&shared->fpuState); // clears TS flag
344:
345: shared->fpuStateValid = FALSE;
346: }
347: else {
348: fp_init_default(&shared->fpuState);
349:
350: if (cpu_config.fpu_type == FPU_HDW)
351: frstor(&shared->fpuState); // clears TS flag
352: }
353:
354: #if FP_EMUL
355: if (cpu_config.fpu_type == FPU_EMUL)
356: map_data(sel_to_gdt_entry(FPSTATE_SEL),
357: (vm_offset_t) &shared->fpuState
358: + KERNEL_LINEAR_BASE,
359: (vm_size_t) sizeof (shared->fpuState),
360: KERN_PRIV, FALSE);
361: #endif
362:
363: shared->fpuOwned = TRUE;
364: }
365: else {
366: shared->fpuOwned = FALSE;
367: goto restore_thread;
368: }
369: }
370: else {
371: restore_thread:
372: #endif
373: if (thread->pcb->fpvalid) {
374: if (cpu_config.fpu_type == FPU_HDW)
375: frstor(&thread->pcb->fpstate); // clears TS flag
376:
377: thread->pcb->fpvalid = FALSE;
378: }
379: else {
380: fp_init(&thread->pcb->fpstate);
381:
382: if (cpu_config.fpu_type == FPU_HDW)
383: frstor(&thread->pcb->fpstate); // clears TS flag
384: }
385:
386: #if FP_EMUL
387: if (cpu_config.fpu_type == FPU_EMUL)
388: map_data(sel_to_gdt_entry(FPSTATE_SEL),
389: (vm_offset_t) &thread->pcb->fpstate
390: + KERNEL_LINEAR_BASE,
391: (vm_size_t) sizeof (thread->pcb->fpstate),
392: KERN_PRIV, FALSE);
393: #endif
394: #if PC_SUPPORT
395: }
396: #endif
397: }
398:
399: /*
400: * Restore the floating point context
401: * of the current thread, saving the
402: * current context if necessary.
403: */
404:
405: static
406: void
407: fp_switch(void)
408: {
409: thread_t thread = current_thread();
410:
411: if (thread == fp_thread) {
412: #if PC_SUPPORT
413: PCshared_t shared = threadPCShared(thread);
414:
415: if (shared) {
416: PCcontext_t context = currentContext(shared);
417:
418: if (context->running) {
419: if (!shared->fpuOwned) {
420: if (cpu_config.fpu_type == FPU_HDW)
421: fnsave(&thread->pcb->fpstate); // clears TS flag
422:
423: thread->pcb->fpvalid = TRUE;
424:
425: if (shared->fpuStateValid) {
426: if (cpu_config.fpu_type == FPU_HDW)
427: frstor(&shared->fpuState); // clears TS flag
428:
429: shared->fpuStateValid = FALSE;
430: }
431: else {
432: fp_init_default(&shared->fpuState);
433:
434: if (cpu_config.fpu_type == FPU_HDW)
435: frstor(&shared->fpuState); // clears TS flag
436: }
437:
438: #if FP_EMUL
439: if (cpu_config.fpu_type == FPU_EMUL)
440: map_data(sel_to_gdt_entry(FPSTATE_SEL),
441: (vm_offset_t) &shared->fpuState
442: + KERNEL_LINEAR_BASE,
443: (vm_size_t) sizeof (shared->fpuState),
444: KERN_PRIV, FALSE);
445: #endif
446:
447: shared->fpuOwned = TRUE;
448: }
449: }
450: else {
451: if (shared->fpuOwned) {
452: if (cpu_config.fpu_type == FPU_HDW)
453: fnsave(&shared->fpuState); // clears TS flag
454:
455: shared->fpuStateValid = TRUE;
456:
457: if (thread->pcb->fpvalid) {
458: if (cpu_config.fpu_type == FPU_HDW)
459: frstor(&thread->pcb->fpstate);// clears TS flag
460:
461: thread->pcb->fpvalid = FALSE;
462: }
463: else {
464: fp_init(&thread->pcb->fpstate);
465:
466: if (cpu_config.fpu_type == FPU_HDW)
467: frstor(&thread->pcb->fpstate);// clears TS flag
468: }
469:
470: #if FP_EMUL
471: if (cpu_config.fpu_type == FPU_EMUL)
472: map_data(sel_to_gdt_entry(FPSTATE_SEL),
473: (vm_offset_t) &thread->pcb->fpstate
474: + KERNEL_LINEAR_BASE,
475: (vm_size_t)
476: sizeof (thread->pcb->fpstate),
477: KERN_PRIV, FALSE);
478: #endif
479:
480: shared->fpuOwned = FALSE;
481: }
482: }
483: }
484: #endif
485: }
486: else {
487: fp_save(); fp_thread = thread; fp_restore();
488: }
489:
490: clts(); // make sure that the TS flag is cleared
491: }
492:
493: /*
494: * Mark the FPU as currently
495: * unowned.
496: */
497:
498: static inline
499: void
500: fp_unowned(void)
501: {
502: fp_thread = THREAD_NULL;
503: setts();
504: }
505:
506: /*
507: * Mark the FPU unowned if the
508: * thread currently owns it. The
509: * context is discarded.
510: */
511:
512: void
513: fp_terminate(
514: thread_t thread
515: )
516: {
517: if (thread == fp_thread)
518: fp_unowned();
519: }
520:
521: /*
522: * Update the saved floating point
523: * context of the thread if necessary.
524: * Perform a software FINIT if the
525: * thread has not performed any floating
526: * point operations yet.
527: */
528:
529: void
530: fp_synch(
531: thread_t thread
532: )
533: {
534: if (thread == fp_thread)
535: fp_save();
536: else {
537: if (!thread->pcb->fpvalid)
538: fp_init(&thread->pcb->fpstate);
539: }
540: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.