Print this page
11210 libm should be cstyle(1ONBLD) clean

Split Close
Expand all
Collapse all
          --- old/usr/src/lib/libm/common/m9x/__fex_sparc.c
          +++ new/usr/src/lib/libm/common/m9x/__fex_sparc.c
↓ open down ↓ 14 lines elided ↑ open up ↑
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  
  22   22  /*
  23   23   * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  24   24   */
       25 +
  25   26  /*
  26   27   * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  27   28   * Use is subject to license terms.
  28   29   */
  29   30  
  30   31  #if defined(__sparc)
  31   32  #include <stdio.h>
  32   33  #include <unistd.h>
  33   34  #include <string.h>
  34   35  #include <signal.h>
↓ open down ↓ 3 lines elided ↑ open up ↑
  38   39  #include <math.h>
  39   40  #if defined(__SUNPRO_C)
  40   41  #include <sunmath.h>
  41   42  #endif
  42   43  #include <fenv.h>
  43   44  
  44   45  #include "fenv_inlines.h"
  45   46  #include "libm_inlines.h"
  46   47  
  47   48  #ifdef __sparcv9
       49 +#define FPreg(X)        &uap->uc_mcontext.fpregs.fpu_fr.fpu_regs[X]
  48   50  
  49      -#define FPreg(X)        &uap->uc_mcontext.fpregs.fpu_fr.fpu_regs[X]
  50      -
  51      -#define FPREG(X)        &uap->uc_mcontext.fpregs.fpu_fr.fpu_dregs[(X>>1)| \
  52      -                                        ((X&1)<<4)]
  53      -
       51 +#define FPREG(X)        &uap->uc_mcontext.fpregs.fpu_fr.fpu_dregs[(X >> 1) | \
       52 +        ((X & 1) << 4)]
  54   53  #else
  55      -
  56   54  #include <sys/procfs.h>
  57   55  
  58      -#define FPxreg(X)       &((prxregset_t*)uap->uc_mcontext.xrs.xrs_ptr)->pr_un.pr_v8p.pr_xfr.pr_regs[X]
       56 +#define FPxreg(X)               & \
       57 +        ((prxregset_t *)uap->uc_mcontext.xrs.xrs_ptr)->pr_un.pr_v8p.pr_xfr. \
       58 +            pr_regs[X]
  59   59  
  60      -#define FPreg(X)        &uap->uc_mcontext.fpregs.fpu_fr.fpu_regs[X]
       60 +#define FPreg(X)                & uap->uc_mcontext.fpregs.fpu_fr.fpu_regs[X]
  61   61  
  62      -#define FPREG(X)        ((X & 1)? FPxreg(X - 1) : FPreg(X))
  63      -
  64      -#endif  /* __sparcv9 */
       62 +#define FPREG(X)                ((X & 1) ? FPxreg(X - 1) : FPreg(X))
       63 +#endif /* __sparcv9 */
  65   64  
  66   65  #include "fex_handler.h"
  67   66  
  68   67  /* avoid dependence on libsunmath */
  69   68  static enum fp_class_type
  70   69  my_fp_classl(long double *a)
  71   70  {
  72      -        int             msw = *(int*)a & ~0x80000000;
       71 +        int msw = *(int *)a & ~0x80000000;
  73   72  
  74   73          if (msw >= 0x7fff0000) {
  75      -                if (((msw & 0xffff) | *(1+(int*)a) | *(2+(int*)a) | *(3+(int*)a)) == 0)
  76      -                        return fp_infinity;
       74 +                if (((msw & 0xffff) | *(1 + (int *)a) | *(2 + (int *)a) | *(3 +
       75 +                    (int *)a)) == 0)
       76 +                        return (fp_infinity);
  77   77                  else if (msw & 0x8000)
  78      -                        return fp_quiet;
       78 +                        return (fp_quiet);
  79   79                  else
  80      -                        return fp_signaling;
       80 +                        return (fp_signaling);
  81   81          } else if (msw < 0x10000) {
  82      -                if ((msw | *(1+(int*)a) | *(2+(int*)a) | *(3+(int*)a)) == 0)
  83      -                        return fp_zero;
       82 +                if ((msw | *(1 + (int *)a) | *(2 + (int *)a) | *(3 +
       83 +                    (int *)a)) == 0)
       84 +                        return (fp_zero);
  84   85                  else
  85      -                        return fp_subnormal;
  86      -        } else
  87      -                return fp_normal;
       86 +                        return (fp_subnormal);
       87 +        } else {
       88 +                return (fp_normal);
       89 +        }
  88   90  }
  89   91  
  90   92  /*
  91      -*  Determine which type of invalid operation exception occurred
  92      -*/
       93 + *  Determine which type of invalid operation exception occurred
       94 + */
  93   95  enum fex_exception
  94   96  __fex_get_invalid_type(siginfo_t *sip, ucontext_t *uap)
  95   97  {
  96      -        unsigned                        instr, opf, rs1, rs2;
  97      -        enum fp_class_type      t1, t2;
       98 +        unsigned instr, opf, rs1, rs2;
       99 +        enum fp_class_type t1, t2;
  98  100  
  99  101          /* parse the instruction which caused the exception */
 100  102          instr = uap->uc_mcontext.fpregs.fpu_q->FQu.fpq.fpq_instr;
 101  103          opf = (instr >> 5) & 0x1ff;
 102  104          rs1 = (instr >> 14) & 0x1f;
 103  105          rs2 = instr & 0x1f;
 104  106  
 105  107          /* determine the classes of the operands */
 106  108          switch (opf & 3) {
 107      -        case 1: /* single */
 108      -                t1 = fp_classf(*(float*)FPreg(rs1));
 109      -                t2 = fp_classf(*(float*)FPreg(rs2));
      109 +        case 1:                         /* single */
      110 +                t1 = fp_classf(*(float *)FPreg(rs1));
      111 +                t2 = fp_classf(*(float *)FPreg(rs2));
 110  112                  break;
 111  113  
 112      -        case 2: /* double */
 113      -                t1 = fp_class(*(double*)FPREG(rs1));
 114      -                t2 = fp_class(*(double*)FPREG(rs2));
      114 +        case 2:                         /* double */
      115 +                t1 = fp_class(*(double *)FPREG(rs1));
      116 +                t2 = fp_class(*(double *)FPREG(rs2));
 115  117                  break;
 116  118  
 117      -        case 3: /* quad */
 118      -                t1 = my_fp_classl((long double*)FPREG(rs1));
 119      -                t2 = my_fp_classl((long double*)FPREG(rs2));
      119 +        case 3:                         /* quad */
      120 +                t1 = my_fp_classl((long double *)FPREG(rs1));
      121 +                t2 = my_fp_classl((long double *)FPREG(rs2));
 120  122                  break;
 121  123  
 122      -        default: /* integer operands never cause an invalid operation */
 123      -                return (enum fex_exception) -1;
      124 +        default:        /* integer operands never cause an invalid operation */
      125 +                return ((enum fex_exception)-1);
 124  126          }
 125  127  
 126  128          /* if rs2 is snan, return immediately */
 127  129          if (t2 == fp_signaling)
 128      -                return fex_inv_snan;
      130 +                return (fex_inv_snan);
 129  131  
 130  132          /* determine the type of operation */
 131  133          switch ((instr >> 19) & 0x183f) {
 132  134          case 0x1034: /* add, subtract, multiply, divide, square root, convert */
      135 +
 133  136                  switch (opf & 0x1fc) {
 134  137                  case 0x40:
 135      -                case 0x44: /* add or subtract */
      138 +                case 0x44:              /* add or subtract */
      139 +
 136  140                          if (t1 == fp_signaling)
 137      -                                return fex_inv_snan;
      141 +                                return (fex_inv_snan);
 138  142                          else
 139      -                                return fex_inv_isi;
      143 +                                return (fex_inv_isi);
 140  144  
 141  145                  case 0x48:
 142  146                  case 0x68:
 143      -                case 0x6c: /* multiply */
      147 +                case 0x6c:              /* multiply */
      148 +
 144  149                          if (t1 == fp_signaling)
 145      -                                return fex_inv_snan;
      150 +                                return (fex_inv_snan);
 146  151                          else
 147      -                                return fex_inv_zmi;
      152 +                                return (fex_inv_zmi);
      153 +
      154 +                case 0x4c:              /* divide */
 148  155  
 149      -                case 0x4c: /* divide */
 150  156                          if (t1 == fp_signaling)
 151      -                                return fex_inv_snan;
      157 +                                return (fex_inv_snan);
 152  158                          else if (t1 == fp_zero)
 153      -                                return fex_inv_zdz;
      159 +                                return (fex_inv_zdz);
 154  160                          else
 155      -                                return fex_inv_idi;
      161 +                                return (fex_inv_idi);
 156  162  
 157      -                case 0x28: /* square root */
 158      -                        return fex_inv_sqrt;
      163 +                case 0x28:              /* square root */
      164 +                        return (fex_inv_sqrt);
 159  165  
 160  166                  case 0x80:
 161      -                case 0xd0: /* convert to integer */
 162      -                        return fex_inv_int;
      167 +                case 0xd0:              /* convert to integer */
      168 +                        return (fex_inv_int);
 163  169                  }
      170 +
 164  171                  break;
 165  172  
 166      -        case 0x1035: /* compare */
      173 +        case 0x1035:                    /* compare */
      174 +
 167  175                  if (t1 == fp_signaling)
 168      -                        return fex_inv_snan;
      176 +                        return (fex_inv_snan);
 169  177                  else
 170      -                        return fex_inv_cmp;
      178 +                        return (fex_inv_cmp);
 171  179          }
 172  180  
 173      -        return (enum fex_exception) -1;
      181 +        return ((enum fex_exception)-1);
 174  182  }
 175  183  
 176  184  #ifdef __sparcv9
 177  185  extern void _Qp_sqrt(long double *, const long double *);
 178  186  #else
 179  187  extern long double _Q_sqrt(long double);
 180  188  #endif
 181  189  
 182  190  /*
 183      -*  Get the operands, generate the default untrapped result with
 184      -*  exceptions, and set a code indicating the type of operation
 185      -*/
      191 + *  Get the operands, generate the default untrapped result with
      192 + *  exceptions, and set a code indicating the type of operation
      193 + */
 186  194  void
 187  195  __fex_get_op(siginfo_t *sip, ucontext_t *uap, fex_info_t *info)
 188  196  {
 189      -        unsigned long   fsr;
 190      -        unsigned                instr, opf, rs1, rs2;
 191      -        volatile int    c;
      197 +        unsigned long fsr;
      198 +        unsigned instr, opf, rs1, rs2;
      199 +        volatile int c;
 192  200  
 193  201          /* parse the instruction which caused the exception */
 194  202          instr = uap->uc_mcontext.fpregs.fpu_q->FQu.fpq.fpq_instr;
 195  203          opf = (instr >> 5) & 0x1ff;
 196  204          rs1 = (instr >> 14) & 0x1f;
 197  205          rs2 = instr & 0x1f;
 198  206  
 199  207          /* get the operands */
 200  208          switch (opf & 3) {
 201      -        case 0: /* integer */
      209 +        case 0:                         /* integer */
 202  210                  info->op1.type = fex_nodata;
      211 +
 203  212                  if (opf & 0x40) {
 204  213                          info->op2.type = fex_int;
 205      -                        info->op2.val.i = *(int*)FPreg(rs2);
 206      -                }
 207      -                else {
      214 +                        info->op2.val.i = *(int *)FPreg(rs2);
      215 +                } else {
 208  216                          info->op2.type = fex_llong;
 209      -                        info->op2.val.l = *(long long*)FPREG(rs2);
      217 +                        info->op2.val.l = *(long long *)FPREG(rs2);
 210  218                  }
      219 +
 211  220                  break;
 212  221  
 213      -        case 1: /* single */
      222 +        case 1:                         /* single */
 214  223                  info->op1.type = info->op2.type = fex_float;
 215      -                info->op1.val.f = *(float*)FPreg(rs1);
 216      -                info->op2.val.f = *(float*)FPreg(rs2);
      224 +                info->op1.val.f = *(float *)FPreg(rs1);
      225 +                info->op2.val.f = *(float *)FPreg(rs2);
 217  226                  break;
 218  227  
 219      -        case 2: /* double */
      228 +        case 2:                         /* double */
 220  229                  info->op1.type = info->op2.type = fex_double;
 221      -                info->op1.val.d = *(double*)FPREG(rs1);
 222      -                info->op2.val.d = *(double*)FPREG(rs2);
      230 +                info->op1.val.d = *(double *)FPREG(rs1);
      231 +                info->op2.val.d = *(double *)FPREG(rs2);
 223  232                  break;
 224  233  
 225      -        case 3: /* quad */
      234 +        case 3:                         /* quad */
 226  235                  info->op1.type = info->op2.type = fex_ldouble;
 227      -                info->op1.val.q = *(long double*)FPREG(rs1);
 228      -                info->op2.val.q = *(long double*)FPREG(rs2);
      236 +                info->op1.val.q = *(long double *)FPREG(rs1);
      237 +                info->op2.val.q = *(long double *)FPREG(rs2);
 229  238                  break;
 230  239          }
 231  240  
 232      -        /* initialize res to the default untrapped result and ex to the
 233      -           corresponding flags (assume trapping is disabled and flags
 234      -           are clear) */
      241 +        /*
      242 +         * initialize res to the default untrapped result and ex to the
      243 +         * corresponding flags (assume trapping is disabled and flags are
      244 +         * clear)
      245 +         */
 235  246          info->op = fex_other;
 236  247          info->res.type = fex_nodata;
      248 +
 237  249          switch ((instr >> 19) & 0x183f) {
 238      -        case 0x1035: /* compare */
      250 +        case 0x1035:                    /* compare */
 239  251                  info->op = fex_cmp;
      252 +
 240  253                  switch (opf) {
 241      -                case 0x51: /* compare single */
      254 +                case 0x51:              /* compare single */
 242  255                          c = (info->op1.val.f == info->op2.val.f);
 243  256                          break;
 244  257  
 245      -                case 0x52: /* compare double */
      258 +                case 0x52:              /* compare double */
 246  259                          c = (info->op1.val.d == info->op2.val.d);
 247  260                          break;
 248  261  
 249      -                case 0x53: /* compare quad */
      262 +                case 0x53:              /* compare quad */
 250  263                          c = (info->op1.val.q == info->op2.val.q);
 251  264                          break;
 252  265  
 253      -                case 0x55: /* compare single with exception */
      266 +                case 0x55:              /* compare single with exception */
 254  267                          c = (info->op1.val.f < info->op2.val.f);
 255  268                          break;
 256  269  
 257      -                case 0x56: /* compare double with exception */
      270 +                case 0x56:              /* compare double with exception */
 258  271                          c = (info->op1.val.d < info->op2.val.d);
 259  272                          break;
 260  273  
 261      -                case 0x57: /* compare quad with exception */
      274 +                case 0x57:              /* compare quad with exception */
 262  275                          c = (info->op1.val.q < info->op2.val.q);
 263  276                          break;
 264  277                  }
      278 +
 265  279                  break;
 266  280  
 267  281          case 0x1034: /* add, subtract, multiply, divide, square root, convert */
      282 +
 268  283                  switch (opf) {
 269      -                case 0x41: /* add single */
      284 +                case 0x41:              /* add single */
 270  285                          info->op = fex_add;
 271  286                          info->res.type = fex_float;
 272  287                          info->res.val.f = info->op1.val.f + info->op2.val.f;
 273  288                          break;
 274  289  
 275      -                case 0x42: /* add double */
      290 +                case 0x42:              /* add double */
 276  291                          info->op = fex_add;
 277  292                          info->res.type = fex_double;
 278  293                          info->res.val.d = info->op1.val.d + info->op2.val.d;
 279  294                          break;
 280  295  
 281      -                case 0x43: /* add quad */
      296 +                case 0x43:              /* add quad */
 282  297                          info->op = fex_add;
 283  298                          info->res.type = fex_ldouble;
 284  299                          info->res.val.q = info->op1.val.q + info->op2.val.q;
 285  300                          break;
 286  301  
 287      -                case 0x45: /* subtract single */
      302 +                case 0x45:              /* subtract single */
 288  303                          info->op = fex_sub;
 289  304                          info->res.type = fex_float;
 290  305                          info->res.val.f = info->op1.val.f - info->op2.val.f;
 291  306                          break;
 292  307  
 293      -                case 0x46: /* subtract double */
      308 +                case 0x46:              /* subtract double */
 294  309                          info->op = fex_sub;
 295  310                          info->res.type = fex_double;
 296  311                          info->res.val.d = info->op1.val.d - info->op2.val.d;
 297  312                          break;
 298  313  
 299      -                case 0x47: /* subtract quad */
      314 +                case 0x47:              /* subtract quad */
 300  315                          info->op = fex_sub;
 301  316                          info->res.type = fex_ldouble;
 302  317                          info->res.val.q = info->op1.val.q - info->op2.val.q;
 303  318                          break;
 304  319  
 305      -                case 0x49: /* multiply single */
      320 +                case 0x49:              /* multiply single */
 306  321                          info->op = fex_mul;
 307  322                          info->res.type = fex_float;
 308  323                          info->res.val.f = info->op1.val.f * info->op2.val.f;
 309  324                          break;
 310  325  
 311      -                case 0x4a: /* multiply double */
      326 +                case 0x4a:              /* multiply double */
 312  327                          info->op = fex_mul;
 313  328                          info->res.type = fex_double;
 314  329                          info->res.val.d = info->op1.val.d * info->op2.val.d;
 315  330                          break;
 316  331  
 317      -                case 0x4b: /* multiply quad */
      332 +                case 0x4b:              /* multiply quad */
 318  333                          info->op = fex_mul;
 319  334                          info->res.type = fex_ldouble;
 320  335                          info->res.val.q = info->op1.val.q * info->op2.val.q;
 321  336                          break;
 322  337  
 323      -                case 0x69: /* fsmuld */
      338 +                case 0x69:              /* fsmuld */
 324  339                          info->op = fex_mul;
 325  340                          info->res.type = fex_double;
 326      -                        info->res.val.d = (double)info->op1.val.f * (double)info->op2.val.f;
      341 +                        info->res.val.d = (double)info->op1.val.f *
      342 +                            (double)info->op2.val.f;
 327  343                          break;
 328  344  
 329      -                case 0x6e: /* fdmulq */
      345 +                case 0x6e:              /* fdmulq */
 330  346                          info->op = fex_mul;
 331  347                          info->res.type = fex_ldouble;
 332      -                        info->res.val.q = (long double)info->op1.val.d *
 333      -                                (long double)info->op2.val.d;
      348 +                        info->res.val.q = (long double)info->op1.val.d * (long
      349 +                            double)info->op2.val.d;
 334  350                          break;
 335  351  
 336      -                case 0x4d: /* divide single */
      352 +                case 0x4d:              /* divide single */
 337  353                          info->op = fex_div;
 338  354                          info->res.type = fex_float;
 339  355                          info->res.val.f = info->op1.val.f / info->op2.val.f;
 340  356                          break;
 341  357  
 342      -                case 0x4e: /* divide double */
      358 +                case 0x4e:              /* divide double */
 343  359                          info->op = fex_div;
 344  360                          info->res.type = fex_double;
 345  361                          info->res.val.d = info->op1.val.d / info->op2.val.d;
 346  362                          break;
 347  363  
 348      -                case 0x4f: /* divide quad */
      364 +                case 0x4f:              /* divide quad */
 349  365                          info->op = fex_div;
 350  366                          info->res.type = fex_ldouble;
 351  367                          info->res.val.q = info->op1.val.q / info->op2.val.q;
 352  368                          break;
 353  369  
 354      -                case 0x29: /* square root single */
      370 +                case 0x29:              /* square root single */
 355  371                          info->op = fex_sqrt;
 356  372                          info->op1 = info->op2;
 357  373                          info->op2.type = fex_nodata;
 358  374                          info->res.type = fex_float;
 359  375                          info->res.val.f = sqrtf(info->op1.val.f);
 360  376                          break;
 361  377  
 362      -                case 0x2a: /* square root double */
      378 +                case 0x2a:              /* square root double */
 363  379                          info->op = fex_sqrt;
 364  380                          info->op1 = info->op2;
 365  381                          info->op2.type = fex_nodata;
 366  382                          info->res.type = fex_double;
 367  383                          info->res.val.d = sqrt(info->op1.val.d);
 368  384                          break;
 369  385  
 370      -                case 0x2b: /* square root quad */
      386 +                case 0x2b:              /* square root quad */
 371  387                          info->op = fex_sqrt;
 372  388                          info->op1 = info->op2;
 373  389                          info->op2.type = fex_nodata;
 374  390                          info->res.type = fex_ldouble;
 375  391  #ifdef __sparcv9
 376  392                          _Qp_sqrt(&info->res.val.q, &info->op1.val.q);
 377  393  #else
 378  394                          info->res.val.q = _Q_sqrt(info->op1.val.q);
 379  395  #endif
 380  396                          break;
 381  397  
 382      -                default: /* conversions */
      398 +                default:                /* conversions */
 383  399                          info->op = fex_cnvt;
 384  400                          info->op1 = info->op2;
 385  401                          info->op2.type = fex_nodata;
      402 +
 386  403                          switch (opf) {
 387      -                        case 0xd1: /* convert single to int */
      404 +                        case 0xd1:      /* convert single to int */
 388  405                                  info->res.type = fex_int;
 389      -                                info->res.val.i = (int) info->op1.val.f;
      406 +                                info->res.val.i = (int)info->op1.val.f;
 390  407                                  break;
 391  408  
 392      -                        case 0xd2: /* convert double to int */
      409 +                        case 0xd2:      /* convert double to int */
 393  410                                  info->res.type = fex_int;
 394      -                                info->res.val.i = (int) info->op1.val.d;
      411 +                                info->res.val.i = (int)info->op1.val.d;
 395  412                                  break;
 396  413  
 397      -                        case 0xd3: /* convert quad to int */
      414 +                        case 0xd3:      /* convert quad to int */
 398  415                                  info->res.type = fex_int;
 399      -                                info->res.val.i = (int) info->op1.val.q;
      416 +                                info->res.val.i = (int)info->op1.val.q;
 400  417                                  break;
 401  418  
 402      -                        case 0x81: /* convert single to long long */
      419 +                        case 0x81:      /* convert single to long long */
 403  420                                  info->res.type = fex_llong;
 404      -                                info->res.val.l = (long long) info->op1.val.f;
      421 +                                info->res.val.l = (long long)info->op1.val.f;
 405  422                                  break;
 406  423  
 407      -                        case 0x82: /* convert double to long long */
      424 +                        case 0x82:      /* convert double to long long */
 408  425                                  info->res.type = fex_llong;
 409      -                                info->res.val.l = (long long) info->op1.val.d;
      426 +                                info->res.val.l = (long long)info->op1.val.d;
 410  427                                  break;
 411  428  
 412      -                        case 0x83: /* convert quad to long long */
      429 +                        case 0x83:      /* convert quad to long long */
 413  430                                  info->res.type = fex_llong;
 414      -                                info->res.val.l = (long long) info->op1.val.q;
      431 +                                info->res.val.l = (long long)info->op1.val.q;
 415  432                                  break;
 416  433  
 417      -                        case 0xc4: /* convert int to single */
      434 +                        case 0xc4:      /* convert int to single */
 418  435                                  info->res.type = fex_float;
 419      -                                info->res.val.f = (float) info->op1.val.i;
      436 +                                info->res.val.f = (float)info->op1.val.i;
 420  437                                  break;
 421  438  
 422      -                        case 0x84: /* convert long long to single */
      439 +                        case 0x84:      /* convert long long to single */
 423  440                                  info->res.type = fex_float;
 424      -                                info->res.val.f = (float) info->op1.val.l;
      441 +                                info->res.val.f = (float)info->op1.val.l;
 425  442                                  break;
 426  443  
 427      -                        case 0x88: /* convert long long to double */
      444 +                        case 0x88:      /* convert long long to double */
 428  445                                  info->res.type = fex_double;
 429      -                                info->res.val.d = (double) info->op1.val.l;
      446 +                                info->res.val.d = (double)info->op1.val.l;
 430  447                                  break;
 431  448  
 432      -                        case 0xc6: /* convert double to single */
      449 +                        case 0xc6:      /* convert double to single */
 433  450                                  info->res.type = fex_float;
 434      -                                info->res.val.f = (float) info->op1.val.d;
      451 +                                info->res.val.f = (float)info->op1.val.d;
 435  452                                  break;
 436  453  
 437      -                        case 0xc7: /* convert quad to single */
      454 +                        case 0xc7:      /* convert quad to single */
 438  455                                  info->res.type = fex_float;
 439      -                                info->res.val.f = (float) info->op1.val.q;
      456 +                                info->res.val.f = (float)info->op1.val.q;
 440  457                                  break;
 441  458  
 442      -                        case 0xc9: /* convert single to double */
      459 +                        case 0xc9:      /* convert single to double */
 443  460                                  info->res.type = fex_double;
 444      -                                info->res.val.d = (double) info->op1.val.f;
      461 +                                info->res.val.d = (double)info->op1.val.f;
 445  462                                  break;
 446  463  
 447      -                        case 0xcb: /* convert quad to double */
      464 +                        case 0xcb:      /* convert quad to double */
 448  465                                  info->res.type = fex_double;
 449      -                                info->res.val.d = (double) info->op1.val.q;
      466 +                                info->res.val.d = (double)info->op1.val.q;
 450  467                                  break;
 451  468  
 452      -                        case 0xcd: /* convert single to quad */
      469 +                        case 0xcd:      /* convert single to quad */
 453  470                                  info->res.type = fex_ldouble;
 454      -                                info->res.val.q = (long double) info->op1.val.f;
      471 +                                info->res.val.q = (long double)info->op1.val.f;
 455  472                                  break;
 456  473  
 457      -                        case 0xce: /* convert double to quad */
      474 +                        case 0xce:      /* convert double to quad */
 458  475                                  info->res.type = fex_ldouble;
 459      -                                info->res.val.q = (long double) info->op1.val.d;
      476 +                                info->res.val.q = (long double)info->op1.val.d;
 460  477                                  break;
 461  478                          }
 462  479                  }
      480 +
 463  481                  break;
 464  482          }
      483 +
 465  484          __fenv_getfsr(&fsr);
 466  485          info->flags = (int)__fenv_get_ex(fsr);
 467  486          __fenv_set_ex(fsr, 0);
 468  487          __fenv_setfsr(&fsr);
 469  488  }
 470  489  
 471  490  /*
 472      -*  Store the specified result; if no result is given but the exception
 473      -*  is underflow or overflow, supply the default trapped result
 474      -*/
      491 + *  Store the specified result; if no result is given but the exception
      492 + *  is underflow or overflow, supply the default trapped result
      493 + */
 475  494  void
 476  495  __fex_st_result(siginfo_t *sip, ucontext_t *uap, fex_info_t *info)
 477  496  {
 478      -        unsigned                instr, opf, rs1, rs2, rd;
 479      -        long double             qscl;
 480      -        double                  dscl;
 481      -        float                   fscl;
      497 +        unsigned instr, opf, rs1, rs2, rd;
      498 +        long double qscl;
      499 +        double dscl;
      500 +        float fscl;
 482  501  
 483  502          /* parse the instruction which caused the exception */
 484  503          instr = uap->uc_mcontext.fpregs.fpu_q->FQu.fpq.fpq_instr;
 485  504          opf = (instr >> 5) & 0x1ff;
 486  505          rs1 = (instr >> 14) & 0x1f;
 487  506          rs2 = instr & 0x1f;
 488  507          rd = (instr >> 25) & 0x1f;
 489  508  
 490  509          /* if the instruction is a compare, just set fcc to unordered */
 491  510          if (((instr >> 19) & 0x183f) == 0x1035) {
 492      -                if (rd == 0)
      511 +                if (rd == 0) {
 493  512                          uap->uc_mcontext.fpregs.fpu_fsr |= 0xc00;
 494      -                else {
      513 +                } else {
 495  514  #ifdef __sparcv9
 496      -                        uap->uc_mcontext.fpregs.fpu_fsr |= (3l << ((rd << 1) + 30));
      515 +                        uap->uc_mcontext.fpregs.fpu_fsr |= (3l << ((rd << 1) +
      516 +                            30));
 497  517  #else
 498      -                        ((prxregset_t*)uap->uc_mcontext.xrs.xrs_ptr)->pr_un.pr_v8p.pr_xfsr |= (3 << ((rd - 1) << 1));
      518 +                        ((prxregset_t *)uap->uc_mcontext.xrs.xrs_ptr)->pr_un.
      519 +                            pr_v8p.pr_xfsr |= (3 << ((rd - 1) << 1));
 499  520  #endif
 500  521                  }
      522 +
 501  523                  return;
 502  524          }
 503  525  
 504      -        /* if there is no result available, try to generate the untrapped
 505      -           default */
      526 +        /*
      527 +         * if there is no result available, try to generate the untrapped
      528 +         * default
      529 +         */
 506  530          if (info->res.type == fex_nodata) {
 507  531                  /* set scale factors for exponent wrapping */
 508  532                  switch (sip->si_code) {
 509  533                  case FPE_FLTOVF:
 510      -                        fscl = 1.262177448e-29f;        /* 2^-96 */
 511      -                        dscl = 6.441148769597133308e-232;       /* 2^-768 */
 512      -                        qscl = 8.778357852076208839765066529179033145e-3700l;/* 2^-12288 */
      534 +                        /* 2^-96 */
      535 +                        fscl = 1.262177448e-29f;
      536 +                        /* 2^-768 */
      537 +                        dscl = 6.441148769597133308e-232;
      538 +                        /* 2^-12288 */
      539 +                        qscl = 8.778357852076208839765066529179033145e-3700l;
 513  540                          break;
 514  541  
 515  542                  case FPE_FLTUND:
 516      -                        fscl = 7.922816251e+28f;        /* 2^96 */
 517      -                        dscl = 1.552518092300708935e+231;       /* 2^768 */
 518      -                        qscl = 1.139165225263043370845938579315932009e+3699l;/* 2^12288 */
      543 +                        /* 2^96 */
      544 +                        fscl = 7.922816251e+28f;
      545 +                        /* 2^768 */
      546 +                        dscl = 1.552518092300708935e+231;
      547 +                        /* 2^12288 */
      548 +                        qscl = 1.139165225263043370845938579315932009e+3699l;
 519  549                          break;
 520  550  
 521  551                  default:
 522      -                        /* user may have blown away the default result by mistake,
 523      -                           so try to regenerate it */
      552 +
      553 +                        /*
      554 +                         * user may have blown away the default result by
      555 +                         * mistake, so try to regenerate it
      556 +                         */
 524  557                          (void) __fex_get_op(sip, uap, info);
      558 +
 525  559                          if (info->res.type != fex_nodata)
 526  560                                  goto stuff;
      561 +
 527  562                          /* couldn't do it */
 528  563                          return;
 529  564                  }
 530  565  
 531  566                  /* get the operands */
 532  567                  switch (opf & 3) {
 533      -                case 1: /* single */
 534      -                        info->op1.val.f = *(float*)FPreg(rs1);
 535      -                        info->op2.val.f = *(float*)FPreg(rs2);
      568 +                case 1:                 /* single */
      569 +                        info->op1.val.f = *(float *)FPreg(rs1);
      570 +                        info->op2.val.f = *(float *)FPreg(rs2);
 536  571                          break;
 537  572  
 538      -                case 2: /* double */
 539      -                        info->op1.val.d = *(double*)FPREG(rs1);
 540      -                        info->op2.val.d = *(double*)FPREG(rs2);
      573 +                case 2:                 /* double */
      574 +                        info->op1.val.d = *(double *)FPREG(rs1);
      575 +                        info->op2.val.d = *(double *)FPREG(rs2);
 541  576                          break;
 542  577  
 543      -                case 3: /* quad */
 544      -                        info->op1.val.q = *(long double*)FPREG(rs1);
 545      -                        info->op2.val.q = *(long double*)FPREG(rs2);
      578 +                case 3:                 /* quad */
      579 +                        info->op1.val.q = *(long double *)FPREG(rs1);
      580 +                        info->op2.val.q = *(long double *)FPREG(rs2);
 546  581                          break;
 547  582                  }
 548  583  
 549  584                  /* generate the wrapped result */
 550  585                  switch (opf) {
 551      -                case 0x41: /* add single */
      586 +                case 0x41:              /* add single */
 552  587                          info->res.type = fex_float;
 553  588                          info->res.val.f = fscl * (fscl * info->op1.val.f +
 554      -                                fscl * info->op2.val.f);
      589 +                            fscl * info->op2.val.f);
 555  590                          break;
 556  591  
 557      -                case 0x42: /* add double */
      592 +                case 0x42:              /* add double */
 558  593                          info->res.type = fex_double;
 559  594                          info->res.val.d = dscl * (dscl * info->op1.val.d +
 560      -                                dscl * info->op2.val.d);
      595 +                            dscl * info->op2.val.d);
 561  596                          break;
 562  597  
 563      -                case 0x43: /* add quad */
      598 +                case 0x43:              /* add quad */
 564  599                          info->res.type = fex_ldouble;
 565  600                          info->res.val.q = qscl * (qscl * info->op1.val.q +
 566      -                                qscl * info->op2.val.q);
      601 +                            qscl * info->op2.val.q);
 567  602                          break;
 568  603  
 569      -                case 0x45: /* subtract single */
      604 +                case 0x45:              /* subtract single */
 570  605                          info->res.type = fex_float;
 571  606                          info->res.val.f = fscl * (fscl * info->op1.val.f -
 572      -                                fscl * info->op2.val.f);
      607 +                            fscl * info->op2.val.f);
 573  608                          break;
 574  609  
 575      -                case 0x46: /* subtract double */
      610 +                case 0x46:              /* subtract double */
 576  611                          info->res.type = fex_double;
 577  612                          info->res.val.d = dscl * (dscl * info->op1.val.d -
 578      -                                dscl * info->op2.val.d);
      613 +                            dscl * info->op2.val.d);
 579  614                          break;
 580  615  
 581      -                case 0x47: /* subtract quad */
      616 +                case 0x47:              /* subtract quad */
 582  617                          info->res.type = fex_ldouble;
 583  618                          info->res.val.q = qscl * (qscl * info->op1.val.q -
 584      -                                qscl * info->op2.val.q);
      619 +                            qscl * info->op2.val.q);
 585  620                          break;
 586  621  
 587      -                case 0x49: /* multiply single */
      622 +                case 0x49:              /* multiply single */
 588  623                          info->res.type = fex_float;
 589      -                        info->res.val.f = (fscl * info->op1.val.f) *
 590      -                                (fscl * info->op2.val.f);
      624 +                        info->res.val.f = (fscl * info->op1.val.f) * (fscl *
      625 +                            info->op2.val.f);
 591  626                          break;
 592  627  
 593      -                case 0x4a: /* multiply double */
      628 +                case 0x4a:              /* multiply double */
 594  629                          info->res.type = fex_double;
 595      -                        info->res.val.d = (dscl * info->op1.val.d) *
 596      -                                (dscl * info->op2.val.d);
      630 +                        info->res.val.d = (dscl * info->op1.val.d) * (dscl *
      631 +                            info->op2.val.d);
 597  632                          break;
 598  633  
 599      -                case 0x4b: /* multiply quad */
      634 +                case 0x4b:              /* multiply quad */
 600  635                          info->res.type = fex_ldouble;
 601      -                        info->res.val.q = (qscl * info->op1.val.q) *
 602      -                                (qscl * info->op2.val.q);
      636 +                        info->res.val.q = (qscl * info->op1.val.q) * (qscl *
      637 +                            info->op2.val.q);
 603  638                          break;
 604  639  
 605      -                case 0x4d: /* divide single */
      640 +                case 0x4d:              /* divide single */
 606  641                          info->res.type = fex_float;
 607  642                          info->res.val.f = (fscl * info->op1.val.f) /
 608      -                                (info->op2.val.f / fscl);
      643 +                            (info->op2.val.f / fscl);
 609  644                          break;
 610  645  
 611      -                case 0x4e: /* divide double */
      646 +                case 0x4e:              /* divide double */
 612  647                          info->res.type = fex_double;
 613  648                          info->res.val.d = (dscl * info->op1.val.d) /
 614      -                                (info->op2.val.d / dscl);
      649 +                            (info->op2.val.d / dscl);
 615  650                          break;
 616  651  
 617      -                case 0x4f: /* divide quad */
      652 +                case 0x4f:              /* divide quad */
 618  653                          info->res.type = fex_ldouble;
 619  654                          info->res.val.q = (qscl * info->op1.val.q) /
 620      -                                (info->op2.val.q / qscl);
      655 +                            (info->op2.val.q / qscl);
 621  656                          break;
 622  657  
 623      -                case 0xc6: /* convert double to single */
      658 +                case 0xc6:              /* convert double to single */
 624  659                          info->res.type = fex_float;
 625      -                        info->res.val.f = (float) (fscl * (fscl * info->op1.val.d));
      660 +                        info->res.val.f = (float)(fscl * (fscl *
      661 +                            info->op1.val.d));
 626  662                          break;
 627  663  
 628      -                case 0xc7: /* convert quad to single */
      664 +                case 0xc7:              /* convert quad to single */
 629  665                          info->res.type = fex_float;
 630      -                        info->res.val.f = (float) (fscl * (fscl * info->op1.val.q));
      666 +                        info->res.val.f = (float)(fscl * (fscl *
      667 +                            info->op1.val.q));
 631  668                          break;
 632  669  
 633      -                case 0xcb: /* convert quad to double */
      670 +                case 0xcb:              /* convert quad to double */
 634  671                          info->res.type = fex_double;
 635      -                        info->res.val.d = (double) (dscl * (dscl * info->op1.val.q));
      672 +                        info->res.val.d = (double)(dscl * (dscl *
      673 +                            info->op1.val.q));
 636  674                          break;
 637  675                  }
 638  676  
 639  677                  if (info->res.type == fex_nodata)
 640  678                          /* couldn't do it */
 641  679                          return;
 642  680          }
 643  681  
 644  682  stuff:
 645  683          /* stick the result in the destination */
 646      -        if (opf & 0x80) { /* conversion */
 647      -                if (opf & 0x10) { /* result is an int */
      684 +        if (opf & 0x80) {               /* conversion */
      685 +                if (opf & 0x10) {       /* result is an int */
 648  686                          switch (info->res.type) {
 649  687                          case fex_llong:
 650      -                                info->res.val.i = (int) info->res.val.l;
      688 +                                info->res.val.i = (int)info->res.val.l;
 651  689                                  break;
 652  690  
 653  691                          case fex_float:
 654      -                                info->res.val.i = (int) info->res.val.f;
      692 +                                info->res.val.i = (int)info->res.val.f;
 655  693                                  break;
 656  694  
 657  695                          case fex_double:
 658      -                                info->res.val.i = (int) info->res.val.d;
      696 +                                info->res.val.i = (int)info->res.val.d;
 659  697                                  break;
 660  698  
 661  699                          case fex_ldouble:
 662      -                                info->res.val.i = (int) info->res.val.q;
      700 +                                info->res.val.i = (int)info->res.val.q;
 663  701                                  break;
 664  702  
 665  703                          default:
 666  704                                  break;
 667  705                          }
 668      -                        *(int*)FPreg(rd) = info->res.val.i;
      706 +
      707 +                        *(int *)FPreg(rd) = info->res.val.i;
 669  708                          return;
 670  709                  }
 671  710  
 672  711                  switch (opf & 0xc) {
 673      -                case 0: /* result is long long */
      712 +                case 0:                 /* result is long long */
      713 +
 674  714                          switch (info->res.type) {
 675  715                          case fex_int:
 676      -                                info->res.val.l = (long long) info->res.val.i;
      716 +                                info->res.val.l = (long long)info->res.val.i;
 677  717                                  break;
 678  718  
 679  719                          case fex_float:
 680      -                                info->res.val.l = (long long) info->res.val.f;
      720 +                                info->res.val.l = (long long)info->res.val.f;
 681  721                                  break;
 682  722  
 683  723                          case fex_double:
 684      -                                info->res.val.l = (long long) info->res.val.d;
      724 +                                info->res.val.l = (long long)info->res.val.d;
 685  725                                  break;
 686  726  
 687  727                          case fex_ldouble:
 688      -                                info->res.val.l = (long long) info->res.val.q;
      728 +                                info->res.val.l = (long long)info->res.val.q;
 689  729                                  break;
 690  730  
 691  731                          default:
 692  732                                  break;
 693  733                          }
 694      -                        *(long long*)FPREG(rd) = info->res.val.l;
      734 +
      735 +                        *(long long *)FPREG(rd) = info->res.val.l;
 695  736                          break;
 696  737  
 697      -                case 0x4: /* result is float */
      738 +                case 0x4:               /* result is float */
      739 +
 698  740                          switch (info->res.type) {
 699  741                          case fex_int:
 700      -                                info->res.val.f = (float) info->res.val.i;
      742 +                                info->res.val.f = (float)info->res.val.i;
 701  743                                  break;
 702  744  
 703  745                          case fex_llong:
 704      -                                info->res.val.f = (float) info->res.val.l;
      746 +                                info->res.val.f = (float)info->res.val.l;
 705  747                                  break;
 706  748  
 707  749                          case fex_double:
 708      -                                info->res.val.f = (float) info->res.val.d;
      750 +                                info->res.val.f = (float)info->res.val.d;
 709  751                                  break;
 710  752  
 711  753                          case fex_ldouble:
 712      -                                info->res.val.f = (float) info->res.val.q;
      754 +                                info->res.val.f = (float)info->res.val.q;
 713  755                                  break;
 714  756  
 715  757                          default:
 716  758                                  break;
 717  759                          }
 718      -                        *(float*)FPreg(rd) = info->res.val.f;
      760 +
      761 +                        *(float *)FPreg(rd) = info->res.val.f;
 719  762                          break;
 720  763  
 721      -                case 0x8: /* result is double */
      764 +                case 0x8:               /* result is double */
      765 +
 722  766                          switch (info->res.type) {
 723  767                          case fex_int:
 724      -                                info->res.val.d = (double) info->res.val.i;
      768 +                                info->res.val.d = (double)info->res.val.i;
 725  769                                  break;
 726  770  
 727  771                          case fex_llong:
 728      -                                info->res.val.d = (double) info->res.val.l;
      772 +                                info->res.val.d = (double)info->res.val.l;
 729  773                                  break;
 730  774  
 731  775                          case fex_float:
 732      -                                info->res.val.d = (double) info->res.val.f;
      776 +                                info->res.val.d = (double)info->res.val.f;
 733  777                                  break;
 734  778  
 735  779                          case fex_ldouble:
 736      -                                info->res.val.d = (double) info->res.val.q;
      780 +                                info->res.val.d = (double)info->res.val.q;
 737  781                                  break;
 738  782  
 739  783                          default:
 740  784                                  break;
 741  785                          }
 742      -                        *(double*)FPREG(rd) = info->res.val.d;
      786 +
      787 +                        *(double *)FPREG(rd) = info->res.val.d;
 743  788                          break;
 744  789  
 745      -                case 0xc: /* result is long double */
      790 +                case 0xc:               /* result is long double */
      791 +
 746  792                          switch (info->res.type) {
 747  793                          case fex_int:
 748      -                                info->res.val.q = (long double) info->res.val.i;
      794 +                                info->res.val.q = (long double)info->res.val.i;
 749  795                                  break;
 750  796  
 751  797                          case fex_llong:
 752      -                                info->res.val.q = (long double) info->res.val.l;
      798 +                                info->res.val.q = (long double)info->res.val.l;
 753  799                                  break;
 754  800  
 755  801                          case fex_float:
 756      -                                info->res.val.q = (long double) info->res.val.f;
      802 +                                info->res.val.q = (long double)info->res.val.f;
 757  803                                  break;
 758  804  
 759  805                          case fex_double:
 760      -                                info->res.val.q = (long double) info->res.val.d;
      806 +                                info->res.val.q = (long double)info->res.val.d;
 761  807                                  break;
 762  808  
 763  809                          default:
 764  810                                  break;
 765  811                          }
 766      -                        *(long double*)FPREG(rd) = info->res.val.q;
      812 +
      813 +                        *(long double *)FPREG(rd) = info->res.val.q;
 767  814                          break;
 768  815                  }
      816 +
 769  817                  return;
 770  818          }
 771  819  
 772      -        if ((opf & 0xf0) == 0x60) { /* fsmuld, fdmulq */
      820 +        if ((opf & 0xf0) == 0x60) {     /* fsmuld, fdmulq */
 773  821                  switch (opf & 0xc0) {
 774      -                case 0x8: /* result is double */
      822 +                case 0x8:               /* result is double */
      823 +
 775  824                          switch (info->res.type) {
 776  825                          case fex_int:
 777      -                                info->res.val.d = (double) info->res.val.i;
      826 +                                info->res.val.d = (double)info->res.val.i;
 778  827                                  break;
 779  828  
 780  829                          case fex_llong:
 781      -                                info->res.val.d = (double) info->res.val.l;
      830 +                                info->res.val.d = (double)info->res.val.l;
 782  831                                  break;
 783  832  
 784  833                          case fex_float:
 785      -                                info->res.val.d = (double) info->res.val.f;
      834 +                                info->res.val.d = (double)info->res.val.f;
 786  835                                  break;
 787  836  
 788  837                          case fex_ldouble:
 789      -                                info->res.val.d = (double) info->res.val.q;
      838 +                                info->res.val.d = (double)info->res.val.q;
 790  839                                  break;
 791  840  
 792  841                          default:
 793  842                                  break;
 794  843                          }
 795      -                        *(double*)FPREG(rd) = info->res.val.d;
      844 +
      845 +                        *(double *)FPREG(rd) = info->res.val.d;
 796  846                          break;
 797  847  
 798      -                case 0xc: /* result is long double */
      848 +                case 0xc:               /* result is long double */
      849 +
 799  850                          switch (info->res.type) {
 800  851                          case fex_int:
 801      -                                info->res.val.q = (long double) info->res.val.i;
      852 +                                info->res.val.q = (long double)info->res.val.i;
 802  853                                  break;
 803  854  
 804  855                          case fex_llong:
 805      -                                info->res.val.q = (long double) info->res.val.l;
      856 +                                info->res.val.q = (long double)info->res.val.l;
 806  857                                  break;
 807  858  
 808  859                          case fex_float:
 809      -                                info->res.val.q = (long double) info->res.val.f;
      860 +                                info->res.val.q = (long double)info->res.val.f;
 810  861                                  break;
 811  862  
 812  863                          case fex_double:
 813      -                                info->res.val.q = (long double) info->res.val.d;
      864 +                                info->res.val.q = (long double)info->res.val.d;
 814  865                                  break;
 815  866  
 816  867                          default:
 817  868                                  break;
 818  869                          }
 819      -                        *(long double*)FPREG(rd) = info->res.val.q;
      870 +
      871 +                        *(long double *)FPREG(rd) = info->res.val.q;
 820  872                          break;
 821  873                  }
      874 +
 822  875                  return;
 823  876          }
 824  877  
 825      -        switch (opf & 3) { /* other arithmetic op */
 826      -        case 1: /* result is float */
      878 +        switch (opf & 3) {              /* other arithmetic op */
      879 +        case 1:                         /* result is float */
      880 +
 827  881                  switch (info->res.type) {
 828  882                  case fex_int:
 829      -                        info->res.val.f = (float) info->res.val.i;
      883 +                        info->res.val.f = (float)info->res.val.i;
 830  884                          break;
 831  885  
 832  886                  case fex_llong:
 833      -                        info->res.val.f = (float) info->res.val.l;
      887 +                        info->res.val.f = (float)info->res.val.l;
 834  888                          break;
 835  889  
 836  890                  case fex_double:
 837      -                        info->res.val.f = (float) info->res.val.d;
      891 +                        info->res.val.f = (float)info->res.val.d;
 838  892                          break;
 839  893  
 840  894                  case fex_ldouble:
 841      -                        info->res.val.f = (float) info->res.val.q;
      895 +                        info->res.val.f = (float)info->res.val.q;
 842  896                          break;
 843  897  
 844  898                  default:
 845  899                          break;
 846  900                  }
 847      -                *(float*)FPreg(rd) = info->res.val.f;
      901 +
      902 +                *(float *)FPreg(rd) = info->res.val.f;
 848  903                  break;
 849  904  
 850      -        case 2: /* result is double */
      905 +        case 2:                         /* result is double */
      906 +
 851  907                  switch (info->res.type) {
 852  908                  case fex_int:
 853      -                        info->res.val.d = (double) info->res.val.i;
      909 +                        info->res.val.d = (double)info->res.val.i;
 854  910                          break;
 855  911  
 856  912                  case fex_llong:
 857      -                        info->res.val.d = (double) info->res.val.l;
      913 +                        info->res.val.d = (double)info->res.val.l;
 858  914                          break;
 859  915  
 860  916                  case fex_float:
 861      -                        info->res.val.d = (double) info->res.val.f;
      917 +                        info->res.val.d = (double)info->res.val.f;
 862  918                          break;
 863  919  
 864  920                  case fex_ldouble:
 865      -                        info->res.val.d = (double) info->res.val.q;
      921 +                        info->res.val.d = (double)info->res.val.q;
 866  922                          break;
 867  923  
 868  924                  default:
 869  925                          break;
 870  926                  }
 871      -                *(double*)FPREG(rd) = info->res.val.d;
      927 +
      928 +                *(double *)FPREG(rd) = info->res.val.d;
 872  929                  break;
 873  930  
 874      -        case 3: /* result is long double */
      931 +        case 3:                         /* result is long double */
      932 +
 875  933                  switch (info->res.type) {
 876  934                  case fex_int:
 877      -                        info->res.val.q = (long double) info->res.val.i;
      935 +                        info->res.val.q = (long double)info->res.val.i;
 878  936                          break;
 879  937  
 880  938                  case fex_llong:
 881      -                        info->res.val.q = (long double) info->res.val.l;
      939 +                        info->res.val.q = (long double)info->res.val.l;
 882  940                          break;
 883  941  
 884  942                  case fex_float:
 885      -                        info->res.val.q = (long double) info->res.val.f;
      943 +                        info->res.val.q = (long double)info->res.val.f;
 886  944                          break;
 887  945  
 888  946                  case fex_double:
 889      -                        info->res.val.q = (long double) info->res.val.d;
      947 +                        info->res.val.q = (long double)info->res.val.d;
 890  948                          break;
 891  949  
 892  950                  default:
 893  951                          break;
 894  952                  }
 895      -                *(long double*)FPREG(rd) = info->res.val.q;
      953 +
      954 +                *(long double *)FPREG(rd) = info->res.val.q;
 896  955                  break;
 897  956          }
 898  957  }
 899      -#endif  /* defined(__sparc) */
      958 +#endif /* defined(__sparc) */
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX