sysdeps/ia64/fpu/e_hypot.S

   1 .file "hypot.asm"
   2
   3 // Copyright (c) 2000, 2001, Intel Corporation
   4 // All rights reserved.
   5 //
   6 // Contributed 2/2/2000 by John Harrison, Cristina Iordache, Ted Kubaska,
   7 // Bob Norin, Shane Story, and Ping Tak Peter Tang of the
   8 // Computational Software Lab, Intel Corporation.
   9 //
  10 // WARRANTY DISCLAIMER
  11 //
  12 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  13 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  14 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  15 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS
  16 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  17 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  18 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  19 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  20 // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING
  21 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  22 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23 //
  24 // Intel Corporation is the author of this code, and requests that all
  25 // problem reports or change requests be submitted to it directly at
  26 // http://developer.intel.com/opensource.
  27 //
  28 // *********************************************************************
  29 //
  30 // History:
  31 // 2/02/00  hand-optimized
  32 // 4/04/00  Unwind support added
  33 // 6/20/00  new version
  34 // 8/15/00  Bundle added after call to __libm_error_support to properly
  35 //          set [the previously overwritten] GR_Parameter_RESULT.
  36 //
  37 // *********************************************************************
  38 //                           ___________
  39 // Function:   hypot(x,y) = |(x^2 + y^2) = for double precision values
  40 //             x and y
  41 //             Also provides cabs functionality.
  42 //
  43 // *********************************************************************
  44 //
  45 // Resources Used:
  46 //
  47 //    Floating-Point Registers: f8  (Input and Return Value)
  48 //                              f9  (Input)
  49 //                              f6 -f15, f32-f34
  50 //
  51 //    General Purpose Registers:
  52 //      r2,r3,r29 (Scratch)
  53 //      r32-r36 (Locals)
  54 //      r37-r40 (Used to pass arguments to error handling routine)
  55 //
  56 //    Predicate Registers:      p6 - p10
  57 //
  58 // *********************************************************************
  59 //
  60 // IEEE Special Conditions:
  61 //
  62 //    All faults and exceptions should be raised correctly.
  63 //    Overflow can occur.
  64 //    hypot(Infinity and anything) = +Infinity
  65 //    hypot(QNaN and anything) = QNaN
  66 //    hypot(SNaN and anything ) = QNaN
  67 //
  68 // *********************************************************************
  69 //
  70 // Implementation:
  71 //  x2 = x * x   in double-extended
  72 //  y2 = y * y   in double-extended
  73 //  temp = x2 + y2   in double-extended
  74 //  sqrt(temp) rounded to double
  75 //
  76 // *********************************************************************
  77
  78 #include "libm_support.h"
  79
  80 GR_SAVE_PFS         = r33
  81 GR_SAVE_B0          = r34
  82 GR_SAVE_GP          = r35
  83 GR_Parameter_X      = r36
  84 GR_Parameter_Y      = r37
  85 GR_Parameter_RESULT = r38
  86 GR_Parameter_TAG    = r39
  87
  88 FR_X                = f32
  89 FR_Y                = f33
  90 FR_RESULT           = f8
  91
  92 .section .text
  93 #ifndef _LIBC
  94 .proc cabs#
  95 .global cabs#
  96 cabs:
  97 .endp cabs
  98 #endif
  99 .proc hypot#
 100 .global hypot#
 101 .align 64
 102
 103 hypot:
 104 #ifdef _LIBC
 105 .global __hypot
 106 __hypot:
 107 .global __ieee754_hypot
 108 __ieee754_hypot:
 109 #endif
 110 {.mfi
 111   alloc r32= ar.pfs,0,4,4,0
 112   // Compute x*x
 113   fma.s1 f10=f8,f8,f0
 114   // r2=bias-1
 115   mov r2=0xfffe
 116 }
 117 {.mfi
 118   // 63/8
 119   mov r3=0x40fc //0000
 120   // y*y
 121   fma.s1 f11=f9,f9,f0
 122   // r29=429/16
 123   mov r29=0x41d68;; //000
 124 }
 125
 126 { .mfi
 127      nop.m 0
 128 //   Check if x is an Inf - if so return Inf even
 129 //   if y is a NaN (C9X)
 130      fclass.m.unc p7, p6 = f8, 0x023
 131      shl r3=r3,16
 132 }
 133 {.mfi
 134         nop.m 0
 135   // if possible overflow, copy f8 to f32
 136   // set Denormal, if necessary
 137   // (p8)
 138   fma.d.s0 f32=f8,f1,f0
 139   nop.i 0;;
 140 }
 141 { .mfi
 142      nop.m 0
 143 //   Check if y is an Inf - if so return Inf even
 144 //   if x is a NaN (C9X)
 145      fclass.m.unc p8, p9 = f9, 0x023
 146      shl r29=r29,12
 147 }
 148 { .mfb
 149          // f7=0.5
 150          setf.exp f7=r2
 151 //   For x=inf, multiply y by 1 to raise invalid on y an SNaN
 152 //   (p7) fma.s0 f9=f9,f1,f0
 153      // copy f9 to f33; set Denormal, if necessary
 154          fma.d.s0 f33=f9,f1,f0
 155      nop.b 0;;
 156 }
 157 {.mfb
 158   // f13=63/8
 159   setf.s f13=r3
 160   // is y Zero ?
 161   (p6) fclass.m p6,p0=f9,0x7
 162   nop.b 0
 163 }
 164 {.mlx
 165   nop.m 0
 166   movl r2=0x408c0000;;
 167 }
 168
 169 {.mfi
 170   // f34=429/16
 171   setf.s f34=r29
 172   // is x Zero ?
 173   (p9) fclass.m p9,p0=f8,0x7
 174   // 231/16
 175   mov r3=0x4167;; //0000
 176 }
 177 {.mfi
 178   nop.m 0
 179   // a=x2+y2
 180   fma.s1 f12=f10,f1,f11
 181   nop.i 0;;
 182 }
 183 {.mfi
 184   nop.m 0
 185   // y not NaN ?
 186   (p9) fclass.m p8,p0=f9,0x3f
 187   shl r3=r3,16
 188 }
 189 {.mfi
 190   nop.m 0
 191   // f6=2
 192   fma.s1 f6=f1,f1,f1
 193   nop.i 0;;
 194 }
 195
 196
 197 {.mfi
 198   nop.m 0
 199   // x not NaN ?
 200   (p6) fclass.m p7,p0=f8,0x3f
 201   nop.i 0;;
 202 }
 203 {.mfi
 204   // f9=35/8
 205   setf.s f9=r2
 206   nop.f 0
 207   // 2*emax-2
 208   mov r2=0x107fb;;
 209 }
 210
 211 {.mfb
 212   nop.m 0
 213   // if f8=Infinity or f9=Zero, return |f8|
 214   (p7) fmerge.s f8=f0,f32
 215   (p7) br.ret.spnt b0
 216 }
 217 {.mfb
 218   nop.m 0
 219   // if f9=Infinity or f8=Zero, return |f9|
 220   (p8) fmerge.s f8=f0,f33
 221   (p8) br.ret.spnt b0;;
 222 }
 223
 224
 225 {.mfi
 226   // f10 =231/16
 227   setf.s f10=r3
 228   // z0=frsqrta(a)
 229   frsqrta.s1 f8,p6=f12
 230   nop.i 0;;
 231 }
 232
 233 { .mfi
 234          nop.m 0
 235 //   Identify Natvals, Infs, NaNs, and Zeros
 236 //   and return result
 237      fclass.m.unc p7, p0 = f12, 0x1E7
 238      nop.i 0;;
 239 }
 240 {.mfb
 241   // get exponent of x^2+y^2
 242   getf.exp r3=f12
 243   // if special case, set f8
 244   (p7) mov f8=f12
 245   (p7) br.ret.spnt b0;;
 246 }
 247
 248
 249 {.mfi
 250   nop.m 0
 251   // S0=a*z0
 252   (p6) fma.s1 f14=f12,f8,f0
 253   nop.i 0
 254 }
 255 {.mfi
 256   nop.m 0
 257   // H0=0.5*z0
 258   (p6) fma.s1 f15=f8,f7,f0
 259   nop.i 0;;
 260 }
 261
 262
 263 {.mfi
 264   nop.m 0
 265   // f6=5/2
 266   fma.s1 f6=f7,f1,f6
 267   nop.i 0
 268 }
 269 {.mfi
 270   nop.m 0
 271   // f11=3/2
 272   fma.s1 f11=f7,f1,f1
 273   nop.i 0;;
 274 }
 275
 276 {.mfi
 277   nop.m 0
 278   // d=0.5-S0*H0
 279   (p6) fnma.s1 f7=f14,f15,f7
 280   nop.i 0;;
 281 }
 282
 283 {.mfi
 284   nop.m 0
 285   // P67=231/16+429/16*d
 286   (p6) fma.s1 f10=f34,f7,f10
 287   nop.i 0
 288 }
 289 {.mfi
 290   nop.m 0
 291   // P45=63/8*d+35/8
 292   (p6) fma.s1 f9=f13,f7,f9
 293   nop.i 0;;
 294 }
 295 {.mfi
 296   nop.m 0
 297   // P23=5/2*d+3/2
 298   (p6) fma.s1 f11=f6,f7,f11
 299   nop.i 0
 300 }
 301 {.mfi
 302   nop.m 0
 303   // d2=d*d
 304   (p6) fma.s1 f13=f7,f7,f0
 305   nop.i 0;;
 306 }
 307
 308 {.mfi
 309   nop.m 0
 310   // P47=d2*P67+P45
 311   (p6) fma.s1 f10=f10,f13,f9
 312   nop.i 0
 313 }
 314 {.mfi
 315   nop.m 0
 316   // P13=d*P23+1
 317   (p6) fma.s1 f11=f11,f7,f1
 318   nop.i 0;;
 319 }
 320 {.mfi
 321   nop.m 0
 322   // d3=d2*d
 323   (p6) fma.s1 f13=f13,f7,f0
 324   nop.i 0;;
 325 }
 326
 327 {.mfi
 328   nop.m 0
 329   // T0=d*S0
 330   (p6) fma.s1 f15=f7,f14,f0
 331   nop.i 0
 332 }
 333 {.mfi
 334   // Is x^2 + y^2 well less than the overflow
 335   // threshold?
 336   (p6) cmp.lt.unc p7, p8 =  r3,r2
 337   // P=P13+d3*P47
 338   (p6) fma.s1 f10=f13,f10,f11
 339   nop.i 0;;
 340 }
 341
 342 {.mfb
 343   nop.m 0
 344   // S=P*T0+S0
 345   fma.d.s0 f8=f10,f15,f14
 346   // No overflow in this case
 347   (p7) br.ret.sptk b0;;
 348 }
 349
 350 { .mfi
 351      nop.m 0
 352 (p8) fsetc.s2 0x7F,0x42
 353      // Possible overflow path, must detect by
 354      // Setting widest range exponent with prevailing
 355      // rounding mode.
 356      nop.i 0 ;;
 357 }
 358
 359
 360 { .mfi
 361    // bias+0x400 (bias+EMAX+1)
 362    (p8) mov r2=0x103ff
 363    // S=P*T0+S0
 364    (p8) fma.d.s2 f12=f10,f15,f14
 365    nop.i 0 ;;
 366 }
 367 { .mfi
 368 (p8) setf.exp f11 = r2
 369 (p8) fsetc.s2 0x7F,0x40
 370 //   Restore Original Mode in S2
 371      nop.i 0 ;;
 372 }
 373 { .mfi
 374      nop.m 0
 375 (p8) fcmp.lt.unc.s1 p9, p10 =  f12, f11
 376      nop.i 0 ;;
 377 }
 378 { .mib
 379      nop.m 0
 380      mov GR_Parameter_TAG = 46
 381          // No overflow
 382 (p9) br.ret.sptk b0;;
 383 }
 384 .endp hypot
 385 ASM_SIZE_DIRECTIVE(hypot)
 386
 387 .proc __libm_error_region
 388 __libm_error_region:
 389 .prologue
 390 { .mfi
 391         add   GR_Parameter_Y=-32,sp             // Parameter 2 value
 392         nop.f 0
 393 .save   ar.pfs,GR_SAVE_PFS
 394         mov  GR_SAVE_PFS=ar.pfs                 // Save ar.pfs
 395 }
 396 { .mfi
 397 .fframe 64
 398         add sp=-64,sp                           // Create new stack
 399         nop.f 0
 400         mov GR_SAVE_GP=gp                       // Save gp
 401 };;
 402 { .mmi
 403         stfd [GR_Parameter_Y] = FR_Y,16         // Save Parameter 2 on stack
 404         add GR_Parameter_X = 16,sp              // Parameter 1 address
 405 .save   b0, GR_SAVE_B0
 406         mov GR_SAVE_B0=b0                       // Save b0
 407 };;
 408 .body
 409 { .mib
 410         stfd [GR_Parameter_X] = FR_X            // Store Parameter 1 on stack
 411         add   GR_Parameter_RESULT = 0,GR_Parameter_Y
 412         nop.b 0                                 // Parameter 3 address
 413 }
 414 { .mib
 415         stfd [GR_Parameter_Y] = FR_RESULT      // Store Parameter 3 on stack
 416         add   GR_Parameter_Y = -16,GR_Parameter_Y
 417         br.call.sptk b0=__libm_error_support#  // Call error handling function
 418 };;
 419 { .mmi
 420         nop.m 0
 421         nop.m 0
 422         add   GR_Parameter_RESULT = 48,sp
 423 };;
 424 { .mmi
 425         ldfd  f8 = [GR_Parameter_RESULT]       // Get return result off stack
 426 .restore sp
 427         add   sp = 64,sp                       // Restore stack pointer
 428         mov   b0 = GR_SAVE_B0                  // Restore return address
 429 };;
 430 { .mib
 431         mov   gp = GR_SAVE_GP                  // Restore gp
 432         mov   ar.pfs = GR_SAVE_PFS             // Restore ar.pfs
 433         br.ret.sptk     b0                     // Return
 434 };;
 435 .endp __libm_error_region
 436 ASM_SIZE_DIRECTIVE(__libm_error_region)
 437 .type   __libm_error_support#,@function
 438 .global __libm_error_support#