llvm/test/Feature/fp-intrinsics.ll

   1 ; RUN: opt -O3 -S < %s | FileCheck %s
   2
   3 ; Test to verify that constants aren't folded when the rounding mode is unknown.
   4 ; CHECK-LABEL: @f1
   5 ; CHECK: call double @llvm.experimental.constrained.fdiv.f64
   6 define double @f1() #0 {
   7 entry:
   8   %div = call double @llvm.experimental.constrained.fdiv.f64(
   9                                                double 1.000000e+00,
  10                                                double 1.000000e+01,
  11                                                metadata !"round.dynamic",
  12                                                metadata !"fpexcept.strict") #0
  13   ret double %div
  14 }
  15
  16 ; Verify that 'a - 0' isn't simplified to 'a' when the rounding mode is unknown.
  17 ;
  18 ; double f2(double a) {
  19 ;   // Because the result of '0 - 0' is negative zero if rounding mode is
  20 ;   // downward, this shouldn't be simplified.
  21 ;   return a - 0.0;
  22 ; }
  23 ;
  24 ; CHECK-LABEL: @f2
  25 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
  26 define double @f2(double %a) #0 {
  27 entry:
  28   %div = call double @llvm.experimental.constrained.fsub.f64(
  29                                                double %a, double 0.000000e+00,
  30                                                metadata !"round.dynamic",
  31                                                metadata !"fpexcept.strict") #0
  32   ret double %div
  33 }
  34
  35 ; Verify that '-((-a)*b)' isn't simplified to 'a*b' when the rounding mode is
  36 ; unknown.
  37 ;
  38 ; double f3(double a, double b) {
  39 ;   // Because the intermediate value involved in this calculation may require
  40 ;   // rounding, this shouldn't be simplified.
  41 ;   return -((-a)*b);
  42 ; }
  43 ;
  44 ; CHECK-LABEL: @f3
  45 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
  46 ; CHECK: call double @llvm.experimental.constrained.fmul.f64
  47 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
  48 define double @f3(double %a, double %b) #0 {
  49 entry:
  50   %sub = call double @llvm.experimental.constrained.fsub.f64(
  51                                                double -0.000000e+00, double %a,
  52                                                metadata !"round.dynamic",
  53                                                metadata !"fpexcept.strict") #0
  54   %mul = call double @llvm.experimental.constrained.fmul.f64(
  55                                                double %sub, double %b,
  56                                                metadata !"round.dynamic",
  57                                                metadata !"fpexcept.strict") #0
  58   %ret = call double @llvm.experimental.constrained.fsub.f64(
  59                                                double -0.000000e+00,
  60                                                double %mul,
  61                                                metadata !"round.dynamic",
  62                                                metadata !"fpexcept.strict") #0
  63   ret double %ret
  64 }
  65
  66 ; Verify that FP operations are not performed speculatively when FP exceptions
  67 ; are not being ignored.
  68 ;
  69 ; double f4(int n, double a) {
  70 ;   // Because a + 1 may overflow, this should not be simplified.
  71 ;   if (n > 0)
  72 ;     return a + 1.0;
  73 ;   return a;
  74 ; }
  75 ;
  76 ;
  77 ; CHECK-LABEL: @f4
  78 ; CHECK-NOT: select
  79 ; CHECK: br i1 %cmp
  80 define double @f4(i32 %n, double %a) #0 {
  81 entry:
  82   %cmp = icmp sgt i32 %n, 0
  83   br i1 %cmp, label %if.then, label %if.end
  84
  85 if.then:
  86   %add = call double @llvm.experimental.constrained.fadd.f64(
  87                                                double 1.000000e+00, double %a,
  88                                                metadata !"round.dynamic",
  89                                                metadata !"fpexcept.strict") #0
  90   br label %if.end
  91
  92 if.end:
  93   %a.0 = phi double [%add, %if.then], [ %a, %entry ]
  94   ret double %a.0
  95 }
  96
  97 ; Verify that sqrt(42.0) isn't simplified when the rounding mode is unknown.
  98 ; CHECK-LABEL: f5
  99 ; CHECK: call double @llvm.experimental.constrained.sqrt
 100 define double @f5() #0 {
 101 entry:
 102   %result = call double @llvm.experimental.constrained.sqrt.f64(double 42.0,
 103                                                metadata !"round.dynamic",
 104                                                metadata !"fpexcept.strict") #0
 105   ret double %result
 106 }
 107
 108 ; Verify that pow(42.1, 3.0) isn't simplified when the rounding mode is unknown.
 109 ; CHECK-LABEL: f6
 110 ; CHECK: call double @llvm.experimental.constrained.pow
 111 define double @f6() #0 {
 112 entry:
 113   %result = call double @llvm.experimental.constrained.pow.f64(double 42.1,
 114                                                double 3.0,
 115                                                metadata !"round.dynamic",
 116                                                metadata !"fpexcept.strict") #0
 117   ret double %result
 118 }
 119
 120 ; Verify that powi(42.1, 3) isn't simplified when the rounding mode is unknown.
 121 ; CHECK-LABEL: f7
 122 ; CHECK: call double @llvm.experimental.constrained.powi
 123 define double @f7() #0 {
 124 entry:
 125   %result = call double @llvm.experimental.constrained.powi.f64(double 42.1,
 126                                                i32 3,
 127                                                metadata !"round.dynamic",
 128                                                metadata !"fpexcept.strict") #0
 129   ret double %result
 130 }
 131
 132 ; Verify that sin(42.0) isn't simplified when the rounding mode is unknown.
 133 ; CHECK-LABEL: f8
 134 ; CHECK: call double @llvm.experimental.constrained.sin
 135 define double @f8() #0 {
 136 entry:
 137   %result = call double @llvm.experimental.constrained.sin.f64(double 42.0,
 138                                                metadata !"round.dynamic",
 139                                                metadata !"fpexcept.strict") #0
 140   ret double %result
 141 }
 142
 143 ; Verify that cos(42.0) isn't simplified when the rounding mode is unknown.
 144 ; CHECK-LABEL: f9
 145 ; CHECK: call double @llvm.experimental.constrained.cos
 146 define double @f9() #0 {
 147 entry:
 148   %result = call double @llvm.experimental.constrained.cos.f64(double 42.0,
 149                                                metadata !"round.dynamic",
 150                                                metadata !"fpexcept.strict") #0
 151   ret double %result
 152 }
 153
 154 ; Verify that tan(42.0) isn't simplified when the rounding mode is unknown.
 155 ; CHECK-LABEL: ftan
 156 ; CHECK: call double @llvm.experimental.constrained.tan
 157 define double @ftan() #0 {
 158 entry:
 159   %result = call double @llvm.experimental.constrained.tan.f64(double 42.0,
 160                                                metadata !"round.dynamic",
 161                                                metadata !"fpexcept.strict") #0
 162   ret double %result
 163 }
 164
 165 ; Verify that acos(42.0) isn't simplified when the rounding mode is unknown.
 166 ; CHECK-LABEL: facos
 167 ; CHECK: call double @llvm.experimental.constrained.acos
 168 define double @facos() #0 {
 169 entry:
 170   %result = call double @llvm.experimental.constrained.acos.f64(double 42.0,
 171                                                metadata !"round.dynamic",
 172                                                metadata !"fpexcept.strict") #0
 173   ret double %result
 174 }
 175
 176 ; Verify that asin(42.0) isn't simplified when the rounding mode is unknown.
 177 ; CHECK-LABEL: fasin
 178 ; CHECK: call double @llvm.experimental.constrained.asin
 179 define double @fasin() #0 {
 180 entry:
 181   %result = call double @llvm.experimental.constrained.asin.f64(double 42.0,
 182                                                metadata !"round.dynamic",
 183                                                metadata !"fpexcept.strict") #0
 184   ret double %result
 185 }
 186
 187 ; Verify that atan(42.0) isn't simplified when the rounding mode is unknown.
 188 ; CHECK-LABEL: fatan
 189 ; CHECK: call double @llvm.experimental.constrained.atan
 190 define double @fatan() #0 {
 191 entry:
 192   %result = call double @llvm.experimental.constrained.atan.f64(double 42.0,
 193                                                metadata !"round.dynamic",
 194                                                metadata !"fpexcept.strict") #0
 195   ret double %result
 196 }
 197
 198 ; Verify that cosh(42.0) isn't simplified when the rounding mode is unknown.
 199 ; CHECK-LABEL: fcosh
 200 ; CHECK: call double @llvm.experimental.constrained.cosh
 201 define double @fcosh() #0 {
 202 entry:
 203   %result = call double @llvm.experimental.constrained.cosh.f64(double 42.0,
 204                                                metadata !"round.dynamic",
 205                                                metadata !"fpexcept.strict") #0
 206   ret double %result
 207 }
 208
 209 ; Verify that sinh(42.0) isn't simplified when the rounding mode is unknown.
 210 ; CHECK-LABEL: fsinh
 211 ; CHECK: call double @llvm.experimental.constrained.sinh
 212 define double @fsinh() #0 {
 213 entry:
 214   %result = call double @llvm.experimental.constrained.sinh.f64(double 42.0,
 215                                                metadata !"round.dynamic",
 216                                                metadata !"fpexcept.strict") #0
 217   ret double %result
 218 }
 219
 220 ; Verify that tanh(42.0) isn't simplified when the rounding mode is unknown.
 221 ; CHECK-LABEL: ftanh
 222 ; CHECK: call double @llvm.experimental.constrained.tanh
 223 define double @ftanh() #0 {
 224 entry:
 225   %result = call double @llvm.experimental.constrained.tanh.f64(double 42.0,
 226                                                metadata !"round.dynamic",
 227                                                metadata !"fpexcept.strict") #0
 228   ret double %result
 229 }
 230
 231 ; Verify that exp(42.0) isn't simplified when the rounding mode is unknown.
 232 ; CHECK-LABEL: f10
 233 ; CHECK: call double @llvm.experimental.constrained.exp
 234 define double @f10() #0 {
 235 entry:
 236   %result = call double @llvm.experimental.constrained.exp.f64(double 42.0,
 237                                                metadata !"round.dynamic",
 238                                                metadata !"fpexcept.strict") #0
 239   ret double %result
 240 }
 241
 242 ; Verify that exp2(42.1) isn't simplified when the rounding mode is unknown.
 243 ; CHECK-LABEL: f11
 244 ; CHECK: call double @llvm.experimental.constrained.exp2
 245 define double @f11() #0 {
 246 entry:
 247   %result = call double @llvm.experimental.constrained.exp2.f64(double 42.1,
 248                                                metadata !"round.dynamic",
 249                                                metadata !"fpexcept.strict") #0
 250   ret double %result
 251 }
 252
 253 ; Verify that log(42.0) isn't simplified when the rounding mode is unknown.
 254 ; CHECK-LABEL: f12
 255 ; CHECK: call double @llvm.experimental.constrained.log
 256 define double @f12() #0 {
 257 entry:
 258   %result = call double @llvm.experimental.constrained.log.f64(double 42.0,
 259                                                metadata !"round.dynamic",
 260                                                metadata !"fpexcept.strict") #0
 261   ret double %result
 262 }
 263
 264 ; Verify that log10(42.0) isn't simplified when the rounding mode is unknown.
 265 ; CHECK-LABEL: f13
 266 ; CHECK: call double @llvm.experimental.constrained.log10
 267 define double @f13() #0 {
 268 entry:
 269   %result = call double @llvm.experimental.constrained.log10.f64(double 42.0,
 270                                                metadata !"round.dynamic",
 271                                                metadata !"fpexcept.strict") #0
 272   ret double %result
 273 }
 274
 275 ; Verify that log2(42.0) isn't simplified when the rounding mode is unknown.
 276 ; CHECK-LABEL: f14
 277 ; CHECK: call double @llvm.experimental.constrained.log2
 278 define double @f14() #0 {
 279 entry:
 280   %result = call double @llvm.experimental.constrained.log2.f64(double 42.0,
 281                                                metadata !"round.dynamic",
 282                                                metadata !"fpexcept.strict") #0
 283   ret double %result
 284 }
 285
 286 ; Verify that rint(42.1) isn't simplified when the rounding mode is unknown.
 287 ; CHECK-LABEL: f15
 288 ; CHECK: call double @llvm.experimental.constrained.rint
 289 define double @f15() #0 {
 290 entry:
 291   %result = call double @llvm.experimental.constrained.rint.f64(double 42.1,
 292                                                metadata !"round.dynamic",
 293                                                metadata !"fpexcept.strict") #0
 294   ret double %result
 295 }
 296
 297 ; Verify that nearbyint(42.1) isn't simplified when the rounding mode is
 298 ; unknown.
 299 ; CHECK-LABEL: f16
 300 ; CHECK: call double @llvm.experimental.constrained.nearbyint
 301 define double @f16() #0 {
 302 entry:
 303   %result = call double @llvm.experimental.constrained.nearbyint.f64(
 304                                                double 42.1,
 305                                                metadata !"round.dynamic",
 306                                                metadata !"fpexcept.strict") #0
 307   ret double %result
 308 }
 309
 310 ; Verify that fma(42.1) isn't simplified when the rounding mode is
 311 ; unknown.
 312 ; CHECK-LABEL: f17
 313 ; CHECK: call double @llvm.experimental.constrained.fma
 314 define double @f17() #0 {
 315 entry:
 316   %result = call double @llvm.experimental.constrained.fma.f64(double 42.1, double 42.1, double 42.1,
 317                                                metadata !"round.dynamic",
 318                                                metadata !"fpexcept.strict") #0
 319   ret double %result
 320 }
 321
 322 ; Verify that fptoui(42.1) isn't simplified when the rounding mode is
 323 ; unknown.
 324 ; CHECK-LABEL: f18
 325 ; CHECK: call zeroext i32 @llvm.experimental.constrained.fptoui
 326 define zeroext i32 @f18() #0 {
 327 entry:
 328   %result = call zeroext i32 @llvm.experimental.constrained.fptoui.i32.f64(
 329                                                double 42.1,
 330                                                metadata !"fpexcept.strict") #0
 331   ret i32 %result
 332 }
 333
 334 ; Verify that fptosi(42.1) isn't simplified when the rounding mode is
 335 ; unknown.
 336 ; CHECK-LABEL: f19
 337 ; CHECK: call i32 @llvm.experimental.constrained.fptosi
 338 define i32 @f19() #0 {
 339 entry:
 340   %result = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double 42.1,
 341                                                metadata !"fpexcept.strict") #0
 342   ret i32 %result
 343 }
 344
 345 ; Verify that fptrunc(42.1) isn't simplified when the rounding mode is
 346 ; unknown.
 347 ; CHECK-LABEL: f20
 348 ; CHECK: call float @llvm.experimental.constrained.fptrunc
 349 define float @f20() #0 {
 350 entry:
 351   %result = call float @llvm.experimental.constrained.fptrunc.f32.f64(
 352                                                double 42.1,
 353                                                metadata !"round.dynamic",
 354                                                metadata !"fpexcept.strict") #0
 355   ret float %result
 356 }
 357
 358 ; Verify that fpext(42.1) isn't simplified when the rounding mode is
 359 ; unknown.
 360 ; CHECK-LABEL: f21
 361 ; CHECK: call double @llvm.experimental.constrained.fpext
 362 define double @f21() #0 {
 363 entry:
 364   %result = call double @llvm.experimental.constrained.fpext.f64.f32(float 42.0,
 365                                                metadata !"fpexcept.strict") #0
 366   ret double %result
 367 }
 368
 369 ; Verify that lrint(42.1) isn't simplified when the rounding mode is unknown.
 370 ; CHECK-LABEL: f22
 371 ; CHECK: call i32 @llvm.experimental.constrained.lrint
 372 define i32 @f22() #0 {
 373 entry:
 374   %result = call i32 @llvm.experimental.constrained.lrint.i32.f64(double 42.1,
 375                                                metadata !"round.dynamic",
 376                                                metadata !"fpexcept.strict") #0
 377   ret i32 %result
 378 }
 379
 380 ; Verify that lrintf(42.0) isn't simplified when the rounding mode is unknown.
 381 ; CHECK-LABEL: f23
 382 ; CHECK: call i32 @llvm.experimental.constrained.lrint
 383 define i32 @f23() #0 {
 384 entry:
 385   %result = call i32 @llvm.experimental.constrained.lrint.i32.f32(float 42.0,
 386                                                metadata !"round.dynamic",
 387                                                metadata !"fpexcept.strict") #0
 388   ret i32 %result
 389 }
 390
 391 ; Verify that llrint(42.1) isn't simplified when the rounding mode is unknown.
 392 ; CHECK-LABEL: f24
 393 ; CHECK: call i64 @llvm.experimental.constrained.llrint
 394 define i64 @f24() #0 {
 395 entry:
 396   %result = call i64 @llvm.experimental.constrained.llrint.i64.f64(double 42.1,
 397                                                metadata !"round.dynamic",
 398                                                metadata !"fpexcept.strict") #0
 399   ret i64 %result
 400 }
 401
 402 ; Verify that llrint(42.0) isn't simplified when the rounding mode is unknown.
 403 ; CHECK-LABEL: f25
 404 ; CHECK: call i64 @llvm.experimental.constrained.llrint
 405 define i64 @f25() #0 {
 406 entry:
 407   %result = call i64 @llvm.experimental.constrained.llrint.i64.f32(float 42.0,
 408                                                metadata !"round.dynamic",
 409                                                metadata !"fpexcept.strict") #0
 410   ret i64 %result
 411 }
 412
 413 ; Verify that lround(42.1) isn't simplified when the rounding mode is unknown.
 414 ; CHECK-LABEL: f26
 415 ; CHECK: call i32 @llvm.experimental.constrained.lround
 416 define i32 @f26() #0 {
 417 entry:
 418   %result = call i32 @llvm.experimental.constrained.lround.i32.f64(double 42.1,
 419                                                metadata !"fpexcept.strict") #0
 420   ret i32 %result
 421 }
 422
 423 ; Verify that lround(42.0) isn't simplified when the rounding mode is unknown.
 424 ; CHECK-LABEL: f27
 425 ; CHECK: call i32 @llvm.experimental.constrained.lround
 426 define i32 @f27() #0 {
 427 entry:
 428   %result = call i32 @llvm.experimental.constrained.lround.i32.f32(float 42.0,
 429                                                metadata !"fpexcept.strict") #0
 430   ret i32 %result
 431 }
 432
 433 ; Verify that llround(42.1) isn't simplified when the rounding mode is unknown.
 434 ; CHECK-LABEL: f28
 435 ; CHECK: call i64 @llvm.experimental.constrained.llround
 436 define i64 @f28() #0 {
 437 entry:
 438   %result = call i64 @llvm.experimental.constrained.llround.i64.f64(double 42.1,
 439                                                metadata !"fpexcept.strict") #0
 440   ret i64 %result
 441 }
 442
 443 ; Verify that llround(42.0) isn't simplified when the rounding mode is unknown.
 444 ; CHECK-LABEL: f29
 445 ; CHECK: call i64 @llvm.experimental.constrained.llround
 446 define i64 @f29() #0 {
 447 entry:
 448   %result = call i64 @llvm.experimental.constrained.llround.i64.f32(float 42.0,
 449                                                metadata !"fpexcept.strict") #0
 450   ret i64 %result
 451 }
 452
 453 ; Verify that sitofp(42) isn't simplified when the rounding mode is unknown.
 454 ; CHECK-LABEL: @f30
 455 ; CHECK: call double @llvm.experimental.constrained.sitofp
 456 define double @f30() #0 {
 457 entry:
 458   %result = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 42,
 459                                                metadata !"round.dynamic",
 460                                                metadata !"fpexcept.strict") #0
 461   ret double %result
 462 }
 463
 464 ; Verify that uitofp(42) isn't simplified when the rounding mode is unknown.
 465 ; CHECK-LABEL: @f31
 466 ; CHECK: call double @llvm.experimental.constrained.uitofp
 467 define double @f31() #0 {
 468 entry:
 469   %result = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 42,
 470                                                metadata !"round.dynamic",
 471                                                metadata !"fpexcept.strict") #0
 472   ret double %result
 473 }
 474
 475 attributes #0 = { strictfp }
 476
 477 @llvm.fp.env = thread_local global i8 zeroinitializer, section "llvm.metadata"
 478 declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
 479 declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
 480 declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
 481 declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
 482 declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
 483 declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata)
 484 declare double @llvm.experimental.constrained.powi.f64(double, i32, metadata, metadata)
 485 declare double @llvm.experimental.constrained.sin.f64(double, metadata, metadata)
 486 declare double @llvm.experimental.constrained.cos.f64(double, metadata, metadata)
 487 declare double @llvm.experimental.constrained.tan.f64(double, metadata, metadata)
 488 declare double @llvm.experimental.constrained.exp.f64(double, metadata, metadata)
 489 declare double @llvm.experimental.constrained.exp2.f64(double, metadata, metadata)
 490 declare double @llvm.experimental.constrained.log.f64(double, metadata, metadata)
 491 declare double @llvm.experimental.constrained.log10.f64(double, metadata, metadata)
 492 declare double @llvm.experimental.constrained.log2.f64(double, metadata, metadata)
 493 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
 494 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
 495 declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)
 496 declare i32 @llvm.experimental.constrained.fptosi.i32.f64(double, metadata)
 497 declare i32 @llvm.experimental.constrained.fptoui.i32.f64(double, metadata)
 498 declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)
 499 declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)
 500 declare i32 @llvm.experimental.constrained.lrint.i32.f64(double, metadata, metadata)
 501 declare i32 @llvm.experimental.constrained.lrint.i32.f32(float, metadata, metadata)
 502 declare i64 @llvm.experimental.constrained.llrint.i64.f64(double, metadata, metadata)
 503 declare i64 @llvm.experimental.constrained.llrint.i64.f32(float, metadata, metadata)
 504 declare i32 @llvm.experimental.constrained.lround.i32.f64(double, metadata)
 505 declare i32 @llvm.experimental.constrained.lround.i32.f32(float, metadata)
 506 declare i64 @llvm.experimental.constrained.llround.i64.f64(double, metadata)
 507 declare i64 @llvm.experimental.constrained.llround.i64.f32(float, metadata)
 508 declare double @llvm.experimental.constrained.sitofp.f64.i32(i32, metadata, metadata)
 509 declare double @llvm.experimental.constrained.uitofp.f64.i32(i32, metadata, metadata)