This is an archive of the discontinued LLVM Phabricator instance.

Differential D41388

[X86][MC]: Adding test coverage of MC encoding for several small extensions.<NFC>
ClosedPublic

Authored by gadi.haber on Dec 19 2017, 4:55 AM.

Details

Reviewers
RKSimon
craig.topper
zvi
AndreiGrischenko
Commits
rG25dc3d27ea81: [X86][MC]: Adding test coverage of MC encoding for several small extensions.
rL324595: [X86][MC]: Adding test coverage of MC encoding for several small extensions.
Summary

NFC.
Adding MC regressions tests to cover several small x86 extensions as follows:
CLWB, CLZERO, F16C, INVPCID, PKU, POPCNT, RTM, SGX, SHA, SVM, VMFUNC, VTX

This patch is part of a larger task to cover MC encoding of all X86 isa sets started in revision: https://reviews.llvm.org/D39952

Diff Detail

Repository
rL LLVM

Event Timeline

gadi.haber created this revision.Dec 19 2017, 4:55 AM
gadi.haber updated this revision to Diff 127511.Dec 19 2017, 5:55 AM
gadi.haber retitled this revision from [X86][NC]: Adding test coverage of MC encoding for several small extensions.<NFC> to [X86][MC]: Adding test coverage of MC encoding for several small extensions.<NFC>.

fixed a typo in SHA-64.s tests

craig.topper added inline comments.Dec 19 2017, 9:23 AM
test/MC/X86/POPCNT-64.s
5 ↗(On Diff #127511)

What about popcntw and popcntq?

RKSimon added a comment.Dec 19 2017, 10:27 AM

What happened to clzero-32.s etc?

gadi.haber updated this revision to Diff 127751.Dec 20 2017, 9:58 AM

fixed comments found by Simon

gadi.haber marked an inline comment as done.Dec 20 2017, 9:58 AM
RKSimon added a comment.Dec 20 2017, 10:03 AM

Isn't POPCNT missing the memory fold tests?

gadi.haber added a comment.Dec 20 2017, 10:08 AM

good catch. I will add the mem ops for popcnt.

gadi.haber edited reviewers, added: AndreiGrischenko; removed: m_zuckerman.Dec 20 2017, 10:10 AM
gadi.haber updated this revision to Diff 127756.Dec 20 2017, 10:40 AM

Added mem ops tests for POPCNT 32 and 64 bit

RKSimon added a comment.Dec 21 2017, 10:09 AM
In D41388#961214, @gadi.haber wrote:

Added mem ops tests for POPCNT 32 and 64 bit

Thanks - would it be possible to test all the various MRM permutations like you have for other memory folds?

gadi.haber updated this revision to Diff 132840.Feb 5 2018, 8:56 AM

Added more MRM tests in POPCNT-32.s and POPCNT-64.s following Simon's comment.

gadi.haber updated this revision to Diff 132847.Feb 5 2018, 9:07 AM

Sorry. Updated diff as the added MRM tests in POPCNT-*.s were not reflected in the previous diff file.

craig.topper accepted this revision.Feb 7 2018, 10:17 AM

LGTM

This revision is now accepted and ready to land.Feb 7 2018, 10:17 AM
Closed by commit rL324595: [X86][MC]: Adding test coverage of MC encoding for several small extensions. (authored by gadi.haber). · Explain WhyFeb 8 2018, 3:18 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
test/
MC/
X86/
26 lines
26 lines
6 lines
6 lines
114 lines
114 lines
26 lines
26 lines
10 lines
10 lines
34 lines
50 lines
18 lines
10 lines
10 lines
202 lines
394 lines
34 lines
34 lines
6 lines
6 lines
222 lines
218 lines

Diff 133396

llvm/trunk/test/MC/X86/CLWB-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: clwb -485498096(%edx,%eax,4)
// CHECK: encoding: [0x66,0x0f,0xae,0xb4,0x82,0x10,0xe3,0x0f,0xe3]
clwb -485498096(%edx,%eax,4)
// CHECK: clwb 485498096(%edx,%eax,4)
// CHECK: encoding: [0x66,0x0f,0xae,0xb4,0x82,0xf0,0x1c,0xf0,0x1c]
clwb 485498096(%edx,%eax,4)
// CHECK: clwb 485498096(%edx)
// CHECK: encoding: [0x66,0x0f,0xae,0xb2,0xf0,0x1c,0xf0,0x1c]
clwb 485498096(%edx)
// CHECK: clwb 485498096
// CHECK: encoding: [0x66,0x0f,0xae,0x35,0xf0,0x1c,0xf0,0x1c]
clwb 485498096
// CHECK: clwb 64(%edx,%eax)
// CHECK: encoding: [0x66,0x0f,0xae,0x74,0x02,0x40]
clwb 64(%edx,%eax)
// CHECK: clwb (%edx)
// CHECK: encoding: [0x66,0x0f,0xae,0x32]
clwb (%edx)

llvm/trunk/test/MC/X86/CLWB-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: clwb 485498096
// CHECK: encoding: [0x66,0x0f,0xae,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
clwb 485498096
// CHECK: clwb 64(%rdx)
// CHECK: encoding: [0x66,0x0f,0xae,0x72,0x40]
clwb 64(%rdx)
// CHECK: clwb 64(%rdx,%rax,4)
// CHECK: encoding: [0x66,0x0f,0xae,0x74,0x82,0x40]
clwb 64(%rdx,%rax,4)
// CHECK: clwb -64(%rdx,%rax,4)
// CHECK: encoding: [0x66,0x0f,0xae,0x74,0x82,0xc0]
clwb -64(%rdx,%rax,4)
// CHECK: clwb 64(%rdx,%rax)
// CHECK: encoding: [0x66,0x0f,0xae,0x74,0x02,0x40]
clwb 64(%rdx,%rax)
// CHECK: clwb (%rdx)
// CHECK: encoding: [0x66,0x0f,0xae,0x32]
clwb (%rdx)

llvm/trunk/test/MC/X86/CLZERO-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: clzero
// CHECK: encoding: [0x0f,0x01,0xfc]
clzero

llvm/trunk/test/MC/X86/CLZERO-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: clzero
// CHECK: encoding: [0x0f,0x01,0xfc]
clzero

llvm/trunk/test/MC/X86/F16C-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vcvtph2ps -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
vcvtph2ps -485498096(%edx,%eax,4), %xmm1
// CHECK: vcvtph2ps 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096(%edx,%eax,4), %xmm1
// CHECK: vcvtph2ps -485498096(%edx,%eax,4), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
vcvtph2ps -485498096(%edx,%eax,4), %ymm4
// CHECK: vcvtph2ps 485498096(%edx,%eax,4), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096(%edx,%eax,4), %ymm4
// CHECK: vcvtph2ps 485498096(%edx), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x8a,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096(%edx), %xmm1
// CHECK: vcvtph2ps 485498096(%edx), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0xa2,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096(%edx), %ymm4
// CHECK: vcvtph2ps 485498096, %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x0d,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096, %xmm1
// CHECK: vcvtph2ps 485498096, %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0x25,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096, %ymm4
// CHECK: vcvtph2ps 64(%edx,%eax), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x4c,0x02,0x40]
vcvtph2ps 64(%edx,%eax), %xmm1
// CHECK: vcvtph2ps 64(%edx,%eax), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0x64,0x02,0x40]
vcvtph2ps 64(%edx,%eax), %ymm4
// CHECK: vcvtph2ps (%edx), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x0a]
vcvtph2ps (%edx), %xmm1
// CHECK: vcvtph2ps (%edx), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0x22]
vcvtph2ps (%edx), %ymm4
// CHECK: vcvtph2ps %xmm1, %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0xc9]
vcvtph2ps %xmm1, %xmm1
// CHECK: vcvtph2ps %xmm1, %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0xe1]
vcvtph2ps %xmm1, %ymm4
// CHECK: vcvtps2ph $0, %xmm1, -485498096(%edx,%eax,4)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
vcvtps2ph $0, %xmm1, -485498096(%edx,%eax,4)
// CHECK: vcvtps2ph $0, %xmm1, 485498096(%edx,%eax,4)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %xmm1, 485498096(%edx,%eax,4)
// CHECK: vcvtps2ph $0, %xmm1, 485498096(%edx)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %xmm1, 485498096(%edx)
// CHECK: vcvtps2ph $0, %xmm1, 485498096
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %xmm1, 485498096
// CHECK: vcvtps2ph $0, %xmm1, 64(%edx,%eax)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x4c,0x02,0x40,0x00]
vcvtps2ph $0, %xmm1, 64(%edx,%eax)
// CHECK: vcvtps2ph $0, %xmm1, (%edx)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x0a,0x00]
vcvtps2ph $0, %xmm1, (%edx)
// CHECK: vcvtps2ph $0, %xmm1, %xmm1
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0xc9,0x00]
vcvtps2ph $0, %xmm1, %xmm1
// CHECK: vcvtps2ph $0, %ymm4, -485498096(%edx,%eax,4)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0xa4,0x82,0x10,0xe3,0x0f,0xe3,0x00]
vcvtps2ph $0, %ymm4, -485498096(%edx,%eax,4)
// CHECK: vcvtps2ph $0, %ymm4, 485498096(%edx,%eax,4)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0xa4,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %ymm4, 485498096(%edx,%eax,4)
// CHECK: vcvtps2ph $0, %ymm4, 485498096(%edx)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0xa2,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %ymm4, 485498096(%edx)
// CHECK: vcvtps2ph $0, %ymm4, 485498096
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %ymm4, 485498096
// CHECK: vcvtps2ph $0, %ymm4, 64(%edx,%eax)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0x64,0x02,0x40,0x00]
vcvtps2ph $0, %ymm4, 64(%edx,%eax)
// CHECK: vcvtps2ph $0, %ymm4, (%edx)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0x22,0x00]
vcvtps2ph $0, %ymm4, (%edx)
// CHECK: vcvtps2ph $0, %ymm4, %xmm1
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0xe1,0x00]
vcvtps2ph $0, %ymm4, %xmm1

