Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*---------------------------------------------------------------------------+
3 | reg_divide.c |
4 | |
5 | Divide one FPU_REG by another and put the result in a destination FPU_REG.|
6 | |
7 | Copyright (C) 1996 |
8 | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
9 | E-mail billm@jacobi.maths.monash.edu.au |
10 | |
11 | Return value is the tag of the answer, or-ed with FPU_Exception if |
12 | one was raised, or -1 on internal error. |
13 | |
14 +---------------------------------------------------------------------------*/
15
16/*---------------------------------------------------------------------------+
17 | The destination may be any FPU_REG, including one of the source FPU_REGs. |
18 +---------------------------------------------------------------------------*/
19
20#include "exception.h"
21#include "reg_constant.h"
22#include "fpu_emu.h"
23#include "fpu_system.h"
24
25/*
26 Divide one register by another and put the result into a third register.
27 */
28int FPU_div(int flags, int rm, int control_w)
29{
30 FPU_REG x, y;
31 FPU_REG const *a, *b, *st0_ptr, *st_ptr;
32 FPU_REG *dest;
33 u_char taga, tagb, signa, signb, sign, saved_sign;
34 int tag, deststnr;
35
36 if (flags & DEST_RM)
37 deststnr = rm;
38 else
39 deststnr = 0;
40
41 if (flags & REV) {
42 b = &st(0);
43 st0_ptr = b;
44 tagb = FPU_gettag0();
45 if (flags & LOADED) {
46 a = (FPU_REG *) rm;
47 taga = flags & 0x0f;
48 } else {
49 a = &st(rm);
50 st_ptr = a;
51 taga = FPU_gettagi(rm);
52 }
53 } else {
54 a = &st(0);
55 st0_ptr = a;
56 taga = FPU_gettag0();
57 if (flags & LOADED) {
58 b = (FPU_REG *) rm;
59 tagb = flags & 0x0f;
60 } else {
61 b = &st(rm);
62 st_ptr = b;
63 tagb = FPU_gettagi(rm);
64 }
65 }
66
67 signa = getsign(a);
68 signb = getsign(b);
69
70 sign = signa ^ signb;
71
72 dest = &st(deststnr);
73 saved_sign = getsign(dest);
74
75 if (!(taga | tagb)) {
76 /* Both regs Valid, this should be the most common case. */
77 reg_copy(a, &x);
78 reg_copy(b, &y);
79 setpositive(&x);
80 setpositive(&y);
81 tag = FPU_u_div(&x, &y, dest, control_w, sign);
82
83 if (tag < 0)
84 return tag;
85
86 FPU_settagi(deststnr, tag);
87 return tag;
88 }
89
90 if (taga == TAG_Special)
91 taga = FPU_Special(a);
92 if (tagb == TAG_Special)
93 tagb = FPU_Special(b);
94
95 if (((taga == TAG_Valid) && (tagb == TW_Denormal))
96 || ((taga == TW_Denormal) && (tagb == TAG_Valid))
97 || ((taga == TW_Denormal) && (tagb == TW_Denormal))) {
98 if (denormal_operand() < 0)
99 return FPU_Exception;
100
101 FPU_to_exp16(a, &x);
102 FPU_to_exp16(b, &y);
103 tag = FPU_u_div(&x, &y, dest, control_w, sign);
104 if (tag < 0)
105 return tag;
106
107 FPU_settagi(deststnr, tag);
108 return tag;
109 } else if ((taga <= TW_Denormal) && (tagb <= TW_Denormal)) {
110 if (tagb != TAG_Zero) {
111 /* Want to find Zero/Valid */
112 if (tagb == TW_Denormal) {
113 if (denormal_operand() < 0)
114 return FPU_Exception;
115 }
116
117 /* The result is zero. */
118 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
119 setsign(dest, sign);
120 return TAG_Zero;
121 }
122 /* We have an exception condition, either 0/0 or Valid/Zero. */
123 if (taga == TAG_Zero) {
124 /* 0/0 */
125 return arith_invalid(deststnr);
126 }
127 /* Valid/Zero */
128 return FPU_divide_by_zero(deststnr, sign);
129 }
130 /* Must have infinities, NaNs, etc */
131 else if ((taga == TW_NaN) || (tagb == TW_NaN)) {
132 if (flags & LOADED)
133 return real_2op_NaN((FPU_REG *) rm, flags & 0x0f, 0,
134 st0_ptr);
135
136 if (flags & DEST_RM) {
137 int tag;
138 tag = FPU_gettag0();
139 if (tag == TAG_Special)
140 tag = FPU_Special(st0_ptr);
141 return real_2op_NaN(st0_ptr, tag, rm,
142 (flags & REV) ? st0_ptr : &st(rm));
143 } else {
144 int tag;
145 tag = FPU_gettagi(rm);
146 if (tag == TAG_Special)
147 tag = FPU_Special(&st(rm));
148 return real_2op_NaN(&st(rm), tag, 0,
149 (flags & REV) ? st0_ptr : &st(rm));
150 }
151 } else if (taga == TW_Infinity) {
152 if (tagb == TW_Infinity) {
153 /* infinity/infinity */
154 return arith_invalid(deststnr);
155 } else {
156 /* tagb must be Valid or Zero */
157 if ((tagb == TW_Denormal) && (denormal_operand() < 0))
158 return FPU_Exception;
159
160 /* Infinity divided by Zero or Valid does
161 not raise and exception, but returns Infinity */
162 FPU_copy_to_regi(a, TAG_Special, deststnr);
163 setsign(dest, sign);
164 return taga;
165 }
166 } else if (tagb == TW_Infinity) {
167 if ((taga == TW_Denormal) && (denormal_operand() < 0))
168 return FPU_Exception;
169
170 /* The result is zero. */
171 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
172 setsign(dest, sign);
173 return TAG_Zero;
174 }
175#ifdef PARANOID
176 else {
177 EXCEPTION(EX_INTERNAL | 0x102);
178 return FPU_Exception;
179 }
180#endif /* PARANOID */
181
182 return 0;
183}
1/*---------------------------------------------------------------------------+
2 | reg_divide.c |
3 | |
4 | Divide one FPU_REG by another and put the result in a destination FPU_REG.|
5 | |
6 | Copyright (C) 1996 |
7 | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
8 | E-mail billm@jacobi.maths.monash.edu.au |
9 | |
10 | Return value is the tag of the answer, or-ed with FPU_Exception if |
11 | one was raised, or -1 on internal error. |
12 | |
13 +---------------------------------------------------------------------------*/
14
15/*---------------------------------------------------------------------------+
16 | The destination may be any FPU_REG, including one of the source FPU_REGs. |
17 +---------------------------------------------------------------------------*/
18
19#include "exception.h"
20#include "reg_constant.h"
21#include "fpu_emu.h"
22#include "fpu_system.h"
23
24/*
25 Divide one register by another and put the result into a third register.
26 */
27int FPU_div(int flags, int rm, int control_w)
28{
29 FPU_REG x, y;
30 FPU_REG const *a, *b, *st0_ptr, *st_ptr;
31 FPU_REG *dest;
32 u_char taga, tagb, signa, signb, sign, saved_sign;
33 int tag, deststnr;
34
35 if (flags & DEST_RM)
36 deststnr = rm;
37 else
38 deststnr = 0;
39
40 if (flags & REV) {
41 b = &st(0);
42 st0_ptr = b;
43 tagb = FPU_gettag0();
44 if (flags & LOADED) {
45 a = (FPU_REG *) rm;
46 taga = flags & 0x0f;
47 } else {
48 a = &st(rm);
49 st_ptr = a;
50 taga = FPU_gettagi(rm);
51 }
52 } else {
53 a = &st(0);
54 st0_ptr = a;
55 taga = FPU_gettag0();
56 if (flags & LOADED) {
57 b = (FPU_REG *) rm;
58 tagb = flags & 0x0f;
59 } else {
60 b = &st(rm);
61 st_ptr = b;
62 tagb = FPU_gettagi(rm);
63 }
64 }
65
66 signa = getsign(a);
67 signb = getsign(b);
68
69 sign = signa ^ signb;
70
71 dest = &st(deststnr);
72 saved_sign = getsign(dest);
73
74 if (!(taga | tagb)) {
75 /* Both regs Valid, this should be the most common case. */
76 reg_copy(a, &x);
77 reg_copy(b, &y);
78 setpositive(&x);
79 setpositive(&y);
80 tag = FPU_u_div(&x, &y, dest, control_w, sign);
81
82 if (tag < 0)
83 return tag;
84
85 FPU_settagi(deststnr, tag);
86 return tag;
87 }
88
89 if (taga == TAG_Special)
90 taga = FPU_Special(a);
91 if (tagb == TAG_Special)
92 tagb = FPU_Special(b);
93
94 if (((taga == TAG_Valid) && (tagb == TW_Denormal))
95 || ((taga == TW_Denormal) && (tagb == TAG_Valid))
96 || ((taga == TW_Denormal) && (tagb == TW_Denormal))) {
97 if (denormal_operand() < 0)
98 return FPU_Exception;
99
100 FPU_to_exp16(a, &x);
101 FPU_to_exp16(b, &y);
102 tag = FPU_u_div(&x, &y, dest, control_w, sign);
103 if (tag < 0)
104 return tag;
105
106 FPU_settagi(deststnr, tag);
107 return tag;
108 } else if ((taga <= TW_Denormal) && (tagb <= TW_Denormal)) {
109 if (tagb != TAG_Zero) {
110 /* Want to find Zero/Valid */
111 if (tagb == TW_Denormal) {
112 if (denormal_operand() < 0)
113 return FPU_Exception;
114 }
115
116 /* The result is zero. */
117 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
118 setsign(dest, sign);
119 return TAG_Zero;
120 }
121 /* We have an exception condition, either 0/0 or Valid/Zero. */
122 if (taga == TAG_Zero) {
123 /* 0/0 */
124 return arith_invalid(deststnr);
125 }
126 /* Valid/Zero */
127 return FPU_divide_by_zero(deststnr, sign);
128 }
129 /* Must have infinities, NaNs, etc */
130 else if ((taga == TW_NaN) || (tagb == TW_NaN)) {
131 if (flags & LOADED)
132 return real_2op_NaN((FPU_REG *) rm, flags & 0x0f, 0,
133 st0_ptr);
134
135 if (flags & DEST_RM) {
136 int tag;
137 tag = FPU_gettag0();
138 if (tag == TAG_Special)
139 tag = FPU_Special(st0_ptr);
140 return real_2op_NaN(st0_ptr, tag, rm,
141 (flags & REV) ? st0_ptr : &st(rm));
142 } else {
143 int tag;
144 tag = FPU_gettagi(rm);
145 if (tag == TAG_Special)
146 tag = FPU_Special(&st(rm));
147 return real_2op_NaN(&st(rm), tag, 0,
148 (flags & REV) ? st0_ptr : &st(rm));
149 }
150 } else if (taga == TW_Infinity) {
151 if (tagb == TW_Infinity) {
152 /* infinity/infinity */
153 return arith_invalid(deststnr);
154 } else {
155 /* tagb must be Valid or Zero */
156 if ((tagb == TW_Denormal) && (denormal_operand() < 0))
157 return FPU_Exception;
158
159 /* Infinity divided by Zero or Valid does
160 not raise and exception, but returns Infinity */
161 FPU_copy_to_regi(a, TAG_Special, deststnr);
162 setsign(dest, sign);
163 return taga;
164 }
165 } else if (tagb == TW_Infinity) {
166 if ((taga == TW_Denormal) && (denormal_operand() < 0))
167 return FPU_Exception;
168
169 /* The result is zero. */
170 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
171 setsign(dest, sign);
172 return TAG_Zero;
173 }
174#ifdef PARANOID
175 else {
176 EXCEPTION(EX_INTERNAL | 0x102);
177 return FPU_Exception;
178 }
179#endif /* PARANOID */
180
181 return 0;
182}