Lines Matching refs:AN
13 # THE SOFTWARE is provided on an "AS IS" basis and without warranty.
400 set FTEMP, 0 # offsets within an
407 set LOCAL, 0 # offsets within an
414 set DST, 0 # offsets within an
419 set SRC, 0 # offsets within an
592 # FP Overflow exception in an operating system. #
601 # fout() - emulate an opclass 3 instruction #
621 # On the 060, if an FP overflow is present as the result of any #
622 # instruction, the 060 will take an overflow exception whether the #
639 # Also, in the case of an opclass three instruction where #
667 btst &0x5,EXC_CMDREG(%a6) # is instr an fmove out?
691 cmpi.b %d0,&UNNORM # is operand an UNNORM?
725 # the EXOP, if an exception occurred, is in fp1.
832 # FP Underflow exception in an operating system. #
841 # fout() - emulate an opclass 3 instruction #
861 # On the 060, if an FP underflow is present as the result of any #
862 # instruction, the 060 will take an underflow exception whether the #
879 # Also, in the case of an opclass three instruction where #
907 btst &0x5,EXC_CMDREG(%a6) # is instr an fmove out?
926 btst &0x4,1+EXC_CMDREG(%a6) # is op an fsincos?
934 cmpi.b %d0,&UNNORM # is operand an UNNORM?
972 # (0x00000000_80000000_00000000), then the machine will take an
1005 # (0x00000000_80000000_00000000), then the machine will take an
1033 # (0x00000000_80000000_00000000), then the machine will take an
1107 # FP Unimplemented Data Type exception in an operating system. #
1117 # fout() - emulate an opclass 3 instruction #
1135 # - The system stack is changed to an Inexact exception stk frame #
1137 # - The system stack is changed to an SNAN exception stk frame #
1139 # - The system stack is changed to an OPERR exception stk frame #
1141 # - The system stack is changed to an OVFL exception stk frame #
1143 # - The system stack is changed to an UNFL exception stack frame #
1157 # choosing an emulation routine from a table of routines indexed by #
1161 # _fpsp_done(). If there is an enabled FP exception, then we insert #
1169 # frame is changed to a Trace exception stack frame and an exit is #
1173 # as the result of emulation, then an exit either occurs through #
1175 # (a Trace stack frame must be created here, too). If an FP exception #
1176 # should occur, then we must create an exception stack frame of that #
1229 # if the exception is an opclass zero or two unimplemented data type
1231 # stack an ea. however, we don't need an a7' for this case anyways.
1253 btst &0x5,EXC_CMDREG(%a6) # is it an fmove out?
1269 # Opclass two w/ memory-to-fpn operation will have an incorrect extended
1271 # source data type was an INF, NAN, DENORM, or UNNORM
1277 # input is an UNNORM, then convert it to a NORM, DENORM, or ZERO.
1280 cmpi.b %d0,&UNNORM # is operand an UNNORM?
1293 cmpi.b 1+EXC_CMDREG(%a6),&0x3a # is operation an ftst?
1300 cmpi.b %d0,&UNNORM # is operand an UNNORM?
1379 # An exception occurred and that exception was enabled:
1503 # fmove out took an unimplemented data type exception.
1524 # the src can ONLY be a DENORM or an UNNORM! so, don't make any big subroutine
1663 # an exception occurred and that exception was enabled.
1838 cmpi.b 1+EXC_CMDREG(%a6),&0x3a # is operation an ftst?
1845 cmpi.b %d0,&UNNORM # is operand an UNNORM?
1957 # An exception occurred and that exception was enabled:
2048 # The opclass two PACKED instruction that took an "Unimplemented Data Type"
2090 cmpi.b %d0,&UNNORM # is operand an UNNORM?
2176 # an exception occurred and that exception was enabled.
2306 # if we're stuffing a source operand back into an fsave frame then we
2377 # FP Unimplemented Effective Address exception in an operating #
2402 # - The system stack is changed to an access error stack frame #
2404 # - The system stack is changed to an FPU disabled stack frame #
2422 # the handler exits through _fpsp_done(). If an enabled exc has been #
2423 # signalled as a result of emulation, then an fsave state frame #
2434 # to a Trace stack frame and an exit made through _real_trace(). #
2441 # Again, a Trace exception may be pending and an exit made through #
2448 # then we must create an 8 word "FPU disabled" exception stack frame #
2454 # "callout" returns a failing result indicating an access error, then #
2455 # we must create an access error stack frame from the current stack #
2538 # The packed operand is an INF or a NAN if the exponent field is all ones.
2541 beq.b iea_op_setsrc # operand is an INF or NAN
2564 cmpi.b %d0,&UNNORM # is operand an UNNORM?
2583 cmpi.b %d0,&UNNORM # is operand an UNNORM?
2663 # enabled? if so, then we have to stuff an overflow frame into the FPU.
2672 # an enabled exception occurred. we have to insert the exception type back into
2679 # the enabled exception was inexact. so, if it occurs with an overflow
2680 # or underflow that was disabled, then we have to force an overflow or
2720 # The opclass two instruction that took an "Unimplemented Effective Address"
2921 # The control reg instruction that took an "Unimplemented Effective Address"
2954 # F Emulator" exception. So, here we create an 8-word stack frame
2975 # instruction is using an extended precision immediate operand. therefore,
2990 # the instruction is an fmovm.x dynamic which can use many addressing
3078 # FP Operand Error exception in an operating system. #
3110 # which creates an access error stack frame from the current operr #
3136 btst &13,%d0 # is instr an fmove out?
3143 # cause an operr so we don't need to check for them here.
3180 # the operand is either an infinity or a QNAN.
3267 # FP Signalling NAN exception in an operating system. #
3276 # _calc_ea_fout() - fix An if <ea> is -() or ()+; also get <ea> #
3300 # which creates an access error stack frame from the current SNAN #
3302 # For the case of an extended precision opclass 3 instruction, #
3332 btst &13,%d0 # is instr an fmove out?
3510 bsr.l _calc_ea_fout # find the correct ea,update An
3531 bsr.l _calc_ea_fout # find the correct ea,update An
3566 # FP Inexact exception in an operating system. #
3575 # smovcr() - emulate an "fmovcr" instruction #
3576 # fout() - emulate an opclass 3 instruction #
3624 btst &13,%d0 # is instr an fmove out?
3630 # w/ an exponent value of 0x401e. we convert this to extended precision here.
3655 cmpi.b %d1,&0x17 # is op an fmovecr?
3668 btst &0x4,1+EXC_CMDREG(%a6) # is operation an fsincos?
3676 cmpi.b %d0,&UNNORM # is operand an UNNORM?
3752 # the FP DZ exception in an operating system. #
3820 # "Line F Emulator" exception in an operating system. #
3865 # the exception was an "F-Line Illegal" exception. we check to see
3866 # if the F-Line instruction is an "fmovecr" w/ a non-zero <ea>. if
3867 # so, convert the F-Line exception stack frame to an FP Unimplemented
3879 bfextu %d0{&0:&10},%d1 # is it an fmovecr?
3883 bfextu %d0{&16:&6},%d1 # is it an fmovecr?
3887 # it's an fmovecr w/ a non-zero <ea> that has entered through
3889 # so, we need to convert the F-Line exception stack frame into an
3939 # FP Unimplemented Instruction exception in an operating system. #
3951 # _ftrapcc() - emulate an "ftrapcc" instruction #
3952 # _fdbcc() - emulate an "fdbcc" instruction #
3953 # _fscc() - emulate an "fscc" instruction #
3962 # - The system stack is changed to an access error stack frame #
3975 # chosen by decoding the instruction type and indexing into an #
3977 # handler checks to see if an exception should occur as a result of the #
3978 # FP instruction emulation. If so, then an FP exception of the correct #
3989 # stack frame and an exit is made through _real_bsun(). If the #
3991 # exception stack frame is created from the current frame and an exit #
3998 # "callout" returns a failing value, then an access error stack frame #
3999 # is created from the current stack frame and an exit is made through #
4022 # machine encounters an fp unimp exception. Therefore, it must be set
4085 cmpi.b %d1,&0x17 # is op an fmovecr?
4132 # this catches a problem with the case where an exception will be re-inserted
4134 # alone of the control register would trigger an unwanted exception.
4189 # was an exception set that was also enabled?
4194 # no exception that was enabled was set BUT if we got an exact overflow
4196 # an inexact exception; otherwise, return to normal non-exception flow.
4213 # the enabled exception was inexact. so, if it occurs with an overflow
4214 # or underflow that was disabled, then we have to force an overflow or
4216 # it's actually an inexact and act appropriately. this is the only easy
4224 # force the fsave exception status bits to signal an exception of the
4238 # insert an overflow frame
4244 # insert an underflow frame
4249 # this is the general exit point for an enabled exception that will be
4270 cmpi.b %d1,&0x1 # is it an fdb<cc>?
4272 cmpi.b %d1,&0x7 # is it an fs<cc>?
4275 cmpi.b %d1,&0x2 # is it an fs<cc>?
4306 # trap stack frame from an unimplemented fp instruction stack frame and
4347 # I am assuming here that an "fs<cc>.b -(An)" or "fs<cc>.b (An)+" instruction
4348 # does not need to update "An" before taking a bsun exception.
4362 # overwritten by the "fs<cc> -(An)". We must shift the stack frame "down"
4395 # The ftrap<cc>, fs<cc>, or fdb<cc> is to take an enabled bsun. we must convert
4464 # trace stack frame from an unimplemented fp instruction stack frame and
4984 # fdbcc emulation failed. here, we create an access error frame
5047 # Return sgn*cos(r) where cos(r) is approximated by an #
5053 # where sin(r) is approximated by an odd polynomial in r #
6184 # Step 6. Approximate arctan(X) by an odd polynomial in X. Exit. #
6186 # Step 7. Define X' = -1/X. Approximate arctan(X') by an odd #
6632 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. #
6677 fbgt t_operr # cause an operr exception
6733 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. #
6772 fbgt t_operr # cause an operr exception
6981 # with an inexact result. Thus, 9.5 always raises the #
7112 # Notes: 10.2 will always create an inexact and return -1 + tiny #
7613 # returned as an extended precision number in fp0. #
7617 # mantissa is converted to an extended precision number w/ #
7618 # an exponent of $3fff and is returned in fp0. The range of #
7719 # Huge*Huge to generate overflow and an infinity with #
7834 # sign(X)*Huge*Huge to generate overflow and an infinity with #
8096 # Step 1. If |X-1| < 1/16, approximate log(X) by an odd #
8114 # Step 1: If |X| < 1/16, approximate log(1+X) by an odd #
8392 #--AN RE-ENTRY POINT FOR LOGNP1
8447 #--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL
8451 #--THIS IS AN RE-ENTRY POINT FOR LOGNP1
8703 # 4. (|X| = 1) Generate infinity with an appropriate sign and #
8709 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. #
8829 # Step 1. If X is not an integer power of two, i.e., X != 2^k, #
8856 fbeq.l ld_pzero # return an EXACT zero
9575 # >= 2^14, an overflow or underflow is returned. #
9637 # multiply with a denorm which will cause an unimplemented data type
9661 # create an fp multiply that will create the result.
10217 # we have a DENORM that needs to be converted into an EXOP.
10236 # - This routine is for cases where even an EXOP isn't #
10271 # - This routine is for cases where even an EXOP isn't #
10352 # routine may have caused an underflow or overflow. #
10353 # we find out if this occurred by doing an fsave and #
10390 # an underflow or overflow exception occurred.
10687 # ssincossnan(): When the src operand is an SNAN, store the SNAN w/ the SNAN bit set
10931 # sop_ssnan(): The src op for frem/fmod/fscale was an SNAN.
10999 # routines where an instruction is selected by an index into
11343 # fgen_except(): catch an exception during transcendental #
11348 # fadd() - emulate an add instruction #
11349 # fin() - emulate an fmove instruction #
11361 # An exception occurred on the last instruction of the #
11393 beq.b fge_fin # it was an "fmov"
11395 beq.b fge_fadd # it was an "fadd"
11557 # instruction won't cause an exception. Use the regular fmul to #
11559 # an exception. If so, return the default overflow/underflow result #
11660 # - the result of the multiply operation is an overflow.
11705 # with an extra -0x6000. if the precision is single or double, we need to
11771 # - the result of the multiply operation is an underflow.
11880 # we don't know if the result was an underflow that rounded up to a 2 or
11995 # Note: The j-bit for an infinity is a don't-care. However, to be
11996 # strictly compatible w/ the 68881/882, we make sure to return an
12052 # sgl/dbl, must scale exponent and perform an "fmove". Check to see #
12086 # precision selected is extended. so...we cannot get an underflow
12098 # for an extended precision DENORM, the UNFL exception bit is set
12116 # the input is an extended DENORM and underflow is enabled in the FPCR.
12374 # instruction won't cause an exception. Use the regular fdiv to #
12376 # an exception. If so, return the default overflow/underflow result #
12648 # we don't know if the result was an underflow that rounded up to a 1
12758 # therefore, is an INF w/ the proper sign.
12777 # The destination was an INF w/ an In Range or ZERO source, the result is
12778 # an INF w/ the proper sign.
12827 # and an actual fneg performed to see if overflow/underflow would have #
12859 # precision selected is extended. so...we can not get an underflow
12875 # for an extended precision DENORM, the UNFL exception bit is set
12899 # the input is an extended DENORM and underflow is enabled in the FPCR.
13445 # gets an EXOP created for it since it's an underflow. #
13447 # scale the operand such that the exponent is zero. Perform an "fabs" #
13449 # exponent would take an exception. If so, use unf_res() or ovf_res() #
13482 # precision selected is extended. so...we can not get an underflow
13495 # for an extended precision DENORM, the UNFL exception bit is set
13517 # the input is an extended DENORM and underflow is enabled in the FPCR.
13865 # If you have a DENORM and an INF or ZERO, just force the DENORM's j-bit to a one
13959 # instruction won't cause an exception. Use the regular fsglmul to #
13961 # an exception. If so, return the default overflow/underflow result #
14175 # we don't know if the result was an underflow that rounded up to a 2 or
14300 # instruction won't cause an exception. Use the regular fsgldiv to #
14302 # an exception. If so, return the default overflow/underflow result #
14511 # we don't know if the result was an underflow that rounded up to a 1
14698 cmp.l %d2,(tbl_fadd_ovfl.b,%pc,%d1.w*4) # is it an overflow?
14701 cmp.l %d2,(tbl_fadd_unfl.b,%pc,%d1.w*4) # is it an underflow?
14849 # if the precision is extended, this result could not have come from an
14872 # now, we must determine whether the pre-rounded result was an underflow
14893 fbgt.w fadd_unfl # yes; it's an underflow
14894 bra.w fadd_normal # no; it's not an underflow
15027 # both operands are INFs. an OPERR will result if the INFs have
15028 # different signs. else, an INF of the same sign is returned
15036 # ok, so it's not an OPERR. but, we do have to remember to return the
15151 cmp.l %d2,(tbl_fsub_ovfl.b,%pc,%d1.w*4) # is it an overflow?
15154 cmp.l %d2,(tbl_fsub_unfl.b,%pc,%d1.w*4) # is it an underflow?
15302 # if the precision is extended, this result could not have come from an
15325 # now, we must determine whether the pre-rounded result was an underflow
15346 fbgt.w fsub_unfl # yes; it's an underflow
15347 bra.w fsub_normal # no; it's not an underflow
15479 # both operands are INFs. an OPERR will result if the INFs have the
15488 # ok, so it's not an OPERR. but we do have to remember to return
15534 # instruction won't cause an exception. Use the regular fsqrt to #
15536 # an exception. If so, return the default overflow/underflow result #
16025 # fsqrt operation won't take an exception. #
16166 # If either operand (but not both operands) of an operation is a #
16170 # If either operand to an operation is a signalling NAN (SNAN), #
16185 cmp.b DTAG(%a6), &SNAN # is the dst an SNAN?
16239 # An nonsignalling NAN is returned as the default result when #
16240 # an operand error occurs for the following cases: #
16280 # the fbsun_flg is set in the SPCOND_FLG location on the stack. If an #
16283 # the displacement value to the stacked PC so that when an "rte" is #
16388 bne.w fdbcc_bsun # yes; we have an exception
16407 bne.w fdbcc_bsun # yes; we have an exception
16423 bne.w fdbcc_bsun # yes; we have an exception
16430 bne.w fdbcc_bsun # yes; we have an exception
16448 bne.w fdbcc_bsun # yes; we have an exception
16464 bne.w fdbcc_bsun # yes; we have an exception
16483 bne.w fdbcc_bsun # yes; we have an exception
16499 bne.w fdbcc_bsun # yes; we have an exception
16506 bne.w fdbcc_bsun # yes; we have an exception
16524 bne.w fdbcc_bsun # yes; we have an exception
16540 bne.w fdbcc_bsun # yes; we have an exception
16559 bne.w fdbcc_bsun # yes; we have an exception
16573 bne.w fdbcc_bsun # yes; we have an exception
16590 bne.w fdbcc_bsun # yes; we have an exception
16627 bne.w fdbcc_bsun # yes; we have an exception
16640 bne.w fdbcc_bsun # yes; we have an exception
16656 bne.w fdbcc_bsun # yes; we have an exception
16663 bne.w fdbcc_bsun # yes; we have an exception
16679 bne.w fdbcc_bsun # yes; we have an exception
16686 bne.w fdbcc_bsun # yes; we have an exception
16909 # the fbsun_flg is set in the SPCOND_FLG location on the stack. If an #
17463 # dec_areg() - decrement an areg for -(an) mode #
17464 # inc_areg() - increment an areg for (an)+ mode #
17481 # the fbsun_flg is set in the SPCOND_FLG location on the stack. If an #
18093 cmpi.b %d1,&0x18 # is <ea> (An)+ ?
18095 cmpi.b %d1,&0x20 # is <ea> -(An) ?
18167 # restore() - restore An index regs if access error occurred #
18186 # from an "Unimplemented Effective Address" exception handler. So, we #
18187 # have our own fcalc_ea() routine here. If an access error is flagged #
18191 # string of FP registers affected. This value is used as an index into #
18273 # the operation was unfortunately an: fmovm.x dn,-(sp)
18622 # Address register indirect: (An) #
18657 # Address register indirect w/ postincrement: (An)+ #
18726 # Address register indirect w/ predecrement: -(An) #
18787 # Address register indirect w/ displacement: (d16, An) #
18894 # Address register indirect w/ index(8-bit displacement): (d8, An, Xn) #
18895 # " " " w/ " (base displacement): (bd, An, Xn) #
18896 # Memory indirect postindexed: ([bd, An], Xn, od) #
18897 # Memory indirect preindexed: ([bd, An, Xn], od) #
18940 add.l %d0,%a0 # An + (index + disp)
18993 # PC indirect w/ index(8-bit displacement): (d8, PC, An) #
18994 # " " w/ " (base displacement): (bd, PC, An) #
19036 add.l %d0,%a0 # An + (index + disp)
19347 # inc_areg() - increment an address register #
19348 # dec_areg() - decrement an address register #
19361 # 1) -(An) : The register is not updated regardless of size. #
19364 # 2) (An)+ : The register is not updated. #
19381 cmpi.b %d0,&0x18 # is mode (An)+ ?
19384 cmpi.b %d0,&0x20 # is mode -(An) ?
19396 # an imem_read to fetch this later.
19445 # stacked for the exception is incorrect for -(an) and (an)+ addressing #
19448 # So, for -(an), we must subtract 8 off of the stacked <ea> value #
19449 # and return that value as the correct <ea> and store that value in An. #
19450 # For (an)+, the stacked <ea> is correct but we must adjust An by +12. #
19464 cmpi.b %d0,&0x18 # is mode (An)+ ?
19467 cmpi.b %d0,&0x20 # is mode -(An) ?
19473 # (An)+ : extended and packed fmove out
19475 # : "An" not updated
19518 # -(An) : extended and packed fmove out
19520 # : "An" not updated
19576 # _dcalc_ea() - calculate <ea>, fixing An in process #
19597 # tags for both if dyadic, one for monadic. If a number is an UNNORM, #
19606 # will create an acess error exception frame from the current exception #
19609 # if an immediate data access fails, the resulting fault status #
19644 cmpi.w %d0,&0x0038 # is it an fcmp (dyadic) ?
19645 bne.b op000_src # it's an fcmp
19653 cmpi.b %d0, &UNNORM # is dst fpreg an UNNORM?
19664 cmpi.b %d0, &UNNORM # is src fpreg an UNNORM?
19687 cmpi.w %d0,&0x0038 # is it an fcmp (dyadic) ?
19688 bne.b op010_src # it's an fcmp
19696 cmpi.b %d0, &UNNORM # is dst fpreg an UNNORM?
19782 cmpi.b %d0, &SNAN # is it an SNAN?
19973 # must convert sgl denorm format to an Xprec denorm fmt suitable for
20058 # must convert dbl denorm format to an Xprec denorm fmt suitable for
20123 cmpi.b %d0, &UNNORM # is the src op an UNNORM?
20146 cmpi.b %d0,&UNNORM # is the src op an UNNORM ZERO?
20185 # This routine is accessed by many handlers that need to do an #
20186 # opclass three move of an operand out to memory. #
20187 # Decode an fmove out (opclass 3) instruction to determine if #
20196 # the source is a denorm and if underflow is enabled, an EXOP must be #
20202 # If at any time an access error is flagged by one of the move- #
20370 # The DENORM causes an Underflow exception.
20449 # would cause either an underflow or overflow. these cases are handled
20552 # it's definitely an overflow so call ovf_res to get the correct answer
20687 # would cause either an underflow or overflow. these cases are handled
20773 # it's definitely an overflow so call ovf_res to get the correct answer
21051 cmpi.b %d0,&SNAN # is it an SNAN?
21339 # inc_areg(): increment an address register by the value in d0 #
21352 # Typically used for an instruction w/ a post-increment <ea>, #
21358 # an access error exception occurs later in emulation, this address #
21403 # dec_areg(): decrement an address register by the value in d0 #
21416 # Typically used for an instruction w/ a pre-decrement <ea>, #
21422 # an access error exception occurs later in emulation, this address #
21615 # store_fpreg(): store an fp value to the fpreg designated d0. #
21630 # careful that we don't take an exception here. #
21682 # _denorm(): denormalize an intermediate result #
21991 # last operation done was an "and" of the bits shifted off so the condition
22068 # Use rounding mode as an index into a jump table for these modes.
22220 # only. All registers except d0 are kept intact. d0 becomes an
22307 # norm(): normalize the mantissa of an extended precision input. the #
22369 # unnorm_fix(): - changes an UNNORM to one of NORM, DENORM, or ZERO #
22489 # If it's an unnormalized zero, alter the operand and force it #
22527 # it's an "unnormalized zero". let's convert it to an actual zero...
22834 # an overflowing number. #
22856 # concatenated together to create an index into the default result #
22956 # frame w/ maybe a correction factor if the <ea> is -(an) or (an)+. #
22961 # convert the packed value to an extended precision binary value. #
22965 # the stacked <ea> for packed is correct except for -(An).
22966 # the base reg must be updated for both -(An) and (An)+.
22970 bsr.l _dcalc_ea # fetch <ea>; correct An
22979 # The packed operand is an INF or a NAN if the exponent field is all ones.
22983 rts # operand is an INF or NAN
23199 # For adjusted exponents which have an absolute value greater than 27*,
23454 # If the final mul/div in decbin incurred an inex exception,
23471 # bindec(): Converts an input in extended precision format to bcd format#
24615 # Flow jumps here when an FP data fetch call gets an error #
24616 # result. This means the operating system wants an access error frame #
24619 # -(an)+ register gets returned to its pre-exception value and then #
24620 # we change the stack to an acess error stack frame. #
24626 bsr.w restore # fix An
24633 bsr.w restore # fix An
24640 bsr.w restore # fix An
24647 bsr.w restore # fix An
24654 bsr.w restore # fix An
24663 bsr.w restore # restore An
24670 bsr.w restore # restore An
24677 bsr.w restore # restore An
24684 bsr.w restore # restore An
24691 bsr.w restore # restore An
24725 # handler, then AN must be returned to its pre-instruction value.
24738 andi.w &0x0007,%d1 # fetch An
24775 # because we hadn't changed it yet. if it's an opclass two
Indexes created Sat Oct 25 16:10:12 GMT 2025