llvm/trunk/test/MC/X86/F16C-64.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vcvtph2ps -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
vcvtph2ps -485498096(%edx,%eax,4), %xmm1
// CHECK: vcvtph2ps 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096(%edx,%eax,4), %xmm1
// CHECK: vcvtph2ps -485498096(%edx,%eax,4), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
vcvtph2ps -485498096(%edx,%eax,4), %ymm4
// CHECK: vcvtph2ps 485498096(%edx,%eax,4), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096(%edx,%eax,4), %ymm4
// CHECK: vcvtph2ps 485498096(%edx), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x8a,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096(%edx), %xmm1
// CHECK: vcvtph2ps 485498096(%edx), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0xa2,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096(%edx), %ymm4
// CHECK: vcvtph2ps 485498096, %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x0d,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096, %xmm1
// CHECK: vcvtph2ps 485498096, %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0x25,0xf0,0x1c,0xf0,0x1c]
vcvtph2ps 485498096, %ymm4
// CHECK: vcvtph2ps 64(%edx,%eax), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x4c,0x02,0x40]
vcvtph2ps 64(%edx,%eax), %xmm1
// CHECK: vcvtph2ps 64(%edx,%eax), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0x64,0x02,0x40]
vcvtph2ps 64(%edx,%eax), %ymm4
// CHECK: vcvtph2ps (%edx), %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0x0a]
vcvtph2ps (%edx), %xmm1
// CHECK: vcvtph2ps (%edx), %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0x22]
vcvtph2ps (%edx), %ymm4
// CHECK: vcvtph2ps %xmm1, %xmm1
// CHECK: encoding: [0xc4,0xe2,0x79,0x13,0xc9]
vcvtph2ps %xmm1, %xmm1
// CHECK: vcvtph2ps %xmm1, %ymm4
// CHECK: encoding: [0xc4,0xe2,0x7d,0x13,0xe1]
vcvtph2ps %xmm1, %ymm4
// CHECK: vcvtps2ph $0, %xmm1, -485498096(%edx,%eax,4)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
vcvtps2ph $0, %xmm1, -485498096(%edx,%eax,4)
// CHECK: vcvtps2ph $0, %xmm1, 485498096(%edx,%eax,4)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %xmm1, 485498096(%edx,%eax,4)
// CHECK: vcvtps2ph $0, %xmm1, 485498096(%edx)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %xmm1, 485498096(%edx)
// CHECK: vcvtps2ph $0, %xmm1, 485498096
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %xmm1, 485498096
// CHECK: vcvtps2ph $0, %xmm1, 64(%edx,%eax)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x4c,0x02,0x40,0x00]
vcvtps2ph $0, %xmm1, 64(%edx,%eax)
// CHECK: vcvtps2ph $0, %xmm1, (%edx)
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0x0a,0x00]
vcvtps2ph $0, %xmm1, (%edx)
// CHECK: vcvtps2ph $0, %xmm1, %xmm1
// CHECK: encoding: [0xc4,0xe3,0x79,0x1d,0xc9,0x00]
vcvtps2ph $0, %xmm1, %xmm1
// CHECK: vcvtps2ph $0, %ymm4, -485498096(%edx,%eax,4)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0xa4,0x82,0x10,0xe3,0x0f,0xe3,0x00]
vcvtps2ph $0, %ymm4, -485498096(%edx,%eax,4)
// CHECK: vcvtps2ph $0, %ymm4, 485498096(%edx,%eax,4)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0xa4,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %ymm4, 485498096(%edx,%eax,4)
// CHECK: vcvtps2ph $0, %ymm4, 485498096(%edx)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0xa2,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %ymm4, 485498096(%edx)
// CHECK: vcvtps2ph $0, %ymm4, 485498096
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
vcvtps2ph $0, %ymm4, 485498096
// CHECK: vcvtps2ph $0, %ymm4, 64(%edx,%eax)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0x64,0x02,0x40,0x00]
vcvtps2ph $0, %ymm4, 64(%edx,%eax)
// CHECK: vcvtps2ph $0, %ymm4, (%edx)
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0x22,0x00]
vcvtps2ph $0, %ymm4, (%edx)
// CHECK: vcvtps2ph $0, %ymm4, %xmm1
// CHECK: encoding: [0xc4,0xe3,0x7d,0x1d,0xe1,0x00]
vcvtps2ph $0, %ymm4, %xmm1

llvm/trunk/test/MC/X86/INVPCID-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: invpcid 3809469200(%edx,%eax,4), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x82,0x84,0x82,0x10,0xe3,0x0f,0xe3]
invpcid 3809469200(%edx,%eax,4), %eax
// CHECK: invpcid 485498096, %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x82,0x05,0xf0,0x1c,0xf0,0x1c]
invpcid 485498096, %eax
// CHECK: invpcid 485498096(%edx,%eax,4), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x82,0x84,0x82,0xf0,0x1c,0xf0,0x1c]
invpcid 485498096(%edx,%eax,4), %eax
// CHECK: invpcid 485498096(%edx), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x82,0x82,0xf0,0x1c,0xf0,0x1c]
invpcid 485498096(%edx), %eax
// CHECK: invpcid 64(%edx,%eax), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x82,0x44,0x02,0x40]
invpcid 64(%edx,%eax), %eax
// CHECK: invpcid (%edx), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x82,0x02]
invpcid (%edx), %eax

llvm/trunk/test/MC/X86/INVPCID-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: invpcid 485498096, %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x82,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
invpcid 485498096, %r15
// CHECK: invpcid 64(%rdx), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x82,0x7a,0x40]
invpcid 64(%rdx), %r15
// CHECK: invpcid 64(%rdx,%rax,4), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x82,0x7c,0x82,0x40]
invpcid 64(%rdx,%rax,4), %r15
// CHECK: invpcid -64(%rdx,%rax,4), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x82,0x7c,0x82,0xc0]
invpcid -64(%rdx,%rax,4), %r15
// CHECK: invpcid 64(%rdx,%rax), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x82,0x7c,0x02,0x40]
invpcid 64(%rdx,%rax), %r15
// CHECK: invpcid (%rdx), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x82,0x3a]
invpcid (%rdx), %r15

llvm/trunk/test/MC/X86/PKU-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: rdpkru
// CHECK: encoding: [0x0f,0x01,0xee]
rdpkru
// CHECK: wrpkru
// CHECK: encoding: [0x0f,0x01,0xef]
wrpkru

llvm/trunk/test/MC/X86/PKU-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: rdpkru
// CHECK: encoding: [0x0f,0x01,0xee]
rdpkru
// CHECK: wrpkru
// CHECK: encoding: [0x0f,0x01,0xef]
wrpkru

