Changeset 6988 for branches

Timestamp:

Aug 2, 2007, 11:58:27 AM (17 years ago)

Author:

R. Matthew Emerson

Message:

Add instruction templates for IA-32. Add :self pseudo-operand.
Conditionalize functions to access *X8664-REGISTER-ENTRIES*
and *X8632-REGISTER-ENTRIES* depending on target-arch.

File:

• branches/ia32/compiler/X86/x86-asm.lisp (modified) (10 diffs)

branches/ia32/compiler/X86/x86-asm.lisp

@@ -330 +330 @@
 (defconstant +operand-type-Label+ #x100000000)
 
+;;; 4 bytes and a :reloc; otherwise just like a 32-bit immediate
+(defconstant +operand-type-Self+ #x200000000)
+
 (defconstant +operand-type-Reg+ (logior +operand-type-Reg8+ +operand-type-Reg16+ +operand-type-Reg32+ +operand-type-Reg64+)) ; gen'l register
 (defconstant +operand-type-WordReg+ (logior +operand-type-Reg16+ +operand-type-Reg32+ +operand-type-Reg64+))
@@ -397 +400 @@
     (:ByteMem . ,+operand-type-ByteMem+)
     (:Label . ,+operand-type-Label+)
+    (:Self . ,+operand-type-Self+)
   ))
 
@@ -564 +568 @@
     :insert-reg4-pseudo-rm-high
     :insert-reg4-pseudo-rm-low
+    :insert-self
     ))
 
@@ -705 +710 @@
                                 (x86-memory-operand-scale operand)
                                 (x86-memory-operand-type operand)))
