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 #pragma weak fmaxf = __fmaxf
  31 
  32 /*
  33  * fmax(x,y) returns the larger of x and y.  If just one of the
  34  * arguments is NaN, fmax returns the other argument.  If both
  35  * arguments are NaN, fmax returns NaN (ideally, one of the
  36  * argument NaNs).
  37  *
  38  * C99 does not require that fmax(-0,+0) = fmax(+0,-0) = +0, but
  39  * ideally fmax should satisfy this.
  40  *
  41  * C99 makes no mention of exceptions for fmax.  I suppose ideally
  42  * either fmax never raises any exceptions or else it raises the
  43  * invalid operation exception if and only if some argument is a
  44  * signaling NaN.  In the former case, fmax should always return
  45  * one of its arguments.  In the latter, fmax shouldn't return a
  46  * signaling NaN, although when both arguments are signaling NaNs,
  47  * this ideal is at odds with the stipulation that fmax should
  48  * always return one of its arguments.
  49  *
  50  * Commutativity of fmax follows from the properties listed above
  51  * except when both arguments are NaN.  In that case, fmax may be
  52  * declared commutative by fiat because there is no portable way
  53  * to tell different NaNs apart.  Ideally fmax would be truly com-
  54  * mutative for all arguments.
  55  *
  56  * On SPARC V8, fmax must involve tests and branches.  Ideally,
  57  * an implementation on SPARC V9 should avoid branching, using
  58  * conditional moves instead where necessary, and be as efficient
  59  * as possible in its use of other resources.
  60  *
  61  * It appears to be impossible to attain all of the aforementioned
  62  * ideals simultaneously.  The implementation below satisfies the
  63  * following (on SPARC):
  64  *
  65  * 1. fmax(x,y) returns the larger of x and y if neither x nor y
  66  *    is NaN and the non-NaN argument if just one of x or y is NaN.
  67  *    If both x and y are NaN, fmax(x,y) returns x unchanged.
  68  * 2. fmax(-0,+0) = fmax(+0,-0) = +0.
  69  * 3. If either argument is a signaling NaN, fmax raises the invalid
  70  *    operation exception.  Otherwise, it raises no exceptions.
  71  */
  72 
  73 #include "libm.h"       /* for isgreaterequal macro */
  74 
  75 float
  76 __fmaxf(float x, float y) {
  77         /*
  78          * On SPARC v8plus/v9, this could be implemented as follows
  79          * (assuming %f0 = x, %f1 = y, return value left in %f0):
  80          *
  81          * fcmps        %fcc0,%f1,%f1
  82          * fmovsu       %fcc0,%f0,%f1
  83          * fcmps        %fcc0,%f0,%f1
  84          * fmovsul      %fcc0,%f1,%f0
  85          * st           %f0,[x]
  86          * st           %f1,[y]
  87          * ld           [x],%l0
  88          * ld           [y],%l1
  89          * and          %l0,%l1,%l2
  90          * sethi        %hi(0x80000000),%l3
  91          * andn         %l3,%l2,%l2
  92          * andn         %l0,%l2,%l0
  93          * st           %l0,[x]
  94          * ld           [x],%f0
  95          *
  96          * If VIS instructions are available, use this code instead:
  97          *
  98          * fcmps        %fcc0,%f1,%f1
  99          * fmovsu       %fcc0,%f0,%f1
 100          * fcmps        %fcc0,%f0,%f1
 101          * fmovsul      %fcc0,%f1,%f0
 102          * fands        %f0,%f1,%f2
 103          * fzeros       %f3
 104          * fnegs        %f3,%f3
 105          * fandnot2s %f3,%f2,%f2
 106          * fandnot2s %f0,%f2,%f0
 107          *
 108          * If VIS 3.0 instructions are available, use this:
 109          *
 110          * flcmps       %fcc0,%f0,%f1
 111          * fmovslg      %fcc0,%f1,%f0   ! move if %fcc0 is 1 or 2
 112          */
 113 
 114         union {
 115                 unsigned i;
 116                 float f;
 117         } xx, yy;
 118         unsigned s;
 119 
 120         /* if y is nan, replace it by x */
 121         if (y != y)
 122                 y = x;
 123 
 124         /* if x is nan, replace it by y */
 125         if (x != x)
 126                 x = y;
 127 
 128         /* At this point, x and y are either both numeric, or both NaN */
 129         if (!isnan(x) && !isgreaterequal(x, y))
 130                 x = y;
 131 
 132         /*
 133          * clear the sign of the result if either x or y has its sign clear
 134          */
 135         xx.f = x;
 136         yy.f = y;
 137         s = ~(xx.i & yy.i) & 0x80000000;
 138         xx.i &= ~s;
 139 
 140         return (xx.f);
 141 }