llvm/trunk/test/MC/X86/POPCNT-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: popcntl %eax, %eax
// CHECK: encoding: [0xf3,0x0f,0xb8,0xc0]
popcntl %eax, %eax
// CHECK: popcntl 4096(%eax), %eax
// CHECK: encoding: [0xf3,0x0f,0xb8,0x80,0x00,0x10,0x00,0x00]
popcntl 4096(%eax), %eax
// CHECK: popcntl 64(%edx,%eax), %ecx
// CHECK: encoding: [0xf3,0x0f,0xb8,0x4c,0x02,0x40]
popcntl 64(%edx,%eax), %ecx
// CHECK: popcntl 64(%edx,%eax,4), %ecx
// CHECK: encoding: [0xf3,0x0f,0xb8,0x4c,0x82,0x40]
popcntl 64(%edx,%eax,4), %ecx
// CHECK: popcntw %ax, %ax
// CHECK: encoding: [0x66,0xf3,0x0f,0xb8,0xc0]
popcntw %ax, %ax
// CHECK: popcntw 4096(%eax), %ax
// CHECK: encoding: [0x66,0xf3,0x0f,0xb8,0x80,0x00,0x10,0x00,0x00]
popcntw 4096(%eax), %ax
// CHECK: popcntw 64(%edx,%eax), %cx
// CHECK: encoding: [0x66,0xf3,0x0f,0xb8,0x4c,0x02,0x40]
popcntw 64(%edx,%eax), %cx
// CHECK: popcntw 64(%edx,%eax,4), %cx
// CHECK: encoding: [0x66,0xf3,0x0f,0xb8,0x4c,0x82,0x40]
popcntw 64(%edx,%eax,4), %cx

llvm/trunk/test/MC/X86/POPCNT-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: popcntl %r13d, %r13d
// CHECK: encoding: [0xf3,0x45,0x0f,0xb8,0xed]
popcntl %r13d, %r13d
// CHECK: popcntl 4096(%rax), %r13d
// CHECK: encoding: [0xf3,0x44,0x0f,0xb8,0xa8,0x00,0x10,0x00,0x00]
popcntl 4096(%rax), %r13d
// CHECK: popcntl 64(%rdx,%rax), %r13d
// CHECK: encoding: [0xf3,0x44,0x0f,0xb8,0x6c,0x02,0x40]
popcntl 64(%rdx,%rax), %r13d
// CHECK: popcntl 64(%rdx,%rax,4), %r13d
// CHECK: encoding: [0xf3,0x44,0x0f,0xb8,0x6c,0x82,0x40]
popcntl 64(%rdx,%rax,4), %r13d
// CHECK: popcntq %r13, %r13
// CHECK: encoding: [0xf3,0x4d,0x0f,0xb8,0xed]
popcntq %r13, %r13
// CHECK: popcntq 4096(%rax), %r13
// CHECK: encoding: [0xf3,0x4c,0x0f,0xb8,0xa8,0x00,0x10,0x00,0x00]
popcntq 4096(%rax), %r13
// CHECK: popcntq 64(%rdx,%rax), %r13
// CHECK: encoding: [0xf3,0x4c,0x0f,0xb8,0x6c,0x02,0x40]
popcntq 64(%rdx,%rax), %r13
// CHECK: popcntq 64(%rdx,%rax,4), %r13
// CHECK: encoding: [0xf3,0x4c,0x0f,0xb8,0x6c,0x82,0x40]
popcntq 64(%rdx,%rax,4), %r13
// CHECK: popcntw %r13w, %r13w
// CHECK: encoding: [0x66,0xf3,0x45,0x0f,0xb8,0xed]
popcntw %r13w, %r13w
// CHECK: popcntw 4096(%rax), %r13w
// CHECK: encoding: [0x66,0xf3,0x44,0x0f,0xb8,0xa8,0x00,0x10,0x00,0x00]
popcntw 4096(%rax), %r13w
// CHECK: popcntw 64(%rdx,%rax), %r13w
// CHECK: encoding: [0x66,0xf3,0x44,0x0f,0xb8,0x6c,0x02,0x40]
popcntw 64(%rdx,%rax), %r13w
// CHECK: popcntw 64(%rdx,%rax,4), %r13w
// CHECK: encoding: [0x66,0xf3,0x44,0x0f,0xb8,0x6c,0x82,0x40]
popcntw 64(%rdx,%rax,4), %r13w

llvm/trunk/test/MC/X86/RTM.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: xabort $0
// CHECK: encoding: [0xc6,0xf8,0x00]
xabort $0
// CHECK: xbegin 64
// CHECK: encoding: [0xc7,0xf8,A,A,A,A]
xbegin 64
// CHECK: xend
// CHECK: encoding: [0x0f,0x01,0xd5]
xend
// CHECK: xtest
// CHECK: encoding: [0x0f,0x01,0xd6]
xtest

llvm/trunk/test/MC/X86/SGX-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: encls
// CHECK: encoding: [0x0f,0x01,0xcf]
encls
// CHECK: enclu
// CHECK: encoding: [0x0f,0x01,0xd7]
enclu

llvm/trunk/test/MC/X86/SGX-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: encls
// CHECK: encoding: [0x0f,0x01,0xcf]
encls
// CHECK: enclu
// CHECK: encoding: [0x0f,0x01,0xd7]
enclu