+
+(defmacro def-x86-opcode (name&flags types-and-classes base-opcode
+                          modrm-byte &rest prefixes)
+  `(%make-x86-opcode-template
+    :mnemonic ,(parse-x86-opcode-name name&flags)
+    :flags ,(parse-x86-opcode-flags name&flags)
+    :operand-types ,(parse-x86-opcode-operand-types types-and-classes)
+    :operand-classes ,(parse-x86-opcode-operand-classes types-and-classes)
+    :base-opcode ,base-opcode
+    :prefixes ',prefixes
+    :rex-prefix 0
+    :modrm-byte ,modrm-byte))
+
+(defparameter *x86-32-bit-only-opcode-templates*
+  (vector
+   ;; call
+   (def-x86-opcode call ((:reg32 :insert-modrm-rm))
+     #xff #o320)
+
+   ;; dec (single byte encoding)
+   (def-x86-opcode decl ((:reg32 :insert-opcode-reg))
+     #x48 nil)
+   (def-x86-opcode decw ((:reg16 :insert-opcode-reg))
+     #x48 nil #x66)
+   
+   ;; inc (single byte encoding)
+   (def-x86-opcode incl ((:reg32 :insert-opcode-reg))
+     #x40 nil)
+   (def-x86-opcode incw ((:reg16 :insert-opcode-reg))
+     #x40 nil #x66)
+   
+   ;; UUOs.  Expect lots more, some of which may take pseudo-operands.
+   (def-x86-opcode uuo-error-slot-unbound ((:reg32 :insert-opcode-reg4)
+                                           (:reg32 :insert-reg4-pseudo-rm-high)
+                                           (:reg32 :insert-reg4-pseudo-rm-low))
+     #xcd70 0)
+   
+   ;;; DON'T use #xcd8x: doing so will make Mach angry and confused.
+   
+   (def-x86-opcode uuo-error-unbound ((:reg32 :insert-opcode-reg4))
+     #xcd90 nil)
+   
+   (def-x86-opcode uuo-error-udf ((:reg32 :insert-opcode-reg4))
+     #xcda0 nil)
+   
+   (def-x86-opcode uuo-error-reg-not-type ((:reg32 :insert-opcode-reg4) (:imm8 :insert-imm8))
+     #xcdb0 nil)
+   
+   (def-x86-opcode uuo-error-too-few-args ()
+     #xcdc0 nil)
+   (def-x86-opcode uuo-error-too-many-args ()
+     #xcdc1 nil)
+   (def-x86-opcode uuo-error-wrong-number-of-args ()
+     #xcdc2 nil)
+   (def-x86-opcode uuo-error-array-rank ((:reg32 :insert-reg4-pseudo-rm-high)
+                                         (:reg32 :insert-reg4-pseudo-rm-low))
+     #xcdc3 0)
+   
+   (def-x86-opcode uuo-gc-trap ()
+     #xcdc4 nil)
+   (def-x86-opcode uuo-alloc ()
+     #xcdc5 nil)
+   (def-x86-opcode uuo-error-not-callable ()
+     #xcdc6 nil)
+   (def-x86-opcode uuo-error-udf-call ()
+     #xcdc7 nil)
+   
+   (def-x86-opcode uuo-error-vector-bounds ((:reg32 :insert-reg4-pseudo-rm-high)
+                                            (:reg32 :insert-reg4-pseudo-rm-low))
+     #xcdc8 0)
+   
+   (def-x86-opcode uuo-error-call-macro-or-special-operator ()
+     #xcdc9 nil)
+   
+   (def-x86-opcode uuo-error-debug-trap ()
+     #xcdca nil)
+   
+   (def-x86-opcode uuo-error-array-bounds ((:reg32 :insert-reg4-pseudo-rm-high)
+                                           (:reg32 :insert-reg4-pseudo-rm-low))
+     #xcdcb 0)
+   
+   (def-x86-opcode uuo-error-eep-unresolved ((:reg32 :insert-reg4-pseudo-rm-high)
+                                             (:reg32 :insert-reg4-pseudo-rm-low))
+     #xcdcc 0)
+   
+   (def-x86-opcode uuo-error-debug-trap-with-string ()
+     #xcdcd nil)
+   
+   (def-x86-opcode uuo-error-reg-not-tag ((:reg32 :insert-opcode-reg4)
+                                          (:imm8 :insert-imm8))
+     #xcdd0 nil)
+   (def-x86-opcode uuo-error-reg-not-list ((:reg32 :insert-opcode-reg4))
+     #xcde0 nil)
+   (def-x86-opcode uuo-error-reg-not-fixnum ((:reg32 :insert-opcode-reg4))
+     #xcdf0 nil)
+   ))
+
+
+(defparameter *x86-common-opcode-templates*
+  (vector
+   ;; adc
+   (def-x86-opcode adcl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x11 #o300)
+   (def-x86-opcode adcl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x13 #o000)
+   (def-x86-opcode adcl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x11 #x00)
+   (def-x86-opcode adcl ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm))
+     #x83 #o320)
+   (def-x86-opcode adcl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #x15 nil)
+   (def-x86-opcode adcl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #x81 #o320)
+   (def-x86-opcode adcl ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o020)
+   (def-x86-opcode adcl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #x81 #o020)
+
+   (def-x86-opcode adcw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x11 #o300 #x66)
+   (def-x86-opcode adcw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x13 #o000 #x66)
+   (def-x86-opcode adcw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x11 #x00 #x66)
+   (def-x86-opcode adcw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm))
+     #x83 #o320 #x66)
+   (def-x86-opcode adcw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #x15 nil #x66)
+   (def-x86-opcode adcw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #x81 #o320 #x66)
+   (def-x86-opcode adcw ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o020 #x66)
+   (def-x86-opcode adcw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #x81 #o020 #x66)
+
+   (def-x86-opcode adcb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x10 #o300)
+   (def-x86-opcode adcb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x12 #o000)
+   (def-x86-opcode adcb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x10 #x00)
+   (def-x86-opcode adcb ((:imm8 :insert-imm8) (:acc :insert-nothing))
+     #x14 nil)
+   (def-x86-opcode adcb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #x80 #o320)
+   (def-x86-opcode adcb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #x80 #o320)
+   (def-x86-opcode adcb ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x80 #o020)
+
+   ;; add
+   (def-x86-opcode addl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x01 #o300)
+   (def-x86-opcode addl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x03 #o000)
+   (def-x86-opcode addl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x01 #x00)
+   (def-x86-opcode addl ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm))
+     #x83 #o300)
+   (def-x86-opcode addl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #x05 nil)
+   (def-x86-opcode addl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #x81 #o300)
+   (def-x86-opcode addl ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o000)
+   (def-x86-opcode addl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #x81 #o000)
+
+   (def-x86-opcode addw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x01 #o300 #x66)
+   (def-x86-opcode addw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x03 #o000 #x66)
+   (def-x86-opcode addw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x01 #x00 #x66)
+   (def-x86-opcode addw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm))
+     #x83 #o300 #x66)
+   (def-x86-opcode addw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #x05 nil #x66)
+   (def-x86-opcode addw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #x81 #o300 #x66)
+   (def-x86-opcode addw ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o000 #x66)
+   (def-x86-opcode addw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #x81 #o000 #x66)
+
+   (def-x86-opcode addb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x00 #o300)
+   (def-x86-opcode addb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x02 #o000)
+   (def-x86-opcode addb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x00 #x00)
+   (def-x86-opcode addb ((:imm8s :insert-imm8s) (:acc :insert-nothing))
+     #x04 nil)
+   (def-x86-opcode addb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o300)
+   (def-x86-opcode addb ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x80 #o000)
+
+   ;; and
+   (def-x86-opcode andl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x21 #o300)
+   (def-x86-opcode andl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x23 #o000)
+   (def-x86-opcode andl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x21 #x00)
+   (def-x86-opcode andl ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm))
+     #x83 #o340)
+   (def-x86-opcode andl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #x25 nil)
+   (def-x86-opcode andl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #x81 #o340)
+   (def-x86-opcode andl ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o040)
+   (def-x86-opcode andl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #x81 #o040)
+
+   (def-x86-opcode andw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x21 #o300 #x66)
+   (def-x86-opcode andw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x23 #o000 #x66)
+   (def-x86-opcode andw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x21 #x00 #x66)
+   (def-x86-opcode andw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm))
+     #x83 #o340 #x66)
+   (def-x86-opcode andw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #x25 nil #x66)
+   (def-x86-opcode andw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #x81 #o340 #x66)
+   (def-x86-opcode andw ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o040 #x66)
+   (def-x86-opcode andw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #x81 #o040 #x66)
+
+   (def-x86-opcode andb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x20 #o300)
+   (def-x86-opcode andb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x22 #o000)
+   (def-x86-opcode andb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x20 #o000)
+   (def-x86-opcode andb ((:imm8s :insert-imm8s) (:acc :insert-nothing))
+     #x24 nil)
+   (def-x86-opcode andb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o340)
+   (def-x86-opcode andb ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x80 #o040)
+
+   ;; bsf
+   (def-x86-opcode bsfl ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0fbc #o300)
+   (def-x86-opcode bsfl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0fbc #o000)
+
+   (def-x86-opcode bsfw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0fbc #o300 #x66)
+   (def-x86-opcode bsfw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0fbc #o000 #x66)
+
+   ;; bsr
+   (def-x86-opcode bsrl ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0fbd #o300)
+   (def-x86-opcode bsrl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0fbd #o000)
+
+   (def-x86-opcode bsrw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0fbd #o300 #x66)
+   (def-x86-opcode bsrw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0fbd #o000 #x66)
+
+   ;; bswap
+   (def-x86-opcode bswapl ((:reg64 :insert-opcode-reg))
+     #x0fc8 nil)
+
+   ;; bt
+   (def-x86-opcode btl ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #x0fba #o340)
+   (def-x86-opcode btl ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x0fba #o040)
+   (def-x86-opcode btl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x0fa3 #o300)
+   (def-x86-opcode btl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fa3 #o000)
+
+   (def-x86-opcode btw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #x0fba #o340 #x66)
+   (def-x86-opcode btw ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x0fba #o040 #x66)
+   (def-x86-opcode btw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x0fa3 #o300 #x66)
+   (def-x86-opcode btw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fa3 #o000 #x66)
+
+   ;; btc
+   (def-x86-opcode btcl ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #x0fba #o370)
+   (def-x86-opcode btcl ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x0fba #o070)
+   (def-x86-opcode btcl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x0fbb #o300)
+   (def-x86-opcode btcl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fbb #o000)
+
+   (def-x86-opcode btcw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #x0fba #o370 #x66)
+   (def-x86-opcode btcw ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x0fba #o070 #x66)
+   (def-x86-opcode btcw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x0fbb #o300 #x66)
+   (def-x86-opcode btcw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fbb #o000 #x66)
+
+   ;; btr
+   (def-x86-opcode btrl ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #x0fba #o360)
+   (def-x86-opcode btrl ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x0fba #o060)
+   (def-x86-opcode btrl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x0fb3 #o300)
+   (def-x86-opcode btrl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fb3 #o000)
+
+   (def-x86-opcode btrw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #x0fba #o360 #x66)
+   (def-x86-opcode btrw ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x0fba #o060 #x66)
+   (def-x86-opcode btrw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x0fb3 #o300 #x66)
+   (def-x86-opcode btrw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fb3 #o000 #x66)
+
+   ;; bts
+   (def-x86-opcode btsl ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #x0fba #o350)
+   (def-x86-opcode btsl ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x0fba #o050)
+   (def-x86-opcode btsl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x0fab #o300)
+   (def-x86-opcode btsl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fab #o000)
+
+   (def-x86-opcode btsw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #x0fba #o350 #x66)
+   (def-x86-opcode btsw ((:imm8 :insert-imm8) (:anymem :insert-memory))
+     #x0fba #o050 #x66)
+   (def-x86-opcode btsw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x0fab #o300 #x66)
+   (def-x86-opcode btsw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fab #o000 #x66)
+
+   ;; call
+   (def-x86-opcode call ((:label :insert-label))
+     #xe8 nil)
+   (def-x86-opcode call ((:anymem :insert-memory))
+     #xff #o020)
+
+   ;; cbtw
+   (def-x86-opcode cbtw ()
+     #x98 nil #x66)
+
+   ;; clc
+   (def-x86-opcode clc ()
+     #xf8 nil)
+
+   ;; cld
+   (def-x86-opcode cld ()
+     #xfc nil)
+
+   ;; cltd
+   (def-x86-opcode cltd ()
+     #x99 nil)
+
+   ;; cmc
+   (def-x86-opcode cmc ()
+     #xf5 nil)
+
+   ;; cmovCC
+   (def-x86-opcode cmovccl
+       ((:imm8 :insert-cc) (:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f40 #o300)
+   (def-x86-opcode cmovccl
+       ((:imm8 :insert-cc) (:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f40 #o000)
+   (def-x86-opcode cmovccw
+       ((:imm8 :insert-cc) (:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f40 #o300 #x66)
+   (def-x86-opcode cmovccw
+       ((:imm8 :insert-cc) (:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f40 #o000 #x66)
+
+   (def-x86-opcode cmovol ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f40 #o300)
+   (def-x86-opcode cmovol ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f40 #o000)
+   (def-x86-opcode cmovow ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f40 #o300 #x66)
+   (def-x86-opcode cmovow ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f40 #o000 #x66)
+
+   (def-x86-opcode cmovnol ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f41 #o300)
+   (def-x86-opcode cmovnol ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f41 #o000)
+   (def-x86-opcode cmovnow ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f41 #o300 #x66)
+   (def-x86-opcode cmovnow ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f41 #o000 #x66)
+
+   (def-x86-opcode cmovbl ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f42 #o300)
+   (def-x86-opcode cmovbl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f42 #o000)
+   (def-x86-opcode cmovbw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f42 #o300 #x66)
+   (def-x86-opcode cmovbw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f42 #o000 #x66)
+
+   (def-x86-opcode cmovael ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f43 #o300)
+   (def-x86-opcode cmovael ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f43 #o000)
+   (def-x86-opcode cmovaew ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f43 #o300 #x66)
+   (def-x86-opcode cmovaew ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f43 #o000 #x66)
+
+   (def-x86-opcode cmovel ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f44 #o300)
+   (def-x86-opcode cmovel ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f44 #o000)
+   (def-x86-opcode cmovew ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f44 #o300 #x66)
+   (def-x86-opcode cmovew ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f44 #o000 #x66)
+
+   (def-x86-opcode cmovnel ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f45 #o300)
+   (def-x86-opcode cmovnel ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f45 #o000)
+   (def-x86-opcode cmovnew ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f45 #o300 #x66)
+   (def-x86-opcode cmovnew ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f45 #o000 #x66)
+
+   (def-x86-opcode cmovbel ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-reg))
+     #x0f46 #o300)
+   (def-x86-opcode cmovbel ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f46 #o000)
+   (def-x86-opcode cmovbew ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f46 #o300 #x66)
+   (def-x86-opcode cmovbew ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f46 #o000 #x66)
+
+   (def-x86-opcode cmoval ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f47 #o300)
+   (def-x86-opcode cmoval ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f47 #o000)
+   (def-x86-opcode cmovaw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f47 #o300 #x66)
+   (def-x86-opcode cmovaw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f47 #o000 #x66)
+
+   (def-x86-opcode cmovsl ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f48 #o300)
+   (def-x86-opcode cmovsl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f48 #o000)
+   (def-x86-opcode cmovsw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f48 #o300 #x66)
+   (def-x86-opcode cmovsw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f48 #o000 #x66)
+
+   (def-x86-opcode cmovnsl ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f49 #o300)
+   (def-x86-opcode cmovnsl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f49 #o000)
+   (def-x86-opcode cmovnsw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f49 #o300 #x66)
+   (def-x86-opcode cmovnsw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f49 #o000 #x66)
+
+   (def-x86-opcode cmovpel ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f4a #o300)
+   (def-x86-opcode cmovpel ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f4a #o000)
+   (def-x86-opcode cmovpew ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f4a #o300 #x66)
+   (def-x86-opcode cmovpew ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f4a #o000 #x66)
+
+   (def-x86-opcode cmovpol ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f4b #o300)
+   (def-x86-opcode cmovpol ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f4b #o000)
+   (def-x86-opcode cmovpow ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f4b #o300 #x66)
+   (def-x86-opcode cmovpow ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f4b #o000 #x66)
+
+   (def-x86-opcode cmovll ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f4c #o300)
+   (def-x86-opcode cmovll ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f4c #o000)
+   (def-x86-opcode cmovlw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f4c #o300 #x66)
+   (def-x86-opcode cmovlw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f4c #o000 #x66)
+
+   (def-x86-opcode cmovgel ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f4d #o300)
+   (def-x86-opcode cmovgel ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f4d #o000)
+   (def-x86-opcode cmovgew ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f4d #o300 #x66)
+   (def-x86-opcode cmovgew ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f4d #o000 #x66)
+
+   (def-x86-opcode cmovlel ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f4e #o300)
+   (def-x86-opcode cmovlel ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f4e #o000)
+   (def-x86-opcode cmovlew ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f4e #o300 #x66)
+   (def-x86-opcode cmovlew ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f4e #o000 #x66)
+
+   (def-x86-opcode cmovgl ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0f4f #o300)
+   (def-x86-opcode cmovgl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f4f #o000)
+   (def-x86-opcode cmovgw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0f4f #o300 #x66)
+   (def-x86-opcode cmovgw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0f4f #o000 #x66)
+
+   ;; cmp
+   (def-x86-opcode cmpl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x39 #o300)
+   (def-x86-opcode rcmpl ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x39 #o300)   
+   (def-x86-opcode cmpl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x3b #o000)
+   (def-x86-opcode rcmpl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x3b #o000)   
+   (def-x86-opcode cmpl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x39 #x00)
+   (def-x86-opcode rcmpl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x39 #x00)   
+   (def-x86-opcode cmpl ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm))
+     #x83 #o370)
+   (def-x86-opcode rcmpl ((:reg32 :insert-modrm-rm) (:imm8s :insert-imm8s))
+     #x83 #o370)   
+   (def-x86-opcode cmpl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #x3d nil)
+   (def-x86-opcode rcmpl ((:acc :insert-nothing) (:imm32s :insert-imm32s))
+     #x3d nil)   
+   (def-x86-opcode cmpl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #x81 #o370)
+   (def-x86-opcode rcmpl ((:reg32 :insert-modrm-rm) (:imm32s :insert-imm32s))
+     #x81 #o370)   
+   (def-x86-opcode cmpl ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o070)
+   (def-x86-opcode rcmpl ((:anymem :insert-memory) (:imm8s :insert-imm8s))
+     #x83 #o070)   
+   (def-x86-opcode cmpl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #x81 #o070)
+   (def-x86-opcode rcmpl ((:anymem :insert-memory) (:imm32s :insert-imm32s))
+     #x81 #o070)   
+
+   (def-x86-opcode cmpw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x39 #o300 #x66)
+   (def-x86-opcode rcmpw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x39 #o300 #x66)   
+   (def-x86-opcode cmpw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x3b #o000 #x66)
+   (def-x86-opcode rcmpw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x3b #o000 #x00)   
+   (def-x86-opcode cmpw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x39 #x00 #x00 )
+   (def-x86-opcode rcmpw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x39 #x00 #x00 )   
+   (def-x86-opcode cmpw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm))
+     #x83 #o370 #x00)
+   (def-x86-opcode rcmpw ((:reg16 :insert-modrm-rm) (:imm8s :insert-imm8s))
+     #x83 #o370 #x00)   
+   (def-x86-opcode cmpw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #x3d nil #x66)
+   (def-x86-opcode rcmpw ((:acc :insert-nothing) (:imm16 :insert-imm16))
+     #x3d nil #x66)   
+   (def-x86-opcode cmpw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #x81 #o370 #x66)
+   (def-x86-opcode rcmpw ((:reg16 :insert-modrm-rm) (:imm16 :insert-imm16))
+     #x81 #o370 #x66)   
+   (def-x86-opcode cmpw ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o070 #x66)
+   (def-x86-opcode rcmpw ((:anymem :insert-memory) (:imm8s :insert-imm8s))
+     #x83 #o070 #x66)   
+   (def-x86-opcode cmpw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #x81 #o070 #x66)
+   (def-x86-opcode rcmpw ((:anymem :insert-memory) (:imm16 :insert-imm16))
+     #x81 #o070 #x66)   
+
+   (def-x86-opcode cmpb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x38 #o300)
+   (def-x86-opcode rcmpb ((:reg8 :insert-modrm-rm) (:reg8 :insert-modrm-reg))
+     #x38 #o300)
+   (def-x86-opcode cmpb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x3a #o000)
+   (def-x86-opcode rcmpb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x3a #o000)
+   (def-x86-opcode cmpb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x38 #x00)
+   (def-x86-opcode rcmpb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x38 #x00)   
+   (def-x86-opcode cmpb (((:imm8s :imm8) :insert-imm8s) (:acc :insert-nothing))
+     #x3c nil)
+   (def-x86-opcode rcmpb ((:acc :insert-nothing) ((:imm8s :imm8) :insert-imm8s))
+     #x3c nil)
+   (def-x86-opcode cmpb (((:imm8s :imm8) :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o370)
+   (def-x86-opcode rcmpb ((:reg8 :insert-modrm-rm) ((:imm8s :imm8) :insert-imm8s))
+     #x80 #o370)
+   (def-x86-opcode cmpb (((:imm8s :imm8) :insert-imm8s) (:anymem :insert-memory))
+     #x80 #o070)
+   (def-x86-opcode rcmpb ((:anymem :insert-memory) ((:imm8s :imm8) :insert-imm8s))
+     #x80 #o070)
+
+   ;; cmps
+   (def-x86-opcode cmpsl ()
+     #xa7 nil)
+
+   (def-x86-opcode cmpsw ()
+     #xa7 nil #x66)
+
+   (def-x86-opcode cmpsb ()
+     #xa6 nil)
+
+   ;; cmpxchg
+   (def-x86-opcode cmpxchgl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x0fb1 #o300)
+   (def-x86-opcode cmpxchgl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fb1 #o000)
+
+   (def-x86-opcode cmpxchgw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x0fb1 #o300 #x66)
+   (def-x86-opcode cmpxchgw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fb1 #o000 #x66)
+
+   (def-x86-opcode cmpxchgb ((:reg8 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x0fb0 #o300)
+   (def-x86-opcode cmpxchgb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fb0 #o000)
+
+   ;; cpuid
+   (def-x86-opcode cpuid ()
+     #x0fa2 nil)
+
+   ;; cwtd
+   (def-x86-opcode cwtd ()
+     #x99 nil #x66)
+
+   ;; cwtl
+   (def-x86-opcode cwtl ()
+     #x98 nil)
+
+   ;; dec
+   (def-x86-opcode decl ((:anymem :insert-memory))
+     #xff #o010)
+
+   (def-x86-opcode decw ((:anymem :insert-memory))
+     #xff #o010 #x66)
+
+   (def-x86-opcode decb ((:reg8 :insert-modrm-rm))
+     #xfe #o310)
+   (def-x86-opcode decb ((:anymem :insert-memory))
+     #xfe #o010)
+
+   ;; div
+   (def-x86-opcode divl ((:reg32 :insert-modrm-rm))
+     #xf7 #o360)
+   (def-x86-opcode divl ((:anymem :insert-memory))
+     #xf7 #o060)
+
+   (def-x86-opcode divw ((:reg16 :insert-modrm-rm))
+     #xf7 #o360 #x66)
+   (def-x86-opcode divw ((:anymem :insert-memory))
+     #xf7 #o060 #x66)
+
+   (def-x86-opcode divb ((:reg8 :insert-modrm-rm))
+     #xf6 #o360)
+   (def-x86-opcode divl ((:anymem :insert-memory))
+     #xf6 #o060)
+
+   ;; enter
+   (def-x86-opcode enter ((:imm16 :insert-imm16) (:imm8 :insert-extra))
+     #xc8 nil)
+
+   ;; hlt
+   (def-x86-opcode hlt ()
+     #xf4 nil)
+
+   ;; idiv.  Note that GAS doesn't know about newer(?) idiv forms
+   (def-x86-opcode idivl ((:reg32 :insert-modrm-rm))
+     #xf7 #o370)
+   (def-x86-opcode idivl ((:anymem :insert-memory))
+     #xf7 #o070)
+
+   (def-x86-opcode idivw ((:reg16 :insert-modrm-rm))
+     #xf7 #o370 #x66)
+   (def-x86-opcode idivw ((:anymem :insert-memory))
+     #xf7 #o070 #x66)
+
+   (def-x86-opcode idivb ((:reg8 :insert-modrm-rm))
+     #xf6 #o370)
+   (def-x86-opcode idivl ((:anymem :insert-memory))
+     #xf6 #o070)
+
+   ;; imul
+   (def-x86-opcode imull ((:reg32 :insert-modrm-rm))
+     #xf7 #o350)
+   (def-x86-opcode imull ((:anymem :insert-memory))
+     #xf7 #o050)
+
+   (def-x86-opcode imull ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x6b #o300)
+   (def-x86-opcode imull ((:imm8s :insert-imm8s) (:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x6b #o000)
+   (def-x86-opcode imull ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x69 #o300)
+   (def-x86-opcode imull ((:imm32s :insert-imm32s) (:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x69 #o000)
+   (def-x86-opcode imull ((:reg32 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0faf #o300)
+   (def-x86-opcode imull ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0faf #o000)   
+   
+   (def-x86-opcode imulw ((:reg16 :insert-modrm-rm))
+     #xf7 #o350 #x66)
+   (def-x86-opcode imulw ((:anymem :insert-memory))
+     #xf7 #o050 #x66)
+
+   (def-x86-opcode imulw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x6b #o300 #x66)
+   (def-x86-opcode imulw ((:imm8s :insert-imm8s) (:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x6b #o000 #x66)
+   (def-x86-opcode imulw ((:imm32s :insert-imm32s) (:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x69 #o300 #x66)
+   (def-x86-opcode imulw ((:imm32s :insert-imm32s) (:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x69 #o000 #x66)
+   (def-x86-opcode imulw ((:reg16 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0faf #o300 #x66)
+   (def-x86-opcode imulw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0faf #o000 #x66)   
+
+   (def-x86-opcode imulb ((:reg8 :insert-modrm-rm))
+     #xf6 #o350)
+   (def-x86-opcode imulb ((:anymem :insert-memory))
+     #xf6 #o050)
+
+   ;; inc
+   (def-x86-opcode incl ((:anymem :insert-memory))
+     #xff #o000)
+
+   (def-x86-opcode incw ((:anymem :insert-memory))
+     #xff #o000 #x66)
+
+   (def-x86-opcode incb ((:reg8 :insert-modrm-rm))
+     #xfe #o300)
+   (def-x86-opcode incb ((:anymem :insert-memory))
+     #xfe #o000)
+
+   ;; int.  See also UUOs.
+   (def-x86-opcode int ((:imm8 :insert-imm8-for-int))
+     #xcd nil)
+
+   ;; Jcc.  Generate the short form here; maybe relax later.
+   (def-x86-opcode (jcc :jump) ((:imm8 :insert-cc) (:label :insert-label))
+     #x70 nil)
+   (def-x86-opcode (jcc.pt :jump) ((:imm8 :insert-cc) (:label :insert-label))
+     #x70 nil #x3e)
+   (def-x86-opcode (jcc.pn :jump) ((:imm8 :insert-cc) (:label :insert-label))
+     #x70 nil #x2e)
+
+   (def-x86-opcode (jo :jump) ((:label :insert-label))
+     #x70 nil)
+   (def-x86-opcode (jo.pt :jump) ((:label :insert-label))
+     #x70 nil #x3e)
+   (def-x86-opcode (jo.pn :jump) ((:label :insert-label))
+     #x70 nil #x2e)
+   (def-x86-opcode (jno :jump) ((:label :insert-label))
+     #x71 nil)
+   (def-x86-opcode (jno.pt :jump) ((:label :insert-label))
+     #x71 nil #x3e)
+   (def-x86-opcode (jno.pn :jump) ((:label :insert-label))
+     #x71 nil #x2e)
+   (def-x86-opcode (jb :jump) ((:label :insert-label))
+     #x72 nil)
+   (def-x86-opcode (jb.pt :jump) ((:label :insert-label))
+     #x72 nil #x3e)
+   (def-x86-opcode (jb.pn :jump) ((:label :insert-label))
+     #x72 nil #x2e)
+   (def-x86-opcode (jae :jump) ((:label :insert-label))
+     #x73 nil)
+   (def-x86-opcode (jae.pt :jump) ((:label :insert-label))
+     #x73 nil #x3e)
+   (def-x86-opcode (jae.pn :jump) ((:label :insert-label))
+     #x73 nil #x2e)
+   (def-x86-opcode (je :jump) ((:label :insert-label))
+     #x74 nil)
+   (def-x86-opcode (je.pt :jump) ((:label :insert-label))
+     #x74 nil #x3e)
+   (def-x86-opcode (je.pn :jump) ((:label :insert-label))
+     #x74 nil #x2e)
+   (def-x86-opcode (jz :jump) ((:label :insert-label))
+     #x74 nil)
+   (def-x86-opcode (jz.pt :jump) ((:label :insert-label))
+     #x74 nil #x3e)
+   (def-x86-opcode (jz.pn :jump) ((:label :insert-label))
+     #x74 nil #x2e)
+   (def-x86-opcode (jne :jump) ((:label :insert-label))
+     #x75 nil)
+   (def-x86-opcode (jne.pt :jump) ((:label :insert-label))
+     #x75 nil #x3e)
+   (def-x86-opcode (jne.pn :jump) ((:label :insert-label))
+     #x75 nil #x2e)
+   (def-x86-opcode (jnz :jump) ((:label :insert-label))
+     #x75 nil)
+   (def-x86-opcode (jnz.pt :jump) ((:label :insert-label))
+     #x75 nil #x3e)
+   (def-x86-opcode (jnz.pn :jump) ((:label :insert-label))
+     #x75 nil #x2e)
+   (def-x86-opcode (jbe :jump) ((:label :insert-label))
+     #x76 nil)
+   (def-x86-opcode (jbe.pt :jump) ((:label :insert-label))
+     #x76 nil #x3e)
+   (def-x86-opcode (jbe.pn :jump) ((:label :insert-label))
+     #x76 nil #x2e)
+   (def-x86-opcode (ja :jump) ((:label :insert-label))
+     #x77 nil)
+   (def-x86-opcode (ja.pt :jump) ((:label :insert-label))
+     #x77 nil #x3e)
+   (def-x86-opcode (ja.pn :jump) ((:label :insert-label))
+     #x77 nil #x2e)
+   (def-x86-opcode (js :jump) ((:label :insert-label))
+     #x78 nil)
+   (def-x86-opcode (js.pt :jump) ((:label :insert-label))
+     #x78 nil #x3e)
+   (def-x86-opcode (js.pn :jump) ((:label :insert-label))
+     #x78 nil #x2e)
+   (def-x86-opcode (jns :jump) ((:label :insert-label))
+     #x79 nil)
+   (def-x86-opcode (jns.pt :jump) ((:label :insert-label))
+     #x79 nil #x3e)
+   (def-x86-opcode (jns.pn :jump) ((:label :insert-label))
+     #x79 nil #x2e)
+   (def-x86-opcode (jpe :jump) ((:label :insert-label))
+     #x7a nil)
+   (def-x86-opcode (jpe.pt :jump) ((:label :insert-label))
+     #x7a nil #x3e)
+   (def-x86-opcode (jpe.pn :jump) ((:label :insert-label))
+     #x7a nil #x2e)
+   (def-x86-opcode (jpo :jump) ((:label :insert-label))
+     #x7b nil)
+   (def-x86-opcode (jpo.pt :jump) ((:label :insert-label))
+     #x7b nil #x3e)
+   (def-x86-opcode (jpo.pn :jump) ((:label :insert-label))
+     #x7b nil #x2e)
+   (def-x86-opcode (jl :jump) ((:label :insert-label))
+     #x7c nil)
+   (def-x86-opcode (jl.pt :jump) ((:label :insert-label))
+     #x7c nil #x3e)
+   (def-x86-opcode (jl.pn :jump) ((:label :insert-label))
+     #x7c nil #x2e)
+   (def-x86-opcode (jge :jump) ((:label :insert-label))
+     #x7d nil)
+   (def-x86-opcode (jge.pt :jump) ((:label :insert-label))
+     #x7d nil #x3e)
+   (def-x86-opcode (jge.pn :jump) ((:label :insert-label))
+     #x7d nil #x2e)
+   (def-x86-opcode (jle :jump) ((:label :insert-label))
+     #x7e nil)
+   (def-x86-opcode (jle.pt :jump) ((:label :insert-label))
+     #x7e nil #x3e)
+   (def-x86-opcode (jle.pn :jump) ((:label :insert-label))
+     #x7e nil #x2e)
+   (def-x86-opcode (jg :jump) ((:label :insert-label))
+     #x7f nil)
+   (def-x86-opcode (jg.pt :jump) ((:label :insert-label))
+     #x7f nil #x3e)
+   (def-x86-opcode (jg.pn :jump) ((:label :insert-label))
+     #x7f nil #x2e)
+
+   ;; jmp .  Translating the 8-bit pc-relative version to the 32-bit
+   ;;        pc-relative version happens during relaxation.
+   (def-x86-opcode (jmp :jump) ((:label :insert-label))
+     #xeb nil)
+   (def-x86-opcode jmp ((:reg32 :insert-modrm-rm))
+     #xff #o340)
+   (def-x86-opcode jmp ((:anymem :insert-memory))
+     #xff #o040)
+
+   ;; lea
+   (def-x86-opcode leal ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x8d 0)
+
+   (def-x86-opcode leaw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x8d 0 #x66)
+
+   ;; leave
+   (def-x86-opcode leave ()
+     #xc9 nil)
+
+   ;; lock
+   (def-x86-opcode lock ()
+     #xf0 nil)
+
+   ;; lods
+   (def-x86-opcode lodsl ()
+     #xac nil)
+
+   ;; loop
+   (def-x86-opcode loopl ((:label :insert-label))
+     #xe2 nil)
+   (def-x86-opcode loopzl ((:label :insert-label))
+     #xe1 nil)
+   (def-x86-opcode loopnzl ((:label :insert-label))
+     #xe0 nil)
+
+   ;; mov, including the MMX/XMM variants.
+   (def-x86-opcode movq ((:regmmx :insert-mmx-rm) (:regmmx :insert-mmx-reg))
+     #x0f6f #o300)
+   (def-x86-opcode movq ((:regmmx :insert-mmx-reg) (:anymem :insert-memory))
+     #x0f7f #o0)
+   (def-x86-opcode movq ((:anymem :insert-memory) (:regmmx :insert-mmx-reg))
+     #x0f6f #o0)
+   (def-x86-opcode movq ((:regxmm :insert-xmm-reg) (:regxmm :insert-xmm-rm))
+     #x0f7e #o300 #xf3)
+   (def-x86-opcode movq ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f7e #o000 #xf3)
+   (def-x86-opcode movq ((:regxmm :insert-xmm-reg) (:anymem :insert-memory))
+     #x0fd6 #o000 #x66)
+
+   (def-x86-opcode movl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x89 #o300)
+   (def-x86-opcode movl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x8b #o0)
+   (def-x86-opcode movl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x89 #o0)
+   (def-x86-opcode movl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #xc7 #o300)
+   (def-x86-opcode movl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #xc7 #o000)
+   (def-x86-opcode movl ((:self :insert-self) (:reg32 :insert-modrm-rm))
+     #xc7 #o300)
+
+   (def-x86-opcode movw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x89 #o300 #x66)
+   (def-x86-opcode movw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x8b #o0 #x66)
+   (def-x86-opcode movw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x89 #o0 #x66)
+   (def-x86-opcode movw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #xc7 #o300 #x66)
+   (def-x86-opcode movw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #xc7 #o000 #x66)
+
+   (def-x86-opcode movb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x88 #o300)
+   (def-x86-opcode movb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x8a #o0)
+   (def-x86-opcode movb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x88 #o0)
+   (def-x86-opcode movb ((:imm8s :insert-imm8s) (:reg8 :insert-opcode-reg))
+     #xb0 nil)
+   (def-x86-opcode movb ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #xc6 #o000)
+  
+   ;; movd
+   (def-x86-opcode movd ((:reg32 :insert-modrm-rm) (:regmmx :insert-mmx-reg))
+     #x0f6e #o300)
+   (def-x86-opcode movd ((:anymem :insert-memory) (:regmmx :insert-mmx-reg))
+     #x0f6e #o000)
+   (def-x86-opcode movd ((:regmmx :insert-mmx-reg) (:reg32 :insert-modrm-rm))
+     #x0f7e #o300)
+   (def-x86-opcode movd ((:regmmx :insert-mmx-reg) (:anymem :insert-memory))
+     #x0f7e #o000)
+
+   (def-x86-opcode movd ((:reg32 :insert-modrm-rm) (:regxmm :insert-xmm-reg))
+     #x0f6e #o300 #x66)
+   (def-x86-opcode movd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f6e #o000 #x66)
+   (def-x86-opcode movd ((:regxmm :insert-xmm-reg) (:reg32 :insert-modrm-rm))
+     #x0f7e #o300 #x66)
+   (def-x86-opcode movd ((:regxmm :insert-xmm-reg) (:anymem :insert-memory))
+     #x0f7e #o000 #x66)
+
+   ;; sign-extending mov
+   (def-x86-opcode movsbl ((:reg8 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0fbe #o300)
+   (def-x86-opcode movsbl ((:anymem :insert-memory)  (:reg32 :insert-modrm-reg))
+     #x0fbe #o000)
+   (def-x86-opcode movsbw ((:reg8 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x0fbe #o300 #x66)
+   (def-x86-opcode movsbw ((:anymem :insert-memory) (:reg16 :insert-modrm-rm))
+     #x0fbe #o300 #x66)
+   (def-x86-opcode movswl ((:reg16 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0fbf #o300)
+   (def-x86-opcode movswl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0fbf #o000)
+
+   ;; zero-extending MOVs
+   (def-x86-opcode movzbl ((:reg8 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0fb6 #o300)
+   (def-x86-opcode movzbl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0fb6 #o000)
+   (def-x86-opcode movzbw ((:reg8 :insert-modrm-rm) (:reg16 :insert-modrm-reg))
+     #x0fb6 #o300 #x66)
+   (def-x86-opcode movzbw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0fb6 #o300 #x66)
+   (def-x86-opcode movzwl ((:reg16 :insert-modrm-rm) (:reg32 :insert-modrm-reg))
+     #x0fb7 #o300)
+   (def-x86-opcode movzwl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0fb7 #o000)
+
+   ;; mul
+   (def-x86-opcode mull ((:reg32 :insert-modrm-rm))
+     #xf7 #o340)
+   (def-x86-opcode mull ((:anymem :insert-memory))
+     #xf7 #o040)
+
+   (def-x86-opcode mulw ((:reg16 :insert-modrm-rm))
+     #xf7 #o340 #x66)
+   (def-x86-opcode mulw ((:anymem :insert-memory))
+     #xf7 #o040 #x66)
+
+   (def-x86-opcode mulb ((:reg8 :insert-modrm-rm))
+     #xf6 #o340)
+   (def-x86-opcode mull ((:anymem :insert-memory))
+     #xf6 #o040)
+
+   ;; neg
+   (def-x86-opcode negl ((:reg32 :insert-modrm-rm))
+     #xf7 #o330)
+   (def-x86-opcode negl ((:anymem :insert-memory))
+     #xf7 #o030)
+
+   (def-x86-opcode negw ((:reg16 :insert-modrm-rm))
+     #xf7 #o330 #x66)
+   (def-x86-opcode negw ((:anymem :insert-memory))
+     #xf7 #o030 #x66)
+
+   (def-x86-opcode negb ((:reg8 :insert-modrm-rm))
+     #xf6 #o330)
+   (def-x86-opcode negb ((:anymem :insert-memory))
+     #xf6 #o030)
+
+   ;; nop
+   (def-x86-opcode nop ()
+     #x90 nil)
+
+   ;; not
+   (def-x86-opcode notl ((:reg32 :insert-modrm-rm))
+     #xf7 #o320)
+   (def-x86-opcode notl ((:anymem :insert-memory))
+     #xf7 #o020)
+   (def-x86-opcode notw ((:reg16 :insert-modrm-rm))
+     #xf7 #o320 #x66)
+   (def-x86-opcode notw ((:anymem :insert-memory))
+     #xf7 #o020 #x66)
+   (def-x86-opcode notb ((:reg8 :insert-modrm-rm))
+     #xf6 #o320)
+   (def-x86-opcode notb ((:anymem :insert-memory))
+     #xf6 #o020)
+
+   ;; or
+   (def-x86-opcode orl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x09 #o300)
+   (def-x86-opcode orl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0b #o000)
+   (def-x86-opcode orl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x09 #x00)
+   (def-x86-opcode orl ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm))
+     #x83 #o310)
+   (def-x86-opcode orl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #x0d nil)
+   (def-x86-opcode orl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #x81 #o310)
+   (def-x86-opcode orl ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o010)
+   (def-x86-opcode orl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #x81 #o010)
+
+   (def-x86-opcode orw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x09 #o300 #x66)
+   (def-x86-opcode orw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x0b #o000 #x66)
+   (def-x86-opcode orw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x09 #x00 #x66)
+   (def-x86-opcode orw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm))
+     #x83 #o310 #x66)
+   (def-x86-opcode orw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #x0d nil #x66)
+   (def-x86-opcode orw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #x81 #o310 #x66)
+   (def-x86-opcode orw ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o010 #x66)
+   (def-x86-opcode orw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #x81 #o010 #x66)
+
+   (def-x86-opcode orb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x08 #o300)
+   (def-x86-opcode orb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x0a #o000)
+   (def-x86-opcode orb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x08 #x000)
+   (def-x86-opcode orb ((:imm8s :insert-imm8s) (:acc :insert-nothing))
+     #x0c nil)
+   (def-x86-opcode orb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o310)
+   (def-x86-opcode orb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o310)
+   (def-x86-opcode orb ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x80 #o010)
+
+   ;; pop
+   (def-x86-opcode popl ((:reg32 :insert-opcode-reg))
+     #x58 nil)
+   (def-x86-opcode popl ((:anymem :insert-memory))
+     #x8f #o000)
+   (def-x86-opcode popw ((:reg16 :insert-opcode-reg))
+     #x58 nil #x66)
+   (def-x86-opcode popw ((:anymem :insert-memory))
+     #x8f #o000 #x66)
+
+   ;; popf
+   (def-x86-opcode popfl ()
+     #x9d nil)
+
+   ;; push .  It's not clear how "pushw $imm16" is encoded.
+   (def-x86-opcode pushl ((:reg64 :insert-opcode-reg))
+     #x50 nil)
+   (def-x86-opcode pushl ((:anymem :insert-memory))
+     #xff #o060)
+   (def-x86-opcode pushl ((:imm8s :insert-imm8s))
+     #x6a nil)
+   (def-x86-opcode pushl ((:imm32s :insert-imm32s))
+     #x68 nil)
+
+   (def-x86-opcode pushw ((:reg16 :insert-opcode-reg))
+     #x50 nil #x66)
+   (def-x86-opcode pushw ((:anymem :insert-memory))
+     #xff #o060 #x66)
+
+   ;; pushf
+   (def-x86-opcode pushfl ()
+     #x9c nil)
+   (def-x86-opcode pushfw ()
+     #x9c nil #x66)
+
+   ;; rcl.  Note that the :ShiftCount operand type only matches %cl.
+   (def-x86-opcode rcll ((:imm1 :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd1 #o320)
+   (def-x86-opcode rcll ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o020)
+   (def-x86-opcode rcll ((:reg32 :insert-modrm-rm))
+     #xd1 #o320)
+   (def-x86-opcode rcll ((:anymem :insert-memory))
+     #xd1 #o020)
+   (def-x86-opcode rcll ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #xc1 #o320)
+   (def-x86-opcode rcll ((:shiftcount :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd3 #o320)
+
+   (def-x86-opcode rclw ((:imm1 :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd1 #o320 #x66)
+   (def-x86-opcode rclw ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o020 #x66)
+   (def-x86-opcode rclw ((:reg16 :insert-modrm-rm))
+     #xd1 #o320 #x66)
+   (def-x86-opcode rclw ((:anymem :insert-memory))
+     #xd1 #o020 #x66)
+   (def-x86-opcode rclw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #xc1 #o320 #x66)
+   (def-x86-opcode rclw ((:shiftcount :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd3 #o320 #x66)
+
+   (def-x86-opcode rclb ((:imm1 :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd0 #o320)
+   (def-x86-opcode rclb ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd0 #o020)
+   (def-x86-opcode rclb ((:reg8 :insert-modrm-rm))
+     #xd0 #o320)
+   (def-x86-opcode rclb ((:anymem :insert-memory))
+     #xd0 #o020)
+   (def-x86-opcode rclb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #xc0 #o320)
+   (def-x86-opcode rclb ((:shiftcount :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd2 #o320)
+
+   ;; rcr
+   (def-x86-opcode rcrl ((:imm1 :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd1 #o330)
+   (def-x86-opcode rcrl ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o030)
+   (def-x86-opcode rcrl ((:reg32 :insert-modrm-rm))
+     #xd1 #o330)
+   (def-x86-opcode rcrl ((:anymem :insert-memory))
+     #xd1 #o030)
+   (def-x86-opcode rcrl ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #xc1 #o330)
+   (def-x86-opcode rcrl ((:shiftcount :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd3 #o330)
+
+   (def-x86-opcode rcrw ((:imm1 :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd1 #o330 #x66)
+   (def-x86-opcode rcrw ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o030 #x66)
+   (def-x86-opcode rcrw ((:reg16 :insert-modrm-rm))
+     #xd1 #o330 #x66)
+   (def-x86-opcode rcrw ((:anymem :insert-memory))
+     #xd1 #o030 #x66)
+   (def-x86-opcode rcrw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #xc1 #o330 #x66)
+   (def-x86-opcode rcrw ((:shiftcount :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd3 #o330 #x66)
+
+   (def-x86-opcode rcrb ((:imm1 :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd0 #o330)
+   (def-x86-opcode rcrb ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd0 #o030)
+   (def-x86-opcode rcrb ((:reg8 :insert-modrm-rm))
+     #xd0 #o330)
+   (def-x86-opcode rcrb ((:anymem :insert-memory))
+     #xd0 #o030)
+   (def-x86-opcode rcrb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #xc0 #o330)
+   (def-x86-opcode rcrb ((:shiftcount :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd2 #o330)
+
+   ;; repe, repne.  These are really prefixes, that should
+   ;; only be used before string instructions.
+   (def-x86-opcode repe ()
+     #xf3 nil)
+   (def-x86-opcode repne ()
+     #xf2 nil)
+
+   ;; ret
+   (def-x86-opcode ret ()
+     #xc3 nil)
+   (def-x86-opcode ret ((:imm16 :insert-imm16))
+     #xc2 nil)
+
+   ;; rol
+   (def-x86-opcode roll ((:imm1 :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd1 #o300)
+   (def-x86-opcode roll ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o000)
+   (def-x86-opcode roll ((:reg32 :insert-modrm-rm))
+     #xd1 #o300)
+   (def-x86-opcode roll ((:anymem :insert-memory))
+     #xd1 #o000)
+   (def-x86-opcode roll ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #xc1 #o300)
+   (def-x86-opcode roll ((:shiftcount :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd3 #o300)
+
+   (def-x86-opcode rolw ((:imm1 :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd1 #o300 #x66)
+   (def-x86-opcode rolw ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o000 #x66)
+   (def-x86-opcode rolw ((:reg16 :insert-modrm-rm))
+     #xd1 #o300 #x66)
+   (def-x86-opcode rolw ((:anymem :insert-memory))
+     #xd1 #o000 #x66)
+   (def-x86-opcode rolw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #xc1 #o300 #x66)
+   (def-x86-opcode rolw ((:shiftcount :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd3 #o300 #x66)
+
+   (def-x86-opcode rolb ((:imm1 :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd0 #o300)
+   (def-x86-opcode rolb ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd0 #o000)
+   (def-x86-opcode rolb ((:reg8 :insert-modrm-rm))
+     #xd0 #o300)
+   (def-x86-opcode rolb ((:anymem :insert-memory))
+     #xd0 #o000)
+   (def-x86-opcode rolb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #xc0 #o300)
+   (def-x86-opcode rolb ((:shiftcount :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd2 #o300)
+
+   ;; ror
+   (def-x86-opcode rorl ((:imm1 :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd1 #o310)
+   (def-x86-opcode rorl ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o010)
+   (def-x86-opcode rorl ((:reg32 :insert-modrm-rm))
+     #xd1 #o310)
+   (def-x86-opcode rorl ((:anymem :insert-memory))
+     #xd1 #o010)
+   (def-x86-opcode rorl ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #xc1 #o310)
+   (def-x86-opcode rorl ((:shiftcount :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd3 #o310)
+
+   (def-x86-opcode rorw ((:imm1 :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd1 #o310 #x66)
+   (def-x86-opcode rorw ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o010 #x66)
+   (def-x86-opcode rorw ((:reg16 :insert-modrm-rm))
+     #xd1 #o310 #x66)
+   (def-x86-opcode rorw ((:anymem :insert-memory))
+     #xd1 #o010 #x66)
+   (def-x86-opcode rorw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #xc1 #o310 #x66)
+   (def-x86-opcode rorw ((:shiftcount :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd3 #o310 #x66)
+
+   (def-x86-opcode rorb ((:imm1 :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd0 #o310)
+   (def-x86-opcode rorb ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd0 #o010)
+   (def-x86-opcode rorb ((:reg8 :insert-modrm-rm))
+     #xd0 #o310)
+   (def-x86-opcode rorb ((:anymem :insert-memory))
+     #xd0 #o010)
+   (def-x86-opcode rorb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #xc0 #o310)
+   (def-x86-opcode rorb ((:shiftcount :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd2 #o310)
+
+   ;; sar
+   (def-x86-opcode sarl ((:imm1 :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd1 #o370)
+   (def-x86-opcode sarl ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o070)
+   (def-x86-opcode sarl ((:reg32 :insert-modrm-rm))
+     #xd1 #o370)
+   (def-x86-opcode sarl ((:anymem :insert-memory))
+     #xd1 #o070)
+   (def-x86-opcode sarl ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #xc1 #o370)
+   (def-x86-opcode sarl ((:shiftcount :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd3 #o370)
+
+   (def-x86-opcode sarw ((:imm1 :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd1 #o370 #x66)
+   (def-x86-opcode sarw ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o070 #x66)
+   (def-x86-opcode sarw ((:reg16 :insert-modrm-rm))
+     #xd1 #o370 #x66)
+   (def-x86-opcode sarw ((:anymem :insert-memory))
+     #xd1 #o070 #x66)
+   (def-x86-opcode sarw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #xc1 #o370 #x66)
+   (def-x86-opcode sarw ((:shiftcount :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd3 #o370 #x66)
+
+   (def-x86-opcode sarb ((:imm1 :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd0 #o370)
+   (def-x86-opcode sarb ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd0 #o070)
+   (def-x86-opcode sarb ((:reg8 :insert-modrm-rm))
+     #xd0 #o370)
+   (def-x86-opcode sarb ((:anymem :insert-memory))
+     #xd0 #o070)
+   (def-x86-opcode sarb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #xc0 #o370)
+   (def-x86-opcode sarb ((:shiftcount :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd2 #o370)
+
+   ;; sbb
+   (def-x86-opcode sbbl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x19 #o300)
+   (def-x86-opcode sbbl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x1b #o000)
+   (def-x86-opcode sbbl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x19 #x00)
+   (def-x86-opcode sbbl ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm))
+     #x83 #o330)
+   (def-x86-opcode sbbl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #x1d nil)
+   (def-x86-opcode sbbl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #x81 #o330)
+   (def-x86-opcode sbbl ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o030)
+   (def-x86-opcode sbbl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #x81 #o030)
+
+   (def-x86-opcode sbbw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x19 #o300 #x66)
+   (def-x86-opcode sbbw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x1b #o000 #x66)
+   (def-x86-opcode sbbw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x19 #x00 #x66)
+   (def-x86-opcode sbbw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm))
+     #x83 #o330 #x66)
+   (def-x86-opcode sbbw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #x1d nil #x66)
+   (def-x86-opcode sbbw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #x81 #o330 #x66)
+   (def-x86-opcode sbbw ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o030 #x66)
+   (def-x86-opcode sbbw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #x81 #o030 #x66)
+
+   (def-x86-opcode sbbb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x18 #o300)
+   (def-x86-opcode sbbb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x1a #o000)
+   (def-x86-opcode sbbb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x18 #x00)
+   (def-x86-opcode sbbb ((:imm8 :insert-imm8) (:acc :insert-nothing))
+     #x1c nil)
+   (def-x86-opcode sbbb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o330)
+   (def-x86-opcode sbbb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o330)
+   (def-x86-opcode sbbb ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x80 #o030)
+
+   ;; scas
+   (def-x86-opcode scasl ()
+     #xaf nil)
+   (def-x86-opcode scasw ()
+     #xaf nil #x66)
+   (def-x86-opcode scasb ()
+     #xae nil)
+
+   ;; setcc
+   (def-x86-opcode setcc ((:imm8 :insert-cc) (:reg8 :insert-modrm-rm))
+     #x0f90 #o300)     
+   (def-x86-opcode seto ((:reg8 :insert-modrm-rm))
+     #x0f90 #o300)
+   (def-x86-opcode seto ((:anymem :insert-memory))
+     #x0f90 #o000)
+   (def-x86-opcode setno ((:reg8 :insert-modrm-rm))
+     #x0f91 #o300)
+   (def-x86-opcode setno ((:anymem :insert-memory))
+     #x0f91 #o000)
+   (def-x86-opcode setb ((:reg8 :insert-modrm-rm))
+     #x0f92 #o300)
+   (def-x86-opcode setb ((:anymem :insert-memory))
+     #x0f92 #o000)
+   (def-x86-opcode setc ((:reg8 :insert-modrm-rm))
+     #x0f92 #o300)
+   (def-x86-opcode setc ((:anymem :insert-memory))
+     #x0f92 #o000)
+   (def-x86-opcode setae ((:reg8 :insert-modrm-rm))
+     #x0f93 #o300)
+   (def-x86-opcode setae ((:anymem :insert-memory))
+     #x0f93 #o000)
+   (def-x86-opcode sete ((:reg8 :insert-modrm-rm))
+     #x0f94 #o300)
+   (def-x86-opcode sete ((:anymem :insert-memory))
+     #x0f94 #o000)
+   (def-x86-opcode setne ((:reg8 :insert-modrm-rm))
+     #x0f95 #o300)
+   (def-x86-opcode setne ((:anymem :insert-memory))
+     #x0f95 #o000)
+   (def-x86-opcode setbe ((:reg8 :insert-modrm-rm))
+     #x0f96 #o300)
+   (def-x86-opcode setbe ((:anymem :insert-memory))
+     #x0f96 #o000)
+   (def-x86-opcode seta ((:reg8 :insert-modrm-rm))
+     #x0f97 #o300)
+   (def-x86-opcode seta ((:anymem :insert-memory))
+     #x0f97 #o000)
+   (def-x86-opcode sets ((:reg8 :insert-modrm-rm))
+     #x0f98 #o300)
+   (def-x86-opcode sets ((:anymem :insert-memory))
+     #x0f98 #o000)
+   (def-x86-opcode setns ((:reg8 :insert-modrm-rm))
+     #x0f99 #o300)
+   (def-x86-opcode setns ((:anymem :insert-memory))
+     #x0f99 #o000)
+   (def-x86-opcode setpe ((:reg8 :insert-modrm-rm))
+     #x0f9a #o300)
+   (def-x86-opcode setpe ((:anymem :insert-memory))
+     #x0f9a #o000)
+   (def-x86-opcode setpo ((:reg8 :insert-modrm-rm))
+     #x0f9b #o300)
+   (def-x86-opcode setpo ((:anymem :insert-memory))
+     #x0f9b #o000)
+   (def-x86-opcode setl ((:reg8 :insert-modrm-rm))
+     #x0f9c #o300)
+   (def-x86-opcode setl ((:anymem :insert-memory))
+     #x0f9c #o000)
+   (def-x86-opcode setge ((:reg8 :insert-modrm-rm))
+     #x0f9d #o300)
+   (def-x86-opcode setge ((:anymem :insert-memory))
+     #x0f9d #o000)
+   (def-x86-opcode setle ((:reg8 :insert-modrm-rm))
+     #x0f9e #o300)
+   (def-x86-opcode setle ((:anymem :insert-memory))
+     #x0f9e #o000)
+   (def-x86-opcode setg ((:reg8 :insert-modrm-rm))
+     #x0f9f #o300)
+   (def-x86-opcode setg ((:anymem :insert-memory))
+     #x0f9f #o000)
+
+   ;; shl
+   (def-x86-opcode shll ((:imm1 :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd1 #o340)
+   (def-x86-opcode shll ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o040)
+   (def-x86-opcode shll ((:reg32 :insert-modrm-rm))
+     #xd1 #o340)
+   (def-x86-opcode shll ((:anymem :insert-memory))
+     #xd1 #o040)
+   (def-x86-opcode shll ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #xc1 #o340)
+   (def-x86-opcode shll ((:shiftcount :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd3 #o340)
+
+   (def-x86-opcode shlw ((:imm1 :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd1 #o340 #x66)
+   (def-x86-opcode shlw ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o040 #x66)
+   (def-x86-opcode shlw ((:reg16 :insert-modrm-rm))
+     #xd1 #o340 #x66)
+   (def-x86-opcode shlw ((:anymem :insert-memory))
+     #xd1 #o040 #x66)
+   (def-x86-opcode shlw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #xc1 #o340 #x66)
+   (def-x86-opcode shlw ((:shiftcount :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd3 #o340 #x66)
+
+   (def-x86-opcode shlb ((:imm1 :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd0 #o340)
+   (def-x86-opcode shlb ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd0 #o040)
+   (def-x86-opcode shlb ((:reg8 :insert-modrm-rm))
+     #xd0 #o340)
+   (def-x86-opcode shlb ((:anymem :insert-memory))
+     #xd0 #o040)
+   (def-x86-opcode shlb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #xc0 #o340)
+   (def-x86-opcode shlb ((:shiftcount :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd2 #o340)
+
+   ;; shld
+   (def-x86-opcode shldl ((:imm8 :insert-imm8) (:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fa4 #o300)
+   (def-x86-opcode shldl ((:imm8 :insert-imm8) (:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fa4 #o000)
+   (def-x86-opcode shldl ((:shiftcount :insert-nothing) (:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fa5 #o300)
+   (def-x86-opcode shldl ((:shiftcount :insert-nothing) (:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fa5 #o000)
+   (def-x86-opcode shldl ((:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fa5 #o300)
+   (def-x86-opcode shldl ((:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fa5 #o000)
+
+   (def-x86-opcode shldw ((:imm8 :insert-imm8) (:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fa4 #o300 #x66)
+   (def-x86-opcode shldw ((:imm8 :insert-imm8) (:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fa4 #o000 #x66)
+   (def-x86-opcode shldw ((:shiftcount :insert-nothing) (:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fa5 #o300 #x66)
+   (def-x86-opcode shldw ((:shiftcount :insert-nothing) (:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fa5 #o000 #x66)
+   (def-x86-opcode shldw ((:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fa5 #o300 #x66)
+   (def-x86-opcode shldw ((:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fa5 #o000 #x66)
+
+   ;; shr
+   (def-x86-opcode shrl ((:imm1 :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd1 #o350)
+   (def-x86-opcode shrl ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o050)
+   (def-x86-opcode shrl ((:reg32 :insert-modrm-rm))
+     #xd1 #o350)
+   (def-x86-opcode shrl ((:anymem :insert-memory))
+     #xd1 #o050)
+   (def-x86-opcode shrl ((:imm8 :insert-imm8) (:reg32 :insert-modrm-rm))
+     #xc1 #o350)
+   (def-x86-opcode shrl ((:shiftcount :insert-nothing) (:reg32 :insert-modrm-rm))
+     #xd3 #o350)
+
+   (def-x86-opcode shrw ((:imm1 :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd1 #o350 #x66)
+   (def-x86-opcode shrw ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd1 #o050 #x66)
+   (def-x86-opcode shrw ((:reg16 :insert-modrm-rm))
+     #xd1 #o350 #x66)
+   (def-x86-opcode shrw ((:anymem :insert-memory))
+     #xd1 #o050 #x66)
+   (def-x86-opcode shrw ((:imm8 :insert-imm8) (:reg16 :insert-modrm-rm))
+     #xc1 #o350 #x66)
+   (def-x86-opcode shrw ((:shiftcount :insert-nothing) (:reg16 :insert-modrm-rm))
+     #xd3 #o350 #x66)
+
+   (def-x86-opcode shrb ((:imm1 :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd0 #o350)
+   (def-x86-opcode shrb ((:imm1 :insert-nothing) (:anymem :insert-memory))
+     #xd0 #o050)
+   (def-x86-opcode shrb ((:reg8 :insert-modrm-rm))
+     #xd0 #o350)
+   (def-x86-opcode shrb ((:anymem :insert-memory))
+     #xd0 #o050)
+   (def-x86-opcode shrb ((:imm8 :insert-imm8) (:reg8 :insert-modrm-rm))
+     #xc0 #o350)
+   (def-x86-opcode shrb ((:shiftcount :insert-nothing) (:reg8 :insert-modrm-rm))
+     #xd2 #o350)
+
+   ;; shrd
+   (def-x86-opcode shrdl ((:imm8 :insert-imm8) (:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fac #o300)
+   (def-x86-opcode shrdl ((:imm8 :insert-imm8) (:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fac #o000)
+   (def-x86-opcode shrdl ((:shiftcount :insert-nothing) (:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fad #o300)
+   (def-x86-opcode shrdl ((:shiftcount :insert-nothing) (:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fad #o000)
+   (def-x86-opcode shrdl ((:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fad #o300)
+   (def-x86-opcode shrdl ((:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fad #o000)
+
+   (def-x86-opcode shrdw ((:imm8 :insert-imm8) (:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fac #o300 #x66)
+   (def-x86-opcode shrdw ((:imm8 :insert-imm8) (:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fac #o000 #x66)
+   (def-x86-opcode shrdw ((:shiftcount :insert-nothing) (:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fad #o300 #x66)
+   (def-x86-opcode shrdw ((:shiftcount :insert-nothing) (:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fad #o000 #x66)
+   (def-x86-opcode shrdw ((:reg64 :insert-modrm-reg) (:reg64 :insert-modrm-rm))
+     #x0fad #o300 #x66)
+   (def-x86-opcode shrdw ((:reg64 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fad #o000 #x66)
+
+   ;; stc
+   (def-x86-opcode stc ()
+     #xf9 nil)
+
+   ;; std
+   (def-x86-opcode std ()
+     #xfd nil)
+
+   ;; sub
+   (def-x86-opcode subl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x29 #o300)
+   (def-x86-opcode subl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x2b #o000)
+   (def-x86-opcode subl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x29 #x00)
+   (def-x86-opcode subl ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm))
+     #x83 #o350)
+   (def-x86-opcode subl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #x2d nil)
+   (def-x86-opcode subl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #x81 #o350)
+   (def-x86-opcode subl ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o050)
+   (def-x86-opcode subl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #x81 #o050)
+
+   (def-x86-opcode subw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x29 #o300 #x66)
+   (def-x86-opcode subw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x2b #o000 #x66)
+   (def-x86-opcode subw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x29 #x00 #x66)
+   (def-x86-opcode subw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm))
+     #x83 #o350 #x66)
+   (def-x86-opcode subw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #x2d nil #x66)
+   (def-x86-opcode subw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #x81 #o350 #x66)
+   (def-x86-opcode subw ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o050 #x66)
+   (def-x86-opcode subw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #x81 #o050 #x66)
+
+   (def-x86-opcode subb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x28 #o300)
+   (def-x86-opcode subb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x2a #o000)
+   (def-x86-opcode subb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x2a #x00)
+   (def-x86-opcode subb ((:imm8s :insert-imm8s) (:acc :insert-nothing))
+     #x2c nil)
+   (def-x86-opcode subb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o350)
+   (def-x86-opcode subb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o350)
+   (def-x86-opcode subb ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x80 #o050)
+
+   ;; test
+   (def-x86-opcode testl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x85 #o300)
+   (def-x86-opcode testl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x85 #o000)
+   (def-x86-opcode testl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x87 #o000)
+   (def-x86-opcode testl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #xa9 nil)
+   (def-x86-opcode testl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #xf7 #o300)
+   (def-x86-opcode testl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #xf7 #o000)
+
+   (def-x86-opcode testw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x85 #o300 #x66)
+   (def-x86-opcode testw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x85 #o000 #x66)
+   (def-x86-opcode testw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x87 #o000 #x66)
+   (def-x86-opcode testw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #xa9 nil #x66)
+   (def-x86-opcode testw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #xf7 #o300 #x66)
+   (def-x86-opcode testw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #xf7 #o000 #x66)
+
+   (def-x86-opcode testb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x84 #o300)
+   (def-x86-opcode testb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x84 #o000)
+   (def-x86-opcode testb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x86 #o000)
+   (def-x86-opcode testb ((:imm8s :insert-imm8s) (:acc :insert-nothing))
+     #xa8 nil)
+   (def-x86-opcode testb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #xf6 #o300)
+   (def-x86-opcode testb ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #xf6 #o000)
+
+   ;; ud2a (not to be confused with all of the other undefined/accidental
+   ;; instructions) is "officially undefined".
+   (def-x86-opcode ud2a ()
+     #x0f0b nil)
+
+   (def-x86-opcode ud2b ()
+     #x0fb9 nil)
+
+   ;; xadd
+   (def-x86-opcode xaddl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x0fc1 #o300)
+   (def-x86-opcode xaddl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fc1 #o000)
+
+   (def-x86-opcode xaddw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x0fc1 #o300 #x66)
+   (def-x86-opcode xaddw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fc1 #o000 #x66)
+
+   (def-x86-opcode xaddb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x0fc0 #o300)
+   (def-x86-opcode xaddb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x0fc0 #o000)
+
+   ;; xchg
+   ;; Allegedly, using the opcode #x9x to implement "(xchg (% eax) (% eax))"
+   ;; doesn't zero-extend eax to rax on x86-64.  (So don't special-case
+   ;; :acc as source or destination, and use #x86 and a modrm byte in all cases.)
+   (def-x86-opcode xchgl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x87 #o300)
+   (def-x86-opcode xchgl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x87 #o000)
+   (def-x86-opcode xchgl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x89 #o000)
+
+   (def-x86-opcode xchgw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x87 #o300 #x66)
+   (def-x86-opcode xchgw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x87 #o000 #x66)
+   (def-x86-opcode xchgw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x89 #o000 #x66)
+
+   (def-x86-opcode xchgl ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x86 #o300)
+   (def-x86-opcode xchgl ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x86 #o000)
+   (def-x86-opcode xchgl ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x88 #o000)
+
+   ;; xlat
+   (def-x86-opcode xlatb ()
+     #xd7 nil)
+
+   ;; xor
+   (def-x86-opcode xorl ((:reg32 :insert-modrm-reg) (:reg32 :insert-modrm-rm))
+     #x31 #o300)
+   (def-x86-opcode xorl ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x33 #o000)
+   (def-x86-opcode xorl ((:reg32 :insert-modrm-reg) (:anymem :insert-memory))
+     #x31 #x00)
+   (def-x86-opcode xorl ((:imm8s :insert-imm8s) (:reg32 :insert-modrm-rm))
+     #x83 #o360)
+   (def-x86-opcode xorl ((:imm32s :insert-imm32s) (:acc :insert-nothing))
+     #x35 nil)
+   (def-x86-opcode xorl ((:imm32s :insert-imm32s) (:reg32 :insert-modrm-rm))
+     #x81 #o360)
+   (def-x86-opcode xorl ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o060)
+   (def-x86-opcode xorl ((:imm32s :insert-imm32s) (:anymem :insert-memory))
+     #x81 #o060)
+
+   (def-x86-opcode xorw ((:reg16 :insert-modrm-reg) (:reg16 :insert-modrm-rm))
+     #x31 #o300 #x66)
+   (def-x86-opcode xorw ((:anymem :insert-memory) (:reg16 :insert-modrm-reg))
+     #x33 #o000 #x66)
+   (def-x86-opcode xorw ((:reg16 :insert-modrm-reg) (:anymem :insert-memory))
+     #x31 #x00 #x66)
+   (def-x86-opcode xorw ((:imm8s :insert-imm8s) (:reg16 :insert-modrm-rm))
+     #x83 #o360 #x66)
+   (def-x86-opcode xorw ((:imm16 :insert-imm16) (:acc :insert-nothing))
+     #x35 nil #x66)
+   (def-x86-opcode xorw ((:imm16 :insert-imm16) (:reg16 :insert-modrm-rm))
+     #x81 #o360 #x66)
+   (def-x86-opcode xorw ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x83 #o060 #x66)
+   (def-x86-opcode xorw ((:imm16 :insert-imm16) (:anymem :insert-memory))
+     #x81 #o060 #x66)
+
+   (def-x86-opcode xorb ((:reg8 :insert-modrm-reg) (:reg8 :insert-modrm-rm))
+     #x30 #o300)
+   (def-x86-opcode xorb ((:anymem :insert-memory) (:reg8 :insert-modrm-reg))
+     #x32 #o000)
+   (def-x86-opcode xorb ((:reg8 :insert-modrm-reg) (:anymem :insert-memory))
+     #x30 #x00)
+   (def-x86-opcode xorb ((:imm8s :insert-imm8s) (:acc :insert-nothing))
+     #x34 nil)
+   (def-x86-opcode xorb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o360)
+   (def-x86-opcode xorb ((:imm8s :insert-imm8s) (:reg8 :insert-modrm-rm))
+     #x80 #o360)
+   (def-x86-opcode xorb ((:imm8s :insert-imm8s) (:anymem :insert-memory))
+     #x80 #o060)
+
+   ;; fxsave
+   (def-x86-opcode fxsaveq ((:anymem :insert-memory))
+     #x0fae #o000)
+
+   ;; fxrstor
+   (def-x86-opcode fxrstor ((:anymem :insert-memory))
+     #x0fae #o010)
+
+   ;; clflush
+   (def-x86-opcode clflush ((:anymem :insert-memory))
+     #x0fae #o070)
+
+   ;; lfence
+   (def-x86-opcode lfence ()
+     #x0fae #xe8)
+
+   ;; mfence
+   (def-x86-opcode mfence ()
+     #x0fae #xf0)
+   
+   ;; pause
+   (def-x86-opcode pause ()
+     #xf390 nil)
+
+   ;; I don't want to have to define all mmx/sse/sse2 instructions at the
+   ;; moment, but it wouldn't hurt to define those that the lisp is
+   ;; likely to use.
+
+   ;; Useful mmx/sse2 instructions, other than movd/movq:
+
+   ;; emms
+   (def-x86-opcode emms ()
+     #x0f77 nil)
+
+   ;; addsd
+   (def-x86-opcode addsd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f58 #o000 #xf2)
+   (def-x86-opcode addsd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f58 #o300 #xf2)
+   
+   ;; addss
+   (def-x86-opcode addss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f58 #o000 #xf3)
+   (def-x86-opcode addss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f58 #o300 #xf3)
+
+   ;; subsd
+   (def-x86-opcode subsd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f5c #o000 #xf2)
+   (def-x86-opcode subsd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f5c #o300 #xf2)
+
+   ;; subss
+   (def-x86-opcode subss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f5c #o000 #xf3)
+   (def-x86-opcode subss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f5c #o300 #xf3)
+
+   ;; movapd
+   (def-x86-opcode movapd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f28 #o300 #x66)
+   (def-x86-opcode movapd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f28 #o000 #x66)
+   (def-x86-opcode movapd ((:regxmm :insert-xmm-reg) (:anymem :insert-memory))
+     #x0f29 #o000 #x66)
+   
+   ;; mulsd
+   (def-x86-opcode mulsd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f59 #o000 #xf2)
+   (def-x86-opcode mulsd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f59 #o300 #xf2)
+
+   ;; mulss
+   (def-x86-opcode mulss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f59 #o000 #xf3)
+   (def-x86-opcode mulss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f59 #o300 #xf3)
+
+   ;; divsd
+   (def-x86-opcode divsd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f5e #o000 #xf2)
+   (def-x86-opcode divsd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f5e #o300 #xf2)
+
+   ;; divss
+   (def-x86-opcode divss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f5e #o000 #xf3)
+   (def-x86-opcode divss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f5e #o300 #xf3)
+
+
+   ;; sqrtsd
+   (def-x86-opcode sqrtsd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f51 #o000 #xf2)
+   (def-x86-opcode sqrtsd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f51 #o300 #xf2)
+
+   ;; sqrtss
+   (def-x86-opcode sqrtss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f51 #o000 #xf3)
+   (def-x86-opcode sqrtss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f51 #o300 #xf3)
+   
+   ;; comisd
+   (def-x86-opcode comisd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f2f #o000 #x66)
+   (def-x86-opcode comisd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f2f #o300 #x66)
+
+   ;; ucomisd
+   (def-x86-opcode ucomisd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f2e #o000 #x66)
+   (def-x86-opcode ucomisd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f2e #o300 #x66)
+
+   ;; comiss
+   (def-x86-opcode comiss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f2f #o000)
+   (def-x86-opcode comiss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f2f #o300)
+
+   ;; ucomiss
+   (def-x86-opcode ucomiss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f2e #o000)
+   (def-x86-opcode ucomiss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f2e #o300)
+
+   ;; movsd
+   (def-x86-opcode movsd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f10 #o300 #xf2)
+   (def-x86-opcode movsd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f10 #o300 #xf2)
+   (def-x86-opcode movsd ((:regxmm :insert-xmm-reg) (:anymem :insert-memory))
+     #x0f11 #o000 #xf2)
+
+   ;; movss
+   (def-x86-opcode movss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f10 #o300 #xf3)
+   (def-x86-opcode movss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f10 #o300 #xf3)
+   (def-x86-opcode movss ((:regxmm :insert-xmm-reg) (:anymem :insert-memory))
+     #x0f11 #o000 #xf3)
+
+   ;;; cvtsd2si.  This does rounding (as opposed to truncation).
+   (def-x86-opcode cvtsd2sil ((:regxmm :insert-xmm-rm) (:reg32 :insert-modrm-reg))
+     #x0f2d #o300 #xf2)
+   (def-x86-opcode cvtsd2sil ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f2d #o000 #xf2)
+
+   ;;; cvtss2si.  This does rounding (as opposed to truncation).
+   (def-x86-opcode cvtss2sil ((:regxmm :insert-xmm-rm) (:reg32 :insert-modrm-reg))
+     #x0f2d #o300 #xf3)
+   (def-x86-opcode cvtss2sil ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f2d #o000 #xf3)
+   
+   ;;; cvttsd2si.  This does truncation (as opposed to rounding).
+   (def-x86-opcode cvttsd2sil ((:regxmm :insert-xmm-rm) (:reg32 :insert-modrm-reg))
+     #x0f2c #o300 #xf2)
+   (def-x86-opcode cvtsd2sil ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f2c #o000 #xf2)
+
+   ;;; cvtss2si.  This does rounding (as opposed to truncation).
+   (def-x86-opcode cvttss2sil ((:regxmm :insert-xmm-rm) (:reg32 :insert-modrm-reg))
+     #x0f2d #o300 #xf3)
+   (def-x86-opcode cvttss2sil ((:anymem :insert-memory) (:reg32 :insert-modrm-reg))
+     #x0f2c #o000 #xf3)
+
+   ;; cvtsi2sd
+   (def-x86-opcode cvtsi2sdl ((:reg32 :insert-modrm-rm) (:regxmm :insert-xmm-reg))
+     #x0f2a #o300 #xf2)
+   (def-x86-opcode cvtsi2sdl ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f2a #o000 #xf2)
+   
+   ;; cvtsd2ss
+   (def-x86-opcode cvtsd2ss ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f5a #o300 #xf2)
+   (def-x86-opcode cvtsd2ss ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f5a #o000 #xf2)
+
+   ;; cvtsi2sd
+   (def-x86-opcode cvtsi2sdl ((:reg32 :insert-modrm-rm) (:regxmm :insert-xmm-reg))
+     #x0f2a #o300 #xf2)
+   (def-x86-opcode cvtsi2sdl ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f2a #o000 #xf2)
+
+   ;; cvtsi2ss
+   (def-x86-opcode cvtsi2ssl ((:reg32 :insert-modrm-rm) (:regxmm :insert-xmm-reg))
+     #x0f2a #o300 #xf3)
+   (def-x86-opcode cvtsi2ssl ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f2a #o000 #xf3)
+
+   ;;; cvtss2sd
+   (def-x86-opcode cvtss2sd ((:regxmm :insert-xmm-rm) (:regxmm :insert-xmm-reg))
+     #x0f5a #o300 #xf3)
+   (def-x86-opcode cvtss2sd ((:anymem :insert-memory) (:regxmm :insert-xmm-reg))
+     #x0f5a #o000 #xf3)
+   
+   ;; pand
+   (def-x86-opcode pand ((:regmmx :insert-mmx-rm) (:regmmx :insert-mmx-reg))
+     #x0fdb #o300)
+   (def-x86-opcode pand ((:anymem :insert-memory) (:regmmx :insert-mmx-reg))
+     #x0fdb #o000)
+   (def-x86-opcode pand ((:regxmm :insert-modrm-rm) (:regxmm :insert-modrm-reg))
+     #x0fef #o300 #x66)
+   (def-x86-opcode pand ((:anymem :insert-memory) (:regxmm :insert-modrm-reg))
+     #x0fdb #o000 #x66)
+   
+   ;; pandn
+   (def-x86-opcode pandn ((:regmmx :insert-mmx-rm) (:regmmx :insert-mmx-reg))
+     #x0fdf #o300)
+   (def-x86-opcode pandn ((:anymem :insert-memory) (:regmmx :insert-mmx-reg))
+     #x0fdf #o000)
+   (def-x86-opcode pandn ((:regxmm :insert-modrm-rm) (:regxmm :insert-modrm-reg))
+     #x0fdf #o300 #x66)
+   (def-x86-opcode pandn ((:anymem :insert-memory) (:regxmm :insert-modrm-reg))
+     #x0fdf #o000 #x66)
+
+   ;; por
+   (def-x86-opcode por ((:regmmx :insert-mmx-rm) (:regmmx :insert-mmx-reg))
+     #x0feb #o300)
+   (def-x86-opcode por ((:anymem :insert-memory) (:regmmx :insert-mmx-reg))
+     #x0feb #o000)
+   (def-x86-opcode por ((:regxmm :insert-modrm-rm) (:regxmm :insert-modrm-reg))
+     #x0feb #o300 #x66)
+   (def-x86-opcode por ((:anymem :insert-memory) (:regxmm :insert-modrm-reg))
+     #x0feb #o000 #x66)
+
+   ;; pxor
+   (def-x86-opcode pxor ((:regmmx :insert-mmx-rm) (:regmmx :insert-mmx-reg))
+     #x0fef #o300)
+   (def-x86-opcode pxor ((:anymem :insert-memory) (:regmmx :insert-mmx-reg))
+     #x0fef #o000)
+   (def-x86-opcode pxor ((:regxmm :insert-modrm-rm) (:regxmm :insert-modrm-reg))
+     #x0fef #o300 #x66)
+   (def-x86-opcode pxor ((:anymem :insert-memory) (:regxmm :insert-modrm-reg))
+     #x0fef #o000 #x66)
+
+   ;; psllq
+   (def-x86-opcode psllq ((:regmmx :insert-mmx-rm) (:regmmx :insert-mmx-reg))
+     #x0ff3 #o300)
+   (def-x86-opcode psllq ((:anymem :insert-memory) (:regmmx :insert-mmx-reg))
+     #x0ff3 #o000)
+   (def-x86-opcode psllq ((:regxmm :insert-modrm-rm) (:regxmm :insert-modrm-reg))
+     #x0ff3 #o300 #x66)
+   (def-x86-opcode psllq ((:anymem :insert-memory) (:regxmm :insert-modrm-reg))
+     #x0ff3 #o000 #x66)
+   (def-x86-opcode psllq ((:imm8 :insert-imm8) (:regxmm :insert-xmm-rm))
+     #x0f73 #o360 #x66)
+
+   ;; psllw
+   
+   ;; pslld
+
+   ;; pslldq
+   (def-x86-opcode pslldq ((:imm8 :insert-imm8) (:regxmm :insert-xmm-rm))
+     #x0f73 #o370 #x66)
+   
+   ;; psrlq 
+   (def-x86-opcode psrlq ((:regmmx :insert-mmx-rm) (:regmmx :insert-mmx-reg))
+     #x0fd3 #o300)
+   (def-x86-opcode psrlq ((:anymem :insert-memory) (:regmmx :insert-mmx-reg))
+     #x0fd3 #o000)
+   (def-x86-opcode psrlq ((:regxmm :insert-modrm-rm) (:regxmm :insert-modrm-reg))
+     #x0fd3 #o300 #x66)
+   (def-x86-opcode psrlq ((:anymem :insert-memory) (:regxmm :insert-modrm-reg))
+     #x0fd3 #o000 #x66)
+   (def-x86-opcode psrlq ((:imm8 :insert-imm8) (:regxmm :insert-xmm-rm))
+     #x0f73 #o320 #x66)
+
+   ;; psrld
+
+   ;; psrldq
+   (def-x86-opcode psrldq ((:imm8 :insert-imm8) (:regxmm :insert-xmm-rm))
+     #x0f73 #o330 #x66)
+   
+   ;; psrlw
+   
+   ;;; End of list of useful mmx instructions
+   (def-x86-opcode ldmxcsr ((:anymem :insert-memory))
+     #x0fae #o020)
+
+   (def-x86-opcode stmxcsr ((:anymem :insert-memory))
+     #x0fae #o030)
+
+   ))
+
+;;; wastes space
+(defparameter *x8632-opcode-templates*
+  (concatenate 'vector *x86-common-opcode-templates*
+               *x86-32-bit-only-opcode-templates*))
+
+(dotimes (i (length *x8632-opcode-templates*))
+  (setf (x86-opcode-template-ordinal (svref *x8632-opcode-templates* i)) i))
+
 
          
@@ -3434 +5567 @@
                     (name (x86-opcode-template-mnemonic template)))
                (push template (gethash name hash))))))
-    #+notyet
     (setup-templates-hash
      *x86-32-opcode-template-lists*
@@ -3455 +5587 @@
 
 (defparameter *x86-32-operand-insert-functions*
-  #(tbd))
+  #(insert-nothing
+    insert-modrm-reg
+    insert-modrm-rm
+    insert-memory
+    insert-opcode-reg
+    insert-opcode-reg4
+    insert-cc
+    insert-label
+    insert-imm8-for-int
+    insert-extra
+    insert-imm8
+    insert-imm8s
+    insert-imm16
+    insert-imm32s
+    insert-imm32
+    insert-mmx-reg
+    insert-mmx-rm
+    insert-xmm-reg
+    insert-xmm-rm
+    insert-reg4-pseudo-rm-high
+    insert-reg4-pseudo-rm-low
+    insert-self
+))
 
 (defparameter *x86-64-operand-insert-functions*
@@ -3479 +5633 @@
     insert-xmm-rm
     insert-reg4-pseudo-rm-high
-    insert-reg4-pseudo-rm-low))
+    insert-reg4-pseudo-rm-low
+    insert-self                         ;just for testing.  should go away.
+))
 
 (defvar *x86-operand-insert-functions* ())
@@ -4446 +6602 @@
   (setf (x86-instruction-extra instruction)
         (x86::x86-label-operand-label operand)))
+
+(defun insert-self (instruction operand)
+  (format t "~&insert-self: instruction = ~a operand = ~a"
+          instruction operand)
+  (setf (x86-immediate-operand-type operand)
+        (encode-operand-type :self))
+  (setf (x86-instruction-imm instruction) operand))
+
+(defparameter *x8632-register-entries*
+  (flet ((register-entry (name)
+           (let* ((r (gethash name *x86-registers*)))
+             (unless r (error "unknown register ~s" name))
+             r)))
+    (vector
+     ;; 32-bit registers
+     (register-entry "eax")
+     (register-entry "ecx")
+     (register-entry "edx")
+     (register-entry "ebx")
+     (register-entry "esp")
+     (register-entry "ebp")
+     (register-entry "esi")
+     (register-entry "edi")
+     ;; 16-bit-registers
+     (register-entry "ax")
+     (register-entry "cx")
+     (register-entry "dx")
+     (register-entry "bx")
+     (register-entry "sp")
+     (register-entry "bp")
+     (register-entry "si")
+     (register-entry "di")
+     ;; 8-bit registers
+     (register-entry "al")
+     (register-entry "cl")
+     (register-entry "dl")
+     (register-entry "bl")
+     (register-entry "spl")
+     (register-entry "bpl")
+     (register-entry "sil")
+     (register-entry "dil")
+       ;;; xmm registers
+     (register-entry "xmm0")
+     (register-entry "xmm1")
+     (register-entry "xmm2")
+     (register-entry "xmm3")
+     (register-entry "xmm4")
+     (register-entry "xmm5")
+     (register-entry "xmm6")
+     (register-entry "xmm7")
+     ;; MMX registers
+     (register-entry "mm0")
+     (register-entry "mm1")
+     (register-entry "mm2")
+     (register-entry "mm3")
+     (register-entry "mm4")
+     (register-entry "mm5")
+     (register-entry "mm6")
+     (register-entry "mm7")
+     ;; x87 FP regs.  May or may not be useful.
+     (register-entry "st[0]")
+     (register-entry "st[1]")
+     (register-entry "st[2]")
+     (register-entry "st[3]")
+     (register-entry "st[4]")
+     (register-entry "st[5]")
+     (register-entry "st[6]")
+     (register-entry "st[7]")
+     ;; Our friends, the segment registers
+     (register-entry "cs")
+     (register-entry "ds")
+     (register-entry "ss")
+     (register-entry "es")
+     (register-entry "fs")
+     (register-entry "gs")
+     )))
+
+(dotimes (i (length *x8632-register-entries*))
+  (let* ((entry (svref *x8632-register-entries* i)))
+    (when entry
+      (setf (reg-entry-ordinal32 entry) i))))
+
+(defconstant +x8632-32-bit-register+ #x0)
+(defconstant +x8632-16-bit-register+ #x8)
+(defconstant +x8632-8-bit-register+ #x10)
+(defconstant +x8632-xmm-register-offset+ #x18)
+(defconstant +x8632-mmx-register-offset+ #x20)
+(defconstant +x8632-fpu-register-offset+ #x28)
+(defconstant +x8632-segment-register-offset+ #x30)
 
 (defparameter *x8664-register-entries*
@@ -4571 +6816 @@
       (setf (reg-entry-ordinal64 entry) i))))
 
-
+;;; "x86" here really means "x8664"
 (defconstant +x86-64-bit-register+ #x00)
 (defconstant +x86-32-bit-register+ #x10)
@@ -4584 +6829 @@
   (if (and (typep i 'unsigned-byte)
            (< i 6))
-    (svref *x8664-register-entries* (+ +x86-segment-register-offset+ i))))
+      (ccl::target-arch-case
+       (:x8632
+        (svref *x8632-register-entries* (+ +x8632-segment-register-offset+ i)))
+       (:x8664
+        (svref *x8664-register-entries* (+ +x86-segment-register-offset+ i))))))
 
 (defun x86-xmm-register (i)
-  (if (typep i '(mod 16))
-    (svref *x8664-register-entries* (+ +x86-xmm-register-offset+ i))))
+  (ccl::target-arch-case
+   (:x8632
+    (if (typep i '(mod 8))
+        (svref *x8632-register-entries* (+ +x8632-xmm-register-offset+ i))))
+   (:x8664
+    (if (typep i '(mod 16))
+        (svref *x8664-register-entries* (+ +x86-xmm-register-offset+ i))))))
 
 (defun x86-mmx-register (i)
   (if (typep i '(mod 8))
-    (svref *x8664-register-entries* (+ +x86-mmx-register-offset+ i))))
+      (ccl::target-arch-case
+       (:x8632
+        (svref *x8632-register-entries* (+ +x8632-mmx-register-offset+ i)))
+       (:x8664
+        (svref *x8664-register-entries* (+ +x86-mmx-register-offset+ i))))))
     
 
 (defun gpr-ordinal (r)
-  (or
-   (etypecase r
-     ((mod 64) r)
-     ((or string symbol)
-      (let* ((entry (gethash r *x86-registers*)))
-        (if entry
-          (reg-entry-ordinal64 entry))))
-     (reg-entry (reg-entry-ordinal64 r))
-     (x86-register-operand
-      (reg-entry-ordinal64 (x86-register-operand-entry r))))
-   (error "Can't determine register ordinal of ~s" r)))
-
+  (ccl::target-arch-case
+   (:x8632
+    (or
+     (etypecase r
+       ((mod 32) r)                     ;???
+       ((or string symbol)
+        (let* ((entry (gethash r *x86-registers*)))
+          (if entry
+              (reg-entry-ordinal32 entry))))
+       (reg-entry (reg-entry-ordinal32 r))
+       (x86-register-operand
+        (reg-entry-ordinal32 (x86-register-operand-entry r))))
+     (error "Can't determine register ordinal of ~s" r)))
+   (:x8664
+    (or
+     (etypecase r
+       ((mod 64) r)
+       ((or string symbol)
+        (let* ((entry (gethash r *x86-registers*)))
+          (if entry
+              (reg-entry-ordinal64 entry))))
+       (reg-entry (reg-entry-ordinal64 r))
+       (x86-register-operand
+        (reg-entry-ordinal64 (x86-register-operand-entry r))))
+     (error "Can't determine register ordinal of ~s" r)))))
+   
 
 (defun x86-reg8 (r)
-  (svref *x8664-register-entries* (dpb (gpr-ordinal r)
-                                       (byte 4 0)
-                                       +x86-8-bit-register+)))
+  (ccl::target-arch-case
+   (:x8632
+    (svref *x8632-register-entries* (dpb (gpr-ordinal r)
+                                         (byte 3 0)
+                                         +x8632-8-bit-register+)))
+   (:x8664
+    (svref *x8664-register-entries* (dpb (gpr-ordinal r)
+                                         (byte 4 0)
+                                         +x86-8-bit-register+)))))
 
 (defun x86-reg16 (r)
-  (svref *x8664-register-entries* (dpb (gpr-ordinal r)
-                                        (byte 4 0)
-                                        +x86-16-bit-register+)))
+  (ccl::target-arch-case
+   (:x8632
+    (svref *x8632-register-entries* (dpb (gpr-ordinal r)
+                                         (byte 3 0)
+                                         +x8632-16-bit-register+)))
+   (:x8664
+    (svref *x8664-register-entries* (dpb (gpr-ordinal r)
+                                         (byte 4 0)
+                                         +x86-16-bit-register+)))))
 
 (defun x86-reg32 (r)
-  (svref *x8664-register-entries* (dpb (gpr-ordinal r)
-                                        (byte 4 0)
-                                        +x86-32-bit-register+)))       
+  (ccl::target-arch-case
+   (:x8632
+    (svref *x8632-register-entries* (dpb (gpr-ordinal r)
+                                         (byte 3 0)
+                                         +x8632-32-bit-register+)))
+   (:x8664
+    (svref *x8664-register-entries* (dpb (gpr-ordinal r)
+                                         (byte 4 0)
+                                         +x86-32-bit-register+)))))
 
 (defun x86-reg64 (r)
-  (svref *x8664-register-entries* (dpb (gpr-ordinal r)
-                                        (byte 4 0)
-                                        +x86-64-bit-register+)))
+  (ccl::target-arch-case
+   (:x8632
+    (error "x8632 doesn't have 64 bit register ~s" r))
+   (:x8664
+    (svref *x8664-register-entries* (dpb (gpr-ordinal r)
+                                         (byte 4 0)
+                                         +x86-64-bit-register+)))))