blob: 16ed796bad87f375b98e21e5804aa375c4648858 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001|
2| decbin.sa 3.3 12/19/90
3|
4| Description: Converts normalized packed bcd value pointed to by
5| register A6 to extended-precision value in FP0.
6|
7| Input: Normalized packed bcd value in ETEMP(a6).
8|
9| Output: Exact floating-point representation of the packed bcd value.
10|
11| Saves and Modifies: D2-D5
12|
13| Speed: The program decbin takes ??? cycles to execute.
14|
15| Object Size:
16|
17| External Reference(s): None.
18|
19| Algorithm:
20| Expected is a normal bcd (i.e. non-exceptional; all inf, zero,
21| and NaN operands are dispatched without entering this routine)
22| value in 68881/882 format at location ETEMP(A6).
23|
24| A1. Convert the bcd exponent to binary by successive adds and muls.
25| Set the sign according to SE. Subtract 16 to compensate
26| for the mantissa which is to be interpreted as 17 integer
27| digits, rather than 1 integer and 16 fraction digits.
28| Note: this operation can never overflow.
29|
30| A2. Convert the bcd mantissa to binary by successive
31| adds and muls in FP0. Set the sign according to SM.
32| The mantissa digits will be converted with the decimal point
33| assumed following the least-significant digit.
34| Note: this operation can never overflow.
35|
36| A3. Count the number of leading/trailing zeros in the
37| bcd string. If SE is positive, count the leading zeros;
38| if negative, count the trailing zeros. Set the adjusted
39| exponent equal to the exponent from A1 and the zero count
40| added if SM = 1 and subtracted if SM = 0. Scale the
41| mantissa the equivalent of forcing in the bcd value:
42|
43| SM = 0 a non-zero digit in the integer position
44| SM = 1 a non-zero digit in Mant0, lsd of the fraction
45|
46| this will insure that any value, regardless of its
47| representation (ex. 0.1E2, 1E1, 10E0, 100E-1), is converted
48| consistently.
49|
50| A4. Calculate the factor 10^exp in FP1 using a table of
51| 10^(2^n) values. To reduce the error in forming factors
52| greater than 10^27, a directed rounding scheme is used with
53| tables rounded to RN, RM, and RP, according to the table
54| in the comments of the pwrten section.
55|
56| A5. Form the final binary number by scaling the mantissa by
57| the exponent factor. This is done by multiplying the
58| mantissa in FP0 by the factor in FP1 if the adjusted
59| exponent sign is positive, and dividing FP0 by FP1 if
60| it is negative.
61|
62| Clean up and return. Check if the final mul or div resulted
63| in an inex2 exception. If so, set inex1 in the fpsr and
64| check if the inex1 exception is enabled. If so, set d7 upper
65| word to $0100. This will signal unimp.sa that an enabled inex1
66| exception occurred. Unimp will fix the stack.
67|
68
69| Copyright (C) Motorola, Inc. 1990
70| All Rights Reserved
71|
Matt Waddele00d82d2006-02-11 17:55:48 -080072| For details on the license for this file, please see the
73| file, README, in this same directory.
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75|DECBIN idnt 2,1 | Motorola 040 Floating Point Software Package
76
77 |section 8
78
79#include "fpsp.h"
80
81|
82| PTENRN, PTENRM, and PTENRP are arrays of powers of 10 rounded
83| to nearest, minus, and plus, respectively. The tables include
84| 10**{1,2,4,8,16,32,64,128,256,512,1024,2048,4096}. No rounding
85| is required until the power is greater than 27, however, all
86| tables include the first 5 for ease of indexing.
87|
88 |xref PTENRN
89 |xref PTENRM
90 |xref PTENRP
91
92RTABLE: .byte 0,0,0,0
93 .byte 2,3,2,3
94 .byte 2,3,3,2
95 .byte 3,2,2,3
96
97 .global decbin
98 .global calc_e
99 .global pwrten
100 .global calc_m
101 .global norm
102 .global ap_st_z
103 .global ap_st_n
104|
105 .set FNIBS,7
106 .set FSTRT,0
107|
108 .set ESTRT,4
109 .set EDIGITS,2 |
110|
111| Constants in single precision
112FZERO: .long 0x00000000
113FONE: .long 0x3F800000
114FTEN: .long 0x41200000
115
116 .set TEN,10
117
118|
119decbin:
120 | fmovel #0,FPCR ;clr real fpcr
121 moveml %d2-%d5,-(%a7)
122|
123| Calculate exponent:
124| 1. Copy bcd value in memory for use as a working copy.
125| 2. Calculate absolute value of exponent in d1 by mul and add.
126| 3. Correct for exponent sign.
127| 4. Subtract 16 to compensate for interpreting the mant as all integer digits.
128| (i.e., all digits assumed left of the decimal point.)
129|
130| Register usage:
131|
132| calc_e:
133| (*) d0: temp digit storage
134| (*) d1: accumulator for binary exponent
135| (*) d2: digit count
136| (*) d3: offset pointer
137| ( ) d4: first word of bcd
138| ( ) a0: pointer to working bcd value
139| ( ) a6: pointer to original bcd value
140| (*) FP_SCR1: working copy of original bcd value
141| (*) L_SCR1: copy of original exponent word
142|
143calc_e:
144 movel #EDIGITS,%d2 |# of nibbles (digits) in fraction part
145 moveql #ESTRT,%d3 |counter to pick up digits
146 leal FP_SCR1(%a6),%a0 |load tmp bcd storage address
147 movel ETEMP(%a6),(%a0) |save input bcd value
148 movel ETEMP_HI(%a6),4(%a0) |save words 2 and 3
149 movel ETEMP_LO(%a6),8(%a0) |and work with these
150 movel (%a0),%d4 |get first word of bcd
151 clrl %d1 |zero d1 for accumulator
152e_gd:
153 mulul #TEN,%d1 |mul partial product by one digit place
154 bfextu %d4{%d3:#4},%d0 |get the digit and zero extend into d0
155 addl %d0,%d1 |d1 = d1 + d0
156 addqb #4,%d3 |advance d3 to the next digit
157 dbf %d2,e_gd |if we have used all 3 digits, exit loop
158 btst #30,%d4 |get SE
159 beqs e_pos |don't negate if pos
160 negl %d1 |negate before subtracting
161e_pos:
162 subl #16,%d1 |sub to compensate for shift of mant
163 bges e_save |if still pos, do not neg
164 negl %d1 |now negative, make pos and set SE
165 orl #0x40000000,%d4 |set SE in d4,
166 orl #0x40000000,(%a0) |and in working bcd
167e_save:
168 movel %d1,L_SCR1(%a6) |save exp in memory
169|
170|
171| Calculate mantissa:
172| 1. Calculate absolute value of mantissa in fp0 by mul and add.
173| 2. Correct for mantissa sign.
174| (i.e., all digits assumed left of the decimal point.)
175|
176| Register usage:
177|
178| calc_m:
179| (*) d0: temp digit storage
180| (*) d1: lword counter
181| (*) d2: digit count
182| (*) d3: offset pointer
183| ( ) d4: words 2 and 3 of bcd
184| ( ) a0: pointer to working bcd value
185| ( ) a6: pointer to original bcd value
186| (*) fp0: mantissa accumulator
187| ( ) FP_SCR1: working copy of original bcd value
188| ( ) L_SCR1: copy of original exponent word
189|
190calc_m:
191 moveql #1,%d1 |word counter, init to 1
192 fmoves FZERO,%fp0 |accumulator
193|
194|
195| Since the packed number has a long word between the first & second parts,
196| get the integer digit then skip down & get the rest of the
197| mantissa. We will unroll the loop once.
198|
199 bfextu (%a0){#28:#4},%d0 |integer part is ls digit in long word
200 faddb %d0,%fp0 |add digit to sum in fp0
201|
202|
203| Get the rest of the mantissa.
204|
205loadlw:
206 movel (%a0,%d1.L*4),%d4 |load mantissa longword into d4
207 moveql #FSTRT,%d3 |counter to pick up digits
208 moveql #FNIBS,%d2 |reset number of digits per a0 ptr
209md2b:
210 fmuls FTEN,%fp0 |fp0 = fp0 * 10
211 bfextu %d4{%d3:#4},%d0 |get the digit and zero extend
212 faddb %d0,%fp0 |fp0 = fp0 + digit
213|
214|
215| If all the digits (8) in that long word have been converted (d2=0),
216| then inc d1 (=2) to point to the next long word and reset d3 to 0
217| to initialize the digit offset, and set d2 to 7 for the digit count;
218| else continue with this long word.
219|
220 addqb #4,%d3 |advance d3 to the next digit
221 dbf %d2,md2b |check for last digit in this lw
222nextlw:
223 addql #1,%d1 |inc lw pointer in mantissa
224 cmpl #2,%d1 |test for last lw
225 ble loadlw |if not, get last one
226
227|
228| Check the sign of the mant and make the value in fp0 the same sign.
229|
230m_sign:
231 btst #31,(%a0) |test sign of the mantissa
232 beq ap_st_z |if clear, go to append/strip zeros
233 fnegx %fp0 |if set, negate fp0
234
235|
236| Append/strip zeros:
237|
238| For adjusted exponents which have an absolute value greater than 27*,
239| this routine calculates the amount needed to normalize the mantissa
240| for the adjusted exponent. That number is subtracted from the exp
241| if the exp was positive, and added if it was negative. The purpose
242| of this is to reduce the value of the exponent and the possibility
243| of error in calculation of pwrten.
244|
245| 1. Branch on the sign of the adjusted exponent.
246| 2p.(positive exp)
247| 2. Check M16 and the digits in lwords 2 and 3 in descending order.
248| 3. Add one for each zero encountered until a non-zero digit.
249| 4. Subtract the count from the exp.
250| 5. Check if the exp has crossed zero in #3 above; make the exp abs
251| and set SE.
252| 6. Multiply the mantissa by 10**count.
253| 2n.(negative exp)
254| 2. Check the digits in lwords 3 and 2 in descending order.
255| 3. Add one for each zero encountered until a non-zero digit.
256| 4. Add the count to the exp.
257| 5. Check if the exp has crossed zero in #3 above; clear SE.
258| 6. Divide the mantissa by 10**count.
259|
260| *Why 27? If the adjusted exponent is within -28 < expA < 28, than
261| any adjustment due to append/strip zeros will drive the resultant
262| exponent towards zero. Since all pwrten constants with a power
263| of 27 or less are exact, there is no need to use this routine to
264| attempt to lessen the resultant exponent.
265|
266| Register usage:
267|
268| ap_st_z:
269| (*) d0: temp digit storage
270| (*) d1: zero count
271| (*) d2: digit count
272| (*) d3: offset pointer
273| ( ) d4: first word of bcd
274| (*) d5: lword counter
275| ( ) a0: pointer to working bcd value
276| ( ) FP_SCR1: working copy of original bcd value
277| ( ) L_SCR1: copy of original exponent word
278|
279|
280| First check the absolute value of the exponent to see if this
281| routine is necessary. If so, then check the sign of the exponent
282| and do append (+) or strip (-) zeros accordingly.
283| This section handles a positive adjusted exponent.
284|
285ap_st_z:
286 movel L_SCR1(%a6),%d1 |load expA for range test
287 cmpl #27,%d1 |test is with 27
288 ble pwrten |if abs(expA) <28, skip ap/st zeros
289 btst #30,(%a0) |check sign of exp
290 bne ap_st_n |if neg, go to neg side
291 clrl %d1 |zero count reg
292 movel (%a0),%d4 |load lword 1 to d4
293 bfextu %d4{#28:#4},%d0 |get M16 in d0
294 bnes ap_p_fx |if M16 is non-zero, go fix exp
295 addql #1,%d1 |inc zero count
296 moveql #1,%d5 |init lword counter
297 movel (%a0,%d5.L*4),%d4 |get lword 2 to d4
298 bnes ap_p_cl |if lw 2 is zero, skip it
299 addql #8,%d1 |and inc count by 8
300 addql #1,%d5 |inc lword counter
301 movel (%a0,%d5.L*4),%d4 |get lword 3 to d4
302ap_p_cl:
303 clrl %d3 |init offset reg
304 moveql #7,%d2 |init digit counter
305ap_p_gd:
306 bfextu %d4{%d3:#4},%d0 |get digit
307 bnes ap_p_fx |if non-zero, go to fix exp
308 addql #4,%d3 |point to next digit
309 addql #1,%d1 |inc digit counter
310 dbf %d2,ap_p_gd |get next digit
311ap_p_fx:
312 movel %d1,%d0 |copy counter to d2
313 movel L_SCR1(%a6),%d1 |get adjusted exp from memory
314 subl %d0,%d1 |subtract count from exp
315 bges ap_p_fm |if still pos, go to pwrten
316 negl %d1 |now its neg; get abs
317 movel (%a0),%d4 |load lword 1 to d4
318 orl #0x40000000,%d4 | and set SE in d4
319 orl #0x40000000,(%a0) | and in memory
320|
321| Calculate the mantissa multiplier to compensate for the striping of
322| zeros from the mantissa.
323|
324ap_p_fm:
325 movel #PTENRN,%a1 |get address of power-of-ten table
326 clrl %d3 |init table index
327 fmoves FONE,%fp1 |init fp1 to 1
328 moveql #3,%d2 |init d2 to count bits in counter
329ap_p_el:
330 asrl #1,%d0 |shift lsb into carry
331 bccs ap_p_en |if 1, mul fp1 by pwrten factor
332 fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no)
333ap_p_en:
334 addl #12,%d3 |inc d3 to next rtable entry
335 tstl %d0 |check if d0 is zero
336 bnes ap_p_el |if not, get next bit
337 fmulx %fp1,%fp0 |mul mantissa by 10**(no_bits_shifted)
338 bra pwrten |go calc pwrten
339|
340| This section handles a negative adjusted exponent.
341|
342ap_st_n:
343 clrl %d1 |clr counter
344 moveql #2,%d5 |set up d5 to point to lword 3
345 movel (%a0,%d5.L*4),%d4 |get lword 3
346 bnes ap_n_cl |if not zero, check digits
347 subl #1,%d5 |dec d5 to point to lword 2
348 addql #8,%d1 |inc counter by 8
349 movel (%a0,%d5.L*4),%d4 |get lword 2
350ap_n_cl:
351 movel #28,%d3 |point to last digit
352 moveql #7,%d2 |init digit counter
353ap_n_gd:
354 bfextu %d4{%d3:#4},%d0 |get digit
355 bnes ap_n_fx |if non-zero, go to exp fix
356 subql #4,%d3 |point to previous digit
357 addql #1,%d1 |inc digit counter
358 dbf %d2,ap_n_gd |get next digit
359ap_n_fx:
360 movel %d1,%d0 |copy counter to d0
361 movel L_SCR1(%a6),%d1 |get adjusted exp from memory
362 subl %d0,%d1 |subtract count from exp
363 bgts ap_n_fm |if still pos, go fix mantissa
364 negl %d1 |take abs of exp and clr SE
365 movel (%a0),%d4 |load lword 1 to d4
366 andl #0xbfffffff,%d4 | and clr SE in d4
367 andl #0xbfffffff,(%a0) | and in memory
368|
369| Calculate the mantissa multiplier to compensate for the appending of
370| zeros to the mantissa.
371|
372ap_n_fm:
373 movel #PTENRN,%a1 |get address of power-of-ten table
374 clrl %d3 |init table index
375 fmoves FONE,%fp1 |init fp1 to 1
376 moveql #3,%d2 |init d2 to count bits in counter
377ap_n_el:
378 asrl #1,%d0 |shift lsb into carry
379 bccs ap_n_en |if 1, mul fp1 by pwrten factor
380 fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no)
381ap_n_en:
382 addl #12,%d3 |inc d3 to next rtable entry
383 tstl %d0 |check if d0 is zero
384 bnes ap_n_el |if not, get next bit
385 fdivx %fp1,%fp0 |div mantissa by 10**(no_bits_shifted)
386|
387|
388| Calculate power-of-ten factor from adjusted and shifted exponent.
389|
390| Register usage:
391|
392| pwrten:
393| (*) d0: temp
394| ( ) d1: exponent
395| (*) d2: {FPCR[6:5],SM,SE} as index in RTABLE; temp
396| (*) d3: FPCR work copy
397| ( ) d4: first word of bcd
398| (*) a1: RTABLE pointer
399| calc_p:
400| (*) d0: temp
401| ( ) d1: exponent
402| (*) d3: PWRTxx table index
403| ( ) a0: pointer to working copy of bcd
404| (*) a1: PWRTxx pointer
405| (*) fp1: power-of-ten accumulator
406|
407| Pwrten calculates the exponent factor in the selected rounding mode
408| according to the following table:
409|
410| Sign of Mant Sign of Exp Rounding Mode PWRTEN Rounding Mode
411|
412| ANY ANY RN RN
413|
414| + + RP RP
415| - + RP RM
416| + - RP RM
417| - - RP RP
418|
419| + + RM RM
420| - + RM RP
421| + - RM RP
422| - - RM RM
423|
424| + + RZ RM
425| - + RZ RM
426| + - RZ RP
427| - - RZ RP
428|
429|
430pwrten:
431 movel USER_FPCR(%a6),%d3 |get user's FPCR
432 bfextu %d3{#26:#2},%d2 |isolate rounding mode bits
433 movel (%a0),%d4 |reload 1st bcd word to d4
434 asll #2,%d2 |format d2 to be
435 bfextu %d4{#0:#2},%d0 | {FPCR[6],FPCR[5],SM,SE}
436 addl %d0,%d2 |in d2 as index into RTABLE
437 leal RTABLE,%a1 |load rtable base
438 moveb (%a1,%d2),%d0 |load new rounding bits from table
439 clrl %d3 |clear d3 to force no exc and extended
440 bfins %d0,%d3{#26:#2} |stuff new rounding bits in FPCR
441 fmovel %d3,%FPCR |write new FPCR
442 asrl #1,%d0 |write correct PTENxx table
443 bccs not_rp |to a1
444 leal PTENRP,%a1 |it is RP
445 bras calc_p |go to init section
446not_rp:
447 asrl #1,%d0 |keep checking
448 bccs not_rm
449 leal PTENRM,%a1 |it is RM
450 bras calc_p |go to init section
451not_rm:
452 leal PTENRN,%a1 |it is RN
453calc_p:
454 movel %d1,%d0 |copy exp to d0;use d0
455 bpls no_neg |if exp is negative,
456 negl %d0 |invert it
457 orl #0x40000000,(%a0) |and set SE bit
458no_neg:
459 clrl %d3 |table index
460 fmoves FONE,%fp1 |init fp1 to 1
461e_loop:
462 asrl #1,%d0 |shift next bit into carry
463 bccs e_next |if zero, skip the mul
464 fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no)
465e_next:
466 addl #12,%d3 |inc d3 to next rtable entry
467 tstl %d0 |check if d0 is zero
468 bnes e_loop |not zero, continue shifting
469|
470|
471| Check the sign of the adjusted exp and make the value in fp0 the
472| same sign. If the exp was pos then multiply fp1*fp0;
473| else divide fp0/fp1.
474|
475| Register Usage:
476| norm:
477| ( ) a0: pointer to working bcd value
478| (*) fp0: mantissa accumulator
479| ( ) fp1: scaling factor - 10**(abs(exp))
480|
481norm:
482 btst #30,(%a0) |test the sign of the exponent
483 beqs mul |if clear, go to multiply
484div:
485 fdivx %fp1,%fp0 |exp is negative, so divide mant by exp
486 bras end_dec
487mul:
488 fmulx %fp1,%fp0 |exp is positive, so multiply by exp
489|
490|
491| Clean up and return with result in fp0.
492|
493| If the final mul/div in decbin incurred an inex exception,
494| it will be inex2, but will be reported as inex1 by get_op.
495|
496end_dec:
497 fmovel %FPSR,%d0 |get status register
498 bclrl #inex2_bit+8,%d0 |test for inex2 and clear it
499 fmovel %d0,%FPSR |return status reg w/o inex2
500 beqs no_exc |skip this if no exc
501 orl #inx1a_mask,USER_FPSR(%a6) |set inex1/ainex
502no_exc:
503 moveml (%a7)+,%d2-%d5
504 rts
505 |end