llvm/trunk/test/MC/X86/SHA-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: sha1msg1 -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
sha1msg1 -485498096(%edx,%eax,4), %xmm1
// CHECK: sha1msg1 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
sha1msg1 485498096(%edx,%eax,4), %xmm1
// CHECK: sha1msg1 485498096(%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc9,0x8a,0xf0,0x1c,0xf0,0x1c]
sha1msg1 485498096(%edx), %xmm1
// CHECK: sha1msg1 485498096, %xmm1
// CHECK: encoding: [0x0f,0x38,0xc9,0x0d,0xf0,0x1c,0xf0,0x1c]
sha1msg1 485498096, %xmm1
// CHECK: sha1msg1 64(%edx,%eax), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc9,0x4c,0x02,0x40]
sha1msg1 64(%edx,%eax), %xmm1
// CHECK: sha1msg1 (%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc9,0x0a]
sha1msg1 (%edx), %xmm1
// CHECK: sha1msg1 %xmm1, %xmm1
// CHECK: encoding: [0x0f,
sha1msg1 %xmm1, %xmm1
// CHECK: sha1msg1 %xmm1, %xmm1
// CHECK: encoding: [0x0f,0x38,0xc9,0xc9]
sha1msg1 %xmm1, %xmm1
// CHECK: sha1msg2 -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xca,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
sha1msg2 -485498096(%edx,%eax,4), %xmm1
// CHECK: sha1msg2 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xca,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
sha1msg2 485498096(%edx,%eax,4), %xmm1
// CHECK: sha1msg2 485498096(%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xca,0x8a,0xf0,0x1c,0xf0,0x1c]
sha1msg2 485498096(%edx), %xmm1
// CHECK: sha1msg2 485498096, %xmm1
// CHECK: encoding: [0x0f,0x38,0xca,0x0d,0xf0,0x1c,0xf0,0x1c]
sha1msg2 485498096, %xmm1
// CHECK: sha1msg2 64(%edx,%eax), %xmm1
// CHECK: encoding: [0x0f,0x38,0xca,0x4c,0x02,0x40]
sha1msg2 64(%edx,%eax), %xmm1
// CHECK: sha1msg2 (%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xca,0x0a]
sha1msg2 (%edx), %xmm1
// CHECK: sha1msg2 %xmm1, %xmm1
// CHECK: encoding: [0x0f,0x38,0xca,0xc9]
sha1msg2 %xmm1, %xmm1
// CHECK: sha1nexte -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc8,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
sha1nexte -485498096(%edx,%eax,4), %xmm1
// CHECK: sha1nexte 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc8,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
sha1nexte 485498096(%edx,%eax,4), %xmm1
// CHECK: sha1nexte 485498096(%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc8,0x8a,0xf0,0x1c,0xf0,0x1c]
sha1nexte 485498096(%edx), %xmm1
// CHECK: sha1nexte 485498096, %xmm1
// CHECK: encoding: [0x0f,0x38,0xc8,0x0d,0xf0,0x1c,0xf0,0x1c]
sha1nexte 485498096, %xmm1
// CHECK: sha1nexte 64(%edx,%eax), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc8,0x4c,0x02,0x40]
sha1nexte 64(%edx,%eax), %xmm1
// CHECK: sha1nexte (%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xc8,0x0a]
sha1nexte (%edx), %xmm1
// CHECK: sha1nexte %xmm1, %xmm1
// CHECK: encoding: [0x0f,0x38,0xc8,0xc9]
sha1nexte %xmm1, %xmm1
// CHECK: sha1rnds4 $0, -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x3a,0xcc,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
sha1rnds4 $0, -485498096(%edx,%eax,4), %xmm1
// CHECK: sha1rnds4 $0, 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x3a,0xcc,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
sha1rnds4 $0, 485498096(%edx,%eax,4), %xmm1
// CHECK: sha1rnds4 $0, 485498096(%edx), %xmm1
// CHECK: encoding: [0x0f,0x3a,0xcc,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
sha1rnds4 $0, 485498096(%edx), %xmm1
// CHECK: sha1rnds4 $0, 485498096, %xmm1
// CHECK: encoding: [0x0f,0x3a,0xcc,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
sha1rnds4 $0, 485498096, %xmm1
// CHECK: sha1rnds4 $0, 64(%edx,%eax), %xmm1
// CHECK: encoding: [0x0f,0x3a,0xcc,0x4c,0x02,0x40,0x00]
sha1rnds4 $0, 64(%edx,%eax), %xmm1
// CHECK: sha1rnds4 $0, (%edx), %xmm1
// CHECK: encoding: [0x0f,0x3a,0xcc,0x0a,0x00]
sha1rnds4 $0, (%edx), %xmm1
// CHECK: sha1rnds4 $0, %xmm1, %xmm1
// CHECK: encoding: [0x0f,0x3a,0xcc,0xc9,0x00]
sha1rnds4 $0, %xmm1, %xmm1
// CHECK: sha256msg1 -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcc,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
sha256msg1 -485498096(%edx,%eax,4), %xmm1
// CHECK: sha256msg1 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcc,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
sha256msg1 485498096(%edx,%eax,4), %xmm1
// CHECK: sha256msg1 485498096(%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcc,0x8a,0xf0,0x1c,0xf0,0x1c]
sha256msg1 485498096(%edx), %xmm1
// CHECK: sha256msg1 485498096, %xmm1
// CHECK: encoding: [0x0f,0x38,0xcc,0x0d,0xf0,0x1c,0xf0,0x1c]
sha256msg1 485498096, %xmm1
// CHECK: sha256msg1 64(%edx,%eax), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcc,0x4c,0x02,0x40]
sha256msg1 64(%edx,%eax), %xmm1
// CHECK: sha256msg1 (%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcc,0x0a]
sha256msg1 (%edx), %xmm1
// CHECK: sha256msg1 %xmm1, %xmm1
// CHECK: encoding: [0x0f,0x38,0xcc,0xc9]
sha256msg1 %xmm1, %xmm1
// CHECK: sha256msg2 -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
sha256msg2 -485498096(%edx,%eax,4), %xmm1
// CHECK: sha256msg2 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
sha256msg2 485498096(%edx,%eax,4), %xmm1
// CHECK: sha256msg2 485498096(%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcd,0x8a,0xf0,0x1c,0xf0,0x1c]
sha256msg2 485498096(%edx), %xmm1
// CHECK: sha256msg2 485498096, %xmm1
// CHECK: encoding: [0x0f,0x38,0xcd,0x0d,0xf0,0x1c,0xf0,0x1c]
sha256msg2 485498096, %xmm1
// CHECK: sha256msg2 64(%edx,%eax), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcd,0x4c,0x02,0x40]
sha256msg2 64(%edx,%eax), %xmm1
// CHECK: sha256msg2 (%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcd,0x0a]
sha256msg2 (%edx), %xmm1
// CHECK: sha256msg2 %xmm1, %xmm1
// CHECK: encoding: [0x0f,0x38,0xcd,0xc9]
sha256msg2 %xmm1, %xmm1
// CHECK: sha256rnds2 %xmm0, -485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
sha256rnds2 %xmm0, -485498096(%edx,%eax,4), %xmm1
// CHECK: sha256rnds2 %xmm0, 485498096(%edx,%eax,4), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
sha256rnds2 %xmm0, 485498096(%edx,%eax,4), %xmm1
// CHECK: sha256rnds2 %xmm0, 485498096(%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcb,0x8a,0xf0,0x1c,0xf0,0x1c]
sha256rnds2 %xmm0, 485498096(%edx), %xmm1
// CHECK: sha256rnds2 %xmm0, 485498096, %xmm1
// CHECK: encoding: [0x0f,0x38,0xcb,0x0d,0xf0,0x1c,0xf0,0x1c]
sha256rnds2 %xmm0, 485498096, %xmm1
// CHECK: sha256rnds2 %xmm0, 64(%edx,%eax), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcb,0x4c,0x02,0x40]
sha256rnds2 %xmm0, 64(%edx,%eax), %xmm1
// CHECK: sha256rnds2 %xmm0, (%edx), %xmm1
// CHECK: encoding: [0x0f,0x38,0xcb,0x0a]
sha256rnds2 %xmm0, (%edx), %xmm1
// CHECK: sha256rnds2 %xmm0, %xmm1, %xmm1
// CHECK: encoding: [0x0f,0x38,0xcb,0xc9]
sha256rnds2 %xmm0, %xmm1, %xmm1

