1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  24  */
  25 /*
  26  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  27  * Use is subject to license terms.
  28  */
  29 
  30 #if defined(ELFOBJ)
  31 #pragma weak fmaxf = __fmaxf
  32 #endif
  33 
  34 /*
  35  * fmax(x,y) returns the larger of x and y.  If just one of the
  36  * arguments is NaN, fmax returns the other argument.  If both
  37  * arguments are NaN, fmax returns NaN (ideally, one of the
  38  * argument NaNs).
  39  *
  40  * C99 does not require that fmax(-0,+0) = fmax(+0,-0) = +0, but
  41  * ideally fmax should satisfy this.
  42  *
  43  * C99 makes no mention of exceptions for fmax.  I suppose ideally
  44  * either fmax never raises any exceptions or else it raises the
  45  * invalid operation exception if and only if some argument is a
  46  * signaling NaN.  In the former case, fmax should always return
  47  * one of its arguments.  In the latter, fmax shouldn't return a
  48  * signaling NaN, although when both arguments are signaling NaNs,
  49  * this ideal is at odds with the stipulation that fmax should
  50  * always return one of its arguments.
  51  *
  52  * Commutativity of fmax follows from the properties listed above
  53  * except when both arguments are NaN.  In that case, fmax may be
  54  * declared commutative by fiat because there is no portable way
  55  * to tell different NaNs apart.  Ideally fmax would be truly com-
  56  * mutative for all arguments.
  57  *
  58  * On SPARC V8, fmax must involve tests and branches.  Ideally,
  59  * an implementation on SPARC V9 should avoid branching, using
  60  * conditional moves instead where necessary, and be as efficient
  61  * as possible in its use of other resources.
  62  *
  63  * It appears to be impossible to attain all of the aforementioned
  64  * ideals simultaneously.  The implementation below satisfies the
  65  * following (on SPARC):
  66  *
  67  * 1. fmax(x,y) returns the larger of x and y if neither x nor y
  68  *    is NaN and the non-NaN argument if just one of x or y is NaN.
  69  *    If both x and y are NaN, fmax(x,y) returns x unchanged.
  70  * 2. fmax(-0,+0) = fmax(+0,-0) = +0.
  71  * 3. If either argument is a signaling NaN, fmax raises the invalid
  72  *    operation exception.  Otherwise, it raises no exceptions.
  73  */
  74 
  75 #include "libm.h"       /* for isgreaterequal macro */
  76 
  77 float
  78 __fmaxf(float x, float y) {
  79         /*
  80          * On SPARC v8plus/v9, this could be implemented as follows
  81          * (assuming %f0 = x, %f1 = y, return value left in %f0):
  82          *
  83          * fcmps        %fcc0,%f1,%f1
  84          * fmovsu       %fcc0,%f0,%f1
  85          * fcmps        %fcc0,%f0,%f1
  86          * fmovsul      %fcc0,%f1,%f0
  87          * st           %f0,[x]
  88          * st           %f1,[y]
  89          * ld           [x],%l0
  90          * ld           [y],%l1
  91          * and          %l0,%l1,%l2
  92          * sethi        %hi(0x80000000),%l3
  93          * andn         %l3,%l2,%l2
  94          * andn         %l0,%l2,%l0
  95          * st           %l0,[x]
  96          * ld           [x],%f0
  97          *
  98          * If VIS instructions are available, use this code instead:
  99          *
 100          * fcmps        %fcc0,%f1,%f1
 101          * fmovsu       %fcc0,%f0,%f1
 102          * fcmps        %fcc0,%f0,%f1
 103          * fmovsul      %fcc0,%f1,%f0
 104          * fands        %f0,%f1,%f2
 105          * fzeros       %f3
 106          * fnegs        %f3,%f3
 107          * fandnot2s %f3,%f2,%f2
 108          * fandnot2s %f0,%f2,%f0
 109          *
 110          * If VIS 3.0 instructions are available, use this:
 111          *
 112          * flcmps       %fcc0,%f0,%f1
 113          * fmovslg      %fcc0,%f1,%f0   ! move if %fcc0 is 1 or 2
 114          */
 115 
 116         union {
 117                 unsigned i;
 118                 float f;
 119         } xx, yy;
 120         unsigned s;
 121 
 122         /* if y is nan, replace it by x */
 123         if (y != y)
 124                 y = x;
 125 
 126         /* if x is nan, replace it by y */
 127         if (x != x)
 128                 x = y;
 129 
 130         /* At this point, x and y are either both numeric, or both NaN */
 131         if (!isnan(x) && !isgreaterequal(x, y))
 132                 x = y;
 133 
 134         /*
 135          * clear the sign of the result if either x or y has its sign clear
 136          */
 137         xx.f = x;
 138         yy.f = y;
 139         s = ~(xx.i & yy.i) & 0x80000000;
 140         xx.i &= ~s;
 141 
 142         return (xx.f);
 143 }