| ; RUN: llc < %s -mtriple=sparc -mattr=hard-quad-float | FileCheck %s --check-prefix=CHECK --check-prefix=HARD --check-prefix=BE |
| ; RUN: llc < %s -mtriple=sparcel -mattr=hard-quad-float | FileCheck %s --check-prefix=CHECK --check-prefix=HARD --check-prefix=EL |
| ; RUN: llc < %s -mtriple=sparc -mattr=-hard-quad-float -verify-machineinstrs | FileCheck %s --check-prefix=CHECK --check-prefix=SOFT --check-prefix=BE |
| ; RUN: llc < %s -mtriple=sparcel -mattr=-hard-quad-float | FileCheck %s --check-prefix=CHECK --check-prefix=SOFT --check-prefix=EL |
| |
| ; CHECK-LABEL: f128_ops: |
| ; CHECK: ldd |
| ; CHECK: ldd |
| ; CHECK: ldd |
| ; CHECK: ldd |
| ; HARD: faddq [[R0:.+]], [[R1:.+]], [[R2:.+]] |
| ; HARD: fsubq [[R2]], [[R3:.+]], [[R4:.+]] |
| ; HARD: fmulq [[R4]], [[R5:.+]], [[R6:.+]] |
| ; HARD: fdivq [[R6]], [[R2]] |
| ; SOFT: call _Q_add |
| ; SOFT: unimp 16 |
| ; SOFT: call _Q_sub |
| ; SOFT: unimp 16 |
| ; SOFT: call _Q_mul |
| ; SOFT: unimp 16 |
| ; SOFT: call _Q_div |
| ; SOFT: unimp 16 |
| ; CHECK: std |
| ; CHECK: std |
| |
| define void @f128_ops(ptr noalias sret(fp128) %scalar.result, ptr byval(fp128) %a, ptr byval(fp128) %b, ptr byval(fp128) %c, ptr byval(fp128) %d) { |
| entry: |
| %0 = load fp128, ptr %a, align 8 |
| %1 = load fp128, ptr %b, align 8 |
| %2 = load fp128, ptr %c, align 8 |
| %3 = load fp128, ptr %d, align 8 |
| %4 = fadd fp128 %0, %1 |
| %5 = fsub fp128 %4, %2 |
| %6 = fmul fp128 %5, %3 |
| %7 = fdiv fp128 %6, %4 |
| store fp128 %7, ptr %scalar.result, align 8 |
| ret void |
| } |
| |
| ; CHECK-LABEL: f128_spill: |
| ; CHECK: std %f{{.+}}, [%[[S0:.+]]] |
| ; CHECK: std %f{{.+}}, [%[[S1:.+]]] |
| ; CHECK-DAG: ldd [%[[S0]]], %f{{.+}} |
| ; CHECK-DAG: ldd [%[[S1]]], %f{{.+}} |
| ; CHECK: jmp {{%[oi]7}}+12 |
| |
| define void @f128_spill(ptr noalias sret(fp128) %scalar.result, ptr byval(fp128) %a) { |
| entry: |
| %0 = load fp128, ptr %a, align 8 |
| call void asm sideeffect "", "~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f8},~{f9},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f18},~{f19},~{f20},~{f21},~{f22},~{f23},~{f24},~{f25},~{f26},~{f27},~{f28},~{f29},~{f30},~{f31}"() |
| store fp128 %0, ptr %scalar.result, align 8 |
| ret void |
| } |
| |
| ; CHECK-LABEL: f128_spill_large: |
| ; CHECK: sethi 4, %g1 |
| |
| ; CHECK: std %f{{.+}}, [%[[S0:.+]]] |
| ; CHECK: std %f{{.+}}, [%[[S1:.+]]] |
| ; CHECK-DAG: ldd [%[[S0]]], %f{{.+}} |
| ; CHECK-DAG: ldd [%[[S1]]], %f{{.+}} |
| define void @f128_spill_large(ptr noalias sret(<251 x fp128>) %scalar.result, ptr byval(<251 x fp128>) %a) { |
| entry: |
| %0 = load <251 x fp128>, ptr %a, align 8 |
| call void asm sideeffect "", "~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f8},~{f9},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f18},~{f19},~{f20},~{f21},~{f22},~{f23},~{f24},~{f25},~{f26},~{f27},~{f28},~{f29},~{f30},~{f31}"() |
| store <251 x fp128> %0, ptr %scalar.result, align 8 |
| ret void |
| } |
| |
| ; CHECK-LABEL: f128_compare: |
| ; HARD: fcmpq |
| ; HARD-NEXT: nop |
| ; SOFT: _Q_cmp |
| |
| define i32 @f128_compare(ptr byval(fp128) %f0, ptr byval(fp128) %f1, i32 %a, i32 %b) { |
| entry: |
| %0 = load fp128, ptr %f0, align 8 |
| %1 = load fp128, ptr %f1, align 8 |
| %cond = fcmp ult fp128 %0, %1 |
| %ret = select i1 %cond, i32 %a, i32 %b |
| ret i32 %ret |
| } |
| |
| ; CHECK-LABEL: f128_compare2: |
| ; HARD: fcmpq |
| ; HARD: fb{{ule|g}} |
| ; SOFT: _Q_cmp |
| ; SOFT: cmp |
| |
| define i32 @f128_compare2(ptr byval(fp128) %f0) { |
| entry: |
| %0 = load fp128, ptr %f0, align 8 |
| %1 = fcmp ogt fp128 %0, 0xL00000000000000000000000000000000 |
| br i1 %1, label %"5", label %"7" |
| |
| "5": ; preds = %entry |
| ret i32 0 |
| |
| "7": ; preds = %entry |
| ret i32 1 |
| } |
| |
| |
| ; CHECK-LABEL: f128_abs: |
| ; CHECK-DAG: ldd [%o0], [[REG:%f[0-9]+]] |
| ; CHECK-DAG: ldd [%o0+8], %f{{[0-9]+}} |
| ; BE: fabss [[REG]], [[REG]] |
| ; EL: fabss %f1, %f1 |
| |
| define void @f128_abs(ptr noalias sret(fp128) %scalar.result, ptr byval(fp128) %a) { |
| entry: |
| %0 = load fp128, ptr %a, align 8 |
| %1 = tail call fp128 @llvm.fabs.f128(fp128 %0) |
| store fp128 %1, ptr %scalar.result, align 8 |
| ret void |
| } |
| |
| declare fp128 @llvm.fabs.f128(fp128) nounwind readonly |
| |
| ; CHECK-LABEL: int_to_f128: |
| ; HARD: fitoq |
| ; SOFT: _Q_itoq |
| ; SOFT: unimp 16 |
| |
| define void @int_to_f128(ptr noalias sret(fp128) %scalar.result, i32 %i) { |
| entry: |
| %0 = sitofp i32 %i to fp128 |
| store fp128 %0, ptr %scalar.result, align 8 |
| ret void |
| } |
| |
| ; CHECK-LABEL: fp128_unaligned: |
| ; CHECK: ldub |
| ; HARD: faddq |
| ; SOFT: call _Q_add |
| ; SOFT: unimp 16 |
| ; CHECK: stb |
| ; CHECK: ret |
| |
| define void @fp128_unaligned(ptr %a, ptr %b, ptr %c) { |
| entry: |
| %0 = load fp128, ptr %a, align 1 |
| %1 = load fp128, ptr %b, align 1 |
| %2 = fadd fp128 %0, %1 |
| store fp128 %2, ptr %c, align 1 |
| ret void |
| } |
| |
| ; CHECK-LABEL: uint_to_f128: |
| ; HARD: fdtoq |
| ; SOFT: _Q_utoq |
| ; SOFT: unimp 16 |
| |
| define void @uint_to_f128(ptr noalias sret(fp128) %scalar.result, i32 %i) { |
| entry: |
| %0 = uitofp i32 %i to fp128 |
| store fp128 %0, ptr %scalar.result, align 8 |
| ret void |
| } |
| |
| ; CHECK-LABEL: f128_to_i32: |
| ; HARD: fqtoi |
| ; HARD: fqtoi |
| ; SOFT: call _Q_qtou |
| ; SOFT: call _Q_qtoi |
| |
| |
| define i32 @f128_to_i32(ptr %a, ptr %b) { |
| entry: |
| %0 = load fp128, ptr %a, align 8 |
| %1 = load fp128, ptr %b, align 8 |
| %2 = fptoui fp128 %0 to i32 |
| %3 = fptosi fp128 %1 to i32 |
| %4 = add i32 %2, %3 |
| ret i32 %4 |
| } |
| |
| ; CHECK-LABEL: test_itoq_qtoi |
| ; HARD-DAG: call _Q_lltoq |
| ; HARD-DAG: call _Q_qtoll |
| ; HARD-DAG: fitoq |
| ; HARD-DAG: fqtoi |
| ; SOFT-DAG: call _Q_lltoq |
| ; SOFT-DAG: unimp 16 |
| ; SOFT-DAG: call _Q_qtoll |
| ; SOFT-DAG: call _Q_itoq |
| ; SOFT-DAG: unimp 16 |
| ; SOFT-DAG: call _Q_qtoi |
| |
| define void @test_itoq_qtoi(i64 %a, i32 %b, ptr %c, ptr %d, ptr %ptr0, ptr %ptr1) { |
| entry: |
| %0 = sitofp i64 %a to fp128 |
| store fp128 %0, ptr %ptr1, align 8 |
| %cval = load fp128, ptr %c, align 8 |
| %1 = fptosi fp128 %cval to i64 |
| store i64 %1, ptr %ptr0, align 8 |
| %2 = sitofp i32 %b to fp128 |
| store fp128 %2, ptr %ptr1, align 8 |
| %dval = load fp128, ptr %d, align 8 |
| %3 = fptosi fp128 %dval to i32 |
| %4 = bitcast ptr %ptr0 to ptr |
| store i32 %3, ptr %4, align 8 |
| ret void |
| } |
| |
| ; CHECK-LABEL: test_utoq_qtou: |
| ; CHECK-DAG: call _Q_ulltoq |
| ; CHECK-DAG: call _Q_qtoull |
| ; HARD-DAG: fdtoq |
| ; HARD-DAG: fqtoi |
| ; SOFT-DAG: call _Q_utoq |
| ; SOFT-DAG: unimp 16 |
| ; SOFT-DAG: call _Q_qtou |
| |
| define void @test_utoq_qtou(i64 %a, i32 %b, ptr %c, ptr %d, ptr %ptr0, ptr %ptr1) { |
| entry: |
| %0 = uitofp i64 %a to fp128 |
| store fp128 %0, ptr %ptr1, align 8 |
| %cval = load fp128, ptr %c, align 8 |
| %1 = fptoui fp128 %cval to i64 |
| store i64 %1, ptr %ptr0, align 8 |
| %2 = uitofp i32 %b to fp128 |
| store fp128 %2, ptr %ptr1, align 8 |
| %dval = load fp128, ptr %d, align 8 |
| %3 = fptoui fp128 %dval to i32 |
| %4 = bitcast ptr %ptr0 to ptr |
| store i32 %3, ptr %4, align 8 |
| ret void |
| } |
| |
| ; CHECK-LABEL: f128_neg: |
| ; CHECK-DAG: ldd [%o0], [[REG:%f[0-9]+]] |
| ; CHECK-DAG: ldd [%o0+8], %f{{[0-9]+}} |
| ; BE: fnegs [[REG]], [[REG]] |
| ; LE: fnegs [[REG]], [[REG]] |
| |
| define void @f128_neg(ptr noalias sret(fp128) %scalar.result, ptr byval(fp128) %a) { |
| entry: |
| %0 = load fp128, ptr %a, align 8 |
| %1 = fsub fp128 0xL00000000000000008000000000000000, %0 |
| store fp128 %1, ptr %scalar.result, align 8 |
| ret void |
| } |
