--- /dev/null	Sat May 10 12:09:57 2014
+++ new/usr/src/lib/libmvec/common/vis/__vatan.S	Sat May 10 12:09:57 2014
@@ -0,0 +1,572 @@
+/*
+ * 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.
+ */
+
+	.file	"__vatan.S"
+
+#include "libm.h"
+
+	RO_DATA
+
+! following is the C version of the ATAN algorithm
+!  #include <math.h>
+!  #include <stdio.h>
+!  double jkatan(double *x)
+!  {
+!    double  f, z, ans, ansu, ansl, tmp, poly, conup, conlo, dummy;
+!    int index, sign, intf, intz;
+!    extern const double __vlibm_TBL_atan1[];
+!    long *pf = (long *) &f, *pz = (long *) &z;
+!  
+!  /*    Power series  atan(x) = x + p1*x**3 + p2*x**5 + p3*x**7
+!   *    Error =  -3.08254E-18   On the interval  |x| < 1/64 */
+!  
+!  /* define dummy names for readability.  Use parray to help compiler optimize loads */
+!  #define p3    parray[0]
+!  #define p2    parray[1]
+!  #define p1    parray[2]
+!  #define soffset      3  
+!  
+!    static const double parray[] = { 
+!     -1.428029046844299722E-01,		/* p[3]		*/
+!      1.999999917247000615E-01, 		/* p[2]		*/
+!     -3.333333333329292858E-01, 		/* p[1]		*/
+!      1.0, 				/* not used for p[0], though		*/
+!     -1.0,				/* used to flip sign of answer 		*/
+!    };
+!  
+!    f        = *x;				/* fetch argument		*/
+!    intf     = pf[0];				/* grab upper half		*/
+!    sign     = intf & 0x80000000;			/* sign of argument		*/
+!    intf    ^= sign;				/* abs(upper argument)		*/
+!    sign     = (unsigned) sign >> 31;		/* sign bit = 0 or 1		*/
+!    pf[0]    = intf;
+!  
+!    if( (intf > 0x43600000) || (intf < 0x3e300000) ) /* filter out special cases */
+!    {
+!      if(  (intf > 0x7ff00000) || 
+!        ((intf == 0x7ff00000) &&  (pf[1] !=0)) ) return (*x-*x);/* return NaN if x=NaN*/
+!      if( intf < 0x3e300000 ) 			/* avoid underflow for small arg */
+!      {
+!        dummy = 1.0e37 + f;
+!        dummy = dummy;
+!        return (*x);
+!      }
+!      if( intf > 0x43600000 )			/* avoid underflow for big arg  */
+!      {
+!        index = 2;
+!        f     = __vlibm_TBL_atan1[index] + __vlibm_TBL_atan1[index+1];/* pi/2 up + pi/2 low   */
+!        f     = parray[soffset + sign] * f;	/* put sign bit on ans		*/
+!        return (f);
+!      }
+!    }
+!  
+!    index    = 0;				/* points to 0,0 in table	*/
+!    if (intf > 0x40500000)			/* if(|x| > 64               	*/
+!    { f = -1.0/f;
+!      index  = 2; 				/* point to pi/2 upper, lower	*/
+!    }
+!    else if( intf >= 0x3f900000 )		/* if |x| >= (1/64)... 		*/
+!    {
+!      intz   = (intf + 0x00008000) & 0x7fff0000;/* round arg, keep upper	*/
+!      pz[0]  = intz;				/* store as a double (z)	*/
+!      pz[1]  = 0;				/* ...lower			*/
+!      f      = (f - z)/(1.0 + f*z); 		/* get reduced argument		*/
+!      index  = (intz - 0x3f900000) >> 15;	/* (index >> 16) << 1)		*/
+!      index += 4;				/* skip over 0,0,pi/2,pi/2	*/
+!    }
+!    conup    = __vlibm_TBL_atan1[index];	/* upper table 			*/
+!    conlo    = __vlibm_TBL_atan1[index+1];	/* lower table 			*/
+!    tmp      = f*f;
+!    poly     = (f*tmp)*((p3*tmp + p2)*tmp + p1);
+!    ansu     = conup + f;     			/* compute atan(f)  upper 	*/
+!    ansl     = (((conup - ansu) + f) + poly) + conlo;
+!    ans      = ansu + ansl;
+!    ans      = parray[soffset + sign] * ans;
+!    return ans;
+!  }
+
+/* 8 bytes = 1 double f.p. word */
+#define WSIZE	8
+
+	.align	32			!align with full D-cache line
+.COEFFS:
+	.double	0r-1.428029046844299722E-01 	!p[3]
+        .double 0r1.999999917247000615E-01 	!p[2]
+        .double 0r-3.333333333329292858E-01	!p[1]
+        .double 0r-1.0, 			!constant -1.0
+	.word   0x00008000,0x0			!for fp rounding of reduced arg
+	.word   0x7fff0000,0x0			!for fp truncation
+	.word	0x47900000,0			!a number close to 1.0E37
+	.word   0x80000000,0x0			!mask for fp sign bit
+	.word   0x3f800000,0x0			!1.0/128.0 dummy "safe" argument
+	.type	.COEFFS,#object
+
+	ENTRY(__vatan)
+	save	%sp,-SA(MINFRAME)-16,%sp
+	PIC_SETUP(g5)
+	PIC_SET(g5,__vlibm_TBL_atan1,o4)
+	PIC_SET(g5,.COEFFS,o0)
+/*
+   __vatan(int n, double *x, int stridex, double *y, stridey)
+   computes y(i) = atan( x(i) ), for 1=1,n.  Stridex, stridey
+   are the distance between x and y elements			 
+
+	%i0    n
+	%i1    address of x
+	%i2    stride x
+	%i3    address of y
+	%i4    stride y
+*/
+	cmp	%i0,0			!if n <=0,
+	ble,pn	%icc,.RETURN		!....then do nothing
+	sll	%i2,3,%i2		!convert stride to byte count
+	sll	%i4,3,%i4		!convert stride to byte count
+
+/*  pre-load constants before beginning main loop */
+
+	ldd	[%o0],%f58		!load p[3]
+	mov	2,%i5			!argcount = 3 
+
+	ldd	[%o0+WSIZE],%f60	!load p[2]
+	add	%fp,STACK_BIAS-8,%l1		!yaddr1 = &dummy
+	fzero   %f18			!ansu1 = 0
+
+	ldd	[%o0+2*WSIZE],%f62	!load p[1]
+	add	%fp,STACK_BIAS-8,%l2		!yaddr2 = &dummy
+	fzero   %f12			!(poly1) = 0
+
+	ldd 	[%o0+3*WSIZE],%f56	!-1.0 
+	fzero   %f14			!tmp1 = 0
+
+	ldd     [%o0+4*WSIZE],%f52	!load rounding mask
+	fzero   %f16			!conup1 = 0
+
+	ldd     [%o0+5*WSIZE],%f54	!load truncation mask
+	fzero   %f36			!f1 = 0
+
+	ldd	[%o0+6*WSIZE],%f50	!1.0e37
+	fzero   %f38			!f2 = 0
+
+	ldd	[%o0+7*WSIZE],%f32	!mask for sign bit
+
+	ldd	[%o4+2*WSIZE],%f46	!pi/2 upper
+	ldd	[%o4+(2*WSIZE+8)],%f48	!pi/2 lower 
+	sethi	%hi(0x40500000),%l6	!64.0
+	sethi	%hi(0x3f900000),%l7	!1/64.0
+	mov     0,%l4			!index1 = 0
+	mov     0,%l5			!index2 = 0
+
+.MAINLOOP:
+
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+
+.LOOP0:
+        deccc   %i0                     !--n
+	bneg	1f
+        mov	%i1,%o5			!xuse = x (delay slot)
+
+	ba	2f
+	nop				!delay slot
+1:
+	PIC_SET(g5,.COEFFS+8*WSIZE,o5)
+	dec	%i5			!argcount--
+2:
+	sethi	%hi(0x80000000),%o7	!mask for sign bit
+/*2 */  sethi	%hi(0x43600000),%o1	!big = 0x43600000,0
+	ld	[%o5],%o0		!intf = pf[0] = f upper
+	ldd     [%o4+%l5],%f26		!conup2 = __vlibm_TBL_atan1[index2]
+
+	sethi	%hi(0x3e300000),%o2	!small = 0x3e300000,0
+/*4 */  andn	%o0,%o7,%o0		!intf = fabs(intf)
+	ldd 	[%o5],%f34		!f = *x into f34
+
+	sub	%o1,%o0,%o1		!(-) if intf > big
+/*6 */  sub	%o0,%o2,%o2		!(-) if intf < small
+	fand 	%f34,%f32,%f40		!sign0 = sign bit 
+            fmuld   %f38,%f38,%f24      !tmp2= f2*f2
+
+/*7 */  orcc	%o1,%o2,%g0		!(-) if either true
+ 	bneg,pn  %icc,.SPECIAL0		!if (-) goto special cases below
+	fabsd	%f34,%f34		!abs(f)  (delay slot)
+	!----------------------
+
+
+	sethi   %hi(0x8000),%o7		!rounding bit
+/*8 */  fpadd32 %f34,%f52,%f0		!intf + 0x00008000 (again)
+            faddd   %f26,%f38,%f28      !ansu2 = conup2 + f2
+
+ 	add	%o0,%o7,%o0		!intf + 0x00008000  (delay slot)
+/*9*/   fand    %f0,%f54,%f0		!pz[0] = intz = (intf + 0x00008000) & 0x7fff0000 (again)
+            fmuld   %f58,%f24,%f22      !p[3]*tmp2
+
+/*10 */ sethi   %hi(0x7fff0000),%o7     !mask for rounding argument
+	fmuld	%f34,%f0,%f10		!f*z
+	fsubd	%f34,%f0,%f20		!f - z
+          add     %o4,%l4,%l4           !base addr + index1
+          fmuld   %f14,%f12,%f12        !poly1 = (f1*tmp1)*((p3*tmp1 + p2)*tmp1 + p1)
+          faddd   %f16,%f36,%f16        !(conup1 - ansu1) + f1
+
+/*12 */ and	%o0,%o7,%o0		!intz = (intf + 0x00008000) & 0x7fff0000
+            faddd   %f22,%f60,%f22      !p[3]*tmp2 + p[2]
+          ldd     [%l4+WSIZE],%f14      !conlo1 = __vlibm_TBL_atan1[index+1]
+
+/*13 */ sub	%o0,%l7,%o2		!intz - 0x3f900000
+	fsubd	%f10,%f56,%f10		!(f*z - (-1.0))
+          faddd   %f16,%f12,%f12        !((conup1 - ansu1) + f1) + poly1
+
+	cmp	%o0,%l6			!(|f| > 64)
+        ble	.ELSE0			!if(|f| > 64) then
+/*15 */ sra	  %o2,15,%o3		!index  = (intz - 0x3f900000) >> 15
+	  mov	  2,%o1			!index == 2, point to conup, conlo = pi/2 upper, lower
+          ba	  .ENDIF0		!continue
+/*16 */   fdivd	  %f56,%f34,%f34	!f = -1.0/f (delay slot)
+        .ELSE0:				!else f( |x| >= (1/64))
+	cmp	%o0,%l7			!if intf >= 1/64
+	bl  	.ENDIF0			!if( |x| >= (1/64) ) then...
+	mov	0,%o1			!index == 0 , point to conup,conlo = 0,0
+          add	  %o3,4,%o1		!index = index + 4
+/*16 */   fdivd	  %f20,%f10,%f34	!f = (f - z)/(1.0 + f*z), reduced argument
+	.ENDIF0:
+
+/*17*/  sll	%o1,3,%l3		!index0 = index
+	mov	%i3,%l0			!yaddr0 = address of y
+          faddd   %f12,%f14,%f12        !ansl1 = (((conup1 - ansu)1 + f1) + poly1) + conlo1
+            fmuld   %f22,%f24,%f22      !(p3*tmp2 + p2)*tmp2
+            fsubd   %f26,%f28,%f26      !conup2 - ansu2
+
+/*20*/  add	%i1,%i2,%i1		!x     += stridex
+        add	%i3,%i4,%i3		!y     += stridey
+          faddd   %f18,%f12,%f36        !ans1 = ansu1 + ansl1
+            fmuld   %f38,%f24,%f24      !f*tmp2
+            faddd   %f22,%f62,%f22      !(p3*tmp2 + p2)*tmp2 + p1
+
+/*23*/    for     %f36,%f42,%f36        !sign(ans1) = sign of argument
+          std     %f36,[%l1]            !*yaddr1 = ans1
+            add     %o4,%l5,%l5         !base addr + index2
+            fmuld   %f24,%f22,%f22      !poly2 = (f2*tmp2)*((p3*tmp2 + p2)*tmp2 + p1)
+            faddd   %f26,%f38,%f26      !(conup2 - ansu2) + f2
+	cmp	%i5,0			!if argcount =0, we are done
+	be	.RETURN
+	  nop
+
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+
+.LOOP1:
+/*25*/  deccc   %i0                     !--n
+        bneg    1f
+        mov     %i1,%o5                 !xuse = x (delay slot)
+        ba      2f
+        nop                             !delay slot
+1:
+	PIC_SET(g5,.COEFFS+8*WSIZE,o5)
+        dec     %i5                     !argcount--
+2:
+
+/*26*/  sethi	%hi(0x80000000),%o7	!mask for sign bit
+	sethi	%hi(0x43600000),%o1	!big = 0x43600000,0
+	ld	[%o5],%o0		!intf = pf[0] = f upper
+
+/*28*/  sethi	%hi(0x3e300000),%o2	!small = 0x3e300000,0
+	andn	%o0,%o7,%o0		!intf = fabs(intf)
+	ldd 	[%o5],%f36		!f = *x into f36
+
+/*30*/  sub	%o1,%o0,%o1		!(-) if intf > big
+	sub	%o0,%o2,%o2		!(-) if intf < small
+	fand 	%f36,%f32,%f42		!sign1 = sign bit 
+
+/*31*/  orcc	%o1,%o2,%g0		!(-) if either true
+ 	bneg,pn  %icc,.SPECIAL1		!if (-) goto special cases below
+	fabsd	%f36,%f36		!abs(f)  (delay slot)
+	!----------------------
+
+/*32*/  fpadd32 %f36,%f52,%f0		!intf + 0x00008000 (again)
+          ldd     [%l5+WSIZE],%f24      !conlo2 = __vlibm_TBL_atan1[index2+1]
+
+/*33*/  fand    %f0,%f54,%f0		!pz[0] = intz = (intf + 0x00008000) & 0x7fff0000 (again)
+        sethi   %hi(0x8000),%o7		!rounding bit
+          faddd   %f26,%f22,%f22        !((conup2 - ansu2) + f2) + poly2
+
+/*34*/  add	%o0,%o7,%o0		!intf + 0x00008000  (delay slot)
+	sethi   %hi(0x7fff0000),%o7	!mask for rounding argument
+	fmuld	%f36,%f0,%f10		!f*z
+	fsubd	%f36,%f0,%f20		!f - z
+
+/*35*/  and	%o0,%o7,%o0		!intz = (intf + 0x00008000) & 0x7fff0000
+          faddd   %f22,%f24,%f22        !ansl2 = (((conup2 - ansu2) + f2) + poly2) + conlo2
+
+/*37*/  sub	%o0,%l7,%o2		!intz - 0x3f900000
+	fsubd	%f10,%f56,%f10		!(f*z - (-1.0))
+      ldd     [%o4+%l3],%f6             !conup0 = __vlibm_TBL_atan1[index0]
+
+        cmp	%o0,%l6			!(|f| > 64)
+	ble	.ELSE1			!if(|f| > 64) then
+/*38*/  sra	%o2,15,%o3		!index  = (intz - 0x3f900000) >> 15
+          mov	  2,%o1			!index == 2, point to conup, conlo = pi/2 upper, lower
+	  ba	  .ENDIF1		!continue
+/*40*/    fdivd	  %f56,%f36,%f36	!f = -1.0/f (delay slot)
+        .ELSE1:				!else f( |x| >= (1/64))
+	cmp	%o0,%l7			!if intf >= 1/64
+	bl  	.ENDIF1			!if( |x| >= (1/64) ) then...
+	mov	0,%o1			!index == 0 , point to conup,conlo = 0,0
+          add	  %o3,4,%o1		!index = index + 4
+/*40*/    fdivd	  %f20,%f10,%f36	!f = (f - z)/(1.0 + f*z), reduced argument
+	.ENDIF1:
+
+/*41*/sll     %o1,3,%l4		 	!index1 = index
+      mov     %i3,%l1			!yaddr1 = address of y
+      fmuld   %f34,%f34,%f4             !tmp0= f0*f0
+          faddd   %f28,%f22,%f38        !ans2 = ansu2 + ansl2
+        
+/*44*/add	%i1,%i2,%i1		!x     += stridex
+      add	%i3,%i4,%i3		!y     += stridey
+    fmuld   %f58,%f4,%f2                !p[3]*tmp0
+    faddd   %f6,%f34,%f8                !ansu0 = conup0 + f0
+          for     %f38,%f44,%f38        !sign(ans2) = sign of argument
+          std     %f38,[%l2]            !*yaddr2 = ans2
+          cmp	%i5,0			!if argcount =0, we are done
+	  be	.RETURN
+	  nop
+
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+
+.LOOP2:
+/*46*/  deccc   %i0                     !--n
+        bneg    1f
+        mov     %i1,%o5                 !xuse = x (delay slot)
+        ba      2f
+        nop                             !delay slot
+1:
+	PIC_SET(g5,.COEFFS+8*WSIZE,o5)
+        dec     %i5                     !argcount--
+2:
+
+/*47*/  sethi	%hi(0x80000000),%o7	!mask for sign bit
+	sethi	%hi(0x43600000),%o1	!big = 0x43600000,0
+	ld	[%o5],%o0		!intf = pf[0] = f upper
+
+/*49*/  sethi	%hi(0x3e300000),%o2	!small = 0x3e300000,0
+	andn	%o0,%o7,%o0		!intf = fabs(intf)
+	ldd 	[%o5],%f38		!f = *x into f38
+
+/*51*/  sub	%o1,%o0,%o1		!(-) if intf > big
+	sub	%o0,%o2,%o2		!(-) if intf < small
+	fand 	%f38,%f32,%f44		!sign2 = sign bit 
+
+/*52*/  orcc	%o1,%o2,%g0		!(-) if either true
+ 	bneg,pn  %icc,.SPECIAL2		!if (-) goto special cases below
+	fabsd	%f38,%f38		!abs(f)  (delay slot)
+	!----------------------
+
+/*53*/  fpadd32 %f38,%f52,%f0		!intf + 0x00008000 (again)
+      faddd   %f2,%f60,%f2              !p[3]*tmp0 + p[2]
+
+/*54*/  sethi   %hi(0x8000),%o7		!rounding bit
+	fand    %f0,%f54,%f0		!pz[0] = intz = (intf + 0x00008000) & 0x7fff0000 (again)
+
+/*55*/  add	%o0,%o7,%o0		!intf + 0x00008000  (delay slot)
+	sethi   %hi(0x7fff0000),%o7     !mask for rounding argument
+	fmuld	%f38,%f0,%f10		!f*z
+	fsubd	%f38,%f0,%f20		!f - z
+
+/*56*/  and	%o0,%o7,%o0		!intz = (intf + 0x00008000) & 0x7fff0000
+      fmuld   %f2,%f4,%f2               !(p3*tmp0 + p2)*tmp0
+      fsubd   %f6,%f8,%f6               !conup0 - ansu0
+
+/*58*/  sub	%o0,%l7,%o2		!intz - 0x3f900000
+	fsubd	%f10,%f56,%f10		!(f*z - (-1.0))
+            ldd     [%o4+%l4],%f16      !conup1 = __vlibm_TBL_atan1[index1]
+
+	cmp	%o0,%l6			!(|f| > 64)
+	ble	.ELSE2			!if(|f| > 64) then
+/*60*/  sra	%o2,15,%o3		!index  = (intz - 0x3f900000) >> 15
+	  mov	  2,%o1			!index == 2, point to conup, conlo = pi/2 upper, lower
+	  ba	  .ENDIF2		!continue
+/*61*/    fdivd	  %f56,%f38,%f38	!f = -1.0/f (delay slot)
+        .ELSE2:				!else f( |x| >= (1/64))
+	cmp	%o0,%l7			!if intf >= 1/64
+	bl  	.ENDIF2			!if( |x| >= (1/64) ) then...
+	mov	0,%o1			!index == 0 , point to conup,conlo = 0,0
+          add	  %o3,4,%o1		!index = index + 4
+/*61*/    fdivd	  %f20,%f10,%f38	!f = (f - z)/(1.0 + f*z), reduced argument
+	.ENDIF2:
+
+        
+/*62*/  sll	%o1,3,%l5		!index2 = index
+	mov	%i3,%l2			!yaddr2 = address of y
+      fmuld   %f34,%f4,%f4              !f0*tmp0
+      faddd   %f2,%f62,%f2              !(p3*tmp0 + p2)*tmp0 + p1
+            fmuld   %f36,%f36,%f14      !tmp1= f1*f1
+
+/*65*/add     %o4,%l3,%l3               !base addr + index0
+      fmuld   %f4,%f2,%f2               !poly0 = (f0*tmp0)*((p3*tmp0 + p2)*tmp0 + p1)
+      faddd   %f6,%f34,%f6              !(conup0 - ansu0) + f0
+            fmuld   %f58,%f14,%f12      !p[3]*tmp1
+            faddd   %f16,%f36,%f18      !ansu1 = conup1 + f1
+      ldd     [%l3+WSIZE],%f4           !conlo0 = __vlibm_TBL_atan1[index0+1]
+
+/*68*/  add	%i1,%i2,%i1		!x     += stridex
+	add	%i3,%i4,%i3		!y     += stridey
+      faddd   %f6,%f2,%f2               !((conup0 - ansu0) + f0) + poly0
+            faddd   %f12,%f60,%f12      !p[3]*tmp1 + p[2]
+
+/*71*/faddd   %f2,%f4,%f2               !ansl0 = (((conup0 - ansu)0 + f0) + poly0) + conlo0
+            fmuld   %f12,%f14,%f12      !(p3*tmp1 + p2)*tmp1
+            fsubd   %f16,%f18,%f16      !conup1 - ansu1
+
+/*74*/faddd   %f8,%f2,%f34              !ans0 = ansu0 + ansl0
+          fmuld   %f36,%f14,%f14        !f1*tmp1
+          faddd   %f12,%f62,%f12        !(p3*tmp1 + p2)*tmp1 + p1
+
+/*77*/  for     %f34,%f40,%f34          !sign(ans0) = sign of argument
+        std     %f34,[%l0]              !*yaddr0 = ans, always gets stored (delay slot)
+        cmp	%i5,0			!if argcount =0, we are done
+	bg	.MAINLOOP
+	  nop
+
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+
+.RETURN:
+	ret
+	restore	%g0,%g0,%g0
+
+    /*--------------------------------------------------------------------------*/
+    /*------------SPECIAL CASE HANDLING FOR LOOP0 ------------------------------*/
+    /*--------------------------------------------------------------------------*/
+
+/* at this point
+   %i1     x address
+   %o0     intf
+   %o2     intf - 0x3e300000
+   %f34,36,38     f0,f1,f2
+   %f40,42,44     sign0,sign1,sign2
+*/
+
+ 	.align	32				!align on I-cache boundary
+.SPECIAL0:
+	orcc	%o2,%g0,%g0			!(-) if intf < 0x3e300000
+	bpos	1f  				!if >=...continue
+	sethi	%hi(0x7ff00000),%g1	!upper word of Inf (we use 64-bit wide int for this)
+	  ba	  3f
+	  faddd	  %f34,%f50,%f30		!dummy op just to generate exception (delay slot)
+1:
+	ld	[%o5+4],%o5			!load x lower word  
+	sllx	%o0,32,%o0			!left justify intf
+	sllx	%g1,32,%g1		!left justify Inf
+	or	%o0,%o5,%o0			!merge in lower intf
+	cmp	%o0,%g1				!if intf > 0x7ff00000 00000000
+	ble,pt	%xcc,2f				!pass thru if NaN
+	  nop
+	  fmuld	  %f34,%f34,%f34		!...... (x*x) trigger invalid exception
+	  ba      3f
+	  nop
+2:
+	faddd	%f46,%f48,%f34			!ans = pi/2 upper + pi/2 lower 
+3:   
+	add	%i1,%i2,%i1			!x += stridex
+	for     %f34,%f40,%f34			!sign(ans) = sign of argument
+	std	%f34,[%i3]			!*y = ans
+	ba	.LOOP0				!keep looping
+	add	%i3,%i4,%i3			!y += stridey (delay slot)
+
+    /*--------------------------------------------------------------------------*/
+    /*-----------SPECIAL CASE HANDLING FOR LOOP1 -------------------------------*/
+    /*--------------------------------------------------------------------------*/
+
+ 	.align	32				!align on I-cache boundary
+.SPECIAL1:
+	orcc	%o2,%g0,%g0			!(-) if intf < 0x3e300000
+	bpos	1f  				!if >=...continue
+	sethi	%hi(0x7ff00000),%g1	!upper word of Inf (we use 64-bit wide int for this)
+	  ba	  3f
+	  faddd	  %f36,%f50,%f30		!dummy op just to generate exception (delay slot)
+1:
+	ld	[%o5+4],%o5			!load x lower word  
+	sllx	%o0,32,%o0			!left justify intf
+	sllx	%g1,32,%g1		!left justify Inf
+	or	%o0,%o5,%o0			!merge in lower intf
+	cmp	%o0,%g1				!if intf > 0x7ff00000 00000000
+	ble,pt	%xcc,2f				!pass thru if NaN
+	  nop
+	  fmuld	  %f36,%f36,%f36		!...... (x*x) trigger invalid exception
+	  ba      3f
+	  nop
+2:
+	faddd	%f46,%f48,%f36			!ans = pi/2 upper + pi/2 lower 
+3:   
+	add	%i1,%i2,%i1			!x += stridex
+	for     %f36,%f42,%f36			!sign(ans) = sign of argument
+	std	%f36,[%i3]			!*y = ans
+	ba      .LOOP1 				!keep looping
+	add	%i3,%i4,%i3			!y += stridey (delay slot)
+
+    /*--------------------------------------------------------------------------*/
+    /*------------SPECIAL CASE HANDLING FOR LOOP2 ------------------------------*/
+    /*--------------------------------------------------------------------------*/
+
+ 	.align	32				!align on I-cache boundary
+.SPECIAL2:
+	orcc	%o2,%g0,%g0			!(-) if intf < 0x3e300000
+	bpos	1f  				!if >=...continue
+	sethi	%hi(0x7ff00000),%g1	!upper word of Inf (we use 64-bit wide int for this)
+	  ba	  3f
+	  faddd	  %f38,%f50,%f30		!dummy op just to generate exception (delay slot)
+1:
+	ld	[%o5+4],%o5			!load x lower word  
+	sllx	%o0,32,%o0			!left justify intf
+	sllx	%g1,32,%g1		!left justify Inf
+	or	%o0,%o5,%o0			!merge in lower intf
+	cmp	%o0,%g1				!if intf > 0x7ff00000 00000000
+	ble,pt	%xcc,2f				!pass thru if NaN
+	  nop
+	  fmuld	  %f38,%f38,%f38		!...... (x*x) trigger invalid exception
+	  ba      3f
+	  nop
+2:
+	faddd	%f46,%f48,%f38			!ans = pi/2 upper + pi/2 lower 
+3:   
+	add	%i1,%i2,%i1			!x += stridex
+	for     %f38,%f44,%f38			!sign(ans) = sign of argument
+	std	%f38,[%i3]			!*y = ans
+	ba      .LOOP2 				!keep looping
+	add	%i3,%i4,%i3			!y += stridey
+
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
+
+	SET_SIZE(__vatan)
+
+!	.ident	"03-20-96 Sparc V9 3-way-unrolled version"
