llvm/test/Transforms/Attributor/nofpclass-log.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
   2 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
   3
   4 declare float @llvm.log.f32(float)
   5 declare float @llvm.log2.f32(float)
   6 declare float @llvm.log10.f32(float)
   7
   8 declare <2 x float> @llvm.log.v2f32(<2 x float>)
   9 declare float @llvm.experimental.constrained.log.f32(float, metadata, metadata)
  10 declare float @llvm.experimental.constrained.log2.f32(float, metadata, metadata)
  11 declare float @llvm.experimental.constrained.log10.f32(float, metadata, metadata)
  12
  13 define float @ret_log(float %arg) #0 {
  14 ; CHECK-LABEL: define float @ret_log
  15 ; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR2:[0-9]+]] {
  16 ; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float [[ARG]]) #[[ATTR10:[0-9]+]]
  17 ; CHECK-NEXT:    ret float [[CALL]]
  18 ;
  19   %call = call float @llvm.log.f32(float %arg)
  20   ret float %call
  21 }
  22
  23 define float @ret_log_noinf(float nofpclass(inf) %arg) #0 {
  24 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_noinf
  25 ; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] {
  26 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
  27 ; CHECK-NEXT:    ret float [[CALL]]
  28 ;
  29   %call = call float @llvm.log.f32(float %arg)
  30   ret float %call
  31 }
  32
  33 define float @ret_log_noneg(float nofpclass(ninf nsub nnorm) %arg) #0 {
  34 ; CHECK-LABEL: define float @ret_log_noneg
  35 ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
  36 ; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
  37 ; CHECK-NEXT:    ret float [[CALL]]
  38 ;
  39   %call = call float @llvm.log.f32(float %arg)
  40   ret float %call
  41 }
  42
  43 define float @ret_log_noneg_nonan(float nofpclass(ninf nsub nnorm nan) %arg) #0 {
  44 ; CHECK-LABEL: define nofpclass(nan) float @ret_log_noneg_nonan
  45 ; CHECK-SAME: (float nofpclass(nan ninf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
  46 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
  47 ; CHECK-NEXT:    ret float [[CALL]]
  48 ;
  49   %call = call float @llvm.log.f32(float %arg)
  50   ret float %call
  51 }
  52
  53 define float @ret_log_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) #0 {
  54 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_noinf_noneg
  55 ; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
  56 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
  57 ; CHECK-NEXT:    ret float [[CALL]]
  58 ;
  59   %call = call float @llvm.log.f32(float %arg)
  60   ret float %call
  61 }
  62
  63 define float @ret_log_noinf_noneg_nonan(float nofpclass(inf nsub nnorm nan) %arg) #0 {
  64 ; CHECK-LABEL: define nofpclass(nan pinf) float @ret_log_noinf_noneg_nonan
  65 ; CHECK-SAME: (float nofpclass(nan inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
  66 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
  67 ; CHECK-NEXT:    ret float [[CALL]]
  68 ;
  69   %call = call float @llvm.log.f32(float %arg)
  70   ret float %call
  71 }
  72
  73 define float @ret_log_nopinf(float nofpclass(pinf) %arg) #0 {
  74 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_nopinf
  75 ; CHECK-SAME: (float nofpclass(pinf) [[ARG:%.*]]) #[[ATTR2]] {
  76 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
  77 ; CHECK-NEXT:    ret float [[CALL]]
  78 ;
  79   %call = call float @llvm.log.f32(float %arg)
  80   ret float %call
  81 }
  82
  83 define float @ret_log_noninf(float nofpclass(ninf) %arg) #0 {
  84 ; CHECK-LABEL: define float @ret_log_noninf
  85 ; CHECK-SAME: (float nofpclass(ninf) [[ARG:%.*]]) #[[ATTR2]] {
  86 ; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
  87 ; CHECK-NEXT:    ret float [[CALL]]
  88 ;
  89   %call = call float @llvm.log.f32(float %arg)
  90   ret float %call
  91 }
  92
  93 define float @ret_log_nonan(float nofpclass(nan) %arg) #0 {
  94 ; CHECK-LABEL: define float @ret_log_nonan
  95 ; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR2]] {
  96 ; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
  97 ; CHECK-NEXT:    ret float [[CALL]]
  98 ;
  99   %call = call float @llvm.log.f32(float %arg)
 100   ret float %call
 101 }
 102
 103 define float @ret_log_nonan_noinf(float nofpclass(nan inf) %arg) #0 {
 104 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_nonan_noinf
 105 ; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR2]] {
 106 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 107 ; CHECK-NEXT:    ret float [[CALL]]
 108 ;
 109   %call = call float @llvm.log.f32(float %arg)
 110   ret float %call
 111 }
 112
 113 define float @ret_log_nonan_noinf_nozero(float nofpclass(nan inf zero) %arg) #0 {
 114 ; CHECK-LABEL: define nofpclass(inf) float @ret_log_nonan_noinf_nozero
 115 ; CHECK-SAME: (float nofpclass(nan inf zero) [[ARG:%.*]]) #[[ATTR2]] {
 116 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(inf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 117 ; CHECK-NEXT:    ret float [[CALL]]
 118 ;
 119   %call = call float @llvm.log.f32(float %arg)
 120   ret float %call
 121 }
 122
 123 define float @ret_log_noinf_nozero(float nofpclass(inf zero) %arg) #0 {
 124 ; CHECK-LABEL: define nofpclass(inf) float @ret_log_noinf_nozero
 125 ; CHECK-SAME: (float nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR2]] {
 126 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(inf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 127 ; CHECK-NEXT:    ret float [[CALL]]
 128 ;
 129   %call = call float @llvm.log.f32(float %arg)
 130   ret float %call
 131 }
 132
 133 define float @ret_log_noinf_nonegzero(float nofpclass(inf nzero) %arg) #0 {
 134 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_noinf_nonegzero
 135 ; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR2]] {
 136 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 137 ; CHECK-NEXT:    ret float [[CALL]]
 138 ;
 139   %call = call float @llvm.log.f32(float %arg)
 140   ret float %call
 141 }
 142
 143 define float @ret_log_positive_source(i32 %arg) #0 {
 144 ; CHECK-LABEL: define nofpclass(nan pinf) float @ret_log_positive_source
 145 ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
 146 ; CHECK-NEXT:    [[UITOFP:%.*]] = uitofp i32 [[ARG]] to float
 147 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan pinf) float @llvm.log.f32(float [[UITOFP]]) #[[ATTR10]]
 148 ; CHECK-NEXT:    ret float [[CALL]]
 149 ;
 150   %uitofp = uitofp i32 %arg to float
 151   %call = call float @llvm.log.f32(float %uitofp)
 152   ret float %call
 153 }
 154
 155 ; Could produce a nan because we don't know if the multiply is negative.
 156 define float @ret_log_unknown_sign(float nofpclass(nan) %arg, float nofpclass(nan) %arg1) #0 {
 157 ; CHECK-LABEL: define float @ret_log_unknown_sign
 158 ; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]], float nofpclass(nan) [[ARG1:%.*]]) #[[ATTR2]] {
 159 ; CHECK-NEXT:    [[UNKNOWN_SIGN_NOT_NAN:%.*]] = fmul nnan float [[ARG]], [[ARG1]]
 160 ; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float [[UNKNOWN_SIGN_NOT_NAN]]) #[[ATTR10]]
 161 ; CHECK-NEXT:    ret float [[CALL]]
 162 ;
 163   %unknown.sign.not.nan = fmul nnan float %arg, %arg1
 164   %call = call float @llvm.log.f32(float %unknown.sign.not.nan)
 165   ret float %call
 166 }
 167
 168 define float @ret_log_daz_noinf_nozero(float nofpclass(inf zero) %arg) #1 {
 169 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_daz_noinf_nozero
 170 ; CHECK-SAME: (float nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR3:[0-9]+]] {
 171 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 172 ; CHECK-NEXT:    ret float [[CALL]]
 173 ;
 174   %call = call float @llvm.log.f32(float %arg)
 175   ret float %call
 176 }
 177
 178 define <2 x float> @ret_log_daz_noinf_nozero_v2f32(<2 x float> nofpclass(inf zero) %arg) #1 {
 179 ; CHECK-LABEL: define nofpclass(pinf) <2 x float> @ret_log_daz_noinf_nozero_v2f32
 180 ; CHECK-SAME: (<2 x float> nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR3]] {
 181 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) <2 x float> @llvm.log.v2f32(<2 x float> [[ARG]]) #[[ATTR10]]
 182 ; CHECK-NEXT:    ret <2 x float> [[CALL]]
 183 ;
 184   %call = call <2 x float> @llvm.log.v2f32(<2 x float> %arg)
 185   ret <2 x float> %call
 186 }
 187
 188 define float @ret_log_daz_noinf_nonegzero(float nofpclass(inf nzero) %arg) #1 {
 189 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_daz_noinf_nonegzero
 190 ; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR3]] {
 191 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 192 ; CHECK-NEXT:    ret float [[CALL]]
 193 ;
 194   %call = call float @llvm.log.f32(float %arg)
 195   ret float %call
 196 }
 197
 198 define float @ret_log_dapz_noinf_nozero(float nofpclass(inf zero) %arg) #2 {
 199 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_dapz_noinf_nozero
 200 ; CHECK-SAME: (float nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR4:[0-9]+]] {
 201 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 202 ; CHECK-NEXT:    ret float [[CALL]]
 203 ;
 204   %call = call float @llvm.log.f32(float %arg)
 205   ret float %call
 206 }
 207
 208 define float @ret_log_dapz_noinf_nonegzero(float nofpclass(inf nzero) %arg) #2 {
 209 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_dapz_noinf_nonegzero
 210 ; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR4]] {
 211 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 212 ; CHECK-NEXT:    ret float [[CALL]]
 213 ;
 214   %call = call float @llvm.log.f32(float %arg)
 215   ret float %call
 216 }
 217
 218 define float @ret_log_dynamic_noinf_nozero(float nofpclass(inf zero) %arg) #3 {
 219 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_dynamic_noinf_nozero
 220 ; CHECK-SAME: (float nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
 221 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 222 ; CHECK-NEXT:    ret float [[CALL]]
 223 ;
 224   %call = call float @llvm.log.f32(float %arg)
 225   ret float %call
 226 }
 227
 228 define float @ret_log_dynamic_noinf_nonegzero(float nofpclass(inf nzero) %arg) #3 {
 229 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_dynamic_noinf_nonegzero
 230 ; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR5]] {
 231 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 232 ; CHECK-NEXT:    ret float [[CALL]]
 233 ;
 234   %call = call float @llvm.log.f32(float %arg)
 235   ret float %call
 236 }
 237
 238 define float @ret_log_ftz_noinf_nonegzero(float nofpclass(inf nzero) %arg) #4 {
 239 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_ftz_noinf_nonegzero
 240 ; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR6:[0-9]+]] {
 241 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 242 ; CHECK-NEXT:    ret float [[CALL]]
 243 ;
 244   %call = call float @llvm.log.f32(float %arg)
 245   ret float %call
 246 }
 247
 248 define float @ret_log_ftpz_noinf_nonegzero(float nofpclass(inf nzero) %arg) #5 {
 249 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_ftpz_noinf_nonegzero
 250 ; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR7:[0-9]+]] {
 251 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 252 ; CHECK-NEXT:    ret float [[CALL]]
 253 ;
 254   %call = call float @llvm.log.f32(float %arg)
 255   ret float %call
 256 }
 257
 258 define float @ret_log_ftz_dynamic_noinf_nonegzero(float nofpclass(inf nzero) %arg) #6 {
 259 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log_ftz_dynamic_noinf_nonegzero
 260 ; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR8:[0-9]+]] {
 261 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float [[ARG]]) #[[ATTR10]]
 262 ; CHECK-NEXT:    ret float [[CALL]]
 263 ;
 264   %call = call float @llvm.log.f32(float %arg)
 265   ret float %call
 266 }
 267
 268 define float @constrained_log(float %arg) strictfp {
 269 ; CHECK-LABEL: define float @constrained_log
 270 ; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR9:[0-9]+]] {
 271 ; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.experimental.constrained.log.f32(float [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11:[0-9]+]]
 272 ; CHECK-NEXT:    ret float [[VAL]]
 273 ;
 274   %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
 275   ret float %val
 276 }
 277
 278 define float @constrained_log_nonan(float nofpclass(nan) %arg) strictfp {
 279 ; CHECK-LABEL: define float @constrained_log_nonan
 280 ; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR9]] {
 281 ; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.experimental.constrained.log.f32(float [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
 282 ; CHECK-NEXT:    ret float [[VAL]]
 283 ;
 284   %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
 285   ret float %val
 286 }
 287
 288 define float @constrained_log_nopinf(float nofpclass(pinf) %arg) strictfp {
 289 ; CHECK-LABEL: define nofpclass(pinf) float @constrained_log_nopinf
 290 ; CHECK-SAME: (float nofpclass(pinf) [[ARG:%.*]]) #[[ATTR9]] {
 291 ; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(pinf) float @llvm.experimental.constrained.log.f32(float [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
 292 ; CHECK-NEXT:    ret float [[VAL]]
 293 ;
 294   %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
 295   ret float %val
 296 }
 297
 298 define float @constrained_log_nonegzero(float nofpclass(nzero) %arg) strictfp {
 299 ; CHECK-LABEL: define float @constrained_log_nonegzero
 300 ; CHECK-SAME: (float nofpclass(nzero) [[ARG:%.*]]) #[[ATTR9]] {
 301 ; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.experimental.constrained.log.f32(float [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
 302 ; CHECK-NEXT:    ret float [[VAL]]
 303 ;
 304   %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
 305   ret float %val
 306 }
 307
 308 define float @constrained_log_nozero(float nofpclass(zero) %arg) strictfp {
 309 ; CHECK-LABEL: define nofpclass(ninf) float @constrained_log_nozero
 310 ; CHECK-SAME: (float nofpclass(ninf zero) [[ARG:%.*]]) #[[ATTR9]] {
 311 ; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(ninf) float @llvm.experimental.constrained.log.f32(float [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
 312 ; CHECK-NEXT:    ret float [[VAL]]
 313 ;
 314   %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
 315   ret float %val
 316 }
 317
 318 define float @ret_log2_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) #0 {
 319 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log2_noinf_noneg
 320 ; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
 321 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log2.f32(float [[ARG]]) #[[ATTR10]]
 322 ; CHECK-NEXT:    ret float [[CALL]]
 323 ;
 324   %call = call float @llvm.log2.f32(float %arg)
 325   ret float %call
 326 }
 327
 328 define float @ret_log2_noinf_noneg_nonan(float nofpclass(inf nsub nnorm nan) %arg) #0 {
 329 ; CHECK-LABEL: define nofpclass(nan pinf) float @ret_log2_noinf_noneg_nonan
 330 ; CHECK-SAME: (float nofpclass(nan inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
 331 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan pinf) float @llvm.log2.f32(float [[ARG]]) #[[ATTR10]]
 332 ; CHECK-NEXT:    ret float [[CALL]]
 333 ;
 334   %call = call float @llvm.log2.f32(float %arg)
 335   ret float %call
 336 }
 337
 338 define float @ret_log2_noinf_noneg_noqnan(float nofpclass(inf nsub nnorm qnan) %arg) #0 {
 339 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log2_noinf_noneg_noqnan
 340 ; CHECK-SAME: (float nofpclass(qnan inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
 341 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log2.f32(float [[ARG]]) #[[ATTR10]]
 342 ; CHECK-NEXT:    ret float [[CALL]]
 343 ;
 344   %call = call float @llvm.log2.f32(float %arg)
 345   ret float %call
 346 }
 347
 348 define float @ret_log2_noinf_noneg_nosnan(float nofpclass(inf nsub nnorm snan) %arg) #0 {
 349 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log2_noinf_noneg_nosnan
 350 ; CHECK-SAME: (float nofpclass(snan inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
 351 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log2.f32(float [[ARG]]) #[[ATTR10]]
 352 ; CHECK-NEXT:    ret float [[CALL]]
 353 ;
 354   %call = call float @llvm.log2.f32(float %arg)
 355   ret float %call
 356 }
 357
 358 define float @ret_log10_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) #0 {
 359 ; CHECK-LABEL: define nofpclass(pinf) float @ret_log10_noinf_noneg
 360 ; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
 361 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log10.f32(float [[ARG]]) #[[ATTR10]]
 362 ; CHECK-NEXT:    ret float [[CALL]]
 363 ;
 364   %call = call float @llvm.log10.f32(float %arg)
 365   ret float %call
 366 }
 367
 368 define float @ret_constrained_log2_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) strictfp {
 369 ; CHECK-LABEL: define nofpclass(pinf) float @ret_constrained_log2_noinf_noneg
 370 ; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR9]] {
 371 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.experimental.constrained.log2.f32(float [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
 372 ; CHECK-NEXT:    ret float [[CALL]]
 373 ;
 374   %call = call float @llvm.experimental.constrained.log2.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
 375   ret float %call
 376 }
 377
 378 define float @ret_constrained_log10_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) strictfp {
 379 ; CHECK-LABEL: define nofpclass(pinf) float @ret_constrained_log10_noinf_noneg
 380 ; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR9]] {
 381 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.experimental.constrained.log10.f32(float [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
 382 ; CHECK-NEXT:    ret float [[CALL]]
 383 ;
 384   %call = call float @llvm.experimental.constrained.log10.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
 385   ret float %call
 386 }
 387
 388 attributes #0 = { "denormal-fp-math"="ieee,ieee" }
 389 attributes #1 = { "denormal-fp-math"="ieee,preserve-sign" }
 390 attributes #2 = { "denormal-fp-math"="ieee,positive-zero" }
 391 attributes #3 = { "denormal-fp-math"="ieee,dynamic" }
 392 attributes #4 = { "denormal-fp-math"="preserve-sign,ieee" }
 393 attributes #5 = { "denormal-fp-math"="positive-zero,ieee" }
 394 attributes #6 = { "denormal-fp-math"="dynamic,ieee" }
 395
 396 ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
 397 ; TUNIT: {{.*}}