开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
op-common.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：25k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

op-common.h：源码内容
  1. /* Software floating-point emulation. Common operations.
  2.    Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
  3.    This file is part of the GNU C Library.
  4.    Contributed by Richard Henderson (rth@cygnus.com),
  5.   Jakub Jelinek (jj@ultra.linux.cz),
  6.   David S. Miller (davem@redhat.com) and
  7.   Peter Maydell (pmaydell@chiark.greenend.org.uk).
  9.    The GNU C Library is free software; you can redistribute it and/or
  10.    modify it under the terms of the GNU Library General Public License as
  11.    published by the Free Software Foundation; either version 2 of the
  12.    License, or (at your option) any later version.
  14.    The GNU C Library is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17.    Library General Public License for more details.
  19.    You should have received a copy of the GNU Library General Public
  20.    License along with the GNU C Library; see the file COPYING.LIB.  If
  21.    not, write to the Free Software Foundation, Inc.,
  22.    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  24. #ifndef __MATH_EMU_OP_COMMON_H__
  25. #define __MATH_EMU_OP_COMMON_H__
  27. #define _FP_DECL(wc, X)
  28.   _FP_I_TYPE X##_c, X##_s, X##_e;
  29.   _FP_FRAC_DECL_##wc(X)
  31. /*
  32.  * Finish truely unpacking a native fp value by classifying the kind
  33.  * of fp value and normalizing both the exponent and the fraction.
  34.  */
  36. #define _FP_UNPACK_CANONICAL(fs, wc, X)
  37. do {
  38.   switch (X##_e)
  39.   {
  40.   default:
  41.     _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_IMPLBIT_##fs;
  42.     _FP_FRAC_SLL_##wc(X, _FP_WORKBITS);
  43.     X##_e -= _FP_EXPBIAS_##fs;
  44.     X##_c = FP_CLS_NORMAL;
  45.     break;
  47.   case 0:
  48.     if (_FP_FRAC_ZEROP_##wc(X))
  49.       X##_c = FP_CLS_ZERO;
  50.     else
  51.       {
  52. /* a denormalized number */
  53. _FP_I_TYPE _shift;
  54. _FP_FRAC_CLZ_##wc(_shift, X);
  55. _shift -= _FP_FRACXBITS_##fs;
  56. _FP_FRAC_SLL_##wc(X, (_shift+_FP_WORKBITS));
  57. X##_e -= _FP_EXPBIAS_##fs - 1 + _shift;
  58. X##_c = FP_CLS_NORMAL;
  59. FP_SET_EXCEPTION(FP_EX_DENORM);
  60. if (FP_DENORM_ZERO)
  61.   {
  62.     FP_SET_EXCEPTION(FP_EX_INEXACT);
  63.     X##_c = FP_CLS_ZERO;
  64.   }
  65.       }
  66.     break;
  68.   case _FP_EXPMAX_##fs:
  69.     if (_FP_FRAC_ZEROP_##wc(X))
  70.       X##_c = FP_CLS_INF;
  71.     else
  72.       {
  73. X##_c = FP_CLS_NAN;
  74. /* Check for signaling NaN */
  75. if (!(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs))
  76.   FP_SET_EXCEPTION(FP_EX_INVALID);
  77.       }
  78.     break;
  79.   }
  80. } while (0)
  82. /*
  83.  * Before packing the bits back into the native fp result, take care
  84.  * of such mundane things as rounding and overflow.  Also, for some
  85.  * kinds of fp values, the original parts may not have been fully
  86.  * extracted -- but that is ok, we can regenerate them now.
  87.  */
  89. #define _FP_PACK_CANONICAL(fs, wc, X)
  90. do {
  91.   switch (X##_c)
  92.   {
  93.   case FP_CLS_NORMAL:
  94.     X##_e += _FP_EXPBIAS_##fs;
  95.     if (X##_e > 0)
  96.       {
  97. _FP_ROUND(wc, X);
  98. if (_FP_FRAC_OVERP_##wc(fs, X))
  99.   {
  100.     _FP_FRAC_SRL_##wc(X, (_FP_WORKBITS+1));
  101.     X##_e++;
  102.   }
  103. else
  104.   _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);
  105. if (X##_e >= _FP_EXPMAX_##fs)
  106.   {
  107.     /* overflow */
  108.     switch (FP_ROUNDMODE)
  109.       {
  110.       case FP_RND_NEAREST:
  111. X##_c = FP_CLS_INF;
  112. break;
  113.       case FP_RND_PINF:
  114. if (!X##_s) X##_c = FP_CLS_INF;
  115. break;
  116.       case FP_RND_MINF:
  117. if (X##_s) X##_c = FP_CLS_INF;
  118. break;
  119.       }
  120.     if (X##_c == FP_CLS_INF)
  121.       {
  122. /* Overflow to infinity */
  123. X##_e = _FP_EXPMAX_##fs;
  124. _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);
  125.       }
  126.     else
  127.       {
  128. /* Overflow to maximum normal */
  129. X##_e = _FP_EXPMAX_##fs - 1;
  130. _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc);
  131.       }
  132.     FP_SET_EXCEPTION(FP_EX_OVERFLOW);
  133.             FP_SET_EXCEPTION(FP_EX_INEXACT);
  134.   }
  135.       }
  136.     else
  137.       {
  138. /* we've got a denormalized number */
  139. X##_e = -X##_e + 1;
  140. if (X##_e <= _FP_WFRACBITS_##fs)
  141.   {
  142.     _FP_FRAC_SRS_##wc(X, X##_e, _FP_WFRACBITS_##fs);
  143.     _FP_ROUND(wc, X);
  144.     if (_FP_FRAC_HIGH_##fs(X)
  145. & (_FP_OVERFLOW_##fs >> 1))
  146.       {
  147.         X##_e = 1;
  148.         _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);
  149.       }
  150.     else
  151.       {
  152. X##_e = 0;
  153. _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);
  154. FP_SET_EXCEPTION(FP_EX_UNDERFLOW);
  155.       }
  156.   }
  157. else
  158.   {
  159.     /* underflow to zero */
  160.     X##_e = 0;
  161.     if (!_FP_FRAC_ZEROP_##wc(X))
  162.       {
  163.         _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);
  164.         _FP_ROUND(wc, X);
  165.         _FP_FRAC_LOW_##wc(X) >>= (_FP_WORKBITS);
  166.       }
  167.     FP_SET_EXCEPTION(FP_EX_UNDERFLOW);
  168.   }
  169.       }
  170.     break;
  172.   case FP_CLS_ZERO:
  173.     X##_e = 0;
  174.     _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);
  175.     break;
  177.   case FP_CLS_INF:
  178.     X##_e = _FP_EXPMAX_##fs;
  179.     _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);
  180.     break;
  182.   case FP_CLS_NAN:
  183.     X##_e = _FP_EXPMAX_##fs;
  184.     if (!_FP_KEEPNANFRACP)
  185.       {
  186. _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);
  187. X##_s = _FP_NANSIGN_##fs;
  188.       }
  189.     else
  190.       _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs;
  191.     break;
  192.   }
  193. } while (0)
  195. /* This one accepts raw argument and not cooked,  returns
  196.  * 1 if X is a signaling NaN.
  197.  */
  198. #define _FP_ISSIGNAN(fs, wc, X)
  199. ({
  200.   int __ret = 0;
  201.   if (X##_e == _FP_EXPMAX_##fs)
  202.     {
  203.       if (!_FP_FRAC_ZEROP_##wc(X)
  204.   && !(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs))
  205. __ret = 1;
  206.     }
  207.   __ret;
  208. })
  214. /*
  215.  * Main addition routine.  The input values should be cooked.
  216.  */
  218. #define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP)      
  219. do {      
  220.   switch (_FP_CLS_COMBINE(X##_c, Y##_c))      
  221.   {      
  222.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL):      
  223.     {      
  224.       /* shift the smaller number so that its exponent matches the larger */ 
  225.       _FP_I_TYPE diff = X##_e - Y##_e;      
  226.      
  227.       if (diff < 0)      
  228. {      
  229.   diff = -diff;      
  230.   if (diff <= _FP_WFRACBITS_##fs)      
  231.     _FP_FRAC_SRS_##wc(X, diff, _FP_WFRACBITS_##fs);      
  232.   else if (!_FP_FRAC_ZEROP_##wc(X))      
  233.     _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);      
  234.   R##_e = Y##_e;      
  235. }      
  236.       else      
  237. {      
  238.   if (diff > 0)      
  239.     {      
  240.       if (diff <= _FP_WFRACBITS_##fs)      
  241.         _FP_FRAC_SRS_##wc(Y, diff, _FP_WFRACBITS_##fs);      
  242.       else if (!_FP_FRAC_ZEROP_##wc(Y))      
  243.         _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc);      
  244.     }      
  245.   R##_e = X##_e;      
  246. }      
  247.      
  248.       R##_c = FP_CLS_NORMAL;      
  249.      
  250.       if (X##_s == Y##_s)      
  251. {      
  252.   R##_s = X##_s;      
  253.   _FP_FRAC_ADD_##wc(R, X, Y);      
  254.   if (_FP_FRAC_OVERP_##wc(fs, R))      
  255.     {      
  256.       _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs);      
  257.       R##_e++;      
  258.     }      
  259. }      
  260.       else      
  261. {      
  262.   R##_s = X##_s;      
  263.   _FP_FRAC_SUB_##wc(R, X, Y);      
  264.   if (_FP_FRAC_ZEROP_##wc(R))      
  265.     {      
  266.       /* return an exact zero */      
  267.       if (FP_ROUNDMODE == FP_RND_MINF)      
  268. R##_s |= Y##_s;      
  269.       else      
  270. R##_s &= Y##_s;      
  271.       R##_c = FP_CLS_ZERO;      
  272.     }      
  273.   else      
  274.     {      
  275.       if (_FP_FRAC_NEGP_##wc(R))      
  276. {      
  277.   _FP_FRAC_SUB_##wc(R, Y, X);      
  278.   R##_s = Y##_s;      
  279. }      
  280.      
  281.       /* renormalize after subtraction */      
  282.       _FP_FRAC_CLZ_##wc(diff, R);      
  283.       diff -= _FP_WFRACXBITS_##fs;      
  284.       if (diff)      
  285. {      
  286.   R##_e -= diff;      
  287.   _FP_FRAC_SLL_##wc(R, diff);      
  288. }      
  289.     }      
  290. }      
  291.       break;      
  292.     }      
  293.      
  294.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN):      
  295.     _FP_CHOOSENAN(fs, wc, R, X, Y, OP);      
  296.     break;      
  297.      
  298.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO):      
  299.     R##_e = X##_e;      
  300.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL):      
  301.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF):      
  302.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO):      
  303.     _FP_FRAC_COPY_##wc(R, X);      
  304.     R##_s = X##_s;      
  305.     R##_c = X##_c;      
  306.     break;      
  307.      
  308.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL):      
  309.     R##_e = Y##_e;      
  310.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN):      
  311.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN):      
  312.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN):      
  313.     _FP_FRAC_COPY_##wc(R, Y);      
  314.     R##_s = Y##_s;      
  315.     R##_c = Y##_c;      
  316.     break;      
  317.      
  318.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF):      
  319.     if (X##_s != Y##_s)      
  320.       {      
  321. /* +INF + -INF => NAN */      
  322. _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs);      
  323. R##_s = _FP_NANSIGN_##fs;      
  324. R##_c = FP_CLS_NAN;      
  325. FP_SET_EXCEPTION(FP_EX_INVALID);      
  326. break;      
  327.       }      
  328.     /* FALLTHRU */      
  329.      
  330.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL):      
  331.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO):      
  332.     R##_s = X##_s;      
  333.     R##_c = FP_CLS_INF;      
  334.     break;      
  335.      
  336.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF):      
  337.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF):      
  338.     R##_s = Y##_s;      
  339.     R##_c = FP_CLS_INF;      
  340.     break;      
  341.      
  342.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO):      
  343.     /* make sure the sign is correct */      
  344.     if (FP_ROUNDMODE == FP_RND_MINF)      
  345.       R##_s = X##_s | Y##_s;      
  346.     else      
  347.       R##_s = X##_s & Y##_s;      
  348.     R##_c = FP_CLS_ZERO;      
  349.     break;      
  350.      
  351.   default:      
  352.     abort();      
  353.   }      
  354. } while (0)
  356. #define _FP_ADD(fs, wc, R, X, Y) _FP_ADD_INTERNAL(fs, wc, R, X, Y, '+')
  357. #define _FP_SUB(fs, wc, R, X, Y)      
  358.   do {      
  359.     if (Y##_c != FP_CLS_NAN) Y##_s ^= 1;      
  360.     _FP_ADD_INTERNAL(fs, wc, R, X, Y, '-');      
  361.   } while (0)
  364. /*
  365.  * Main negation routine.  FIXME -- when we care about setting exception
  366.  * bits reliably, this will not do.  We should examine all of the fp classes.
  367.  */
  369. #define _FP_NEG(fs, wc, R, X)
  370.   do {
  371.     _FP_FRAC_COPY_##wc(R, X);
  372.     R##_c = X##_c;
  373.     R##_e = X##_e;
  374.     R##_s = 1 ^ X##_s;
  375.   } while (0)
  378. /*
  379.  * Main multiplication routine.  The input values should be cooked.
  380.  */
  382. #define _FP_MUL(fs, wc, R, X, Y)
  383. do {
  384.   R##_s = X##_s ^ Y##_s;
  385.   switch (_FP_CLS_COMBINE(X##_c, Y##_c))
  386.   {
  387.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL):
  388.     R##_c = FP_CLS_NORMAL;
  389.     R##_e = X##_e + Y##_e + 1;
  391.     _FP_MUL_MEAT_##fs(R,X,Y);
  393.     if (_FP_FRAC_OVERP_##wc(fs, R))
  394.       _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs);
  395.     else
  396.       R##_e--;
  397.     break;
  399.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN):
  400.     _FP_CHOOSENAN(fs, wc, R, X, Y, '*');
  401.     break;
  403.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL):
  404.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF):
  405.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO):
  406.     R##_s = X##_s;
  408.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF):
  409.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL):
  410.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL):
  411.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO):
  412.     _FP_FRAC_COPY_##wc(R, X);
  413.     R##_c = X##_c;
  414.     break;
  416.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN):
  417.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN):
  418.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN):
  419.     R##_s = Y##_s;
  421.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF):
  422.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO):
  423.     _FP_FRAC_COPY_##wc(R, Y);
  424.     R##_c = Y##_c;
  425.     break;
  427.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO):
  428.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF):
  429.     R##_s = _FP_NANSIGN_##fs;
  430.     R##_c = FP_CLS_NAN;
  431.     _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs);
  432.     FP_SET_EXCEPTION(FP_EX_INVALID);
  433.     break;
  435.   default:
  436.     abort();
  437.   }
  438. } while (0)
  441. /*
  442.  * Main division routine.  The input values should be cooked.
  443.  */
  445. #define _FP_DIV(fs, wc, R, X, Y)
  446. do {
  447.   R##_s = X##_s ^ Y##_s;
  448.   switch (_FP_CLS_COMBINE(X##_c, Y##_c))
  449.   {
  450.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL):
  451.     R##_c = FP_CLS_NORMAL;
  452.     R##_e = X##_e - Y##_e;
  454.     _FP_DIV_MEAT_##fs(R,X,Y);
  455.     break;
  457.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN):
  458.     _FP_CHOOSENAN(fs, wc, R, X, Y, '/');
  459.     break;
  461.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL):
  462.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF):
  463.   case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO):
  464.     R##_s = X##_s;
  465.     _FP_FRAC_COPY_##wc(R, X);
  466.     R##_c = X##_c;
  467.     break;
  469.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN):
  470.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN):
  471.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN):
  472.     R##_s = Y##_s;
  473.     _FP_FRAC_COPY_##wc(R, Y);
  474.     R##_c = Y##_c;
  475.     break;
  477.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF):
  478.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF):
  479.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL):
  480.     R##_c = FP_CLS_ZERO;
  481.     break;
  483.   case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO):
  484.     FP_SET_EXCEPTION(FP_EX_DIVZERO);
  485.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO):
  486.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL):
  487.     R##_c = FP_CLS_INF;
  488.     break;
  490.   case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF):
  491.   case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO):
  492.     R##_s = _FP_NANSIGN_##fs;
  493.     R##_c = FP_CLS_NAN;
  494.     _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs);
  495.     FP_SET_EXCEPTION(FP_EX_INVALID);
  496.     break;
  498.   default:
  499.     abort();
  500.   }
  501. } while (0)
  504. /*
  505.  * Main differential comparison routine.  The inputs should be raw not
  506.  * cooked.  The return is -1,0,1 for normal values, 2 otherwise.
  507.  */
  509. #define _FP_CMP(fs, wc, ret, X, Y, un)
  510.   do {
  511.     /* NANs are unordered */
  512.     if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))
  513. || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y)))
  514.       {
  515. ret = un;
  516.       }
  517.     else
  518.       {
  519. int __is_zero_x;
  520. int __is_zero_y;
  522. __is_zero_x = (!X##_e && _FP_FRAC_ZEROP_##wc(X)) ? 1 : 0;
  523. __is_zero_y = (!Y##_e && _FP_FRAC_ZEROP_##wc(Y)) ? 1 : 0;
  525. if (__is_zero_x && __is_zero_y)
  526. ret = 0;
  527. else if (__is_zero_x)
  528. ret = Y##_s ? 1 : -1;
  529. else if (__is_zero_y)
  530. ret = X##_s ? -1 : 1;
  531. else if (X##_s != Y##_s)
  532.   ret = X##_s ? -1 : 1;
  533. else if (X##_e > Y##_e)
  534.   ret = X##_s ? -1 : 1;
  535. else if (X##_e < Y##_e)
  536.   ret = X##_s ? 1 : -1;
  537. else if (_FP_FRAC_GT_##wc(X, Y))
  538.   ret = X##_s ? -1 : 1;
  539. else if (_FP_FRAC_GT_##wc(Y, X))
  540.   ret = X##_s ? 1 : -1;
  541. else
  542.   ret = 0;
  543.       }
  544.   } while (0)
  547. /* Simplification for strict equality.  */
  549. #define _FP_CMP_EQ(fs, wc, ret, X, Y)   
  550.   do {   
  551.     /* NANs are unordered */   
  552.     if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))   
  553. || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y)))   
  554.       {   
  555. ret = 1;   
  556.       }   
  557.     else   
  558.       {   
  559. ret = !(X##_e == Y##_e   
  560. && _FP_FRAC_EQ_##wc(X, Y)   
  561. && (X##_s == Y##_s || !X##_e && _FP_FRAC_ZEROP_##wc(X))); 
  562.       }   
  563.   } while (0)
  565. /*
  566.  * Main square root routine.  The input value should be cooked.
  567.  */
  569. #define _FP_SQRT(fs, wc, R, X)
  570. do {
  571.     _FP_FRAC_DECL_##wc(T); _FP_FRAC_DECL_##wc(S);
  572.     _FP_W_TYPE q;
  573.     switch (X##_c)
  574.     {
  575.     case FP_CLS_NAN:
  576. _FP_FRAC_COPY_##wc(R, X);
  577. R##_s = X##_s;
  578.      R##_c = FP_CLS_NAN;
  579.      break;
  580.     case FP_CLS_INF:
  581.      if (X##_s)
  582.        {
  583.          R##_s = _FP_NANSIGN_##fs;
  584.     R##_c = FP_CLS_NAN; /* NAN */
  585.     _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs);
  586.     FP_SET_EXCEPTION(FP_EX_INVALID);
  587.        }
  588.      else
  589.        {
  590.          R##_s = 0;
  591.          R##_c = FP_CLS_INF; /* sqrt(+inf) = +inf */
  592.        }
  593.      break;
  594.     case FP_CLS_ZERO:
  595. R##_s = X##_s;
  596. R##_c = FP_CLS_ZERO; /* sqrt(+-0) = +-0 */
  597. break;
  598.     case FP_CLS_NORMAL:
  599.      R##_s = 0;
  600.         if (X##_s)
  601.           {
  602.     R##_c = FP_CLS_NAN; /* sNAN */
  603.     R##_s = _FP_NANSIGN_##fs;
  604.     _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs);
  605.     FP_SET_EXCEPTION(FP_EX_INVALID);
  606.     break;
  607.           }
  608.      R##_c = FP_CLS_NORMAL;
  609.         if (X##_e & 1)
  610.           _FP_FRAC_SLL_##wc(X, 1);
  611.         R##_e = X##_e >> 1;
  612.         _FP_FRAC_SET_##wc(S, _FP_ZEROFRAC_##wc);
  613.         _FP_FRAC_SET_##wc(R, _FP_ZEROFRAC_##wc);
  614.         q = _FP_OVERFLOW_##fs >> 1;
  615.         _FP_SQRT_MEAT_##wc(R, S, T, X, q);
  616.     }
  617.   } while (0)
  619. /*
  620.  * Convert from FP to integer
  621.  */
  623. /* RSIGNED can have following values:
  624.  * 0:  the number is required to be 0..(2^rsize)-1, if not, NV is set plus
  625.  *     the result is either 0 or (2^rsize)-1 depending on the sign in such case.
  626.  * 1:  the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is
  627.  *     set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending
  628.  *     on the sign in such case.
  629.  * 2:  the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is
  630.  *     set plus the result is truncated to fit into destination.
  631.  * -1: the number is required to be -(2^(rsize-1))..(2^rsize)-1, if not, NV is
  632.  *     set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending
  633.  *     on the sign in such case.
  634.  */
  635. #define _FP_TO_INT(fs, wc, r, X, rsize, rsigned)
  636.   do {
  637.     switch (X##_c)
  638.       {
  639.       case FP_CLS_NORMAL:
  640. if (X##_e < 0)
  641.   {
  642.     FP_SET_EXCEPTION(FP_EX_INEXACT);
  643.   case FP_CLS_ZERO:
  644.     r = 0;
  645.   }
  646. else if (X##_e >= rsize - (rsigned > 0 || X##_s)
  647.  || (!rsigned && X##_s))
  648.   { /* overflow */
  649.   case FP_CLS_NAN:                                                      
  650.   case FP_CLS_INF:
  651.     if (rsigned == 2)
  652.       {
  653. if (X##_c != FP_CLS_NORMAL
  654.     || X##_e >= rsize - 1 + _FP_WFRACBITS_##fs)
  655.   r = 0;
  656. else
  657.   {
  658.     _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1));
  659.     _FP_FRAC_ASSEMBLE_##wc(r, X, rsize);
  660.   }
  661.       }
  662.     else if (rsigned)
  663.       {
  664. r = 1;
  665. r <<= rsize - 1;
  666. r -= 1 - X##_s;
  667.       }
  668.     else
  669.       {
  670. r = 0;
  671. if (X##_s)
  672.   r = ~r;
  673.       }
  674.     FP_SET_EXCEPTION(FP_EX_INVALID);
  675.   }
  676. else
  677.   {
  678.     if (_FP_W_TYPE_SIZE*wc < rsize)
  679.       {
  680. _FP_FRAC_ASSEMBLE_##wc(r, X, rsize);
  681. r <<= X##_e - _FP_WFRACBITS_##fs;
  682.       }
  683.     else
  684.       {
  685. if (X##_e >= _FP_WFRACBITS_##fs)
  686.   _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1));
  687. else if (X##_e < _FP_WFRACBITS_##fs - 1)
  688.   {
  689.     _FP_FRAC_SRS_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 2),
  690.       _FP_WFRACBITS_##fs);
  691.     if (_FP_FRAC_LOW_##wc(X) & 1)
  692.       FP_SET_EXCEPTION(FP_EX_INEXACT);
  693.     _FP_FRAC_SRL_##wc(X, 1);
  694.   }
  695. _FP_FRAC_ASSEMBLE_##wc(r, X, rsize);
  696.       }
  697.     if (rsigned && X##_s)
  698.       r = -r;
  699.   }
  700. break;
  701.       }
  702.   } while (0)
  704. #define _FP_TO_INT_ROUND(fs, wc, r, X, rsize, rsigned)
  705.   do {
  706.     r = 0;
  707.     switch (X##_c)
  708.       {
  709.       case FP_CLS_NORMAL:
  710. if (X##_e >= _FP_FRACBITS_##fs - 1)
  711.   {
  712.     if (X##_e < rsize - 1 + _FP_WFRACBITS_##fs)
  713.       {
  714. if (X##_e >= _FP_WFRACBITS_##fs - 1)
  715.   {
  716.     _FP_FRAC_ASSEMBLE_##wc(r, X, rsize);
  717.     r <<= X##_e - _FP_WFRACBITS_##fs + 1;
  718.   }
  719. else
  720.   {
  721.     _FP_FRAC_SRL_##wc(X, _FP_WORKBITS - X##_e
  722.       + _FP_FRACBITS_##fs - 1);
  723.     _FP_FRAC_ASSEMBLE_##wc(r, X, rsize);
  724.   }
  725.       }
  726.   }
  727. else
  728.   {
  729.     if (X##_e <= -_FP_WORKBITS - 1)
  730.       _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);
  731.     else
  732.       _FP_FRAC_SRS_##wc(X, _FP_FRACBITS_##fs - 1 - X##_e,
  733. _FP_WFRACBITS_##fs);
  734.     _FP_ROUND(wc, X);
  735.     _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);
  736.     _FP_FRAC_ASSEMBLE_##wc(r, X, rsize);
  737.   }
  738. if (rsigned && X##_s)
  739.   r = -r;
  740. if (X##_e >= rsize - (rsigned > 0 || X##_s)
  741.     || (!rsigned && X##_s))
  742.   { /* overflow */
  743.   case FP_CLS_NAN:                                                      
  744.   case FP_CLS_INF:
  745.     if (!rsigned)
  746.       {
  747. r = 0;
  748. if (X##_s)
  749.   r = ~r;
  750.       }
  751.     else if (rsigned != 2)
  752.       {
  753. r = 1;
  754. r <<= rsize - 1;
  755. r -= 1 - X##_s;
  756.       }
  757.     FP_SET_EXCEPTION(FP_EX_INVALID);
  758.   }
  759. break;
  760.       case FP_CLS_ZERO:
  761.         break;
  762.       }
  763.   } while (0)
  765. #define _FP_FROM_INT(fs, wc, X, r, rsize, rtype)
  766.   do {
  767.     if (r)
  768.       {
  769. X##_c = FP_CLS_NORMAL;
  771. if ((X##_s = (r < 0)))
  772.   r = -r;
  774. if (rsize <= _FP_W_TYPE_SIZE)
  775.   __FP_CLZ(X##_e, r);
  776. else
  777.   __FP_CLZ_2(X##_e, (_FP_W_TYPE)(r >> _FP_W_TYPE_SIZE), 
  778.      (_FP_W_TYPE)r);
  779. if (rsize < _FP_W_TYPE_SIZE)
  780. X##_e -= (_FP_W_TYPE_SIZE - rsize);
  781. X##_e = rsize - X##_e - 1;
  783. if (_FP_FRACBITS_##fs < rsize && _FP_WFRACBITS_##fs < X##_e)
  784.   __FP_FRAC_SRS_1(r, (X##_e - _FP_WFRACBITS_##fs), rsize);
  785. r &= ~((rtype)1 << X##_e);
  786. _FP_FRAC_DISASSEMBLE_##wc(X, ((unsigned rtype)r), rsize);
  787. _FP_FRAC_SLL_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 1));
  788.       }
  789.     else
  790.       {
  791. X##_c = FP_CLS_ZERO, X##_s = 0;
  792.       }
  793.   } while (0)
  796. #define FP_CONV(dfs,sfs,dwc,swc,D,S)
  797.   do {
  798.     _FP_FRAC_CONV_##dwc##_##swc(dfs, sfs, D, S);
  799.     D##_e = S##_e;
  800.     D##_c = S##_c;
  801.     D##_s = S##_s;
  802.   } while (0)
  804. /*
  805.  * Helper primitives.
  806.  */
  808. /* Count leading zeros in a word.  */
  810. #ifndef __FP_CLZ
  811. #if _FP_W_TYPE_SIZE < 64
  812. /* this is just to shut the compiler up about shifts > word length -- PMM 02/1998 */
  813. #define __FP_CLZ(r, x)
  814.   do {
  815.     _FP_W_TYPE _t = (x);
  816.     r = _FP_W_TYPE_SIZE - 1;
  817.     if (_t > 0xffff) r -= 16;
  818.     if (_t > 0xffff) _t >>= 16;
  819.     if (_t > 0xff) r -= 8;
  820.     if (_t > 0xff) _t >>= 8;
  821.     if (_t & 0xf0) r -= 4;
  822.     if (_t & 0xf0) _t >>= 4;
  823.     if (_t & 0xc) r -= 2;
  824.     if (_t & 0xc) _t >>= 2;
  825.     if (_t & 0x2) r -= 1;
  826.   } while (0)
  827. #else /* not _FP_W_TYPE_SIZE < 64 */
  828. #define __FP_CLZ(r, x)
  829.   do {
  830.     _FP_W_TYPE _t = (x);
  831.     r = _FP_W_TYPE_SIZE - 1;
  832.     if (_t > 0xffffffff) r -= 32;
  833.     if (_t > 0xffffffff) _t >>= 32;
  834.     if (_t > 0xffff) r -= 16;
  835.     if (_t > 0xffff) _t >>= 16;
  836.     if (_t > 0xff) r -= 8;
  837.     if (_t > 0xff) _t >>= 8;
  838.     if (_t & 0xf0) r -= 4;
  839.     if (_t & 0xf0) _t >>= 4;
  840.     if (_t & 0xc) r -= 2;
  841.     if (_t & 0xc) _t >>= 2;
  842.     if (_t & 0x2) r -= 1;
  843.   } while (0)
  844. #endif /* not _FP_W_TYPE_SIZE < 64 */
  845. #endif /* ndef __FP_CLZ */
  847. #define _FP_DIV_HELP_imm(q, r, n, d)
  848.   do {
  849.     q = n / d, r = n % d;
  850.   } while (0)
  852. #endif /* __MATH_EMU_OP_COMMON_H__ */