5262 libm needs to be carefully unifdef'd
5268 libm doesn't need to hide symbols which are already local

          --- old/usr/src/lib/libm/common/m9x/frexp.c
          +++ new/usr/src/lib/libm/common/m9x/frexp.c

   1    1  /*
   2    2   * CDDL HEADER START
   3    3   *
   4    4   * The contents of this file are subject to the terms of the
   5    5   * Common Development and Distribution License (the "License").
   6    6   * You may not use this file except in compliance with the License.
   7    7   *
   8    8   * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9    9   * or http://www.opensolaris.org/os/licensing.
  10   10   * See the License for the specific language governing permissions
  11   11   * and limitations under the License.
  12   12   *
  13   13   * When distributing Covered Code, include this CDDL HEADER in each
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  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   * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  27   27   * Use is subject to license terms.
  28   28   */
  29   29  
  30      -#if defined(ELFOBJ)
  31   30  #pragma weak frexp = __frexp
  32      -#endif
  33   31  
  34   32  /*
  35   33   * frexp(x, exp) returns the normalized significand of x and sets
  36   34   * *exp so that x = r*2^(*exp) where r is the return value.  If x
  37   35   * is finite and nonzero, 1/2 <= |r| < 1.
  38   36   *
  39   37   * If x is zero, infinite or NaN, frexp returns x and sets *exp = 0.
  40   38   * (The relevant standards do not specify *exp when x is infinite or
  41   39   * NaN, but this code sets it anyway.)
  42   40   *

  43   41   * If x is a signaling NaN, this code returns x without attempting
  44   42   * to raise the invalid operation exception.  If x is subnormal,
  45   43   * this code treats it as nonzero regardless of nonstandard mode.
  46   44   */
  47   45  
  48   46  #include "libm.h"
  49   47  
  50   48  double
  51   49  __frexp(double x, int *exp) {
  52   50          union {
  53   51                  unsigned i[2];
  54   52                  double d;
  55   53          } xx, yy;
  56   54          double t;
  57   55          unsigned hx;
  58   56          int e;
  59   57  
  60   58          xx.d = x;
  61   59          hx = xx.i[HIWORD] & ~0x80000000;
  62   60  
  63   61          if (hx >= 0x7ff00000) { /* x is infinite or NaN */
  64   62                  *exp = 0;
  65   63                  return (x);
  66   64          }
  67   65  
  68   66          e = 0;
  69   67          if (hx < 0x00100000) { /* x is subnormal or zero */
  70   68                  if ((hx | xx.i[LOWORD]) == 0) {
  71   69                          *exp = 0;
  72   70                          return (x);
  73   71                  }
  74   72  
  75   73                  /*
  76   74                   * normalize x by regarding it as an integer
  77   75                   *
  78   76                   * Here we use 32-bit integer arithmetic to avoid trapping
  79   77                   * or emulating 64-bit arithmetic.  If 64-bit arithmetic is
  80   78                   * available (e.g., in SPARC V9), do this instead:
  81   79                   *
  82   80                   *  long lx = ((long) hx << 32) | xx.i[LOWORD];
  83   81                   *  xx.d = (xx.i[HIWORD] < 0)? -lx : lx;
  84   82                   *
  85   83                   * If subnormal arithmetic doesn't trap, just multiply x by
  86   84                   * a power of two.
  87   85                   */
  88   86                  yy.i[HIWORD] = 0x43300000 | hx;
  89   87                  yy.i[LOWORD] = xx.i[LOWORD];
  90   88                  t = yy.d;
  91   89                  yy.i[HIWORD] = 0x43300000;
  92   90                  yy.i[LOWORD] = 0;
  93   91                  t -= yy.d; /* t = |x| scaled */
  94   92                  xx.d = ((int)xx.i[HIWORD] < 0)? -t : t;
  95   93                  hx = xx.i[HIWORD] & ~0x80000000;
  96   94                  e = -1074;
  97   95          }
  98   96  
  99   97          /* now xx.d is normal */
 100   98          xx.i[HIWORD] = (xx.i[HIWORD] & ~0x7ff00000) | 0x3fe00000;
 101   99          *exp = e + (hx >> 20) - 0x3fe;
 102  100          return (xx.d);
 103  101  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX