1; RUN: llc -mtriple=arm-eabi -float-abi=soft -mcpu=cortex-a9 %s -o - | FileCheck %s 2 3@A = global <4 x float> <float 0., float 1., float 2., float 3.> 4 5define void @test_sqrt(ptr %X) nounwind { 6 7; CHECK-LABEL: test_sqrt: 8 9; CHECK: movw r1, :lower16:{{.*}} 10; CHECK: movt r1, :upper16:{{.*}} 11; CHECK: vld1.64 {{.*}}, [r1:128] 12; CHECK: vsqrt.f32 {{s[0-9]+}}, {{s[0-9]+}} 13; CHECK: vsqrt.f32 {{s[0-9]+}}, {{s[0-9]+}} 14; CHECK: vsqrt.f32 {{s[0-9]+}}, {{s[0-9]+}} 15; CHECK: vsqrt.f32 {{s[0-9]+}}, {{s[0-9]+}} 16; CHECK: vst1.64 {{.*}} 17 18L.entry: 19 %0 = load <4 x float>, ptr @A, align 16 20 %1 = call <4 x float> @llvm.sqrt.v4f32(<4 x float> %0) 21 store <4 x float> %1, ptr %X, align 16 22 ret void 23} 24 25declare <4 x float> @llvm.sqrt.v4f32(<4 x float>) nounwind readonly 26 27 28define void @test_cos(ptr %X) nounwind { 29 30; CHECK-LABEL: test_cos: 31 32; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 33; CHECK: movt [[reg0]], :upper16:{{.*}} 34; CHECK: vld1.64 35 36; CHECK: {{v?mov(.32)?}} r0, 37; CHECK: bl {{.*}}cosf 38 39; CHECK: {{v?mov(.32)?}} r0, 40; CHECK: bl {{.*}}cosf 41 42; CHECK: {{v?mov(.32)?}} r0, 43; CHECK: bl {{.*}}cosf 44 45; CHECK: {{v?mov(.32)?}} r0, 46; CHECK: bl {{.*}}cosf 47 48; CHECK: vst1.64 49 50L.entry: 51 %0 = load <4 x float>, ptr @A, align 16 52 %1 = call <4 x float> @llvm.cos.v4f32(<4 x float> %0) 53 store <4 x float> %1, ptr %X, align 16 54 ret void 55} 56 57declare <4 x float> @llvm.cos.v4f32(<4 x float>) nounwind readonly 58 59define void @test_tan(ptr %X) nounwind { 60 61; CHECK-LABEL: test_tan: 62 63; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 64; CHECK: movt [[reg0]], :upper16:{{.*}} 65; CHECK: vld1.64 66 67; CHECK: {{v?mov(.32)?}} r0, 68; CHECK: bl {{.*}}tanf 69 70; CHECK: {{v?mov(.32)?}} r0, 71; CHECK: bl {{.*}}tanf 72 73; CHECK: {{v?mov(.32)?}} r0, 74; CHECK: bl {{.*}}tanf 75 76; CHECK: {{v?mov(.32)?}} r0, 77; CHECK: bl {{.*}}tanf 78 79; CHECK: vst1.64 80 81L.entry: 82 %0 = load <4 x float>, ptr @A, align 16 83 %1 = call <4 x float> @llvm.tan.v4f32(<4 x float> %0) 84 store <4 x float> %1, ptr %X, align 16 85 ret void 86} 87 88declare <4 x float> @llvm.tan.v4f32(<4 x float>) nounwind readonly 89 90define void @test_exp(ptr %X) nounwind { 91 92; CHECK-LABEL: test_exp: 93 94; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 95; CHECK: movt [[reg0]], :upper16:{{.*}} 96; CHECK: vld1.64 97 98; CHECK: {{v?mov(.32)?}} r0, 99; CHECK: bl {{.*}}expf 100 101; CHECK: {{v?mov(.32)?}} r0, 102; CHECK: bl {{.*}}expf 103 104; CHECK: {{v?mov(.32)?}} r0, 105; CHECK: bl {{.*}}expf 106 107; CHECK: {{v?mov(.32)?}} r0, 108; CHECK: bl {{.*}}expf 109 110; CHECK: vst1.64 111 112L.entry: 113 %0 = load <4 x float>, ptr @A, align 16 114 %1 = call <4 x float> @llvm.exp.v4f32(<4 x float> %0) 115 store <4 x float> %1, ptr %X, align 16 116 ret void 117} 118 119declare <4 x float> @llvm.exp.v4f32(<4 x float>) nounwind readonly 120 121define void @test_exp2(ptr %X) nounwind { 122 123; CHECK-LABEL: test_exp2: 124 125; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 126; CHECK: movt [[reg0]], :upper16:{{.*}} 127; CHECK: vld1.64 128 129; CHECK: {{v?mov(.32)?}} r0, 130; CHECK: bl {{.*}}exp2f 131 132; CHECK: {{v?mov(.32)?}} r0, 133; CHECK: bl {{.*}}exp2f 134 135; CHECK: {{v?mov(.32)?}} r0, 136; CHECK: bl {{.*}}exp2f 137 138; CHECK: {{v?mov(.32)?}} r0, 139; CHECK: bl {{.*}}exp2f 140 141; CHECK: vst1.64 142 143L.entry: 144 %0 = load <4 x float>, ptr @A, align 16 145 %1 = call <4 x float> @llvm.exp2.v4f32(<4 x float> %0) 146 store <4 x float> %1, ptr %X, align 16 147 ret void 148} 149 150declare <4 x float> @llvm.exp2.v4f32(<4 x float>) nounwind readonly 151 152define void @test_log10(ptr %X) nounwind { 153 154; CHECK-LABEL: test_log10: 155 156; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 157; CHECK: movt [[reg0]], :upper16:{{.*}} 158; CHECK: vld1.64 159 160; CHECK: {{v?mov(.32)?}} r0, 161; CHECK: bl {{.*}}log10f 162 163; CHECK: {{v?mov(.32)?}} r0, 164; CHECK: bl {{.*}}log10f 165 166; CHECK: {{v?mov(.32)?}} r0, 167; CHECK: bl {{.*}}log10f 168 169; CHECK: {{v?mov(.32)?}} r0, 170; CHECK: bl {{.*}}log10f 171 172; CHECK: vst1.64 173 174L.entry: 175 %0 = load <4 x float>, ptr @A, align 16 176 %1 = call <4 x float> @llvm.log10.v4f32(<4 x float> %0) 177 store <4 x float> %1, ptr %X, align 16 178 ret void 179} 180 181declare <4 x float> @llvm.log10.v4f32(<4 x float>) nounwind readonly 182 183define void @test_log(ptr %X) nounwind { 184 185; CHECK-LABEL: test_log: 186 187; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 188; CHECK: movt [[reg0]], :upper16:{{.*}} 189; CHECK: vld1.64 190 191; CHECK: {{v?mov(.32)?}} r0, 192; CHECK: bl {{.*}}logf 193 194; CHECK: {{v?mov(.32)?}} r0, 195; CHECK: bl {{.*}}logf 196 197; CHECK: {{v?mov(.32)?}} r0, 198; CHECK: bl {{.*}}logf 199 200; CHECK: {{v?mov(.32)?}} r0, 201; CHECK: bl {{.*}}logf 202 203; CHECK: vst1.64 204 205L.entry: 206 %0 = load <4 x float>, ptr @A, align 16 207 %1 = call <4 x float> @llvm.log.v4f32(<4 x float> %0) 208 store <4 x float> %1, ptr %X, align 16 209 ret void 210} 211 212declare <4 x float> @llvm.log.v4f32(<4 x float>) nounwind readonly 213 214define void @test_log2(ptr %X) nounwind { 215 216; CHECK-LABEL: test_log2: 217 218; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 219; CHECK: movt [[reg0]], :upper16:{{.*}} 220; CHECK: vld1.64 221 222; CHECK: {{v?mov(.32)?}} r0, 223; CHECK: bl {{.*}}log2f 224 225; CHECK: {{v?mov(.32)?}} r0, 226; CHECK: bl {{.*}}log2f 227 228; CHECK: {{v?mov(.32)?}} r0, 229; CHECK: bl {{.*}}log2f 230 231; CHECK: {{v?mov(.32)?}} r0, 232; CHECK: bl {{.*}}log2f 233 234; CHECK: vst1.64 235 236L.entry: 237 %0 = load <4 x float>, ptr @A, align 16 238 %1 = call <4 x float> @llvm.log2.v4f32(<4 x float> %0) 239 store <4 x float> %1, ptr %X, align 16 240 ret void 241} 242 243declare <4 x float> @llvm.log2.v4f32(<4 x float>) nounwind readonly 244 245 246define void @test_pow(ptr %X) nounwind { 247 248; CHECK-LABEL: test_pow: 249 250; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 251; CHECK: movt [[reg0]], :upper16:{{.*}} 252; CHECK: vld1.64 253 254; CHECK: {{v?mov(.32)?}} r0, 255; CHECK: bl {{.*}}powf 256 257; CHECK: {{v?mov(.32)?}} r0, 258; CHECK: bl {{.*}}powf 259 260; CHECK: {{v?mov(.32)?}} r0, 261; CHECK: bl {{.*}}powf 262 263; CHECK: {{v?mov(.32)?}} r0, 264; CHECK: bl {{.*}}powf 265 266; CHECK: vst1.64 267 268L.entry: 269 270 %0 = load <4 x float>, ptr @A, align 16 271 %1 = call <4 x float> @llvm.pow.v4f32(<4 x float> %0, <4 x float> <float 2., float 2., float 2., float 2.>) 272 273 store <4 x float> %1, ptr %X, align 16 274 275 ret void 276} 277 278declare <4 x float> @llvm.pow.v4f32(<4 x float>, <4 x float>) nounwind readonly 279 280define void @test_powi(ptr %X) nounwind { 281 282; CHECK-LABEL: test_powi: 283 284; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 285; CHECK: movt [[reg0]], :upper16:{{.*}} 286; CHECK: vld1.64 {{.*}}:128 287; CHECK: vmul.f32 {{.*}} 288 289; CHECK: vst1.64 290 291L.entry: 292 293 %0 = load <4 x float>, ptr @A, align 16 294 %1 = call <4 x float> @llvm.powi.v4f32.i32(<4 x float> %0, i32 2) 295 296 store <4 x float> %1, ptr %X, align 16 297 298 ret void 299} 300 301declare <4 x float> @llvm.powi.v4f32.i32(<4 x float>, i32) nounwind readonly 302 303define void @test_sin(ptr %X) nounwind { 304 305; CHECK-LABEL: test_sin: 306 307; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 308; CHECK: movt [[reg0]], :upper16:{{.*}} 309; CHECK: vld1.64 310 311; CHECK: {{v?mov(.32)?}} r0, 312; CHECK: bl {{.*}}sinf 313 314; CHECK: {{v?mov(.32)?}} r0, 315; CHECK: bl {{.*}}sinf 316 317; CHECK: {{v?mov(.32)?}} r0, 318; CHECK: bl {{.*}}sinf 319 320; CHECK: {{v?mov(.32)?}} r0, 321; CHECK: bl {{.*}}sinf 322 323; CHECK: vst1.64 324 325L.entry: 326 %0 = load <4 x float>, ptr @A, align 16 327 %1 = call <4 x float> @llvm.sin.v4f32(<4 x float> %0) 328 store <4 x float> %1, ptr %X, align 16 329 ret void 330} 331 332declare <4 x float> @llvm.sin.v4f32(<4 x float>) nounwind readonly 333 334define void @test_floor(ptr %X) nounwind { 335 336; CHECK-LABEL: test_floor: 337 338; CHECK: movw [[reg0:r[0-9]+]], :lower16:{{.*}} 339; CHECK: movt [[reg0]], :upper16:{{.*}} 340; CHECK: vld1.64 341 342; CHECK: {{v?mov(.32)?}} r0, 343; CHECK: bl {{.*}}floorf 344 345; CHECK: {{v?mov(.32)?}} r0, 346; CHECK: bl {{.*}}floorf 347 348; CHECK: {{v?mov(.32)?}} r0, 349; CHECK: bl {{.*}}floorf 350 351; CHECK: {{v?mov(.32)?}} r0, 352; CHECK: bl {{.*}}floorf 353 354; CHECK: vst1.64 355 356L.entry: 357 %0 = load <4 x float>, ptr @A, align 16 358 %1 = call <4 x float> @llvm.floor.v4f32(<4 x float> %0) 359 store <4 x float> %1, ptr %X, align 16 360 ret void 361} 362 363declare <4 x float> @llvm.floor.v4f32(<4 x float>) nounwind readonly 364 365