--- /dev/null	Thu Oct  9 19:48:52 2014
+++ new/usr/src/lib/libm/amd64/src/libm_inlines.h	Thu Oct  9 19:48:52 2014
@@ -0,0 +1,221 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
+ */
+/*
+ * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright 2011, Richard Lowe.
+ */
+
+/* Functions in this file are duplicated in locallibm.il.  Keep them in sync */
+
+#ifndef _LIBM_INLINES_H
+#define	_LIBM_INLINES_H
+
+#ifdef __GNUC__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+#include <sys/ieeefp.h>
+
+extern __inline__ float
+__inline_sqrtf(float a)
+{
+	float ret;
+
+	__asm__ __volatile__("sqrtss %1, %0\n\t" : "=x" (ret) : "x" (a));
+	return (ret);
+}
+
+extern __inline__ double
+__inline_sqrt(double a)
+{
+	double ret;
+
+	__asm__ __volatile__("sqrtsd %1, %0\n\t" : "=x" (ret) : "x" (a));
+	return (ret);
+}
+
+extern __inline__ double
+__ieee754_sqrt(double a)
+{
+	return (__inline_sqrt(a));
+}
+
+/*
+ * 00 - 24 bits
+ * 01 - reserved
+ * 10 - 53 bits
+ * 11 - 64 bits
+ */
+extern __inline__ int
+__swapRP(int i)
+{
+	int ret;
+	uint16_t cw;
+
+	__asm__ __volatile__("fstcw %0\n\t" : "=m" (cw));
+
+	ret = (cw >> 8) & 0x3;
+	cw = (cw & 0xfcff) | ((i & 0x3) << 8);
+
+	__asm__ __volatile__("fldcw %0\n\t" : : "m" (cw));
+
+	return (ret);
+}
+
+/*
+ * 00 - Round to nearest, with even preferred
+ * 01 - Round down
+ * 10 - Round up
+ * 11 - Chop
+ */
+extern __inline__ enum fp_direction_type
+__swap87RD(enum fp_direction_type i)
+{
+	int ret;
+	uint16_t cw;
+
+	__asm__ __volatile__("fstcw %0\n\t" : "=m" (cw));
+
+	ret = (cw >> 10) & 0x3;
+	cw = (cw & 0xf3ff) | ((i & 0x3) << 10);
+
+	__asm__ __volatile__("fldcw %0\n\t" : : "m" (cw));
+
+	return (ret);
+}
+
+extern __inline__ int
+abs(int i)
+{
+	int ret;
+	__asm__ __volatile__(
+	    "movl    %1, %0\n\t"
+	    "negl    %1\n\t"
+	    "cmovnsl %1, %0\n\t"
+	    : "=r" (ret), "+r" (i)
+	    :
+	    : "cc");
+	return (ret);
+}
+
+extern __inline__ double
+copysign(double d1, double d2)
+{
+	double tmpd;
+
+	__asm__ __volatile__(
+	    "movd %3, %1\n\t"
+	    "andpd %1, %0\n\t"
+	    "andnpd %2, %1\n\t"
+	    "orpd %1, %0\n\t"
+	    : "+&x" (d1), "=&x" (tmpd)
+	    : "x" (d2), "r" (0x7fffffffffffffff));
+
+	return (d1);
+}
+
+extern __inline__ double
+fabs(double d)
+{
+	double tmp;
+
+	__asm__ __volatile__(
+	    "movd  %2, %1\n\t"
+	    "andpd %1, %0"
+	    : "+x" (d), "=&x" (tmp)
+	    : "r" (0x7fffffffffffffff));
+
+	return (d);
+}
+
+extern __inline__ float
+fabsf(float d)
+{
+	__asm__ __volatile__(
+	    "andpd %1, %0"
+	    : "+x" (d)
+	    : "x" (0x7fffffff));
+
+	return (d);
+}
+
+extern __inline__ int
+finite(double d)
+{
+	long ret = 0x7fffffffffffffff;
+	uint64_t tmp;
+
+	__asm__ __volatile__(
+	    "movq %2, %1\n\t"
+	    "andq %1, %0\n\t"
+	    "movq $0x7ff0000000000000, %1\n\t"
+	    "subq %1, %0\n\t"
+	    "shrq $63, %0\n\t"
+	    : "+r" (ret), "=r" (tmp)
+	    : "x" (d)
+	    : "cc");
+
+	return (ret);
+}
+
+extern __inline__ int
+signbit(double d)
+{
+	long ret;
+	__asm__ __volatile__(
+	    "movmskpd %1, %0\n\t"
+	    "andq     $1, %0\n\t"
+	    : "=r" (ret)
+	    : "x" (d)
+	    : "cc");
+	return (ret);
+}
+
+extern __inline__ double
+sqrt(double d)
+{
+	return (__inline_sqrt(d));
+}
+
+extern __inline__ float
+sqrtf(float f)
+{
+	return (__inline_sqrtf(f));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __GNUC__ */
+
+#endif /* _LIBM_INLINES_H */
