src/native_client/src/trusted/validator/x86/decoder/generator/ncdecode_0F.c

   1 /*
   2  * Copyright 2009 The Native Client Authors. All rights reserved.
   3  * Use of this source code is governed by a BSD-style license that can be
   4  * found in the LICENSE file.
   5  */
   6
   7 /*
   8  * Defines two byte opcodes beginning with OF. Taken from:
   9  * (1) Tables A-3 and A-4 of appendix "A2 - Opcode Encodings", in AMD
  10  *     document 24594-Rev.3.14-September 2007: "AMD64 Architecture
  11  *     Programmer's manual Volume 3: General-Purpose and System Instructions".
  12  * (2) Table A-4 of "appendix A.3", in Intel Document 253667-030US (March 2009):
  13  *     "Intel 64 and IA-32 Architectures Software Developer's Manual,
  14  *     Volume 2g: Instruction Set Reference, N-Z."
  15  *
  16  * Note: The SSE instructions that begin with 0F are not defined here. Look
  17  * at ncdecode_sse.c for the definitions of SSE instruction.
  18  *
  19  * Note: Invalid etries with f2 (REPNE) and f3 (REP) can be ommitted in
  20  * the tables, because the corresponding entry without that prefix will
  21  * be explicitly rejected (unless it is one of the special instructions
  22  * that allow such prefixes).
  23  */
  24
  25 #ifndef NACL_TRUSTED_BUT_NOT_TCB
  26 #error("This file is not meant for use in the TCB")
  27 #endif
  28
  29 #include "native_client/src/trusted/validator/x86/decoder/generator/ncdecode_forms.h"
  30 #include "native_client/src/trusted/validator/x86/decoder/generator/ncdecode_tablegen.h"
  31
  32 static void NaCl3DNow0F0FInsts(struct NaClSymbolTable* st) {
  33   /* All 3DNOW instructions of form: 0f 0f [modrm] [sib] [displacement]
  34    *      imm8_opcode
  35    *
  36    * These instructions encode into "OP Pq, Qq", based on the value of
  37    * imm8_opcode. We decode these instructions in two steps. The first
  38    * step uses a OF0F instruction to read in the bytes of the instruction.
  39    * These bytes are then inspected, and is replaced by the corresponding
  40    * 3DNOW instruction in the OFOF prefix table. If no such entry is found,
  41    * The original match is left so that the bytes are marked as an
  42    * invalid 3dnow instruction.
  43    *
  44    * Note: 3DNow instructions are defined in document 21928G/0-March 2000:
  45    * "3DNow!(TM) Technology Manual".
  46    */
  47   NaClBegDef("     0f0f:     Invalid $Pq, $Qq, $Ib",
  48                                                    NACLi_INVALID,   st);
  49   NaClAddIFlags(NACL_IFLAG(Opcode0F0F));
  50   NaClEndDef(                                                         Other);
  51   NaClDefine("     0f0f..0c: Pi2fw $Pq, $Qq",      NACLi_E3DNOW,  st, Move);
  52   NaClDefine("     0f0f..0d: Pi2fd $Pq, $Qq",      NACLi_3DNOW,   st, Move);
  53   NaClDefine("     0f0f..1c: Pf2iw $Pq, $Qq",      NACLi_E3DNOW,  st, Move);
  54   NaClDefine("     0f0f..1d: Pf2id $Pq, $Qq",      NACLi_3DNOW,   st, Move);
  55   NaClDefine("     0f0f..8a: Pfnacc $Pq, $Qq",     NACLi_E3DNOW,  st, Binary);
  56   NaClDefine("     0f0f..8e: Pfpnacc $Pq, $Qq",    NACLi_E3DNOW,  st, Binary);
  57   NaClDefine("     0f0f..90: Pfcmpge $Pq, $Qq",    NACLi_3DNOW,   st, Binary);
  58   NaClDefine("     0f0f..94: Pfmin $Pq, $Qq",      NACLi_3DNOW,   st, Binary);
  59   NaClDefine("     0f0f..96: Pfrcp $Pq, $Qq",      NACLi_3DNOW,   st, Move);
  60   NaClDefine("     0f0f..97: Pfrsqrt $Pq, $Qq",    NACLi_3DNOW,   st, Move);
  61   NaClDefine("     0f0f..9a: Pfsub $Pq, $Qq",      NACLi_3DNOW,   st, Binary);
  62   NaClDefine("     0f0f..9e: Pfadd $Pq, $Qq",      NACLi_3DNOW,   st, Binary);
  63   NaClDefine("     0f0f..a0: Pfcmpgt $Pq, $Qq",    NACLi_3DNOW,   st, Binary);
  64   NaClDefine("     0f0f..a4: Pfmax $Pq, $Qq",      NACLi_3DNOW,   st, Binary);
  65   NaClDefine("     0f0f..a6: Pfrcpit1 $Pq, $Qq",   NACLi_3DNOW,   st, Binary);
  66   NaClDefine("     0f0f..a7: Pfrsqit1 $Pq, $Qq",   NACLi_3DNOW,   st, Binary);
  67   NaClDefine("     0f0f..aa: Pfsubr $Pq, $Qq",     NACLi_3DNOW,   st, Binary);
  68   NaClDefine("     0f0f..ae: Pfacc $Pq, $Qq",      NACLi_3DNOW,   st, Binary);
  69   NaClDefine("     0f0f..b0: Pfcmpeq $Pq, $Qq",    NACLi_3DNOW,   st, Binary);
  70   NaClDefine("     0f0f..b4: Pfmul $Pq, $Qq",      NACLi_3DNOW,   st, Binary);
  71   NaClDefine("     0f0f..b6: Pfrcpit2 $Pq, $Qq",   NACLi_3DNOW,   st, Binary);
  72   NaClDefine("     0f0f..b7: Pmulhrw $Pq, $Qq",    NACLi_3DNOW,   st, Binary);
  73   NaClDefine("     0f0f..bb: Pswapd $Pq, $Qq",     NACLi_E3DNOW,  st, Move);
  74   NaClDefine("     0f0f..bf: Pavgusb $Pq, $Qq",    NACLi_3DNOW,   st, Binary);
  75 }
  76
  77 void NaClDef0FInsts(struct NaClSymbolTable* st) {
  78   int i;
  79   NaClDefPrefixInstMrmChoices(Prefix0F, 0x01, 1, 4);
  80   NaClDefPrefixInstMrmChoices(Prefix0F, 0x01, 3, 9);
  81   NaClDefPrefixInstMrmChoices_32_64(Prefix0F, 0x01, 7, 2, 4);
  82   NaClDefPrefixInstMrmChoices_32_64(Prefix0F, 0xc7, 1, 1, 2);
  83   NaClDefPrefixInstMrmChoices(Prefix0F, 0xae, 5, 8);
  84   NaClDefPrefixInstMrmChoices(Prefix0F, 0xae, 6, 8);
  85   NaClDefPrefixInstMrmChoices(Prefix0F, 0xae, 7, 9);
  86
  87   NaClDefine("     0f00/0:   Sldt $Mw/Rv",         NACLi_SYSTEM,  st, Sets);
  88   NaClDefine("     0f00/1:   Str   $Mw/Rv",        NACLi_SYSTEM,  st, Sets);
  89   NaClDefine("     0f00/2:   Lldt $Ew",            NACLi_SYSTEM,  st, Uses);
  90   NaClDefine("     0f00/3:   Ltr $Ew",             NACLi_SYSTEM,  st, Uses);
  91   NaClDefine("     0f00/4:   Verr $Ew",            NACLi_SYSTEM,  st, Other);
  92   NaClDefine("     0f00/5:   Verw $Ew",            NACLi_SYSTEM,  st, Other);
  93   NaClDefIter("    0f00/@i:  Invalid", 6, 7,       NACLi_INVALID, st, Other);
  94   NaClDefine("     0f01/0:   Sgdt $Ms",            NACLi_SYSTEM,  st, Sets);
  95   NaClDefine("     0f01/1:   Sidt $Ms",            NACLi_SYSTEM,  st, Sets);
  96   NaClDefine("     0f01/1/0: Monitor %reax, %ecx, %edx",
  97                                                    NACLi_SYSTEM,  st, Uses);
  98   NaClDefine("     0f01/1/1: Mwait %eax, %ecx",    NACLi_SYSTEM,  st, Other);
  99   NaClDefine("     0f01/1:   Invalid",             NACLi_INVALID, st, Other);
 100   NaClDefine("     0f01/2:   Lgdt $Ms",            NACLi_SYSTEM,  st, Uses);
 101   NaClDefine("     0f01/3:   Lidt $Ms",            NACLi_SYSTEM,  st, Uses);
 102   NaClDef_64("     0f01/3/0: Vmrun $rAXva",        NACLi_SVM,     st, Uses);
 103   NaClDefine("     0f01/3/1: Vmmcall",             NACLi_SVM,     st, Other);
 104   NaClDefine("     0f01/3/2: Vmload $rAXva",       NACLi_SVM,     st, Uses);
 105   NaClDefine("     0f01/3/3: Vmsave $rAXva",       NACLi_SVM,     st, Uses);
 106   NaClDefine("     0f01/3/4: Stgi",                NACLi_SVM,     st, Other);
 107   NaClDefine("     0f01/3/5: Clgi",                NACLi_SVM,     st, Other);
 108   NaClDefine("     0f01/3/6: Skinit {%eip}, %eax", NACLi_SVM,     st, Jump);
 109   NaClDefine("     0f01/3/7: Invlpga $rAXva, %ecx",
 110                                                    NACLi_SVM,     st, Uses);
 111   NaClDef_32("     0f01/3:   Invalid",             NACLi_INVALID, st, Other);
 112   NaClDefine("     0f01/4:   Smsw $Mw/Rv",         NACLi_SYSTEM,  st, Sets);
 113   NaClDefine("     0f01/5:   Invalid",             NACLi_INVALID, st, Other);
 114   NaClDefine("     0f01/6:   Lmsw $Ew",            NACLi_INVALID, st, Uses);
 115   NaClDefine("     0f01/7:   Invlpg $Mb",          NACLi_SYSTEM,  st, Uses);
 116   NaClDef_64("     0f01/7/0: Swapgs {%gs}",        NACLi_SYSTEM,  st, Sets);
 117   NaClDef_64("     0f01/7/1: Rdtscp {%rdx}, {%rax}, {%rcx}",
 118                                                    NACLi_RDTSCP,  st, Sets);
 119   NaClDefine("     0f01/7:   Invalid",             NACLi_INVALID, st, Other);
 120   /* Note: Xed appears to use Ev for second argument for Lar aand Lsl. */
 121   NaClDefine("     0f02:     Lar $Gv, $Ew",        NACLi_SYSTEM,  st, Other);
 122   NaClDefine("     0f03:     Lsl $Gv, $Ew",        NACLi_SYSTEM,  st, Other);
 123   NaClDefine("     0f04:     Invalid",             NACLi_INVALID, st, Other);
 124   NaClDef_64("     0f05:     Syscall {%rip}, {%rcx}",
 125                                                    NACLi_SYSCALL, st, SysCall);
 126   NaClDefine("     0f06:     Clts",                NACLi_SYSTEM,  st, Other);
 127   NaClDef_64("     0f07:     Sysret {%rip}, {%rcx}",
 128                                                    NACLi_SYSTEM,  st, SysRet);
 129   NaClDefine("     0f08:     Invd",                NACLi_SYSTEM,  st, Other);
 130   NaClDefine("     0f09:     Wbinvd",              NACLi_SYSTEM,  st, Other);
 131   NaClDefine("     0f0a:     Invalid",             NACLi_INVALID, st, Other);
 132   /* Note: ud2 with no prefix bytes is currently understood as a NOP sequence.
 133    * The definition here only applies to cases where prefix bytes are added.
 134    */
 135   NaClDefine("     0f0b:     Ud2",                 NACLi_386,     st, Other);
 136   NaClDefine("     0f0c:     Invalid",             NACLi_INVALID, st, Other);
 137   NaClDefine("     0f0d/0:   Prefetch_exclusive $Mb",
 138                                                    NACLi_3DNOW,   st, Other);
 139   NaClDefine("     0f0d/1:   Prefetch_modified $Mb",
 140                                                    NACLi_3DNOW,   st, Other);
 141   NaClDefine("     0f0d/2:   Prefetch_reserved $Mb",
 142                                                    NACLi_3DNOW,   st, Other);
 143   NaClDefine("     0f0d/3:   Prefetch_modified $Mb",
 144                                                    NACLi_3DNOW,   st, Other);
 145   NaClDefine("     0f0d/4:   Prefetch_reserved $Mb",
 146                                                    NACLi_3DNOW,   st, Other);
 147   NaClDefine("     0f0d/5:   Prefetch_reserved $Mb",
 148                                                    NACLi_3DNOW,   st, Other);
 149   NaClDefine("     0f0d/6:   Prefetch_reserved $Mb",
 150                                                    NACLi_3DNOW,   st, Other);
 151   NaClDefine("     0f0d/7:   Prefetch_reserved $Mb",
 152                                                    NACLi_3DNOW,   st, Other);
 153   NaClDefine("     0f0e:     Femms",               NACLi_3DNOW,   st, Other);
 154   NaCl3DNow0F0FInsts(st);
 155   NaClDefIter("  f20f13+@i:  Invalid", 0, 4,       NACLi_INVALID, st, Other);
 156   NaClDefine("     0f18/0:   Prefetchnta $Mb",     NACLi_MMX,     st, Other);
 157   NaClDefine("     0f18/1:   Prefetcht0 $Mb",      NACLi_MMX,     st, Other);
 158   NaClDefine("     0f18/2:   Prefetcht1 $Mb",      NACLi_MMX,     st, Other);
 159   NaClDefine("     0f18/3:   Prefetcht2 $Mb",      NACLi_MMX,     st, Other);
 160   /* The following 4 are reserved for future prefetch instructions. */
 161   NaClDefIter("    0f18/@i:  Invalid", 4, 7,       NACLi_INVALID, st, Other);
 162   NaClDefine("     0f1f/0:   Nop",                 NACLi_386,     st, Other);
 163   NaClDefIter("    0f19+@i/r: Nop", 0, 6,          NACLi_386,     st, Other);
 164   NaClDefine("     0f20:     Mov $Rd/q, $Cd/q",    NACLi_SYSTEM,  st, Move);
 165   NaClDefine("     0f21:     Mov $Rd/q, $Dd/q",    NACLi_SYSTEM,  st, Move);
 166   NaClDefine("     0f22:     Mov $Cd/q, $Rd/q",    NACLi_SYSTEM,  st, Move);
 167   NaClDefine("     0f23:     Mov $Dd/q, $Rd/q",    NACLi_SYSTEM,  st, Move);
 168   NaClDefIter("    0f24+@i:  Invalid", 0, 3,       NACLi_INVALID, st, Other);
 169   NaClDefine("     0f30:     Wrmsr {%eax}, {%edx}, {%ecx}",
 170                                                    NACLi_RDMSR,   st, Uses);
 171   NaClDefine("     0f31:     Rdtsc {%eax}, {%edx}",
 172                                                    NACLi_RDTSC,   st, Sets);
 173   NaClDefine("     0f32:     Rdmsr {%eax}, {%edx}, {%ecx}",
 174                                                    NACLi_RDMSR,   st, O2Move);
 175   NaClDefine("     0f33:     Rdpmc {%eax}, {%edx}, {%ecx}",
 176                                                    NACLi_SYSTEM,  st, O2Move);
 177   NaClDefine("     0f34:     Sysenter {%eip}, {%esp}, {%cs}, {%ss}",
 178                                                    NACLi_SYSENTER,st, SysJump);
 179   NaClDefine("     0f35:     Sysexit {%eip}, {%esp}, {%cs}, {%ss}, "
 180                                  "{%edx}, {%ecx}", NACLi_SYSENTER,st, SysJump);
 181   NaClDefIter("    0f36+@i:  Invalid", 0, 9,       NACLi_INVALID, st, Other);
 182   NaClDefine("     0f40:     Cmovo $Gv, $Ev",      NACLi_CMOV,    st, Move);
 183   NaClDefine("     0f41:     Cmovno $Gv, $Ev",     NACLi_CMOV,    st, Move);
 184   NaClDefine("     0f42:     Cmovb $Gv, $Ev",      NACLi_CMOV,    st, Move);
 185   NaClDefine("     0f43:     Cmovnb $Gv, $Ev",     NACLi_CMOV,    st, Move);
 186   NaClDefine("     0f44:     Cmovz $Gv, $Ev",      NACLi_CMOV,    st, Move);
 187   NaClDefine("     0f45:     Cmovnz $Gv, $Ev",     NACLi_CMOV,    st, Move);
 188   NaClDefine("     0f46:     Cmovbe $Gv, $Ev",     NACLi_CMOV,    st, Move);
 189   NaClDefine("     0f47:     Cmovnbe $Gv, $Ev",    NACLi_CMOV,    st, Move);
 190   NaClDefine("     0f48:     Cmovs $Gv, $Ev",      NACLi_CMOV,    st, Move);
 191   NaClDefine("     0f49:     Cmovns $Gv, $Ev",     NACLi_CMOV,    st, Move);
 192   NaClDefine("     0f4a:     Cmovp $Gv, $Ev",      NACLi_CMOV,    st, Move);
 193   NaClDefine("     0f4b:     Cmovnp $Gv, $Ev",     NACLi_CMOV,    st, Move);
 194   NaClDefine("     0f4c:     Cmovl $Gv, $Ev",      NACLi_CMOV,    st, Move);
 195   NaClDefine("     0f4d:     Cmovnl $Gv, $Ev",     NACLi_CMOV,    st, Move);
 196   NaClDefine("     0f4e:     Cmovle $Gv, $Ev",     NACLi_CMOV,    st, Move);
 197   NaClDefine("     0f4f:     Cmovnle $Gv, $Ev",    NACLi_CMOV,    st, Move);
 198   /* Note: We special case the 66 prefix on direct conditional jumps, by
 199    * explicitly disallowing 16-bit direct jumps. This is done partly because
 200    * some versions (within x86-64) are not supported in such cases. However,
 201    * NaCl also doesn't want to allow 16-bit direct jumps.
 202    */
 203   NaClDefine("     0f80:     Jo {%@ip}, $Jzd",     NACLi_386,     st, Jump);
 204   NaClDefine("     0f81:     Jno {%@ip}, $Jzd",    NACLi_386,     st, Jump);
 205   NaClDefine("     0f82:     Jb {%@ip}, $Jzd",     NACLi_386,     st, Jump);
 206   NaClDefine("     0f83:     Jnb {%@ip}, $Jzd",    NACLi_386,     st, Jump);
 207   NaClDefine("     0f84:     Jz {%@ip}, $Jzd",     NACLi_386,     st, Jump);
 208   NaClDefine("     0f85:     Jnz {%@ip}, $Jzd",    NACLi_386,     st, Jump);
 209   NaClDefine("     0f86:     Jbe {%@ip}, $Jzd",    NACLi_386,     st, Jump);
 210   NaClDefine("     0f87:     Jnbe {%@ip}, $Jzd",   NACLi_386,     st, Jump);
 211   NaClDefine("     0f88:     Js {%@ip}, $Jzd",     NACLi_386,     st, Jump);
 212   NaClDefine("     0f89:     Jns {%@ip}, $Jzd",    NACLi_386,     st, Jump);
 213   NaClDefine("     0f8a:     Jp {%@ip}, $Jzd",     NACLi_386,     st, Jump);
 214   NaClDefine("     0f8b:     Jnp {%@ip}, $Jzd",    NACLi_386,     st, Jump);
 215   NaClDefine("     0f8c:     Jl {%@ip}, $Jzd",     NACLi_386,     st, Jump);
 216   NaClDefine("     0f8d:     Jnl {%@ip}, $Jzd",    NACLi_386,     st, Jump);
 217   NaClDefine("     0f8e:     Jle {%@ip}, $Jzd",    NACLi_386,     st, Jump);
 218   NaClDefine("     0f8f:     Jnle {%@ip}, $Jzd",   NACLi_386,     st, Jump);
 219   NaClDefine("     0f90:     Seto $Eb",            NACLi_386,     st, Sets);
 220   NaClDefine("     0f91:     Setno $Eb",           NACLi_386,     st, Sets);
 221   NaClDefine("     0f92:     Setb $Eb",            NACLi_386,     st, Sets);
 222   NaClDefine("     0f93:     Setnb $Eb",           NACLi_386,     st, Sets);
 223   NaClDefine("     0f94:     Setz $Eb",            NACLi_386,     st, Sets);
 224   NaClDefine("     0f95:     Setnz $Eb",           NACLi_386,     st, Sets);
 225   NaClDefine("     0f96:     Setbe $Eb",           NACLi_386,     st, Sets);
 226   NaClDefine("     0f97:     Setnbe $Eb",          NACLi_386,     st, Sets);
 227   NaClDefine("     0f98:     Sets $Eb",            NACLi_386,     st, Sets);
 228   NaClDefine("     0f99:     Setns $Eb",           NACLi_386,     st, Sets);
 229   NaClDefine("     0f9a:     Setp $Eb",            NACLi_386,     st, Sets);
 230   NaClDefine("     0f9b:     Setnp $Eb",           NACLi_386,     st, Sets);
 231   NaClDefine("     0f9c:     Setl $Eb",            NACLi_386,     st, Sets);
 232   NaClDefine("     0f9d:     Setnl $Eb",           NACLi_386,     st, Sets);
 233   NaClDefine("     0f9e:     Setle $Eb",           NACLi_386,     st, Sets);
 234   NaClDefine("     0f9f:     Setnle $Eb",          NACLi_386,     st, Sets);
 235   NaClDefine("     0fa0:     Push {%@sp}, %fs",    NACLi_386,     st, Push);
 236   NaClDefine("     0fa1:     Pop {%@sp}, %fs",     NACLi_386,     st, Pop);
 237   NaClDefine("     0fa2:     Cpuid {%ebx}, {%edx}, {%eax}, {%ecx}",
 238                                                    NACLi_386,     st, Cpuid);
 239   NaClDefine("     0fa3:     Bt $Ev, $Gv",         NACLi_386,     st, Compare);
 240   NaClDefine("     0fa4:     Shld $Ev, $Gv, $Ib",  NACLi_386,     st, Binary);
 241   NaClDefine("     0fa5:     Shld $Ev, $Gv, %cl",  NACLi_386,     st, Binary);
 242   NaClDefIter("    0fa6+@i:  Invalid", 0, 1,       NACLi_INVALID, st, Other);
 243   NaClDefine("     0fa8:     Push {%@sp}, %gs",    NACLi_386,     st, Push);
 244   NaClDefine("     0fa9:     Pop {%@sp}, %gs",     NACLi_386,     st, Pop);
 245   NaClDefine("     0faa:     Rsm",                 NACLi_SYSTEM,  st, Other);
 246   NaClDefine("     0fab:     Bts $Ev, $Gv",        NACLi_386,     st, Binary);
 247   NaClDefine("     0fac:     Shrd $Ev, $Gv, $Ib",  NACLi_386,     st, Nary);
 248   NaClDefine("     0fad:     Shrd $Ev, $Gv, %cl",  NACLi_386,     st, Nary);
 249
 250   NaClDefine("     0fae/0:   Fxsave $Mf",          NACLi_FXSAVE,  st, Sets);
 251   NaClDefine("     0fae/1:   Fxrstor $Mf",         NACLi_FXSAVE,  st, Uses);
 252   NaClDefine("     0fae/2:   Ldmxcsr $Md",         NACLi_SSE,     st, Uses);
 253   NaClDefine("     0fae/3:   Stmxcsr $Md",         NACLi_SSE,     st, Sets);
 254   NaClDefine("     0fae/4:   Invalid",             NACLi_INVALID, st, Other);
 255   NaClDefine("     0fae/5/0: Lfence",              NACLi_SSE2,    st, Other);
 256   NaClDefine("     0fae/6/0: Mfence",              NACLi_SSE2,    st, Other);
 257   NaClDefine("     0fae/7/0: Sfence",              NACLi_SFENCE_CLFLUSH,
 258                                                                   st, Other);
 259   NaClDefIter("    0fae/5/@i: Invalid", 1, 7,      NACLi_INVALID, st, Other);
 260   NaClDefIter("    0fae/6/@i: Invalid", 1, 7,      NACLi_INVALID, st, Other);
 261   NaClDefIter("    0fae/7/@i: Invalid", 1, 7,      NACLi_INVALID, st, Other);
 262   NaClDefine("     0fae/7:   Clflush $Mb",         NACLi_SFENCE_CLFLUSH,
 263                                                                   st, Uses);
 264
 265   NaClDefine("   f20fae:     Invalid",             NACLi_INVALID, st, Other);
 266   NaClDefine("   660fae:     Invalid",             NACLi_INVALID, st, Other);
 267   NaClDefine("     0faf:     Imul $Gv, $Ev",       NACLi_386,     st, Binary);
 268   NaClDefine("     0fb0:     Cmpxchg {%al}, $Eb, $Gb",
 269                                                    NACLi_386,     st, Exchange);
 270   NaClDefine("     0fb1:     Cmpxchg {$rAXv}, $Ev, $Gv",
 271                                                    NACLi_386,     st, Exchange);
 272   NaClDefine("     0fb2:     Lss $SGz, $Mp",       NACLi_386,     st, Lea);
 273   NaClDefine("     0fb3:     Btr $Ev, $Gv",        NACLi_386,     st, Binary);
 274   NaClDefine("     0fb4:     Lfs $SGz, $Mp",       NACLi_386,     st, Lea);
 275   NaClDefine("     0fb5:     Lgs $SGz, $Mp",       NACLi_386,     st, Lea);
 276   NaClDefine("     0fb6:     Movzx $Gv, $Eb",      NACLi_386,     st, Move);
 277   NaClDefine("     0fb7:     Movzx $Gv, $Ew",      NACLi_386,     st, Move);
 278
 279   NaClDefine("     0fb8:     Invalid",             NACLi_INVALID, st, Other);
 280   NaClDefine("     0fb9/r:   Invalid",             NACLi_INVALID, st, Other);
 281   NaClDefine("     0fba/4:   Bt $Ev, $Ib",         NACLi_386,     st, Compare);
 282   NaClDefine("     0fba/5:   Bts $Ev, $Ib",        NACLi_386,     st, Binary);
 283   NaClDefine("     0fba/6:   Btr $Ev, $Ib",        NACLi_386,     st, Binary);
 284   NaClDefine("     0fba/7:   Btc $Ev, $Ib",        NACLi_386,     st, Binary);
 285   NaClDefine("     0fba/r:   Invalid",             NACLi_INVALID, st, Other);
 286   NaClDefine("     0fbb:     Btc $Ev, $Gv",        NACLi_386,     st, Binary);
 287   NaClDefine("     0fbc:     Bsf $Gv, $Ev",        NACLi_386,     st, Move);
 288   NaClDefine("     0fbd:     Bsr $Gv, $Ev",        NACLi_386,     st, Move);
 289   NaClDefine("     0fbe:     Movsx $Gv, $Eb",      NACLi_386,     st, Move);
 290   NaClDefine("     0fbf:     Movsx $Gv, $Ew",      NACLi_386,     st, Move);
 291   NaClDefine("     0fc0:     Xadd $Eb, $Gb",       NACLi_386,     st, Exchange);
 292   NaClDefine("     0fc1:     Xadd $Ev, $Gv",       NACLi_386,     st, Exchange);
 293   NaClBegDef("     0fc7/1:   Cmpxchg8b {%edx}, {%eax}, $Mq",
 294                                                    NACLi_CMPXCHG8B, st);
 295   NaClAddIFlags(NACL_IFLAG(OperandSize_v));
 296   NaClEndDef(                                                         Exchange);
 297   NaClBegD64("     0fc7/1:   Cmpxchg16b {%rdx}, {%eax}, $Mdq",
 298                                                    NACLi_CMPXCHG16B, st);
 299   NaClAddIFlags(NACL_IFLAG(OperandSize_o));
 300   NaClEndDef(                                                         Exchange);
 301   NaClDefine("     0fc7/r:   Invalid",             NACLi_INVALID, st, Other);
 302   for (i = 0; i <= 7; ++i) {
 303     NaClDefPrefixInstChoices(Prefix0F, 0xc8 + i, 2);
 304   }
 305   NaClDefReg("     0fc8+@reg:  Bswap $r8vd", 0, 7, NACLi_386,     st,
 306                                                                   UnaryUpdate);
 307   NaClDefReg("     0fc8+@reg:  Bswap $r8vq", 0, 7,  NACLi_386,    st,
 308                                                                   UnaryUpdate);
 309 }