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 /*
  27  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30 
  31 #pragma weak __ceilf = ceilf
  32 #pragma weak __floorf = floorf
  33 
  34 
  35 /*
  36  * ceilf(x)     return the biggest integral value (in float) below x
  37  * floorf(x)    return the least integral value (in float) above x
  38  *
  39  * NOTE: ceilf(x) and floorf(x) return result
  40  * with the same sign as x's,  including 0.0F.
  41  */
  42 
  43 #include "libm.h"
  44 
  45 static const float xf[] = {
  46 /* ZEROF */
  47         0.0f,
  48 /* ONEF */ 1.0f,
  49 /* MONEF */ -1.0f,
  50 /* HUGEF */ 1.0e30f, };
  51 
  52 #define ZEROF           xf[0]
  53 #define ONEF            xf[1]
  54 #define MONEF           xf[2]
  55 #define HUGEF           xf[3]
  56 
  57 float
  58 ceilf(float x)
  59 {
  60         volatile float dummy __unused;
  61         int hx, k, j, ix;
  62 
  63         hx = *(int *)&x;
  64         ix = hx & ~0x80000000;
  65         k = ix >> 23;
  66 
  67         if (((k - 127) ^ (k - 150)) < 0) {
  68                 k = (1 << (150 - k)) - 1;
  69 
  70                 if ((k & hx) != 0)
  71                         dummy = HUGEF + x;      /* raise inexact */
  72 
  73                 j = k & (~(hx >> 31));
  74                 *(int *)&x = (hx + j) & ~k;
  75                 return (x);
  76         } else if (k <= 126) {
  77                 dummy = HUGEF + x;
  78 
  79                 if (hx > 0)
  80                         return (ONEF);
  81                 else if (ix == 0)
  82                         return (x);
  83                 else
  84                         return (-ZEROF);
  85         } else {
  86                 /* signal invalid if x is a SNaN */
  87                 return (x * ONEF);      /* +0 -> *1 for Cheetah */
  88         }
  89 }
  90 
  91 float
  92 floorf(float x)
  93 {
  94         volatile float dummy __unused;
  95         int hx, k, j, ix;
  96 
  97         hx = *(int *)&x;
  98         ix = hx & ~0x80000000;
  99         k = ix >> 23;
 100 
 101         if (((k - 127) ^ (k - 150)) < 0) {
 102                 k = (1 << (150 - k)) - 1;
 103 
 104                 if ((k & hx) != 0)
 105                         dummy = HUGEF + x;      /* raise inexact */
 106 
 107                 j = k & (hx >> 31);
 108                 *(int *)&x = (hx + j) & ~k;
 109                 return (x);
 110         } else if (k <= 126) {
 111                 dummy = HUGEF + x;
 112 
 113                 if (hx > 0)
 114                         return (ZEROF);
 115                 else if (ix == 0)
 116                         return (x);
 117                 else
 118                         return (MONEF);
 119         } else {
 120                 /* signal invalid if x is a SNaN */
 121                 return (x * ONEF);      /* +0 -> *1 for Cheetah */
 122         }
 123 }