github.com/ccccaoqing/test@v0.0.0-20220510085219-3985d23445c0/src/math/dim_amd64.s (about)

     1  // Copyright 2010 The Go Authors.  All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  #include "textflag.h"
     6  
     7  #define PosInf 0x7FF0000000000000
     8  #define NaN    0x7FF8000000000001
     9  #define NegInf 0xFFF0000000000000
    10  
    11  // func Dim(x, y float64) float64
    12  TEXT ·Dim(SB),NOSPLIT,$0
    13  	// (+Inf, +Inf) special case
    14  	MOVQ    x+0(FP), BX
    15  	MOVQ    y+8(FP), CX
    16  	MOVQ    $PosInf, AX
    17  	CMPQ    AX, BX
    18  	JNE     dim2
    19  	CMPQ    AX, CX
    20  	JEQ     bothInf
    21  dim2:	// (-Inf, -Inf) special case
    22  	MOVQ    $NegInf, AX
    23  	CMPQ    AX, BX
    24  	JNE     dim3
    25  	CMPQ    AX, CX
    26  	JEQ     bothInf
    27  dim3:	// (NaN, x) or (x, NaN)
    28  	MOVQ    $~(1<<63), DX
    29  	MOVQ    $NaN, AX
    30  	ANDQ    DX, BX // x = |x|
    31  	CMPQ    AX, BX
    32  	JLE     isDimNaN
    33  	ANDQ    DX, CX // y = |y|
    34  	CMPQ    AX, CX
    35  	JLE     isDimNaN
    36  
    37  	MOVSD x+0(FP), X0
    38  	SUBSD y+8(FP), X0
    39  	MOVSD $(0.0), X1
    40  	MAXSD X1, X0
    41  	MOVSD X0, ret+16(FP)
    42  	RET
    43  bothInf: // Dim(-Inf, -Inf) or Dim(+Inf, +Inf)
    44  	MOVQ    $NaN, AX
    45  isDimNaN:
    46  	MOVQ    AX, ret+16(FP)
    47  	RET
    48  
    49  // func ·Max(x, y float64) float64
    50  TEXT ·Max(SB),NOSPLIT,$0
    51  	// +Inf special cases
    52  	MOVQ    $PosInf, AX
    53  	MOVQ    x+0(FP), R8
    54  	CMPQ    AX, R8
    55  	JEQ     isPosInf
    56  	MOVQ    y+8(FP), R9
    57  	CMPQ    AX, R9
    58  	JEQ     isPosInf
    59  	// NaN special cases
    60  	MOVQ    $~(1<<63), DX // bit mask
    61  	MOVQ    $NaN, AX
    62  	MOVQ    R8, BX
    63  	ANDQ    DX, BX // x = |x|
    64  	CMPQ    AX, BX
    65  	JLE     isMaxNaN
    66  	MOVQ    R9, CX
    67  	ANDQ    DX, CX // y = |y|
    68  	CMPQ    AX, CX
    69  	JLE     isMaxNaN
    70  	// ±0 special cases
    71  	ORQ     CX, BX
    72  	JEQ     isMaxZero
    73  
    74  	MOVQ    R8, X0
    75  	MOVQ    R9, X1
    76  	MAXSD   X1, X0
    77  	MOVSD   X0, ret+16(FP)
    78  	RET
    79  isMaxNaN: // return NaN
    80  isPosInf: // return +Inf
    81  	MOVQ    AX, ret+16(FP)
    82  	RET
    83  isMaxZero:
    84  	MOVQ    $(1<<63), AX // -0.0
    85  	CMPQ    AX, R8
    86  	JEQ     +3(PC)
    87  	MOVQ    R8, ret+16(FP) // return 0
    88  	RET
    89  	MOVQ    R9, ret+16(FP) // return other 0
    90  	RET
    91  
    92  /*
    93  	MOVQ    $0, AX
    94  	CMPQ    AX, R8
    95  	JNE     +3(PC)
    96  	MOVQ    R8, ret+16(FP) // return 0
    97  	RET
    98  	MOVQ    R9, ret+16(FP) // return other 0
    99  	RET
   100  */
   101  
   102  // func Min(x, y float64) float64
   103  TEXT ·Min(SB),NOSPLIT,$0
   104  	// -Inf special cases
   105  	MOVQ    $NegInf, AX
   106  	MOVQ    x+0(FP), R8
   107  	CMPQ    AX, R8
   108  	JEQ     isNegInf
   109  	MOVQ    y+8(FP), R9
   110  	CMPQ    AX, R9
   111  	JEQ     isNegInf
   112  	// NaN special cases
   113  	MOVQ    $~(1<<63), DX
   114  	MOVQ    $NaN, AX
   115  	MOVQ    R8, BX
   116  	ANDQ    DX, BX // x = |x|
   117  	CMPQ    AX, BX
   118  	JLE     isMinNaN
   119  	MOVQ    R9, CX
   120  	ANDQ    DX, CX // y = |y|
   121  	CMPQ    AX, CX
   122  	JLE     isMinNaN
   123  	// ±0 special cases
   124  	ORQ     CX, BX
   125  	JEQ     isMinZero
   126  
   127  	MOVQ    R8, X0
   128  	MOVQ    R9, X1
   129  	MINSD   X1, X0
   130  	MOVSD X0, ret+16(FP)
   131  	RET
   132  isMinNaN: // return NaN
   133  isNegInf: // return -Inf
   134  	MOVQ    AX, ret+16(FP)
   135  	RET
   136  isMinZero:
   137  	MOVQ    $(1<<63), AX // -0.0
   138  	CMPQ    AX, R8
   139  	JEQ     +3(PC)
   140  	MOVQ    R9, ret+16(FP) // return other 0
   141  	RET
   142  	MOVQ    R8, ret+16(FP) // return -0
   143  	RET
   144