ifpsp060/src/fpsp.S

549 set fmovm_flg,		0x40			# flag bit: fmovm instruction
586 #	_imem_read_long() - read instruction longword			#
592 #	fout() - emulate an opclass 3 instruction			#
613 # instruction, the 060 will take an overflow exception whether the	#
615 # This handler emulates the instruction to determine what the correct	#
622 # the default result (only if the instruction is opclass 3). For	#
630 #	Also, in the case of an opclass three instruction where		#
649 # the FPIAR holds the "current PC" of the faulting instruction
651 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
652 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
653 	bsr.l		_imem_read_long		# fetch the instruction words
826 #	_imem_read_long() - read instruction longword			#
832 #	fout() - emulate an opclass 3 instruction			#
853 # instruction, the 060 will take an underflow exception whether the	#
855 # This handler emulates the instruction to determine what the correct	#
862 # the default result (only if the instruction is opclass 3). For	#
870 #	Also, in the case of an opclass three instruction where		#
889 # the FPIAR holds the "current PC" of the faulting instruction
891 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
892 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
893 	bsr.l		_imem_read_long		# fetch the instruction words
1101 #	_imem_read_{word,long}() - read instruction word/longword	#
1108 #	fout() - emulate an opclass 3 instruction			#
1141 #	Two main instruction types can enter here: (1) DENORM or UNNORM	#
1147 # from the FP register file. The instruction is then emulated by	#
1149 # instruction type. Once the instruction has been emulated and result	#
1151 # instruction emulation. If none, then we exit through the "callout"	#
1155 #	PACKED opclass 0 and 2 is similar in how the instruction is	#
1177 #				post-instruction
1180 #	 pre-instruction	*		*
1229 # the FPIAR holds the "current PC" of the faulting instruction
1233 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
1234 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
1235 	bsr.l		_imem_read_long		# fetch the instruction words
1253 # I'm not sure at this point what FPSR bits are valid for this instruction.
1507 # I'm not sure at this point what FPSR bits are valid for this instruction.
1723 # three instruction exceptions don't update the stack pointer. so, if the
1809 # I'm not sure at this point what FPSR bits are valid for this instruction.
2039 # The opclass two PACKED instruction that took an "Unimplemented Data Type"
2066 # I'm not sure at this point what FPSR bits are valid for this instruction.
2186 # the instruction was "fmove.p fpn,-(a7)" from supervisor mode.
2226 # the instruction was "fmove.p fpn,-(a7)" from supervisor mode.
2266 # the instruction was "fmove.p fpn,-(a7)" from supervisor mode.
2372 #	_imem_read_long() - read instruction longword			#
2385 #	fmovm_dynamic() - emulate dynamic fmovm instruction		#
2386 #	fmovm_ctrl() - emulate fmovm control instruction		#
2405 # (2) The "fmovm.x" instruction w/ dynamic register specification.	#
2406 # (3) The "fmovm.l" instruction w/ 2 or 3 control registers.		#
2410 # as the source operand to the instruction specified by the instruction	#
2422 # decode and emulate the instruction. No FP exceptions can be pending	#
2426 # For the case of "fmovm.x Dn,-(a7)", where the offending instruction	#
2431 #	For "fmovm.l", fmovm_ctrl() is used to emulate the instruction.	#
2441 # reproducing the effective address of the instruction to put on the	#
2470 # PC of instruction that took the exception is the PC in the frame
2473 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
2474 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
2475 	bsr.l		_imem_read_long		# fetch the instruction words
2711 # The opclass two instruction that took an "Unimplemented Effective Address"
2912 # The control reg instruction that took an "Unimplemented Effective Address"
2947 # the faulting instruction to get the "next PC". This is trivial for
2957 # PC of instruction that took the exception is the PC in the frame
2959 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
2960 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
2961 	bsr.l		_imem_read_long		# fetch the instruction words
2966 # instruction is using an extended precision immediate operand. Therefore,
2967 # the total instruction length is 16 bytes.
2969 	mov.l		&0x10,%d0		# 16 bytes of instruction
2974 # the instruction is a fmovm.l with 2 or 3 registers.
2981 # the instruction is an fmovm.x dynamic which can use many addressing
2982 # modes and thus can have several different total instruction lengths.
2984 # as a by-product, will tell us how long the instruction is.
3072 #	_imem_read_long() - read instruction longword			#
3091 # for opclass zero and two instruction taking this exception, the	#
3117 # the FPIAR holds the "current PC" of the faulting instruction
3120 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
3121 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
3122 	bsr.l		_imem_read_long		# fetch the instruction words
3261 #	_imem_read_long() - read instruction longword			#
3293 #	For the case of an extended precision opclass 3 instruction,	#
3313 # the FPIAR holds the "current PC" of the faulting instruction
3316 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
3317 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
3318 	bsr.l		_imem_read_long		# fetch the instruction words
3560 #	_imem_read_long() - read instruction longword			#
3566 #	smovcr() - emulate an "fmovcr" instruction			#
3567 #	fout() - emulate an opclass 3 instruction			#
3582 # for opclass zero and two instruction taking this exception, the	#
3585 # instruction in order to get this value and then store it to the	#
3605 # the FPIAR holds the "current PC" of the faulting instruction
3608 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
3609 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
3610 	bsr.l		_imem_read_long		# fetch the instruction words
3636 # emulate the whole instruction. Notice, though, that we don't kill the
3746 #	_imem_read_long() - read instruction longword from memory	#
3779 # the FPIAR holds the "current PC" of the faulting instruction
3782 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
3783 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
3784 	bsr.l		_imem_read_long		# fetch the instruction words
3817 #	_imem_read_long() - read instruction longword			#
3829 #	(1) FPU unimplemented instruction (6 word stack frame)		#
3857 # if the F-Line instruction is an "fmovecr" w/ a non-zero <ea>. if
3866 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
3867 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
3868 	bsr.l		_imem_read_long		# fetch instruction words
3933 #	_imem_read_{word,long}() - read instruction word/longword	#
3940 #	smovcr() - emulate "fmovecr" instruction			#
3942 #	_ftrapcc() - emulate an "ftrapcc" instruction			#
3943 #	_fdbcc() - emulate an "fdbcc" instruction			#
3944 #	_fscc() - emulate an "fscc" instruction				#
3965 # for instruction emulation. The correct emulation routine is then	#
3966 # chosen by decoding the instruction type and indexing into an		#
3969 # FP instruction emulation. If so, then an FP exception of the correct	#
3971 # instruction before exiting through _fpsp_done(). In either the	#
3981 # instruction was "ftrapcc" and a Trap exception should result, a Trap	#
4043 # the FPIAR holds the "current PC" of the faulting instruction.
4046 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
4047 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
4048 	bsr.l		_imem_read_long		# fetch the instruction words
4143 # if the instruction was executed from supervisor mode and the addressing
4241 # restored into the machine for the instruction just emulated.
4296 # the ftrapcc instruction should take a trap. so, here we must create a
4297 # trap stack frame from an unimplemented fp instruction stack frame and
4315 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
4316 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
4338 # I am assuming here that an "fs<cc>.b -(An)" or "fs<cc>.b (An)+" instruction
4357 # remember, also, this instruction may be traced.
4387 # the fp unimplemented instruction exception stack frame into a bsun stack frame,
4454 # the fscc instruction should take a trace trap. so, here we must create a
4455 # trace stack frame from an unimplemented fp instruction stack frame and
4974 # the instruction fetch access for the displacement word for the
6943 #		Note also that we use the FMOVEM instruction to move X	#
10413 #	a0   : points to result (in instruction memory)			#
10990 # routines where an instruction is selected by an index into
10991 # a large jump table corresponding to a given instruction which
11338 #	fmul() - emulate a multiply instruction				#
11339 #	fadd() - emulate an add instruction				#
11340 #	fin() - emulate an fmove instruction				#
11344 #	d0  = type of instruction that took exception			#
11352 #	An exception occurred on the last instruction of the		#
11523 #	fmul(): emulates the fmul instruction				#
11524 #	fsmul(): emulates the fsmul instruction				#
11525 #	fdmul(): emulates the fdmul instruction				#
11548 # instruction won't cause an exception. Use the regular fmul to		#
12019 #	fin(): emulates the fmove instruction				#
12020 #	fsin(): emulates the fsmove instruction				#
12021 #	fdin(): emulates the fdmove instruction				#
12042 #	Norms can be emulated w/ a regular fmove instruction. For	#
12340 #	fdiv(): emulates the fdiv instruction				#
12341 #	fsdiv(): emulates the fsdiv instruction				#
12342 #	fddiv(): emulates the fddiv instruction				#
12365 # instruction won't cause an exception. Use the regular fdiv to		#
12794 #	fneg(): emulates the fneg instruction				#
12795 #	fsneg(): emulates the fsneg instruction				#
12796 #	fdneg(): emulates the fdneg instruction				#
13120 #	ftst(): emulates the ftest instruction				#
13123 #	res{s,q}nan_1op() - set NAN result for monadic instruction	#
13205 #	fint(): emulates the fint instruction				#
13311 #	fintrz(): emulates the fintrz instruction			#
13413 #	fabs():  emulates the fabs instruction				#
13414 #	fsabs(): emulates the fsabs instruction				#
13415 #	fdabs(): emulates the fdabs instruction				#
13751 # just use the actual fcmp instruction to produce the correct condition	#
13927 #	fsglmul(): emulates the fsglmul instruction			#
13950 # instruction won't cause an exception. Use the regular fsglmul to	#
14268 #	fsgldiv(): emulates the fsgldiv instruction			#
14291 # instruction won't cause an exception. Use the regular fsgldiv to	#
14603 #	fadd(): emulates the fadd instruction				#
14604 #	fsadd(): emulates the fadd instruction				#
14605 #	fdadd(): emulates the fdadd instruction				#
15056 #	fsub(): emulates the fsub instruction				#
15057 #	fssub(): emulates the fssub instruction				#
15058 #	fdsub(): emulates the fdsub instruction				#
15502 #	fsqrt(): emulates the fsqrt instruction				#
15503 #	fssqrt(): emulates the fssqrt instruction			#
15504 #	fdsqrt(): emulates the fdsqrt instruction			#
15525 # instruction won't cause an exception. Use the regular fsqrt to	#
16248 # fdbcc(): routine to emulate the fdbcc instruction			#
16265 # the stacked fdbcc instruction opcode and then branches to a routine	#
16266 # for that predicate. The corresponding fbcc instruction is then used	#
16843 #	pc = pc of next instruction
16864 	add.l		USER_FPIAR(%a6),%d0	# add instruction PC
16865 	addq.l		&0x4,%d0		# add instruction length
16878 # ftrapcc(): routine to emulate the ftrapcc instruction			#
16894 # the stacked ftrapcc instruction opcode and then branches to a routine	#
16895 # for that predicate. The corresponding fbcc instruction is then used	#
17430 # is the same size as that of the fp unimp instruction. the
17432 # of the ftrapcc instruction and the vector offset field
17447 # fscc(): routine to emulate the fscc instruction			#
17466 # the stacked fscc instruction opcode and then branches to a routine	#
17467 # for that predicate. The corresponding fbcc instruction is then used	#
18150 #	fmovm_dynamic(): emulate "fmovm" dynamic instruction		#
18156 #	iea_iacc() - instruction memory access error occurred		#
18167 #	Else if instruction access error,				#
18185 #	If the instruction is "fmovm.x <ea>,Dn", a _mem_read() is used	#
18188 #	If the instruction is "fmovm.x DN,<ea>", a _mem_write() is used	#
18190 #	If the instruction is "fmovm.x DN,-(a7)" from supervisor mode,	#
18211 #	instruction is a nop.						#
18781 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18782 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18794 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18795 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18807 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18808 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18820 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18821 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18833 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18834 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18846 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18847 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18859 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18860 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18872 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18873 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18895 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18896 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18940 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18941 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18954 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18955 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
18968 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18969 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
18990 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
18991 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
19083 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19084 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19093 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19094 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
19114 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19115 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19124 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19125 	addq.l		&0x2,EXC_EXTWPTR(%a6)	# incr instruction ptr
19216 #	Decode the instruction type by looking at the extension word	#
19247 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19248 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19255 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19256 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19267 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19268 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19275 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19276 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19287 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19288 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19295 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19296 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19307 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19308 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19315 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19316 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19323 	mov.l		EXC_EXTWPTR(%a6),%a0	# fetch instruction addr
19324 	addq.l		&0x4,EXC_EXTWPTR(%a6)	# incr instruction ptr
19569 #	_imem_read_{word,long}() - read from instruction memory		#
19586 # FP_SRC(a6) and FP_DST(a6). If the instruction was opclass zero, load	#
19590 #	If the instruction is opclass two (memory->reg), then fetch	#
19602 # instruction bit set.							#
19612 # | opclass | RX  | RY | EXTENSION |  (2nd word of general FP instruction)
20178 #	Decode an fmove out (opclass 3) instruction to determine if	#
20189 #	For packed, the k-factor must be fetched from the instruction	#
21343 #	Typically used for an instruction w/ a post-increment <ea>,	#
21407 #	Typically used for an instruction w/ a pre-decrement <ea>,	#
24715 # instruction value. but since we're exiting to the access error
24716 # handler, then AN must be returned to its pre-instruction value.
24765 # if it's a fmove out instruction, we don't have to fix a7
24767 # instruction (data moved in) and the exception was in supervisor