Lines Matching refs:INPUT
608 # INPUT *************************************************************** #
848 # INPUT *************************************************************** #
1129 # INPUT *************************************************************** #
1272 lea FP_SRC(%a6),%a0 # pass ptr to input
1277 # input is an UNNORM, then convert it to a NORM, DENORM, or ZERO.
1435 # If the input operand to this operation was opclass two and a single
2397 # INPUT *************************************************************** #
3088 # INPUT *************************************************************** #
3101 # input operand in the fsave frame may be incorrect for some cases #
3278 # INPUT *************************************************************** #
3291 # input operand in the fsave frame may be incorrect for some cases #
3580 # INPUT *************************************************************** #
3759 # INPUT *************************************************************** #
3770 # exception is taken, the input operand in the fsave state frame may #
3828 # INPUT *************************************************************** #
3957 # INPUT *************************************************************** #
5009 # ssin(): computes the sine of a normalized input #
5010 # ssind(): computes the sine of a denormalized input #
5011 # scos(): computes the cosine of a normalized input #
5012 # scosd(): computes the cosine of a denormalized input #
5013 # ssincos(): computes the sine and cosine of a normalized input #
5014 # ssincosd(): computes the sine and cosine of a denormalized input #
5016 # INPUT *************************************************************** #
5017 # a0 = pointer to extended precision input #
5143 fmov.x (%a0),%fp0 # LOAD INPUT
5144 fmov.x %fp0,X(%a6) # save input at X
5153 bra.w SINSM # yes; input is very small
5158 bra.w SREDUCEX # yes; input is very large
5354 fmov.x (%a0),%fp0 # LOAD INPUT
5722 # stan(): computes the tangent of a normalized input #
5723 # stand(): computes the tangent of a denormalized input #
5725 # INPUT *************************************************************** #
5726 # a0 = pointer to extended precision input #
5875 fmov.x (%a0),%fp0 # LOAD INPUT
6155 # INPUT *************************************************************** #
6156 # a0 = pointer to extended precision input #
6357 fmov.x (%a0),%fp0 # LOAD INPUT
6602 # sasin(): computes the inverse sine of a normalized input #
6603 # sasind(): computes the inverse sine of a denormalized input #
6605 # INPUT *************************************************************** #
6606 # a0 = pointer to extended precision input #
6639 fmov.x (%a0),%fp0 # LOAD INPUT
6703 # sacos(): computes the inverse cosine of a normalized input #
6704 # sacosd(): computes the inverse cosine of a denormalized input #
6706 # INPUT *************************************************************** #
6707 # a0 = pointer to extended precision input #
6740 fmov.x (%a0),%fp0 # LOAD INPUT
6797 # setox(): computes the exponential for a normalized input #
6798 # setoxd(): computes the exponential for a denormalized input #
6799 # setoxm1(): computes the exponential minus 1 for a normalized input #
6800 # setoxm1d(): computes the exponential minus 1 for a denormalized input #
6802 # INPUT *************************************************************** #
6803 # a0 = pointer to extended precision input #
6828 # Step 1. Filter out extreme cases of input argument. #
7220 mov.l (%a0),%d1 # load part of input X
7236 fmov.x (%a0),%fp0 # load input from (a0)
7333 fmov.x (%a0),%fp0 # load input from (a0)
7384 mov.l (%a0),%d1 # load part of input X
7401 fmov.x (%a0),%fp0 # load input from (a0)
7611 # sgetexp(): returns the exponent portion of the input argument. #
7616 # sgetman(): extracts the mantissa of the input argument. The #
7622 # INPUT *************************************************************** #
7623 # a0 = pointer to extended precision input #
7658 # here, we build the result in a tmp location so as not to disturb the input
7680 # scosh(): computes the hyperbolic cosine of a normalized input #
7681 # scoshd(): computes the hyperbolic cosine of a denormalized input #
7683 # INPUT *************************************************************** #
7684 # a0 = pointer to extended precision input #
7730 fmov.x (%a0),%fp0 # LOAD INPUT
7794 # ssinh(): computes the hyperbolic sine of a normalized input #
7795 # ssinhd(): computes the hyperbolic sine of a denormalized input #
7797 # INPUT *************************************************************** #
7798 # a0 = pointer to extended precision input #
7842 fmov.x (%a0),%fp0 # LOAD INPUT
7912 # stanh(): computes the hyperbolic tangent of a normalized input #
7913 # stanhd(): computes the hyperbolic tangent of a denormalized input #
7915 # INPUT *************************************************************** #
7916 # a0 = pointer to extended precision input #
7967 fmov.x (%a0),%fp0 # LOAD INPUT
8076 # slogn(): computes the natural logarithm of a normalized input #
8077 # slognd(): computes the natural logarithm of a denormalized input #
8078 # slognp1(): computes the log(1+X) of a normalized input #
8079 # slognp1d(): computes the log(1+X) of a denormalized input #
8081 # INPUT *************************************************************** #
8082 # a0 = pointer to extended precision input #
8329 fmov.x (%a0),%fp0 # LOAD INPUT
8333 #--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS
8367 add.l ADJK(%a6),%d1 # ADJUST K, ORIGINAL INPUT MAY BE DENORM.
8436 # if the input is exactly equal to one, then exit through ld_pzero.
8442 #--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.
8495 #--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUT
8497 mov.l &-100,ADJK(%a6) # INPUT = 2^(ADJK) * FP0
8499 #----normalize the input value by left shifting k bits (k to be determined
8502 #----Note that this code assumes the denormalized input is NON-ZERO.
8557 fmov.x (%a0),%fp0 # LOAD INPUT
8567 fmov.x (%a0),%fp0 # LOAD INPUT
8569 fmov.x %fp0,%fp1 # FP1 IS INPUT Z
8667 #--ENTRY POINT FOR LOG(1+Z) FOR DENORMALIZED INPUT
8673 # satanh(): computes the inverse hyperbolic tangent of a norm input #
8674 # satanhd(): computes the inverse hyperbolic tangent of a denorm input #
8676 # INPUT *************************************************************** #
8677 # a0 = pointer to extended precision input #
8761 # slog10(): computes the base-10 logarithm of a normalized input #
8762 # slog10d(): computes the base-10 logarithm of a denormalized input #
8763 # slog2(): computes the base-2 logarithm of a normalized input #
8764 # slog2d(): computes the base-2 logarithm of a denormalized input #
8766 # INPUT *************************************************************** #
8767 # a0 = pointer to extended precision input #
8925 # stwotox(): computes 2**X for a normalized input #
8926 # stwotoxd(): computes 2**X for a denormalized input #
8927 # stentox(): computes 10**X for a normalized input #
8928 # stentoxd(): computes 10**X for a denormalized input #
8930 # INPUT *************************************************************** #
8931 # a0 = pointer to extended precision input #
9101 fmovm.x (%a0),&0x80 # LOAD INPUT
9198 fmovm.x (%a0),&0x80 # LOAD INPUT
9323 # INPUT *************************************************************** #
9577 # INPUT *************************************************************** #
9691 # The source input is below 1, so we check for denormalized numbers
9709 # smod(): computes the fp MOD of the input values X,Y. #
9710 # srem(): computes the fp (IEEE) REM of the input values X,Y. #
9712 # INPUT *************************************************************** #
9713 # a0 = pointer to extended precision input X #
9714 # a1 = pointer to extended precision input Y #
9717 # The input operands X and Y can be either normalized or #
10127 # INPUT *************************************************************** #
10169 # - For all functions that have a denormalized input and #
10418 # INPUT: #
10702 # INPUT: #
11351 # INPUT *************************************************************** #
11544 # INPUT *************************************************************** #
11594 bne.w fmul_not_norm # optimize on non-norm input
11997 # INF w/ the j-bit set if the input INF j-bit was set. Destination
12040 # INPUT *************************************************************** #
12076 bne.w fin_not_norm # optimize on non-norm input
12116 # the input is an extended DENORM and underflow is enabled in the FPCR.
12361 # INPUT *************************************************************** #
12413 bne.w fdiv_not_norm # optimize on non-norm input
12745 mov.b DST_EX(%a1),%d1 # or of input signs.
12815 # INPUT *************************************************************** #
12849 bne.w fneg_not_norm # optimize on non-norm input
12899 # the input is an extended DENORM and underflow is enabled in the FPCR.
13106 # input is not normalized; what is it?
13134 # INPUT *************************************************************** #
13149 bne.b ftst_not_norm # optimize on non-norm input
13163 # input is not normalized; what is it?
13219 # INPUT *************************************************************** #
13241 bne.b fint_not_norm # optimize on non-norm input
13261 # input is not normalized; what is it?
13325 # INPUT *************************************************************** #
13347 bne.b fintrz_not_norm # optimize on non-norm input
13363 # input is not normalized; what is it?
13433 # INPUT *************************************************************** #
13472 bne.w fabs_not_norm # optimize on non-norm input
13517 # the input is an extended DENORM and underflow is enabled in the FPCR.
13721 # input is not normalized; what is it?
13750 # INPUT *************************************************************** #
13771 bne.b fcmp_not_norm # optimize on non-norm input
13851 # 'N' bit for a negative QNAN or SNAN input so we must squelch it here.
13946 # INPUT *************************************************************** #
13976 bne.w fsglmul_not_norm # optimize on non-norm input
14287 # INPUT *************************************************************** #
14317 bne.w fsgldiv_not_norm # optimize on non-norm input
14626 # INPUT *************************************************************** #
14664 bne.w fadd_not_norm # optimize on non-norm input
15079 # INPUT *************************************************************** #
15117 bne.w fsub_not_norm # optimize on non-norm input
15522 # INPUT *************************************************************** #
15558 bne.w fsqrt_not_norm # optimize on non-norm input
15806 # input is not normalized; what is it?
15855 # INPUT *************************************************************** #
15977 # INPUT *************************************************************** #
15985 # Set the exponent of the input operand to 0x3fff. Save the value #
16024 # scale_sqrt(): scale the input operand exponent so a subsequent #
16030 # INPUT *************************************************************** #
16038 # If the input operand is a DENORM, normalize it. #
16039 # If the exponent of the input operand is even, set the exponent #
16041 # exponent of the input operand is off, set the exponent to ox3fff and #
16104 # INPUT *************************************************************** #
16112 # Set the exponent of the input operand to 0x3fff. Save the value #
16158 # INPUT *************************************************************** #
16232 # INPUT *************************************************************** #
16266 # INPUT *************************************************************** #
16895 # INPUT *************************************************************** #
17467 # INPUT *************************************************************** #
18169 # INPUT *************************************************************** #
19215 # INPUT *************************************************************** #
19350 # INPUT *************************************************************** #
19437 # INPUT *************************************************************** #
19584 # INPUT *************************************************************** #
19803 # INPUT: #
20027 lea L_SCR1(%a6), %a1 # pass: ptr to input dbl tmp space
20035 lea L_SCR1(%a6), %a0 # pass: ptr to input dbl
20050 lea L_SCR1(%a6), %a1 # pass: ptr to input dbl tmp space
20113 lea FP_SRC(%a6), %a1 # pass: ptr to input ext tmp space
20176 # INPUT *************************************************************** #
20845 # INPUT *************************************************************** #
20912 # INPUT *************************************************************** #
20967 mov.b STAG(%a6),%d0 # fetch input type
20968 bne.w fout_pack_not_norm # input is not NORM
20989 lea FP_SRC(%a6),%a0 # pass: ptr to input
21067 # INPUT *************************************************************** #
21161 # INPUT *************************************************************** #
21222 # INPUT *************************************************************** #
21283 # INPUT *************************************************************** #
21344 # INPUT *************************************************************** #
21408 # INPUT *************************************************************** #
21474 # INPUT *************************************************************** #
21547 # INPUT *************************************************************** #
21620 # INPUT *************************************************************** #
21687 # INPUT *************************************************************** #
21757 # INPUT: #
22025 # INPUT *************************************************************** #
22026 # a0 = ptr to input operand in internal extended format #
22212 # INPUT
22307 # norm(): normalize the mantissa of an extended precision input. the #
22308 # input operand should not be normalized already. #
22316 # INPUT *************************************************************** #
22321 # a0 = the input operand's mantissa is normalized; the exponent #
22378 # INPUT *************************************************************** #
22383 # a0 = input operand has been converted to a norm, denorm, or #
22474 # set_tag_x(): return the optype of the input ext fp number #
22479 # INPUT *************************************************************** #
22554 # set_tag_d(): return the optype of the input dbl fp number #
22559 # INPUT *************************************************************** #
22617 # set_tag_s(): return the optype of the input sgl fp number #
22622 # INPUT *************************************************************** #
22686 # INPUT *************************************************************** #
22696 # Convert the input operand to "internal format" which means the #
22841 # INPUT *************************************************************** #
22947 # INPUT *************************************************************** #
23006 # INPUT *************************************************************** #
23081 mov.l 0x0(%a0),FP_SCR0_EX(%a6) # make a copy of input
23471 # bindec(): Converts an input in extended precision format to bcd format#
23473 # INPUT *************************************************************** #
23474 # a0 = pointer to the input extended precision value in memory. #
23475 # the input may be either normalized, unnormalized, or #
23484 # A1. Set RM and size ext; Set SIGMA = sign of input. #
23487 # input. If input is unnormalized or denormalized, #
23490 # A2. Set X = abs(input). #
23493 # ILOG is the log base 10 of the input value. It is #
23556 # mantissa to bcd in memory. The input to binstr is #
23600 # d0: scratch; LEN input to binstr
23624 # A1. Set RM and size ext. Set SIGMA = sign input;
23626 # separating normalized/denormalized input. If the input
23628 # to signal denorm. If the input is unnormalized, normalize
23629 # the input and test for denormalized result.
23636 cmpi.b STAG(%a6),&DENORM # is input a DENORM?
23637 bne.w A2_str # no; input is a NORM
23654 # Test if the normalized input is denormalized
23665 # A2. Set X = abs(input).
23668 mov.l (%a0),FP_SCR1(%a6) # move input to work space
23669 mov.l 4(%a0),FP_SCR1+4(%a6) # move input to work space
23670 mov.l 8(%a0),FP_SCR1+8(%a6) # move input to work space
23674 # ILOG is the log base 10 of the input value. It is approx-
23680 # Input/Output
23742 # Input/Output
23814 # Input/Output
23899 # Input/Output
23912 # 10^24 is exact. If the input was denormalized, we must
23917 # Input/Output
23950 # since the input operand is a DENORM, we can't multiply it directly.
23971 mov.l 0x8(%a0),-(%sp) # put input op mantissa on stk
24005 # Input/Output
24046 # Input/Output
24114 # Input/Output
24153 # 10^LEN-1 is computed for this test and A14. If the input was
24156 tst.b BINDEC_FLG(%a6) # check if input was norm
24213 # mantissa to bcd in memory. The input to binstr is
24221 # Input/Output
24294 # Input/Output
24375 # Input/Output
24465 # INPUT *************************************************************** #
24608 # INPUT *************************************************************** #
Indexes created Sat Oct 25 01:09:55 GMT 2025