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 4declare float @llvm.ldexp.f32.i32(float, i32) 5declare float @llvm.ldexp.f32.i64(float, i64) 6declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>) 7declare double @llvm.ldexp.f64.i32(double, i32) 8declare half @llvm.ldexp.f16.i32(half, i32) 9declare bfloat @llvm.ldexp.bf16.i32(bfloat, i32) 10declare i32 @llvm.smin.i32(i32, i32) 11 12define float @ret_ldexp_f32(float %arg0, i32 %arg1) #0 { 13; CHECK-LABEL: define float @ret_ldexp_f32 14; CHECK-SAME: (float [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1:[0-9]+]] { 15; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 [[ARG1]]) #[[ATTR10:[0-9]+]] 16; CHECK-NEXT: ret float [[CALL]] 17; 18 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 19 ret float %call 20} 21 22define float @ret_ldexp_f32_0(float %arg0) #0 { 23; CHECK-LABEL: define float @ret_ldexp_f32_0 24; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 25; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef 0) #[[ATTR10]] 26; CHECK-NEXT: ret float [[CALL]] 27; 28 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 29 ret float %call 30} 31 32define float @ret_ldexp_f32_0_nopsub(float nofpclass(psub) %arg0) #0 { 33; CHECK-LABEL: define nofpclass(psub) float @ret_ldexp_f32_0_nopsub 34; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] { 35; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(psub) float @llvm.ldexp.f32.i32(float nofpclass(psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 36; CHECK-NEXT: ret float [[CALL]] 37; 38 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 39 ret float %call 40} 41 42define float @ret_ldexp_f32_0_nonsub(float nofpclass(nsub) %arg0) #0 { 43; CHECK-LABEL: define nofpclass(nsub) float @ret_ldexp_f32_0_nonsub 44; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] { 45; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nsub) float @llvm.ldexp.f32.i32(float nofpclass(nsub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 46; CHECK-NEXT: ret float [[CALL]] 47; 48 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 49 ret float %call 50} 51 52define float @ret_ldexp_f32_0_nosub(float nofpclass(sub) %arg0) #0 { 53; CHECK-LABEL: define nofpclass(sub) float @ret_ldexp_f32_0_nosub 54; CHECK-SAME: (float nofpclass(sub) [[ARG0:%.*]]) #[[ATTR1]] { 55; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ldexp.f32.i32(float nofpclass(sub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 56; CHECK-NEXT: ret float [[CALL]] 57; 58 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 59 ret float %call 60} 61 62define float @ret_ldexp_f32_0_nosub_nosnan(float nofpclass(sub snan) %arg0) #0 { 63; CHECK-LABEL: define nofpclass(snan sub) float @ret_ldexp_f32_0_nosub_nosnan 64; CHECK-SAME: (float nofpclass(snan sub) [[ARG0:%.*]]) #[[ATTR1]] { 65; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.ldexp.f32.i32(float nofpclass(snan sub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 66; CHECK-NEXT: ret float [[CALL]] 67; 68 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 69 ret float %call 70} 71 72define float @ret_ldexp_f32_0_nopsub_nopzero(float nofpclass(psub pzero) %arg0) #0 { 73; CHECK-LABEL: define nofpclass(pzero psub) float @ret_ldexp_f32_0_nopsub_nopzero 74; CHECK-SAME: (float nofpclass(pzero psub) [[ARG0:%.*]]) #[[ATTR1]] { 75; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pzero psub) float @llvm.ldexp.f32.i32(float nofpclass(pzero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 76; CHECK-NEXT: ret float [[CALL]] 77; 78 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 79 ret float %call 80} 81 82define float @ret_ldexp_f32_0_nonsub_nonzero(float nofpclass(nsub nzero) %arg0) #0 { 83; CHECK-LABEL: define nofpclass(nzero nsub) float @ret_ldexp_f32_0_nonsub_nonzero 84; CHECK-SAME: (float nofpclass(nzero nsub) [[ARG0:%.*]]) #[[ATTR1]] { 85; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nzero nsub) float @llvm.ldexp.f32.i32(float nofpclass(nzero nsub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 86; CHECK-NEXT: ret float [[CALL]] 87; 88 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 89 ret float %call 90} 91 92define float @ret_ldexp_f32_0_nosub_nozero(float nofpclass(sub zero) %arg0) #0 { 93; CHECK-LABEL: define nofpclass(zero sub) float @ret_ldexp_f32_0_nosub_nozero 94; CHECK-SAME: (float nofpclass(zero sub) [[ARG0:%.*]]) #[[ATTR1]] { 95; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(zero sub) float @llvm.ldexp.f32.i32(float nofpclass(zero sub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 96; CHECK-NEXT: ret float [[CALL]] 97; 98 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 99 ret float %call 100} 101 102define float @ret_ldexp_f32_0_nopsub_daz(float nofpclass(psub) %arg0) #1 { 103; CHECK-LABEL: define nofpclass(psub) float @ret_ldexp_f32_0_nopsub_daz 104; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR2:[0-9]+]] { 105; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(psub) float @llvm.ldexp.f32.i32(float nofpclass(psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 106; CHECK-NEXT: ret float [[CALL]] 107; 108 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 109 ret float %call 110} 111 112define float @ret_ldexp_f32_0_nonsub_daz(float nofpclass(nsub) %arg0) #1 { 113; CHECK-LABEL: define nofpclass(nsub) float @ret_ldexp_f32_0_nonsub_daz 114; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR2]] { 115; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nsub) float @llvm.ldexp.f32.i32(float nofpclass(nsub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 116; CHECK-NEXT: ret float [[CALL]] 117; 118 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 119 ret float %call 120} 121 122define float @ret_ldexp_f32_0_nosub_daz(float nofpclass(sub) %arg0) #1 { 123; CHECK-LABEL: define nofpclass(sub) float @ret_ldexp_f32_0_nosub_daz 124; CHECK-SAME: (float nofpclass(sub) [[ARG0:%.*]]) #[[ATTR2]] { 125; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ldexp.f32.i32(float nofpclass(sub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 126; CHECK-NEXT: ret float [[CALL]] 127; 128 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 129 ret float %call 130} 131 132define float @ret_ldexp_f32_0_nosub_nosnan_daz(float nofpclass(sub snan) %arg0) #1 { 133; CHECK-LABEL: define nofpclass(snan sub) float @ret_ldexp_f32_0_nosub_nosnan_daz 134; CHECK-SAME: (float nofpclass(snan sub) [[ARG0:%.*]]) #[[ATTR2]] { 135; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.ldexp.f32.i32(float nofpclass(snan sub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 136; CHECK-NEXT: ret float [[CALL]] 137; 138 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 139 ret float %call 140} 141 142define float @ret_ldexp_f32_0_nopsub_nozero_daz(float nofpclass(psub pzero) %arg0) #1 { 143; CHECK-LABEL: define nofpclass(pzero psub) float @ret_ldexp_f32_0_nopsub_nozero_daz 144; CHECK-SAME: (float nofpclass(pzero psub) [[ARG0:%.*]]) #[[ATTR2]] { 145; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pzero psub) float @llvm.ldexp.f32.i32(float nofpclass(pzero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 146; CHECK-NEXT: ret float [[CALL]] 147; 148 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 149 ret float %call 150} 151 152define float @ret_ldexp_f32_0_nonsub_nonzero_daz(float nofpclass(nsub nzero) %arg0) #1 { 153; CHECK-LABEL: define nofpclass(nzero nsub) float @ret_ldexp_f32_0_nonsub_nonzero_daz 154; CHECK-SAME: (float nofpclass(nzero nsub) [[ARG0:%.*]]) #[[ATTR2]] { 155; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nzero nsub) float @llvm.ldexp.f32.i32(float nofpclass(nzero nsub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 156; CHECK-NEXT: ret float [[CALL]] 157; 158 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 159 ret float %call 160} 161 162define float @ret_ldexp_f32_0_nosub_nozero_daz(float nofpclass(sub zero) %arg0) #1 { 163; CHECK-LABEL: define nofpclass(zero sub) float @ret_ldexp_f32_0_nosub_nozero_daz 164; CHECK-SAME: (float nofpclass(zero sub) [[ARG0:%.*]]) #[[ATTR2]] { 165; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(zero sub) float @llvm.ldexp.f32.i32(float nofpclass(zero sub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 166; CHECK-NEXT: ret float [[CALL]] 167; 168 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 169 ret float %call 170} 171 172define float @ret_ldexp_f32_0_nopsub_dapz(float nofpclass(psub) %arg0) #2 { 173; CHECK-LABEL: define nofpclass(psub) float @ret_ldexp_f32_0_nopsub_dapz 174; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR3:[0-9]+]] { 175; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(psub) float @llvm.ldexp.f32.i32(float nofpclass(psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 176; CHECK-NEXT: ret float [[CALL]] 177; 178 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 179 ret float %call 180} 181 182define float @ret_ldexp_f32_0_nonsub_dapz(float nofpclass(nsub) %arg0) #2 { 183; CHECK-LABEL: define nofpclass(nsub) float @ret_ldexp_f32_0_nonsub_dapz 184; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR3]] { 185; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nsub) float @llvm.ldexp.f32.i32(float nofpclass(nsub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 186; CHECK-NEXT: ret float [[CALL]] 187; 188 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 189 ret float %call 190} 191 192define float @ret_ldexp_f32_0_nosub_dapz(float nofpclass(sub) %arg0) #2 { 193; CHECK-LABEL: define nofpclass(sub) float @ret_ldexp_f32_0_nosub_dapz 194; CHECK-SAME: (float nofpclass(sub) [[ARG0:%.*]]) #[[ATTR3]] { 195; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ldexp.f32.i32(float nofpclass(sub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 196; CHECK-NEXT: ret float [[CALL]] 197; 198 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 199 ret float %call 200} 201 202define float @ret_ldexp_f32_0_nopsub_nozero_dapz(float nofpclass(psub zero) %arg0) #2 { 203; CHECK-LABEL: define nofpclass(nzero psub) float @ret_ldexp_f32_0_nopsub_nozero_dapz 204; CHECK-SAME: (float nofpclass(zero psub) [[ARG0:%.*]]) #[[ATTR3]] { 205; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nzero psub) float @llvm.ldexp.f32.i32(float nofpclass(zero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 206; CHECK-NEXT: ret float [[CALL]] 207; 208 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 209 ret float %call 210} 211 212define float @ret_ldexp_f32_0_nonsub_nonzero_dapz(float nofpclass(nsub nzero) %arg0) #2 { 213; CHECK-LABEL: define nofpclass(nzero nsub) float @ret_ldexp_f32_0_nonsub_nonzero_dapz 214; CHECK-SAME: (float nofpclass(nzero nsub) [[ARG0:%.*]]) #[[ATTR3]] { 215; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nzero nsub) float @llvm.ldexp.f32.i32(float nofpclass(nzero nsub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 216; CHECK-NEXT: ret float [[CALL]] 217; 218 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 219 ret float %call 220} 221 222define float @ret_ldexp_f32_0_nosub_nozero_dapz(float nofpclass(sub zero) %arg0) #2 { 223; CHECK-LABEL: define nofpclass(zero sub) float @ret_ldexp_f32_0_nosub_nozero_dapz 224; CHECK-SAME: (float nofpclass(zero sub) [[ARG0:%.*]]) #[[ATTR3]] { 225; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(zero sub) float @llvm.ldexp.f32.i32(float nofpclass(zero sub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 226; CHECK-NEXT: ret float [[CALL]] 227; 228 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 229 ret float %call 230} 231 232define float @ret_ldexp_f32_0_nopsub_nozero_dapz_dapz(float nofpclass(psub zero) %arg0) #2 { 233; CHECK-LABEL: define nofpclass(nzero psub) float @ret_ldexp_f32_0_nopsub_nozero_dapz_dapz 234; CHECK-SAME: (float nofpclass(zero psub) [[ARG0:%.*]]) #[[ATTR3]] { 235; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nzero psub) float @llvm.ldexp.f32.i32(float nofpclass(zero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 236; CHECK-NEXT: ret float [[CALL]] 237; 238 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 239 ret float %call 240} 241 242define float @ret_ldexp_f32_0_nopsub_nozero_daz_ieee(float nofpclass(psub zero) %arg0) #3 { 243; CHECK-LABEL: define nofpclass(pzero psub) float @ret_ldexp_f32_0_nopsub_nozero_daz_ieee 244; CHECK-SAME: (float nofpclass(zero psub) [[ARG0:%.*]]) #[[ATTR4:[0-9]+]] { 245; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pzero psub) float @llvm.ldexp.f32.i32(float nofpclass(zero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 246; CHECK-NEXT: ret float [[CALL]] 247; 248 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 249 ret float %call 250} 251 252define float @ret_ldexp_f32_0_nopsub_nozero_daz_dynamic(float nofpclass(psub zero) %arg0) #4 { 253; CHECK-LABEL: define nofpclass(psub) float @ret_ldexp_f32_0_nopsub_nozero_daz_dynamic 254; CHECK-SAME: (float nofpclass(zero psub) [[ARG0:%.*]]) #[[ATTR5:[0-9]+]] { 255; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(psub) float @llvm.ldexp.f32.i32(float nofpclass(zero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 256; CHECK-NEXT: ret float [[CALL]] 257; 258 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 259 ret float %call 260} 261 262define float @ret_ldexp_f32_0_nopsub_nozero_ieee_daz(float nofpclass(psub zero) %arg0) #5 { 263; CHECK-LABEL: define nofpclass(pzero psub) float @ret_ldexp_f32_0_nopsub_nozero_ieee_daz 264; CHECK-SAME: (float nofpclass(zero psub) [[ARG0:%.*]]) #[[ATTR6:[0-9]+]] { 265; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pzero psub) float @llvm.ldexp.f32.i32(float nofpclass(zero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 266; CHECK-NEXT: ret float [[CALL]] 267; 268 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 269 ret float %call 270} 271 272define float @ret_ldexp_f32_0_nopsub_nozero_dynamic_daz(float nofpclass(psub zero) %arg0) #6 { 273; CHECK-LABEL: define nofpclass(psub) float @ret_ldexp_f32_0_nopsub_nozero_dynamic_daz 274; CHECK-SAME: (float nofpclass(zero psub) [[ARG0:%.*]]) #[[ATTR7:[0-9]+]] { 275; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(psub) float @llvm.ldexp.f32.i32(float nofpclass(zero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 276; CHECK-NEXT: ret float [[CALL]] 277; 278 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 279 ret float %call 280} 281 282define float @ret_ldexp_f32_0_nopsub_nozero_dynamic_dapz(float nofpclass(psub zero) %arg0) #7 { 283; CHECK-LABEL: define nofpclass(psub) float @ret_ldexp_f32_0_nopsub_nozero_dynamic_dapz 284; CHECK-SAME: (float nofpclass(zero psub) [[ARG0:%.*]]) #[[ATTR8:[0-9]+]] { 285; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(psub) float @llvm.ldexp.f32.i32(float nofpclass(zero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 286; CHECK-NEXT: ret float [[CALL]] 287; 288 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 289 ret float %call 290} 291 292define float @ret_ldexp_f32_0_nopsub_nozero_dapz_dynamic(float nofpclass(psub zero) %arg0) #8 { 293; CHECK-LABEL: define nofpclass(psub) float @ret_ldexp_f32_0_nopsub_nozero_dapz_dynamic 294; CHECK-SAME: (float nofpclass(zero psub) [[ARG0:%.*]]) #[[ATTR9:[0-9]+]] { 295; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(psub) float @llvm.ldexp.f32.i32(float nofpclass(zero psub) [[ARG0]], i32 noundef 0) #[[ATTR10]] 296; CHECK-NEXT: ret float [[CALL]] 297; 298 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 299 ret float %call 300} 301 302define float @ret_ldexp_f32_0_nopnorm(float nofpclass(pnorm) %arg0) #0 { 303; CHECK-LABEL: define nofpclass(pnorm) float @ret_ldexp_f32_0_nopnorm 304; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] { 305; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pnorm) float @llvm.ldexp.f32.i32(float nofpclass(pnorm) [[ARG0]], i32 noundef 0) #[[ATTR10]] 306; CHECK-NEXT: ret float [[CALL]] 307; 308 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 309 ret float %call 310} 311 312define float @ret_ldexp_f32_0_nnorm(float nofpclass(nnorm) %arg0) #0 { 313; CHECK-LABEL: define nofpclass(nnorm) float @ret_ldexp_f32_0_nnorm 314; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] { 315; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nnorm) float @llvm.ldexp.f32.i32(float nofpclass(nnorm) [[ARG0]], i32 noundef 0) #[[ATTR10]] 316; CHECK-NEXT: ret float [[CALL]] 317; 318 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 319 ret float %call 320} 321 322define float @ret_ldexp_f32_0_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) #0 { 323; CHECK-LABEL: define nofpclass(nsub pnorm) float @ret_ldexp_f32_0_nopnorm_nonsub 324; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] { 325; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nsub pnorm) float @llvm.ldexp.f32.i32(float nofpclass(nsub pnorm) [[ARG0]], i32 noundef 0) #[[ATTR10]] 326; CHECK-NEXT: ret float [[CALL]] 327; 328 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 0) 329 ret float %call 330} 331 332define <2 x float> @ret_ldexp_v2f32_0(<2 x float> %arg0) #0 { 333; CHECK-LABEL: define <2 x float> @ret_ldexp_v2f32_0 334; CHECK-SAME: (<2 x float> [[ARG0:%.*]]) #[[ATTR1]] { 335; CHECK-NEXT: [[CALL:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[ARG0]], <2 x i32> <i32 undef, i32 0>) #[[ATTR10]] 336; CHECK-NEXT: ret <2 x float> [[CALL]] 337; 338 %call = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %arg0, <2 x i32> <i32 undef, i32 0>) 339 ret <2 x float> %call 340} 341 342define float @ret_ldexp_f32_i64(float %arg0, i64 %arg1) #0 { 343; CHECK-LABEL: define float @ret_ldexp_f32_i64 344; CHECK-SAME: (float [[ARG0:%.*]], i64 [[ARG1:%.*]]) #[[ATTR1]] { 345; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i64(float [[ARG0]], i64 [[ARG1]]) #[[ATTR10]] 346; CHECK-NEXT: ret float [[CALL]] 347; 348 %call = call float @llvm.ldexp.f32.i64(float %arg0, i64 %arg1) 349 ret float %call 350} 351 352define <2 x float> @ret_ldexp_v2f32(<2 x float> %arg0, <2 x i32> %arg1) #0 { 353; CHECK-LABEL: define <2 x float> @ret_ldexp_v2f32 354; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x i32> [[ARG1:%.*]]) #[[ATTR1]] { 355; CHECK-NEXT: [[CALL:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[ARG0]], <2 x i32> [[ARG1]]) #[[ATTR10]] 356; CHECK-NEXT: ret <2 x float> [[CALL]] 357; 358 %call = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %arg0, <2 x i32> %arg1) 359 ret <2 x float> %call 360} 361 362define float @ret_ldexp_f32_nonan(float nofpclass(nan) %arg0, i32 %arg1) #0 { 363; CHECK-LABEL: define nofpclass(nan) float @ret_ldexp_f32_nonan 364; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 365; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan) float @llvm.ldexp.f32.i32(float nofpclass(nan) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 366; CHECK-NEXT: ret float [[CALL]] 367; 368 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 369 ret float %call 370} 371 372define float @ret_ldexp_f32_nosnan(float nofpclass(snan) %arg0, i32 %arg1) #0 { 373; CHECK-LABEL: define nofpclass(snan) float @ret_ldexp_f32_nosnan 374; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 375; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(snan) float @llvm.ldexp.f32.i32(float nofpclass(snan) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 376; CHECK-NEXT: ret float [[CALL]] 377; 378 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 379 ret float %call 380} 381 382define float @ret_ldexp_f32_noqnan(float nofpclass(qnan) %arg0, i32 %arg1) #0 { 383; CHECK-LABEL: define float @ret_ldexp_f32_noqnan 384; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 385; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(qnan) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 386; CHECK-NEXT: ret float [[CALL]] 387; 388 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 389 ret float %call 390} 391 392define float @ret_ldexp_f32_noneg(float nofpclass(ninf nsub nnorm) %arg0, i32 %arg1) #0 { 393; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @ret_ldexp_f32_noneg 394; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 395; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nsub nnorm) float @llvm.ldexp.f32.i32(float nofpclass(ninf nsub nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 396; CHECK-NEXT: ret float [[CALL]] 397; 398 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 399 ret float %call 400} 401 402define float @ret_ldexp_f32_noneg_nonzero(float nofpclass(ninf nsub nnorm nzero) %arg0, i32 %arg1) #0 { 403; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_ldexp_f32_noneg_nonzero 404; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 405; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.ldexp.f32.i32(float nofpclass(ninf nzero nsub nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 406; CHECK-NEXT: ret float [[CALL]] 407; 408 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 409 ret float %call 410} 411 412define float @ret_ldexp_f32_noneg_nozero(float nofpclass(ninf nsub nnorm) %arg0, i32 %arg1) #0 { 413; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @ret_ldexp_f32_noneg_nozero 414; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 415; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nsub nnorm) float @llvm.ldexp.f32.i32(float nofpclass(ninf nsub nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 416; CHECK-NEXT: ret float [[CALL]] 417; 418 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 419 ret float %call 420} 421 422define float @ret_ldexp_f32_nonzero(float nofpclass(nzero) %arg0, i32 %arg1) #0 { 423; CHECK-LABEL: define float @ret_ldexp_f32_nonzero 424; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 425; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(nzero) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 426; CHECK-NEXT: ret float [[CALL]] 427; 428 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 429 ret float %call 430} 431 432define float @ret_ldexp_f32_nopzero(float nofpclass(pzero) %arg0, i32 %arg1) #0 { 433; CHECK-LABEL: define float @ret_ldexp_f32_nopzero 434; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 435; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(pzero) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 436; CHECK-NEXT: ret float [[CALL]] 437; 438 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 439 ret float %call 440} 441 442define float @ret_ldexp_f32_noneg_ftz_daz(float nofpclass(ninf nsub nnorm) %arg0, i32 %arg1) #1 { 443; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @ret_ldexp_f32_noneg_ftz_daz 444; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 445; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nsub nnorm) float @llvm.ldexp.f32.i32(float nofpclass(ninf nsub nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 446; CHECK-NEXT: ret float [[CALL]] 447; 448 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 449 ret float %call 450} 451 452define float @ret_ldexp_f32_noneg_nonzero_ftz_daz(float nofpclass(ninf nsub nnorm nzero) %arg0, i32 %arg1) #1 { 453; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_ldexp_f32_noneg_nonzero_ftz_daz 454; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 455; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.ldexp.f32.i32(float nofpclass(ninf nzero nsub nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 456; CHECK-NEXT: ret float [[CALL]] 457; 458 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 459 ret float %call 460} 461 462define float @ret_ldexp_f32_noneg_nonzero_ftpz_dapz(float nofpclass(ninf nsub nnorm nzero) %arg0, i32 %arg1) #2 { 463; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_ldexp_f32_noneg_nonzero_ftpz_dapz 464; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR3]] { 465; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.ldexp.f32.i32(float nofpclass(ninf nzero nsub nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 466; CHECK-NEXT: ret float [[CALL]] 467; 468 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 469 ret float %call 470} 471 472define float @ret_ldexp_f32_noninf_nonnorm(float nofpclass(ninf nnorm) %arg0, i32 %arg1) #0 { 473; CHECK-LABEL: define float @ret_ldexp_f32_noninf_nonnorm 474; CHECK-SAME: (float nofpclass(ninf nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 475; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(ninf nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 476; CHECK-NEXT: ret float [[CALL]] 477; 478 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 479 ret float %call 480} 481 482define float @ret_ldexp_f32_noninf_nonnorm_ftz_daz(float nofpclass(ninf nnorm) %arg0, i32 %arg1) #1 { 483; CHECK-LABEL: define float @ret_ldexp_f32_noninf_nonnorm_ftz_daz 484; CHECK-SAME: (float nofpclass(ninf nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 485; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(ninf nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 486; CHECK-NEXT: ret float [[CALL]] 487; 488 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 489 ret float %call 490} 491 492define float @ret_ldexp_f32_noneg_ftz_ieee(float nofpclass(ninf nsub nnorm) %arg0, i32 %arg1) #3 { 493; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @ret_ldexp_f32_noneg_ftz_ieee 494; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR4]] { 495; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nsub nnorm) float @llvm.ldexp.f32.i32(float nofpclass(ninf nsub nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 496; CHECK-NEXT: ret float [[CALL]] 497; 498 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 499 ret float %call 500} 501 502define float @ret_ldexp_f32_noneg_nonzero_ftz_ieee(float nofpclass(ninf nsub nnorm nzero) %arg0, i32 %arg1) #3 { 503; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_ldexp_f32_noneg_nonzero_ftz_ieee 504; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR4]] { 505; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.ldexp.f32.i32(float nofpclass(ninf nzero nsub nnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 506; CHECK-NEXT: ret float [[CALL]] 507; 508 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 509 ret float %call 510} 511 512define float @ret_ldexp_f32_nopos(float nofpclass(pinf psub pnorm) %arg0, i32 %arg1) #0 { 513; CHECK-LABEL: define nofpclass(pinf psub pnorm) float @ret_ldexp_f32_nopos 514; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 515; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf psub pnorm) float @llvm.ldexp.f32.i32(float nofpclass(pinf psub pnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 516; CHECK-NEXT: ret float [[CALL]] 517; 518 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 519 ret float %call 520} 521 522define float @ret_ldexp_f32_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0, i32 %arg1) #0 { 523; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_ldexp_f32_nopos_nopzero 524; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 525; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero psub pnorm) float @llvm.ldexp.f32.i32(float nofpclass(pinf pzero psub pnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 526; CHECK-NEXT: ret float [[CALL]] 527; 528 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 529 ret float %call 530} 531 532define float @ret_ldexp_f32_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0, i32 %arg1) #0 { 533; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_ldexp_f32_nopos_nozero 534; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 535; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf pzero psub pnorm) float @llvm.ldexp.f32.i32(float nofpclass(pinf zero psub pnorm) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 536; CHECK-NEXT: ret float [[CALL]] 537; 538 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 539 ret float %call 540} 541 542define float @ret_ldexp_f32_nozero(float nofpclass(zero) %arg0, i32 %arg1) #0 { 543; CHECK-LABEL: define float @ret_ldexp_f32_nozero 544; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 545; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(zero) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 546; CHECK-NEXT: ret float [[CALL]] 547; 548 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 549 ret float %call 550} 551 552define float @ret_ldexp_f32_noinf(float nofpclass(inf) %arg0, i32 %arg1) #0 { 553; CHECK-LABEL: define float @ret_ldexp_f32_noinf 554; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 555; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(inf) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 556; CHECK-NEXT: ret float [[CALL]] 557; 558 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 559 ret float %call 560} 561 562define float @ret_ldexp_f32_noinf_nonan(float nofpclass(inf nan) %arg0, i32 %arg1) #0 { 563; CHECK-LABEL: define nofpclass(nan) float @ret_ldexp_f32_noinf_nonan 564; CHECK-SAME: (float nofpclass(nan inf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 565; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan) float @llvm.ldexp.f32.i32(float nofpclass(nan inf) [[ARG0]], i32 [[ARG1]]) #[[ATTR10]] 566; CHECK-NEXT: ret float [[CALL]] 567; 568 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %arg1) 569 ret float %call 570} 571 572define float @ret_ldexp_f32_known_pos_exp(float %arg0, i32 %arg1) #0 { 573; CHECK-LABEL: define float @ret_ldexp_f32_known_pos_exp 574; CHECK-SAME: (float [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 575; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 576; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 577; CHECK-NEXT: ret float [[CALL]] 578; 579 %and.arg1 = and i32 %arg1, 127 580 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 581 ret float %call 582} 583 584define float @ret_ldexp_f32_known_neg_exp(float %arg0, i32 %arg1) #0 { 585; CHECK-LABEL: define float @ret_ldexp_f32_known_neg_exp 586; CHECK-SAME: (float [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 587; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 588; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 589; CHECK-NEXT: ret float [[CALL]] 590; 591 %or.arg1 = or i32 %arg1, -16 592 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 593 ret float %call 594} 595 596define float @ret_ldexp_f32_known_pos_exp_nosub(float nofpclass(sub) %arg0, i32 %arg1) #0 { 597; CHECK-LABEL: define nofpclass(sub) float @ret_ldexp_f32_known_pos_exp_nosub 598; CHECK-SAME: (float nofpclass(sub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 599; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 600; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ldexp.f32.i32(float nofpclass(sub) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 601; CHECK-NEXT: ret float [[CALL]] 602; 603 %and.arg1 = and i32 %arg1, 127 604 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 605 ret float %call 606} 607 608define float @ret_ldexp_f32_known_neg_exp_nosub(float nofpclass(sub) %arg0, i32 %arg1) #0 { 609; CHECK-LABEL: define float @ret_ldexp_f32_known_neg_exp_nosub 610; CHECK-SAME: (float nofpclass(sub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 611; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 612; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(sub) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 613; CHECK-NEXT: ret float [[CALL]] 614; 615 %or.arg1 = or i32 %arg1, -16 616 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 617 ret float %call 618} 619 620define float @ret_ldexp_f32_known_pos_exp_nopsub(float nofpclass(psub) %arg0, i32 %arg1) #0 { 621; CHECK-LABEL: define nofpclass(psub) float @ret_ldexp_f32_known_pos_exp_nopsub 622; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 623; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 624; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(psub) float @llvm.ldexp.f32.i32(float nofpclass(psub) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 625; CHECK-NEXT: ret float [[CALL]] 626; 627 %and.arg1 = and i32 %arg1, 127 628 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 629 ret float %call 630} 631 632define float @ret_ldexp_f32_known_neg_exp_nopsub(float nofpclass(psub) %arg0, i32 %arg1) #0 { 633; CHECK-LABEL: define float @ret_ldexp_f32_known_neg_exp_nopsub 634; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 635; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 636; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(psub) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 637; CHECK-NEXT: ret float [[CALL]] 638; 639 %or.arg1 = or i32 %arg1, -16 640 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 641 ret float %call 642} 643 644define float @ret_ldexp_f32_known_pos_exp_nonsub(float nofpclass(nsub) %arg0, i32 %arg1) #0 { 645; CHECK-LABEL: define nofpclass(nsub) float @ret_ldexp_f32_known_pos_exp_nonsub 646; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 647; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 648; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nsub) float @llvm.ldexp.f32.i32(float nofpclass(nsub) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 649; CHECK-NEXT: ret float [[CALL]] 650; 651 %and.arg1 = and i32 %arg1, 127 652 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 653 ret float %call 654} 655 656define float @ret_ldexp_f32_known_neg_exp_nonsub(float nofpclass(nsub) %arg0, i32 %arg1) #0 { 657; CHECK-LABEL: define float @ret_ldexp_f32_known_neg_exp_nonsub 658; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 659; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 660; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(nsub) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 661; CHECK-NEXT: ret float [[CALL]] 662; 663 %or.arg1 = or i32 %arg1, -16 664 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 665 ret float %call 666} 667 668define float @ret_ldexp_f32_known_pos_exp_noinf(float nofpclass(inf) %arg0, i32 %arg1) #0 { 669; CHECK-LABEL: define float @ret_ldexp_f32_known_pos_exp_noinf 670; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 671; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 672; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(inf) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 673; CHECK-NEXT: ret float [[CALL]] 674; 675 %and.arg1 = and i32 %arg1, 127 676 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 677 ret float %call 678} 679 680define float @ret_ldexp_f32_known_neg_exp_noinf(float nofpclass(inf) %arg0, i32 %arg1) #0 { 681; CHECK-LABEL: define nofpclass(inf) float @ret_ldexp_f32_known_neg_exp_noinf 682; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 683; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 684; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.ldexp.f32.i32(float nofpclass(inf) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 685; CHECK-NEXT: ret float [[CALL]] 686; 687 %or.arg1 = or i32 %arg1, -16 688 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 689 ret float %call 690} 691 692define <2 x float> @ret_ldexp_v2f32_known_pos_exp_noinf(<2 x float> nofpclass(inf) %arg0, <2 x i32> %arg1) #0 { 693; CHECK-LABEL: define <2 x float> @ret_ldexp_v2f32_known_pos_exp_noinf 694; CHECK-SAME: (<2 x float> nofpclass(inf) [[ARG0:%.*]], <2 x i32> [[ARG1:%.*]]) #[[ATTR1]] { 695; CHECK-NEXT: [[AND_ARG1:%.*]] = and <2 x i32> [[ARG1]], <i32 127, i32 64> 696; CHECK-NEXT: [[CALL:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> nofpclass(inf) [[ARG0]], <2 x i32> [[AND_ARG1]]) #[[ATTR10]] 697; CHECK-NEXT: ret <2 x float> [[CALL]] 698; 699 %and.arg1 = and <2 x i32> %arg1, <i32 127, i32 64> 700 %call = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %arg0, <2 x i32> %and.arg1) 701 ret <2 x float> %call 702} 703 704define <2 x float> @ret_ldexp_v2f32_known_neg_exp_noinf(<2 x float> nofpclass(inf) %arg0, <2 x i32> %arg1) #0 { 705; CHECK-LABEL: define <2 x float> @ret_ldexp_v2f32_known_neg_exp_noinf 706; CHECK-SAME: (<2 x float> nofpclass(inf) [[ARG0:%.*]], <2 x i32> [[ARG1:%.*]]) #[[ATTR1]] { 707; CHECK-NEXT: [[OR_ARG1:%.*]] = or <2 x i32> [[ARG1]], <i32 -16, i32 -32> 708; CHECK-NEXT: [[CALL:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> nofpclass(inf) [[ARG0]], <2 x i32> [[OR_ARG1]]) #[[ATTR10]] 709; CHECK-NEXT: ret <2 x float> [[CALL]] 710; 711 %or.arg1 = or <2 x i32> %arg1, <i32 -16, i32 -32> 712 %call = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %arg0, <2 x i32> %or.arg1) 713 ret <2 x float> %call 714} 715 716define float @ret_ldexp_f32_known_pos_exp_nopinf(float nofpclass(pinf) %arg0, i32 %arg1) #0 { 717; CHECK-LABEL: define float @ret_ldexp_f32_known_pos_exp_nopinf 718; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 719; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 720; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(pinf) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 721; CHECK-NEXT: ret float [[CALL]] 722; 723 %and.arg1 = and i32 %arg1, 127 724 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 725 ret float %call 726} 727 728define float @ret_ldexp_f32_known_neg_exp_nopinf(float nofpclass(pinf) %arg0, i32 %arg1) #0 { 729; CHECK-LABEL: define nofpclass(pinf) float @ret_ldexp_f32_known_neg_exp_nopinf 730; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 731; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 732; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pinf) float @llvm.ldexp.f32.i32(float nofpclass(pinf) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 733; CHECK-NEXT: ret float [[CALL]] 734; 735 %or.arg1 = or i32 %arg1, -16 736 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 737 ret float %call 738} 739 740define float @ret_ldexp_f32_known_pos_exp_noninf(float nofpclass(ninf) %arg0, i32 %arg1) #0 { 741; CHECK-LABEL: define float @ret_ldexp_f32_known_pos_exp_noninf 742; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 743; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 744; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(ninf) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 745; CHECK-NEXT: ret float [[CALL]] 746; 747 %and.arg1 = and i32 %arg1, 127 748 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 749 ret float %call 750} 751 752define float @ret_ldexp_f32_known_neg_exp_noninf(float nofpclass(ninf) %arg0, i32 %arg1) #0 { 753; CHECK-LABEL: define nofpclass(ninf) float @ret_ldexp_f32_known_neg_exp_noninf 754; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 755; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 756; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(ninf) float @llvm.ldexp.f32.i32(float nofpclass(ninf) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 757; CHECK-NEXT: ret float [[CALL]] 758; 759 %or.arg1 = or i32 %arg1, -16 760 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 761 ret float %call 762} 763 764define float @ret_ldexp_f32_known_pos_exp_nopsub_nopzero_daz(float nofpclass(psub pzero) %arg0, i32 %arg1) #1 { 765; CHECK-LABEL: define nofpclass(pzero psub) float @ret_ldexp_f32_known_pos_exp_nopsub_nopzero_daz 766; CHECK-SAME: (float nofpclass(pzero psub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 767; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 768; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(pzero psub) float @llvm.ldexp.f32.i32(float nofpclass(pzero psub) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 769; CHECK-NEXT: ret float [[CALL]] 770; 771 %and.arg1 = and i32 %arg1, 127 772 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 773 ret float %call 774} 775 776define float @ret_ldexp_f32_known_neg_exp_nopsub_nopzero_daz(float nofpclass(psub pzero) %arg0, i32 %arg1) #1 { 777; CHECK-LABEL: define float @ret_ldexp_f32_known_neg_exp_nopsub_nopzero_daz 778; CHECK-SAME: (float nofpclass(pzero psub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 779; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 780; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(pzero psub) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 781; CHECK-NEXT: ret float [[CALL]] 782; 783 %or.arg1 = or i32 %arg1, -16 784 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 785 ret float %call 786} 787 788define float @ret_ldexp_f32_known_pos_exp_nonsub_nonzero_daz(float nofpclass(nsub nzero) %arg0, i32 %arg1) #1 { 789; CHECK-LABEL: define nofpclass(nzero nsub) float @ret_ldexp_f32_known_pos_exp_nonsub_nonzero_daz 790; CHECK-SAME: (float nofpclass(nzero nsub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 791; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 792; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nzero nsub) float @llvm.ldexp.f32.i32(float nofpclass(nzero nsub) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 793; CHECK-NEXT: ret float [[CALL]] 794; 795 %and.arg1 = and i32 %arg1, 127 796 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 797 ret float %call 798} 799 800define float @ret_ldexp_f32_known_neg_exp_nonsub_nonzero_daz(float nofpclass(nsub nzero) %arg0, i32 %arg1) #1 { 801; CHECK-LABEL: define float @ret_ldexp_f32_known_neg_exp_nonsub_nonzero_daz 802; CHECK-SAME: (float nofpclass(nzero nsub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 803; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 804; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(nzero nsub) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 805; CHECK-NEXT: ret float [[CALL]] 806; 807 %or.arg1 = or i32 %arg1, -16 808 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 809 ret float %call 810} 811 812define float @ret_ldexp_f32_known_pos_exp_nosub_nozero_daz(float nofpclass(sub zero) %arg0, i32 %arg1) #1 { 813; CHECK-LABEL: define nofpclass(zero sub) float @ret_ldexp_f32_known_pos_exp_nosub_nozero_daz 814; CHECK-SAME: (float nofpclass(zero sub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 815; CHECK-NEXT: [[AND_ARG1:%.*]] = and i32 [[ARG1]], 127 816; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(zero sub) float @llvm.ldexp.f32.i32(float nofpclass(zero sub) [[ARG0]], i32 [[AND_ARG1]]) #[[ATTR10]] 817; CHECK-NEXT: ret float [[CALL]] 818; 819 %and.arg1 = and i32 %arg1, 127 820 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %and.arg1) 821 ret float %call 822} 823 824define float @ret_ldexp_f32_known_neg_exp_nosub_nozero_daz(float nofpclass(sub zero) %arg0, i32 %arg1) #1 { 825; CHECK-LABEL: define float @ret_ldexp_f32_known_neg_exp_nosub_nozero_daz 826; CHECK-SAME: (float nofpclass(zero sub) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR2]] { 827; CHECK-NEXT: [[OR_ARG1:%.*]] = or i32 [[ARG1]], -16 828; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float nofpclass(zero sub) [[ARG0]], i32 [[OR_ARG1]]) #[[ATTR10]] 829; CHECK-NEXT: ret float [[CALL]] 830; 831 %or.arg1 = or i32 %arg1, -16 832 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %or.arg1) 833 ret float %call 834} 835 836define float @ret_ldexp_f32_22(float %arg0) #0 { 837; CHECK-LABEL: define float @ret_ldexp_f32_22 838; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 839; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef 22) #[[ATTR10]] 840; CHECK-NEXT: ret float [[CALL]] 841; 842 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 22) 843 ret float %call 844} 845 846define float @ret_ldexp_f32_23(float %arg0) #0 { 847; CHECK-LABEL: define nofpclass(sub) float @ret_ldexp_f32_23 848; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 849; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef 23) #[[ATTR10]] 850; CHECK-NEXT: ret float [[CALL]] 851; 852 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 23) 853 ret float %call 854} 855 856define float @ret_ldexp_f32_24(float %arg0) #0 { 857; CHECK-LABEL: define nofpclass(sub) float @ret_ldexp_f32_24 858; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 859; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef 24) #[[ATTR10]] 860; CHECK-NEXT: ret float [[CALL]] 861; 862 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 24) 863 ret float %call 864} 865 866define float @ret_ldexp_f32_min24(float %arg0, i32 %arg1) #0 { 867; CHECK-LABEL: define float @ret_ldexp_f32_min24 868; CHECK-SAME: (float [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] { 869; CHECK-NEXT: [[MIN:%.*]] = call i32 @llvm.smin.i32(i32 [[ARG1]], i32 noundef 24) #[[ATTR10]] 870; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 [[MIN]]) #[[ATTR10]] 871; CHECK-NEXT: ret float [[CALL]] 872; 873 %min = call i32 @llvm.smin.i32(i32 %arg1, i32 24) 874 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 %min) 875 ret float %call 876} 877 878define float @ret_ldexp_f32_23_nnan(float nofpclass(nan) %arg0) #0 { 879; CHECK-LABEL: define nofpclass(nan sub) float @ret_ldexp_f32_23_nnan 880; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] { 881; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(nan sub) float @llvm.ldexp.f32.i32(float nofpclass(nan) [[ARG0]], i32 noundef 23) #[[ATTR10]] 882; CHECK-NEXT: ret float [[CALL]] 883; 884 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 23) 885 ret float %call 886} 887 888define double @ret_ldexp_f64_24(double %arg0) #0 { 889; CHECK-LABEL: define double @ret_ldexp_f64_24 890; CHECK-SAME: (double [[ARG0:%.*]]) #[[ATTR1]] { 891; CHECK-NEXT: [[CALL:%.*]] = call double @llvm.ldexp.f64.i32(double [[ARG0]], i32 noundef 24) #[[ATTR10]] 892; CHECK-NEXT: ret double [[CALL]] 893; 894 %call = call double @llvm.ldexp.f64.i32(double %arg0, i32 24) 895 ret double %call 896} 897 898define double @ret_ldexp_f64_51(double %arg0) #0 { 899; CHECK-LABEL: define double @ret_ldexp_f64_51 900; CHECK-SAME: (double [[ARG0:%.*]]) #[[ATTR1]] { 901; CHECK-NEXT: [[CALL:%.*]] = call double @llvm.ldexp.f64.i32(double [[ARG0]], i32 noundef 51) #[[ATTR10]] 902; CHECK-NEXT: ret double [[CALL]] 903; 904 %call = call double @llvm.ldexp.f64.i32(double %arg0, i32 51) 905 ret double %call 906} 907 908define double @ret_ldexp_f64_52(double %arg0) #0 { 909; CHECK-LABEL: define nofpclass(sub) double @ret_ldexp_f64_52 910; CHECK-SAME: (double [[ARG0:%.*]]) #[[ATTR1]] { 911; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) double @llvm.ldexp.f64.i32(double [[ARG0]], i32 noundef 52) #[[ATTR10]] 912; CHECK-NEXT: ret double [[CALL]] 913; 914 %call = call double @llvm.ldexp.f64.i32(double %arg0, i32 52) 915 ret double %call 916} 917 918define double @ret_ldexp_f64_53(double %arg0) #0 { 919; CHECK-LABEL: define nofpclass(sub) double @ret_ldexp_f64_53 920; CHECK-SAME: (double [[ARG0:%.*]]) #[[ATTR1]] { 921; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) double @llvm.ldexp.f64.i32(double [[ARG0]], i32 noundef 53) #[[ATTR10]] 922; CHECK-NEXT: ret double [[CALL]] 923; 924 %call = call double @llvm.ldexp.f64.i32(double %arg0, i32 53) 925 ret double %call 926} 927 928define half @ret_ldexp_f16_8(half %arg0) #0 { 929; CHECK-LABEL: define half @ret_ldexp_f16_8 930; CHECK-SAME: (half [[ARG0:%.*]]) #[[ATTR1]] { 931; CHECK-NEXT: [[CALL:%.*]] = call half @llvm.ldexp.f16.i32(half [[ARG0]], i32 noundef 8) #[[ATTR10]] 932; CHECK-NEXT: ret half [[CALL]] 933; 934 %call = call half @llvm.ldexp.f16.i32(half %arg0, i32 8) 935 ret half %call 936} 937 938define half @ret_ldexp_f16_9(half %arg0) #0 { 939; CHECK-LABEL: define half @ret_ldexp_f16_9 940; CHECK-SAME: (half [[ARG0:%.*]]) #[[ATTR1]] { 941; CHECK-NEXT: [[CALL:%.*]] = call half @llvm.ldexp.f16.i32(half [[ARG0]], i32 noundef 9) #[[ATTR10]] 942; CHECK-NEXT: ret half [[CALL]] 943; 944 %call = call half @llvm.ldexp.f16.i32(half %arg0, i32 9) 945 ret half %call 946} 947 948define half @ret_ldexp_f16_10(half %arg0) #0 { 949; CHECK-LABEL: define nofpclass(sub) half @ret_ldexp_f16_10 950; CHECK-SAME: (half [[ARG0:%.*]]) #[[ATTR1]] { 951; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) half @llvm.ldexp.f16.i32(half [[ARG0]], i32 noundef 10) #[[ATTR10]] 952; CHECK-NEXT: ret half [[CALL]] 953; 954 %call = call half @llvm.ldexp.f16.i32(half %arg0, i32 10) 955 ret half %call 956} 957 958define bfloat @ret_ldexp_bf16_6(bfloat %arg0) #0 { 959; CHECK-LABEL: define bfloat @ret_ldexp_bf16_6 960; CHECK-SAME: (bfloat [[ARG0:%.*]]) #[[ATTR1]] { 961; CHECK-NEXT: [[CALL:%.*]] = call bfloat @llvm.ldexp.bf16.i32(bfloat [[ARG0]], i32 noundef 6) #[[ATTR10]] 962; CHECK-NEXT: ret bfloat [[CALL]] 963; 964 %call = call bfloat @llvm.ldexp.bf16.i32(bfloat %arg0, i32 6) 965 ret bfloat %call 966} 967 968define bfloat @ret_ldexp_bf16_7(bfloat %arg0) #0 { 969; CHECK-LABEL: define nofpclass(sub) bfloat @ret_ldexp_bf16_7 970; CHECK-SAME: (bfloat [[ARG0:%.*]]) #[[ATTR1]] { 971; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) bfloat @llvm.ldexp.bf16.i32(bfloat [[ARG0]], i32 noundef 7) #[[ATTR10]] 972; CHECK-NEXT: ret bfloat [[CALL]] 973; 974 %call = call bfloat @llvm.ldexp.bf16.i32(bfloat %arg0, i32 7) 975 ret bfloat %call 976} 977 978define bfloat @ret_ldexp_bf16_8(bfloat %arg0) #0 { 979; CHECK-LABEL: define nofpclass(sub) bfloat @ret_ldexp_bf16_8 980; CHECK-SAME: (bfloat [[ARG0:%.*]]) #[[ATTR1]] { 981; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(sub) bfloat @llvm.ldexp.bf16.i32(bfloat [[ARG0]], i32 noundef 8) #[[ATTR10]] 982; CHECK-NEXT: ret bfloat [[CALL]] 983; 984 %call = call bfloat @llvm.ldexp.bf16.i32(bfloat %arg0, i32 8) 985 ret bfloat %call 986} 987 988define float @ret_ldexp_f32_neg22(float %arg0) #0 { 989; CHECK-LABEL: define float @ret_ldexp_f32_neg22 990; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 991; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef -22) #[[ATTR10]] 992; CHECK-NEXT: ret float [[CALL]] 993; 994 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 -22) 995 ret float %call 996} 997 998define float @ret_ldexp_f32_neg23(float %arg0) #0 { 999; CHECK-LABEL: define float @ret_ldexp_f32_neg23 1000; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 1001; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef -23) #[[ATTR10]] 1002; CHECK-NEXT: ret float [[CALL]] 1003; 1004 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 -23) 1005 ret float %call 1006} 1007 1008define float @ret_ldexp_f32_neg24(float %arg0) #0 { 1009; CHECK-LABEL: define float @ret_ldexp_f32_neg24 1010; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 1011; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef -24) #[[ATTR10]] 1012; CHECK-NEXT: ret float [[CALL]] 1013; 1014 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 -24) 1015 ret float %call 1016} 1017 1018define float @ret_ldexp_f32_neg126(float %arg0) #0 { 1019; CHECK-LABEL: define float @ret_ldexp_f32_neg126 1020; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 1021; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef -126) #[[ATTR10]] 1022; CHECK-NEXT: ret float [[CALL]] 1023; 1024 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 -126) 1025 ret float %call 1026} 1027 1028define float @ret_ldexp_f32_neg127(float %arg0) #0 { 1029; CHECK-LABEL: define float @ret_ldexp_f32_neg127 1030; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1]] { 1031; CHECK-NEXT: [[CALL:%.*]] = call float @llvm.ldexp.f32.i32(float [[ARG0]], i32 noundef -127) #[[ATTR10]] 1032; CHECK-NEXT: ret float [[CALL]] 1033; 1034 %call = call float @llvm.ldexp.f32.i32(float %arg0, i32 -127) 1035 ret float %call 1036} 1037 1038attributes #0 = { "denormal-fp-math"="ieee,ieee" } 1039attributes #1 = { "denormal-fp-math"="preserve-sign,preserve-sign" } 1040attributes #2 = { "denormal-fp-math"="positive-zero,positive-zero" } 1041attributes #3 = { "denormal-fp-math"="preserve-sign,ieee" } 1042attributes #4 = { "denormal-fp-math"="ieee,dynamic" } 1043attributes #5 = { "denormal-fp-math"="ieee,preserve-sign" } 1044attributes #6 = { "denormal-fp-math"="dynamic,preserve-sign" } 1045attributes #7 = { "denormal-fp-math"="dynamic,positive-zero" } 1046attributes #8 = { "denormal-fp-math"="positive-zero,dynamic" } 1047 1048;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: 1049; TUNIT: {{.*}} 1050