test/CodeGen/Hexagon/intrinsics-v60-misc.ll

   1 ; RUN: llc -march=hexagon < %s | FileCheck %s
   2
   3 @l = external global <32 x i32>
   4 @k = external global <16 x i32>
   5 @h = external global <16 x i32>
   6 @n = external global i64
   7 @m = external global i32
   8
   9 ; CHECK-LABEL: test1:
  10 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.w = vrmpy(v{{[0-9]+}}:{{[0-9]+}}.ub,r{{[0-9]+}}.b,#1)
  11 define void @test1(<32 x i32> %a, i32 %b) #0 {
  12 entry:
  13   %0 = tail call <32 x i32> @llvm.hexagon.V6.vrmpybusi(<32 x i32> %a, i32 %b, i32 1)
  14   store <32 x i32> %0, <32 x i32>* @l, align 128
  15   ret void
  16 }
  17
  18 ; CHECK-LABEL: test2:
  19 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.uw = vrsad(v{{[0-9]+}}:{{[0-9]+}}.ub,r{{[0-9]+}}.ub,#1)
  20 define void @test2(<32 x i32> %a, i32 %b) #0 {
  21 entry:
  22   %0 = tail call <32 x i32> @llvm.hexagon.V6.vrsadubi(<32 x i32> %a, i32 %b, i32 1)
  23   store <32 x i32> %0, <32 x i32>* @l, align 128
  24   ret void
  25 }
  26
  27 ; CHECK-LABEL: test3:
  28 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.uw = vrmpy(v{{[0-9]+}}:{{[0-9]+}}.ub,r{{[0-9]+}}.ub,#1)
  29 define void @test3(<32 x i32> %a, i32 %b) #0 {
  30 entry:
  31   %0 = tail call <32 x i32> @llvm.hexagon.V6.vrmpyubi(<32 x i32> %a, i32 %b, i32 1)
  32   store <32 x i32> %0, <32 x i32>* @l, align 128
  33   ret void
  34 }
  35
  36 ; CHECK-LABEL: test4:
  37 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.w += vrmpy(v{{[0-9]+}}:{{[0-9]+}}.ub,r{{[0-9]+}}.b,#1)
  38 define void @test4(<32 x i32> %a, <32 x i32> %b, i32 %c) #0 {
  39 entry:
  40   %0 = tail call <32 x i32> @llvm.hexagon.V6.vrmpybusi.acc(<32 x i32> %a, <32 x i32> %b, i32 %c, i32 1)
  41   store <32 x i32> %0, <32 x i32>* @l, align 128
  42   ret void
  43 }
  44
  45 ; CHECK-LABEL: test5:
  46 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.uw += vrsad(v{{[0-9]+}}:{{[0-9]+}}.ub,r{{[0-9]+}}.ub,#1)
  47 define void @test5(<32 x i32> %a, <32 x i32> %b, i32 %c) #0 {
  48 entry:
  49   %0 = tail call <32 x i32> @llvm.hexagon.V6.vrsadubi.acc(<32 x i32> %a, <32 x i32> %b, i32 %c, i32 1)
  50   store <32 x i32> %0, <32 x i32>* @l, align 128
  51   ret void
  52 }
  53
  54 ; CHECK-LABEL: test6:
  55 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.uw += vrmpy(v{{[0-9]+}}:{{[0-9]+}}.ub,r{{[0-9]+}}.ub,#0)
  56 define void @test6(<32 x i32> %a, <32 x i32> %b, i32 %c) #0 {
  57 entry:
  58   %0 = tail call <32 x i32> @llvm.hexagon.V6.vrmpyubi.acc(<32 x i32> %a, <32 x i32> %b, i32 %c, i32 0)
  59   store <32 x i32> %0, <32 x i32>* @l, align 128
  60   ret void
  61 }
  62
  63 ; CHECK-LABEL: test7:
  64 ; CHECK: v{{[0-9]+}} = valign(v{{[0-9]+}},v{{[0-9]+}},r{{[0-9]+}})
  65 define void @test7(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
  66 entry:
  67   %0 = tail call <16 x i32> @llvm.hexagon.V6.valignb(<16 x i32> %a, <16 x i32> %b, i32 %c)
  68   store <16 x i32> %0, <16 x i32>* @k, align 64
  69   ret void
  70 }
  71
  72 ; CHECK-LABEL: test8:
  73 ; CHECK: v{{[0-9]+}} = vlalign(v{{[0-9]+}},v{{[0-9]+}},r{{[0-9]+}})
  74 define void @test8(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
  75 entry:
  76   %0 = tail call <16 x i32> @llvm.hexagon.V6.vlalignb(<16 x i32> %a, <16 x i32> %b, i32 %c)
  77   store <16 x i32> %0, <16 x i32>* @k, align 64
  78   ret void
  79 }
  80
  81 ; CHECK-LABEL: test9:
  82 ; CHECK: v{{[0-9]+}}.h = vasr(v{{[0-9]+}}.w,v{{[0-9]+}}.w,r{{[0-9]+}})
  83 define void @test9(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
  84 entry:
  85   %0 = tail call <16 x i32> @llvm.hexagon.V6.vasrwh(<16 x i32> %a, <16 x i32> %b, i32 %c)
  86   store <16 x i32> %0, <16 x i32>* @k, align 64
  87   ret void
  88 }
  89
  90 ; CHECK-LABEL: test10:
  91 ; CHECK: v{{[0-9]+}}.h = vasr(v{{[0-9]+}}.w,v{{[0-9]+}}.w,r{{[0-9]+}}):sat
  92 define void @test10(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
  93 entry:
  94   %0 = tail call <16 x i32> @llvm.hexagon.V6.vasrwhsat(<16 x i32> %a, <16 x i32> %b, i32 %c)
  95   store <16 x i32> %0, <16 x i32>* @k, align 64
  96   ret void
  97 }
  98
  99 ; CHECK-LABEL: test11:
 100 ; CHECK: v{{[0-9]+}}.h = vasr(v{{[0-9]+}}.w,v{{[0-9]+}}.w,r{{[0-9]+}}):rnd:sat
 101 define void @test11(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 102 entry:
 103   %0 = tail call <16 x i32> @llvm.hexagon.V6.vasrwhrndsat(<16 x i32> %a, <16 x i32> %b, i32 %c)
 104   store <16 x i32> %0, <16 x i32>* @k, align 64
 105   ret void
 106 }
 107
 108 ; CHECK-LABEL: test12:
 109 ; CHECK: v{{[0-9]+}}.uh = vasr(v{{[0-9]+}}.w,v{{[0-9]+}}.w,r{{[0-9]+}}):sat
 110 define void @test12(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 111 entry:
 112   %0 = tail call <16 x i32> @llvm.hexagon.V6.vasrwuhsat(<16 x i32> %a, <16 x i32> %b, i32 %c)
 113   store <16 x i32> %0, <16 x i32>* @k, align 64
 114   ret void
 115 }
 116
 117 ; CHECK-LABEL: test13:
 118 ; CHECK: v{{[0-9]+}}.ub = vasr(v{{[0-9]+}}.h,v{{[0-9]+}}.h,r{{[0-9]+}}):sat
 119 define void @test13(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 120 entry:
 121   %0 = tail call <16 x i32> @llvm.hexagon.V6.vasrhubsat(<16 x i32> %a, <16 x i32> %b, i32 %c)
 122   store <16 x i32> %0, <16 x i32>* @k, align 64
 123   ret void
 124 }
 125
 126 ; CHECK-LABEL: test14:
 127 ; CHECK: v{{[0-9]+}}.ub = vasr(v{{[0-9]+}}.h,v{{[0-9]+}}.h,r{{[0-9]+}}):rnd:sat
 128 define void @test14(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 129 entry:
 130   %0 = tail call <16 x i32> @llvm.hexagon.V6.vasrhubrndsat(<16 x i32> %a, <16 x i32> %b, i32 %c)
 131   store <16 x i32> %0, <16 x i32>* @k, align 64
 132   ret void
 133 }
 134
 135 ; CHECK-LABEL: test15:
 136 ; CHECK: v{{[0-9]+}}.b = vasr(v{{[0-9]+}}.h,v{{[0-9]+}}.h,r{{[0-9]+}}):rnd:sat
 137 define void @test15(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 138 entry:
 139   %0 = tail call <16 x i32> @llvm.hexagon.V6.vasrhbrndsat(<16 x i32> %a, <16 x i32> %b, i32 %c)
 140   store <16 x i32> %0, <16 x i32>* @k, align 64
 141   ret void
 142 }
 143
 144 ; CHECK-LABEL: test16:
 145 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.h |= vunpacko(v{{[0-9]+}}.b)
 146 define void @test16(<32 x i32> %a, <16 x i32> %b) #0 {
 147 entry:
 148   %0 = tail call <32 x i32> @llvm.hexagon.V6.vunpackob(<32 x i32> %a, <16 x i32> %b)
 149   store <32 x i32> %0, <32 x i32>* @l, align 128
 150   ret void
 151 }
 152
 153 ; CHECK-LABEL: test17:
 154 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.w |= vunpacko(v{{[0-9]+}}.h)
 155 define void @test17(<32 x i32> %a, <16 x i32> %b) #0 {
 156 entry:
 157   %0 = tail call <32 x i32> @llvm.hexagon.V6.vunpackoh(<32 x i32> %a, <16 x i32> %b)
 158   store <32 x i32> %0, <32 x i32>* @l, align 128
 159   ret void
 160 }
 161
 162 ; CHECK-LABEL: test18:
 163 ; CHECK: v{{[0-9]+}} = valign(v{{[0-9]+}},v{{[0-9]+}},#3)
 164 define void @test18(<16 x i32> %a, <16 x i32> %b) #0 {
 165 entry:
 166   %0 = tail call <16 x i32> @llvm.hexagon.V6.valignbi(<16 x i32> %a, <16 x i32> %b, i32 3)
 167   store <16 x i32> %0, <16 x i32>* @k, align 64
 168   ret void
 169 }
 170
 171 ; CHECK-LABEL: test19:
 172 ; CHECK: v{{[0-9]+}} = vlalign(v{{[0-9]+}},v{{[0-9]+}},#3)
 173 define void @test19(<16 x i32> %a, <16 x i32> %b) #0 {
 174 entry:
 175   %0 = tail call <16 x i32> @llvm.hexagon.V6.vlalignbi(<16 x i32> %a, <16 x i32> %b, i32 3)
 176   store <16 x i32> %0, <16 x i32>* @k, align 64
 177   ret void
 178 }
 179
 180 ; CHECK-LABEL: test20:
 181 ; CHECK: v{{[0-9]+}} = vmux(q{{[0-3]+}},v{{[0-9]+}},v{{[0-9]+}})
 182 define void @test20(<16 x i32> %a, <16 x i32> %b, <16 x i32> %c) #0 {
 183 entry:
 184   %0 = bitcast <16 x i32> %a to <512 x i1>
 185   %1 = tail call <16 x i32> @llvm.hexagon.V6.vmux(<512 x i1> %0, <16 x i32> %b, <16 x i32> %c)
 186   store <16 x i32> %1, <16 x i32>* @k, align 64
 187   ret void
 188 }
 189
 190 ; CHECK-LABEL: test21:
 191 ; CHECK: q{{[0-3]+}} = and(q{{[0-3]+}},q{{[0-3]+}})
 192 define void @test21(<16 x i32> %a, <16 x i32> %b) #0 {
 193 entry:
 194   %0 = bitcast <16 x i32> %a to <512 x i1>
 195   %1 = bitcast <16 x i32> %b to <512 x i1>
 196   %2 = tail call <512 x i1> @llvm.hexagon.V6.pred.and(<512 x i1> %0, <512 x i1> %1)
 197   store <512 x i1> %2, <512 x i1>* bitcast (<16 x i32>* @h to <512 x i1>*), align 64
 198   ret void
 199 }
 200
 201 ; CHECK-LABEL: test22:
 202 ; CHECK: q{{[0-3]+}} = or(q{{[0-3]+}},q{{[0-3]+}})
 203 define void @test22(<16 x i32> %a, <16 x i32> %b) #0 {
 204 entry:
 205   %0 = bitcast <16 x i32> %a to <512 x i1>
 206   %1 = bitcast <16 x i32> %b to <512 x i1>
 207   %2 = tail call <512 x i1> @llvm.hexagon.V6.pred.or(<512 x i1> %0, <512 x i1> %1)
 208   store <512 x i1> %2, <512 x i1>* bitcast (<16 x i32>* @h to <512 x i1>*), align 64
 209   ret void
 210 }
 211
 212 ; CHECK-LABEL: test23:
 213 ; CHECK: q{{[0-3]+}} = not(q{{[0-3]+}})
 214 define void @test23(<16 x i32> %a) #0 {
 215 entry:
 216   %0 = bitcast <16 x i32> %a to <512 x i1>
 217   %1 = tail call <512 x i1> @llvm.hexagon.V6.pred.not(<512 x i1> %0)
 218   store <512 x i1> %1, <512 x i1>* bitcast (<16 x i32>* @h to <512 x i1>*), align 64
 219   ret void
 220 }
 221
 222 ; CHECK-LABEL: test24:
 223 ; CHECK: q{{[0-3]+}} = xor(q{{[0-3]+}},q{{[0-3]+}})
 224 define void @test24(<16 x i32> %a, <16 x i32> %b) #0 {
 225 entry:
 226   %0 = bitcast <16 x i32> %a to <512 x i1>
 227   %1 = bitcast <16 x i32> %b to <512 x i1>
 228   %2 = tail call <512 x i1> @llvm.hexagon.V6.pred.xor(<512 x i1> %0, <512 x i1> %1)
 229   store <512 x i1> %2, <512 x i1>* bitcast (<16 x i32>* @h to <512 x i1>*), align 64
 230   ret void
 231 }
 232
 233 ; CHECK-LABEL: test25:
 234 ; CHECK: q{{[0-3]+}} = or(q{{[0-3]+}},!q{{[0-3]+}})
 235 define void @test25(<16 x i32> %a, <16 x i32> %b) #0 {
 236 entry:
 237   %0 = bitcast <16 x i32> %a to <512 x i1>
 238   %1 = bitcast <16 x i32> %b to <512 x i1>
 239   %2 = tail call <512 x i1> @llvm.hexagon.V6.pred.or.n(<512 x i1> %0, <512 x i1> %1)
 240   store <512 x i1> %2, <512 x i1>* bitcast (<16 x i32>* @h to <512 x i1>*), align 64
 241   ret void
 242 }
 243
 244 ; CHECK-LABEL: test26:
 245 ; CHECK: q{{[0-3]+}} = and(q{{[0-3]+}},!q{{[0-3]+}})
 246 define void @test26(<16 x i32> %a, <16 x i32> %b) #0 {
 247 entry:
 248   %0 = bitcast <16 x i32> %a to <512 x i1>
 249   %1 = bitcast <16 x i32> %b to <512 x i1>
 250   %2 = tail call <512 x i1> @llvm.hexagon.V6.pred.and.n(<512 x i1> %0, <512 x i1> %1)
 251   store <512 x i1> %2, <512 x i1>* bitcast (<16 x i32>* @h to <512 x i1>*), align 64
 252   ret void
 253 }
 254
 255 ; CHECK-LABEL: test27:
 256 ; CHECK: q{{[0-3]+}} = vcmp.gt(v{{[0-9]+}}.ub,v{{[0-9]+}}.ub)
 257 define void @test27(<16 x i32> %a, <16 x i32> %b) #0 {
 258 entry:
 259   %0 = tail call <512 x i1> @llvm.hexagon.V6.vgtub(<16 x i32> %a, <16 x i32> %b)
 260   store <512 x i1> %0, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 261   ret void
 262 }
 263
 264 ; CHECK-LABEL: test28:
 265 ; CHECK: q{{[0-3]+}} = vcmp.gt(v{{[0-9]+}}.h,v{{[0-9]+}}.h)
 266 define void @test28(<16 x i32> %a, <16 x i32> %b) #0 {
 267 entry:
 268   %0 = tail call <512 x i1> @llvm.hexagon.V6.vgth(<16 x i32> %a, <16 x i32> %b)
 269   store <512 x i1> %0, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 270   ret void
 271 }
 272
 273 ; CHECK-LABEL: test29:
 274 ; CHECK: q{{[0-3]+}} = vcmp.eq(v{{[0-9]+}}.h,v{{[0-9]+}}.h)
 275 define void @test29(<16 x i32> %a, <16 x i32> %b) #0 {
 276 entry:
 277   %0 = tail call <512 x i1> @llvm.hexagon.V6.veqh(<16 x i32> %a, <16 x i32> %b)
 278   store <512 x i1> %0, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 279   ret void
 280 }
 281
 282 ; CHECK-LABEL: test30:
 283 ; CHECK: q{{[0-3]+}} = vcmp.gt(v{{[0-9]+}}.w,v{{[0-9]+}}.w)
 284 define void @test30(<16 x i32> %a, <16 x i32> %b) #0 {
 285 entry:
 286   %0 = tail call <512 x i1> @llvm.hexagon.V6.vgtw(<16 x i32> %a, <16 x i32> %b)
 287   store <512 x i1> %0, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 288   ret void
 289 }
 290
 291 ; CHECK-LABEL: test31:
 292 ; CHECK: q{{[0-3]+}} = vcmp.eq(v{{[0-9]+}}.w,v{{[0-9]+}}.w)
 293 define void @test31(<16 x i32> %a, <16 x i32> %b) #0 {
 294 entry:
 295   %0 = tail call <512 x i1> @llvm.hexagon.V6.veqw(<16 x i32> %a, <16 x i32> %b)
 296   store <512 x i1> %0, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 297   ret void
 298 }
 299
 300 ; CHECK-LABEL: test32:
 301 ; CHECK: q{{[0-3]+}} = vcmp.gt(v{{[0-9]+}}.uh,v{{[0-9]+}}.uh)
 302 define void @test32(<16 x i32> %a, <16 x i32> %b) #0 {
 303 entry:
 304   %0 = tail call <512 x i1> @llvm.hexagon.V6.vgtuh(<16 x i32> %a, <16 x i32> %b)
 305   store <512 x i1> %0, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 306   ret void
 307 }
 308
 309 ; CHECK-LABEL: test33:
 310 ; CHECK: v{{[0-9]+}} |= vand(q{{[0-3]+}},r{{[0-9]+}})
 311 define void @test33(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 312 entry:
 313   %0 = bitcast <16 x i32> %b to <512 x i1>
 314   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt.acc(<16 x i32> %a, <512 x i1> %0, i32 %c)
 315   store <16 x i32> %1, <16 x i32>* @h, align 64
 316   ret void
 317 }
 318
 319 ; CHECK-LABEL: test34:
 320 ; CHECK: q{{[0-3]+}} |= vand(v{{[0-9]+}},r{{[0-9]+}})
 321 define void @test34(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 322 entry:
 323   %0 = bitcast <16 x i32> %a to <512 x i1>
 324   %1 = tail call <512 x i1> @llvm.hexagon.V6.vandvrt.acc(<512 x i1> %0, <16 x i32> %b, i32 %c)
 325   store <512 x i1> %1, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 326   ret void
 327 }
 328
 329 ; CHECK-LABEL: test35:
 330 ; CHECK: v{{[0-9]+}} = vand(q{{[0-3]+}},r{{[0-9]+}})
 331 define void @test35(<16 x i32> %a, i32 %b) #0 {
 332 entry:
 333   %0 = bitcast <16 x i32> %a to <512 x i1>
 334   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<512 x i1> %0, i32 %b)
 335   store <16 x i32> %1, <16 x i32>* @h, align 64
 336   ret void
 337 }
 338
 339 ; CHECK-LABEL: test36:
 340 ; CHECK: q{{[0-3]+}} = vand(v{{[0-9]+}},r{{[0-9]+}})
 341 define void @test36(<16 x i32> %a, i32 %b) #0 {
 342 entry:
 343   %0 = tail call <512 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 %b)
 344   store <512 x i1> %0, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 345   ret void
 346 }
 347
 348 ; CHECK-LABEL: test37:
 349 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} = rol(r{{[0-9]+}}:{{[0-9]+}},#38)
 350 define void @test37(i64 %a) #0 {
 351 entry:
 352   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p(i64 %a, i32 38)
 353   store i64 %0, i64* @n, align 8
 354   ret void
 355 }
 356
 357 ; CHECK-LABEL: test38:
 358 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} += rol(r{{[0-9]+}}:{{[0-9]+}},#36)
 359 define void @test38(i64 %a, i64 %b) #0 {
 360 entry:
 361   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.acc(i64 %a, i64 %b, i32 36)
 362   store i64 %0, i64* @n, align 8
 363   ret void
 364 }
 365
 366 ; CHECK-LABEL: test39:
 367 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} &= rol(r{{[0-9]+}}:{{[0-9]+}},#25)
 368 define void @test39(i64 %a, i64 %b) #0 {
 369 entry:
 370   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.and(i64 %a, i64 %b, i32 25)
 371   store i64 %0, i64* @n, align 8
 372   ret void
 373 }
 374
 375 ; CHECK-LABEL: test40:
 376 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} -= rol(r{{[0-9]+}}:{{[0-9]+}},#20)
 377 define void @test40(i64 %a, i64 %b) #0 {
 378 entry:
 379   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.nac(i64 %a, i64 %b, i32 20)
 380   store i64 %0, i64* @n, align 8
 381   ret void
 382 }
 383
 384 ; CHECK-LABEL: test41:
 385 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} |= rol(r{{[0-9]+}}:{{[0-9]+}},#22)
 386 define void @test41(i64 %a, i64 %b) #0 {
 387 entry:
 388   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.or(i64 %a, i64 %b, i32 22)
 389   store i64 %0, i64* @n, align 8
 390   ret void
 391 }
 392
 393 ; CHECK-LABEL: test42:
 394 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} ^= rol(r{{[0-9]+}}:{{[0-9]+}},#25)
 395 define void @test42(i64 %a, i64 %b) #0 {
 396 entry:
 397   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.xacc(i64 %a, i64 %b, i32 25)
 398   store i64 %0, i64* @n, align 8
 399   ret void
 400 }
 401
 402 ; CHECK-LABEL: test43:
 403 ; CHECK: r{{[0-9]+}} = rol(r{{[0-9]+}},#14)
 404 define void @test43(i32 %a) #0 {
 405 entry:
 406   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r(i32 %a, i32 14)
 407   %conv = sext i32 %0 to i64
 408   store i64 %conv, i64* @n, align 8
 409   ret void
 410 }
 411
 412 ; CHECK-LABEL: test44:
 413 ; CHECK: r{{[0-9]+}} += rol(r{{[0-9]+}},#12)
 414 define void @test44(i32 %a, i32 %b) #0 {
 415 entry:
 416   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.acc(i32 %a, i32 %b, i32 12)
 417   store i32 %0, i32* @m, align 4
 418   ret void
 419 }
 420
 421 ; CHECK-LABEL: test45:
 422 ; CHECK: r{{[0-9]+}} &= rol(r{{[0-9]+}},#18)
 423 define void @test45(i32 %a, i32 %b) #0 {
 424 entry:
 425   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.and(i32 %a, i32 %b, i32 18)
 426   store i32 %0, i32* @m, align 4
 427   ret void
 428 }
 429
 430 ; CHECK-LABEL: test46:
 431 ; CHECK: r{{[0-9]+}} -= rol(r{{[0-9]+}},#31)
 432 define void @test46(i32 %a, i32 %b) #0 {
 433 entry:
 434   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.nac(i32 %a, i32 %b, i32 31)
 435   store i32 %0, i32* @m, align 4
 436   ret void
 437 }
 438
 439 ; CHECK-LABEL: test47:
 440 ; CHECK: r{{[0-9]+}} |= rol(r{{[0-9]+}},#30)
 441 define void @test47(i32 %a, i32 %b) #0 {
 442 entry:
 443   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.or(i32 %a, i32 %b, i32 30)
 444   store i32 %0, i32* @m, align 4
 445   ret void
 446 }
 447
 448 ; CHECK-LABEL: test48:
 449 ; CHECK: r{{[0-9]+}} ^= rol(r{{[0-9]+}},#31)
 450 define void @test48(i32 %a, i32 %b) #0 {
 451 entry:
 452   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.xacc(i32 %a, i32 %b, i32 31)
 453   store i32 %0, i32* @m, align 4
 454   ret void
 455 }
 456
 457 ; CHECK-LABEL: test49:
 458 ; CHECK: r{{[0-9]+}} = vextract(v{{[0-9]+}},r{{[0-9]+}})
 459 define void @test49(<16 x i32> %a, i32 %b) #0 {
 460 entry:
 461   %0 = tail call i32 @llvm.hexagon.V6.extractw(<16 x i32> %a, i32 %b)
 462   store i32 %0, i32* @m, align 4
 463   ret void
 464 }
 465
 466 ; CHECK-LABEL: test50:
 467 ; CHECK: v{{[0-9]+}} = vsplat(r{{[0-9]+}})
 468 define void @test50(i32 %a) #0 {
 469 entry:
 470   %0 = tail call <16 x i32> @llvm.hexagon.V6.lvsplatw(i32 %a)
 471   store <16 x i32> %0, <16 x i32>* @k, align 64
 472   ret void
 473 }
 474
 475 ; CHECK-LABEL: test51:
 476 ; CHECK: q{{[0-3]}} = vsetq(r{{[0-9]+}})
 477 define void @test51(i32 %a) #0 {
 478 entry:
 479   %0 = tail call <512 x i1> @llvm.hexagon.V6.pred.scalar2(i32 %a)
 480   store <512 x i1> %0, <512 x i1>* bitcast (<16 x i32>* @k to <512 x i1>*), align 64
 481   ret void
 482 }
 483
 484 ; CHECK-LABEL: test52:
 485 ; CHECK: v{{[0-9]+}}.b = vlut32(v{{[0-9]+}}.b,v{{[0-9]+}}.b,r{{[0-9]+}})
 486 define void @test52(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 487 entry:
 488   %0 = tail call <16 x i32> @llvm.hexagon.V6.vlutvvb(<16 x i32> %a, <16 x i32> %b, i32 %c)
 489   store <16 x i32> %0, <16 x i32>* @k, align 64
 490   ret void
 491 }
 492
 493 ; CHECK-LABEL: test53:
 494 ; CHECK: v{{[0-9]+}}.b |= vlut32(v{{[0-9]+}}.b,v{{[0-9]+}}.b,r{{[0-9]+}})
 495 define void @test53(<16 x i32> %a, <16 x i32> %b, <16 x i32> %c, i32 %d) #0 {
 496 entry:
 497   %0 = tail call <16 x i32> @llvm.hexagon.V6.vlutvvb.oracc(<16 x i32> %a, <16 x i32> %b, <16 x i32> %c, i32 %d)
 498   store <16 x i32> %0, <16 x i32>* @k, align 64
 499   ret void
 500 }
 501
 502 ; CHECK-LABEL: test54:
 503 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.h |= vlut16(v{{[0-9]+}}.b,v{{[0-9]+}}.h,r{{[0-9]+}})
 504 define void @test54(<32 x i32> %a, <16 x i32> %b, <16 x i32> %c, i32 %d) #0 {
 505 entry:
 506   %0 = tail call <32 x i32> @llvm.hexagon.V6.vlutvwh.oracc(<32 x i32> %a, <16 x i32> %b, <16 x i32> %c, i32 %d)
 507   store <32 x i32> %0, <32 x i32>* @l, align 128
 508   ret void
 509 }
 510
 511 ; CHECK-LABEL: test55:
 512 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.h = vlut16(v{{[0-9]+}}.b,v{{[0-9]+}}.h,r{{[0-9]+}})
 513 define void @test55(<16 x i32> %a, <16 x i32> %b, i32 %l) #0 {
 514 entry:
 515   %0 = tail call <32 x i32> @llvm.hexagon.V6.vlutvwh(<16 x i32> %a, <16 x i32> %b, i32 %l)
 516   store <32 x i32> %0, <32 x i32>* @l, align 128
 517   ret void
 518 }
 519
 520 ; CHECK-LABEL: test56:
 521 ; CHECK: v{{[0-9]+}}.w = vinsert(r{{[0-9]+}})
 522 define void @test56(i32 %b) #0 {
 523 entry:
 524   %0 = load <16 x i32>, <16 x i32>* @k, align 64
 525   %1 = tail call <16 x i32> @llvm.hexagon.V6.vinsertwr(<16 x i32> %0, i32 %b)
 526   store <16 x i32> %1, <16 x i32>* @k, align 64
 527   ret void
 528 }
 529
 530 declare <32 x i32> @llvm.hexagon.V6.vrmpybusi(<32 x i32>, i32, i32) #0
 531 declare <32 x i32> @llvm.hexagon.V6.vrsadubi(<32 x i32>, i32, i32) #0
 532 declare <32 x i32> @llvm.hexagon.V6.vrmpyubi(<32 x i32>, i32, i32) #0
 533 declare <32 x i32> @llvm.hexagon.V6.vrmpybusi.acc(<32 x i32>, <32 x i32>, i32, i32) #0
 534 declare <32 x i32> @llvm.hexagon.V6.vrsadubi.acc(<32 x i32>, <32 x i32>, i32, i32) #0
 535 declare <32 x i32> @llvm.hexagon.V6.vrmpyubi.acc(<32 x i32>, <32 x i32>, i32, i32) #0
 536 declare <16 x i32> @llvm.hexagon.V6.valignb(<16 x i32>, <16 x i32>, i32) #0
 537 declare <16 x i32> @llvm.hexagon.V6.vlalignb(<16 x i32>, <16 x i32>, i32) #0
 538 declare <16 x i32> @llvm.hexagon.V6.vasrwh(<16 x i32>, <16 x i32>, i32) #0
 539 declare <16 x i32> @llvm.hexagon.V6.vasrwhsat(<16 x i32>, <16 x i32>, i32) #0
 540 declare <16 x i32> @llvm.hexagon.V6.vasrwhrndsat(<16 x i32>, <16 x i32>, i32) #0
 541 declare <16 x i32> @llvm.hexagon.V6.vasrwuhsat(<16 x i32>, <16 x i32>, i32) #0
 542 declare <16 x i32> @llvm.hexagon.V6.vasrhubsat(<16 x i32>, <16 x i32>, i32) #0
 543 declare <16 x i32> @llvm.hexagon.V6.vasrhubrndsat(<16 x i32>, <16 x i32>, i32) #0
 544 declare <16 x i32> @llvm.hexagon.V6.vasrhbrndsat(<16 x i32>, <16 x i32>, i32) #0
 545 declare <32 x i32> @llvm.hexagon.V6.vunpackob(<32 x i32>, <16 x i32>) #0
 546 declare <32 x i32> @llvm.hexagon.V6.vunpackoh(<32 x i32>, <16 x i32>) #0
 547 declare <16 x i32> @llvm.hexagon.V6.valignbi(<16 x i32>, <16 x i32>, i32) #0
 548 declare <16 x i32> @llvm.hexagon.V6.vlalignbi(<16 x i32>, <16 x i32>, i32) #0
 549 declare <16 x i32> @llvm.hexagon.V6.vmux(<512 x i1>, <16 x i32>, <16 x i32>) #0
 550 declare <512 x i1> @llvm.hexagon.V6.pred.and(<512 x i1>, <512 x i1>) #0
 551 declare <512 x i1> @llvm.hexagon.V6.pred.or(<512 x i1>, <512 x i1>) #0
 552 declare <512 x i1> @llvm.hexagon.V6.pred.not(<512 x i1>) #0
 553 declare <512 x i1> @llvm.hexagon.V6.pred.xor(<512 x i1>, <512 x i1>) #0
 554 declare <512 x i1> @llvm.hexagon.V6.pred.or.n(<512 x i1>, <512 x i1>) #0
 555 declare <512 x i1> @llvm.hexagon.V6.pred.and.n(<512 x i1>, <512 x i1>) #0
 556 declare <512 x i1> @llvm.hexagon.V6.vgtub(<16 x i32>, <16 x i32>) #0
 557 declare <512 x i1> @llvm.hexagon.V6.vgth(<16 x i32>, <16 x i32>) #0
 558 declare <512 x i1> @llvm.hexagon.V6.veqh(<16 x i32>, <16 x i32>) #0
 559 declare <512 x i1> @llvm.hexagon.V6.vgtw(<16 x i32>, <16 x i32>) #0
 560 declare <512 x i1> @llvm.hexagon.V6.veqw(<16 x i32>, <16 x i32>) #0
 561 declare <512 x i1> @llvm.hexagon.V6.vgtuh(<16 x i32>, <16 x i32>) #0
 562 declare <16 x i32> @llvm.hexagon.V6.vandqrt.acc(<16 x i32>, <512 x i1>, i32) #0
 563 declare <512 x i1> @llvm.hexagon.V6.vandvrt.acc(<512 x i1>, <16 x i32>, i32) #0
 564 declare <16 x i32> @llvm.hexagon.V6.vandqrt(<512 x i1>, i32) #0
 565 declare <512 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32>, i32) #0
 566 declare i64 @llvm.hexagon.S6.rol.i.p(i64, i32) #0
 567 declare i64 @llvm.hexagon.S6.rol.i.p.acc(i64, i64, i32) #0
 568 declare i64 @llvm.hexagon.S6.rol.i.p.and(i64, i64, i32) #0
 569 declare i64 @llvm.hexagon.S6.rol.i.p.nac(i64, i64, i32) #0
 570 declare i64 @llvm.hexagon.S6.rol.i.p.or(i64, i64, i32) #0
 571 declare i64 @llvm.hexagon.S6.rol.i.p.xacc(i64, i64, i32) #0
 572 declare i32 @llvm.hexagon.S6.rol.i.r(i32, i32) #0
 573 declare i32 @llvm.hexagon.S6.rol.i.r.acc(i32, i32, i32) #0
 574 declare i32 @llvm.hexagon.S6.rol.i.r.and(i32, i32, i32) #0
 575 declare i32 @llvm.hexagon.S6.rol.i.r.nac(i32, i32, i32) #0
 576 declare i32 @llvm.hexagon.S6.rol.i.r.or(i32, i32, i32) #0
 577 declare i32 @llvm.hexagon.S6.rol.i.r.xacc(i32, i32, i32) #0
 578 declare i32 @llvm.hexagon.V6.extractw(<16 x i32>, i32) #0
 579 declare <16 x i32> @llvm.hexagon.V6.lvsplatw(i32) #0
 580 declare <512 x i1> @llvm.hexagon.V6.pred.scalar2(i32) #0
 581 declare <16 x i32> @llvm.hexagon.V6.vlutvvb(<16 x i32>, <16 x i32>, i32) #0
 582 declare <32 x i32> @llvm.hexagon.V6.vlutvwh(<16 x i32>, <16 x i32>, i32) #0
 583 declare <16 x i32> @llvm.hexagon.V6.vlutvvb.oracc(<16 x i32>, <16 x i32>, <16 x i32>, i32) #0
 584 declare <32 x i32> @llvm.hexagon.V6.vlutvwh.oracc(<32 x i32>, <16 x i32>, <16 x i32>, i32) #0
 585 declare <16 x i32> @llvm.hexagon.V6.vinsertwr(<16 x i32>, i32) #0
 586
 587 attributes #0 = { nounwind readnone "target-cpu"="hexagonv60" "target-features"="+hvxv60,+hvx-length64b" }