llvm/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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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, ptr @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 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 185   %1 = tail call <16 x i32> @llvm.hexagon.V6.vmux(<64 x i1> %0, <16 x i32> %b, <16 x i32> %c)
 186   store <16 x i32> %1, ptr @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 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 195   %1 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %b, i32 -1)
 196   %2 = tail call <64 x i1> @llvm.hexagon.V6.pred.and(<64 x i1> %0, <64 x i1> %1)
 197   %3 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %2, i32 -1)
 198   store <16 x i32> %3, ptr @h, align 64
 199   ret void
 200 }
 201
 202 ; CHECK-LABEL: test22:
 203 ; CHECK: q{{[0-3]+}} = or(q{{[0-3]+}},q{{[0-3]+}})
 204 define void @test22(<16 x i32> %a, <16 x i32> %b) #0 {
 205 entry:
 206   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 207   %1 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %b, i32 -1)
 208   %2 = tail call <64 x i1> @llvm.hexagon.V6.pred.or(<64 x i1> %0, <64 x i1> %1)
 209   %3 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %2, i32 -1)
 210   store <16 x i32> %3, ptr @h, align 64
 211   ret void
 212 }
 213
 214 ; CHECK-LABEL: test23:
 215 ; CHECK: q{{[0-3]+}} = not(q{{[0-3]+}})
 216 define void @test23(<16 x i32> %a) #0 {
 217 entry:
 218   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 219   %1 = tail call <64 x i1> @llvm.hexagon.V6.pred.not(<64 x i1> %0)
 220   %2 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %1, i32 -1)
 221   store <16 x i32> %2, ptr @h, align 64
 222   ret void
 223 }
 224
 225 ; CHECK-LABEL: test24:
 226 ; CHECK: q{{[0-3]+}} = xor(q{{[0-3]+}},q{{[0-3]+}})
 227 define void @test24(<16 x i32> %a, <16 x i32> %b) #0 {
 228 entry:
 229   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 230   %1 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %b, i32 -1)
 231   %2 = tail call <64 x i1> @llvm.hexagon.V6.pred.xor(<64 x i1> %0, <64 x i1> %1)
 232   %3 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %2, i32 -1)
 233   store <16 x i32> %3, ptr @h, align 64
 234   ret void
 235 }
 236
 237 ; CHECK-LABEL: test25:
 238 ; CHECK: q{{[0-3]+}} = or(q{{[0-3]+}},!q{{[0-3]+}})
 239 define void @test25(<16 x i32> %a, <16 x i32> %b) #0 {
 240 entry:
 241   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 242   %1 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %b, i32 -1)
 243   %2 = tail call <64 x i1> @llvm.hexagon.V6.pred.or.n(<64 x i1> %0, <64 x i1> %1)
 244   %3 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %2, i32 -1)
 245   store <16 x i32> %3, ptr @h, align 64
 246   ret void
 247 }
 248
 249 ; CHECK-LABEL: test26:
 250 ; CHECK: q{{[0-3]+}} = and(q{{[0-3]+}},!q{{[0-3]+}})
 251 define void @test26(<16 x i32> %a, <16 x i32> %b) #0 {
 252 entry:
 253   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 254   %1 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %b, i32 -1)
 255   %2 = tail call <64 x i1> @llvm.hexagon.V6.pred.and.n(<64 x i1> %0, <64 x i1> %1)
 256   %3 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %2, i32 -1)
 257   store <16 x i32> %3, ptr @h, align 64
 258   ret void
 259 }
 260
 261 ; CHECK-LABEL: test27:
 262 ; CHECK: q{{[0-3]+}} = vcmp.gt(v{{[0-9]+}}.ub,v{{[0-9]+}}.ub)
 263 define void @test27(<16 x i32> %a, <16 x i32> %b) #0 {
 264 entry:
 265   %0 = tail call <64 x i1> @llvm.hexagon.V6.vgtub(<16 x i32> %a, <16 x i32> %b)
 266   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 -1)
 267   store <16 x i32> %1, ptr @k, align 64
 268   ret void
 269 }
 270
 271 ; CHECK-LABEL: test28:
 272 ; CHECK: q{{[0-3]+}} = vcmp.gt(v{{[0-9]+}}.h,v{{[0-9]+}}.h)
 273 define void @test28(<16 x i32> %a, <16 x i32> %b) #0 {
 274 entry:
 275   %0 = tail call <64 x i1> @llvm.hexagon.V6.vgth(<16 x i32> %a, <16 x i32> %b)
 276   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 -1)
 277   store <16 x i32> %1, ptr @k, align 64
 278   ret void
 279 }
 280
 281 ; CHECK-LABEL: test29:
 282 ; CHECK: q{{[0-3]+}} = vcmp.eq(v{{[0-9]+}}.h,v{{[0-9]+}}.h)
 283 define void @test29(<16 x i32> %a, <16 x i32> %b) #0 {
 284 entry:
 285   %0 = tail call <64 x i1> @llvm.hexagon.V6.veqh(<16 x i32> %a, <16 x i32> %b)
 286   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 -1)
 287   store <16 x i32> %1, ptr @k, align 64
 288   ret void
 289 }
 290
 291 ; CHECK-LABEL: test30:
 292 ; CHECK: q{{[0-3]+}} = vcmp.gt(v{{[0-9]+}}.w,v{{[0-9]+}}.w)
 293 define void @test30(<16 x i32> %a, <16 x i32> %b) #0 {
 294 entry:
 295   %0 = tail call <64 x i1> @llvm.hexagon.V6.vgtw(<16 x i32> %a, <16 x i32> %b)
 296   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 -1)
 297   store <16 x i32> %1, ptr @k, align 64
 298   ret void
 299 }
 300
 301 ; CHECK-LABEL: test31:
 302 ; CHECK: q{{[0-3]+}} = vcmp.eq(v{{[0-9]+}}.w,v{{[0-9]+}}.w)
 303 define void @test31(<16 x i32> %a, <16 x i32> %b) #0 {
 304 entry:
 305   %0 = tail call <64 x i1> @llvm.hexagon.V6.veqw(<16 x i32> %a, <16 x i32> %b)
 306   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 -1)
 307   store <16 x i32> %1, ptr @k, align 64
 308   ret void
 309 }
 310
 311 ; CHECK-LABEL: test32:
 312 ; CHECK: q{{[0-3]+}} = vcmp.gt(v{{[0-9]+}}.uh,v{{[0-9]+}}.uh)
 313 define void @test32(<16 x i32> %a, <16 x i32> %b) #0 {
 314 entry:
 315   %0 = tail call <64 x i1> @llvm.hexagon.V6.vgtuh(<16 x i32> %a, <16 x i32> %b)
 316   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 -1)
 317   store <16 x i32> %1, ptr @k, align 64
 318   ret void
 319 }
 320
 321 ; CHECK-LABEL: test33:
 322 ; CHECK: v{{[0-9]+}} |= vand(q{{[0-3]+}},r{{[0-9]+}})
 323 define void @test33(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 324 entry:
 325   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %b, i32 -1)
 326   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt.acc(<16 x i32> %a, <64 x i1> %0, i32 %c)
 327   store <16 x i32> %1, ptr @h, align 64
 328   ret void
 329 }
 330
 331 ; CHECK-LABEL: test34:
 332 ; CHECK: q{{[0-3]+}} |= vand(v{{[0-9]+}},r{{[0-9]+}})
 333 define void @test34(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 334 entry:
 335   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 336   %1 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt.acc(<64 x i1> %0, <16 x i32> %b, i32 %c)
 337   %2 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %1, i32 -1)
 338   store <16 x i32> %2, ptr @k, align 64
 339   ret void
 340 }
 341
 342 ; CHECK-LABEL: test35:
 343 ; CHECK: v{{[0-9]+}} = vand(q{{[0-3]+}},r{{[0-9]+}})
 344 define void @test35(<16 x i32> %a, i32 %b) #0 {
 345 entry:
 346   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 -1)
 347   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 %b)
 348   store <16 x i32> %1, ptr @h, align 64
 349   ret void
 350 }
 351
 352 ; CHECK-LABEL: test36:
 353 ; CHECK: q{{[0-3]+}} = vand(v{{[0-9]+}},r{{[0-9]+}})
 354 define void @test36(<16 x i32> %a, i32 %b) #0 {
 355 entry:
 356   %0 = tail call <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32> %a, i32 %b)
 357   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 -1)
 358   store <16 x i32> %1, ptr @k, align 64
 359   ret void
 360 }
 361
 362 ; CHECK-LABEL: test37:
 363 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} = rol(r{{[0-9]+}}:{{[0-9]+}},#38)
 364 define void @test37(i64 %a) #0 {
 365 entry:
 366   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p(i64 %a, i32 38)
 367   store i64 %0, ptr @n, align 8
 368   ret void
 369 }
 370
 371 ; CHECK-LABEL: test38:
 372 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} += rol(r{{[0-9]+}}:{{[0-9]+}},#36)
 373 define void @test38(i64 %a, i64 %b) #0 {
 374 entry:
 375   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.acc(i64 %a, i64 %b, i32 36)
 376   store i64 %0, ptr @n, align 8
 377   ret void
 378 }
 379
 380 ; CHECK-LABEL: test39:
 381 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} &= rol(r{{[0-9]+}}:{{[0-9]+}},#25)
 382 define void @test39(i64 %a, i64 %b) #0 {
 383 entry:
 384   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.and(i64 %a, i64 %b, i32 25)
 385   store i64 %0, ptr @n, align 8
 386   ret void
 387 }
 388
 389 ; CHECK-LABEL: test40:
 390 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} -= rol(r{{[0-9]+}}:{{[0-9]+}},#20)
 391 define void @test40(i64 %a, i64 %b) #0 {
 392 entry:
 393   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.nac(i64 %a, i64 %b, i32 20)
 394   store i64 %0, ptr @n, align 8
 395   ret void
 396 }
 397
 398 ; CHECK-LABEL: test41:
 399 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} |= rol(r{{[0-9]+}}:{{[0-9]+}},#22)
 400 define void @test41(i64 %a, i64 %b) #0 {
 401 entry:
 402   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.or(i64 %a, i64 %b, i32 22)
 403   store i64 %0, ptr @n, align 8
 404   ret void
 405 }
 406
 407 ; CHECK-LABEL: test42:
 408 ; CHECK: r{{[0-9]+}}:{{[0-9]+}} ^= rol(r{{[0-9]+}}:{{[0-9]+}},#25)
 409 define void @test42(i64 %a, i64 %b) #0 {
 410 entry:
 411   %0 = tail call i64 @llvm.hexagon.S6.rol.i.p.xacc(i64 %a, i64 %b, i32 25)
 412   store i64 %0, ptr @n, align 8
 413   ret void
 414 }
 415
 416 ; CHECK-LABEL: test43:
 417 ; CHECK: r{{[0-9]+}} = rol(r{{[0-9]+}},#14)
 418 define void @test43(i32 %a) #0 {
 419 entry:
 420   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r(i32 %a, i32 14)
 421   %conv = sext i32 %0 to i64
 422   store i64 %conv, ptr @n, align 8
 423   ret void
 424 }
 425
 426 ; CHECK-LABEL: test44:
 427 ; CHECK: r{{[0-9]+}} += rol(r{{[0-9]+}},#12)
 428 define void @test44(i32 %a, i32 %b) #0 {
 429 entry:
 430   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.acc(i32 %a, i32 %b, i32 12)
 431   store i32 %0, ptr @m, align 4
 432   ret void
 433 }
 434
 435 ; CHECK-LABEL: test45:
 436 ; CHECK: r{{[0-9]+}} &= rol(r{{[0-9]+}},#18)
 437 define void @test45(i32 %a, i32 %b) #0 {
 438 entry:
 439   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.and(i32 %a, i32 %b, i32 18)
 440   store i32 %0, ptr @m, align 4
 441   ret void
 442 }
 443
 444 ; CHECK-LABEL: test46:
 445 ; CHECK: r{{[0-9]+}} -= rol(r{{[0-9]+}},#31)
 446 define void @test46(i32 %a, i32 %b) #0 {
 447 entry:
 448   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.nac(i32 %a, i32 %b, i32 31)
 449   store i32 %0, ptr @m, align 4
 450   ret void
 451 }
 452
 453 ; CHECK-LABEL: test47:
 454 ; CHECK: r{{[0-9]+}} |= rol(r{{[0-9]+}},#30)
 455 define void @test47(i32 %a, i32 %b) #0 {
 456 entry:
 457   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.or(i32 %a, i32 %b, i32 30)
 458   store i32 %0, ptr @m, align 4
 459   ret void
 460 }
 461
 462 ; CHECK-LABEL: test48:
 463 ; CHECK: r{{[0-9]+}} ^= rol(r{{[0-9]+}},#31)
 464 define void @test48(i32 %a, i32 %b) #0 {
 465 entry:
 466   %0 = tail call i32 @llvm.hexagon.S6.rol.i.r.xacc(i32 %a, i32 %b, i32 31)
 467   store i32 %0, ptr @m, align 4
 468   ret void
 469 }
 470
 471 ; CHECK-LABEL: test49:
 472 ; CHECK: r{{[0-9]+}} = vextract(v{{[0-9]+}},r{{[0-9]+}})
 473 define void @test49(<16 x i32> %a, i32 %b) #0 {
 474 entry:
 475   %0 = tail call i32 @llvm.hexagon.V6.extractw(<16 x i32> %a, i32 %b)
 476   store i32 %0, ptr @m, align 4
 477   ret void
 478 }
 479
 480 ; CHECK-LABEL: test50:
 481 ; CHECK: v{{[0-9]+}} = vsplat(r{{[0-9]+}})
 482 define void @test50(i32 %a) #0 {
 483 entry:
 484   %0 = tail call <16 x i32> @llvm.hexagon.V6.lvsplatw(i32 %a)
 485   store <16 x i32> %0, ptr @k, align 64
 486   ret void
 487 }
 488
 489 ; CHECK-LABEL: test51:
 490 ; CHECK: q{{[0-3]}} = vsetq(r{{[0-9]+}})
 491 define void @test51(i32 %a) #0 {
 492 entry:
 493   %0 = tail call <64 x i1> @llvm.hexagon.V6.pred.scalar2(i32 %a)
 494   %1 = tail call <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1> %0, i32 -1)
 495   store <16 x i32> %1, ptr @k, align 64
 496   ret void
 497 }
 498
 499 ; CHECK-LABEL: test52:
 500 ; CHECK: v{{[0-9]+}}.b = vlut32(v{{[0-9]+}}.b,v{{[0-9]+}}.b,r{{[0-9]+}})
 501 define void @test52(<16 x i32> %a, <16 x i32> %b, i32 %c) #0 {
 502 entry:
 503   %0 = tail call <16 x i32> @llvm.hexagon.V6.vlutvvb(<16 x i32> %a, <16 x i32> %b, i32 %c)
 504   store <16 x i32> %0, ptr @k, align 64
 505   ret void
 506 }
 507
 508 ; CHECK-LABEL: test53:
 509 ; CHECK: v{{[0-9]+}}.b |= vlut32(v{{[0-9]+}}.b,v{{[0-9]+}}.b,r{{[0-9]+}})
 510 define void @test53(<16 x i32> %a, <16 x i32> %b, <16 x i32> %c, i32 %d) #0 {
 511 entry:
 512   %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)
 513   store <16 x i32> %0, ptr @k, align 64
 514   ret void
 515 }
 516
 517 ; CHECK-LABEL: test54:
 518 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.h |= vlut16(v{{[0-9]+}}.b,v{{[0-9]+}}.h,r{{[0-9]+}})
 519 define void @test54(<32 x i32> %a, <16 x i32> %b, <16 x i32> %c, i32 %d) #0 {
 520 entry:
 521   %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)
 522   store <32 x i32> %0, ptr @l, align 128
 523   ret void
 524 }
 525
 526 ; CHECK-LABEL: test55:
 527 ; CHECK: v{{[0-9]+}}:{{[0-9]+}}.h = vlut16(v{{[0-9]+}}.b,v{{[0-9]+}}.h,r{{[0-9]+}})
 528 define void @test55(<16 x i32> %a, <16 x i32> %b, i32 %l) #0 {
 529 entry:
 530   %0 = tail call <32 x i32> @llvm.hexagon.V6.vlutvwh(<16 x i32> %a, <16 x i32> %b, i32 %l)
 531   store <32 x i32> %0, ptr @l, align 128
 532   ret void
 533 }
 534
 535 ; CHECK-LABEL: test56:
 536 ; CHECK: v{{[0-9]+}}.w = vinsert(r{{[0-9]+}})
 537 define void @test56(i32 %b) #0 {
 538 entry:
 539   %0 = load <16 x i32>, ptr @k, align 64
 540   %1 = tail call <16 x i32> @llvm.hexagon.V6.vinsertwr(<16 x i32> %0, i32 %b)
 541   store <16 x i32> %1, ptr @k, align 64
 542   ret void
 543 }
 544
 545 declare <32 x i32> @llvm.hexagon.V6.vrmpybusi(<32 x i32>, i32, i32) #0
 546 declare <32 x i32> @llvm.hexagon.V6.vrsadubi(<32 x i32>, i32, i32) #0
 547 declare <32 x i32> @llvm.hexagon.V6.vrmpyubi(<32 x i32>, i32, i32) #0
 548 declare <32 x i32> @llvm.hexagon.V6.vrmpybusi.acc(<32 x i32>, <32 x i32>, i32, i32) #0
 549 declare <32 x i32> @llvm.hexagon.V6.vrsadubi.acc(<32 x i32>, <32 x i32>, i32, i32) #0
 550 declare <32 x i32> @llvm.hexagon.V6.vrmpyubi.acc(<32 x i32>, <32 x i32>, i32, i32) #0
 551 declare <16 x i32> @llvm.hexagon.V6.valignb(<16 x i32>, <16 x i32>, i32) #0
 552 declare <16 x i32> @llvm.hexagon.V6.vlalignb(<16 x i32>, <16 x i32>, i32) #0
 553 declare <16 x i32> @llvm.hexagon.V6.vasrwh(<16 x i32>, <16 x i32>, i32) #0
 554 declare <16 x i32> @llvm.hexagon.V6.vasrwhsat(<16 x i32>, <16 x i32>, i32) #0
 555 declare <16 x i32> @llvm.hexagon.V6.vasrwhrndsat(<16 x i32>, <16 x i32>, i32) #0
 556 declare <16 x i32> @llvm.hexagon.V6.vasrwuhsat(<16 x i32>, <16 x i32>, i32) #0
 557 declare <16 x i32> @llvm.hexagon.V6.vasrhubsat(<16 x i32>, <16 x i32>, i32) #0
 558 declare <16 x i32> @llvm.hexagon.V6.vasrhubrndsat(<16 x i32>, <16 x i32>, i32) #0
 559 declare <16 x i32> @llvm.hexagon.V6.vasrhbrndsat(<16 x i32>, <16 x i32>, i32) #0
 560 declare <32 x i32> @llvm.hexagon.V6.vunpackob(<32 x i32>, <16 x i32>) #0
 561 declare <32 x i32> @llvm.hexagon.V6.vunpackoh(<32 x i32>, <16 x i32>) #0
 562 declare <16 x i32> @llvm.hexagon.V6.valignbi(<16 x i32>, <16 x i32>, i32) #0
 563 declare <16 x i32> @llvm.hexagon.V6.vlalignbi(<16 x i32>, <16 x i32>, i32) #0
 564 declare <16 x i32> @llvm.hexagon.V6.vmux(<64 x i1>, <16 x i32>, <16 x i32>) #0
 565 declare <64 x i1> @llvm.hexagon.V6.pred.and(<64 x i1>, <64 x i1>) #0
 566 declare <64 x i1> @llvm.hexagon.V6.pred.or(<64 x i1>, <64 x i1>) #0
 567 declare <64 x i1> @llvm.hexagon.V6.pred.not(<64 x i1>) #0
 568 declare <64 x i1> @llvm.hexagon.V6.pred.xor(<64 x i1>, <64 x i1>) #0
 569 declare <64 x i1> @llvm.hexagon.V6.pred.or.n(<64 x i1>, <64 x i1>) #0
 570 declare <64 x i1> @llvm.hexagon.V6.pred.and.n(<64 x i1>, <64 x i1>) #0
 571 declare <64 x i1> @llvm.hexagon.V6.vgtub(<16 x i32>, <16 x i32>) #0
 572 declare <64 x i1> @llvm.hexagon.V6.vgth(<16 x i32>, <16 x i32>) #0
 573 declare <64 x i1> @llvm.hexagon.V6.veqh(<16 x i32>, <16 x i32>) #0
 574 declare <64 x i1> @llvm.hexagon.V6.vgtw(<16 x i32>, <16 x i32>) #0
 575 declare <64 x i1> @llvm.hexagon.V6.veqw(<16 x i32>, <16 x i32>) #0
 576 declare <64 x i1> @llvm.hexagon.V6.vgtuh(<16 x i32>, <16 x i32>) #0
 577 declare <16 x i32> @llvm.hexagon.V6.vandqrt.acc(<16 x i32>, <64 x i1>, i32) #0
 578 declare <64 x i1> @llvm.hexagon.V6.vandvrt.acc(<64 x i1>, <16 x i32>, i32) #0
 579 declare <16 x i32> @llvm.hexagon.V6.vandqrt(<64 x i1>, i32) #0
 580 declare <64 x i1> @llvm.hexagon.V6.vandvrt(<16 x i32>, i32) #0
 581 declare i64 @llvm.hexagon.S6.rol.i.p(i64, i32) #0
 582 declare i64 @llvm.hexagon.S6.rol.i.p.acc(i64, i64, i32) #0
 583 declare i64 @llvm.hexagon.S6.rol.i.p.and(i64, i64, i32) #0
 584 declare i64 @llvm.hexagon.S6.rol.i.p.nac(i64, i64, i32) #0
 585 declare i64 @llvm.hexagon.S6.rol.i.p.or(i64, i64, i32) #0
 586 declare i64 @llvm.hexagon.S6.rol.i.p.xacc(i64, i64, i32) #0
 587 declare i32 @llvm.hexagon.S6.rol.i.r(i32, i32) #0
 588 declare i32 @llvm.hexagon.S6.rol.i.r.acc(i32, i32, i32) #0
 589 declare i32 @llvm.hexagon.S6.rol.i.r.and(i32, i32, i32) #0
 590 declare i32 @llvm.hexagon.S6.rol.i.r.nac(i32, i32, i32) #0
 591 declare i32 @llvm.hexagon.S6.rol.i.r.or(i32, i32, i32) #0
 592 declare i32 @llvm.hexagon.S6.rol.i.r.xacc(i32, i32, i32) #0
 593 declare i32 @llvm.hexagon.V6.extractw(<16 x i32>, i32) #0
 594 declare <16 x i32> @llvm.hexagon.V6.lvsplatw(i32) #0
 595 declare <64 x i1> @llvm.hexagon.V6.pred.scalar2(i32) #0
 596 declare <16 x i32> @llvm.hexagon.V6.vlutvvb(<16 x i32>, <16 x i32>, i32) #0
 597 declare <32 x i32> @llvm.hexagon.V6.vlutvwh(<16 x i32>, <16 x i32>, i32) #0
 598 declare <16 x i32> @llvm.hexagon.V6.vlutvvb.oracc(<16 x i32>, <16 x i32>, <16 x i32>, i32) #0
 599 declare <32 x i32> @llvm.hexagon.V6.vlutvwh.oracc(<32 x i32>, <16 x i32>, <16 x i32>, i32) #0
 600 declare <16 x i32> @llvm.hexagon.V6.vinsertwr(<16 x i32>, i32) #0
 601
 602 attributes #0 = { nounwind readnone "target-cpu"="hexagonv60" "target-features"="+hvxv60,+hvx-length64b" }