test/CodeGen/SPARC/fp128.ll

   1 ; RUN: llc < %s -march=sparc -mattr=hard-quad-float | FileCheck %s --check-prefix=HARD
   2 ; RUN: llc < %s -march=sparc -mattr=-hard-quad-float | FileCheck %s --check-prefix=SOFT
   3
   4
   5 ; HARD-LABEL: f128_ops
   6 ; HARD:       ldd
   7 ; HARD:       ldd
   8 ; HARD:       ldd
   9 ; HARD:       ldd
  10 ; HARD:       faddq [[R0:.+]],  [[R1:.+]],  [[R2:.+]]
  11 ; HARD:       fsubq [[R2]], [[R3:.+]], [[R4:.+]]
  12 ; HARD:       fmulq [[R4]], [[R5:.+]], [[R6:.+]]
  13 ; HARD:       fdivq [[R6]], [[R2]]
  14 ; HARD:       std
  15 ; HARD:       std
  16
  17 ; SOFT-LABEL: f128_ops
  18 ; SOFT:       ldd
  19 ; SOFT:       ldd
  20 ; SOFT:       ldd
  21 ; SOFT:       ldd
  22 ; SOFT:       call _Q_add
  23 ; SOFT:       call _Q_sub
  24 ; SOFT:       call _Q_mul
  25 ; SOFT:       call _Q_div
  26 ; SOFT:       std
  27 ; SOFT:       std
  28
  29 define void @f128_ops(fp128* noalias sret %scalar.result, fp128* byval %a, fp128* byval %b, fp128* byval %c, fp128* byval %d) {
  30 entry:
  31   %0 = load fp128, fp128* %a, align 8
  32   %1 = load fp128, fp128* %b, align 8
  33   %2 = load fp128, fp128* %c, align 8
  34   %3 = load fp128, fp128* %d, align 8
  35   %4 = fadd fp128 %0, %1
  36   %5 = fsub fp128 %4, %2
  37   %6 = fmul fp128 %5, %3
  38   %7 = fdiv fp128 %6, %4
  39   store fp128 %7, fp128* %scalar.result, align 8
  40   ret void
  41 }
  42
  43 ; HARD-LABEL: f128_spill
  44 ; HARD:       std %f{{.+}}, [%[[S0:.+]]]
  45 ; HARD:       std %f{{.+}}, [%[[S1:.+]]]
  46 ; HARD-DAG:   ldd [%[[S0]]], %f{{.+}}
  47 ; HARD-DAG:   ldd [%[[S1]]], %f{{.+}}
  48 ; HARD:       jmp %o7+12
  49
  50 ; SOFT-LABEL: f128_spill
  51 ; SOFT:       std %f{{.+}}, [%[[S0:.+]]]
  52 ; SOFT:       std %f{{.+}}, [%[[S1:.+]]]
  53 ; SOFT-DAG:   ldd [%[[S0]]], %f{{.+}}
  54 ; SOFT-DAG:   ldd [%[[S1]]], %f{{.+}}
  55 ; SOFT:       jmp %o7+12
  56
  57 define void @f128_spill(fp128* noalias sret %scalar.result, fp128* byval %a) {
  58 entry:
  59   %0 = load fp128, fp128* %a, align 8
  60   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}"()
  61   store fp128 %0, fp128* %scalar.result, align 8
  62   ret void
  63 }
  64
  65 ; HARD-LABEL: f128_compare
  66 ; HARD:       fcmpq
  67 ; HARD-NEXT:  nop
  68
  69 ; SOFT-LABEL: f128_compare
  70 ; SOFT:       _Q_cmp
  71
  72 define i32 @f128_compare(fp128* byval %f0, fp128* byval %f1, i32 %a, i32 %b) {
  73 entry:
  74    %0 = load fp128, fp128* %f0, align 8
  75    %1 = load fp128, fp128* %f1, align 8
  76    %cond = fcmp ult fp128 %0, %1
  77    %ret = select i1 %cond, i32 %a, i32 %b
  78    ret i32 %ret
  79 }
  80
  81 ; HARD-LABEL: f128_compare2
  82 ; HARD:       fcmpq
  83 ; HARD:       fb{{ule|g}}
  84
  85 ; SOFT-LABEL: f128_compare2
  86 ; SOFT:       _Q_cmp
  87 ; SOFT:       cmp
  88
  89 define i32 @f128_compare2() {
  90 entry:
  91   %0 = fcmp ogt fp128 undef, 0xL00000000000000000000000000000000
  92   br i1 %0, label %"5", label %"7"
  93
  94 "5":                                              ; preds = %entry
  95   ret i32 0
  96
  97 "7":                                              ; preds = %entry
  98   ret i32 1
  99 }
 100
 101
 102 ; HARD-LABEL: f128_abs
 103 ; HARD:       fabss
 104
 105 ; SOFT-LABEL: f128_abs
 106 ; SOFT:       fabss
 107
 108 define void @f128_abs(fp128* noalias sret %scalar.result, fp128* byval %a) {
 109 entry:
 110   %0 = load fp128, fp128* %a, align 8
 111   %1 = tail call fp128 @llvm.fabs.f128(fp128 %0)
 112   store fp128 %1, fp128* %scalar.result, align 8
 113   ret void
 114 }
 115
 116 declare fp128 @llvm.fabs.f128(fp128) nounwind readonly
 117
 118 ; HARD-LABEL: int_to_f128
 119 ; HARD:       fitoq
 120
 121 ; SOFT-LABEL: int_to_f128
 122 ; SOFT:       _Q_itoq
 123
 124 define void @int_to_f128(fp128* noalias sret %scalar.result, i32 %i) {
 125 entry:
 126   %0 = sitofp i32 %i to fp128
 127   store fp128 %0, fp128* %scalar.result, align 8
 128   ret void
 129 }
 130
 131 ; HARD-LABEL: fp128_unaligned
 132 ; HARD:       ldub
 133 ; HARD:       faddq
 134 ; HARD:       stb
 135 ; HARD:       ret
 136
 137 ; SOFT-LABEL: fp128_unaligned
 138 ; SOFT:       ldub
 139 ; SOFT:       call _Q_add
 140 ; SOFT:       stb
 141 ; SOFT:       ret
 142
 143 define void @fp128_unaligned(fp128* %a, fp128* %b, fp128* %c) {
 144 entry:
 145   %0 = load fp128, fp128* %a, align 1
 146   %1 = load fp128, fp128* %b, align 1
 147   %2 = fadd fp128 %0, %1
 148   store fp128 %2, fp128* %c, align 1
 149   ret void
 150 }
 151
 152 ; HARD-LABEL: uint_to_f128
 153 ; HARD:       fdtoq
 154
 155 ; SOFT-LABEL: uint_to_f128
 156 ; SOFT:       _Q_utoq
 157
 158 define void @uint_to_f128(fp128* noalias sret %scalar.result, i32 %i) {
 159 entry:
 160   %0 = uitofp i32 %i to fp128
 161   store fp128 %0, fp128* %scalar.result, align 8
 162   ret void
 163 }
 164
 165 ; HARD-LABEL: f128_to_i32
 166 ; HARD:       fqtoi
 167 ; HARD:       fqtoi
 168
 169 ; SOFT-LABEL: f128_to_i32
 170 ; SOFT:       call _Q_qtou
 171 ; SOFT:       call _Q_qtoi
 172
 173
 174 define i32 @f128_to_i32(fp128* %a, fp128* %b) {
 175 entry:
 176   %0 = load fp128, fp128* %a, align 8
 177   %1 = load fp128, fp128* %b, align 8
 178   %2 = fptoui fp128 %0 to i32
 179   %3 = fptosi fp128 %1 to i32
 180   %4 = add i32 %2, %3
 181   ret i32 %4
 182 }
 183
 184 ; HARD-LABEL:    test_itoq_qtoi
 185 ; HARD-DAG:      call _Q_lltoq
 186 ; HARD-DAG:      call _Q_qtoll
 187 ; HARD-DAG:      fitoq
 188 ; HARD-DAG:      fqtoi
 189
 190 ; SOFT-LABEL:    test_itoq_qtoi
 191 ; SOFT-DAG:      call _Q_lltoq
 192 ; SOFT-DAG:      call _Q_qtoll
 193 ; SOFT-DAG:      call _Q_itoq
 194 ; SOFT-DAG:      call _Q_qtoi
 195
 196 define void @test_itoq_qtoi(i64 %a, i32 %b, fp128* %c, fp128* %d, i64* %ptr0, fp128* %ptr1) {
 197 entry:
 198   %0 = sitofp i64 %a to fp128
 199   store  fp128 %0, fp128* %ptr1, align 8
 200   %cval = load fp128, fp128* %c, align 8
 201   %1 = fptosi fp128 %cval to i64
 202   store  i64 %1, i64* %ptr0, align 8
 203   %2 = sitofp i32 %b to fp128
 204   store  fp128 %2, fp128* %ptr1, align 8
 205   %dval = load fp128, fp128* %d, align 8
 206   %3 = fptosi fp128 %dval to i32
 207   %4 = bitcast i64* %ptr0 to i32*
 208   store  i32 %3, i32* %4, align 8
 209   ret void
 210 }
 211
 212 ; HARD-LABEL:    test_utoq_qtou
 213 ; HARD-DAG:      call _Q_ulltoq
 214 ; HARD-DAG:      call _Q_qtoull
 215 ; HARD-DAG:      fdtoq
 216 ; HARD-DAG:      fqtoi
 217
 218 ; SOFT-LABEL:    test_utoq_qtou
 219 ; SOFT-DAG:      call _Q_ulltoq
 220 ; SOFT-DAG:      call _Q_qtoull
 221 ; SOFT-DAG:      call _Q_utoq
 222 ; SOFT-DAG:      call _Q_qtou
 223
 224 define void @test_utoq_qtou(i64 %a, i32 %b, fp128* %c, fp128* %d, i64* %ptr0, fp128* %ptr1) {
 225 entry:
 226   %0 = uitofp i64 %a to fp128
 227   store  fp128 %0, fp128* %ptr1, align 8
 228   %cval = load fp128, fp128* %c, align 8
 229   %1 = fptoui fp128 %cval to i64
 230   store  i64 %1, i64* %ptr0, align 8
 231   %2 = uitofp i32 %b to fp128
 232   store  fp128 %2, fp128* %ptr1, align 8
 233   %dval = load fp128, fp128* %d, align 8
 234   %3 = fptoui fp128 %dval to i32
 235   %4 = bitcast i64* %ptr0 to i32*
 236   store  i32 %3, i32* %4, align 8
 237   ret void
 238 }
 239
 240 ; SOFT-LABEL:     f128_neg
 241 ; SOFT:           fnegs
 242
 243 define void @f128_neg(fp128* noalias sret %scalar.result, fp128* byval %a) {
 244 entry:
 245   %0 = load fp128, fp128* %a, align 8
 246   %1 = fsub fp128 0xL00000000000000008000000000000000, %0
 247   store fp128 %1, fp128* %scalar.result, align 8
 248   ret void
 249 }