mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 5.18.0.167

Browse Source 
Former-commit-id: 289509151e0fee68a1b591a20c9f109c3c789d3a
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2018-10-20 08:25:10 +00:00
parent e19d552987
commit b084638f15
28489 changed files with 184 additions and 3866856 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
external/llvm/test/MC/Hexagon/instructions/alu32_alu.s vendored
View File

@@ -1,84 +0,0 @@
# RUN: llvm-mc -triple hexagon -filetype=obj %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.1.1 ALU32/ALU
# Add
# CHECK: f1 c3 15 b0
r17 = add(r21, #31)
# CHECK: 11 df 15 f3
r17 = add(r21, r31)
# CHECK: 11 df 55 f6
r17 = add(r21, r31):sat
# And
# CHECK: f1 c3 15 76
r17 = and(r21, #31)
# CHECK: f1 c3 95 76
r17 = or(r21, #31)
# CHECK: 11 df 15 f1
r17 = and(r21, r31)
# CHECK: 11 df 35 f1
r17 = or(r21, r31)
# CHECK: 11 df 75 f1
r17 = xor(r21, r31)
# CHECK: 11 d5 9f f1
r17 = and(r21, ~r31)
# CHECK: 11 d5 bf f1
r17 = or(r21, ~r31)
# Nop
# CHECK: 00 c0 00 7f
nop
# Subtract
# CHECK: b1 c2 5f 76
r17 = sub(#21, r31)
# CHECK: 11 df 35 f3
r17 = sub(r31, r21)
# CHECK: 11 df d5 f6
r17 = sub(r31, r21):sat
# Sign extend
# CHECK: 11 c0 bf 70
r17 = sxtb(r31)
# Transfer immediate
# CHECK: 15 c0 31 72
r17.h = #21
# CHECK: 15 c0 31 71
r17.l = #21
# CHECK: f1 ff 5f 78
r17 = #32767
# CHECK: f1 ff df 78
r17 = #-1
# Transfer register
# CHECK: 11 c0 75 70
r17 = r21
# Vector add halfwords
# CHECK: 11 df 15 f6
r17 = vaddh(r21, r31)
# CHECK: 11 df 35 f6
r17 = vaddh(r21, r31):sat
# CHECK: 11 df 75 f6
r17 = vadduh(r21, r31):sat
# Vector average halfwords
# CHECK: 11 df 15 f7
r17 = vavgh(r21, r31)
# CHECK: 11 df 35 f7
r17 = vavgh(r21, r31):rnd
# CHECK: 11 df 75 f7
r17 = vnavgh(r31, r21)
# Vector subtract halfwords
# CHECK: 11 df 95 f6
r17 = vsubh(r31, r21)
# CHECK: 11 df b5 f6
r17 = vsubh(r31, r21):sat
# CHECK: 11 df f5 f6
r17 = vsubuh(r31, r21):sat
# Zero extend
# CHECK: 11 c0 d5 70
r17 = zxth(r21)

40
external/llvm/test/MC/Hexagon/instructions/alu32_perm.s vendored
View File

@@ -1,40 +0,0 @@
# RUN: llvm-mc -triple hexagon -filetype=obj %s -o - | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.1.2 ALU32/PERM
# Combine words in to doublewords
# CHECK: 11 df 95 f3
r17 = combine(r31.h, r21.h)
# CHECK: 11 df b5 f3
r17 = combine(r31.h, r21.l)
# CHECK: 11 df d5 f3
r17 = combine(r31.l, r21.h)
# CHECK: 11 df f5 f3
r17 = combine(r31.l, r21.l)
# CHECK: b0 e2 0f 7c
r17:16 = combine(#21, #31)
# CHECK: b0 e2 3f 73
r17:16 = combine(#21, r31)
# CHECK: f0 e3 15 73
r17:16 = combine(r21, #31)
# CHECK: 10 df 15 f5
r17:16 = combine(r21, r31)
# Mux
# CHECK: f1 c3 75 73
r17 = mux(p3, r21, #31)
# CHECK: b1 c2 ff 73
r17 = mux(p3, #21, r31)
# CHECK: b1 e2 8f 7b
r17 = mux(p3, #21, #31)
# CHECK: 71 df 15 f4
r17 = mux(p3, r21, r31)
# Shift word by 16
# CHECK: 11 c0 15 70
r17 = aslh(r21)
# CHECK: 11 c0 35 70
r17 = asrh(r21)
# Pack high and low halfwords
# CHECK: 10 df 95 f5
r17:16 = packhl(r21, r31)

222
external/llvm/test/MC/Hexagon/instructions/alu32_pred.s vendored
View File

@@ -1,222 +0,0 @@
# RUN: llvm-mc -triple hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.1.3 ALU32/PRED
# Conditional add
# CHECK: f1 c3 75 74
if (p3) r17 = add(r21, #31)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 e3 75 74
{ p3 = r5
if (p3.new) r17 = add(r21, #31) }
# CHECK: f1 c3 f5 74
if (!p3) r17 = add(r21, #31)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 e3 f5 74
{ p3 = r5
if (!p3.new) r17 = add(r21, #31) }
# CHECK: 71 df 15 fb
if (p3) r17 = add(r21, r31)
# CHECK: 03 40 45 85
# CHECK-NEXT: 71 ff 15 fb
{ p3 = r5
if (p3.new) r17 = add(r21, r31) }
# CHECK: f1 df 15 fb
if (!p3) r17 = add(r21, r31)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 15 fb
{ p3 = r5
if (!p3.new) r17 = add(r21, r31) }
# Conditional shift halfword
# CHECK: 11 e3 15 70
if (p3) r17 = aslh(r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 e7 15 70
{ p3 = r5
if (p3.new) r17 = aslh(r21) }
# CHECK: 11 eb 15 70
if (!p3) r17 = aslh(r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 ef 15 70
{ p3 = r5
if (!p3.new) r17 = aslh(r21) }
# CHECK: 11 e3 35 70
if (p3) r17 = asrh(r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 e7 35 70
{ p3 = r5
if (p3.new) r17 = asrh(r21) }
# CHECK: 11 eb 35 70
if (!p3) r17 = asrh(r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 ef 35 70
{ p3 = r5
if (!p3.new) r17 = asrh(r21) }
# Conditional combine
# CHECK: 70 df 15 fd
if (p3) r17:16 = combine(r21, r31)
# CHECK: f0 df 15 fd
if (!p3) r17:16 = combine(r21, r31)
# CHECK: 03 40 45 85
# CHECK-NEXT: 70 ff 15 fd
{ p3 = r5
if (p3.new) r17:16 = combine(r21, r31) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f0 ff 15 fd
{ p3 = r5
if (!p3.new) r17:16 = combine(r21, r31) }
# Conditional logical operations
# CHECK: 71 df 15 f9
if (p3) r17 = and(r21, r31)
# CHECK: f1 df 15 f9
if (!p3) r17 = and(r21, r31)
# CHECK: 03 40 45 85
# CHECK-NEXT: 71 ff 15 f9
{ p3 = r5
if (p3.new) r17 = and(r21, r31) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 15 f9
{ p3 = r5
if (!p3.new) r17 = and(r21, r31) }
# CHECK: 71 df 35 f9
if (p3) r17 = or(r21, r31)
# CHECK: f1 df 35 f9
if (!p3) r17 = or(r21, r31)
# CHECK: 03 40 45 85
# CHECK-NEXT: 71 ff 35 f9
{ p3 = r5
if (p3.new) r17 = or(r21, r31) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 35 f9
{ p3 = r5
if (!p3.new) r17 = or(r21, r31) }
# CHECK: 71 df 75 f9
if (p3) r17 = xor(r21, r31)
# CHECK: f1 df 75 f9
if (!p3) r17 = xor(r21, r31)
# CHECK: 03 40 45 85
# CHECK-NEXT: 71 ff 75 f9
{ p3 = r5
if (p3.new) r17 = xor(r21, r31) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 75 f9
{ p3 = r5
if (!p3.new) r17 = xor(r21, r31) }
# Conditional subtract
# CHECK: 71 df 35 fb
if (p3) r17 = sub(r31, r21)
# CHECK: f1 df 35 fb
if (!p3) r17 = sub(r31, r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 71 ff 35 fb
{ p3 = r5
if (p3.new) r17 = sub(r31, r21) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 35 fb
{ p3 = r5
if (!p3.new) r17 = sub(r31, r21) }
# Conditional sign extend
# CHECK: 11 e3 b5 70
if (p3) r17 = sxtb(r21)
# CHECK: 11 eb b5 70
if (!p3) r17 = sxtb(r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 e7 b5 70
{ p3 = r5
if (p3.new) r17 = sxtb(r21) }
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 ef b5 70
{ p3 = r5
if (!p3.new) r17 = sxtb(r21) }
# CHECK: 11 e3 f5 70
if (p3) r17 = sxth(r21)
# CHECK: 11 eb f5 70
if (!p3) r17 = sxth(r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 e7 f5 70
{ p3 = r5
if (p3.new) r17 = sxth(r21) }
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 ef f5 70
{ p3 = r5
if (!p3.new) r17 = sxth(r21) }
# Conditional transfer
# CHECK: b1 c2 60 7e
if (p3) r17 = #21
# CHECK: b1 c2 e0 7e
if (!p3) r17 = #21
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 e2 60 7e
{ p3 = r5
if (p3.new) r17 = #21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 e2 e0 7e
{ p3 = r5
if (!p3.new) r17 = #21 }
# Conditional zero extend
# CHECK: 11 e3 95 70
if (p3) r17 = zxtb(r21)
# CHECK: 11 eb 95 70
if (!p3) r17 = zxtb(r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 e7 95 70
{ p3 = r5
if (p3.new) r17 = zxtb(r21) }
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 ef 95 70
{ p3 = r5
if (!p3.new) r17 = zxtb(r21) }
# CHECK: 11 e3 d5 70
if (p3) r17 = zxth(r21)
# CHECK: 11 eb d5 70
if (!p3) r17 = zxth(r21)
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 e7 d5 70
{ p3 = r5
if (p3.new) r17 = zxth(r21) }
# CHECK: 03 40 45 85
# CHECK-NEXT: 11 ef d5 70
{ p3 = r5
if (!p3.new) r17 = zxth(r21) }
# Compare
# CHECK: e3 c3 15 75
p3 = cmp.eq(r21, #31)
# CHECK: f3 c3 15 75
p3 = !cmp.eq(r21, #31)
# CHECK: e3 c3 55 75
p3 = cmp.gt(r21, #31)
# CHECK: f3 c3 55 75
p3 = !cmp.gt(r21, #31)
# CHECK: e3 c3 95 75
p3 = cmp.gtu(r21, #31)
# CHECK: f3 c3 95 75
p3 = !cmp.gtu(r21, #31)
# CHECK: 03 df 15 f2
p3 = cmp.eq(r21, r31)
# CHECK: 13 df 15 f2
p3 = !cmp.eq(r21, r31)
# CHECK: 03 df 55 f2
p3 = cmp.gt(r21, r31)
# CHECK: 13 df 55 f2
p3 = !cmp.gt(r21, r31)
# CHECK: 03 df 75 f2
p3 = cmp.gtu(r21, r31)
# CHECK: 13 df 75 f2
p3 = !cmp.gtu(r21, r31)
# Compare to general register
# CHECK: f1 e3 55 73
r17 = cmp.eq(r21, #31)
# CHECK: f1 e3 75 73
r17 = !cmp.eq(r21, #31)
# CHECK: 11 df 55 f3
r17 = cmp.eq(r21, r31)
# CHECK: 11 df 75 f3
r17 = !cmp.eq(r21, r31)

78
external/llvm/test/MC/Hexagon/instructions/cr.s vendored
View File

@@ -1,78 +0,0 @@
# RUN: llvm-mc --triple hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.2 CR
# Corner detection acceleration
# CHECK: 93 e1 12 6b
p3 = !fastcorner9(p2, p1)
# CHECK: 91 e3 02 6b
p1 = fastcorner9(p2, p3)
# Logical reductions on predicates
# CHECK: 01 c0 82 6b
p1 = any8(p2)
# CHECK: 01 c0 a2 6b
p1 = all8(p2)
# Looping instructions
# CHECK: 00 c0 15 60
loop0(0, r21)
# CHECK: 00 c0 35 60
loop1(0, r21)
# CHECK: 60 c0 00 69
loop0(0, #12)
# CHECK: 60 c0 20 69
loop1(0, #12)
# Add to PC
# CHECK: 91 ca 49 6a
r17 = add(pc, #21)
# Pipelined loop instructions
# CHECK: 00 c0 b5 60
p3 = sp1loop0(0, r21)
# CHECK: 00 c0 d5 60
p3 = sp2loop0(0, r21)
# CHECK: 00 c0 f5 60
p3 = sp3loop0(0, r21)
# CHECK: a1 c0 a0 69
p3 = sp1loop0(0, #21)
# CHECK: a1 c0 c0 69
p3 = sp2loop0(0, #21)
# CHECK: a1 c0 e0 69
p3 = sp3loop0(0, #21)
# Logical operations on predicates
# CHECK: 01 c3 02 6b
p1 = and(p3, p2)
# CHECK: c1 c3 12 6b
p1 = and(p2, and(p3, p3))
# CHECK: 01 c3 22 6b
p1 = or(p3, p2)
# CHECK: c1 c3 32 6b
p1 = and(p2, or(p3, p3))
# CHECK: 01 c3 42 6b
p1 = xor(p2, p3)
# CHECK: c1 c3 52 6b
p1 = or(p2, and(p3, p3))
# CHECK: 01 c2 63 6b
p1 = and(p2, !p3)
# CHECK: c1 c3 72 6b
p1 = or(p2, or(p3, p3))
# CHECK: c1 c3 92 6b
p1 = and(p2, and(p3, !p3))
# CHECK: c1 c3 b2 6b
p1 = and(p2, or(p3, !p3))
# CHECK: 01 c0 c2 6b
p1 = not(p2)
# CHECK: c1 c3 d2 6b
p1 = or(p2, and(p3, !p3))
# CHECK: 01 c2 e3 6b
p1 = or(p2, !p3)
# CHECK: c1 c3 f2 6b
p1 = or(p2, or(p3, !p3))
# User control register transfer
# CHECK: 0d c0 35 62
cs1 = r21
# CHECK: 11 c0 0d 6a
r17 = cs1

206
external/llvm/test/MC/Hexagon/instructions/j.s vendored
View File

@@ -1,206 +0,0 @@
# RUN: llvm-mc -triple hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.4 J
# Call subroutine
# CHECK: 00 c0 00 5a
call 0
# CHECK: 00 c3 00 5d
if (p3) call 0
# CHECK: 00 c3 20 5d
if (!p3) call 0
# Compare and jump
# CHECK: 00 c0 89 11
{ p0 = cmp.eq(r17,#-1); if (p0.new) jump:nt 0 }
# CHECK: 00 c1 89 11
{ p0 = cmp.gt(r17,#-1); if (p0.new) jump:nt 0 }
# CHECK: 00 c3 89 11
{ p0 = tstbit(r17, #0); if (p0.new) jump:nt 0 }
# CHECK: 00 e0 89 11
{ p0 = cmp.eq(r17,#-1); if (p0.new) jump:t 0 }
# CHECK: 00 e1 89 11
{ p0 = cmp.gt(r17,#-1); if (p0.new) jump:t 0 }
# CHECK: 00 e3 89 11
{ p0 = tstbit(r17, #0); if (p0.new) jump:t 0 }
# CHECK: 00 c0 c9 11
{ p0 = cmp.eq(r17,#-1); if (!p0.new) jump:nt 0 }
# CHECK: 00 c1 c9 11
{ p0 = cmp.gt(r17,#-1); if (!p0.new) jump:nt 0 }
# CHECK: 00 c3 c9 11
{ p0 = tstbit(r17, #0); if (!p0.new) jump:nt 0 }
# CHECK: 00 e0 c9 11
{ p0 = cmp.eq(r17,#-1); if (!p0.new) jump:t 0 }
# CHECK: 00 e1 c9 11
{ p0 = cmp.gt(r17,#-1); if (!p0.new) jump:t 0 }
# CHECK: 00 e3 c9 11
{ p0 = tstbit(r17, #0); if (!p0.new) jump:t 0 }
# CHECK: 00 d5 09 10
{ p0 = cmp.eq(r17, #21); if (p0.new) jump:nt 0 }
# CHECK: 00 f5 09 10
{ p0 = cmp.eq(r17, #21); if (p0.new) jump:t 0 }
# CHECK: 00 d5 49 10
{ p0 = cmp.eq(r17, #21); if (!p0.new) jump:nt 0 }
# CHECK: 00 f5 49 10
{ p0 = cmp.eq(r17, #21); if (!p0.new) jump:t 0 }
# CHECK: 00 d5 89 10
{ p0 = cmp.gt(r17, #21); if (p0.new) jump:nt 0 }
# CHECK: 00 f5 89 10
{ p0 = cmp.gt(r17, #21); if (p0.new) jump:t 0 }
# CHECK: 00 d5 c9 10
{ p0 = cmp.gt(r17, #21); if (!p0.new) jump:nt 0 }
# CHECK: 00 f5 c9 10
{ p0 = cmp.gt(r17, #21); if (!p0.new) jump:t 0 }
# CHECK: 00 d5 09 11
{ p0 = cmp.gtu(r17, #21); if (p0.new) jump:nt 0 }
# CHECK: 00 f5 09 11
{ p0 = cmp.gtu(r17, #21); if (p0.new) jump:t 0 }
# CHECK: 00 d5 49 11
{ p0 = cmp.gtu(r17, #21); if (!p0.new) jump:nt 0 }
# CHECK: 00 f5 49 11
{ p0 = cmp.gtu(r17, #21); if (!p0.new) jump:t 0 }
# CHECK: 00 c0 89 13
{ p1 = cmp.eq(r17,#-1); if (p1.new) jump:nt 0 }
# CHECK: 00 c1 89 13
{ p1 = cmp.gt(r17,#-1); if (p1.new) jump:nt 0 }
# CHECK: 00 c3 89 13
{ p1 = tstbit(r17, #0); if (p1.new) jump:nt 0 }
# CHECK: 00 e0 89 13
{ p1 = cmp.eq(r17,#-1); if (p1.new) jump:t 0 }
# CHECK: 00 e1 89 13
{ p1 = cmp.gt(r17,#-1); if (p1.new) jump:t 0 }
# CHECK: 00 e3 89 13
{ p1 = tstbit(r17, #0); if (p1.new) jump:t 0 }
# CHECK: 00 c0 c9 13
{ p1 = cmp.eq(r17,#-1); if (!p1.new) jump:nt 0 }
# CHECK: 00 c1 c9 13
{ p1 = cmp.gt(r17,#-1); if (!p1.new) jump:nt 0 }
# CHECK: 00 c3 c9 13
{ p1 = tstbit(r17, #0); if (!p1.new) jump:nt 0 }
# CHECK: 00 e0 c9 13
{ p1 = cmp.eq(r17,#-1); if (!p1.new) jump:t 0 }
# CHECK: 00 e1 c9 13
{ p1 = cmp.gt(r17,#-1); if (!p1.new) jump:t 0 }
# CHECK: 00 e3 c9 13
{ p1 = tstbit(r17, #0); if (!p1.new) jump:t 0 }
# CHECK: 00 d5 09 12
{ p1 = cmp.eq(r17, #21); if (p1.new) jump:nt 0 }
# CHECK: 00 f5 09 12
{ p1 = cmp.eq(r17, #21); if (p1.new) jump:t 0 }
# CHECK: 00 d5 49 12
{ p1 = cmp.eq(r17, #21); if (!p1.new) jump:nt 0 }
# CHECK: 00 f5 49 12
{ p1 = cmp.eq(r17, #21); if (!p1.new) jump:t 0 }
# CHECK: 00 d5 89 12
{ p1 = cmp.gt(r17, #21); if (p1.new) jump:nt 0 }
# CHECK: 00 f5 89 12
{ p1 = cmp.gt(r17, #21); if (p1.new) jump:t 0 }
# CHECK: 00 d5 c9 12
{ p1 = cmp.gt(r17, #21); if (!p1.new) jump:nt 0 }
# CHECK: 00 f5 c9 12
{ p1 = cmp.gt(r17, #21); if (!p1.new) jump:t 0 }
# CHECK: 00 d5 09 13
{ p1 = cmp.gtu(r17, #21); if (p1.new) jump:nt 0 }
# CHECK: 00 f5 09 13
{ p1 = cmp.gtu(r17, #21); if (p1.new) jump:t 0 }
# CHECK: 00 d5 49 13
{ p1 = cmp.gtu(r17, #21); if (!p1.new) jump:nt 0 }
# CHECK: 00 f5 49 13
{ p1 = cmp.gtu(r17, #21); if (!p1.new) jump:t 0 }
# CHECK: 00 cd 09 14
{ p0 = cmp.eq(r17, r21); if (p0.new) jump:nt 0 }
# CHECK: 00 dd 09 14
{ p1 = cmp.eq(r17, r21); if (p1.new) jump:nt 0 }
# CHECK: 00 ed 09 14
{ p0 = cmp.eq(r17, r21); if (p0.new) jump:t 0 }
# CHECK: 00 fd 09 14
{ p1 = cmp.eq(r17, r21); if (p1.new) jump:t 0 }
# CHECK: 00 cd 49 14
{ p0 = cmp.eq(r17, r21); if (!p0.new) jump:nt 0 }
# CHECK: 00 dd 49 14
{ p1 = cmp.eq(r17, r21); if (!p1.new) jump:nt 0 }
# CHECK: 00 ed 49 14
{ p0 = cmp.eq(r17, r21); if (!p0.new) jump:t 0 }
# CHECK: 00 fd 49 14
{ p1 = cmp.eq(r17, r21); if (!p1.new) jump:t 0 }
# CHECK: 00 cd 89 14
{ p0 = cmp.gt(r17, r21); if (p0.new) jump:nt 0 }
# CHECK: 00 dd 89 14
{ p1 = cmp.gt(r17, r21); if (p1.new) jump:nt 0 }
# CHECK: 00 ed 89 14
{ p0 = cmp.gt(r17, r21); if (p0.new) jump:t 0 }
# CHECK: 00 fd 89 14
{ p1 = cmp.gt(r17, r21); if (p1.new) jump:t 0 }
# CHECK: 00 cd c9 14
{ p0 = cmp.gt(r17, r21); if (!p0.new) jump:nt 0 }
# CHECK: 00 dd c9 14
{ p1 = cmp.gt(r17, r21); if (!p1.new) jump:nt 0 }
# CHECK: 00 ed c9 14
{ p0 = cmp.gt(r17, r21); if (!p0.new) jump:t 0 }
# CHECK: 00 fd c9 14
{ p1 = cmp.gt(r17, r21); if (!p1.new) jump:t 0 }
# CHECK: 00 cd 09 15
{ p0 = cmp.gtu(r17, r21); if (p0.new) jump:nt 0 }
# CHECK: 00 dd 09 15
{ p1 = cmp.gtu(r17, r21); if (p1.new) jump:nt 0 }
# CHECK: 00 ed 09 15
{ p0 = cmp.gtu(r17, r21); if (p0.new) jump:t 0 }
# CHECK: 00 fd 09 15
{ p1 = cmp.gtu(r17, r21); if (p1.new) jump:t 0 }
# CHECK: 00 cd 49 15
{ p0 = cmp.gtu(r17, r21); if (!p0.new) jump:nt 0 }
# CHECK: 00 dd 49 15
{ p1 = cmp.gtu(r17, r21); if (!p1.new) jump:nt 0 }
# CHECK: 00 ed 49 15
{ p0 = cmp.gtu(r17, r21); if (!p0.new) jump:t 0 }
# CHECK: 00 fd 49 15
{ p1 = cmp.gtu(r17, r21); if (!p1.new) jump:t 0 }
# Jump to address
# CHECK: 00 c0 00 58
jump 0
# CHECK: 00 c3 00 5c
if (p3) jump 0
# CHECK: 00 c3 20 5c
if (!p3) jump 0
# Jump to address conditioned on new predicate
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 cb 00 5c
{ p3 = r5
if (p3.new) jump:nt 0 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 db 00 5c
{ p3 = r5
if (p3.new) jump:t 0 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 cb 20 5c
{ p3 = r5
if (!p3.new) jump:nt 0 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 db 20 5c
{ p3 = r5
if (!p3.new) jump:t 0 }
# Jump to address conditioned on register value
# CHECK: 00 c0 11 61
if (r17!=#0) jump:nt 0
# CHECK: 00 d0 11 61
if (r17!=#0) jump:t 0
# CHECK: 00 c0 51 61
if (r17>=#0) jump:nt 0
# CHECK: 00 d0 51 61
if (r17>=#0) jump:t 0
# CHECK: 00 c0 91 61
if (r17==#0) jump:nt 0
# CHECK: 00 d0 91 61
if (r17==#0) jump:t 0
# CHECK: 00 c0 d1 61
if (r17<=#0) jump:nt 0
# CHECK: 00 d0 d1 61
if (r17<=#0) jump:t 0
# Transfer and jump
# CHECK: 00 d5 09 16
{ r17 = #21 ; jump 0 }
# CHECK: 00 c9 0d 17
{ r17 = r21 ; jump 0 }

38
external/llvm/test/MC/Hexagon/instructions/jr.s vendored
View File

@@ -1,38 +0,0 @@
# RUN: llvm-mc -triple hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.3 JR
# Call subroutine from register
# CHECK: 00 c0 b5 50
callr r21
# CHECK: 00 c1 15 51
if (p1) callr r21
# CHECK: 00 c3 35 51
if (!p3) callr r21
# Hint an indirect jump address
# CHECK: 00 c0 b5 52
hintjr(r21)
# Jump to address from register
# CHECK: 00 c0 95 52
jumpr r21
# CHECK: 00 c1 55 53
if (p1) jumpr r21
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 cb 55 53
{ p3 = r5
if (p3.new) jumpr:nt r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 db 55 53
{ p3 = r5
if (p3.new) jumpr:t r21 }
# CHECK: 00 c3 75 53
if (!p3) jumpr r21
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 cb 75 53
{ p3 = r5
if (!p3.new) jumpr:nt r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 db 75 53
{ p3 = r5
if (!p3.new) jumpr:t r21 }

498
external/llvm/test/MC/Hexagon/instructions/ld.s vendored
View File

@@ -1,498 +0,0 @@
# RUN: llvm-mc -triple hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.5 LD
# Load doubleword
# CHECK: 90 ff d5 3a
r17:16 = memd(r21 + r31<<#3)
# CHECK: b0 c2 c0 49
r17:16 = memd(gp+#168)
# CHECK: 02 40 00 00
# CHECK-NEXT: 10 c5 c0 49
r17:16 = memd(##168)
# CHECK: d0 c0 d5 91
r17:16 = memd(r21 + #48)
# CHECK: b0 e0 d5 99
r17:16 = memd(r21 ++ #40:circ(m1))
# CHECK: 10 e2 d5 99
r17:16 = memd(r21 ++ I:circ(m1))
# CHECK: 00 40 00 00
# CHECK-NEXT: 70 d7 d5 9b
r17:16 = memd(r21 = ##31)
# CHECK: b0 c0 d5 9b
r17:16 = memd(r21++#40)
# CHECK: 10 e0 d5 9d
r17:16 = memd(r21++m1)
# CHECK: 10 e0 d5 9f
r17:16 = memd(r21 ++ m1:brev)
# Load doubleword conditionally
# CHECK: f0 ff d5 30
if (p3) r17:16 = memd(r21+r31<<#3)
# CHECK: f0 ff d5 31
if (!p3) r17:16 = memd(r21+r31<<#3)
# CHECK: 03 40 45 85
# CHECK-NEXT: f0 ff d5 32
{ p3 = r5
if (p3.new) r17:16 = memd(r21+r31<<#3) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f0 ff d5 33
{ p3 = r5
if (!p3.new) r17:16 = memd(r21+r31<<#3) }
# CHECK: 70 d8 d5 41
if (p3) r17:16 = memd(r21 + #24)
# CHECK: 03 40 45 85
# CHECK-NEXT: 70 d8 d5 43
{ p3 = r5
if (p3.new) r17:16 = memd(r21 + #24) }
# CHECK: 70 d8 d5 45
if (!p3) r17:16 = memd(r21 + #24)
# CHECK: 03 40 45 85
# CHECK-NEXT: 70 d8 d5 47
{ p3 = r5
if (!p3.new) r17:16 = memd(r21 + #24) }
# CHECK: b0 e6 d5 9b
if (p3) r17:16 = memd(r21++#40)
# CHECK: b0 ee d5 9b
if (!p3) r17:16 = memd(r21++#40)
# CHECK: 03 40 45 85
# CHECK-NEXT: b0 f6 d5 9b
{ p3 = r5
if (p3.new) r17:16 = memd(r21++#40) }
# CHECK: 03 40 45 85
# CHECK-NEXT: b0 fe d5 9b
{ p3 = r5
if (!p3.new) r17:16 = memd(r21++#40) }
# Load byte
# CHECK: 91 ff 15 3a
r17 = memb(r21 + r31<<#3)
# CHECK: b1 c2 00 49
r17 = memb(gp+#21)
# CHECK: 00 40 00 00
# CHECK-NEXT: b1 c2 00 49
r17 = memb(##21)
# CHECK: f1 c3 15 91
r17 = memb(r21 + #31)
# CHECK: b1 e0 15 99
r17 = memb(r21 ++ #5:circ(m1))
# CHECK: 11 e2 15 99
r17 = memb(r21 ++ I:circ(m1))
# CHECK: 00 40 00 00
# CHECK-NEXT: 71 d7 15 9b
r17 = memb(r21 = ##31)
# CHECK: b1 c0 15 9b
r17 = memb(r21++#5)
# CHECK: 11 e0 15 9d
r17 = memb(r21++m1)
# CHECK: 11 e0 15 9f
r17 = memb(r21 ++ m1:brev)
# Load byte conditionally
# CHECK: f1 ff 15 30
if (p3) r17 = memb(r21+r31<<#3)
# CHECK: f1 ff 15 31
if (!p3) r17 = memb(r21+r31<<#3)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 15 32
{ p3 = r5
if (p3.new) r17 = memb(r21+r31<<#3) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 15 33
{ p3 = r5
if (!p3.new) r17 = memb(r21+r31<<#3) }
# CHECK: 91 dd 15 41
if (p3) r17 = memb(r21 + #44)
# CHECK: 03 40 45 85
# CHECK-NEXT: 91 dd 15 43
{ p3 = r5
if (p3.new) r17 = memb(r21 + #44) }
# CHECK: 91 dd 15 45
if (!p3) r17 = memb(r21 + #44)
# CHECK: 03 40 45 85
# CHECK-NEXT: 91 dd 15 47
{ p3 = r5
if (!p3.new) r17 = memb(r21 + #44) }
# CHECK: b1 e6 15 9b
if (p3) r17 = memb(r21++#5)
# CHECK: b1 ee 15 9b
if (!p3) r17 = memb(r21++#5)
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 f6 15 9b
{ p3 = r5
if (p3.new) r17 = memb(r21++#5) }
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 fe 15 9b
{ p3 = r5
if (!p3.new) r17 = memb(r21++#5) }
# Load byte into shifted vector
# CHECK: f0 c3 95 90
r17:16 = memb_fifo(r21 + #31)
# CHECK: b0 e0 95 98
r17:16 = memb_fifo(r21 ++ #5:circ(m1))
# CHECK: 10 e2 95 98
r17:16 = memb_fifo(r21 ++ I:circ(m1))
# Load half into shifted vector
# CHECK: f0 c3 55 90
r17:16 = memh_fifo(r21 + #62)
# CHECK: b0 e0 55 98
r17:16 = memh_fifo(r21 ++ #10:circ(m1))
# CHECK: 10 e2 55 98
r17:16 = memh_fifo(r21 ++ I:circ(m1))
# Load halfword
# CHECK: 91 ff 55 3a
r17 = memh(r21 + r31<<#3)
# CHECK: b1 c2 40 49
r17 = memh(gp+#42)
# CHECK: 00 40 00 00
# CHECK-NEXT: 51 c5 40 49
r17 = memh(##42)
# CHECK: f1 c3 55 91
r17 = memh(r21 + #62)
# CHECK: b1 e0 55 99
r17 = memh(r21 ++ #10:circ(m1))
# CHECK: 11 e2 55 99
r17 = memh(r21 ++ I:circ(m1))
# CHECK: 00 40 00 00
# CHECK-NEXT: 71 d7 55 9b
r17 = memh(r21 = ##31)
# CHECK: b1 c0 55 9b
r17 = memh(r21++#10)
# CHECK: 11 e0 55 9d
r17 = memh(r21++m1)
# CHECK: 11 e0 55 9f
r17 = memh(r21 ++ m1:brev)
# Load halfword conditionally
# CHECK: f1 ff 55 30
if (p3) r17 = memh(r21+r31<<#3)
# CHECK: f1 ff 55 31
if (!p3) r17 = memh(r21+r31<<#3)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 55 32
{ p3 = r5
if (p3.new) r17 = memh(r21+r31<<#3) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 55 33
{ p3 = r5
if (!p3.new) r17 = memh(r21+r31<<#3) }
# CHECK: b1 e6 55 9b
if (p3) r17 = memh(r21++#10)
# CHECK: b1 ee 55 9b
if (!p3) r17 = memh(r21++#10)
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 f6 55 9b
{ p3 = r5
if (p3.new) r17 = memh(r21++#10) }
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 fe 55 9b
{ p3 = r5
if (!p3.new) r17 = memh(r21++#10) }
# CHECK: f1 db 55 41
if (p3) r17 = memh(r21 + #62)
# CHECK: f1 db 55 45
if (!p3) r17 = memh(r21 + #62)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 db 55 43
{ p3 = r5
if (p3.new) r17 = memh(r21 + #62) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 db 55 47
{ p3 = r5
if (!p3.new) r17 = memh(r21 + #62) }
# Load unsigned byte
# CHECK: 91 ff 35 3a
r17 = memub(r21 + r31<<#3)
# CHECK: b1 c2 20 49
r17 = memub(gp+#21)
# CHECK: 00 40 00 00
# CHECK-NEXT: b1 c2 20 49
r17 = memub(##21)
# CHECK: f1 c3 35 91
r17 = memub(r21 + #31)
# CHECK: b1 e0 35 99
r17 = memub(r21 ++ #5:circ(m1))
# CHECK: 11 e2 35 99
r17 = memub(r21 ++ I:circ(m1))
# CHECK: 00 40 00 00
# CHECK-NEXT: 71 d7 35 9b
r17 = memub(r21 = ##31)
# CHECK: b1 c0 35 9b
r17 = memub(r21++#5)
# CHECK: 11 e0 35 9d
r17 = memub(r21++m1)
# CHECK: 11 e0 35 9f
r17 = memub(r21 ++ m1:brev)
# Load unsigned byte conditionally
# CHECK: f1 ff 35 30
if (p3) r17 = memub(r21+r31<<#3)
# CHECK: f1 ff 35 31
if (!p3) r17 = memub(r21+r31<<#3)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 35 32
{ p3 = r5
if (p3.new) r17 = memub(r21+r31<<#3) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 35 33
{ p3 = r5
if (!p3.new) r17 = memub(r21+r31<<#3) }
# CHECK: f1 db 35 41
if (p3) r17 = memub(r21 + #31)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 db 35 43
{ p3 = r5
if (p3.new) r17 = memub(r21 + #31) }
# CHECK: f1 db 35 45
if (!p3) r17 = memub(r21 + #31)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 db 35 47
{ p3 = r5
if (!p3.new) r17 = memub(r21 + #31) }
# CHECK: b1 e6 35 9b
if (p3) r17 = memub(r21++#5)
# CHECK: b1 ee 35 9b
if (!p3) r17 = memub(r21++#5)
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 f6 35 9b
{ p3 = r5
if (p3.new) r17 = memub(r21++#5) }
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 fe 35 9b
{ p3 = r5
if (!p3.new) r17 = memub(r21++#5) }
# Load unsigned halfword
# CHECK: 91 ff 75 3a
r17 = memuh(r21 + r31<<#3)
# CHECK: b1 c2 60 49
r17 = memuh(gp+#42)
# CHECK: 00 40 00 00
# CHECK-NEXT: 51 c5 60 49
r17 = memuh(##42)
# CHECK: b1 c2 75 91
r17 = memuh(r21 + #42)
# CHECK: b1 e0 75 99
r17 = memuh(r21 ++ #10:circ(m1))
# CHECK: 11 e2 75 99
r17 = memuh(r21 ++ I:circ(m1))
# CHECK: 00 40 00 00
# CHECK-NEXT: 71 d7 75 9b
r17 = memuh(r21 = ##31)
# CHECK: b1 c0 75 9b
r17 = memuh(r21++#10)
# CHECK: 11 e0 75 9d
r17 = memuh(r21++m1)
# CHECK: 11 e0 75 9f
r17 = memuh(r21 ++ m1:brev)
# Load unsigned halfword conditionally
# CHECK: f1 ff 75 30
if (p3) r17 = memuh(r21+r31<<#3)
# CHECK: f1 ff 75 31
if (!p3) r17 = memuh(r21+r31<<#3)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 75 32
{ p3 = r5
if (p3.new) r17 = memuh(r21+r31<<#3) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 75 33
{ p3 = r5
if (!p3.new) r17 = memuh(r21+r31<<#3) }
# CHECK: b1 da 75 41
if (p3) r17 = memuh(r21 + #42)
# CHECK: b1 da 75 45
if (!p3) r17 = memuh(r21 + #42)
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 da 75 43
{ p3 = r5
if (p3.new) r17 = memuh(r21 + #42) }
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 da 75 47
{ p3 = r5
if (!p3.new) r17 = memuh(r21 + #42) }
# CHECK: b1 e6 75 9b
if (p3) r17 = memuh(r21++#10)
# CHECK: b1 ee 75 9b
if (!p3) r17 = memuh(r21++#10)
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 f6 75 9b
{ p3 = r5
if (p3.new) r17 = memuh(r21++#10) }
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 fe 75 9b
{ p3 = r5
if (!p3.new) r17 = memuh(r21++#10) }
# Load word
# CHECK: 91 ff 95 3a
r17 = memw(r21 + r31<<#3)
# CHECK: b1 c2 80 49
r17 = memw(gp+#84)
# CHECK: 01 40 00 00
# CHECK-NEXT: 91 c2 80 49
r17 = memw(##84)
# CHECK: b1 c2 95 91
r17 = memw(r21 + #84)
# CHECK: b1 e0 95 99
r17 = memw(r21 ++ #20:circ(m1))
# CHECK: 11 e2 95 99
r17 = memw(r21 ++ I:circ(m1))
# CHECK: 00 40 00 00
# CHECK-NEXT: 71 d7 95 9b
r17 = memw(r21 = ##31)
# CHECK: b1 c0 95 9b
r17 = memw(r21++#20)
# CHECK: 11 e0 95 9d
r17 = memw(r21++m1)
# CHECK: 11 e0 95 9f
r17 = memw(r21 ++ m1:brev)
# Load word conditionally
# CHECK: f1 ff 95 30
if (p3) r17 = memw(r21+r31<<#3)
# CHECK: f1 ff 95 31
if (!p3) r17 = memw(r21+r31<<#3)
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 95 32
{ p3 = r5
if (p3.new) r17 = memw(r21+r31<<#3) }
# CHECK: 03 40 45 85
# CHECK-NEXT: f1 ff 95 33
{ p3 = r5
if (!p3.new) r17 = memw(r21+r31<<#3) }
# CHECK: b1 da 95 41
if (p3) r17 = memw(r21 + #84)
# CHECK: b1 da 95 45
if (!p3) r17 = memw(r21 + #84)
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 da 95 43
{ p3 = r5
if (p3.new) r17 = memw(r21 + #84) }
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 da 95 47
{ p3 = r5
if (!p3.new) r17 = memw(r21 + #84) }
# CHECK: b1 e6 95 9b
if (p3) r17 = memw(r21++#20)
# CHECK: b1 ee 95 9b
if (!p3) r17 = memw(r21++#20)
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 f6 95 9b
{ p3 = r5
if (p3.new) r17 = memw(r21++#20) }
# CHECK: 03 40 45 85
# CHECK-NEXT: b1 fe 95 9b
{ p3 = r5
if (!p3.new) r17 = memw(r21++#20) }
# Deallocate stack frame
# CHECK: 1e c0 1e 90
deallocframe
# Deallocate stack frame and return
# CHECK: 1e c0 1e 96
dealloc_return
# CHECK: 03 40 45 85
# CHECK-NEXT: 1e cb 1e 96
{ p3 = r5
if (p3.new) dealloc_return:nt }
# CHECK: 1e d3 1e 96
if (p3) dealloc_return
# CHECK: 03 40 45 85
# CHECK-NEXT: 1e db 1e 96
{ p3 = r5
if (p3.new) dealloc_return:t }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1e eb 1e 96
{ p3 = r5
if (!p3.new) dealloc_return:nt }
# CHECK: 1e f3 1e 96
if (!p3) dealloc_return
# CHECK: 03 40 45 85
# CHECK-NEXT: 1e fb 1e 96
{ p3 = r5
if (!p3.new) dealloc_return:t }
# Load and unpack bytes to halfwords
# CHECK: f1 c3 35 90
r17 = membh(r21 + #62)
# CHECK: f1 c3 75 90
r17 = memubh(r21 + #62)
# CHECK: f0 c3 b5 90
r17:16 = memubh(r21 + #124)
# CHECK: f0 c3 f5 90
r17:16 = membh(r21 + #124)
# CHECK: b1 e0 35 98
r17 = membh(r21 ++ #10:circ(m1))
# CHECK: 11 e2 35 98
r17 = membh(r21 ++ I:circ(m1))
# CHECK: b1 e0 75 98
r17 = memubh(r21 ++ #10:circ(m1))
# CHECK: 11 e2 75 98
r17 = memubh(r21 ++ I:circ(m1))
# CHECK: b0 e0 f5 98
r17:16 = membh(r21 ++ #20:circ(m1))
# CHECK: 10 e2 f5 98
r17:16 = membh(r21 ++ I:circ(m1))
# CHECK: b0 e0 b5 98
r17:16 = memubh(r21 ++ #20:circ(m1))
# CHECK: 10 e2 b5 98
r17:16 = memubh(r21 ++ I:circ(m1))
# CHECK: 00 40 00 00
# CHECK-NEXT: 71 d7 35 9a
r17 = membh(r21 = ##31)
# CHECK: b1 c0 35 9a
r17 = membh(r21++#10)
# CHECK: 00 40 00 00
# CHECK-NEXT: 71 d7 75 9a
r17 = memubh(r21 = ##31)
# CHECK: b1 c0 75 9a
r17 = memubh(r21++#10)
# CHECK: 00 40 00 00
# CHECK-NEXT: 70 d7 b5 9a
r17:16 = memubh(r21 = ##31)
# CHECK: b0 c0 b5 9a
r17:16 = memubh(r21++#20)
# CHECK: 00 40 00 00
# CHECK-NEXT: 70 d7 f5 9a
r17:16 = membh(r21 = ##31)
# CHECK: b0 c0 f5 9a
r17:16 = membh(r21++#20)
# CHECK: 00 40 00 00
# CHECK-NEXT: f1 f7 35 9c
r17 = membh(r21<<#3 + ##31)
# CHECK: 11 e0 35 9c
r17 = membh(r21++m1)
# CHECK: 00 40 00 00
# CHECK-NEXT: f1 f7 75 9c
r17 = memubh(r21<<#3 + ##31)
# CHECK: 11 e0 75 9c
r17 = memubh(r21++m1)
# CHECK: 00 40 00 00
# CHECK-NEXT: f0 f7 f5 9c
r17:16 = membh(r21<<#3 + ##31)
# CHECK: 10 e0 f5 9c
r17:16 = membh(r21++m1)
# CHECK: 00 40 00 00
# CHECK-NEXT: f0 f7 b5 9c
r17:16 = memubh(r21<<#3 + ##31)
# CHECK: 11 e0 35 9c
r17 = membh(r21++m1)
# CHECK: 11 e0 75 9c
r17 = memubh(r21++m1)
# CHECK: 10 e0 f5 9c
r17:16 = membh(r21++m1)
# CHECK: 10 e0 b5 9c
r17:16 = memubh(r21++m1)
# CHECK: 11 e0 35 9e
r17 = membh(r21 ++ m1:brev)
# CHECK: 11 e0 75 9e
r17 = memubh(r21 ++ m1:brev)
# CHECK: 10 e0 b5 9e
r17:16 = memubh(r21 ++ m1:brev)
# CHECK: 10 e0 f5 9e
r17:16 = membh(r21 ++ m1:brev)

56
external/llvm/test/MC/Hexagon/instructions/memop.s vendored
View File

@@ -1,56 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.6 MEMOP
# Operation on memory byte
# CHECK: 95 d9 11 3e
memb(r17+#51) += r21
# CHECK: b5 d9 11 3e
memb(r17+#51) -= r21
# CHECK: d5 d9 11 3e
memb(r17+#51) &= r21
# CHECK: f5 d9 11 3e
memb(r17+#51) |= r21
# CHECK: 95 d9 11 3f
memb(r17+#51) += #21
# CHECK: b5 d9 11 3f
memb(r17+#51) -= #21
# CHECK: d5 d9 11 3f
memb(r17+#51) = clrbit(#21)
# CHECK: f5 d9 11 3f
memb(r17+#51) = setbit(#21)
# Operation on memory halfword
# CHECK: 95 d9 31 3e
memh(r17+#102) += r21
# CHECK: b5 d9 31 3e
memh(r17+#102) -= r21
# CHECK: d5 d9 31 3e
memh(r17+#102) &= r21
# CHECK: f5 d9 31 3e
memh(r17+#102) |= r21
# CHECK: 95 d9 31 3f
memh(r17+#102) += #21
# CHECK: b5 d9 31 3f
memh(r17+#102) -= #21
# CHECK: d5 d9 31 3f
memh(r17+#102) = clrbit(#21)
# CHECK: f5 d9 31 3f
memh(r17+#102) = setbit(#21)
# Operation on memory word
# CHECK: 95 d9 51 3e
memw(r17+#204) += r21
# CHECK: b5 d9 51 3e
memw(r17+#204) -= r21
# CHECK: d5 d9 51 3e
memw(r17+#204) &= r21
# CHECK: f5 d9 51 3e
memw(r17+#204) |= r21
# CHECK: 95 d9 51 3f
memw(r17+#204) += #21
# CHECK: b5 d9 51 3f
memw(r17+#204) -= #21
# CHECK: d5 d9 51 3f
memw(r17+#204) = clrbit(#21)
# CHECK: f5 d9 51 3f
memw(r17+#204) = setbit(#21)

180
external/llvm/test/MC/Hexagon/instructions/nv_j.s vendored
View File

@@ -1,180 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.7.1 NV/J
# Jump to address conditioned on new register value
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 02 20
{ r17 = r17
if (cmp.eq(r17.new, r21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 02 20
{ r17 = r17
if (cmp.eq(r17.new, r21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 42 20
{ r17 = r17
if (!cmp.eq(r17.new, r21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 42 20
{ r17 = r17
if (!cmp.eq(r17.new, r21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 82 20
{ r17 = r17
if (cmp.gt(r17.new, r21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 82 20
{ r17 = r17
if (cmp.gt(r17.new, r21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 c2 20
{ r17 = r17
if (!cmp.gt(r17.new, r21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 c2 20
{ r17 = r17
if (!cmp.gt(r17.new, r21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 02 21
{ r17 = r17
if (cmp.gtu(r17.new, r21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 02 21
{ r17 = r17
if (cmp.gtu(r17.new, r21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 42 21
{ r17 = r17
if (!cmp.gtu(r17.new, r21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 42 21
{ r17 = r17
if (!cmp.gtu(r17.new, r21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 82 21
{ r17 = r17
if (cmp.gt(r21, r17.new)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 82 21
{ r17 = r17
if (cmp.gt(r21, r17.new)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 c2 21
{ r17 = r17
if (!cmp.gt(r21, r17.new)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 c2 21
{ r17 = r17
if (!cmp.gt(r21, r17.new)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 02 22
{ r17 = r17
if (cmp.gtu(r21, r17.new)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 02 22
{ r17 = r17
if (cmp.gtu(r21, r17.new)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 42 22
{ r17 = r17
if (!cmp.gtu(r21, r17.new)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 42 22
{ r17 = r17
if (!cmp.gtu(r21, r17.new)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 02 24
{ r17 = r17
if (cmp.eq(r17.new, #21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 02 24
{ r17 = r17
if (cmp.eq(r17.new, #21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 42 24
{ r17 = r17
if (!cmp.eq(r17.new, #21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 42 24
{ r17 = r17
if (!cmp.eq(r17.new, #21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 82 24
{ r17 = r17
if (cmp.gt(r17.new, #21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 82 24
{ r17 = r17
if (cmp.gt(r17.new, #21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 c2 24
{ r17 = r17
if (!cmp.gt(r17.new, #21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 c2 24
{ r17 = r17
if (!cmp.gt(r17.new, #21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 02 25
{ r17 = r17
if (cmp.gtu(r17.new, #21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 02 25
{ r17 = r17
if (cmp.gtu(r17.new, #21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 d5 42 25
{ r17 = r17
if (!cmp.gtu(r17.new, #21)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 f5 42 25
{ r17 = r17
if (!cmp.gtu(r17.new, #21)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 c0 82 25
{ r17 = r17
if (tstbit(r17.new, #0)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 e0 82 25
{ r17 = r17
if (tstbit(r17.new, #0)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 c0 c2 25
{ r17 = r17
if (!tstbit(r17.new, #0)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 e0 c2 25
{ r17 = r17
if (!tstbit(r17.new, #0)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 c0 02 26
{ r17 = r17
if (cmp.eq(r17.new, #-1)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 e0 02 26
{ r17 = r17
if (cmp.eq(r17.new, #-1)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 c0 42 26
{ r17 = r17
if (!cmp.eq(r17.new, #-1)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 e0 42 26
{ r17 = r17
if (!cmp.eq(r17.new, #-1)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 c0 82 26
{ r17 = r17
if (cmp.gt(r17.new, #-1)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 e0 82 26
{ r17 = r17
if (cmp.gt(r17.new, #-1)) jump:t 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 c0 c2 26
{ r17 = r17
if (!cmp.gt(r17.new, #-1)) jump:nt 0x0 }
# CHECK: 11 40 71 70
# CHECK-NEXT: 00 e0 c2 26
{ r17 = r17
if (!cmp.gt(r17.new, #-1)) jump:t 0x0 }

290
external/llvm/test/MC/Hexagon/instructions/nv_st.s vendored
View File

@@ -1,290 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.7.2 NV/ST
# Store new-value byte
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 82 f5 b1 3b
{ r31 = r31
memb(r17 + r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 11 c2 a0 48
{ r31 = r31
memb(gp+#17) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 15 c2 b1 a1
{ r31 = r31
memb(r17+#21) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 02 e2 b1 a9
{ r31 = r31
memb(r17 ++ I:circ(m1)) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 28 e2 b1 a9
{ r31 = r31
memb(r17 ++ #5:circ(m1)) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 28 c2 b1 ab
{ r31 = r31
memb(r17++#5) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 00 e2 b1 ad
{ r31 = r31
memb(r17++m1) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 00 e2 b1 af
{ r31 = r31
memb(r17 ++ m1:brev) = r31.new }
# Store new-value byte conditionally
# CHECK: 1f 40 7f 70
# CHECK-NEXT: e2 f5 b1 34
{ r31 = r31
if (p3) memb(r17+r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: e2 f5 b1 35
{ r31 = r31
if (!p3) memb(r17+r21<<#3) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: e2 f5 b1 36
{ p3 = r5
r31 = r31
if (p3.new) memb(r17+r21<<#3) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: e2 f5 b1 37
{ p3 = r5
r31 = r31
if (!p3.new) memb(r17+r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: ab c2 b1 40
{ r31 = r31
if (p3) memb(r17+#21) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: ab c2 b1 44
{ r31 = r31
if (!p3) memb(r17+#21) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab c2 b1 42
{ p3 = r5
r31 = r31
if (p3.new) memb(r17+#21) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab c2 b1 46
{ p3 = r5
r31 = r31
if (!p3.new) memb(r17+#21) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 2b e2 b1 ab
{ r31 = r31
if (p3) memb(r17++#5) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 2f e2 b1 ab
{ r31 = r31
if (!p3) memb(r17++#5) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab e2 b1 ab
{ p3 = r5
r31 = r31
if (p3.new) memb(r17++#5) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: af e2 b1 ab
{ p3 = r5
r31 = r31
if (!p3.new) memb(r17++#5) = r31.new }
# Store new-value halfword
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 8a f5 b1 3b
{ r31 = r31
memh(r17 + r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 15 ca a0 48
{ r31 = r31
memh(gp+#42) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 15 ca b1 a1
{ r31 = r31
memh(r17+#42) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 02 ea b1 a9
{ r31 = r31
memh(r17 ++ I:circ(m1)) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 28 ea b1 a9
{ r31 = r31
memh(r17 ++ #10:circ(m1)) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 28 ca b1 ab
{ r31 = r31
memh(r17++#10) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 00 ea b1 ad
{ r31 = r31
memh(r17++m1) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 00 ea b1 af
{ r31 = r31
memh(r17 ++ m1:brev) = r31.new }
# Store new-value halfword conditionally
# CHECK: 1f 40 7f 70
# CHECK-NEXT: ea f5 b1 34
{ r31 = r31
if (p3) memh(r17+r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: ea f5 b1 35
{ r31 = r31
if (!p3) memh(r17+r21<<#3) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ea f5 b1 36
{ p3 = r5
r31 = r31
if (p3.new) memh(r17+r21<<#3) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ea f5 b1 37
{ p3 = r5
r31 = r31
if (!p3.new) memh(r17+r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: ab ca b1 40
{ r31 = r31
if (p3) memh(r17+#42) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: ab ca b1 44
{ r31 = r31
if (!p3) memh(r17+#42) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab ca b1 42
{ p3 = r5
r31 = r31
if (p3.new) memh(r17+#42) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab ca b1 46
{ p3 = r5
r31 = r31
if (!p3.new) memh(r17+#42) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 2b ea b1 ab
{ r31 = r31
if (p3) memh(r17++#10) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 2f ea b1 ab
{ r31 = r31
if (!p3) memh(r17++#10) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab ea b1 ab
{ p3 = r5
r31 = r31
if (p3.new) memh(r17++#10) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: af ea b1 ab
{ p3 = r5
r31 = r31
if (!p3.new) memh(r17++#10) = r31.new }
# Store new-value word
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 92 f5 b1 3b
{ r31 = r31
memw(r17 + r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 15 d2 a0 48
{ r31 = r31
memw(gp+#84) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 15 d2 b1 a1
{ r31 = r31
memw(r17+#84) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 02 f2 b1 a9
{ r31 = r31
memw(r17 ++ I:circ(m1)) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 28 f2 b1 a9
{ r31 = r31
memw(r17 ++ #20:circ(m1)) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 28 d2 b1 ab
{ r31 = r31
memw(r17++#20) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 00 f2 b1 ad
{ r31 = r31
memw(r17++m1) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 00 f2 b1 af
{ r31 = r31
memw(r17 ++ m1:brev) = r31.new }
# Store new-value word conditionally
# CHECK: 1f 40 7f 70
# CHECK-NEXT: f2 f5 b1 34
{ r31 = r31
if (p3) memw(r17+r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: f2 f5 b1 35
{ r31 = r31
if (!p3) memw(r17+r21<<#3) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: f2 f5 b1 36
{ p3 = r5
r31 = r31
if (p3.new) memw(r17+r21<<#3) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: f2 f5 b1 37
{ p3 = r5
r31 = r31
if (!p3.new) memw(r17+r21<<#3) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: ab d2 b1 40
{ r31 = r31
if (p3) memw(r17+#84) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: ab d2 b1 44
{ r31 = r31
if (!p3) memw(r17+#84) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab d2 b1 42
{ p3 = r5
r31 = r31
if (p3.new) memw(r17+#84) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab d2 b1 46
{ p3 = r5
r31 = r31
if (!p3.new) memw(r17+#84) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 2b f2 b1 ab
{ r31 = r31
if (p3) memw(r17++#20) = r31.new }
# CHECK: 1f 40 7f 70
# CHECK-NEXT: 2f f2 b1 ab
{ r31 = r31
if (!p3) memw(r17++#20) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: ab f2 b1 ab
{ p3 = r5
r31 = r31
if (p3.new) memw(r17++#20) = r31.new }
# CHECK: 03 40 45 85
# CHECK-NEXT: 1f 40 7f 70
# CHECK-NEXT: af f2 b1 ab
{ p3 = r5
r31 = r31
if (!p3.new) memw(r17++#20) = r31.new }

434
external/llvm/test/MC/Hexagon/instructions/st.s vendored
View File

@@ -1,434 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.8 ST
# Store doubleword
# CHECK: 9e f5 d1 3b
memd(r17 + r21<<#3) = r31:30
# CHECK: 28 d4 c0 48
memd(gp+#320) = r21:20
# CHECK: 02 40 00 00
# CHECK-NEXT: 28 d4 c0 48
memd(##168) = r21:20
memd(r17+#168) = r21:20
# CHECK: 02 f4 d1 a9
memd(r17 ++ I:circ(m1)) = r21:20
# CHECK: 28 f4 d1 a9
memd(r17 ++ #40:circ(m1)) = r21:20
# CHECK: 28 d4 d1 ab
memd(r17++#40) = r21:20
# CHECK: 00 40 00 00
# CHECK-NEXT: d5 fe d1 ad
memd(r17<<#3 + ##21) = r31:30
memd(r17++m1) = r21:20
# CHECK: 00 f4 d1 af
memd(r17 ++ m1:brev) = r21:20
# Store doubleword conditionally
# CHECK: fe f5 d1 34
if (p3) memd(r17+r21<<#3) = r31:30
# CHECK: fe f5 d1 35
if (!p3) memd(r17+r21<<#3) = r31:30
# CHECK: 03 40 45 85
# CHECK-NEXT: fe f5 d1 36
{ p3 = r5
if (p3.new) memd(r17+r21<<#3) = r31:30 }
# CHECK: 03 40 45 85
# CHECK-NEXT: fe f5 d1 37
{ p3 = r5
if (!p3.new) memd(r17+r21<<#3) = r31:30 }
# CHECK: ab de d1 40
if (p3) memd(r17+#168) = r31:30
# CHECK: ab de d1 44
if (!p3) memd(r17+#168) = r31:30
# CHECK: 03 40 45 85
# CHECK-NEXT: ab de d1 42
{ p3 = r5
if (p3.new) memd(r17+#168) = r31:30 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ab de d1 46
{ p3 = r5
if (!p3.new) memd(r17+#168) = r31:30 }
# CHECK: 2b f4 d1 ab
if (p3) memd(r17++#40) = r21:20
# CHECK: 2f f4 d1 ab
if (!p3) memd(r17++#40) = r21:20
# CHECK: 03 40 45 85
# CHECK-NEXT: ab f4 d1 ab
{ p3 = r5
if (p3.new) memd(r17++#40) = r21:20 }
# CHECK: 03 40 45 85
# CHECK-NEXT: af f4 d1 ab
{ p3 = r5
if (!p3.new) memd(r17++#40) = r21:20 }
# CHECK: 02 40 00 00
# CHECK-NEXT: c3 d4 c2 af
if (p3) memd(##168) = r21:20
# CHECK: 02 40 00 00
# CHECK-NEXT: c7 d4 c2 af
if (!p3) memd(##168) = r21:20
# CHECK: 03 40 45 85
# CHECK-NEXT: 02 40 00 00
# CHECK-NEXT: c3 f4 c2 af
{ p3 = r5
if (p3.new) memd(##168) = r21:20 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 02 40 00 00
# CHECK-NEXT: c7 f4 c2 af
{ p3 = r5
if (!p3.new) memd(##168) = r21:20 }
# Store byte
# CHECK: 9f f5 11 3b
memb(r17 + r21<<#3) = r31
# CHECK: 9f ca 11 3c
memb(r17+#21)=#31
# CHECK: 15 d5 00 48
memb(gp+#21) = r21
# CHECK: 00 40 00 00
# CHECK-NEXT: 15 d5 00 48
memb(##21) = r21
# CHECK: 15 d5 11 a1
memb(r17+#21) = r21
# CHECK: 02 f5 11 a9
memb(r17 ++ I:circ(m1)) = r21
# CHECK: 28 f5 11 a9
memb(r17 ++ #5:circ(m1)) = r21
# CHECK: 28 d5 11 ab
memb(r17++#5) = r21
# CHECK: 00 40 00 00
# CHECK-NEXT: d5 ff 11 ad
memb(r17<<#3 + ##21) = r31
# CHECK: 00 f5 11 ad
memb(r17++m1) = r21
# CHECK: 00 f5 11 af
memb(r17 ++ m1:brev) = r21
# Store byte conditionally
# CHECK: ff f5 11 34
if (p3) memb(r17+r21<<#3) = r31
# CHECK: ff f5 11 35
if (!p3) memb(r17+r21<<#3) = r31
# CHECK: 03 40 45 85
# CHECK-NEXT: ff f5 11 36
{ p3 = r5
if (p3.new) memb(r17+r21<<#3) = r31 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ff f5 11 37
{ p3 = r5
if (!p3.new) memb(r17+r21<<#3) = r31 }
# CHECK: ff ca 11 38
if (p3) memb(r17+#21)=#31
# CHECK: ff ca 91 38
if (!p3) memb(r17+#21)=#31
# CHECK: 03 40 45 85
# CHECK-NEXT: ff ca 11 39
{ p3 = r5
if (p3.new) memb(r17+#21)=#31 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ff ca 91 39
{ p3 = r5
if (!p3.new) memb(r17+#21)=#31 }
# CHECK: ab df 11 40
if (p3) memb(r17+#21) = r31
# CHECK: ab df 11 44
if (!p3) memb(r17+#21) = r31
# CHECK: 03 40 45 85
# CHECK-NEXT: ab df 11 42
{ p3 = r5
if (p3.new) memb(r17+#21) = r31 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ab df 11 46
{ p3 = r5
if (!p3.new) memb(r17+#21) = r31 }
# CHECK: 2b f5 11 ab
if (p3) memb(r17++#5) = r21
# CHECK: 2f f5 11 ab
if (!p3) memb(r17++#5) = r21
# CHECK: 03 40 45 85
# CHECK-NEXT: ab f5 11 ab
{ p3 = r5
if (p3.new) memb(r17++#5) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: af f5 11 ab
{ p3 = r5
if (!p3.new) memb(r17++#5) = r21 }
# CHECK: 00 40 00 00
# CHECK-NEXT: ab d5 01 af
if (p3) memb(##21) = r21
# CHECK: 00 40 00 00
# CHECK-NEXT: af d5 01 af
if (!p3) memb(##21) = r21
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 40 00 00
# CHECK-NEXT: ab f5 01 af
{ p3 = r5
if (p3.new) memb(##21) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 40 00 00
# CHECK-NEXT: af f5 01 af
{ p3 = r5
if (!p3.new) memb(##21) = r21 }
# Store halfword
# CHECK: 9f f5 51 3b
memh(r17 + r21<<#3) = r31
# CHECK: 9f f5 71 3b
memh(r17 + r21<<#3) = r31.h
# CHECK: 95 cf 31 3c
memh(r17+#62)=#21
# CHECK: 00 40 00 00
# CHECK-NEXT: 2a d5 40 48
memh(##42) = r21
# CHECK: 00 40 00 00
# CHECK-NEXT: 2a d5 60 48
memh(##42) = r21.h
# CHECK: 2a d5 40 48
memh(gp+#84) = r21
# CHECK: 2a d5 60 48
memh(gp+#84) = r21.h
# CHECK: 15 df 51 a1
memh(r17+#42) = r31
# CHECK: 15 df 71 a1
memh(r17+#42) = r31.h
# CHECK: 02 f5 51 a9
memh(r17 ++ I:circ(m1)) = r21
# CHECK: 28 f5 51 a9
memh(r17 ++ #10:circ(m1)) = r21
# CHECK: 02 f5 71 a9
memh(r17 ++ I:circ(m1)) = r21.h
# CHECK: 28 f5 71 a9
memh(r17 ++ #10:circ(m1)) = r21.h
# CHECK: 28 d5 51 ab
memh(r17++#10) = r21
# CHECK: 00 40 00 00
# CHECK-NEXT: d5 ff 51 ad
memh(r17<<#3 + ##21) = r31
# CHECK: 28 d5 71 ab
memh(r17++#10) = r21.h
# CHECK: 00 40 00 00
# CHECK-NEXT: d5 ff 71 ad
memh(r17<<#3 + ##21) = r31.h
# CHECK: 00 f5 51 ad
memh(r17++m1) = r21
# CHECK: 00 f5 71 ad
memh(r17++m1) = r21.h
# CHECK: 00 f5 51 af
memh(r17 ++ m1:brev) = r21
# CHECK: 00 f5 71 af
memh(r17 ++ m1:brev) = r21.h
# Store halfword conditionally
# CHECK: ff f5 51 34
if (p3) memh(r17+r21<<#3) = r31
# CHECK: ff f5 71 34
if (p3) memh(r17+r21<<#3) = r31.h
# CHECK: ff f5 51 35
if (!p3) memh(r17+r21<<#3) = r31
# CHECK: ff f5 71 35
if (!p3) memh(r17+r21<<#3) = r31.h
# CHECK: 03 40 45 85
# CHECK-NEXT: ff f5 51 36
{ p3 = r5
if (p3.new) memh(r17+r21<<#3) = r31 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ff f5 71 36
{ p3 = r5
if (p3.new) memh(r17+r21<<#3) = r31.h }
# CHECK: 03 40 45 85
# CHECK-NEXT: ff f5 51 37
{ p3 = r5
if (!p3.new) memh(r17+r21<<#3) = r31 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ff f5 71 37
{ p3 = r5
if (!p3.new) memh(r17+r21<<#3) = r31.h }
# CHECK: f5 cf 31 38
if (p3) memh(r17+#62)=#21
# CHECK: f5 cf b1 38
if (!p3) memh(r17+#62)=#21
# CHECK: 03 40 45 85
# CHECK-NEXT: f5 cf 31 39
{ p3 = r5
if (p3.new) memh(r17+#62)=#21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: f5 cf b1 39
{ p3 = r5
if (!p3.new) memh(r17+#62)=#21 }
# CHECK: fb d5 51 40
if (p3) memh(r17+#62) = r21
# CHECK: fb d5 71 40
if (p3) memh(r17+#62) = r21.h
# CHECK: fb d5 51 44
if (!p3) memh(r17+#62) = r21
# CHECK: fb d5 71 44
if (!p3) memh(r17+#62) = r21.h
# CHECK: 03 40 45 85
# CHECK-NEXT: fb d5 51 42
{ p3 = r5
if (p3.new) memh(r17+#62) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: fb d5 71 42
{ p3 = r5
if (p3.new) memh(r17+#62) = r21.h }
# CHECK: 03 40 45 85
# CHECK-NEXT: fb d5 51 46
{ p3 = r5
if (!p3.new) memh(r17+#62) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: fb d5 71 46
{ p3 = r5
if (!p3.new) memh(r17+#62) = r21.h }
# CHECK: 2b f5 51 ab
if (p3) memh(r17++#10) = r21
# CHECK: 2f f5 51 ab
if (!p3) memh(r17++#10) = r21
# CHECK: 03 40 45 85
# CHECK-NEXT: ab f5 51 ab
{ p3 = r5
if (p3.new) memh(r17++#10) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: af f5 51 ab
{ p3 = r5
if (!p3.new) memh(r17++#10) = r21 }
# CHECK: 2b f5 71 ab
if (p3) memh(r17++#10) = r21.h
# CHECK: 2f f5 71 ab
if (!p3) memh(r17++#10) = r21.h
# CHECK: 03 40 45 85
# CHECK-NEXT: ab f5 71 ab
{ p3 = r5
if (p3.new) memh(r17++#10) = r21.h }
# CHECK: 03 40 45 85
# CHECK-NEXT: af f5 71 ab
{ p3 = r5
if (!p3.new) memh(r17++#10) = r21.h }
# CHECK: 00 40 00 00
# CHECK-NEXT: d3 d5 42 af
if (p3) memh(##42) = r21
# CHECK: 00 40 00 00
# CHECK-NEXT: d3 d5 62 af
if (p3) memh(##42) = r21.h
# CHECK: 00 40 00 00
# CHECK-NEXT: d7 d5 42 af
if (!p3) memh(##42) = r21
# CHECK: 00 40 00 00
# CHECK-NEXT: d7 d5 62 af
if (!p3) memh(##42) = r21.h
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 40 00 00
# CHECK-NEXT: d3 f5 42 af
{ p3 = r5
if (p3.new) memh(##42) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 40 00 00
# CHECK-NEXT: d3 f5 62 af
{ p3 = r5
if (p3.new) memh(##42) = r21.h }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 40 00 00
# CHECK-NEXT: d7 f5 42 af
{ p3 = r5
if (!p3.new) memh(##42) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 00 40 00 00
# CHECK-NEXT: d7 f5 62 af
{ p3 = r5
if (!p3.new) memh(##42) = r21.h }
# Store word
# CHECK: 9f f5 91 3b
memw(r17 + r21<<#3) = r31
# CHECK: 9f ca 51 3c
memw(r17+#84)=#31
# CHECK: 15 df 80 48
memw(gp+#84) = r31
# CHECK: 01 40 00 00
# CHECK-NEXT: 14 d5 80 48
memw(##84) = r21
# CHECK: 9f ca 51 3c
memw(r17+#84)=#31
# CHECK: 15 df 91 a1
memw(r17+#84) = r31
# CHECK: 02 f5 91 a9
memw(r17 ++ I:circ(m1)) = r21
# CHECK: 28 f5 91 a9
memw(r17 ++ #20:circ(m1)) = r21
# CHECK: 28 d5 91 ab
memw(r17++#20) = r21
# CHECK: 00 40 00 00
# CHECK-NEXT: d5 ff 91 ad
memw(r17<<#3 + ##21) = r31
# CHECK: 00 f5 91 ad
memw(r17++m1) = r21
# CHECK: 00 f5 91 af
memw(r17 ++ m1:brev) = r21
# Store word conditionally
# CHECK: ff f5 91 34
if (p3) memw(r17+r21<<#3) = r31
# CHECK: ff f5 91 35
if (!p3) memw(r17+r21<<#3) = r31
# CHECK: 03 40 45 85
# CHECK-NEXT: ff f5 91 36
{ p3 = r5
if (p3.new) memw(r17+r21<<#3) = r31 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ff f5 91 37
{ p3 = r5
if (!p3.new) memw(r17+r21<<#3) = r31 }
# CHECK: ff ca 51 38
if (p3) memw(r17+#84)=#31
# CHECK: ff ca d1 38
if (!p3) memw(r17+#84)=#31
# CHECK: 03 40 45 85
# CHECK-NEXT: ff ca 51 39
{ p3 = r5
if (p3.new) memw(r17+#84)=#31 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ff ca d1 39
{ p3 = r5
if (!p3.new) memw(r17+#84)=#31 }
# CHECK: ab df 91 40
if (p3) memw(r17+#84) = r31
# CHECK: ab df 91 44
if (!p3) memw(r17+#84) = r31
# CHECK: 03 40 45 85
# CHECK-NEXT: ab df 91 42
{ p3 = r5
if (p3.new) memw(r17+#84) = r31 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ab df 91 46
{ p3 = r5
if (!p3.new) memw(r17+#84) = r31 }
# CHECK: 2b f5 91 ab
if (p3) memw(r17++#20) = r21
# CHECK: 2f f5 91 ab
if (!p3) memw(r17++#20) = r21
# CHECK: 03 40 45 85
# CHECK-NEXT: af f5 91 ab
{ p3 = r5
if (!p3.new) memw(r17++#20) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: ab f5 91 ab
{ p3 = r5
if (p3.new) memw(r17++#20) = r21 }
# CHECK: 01 40 00 00
# CHECK-NEXT: a3 d5 81 af
if (p3) memw(##84) = r21
# CHECK: 01 40 00 00
# CHECK-NEXT: a7 d5 81 af
if (!p3) memw(##84) = r21
# CHECK: 03 40 45 85
# CHECK-NEXT: 01 40 00 00
# CHECK-NEXT: a3 f5 81 af
{ p3 = r5
if (p3.new) memw(##84) = r21 }
# CHECK: 03 40 45 85
# CHECK-NEXT: 01 40 00 00
# CHECK-NEXT: a7 f5 81 af
{ p3 = r5
if (!p3.new) memw(##84) = r21 }
# Allocate stack frame
# CHECK: 1f c0 9d a0
allocframe(#248)

59
external/llvm/test/MC/Hexagon/instructions/system_user.s vendored
View File

@@ -1,59 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.9.1 SYSTEM/USER
# Load locked
# CHECK: 11 c0 15 92
r17 = memw_locked(r21)
# CHECK: 10 d0 15 92
r17:16 = memd_locked(r21)
# Store conditional
# CHECK: 03 d5 b1 a0
memw_locked(r17, p3) = r21
# CHECK: 03 d4 f1 a0
memd_locked(r17, p3) = r21:20
# Memory barrier
# CHECK: 00 c0 00 a8
barrier
# Data cache prefetch
# CHECK: 15 c0 11 94
dcfetch(r17 + #168)
# Send value to ETM trace
# CHECK: 00 c0 51 62
trace(r17)
# CHECK: 00 c0 00 a0
dccleana(r0)
# CHECK: 00 c0 41 a0
dccleaninva(r1)
# CHECK: 00 c0 22 a0
dcinva(r2)
# CHECK: 00 c0 c3 a0
dczeroa(r3)
# CHECK: 00 c0 c4 56
icinva(r4)
# CHECK: 02 c0 c0 57
isync
# CHECK: 00 c6 05 a6
l2fetch(r5, r6)
# CHECK: 00 c8 87 a6
l2fetch(r7, r9:8)
# CHECK: 1c df 40 54
pause(#255)
# CHECK: 00 c0 40 a8
syncht
# CHECK: 18 df 00 54
trap0(#254)

395
external/llvm/test/MC/Hexagon/instructions/xtype_alu.s vendored
View File

@@ -1,395 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.10.1 XTYPE/ALU
# Absolute value doubleword
# CHECK: d0 c0 94 80
r17:16 = abs(r21:20)
# CHECK: 91 c0 95 8c
r17 = abs(r21)
# CHECK: b1 c0 95 8c
r17 = abs(r21):sat
# Add and accumulate
# CHECK: ff d1 35 db
r17 = add(r21, add(r31, #23))
# CHECK: ff d1 b5 db
r17 = add(r21, sub(#23, r31))
# CHECK: f1 c2 15 e2
r17 += add(r21, #23)
# CHECK: f1 c2 95 e2
r17 -= add(r21, #23)
# CHECK: 31 df 15 ef
r17 += add(r21, r31)
# CHECK: 31 df 95 ef
r17 -= add(r21, r31)
# Add doublewords
# CHECK: f0 de 14 d3
r17:16 = add(r21:20, r31:30)
# CHECK: b0 de 74 d3
r17:16 = add(r21:20, r31:30):sat
# CHECK: d0 de 74 d3
r17:16 = add(r21:20, r31:30):raw:lo
# CHECK: f0 de 74 d3
r17:16 = add(r21:20, r31:30):raw:hi
# Add halfword
# CHECK: 11 d5 1f d5
r17 = add(r21.l, r31.l)
# CHECK: 51 d5 1f d5
r17 = add(r21.l, r31.h)
# CHECK: 91 d5 1f d5
r17 = add(r21.l, r31.l):sat
# CHECK: d1 d5 1f d5
r17 = add(r21.l, r31.h):sat
# CHECK: 11 d5 5f d5
r17 = add(r21.l, r31.l):<<16
# CHECK: 31 d5 5f d5
r17 = add(r21.l, r31.h):<<16
# CHECK: 51 d5 5f d5
r17 = add(r21.h, r31.l):<<16
# CHECK: 71 d5 5f d5
r17 = add(r21.h, r31.h):<<16
# CHECK: 91 d5 5f d5
r17 = add(r21.l, r31.l):sat:<<16
# CHECK: b1 d5 5f d5
r17 = add(r21.l, r31.h):sat:<<16
# CHECK: d1 d5 5f d5
r17 = add(r21.h, r31.l):sat:<<16
# CHECK: f1 d5 5f d5
r17 = add(r21.h, r31.h):sat:<<16
# Add or subtract doublewords with carry
# CHECK: 70 de d4 c2
r17:16 = add(r21:20, r31:30, p3):carry
# CHECK: 70 de f4 c2
r17:16 = sub(r21:20, r31:30, p3):carry
# Logical doublewords
# CHECK: 90 c0 94 80
r17:16 = not(r21:20)
# CHECK: 10 de f4 d3
r17:16 = and(r21:20, r31:30)
# CHECK: 30 d4 fe d3
r17:16 = and(r21:20, ~r31:30)
# CHECK: 50 de f4 d3
r17:16 = or(r21:20, r31:30)
# CHECK: 70 d4 fe d3
r17:16 = or(r21:20, ~r31:30)
# CHECK: 90 de f4 d3
r17:16 = xor(r21:20, r31:30)
# Logical-logical doublewords
# CHECK: 10 de 94 ca
r17:16 ^= xor(r21:20, r31:30)
# Logical-logical words
# CHECK: f1 c3 15 da
r17 |= and(r21, #31)
# CHECK: f5 c3 51 da
r17 = or(r21, and(r17, #31))
# CHECK: f1 c3 95 da
r17 |= or(r21, #31)
# CHECK: 11 df 35 ef
r17 |= and(r21, ~r31)
# CHECK: 31 df 35 ef
r17 &= and(r21, ~r31)
# CHECK: 51 df 35 ef
r17 ^= and(r21, ~r31)
# CHECK: 11 df 55 ef
r17 &= and(r21, r31)
# CHECK: 31 df 55 ef
r17 &= or(r21, r31)
# CHECK: 51 df 55 ef
r17 &= xor(r21, r31)
# CHECK: 71 df 55 ef
r17 |= and(r21, r31)
# CHECK: 71 df 95 ef
r17 ^= xor(r21, r31)
# CHECK: 11 df d5 ef
r17 |= or(r21, r31)
# CHECK: 31 df d5 ef
r17 |= xor(r21, r31)
# CHECK: 51 df d5 ef
r17 ^= and(r21, r31)
# CHECK: 71 df d5 ef
r17 ^= or(r21, r31)
# Maximum words
# CHECK: 11 df d5 d5
r17 = max(r21, r31)
# CHECK: 91 df d5 d5
r17 = maxu(r21, r31)
# Maximum doublewords
# CHECK: 90 de d4 d3
r17:16 = max(r21:20, r31:30)
# CHECK: b0 de d4 d3
r17:16 = maxu(r21:20, r31:30)
# Minimum words
# CHECK: 11 d5 bf d5
r17 = min(r21, r31)
# CHECK: 91 d5 bf d5
r17 = minu(r21, r31)
# Minimum doublewords
# CHECK: d0 d4 be d3
r17:16 = min(r21:20, r31:30)
# CHECK: f0 d4 be d3
r17:16 = minu(r21:20, r31:30)
# Module wrap
# CHECK: f1 df f5 d3
r17 = modwrap(r21, r31)
# Negate
# CHECK: b0 c0 94 80
r17:16 = neg(r21:20)
# CHECK: d1 c0 95 8c
r17 = neg(r21):sat
# Round
# CHECK: 31 c0 d4 88
r17 = round(r21:20):sat
# CHECK: 11 df f5 8c
r17 = cround(r21, #31)
# CHECK: 91 df f5 8c
r17 = round(r21, #31)
# CHECK: d1 df f5 8c
r17 = round(r21, #31):sat
# CHECK: 11 df d5 c6
r17 = cround(r21, r31)
# CHECK: 91 df d5 c6
r17 = round(r21, r31)
# CHECK: d1 df d5 c6
r17 = round(r21, r31):sat
# Subtract doublewords
# CHECK: f0 d4 3e d3
r17:16 = sub(r21:20, r31:30)
# Subtract and accumulate words
# CHECK: 71 d5 1f ef
r17 += sub(r21, r31)
# Subtract halfword
# CHECK: 11 d5 3f d5
r17 = sub(r21.l, r31.l)
# CHECK: 51 d5 3f d5
r17 = sub(r21.l, r31.h)
# CHECK: 91 d5 3f d5
r17 = sub(r21.l, r31.l):sat
# CHECK: d1 d5 3f d5
r17 = sub(r21.l, r31.h):sat
# CHECK: 11 d5 7f d5
r17 = sub(r21.l, r31.l):<<16
# CHECK: 31 d5 7f d5
r17 = sub(r21.l, r31.h):<<16
# CHECK: 51 d5 7f d5
r17 = sub(r21.h, r31.l):<<16
# CHECK: 71 d5 7f d5
r17 = sub(r21.h, r31.h):<<16
# CHECK: 91 d5 7f d5
r17 = sub(r21.l, r31.l):sat:<<16
# CHECK: b1 d5 7f d5
r17 = sub(r21.l, r31.h):sat:<<16
# CHECK: d1 d5 7f d5
r17 = sub(r21.h, r31.l):sat:<<16
# CHECK: f1 d5 7f d5
r17 = sub(r21.h, r31.h):sat:<<16
# Sign extend word to doubleword
# CHECK: 10 c0 55 84
r17:16 = sxtw(r21)
# Vector absolute value halfwords
# CHECK: 90 c0 54 80
r17:16 = vabsh(r21:20)
# CHECK: b0 c0 54 80
r17:16 = vabsh(r21:20):sat
# Vector absolute value words
# CHECK: d0 c0 54 80
r17:16 = vabsw(r21:20)
# CHECK: f0 c0 54 80
r17:16 = vabsw(r21:20):sat
# Vector absolute difference halfwords
# CHECK: 10 d4 7e e8
r17:16 = vabsdiffh(r21:20, r31:30)
# Vector absolute difference words
# CHECK: 10 d4 3e e8
r17:16 = vabsdiffw(r21:20, r31:30)
# Vector add halfwords
# CHECK: 50 de 14 d3
r17:16 = vaddh(r21:20, r31:30)
# CHECK: 70 de 14 d3
r17:16 = vaddh(r21:20, r31:30):sat
# CHECK: 90 de 14 d3
r17:16 = vadduh(r21:20, r31:30):sat
# Vector add halfwords with saturate and pack to unsigned bytes
# CHECK: 31 de 54 c1
r17 = vaddhub(r21:20, r31:30):sat
# Vector reduce add unsigned bytes
# CHECK: 30 de 54 e8
r17:16 = vraddub(r21:20, r31:30)
# CHECK: 30 de 54 ea
r17:16 += vraddub(r21:20, r31:30)
# Vector reduce add halfwords
# CHECK: 31 de 14 e9
r17 = vradduh(r21:20, r31:30)
# CHECK: f1 de 34 e9
r17 = vraddh(r21:20, r31:30)
# Vector add bytes
# CHECK: 10 de 14 d3
r17:16 = vaddub(r21:20, r31:30)
# CHECK: 30 de 14 d3
r17:16 = vaddub(r21:20, r31:30):sat
# Vector add words
# CHECK: b0 de 14 d3
r17:16 = vaddw(r21:20, r31:30)
# CHECK: d0 de 14 d3
r17:16 = vaddw(r21:20, r31:30):sat
# Vector average halfwords
# CHECK: 50 de 54 d3
r17:16 = vavgh(r21:20, r31:30)
# CHECK: 70 de 54 d3
r17:16 = vavgh(r21:20, r31:30):rnd
# CHECK: 90 de 54 d3
r17:16 = vavgh(r21:20, r31:30):crnd
# CHECK: b0 de 54 d3
r17:16 = vavguh(r21:20, r31:30)
# CHECK: d0 de 54 d3
r17:16 = vavguh(r21:20, r31:30):rnd
# CHECK: 10 d4 9e d3
r17:16 = vnavgh(r21:20, r31:30)
# CHECK: 30 d4 9e d3
r17:16 = vnavgh(r21:20, r31:30):rnd:sat
# CHECK: 50 d4 9e d3
r17:16 = vnavgh(r21:20, r31:30):crnd:sat
# Vector average unsigned bytes
# CHECK: 10 de 54 d3
r17:16 = vavgub(r21:20, r31:30)
# CHECK: 30 de 54 d3
r17:16 = vavgub(r21:20, r31:30):rnd
# Vector average words
# CHECK: 10 de 74 d3
r17:16 = vavgw(r21:20, r31:30)
# CHECK: 30 de 74 d3
r17:16 = vavgw(r21:20, r31:30):rnd
# CHECK: 50 de 74 d3
r17:16 = vavgw(r21:20, r31:30):crnd
# CHECK: 70 de 74 d3
r17:16 = vavguw(r21:20, r31:30)
# CHECK: 90 de 74 d3
r17:16 = vavguw(r21:20, r31:30):rnd
# CHECK: 70 d4 9e d3
r17:16 = vnavgw(r21:20, r31:30)
# CHECK: 90 d4 9e d3
r17:16 = vnavgw(r21:20, r31:30):rnd:sat
# CHECK: d0 d4 9e d3
r17:16 = vnavgw(r21:20, r31:30):crnd:sat
# Vector conditional negate
# CHECK: 50 df d4 c3
r17:16 = vcnegh(r21:20, r31)
# CHECK: f0 ff 34 cb
r17:16 += vrcnegh(r21:20, r31)
# Vector maximum bytes
# CHECK: 10 d4 de d3
r17:16 = vmaxub(r21:20, r31:30)
# CHECK: d0 d4 de d3
r17:16 = vmaxb(r21:20, r31:30)
# Vector maximum halfwords
# CHECK: 30 d4 de d3
r17:16 = vmaxh(r21:20, r31:30)
# CHECK: 50 d4 de d3
r17:16 = vmaxuh(r21:20, r31:30)
# Vector reduce maximum halfwords
# CHECK: 3f d0 34 cb
r17:16 = vrmaxh(r21:20, r31)
# CHECK: 3f f0 34 cb
r17:16 = vrmaxuh(r21:20, r31)
# Vector reduce maximum words
# CHECK: 5f d0 34 cb
r17:16 = vrmaxw(r21:20, r31)
# CHECK: 5f f0 34 cb
r17:16 = vrmaxuw(r21:20, r31)
# Vector maximum words
# CHECK: b0 d4 be d3
r17:16 = vmaxuw(r21:20, r31:30)
# CHECK: 70 d4 de d3
r17:16 = vmaxw(r21:20, r31:30)
# Vector minimum bytes
# CHECK: 10 d4 be d3
r17:16 = vminub(r21:20, r31:30)
# CHECK: f0 d4 de d3
r17:16 = vminb(r21:20, r31:30)
# Vector minimum halfwords
# CHECK: 30 d4 be d3
r17:16 = vminh(r21:20, r31:30)
# CHECK: 50 d4 be d3
r17:16 = vminuh(r21:20, r31:30)
# Vector reduce minimum halfwords
# CHECK: bf d0 34 cb
r17:16 = vrminh(r21:20, r31)
# CHECK: bf f0 34 cb
r17:16 = vrminuh(r21:20, r31)
# Vector reduce minimum words
# CHECK: df d0 34 cb
r17:16 = vrminw(r21:20, r31)
# CHECK: df f0 34 cb
r17:16 = vrminuw(r21:20, r31)
# Vector minimum words
# CHECK: 70 d4 be d3
r17:16 = vminw(r21:20, r31:30)
# CHECK: 90 d4 be d3
r17:16 = vminuw(r21:20, r31:30)
# Vector sum of absolute differences unsigned bytes
# CHECK: 50 de 54 e8
r17:16 = vrsadub(r21:20, r31:30)
# CHECK: 50 de 54 ea
r17:16 += vrsadub(r21:20, r31:30)
# Vector subtract halfwords
# CHECK: 50 d4 3e d3
r17:16 = vsubh(r21:20, r31:30)
# CHECK: 70 d4 3e d3
r17:16 = vsubh(r21:20, r31:30):sat
# CHECK: 90 d4 3e d3
r17:16 = vsubuh(r21:20, r31:30):sat
# Vector subtract bytes
# CHECK: 10 d4 3e d3
r17:16 = vsubub(r21:20, r31:30)
# CHECK: 30 d4 3e d3
r17:16 = vsubub(r21:20, r31:30):sat
# Vector subtract words
# CHECK: b0 d4 3e d3
r17:16 = vsubw(r21:20, r31:30)
# CHECK: d0 d4 3e d3
r17:16 = vsubw(r21:20, r31:30):sat

118
external/llvm/test/MC/Hexagon/instructions/xtype_bit.s vendored
View File

@@ -1,118 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.10.2 XTYPE/BIT
# Count leading
# CHECK: 11 c0 54 88
r17 = clb(r21:20)
# CHECK: 51 c0 54 88
r17 = cl0(r21:20)
# CHECK: 91 c0 54 88
r17 = cl1(r21:20)
# CHECK: 11 c0 74 88
r17 = normamt(r21:20)
# CHECK: 51 d7 74 88
r17 = add(clb(r21:20), #23)
# CHECK: 11 d7 35 8c
r17 = add(clb(r21), #23)
# CHECK: 91 c0 15 8c
r17 = clb(r21)
# CHECK: b1 c0 15 8c
r17 = cl0(r21)
# CHECK: d1 c0 15 8c
r17 = cl1(r21)
# CHECK: f1 c0 15 8c
r17 = normamt(r21)
# Count population
# CHECK: 71 c0 74 88
r17 = popcount(r21:20)
# Count trailing
# CHECK: 51 c0 f4 88
r17 = ct0(r21:20)
# CHECK: 91 c0 f4 88
r17 = ct1(r21:20)
# CHECK: 91 c0 55 8c
r17 = ct0(r21)
# CHECK: b1 c0 55 8c
r17 = ct1(r21)
# Extract bitfield
# CHECK: f0 df 54 81
r17:16 = extractu(r21:20, #31, #23)
# CHECK: f0 df 54 8a
r17:16 = extract(r21:20, #31, #23)
# CHECK: f1 df 55 8d
r17 = extractu(r21, #31, #23)
# CHECK: f1 df d5 8d
r17 = extract(r21, #31, #23)
# CHECK: 10 de 14 c1
r17:16 = extractu(r21:20, r31:30)
# CHECK: 90 de d4 c1
r17:16 = extract(r21:20, r31:30)
# CHECK: 11 de 15 c9
r17 = extractu(r21, r31:30)
# CHECK: 51 de 15 c9
r17 = extract(r21, r31:30)
# Insert bitfield
# CHECK: f0 df 54 83
r17:16 = insert(r21:20, #31, #23)
# CHECK: f1 df 55 8f
r17 = insert(r21, #31, #23)
# CHECK: 11 de 15 c8
r17 = insert(r21, r31:30)
# CHECK: 10 de 14 ca
r17:16 = insert(r21:20, r31:30)
# Interleave/deinterleave
# CHECK: 90 c0 d4 80
r17:16 = deinterleave(r21:20)
# CHECK: b0 c0 d4 80
r17:16 = interleave(r21:20)
# Linear feedback-shift iteration
# CHECK: d0 de 94 c1
r17:16 = lfs(r21:20, r31:30)
# Masked parity
# CHECK: 11 de 14 d0
r17 = parity(r21:20, r31:30)
# CHECK: 11 df f5 d5
r17 = parity(r21, r31)
# Bit reverse
# CHECK: d0 c0 d4 80
r17:16 = brev(r21:20)
# CHECK: d1 c0 55 8c
r17 = brev(r21)
# Set/clear/toggle bit
# CHECK: 11 df d5 8c
r17 = setbit(r21, #31)
# CHECK: 31 df d5 8c
r17 = clrbit(r21, #31)
# CHECK: 51 df d5 8c
r17 = togglebit(r21, #31)
# CHECK: 11 df 95 c6
r17 = setbit(r21, r31)
# CHECK: 51 df 95 c6
r17 = clrbit(r21, r31)
# CHECK: 91 df 95 c6
r17 = togglebit(r21, r31)
# Split bitfield
# CHECK: 90 df d5 88
r17:16 = bitsplit(r21, #31)
# CHECK: 10 df 35 d4
r17:16 = bitsplit(r21, r31)
# Table index
# CHECK: f1 cd 15 87
r17 = tableidxb(r21, #7, #13):raw
# CHECK: f1 cd 55 87
r17 = tableidxh(r21, #7, #13):raw
# CHECK: f1 cd 95 87
r17 = tableidxw(r21, #7, #13):raw
# CHECK: f1 cd d5 87
r17 = tableidxd(r21, #7, #13):raw

128
external/llvm/test/MC/Hexagon/instructions/xtype_complex.s vendored
View File

@@ -1,128 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.10.3 XTYPE/COMPLEX
# Complex add/sub halfwords
# CHECK: 90 de 54 c1
r17:16 = vxaddsubh(r21:20, r31:30):sat
# CHECK: d0 de 54 c1
r17:16 = vxsubaddh(r21:20, r31:30):sat
# CHECK: 10 de d4 c1
r17:16 = vxaddsubh(r21:20, r31:30):rnd:>>1:sat
# CHECK: 50 de d4 c1
r17:16 = vxsubaddh(r21:20, r31:30):rnd:>>1:sat
# Complex add/sub words
# CHECK: 10 de 54 c1
r17:16 = vxaddsubw(r21:20, r31:30):sat
# CHECK: 50 de 54 c1
r17:16 = vxsubaddw(r21:20, r31:30):sat
# Complex multiply
# CHECK: d0 df 15 e5
r17:16 = cmpy(r21, r31):sat
# CHECK: d0 df 95 e5
r17:16 = cmpy(r21, r31):<<1:sat
# CHECK: d0 df 55 e5
r17:16 = cmpy(r21, r31*):sat
# CHECK: d0 df d5 e5
r17:16 = cmpy(r21, r31*):<<1:sat
# CHECK: d0 df 15 e7
r17:16 += cmpy(r21, r31):sat
# CHECK: d0 df 95 e7
r17:16 += cmpy(r21, r31):<<1:sat
# CHECK: f0 df 15 e7
r17:16 -= cmpy(r21, r31):sat
# CHECK: f0 df 95 e7
r17:16 -= cmpy(r21, r31):<<1:sat
# CHECK: d0 df 55 e7
r17:16 += cmpy(r21, r31*):sat
# CHECK: d0 df d5 e7
r17:16 += cmpy(r21, r31*):<<1:sat
# CHECK: f0 df 55 e7
r17:16 -= cmpy(r21, r31*):sat
# CHECK: f0 df d5 e7
r17:16 -= cmpy(r21, r31*):<<1:sat
# Complex multiply real or imaginary
# CHECK: 30 df 15 e5
r17:16 = cmpyi(r21, r31)
# CHECK: 50 df 15 e5
r17:16 = cmpyr(r21, r31)
# CHECK: 30 df 15 e7
r17:16 += cmpyi(r21, r31)
# CHECK: 50 df 15 e7
r17:16 += cmpyr(r21, r31)
# Complex multiply with round and pack
# CHECK: d1 df 35 ed
r17 = cmpy(r21, r31):rnd:sat
# CHECK: d1 df b5 ed
r17 = cmpy(r21, r31):<<1:rnd:sat
# CHECK: d1 df 75 ed
r17 = cmpy(r21, r31*):rnd:sat
# CHECK: d1 df f5 ed
r17 = cmpy(r21, r31*):<<1:rnd:sat
# Complex multiply 32x16
# CHECK: 91 df 14 c5
r17 = cmpyiwh(r21:20, r31):<<1:rnd:sat
# CHECK: b1 df 14 c5
r17 = cmpyiwh(r21:20, r31*):<<1:rnd:sat
# CHECK: d1 df 14 c5
r17 = cmpyrwh(r21:20, r31):<<1:rnd:sat
# CHECK: f1 df 14 c5
r17 = cmpyrwh(r21:20, r31*):<<1:rnd:sat
# Vector complex multiply real or imaginary
# CHECK: d0 de 34 e8
r17:16 = vcmpyr(r21:20, r31:30):sat
# CHECK: d0 de b4 e8
r17:16 = vcmpyr(r21:20, r31:30):<<1:sat
# CHECK: d0 de 54 e8
r17:16 = vcmpyi(r21:20, r31:30):sat
# CHECK: d0 de d4 e8
r17:16 = vcmpyi(r21:20, r31:30):<<1:sat
# CHECK: 90 de 34 ea
r17:16 += vcmpyr(r21:20, r31:30):sat
# CHECK: 90 de 54 ea
r17:16 += vcmpyi(r21:20, r31:30):sat
# Vector complex conjugate
# CHECK: f0 c0 94 80
r17:16 = vconj(r21:20):sat
# Vector complex rotate
# CHECK: 10 df d4 c3
r17:16 = vcrotate(r21:20, r31)
# Vector reduce complex multiply real or imaginary
# CHECK: 10 de 14 e8
r17:16 = vrcmpyi(r21:20, r31:30)
# CHECK: 30 de 14 e8
r17:16 = vrcmpyr(r21:20, r31:30)
# CHECK: 10 de 54 e8
r17:16 = vrcmpyi(r21:20, r31:30*)
# CHECK: 30 de 74 e8
r17:16 = vrcmpyr(r21:20, r31:30*)
# Vector reduce complex multiply by scalar
# CHECK: 90 de b4 e8
r17:16 = vrcmpys(r21:20, r31:30):<<1:sat:raw:hi
# CHECK: 90 de f4 e8
r17:16 = vrcmpys(r21:20, r31:30):<<1:sat:raw:lo
# CHECK: 90 de b4 ea
r17:16 += vrcmpys(r21:20, r31:30):<<1:sat:raw:hi
# CHECK: 90 de f4 ea
r17:16 += vrcmpys(r21:20, r31:30):<<1:sat:raw:lo
# Vector reduce complex multiply by scalar with round and pack
# CHECK: d1 de b4 e9
r17 = vrcmpys(r21:20, r31:30):<<1:rnd:sat:raw:hi
# CHECK: f1 de b4 e9
r17 = vrcmpys(r21:20, r31:30):<<1:rnd:sat:raw:lo
# Vector reduce complex rotate
# CHECK: f0 ff d4 c3
r17:16 = vrcrotate(r21:20, r31, #3)
# CHECK: 30 ff b4 cb
r17:16 += vrcrotate(r21:20, r31, #3)

146
external/llvm/test/MC/Hexagon/instructions/xtype_fp.s vendored
View File

@@ -1,146 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.10.4 XTYPE/FP
# Floating point addition
# CHECK: 11 df 15 eb
r17 = sfadd(r21, r31)
# Classify floating-point value
# CHECK: 03 d5 f1 85
p3 = sfclass(r17, #21)
# CHECK: b3 c2 90 dc
p3 = dfclass(r17:16, #21)
# Compare floating-point value
# CHECK: 03 d5 f1 c7
p3 = sfcmp.ge(r17, r21)
# CHECK: 23 d5 f1 c7
p3 = sfcmp.uo(r17, r21)
# CHECK: 63 d5 f1 c7
p3 = sfcmp.eq(r17, r21)
# CHECK: 83 d5 f1 c7
p3 = sfcmp.gt(r17, r21)
# CHECK: 03 d4 f0 d2
p3 = dfcmp.eq(r17:16, r21:20)
# CHECK: 23 d4 f0 d2
p3 = dfcmp.gt(r17:16, r21:20)
# CHECK: 43 d4 f0 d2
p3 = dfcmp.ge(r17:16, r21:20)
# CHECK: 63 d4 f0 d2
p3 = dfcmp.uo(r17:16, r21:20)
# Convert floating-point value to other format
# CHECK: 10 c0 95 84
r17:16 = convert_sf2df(r21)
# CHECK: 31 c0 14 88
r17 = convert_df2sf(r21:20)
# Convert integer to floating-point value
# CHECK: 50 c0 f4 80
r17:16 = convert_ud2df(r21:20)
# CHECK: 70 c0 f4 80
r17:16 = convert_d2df(r21:20)
# CHECK: 30 c0 95 84
r17:16 = convert_uw2df(r21)
# CHECK: 50 c0 95 84
r17:16 = convert_w2df(r21)
# CHECK: 31 c0 34 88
r17 = convert_ud2sf(r21:20)
# CHECK: 31 c0 54 88
r17 = convert_d2sf(r21:20)
# CHECK: 11 c0 35 8b
r17 = convert_uw2sf(r21)
# CHECK: 11 c0 55 8b
r17 = convert_w2sf(r21)
# Convert floating-point value to integer
# CHECK: 10 c0 f4 80
r17:16 = convert_df2d(r21:20)
# CHECK: 30 c0 f4 80
r17:16 = convert_df2ud(r21:20)
# CHECK: d0 c0 f4 80
r17:16 = convert_df2d(r21:20):chop
# CHECK: f0 c0 f4 80
r17:16 = convert_df2ud(r21:20):chop
# CHECK: 70 c0 95 84
r17:16 = convert_sf2ud(r21)
# CHECK: 90 c0 95 84
r17:16 = convert_sf2d(r21)
# CHECK: b0 c0 95 84
r17:16 = convert_sf2ud(r21):chop
# CHECK: d0 c0 95 84
r17:16 = convert_sf2d(r21):chop
# CHECK: 31 c0 74 88
r17 = convert_df2uw(r21:20)
# CHECK: 31 c0 94 88
r17 = convert_df2w(r21:20)
# CHECK: 31 c0 b4 88
r17 = convert_df2uw(r21:20):chop
# CHECK: 31 c0 f4 88
r17 = convert_df2w(r21:20):chop
# CHECK: 11 c0 75 8b
r17 = convert_sf2uw(r21)
# CHECK: 31 c0 75 8b
r17 = convert_sf2uw(r21):chop
# CHECK: 11 c0 95 8b
r17 = convert_sf2w(r21)
# CHECK: 31 c0 95 8b
r17 = convert_sf2w(r21):chop
# Floating point extreme value assistance
# CHECK: 11 c0 b5 8b
r17 = sffixupr(r21)
# CHECK: 11 df d5 eb
r17 = sffixupn(r21, r31)
# CHECK: 31 df d5 eb
r17 = sffixupd(r21, r31)
# Floating point fused multiply-add
# CHECK: 91 df 15 ef
r17 += sfmpy(r21, r31)
# CHECK: b1 df 15 ef
r17 -= sfmpy(r21, r31)
# Floating point fused multiply-add with scaling
# CHECK: f1 df 75 ef
r17 += sfmpy(r21, r31, p3):scale
# Floating point reciprocal square root approximation
# CHECK: 71 c0 f5 8b
r17, p3 = sfinvsqrta(r21)
# Floating point fused multiply-add for library routines
# CHECK: d1 df 15 ef
r17 += sfmpy(r21, r31):lib
# CHECK: f1 df 15 ef
r17 -= sfmpy(r21, r31):lib
# Create floating-point constant
# CHECK: b1 c2 00 d6
r17 = sfmake(#21):pos
# CHECK: b1 c2 40 d6
r17 = sfmake(#21):neg
# CHECK: b0 c2 00 d9
r17:16 = dfmake(#21):pos
# CHECK: b0 c2 40 d9
r17:16 = dfmake(#21):neg
# Floating point maximum
# CHECK: 11 df 95 eb
r17 = sfmax(r21, r31)
# Floating point minimum
# CHECK: 31 df 95 eb
r17 = sfmin(r21, r31)
# Floating point multiply
# CHECK: 11 df 55 eb
r17 = sfmpy(r21, r31)
# Floating point reciprocal approximation
# CHECK: f1 df f5 eb
r17, p3 = sfrecipa(r21, r31)
# Floating point subtraction
# CHECK: 31 df 15 eb
r17 = sfsub(r21, r31)

400
external/llvm/test/MC/Hexagon/instructions/xtype_mpy.s vendored
View File

@@ -1,400 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.10.5 XTYPE/MPY
# Multiply and use lower result
# CHECK: b1 df 35 d7
r17 = add(#21, mpyi(r21, r31))
# CHECK: bf d1 35 d8
r17 = add(#21, mpyi(r21, #31))
# CHECK: b5 d1 3f df
r17 = add(r21, mpyi(#84, r31))
# CHECK: f5 f1 b5 df
r17 = add(r21, mpyi(r21, #31))
# CHECK: 15 d1 1f e3
r17 = add(r21, mpyi(r17, r31))
# CHECK: f1 c3 15 e0
r17 =+ mpyi(r21, #31)
# CHECK: f1 c3 95 e0
r17 =- mpyi(r21, #31)
# CHECK: f1 c3 15 e1
r17 += mpyi(r21, #31)
# CHECK: f1 c3 95 e1
r17 -= mpyi(r21, #31)
# CHECK: 11 df 15 ed
r17 = mpyi(r21, r31)
# CHECK: 11 df 15 ef
r17 += mpyi(r21, r31)
# Vector multiply word by signed half (32x16)
# CHECK: b0 de 14 e8
r17:16 = vmpyweh(r21:20, r31:30):sat
# CHECK: b0 de 94 e8
r17:16 = vmpyweh(r21:20, r31:30):<<1:sat
# CHECK: f0 de 14 e8
r17:16 = vmpywoh(r21:20, r31:30):sat
# CHECK: f0 de 94 e8
r17:16 = vmpywoh(r21:20, r31:30):<<1:sat
# CHECK: b0 de 34 e8
r17:16 = vmpyweh(r21:20, r31:30):rnd:sat
# CHECK: b0 de b4 e8
r17:16 = vmpyweh(r21:20, r31:30):<<1:rnd:sat
# CHECK: f0 de 34 e8
r17:16 = vmpywoh(r21:20, r31:30):rnd:sat
# CHECK: f0 de b4 e8
r17:16 = vmpywoh(r21:20, r31:30):<<1:rnd:sat
# CHECK: b0 de 14 ea
r17:16 += vmpyweh(r21:20, r31:30):sat
# CHECK: b0 de 94 ea
r17:16 += vmpyweh(r21:20, r31:30):<<1:sat
# CHECK: f0 de 14 ea
r17:16 += vmpywoh(r21:20, r31:30):sat
# CHECK: f0 de 94 ea
r17:16 += vmpywoh(r21:20, r31:30):<<1:sat
# CHECK: b0 de 34 ea
r17:16 += vmpyweh(r21:20, r31:30):rnd:sat
# CHECK: b0 de b4 ea
r17:16 += vmpyweh(r21:20, r31:30):<<1:rnd:sat
# CHECK: f0 de 34 ea
r17:16 += vmpywoh(r21:20, r31:30):rnd:sat
# CHECK: f0 de b4 ea
r17:16 += vmpywoh(r21:20, r31:30):<<1:rnd:sat
# Vector multiply word by unsigned half (32x16)
# CHECK: b0 de 54 e8
r17:16 = vmpyweuh(r21:20, r31:30):sat
# CHECK: b0 de d4 e8
r17:16 = vmpyweuh(r21:20, r31:30):<<1:sat
# CHECK: f0 de 54 e8
r17:16 = vmpywouh(r21:20, r31:30):sat
# CHECK: f0 de d4 e8
r17:16 = vmpywouh(r21:20, r31:30):<<1:sat
# CHECK: b0 de 74 e8
r17:16 = vmpyweuh(r21:20, r31:30):rnd:sat
# CHECK: b0 de f4 e8
r17:16 = vmpyweuh(r21:20, r31:30):<<1:rnd:sat
# CHECK: f0 de 74 e8
r17:16 = vmpywouh(r21:20, r31:30):rnd:sat
# CHECK: f0 de f4 e8
r17:16 = vmpywouh(r21:20, r31:30):<<1:rnd:sat
# CHECK: b0 de 54 ea
r17:16 += vmpyweuh(r21:20, r31:30):sat
# CHECK: b0 de d4 ea
r17:16 += vmpyweuh(r21:20, r31:30):<<1:sat
# CHECK: f0 de 54 ea
r17:16 += vmpywouh(r21:20, r31:30):sat
# CHECK: f0 de d4 ea
r17:16 += vmpywouh(r21:20, r31:30):<<1:sat
# CHECK: b0 de 74 ea
r17:16 += vmpyweuh(r21:20, r31:30):rnd:sat
# CHECK: b0 de f4 ea
r17:16 += vmpyweuh(r21:20, r31:30):<<1:rnd:sat
# CHECK: f0 de 74 ea
r17:16 += vmpywouh(r21:20, r31:30):rnd:sat
# CHECK: f0 de f4 ea
r17:16 += vmpywouh(r21:20, r31:30):<<1:rnd:sat
# Multiply signed halfwords
# CHECK: 10 df 95 e4
r17:16 = mpy(r21.l, r31.l):<<1
# CHECK: 30 df 95 e4
r17:16 = mpy(r21.l, r31.h):<<1
# CHECK: 50 df 95 e4
r17:16 = mpy(r21.h, r31.l):<<1
# CHECK: 70 df 95 e4
r17:16 = mpy(r21.h, r31.h):<<1
# CHECK: 10 df b5 e4
r17:16 = mpy(r21.l, r31.l):<<1:rnd
# CHECK: 30 df b5 e4
r17:16 = mpy(r21.l, r31.h):<<1:rnd
# CHECK: 50 df b5 e4
r17:16 = mpy(r21.h, r31.l):<<1:rnd
# CHECK: 70 df b5 e4
r17:16 = mpy(r21.h, r31.h):<<1:rnd
# CHECK: 10 df 95 e6
r17:16 += mpy(r21.l, r31.l):<<1
# CHECK: 30 df 95 e6
r17:16 += mpy(r21.l, r31.h):<<1
# CHECK: 50 df 95 e6
r17:16 += mpy(r21.h, r31.l):<<1
# CHECK: 70 df 95 e6
r17:16 += mpy(r21.h, r31.h):<<1
# CHECK: 10 df b5 e6
r17:16 -= mpy(r21.l, r31.l):<<1
# CHECK: 30 df b5 e6
r17:16 -= mpy(r21.l, r31.h):<<1
# CHECK: 50 df b5 e6
r17:16 -= mpy(r21.h, r31.l):<<1
# CHECK: 70 df b5 e6
r17:16 -= mpy(r21.h, r31.h):<<1
# CHECK: 11 df 95 ec
r17 = mpy(r21.l, r31.l):<<1
# CHECK: 31 df 95 ec
r17 = mpy(r21.l, r31.h):<<1
# CHECK: 51 df 95 ec
r17 = mpy(r21.h, r31.l):<<1
# CHECK: 71 df 95 ec
r17 = mpy(r21.h, r31.h):<<1
# CHECK: 91 df 95 ec
r17 = mpy(r21.l, r31.l):<<1:sat
# CHECK: b1 df 95 ec
r17 = mpy(r21.l, r31.h):<<1:sat
# CHECK: d1 df 95 ec
r17 = mpy(r21.h, r31.l):<<1:sat
# CHECK: f1 df 95 ec
r17 = mpy(r21.h, r31.h):<<1:sat
# CHECK: 11 df b5 ec
r17 = mpy(r21.l, r31.l):<<1:rnd
# CHECK: 31 df b5 ec
r17 = mpy(r21.l, r31.h):<<1:rnd
# CHECK: 51 df b5 ec
r17 = mpy(r21.h, r31.l):<<1:rnd
# CHECK: 71 df b5 ec
r17 = mpy(r21.h, r31.h):<<1:rnd
# CHECK: 91 df b5 ec
r17 = mpy(r21.l, r31.l):<<1:rnd:sat
# CHECK: b1 df b5 ec
r17 = mpy(r21.l, r31.h):<<1:rnd:sat
# CHECK: d1 df b5 ec
r17 = mpy(r21.h, r31.l):<<1:rnd:sat
# CHECK: f1 df b5 ec
r17 = mpy(r21.h, r31.h):<<1:rnd:sat
# CHECK: 11 df 95 ee
r17 += mpy(r21.l, r31.l):<<1
# CHECK: 31 df 95 ee
r17 += mpy(r21.l, r31.h):<<1
# CHECK: 51 df 95 ee
r17 += mpy(r21.h, r31.l):<<1
# CHECK: 71 df 95 ee
r17 += mpy(r21.h, r31.h):<<1
# CHECK: 91 df 95 ee
r17 += mpy(r21.l, r31.l):<<1:sat
# CHECK: b1 df 95 ee
r17 += mpy(r21.l, r31.h):<<1:sat
# CHECK: d1 df 95 ee
r17 += mpy(r21.h, r31.l):<<1:sat
# CHECK: f1 df 95 ee
r17 += mpy(r21.h, r31.h):<<1:sat
# CHECK: 11 df b5 ee
r17 -= mpy(r21.l, r31.l):<<1
# CHECK: 31 df b5 ee
r17 -= mpy(r21.l, r31.h):<<1
# CHECK: 51 df b5 ee
r17 -= mpy(r21.h, r31.l):<<1
# CHECK: 71 df b5 ee
r17 -= mpy(r21.h, r31.h):<<1
# CHECK: 91 df b5 ee
r17 -= mpy(r21.l, r31.l):<<1:sat
# CHECK: b1 df b5 ee
r17 -= mpy(r21.l, r31.h):<<1:sat
# CHECK: d1 df b5 ee
r17 -= mpy(r21.h, r31.l):<<1:sat
# CHECK: f1 df b5 ee
r17 -= mpy(r21.h, r31.h):<<1:sat
# Multiply unsigned halfwords
# CHECK: 10 df d5 e4
r17:16 = mpyu(r21.l, r31.l):<<1
# CHECK: 30 df d5 e4
r17:16 = mpyu(r21.l, r31.h):<<1
# CHECK: 50 df d5 e4
r17:16 = mpyu(r21.h, r31.l):<<1
# CHECK: 70 df d5 e4
r17:16 = mpyu(r21.h, r31.h):<<1
# CHECK: 10 df d5 e6
r17:16 += mpyu(r21.l, r31.l):<<1
# CHECK: 30 df d5 e6
r17:16 += mpyu(r21.l, r31.h):<<1
# CHECK: 50 df d5 e6
r17:16 += mpyu(r21.h, r31.l):<<1
# CHECK: 70 df d5 e6
r17:16 += mpyu(r21.h, r31.h):<<1
# CHECK: 10 df f5 e6
r17:16 -= mpyu(r21.l, r31.l):<<1
# CHECK: 30 df f5 e6
r17:16 -= mpyu(r21.l, r31.h):<<1
# CHECK: 50 df f5 e6
r17:16 -= mpyu(r21.h, r31.l):<<1
# CHECK: 70 df f5 e6
r17:16 -= mpyu(r21.h, r31.h):<<1
# CHECK: 11 df d5 ec
r17 = mpyu(r21.l, r31.l):<<1
# CHECK: 31 df d5 ec
r17 = mpyu(r21.l, r31.h):<<1
# CHECK: 51 df d5 ec
r17 = mpyu(r21.h, r31.l):<<1
# CHECK: 71 df d5 ec
r17 = mpyu(r21.h, r31.h):<<1
# CHECK: 11 df d5 ee
r17 += mpyu(r21.l, r31.l):<<1
# CHECK: 31 df d5 ee
r17 += mpyu(r21.l, r31.h):<<1
# CHECK: 51 df d5 ee
r17 += mpyu(r21.h, r31.l):<<1
# CHECK: 71 df d5 ee
r17 += mpyu(r21.h, r31.h):<<1
# CHECK: 11 df f5 ee
r17 -= mpyu(r21.l, r31.l):<<1
# CHECK: 31 df f5 ee
r17 -= mpyu(r21.l, r31.h):<<1
# CHECK: 51 df f5 ee
r17 -= mpyu(r21.h, r31.l):<<1
# CHECK: 71 df f5 ee
r17 -= mpyu(r21.h, r31.h):<<1
# Polynomial multiply words
# CHECK: f0 df 55 e5
r17:16 = pmpyw(r21, r31)
# CHECK: f0 df 35 e7
r17:16 ^= pmpyw(r21, r31)
# Vector reduce multiply word by signed half (32x16)
# CHECK: 50 de 34 e8
r17:16 = vrmpywoh(r21:20, r31:30)
# CHECK: 50 de b4 e8
r17:16 = vrmpywoh(r21:20, r31:30):<<1
# CHECK: 90 de 54 e8
r17:16 = vrmpyweh(r21:20, r31:30)
# CHECK: 90 de d4 e8
r17:16 = vrmpyweh(r21:20, r31:30):<<1
# CHECK: d0 de 74 ea
r17:16 += vrmpywoh(r21:20, r31:30)
# CHECK: d0 de f4 ea
r17:16 += vrmpywoh(r21:20, r31:30):<<1
# CHECK: d0 de 34 ea
r17:16 += vrmpyweh(r21:20, r31:30)
# CHECK: d0 de b4 ea
r17:16 += vrmpyweh(r21:20, r31:30):<<1
# Multiply and use upper result
# CHECK: 31 df 15 ed
r17 = mpy(r21, r31)
# CHECK: 31 df 35 ed
r17 = mpy(r21, r31):rnd
# CHECK: 31 df 55 ed
r17 = mpyu(r21, r31)
# CHECK: 31 df 75 ed
r17 = mpysu(r21, r31)
# CHECK: 11 df b5 ed
r17 = mpy(r21, r31.h):<<1:sat
# CHECK: 31 df b5 ed
r17 = mpy(r21, r31.l):<<1:sat
# CHECK: 91 df b5 ed
r17 = mpy(r21, r31.h):<<1:rnd:sat
# CHECK: 11 df f5 ed
r17 = mpy(r21, r31):<<1:sat
# CHECK: 91 df f5 ed
r17 = mpy(r21, r31.l):<<1:rnd:sat
# CHECK: 51 df b5 ed
r17 = mpy(r21, r31):<<1
# CHECK: 11 df 75 ef
r17 += mpy(r21, r31):<<1:sat
# CHECK: 31 df 75 ef
r17 -= mpy(r21, r31):<<1:sat
# Multiply and use full result
# CHECK: 10 df 15 e5
r17:16 = mpy(r21, r31)
# CHECK: 10 df 55 e5
r17:16 = mpyu(r21, r31)
# CHECK: 10 df 15 e7
r17:16 += mpy(r21, r31)
# CHECK: 10 df 35 e7
r17:16 -= mpy(r21, r31)
# CHECK: 10 df 55 e7
r17:16 += mpyu(r21, r31)
# CHECK: 10 df 75 e7
r17:16 -= mpyu(r21, r31)
# Vector dual multiply
# CHECK: 90 de 14 e8
r17:16 = vdmpy(r21:20, r31:30):sat
# CHECK: 90 de 94 e8
r17:16 = vdmpy(r21:20, r31:30):<<1:sat
# CHECK: 90 de 14 ea
r17:16 += vdmpy(r21:20, r31:30):sat
# CHECK: 90 de 94 ea
r17:16 += vdmpy(r21:20, r31:30):<<1:sat
# Vector dual multiply with round and pack
# CHECK: 11 de 14 e9
r17 = vdmpy(r21:20, r31:30):rnd:sat
# CHECK: 11 de 94 e9
r17 = vdmpy(r21:20, r31:30):<<1:rnd:sat
# Vector reduce multiply bytes
# CHECK: 30 de 94 e8
r17:16 = vrmpybu(r21:20, r31:30)
# CHECK: 30 de d4 e8
r17:16 = vrmpybsu(r21:20, r31:30)
# CHECK: 30 de 94 ea
r17:16 += vrmpybu(r21:20, r31:30)
# CHECK: 30 de d4 ea
r17:16 += vrmpybsu(r21:20, r31:30)
# Vector dual multiply signed by unsigned bytes
# CHECK: 30 de b4 e8
r17:16 = vdmpybsu(r21:20, r31:30):sat
# CHECK: 30 de 34 ea
r17:16 += vdmpybsu(r21:20, r31:30):sat
# Vector multiply even haldwords
# CHECK: d0 de 14 e8
r17:16 = vmpyeh(r21:20, r31:30):sat
# CHECK: d0 de 94 e8
r17:16 = vmpyeh(r21:20, r31:30):<<1:sat
# CHECK: 50 de 34 ea
r17:16 += vmpyeh(r21:20, r31:30)
# CHECK: d0 de 14 ea
r17:16 += vmpyeh(r21:20, r31:30):sat
# CHECK: d0 de 94 ea
r17:16 += vmpyeh(r21:20, r31:30):<<1:sat
# Vector multiply halfwords
# CHECK: b0 df 15 e5
r17:16 = vmpyh(r21, r31):sat
# CHECK: b0 df 95 e5
r17:16 = vmpyh(r21, r31):<<1:sat
# CHECK: 30 df 35 e7
r17:16 += vmpyh(r21, r31)
# CHECK: b0 df 15 e7
r17:16 += vmpyh(r21, r31):sat
# CHECK: b0 df 95 e7
r17:16 += vmpyh(r21, r31):<<1:sat
# Vector multiply halfwords with round and pack
# CHECK: f1 df 35 ed
r17 = vmpyh(r21, r31):rnd:sat
# CHECK: f1 df b5 ed
r17 = vmpyh(r21, r31):<<1:rnd:sat
# Vector multiply halfwords signed by unsigned
# CHECK: f0 df 15 e5
r17:16 = vmpyhsu(r21, r31):sat
# CHECK: f0 df 95 e5
r17:16 = vmpyhsu(r21, r31):<<1:sat
# CHECK: b0 df 75 e7
r17:16 += vmpyhsu(r21, r31):sat
# CHECK: b0 df f5 e7
r17:16 += vmpyhsu(r21, r31):<<1:sat
# Vector reduce multiply halfwords
# CHECK: 50 de 14 e8
r17:16 = vrmpyh(r21:20, r31:30)
# CHECK: 50 de 14 ea
r17:16 += vrmpyh(r21:20, r31:30)
# Vector multiply bytes
# CHECK: 30 df 55 e5
r17:16 = vmpybsu(r21, r31)
# CHECK: 30 df 95 e5
r17:16 = vmpybu(r21, r31)
# CHECK: 30 df 95 e7
r17:16 += vmpybu(r21, r31)
# CHECK: 30 df d5 e7
r17:16 += vmpybsu(r21, r31)
# Vector polynomial multiply halfwords
# CHECK: f0 df d5 e5
r17:16 = vpmpyh(r21, r31)
# CHECK: f0 df b5 e7
r17:16 ^= vpmpyh(r21, r31)

104
external/llvm/test/MC/Hexagon/instructions/xtype_perm.s vendored
View File

@@ -1,104 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.10.6 XTYPE/PERM
# CABAC decode bin
# CHECK: d0 de d4 c1
r17:16 = decbin(r21:20, r31:30)
# Saturate
# CHECK: 11 c0 d4 88
r17 = sat(r21:20)
# CHECK: 91 c0 d5 8c
r17 = sath(r21)
# CHECK: b1 c0 d5 8c
r17 = satuh(r21)
# CHECK: d1 c0 d5 8c
r17 = satub(r21)
# CHECK: f1 c0 d5 8c
r17 = satb(r21)
# Swizzle bytes
# CHECK: f1 c0 95 8c
r17 = swiz(r21)
# Vector align
# CHECK: 70 d4 1e c2
r17:16 = valignb(r21:20, r31:30, p3)
# CHECK: 70 de 94 c2
r17:16 = vspliceb(r21:20, r31:30, p3)
# Vector round and pack
# CHECK: 91 c0 94 88
r17 = vrndwh(r21:20)
# CHECK: d1 c0 94 88
r17 = vrndwh(r21:20):sat
# Vector saturate and pack
# CHECK: 11 c0 14 88
r17 = vsathub(r21:20)
# CHECK: 51 c0 14 88
r17 = vsatwh(r21:20)
# CHECK: 91 c0 14 88
r17 = vsatwuh(r21:20)
# CHECK: d1 c0 14 88
r17 = vsathb(r21:20)
# CHECK: 11 c0 95 8c
r17 = vsathb(r21)
# CHECK: 51 c0 95 8c
r17 = vsathub(r21)
# Vector saturate without pack
# CHECK: 90 c0 14 80
r17:16 = vsathub(r21:20)
# CHECK: b0 c0 14 80
r17:16 = vsatwuh(r21:20)
# CHECK: d0 c0 14 80
r17:16 = vsatwh(r21:20)
# CHECK: f0 c0 14 80
r17:16 = vsathb(r21:20)
# Vector shuffle
# CHECK: 50 de 14 c1
r17:16 = shuffeb(r21:20, r31:30)
# CHECK: 90 d4 1e c1
r17:16 = shuffob(r21:20, r31:30)
# CHECK: d0 de 14 c1
r17:16 = shuffeh(r21:20, r31:30)
# CHECK: 10 d4 9e c1
r17:16 = shuffoh(r21:20, r31:30)
# Vector splat bytes
# CHECK: f1 c0 55 8c
r17 = vsplatb(r21)
# Vector splat halfwords
# CHECK: 50 c0 55 84
r17:16 = vsplath(r21)
# Vector splice
# CHECK: 70 de 94 c0
r17:16 = vspliceb(r21:20, r31:30, #3)
# CHECK: 70 de 94 c2
r17:16 = vspliceb(r21:20, r31:30, p3)
# Vector sign extend
# CHECK: 10 c0 15 84
r17:16 = vsxtbh(r21)
# CHECK: 90 c0 15 84
r17:16 = vsxthw(r21)
# Vector truncate
# CHECK: 11 c0 94 88
r17 = vtrunohb(r21:20)
# CHECK: 51 c0 94 88
r17 = vtrunehb(r21:20)
# CHECK: 50 de 94 c1
r17:16 = vtrunewh(r21:20, r31:30)
# CHECK: 90 de 94 c1
r17:16 = vtrunowh(r21:20, r31:30)
# Vector zero extend
# CHECK: 50 c0 15 84
r17:16 = vzxtbh(r21)
# CHECK: d0 c0 15 84
r17:16 = vzxthw(r21)

136
external/llvm/test/MC/Hexagon/instructions/xtype_pred.s vendored
View File

@@ -1,136 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.10.7 XTYPE/PRED
# Bounds check
# CHECK: 83 f4 10 d2
p3 = boundscheck(r17:16, r21:20):raw:lo
# CHECK: a3 f4 10 d2
p3 = boundscheck(r17:16, r21:20):raw:hi
# Compare byte
# CHECK: 43 d5 d1 c7
p3 = cmpb.gt(r17, r21)
# CHECK: c3 d5 d1 c7
p3 = cmpb.eq(r17, r21)
# CHECK: e3 d5 d1 c7
p3 = cmpb.gtu(r17, r21)
# CHECK: a3 c2 11 dd
p3 = cmpb.eq(r17, #21)
# CHECK: a3 c2 31 dd
p3 = cmpb.gt(r17, #21)
# CHECK: a3 c2 51 dd
p3 = cmpb.gtu(r17, #21)
# Compare half
# CHECK: 63 d5 d1 c7
p3 = cmph.eq(r17, r21)
# CHECK: 83 d5 d1 c7
p3 = cmph.gt(r17, r21)
# CHECK: a3 d5 d1 c7
p3 = cmph.gtu(r17, r21)
# CHECK: ab c2 11 dd
p3 = cmph.eq(r17, #21)
# CHECK: ab c2 31 dd
p3 = cmph.gt(r17, #21)
# CHECK: ab c2 51 dd
p3 = cmph.gtu(r17, #21)
# Compare doublewords
# CHECK: 03 de 94 d2
p3 = cmp.eq(r21:20, r31:30)
# CHECK: 43 de 94 d2
p3 = cmp.gt(r21:20, r31:30)
# CHECK: 83 de 94 d2
p3 = cmp.gtu(r21:20, r31:30)
# Compare bitmask
# CHECK: 03 d5 91 85
p3 = bitsclr(r17, #21)
# CHECK: 03 d5 b1 85
p3 = !bitsclr(r17, #21)
# CHECK: 03 d5 51 c7
p3 = bitsset(r17, r21)
# CHECK: 03 d5 71 c7
p3 = !bitsset(r17, r21)
# CHECK: 03 d5 91 c7
p3 = bitsclr(r17, r21)
# CHECK: 03 d5 b1 c7
p3 = !bitsclr(r17, r21)
# mask generate from predicate
# CHECK: 10 c3 00 86
r17:16 = mask(p3)
# Check for TLB match
# CHECK: 63 f5 10 d2
p3 = tlbmatch(r17:16, r21)
# Predicate Transfer
# CHECK: 03 c0 45 85
p3 = r5
# CHECK: 05 c0 43 89
r5 = p3
# Test bit
# CHECK: 03 d5 11 85
p3 = tstbit(r17, #21)
# CHECK: 03 d5 31 85
p3 = !tstbit(r17, #21)
# CHECK: 03 d5 11 c7
p3 = tstbit(r17, r21)
# CHECK: 03 d5 31 c7
p3 = !tstbit(r17, r21)
# Vector compare halfwords
# CHECK: 63 de 14 d2
p3 = vcmph.eq(r21:20, r31:30)
# CHECK: 83 de 14 d2
p3 = vcmph.gt(r21:20, r31:30)
# CHECK: a3 de 14 d2
p3 = vcmph.gtu(r21:20, r31:30)
# CHECK: eb c3 14 dc
p3 = vcmph.eq(r21:20, #31)
# CHECK: eb c3 34 dc
p3 = vcmph.gt(r21:20, #31)
# CHECK: eb c3 54 dc
p3 = vcmph.gtu(r21:20, #31)
# Vector compare bytes for any match
# CHECK: 03 fe 14 d2
p3 = any8(vcmpb.eq(r21:20, r31:30))
# Vector compare bytes
# CHECK: 63 de 14 d2
p3 = vcmph.eq(r21:20, r31:30)
# CHECK: 83 de 14 d2
p3 = vcmph.gt(r21:20, r31:30)
# CHECK: a3 de 14 d2
p3 = vcmph.gtu(r21:20, r31:30)
# CHECK: eb c3 14 dc
p3 = vcmph.eq(r21:20, #31)
# CHECK: eb c3 34 dc
p3 = vcmph.gt(r21:20, #31)
# CHECK: eb c3 54 dc
p3 = vcmph.gtu(r21:20, #31)
# Vector compare words
# CHECK: 03 de 14 d2
p3 = vcmpw.eq(r21:20, r31:30)
# CHECK: 23 de 14 d2
p3 = vcmpw.gt(r21:20, r31:30)
# CHECK: 43 de 14 d2
p3 = vcmpw.gtu(r21:20, r31:30)
# CHECK: f3 c3 14 dc
p3 = vcmpw.eq(r21:20, #31)
# CHECK: f3 c3 34 dc
p3 = vcmpw.gt(r21:20, #31)
# CHECK: f3 c3 54 dc
p3 = vcmpw.gtu(r21:20, #31)
# Viterbi pack even and odd predicate bits
# CHECK: 11 c2 03 89
r17 = vitpack(p3, p2)
# Vector mux
# CHECK: 70 de 14 d1
r17:16 = vmux(p3, r21:20, r31:30)

260
external/llvm/test/MC/Hexagon/instructions/xtype_shift.s vendored
View File

@@ -1,260 +0,0 @@
# RUN: llvm-mc -triple=hexagon -filetype=obj -o - %s | llvm-objdump -d - | FileCheck %s
# Hexagon Programmer's Reference Manual 11.10.8 XTYPE/SHIFT
# Shift by immediate
# CHECK: 10 df 14 80
r17:16 = asr(r21:20, #31)
# CHECK: 30 df 14 80
r17:16 = lsr(r21:20, #31)
# CHECK: 50 df 14 80
r17:16 = asl(r21:20, #31)
# CHECK: 11 df 15 8c
r17 = asr(r21, #31)
# CHECK: 31 df 15 8c
r17 = lsr(r21, #31)
# CHECK: 51 df 15 8c
r17 = asl(r21, #31)
# Shift by immediate and accumulate
# CHECK: 10 df 14 82
r17:16 -= asr(r21:20, #31)
# CHECK: 30 df 14 82
r17:16 -= lsr(r21:20, #31)
# CHECK: 50 df 14 82
r17:16 -= asl(r21:20, #31)
# CHECK: 90 df 14 82
r17:16 += asr(r21:20, #31)
# CHECK: b0 df 14 82
r17:16 += lsr(r21:20, #31)
# CHECK: d0 df 14 82
r17:16 += asl(r21:20, #31)
# CHECK: 11 df 15 8e
r17 -= asr(r21, #31)
# CHECK: 31 df 15 8e
r17 -= lsr(r21, #31)
# CHECK: 51 df 15 8e
r17 -= asl(r21, #31)
# CHECK: 91 df 15 8e
r17 += asr(r21, #31)
# CHECK: b1 df 15 8e
r17 += lsr(r21, #31)
# CHECK: d1 df 15 8e
r17 += asl(r21, #31)
# CHECK: 4c f7 11 de
r17 = add(#21, asl(r17, #23))
# CHECK: 4e f7 11 de
r17 = sub(#21, asl(r17, #23))
# CHECK: 5c f7 11 de
r17 = add(#21, lsr(r17, #23))
# CHECK: 5e f7 11 de
r17 = sub(#21, lsr(r17, #23))
# Shift by immediate and add
# CHECK: f1 d5 1f c4
r17 = addasl(r21, r31, #7)
# Shift by immediate and logical
# CHECK: 10 df 54 82
r17:16 &= asr(r21:20, #31)
# CHECK: 30 df 54 82
r17:16 &= lsr(r21:20, #31)
# CHECK: 50 df 54 82
r17:16 &= asl(r21:20, #31)
# CHECK: 90 df 54 82
r17:16 |= asr(r21:20, #31)
# CHECK: b0 df 54 82
r17:16 |= lsr(r21:20, #31)
# CHECK: d0 df 54 82
r17:16 |= asl(r21:20, #31)
# CHECK: 30 df 94 82
r17:16 ^= lsr(r21:20, #31)
# CHECK: 50 df 94 82
r17:16 ^= asl(r21:20, #31)
# CHECK: 11 df 55 8e
r17 &= asr(r21, #31)
# CHECK: 31 df 55 8e
r17 &= lsr(r21, #31)
# CHECK: 51 df 55 8e
r17 &= asl(r21, #31)
# CHECK: 91 df 55 8e
r17 |= asr(r21, #31)
# CHECK: b1 df 55 8e
r17 |= lsr(r21, #31)
# CHECK: d1 df 55 8e
r17 |= asl(r21, #31)
# CHECK: 31 df 95 8e
r17 ^= lsr(r21, #31)
# CHECK: 51 df 95 8e
r17 ^= asl(r21, #31)
# CHECK: 48 ff 11 de
r17 = and(#21, asl(r17, #31))
# CHECK: 4a ff 11 de
r17 = or(#21, asl(r17, #31))
# CHECK: 58 ff 11 de
r17 = and(#21, lsr(r17, #31))
# CHECK: 5a ff 11 de
r17 = or(#21, lsr(r17, #31))
# Shift right by immediate with rounding
# CHECK: f0 df d4 80
r17:16 = asr(r21:20, #31):rnd
# CHECK: 11 df 55 8c
r17 = asr(r21, #31):rnd
# Shift left by immediate with saturation
# CHECK: 51 df 55 8c
r17 = asl(r21, #31):sat
# Shift by register
# CHECK: 10 df 94 c3
r17:16 = asr(r21:20, r31)
# CHECK: 50 df 94 c3
r17:16 = lsr(r21:20, r31)
# CHECK: 90 df 94 c3
r17:16 = asl(r21:20, r31)
# CHECK: d0 df 94 c3
r17:16 = lsl(r21:20, r31)
# CHECK: 11 df 55 c6
r17 = asr(r21, r31)
# CHECK: 51 df 55 c6
r17 = lsr(r21, r31)
# CHECK: 91 df 55 c6
r17 = asl(r21, r31)
# CHECK: d1 df 55 c6
r17 = lsl(r21, r31)
# CHECK: f1 df 8a c6
r17 = lsl(#21, r31)
# Shift by register and accumulate
# CHECK: 10 df 94 cb
r17:16 -= asr(r21:20, r31)
# CHECK: 50 df 94 cb
r17:16 -= lsr(r21:20, r31)
# CHECK: 90 df 94 cb
r17:16 -= asl(r21:20, r31)
# CHECK: d0 df 94 cb
r17:16 -= lsl(r21:20, r31)
# CHECK: 10 df d4 cb
r17:16 += asr(r21:20, r31)
# CHECK: 50 df d4 cb
r17:16 += lsr(r21:20, r31)
# CHECK: 90 df d4 cb
r17:16 += asl(r21:20, r31)
# CHECK: d0 df d4 cb
r17:16 += lsl(r21:20, r31)
# CHECK: 11 df 95 cc
r17 -= asr(r21, r31)
# CHECK: 51 df 95 cc
r17 -= lsr(r21, r31)
# CHECK: 91 df 95 cc
r17 -= asl(r21, r31)
# CHECK: d1 df 95 cc
r17 -= lsl(r21, r31)
# CHECK: 11 df d5 cc
r17 += asr(r21, r31)
# CHECK: 51 df d5 cc
r17 += lsr(r21, r31)
# CHECK: 91 df d5 cc
r17 += asl(r21, r31)
# CHECK: d1 df d5 cc
r17 += lsl(r21, r31)
# Shift by register and logical
# CHECK: 10 df 14 cb
r17:16 |= asr(r21:20, r31)
# CHECK: 50 df 14 cb
r17:16 |= lsr(r21:20, r31)
# CHECK: 90 df 14 cb
r17:16 |= asl(r21:20, r31)
# CHECK: d0 df 14 cb
r17:16 |= lsl(r21:20, r31)
# CHECK: 10 df 54 cb
r17:16 &= asr(r21:20, r31)
# CHECK: 50 df 54 cb
r17:16 &= lsr(r21:20, r31)
# CHECK: 90 df 54 cb
r17:16 &= asl(r21:20, r31)
# CHECK: d0 df 54 cb
r17:16 &= lsl(r21:20, r31)
# CHECK: 10 df 74 cb
r17:16 ^= asr(r21:20, r31)
# CHECK: 50 df 74 cb
r17:16 ^= lsr(r21:20, r31)
# CHECK: 90 df 74 cb
r17:16 ^= asl(r21:20, r31)
# CHECK: d0 df 74 cb
r17:16 ^= lsl(r21:20, r31)
# CHECK: 11 df 15 cc
r17 |= asr(r21, r31)
# CHECK: 51 df 15 cc
r17 |= lsr(r21, r31)
# CHECK: 91 df 15 cc
r17 |= asl(r21, r31)
# CHECK: d1 df 15 cc
r17 |= lsl(r21, r31)
# CHECK: 11 df 55 cc
r17 &= asr(r21, r31)
# CHECK: 51 df 55 cc
r17 &= lsr(r21, r31)
# CHECK: 91 df 55 cc
r17 &= asl(r21, r31)
# CHECK: d1 df 55 cc
r17 &= lsl(r21, r31)
# Shift by register with saturation
# CHECK: 11 df 15 c6
r17 = asr(r21, r31):sat
# CHECK: 91 df 15 c6
r17 = asl(r21, r31):sat
# Vector shift halfwords by immediate
# CHECK: 10 c5 94 80
r17:16 = vasrh(r21:20, #5)
# CHECK: 30 c5 94 80
r17:16 = vlsrh(r21:20, #5)
# CHECK: 50 c5 94 80
r17:16 = vaslh(r21:20, #5)
# Vector arithmetic shift halfwords with round
# CHECK: 10 c5 34 80
r17:16 = vasrh(r21:20, #5):raw
# Vector arithmetic shift halfwords with saturate and pack
# CHECK: 91 c5 74 88
r17 = vasrhub(r21:20, #5):raw
# CHECK: b1 c5 74 88
r17 = vasrhub(r21:20, #5):sat
# Vector shift halfwords by register
# CHECK: 10 df 54 c3
r17:16 = vasrh(r21:20, r31)
# CHECK: 50 df 54 c3
r17:16 = vlsrh(r21:20, r31)
# CHECK: 90 df 54 c3
r17:16 = vaslh(r21:20, r31)
# CHECK: d0 df 54 c3
r17:16 = vlslh(r21:20, r31)
# Vector shift words by immediate
# CHECK: 10 df 54 80
r17:16 = vasrw(r21:20, #31)
# CHECK: 30 df 54 80
r17:16 = vlsrw(r21:20, #31)
# CHECK: 50 df 54 80
r17:16 = vaslw(r21:20, #31)
# Vector shift words by register
# CHECK: 10 df 14 c3
r17:16 = vasrw(r21:20, r31)
# CHECK: 50 df 14 c3
r17:16 = vlsrw(r21:20, r31)
# CHECK: 90 df 14 c3
r17:16 = vaslw(r21:20, r31)
# CHECK: d0 df 14 c3
r17:16 = vlslw(r21:20, r31)
# Vector shift words with truncate and pack
# CHECK: 51 df d4 88
r17 = vasrw(r21:20, #31)
# CHECK: 51 df 14 c5
r17 = vasrw(r21:20, r31)