test/CodeGen/Mips/msa/arithmetic_float.ll

   1 ; RUN: llc -march=mips -mattr=+msa,+fp64 < %s | FileCheck %s
   2
   3 define void @add_v4f32(<4 x float>* %c, <4 x float>* %a, <4 x float>* %b) nounwind {
   4   ; CHECK: add_v4f32:
   5
   6   %1 = load <4 x float>* %a
   7   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
   8   %2 = load <4 x float>* %b
   9   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
  10   %3 = fadd <4 x float> %1, %2
  11   ; CHECK-DAG: fadd.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  12   store <4 x float> %3, <4 x float>* %c
  13   ; CHECK-DAG: st.w [[R3]], 0($4)
  14
  15   ret void
  16   ; CHECK: .size add_v4f32
  17 }
  18
  19 define void @add_v2f64(<2 x double>* %c, <2 x double>* %a, <2 x double>* %b) nounwind {
  20   ; CHECK: add_v2f64:
  21
  22   %1 = load <2 x double>* %a
  23   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
  24   %2 = load <2 x double>* %b
  25   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
  26   %3 = fadd <2 x double> %1, %2
  27   ; CHECK-DAG: fadd.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  28   store <2 x double> %3, <2 x double>* %c
  29   ; CHECK-DAG: st.d [[R3]], 0($4)
  30
  31   ret void
  32   ; CHECK: .size add_v2f64
  33 }
  34
  35 define void @sub_v4f32(<4 x float>* %c, <4 x float>* %a, <4 x float>* %b) nounwind {
  36   ; CHECK: sub_v4f32:
  37
  38   %1 = load <4 x float>* %a
  39   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
  40   %2 = load <4 x float>* %b
  41   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
  42   %3 = fsub <4 x float> %1, %2
  43   ; CHECK-DAG: fsub.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  44   store <4 x float> %3, <4 x float>* %c
  45   ; CHECK-DAG: st.w [[R3]], 0($4)
  46
  47   ret void
  48   ; CHECK: .size sub_v4f32
  49 }
  50
  51 define void @sub_v2f64(<2 x double>* %c, <2 x double>* %a, <2 x double>* %b) nounwind {
  52   ; CHECK: sub_v2f64:
  53
  54   %1 = load <2 x double>* %a
  55   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
  56   %2 = load <2 x double>* %b
  57   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
  58   %3 = fsub <2 x double> %1, %2
  59   ; CHECK-DAG: fsub.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  60   store <2 x double> %3, <2 x double>* %c
  61   ; CHECK-DAG: st.d [[R3]], 0($4)
  62
  63   ret void
  64   ; CHECK: .size sub_v2f64
  65 }
  66
  67 define void @mul_v4f32(<4 x float>* %c, <4 x float>* %a, <4 x float>* %b) nounwind {
  68   ; CHECK: mul_v4f32:
  69
  70   %1 = load <4 x float>* %a
  71   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
  72   %2 = load <4 x float>* %b
  73   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
  74   %3 = fmul <4 x float> %1, %2
  75   ; CHECK-DAG: fmul.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  76   store <4 x float> %3, <4 x float>* %c
  77   ; CHECK-DAG: st.w [[R3]], 0($4)
  78
  79   ret void
  80   ; CHECK: .size mul_v4f32
  81 }
  82
  83 define void @mul_v2f64(<2 x double>* %c, <2 x double>* %a, <2 x double>* %b) nounwind {
  84   ; CHECK: mul_v2f64:
  85
  86   %1 = load <2 x double>* %a
  87   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
  88   %2 = load <2 x double>* %b
  89   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
  90   %3 = fmul <2 x double> %1, %2
  91   ; CHECK-DAG: fmul.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
  92   store <2 x double> %3, <2 x double>* %c
  93   ; CHECK-DAG: st.d [[R3]], 0($4)
  94
  95   ret void
  96   ; CHECK: .size mul_v2f64
  97 }
  98
  99 define void @fdiv_v4f32(<4 x float>* %c, <4 x float>* %a, <4 x float>* %b) nounwind {
 100   ; CHECK: fdiv_v4f32:
 101
 102   %1 = load <4 x float>* %a
 103   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 104   %2 = load <4 x float>* %b
 105   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 106   %3 = fdiv <4 x float> %1, %2
 107   ; CHECK-DAG: fdiv.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 108   store <4 x float> %3, <4 x float>* %c
 109   ; CHECK-DAG: st.w [[R3]], 0($4)
 110
 111   ret void
 112   ; CHECK: .size fdiv_v4f32
 113 }
 114
 115 define void @fdiv_v2f64(<2 x double>* %c, <2 x double>* %a, <2 x double>* %b) nounwind {
 116   ; CHECK: fdiv_v2f64:
 117
 118   %1 = load <2 x double>* %a
 119   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 120   %2 = load <2 x double>* %b
 121   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 122   %3 = fdiv <2 x double> %1, %2
 123   ; CHECK-DAG: fdiv.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 124   store <2 x double> %3, <2 x double>* %c
 125   ; CHECK-DAG: st.d [[R3]], 0($4)
 126
 127   ret void
 128   ; CHECK: .size fdiv_v2f64
 129 }
 130
 131 define void @fabs_v4f32(<4 x float>* %c, <4 x float>* %a) nounwind {
 132   ; CHECK: fabs_v4f32:
 133
 134   %1 = load <4 x float>* %a
 135   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 136   %2 = tail call <4 x float> @llvm.fabs.v4f32 (<4 x float> %1)
 137   ; CHECK-DAG: fmax_a.w [[R3:\$w[0-9]+]], [[R1]], [[R1]]
 138   store <4 x float> %2, <4 x float>* %c
 139   ; CHECK-DAG: st.w [[R3]], 0($4)
 140
 141   ret void
 142   ; CHECK: .size fabs_v4f32
 143 }
 144
 145 define void @fabs_v2f64(<2 x double>* %c, <2 x double>* %a) nounwind {
 146   ; CHECK: fabs_v2f64:
 147
 148   %1 = load <2 x double>* %a
 149   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 150   %2 = tail call <2 x double> @llvm.fabs.v2f64 (<2 x double> %1)
 151   ; CHECK-DAG: fmax_a.d [[R3:\$w[0-9]+]], [[R1]], [[R1]]
 152   store <2 x double> %2, <2 x double>* %c
 153   ; CHECK-DAG: st.d [[R3]], 0($4)
 154
 155   ret void
 156   ; CHECK: .size fabs_v2f64
 157 }
 158
 159 define void @fsqrt_v4f32(<4 x float>* %c, <4 x float>* %a) nounwind {
 160   ; CHECK: fsqrt_v4f32:
 161
 162   %1 = load <4 x float>* %a
 163   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 164   %2 = tail call <4 x float> @llvm.sqrt.v4f32 (<4 x float> %1)
 165   ; CHECK-DAG: fsqrt.w [[R3:\$w[0-9]+]], [[R1]]
 166   store <4 x float> %2, <4 x float>* %c
 167   ; CHECK-DAG: st.w [[R3]], 0($4)
 168
 169   ret void
 170   ; CHECK: .size fsqrt_v4f32
 171 }
 172
 173 define void @fsqrt_v2f64(<2 x double>* %c, <2 x double>* %a) nounwind {
 174   ; CHECK: fsqrt_v2f64:
 175
 176   %1 = load <2 x double>* %a
 177   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 178   %2 = tail call <2 x double> @llvm.sqrt.v2f64 (<2 x double> %1)
 179   ; CHECK-DAG: fsqrt.d [[R3:\$w[0-9]+]], [[R1]]
 180   store <2 x double> %2, <2 x double>* %c
 181   ; CHECK-DAG: st.d [[R3]], 0($4)
 182
 183   ret void
 184   ; CHECK: .size fsqrt_v2f64
 185 }
 186
 187 define void @ffint_u_v4f32(<4 x float>* %c, <4 x i32>* %a) nounwind {
 188   ; CHECK: ffint_u_v4f32:
 189
 190   %1 = load <4 x i32>* %a
 191   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 192   %2 = uitofp <4 x i32> %1 to <4 x float>
 193   ; CHECK-DAG: ffint_u.w [[R3:\$w[0-9]+]], [[R1]]
 194   store <4 x float> %2, <4 x float>* %c
 195   ; CHECK-DAG: st.w [[R3]], 0($4)
 196
 197   ret void
 198   ; CHECK: .size ffint_u_v4f32
 199 }
 200
 201 define void @ffint_u_v2f64(<2 x double>* %c, <2 x i64>* %a) nounwind {
 202   ; CHECK: ffint_u_v2f64:
 203
 204   %1 = load <2 x i64>* %a
 205   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 206   %2 = uitofp <2 x i64> %1 to <2 x double>
 207   ; CHECK-DAG: ffint_u.d [[R3:\$w[0-9]+]], [[R1]]
 208   store <2 x double> %2, <2 x double>* %c
 209   ; CHECK-DAG: st.d [[R3]], 0($4)
 210
 211   ret void
 212   ; CHECK: .size ffint_u_v2f64
 213 }
 214
 215 define void @ffint_s_v4f32(<4 x float>* %c, <4 x i32>* %a) nounwind {
 216   ; CHECK: ffint_s_v4f32:
 217
 218   %1 = load <4 x i32>* %a
 219   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 220   %2 = sitofp <4 x i32> %1 to <4 x float>
 221   ; CHECK-DAG: ffint_s.w [[R3:\$w[0-9]+]], [[R1]]
 222   store <4 x float> %2, <4 x float>* %c
 223   ; CHECK-DAG: st.w [[R3]], 0($4)
 224
 225   ret void
 226   ; CHECK: .size ffint_s_v4f32
 227 }
 228
 229 define void @ffint_s_v2f64(<2 x double>* %c, <2 x i64>* %a) nounwind {
 230   ; CHECK: ffint_s_v2f64:
 231
 232   %1 = load <2 x i64>* %a
 233   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 234   %2 = sitofp <2 x i64> %1 to <2 x double>
 235   ; CHECK-DAG: ffint_s.d [[R3:\$w[0-9]+]], [[R1]]
 236   store <2 x double> %2, <2 x double>* %c
 237   ; CHECK-DAG: st.d [[R3]], 0($4)
 238
 239   ret void
 240   ; CHECK: .size ffint_s_v2f64
 241 }
 242
 243 define void @ftrunc_u_v4f32(<4 x i32>* %c, <4 x float>* %a) nounwind {
 244   ; CHECK: ftrunc_u_v4f32:
 245
 246   %1 = load <4 x float>* %a
 247   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 248   %2 = fptoui <4 x float> %1 to <4 x i32>
 249   ; CHECK-DAG: ftrunc_u.w [[R3:\$w[0-9]+]], [[R1]]
 250   store <4 x i32> %2, <4 x i32>* %c
 251   ; CHECK-DAG: st.w [[R3]], 0($4)
 252
 253   ret void
 254   ; CHECK: .size ftrunc_u_v4f32
 255 }
 256
 257 define void @ftrunc_u_v2f64(<2 x i64>* %c, <2 x double>* %a) nounwind {
 258   ; CHECK: ftrunc_u_v2f64:
 259
 260   %1 = load <2 x double>* %a
 261   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 262   %2 = fptoui <2 x double> %1 to <2 x i64>
 263   ; CHECK-DAG: ftrunc_u.d [[R3:\$w[0-9]+]], [[R1]]
 264   store <2 x i64> %2, <2 x i64>* %c
 265   ; CHECK-DAG: st.d [[R3]], 0($4)
 266
 267   ret void
 268   ; CHECK: .size ftrunc_u_v2f64
 269 }
 270
 271 define void @ftrunc_s_v4f32(<4 x i32>* %c, <4 x float>* %a) nounwind {
 272   ; CHECK: ftrunc_s_v4f32:
 273
 274   %1 = load <4 x float>* %a
 275   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 276   %2 = fptosi <4 x float> %1 to <4 x i32>
 277   ; CHECK-DAG: ftrunc_s.w [[R3:\$w[0-9]+]], [[R1]]
 278   store <4 x i32> %2, <4 x i32>* %c
 279   ; CHECK-DAG: st.w [[R3]], 0($4)
 280
 281   ret void
 282   ; CHECK: .size ftrunc_s_v4f32
 283 }
 284
 285 define void @ftrunc_s_v2f64(<2 x i64>* %c, <2 x double>* %a) nounwind {
 286   ; CHECK: ftrunc_s_v2f64:
 287
 288   %1 = load <2 x double>* %a
 289   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 290   %2 = fptosi <2 x double> %1 to <2 x i64>
 291   ; CHECK-DAG: ftrunc_s.d [[R3:\$w[0-9]+]], [[R1]]
 292   store <2 x i64> %2, <2 x i64>* %c
 293   ; CHECK-DAG: st.d [[R3]], 0($4)
 294
 295   ret void
 296   ; CHECK: .size ftrunc_s_v2f64
 297 }
 298
 299 declare <4 x float>  @llvm.fabs.v4f32(<4 x float>  %Val)
 300 declare <2 x double> @llvm.fabs.v2f64(<2 x double> %Val)
 301 declare <4 x float>  @llvm.sqrt.v4f32(<4 x float>  %Val)
 302 declare <2 x double> @llvm.sqrt.v2f64(<2 x double> %Val)