URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [arch/] [i386/] [math-emu/] [reg_add_sub.c] - Blame information for rev 1782

Details | Compare with Previous | View Log


/*---------------------------------------------------------------------------+
 |  reg_add_sub.c                                                            |
 |                                                                           |
 | Functions to add or subtract two registers and put the result in a third. |
 |                                                                           |
 | Copyright (C) 1992,1993                                                   |
 |                       W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
 |                       Australia.  E-mail   billm@vaxc.cc.monash.edu.au    |
 |                                                                           |
 |                                                                           |
 +---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------+
 | For each function, the destination may be any FPU_REG, including one of   |
 | the source FPU_REGs.                                                      |
 +---------------------------------------------------------------------------*/
 
#include "exception.h"
#include "reg_constant.h"
#include "fpu_emu.h"
#include "control_w.h"
#include "fpu_system.h"
 
 
int reg_add(FPU_REG const *a, FPU_REG const *b, FPU_REG *dest, int control_w)
{
  char saved_sign = dest->sign;
  int diff;
 
  if ( !(a->tag | b->tag) )
    {
      /* Both registers are valid */
      if (!(a->sign ^ b->sign))
        {
          /* signs are the same */
          dest->sign = a->sign;
          if ( reg_u_add(a, b, dest, control_w) )
            {
              dest->sign = saved_sign;
              return 1;
            }
          return 0;
        }
 
      /* The signs are different, so do a subtraction */
      diff = a->exp - b->exp;
      if (!diff)
        {
          diff = a->sigh - b->sigh;  /* Works only if ms bits are identical */
          if (!diff)
            {
              diff = a->sigl > b->sigl;
              if (!diff)
                diff = -(a->sigl < b->sigl);
            }
        }
 
      if (diff > 0)
        {
          dest->sign = a->sign;
          if ( reg_u_sub(a, b, dest, control_w) )
            {
              dest->sign = saved_sign;
              return 1;
            }
        }
      else if ( diff == 0 )
        {
#ifdef DENORM_OPERAND
          if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
              denormal_operand() )
            return 1;
#endif DENORM_OPERAND
          reg_move(&CONST_Z, dest);
          /* sign depends upon rounding mode */
          dest->sign = ((control_w & CW_RC) != RC_DOWN)
            ? SIGN_POS : SIGN_NEG;
        }
      else
        {
          dest->sign = b->sign;
          if ( reg_u_sub(b, a, dest, control_w) )
            {
              dest->sign = saved_sign;
              return 1;
            }
        }
      return 0;
    }
  else
    {
      if ( (a->tag == TW_NaN) || (b->tag == TW_NaN) )
        { return real_2op_NaN(a, b, dest); }
      else if (a->tag == TW_Zero)
        {
          if (b->tag == TW_Zero)
            {
              char different_signs = a->sign ^ b->sign;
              /* Both are zero, result will be zero. */
              reg_move(a, dest);
              if (different_signs)
                {
                  /* Signs are different. */
                  /* Sign of answer depends upon rounding mode. */
                  dest->sign = ((control_w & CW_RC) != RC_DOWN)
                    ? SIGN_POS : SIGN_NEG;
                }
            }
          else
            {
#ifdef DENORM_OPERAND
              if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
                  denormal_operand() )
                return 1;
#endif DENORM_OPERAND
              reg_move(b, dest);
            }
          return 0;
        }
      else if (b->tag == TW_Zero)
        {
#ifdef DENORM_OPERAND
          if ( (a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
              denormal_operand() )
            return 1;
#endif DENORM_OPERAND
          reg_move(a, dest); return 0;
        }
      else if (a->tag == TW_Infinity)
        {
          if (b->tag != TW_Infinity)
            {
#ifdef DENORM_OPERAND
              if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
                  denormal_operand() )
                return 1;
#endif DENORM_OPERAND
              reg_move(a, dest); return 0;
            }
          if (a->sign == b->sign)
            {
              /* They are both + or - infinity */
              reg_move(a, dest); return 0;
            }
          return arith_invalid(dest);   /* Infinity-Infinity is undefined. */
        }
      else if (b->tag == TW_Infinity)
        {
#ifdef DENORM_OPERAND
          if ( (a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
              denormal_operand() )
            return 1;
#endif DENORM_OPERAND
          reg_move(b, dest); return 0;
        }
    }