llvm/trunk/test/MC/X86/SHA-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: sha1msg1 485498096, %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc9,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
sha1msg1 485498096, %xmm15
// CHECK: sha1msg1 485498096, %xmm6
// CHECK: encoding: [0x0f,0x38,0xc9,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
sha1msg1 485498096, %xmm6
// CHECK: sha1msg1 64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc9,0x7c,0x82,0x40]
sha1msg1 64(%rdx,%rax,4), %xmm15
// CHECK: sha1msg1 -64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc9,0x7c,0x82,0xc0]
sha1msg1 -64(%rdx,%rax,4), %xmm15
// CHECK: sha1msg1 64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc9,0x74,0x82,0x40]
sha1msg1 64(%rdx,%rax,4), %xmm6
// CHECK: sha1msg1 -64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc9,0x74,0x82,0xc0]
sha1msg1 -64(%rdx,%rax,4), %xmm6
// CHECK: sha1msg1 64(%rdx,%rax), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc9,0x7c,0x02,0x40]
sha1msg1 64(%rdx,%rax), %xmm15
// CHECK: sha1msg1 64(%rdx,%rax), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc9,0x74,0x02,0x40]
sha1msg1 64(%rdx,%rax), %xmm6
// CHECK: sha1msg1 64(%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc9,0x7a,0x40]
sha1msg1 64(%rdx), %xmm15
// CHECK: sha1msg1 64(%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc9,0x72,0x40]
sha1msg1 64(%rdx), %xmm6
// CHECK: sha1msg1 (%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc9,0x3a]
sha1msg1 (%rdx), %xmm15
// CHECK: sha1msg1 (%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc9,0x32]
sha1msg1 (%rdx), %xmm6
// CHECK: sha1msg1 %xmm15, %xmm15
// CHECK: encoding: [0x45,0x0f,0x38,0xc9,0xff]
sha1msg1 %xmm15, %xmm15
// CHECK: sha1msg1 %xmm6, %xmm6
// CHECK: encoding: [0x0f,0x38,0xc9,0xf6]
sha1msg1 %xmm6, %xmm6
// CHECK: sha1msg2 485498096, %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xca,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
sha1msg2 485498096, %xmm15
// CHECK: sha1msg2 485498096, %xmm6
// CHECK: encoding: [0x0f,0x38,0xca,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
sha1msg2 485498096, %xmm6
// CHECK: sha1msg2 64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xca,0x7c,0x82,0x40]
sha1msg2 64(%rdx,%rax,4), %xmm15
// CHECK: sha1msg2 -64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xca,0x7c,0x82,0xc0]
sha1msg2 -64(%rdx,%rax,4), %xmm15
// CHECK: sha1msg2 64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xca,0x74,0x82,0x40]
sha1msg2 64(%rdx,%rax,4), %xmm6
// CHECK: sha1msg2 -64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xca,0x74,0x82,0xc0]
sha1msg2 -64(%rdx,%rax,4), %xmm6
// CHECK: sha1msg2 64(%rdx,%rax), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xca,0x7c,0x02,0x40]
sha1msg2 64(%rdx,%rax), %xmm15
// CHECK: sha1msg2 64(%rdx,%rax), %xmm6
// CHECK: encoding: [0x0f,0x38,0xca,0x74,0x02,0x40]
sha1msg2 64(%rdx,%rax), %xmm6
// CHECK: sha1msg2 64(%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xca,0x7a,0x40]
sha1msg2 64(%rdx), %xmm15
// CHECK: sha1msg2 64(%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xca,0x72,0x40]
sha1msg2 64(%rdx), %xmm6
// CHECK: sha1msg2 (%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xca,0x3a]
sha1msg2 (%rdx), %xmm15
// CHECK: sha1msg2 (%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xca,0x32]
sha1msg2 (%rdx), %xmm6
// CHECK: sha1msg2 %xmm15, %xmm15
// CHECK: encoding: [0x45,0x0f,0x38,0xca,0xff]
sha1msg2 %xmm15, %xmm15
// CHECK: sha1msg2 %xmm6, %xmm6
// CHECK: encoding: [0x0f,0x38,0xca,0xf6]
sha1msg2 %xmm6, %xmm6
// CHECK: sha1nexte 485498096, %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc8,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
sha1nexte 485498096, %xmm15
// CHECK: sha1nexte 485498096, %xmm6
// CHECK: encoding: [0x0f,0x38,0xc8,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
sha1nexte 485498096, %xmm6
// CHECK: sha1nexte 64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc8,0x7c,0x82,0x40]
sha1nexte 64(%rdx,%rax,4), %xmm15
// CHECK: sha1nexte -64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc8,0x7c,0x82,0xc0]
sha1nexte -64(%rdx,%rax,4), %xmm15
// CHECK: sha1nexte 64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc8,0x74,0x82,0x40]
sha1nexte 64(%rdx,%rax,4), %xmm6
// CHECK: sha1nexte -64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc8,0x74,0x82,0xc0]
sha1nexte -64(%rdx,%rax,4), %xmm6
// CHECK: sha1nexte 64(%rdx,%rax), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc8,0x7c,0x02,0x40]
sha1nexte 64(%rdx,%rax), %xmm15
// CHECK: sha1nexte 64(%rdx,%rax), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc8,0x74,0x02,0x40]
sha1nexte 64(%rdx,%rax), %xmm6
// CHECK: sha1nexte 64(%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc8,0x7a,0x40]
sha1nexte 64(%rdx), %xmm15
// CHECK: sha1nexte 64(%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc8,0x72,0x40]
sha1nexte 64(%rdx), %xmm6
// CHECK: sha1nexte (%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xc8,0x3a]
sha1nexte (%rdx), %xmm15
// CHECK: sha1nexte (%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xc8,0x32]
sha1nexte (%rdx), %xmm6
// CHECK: sha1nexte %xmm15, %xmm15
// CHECK: encoding: [0x45,0x0f,0x38,0xc8,0xff]
sha1nexte %xmm15, %xmm15
// CHECK: sha1nexte %xmm6, %xmm6
// CHECK: encoding: [0x0f,0x38,0xc8,0xf6]
sha1nexte %xmm6, %xmm6
// CHECK: sha1rnds4 $0, 485498096, %xmm15
// CHECK: encoding: [0x44,0x0f,0x3a,0xcc,0x3c,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
sha1rnds4 $0, 485498096, %xmm15
// CHECK: sha1rnds4 $0, 485498096, %xmm6
// CHECK: encoding: [0x0f,0x3a,0xcc,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
sha1rnds4 $0, 485498096, %xmm6
// CHECK: sha1rnds4 $0, 64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x3a,0xcc,0x7c,0x82,0x40,0x00]
sha1rnds4 $0, 64(%rdx,%rax,4), %xmm15
// CHECK: sha1rnds4 $0, -64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x3a,0xcc,0x7c,0x82,0xc0,0x00]
sha1rnds4 $0, -64(%rdx,%rax,4), %xmm15
// CHECK: sha1rnds4 $0, 64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x3a,0xcc,0x74,0x82,0x40,0x00]
sha1rnds4 $0, 64(%rdx,%rax,4), %xmm6
// CHECK: sha1rnds4 $0, -64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x3a,0xcc,0x74,0x82,0xc0,0x00]
sha1rnds4 $0, -64(%rdx,%rax,4), %xmm6
// CHECK: sha1rnds4 $0, 64(%rdx,%rax), %xmm15
// CHECK: encoding: [0x44,0x0f,0x3a,0xcc,0x7c,0x02,0x40,0x00]
sha1rnds4 $0, 64(%rdx,%rax), %xmm15
// CHECK: sha1rnds4 $0, 64(%rdx,%rax), %xmm6
// CHECK: encoding: [0x0f,0x3a,0xcc,0x74,0x02,0x40,0x00]
sha1rnds4 $0, 64(%rdx,%rax), %xmm6
// CHECK: sha1rnds4 $0, 64(%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x3a,0xcc,0x7a,0x40,0x00]
sha1rnds4 $0, 64(%rdx), %xmm15
// CHECK: sha1rnds4 $0, 64(%rdx), %xmm6
// CHECK: encoding: [0x0f,0x3a,0xcc,0x72,0x40,0x00]
sha1rnds4 $0, 64(%rdx), %xmm6
// CHECK: sha1rnds4 $0, (%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x3a,0xcc,0x3a,0x00]
sha1rnds4 $0, (%rdx), %xmm15
// CHECK: sha1rnds4 $0, (%rdx), %xmm6
// CHECK: encoding: [0x0f,0x3a,0xcc,0x32,0x00]
sha1rnds4 $0, (%rdx), %xmm6
// CHECK: sha1rnds4 $0, %xmm15, %xmm15
// CHECK: encoding: [0x45,0x0f,0x3a,0xcc,0xff,0x00]
sha1rnds4 $0, %xmm15, %xmm15
// CHECK: sha1rnds4 $0, %xmm6, %xmm6
// CHECK: encoding: [0x0f,0x3a,0xcc,0xf6,0x00]
sha1rnds4 $0, %xmm6, %xmm6
// CHECK: sha256msg1 485498096, %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcc,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
sha256msg1 485498096, %xmm15
// CHECK: sha256msg1 485498096, %xmm6
// CHECK: encoding: [0x0f,0x38,0xcc,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
sha256msg1 485498096, %xmm6
// CHECK: sha256msg1 64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcc,0x7c,0x82,0x40]
sha256msg1 64(%rdx,%rax,4), %xmm15
// CHECK: sha256msg1 -64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcc,0x7c,0x82,0xc0]
sha256msg1 -64(%rdx,%rax,4), %xmm15
// CHECK: sha256msg1 64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcc,0x74,0x82,0x40]
sha256msg1 64(%rdx,%rax,4), %xmm6
// CHECK: sha256msg1 -64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcc,0x74,0x82,0xc0]
sha256msg1 -64(%rdx,%rax,4), %xmm6
// CHECK: sha256msg1 64(%rdx,%rax), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcc,0x7c,0x02,0x40]
sha256msg1 64(%rdx,%rax), %xmm15
// CHECK: sha256msg1 64(%rdx,%rax), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcc,0x74,0x02,0x40]
sha256msg1 64(%rdx,%rax), %xmm6
// CHECK: sha256msg1 64(%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcc,0x7a,0x40]
sha256msg1 64(%rdx), %xmm15
// CHECK: sha256msg1 64(%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcc,0x72,0x40]
sha256msg1 64(%rdx), %xmm6
// CHECK: sha256msg1 (%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcc,0x3a]
sha256msg1 (%rdx), %xmm15
// CHECK: sha256msg1 (%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcc,0x32]
sha256msg1 (%rdx), %xmm6
// CHECK: sha256msg1 %xmm15, %xmm15
// CHECK: encoding: [0x45,0x0f,0x38,0xcc,0xff]
sha256msg1 %xmm15, %xmm15
// CHECK: sha256msg1 %xmm6, %xmm6
// CHECK: encoding: [0x0f,0x38,0xcc,0xf6]
sha256msg1 %xmm6, %xmm6
// CHECK: sha256msg2 485498096, %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcd,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
sha256msg2 485498096, %xmm15
// CHECK: sha256msg2 485498096, %xmm6
// CHECK: encoding: [0x0f,0x38,0xcd,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
sha256msg2 485498096, %xmm6
// CHECK: sha256msg2 64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcd,0x7c,0x82,0x40]
sha256msg2 64(%rdx,%rax,4), %xmm15
// CHECK: sha256msg2 -64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcd,0x7c,0x82,0xc0]
sha256msg2 -64(%rdx,%rax,4), %xmm15
// CHECK: sha256msg2 64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcd,0x74,0x82,0x40]
sha256msg2 64(%rdx,%rax,4), %xmm6
// CHECK: sha256msg2 -64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcd,0x74,0x82,0xc0]
sha256msg2 -64(%rdx,%rax,4), %xmm6
// CHECK: sha256msg2 64(%rdx,%rax), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcd,0x7c,0x02,0x40]
sha256msg2 64(%rdx,%rax), %xmm15
// CHECK: sha256msg2 64(%rdx,%rax), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcd,0x74,0x02,0x40]
sha256msg2 64(%rdx,%rax), %xmm6
// CHECK: sha256msg2 64(%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcd,0x7a,0x40]
sha256msg2 64(%rdx), %xmm15
// CHECK: sha256msg2 64(%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcd,0x72,0x40]
sha256msg2 64(%rdx), %xmm6
// CHECK: sha256msg2 (%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcd,0x3a]
sha256msg2 (%rdx), %xmm15
// CHECK: sha256msg2 (%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcd,0x32]
sha256msg2 (%rdx), %xmm6
// CHECK: sha256msg2 %xmm15, %xmm15
// CHECK: encoding: [0x45,0x0f,0x38,0xcd,0xff]
sha256msg2 %xmm15, %xmm15
// CHECK: sha256msg2 %xmm6, %xmm6
// CHECK: encoding: [0x0f,0x38,0xcd,0xf6]
sha256msg2 %xmm6, %xmm6
// CHECK: sha256rnds2 %xmm0, 485498096, %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcb,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
sha256rnds2 %xmm0, 485498096, %xmm15
// CHECK: sha256rnds2 %xmm0, 485498096, %xmm6
// CHECK: encoding: [0x0f,0x38,0xcb,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
sha256rnds2 %xmm0, 485498096, %xmm6
// CHECK: sha256rnds2 %xmm0, 64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcb,0x7c,0x82,0x40]
sha256rnds2 %xmm0, 64(%rdx,%rax,4), %xmm15
// CHECK: sha256rnds2 %xmm0, -64(%rdx,%rax,4), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcb,0x7c,0x82,0xc0]
sha256rnds2 %xmm0, -64(%rdx,%rax,4), %xmm15
// CHECK: sha256rnds2 %xmm0, 64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcb,0x74,0x82,0x40]
sha256rnds2 %xmm0, 64(%rdx,%rax,4), %xmm6
// CHECK: sha256rnds2 %xmm0, -64(%rdx,%rax,4), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcb,0x74,0x82,0xc0]
sha256rnds2 %xmm0, -64(%rdx,%rax,4), %xmm6
// CHECK: sha256rnds2 %xmm0, 64(%rdx,%rax), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcb,0x7c,0x02,0x40]
sha256rnds2 %xmm0, 64(%rdx,%rax), %xmm15
// CHECK: sha256rnds2 %xmm0, 64(%rdx,%rax), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcb,0x74,0x02,0x40]
sha256rnds2 %xmm0, 64(%rdx,%rax), %xmm6
// CHECK: sha256rnds2 %xmm0, 64(%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcb,0x7a,0x40]
sha256rnds2 %xmm0, 64(%rdx), %xmm15
// CHECK: sha256rnds2 %xmm0, 64(%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcb,0x72,0x40]
sha256rnds2 %xmm0, 64(%rdx), %xmm6
// CHECK: sha256rnds2 %xmm0, (%rdx), %xmm15
// CHECK: encoding: [0x44,0x0f,0x38,0xcb,0x3a]
sha256rnds2 %xmm0, (%rdx), %xmm15
// CHECK: sha256rnds2 %xmm0, (%rdx), %xmm6
// CHECK: encoding: [0x0f,0x38,0xcb,0x32]
sha256rnds2 %xmm0, (%rdx), %xmm6
// CHECK: sha256rnds2 %xmm0, %xmm15, %xmm15
// CHECK: encoding: [0x45,0x0f,0x38,0xcb,0xff]
sha256rnds2 %xmm0, %xmm15, %xmm15
// CHECK: sha256rnds2 %xmm0, %xmm6, %xmm6
// CHECK: encoding: [0x0f,0x38,0xcb,0xf6]
sha256rnds2 %xmm0, %xmm6, %xmm6

