test/CodeGen/AArch64/fp128.ll

   1 ; RUN: llc -mtriple=aarch64-none-linux-gnu -verify-machineinstrs < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-AARCH64
   2 ; RUN: llc -mtriple=arm64-none-linux-gnu -verify-machineinstrs -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ARM64
   3
   4 @lhs = global fp128 zeroinitializer
   5 @rhs = global fp128 zeroinitializer
   6
   7 define fp128 @test_add() {
   8 ; CHECK-LABEL: test_add:
   9
  10   %lhs = load fp128* @lhs
  11   %rhs = load fp128* @rhs
  12 ; CHECK: ldr q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
  13 ; CHECK: ldr q1, [{{x[0-9]+}}, {{#?}}:lo12:rhs]
  14
  15   %val = fadd fp128 %lhs, %rhs
  16 ; CHECK: bl __addtf3
  17   ret fp128 %val
  18 }
  19
  20 define fp128 @test_sub() {
  21 ; CHECK-LABEL: test_sub:
  22
  23   %lhs = load fp128* @lhs
  24   %rhs = load fp128* @rhs
  25 ; CHECK: ldr q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
  26 ; CHECK: ldr q1, [{{x[0-9]+}}, {{#?}}:lo12:rhs]
  27
  28   %val = fsub fp128 %lhs, %rhs
  29 ; CHECK: bl __subtf3
  30   ret fp128 %val
  31 }
  32
  33 define fp128 @test_mul() {
  34 ; CHECK-LABEL: test_mul:
  35
  36   %lhs = load fp128* @lhs
  37   %rhs = load fp128* @rhs
  38 ; CHECK: ldr q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
  39 ; CHECK: ldr q1, [{{x[0-9]+}}, {{#?}}:lo12:rhs]
  40
  41   %val = fmul fp128 %lhs, %rhs
  42 ; CHECK: bl __multf3
  43   ret fp128 %val
  44 }
  45
  46 define fp128 @test_div() {
  47 ; CHECK-LABEL: test_div:
  48
  49   %lhs = load fp128* @lhs
  50   %rhs = load fp128* @rhs
  51 ; CHECK: ldr q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
  52 ; CHECK: ldr q1, [{{x[0-9]+}}, {{#?}}:lo12:rhs]
  53
  54   %val = fdiv fp128 %lhs, %rhs
  55 ; CHECK: bl __divtf3
  56   ret fp128 %val
  57 }
  58
  59 @var32 = global i32 0
  60 @var64 = global i64 0
  61
  62 define void @test_fptosi() {
  63 ; CHECK-LABEL: test_fptosi:
  64   %val = load fp128* @lhs
  65
  66   %val32 = fptosi fp128 %val to i32
  67   store i32 %val32, i32* @var32
  68 ; CHECK: bl __fixtfsi
  69
  70   %val64 = fptosi fp128 %val to i64
  71   store i64 %val64, i64* @var64
  72 ; CHECK: bl __fixtfdi
  73
  74   ret void
  75 }
  76
  77 define void @test_fptoui() {
  78 ; CHECK-LABEL: test_fptoui:
  79   %val = load fp128* @lhs
  80
  81   %val32 = fptoui fp128 %val to i32
  82   store i32 %val32, i32* @var32
  83 ; CHECK: bl __fixunstfsi
  84
  85   %val64 = fptoui fp128 %val to i64
  86   store i64 %val64, i64* @var64
  87 ; CHECK: bl __fixunstfdi
  88
  89   ret void
  90 }
  91
  92 define void @test_sitofp() {
  93 ; CHECK-LABEL: test_sitofp:
  94
  95   %src32 = load i32* @var32
  96   %val32 = sitofp i32 %src32 to fp128
  97   store volatile fp128 %val32, fp128* @lhs
  98 ; CHECK: bl __floatsitf
  99
 100   %src64 = load i64* @var64
 101   %val64 = sitofp i64 %src64 to fp128
 102   store volatile fp128 %val64, fp128* @lhs
 103 ; CHECK: bl __floatditf
 104
 105   ret void
 106 }
 107
 108 define void @test_uitofp() {
 109 ; CHECK-LABEL: test_uitofp:
 110
 111   %src32 = load i32* @var32
 112   %val32 = uitofp i32 %src32 to fp128
 113   store volatile fp128 %val32, fp128* @lhs
 114 ; CHECK: bl __floatunsitf
 115
 116   %src64 = load i64* @var64
 117   %val64 = uitofp i64 %src64 to fp128
 118   store volatile fp128 %val64, fp128* @lhs
 119 ; CHECK: bl __floatunditf
 120
 121   ret void
 122 }
 123
 124 define i1 @test_setcc1() {
 125 ; CHECK-LABEL: test_setcc1:
 126
 127   %lhs = load fp128* @lhs
 128   %rhs = load fp128* @rhs
 129 ; CHECK: ldr q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
 130 ; CHECK: ldr q1, [{{x[0-9]+}}, {{#?}}:lo12:rhs]
 131
 132 ; Technically, everything after the call to __letf2 is redundant, but we'll let
 133 ; LLVM have its fun for now.
 134   %val = fcmp ole fp128 %lhs, %rhs
 135 ; CHECK: bl __letf2
 136 ; CHECK: cmp w0, #0
 137 ; CHECK: csinc w0, wzr, wzr, gt
 138
 139   ret i1 %val
 140 ; CHECK: ret
 141 }
 142
 143 define i1 @test_setcc2() {
 144 ; CHECK-LABEL: test_setcc2:
 145
 146   %lhs = load fp128* @lhs
 147   %rhs = load fp128* @rhs
 148 ; CHECK: ldr q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
 149 ; CHECK: ldr q1, [{{x[0-9]+}}, {{#?}}:lo12:rhs]
 150
 151 ; Technically, everything after the call to __letf2 is redundant, but we'll let
 152 ; LLVM have its fun for now.
 153   %val = fcmp ugt fp128 %lhs, %rhs
 154 ; CHECK: bl      __gttf2
 155 ; CHECK: cmp w0, #0
 156 ; CHECK: csinc   [[GT:w[0-9]+]], wzr, wzr, le
 157
 158 ; CHECK: bl      __unordtf2
 159 ; CHECK: cmp w0, #0
 160 ; CHECK: csinc   [[UNORDERED:w[0-9]+]], wzr, wzr, eq
 161
 162 ; CHECK: orr     w0, [[UNORDERED]], [[GT]]
 163
 164   ret i1 %val
 165 ; CHECK: ret
 166 }
 167
 168 define i32 @test_br_cc() {
 169 ; CHECK-LABEL: test_br_cc:
 170
 171   %lhs = load fp128* @lhs
 172   %rhs = load fp128* @rhs
 173 ; CHECK: ldr q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
 174 ; CHECK: ldr q1, [{{x[0-9]+}}, {{#?}}:lo12:rhs]
 175
 176   ; olt == !uge, which LLVM unfortunately "optimizes" this to.
 177   %cond = fcmp olt fp128 %lhs, %rhs
 178 ; CHECK: bl      __getf2
 179 ; CHECK: cmp w0, #0
 180 ; CHECK: csinc   [[OGE:w[0-9]+]], wzr, wzr, lt
 181
 182 ; CHECK: bl      __unordtf2
 183 ; CHECK: cmp w0, #0
 184 ; CHECK: csinc   [[UNORDERED:w[0-9]+]], wzr, wzr, eq
 185
 186 ; CHECK: orr     [[UGE:w[0-9]+]], [[UNORDERED]], [[OGE]]
 187 ; CHECK: cbnz [[UGE]], [[RET29:.LBB[0-9]+_[0-9]+]]
 188   br i1 %cond, label %iftrue, label %iffalse
 189
 190 iftrue:
 191   ret i32 42
 192 ; CHECK-NEXT: BB#
 193 ; CHECK-NEXT: movz {{x0|w0}}, #42
 194 ; CHECK-NEXT: b [[REALRET:.LBB[0-9]+_[0-9]+]]
 195
 196 iffalse:
 197   ret i32 29
 198 ; CHECK: [[RET29]]:
 199 ; CHECK-NEXT: movz {{x0|w0}}, #29
 200 ; CHECK-NEXT: [[REALRET]]:
 201 ; CHECK: ret
 202 }
 203
 204 define void @test_select(i1 %cond, fp128 %lhs, fp128 %rhs) {
 205 ; CHECK-LABEL: test_select:
 206
 207   %val = select i1 %cond, fp128 %lhs, fp128 %rhs
 208   store fp128 %val, fp128* @lhs
 209 ; CHECK: cmp {{w[0-9]+}}, #0
 210 ; CHECK-AARCH64: str q1, [sp]
 211 ; CHECK-NEXT: b.eq [[IFFALSE:.LBB[0-9]+_[0-9]+]]
 212 ; CHECK-NEXT: BB#
 213 ; CHECK-AARCH64-NEXT: str q0, [sp]
 214 ; CHECK-ARM64-NEXT: orr v[[DEST:[0-9]+]].16b, v0.16b, v0.16b
 215 ; CHECK-NEXT: [[IFFALSE]]:
 216 ; CHECK-AARCH64-NEXT: ldr q[[DEST:[0-9]+]], [sp]
 217 ; CHECK: str q[[DEST]], [{{x[0-9]+}}, {{#?}}:lo12:lhs]
 218   ret void
 219 ; CHECK: ret
 220 }
 221
 222 @varfloat = global float 0.0
 223 @vardouble = global double 0.0
 224
 225 define void @test_round() {
 226 ; CHECK-LABEL: test_round:
 227
 228   %val = load fp128* @lhs
 229
 230   %float = fptrunc fp128 %val to float
 231   store float %float, float* @varfloat
 232 ; CHECK: bl __trunctfsf2
 233 ; CHECK: str s0, [{{x[0-9]+}}, {{#?}}:lo12:varfloat]
 234
 235   %double = fptrunc fp128 %val to double
 236   store double %double, double* @vardouble
 237 ; CHECK: bl __trunctfdf2
 238 ; CHECK: str d0, [{{x[0-9]+}}, {{#?}}:lo12:vardouble]
 239
 240   ret void
 241 }
 242
 243 define void @test_extend() {
 244 ; CHECK-LABEL: test_extend:
 245
 246   %val = load fp128* @lhs
 247
 248   %float = load float* @varfloat
 249   %fromfloat = fpext float %float to fp128
 250   store volatile fp128 %fromfloat, fp128* @lhs
 251 ; CHECK: bl __extendsftf2
 252 ; CHECK: str q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
 253
 254   %double = load double* @vardouble
 255   %fromdouble = fpext double %double to fp128
 256   store volatile fp128 %fromdouble, fp128* @lhs
 257 ; CHECK: bl __extenddftf2
 258 ; CHECK: str q0, [{{x[0-9]+}}, {{#?}}:lo12:lhs]
 259
 260   ret void
 261 ; CHECK: ret
 262 }
 263
 264 define fp128 @test_neg(fp128 %in) {
 265 ; CHECK: [[MINUS0:.LCPI[0-9]+_0]]:
 266 ; Make sure the weird hex constant below *is* -0.0
 267 ; CHECK-NEXT: fp128 -0
 268
 269 ; CHECK-LABEL: test_neg:
 270
 271   ; Could in principle be optimized to fneg which we can't select, this makes
 272   ; sure that doesn't happen.
 273   %ret = fsub fp128 0xL00000000000000008000000000000000, %in
 274 ; CHECK-AARCH64: str q0, [sp, #-16]
 275 ; CHECK-AARCH64-NEXT: ldr q1, [sp], #16
 276 ; CHECK-ARM64: orr v1.16b, v0.16b, v0.16b
 277 ; CHECK: ldr q0, [{{x[0-9]+}}, {{#?}}:lo12:[[MINUS0]]]
 278 ; CHECK: bl __subtf3
 279
 280   ret fp128 %ret
 281 ; CHECK: ret
 282 }