1*fae548d3Szrj /* flonum_mult.c - multiply two flonums
2*fae548d3Szrj Copyright (C) 1987-2020 Free Software Foundation, Inc.
3*fae548d3Szrj
4*fae548d3Szrj This file is part of GAS, the GNU Assembler.
5*fae548d3Szrj
6*fae548d3Szrj GAS is free software; you can redistribute it and/or modify
7*fae548d3Szrj it under the terms of the GNU General Public License as published by
8*fae548d3Szrj the Free Software Foundation; either version 3, or (at your option)
9*fae548d3Szrj any later version.
10*fae548d3Szrj
11*fae548d3Szrj GAS is distributed in the hope that it will be useful, but WITHOUT
12*fae548d3Szrj ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13*fae548d3Szrj or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14*fae548d3Szrj License for more details.
15*fae548d3Szrj
16*fae548d3Szrj You should have received a copy of the GNU General Public License
17*fae548d3Szrj along with GAS; see the file COPYING. If not, write to the Free
18*fae548d3Szrj Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19*fae548d3Szrj 02110-1301, USA. */
20*fae548d3Szrj
21*fae548d3Szrj #include "ansidecl.h"
22*fae548d3Szrj #include "flonum.h"
23*fae548d3Szrj
24*fae548d3Szrj /* plan for a . b => p(roduct)
25*fae548d3Szrj
26*fae548d3Szrj +-------+-------+-/ /-+-------+-------+
27*fae548d3Szrj | a | a | ... | a | a |
28*fae548d3Szrj | A | A-1 | | 1 | 0 |
29*fae548d3Szrj +-------+-------+-/ /-+-------+-------+
30*fae548d3Szrj
31*fae548d3Szrj +-------+-------+-/ /-+-------+-------+
32*fae548d3Szrj | b | b | ... | b | b |
33*fae548d3Szrj | B | B-1 | | 1 | 0 |
34*fae548d3Szrj +-------+-------+-/ /-+-------+-------+
35*fae548d3Szrj
36*fae548d3Szrj +-------+-------+-/ /-+-------+-/ /-+-------+-------+
37*fae548d3Szrj | p | p | ... | p | ... | p | p |
38*fae548d3Szrj | A+B+1| A+B | | N | | 1 | 0 |
39*fae548d3Szrj +-------+-------+-/ /-+-------+-/ /-+-------+-------+
40*fae548d3Szrj
41*fae548d3Szrj /^\
42*fae548d3Szrj (carry) a .b ... | ... a .b a .b
43*fae548d3Szrj A B | 0 1 0 0
44*fae548d3Szrj |
45*fae548d3Szrj ... | ... a .b
46*fae548d3Szrj | 1 0
47*fae548d3Szrj |
48*fae548d3Szrj | ...
49*fae548d3Szrj |
50*fae548d3Szrj |
51*fae548d3Szrj |
52*fae548d3Szrj | ___
53*fae548d3Szrj | \
54*fae548d3Szrj +----- P = > a .b
55*fae548d3Szrj N /__ i j
56*fae548d3Szrj
57*fae548d3Szrj N = 0 ... A+B
58*fae548d3Szrj
59*fae548d3Szrj for all i,j where i+j=N
60*fae548d3Szrj [i,j integers > 0]
61*fae548d3Szrj
62*fae548d3Szrj a[], b[], p[] may not intersect.
63*fae548d3Szrj Zero length factors signify 0 significant bits: treat as 0.0.
64*fae548d3Szrj 0.0 factors do the right thing.
65*fae548d3Szrj Zero length product OK.
66*fae548d3Szrj
67*fae548d3Szrj I chose the ForTran accent "foo[bar]" instead of the C accent "*garply"
68*fae548d3Szrj because I felt the ForTran way was more intuitive. The C way would
69*fae548d3Szrj probably yield better code on most C compilers. Dean Elsner.
70*fae548d3Szrj (C style also gives deeper insight [to me] ... oh well ...) */
71*fae548d3Szrj
72*fae548d3Szrj void
flonum_multip(const FLONUM_TYPE * a,const FLONUM_TYPE * b,FLONUM_TYPE * product)73*fae548d3Szrj flonum_multip (const FLONUM_TYPE *a, const FLONUM_TYPE *b,
74*fae548d3Szrj FLONUM_TYPE *product)
75*fae548d3Szrj {
76*fae548d3Szrj int size_of_a; /* 0 origin */
77*fae548d3Szrj int size_of_b; /* 0 origin */
78*fae548d3Szrj int size_of_product; /* 0 origin */
79*fae548d3Szrj int size_of_sum; /* 0 origin */
80*fae548d3Szrj int extra_product_positions; /* 1 origin */
81*fae548d3Szrj unsigned long work;
82*fae548d3Szrj unsigned long carry;
83*fae548d3Szrj long exponent;
84*fae548d3Szrj LITTLENUM_TYPE *q;
85*fae548d3Szrj long significant; /* TRUE when we emit a non-0 littlenum */
86*fae548d3Szrj /* ForTran accent follows. */
87*fae548d3Szrj int P; /* Scan product low-order -> high. */
88*fae548d3Szrj int N; /* As in sum above. */
89*fae548d3Szrj int A; /* Which [] of a? */
90*fae548d3Szrj int B; /* Which [] of b? */
91*fae548d3Szrj
92*fae548d3Szrj if ((a->sign != '-' && a->sign != '+')
93*fae548d3Szrj || (b->sign != '-' && b->sign != '+'))
94*fae548d3Szrj {
95*fae548d3Szrj /* Got to fail somehow. Any suggestions? */
96*fae548d3Szrj product->sign = 0;
97*fae548d3Szrj return;
98*fae548d3Szrj }
99*fae548d3Szrj product->sign = (a->sign == b->sign) ? '+' : '-';
100*fae548d3Szrj size_of_a = a->leader - a->low;
101*fae548d3Szrj size_of_b = b->leader - b->low;
102*fae548d3Szrj exponent = a->exponent + b->exponent;
103*fae548d3Szrj size_of_product = product->high - product->low;
104*fae548d3Szrj size_of_sum = size_of_a + size_of_b;
105*fae548d3Szrj extra_product_positions = size_of_product - size_of_sum;
106*fae548d3Szrj if (extra_product_positions < 0)
107*fae548d3Szrj {
108*fae548d3Szrj P = extra_product_positions; /* P < 0 */
109*fae548d3Szrj exponent -= extra_product_positions; /* Increases exponent. */
110*fae548d3Szrj }
111*fae548d3Szrj else
112*fae548d3Szrj {
113*fae548d3Szrj P = 0;
114*fae548d3Szrj }
115*fae548d3Szrj carry = 0;
116*fae548d3Szrj significant = 0;
117*fae548d3Szrj for (N = 0; N <= size_of_sum; N++)
118*fae548d3Szrj {
119*fae548d3Szrj work = carry;
120*fae548d3Szrj carry = 0;
121*fae548d3Szrj for (A = 0; A <= N; A++)
122*fae548d3Szrj {
123*fae548d3Szrj B = N - A;
124*fae548d3Szrj if (A <= size_of_a && B <= size_of_b && B >= 0)
125*fae548d3Szrj {
126*fae548d3Szrj #ifdef TRACE
127*fae548d3Szrj printf ("a:low[%d.]=%04x b:low[%d.]=%04x work_before=%08x\n",
128*fae548d3Szrj A, a->low[A], B, b->low[B], work);
129*fae548d3Szrj #endif
130*fae548d3Szrj /* Watch out for sign extension! Without the casts, on
131*fae548d3Szrj the DEC Alpha, the multiplication result is *signed*
132*fae548d3Szrj int, which gets sign-extended to convert to the
133*fae548d3Szrj unsigned long! */
134*fae548d3Szrj work += (unsigned long) a->low[A] * (unsigned long) b->low[B];
135*fae548d3Szrj carry += work >> LITTLENUM_NUMBER_OF_BITS;
136*fae548d3Szrj work &= LITTLENUM_MASK;
137*fae548d3Szrj #ifdef TRACE
138*fae548d3Szrj printf ("work=%08x carry=%04x\n", work, carry);
139*fae548d3Szrj #endif
140*fae548d3Szrj }
141*fae548d3Szrj }
142*fae548d3Szrj significant |= work;
143*fae548d3Szrj if (significant || P < 0)
144*fae548d3Szrj {
145*fae548d3Szrj if (P >= 0)
146*fae548d3Szrj {
147*fae548d3Szrj product->low[P] = work;
148*fae548d3Szrj #ifdef TRACE
149*fae548d3Szrj printf ("P=%d. work[p]:=%04x\n", P, work);
150*fae548d3Szrj #endif
151*fae548d3Szrj }
152*fae548d3Szrj P++;
153*fae548d3Szrj }
154*fae548d3Szrj else
155*fae548d3Szrj {
156*fae548d3Szrj extra_product_positions++;
157*fae548d3Szrj exponent++;
158*fae548d3Szrj }
159*fae548d3Szrj }
160*fae548d3Szrj /* [P]-> position # size_of_sum + 1.
161*fae548d3Szrj This is where 'carry' should go. */
162*fae548d3Szrj #ifdef TRACE
163*fae548d3Szrj printf ("final carry =%04x\n", carry);
164*fae548d3Szrj #endif
165*fae548d3Szrj if (carry)
166*fae548d3Szrj {
167*fae548d3Szrj if (extra_product_positions > 0)
168*fae548d3Szrj product->low[P] = carry;
169*fae548d3Szrj else
170*fae548d3Szrj {
171*fae548d3Szrj /* No room at high order for carry littlenum. */
172*fae548d3Szrj /* Shift right 1 to make room for most significant littlenum. */
173*fae548d3Szrj exponent++;
174*fae548d3Szrj P--;
175*fae548d3Szrj for (q = product->low + P; q >= product->low; q--)
176*fae548d3Szrj {
177*fae548d3Szrj work = *q;
178*fae548d3Szrj *q = carry;
179*fae548d3Szrj carry = work;
180*fae548d3Szrj }
181*fae548d3Szrj }
182*fae548d3Szrj }
183*fae548d3Szrj else
184*fae548d3Szrj P--;
185*fae548d3Szrj product->leader = product->low + P;
186*fae548d3Szrj product->exponent = exponent;
187*fae548d3Szrj }
188