Lines Matching refs:operand
352 set FP_DST, LV+56 # fp destination operand
358 set FP_SRC, LV+44 # fp source operand
380 set STORE_FLG, LV+19 # flag: operand store (ie. not fcmp/ftst)
385 set DTAG, LV+15 # destination operand type
386 set STAG, LV+14 # source operand type
435 set NORM, 0x00 # operand type for STAG/DTAG
436 set ZERO, 0x01 # operand type for STAG/DTAG
437 set INF, 0x02 # operand type for STAG/DTAG
438 set QNAN, 0x03 # operand type for STAG/DTAG
439 set DENORM, 0x04 # operand type for STAG/DTAG
440 set SNAN, 0x05 # operand type for STAG/DTAG
441 set UNNORM, 0x06 # operand type for STAG/DTAG
455 set operr_bit, 5 # operand error
596 # fix_skewed_ops() - adjust src operand in fsave frame #
600 # load_fpn2() - load dst operand from FP regfile #
610 # - The fsave frame contains the source operand #
630 # exceptional operand and plave it in the fsave state frame, and store #
677 bsr.l set_tag_x # tag the operand type
690 bsr.l set_tag_x # tag the operand type
691 cmpi.b %d0,&UNNORM # is operand an UNNORM?
792 # the src operand is definitely a NORM(!), so tag it as such
803 lea FP_SRC(%a6),%a0 # pass ptr to src operand
836 # fix_skewed_ops() - adjust src operand in fsave frame #
840 # load_fpn2() - load dst operand from FP regfile #
850 # - The fsave frame contains the source operand #
870 # exceptional operand and plave it in the fsave state frame, and store #
915 bsr.l set_tag_x # tag the operand type
933 bsr.l set_tag_x # tag the operand type
934 cmpi.b %d0,&UNNORM # is operand an UNNORM?
1066 # the src operand is definitely a NORM(!), so tag it as such
1077 lea FP_SRC(%a6),%a0 # pass ptr to src operand
1111 # fix_skewed_ops() - adjust src operand in fsave frame #
1115 # load_fpn2() - load dst operand from FP regfile #
1116 # load_fpn1() - load src operand from FP regfile #
1127 # get_packed() - fetch packed operand from memory #
1155 # operand from the fsave state frame and the dst operand (if dyadic) #
1275 # we don't know whether the src operand or the dst operand (or both) is the
1276 # UNNORM or DENORM. call the function that tags the operand type. if the
1279 bsr.l set_tag_x # tag the operand type
1280 cmpi.b %d0,&UNNORM # is operand an UNNORM?
1299 bsr.l set_tag_x # tag the operand type
1300 cmpi.b %d0,&UNNORM # is operand an UNNORM?
1386 # * there will be no other way to pass it the exceptional operand
1405 # corresponding exception. the operand in the fsave frame should be the original
1406 # src operand.
1435 # If the input operand to this operation was opclass two and a single
1436 # or double precision denorm, inf, or nan, the operand needs to be
1504 # the src operand is in FP_SRC. Call _fout() to write out the result and
1543 lea FP_SRC(%a6),%a0 # pass ptr to src operand
1825 bsr.l get_packed # fetch packed src operand
1844 bsr.l set_tag_x # tag the operand type
1845 cmpi.b %d0,&UNNORM # is operand an UNNORM?
1964 # * there will be no other way to pass it the exceptional operand
1983 # corresponding exception. the operand in the fsave frame should be the original
1984 # src operand.
1986 # "non-skewed" operand for cases of sgl and dbl src INFs,NANs, and DENORMs.
2087 # able to detect all operand types.
2089 bsr.l set_tag_x # tag the operand type
2090 cmpi.b %d0,&UNNORM # is operand an UNNORM?
2100 lea FP_SRC(%a6),%a0 # pass ptr to src operand
2205 frestore FP_SRC(%a6) # restore src operand
2245 frestore FP_SRC(%a6) # restore src operand
2285 frestore FP_SRC(%a6) # restore src operand
2306 # if we're stuffing a source operand back into an fsave frame then we
2382 # fix_skewed_ops() - adjust src operand in fsave frame #
2386 # load_fpn2() - load dst operand from FP regfile #
2391 # _mem_read() - read extended immediate operand from memory #
2419 # as the source operand to the instruction specified by the instruction #
2533 bsr.l _imem_read # read packed operand
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
2543 # The packed operand is a zero if the mantissa is all zero, else it's
2551 beq.b iea_op_setsrc # operand is a ZERO
2560 # FP_SRC now holds the src operand.
2562 bsr.l set_tag_x # tag the operand type
2564 cmpi.b %d0,&UNNORM # is operand an UNNORM?
2578 bsr.l load_fpn2 # load dst operand
2581 bsr.l set_tag_x # tag the operand type
2583 cmpi.b %d0,&UNNORM # is operand an UNNORM?
2594 # store a result. then, only fcmp will branch back and pick up a dst operand.
2975 # instruction is using an extended precision immediate operand. therefore,
3078 # FP Operand Error exception in an operating system. #
3082 # fix_skewed_ops() - adjust src operand in fsave frame #
3090 # - The fsave frame contains the source operand #
3101 # input operand in the fsave frame may be incorrect for some cases #
3140 # here, we simply see if the operand in the fsave frame needs to be "unskewed".
3142 # denorm operand in the sgl or dbl format. NANs also become skewed, but can't
3161 # operand error exceptions. we do this here before passing control to
3162 # the user operand error handler.
3166 # operand and save the appropriate minimum or maximum integer value
3169 # although packed opclass three operations can take operand error
3180 # the operand is either an infinity or a QNAN.
3271 # fix_skewed_ops() - adjust src operand in fsave frame #
3280 # - The fsave frame contains the source operand #
3291 # input operand in the fsave frame may be incorrect for some cases #
3307 # for the operand being moved. #
3336 # here, we simply see if the operand in the fsave frame needs to be "unskewed".
3338 # denorm operand in the sgl or dbl format. NANs also become skewed and must be
3364 # operand and save the appropriate minimum or maximum integer value
3480 lea FP_SCR0(%a6),%a0 # pass: ptr to operand
3519 lea FP_SCR0(%a6),%a0 # pass: ptr to operand
3570 # fix_skewed_ops() - adjust src operand in fsave frame #
3574 # load_fpn2() - load dst operand from FP regfile #
3582 # - The fsave frame contains the source operand #
3648 # INEX1 bit from when the operand was first converted.
3659 bsr.l set_tag_x # tag the operand type
3675 bsr.l set_tag_x # tag the operand type
3676 cmpi.b %d0,&UNNORM # is operand an UNNORM?
3741 lea FP_SRC(%a6),%a0 # pass ptr to src operand
3756 # fix_skewed_ops() - adjust fsave operand #
3761 # - The fsave frame contains the source operand. #
3765 # - The fsave frame contains the adjusted source operand. #
3770 # exception is taken, the input operand in the fsave state frame may #
3772 # adjusts the operand using fix_skewed_ops() and then branches to #
3799 # here, we simply see if the operand in the fsave frame needs to be "unskewed".
3879 # 3) #<data> : The upper longword of the immediate operand is #
5522 # norm() - normalize the mantissa if the operand was a DENORM #
5525 # FP_SCR0(a6) = extended precision operand to be scaled #
5528 # FP_SCR0(a6) = scaled extended precision operand #
5532 # Set the exponent of the input operand to 0x3fff. Save the value #
5534 # normalize the operand if it was a DENORM. Add this normalization #
5541 mov.w FP_SCR0_EX(%a6),%d1 # extract operand's {sgn,exp}
5544 andi.l &0x7fff,%d1 # extract operand's exponent
5546 andi.w &0x8000,%d0 # extract operand's sgn
5547 or.w &0x3fff,%d0 # insert new operand's exponent(=0)
5551 cmpi.b STAG(%a6),&DENORM # is operand normalized?
5571 # scale_sqrt(): scale the input operand exponent so a subsequent #
5575 # norm() - normalize the mantissa if the operand was a DENORM #
5578 # FP_SCR0(a6) = extended precision operand to be scaled #
5581 # FP_SCR0(a6) = scaled extended precision operand #
5585 # If the input operand is a DENORM, normalize it. #
5586 # If the exponent of the input operand is even, set the exponent #
5588 # exponent of the input operand is off, set the exponent to ox3fff and #
5595 cmpi.b STAG(%a6),&DENORM # is operand normalized?
5598 mov.w FP_SCR0_EX(%a6),%d1 # extract operand's {sgn,exp}
5599 andi.l &0x7fff,%d1 # extract operand's exponent
5601 andi.w &0x8000,FP_SCR0_EX(%a6) # extract operand's sgn
5606 ori.w &0x3fff,FP_SCR0_EX(%a6) # insert new operand's exponent(=0)
5614 ori.w &0x3ffe,FP_SCR0_EX(%a6) # insert new operand's exponent(=0)
5628 ori.w &0x3fff,FP_SCR0_EX(%a6) # insert new operand's exponent(=0)
5635 ori.w &0x3ffe,FP_SCR0_EX(%a6) # insert new operand's exponent(=0)
5649 # norm() - normalize the mantissa if the operand was a DENORM #
5652 # FP_SCR1(a6) = extended precision operand to be scaled #
5655 operand #
5659 # Set the exponent of the input operand to 0x3fff. Save the value #
5661 # normalize the operand if it was a DENORM. Add this normalization #
5668 mov.w FP_SCR1_EX(%a6),%d1 # extract operand's {sgn,exp}
5671 andi.l &0x7fff,%d1 # extract operand's exponent
5673 andi.w &0x8000,%d0 # extract operand's sgn
5674 or.w &0x3fff,%d0 # insert new operand's exponent(=0)
5678 cmpi.b DTAG(%a6),&DENORM # is operand normalized?
5697 # res_qnan(): return default result w/ QNAN operand for dyadic #
5698 # res_snan(): return default result w/ SNAN operand for dyadic #
5699 # res_qnan_1op(): return dflt result w/ QNAN operand for monadic #
5700 # res_snan_1op(): return dflt result w/ SNAN operand for monadic #
5706 # FP_SRC(a6) = pointer to extended precision src operand #
5707 # FP_DST(a6) = pointer to extended precision dst operand #
5713 # If either operand (but not both operands) of an operation is a #
5715 # operands are nonsignalling NANs, then the destination operand #
5717 # If either operand to an operation is a signalling NAN (SNAN), #
5722 # SNAN bit in the operand to one), and the operation continues as #
5774 # res_operr(): return default result during operand error #
5783 # fp0 = default operand error result #
5787 # an operand error occurs for the following cases: #
5811 # a0 = points to the operand to be denormalized #
5825 # exponent of the operand to the threshold value. While shifting the #
5881 # %a0 : points to the operand to be denormalized #
5885 # %a0 : points to the denormalized operand #
5904 # check to see how much less than the underflow threshold the operand
6149 # a0 = ptr to input operand in internal extended format #
6431 # input operand should not be normalized already. #
6440 # a0 = pointer fp extended precision operand to normalize #
6444 # a0 = the input operand's mantissa is normalized; the exponent #
6506 # a0 = input operand has been converted to a norm, denorm, or #
6520 bfffo FTEMP_LO(%a0){&0:&32}, %d0 # is operand really a zero?
6603 # a0 = pointer to extended precision operand #
6611 # determine the type of operand. #
6612 # If it's an unnormalized zero, alter the operand and force it #
6683 # a0 = points to double precision operand #
6691 # determine the type of operand. #
6746 # a0 = pointer to single precision operand #
6754 # determine the type of operand. #
6810 # a0 = pointer to extended precison operand #
6819 # Convert the input operand to "internal format" which means the #
6821 # portion of the extended precison operand. Denormalize the number #
6843 mov.l %a0, -(%sp) # save operand ptr during calls
6907 mov.l %a0,-(%sp) # save operand ptr during calls
7079 # a0 = pointer to extended precision source operand #
7084 # OVFL/UNFL occurred for a sgl or dbl operand #
7088 # opclass three move of an operand out to memory. #
7131 # Only "Unimplemented Data Type" exceptions enter here. The operand
7134 tst.b STAG(%a6) # is operand normalized?
7177 # Only "Unimplemented Data Type" exceptions enter here. The operand
7180 tst.b STAG(%a6) # is operand normalized?
7223 # Only "Unimplemented Data Type" exceptions enter here. The operand
7226 tst.b STAG(%a6) # is operand normalized?
7270 # Only "Unimplemented Data Type" exceptions enter here. The operand
7302 tst.b STAG(%a6) # is operand normalized?
7323 tst.b STAG(%a6) # is operand normalized?
7350 # operand is a normalized number. first, we check to see if the move out
7358 cmpi.w %d0,&SGL_HI # will operand overflow?
7361 cmpi.w %d0,&SGL_LO # will operand underflow?
7401 # here, we know that the operand would UNFL if moved out to single prec,
7422 lea FP_SCR0(%a6),%a0 # pass: ptr to operand
7472 tst.b SRC_EX(%a0) # is operand negative?
7588 # operand is a normalized number. first, we check to see if the move out
7596 cmpi.w %d0,&DBL_HI # will operand overflow?
7599 cmpi.w %d0,&DBL_LO # will operand underflow?
7630 # here, we know that the operand would UNFL if moved out to double prec,
7651 lea FP_SCR0(%a6),%a0 # pass: ptr to operand
7693 tst.b SRC_EX(%a0) # is operand negative?
7748 # a0 = pointer to source operand in extended precision #
7815 # a0 = pointer to source operand in extended precision #
7977 # a0 = pointer to extended precision source operand #
7978 # a1 = pointer to extended precision destination operand #
7993 # result operand to the proper exponent. #
8064 fmovm.x FP_SCR1(%a6),&0x80 # load dst operand
8101 # exceptional operand.
8104 fmovm.x FP_SCR1(%a6),&0x80 # load dst operand
8163 fmovm.x FP_SCR1(%a6),&0x80 # load dst operand
8212 # exceptional operand.
8220 fmovm.x FP_SCR1(%a6),&0x80 # load dst operand
8293 fmovm.x FP_SCR1(%a6),&0x80 # load dst operand
8317 fmovm.x FP_SCR1(%a6),&0x40 # load dst operand
8473 # a0 = pointer to extended precision source operand #
8522 tst.b SRC_EX(%a0) # is the operand negative?
8538 tst.b SRC_EX(%a0) # is the operand negative?
8550 # exponent and insert back into the operand.
8556 lea FP_SCR0(%a6),%a0 # pass: ptr to operand
8569 # operand is to be rounded to single or double precision
8576 # operand is to be rounded to single precision
8591 # operand will NOT overflow or underflow when moved into the fp reg file
8619 # operand is to be rounded to double precision
8635 # operand WILL underflow when moved in to the fp register file
8640 tst.b FP_SCR0_EX(%a6) # is operand negative?
8659 # operand will underflow AND underflow or inexact is enabled.
8681 # operand WILL overflow.
8758 # operand is not a NORM: check its optype and branch accordingly
8794 # a0 = pointer to extended precision source operand #
8795 # a1 = pointer to extended precision destination operand #
8810 # result operand to the proper exponent. #
8976 fmovm.x FP_SCR1(%a6),&0x80 # load dst operand
9248 # a0 = pointer to extended precision source operand #
9333 # exponent and insert back into the operand.
9336 lea FP_SCR0(%a6),%a0 # pass: ptr to operand
9349 # operand is either single or double
9356 # operand is to be rounded to single precision
9371 # operand will NOT overflow or underflow when moved in to the fp reg file
9399 # operand is to be rounded to double precision
9415 # operand WILL underflow when moved in to the fp register file
9439 # operand will underflow AND underflow is enabled.
9461 # operand WILL overflow.
9567 # a0 = pointer to extended precision source operand #
9573 # Check the source operand tag (STAG) and set the FPCR according #
9574 # to the operand type and sign. #
9587 tst.b SRC_EX(%a0) # is operand negative?
9611 tst.b SRC_EX(%a0) # is operand negative?
9622 tst.b SRC_EX(%a0) # is operand negative?
9635 tst.b SRC_EX(%a0) # is operand negative?
9652 # a0 = pointer to extended precision source operand #
9659 # Separate according to operand type. Unnorms don't pass through #
9758 # a0 = pointer to extended precision source operand #
9765 # Separate according to operand type. Unnorms don't pass through #
9866 operand #
9879 # scale the operand such that the exponent is zero. Perform an "fabs" #
9951 # exponent and insert back into the operand.
9954 lea FP_SCR0(%a6),%a0 # pass: ptr to operand
9967 # operand is either single or double
9974 # operand is to be rounded to single precision
9989 # operand will NOT overflow or underflow when moved in to the fp reg file
10017 # operand is to be rounded to double precision
10033 # operand WILL underflow when moved in to the fp register file
10054 # operand will underflow AND underflow is enabled.
10076 # operand WILL overflow.
10183 # a0 = pointer to extended precision source operand #
10184 # a1 = pointer to extended precision destination operand #
10379 # a0 = pointer to extended precision source operand #
10380 # a1 = pointer to extended precision destination operand #
10395 # result operand to the proper exponent. #
10720 # a0 = pointer to extended precision source operand #
10721 # a1 = pointer to extended precision destination operand #
10736 # result operand to the proper exponent. #
11055 # scale_to_zero_src() - set src operand exponent equal to zero #
11056 # scale_to_zero_dst() - set dst operand exponent equal to zero #
11059 # a0 = pointer to extended precision source operand #
11060 # a1 = pointer to extended precision destination operand #
11435 # one operand is a ZERO and the other is a DENORM or NORM. scale
11442 bsr.l scale_to_zero_src # scale the operand
11452 bsr.l scale_to_zero_dst # scale the operand
11508 # scale_to_zero_src() - set src operand exponent equal to zero #
11509 # scale_to_zero_dst() - set dst operand exponent equal to zero #
11512 # a0 = pointer to extended precision source operand #
11513 # a1 = pointer to extended precision destination operand #
11887 # one operand is a ZERO and the other is a DENORM or a NORM.
11894 bsr.l scale_to_zero_src # scale the operand
11904 bsr.l scale_to_zero_dst # scale the operand
11948 # scale_sqrt() - scale the source operand #
11955 # a0 = pointer to extended precision source operand #
11970 # result operand to the proper exponent. #
11996 tst.b SRC_EX(%a0) # is operand negative?
12013 tst.b SRC_EX(%a0) # is operand negative?
12028 # operand is either single or double
12035 # operand is to be rounded to single precision
12052 # operand will NOT overflow or underflow when moved in to the fp reg file
12080 # operand is to be rounded to double precision
12105 # operand WILL underflow when moved in to the fp register file
12136 # operand will underflow AND underflow is enabled.
12158 # operand WILL overflow.
12899 # get_packed(): fetch a packed operand from memory and then #
12904 # _mem_read() - fetch the packed operand from memory #
12913 # FP_SRC(a6) = packed operand now as a binary FP number #
12918 # Then, fetch the operand from memory. If the fetch fails, exit #
12920 # If the packed operand is a ZERO,NAN, or INF, convert it to #
12935 bsr.l _dmem_read # read packed operand
12940 # The packed operand is an INF or a NAN if the exponent field is all ones.
12944 rts # operand is an INF or NAN
12946 # The packed operand is a zero if the mantissa is all zero, else it's
12956 rts # operand is a ZERO
13569 # a0: ptr for original operand/final result
13649 # a0: ptr for original operand/final result
13711 # a0: ptr for original operand/final result
13783 # a0: ptr for original operand/final result
13886 # a0: ptr for original operand/final result
13911 # since the input operand is a DENORM, we can't multiply it directly.
13974 # a0: ptr for original operand/final result
14015 # a0: ptr for original operand/src ptr for sintdo
14034 tst.l L_SCR2(%a6) # test sign of original operand
Indexes created Sat Oct 18 17:09:52 GMT 2025