/* * linux/kernel/math/math_emulate.c * * (C) 1991 Linus Torvalds *//* * Limited emulation 27.12.91 - mostly loads/stores, which gcc wants * even for soft-float, unless you use bruce evans' patches. The patches * are great, but they have to be re-applied for every version, and the * library is different for soft-float and 80387. So emulation is more * practical, even though it's slower. * * 28.12.91 - loads/stores work, even BCD. I'll have to start thinking * about add/sub/mul/div. Urgel. I should find some good source, but I'll * just fake up something. * * 30.12.91 - add/sub/mul/div/com seem to work mostly. I should really * test every possible combination. *//* * This file is full of ugly macros etc: one problem was that gcc simply * didn't want to make the structures as they should be: it has to try to * align them. Sickening code, but at least I've hidden the ugly things * in this one file: the other files don't need to know about these things. * * The other files also don't care about ST(x) etc - they just get addresses * to 80-bit temporary reals, and do with them as they please. I wanted to * hide most of the 387-specific things here. */#include <signal.h>#define __ALIGNED_TEMP_REAL 1#include <linux/math_emu.h>#include <linux/kernel.h>#include <asm/segment.h>#define bswapw(x) __asm__("xchgb %%al,%%ah":"=a" (x):"0" ((short)x))#define ST(x) (*__st((x)))#define PST(x) ((const temp_real *) __st((x)))/* * We don't want these inlined - it gets too messy in the machine-code. */static void fpop(void);static void fpush(void);static void fxchg(temp_real_unaligned * a, temp_real_unaligned * b);static temp_real_unaligned * __st(int i);static void do_emu(struct info * info){	unsigned short code;	temp_real tmp;	char * address;	if (I387.cwd & I387.swd & 0x3f)		I387.swd |= 0x8000;	else		I387.swd &= 0x7fff;	ORIG_EIP = EIP;/* 0x0007 means user code space */	if (CS != 0x000F) {		printk("math_emulate: %04x:%08x\n\r",CS,EIP);		panic("Math emulation needed in kernel");	}	code = get_fs_word((unsigned short *) EIP);	bswapw(code);	code &= 0x7ff;	I387.fip = EIP;	*(unsigned short *) &I387.fcs = CS;	*(1+(unsigned short *) &I387.fcs) = code;	EIP += 2;	switch (code) {		case 0x1d0: /* fnop */			return;		case 0x1d1: case 0x1d2: case 0x1d3:		case 0x1d4: case 0x1d5: case 0x1d6: case 0x1d7:			math_abort(info,1<<(SIGILL-1));		case 0x1e0:			ST(0).exponent ^= 0x8000;			return;		case 0x1e1:			ST(0).exponent &= 0x7fff;			return;		case 0x1e2: case 0x1e3:			math_abort(info,1<<(SIGILL-1));		case 0x1e4:			ftst(PST(0));			return;		case 0x1e5:			printk("fxam not implemented\n\r");			math_abort(info,1<<(SIGILL-1));		case 0x1e6: case 0x1e7:			math_abort(info,1<<(SIGILL-1));		case 0x1e8:			fpush();			ST(0) = CONST1;			return;		case 0x1e9:			fpush();			ST(0) = CONSTL2T;			return;		case 0x1ea:			fpush();			ST(0) = CONSTL2E;			return;		case 0x1eb:			fpush();			ST(0) = CONSTPI;			return;		case 0x1ec:			fpush();			ST(0) = CONSTLG2;			return;		case 0x1ed:			fpush();			ST(0) = CONSTLN2;			return;		case 0x1ee:			fpush();			ST(0) = CONSTZ;			return;		case 0x1ef:			math_abort(info,1<<(SIGILL-1));		case 0x1f0: case 0x1f1: case 0x1f2: case 0x1f3:		case 0x1f4: case 0x1f5: case 0x1f6: case 0x1f7:		case 0x1f8: case 0x1f9: case 0x1fa: case 0x1fb:		case 0x1fc: case 0x1fd: case 0x1fe: case 0x1ff:			printk("%04x fxxx not implemented\n\r",code + 0xc800);			math_abort(info,1<<(SIGILL-1));		case 0x2e9:			fucom(PST(1),PST(0));			fpop(); fpop();			return;		case 0x3d0: case 0x3d1:			return;		case 0x3e2:			I387.swd &= 0x7f00;			return;		case 0x3e3:			I387.cwd = 0x037f;			I387.swd = 0x0000;			I387.twd = 0x0000;			return;		case 0x3e4:			return;		case 0x6d9:			fcom(PST(1),PST(0));			fpop(); fpop();			return;		case 0x7e0:			*(short *) &EAX = I387.swd;			return;	}	switch (code >> 3) {		case 0x18:			fadd(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 0x19:			fmul(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 0x1a:			fcom(PST(code & 7),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 0x1b:			fcom(PST(code & 7),&tmp);			real_to_real(&tmp,&ST(0));			fpop();			return;		case 0x1c:			real_to_real(&ST(code & 7),&tmp);			tmp.exponent ^= 0x8000;			fadd(PST(0),&tmp,&tmp);			real_to_real(&tmp,&ST(0));			return;		case 0x1d:			ST(0).exponent ^= 0x8000;			fadd(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 0x1e:			fdiv(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 0x1f:			fdiv(PST(code & 7),PST(0),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 0x38:			fpush();			ST(0) = ST((code & 7)+1);			return;		case 0x39:			fxchg(&ST(0),&ST(code & 7));			return;		case 0x3b:			ST(code & 7) = ST(0);			fpop();			return;		case 0x98:			fadd(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(code & 7));			return;		case 0x99:			fmul(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(code & 7));			return;		case 0x9a:			fcom(PST(code & 7),PST(0));			return;		case 0x9b:			fcom(PST(code & 7),PST(0));			fpop();			return;					case 0x9c:			ST(code & 7).exponent ^= 0x8000;			fadd(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(code & 7));			return;		case 0x9d:			real_to_real(&ST(0),&tmp);			tmp.exponent ^= 0x8000;			fadd(PST(code & 7),&tmp,&tmp);			real_to_real(&tmp,&ST(code & 7));			return;		case 0x9e:			fdiv(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(code & 7));			return;		case 0x9f:			fdiv(PST(code & 7),PST(0),&tmp);			real_to_real(&tmp,&ST(code & 7));			return;		case 0xb8:			printk("ffree not implemented\n\r");			math_abort(info,1<<(SIGILL-1));		case 0xb9:			fxchg(&ST(0),&ST(code & 7));			return;		case 0xba:			ST(code & 7) = ST(0);			return;		case 0xbb:			ST(code & 7) = ST(0);			fpop();			return;		case 0xbc:			fucom(PST(code & 7),PST(0));			return;		case 0xbd:			fucom(PST(code & 7),PST(0));			fpop();			return;		case 0xd8:			fadd(PST(code & 7),PST(0),&tmp);			real_to_real(&tmp,&ST(code & 7));			fpop();			return;		case 0xd9:			fmul(PST(code & 7),PST(0),&tmp);			real_to_real(&tmp,&ST(code & 7));			fpop();			return;		case 0xda:			fcom(PST(code & 7),PST(0));			fpop();			return;		case 0xdc:			ST(code & 7).exponent ^= 0x8000;			fadd(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(code & 7));			fpop();			return;		case 0xdd:			real_to_real(&ST(0),&tmp);			tmp.exponent ^= 0x8000;			fadd(PST(code & 7),&tmp,&tmp);			real_to_real(&tmp,&ST(code & 7));			fpop();			return;		case 0xde:			fdiv(PST(0),PST(code & 7),&tmp);			real_to_real(&tmp,&ST(code & 7));			fpop();			return;		case 0xdf:			fdiv(PST(code & 7),PST(0),&tmp);			real_to_real(&tmp,&ST(code & 7));			fpop();			return;		case 0xf8:			printk("ffree not implemented\n\r");			math_abort(info,1<<(SIGILL-1));			fpop();			return;		case 0xf9:			fxchg(&ST(0),&ST(code & 7));			return;		case 0xfa:		case 0xfb:			ST(code & 7) = ST(0);			fpop();			return;	}	switch ((code>>3) & 0xe7) {		case 0x22:			put_short_real(PST(0),info,code);			return;		case 0x23:			put_short_real(PST(0),info,code);			fpop();			return;		case 0x24:			address = ea(info,code);			for (code = 0 ; code < 7 ; code++) {				((long *) & I387)[code] =				   get_fs_long((unsigned long *) address);				address += 4;			}			return;		case 0x25:			address = ea(info,code);			*(unsigned short *) &I387.cwd =				get_fs_word((unsigned short *) address);			return;		case 0x26:			address = ea(info,code);			verify_area(address,28);			for (code = 0 ; code < 7 ; code++) {				put_fs_long( ((long *) & I387)[code],					(unsigned long *) address);				address += 4;			}			return;		case 0x27:			address = ea(info,code);			verify_area(address,2);			put_fs_word(I387.cwd,(short *) address);			return;		case 0x62:			put_long_int(PST(0),info,code);			return;		case 0x63:			put_long_int(PST(0),info,code);			fpop();			return;		case 0x65:			fpush();			get_temp_real(&tmp,info,code);			real_to_real(&tmp,&ST(0));			return;		case 0x67:			put_temp_real(PST(0),info,code);			fpop();			return;		case 0xa2:			put_long_real(PST(0),info,code);			return;		case 0xa3:			put_long_real(PST(0),info,code);			fpop();			return;		case 0xa4:			address = ea(info,code);			for (code = 0 ; code < 27 ; code++) {				((long *) & I387)[code] =				   get_fs_long((unsigned long *) address);				address += 4;			}			return;		case 0xa6:			address = ea(info,code);			verify_area(address,108);			for (code = 0 ; code < 27 ; code++) {				put_fs_long( ((long *) & I387)[code],					(unsigned long *) address);				address += 4;			}			I387.cwd = 0x037f;			I387.swd = 0x0000;			I387.twd = 0x0000;			return;		case 0xa7:			address = ea(info,code);			verify_area(address,2);			put_fs_word(I387.swd,(short *) address);			return;		case 0xe2:			put_short_int(PST(0),info,code);			return;		case 0xe3:			put_short_int(PST(0),info,code);			fpop();			return;		case 0xe4:			fpush();			get_BCD(&tmp,info,code);			real_to_real(&tmp,&ST(0));			return;		case 0xe5:			fpush();			get_longlong_int(&tmp,info,code);			real_to_real(&tmp,&ST(0));			return;		case 0xe6:			put_BCD(PST(0),info,code);			fpop();			return;		case 0xe7:			put_longlong_int(PST(0),info,code);			fpop();			return;	}	switch (code >> 9) {		case 0:			get_short_real(&tmp,info,code);			break;		case 1:			get_long_int(&tmp,info,code);			break;		case 2:			get_long_real(&tmp,info,code);			break;		case 4:			get_short_int(&tmp,info,code);	}	switch ((code>>3) & 0x27) {		case 0:			fadd(&tmp,PST(0),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 1:			fmul(&tmp,PST(0),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 2:			fcom(&tmp,PST(0));			return;		case 3:			fcom(&tmp,PST(0));			fpop();			return;		case 4:			tmp.exponent ^= 0x8000;			fadd(&tmp,PST(0),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 5:			ST(0).exponent ^= 0x8000;			fadd(&tmp,PST(0),&tmp);			real_to_real(&tmp,&ST(0));			return;		case 6:			fdiv(PST(0),&tmp,&tmp);			real_to_real(&tmp,&ST(0));			return;		case 7:			fdiv(&tmp,PST(0),&tmp);			real_to_real(&tmp,&ST(0));			return;	}	if ((code & 0x138) == 0x100) {			fpush();			real_to_real(&tmp,&ST(0));			return;	}	printk("Unknown math-insns: %04x:%08x %04x\n\r",CS,EIP,code);	math_abort(info,1<<(SIGFPE-1));}void math_emulate(long ___false){	if (!current->used_math) {		current->used_math = 1;		I387.cwd = 0x037f;		I387.swd = 0x0000;		I387.twd = 0x0000;	}/* &___false points to info->___orig_eip, so subtract 1 to get info */	do_emu((struct info *) ((&___false) - 1));}void __math_abort(struct info * info, unsigned int signal){	EIP = ORIG_EIP;	current->signal |= signal;	__asm__("movl %0,%%esp ; ret"::"g" ((long) info));}static void fpop(void){	unsigned long tmp;	tmp = I387.swd & 0xffffc7ff;	I387.swd += 0x00000800;	I387.swd &= 0x00003800;	I387.swd |= tmp;}static void fpush(void){	unsigned long tmp;	tmp = I387.swd & 0xffffc7ff;	I387.swd += 0x00003800;	I387.swd &= 0x00003800;	I387.swd |= tmp;}static void fxchg(temp_real_unaligned * a, temp_real_unaligned * b){	temp_real_unaligned c;	c = *a;	*a = *b;	*b = c;}static temp_real_unaligned * __st(int i){	i += I387.swd >> 11;	i &= 7;	return (temp_real_unaligned *) (i*10 + (char *)(I387.st_space));}