test/CodeGen/X86/fmaxnum.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=x86_64-unknown-unknown -mattr=sse2  < %s | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
   3 ; RUN: llc -mtriple=x86_64-unknown-unknown -mattr=avx  < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX1
   4 ; RUN: llc -mtriple=x86_64-unknown-unknown -mattr=avx512f  < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512
   5
   6 declare float @fmaxf(float, float)
   7 declare double @fmax(double, double)
   8 declare x86_fp80 @fmaxl(x86_fp80, x86_fp80)
   9 declare float @llvm.maxnum.f32(float, float)
  10 declare double @llvm.maxnum.f64(double, double)
  11 declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80)
  12
  13 declare <2 x float> @llvm.maxnum.v2f32(<2 x float>, <2 x float>)
  14 declare <4 x float> @llvm.maxnum.v4f32(<4 x float>, <4 x float>)
  15 declare <8 x float> @llvm.maxnum.v8f32(<8 x float>, <8 x float>)
  16 declare <16 x float> @llvm.maxnum.v16f32(<16 x float>, <16 x float>)
  17 declare <2 x double> @llvm.maxnum.v2f64(<2 x double>, <2 x double>)
  18 declare <4 x double> @llvm.maxnum.v4f64(<4 x double>, <4 x double>)
  19 declare <8 x double> @llvm.maxnum.v8f64(<8 x double>, <8 x double>)
  20
  21 ; FIXME: As the vector tests show, the SSE run shouldn't need this many moves.
  22
  23 define float @test_fmaxf(float %x, float %y) {
  24 ; SSE-LABEL: test_fmaxf:
  25 ; SSE:       # %bb.0:
  26 ; SSE-NEXT:    movaps %xmm0, %xmm2
  27 ; SSE-NEXT:    cmpunordss %xmm0, %xmm2
  28 ; SSE-NEXT:    movaps %xmm2, %xmm3
  29 ; SSE-NEXT:    andps %xmm1, %xmm3
  30 ; SSE-NEXT:    maxss %xmm0, %xmm1
  31 ; SSE-NEXT:    andnps %xmm1, %xmm2
  32 ; SSE-NEXT:    orps %xmm3, %xmm2
  33 ; SSE-NEXT:    movaps %xmm2, %xmm0
  34 ; SSE-NEXT:    retq
  35 ;
  36 ; AVX1-LABEL: test_fmaxf:
  37 ; AVX1:       # %bb.0:
  38 ; AVX1-NEXT:    vmaxss %xmm0, %xmm1, %xmm2
  39 ; AVX1-NEXT:    vcmpunordss %xmm0, %xmm0, %xmm0
  40 ; AVX1-NEXT:    vblendvps %xmm0, %xmm1, %xmm2, %xmm0
  41 ; AVX1-NEXT:    retq
  42 ;
  43 ; AVX512-LABEL: test_fmaxf:
  44 ; AVX512:       # %bb.0:
  45 ; AVX512-NEXT:    vmaxss %xmm0, %xmm1, %xmm2
  46 ; AVX512-NEXT:    vcmpunordss %xmm0, %xmm0, %k1
  47 ; AVX512-NEXT:    vmovss %xmm1, %xmm2, %xmm2 {%k1}
  48 ; AVX512-NEXT:    vmovaps %xmm2, %xmm0
  49 ; AVX512-NEXT:    retq
  50   %z = call float @fmaxf(float %x, float %y) readnone
  51   ret float %z
  52 }
  53
  54 define float @test_fmaxf_minsize(float %x, float %y) minsize {
  55 ; CHECK-LABEL: test_fmaxf_minsize:
  56 ; CHECK:       # %bb.0:
  57 ; CHECK-NEXT:    jmp fmaxf # TAILCALL
  58   %z = call float @fmaxf(float %x, float %y) readnone
  59   ret float %z
  60 }
  61
  62 ; FIXME: As the vector tests show, the SSE run shouldn't need this many moves.
  63
  64 define double @test_fmax(double %x, double %y) {
  65 ; SSE-LABEL: test_fmax:
  66 ; SSE:       # %bb.0:
  67 ; SSE-NEXT:    movapd %xmm0, %xmm2
  68 ; SSE-NEXT:    cmpunordsd %xmm0, %xmm2
  69 ; SSE-NEXT:    movapd %xmm2, %xmm3
  70 ; SSE-NEXT:    andpd %xmm1, %xmm3
  71 ; SSE-NEXT:    maxsd %xmm0, %xmm1
  72 ; SSE-NEXT:    andnpd %xmm1, %xmm2
  73 ; SSE-NEXT:    orpd %xmm3, %xmm2
  74 ; SSE-NEXT:    movapd %xmm2, %xmm0
  75 ; SSE-NEXT:    retq
  76 ;
  77 ; AVX1-LABEL: test_fmax:
  78 ; AVX1:       # %bb.0:
  79 ; AVX1-NEXT:    vmaxsd %xmm0, %xmm1, %xmm2
  80 ; AVX1-NEXT:    vcmpunordsd %xmm0, %xmm0, %xmm0
  81 ; AVX1-NEXT:    vblendvpd %xmm0, %xmm1, %xmm2, %xmm0
  82 ; AVX1-NEXT:    retq
  83 ;
  84 ; AVX512-LABEL: test_fmax:
  85 ; AVX512:       # %bb.0:
  86 ; AVX512-NEXT:    vmaxsd %xmm0, %xmm1, %xmm2
  87 ; AVX512-NEXT:    vcmpunordsd %xmm0, %xmm0, %k1
  88 ; AVX512-NEXT:    vmovsd %xmm1, %xmm2, %xmm2 {%k1}
  89 ; AVX512-NEXT:    vmovapd %xmm2, %xmm0
  90 ; AVX512-NEXT:    retq
  91   %z = call double @fmax(double %x, double %y) readnone
  92   ret double %z
  93 }
  94
  95 define x86_fp80 @test_fmaxl(x86_fp80 %x, x86_fp80 %y) {
  96 ; CHECK-LABEL: test_fmaxl:
  97 ; CHECK:       # %bb.0:
  98 ; CHECK-NEXT:    subq $40, %rsp
  99 ; CHECK-NEXT:    .cfi_def_cfa_offset 48
 100 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 101 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 102 ; CHECK-NEXT:    fstpt {{[0-9]+}}(%rsp)
 103 ; CHECK-NEXT:    fstpt (%rsp)
 104 ; CHECK-NEXT:    callq fmaxl
 105 ; CHECK-NEXT:    addq $40, %rsp
 106 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 107 ; CHECK-NEXT:    retq
 108   %z = call x86_fp80 @fmaxl(x86_fp80 %x, x86_fp80 %y) readnone
 109   ret x86_fp80 %z
 110 }
 111
 112 define float @test_intrinsic_fmaxf(float %x, float %y) {
 113 ; SSE-LABEL: test_intrinsic_fmaxf:
 114 ; SSE:       # %bb.0:
 115 ; SSE-NEXT:    movaps %xmm0, %xmm2
 116 ; SSE-NEXT:    cmpunordss %xmm0, %xmm2
 117 ; SSE-NEXT:    movaps %xmm2, %xmm3
 118 ; SSE-NEXT:    andps %xmm1, %xmm3
 119 ; SSE-NEXT:    maxss %xmm0, %xmm1
 120 ; SSE-NEXT:    andnps %xmm1, %xmm2
 121 ; SSE-NEXT:    orps %xmm3, %xmm2
 122 ; SSE-NEXT:    movaps %xmm2, %xmm0
 123 ; SSE-NEXT:    retq
 124 ;
 125 ; AVX1-LABEL: test_intrinsic_fmaxf:
 126 ; AVX1:       # %bb.0:
 127 ; AVX1-NEXT:    vmaxss %xmm0, %xmm1, %xmm2
 128 ; AVX1-NEXT:    vcmpunordss %xmm0, %xmm0, %xmm0
 129 ; AVX1-NEXT:    vblendvps %xmm0, %xmm1, %xmm2, %xmm0
 130 ; AVX1-NEXT:    retq
 131 ;
 132 ; AVX512-LABEL: test_intrinsic_fmaxf:
 133 ; AVX512:       # %bb.0:
 134 ; AVX512-NEXT:    vmaxss %xmm0, %xmm1, %xmm2
 135 ; AVX512-NEXT:    vcmpunordss %xmm0, %xmm0, %k1
 136 ; AVX512-NEXT:    vmovss %xmm1, %xmm2, %xmm2 {%k1}
 137 ; AVX512-NEXT:    vmovaps %xmm2, %xmm0
 138 ; AVX512-NEXT:    retq
 139   %z = call float @llvm.maxnum.f32(float %x, float %y) readnone
 140   ret float %z
 141 }
 142
 143 define double @test_intrinsic_fmax(double %x, double %y) {
 144 ; SSE-LABEL: test_intrinsic_fmax:
 145 ; SSE:       # %bb.0:
 146 ; SSE-NEXT:    movapd %xmm0, %xmm2
 147 ; SSE-NEXT:    cmpunordsd %xmm0, %xmm2
 148 ; SSE-NEXT:    movapd %xmm2, %xmm3
 149 ; SSE-NEXT:    andpd %xmm1, %xmm3
 150 ; SSE-NEXT:    maxsd %xmm0, %xmm1
 151 ; SSE-NEXT:    andnpd %xmm1, %xmm2
 152 ; SSE-NEXT:    orpd %xmm3, %xmm2
 153 ; SSE-NEXT:    movapd %xmm2, %xmm0
 154 ; SSE-NEXT:    retq
 155 ;
 156 ; AVX1-LABEL: test_intrinsic_fmax:
 157 ; AVX1:       # %bb.0:
 158 ; AVX1-NEXT:    vmaxsd %xmm0, %xmm1, %xmm2
 159 ; AVX1-NEXT:    vcmpunordsd %xmm0, %xmm0, %xmm0
 160 ; AVX1-NEXT:    vblendvpd %xmm0, %xmm1, %xmm2, %xmm0
 161 ; AVX1-NEXT:    retq
 162 ;
 163 ; AVX512-LABEL: test_intrinsic_fmax:
 164 ; AVX512:       # %bb.0:
 165 ; AVX512-NEXT:    vmaxsd %xmm0, %xmm1, %xmm2
 166 ; AVX512-NEXT:    vcmpunordsd %xmm0, %xmm0, %k1
 167 ; AVX512-NEXT:    vmovsd %xmm1, %xmm2, %xmm2 {%k1}
 168 ; AVX512-NEXT:    vmovapd %xmm2, %xmm0
 169 ; AVX512-NEXT:    retq
 170   %z = call double @llvm.maxnum.f64(double %x, double %y) readnone
 171   ret double %z
 172 }
 173
 174 define x86_fp80 @test_intrinsic_fmaxl(x86_fp80 %x, x86_fp80 %y) {
 175 ; CHECK-LABEL: test_intrinsic_fmaxl:
 176 ; CHECK:       # %bb.0:
 177 ; CHECK-NEXT:    subq $40, %rsp
 178 ; CHECK-NEXT:    .cfi_def_cfa_offset 48
 179 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 180 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 181 ; CHECK-NEXT:    fstpt {{[0-9]+}}(%rsp)
 182 ; CHECK-NEXT:    fstpt (%rsp)
 183 ; CHECK-NEXT:    callq fmaxl
 184 ; CHECK-NEXT:    addq $40, %rsp
 185 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 186 ; CHECK-NEXT:    retq
 187   %z = call x86_fp80 @llvm.maxnum.f80(x86_fp80 %x, x86_fp80 %y) readnone
 188   ret x86_fp80 %z
 189 }
 190
 191 define <2 x float> @test_intrinsic_fmax_v2f32(<2 x float> %x, <2 x float> %y) {
 192 ; SSE-LABEL: test_intrinsic_fmax_v2f32:
 193 ; SSE:       # %bb.0:
 194 ; SSE-NEXT:    movaps %xmm1, %xmm2
 195 ; SSE-NEXT:    maxps %xmm0, %xmm2
 196 ; SSE-NEXT:    cmpunordps %xmm0, %xmm0
 197 ; SSE-NEXT:    andps %xmm0, %xmm1
 198 ; SSE-NEXT:    andnps %xmm2, %xmm0
 199 ; SSE-NEXT:    orps %xmm1, %xmm0
 200 ; SSE-NEXT:    retq
 201 ;
 202 ; AVX-LABEL: test_intrinsic_fmax_v2f32:
 203 ; AVX:       # %bb.0:
 204 ; AVX-NEXT:    vmaxps %xmm0, %xmm1, %xmm2
 205 ; AVX-NEXT:    vcmpunordps %xmm0, %xmm0, %xmm0
 206 ; AVX-NEXT:    vblendvps %xmm0, %xmm1, %xmm2, %xmm0
 207 ; AVX-NEXT:    retq
 208   %z = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> %y) readnone
 209   ret <2 x float> %z
 210 }
 211
 212 define <4 x float> @test_intrinsic_fmax_v4f32(<4 x float> %x, <4 x float> %y) {
 213 ; SSE-LABEL: test_intrinsic_fmax_v4f32:
 214 ; SSE:       # %bb.0:
 215 ; SSE-NEXT:    movaps %xmm1, %xmm2
 216 ; SSE-NEXT:    maxps %xmm0, %xmm2
 217 ; SSE-NEXT:    cmpunordps %xmm0, %xmm0
 218 ; SSE-NEXT:    andps %xmm0, %xmm1
 219 ; SSE-NEXT:    andnps %xmm2, %xmm0
 220 ; SSE-NEXT:    orps %xmm1, %xmm0
 221 ; SSE-NEXT:    retq
 222 ;
 223 ; AVX-LABEL: test_intrinsic_fmax_v4f32:
 224 ; AVX:       # %bb.0:
 225 ; AVX-NEXT:    vmaxps %xmm0, %xmm1, %xmm2
 226 ; AVX-NEXT:    vcmpunordps %xmm0, %xmm0, %xmm0
 227 ; AVX-NEXT:    vblendvps %xmm0, %xmm1, %xmm2, %xmm0
 228 ; AVX-NEXT:    retq
 229   %z = call <4 x float> @llvm.maxnum.v4f32(<4 x float> %x, <4 x float> %y) readnone
 230   ret <4 x float> %z
 231 }
 232
 233 define <8 x float> @test_intrinsic_fmax_v8f32(<8 x float> %x, <8 x float> %y) {
 234 ; SSE-LABEL: test_intrinsic_fmax_v8f32:
 235 ; SSE:       # %bb.0:
 236 ; SSE-NEXT:    movaps %xmm2, %xmm4
 237 ; SSE-NEXT:    maxps %xmm0, %xmm4
 238 ; SSE-NEXT:    cmpunordps %xmm0, %xmm0
 239 ; SSE-NEXT:    andps %xmm0, %xmm2
 240 ; SSE-NEXT:    andnps %xmm4, %xmm0
 241 ; SSE-NEXT:    orps %xmm2, %xmm0
 242 ; SSE-NEXT:    movaps %xmm3, %xmm2
 243 ; SSE-NEXT:    maxps %xmm1, %xmm2
 244 ; SSE-NEXT:    cmpunordps %xmm1, %xmm1
 245 ; SSE-NEXT:    andps %xmm1, %xmm3
 246 ; SSE-NEXT:    andnps %xmm2, %xmm1
 247 ; SSE-NEXT:    orps %xmm3, %xmm1
 248 ; SSE-NEXT:    retq
 249 ;
 250 ; AVX-LABEL: test_intrinsic_fmax_v8f32:
 251 ; AVX:       # %bb.0:
 252 ; AVX-NEXT:    vmaxps %ymm0, %ymm1, %ymm2
 253 ; AVX-NEXT:    vcmpunordps %ymm0, %ymm0, %ymm0
 254 ; AVX-NEXT:    vblendvps %ymm0, %ymm1, %ymm2, %ymm0
 255 ; AVX-NEXT:    retq
 256   %z = call <8 x float> @llvm.maxnum.v8f32(<8 x float> %x, <8 x float> %y) readnone
 257   ret <8 x float> %z
 258 }
 259
 260 define <16 x float> @test_intrinsic_fmax_v16f32(<16 x float> %x, <16 x float> %y) {
 261 ; SSE-LABEL: test_intrinsic_fmax_v16f32:
 262 ; SSE:       # %bb.0:
 263 ; SSE-NEXT:    movaps %xmm4, %xmm8
 264 ; SSE-NEXT:    maxps %xmm0, %xmm8
 265 ; SSE-NEXT:    cmpunordps %xmm0, %xmm0
 266 ; SSE-NEXT:    andps %xmm0, %xmm4
 267 ; SSE-NEXT:    andnps %xmm8, %xmm0
 268 ; SSE-NEXT:    orps %xmm4, %xmm0
 269 ; SSE-NEXT:    movaps %xmm5, %xmm4
 270 ; SSE-NEXT:    maxps %xmm1, %xmm4
 271 ; SSE-NEXT:    cmpunordps %xmm1, %xmm1
 272 ; SSE-NEXT:    andps %xmm1, %xmm5
 273 ; SSE-NEXT:    andnps %xmm4, %xmm1
 274 ; SSE-NEXT:    orps %xmm5, %xmm1
 275 ; SSE-NEXT:    movaps %xmm6, %xmm4
 276 ; SSE-NEXT:    maxps %xmm2, %xmm4
 277 ; SSE-NEXT:    cmpunordps %xmm2, %xmm2
 278 ; SSE-NEXT:    andps %xmm2, %xmm6
 279 ; SSE-NEXT:    andnps %xmm4, %xmm2
 280 ; SSE-NEXT:    orps %xmm6, %xmm2
 281 ; SSE-NEXT:    movaps %xmm7, %xmm4
 282 ; SSE-NEXT:    maxps %xmm3, %xmm4
 283 ; SSE-NEXT:    cmpunordps %xmm3, %xmm3
 284 ; SSE-NEXT:    andps %xmm3, %xmm7
 285 ; SSE-NEXT:    andnps %xmm4, %xmm3
 286 ; SSE-NEXT:    orps %xmm7, %xmm3
 287 ; SSE-NEXT:    retq
 288 ;
 289 ; AVX1-LABEL: test_intrinsic_fmax_v16f32:
 290 ; AVX1:       # %bb.0:
 291 ; AVX1-NEXT:    vmaxps %ymm0, %ymm2, %ymm4
 292 ; AVX1-NEXT:    vcmpunordps %ymm0, %ymm0, %ymm0
 293 ; AVX1-NEXT:    vblendvps %ymm0, %ymm2, %ymm4, %ymm0
 294 ; AVX1-NEXT:    vmaxps %ymm1, %ymm3, %ymm2
 295 ; AVX1-NEXT:    vcmpunordps %ymm1, %ymm1, %ymm1
 296 ; AVX1-NEXT:    vblendvps %ymm1, %ymm3, %ymm2, %ymm1
 297 ; AVX1-NEXT:    retq
 298 ;
 299 ; AVX512-LABEL: test_intrinsic_fmax_v16f32:
 300 ; AVX512:       # %bb.0:
 301 ; AVX512-NEXT:    vmaxps %zmm0, %zmm1, %zmm2
 302 ; AVX512-NEXT:    vcmpunordps %zmm0, %zmm0, %k1
 303 ; AVX512-NEXT:    vmovaps %zmm1, %zmm2 {%k1}
 304 ; AVX512-NEXT:    vmovaps %zmm2, %zmm0
 305 ; AVX512-NEXT:    retq
 306   %z = call <16 x float> @llvm.maxnum.v16f32(<16 x float> %x, <16 x float> %y) readnone
 307   ret <16 x float> %z
 308 }
 309
 310 define <2 x double> @test_intrinsic_fmax_v2f64(<2 x double> %x, <2 x double> %y) {
 311 ; SSE-LABEL: test_intrinsic_fmax_v2f64:
 312 ; SSE:       # %bb.0:
 313 ; SSE-NEXT:    movapd %xmm1, %xmm2
 314 ; SSE-NEXT:    maxpd %xmm0, %xmm2
 315 ; SSE-NEXT:    cmpunordpd %xmm0, %xmm0
 316 ; SSE-NEXT:    andpd %xmm0, %xmm1
 317 ; SSE-NEXT:    andnpd %xmm2, %xmm0
 318 ; SSE-NEXT:    orpd %xmm1, %xmm0
 319 ; SSE-NEXT:    retq
 320 ;
 321 ; AVX-LABEL: test_intrinsic_fmax_v2f64:
 322 ; AVX:       # %bb.0:
 323 ; AVX-NEXT:    vmaxpd %xmm0, %xmm1, %xmm2
 324 ; AVX-NEXT:    vcmpunordpd %xmm0, %xmm0, %xmm0
 325 ; AVX-NEXT:    vblendvpd %xmm0, %xmm1, %xmm2, %xmm0
 326 ; AVX-NEXT:    retq
 327   %z = call <2 x double> @llvm.maxnum.v2f64(<2 x double> %x, <2 x double> %y) readnone
 328   ret <2 x double> %z
 329 }
 330
 331 define <4 x double> @test_intrinsic_fmax_v4f64(<4 x double> %x, <4 x double> %y) {
 332 ; SSE-LABEL: test_intrinsic_fmax_v4f64:
 333 ; SSE:       # %bb.0:
 334 ; SSE-NEXT:    movapd %xmm2, %xmm4
 335 ; SSE-NEXT:    maxpd %xmm0, %xmm4
 336 ; SSE-NEXT:    cmpunordpd %xmm0, %xmm0
 337 ; SSE-NEXT:    andpd %xmm0, %xmm2
 338 ; SSE-NEXT:    andnpd %xmm4, %xmm0
 339 ; SSE-NEXT:    orpd %xmm2, %xmm0
 340 ; SSE-NEXT:    movapd %xmm3, %xmm2
 341 ; SSE-NEXT:    maxpd %xmm1, %xmm2
 342 ; SSE-NEXT:    cmpunordpd %xmm1, %xmm1
 343 ; SSE-NEXT:    andpd %xmm1, %xmm3
 344 ; SSE-NEXT:    andnpd %xmm2, %xmm1
 345 ; SSE-NEXT:    orpd %xmm3, %xmm1
 346 ; SSE-NEXT:    retq
 347 ;
 348 ; AVX-LABEL: test_intrinsic_fmax_v4f64:
 349 ; AVX:       # %bb.0:
 350 ; AVX-NEXT:    vmaxpd %ymm0, %ymm1, %ymm2
 351 ; AVX-NEXT:    vcmpunordpd %ymm0, %ymm0, %ymm0
 352 ; AVX-NEXT:    vblendvpd %ymm0, %ymm1, %ymm2, %ymm0
 353 ; AVX-NEXT:    retq
 354   %z = call <4 x double> @llvm.maxnum.v4f64(<4 x double> %x, <4 x double> %y) readnone
 355   ret <4 x double> %z
 356 }
 357
 358 define <8 x double> @test_intrinsic_fmax_v8f64(<8 x double> %x, <8 x double> %y) {
 359 ; SSE-LABEL: test_intrinsic_fmax_v8f64:
 360 ; SSE:       # %bb.0:
 361 ; SSE-NEXT:    movapd %xmm4, %xmm8
 362 ; SSE-NEXT:    maxpd %xmm0, %xmm8
 363 ; SSE-NEXT:    cmpunordpd %xmm0, %xmm0
 364 ; SSE-NEXT:    andpd %xmm0, %xmm4
 365 ; SSE-NEXT:    andnpd %xmm8, %xmm0
 366 ; SSE-NEXT:    orpd %xmm4, %xmm0
 367 ; SSE-NEXT:    movapd %xmm5, %xmm4
 368 ; SSE-NEXT:    maxpd %xmm1, %xmm4
 369 ; SSE-NEXT:    cmpunordpd %xmm1, %xmm1
 370 ; SSE-NEXT:    andpd %xmm1, %xmm5
 371 ; SSE-NEXT:    andnpd %xmm4, %xmm1
 372 ; SSE-NEXT:    orpd %xmm5, %xmm1
 373 ; SSE-NEXT:    movapd %xmm6, %xmm4
 374 ; SSE-NEXT:    maxpd %xmm2, %xmm4
 375 ; SSE-NEXT:    cmpunordpd %xmm2, %xmm2
 376 ; SSE-NEXT:    andpd %xmm2, %xmm6
 377 ; SSE-NEXT:    andnpd %xmm4, %xmm2
 378 ; SSE-NEXT:    orpd %xmm6, %xmm2
 379 ; SSE-NEXT:    movapd %xmm7, %xmm4
 380 ; SSE-NEXT:    maxpd %xmm3, %xmm4
 381 ; SSE-NEXT:    cmpunordpd %xmm3, %xmm3
 382 ; SSE-NEXT:    andpd %xmm3, %xmm7
 383 ; SSE-NEXT:    andnpd %xmm4, %xmm3
 384 ; SSE-NEXT:    orpd %xmm7, %xmm3
 385 ; SSE-NEXT:    retq
 386 ;
 387 ; AVX1-LABEL: test_intrinsic_fmax_v8f64:
 388 ; AVX1:       # %bb.0:
 389 ; AVX1-NEXT:    vmaxpd %ymm0, %ymm2, %ymm4
 390 ; AVX1-NEXT:    vcmpunordpd %ymm0, %ymm0, %ymm0
 391 ; AVX1-NEXT:    vblendvpd %ymm0, %ymm2, %ymm4, %ymm0
 392 ; AVX1-NEXT:    vmaxpd %ymm1, %ymm3, %ymm2
 393 ; AVX1-NEXT:    vcmpunordpd %ymm1, %ymm1, %ymm1
 394 ; AVX1-NEXT:    vblendvpd %ymm1, %ymm3, %ymm2, %ymm1
 395 ; AVX1-NEXT:    retq
 396 ;
 397 ; AVX512-LABEL: test_intrinsic_fmax_v8f64:
 398 ; AVX512:       # %bb.0:
 399 ; AVX512-NEXT:    vmaxpd %zmm0, %zmm1, %zmm2
 400 ; AVX512-NEXT:    vcmpunordpd %zmm0, %zmm0, %k1
 401 ; AVX512-NEXT:    vmovapd %zmm1, %zmm2 {%k1}
 402 ; AVX512-NEXT:    vmovapd %zmm2, %zmm0
 403 ; AVX512-NEXT:    retq
 404   %z = call <8 x double> @llvm.maxnum.v8f64(<8 x double> %x, <8 x double> %y) readnone
 405   ret <8 x double> %z
 406 }
 407
 408 ; The IR-level FMF propagate to the node. With nnan, there's no need to blend.
 409
 410 define double @maxnum_intrinsic_nnan_fmf_f64(double %a, double %b) {
 411 ; SSE-LABEL: maxnum_intrinsic_nnan_fmf_f64:
 412 ; SSE:       # %bb.0:
 413 ; SSE-NEXT:    maxsd %xmm1, %xmm0
 414 ; SSE-NEXT:    retq
 415 ;
 416 ; AVX-LABEL: maxnum_intrinsic_nnan_fmf_f64:
 417 ; AVX:       # %bb.0:
 418 ; AVX-NEXT:    vmaxsd %xmm1, %xmm0, %xmm0
 419 ; AVX-NEXT:    retq
 420   %r = tail call nnan double @llvm.maxnum.f64(double %a, double %b)
 421   ret double %r
 422 }
 423
 424 ; Make sure vectors work too.
 425
 426 define <4 x float> @maxnum_intrinsic_nnan_fmf_f432(<4 x float> %a, <4 x float> %b) {
 427 ; SSE-LABEL: maxnum_intrinsic_nnan_fmf_f432:
 428 ; SSE:       # %bb.0:
 429 ; SSE-NEXT:    maxps %xmm1, %xmm0
 430 ; SSE-NEXT:    retq
 431 ;
 432 ; AVX-LABEL: maxnum_intrinsic_nnan_fmf_f432:
 433 ; AVX:       # %bb.0:
 434 ; AVX-NEXT:    vmaxps %xmm1, %xmm0, %xmm0
 435 ; AVX-NEXT:    retq
 436   %r = tail call nnan <4 x float> @llvm.maxnum.v4f32(<4 x float> %a, <4 x float> %b)
 437   ret <4 x float> %r
 438 }
 439
 440 ; Current (but legacy someday): a function-level attribute should also enable the fold.
 441
 442 define float @maxnum_intrinsic_nnan_attr_f32(float %a, float %b) #0 {
 443 ; SSE-LABEL: maxnum_intrinsic_nnan_attr_f32:
 444 ; SSE:       # %bb.0:
 445 ; SSE-NEXT:    maxss %xmm1, %xmm0
 446 ; SSE-NEXT:    retq
 447 ;
 448 ; AVX-LABEL: maxnum_intrinsic_nnan_attr_f32:
 449 ; AVX:       # %bb.0:
 450 ; AVX-NEXT:    vmaxss %xmm1, %xmm0, %xmm0
 451 ; AVX-NEXT:    retq
 452   %r = tail call float @llvm.maxnum.f32(float %a, float %b)
 453   ret float %r
 454 }
 455
 456 ; Make sure vectors work too.
 457
 458 define <2 x double> @maxnum_intrinsic_nnan_attr_f64(<2 x double> %a, <2 x double> %b) #0 {
 459 ; SSE-LABEL: maxnum_intrinsic_nnan_attr_f64:
 460 ; SSE:       # %bb.0:
 461 ; SSE-NEXT:    maxpd %xmm1, %xmm0
 462 ; SSE-NEXT:    retq
 463 ;
 464 ; AVX-LABEL: maxnum_intrinsic_nnan_attr_f64:
 465 ; AVX:       # %bb.0:
 466 ; AVX-NEXT:    vmaxpd %xmm1, %xmm0, %xmm0
 467 ; AVX-NEXT:    retq
 468   %r = tail call <2 x double> @llvm.maxnum.v2f64(<2 x double> %a, <2 x double> %b)
 469   ret <2 x double> %r
 470 }
 471
 472 define float @test_maxnum_const_op1(float %x) {
 473 ; SSE-LABEL: test_maxnum_const_op1:
 474 ; SSE:       # %bb.0:
 475 ; SSE-NEXT:    maxss {{.*}}(%rip), %xmm0
 476 ; SSE-NEXT:    retq
 477 ;
 478 ; AVX-LABEL: test_maxnum_const_op1:
 479 ; AVX:       # %bb.0:
 480 ; AVX-NEXT:    vmaxss {{.*}}(%rip), %xmm0, %xmm0
 481 ; AVX-NEXT:    retq
 482   %r = call float @llvm.maxnum.f32(float 1.0, float %x)
 483   ret float %r
 484 }
 485
 486 define float @test_maxnum_const_op2(float %x) {
 487 ; SSE-LABEL: test_maxnum_const_op2:
 488 ; SSE:       # %bb.0:
 489 ; SSE-NEXT:    maxss {{.*}}(%rip), %xmm0
 490 ; SSE-NEXT:    retq
 491 ;
 492 ; AVX-LABEL: test_maxnum_const_op2:
 493 ; AVX:       # %bb.0:
 494 ; AVX-NEXT:    vmaxss {{.*}}(%rip), %xmm0, %xmm0
 495 ; AVX-NEXT:    retq
 496   %r = call float @llvm.maxnum.f32(float %x, float 1.0)
 497   ret float %r
 498 }
 499
 500 attributes #0 = { "no-nans-fp-math"="true" }
 501