#ifdef PARANOID
  EXCEPTION(EX_INTERNAL|0x101);
#endif
  return 1;
}
 
 
/* Subtract b from a.  (a-b) -> dest */
int reg_sub(FPU_REG const *a, FPU_REG const *b, FPU_REG *dest, int control_w)
{
  char saved_sign = dest->sign;
  int diff;
 
  if ( !(a->tag | b->tag) )
    {
      /* Both registers are valid */
      diff = a->exp - b->exp;
      if (!diff)
        {
          diff = a->sigh - b->sigh;  /* Works only if ms bits are identical */
          if (!diff)
            {
              diff = a->sigl > b->sigl;
              if (!diff)
                diff = -(a->sigl < b->sigl);
            }
        }
 
      switch (a->sign*2 + b->sign)
        {
        case 0: /* P - P */
        case 3: /* N - N */
          if (diff > 0)
            {
              /* |a| > |b| */
              dest->sign = a->sign;
              if ( reg_u_sub(a, b, dest, control_w) )
                {
                  dest->sign = saved_sign;
                  return 1;
                }
              return 0;
            }
          else if ( diff == 0 )
            {
#ifdef DENORM_OPERAND
              if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
                  denormal_operand() )
                return 1;
#endif DENORM_OPERAND
              reg_move(&CONST_Z, dest);
              /* sign depends upon rounding mode */
              dest->sign = ((control_w & CW_RC) != RC_DOWN)
                ? SIGN_POS : SIGN_NEG;
            }
          else
            {
              dest->sign = a->sign ^ SIGN_POS^SIGN_NEG;
              if ( reg_u_sub(b, a, dest, control_w) )
                {
                  dest->sign = saved_sign;
                  return 1;
                }
            }
          break;
        case 1: /* P - N */
          dest->sign = SIGN_POS;
          if ( reg_u_add(a, b, dest, control_w) )
            {
              dest->sign = saved_sign;
              return 1;
            }
          break;
        case 2: /* N - P */
          dest->sign = SIGN_NEG;
          if ( reg_u_add(a, b, dest, control_w) )
            {
              dest->sign = saved_sign;
              return 1;
            }
          break;
        }
      return 0;
    }
  else
    {
      if ( (a->tag == TW_NaN) || (b->tag == TW_NaN) )
        { return real_2op_NaN(b, a, dest); }
      else if (b->tag == TW_Zero)
        {
          if (a->tag == TW_Zero)
            {
              char same_signs = !(a->sign ^ b->sign);
              /* Both are zero, result will be zero. */
              reg_move(a, dest); /* Answer for different signs. */
              if (same_signs)
                {
                  /* Sign depends upon rounding mode */
                  dest->sign = ((control_w & CW_RC) != RC_DOWN)
                    ? SIGN_POS : SIGN_NEG;
                }
            }
          else
            {
#ifdef DENORM_OPERAND
              if ( (a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
                  denormal_operand() )
                return 1;
#endif DENORM_OPERAND
              reg_move(a, dest);
            }
          return 0;
        }
      else if (a->tag == TW_Zero)
        {
#ifdef DENORM_OPERAND
          if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
              denormal_operand() )
            return 1;
#endif DENORM_OPERAND
          reg_move(b, dest);
          dest->sign ^= SIGN_POS^SIGN_NEG;
          return 0;
        }
      else if (a->tag == TW_Infinity)
        {
          if (b->tag != TW_Infinity)
            {
#ifdef DENORM_OPERAND
              if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
                  denormal_operand() )
                return 1;
#endif DENORM_OPERAND
              reg_move(a, dest); return 0;
            }
          /* Both args are Infinity */
          if (a->sign == b->sign)
            {
              /* Infinity-Infinity is undefined. */
              return arith_invalid(dest);
            }
          reg_move(a, dest);
          return 0;
        }
      else if (b->tag == TW_Infinity)
        {
#ifdef DENORM_OPERAND
          if ( (a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
              denormal_operand() )
            return 1;
#endif DENORM_OPERAND
          reg_move(b, dest);
          dest->sign ^= SIGN_POS^SIGN_NEG;
          return 0;
        }
    }
