1; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py 2; RUN: llc -mtriple=arm64-linux-gnu -verify-machineinstrs < %s | FileCheck %s --check-prefixes=CHECK,CHECK-SD 3; RUN: llc -mtriple=arm64-linux-gnu -verify-machineinstrs -global-isel -global-isel-abort=2 < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-GI 4 5; CHECK-GI: warning: Instruction selection used fallback path for test_neg_sub 6 7define fp128 @test_add(fp128 %lhs, fp128 %rhs) { 8; CHECK-LABEL: test_add: 9; CHECK: // %bb.0: 10; CHECK-NEXT: b __addtf3 11 %val = fadd fp128 %lhs, %rhs 12 ret fp128 %val 13} 14 15define fp128 @test_sub(fp128 %lhs, fp128 %rhs) { 16; CHECK-LABEL: test_sub: 17; CHECK: // %bb.0: 18; CHECK-NEXT: b __subtf3 19 %val = fsub fp128 %lhs, %rhs 20 ret fp128 %val 21} 22 23define fp128 @test_mul(fp128 %lhs, fp128 %rhs) { 24; CHECK-LABEL: test_mul: 25; CHECK: // %bb.0: 26; CHECK-NEXT: b __multf3 27 %val = fmul fp128 %lhs, %rhs 28 ret fp128 %val 29} 30 31define fp128 @test_div(fp128 %lhs, fp128 %rhs) { 32; CHECK-LABEL: test_div: 33; CHECK: // %bb.0: 34; CHECK-NEXT: b __divtf3 35 %val = fdiv fp128 %lhs, %rhs 36 ret fp128 %val 37} 38 39define i32 @test_fptosi_32(fp128 %val) { 40; CHECK-SD-LABEL: test_fptosi_32: 41; CHECK-SD: // %bb.0: 42; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 43; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 44; CHECK-SD-NEXT: .cfi_offset w30, -16 45; CHECK-SD-NEXT: bl __fixtfsi 46; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 47; CHECK-SD-NEXT: ret 48; 49; CHECK-GI-LABEL: test_fptosi_32: 50; CHECK-GI: // %bb.0: 51; CHECK-GI-NEXT: b __fixtfsi 52 %val32 = fptosi fp128 %val to i32 53 ret i32 %val32 54} 55 56define i64 @test_fptosi_64(fp128 %val) { 57; CHECK-SD-LABEL: test_fptosi_64: 58; CHECK-SD: // %bb.0: 59; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 60; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 61; CHECK-SD-NEXT: .cfi_offset w30, -16 62; CHECK-SD-NEXT: bl __fixtfdi 63; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 64; CHECK-SD-NEXT: ret 65; 66; CHECK-GI-LABEL: test_fptosi_64: 67; CHECK-GI: // %bb.0: 68; CHECK-GI-NEXT: b __fixtfdi 69 %val64 = fptosi fp128 %val to i64 70 ret i64 %val64 71} 72 73define i32 @test_fptoui_32(fp128 %val) { 74; CHECK-SD-LABEL: test_fptoui_32: 75; CHECK-SD: // %bb.0: 76; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 77; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 78; CHECK-SD-NEXT: .cfi_offset w30, -16 79; CHECK-SD-NEXT: bl __fixunstfsi 80; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 81; CHECK-SD-NEXT: ret 82; 83; CHECK-GI-LABEL: test_fptoui_32: 84; CHECK-GI: // %bb.0: 85; CHECK-GI-NEXT: b __fixunstfsi 86 %val32 = fptoui fp128 %val to i32 87 ret i32 %val32 88} 89 90define i64 @test_fptoui_64(fp128 %val) { 91; CHECK-SD-LABEL: test_fptoui_64: 92; CHECK-SD: // %bb.0: 93; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 94; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 95; CHECK-SD-NEXT: .cfi_offset w30, -16 96; CHECK-SD-NEXT: bl __fixunstfdi 97; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 98; CHECK-SD-NEXT: ret 99; 100; CHECK-GI-LABEL: test_fptoui_64: 101; CHECK-GI: // %bb.0: 102; CHECK-GI-NEXT: b __fixunstfdi 103 %val64 = fptoui fp128 %val to i64 104 ret i64 %val64 105} 106 107define fp128 @test_sitofp_32(i32 %src32) { 108; CHECK-SD-LABEL: test_sitofp_32: 109; CHECK-SD: // %bb.0: 110; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 111; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 112; CHECK-SD-NEXT: .cfi_offset w30, -16 113; CHECK-SD-NEXT: bl __floatsitf 114; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 115; CHECK-SD-NEXT: ret 116; 117; CHECK-GI-LABEL: test_sitofp_32: 118; CHECK-GI: // %bb.0: 119; CHECK-GI-NEXT: b __floatsitf 120 %val32 = sitofp i32 %src32 to fp128 121 ret fp128 %val32 122} 123 124define fp128 @test_sitofp_64(i64 %src64) { 125; CHECK-SD-LABEL: test_sitofp_64: 126; CHECK-SD: // %bb.0: 127; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 128; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 129; CHECK-SD-NEXT: .cfi_offset w30, -16 130; CHECK-SD-NEXT: bl __floatditf 131; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 132; CHECK-SD-NEXT: ret 133; 134; CHECK-GI-LABEL: test_sitofp_64: 135; CHECK-GI: // %bb.0: 136; CHECK-GI-NEXT: b __floatditf 137 %val64 = sitofp i64 %src64 to fp128 138 ret fp128 %val64 139} 140 141define fp128 @test_uitofp_32(i32 %src32) { 142; CHECK-SD-LABEL: test_uitofp_32: 143; CHECK-SD: // %bb.0: 144; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 145; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 146; CHECK-SD-NEXT: .cfi_offset w30, -16 147; CHECK-SD-NEXT: bl __floatunsitf 148; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 149; CHECK-SD-NEXT: ret 150; 151; CHECK-GI-LABEL: test_uitofp_32: 152; CHECK-GI: // %bb.0: 153; CHECK-GI-NEXT: b __floatunsitf 154 %val32 = uitofp i32 %src32 to fp128 155 ret fp128 %val32 156} 157 158define fp128 @test_uitofp_64(i64 %src64) { 159; CHECK-SD-LABEL: test_uitofp_64: 160; CHECK-SD: // %bb.0: 161; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 162; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 163; CHECK-SD-NEXT: .cfi_offset w30, -16 164; CHECK-SD-NEXT: bl __floatunditf 165; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 166; CHECK-SD-NEXT: ret 167; 168; CHECK-GI-LABEL: test_uitofp_64: 169; CHECK-GI: // %bb.0: 170; CHECK-GI-NEXT: b __floatunditf 171 %val64 = uitofp i64 %src64 to fp128 172 ret fp128 %val64 173} 174 175; Technically, everything after the call to __letf2 is redundant, but we'll let 176; LLVM have its fun for now. 177define i1 @test_setcc1(fp128 %lhs, fp128 %rhs) { 178; CHECK-LABEL: test_setcc1: 179; CHECK: // %bb.0: 180; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 181; CHECK-NEXT: .cfi_def_cfa_offset 16 182; CHECK-NEXT: .cfi_offset w30, -16 183; CHECK-NEXT: bl __letf2 184; CHECK-NEXT: cmp w0, #0 185; CHECK-NEXT: cset w0, le 186; CHECK-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 187; CHECK-NEXT: ret 188 %val = fcmp ole fp128 %lhs, %rhs 189 ret i1 %val 190} 191 192define i1 @test_setcc2(fp128 %lhs, fp128 %rhs) { 193; CHECK-LABEL: test_setcc2: 194; CHECK: // %bb.0: 195; CHECK-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 196; CHECK-NEXT: .cfi_def_cfa_offset 16 197; CHECK-NEXT: .cfi_offset w30, -16 198; CHECK-NEXT: bl __letf2 199; CHECK-NEXT: cmp w0, #0 200; CHECK-NEXT: cset w0, gt 201; CHECK-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 202; CHECK-NEXT: ret 203 %val = fcmp ugt fp128 %lhs, %rhs 204 ret i1 %val 205} 206 207define i1 @test_setcc3(fp128 %lhs, fp128 %rhs) { 208; CHECK-SD-LABEL: test_setcc3: 209; CHECK-SD: // %bb.0: 210; CHECK-SD-NEXT: sub sp, sp, #48 211; CHECK-SD-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill 212; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 213; CHECK-SD-NEXT: .cfi_offset w19, -8 214; CHECK-SD-NEXT: .cfi_offset w30, -16 215; CHECK-SD-NEXT: stp q0, q1, [sp] // 32-byte Folded Spill 216; CHECK-SD-NEXT: bl __eqtf2 217; CHECK-SD-NEXT: ldp q0, q1, [sp] // 32-byte Folded Reload 218; CHECK-SD-NEXT: mov w19, w0 219; CHECK-SD-NEXT: bl __unordtf2 220; CHECK-SD-NEXT: cmp w0, #0 221; CHECK-SD-NEXT: ccmp w19, #0, #4, eq 222; CHECK-SD-NEXT: ldp x30, x19, [sp, #32] // 16-byte Folded Reload 223; CHECK-SD-NEXT: cset w0, eq 224; CHECK-SD-NEXT: add sp, sp, #48 225; CHECK-SD-NEXT: ret 226; 227; CHECK-GI-LABEL: test_setcc3: 228; CHECK-GI: // %bb.0: 229; CHECK-GI-NEXT: sub sp, sp, #48 230; CHECK-GI-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill 231; CHECK-GI-NEXT: .cfi_def_cfa_offset 48 232; CHECK-GI-NEXT: .cfi_offset w19, -8 233; CHECK-GI-NEXT: .cfi_offset w30, -16 234; CHECK-GI-NEXT: stp q1, q0, [sp] // 32-byte Folded Spill 235; CHECK-GI-NEXT: bl __eqtf2 236; CHECK-GI-NEXT: ldp q1, q0, [sp] // 32-byte Folded Reload 237; CHECK-GI-NEXT: cmp w0, #0 238; CHECK-GI-NEXT: cset w19, eq 239; CHECK-GI-NEXT: bl __unordtf2 240; CHECK-GI-NEXT: cmp w0, #0 241; CHECK-GI-NEXT: cset w8, ne 242; CHECK-GI-NEXT: orr w0, w19, w8 243; CHECK-GI-NEXT: ldp x30, x19, [sp, #32] // 16-byte Folded Reload 244; CHECK-GI-NEXT: add sp, sp, #48 245; CHECK-GI-NEXT: ret 246 %val = fcmp ueq fp128 %lhs, %rhs 247 ret i1 %val 248} 249 250; olt == !uge, which LLVM optimizes this to. 251define i32 @test_br_cc(fp128 %lhs, fp128 %rhs) { 252; CHECK-SD-LABEL: test_br_cc: 253; CHECK-SD: // %bb.0: // %common.ret 254; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 255; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 256; CHECK-SD-NEXT: .cfi_offset w30, -16 257; CHECK-SD-NEXT: bl __lttf2 258; CHECK-SD-NEXT: mov w8, #29 // =0x1d 259; CHECK-SD-NEXT: cmp w0, #0 260; CHECK-SD-NEXT: mov w9, #42 // =0x2a 261; CHECK-SD-NEXT: csel w0, w9, w8, lt 262; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 263; CHECK-SD-NEXT: ret 264; 265; CHECK-GI-LABEL: test_br_cc: 266; CHECK-GI: // %bb.0: // %common.ret 267; CHECK-GI-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 268; CHECK-GI-NEXT: .cfi_def_cfa_offset 16 269; CHECK-GI-NEXT: .cfi_offset w30, -16 270; CHECK-GI-NEXT: bl __lttf2 271; CHECK-GI-NEXT: mov w8, #29 // =0x1d 272; CHECK-GI-NEXT: mov w9, #42 // =0x2a 273; CHECK-GI-NEXT: cmp w0, #0 274; CHECK-GI-NEXT: csel w0, w9, w8, lt 275; CHECK-GI-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 276; CHECK-GI-NEXT: ret 277 %cond = fcmp olt fp128 %lhs, %rhs 278 br i1 %cond, label %iftrue, label %iffalse 279 280iftrue: 281 ret i32 42 282iffalse: 283 ret i32 29 284} 285 286define fp128 @test_select(i1 %cond, fp128 %lhs, fp128 %rhs) { 287; CHECK-SD-LABEL: test_select: 288; CHECK-SD: // %bb.0: 289; CHECK-SD-NEXT: tst w0, #0x1 290; CHECK-SD-NEXT: b.eq .LBB16_2 291; CHECK-SD-NEXT: // %bb.1: 292; CHECK-SD-NEXT: mov v1.16b, v0.16b 293; CHECK-SD-NEXT: .LBB16_2: 294; CHECK-SD-NEXT: mov v0.16b, v1.16b 295; CHECK-SD-NEXT: ret 296; 297; CHECK-GI-LABEL: test_select: 298; CHECK-GI: // %bb.0: 299; CHECK-GI-NEXT: and w8, w0, #0x1 300; CHECK-GI-NEXT: mov d2, v0.d[1] 301; CHECK-GI-NEXT: mov d3, v1.d[1] 302; CHECK-GI-NEXT: tst w8, #0x1 303; CHECK-GI-NEXT: fcsel d0, d0, d1, ne 304; CHECK-GI-NEXT: fcsel d1, d2, d3, ne 305; CHECK-GI-NEXT: fmov x8, d0 306; CHECK-GI-NEXT: mov v0.d[0], x8 307; CHECK-GI-NEXT: fmov x8, d1 308; CHECK-GI-NEXT: mov v0.d[1], x8 309; CHECK-GI-NEXT: ret 310 %val = select i1 %cond, fp128 %lhs, fp128 %rhs 311 ret fp128 %val 312} 313 314define half @test_round_f16(fp128 %val) { 315; CHECK-SD-LABEL: test_round_f16: 316; CHECK-SD: // %bb.0: 317; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 318; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 319; CHECK-SD-NEXT: .cfi_offset w30, -16 320; CHECK-SD-NEXT: bl __trunctfhf2 321; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 322; CHECK-SD-NEXT: ret 323; 324; CHECK-GI-LABEL: test_round_f16: 325; CHECK-GI: // %bb.0: 326; CHECK-GI-NEXT: b __trunctfhf2 327 %dst = fptrunc fp128 %val to half 328 ret half %dst 329} 330 331define float @test_round_f32(fp128 %val) { 332; CHECK-SD-LABEL: test_round_f32: 333; CHECK-SD: // %bb.0: 334; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 335; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 336; CHECK-SD-NEXT: .cfi_offset w30, -16 337; CHECK-SD-NEXT: bl __trunctfsf2 338; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 339; CHECK-SD-NEXT: ret 340; 341; CHECK-GI-LABEL: test_round_f32: 342; CHECK-GI: // %bb.0: 343; CHECK-GI-NEXT: b __trunctfsf2 344 %dst = fptrunc fp128 %val to float 345 ret float %dst 346} 347 348define double @test_round_f64(fp128 %val) { 349; CHECK-SD-LABEL: test_round_f64: 350; CHECK-SD: // %bb.0: 351; CHECK-SD-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill 352; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 353; CHECK-SD-NEXT: .cfi_offset w30, -16 354; CHECK-SD-NEXT: bl __trunctfdf2 355; CHECK-SD-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload 356; CHECK-SD-NEXT: ret 357; 358; CHECK-GI-LABEL: test_round_f64: 359; CHECK-GI: // %bb.0: 360; CHECK-GI-NEXT: b __trunctfdf2 361 %dst = fptrunc fp128 %val to double 362 ret double %dst 363} 364 365define fp128 @test_extend_f16(half %val) { 366; CHECK-LABEL: test_extend_f16: 367; CHECK: // %bb.0: 368; CHECK-NEXT: b __extendhftf2 369 %dst = fpext half %val to fp128 370 ret fp128 %dst 371} 372 373define fp128 @test_extend_f32(float %val) { 374; CHECK-LABEL: test_extend_f32: 375; CHECK: // %bb.0: 376; CHECK-NEXT: b __extendsftf2 377 %dst = fpext float %val to fp128 378 ret fp128 %dst 379} 380 381define fp128 @test_extend_f64(double %val) { 382; CHECK-LABEL: test_extend_f64: 383; CHECK: // %bb.0: 384; CHECK-NEXT: b __extenddftf2 385 %dst = fpext double %val to fp128 386 ret fp128 %dst 387} 388 389;; We convert this to fneg, and target-independent code expands it with 390;; integer operations. 391define fp128 @test_neg_sub(fp128 %in) { 392; CHECK-LABEL: test_neg_sub: 393; CHECK: // %bb.0: 394; CHECK-NEXT: str q0, [sp, #-16]! 395; CHECK-NEXT: .cfi_def_cfa_offset 16 396; CHECK-NEXT: ldrb w8, [sp, #15] 397; CHECK-NEXT: eor w8, w8, #0x80 398; CHECK-NEXT: strb w8, [sp, #15] 399; CHECK-NEXT: ldr q0, [sp], #16 400; CHECK-NEXT: ret 401 %ret = fsub fp128 0xL00000000000000008000000000000000, %in 402 ret fp128 %ret 403} 404 405define fp128 @test_neg(fp128 %in) { 406; CHECK-SD-LABEL: test_neg: 407; CHECK-SD: // %bb.0: 408; CHECK-SD-NEXT: str q0, [sp, #-16]! 409; CHECK-SD-NEXT: .cfi_def_cfa_offset 16 410; CHECK-SD-NEXT: ldrb w8, [sp, #15] 411; CHECK-SD-NEXT: eor w8, w8, #0x80 412; CHECK-SD-NEXT: strb w8, [sp, #15] 413; CHECK-SD-NEXT: ldr q0, [sp], #16 414; CHECK-SD-NEXT: ret 415; 416; CHECK-GI-LABEL: test_neg: 417; CHECK-GI: // %bb.0: 418; CHECK-GI-NEXT: mov x8, v0.d[1] 419; CHECK-GI-NEXT: mov v0.d[0], v0.d[0] 420; CHECK-GI-NEXT: eor x8, x8, #0x8000000000000000 421; CHECK-GI-NEXT: mov v0.d[1], x8 422; CHECK-GI-NEXT: ret 423 %ret = fneg fp128 %in 424 ret fp128 %ret 425} 426 427 428 429define <2 x fp128> @vec_add(<2 x fp128> %lhs, <2 x fp128> %rhs) { 430; CHECK-SD-LABEL: vec_add: 431; CHECK-SD: // %bb.0: 432; CHECK-SD-NEXT: sub sp, sp, #64 433; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 434; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 435; CHECK-SD-NEXT: .cfi_offset w30, -16 436; CHECK-SD-NEXT: stp q1, q3, [sp, #16] // 32-byte Folded Spill 437; CHECK-SD-NEXT: mov v1.16b, v2.16b 438; CHECK-SD-NEXT: bl __addtf3 439; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 440; CHECK-SD-NEXT: ldp q0, q1, [sp, #16] // 32-byte Folded Reload 441; CHECK-SD-NEXT: bl __addtf3 442; CHECK-SD-NEXT: mov v1.16b, v0.16b 443; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 444; CHECK-SD-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 445; CHECK-SD-NEXT: add sp, sp, #64 446; CHECK-SD-NEXT: ret 447; 448; CHECK-GI-LABEL: vec_add: 449; CHECK-GI: // %bb.0: 450; CHECK-GI-NEXT: sub sp, sp, #64 451; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 452; CHECK-GI-NEXT: .cfi_def_cfa_offset 64 453; CHECK-GI-NEXT: .cfi_offset w30, -16 454; CHECK-GI-NEXT: stp q3, q1, [sp, #16] // 32-byte Folded Spill 455; CHECK-GI-NEXT: mov v1.16b, v2.16b 456; CHECK-GI-NEXT: bl __addtf3 457; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 458; CHECK-GI-NEXT: ldp q1, q0, [sp, #16] // 32-byte Folded Reload 459; CHECK-GI-NEXT: bl __addtf3 460; CHECK-GI-NEXT: mov v1.16b, v0.16b 461; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 462; CHECK-GI-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 463; CHECK-GI-NEXT: add sp, sp, #64 464; CHECK-GI-NEXT: ret 465 %val = fadd <2 x fp128> %lhs, %rhs 466 ret <2 x fp128> %val 467} 468 469define <2 x fp128> @vec_sub(<2 x fp128> %lhs, <2 x fp128> %rhs) { 470; CHECK-SD-LABEL: vec_sub: 471; CHECK-SD: // %bb.0: 472; CHECK-SD-NEXT: sub sp, sp, #64 473; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 474; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 475; CHECK-SD-NEXT: .cfi_offset w30, -16 476; CHECK-SD-NEXT: stp q1, q3, [sp, #16] // 32-byte Folded Spill 477; CHECK-SD-NEXT: mov v1.16b, v2.16b 478; CHECK-SD-NEXT: bl __subtf3 479; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 480; CHECK-SD-NEXT: ldp q0, q1, [sp, #16] // 32-byte Folded Reload 481; CHECK-SD-NEXT: bl __subtf3 482; CHECK-SD-NEXT: mov v1.16b, v0.16b 483; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 484; CHECK-SD-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 485; CHECK-SD-NEXT: add sp, sp, #64 486; CHECK-SD-NEXT: ret 487; 488; CHECK-GI-LABEL: vec_sub: 489; CHECK-GI: // %bb.0: 490; CHECK-GI-NEXT: sub sp, sp, #64 491; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 492; CHECK-GI-NEXT: .cfi_def_cfa_offset 64 493; CHECK-GI-NEXT: .cfi_offset w30, -16 494; CHECK-GI-NEXT: stp q3, q1, [sp, #16] // 32-byte Folded Spill 495; CHECK-GI-NEXT: mov v1.16b, v2.16b 496; CHECK-GI-NEXT: bl __subtf3 497; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 498; CHECK-GI-NEXT: ldp q1, q0, [sp, #16] // 32-byte Folded Reload 499; CHECK-GI-NEXT: bl __subtf3 500; CHECK-GI-NEXT: mov v1.16b, v0.16b 501; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 502; CHECK-GI-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 503; CHECK-GI-NEXT: add sp, sp, #64 504; CHECK-GI-NEXT: ret 505 %val = fsub <2 x fp128> %lhs, %rhs 506 ret <2 x fp128> %val 507} 508 509define <2 x fp128> @vec_mul(<2 x fp128> %lhs, <2 x fp128> %rhs) { 510; CHECK-SD-LABEL: vec_mul: 511; CHECK-SD: // %bb.0: 512; CHECK-SD-NEXT: sub sp, sp, #64 513; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 514; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 515; CHECK-SD-NEXT: .cfi_offset w30, -16 516; CHECK-SD-NEXT: stp q1, q3, [sp, #16] // 32-byte Folded Spill 517; CHECK-SD-NEXT: mov v1.16b, v2.16b 518; CHECK-SD-NEXT: bl __multf3 519; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 520; CHECK-SD-NEXT: ldp q0, q1, [sp, #16] // 32-byte Folded Reload 521; CHECK-SD-NEXT: bl __multf3 522; CHECK-SD-NEXT: mov v1.16b, v0.16b 523; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 524; CHECK-SD-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 525; CHECK-SD-NEXT: add sp, sp, #64 526; CHECK-SD-NEXT: ret 527; 528; CHECK-GI-LABEL: vec_mul: 529; CHECK-GI: // %bb.0: 530; CHECK-GI-NEXT: sub sp, sp, #64 531; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 532; CHECK-GI-NEXT: .cfi_def_cfa_offset 64 533; CHECK-GI-NEXT: .cfi_offset w30, -16 534; CHECK-GI-NEXT: stp q3, q1, [sp, #16] // 32-byte Folded Spill 535; CHECK-GI-NEXT: mov v1.16b, v2.16b 536; CHECK-GI-NEXT: bl __multf3 537; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 538; CHECK-GI-NEXT: ldp q1, q0, [sp, #16] // 32-byte Folded Reload 539; CHECK-GI-NEXT: bl __multf3 540; CHECK-GI-NEXT: mov v1.16b, v0.16b 541; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 542; CHECK-GI-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 543; CHECK-GI-NEXT: add sp, sp, #64 544; CHECK-GI-NEXT: ret 545 %val = fmul <2 x fp128> %lhs, %rhs 546 ret <2 x fp128> %val 547} 548 549define <2 x fp128> @vec_div(<2 x fp128> %lhs, <2 x fp128> %rhs) { 550; CHECK-SD-LABEL: vec_div: 551; CHECK-SD: // %bb.0: 552; CHECK-SD-NEXT: sub sp, sp, #64 553; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 554; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 555; CHECK-SD-NEXT: .cfi_offset w30, -16 556; CHECK-SD-NEXT: stp q1, q3, [sp, #16] // 32-byte Folded Spill 557; CHECK-SD-NEXT: mov v1.16b, v2.16b 558; CHECK-SD-NEXT: bl __divtf3 559; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 560; CHECK-SD-NEXT: ldp q0, q1, [sp, #16] // 32-byte Folded Reload 561; CHECK-SD-NEXT: bl __divtf3 562; CHECK-SD-NEXT: mov v1.16b, v0.16b 563; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 564; CHECK-SD-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 565; CHECK-SD-NEXT: add sp, sp, #64 566; CHECK-SD-NEXT: ret 567; 568; CHECK-GI-LABEL: vec_div: 569; CHECK-GI: // %bb.0: 570; CHECK-GI-NEXT: sub sp, sp, #64 571; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 572; CHECK-GI-NEXT: .cfi_def_cfa_offset 64 573; CHECK-GI-NEXT: .cfi_offset w30, -16 574; CHECK-GI-NEXT: stp q3, q1, [sp, #16] // 32-byte Folded Spill 575; CHECK-GI-NEXT: mov v1.16b, v2.16b 576; CHECK-GI-NEXT: bl __divtf3 577; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 578; CHECK-GI-NEXT: ldp q1, q0, [sp, #16] // 32-byte Folded Reload 579; CHECK-GI-NEXT: bl __divtf3 580; CHECK-GI-NEXT: mov v1.16b, v0.16b 581; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 582; CHECK-GI-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 583; CHECK-GI-NEXT: add sp, sp, #64 584; CHECK-GI-NEXT: ret 585 %val = fdiv <2 x fp128> %lhs, %rhs 586 ret <2 x fp128> %val 587} 588 589define <2 x i32> @vec_fptosi_32(<2 x fp128> %val) { 590; CHECK-SD-LABEL: vec_fptosi_32: 591; CHECK-SD: // %bb.0: 592; CHECK-SD-NEXT: sub sp, sp, #48 593; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 594; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 595; CHECK-SD-NEXT: .cfi_offset w30, -16 596; CHECK-SD-NEXT: str q1, [sp, #16] // 16-byte Folded Spill 597; CHECK-SD-NEXT: bl __fixtfsi 598; CHECK-SD-NEXT: fmov s0, w0 599; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 600; CHECK-SD-NEXT: ldr q0, [sp, #16] // 16-byte Folded Reload 601; CHECK-SD-NEXT: bl __fixtfsi 602; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 603; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 604; CHECK-SD-NEXT: mov v0.s[1], w0 605; CHECK-SD-NEXT: // kill: def $d0 killed $d0 killed $q0 606; CHECK-SD-NEXT: add sp, sp, #48 607; CHECK-SD-NEXT: ret 608; 609; CHECK-GI-LABEL: vec_fptosi_32: 610; CHECK-GI: // %bb.0: 611; CHECK-GI-NEXT: sub sp, sp, #32 612; CHECK-GI-NEXT: stp x30, x19, [sp, #16] // 16-byte Folded Spill 613; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 614; CHECK-GI-NEXT: .cfi_offset w19, -8 615; CHECK-GI-NEXT: .cfi_offset w30, -16 616; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill 617; CHECK-GI-NEXT: bl __fixtfsi 618; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 619; CHECK-GI-NEXT: mov w19, w0 620; CHECK-GI-NEXT: bl __fixtfsi 621; CHECK-GI-NEXT: mov v0.s[0], w19 622; CHECK-GI-NEXT: ldp x30, x19, [sp, #16] // 16-byte Folded Reload 623; CHECK-GI-NEXT: mov v0.s[1], w0 624; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 625; CHECK-GI-NEXT: add sp, sp, #32 626; CHECK-GI-NEXT: ret 627 %val32 = fptosi <2 x fp128> %val to <2 x i32> 628 ret <2 x i32> %val32 629} 630 631define <2 x i64> @vec_fptosi_64(<2 x fp128> %val) { 632; CHECK-SD-LABEL: vec_fptosi_64: 633; CHECK-SD: // %bb.0: 634; CHECK-SD-NEXT: sub sp, sp, #48 635; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 636; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 637; CHECK-SD-NEXT: .cfi_offset w30, -16 638; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 639; CHECK-SD-NEXT: mov v0.16b, v1.16b 640; CHECK-SD-NEXT: bl __fixtfdi 641; CHECK-SD-NEXT: fmov d0, x0 642; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 643; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 644; CHECK-SD-NEXT: bl __fixtfdi 645; CHECK-SD-NEXT: fmov d0, x0 646; CHECK-SD-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload 647; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 648; CHECK-SD-NEXT: mov v0.d[1], v1.d[0] 649; CHECK-SD-NEXT: add sp, sp, #48 650; CHECK-SD-NEXT: ret 651; 652; CHECK-GI-LABEL: vec_fptosi_64: 653; CHECK-GI: // %bb.0: 654; CHECK-GI-NEXT: sub sp, sp, #32 655; CHECK-GI-NEXT: stp x30, x19, [sp, #16] // 16-byte Folded Spill 656; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 657; CHECK-GI-NEXT: .cfi_offset w19, -8 658; CHECK-GI-NEXT: .cfi_offset w30, -16 659; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill 660; CHECK-GI-NEXT: bl __fixtfdi 661; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 662; CHECK-GI-NEXT: mov x19, x0 663; CHECK-GI-NEXT: bl __fixtfdi 664; CHECK-GI-NEXT: mov v0.d[0], x19 665; CHECK-GI-NEXT: ldp x30, x19, [sp, #16] // 16-byte Folded Reload 666; CHECK-GI-NEXT: mov v0.d[1], x0 667; CHECK-GI-NEXT: add sp, sp, #32 668; CHECK-GI-NEXT: ret 669 %val64 = fptosi <2 x fp128> %val to <2 x i64> 670 ret <2 x i64> %val64 671} 672 673define <2 x i32> @vec_fptoui_32(<2 x fp128> %val) { 674; CHECK-SD-LABEL: vec_fptoui_32: 675; CHECK-SD: // %bb.0: 676; CHECK-SD-NEXT: sub sp, sp, #48 677; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 678; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 679; CHECK-SD-NEXT: .cfi_offset w30, -16 680; CHECK-SD-NEXT: str q1, [sp, #16] // 16-byte Folded Spill 681; CHECK-SD-NEXT: bl __fixunstfsi 682; CHECK-SD-NEXT: fmov s0, w0 683; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 684; CHECK-SD-NEXT: ldr q0, [sp, #16] // 16-byte Folded Reload 685; CHECK-SD-NEXT: bl __fixunstfsi 686; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 687; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 688; CHECK-SD-NEXT: mov v0.s[1], w0 689; CHECK-SD-NEXT: // kill: def $d0 killed $d0 killed $q0 690; CHECK-SD-NEXT: add sp, sp, #48 691; CHECK-SD-NEXT: ret 692; 693; CHECK-GI-LABEL: vec_fptoui_32: 694; CHECK-GI: // %bb.0: 695; CHECK-GI-NEXT: sub sp, sp, #32 696; CHECK-GI-NEXT: stp x30, x19, [sp, #16] // 16-byte Folded Spill 697; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 698; CHECK-GI-NEXT: .cfi_offset w19, -8 699; CHECK-GI-NEXT: .cfi_offset w30, -16 700; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill 701; CHECK-GI-NEXT: bl __fixunstfsi 702; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 703; CHECK-GI-NEXT: mov w19, w0 704; CHECK-GI-NEXT: bl __fixunstfsi 705; CHECK-GI-NEXT: mov v0.s[0], w19 706; CHECK-GI-NEXT: ldp x30, x19, [sp, #16] // 16-byte Folded Reload 707; CHECK-GI-NEXT: mov v0.s[1], w0 708; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 709; CHECK-GI-NEXT: add sp, sp, #32 710; CHECK-GI-NEXT: ret 711 %val32 = fptoui <2 x fp128> %val to <2 x i32> 712 ret <2 x i32> %val32 713} 714 715define <2 x i64> @vec_fptoui_64(<2 x fp128> %val) { 716; CHECK-SD-LABEL: vec_fptoui_64: 717; CHECK-SD: // %bb.0: 718; CHECK-SD-NEXT: sub sp, sp, #48 719; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 720; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 721; CHECK-SD-NEXT: .cfi_offset w30, -16 722; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 723; CHECK-SD-NEXT: mov v0.16b, v1.16b 724; CHECK-SD-NEXT: bl __fixunstfdi 725; CHECK-SD-NEXT: fmov d0, x0 726; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 727; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 728; CHECK-SD-NEXT: bl __fixunstfdi 729; CHECK-SD-NEXT: fmov d0, x0 730; CHECK-SD-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload 731; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 732; CHECK-SD-NEXT: mov v0.d[1], v1.d[0] 733; CHECK-SD-NEXT: add sp, sp, #48 734; CHECK-SD-NEXT: ret 735; 736; CHECK-GI-LABEL: vec_fptoui_64: 737; CHECK-GI: // %bb.0: 738; CHECK-GI-NEXT: sub sp, sp, #32 739; CHECK-GI-NEXT: stp x30, x19, [sp, #16] // 16-byte Folded Spill 740; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 741; CHECK-GI-NEXT: .cfi_offset w19, -8 742; CHECK-GI-NEXT: .cfi_offset w30, -16 743; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill 744; CHECK-GI-NEXT: bl __fixunstfdi 745; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 746; CHECK-GI-NEXT: mov x19, x0 747; CHECK-GI-NEXT: bl __fixunstfdi 748; CHECK-GI-NEXT: mov v0.d[0], x19 749; CHECK-GI-NEXT: ldp x30, x19, [sp, #16] // 16-byte Folded Reload 750; CHECK-GI-NEXT: mov v0.d[1], x0 751; CHECK-GI-NEXT: add sp, sp, #32 752; CHECK-GI-NEXT: ret 753 %val64 = fptoui <2 x fp128> %val to <2 x i64> 754 ret <2 x i64> %val64 755} 756 757define <2 x fp128> @vec_sitofp_32(<2 x i32> %src32) { 758; CHECK-SD-LABEL: vec_sitofp_32: 759; CHECK-SD: // %bb.0: 760; CHECK-SD-NEXT: sub sp, sp, #32 761; CHECK-SD-NEXT: str x30, [sp, #16] // 8-byte Folded Spill 762; CHECK-SD-NEXT: .cfi_def_cfa_offset 32 763; CHECK-SD-NEXT: .cfi_offset w30, -16 764; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 765; CHECK-SD-NEXT: fmov w0, s0 766; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 767; CHECK-SD-NEXT: bl __floatsitf 768; CHECK-SD-NEXT: ldr q1, [sp] // 16-byte Folded Reload 769; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 770; CHECK-SD-NEXT: mov w0, v1.s[1] 771; CHECK-SD-NEXT: bl __floatsitf 772; CHECK-SD-NEXT: mov v1.16b, v0.16b 773; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 774; CHECK-SD-NEXT: ldr x30, [sp, #16] // 8-byte Folded Reload 775; CHECK-SD-NEXT: add sp, sp, #32 776; CHECK-SD-NEXT: ret 777; 778; CHECK-GI-LABEL: vec_sitofp_32: 779; CHECK-GI: // %bb.0: 780; CHECK-GI-NEXT: sub sp, sp, #32 781; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill 782; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill 783; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 784; CHECK-GI-NEXT: .cfi_offset w30, -8 785; CHECK-GI-NEXT: .cfi_offset b8, -16 786; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 787; CHECK-GI-NEXT: fmov w0, s0 788; CHECK-GI-NEXT: mov s8, v0.s[1] 789; CHECK-GI-NEXT: bl __floatsitf 790; CHECK-GI-NEXT: fmov w0, s8 791; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 792; CHECK-GI-NEXT: bl __floatsitf 793; CHECK-GI-NEXT: mov v1.16b, v0.16b 794; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 795; CHECK-GI-NEXT: ldr x30, [sp, #24] // 8-byte Folded Reload 796; CHECK-GI-NEXT: ldr d8, [sp, #16] // 8-byte Folded Reload 797; CHECK-GI-NEXT: add sp, sp, #32 798; CHECK-GI-NEXT: ret 799 %val32 = sitofp <2 x i32> %src32 to <2 x fp128> 800 ret <2 x fp128> %val32 801} 802 803define <2 x fp128> @vec_sitofp_64(<2 x i64> %src64) { 804; CHECK-SD-LABEL: vec_sitofp_64: 805; CHECK-SD: // %bb.0: 806; CHECK-SD-NEXT: sub sp, sp, #48 807; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 808; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 809; CHECK-SD-NEXT: .cfi_offset w30, -16 810; CHECK-SD-NEXT: fmov x0, d0 811; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 812; CHECK-SD-NEXT: bl __floatditf 813; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 814; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 815; CHECK-SD-NEXT: mov x0, v0.d[1] 816; CHECK-SD-NEXT: bl __floatditf 817; CHECK-SD-NEXT: mov v1.16b, v0.16b 818; CHECK-SD-NEXT: ldr q0, [sp, #16] // 16-byte Folded Reload 819; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 820; CHECK-SD-NEXT: add sp, sp, #48 821; CHECK-SD-NEXT: ret 822; 823; CHECK-GI-LABEL: vec_sitofp_64: 824; CHECK-GI: // %bb.0: 825; CHECK-GI-NEXT: sub sp, sp, #32 826; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill 827; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill 828; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 829; CHECK-GI-NEXT: .cfi_offset w30, -8 830; CHECK-GI-NEXT: .cfi_offset b8, -16 831; CHECK-GI-NEXT: fmov x0, d0 832; CHECK-GI-NEXT: mov d8, v0.d[1] 833; CHECK-GI-NEXT: bl __floatditf 834; CHECK-GI-NEXT: fmov x0, d8 835; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 836; CHECK-GI-NEXT: bl __floatditf 837; CHECK-GI-NEXT: mov v1.16b, v0.16b 838; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 839; CHECK-GI-NEXT: ldr x30, [sp, #24] // 8-byte Folded Reload 840; CHECK-GI-NEXT: ldr d8, [sp, #16] // 8-byte Folded Reload 841; CHECK-GI-NEXT: add sp, sp, #32 842; CHECK-GI-NEXT: ret 843 %val64 = sitofp <2 x i64> %src64 to <2 x fp128> 844 ret <2 x fp128> %val64 845} 846 847define <2 x fp128> @vec_uitofp_32(<2 x i32> %src32) { 848; CHECK-SD-LABEL: vec_uitofp_32: 849; CHECK-SD: // %bb.0: 850; CHECK-SD-NEXT: sub sp, sp, #32 851; CHECK-SD-NEXT: str x30, [sp, #16] // 8-byte Folded Spill 852; CHECK-SD-NEXT: .cfi_def_cfa_offset 32 853; CHECK-SD-NEXT: .cfi_offset w30, -16 854; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 855; CHECK-SD-NEXT: fmov w0, s0 856; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 857; CHECK-SD-NEXT: bl __floatunsitf 858; CHECK-SD-NEXT: ldr q1, [sp] // 16-byte Folded Reload 859; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 860; CHECK-SD-NEXT: mov w0, v1.s[1] 861; CHECK-SD-NEXT: bl __floatunsitf 862; CHECK-SD-NEXT: mov v1.16b, v0.16b 863; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 864; CHECK-SD-NEXT: ldr x30, [sp, #16] // 8-byte Folded Reload 865; CHECK-SD-NEXT: add sp, sp, #32 866; CHECK-SD-NEXT: ret 867; 868; CHECK-GI-LABEL: vec_uitofp_32: 869; CHECK-GI: // %bb.0: 870; CHECK-GI-NEXT: sub sp, sp, #32 871; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill 872; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill 873; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 874; CHECK-GI-NEXT: .cfi_offset w30, -8 875; CHECK-GI-NEXT: .cfi_offset b8, -16 876; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 877; CHECK-GI-NEXT: fmov w0, s0 878; CHECK-GI-NEXT: mov s8, v0.s[1] 879; CHECK-GI-NEXT: bl __floatunsitf 880; CHECK-GI-NEXT: fmov w0, s8 881; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 882; CHECK-GI-NEXT: bl __floatunsitf 883; CHECK-GI-NEXT: mov v1.16b, v0.16b 884; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 885; CHECK-GI-NEXT: ldr x30, [sp, #24] // 8-byte Folded Reload 886; CHECK-GI-NEXT: ldr d8, [sp, #16] // 8-byte Folded Reload 887; CHECK-GI-NEXT: add sp, sp, #32 888; CHECK-GI-NEXT: ret 889 %val32 = uitofp <2 x i32> %src32 to <2 x fp128> 890 ret <2 x fp128> %val32 891} 892 893define <2 x fp128> @vec_uitofp_64(<2 x i64> %src64) { 894; CHECK-SD-LABEL: vec_uitofp_64: 895; CHECK-SD: // %bb.0: 896; CHECK-SD-NEXT: sub sp, sp, #48 897; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 898; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 899; CHECK-SD-NEXT: .cfi_offset w30, -16 900; CHECK-SD-NEXT: fmov x0, d0 901; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 902; CHECK-SD-NEXT: bl __floatunditf 903; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 904; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 905; CHECK-SD-NEXT: mov x0, v0.d[1] 906; CHECK-SD-NEXT: bl __floatunditf 907; CHECK-SD-NEXT: mov v1.16b, v0.16b 908; CHECK-SD-NEXT: ldr q0, [sp, #16] // 16-byte Folded Reload 909; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 910; CHECK-SD-NEXT: add sp, sp, #48 911; CHECK-SD-NEXT: ret 912; 913; CHECK-GI-LABEL: vec_uitofp_64: 914; CHECK-GI: // %bb.0: 915; CHECK-GI-NEXT: sub sp, sp, #32 916; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill 917; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill 918; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 919; CHECK-GI-NEXT: .cfi_offset w30, -8 920; CHECK-GI-NEXT: .cfi_offset b8, -16 921; CHECK-GI-NEXT: fmov x0, d0 922; CHECK-GI-NEXT: mov d8, v0.d[1] 923; CHECK-GI-NEXT: bl __floatunditf 924; CHECK-GI-NEXT: fmov x0, d8 925; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 926; CHECK-GI-NEXT: bl __floatunditf 927; CHECK-GI-NEXT: mov v1.16b, v0.16b 928; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 929; CHECK-GI-NEXT: ldr x30, [sp, #24] // 8-byte Folded Reload 930; CHECK-GI-NEXT: ldr d8, [sp, #16] // 8-byte Folded Reload 931; CHECK-GI-NEXT: add sp, sp, #32 932; CHECK-GI-NEXT: ret 933 %val64 = uitofp <2 x i64> %src64 to <2 x fp128> 934 ret <2 x fp128> %val64 935} 936 937define <2 x i1> @vec_setcc1(<2 x fp128> %lhs, <2 x fp128> %rhs) { 938; CHECK-SD-LABEL: vec_setcc1: 939; CHECK-SD: // %bb.0: 940; CHECK-SD-NEXT: sub sp, sp, #48 941; CHECK-SD-NEXT: str d8, [sp, #32] // 8-byte Folded Spill 942; CHECK-SD-NEXT: str x30, [sp, #40] // 8-byte Folded Spill 943; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 944; CHECK-SD-NEXT: .cfi_offset w30, -8 945; CHECK-SD-NEXT: .cfi_offset b8, -16 946; CHECK-SD-NEXT: stp q0, q2, [sp] // 32-byte Folded Spill 947; CHECK-SD-NEXT: mov v0.16b, v1.16b 948; CHECK-SD-NEXT: mov v1.16b, v3.16b 949; CHECK-SD-NEXT: bl __letf2 950; CHECK-SD-NEXT: cmp w0, #0 951; CHECK-SD-NEXT: ldp q0, q1, [sp] // 32-byte Folded Reload 952; CHECK-SD-NEXT: cset w8, le 953; CHECK-SD-NEXT: sbfx x8, x8, #0, #1 954; CHECK-SD-NEXT: fmov d8, x8 955; CHECK-SD-NEXT: bl __letf2 956; CHECK-SD-NEXT: cmp w0, #0 957; CHECK-SD-NEXT: ldr x30, [sp, #40] // 8-byte Folded Reload 958; CHECK-SD-NEXT: cset w8, le 959; CHECK-SD-NEXT: sbfx x8, x8, #0, #1 960; CHECK-SD-NEXT: fmov d0, x8 961; CHECK-SD-NEXT: zip1 v0.2s, v0.2s, v8.2s 962; CHECK-SD-NEXT: ldr d8, [sp, #32] // 8-byte Folded Reload 963; CHECK-SD-NEXT: add sp, sp, #48 964; CHECK-SD-NEXT: ret 965; 966; CHECK-GI-LABEL: vec_setcc1: 967; CHECK-GI: // %bb.0: 968; CHECK-GI-NEXT: sub sp, sp, #48 969; CHECK-GI-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill 970; CHECK-GI-NEXT: .cfi_def_cfa_offset 48 971; CHECK-GI-NEXT: .cfi_offset w19, -8 972; CHECK-GI-NEXT: .cfi_offset w30, -16 973; CHECK-GI-NEXT: stp q3, q1, [sp] // 32-byte Folded Spill 974; CHECK-GI-NEXT: mov v1.16b, v2.16b 975; CHECK-GI-NEXT: bl __letf2 976; CHECK-GI-NEXT: ldp q1, q0, [sp] // 32-byte Folded Reload 977; CHECK-GI-NEXT: cmp w0, #0 978; CHECK-GI-NEXT: cset w19, le 979; CHECK-GI-NEXT: bl __letf2 980; CHECK-GI-NEXT: mov v0.s[0], w19 981; CHECK-GI-NEXT: cmp w0, #0 982; CHECK-GI-NEXT: cset w8, le 983; CHECK-GI-NEXT: ldp x30, x19, [sp, #32] // 16-byte Folded Reload 984; CHECK-GI-NEXT: mov v0.s[1], w8 985; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 986; CHECK-GI-NEXT: add sp, sp, #48 987; CHECK-GI-NEXT: ret 988 %val = fcmp ole <2 x fp128> %lhs, %rhs 989 ret <2 x i1> %val 990} 991 992define <2 x i1> @vec_setcc2(<2 x fp128> %lhs, <2 x fp128> %rhs) { 993; CHECK-SD-LABEL: vec_setcc2: 994; CHECK-SD: // %bb.0: 995; CHECK-SD-NEXT: sub sp, sp, #48 996; CHECK-SD-NEXT: str d8, [sp, #32] // 8-byte Folded Spill 997; CHECK-SD-NEXT: str x30, [sp, #40] // 8-byte Folded Spill 998; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 999; CHECK-SD-NEXT: .cfi_offset w30, -8 1000; CHECK-SD-NEXT: .cfi_offset b8, -16 1001; CHECK-SD-NEXT: stp q0, q2, [sp] // 32-byte Folded Spill 1002; CHECK-SD-NEXT: mov v0.16b, v1.16b 1003; CHECK-SD-NEXT: mov v1.16b, v3.16b 1004; CHECK-SD-NEXT: bl __letf2 1005; CHECK-SD-NEXT: cmp w0, #0 1006; CHECK-SD-NEXT: ldp q0, q1, [sp] // 32-byte Folded Reload 1007; CHECK-SD-NEXT: cset w8, gt 1008; CHECK-SD-NEXT: sbfx x8, x8, #0, #1 1009; CHECK-SD-NEXT: fmov d8, x8 1010; CHECK-SD-NEXT: bl __letf2 1011; CHECK-SD-NEXT: cmp w0, #0 1012; CHECK-SD-NEXT: ldr x30, [sp, #40] // 8-byte Folded Reload 1013; CHECK-SD-NEXT: cset w8, gt 1014; CHECK-SD-NEXT: sbfx x8, x8, #0, #1 1015; CHECK-SD-NEXT: fmov d0, x8 1016; CHECK-SD-NEXT: zip1 v0.2s, v0.2s, v8.2s 1017; CHECK-SD-NEXT: ldr d8, [sp, #32] // 8-byte Folded Reload 1018; CHECK-SD-NEXT: add sp, sp, #48 1019; CHECK-SD-NEXT: ret 1020; 1021; CHECK-GI-LABEL: vec_setcc2: 1022; CHECK-GI: // %bb.0: 1023; CHECK-GI-NEXT: sub sp, sp, #48 1024; CHECK-GI-NEXT: stp x30, x19, [sp, #32] // 16-byte Folded Spill 1025; CHECK-GI-NEXT: .cfi_def_cfa_offset 48 1026; CHECK-GI-NEXT: .cfi_offset w19, -8 1027; CHECK-GI-NEXT: .cfi_offset w30, -16 1028; CHECK-GI-NEXT: stp q3, q1, [sp] // 32-byte Folded Spill 1029; CHECK-GI-NEXT: mov v1.16b, v2.16b 1030; CHECK-GI-NEXT: bl __letf2 1031; CHECK-GI-NEXT: ldp q1, q0, [sp] // 32-byte Folded Reload 1032; CHECK-GI-NEXT: cmp w0, #0 1033; CHECK-GI-NEXT: cset w19, gt 1034; CHECK-GI-NEXT: bl __letf2 1035; CHECK-GI-NEXT: mov v0.s[0], w19 1036; CHECK-GI-NEXT: cmp w0, #0 1037; CHECK-GI-NEXT: cset w8, gt 1038; CHECK-GI-NEXT: ldp x30, x19, [sp, #32] // 16-byte Folded Reload 1039; CHECK-GI-NEXT: mov v0.s[1], w8 1040; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 1041; CHECK-GI-NEXT: add sp, sp, #48 1042; CHECK-GI-NEXT: ret 1043 %val = fcmp ugt <2 x fp128> %lhs, %rhs 1044 ret <2 x i1> %val 1045} 1046 1047define <2 x i1> @vec_setcc3(<2 x fp128> %lhs, <2 x fp128> %rhs) { 1048; CHECK-SD-LABEL: vec_setcc3: 1049; CHECK-SD: // %bb.0: 1050; CHECK-SD-NEXT: sub sp, sp, #96 1051; CHECK-SD-NEXT: str d8, [sp, #64] // 8-byte Folded Spill 1052; CHECK-SD-NEXT: stp x30, x19, [sp, #80] // 16-byte Folded Spill 1053; CHECK-SD-NEXT: .cfi_def_cfa_offset 96 1054; CHECK-SD-NEXT: .cfi_offset w19, -8 1055; CHECK-SD-NEXT: .cfi_offset w30, -16 1056; CHECK-SD-NEXT: .cfi_offset b8, -32 1057; CHECK-SD-NEXT: stp q1, q3, [sp] // 32-byte Folded Spill 1058; CHECK-SD-NEXT: stp q0, q2, [sp, #32] // 32-byte Folded Spill 1059; CHECK-SD-NEXT: mov v0.16b, v1.16b 1060; CHECK-SD-NEXT: mov v1.16b, v3.16b 1061; CHECK-SD-NEXT: bl __eqtf2 1062; CHECK-SD-NEXT: ldp q0, q1, [sp] // 32-byte Folded Reload 1063; CHECK-SD-NEXT: mov w19, w0 1064; CHECK-SD-NEXT: bl __unordtf2 1065; CHECK-SD-NEXT: cmp w0, #0 1066; CHECK-SD-NEXT: ldp q0, q1, [sp, #32] // 32-byte Folded Reload 1067; CHECK-SD-NEXT: ccmp w19, #0, #4, eq 1068; CHECK-SD-NEXT: cset w8, eq 1069; CHECK-SD-NEXT: sbfx x8, x8, #0, #1 1070; CHECK-SD-NEXT: fmov d8, x8 1071; CHECK-SD-NEXT: bl __eqtf2 1072; CHECK-SD-NEXT: ldp q0, q1, [sp, #32] // 32-byte Folded Reload 1073; CHECK-SD-NEXT: mov w19, w0 1074; CHECK-SD-NEXT: bl __unordtf2 1075; CHECK-SD-NEXT: cmp w0, #0 1076; CHECK-SD-NEXT: ccmp w19, #0, #4, eq 1077; CHECK-SD-NEXT: ldp x30, x19, [sp, #80] // 16-byte Folded Reload 1078; CHECK-SD-NEXT: cset w8, eq 1079; CHECK-SD-NEXT: sbfx x8, x8, #0, #1 1080; CHECK-SD-NEXT: fmov d0, x8 1081; CHECK-SD-NEXT: zip1 v0.2s, v0.2s, v8.2s 1082; CHECK-SD-NEXT: ldr d8, [sp, #64] // 8-byte Folded Reload 1083; CHECK-SD-NEXT: add sp, sp, #96 1084; CHECK-SD-NEXT: ret 1085; 1086; CHECK-GI-LABEL: vec_setcc3: 1087; CHECK-GI: // %bb.0: 1088; CHECK-GI-NEXT: sub sp, sp, #96 1089; CHECK-GI-NEXT: str x30, [sp, #64] // 8-byte Folded Spill 1090; CHECK-GI-NEXT: stp x20, x19, [sp, #80] // 16-byte Folded Spill 1091; CHECK-GI-NEXT: .cfi_def_cfa_offset 96 1092; CHECK-GI-NEXT: .cfi_offset w19, -8 1093; CHECK-GI-NEXT: .cfi_offset w20, -16 1094; CHECK-GI-NEXT: .cfi_offset w30, -32 1095; CHECK-GI-NEXT: stp q2, q0, [sp] // 32-byte Folded Spill 1096; CHECK-GI-NEXT: stp q3, q1, [sp, #32] // 32-byte Folded Spill 1097; CHECK-GI-NEXT: mov v1.16b, v2.16b 1098; CHECK-GI-NEXT: bl __eqtf2 1099; CHECK-GI-NEXT: ldp q1, q0, [sp] // 32-byte Folded Reload 1100; CHECK-GI-NEXT: cmp w0, #0 1101; CHECK-GI-NEXT: cset w19, eq 1102; CHECK-GI-NEXT: bl __unordtf2 1103; CHECK-GI-NEXT: ldp q1, q0, [sp, #32] // 32-byte Folded Reload 1104; CHECK-GI-NEXT: cmp w0, #0 1105; CHECK-GI-NEXT: cset w8, ne 1106; CHECK-GI-NEXT: orr w19, w19, w8 1107; CHECK-GI-NEXT: bl __eqtf2 1108; CHECK-GI-NEXT: ldp q1, q0, [sp, #32] // 32-byte Folded Reload 1109; CHECK-GI-NEXT: cmp w0, #0 1110; CHECK-GI-NEXT: cset w20, eq 1111; CHECK-GI-NEXT: bl __unordtf2 1112; CHECK-GI-NEXT: mov v0.s[0], w19 1113; CHECK-GI-NEXT: cmp w0, #0 1114; CHECK-GI-NEXT: ldr x30, [sp, #64] // 8-byte Folded Reload 1115; CHECK-GI-NEXT: cset w8, ne 1116; CHECK-GI-NEXT: orr w8, w20, w8 1117; CHECK-GI-NEXT: ldp x20, x19, [sp, #80] // 16-byte Folded Reload 1118; CHECK-GI-NEXT: mov v0.s[1], w8 1119; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 1120; CHECK-GI-NEXT: add sp, sp, #96 1121; CHECK-GI-NEXT: ret 1122 %val = fcmp ueq <2 x fp128> %lhs, %rhs 1123 ret <2 x i1> %val 1124} 1125 1126define <2 x fp128> @vec_select(<2 x i1> %cond, <2 x fp128> %lhs, <2 x fp128> %rhs) { 1127; CHECK-SD-LABEL: vec_select: 1128; CHECK-SD: // %bb.0: 1129; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 1130; CHECK-SD-NEXT: fmov w8, s0 1131; CHECK-SD-NEXT: tst w8, #0x1 1132; CHECK-SD-NEXT: b.eq .LBB40_2 1133; CHECK-SD-NEXT: // %bb.1: 1134; CHECK-SD-NEXT: mov v3.16b, v1.16b 1135; CHECK-SD-NEXT: .LBB40_2: 1136; CHECK-SD-NEXT: mov w8, v0.s[1] 1137; CHECK-SD-NEXT: tst w8, #0x1 1138; CHECK-SD-NEXT: b.eq .LBB40_4 1139; CHECK-SD-NEXT: // %bb.3: 1140; CHECK-SD-NEXT: mov v4.16b, v2.16b 1141; CHECK-SD-NEXT: .LBB40_4: 1142; CHECK-SD-NEXT: mov v0.16b, v3.16b 1143; CHECK-SD-NEXT: mov v1.16b, v4.16b 1144; CHECK-SD-NEXT: ret 1145; 1146; CHECK-GI-LABEL: vec_select: 1147; CHECK-GI: // %bb.0: 1148; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 1149; CHECK-GI-NEXT: mov w8, v0.s[1] 1150; CHECK-GI-NEXT: fmov w9, s0 1151; CHECK-GI-NEXT: mov d5, v1.d[1] 1152; CHECK-GI-NEXT: mov d6, v3.d[1] 1153; CHECK-GI-NEXT: and w9, w9, #0x1 1154; CHECK-GI-NEXT: tst w9, #0x1 1155; CHECK-GI-NEXT: and w8, w8, #0x1 1156; CHECK-GI-NEXT: fcsel d0, d1, d3, ne 1157; CHECK-GI-NEXT: fcsel d3, d5, d6, ne 1158; CHECK-GI-NEXT: tst w8, #0x1 1159; CHECK-GI-NEXT: mov d1, v2.d[1] 1160; CHECK-GI-NEXT: mov d5, v4.d[1] 1161; CHECK-GI-NEXT: fcsel d2, d2, d4, ne 1162; CHECK-GI-NEXT: fmov x8, d0 1163; CHECK-GI-NEXT: fmov x9, d2 1164; CHECK-GI-NEXT: fcsel d2, d1, d5, ne 1165; CHECK-GI-NEXT: mov v0.d[0], x8 1166; CHECK-GI-NEXT: fmov x8, d3 1167; CHECK-GI-NEXT: mov v1.d[0], x9 1168; CHECK-GI-NEXT: fmov x9, d2 1169; CHECK-GI-NEXT: mov v0.d[1], x8 1170; CHECK-GI-NEXT: mov v1.d[1], x9 1171; CHECK-GI-NEXT: ret 1172 %val = select <2 x i1> %cond, <2 x fp128> %lhs, <2 x fp128> %rhs 1173 ret <2 x fp128> %val 1174} 1175 1176define <2 x half> @vec_round_f16(<2 x fp128> %val) { 1177; CHECK-SD-LABEL: vec_round_f16: 1178; CHECK-SD: // %bb.0: 1179; CHECK-SD-NEXT: sub sp, sp, #48 1180; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 1181; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 1182; CHECK-SD-NEXT: .cfi_offset w30, -16 1183; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1184; CHECK-SD-NEXT: mov v0.16b, v1.16b 1185; CHECK-SD-NEXT: bl __trunctfhf2 1186; CHECK-SD-NEXT: // kill: def $h0 killed $h0 def $q0 1187; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1188; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1189; CHECK-SD-NEXT: bl __trunctfhf2 1190; CHECK-SD-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload 1191; CHECK-SD-NEXT: // kill: def $h0 killed $h0 def $q0 1192; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 1193; CHECK-SD-NEXT: mov v0.h[1], v1.h[0] 1194; CHECK-SD-NEXT: // kill: def $d0 killed $d0 killed $q0 1195; CHECK-SD-NEXT: add sp, sp, #48 1196; CHECK-SD-NEXT: ret 1197; 1198; CHECK-GI-LABEL: vec_round_f16: 1199; CHECK-GI: // %bb.0: 1200; CHECK-GI-NEXT: sub sp, sp, #64 1201; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 1202; CHECK-GI-NEXT: .cfi_def_cfa_offset 64 1203; CHECK-GI-NEXT: .cfi_offset w30, -16 1204; CHECK-GI-NEXT: mov v2.d[0], x8 1205; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill 1206; CHECK-GI-NEXT: mov v2.d[1], x8 1207; CHECK-GI-NEXT: str q2, [sp, #32] // 16-byte Folded Spill 1208; CHECK-GI-NEXT: bl __trunctfhf2 1209; CHECK-GI-NEXT: // kill: def $h0 killed $h0 def $q0 1210; CHECK-GI-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1211; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1212; CHECK-GI-NEXT: bl __trunctfhf2 1213; CHECK-GI-NEXT: // kill: def $h0 killed $h0 def $q0 1214; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 1215; CHECK-GI-NEXT: ldr q0, [sp, #32] // 16-byte Folded Reload 1216; CHECK-GI-NEXT: bl __trunctfhf2 1217; CHECK-GI-NEXT: ldr q0, [sp, #32] // 16-byte Folded Reload 1218; CHECK-GI-NEXT: bl __trunctfhf2 1219; CHECK-GI-NEXT: ldp q1, q0, [sp] // 32-byte Folded Reload 1220; CHECK-GI-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 1221; CHECK-GI-NEXT: mov v0.h[1], v1.h[0] 1222; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 1223; CHECK-GI-NEXT: add sp, sp, #64 1224; CHECK-GI-NEXT: ret 1225 %dst = fptrunc <2 x fp128> %val to <2 x half> 1226 ret <2 x half> %dst 1227} 1228 1229define <2 x float> @vec_round_f32(<2 x fp128> %val) { 1230; CHECK-SD-LABEL: vec_round_f32: 1231; CHECK-SD: // %bb.0: 1232; CHECK-SD-NEXT: sub sp, sp, #48 1233; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 1234; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 1235; CHECK-SD-NEXT: .cfi_offset w30, -16 1236; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1237; CHECK-SD-NEXT: mov v0.16b, v1.16b 1238; CHECK-SD-NEXT: bl __trunctfsf2 1239; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 1240; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1241; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1242; CHECK-SD-NEXT: bl __trunctfsf2 1243; CHECK-SD-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload 1244; CHECK-SD-NEXT: // kill: def $s0 killed $s0 def $q0 1245; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 1246; CHECK-SD-NEXT: mov v0.s[1], v1.s[0] 1247; CHECK-SD-NEXT: // kill: def $d0 killed $d0 killed $q0 1248; CHECK-SD-NEXT: add sp, sp, #48 1249; CHECK-SD-NEXT: ret 1250; 1251; CHECK-GI-LABEL: vec_round_f32: 1252; CHECK-GI: // %bb.0: 1253; CHECK-GI-NEXT: sub sp, sp, #48 1254; CHECK-GI-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 1255; CHECK-GI-NEXT: .cfi_def_cfa_offset 48 1256; CHECK-GI-NEXT: .cfi_offset w30, -16 1257; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill 1258; CHECK-GI-NEXT: bl __trunctfsf2 1259; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 1260; CHECK-GI-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1261; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1262; CHECK-GI-NEXT: bl __trunctfsf2 1263; CHECK-GI-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload 1264; CHECK-GI-NEXT: // kill: def $s0 killed $s0 def $q0 1265; CHECK-GI-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 1266; CHECK-GI-NEXT: mov v1.s[1], v0.s[0] 1267; CHECK-GI-NEXT: fmov d0, d1 1268; CHECK-GI-NEXT: add sp, sp, #48 1269; CHECK-GI-NEXT: ret 1270 %dst = fptrunc <2 x fp128> %val to <2 x float> 1271 ret <2 x float> %dst 1272} 1273 1274define <2 x double> @vec_round_f64(<2 x fp128> %val) { 1275; CHECK-SD-LABEL: vec_round_f64: 1276; CHECK-SD: // %bb.0: 1277; CHECK-SD-NEXT: sub sp, sp, #48 1278; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 1279; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 1280; CHECK-SD-NEXT: .cfi_offset w30, -16 1281; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1282; CHECK-SD-NEXT: mov v0.16b, v1.16b 1283; CHECK-SD-NEXT: bl __trunctfdf2 1284; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 1285; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1286; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1287; CHECK-SD-NEXT: bl __trunctfdf2 1288; CHECK-SD-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload 1289; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 1290; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 1291; CHECK-SD-NEXT: mov v0.d[1], v1.d[0] 1292; CHECK-SD-NEXT: add sp, sp, #48 1293; CHECK-SD-NEXT: ret 1294; 1295; CHECK-GI-LABEL: vec_round_f64: 1296; CHECK-GI: // %bb.0: 1297; CHECK-GI-NEXT: sub sp, sp, #48 1298; CHECK-GI-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 1299; CHECK-GI-NEXT: .cfi_def_cfa_offset 48 1300; CHECK-GI-NEXT: .cfi_offset w30, -16 1301; CHECK-GI-NEXT: str q1, [sp] // 16-byte Folded Spill 1302; CHECK-GI-NEXT: bl __trunctfdf2 1303; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 1304; CHECK-GI-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1305; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1306; CHECK-GI-NEXT: bl __trunctfdf2 1307; CHECK-GI-NEXT: ldr q1, [sp, #16] // 16-byte Folded Reload 1308; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 1309; CHECK-GI-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 1310; CHECK-GI-NEXT: mov v1.d[1], v0.d[0] 1311; CHECK-GI-NEXT: mov v0.16b, v1.16b 1312; CHECK-GI-NEXT: add sp, sp, #48 1313; CHECK-GI-NEXT: ret 1314 %dst = fptrunc <2 x fp128> %val to <2 x double> 1315 ret <2 x double> %dst 1316} 1317 1318define <2 x fp128> @vec_extend_f16(<2 x half> %val) { 1319; CHECK-SD-LABEL: vec_extend_f16: 1320; CHECK-SD: // %bb.0: 1321; CHECK-SD-NEXT: sub sp, sp, #32 1322; CHECK-SD-NEXT: str x30, [sp, #16] // 8-byte Folded Spill 1323; CHECK-SD-NEXT: .cfi_def_cfa_offset 32 1324; CHECK-SD-NEXT: .cfi_offset w30, -16 1325; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 1326; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1327; CHECK-SD-NEXT: // kill: def $h0 killed $h0 killed $q0 1328; CHECK-SD-NEXT: bl __extendhftf2 1329; CHECK-SD-NEXT: ldr q1, [sp] // 16-byte Folded Reload 1330; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1331; CHECK-SD-NEXT: mov h1, v1.h[1] 1332; CHECK-SD-NEXT: fmov s0, s1 1333; CHECK-SD-NEXT: bl __extendhftf2 1334; CHECK-SD-NEXT: mov v1.16b, v0.16b 1335; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1336; CHECK-SD-NEXT: ldr x30, [sp, #16] // 8-byte Folded Reload 1337; CHECK-SD-NEXT: add sp, sp, #32 1338; CHECK-SD-NEXT: ret 1339; 1340; CHECK-GI-LABEL: vec_extend_f16: 1341; CHECK-GI: // %bb.0: 1342; CHECK-GI-NEXT: sub sp, sp, #32 1343; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill 1344; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill 1345; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 1346; CHECK-GI-NEXT: .cfi_offset w30, -8 1347; CHECK-GI-NEXT: .cfi_offset b8, -16 1348; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 1349; CHECK-GI-NEXT: mov h8, v0.h[1] 1350; CHECK-GI-NEXT: // kill: def $h0 killed $h0 killed $q0 1351; CHECK-GI-NEXT: bl __extendhftf2 1352; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 1353; CHECK-GI-NEXT: fmov s0, s8 1354; CHECK-GI-NEXT: bl __extendhftf2 1355; CHECK-GI-NEXT: mov v1.16b, v0.16b 1356; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1357; CHECK-GI-NEXT: ldr x30, [sp, #24] // 8-byte Folded Reload 1358; CHECK-GI-NEXT: ldr d8, [sp, #16] // 8-byte Folded Reload 1359; CHECK-GI-NEXT: add sp, sp, #32 1360; CHECK-GI-NEXT: ret 1361 %dst = fpext <2 x half> %val to <2 x fp128> 1362 ret <2 x fp128> %dst 1363} 1364 1365define <2 x fp128> @vec_extend_f32(<2 x float> %val) { 1366; CHECK-SD-LABEL: vec_extend_f32: 1367; CHECK-SD: // %bb.0: 1368; CHECK-SD-NEXT: sub sp, sp, #32 1369; CHECK-SD-NEXT: str x30, [sp, #16] // 8-byte Folded Spill 1370; CHECK-SD-NEXT: .cfi_def_cfa_offset 32 1371; CHECK-SD-NEXT: .cfi_offset w30, -16 1372; CHECK-SD-NEXT: // kill: def $d0 killed $d0 def $q0 1373; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1374; CHECK-SD-NEXT: // kill: def $s0 killed $s0 killed $q0 1375; CHECK-SD-NEXT: bl __extendsftf2 1376; CHECK-SD-NEXT: ldr q1, [sp] // 16-byte Folded Reload 1377; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1378; CHECK-SD-NEXT: mov s1, v1.s[1] 1379; CHECK-SD-NEXT: fmov s0, s1 1380; CHECK-SD-NEXT: bl __extendsftf2 1381; CHECK-SD-NEXT: mov v1.16b, v0.16b 1382; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1383; CHECK-SD-NEXT: ldr x30, [sp, #16] // 8-byte Folded Reload 1384; CHECK-SD-NEXT: add sp, sp, #32 1385; CHECK-SD-NEXT: ret 1386; 1387; CHECK-GI-LABEL: vec_extend_f32: 1388; CHECK-GI: // %bb.0: 1389; CHECK-GI-NEXT: sub sp, sp, #32 1390; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill 1391; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill 1392; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 1393; CHECK-GI-NEXT: .cfi_offset w30, -8 1394; CHECK-GI-NEXT: .cfi_offset b8, -16 1395; CHECK-GI-NEXT: // kill: def $d0 killed $d0 def $q0 1396; CHECK-GI-NEXT: mov s8, v0.s[1] 1397; CHECK-GI-NEXT: // kill: def $s0 killed $s0 killed $q0 1398; CHECK-GI-NEXT: bl __extendsftf2 1399; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 1400; CHECK-GI-NEXT: fmov s0, s8 1401; CHECK-GI-NEXT: bl __extendsftf2 1402; CHECK-GI-NEXT: mov v1.16b, v0.16b 1403; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1404; CHECK-GI-NEXT: ldr x30, [sp, #24] // 8-byte Folded Reload 1405; CHECK-GI-NEXT: ldr d8, [sp, #16] // 8-byte Folded Reload 1406; CHECK-GI-NEXT: add sp, sp, #32 1407; CHECK-GI-NEXT: ret 1408 %dst = fpext <2 x float> %val to <2 x fp128> 1409 ret <2 x fp128> %dst 1410} 1411 1412define <2 x fp128> @vec_extend_f64(<2 x double> %val) { 1413; CHECK-SD-LABEL: vec_extend_f64: 1414; CHECK-SD: // %bb.0: 1415; CHECK-SD-NEXT: sub sp, sp, #48 1416; CHECK-SD-NEXT: str x30, [sp, #32] // 8-byte Folded Spill 1417; CHECK-SD-NEXT: .cfi_def_cfa_offset 48 1418; CHECK-SD-NEXT: .cfi_offset w30, -16 1419; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1420; CHECK-SD-NEXT: // kill: def $d0 killed $d0 killed $q0 1421; CHECK-SD-NEXT: bl __extenddftf2 1422; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1423; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1424; CHECK-SD-NEXT: mov d0, v0.d[1] 1425; CHECK-SD-NEXT: bl __extenddftf2 1426; CHECK-SD-NEXT: mov v1.16b, v0.16b 1427; CHECK-SD-NEXT: ldr q0, [sp, #16] // 16-byte Folded Reload 1428; CHECK-SD-NEXT: ldr x30, [sp, #32] // 8-byte Folded Reload 1429; CHECK-SD-NEXT: add sp, sp, #48 1430; CHECK-SD-NEXT: ret 1431; 1432; CHECK-GI-LABEL: vec_extend_f64: 1433; CHECK-GI: // %bb.0: 1434; CHECK-GI-NEXT: sub sp, sp, #32 1435; CHECK-GI-NEXT: str d8, [sp, #16] // 8-byte Folded Spill 1436; CHECK-GI-NEXT: str x30, [sp, #24] // 8-byte Folded Spill 1437; CHECK-GI-NEXT: .cfi_def_cfa_offset 32 1438; CHECK-GI-NEXT: .cfi_offset w30, -8 1439; CHECK-GI-NEXT: .cfi_offset b8, -16 1440; CHECK-GI-NEXT: mov d8, v0.d[1] 1441; CHECK-GI-NEXT: // kill: def $d0 killed $d0 killed $q0 1442; CHECK-GI-NEXT: bl __extenddftf2 1443; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 1444; CHECK-GI-NEXT: fmov d0, d8 1445; CHECK-GI-NEXT: bl __extenddftf2 1446; CHECK-GI-NEXT: mov v1.16b, v0.16b 1447; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1448; CHECK-GI-NEXT: ldr x30, [sp, #24] // 8-byte Folded Reload 1449; CHECK-GI-NEXT: ldr d8, [sp, #16] // 8-byte Folded Reload 1450; CHECK-GI-NEXT: add sp, sp, #32 1451; CHECK-GI-NEXT: ret 1452 %dst = fpext <2 x double> %val to <2 x fp128> 1453 ret <2 x fp128> %dst 1454} 1455 1456define <2 x fp128> @vec_neg_sub(<2 x fp128> %in) { 1457; CHECK-SD-LABEL: vec_neg_sub: 1458; CHECK-SD: // %bb.0: 1459; CHECK-SD-NEXT: sub sp, sp, #64 1460; CHECK-SD-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 1461; CHECK-SD-NEXT: .cfi_def_cfa_offset 64 1462; CHECK-SD-NEXT: .cfi_offset w30, -16 1463; CHECK-SD-NEXT: str q1, [sp, #32] // 16-byte Folded Spill 1464; CHECK-SD-NEXT: mov v1.16b, v0.16b 1465; CHECK-SD-NEXT: adrp x8, .LCPI47_0 1466; CHECK-SD-NEXT: ldr q0, [x8, :lo12:.LCPI47_0] 1467; CHECK-SD-NEXT: str q0, [sp] // 16-byte Folded Spill 1468; CHECK-SD-NEXT: bl __subtf3 1469; CHECK-SD-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1470; CHECK-SD-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1471; CHECK-SD-NEXT: ldr q1, [sp, #32] // 16-byte Folded Reload 1472; CHECK-SD-NEXT: bl __subtf3 1473; CHECK-SD-NEXT: mov v1.16b, v0.16b 1474; CHECK-SD-NEXT: ldr q0, [sp, #16] // 16-byte Folded Reload 1475; CHECK-SD-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 1476; CHECK-SD-NEXT: add sp, sp, #64 1477; CHECK-SD-NEXT: ret 1478; 1479; CHECK-GI-LABEL: vec_neg_sub: 1480; CHECK-GI: // %bb.0: 1481; CHECK-GI-NEXT: sub sp, sp, #64 1482; CHECK-GI-NEXT: str x30, [sp, #48] // 8-byte Folded Spill 1483; CHECK-GI-NEXT: .cfi_def_cfa_offset 64 1484; CHECK-GI-NEXT: .cfi_offset w30, -16 1485; CHECK-GI-NEXT: mov v2.16b, v0.16b 1486; CHECK-GI-NEXT: adrp x8, .LCPI47_0 1487; CHECK-GI-NEXT: str q1, [sp, #32] // 16-byte Folded Spill 1488; CHECK-GI-NEXT: ldr q0, [x8, :lo12:.LCPI47_0] 1489; CHECK-GI-NEXT: mov v1.16b, v2.16b 1490; CHECK-GI-NEXT: str q0, [sp] // 16-byte Folded Spill 1491; CHECK-GI-NEXT: bl __subtf3 1492; CHECK-GI-NEXT: str q0, [sp, #16] // 16-byte Folded Spill 1493; CHECK-GI-NEXT: ldr q0, [sp] // 16-byte Folded Reload 1494; CHECK-GI-NEXT: ldr q1, [sp, #32] // 16-byte Folded Reload 1495; CHECK-GI-NEXT: bl __subtf3 1496; CHECK-GI-NEXT: mov v1.16b, v0.16b 1497; CHECK-GI-NEXT: ldr q0, [sp, #16] // 16-byte Folded Reload 1498; CHECK-GI-NEXT: ldr x30, [sp, #48] // 8-byte Folded Reload 1499; CHECK-GI-NEXT: add sp, sp, #64 1500; CHECK-GI-NEXT: ret 1501 %ret = fsub <2 x fp128> zeroinitializer, %in 1502 ret <2 x fp128> %ret 1503} 1504 1505define <2 x fp128> @vec_neg(<2 x fp128> %in) { 1506; CHECK-SD-LABEL: vec_neg: 1507; CHECK-SD: // %bb.0: 1508; CHECK-SD-NEXT: stp q0, q1, [sp, #-32]! 1509; CHECK-SD-NEXT: .cfi_def_cfa_offset 32 1510; CHECK-SD-NEXT: ldrb w8, [sp, #15] 1511; CHECK-SD-NEXT: eor w8, w8, #0x80 1512; CHECK-SD-NEXT: strb w8, [sp, #15] 1513; CHECK-SD-NEXT: ldrb w8, [sp, #31] 1514; CHECK-SD-NEXT: eor w8, w8, #0x80 1515; CHECK-SD-NEXT: strb w8, [sp, #31] 1516; CHECK-SD-NEXT: ldp q0, q1, [sp], #32 1517; CHECK-SD-NEXT: ret 1518; 1519; CHECK-GI-LABEL: vec_neg: 1520; CHECK-GI: // %bb.0: 1521; CHECK-GI-NEXT: mov x8, v0.d[1] 1522; CHECK-GI-NEXT: mov x9, v1.d[1] 1523; CHECK-GI-NEXT: mov v0.d[0], v0.d[0] 1524; CHECK-GI-NEXT: mov v1.d[0], v1.d[0] 1525; CHECK-GI-NEXT: eor x8, x8, #0x8000000000000000 1526; CHECK-GI-NEXT: eor x9, x9, #0x8000000000000000 1527; CHECK-GI-NEXT: mov v0.d[1], x8 1528; CHECK-GI-NEXT: mov v1.d[1], x9 1529; CHECK-GI-NEXT: ret 1530 %ret = fneg <2 x fp128> %in 1531 ret <2 x fp128> %ret 1532} 1533