1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
/* $OpenBSD: n_support.S,v 1.18 2013/07/05 21:10:50 miod Exp $ */
/* $NetBSD: n_support.S,v 1.1 1995/10/10 23:40:30 ragge Exp $ */
/*
* Copyright (c) 1985, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)support.s 8.1 (Berkeley) 6/4/93
*/
#include <machine/asm.h>
#include <sys/errno.h>
/*
* copysign(x,y),
* copysignf(x,y),
* logb(x),
* logbf(x),
* scalbn(x,N),
* remainder(x,y),
* Coded in vax assembly language by K.C. Ng, 3/14/85.
* Revised by K.C. Ng on 4/9/85.
* Float versions by M.V. on 11/19/08.
*/
/*
* double
* copysign(double x, double y)
*/
STRONG_ALIAS(copysignl,copysign)
ENTRY(copysign, R2)
movq 4(%ap),%r0 # load x into r0
bicw3 $0x807f,%r0,%r2 # mask off the exponent of x
beql Lz # if zero or reserved op then return x
bicw3 $0x7fff,12(%ap),%r2 # copy the sign bit of y into r2
bicw2 $0x8000,%r0 # replace x by |x|
bisw2 %r2,%r0 # copy the sign bit of y to x
Lz: ret
/*
* float
* copysignf(float x, float y)
*/
ENTRY(copysignf, R2)
movl 4(%ap),%r0 # load x into r0
bicw3 $0x807f,%r0,%r2 # mask off the exponent of x
beql Fz # if zero or reserved op then return x
bicw3 $0x7fff,8(%ap),%r2 # copy the sign bit of y into r2
bicw2 $0x8000,%r0 # replace x by |x|
bisw2 %r2,%r0 # copy the sign bit of y to x
Fz: ret
/*
* double
* logb(double x)
*/
STRONG_ALIAS(logbl,logb)
ENTRY(logb, 0)
bicl3 $0xffff807f,4(%ap),%r0 # mask off the exponent of x
beql Ln
ashl $-7,%r0,%r0 # get the bias exponent
subl2 $129,%r0 # get the unbias exponent
cvtld %r0,%r0 # return the answer in double
ret
Ln: movq 4(%ap),%r0 # r0:1 = x (zero or reserved op)
bneq 1f # simply return if reserved op
movq $0x0000fe00ffffcfff,%r0 # -2147483647.0
1: ret
/*
* float
* logbf(float x)
*/
ENTRY(logbf, 0)
bicl3 $0xffff807f,4(%ap),%r0 # mask off the exponent of x
beql Fn
ashl $-7,%r0,%r0 # get the bias exponent
subl2 $129,%r0 # get the unbias exponent
cvtlf %r0,%r0 # return the answer in float
ret
Fn: movl 4(%ap),%r0 # r0:1 = x (zero or reserved op)
bneq 1f # simply return if reserved op
movl $0x0000d000,%r0 # -2147483647.0
1: ret
/*
* double
* scalbn(double x, int N)
*/
STRONG_ALIAS(scalbnl,scalbn)
ENTRY(scalbn, R2|R3)
movq 4(%ap),%r0
bicl3 $0xffff807f,%r0,%r3
beql ret1 # 0 or reserved operand
movl 12(%ap),%r2
cmpl %r2,$0x12c
bgeq ovfl
cmpl %r2,$-0x12c
bleq unfl
ashl $7,%r2,%r2
addl2 %r2,%r3
bleq unfl
cmpl %r3,$0x8000
bgeq ovfl
addl2 %r2,%r0
ret
ovfl: pushl $ERANGE
calls $1,_C_LABEL(infnan) # if it returns
bicw3 $0x7fff,4(%ap),%r2 # get the sign of input arg
bisw2 %r2,%r0 # re-attach the sign to r0/1
ret
unfl: movq $0,%r0
ret1: ret
/*
* REMAINDER(X,Y)
* RETURN X REM Y =X-N*Y, N=[X/Y] ROUNDED (ROUNDED TO EVEN IN THE HALF WAY CASE)
* DOUBLE PRECISION (VAX D format 56 bits)
* CODED IN VAX ASSEMBLY LANGUAGE BY K.C. NG, 4/8/85.
*/
ALTENTRY(drem)
ENTRY(remainder, R2|R3|R4|R5|R6|R7|R8|R9|R10|R11)
subl2 $12,%sp
movq 4(%ap),%r0 #r0=x
movq 12(%ap),%r2 #r2=y
jeql Rop #if y=0 then generate reserved op fault
bicw3 $0x007f,%r0,%r4 #check if x is Rop
cmpw %r4,$0x8000
jeql Ret #if x is Rop then return Rop
bicl3 $0x007f,%r2,%r4 #check if y is Rop
cmpw %r4,$0x8000
jeql Ret #if y is Rop then return Rop
bicw2 $0x8000,%r2 #y := |y|
movw $0,-4(%fp) #-4(fp) = nx := 0
cmpw %r2,$0x1c80 #yexp ? 57
bgtr C1 #if yexp > 57 goto C1
addw2 $0x1c80,%r2 #scale up y by 2**57
movw $0x1c80,-4(%fp) #nx := 57 (exponent field)
C1:
movw -4(%fp),-8(%fp) #-8(fp) = nf := nx
bicw3 $0x7fff,%r0,-12(%fp) #-12(fp) = sign of x
bicw2 $0x8000,%r0 #x := |x|
movq %r2,%r10 #y1 := y
bicl2 $0xffff07ff,%r11 #clear the last 27 bits of y1
loop:
cmpd %r0,%r2 #x ? y
bleq E1 #if x <= y goto E1
/* begin argument reduction */
movq %r2,%r4 #t =y
movq %r10,%r6 #t1=y1
bicw3 $0x807f,%r0,%r8 #xexp= exponent of x
bicw3 $0x807f,%r2,%r9 #yexp= exponent fo y
subw2 %r9,%r8 #xexp-yexp
subw2 $0x0c80,%r8 #k=xexp-yexp-25(exponent bit field)
blss C2 #if k<0 goto C2
addw2 %r8,%r4 #t +=k
addw2 %r8,%r6 #t1+=k, scale up t and t1
C2:
divd3 %r4,%r0,%r8 #x/t
cvtdl %r8,%r8 #n=[x/t] truncated
cvtld %r8,%r8 #float(n)
subd2 %r6,%r4 #t:=t-t1
muld2 %r8,%r4 #n*(t-t1)
muld2 %r8,%r6 #n*t1
subd2 %r6,%r0 #x-n*t1
subd2 %r4,%r0 #(x-n*t1)-n*(t-t1)
brb loop
E1:
movw -4(%fp),%r6 #r6=nx
beql C3 #if nx=0 goto C3
addw2 %r6,%r0 #x:=x*2**57 scale up x by nx
movw $0,-4(%fp) #clear nx
brb loop
C3:
movq %r2,%r4 #r4 = y
subw2 $0x80,%r4 #r4 = y/2
cmpd %r0,%r4 #x:y/2
blss E2 #if x < y/2 goto E2
bgtr C4 #if x > y/2 goto C4
cvtdl %r8,%r8 #ifix(float(n))
blbc %r8,E2 #if the last bit is zero, goto E2
C4:
subd2 %r2,%r0 #x-y
E2:
xorw2 -12(%fp),%r0 #x^sign (exclusive or)
movw -8(%fp),%r6 #r6=nf
bicw3 $0x807f,%r0,%r8 #r8=exponent of x
bicw2 $0x7f80,%r0 #clear the exponent of x
subw2 %r6,%r8 #r8=xexp-nf
bgtr C5 #if xexp-nf is positive goto C5
movw $0,%r8 #clear r8
movq $0,%r0 #x underflow to zero
C5:
bisw2 %r8,%r0 #put r8 into exponent field of x
ret
Rop: #Reserved operand
pushl $EDOM
calls $1,_C_LABEL(infnan) #generate reserved op fault
ret
Ret:
movq $0x8000,%r0 #propagate reserved op
ret
|