#ifdef PARANOID
  EXCEPTION(EX_INTERNAL|0x110);
#endif
  return 1;
}
 

Browse

Tools

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [arch/] [i386/] [math-emu/] [reg_add_sub.c] - Blame information for rev 1782

Line No.	Rev	Author	Line
1	1623	jcastillo	`/*---------------------------------------------------------------------------+`
2			`\| reg_add_sub.c \|`
3			`\| \|`
4			`\| Functions to add or subtract two registers and put the result in a third. \|`
5			`\| \|`
6			`\| Copyright (C) 1992,1993 \|`
7			`\| W. Metzenthen, 22 Parker St, Ormond, Vic 3163, \|`
8			`\| Australia. E-mail billm@vaxc.cc.monash.edu.au \|`
9			`\| \|`
10			`\| \|`
11			`+---------------------------------------------------------------------------*/`
12
13			`/*---------------------------------------------------------------------------+`
14			`\| For each function, the destination may be any FPU_REG, including one of \|`
15			`\| the source FPU_REGs. \|`
16			`+---------------------------------------------------------------------------*/`
17
18			`#include "exception.h"`
19			`#include "reg_constant.h"`
20			`#include "fpu_emu.h"`
21			`#include "control_w.h"`
22			`#include "fpu_system.h"`
23
24
25			`int reg_add(FPU_REG const a, FPU_REG const b, FPU_REG *dest, int control_w)`
26			`{`
27			`char saved_sign = dest->sign;`
28			`int diff;`
29
30			`if ( !(a->tag \| b->tag) )`
31			`{`
32			`/* Both registers are valid */`
33			`if (!(a->sign ^ b->sign))`
34			`{`
35			`/* signs are the same */`
36			`dest->sign = a->sign;`
37			`if ( reg_u_add(a, b, dest, control_w) )`
38			`{`
39			`dest->sign = saved_sign;`
40			`return 1;`
41			`}`
42			`return 0;`
43			`}`
44
45			`/* The signs are different, so do a subtraction */`
46			`diff = a->exp - b->exp;`
47			`if (!diff)`
48			`{`
49			`diff = a->sigh - b->sigh; /* Works only if ms bits are identical */`
50			`if (!diff)`
51			`{`
52			`diff = a->sigl > b->sigl;`
53			`if (!diff)`
54			`diff = -(a->sigl < b->sigl);`
55			`}`
56			`}`
57
58			`if (diff > 0)`
59			`{`
60			`dest->sign = a->sign;`
61			`if ( reg_u_sub(a, b, dest, control_w) )`
62			`{`
63			`dest->sign = saved_sign;`
64			`return 1;`
65			`}`
66			`}`
67			`else if ( diff == 0 )`
68			`{`
69			`#ifdef DENORM_OPERAND`
70			`if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&`
71			`denormal_operand() )`
72			`return 1;`
73			`#endif DENORM_OPERAND`
74			`reg_move(&CONST_Z, dest);`
75			`/* sign depends upon rounding mode */`
76			`dest->sign = ((control_w & CW_RC) != RC_DOWN)`
77			`? SIGN_POS : SIGN_NEG;`
78			`}`
79			`else`
80			`{`
81			`dest->sign = b->sign;`
82			`if ( reg_u_sub(b, a, dest, control_w) )`
83			`{`
84			`dest->sign = saved_sign;`
85			`return 1;`
86			`}`
87			`}`
88			`return 0;`
89			`}`
90			`else`
91			`{`
92			`if ( (a->tag == TW_NaN) \|\| (b->tag == TW_NaN) )`
93			`{ return real_2op_NaN(a, b, dest); }`
94			`else if (a->tag == TW_Zero)`
95			`{`
96			`if (b->tag == TW_Zero)`
97			`{`
98			`char different_signs = a->sign ^ b->sign;`
99			`/* Both are zero, result will be zero. */`
100			`reg_move(a, dest);`
101			`if (different_signs)`
102			`{`
103			`/* Signs are different. */`
104			`/* Sign of answer depends upon rounding mode. */`
105			`dest->sign = ((control_w & CW_RC) != RC_DOWN)`
106			`? SIGN_POS : SIGN_NEG;`
107			`}`
108			`}`
109			`else`
110			`{`
111			`#ifdef DENORM_OPERAND`
112			`if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&`
113			`denormal_operand() )`
114			`return 1;`
115			`#endif DENORM_OPERAND`
116			`reg_move(b, dest);`
117			`}`
118			`return 0;`
119			`}`
120			`else if (b->tag == TW_Zero)`
121			`{`
122			`#ifdef DENORM_OPERAND`
123			`if ( (a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&`
124			`denormal_operand() )`
125			`return 1;`
126			`#endif DENORM_OPERAND`
127			`reg_move(a, dest); return 0;`
128			`}`
129			`else if (a->tag == TW_Infinity)`
130			`{`
131			`if (b->tag != TW_Infinity)`
132			`{`
133			`#ifdef DENORM_OPERAND`
134			`if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&`
135			`denormal_operand() )`
136			`return 1;`
137			`#endif DENORM_OPERAND`
138			`reg_move(a, dest); return 0;`
139			`}`
140			`if (a->sign == b->sign)`
141			`{`
142			`/* They are both + or - infinity */`
143			`reg_move(a, dest); return 0;`
144			`}`
145			`return arith_invalid(dest); /* Infinity-Infinity is undefined. */`
146			`}`
147			`else if (b->tag == TW_Infinity)`
148			`{`
149			`#ifdef DENORM_OPERAND`
150			`if ( (a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&`
151			`denormal_operand() )`
152			`return 1;`
153			`#endif DENORM_OPERAND`
154			`reg_move(b, dest); return 0;`
155			`}`
156			`}`
157			`#ifdef PARANOID`
158			`EXCEPTION(EX_INTERNAL\|0x101);`
159			`#endif`
160			`return 1;`
161			`}`
162
163
164			`/* Subtract b from a. (a-b) -> dest */`
165			`int reg_sub(FPU_REG const a, FPU_REG const b, FPU_REG *dest, int control_w)`
166			`{`
167			`char saved_sign = dest->sign;`
168			`int diff;`
169
170			`if ( !(a->tag \| b->tag) )`
171			`{`
172			`/* Both registers are valid */`
173			`diff = a->exp - b->exp;`
174			`if (!diff)`
175			`{`
176			`diff = a->sigh - b->sigh; /* Works only if ms bits are identical */`
177			`if (!diff)`
178			`{`
179			`diff = a->sigl > b->sigl;`
180			`if (!diff)`
181			`diff = -(a->sigl < b->sigl);`
182			`}`
183			`}`
184
185			`switch (a->sign*2 + b->sign)`
186			`{`
187			`case 0: /* P - P */`
188			`case 3: /* N - N */`
189			`if (diff > 0)`
190			`{`
191			`/* \|a\| > \|b\| */`
192			`dest->sign = a->sign;`
193			`if ( reg_u_sub(a, b, dest, control_w) )`
194			`{`
195			`dest->sign = saved_sign;`
196			`return 1;`
197			`}`
198			`return 0;`
199			`}`
200			`else if ( diff == 0 )`
201			`{`
202			`#ifdef DENORM_OPERAND`
203			`if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&`
204			`denormal_operand() )`
205			`return 1;`
206			`#endif DENORM_OPERAND`
207			`reg_move(&CONST_Z, dest);`
208			`/* sign depends upon rounding mode */`
209			`dest->sign = ((control_w & CW_RC) != RC_DOWN)`
210			`? SIGN_POS : SIGN_NEG;`
211			`}`
212			`else`
213			`{`
214			`dest->sign = a->sign ^ SIGN_POS^SIGN_NEG;`
215			`if ( reg_u_sub(b, a, dest, control_w) )`
216			`{`
217			`dest->sign = saved_sign;`
218			`return 1;`
219			`}`
220			`}`
221			`break;`
222			`case 1: /* P - N */`
223			`dest->sign = SIGN_POS;`
224			`if ( reg_u_add(a, b, dest, control_w) )`
225			`{`
226			`dest->sign = saved_sign;`
227			`return 1;`
228			`}`
229			`break;`
230			`case 2: /* N - P */`
231			`dest->sign = SIGN_NEG;`
232			`if ( reg_u_add(a, b, dest, control_w) )`
233			`{`
234			`dest->sign = saved_sign;`
235			`return 1;`
236			`}`
237			`break;`
238			`}`
239			`return 0;`
240			`}`
241			`else`
242			`{`
243			`if ( (a->tag == TW_NaN) \|\| (b->tag == TW_NaN) )`
244			`{ return real_2op_NaN(b, a, dest); }`
245			`else if (b->tag == TW_Zero)`
246			`{`
247			`if (a->tag == TW_Zero)`
248			`{`
249			`char same_signs = !(a->sign ^ b->sign);`
250			`/* Both are zero, result will be zero. */`
251			`reg_move(a, dest); /* Answer for different signs. */`
252			`if (same_signs)`
253			`{`
254			`/* Sign depends upon rounding mode */`
255			`dest->sign = ((control_w & CW_RC) != RC_DOWN)`
256			`? SIGN_POS : SIGN_NEG;`
257			`}`
258			`}`
259			`else`
260			`{`
261			`#ifdef DENORM_OPERAND`
262			`if ( (a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&`
263			`denormal_operand() )`
264			`return 1;`
265			`#endif DENORM_OPERAND`
266			`reg_move(a, dest);`
267			`}`
268			`return 0;`
269			`}`
270			`else if (a->tag == TW_Zero)`
271			`{`
272			`#ifdef DENORM_OPERAND`
273			`if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&`
274			`denormal_operand() )`
275			`return 1;`
276			`#endif DENORM_OPERAND`
277			`reg_move(b, dest);`
278			`dest->sign ^= SIGN_POS^SIGN_NEG;`
279			`return 0;`
280			`}`
281			`else if (a->tag == TW_Infinity)`
282			`{`
283			`if (b->tag != TW_Infinity)`
284			`{`
285			`#ifdef DENORM_OPERAND`
286			`if ( (b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&`
287			`denormal_operand() )`
288			`return 1;`
289			`#endif DENORM_OPERAND`
290			`reg_move(a, dest); return 0;`
291			`}`
292			`/* Both args are Infinity */`
293			`if (a->sign == b->sign)`
294			`{`
295			`/* Infinity-Infinity is undefined. */`
296			`return arith_invalid(dest);`
297			`}`
298			`reg_move(a, dest);`
299			`return 0;`
300			`}`
301			`else if (b->tag == TW_Infinity)`
302			`{`
303			`#ifdef DENORM_OPERAND`
304			`if ( (a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&`
305			`denormal_operand() )`
306			`return 1;`
307			`#endif DENORM_OPERAND`
308			`reg_move(b, dest);`
309			`dest->sign ^= SIGN_POS^SIGN_NEG;`
310			`return 0;`
311			`}`
312			`}`
313			`#ifdef PARANOID`
314			`EXCEPTION(EX_INTERNAL\|0x110);`
315			`#endif`
316			`return 1;`
317			`}`
318