llvm/trunk/test/MC/X86/SVM-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: clgi
// CHECK: encoding: [0x0f,0x01,0xdd]
clgi
// CHECK: invlpga %ecx, %eax
// CHECK: encoding: [0x0f,0x01,0xdf]
invlpga %ecx, %eax
// CHECK: skinit %eax
// CHECK: encoding: [0x0f,0x01,0xde]
skinit %eax
// CHECK: stgi
// CHECK: encoding: [0x0f,0x01,0xdc]
stgi
// CHECK: vmload %eax
// CHECK: encoding: [0x0f,0x01,0xda]
vmload %eax
// CHECK: vmmcall
// CHECK: encoding: [0x0f,0x01,0xd9]
vmmcall
// CHECK: vmrun %eax
// CHECK: encoding: [0x0f,0x01,0xd8]
vmrun %eax
// CHECK: vmsave %eax
// CHECK: encoding: [0x0f,0x01,0xdb]
vmsave %eax

llvm/trunk/test/MC/X86/SVM-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: clgi
// CHECK: encoding: [0x0f,0x01,0xdd]
clgi
// CHECK: invlpga %ecx, %rax
// CHECK: encoding: [0x0f,0x01,0xdf]
invlpga %ecx, %rax
// CHECK: skinit %eax
// CHECK: encoding: [0x0f,0x01,0xde]
skinit %eax
// CHECK: stgi
// CHECK: encoding: [0x0f,0x01,0xdc]
stgi
// CHECK: vmload %rax
// CHECK: encoding: [0x0f,0x01,0xda]
vmload %rax
// CHECK: vmmcall
// CHECK: encoding: [0x0f,0x01,0xd9]
vmmcall
// CHECK: vmrun %rax
// CHECK: encoding: [0x0f,0x01,0xd8]
vmrun %rax
// CHECK: vmsave %rax
// CHECK: encoding: [0x0f,0x01,0xdb]
vmsave %rax

llvm/trunk/test/MC/X86/VMFUNC-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vmfunc
// CHECK: encoding: [0x0f,0x01,0xd4]
vmfunc

llvm/trunk/test/MC/X86/VMFUNC-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: vmfunc
// CHECK: encoding: [0x0f,0x01,0xd4]
vmfunc

llvm/trunk/test/MC/X86/VTX-32.s

// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: invept 3809469200(%edx,%eax,4), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x80,0x84,0x82,0x10,0xe3,0x0f,0xe3]
invept 3809469200(%edx,%eax,4), %eax
// CHECK: invept 485498096, %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x80,0x05,0xf0,0x1c,0xf0,0x1c]
invept 485498096, %eax
// CHECK: invept 485498096(%edx,%eax,4), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x80,0x84,0x82,0xf0,0x1c,0xf0,0x1c]
invept 485498096(%edx,%eax,4), %eax
// CHECK: invept 485498096(%edx), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x80,0x82,0xf0,0x1c,0xf0,0x1c]
invept 485498096(%edx), %eax
// CHECK: invept 64(%edx,%eax), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x80,0x44,0x02,0x40]
invept 64(%edx,%eax), %eax
// CHECK: invept (%edx), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x80,0x02]
invept (%edx), %eax
// CHECK: invvpid 3809469200(%edx,%eax,4), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x81,0x84,0x82,0x10,0xe3,0x0f,0xe3]
invvpid 3809469200(%edx,%eax,4), %eax
// CHECK: invvpid 485498096, %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x81,0x05,0xf0,0x1c,0xf0,0x1c]
invvpid 485498096, %eax
// CHECK: invvpid 485498096(%edx,%eax,4), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x81,0x84,0x82,0xf0,0x1c,0xf0,0x1c]
invvpid 485498096(%edx,%eax,4), %eax
// CHECK: invvpid 485498096(%edx), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x81,0x82,0xf0,0x1c,0xf0,0x1c]
invvpid 485498096(%edx), %eax
// CHECK: invvpid 64(%edx,%eax), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x81,0x44,0x02,0x40]
invvpid 64(%edx,%eax), %eax
// CHECK: invvpid (%edx), %eax
// CHECK: encoding: [0x66,0x0f,0x38,0x81,0x02]
invvpid (%edx), %eax
// CHECK: vmcall
// CHECK: encoding: [0x0f,0x01,0xc1]
vmcall
// CHECK: vmclear -485498096(%edx,%eax,4)
// CHECK: encoding: [0x66,0x0f,0xc7,0xb4,0x82,0x10,0xe3,0x0f,0xe3]
vmclear -485498096(%edx,%eax,4)
// CHECK: vmclear 485498096(%edx,%eax,4)
// CHECK: encoding: [0x66,0x0f,0xc7,0xb4,0x82,0xf0,0x1c,0xf0,0x1c]
vmclear 485498096(%edx,%eax,4)
// CHECK: vmclear 485498096(%edx)
// CHECK: encoding: [0x66,0x0f,0xc7,0xb2,0xf0,0x1c,0xf0,0x1c]
vmclear 485498096(%edx)
// CHECK: vmclear 485498096
// CHECK: encoding: [0x66,0x0f,0xc7,0x35,0xf0,0x1c,0xf0,0x1c]
vmclear 485498096
// CHECK: vmclear 64(%edx,%eax)
// CHECK: encoding: [0x66,0x0f,0xc7,0x74,0x02,0x40]
vmclear 64(%edx,%eax)
// CHECK: vmclear (%edx)
// CHECK: encoding: [0x66,0x0f,0xc7,0x32]
vmclear (%edx)
// CHECK: vmlaunch
// CHECK: encoding: [0x0f,0x01,0xc2]
vmlaunch
// CHECK: vmptrld -485498096(%edx,%eax,4)
// CHECK: encoding: [0x0f,0xc7,0xb4,0x82,0x10,0xe3,0x0f,0xe3]
vmptrld -485498096(%edx,%eax,4)
// CHECK: vmptrld 485498096(%edx,%eax,4)
// CHECK: encoding: [0x0f,0xc7,0xb4,0x82,0xf0,0x1c,0xf0,0x1c]
vmptrld 485498096(%edx,%eax,4)
// CHECK: vmptrld 485498096(%edx)
// CHECK: encoding: [0x0f,0xc7,0xb2,0xf0,0x1c,0xf0,0x1c]
vmptrld 485498096(%edx)
// CHECK: vmptrld 485498096
// CHECK: encoding: [0x0f,0xc7,0x35,0xf0,0x1c,0xf0,0x1c]
vmptrld 485498096
// CHECK: vmptrld 64(%edx,%eax)
// CHECK: encoding: [0x0f,0xc7,0x74,0x02,0x40]
vmptrld 64(%edx,%eax)
// CHECK: vmptrld (%edx)
// CHECK: encoding: [0x0f,0xc7,0x32]
vmptrld (%edx)
// CHECK: vmptrst -485498096(%edx,%eax,4)
// CHECK: encoding: [0x0f,0xc7,0xbc,0x82,0x10,0xe3,0x0f,0xe3]
vmptrst -485498096(%edx,%eax,4)
// CHECK: vmptrst 485498096(%edx,%eax,4)
// CHECK: encoding: [0x0f,0xc7,0xbc,0x82,0xf0,0x1c,0xf0,0x1c]
vmptrst 485498096(%edx,%eax,4)
// CHECK: vmptrst 485498096(%edx)
// CHECK: encoding: [0x0f,0xc7,0xba,0xf0,0x1c,0xf0,0x1c]
vmptrst 485498096(%edx)
// CHECK: vmptrst 485498096
// CHECK: encoding: [0x0f,0xc7,0x3d,0xf0,0x1c,0xf0,0x1c]
vmptrst 485498096
// CHECK: vmptrst 64(%edx,%eax)
// CHECK: encoding: [0x0f,0xc7,0x7c,0x02,0x40]
vmptrst 64(%edx,%eax)
// CHECK: vmptrst (%edx)
// CHECK: encoding: [0x0f,0xc7,0x3a]
vmptrst (%edx)
// CHECK: vmreadl %eax, 3809469200(%edx,%eax,4)
// CHECK: encoding: [0x0f,0x78,0x84,0x82,0x10,0xe3,0x0f,0xe3]
vmreadl %eax, 3809469200(%edx,%eax,4)
// CHECK: vmreadl %eax, 485498096(%edx,%eax,4)
// CHECK: encoding: [0x0f,0x78,0x84,0x82,0xf0,0x1c,0xf0,0x1c]
vmreadl %eax, 485498096(%edx,%eax,4)
// CHECK: vmreadl %eax, 485498096(%edx)
// CHECK: encoding: [0x0f,0x78,0x82,0xf0,0x1c,0xf0,0x1c]
vmreadl %eax, 485498096(%edx)
// CHECK: vmreadl %eax, 485498096
// CHECK: encoding: [0x0f,0x78,0x05,0xf0,0x1c,0xf0,0x1c]
vmreadl %eax, 485498096
// CHECK: vmreadl %eax, 64(%edx,%eax)
// CHECK: encoding: [0x0f,0x78,0x44,0x02,0x40]
vmreadl %eax, 64(%edx,%eax)
// CHECK: vmreadl %eax, %eax
// CHECK: encoding: [0x0f,0x78,0xc0]
vmreadl %eax, %eax
// CHECK: vmreadl %eax, (%edx)
// CHECK: encoding: [0x0f,0x78,0x02]
vmreadl %eax, (%edx)
// CHECK: vmresume
// CHECK: encoding: [0x0f,0x01,0xc3]
vmresume
// CHECK: vmwritel 3809469200(%edx,%eax,4), %eax
// CHECK: encoding: [0x0f,0x79,0x84,0x82,0x10,0xe3,0x0f,0xe3]
vmwritel 3809469200(%edx,%eax,4), %eax
// CHECK: vmwritel 485498096, %eax
// CHECK: encoding: [0x0f,0x79,0x05,0xf0,0x1c,0xf0,0x1c]
vmwritel 485498096, %eax
// CHECK: vmwritel 485498096(%edx,%eax,4), %eax
// CHECK: encoding: [0x0f,0x79,0x84,0x82,0xf0,0x1c,0xf0,0x1c]
vmwritel 485498096(%edx,%eax,4), %eax
// CHECK: vmwritel 485498096(%edx), %eax
// CHECK: encoding: [0x0f,0x79,0x82,0xf0,0x1c,0xf0,0x1c]
vmwritel 485498096(%edx), %eax
// CHECK: vmwritel 64(%edx,%eax), %eax
// CHECK: encoding: [0x0f,0x79,0x44,0x02,0x40]
vmwritel 64(%edx,%eax), %eax
// CHECK: vmwritel %eax, %eax
// CHECK: encoding: [0x0f,0x79,0xc0]
vmwritel %eax, %eax
// CHECK: vmwritel (%edx), %eax
// CHECK: encoding: [0x0f,0x79,0x02]
vmwritel (%edx), %eax
// CHECK: vmxoff
// CHECK: encoding: [0x0f,0x01,0xc4]
vmxoff
// CHECK: vmxon -485498096(%edx,%eax,4)
// CHECK: encoding: [0xf3,0x0f,0xc7,0xb4,0x82,0x10,0xe3,0x0f,0xe3]
vmxon -485498096(%edx,%eax,4)
// CHECK: vmxon 485498096(%edx,%eax,4)
// CHECK: encoding: [0xf3,0x0f,0xc7,0xb4,0x82,0xf0,0x1c,0xf0,0x1c]
vmxon 485498096(%edx,%eax,4)
// CHECK: vmxon 485498096(%edx)
// CHECK: encoding: [0xf3,0x0f,0xc7,0xb2,0xf0,0x1c,0xf0,0x1c]
vmxon 485498096(%edx)
// CHECK: vmxon 485498096
// CHECK: encoding: [0xf3,0x0f,0xc7,0x35,0xf0,0x1c,0xf0,0
vmxon 485498096
// CHECK: vmxon 485498096
// CHECK: encoding: [0xf3,0x0f,0xc7,0x35,0xf0,0x1c,0xf0,0x1c]
vmxon 485498096
// CHECK: vmxon 64(%edx,%eax)
// CHECK: encoding: [0xf3,0x0f,0xc7,0x74,0x02,0x40]
vmxon 64(%edx,%eax)
// CHECK: vmxon (%edx)
// CHECK: encoding: [0xf3,0x0f,0xc7,0x32]
vmxon (%edx)

llvm/trunk/test/MC/X86/VTX-64.s

// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
// CHECK: invept 485498096, %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x80,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
invept 485498096, %r15
// CHECK: invept 64(%rdx), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x80,0x7a,0x40]
invept 64(%rdx), %r15
// CHECK: invept 64(%rdx,%rax,4), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x80,0x7c,0x82,0x40]
invept 64(%rdx,%rax,4), %r15
// CHECK: invept -64(%rdx,%rax,4), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x80,0x7c,0x82,0xc0]
invept -64(%rdx,%rax,4), %r15
// CHECK: invept 64(%rdx,%rax), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x80,0x7c,0x02,0x40]
invept 64(%rdx,%rax), %r15
// CHECK: invept (%rdx), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x80,0x3a]
invept (%rdx), %r15
// CHECK: invvpid 485498096, %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x81,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
invvpid 485498096, %r15
// CHECK: invvpid 64(%rdx), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x81,0x7a,0x40]
invvpid 64(%rdx), %r15
// CHECK: invvpid 64(%rdx,%rax,4), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x81,0x7c,0x82,0x40]
invvpid 64(%rdx,%rax,4), %r15
// CHECK: invvpid -64(%rdx,%rax,4), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x81,0x7c,0x82,0xc0]
invvpid -64(%rdx,%rax,4), %r15
// CHECK: invvpid 64(%rdx,%rax), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x81,0x7c,0x02,0x40]
invvpid 64(%rdx,%rax), %r15
// CHECK: invvpid (%rdx), %r15
// CHECK: encoding: [0x66,0x44,0x0f,0x38,0x81,0x3a]
invvpid (%rdx), %r15
// CHECK: vmcall
// CHECK: encoding: [0x0f,0x01,0xc1]
vmcall
// CHECK: vmclear 485498096
// CHECK: encoding: [0x66,0x0f,0xc7,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
vmclear 485498096
// CHECK: vmclear 64(%rdx)
// CHECK: encoding: [0x66,0x0f,0xc7,0x72,0x40]
vmclear 64(%rdx)
// CHECK: vmclear 64(%rdx,%rax,4)
// CHECK: encoding: [0x66,0x0f,0xc7,0x74,0x82,0x40]
vmclear 64(%rdx,%rax,4)
// CHECK: vmclear -64(%rdx,%rax,4)
// CHECK: encoding: [0x66,0x0f,0xc7,0x74,0x82,0xc0]
vmclear -64(%rdx,%rax,4)
// CHECK: vmclear 64(%rdx,%rax)
// CHECK: encoding: [0x66,0x0f,0xc7,0x74,0x02,0x40]
vmclear 64(%rdx,%rax)
// CHECK: vmclear (%rdx)
// CHECK: encoding: [0x66,0x0f,0xc7,0x32]
vmclear (%rdx)
// CHECK: vmlaunch
// CHECK: encoding: [0x0f,0x01,0xc2]
vmlaunch
// CHECK: vmptrld 485498096
// CHECK: encoding: [0x0f,0xc7,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
vmptrld 485498096
// CHECK: vmptrld 64(%rdx)
// CHECK: encoding: [0x0f,0xc7,0x72,0x40]
vmptrld 64(%rdx)
// CHECK: vmptrld 64(%rdx,%rax,4)
// CHECK: encoding: [0x0f,0xc7,0x74,0x82,0x40]
vmptrld 64(%rdx,%rax,4)
// CHECK: vmptrld -64(%rdx,%rax,4)
// CHECK: encoding: [0x0f,0xc7,0x74,0x82,0xc0]
vmptrld -64(%rdx,%rax,4)
// CHECK: vmptrld 64(%rdx,%rax)
// CHECK: encoding: [0x0f,0xc7,0x74,0x02,0x40]
vmptrld 64(%rdx,%rax)
// CHECK: vmptrld (%rdx)
// CHECK: encoding: [0x0f,0xc7,0x32]
vmptrld (%rdx)
// CHECK: vmptrst 485498096
// CHECK: encoding: [0x0f,0xc7,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
vmptrst 485498096
// CHECK: vmptrst 64(%rdx)
// CHECK: encoding: [0x0f,0xc7,0x7a,0x40]
vmptrst 64(%rdx)
// CHECK: vmptrst 64(%rdx,%rax,4)
// CHECK: encoding: [0x0f,0xc7,0x7c,0x82,0x40]
vmptrst 64(%rdx,%rax,4)
// CHECK: vmptrst -64(%rdx,%rax,4)
// CHECK: encoding: [0x0f,0xc7,0x7c,0x82,0xc0]
vmptrst -64(%rdx,%rax,4)
// CHECK: vmptrst 64(%rdx,%rax)
// CHECK: encoding: [0x0f,0xc7,0x7c,0x02,0x40]
vmptrst 64(%rdx,%rax)
// CHECK: vmptrst (%rdx)
// CHECK: encoding: [0x0f,0xc7,0x3a]
vmptrst (%rdx)
// CHECK: vmreadq %r15, 485498096
// CHECK: encoding: [0x44,0x0f,0x78,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
vmreadq %r15, 485498096
// CHECK: vmreadq %r15, 64(%rdx)
// CHECK: encoding: [0x44,0x0f,0x78,0x7a,0x40]
vmreadq %r15, 64(%rdx)
// CHECK: vmreadq %r15, 64(%rdx,%rax,4)
// CHECK: encoding: [0x44,0x0f,0x78,0x7c,0x82,0x40]
vmreadq %r15, 64(%rdx,%rax,4)
// CHECK: vmreadq %r15, -64(%rdx,%rax,4)
// CHECK: encoding: [0x44,0x0f,0x78,0x7c,0x82,0xc0]
vmreadq %r15, -64(%rdx,%rax,4)
// CHECK: vmreadq %r15, 64(%rdx,%rax)
// CHECK: encoding: [0x44,0x0f,0x78,0x7c,0x02,0x40]
vmreadq %r15, 64(%rdx,%rax)
// CHECK: vmreadq %r15, %r15
// CHECK: encoding: [0x45,0x0f,0x78,0xff]
vmreadq %r15, %r15
// CHECK: vmreadq %r15, (%rdx)
// CHECK: encoding: [0x44,0x0f,0x78,0x3a]
vmreadq %r15, (%rdx)
// CHECK: vmresume
// CHECK: encoding: [0x0f,0x01,0xc3]
vmresume
// CHECK: vmwriteq 485498096, %r15
// CHECK: encoding: [0x44,0x0f,0x79,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
vmwriteq 485498096, %r15
// CHECK: vmwriteq 64(%rdx), %r15
// CHECK: encoding: [0x44,0x0f,0x79,0x7a,0x40]
vmwriteq 64(%rdx), %r15
// CHECK: vmwriteq 64(%rdx,%rax,4), %r15
// CHECK: encoding: [0x44,0x0f,0x79,0x7c,0x82,0x40]
vmwriteq 64(%rdx,%rax,4), %r15
// CHECK: vmwriteq -64(%rdx,%rax,4), %r15
// CHECK: encoding: [0x44,0x0f,0x79,0x7c,0x82,0xc0]
vmwriteq -64(%rdx,%rax,4), %r15
// CHECK: vmwriteq 64(%rdx,%rax), %r15
// CHECK: encoding: [0x44,0x0f,0x79,0x7c,0x02,0x40]
vmwriteq 64(%rdx,%rax), %r15
// CHECK: vmwriteq %r15, %r15
// CHECK: encoding: [0x45,0x0f,0x79,0xff]
vmwriteq %r15, %r15
// CHECK: vmwriteq (%rdx), %r15
// CHECK: encoding: [0x44,0x0f,0x79,0x3a]
vmwriteq (%rdx), %r15
// CHECK: vmxoff
// CHECK: encoding: [0x0f,0x01,0xc4]
vmxoff
// CHECK: vmxon 485498096
// CHECK: encoding: [0xf3,0x0f,0xc7,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
vmxon 485498096
// CHECK: vmxon 64(%rdx)
// CHECK: encoding: [0xf3,0x0f,0xc7,0x72,0x40]
vmxon 64(%rdx)
// CHECK: vmxon 64(%rdx,%rax,4)
// CHECK: encoding: [0xf3,0x0f,0xc7,0x74,0x82,0x40]
vmxon 64(%rdx,%rax,4)
// CHECK: vmxon -64(%rdx,%rax,4)
// CHECK: encoding: [0xf3,0x0f,0xc7,0x74,0x82,0xc0]
vmxon -64(%rdx,%rax,4)
// CHECK: vmxon 64(%rdx,%rax)
// CHECK: encoding: [0xf3,0x0f,0xc7,0x74,0x02,0x40]
vmxon 64(%rdx,%rax)
// CHECK: vmxon (%rdx)
// CHECK: encoding: [0xf3,0x0f,0xc7,0x32]
vmxon (%rdx)