test/CodeGen/ARM/2011-11-29-128bitArithmetics.ll

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