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