llvm/test/Transforms/InstSimplify/strictfp-fadd.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
   3
   4 ;
   5 ; constrained fadd
   6 ;
   7
   8 ;
   9 ; fadd X, -0 ==> X
  10 ;
  11
  12 define float @fadd_x_n0_defaultenv(float %a) #0 {
  13 ; CHECK-LABEL: @fadd_x_n0_defaultenv(
  14 ; CHECK-NEXT:    ret float [[A:%.*]]
  15 ;
  16   %ret = call float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
  17   ret float %ret
  18 }
  19
  20 define <2 x float> @fadd_vec_x_n0_defaultenv(<2 x float> %a) #0 {
  21 ; CHECK-LABEL: @fadd_vec_x_n0_defaultenv(
  22 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
  23 ;
  24   %ret = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
  25   ret <2 x float> %ret
  26 }
  27
  28 define float @fadd_x_n0_ebmaytrap(float %a) #0 {
  29 ; CHECK-LABEL: @fadd_x_n0_ebmaytrap(
  30 ; CHECK-NEXT:    [[RET:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float -0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0:[0-9]+]]
  31 ; CHECK-NEXT:    ret float [[RET]]
  32 ;
  33   %ret = call float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
  34   ret float %ret
  35 }
  36
  37 define <2 x float> @fadd_vec_x_n0_ebmaytrap(<2 x float> %a) #0 {
  38 ; CHECK-LABEL: @fadd_vec_x_n0_ebmaytrap(
  39 ; CHECK-NEXT:    [[RET:%.*]] = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> splat (float -0.000000e+00), metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
  40 ; CHECK-NEXT:    ret <2 x float> [[RET]]
  41 ;
  42   %ret = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
  43   ret <2 x float> %ret
  44 }
  45
  46 define float @fadd_x_n0_ebstrict(float %a) #0 {
  47 ; CHECK-LABEL: @fadd_x_n0_ebstrict(
  48 ; CHECK-NEXT:    [[RET:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float -0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
  49 ; CHECK-NEXT:    ret float [[RET]]
  50 ;
  51   %ret = call float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
  52   ret float %ret
  53 }
  54
  55 define <2 x float> @fadd_vec_x_n0_ebstrict(<2 x float> %a) #0 {
  56 ; CHECK-LABEL: @fadd_vec_x_n0_ebstrict(
  57 ; CHECK-NEXT:    [[RET:%.*]] = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> splat (float -0.000000e+00), metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
  58 ; CHECK-NEXT:    ret <2 x float> [[RET]]
  59 ;
  60   %ret = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
  61   ret <2 x float> %ret
  62 }
  63
  64 define float @fadd_x_n0_neginf(float %a) #0 {
  65 ; CHECK-LABEL: @fadd_x_n0_neginf(
  66 ; CHECK-NEXT:    [[RET:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float -0.000000e+00, metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
  67 ; CHECK-NEXT:    ret float [[RET]]
  68 ;
  69   %ret = call float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.downward", metadata !"fpexcept.ignore") #0
  70   ret float %ret
  71 }
  72
  73 define <2 x float> @fadd_vec_x_n0_neginf(<2 x float> %a) #0 {
  74 ; CHECK-LABEL: @fadd_vec_x_n0_neginf(
  75 ; CHECK-NEXT:    [[RET:%.*]] = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> splat (float -0.000000e+00), metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
  76 ; CHECK-NEXT:    ret <2 x float> [[RET]]
  77 ;
  78   %ret = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.downward", metadata !"fpexcept.ignore") #0
  79   ret <2 x float> %ret
  80 }
  81
  82 define float @fadd_x_n0_dynamic(float %a) #0 {
  83 ; CHECK-LABEL: @fadd_x_n0_dynamic(
  84 ; CHECK-NEXT:    [[RET:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float -0.000000e+00, metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
  85 ; CHECK-NEXT:    ret float [[RET]]
  86 ;
  87   %ret = call float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
  88   ret float %ret
  89 }
  90
  91 define <2 x float> @fadd_vec_x_n0_dynamic(<2 x float> %a) #0 {
  92 ; CHECK-LABEL: @fadd_vec_x_n0_dynamic(
  93 ; CHECK-NEXT:    [[RET:%.*]] = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> splat (float -0.000000e+00), metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
  94 ; CHECK-NEXT:    ret <2 x float> [[RET]]
  95 ;
  96   %ret = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
  97   ret <2 x float> %ret
  98 }
  99
 100 ; The rounding mode here needs to not be { tonearest, downward, dynamic }.
 101 ; Test one of the remaining rounding modes and the rest will be fine.
 102 define float @fadd_x_n0_towardzero(float %a) #0 {
 103 ; CHECK-LABEL: @fadd_x_n0_towardzero(
 104 ; CHECK-NEXT:    ret float [[A:%.*]]
 105 ;
 106   %ret = call float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.towardzero", metadata !"fpexcept.ignore") #0
 107   ret float %ret
 108 }
 109
 110 ; The rounding mode here needs to not be { tonearest, downward, dynamic }.
 111 ; Test one of the remaining rounding modes and the rest will be fine.
 112 define <2 x float> @fadd_vec_x_n0_towardzero(<2 x float> %a) #0 {
 113 ; CHECK-LABEL: @fadd_vec_x_n0_towardzero(
 114 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 115 ;
 116   %ret = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.towardzero", metadata !"fpexcept.ignore") #0
 117   ret <2 x float> %ret
 118 }
 119
 120 define float @fadd_nnan_x_n0_ebmaytrap(float %a) #0 {
 121 ; CHECK-LABEL: @fadd_nnan_x_n0_ebmaytrap(
 122 ; CHECK-NEXT:    ret float [[A:%.*]]
 123 ;
 124   %ret = call nnan float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 125   ret float %ret
 126 }
 127
 128 define <2 x float> @fadd_vec_nnan_x_n0_ebmaytrap(<2 x float> %a) #0 {
 129 ; CHECK-LABEL: @fadd_vec_nnan_x_n0_ebmaytrap(
 130 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 131 ;
 132   %ret = call nnan <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 133   ret <2 x float> %ret
 134 }
 135
 136 define float @fadd_nnan_x_n0_ebstrict(float %a) #0 {
 137 ; CHECK-LABEL: @fadd_nnan_x_n0_ebstrict(
 138 ; CHECK-NEXT:    [[RET:%.*]] = call nnan float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float -0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 139 ; CHECK-NEXT:    ret float [[A]]
 140 ;
 141   %ret = call nnan float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 142   ret float %ret
 143 }
 144
 145 define <2 x float> @fadd_vec_nnan_x_n0_ebstrict(<2 x float> %a) #0 {
 146 ; CHECK-LABEL: @fadd_vec_nnan_x_n0_ebstrict(
 147 ; CHECK-NEXT:    [[RET:%.*]] = call nnan <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> splat (float -0.000000e+00), metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 148 ; CHECK-NEXT:    ret <2 x float> [[A]]
 149 ;
 150   %ret = call nnan <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 151   ret <2 x float> %ret
 152 }
 153
 154 ; Test with a fast math flag set but that flag is not "nnan".
 155 define float @fadd_ninf_x_n0_ebstrict(float %a) #0 {
 156 ; CHECK-LABEL: @fadd_ninf_x_n0_ebstrict(
 157 ; CHECK-NEXT:    [[RET:%.*]] = call ninf float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float -0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 158 ; CHECK-NEXT:    ret float [[RET]]
 159 ;
 160   %ret = call ninf float @llvm.experimental.constrained.fadd.f32(float %a, float -0.0, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 161   ret float %ret
 162 }
 163
 164 ; Test with a fast math flag set but that flag is not "nnan".
 165 define <2 x float> @fadd_vec_ninf_x_n0_ebstrict(<2 x float> %a) #0 {
 166 ; CHECK-LABEL: @fadd_vec_ninf_x_n0_ebstrict(
 167 ; CHECK-NEXT:    [[RET:%.*]] = call ninf <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> splat (float -0.000000e+00), metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 168 ; CHECK-NEXT:    ret <2 x float> [[RET]]
 169 ;
 170   %ret = call ninf <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float><float -0.0, float -0.0>, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 171   ret <2 x float> %ret
 172 }
 173
 174 define float @fadd_n0_x_defaultenv(float %a) #0 {
 175 ; CHECK-LABEL: @fadd_n0_x_defaultenv(
 176 ; CHECK-NEXT:    ret float [[A:%.*]]
 177 ;
 178   %ret = call float @llvm.experimental.constrained.fadd.f32(float -0.0, float %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 179   ret float %ret
 180 }
 181
 182 define <2 x float> @fadd_vec_n0_x_defaultenv(<2 x float> %a) #0 {
 183 ; CHECK-LABEL: @fadd_vec_n0_x_defaultenv(
 184 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 185 ;
 186   %ret = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float><float -0.0, float -0.0>, <2 x float> %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 187   ret <2 x float> %ret
 188 }
 189
 190 ; TODO: Canonicalize the order of the arguments. Then this will fire.
 191 define float @fadd_n0_x_ebmaytrap(float %a) #0 {
 192 ; CHECK-LABEL: @fadd_n0_x_ebmaytrap(
 193 ; CHECK-NEXT:    [[RET:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float -0.000000e+00, float [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
 194 ; CHECK-NEXT:    ret float [[RET]]
 195 ;
 196   %ret = call float @llvm.experimental.constrained.fadd.f32(float -0.0, float %a, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 197   ret float %ret
 198 }
 199
 200 ; TODO: Canonicalize the order of the arguments. Then this will fire.
 201 define <2 x float> @fadd_vec_n0_x_ebmaytrap(<2 x float> %a) #0 {
 202 ; CHECK-LABEL: @fadd_vec_n0_x_ebmaytrap(
 203 ; CHECK-NEXT:    [[RET:%.*]] = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> splat (float -0.000000e+00), <2 x float> [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
 204 ; CHECK-NEXT:    ret <2 x float> [[RET]]
 205 ;
 206   %ret = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float><float -0.0, float -0.0>, <2 x float> %a, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 207   ret <2 x float> %ret
 208 }
 209
 210 ;
 211 ; fadd X, 0 ==> X, when we know X is not -0
 212 ;
 213
 214 define float @fold_fadd_nsz_x_0_defaultenv(float %a) #0 {
 215 ; CHECK-LABEL: @fold_fadd_nsz_x_0_defaultenv(
 216 ; CHECK-NEXT:    ret float [[A:%.*]]
 217 ;
 218   %add = call nsz float @llvm.experimental.constrained.fadd.f32(float %a, float 0.0, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 219   ret float %add
 220 }
 221
 222 define <2 x float> @fold_fadd_vec_nsz_x_0_defaultenv(<2 x float> %a) #0 {
 223 ; CHECK-LABEL: @fold_fadd_vec_nsz_x_0_defaultenv(
 224 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 225 ;
 226   %add = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 227   ret <2 x float> %add
 228 }
 229
 230 define float @fold_fadd_nsz_x_0_neginf(float %a) #0 {
 231 ; CHECK-LABEL: @fold_fadd_nsz_x_0_neginf(
 232 ; CHECK-NEXT:    ret float [[A:%.*]]
 233 ;
 234   %add = call nsz float @llvm.experimental.constrained.fadd.f32(float %a, float 0.0, metadata !"round.downward", metadata !"fpexcept.ignore") #0
 235   ret float %add
 236 }
 237
 238 define <2 x float> @fold_fadd_vec_nsz_x_0_neginf(<2 x float> %a) #0 {
 239 ; CHECK-LABEL: @fold_fadd_vec_nsz_x_0_neginf(
 240 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 241 ;
 242   %add = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float> zeroinitializer, metadata !"round.downward", metadata !"fpexcept.ignore") #0
 243   ret <2 x float> %add
 244 }
 245
 246 define float @fold_fadd_nsz_x_0_ebmaytrap(float %a) #0 {
 247 ; CHECK-LABEL: @fold_fadd_nsz_x_0_ebmaytrap(
 248 ; CHECK-NEXT:    [[ADD:%.*]] = call nsz float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float 0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
 249 ; CHECK-NEXT:    ret float [[ADD]]
 250 ;
 251   %add = call nsz float @llvm.experimental.constrained.fadd.f32(float %a, float 0.0, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 252   ret float %add
 253 }
 254
 255 define <2 x float> @fold_fadd_vec_nsz_x_0_ebmaytrap(<2 x float> %a) #0 {
 256 ; CHECK-LABEL: @fold_fadd_vec_nsz_x_0_ebmaytrap(
 257 ; CHECK-NEXT:    [[ADD:%.*]] = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
 258 ; CHECK-NEXT:    ret <2 x float> [[ADD]]
 259 ;
 260   %add = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 261   ret <2 x float> %add
 262 }
 263
 264 define float @fold_fadd_nnan_nsz_x_0_ebmaytrap(float %a) #0 {
 265 ; CHECK-LABEL: @fold_fadd_nnan_nsz_x_0_ebmaytrap(
 266 ; CHECK-NEXT:    ret float [[A:%.*]]
 267 ;
 268   %add = call nnan nsz float @llvm.experimental.constrained.fadd.f32(float %a, float 0.0, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 269   ret float %add
 270 }
 271
 272 define <2 x float> @fold_fadd_vec_nnan_nsz_x_0_ebmaytrap(<2 x float> %a) #0 {
 273 ; CHECK-LABEL: @fold_fadd_vec_nnan_nsz_x_0_ebmaytrap(
 274 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 275 ;
 276   %add = call nnan nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 277   ret <2 x float> %add
 278 }
 279
 280 define float @fold_fadd_nsz_x_0_ebstrict(float %a) #0 {
 281 ; CHECK-LABEL: @fold_fadd_nsz_x_0_ebstrict(
 282 ; CHECK-NEXT:    [[ADD:%.*]] = call nsz float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float 0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 283 ; CHECK-NEXT:    ret float [[ADD]]
 284 ;
 285   %add = call nsz float @llvm.experimental.constrained.fadd.f32(float %a, float 0.0, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 286   ret float %add
 287 }
 288
 289 define <2 x float> @fold_fadd_vec_nsz_x_0_ebstrict(<2 x float> %a) #0 {
 290 ; CHECK-LABEL: @fold_fadd_vec_nsz_x_0_ebstrict(
 291 ; CHECK-NEXT:    [[ADD:%.*]] = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 292 ; CHECK-NEXT:    ret <2 x float> [[ADD]]
 293 ;
 294   %add = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 295   ret <2 x float> %add
 296 }
 297
 298 define float @fold_fadd_nsz_nnan_x_0_ebstrict(float %a) #0 {
 299 ; CHECK-LABEL: @fold_fadd_nsz_nnan_x_0_ebstrict(
 300 ; CHECK-NEXT:    [[ADD:%.*]] = call nnan nsz float @llvm.experimental.constrained.fadd.f32(float [[A:%.*]], float 0.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 301 ; CHECK-NEXT:    ret float [[A]]
 302 ;
 303   %add = call nsz nnan float @llvm.experimental.constrained.fadd.f32(float %a, float 0.0, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 304   ret float %add
 305 }
 306
 307 define <2 x float> @fold_fadd_vec_nsz_nnan_x_0_ebstrict(<2 x float> %a) #0 {
 308 ; CHECK-LABEL: @fold_fadd_vec_nsz_nnan_x_0_ebstrict(
 309 ; CHECK-NEXT:    [[ADD:%.*]] = call nnan nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> [[A:%.*]], <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 310 ; CHECK-NEXT:    ret <2 x float> [[A]]
 311 ;
 312   %add = call nsz nnan <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> %a, <2 x float> zeroinitializer, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 313   ret <2 x float> %add
 314 }
 315
 316 define float @fold_fadd_nsz_0_x_defaultenv(float %a) #0 {
 317 ; CHECK-LABEL: @fold_fadd_nsz_0_x_defaultenv(
 318 ; CHECK-NEXT:    ret float [[A:%.*]]
 319 ;
 320   %add = call nsz float @llvm.experimental.constrained.fadd.f32(float 0.0, float %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 321   ret float %add
 322 }
 323
 324 define <2 x float> @fold_fadd_vec_nsz_0_x_defaultenv(<2 x float> %a) #0 {
 325 ; CHECK-LABEL: @fold_fadd_vec_nsz_0_x_defaultenv(
 326 ; CHECK-NEXT:    ret <2 x float> [[A:%.*]]
 327 ;
 328   %add = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> zeroinitializer, <2 x float> %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 329   ret <2 x float> %add
 330 }
 331
 332 ; TODO: Canonicalize the order of the arguments. Then this will fire.
 333 define float @fold_fadd_nsz_0_x_ebmaytrap(float %a) #0 {
 334 ; CHECK-LABEL: @fold_fadd_nsz_0_x_ebmaytrap(
 335 ; CHECK-NEXT:    [[ADD:%.*]] = call nsz float @llvm.experimental.constrained.fadd.f32(float 0.000000e+00, float [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
 336 ; CHECK-NEXT:    ret float [[ADD]]
 337 ;
 338   %add = call nsz float @llvm.experimental.constrained.fadd.f32(float 0.0, float %a, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 339   ret float %add
 340 }
 341
 342 ; TODO: Canonicalize the order of the arguments. Then this will fire.
 343 define <2 x float> @fold_fadd_vec_nsz_0_x_ebmaytrap(<2 x float> %a) #0 {
 344 ; CHECK-LABEL: @fold_fadd_vec_nsz_0_x_ebmaytrap(
 345 ; CHECK-NEXT:    [[ADD:%.*]] = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> zeroinitializer, <2 x float> [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
 346 ; CHECK-NEXT:    ret <2 x float> [[ADD]]
 347 ;
 348   %add = call nsz <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float> zeroinitializer, <2 x float> %a, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 349   ret <2 x float> %add
 350 }
 351
 352 ;
 353 ; fadd with NaNs
 354 ;
 355
 356 define float @fold_fadd_qnan_qnan_ebmaytrap() #0 {
 357 ; CHECK-LABEL: @fold_fadd_qnan_qnan_ebmaytrap(
 358 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 359 ;
 360   %add = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff8000000000000, float 0x7ff8000000000000, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 361   ret float %add
 362 }
 363
 364 define float @fold_fadd_qnan_qnan_ebstrict() #0 {
 365 ; CHECK-LABEL: @fold_fadd_qnan_qnan_ebstrict(
 366 ; CHECK-NEXT:    [[ADD:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF8000000000000, float 0x7FF8000000000000, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 367 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 368 ;
 369   %add = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff8000000000000, float 0x7ff8000000000000, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 370   ret float %add
 371 }
 372
 373 ; Exceptions are ignored, so this can be folded, but constrained math requires that SNaN is quieted per IEEE-754 spec.
 374
 375 define float @fold_fadd_snan_variable_ebignore(float %x) #0 {
 376 ; CHECK-LABEL: @fold_fadd_snan_variable_ebignore(
 377 ; CHECK-NEXT:    ret float 0x7FFC000000000000
 378 ;
 379   %add = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff4000000000000, float %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 380   ret float %add
 381 }
 382
 383 ; Exceptions may (not) trap, so this can be folded, but constrained math requires that SNaN is quieted per IEEE-754 spec.
 384
 385 define float @fold_fadd_snan_variable_ebmaytrap(float %x) #0 {
 386 ; CHECK-LABEL: @fold_fadd_snan_variable_ebmaytrap(
 387 ; CHECK-NEXT:    ret float 0x7FFC000000000000
 388 ;
 389   %add = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff4000000000000, float %x, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 390   ret float %add
 391 }
 392
 393 ; Exceptions are ignored, so this can be folded, but constrained math requires that SNaN is quieted per IEEE-754 spec.
 394
 395 define <2 x float> @fold_fadd_vec_snan_variable_ebignore(<2 x float> %x) #0 {
 396 ; CHECK-LABEL: @fold_fadd_vec_snan_variable_ebignore(
 397 ; CHECK-NEXT:    ret <2 x float> <float 0x7FFC000000000000, float 0xFFFC000000000000>
 398 ;
 399   %add = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float><float 0x7ff4000000000000, float 0xfff4000000000000>, <2 x float> %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 400   ret <2 x float> %add
 401 }
 402
 403 ; Exceptions may (not) trap, so this can be folded, but constrained math requires that SNaN is quieted per IEEE-754 spec.
 404
 405 define <2 x float> @fold_fadd_vec_snan_variable_ebmaytrap(<2 x float> %x) #0 {
 406 ; CHECK-LABEL: @fold_fadd_vec_snan_variable_ebmaytrap(
 407 ; CHECK-NEXT:    ret <2 x float> <float 0xFFFC000000000000, float 0x7FFC000000000000>
 408 ;
 409   %add = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float><float 0xfff4000000000000, float 0x7ff4000000000000>, <2 x float> %x, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 410   ret <2 x float> %add
 411 }
 412
 413 ; Exceptions are ignored, so this can be folded, but constrained math requires that SNaN is quieted per IEEE-754 spec.
 414
 415 define <2 x float> @fold_fadd_vec_partial_snan_variable_ebignore(<2 x float> %x) #0 {
 416 ; CHECK-LABEL: @fold_fadd_vec_partial_snan_variable_ebignore(
 417 ; CHECK-NEXT:    ret <2 x float> <float 0x7FFC000000000000, float 0xFFFF000000000000>
 418 ;
 419   %add = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float><float 0x7ff4000000000000, float 0xffff000000000000>, <2 x float> %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
 420   ret <2 x float> %add
 421 }
 422
 423 ; Exceptions may (not) trap, so this can be folded, but constrained math requires that SNaN is quieted per IEEE-754 spec.
 424
 425 define <2 x float> @fold_fadd_vec_partial_snan_variable_ebmaytrap(<2 x float> %x) #0 {
 426 ; CHECK-LABEL: @fold_fadd_vec_partial_snan_variable_ebmaytrap(
 427 ; CHECK-NEXT:    ret <2 x float> <float 0xFFF8000000000000, float 0x7FFC000000000000>
 428 ;
 429   %add = call <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float><float 0xfff8000000000000, float 0x7ff4000000000000>, <2 x float> %x, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 430   ret <2 x float> %add
 431 }
 432
 433 define float @fold_fadd_snan_variable_ebstrict(float %x) #0 {
 434 ; CHECK-LABEL: @fold_fadd_snan_variable_ebstrict(
 435 ; CHECK-NEXT:    [[ADD:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF4000000000000, float [[X:%.*]], metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 436 ; CHECK-NEXT:    ret float [[ADD]]
 437 ;
 438   %add = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff4000000000000, float %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 439   ret float %add
 440 }
 441
 442 define float @fold_fadd_snan_qnan_ebmaytrap() #0 {
 443 ; CHECK-LABEL: @fold_fadd_snan_qnan_ebmaytrap(
 444 ; CHECK-NEXT:    ret float 0x7FFC000000000000
 445 ;
 446   %add = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff4000000000000, float 0x7ff8000000000000, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
 447   ret float %add
 448 }
 449
 450 define float @fold_fadd_snan_qnan_ebstrict() #0 {
 451 ; CHECK-LABEL: @fold_fadd_snan_qnan_ebstrict(
 452 ; CHECK-NEXT:    [[ADD:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF4000000000000, float 0x7FF8000000000000, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
 453 ; CHECK-NEXT:    ret float [[ADD]]
 454 ;
 455   %add = call float @llvm.experimental.constrained.fadd.f32(float 0x7ff4000000000000, float 0x7ff8000000000000, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
 456   ret float %add
 457 }
 458
 459 declare float @llvm.experimental.constrained.fadd.f32(float, float, metadata, metadata) #0
 460 declare <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float>, <2 x float>, metadata, metadata) #0
 461
 462 attributes #0 = { strictfp }