[X86][SSE]: Adding full coverage of MC encoding tests for the SSE isa sets.<NFC>

[tianqing]

Summary

NFC.
Adding MC regressions tests to cover all the SSE ISA sets as follows:
SSE, SSE2, SSE3, SSE4, SSE42, SSEMXCSR, SSE_PREFETCH, SSSE3

This patch is part of a larger task to cover MC encoding of all X86 ISA Sets.
See revision: https://reviews.llvm.org/D39952

[craig.topper]

test/MC/X86/SSE4-64.s

301 ↗

(On Diff #124063)

movntsd/movntss is an AMD SSE4A instruction. Can you move it any other instructions to SSE4A-64.s/SSE4A-32.s Probably should split SSE4.1 and SSE4.2 as well.

[tianqing]

Removed SSE4a tests. Split SSE4.1 and SSE4.2 tests.

[craig.topper]

Why were the SSE4a tests removed? They should be split out, but I don't see any reason to remove them unless we already have equivalent coverage for them.

[tianqing]

In D40387#1367366, @craig.topper wrote:

Why were the SSE4a tests removed? They should be split out, but I don't see any reason to remove them unless we already have equivalent coverage for them.

I saw there is a x86_64-sse4a.s which has the 64-bit part already covered. Should I just ignore it and split out SSE4a-32/64.s, or just add the 32-bit tests with some name like x86-sse4a.s?

[craig.topper]

I think just ignore what’s there already. We definitely need a 32 bit test. We can look for redundant tests once we get everything in.

[RKSimon]

Please add the SSE4A test files back - once those are in we can look at stripping out the older (partial) coverage tests

[RKSimon]

Also, please can you PCLMUL full coverage tests as well - AFAICT we have AVX variants tests but not non-VEX

[tianqing]

Added SSE4a tests.

[tianqing]

In D40387#1367603, @RKSimon wrote:

Also, please can you PCLMUL full coverage tests as well - AFAICT we have AVX variants tests but not non-VEX

Of course. But I'd prefer to do it in a separate patch, and after we are finished with the AVX tests.

[RKSimon]

Shouldn't the MMX pextrw/pinsrw ops be under SSE1 not MMX?

[craig.topper]

In D40387#1369358, @RKSimon wrote:

Shouldn't the MMX pextrw/pinsrw ops be under SSE1 not MMX?

Same could also be said for PADDQ and PSUBQ which are in the MMX file but are SSE2. Despite the Intel SDM mistakenly listing PADDQ as MMX.

Weirdly pextrw is missing from MMX-32.s but its in MMX-64.s

[RKSimon]

The reg-reg variant of pinsrw is missing from the MMX tests as well.

[tianqing]

Fix tests for pinsrw/pextrw/paddq.

[tianqing]

Fixed whitespace.

[RKSimon]

I think psubq needs moving to SSE2 as well

[tianqing]

Moved psubq tests from MMX to SSE2

[craig.topper]

test/MC/X86/SSE42-64.s

34

crc32q?

[tianqing]

Added crc32 tests.

[RKSimon]

psubq needs removing from MMX-64.s as well

[tianqing]

Removed psubq from MMX-64.s.

I don't know what's wrong with me but I'm sorry for so many negligences ...

[RKSimon]

Not your fault, we don't have a canonical list of the instructions and their CPUID bits to generate this kind of thing from (at least not one that people can agree on), so everybody ends up redoing this from scratch - I went through the same thing with the llvm-mca resource tests.

[RKSimon]

@craig.topper Any more comments?

[craig.topper]

LGTM

test/MC/X86/MMX-32.s

 // CHECK: paddd (%edx), %mm4 
 // CHECK: encoding: [0x0f,0xfe,0x22]        
 paddd (%edx), %mm4 
 
 // CHECK: paddd %mm4, %mm4 
 // CHECK: encoding: [0x0f,0xfe,0xe4]        
 paddd %mm4, %mm4 
 
-// CHECK: paddq -485498096(%edx,%eax,4), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0xa4,0x82,0x10,0xe3,0x0f,0xe3]        
-paddq -485498096(%edx,%eax,4), %mm4 
-
-// CHECK: paddq 485498096(%edx,%eax,4), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]        
-paddq 485498096(%edx,%eax,4), %mm4 
-
-// CHECK: paddq 485498096(%edx), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0xa2,0xf0,0x1c,0xf0,0x1c]        
-paddq 485498096(%edx), %mm4 
-
-// CHECK: paddq 485498096, %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x25,0xf0,0x1c,0xf0,0x1c]        
-paddq 485498096, %mm4 
-
-// CHECK: paddq 64(%edx,%eax), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x64,0x02,0x40]        
-paddq 64(%edx,%eax), %mm4 
-
-// CHECK: paddq (%edx), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x22]        
-paddq (%edx), %mm4 
-
-// CHECK: paddq %mm4, %mm4 
-// CHECK: encoding: [0x0f,0xd4,0xe4]        
-paddq %mm4, %mm4 
-
-// CHECK: paddsb -485498096(%edx,%eax,4), %mm4 
+// CHECK: paddsb -485498096(%edx,%eax,4), %mm4
 // CHECK: encoding: [0x0f,0xec,0xa4,0x82,0x10,0xe3,0x0f,0xe3]        
 paddsb -485498096(%edx,%eax,4), %mm4 
 
 // CHECK: paddsb 485498096(%edx,%eax,4), %mm4 
 // CHECK: encoding: [0x0f,0xec,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]        
 paddsb 485498096(%edx,%eax,4), %mm4 
 
 // CHECK: paddsb 485498096(%edx), %mm4 

 // CHECK: pcmpgtw (%edx), %mm4 
 // CHECK: encoding: [0x0f,0x65,0x22]        
 pcmpgtw (%edx), %mm4 
 
 // CHECK: pcmpgtw %mm4, %mm4 
 // CHECK: encoding: [0x0f,0x65,0xe4]        
 pcmpgtw %mm4, %mm4 
 
-// CHECK: pinsrw $0, -485498096(%edx,%eax,4), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0xa4,0x82,0x10,0xe3,0x0f,0xe3,0x00]       
-pinsrw $0, -485498096(%edx,%eax,4), %mm4 
-
-// CHECK: pinsrw $0, 485498096(%edx,%eax,4), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0xa4,0x82,0xf0,0x1c,0xf0,0x1c,0x00]       
-pinsrw $0, 485498096(%edx,%eax,4), %mm4 
-
-// CHECK: pinsrw $0, 485498096(%edx), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0xa2,0xf0,0x1c,0xf0,0x1c,0x00]       
-pinsrw $0, 485498096(%edx), %mm4 
-
-// CHECK: pinsrw $0, 485498096, %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x25,0xf0,0x1c,0xf0,0x1c,0x00]       
-pinsrw $0, 485498096, %mm4 
-
-// CHECK: pinsrw $0, 64(%edx,%eax), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x64,0x02,0x40,0x00]       
-pinsrw $0, 64(%edx,%eax), %mm4 
-
-// CHECK: pinsrw $0, (%edx), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x22,0x00]       
-pinsrw $0, (%edx), %mm4 
-
 // CHECK: pmaddwd -485498096(%edx,%eax,4), %mm4 
 // CHECK: encoding: [0x0f,0xf5,0xa4,0x82,0x10,0xe3,0x0f,0xe3]        
 pmaddwd -485498096(%edx,%eax,4), %mm4 
 
 // CHECK: pmaddwd 485498096(%edx,%eax,4), %mm4 
 // CHECK: encoding: [0x0f,0xf5,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]        
 pmaddwd 485498096(%edx,%eax,4), %mm4 
 

test/MC/X86/MMX-64.s

 // CHECK: paddd %mm4, %mm4 
 // CHECK: encoding: [0x0f,0xfe,0xe4]        
 paddd %mm4, %mm4 
 
 // CHECK: paddd (%rdx), %mm4 
 // CHECK: encoding: [0x0f,0xfe,0x22]        
 paddd (%rdx), %mm4 
 
-// CHECK: paddq 485498096, %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x24,0x25,0xf0,0x1c,0xf0,0x1c]        
-paddq 485498096, %mm4 
-
-// CHECK: paddq 64(%rdx), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x62,0x40]        
-paddq 64(%rdx), %mm4 
-
-// CHECK: paddq 64(%rdx,%rax,4), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x64,0x82,0x40]        
-paddq 64(%rdx,%rax,4), %mm4 
-
-// CHECK: paddq -64(%rdx,%rax,4), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x64,0x82,0xc0]        
-paddq -64(%rdx,%rax,4), %mm4 
-
-// CHECK: paddq 64(%rdx,%rax), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x64,0x02,0x40]        
-paddq 64(%rdx,%rax), %mm4 
-
-// CHECK: paddq %mm4, %mm4 
-// CHECK: encoding: [0x0f,0xd4,0xe4]        
-paddq %mm4, %mm4 
-
-// CHECK: paddq (%rdx), %mm4 
-// CHECK: encoding: [0x0f,0xd4,0x22]        
-paddq (%rdx), %mm4 
-
 // CHECK: paddsb 485498096, %mm4 
 // CHECK: encoding: [0x0f,0xec,0x24,0x25,0xf0,0x1c,0xf0,0x1c]        
 paddsb 485498096, %mm4 
 
 // CHECK: paddsb 64(%rdx), %mm4 
 // CHECK: encoding: [0x0f,0xec,0x62,0x40]        
 paddsb 64(%rdx), %mm4 
 

 // CHECK: pcmpgtw %mm4, %mm4 
 // CHECK: encoding: [0x0f,0x65,0xe4]        
 pcmpgtw %mm4, %mm4 
 
 // CHECK: pcmpgtw (%rdx), %mm4 
 // CHECK: encoding: [0x0f,0x65,0x22]        
 pcmpgtw (%rdx), %mm4 
 
-// CHECK: pextrw $0, %mm4, %r13d 
-// CHECK: encoding: [0x44,0x0f,0xc5,0xec,0x00]       
-pextrw $0, %mm4, %r13d 
-
-// CHECK: pinsrw $0, 485498096, %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x24,0x25,0xf0,0x1c,0xf0,0x1c,0x00]       
-pinsrw $0, 485498096, %mm4 
-
-// CHECK: pinsrw $0, 64(%rdx), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x62,0x40,0x00]       
-pinsrw $0, 64(%rdx), %mm4 
-
-// CHECK: pinsrw $0, 64(%rdx,%rax,4), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x64,0x82,0x40,0x00]       
-pinsrw $0, 64(%rdx,%rax,4), %mm4 
-
-// CHECK: pinsrw $0, -64(%rdx,%rax,4), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x64,0x82,0xc0,0x00]       
-pinsrw $0, -64(%rdx,%rax,4), %mm4 
-
-// CHECK: pinsrw $0, 64(%rdx,%rax), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x64,0x02,0x40,0x00]       
-pinsrw $0, 64(%rdx,%rax), %mm4 
-
-// CHECK: pinsrw $0, %r13d, %mm4 
-// CHECK: encoding: [0x41,0x0f,0xc4,0xe5,0x00]       
-pinsrw $0, %r13d, %mm4 
-
-// CHECK: pinsrw $0, (%rdx), %mm4 
-// CHECK: encoding: [0x0f,0xc4,0x22,0x00]       
-pinsrw $0, (%rdx), %mm4 
-
-// CHECK: pmaddwd 485498096, %mm4 
+// CHECK: pmaddwd 485498096, %mm4
 // CHECK: encoding: [0x0f,0xf5,0x24,0x25,0xf0,0x1c,0xf0,0x1c]        
 pmaddwd 485498096, %mm4 
 
 // CHECK: pmaddwd 64(%rdx), %mm4 
 // CHECK: encoding: [0x0f,0xf5,0x62,0x40]        
 pmaddwd 64(%rdx), %mm4 
 
 // CHECK: pmaddwd 64(%rdx,%rax,4), %mm4 

test/MC/X86/SSE-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: addps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+addps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+addps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
+addps 485498096(%edx), %xmm1
+
+// CHECK: addps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
+addps 485498096, %xmm1
+
+// CHECK: addps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x58,0x4c,0x02,0x40]
+addps 64(%edx,%eax), %xmm1
+
+// CHECK: addps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x58,0x0a]
+addps (%edx), %xmm1
+
+// CHECK: addps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x58,0xc9]
+addps %xmm1, %xmm1
+
+// CHECK: addss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+addss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+addss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
+addss 485498096(%edx), %xmm1
+
+// CHECK: addss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
+addss 485498096, %xmm1
+
+// CHECK: addss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x58,0x4c,0x02,0x40]
+addss 64(%edx,%eax), %xmm1
+
+// CHECK: addss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x58,0x0a]
+addss (%edx), %xmm1
+
+// CHECK: addss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x58,0xc9]
+addss %xmm1, %xmm1
+
+// CHECK: andnps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x55,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+andnps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: andnps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x55,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+andnps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: andnps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x55,0x8a,0xf0,0x1c,0xf0,0x1c]
+andnps 485498096(%edx), %xmm1
+
+// CHECK: andnps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x55,0x0d,0xf0,0x1c,0xf0,0x1c]
+andnps 485498096, %xmm1
+
+// CHECK: andnps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x55,0x4c,0x02,0x40]
+andnps 64(%edx,%eax), %xmm1
+
+// CHECK: andnps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x55,0x0a]
+andnps (%edx), %xmm1
+
+// CHECK: andnps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x55,0xc9]
+andnps %xmm1, %xmm1
+
+// CHECK: andps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x54,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+andps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: andps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x54,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+andps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: andps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x54,0x8a,0xf0,0x1c,0xf0,0x1c]
+andps 485498096(%edx), %xmm1
+
+// CHECK: andps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x54,0x0d,0xf0,0x1c,0xf0,0x1c]
+andps 485498096, %xmm1
+
+// CHECK: andps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x54,0x4c,0x02,0x40]
+andps 64(%edx,%eax), %xmm1
+
+// CHECK: andps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x54,0x0a]
+andps (%edx), %xmm1
+
+// CHECK: andps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x54,0xc9]
+andps %xmm1, %xmm1
+
+// CHECK: cmpeqps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0xc2,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+cmpeqps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cmpeqps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0xc2,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cmpeqps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0xc2,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqps 485498096(%edx), %xmm1
+
+// CHECK: cmpeqps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0xc2,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqps 485498096, %xmm1
+
+// CHECK: cmpeqps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0xc2,0x4c,0x02,0x40,0x00]
+cmpeqps 64(%edx,%eax), %xmm1
+
+// CHECK: cmpeqps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0xc2,0x0a,0x00]
+cmpeqps (%edx), %xmm1
+
+// CHECK: cmpeqps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0xc2,0xc9,0x00]
+cmpeqps %xmm1, %xmm1
+
+// CHECK: cmpeqss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+cmpeqss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cmpeqss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cmpeqss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqss 485498096(%edx), %xmm1
+
+// CHECK: cmpeqss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqss 485498096, %xmm1
+
+// CHECK: cmpeqss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x4c,0x02,0x40,0x00]
+cmpeqss 64(%edx,%eax), %xmm1
+
+// CHECK: cmpeqss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x0a,0x00]
+cmpeqss (%edx), %xmm1
+
+// CHECK: cmpeqss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xc2,0xc9,0x00]
+cmpeqss %xmm1, %xmm1
+
+// CHECK: comiss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x2f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+comiss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: comiss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x2f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+comiss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: comiss 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x2f,0x8a,0xf0,0x1c,0xf0,0x1c]
+comiss 485498096(%edx), %xmm1
+
+// CHECK: comiss 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x2f,0x0d,0xf0,0x1c,0xf0,0x1c]
+comiss 485498096, %xmm1
+
+// CHECK: comiss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x2f,0x4c,0x02,0x40]
+comiss 64(%edx,%eax), %xmm1
+
+// CHECK: comiss (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x2f,0x0a]
+comiss (%edx), %xmm1
+
+// CHECK: comiss %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x2f,0xc9]
+comiss %xmm1, %xmm1
+
+// CHECK: cvtpi2ps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtpi2ps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtpi2ps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtpi2ps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtpi2ps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtpi2ps 485498096(%edx), %xmm1
+
+// CHECK: cvtpi2ps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtpi2ps 485498096, %xmm1
+
+// CHECK: cvtpi2ps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x2a,0x4c,0x02,0x40]
+cvtpi2ps 64(%edx,%eax), %xmm1
+
+// CHECK: cvtpi2ps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x2a,0x0a]
+cvtpi2ps (%edx), %xmm1
+
+// CHECK: cvtpi2ps %mm4, %xmm1
+// CHECK: encoding: [0x0f,0x2a,0xcc]
+cvtpi2ps %mm4, %xmm1
+
+// CHECK: cvtps2pi -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x2d,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+cvtps2pi -485498096(%edx,%eax,4), %mm4
+
+// CHECK: cvtps2pi 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x2d,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtps2pi 485498096(%edx,%eax,4), %mm4
+
+// CHECK: cvtps2pi 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x2d,0xa2,0xf0,0x1c,0xf0,0x1c]
+cvtps2pi 485498096(%edx), %mm4
+
+// CHECK: cvtps2pi 485498096, %mm4
+// CHECK: encoding: [0x0f,0x2d,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtps2pi 485498096, %mm4
+
+// CHECK: cvtps2pi 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x2d,0x64,0x02,0x40]
+cvtps2pi 64(%edx,%eax), %mm4
+
+// CHECK: cvtps2pi (%edx), %mm4
+// CHECK: encoding: [0x0f,0x2d,0x22]
+cvtps2pi (%edx), %mm4
+
+// CHECK: cvtps2pi %xmm1, %mm4
+// CHECK: encoding: [0x0f,0x2d,0xe1]
+cvtps2pi %xmm1, %mm4
+
+// CHECK: cvtsi2ssl -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtsi2ssl -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtsi2ssl 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtsi2ssl 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtsi2ssl 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtsi2ssl 485498096(%edx), %xmm1
+
+// CHECK: cvtsi2ssl 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtsi2ssl 485498096, %xmm1
+
+// CHECK: cvtsi2ssl 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x4c,0x02,0x40]
+cvtsi2ssl 64(%edx,%eax), %xmm1
+
+// CHECK: cvtsi2ssl (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x0a]
+cvtsi2ssl (%edx), %xmm1
+
+// CHECK: cvttps2pi -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x2c,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+cvttps2pi -485498096(%edx,%eax,4), %mm4
+
+// CHECK: cvttps2pi 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x2c,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+cvttps2pi 485498096(%edx,%eax,4), %mm4
+
+// CHECK: cvttps2pi 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x2c,0xa2,0xf0,0x1c,0xf0,0x1c]
+cvttps2pi 485498096(%edx), %mm4
+
+// CHECK: cvttps2pi 485498096, %mm4
+// CHECK: encoding: [0x0f,0x2c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttps2pi 485498096, %mm4
+
+// CHECK: cvttps2pi 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x2c,0x64,0x02,0x40]
+cvttps2pi 64(%edx,%eax), %mm4
+
+// CHECK: cvttps2pi (%edx), %mm4
+// CHECK: encoding: [0x0f,0x2c,0x22]
+cvttps2pi (%edx), %mm4
+
+// CHECK: cvttps2pi %xmm1, %mm4
+// CHECK: encoding: [0x0f,0x2c,0xe1]
+cvttps2pi %xmm1, %mm4
+
+// CHECK: divps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+divps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: divps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+divps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: divps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
+divps 485498096(%edx), %xmm1
+
+// CHECK: divps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
+divps 485498096, %xmm1
+
+// CHECK: divps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x5e,0x4c,0x02,0x40]
+divps 64(%edx,%eax), %xmm1
+
+// CHECK: divps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5e,0x0a]
+divps (%edx), %xmm1
+
+// CHECK: divps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x5e,0xc9]
+divps %xmm1, %xmm1
+
+// CHECK: divss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+divss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: divss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+divss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: divss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
+divss 485498096(%edx), %xmm1
+
+// CHECK: divss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
+divss 485498096, %xmm1
+
+// CHECK: divss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x4c,0x02,0x40]
+divss 64(%edx,%eax), %xmm1
+
+// CHECK: divss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x0a]
+divss (%edx), %xmm1
+
+// CHECK: divss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5e,0xc9]
+divss %xmm1, %xmm1
+
+// CHECK: maxps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+maxps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: maxps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+maxps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: maxps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
+maxps 485498096(%edx), %xmm1
+
+// CHECK: maxps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
+maxps 485498096, %xmm1
+
+// CHECK: maxps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x5f,0x4c,0x02,0x40]
+maxps 64(%edx,%eax), %xmm1
+
+// CHECK: maxps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5f,0x0a]
+maxps (%edx), %xmm1
+
+// CHECK: maxps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x5f,0xc9]
+maxps %xmm1, %xmm1
+
+// CHECK: maxss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+maxss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: maxss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+maxss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: maxss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
+maxss 485498096(%edx), %xmm1
+
+// CHECK: maxss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
+maxss 485498096, %xmm1
+
+// CHECK: maxss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x4c,0x02,0x40]
+maxss 64(%edx,%eax), %xmm1
+
+// CHECK: maxss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x0a]
+maxss (%edx), %xmm1
+
+// CHECK: maxss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5f,0xc9]
+maxss %xmm1, %xmm1
+
+// CHECK: minps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+minps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: minps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+minps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: minps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
+minps 485498096(%edx), %xmm1
+
+// CHECK: minps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
+minps 485498096, %xmm1
+
+// CHECK: minps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x5d,0x4c,0x02,0x40]
+minps 64(%edx,%eax), %xmm1
+
+// CHECK: minps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5d,0x0a]
+minps (%edx), %xmm1
+
+// CHECK: minps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x5d,0xc9]
+minps %xmm1, %xmm1
+
+// CHECK: minss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+minss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: minss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+minss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: minss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
+minss 485498096(%edx), %xmm1
+
+// CHECK: minss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
+minss 485498096, %xmm1
+
+// CHECK: minss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x4c,0x02,0x40]
+minss 64(%edx,%eax), %xmm1
+
+// CHECK: minss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x0a]
+minss (%edx), %xmm1
+
+// CHECK: minss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5d,0xc9]
+minss %xmm1, %xmm1
+
+// CHECK: movaps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x28,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movaps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movaps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x28,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movaps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movaps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x28,0x8a,0xf0,0x1c,0xf0,0x1c]
+movaps 485498096(%edx), %xmm1
+
+// CHECK: movaps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x28,0x0d,0xf0,0x1c,0xf0,0x1c]
+movaps 485498096, %xmm1
+
+// CHECK: movaps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x28,0x4c,0x02,0x40]
+movaps 64(%edx,%eax), %xmm1
+
+// CHECK: movaps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x28,0x0a]
+movaps (%edx), %xmm1
+
+// CHECK: movaps %xmm1, 485498096
+// CHECK: encoding: [0x0f,0x29,0x0d,0xf0,0x1c,0xf0,0x1c]
+movaps %xmm1, 485498096
+
+// CHECK: movaps %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x0f,0x29,0x8a,0xf0,0x1c,0xf0,0x1c]
+movaps %xmm1, 485498096(%edx)
+
+// CHECK: movaps %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x29,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movaps %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movaps %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x29,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movaps %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movaps %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x29,0x4c,0x02,0x40]
+movaps %xmm1, 64(%edx,%eax)
+
+// CHECK: movaps %xmm1, (%edx)
+// CHECK: encoding: [0x0f,0x29,0x0a]
+movaps %xmm1, (%edx)
+
+// CHECK: movaps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x28,0xc9]
+movaps %xmm1, %xmm1
+
+// CHECK: movhlps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x12,0xc9]
+movhlps %xmm1, %xmm1
+
+// CHECK: movhps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x16,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movhps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movhps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x16,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movhps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movhps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x16,0x8a,0xf0,0x1c,0xf0,0x1c]
+movhps 485498096(%edx), %xmm1
+
+// CHECK: movhps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x16,0x0d,0xf0,0x1c,0xf0,0x1c]
+movhps 485498096, %xmm1
+
+// CHECK: movhps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x16,0x4c,0x02,0x40]
+movhps 64(%edx,%eax), %xmm1
+
+// CHECK: movhps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x16,0x0a]
+movhps (%edx), %xmm1
+
+// CHECK: movhps %xmm1, 485498096
+// CHECK: encoding: [0x0f,0x17,0x0d,0xf0,0x1c,0xf0,0x1c]
+movhps %xmm1, 485498096
+
+// CHECK: movhps %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x0f,0x17,0x8a,0xf0,0x1c,0xf0,0x1c]
+movhps %xmm1, 485498096(%edx)
+
+// CHECK: movhps %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x17,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movhps %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movhps %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x17,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movhps %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movhps %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x17,0x4c,0x02,0x40]
+movhps %xmm1, 64(%edx,%eax)
+
+// CHECK: movhps %xmm1, (%edx)
+// CHECK: encoding: [0x0f,0x17,0x0a]
+movhps %xmm1, (%edx)
+
+// CHECK: movlhps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x16,0xc9]
+movlhps %xmm1, %xmm1
+
+// CHECK: movlps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x12,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movlps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movlps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x12,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movlps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movlps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x12,0x8a,0xf0,0x1c,0xf0,0x1c]
+movlps 485498096(%edx), %xmm1
+
+// CHECK: movlps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x12,0x0d,0xf0,0x1c,0xf0,0x1c]
+movlps 485498096, %xmm1
+
+// CHECK: movlps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x12,0x4c,0x02,0x40]
+movlps 64(%edx,%eax), %xmm1
+
+// CHECK: movlps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x12,0x0a]
+movlps (%edx), %xmm1
+
+// CHECK: movlps %xmm1, 485498096
+// CHECK: encoding: [0x0f,0x13,0x0d,0xf0,0x1c,0xf0,0x1c]
+movlps %xmm1, 485498096
+
+// CHECK: movlps %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x0f,0x13,0x8a,0xf0,0x1c,0xf0,0x1c]
+movlps %xmm1, 485498096(%edx)
+
+// CHECK: movlps %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x13,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movlps %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movlps %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x13,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movlps %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movlps %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x13,0x4c,0x02,0x40]
+movlps %xmm1, 64(%edx,%eax)
+
+// CHECK: movlps %xmm1, (%edx)
+// CHECK: encoding: [0x0f,0x13,0x0a]
+movlps %xmm1, (%edx)
+
+// CHECK: movntps %xmm1, 485498096
+// CHECK: encoding: [0x0f,0x2b,0x0d,0xf0,0x1c,0xf0,0x1c]
+movntps %xmm1, 485498096
+
+// CHECK: movntps %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x0f,0x2b,0x8a,0xf0,0x1c,0xf0,0x1c]
+movntps %xmm1, 485498096(%edx)
+
+// CHECK: movntps %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x2b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movntps %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movntps %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x2b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movntps %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movntps %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x2b,0x4c,0x02,0x40]
+movntps %xmm1, 64(%edx,%eax)
+
+// CHECK: movntps %xmm1, (%edx)
+// CHECK: encoding: [0x0f,0x2b,0x0a]
+movntps %xmm1, (%edx)
+
+// CHECK: movss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
+movss 485498096(%edx), %xmm1
+
+// CHECK: movss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
+movss 485498096, %xmm1
+
+// CHECK: movss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x10,0x4c,0x02,0x40]
+movss 64(%edx,%eax), %xmm1
+
+// CHECK: movss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x10,0x0a]
+movss (%edx), %xmm1
+
+// CHECK: movss %xmm1, 485498096
+// CHECK: encoding: [0xf3,0x0f,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
+movss %xmm1, 485498096
+
+// CHECK: movss %xmm1, 485498096(%edx)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
+movss %xmm1, 485498096(%edx)
+
+// CHECK: movss %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movss %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movss %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movss %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movss %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x4c,0x02,0x40]
+movss %xmm1, 64(%edx,%eax)
+
+// CHECK: movss %xmm1, (%edx)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x0a]
+movss %xmm1, (%edx)
+
+// CHECK: movss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x10,0xc9]
+movss %xmm1, %xmm1
+
+// CHECK: movups -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movups -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movups 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movups 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movups 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
+movups 485498096(%edx), %xmm1
+
+// CHECK: movups 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
+movups 485498096, %xmm1
+
+// CHECK: movups 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x10,0x4c,0x02,0x40]
+movups 64(%edx,%eax), %xmm1
+
+// CHECK: movups (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x10,0x0a]
+movups (%edx), %xmm1
+
+// CHECK: movups %xmm1, 485498096
+// CHECK: encoding: [0x0f,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
+movups %xmm1, 485498096
+
+// CHECK: movups %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x0f,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
+movups %xmm1, 485498096(%edx)
+
+// CHECK: movups %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movups %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movups %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movups %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movups %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x11,0x4c,0x02,0x40]
+movups %xmm1, 64(%edx,%eax)
+
+// CHECK: movups %xmm1, (%edx)
+// CHECK: encoding: [0x0f,0x11,0x0a]
+movups %xmm1, (%edx)
+
+// CHECK: movups %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x10,0xc9]
+movups %xmm1, %xmm1
+
+// CHECK: mulps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+mulps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mulps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+mulps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mulps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
+mulps 485498096(%edx), %xmm1
+
+// CHECK: mulps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
+mulps 485498096, %xmm1
+
+// CHECK: mulps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x59,0x4c,0x02,0x40]
+mulps 64(%edx,%eax), %xmm1
+
+// CHECK: mulps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x59,0x0a]
+mulps (%edx), %xmm1
+
+// CHECK: mulps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x59,0xc9]
+mulps %xmm1, %xmm1
+
+// CHECK: mulss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+mulss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mulss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+mulss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mulss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
+mulss 485498096(%edx), %xmm1
+
+// CHECK: mulss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
+mulss 485498096, %xmm1
+
+// CHECK: mulss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x59,0x4c,0x02,0x40]
+mulss 64(%edx,%eax), %xmm1
+
+// CHECK: mulss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x59,0x0a]
+mulss (%edx), %xmm1
+
+// CHECK: mulss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x59,0xc9]
+mulss %xmm1, %xmm1
+
+// CHECK: orps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x56,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+orps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: orps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x56,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+orps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: orps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x56,0x8a,0xf0,0x1c,0xf0,0x1c]
+orps 485498096(%edx), %xmm1
+
+// CHECK: orps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x56,0x0d,0xf0,0x1c,0xf0,0x1c]
+orps 485498096, %xmm1
+
+// CHECK: orps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x56,0x4c,0x02,0x40]
+orps 64(%edx,%eax), %xmm1
+
+// CHECK: orps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x56,0x0a]
+orps (%edx), %xmm1
+
+// CHECK: orps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x56,0xc9]
+orps %xmm1, %xmm1
+
+// CHECK: pextrw $0, %mm4, %eax
+// CHECK: encoding: [0x0f,0xc5,0xc4,0x00]
+pextrw $0, %mm4, %eax
+
+// CHECK: pinsrw $0, -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0xc4,0xa4,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pinsrw $0, -485498096(%edx,%eax,4), %mm4
+
+// CHECK: pinsrw $0, 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0xc4,0xa4,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096(%edx,%eax,4), %mm4
+
+// CHECK: pinsrw $0, 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0xc4,0xa2,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096(%edx), %mm4
+
+// CHECK: pinsrw $0, 485498096, %mm4
+// CHECK: encoding: [0x0f,0xc4,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096, %mm4
+
+// CHECK: pinsrw $0, 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0xc4,0x64,0x02,0x40,0x00]
+pinsrw $0, 64(%edx,%eax), %mm4
+
+// CHECK: pinsrw $0, (%edx), %mm4
+// CHECK: encoding: [0x0f,0xc4,0x22,0x00]
+pinsrw $0, (%edx), %mm4
+
+// CHECK: pinsrw $0, %eax, %mm4
+// CHECK: encoding: [0x0f,0xc4,0xe0,0x00]
+pinsrw $0, %eax, %mm4
+
+// CHECK: pmovmskb %mm4, %eax
+// CHECK: encoding: [0x0f,0xd7,0xc4]
+pmovmskb %mm4, %eax
+
+// CHECK: rcpps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x53,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+rcpps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: rcpps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x53,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+rcpps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: rcpps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x53,0x8a,0xf0,0x1c,0xf0,0x1c]
+rcpps 485498096(%edx), %xmm1
+
+// CHECK: rcpps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x53,0x0d,0xf0,0x1c,0xf0,0x1c]
+rcpps 485498096, %xmm1
+
+// CHECK: rcpps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x53,0x4c,0x02,0x40]
+rcpps 64(%edx,%eax), %xmm1
+
+// CHECK: rcpps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x53,0x0a]
+rcpps (%edx), %xmm1
+
+// CHECK: rcpps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x53,0xc9]
+rcpps %xmm1, %xmm1
+
+// CHECK: rcpss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x53,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+rcpss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: rcpss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x53,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+rcpss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: rcpss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x53,0x8a,0xf0,0x1c,0xf0,0x1c]
+rcpss 485498096(%edx), %xmm1
+
+// CHECK: rcpss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x53,0x0d,0xf0,0x1c,0xf0,0x1c]
+rcpss 485498096, %xmm1
+
+// CHECK: rcpss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x53,0x4c,0x02,0x40]
+rcpss 64(%edx,%eax), %xmm1
+
+// CHECK: rcpss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x53,0x0a]
+rcpss (%edx), %xmm1
+
+// CHECK: rcpss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x53,0xc9]
+rcpss %xmm1, %xmm1
+
+// CHECK: rsqrtps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x52,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+rsqrtps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: rsqrtps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x52,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+rsqrtps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: rsqrtps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x52,0x8a,0xf0,0x1c,0xf0,0x1c]
+rsqrtps 485498096(%edx), %xmm1
+
+// CHECK: rsqrtps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x52,0x0d,0xf0,0x1c,0xf0,0x1c]
+rsqrtps 485498096, %xmm1
+
+// CHECK: rsqrtps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x52,0x4c,0x02,0x40]
+rsqrtps 64(%edx,%eax), %xmm1
+
+// CHECK: rsqrtps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x52,0x0a]
+rsqrtps (%edx), %xmm1
+
+// CHECK: rsqrtps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x52,0xc9]
+rsqrtps %xmm1, %xmm1
+
+// CHECK: rsqrtss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x52,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+rsqrtss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: rsqrtss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x52,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+rsqrtss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: rsqrtss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x52,0x8a,0xf0,0x1c,0xf0,0x1c]
+rsqrtss 485498096(%edx), %xmm1
+
+// CHECK: rsqrtss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x52,0x0d,0xf0,0x1c,0xf0,0x1c]
+rsqrtss 485498096, %xmm1
+
+// CHECK: rsqrtss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x52,0x4c,0x02,0x40]
+rsqrtss 64(%edx,%eax), %xmm1
+
+// CHECK: rsqrtss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x52,0x0a]
+rsqrtss (%edx), %xmm1
+
+// CHECK: rsqrtss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x52,0xc9]
+rsqrtss %xmm1, %xmm1
+
+// CHECK: sfence
+// CHECK: encoding: [0x0f,0xae,0xf8]
+sfence
+
+// CHECK: shufps $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0xc6,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+shufps $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: shufps $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0xc6,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+shufps $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: shufps $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0xc6,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+shufps $0, 485498096(%edx), %xmm1
+
+// CHECK: shufps $0, 485498096, %xmm1
+// CHECK: encoding: [0x0f,0xc6,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+shufps $0, 485498096, %xmm1
+
+// CHECK: shufps $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0xc6,0x4c,0x02,0x40,0x00]
+shufps $0, 64(%edx,%eax), %xmm1
+
+// CHECK: shufps $0, (%edx), %xmm1
+// CHECK: encoding: [0x0f,0xc6,0x0a,0x00]
+shufps $0, (%edx), %xmm1
+
+// CHECK: shufps $0, %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0xc6,0xc9,0x00]
+shufps $0, %xmm1, %xmm1
+
+// CHECK: sqrtps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+sqrtps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: sqrtps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+sqrtps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: sqrtps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
+sqrtps 485498096(%edx), %xmm1
+
+// CHECK: sqrtps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
+sqrtps 485498096, %xmm1
+
+// CHECK: sqrtps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x51,0x4c,0x02,0x40]
+sqrtps 64(%edx,%eax), %xmm1
+
+// CHECK: sqrtps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x51,0x0a]
+sqrtps (%edx), %xmm1
+
+// CHECK: sqrtps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x51,0xc9]
+sqrtps %xmm1, %xmm1
+
+// CHECK: sqrtss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+sqrtss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: sqrtss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+sqrtss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: sqrtss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
+sqrtss 485498096(%edx), %xmm1
+
+// CHECK: sqrtss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
+sqrtss 485498096, %xmm1
+
+// CHECK: sqrtss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x51,0x4c,0x02,0x40]
+sqrtss 64(%edx,%eax), %xmm1
+
+// CHECK: sqrtss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x51,0x0a]
+sqrtss (%edx), %xmm1
+
+// CHECK: sqrtss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x51,0xc9]
+sqrtss %xmm1, %xmm1
+
+// CHECK: subps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+subps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: subps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+subps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: subps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
+subps 485498096(%edx), %xmm1
+
+// CHECK: subps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
+subps 485498096, %xmm1
+
+// CHECK: subps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x5c,0x4c,0x02,0x40]
+subps 64(%edx,%eax), %xmm1
+
+// CHECK: subps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5c,0x0a]
+subps (%edx), %xmm1
+
+// CHECK: subps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x5c,0xc9]
+subps %xmm1, %xmm1
+
+// CHECK: subss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+subss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: subss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+subss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: subss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
+subss 485498096(%edx), %xmm1
+
+// CHECK: subss 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
+subss 485498096, %xmm1
+
+// CHECK: subss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x4c,0x02,0x40]
+subss 64(%edx,%eax), %xmm1
+
+// CHECK: subss (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x0a]
+subss (%edx), %xmm1
+
+// CHECK: subss %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5c,0xc9]
+subss %xmm1, %xmm1
+
+// CHECK: ucomiss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x2e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+ucomiss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: ucomiss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x2e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+ucomiss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: ucomiss 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x2e,0x8a,0xf0,0x1c,0xf0,0x1c]
+ucomiss 485498096(%edx), %xmm1
+
+// CHECK: ucomiss 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x2e,0x0d,0xf0,0x1c,0xf0,0x1c]
+ucomiss 485498096, %xmm1
+
+// CHECK: ucomiss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x2e,0x4c,0x02,0x40]
+ucomiss 64(%edx,%eax), %xmm1
+
+// CHECK: ucomiss (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x2e,0x0a]
+ucomiss (%edx), %xmm1
+
+// CHECK: ucomiss %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x2e,0xc9]
+ucomiss %xmm1, %xmm1
+
+// CHECK: unpckhps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x15,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+unpckhps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: unpckhps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x15,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+unpckhps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: unpckhps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x15,0x8a,0xf0,0x1c,0xf0,0x1c]
+unpckhps 485498096(%edx), %xmm1
+
+// CHECK: unpckhps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x15,0x0d,0xf0,0x1c,0xf0,0x1c]
+unpckhps 485498096, %xmm1
+
+// CHECK: unpckhps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x15,0x4c,0x02,0x40]
+unpckhps 64(%edx,%eax), %xmm1
+
+// CHECK: unpckhps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x15,0x0a]
+unpckhps (%edx), %xmm1
+
+// CHECK: unpckhps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x15,0xc9]
+unpckhps %xmm1, %xmm1
+
+// CHECK: unpcklps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x14,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+unpcklps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: unpcklps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x14,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+unpcklps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: unpcklps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x14,0x8a,0xf0,0x1c,0xf0,0x1c]
+unpcklps 485498096(%edx), %xmm1
+
+// CHECK: unpcklps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x14,0x0d,0xf0,0x1c,0xf0,0x1c]
+unpcklps 485498096, %xmm1
+
+// CHECK: unpcklps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x14,0x4c,0x02,0x40]
+unpcklps 64(%edx,%eax), %xmm1
+
+// CHECK: unpcklps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x14,0x0a]
+unpcklps (%edx), %xmm1
+
+// CHECK: unpcklps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x14,0xc9]
+unpcklps %xmm1, %xmm1
+
+// CHECK: xorps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x57,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+xorps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: xorps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x57,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+xorps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: xorps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x57,0x8a,0xf0,0x1c,0xf0,0x1c]
+xorps 485498096(%edx), %xmm1
+
+// CHECK: xorps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x57,0x0d,0xf0,0x1c,0xf0,0x1c]
+xorps 485498096, %xmm1
+
+// CHECK: xorps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x57,0x4c,0x02,0x40]
+xorps 64(%edx,%eax), %xmm1
+
+// CHECK: xorps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x57,0x0a]
+xorps (%edx), %xmm1
+
+// CHECK: xorps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x57,0xc9]
+xorps %xmm1, %xmm1
+

test/MC/X86/SSE-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: addps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x58,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+addps 485498096, %xmm6
+
+// CHECK: addps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x58,0x74,0x82,0xc0]
+addps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: addps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x58,0x74,0x82,0x40]
+addps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: addps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x58,0x74,0x02,0x40]
+addps 64(%rdx,%rax), %xmm6
+
+// CHECK: addps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x58,0x72,0x40]
+addps 64(%rdx), %xmm6
+
+// CHECK: addps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x58,0x32]
+addps (%rdx), %xmm6
+
+// CHECK: addps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x58,0xf6]
+addps %xmm6, %xmm6
+
+// CHECK: addss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x58,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+addss 485498096, %xmm6
+
+// CHECK: addss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x58,0x74,0x82,0xc0]
+addss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: addss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x58,0x74,0x82,0x40]
+addss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: addss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x58,0x74,0x02,0x40]
+addss 64(%rdx,%rax), %xmm6
+
+// CHECK: addss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x58,0x72,0x40]
+addss 64(%rdx), %xmm6
+
+// CHECK: addss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x58,0x32]
+addss (%rdx), %xmm6
+
+// CHECK: addss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x58,0xf6]
+addss %xmm6, %xmm6
+
+// CHECK: andnps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x55,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+andnps 485498096, %xmm6
+
+// CHECK: andnps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x55,0x74,0x82,0xc0]
+andnps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: andnps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x55,0x74,0x82,0x40]
+andnps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: andnps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x55,0x74,0x02,0x40]
+andnps 64(%rdx,%rax), %xmm6
+
+// CHECK: andnps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x55,0x72,0x40]
+andnps 64(%rdx), %xmm6
+
+// CHECK: andnps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x55,0x32]
+andnps (%rdx), %xmm6
+
+// CHECK: andnps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x55,0xf6]
+andnps %xmm6, %xmm6
+
+// CHECK: andps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x54,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+andps 485498096, %xmm6
+
+// CHECK: andps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x54,0x74,0x82,0xc0]
+andps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: andps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x54,0x74,0x82,0x40]
+andps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: andps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x54,0x74,0x02,0x40]
+andps 64(%rdx,%rax), %xmm6
+
+// CHECK: andps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x54,0x72,0x40]
+andps 64(%rdx), %xmm6
+
+// CHECK: andps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x54,0x32]
+andps (%rdx), %xmm6
+
+// CHECK: andps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x54,0xf6]
+andps %xmm6, %xmm6
+
+// CHECK: cmpeqps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0xc2,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqps 485498096, %xmm6
+
+// CHECK: cmpeqps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0xc2,0x74,0x82,0xc0,0x00]
+cmpeqps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cmpeqps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0xc2,0x74,0x82,0x40,0x00]
+cmpeqps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cmpeqps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0xc2,0x74,0x02,0x40,0x00]
+cmpeqps 64(%rdx,%rax), %xmm6
+
+// CHECK: cmpeqps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0xc2,0x72,0x40,0x00]
+cmpeqps 64(%rdx), %xmm6
+
+// CHECK: cmpeqps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0xc2,0x32,0x00]
+cmpeqps (%rdx), %xmm6
+
+// CHECK: cmpeqps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0xc2,0xf6,0x00]
+cmpeqps %xmm6, %xmm6
+
+// CHECK: cmpeqss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqss 485498096, %xmm6
+
+// CHECK: cmpeqss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x74,0x82,0xc0,0x00]
+cmpeqss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cmpeqss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x74,0x82,0x40,0x00]
+cmpeqss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cmpeqss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x74,0x02,0x40,0x00]
+cmpeqss 64(%rdx,%rax), %xmm6
+
+// CHECK: cmpeqss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x72,0x40,0x00]
+cmpeqss 64(%rdx), %xmm6
+
+// CHECK: cmpeqss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xc2,0x32,0x00]
+cmpeqss (%rdx), %xmm6
+
+// CHECK: cmpeqss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xc2,0xf6,0x00]
+cmpeqss %xmm6, %xmm6
+
+// CHECK: comiss 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x2f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+comiss 485498096, %xmm6
+
+// CHECK: comiss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x2f,0x74,0x82,0xc0]
+comiss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: comiss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x2f,0x74,0x82,0x40]
+comiss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: comiss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x2f,0x74,0x02,0x40]
+comiss 64(%rdx,%rax), %xmm6
+
+// CHECK: comiss 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x2f,0x72,0x40]
+comiss 64(%rdx), %xmm6
+
+// CHECK: comiss (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x2f,0x32]
+comiss (%rdx), %xmm6
+
+// CHECK: comiss %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x2f,0xf6]
+comiss %xmm6, %xmm6
+
+// CHECK: cvtpi2ps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x2a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtpi2ps 485498096, %xmm6
+
+// CHECK: cvtpi2ps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x2a,0x74,0x82,0xc0]
+cvtpi2ps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtpi2ps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x2a,0x74,0x82,0x40]
+cvtpi2ps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtpi2ps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x2a,0x74,0x02,0x40]
+cvtpi2ps 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtpi2ps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x2a,0x72,0x40]
+cvtpi2ps 64(%rdx), %xmm6
+
+// CHECK: cvtpi2ps %mm4, %xmm6
+// CHECK: encoding: [0x0f,0x2a,0xf4]
+cvtpi2ps %mm4, %xmm6
+
+// CHECK: cvtpi2ps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x2a,0x32]
+cvtpi2ps (%rdx), %xmm6
+
+// CHECK: cvtps2pi 485498096, %mm4
+// CHECK: encoding: [0x0f,0x2d,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtps2pi 485498096, %mm4
+
+// CHECK: cvtps2pi 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x2d,0x62,0x40]
+cvtps2pi 64(%rdx), %mm4
+
+// CHECK: cvtps2pi -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x2d,0x64,0x82,0xc0]
+cvtps2pi -64(%rdx,%rax,4), %mm4
+
+// CHECK: cvtps2pi 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x2d,0x64,0x82,0x40]
+cvtps2pi 64(%rdx,%rax,4), %mm4
+
+// CHECK: cvtps2pi 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x2d,0x64,0x02,0x40]
+cvtps2pi 64(%rdx,%rax), %mm4
+
+// CHECK: cvtps2pi (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x2d,0x22]
+cvtps2pi (%rdx), %mm4
+
+// CHECK: cvtps2pi %xmm6, %mm4
+// CHECK: encoding: [0x0f,0x2d,0xe6]
+cvtps2pi %xmm6, %mm4
+
+// CHECK: cvtsi2ssl 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtsi2ssl 485498096, %xmm6
+
+// CHECK: cvtsi2ssl -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x74,0x82,0xc0]
+cvtsi2ssl -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsi2ssl 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x74,0x82,0x40]
+cvtsi2ssl 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsi2ssl 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x74,0x02,0x40]
+cvtsi2ssl 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtsi2ssl 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x72,0x40]
+cvtsi2ssl 64(%rdx), %xmm6
+
+// CHECK: cvtsi2ssl %r13d, %xmm6
+// CHECK: encoding: [0xf3,0x41,0x0f,0x2a,0xf5]
+cvtsi2ssl %r13d, %xmm6
+
+// CHECK: cvtsi2ssl (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x2a,0x32]
+cvtsi2ssl (%rdx), %xmm6
+
+// CHECK: cvtsi2ssq 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x48,0x0f,0x2a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtsi2ssq 485498096, %xmm6
+
+// CHECK: cvtsi2ssq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x48,0x0f,0x2a,0x74,0x82,0xc0]
+cvtsi2ssq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsi2ssq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x48,0x0f,0x2a,0x74,0x82,0x40]
+cvtsi2ssq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsi2ssq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x48,0x0f,0x2a,0x74,0x02,0x40]
+cvtsi2ssq 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtsi2ssq 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x48,0x0f,0x2a,0x72,0x40]
+cvtsi2ssq 64(%rdx), %xmm6
+
+// CHECK: cvtsi2ssq %r15, %xmm6
+// CHECK: encoding: [0xf3,0x49,0x0f,0x2a,0xf7]
+cvtsi2ssq %r15, %xmm6
+
+// CHECK: cvtsi2ssq (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x48,0x0f,0x2a,0x32]
+cvtsi2ssq (%rdx), %xmm6
+
+// CHECK: cvtss2si 485498096, %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2d,0x2c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtss2si 485498096, %r13d
+
+// CHECK: cvtss2si 485498096, %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2d,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtss2si 485498096, %r15
+
+// CHECK: cvtss2si 64(%rdx), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2d,0x6a,0x40]
+cvtss2si 64(%rdx), %r13d
+
+// CHECK: cvtss2si 64(%rdx), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2d,0x7a,0x40]
+cvtss2si 64(%rdx), %r15
+
+// CHECK: cvtss2si -64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2d,0x6c,0x82,0xc0]
+cvtss2si -64(%rdx,%rax,4), %r13d
+
+// CHECK: cvtss2si 64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2d,0x6c,0x82,0x40]
+cvtss2si 64(%rdx,%rax,4), %r13d
+
+// CHECK: cvtss2si -64(%rdx,%rax,4), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2d,0x7c,0x82,0xc0]
+cvtss2si -64(%rdx,%rax,4), %r15
+
+// CHECK: cvtss2si 64(%rdx,%rax,4), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2d,0x7c,0x82,0x40]
+cvtss2si 64(%rdx,%rax,4), %r15
+
+// CHECK: cvtss2si 64(%rdx,%rax), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2d,0x6c,0x02,0x40]
+cvtss2si 64(%rdx,%rax), %r13d
+
+// CHECK: cvtss2si 64(%rdx,%rax), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2d,0x7c,0x02,0x40]
+cvtss2si 64(%rdx,%rax), %r15
+
+// CHECK: cvtss2si (%rdx), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2d,0x2a]
+cvtss2si (%rdx), %r13d
+
+// CHECK: cvtss2si (%rdx), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2d,0x3a]
+cvtss2si (%rdx), %r15
+
+// CHECK: cvtss2si %xmm6, %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2d,0xee]
+cvtss2si %xmm6, %r13d
+
+// CHECK: cvtss2si %xmm6, %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2d,0xfe]
+cvtss2si %xmm6, %r15
+
+// CHECK: cvttps2pi 485498096, %mm4
+// CHECK: encoding: [0x0f,0x2c,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttps2pi 485498096, %mm4
+
+// CHECK: cvttps2pi 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x2c,0x62,0x40]
+cvttps2pi 64(%rdx), %mm4
+
+// CHECK: cvttps2pi -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x2c,0x64,0x82,0xc0]
+cvttps2pi -64(%rdx,%rax,4), %mm4
+
+// CHECK: cvttps2pi 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x2c,0x64,0x82,0x40]
+cvttps2pi 64(%rdx,%rax,4), %mm4
+
+// CHECK: cvttps2pi 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x2c,0x64,0x02,0x40]
+cvttps2pi 64(%rdx,%rax), %mm4
+
+// CHECK: cvttps2pi (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x2c,0x22]
+cvttps2pi (%rdx), %mm4
+
+// CHECK: cvttps2pi %xmm6, %mm4
+// CHECK: encoding: [0x0f,0x2c,0xe6]
+cvttps2pi %xmm6, %mm4
+
+// CHECK: cvttss2si 485498096, %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2c,0x2c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttss2si 485498096, %r13d
+
+// CHECK: cvttss2si 485498096, %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2c,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttss2si 485498096, %r15
+
+// CHECK: cvttss2si 64(%rdx), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2c,0x6a,0x40]
+cvttss2si 64(%rdx), %r13d
+
+// CHECK: cvttss2si 64(%rdx), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2c,0x7a,0x40]
+cvttss2si 64(%rdx), %r15
+
+// CHECK: cvttss2si -64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2c,0x6c,0x82,0xc0]
+cvttss2si -64(%rdx,%rax,4), %r13d
+
+// CHECK: cvttss2si 64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2c,0x6c,0x82,0x40]
+cvttss2si 64(%rdx,%rax,4), %r13d
+
+// CHECK: cvttss2si -64(%rdx,%rax,4), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2c,0x7c,0x82,0xc0]
+cvttss2si -64(%rdx,%rax,4), %r15
+
+// CHECK: cvttss2si 64(%rdx,%rax,4), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2c,0x7c,0x82,0x40]
+cvttss2si 64(%rdx,%rax,4), %r15
+
+// CHECK: cvttss2si 64(%rdx,%rax), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2c,0x6c,0x02,0x40]
+cvttss2si 64(%rdx,%rax), %r13d
+
+// CHECK: cvttss2si 64(%rdx,%rax), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2c,0x7c,0x02,0x40]
+cvttss2si 64(%rdx,%rax), %r15
+
+// CHECK: cvttss2si (%rdx), %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2c,0x2a]
+cvttss2si (%rdx), %r13d
+
+// CHECK: cvttss2si (%rdx), %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2c,0x3a]
+cvttss2si (%rdx), %r15
+
+// CHECK: cvttss2si %xmm6, %r13d
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2c,0xee]
+cvttss2si %xmm6, %r13d
+
+// CHECK: cvttss2si %xmm6, %r15
+// CHECK: encoding: [0xf3,0x4c,0x0f,0x2c,0xfe]
+cvttss2si %xmm6, %r15
+
+// CHECK: divps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x5e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+divps 485498096, %xmm6
+
+// CHECK: divps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5e,0x74,0x82,0xc0]
+divps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: divps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5e,0x74,0x82,0x40]
+divps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: divps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x5e,0x74,0x02,0x40]
+divps 64(%rdx,%rax), %xmm6
+
+// CHECK: divps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5e,0x72,0x40]
+divps 64(%rdx), %xmm6
+
+// CHECK: divps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5e,0x32]
+divps (%rdx), %xmm6
+
+// CHECK: divps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x5e,0xf6]
+divps %xmm6, %xmm6
+
+// CHECK: divss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+divss 485498096, %xmm6
+
+// CHECK: divss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x74,0x82,0xc0]
+divss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: divss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x74,0x82,0x40]
+divss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: divss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x74,0x02,0x40]
+divss 64(%rdx,%rax), %xmm6
+
+// CHECK: divss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x72,0x40]
+divss 64(%rdx), %xmm6
+
+// CHECK: divss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5e,0x32]
+divss (%rdx), %xmm6
+
+// CHECK: divss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5e,0xf6]
+divss %xmm6, %xmm6
+
+// CHECK: maxps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x5f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+maxps 485498096, %xmm6
+
+// CHECK: maxps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5f,0x74,0x82,0xc0]
+maxps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: maxps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5f,0x74,0x82,0x40]
+maxps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: maxps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x5f,0x74,0x02,0x40]
+maxps 64(%rdx,%rax), %xmm6
+
+// CHECK: maxps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5f,0x72,0x40]
+maxps 64(%rdx), %xmm6
+
+// CHECK: maxps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5f,0x32]
+maxps (%rdx), %xmm6
+
+// CHECK: maxps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x5f,0xf6]
+maxps %xmm6, %xmm6
+
+// CHECK: maxss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+maxss 485498096, %xmm6
+
+// CHECK: maxss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x74,0x82,0xc0]
+maxss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: maxss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x74,0x82,0x40]
+maxss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: maxss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x74,0x02,0x40]
+maxss 64(%rdx,%rax), %xmm6
+
+// CHECK: maxss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x72,0x40]
+maxss 64(%rdx), %xmm6
+
+// CHECK: maxss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5f,0x32]
+maxss (%rdx), %xmm6
+
+// CHECK: maxss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5f,0xf6]
+maxss %xmm6, %xmm6
+
+// CHECK: minps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x5d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+minps 485498096, %xmm6
+
+// CHECK: minps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5d,0x74,0x82,0xc0]
+minps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: minps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5d,0x74,0x82,0x40]
+minps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: minps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x5d,0x74,0x02,0x40]
+minps 64(%rdx,%rax), %xmm6
+
+// CHECK: minps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5d,0x72,0x40]
+minps 64(%rdx), %xmm6
+
+// CHECK: minps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5d,0x32]
+minps (%rdx), %xmm6
+
+// CHECK: minps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x5d,0xf6]
+minps %xmm6, %xmm6
+
+// CHECK: minss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+minss 485498096, %xmm6
+
+// CHECK: minss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x74,0x82,0xc0]
+minss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: minss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x74,0x82,0x40]
+minss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: minss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x74,0x02,0x40]
+minss 64(%rdx,%rax), %xmm6
+
+// CHECK: minss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x72,0x40]
+minss 64(%rdx), %xmm6
+
+// CHECK: minss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5d,0x32]
+minss (%rdx), %xmm6
+
+// CHECK: minss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5d,0xf6]
+minss %xmm6, %xmm6
+
+// CHECK: movaps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x28,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movaps 485498096, %xmm6
+
+// CHECK: movaps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x28,0x74,0x82,0xc0]
+movaps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movaps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x28,0x74,0x82,0x40]
+movaps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movaps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x28,0x74,0x02,0x40]
+movaps 64(%rdx,%rax), %xmm6
+
+// CHECK: movaps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x28,0x72,0x40]
+movaps 64(%rdx), %xmm6
+
+// CHECK: movaps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x28,0x32]
+movaps (%rdx), %xmm6
+
+// CHECK: movaps %xmm6, 485498096
+// CHECK: encoding: [0x0f,0x29,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movaps %xmm6, 485498096
+
+// CHECK: movaps %xmm6, 64(%rdx)
+// CHECK: encoding: [0x0f,0x29,0x72,0x40]
+movaps %xmm6, 64(%rdx)
+
+// CHECK: movaps %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x29,0x74,0x02,0x40]
+movaps %xmm6, 64(%rdx,%rax)
+
+// CHECK: movaps %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x29,0x74,0x82,0xc0]
+movaps %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movaps %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x29,0x74,0x82,0x40]
+movaps %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movaps %xmm6, (%rdx)
+// CHECK: encoding: [0x0f,0x29,0x32]
+movaps %xmm6, (%rdx)
+
+// CHECK: movaps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x28,0xf6]
+movaps %xmm6, %xmm6
+
+// CHECK: movhlps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x12,0xf6]
+movhlps %xmm6, %xmm6
+
+// CHECK: movhps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x16,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movhps 485498096, %xmm6
+
+// CHECK: movhps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x16,0x74,0x82,0xc0]
+movhps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movhps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x16,0x74,0x82,0x40]
+movhps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movhps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x16,0x74,0x02,0x40]
+movhps 64(%rdx,%rax), %xmm6
+
+// CHECK: movhps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x16,0x72,0x40]
+movhps 64(%rdx), %xmm6
+
+// CHECK: movhps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x16,0x32]
+movhps (%rdx), %xmm6
+
+// CHECK: movhps %xmm6, 485498096
+// CHECK: encoding: [0x0f,0x17,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movhps %xmm6, 485498096
+
+// CHECK: movhps %xmm6, 64(%rdx)
+// CHECK: encoding: [0x0f,0x17,0x72,0x40]
+movhps %xmm6, 64(%rdx)
+
+// CHECK: movhps %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x17,0x74,0x02,0x40]
+movhps %xmm6, 64(%rdx,%rax)
+
+// CHECK: movhps %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x17,0x74,0x82,0xc0]
+movhps %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movhps %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x17,0x74,0x82,0x40]
+movhps %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movhps %xmm6, (%rdx)
+// CHECK: encoding: [0x0f,0x17,0x32]
+movhps %xmm6, (%rdx)
+
+// CHECK: movlhps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x16,0xf6]
+movlhps %xmm6, %xmm6
+
+// CHECK: movlps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x12,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movlps 485498096, %xmm6
+
+// CHECK: movlps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x12,0x74,0x82,0xc0]
+movlps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movlps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x12,0x74,0x82,0x40]
+movlps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movlps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x12,0x74,0x02,0x40]
+movlps 64(%rdx,%rax), %xmm6
+
+// CHECK: movlps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x12,0x72,0x40]
+movlps 64(%rdx), %xmm6
+
+// CHECK: movlps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x12,0x32]
+movlps (%rdx), %xmm6
+
+// CHECK: movlps %xmm6, 485498096
+// CHECK: encoding: [0x0f,0x13,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movlps %xmm6, 485498096
+
+// CHECK: movlps %xmm6, 64(%rdx)
+// CHECK: encoding: [0x0f,0x13,0x72,0x40]
+movlps %xmm6, 64(%rdx)
+
+// CHECK: movlps %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x13,0x74,0x02,0x40]
+movlps %xmm6, 64(%rdx,%rax)
+
+// CHECK: movlps %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x13,0x74,0x82,0xc0]
+movlps %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movlps %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x13,0x74,0x82,0x40]
+movlps %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movlps %xmm6, (%rdx)
+// CHECK: encoding: [0x0f,0x13,0x32]
+movlps %xmm6, (%rdx)
+
+// CHECK: movmskps %xmm6, %r13d
+// CHECK: encoding: [0x44,0x0f,0x50,0xee]
+movmskps %xmm6, %r13d
+
+// CHECK: movntps %xmm6, 485498096
+// CHECK: encoding: [0x0f,0x2b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntps %xmm6, 485498096
+
+// CHECK: movntps %xmm6, 64(%rdx)
+// CHECK: encoding: [0x0f,0x2b,0x72,0x40]
+movntps %xmm6, 64(%rdx)
+
+// CHECK: movntps %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x2b,0x74,0x02,0x40]
+movntps %xmm6, 64(%rdx,%rax)
+
+// CHECK: movntps %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x2b,0x74,0x82,0xc0]
+movntps %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movntps %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x2b,0x74,0x82,0x40]
+movntps %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movntps %xmm6, (%rdx)
+// CHECK: encoding: [0x0f,0x2b,0x32]
+movntps %xmm6, (%rdx)
+
+// CHECK: movss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x10,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movss 485498096, %xmm6
+
+// CHECK: movss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x10,0x74,0x82,0xc0]
+movss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x10,0x74,0x82,0x40]
+movss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x10,0x74,0x02,0x40]
+movss 64(%rdx,%rax), %xmm6
+
+// CHECK: movss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x10,0x72,0x40]
+movss 64(%rdx), %xmm6
+
+// CHECK: movss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x10,0x32]
+movss (%rdx), %xmm6
+
+// CHECK: movss %xmm6, 485498096
+// CHECK: encoding: [0xf3,0x0f,0x11,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movss %xmm6, 485498096
+
+// CHECK: movss %xmm6, 64(%rdx)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x72,0x40]
+movss %xmm6, 64(%rdx)
+
+// CHECK: movss %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x74,0x02,0x40]
+movss %xmm6, 64(%rdx,%rax)
+
+// CHECK: movss %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x74,0x82,0xc0]
+movss %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movss %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x74,0x82,0x40]
+movss %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movss %xmm6, (%rdx)
+// CHECK: encoding: [0xf3,0x0f,0x11,0x32]
+movss %xmm6, (%rdx)
+
+// CHECK: movss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x10,0xf6]
+movss %xmm6, %xmm6
+
+// CHECK: movups 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x10,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movups 485498096, %xmm6
+
+// CHECK: movups -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x10,0x74,0x82,0xc0]
+movups -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movups 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x10,0x74,0x82,0x40]
+movups 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movups 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x10,0x74,0x02,0x40]
+movups 64(%rdx,%rax), %xmm6
+
+// CHECK: movups 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x10,0x72,0x40]
+movups 64(%rdx), %xmm6
+
+// CHECK: movups (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x10,0x32]
+movups (%rdx), %xmm6
+
+// CHECK: movups %xmm6, 485498096
+// CHECK: encoding: [0x0f,0x11,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movups %xmm6, 485498096
+
+// CHECK: movups %xmm6, 64(%rdx)
+// CHECK: encoding: [0x0f,0x11,0x72,0x40]
+movups %xmm6, 64(%rdx)
+
+// CHECK: movups %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x11,0x74,0x02,0x40]
+movups %xmm6, 64(%rdx,%rax)
+
+// CHECK: movups %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x11,0x74,0x82,0xc0]
+movups %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movups %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x11,0x74,0x82,0x40]
+movups %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movups %xmm6, (%rdx)
+// CHECK: encoding: [0x0f,0x11,0x32]
+movups %xmm6, (%rdx)
+
+// CHECK: movups %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x10,0xf6]
+movups %xmm6, %xmm6
+
+// CHECK: mulps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x59,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+mulps 485498096, %xmm6
+
+// CHECK: mulps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x59,0x74,0x82,0xc0]
+mulps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: mulps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x59,0x74,0x82,0x40]
+mulps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: mulps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x59,0x74,0x02,0x40]
+mulps 64(%rdx,%rax), %xmm6
+
+// CHECK: mulps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x59,0x72,0x40]
+mulps 64(%rdx), %xmm6
+
+// CHECK: mulps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x59,0x32]
+mulps (%rdx), %xmm6
+
+// CHECK: mulps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x59,0xf6]
+mulps %xmm6, %xmm6
+
+// CHECK: mulss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x59,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+mulss 485498096, %xmm6
+
+// CHECK: mulss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x59,0x74,0x82,0xc0]
+mulss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: mulss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x59,0x74,0x82,0x40]
+mulss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: mulss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x59,0x74,0x02,0x40]
+mulss 64(%rdx,%rax), %xmm6
+
+// CHECK: mulss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x59,0x72,0x40]
+mulss 64(%rdx), %xmm6
+
+// CHECK: mulss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x59,0x32]
+mulss (%rdx), %xmm6
+
+// CHECK: mulss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x59,0xf6]
+mulss %xmm6, %xmm6
+
+// CHECK: orps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x56,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+orps 485498096, %xmm6
+
+// CHECK: orps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x56,0x74,0x82,0xc0]
+orps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: orps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x56,0x74,0x82,0x40]
+orps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: orps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x56,0x74,0x02,0x40]
+orps 64(%rdx,%rax), %xmm6
+
+// CHECK: orps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x56,0x72,0x40]
+orps 64(%rdx), %xmm6
+
+// CHECK: orps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x56,0x32]
+orps (%rdx), %xmm6
+
+// CHECK: orps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x56,0xf6]
+orps %xmm6, %xmm6
+
+// CHECK: pextrw $0, %mm4, %r13d
+// CHECK: encoding: [0x44,0x0f,0xc5,0xec,0x00]
+pextrw $0, %mm4, %r13d
+
+// CHECK: pinsrw $0, -485498096(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0xc4,0xa4,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pinsrw $0, -485498096(%rdx,%rax,4), %mm4
+
+// CHECK: pinsrw $0, 485498096(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0xc4,0xa4,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096(%rdx,%rax,4), %mm4
+
+// CHECK: pinsrw $0, 485498096(%rdx), %mm4
+// CHECK: encoding: [0x0f,0xc4,0xa2,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096(%rdx), %mm4
+
+// CHECK: pinsrw $0, 485498096, %mm4
+// CHECK: encoding: [0x0f,0xc4,0x24,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096, %mm4
+
+// CHECK: pinsrw $0, 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0xc4,0x64,0x02,0x40,0x00]
+pinsrw $0, 64(%rdx,%rax), %mm4
+
+// CHECK: pinsrw $0, (%rdx), %mm4
+// CHECK: encoding: [0x0f,0xc4,0x22,0x00]
+pinsrw $0, (%rdx), %mm4
+
+// CHECK: pinsrw $0, %r13d, %mm4
+// CHECK: encoding: [0x41,0x0f,0xc4,0xe5,0x00]
+pinsrw $0, %r13d, %mm4
+
+// CHECK: pmovmskb %mm4, %r13d
+// CHECK: encoding: [0x44,0x0f,0xd7,0xec]
+pmovmskb %mm4, %r13d
+
+// CHECK: pmovmskb %mm4, %r13d
+// CHECK: encoding: [0x44,0x0f,0xd7,0xec]
+pmovmskb %mm4, %r13
+
+// CHECK: rcpps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x53,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+rcpps 485498096, %xmm6
+
+// CHECK: rcpps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x53,0x74,0x82,0xc0]
+rcpps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: rcpps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x53,0x74,0x82,0x40]
+rcpps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: rcpps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x53,0x74,0x02,0x40]
+rcpps 64(%rdx,%rax), %xmm6
+
+// CHECK: rcpps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x53,0x72,0x40]
+rcpps 64(%rdx), %xmm6
+
+// CHECK: rcpps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x53,0x32]
+rcpps (%rdx), %xmm6
+
+// CHECK: rcpps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x53,0xf6]
+rcpps %xmm6, %xmm6
+
+// CHECK: rcpss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x53,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+rcpss 485498096, %xmm6
+
+// CHECK: rcpss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x53,0x74,0x82,0xc0]
+rcpss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: rcpss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x53,0x74,0x82,0x40]
+rcpss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: rcpss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x53,0x74,0x02,0x40]
+rcpss 64(%rdx,%rax), %xmm6
+
+// CHECK: rcpss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x53,0x72,0x40]
+rcpss 64(%rdx), %xmm6
+
+// CHECK: rcpss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x53,0x32]
+rcpss (%rdx), %xmm6
+
+// CHECK: rcpss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x53,0xf6]
+rcpss %xmm6, %xmm6
+
+// CHECK: rsqrtps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x52,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+rsqrtps 485498096, %xmm6
+
+// CHECK: rsqrtps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x52,0x74,0x82,0xc0]
+rsqrtps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: rsqrtps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x52,0x74,0x82,0x40]
+rsqrtps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: rsqrtps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x52,0x74,0x02,0x40]
+rsqrtps 64(%rdx,%rax), %xmm6
+
+// CHECK: rsqrtps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x52,0x72,0x40]
+rsqrtps 64(%rdx), %xmm6
+
+// CHECK: rsqrtps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x52,0x32]
+rsqrtps (%rdx), %xmm6
+
+// CHECK: rsqrtps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x52,0xf6]
+rsqrtps %xmm6, %xmm6
+
+// CHECK: rsqrtss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x52,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+rsqrtss 485498096, %xmm6
+
+// CHECK: rsqrtss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x52,0x74,0x82,0xc0]
+rsqrtss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: rsqrtss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x52,0x74,0x82,0x40]
+rsqrtss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: rsqrtss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x52,0x74,0x02,0x40]
+rsqrtss 64(%rdx,%rax), %xmm6
+
+// CHECK: rsqrtss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x52,0x72,0x40]
+rsqrtss 64(%rdx), %xmm6
+
+// CHECK: rsqrtss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x52,0x32]
+rsqrtss (%rdx), %xmm6
+
+// CHECK: rsqrtss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x52,0xf6]
+rsqrtss %xmm6, %xmm6
+
+// CHECK: sfence
+// CHECK: encoding: [0x0f,0xae,0xf8]
+sfence
+
+// CHECK: shufps $0, 485498096, %xmm6
+// CHECK: encoding: [0x0f,0xc6,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+shufps $0, 485498096, %xmm6
+
+// CHECK: shufps $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0xc6,0x74,0x82,0xc0,0x00]
+shufps $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: shufps $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0xc6,0x74,0x82,0x40,0x00]
+shufps $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: shufps $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0xc6,0x74,0x02,0x40,0x00]
+shufps $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: shufps $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0xc6,0x72,0x40,0x00]
+shufps $0, 64(%rdx), %xmm6
+
+// CHECK: shufps $0, (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0xc6,0x32,0x00]
+shufps $0, (%rdx), %xmm6
+
+// CHECK: shufps $0, %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0xc6,0xf6,0x00]
+shufps $0, %xmm6, %xmm6
+
+// CHECK: sqrtps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x51,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+sqrtps 485498096, %xmm6
+
+// CHECK: sqrtps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x51,0x74,0x82,0xc0]
+sqrtps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: sqrtps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x51,0x74,0x82,0x40]
+sqrtps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: sqrtps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x51,0x74,0x02,0x40]
+sqrtps 64(%rdx,%rax), %xmm6
+
+// CHECK: sqrtps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x51,0x72,0x40]
+sqrtps 64(%rdx), %xmm6
+
+// CHECK: sqrtps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x51,0x32]
+sqrtps (%rdx), %xmm6
+
+// CHECK: sqrtps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x51,0xf6]
+sqrtps %xmm6, %xmm6
+
+// CHECK: sqrtss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x51,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+sqrtss 485498096, %xmm6
+
+// CHECK: sqrtss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x51,0x74,0x82,0xc0]
+sqrtss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: sqrtss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x51,0x74,0x82,0x40]
+sqrtss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: sqrtss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x51,0x74,0x02,0x40]
+sqrtss 64(%rdx,%rax), %xmm6
+
+// CHECK: sqrtss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x51,0x72,0x40]
+sqrtss 64(%rdx), %xmm6
+
+// CHECK: sqrtss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x51,0x32]
+sqrtss (%rdx), %xmm6
+
+// CHECK: sqrtss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x51,0xf6]
+sqrtss %xmm6, %xmm6
+
+// CHECK: subps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x5c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+subps 485498096, %xmm6
+
+// CHECK: subps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5c,0x74,0x82,0xc0]
+subps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: subps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5c,0x74,0x82,0x40]
+subps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: subps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x5c,0x74,0x02,0x40]
+subps 64(%rdx,%rax), %xmm6
+
+// CHECK: subps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5c,0x72,0x40]
+subps 64(%rdx), %xmm6
+
+// CHECK: subps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5c,0x32]
+subps (%rdx), %xmm6
+
+// CHECK: subps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x5c,0xf6]
+subps %xmm6, %xmm6
+
+// CHECK: subss 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+subss 485498096, %xmm6
+
+// CHECK: subss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x74,0x82,0xc0]
+subss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: subss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x74,0x82,0x40]
+subss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: subss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x74,0x02,0x40]
+subss 64(%rdx,%rax), %xmm6
+
+// CHECK: subss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x72,0x40]
+subss 64(%rdx), %xmm6
+
+// CHECK: subss (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5c,0x32]
+subss (%rdx), %xmm6
+
+// CHECK: subss %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5c,0xf6]
+subss %xmm6, %xmm6
+
+// CHECK: ucomiss 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x2e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+ucomiss 485498096, %xmm6
+
+// CHECK: ucomiss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x2e,0x74,0x82,0xc0]
+ucomiss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: ucomiss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x2e,0x74,0x82,0x40]
+ucomiss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: ucomiss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x2e,0x74,0x02,0x40]
+ucomiss 64(%rdx,%rax), %xmm6
+
+// CHECK: ucomiss 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x2e,0x72,0x40]
+ucomiss 64(%rdx), %xmm6
+
+// CHECK: ucomiss (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x2e,0x32]
+ucomiss (%rdx), %xmm6
+
+// CHECK: ucomiss %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x2e,0xf6]
+ucomiss %xmm6, %xmm6
+
+// CHECK: unpckhps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x15,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+unpckhps 485498096, %xmm6
+
+// CHECK: unpckhps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x15,0x74,0x82,0xc0]
+unpckhps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: unpckhps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x15,0x74,0x82,0x40]
+unpckhps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: unpckhps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x15,0x74,0x02,0x40]
+unpckhps 64(%rdx,%rax), %xmm6
+
+// CHECK: unpckhps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x15,0x72,0x40]
+unpckhps 64(%rdx), %xmm6
+
+// CHECK: unpckhps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x15,0x32]
+unpckhps (%rdx), %xmm6
+
+// CHECK: unpckhps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x15,0xf6]
+unpckhps %xmm6, %xmm6
+
+// CHECK: unpcklps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x14,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+unpcklps 485498096, %xmm6
+
+// CHECK: unpcklps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x14,0x74,0x82,0xc0]
+unpcklps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: unpcklps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x14,0x74,0x82,0x40]
+unpcklps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: unpcklps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x14,0x74,0x02,0x40]
+unpcklps 64(%rdx,%rax), %xmm6
+
+// CHECK: unpcklps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x14,0x72,0x40]
+unpcklps 64(%rdx), %xmm6
+
+// CHECK: unpcklps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x14,0x32]
+unpcklps (%rdx), %xmm6
+
+// CHECK: unpcklps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x14,0xf6]
+unpcklps %xmm6, %xmm6
+
+// CHECK: xorps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x57,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+xorps 485498096, %xmm6
+
+// CHECK: xorps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x57,0x74,0x82,0xc0]
+xorps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: xorps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x57,0x74,0x82,0x40]
+xorps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: xorps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x57,0x74,0x02,0x40]
+xorps 64(%rdx,%rax), %xmm6
+
+// CHECK: xorps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x57,0x72,0x40]
+xorps 64(%rdx), %xmm6
+
+// CHECK: xorps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x57,0x32]
+xorps (%rdx), %xmm6
+
+// CHECK: xorps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x57,0xf6]
+xorps %xmm6, %xmm6
+

test/MC/X86/SSE2-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: addpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+addpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+addpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
+addpd 485498096(%edx), %xmm1
+
+// CHECK: addpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
+addpd 485498096, %xmm1
+
+// CHECK: addpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x58,0x4c,0x02,0x40]
+addpd 64(%edx,%eax), %xmm1
+
+// CHECK: addpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x58,0x0a]
+addpd (%edx), %xmm1
+
+// CHECK: addpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x58,0xc9]
+addpd %xmm1, %xmm1
+
+// CHECK: addsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+addsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+addsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
+addsd 485498096(%edx), %xmm1
+
+// CHECK: addsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
+addsd 485498096, %xmm1
+
+// CHECK: addsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x58,0x4c,0x02,0x40]
+addsd 64(%edx,%eax), %xmm1
+
+// CHECK: addsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x58,0x0a]
+addsd (%edx), %xmm1
+
+// CHECK: addsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x58,0xc9]
+addsd %xmm1, %xmm1
+
+// CHECK: andnpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x55,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+andnpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: andnpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x55,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+andnpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: andnpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x55,0x8a,0xf0,0x1c,0xf0,0x1c]
+andnpd 485498096(%edx), %xmm1
+
+// CHECK: andnpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x55,0x0d,0xf0,0x1c,0xf0,0x1c]
+andnpd 485498096, %xmm1
+
+// CHECK: andnpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x55,0x4c,0x02,0x40]
+andnpd 64(%edx,%eax), %xmm1
+
+// CHECK: andnpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x55,0x0a]
+andnpd (%edx), %xmm1
+
+// CHECK: andnpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x55,0xc9]
+andnpd %xmm1, %xmm1
+
+// CHECK: andpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x54,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+andpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: andpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x54,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+andpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: andpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x54,0x8a,0xf0,0x1c,0xf0,0x1c]
+andpd 485498096(%edx), %xmm1
+
+// CHECK: andpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x54,0x0d,0xf0,0x1c,0xf0,0x1c]
+andpd 485498096, %xmm1
+
+// CHECK: andpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x54,0x4c,0x02,0x40]
+andpd 64(%edx,%eax), %xmm1
+
+// CHECK: andpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x54,0x0a]
+andpd (%edx), %xmm1
+
+// CHECK: andpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x54,0xc9]
+andpd %xmm1, %xmm1
+
+// CHECK: cmpeqpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc2,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+cmpeqpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cmpeqpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc2,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cmpeqpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc2,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqpd 485498096(%edx), %xmm1
+
+// CHECK: cmpeqpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc2,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqpd 485498096, %xmm1
+
+// CHECK: cmpeqpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc2,0x4c,0x02,0x40,0x00]
+cmpeqpd 64(%edx,%eax), %xmm1
+
+// CHECK: cmpeqpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc2,0x0a,0x00]
+cmpeqpd (%edx), %xmm1
+
+// CHECK: cmpeqpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc2,0xc9,0x00]
+cmpeqpd %xmm1, %xmm1
+
+// CHECK: cmpeqsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+cmpeqsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cmpeqsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cmpeqsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqsd 485498096(%edx), %xmm1
+
+// CHECK: cmpeqsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqsd 485498096, %xmm1
+
+// CHECK: cmpeqsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x4c,0x02,0x40,0x00]
+cmpeqsd 64(%edx,%eax), %xmm1
+
+// CHECK: cmpeqsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x0a,0x00]
+cmpeqsd (%edx), %xmm1
+
+// CHECK: cmpeqsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xc2,0xc9,0x00]
+cmpeqsd %xmm1, %xmm1
+
+// CHECK: comisd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+comisd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: comisd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+comisd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: comisd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2f,0x8a,0xf0,0x1c,0xf0,0x1c]
+comisd 485498096(%edx), %xmm1
+
+// CHECK: comisd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2f,0x0d,0xf0,0x1c,0xf0,0x1c]
+comisd 485498096, %xmm1
+
+
+// CHECK: comisd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2f,0x4c,0x02,0x40]
+comisd 64(%edx,%eax), %xmm1
+
+// CHECK: comisd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2f,0x0a]
+comisd (%edx), %xmm1
+
+// CHECK: comisd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2f,0xc9]
+comisd %xmm1, %xmm1
+
+// CHECK: cvtdq2pd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtdq2pd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtdq2pd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtdq2pd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtdq2pd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtdq2pd 485498096(%edx), %xmm1
+
+// CHECK: cvtdq2pd 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtdq2pd 485498096, %xmm1
+
+// CHECK: cvtdq2pd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x4c,0x02,0x40]
+cvtdq2pd 64(%edx,%eax), %xmm1
+
+// CHECK: cvtdq2pd (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x0a]
+cvtdq2pd (%edx), %xmm1
+
+// CHECK: cvtdq2pd %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xe6,0xc9]
+cvtdq2pd %xmm1, %xmm1
+
+// CHECK: cvtdq2ps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtdq2ps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtdq2ps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtdq2ps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtdq2ps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5b,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtdq2ps 485498096(%edx), %xmm1
+
+// CHECK: cvtdq2ps 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x5b,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtdq2ps 485498096, %xmm1
+
+// CHECK: cvtdq2ps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x5b,0x4c,0x02,0x40]
+cvtdq2ps 64(%edx,%eax), %xmm1
+
+// CHECK: cvtdq2ps (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5b,0x0a]
+cvtdq2ps (%edx), %xmm1
+
+// CHECK: cvtdq2ps %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x5b,0xc9]
+cvtdq2ps %xmm1, %xmm1
+
+// CHECK: cvtpd2dq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtpd2dq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtpd2dq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtpd2dq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtpd2dq 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtpd2dq 485498096(%edx), %xmm1
+
+// CHECK: cvtpd2dq 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtpd2dq 485498096, %xmm1
+
+// CHECK: cvtpd2dq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x4c,0x02,0x40]
+cvtpd2dq 64(%edx,%eax), %xmm1
+
+// CHECK: cvtpd2dq (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x0a]
+cvtpd2dq (%edx), %xmm1
+
+// CHECK: cvtpd2dq %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xe6,0xc9]
+cvtpd2dq %xmm1, %xmm1
+
+// CHECK: cvtpd2pi -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+cvtpd2pi -485498096(%edx,%eax,4), %mm4
+
+// CHECK: cvtpd2pi 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtpd2pi 485498096(%edx,%eax,4), %mm4
+
+// CHECK: cvtpd2pi 485498096(%edx), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0xa2,0xf0,0x1c,0xf0,0x1c]
+cvtpd2pi 485498096(%edx), %mm4
+
+// CHECK: cvtpd2pi 485498096, %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtpd2pi 485498096, %mm4
+
+// CHECK: cvtpd2pi 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x64,0x02,0x40]
+cvtpd2pi 64(%edx,%eax), %mm4
+
+// CHECK: cvtpd2pi (%edx), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x22]
+cvtpd2pi (%edx), %mm4
+
+// CHECK: cvtpd2pi %xmm1, %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0xe1]
+cvtpd2pi %xmm1, %mm4
+
+// CHECK: cvtpd2ps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtpd2ps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtpd2ps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtpd2ps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtpd2ps 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtpd2ps 485498096(%edx), %xmm1
+
+// CHECK: cvtpd2ps 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtpd2ps 485498096, %xmm1
+
+// CHECK: cvtpd2ps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5a,0x4c,0x02,0x40]
+cvtpd2ps 64(%edx,%eax), %xmm1
+
+// CHECK: cvtpd2ps (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5a,0x0a]
+cvtpd2ps (%edx), %xmm1
+
+// CHECK: cvtpd2ps %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5a,0xc9]
+cvtpd2ps %xmm1, %xmm1
+
+// CHECK: cvtpi2pd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtpi2pd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtpi2pd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtpi2pd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtpi2pd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtpi2pd 485498096(%edx), %xmm1
+
+// CHECK: cvtpi2pd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtpi2pd 485498096, %xmm1
+
+// CHECK: cvtpi2pd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2a,0x4c,0x02,0x40]
+cvtpi2pd 64(%edx,%eax), %xmm1
+
+// CHECK: cvtpi2pd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2a,0x0a]
+cvtpi2pd (%edx), %xmm1
+
+// CHECK: cvtpi2pd %mm4, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2a,0xcc]
+cvtpi2pd %mm4, %xmm1
+
+// CHECK: cvtps2dq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtps2dq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtps2dq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtps2dq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtps2dq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5b,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtps2dq 485498096(%edx), %xmm1
+
+// CHECK: cvtps2dq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5b,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtps2dq 485498096, %xmm1
+
+// CHECK: cvtps2dq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5b,0x4c,0x02,0x40]
+cvtps2dq 64(%edx,%eax), %xmm1
+
+// CHECK: cvtps2dq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5b,0x0a]
+cvtps2dq (%edx), %xmm1
+
+// CHECK: cvtps2dq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5b,0xc9]
+cvtps2dq %xmm1, %xmm1
+
+// CHECK: cvtps2pd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtps2pd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtps2pd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x0f,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtps2pd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtps2pd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtps2pd 485498096(%edx), %xmm1
+
+// CHECK: cvtps2pd 485498096, %xmm1
+// CHECK: encoding: [0x0f,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtps2pd 485498096, %xmm1
+
+// CHECK: cvtps2pd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x0f,0x5a,0x4c,0x02,0x40]
+cvtps2pd 64(%edx,%eax), %xmm1
+
+// CHECK: cvtps2pd (%edx), %xmm1
+// CHECK: encoding: [0x0f,0x5a,0x0a]
+cvtps2pd (%edx), %xmm1
+
+// CHECK: cvtps2pd %xmm1, %xmm1
+// CHECK: encoding: [0x0f,0x5a,0xc9]
+cvtps2pd %xmm1, %xmm1
+
+// CHECK: cvtsd2ss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtsd2ss -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtsd2ss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtsd2ss 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtsd2ss 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtsd2ss 485498096(%edx), %xmm1
+
+// CHECK: cvtsd2ss 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtsd2ss 485498096, %xmm1
+
+// CHECK: cvtsd2ss 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x4c,0x02,0x40]
+cvtsd2ss 64(%edx,%eax), %xmm1
+
+// CHECK: cvtsd2ss (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x0a]
+cvtsd2ss (%edx), %xmm1
+
+// CHECK: cvtsd2ss %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5a,0xc9]
+cvtsd2ss %xmm1, %xmm1
+
+// CHECK: cvtsi2sdl -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtsi2sdl -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtsi2sdl 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtsi2sdl 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtsi2sdl 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtsi2sdl 485498096(%edx), %xmm1
+
+// CHECK: cvtsi2sdl 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtsi2sdl 485498096, %xmm1
+
+// CHECK: cvtsi2sdl 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x4c,0x02,0x40]
+cvtsi2sdl 64(%edx,%eax), %xmm1
+
+// CHECK: cvtsi2sdl (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x0a]
+cvtsi2sdl (%edx), %xmm1
+
+// CHECK: cvtss2sd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvtss2sd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtss2sd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvtss2sd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvtss2sd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvtss2sd 485498096(%edx), %xmm1
+
+// CHECK: cvtss2sd 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvtss2sd 485498096, %xmm1
+
+// CHECK: cvtss2sd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x4c,0x02,0x40]
+cvtss2sd 64(%edx,%eax), %xmm1
+
+// CHECK: cvtss2sd (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x0a]
+cvtss2sd (%edx), %xmm1
+
+// CHECK: cvtss2sd %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5a,0xc9]
+cvtss2sd %xmm1, %xmm1
+
+// CHECK: cvttpd2dq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe6,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvttpd2dq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvttpd2dq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe6,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvttpd2dq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvttpd2dq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe6,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvttpd2dq 485498096(%edx), %xmm1
+
+// CHECK: cvttpd2dq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe6,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvttpd2dq 485498096, %xmm1
+
+// CHECK: cvttpd2dq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe6,0x4c,0x02,0x40]
+cvttpd2dq 64(%edx,%eax), %xmm1
+
+// CHECK: cvttpd2dq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe6,0x0a]
+cvttpd2dq (%edx), %xmm1
+
+// CHECK: cvttpd2dq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe6,0xc9]
+cvttpd2dq %xmm1, %xmm1
+
+// CHECK: cvttpd2pi -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+cvttpd2pi -485498096(%edx,%eax,4), %mm4
+
+// CHECK: cvttpd2pi 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+cvttpd2pi 485498096(%edx,%eax,4), %mm4
+
+// CHECK: cvttpd2pi 485498096(%edx), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0xa2,0xf0,0x1c,0xf0,0x1c]
+cvttpd2pi 485498096(%edx), %mm4
+
+// CHECK: cvttpd2pi 485498096, %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttpd2pi 485498096, %mm4
+
+// CHECK: cvttpd2pi 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x64,0x02,0x40]
+cvttpd2pi 64(%edx,%eax), %mm4
+
+// CHECK: cvttpd2pi (%edx), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x22]
+cvttpd2pi (%edx), %mm4
+
+// CHECK: cvttpd2pi %xmm1, %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0xe1]
+cvttpd2pi %xmm1, %mm4
+
+// CHECK: cvttps2dq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+cvttps2dq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvttps2dq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+cvttps2dq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: cvttps2dq 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x8a,0xf0,0x1c,0xf0,0x1c]
+cvttps2dq 485498096(%edx), %xmm1
+
+// CHECK: cvttps2dq 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x0d,0xf0,0x1c,0xf0,0x1c]
+cvttps2dq 485498096, %xmm1
+
+// CHECK: cvttps2dq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x4c,0x02,0x40]
+cvttps2dq 64(%edx,%eax), %xmm1
+
+// CHECK: cvttps2dq (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x0a]
+cvttps2dq (%edx), %xmm1
+
+// CHECK: cvttps2dq %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x5b,0xc9]
+cvttps2dq %xmm1, %xmm1
+
+// CHECK: divpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+divpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: divpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+divpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: divpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
+divpd 485498096(%edx), %xmm1
+
+// CHECK: divpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
+divpd 485498096, %xmm1
+
+// CHECK: divpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5e,0x4c,0x02,0x40]
+divpd 64(%edx,%eax), %xmm1
+
+// CHECK: divpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5e,0x0a]
+divpd (%edx), %xmm1
+
+// CHECK: divpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5e,0xc9]
+divpd %xmm1, %xmm1
+
+// CHECK: divsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+divsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: divsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+divsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: divsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
+divsd 485498096(%edx), %xmm1
+
+// CHECK: divsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
+divsd 485498096, %xmm1
+
+// CHECK: divsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x4c,0x02,0x40]
+divsd 64(%edx,%eax), %xmm1
+
+// CHECK: divsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x0a]
+divsd (%edx), %xmm1
+
+// CHECK: divsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5e,0xc9]
+divsd %xmm1, %xmm1
+
+// CHECK: lfence
+// CHECK: encoding: [0x0f,0xae,0xe8]
+lfence
+
+// CHECK: maskmovdqu %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf7,0xc9]
+maskmovdqu %xmm1, %xmm1
+
+// CHECK: maxpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+maxpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: maxpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+maxpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: maxpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
+maxpd 485498096(%edx), %xmm1
+
+// CHECK: maxpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
+maxpd 485498096, %xmm1
+
+// CHECK: maxpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5f,0x4c,0x02,0x40]
+maxpd 64(%edx,%eax), %xmm1
+
+// CHECK: maxpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5f,0x0a]
+maxpd (%edx), %xmm1
+
+// CHECK: maxpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5f,0xc9]
+maxpd %xmm1, %xmm1
+
+// CHECK: maxsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+maxsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: maxsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+maxsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: maxsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
+maxsd 485498096(%edx), %xmm1
+
+// CHECK: maxsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
+maxsd 485498096, %xmm1
+
+// CHECK: maxsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x4c,0x02,0x40]
+maxsd 64(%edx,%eax), %xmm1
+
+// CHECK: maxsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x0a]
+maxsd (%edx), %xmm1
+
+// CHECK: maxsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5f,0xc9]
+maxsd %xmm1, %xmm1
+
+// CHECK: mfence
+// CHECK: encoding: [0x0f,0xae,0xf0]
+mfence
+
+// CHECK: minpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+minpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: minpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+minpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: minpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
+minpd 485498096(%edx), %xmm1
+
+// CHECK: minpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
+minpd 485498096, %xmm1
+
+// CHECK: minpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5d,0x4c,0x02,0x40]
+minpd 64(%edx,%eax), %xmm1
+
+// CHECK: minpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5d,0x0a]
+minpd (%edx), %xmm1
+
+// CHECK: minpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5d,0xc9]
+minpd %xmm1, %xmm1
+
+// CHECK: minsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+minsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: minsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+minsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: minsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
+minsd 485498096(%edx), %xmm1
+
+// CHECK: minsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
+minsd 485498096, %xmm1
+
+// CHECK: minsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x4c,0x02,0x40]
+minsd 64(%edx,%eax), %xmm1
+
+// CHECK: minsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x0a]
+minsd (%edx), %xmm1
+
+// CHECK: minsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5d,0xc9]
+minsd %xmm1, %xmm1
+
+// CHECK: movapd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x28,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movapd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movapd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x28,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movapd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movapd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x28,0x8a,0xf0,0x1c,0xf0,0x1c]
+movapd 485498096(%edx), %xmm1
+
+// CHECK: movapd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x28,0x0d,0xf0,0x1c,0xf0,0x1c]
+movapd 485498096, %xmm1
+
+// CHECK: movapd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x28,0x4c,0x02,0x40]
+movapd 64(%edx,%eax), %xmm1
+
+// CHECK: movapd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x28,0x0a]
+movapd (%edx), %xmm1
+
+// CHECK: movapd %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x29,0x0d,0xf0,0x1c,0xf0,0x1c]
+movapd %xmm1, 485498096
+
+// CHECK: movapd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x29,0x8a,0xf0,0x1c,0xf0,0x1c]
+movapd %xmm1, 485498096(%edx)
+
+// CHECK: movapd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x29,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movapd %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movapd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x29,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movapd %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movapd %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x29,0x4c,0x02,0x40]
+movapd %xmm1, 64(%edx,%eax)
+
+// CHECK: movapd %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x29,0x0a]
+movapd %xmm1, (%edx)
+
+// CHECK: movapd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x28,0xc9]
+movapd %xmm1, %xmm1
+
+// CHECK: movd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6e,0x8a,0xf0,0x1c,0xf0,0x1c]
+movd 485498096(%edx), %xmm1
+
+// CHECK: movd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6e,0x0d,0xf0,0x1c,0xf0,0x1c]
+movd 485498096, %xmm1
+
+// CHECK: movd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6e,0x4c,0x02,0x40]
+movd 64(%edx,%eax), %xmm1
+
+// CHECK: movd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6e,0x0a]
+movd (%edx), %xmm1
+
+// CHECK: movdq2q %xmm1, %mm4
+// CHECK: encoding: [0xf2,0x0f,0xd6,0xe1]
+movdq2q %xmm1, %mm4
+
+// CHECK: movdqa -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movdqa -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movdqa 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movdqa 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movdqa 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6f,0x8a,0xf0,0x1c,0xf0,0x1c]
+movdqa 485498096(%edx), %xmm1
+
+// CHECK: movdqa 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6f,0x0d,0xf0,0x1c,0xf0,0x1c]
+movdqa 485498096, %xmm1
+
+// CHECK: movdqa 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6f,0x4c,0x02,0x40]
+movdqa 64(%edx,%eax), %xmm1
+
+// CHECK: movdqa (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6f,0x0a]
+movdqa (%edx), %xmm1
+
+// CHECK: movdqa %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x7f,0x0d,0xf0,0x1c,0xf0,0x1c]
+movdqa %xmm1, 485498096
+
+// CHECK: movdqa %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x8a,0xf0,0x1c,0xf0,0x1c]
+movdqa %xmm1, 485498096(%edx)
+
+// CHECK: movdqa %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movdqa %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movdqa %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movdqa %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movdqa %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x4c,0x02,0x40]
+movdqa %xmm1, 64(%edx,%eax)
+
+// CHECK: movdqa %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x0a]
+movdqa %xmm1, (%edx)
+
+// CHECK: movdqa %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6f,0xc9]
+movdqa %xmm1, %xmm1
+
+// CHECK: movdqu -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movdqu -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movdqu 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movdqu 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movdqu 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x8a,0xf0,0x1c,0xf0,0x1c]
+movdqu 485498096(%edx), %xmm1
+
+// CHECK: movdqu 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x0d,0xf0,0x1c,0xf0,0x1c]
+movdqu 485498096, %xmm1
+
+// CHECK: movdqu 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x4c,0x02,0x40]
+movdqu 64(%edx,%eax), %xmm1
+
+// CHECK: movdqu (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x0a]
+movdqu (%edx), %xmm1
+
+// CHECK: movdqu %xmm1, 485498096
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x0d,0xf0,0x1c,0xf0,0x1c]
+movdqu %xmm1, 485498096
+
+// CHECK: movdqu %xmm1, 485498096(%edx)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x8a,0xf0,0x1c,0xf0,0x1c]
+movdqu %xmm1, 485498096(%edx)
+
+// CHECK: movdqu %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movdqu %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movdqu %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movdqu %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movdqu %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x4c,0x02,0x40]
+movdqu %xmm1, 64(%edx,%eax)
+
+// CHECK: movdqu %xmm1, (%edx)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x0a]
+movdqu %xmm1, (%edx)
+
+// CHECK: movdqu %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x6f,0xc9]
+movdqu %xmm1, %xmm1
+
+// CHECK: movd %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x7e,0x0d,0xf0,0x1c,0xf0,0x1c]
+movd %xmm1, 485498096
+
+// CHECK: movd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x8a,0xf0,0x1c,0xf0,0x1c]
+movd %xmm1, 485498096(%edx)
+
+// CHECK: movd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movd %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movd %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movd %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x4c,0x02,0x40]
+movd %xmm1, 64(%edx,%eax)
+
+// CHECK: movd %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x0a]
+movd %xmm1, (%edx)
+
+// CHECK: movhpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x16,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movhpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movhpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x16,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movhpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movhpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x16,0x8a,0xf0,0x1c,0xf0,0x1c]
+movhpd 485498096(%edx), %xmm1
+
+// CHECK: movhpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x16,0x0d,0xf0,0x1c,0xf0,0x1c]
+movhpd 485498096, %xmm1
+
+// CHECK: movhpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x16,0x4c,0x02,0x40]
+movhpd 64(%edx,%eax), %xmm1
+
+// CHECK: movhpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x16,0x0a]
+movhpd (%edx), %xmm1
+
+// CHECK: movhpd %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x17,0x0d,0xf0,0x1c,0xf0,0x1c]
+movhpd %xmm1, 485498096
+
+// CHECK: movhpd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x17,0x8a,0xf0,0x1c,0xf0,0x1c]
+movhpd %xmm1, 485498096(%edx)
+
+// CHECK: movhpd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x17,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movhpd %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movhpd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x17,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movhpd %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movhpd %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x17,0x4c,0x02,0x40]
+movhpd %xmm1, 64(%edx,%eax)
+
+// CHECK: movhpd %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x17,0x0a]
+movhpd %xmm1, (%edx)
+
+// CHECK: movlpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x12,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movlpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movlpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x12,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movlpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movlpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x12,0x8a,0xf0,0x1c,0xf0,0x1c]
+movlpd 485498096(%edx), %xmm1
+
+// CHECK: movlpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x12,0x0d,0xf0,0x1c,0xf0,0x1c]
+movlpd 485498096, %xmm1
+
+// CHECK: movlpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x12,0x4c,0x02,0x40]
+movlpd 64(%edx,%eax), %xmm1
+
+// CHECK: movlpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x12,0x0a]
+movlpd (%edx), %xmm1
+
+// CHECK: movlpd %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x13,0x0d,0xf0,0x1c,0xf0,0x1c]
+movlpd %xmm1, 485498096
+
+// CHECK: movlpd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x13,0x8a,0xf0,0x1c,0xf0,0x1c]
+movlpd %xmm1, 485498096(%edx)
+
+// CHECK: movlpd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x13,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movlpd %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movlpd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x13,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movlpd %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movlpd %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x13,0x4c,0x02,0x40]
+movlpd %xmm1, 64(%edx,%eax)
+
+// CHECK: movlpd %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x13,0x0a]
+movlpd %xmm1, (%edx)
+
+// CHECK: movntdq %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0xe7,0x0d,0xf0,0x1c,0xf0,0x1c]
+movntdq %xmm1, 485498096
+
+// CHECK: movntdq %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x8a,0xf0,0x1c,0xf0,0x1c]
+movntdq %xmm1, 485498096(%edx)
+
+// CHECK: movntdq %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movntdq %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movntdq %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movntdq %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movntdq %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x4c,0x02,0x40]
+movntdq %xmm1, 64(%edx,%eax)
+
+// CHECK: movntdq %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x0a]
+movntdq %xmm1, (%edx)
+
+// CHECK: movntpd %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x2b,0x0d,0xf0,0x1c,0xf0,0x1c]
+movntpd %xmm1, 485498096
+
+// CHECK: movntpd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x8a,0xf0,0x1c,0xf0,0x1c]
+movntpd %xmm1, 485498096(%edx)
+
+// CHECK: movntpd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movntpd %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movntpd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movntpd %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movntpd %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x4c,0x02,0x40]
+movntpd %xmm1, 64(%edx,%eax)
+
+// CHECK: movntpd %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x0a]
+movntpd %xmm1, (%edx)
+
+// CHECK: movq2dq %mm4, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0xd6,0xcc]
+movq2dq %mm4, %xmm1
+
+// CHECK: movq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movq 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x8a,0xf0,0x1c,0xf0,0x1c]
+movq 485498096(%edx), %xmm1
+
+// CHECK: movq 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x0d,0xf0,0x1c,0xf0,0x1c]
+movq 485498096, %xmm1
+
+// CHECK: movq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x4c,0x02,0x40]
+movq 64(%edx,%eax), %xmm1
+
+// CHECK: movq (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x0a]
+movq (%edx), %xmm1
+
+// CHECK: movq %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0xd6,0x0d,0xf0,0x1c,0xf0,0x1c]
+movq %xmm1, 485498096
+
+// CHECK: movq %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x8a,0xf0,0x1c,0xf0,0x1c]
+movq %xmm1, 485498096(%edx)
+
+// CHECK: movq %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movq %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movq %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movq %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movq %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x4c,0x02,0x40]
+movq %xmm1, 64(%edx,%eax)
+
+// CHECK: movq %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x0a]
+movq %xmm1, (%edx)
+
+// CHECK: movq %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x7e,0xc9]
+movq %xmm1, %xmm1
+
+// CHECK: movsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
+movsd 485498096(%edx), %xmm1
+
+// CHECK: movsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
+movsd 485498096, %xmm1
+
+// CHECK: movsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x10,0x4c,0x02,0x40]
+movsd 64(%edx,%eax), %xmm1
+
+// CHECK: movsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x10,0x0a]
+movsd (%edx), %xmm1
+
+// CHECK: movsd %xmm1, 485498096
+// CHECK: encoding: [0xf2,0x0f,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
+movsd %xmm1, 485498096
+
+// CHECK: movsd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
+movsd %xmm1, 485498096(%edx)
+
+// CHECK: movsd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movsd %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movsd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movsd %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movsd %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x4c,0x02,0x40]
+movsd %xmm1, 64(%edx,%eax)
+
+// CHECK: movsd %xmm1, (%edx)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x0a]
+movsd %xmm1, (%edx)
+
+// CHECK: movsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x10,0xc9]
+movsd %xmm1, %xmm1
+
+// CHECK: movupd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movupd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movupd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movupd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movupd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
+movupd 485498096(%edx), %xmm1
+
+// CHECK: movupd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
+movupd 485498096, %xmm1
+
+// CHECK: movupd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x10,0x4c,0x02,0x40]
+movupd 64(%edx,%eax), %xmm1
+
+// CHECK: movupd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x10,0x0a]
+movupd (%edx), %xmm1
+
+// CHECK: movupd %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
+movupd %xmm1, 485498096
+
+// CHECK: movupd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
+movupd %xmm1, 485498096(%edx)
+
+// CHECK: movupd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movupd %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movupd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movupd %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movupd %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x11,0x4c,0x02,0x40]
+movupd %xmm1, 64(%edx,%eax)
+
+// CHECK: movupd %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x11,0x0a]
+movupd %xmm1, (%edx)
+
+// CHECK: movupd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x10,0xc9]
+movupd %xmm1, %xmm1
+
+// CHECK: mulpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+mulpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mulpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+mulpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mulpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
+mulpd 485498096(%edx), %xmm1
+
+// CHECK: mulpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
+mulpd 485498096, %xmm1
+
+// CHECK: mulpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x59,0x4c,0x02,0x40]
+mulpd 64(%edx,%eax), %xmm1
+
+// CHECK: mulpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x59,0x0a]
+mulpd (%edx), %xmm1
+
+// CHECK: mulpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x59,0xc9]
+mulpd %xmm1, %xmm1
+
+// CHECK: mulsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+mulsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mulsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+mulsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mulsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
+mulsd 485498096(%edx), %xmm1
+
+// CHECK: mulsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
+mulsd 485498096, %xmm1
+
+// CHECK: mulsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x59,0x4c,0x02,0x40]
+mulsd 64(%edx,%eax), %xmm1
+
+// CHECK: mulsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x59,0x0a]
+mulsd (%edx), %xmm1
+
+// CHECK: mulsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x59,0xc9]
+mulsd %xmm1, %xmm1
+
+// CHECK: orpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x56,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+orpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: orpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x56,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+orpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: orpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x56,0x8a,0xf0,0x1c,0xf0,0x1c]
+orpd 485498096(%edx), %xmm1
+
+// CHECK: orpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x56,0x0d,0xf0,0x1c,0xf0,0x1c]
+orpd 485498096, %xmm1
+
+// CHECK: orpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x56,0x4c,0x02,0x40]
+orpd 64(%edx,%eax), %xmm1
+
+// CHECK: orpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x56,0x0a]
+orpd (%edx), %xmm1
+
+// CHECK: orpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x56,0xc9]
+orpd %xmm1, %xmm1
+
+// CHECK: packssdw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+packssdw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: packssdw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+packssdw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: packssdw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6b,0x8a,0xf0,0x1c,0xf0,0x1c]
+packssdw 485498096(%edx), %xmm1
+
+// CHECK: packssdw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6b,0x0d,0xf0,0x1c,0xf0,0x1c]
+packssdw 485498096, %xmm1
+
+// CHECK: packssdw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6b,0x4c,0x02,0x40]
+packssdw 64(%edx,%eax), %xmm1
+
+// CHECK: packssdw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6b,0x0a]
+packssdw (%edx), %xmm1
+
+// CHECK: packssdw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6b,0xc9]
+packssdw %xmm1, %xmm1
+
+// CHECK: packsswb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x63,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+packsswb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: packsswb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x63,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+packsswb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: packsswb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x63,0x8a,0xf0,0x1c,0xf0,0x1c]
+packsswb 485498096(%edx), %xmm1
+
+// CHECK: packsswb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x63,0x0d,0xf0,0x1c,0xf0,0x1c]
+packsswb 485498096, %xmm1
+
+// CHECK: packsswb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x63,0x4c,0x02,0x40]
+packsswb 64(%edx,%eax), %xmm1
+
+// CHECK: packsswb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x63,0x0a]
+packsswb (%edx), %xmm1
+
+// CHECK: packsswb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x63,0xc9]
+packsswb %xmm1, %xmm1
+
+// CHECK: packuswb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x67,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+packuswb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: packuswb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x67,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+packuswb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: packuswb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x67,0x8a,0xf0,0x1c,0xf0,0x1c]
+packuswb 485498096(%edx), %xmm1
+
+// CHECK: packuswb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x67,0x0d,0xf0,0x1c,0xf0,0x1c]
+packuswb 485498096, %xmm1
+
+// CHECK: packuswb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x67,0x4c,0x02,0x40]
+packuswb 64(%edx,%eax), %xmm1
+
+// CHECK: packuswb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x67,0x0a]
+packuswb (%edx), %xmm1
+
+// CHECK: packuswb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x67,0xc9]
+packuswb %xmm1, %xmm1
+
+// CHECK: paddb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfc,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+paddb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfc,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+paddb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfc,0x8a,0xf0,0x1c,0xf0,0x1c]
+paddb 485498096(%edx), %xmm1
+
+// CHECK: paddb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfc,0x0d,0xf0,0x1c,0xf0,0x1c]
+paddb 485498096, %xmm1
+
+// CHECK: paddb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfc,0x4c,0x02,0x40]
+paddb 64(%edx,%eax), %xmm1
+
+// CHECK: paddb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfc,0x0a]
+paddb (%edx), %xmm1
+
+// CHECK: paddb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfc,0xc9]
+paddb %xmm1, %xmm1
+
+// CHECK: paddd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfe,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+paddd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfe,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+paddd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfe,0x8a,0xf0,0x1c,0xf0,0x1c]
+paddd 485498096(%edx), %xmm1
+
+// CHECK: paddd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfe,0x0d,0xf0,0x1c,0xf0,0x1c]
+paddd 485498096, %xmm1
+
+// CHECK: paddd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfe,0x4c,0x02,0x40]
+paddd 64(%edx,%eax), %xmm1
+
+// CHECK: paddd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfe,0x0a]
+paddd (%edx), %xmm1
+
+// CHECK: paddd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfe,0xc9]
+paddd %xmm1, %xmm1
+
+// CHECK: paddq -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0xd4,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+paddq -485498096(%edx,%eax,4), %mm4
+
+// CHECK: paddq 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0xd4,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+paddq 485498096(%edx,%eax,4), %mm4
+
+// CHECK: paddq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd4,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+paddq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd4,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+paddq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddq 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0xd4,0xa2,0xf0,0x1c,0xf0,0x1c]
+paddq 485498096(%edx), %mm4
+
+// CHECK: paddq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd4,0x8a,0xf0,0x1c,0xf0,0x1c]
+paddq 485498096(%edx), %xmm1
+
+// CHECK: paddq 485498096, %mm4
+// CHECK: encoding: [0x0f,0xd4,0x25,0xf0,0x1c,0xf0,0x1c]
+paddq 485498096, %mm4
+
+// CHECK: paddq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd4,0x0d,0xf0,0x1c,0xf0,0x1c]
+paddq 485498096, %xmm1
+
+// CHECK: paddq 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0xd4,0x64,0x02,0x40]
+paddq 64(%edx,%eax), %mm4
+
+// CHECK: paddq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd4,0x4c,0x02,0x40]
+paddq 64(%edx,%eax), %xmm1
+
+// CHECK: paddq (%edx), %mm4
+// CHECK: encoding: [0x0f,0xd4,0x22]
+paddq (%edx), %mm4
+
+// CHECK: paddq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd4,0x0a]
+paddq (%edx), %xmm1
+
+// CHECK: paddq %mm4, %mm4
+// CHECK: encoding: [0x0f,0xd4,0xe4]
+paddq %mm4, %mm4
+
+// CHECK: paddq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd4,0xc9]
+paddq %xmm1, %xmm1
+
+// CHECK: paddsb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xec,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+paddsb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddsb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xec,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+paddsb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddsb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xec,0x8a,0xf0,0x1c,0xf0,0x1c]
+paddsb 485498096(%edx), %xmm1
+
+// CHECK: paddsb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xec,0x0d,0xf0,0x1c,0xf0,0x1c]
+paddsb 485498096, %xmm1
+
+// CHECK: paddsb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xec,0x4c,0x02,0x40]
+paddsb 64(%edx,%eax), %xmm1
+
+// CHECK: paddsb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xec,0x0a]
+paddsb (%edx), %xmm1
+
+// CHECK: paddsb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xec,0xc9]
+paddsb %xmm1, %xmm1
+
+// CHECK: paddsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xed,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+paddsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xed,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+paddsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xed,0x8a,0xf0,0x1c,0xf0,0x1c]
+paddsw 485498096(%edx), %xmm1
+
+// CHECK: paddsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xed,0x0d,0xf0,0x1c,0xf0,0x1c]
+paddsw 485498096, %xmm1
+
+// CHECK: paddsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xed,0x4c,0x02,0x40]
+paddsw 64(%edx,%eax), %xmm1
+
+// CHECK: paddsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xed,0x0a]
+paddsw (%edx), %xmm1
+
+// CHECK: paddsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xed,0xc9]
+paddsw %xmm1, %xmm1
+
+// CHECK: paddusb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdc,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+paddusb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddusb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdc,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+paddusb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddusb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdc,0x8a,0xf0,0x1c,0xf0,0x1c]
+paddusb 485498096(%edx), %xmm1
+
+// CHECK: paddusb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdc,0x0d,0xf0,0x1c,0xf0,0x1c]
+paddusb 485498096, %xmm1
+
+// CHECK: paddusb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdc,0x4c,0x02,0x40]
+paddusb 64(%edx,%eax), %xmm1
+
+// CHECK: paddusb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdc,0x0a]
+paddusb (%edx), %xmm1
+
+// CHECK: paddusb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdc,0xc9]
+paddusb %xmm1, %xmm1
+
+// CHECK: paddusw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+paddusw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddusw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+paddusw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddusw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdd,0x8a,0xf0,0x1c,0xf0,0x1c]
+paddusw 485498096(%edx), %xmm1
+
+// CHECK: paddusw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdd,0x0d,0xf0,0x1c,0xf0,0x1c]
+paddusw 485498096, %xmm1
+
+// CHECK: paddusw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdd,0x4c,0x02,0x40]
+paddusw 64(%edx,%eax), %xmm1
+
+// CHECK: paddusw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdd,0x0a]
+paddusw (%edx), %xmm1
+
+// CHECK: paddusw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdd,0xc9]
+paddusw %xmm1, %xmm1
+
+// CHECK: paddw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+paddw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+paddw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: paddw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfd,0x8a,0xf0,0x1c,0xf0,0x1c]
+paddw 485498096(%edx), %xmm1
+
+// CHECK: paddw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfd,0x0d,0xf0,0x1c,0xf0,0x1c]
+paddw 485498096, %xmm1
+
+// CHECK: paddw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfd,0x4c,0x02,0x40]
+paddw 64(%edx,%eax), %xmm1
+
+// CHECK: paddw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfd,0x0a]
+paddw (%edx), %xmm1
+
+// CHECK: paddw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfd,0xc9]
+paddw %xmm1, %xmm1
+
+// CHECK: pand -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pand -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pand 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pand 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pand 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdb,0x8a,0xf0,0x1c,0xf0,0x1c]
+pand 485498096(%edx), %xmm1
+
+// CHECK: pand 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdb,0x0d,0xf0,0x1c,0xf0,0x1c]
+pand 485498096, %xmm1
+
+// CHECK: pand 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdb,0x4c,0x02,0x40]
+pand 64(%edx,%eax), %xmm1
+
+// CHECK: pand (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdb,0x0a]
+pand (%edx), %xmm1
+
+// CHECK: pandn -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pandn -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pandn 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pandn 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pandn 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdf,0x8a,0xf0,0x1c,0xf0,0x1c]
+pandn 485498096(%edx), %xmm1
+
+// CHECK: pandn 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdf,0x0d,0xf0,0x1c,0xf0,0x1c]
+pandn 485498096, %xmm1
+
+// CHECK: pandn 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdf,0x4c,0x02,0x40]
+pandn 64(%edx,%eax), %xmm1
+
+// CHECK: pandn (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdf,0x0a]
+pandn (%edx), %xmm1
+
+// CHECK: pandn %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdf,0xc9]
+pandn %xmm1, %xmm1
+
+// CHECK: pand %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xdb,0xc9]
+pand %xmm1, %xmm1
+
+// CHECK: pavgb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe0,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pavgb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pavgb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe0,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pavgb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pavgb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe0,0x8a,0xf0,0x1c,0xf0,0x1c]
+pavgb 485498096(%edx), %xmm1
+
+// CHECK: pavgb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe0,0x0d,0xf0,0x1c,0xf0,0x1c]
+pavgb 485498096, %xmm1
+
+// CHECK: pavgb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe0,0x4c,0x02,0x40]
+pavgb 64(%edx,%eax), %xmm1
+
+// CHECK: pavgb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe0,0x0a]
+pavgb (%edx), %xmm1
+
+// CHECK: pavgb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe0,0xc9]
+pavgb %xmm1, %xmm1
+
+// CHECK: pavgw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe3,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pavgw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pavgw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe3,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pavgw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pavgw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe3,0x8a,0xf0,0x1c,0xf0,0x1c]
+pavgw 485498096(%edx), %xmm1
+
+// CHECK: pavgw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe3,0x0d,0xf0,0x1c,0xf0,0x1c]
+pavgw 485498096, %xmm1
+
+// CHECK: pavgw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe3,0x4c,0x02,0x40]
+pavgw 64(%edx,%eax), %xmm1
+
+// CHECK: pavgw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe3,0x0a]
+pavgw (%edx), %xmm1
+
+// CHECK: pavgw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe3,0xc9]
+pavgw %xmm1, %xmm1
+
+// CHECK: pcmpeqb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x74,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pcmpeqb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpeqb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x74,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pcmpeqb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpeqb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x74,0x8a,0xf0,0x1c,0xf0,0x1c]
+pcmpeqb 485498096(%edx), %xmm1
+
+// CHECK: pcmpeqb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x74,0x0d,0xf0,0x1c,0xf0,0x1c]
+pcmpeqb 485498096, %xmm1
+
+// CHECK: pcmpeqb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x74,0x4c,0x02,0x40]
+pcmpeqb 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpeqb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x74,0x0a]
+pcmpeqb (%edx), %xmm1
+
+// CHECK: pcmpeqb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x74,0xc9]
+pcmpeqb %xmm1, %xmm1
+
+// CHECK: pcmpeqd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x76,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pcmpeqd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpeqd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x76,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pcmpeqd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpeqd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x76,0x8a,0xf0,0x1c,0xf0,0x1c]
+pcmpeqd 485498096(%edx), %xmm1
+
+// CHECK: pcmpeqd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x76,0x0d,0xf0,0x1c,0xf0,0x1c]
+pcmpeqd 485498096, %xmm1
+
+// CHECK: pcmpeqd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x76,0x4c,0x02,0x40]
+pcmpeqd 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpeqd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x76,0x0a]
+pcmpeqd (%edx), %xmm1
+
+// CHECK: pcmpeqd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x76,0xc9]
+pcmpeqd %xmm1, %xmm1
+
+// CHECK: pcmpeqw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x75,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pcmpeqw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpeqw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x75,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pcmpeqw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpeqw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x75,0x8a,0xf0,0x1c,0xf0,0x1c]
+pcmpeqw 485498096(%edx), %xmm1
+
+// CHECK: pcmpeqw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x75,0x0d,0xf0,0x1c,0xf0,0x1c]
+pcmpeqw 485498096, %xmm1
+
+// CHECK: pcmpeqw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x75,0x4c,0x02,0x40]
+pcmpeqw 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpeqw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x75,0x0a]
+pcmpeqw (%edx), %xmm1
+
+// CHECK: pcmpeqw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x75,0xc9]
+pcmpeqw %xmm1, %xmm1
+
+// CHECK: pcmpgtb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x64,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pcmpgtb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpgtb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x64,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pcmpgtb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpgtb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x64,0x8a,0xf0,0x1c,0xf0,0x1c]
+pcmpgtb 485498096(%edx), %xmm1
+
+// CHECK: pcmpgtb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x64,0x0d,0xf0,0x1c,0xf0,0x1c]
+pcmpgtb 485498096, %xmm1
+
+// CHECK: pcmpgtb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x64,0x4c,0x02,0x40]
+pcmpgtb 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpgtb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x64,0x0a]
+pcmpgtb (%edx), %xmm1
+
+// CHECK: pcmpgtb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x64,0xc9]
+pcmpgtb %xmm1, %xmm1
+
+// CHECK: pcmpgtd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x66,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pcmpgtd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpgtd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x66,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pcmpgtd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpgtd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x66,0x8a,0xf0,0x1c,0xf0,0x1c]
+pcmpgtd 485498096(%edx), %xmm1
+
+// CHECK: pcmpgtd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x66,0x0d,0xf0,0x1c,0xf0,0x1c]
+pcmpgtd 485498096, %xmm1
+
+// CHECK: pcmpgtd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x66,0x4c,0x02,0x40]
+pcmpgtd 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpgtd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x66,0x0a]
+pcmpgtd (%edx), %xmm1
+
+// CHECK: pcmpgtd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x66,0xc9]
+pcmpgtd %xmm1, %xmm1
+
+// CHECK: pcmpgtw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x65,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pcmpgtw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpgtw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x65,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pcmpgtw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpgtw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x65,0x8a,0xf0,0x1c,0xf0,0x1c]
+pcmpgtw 485498096(%edx), %xmm1
+
+// CHECK: pcmpgtw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x65,0x0d,0xf0,0x1c,0xf0,0x1c]
+pcmpgtw 485498096, %xmm1
+
+// CHECK: pcmpgtw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x65,0x4c,0x02,0x40]
+pcmpgtw 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpgtw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x65,0x0a]
+pcmpgtw (%edx), %xmm1
+
+// CHECK: pcmpgtw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x65,0xc9]
+pcmpgtw %xmm1, %xmm1
+
+// CHECK: pextrw $0, %xmm1, %eax
+// CHECK: encoding: [0x66,0x0f,0xc5,0xc1,0x00]
+pextrw $0, %xmm1, %eax
+
+// CHECK: pinsrw $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc4,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pinsrw $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pinsrw $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc4,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pinsrw $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc4,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096(%edx), %xmm1
+
+// CHECK: pinsrw $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc4,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096, %xmm1
+
+// CHECK: pinsrw $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc4,0x4c,0x02,0x40,0x00]
+pinsrw $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pinsrw $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc4,0x0a,0x00]
+pinsrw $0, (%edx), %xmm1
+
+// CHECK: pmaddwd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf5,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmaddwd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaddwd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf5,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaddwd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaddwd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf5,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmaddwd 485498096(%edx), %xmm1
+
+// CHECK: pmaddwd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf5,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmaddwd 485498096, %xmm1
+
+// CHECK: pmaddwd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf5,0x4c,0x02,0x40]
+pmaddwd 64(%edx,%eax), %xmm1
+
+// CHECK: pmaddwd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf5,0x0a]
+pmaddwd (%edx), %xmm1
+
+// CHECK: pmaddwd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf5,0xc9]
+pmaddwd %xmm1, %xmm1
+
+// CHECK: pmaxsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xee,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmaxsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xee,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaxsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xee,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmaxsw 485498096(%edx), %xmm1
+
+// CHECK: pmaxsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xee,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmaxsw 485498096, %xmm1
+
+// CHECK: pmaxsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xee,0x4c,0x02,0x40]
+pmaxsw 64(%edx,%eax), %xmm1
+
+// CHECK: pmaxsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xee,0x0a]
+pmaxsw (%edx), %xmm1
+
+// CHECK: pmaxsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xee,0xc9]
+pmaxsw %xmm1, %xmm1
+
+// CHECK: pmaxub -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xde,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmaxub -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxub 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xde,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaxub 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxub 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xde,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmaxub 485498096(%edx), %xmm1
+
+// CHECK: pmaxub 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xde,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmaxub 485498096, %xmm1
+
+// CHECK: pmaxub 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xde,0x4c,0x02,0x40]
+pmaxub 64(%edx,%eax), %xmm1
+
+// CHECK: pmaxub (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xde,0x0a]
+pmaxub (%edx), %xmm1
+
+// CHECK: pmaxub %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xde,0xc9]
+pmaxub %xmm1, %xmm1
+
+// CHECK: pminsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xea,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pminsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xea,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pminsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xea,0x8a,0xf0,0x1c,0xf0,0x1c]
+pminsw 485498096(%edx), %xmm1
+
+// CHECK: pminsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xea,0x0d,0xf0,0x1c,0xf0,0x1c]
+pminsw 485498096, %xmm1
+
+// CHECK: pminsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xea,0x4c,0x02,0x40]
+pminsw 64(%edx,%eax), %xmm1
+
+// CHECK: pminsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xea,0x0a]
+pminsw (%edx), %xmm1
+
+// CHECK: pminsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xea,0xc9]
+pminsw %xmm1, %xmm1
+
+// CHECK: pminub -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xda,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pminub -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminub 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xda,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pminub 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminub 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xda,0x8a,0xf0,0x1c,0xf0,0x1c]
+pminub 485498096(%edx), %xmm1
+
+// CHECK: pminub 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xda,0x0d,0xf0,0x1c,0xf0,0x1c]
+pminub 485498096, %xmm1
+
+// CHECK: pminub 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xda,0x4c,0x02,0x40]
+pminub 64(%edx,%eax), %xmm1
+
+// CHECK: pminub (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xda,0x0a]
+pminub (%edx), %xmm1
+
+// CHECK: pminub %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xda,0xc9]
+pminub %xmm1, %xmm1
+
+// CHECK: pmulhuw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe4,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmulhuw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmulhuw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe4,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmulhuw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmulhuw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe4,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmulhuw 485498096(%edx), %xmm1
+
+// CHECK: pmulhuw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe4,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmulhuw 485498096, %xmm1
+
+// CHECK: pmulhuw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe4,0x4c,0x02,0x40]
+pmulhuw 64(%edx,%eax), %xmm1
+
+// CHECK: pmulhuw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe4,0x0a]
+pmulhuw (%edx), %xmm1
+
+// CHECK: pmulhuw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe4,0xc9]
+pmulhuw %xmm1, %xmm1
+
+// CHECK: pmulhw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe5,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmulhw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmulhw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe5,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmulhw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmulhw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe5,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmulhw 485498096(%edx), %xmm1
+
+// CHECK: pmulhw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe5,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmulhw 485498096, %xmm1
+
+// CHECK: pmulhw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe5,0x4c,0x02,0x40]
+pmulhw 64(%edx,%eax), %xmm1
+
+// CHECK: pmulhw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe5,0x0a]
+pmulhw (%edx), %xmm1
+
+// CHECK: pmulhw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe5,0xc9]
+pmulhw %xmm1, %xmm1
+
+// CHECK: pmullw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd5,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmullw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmullw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd5,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmullw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmullw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd5,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmullw 485498096(%edx), %xmm1
+
+// CHECK: pmullw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd5,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmullw 485498096, %xmm1
+
+// CHECK: pmullw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd5,0x4c,0x02,0x40]
+pmullw 64(%edx,%eax), %xmm1
+
+// CHECK: pmullw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd5,0x0a]
+pmullw (%edx), %xmm1
+
+// CHECK: pmullw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd5,0xc9]
+pmullw %xmm1, %xmm1
+
+// CHECK: pmuludq -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0xf4,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+pmuludq -485498096(%edx,%eax,4), %mm4
+
+// CHECK: pmuludq 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0xf4,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+pmuludq 485498096(%edx,%eax,4), %mm4
+
+// CHECK: pmuludq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf4,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmuludq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmuludq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf4,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmuludq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmuludq 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0xf4,0xa2,0xf0,0x1c,0xf0,0x1c]
+pmuludq 485498096(%edx), %mm4
+
+// CHECK: pmuludq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf4,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmuludq 485498096(%edx), %xmm1
+
+// CHECK: pmuludq 485498096, %mm4
+// CHECK: encoding: [0x0f,0xf4,0x25,0xf0,0x1c,0xf0,0x1c]
+pmuludq 485498096, %mm4
+
+// CHECK: pmuludq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf4,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmuludq 485498096, %xmm1
+
+// CHECK: pmuludq 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0xf4,0x64,0x02,0x40]
+pmuludq 64(%edx,%eax), %mm4
+
+// CHECK: pmuludq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf4,0x4c,0x02,0x40]
+pmuludq 64(%edx,%eax), %xmm1
+
+// CHECK: pmuludq (%edx), %mm4
+// CHECK: encoding: [0x0f,0xf4,0x22]
+pmuludq (%edx), %mm4
+
+// CHECK: pmuludq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf4,0x0a]
+pmuludq (%edx), %xmm1
+
+// CHECK: pmuludq %mm4, %mm4
+// CHECK: encoding: [0x0f,0xf4,0xe4]
+pmuludq %mm4, %mm4
+
+// CHECK: pmuludq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf4,0xc9]
+pmuludq %xmm1, %xmm1
+
+// CHECK: por -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xeb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+por -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: por 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xeb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+por 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: por 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xeb,0x8a,0xf0,0x1c,0xf0,0x1c]
+por 485498096(%edx), %xmm1
+
+// CHECK: por 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xeb,0x0d,0xf0,0x1c,0xf0,0x1c]
+por 485498096, %xmm1
+
+// CHECK: por 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xeb,0x4c,0x02,0x40]
+por 64(%edx,%eax), %xmm1
+
+// CHECK: por (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xeb,0x0a]
+por (%edx), %xmm1
+
+// CHECK: por %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xeb,0xc9]
+por %xmm1, %xmm1
+
+// CHECK: psadbw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf6,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psadbw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psadbw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf6,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psadbw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psadbw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf6,0x8a,0xf0,0x1c,0xf0,0x1c]
+psadbw 485498096(%edx), %xmm1
+
+// CHECK: psadbw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf6,0x0d,0xf0,0x1c,0xf0,0x1c]
+psadbw 485498096, %xmm1
+
+// CHECK: psadbw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf6,0x4c,0x02,0x40]
+psadbw 64(%edx,%eax), %xmm1
+
+// CHECK: psadbw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf6,0x0a]
+psadbw (%edx), %xmm1
+
+// CHECK: psadbw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf6,0xc9]
+psadbw %xmm1, %xmm1
+
+// CHECK: pshufd $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x70,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pshufd $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pshufd $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x70,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pshufd $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pshufd $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x70,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pshufd $0, 485498096(%edx), %xmm1
+
+// CHECK: pshufd $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x70,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pshufd $0, 485498096, %xmm1
+
+// CHECK: pshufd $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x70,0x4c,0x02,0x40,0x00]
+pshufd $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pshufd $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x70,0x0a,0x00]
+pshufd $0, (%edx), %xmm1
+
+// CHECK: pshufd $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x70,0xc9,0x00]
+pshufd $0, %xmm1, %xmm1
+
+// CHECK: pshufhw $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x70,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pshufhw $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pshufhw $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x70,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pshufhw $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pshufhw $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x70,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pshufhw $0, 485498096(%edx), %xmm1
+
+// CHECK: pshufhw $0, 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x70,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pshufhw $0, 485498096, %xmm1
+
+// CHECK: pshufhw $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x70,0x4c,0x02,0x40,0x00]
+pshufhw $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pshufhw $0, (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x70,0x0a,0x00]
+pshufhw $0, (%edx), %xmm1
+
+// CHECK: pshufhw $0, %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x70,0xc9,0x00]
+pshufhw $0, %xmm1, %xmm1
+
+// CHECK: pshuflw $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x70,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pshuflw $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pshuflw $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x70,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pshuflw $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pshuflw $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x70,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pshuflw $0, 485498096(%edx), %xmm1
+
+// CHECK: pshuflw $0, 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x70,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pshuflw $0, 485498096, %xmm1
+
+// CHECK: pshuflw $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x70,0x4c,0x02,0x40,0x00]
+pshuflw $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pshuflw $0, (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x70,0x0a,0x00]
+pshuflw $0, (%edx), %xmm1
+
+// CHECK: pshuflw $0, %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x70,0xc9,0x00]
+pshuflw $0, %xmm1, %xmm1
+
+// CHECK: pslld $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x72,0xf1,0x00]
+pslld $0, %xmm1
+
+// CHECK: pslld -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf2,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pslld -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pslld 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf2,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pslld 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pslld 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf2,0x8a,0xf0,0x1c,0xf0,0x1c]
+pslld 485498096(%edx), %xmm1
+
+// CHECK: pslld 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf2,0x0d,0xf0,0x1c,0xf0,0x1c]
+pslld 485498096, %xmm1
+
+// CHECK: pslld 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf2,0x4c,0x02,0x40]
+pslld 64(%edx,%eax), %xmm1
+
+// CHECK: pslld (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf2,0x0a]
+pslld (%edx), %xmm1
+
+// CHECK: pslldq $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x73,0xf9,0x00]
+pslldq $0, %xmm1
+
+// CHECK: pslld %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf2,0xc9]
+pslld %xmm1, %xmm1
+
+// CHECK: psllq $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x73,0xf1,0x00]
+psllq $0, %xmm1
+
+// CHECK: psllq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf3,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psllq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psllq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf3,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psllq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psllq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf3,0x8a,0xf0,0x1c,0xf0,0x1c]
+psllq 485498096(%edx), %xmm1
+
+// CHECK: psllq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf3,0x0d,0xf0,0x1c,0xf0,0x1c]
+psllq 485498096, %xmm1
+
+// CHECK: psllq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf3,0x4c,0x02,0x40]
+psllq 64(%edx,%eax), %xmm1
+
+// CHECK: psllq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf3,0x0a]
+psllq (%edx), %xmm1
+
+// CHECK: psllq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf3,0xc9]
+psllq %xmm1, %xmm1
+
+// CHECK: psllw $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x71,0xf1,0x00]
+psllw $0, %xmm1
+
+// CHECK: psllw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf1,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psllw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psllw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf1,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psllw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psllw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf1,0x8a,0xf0,0x1c,0xf0,0x1c]
+psllw 485498096(%edx), %xmm1
+
+// CHECK: psllw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf1,0x0d,0xf0,0x1c,0xf0,0x1c]
+psllw 485498096, %xmm1
+
+// CHECK: psllw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf1,0x4c,0x02,0x40]
+psllw 64(%edx,%eax), %xmm1
+
+// CHECK: psllw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf1,0x0a]
+psllw (%edx), %xmm1
+
+// CHECK: psllw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf1,0xc9]
+psllw %xmm1, %xmm1
+
+// CHECK: psrad $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x72,0xe1,0x00]
+psrad $0, %xmm1
+
+// CHECK: psrad -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe2,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psrad -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psrad 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe2,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psrad 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psrad 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe2,0x8a,0xf0,0x1c,0xf0,0x1c]
+psrad 485498096(%edx), %xmm1
+
+// CHECK: psrad 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe2,0x0d,0xf0,0x1c,0xf0,0x1c]
+psrad 485498096, %xmm1
+
+// CHECK: psrad 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe2,0x4c,0x02,0x40]
+psrad 64(%edx,%eax), %xmm1
+
+// CHECK: psrad (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe2,0x0a]
+psrad (%edx), %xmm1
+
+// CHECK: psrad %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe2,0xc9]
+psrad %xmm1, %xmm1
+
+// CHECK: psraw $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x71,0xe1,0x00]
+psraw $0, %xmm1
+
+// CHECK: psraw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe1,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psraw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psraw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe1,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psraw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psraw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe1,0x8a,0xf0,0x1c,0xf0,0x1c]
+psraw 485498096(%edx), %xmm1
+
+// CHECK: psraw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe1,0x0d,0xf0,0x1c,0xf0,0x1c]
+psraw 485498096, %xmm1
+
+// CHECK: psraw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe1,0x4c,0x02,0x40]
+psraw 64(%edx,%eax), %xmm1
+
+// CHECK: psraw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe1,0x0a]
+psraw (%edx), %xmm1
+
+// CHECK: psraw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe1,0xc9]
+psraw %xmm1, %xmm1
+
+// CHECK: psrld $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x72,0xd1,0x00]
+psrld $0, %xmm1
+
+// CHECK: psrld -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd2,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psrld -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psrld 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd2,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psrld 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psrld 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd2,0x8a,0xf0,0x1c,0xf0,0x1c]
+psrld 485498096(%edx), %xmm1
+
+// CHECK: psrld 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd2,0x0d,0xf0,0x1c,0xf0,0x1c]
+psrld 485498096, %xmm1
+
+// CHECK: psrld 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd2,0x4c,0x02,0x40]
+psrld 64(%edx,%eax), %xmm1
+
+// CHECK: psrld (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd2,0x0a]
+psrld (%edx), %xmm1
+
+// CHECK: psrldq $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x73,0xd9,0x00]
+psrldq $0, %xmm1
+
+// CHECK: psrld %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd2,0xc9]
+psrld %xmm1, %xmm1
+
+// CHECK: psrlq $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x73,0xd1,0x00]
+psrlq $0, %xmm1
+
+// CHECK: psrlq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd3,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psrlq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psrlq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd3,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psrlq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psrlq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd3,0x8a,0xf0,0x1c,0xf0,0x1c]
+psrlq 485498096(%edx), %xmm1
+
+// CHECK: psrlq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd3,0x0d,0xf0,0x1c,0xf0,0x1c]
+psrlq 485498096, %xmm1
+
+// CHECK: psrlq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd3,0x4c,0x02,0x40]
+psrlq 64(%edx,%eax), %xmm1
+
+// CHECK: psrlq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd3,0x0a]
+psrlq (%edx), %xmm1
+
+// CHECK: psrlq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd3,0xc9]
+psrlq %xmm1, %xmm1
+
+// CHECK: psrlw $0, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x71,0xd1,0x00]
+psrlw $0, %xmm1
+
+// CHECK: psrlw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd1,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psrlw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psrlw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd1,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psrlw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psrlw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd1,0x8a,0xf0,0x1c,0xf0,0x1c]
+psrlw 485498096(%edx), %xmm1
+
+// CHECK: psrlw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd1,0x0d,0xf0,0x1c,0xf0,0x1c]
+psrlw 485498096, %xmm1
+
+// CHECK: psrlw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd1,0x4c,0x02,0x40]
+psrlw 64(%edx,%eax), %xmm1
+
+// CHECK: psrlw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd1,0x0a]
+psrlw (%edx), %xmm1
+
+// CHECK: psrlw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd1,0xc9]
+psrlw %xmm1, %xmm1
+
+// CHECK: psubb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf8,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psubb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf8,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psubb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf8,0x8a,0xf0,0x1c,0xf0,0x1c]
+psubb 485498096(%edx), %xmm1
+
+// CHECK: psubb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf8,0x0d,0xf0,0x1c,0xf0,0x1c]
+psubb 485498096, %xmm1
+
+// CHECK: psubb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf8,0x4c,0x02,0x40]
+psubb 64(%edx,%eax), %xmm1
+
+// CHECK: psubb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf8,0x0a]
+psubb (%edx), %xmm1
+
+// CHECK: psubb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf8,0xc9]
+psubb %xmm1, %xmm1
+
+// CHECK: psubd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfa,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psubd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfa,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psubd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfa,0x8a,0xf0,0x1c,0xf0,0x1c]
+psubd 485498096(%edx), %xmm1
+
+// CHECK: psubd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfa,0x0d,0xf0,0x1c,0xf0,0x1c]
+psubd 485498096, %xmm1
+
+// CHECK: psubd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfa,0x4c,0x02,0x40]
+psubd 64(%edx,%eax), %xmm1
+
+// CHECK: psubd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfa,0x0a]
+psubd (%edx), %xmm1
+
+// CHECK: psubd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfa,0xc9]
+psubd %xmm1, %xmm1
+
+// CHECK: psubq -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0xfb,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+psubq -485498096(%edx,%eax,4), %mm4
+
+// CHECK: psubq 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0xfb,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+psubq 485498096(%edx,%eax,4), %mm4
+
+// CHECK: psubq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psubq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psubq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubq 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0xfb,0xa2,0xf0,0x1c,0xf0,0x1c]
+psubq 485498096(%edx), %mm4
+
+// CHECK: psubq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfb,0x8a,0xf0,0x1c,0xf0,0x1c]
+psubq 485498096(%edx), %xmm1
+
+// CHECK: psubq 485498096, %mm4
+// CHECK: encoding: [0x0f,0xfb,0x25,0xf0,0x1c,0xf0,0x1c]
+psubq 485498096, %mm4
+
+// CHECK: psubq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfb,0x0d,0xf0,0x1c,0xf0,0x1c]
+psubq 485498096, %xmm1
+
+// CHECK: psubq 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0xfb,0x64,0x02,0x40]
+psubq 64(%edx,%eax), %mm4
+
+// CHECK: psubq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfb,0x4c,0x02,0x40]
+psubq 64(%edx,%eax), %xmm1
+
+// CHECK: psubq (%edx), %mm4
+// CHECK: encoding: [0x0f,0xfb,0x22]
+psubq (%edx), %mm4
+
+// CHECK: psubq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfb,0x0a]
+psubq (%edx), %xmm1
+
+// CHECK: psubq %mm4, %mm4
+// CHECK: encoding: [0x0f,0xfb,0xe4]
+psubq %mm4, %mm4
+
+// CHECK: psubq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xfb,0xc9]
+psubq %xmm1, %xmm1
+
+// CHECK: psubsb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe8,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psubsb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubsb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe8,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psubsb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubsb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe8,0x8a,0xf0,0x1c,0xf0,0x1c]
+psubsb 485498096(%edx), %xmm1
+
+// CHECK: psubsb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe8,0x0d,0xf0,0x1c,0xf0,0x1c]
+psubsb 485498096, %xmm1
+
+// CHECK: psubsb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe8,0x4c,0x02,0x40]
+psubsb 64(%edx,%eax), %xmm1
+
+// CHECK: psubsb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe8,0x0a]
+psubsb (%edx), %xmm1
+
+// CHECK: psubsb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe8,0xc9]
+psubsb %xmm1, %xmm1
+
+// CHECK: psubsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psubsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psubsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe9,0x8a,0xf0,0x1c,0xf0,0x1c]
+psubsw 485498096(%edx), %xmm1
+
+// CHECK: psubsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe9,0x0d,0xf0,0x1c,0xf0,0x1c]
+psubsw 485498096, %xmm1
+
+// CHECK: psubsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe9,0x4c,0x02,0x40]
+psubsw 64(%edx,%eax), %xmm1
+
+// CHECK: psubsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe9,0x0a]
+psubsw (%edx), %xmm1
+
+// CHECK: psubsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xe9,0xc9]
+psubsw %xmm1, %xmm1
+
+// CHECK: psubusb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd8,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psubusb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubusb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd8,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psubusb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubusb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd8,0x8a,0xf0,0x1c,0xf0,0x1c]
+psubusb 485498096(%edx), %xmm1
+
+// CHECK: psubusb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd8,0x0d,0xf0,0x1c,0xf0,0x1c]
+psubusb 485498096, %xmm1
+
+// CHECK: psubusb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd8,0x4c,0x02,0x40]
+psubusb 64(%edx,%eax), %xmm1
+
+// CHECK: psubusb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd8,0x0a]
+psubusb (%edx), %xmm1
+
+// CHECK: psubusb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd8,0xc9]
+psubusb %xmm1, %xmm1
+
+// CHECK: psubusw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psubusw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubusw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psubusw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubusw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd9,0x8a,0xf0,0x1c,0xf0,0x1c]
+psubusw 485498096(%edx), %xmm1
+
+// CHECK: psubusw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd9,0x0d,0xf0,0x1c,0xf0,0x1c]
+psubusw 485498096, %xmm1
+
+// CHECK: psubusw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd9,0x4c,0x02,0x40]
+psubusw 64(%edx,%eax), %xmm1
+
+// CHECK: psubusw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd9,0x0a]
+psubusw (%edx), %xmm1
+
+// CHECK: psubusw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd9,0xc9]
+psubusw %xmm1, %xmm1
+
+// CHECK: psubw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psubw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psubw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psubw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf9,0x8a,0xf0,0x1c,0xf0,0x1c]
+psubw 485498096(%edx), %xmm1
+
+// CHECK: psubw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf9,0x0d,0xf0,0x1c,0xf0,0x1c]
+psubw 485498096, %xmm1
+
+// CHECK: psubw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf9,0x4c,0x02,0x40]
+psubw 64(%edx,%eax), %xmm1
+
+// CHECK: psubw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf9,0x0a]
+psubw (%edx), %xmm1
+
+// CHECK: psubw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xf9,0xc9]
+psubw %xmm1, %xmm1
+
+// CHECK: punpckhbw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x68,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+punpckhbw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckhbw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x68,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+punpckhbw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckhbw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x68,0x8a,0xf0,0x1c,0xf0,0x1c]
+punpckhbw 485498096(%edx), %xmm1
+
+// CHECK: punpckhbw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x68,0x0d,0xf0,0x1c,0xf0,0x1c]
+punpckhbw 485498096, %xmm1
+
+// CHECK: punpckhbw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x68,0x4c,0x02,0x40]
+punpckhbw 64(%edx,%eax), %xmm1
+
+// CHECK: punpckhbw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x68,0x0a]
+punpckhbw (%edx), %xmm1
+
+// CHECK: punpckhbw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x68,0xc9]
+punpckhbw %xmm1, %xmm1
+
+// CHECK: punpckhdq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+punpckhdq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckhdq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+punpckhdq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckhdq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6a,0x8a,0xf0,0x1c,0xf0,0x1c]
+punpckhdq 485498096(%edx), %xmm1
+
+// CHECK: punpckhdq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6a,0x0d,0xf0,0x1c,0xf0,0x1c]
+punpckhdq 485498096, %xmm1
+
+// CHECK: punpckhdq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6a,0x4c,0x02,0x40]
+punpckhdq 64(%edx,%eax), %xmm1
+
+// CHECK: punpckhdq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6a,0x0a]
+punpckhdq (%edx), %xmm1
+
+// CHECK: punpckhdq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6a,0xc9]
+punpckhdq %xmm1, %xmm1
+
+// CHECK: punpckhqdq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+punpckhqdq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckhqdq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+punpckhqdq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckhqdq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6d,0x8a,0xf0,0x1c,0xf0,0x1c]
+punpckhqdq 485498096(%edx), %xmm1
+
+// CHECK: punpckhqdq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6d,0x0d,0xf0,0x1c,0xf0,0x1c]
+punpckhqdq 485498096, %xmm1
+
+// CHECK: punpckhqdq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6d,0x4c,0x02,0x40]
+punpckhqdq 64(%edx,%eax), %xmm1
+
+// CHECK: punpckhqdq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6d,0x0a]
+punpckhqdq (%edx), %xmm1
+
+// CHECK: punpckhqdq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6d,0xc9]
+punpckhqdq %xmm1, %xmm1
+
+// CHECK: punpckhwd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x69,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+punpckhwd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckhwd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x69,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+punpckhwd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckhwd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x69,0x8a,0xf0,0x1c,0xf0,0x1c]
+punpckhwd 485498096(%edx), %xmm1
+
+// CHECK: punpckhwd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x69,0x0d,0xf0,0x1c,0xf0,0x1c]
+punpckhwd 485498096, %xmm1
+
+// CHECK: punpckhwd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x69,0x4c,0x02,0x40]
+punpckhwd 64(%edx,%eax), %xmm1
+
+// CHECK: punpckhwd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x69,0x0a]
+punpckhwd (%edx), %xmm1
+
+// CHECK: punpckhwd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x69,0xc9]
+punpckhwd %xmm1, %xmm1
+
+// CHECK: punpcklbw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x60,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+punpcklbw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpcklbw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x60,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+punpcklbw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpcklbw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x60,0x8a,0xf0,0x1c,0xf0,0x1c]
+punpcklbw 485498096(%edx), %xmm1
+
+// CHECK: punpcklbw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x60,0x0d,0xf0,0x1c,0xf0,0x1c]
+punpcklbw 485498096, %xmm1
+
+// CHECK: punpcklbw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x60,0x4c,0x02,0x40]
+punpcklbw 64(%edx,%eax), %xmm1
+
+// CHECK: punpcklbw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x60,0x0a]
+punpcklbw (%edx), %xmm1
+
+// CHECK: punpcklbw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x60,0xc9]
+punpcklbw %xmm1, %xmm1
+
+// CHECK: punpckldq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x62,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+punpckldq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckldq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x62,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+punpckldq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpckldq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x62,0x8a,0xf0,0x1c,0xf0,0x1c]
+punpckldq 485498096(%edx), %xmm1
+
+// CHECK: punpckldq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x62,0x0d,0xf0,0x1c,0xf0,0x1c]
+punpckldq 485498096, %xmm1
+
+// CHECK: punpckldq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x62,0x4c,0x02,0x40]
+punpckldq 64(%edx,%eax), %xmm1
+
+// CHECK: punpckldq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x62,0x0a]
+punpckldq (%edx), %xmm1
+
+// CHECK: punpckldq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x62,0xc9]
+punpckldq %xmm1, %xmm1
+
+// CHECK: punpcklqdq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+punpcklqdq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpcklqdq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+punpcklqdq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpcklqdq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6c,0x8a,0xf0,0x1c,0xf0,0x1c]
+punpcklqdq 485498096(%edx), %xmm1
+
+// CHECK: punpcklqdq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6c,0x0d,0xf0,0x1c,0xf0,0x1c]
+punpcklqdq 485498096, %xmm1
+
+// CHECK: punpcklqdq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6c,0x4c,0x02,0x40]
+punpcklqdq 64(%edx,%eax), %xmm1
+
+// CHECK: punpcklqdq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6c,0x0a]
+punpcklqdq (%edx), %xmm1
+
+// CHECK: punpcklqdq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x6c,0xc9]
+punpcklqdq %xmm1, %xmm1
+
+// CHECK: punpcklwd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x61,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+punpcklwd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpcklwd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x61,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+punpcklwd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: punpcklwd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x61,0x8a,0xf0,0x1c,0xf0,0x1c]
+punpcklwd 485498096(%edx), %xmm1
+
+// CHECK: punpcklwd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x61,0x0d,0xf0,0x1c,0xf0,0x1c]
+punpcklwd 485498096, %xmm1
+
+// CHECK: punpcklwd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x61,0x4c,0x02,0x40]
+punpcklwd 64(%edx,%eax), %xmm1
+
+// CHECK: punpcklwd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x61,0x0a]
+punpcklwd (%edx), %xmm1
+
+// CHECK: punpcklwd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x61,0xc9]
+punpcklwd %xmm1, %xmm1
+
+// CHECK: pxor -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xef,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pxor -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pxor 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xef,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pxor 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pxor 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xef,0x8a,0xf0,0x1c,0xf0,0x1c]
+pxor 485498096(%edx), %xmm1
+
+// CHECK: pxor 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xef,0x0d,0xf0,0x1c,0xf0,0x1c]
+pxor 485498096, %xmm1
+
+// CHECK: pxor 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xef,0x4c,0x02,0x40]
+pxor 64(%edx,%eax), %xmm1
+
+// CHECK: pxor (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xef,0x0a]
+pxor (%edx), %xmm1
+
+// CHECK: pxor %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xef,0xc9]
+pxor %xmm1, %xmm1
+
+// CHECK: shufpd $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc6,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+shufpd $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: shufpd $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc6,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+shufpd $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: shufpd $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc6,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+shufpd $0, 485498096(%edx), %xmm1
+
+// CHECK: shufpd $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc6,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+shufpd $0, 485498096, %xmm1
+
+// CHECK: shufpd $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc6,0x4c,0x02,0x40,0x00]
+shufpd $0, 64(%edx,%eax), %xmm1
+
+// CHECK: shufpd $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc6,0x0a,0x00]
+shufpd $0, (%edx), %xmm1
+
+// CHECK: shufpd $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xc6,0xc9,0x00]
+shufpd $0, %xmm1, %xmm1
+
+// CHECK: sqrtpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+sqrtpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: sqrtpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+sqrtpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: sqrtpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
+sqrtpd 485498096(%edx), %xmm1
+
+// CHECK: sqrtpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
+sqrtpd 485498096, %xmm1
+
+// CHECK: sqrtpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x51,0x4c,0x02,0x40]
+sqrtpd 64(%edx,%eax), %xmm1
+
+// CHECK: sqrtpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x51,0x0a]
+sqrtpd (%edx), %xmm1
+
+// CHECK: sqrtpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x51,0xc9]
+sqrtpd %xmm1, %xmm1
+
+// CHECK: sqrtsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+sqrtsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: sqrtsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+sqrtsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: sqrtsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
+sqrtsd 485498096(%edx), %xmm1
+
+// CHECK: sqrtsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
+sqrtsd 485498096, %xmm1
+
+// CHECK: sqrtsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x51,0x4c,0x02,0x40]
+sqrtsd 64(%edx,%eax), %xmm1
+
+// CHECK: sqrtsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x51,0x0a]
+sqrtsd (%edx), %xmm1
+
+// CHECK: sqrtsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x51,0xc9]
+sqrtsd %xmm1, %xmm1
+
+// CHECK: subpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+subpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: subpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+subpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: subpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
+subpd 485498096(%edx), %xmm1
+
+// CHECK: subpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
+subpd 485498096, %xmm1
+
+// CHECK: subpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5c,0x4c,0x02,0x40]
+subpd 64(%edx,%eax), %xmm1
+
+// CHECK: subpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5c,0x0a]
+subpd (%edx), %xmm1
+
+// CHECK: subpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x5c,0xc9]
+subpd %xmm1, %xmm1
+
+// CHECK: subsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+subsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: subsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+subsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: subsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
+subsd 485498096(%edx), %xmm1
+
+// CHECK: subsd 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
+subsd 485498096, %xmm1
+
+// CHECK: subsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x4c,0x02,0x40]
+subsd 64(%edx,%eax), %xmm1
+
+// CHECK: subsd (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x0a]
+subsd (%edx), %xmm1
+
+// CHECK: subsd %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x5c,0xc9]
+subsd %xmm1, %xmm1
+
+// CHECK: ucomisd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+ucomisd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: ucomisd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+ucomisd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: ucomisd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2e,0x8a,0xf0,0x1c,0xf0,0x1c]
+ucomisd 485498096(%edx), %xmm1
+
+// CHECK: ucomisd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2e,0x0d,0xf0,0x1c,0xf0,0x1c]
+ucomisd 485498096, %xmm1
+
+// CHECK: ucomisd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2e,0x4c,0x02,0x40]
+ucomisd 64(%edx,%eax), %xmm1
+
+// CHECK: ucomisd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2e,0x0a]
+ucomisd (%edx), %xmm1
+
+// CHECK: ucomisd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x2e,0xc9]
+ucomisd %xmm1, %xmm1
+
+// CHECK: unpckhpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x15,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+unpckhpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: unpckhpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x15,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+unpckhpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: unpckhpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x15,0x8a,0xf0,0x1c,0xf0,0x1c]
+unpckhpd 485498096(%edx), %xmm1
+
+// CHECK: unpckhpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x15,0x0d,0xf0,0x1c,0xf0,0x1c]
+unpckhpd 485498096, %xmm1
+
+// CHECK: unpckhpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x15,0x4c,0x02,0x40]
+unpckhpd 64(%edx,%eax), %xmm1
+
+// CHECK: unpckhpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x15,0x0a]
+unpckhpd (%edx), %xmm1
+
+// CHECK: unpckhpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x15,0xc9]
+unpckhpd %xmm1, %xmm1
+
+// CHECK: unpcklpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x14,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+unpcklpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: unpcklpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x14,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+unpcklpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: unpcklpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x14,0x8a,0xf0,0x1c,0xf0,0x1c]
+unpcklpd 485498096(%edx), %xmm1
+
+// CHECK: unpcklpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x14,0x0d,0xf0,0x1c,0xf0,0x1c]
+unpcklpd 485498096, %xmm1
+
+// CHECK: unpcklpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x14,0x4c,0x02,0x40]
+unpcklpd 64(%edx,%eax), %xmm1
+
+// CHECK: unpcklpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x14,0x0a]
+unpcklpd (%edx), %xmm1
+
+// CHECK: unpcklpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x14,0xc9]
+unpcklpd %xmm1, %xmm1
+
+// CHECK: xorpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x57,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+xorpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: xorpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x57,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+xorpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: xorpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x57,0x8a,0xf0,0x1c,0xf0,0x1c]
+xorpd 485498096(%edx), %xmm1
+
+// CHECK: xorpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x57,0x0d,0xf0,0x1c,0xf0,0x1c]
+xorpd 485498096, %xmm1
+
+// CHECK: xorpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x57,0x4c,0x02,0x40]
+xorpd 64(%edx,%eax), %xmm1
+
+// CHECK: xorpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x57,0x0a]
+xorpd (%edx), %xmm1
+
+// CHECK: xorpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x57,0xc9]
+xorpd %xmm1, %xmm1
+

test/MC/X86/SSE2-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: addpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x58,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+addpd 485498096, %xmm6
+
+// CHECK: addpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x58,0x74,0x82,0xc0]
+addpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: addpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x58,0x74,0x82,0x40]
+addpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: addpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x58,0x74,0x02,0x40]
+addpd 64(%rdx,%rax), %xmm6
+
+// CHECK: addpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x58,0x72,0x40]
+addpd 64(%rdx), %xmm6
+
+// CHECK: addpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x58,0x32]
+addpd (%rdx), %xmm6
+
+// CHECK: addpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x58,0xf6]
+addpd %xmm6, %xmm6
+
+// CHECK: addsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x58,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+addsd 485498096, %xmm6
+
+// CHECK: addsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x58,0x74,0x82,0xc0]
+addsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: addsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x58,0x74,0x82,0x40]
+addsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: addsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x58,0x74,0x02,0x40]
+addsd 64(%rdx,%rax), %xmm6
+
+// CHECK: addsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x58,0x72,0x40]
+addsd 64(%rdx), %xmm6
+
+// CHECK: addsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x58,0x32]
+addsd (%rdx), %xmm6
+
+// CHECK: addsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x58,0xf6]
+addsd %xmm6, %xmm6
+
+// CHECK: andnpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x55,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+andnpd 485498096, %xmm6
+
+// CHECK: andnpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x55,0x74,0x82,0xc0]
+andnpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: andnpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x55,0x74,0x82,0x40]
+andnpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: andnpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x55,0x74,0x02,0x40]
+andnpd 64(%rdx,%rax), %xmm6
+
+// CHECK: andnpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x55,0x72,0x40]
+andnpd 64(%rdx), %xmm6
+
+// CHECK: andnpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x55,0x32]
+andnpd (%rdx), %xmm6
+
+// CHECK: andnpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x55,0xf6]
+andnpd %xmm6, %xmm6
+
+// CHECK: andpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x54,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+andpd 485498096, %xmm6
+
+// CHECK: andpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x54,0x74,0x82,0xc0]
+andpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: andpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x54,0x74,0x82,0x40]
+andpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: andpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x54,0x74,0x02,0x40]
+andpd 64(%rdx,%rax), %xmm6
+
+// CHECK: andpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x54,0x72,0x40]
+andpd 64(%rdx), %xmm6
+
+// CHECK: andpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x54,0x32]
+andpd (%rdx), %xmm6
+
+// CHECK: andpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x54,0xf6]
+andpd %xmm6, %xmm6
+
+// CHECK: cmpeqpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc2,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqpd 485498096, %xmm6
+
+// CHECK: cmpeqpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc2,0x74,0x82,0xc0,0x00]
+cmpeqpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cmpeqpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc2,0x74,0x82,0x40,0x00]
+cmpeqpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cmpeqpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc2,0x74,0x02,0x40,0x00]
+cmpeqpd 64(%rdx,%rax), %xmm6
+
+// CHECK: cmpeqpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc2,0x72,0x40,0x00]
+cmpeqpd 64(%rdx), %xmm6
+
+// CHECK: cmpeqpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc2,0x32,0x00]
+cmpeqpd (%rdx), %xmm6
+
+// CHECK: cmpeqpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc2,0xf6,0x00]
+cmpeqpd %xmm6, %xmm6
+
+// CHECK: cmpeqsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+cmpeqsd 485498096, %xmm6
+
+// CHECK: cmpeqsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x74,0x82,0xc0,0x00]
+cmpeqsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cmpeqsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x74,0x82,0x40,0x00]
+cmpeqsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cmpeqsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x74,0x02,0x40,0x00]
+cmpeqsd 64(%rdx,%rax), %xmm6
+
+// CHECK: cmpeqsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x72,0x40,0x00]
+cmpeqsd 64(%rdx), %xmm6
+
+// CHECK: cmpeqsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xc2,0x32,0x00]
+cmpeqsd (%rdx), %xmm6
+
+// CHECK: cmpeqsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xc2,0xf6,0x00]
+cmpeqsd %xmm6, %xmm6
+
+// CHECK: comisd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+comisd 485498096, %xmm6
+
+// CHECK: comisd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2f,0x74,0x82,0xc0]
+comisd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: comisd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2f,0x74,0x82,0x40]
+comisd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: comisd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2f,0x74,0x02,0x40]
+comisd 64(%rdx,%rax), %xmm6
+
+// CHECK: comisd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2f,0x72,0x40]
+comisd 64(%rdx), %xmm6
+
+// CHECK: comisd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2f,0x32]
+comisd (%rdx), %xmm6
+
+// CHECK: comisd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2f,0xf6]
+comisd %xmm6, %xmm6
+
+// CHECK: cvtdq2pd 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtdq2pd 485498096, %xmm6
+
+// CHECK: cvtdq2pd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x74,0x82,0xc0]
+cvtdq2pd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtdq2pd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x74,0x82,0x40]
+cvtdq2pd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtdq2pd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x74,0x02,0x40]
+cvtdq2pd 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtdq2pd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x72,0x40]
+cvtdq2pd 64(%rdx), %xmm6
+
+// CHECK: cvtdq2pd (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xe6,0x32]
+cvtdq2pd (%rdx), %xmm6
+
+// CHECK: cvtdq2pd %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xe6,0xf6]
+cvtdq2pd %xmm6, %xmm6
+
+// CHECK: cvtdq2ps 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x5b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtdq2ps 485498096, %xmm6
+
+// CHECK: cvtdq2ps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5b,0x74,0x82,0xc0]
+cvtdq2ps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtdq2ps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5b,0x74,0x82,0x40]
+cvtdq2ps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtdq2ps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x5b,0x74,0x02,0x40]
+cvtdq2ps 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtdq2ps 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5b,0x72,0x40]
+cvtdq2ps 64(%rdx), %xmm6
+
+// CHECK: cvtdq2ps (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5b,0x32]
+cvtdq2ps (%rdx), %xmm6
+
+// CHECK: cvtdq2ps %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x5b,0xf6]
+cvtdq2ps %xmm6, %xmm6
+
+// CHECK: cvtpd2dq 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtpd2dq 485498096, %xmm6
+
+// CHECK: cvtpd2dq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x74,0x82,0xc0]
+cvtpd2dq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtpd2dq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x74,0x82,0x40]
+cvtpd2dq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtpd2dq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x74,0x02,0x40]
+cvtpd2dq 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtpd2dq 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x72,0x40]
+cvtpd2dq 64(%rdx), %xmm6
+
+// CHECK: cvtpd2dq (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xe6,0x32]
+cvtpd2dq (%rdx), %xmm6
+
+// CHECK: cvtpd2dq %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xe6,0xf6]
+cvtpd2dq %xmm6, %xmm6
+
+// CHECK: cvtpd2pi 485498096, %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtpd2pi 485498096, %mm4
+
+// CHECK: cvtpd2pi 64(%rdx), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x62,0x40]
+cvtpd2pi 64(%rdx), %mm4
+
+// CHECK: cvtpd2pi -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x64,0x82,0xc0]
+cvtpd2pi -64(%rdx,%rax,4), %mm4
+
+// CHECK: cvtpd2pi 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x64,0x82,0x40]
+cvtpd2pi 64(%rdx,%rax,4), %mm4
+
+// CHECK: cvtpd2pi 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x64,0x02,0x40]
+cvtpd2pi 64(%rdx,%rax), %mm4
+
+// CHECK: cvtpd2pi (%rdx), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0x22]
+cvtpd2pi (%rdx), %mm4
+
+// CHECK: cvtpd2pi %xmm6, %mm4
+// CHECK: encoding: [0x66,0x0f,0x2d,0xe6]
+cvtpd2pi %xmm6, %mm4
+
+// CHECK: cvtpd2ps 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtpd2ps 485498096, %xmm6
+
+// CHECK: cvtpd2ps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5a,0x74,0x82,0xc0]
+cvtpd2ps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtpd2ps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5a,0x74,0x82,0x40]
+cvtpd2ps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtpd2ps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5a,0x74,0x02,0x40]
+cvtpd2ps 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtpd2ps 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5a,0x72,0x40]
+cvtpd2ps 64(%rdx), %xmm6
+
+// CHECK: cvtpd2ps (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5a,0x32]
+cvtpd2ps (%rdx), %xmm6
+
+// CHECK: cvtpd2ps %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5a,0xf6]
+cvtpd2ps %xmm6, %xmm6
+
+// CHECK: cvtpi2pd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtpi2pd 485498096, %xmm6
+
+// CHECK: cvtpi2pd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2a,0x74,0x82,0xc0]
+cvtpi2pd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtpi2pd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2a,0x74,0x82,0x40]
+cvtpi2pd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtpi2pd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2a,0x74,0x02,0x40]
+cvtpi2pd 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtpi2pd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2a,0x72,0x40]
+cvtpi2pd 64(%rdx), %xmm6
+
+// CHECK: cvtpi2pd %mm4, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2a,0xf4]
+cvtpi2pd %mm4, %xmm6
+
+// CHECK: cvtpi2pd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2a,0x32]
+cvtpi2pd (%rdx), %xmm6
+
+// CHECK: cvtps2dq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtps2dq 485498096, %xmm6
+
+// CHECK: cvtps2dq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5b,0x74,0x82,0xc0]
+cvtps2dq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtps2dq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5b,0x74,0x82,0x40]
+cvtps2dq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtps2dq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5b,0x74,0x02,0x40]
+cvtps2dq 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtps2dq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5b,0x72,0x40]
+cvtps2dq 64(%rdx), %xmm6
+
+// CHECK: cvtps2dq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5b,0x32]
+cvtps2dq (%rdx), %xmm6
+
+// CHECK: cvtps2dq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5b,0xf6]
+cvtps2dq %xmm6, %xmm6
+
+// CHECK: cvtps2pd 485498096, %xmm6
+// CHECK: encoding: [0x0f,0x5a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtps2pd 485498096, %xmm6
+
+// CHECK: cvtps2pd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5a,0x74,0x82,0xc0]
+cvtps2pd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtps2pd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x0f,0x5a,0x74,0x82,0x40]
+cvtps2pd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtps2pd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x0f,0x5a,0x74,0x02,0x40]
+cvtps2pd 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtps2pd 64(%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5a,0x72,0x40]
+cvtps2pd 64(%rdx), %xmm6
+
+// CHECK: cvtps2pd (%rdx), %xmm6
+// CHECK: encoding: [0x0f,0x5a,0x32]
+cvtps2pd (%rdx), %xmm6
+
+// CHECK: cvtps2pd %xmm6, %xmm6
+// CHECK: encoding: [0x0f,0x5a,0xf6]
+cvtps2pd %xmm6, %xmm6
+
+// CHECK: cvtsd2si 485498096, %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2d,0x2c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtsd2si 485498096, %r13d
+
+// CHECK: cvtsd2si 485498096, %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2d,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtsd2si 485498096, %r15
+
+// CHECK: cvtsd2si 64(%rdx), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2d,0x6a,0x40]
+cvtsd2si 64(%rdx), %r13d
+
+// CHECK: cvtsd2si 64(%rdx), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2d,0x7a,0x40]
+cvtsd2si 64(%rdx), %r15
+
+// CHECK: cvtsd2si -64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2d,0x6c,0x82,0xc0]
+cvtsd2si -64(%rdx,%rax,4), %r13d
+
+// CHECK: cvtsd2si 64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2d,0x6c,0x82,0x40]
+cvtsd2si 64(%rdx,%rax,4), %r13d
+
+// CHECK: cvtsd2si -64(%rdx,%rax,4), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2d,0x7c,0x82,0xc0]
+cvtsd2si -64(%rdx,%rax,4), %r15
+
+// CHECK: cvtsd2si 64(%rdx,%rax,4), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2d,0x7c,0x82,0x40]
+cvtsd2si 64(%rdx,%rax,4), %r15
+
+// CHECK: cvtsd2si 64(%rdx,%rax), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2d,0x6c,0x02,0x40]
+cvtsd2si 64(%rdx,%rax), %r13d
+
+// CHECK: cvtsd2si 64(%rdx,%rax), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2d,0x7c,0x02,0x40]
+cvtsd2si 64(%rdx,%rax), %r15
+
+// CHECK: cvtsd2si (%rdx), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2d,0x2a]
+cvtsd2si (%rdx), %r13d
+
+// CHECK: cvtsd2si (%rdx), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2d,0x3a]
+cvtsd2si (%rdx), %r15
+
+// CHECK: cvtsd2si %xmm6, %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2d,0xee]
+cvtsd2si %xmm6, %r13d
+
+// CHECK: cvtsd2si %xmm6, %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2d,0xfe]
+cvtsd2si %xmm6, %r15
+
+// CHECK: cvtsd2ss 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtsd2ss 485498096, %xmm6
+
+// CHECK: cvtsd2ss -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x74,0x82,0xc0]
+cvtsd2ss -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsd2ss 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x74,0x82,0x40]
+cvtsd2ss 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsd2ss 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x74,0x02,0x40]
+cvtsd2ss 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtsd2ss 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x72,0x40]
+cvtsd2ss 64(%rdx), %xmm6
+
+// CHECK: cvtsd2ss (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5a,0x32]
+cvtsd2ss (%rdx), %xmm6
+
+// CHECK: cvtsd2ss %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5a,0xf6]
+cvtsd2ss %xmm6, %xmm6
+
+// CHECK: cvtsi2sdl 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtsi2sdl 485498096, %xmm6
+
+// CHECK: cvtsi2sdl -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x74,0x82,0xc0]
+cvtsi2sdl -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsi2sdl 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x74,0x82,0x40]
+cvtsi2sdl 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsi2sdl 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x74,0x02,0x40]
+cvtsi2sdl 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtsi2sdl 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x72,0x40]
+cvtsi2sdl 64(%rdx), %xmm6
+
+// CHECK: cvtsi2sdl %r13d, %xmm6
+// CHECK: encoding: [0xf2,0x41,0x0f,0x2a,0xf5]
+cvtsi2sdl %r13d, %xmm6
+
+// CHECK: cvtsi2sdl (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x2a,0x32]
+cvtsi2sdl (%rdx), %xmm6
+
+// CHECK: cvtsi2sdq 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x48,0x0f,0x2a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtsi2sdq 485498096, %xmm6
+
+// CHECK: cvtsi2sdq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x48,0x0f,0x2a,0x74,0x82,0xc0]
+cvtsi2sdq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsi2sdq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x48,0x0f,0x2a,0x74,0x82,0x40]
+cvtsi2sdq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtsi2sdq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x48,0x0f,0x2a,0x74,0x02,0x40]
+cvtsi2sdq 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtsi2sdq 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x48,0x0f,0x2a,0x72,0x40]
+cvtsi2sdq 64(%rdx), %xmm6
+
+// CHECK: cvtsi2sdq %r15, %xmm6
+// CHECK: encoding: [0xf2,0x49,0x0f,0x2a,0xf7]
+cvtsi2sdq %r15, %xmm6
+
+// CHECK: cvtsi2sdq (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x48,0x0f,0x2a,0x32]
+cvtsi2sdq (%rdx), %xmm6
+
+// CHECK: cvtss2sd 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvtss2sd 485498096, %xmm6
+
+// CHECK: cvtss2sd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x74,0x82,0xc0]
+cvtss2sd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtss2sd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x74,0x82,0x40]
+cvtss2sd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvtss2sd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x74,0x02,0x40]
+cvtss2sd 64(%rdx,%rax), %xmm6
+
+// CHECK: cvtss2sd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x72,0x40]
+cvtss2sd 64(%rdx), %xmm6
+
+// CHECK: cvtss2sd (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5a,0x32]
+cvtss2sd (%rdx), %xmm6
+
+// CHECK: cvtss2sd %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5a,0xf6]
+cvtss2sd %xmm6, %xmm6
+
+// CHECK: cvttpd2dq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe6,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttpd2dq 485498096, %xmm6
+
+// CHECK: cvttpd2dq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe6,0x74,0x82,0xc0]
+cvttpd2dq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvttpd2dq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe6,0x74,0x82,0x40]
+cvttpd2dq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvttpd2dq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe6,0x74,0x02,0x40]
+cvttpd2dq 64(%rdx,%rax), %xmm6
+
+// CHECK: cvttpd2dq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe6,0x72,0x40]
+cvttpd2dq 64(%rdx), %xmm6
+
+// CHECK: cvttpd2dq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe6,0x32]
+cvttpd2dq (%rdx), %xmm6
+
+// CHECK: cvttpd2dq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe6,0xf6]
+cvttpd2dq %xmm6, %xmm6
+
+// CHECK: cvttpd2pi 485498096, %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttpd2pi 485498096, %mm4
+
+// CHECK: cvttpd2pi 64(%rdx), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x62,0x40]
+cvttpd2pi 64(%rdx), %mm4
+
+// CHECK: cvttpd2pi -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x64,0x82,0xc0]
+cvttpd2pi -64(%rdx,%rax,4), %mm4
+
+// CHECK: cvttpd2pi 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x64,0x82,0x40]
+cvttpd2pi 64(%rdx,%rax,4), %mm4
+
+// CHECK: cvttpd2pi 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x64,0x02,0x40]
+cvttpd2pi 64(%rdx,%rax), %mm4
+
+// CHECK: cvttpd2pi (%rdx), %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0x22]
+cvttpd2pi (%rdx), %mm4
+
+// CHECK: cvttpd2pi %xmm6, %mm4
+// CHECK: encoding: [0x66,0x0f,0x2c,0xe6]
+cvttpd2pi %xmm6, %mm4
+
+// CHECK: cvttps2dq 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttps2dq 485498096, %xmm6
+
+// CHECK: cvttps2dq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x74,0x82,0xc0]
+cvttps2dq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvttps2dq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x74,0x82,0x40]
+cvttps2dq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: cvttps2dq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x74,0x02,0x40]
+cvttps2dq 64(%rdx,%rax), %xmm6
+
+// CHECK: cvttps2dq 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x72,0x40]
+cvttps2dq 64(%rdx), %xmm6
+
+// CHECK: cvttps2dq (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5b,0x32]
+cvttps2dq (%rdx), %xmm6
+
+// CHECK: cvttps2dq %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x5b,0xf6]
+cvttps2dq %xmm6, %xmm6
+
+// CHECK: cvttsd2si 485498096, %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2c,0x2c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttsd2si 485498096, %r13d
+
+// CHECK: cvttsd2si 485498096, %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2c,0x3c,0x25,0xf0,0x1c,0xf0,0x1c]
+cvttsd2si 485498096, %r15
+
+// CHECK: cvttsd2si 64(%rdx), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2c,0x6a,0x40]
+cvttsd2si 64(%rdx), %r13d
+
+// CHECK: cvttsd2si 64(%rdx), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2c,0x7a,0x40]
+cvttsd2si 64(%rdx), %r15
+
+// CHECK: cvttsd2si -64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2c,0x6c,0x82,0xc0]
+cvttsd2si -64(%rdx,%rax,4), %r13d
+
+// CHECK: cvttsd2si 64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2c,0x6c,0x82,0x40]
+cvttsd2si 64(%rdx,%rax,4), %r13d
+
+// CHECK: cvttsd2si -64(%rdx,%rax,4), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2c,0x7c,0x82,0xc0]
+cvttsd2si -64(%rdx,%rax,4), %r15
+
+// CHECK: cvttsd2si 64(%rdx,%rax,4), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2c,0x7c,0x82,0x40]
+cvttsd2si 64(%rdx,%rax,4), %r15
+
+// CHECK: cvttsd2si 64(%rdx,%rax), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2c,0x6c,0x02,0x40]
+cvttsd2si 64(%rdx,%rax), %r13d
+
+// CHECK: cvttsd2si 64(%rdx,%rax), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2c,0x7c,0x02,0x40]
+cvttsd2si 64(%rdx,%rax), %r15
+
+// CHECK: cvttsd2si (%rdx), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2c,0x2a]
+cvttsd2si (%rdx), %r13d
+
+// CHECK: cvttsd2si (%rdx), %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2c,0x3a]
+cvttsd2si (%rdx), %r15
+
+// CHECK: cvttsd2si %xmm6, %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2c,0xee]
+cvttsd2si %xmm6, %r13d
+
+// CHECK: cvttsd2si %xmm6, %r15
+// CHECK: encoding: [0xf2,0x4c,0x0f,0x2c,0xfe]
+cvttsd2si %xmm6, %r15
+
+// CHECK: divpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+divpd 485498096, %xmm6
+
+// CHECK: divpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5e,0x74,0x82,0xc0]
+divpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: divpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5e,0x74,0x82,0x40]
+divpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: divpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5e,0x74,0x02,0x40]
+divpd 64(%rdx,%rax), %xmm6
+
+// CHECK: divpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5e,0x72,0x40]
+divpd 64(%rdx), %xmm6
+
+// CHECK: divpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5e,0x32]
+divpd (%rdx), %xmm6
+
+// CHECK: divpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5e,0xf6]
+divpd %xmm6, %xmm6
+
+// CHECK: divsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+divsd 485498096, %xmm6
+
+// CHECK: divsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x74,0x82,0xc0]
+divsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: divsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x74,0x82,0x40]
+divsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: divsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x74,0x02,0x40]
+divsd 64(%rdx,%rax), %xmm6
+
+// CHECK: divsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x72,0x40]
+divsd 64(%rdx), %xmm6
+
+// CHECK: divsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5e,0x32]
+divsd (%rdx), %xmm6
+
+// CHECK: divsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5e,0xf6]
+divsd %xmm6, %xmm6
+
+// CHECK: lfence
+// CHECK: encoding: [0x0f,0xae,0xe8]
+lfence
+
+// CHECK: maskmovdqu %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf7,0xf6]
+maskmovdqu %xmm6, %xmm6
+
+// CHECK: maxpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+maxpd 485498096, %xmm6
+
+// CHECK: maxpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5f,0x74,0x82,0xc0]
+maxpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: maxpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5f,0x74,0x82,0x40]
+maxpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: maxpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5f,0x74,0x02,0x40]
+maxpd 64(%rdx,%rax), %xmm6
+
+// CHECK: maxpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5f,0x72,0x40]
+maxpd 64(%rdx), %xmm6
+
+// CHECK: maxpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5f,0x32]
+maxpd (%rdx), %xmm6
+
+// CHECK: maxpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5f,0xf6]
+maxpd %xmm6, %xmm6
+
+// CHECK: maxsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+maxsd 485498096, %xmm6
+
+// CHECK: maxsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x74,0x82,0xc0]
+maxsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: maxsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x74,0x82,0x40]
+maxsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: maxsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x74,0x02,0x40]
+maxsd 64(%rdx,%rax), %xmm6
+
+// CHECK: maxsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x72,0x40]
+maxsd 64(%rdx), %xmm6
+
+// CHECK: maxsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5f,0x32]
+maxsd (%rdx), %xmm6
+
+// CHECK: maxsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5f,0xf6]
+maxsd %xmm6, %xmm6
+
+// CHECK: mfence
+// CHECK: encoding: [0x0f,0xae,0xf0]
+mfence
+
+// CHECK: minpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+minpd 485498096, %xmm6
+
+// CHECK: minpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5d,0x74,0x82,0xc0]
+minpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: minpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5d,0x74,0x82,0x40]
+minpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: minpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5d,0x74,0x02,0x40]
+minpd 64(%rdx,%rax), %xmm6
+
+// CHECK: minpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5d,0x72,0x40]
+minpd 64(%rdx), %xmm6
+
+// CHECK: minpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5d,0x32]
+minpd (%rdx), %xmm6
+
+// CHECK: minpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5d,0xf6]
+minpd %xmm6, %xmm6
+
+// CHECK: minsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+minsd 485498096, %xmm6
+
+// CHECK: minsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x74,0x82,0xc0]
+minsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: minsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x74,0x82,0x40]
+minsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: minsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x74,0x02,0x40]
+minsd 64(%rdx,%rax), %xmm6
+
+// CHECK: minsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x72,0x40]
+minsd 64(%rdx), %xmm6
+
+// CHECK: minsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5d,0x32]
+minsd (%rdx), %xmm6
+
+// CHECK: minsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5d,0xf6]
+minsd %xmm6, %xmm6
+
+// CHECK: movapd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x28,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movapd 485498096, %xmm6
+
+// CHECK: movapd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x28,0x74,0x82,0xc0]
+movapd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movapd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x28,0x74,0x82,0x40]
+movapd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movapd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x28,0x74,0x02,0x40]
+movapd 64(%rdx,%rax), %xmm6
+
+// CHECK: movapd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x28,0x72,0x40]
+movapd 64(%rdx), %xmm6
+
+// CHECK: movapd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x28,0x32]
+movapd (%rdx), %xmm6
+
+// CHECK: movapd %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x29,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movapd %xmm6, 485498096
+
+// CHECK: movapd %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x29,0x72,0x40]
+movapd %xmm6, 64(%rdx)
+
+// CHECK: movapd %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x29,0x74,0x02,0x40]
+movapd %xmm6, 64(%rdx,%rax)
+
+// CHECK: movapd %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x29,0x74,0x82,0xc0]
+movapd %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movapd %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x29,0x74,0x82,0x40]
+movapd %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movapd %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x29,0x32]
+movapd %xmm6, (%rdx)
+
+// CHECK: movapd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x28,0xf6]
+movapd %xmm6, %xmm6
+
+// CHECK: movd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movd 485498096, %xmm6
+
+// CHECK: movd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6e,0x74,0x82,0xc0]
+movd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6e,0x74,0x82,0x40]
+movd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6e,0x74,0x02,0x40]
+movd 64(%rdx,%rax), %xmm6
+
+// CHECK: movd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6e,0x72,0x40]
+movd 64(%rdx), %xmm6
+
+// CHECK: movdq2q %xmm6, %mm4
+// CHECK: encoding: [0xf2,0x0f,0xd6,0xe6]
+movdq2q %xmm6, %mm4
+
+// CHECK: movdqa 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movdqa 485498096, %xmm6
+
+// CHECK: movdqa -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6f,0x74,0x82,0xc0]
+movdqa -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movdqa 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6f,0x74,0x82,0x40]
+movdqa 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movdqa 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6f,0x74,0x02,0x40]
+movdqa 64(%rdx,%rax), %xmm6
+
+// CHECK: movdqa 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6f,0x72,0x40]
+movdqa 64(%rdx), %xmm6
+
+// CHECK: movdqa (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6f,0x32]
+movdqa (%rdx), %xmm6
+
+// CHECK: movdqa %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x7f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movdqa %xmm6, 485498096
+
+// CHECK: movdqa %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x72,0x40]
+movdqa %xmm6, 64(%rdx)
+
+// CHECK: movdqa %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x74,0x02,0x40]
+movdqa %xmm6, 64(%rdx,%rax)
+
+// CHECK: movdqa %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x74,0x82,0xc0]
+movdqa %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movdqa %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x74,0x82,0x40]
+movdqa %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movdqa %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x7f,0x32]
+movdqa %xmm6, (%rdx)
+
+// CHECK: movdqa %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6f,0xf6]
+movdqa %xmm6, %xmm6
+
+// CHECK: movdqu 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movdqu 485498096, %xmm6
+
+// CHECK: movdqu -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x74,0x82,0xc0]
+movdqu -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movdqu 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x74,0x82,0x40]
+movdqu 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movdqu 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x74,0x02,0x40]
+movdqu 64(%rdx,%rax), %xmm6
+
+// CHECK: movdqu 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x72,0x40]
+movdqu 64(%rdx), %xmm6
+
+// CHECK: movdqu (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x6f,0x32]
+movdqu (%rdx), %xmm6
+
+// CHECK: movdqu %xmm6, 485498096
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movdqu %xmm6, 485498096
+
+// CHECK: movdqu %xmm6, 64(%rdx)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x72,0x40]
+movdqu %xmm6, 64(%rdx)
+
+// CHECK: movdqu %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x74,0x02,0x40]
+movdqu %xmm6, 64(%rdx,%rax)
+
+// CHECK: movdqu %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x74,0x82,0xc0]
+movdqu %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movdqu %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x74,0x82,0x40]
+movdqu %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movdqu %xmm6, (%rdx)
+// CHECK: encoding: [0xf3,0x0f,0x7f,0x32]
+movdqu %xmm6, (%rdx)
+
+// CHECK: movdqu %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x6f,0xf6]
+movdqu %xmm6, %xmm6
+
+// CHECK: movd %r13d, %xmm6
+// CHECK: encoding: [0x66,0x41,0x0f,0x6e,0xf5]
+movd %r13d, %xmm6
+
+// CHECK: movd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6e,0x32]
+movd (%rdx), %xmm6
+
+// CHECK: movd %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x7e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movd %xmm6, 485498096
+
+// CHECK: movd %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x72,0x40]
+movd %xmm6, 64(%rdx)
+
+// CHECK: movd %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x74,0x02,0x40]
+movd %xmm6, 64(%rdx,%rax)
+
+// CHECK: movd %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x74,0x82,0xc0]
+movd %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movd %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x74,0x82,0x40]
+movd %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movd %xmm6, %r13d
+// CHECK: encoding: [0x66,0x41,0x0f,0x7e,0xf5]
+movd %xmm6, %r13d
+
+// CHECK: movd %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x7e,0x32]
+movd %xmm6, (%rdx)
+
+// CHECK: movhpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x16,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movhpd 485498096, %xmm6
+
+// CHECK: movhpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x16,0x74,0x82,0xc0]
+movhpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movhpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x16,0x74,0x82,0x40]
+movhpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movhpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x16,0x74,0x02,0x40]
+movhpd 64(%rdx,%rax), %xmm6
+
+// CHECK: movhpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x16,0x72,0x40]
+movhpd 64(%rdx), %xmm6
+
+// CHECK: movhpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x16,0x32]
+movhpd (%rdx), %xmm6
+
+// CHECK: movhpd %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x17,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movhpd %xmm6, 485498096
+
+// CHECK: movhpd %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x17,0x72,0x40]
+movhpd %xmm6, 64(%rdx)
+
+// CHECK: movhpd %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x17,0x74,0x02,0x40]
+movhpd %xmm6, 64(%rdx,%rax)
+
+// CHECK: movhpd %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x17,0x74,0x82,0xc0]
+movhpd %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movhpd %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x17,0x74,0x82,0x40]
+movhpd %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movhpd %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x17,0x32]
+movhpd %xmm6, (%rdx)
+
+// CHECK: movlpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x12,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movlpd 485498096, %xmm6
+
+// CHECK: movlpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x12,0x74,0x82,0xc0]
+movlpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movlpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x12,0x74,0x82,0x40]
+movlpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movlpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x12,0x74,0x02,0x40]
+movlpd 64(%rdx,%rax), %xmm6
+
+// CHECK: movlpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x12,0x72,0x40]
+movlpd 64(%rdx), %xmm6
+
+// CHECK: movlpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x12,0x32]
+movlpd (%rdx), %xmm6
+
+// CHECK: movlpd %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x13,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movlpd %xmm6, 485498096
+
+// CHECK: movlpd %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x13,0x72,0x40]
+movlpd %xmm6, 64(%rdx)
+
+// CHECK: movlpd %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x13,0x74,0x02,0x40]
+movlpd %xmm6, 64(%rdx,%rax)
+
+// CHECK: movlpd %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x13,0x74,0x82,0xc0]
+movlpd %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movlpd %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x13,0x74,0x82,0x40]
+movlpd %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movlpd %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x13,0x32]
+movlpd %xmm6, (%rdx)
+
+// CHECK: movmskpd %xmm6, %r13d
+// CHECK: encoding: [0x66,0x44,0x0f,0x50,0xee]
+movmskpd %xmm6, %r13d
+
+// CHECK: movntdq %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0xe7,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntdq %xmm6, 485498096
+
+// CHECK: movntdq %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x72,0x40]
+movntdq %xmm6, 64(%rdx)
+
+// CHECK: movntdq %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x74,0x02,0x40]
+movntdq %xmm6, 64(%rdx,%rax)
+
+// CHECK: movntdq %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x74,0x82,0xc0]
+movntdq %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movntdq %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x74,0x82,0x40]
+movntdq %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movntdq %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0xe7,0x32]
+movntdq %xmm6, (%rdx)
+
+// CHECK: movntil %r13d, 485498096
+// CHECK: encoding: [0x44,0x0f,0xc3,0x2c,0x25,0xf0,0x1c,0xf0,0x1c]
+movntil %r13d, 485498096
+
+// CHECK: movntil %r13d, 64(%rdx)
+// CHECK: encoding: [0x44,0x0f,0xc3,0x6a,0x40]
+movntil %r13d, 64(%rdx)
+
+// CHECK: movntil %r13d, 64(%rdx,%rax)
+// CHECK: encoding: [0x44,0x0f,0xc3,0x6c,0x02,0x40]
+movntil %r13d, 64(%rdx,%rax)
+
+// CHECK: movntil %r13d, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x44,0x0f,0xc3,0x6c,0x82,0xc0]
+movntil %r13d, -64(%rdx,%rax,4)
+
+// CHECK: movntil %r13d, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x44,0x0f,0xc3,0x6c,0x82,0x40]
+movntil %r13d, 64(%rdx,%rax,4)
+
+// CHECK: movntil %r13d, (%rdx)
+// CHECK: encoding: [0x44,0x0f,0xc3,0x2a]
+movntil %r13d, (%rdx)
+
+// CHECK: movntpd %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x2b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntpd %xmm6, 485498096
+
+// CHECK: movntpd %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x72,0x40]
+movntpd %xmm6, 64(%rdx)
+
+// CHECK: movntpd %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x74,0x02,0x40]
+movntpd %xmm6, 64(%rdx,%rax)
+
+// CHECK: movntpd %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x74,0x82,0xc0]
+movntpd %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movntpd %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x74,0x82,0x40]
+movntpd %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movntpd %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x2b,0x32]
+movntpd %xmm6, (%rdx)
+
+// CHECK: movq2dq %mm4, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0xd6,0xf4]
+movq2dq %mm4, %xmm6
+
+// CHECK: movq 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movq 485498096, %xmm6
+
+// CHECK: movq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x74,0x82,0xc0]
+movq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x74,0x82,0x40]
+movq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x74,0x02,0x40]
+movq 64(%rdx,%rax), %xmm6
+
+// CHECK: movq 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x72,0x40]
+movq 64(%rdx), %xmm6
+
+// CHECK: movq %r15, %xmm6
+// CHECK: encoding: [0x66,0x49,0x0f,0x6e,0xf7]
+movq %r15, %xmm6
+
+// CHECK: movq (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x7e,0x32]
+movq (%rdx), %xmm6
+
+// CHECK: movq %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0xd6,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movq %xmm6, 485498096
+
+// CHECK: movq %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x72,0x40]
+movq %xmm6, 64(%rdx)
+
+// CHECK: movq %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x74,0x02,0x40]
+movq %xmm6, 64(%rdx,%rax)
+
+// CHECK: movq %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x74,0x82,0xc0]
+movq %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movq %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x74,0x82,0x40]
+movq %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movq %xmm6, %r15
+// CHECK: encoding: [0x66,0x49,0x0f,0x7e,0xf7]
+movq %xmm6, %r15
+
+// CHECK: movq %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0xd6,0x32]
+movq %xmm6, (%rdx)
+
+// CHECK: movq %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x7e,0xf6]
+movq %xmm6, %xmm6
+
+// CHECK: movsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x10,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movsd 485498096, %xmm6
+
+// CHECK: movsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x10,0x74,0x82,0xc0]
+movsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x10,0x74,0x82,0x40]
+movsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x10,0x74,0x02,0x40]
+movsd 64(%rdx,%rax), %xmm6
+
+// CHECK: movsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x10,0x72,0x40]
+movsd 64(%rdx), %xmm6
+
+// CHECK: movsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x10,0x32]
+movsd (%rdx), %xmm6
+
+// CHECK: movsd %xmm6, 485498096
+// CHECK: encoding: [0xf2,0x0f,0x11,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movsd %xmm6, 485498096
+
+// CHECK: movsd %xmm6, 64(%rdx)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x72,0x40]
+movsd %xmm6, 64(%rdx)
+
+// CHECK: movsd %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x74,0x02,0x40]
+movsd %xmm6, 64(%rdx,%rax)
+
+// CHECK: movsd %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x74,0x82,0xc0]
+movsd %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movsd %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x74,0x82,0x40]
+movsd %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movsd %xmm6, (%rdx)
+// CHECK: encoding: [0xf2,0x0f,0x11,0x32]
+movsd %xmm6, (%rdx)
+
+// CHECK: movsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x10,0xf6]
+movsd %xmm6, %xmm6
+
+// CHECK: movupd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x10,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movupd 485498096, %xmm6
+
+// CHECK: movupd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x10,0x74,0x82,0xc0]
+movupd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movupd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x10,0x74,0x82,0x40]
+movupd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movupd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x10,0x74,0x02,0x40]
+movupd 64(%rdx,%rax), %xmm6
+
+// CHECK: movupd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x10,0x72,0x40]
+movupd 64(%rdx), %xmm6
+
+// CHECK: movupd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x10,0x32]
+movupd (%rdx), %xmm6
+
+// CHECK: movupd %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x11,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movupd %xmm6, 485498096
+
+// CHECK: movupd %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x11,0x72,0x40]
+movupd %xmm6, 64(%rdx)
+
+// CHECK: movupd %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x11,0x74,0x02,0x40]
+movupd %xmm6, 64(%rdx,%rax)
+
+// CHECK: movupd %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x11,0x74,0x82,0xc0]
+movupd %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: movupd %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x11,0x74,0x82,0x40]
+movupd %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: movupd %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x11,0x32]
+movupd %xmm6, (%rdx)
+
+// CHECK: movupd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x10,0xf6]
+movupd %xmm6, %xmm6
+
+// CHECK: mulpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x59,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+mulpd 485498096, %xmm6
+
+// CHECK: mulpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x59,0x74,0x82,0xc0]
+mulpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: mulpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x59,0x74,0x82,0x40]
+mulpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: mulpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x59,0x74,0x02,0x40]
+mulpd 64(%rdx,%rax), %xmm6
+
+// CHECK: mulpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x59,0x72,0x40]
+mulpd 64(%rdx), %xmm6
+
+// CHECK: mulpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x59,0x32]
+mulpd (%rdx), %xmm6
+
+// CHECK: mulpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x59,0xf6]
+mulpd %xmm6, %xmm6
+
+// CHECK: mulsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x59,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+mulsd 485498096, %xmm6
+
+// CHECK: mulsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x59,0x74,0x82,0xc0]
+mulsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: mulsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x59,0x74,0x82,0x40]
+mulsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: mulsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x59,0x74,0x02,0x40]
+mulsd 64(%rdx,%rax), %xmm6
+
+// CHECK: mulsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x59,0x72,0x40]
+mulsd 64(%rdx), %xmm6
+
+// CHECK: mulsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x59,0x32]
+mulsd (%rdx), %xmm6
+
+// CHECK: mulsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x59,0xf6]
+mulsd %xmm6, %xmm6
+
+// CHECK: orpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x56,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+orpd 485498096, %xmm6
+
+// CHECK: orpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x56,0x74,0x82,0xc0]
+orpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: orpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x56,0x74,0x82,0x40]
+orpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: orpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x56,0x74,0x02,0x40]
+orpd 64(%rdx,%rax), %xmm6
+
+// CHECK: orpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x56,0x72,0x40]
+orpd 64(%rdx), %xmm6
+
+// CHECK: orpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x56,0x32]
+orpd (%rdx), %xmm6
+
+// CHECK: orpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x56,0xf6]
+orpd %xmm6, %xmm6
+
+// CHECK: packssdw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+packssdw 485498096, %xmm6
+
+// CHECK: packssdw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6b,0x74,0x82,0xc0]
+packssdw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: packssdw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6b,0x74,0x82,0x40]
+packssdw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: packssdw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6b,0x74,0x02,0x40]
+packssdw 64(%rdx,%rax), %xmm6
+
+// CHECK: packssdw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6b,0x72,0x40]
+packssdw 64(%rdx), %xmm6
+
+// CHECK: packssdw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6b,0x32]
+packssdw (%rdx), %xmm6
+
+// CHECK: packssdw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6b,0xf6]
+packssdw %xmm6, %xmm6
+
+// CHECK: packsswb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x63,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+packsswb 485498096, %xmm6
+
+// CHECK: packsswb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x63,0x74,0x82,0xc0]
+packsswb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: packsswb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x63,0x74,0x82,0x40]
+packsswb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: packsswb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x63,0x74,0x02,0x40]
+packsswb 64(%rdx,%rax), %xmm6
+
+// CHECK: packsswb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x63,0x72,0x40]
+packsswb 64(%rdx), %xmm6
+
+// CHECK: packsswb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x63,0x32]
+packsswb (%rdx), %xmm6
+
+// CHECK: packsswb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x63,0xf6]
+packsswb %xmm6, %xmm6
+
+// CHECK: packuswb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x67,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+packuswb 485498096, %xmm6
+
+// CHECK: packuswb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x67,0x74,0x82,0xc0]
+packuswb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: packuswb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x67,0x74,0x82,0x40]
+packuswb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: packuswb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x67,0x74,0x02,0x40]
+packuswb 64(%rdx,%rax), %xmm6
+
+// CHECK: packuswb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x67,0x72,0x40]
+packuswb 64(%rdx), %xmm6
+
+// CHECK: packuswb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x67,0x32]
+packuswb (%rdx), %xmm6
+
+// CHECK: packuswb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x67,0xf6]
+packuswb %xmm6, %xmm6
+
+// CHECK: paddb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfc,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+paddb 485498096, %xmm6
+
+// CHECK: paddb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfc,0x74,0x82,0xc0]
+paddb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfc,0x74,0x82,0x40]
+paddb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfc,0x74,0x02,0x40]
+paddb 64(%rdx,%rax), %xmm6
+
+// CHECK: paddb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfc,0x72,0x40]
+paddb 64(%rdx), %xmm6
+
+// CHECK: paddb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfc,0x32]
+paddb (%rdx), %xmm6
+
+// CHECK: paddb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfc,0xf6]
+paddb %xmm6, %xmm6
+
+// CHECK: paddd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfe,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+paddd 485498096, %xmm6
+
+// CHECK: paddd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfe,0x74,0x82,0xc0]
+paddd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfe,0x74,0x82,0x40]
+paddd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfe,0x74,0x02,0x40]
+paddd 64(%rdx,%rax), %xmm6
+
+// CHECK: paddd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfe,0x72,0x40]
+paddd 64(%rdx), %xmm6
+
+// CHECK: paddd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfe,0x32]
+paddd (%rdx), %xmm6
+
+// CHECK: paddd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfe,0xf6]
+paddd %xmm6, %xmm6
+
+// CHECK: paddq 485498096, %mm4
+// CHECK: encoding: [0x0f,0xd4,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+paddq 485498096, %mm4
+
+// CHECK: paddq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd4,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+paddq 485498096, %xmm6
+
+// CHECK: paddq 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0xd4,0x62,0x40]
+paddq 64(%rdx), %mm4
+
+// CHECK: paddq -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0xd4,0x64,0x82,0xc0]
+paddq -64(%rdx,%rax,4), %mm4
+
+// CHECK: paddq 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0xd4,0x64,0x82,0x40]
+paddq 64(%rdx,%rax,4), %mm4
+
+// CHECK: paddq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd4,0x74,0x82,0xc0]
+paddq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd4,0x74,0x82,0x40]
+paddq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddq 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0xd4,0x64,0x02,0x40]
+paddq 64(%rdx,%rax), %mm4
+
+// CHECK: paddq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd4,0x74,0x02,0x40]
+paddq 64(%rdx,%rax), %xmm6
+
+// CHECK: paddq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd4,0x72,0x40]
+paddq 64(%rdx), %xmm6
+
+// CHECK: paddq %mm4, %mm4
+// CHECK: encoding: [0x0f,0xd4,0xe4]
+paddq %mm4, %mm4
+
+// CHECK: paddq (%rdx), %mm4
+// CHECK: encoding: [0x0f,0xd4,0x22]
+paddq (%rdx), %mm4
+
+// CHECK: paddq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd4,0x32]
+paddq (%rdx), %xmm6
+
+// CHECK: paddq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd4,0xf6]
+paddq %xmm6, %xmm6
+
+// CHECK: paddsb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xec,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+paddsb 485498096, %xmm6
+
+// CHECK: paddsb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xec,0x74,0x82,0xc0]
+paddsb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddsb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xec,0x74,0x82,0x40]
+paddsb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddsb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xec,0x74,0x02,0x40]
+paddsb 64(%rdx,%rax), %xmm6
+
+// CHECK: paddsb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xec,0x72,0x40]
+paddsb 64(%rdx), %xmm6
+
+// CHECK: paddsb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xec,0x32]
+paddsb (%rdx), %xmm6
+
+// CHECK: paddsb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xec,0xf6]
+paddsb %xmm6, %xmm6
+
+// CHECK: paddsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xed,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+paddsw 485498096, %xmm6
+
+// CHECK: paddsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xed,0x74,0x82,0xc0]
+paddsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xed,0x74,0x82,0x40]
+paddsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xed,0x74,0x02,0x40]
+paddsw 64(%rdx,%rax), %xmm6
+
+// CHECK: paddsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xed,0x72,0x40]
+paddsw 64(%rdx), %xmm6
+
+// CHECK: paddsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xed,0x32]
+paddsw (%rdx), %xmm6
+
+// CHECK: paddsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xed,0xf6]
+paddsw %xmm6, %xmm6
+
+// CHECK: paddusb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdc,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+paddusb 485498096, %xmm6
+
+// CHECK: paddusb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdc,0x74,0x82,0xc0]
+paddusb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddusb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdc,0x74,0x82,0x40]
+paddusb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddusb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdc,0x74,0x02,0x40]
+paddusb 64(%rdx,%rax), %xmm6
+
+// CHECK: paddusb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdc,0x72,0x40]
+paddusb 64(%rdx), %xmm6
+
+// CHECK: paddusb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdc,0x32]
+paddusb (%rdx), %xmm6
+
+// CHECK: paddusb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdc,0xf6]
+paddusb %xmm6, %xmm6
+
+// CHECK: paddusw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdd,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+paddusw 485498096, %xmm6
+
+// CHECK: paddusw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdd,0x74,0x82,0xc0]
+paddusw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddusw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdd,0x74,0x82,0x40]
+paddusw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddusw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdd,0x74,0x02,0x40]
+paddusw 64(%rdx,%rax), %xmm6
+
+// CHECK: paddusw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdd,0x72,0x40]
+paddusw 64(%rdx), %xmm6
+
+// CHECK: paddusw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdd,0x32]
+paddusw (%rdx), %xmm6
+
+// CHECK: paddusw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdd,0xf6]
+paddusw %xmm6, %xmm6
+
+// CHECK: paddw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfd,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+paddw 485498096, %xmm6
+
+// CHECK: paddw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfd,0x74,0x82,0xc0]
+paddw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfd,0x74,0x82,0x40]
+paddw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: paddw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfd,0x74,0x02,0x40]
+paddw 64(%rdx,%rax), %xmm6
+
+// CHECK: paddw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfd,0x72,0x40]
+paddw 64(%rdx), %xmm6
+
+// CHECK: paddw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfd,0x32]
+paddw (%rdx), %xmm6
+
+// CHECK: paddw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfd,0xf6]
+paddw %xmm6, %xmm6
+
+// CHECK: pand 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdb,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pand 485498096, %xmm6
+
+// CHECK: pand -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdb,0x74,0x82,0xc0]
+pand -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pand 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdb,0x74,0x82,0x40]
+pand 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pand 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdb,0x74,0x02,0x40]
+pand 64(%rdx,%rax), %xmm6
+
+// CHECK: pand 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdb,0x72,0x40]
+pand 64(%rdx), %xmm6
+
+// CHECK: pandn 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdf,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pandn 485498096, %xmm6
+
+// CHECK: pandn -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdf,0x74,0x82,0xc0]
+pandn -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pandn 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdf,0x74,0x82,0x40]
+pandn 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pandn 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdf,0x74,0x02,0x40]
+pandn 64(%rdx,%rax), %xmm6
+
+// CHECK: pandn 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdf,0x72,0x40]
+pandn 64(%rdx), %xmm6
+
+// CHECK: pandn (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdf,0x32]
+pandn (%rdx), %xmm6
+
+// CHECK: pandn %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdf,0xf6]
+pandn %xmm6, %xmm6
+
+// CHECK: pand (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdb,0x32]
+pand (%rdx), %xmm6
+
+// CHECK: pand %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xdb,0xf6]
+pand %xmm6, %xmm6
+
+// CHECK: pavgb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe0,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pavgb 485498096, %xmm6
+
+// CHECK: pavgb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe0,0x74,0x82,0xc0]
+pavgb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pavgb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe0,0x74,0x82,0x40]
+pavgb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pavgb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe0,0x74,0x02,0x40]
+pavgb 64(%rdx,%rax), %xmm6
+
+// CHECK: pavgb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe0,0x72,0x40]
+pavgb 64(%rdx), %xmm6
+
+// CHECK: pavgb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe0,0x32]
+pavgb (%rdx), %xmm6
+
+// CHECK: pavgb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe0,0xf6]
+pavgb %xmm6, %xmm6
+
+// CHECK: pavgw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe3,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pavgw 485498096, %xmm6
+
+// CHECK: pavgw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe3,0x74,0x82,0xc0]
+pavgw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pavgw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe3,0x74,0x82,0x40]
+pavgw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pavgw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe3,0x74,0x02,0x40]
+pavgw 64(%rdx,%rax), %xmm6
+
+// CHECK: pavgw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe3,0x72,0x40]
+pavgw 64(%rdx), %xmm6
+
+// CHECK: pavgw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe3,0x32]
+pavgw (%rdx), %xmm6
+
+// CHECK: pavgw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe3,0xf6]
+pavgw %xmm6, %xmm6
+
+// CHECK: pcmpeqb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x74,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pcmpeqb 485498096, %xmm6
+
+// CHECK: pcmpeqb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x74,0x74,0x82,0xc0]
+pcmpeqb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpeqb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x74,0x74,0x82,0x40]
+pcmpeqb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpeqb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x74,0x74,0x02,0x40]
+pcmpeqb 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpeqb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x74,0x72,0x40]
+pcmpeqb 64(%rdx), %xmm6
+
+// CHECK: pcmpeqb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x74,0x32]
+pcmpeqb (%rdx), %xmm6
+
+// CHECK: pcmpeqb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x74,0xf6]
+pcmpeqb %xmm6, %xmm6
+
+// CHECK: pcmpeqd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x76,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pcmpeqd 485498096, %xmm6
+
+// CHECK: pcmpeqd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x76,0x74,0x82,0xc0]
+pcmpeqd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpeqd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x76,0x74,0x82,0x40]
+pcmpeqd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpeqd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x76,0x74,0x02,0x40]
+pcmpeqd 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpeqd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x76,0x72,0x40]
+pcmpeqd 64(%rdx), %xmm6
+
+// CHECK: pcmpeqd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x76,0x32]
+pcmpeqd (%rdx), %xmm6
+
+// CHECK: pcmpeqd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x76,0xf6]
+pcmpeqd %xmm6, %xmm6
+
+// CHECK: pcmpeqw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x75,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pcmpeqw 485498096, %xmm6
+
+// CHECK: pcmpeqw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x75,0x74,0x82,0xc0]
+pcmpeqw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpeqw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x75,0x74,0x82,0x40]
+pcmpeqw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpeqw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x75,0x74,0x02,0x40]
+pcmpeqw 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpeqw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x75,0x72,0x40]
+pcmpeqw 64(%rdx), %xmm6
+
+// CHECK: pcmpeqw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x75,0x32]
+pcmpeqw (%rdx), %xmm6
+
+// CHECK: pcmpeqw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x75,0xf6]
+pcmpeqw %xmm6, %xmm6
+
+// CHECK: pcmpgtb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x64,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pcmpgtb 485498096, %xmm6
+
+// CHECK: pcmpgtb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x64,0x74,0x82,0xc0]
+pcmpgtb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpgtb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x64,0x74,0x82,0x40]
+pcmpgtb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpgtb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x64,0x74,0x02,0x40]
+pcmpgtb 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpgtb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x64,0x72,0x40]
+pcmpgtb 64(%rdx), %xmm6
+
+// CHECK: pcmpgtb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x64,0x32]
+pcmpgtb (%rdx), %xmm6
+
+// CHECK: pcmpgtb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x64,0xf6]
+pcmpgtb %xmm6, %xmm6
+
+// CHECK: pcmpgtd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x66,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pcmpgtd 485498096, %xmm6
+
+// CHECK: pcmpgtd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x66,0x74,0x82,0xc0]
+pcmpgtd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpgtd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x66,0x74,0x82,0x40]
+pcmpgtd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpgtd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x66,0x74,0x02,0x40]
+pcmpgtd 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpgtd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x66,0x72,0x40]
+pcmpgtd 64(%rdx), %xmm6
+
+// CHECK: pcmpgtd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x66,0x32]
+pcmpgtd (%rdx), %xmm6
+
+// CHECK: pcmpgtd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x66,0xf6]
+pcmpgtd %xmm6, %xmm6
+
+// CHECK: pcmpgtw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x65,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pcmpgtw 485498096, %xmm6
+
+// CHECK: pcmpgtw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x65,0x74,0x82,0xc0]
+pcmpgtw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpgtw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x65,0x74,0x82,0x40]
+pcmpgtw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpgtw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x65,0x74,0x02,0x40]
+pcmpgtw 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpgtw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x65,0x72,0x40]
+pcmpgtw 64(%rdx), %xmm6
+
+// CHECK: pcmpgtw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x65,0x32]
+pcmpgtw (%rdx), %xmm6
+
+// CHECK: pcmpgtw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x65,0xf6]
+pcmpgtw %xmm6, %xmm6
+
+// CHECK: pextrw $0, %xmm6, %r13d
+// CHECK: encoding: [0x66,0x44,0x0f,0xc5,0xee,0x00]
+pextrw $0, %xmm6, %r13d
+
+// CHECK: pinsrw $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc4,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrw $0, 485498096, %xmm6
+
+// CHECK: pinsrw $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc4,0x74,0x82,0xc0,0x00]
+pinsrw $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pinsrw $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc4,0x74,0x82,0x40,0x00]
+pinsrw $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pinsrw $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc4,0x74,0x02,0x40,0x00]
+pinsrw $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pinsrw $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc4,0x72,0x40,0x00]
+pinsrw $0, 64(%rdx), %xmm6
+
+// CHECK: pinsrw $0, %r13d, %xmm6
+// CHECK: encoding: [0x66,0x41,0x0f,0xc4,0xf5,0x00]
+pinsrw $0, %r13d, %xmm6
+
+// CHECK: pinsrw $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc4,0x32,0x00]
+pinsrw $0, (%rdx), %xmm6
+
+// CHECK: pmaddwd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf5,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaddwd 485498096, %xmm6
+
+// CHECK: pmaddwd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf5,0x74,0x82,0xc0]
+pmaddwd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaddwd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf5,0x74,0x82,0x40]
+pmaddwd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaddwd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf5,0x74,0x02,0x40]
+pmaddwd 64(%rdx,%rax), %xmm6
+
+// CHECK: pmaddwd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf5,0x72,0x40]
+pmaddwd 64(%rdx), %xmm6
+
+// CHECK: pmaddwd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf5,0x32]
+pmaddwd (%rdx), %xmm6
+
+// CHECK: pmaddwd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf5,0xf6]
+pmaddwd %xmm6, %xmm6
+
+// CHECK: pmaxsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xee,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaxsw 485498096, %xmm6
+
+// CHECK: pmaxsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xee,0x74,0x82,0xc0]
+pmaxsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xee,0x74,0x82,0x40]
+pmaxsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xee,0x74,0x02,0x40]
+pmaxsw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmaxsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xee,0x72,0x40]
+pmaxsw 64(%rdx), %xmm6
+
+// CHECK: pmaxsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xee,0x32]
+pmaxsw (%rdx), %xmm6
+
+// CHECK: pmaxsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xee,0xf6]
+pmaxsw %xmm6, %xmm6
+
+// CHECK: pmaxub 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xde,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaxub 485498096, %xmm6
+
+// CHECK: pmaxub -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xde,0x74,0x82,0xc0]
+pmaxub -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxub 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xde,0x74,0x82,0x40]
+pmaxub 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxub 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xde,0x74,0x02,0x40]
+pmaxub 64(%rdx,%rax), %xmm6
+
+// CHECK: pmaxub 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xde,0x72,0x40]
+pmaxub 64(%rdx), %xmm6
+
+// CHECK: pmaxub (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xde,0x32]
+pmaxub (%rdx), %xmm6
+
+// CHECK: pmaxub %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xde,0xf6]
+pmaxub %xmm6, %xmm6
+
+// CHECK: pminsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xea,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pminsw 485498096, %xmm6
+
+// CHECK: pminsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xea,0x74,0x82,0xc0]
+pminsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xea,0x74,0x82,0x40]
+pminsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xea,0x74,0x02,0x40]
+pminsw 64(%rdx,%rax), %xmm6
+
+// CHECK: pminsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xea,0x72,0x40]
+pminsw 64(%rdx), %xmm6
+
+// CHECK: pminsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xea,0x32]
+pminsw (%rdx), %xmm6
+
+// CHECK: pminsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xea,0xf6]
+pminsw %xmm6, %xmm6
+
+// CHECK: pminub 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xda,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pminub 485498096, %xmm6
+
+// CHECK: pminub -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xda,0x74,0x82,0xc0]
+pminub -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminub 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xda,0x74,0x82,0x40]
+pminub 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminub 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xda,0x74,0x02,0x40]
+pminub 64(%rdx,%rax), %xmm6
+
+// CHECK: pminub 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xda,0x72,0x40]
+pminub 64(%rdx), %xmm6
+
+// CHECK: pminub (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xda,0x32]
+pminub (%rdx), %xmm6
+
+// CHECK: pminub %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xda,0xf6]
+pminub %xmm6, %xmm6
+
+// CHECK: pmovmskb %xmm6, %r13d
+// CHECK: encoding: [0x66,0x44,0x0f,0xd7,0xee]
+pmovmskb %xmm6, %r13d
+
+// CHECK: pmulhuw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe4,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmulhuw 485498096, %xmm6
+
+// CHECK: pmulhuw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe4,0x74,0x82,0xc0]
+pmulhuw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmulhuw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe4,0x74,0x82,0x40]
+pmulhuw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmulhuw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe4,0x74,0x02,0x40]
+pmulhuw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmulhuw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe4,0x72,0x40]
+pmulhuw 64(%rdx), %xmm6
+
+// CHECK: pmulhuw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe4,0x32]
+pmulhuw (%rdx), %xmm6
+
+// CHECK: pmulhuw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe4,0xf6]
+pmulhuw %xmm6, %xmm6
+
+// CHECK: pmulhw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe5,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmulhw 485498096, %xmm6
+
+// CHECK: pmulhw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe5,0x74,0x82,0xc0]
+pmulhw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmulhw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe5,0x74,0x82,0x40]
+pmulhw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmulhw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe5,0x74,0x02,0x40]
+pmulhw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmulhw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe5,0x72,0x40]
+pmulhw 64(%rdx), %xmm6
+
+// CHECK: pmulhw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe5,0x32]
+pmulhw (%rdx), %xmm6
+
+// CHECK: pmulhw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe5,0xf6]
+pmulhw %xmm6, %xmm6
+
+// CHECK: pmullw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd5,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmullw 485498096, %xmm6
+
+// CHECK: pmullw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd5,0x74,0x82,0xc0]
+pmullw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmullw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd5,0x74,0x82,0x40]
+pmullw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmullw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd5,0x74,0x02,0x40]
+pmullw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmullw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd5,0x72,0x40]
+pmullw 64(%rdx), %xmm6
+
+// CHECK: pmullw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd5,0x32]
+pmullw (%rdx), %xmm6
+
+// CHECK: pmullw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd5,0xf6]
+pmullw %xmm6, %xmm6
+
+// CHECK: pmuludq 485498096, %mm4
+// CHECK: encoding: [0x0f,0xf4,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+pmuludq 485498096, %mm4
+
+// CHECK: pmuludq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf4,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmuludq 485498096, %xmm6
+
+// CHECK: pmuludq 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0xf4,0x62,0x40]
+pmuludq 64(%rdx), %mm4
+
+// CHECK: pmuludq -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0xf4,0x64,0x82,0xc0]
+pmuludq -64(%rdx,%rax,4), %mm4
+
+// CHECK: pmuludq 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0xf4,0x64,0x82,0x40]
+pmuludq 64(%rdx,%rax,4), %mm4
+
+// CHECK: pmuludq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf4,0x74,0x82,0xc0]
+pmuludq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmuludq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf4,0x74,0x82,0x40]
+pmuludq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmuludq 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0xf4,0x64,0x02,0x40]
+pmuludq 64(%rdx,%rax), %mm4
+
+// CHECK: pmuludq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf4,0x74,0x02,0x40]
+pmuludq 64(%rdx,%rax), %xmm6
+
+// CHECK: pmuludq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf4,0x72,0x40]
+pmuludq 64(%rdx), %xmm6
+
+// CHECK: pmuludq %mm4, %mm4
+// CHECK: encoding: [0x0f,0xf4,0xe4]
+pmuludq %mm4, %mm4
+
+// CHECK: pmuludq (%rdx), %mm4
+// CHECK: encoding: [0x0f,0xf4,0x22]
+pmuludq (%rdx), %mm4
+
+// CHECK: pmuludq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf4,0x32]
+pmuludq (%rdx), %xmm6
+
+// CHECK: pmuludq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf4,0xf6]
+pmuludq %xmm6, %xmm6
+
+// CHECK: por 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xeb,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+por 485498096, %xmm6
+
+// CHECK: por -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xeb,0x74,0x82,0xc0]
+por -64(%rdx,%rax,4), %xmm6
+
+// CHECK: por 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xeb,0x74,0x82,0x40]
+por 64(%rdx,%rax,4), %xmm6
+
+// CHECK: por 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xeb,0x74,0x02,0x40]
+por 64(%rdx,%rax), %xmm6
+
+// CHECK: por 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xeb,0x72,0x40]
+por 64(%rdx), %xmm6
+
+// CHECK: por (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xeb,0x32]
+por (%rdx), %xmm6
+
+// CHECK: por %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xeb,0xf6]
+por %xmm6, %xmm6
+
+// CHECK: psadbw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf6,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psadbw 485498096, %xmm6
+
+// CHECK: psadbw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf6,0x74,0x82,0xc0]
+psadbw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psadbw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf6,0x74,0x82,0x40]
+psadbw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psadbw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf6,0x74,0x02,0x40]
+psadbw 64(%rdx,%rax), %xmm6
+
+// CHECK: psadbw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf6,0x72,0x40]
+psadbw 64(%rdx), %xmm6
+
+// CHECK: psadbw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf6,0x32]
+psadbw (%rdx), %xmm6
+
+// CHECK: psadbw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf6,0xf6]
+psadbw %xmm6, %xmm6
+
+// CHECK: pshufd $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x70,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pshufd $0, 485498096, %xmm6
+
+// CHECK: pshufd $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x70,0x74,0x82,0xc0,0x00]
+pshufd $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pshufd $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x70,0x74,0x82,0x40,0x00]
+pshufd $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pshufd $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x70,0x74,0x02,0x40,0x00]
+pshufd $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pshufd $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x70,0x72,0x40,0x00]
+pshufd $0, 64(%rdx), %xmm6
+
+// CHECK: pshufd $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x70,0x32,0x00]
+pshufd $0, (%rdx), %xmm6
+
+// CHECK: pshufd $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x70,0xf6,0x00]
+pshufd $0, %xmm6, %xmm6
+
+// CHECK: pshufhw $0, 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x70,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pshufhw $0, 485498096, %xmm6
+
+// CHECK: pshufhw $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x70,0x74,0x82,0xc0,0x00]
+pshufhw $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pshufhw $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x70,0x74,0x82,0x40,0x00]
+pshufhw $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pshufhw $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x70,0x74,0x02,0x40,0x00]
+pshufhw $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pshufhw $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x70,0x72,0x40,0x00]
+pshufhw $0, 64(%rdx), %xmm6
+
+// CHECK: pshufhw $0, (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x70,0x32,0x00]
+pshufhw $0, (%rdx), %xmm6
+
+// CHECK: pshufhw $0, %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x70,0xf6,0x00]
+pshufhw $0, %xmm6, %xmm6
+
+// CHECK: pshuflw $0, 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x70,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pshuflw $0, 485498096, %xmm6
+
+// CHECK: pshuflw $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x70,0x74,0x82,0xc0,0x00]
+pshuflw $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pshuflw $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x70,0x74,0x82,0x40,0x00]
+pshuflw $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pshuflw $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x70,0x74,0x02,0x40,0x00]
+pshuflw $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pshuflw $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x70,0x72,0x40,0x00]
+pshuflw $0, 64(%rdx), %xmm6
+
+// CHECK: pshuflw $0, (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x70,0x32,0x00]
+pshuflw $0, (%rdx), %xmm6
+
+// CHECK: pshuflw $0, %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x70,0xf6,0x00]
+pshuflw $0, %xmm6, %xmm6
+
+// CHECK: pslld $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x72,0xf6,0x00]
+pslld $0, %xmm6
+
+// CHECK: pslld 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf2,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pslld 485498096, %xmm6
+
+// CHECK: pslld -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf2,0x74,0x82,0xc0]
+pslld -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pslld 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf2,0x74,0x82,0x40]
+pslld 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pslld 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf2,0x74,0x02,0x40]
+pslld 64(%rdx,%rax), %xmm6
+
+// CHECK: pslld 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf2,0x72,0x40]
+pslld 64(%rdx), %xmm6
+
+// CHECK: pslldq $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x73,0xfe,0x00]
+pslldq $0, %xmm6
+
+// CHECK: pslld (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf2,0x32]
+pslld (%rdx), %xmm6
+
+// CHECK: pslld %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf2,0xf6]
+pslld %xmm6, %xmm6
+
+// CHECK: psllq $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x73,0xf6,0x00]
+psllq $0, %xmm6
+
+// CHECK: psllq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf3,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psllq 485498096, %xmm6
+
+// CHECK: psllq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf3,0x74,0x82,0xc0]
+psllq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psllq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf3,0x74,0x82,0x40]
+psllq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psllq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf3,0x74,0x02,0x40]
+psllq 64(%rdx,%rax), %xmm6
+
+// CHECK: psllq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf3,0x72,0x40]
+psllq 64(%rdx), %xmm6
+
+// CHECK: psllq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf3,0x32]
+psllq (%rdx), %xmm6
+
+// CHECK: psllq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf3,0xf6]
+psllq %xmm6, %xmm6
+
+// CHECK: psllw $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x71,0xf6,0x00]
+psllw $0, %xmm6
+
+// CHECK: psllw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf1,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psllw 485498096, %xmm6
+
+// CHECK: psllw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf1,0x74,0x82,0xc0]
+psllw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psllw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf1,0x74,0x82,0x40]
+psllw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psllw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf1,0x74,0x02,0x40]
+psllw 64(%rdx,%rax), %xmm6
+
+// CHECK: psllw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf1,0x72,0x40]
+psllw 64(%rdx), %xmm6
+
+// CHECK: psllw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf1,0x32]
+psllw (%rdx), %xmm6
+
+// CHECK: psllw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf1,0xf6]
+psllw %xmm6, %xmm6
+
+// CHECK: psrad $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x72,0xe6,0x00]
+psrad $0, %xmm6
+
+// CHECK: psrad 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe2,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psrad 485498096, %xmm6
+
+// CHECK: psrad -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe2,0x74,0x82,0xc0]
+psrad -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psrad 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe2,0x74,0x82,0x40]
+psrad 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psrad 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe2,0x74,0x02,0x40]
+psrad 64(%rdx,%rax), %xmm6
+
+// CHECK: psrad 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe2,0x72,0x40]
+psrad 64(%rdx), %xmm6
+
+// CHECK: psrad (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe2,0x32]
+psrad (%rdx), %xmm6
+
+// CHECK: psrad %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe2,0xf6]
+psrad %xmm6, %xmm6
+
+// CHECK: psraw $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x71,0xe6,0x00]
+psraw $0, %xmm6
+
+// CHECK: psraw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe1,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psraw 485498096, %xmm6
+
+// CHECK: psraw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe1,0x74,0x82,0xc0]
+psraw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psraw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe1,0x74,0x82,0x40]
+psraw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psraw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe1,0x74,0x02,0x40]
+psraw 64(%rdx,%rax), %xmm6
+
+// CHECK: psraw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe1,0x72,0x40]
+psraw 64(%rdx), %xmm6
+
+// CHECK: psraw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe1,0x32]
+psraw (%rdx), %xmm6
+
+// CHECK: psraw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe1,0xf6]
+psraw %xmm6, %xmm6
+
+// CHECK: psrld $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x72,0xd6,0x00]
+psrld $0, %xmm6
+
+// CHECK: psrld 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd2,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psrld 485498096, %xmm6
+
+// CHECK: psrld -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd2,0x74,0x82,0xc0]
+psrld -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psrld 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd2,0x74,0x82,0x40]
+psrld 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psrld 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd2,0x74,0x02,0x40]
+psrld 64(%rdx,%rax), %xmm6
+
+// CHECK: psrld 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd2,0x72,0x40]
+psrld 64(%rdx), %xmm6
+
+// CHECK: psrldq $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x73,0xde,0x00]
+psrldq $0, %xmm6
+
+// CHECK: psrld (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd2,0x32]
+psrld (%rdx), %xmm6
+
+// CHECK: psrld %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd2,0xf6]
+psrld %xmm6, %xmm6
+
+// CHECK: psrlq $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x73,0xd6,0x00]
+psrlq $0, %xmm6
+
+// CHECK: psrlq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd3,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psrlq 485498096, %xmm6
+
+// CHECK: psrlq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd3,0x74,0x82,0xc0]
+psrlq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psrlq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd3,0x74,0x82,0x40]
+psrlq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psrlq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd3,0x74,0x02,0x40]
+psrlq 64(%rdx,%rax), %xmm6
+
+// CHECK: psrlq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd3,0x72,0x40]
+psrlq 64(%rdx), %xmm6
+
+// CHECK: psrlq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd3,0x32]
+psrlq (%rdx), %xmm6
+
+// CHECK: psrlq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd3,0xf6]
+psrlq %xmm6, %xmm6
+
+// CHECK: psrlw $0, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x71,0xd6,0x00]
+psrlw $0, %xmm6
+
+// CHECK: psrlw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd1,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psrlw 485498096, %xmm6
+
+// CHECK: psrlw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd1,0x74,0x82,0xc0]
+psrlw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psrlw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd1,0x74,0x82,0x40]
+psrlw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psrlw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd1,0x74,0x02,0x40]
+psrlw 64(%rdx,%rax), %xmm6
+
+// CHECK: psrlw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd1,0x72,0x40]
+psrlw 64(%rdx), %xmm6
+
+// CHECK: psrlw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd1,0x32]
+psrlw (%rdx), %xmm6
+
+// CHECK: psrlw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd1,0xf6]
+psrlw %xmm6, %xmm6
+
+// CHECK: psubb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf8,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psubb 485498096, %xmm6
+
+// CHECK: psubb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf8,0x74,0x82,0xc0]
+psubb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf8,0x74,0x82,0x40]
+psubb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf8,0x74,0x02,0x40]
+psubb 64(%rdx,%rax), %xmm6
+
+// CHECK: psubb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf8,0x72,0x40]
+psubb 64(%rdx), %xmm6
+
+// CHECK: psubb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf8,0x32]
+psubb (%rdx), %xmm6
+
+// CHECK: psubb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf8,0xf6]
+psubb %xmm6, %xmm6
+
+// CHECK: psubd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfa,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psubd 485498096, %xmm6
+
+// CHECK: psubd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfa,0x74,0x82,0xc0]
+psubd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfa,0x74,0x82,0x40]
+psubd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfa,0x74,0x02,0x40]
+psubd 64(%rdx,%rax), %xmm6
+
+// CHECK: psubd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfa,0x72,0x40]
+psubd 64(%rdx), %xmm6
+
+// CHECK: psubd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfa,0x32]
+psubd (%rdx), %xmm6
+
+// CHECK: psubd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfa,0xf6]
+psubd %xmm6, %xmm6
+
+// CHECK: psubq 485498096, %mm4
+// CHECK: encoding: [0x0f,0xfb,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+psubq 485498096, %mm4
+
+// CHECK: psubq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfb,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psubq 485498096, %xmm6
+
+// CHECK: psubq 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0xfb,0x62,0x40]
+psubq 64(%rdx), %mm4
+
+// CHECK: psubq -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0xfb,0x64,0x82,0xc0]
+psubq -64(%rdx,%rax,4), %mm4
+
+// CHECK: psubq 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0xfb,0x64,0x82,0x40]
+psubq 64(%rdx,%rax,4), %mm4
+
+// CHECK: psubq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfb,0x74,0x82,0xc0]
+psubq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfb,0x74,0x82,0x40]
+psubq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubq 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0xfb,0x64,0x02,0x40]
+psubq 64(%rdx,%rax), %mm4
+
+// CHECK: psubq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfb,0x74,0x02,0x40]
+psubq 64(%rdx,%rax), %xmm6
+
+// CHECK: psubq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfb,0x72,0x40]
+psubq 64(%rdx), %xmm6
+
+// CHECK: psubq %mm4, %mm4
+// CHECK: encoding: [0x0f,0xfb,0xe4]
+psubq %mm4, %mm4
+
+// CHECK: psubq (%rdx), %mm4
+// CHECK: encoding: [0x0f,0xfb,0x22]
+psubq (%rdx), %mm4
+
+// CHECK: psubq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfb,0x32]
+psubq (%rdx), %xmm6
+
+// CHECK: psubq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xfb,0xf6]
+psubq %xmm6, %xmm6
+
+// CHECK: psubsb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe8,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psubsb 485498096, %xmm6
+
+// CHECK: psubsb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe8,0x74,0x82,0xc0]
+psubsb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubsb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe8,0x74,0x82,0x40]
+psubsb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubsb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe8,0x74,0x02,0x40]
+psubsb 64(%rdx,%rax), %xmm6
+
+// CHECK: psubsb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe8,0x72,0x40]
+psubsb 64(%rdx), %xmm6
+
+// CHECK: psubsb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe8,0x32]
+psubsb (%rdx), %xmm6
+
+// CHECK: psubsb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe8,0xf6]
+psubsb %xmm6, %xmm6
+
+// CHECK: psubsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe9,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psubsw 485498096, %xmm6
+
+// CHECK: psubsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe9,0x74,0x82,0xc0]
+psubsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe9,0x74,0x82,0x40]
+psubsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe9,0x74,0x02,0x40]
+psubsw 64(%rdx,%rax), %xmm6
+
+// CHECK: psubsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe9,0x72,0x40]
+psubsw 64(%rdx), %xmm6
+
+// CHECK: psubsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe9,0x32]
+psubsw (%rdx), %xmm6
+
+// CHECK: psubsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xe9,0xf6]
+psubsw %xmm6, %xmm6
+
+// CHECK: psubusb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd8,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psubusb 485498096, %xmm6
+
+// CHECK: psubusb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd8,0x74,0x82,0xc0]
+psubusb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubusb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd8,0x74,0x82,0x40]
+psubusb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubusb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd8,0x74,0x02,0x40]
+psubusb 64(%rdx,%rax), %xmm6
+
+// CHECK: psubusb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd8,0x72,0x40]
+psubusb 64(%rdx), %xmm6
+
+// CHECK: psubusb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd8,0x32]
+psubusb (%rdx), %xmm6
+
+// CHECK: psubusb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd8,0xf6]
+psubusb %xmm6, %xmm6
+
+// CHECK: psubusw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd9,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psubusw 485498096, %xmm6
+
+// CHECK: psubusw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd9,0x74,0x82,0xc0]
+psubusw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubusw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd9,0x74,0x82,0x40]
+psubusw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubusw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd9,0x74,0x02,0x40]
+psubusw 64(%rdx,%rax), %xmm6
+
+// CHECK: psubusw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd9,0x72,0x40]
+psubusw 64(%rdx), %xmm6
+
+// CHECK: psubusw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd9,0x32]
+psubusw (%rdx), %xmm6
+
+// CHECK: psubusw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd9,0xf6]
+psubusw %xmm6, %xmm6
+
+// CHECK: psubw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf9,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psubw 485498096, %xmm6
+
+// CHECK: psubw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf9,0x74,0x82,0xc0]
+psubw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf9,0x74,0x82,0x40]
+psubw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psubw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf9,0x74,0x02,0x40]
+psubw 64(%rdx,%rax), %xmm6
+
+// CHECK: psubw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf9,0x72,0x40]
+psubw 64(%rdx), %xmm6
+
+// CHECK: psubw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf9,0x32]
+psubw (%rdx), %xmm6
+
+// CHECK: psubw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xf9,0xf6]
+psubw %xmm6, %xmm6
+
+// CHECK: punpckhbw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x68,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+punpckhbw 485498096, %xmm6
+
+// CHECK: punpckhbw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x68,0x74,0x82,0xc0]
+punpckhbw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckhbw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x68,0x74,0x82,0x40]
+punpckhbw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckhbw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x68,0x74,0x02,0x40]
+punpckhbw 64(%rdx,%rax), %xmm6
+
+// CHECK: punpckhbw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x68,0x72,0x40]
+punpckhbw 64(%rdx), %xmm6
+
+// CHECK: punpckhbw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x68,0x32]
+punpckhbw (%rdx), %xmm6
+
+// CHECK: punpckhbw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x68,0xf6]
+punpckhbw %xmm6, %xmm6
+
+// CHECK: punpckhdq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+punpckhdq 485498096, %xmm6
+
+// CHECK: punpckhdq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6a,0x74,0x82,0xc0]
+punpckhdq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckhdq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6a,0x74,0x82,0x40]
+punpckhdq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckhdq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6a,0x74,0x02,0x40]
+punpckhdq 64(%rdx,%rax), %xmm6
+
+// CHECK: punpckhdq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6a,0x72,0x40]
+punpckhdq 64(%rdx), %xmm6
+
+// CHECK: punpckhdq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6a,0x32]
+punpckhdq (%rdx), %xmm6
+
+// CHECK: punpckhdq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6a,0xf6]
+punpckhdq %xmm6, %xmm6
+
+// CHECK: punpckhqdq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+punpckhqdq 485498096, %xmm6
+
+// CHECK: punpckhqdq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6d,0x74,0x82,0xc0]
+punpckhqdq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckhqdq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6d,0x74,0x82,0x40]
+punpckhqdq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckhqdq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6d,0x74,0x02,0x40]
+punpckhqdq 64(%rdx,%rax), %xmm6
+
+// CHECK: punpckhqdq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6d,0x72,0x40]
+punpckhqdq 64(%rdx), %xmm6
+
+// CHECK: punpckhqdq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6d,0x32]
+punpckhqdq (%rdx), %xmm6
+
+// CHECK: punpckhqdq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6d,0xf6]
+punpckhqdq %xmm6, %xmm6
+
+// CHECK: punpckhwd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x69,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+punpckhwd 485498096, %xmm6
+
+// CHECK: punpckhwd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x69,0x74,0x82,0xc0]
+punpckhwd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckhwd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x69,0x74,0x82,0x40]
+punpckhwd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckhwd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x69,0x74,0x02,0x40]
+punpckhwd 64(%rdx,%rax), %xmm6
+
+// CHECK: punpckhwd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x69,0x72,0x40]
+punpckhwd 64(%rdx), %xmm6
+
+// CHECK: punpckhwd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x69,0x32]
+punpckhwd (%rdx), %xmm6
+
+// CHECK: punpckhwd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x69,0xf6]
+punpckhwd %xmm6, %xmm6
+
+// CHECK: punpcklbw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x60,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+punpcklbw 485498096, %xmm6
+
+// CHECK: punpcklbw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x60,0x74,0x82,0xc0]
+punpcklbw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpcklbw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x60,0x74,0x82,0x40]
+punpcklbw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpcklbw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x60,0x74,0x02,0x40]
+punpcklbw 64(%rdx,%rax), %xmm6
+
+// CHECK: punpcklbw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x60,0x72,0x40]
+punpcklbw 64(%rdx), %xmm6
+
+// CHECK: punpcklbw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x60,0x32]
+punpcklbw (%rdx), %xmm6
+
+// CHECK: punpcklbw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x60,0xf6]
+punpcklbw %xmm6, %xmm6
+
+// CHECK: punpckldq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x62,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+punpckldq 485498096, %xmm6
+
+// CHECK: punpckldq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x62,0x74,0x82,0xc0]
+punpckldq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckldq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x62,0x74,0x82,0x40]
+punpckldq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpckldq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x62,0x74,0x02,0x40]
+punpckldq 64(%rdx,%rax), %xmm6
+
+// CHECK: punpckldq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x62,0x72,0x40]
+punpckldq 64(%rdx), %xmm6
+
+// CHECK: punpckldq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x62,0x32]
+punpckldq (%rdx), %xmm6
+
+// CHECK: punpckldq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x62,0xf6]
+punpckldq %xmm6, %xmm6
+
+// CHECK: punpcklqdq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+punpcklqdq 485498096, %xmm6
+
+// CHECK: punpcklqdq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6c,0x74,0x82,0xc0]
+punpcklqdq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpcklqdq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6c,0x74,0x82,0x40]
+punpcklqdq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpcklqdq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6c,0x74,0x02,0x40]
+punpcklqdq 64(%rdx,%rax), %xmm6
+
+// CHECK: punpcklqdq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6c,0x72,0x40]
+punpcklqdq 64(%rdx), %xmm6
+
+// CHECK: punpcklqdq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6c,0x32]
+punpcklqdq (%rdx), %xmm6
+
+// CHECK: punpcklqdq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x6c,0xf6]
+punpcklqdq %xmm6, %xmm6
+
+// CHECK: punpcklwd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x61,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+punpcklwd 485498096, %xmm6
+
+// CHECK: punpcklwd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x61,0x74,0x82,0xc0]
+punpcklwd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpcklwd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x61,0x74,0x82,0x40]
+punpcklwd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: punpcklwd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x61,0x74,0x02,0x40]
+punpcklwd 64(%rdx,%rax), %xmm6
+
+// CHECK: punpcklwd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x61,0x72,0x40]
+punpcklwd 64(%rdx), %xmm6
+
+// CHECK: punpcklwd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x61,0x32]
+punpcklwd (%rdx), %xmm6
+
+// CHECK: punpcklwd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x61,0xf6]
+punpcklwd %xmm6, %xmm6
+
+// CHECK: pxor 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xef,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pxor 485498096, %xmm6
+
+// CHECK: pxor -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xef,0x74,0x82,0xc0]
+pxor -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pxor 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xef,0x74,0x82,0x40]
+pxor 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pxor 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xef,0x74,0x02,0x40]
+pxor 64(%rdx,%rax), %xmm6
+
+// CHECK: pxor 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xef,0x72,0x40]
+pxor 64(%rdx), %xmm6
+
+// CHECK: pxor (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xef,0x32]
+pxor (%rdx), %xmm6
+
+// CHECK: pxor %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xef,0xf6]
+pxor %xmm6, %xmm6
+
+// CHECK: shufpd $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc6,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+shufpd $0, 485498096, %xmm6
+
+// CHECK: shufpd $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc6,0x74,0x82,0xc0,0x00]
+shufpd $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: shufpd $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc6,0x74,0x82,0x40,0x00]
+shufpd $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: shufpd $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc6,0x74,0x02,0x40,0x00]
+shufpd $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: shufpd $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc6,0x72,0x40,0x00]
+shufpd $0, 64(%rdx), %xmm6
+
+// CHECK: shufpd $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc6,0x32,0x00]
+shufpd $0, (%rdx), %xmm6
+
+// CHECK: shufpd $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xc6,0xf6,0x00]
+shufpd $0, %xmm6, %xmm6
+
+// CHECK: sqrtpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x51,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+sqrtpd 485498096, %xmm6
+
+// CHECK: sqrtpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x51,0x74,0x82,0xc0]
+sqrtpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: sqrtpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x51,0x74,0x82,0x40]
+sqrtpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: sqrtpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x51,0x74,0x02,0x40]
+sqrtpd 64(%rdx,%rax), %xmm6
+
+// CHECK: sqrtpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x51,0x72,0x40]
+sqrtpd 64(%rdx), %xmm6
+
+// CHECK: sqrtpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x51,0x32]
+sqrtpd (%rdx), %xmm6
+
+// CHECK: sqrtpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x51,0xf6]
+sqrtpd %xmm6, %xmm6
+
+// CHECK: sqrtsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x51,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+sqrtsd 485498096, %xmm6
+
+// CHECK: sqrtsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x51,0x74,0x82,0xc0]
+sqrtsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: sqrtsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x51,0x74,0x82,0x40]
+sqrtsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: sqrtsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x51,0x74,0x02,0x40]
+sqrtsd 64(%rdx,%rax), %xmm6
+
+// CHECK: sqrtsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x51,0x72,0x40]
+sqrtsd 64(%rdx), %xmm6
+
+// CHECK: sqrtsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x51,0x32]
+sqrtsd (%rdx), %xmm6
+
+// CHECK: sqrtsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x51,0xf6]
+sqrtsd %xmm6, %xmm6
+
+// CHECK: subpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+subpd 485498096, %xmm6
+
+// CHECK: subpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5c,0x74,0x82,0xc0]
+subpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: subpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5c,0x74,0x82,0x40]
+subpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: subpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5c,0x74,0x02,0x40]
+subpd 64(%rdx,%rax), %xmm6
+
+// CHECK: subpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5c,0x72,0x40]
+subpd 64(%rdx), %xmm6
+
+// CHECK: subpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5c,0x32]
+subpd (%rdx), %xmm6
+
+// CHECK: subpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x5c,0xf6]
+subpd %xmm6, %xmm6
+
+// CHECK: subsd 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+subsd 485498096, %xmm6
+
+// CHECK: subsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x74,0x82,0xc0]
+subsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: subsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x74,0x82,0x40]
+subsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: subsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x74,0x02,0x40]
+subsd 64(%rdx,%rax), %xmm6
+
+// CHECK: subsd 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x72,0x40]
+subsd 64(%rdx), %xmm6
+
+// CHECK: subsd (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5c,0x32]
+subsd (%rdx), %xmm6
+
+// CHECK: subsd %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x5c,0xf6]
+subsd %xmm6, %xmm6
+
+// CHECK: ucomisd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+ucomisd 485498096, %xmm6
+
+// CHECK: ucomisd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2e,0x74,0x82,0xc0]
+ucomisd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: ucomisd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2e,0x74,0x82,0x40]
+ucomisd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: ucomisd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2e,0x74,0x02,0x40]
+ucomisd 64(%rdx,%rax), %xmm6
+
+// CHECK: ucomisd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2e,0x72,0x40]
+ucomisd 64(%rdx), %xmm6
+
+// CHECK: ucomisd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2e,0x32]
+ucomisd (%rdx), %xmm6
+
+// CHECK: ucomisd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x2e,0xf6]
+ucomisd %xmm6, %xmm6
+
+// CHECK: unpckhpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x15,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+unpckhpd 485498096, %xmm6
+
+// CHECK: unpckhpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x15,0x74,0x82,0xc0]
+unpckhpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: unpckhpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x15,0x74,0x82,0x40]
+unpckhpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: unpckhpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x15,0x74,0x02,0x40]
+unpckhpd 64(%rdx,%rax), %xmm6
+
+// CHECK: unpckhpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x15,0x72,0x40]
+unpckhpd 64(%rdx), %xmm6
+
+// CHECK: unpckhpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x15,0x32]
+unpckhpd (%rdx), %xmm6
+
+// CHECK: unpckhpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x15,0xf6]
+unpckhpd %xmm6, %xmm6
+
+// CHECK: unpcklpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x14,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+unpcklpd 485498096, %xmm6
+
+// CHECK: unpcklpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x14,0x74,0x82,0xc0]
+unpcklpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: unpcklpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x14,0x74,0x82,0x40]
+unpcklpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: unpcklpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x14,0x74,0x02,0x40]
+unpcklpd 64(%rdx,%rax), %xmm6
+
+// CHECK: unpcklpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x14,0x72,0x40]
+unpcklpd 64(%rdx), %xmm6
+
+// CHECK: unpcklpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x14,0x32]
+unpcklpd (%rdx), %xmm6
+
+// CHECK: unpcklpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x14,0xf6]
+unpcklpd %xmm6, %xmm6
+
+// CHECK: xorpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x57,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+xorpd 485498096, %xmm6
+
+// CHECK: xorpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x57,0x74,0x82,0xc0]
+xorpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: xorpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x57,0x74,0x82,0x40]
+xorpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: xorpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x57,0x74,0x02,0x40]
+xorpd 64(%rdx,%rax), %xmm6
+
+// CHECK: xorpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x57,0x72,0x40]
+xorpd 64(%rdx), %xmm6
+
+// CHECK: xorpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x57,0x32]
+xorpd (%rdx), %xmm6
+
+// CHECK: xorpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x57,0xf6]
+xorpd %xmm6, %xmm6
+

test/MC/X86/SSE3-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: addsubpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd0,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+addsubpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addsubpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd0,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+addsubpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addsubpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd0,0x8a,0xf0,0x1c,0xf0,0x1c]
+addsubpd 485498096(%edx), %xmm1
+
+// CHECK: addsubpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd0,0x0d,0xf0,0x1c,0xf0,0x1c]
+addsubpd 485498096, %xmm1
+
+// CHECK: addsubpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd0,0x4c,0x02,0x40]
+addsubpd 64(%edx,%eax), %xmm1
+
+// CHECK: addsubpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd0,0x0a]
+addsubpd (%edx), %xmm1
+
+// CHECK: addsubpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0xd0,0xc9]
+addsubpd %xmm1, %xmm1
+
+// CHECK: addsubps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+addsubps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addsubps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+addsubps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: addsubps 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x8a,0xf0,0x1c,0xf0,0x1c]
+addsubps 485498096(%edx), %xmm1
+
+// CHECK: addsubps 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x0d,0xf0,0x1c,0xf0,0x1c]
+addsubps 485498096, %xmm1
+
+// CHECK: addsubps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x4c,0x02,0x40]
+addsubps 64(%edx,%eax), %xmm1
+
+// CHECK: addsubps (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x0a]
+addsubps (%edx), %xmm1
+
+// CHECK: addsubps %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xd0,0xc9]
+addsubps %xmm1, %xmm1
+
+// CHECK: fisttpl -485498096(%edx,%eax,4)
+// CHECK: encoding: [0xdb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+fisttpl -485498096(%edx,%eax,4)
+
+// CHECK: fisttpl 485498096(%edx,%eax,4)
+// CHECK: encoding: [0xdb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+fisttpl 485498096(%edx,%eax,4)
+
+// CHECK: fisttpl 485498096(%edx)
+// CHECK: encoding: [0xdb,0x8a,0xf0,0x1c,0xf0,0x1c]
+fisttpl 485498096(%edx)
+
+// CHECK: fisttpl 485498096
+// CHECK: encoding: [0xdb,0x0d,0xf0,0x1c,0xf0,0x1c]
+fisttpl 485498096
+
+// CHECK: fisttpl 64(%edx,%eax)
+// CHECK: encoding: [0xdb,0x4c,0x02,0x40]
+fisttpl 64(%edx,%eax)
+
+// CHECK: fisttpl (%edx)
+// CHECK: encoding: [0xdb,0x0a]
+fisttpl (%edx)
+
+// CHECK: fisttpll -485498096(%edx,%eax,4)
+// CHECK: encoding: [0xdd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+fisttpll -485498096(%edx,%eax,4)
+
+// CHECK: fisttpll 485498096(%edx,%eax,4)
+// CHECK: encoding: [0xdd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+fisttpll 485498096(%edx,%eax,4)
+
+// CHECK: fisttpll 485498096(%edx)
+// CHECK: encoding: [0xdd,0x8a,0xf0,0x1c,0xf0,0x1c]
+fisttpll 485498096(%edx)
+
+// CHECK: fisttpll 485498096
+// CHECK: encoding: [0xdd,0x0d,0xf0,0x1c,0xf0,0x1c]
+fisttpll 485498096
+
+// CHECK: fisttpll 64(%edx,%eax)
+// CHECK: encoding: [0xdd,0x4c,0x02,0x40]
+fisttpll 64(%edx,%eax)
+
+// CHECK: fisttpll (%edx)
+// CHECK: encoding: [0xdd,0x0a]
+fisttpll (%edx)
+
+// CHECK: fisttps -485498096(%edx,%eax,4)
+// CHECK: encoding: [0xdf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+fisttps -485498096(%edx,%eax,4)
+
+// CHECK: fisttps 485498096(%edx,%eax,4)
+// CHECK: encoding: [0xdf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+fisttps 485498096(%edx,%eax,4)
+
+// CHECK: fisttps 485498096(%edx)
+// CHECK: encoding: [0xdf,0x8a,0xf0,0x1c,0xf0,0x1c]
+fisttps 485498096(%edx)
+
+// CHECK: fisttps 485498096
+// CHECK: encoding: [0xdf,0x0d,0xf0,0x1c,0xf0,0x1c]
+fisttps 485498096
+
+// CHECK: fisttps 64(%edx,%eax)
+// CHECK: encoding: [0xdf,0x4c,0x02,0x40]
+fisttps 64(%edx,%eax)
+
+// CHECK: fisttps (%edx)
+// CHECK: encoding: [0xdf,0x0a]
+fisttps (%edx)
+
+// CHECK: haddpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+haddpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: haddpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+haddpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: haddpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7c,0x8a,0xf0,0x1c,0xf0,0x1c]
+haddpd 485498096(%edx), %xmm1
+
+// CHECK: haddpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7c,0x0d,0xf0,0x1c,0xf0,0x1c]
+haddpd 485498096, %xmm1
+
+// CHECK: haddpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7c,0x4c,0x02,0x40]
+haddpd 64(%edx,%eax), %xmm1
+
+// CHECK: haddpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7c,0x0a]
+haddpd (%edx), %xmm1
+
+// CHECK: haddpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7c,0xc9]
+haddpd %xmm1, %xmm1
+
+// CHECK: haddps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+haddps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: haddps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+haddps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: haddps 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x8a,0xf0,0x1c,0xf0,0x1c]
+haddps 485498096(%edx), %xmm1
+
+// CHECK: haddps 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x0d,0xf0,0x1c,0xf0,0x1c]
+haddps 485498096, %xmm1
+
+// CHECK: haddps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x4c,0x02,0x40]
+haddps 64(%edx,%eax), %xmm1
+
+// CHECK: haddps (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x0a]
+haddps (%edx), %xmm1
+
+// CHECK: haddps %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7c,0xc9]
+haddps %xmm1, %xmm1
+
+// CHECK: hsubpd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+hsubpd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: hsubpd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+hsubpd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: hsubpd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7d,0x8a,0xf0,0x1c,0xf0,0x1c]
+hsubpd 485498096(%edx), %xmm1
+
+// CHECK: hsubpd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7d,0x0d,0xf0,0x1c,0xf0,0x1c]
+hsubpd 485498096, %xmm1
+
+// CHECK: hsubpd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7d,0x4c,0x02,0x40]
+hsubpd 64(%edx,%eax), %xmm1
+
+// CHECK: hsubpd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7d,0x0a]
+hsubpd (%edx), %xmm1
+
+// CHECK: hsubpd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x7d,0xc9]
+hsubpd %xmm1, %xmm1
+
+// CHECK: hsubps -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+hsubps -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: hsubps 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+hsubps 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: hsubps 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x8a,0xf0,0x1c,0xf0,0x1c]
+hsubps 485498096(%edx), %xmm1
+
+// CHECK: hsubps 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x0d,0xf0,0x1c,0xf0,0x1c]
+hsubps 485498096, %xmm1
+
+// CHECK: hsubps 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x4c,0x02,0x40]
+hsubps 64(%edx,%eax), %xmm1
+
+// CHECK: hsubps (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x0a]
+hsubps (%edx), %xmm1
+
+// CHECK: hsubps %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x7d,0xc9]
+hsubps %xmm1, %xmm1
+
+// CHECK: lddqu -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+lddqu -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: lddqu 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+lddqu 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: lddqu 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x8a,0xf0,0x1c,0xf0,0x1c]
+lddqu 485498096(%edx), %xmm1
+
+// CHECK: lddqu 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x0d,0xf0,0x1c,0xf0,0x1c]
+lddqu 485498096, %xmm1
+
+// CHECK: lddqu 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x4c,0x02,0x40]
+lddqu 64(%edx,%eax), %xmm1
+
+// CHECK: lddqu (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x0a]
+lddqu (%edx), %xmm1
+
+// CHECK: monitor
+// CHECK: encoding: [0x0f,0x01,0xc8]
+monitor
+
+// CHECK: movddup -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x12,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movddup -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movddup 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x12,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movddup 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movddup 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x12,0x8a,0xf0,0x1c,0xf0,0x1c]
+movddup 485498096(%edx), %xmm1
+
+// CHECK: movddup 485498096, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x12,0x0d,0xf0,0x1c,0xf0,0x1c]
+movddup 485498096, %xmm1
+
+// CHECK: movddup 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x12,0x4c,0x02,0x40]
+movddup 64(%edx,%eax), %xmm1
+
+// CHECK: movddup (%edx), %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x12,0x0a]
+movddup (%edx), %xmm1
+
+// CHECK: movddup %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x12,0xc9]
+movddup %xmm1, %xmm1
+
+// CHECK: movshdup -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x16,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movshdup -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movshdup 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x16,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movshdup 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movshdup 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x16,0x8a,0xf0,0x1c,0xf0,0x1c]
+movshdup 485498096(%edx), %xmm1
+
+// CHECK: movshdup 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x16,0x0d,0xf0,0x1c,0xf0,0x1c]
+movshdup 485498096, %xmm1
+
+// CHECK: movshdup 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x16,0x4c,0x02,0x40]
+movshdup 64(%edx,%eax), %xmm1
+
+// CHECK: movshdup (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x16,0x0a]
+movshdup (%edx), %xmm1
+
+// CHECK: movshdup %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x16,0xc9]
+movshdup %xmm1, %xmm1
+
+// CHECK: movsldup -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x12,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movsldup -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movsldup 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x12,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movsldup 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movsldup 485498096(%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x12,0x8a,0xf0,0x1c,0xf0,0x1c]
+movsldup 485498096(%edx), %xmm1
+
+// CHECK: movsldup 485498096, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x12,0x0d,0xf0,0x1c,0xf0,0x1c]
+movsldup 485498096, %xmm1
+
+// CHECK: movsldup 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x12,0x4c,0x02,0x40]
+movsldup 64(%edx,%eax), %xmm1
+
+// CHECK: movsldup (%edx), %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x12,0x0a]
+movsldup (%edx), %xmm1
+
+// CHECK: movsldup %xmm1, %xmm1
+// CHECK: encoding: [0xf3,0x0f,0x12,0xc9]
+movsldup %xmm1, %xmm1
+
+// CHECK: mwait
+// CHECK: encoding: [0x0f,0x01,0xc9]
+mwait
+

test/MC/X86/SSE3-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: addsubpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd0,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+addsubpd 485498096, %xmm6
+
+// CHECK: addsubpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd0,0x74,0x82,0xc0]
+addsubpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: addsubpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd0,0x74,0x82,0x40]
+addsubpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: addsubpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd0,0x74,0x02,0x40]
+addsubpd 64(%rdx,%rax), %xmm6
+
+// CHECK: addsubpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd0,0x72,0x40]
+addsubpd 64(%rdx), %xmm6
+
+// CHECK: addsubpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd0,0x32]
+addsubpd (%rdx), %xmm6
+
+// CHECK: addsubpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0xd0,0xf6]
+addsubpd %xmm6, %xmm6
+
+// CHECK: addsubps 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+addsubps 485498096, %xmm6
+
+// CHECK: addsubps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x74,0x82,0xc0]
+addsubps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: addsubps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x74,0x82,0x40]
+addsubps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: addsubps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x74,0x02,0x40]
+addsubps 64(%rdx,%rax), %xmm6
+
+// CHECK: addsubps 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x72,0x40]
+addsubps 64(%rdx), %xmm6
+
+// CHECK: addsubps (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xd0,0x32]
+addsubps (%rdx), %xmm6
+
+// CHECK: addsubps %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xd0,0xf6]
+addsubps %xmm6, %xmm6
+
+// CHECK: fisttpl 485498096
+// CHECK: encoding: [0xdb,0x0c,0x25,0xf0,0x1c,0xf0,0x1c]
+fisttpl 485498096
+
+// CHECK: fisttpl 64(%rdx)
+// CHECK: encoding: [0xdb,0x4a,0x40]
+fisttpl 64(%rdx)
+
+// CHECK: fisttpl -64(%rdx,%rax,4)
+// CHECK: encoding: [0xdb,0x4c,0x82,0xc0]
+fisttpl -64(%rdx,%rax,4)
+
+// CHECK: fisttpl 64(%rdx,%rax,4)
+// CHECK: encoding: [0xdb,0x4c,0x82,0x40]
+fisttpl 64(%rdx,%rax,4)
+
+// CHECK: fisttpl 64(%rdx,%rax)
+// CHECK: encoding: [0xdb,0x4c,0x02,0x40]
+fisttpl 64(%rdx,%rax)
+
+// CHECK: fisttpll 485498096
+// CHECK: encoding: [0xdd,0x0c,0x25,0xf0,0x1c,0xf0,0x1c]
+fisttpll 485498096
+
+// CHECK: fisttpll 64(%rdx)
+// CHECK: encoding: [0xdd,0x4a,0x40]
+fisttpll 64(%rdx)
+
+// CHECK: fisttpll -64(%rdx,%rax,4)
+// CHECK: encoding: [0xdd,0x4c,0x82,0xc0]
+fisttpll -64(%rdx,%rax,4)
+
+// CHECK: fisttpll 64(%rdx,%rax,4)
+// CHECK: encoding: [0xdd,0x4c,0x82,0x40]
+fisttpll 64(%rdx,%rax,4)
+
+// CHECK: fisttpll 64(%rdx,%rax)
+// CHECK: encoding: [0xdd,0x4c,0x02,0x40]
+fisttpll 64(%rdx,%rax)
+
+// CHECK: fisttpll (%rdx)
+// CHECK: encoding: [0xdd,0x0a]
+fisttpll (%rdx)
+
+// CHECK: fisttpl (%rdx)
+// CHECK: encoding: [0xdb,0x0a]
+fisttpl (%rdx)
+
+// CHECK: fisttps 485498096
+// CHECK: encoding: [0xdf,0x0c,0x25,0xf0,0x1c,0xf0,0x1c]
+fisttps 485498096
+
+// CHECK: fisttps 64(%rdx)
+// CHECK: encoding: [0xdf,0x4a,0x40]
+fisttps 64(%rdx)
+
+// CHECK: fisttps -64(%rdx,%rax,4)
+// CHECK: encoding: [0xdf,0x4c,0x82,0xc0]
+fisttps -64(%rdx,%rax,4)
+
+// CHECK: fisttps 64(%rdx,%rax,4)
+// CHECK: encoding: [0xdf,0x4c,0x82,0x40]
+fisttps 64(%rdx,%rax,4)
+
+// CHECK: fisttps 64(%rdx,%rax)
+// CHECK: encoding: [0xdf,0x4c,0x02,0x40]
+fisttps 64(%rdx,%rax)
+
+// CHECK: fisttps (%rdx)
+// CHECK: encoding: [0xdf,0x0a]
+fisttps (%rdx)
+
+// CHECK: haddpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+haddpd 485498096, %xmm6
+
+// CHECK: haddpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7c,0x74,0x82,0xc0]
+haddpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: haddpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7c,0x74,0x82,0x40]
+haddpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: haddpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7c,0x74,0x02,0x40]
+haddpd 64(%rdx,%rax), %xmm6
+
+// CHECK: haddpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7c,0x72,0x40]
+haddpd 64(%rdx), %xmm6
+
+// CHECK: haddpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7c,0x32]
+haddpd (%rdx), %xmm6
+
+// CHECK: haddpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7c,0xf6]
+haddpd %xmm6, %xmm6
+
+// CHECK: haddps 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+haddps 485498096, %xmm6
+
+// CHECK: haddps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x74,0x82,0xc0]
+haddps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: haddps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x74,0x82,0x40]
+haddps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: haddps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x74,0x02,0x40]
+haddps 64(%rdx,%rax), %xmm6
+
+// CHECK: haddps 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x72,0x40]
+haddps 64(%rdx), %xmm6
+
+// CHECK: haddps (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7c,0x32]
+haddps (%rdx), %xmm6
+
+// CHECK: haddps %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7c,0xf6]
+haddps %xmm6, %xmm6
+
+// CHECK: hsubpd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+hsubpd 485498096, %xmm6
+
+// CHECK: hsubpd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7d,0x74,0x82,0xc0]
+hsubpd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: hsubpd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7d,0x74,0x82,0x40]
+hsubpd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: hsubpd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7d,0x74,0x02,0x40]
+hsubpd 64(%rdx,%rax), %xmm6
+
+// CHECK: hsubpd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7d,0x72,0x40]
+hsubpd 64(%rdx), %xmm6
+
+// CHECK: hsubpd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7d,0x32]
+hsubpd (%rdx), %xmm6
+
+// CHECK: hsubpd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x7d,0xf6]
+hsubpd %xmm6, %xmm6
+
+// CHECK: hsubps 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+hsubps 485498096, %xmm6
+
+// CHECK: hsubps -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x74,0x82,0xc0]
+hsubps -64(%rdx,%rax,4), %xmm6
+
+// CHECK: hsubps 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x74,0x82,0x40]
+hsubps 64(%rdx,%rax,4), %xmm6
+
+// CHECK: hsubps 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x74,0x02,0x40]
+hsubps 64(%rdx,%rax), %xmm6
+
+// CHECK: hsubps 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x72,0x40]
+hsubps 64(%rdx), %xmm6
+
+// CHECK: hsubps (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7d,0x32]
+hsubps (%rdx), %xmm6
+
+// CHECK: hsubps %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x7d,0xf6]
+hsubps %xmm6, %xmm6
+
+// CHECK: lddqu 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+lddqu 485498096, %xmm6
+
+// CHECK: lddqu -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x74,0x82,0xc0]
+lddqu -64(%rdx,%rax,4), %xmm6
+
+// CHECK: lddqu 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x74,0x82,0x40]
+lddqu 64(%rdx,%rax,4), %xmm6
+
+// CHECK: lddqu 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x74,0x02,0x40]
+lddqu 64(%rdx,%rax), %xmm6
+
+// CHECK: lddqu 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x72,0x40]
+lddqu 64(%rdx), %xmm6
+
+// CHECK: lddqu (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0xf0,0x32]
+lddqu (%rdx), %xmm6
+
+// CHECK: monitor
+// CHECK: encoding: [0x0f,0x01,0xc8]
+monitor
+
+// CHECK: movddup 485498096, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x12,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movddup 485498096, %xmm6
+
+// CHECK: movddup -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x12,0x74,0x82,0xc0]
+movddup -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movddup 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x12,0x74,0x82,0x40]
+movddup 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movddup 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x12,0x74,0x02,0x40]
+movddup 64(%rdx,%rax), %xmm6
+
+// CHECK: movddup 64(%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x12,0x72,0x40]
+movddup 64(%rdx), %xmm6
+
+// CHECK: movddup (%rdx), %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x12,0x32]
+movddup (%rdx), %xmm6
+
+// CHECK: movddup %xmm6, %xmm6
+// CHECK: encoding: [0xf2,0x0f,0x12,0xf6]
+movddup %xmm6, %xmm6
+
+// CHECK: movshdup 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x16,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movshdup 485498096, %xmm6
+
+// CHECK: movshdup -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x16,0x74,0x82,0xc0]
+movshdup -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movshdup 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x16,0x74,0x82,0x40]
+movshdup 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movshdup 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x16,0x74,0x02,0x40]
+movshdup 64(%rdx,%rax), %xmm6
+
+// CHECK: movshdup 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x16,0x72,0x40]
+movshdup 64(%rdx), %xmm6
+
+// CHECK: movshdup (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x16,0x32]
+movshdup (%rdx), %xmm6
+
+// CHECK: movshdup %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x16,0xf6]
+movshdup %xmm6, %xmm6
+
+// CHECK: movsldup 485498096, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x12,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movsldup 485498096, %xmm6
+
+// CHECK: movsldup -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x12,0x74,0x82,0xc0]
+movsldup -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movsldup 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x12,0x74,0x82,0x40]
+movsldup 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movsldup 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x12,0x74,0x02,0x40]
+movsldup 64(%rdx,%rax), %xmm6
+
+// CHECK: movsldup 64(%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x12,0x72,0x40]
+movsldup 64(%rdx), %xmm6
+
+// CHECK: movsldup (%rdx), %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x12,0x32]
+movsldup (%rdx), %xmm6
+
+// CHECK: movsldup %xmm6, %xmm6
+// CHECK: encoding: [0xf3,0x0f,0x12,0xf6]
+movsldup %xmm6, %xmm6
+
+// CHECK: mwait
+// CHECK: encoding: [0x0f,0x01,0xc9]
+mwait
+

test/MC/X86/SSE41-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: blendpd $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+blendpd $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: blendpd $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+blendpd $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: blendpd $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+blendpd $0, 485498096(%edx), %xmm1
+
+// CHECK: blendpd $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+blendpd $0, 485498096, %xmm1
+
+// CHECK: blendpd $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x4c,0x02,0x40,0x00]
+blendpd $0, 64(%edx,%eax), %xmm1
+
+// CHECK: blendpd $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x0a,0x00]
+blendpd $0, (%edx), %xmm1
+
+// CHECK: blendpd $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0xc9,0x00]
+blendpd $0, %xmm1, %xmm1
+
+// CHECK: blendps $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+blendps $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: blendps $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+blendps $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: blendps $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+blendps $0, 485498096(%edx), %xmm1
+
+// CHECK: blendps $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+blendps $0, 485498096, %xmm1
+
+// CHECK: blendps $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x4c,0x02,0x40,0x00]
+blendps $0, 64(%edx,%eax), %xmm1
+
+// CHECK: blendps $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x0a,0x00]
+blendps $0, (%edx), %xmm1
+
+// CHECK: blendps $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0xc9,0x00]
+blendps $0, %xmm1, %xmm1
+
+// CHECK: blendvpd %xmm0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+blendvpd %xmm0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: blendvpd %xmm0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+blendvpd %xmm0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: blendvpd %xmm0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x8a,0xf0,0x1c,0xf0,0x1c]
+blendvpd %xmm0, 485498096(%edx), %xmm1
+
+// CHECK: blendvpd %xmm0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x0d,0xf0,0x1c,0xf0,0x1c]
+blendvpd %xmm0, 485498096, %xmm1
+
+// CHECK: blendvpd %xmm0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x4c,0x02,0x40]
+blendvpd %xmm0, 64(%edx,%eax), %xmm1
+
+// CHECK: blendvpd %xmm0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x0a]
+blendvpd %xmm0, (%edx), %xmm1
+
+// CHECK: blendvpd %xmm0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0xc9]
+blendvpd %xmm0, %xmm1, %xmm1
+
+// CHECK: blendvps %xmm0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+blendvps %xmm0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: blendvps %xmm0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+blendvps %xmm0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: blendvps %xmm0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x8a,0xf0,0x1c,0xf0,0x1c]
+blendvps %xmm0, 485498096(%edx), %xmm1
+
+// CHECK: blendvps %xmm0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x0d,0xf0,0x1c,0xf0,0x1c]
+blendvps %xmm0, 485498096, %xmm1
+
+// CHECK: blendvps %xmm0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x4c,0x02,0x40]
+blendvps %xmm0, 64(%edx,%eax), %xmm1
+
+// CHECK: blendvps %xmm0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x0a]
+blendvps %xmm0, (%edx), %xmm1
+
+// CHECK: blendvps %xmm0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0xc9]
+blendvps %xmm0, %xmm1, %xmm1
+
+// CHECK: dppd $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+dppd $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: dppd $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+dppd $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: dppd $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+dppd $0, 485498096(%edx), %xmm1
+
+// CHECK: dppd $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+dppd $0, 485498096, %xmm1
+
+// CHECK: dppd $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x4c,0x02,0x40,0x00]
+dppd $0, 64(%edx,%eax), %xmm1
+
+// CHECK: dppd $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x0a,0x00]
+dppd $0, (%edx), %xmm1
+
+// CHECK: dppd $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0xc9,0x00]
+dppd $0, %xmm1, %xmm1
+
+// CHECK: dpps $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+dpps $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: dpps $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+dpps $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: dpps $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+dpps $0, 485498096(%edx), %xmm1
+
+// CHECK: dpps $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+dpps $0, 485498096, %xmm1
+
+// CHECK: dpps $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x4c,0x02,0x40,0x00]
+dpps $0, 64(%edx,%eax), %xmm1
+
+// CHECK: dpps $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x0a,0x00]
+dpps $0, (%edx), %xmm1
+
+// CHECK: dpps $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0xc9,0x00]
+dpps $0, %xmm1, %xmm1
+
+// CHECK: extractps $0, %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+extractps $0, %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: extractps $0, %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+extractps $0, %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: extractps $0, %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+extractps $0, %xmm1, 485498096(%edx)
+
+// CHECK: extractps $0, %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+extractps $0, %xmm1, 485498096
+
+// CHECK: extractps $0, %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x4c,0x02,0x40,0x00]
+extractps $0, %xmm1, 64(%edx,%eax)
+
+// CHECK: extractps $0, %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x0a,0x00]
+extractps $0, %xmm1, (%edx)
+
+// CHECK: insertps $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+insertps $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: insertps $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+insertps $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: insertps $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+insertps $0, 485498096(%edx), %xmm1
+
+// CHECK: insertps $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+insertps $0, 485498096, %xmm1
+
+// CHECK: insertps $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x4c,0x02,0x40,0x00]
+insertps $0, 64(%edx,%eax), %xmm1
+
+// CHECK: insertps $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x0a,0x00]
+insertps $0, (%edx), %xmm1
+
+// CHECK: insertps $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0xc9,0x00]
+insertps $0, %xmm1, %xmm1
+
+// CHECK: movntdqa -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movntdqa -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movntdqa 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movntdqa 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: movntdqa 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
+movntdqa 485498096(%edx), %xmm1
+
+// CHECK: movntdqa 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
+movntdqa 485498096, %xmm1
+
+// CHECK: movntdqa 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x4c,0x02,0x40]
+movntdqa 64(%edx,%eax), %xmm1
+
+// CHECK: movntdqa (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x0a]
+movntdqa (%edx), %xmm1
+
+// CHECK: mpsadbw $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+mpsadbw $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mpsadbw $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+mpsadbw $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: mpsadbw $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+mpsadbw $0, 485498096(%edx), %xmm1
+
+// CHECK: mpsadbw $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+mpsadbw $0, 485498096, %xmm1
+
+// CHECK: mpsadbw $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x4c,0x02,0x40,0x00]
+mpsadbw $0, 64(%edx,%eax), %xmm1
+
+// CHECK: mpsadbw $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x0a,0x00]
+mpsadbw $0, (%edx), %xmm1
+
+// CHECK: mpsadbw $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0xc9,0x00]
+mpsadbw $0, %xmm1, %xmm1
+
+// CHECK: packusdw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+packusdw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: packusdw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+packusdw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: packusdw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x8a,0xf0,0x1c,0xf0,0x1c]
+packusdw 485498096(%edx), %xmm1
+
+// CHECK: packusdw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x0d,0xf0,0x1c,0xf0,0x1c]
+packusdw 485498096, %xmm1
+
+// CHECK: packusdw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x4c,0x02,0x40]
+packusdw 64(%edx,%eax), %xmm1
+
+// CHECK: packusdw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x0a]
+packusdw (%edx), %xmm1
+
+// CHECK: packusdw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0xc9]
+packusdw %xmm1, %xmm1
+
+// CHECK: pblendvb %xmm0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pblendvb %xmm0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pblendvb %xmm0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pblendvb %xmm0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pblendvb %xmm0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
+pblendvb %xmm0, 485498096(%edx), %xmm1
+
+// CHECK: pblendvb %xmm0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
+pblendvb %xmm0, 485498096, %xmm1
+
+// CHECK: pblendvb %xmm0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x4c,0x02,0x40]
+pblendvb %xmm0, 64(%edx,%eax), %xmm1
+
+// CHECK: pblendvb %xmm0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x0a]
+pblendvb %xmm0, (%edx), %xmm1
+
+// CHECK: pblendvb %xmm0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0xc9]
+pblendvb %xmm0, %xmm1, %xmm1
+
+// CHECK: pblendw $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pblendw $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pblendw $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pblendw $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pblendw $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pblendw $0, 485498096(%edx), %xmm1
+
+// CHECK: pblendw $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pblendw $0, 485498096, %xmm1
+
+// CHECK: pblendw $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x4c,0x02,0x40,0x00]
+pblendw $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pblendw $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x0a,0x00]
+pblendw $0, (%edx), %xmm1
+
+// CHECK: pblendw $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0xc9,0x00]
+pblendw $0, %xmm1, %xmm1
+
+// CHECK: pcmpeqq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pcmpeqq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpeqq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pcmpeqq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpeqq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x8a,0xf0,0x1c,0xf0,0x1c]
+pcmpeqq 485498096(%edx), %xmm1
+
+// CHECK: pcmpeqq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x0d,0xf0,0x1c,0xf0,0x1c]
+pcmpeqq 485498096, %xmm1
+
+// CHECK: pcmpeqq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x4c,0x02,0x40]
+pcmpeqq 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpeqq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x0a]
+pcmpeqq (%edx), %xmm1
+
+// CHECK: pcmpeqq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0xc9]
+pcmpeqq %xmm1, %xmm1
+
+// CHECK: pextrb $0, %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pextrb $0, %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: pextrb $0, %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrb $0, %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: pextrb $0, %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrb $0, %xmm1, 485498096(%edx)
+
+// CHECK: pextrb $0, %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrb $0, %xmm1, 485498096
+
+// CHECK: pextrb $0, %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x4c,0x02,0x40,0x00]
+pextrb $0, %xmm1, 64(%edx,%eax)
+
+// CHECK: pextrb $0, %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x0a,0x00]
+pextrb $0, %xmm1, (%edx)
+
+// CHECK: pextrd $0, %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pextrd $0, %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: pextrd $0, %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrd $0, %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: pextrd $0, %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrd $0, %xmm1, 485498096(%edx)
+
+// CHECK: pextrd $0, %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrd $0, %xmm1, 485498096
+
+// CHECK: pextrd $0, %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x4c,0x02,0x40,0x00]
+pextrd $0, %xmm1, 64(%edx,%eax)
+
+// CHECK: pextrd $0, %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x0a,0x00]
+pextrd $0, %xmm1, (%edx)
+
+// CHECK: pextrw $0, %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pextrw $0, %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: pextrw $0, %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrw $0, %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: pextrw $0, %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrw $0, %xmm1, 485498096(%edx)
+
+// CHECK: pextrw $0, %xmm1, 485498096
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrw $0, %xmm1, 485498096
+
+// CHECK: pextrw $0, %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x4c,0x02,0x40,0x00]
+pextrw $0, %xmm1, 64(%edx,%eax)
+
+// CHECK: pextrw $0, %xmm1, (%edx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x0a,0x00]
+pextrw $0, %xmm1, (%edx)
+
+// CHECK: phminposuw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+phminposuw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phminposuw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+phminposuw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phminposuw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x8a,0xf0,0x1c,0xf0,0x1c]
+phminposuw 485498096(%edx), %xmm1
+
+// CHECK: phminposuw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x0d,0xf0,0x1c,0xf0,0x1c]
+phminposuw 485498096, %xmm1
+
+// CHECK: phminposuw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x4c,0x02,0x40]
+phminposuw 64(%edx,%eax), %xmm1
+
+// CHECK: phminposuw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x0a]
+phminposuw (%edx), %xmm1
+
+// CHECK: phminposuw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0xc9]
+phminposuw %xmm1, %xmm1
+
+// CHECK: pinsrb $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pinsrb $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pinsrb $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrb $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pinsrb $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrb $0, 485498096(%edx), %xmm1
+
+// CHECK: pinsrb $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrb $0, 485498096, %xmm1
+
+// CHECK: pinsrb $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x4c,0x02,0x40,0x00]
+pinsrb $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pinsrb $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x0a,0x00]
+pinsrb $0, (%edx), %xmm1
+
+// CHECK: pinsrd $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pinsrd $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pinsrd $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrd $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pinsrd $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrd $0, 485498096(%edx), %xmm1
+
+// CHECK: pinsrd $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrd $0, 485498096, %xmm1
+
+// CHECK: pinsrd $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x4c,0x02,0x40,0x00]
+pinsrd $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pinsrd $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x0a,0x00]
+pinsrd $0, (%edx), %xmm1
+
+// CHECK: pmaxsb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmaxsb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxsb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaxsb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxsb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmaxsb 485498096(%edx), %xmm1
+
+// CHECK: pmaxsb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmaxsb 485498096, %xmm1
+
+// CHECK: pmaxsb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x4c,0x02,0x40]
+pmaxsb 64(%edx,%eax), %xmm1
+
+// CHECK: pmaxsb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x0a]
+pmaxsb (%edx), %xmm1
+
+// CHECK: pmaxsb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0xc9]
+pmaxsb %xmm1, %xmm1
+
+// CHECK: pmaxsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmaxsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaxsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmaxsd 485498096(%edx), %xmm1
+
+// CHECK: pmaxsd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmaxsd 485498096, %xmm1
+
+// CHECK: pmaxsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x4c,0x02,0x40]
+pmaxsd 64(%edx,%eax), %xmm1
+
+// CHECK: pmaxsd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x0a]
+pmaxsd (%edx), %xmm1
+
+// CHECK: pmaxsd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0xc9]
+pmaxsd %xmm1, %xmm1
+
+// CHECK: pmaxud -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmaxud -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxud 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaxud 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxud 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmaxud 485498096(%edx), %xmm1
+
+// CHECK: pmaxud 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmaxud 485498096, %xmm1
+
+// CHECK: pmaxud 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x4c,0x02,0x40]
+pmaxud 64(%edx,%eax), %xmm1
+
+// CHECK: pmaxud (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x0a]
+pmaxud (%edx), %xmm1
+
+// CHECK: pmaxud %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0xc9]
+pmaxud %xmm1, %xmm1
+
+// CHECK: pmaxuw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmaxuw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxuw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaxuw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaxuw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmaxuw 485498096(%edx), %xmm1
+
+// CHECK: pmaxuw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmaxuw 485498096, %xmm1
+
+// CHECK: pmaxuw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x4c,0x02,0x40]
+pmaxuw 64(%edx,%eax), %xmm1
+
+// CHECK: pmaxuw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x0a]
+pmaxuw (%edx), %xmm1
+
+// CHECK: pmaxuw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0xc9]
+pmaxuw %xmm1, %xmm1
+
+// CHECK: pminsb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pminsb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminsb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pminsb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminsb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x8a,0xf0,0x1c,0xf0,0x1c]
+pminsb 485498096(%edx), %xmm1
+
+// CHECK: pminsb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x0d,0xf0,0x1c,0xf0,0x1c]
+pminsb 485498096, %xmm1
+
+// CHECK: pminsb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x4c,0x02,0x40]
+pminsb 64(%edx,%eax), %xmm1
+
+// CHECK: pminsb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x0a]
+pminsb (%edx), %xmm1
+
+// CHECK: pminsb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0xc9]
+pminsb %xmm1, %xmm1
+
+// CHECK: pminsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pminsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pminsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x8a,0xf0,0x1c,0xf0,0x1c]
+pminsd 485498096(%edx), %xmm1
+
+// CHECK: pminsd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x0d,0xf0,0x1c,0xf0,0x1c]
+pminsd 485498096, %xmm1
+
+// CHECK: pminsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x4c,0x02,0x40]
+pminsd 64(%edx,%eax), %xmm1
+
+// CHECK: pminsd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x0a]
+pminsd (%edx), %xmm1
+
+// CHECK: pminsd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0xc9]
+pminsd %xmm1, %xmm1
+
+// CHECK: pminud -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pminud -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminud 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pminud 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminud 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x8a,0xf0,0x1c,0xf0,0x1c]
+pminud 485498096(%edx), %xmm1
+
+// CHECK: pminud 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x0d,0xf0,0x1c,0xf0,0x1c]
+pminud 485498096, %xmm1
+
+// CHECK: pminud 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x4c,0x02,0x40]
+pminud 64(%edx,%eax), %xmm1
+
+// CHECK: pminud (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x0a]
+pminud (%edx), %xmm1
+
+// CHECK: pminud %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0xc9]
+pminud %xmm1, %xmm1
+
+// CHECK: pminuw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pminuw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminuw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pminuw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pminuw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x8a,0xf0,0x1c,0xf0,0x1c]
+pminuw 485498096(%edx), %xmm1
+
+// CHECK: pminuw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x0d,0xf0,0x1c,0xf0,0x1c]
+pminuw 485498096, %xmm1
+
+// CHECK: pminuw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x4c,0x02,0x40]
+pminuw 64(%edx,%eax), %xmm1
+
+// CHECK: pminuw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x0a]
+pminuw (%edx), %xmm1
+
+// CHECK: pminuw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0xc9]
+pminuw %xmm1, %xmm1
+
+// CHECK: pmovsxbd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovsxbd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxbd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovsxbd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxbd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovsxbd 485498096(%edx), %xmm1
+
+// CHECK: pmovsxbd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovsxbd 485498096, %xmm1
+
+// CHECK: pmovsxbd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x4c,0x02,0x40]
+pmovsxbd 64(%edx,%eax), %xmm1
+
+// CHECK: pmovsxbd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x0a]
+pmovsxbd (%edx), %xmm1
+
+// CHECK: pmovsxbd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0xc9]
+pmovsxbd %xmm1, %xmm1
+
+// CHECK: pmovsxbq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovsxbq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxbq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovsxbq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxbq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovsxbq 485498096(%edx), %xmm1
+
+// CHECK: pmovsxbq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovsxbq 485498096, %xmm1
+
+// CHECK: pmovsxbq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x4c,0x02,0x40]
+pmovsxbq 64(%edx,%eax), %xmm1
+
+// CHECK: pmovsxbq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x0a]
+pmovsxbq (%edx), %xmm1
+
+// CHECK: pmovsxbq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0xc9]
+pmovsxbq %xmm1, %xmm1
+
+// CHECK: pmovsxbw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovsxbw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxbw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovsxbw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxbw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovsxbw 485498096(%edx), %xmm1
+
+// CHECK: pmovsxbw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovsxbw 485498096, %xmm1
+
+// CHECK: pmovsxbw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x4c,0x02,0x40]
+pmovsxbw 64(%edx,%eax), %xmm1
+
+// CHECK: pmovsxbw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x0a]
+pmovsxbw (%edx), %xmm1
+
+// CHECK: pmovsxbw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0xc9]
+pmovsxbw %xmm1, %xmm1
+
+// CHECK: pmovsxdq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovsxdq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxdq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovsxdq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxdq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovsxdq 485498096(%edx), %xmm1
+
+// CHECK: pmovsxdq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovsxdq 485498096, %xmm1
+
+// CHECK: pmovsxdq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x4c,0x02,0x40]
+pmovsxdq 64(%edx,%eax), %xmm1
+
+// CHECK: pmovsxdq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x0a]
+pmovsxdq (%edx), %xmm1
+
+// CHECK: pmovsxdq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0xc9]
+pmovsxdq %xmm1, %xmm1
+
+// CHECK: pmovsxwd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovsxwd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxwd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovsxwd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxwd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovsxwd 485498096(%edx), %xmm1
+
+// CHECK: pmovsxwd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovsxwd 485498096, %xmm1
+
+// CHECK: pmovsxwd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x4c,0x02,0x40]
+pmovsxwd 64(%edx,%eax), %xmm1
+
+// CHECK: pmovsxwd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x0a]
+pmovsxwd (%edx), %xmm1
+
+// CHECK: pmovsxwd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0xc9]
+pmovsxwd %xmm1, %xmm1
+
+// CHECK: pmovsxwq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovsxwq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxwq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovsxwq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovsxwq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovsxwq 485498096(%edx), %xmm1
+
+// CHECK: pmovsxwq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovsxwq 485498096, %xmm1
+
+// CHECK: pmovsxwq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x4c,0x02,0x40]
+pmovsxwq 64(%edx,%eax), %xmm1
+
+// CHECK: pmovsxwq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x0a]
+pmovsxwq (%edx), %xmm1
+
+// CHECK: pmovsxwq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0xc9]
+pmovsxwq %xmm1, %xmm1
+
+// CHECK: pmovzxbd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovzxbd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxbd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovzxbd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxbd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovzxbd 485498096(%edx), %xmm1
+
+// CHECK: pmovzxbd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovzxbd 485498096, %xmm1
+
+// CHECK: pmovzxbd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x4c,0x02,0x40]
+pmovzxbd 64(%edx,%eax), %xmm1
+
+// CHECK: pmovzxbd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x0a]
+pmovzxbd (%edx), %xmm1
+
+// CHECK: pmovzxbd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0xc9]
+pmovzxbd %xmm1, %xmm1
+
+// CHECK: pmovzxbq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovzxbq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxbq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovzxbq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxbq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovzxbq 485498096(%edx), %xmm1
+
+// CHECK: pmovzxbq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovzxbq 485498096, %xmm1
+
+// CHECK: pmovzxbq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x4c,0x02,0x40]
+pmovzxbq 64(%edx,%eax), %xmm1
+
+// CHECK: pmovzxbq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x0a]
+pmovzxbq (%edx), %xmm1
+
+// CHECK: pmovzxbq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0xc9]
+pmovzxbq %xmm1, %xmm1
+
+// CHECK: pmovzxbw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovzxbw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxbw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovzxbw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxbw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovzxbw 485498096(%edx), %xmm1
+
+// CHECK: pmovzxbw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovzxbw 485498096, %xmm1
+
+// CHECK: pmovzxbw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x4c,0x02,0x40]
+pmovzxbw 64(%edx,%eax), %xmm1
+
+// CHECK: pmovzxbw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x0a]
+pmovzxbw (%edx), %xmm1
+
+// CHECK: pmovzxbw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0xc9]
+pmovzxbw %xmm1, %xmm1
+
+// CHECK: pmovzxdq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovzxdq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxdq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovzxdq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxdq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovzxdq 485498096(%edx), %xmm1
+
+// CHECK: pmovzxdq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovzxdq 485498096, %xmm1
+
+// CHECK: pmovzxdq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x4c,0x02,0x40]
+pmovzxdq 64(%edx,%eax), %xmm1
+
+// CHECK: pmovzxdq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x0a]
+pmovzxdq (%edx), %xmm1
+
+// CHECK: pmovzxdq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0xc9]
+pmovzxdq %xmm1, %xmm1
+
+// CHECK: pmovzxwd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovzxwd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxwd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovzxwd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxwd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovzxwd 485498096(%edx), %xmm1
+
+// CHECK: pmovzxwd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovzxwd 485498096, %xmm1
+
+// CHECK: pmovzxwd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x4c,0x02,0x40]
+pmovzxwd 64(%edx,%eax), %xmm1
+
+// CHECK: pmovzxwd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x0a]
+pmovzxwd (%edx), %xmm1
+
+// CHECK: pmovzxwd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0xc9]
+pmovzxwd %xmm1, %xmm1
+
+// CHECK: pmovzxwq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmovzxwq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxwq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmovzxwq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmovzxwq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmovzxwq 485498096(%edx), %xmm1
+
+// CHECK: pmovzxwq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmovzxwq 485498096, %xmm1
+
+// CHECK: pmovzxwq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x4c,0x02,0x40]
+pmovzxwq 64(%edx,%eax), %xmm1
+
+// CHECK: pmovzxwq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x0a]
+pmovzxwq (%edx), %xmm1
+
+// CHECK: pmovzxwq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0xc9]
+pmovzxwq %xmm1, %xmm1
+
+// CHECK: pmuldq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmuldq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmuldq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmuldq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmuldq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmuldq 485498096(%edx), %xmm1
+
+// CHECK: pmuldq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmuldq 485498096, %xmm1
+
+// CHECK: pmuldq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x4c,0x02,0x40]
+pmuldq 64(%edx,%eax), %xmm1
+
+// CHECK: pmuldq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x0a]
+pmuldq (%edx), %xmm1
+
+// CHECK: pmuldq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0xc9]
+pmuldq %xmm1, %xmm1
+
+// CHECK: pmulld -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmulld -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmulld 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmulld 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmulld 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmulld 485498096(%edx), %xmm1
+
+// CHECK: pmulld 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmulld 485498096, %xmm1
+
+// CHECK: pmulld 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x4c,0x02,0x40]
+pmulld 64(%edx,%eax), %xmm1
+
+// CHECK: pmulld (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x0a]
+pmulld (%edx), %xmm1
+
+// CHECK: pmulld %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0xc9]
+pmulld %xmm1, %xmm1
+
+// CHECK: ptest -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+ptest -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: ptest 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+ptest 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: ptest 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x8a,0xf0,0x1c,0xf0,0x1c]
+ptest 485498096(%edx), %xmm1
+
+// CHECK: ptest 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x0d,0xf0,0x1c,0xf0,0x1c]
+ptest 485498096, %xmm1
+
+// CHECK: ptest 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x4c,0x02,0x40]
+ptest 64(%edx,%eax), %xmm1
+
+// CHECK: ptest (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x0a]
+ptest (%edx), %xmm1
+
+// CHECK: ptest %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0xc9]
+ptest %xmm1, %xmm1
+
+// CHECK: roundpd $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+roundpd $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: roundpd $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+roundpd $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: roundpd $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+roundpd $0, 485498096(%edx), %xmm1
+
+// CHECK: roundpd $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+roundpd $0, 485498096, %xmm1
+
+// CHECK: roundpd $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x4c,0x02,0x40,0x00]
+roundpd $0, 64(%edx,%eax), %xmm1
+
+// CHECK: roundpd $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x0a,0x00]
+roundpd $0, (%edx), %xmm1
+
+// CHECK: roundpd $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0xc9,0x00]
+roundpd $0, %xmm1, %xmm1
+
+// CHECK: roundps $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+roundps $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: roundps $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+roundps $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: roundps $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+roundps $0, 485498096(%edx), %xmm1
+
+// CHECK: roundps $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+roundps $0, 485498096, %xmm1
+
+// CHECK: roundps $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x4c,0x02,0x40,0x00]
+roundps $0, 64(%edx,%eax), %xmm1
+
+// CHECK: roundps $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x0a,0x00]
+roundps $0, (%edx), %xmm1
+
+// CHECK: roundps $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0xc9,0x00]
+roundps $0, %xmm1, %xmm1
+
+// CHECK: roundsd $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+roundsd $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: roundsd $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+roundsd $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: roundsd $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+roundsd $0, 485498096(%edx), %xmm1
+
+// CHECK: roundsd $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+roundsd $0, 485498096, %xmm1
+
+// CHECK: roundsd $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x4c,0x02,0x40,0x00]
+roundsd $0, 64(%edx,%eax), %xmm1
+
+// CHECK: roundsd $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x0a,0x00]
+roundsd $0, (%edx), %xmm1
+
+// CHECK: roundsd $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0xc9,0x00]
+roundsd $0, %xmm1, %xmm1
+
+// CHECK: roundss $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+roundss $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: roundss $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+roundss $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: roundss $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+roundss $0, 485498096(%edx), %xmm1
+
+// CHECK: roundss $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+roundss $0, 485498096, %xmm1
+
+// CHECK: roundss $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x4c,0x02,0x40,0x00]
+roundss $0, 64(%edx,%eax), %xmm1
+
+// CHECK: roundss $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x0a,0x00]
+roundss $0, (%edx), %xmm1
+
+// CHECK: roundss $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0xc9,0x00]
+roundss $0, %xmm1, %xmm1
+

test/MC/X86/SSE41-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: blendpd $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+blendpd $0, 485498096, %xmm6
+
+// CHECK: blendpd $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x74,0x82,0x40,0x00]
+blendpd $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: blendpd $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x74,0x82,0xc0,0x00]
+blendpd $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: blendpd $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x74,0x02,0x40,0x00]
+blendpd $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: blendpd $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x72,0x40,0x00]
+blendpd $0, 64(%rdx), %xmm6
+
+// CHECK: blendpd $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0x32,0x00]
+blendpd $0, (%rdx), %xmm6
+
+// CHECK: blendpd $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0d,0xf6,0x00]
+blendpd $0, %xmm6, %xmm6
+
+// CHECK: blendps $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+blendps $0, 485498096, %xmm6
+
+// CHECK: blendps $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x74,0x82,0x40,0x00]
+blendps $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: blendps $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x74,0x82,0xc0,0x00]
+blendps $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: blendps $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x74,0x02,0x40,0x00]
+blendps $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: blendps $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x72,0x40,0x00]
+blendps $0, 64(%rdx), %xmm6
+
+// CHECK: blendps $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0x32,0x00]
+blendps $0, (%rdx), %xmm6
+
+// CHECK: blendps $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0c,0xf6,0x00]
+blendps $0, %xmm6, %xmm6
+
+// CHECK: blendvpd %xmm0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+blendvpd %xmm0, 485498096, %xmm6
+
+// CHECK: blendvpd %xmm0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x74,0x82,0x40]
+blendvpd %xmm0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: blendvpd %xmm0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x74,0x82,0xc0]
+blendvpd %xmm0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: blendvpd %xmm0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x74,0x02,0x40]
+blendvpd %xmm0, 64(%rdx,%rax), %xmm6
+
+// CHECK: blendvpd %xmm0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x72,0x40]
+blendvpd %xmm0, 64(%rdx), %xmm6
+
+// CHECK: blendvpd %xmm0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0x32]
+blendvpd %xmm0, (%rdx), %xmm6
+
+// CHECK: blendvpd %xmm0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x15,0xf6]
+blendvpd %xmm0, %xmm6, %xmm6
+
+// CHECK: blendvps %xmm0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+blendvps %xmm0, 485498096, %xmm6
+
+// CHECK: blendvps %xmm0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x74,0x82,0x40]
+blendvps %xmm0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: blendvps %xmm0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x74,0x82,0xc0]
+blendvps %xmm0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: blendvps %xmm0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x74,0x02,0x40]
+blendvps %xmm0, 64(%rdx,%rax), %xmm6
+
+// CHECK: blendvps %xmm0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x72,0x40]
+blendvps %xmm0, 64(%rdx), %xmm6
+
+// CHECK: blendvps %xmm0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0x32]
+blendvps %xmm0, (%rdx), %xmm6
+
+// CHECK: blendvps %xmm0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x14,0xf6]
+blendvps %xmm0, %xmm6, %xmm6
+
+// CHECK: dppd $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+dppd $0, 485498096, %xmm6
+
+// CHECK: dppd $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x74,0x82,0x40,0x00]
+dppd $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: dppd $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x74,0x82,0xc0,0x00]
+dppd $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: dppd $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x74,0x02,0x40,0x00]
+dppd $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: dppd $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x72,0x40,0x00]
+dppd $0, 64(%rdx), %xmm6
+
+// CHECK: dppd $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0x32,0x00]
+dppd $0, (%rdx), %xmm6
+
+// CHECK: dppd $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x41,0xf6,0x00]
+dppd $0, %xmm6, %xmm6
+
+// CHECK: dpps $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+dpps $0, 485498096, %xmm6
+
+// CHECK: dpps $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x74,0x82,0x40,0x00]
+dpps $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: dpps $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x74,0x82,0xc0,0x00]
+dpps $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: dpps $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x74,0x02,0x40,0x00]
+dpps $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: dpps $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x72,0x40,0x00]
+dpps $0, 64(%rdx), %xmm6
+
+// CHECK: dpps $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0x32,0x00]
+dpps $0, (%rdx), %xmm6
+
+// CHECK: dpps $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x40,0xf6,0x00]
+dpps $0, %xmm6, %xmm6
+
+// CHECK: extractps $0, %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+extractps $0, %xmm6, 485498096
+
+// CHECK: extractps $0, %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x72,0x40,0x00]
+extractps $0, %xmm6, 64(%rdx)
+
+// CHECK: extractps $0, %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x74,0x82,0x40,0x00]
+extractps $0, %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: extractps $0, %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x74,0x82,0xc0,0x00]
+extractps $0, %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: extractps $0, %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x74,0x02,0x40,0x00]
+extractps $0, %xmm6, 64(%rdx,%rax)
+
+// CHECK: extractps $0, %xmm6, %r13d
+// CHECK: encoding: [0x66,0x41,0x0f,0x3a,0x17,0xf5,0x00]
+extractps $0, %xmm6, %r13d
+
+// CHECK: extractps $0, %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x17,0x32,0x00]
+extractps $0, %xmm6, (%rdx)
+
+// CHECK: insertps $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+insertps $0, 485498096, %xmm6
+
+// CHECK: insertps $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x74,0x82,0x40,0x00]
+insertps $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: insertps $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x74,0x82,0xc0,0x00]
+insertps $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: insertps $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x74,0x02,0x40,0x00]
+insertps $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: insertps $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x72,0x40,0x00]
+insertps $0, 64(%rdx), %xmm6
+
+// CHECK: insertps $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0x32,0x00]
+insertps $0, (%rdx), %xmm6
+
+// CHECK: insertps $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x21,0xf6,0x00]
+insertps $0, %xmm6, %xmm6
+
+// CHECK: movntdqa 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntdqa 485498096, %xmm6
+
+// CHECK: movntdqa 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x74,0x82,0x40]
+movntdqa 64(%rdx,%rax,4), %xmm6
+
+// CHECK: movntdqa -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x74,0x82,0xc0]
+movntdqa -64(%rdx,%rax,4), %xmm6
+
+// CHECK: movntdqa 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x74,0x02,0x40]
+movntdqa 64(%rdx,%rax), %xmm6
+
+// CHECK: movntdqa 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x72,0x40]
+movntdqa 64(%rdx), %xmm6
+
+// CHECK: movntdqa (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2a,0x32]
+movntdqa (%rdx), %xmm6
+
+// CHECK: mpsadbw $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+mpsadbw $0, 485498096, %xmm6
+
+// CHECK: mpsadbw $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x74,0x82,0x40,0x00]
+mpsadbw $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: mpsadbw $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x74,0x82,0xc0,0x00]
+mpsadbw $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: mpsadbw $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x74,0x02,0x40,0x00]
+mpsadbw $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: mpsadbw $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x72,0x40,0x00]
+mpsadbw $0, 64(%rdx), %xmm6
+
+// CHECK: mpsadbw $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0x32,0x00]
+mpsadbw $0, (%rdx), %xmm6
+
+// CHECK: mpsadbw $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x42,0xf6,0x00]
+mpsadbw $0, %xmm6, %xmm6
+
+// CHECK: packusdw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+packusdw 485498096, %xmm6
+
+// CHECK: packusdw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x74,0x82,0x40]
+packusdw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: packusdw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x74,0x82,0xc0]
+packusdw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: packusdw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x74,0x02,0x40]
+packusdw 64(%rdx,%rax), %xmm6
+
+// CHECK: packusdw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x72,0x40]
+packusdw 64(%rdx), %xmm6
+
+// CHECK: packusdw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0x32]
+packusdw (%rdx), %xmm6
+
+// CHECK: packusdw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x2b,0xf6]
+packusdw %xmm6, %xmm6
+
+// CHECK: pblendvb %xmm0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pblendvb %xmm0, 485498096, %xmm6
+
+// CHECK: pblendvb %xmm0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x74,0x82,0x40]
+pblendvb %xmm0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pblendvb %xmm0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x74,0x82,0xc0]
+pblendvb %xmm0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pblendvb %xmm0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x74,0x02,0x40]
+pblendvb %xmm0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pblendvb %xmm0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x72,0x40]
+pblendvb %xmm0, 64(%rdx), %xmm6
+
+// CHECK: pblendvb %xmm0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0x32]
+pblendvb %xmm0, (%rdx), %xmm6
+
+// CHECK: pblendvb %xmm0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x10,0xf6]
+pblendvb %xmm0, %xmm6, %xmm6
+
+// CHECK: pblendw $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pblendw $0, 485498096, %xmm6
+
+// CHECK: pblendw $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x74,0x82,0x40,0x00]
+pblendw $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pblendw $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x74,0x82,0xc0,0x00]
+pblendw $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pblendw $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x74,0x02,0x40,0x00]
+pblendw $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pblendw $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x72,0x40,0x00]
+pblendw $0, 64(%rdx), %xmm6
+
+// CHECK: pblendw $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0x32,0x00]
+pblendw $0, (%rdx), %xmm6
+
+// CHECK: pblendw $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0e,0xf6,0x00]
+pblendw $0, %xmm6, %xmm6
+
+// CHECK: pcmpeqq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pcmpeqq 485498096, %xmm6
+
+// CHECK: pcmpeqq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x74,0x82,0x40]
+pcmpeqq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpeqq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x74,0x82,0xc0]
+pcmpeqq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpeqq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x74,0x02,0x40]
+pcmpeqq 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpeqq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x72,0x40]
+pcmpeqq 64(%rdx), %xmm6
+
+// CHECK: pcmpeqq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0x32]
+pcmpeqq (%rdx), %xmm6
+
+// CHECK: pcmpeqq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x29,0xf6]
+pcmpeqq %xmm6, %xmm6
+
+// CHECK: pextrb $0, %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrb $0, %xmm6, 485498096
+
+// CHECK: pextrb $0, %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x72,0x40,0x00]
+pextrb $0, %xmm6, 64(%rdx)
+
+// CHECK: pextrb $0, %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x74,0x82,0x40,0x00]
+pextrb $0, %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: pextrb $0, %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x74,0x82,0xc0,0x00]
+pextrb $0, %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: pextrb $0, %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x74,0x02,0x40,0x00]
+pextrb $0, %xmm6, 64(%rdx,%rax)
+
+// CHECK: pextrb $0, %xmm6, %r13d
+// CHECK: encoding: [0x66,0x41,0x0f,0x3a,0x14,0xf5,0x00]
+pextrb $0, %xmm6, %r13d
+
+// CHECK: pextrb $0, %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x14,0x32,0x00]
+pextrb $0, %xmm6, (%rdx)
+
+// CHECK: pextrd $0, %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrd $0, %xmm6, 485498096
+
+// CHECK: pextrd $0, %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x72,0x40,0x00]
+pextrd $0, %xmm6, 64(%rdx)
+
+// CHECK: pextrd $0, %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x74,0x82,0x40,0x00]
+pextrd $0, %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: pextrd $0, %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x74,0x82,0xc0,0x00]
+pextrd $0, %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: pextrd $0, %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x74,0x02,0x40,0x00]
+pextrd $0, %xmm6, 64(%rdx,%rax)
+
+// CHECK: pextrd $0, %xmm6, %r13d
+// CHECK: encoding: [0x66,0x41,0x0f,0x3a,0x16,0xf5,0x00]
+pextrd $0, %xmm6, %r13d
+
+// CHECK: pextrd $0, %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x16,0x32,0x00]
+pextrd $0, %xmm6, (%rdx)
+
+// CHECK: pextrq $0, %xmm6, 485498096
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x16,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrq $0, %xmm6, 485498096
+
+// CHECK: pextrq $0, %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x16,0x72,0x40,0x00]
+pextrq $0, %xmm6, 64(%rdx)
+
+// CHECK: pextrq $0, %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x16,0x74,0x82,0x40,0x00]
+pextrq $0, %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: pextrq $0, %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x16,0x74,0x82,0xc0,0x00]
+pextrq $0, %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: pextrq $0, %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x16,0x74,0x02,0x40,0x00]
+pextrq $0, %xmm6, 64(%rdx,%rax)
+
+// CHECK: pextrq $0, %xmm6, %r15
+// CHECK: encoding: [0x66,0x49,0x0f,0x3a,0x16,0xf7,0x00]
+pextrq $0, %xmm6, %r15
+
+// CHECK: pextrq $0, %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x16,0x32,0x00]
+pextrq $0, %xmm6, (%rdx)
+
+// CHECK: pextrw $0, %xmm6, 485498096
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pextrw $0, %xmm6, 485498096
+
+// CHECK: pextrw $0, %xmm6, 64(%rdx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x72,0x40,0x00]
+pextrw $0, %xmm6, 64(%rdx)
+
+// CHECK: pextrw $0, %xmm6, 64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x74,0x82,0x40,0x00]
+pextrw $0, %xmm6, 64(%rdx,%rax,4)
+
+// CHECK: pextrw $0, %xmm6, -64(%rdx,%rax,4)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x74,0x82,0xc0,0x00]
+pextrw $0, %xmm6, -64(%rdx,%rax,4)
+
+// CHECK: pextrw $0, %xmm6, 64(%rdx,%rax)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x74,0x02,0x40,0x00]
+pextrw $0, %xmm6, 64(%rdx,%rax)
+
+// CHECK: pextrw $0, %xmm6, %r13d
+// CHECK: encoding: [0x66,0x44,0x0f,0xc5,0xee,0x00]
+pextrw $0, %xmm6, %r13d
+
+// CHECK: pextrw $0, %xmm6, (%rdx)
+// CHECK: encoding: [0x66,0x0f,0x3a,0x15,0x32,0x00]
+pextrw $0, %xmm6, (%rdx)
+
+// CHECK: phminposuw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+phminposuw 485498096, %xmm6
+
+// CHECK: phminposuw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x74,0x82,0x40]
+phminposuw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: phminposuw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x74,0x82,0xc0]
+phminposuw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: phminposuw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x74,0x02,0x40]
+phminposuw 64(%rdx,%rax), %xmm6
+
+// CHECK: phminposuw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x72,0x40]
+phminposuw 64(%rdx), %xmm6
+
+// CHECK: phminposuw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0x32]
+phminposuw (%rdx), %xmm6
+
+// CHECK: phminposuw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x41,0xf6]
+phminposuw %xmm6, %xmm6
+
+// CHECK: pinsrb $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrb $0, 485498096, %xmm6
+
+// CHECK: pinsrb $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x74,0x82,0x40,0x00]
+pinsrb $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pinsrb $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x74,0x82,0xc0,0x00]
+pinsrb $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pinsrb $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x74,0x02,0x40,0x00]
+pinsrb $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pinsrb $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x72,0x40,0x00]
+pinsrb $0, 64(%rdx), %xmm6
+
+// CHECK: pinsrb $0, %r13d, %xmm6
+// CHECK: encoding: [0x66,0x41,0x0f,0x3a,0x20,0xf5,0x00]
+pinsrb $0, %r13d, %xmm6
+
+// CHECK: pinsrb $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x20,0x32,0x00]
+pinsrb $0, (%rdx), %xmm6
+
+// CHECK: pinsrd $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrd $0, 485498096, %xmm6
+
+// CHECK: pinsrd $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x74,0x82,0x40,0x00]
+pinsrd $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pinsrd $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x74,0x82,0xc0,0x00]
+pinsrd $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pinsrd $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x74,0x02,0x40,0x00]
+pinsrd $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pinsrd $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x72,0x40,0x00]
+pinsrd $0, 64(%rdx), %xmm6
+
+// CHECK: pinsrd $0, %r13d, %xmm6
+// CHECK: encoding: [0x66,0x41,0x0f,0x3a,0x22,0xf5,0x00]
+pinsrd $0, %r13d, %xmm6
+
+// CHECK: pinsrd $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x22,0x32,0x00]
+pinsrd $0, (%rdx), %xmm6
+
+// CHECK: pinsrq $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x22,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pinsrq $0, 485498096, %xmm6
+
+// CHECK: pinsrq $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x22,0x74,0x82,0x40,0x00]
+pinsrq $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pinsrq $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x22,0x74,0x82,0xc0,0x00]
+pinsrq $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pinsrq $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x22,0x74,0x02,0x40,0x00]
+pinsrq $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pinsrq $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x22,0x72,0x40,0x00]
+pinsrq $0, 64(%rdx), %xmm6
+
+// CHECK: pinsrq $0, %r15, %xmm6
+// CHECK: encoding: [0x66,0x49,0x0f,0x3a,0x22,0xf7,0x00]
+pinsrq $0, %r15, %xmm6
+
+// CHECK: pinsrq $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x48,0x0f,0x3a,0x22,0x32,0x00]
+pinsrq $0, (%rdx), %xmm6
+
+// CHECK: pmaxsb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaxsb 485498096, %xmm6
+
+// CHECK: pmaxsb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x74,0x82,0x40]
+pmaxsb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxsb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x74,0x82,0xc0]
+pmaxsb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxsb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x74,0x02,0x40]
+pmaxsb 64(%rdx,%rax), %xmm6
+
+// CHECK: pmaxsb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x72,0x40]
+pmaxsb 64(%rdx), %xmm6
+
+// CHECK: pmaxsb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0x32]
+pmaxsb (%rdx), %xmm6
+
+// CHECK: pmaxsb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3c,0xf6]
+pmaxsb %xmm6, %xmm6
+
+// CHECK: pmaxsd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaxsd 485498096, %xmm6
+
+// CHECK: pmaxsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x74,0x82,0x40]
+pmaxsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x74,0x82,0xc0]
+pmaxsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x74,0x02,0x40]
+pmaxsd 64(%rdx,%rax), %xmm6
+
+// CHECK: pmaxsd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x72,0x40]
+pmaxsd 64(%rdx), %xmm6
+
+// CHECK: pmaxsd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0x32]
+pmaxsd (%rdx), %xmm6
+
+// CHECK: pmaxsd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3d,0xf6]
+pmaxsd %xmm6, %xmm6
+
+// CHECK: pmaxud 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaxud 485498096, %xmm6
+
+// CHECK: pmaxud 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x74,0x82,0x40]
+pmaxud 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxud -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x74,0x82,0xc0]
+pmaxud -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxud 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x74,0x02,0x40]
+pmaxud 64(%rdx,%rax), %xmm6
+
+// CHECK: pmaxud 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x72,0x40]
+pmaxud 64(%rdx), %xmm6
+
+// CHECK: pmaxud (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0x32]
+pmaxud (%rdx), %xmm6
+
+// CHECK: pmaxud %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3f,0xf6]
+pmaxud %xmm6, %xmm6
+
+// CHECK: pmaxuw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaxuw 485498096, %xmm6
+
+// CHECK: pmaxuw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x74,0x82,0x40]
+pmaxuw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxuw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x74,0x82,0xc0]
+pmaxuw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaxuw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x74,0x02,0x40]
+pmaxuw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmaxuw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x72,0x40]
+pmaxuw 64(%rdx), %xmm6
+
+// CHECK: pmaxuw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0x32]
+pmaxuw (%rdx), %xmm6
+
+// CHECK: pmaxuw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3e,0xf6]
+pmaxuw %xmm6, %xmm6
+
+// CHECK: pminsb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pminsb 485498096, %xmm6
+
+// CHECK: pminsb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x74,0x82,0x40]
+pminsb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminsb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x74,0x82,0xc0]
+pminsb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminsb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x74,0x02,0x40]
+pminsb 64(%rdx,%rax), %xmm6
+
+// CHECK: pminsb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x72,0x40]
+pminsb 64(%rdx), %xmm6
+
+// CHECK: pminsb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0x32]
+pminsb (%rdx), %xmm6
+
+// CHECK: pminsb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x38,0xf6]
+pminsb %xmm6, %xmm6
+
+// CHECK: pminsd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pminsd 485498096, %xmm6
+
+// CHECK: pminsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x74,0x82,0x40]
+pminsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x74,0x82,0xc0]
+pminsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x74,0x02,0x40]
+pminsd 64(%rdx,%rax), %xmm6
+
+// CHECK: pminsd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x72,0x40]
+pminsd 64(%rdx), %xmm6
+
+// CHECK: pminsd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0x32]
+pminsd (%rdx), %xmm6
+
+// CHECK: pminsd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x39,0xf6]
+pminsd %xmm6, %xmm6
+
+// CHECK: pminud 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pminud 485498096, %xmm6
+
+// CHECK: pminud 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x74,0x82,0x40]
+pminud 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminud -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x74,0x82,0xc0]
+pminud -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminud 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x74,0x02,0x40]
+pminud 64(%rdx,%rax), %xmm6
+
+// CHECK: pminud 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x72,0x40]
+pminud 64(%rdx), %xmm6
+
+// CHECK: pminud (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0x32]
+pminud (%rdx), %xmm6
+
+// CHECK: pminud %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3b,0xf6]
+pminud %xmm6, %xmm6
+
+// CHECK: pminuw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pminuw 485498096, %xmm6
+
+// CHECK: pminuw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x74,0x82,0x40]
+pminuw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminuw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x74,0x82,0xc0]
+pminuw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pminuw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x74,0x02,0x40]
+pminuw 64(%rdx,%rax), %xmm6
+
+// CHECK: pminuw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x72,0x40]
+pminuw 64(%rdx), %xmm6
+
+// CHECK: pminuw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0x32]
+pminuw (%rdx), %xmm6
+
+// CHECK: pminuw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x3a,0xf6]
+pminuw %xmm6, %xmm6
+
+// CHECK: pmovsxbd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovsxbd 485498096, %xmm6
+
+// CHECK: pmovsxbd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x74,0x82,0x40]
+pmovsxbd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxbd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x74,0x82,0xc0]
+pmovsxbd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxbd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x74,0x02,0x40]
+pmovsxbd 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovsxbd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x72,0x40]
+pmovsxbd 64(%rdx), %xmm6
+
+// CHECK: pmovsxbd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0x32]
+pmovsxbd (%rdx), %xmm6
+
+// CHECK: pmovsxbd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x21,0xf6]
+pmovsxbd %xmm6, %xmm6
+
+// CHECK: pmovsxbq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovsxbq 485498096, %xmm6
+
+// CHECK: pmovsxbq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x74,0x82,0x40]
+pmovsxbq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxbq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x74,0x82,0xc0]
+pmovsxbq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxbq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x74,0x02,0x40]
+pmovsxbq 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovsxbq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x72,0x40]
+pmovsxbq 64(%rdx), %xmm6
+
+// CHECK: pmovsxbq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0x32]
+pmovsxbq (%rdx), %xmm6
+
+// CHECK: pmovsxbq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x22,0xf6]
+pmovsxbq %xmm6, %xmm6
+
+// CHECK: pmovsxbw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovsxbw 485498096, %xmm6
+
+// CHECK: pmovsxbw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x74,0x82,0x40]
+pmovsxbw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxbw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x74,0x82,0xc0]
+pmovsxbw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxbw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x74,0x02,0x40]
+pmovsxbw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovsxbw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x72,0x40]
+pmovsxbw 64(%rdx), %xmm6
+
+// CHECK: pmovsxbw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0x32]
+pmovsxbw (%rdx), %xmm6
+
+// CHECK: pmovsxbw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x20,0xf6]
+pmovsxbw %xmm6, %xmm6
+
+// CHECK: pmovsxdq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovsxdq 485498096, %xmm6
+
+// CHECK: pmovsxdq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x74,0x82,0x40]
+pmovsxdq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxdq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x74,0x82,0xc0]
+pmovsxdq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxdq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x74,0x02,0x40]
+pmovsxdq 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovsxdq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x72,0x40]
+pmovsxdq 64(%rdx), %xmm6
+
+// CHECK: pmovsxdq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0x32]
+pmovsxdq (%rdx), %xmm6
+
+// CHECK: pmovsxdq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x25,0xf6]
+pmovsxdq %xmm6, %xmm6
+
+// CHECK: pmovsxwd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovsxwd 485498096, %xmm6
+
+// CHECK: pmovsxwd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x74,0x82,0x40]
+pmovsxwd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxwd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x74,0x82,0xc0]
+pmovsxwd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxwd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x74,0x02,0x40]
+pmovsxwd 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovsxwd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x72,0x40]
+pmovsxwd 64(%rdx), %xmm6
+
+// CHECK: pmovsxwd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0x32]
+pmovsxwd (%rdx), %xmm6
+
+// CHECK: pmovsxwd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x23,0xf6]
+pmovsxwd %xmm6, %xmm6
+
+// CHECK: pmovsxwq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovsxwq 485498096, %xmm6
+
+// CHECK: pmovsxwq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x74,0x82,0x40]
+pmovsxwq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxwq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x74,0x82,0xc0]
+pmovsxwq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovsxwq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x74,0x02,0x40]
+pmovsxwq 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovsxwq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x72,0x40]
+pmovsxwq 64(%rdx), %xmm6
+
+// CHECK: pmovsxwq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0x32]
+pmovsxwq (%rdx), %xmm6
+
+// CHECK: pmovsxwq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x24,0xf6]
+pmovsxwq %xmm6, %xmm6
+
+// CHECK: pmovzxbd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovzxbd 485498096, %xmm6
+
+// CHECK: pmovzxbd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x74,0x82,0x40]
+pmovzxbd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxbd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x74,0x82,0xc0]
+pmovzxbd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxbd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x74,0x02,0x40]
+pmovzxbd 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovzxbd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x72,0x40]
+pmovzxbd 64(%rdx), %xmm6
+
+// CHECK: pmovzxbd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0x32]
+pmovzxbd (%rdx), %xmm6
+
+// CHECK: pmovzxbd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x31,0xf6]
+pmovzxbd %xmm6, %xmm6
+
+// CHECK: pmovzxbq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovzxbq 485498096, %xmm6
+
+// CHECK: pmovzxbq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x74,0x82,0x40]
+pmovzxbq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxbq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x74,0x82,0xc0]
+pmovzxbq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxbq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x74,0x02,0x40]
+pmovzxbq 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovzxbq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x72,0x40]
+pmovzxbq 64(%rdx), %xmm6
+
+// CHECK: pmovzxbq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0x32]
+pmovzxbq (%rdx), %xmm6
+
+// CHECK: pmovzxbq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x32,0xf6]
+pmovzxbq %xmm6, %xmm6
+
+// CHECK: pmovzxbw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovzxbw 485498096, %xmm6
+
+// CHECK: pmovzxbw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x74,0x82,0x40]
+pmovzxbw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxbw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x74,0x82,0xc0]
+pmovzxbw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxbw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x74,0x02,0x40]
+pmovzxbw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovzxbw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x72,0x40]
+pmovzxbw 64(%rdx), %xmm6
+
+// CHECK: pmovzxbw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0x32]
+pmovzxbw (%rdx), %xmm6
+
+// CHECK: pmovzxbw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x30,0xf6]
+pmovzxbw %xmm6, %xmm6
+
+// CHECK: pmovzxdq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovzxdq 485498096, %xmm6
+
+// CHECK: pmovzxdq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x74,0x82,0x40]
+pmovzxdq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxdq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x74,0x82,0xc0]
+pmovzxdq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxdq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x74,0x02,0x40]
+pmovzxdq 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovzxdq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x72,0x40]
+pmovzxdq 64(%rdx), %xmm6
+
+// CHECK: pmovzxdq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0x32]
+pmovzxdq (%rdx), %xmm6
+
+// CHECK: pmovzxdq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x35,0xf6]
+pmovzxdq %xmm6, %xmm6
+
+// CHECK: pmovzxwd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovzxwd 485498096, %xmm6
+
+// CHECK: pmovzxwd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x74,0x82,0x40]
+pmovzxwd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxwd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x74,0x82,0xc0]
+pmovzxwd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxwd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x74,0x02,0x40]
+pmovzxwd 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovzxwd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x72,0x40]
+pmovzxwd 64(%rdx), %xmm6
+
+// CHECK: pmovzxwd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0x32]
+pmovzxwd (%rdx), %xmm6
+
+// CHECK: pmovzxwd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x33,0xf6]
+pmovzxwd %xmm6, %xmm6
+
+// CHECK: pmovzxwq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmovzxwq 485498096, %xmm6
+
+// CHECK: pmovzxwq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x74,0x82,0x40]
+pmovzxwq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxwq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x74,0x82,0xc0]
+pmovzxwq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmovzxwq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x74,0x02,0x40]
+pmovzxwq 64(%rdx,%rax), %xmm6
+
+// CHECK: pmovzxwq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x72,0x40]
+pmovzxwq 64(%rdx), %xmm6
+
+// CHECK: pmovzxwq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0x32]
+pmovzxwq (%rdx), %xmm6
+
+// CHECK: pmovzxwq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x34,0xf6]
+pmovzxwq %xmm6, %xmm6
+
+// CHECK: pmuldq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmuldq 485498096, %xmm6
+
+// CHECK: pmuldq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x74,0x82,0x40]
+pmuldq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmuldq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x74,0x82,0xc0]
+pmuldq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmuldq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x74,0x02,0x40]
+pmuldq 64(%rdx,%rax), %xmm6
+
+// CHECK: pmuldq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x72,0x40]
+pmuldq 64(%rdx), %xmm6
+
+// CHECK: pmuldq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0x32]
+pmuldq (%rdx), %xmm6
+
+// CHECK: pmuldq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x28,0xf6]
+pmuldq %xmm6, %xmm6
+
+// CHECK: pmulld 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmulld 485498096, %xmm6
+
+// CHECK: pmulld 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x74,0x82,0x40]
+pmulld 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmulld -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x74,0x82,0xc0]
+pmulld -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmulld 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x74,0x02,0x40]
+pmulld 64(%rdx,%rax), %xmm6
+
+// CHECK: pmulld 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x72,0x40]
+pmulld 64(%rdx), %xmm6
+
+// CHECK: pmulld (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0x32]
+pmulld (%rdx), %xmm6
+
+// CHECK: pmulld %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x40,0xf6]
+pmulld %xmm6, %xmm6
+
+// CHECK: ptest 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+ptest 485498096, %xmm6
+
+// CHECK: ptest 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x74,0x82,0x40]
+ptest 64(%rdx,%rax,4), %xmm6
+
+// CHECK: ptest -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x74,0x82,0xc0]
+ptest -64(%rdx,%rax,4), %xmm6
+
+// CHECK: ptest 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x74,0x02,0x40]
+ptest 64(%rdx,%rax), %xmm6
+
+// CHECK: ptest 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x72,0x40]
+ptest 64(%rdx), %xmm6
+
+// CHECK: ptest (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0x32]
+ptest (%rdx), %xmm6
+
+// CHECK: ptest %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x17,0xf6]
+ptest %xmm6, %xmm6
+
+// CHECK: roundpd $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+roundpd $0, 485498096, %xmm6
+
+// CHECK: roundpd $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x74,0x82,0x40,0x00]
+roundpd $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: roundpd $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x74,0x82,0xc0,0x00]
+roundpd $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: roundpd $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x74,0x02,0x40,0x00]
+roundpd $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: roundpd $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x72,0x40,0x00]
+roundpd $0, 64(%rdx), %xmm6
+
+// CHECK: roundpd $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0x32,0x00]
+roundpd $0, (%rdx), %xmm6
+
+// CHECK: roundpd $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x09,0xf6,0x00]
+roundpd $0, %xmm6, %xmm6
+
+// CHECK: roundps $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+roundps $0, 485498096, %xmm6
+
+// CHECK: roundps $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x74,0x82,0x40,0x00]
+roundps $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: roundps $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x74,0x82,0xc0,0x00]
+roundps $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: roundps $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x74,0x02,0x40,0x00]
+roundps $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: roundps $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x72,0x40,0x00]
+roundps $0, 64(%rdx), %xmm6
+
+// CHECK: roundps $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0x32,0x00]
+roundps $0, (%rdx), %xmm6
+
+// CHECK: roundps $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x08,0xf6,0x00]
+roundps $0, %xmm6, %xmm6
+
+// CHECK: roundsd $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+roundsd $0, 485498096, %xmm6
+
+// CHECK: roundsd $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x74,0x82,0x40,0x00]
+roundsd $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: roundsd $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x74,0x82,0xc0,0x00]
+roundsd $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: roundsd $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x74,0x02,0x40,0x00]
+roundsd $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: roundsd $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x72,0x40,0x00]
+roundsd $0, 64(%rdx), %xmm6
+
+// CHECK: roundsd $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0x32,0x00]
+roundsd $0, (%rdx), %xmm6
+
+// CHECK: roundsd $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0xf6,0x00]
+roundsd $0, %xmm6, %xmm6
+
+// CHECK: roundss $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+roundss $0, 485498096, %xmm6
+
+// CHECK: roundss $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x74,0x82,0x40,0x00]
+roundss $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: roundss $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x74,0x82,0xc0,0x00]
+roundss $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: roundss $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x74,0x02,0x40,0x00]
+roundss $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: roundss $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x72,0x40,0x00]
+roundss $0, 64(%rdx), %xmm6
+
+// CHECK: roundss $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0x32,0x00]
+roundss $0, (%rdx), %xmm6
+
+// CHECK: roundss $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0xf6,0x00]
+roundss $0, %xmm6, %xmm6
+

test/MC/X86/SSE42-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: pcmpestri $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pcmpestri $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpestri $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpestri $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpestri $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpestri $0, 485498096(%edx), %xmm1
+
+// CHECK: pcmpestri $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpestri $0, 485498096, %xmm1
+
+// CHECK: pcmpestri $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x4c,0x02,0x40,0x00]
+pcmpestri $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpestri $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x0a,0x00]
+pcmpestri $0, (%edx), %xmm1
+
+// CHECK: pcmpestri $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0xc9,0x00]
+pcmpestri $0, %xmm1, %xmm1
+
+// CHECK: pcmpestrm $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pcmpestrm $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpestrm $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpestrm $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpestrm $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpestrm $0, 485498096(%edx), %xmm1
+
+// CHECK: pcmpestrm $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpestrm $0, 485498096, %xmm1
+
+// CHECK: pcmpestrm $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x4c,0x02,0x40,0x00]
+pcmpestrm $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpestrm $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x0a,0x00]
+pcmpestrm $0, (%edx), %xmm1
+
+// CHECK: pcmpestrm $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0xc9,0x00]
+pcmpestrm $0, %xmm1, %xmm1
+
+// CHECK: pcmpgtq -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pcmpgtq -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpgtq 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pcmpgtq 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpgtq 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x8a,0xf0,0x1c,0xf0,0x1c]
+pcmpgtq 485498096(%edx), %xmm1
+
+// CHECK: pcmpgtq 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x0d,0xf0,0x1c,0xf0,0x1c]
+pcmpgtq 485498096, %xmm1
+
+// CHECK: pcmpgtq 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x4c,0x02,0x40]
+pcmpgtq 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpgtq (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x0a]
+pcmpgtq (%edx), %xmm1
+
+// CHECK: pcmpgtq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0xc9]
+pcmpgtq %xmm1, %xmm1
+
+// CHECK: pcmpistri $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pcmpistri $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpistri $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpistri $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpistri $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpistri $0, 485498096(%edx), %xmm1
+
+// CHECK: pcmpistri $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpistri $0, 485498096, %xmm1
+
+// CHECK: pcmpistri $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x4c,0x02,0x40,0x00]
+pcmpistri $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpistri $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x0a,0x00]
+pcmpistri $0, (%edx), %xmm1
+
+// CHECK: pcmpistri $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0xc9,0x00]
+pcmpistri $0, %xmm1, %xmm1
+
+// CHECK: pcmpistrm $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+pcmpistrm $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpistrm $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpistrm $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pcmpistrm $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpistrm $0, 485498096(%edx), %xmm1
+
+// CHECK: pcmpistrm $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpistrm $0, 485498096, %xmm1
+
+// CHECK: pcmpistrm $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x4c,0x02,0x40,0x00]
+pcmpistrm $0, 64(%edx,%eax), %xmm1
+
+// CHECK: pcmpistrm $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x0a,0x00]
+pcmpistrm $0, (%edx), %xmm1
+
+// CHECK: pcmpistrm $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0xc9,0x00]
+pcmpistrm $0, %xmm1, %xmm1
+

test/MC/X86/SSE42-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: crc32b 485498096, %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x38,0xf0,0x2c,0x25,0xf0,0x1c,0xf0,0x1c]
+crc32b 485498096, %r13d
+
+// CHECK: crc32b 64(%rdx), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x38,0xf0,0x6a,0x40]
+crc32b 64(%rdx), %r13d
+
+// CHECK: crc32b -64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x38,0xf0,0x6c,0x82,0xc0]
+crc32b -64(%rdx,%rax,4), %r13d
+
+// CHECK: crc32b 64(%rdx,%rax,4), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x38,0xf0,0x6c,0x82,0x40]
+crc32b 64(%rdx,%rax,4), %r13d
+
+// CHECK: crc32b 64(%rdx,%rax), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x38,0xf0,0x6c,0x02,0x40]
+crc32b 64(%rdx,%rax), %r13d
+
+// CHECK: crc32b %r14b, %r13d
+// CHECK: encoding: [0xf2,0x45,0x0f,0x38,0xf0,0xee]
+crc32b %r14b, %r13d
+
+// CHECK: crc32b (%rdx), %r13d
+// CHECK: encoding: [0xf2,0x44,0x0f,0x38,0xf0,0x2a]
+crc32b (%rdx), %r13d
+
+// CHECK: crc32l %r13d, %r13d
+// CHECK: encoding: [0xf2,0x45,0x0f,0x38,0xf1,0xed]
+crc32l %r13d, %r13d
+
+// CHECK: pcmpestri $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpestri $0, 485498096, %xmm6
+
+// CHECK: pcmpestri $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x74,0x82,0xc0,0x00]
+pcmpestri $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpestri $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x74,0x82,0x40,0x00]
+pcmpestri $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpestri $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x74,0x02,0x40,0x00]
+pcmpestri $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpestri $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x72,0x40,0x00]
+pcmpestri $0, 64(%rdx), %xmm6
+
+// CHECK: pcmpestri $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0x32,0x00]
+pcmpestri $0, (%rdx), %xmm6
+
+// CHECK: pcmpestri $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x61,0xf6,0x00]
+pcmpestri $0, %xmm6, %xmm6
+
+// CHECK: pcmpestrm $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpestrm $0, 485498096, %xmm6
+
+// CHECK: pcmpestrm $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x74,0x82,0xc0,0x00]
+pcmpestrm $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpestrm $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x74,0x82,0x40,0x00]
+pcmpestrm $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpestrm $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x74,0x02,0x40,0x00]
+pcmpestrm $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpestrm $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x72,0x40,0x00]
+pcmpestrm $0, 64(%rdx), %xmm6
+
+// CHECK: pcmpestrm $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0x32,0x00]
+pcmpestrm $0, (%rdx), %xmm6
+
+// CHECK: pcmpestrm $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x60,0xf6,0x00]
+pcmpestrm $0, %xmm6, %xmm6
+
+// CHECK: pcmpgtq 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pcmpgtq 485498096, %xmm6
+
+// CHECK: pcmpgtq -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x74,0x82,0xc0]
+pcmpgtq -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpgtq 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x74,0x82,0x40]
+pcmpgtq 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpgtq 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x74,0x02,0x40]
+pcmpgtq 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpgtq 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x72,0x40]
+pcmpgtq 64(%rdx), %xmm6
+
+// CHECK: pcmpgtq (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0x32]
+pcmpgtq (%rdx), %xmm6
+
+// CHECK: pcmpgtq %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x37,0xf6]
+pcmpgtq %xmm6, %xmm6
+
+// CHECK: pcmpistri $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpistri $0, 485498096, %xmm6
+
+// CHECK: pcmpistri $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x74,0x82,0xc0,0x00]
+pcmpistri $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpistri $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x74,0x82,0x40,0x00]
+pcmpistri $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpistri $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x74,0x02,0x40,0x00]
+pcmpistri $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpistri $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x72,0x40,0x00]
+pcmpistri $0, 64(%rdx), %xmm6
+
+// CHECK: pcmpistri $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0x32,0x00]
+pcmpistri $0, (%rdx), %xmm6
+
+// CHECK: pcmpistri $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x63,0xf6,0x00]
+pcmpistri $0, %xmm6, %xmm6
+
+// CHECK: pcmpistrm $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+pcmpistrm $0, 485498096, %xmm6
+
+// CHECK: pcmpistrm $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x74,0x82,0xc0,0x00]
+pcmpistrm $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpistrm $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x74,0x82,0x40,0x00]
+pcmpistrm $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pcmpistrm $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x74,0x02,0x40,0x00]
+pcmpistrm $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: pcmpistrm $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x72,0x40,0x00]
+pcmpistrm $0, 64(%rdx), %xmm6
+
+// CHECK: pcmpistrm $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0x32,0x00]
+pcmpistrm $0, (%rdx), %xmm6
+
+// CHECK: pcmpistrm $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x62,0xf6,0x00]
+pcmpistrm $0, %xmm6, %xmm6
+

test/MC/X86/SSE4a-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: extrq $0, $0, %xmm0
+// CHECK: encoding: [0x66,0x0f,0x78,0xc0,0x00,0x00]
+extrq $0, $0, %xmm0
+
+// CHECK: extrq %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x79,0xc9]
+extrq %xmm1, %xmm1
+
+// CHECK: insertq $0, $0, %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x78,0xc9,0x00,0x00]
+insertq $0, $0, %xmm1, %xmm1
+
+// CHECK: insertq %xmm1, %xmm1
+// CHECK: encoding: [0xf2,0x0f,0x79,0xc9]
+insertq %xmm1, %xmm1
+
+// CHECK: movntsd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf2,0x0f,0x2b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movntsd %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movntsd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf2,0x0f,0x2b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movntsd %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movntsd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0xf2,0x0f,0x2b,0x8a,0xf0,0x1c,0xf0,0x1c]
+movntsd %xmm1, 485498096(%edx)
+
+// CHECK: movntsd %xmm1, 485498096
+// CHECK: encoding: [0xf2,0x0f,0x2b,0x0d,0xf0,0x1c,0xf0,0x1c]
+movntsd %xmm1, 485498096
+
+// CHECK: movntsd %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0xf2,0x0f,0x2b,0x4c,0x02,0x40]
+movntsd %xmm1, 64(%edx,%eax)
+
+// CHECK: movntsd %xmm1, (%edx)
+// CHECK: encoding: [0xf2,0x0f,0x2b,0x0a]
+movntsd %xmm1, (%edx)
+
+// CHECK: movntss %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf3,0x0f,0x2b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+movntss %xmm1, -485498096(%edx,%eax,4)
+
+// CHECK: movntss %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0xf3,0x0f,0x2b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+movntss %xmm1, 485498096(%edx,%eax,4)
+
+// CHECK: movntss %xmm1, 485498096(%edx)
+// CHECK: encoding: [0xf3,0x0f,0x2b,0x8a,0xf0,0x1c,0xf0,0x1c]
+movntss %xmm1, 485498096(%edx)
+
+// CHECK: movntss %xmm1, 485498096
+// CHECK: encoding: [0xf3,0x0f,0x2b,0x0d,0xf0,0x1c,0xf0,0x1c]
+movntss %xmm1, 485498096
+
+// CHECK: movntss %xmm1, 64(%edx,%eax)
+// CHECK: encoding: [0xf3,0x0f,0x2b,0x4c,0x02,0x40]
+movntss %xmm1, 64(%edx,%eax)
+
+// CHECK: movntss %xmm1, (%edx)
+// CHECK: encoding: [0xf3,0x0f,0x2b,0x0a]
+movntss %xmm1, (%edx)

test/MC/X86/SSE4a-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: extrq $0, $0, %xmm8
+// CHECK: encoding: [0x66,0x41,0x0f,0x78,0xc0,0x00,0x00]
+extrq $0, $0, %xmm8
+
+// CHECK: extrq %xmm8, %xmm8
+// CHECK: encoding: [0x66,0x45,0x0f,0x79,0xc0]
+extrq %xmm8, %xmm8
+
+// CHECK: insertq $0, $0, %xmm14, %xmm14
+// CHECK: encoding: [0xf2,0x45,0x0f,0x78,0xf6,0x00,0x00]
+insertq $0, $0, %xmm14, %xmm14
+
+// CHECK: insertq %xmm14, %xmm14
+// CHECK: encoding: [0xf2,0x45,0x0f,0x79,0xf6]
+insertq %xmm14, %xmm14
+
+// CHECK: movntsd %xmm6, 485498096
+// CHECK: encoding: [0xf2,0x0f,0x2b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntsd %xmm6, 485498096
+
+// CHECK: movntsd %xmm14, 485498096
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntsd %xmm14, 485498096
+
+// CHECK: movntsd %xmm14, 64(%rdx)
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2b,0x72,0x40]
+movntsd %xmm14, 64(%rdx)
+
+// CHECK: movntsd %xmm14, 64(%rdx,%rax,4)
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2b,0x74,0x82,0x40]
+movntsd %xmm14, 64(%rdx,%rax,4)
+
+// CHECK: movntsd %xmm14, -64(%rdx,%rax,4)
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2b,0x74,0x82,0xc0]
+movntsd %xmm14, -64(%rdx,%rax,4)
+
+// CHECK: movntsd %xmm14, 64(%rdx,%rax)
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2b,0x74,0x02,0x40]
+movntsd %xmm14, 64(%rdx,%rax)
+
+// CHECK: movntsd %xmm14, (%rdx)
+// CHECK: encoding: [0xf2,0x44,0x0f,0x2b,0x32]
+movntsd %xmm14, (%rdx)
+
+// CHECK: movntss %xmm6, 485498096
+// CHECK: encoding: [0xf3,0x0f,0x2b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntss %xmm6, 485498096
+
+// CHECK: movntss %xmm14, 485498096
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntss %xmm14, 485498096
+
+// CHECK: movntss %xmm14, 485498096
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+movntss %xmm14, 485498096
+
+// CHECK: movntss %xmm14, 64(%rdx)
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2b,0x72,0x40]
+movntss %xmm14, 64(%rdx)
+
+// CHECK: movntss %xmm14, 64(%rdx,%rax,4)
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2b,0x74,0x82,0x40]
+movntss %xmm14, 64(%rdx,%rax,4)
+
+// CHECK: movntss %xmm14, -64(%rdx,%rax,4)
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2b,0x74,0x82,0xc0]
+movntss %xmm14, -64(%rdx,%rax,4)
+
+// CHECK: movntss %xmm14, 64(%rdx,%rax)
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2b,0x74,0x02,0x40]
+movntss %xmm14, 64(%rdx,%rax)
+
+// CHECK: movntss %xmm14, (%rdx)
+// CHECK: encoding: [0xf3,0x44,0x0f,0x2b,0x32]
+movntss %xmm14, (%rdx)

test/MC/X86/SSEMXCSR-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: ldmxcsr -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0xae,0x94,0x82,0x10,0xe3,0x0f,0xe3]
+ldmxcsr -485498096(%edx,%eax,4)
+
+// CHECK: ldmxcsr 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0xae,0x94,0x82,0xf0,0x1c,0xf0,0x1c]
+ldmxcsr 485498096(%edx,%eax,4)
+
+// CHECK: ldmxcsr 485498096(%edx)
+// CHECK: encoding: [0x0f,0xae,0x92,0xf0,0x1c,0xf0,0x1c]
+ldmxcsr 485498096(%edx)
+
+// CHECK: ldmxcsr 485498096
+// CHECK: encoding: [0x0f,0xae,0x15,0xf0,0x1c,0xf0,0x1c]
+ldmxcsr 485498096
+
+// CHECK: ldmxcsr 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0xae,0x54,0x02,0x40]
+ldmxcsr 64(%edx,%eax)
+
+// CHECK: ldmxcsr (%edx)
+// CHECK: encoding: [0x0f,0xae,0x12]
+ldmxcsr (%edx)
+
+// CHECK: stmxcsr -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0xae,0x9c,0x82,0x10,0xe3,0x0f,0xe3]
+stmxcsr -485498096(%edx,%eax,4)
+
+// CHECK: stmxcsr 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0xae,0x9c,0x82,0xf0,0x1c,0xf0,0x1c]
+stmxcsr 485498096(%edx,%eax,4)
+
+// CHECK: stmxcsr 485498096(%edx)
+// CHECK: encoding: [0x0f,0xae,0x9a,0xf0,0x1c,0xf0,0x1c]
+stmxcsr 485498096(%edx)
+
+// CHECK: stmxcsr 485498096
+// CHECK: encoding: [0x0f,0xae,0x1d,0xf0,0x1c,0xf0,0x1c]
+stmxcsr 485498096
+
+// CHECK: stmxcsr 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0xae,0x5c,0x02,0x40]
+stmxcsr 64(%edx,%eax)
+
+// CHECK: stmxcsr (%edx)
+// CHECK: encoding: [0x0f,0xae,0x1a]
+stmxcsr (%edx)
+

test/MC/X86/SSEMXCSR-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: ldmxcsr 485498096
+// CHECK: encoding: [0x0f,0xae,0x14,0x25,0xf0,0x1c,0xf0,0x1c]
+ldmxcsr 485498096
+
+// CHECK: ldmxcsr 64(%rdx)
+// CHECK: encoding: [0x0f,0xae,0x52,0x40]
+ldmxcsr 64(%rdx)
+
+// CHECK: ldmxcsr -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0xae,0x54,0x82,0xc0]
+ldmxcsr -64(%rdx,%rax,4)
+
+// CHECK: ldmxcsr 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0xae,0x54,0x82,0x40]
+ldmxcsr 64(%rdx,%rax,4)
+
+// CHECK: ldmxcsr 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0xae,0x54,0x02,0x40]
+ldmxcsr 64(%rdx,%rax)
+
+// CHECK: ldmxcsr (%rdx)
+// CHECK: encoding: [0x0f,0xae,0x12]
+ldmxcsr (%rdx)
+
+// CHECK: stmxcsr 485498096
+// CHECK: encoding: [0x0f,0xae,0x1c,0x25,0xf0,0x1c,0xf0,0x1c]
+stmxcsr 485498096
+
+// CHECK: stmxcsr 64(%rdx)
+// CHECK: encoding: [0x0f,0xae,0x5a,0x40]
+stmxcsr 64(%rdx)
+
+// CHECK: stmxcsr -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0xae,0x5c,0x82,0xc0]
+stmxcsr -64(%rdx,%rax,4)
+
+// CHECK: stmxcsr 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0xae,0x5c,0x82,0x40]
+stmxcsr 64(%rdx,%rax,4)
+
+// CHECK: stmxcsr 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0xae,0x5c,0x02,0x40]
+stmxcsr 64(%rdx,%rax)
+
+// CHECK: stmxcsr (%rdx)
+// CHECK: encoding: [0x0f,0xae,0x1a]
+stmxcsr (%rdx)
+

test/MC/X86/SSE_PREFETCH-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: prefetchnta -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x18,0x84,0x82,0x10,0xe3,0x0f,0xe3]
+prefetchnta -485498096(%edx,%eax,4)
+
+// CHECK: prefetchnta 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x18,0x84,0x82,0xf0,0x1c,0xf0,0x1c]
+prefetchnta 485498096(%edx,%eax,4)
+
+// CHECK: prefetchnta 485498096(%edx)
+// CHECK: encoding: [0x0f,0x18,0x82,0xf0,0x1c,0xf0,0x1c]
+prefetchnta 485498096(%edx)
+
+// CHECK: prefetchnta 485498096
+// CHECK: encoding: [0x0f,0x18,0x05,0xf0,0x1c,0xf0,0x1c]
+prefetchnta 485498096
+
+// CHECK: prefetchnta 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x18,0x44,0x02,0x40]
+prefetchnta 64(%edx,%eax)
+
+// CHECK: prefetchnta (%edx)
+// CHECK: encoding: [0x0f,0x18,0x02]
+prefetchnta (%edx)
+
+// CHECK: prefetcht0 -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x18,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+prefetcht0 -485498096(%edx,%eax,4)
+
+// CHECK: prefetcht0 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x18,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+prefetcht0 485498096(%edx,%eax,4)
+
+// CHECK: prefetcht0 485498096(%edx)
+// CHECK: encoding: [0x0f,0x18,0x8a,0xf0,0x1c,0xf0,0x1c]
+prefetcht0 485498096(%edx)
+
+// CHECK: prefetcht0 485498096
+// CHECK: encoding: [0x0f,0x18,0x0d,0xf0,0x1c,0xf0,0x1c]
+prefetcht0 485498096
+
+// CHECK: prefetcht0 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x18,0x4c,0x02,0x40]
+prefetcht0 64(%edx,%eax)
+
+// CHECK: prefetcht0 (%edx)
+// CHECK: encoding: [0x0f,0x18,0x0a]
+prefetcht0 (%edx)
+
+// CHECK: prefetcht1 -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x18,0x94,0x82,0x10,0xe3,0x0f,0xe3]
+prefetcht1 -485498096(%edx,%eax,4)
+
+// CHECK: prefetcht1 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x18,0x94,0x82,0xf0,0x1c,0xf0,0x1c]
+prefetcht1 485498096(%edx,%eax,4)
+
+// CHECK: prefetcht1 485498096(%edx)
+// CHECK: encoding: [0x0f,0x18,0x92,0xf0,0x1c,0xf0,0x1c]
+prefetcht1 485498096(%edx)
+
+// CHECK: prefetcht1 485498096
+// CHECK: encoding: [0x0f,0x18,0x15,0xf0,0x1c,0xf0,0x1c]
+prefetcht1 485498096
+
+// CHECK: prefetcht1 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x18,0x54,0x02,0x40]
+prefetcht1 64(%edx,%eax)
+
+// CHECK: prefetcht1 (%edx)
+// CHECK: encoding: [0x0f,0x18,0x12]
+prefetcht1 (%edx)
+
+// CHECK: prefetcht2 -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x18,0x9c,0x82,0x10,0xe3,0x0f,0xe3]
+prefetcht2 -485498096(%edx,%eax,4)
+
+// CHECK: prefetcht2 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x0f,0x18,0x9c,0x82,0xf0,0x1c,0xf0,0x1c]
+prefetcht2 485498096(%edx,%eax,4)
+
+// CHECK: prefetcht2 485498096(%edx)
+// CHECK: encoding: [0x0f,0x18,0x9a,0xf0,0x1c,0xf0,0x1c]
+prefetcht2 485498096(%edx)
+
+// CHECK: prefetcht2 485498096
+// CHECK: encoding: [0x0f,0x18,0x1d,0xf0,0x1c,0xf0,0x1c]
+prefetcht2 485498096
+
+// CHECK: prefetcht2 64(%edx,%eax)
+// CHECK: encoding: [0x0f,0x18,0x5c,0x02,0x40]
+prefetcht2 64(%edx,%eax)
+
+// CHECK: prefetcht2 (%edx)
+// CHECK: encoding: [0x0f,0x18,0x1a]
+prefetcht2 (%edx)
+

test/MC/X86/SSE_PREFETCH-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: prefetchnta 485498096
+// CHECK: encoding: [0x0f,0x18,0x04,0x25,0xf0,0x1c,0xf0,0x1c]
+prefetchnta 485498096
+
+// CHECK: prefetchnta 64(%rdx)
+// CHECK: encoding: [0x0f,0x18,0x42,0x40]
+prefetchnta 64(%rdx)
+
+// CHECK: prefetchnta -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x18,0x44,0x82,0xc0]
+prefetchnta -64(%rdx,%rax,4)
+
+// CHECK: prefetchnta 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x18,0x44,0x82,0x40]
+prefetchnta 64(%rdx,%rax,4)
+
+// CHECK: prefetchnta 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x18,0x44,0x02,0x40]
+prefetchnta 64(%rdx,%rax)
+
+// CHECK: prefetchnta (%rdx)
+// CHECK: encoding: [0x0f,0x18,0x02]
+prefetchnta (%rdx)
+
+// CHECK: prefetcht0 485498096
+// CHECK: encoding: [0x0f,0x18,0x0c,0x25,0xf0,0x1c,0xf0,0x1c]
+prefetcht0 485498096
+
+// CHECK: prefetcht0 64(%rdx)
+// CHECK: encoding: [0x0f,0x18,0x4a,0x40]
+prefetcht0 64(%rdx)
+
+// CHECK: prefetcht0 -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x18,0x4c,0x82,0xc0]
+prefetcht0 -64(%rdx,%rax,4)
+
+// CHECK: prefetcht0 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x18,0x4c,0x82,0x40]
+prefetcht0 64(%rdx,%rax,4)
+
+// CHECK: prefetcht0 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x18,0x4c,0x02,0x40]
+prefetcht0 64(%rdx,%rax)
+
+// CHECK: prefetcht0 (%rdx)
+// CHECK: encoding: [0x0f,0x18,0x0a]
+prefetcht0 (%rdx)
+
+// CHECK: prefetcht1 485498096
+// CHECK: encoding: [0x0f,0x18,0x14,0x25,0xf0,0x1c,0xf0,0x1c]
+prefetcht1 485498096
+
+// CHECK: prefetcht1 64(%rdx)
+// CHECK: encoding: [0x0f,0x18,0x52,0x40]
+prefetcht1 64(%rdx)
+
+// CHECK: prefetcht1 -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x18,0x54,0x82,0xc0]
+prefetcht1 -64(%rdx,%rax,4)
+
+// CHECK: prefetcht1 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x18,0x54,0x82,0x40]
+prefetcht1 64(%rdx,%rax,4)
+
+// CHECK: prefetcht1 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x18,0x54,0x02,0x40]
+prefetcht1 64(%rdx,%rax)
+
+// CHECK: prefetcht1 (%rdx)
+// CHECK: encoding: [0x0f,0x18,0x12]
+prefetcht1 (%rdx)
+
+// CHECK: prefetcht2 485498096
+// CHECK: encoding: [0x0f,0x18,0x1c,0x25,0xf0,0x1c,0xf0,0x1c]
+prefetcht2 485498096
+
+// CHECK: prefetcht2 64(%rdx)
+// CHECK: encoding: [0x0f,0x18,0x5a,0x40]
+prefetcht2 64(%rdx)
+
+// CHECK: prefetcht2 -64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x18,0x5c,0x82,0xc0]
+prefetcht2 -64(%rdx,%rax,4)
+
+// CHECK: prefetcht2 64(%rdx,%rax,4)
+// CHECK: encoding: [0x0f,0x18,0x5c,0x82,0x40]
+prefetcht2 64(%rdx,%rax,4)
+
+// CHECK: prefetcht2 64(%rdx,%rax)
+// CHECK: encoding: [0x0f,0x18,0x5c,0x02,0x40]
+prefetcht2 64(%rdx,%rax)
+
+// CHECK: prefetcht2 (%rdx)
+// CHECK: encoding: [0x0f,0x18,0x1a]
+prefetcht2 (%rdx)
+

test/MC/X86/SSSE3-32.s

+// RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: pabsb -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+pabsb -485498096(%edx,%eax,4), %mm4
+
+// CHECK: pabsb 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+pabsb 485498096(%edx,%eax,4), %mm4
+
+// CHECK: pabsb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pabsb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pabsb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pabsb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pabsb 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0xa2,0xf0,0x1c,0xf0,0x1c]
+pabsb 485498096(%edx), %mm4
+
+// CHECK: pabsb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x8a,0xf0,0x1c,0xf0,0x1c]
+pabsb 485498096(%edx), %xmm1
+
+// CHECK: pabsb 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsb 485498096, %mm4
+
+// CHECK: pabsb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x0d,0xf0,0x1c,0xf0,0x1c]
+pabsb 485498096, %xmm1
+
+// CHECK: pabsb 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x64,0x02,0x40]
+pabsb 64(%edx,%eax), %mm4
+
+// CHECK: pabsb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x4c,0x02,0x40]
+pabsb 64(%edx,%eax), %xmm1
+
+// CHECK: pabsb (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x22]
+pabsb (%edx), %mm4
+
+// CHECK: pabsb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x0a]
+pabsb (%edx), %xmm1
+
+// CHECK: pabsb %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0xe4]
+pabsb %mm4, %mm4
+
+// CHECK: pabsb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0xc9]
+pabsb %xmm1, %xmm1
+
+// CHECK: pabsd -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+pabsd -485498096(%edx,%eax,4), %mm4
+
+// CHECK: pabsd 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+pabsd 485498096(%edx,%eax,4), %mm4
+
+// CHECK: pabsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pabsd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pabsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pabsd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pabsd 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0xa2,0xf0,0x1c,0xf0,0x1c]
+pabsd 485498096(%edx), %mm4
+
+// CHECK: pabsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x8a,0xf0,0x1c,0xf0,0x1c]
+pabsd 485498096(%edx), %xmm1
+
+// CHECK: pabsd 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsd 485498096, %mm4
+
+// CHECK: pabsd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x0d,0xf0,0x1c,0xf0,0x1c]
+pabsd 485498096, %xmm1
+
+// CHECK: pabsd 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x64,0x02,0x40]
+pabsd 64(%edx,%eax), %mm4
+
+// CHECK: pabsd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x4c,0x02,0x40]
+pabsd 64(%edx,%eax), %xmm1
+
+// CHECK: pabsd (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x22]
+pabsd (%edx), %mm4
+
+// CHECK: pabsd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x0a]
+pabsd (%edx), %xmm1
+
+// CHECK: pabsd %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0xe4]
+pabsd %mm4, %mm4
+
+// CHECK: pabsd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0xc9]
+pabsd %xmm1, %xmm1
+
+// CHECK: pabsw -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+pabsw -485498096(%edx,%eax,4), %mm4
+
+// CHECK: pabsw 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+pabsw 485498096(%edx,%eax,4), %mm4
+
+// CHECK: pabsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pabsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pabsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pabsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pabsw 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0xa2,0xf0,0x1c,0xf0,0x1c]
+pabsw 485498096(%edx), %mm4
+
+// CHECK: pabsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x8a,0xf0,0x1c,0xf0,0x1c]
+pabsw 485498096(%edx), %xmm1
+
+// CHECK: pabsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsw 485498096, %mm4
+
+// CHECK: pabsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x0d,0xf0,0x1c,0xf0,0x1c]
+pabsw 485498096, %xmm1
+
+// CHECK: pabsw 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x64,0x02,0x40]
+pabsw 64(%edx,%eax), %mm4
+
+// CHECK: pabsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x4c,0x02,0x40]
+pabsw 64(%edx,%eax), %xmm1
+
+// CHECK: pabsw (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x22]
+pabsw (%edx), %mm4
+
+// CHECK: pabsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x0a]
+pabsw (%edx), %xmm1
+
+// CHECK: pabsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0xe4]
+pabsw %mm4, %mm4
+
+// CHECK: pabsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0xc9]
+pabsw %xmm1, %xmm1
+
+// CHECK: palignr $0, -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0xa4,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+palignr $0, -485498096(%edx,%eax,4), %mm4
+
+// CHECK: palignr $0, 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0xa4,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+palignr $0, 485498096(%edx,%eax,4), %mm4
+
+// CHECK: palignr $0, -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x8c,0x82,0x10,0xe3,0x0f,0xe3,0x00]
+palignr $0, -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: palignr $0, 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c,0x00]
+palignr $0, 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: palignr $0, 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0xa2,0xf0,0x1c,0xf0,0x1c,0x00]
+palignr $0, 485498096(%edx), %mm4
+
+// CHECK: palignr $0, 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x8a,0xf0,0x1c,0xf0,0x1c,0x00]
+palignr $0, 485498096(%edx), %xmm1
+
+// CHECK: palignr $0, 485498096, %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+palignr $0, 485498096, %mm4
+
+// CHECK: palignr $0, 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x0d,0xf0,0x1c,0xf0,0x1c,0x00]
+palignr $0, 485498096, %xmm1
+
+// CHECK: palignr $0, 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x64,0x02,0x40,0x00]
+palignr $0, 64(%edx,%eax), %mm4
+
+// CHECK: palignr $0, 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x4c,0x02,0x40,0x00]
+palignr $0, 64(%edx,%eax), %xmm1
+
+// CHECK: palignr $0, (%edx), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x22,0x00]
+palignr $0, (%edx), %mm4
+
+// CHECK: palignr $0, (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x0a,0x00]
+palignr $0, (%edx), %xmm1
+
+// CHECK: palignr $0, %mm4, %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0xe4,0x00]
+palignr $0, %mm4, %mm4
+
+// CHECK: palignr $0, %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0xc9,0x00]
+palignr $0, %xmm1, %xmm1
+
+// CHECK: phaddd -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+phaddd -485498096(%edx,%eax,4), %mm4
+
+// CHECK: phaddd 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+phaddd 485498096(%edx,%eax,4), %mm4
+
+// CHECK: phaddd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+phaddd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phaddd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+phaddd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phaddd 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0xa2,0xf0,0x1c,0xf0,0x1c]
+phaddd 485498096(%edx), %mm4
+
+// CHECK: phaddd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x8a,0xf0,0x1c,0xf0,0x1c]
+phaddd 485498096(%edx), %xmm1
+
+// CHECK: phaddd 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddd 485498096, %mm4
+
+// CHECK: phaddd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x0d,0xf0,0x1c,0xf0,0x1c]
+phaddd 485498096, %xmm1
+
+// CHECK: phaddd 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x64,0x02,0x40]
+phaddd 64(%edx,%eax), %mm4
+
+// CHECK: phaddd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x4c,0x02,0x40]
+phaddd 64(%edx,%eax), %xmm1
+
+// CHECK: phaddd (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x22]
+phaddd (%edx), %mm4
+
+// CHECK: phaddd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x0a]
+phaddd (%edx), %xmm1
+
+// CHECK: phaddd %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0xe4]
+phaddd %mm4, %mm4
+
+// CHECK: phaddd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0xc9]
+phaddd %xmm1, %xmm1
+
+// CHECK: phaddsw -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+phaddsw -485498096(%edx,%eax,4), %mm4
+
+// CHECK: phaddsw 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+phaddsw 485498096(%edx,%eax,4), %mm4
+
+// CHECK: phaddsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+phaddsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phaddsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+phaddsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phaddsw 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0xa2,0xf0,0x1c,0xf0,0x1c]
+phaddsw 485498096(%edx), %mm4
+
+// CHECK: phaddsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x8a,0xf0,0x1c,0xf0,0x1c]
+phaddsw 485498096(%edx), %xmm1
+
+// CHECK: phaddsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddsw 485498096, %mm4
+
+// CHECK: phaddsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x0d,0xf0,0x1c,0xf0,0x1c]
+phaddsw 485498096, %xmm1
+
+// CHECK: phaddsw 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x64,0x02,0x40]
+phaddsw 64(%edx,%eax), %mm4
+
+// CHECK: phaddsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x4c,0x02,0x40]
+phaddsw 64(%edx,%eax), %xmm1
+
+// CHECK: phaddsw (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x22]
+phaddsw (%edx), %mm4
+
+// CHECK: phaddsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x0a]
+phaddsw (%edx), %xmm1
+
+// CHECK: phaddsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0xe4]
+phaddsw %mm4, %mm4
+
+// CHECK: phaddsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0xc9]
+phaddsw %xmm1, %xmm1
+
+// CHECK: phaddw -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+phaddw -485498096(%edx,%eax,4), %mm4
+
+// CHECK: phaddw 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+phaddw 485498096(%edx,%eax,4), %mm4
+
+// CHECK: phaddw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+phaddw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phaddw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+phaddw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phaddw 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0xa2,0xf0,0x1c,0xf0,0x1c]
+phaddw 485498096(%edx), %mm4
+
+// CHECK: phaddw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x8a,0xf0,0x1c,0xf0,0x1c]
+phaddw 485498096(%edx), %xmm1
+
+// CHECK: phaddw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddw 485498096, %mm4
+
+// CHECK: phaddw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x0d,0xf0,0x1c,0xf0,0x1c]
+phaddw 485498096, %xmm1
+
+// CHECK: phaddw 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x64,0x02,0x40]
+phaddw 64(%edx,%eax), %mm4
+
+// CHECK: phaddw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x4c,0x02,0x40]
+phaddw 64(%edx,%eax), %xmm1
+
+// CHECK: phaddw (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x22]
+phaddw (%edx), %mm4
+
+// CHECK: phaddw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x0a]
+phaddw (%edx), %xmm1
+
+// CHECK: phaddw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0xe4]
+phaddw %mm4, %mm4
+
+// CHECK: phaddw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0xc9]
+phaddw %xmm1, %xmm1
+
+// CHECK: phsubd -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+phsubd -485498096(%edx,%eax,4), %mm4
+
+// CHECK: phsubd 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+phsubd 485498096(%edx,%eax,4), %mm4
+
+// CHECK: phsubd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+phsubd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phsubd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+phsubd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phsubd 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0xa2,0xf0,0x1c,0xf0,0x1c]
+phsubd 485498096(%edx), %mm4
+
+// CHECK: phsubd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x8a,0xf0,0x1c,0xf0,0x1c]
+phsubd 485498096(%edx), %xmm1
+
+// CHECK: phsubd 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubd 485498096, %mm4
+
+// CHECK: phsubd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x0d,0xf0,0x1c,0xf0,0x1c]
+phsubd 485498096, %xmm1
+
+// CHECK: phsubd 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x64,0x02,0x40]
+phsubd 64(%edx,%eax), %mm4
+
+// CHECK: phsubd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x4c,0x02,0x40]
+phsubd 64(%edx,%eax), %xmm1
+
+// CHECK: phsubd (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x22]
+phsubd (%edx), %mm4
+
+// CHECK: phsubd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x0a]
+phsubd (%edx), %xmm1
+
+// CHECK: phsubd %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0xe4]
+phsubd %mm4, %mm4
+
+// CHECK: phsubd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0xc9]
+phsubd %xmm1, %xmm1
+
+// CHECK: phsubsw -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+phsubsw -485498096(%edx,%eax,4), %mm4
+
+// CHECK: phsubsw 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+phsubsw 485498096(%edx,%eax,4), %mm4
+
+// CHECK: phsubsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+phsubsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phsubsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+phsubsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phsubsw 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0xa2,0xf0,0x1c,0xf0,0x1c]
+phsubsw 485498096(%edx), %mm4
+
+// CHECK: phsubsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x8a,0xf0,0x1c,0xf0,0x1c]
+phsubsw 485498096(%edx), %xmm1
+
+// CHECK: phsubsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubsw 485498096, %mm4
+
+// CHECK: phsubsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x0d,0xf0,0x1c,0xf0,0x1c]
+phsubsw 485498096, %xmm1
+
+// CHECK: phsubsw 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x64,0x02,0x40]
+phsubsw 64(%edx,%eax), %mm4
+
+// CHECK: phsubsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x4c,0x02,0x40]
+phsubsw 64(%edx,%eax), %xmm1
+
+// CHECK: phsubsw (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x22]
+phsubsw (%edx), %mm4
+
+// CHECK: phsubsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x0a]
+phsubsw (%edx), %xmm1
+
+// CHECK: phsubsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0xe4]
+phsubsw %mm4, %mm4
+
+// CHECK: phsubsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0xc9]
+phsubsw %xmm1, %xmm1
+
+// CHECK: phsubw -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+phsubw -485498096(%edx,%eax,4), %mm4
+
+// CHECK: phsubw 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+phsubw 485498096(%edx,%eax,4), %mm4
+
+// CHECK: phsubw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+phsubw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phsubw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+phsubw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: phsubw 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0xa2,0xf0,0x1c,0xf0,0x1c]
+phsubw 485498096(%edx), %mm4
+
+// CHECK: phsubw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x8a,0xf0,0x1c,0xf0,0x1c]
+phsubw 485498096(%edx), %xmm1
+
+// CHECK: phsubw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubw 485498096, %mm4
+
+// CHECK: phsubw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x0d,0xf0,0x1c,0xf0,0x1c]
+phsubw 485498096, %xmm1
+
+// CHECK: phsubw 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x64,0x02,0x40]
+phsubw 64(%edx,%eax), %mm4
+
+// CHECK: phsubw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x4c,0x02,0x40]
+phsubw 64(%edx,%eax), %xmm1
+
+// CHECK: phsubw (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x22]
+phsubw (%edx), %mm4
+
+// CHECK: phsubw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x0a]
+phsubw (%edx), %xmm1
+
+// CHECK: phsubw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0xe4]
+phsubw %mm4, %mm4
+
+// CHECK: phsubw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0xc9]
+phsubw %xmm1, %xmm1
+
+// CHECK: pmaddubsw -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+pmaddubsw -485498096(%edx,%eax,4), %mm4
+
+// CHECK: pmaddubsw 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaddubsw 485498096(%edx,%eax,4), %mm4
+
+// CHECK: pmaddubsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmaddubsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaddubsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmaddubsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmaddubsw 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0xa2,0xf0,0x1c,0xf0,0x1c]
+pmaddubsw 485498096(%edx), %mm4
+
+// CHECK: pmaddubsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmaddubsw 485498096(%edx), %xmm1
+
+// CHECK: pmaddubsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaddubsw 485498096, %mm4
+
+// CHECK: pmaddubsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmaddubsw 485498096, %xmm1
+
+// CHECK: pmaddubsw 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x64,0x02,0x40]
+pmaddubsw 64(%edx,%eax), %mm4
+
+// CHECK: pmaddubsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x4c,0x02,0x40]
+pmaddubsw 64(%edx,%eax), %xmm1
+
+// CHECK: pmaddubsw (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x22]
+pmaddubsw (%edx), %mm4
+
+// CHECK: pmaddubsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x0a]
+pmaddubsw (%edx), %xmm1
+
+// CHECK: pmaddubsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0xe4]
+pmaddubsw %mm4, %mm4
+
+// CHECK: pmaddubsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0xc9]
+pmaddubsw %xmm1, %xmm1
+
+// CHECK: pmulhrsw -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+pmulhrsw -485498096(%edx,%eax,4), %mm4
+
+// CHECK: pmulhrsw 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+pmulhrsw 485498096(%edx,%eax,4), %mm4
+
+// CHECK: pmulhrsw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pmulhrsw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmulhrsw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pmulhrsw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pmulhrsw 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0xa2,0xf0,0x1c,0xf0,0x1c]
+pmulhrsw 485498096(%edx), %mm4
+
+// CHECK: pmulhrsw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x8a,0xf0,0x1c,0xf0,0x1c]
+pmulhrsw 485498096(%edx), %xmm1
+
+// CHECK: pmulhrsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x25,0xf0,0x1c,0xf0,0x1c]
+pmulhrsw 485498096, %mm4
+
+// CHECK: pmulhrsw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x0d,0xf0,0x1c,0xf0,0x1c]
+pmulhrsw 485498096, %xmm1
+
+// CHECK: pmulhrsw 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x64,0x02,0x40]
+pmulhrsw 64(%edx,%eax), %mm4
+
+// CHECK: pmulhrsw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x4c,0x02,0x40]
+pmulhrsw 64(%edx,%eax), %xmm1
+
+// CHECK: pmulhrsw (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x22]
+pmulhrsw (%edx), %mm4
+
+// CHECK: pmulhrsw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x0a]
+pmulhrsw (%edx), %xmm1
+
+// CHECK: pmulhrsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0xe4]
+pmulhrsw %mm4, %mm4
+
+// CHECK: pmulhrsw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0xc9]
+pmulhrsw %xmm1, %xmm1
+
+// CHECK: pshufb -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+pshufb -485498096(%edx,%eax,4), %mm4
+
+// CHECK: pshufb 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+pshufb 485498096(%edx,%eax,4), %mm4
+
+// CHECK: pshufb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+pshufb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pshufb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+pshufb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: pshufb 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0xa2,0xf0,0x1c,0xf0,0x1c]
+pshufb 485498096(%edx), %mm4
+
+// CHECK: pshufb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x8a,0xf0,0x1c,0xf0,0x1c]
+pshufb 485498096(%edx), %xmm1
+
+// CHECK: pshufb 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x25,0xf0,0x1c,0xf0,0x1c]
+pshufb 485498096, %mm4
+
+// CHECK: pshufb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x0d,0xf0,0x1c,0xf0,0x1c]
+pshufb 485498096, %xmm1
+
+// CHECK: pshufb 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x64,0x02,0x40]
+pshufb 64(%edx,%eax), %mm4
+
+// CHECK: pshufb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x4c,0x02,0x40]
+pshufb 64(%edx,%eax), %xmm1
+
+// CHECK: pshufb (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x22]
+pshufb (%edx), %mm4
+
+// CHECK: pshufb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x0a]
+pshufb (%edx), %xmm1
+
+// CHECK: pshufb %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0xe4]
+pshufb %mm4, %mm4
+
+// CHECK: pshufb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0xc9]
+pshufb %xmm1, %xmm1
+
+// CHECK: psignb -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+psignb -485498096(%edx,%eax,4), %mm4
+
+// CHECK: psignb 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+psignb 485498096(%edx,%eax,4), %mm4
+
+// CHECK: psignb -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psignb -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psignb 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psignb 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psignb 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0xa2,0xf0,0x1c,0xf0,0x1c]
+psignb 485498096(%edx), %mm4
+
+// CHECK: psignb 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x8a,0xf0,0x1c,0xf0,0x1c]
+psignb 485498096(%edx), %xmm1
+
+// CHECK: psignb 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x25,0xf0,0x1c,0xf0,0x1c]
+psignb 485498096, %mm4
+
+// CHECK: psignb 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x0d,0xf0,0x1c,0xf0,0x1c]
+psignb 485498096, %xmm1
+
+// CHECK: psignb 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x64,0x02,0x40]
+psignb 64(%edx,%eax), %mm4
+
+// CHECK: psignb 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x4c,0x02,0x40]
+psignb 64(%edx,%eax), %xmm1
+
+// CHECK: psignb (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x22]
+psignb (%edx), %mm4
+
+// CHECK: psignb (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x0a]
+psignb (%edx), %xmm1
+
+// CHECK: psignb %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0xe4]
+psignb %mm4, %mm4
+
+// CHECK: psignb %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0xc9]
+psignb %xmm1, %xmm1
+
+// CHECK: psignd -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+psignd -485498096(%edx,%eax,4), %mm4
+
+// CHECK: psignd 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+psignd 485498096(%edx,%eax,4), %mm4
+
+// CHECK: psignd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psignd -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psignd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psignd 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psignd 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0xa2,0xf0,0x1c,0xf0,0x1c]
+psignd 485498096(%edx), %mm4
+
+// CHECK: psignd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x8a,0xf0,0x1c,0xf0,0x1c]
+psignd 485498096(%edx), %xmm1
+
+// CHECK: psignd 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x25,0xf0,0x1c,0xf0,0x1c]
+psignd 485498096, %mm4
+
+// CHECK: psignd 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x0d,0xf0,0x1c,0xf0,0x1c]
+psignd 485498096, %xmm1
+
+// CHECK: psignd 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x64,0x02,0x40]
+psignd 64(%edx,%eax), %mm4
+
+// CHECK: psignd 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x4c,0x02,0x40]
+psignd 64(%edx,%eax), %xmm1
+
+// CHECK: psignd (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x22]
+psignd (%edx), %mm4
+
+// CHECK: psignd (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x0a]
+psignd (%edx), %xmm1
+
+// CHECK: psignd %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0xe4]
+psignd %mm4, %mm4
+
+// CHECK: psignd %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0xc9]
+psignd %xmm1, %xmm1
+
+// CHECK: psignw -485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0xa4,0x82,0x10,0xe3,0x0f,0xe3]
+psignw -485498096(%edx,%eax,4), %mm4
+
+// CHECK: psignw 485498096(%edx,%eax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0xa4,0x82,0xf0,0x1c,0xf0,0x1c]
+psignw 485498096(%edx,%eax,4), %mm4
+
+// CHECK: psignw -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+psignw -485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psignw 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+psignw 485498096(%edx,%eax,4), %xmm1
+
+// CHECK: psignw 485498096(%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0xa2,0xf0,0x1c,0xf0,0x1c]
+psignw 485498096(%edx), %mm4
+
+// CHECK: psignw 485498096(%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x8a,0xf0,0x1c,0xf0,0x1c]
+psignw 485498096(%edx), %xmm1
+
+// CHECK: psignw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x25,0xf0,0x1c,0xf0,0x1c]
+psignw 485498096, %mm4
+
+// CHECK: psignw 485498096, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x0d,0xf0,0x1c,0xf0,0x1c]
+psignw 485498096, %xmm1
+
+// CHECK: psignw 64(%edx,%eax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x64,0x02,0x40]
+psignw 64(%edx,%eax), %mm4
+
+// CHECK: psignw 64(%edx,%eax), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x4c,0x02,0x40]
+psignw 64(%edx,%eax), %xmm1
+
+// CHECK: psignw (%edx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x22]
+psignw (%edx), %mm4
+
+// CHECK: psignw (%edx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x0a]
+psignw (%edx), %xmm1
+
+// CHECK: psignw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0xe4]
+psignw %mm4, %mm4
+
+// CHECK: psignw %xmm1, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0xc9]
+psignw %xmm1, %xmm1
+

test/MC/X86/SSSE3-64.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
+
+// CHECK: pabsb 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsb 485498096, %mm4
+
+// CHECK: pabsb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsb 485498096, %xmm6
+
+// CHECK: pabsb 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x62,0x40]
+pabsb 64(%rdx), %mm4
+
+// CHECK: pabsb -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x64,0x82,0xc0]
+pabsb -64(%rdx,%rax,4), %mm4
+
+// CHECK: pabsb 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x64,0x82,0x40]
+pabsb 64(%rdx,%rax,4), %mm4
+
+// CHECK: pabsb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x74,0x82,0xc0]
+pabsb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pabsb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x74,0x82,0x40]
+pabsb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pabsb 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x64,0x02,0x40]
+pabsb 64(%rdx,%rax), %mm4
+
+// CHECK: pabsb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x74,0x02,0x40]
+pabsb 64(%rdx,%rax), %xmm6
+
+// CHECK: pabsb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x72,0x40]
+pabsb 64(%rdx), %xmm6
+
+// CHECK: pabsb %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0xe4]
+pabsb %mm4, %mm4
+
+// CHECK: pabsb (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1c,0x22]
+pabsb (%rdx), %mm4
+
+// CHECK: pabsb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0x32]
+pabsb (%rdx), %xmm6
+
+// CHECK: pabsb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1c,0xf6]
+pabsb %xmm6, %xmm6
+
+// CHECK: pabsd 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsd 485498096, %mm4
+
+// CHECK: pabsd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsd 485498096, %xmm6
+
+// CHECK: pabsd 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x62,0x40]
+pabsd 64(%rdx), %mm4
+
+// CHECK: pabsd -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x64,0x82,0xc0]
+pabsd -64(%rdx,%rax,4), %mm4
+
+// CHECK: pabsd 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x64,0x82,0x40]
+pabsd 64(%rdx,%rax,4), %mm4
+
+// CHECK: pabsd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x74,0x82,0xc0]
+pabsd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pabsd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x74,0x82,0x40]
+pabsd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pabsd 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x64,0x02,0x40]
+pabsd 64(%rdx,%rax), %mm4
+
+// CHECK: pabsd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x74,0x02,0x40]
+pabsd 64(%rdx,%rax), %xmm6
+
+// CHECK: pabsd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x72,0x40]
+pabsd 64(%rdx), %xmm6
+
+// CHECK: pabsd %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0xe4]
+pabsd %mm4, %mm4
+
+// CHECK: pabsd (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1e,0x22]
+pabsd (%rdx), %mm4
+
+// CHECK: pabsd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0x32]
+pabsd (%rdx), %xmm6
+
+// CHECK: pabsd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1e,0xf6]
+pabsd %xmm6, %xmm6
+
+// CHECK: pabsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsw 485498096, %mm4
+
+// CHECK: pabsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pabsw 485498096, %xmm6
+
+// CHECK: pabsw 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x62,0x40]
+pabsw 64(%rdx), %mm4
+
+// CHECK: pabsw -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x64,0x82,0xc0]
+pabsw -64(%rdx,%rax,4), %mm4
+
+// CHECK: pabsw 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x64,0x82,0x40]
+pabsw 64(%rdx,%rax,4), %mm4
+
+// CHECK: pabsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x74,0x82,0xc0]
+pabsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pabsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x74,0x82,0x40]
+pabsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pabsw 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x64,0x02,0x40]
+pabsw 64(%rdx,%rax), %mm4
+
+// CHECK: pabsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x74,0x02,0x40]
+pabsw 64(%rdx,%rax), %xmm6
+
+// CHECK: pabsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x72,0x40]
+pabsw 64(%rdx), %xmm6
+
+// CHECK: pabsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0xe4]
+pabsw %mm4, %mm4
+
+// CHECK: pabsw (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x1d,0x22]
+pabsw (%rdx), %mm4
+
+// CHECK: pabsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0x32]
+pabsw (%rdx), %xmm6
+
+// CHECK: pabsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x1d,0xf6]
+pabsw %xmm6, %xmm6
+
+// CHECK: palignr $0, 485498096, %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x24,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+palignr $0, 485498096, %mm4
+
+// CHECK: palignr $0, 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x34,0x25,0xf0,0x1c,0xf0,0x1c,0x00]
+palignr $0, 485498096, %xmm6
+
+// CHECK: palignr $0, 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x62,0x40,0x00]
+palignr $0, 64(%rdx), %mm4
+
+// CHECK: palignr $0, -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x64,0x82,0xc0,0x00]
+palignr $0, -64(%rdx,%rax,4), %mm4
+
+// CHECK: palignr $0, 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x64,0x82,0x40,0x00]
+palignr $0, 64(%rdx,%rax,4), %mm4
+
+// CHECK: palignr $0, -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x74,0x82,0xc0,0x00]
+palignr $0, -64(%rdx,%rax,4), %xmm6
+
+// CHECK: palignr $0, 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x74,0x82,0x40,0x00]
+palignr $0, 64(%rdx,%rax,4), %xmm6
+
+// CHECK: palignr $0, 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x64,0x02,0x40,0x00]
+palignr $0, 64(%rdx,%rax), %mm4
+
+// CHECK: palignr $0, 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x74,0x02,0x40,0x00]
+palignr $0, 64(%rdx,%rax), %xmm6
+
+// CHECK: palignr $0, 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x72,0x40,0x00]
+palignr $0, 64(%rdx), %xmm6
+
+// CHECK: palignr $0, %mm4, %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0xe4,0x00]
+palignr $0, %mm4, %mm4
+
+// CHECK: palignr $0, (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x3a,0x0f,0x22,0x00]
+palignr $0, (%rdx), %mm4
+
+// CHECK: palignr $0, (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0x32,0x00]
+palignr $0, (%rdx), %xmm6
+
+// CHECK: palignr $0, %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x3a,0x0f,0xf6,0x00]
+palignr $0, %xmm6, %xmm6
+
+// CHECK: phaddd 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddd 485498096, %mm4
+
+// CHECK: phaddd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddd 485498096, %xmm6
+
+// CHECK: phaddd 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x62,0x40]
+phaddd 64(%rdx), %mm4
+
+// CHECK: phaddd -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x64,0x82,0xc0]
+phaddd -64(%rdx,%rax,4), %mm4
+
+// CHECK: phaddd 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x64,0x82,0x40]
+phaddd 64(%rdx,%rax,4), %mm4
+
+// CHECK: phaddd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x74,0x82,0xc0]
+phaddd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: phaddd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x74,0x82,0x40]
+phaddd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: phaddd 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x64,0x02,0x40]
+phaddd 64(%rdx,%rax), %mm4
+
+// CHECK: phaddd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x74,0x02,0x40]
+phaddd 64(%rdx,%rax), %xmm6
+
+// CHECK: phaddd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x72,0x40]
+phaddd 64(%rdx), %xmm6
+
+// CHECK: phaddd %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0xe4]
+phaddd %mm4, %mm4
+
+// CHECK: phaddd (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x02,0x22]
+phaddd (%rdx), %mm4
+
+// CHECK: phaddd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0x32]
+phaddd (%rdx), %xmm6
+
+// CHECK: phaddd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x02,0xf6]
+phaddd %xmm6, %xmm6
+
+// CHECK: phaddsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddsw 485498096, %mm4
+
+// CHECK: phaddsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddsw 485498096, %xmm6
+
+// CHECK: phaddsw 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x62,0x40]
+phaddsw 64(%rdx), %mm4
+
+// CHECK: phaddsw -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x64,0x82,0xc0]
+phaddsw -64(%rdx,%rax,4), %mm4
+
+// CHECK: phaddsw 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x64,0x82,0x40]
+phaddsw 64(%rdx,%rax,4), %mm4
+
+// CHECK: phaddsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x74,0x82,0xc0]
+phaddsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: phaddsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x74,0x82,0x40]
+phaddsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: phaddsw 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x64,0x02,0x40]
+phaddsw 64(%rdx,%rax), %mm4
+
+// CHECK: phaddsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x74,0x02,0x40]
+phaddsw 64(%rdx,%rax), %xmm6
+
+// CHECK: phaddsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x72,0x40]
+phaddsw 64(%rdx), %xmm6
+
+// CHECK: phaddsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0xe4]
+phaddsw %mm4, %mm4
+
+// CHECK: phaddsw (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x03,0x22]
+phaddsw (%rdx), %mm4
+
+// CHECK: phaddsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0x32]
+phaddsw (%rdx), %xmm6
+
+// CHECK: phaddsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x03,0xf6]
+phaddsw %xmm6, %xmm6
+
+// CHECK: phaddw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddw 485498096, %mm4
+
+// CHECK: phaddw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+phaddw 485498096, %xmm6
+
+// CHECK: phaddw 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x62,0x40]
+phaddw 64(%rdx), %mm4
+
+// CHECK: phaddw -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x64,0x82,0xc0]
+phaddw -64(%rdx,%rax,4), %mm4
+
+// CHECK: phaddw 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x64,0x82,0x40]
+phaddw 64(%rdx,%rax,4), %mm4
+
+// CHECK: phaddw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x74,0x82,0xc0]
+phaddw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: phaddw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x74,0x82,0x40]
+phaddw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: phaddw 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x64,0x02,0x40]
+phaddw 64(%rdx,%rax), %mm4
+
+// CHECK: phaddw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x74,0x02,0x40]
+phaddw 64(%rdx,%rax), %xmm6
+
+// CHECK: phaddw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x72,0x40]
+phaddw 64(%rdx), %xmm6
+
+// CHECK: phaddw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0xe4]
+phaddw %mm4, %mm4
+
+// CHECK: phaddw (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x01,0x22]
+phaddw (%rdx), %mm4
+
+// CHECK: phaddw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0x32]
+phaddw (%rdx), %xmm6
+
+// CHECK: phaddw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x01,0xf6]
+phaddw %xmm6, %xmm6
+
+// CHECK: phsubd 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubd 485498096, %mm4
+
+// CHECK: phsubd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubd 485498096, %xmm6
+
+// CHECK: phsubd 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x62,0x40]
+phsubd 64(%rdx), %mm4
+
+// CHECK: phsubd -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x64,0x82,0xc0]
+phsubd -64(%rdx,%rax,4), %mm4
+
+// CHECK: phsubd 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x64,0x82,0x40]
+phsubd 64(%rdx,%rax,4), %mm4
+
+// CHECK: phsubd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x74,0x82,0xc0]
+phsubd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: phsubd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x74,0x82,0x40]
+phsubd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: phsubd 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x64,0x02,0x40]
+phsubd 64(%rdx,%rax), %mm4
+
+// CHECK: phsubd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x74,0x02,0x40]
+phsubd 64(%rdx,%rax), %xmm6
+
+// CHECK: phsubd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x72,0x40]
+phsubd 64(%rdx), %xmm6
+
+// CHECK: phsubd %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0xe4]
+phsubd %mm4, %mm4
+
+// CHECK: phsubd (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x06,0x22]
+phsubd (%rdx), %mm4
+
+// CHECK: phsubd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0x32]
+phsubd (%rdx), %xmm6
+
+// CHECK: phsubd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x06,0xf6]
+phsubd %xmm6, %xmm6
+
+// CHECK: phsubsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubsw 485498096, %mm4
+
+// CHECK: phsubsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubsw 485498096, %xmm6
+
+// CHECK: phsubsw 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x62,0x40]
+phsubsw 64(%rdx), %mm4
+
+// CHECK: phsubsw -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x64,0x82,0xc0]
+phsubsw -64(%rdx,%rax,4), %mm4
+
+// CHECK: phsubsw 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x64,0x82,0x40]
+phsubsw 64(%rdx,%rax,4), %mm4
+
+// CHECK: phsubsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x74,0x82,0xc0]
+phsubsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: phsubsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x74,0x82,0x40]
+phsubsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: phsubsw 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x64,0x02,0x40]
+phsubsw 64(%rdx,%rax), %mm4
+
+// CHECK: phsubsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x74,0x02,0x40]
+phsubsw 64(%rdx,%rax), %xmm6
+
+// CHECK: phsubsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x72,0x40]
+phsubsw 64(%rdx), %xmm6
+
+// CHECK: phsubsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0xe4]
+phsubsw %mm4, %mm4
+
+// CHECK: phsubsw (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x07,0x22]
+phsubsw (%rdx), %mm4
+
+// CHECK: phsubsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0x32]
+phsubsw (%rdx), %xmm6
+
+// CHECK: phsubsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x07,0xf6]
+phsubsw %xmm6, %xmm6
+
+// CHECK: phsubw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubw 485498096, %mm4
+
+// CHECK: phsubw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+phsubw 485498096, %xmm6
+
+// CHECK: phsubw 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x62,0x40]
+phsubw 64(%rdx), %mm4
+
+// CHECK: phsubw -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x64,0x82,0xc0]
+phsubw -64(%rdx,%rax,4), %mm4
+
+// CHECK: phsubw 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x64,0x82,0x40]
+phsubw 64(%rdx,%rax,4), %mm4
+
+// CHECK: phsubw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x74,0x82,0xc0]
+phsubw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: phsubw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x74,0x82,0x40]
+phsubw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: phsubw 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x64,0x02,0x40]
+phsubw 64(%rdx,%rax), %mm4
+
+// CHECK: phsubw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x74,0x02,0x40]
+phsubw 64(%rdx,%rax), %xmm6
+
+// CHECK: phsubw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x72,0x40]
+phsubw 64(%rdx), %xmm6
+
+// CHECK: phsubw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0xe4]
+phsubw %mm4, %mm4
+
+// CHECK: phsubw (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x05,0x22]
+phsubw (%rdx), %mm4
+
+// CHECK: phsubw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0x32]
+phsubw (%rdx), %xmm6
+
+// CHECK: phsubw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x05,0xf6]
+phsubw %xmm6, %xmm6
+
+// CHECK: pmaddubsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaddubsw 485498096, %mm4
+
+// CHECK: pmaddubsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmaddubsw 485498096, %xmm6
+
+// CHECK: pmaddubsw 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x62,0x40]
+pmaddubsw 64(%rdx), %mm4
+
+// CHECK: pmaddubsw -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x64,0x82,0xc0]
+pmaddubsw -64(%rdx,%rax,4), %mm4
+
+// CHECK: pmaddubsw 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x64,0x82,0x40]
+pmaddubsw 64(%rdx,%rax,4), %mm4
+
+// CHECK: pmaddubsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x74,0x82,0xc0]
+pmaddubsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaddubsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x74,0x82,0x40]
+pmaddubsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmaddubsw 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x64,0x02,0x40]
+pmaddubsw 64(%rdx,%rax), %mm4
+
+// CHECK: pmaddubsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x74,0x02,0x40]
+pmaddubsw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmaddubsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x72,0x40]
+pmaddubsw 64(%rdx), %xmm6
+
+// CHECK: pmaddubsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0xe4]
+pmaddubsw %mm4, %mm4
+
+// CHECK: pmaddubsw (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x04,0x22]
+pmaddubsw (%rdx), %mm4
+
+// CHECK: pmaddubsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0x32]
+pmaddubsw (%rdx), %xmm6
+
+// CHECK: pmaddubsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x04,0xf6]
+pmaddubsw %xmm6, %xmm6
+
+// CHECK: pmulhrsw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+pmulhrsw 485498096, %mm4
+
+// CHECK: pmulhrsw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pmulhrsw 485498096, %xmm6
+
+// CHECK: pmulhrsw 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x62,0x40]
+pmulhrsw 64(%rdx), %mm4
+
+// CHECK: pmulhrsw -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x64,0x82,0xc0]
+pmulhrsw -64(%rdx,%rax,4), %mm4
+
+// CHECK: pmulhrsw 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x64,0x82,0x40]
+pmulhrsw 64(%rdx,%rax,4), %mm4
+
+// CHECK: pmulhrsw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x74,0x82,0xc0]
+pmulhrsw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmulhrsw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x74,0x82,0x40]
+pmulhrsw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pmulhrsw 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x64,0x02,0x40]
+pmulhrsw 64(%rdx,%rax), %mm4
+
+// CHECK: pmulhrsw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x74,0x02,0x40]
+pmulhrsw 64(%rdx,%rax), %xmm6
+
+// CHECK: pmulhrsw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x72,0x40]
+pmulhrsw 64(%rdx), %xmm6
+
+// CHECK: pmulhrsw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0xe4]
+pmulhrsw %mm4, %mm4
+
+// CHECK: pmulhrsw (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0b,0x22]
+pmulhrsw (%rdx), %mm4
+
+// CHECK: pmulhrsw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0x32]
+pmulhrsw (%rdx), %xmm6
+
+// CHECK: pmulhrsw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0b,0xf6]
+pmulhrsw %xmm6, %xmm6
+
+// CHECK: pshufb 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+pshufb 485498096, %mm4
+
+// CHECK: pshufb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+pshufb 485498096, %xmm6
+
+// CHECK: pshufb 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x62,0x40]
+pshufb 64(%rdx), %mm4
+
+// CHECK: pshufb -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x64,0x82,0xc0]
+pshufb -64(%rdx,%rax,4), %mm4
+
+// CHECK: pshufb 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x64,0x82,0x40]
+pshufb 64(%rdx,%rax,4), %mm4
+
+// CHECK: pshufb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x74,0x82,0xc0]
+pshufb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: pshufb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x74,0x82,0x40]
+pshufb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: pshufb 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x64,0x02,0x40]
+pshufb 64(%rdx,%rax), %mm4
+
+// CHECK: pshufb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x74,0x02,0x40]
+pshufb 64(%rdx,%rax), %xmm6
+
+// CHECK: pshufb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x72,0x40]
+pshufb 64(%rdx), %xmm6
+
+// CHECK: pshufb %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0xe4]
+pshufb %mm4, %mm4
+
+// CHECK: pshufb (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x00,0x22]
+pshufb (%rdx), %mm4
+
+// CHECK: pshufb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0x32]
+pshufb (%rdx), %xmm6
+
+// CHECK: pshufb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x00,0xf6]
+pshufb %xmm6, %xmm6
+
+// CHECK: psignb 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+psignb 485498096, %mm4
+
+// CHECK: psignb 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psignb 485498096, %xmm6
+
+// CHECK: psignb 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x62,0x40]
+psignb 64(%rdx), %mm4
+
+// CHECK: psignb -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x64,0x82,0xc0]
+psignb -64(%rdx,%rax,4), %mm4
+
+// CHECK: psignb 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x64,0x82,0x40]
+psignb 64(%rdx,%rax,4), %mm4
+
+// CHECK: psignb -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x74,0x82,0xc0]
+psignb -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psignb 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x74,0x82,0x40]
+psignb 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psignb 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x64,0x02,0x40]
+psignb 64(%rdx,%rax), %mm4
+
+// CHECK: psignb 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x74,0x02,0x40]
+psignb 64(%rdx,%rax), %xmm6
+
+// CHECK: psignb 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x72,0x40]
+psignb 64(%rdx), %xmm6
+
+// CHECK: psignb %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0xe4]
+psignb %mm4, %mm4
+
+// CHECK: psignb (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x08,0x22]
+psignb (%rdx), %mm4
+
+// CHECK: psignb (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0x32]
+psignb (%rdx), %xmm6
+
+// CHECK: psignb %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x08,0xf6]
+psignb %xmm6, %xmm6
+
+// CHECK: psignd 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+psignd 485498096, %mm4
+
+// CHECK: psignd 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psignd 485498096, %xmm6
+
+// CHECK: psignd 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x62,0x40]
+psignd 64(%rdx), %mm4
+
+// CHECK: psignd -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x64,0x82,0xc0]
+psignd -64(%rdx,%rax,4), %mm4
+
+// CHECK: psignd 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x64,0x82,0x40]
+psignd 64(%rdx,%rax,4), %mm4
+
+// CHECK: psignd -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x74,0x82,0xc0]
+psignd -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psignd 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x74,0x82,0x40]
+psignd 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psignd 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x64,0x02,0x40]
+psignd 64(%rdx,%rax), %mm4
+
+// CHECK: psignd 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x74,0x02,0x40]
+psignd 64(%rdx,%rax), %xmm6
+
+// CHECK: psignd 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x72,0x40]
+psignd 64(%rdx), %xmm6
+
+// CHECK: psignd %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0xe4]
+psignd %mm4, %mm4
+
+// CHECK: psignd (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x0a,0x22]
+psignd (%rdx), %mm4
+
+// CHECK: psignd (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0x32]
+psignd (%rdx), %xmm6
+
+// CHECK: psignd %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x0a,0xf6]
+psignd %xmm6, %xmm6
+
+// CHECK: psignw 485498096, %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x24,0x25,0xf0,0x1c,0xf0,0x1c]
+psignw 485498096, %mm4
+
+// CHECK: psignw 485498096, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x34,0x25,0xf0,0x1c,0xf0,0x1c]
+psignw 485498096, %xmm6
+
+// CHECK: psignw 64(%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x62,0x40]
+psignw 64(%rdx), %mm4
+
+// CHECK: psignw -64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x64,0x82,0xc0]
+psignw -64(%rdx,%rax,4), %mm4
+
+// CHECK: psignw 64(%rdx,%rax,4), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x64,0x82,0x40]
+psignw 64(%rdx,%rax,4), %mm4
+
+// CHECK: psignw -64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x74,0x82,0xc0]
+psignw -64(%rdx,%rax,4), %xmm6
+
+// CHECK: psignw 64(%rdx,%rax,4), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x74,0x82,0x40]
+psignw 64(%rdx,%rax,4), %xmm6
+
+// CHECK: psignw 64(%rdx,%rax), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x64,0x02,0x40]
+psignw 64(%rdx,%rax), %mm4
+
+// CHECK: psignw 64(%rdx,%rax), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x74,0x02,0x40]
+psignw 64(%rdx,%rax), %xmm6
+
+// CHECK: psignw 64(%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x72,0x40]
+psignw 64(%rdx), %xmm6
+
+// CHECK: psignw %mm4, %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0xe4]
+psignw %mm4, %mm4
+
+// CHECK: psignw (%rdx), %mm4
+// CHECK: encoding: [0x0f,0x38,0x09,0x22]
+psignw (%rdx), %mm4
+
+// CHECK: psignw (%rdx), %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0x32]
+psignw (%rdx), %xmm6
+
+// CHECK: psignw %xmm6, %xmm6
+// CHECK: encoding: [0x66,0x0f,0x38,0x09,0xf6]
+psignw %xmm6, %xmm6
+